[cron] Bump distribution date (2023-04-16)

Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>

.editorconfig

@@ -14,6 +14,10 @@ end_of_line = lf
 indent_style = space
 indent_size = 2
 
-[{*.py,*.conf,*.sublime-project}]
+[{*.py}]
+indent_style = space
+indent_size = 4
+
+[{*.conf,*.sublime-project}]
 indent_style = tab
 indent_size = 4

.github/contributing.md

@@ -34,8 +34,11 @@ This project and everyone participating in it is governed by the [Marlin Code of
 
 We have a Message Board and a Facebook group where our knowledgable user community can provide helpful advice if you have questions.
 
-* [Marlin RepRap forum](https://reprap.org/forum/list.php?415)
-* [MarlinFirmware on Facebook](https://www.facebook.com/groups/1049718498464482/)
+- [Marlin Documentation](https://marlinfw.org) - Official Marlin documentation
+- Facebook Group ["Marlin Firmware"](https://www.facebook.com/groups/1049718498464482/)
+- RepRap.org [Marlin Forum](https://forums.reprap.org/list.php?415)
+- Facebook Group ["Marlin Firmware for 3D Printers"](https://www.facebook.com/groups/3Dtechtalk/)
+- [Marlin Configuration](https://www.youtube.com/results?search_query=marlin+configuration) on YouTube
 
 If chat is more your speed, you can join the MarlinFirmware Discord server:
 

.github/workflows/test-builds.yml

@@ -0,0 +1,147 @@
+#
+# test-builds.yml
+# Do test builds to catch compile errors
+#
+
+name: CI - bugfix-2.0.x
+
+on:
+  pull_request:
+    branches:
+    - bugfix-2.0.x
+    paths-ignore:
+    - config/**
+    - data/**
+    - docs/**
+    - '**/*.md'
+  push:
+    branches:
+    - bugfix-2.0.x
+    paths-ignore:
+    - config/**
+    - data/**
+    - docs/**
+    - '**/*.md'
+
+jobs:
+  test_builds:
+    name: Run All Tests
+    if: github.repository == 'MarlinFirmware/Marlin'
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        test-platform:
+        # Base Environments
+
+        - DUE
+        - DUE_archim
+        - esp32
+        - linux_native
+        - mega2560
+        - at90usb1286_dfu
+        - teensy31
+        - teensy35
+        - teensy41
+        - SAMD51_grandcentral_m4
+
+        # Extended AVR Environments
+
+        - FYSETC_F6
+        - mega1280
+        - rambo
+        - sanguino1284p
+        - sanguino644p
+
+        # STM32F1 (Maple) Environments
+
+        #- STM32F103RC_btt_maple
+        - STM32F103RC_btt_USB_maple
+        - STM32F103RC_fysetc_maple
+        - STM32F103RC_meeb_maple
+        - jgaurora_a5s_a1_maple
+        - STM32F103VE_longer_maple
+        #- mks_robin_maple
+        - mks_robin_lite_maple
+        - mks_robin_pro_maple
+        #- mks_robin_nano35_maple
+        #- STM32F103RE_creality_maple
+        - STM32F103VE_ZM3E4V2_USB_maple
+
+        # STM32 (ST) Environments
+
+        - STM32F103RC_btt
+        #- STM32F103RC_btt_USB
+        - STM32F103RE_btt
+        - STM32F103RE_btt_USB
+        - STM32F103RE_creality
+        - STM32F401RC_creality
+        - STM32F103VE_longer
+        - STM32F407VE_black
+        - STM32F401VE_STEVAL
+        - BIGTREE_BTT002
+        - BIGTREE_SKR_PRO
+        - BIGTREE_GTR_V1_0
+        - mks_robin
+        - ARMED
+        - FYSETC_S6
+        - STM32F070CB_malyan
+        - STM32F070RB_malyan
+        - malyan_M300
+        - FLYF407ZG
+        - rumba32
+        - LERDGEX
+        - LERDGEK
+        - mks_robin_nano35
+        - NUCLEO_F767ZI
+        - REMRAM_V1
+        - BTT_SKR_SE_BX
+        - chitu_f103
+        - Opulo_Lumen_REV3
+
+        # Put lengthy tests last
+
+        - LPC1768
+        - LPC1769
+
+        # Non-working environment tests
+        #- at90usb1286_cdc
+        #- STM32F103CB_malyan
+        #- STM32F103RE
+        #- mks_robin_mini
+
+    steps:
+
+    - name: Check out the PR
+      uses: actions/checkout@v3
+
+    - name: Cache pip
+      uses: actions/cache@v3
+      with:
+        path: ~/.cache/pip
+        key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
+        restore-keys: |
+          ${{ runner.os }}-pip-
+
+    - name: Cache PlatformIO
+      uses: actions/cache@v3
+      with:
+        path: ~/.platformio
+        key: ${{ runner.os }}-${{ hashFiles('**/lockfiles') }}
+
+    - name: Select Python 3.7
+      uses: actions/setup-python@v3
+      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 platformio
+        pio upgrade --dev
+        pio pkg update --global
+
+    - name: Run ${{ matrix.test-platform }} Tests
+      run: |
+        make tests-single-ci TEST_TARGET=${{ matrix.test-platform }}

.gitignore

@@ -1,6 +1,6 @@
 #
 # Marlin 3D Printer Firmware
-# Copyright (c) 2023 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+# Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 #
 # Based on Sprinter and grbl.
 # Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -21,21 +21,35 @@
 
 # Generated files
 _Version.h
-bdf2u8g.exe
-genpages.exe
+bdf2u8g
 marlin_config.json
 mczip.h
-language*.csv
-out-csv/
-out-language/
 *.gen
 *.sublime-workspace
 
+#
 # OS
+#
 applet/
 .DS_Store
 
-# Compiled C++ Object files
+#
+# Misc
+#
+*~
+*.orig
+*.rej
+*.bak
+*.idea
+*.i
+*.ii
+*.swp
+tags
+
+#
+# C++
+#
+# Compiled Object files
 *.slo
 *.lo
 *.o
@@ -66,7 +80,10 @@ applet/
 *.out
 *.app
 
-# Compiled C Object files
+#
+# C
+#
+# Object files
 *.o
 *.ko
 *.obj
@@ -126,16 +143,13 @@ vc-fileutils.settings
 .vscode/*
 !.vscode/extensions.json
 
-# Simulation files
+#Simulation
 imgui.ini
 eeprom.dat
 spi_flash.bin
-fs.img
 
-# CMake
-buildroot/share/cmake/*
+#cmake
 CMakeLists.txt
-!buildroot/share/cmake/CMakeLists.txt
 src/CMakeLists.txt
 CMakeListsPrivate.txt
 build/
@@ -155,16 +169,3 @@ __pycache__
 
 # IOLogger logs
 *_log.csv
-
-# Misc.
-*~
-*.orig
-*.rej
-*.bak
-*.idea
-*.i
-*.ii
-*.swp
-tags
-*.logs
-*.bak

Marlin/Configuration.h

@@ -35,7 +35,7 @@
  *
  * Advanced settings can be found in Configuration_adv.h
  */
-#define CONFIGURATION_H_VERSION 02010000
+#define CONFIGURATION_H_VERSION 02000905
 
 //===========================================================================
 //============================= Getting Started =============================
@@ -57,15 +57,6 @@
  *                      https://www.thingiverse.com/thing:1278865
  */
 
-//===========================================================================
-//========================== DELTA / SCARA / TPARA ==========================
-//===========================================================================
-//
-// Download configurations from the link above and customize for your machine.
-// Examples are located in config/examples/delta, .../SCARA, and .../TPARA.
-//
-//===========================================================================
-
 // @section info
 
 // Author info of this build printed to the host during boot and M115
@@ -176,9 +167,6 @@
 //#define I_DRIVER_TYPE  A4988
 //#define J_DRIVER_TYPE  A4988
 //#define K_DRIVER_TYPE  A4988
-//#define U_DRIVER_TYPE  A4988
-//#define V_DRIVER_TYPE  A4988
-//#define W_DRIVER_TYPE  A4988
 #define E0_DRIVER_TYPE A4988
 //#define E1_DRIVER_TYPE A4988
 //#define E2_DRIVER_TYPE A4988
@@ -191,9 +179,6 @@
 /**
  * Additional Axis Settings
  *
- * Define AXISn_ROTATES for all axes that rotate or pivot.
- * Rotational axis coordinates are expressed in degrees.
- *
  * AXISn_NAME defines the letter used to refer to the axis in (most) G-code commands.
  * By convention the names and roles are typically:
  *   'A' : Rotational axis parallel to X
@@ -203,31 +188,16 @@
  *   'V' : Secondary linear axis parallel to Y
  *   'W' : Secondary linear axis parallel to Z
  *
- * Regardless of these settings the axes are internally named I, J, K, U, V, W.
+ * Regardless of these settings the axes are internally named I, J, K.
  */
 #ifdef I_DRIVER_TYPE
   #define AXIS4_NAME 'A' // :['A', 'B', 'C', 'U', 'V', 'W']
-  #define AXIS4_ROTATES
 #endif
 #ifdef J_DRIVER_TYPE
   #define AXIS5_NAME 'B' // :['B', 'C', 'U', 'V', 'W']
-  #define AXIS5_ROTATES
 #endif
 #ifdef K_DRIVER_TYPE
   #define AXIS6_NAME 'C' // :['C', 'U', 'V', 'W']
-  #define AXIS6_ROTATES
-#endif
-#ifdef U_DRIVER_TYPE
-  #define AXIS7_NAME 'U' // :['U', 'V', 'W']
-  //#define AXIS7_ROTATES
-#endif
-#ifdef V_DRIVER_TYPE
-  #define AXIS8_NAME 'V' // :['V', 'W']
-  //#define AXIS8_ROTATES
-#endif
-#ifdef W_DRIVER_TYPE
-  #define AXIS9_NAME 'W' // :['W']
-  //#define AXIS9_ROTATES
 #endif
 
 // @section extruder
@@ -663,7 +633,7 @@
  *
  * Use a physical model of the hotend to control temperature. When configured correctly
  * this gives better responsiveness and stability than PID and it also removes the need
- * for PID_EXTRUSION_SCALING and PID_FAN_SCALING. Use M306 to autotune the model.
+ * for PID_EXTRUSION_SCALING and PID_FAN_SCALING. Use M306 T to autotune the model.
  */
 #if ENABLED(MPCTEMP)
   //#define MPC_EDIT_MENU                             // Add MPC editing to the "Advanced Settings" menu. (~1300 bytes of flash)
@@ -865,6 +835,134 @@
   #define POLAR_SEGMENTS_PER_SECOND 5
 #endif
 
+// Enable for DELTA kinematics and configure below
+//#define DELTA
+#if ENABLED(DELTA)
+
+  // Make delta curves from many straight lines (linear interpolation).
+  // This is a trade-off between visible corners (not enough segments)
+  // and processor overload (too many expensive sqrt calls).
+  #define DELTA_SEGMENTS_PER_SECOND 200
+
+  // After homing move down to a height where XY movement is unconstrained
+  //#define DELTA_HOME_TO_SAFE_ZONE
+
+  // Delta calibration menu
+  // uncomment to add three points calibration menu option.
+  // See http://minow.blogspot.com/index.html#4918805519571907051
+  //#define DELTA_CALIBRATION_MENU
+
+  // uncomment to add G33 Delta Auto-Calibration (Enable EEPROM_SETTINGS to store results)
+  //#define DELTA_AUTO_CALIBRATION
+
+  // NOTE NB all values for DELTA_* values MUST be floating point, so always have a decimal point in them
+
+  #if ENABLED(DELTA_AUTO_CALIBRATION)
+    // set the default number of probe points : n*n (1 -> 7)
+    #define DELTA_CALIBRATION_DEFAULT_POINTS 4
+  #endif
+
+  #if EITHER(DELTA_AUTO_CALIBRATION, DELTA_CALIBRATION_MENU)
+    // Set the steprate for papertest probing
+    #define PROBE_MANUALLY_STEP 0.05      // (mm)
+  #endif
+
+  // Print surface diameter/2 minus unreachable space (avoid collisions with vertical towers).
+  #define DELTA_PRINTABLE_RADIUS 140.0    // (mm)
+
+  // Maximum reachable area
+  #define DELTA_MAX_RADIUS       140.0    // (mm)
+
+  // Center-to-center distance of the holes in the diagonal push rods.
+  #define DELTA_DIAGONAL_ROD 250.0        // (mm)
+
+  // Distance between bed and nozzle Z home position
+  #define DELTA_HEIGHT 250.00             // (mm) Get this value from G33 auto calibrate
+
+  #define DELTA_ENDSTOP_ADJ { 0.0, 0.0, 0.0 } // Get these values from G33 auto calibrate
+
+  // Horizontal distance bridged by diagonal push rods when effector is centered.
+  #define DELTA_RADIUS 124.0              // (mm) Get this value from G33 auto calibrate
+
+  // Trim adjustments for individual towers
+  // tower angle corrections for X and Y tower / rotate XYZ so Z tower angle = 0
+  // measured in degrees anticlockwise looking from above the printer
+  #define DELTA_TOWER_ANGLE_TRIM { 0.0, 0.0, 0.0 } // Get these values from G33 auto calibrate
+
+  // Delta radius and diagonal rod adjustments (mm)
+  //#define DELTA_RADIUS_TRIM_TOWER { 0.0, 0.0, 0.0 }
+  //#define DELTA_DIAGONAL_ROD_TRIM_TOWER { 0.0, 0.0, 0.0 }
+#endif
+
+/**
+ * MORGAN_SCARA was developed by QHARLEY in South Africa in 2012-2013.
+ * Implemented and slightly reworked by JCERNY in June, 2014.
+ *
+ * Mostly Printed SCARA is an open source design by Tyler Williams. See:
+ *   https://www.thingiverse.com/thing:2487048
+ *   https://www.thingiverse.com/thing:1241491
+ */
+//#define MORGAN_SCARA
+//#define MP_SCARA
+#if EITHER(MORGAN_SCARA, MP_SCARA)
+  // If movement is choppy try lowering this value
+  #define SCARA_SEGMENTS_PER_SECOND 200
+
+  // Length of inner and outer support arms. Measure arm lengths precisely.
+  #define SCARA_LINKAGE_1 150       // (mm)
+  #define SCARA_LINKAGE_2 150       // (mm)
+
+  // SCARA tower offset (position of Tower relative to bed zero position)
+  // This needs to be reasonably accurate as it defines the printbed position in the SCARA space.
+  #define SCARA_OFFSET_X  100       // (mm)
+  #define SCARA_OFFSET_Y  -56       // (mm)
+
+  #if ENABLED(MORGAN_SCARA)
+
+    //#define DEBUG_SCARA_KINEMATICS
+    #define SCARA_FEEDRATE_SCALING  // Convert XY feedrate from mm/s to degrees/s on the fly
+
+    // Radius around the center where the arm cannot reach
+    #define MIDDLE_DEAD_ZONE_R   0  // (mm)
+
+    #define THETA_HOMING_OFFSET  0  // Calculated from Calibration Guide and M360 / M114. See http://reprap.harleystudio.co.za/?page_id=1073
+    #define PSI_HOMING_OFFSET    0  // Calculated from Calibration Guide and M364 / M114. See http://reprap.harleystudio.co.za/?page_id=1073
+
+  #elif ENABLED(MP_SCARA)
+
+    #define SCARA_OFFSET_THETA1  12 // degrees
+    #define SCARA_OFFSET_THETA2 131 // degrees
+
+  #endif
+
+#endif
+
+// Enable for TPARA kinematics and configure below
+//#define AXEL_TPARA
+#if ENABLED(AXEL_TPARA)
+  #define DEBUG_ROBOT_KINEMATICS
+  #define ROBOT_SEGMENTS_PER_SECOND 200
+
+  // Length of inner and outer support arms. Measure arm lengths precisely.
+  #define ROBOT_LINKAGE_1 120       // (mm)
+  #define ROBOT_LINKAGE_2 120       // (mm)
+
+  // SCARA tower offset (position of Tower relative to bed zero position)
+  // This needs to be reasonably accurate as it defines the printbed position in the SCARA space.
+  #define ROBOT_OFFSET_X    0       // (mm)
+  #define ROBOT_OFFSET_Y    0       // (mm)
+  #define ROBOT_OFFSET_Z    0       // (mm)
+
+  #define SCARA_FEEDRATE_SCALING  // Convert XY feedrate from mm/s to degrees/s on the fly
+
+  // Radius around the center where the arm cannot reach
+  #define MIDDLE_DEAD_ZONE_R   0  // (mm)
+
+  // Calculated from Calibration Guide and M360 / M114. See http://reprap.harleystudio.co.za/?page_id=1073
+  #define THETA_HOMING_OFFSET  0
+  #define PSI_HOMING_OFFSET    0
+#endif
+
 //===========================================================================
 //============================== Endstop Settings ===========================
 //===========================================================================
@@ -880,18 +978,12 @@
 //#define USE_IMIN_PLUG
 //#define USE_JMIN_PLUG
 //#define USE_KMIN_PLUG
-//#define USE_UMIN_PLUG
-//#define USE_VMIN_PLUG
-//#define USE_WMIN_PLUG
 //#define USE_XMAX_PLUG
 //#define USE_YMAX_PLUG
 //#define USE_ZMAX_PLUG
 //#define USE_IMAX_PLUG
 //#define USE_JMAX_PLUG
 //#define USE_KMAX_PLUG
-//#define USE_UMAX_PLUG
-//#define USE_VMAX_PLUG
-//#define USE_WMAX_PLUG
 
 // Enable pullup for all endstops to prevent a floating state
 #define ENDSTOPPULLUPS
@@ -903,18 +995,12 @@
   //#define ENDSTOPPULLUP_IMIN
   //#define ENDSTOPPULLUP_JMIN
   //#define ENDSTOPPULLUP_KMIN
-  //#define ENDSTOPPULLUP_UMIN
-  //#define ENDSTOPPULLUP_VMIN
-  //#define ENDSTOPPULLUP_WMIN
   //#define ENDSTOPPULLUP_XMAX
   //#define ENDSTOPPULLUP_YMAX
   //#define ENDSTOPPULLUP_ZMAX
   //#define ENDSTOPPULLUP_IMAX
   //#define ENDSTOPPULLUP_JMAX
   //#define ENDSTOPPULLUP_KMAX
-  //#define ENDSTOPPULLUP_UMAX
-  //#define ENDSTOPPULLUP_VMAX
-  //#define ENDSTOPPULLUP_WMAX
   //#define ENDSTOPPULLUP_ZMIN_PROBE
 #endif
 
@@ -928,18 +1014,12 @@
   //#define ENDSTOPPULLDOWN_IMIN
   //#define ENDSTOPPULLDOWN_JMIN
   //#define ENDSTOPPULLDOWN_KMIN
-  //#define ENDSTOPPULLDOWN_UMIN
-  //#define ENDSTOPPULLDOWN_VMIN
-  //#define ENDSTOPPULLDOWN_WMIN
   //#define ENDSTOPPULLDOWN_XMAX
   //#define ENDSTOPPULLDOWN_YMAX
   //#define ENDSTOPPULLDOWN_ZMAX
   //#define ENDSTOPPULLDOWN_IMAX
   //#define ENDSTOPPULLDOWN_JMAX
   //#define ENDSTOPPULLDOWN_KMAX
-  //#define ENDSTOPPULLDOWN_UMAX
-  //#define ENDSTOPPULLDOWN_VMAX
-  //#define ENDSTOPPULLDOWN_WMAX
   //#define ENDSTOPPULLDOWN_ZMIN_PROBE
 #endif
 
@@ -950,18 +1030,12 @@
 #define I_MIN_ENDSTOP_INVERTING false // Set to true to invert the logic of the endstop.
 #define J_MIN_ENDSTOP_INVERTING false // Set to true to invert the logic of the endstop.
 #define K_MIN_ENDSTOP_INVERTING false // Set to true to invert the logic of the endstop.
-#define U_MIN_ENDSTOP_INVERTING false // Set to true to invert the logic of the endstop.
-#define V_MIN_ENDSTOP_INVERTING false // Set to true to invert the logic of the endstop.
-#define W_MIN_ENDSTOP_INVERTING false // Set to true to invert the logic of the endstop.
 #define X_MAX_ENDSTOP_INVERTING false // Set to true to invert the logic of the endstop.
 #define Y_MAX_ENDSTOP_INVERTING false // Set to true to invert the logic of the endstop.
 #define Z_MAX_ENDSTOP_INVERTING false // Set to true to invert the logic of the endstop.
 #define I_MAX_ENDSTOP_INVERTING false // Set to true to invert the logic of the endstop.
 #define J_MAX_ENDSTOP_INVERTING false // Set to true to invert the logic of the endstop.
 #define K_MAX_ENDSTOP_INVERTING false // Set to true to invert the logic of the endstop.
-#define U_MAX_ENDSTOP_INVERTING false // Set to true to invert the logic of the endstop.
-#define V_MAX_ENDSTOP_INVERTING false // Set to true to invert the logic of the endstop.
-#define W_MAX_ENDSTOP_INVERTING false // Set to true to invert the logic of the endstop.
 #define Z_MIN_PROBE_ENDSTOP_INVERTING false // Set to true to invert the logic of the probe.
 
 // Enable this feature if all enabled endstop pins are interrupt-capable.
@@ -1006,16 +1080,16 @@
 //#define DISTINCT_E_FACTORS
 
 /**
- * Default Axis Steps Per Unit (linear=steps/mm, rotational=steps/°)
+ * Default Axis Steps Per Unit (steps/mm)
  * Override with M92
- *                                      X, Y, Z [, I [, J [, K...]]], E0 [, E1[, E2...]]
+ *                                      X, Y, Z [, I [, J [, K]]], E0 [, E1[, E2...]]
  */
 #define DEFAULT_AXIS_STEPS_PER_UNIT   { 80, 80, 400, 500 }
 
 /**
- * Default Max Feed Rate (linear=mm/s, rotational=°/s)
+ * Default Max Feed Rate (mm/s)
  * Override with M203
- *                                      X, Y, Z [, I [, J [, K...]]], E0 [, E1[, E2...]]
+ *                                      X, Y, Z [, I [, J [, K]]], E0 [, E1[, E2...]]
  */
 #define DEFAULT_MAX_FEEDRATE          { 300, 300, 5, 25 }
 
@@ -1025,10 +1099,10 @@
 #endif
 
 /**
- * Default Max Acceleration (speed change with time) (linear=mm/(s^2), rotational=°/(s^2))
+ * Default Max Acceleration (change/s) change = mm/s
  * (Maximum start speed for accelerated moves)
  * Override with M201
- *                                      X, Y, Z [, I [, J [, K...]]], E0 [, E1[, E2...]]
+ *                                      X, Y, Z [, I [, J [, K]]], E0 [, E1[, E2...]]
  */
 #define DEFAULT_MAX_ACCELERATION      { 3000, 3000, 100, 10000 }
 
@@ -1038,20 +1112,20 @@
 #endif
 
 /**
- * Default Acceleration (speed change with time) (linear=mm/(s^2), rotational=°/(s^2))
+ * Default Acceleration (change/s) change = mm/s
  * Override with M204
  *
  *   M204 P    Acceleration
  *   M204 R    Retract Acceleration
  *   M204 T    Travel Acceleration
  */
-#define DEFAULT_ACCELERATION          3000    // X, Y, Z and E acceleration for printing moves
+#define DEFAULT_ACCELERATION          3000    // X, Y, Z ... and E acceleration for printing moves
 #define DEFAULT_RETRACT_ACCELERATION  3000    // E acceleration for retracts
-#define DEFAULT_TRAVEL_ACCELERATION   3000    // X, Y, Z acceleration for travel (non printing) moves
+#define DEFAULT_TRAVEL_ACCELERATION   3000    // X, Y, Z ... acceleration for travel (non printing) moves
 
 /**
  * Default Jerk limits (mm/s)
- * Override with M205 X Y Z . . . E
+ * Override with M205 X Y Z E
  *
  * "Jerk" specifies the minimum speed change that requires acceleration.
  * When changing speed and direction, if the difference is less than the
@@ -1065,9 +1139,6 @@
   //#define DEFAULT_IJERK  0.3
   //#define DEFAULT_JJERK  0.3
   //#define DEFAULT_KJERK  0.3
-  //#define DEFAULT_UJERK  0.3
-  //#define DEFAULT_VJERK  0.3
-  //#define DEFAULT_WJERK  0.3
 
   //#define TRAVEL_EXTRA_XYJERK 0.0     // Additional jerk allowance for all travel moves
 
@@ -1232,9 +1303,37 @@
  */
 //#define SENSORLESS_PROBING
 
-//
-// For Z_PROBE_ALLEN_KEY see the Delta example configurations.
-//
+/**
+ * Allen key retractable z-probe as seen on many Kossel delta printers - https://reprap.org/wiki/Kossel#Automatic_bed_leveling_probe
+ * Deploys by touching z-axis belt. Retracts by pushing the probe down.
+ */
+//#define Z_PROBE_ALLEN_KEY
+#if ENABLED(Z_PROBE_ALLEN_KEY)
+  // 2 or 3 sets of coordinates for deploying and retracting the spring loaded touch probe on G29,
+  // if servo actuated touch probe is not defined. Uncomment as appropriate for your printer/probe.
+
+  #define Z_PROBE_ALLEN_KEY_DEPLOY_1 { 30.0, DELTA_PRINTABLE_RADIUS, 100.0 }
+  #define Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE XY_PROBE_FEEDRATE
+
+  #define Z_PROBE_ALLEN_KEY_DEPLOY_2 { 0.0, DELTA_PRINTABLE_RADIUS, 100.0 }
+  #define Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE (XY_PROBE_FEEDRATE)/10
+
+  #define Z_PROBE_ALLEN_KEY_DEPLOY_3 { 0.0, (DELTA_PRINTABLE_RADIUS) * 0.75, 100.0 }
+  #define Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE XY_PROBE_FEEDRATE
+
+  #define Z_PROBE_ALLEN_KEY_STOW_1 { -64.0, 56.0, 23.0 } // Move the probe into position
+  #define Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE XY_PROBE_FEEDRATE
+
+  #define Z_PROBE_ALLEN_KEY_STOW_2 { -64.0, 56.0, 3.0 } // Push it down
+  #define Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE (XY_PROBE_FEEDRATE)/10
+
+  #define Z_PROBE_ALLEN_KEY_STOW_3 { -64.0, 56.0, 50.0 } // Move it up to clear
+  #define Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE XY_PROBE_FEEDRATE
+
+  #define Z_PROBE_ALLEN_KEY_STOW_4 { 0.0, 0.0, 50.0 }
+  #define Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE XY_PROBE_FEEDRATE
+
+#endif // Z_PROBE_ALLEN_KEY
 
 /**
  * Nozzle-to-Probe offsets { X, Y, Z }
@@ -1406,9 +1505,6 @@
 //#define I_ENABLE_ON 0
 //#define J_ENABLE_ON 0
 //#define K_ENABLE_ON 0
-//#define U_ENABLE_ON 0
-//#define V_ENABLE_ON 0
-//#define W_ENABLE_ON 0
 
 // Disable axis steppers immediately when they're not being stepped.
 // WARNING: When motors turn off there is a chance of losing position accuracy!
@@ -1418,9 +1514,6 @@
 //#define DISABLE_I false
 //#define DISABLE_J false
 //#define DISABLE_K false
-//#define DISABLE_U false
-//#define DISABLE_V false
-//#define DISABLE_W false
 
 // Turn off the display blinking that warns about possible accuracy reduction
 //#define DISABLE_REDUCED_ACCURACY_WARNING
@@ -1439,9 +1532,6 @@
 //#define INVERT_I_DIR false
 //#define INVERT_J_DIR false
 //#define INVERT_K_DIR false
-//#define INVERT_U_DIR false
-//#define INVERT_V_DIR false
-//#define INVERT_W_DIR false
 
 // @section extruder
 
@@ -1480,9 +1570,6 @@
 //#define I_HOME_DIR -1
 //#define J_HOME_DIR -1
 //#define K_HOME_DIR -1
-//#define U_HOME_DIR -1
-//#define V_HOME_DIR -1
-//#define W_HOME_DIR -1
 
 // @section machine
 
@@ -1490,7 +1577,7 @@
 #define X_BED_SIZE 200
 #define Y_BED_SIZE 200
 
-// Travel limits (linear=mm, rotational=°) after homing, corresponding to endstop positions.
+// Travel limits (mm) after homing, corresponding to endstop positions.
 #define X_MIN_POS 0
 #define Y_MIN_POS 0
 #define Z_MIN_POS 0
@@ -1503,12 +1590,6 @@
 //#define J_MAX_POS 50
 //#define K_MIN_POS 0
 //#define K_MAX_POS 50
-//#define U_MIN_POS 0
-//#define U_MAX_POS 50
-//#define V_MIN_POS 0
-//#define V_MAX_POS 50
-//#define W_MIN_POS 0
-//#define W_MAX_POS 50
 
 /**
  * Software Endstops
@@ -1528,9 +1609,6 @@
   #define MIN_SOFTWARE_ENDSTOP_I
   #define MIN_SOFTWARE_ENDSTOP_J
   #define MIN_SOFTWARE_ENDSTOP_K
-  #define MIN_SOFTWARE_ENDSTOP_U
-  #define MIN_SOFTWARE_ENDSTOP_V
-  #define MIN_SOFTWARE_ENDSTOP_W
 #endif
 
 // Max software endstops constrain movement within maximum coordinate bounds
@@ -1542,9 +1620,6 @@
   #define MAX_SOFTWARE_ENDSTOP_I
   #define MAX_SOFTWARE_ENDSTOP_J
   #define MAX_SOFTWARE_ENDSTOP_K
-  #define MAX_SOFTWARE_ENDSTOP_U
-  #define MAX_SOFTWARE_ENDSTOP_V
-  #define MAX_SOFTWARE_ENDSTOP_W
 #endif
 
 #if EITHER(MIN_SOFTWARE_ENDSTOPS, MAX_SOFTWARE_ENDSTOPS)
@@ -1809,7 +1884,7 @@
 //#define LCD_BED_TRAMMING
 
 #if ENABLED(LCD_BED_TRAMMING)
-  #define BED_TRAMMING_INSET_LFRB { 30, 30, 30, 30 }  // (mm) Left, Front, Right, Back insets
+  #define BED_TRAMMING_INSET_LFRB { 30, 30, 30, 30 } // (mm) Left, Front, Right, Back insets
   #define BED_TRAMMING_HEIGHT      0.0        // (mm) Z height of nozzle at leveling points
   #define BED_TRAMMING_Z_HOP       4.0        // (mm) Z height of nozzle between leveling points
   //#define BED_TRAMMING_INCLUDE_CENTER       // Move to the center after the last corner
@@ -1859,9 +1934,6 @@
 //#define MANUAL_I_HOME_POS 0
 //#define MANUAL_J_HOME_POS 0
 //#define MANUAL_K_HOME_POS 0
-//#define MANUAL_U_HOME_POS 0
-//#define MANUAL_V_HOME_POS 0
-//#define MANUAL_W_HOME_POS 0
 
 /**
  * Use "Z Safe Homing" to avoid homing with a Z probe outside the bed area.
@@ -1877,7 +1949,7 @@
   #define Z_SAFE_HOMING_Y_POINT Y_CENTER  // Y point for Z homing
 #endif
 
-// Homing speeds (linear=mm/min, rotational=°/min)
+// Homing speeds (mm/min)
 #define HOMING_FEEDRATE_MM_M { (50*60), (50*60), (4*60) }
 
 // Validate that endstops are triggered on homing moves

Marlin/Configuration_adv.h

@@ -30,7 +30,7 @@
  *
  * Basic settings can be found in Configuration.h
  */
-#define CONFIGURATION_ADV_H_VERSION 02010000
+#define CONFIGURATION_ADV_H_VERSION 02000905
 
 //===========================================================================
 //============================= Thermal Settings ============================
@@ -54,87 +54,87 @@
 // Custom Thermistor 1000 parameters
 //
 #if TEMP_SENSOR_0 == 1000
-  #define HOTEND0_PULLUP_RESISTOR_OHMS 4700    // Pullup resistor
-  #define HOTEND0_RESISTANCE_25C_OHMS  100000  // Resistance at 25C
-  #define HOTEND0_BETA                 3950    // Beta value
+  #define HOTEND0_PULLUP_RESISTOR_OHMS    4700 // Pullup resistor
+  #define HOTEND0_RESISTANCE_25C_OHMS   100000 // Resistance at 25C
+  #define HOTEND0_BETA                    3950 // Beta value
 #endif
 
 #if TEMP_SENSOR_1 == 1000
-  #define HOTEND1_PULLUP_RESISTOR_OHMS 4700    // Pullup resistor
-  #define HOTEND1_RESISTANCE_25C_OHMS  100000  // Resistance at 25C
-  #define HOTEND1_BETA                 3950    // Beta value
+  #define HOTEND1_PULLUP_RESISTOR_OHMS    4700 // Pullup resistor
+  #define HOTEND1_RESISTANCE_25C_OHMS   100000 // Resistance at 25C
+  #define HOTEND1_BETA                    3950 // Beta value
 #endif
 
 #if TEMP_SENSOR_2 == 1000
-  #define HOTEND2_PULLUP_RESISTOR_OHMS 4700    // Pullup resistor
-  #define HOTEND2_RESISTANCE_25C_OHMS  100000  // Resistance at 25C
-  #define HOTEND2_BETA                 3950    // Beta value
+  #define HOTEND2_PULLUP_RESISTOR_OHMS    4700 // Pullup resistor
+  #define HOTEND2_RESISTANCE_25C_OHMS   100000 // Resistance at 25C
+  #define HOTEND2_BETA                    3950 // Beta value
 #endif
 
 #if TEMP_SENSOR_3 == 1000
-  #define HOTEND3_PULLUP_RESISTOR_OHMS 4700    // Pullup resistor
-  #define HOTEND3_RESISTANCE_25C_OHMS  100000  // Resistance at 25C
-  #define HOTEND3_BETA                 3950    // Beta value
+  #define HOTEND3_PULLUP_RESISTOR_OHMS    4700 // Pullup resistor
+  #define HOTEND3_RESISTANCE_25C_OHMS   100000 // Resistance at 25C
+  #define HOTEND3_BETA                    3950 // Beta value
 #endif
 
 #if TEMP_SENSOR_4 == 1000
-  #define HOTEND4_PULLUP_RESISTOR_OHMS 4700    // Pullup resistor
-  #define HOTEND4_RESISTANCE_25C_OHMS  100000  // Resistance at 25C
-  #define HOTEND4_BETA                 3950    // Beta value
+  #define HOTEND4_PULLUP_RESISTOR_OHMS    4700 // Pullup resistor
+  #define HOTEND4_RESISTANCE_25C_OHMS   100000 // Resistance at 25C
+  #define HOTEND4_BETA                    3950 // Beta value
 #endif
 
 #if TEMP_SENSOR_5 == 1000
-  #define HOTEND5_PULLUP_RESISTOR_OHMS 4700    // Pullup resistor
-  #define HOTEND5_RESISTANCE_25C_OHMS  100000  // Resistance at 25C
-  #define HOTEND5_BETA                 3950    // Beta value
+  #define HOTEND5_PULLUP_RESISTOR_OHMS    4700 // Pullup resistor
+  #define HOTEND5_RESISTANCE_25C_OHMS   100000 // Resistance at 25C
+  #define HOTEND5_BETA                    3950 // Beta value
 #endif
 
 #if TEMP_SENSOR_6 == 1000
-  #define HOTEND6_PULLUP_RESISTOR_OHMS 4700    // Pullup resistor
-  #define HOTEND6_RESISTANCE_25C_OHMS  100000  // Resistance at 25C
-  #define HOTEND6_BETA                 3950    // Beta value
+  #define HOTEND6_PULLUP_RESISTOR_OHMS    4700 // Pullup resistor
+  #define HOTEND6_RESISTANCE_25C_OHMS   100000 // Resistance at 25C
+  #define HOTEND6_BETA                    3950 // Beta value
 #endif
 
 #if TEMP_SENSOR_7 == 1000
-  #define HOTEND7_PULLUP_RESISTOR_OHMS 4700    // Pullup resistor
-  #define HOTEND7_RESISTANCE_25C_OHMS  100000  // Resistance at 25C
-  #define HOTEND7_BETA                 3950    // Beta value
+  #define HOTEND7_PULLUP_RESISTOR_OHMS    4700 // Pullup resistor
+  #define HOTEND7_RESISTANCE_25C_OHMS   100000 // Resistance at 25C
+  #define HOTEND7_BETA                    3950 // Beta value
 #endif
 
 #if TEMP_SENSOR_BED == 1000
-  #define BED_PULLUP_RESISTOR_OHMS     4700    // Pullup resistor
-  #define BED_RESISTANCE_25C_OHMS      100000  // Resistance at 25C
-  #define BED_BETA                     3950    // Beta value
+  #define BED_PULLUP_RESISTOR_OHMS        4700 // Pullup resistor
+  #define BED_RESISTANCE_25C_OHMS       100000 // Resistance at 25C
+  #define BED_BETA                        3950 // Beta value
 #endif
 
 #if TEMP_SENSOR_CHAMBER == 1000
-  #define CHAMBER_PULLUP_RESISTOR_OHMS 4700    // Pullup resistor
-  #define CHAMBER_RESISTANCE_25C_OHMS  100000  // Resistance at 25C
-  #define CHAMBER_BETA                 3950    // Beta value
+  #define CHAMBER_PULLUP_RESISTOR_OHMS    4700 // Pullup resistor
+  #define CHAMBER_RESISTANCE_25C_OHMS   100000 // Resistance at 25C
+  #define CHAMBER_BETA                    3950 // Beta value
 #endif
 
 #if TEMP_SENSOR_COOLER == 1000
-  #define COOLER_PULLUP_RESISTOR_OHMS 4700    // Pullup resistor
-  #define COOLER_RESISTANCE_25C_OHMS  100000  // Resistance at 25C
-  #define COOLER_BETA                 3950    // Beta value
+  #define COOLER_PULLUP_RESISTOR_OHMS     4700 // Pullup resistor
+  #define COOLER_RESISTANCE_25C_OHMS    100000 // Resistance at 25C
+  #define COOLER_BETA                     3950 // Beta value
 #endif
 
 #if TEMP_SENSOR_PROBE == 1000
-  #define PROBE_PULLUP_RESISTOR_OHMS   4700    // Pullup resistor
-  #define PROBE_RESISTANCE_25C_OHMS    100000  // Resistance at 25C
-  #define PROBE_BETA                   3950    // Beta value
+  #define PROBE_PULLUP_RESISTOR_OHMS      4700 // Pullup resistor
+  #define PROBE_RESISTANCE_25C_OHMS     100000 // Resistance at 25C
+  #define PROBE_BETA                      3950 // Beta value
 #endif
 
 #if TEMP_SENSOR_BOARD == 1000
-  #define BOARD_PULLUP_RESISTOR_OHMS   4700    // Pullup resistor
-  #define BOARD_RESISTANCE_25C_OHMS    100000  // Resistance at 25C
-  #define BOARD_BETA                   3950    // Beta value
+  #define BOARD_PULLUP_RESISTOR_OHMS      4700 // Pullup resistor
+  #define BOARD_RESISTANCE_25C_OHMS     100000 // Resistance at 25C
+  #define BOARD_BETA                      3950 // Beta value
 #endif
 
 #if TEMP_SENSOR_REDUNDANT == 1000
-  #define REDUNDANT_PULLUP_RESISTOR_OHMS   4700    // Pullup resistor
-  #define REDUNDANT_RESISTANCE_25C_OHMS    100000  // Resistance at 25C
-  #define REDUNDANT_BETA                   3950    // Beta value
+  #define REDUNDANT_PULLUP_RESISTOR_OHMS  4700 // Pullup resistor
+  #define REDUNDANT_RESISTANCE_25C_OHMS 100000 // Resistance at 25C
+  #define REDUNDANT_BETA                  3950 // Beta value
 #endif
 
 /**
@@ -832,12 +832,12 @@
  * the position of the toolhead relative to the workspace.
  */
 
-//#define SENSORLESS_BACKOFF_MM  { 2, 2, 0 }  // (linear=mm, rotational=°) Backoff from endstops before sensorless homing
+//#define SENSORLESS_BACKOFF_MM  { 2, 2, 0 }  // (mm) Backoff from endstops before sensorless homing
 
-#define HOMING_BUMP_MM      { 5, 5, 2 }       // (linear=mm, rotational=°) Backoff from endstops after first bump
+#define HOMING_BUMP_MM      { 5, 5, 2 }       // (mm) Backoff from endstops after first bump
 #define HOMING_BUMP_DIVISOR { 2, 2, 4 }       // Re-Bump Speed Divisor (Divides the Homing Feedrate)
 
-//#define HOMING_BACKOFF_POST_MM { 2, 2, 2 }  // (linear=mm, rotational=°) Backoff from endstops after homing
+//#define HOMING_BACKOFF_POST_MM { 2, 2, 2 }  // (mm) Backoff from endstops after homing
 
 //#define QUICK_HOME                          // If G28 contains XY do a diagonal move first
 //#define HOME_Y_BEFORE_X                     // If G28 contains XY home Y before X
@@ -923,9 +923,12 @@
  */
 //#define Z_STEPPER_AUTO_ALIGN
 #if ENABLED(Z_STEPPER_AUTO_ALIGN)
-  // Define probe X and Y positions for Z1, Z2 [, Z3 [, Z4]]
-  // If not defined, probe limits will be used.
-  // Override with 'M422 S<index> X<pos> Y<pos>'
+  /**
+   * Define probe X and Y positions for Z1, Z2 [, Z3 [, Z4]]
+   * These positions are machine-relative and do not shift with the M206 home offset!
+   * If not defined, probe limits will be used.
+   * Override with 'M422 S<index> X<pos> Y<pos>'.
+   */
   //#define Z_STEPPER_ALIGN_XY { {  10, 190 }, { 100,  10 }, { 190, 190 } }
 
   /**
@@ -1023,9 +1026,6 @@
 #define INVERT_I_STEP_PIN false
 #define INVERT_J_STEP_PIN false
 #define INVERT_K_STEP_PIN false
-#define INVERT_U_STEP_PIN false
-#define INVERT_V_STEP_PIN false
-#define INVERT_W_STEP_PIN false
 #define INVERT_E_STEP_PIN false
 
 /**
@@ -1040,14 +1040,11 @@
 #define DISABLE_INACTIVE_I true
 #define DISABLE_INACTIVE_J true
 #define DISABLE_INACTIVE_K true
-#define DISABLE_INACTIVE_U true
-#define DISABLE_INACTIVE_V true
-#define DISABLE_INACTIVE_W true
 #define DISABLE_INACTIVE_E true
 
 // Default Minimum Feedrates for printing and travel moves
-#define DEFAULT_MINIMUMFEEDRATE       0.0     // (mm/s. °/s for rotational-only moves) Minimum feedrate. Set with M205 S.
-#define DEFAULT_MINTRAVELFEEDRATE     0.0     // (mm/s. °/s for rotational-only moves) Minimum travel feedrate. Set with M205 T.
+#define DEFAULT_MINIMUMFEEDRATE       0.0     // (mm/s) Minimum feedrate. Set with M205 S.
+#define DEFAULT_MINTRAVELFEEDRATE     0.0     // (mm/s) Minimum travel feedrate. Set with M205 T.
 
 // Minimum time that a segment needs to take as the buffer gets emptied
 #define DEFAULT_MINSEGMENTTIME        20000   // (µs) Set with M205 B.
@@ -1083,7 +1080,7 @@
 #if ENABLED(BACKLASH_COMPENSATION)
   // Define values for backlash distance and correction.
   // If BACKLASH_GCODE is enabled these values are the defaults.
-  #define BACKLASH_DISTANCE_MM { 0, 0, 0 } // (linear=mm, rotational=°) One value for each linear axis
+  #define BACKLASH_DISTANCE_MM { 0, 0, 0 } // (mm) One value for each linear axis
   #define BACKLASH_CORRECTION    0.0       // 0.0 = no correction; 1.0 = full correction
 
   // Add steps for motor direction changes on CORE kinematics
@@ -1160,12 +1157,6 @@
   //#define CALIBRATION_MEASURE_JMAX
   //#define CALIBRATION_MEASURE_KMIN
   //#define CALIBRATION_MEASURE_KMAX
-  //#define CALIBRATION_MEASURE_UMIN
-  //#define CALIBRATION_MEASURE_UMAX
-  //#define CALIBRATION_MEASURE_VMIN
-  //#define CALIBRATION_MEASURE_VMAX
-  //#define CALIBRATION_MEASURE_WMIN
-  //#define CALIBRATION_MEASURE_WMAX
 
   // Probing at the exact top center only works if the center is flat. If
   // probing on a screwhead or hollow washer, probe near the edges.
@@ -2024,21 +2015,6 @@
 
 // @section leveling
 
-/**
- * Use Safe Bed Leveling coordinates to move axes to a useful position before bed probing.
- * For example, after homing a rotational axis the Z probe might not be perpendicular to the bed.
- * Choose values the orient the bed horizontally and the Z-probe vertically.
- */
-//#define SAFE_BED_LEVELING_START_X 0.0
-//#define SAFE_BED_LEVELING_START_Y 0.0
-//#define SAFE_BED_LEVELING_START_Z 0.0
-//#define SAFE_BED_LEVELING_START_I 0.0
-//#define SAFE_BED_LEVELING_START_J 0.0
-//#define SAFE_BED_LEVELING_START_K 0.0
-//#define SAFE_BED_LEVELING_START_U 0.0
-//#define SAFE_BED_LEVELING_START_V 0.0
-//#define SAFE_BED_LEVELING_START_W 0.0
-
 /**
  * Points to probe for all 3-point Leveling procedures.
  * Override if the automatically selected points are inadequate.
@@ -2657,24 +2633,6 @@
     #define K_MICROSTEPS       16
   #endif
 
-  #if AXIS_DRIVER_TYPE_U(TMC26X)
-    #define U_MAX_CURRENT    1000
-    #define U_SENSE_RESISTOR   91
-    #define U_MICROSTEPS       16
-  #endif
-
-  #if AXIS_DRIVER_TYPE_V(TMC26X)
-    #define V_MAX_CURRENT    1000
-    #define V_SENSE_RESISTOR   91
-    #define V_MICROSTEPS       16
-  #endif
-
-  #if AXIS_DRIVER_TYPE_W(TMC26X)
-    #define W_MAX_CURRENT    1000
-    #define W_SENSE_RESISTOR   91
-    #define W_MICROSTEPS       16
-  #endif
-
   #if AXIS_DRIVER_TYPE_E0(TMC26X)
     #define E0_MAX_CURRENT    1000
     #define E0_SENSE_RESISTOR   91
@@ -2863,36 +2821,6 @@
     //#define K_HOLD_MULTIPLIER 0.5
   #endif
 
-  #if AXIS_IS_TMC(U)
-    #define U_CURRENT      800
-    #define U_CURRENT_HOME U_CURRENT
-    #define U_MICROSTEPS     8
-    #define U_RSENSE         0.11
-    #define U_CHAIN_POS     -1
-    //#define U_INTERPOLATE  true
-    //#define U_HOLD_MULTIPLIER 0.5
-  #endif
-
-  #if AXIS_IS_TMC(V)
-    #define V_CURRENT      800
-    #define V_CURRENT_HOME V_CURRENT
-    #define V_MICROSTEPS     8
-    #define V_RSENSE         0.11
-    #define V_CHAIN_POS     -1
-    //#define V_INTERPOLATE  true
-    //#define V_HOLD_MULTIPLIER 0.5
-  #endif
-
-  #if AXIS_IS_TMC(W)
-    #define W_CURRENT      800
-    #define W_CURRENT_HOME W_CURRENT
-    #define W_MICROSTEPS     8
-    #define W_RSENSE         0.11
-    #define W_CHAIN_POS     -1
-    //#define W_INTERPOLATE  true
-    //#define W_HOLD_MULTIPLIER 0.5
-  #endif
-
   #if AXIS_IS_TMC(E0)
     #define E0_CURRENT      800
     #define E0_MICROSTEPS    16
@@ -2980,9 +2908,6 @@
   //#define I_CS_PIN          -1
   //#define J_CS_PIN          -1
   //#define K_CS_PIN          -1
-  //#define U_CS_PIN          -1
-  //#define V_CS_PIN          -1
-  //#define W_CS_PIN          -1
   //#define E0_CS_PIN         -1
   //#define E1_CS_PIN         -1
   //#define E2_CS_PIN         -1
@@ -3025,9 +2950,6 @@
   //#define  I_SLAVE_ADDRESS 0
   //#define  J_SLAVE_ADDRESS 0
   //#define  K_SLAVE_ADDRESS 0
-  //#define  U_SLAVE_ADDRESS 0
-  //#define  V_SLAVE_ADDRESS 0
-  //#define  W_SLAVE_ADDRESS 0
   //#define E0_SLAVE_ADDRESS 0
   //#define E1_SLAVE_ADDRESS 0
   //#define E2_SLAVE_ADDRESS 0
@@ -3055,9 +2977,6 @@
   #define STEALTHCHOP_I
   #define STEALTHCHOP_J
   #define STEALTHCHOP_K
-  #define STEALTHCHOP_U
-  #define STEALTHCHOP_V
-  #define STEALTHCHOP_W
   #define STEALTHCHOP_E
 
   /**
@@ -3084,12 +3003,9 @@
   //#define CHOPPER_TIMING_Z2 CHOPPER_TIMING_Z
   //#define CHOPPER_TIMING_Z3 CHOPPER_TIMING_Z
   //#define CHOPPER_TIMING_Z4 CHOPPER_TIMING_Z
-  //#define CHOPPER_TIMING_I  CHOPPER_TIMING        // For I Axis
-  //#define CHOPPER_TIMING_J  CHOPPER_TIMING        // For J Axis
-  //#define CHOPPER_TIMING_K  CHOPPER_TIMING        // For K Axis
-  //#define CHOPPER_TIMING_U  CHOPPER_TIMING        // For U Axis
-  //#define CHOPPER_TIMING_V  CHOPPER_TIMING        // For V Axis
-  //#define CHOPPER_TIMING_W  CHOPPER_TIMING        // For W Axis
+  //#define CHOPPER_TIMING_I  CHOPPER_TIMING
+  //#define CHOPPER_TIMING_J  CHOPPER_TIMING
+  //#define CHOPPER_TIMING_K  CHOPPER_TIMING
   //#define CHOPPER_TIMING_E  CHOPPER_TIMING        // For Extruders (override below)
   //#define CHOPPER_TIMING_E1 CHOPPER_TIMING_E
   //#define CHOPPER_TIMING_E2 CHOPPER_TIMING_E
@@ -3135,12 +3051,9 @@
   #define Z2_HYBRID_THRESHOLD      3
   #define Z3_HYBRID_THRESHOLD      3
   #define Z4_HYBRID_THRESHOLD      3
-  #define I_HYBRID_THRESHOLD       3  // [linear=mm/s, rotational=°/s]
-  #define J_HYBRID_THRESHOLD       3  // [linear=mm/s, rotational=°/s]
-  #define K_HYBRID_THRESHOLD       3  // [linear=mm/s, rotational=°/s]
-  #define U_HYBRID_THRESHOLD       3  // [mm/s]
-  #define V_HYBRID_THRESHOLD       3
-  #define W_HYBRID_THRESHOLD       3
+  #define I_HYBRID_THRESHOLD       3
+  #define J_HYBRID_THRESHOLD       3
+  #define K_HYBRID_THRESHOLD       3
   #define E0_HYBRID_THRESHOLD     30
   #define E1_HYBRID_THRESHOLD     30
   #define E2_HYBRID_THRESHOLD     30
@@ -3190,9 +3103,6 @@
     //#define I_STALL_SENSITIVITY  8
     //#define J_STALL_SENSITIVITY  8
     //#define K_STALL_SENSITIVITY  8
-    //#define U_STALL_SENSITIVITY  8
-    //#define V_STALL_SENSITIVITY  8
-    //#define W_STALL_SENSITIVITY  8
     //#define SPI_ENDSTOPS              // TMC2130 only
     //#define IMPROVE_HOMING_RELIABILITY
   #endif
@@ -3360,33 +3270,6 @@
     #define K_SLEW_RATE         1
   #endif
 
-  #if AXIS_IS_L64XX(U)
-    #define U_MICROSTEPS      128
-    #define U_OVERCURRENT    2000
-    #define U_STALLCURRENT   1500
-    #define U_MAX_VOLTAGE     127
-    #define U_CHAIN_POS        -1
-    #define U_SLEW_RATE         1
-  #endif
-
-  #if AXIS_IS_L64XX(V)
-    #define V_MICROSTEPS      128
-    #define V_OVERCURRENT    2000
-    #define V_STALLCURRENT   1500
-    #define V_MAX_VOLTAGE     127
-    #define V_CHAIN_POS        -1
-    #define V_SLEW_RATE         1
-  #endif
-
-  #if AXIS_IS_L64XX(W)
-    #define W_MICROSTEPS      128
-    #define W_OVERCURRENT    2000
-    #define W_STALLCURRENT   1500
-    #define W_MAX_VOLTAGE     127
-    #define W_CHAIN_POS        -1
-    #define W_SLEW_RATE         1
-  #endif
-
   #if AXIS_IS_L64XX(E0)
     #define E0_MICROSTEPS              128
     #define E0_OVERCURRENT            2000
@@ -3592,6 +3475,9 @@
   #if ENABLED(SPINDLE_LASER_USE_PWM)
     #define SPINDLE_LASER_PWM_INVERT    false  // Set to "true" if the speed/power goes up when you want it to go slower
     #define SPINDLE_LASER_FREQUENCY     2500   // (Hz) Spindle/laser frequency (only on supported HALs: AVR, ESP32, and LPC)
+                                               // ESP32: If SPINDLE_LASER_PWM_PIN is onboard then <=78125Hz. For I2S expander
+                                               //  the frequency determines the PWM resolution. 2500Hz = 0-100, 977Hz = 0-255, ...
+                                               //  (250000 / SPINDLE_LASER_FREQUENCY) = max value.
   #endif
 
   //#define AIR_EVACUATION                     // Cutter Vacuum / Laser Blower motor control with G-codes M10-M11
@@ -3665,8 +3551,11 @@
     #endif
 
     // Define the minimum and maximum test pulse time values for a laser test fire function
-    #define LASER_TEST_PULSE_MIN           1   // Used with Laser Control Menu
-    #define LASER_TEST_PULSE_MAX         999   // Caution: Menu may not show more than 3 characters
+    #define LASER_TEST_PULSE_MIN           1   // (ms) Used with Laser Control Menu
+    #define LASER_TEST_PULSE_MAX         999   // (ms) Caution: Menu may not show more than 3 characters
+
+    #define SPINDLE_LASER_POWERUP_DELAY   50   // (ms) Delay to allow the spindle/laser to come up to speed/power
+    #define SPINDLE_LASER_POWERDOWN_DELAY 50   // (ms) Delay to allow the spindle to stop
 
    /**
     * Laser Safety Timeout
@@ -3679,79 +3568,38 @@
     #define LASER_SAFETY_TIMEOUT_MS     1000   // (ms)
 
     /**
-     * Enable inline laser power to be handled in the planner / stepper routines.
-     * Inline power is specified by the I (inline) flag in an M3 command (e.g., M3 S20 I)
-     * or by the 'S' parameter in G0/G1/G2/G3 moves (see LASER_MOVE_POWER).
+     * Any M3 or G1/2/3/5 command with the 'I' parameter enables continuous inline power mode.
      *
-     * This allows the laser to keep in perfect sync with the planner and removes
-     * the powerup/down delay since lasers require negligible time.
+     * e.g., 'M3 I' enables continuous inline power which is processed by the planner.
+     * Power is stored in move blocks and applied when blocks are processed by the Stepper ISR.
+     *
+     * 'M4 I' sets dynamic mode which uses the current feedrate to calculate a laser power OCR value.
+     *
+     * Any move in dynamic mode will use the current feedrate to calculate the laser power.
+     * Feed rates are set by the F parameter of a move command e.g. G1 X0 Y10 F6000
+     * Laser power would be calculated by bit shifting off 8 LSB's. In binary this is div 256.
+     * The calculation gives us ocr values from 0 to 255, values over F65535 will be set as 255 .
+     * More refined power control such as compesation for accell/decell will be addressed in future releases.
+     *
+     * M5 I clears inline mode and set power to 0, M5 sets the power output to 0 but leaves inline mode on.
      */
-    //#define LASER_POWER_INLINE
 
-    #if ENABLED(LASER_POWER_INLINE)
-      /**
-       * Scale the laser's power in proportion to the movement rate.
-       *
-       * - Sets the entry power proportional to the entry speed over the nominal speed.
-       * - Ramps the power up every N steps to approximate the speed trapezoid.
-       * - Due to the limited power resolution this is only approximate.
-       */
-      #define LASER_POWER_INLINE_TRAPEZOID
+    /**
+     * Enable M3 commands for laser mode inline power planner syncing.
+     * This feature enables any M3 S-value to be injected into the block buffers while in
+     * CUTTER_MODE_CONTINUOUS. The option allows M3 laser power to be commited without waiting
+     * for a planner syncronization
+     */
+    //#define LASER_POWER_SYNC
 
-      /**
-       * Continuously calculate the current power (nominal_power * current_rate / nominal_rate).
-       * Required for accurate power with non-trapezoidal acceleration (e.g., S_CURVE_ACCELERATION).
-       * This is a costly calculation so this option is discouraged on 8-bit AVR boards.
-       *
-       * LASER_POWER_INLINE_TRAPEZOID_CONT_PER defines how many step cycles there are between power updates. If your
-       * board isn't able to generate steps fast enough (and you are using LASER_POWER_INLINE_TRAPEZOID_CONT), increase this.
-       * Note that when this is zero it means it occurs every cycle; 1 means a delay wait one cycle then run, etc.
-       */
-      //#define LASER_POWER_INLINE_TRAPEZOID_CONT
-
-      /**
-       * Stepper iterations between power updates. Increase this value if the board
-       * can't keep up with the processing demands of LASER_POWER_INLINE_TRAPEZOID_CONT.
-       * Disable (or set to 0) to recalculate power on every stepper iteration.
-       */
-      //#define LASER_POWER_INLINE_TRAPEZOID_CONT_PER 10
-
-      /**
-       * Include laser power in G0/G1/G2/G3/G5 commands with the 'S' parameter
-       */
-      //#define LASER_MOVE_POWER
-
-      #if ENABLED(LASER_MOVE_POWER)
-        // Turn off the laser on G0 moves with no power parameter.
-        // If a power parameter is provided, use that instead.
-        //#define LASER_MOVE_G0_OFF
-
-        // Turn off the laser on G28 homing.
-        //#define LASER_MOVE_G28_OFF
-      #endif
-
-      /**
-       * Inline flag inverted
-       *
-       * WARNING: M5 will NOT turn off the laser unless another move
-       *          is done (so G-code files must end with 'M5 I').
-       */
-      //#define LASER_POWER_INLINE_INVERT
-
-      /**
-       * Continuously apply inline power. ('M3 S3' == 'G1 S3' == 'M3 S3 I')
-       *
-       * The laser might do some weird things, so only enable this
-       * feature if you understand the implications.
-       */
-      //#define LASER_POWER_INLINE_CONTINUOUS
-
-    #else
-
-      #define SPINDLE_LASER_POWERUP_DELAY     50 // (ms) Delay to allow the spindle/laser to come up to speed/power
-      #define SPINDLE_LASER_POWERDOWN_DELAY   50 // (ms) Delay to allow the spindle to stop
-
-    #endif
+    /**
+     * Scale the laser's power in proportion to the movement rate.
+     *
+     * - Sets the entry power proportional to the entry speed over the nominal speed.
+     * - Ramps the power up every N steps to approximate the speed trapezoid.
+     * - Due to the limited power resolution this is only approximate.
+     */
+    //#define LASER_POWER_TRAP
 
     //
     // Laser I2C Ammeter (High precision INA226 low/high side module)

Marlin/Makefile

@@ -109,7 +109,7 @@ LIQUID_TWI2        ?= 0
 # This defines if Wire is needed
 WIRE               ?= 0
 
-# This defines if Tone is needed (i.e SPEAKER is defined in Configuration.h)
+# This defines if Tone is needed (i.e., SPEAKER is defined in Configuration.h)
 # Disabling this (and SPEAKER) saves approximately 350 bytes of memory.
 TONE               ?= 1
 
@@ -317,123 +317,10 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1159)
 else ifeq ($(HARDWARE_MOTHERBOARD),1160)
 # Longer LKx PRO / Alfawise Uxx Pro (PRO version)
 else ifeq ($(HARDWARE_MOTHERBOARD),1161)
-
-
-# 3Drag Controller
-else ifeq ($(HARDWARE_MOTHERBOARD),1100)
-# Velleman K8200 Controller (derived from 3Drag Controller)
-else ifeq ($(HARDWARE_MOTHERBOARD),1101)
-# Velleman K8400 Controller (derived from 3Drag Controller)
-else ifeq ($(HARDWARE_MOTHERBOARD),1102)
-# Velleman K8600 Controller (Vertex Nano)
-else ifeq ($(HARDWARE_MOTHERBOARD),1103)
-# Velleman K8800 Controller (Vertex Delta)
-else ifeq ($(HARDWARE_MOTHERBOARD),1104)
-# 2PrintBeta BAM&DICE with STK drivers
-else ifeq ($(HARDWARE_MOTHERBOARD),1105)
-# 2PrintBeta BAM&DICE Due with STK drivers
-else ifeq ($(HARDWARE_MOTHERBOARD),1106)
-# MKS BASE v1.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1107)
-# MKS v1.4 with A4982 stepper drivers
-else ifeq ($(HARDWARE_MOTHERBOARD),1108)
-# MKS v1.5 with Allegro A4982 stepper drivers
-else ifeq ($(HARDWARE_MOTHERBOARD),1109)
-# MKS v1.6 with Allegro A4982 stepper drivers
-else ifeq ($(HARDWARE_MOTHERBOARD),1110)
-# MKS BASE 1.0 with Heroic HR4982 stepper drivers
-else ifeq ($(HARDWARE_MOTHERBOARD),1111)
-# MKS GEN v1.3 or 1.4
-else ifeq ($(HARDWARE_MOTHERBOARD),1112)
-# MKS GEN L
-else ifeq ($(HARDWARE_MOTHERBOARD),1113)
-# zrib V2.0 control board (Chinese RAMPS replica)
-else ifeq ($(HARDWARE_MOTHERBOARD),1114)
-# BigTreeTech or BIQU KFB2.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1115)
-# Felix 2.0+ Electronics Board (RAMPS like)
-else ifeq ($(HARDWARE_MOTHERBOARD),1116)
-# Invent-A-Part RigidBoard
-else ifeq ($(HARDWARE_MOTHERBOARD),1117)
-# Invent-A-Part RigidBoard V2
-else ifeq ($(HARDWARE_MOTHERBOARD),1118)
-# Sainsmart 2-in-1 board
-else ifeq ($(HARDWARE_MOTHERBOARD),1119)
-# Ultimaker
-else ifeq ($(HARDWARE_MOTHERBOARD),1120)
-# Ultimaker (Older electronics. Pre 1.5.4. This is rare)
-else ifeq ($(HARDWARE_MOTHERBOARD),1121)
-  MCU              ?= atmega1280
-  PROG_MCU         ?= m1280
-
-# Azteeg X3
-else ifeq ($(HARDWARE_MOTHERBOARD),1122)
-# Azteeg X3 Pro
-else ifeq ($(HARDWARE_MOTHERBOARD),1123)
-# Ultimainboard 2.x (Uses TEMP_SENSOR 20)
-else ifeq ($(HARDWARE_MOTHERBOARD),1124)
-# Rumba
-else ifeq ($(HARDWARE_MOTHERBOARD),1125)
-# Raise3D Rumba
-else ifeq ($(HARDWARE_MOTHERBOARD),1126)
-# Rapide Lite RL200 Rumba
-else ifeq ($(HARDWARE_MOTHERBOARD),1127)
-# Formbot T-Rex 2 Plus
-else ifeq ($(HARDWARE_MOTHERBOARD),1128)
-# Formbot T-Rex 3
-else ifeq ($(HARDWARE_MOTHERBOARD),1129)
-# Formbot Raptor
-else ifeq ($(HARDWARE_MOTHERBOARD),1130)
-# Formbot Raptor 2
-else ifeq ($(HARDWARE_MOTHERBOARD),1131)
-# bq ZUM Mega 3D
-else ifeq ($(HARDWARE_MOTHERBOARD),1132)
-# MakeBoard Mini v2.1.2 is a control board sold by MicroMake
-else ifeq ($(HARDWARE_MOTHERBOARD),1133)
-# TriGorilla Anycubic version 1.3 based on RAMPS EFB
-else ifeq ($(HARDWARE_MOTHERBOARD),1134)
-# TriGorilla Anycubic version 1.4 based on RAMPS EFB
-else ifeq ($(HARDWARE_MOTHERBOARD),1135)
-# TriGorilla Anycubic version 1.4 Rev 1.1
-else ifeq ($(HARDWARE_MOTHERBOARD),1136)
-# Creality: Ender-4, CR-8
-else ifeq ($(HARDWARE_MOTHERBOARD),1137)
-# Creality: CR10S, CR20, CR-X
-else ifeq ($(HARDWARE_MOTHERBOARD),1138)
-# Dagoma F5
-else ifeq ($(HARDWARE_MOTHERBOARD),1139)
-# FYSETC F6 1.3
-else ifeq ($(HARDWARE_MOTHERBOARD),1140)
-# FYSETC F6 1.5
-else ifeq ($(HARDWARE_MOTHERBOARD),1141)
-# Duplicator i3 Plus
-else ifeq ($(HARDWARE_MOTHERBOARD),1142)
-# VORON
-else ifeq ($(HARDWARE_MOTHERBOARD),1143)
-# TRONXY V3 1.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1144)
-# Z-Bolt X Series
-else ifeq ($(HARDWARE_MOTHERBOARD),1145)
-# TT OSCAR
-else ifeq ($(HARDWARE_MOTHERBOARD),1146)
-# Overlord/Overlord Pro
-else ifeq ($(HARDWARE_MOTHERBOARD),1147)
-# ADIMLab Gantry v1
-else ifeq ($(HARDWARE_MOTHERBOARD),1148)
-# ADIMLab Gantry v2
-else ifeq ($(HARDWARE_MOTHERBOARD),1149)
-# BIQU Tango V1
-else ifeq ($(HARDWARE_MOTHERBOARD),1150)
-# MKS GEN L V2
-else ifeq ($(HARDWARE_MOTHERBOARD),1151)
-# MKS GEN L V2.1
-else ifeq ($(HARDWARE_MOTHERBOARD),1152)
-# Copymaster 3D
-else ifeq ($(HARDWARE_MOTHERBOARD),1153)
-# Ortur 4
-else ifeq ($(HARDWARE_MOTHERBOARD),1154)
-# Tenlog D3 Hero
-else ifeq ($(HARDWARE_MOTHERBOARD),1155)
+# Zonestar zrib V5.3 (Chinese RAMPS replica)
+else ifeq ($(HARDWARE_MOTHERBOARD),1162)
+# Pxmalion Core I3
+else ifeq ($(HARDWARE_MOTHERBOARD),1163)
 
 #
 # RAMBo and derivatives

Marlin/Version.h

@@ -28,7 +28,7 @@
 /**
  * Marlin release version identifier
  */
-//#define SHORT_BUILD_VERSION "2.1.0.2"
+//#define SHORT_BUILD_VERSION "bugfix-2.0.x"
 
 /**
  * Verbose version identifier which should contain a reference to the location
@@ -41,7 +41,7 @@
  * here we define this default string as the date where the latest release
  * version was tagged.
  */
-//#define STRING_DISTRIBUTION_DATE "2023-12-08"
+//#define STRING_DISTRIBUTION_DATE "2023-04-16"
 
 /**
  * Defines a generic printer name to be output to the LCD after booting Marlin.

Marlin/config.ini

@@ -0,0 +1,211 @@
+#
+# Marlin Firmware
+# config.ini - Options to apply before the build
+#
+[config:base]
+ini_use_config                           = none
+
+# Load all config: sections in this file
+;ini_use_config                          = all
+# Load config file relative to Marlin/
+;ini_use_config                          = another.ini
+# Download configurations from GitHub
+;ini_use_config                          = example/Creality/Ender-5 Plus @ bugfix-2.1.x
+# Download configurations from your server
+;ini_use_config                          = https://me.myserver.com/path/to/configs
+# Evaluate config:base and do a config dump
+;ini_use_config                          = base
+;config_export                           = 2
+
+[config:minimal]
+motherboard                              = BOARD_RAMPS_14_EFB
+serial_port                              = 0
+baudrate                                 = 250000
+
+use_watchdog                             = on
+thermal_protection_hotends               = on
+thermal_protection_hysteresis            = 4
+thermal_protection_period                = 40
+
+bufsize                                  = 4
+block_buffer_size                        = 16
+max_cmd_size                             = 96
+
+extruders                                = 1
+temp_sensor_0                            = 1
+
+temp_hysteresis                          = 3
+heater_0_mintemp                         = 5
+heater_0_maxtemp                         = 275
+preheat_1_temp_hotend                    = 180
+
+bang_max                                 = 255
+pidtemp                                  = on
+pid_k1                                   = 0.95
+pid_max                                  = BANG_MAX
+pid_functional_range                     = 10
+
+default_kp                               = 22.20
+default_ki                               = 1.08
+default_kd                               = 114.00
+
+x_driver_type                            = A4988
+y_driver_type                            = A4988
+z_driver_type                            = A4988
+e0_driver_type                           = A4988
+
+x_bed_size                               = 200
+x_min_pos                                = 0
+x_max_pos                                = X_BED_SIZE
+
+y_bed_size                               = 200
+y_min_pos                                = 0
+y_max_pos                                = Y_BED_SIZE
+
+z_min_pos                                = 0
+z_max_pos                                = 200
+
+x_home_dir                               = -1
+y_home_dir                               = -1
+z_home_dir                               = -1
+
+use_xmin_plug                            = on
+use_ymin_plug                            = on
+use_zmin_plug                            = on
+
+x_min_endstop_inverting                  = false
+y_min_endstop_inverting                  = false
+z_min_endstop_inverting                  = false
+
+default_axis_steps_per_unit              = { 80, 80, 400, 500 }
+axis_relative_modes                      = { false, false, false, false }
+default_max_feedrate                     = { 300, 300, 5, 25 }
+default_max_acceleration                 = { 3000, 3000, 100, 10000 }
+
+homing_feedrate_mm_m                     = { (50*60), (50*60), (4*60) }
+homing_bump_divisor                      = { 2, 2, 4 }
+
+x_enable_on                              = 0
+y_enable_on                              = 0
+z_enable_on                              = 0
+e_enable_on                              = 0
+
+invert_x_dir                             = false
+invert_y_dir                             = true
+invert_z_dir                             = false
+invert_e0_dir                            = false
+
+invert_e_step_pin                        = false
+invert_x_step_pin                        = false
+invert_y_step_pin                        = false
+invert_z_step_pin                        = false
+
+disable_x                                = false
+disable_y                                = false
+disable_z                                = false
+disable_e                                = false
+
+proportional_font_ratio                  = 1.0
+default_nominal_filament_dia             = 1.75
+
+junction_deviation_mm                    = 0.013
+
+default_acceleration                     = 3000
+default_travel_acceleration              = 3000
+default_retract_acceleration             = 3000
+
+default_minimumfeedrate                  = 0.0
+default_mintravelfeedrate                = 0.0
+
+minimum_planner_speed                    = 0.05
+min_steps_per_segment                    = 6
+default_minsegmenttime                   = 20000
+
+[config:basic]
+bed_overshoot                            = 10
+busy_while_heating                       = on
+default_ejerk                            = 5.0
+default_keepalive_interval               = 2
+default_leveling_fade_height             = 0.0
+disable_inactive_extruder                = on
+display_charset_hd44780                  = JAPANESE
+eeprom_boot_silent                       = on
+eeprom_chitchat                          = on
+endstoppullups                           = on
+extrude_maxlength                        = 200
+extrude_mintemp                          = 170
+host_keepalive_feature                   = on
+hotend_overshoot                         = 15
+jd_handle_small_segments                 = on
+lcd_info_screen_style                    = 0
+lcd_language                             = en
+max_bed_power                            = 255
+mesh_inset                               = 0
+min_software_endstops                    = on
+max_software_endstops                    = on
+min_software_endstop_x                   = on
+min_software_endstop_y                   = on
+min_software_endstop_z                   = on
+max_software_endstop_x                   = on
+max_software_endstop_y                   = on
+max_software_endstop_z                   = on
+preheat_1_fan_speed                      = 0
+preheat_1_label                          = "PLA"
+preheat_1_temp_bed                       = 70
+prevent_cold_extrusion                   = on
+prevent_lengthy_extrude                  = on
+printjob_timer_autostart                 = on
+probing_margin                           = 10
+show_bootscreen                          = on
+soft_pwm_scale                           = 0
+string_config_h_author                   = "(none, default config)"
+temp_bed_hysteresis                      = 3
+temp_bed_residency_time                  = 10
+temp_bed_window                          = 1
+temp_residency_time                      = 10
+temp_window                              = 1
+validate_homing_endstops                 = on
+xy_probe_feedrate                        = (133*60)
+z_clearance_between_probes               = 5
+z_clearance_deploy_probe                 = 10
+z_clearance_multi_probe                  = 5
+
+[config:advanced]
+arc_support                              = on
+auto_report_temperatures                 = on
+autotemp                                 = on
+autotemp_oldweight                       = 0.98
+bed_check_interval                       = 5000
+default_stepper_deactive_time            = 120
+default_volumetric_extruder_limit        = 0.00
+disable_inactive_e                       = true
+disable_inactive_x                       = true
+disable_inactive_y                       = true
+disable_inactive_z                       = true
+e0_auto_fan_pin                          = -1
+encoder_100x_steps_per_sec               = 80
+encoder_10x_steps_per_sec                = 30
+encoder_rate_multiplier                  = on
+extended_capabilities_report             = on
+extruder_auto_fan_speed                  = 255
+extruder_auto_fan_temperature            = 50
+fanmux0_pin                              = -1
+fanmux1_pin                              = -1
+fanmux2_pin                              = -1
+faster_gcode_parser                      = on
+homing_bump_mm                           = { 5, 5, 2 }
+max_arc_segment_mm                       = 1.0
+min_arc_segment_mm                       = 0.1
+min_circle_segments                      = 72
+n_arc_correction                         = 25
+serial_overrun_protection                = on
+slowdown                                 = on
+slowdown_divisor                         = 2
+temp_sensor_bed                          = 0
+thermal_protection_bed_hysteresis        = 2
+thermocouple_max_errors                  = 15
+tx_buffer_size                           = 0
+watch_bed_temp_increase                  = 2
+watch_bed_temp_period                    = 60
+watch_temp_increase                      = 2
+watch_temp_period                        = 20

Marlin/src/HAL/AVR/Servo.cpp

@@ -66,27 +66,26 @@ static volatile int8_t Channel[_Nbr_16timers];              // counter for the s
 
 /************ static functions common to all instances ***********************/
 
-static inline void handle_interrupts(timer16_Sequence_t timer, volatile uint16_t* TCNTn, volatile uint16_t* OCRnA) {
-  if (Channel[timer] < 0)
-    *TCNTn = 0; // channel set to -1 indicated that refresh interval completed so reset the timer
-  else {
-    if (SERVO_INDEX(timer, Channel[timer]) < ServoCount && SERVO(timer, Channel[timer]).Pin.isActive)
-      extDigitalWrite(SERVO(timer, Channel[timer]).Pin.nbr, LOW); // pulse this channel low if activated
-  }
+static inline void handle_interrupts(const timer16_Sequence_t timer, volatile uint16_t* TCNTn, volatile uint16_t* OCRnA) {
+  int8_t cho = Channel[timer];                                        // Handle the prior Channel[timer] first
+  if (cho < 0)                                                        // Channel -1 indicates the refresh interval completed...
+    *TCNTn = 0;                                                       // ...so reset the timer
+  else if (SERVO_INDEX(timer, cho) < ServoCount)                      // prior channel handled?
+    extDigitalWrite(SERVO(timer, cho).Pin.nbr, LOW);                  // pulse the prior channel LOW
 
-  Channel[timer]++;    // increment to the next channel
-  if (SERVO_INDEX(timer, Channel[timer]) < ServoCount && Channel[timer] < SERVOS_PER_TIMER) {
-    *OCRnA = *TCNTn + SERVO(timer, Channel[timer]).ticks;
-    if (SERVO(timer, Channel[timer]).Pin.isActive)    // check if activated
-      extDigitalWrite(SERVO(timer, Channel[timer]).Pin.nbr, HIGH); // it's an active channel so pulse it high
+  Channel[timer] = ++cho;                                             // Handle the next channel (or 0)
+  if (cho < SERVOS_PER_TIMER && SERVO_INDEX(timer, cho) < ServoCount) {
+    *OCRnA = *TCNTn + SERVO(timer, cho).ticks;                        // set compare to current ticks plus duration
+    if (SERVO(timer, cho).Pin.isActive)                               // activated?
+      extDigitalWrite(SERVO(timer, cho).Pin.nbr, HIGH);               // yes: pulse HIGH
   }
   else {
     // finished all channels so wait for the refresh period to expire before starting over
-    if (((unsigned)*TCNTn) + 4 < usToTicks(REFRESH_INTERVAL))    // allow a few ticks to ensure the next OCR1A not missed
-      *OCRnA = (unsigned int)usToTicks(REFRESH_INTERVAL);
-    else
-      *OCRnA = *TCNTn + 4;  // at least REFRESH_INTERVAL has elapsed
-    Channel[timer] = -1; // this will get incremented at the end of the refresh period to start again at the first channel
+    const unsigned int cval = ((unsigned)*TCNTn) + 32 / (SERVO_TIMER_PRESCALER), // allow 32 cycles to ensure the next OCR1A not missed
+                       ival = (unsigned int)usToTicks(REFRESH_INTERVAL); // at least REFRESH_INTERVAL has elapsed
+    *OCRnA = max(cval, ival);
+
+    Channel[timer] = -1;                                              // reset the timer counter to 0 on the next call
   }
 }
 
@@ -123,91 +122,102 @@ static inline void handle_interrupts(timer16_Sequence_t timer, volatile uint16_t
 
 /****************** end of static functions ******************************/
 
-void initISR(timer16_Sequence_t timer) {
-  #ifdef _useTimer1
-    if (timer == _timer1) {
-      TCCR1A = 0;             // normal counting mode
-      TCCR1B = _BV(CS11);     // set prescaler of 8
-      TCNT1 = 0;              // clear the timer count
-      #if defined(__AVR_ATmega8__) || defined(__AVR_ATmega128__)
-        SBI(TIFR, OCF1A);      // clear any pending interrupts;
-        SBI(TIMSK, OCIE1A);    // enable the output compare interrupt
-      #else
-        // here if not ATmega8 or ATmega128
-        SBI(TIFR1, OCF1A);     // clear any pending interrupts;
-        SBI(TIMSK1, OCIE1A);   // enable the output compare interrupt
-      #endif
-      #ifdef WIRING
-        timerAttach(TIMER1OUTCOMPAREA_INT, Timer1Service);
-      #endif
-    }
-  #endif
+void initISR(const timer16_Sequence_t timer_index) {
+  switch (timer_index) {
+    default: break;
 
-  #ifdef _useTimer3
-    if (timer == _timer3) {
-      TCCR3A = 0;             // normal counting mode
-      TCCR3B = _BV(CS31);     // set prescaler of 8
-      TCNT3 = 0;              // clear the timer count
-      #ifdef __AVR_ATmega128__
-        SBI(TIFR, OCF3A);     // clear any pending interrupts;
-        SBI(ETIMSK, OCIE3A);  // enable the output compare interrupt
-      #else
-        SBI(TIFR3, OCF3A);   // clear any pending interrupts;
-        SBI(TIMSK3, OCIE3A); // enable the output compare interrupt
-      #endif
-      #ifdef WIRING
-        timerAttach(TIMER3OUTCOMPAREA_INT, Timer3Service);  // for Wiring platform only
-      #endif
-    }
-  #endif
+    #ifdef _useTimer1
+      case _timer1:
+        TCCR1A = 0;             // normal counting mode
+        TCCR1B = _BV(CS11);     // set prescaler of 8
+        TCNT1 = 0;              // clear the timer count
+        #if defined(__AVR_ATmega8__) || defined(__AVR_ATmega128__)
+          SBI(TIFR, OCF1A);      // clear any pending interrupts;
+          SBI(TIMSK, OCIE1A);    // enable the output compare interrupt
+        #else
+          // here if not ATmega8 or ATmega128
+          SBI(TIFR1, OCF1A);     // clear any pending interrupts;
+          SBI(TIMSK1, OCIE1A);   // enable the output compare interrupt
+        #endif
+        #ifdef WIRING
+          timerAttach(TIMER1OUTCOMPAREA_INT, Timer1Service);
+        #endif
+        break;
+    #endif
 
-  #ifdef _useTimer4
-    if (timer == _timer4) {
-      TCCR4A = 0;             // normal counting mode
-      TCCR4B = _BV(CS41);     // set prescaler of 8
-      TCNT4 = 0;              // clear the timer count
-      TIFR4 = _BV(OCF4A);     // clear any pending interrupts;
-      TIMSK4 = _BV(OCIE4A);   // enable the output compare interrupt
-    }
-  #endif
+    #ifdef _useTimer3
+      case _timer3:
+        TCCR3A = 0;             // normal counting mode
+        TCCR3B = _BV(CS31);     // set prescaler of 8
+        TCNT3 = 0;              // clear the timer count
+        #ifdef __AVR_ATmega128__
+          SBI(TIFR, OCF3A);     // clear any pending interrupts;
+          SBI(ETIMSK, OCIE3A);  // enable the output compare interrupt
+        #else
+          SBI(TIFR3, OCF3A);   // clear any pending interrupts;
+          SBI(TIMSK3, OCIE3A); // enable the output compare interrupt
+        #endif
+        #ifdef WIRING
+          timerAttach(TIMER3OUTCOMPAREA_INT, Timer3Service);  // for Wiring platform only
+        #endif
+        break;
+    #endif
 
-  #ifdef _useTimer5
-    if (timer == _timer5) {
-      TCCR5A = 0;             // normal counting mode
-      TCCR5B = _BV(CS51);     // set prescaler of 8
-      TCNT5 = 0;              // clear the timer count
-      TIFR5 = _BV(OCF5A);     // clear any pending interrupts;
-      TIMSK5 = _BV(OCIE5A);   // enable the output compare interrupt
-    }
-  #endif
+    #ifdef _useTimer4
+      case _timer4:
+        TCCR4A = 0;             // normal counting mode
+        TCCR4B = _BV(CS41);     // set prescaler of 8
+        TCNT4 = 0;              // clear the timer count
+        TIFR4 = _BV(OCF4A);     // clear any pending interrupts;
+        TIMSK4 = _BV(OCIE4A);   // enable the output compare interrupt
+        break;
+    #endif
+
+    #ifdef _useTimer5
+      case _timer5:
+        TCCR5A = 0;             // normal counting mode
+        TCCR5B = _BV(CS51);     // set prescaler of 8
+        TCNT5 = 0;              // clear the timer count
+        TIFR5 = _BV(OCF5A);     // clear any pending interrupts;
+        TIMSK5 = _BV(OCIE5A);   // enable the output compare interrupt
+        break;
+    #endif
+  }
 }
 
-void finISR(timer16_Sequence_t timer) {
+void finISR(const timer16_Sequence_t timer_index) {
   // Disable use of the given timer
   #ifdef WIRING
-    if (timer == _timer1) {
-      CBI(
-        #if defined(__AVR_ATmega1281__) || defined(__AVR_ATmega2561__)
-          TIMSK1
-        #else
-          TIMSK
-        #endif
-          , OCIE1A);    // disable timer 1 output compare interrupt
-      timerDetach(TIMER1OUTCOMPAREA_INT);
-    }
-    else if (timer == _timer3) {
-      CBI(
-        #if defined(__AVR_ATmega1281__) || defined(__AVR_ATmega2561__)
-          TIMSK3
-        #else
-          ETIMSK
-        #endif
-          , OCIE3A);    // disable the timer3 output compare A interrupt
-      timerDetach(TIMER3OUTCOMPAREA_INT);
+    switch (timer_index) {
+      default: break;
+
+      case _timer1:
+        CBI(
+          #if defined(__AVR_ATmega1281__) || defined(__AVR_ATmega2561__)
+            TIMSK1
+          #else
+            TIMSK
+          #endif
+          , OCIE1A    // disable timer 1 output compare interrupt
+        );
+        timerDetach(TIMER1OUTCOMPAREA_INT);
+        break;
+
+      case _timer3:
+        CBI(
+          #if defined(__AVR_ATmega1281__) || defined(__AVR_ATmega2561__)
+            TIMSK3
+          #else
+            ETIMSK
+          #endif
+          , OCIE3A    // disable the timer3 output compare A interrupt
+        );
+        timerDetach(TIMER3OUTCOMPAREA_INT);
+        break;
     }
   #else // !WIRING
     // For arduino - in future: call here to a currently undefined function to reset the timer
-    UNUSED(timer);
+    UNUSED(timer_index);
   #endif
 }
 

Marlin/src/HAL/AVR/endstop_interrupts.h

@@ -213,51 +213,6 @@ void setup_endstop_interrupts() {
       pciSetup(K_MIN_PIN);
     #endif
   #endif
-  #if HAS_U_MAX
-    #if (digitalPinToInterrupt(U_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(U_MAX_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(U_MAX_PIN), "U_MAX_PIN is not interrupt-capable");
-      pciSetup(U_MAX_PIN);
-    #endif
-  #elif HAS_U_MIN
-    #if (digitalPinToInterrupt(U_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(U_MIN_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(U_MIN_PIN), "U_MIN_PIN is not interrupt-capable");
-      pciSetup(U_MIN_PIN);
-    #endif
-  #endif
-  #if HAS_V_MAX
-    #if (digitalPinToInterrupt(V_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(V_MAX_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(V_MAX_PIN), "V_MAX_PIN is not interrupt-capable");
-      pciSetup(V_MAX_PIN);
-    #endif
-  #elif HAS_V_MIN
-    #if (digitalPinToInterrupt(V_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(V_MIN_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(V_MIN_PIN), "V_MIN_PIN is not interrupt-capable");
-      pciSetup(V_MIN_PIN);
-    #endif
-  #endif
-  #if HAS_W_MAX
-    #if (digitalPinToInterrupt(W_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(W_MAX_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(W_MAX_PIN), "W_MAX_PIN is not interrupt-capable");
-      pciSetup(W_MAX_PIN);
-    #endif
-  #elif HAS_W_MIN
-    #if (digitalPinToInterrupt(W_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(W_MIN_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(W_MIN_PIN), "W_MIN_PIN is not interrupt-capable");
-      pciSetup(W_MIN_PIN);
-    #endif
-  #endif
   #if HAS_X2_MAX
     #if (digitalPinToInterrupt(X2_MAX_PIN) != NOT_AN_INTERRUPT)
       _ATTACH(X2_MAX_PIN);

Marlin/src/HAL/DUE/Servo.cpp

@@ -47,12 +47,12 @@
 #include "../shared/servo.h"
 #include "../shared/servo_private.h"
 
-static volatile int8_t Channel[_Nbr_16timers];              // counter for the servo being pulsed for each timer (or -1 if refresh interval)
+static Flags<_Nbr_16timers> DisablePending; // ISR should disable the timer at the next timer reset
 
 // ------------------------
 /// Interrupt handler for the TC0 channel 1.
 // ------------------------
-void Servo_Handler(timer16_Sequence_t timer, Tc *pTc, uint8_t channel);
+void Servo_Handler(const timer16_Sequence_t, Tc*, const uint8_t);
 
 #ifdef _useTimer1
   void HANDLER_FOR_TIMER1() { Servo_Handler(_timer1, TC_FOR_TIMER1, CHANNEL_FOR_TIMER1); }
@@ -70,88 +70,92 @@ void Servo_Handler(timer16_Sequence_t timer, Tc *pTc, uint8_t channel);
   void HANDLER_FOR_TIMER5() { Servo_Handler(_timer5, TC_FOR_TIMER5, CHANNEL_FOR_TIMER5); }
 #endif
 
-void Servo_Handler(timer16_Sequence_t timer, Tc *tc, uint8_t channel) {
-  // clear interrupt
-  tc->TC_CHANNEL[channel].TC_SR;
-  if (Channel[timer] < 0)
-    tc->TC_CHANNEL[channel].TC_CCR |= TC_CCR_SWTRG; // channel set to -1 indicated that refresh interval completed so reset the timer
-  else if (SERVO_INDEX(timer, Channel[timer]) < ServoCount && SERVO(timer, Channel[timer]).Pin.isActive)
-    extDigitalWrite(SERVO(timer, Channel[timer]).Pin.nbr, LOW); // pulse this channel low if activated
+void Servo_Handler(const timer16_Sequence_t timer, Tc *tc, const uint8_t channel) {
+  static int8_t Channel[_Nbr_16timers];                               // Servo counters to pulse (or -1 for refresh interval)
+  int8_t cho = Channel[timer];                                        // Handle the prior Channel[timer] first
+  if (cho < 0) {                                                      // Channel -1 indicates the refresh interval completed...
+    tc->TC_CHANNEL[channel].TC_CCR |= TC_CCR_SWTRG;                   // ...so reset the timer
+    if (DisablePending[timer]) {
+      // Disabling only after the full servo period expires prevents
+      // pulses being too close together if immediately re-enabled.
+      DisablePending.clear(timer);
+      TC_Stop(tc, channel);
+      tc->TC_CHANNEL[channel].TC_SR;                                  // clear interrupt
+      return;
+    }
+  }
+  else if (SERVO_INDEX(timer, cho) < ServoCount)                      // prior channel handled?
+    extDigitalWrite(SERVO(timer, cho).Pin.nbr, LOW);                  // pulse the prior channel LOW
 
-  Channel[timer]++;    // increment to the next channel
-  if (SERVO_INDEX(timer, Channel[timer]) < ServoCount && Channel[timer] < SERVOS_PER_TIMER) {
-    tc->TC_CHANNEL[channel].TC_RA = tc->TC_CHANNEL[channel].TC_CV + SERVO(timer,Channel[timer]).ticks;
-    if (SERVO(timer,Channel[timer]).Pin.isActive)    // check if activated
-      extDigitalWrite(SERVO(timer, Channel[timer]).Pin.nbr, HIGH); // its an active channel so pulse it high
+  Channel[timer] = ++cho;                                             // go to the next channel (or 0)
+  if (cho < SERVOS_PER_TIMER && SERVO_INDEX(timer, cho) < ServoCount) {
+    tc->TC_CHANNEL[channel].TC_RA = tc->TC_CHANNEL[channel].TC_CV + SERVO(timer, cho).ticks;
+    if (SERVO(timer, cho).Pin.isActive)                               // activated?
+      extDigitalWrite(SERVO(timer, cho).Pin.nbr, HIGH);               // yes: pulse HIGH
   }
   else {
     // finished all channels so wait for the refresh period to expire before starting over
-    tc->TC_CHANNEL[channel].TC_RA =
-      tc->TC_CHANNEL[channel].TC_CV < usToTicks(REFRESH_INTERVAL) - 4
-        ? (unsigned int)usToTicks(REFRESH_INTERVAL) // allow a few ticks to ensure the next OCR1A not missed
-        : tc->TC_CHANNEL[channel].TC_CV + 4;        // at least REFRESH_INTERVAL has elapsed
-    Channel[timer] = -1; // this will get incremented at the end of the refresh period to start again at the first channel
+    const unsigned int cval = tc->TC_CHANNEL[channel].TC_CV + 128 / (SERVO_TIMER_PRESCALER), // allow 128 cycles to ensure the next CV not missed
+                       ival = (unsigned int)usToTicks(REFRESH_INTERVAL); // at least REFRESH_INTERVAL has elapsed
+    tc->TC_CHANNEL[channel].TC_RA = max(cval, ival);
+
+    Channel[timer] = -1;                                              // reset the timer CCR on the next call
   }
+
+  tc->TC_CHANNEL[channel].TC_SR;                                      // clear interrupt
 }
 
 static void _initISR(Tc *tc, uint32_t channel, uint32_t id, IRQn_Type irqn) {
   pmc_enable_periph_clk(id);
   TC_Configure(tc, channel,
-    TC_CMR_TCCLKS_TIMER_CLOCK3 | // MCK/32
-    TC_CMR_WAVE |                // Waveform mode
-    TC_CMR_WAVSEL_UP_RC );       // Counter running up and reset when equals to RC
+      TC_CMR_WAVE                   // Waveform mode
+    | TC_CMR_WAVSEL_UP_RC           // Counter running up and reset when equal to RC
+    | (SERVO_TIMER_PRESCALER ==   2 ? TC_CMR_TCCLKS_TIMER_CLOCK1 : 0) // MCK/2
+    | (SERVO_TIMER_PRESCALER ==   8 ? TC_CMR_TCCLKS_TIMER_CLOCK2 : 0) // MCK/8
+    | (SERVO_TIMER_PRESCALER ==  32 ? TC_CMR_TCCLKS_TIMER_CLOCK3 : 0) // MCK/32
+    | (SERVO_TIMER_PRESCALER == 128 ? TC_CMR_TCCLKS_TIMER_CLOCK4 : 0) // MCK/128
+  );
 
-  /* 84MHz, MCK/32, for 1.5ms: 3937 */
-  TC_SetRA(tc, channel, 2625); // 1ms
+  // Wait 1ms before the first ISR
+  TC_SetRA(tc, channel, (F_CPU) / (SERVO_TIMER_PRESCALER) / 1000UL); // 1ms
 
-  /* Configure and enable interrupt */
+  // Configure and enable interrupt
   NVIC_EnableIRQ(irqn);
-  // TC_IER_CPAS: RA Compare
-  tc->TC_CHANNEL[channel].TC_IER = TC_IER_CPAS;
+  tc->TC_CHANNEL[channel].TC_IER = TC_IER_CPAS; // TC_IER_CPAS: RA Compare
 
   // Enables the timer clock and performs a software reset to start the counting
   TC_Start(tc, channel);
 }
 
-void initISR(timer16_Sequence_t timer) {
-  #ifdef _useTimer1
-    if (timer == _timer1)
-      _initISR(TC_FOR_TIMER1, CHANNEL_FOR_TIMER1, ID_TC_FOR_TIMER1, IRQn_FOR_TIMER1);
-  #endif
-  #ifdef _useTimer2
-    if (timer == _timer2)
-      _initISR(TC_FOR_TIMER2, CHANNEL_FOR_TIMER2, ID_TC_FOR_TIMER2, IRQn_FOR_TIMER2);
-  #endif
-  #ifdef _useTimer3
-    if (timer == _timer3)
-      _initISR(TC_FOR_TIMER3, CHANNEL_FOR_TIMER3, ID_TC_FOR_TIMER3, IRQn_FOR_TIMER3);
-  #endif
-  #ifdef _useTimer4
-    if (timer == _timer4)
-      _initISR(TC_FOR_TIMER4, CHANNEL_FOR_TIMER4, ID_TC_FOR_TIMER4, IRQn_FOR_TIMER4);
-  #endif
-  #ifdef _useTimer5
-    if (timer == _timer5)
-      _initISR(TC_FOR_TIMER5, CHANNEL_FOR_TIMER5, ID_TC_FOR_TIMER5, IRQn_FOR_TIMER5);
-  #endif
+void initISR(const timer16_Sequence_t timer_index) {
+  CRITICAL_SECTION_START();
+  const bool disable_soon = DisablePending[timer_index];
+  DisablePending.clear(timer_index);
+  CRITICAL_SECTION_END();
+
+  if (!disable_soon) switch (timer_index) {
+    default: break;
+    #ifdef _useTimer1
+      case _timer1: return _initISR(TC_FOR_TIMER1, CHANNEL_FOR_TIMER1, ID_TC_FOR_TIMER1, IRQn_FOR_TIMER1);
+    #endif
+    #ifdef _useTimer2
+      case _timer2: return _initISR(TC_FOR_TIMER2, CHANNEL_FOR_TIMER2, ID_TC_FOR_TIMER2, IRQn_FOR_TIMER2);
+    #endif
+    #ifdef _useTimer3
+      case _timer3: return _initISR(TC_FOR_TIMER3, CHANNEL_FOR_TIMER3, ID_TC_FOR_TIMER3, IRQn_FOR_TIMER3);
+    #endif
+    #ifdef _useTimer4
+      case _timer4: return _initISR(TC_FOR_TIMER4, CHANNEL_FOR_TIMER4, ID_TC_FOR_TIMER4, IRQn_FOR_TIMER4);
+    #endif
+    #ifdef _useTimer5
+      case _timer5: return _initISR(TC_FOR_TIMER5, CHANNEL_FOR_TIMER5, ID_TC_FOR_TIMER5, IRQn_FOR_TIMER5);
+    #endif
+  }
 }
 
-void finISR(timer16_Sequence_t) {
-  #ifdef _useTimer1
-    TC_Stop(TC_FOR_TIMER1, CHANNEL_FOR_TIMER1);
-  #endif
-  #ifdef _useTimer2
-    TC_Stop(TC_FOR_TIMER2, CHANNEL_FOR_TIMER2);
-  #endif
-  #ifdef _useTimer3
-    TC_Stop(TC_FOR_TIMER3, CHANNEL_FOR_TIMER3);
-  #endif
-  #ifdef _useTimer4
-    TC_Stop(TC_FOR_TIMER4, CHANNEL_FOR_TIMER4);
-  #endif
-  #ifdef _useTimer5
-    TC_Stop(TC_FOR_TIMER5, CHANNEL_FOR_TIMER5);
-  #endif
+void finISR(const timer16_Sequence_t timer_index) {
+  // Timer is disabled from the ISR, to ensure proper final pulse length.
+  DisablePending.set(timer_index);
 }
 
 #endif // HAS_SERVOS

Marlin/src/HAL/DUE/ServoTimers.h

@@ -37,7 +37,7 @@
 #define _useTimer5
 
 #define TRIM_DURATION             2   // compensation ticks to trim adjust for digitalWrite delays
-#define SERVO_TIMER_PRESCALER     32  // timer prescaler
+#define SERVO_TIMER_PRESCALER     2   // timer prescaler
 
 /*
   TC0, chan 0 => TC0_Handler

Marlin/src/HAL/DUE/endstop_interrupts.h

@@ -70,10 +70,4 @@ void setup_endstop_interrupts() {
   TERN_(HAS_J_MIN, _ATTACH(J_MIN_PIN));
   TERN_(HAS_K_MAX, _ATTACH(K_MAX_PIN));
   TERN_(HAS_K_MIN, _ATTACH(K_MIN_PIN));
-  TERN_(HAS_U_MAX, _ATTACH(U_MAX_PIN));
-  TERN_(HAS_U_MIN, _ATTACH(U_MIN_PIN));
-  TERN_(HAS_V_MAX, _ATTACH(V_MAX_PIN));
-  TERN_(HAS_V_MIN, _ATTACH(V_MIN_PIN));
-  TERN_(HAS_W_MAX, _ATTACH(W_MAX_PIN));
-  TERN_(HAS_W_MIN, _ATTACH(W_MIN_PIN));
 }

Marlin/src/HAL/DUE/timers.cpp

@@ -89,10 +89,17 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
   NVIC_SetPriority(irq, timer_config[timer_num].priority);
 
   // wave mode, reset counter on match with RC,
-  TC_Configure(tc, channel, TC_CMR_WAVE | TC_CMR_WAVSEL_UP_RC | TC_CMR_TCCLKS_TIMER_CLOCK1);
+  TC_Configure(tc, channel,
+      TC_CMR_WAVE
+    | TC_CMR_WAVSEL_UP_RC
+    | (HAL_TIMER_PRESCALER ==   2 ? TC_CMR_TCCLKS_TIMER_CLOCK1 : 0)
+    | (HAL_TIMER_PRESCALER ==   8 ? TC_CMR_TCCLKS_TIMER_CLOCK2 : 0)
+    | (HAL_TIMER_PRESCALER ==  32 ? TC_CMR_TCCLKS_TIMER_CLOCK3 : 0)
+    | (HAL_TIMER_PRESCALER == 128 ? TC_CMR_TCCLKS_TIMER_CLOCK4 : 0)
+  );
 
   // Set compare value
-  TC_SetRC(tc, channel, VARIANT_MCK / 2 / frequency);
+  TC_SetRC(tc, channel, VARIANT_MCK / (HAL_TIMER_PRESCALER) / frequency);
 
   // And start timer
   TC_Start(tc, channel);

Marlin/src/HAL/DUE/timers.h

@@ -35,7 +35,8 @@
 typedef uint32_t hal_timer_t;
 #define HAL_TIMER_TYPE_MAX 0xFFFFFFFF
 
-#define HAL_TIMER_RATE         ((F_CPU) / 2)    // frequency of timers peripherals
+#define HAL_TIMER_PRESCALER    2
+#define HAL_TIMER_RATE         ((F_CPU) / (HAL_TIMER_PRESCALER))  // frequency of timers peripherals
 
 #ifndef MF_TIMER_STEP
   #define MF_TIMER_STEP         2  // Timer Index for Stepper

Marlin/src/HAL/DUE/upload_extra_script.py

@@ -6,14 +6,14 @@
 #
 import pioutil
 if pioutil.is_pio_build():
-	import platform
-	current_OS = platform.system()
+    import platform
+    current_OS = platform.system()
 
-	if current_OS == 'Windows':
+    if current_OS == 'Windows':
 
-		Import("env")
+        Import("env")
 
-		# Use bossac.exe on Windows
-		env.Replace(
-			UPLOADCMD="bossac --info --unlock --write --verify --reset --erase -U false --boot $SOURCE"
-		)
+        # Use bossac.exe on Windows
+        env.Replace(
+            UPLOADCMD="bossac --info --unlock --write --verify --reset --erase -U false --boot $SOURCE"
+        )

Marlin/src/HAL/DUE/usb/compiler.h

@@ -1059,7 +1059,7 @@ static inline void convert_64_bit_to_byte_array(uint64_t value, uint8_t *data)
     while (val_index < 8)
     {
         data[val_index++] = value & 0xFF;
-        value = value >> 8;
+        value >>= 8;
     }
 }
 

Marlin/src/HAL/ESP32/HAL.cpp

@@ -65,6 +65,7 @@ portMUX_TYPE MarlinHAL::spinlock = portMUX_INITIALIZER_UNLOCKED;
 // ------------------------
 
 uint16_t MarlinHAL::adc_result;
+pwm_pin_t MarlinHAL::pwm_pin_data[MAX_EXPANDER_BITS];
 
 // ------------------------
 // Private Variables
@@ -330,21 +331,46 @@ int8_t get_pwm_channel(const pin_t pin, const uint32_t freq, const uint16_t res)
 }
 
 void MarlinHAL::set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size/*=_BV(PWM_RESOLUTION)-1*/, const bool invert/*=false*/) {
-  const int8_t cid = get_pwm_channel(pin, PWM_FREQUENCY, PWM_RESOLUTION);
-  if (cid >= 0) {
-    uint32_t duty = map(invert ? v_size - v : v, 0, v_size, 0, _BV(PWM_RESOLUTION)-1);
-    ledcWrite(cid, duty);
-  }
+  #if ENABLED(I2S_STEPPER_STREAM)
+    if (pin > 127) {
+      const uint8_t pinlo = pin & 0x7F;
+      pwm_pin_t &pindata = pwm_pin_data[pinlo];
+      const uint32_t duty = map(invert ? v_size - v : v, 0, v_size, 0, pindata.pwm_cycle_ticks);
+      if (duty == 0 || duty == pindata.pwm_cycle_ticks) { // max or min (i.e., on/off)
+        pindata.pwm_duty_ticks = 0;  // turn off PWM for this pin
+        duty ? SBI32(i2s_port_data, pinlo) : CBI32(i2s_port_data, pinlo); // set pin level
+      }
+      else
+        pindata.pwm_duty_ticks = duty; // PWM duty count = # of 4µs ticks per full PWM cycle
+    }
+    else
+  #endif
+    {
+      const int8_t cid = get_pwm_channel(pin, PWM_FREQUENCY, PWM_RESOLUTION);
+      if (cid >= 0) {
+        const uint32_t duty = map(invert ? v_size - v : v, 0, v_size, 0, _BV(PWM_RESOLUTION)-1);
+        ledcWrite(cid, duty);
+      }
+    }
 }
 
 int8_t MarlinHAL::set_pwm_frequency(const pin_t pin, const uint32_t f_desired) {
-  const int8_t cid = channel_for_pin(pin);
-  if (cid >= 0) {
-    if (f_desired == ledcReadFreq(cid)) return cid; // no freq change
-    ledcDetachPin(chan_pin[cid]);
-    chan_pin[cid] = 0;              // remove old freq channel
-  }
-  return get_pwm_channel(pin, f_desired, PWM_RESOLUTION); // try for new one
+  #if ENABLED(I2S_STEPPER_STREAM)
+    if (pin > 127) {
+      pwm_pin_data[pin & 0x7F].pwm_cycle_ticks = 1000000UL / f_desired / 4; // # of 4µs ticks per full PWM cycle
+      return 0;
+    }
+    else
+  #endif
+    {
+      const int8_t cid = channel_for_pin(pin);
+      if (cid >= 0) {
+        if (f_desired == ledcReadFreq(cid)) return cid; // no freq change
+        ledcDetachPin(chan_pin[cid]);
+        chan_pin[cid] = 0;              // remove old freq channel
+      }
+      return get_pwm_channel(pin, f_desired, PWM_RESOLUTION); // try for new one
+    }
 }
 
 // use hardware PWM if avail, if not then ISR

Marlin/src/HAL/ESP32/HAL.h

@@ -60,14 +60,17 @@
   #endif
 #endif
 
-#define CRITICAL_SECTION_START() portENTER_CRITICAL(&spinlock)
-#define CRITICAL_SECTION_END()   portEXIT_CRITICAL(&spinlock)
+#define CRITICAL_SECTION_START() portENTER_CRITICAL(&hal.spinlock)
+#define CRITICAL_SECTION_END()   portEXIT_CRITICAL(&hal.spinlock)
 
 #define HAL_CAN_SET_PWM_FREQ   // This HAL supports PWM Frequency adjustment
 #define PWM_FREQUENCY  1000u   // Default PWM frequency when set_pwm_duty() is called without set_pwm_frequency()
 #define PWM_RESOLUTION   10u   // Default PWM bit resolution
 #define CHANNEL_MAX_NUM  15u   // max PWM channel # to allocate (7 to only use low speed, 15 to use low & high)
 #define MAX_PWM_IOPIN    33u   // hardware pwm pins < 34
+#ifndef MAX_EXPANDER_BITS
+  #define MAX_EXPANDER_BITS 32 // I2S expander bit width (max 32)
+#endif
 
 // ------------------------
 // Types
@@ -76,6 +79,12 @@
 typedef double isr_float_t;   // FPU ops are used for single-precision, so use double for ISRs.
 typedef int16_t pin_t;
 
+typedef struct pwm_pin {
+  uint32_t pwm_cycle_ticks = 1000000UL / (PWM_FREQUENCY) / 4; // # ticks per pwm cycle
+  uint32_t pwm_tick_count = 0;  // current tick count
+  uint32_t pwm_duty_ticks = 0;  // # of ticks for current duty cycle
+} pwm_pin_t;
+
 class Servo;
 typedef Servo hal_servo_t;
 
@@ -197,6 +206,8 @@ public:
   // Free SRAM
   static int freeMemory();
 
+  static pwm_pin_t pwm_pin_data[MAX_EXPANDER_BITS];
+
   //
   // ADC Methods
   //

Marlin/src/HAL/ESP32/endstop_interrupts.h

@@ -65,10 +65,4 @@ void setup_endstop_interrupts() {
   TERN_(HAS_J_MIN, _ATTACH(J_MIN_PIN));
   TERN_(HAS_K_MAX, _ATTACH(K_MAX_PIN));
   TERN_(HAS_K_MIN, _ATTACH(K_MIN_PIN));
-  TERN_(HAS_U_MAX, _ATTACH(U_MAX_PIN));
-  TERN_(HAS_U_MIN, _ATTACH(U_MIN_PIN));
-  TERN_(HAS_V_MAX, _ATTACH(V_MAX_PIN));
-  TERN_(HAS_V_MIN, _ATTACH(V_MIN_PIN));
-  TERN_(HAS_W_MAX, _ATTACH(W_MAX_PIN));
-  TERN_(HAS_W_MIN, _ATTACH(W_MIN_PIN));
 }

Marlin/src/HAL/ESP32/i2s.cpp

@@ -337,6 +337,26 @@ uint8_t i2s_state(uint8_t pin) {
 }
 
 void i2s_push_sample() {
+  // Every 4µs (when space in DMA buffer) toggle each expander PWM output using
+  // the current duty cycle/frequency so they sync with any steps (once
+  // through the DMA/FIFO buffers).  PWM signal inversion handled by other functions
+  LOOP_L_N(p, MAX_EXPANDER_BITS) {
+    if (hal.pwm_pin_data[p].pwm_duty_ticks > 0) { // pin has active pwm?
+      if (hal.pwm_pin_data[p].pwm_tick_count == 0) {
+        if (TEST32(i2s_port_data, p)) {  // hi->lo
+          CBI32(i2s_port_data, p);
+          hal.pwm_pin_data[p].pwm_tick_count = hal.pwm_pin_data[p].pwm_cycle_ticks - hal.pwm_pin_data[p].pwm_duty_ticks;
+        }
+        else { // lo->hi
+          SBI32(i2s_port_data, p);
+          hal.pwm_pin_data[p].pwm_tick_count = hal.pwm_pin_data[p].pwm_duty_ticks;
+        }
+      }
+      else
+        hal.pwm_pin_data[p].pwm_tick_count--;
+    }
+  }
+
   dma.current[dma.rw_pos++] = i2s_port_data;
 }
 

Marlin/src/HAL/ESP32/inc/Conditionals_adv.h

@@ -20,3 +20,10 @@
  *
  */
 #pragma once
+
+//
+// Board-specific options need to be defined before HAL.h
+//
+#if MB(MKS_TINYBEE)
+  #define MAX_EXPANDER_BITS 24  // TinyBee has 3 x HC595
+#endif

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

@@ -48,3 +48,7 @@
 #if USING_PULLDOWNS
   #error "PULLDOWN pin mode is not available on ESP32 boards."
 #endif
+
+#if BOTH(I2S_STEPPER_STREAM, LIN_ADVANCE)
+  #error "I2S stream is currently incompatible with LIN_ADVANCE."
+#endif

Marlin/src/HAL/LINUX/eeprom.cpp

@@ -69,12 +69,12 @@ bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, ui
   std::size_t bytes_written = 0;
 
   for (std::size_t i = 0; i < size; i++) {
-    buffer[pos+i] = value[i];
-    bytes_written ++;
+    buffer[pos + i] = value[i];
+    bytes_written++;
   }
 
   crc16(crc, value, size);
-  pos = pos + size;
+  pos += size;
   return (bytes_written != size);  // return true for any error
 }
 
@@ -82,21 +82,21 @@ bool PersistentStore::read_data(int &pos, uint8_t *value, const size_t size, uin
   std::size_t bytes_read = 0;
   if (writing) {
     for (std::size_t i = 0; i < size; i++) {
-      value[i] = buffer[pos+i];
-      bytes_read ++;
+      value[i] = buffer[pos + i];
+      bytes_read++;
     }
     crc16(crc, value, size);
   }
   else {
     uint8_t temp[size];
     for (std::size_t i = 0; i < size; i++) {
-      temp[i] = buffer[pos+i];
-      bytes_read ++;
+      temp[i] = buffer[pos + i];
+      bytes_read++;
     }
     crc16(crc, temp, size);
   }
 
-  pos = pos + size;
+  pos += size;
   return bytes_read != size;  // return true for any error
 }
 

Marlin/src/HAL/LINUX/hardware/Heater.h

@@ -26,8 +26,8 @@
 struct LowpassFilter {
   uint64_t data_delay = 0;
   uint16_t update(uint16_t value) {
-    data_delay = data_delay - (data_delay >> 6) + value;
-    return (uint16_t)(data_delay >> 6);
+    data_delay += value - (data_delay >> 6);
+    return uint16_t(data_delay >> 6);
   }
 };
 

Marlin/src/HAL/LPC1768/endstop_interrupts.h

@@ -155,37 +155,4 @@ void setup_endstop_interrupts() {
     #endif
     _ATTACH(K_MIN_PIN);
   #endif
-  #if HAS_U_MAX
-    #if !LPC1768_PIN_INTERRUPT_M(U_MAX_PIN)
-      #error "U_MAX_PIN is not INTERRUPT-capable."
-    #endif
-    _ATTACH(U_MAX_PIN);
-  #elif HAS_U_MIN
-    #if !LPC1768_PIN_INTERRUPT_M(U_MIN_PIN)
-      #error "U_MIN_PIN is not INTERRUPT-capable."
-    #endif
-    _ATTACH(U_MIN_PIN);
-  #endif
-  #if HAS_V_MAX
-    #if !LPC1768_PIN_INTERRUPT_M(V_MAX_PIN)
-      #error "V_MAX_PIN is not INTERRUPT-capable."
-    #endif
-    _ATTACH(V_MAX_PIN);
-  #elif HAS_V_MIN
-    #if !LPC1768_PIN_INTERRUPT_M(V_MIN_PIN)
-      #error "V_MIN_PIN is not INTERRUPT-capable."
-    #endif
-    _ATTACH(V_MIN_PIN);
-  #endif
-  #if HAS_W_MAX
-    #if !LPC1768_PIN_INTERRUPT_M(W_MAX_PIN)
-      #error "W_MAX_PIN is not INTERRUPT-capable."
-    #endif
-    _ATTACH(W_MAX_PIN);
-  #elif HAS_W_MIN
-    #if !LPC1768_PIN_INTERRUPT_M(W_MIN_PIN)
-      #error "W_MIN_PIN is not INTERRUPT-capable."
-    #endif
-    _ATTACH(W_MIN_PIN);
-  #endif
 }

Marlin/src/HAL/LPC1768/upload_extra_script.py

@@ -9,119 +9,127 @@ from __future__ import print_function
 import pioutil
 if pioutil.is_pio_build():
 
-	target_filename = "FIRMWARE.CUR"
-	target_drive = "REARM"
+    target_filename = "FIRMWARE.CUR"
+    target_drive = "REARM"
 
-	import os,getpass,platform
+    import platform
 
-	current_OS = platform.system()
-	Import("env")
+    current_OS = platform.system()
+    Import("env")
 
-	def print_error(e):
-		print('\nUnable to find destination disk (%s)\n' \
-			  'Please select it in platformio.ini using the upload_port keyword ' \
-			  '(https://docs.platformio.org/en/latest/projectconf/section_env_upload.html) ' \
-			  'or copy the firmware (.pio/build/%s/firmware.bin) manually to the appropriate disk\n' \
-			  %(e, env.get('PIOENV')))
+    def print_error(e):
+        print('\nUnable to find destination disk (%s)\n' \
+              'Please select it in platformio.ini using the upload_port keyword ' \
+              '(https://docs.platformio.org/en/latest/projectconf/section_env_upload.html) ' \
+              'or copy the firmware (.pio/build/%s/firmware.bin) manually to the appropriate disk\n' \
+              %(e, env.get('PIOENV')))
 
-	def before_upload(source, target, env):
-		try:
-			#
-			# Find a disk for upload
-			#
-			upload_disk = 'Disk not found'
-			target_file_found = False
-			target_drive_found = False
-			if current_OS == 'Windows':
-				#
-				# platformio.ini will accept this for a Windows upload port designation: 'upload_port = L:'
-				#   Windows - doesn't care about the disk's name, only cares about the drive letter
-				import subprocess,string
-				from ctypes import windll
+    def before_upload(source, target, env):
+        try:
+            from pathlib import Path
+            #
+            # Find a disk for upload
+            #
+            upload_disk = 'Disk not found'
+            target_file_found = False
+            target_drive_found = False
+            if current_OS == 'Windows':
+                #
+                # platformio.ini will accept this for a Windows upload port designation: 'upload_port = L:'
+                #   Windows - doesn't care about the disk's name, only cares about the drive letter
+                import subprocess,string
+                from ctypes import windll
+                from pathlib import PureWindowsPath
 
-				# getting list of drives
-				# https://stackoverflow.com/questions/827371/is-there-a-way-to-list-all-the-available-drive-letters-in-python
-				drives = []
-				bitmask = windll.kernel32.GetLogicalDrives()
-				for letter in string.ascii_uppercase:
-					if bitmask & 1:
-						drives.append(letter)
-					bitmask >>= 1
+                # getting list of drives
+                # https://stackoverflow.com/questions/827371/is-there-a-way-to-list-all-the-available-drive-letters-in-python
+                drives = []
+                bitmask = windll.kernel32.GetLogicalDrives()
+                for letter in string.ascii_uppercase:
+                    if bitmask & 1:
+                        drives.append(letter)
+                    bitmask >>= 1
 
-				for drive in drives:
-					final_drive_name = drive + ':\\'
-					# print ('disc check: {}'.format(final_drive_name))
-					try:
-						volume_info = str(subprocess.check_output('cmd /C dir ' + final_drive_name, stderr=subprocess.STDOUT))
-					except Exception as e:
-						print ('error:{}'.format(e))
-						continue
-					else:
-						if target_drive in volume_info and not target_file_found:  # set upload if not found target file yet
-							target_drive_found = True
-							upload_disk = final_drive_name
-						if target_filename in volume_info:
-							if not target_file_found:
-								upload_disk = final_drive_name
-							target_file_found = True
+                for drive in drives:
+                    final_drive_name = drive + ':'
+                    # print ('disc check: {}'.format(final_drive_name))
+                    try:
+                        volume_info = str(subprocess.check_output('cmd /C dir ' + final_drive_name, stderr=subprocess.STDOUT))
+                    except Exception as e:
+                        print ('error:{}'.format(e))
+                        continue
+                    else:
+                        if target_drive in volume_info and not target_file_found:  # set upload if not found target file yet
+                            target_drive_found = True
+                            upload_disk = PureWindowsPath(final_drive_name)
+                        if target_filename in volume_info:
+                            if not target_file_found:
+                                upload_disk = PureWindowsPath(final_drive_name)
+                            target_file_found = True
 
-			elif current_OS == 'Linux':
-				#
-				# platformio.ini will accept this for a Linux upload port designation: 'upload_port = /media/media_name/drive'
-				#
-				drives = os.listdir(os.path.join(os.sep, 'media', getpass.getuser()))
-				if target_drive in drives:  # If target drive is found, use it.
-					target_drive_found = True
-					upload_disk = os.path.join(os.sep, 'media', getpass.getuser(), target_drive) + os.sep
-				else:
-					for drive in drives:
-						try:
-							files = os.listdir(os.path.join(os.sep, 'media', getpass.getuser(), drive))
-						except:
-							continue
-						else:
-							if target_filename in files:
-								upload_disk = os.path.join(os.sep, 'media', getpass.getuser(), drive) + os.sep
-								target_file_found = True
-								break
-				#
-				# set upload_port to drive if found
-				#
+            elif current_OS == 'Linux':
+                #
+                # platformio.ini will accept this for a Linux upload port designation: 'upload_port = /media/media_name/drive'
+                #
+                import getpass
+                user = getpass.getuser()
+                mpath = Path('/media', user)
+                drives = [ x for x in mpath.iterdir() if x.is_dir() ]
+                if target_drive in drives:  # If target drive is found, use it.
+                    target_drive_found = True
+                    upload_disk = mpath / target_drive
+                else:
+                    for drive in drives:
+                        try:
+                            fpath = mpath / drive
+                            filenames = [ x.name for x in fpath.iterdir() if x.is_file() ]
+                        except:
+                            continue
+                        else:
+                            if target_filename in filenames:
+                                upload_disk = mpath / drive
+                                target_file_found = True
+                                break
+                #
+                # set upload_port to drive if found
+                #
 
-				if target_file_found or target_drive_found:
-					env.Replace(
-						UPLOAD_FLAGS="-P$UPLOAD_PORT"
-					)
+                if target_file_found or target_drive_found:
+                    env.Replace(
+                        UPLOAD_FLAGS="-P$UPLOAD_PORT"
+                    )
 
-			elif current_OS == 'Darwin':  # MAC
-				#
-				# platformio.ini will accept this for a OSX upload port designation: 'upload_port = /media/media_name/drive'
-				#
-				drives = os.listdir('/Volumes')  # human readable names
-				if target_drive in drives and not target_file_found:  # set upload if not found target file yet
-					target_drive_found = True
-					upload_disk = '/Volumes/' + target_drive + '/'
-				for drive in drives:
-					try:
-						filenames = os.listdir('/Volumes/' + drive + '/')   # will get an error if the drive is protected
-					except:
-						continue
-					else:
-						if target_filename in filenames:
-							if not target_file_found:
-								upload_disk = '/Volumes/' + drive + '/'
-							target_file_found = True
+            elif current_OS == 'Darwin':  # MAC
+                #
+                # platformio.ini will accept this for a OSX upload port designation: 'upload_port = /media/media_name/drive'
+                #
+                dpath = Path('/Volumes')  # human readable names
+                drives = [ x for x in dpath.iterdir() if x.is_dir() ]
+                if target_drive in drives and not target_file_found:  # set upload if not found target file yet
+                    target_drive_found = True
+                    upload_disk = dpath / target_drive
+                for drive in drives:
+                    try:
+                        fpath = dpath / drive   # will get an error if the drive is protected
+                        filenames = [ x.name for x in fpath.iterdir() if x.is_file() ]
+                    except:
+                        continue
+                    else:
+                        if target_filename in filenames:
+                            upload_disk = dpath / drive
+                            target_file_found = True
+                            break
 
-			#
-			# Set upload_port to drive if found
-			#
-			if target_file_found or target_drive_found:
-				env.Replace(UPLOAD_PORT=upload_disk)
-				print('\nUpload disk: ', upload_disk, '\n')
-			else:
-				print_error('Autodetect Error')
+            #
+            # Set upload_port to drive if found
+            #
+            if target_file_found or target_drive_found:
+                env.Replace(UPLOAD_PORT=str(upload_disk))
+                print('\nUpload disk: ', upload_disk, '\n')
+            else:
+                print_error('Autodetect Error')
 
-		except Exception as e:
-			print_error(str(e))
+        except Exception as e:
+            print_error(str(e))
 
-	env.AddPreAction("upload", before_upload)
+    env.AddPreAction("upload", before_upload)

Marlin/src/HAL/SAMD51/HAL.cpp

@@ -598,7 +598,7 @@ void MarlinHAL::dma_init() {
 void MarlinHAL::init() {
   TERN_(DMA_IS_REQUIRED, dma_init());
   #if ENABLED(SDSUPPORT)
-    #if SD_CONNECTION_IS(ONBOARD) && PIN_EXISTS(SD_DETECT)
+    #if HAS_SD_DETECT && SD_CONNECTION_IS(ONBOARD)
       SET_INPUT_PULLUP(SD_DETECT_PIN);
     #endif
     OUT_WRITE(SDSS, HIGH);  // Try to set SDSS inactive before any other SPI users start up

Marlin/src/HAL/SAMD51/Servo.cpp

@@ -77,7 +77,8 @@ HAL_SERVO_TIMER_ISR() {
   ;
   const uint8_t tcChannel = TIMER_TCCHANNEL(timer);
 
-  if (currentServoIndex[timer] < 0) {
+  int8_t cho = currentServoIndex[timer];                // Handle the prior servo first
+  if (cho < 0) {                                        // Servo -1 indicates the refresh interval completed...
     #if defined(_useTimer1) && defined(_useTimer2)
       if (currentServoIndex[timer ^ 1] >= 0) {
         // Wait for both channels
@@ -86,45 +87,37 @@ HAL_SERVO_TIMER_ISR() {
         return;
       }
     #endif
-    tc->COUNT16.COUNT.reg = TC_COUNTER_START_VAL;
+    tc->COUNT16.COUNT.reg = TC_COUNTER_START_VAL;       // ...so reset the timer
     SYNC(tc->COUNT16.SYNCBUSY.bit.COUNT);
   }
-  else if (SERVO_INDEX(timer, currentServoIndex[timer]) < ServoCount && SERVO(timer, currentServoIndex[timer]).Pin.isActive)
-    digitalWrite(SERVO(timer, currentServoIndex[timer]).Pin.nbr, LOW);      // pulse this channel low if activated
+  else if (SERVO_INDEX(timer, cho) < ServoCount)        // prior channel handled?
+    digitalWrite(SERVO(timer, cho).Pin.nbr, LOW);       // pulse the prior channel LOW
 
-  // Select the next servo controlled by this timer
-  currentServoIndex[timer]++;
+  currentServoIndex[timer] = ++cho;                     // go to the next channel (or 0)
+  if (cho < SERVOS_PER_TIMER && SERVO_INDEX(timer, cho) < ServoCount) {
+    if (SERVO(timer, cho).Pin.isActive)                 // activated?
+      digitalWrite(SERVO(timer, cho).Pin.nbr, HIGH);    // yes: pulse HIGH
 
-  if (SERVO_INDEX(timer, currentServoIndex[timer]) < ServoCount && currentServoIndex[timer] < SERVOS_PER_TIMER) {
-    if (SERVO(timer, currentServoIndex[timer]).Pin.isActive)                // check if activated
-      digitalWrite(SERVO(timer, currentServoIndex[timer]).Pin.nbr, HIGH);   // it's an active channel so pulse it high
-
-    tc->COUNT16.CC[tcChannel].reg = getTimerCount() - (uint16_t)SERVO(timer, currentServoIndex[timer]).ticks;
+    tc->COUNT16.CC[tcChannel].reg = getTimerCount() - (uint16_t)SERVO(timer, cho).ticks;
   }
   else {
     // finished all channels so wait for the refresh period to expire before starting over
-    currentServoIndex[timer] = -1;   // this will get incremented at the end of the refresh period to start again at the first channel
-
-    const uint16_t tcCounterValue = getTimerCount();
-
-    if ((TC_COUNTER_START_VAL - tcCounterValue) + 4UL < usToTicks(REFRESH_INTERVAL))  // allow a few ticks to ensure the next OCR1A not missed
-      tc->COUNT16.CC[tcChannel].reg = TC_COUNTER_START_VAL - (uint16_t)usToTicks(REFRESH_INTERVAL);
-    else
-      tc->COUNT16.CC[tcChannel].reg = (uint16_t)(tcCounterValue - 4UL);               // at least REFRESH_INTERVAL has elapsed
+    currentServoIndex[timer] = -1;                                          // reset the timer COUNT.reg on the next call
+    const uint16_t cval = getTimerCount() - 256 / (SERVO_TIMER_PRESCALER),  // allow 256 cycles to ensure the next CV not missed
+                   ival = (TC_COUNTER_START_VAL) - (uint16_t)usToTicks(REFRESH_INTERVAL); // at least REFRESH_INTERVAL has elapsed
+    tc->COUNT16.CC[tcChannel].reg = min(cval, ival);
   }
   if (tcChannel == 0) {
     SYNC(tc->COUNT16.SYNCBUSY.bit.CC0);
-    // Clear the interrupt
-    tc->COUNT16.INTFLAG.reg = TC_INTFLAG_MC0;
+    tc->COUNT16.INTFLAG.reg = TC_INTFLAG_MC0; // Clear the interrupt
   }
   else {
     SYNC(tc->COUNT16.SYNCBUSY.bit.CC1);
-    // Clear the interrupt
-    tc->COUNT16.INTFLAG.reg = TC_INTFLAG_MC1;
+    tc->COUNT16.INTFLAG.reg = TC_INTFLAG_MC1; // Clear the interrupt
   }
 }
 
-void initISR(timer16_Sequence_t timer) {
+void initISR(const timer16_Sequence_t timer) {
   Tc * const tc = timer_config[SERVO_TC].pTc;
   const uint8_t tcChannel = TIMER_TCCHANNEL(timer);
 
@@ -201,9 +194,9 @@ void initISR(timer16_Sequence_t timer) {
   }
 }
 
-void finISR(timer16_Sequence_t timer) {
+void finISR(const timer16_Sequence_t timer_index) {
   Tc * const tc = timer_config[SERVO_TC].pTc;
-  const uint8_t tcChannel = TIMER_TCCHANNEL(timer);
+  const uint8_t tcChannel = TIMER_TCCHANNEL(timer_index);
 
   // Disable the match channel interrupt request
   tc->COUNT16.INTENCLR.reg = (tcChannel == 0) ? TC_INTENCLR_MC0 : TC_INTENCLR_MC1;

Marlin/src/HAL/SAMD51/endstop_interrupts.h

@@ -60,12 +60,6 @@
 #define MATCH_J_MIN_EILINE(P)   TERN0(HAS_J_MIN,  DEFER4(MATCH_EILINE)(P, J_MIN_PIN))
 #define MATCH_K_MAX_EILINE(P)   TERN0(HAS_K_MAX,  DEFER4(MATCH_EILINE)(P, K_MAX_PIN))
 #define MATCH_K_MIN_EILINE(P)   TERN0(HAS_K_MIN,  DEFER4(MATCH_EILINE)(P, K_MIN_PIN))
-#define MATCH_U_MAX_EILINE(P)   TERN0(HAS_U_MAX,  DEFER4(MATCH_EILINE)(P, U_MAX_PIN))
-#define MATCH_U_MIN_EILINE(P)   TERN0(HAS_U_MIN,  DEFER4(MATCH_EILINE)(P, U_MIN_PIN))
-#define MATCH_V_MAX_EILINE(P)   TERN0(HAS_V_MAX,  DEFER4(MATCH_EILINE)(P, V_MAX_PIN))
-#define MATCH_V_MIN_EILINE(P)   TERN0(HAS_V_MIN,  DEFER4(MATCH_EILINE)(P, V_MIN_PIN))
-#define MATCH_W_MAX_EILINE(P)   TERN0(HAS_W_MAX,  DEFER4(MATCH_EILINE)(P, W_MAX_PIN))
-#define MATCH_W_MIN_EILINE(P)   TERN0(HAS_W_MIN,  DEFER4(MATCH_EILINE)(P, W_MIN_PIN))
 #define MATCH_Z2_MAX_EILINE(P)  TERN0(HAS_Z2_MAX, DEFER4(MATCH_EILINE)(P, Z2_MAX_PIN))
 #define MATCH_Z2_MIN_EILINE(P)  TERN0(HAS_Z2_MIN, DEFER4(MATCH_EILINE)(P, Z2_MIN_PIN))
 #define MATCH_Z3_MAX_EILINE(P)  TERN0(HAS_Z3_MAX, DEFER4(MATCH_EILINE)(P, Z3_MAX_PIN))
@@ -81,9 +75,6 @@
   && !MATCH_I_MAX_EILINE(P) && !MATCH_I_MIN_EILINE(P)   \
   && !MATCH_J_MAX_EILINE(P) && !MATCH_J_MIN_EILINE(P)   \
   && !MATCH_K_MAX_EILINE(P) && !MATCH_K_MIN_EILINE(P)   \
-  && !MATCH_U_MAX_EILINE(P) && !MATCH_U_MIN_EILINE(P)   \
-  && !MATCH_V_MAX_EILINE(P) && !MATCH_V_MIN_EILINE(P)   \
-  && !MATCH_W_MAX_EILINE(P) && !MATCH_W_MIN_EILINE(P)   \
   && !MATCH_Z2_MAX_EILINE(P) && !MATCH_Z2_MIN_EILINE(P) \
   && !MATCH_Z3_MAX_EILINE(P) && !MATCH_Z3_MIN_EILINE(P) \
   && !MATCH_Z4_MAX_EILINE(P) && !MATCH_Z4_MIN_EILINE(P) \
@@ -208,40 +199,4 @@ void setup_endstop_interrupts() {
     #endif
     attachInterrupt(K_MIN_PIN, endstop_ISR, CHANGE);
   #endif
-  #if HAS_U_MAX
-    #if !AVAILABLE_EILINE(U_MAX_PIN)
-      #error "U_MAX_PIN has no EXTINT line available."
-    #endif
-    attachInterrupt(U_MAX_PIN, endstop_ISR, CHANGE);
-  #endif
-  #if HAS_U_MIN
-    #if !AVAILABLE_EILINE(U_MIN_PIN)
-      #error "U_MIN_PIN has no EXTINT line available."
-    #endif
-    attachInterrupt(U_MIN_PIN, endstop_ISR, CHANGE);
-  #endif
-  #if HAS_V_MAX
-    #if !AVAILABLE_EILINE(V_MAX_PIN)
-      #error "V_MAX_PIN has no EXTINT line available."
-    #endif
-    attachInterrupt(V_MAX_PIN, endstop_ISR, CHANGE);
-  #endif
-  #if HAS_V_MIN
-    #if !AVAILABLE_EILINE(V_MIN_PIN)
-      #error "V_MIN_PIN has no EXTINT line available."
-    #endif
-    attachInterrupt(V_MIN_PIN, endstop_ISR, CHANGE);
-  #endif
-  #if HAS_W_MAX
-    #if !AVAILABLE_EILINE(W_MAX_PIN)
-      #error "W_MAX_PIN has no EXTINT line available."
-    #endif
-    attachInterrupt(W_MAX_PIN, endstop_ISR, CHANGE);
-  #endif
-  #if HAS_W_MIN
-    #if !AVAILABLE_EILINE(W_MIN_PIN)
-      #error "W_MIN_PIN has no EXTINT line available."
-    #endif
-    attachInterrupt(W_MIN_PIN, endstop_ISR, CHANGE);
-  #endif
 }

Marlin/src/HAL/STM32/endstop_interrupts.h

@@ -52,10 +52,4 @@ void setup_endstop_interrupts() {
   TERN_(HAS_J_MIN, _ATTACH(J_MIN_PIN));
   TERN_(HAS_K_MAX, _ATTACH(K_MAX_PIN));
   TERN_(HAS_K_MIN, _ATTACH(K_MIN_PIN));
-  TERN_(HAS_U_MAX, _ATTACH(U_MAX_PIN));
-  TERN_(HAS_U_MIN, _ATTACH(U_MIN_PIN));
-  TERN_(HAS_V_MAX, _ATTACH(V_MAX_PIN));
-  TERN_(HAS_V_MIN, _ATTACH(V_MIN_PIN));
-  TERN_(HAS_W_MAX, _ATTACH(W_MAX_PIN));
-  TERN_(HAS_W_MIN, _ATTACH(W_MIN_PIN));
 }

Marlin/src/HAL/STM32/sdio.cpp

@@ -33,157 +33,43 @@
 #include <stdint.h>
 #include <stdbool.h>
 
-// use local drivers
 #if defined(STM32F103xE) || defined(STM32F103xG)
-  #include <stm32f1xx.h>
+  #include <stm32f1xx_hal_rcc_ex.h>
+  #include <stm32f1xx_hal_sd.h>
 #elif defined(STM32F4xx)
-  #include <stm32f4xx.h>
+  #include <stm32f4xx_hal_rcc.h>
+  #include <stm32f4xx_hal_dma.h>
+  #include <stm32f4xx_hal_gpio.h>
+  #include <stm32f4xx_hal_sd.h>
 #elif defined(STM32F7xx)
-  #include <stm32f7xx.h>
+  #include <stm32f7xx_hal_rcc.h>
+  #include <stm32f7xx_hal_dma.h>
+  #include <stm32f7xx_hal_gpio.h>
+  #include <stm32f7xx_hal_sd.h>
 #elif defined(STM32H7xx)
-  #include <stm32h7xx.h>
+  #define SDIO_FOR_STM32H7
+  #include <stm32h7xx_hal_rcc.h>
+  #include <stm32h7xx_hal_dma.h>
+  #include <stm32h7xx_hal_gpio.h>
+  #include <stm32h7xx_hal_sd.h>
 #else
-  #error "SDIO only supported with STM32F103xE, STM32F103xG, STM32F4xx, STM32F7xx, or STM32H7xx."
+  #error "SDIO is only supported with STM32F103xE, STM32F103xG, STM32F4xx, STM32F7xx, and STM32H7xx."
 #endif
 
+// SDIO Max Clock (naming from STM Manual, don't change)
+#define SDIOCLK 48000000
+
 // Target Clock, configurable. Default is 18MHz, from STM32F1
 #ifndef SDIO_CLOCK
   #define SDIO_CLOCK 18000000 // 18 MHz
 #endif
 
-#define SD_TIMEOUT              1000 // ms
-
-// SDIO Max Clock (naming from STM Manual, don't change)
-#define SDIOCLK 48000000
-
-#if defined(STM32F1xx)
-  DMA_HandleTypeDef hdma_sdio;
-  extern "C" void DMA2_Channel4_5_IRQHandler(void) {
-    HAL_DMA_IRQHandler(&hdma_sdio);
-  }
-#elif defined(STM32F4xx)
-  DMA_HandleTypeDef hdma_sdio_rx;
-  DMA_HandleTypeDef hdma_sdio_tx;
-  extern "C" void DMA2_Stream3_IRQHandler(void) {
-    HAL_DMA_IRQHandler(&hdma_sdio_rx);
-  }
-
-  extern "C" void DMA2_Stream6_IRQHandler(void) {
-    HAL_DMA_IRQHandler(&hdma_sdio_tx);
-  }
-#elif defined(STM32H7xx)
-  #define __HAL_RCC_SDIO_FORCE_RESET          __HAL_RCC_SDMMC1_FORCE_RESET
-  #define __HAL_RCC_SDIO_RELEASE_RESET        __HAL_RCC_SDMMC1_RELEASE_RESET
-  #define __HAL_RCC_SDIO_CLK_ENABLE           __HAL_RCC_SDMMC1_CLK_ENABLE
-  #define SDIO                                SDMMC1
-  #define SDIO_IRQn                           SDMMC1_IRQn
-  #define SDIO_IRQHandler                     SDMMC1_IRQHandler
-  #define SDIO_CLOCK_EDGE_RISING              SDMMC_CLOCK_EDGE_RISING
-  #define SDIO_CLOCK_POWER_SAVE_DISABLE       SDMMC_CLOCK_POWER_SAVE_DISABLE
-  #define SDIO_BUS_WIDE_1B                    SDMMC_BUS_WIDE_1B
-  #define SDIO_BUS_WIDE_4B                    SDMMC_BUS_WIDE_4B
-  #define SDIO_HARDWARE_FLOW_CONTROL_DISABLE  SDMMC_HARDWARE_FLOW_CONTROL_DISABLE
-#endif
-
-uint8_t waitingRxCplt = 0;
-uint8_t waitingTxCplt = 0;
-SD_HandleTypeDef hsd;
-
-extern "C" void SDIO_IRQHandler(void) {
-  HAL_SD_IRQHandler(&hsd);
-}
-
-void HAL_SD_TxCpltCallback(SD_HandleTypeDef *hsdio) {
-  waitingTxCplt = 0;
-}
-
-void HAL_SD_RxCpltCallback(SD_HandleTypeDef *hsdio) {
-  waitingRxCplt = 0;
-}
-
-void HAL_SD_MspInit(SD_HandleTypeDef *hsd) {
-  pinmap_pinout(PC_12, PinMap_SD);
-  pinmap_pinout(PD_2, PinMap_SD);
-  pinmap_pinout(PC_8, PinMap_SD);
-  #if PINS_EXIST(SDIO_D1, SDIO_D2, SDIO_D3)  // define D1-D3 only if have a four bit wide SDIO bus
-    // D1-D3
-    pinmap_pinout(PC_9, PinMap_SD);
-    pinmap_pinout(PC_10, PinMap_SD);
-    pinmap_pinout(PC_11, PinMap_SD);
-  #endif
-
-  __HAL_RCC_SDIO_CLK_ENABLE();
-  HAL_NVIC_EnableIRQ(SDIO_IRQn);
-
-  // DMA Config
-  #if defined(STM32F1xx)
-    __HAL_RCC_DMA2_CLK_ENABLE();
-    HAL_NVIC_EnableIRQ(DMA2_Channel4_5_IRQn);
-    hdma_sdio.Instance = DMA2_Channel4;
-    hdma_sdio.Init.Direction = DMA_PERIPH_TO_MEMORY;
-    hdma_sdio.Init.PeriphInc = DMA_PINC_DISABLE;
-    hdma_sdio.Init.MemInc = DMA_MINC_ENABLE;
-    hdma_sdio.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
-    hdma_sdio.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
-    hdma_sdio.Init.Mode = DMA_NORMAL;
-    hdma_sdio.Init.Priority = DMA_PRIORITY_LOW;
-    HAL_DMA_Init(&hdma_sdio);
-
-    __HAL_LINKDMA(hsd, hdmarx ,hdma_sdio);
-    __HAL_LINKDMA(hsd, hdmatx, hdma_sdio);
-  #elif defined(STM32F4xx)
-    __HAL_RCC_DMA2_CLK_ENABLE();
-    HAL_NVIC_EnableIRQ(DMA2_Stream3_IRQn);
-    HAL_NVIC_EnableIRQ(DMA2_Stream6_IRQn);
-    hdma_sdio_rx.Instance = DMA2_Stream3;
-    hdma_sdio_rx.Init.Channel = DMA_CHANNEL_4;
-    hdma_sdio_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
-    hdma_sdio_rx.Init.PeriphInc = DMA_PINC_DISABLE;
-    hdma_sdio_rx.Init.MemInc = DMA_MINC_ENABLE;
-    hdma_sdio_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
-    hdma_sdio_rx.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
-    hdma_sdio_rx.Init.Mode = DMA_PFCTRL;
-    hdma_sdio_rx.Init.Priority = DMA_PRIORITY_LOW;
-    hdma_sdio_rx.Init.FIFOMode = DMA_FIFOMODE_ENABLE;
-    hdma_sdio_rx.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;
-    hdma_sdio_rx.Init.MemBurst = DMA_MBURST_INC4;
-    hdma_sdio_rx.Init.PeriphBurst = DMA_PBURST_INC4;
-    HAL_DMA_Init(&hdma_sdio_rx);
-
-    __HAL_LINKDMA(hsd,hdmarx,hdma_sdio_rx);
-
-    hdma_sdio_tx.Instance = DMA2_Stream6;
-    hdma_sdio_tx.Init.Channel = DMA_CHANNEL_4;
-    hdma_sdio_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
-    hdma_sdio_tx.Init.PeriphInc = DMA_PINC_DISABLE;
-    hdma_sdio_tx.Init.MemInc = DMA_MINC_ENABLE;
-    hdma_sdio_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
-    hdma_sdio_tx.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
-    hdma_sdio_tx.Init.Mode = DMA_PFCTRL;
-    hdma_sdio_tx.Init.Priority = DMA_PRIORITY_LOW;
-    hdma_sdio_tx.Init.FIFOMode = DMA_FIFOMODE_ENABLE;
-    hdma_sdio_tx.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;
-    hdma_sdio_tx.Init.MemBurst = DMA_MBURST_INC4;
-    hdma_sdio_tx.Init.PeriphBurst = DMA_PBURST_INC4;
-    HAL_DMA_Init(&hdma_sdio_tx);
-
-    __HAL_LINKDMA(hsd,hdmatx,hdma_sdio_tx);
-  #endif
-}
-
-void HAL_SD_MspDeInit(SD_HandleTypeDef *hsd) {
-  #if !defined(STM32F1xx)
-    __HAL_RCC_SDIO_FORCE_RESET();
-    delay(10);
-    __HAL_RCC_SDIO_RELEASE_RESET();
-    delay(10);
-  #endif
-}
+SD_HandleTypeDef hsd;  // SDIO structure
 
 static uint32_t clock_to_divider(uint32_t clk) {
-  #if defined(STM32H7xx)
+  #ifdef SDIO_FOR_STM32H7
     // SDMMC_CK frequency = sdmmc_ker_ck / [2 * CLKDIV].
-    uint32_t sdmmc_clk     = HAL_RCCEx_GetPeriphCLKFreq(RCC_PERIPHCLK_SDMMC);
+    uint32_t sdmmc_clk = HAL_RCCEx_GetPeriphCLKFreq(RCC_PERIPHCLK_SDMMC);
     return sdmmc_clk / (2U * SDIO_CLOCK) + (sdmmc_clk % (2U * SDIO_CLOCK) != 0);
   #else
     // limit the SDIO master clock to 8/3 of PCLK2. See STM32 Manuals
@@ -198,62 +84,359 @@ static uint32_t clock_to_divider(uint32_t clk) {
   #endif
 }
 
-bool SDIO_Init() {
-  HAL_StatusTypeDef sd_state = HAL_OK;
-  if (hsd.Instance == SDIO)
-    HAL_SD_DeInit(&hsd);
-
-  /* HAL SD initialization */
-  hsd.Instance = SDIO;
-  hsd.Init.ClockEdge = SDIO_CLOCK_EDGE_RISING;
-  hsd.Init.ClockPowerSave = SDIO_CLOCK_POWER_SAVE_DISABLE;
-  hsd.Init.BusWide = SDIO_BUS_WIDE_1B;
-  hsd.Init.HardwareFlowControl = SDIO_HARDWARE_FLOW_CONTROL_DISABLE;
-  hsd.Init.ClockDiv = clock_to_divider(SDIO_CLOCK);
-  sd_state = HAL_SD_Init(&hsd);
-
-  #if PINS_EXIST(SDIO_D1, SDIO_D2, SDIO_D3)
-    if (sd_state == HAL_OK) {
-      sd_state = HAL_SD_ConfigWideBusOperation(&hsd, SDIO_BUS_WIDE_4B);
-    }
+// Start the SDIO clock
+void HAL_SD_MspInit(SD_HandleTypeDef *hsd) {
+  UNUSED(hsd);
+  #ifdef SDIO_FOR_STM32H7
+    pinmap_pinout(PC_12, PinMap_SD);
+    pinmap_pinout(PD_2,  PinMap_SD);
+    pinmap_pinout(PC_8,  PinMap_SD);
+    #if PINS_EXIST(SDIO_D1, SDIO_D2, SDIO_D3)  // Define D1-D3 only for 4-bit wide SDIO bus
+      pinmap_pinout(PC_9,  PinMap_SD);
+      pinmap_pinout(PC_10, PinMap_SD);
+      pinmap_pinout(PC_11, PinMap_SD);
+    #endif
+    __HAL_RCC_SDMMC1_CLK_ENABLE();
+    HAL_NVIC_EnableIRQ(SDMMC1_IRQn);
+  #else
+    __HAL_RCC_SDIO_CLK_ENABLE();
   #endif
-
-  return (sd_state == HAL_OK) ? true : false;
 }
 
-bool SDIO_ReadBlock(uint32_t block, uint8_t *dst) {
-  uint32_t timeout = HAL_GetTick() + SD_TIMEOUT;
+#ifdef SDIO_FOR_STM32H7
 
-  while (HAL_SD_GetCardState(&hsd) != HAL_SD_CARD_TRANSFER) {
-    if (HAL_GetTick() >= timeout) return false;
+  #define SD_TIMEOUT              1000 // ms
+
+  extern "C" void SDMMC1_IRQHandler(void) { HAL_SD_IRQHandler(&hsd); }
+
+  uint8_t waitingRxCplt = 0, waitingTxCplt = 0;
+  void HAL_SD_TxCpltCallback(SD_HandleTypeDef *hsdio) { waitingTxCplt = 0; }
+  void HAL_SD_RxCpltCallback(SD_HandleTypeDef *hsdio) { waitingRxCplt = 0; }
+
+  void HAL_SD_MspDeInit(SD_HandleTypeDef *hsd) {
+    __HAL_RCC_SDMMC1_FORCE_RESET();   delay(10);
+    __HAL_RCC_SDMMC1_RELEASE_RESET(); delay(10);
   }
 
-  waitingRxCplt = 1;
-  if (HAL_SD_ReadBlocks_DMA(&hsd, (uint8_t *)dst, block, 1) != HAL_OK)
+  bool SDIO_Init() {
+    HAL_StatusTypeDef sd_state = HAL_OK;
+    if (hsd.Instance == SDMMC1) HAL_SD_DeInit(&hsd);
+
+    // HAL SD initialization
+    hsd.Instance = SDMMC1;
+    hsd.Init.ClockEdge = SDMMC_CLOCK_EDGE_RISING;
+    hsd.Init.ClockPowerSave = SDMMC_CLOCK_POWER_SAVE_DISABLE;
+    hsd.Init.BusWide = SDMMC_BUS_WIDE_1B;
+    hsd.Init.HardwareFlowControl = SDMMC_HARDWARE_FLOW_CONTROL_DISABLE;
+    hsd.Init.ClockDiv = clock_to_divider(SDIO_CLOCK);
+    sd_state = HAL_SD_Init(&hsd);
+
+    #if PINS_EXIST(SDIO_D1, SDIO_D2, SDIO_D3)
+      if (sd_state == HAL_OK)
+        sd_state = HAL_SD_ConfigWideBusOperation(&hsd, SDMMC_BUS_WIDE_4B);
+    #endif
+
+    return (sd_state == HAL_OK);
+  }
+
+#else // !SDIO_FOR_STM32H7
+
+  #define SD_TIMEOUT               500 // ms
+
+  // SDIO retries, configurable. Default is 3, from STM32F1
+  #ifndef SDIO_READ_RETRIES
+    #define SDIO_READ_RETRIES 3
+  #endif
+
+  // F4 supports one DMA for RX and another for TX, but Marlin will never
+  // do read and write at same time, so we use the same DMA for both.
+  DMA_HandleTypeDef hdma_sdio;
+
+  #ifdef STM32F1xx
+    #define DMA_IRQ_HANDLER DMA2_Channel4_5_IRQHandler
+  #elif defined(STM32F4xx)
+    #define DMA_IRQ_HANDLER DMA2_Stream3_IRQHandler
+  #else
+    #error "Unknown STM32 architecture."
+  #endif
+
+  extern "C" void SDIO_IRQHandler(void) { HAL_SD_IRQHandler(&hsd); }
+  extern "C" void DMA_IRQ_HANDLER(void) { HAL_DMA_IRQHandler(&hdma_sdio); }
+
+  /*
+    SDIO_INIT_CLK_DIV is 118
+    SDIO clock frequency is 48MHz / (TRANSFER_CLOCK_DIV + 2)
+    SDIO init clock frequency should not exceed 400kHz = 48MHz / (118 + 2)
+
+    Default TRANSFER_CLOCK_DIV is 2 (118 / 40)
+    Default SDIO clock frequency is 48MHz / (2 + 2) = 12 MHz
+    This might be too fast for stable SDIO operations
+
+    MKS Robin SDIO seems stable with BusWide 1bit and ClockDiv 8 (i.e., 4.8MHz SDIO clock frequency)
+    More testing is required as there are clearly some 4bit init problems.
+  */
+
+  void go_to_transfer_speed() {
+    /* Default SDIO peripheral configuration for SD card initialization */
+    hsd.Init.ClockEdge           = hsd.Init.ClockEdge;
+    hsd.Init.ClockBypass         = hsd.Init.ClockBypass;
+    hsd.Init.ClockPowerSave      = hsd.Init.ClockPowerSave;
+    hsd.Init.BusWide             = hsd.Init.BusWide;
+    hsd.Init.HardwareFlowControl = hsd.Init.HardwareFlowControl;
+    hsd.Init.ClockDiv            = clock_to_divider(SDIO_CLOCK);
+
+    /* Initialize SDIO peripheral interface with default configuration */
+    SDIO_Init(hsd.Instance, hsd.Init);
+  }
+
+  void SD_LowLevel_Init() {
+    uint32_t tempreg;
+
+    // Enable GPIO clocks
+    __HAL_RCC_GPIOC_CLK_ENABLE();
+    __HAL_RCC_GPIOD_CLK_ENABLE();
+
+    GPIO_InitTypeDef  GPIO_InitStruct;
+
+    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+    GPIO_InitStruct.Pull = 1;  // GPIO_NOPULL
+    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
+
+    #if DISABLED(STM32F1xx)
+      GPIO_InitStruct.Alternate = GPIO_AF12_SDIO;
+    #endif
+
+    GPIO_InitStruct.Pin = GPIO_PIN_8 | GPIO_PIN_12;  // D0 & SCK
+    HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
+
+    #if PINS_EXIST(SDIO_D1, SDIO_D2, SDIO_D3)  // define D1-D3 only if have a four bit wide SDIO bus
+      GPIO_InitStruct.Pin = GPIO_PIN_9 | GPIO_PIN_10 | GPIO_PIN_11;  // D1-D3
+      HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
+    #endif
+
+    // Configure PD.02 CMD line
+    GPIO_InitStruct.Pin = GPIO_PIN_2;
+    HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
+
+    // Setup DMA
+    #ifdef STM32F1xx
+      hdma_sdio.Init.Mode = DMA_NORMAL;
+      hdma_sdio.Instance = DMA2_Channel4;
+      HAL_NVIC_EnableIRQ(DMA2_Channel4_5_IRQn);
+    #elif defined(STM32F4xx)
+      hdma_sdio.Init.Mode = DMA_PFCTRL;
+      hdma_sdio.Instance = DMA2_Stream3;
+      hdma_sdio.Init.Channel = DMA_CHANNEL_4;
+      hdma_sdio.Init.FIFOMode = DMA_FIFOMODE_ENABLE;
+      hdma_sdio.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;
+      hdma_sdio.Init.MemBurst = DMA_MBURST_INC4;
+      hdma_sdio.Init.PeriphBurst = DMA_PBURST_INC4;
+      HAL_NVIC_EnableIRQ(DMA2_Stream3_IRQn);
+    #endif
+    HAL_NVIC_EnableIRQ(SDIO_IRQn);
+    hdma_sdio.Init.PeriphInc = DMA_PINC_DISABLE;
+    hdma_sdio.Init.MemInc = DMA_MINC_ENABLE;
+    hdma_sdio.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
+    hdma_sdio.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
+    hdma_sdio.Init.Priority = DMA_PRIORITY_LOW;
+    __HAL_LINKDMA(&hsd, hdmarx, hdma_sdio);
+    __HAL_LINKDMA(&hsd, hdmatx, hdma_sdio);
+
+    #ifdef STM32F1xx
+      __HAL_RCC_SDIO_CLK_ENABLE();
+      __HAL_RCC_DMA2_CLK_ENABLE();
+    #else
+      __HAL_RCC_SDIO_FORCE_RESET();   delay(2);
+      __HAL_RCC_SDIO_RELEASE_RESET(); delay(2);
+      __HAL_RCC_SDIO_CLK_ENABLE();
+
+      __HAL_RCC_DMA2_FORCE_RESET();   delay(2);
+      __HAL_RCC_DMA2_RELEASE_RESET(); delay(2);
+      __HAL_RCC_DMA2_CLK_ENABLE();
+    #endif
+
+    // Initialize the SDIO (with initial <400Khz Clock)
+    tempreg = 0                   // Reset value
+            | SDIO_CLKCR_CLKEN    // Clock enabled
+            | SDIO_INIT_CLK_DIV;  // Clock Divider. Clock = 48000 / (118 + 2) = 400Khz
+                                  // Keep the rest at 0 => HW_Flow Disabled, Rising Clock Edge, Disable CLK ByPass, Bus Width = 0, Power save Disable
+    SDIO->CLKCR = tempreg;
+
+    // Power up the SDIO
+    SDIO_PowerState_ON(SDIO);
+    hsd.Instance = SDIO;
+  }
+
+  bool SDIO_Init() {
+    uint8_t retryCnt = SDIO_READ_RETRIES;
+
+    bool status;
+    hsd.Instance = SDIO;
+    hsd.State = HAL_SD_STATE_RESET;
+
+    SD_LowLevel_Init();
+
+    uint8_t retry_Cnt = retryCnt;
+    for (;;) {
+      hal.watchdog_refresh();
+      status = (bool) HAL_SD_Init(&hsd);
+      if (!status) break;
+      if (!--retry_Cnt) return false;   // return failing status if retries are exhausted
+    }
+
+    go_to_transfer_speed();
+
+    #if PINS_EXIST(SDIO_D1, SDIO_D2, SDIO_D3) // go to 4 bit wide mode if pins are defined
+      retry_Cnt = retryCnt;
+      for (;;) {
+        hal.watchdog_refresh();
+        if (!HAL_SD_ConfigWideBusOperation(&hsd, SDIO_BUS_WIDE_4B)) break;  // some cards are only 1 bit wide so a pass here is not required
+        if (!--retry_Cnt) break;
+      }
+      if (!retry_Cnt) {  // wide bus failed, go back to one bit wide mode
+        hsd.State = (HAL_SD_StateTypeDef) 0;  // HAL_SD_STATE_RESET
+        SD_LowLevel_Init();
+        retry_Cnt = retryCnt;
+        for (;;) {
+          hal.watchdog_refresh();
+          status = (bool) HAL_SD_Init(&hsd);
+          if (!status) break;
+          if (!--retry_Cnt) return false;   // return failing status if retries are exhausted
+        }
+        go_to_transfer_speed();
+      }
+    #endif
+
+    return true;
+  }
+
+  /**
+   * @brief Read or Write a block
+   * @details Read or Write a block with SDIO
+   *
+   * @param block The block index
+   * @param src The data buffer source for a write
+   * @param dst The data buffer destination for a read
+   *
+   * @return true on success
+   */
+  static bool SDIO_ReadWriteBlock_DMA(uint32_t block, const uint8_t *src, uint8_t *dst) {
+    if (HAL_SD_GetCardState(&hsd) != HAL_SD_CARD_TRANSFER) return false;
+
+    hal.watchdog_refresh();
+
+    HAL_StatusTypeDef ret;
+    if (src) {
+      hdma_sdio.Init.Direction = DMA_MEMORY_TO_PERIPH;
+      HAL_DMA_Init(&hdma_sdio);
+      ret = HAL_SD_WriteBlocks_DMA(&hsd, (uint8_t*)src, block, 1);
+    }
+    else {
+      hdma_sdio.Init.Direction = DMA_PERIPH_TO_MEMORY;
+      HAL_DMA_Init(&hdma_sdio);
+      ret = HAL_SD_ReadBlocks_DMA(&hsd, (uint8_t*)dst, block, 1);
+    }
+
+    if (ret != HAL_OK) {
+      HAL_DMA_Abort_IT(&hdma_sdio);
+      HAL_DMA_DeInit(&hdma_sdio);
+      return false;
+    }
+
+    millis_t timeout = millis() + SD_TIMEOUT;
+    // Wait the transfer
+    while (hsd.State != HAL_SD_STATE_READY) {
+      if (ELAPSED(millis(), timeout)) {
+        HAL_DMA_Abort_IT(&hdma_sdio);
+        HAL_DMA_DeInit(&hdma_sdio);
+        return false;
+      }
+    }
+
+    while (__HAL_DMA_GET_FLAG(&hdma_sdio, __HAL_DMA_GET_TC_FLAG_INDEX(&hdma_sdio)) != 0
+        || __HAL_DMA_GET_FLAG(&hdma_sdio, __HAL_DMA_GET_TE_FLAG_INDEX(&hdma_sdio)) != 0) { /* nada */ }
+
+    HAL_DMA_Abort_IT(&hdma_sdio);
+    HAL_DMA_DeInit(&hdma_sdio);
+
+    timeout = millis() + SD_TIMEOUT;
+    while (HAL_SD_GetCardState(&hsd) != HAL_SD_CARD_TRANSFER) if (ELAPSED(millis(), timeout)) return false;
+
+    return true;
+  }
+
+#endif // !SDIO_FOR_STM32H7
+
+/**
+ * @brief Read a block
+ * @details Read a block from media with SDIO
+ *
+ * @param block The block index
+ * @param src The block buffer
+ *
+ * @return true on success
+ */
+bool SDIO_ReadBlock(uint32_t block, uint8_t *dst) {
+  #ifdef SDIO_FOR_STM32H7
+
+    uint32_t timeout = HAL_GetTick() + SD_TIMEOUT;
+
+    while (HAL_SD_GetCardState(&hsd) != HAL_SD_CARD_TRANSFER)
+      if (HAL_GetTick() >= timeout) return false;
+
+    waitingRxCplt = 1;
+    if (HAL_SD_ReadBlocks_DMA(&hsd, (uint8_t*)dst, block, 1) != HAL_OK)
+      return false;
+
+    timeout = HAL_GetTick() + SD_TIMEOUT;
+    while (waitingRxCplt)
+      if (HAL_GetTick() >= timeout) return false;
+
+    return true;
+
+  #else
+
+    uint8_t retries = SDIO_READ_RETRIES;
+    while (retries--) if (SDIO_ReadWriteBlock_DMA(block, nullptr, dst)) return true;
     return false;
 
-  timeout = HAL_GetTick() + SD_TIMEOUT;
-  while (waitingRxCplt)
-    if (HAL_GetTick() >= timeout) return false;
-
-  return true;
+  #endif
 }
 
+/**
+ * @brief Write a block
+ * @details Write a block to media with SDIO
+ *
+ * @param block The block index
+ * @param src The block data
+ *
+ * @return true on success
+ */
 bool SDIO_WriteBlock(uint32_t block, const uint8_t *src) {
-  uint32_t timeout = HAL_GetTick() + SD_TIMEOUT;
+  #ifdef SDIO_FOR_STM32H7
 
-  while (HAL_SD_GetCardState(&hsd) != HAL_SD_CARD_TRANSFER)
-    if (HAL_GetTick() >= timeout) return false;
+    uint32_t timeout = HAL_GetTick() + SD_TIMEOUT;
 
-  waitingTxCplt = 1;
-  if (HAL_SD_WriteBlocks_DMA(&hsd, (uint8_t *)src, block, 1) != HAL_OK)
+    while (HAL_SD_GetCardState(&hsd) != HAL_SD_CARD_TRANSFER)
+      if (HAL_GetTick() >= timeout) return false;
+
+    waitingTxCplt = 1;
+    if (HAL_SD_WriteBlocks_DMA(&hsd, (uint8_t*)src, block, 1) != HAL_OK)
+      return false;
+
+    timeout = HAL_GetTick() + SD_TIMEOUT;
+    while (waitingTxCplt)
+      if (HAL_GetTick() >= timeout) return false;
+
+    return true;
+
+  #else
+
+    uint8_t retries = SDIO_READ_RETRIES;
+    while (retries--) if (SDIO_ReadWriteBlock_DMA(block, src, nullptr)) return true;
     return false;
 
-  timeout = HAL_GetTick() + SD_TIMEOUT;
-  while (waitingTxCplt)
-    if (HAL_GetTick() >= timeout) return false;
-
-  return true;
+  #endif
 }
 
 bool SDIO_IsReady() {

Marlin/src/HAL/STM32/tft/gt911.cpp

@@ -159,24 +159,28 @@ void GT911::read_reg(uint16_t reg, uint8_t reg_len, uint8_t* r_data, uint8_t r_l
 void GT911::Init() {
   OUT_WRITE(GT911_RST_PIN, LOW);
   OUT_WRITE(GT911_INT_PIN, LOW);
-  delay(20);
+  delay(11);
+  WRITE(GT911_INT_PIN, HIGH);
+  delayMicroseconds(110);
   WRITE(GT911_RST_PIN, HIGH);
+  delay(6);
+  WRITE(GT911_INT_PIN, LOW);
+  delay(55);
   SET_INPUT(GT911_INT_PIN);
 
   sw_iic.init();
 
-  uint8_t clear_reg = 0x0000;
-  write_reg(0x814E, 2, &clear_reg, 2); // Reset to 0 for start
+  uint8_t clear_reg = 0x00;
+  write_reg(0x814E, 2, &clear_reg, 1); // Reset to 0 for start
 }
 
 bool GT911::getFirstTouchPoint(int16_t *x, int16_t *y) {
   read_reg(0x814E, 2, &reg.REG.status, 1);
 
-  if (reg.REG.status & 0x80) {
+  if (reg.REG.status >= 0x80 && reg.REG.status <= 0x85) {
+    read_reg(0x8150, 2, reg.map + 2, 38);
     uint8_t clear_reg = 0x00;
     write_reg(0x814E, 2, &clear_reg, 1); // Reset to 0 for start
-    read_reg(0x8150, 2, reg.map + 2, 8 * (reg.REG.status & 0x0F));
-
     // First touch point
     *x = ((reg.REG.point[0].xh & 0x0F) << 8) | reg.REG.point[0].xl;
     *y = ((reg.REG.point[0].yh & 0x0F) << 8) | reg.REG.point[0].yl;

Marlin/src/HAL/STM32/tft/gt911.h

@@ -23,7 +23,7 @@
 
 #include "../../../inc/MarlinConfig.h"
 
-#define GT911_SLAVE_ADDRESS   0xBA
+#define GT911_SLAVE_ADDRESS   0x28
 
 #if !PIN_EXISTS(GT911_RST)
   #error "GT911_RST_PIN is not defined."

Marlin/src/HAL/STM32/tft/tft_ltdc.cpp

@@ -372,9 +372,9 @@ void TFT_LTDC::TransmitDMA(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Cou
     if (MemoryIncrease == DMA_PINC_ENABLE) {
       DrawImage(x_min, y_cur, x_min + width, y_cur + height, Data);
       Data += width * height;
-    } else {
-      DrawRect(x_min, y_cur, x_min + width, y_cur + height, *Data);
     }
+    else
+      DrawRect(x_min, y_cur, x_min + width, y_cur + height, *Data);
     y_cur += height;
   }
 

Marlin/src/HAL/STM32F1/Servo.cpp

@@ -147,17 +147,17 @@ void libServo::move(const int32_t value) {
     uint16_t SR = timer_get_status(tdev);
     if (SR & TIMER_SR_CC1IF) { // channel 1 off
       #ifdef SERVO0_PWM_OD
-        OUT_WRITE_OD(SERVO0_PIN, 1); // off
+        OUT_WRITE_OD(SERVO0_PIN, HIGH); // off
       #else
-        OUT_WRITE(SERVO0_PIN, 0);
+        OUT_WRITE(SERVO0_PIN, LOW);
       #endif
       timer_reset_status_bit(tdev, TIMER_SR_CC1IF_BIT);
     }
     if (SR & TIMER_SR_CC2IF) { // channel 2 resume
       #ifdef SERVO0_PWM_OD
-        OUT_WRITE_OD(SERVO0_PIN, 0); // on
+        OUT_WRITE_OD(SERVO0_PIN, LOW); // on
       #else
-        OUT_WRITE(SERVO0_PIN, 1);
+        OUT_WRITE(SERVO0_PIN, HIGH);
       #endif
       timer_reset_status_bit(tdev, TIMER_SR_CC2IF_BIT);
     }
@@ -167,9 +167,9 @@ void libServo::move(const int32_t value) {
     timer_dev *tdev = HAL_get_timer_dev(MF_TIMER_SERVO0);
     if (!tdev) return false;
     #ifdef SERVO0_PWM_OD
-      OUT_WRITE_OD(inPin, 1);
+      OUT_WRITE_OD(inPin, HIGH);
     #else
-      OUT_WRITE(inPin, 0);
+      OUT_WRITE(inPin, LOW);
     #endif
 
     timer_pause(tdev);
@@ -200,9 +200,9 @@ void libServo::move(const int32_t value) {
       timer_disable_irq(tdev, 1);
       timer_disable_irq(tdev, 2);
       #ifdef SERVO0_PWM_OD
-        OUT_WRITE_OD(pin, 1); // off
+        OUT_WRITE_OD(pin, HIGH); // off
       #else
-        OUT_WRITE(pin, 0);
+        OUT_WRITE(pin, LOW);
       #endif
     }
   }

Marlin/src/HAL/STM32F1/endstop_interrupts.h

@@ -77,10 +77,4 @@ void setup_endstop_interrupts() {
   TERN_(HAS_J_MIN, _ATTACH(J_MIN_PIN));
   TERN_(HAS_K_MAX, _ATTACH(K_MAX_PIN));
   TERN_(HAS_K_MIN, _ATTACH(K_MIN_PIN));
-  TERN_(HAS_U_MAX, _ATTACH(U_MAX_PIN));
-  TERN_(HAS_U_MIN, _ATTACH(U_MIN_PIN));
-  TERN_(HAS_V_MAX, _ATTACH(V_MAX_PIN));
-  TERN_(HAS_V_MIN, _ATTACH(V_MIN_PIN));
-  TERN_(HAS_W_MAX, _ATTACH(W_MAX_PIN));
-  TERN_(HAS_W_MIN, _ATTACH(W_MIN_PIN));
 }

Marlin/src/HAL/TEENSY31_32/endstop_interrupts.h

@@ -70,10 +70,4 @@ void setup_endstop_interrupts() {
   TERN_(HAS_J_MIN, _ATTACH(J_MIN_PIN));
   TERN_(HAS_K_MAX, _ATTACH(K_MAX_PIN));
   TERN_(HAS_K_MIN, _ATTACH(K_MIN_PIN));
-  TERN_(HAS_U_MAX, _ATTACH(U_MAX_PIN));
-  TERN_(HAS_U_MIN, _ATTACH(U_MIN_PIN));
-  TERN_(HAS_V_MAX, _ATTACH(V_MAX_PIN));
-  TERN_(HAS_V_MIN, _ATTACH(V_MIN_PIN));
-  TERN_(HAS_W_MAX, _ATTACH(W_MAX_PIN));
-  TERN_(HAS_W_MIN, _ATTACH(W_MIN_PIN));
 }

Marlin/src/HAL/TEENSY35_36/endstop_interrupts.h

@@ -69,10 +69,4 @@ void setup_endstop_interrupts() {
   TERN_(HAS_J_MIN, _ATTACH(J_MIN_PIN));
   TERN_(HAS_K_MAX, _ATTACH(K_MAX_PIN));
   TERN_(HAS_K_MIN, _ATTACH(K_MIN_PIN));
-  TERN_(HAS_U_MAX, _ATTACH(U_MAX_PIN));
-  TERN_(HAS_U_MIN, _ATTACH(U_MIN_PIN));
-  TERN_(HAS_V_MAX, _ATTACH(V_MAX_PIN));
-  TERN_(HAS_V_MIN, _ATTACH(V_MIN_PIN));
-  TERN_(HAS_W_MAX, _ATTACH(W_MAX_PIN));
-  TERN_(HAS_W_MIN, _ATTACH(W_MIN_PIN));
 }

Marlin/src/HAL/shared/backtrace/unwarmbytab.cpp

@@ -135,11 +135,11 @@ static UnwResult UnwTabExecuteInstructions(const UnwindCallbacks *cb, UnwTabStat
   while ((instruction = UnwTabGetNextInstruction(cb, ucb)) != -1) {
 
     if ((instruction & 0xC0) == 0x00) { // ARM_EXIDX_CMD_DATA_POP
-      /* vsp = vsp + (xxxxxx << 2) + 4 */
+      /* vsp += (xxxxxx << 2) + 4 */
       ucb->vrs[13] += ((instruction & 0x3F) << 2) + 4;
     }
     else if ((instruction & 0xC0) == 0x40) { // ARM_EXIDX_CMD_DATA_PUSH
-      /* vsp = vsp - (xxxxxx << 2) - 4 */
+      /* vsp -= (xxxxxx << 2) - 4 */
       ucb->vrs[13] -= ((instruction & 0x3F) << 2) - 4;
     }
     else if ((instruction & 0xF0) == 0x80) {

Marlin/src/HAL/shared/servo.cpp

@@ -65,7 +65,7 @@ uint8_t ServoCount = 0;                         // the total number of attached
 
 /************ static functions common to all instances ***********************/
 
-static boolean isTimerActive(timer16_Sequence_t timer) {
+static bool anyTimerChannelActive(const timer16_Sequence_t timer) {
   // returns true if any servo is active on this timer
   LOOP_L_N(channel, SERVOS_PER_TIMER) {
     if (SERVO(timer, channel).Pin.isActive)
@@ -101,17 +101,18 @@ int8_t Servo::attach(const int inPin, const int inMin, const int inMax) {
   max = (MAX_PULSE_WIDTH - inMax) / 4;
 
   // initialize the timer if it has not already been initialized
-  timer16_Sequence_t timer = SERVO_INDEX_TO_TIMER(servoIndex);
-  if (!isTimerActive(timer)) initISR(timer);
-  servo_info[servoIndex].Pin.isActive = true;  // this must be set after the check for isTimerActive
+  const timer16_Sequence_t timer = SERVO_INDEX_TO_TIMER(servoIndex);
+  if (!anyTimerChannelActive(timer)) initISR(timer);
+  servo_info[servoIndex].Pin.isActive = true;  // this must be set after the check for anyTimerChannelActive
 
   return servoIndex;
 }
 
 void Servo::detach() {
   servo_info[servoIndex].Pin.isActive = false;
-  timer16_Sequence_t timer = SERVO_INDEX_TO_TIMER(servoIndex);
-  if (!isTimerActive(timer)) finISR(timer);
+  const timer16_Sequence_t timer = SERVO_INDEX_TO_TIMER(servoIndex);
+  if (!anyTimerChannelActive(timer)) finISR(timer);
+  //pinMode(servo_info[servoIndex].Pin.nbr, INPUT); // set servo pin to input
 }
 
 void Servo::write(int value) {

Marlin/src/HAL/shared/servo_private.h

@@ -70,10 +70,10 @@
 #define ticksToUs(_ticks) (unsigned(_ticks) * (SERVO_TIMER_PRESCALER) / clockCyclesPerMicrosecond())
 
 // convenience macros
-#define SERVO_INDEX_TO_TIMER(_servo_nbr) ((timer16_Sequence_t)(_servo_nbr / (SERVOS_PER_TIMER))) // returns the timer controlling this servo
-#define SERVO_INDEX_TO_CHANNEL(_servo_nbr) (_servo_nbr % (SERVOS_PER_TIMER))       // returns the index of the servo on this timer
-#define SERVO_INDEX(_timer,_channel)  ((_timer*(SERVOS_PER_TIMER)) + _channel)     // macro to access servo index by timer and channel
-#define SERVO(_timer,_channel)  (servo_info[SERVO_INDEX(_timer,_channel)])       // macro to access servo class by timer and channel
+#define SERVO_INDEX_TO_TIMER(_servo_nbr) timer16_Sequence_t(_servo_nbr / (SERVOS_PER_TIMER)) // the timer controlling this servo
+#define SERVO_INDEX_TO_CHANNEL(_servo_nbr) (_servo_nbr % (SERVOS_PER_TIMER))      // the index of the servo on this timer
+#define SERVO_INDEX(_timer,_channel)  ((_timer*(SERVOS_PER_TIMER)) + _channel)    // servo index by timer and channel
+#define SERVO(_timer,_channel)  servo_info[SERVO_INDEX(_timer,_channel)]          // servo class by timer and channel
 
 // Types
 
@@ -94,5 +94,5 @@ extern ServoInfo_t servo_info[MAX_SERVOS];
 
 // Public functions
 
-extern void initISR(timer16_Sequence_t timer);
-extern void finISR(timer16_Sequence_t timer);
+void initISR(const timer16_Sequence_t timer_index);
+void finISR(const timer16_Sequence_t timer_index);

Marlin/src/MarlinCore.cpp

@@ -443,9 +443,6 @@ inline void manage_inactivity(const bool no_stepper_sleep=false) {
           TERN_(DISABLE_INACTIVE_I, stepper.disable_axis(I_AXIS));
           TERN_(DISABLE_INACTIVE_J, stepper.disable_axis(J_AXIS));
           TERN_(DISABLE_INACTIVE_K, stepper.disable_axis(K_AXIS));
-          TERN_(DISABLE_INACTIVE_U, stepper.disable_axis(U_AXIS));
-          TERN_(DISABLE_INACTIVE_V, stepper.disable_axis(V_AXIS));
-          TERN_(DISABLE_INACTIVE_W, stepper.disable_axis(W_AXIS));
           TERN_(DISABLE_INACTIVE_E, stepper.disable_e_steppers());
 
           TERN_(AUTO_BED_LEVELING_UBL, bedlevel.steppers_were_disabled());
@@ -785,7 +782,7 @@ void idle(bool no_stepper_sleep/*=false*/) {
   manage_inactivity(no_stepper_sleep);
 
   // Manage Heaters (and Watchdog)
-  thermalManager.manage_heater();
+  thermalManager.task();
 
   // Max7219 heartbeat, animation, etc
   TERN_(MAX7219_DEBUG, max7219.idle_tasks());
@@ -1006,15 +1003,6 @@ inline void tmc_standby_setup() {
   #if PIN_EXISTS(K_STDBY)
     SET_INPUT_PULLDOWN(K_STDBY_PIN);
   #endif
-  #if PIN_EXISTS(U_STDBY)
-    SET_INPUT_PULLDOWN(U_STDBY_PIN);
-  #endif
-  #if PIN_EXISTS(V_STDBY)
-    SET_INPUT_PULLDOWN(V_STDBY_PIN);
-  #endif
-  #if PIN_EXISTS(W_STDBY)
-    SET_INPUT_PULLDOWN(W_STDBY_PIN);
-  #endif
   #if PIN_EXISTS(E0_STDBY)
     SET_INPUT_PULLDOWN(E0_STDBY_PIN);
   #endif

Marlin/src/core/boards.h

@@ -238,6 +238,7 @@
 #define BOARD_BTT_SKR_V1_1            2012  // BigTreeTech SKR v1.1
 #define BOARD_BTT_SKR_V1_3            2013  // BigTreeTech SKR v1.3
 #define BOARD_BTT_SKR_V1_4            2014  // BigTreeTech SKR v1.4
+#define BOARD_EMOTRONIC               2015  // eMotion-Tech eMotronic
 
 //
 // LPC1769 ARM Cortex M3
@@ -332,40 +333,41 @@
 #define BOARD_BTT_SKR_E3_DIP          4029  // BigTreeTech SKR E3 DIP V1.0 (STM32F103RC / STM32F103RE)
 #define BOARD_BTT_SKR_CR6             4030  // BigTreeTech SKR CR6 v1.0 (STM32F103RE)
 #define BOARD_JGAURORA_A5S_A1         4031  // JGAurora A5S A1 (STM32F103ZE)
-#define BOARD_FYSETC_AIO_II           4032  // FYSETC AIO_II
-#define BOARD_FYSETC_CHEETAH          4033  // FYSETC Cheetah
-#define BOARD_FYSETC_CHEETAH_V12      4034  // FYSETC Cheetah V1.2
-#define BOARD_LONGER3D_LK             4035  // Alfawise U20/U20+/U30 (Longer3D LK1/2) / STM32F103VE
+#define BOARD_FYSETC_AIO_II           4032  // FYSETC AIO_II (STM32F103RC)
+#define BOARD_FYSETC_CHEETAH          4033  // FYSETC Cheetah (STM32F103RC)
+#define BOARD_FYSETC_CHEETAH_V12      4034  // FYSETC Cheetah V1.2 (STM32F103RC)
+#define BOARD_LONGER3D_LK             4035  // Longer3D LK1/2 - Alfawise U20/U20+/U30 (STM32F103VE)
 #define BOARD_CCROBOT_MEEB_3DP        4036  // ccrobot-online.com MEEB_3DP (STM32F103RC)
-#define BOARD_CHITU3D_V5              4037  // Chitu3D TronXY X5SA V5 Board
-#define BOARD_CHITU3D_V6              4038  // Chitu3D TronXY X5SA V6 Board
-#define BOARD_CHITU3D_V9              4039  // Chitu3D TronXY X5SA V9 Board
+#define BOARD_CHITU3D_V5              4037  // Chitu3D TronXY X5SA V5 Board (STM32F103ZE)
+#define BOARD_CHITU3D_V6              4038  // Chitu3D TronXY X5SA V6 Board (STM32F103ZE)
+#define BOARD_CHITU3D_V9              4039  // Chitu3D TronXY X5SA V9 Board (STM32F103ZE)
 #define BOARD_CREALITY_V4             4040  // Creality v4.x (STM32F103RC / STM32F103RE)
 #define BOARD_CREALITY_V422           4041  // Creality v4.2.2 (STM32F103RC / STM32F103RE)
 #define BOARD_CREALITY_V423           4042  // Creality v4.2.3 (STM32F103RC / STM32F103RE)
-#define BOARD_CREALITY_V427           4043  // Creality v4.2.7 (STM32F103RC / STM32F103RE)
-#define BOARD_CREALITY_V4210          4044  // Creality v4.2.10 (STM32F103RC / STM32F103RE) as found in the CR-30
-#define BOARD_CREALITY_V431           4045  // Creality v4.3.1 (STM32F103RC / STM32F103RE)
-#define BOARD_CREALITY_V431_A         4046  // Creality v4.3.1a (STM32F103RC / STM32F103RE)
-#define BOARD_CREALITY_V431_B         4047  // Creality v4.3.1b (STM32F103RC / STM32F103RE)
-#define BOARD_CREALITY_V431_C         4048  // Creality v4.3.1c (STM32F103RC / STM32F103RE)
-#define BOARD_CREALITY_V431_D         4049  // Creality v4.3.1d (STM32F103RC / STM32F103RE)
-#define BOARD_CREALITY_V452           4050  // Creality v4.5.2 (STM32F103RC / STM32F103RE)
-#define BOARD_CREALITY_V453           4051  // Creality v4.5.3 (STM32F103RC / STM32F103RE)
-#define BOARD_CREALITY_V24S1          4052  // Creality v2.4.S1 (STM32F103RC / STM32F103RE) v101 as found in the Ender-7
-#define BOARD_CREALITY_V24S1_301      4053  // Creality v2.4.S1_301 (STM32F103RC / STM32F103RE) v301 as found in the Ender-3 S1
-#define BOARD_CREALITY_V25S1          4054  // Creality v2.5.S1 (STM32F103RE) as found in the CR-10 Smart Pro
-#define BOARD_TRIGORILLA_PRO          4055  // Trigorilla Pro (STM32F103ZE)
-#define BOARD_FLY_MINI                4056  // FLYmaker FLY MINI (STM32F103RC)
-#define BOARD_FLSUN_HISPEED           4057  // FLSUN HiSpeedV1 (STM32F103VE)
-#define BOARD_BEAST                   4058  // STM32F103RE Libmaple-based controller
-#define BOARD_MINGDA_MPX_ARM_MINI     4059  // STM32F103ZE Mingda MD-16
-#define BOARD_GTM32_PRO_VD            4060  // STM32F103VE controller
-#define BOARD_ZONESTAR_ZM3E2          4061  // Zonestar ZM3E2    (STM32F103RC)
-#define BOARD_ZONESTAR_ZM3E4          4062  // Zonestar ZM3E4 V1 (STM32F103VC)
-#define BOARD_ZONESTAR_ZM3E4V2        4063  // Zonestar ZM3E4 V2 (STM32F103VC)
-#define BOARD_ERYONE_ERY32_MINI       4064  // Eryone Ery32 mini (STM32F103VE)
-#define BOARD_PANDA_PI_V29            4065  // Panda Pi V2.9 - Standalone (STM32F103RC)
+#define BOARD_CREALITY_V425           4043  // Creality v4.2.5 (STM32F103RC / STM32F103RE)
+#define BOARD_CREALITY_V427           4044  // Creality v4.2.7 (STM32F103RC / STM32F103RE)
+#define BOARD_CREALITY_V4210          4045  // Creality v4.2.10 (STM32F103RC / STM32F103RE) as found in the CR-30
+#define BOARD_CREALITY_V431           4046  // Creality v4.3.1 (STM32F103RC / STM32F103RE)
+#define BOARD_CREALITY_V431_A         4047  // Creality v4.3.1a (STM32F103RC / STM32F103RE)
+#define BOARD_CREALITY_V431_B         4048  // Creality v4.3.1b (STM32F103RC / STM32F103RE)
+#define BOARD_CREALITY_V431_C         4049  // Creality v4.3.1c (STM32F103RC / STM32F103RE)
+#define BOARD_CREALITY_V431_D         4050  // Creality v4.3.1d (STM32F103RC / STM32F103RE)
+#define BOARD_CREALITY_V452           4051  // Creality v4.5.2 (STM32F103RC / STM32F103RE)
+#define BOARD_CREALITY_V453           4052  // Creality v4.5.3 (STM32F103RC / STM32F103RE)
+#define BOARD_CREALITY_V24S1          4053  // Creality v2.4.S1 (STM32F103RC / STM32F103RE) v101 as found in the Ender-7
+#define BOARD_CREALITY_V24S1_301      4054  // Creality v2.4.S1_301 (STM32F103RC / STM32F103RE) v301 as found in the Ender-3 S1
+#define BOARD_CREALITY_V25S1          4055  // Creality v2.5.S1 (STM32F103RE) as found in the CR-10 Smart Pro
+#define BOARD_TRIGORILLA_PRO          4056  // Trigorilla Pro (STM32F103ZE)
+#define BOARD_FLY_MINI                4057  // FLYmaker FLY MINI (STM32F103RC)
+#define BOARD_FLSUN_HISPEED           4058  // FLSUN HiSpeedV1 (STM32F103VE)
+#define BOARD_BEAST                   4059  // STM32F103RE Libmaple-based controller
+#define BOARD_MINGDA_MPX_ARM_MINI     4060  // STM32F103ZE Mingda MD-16
+#define BOARD_GTM32_PRO_VD            4061  // STM32F103VE controller
+#define BOARD_ZONESTAR_ZM3E2          4062  // Zonestar ZM3E2    (STM32F103RC)
+#define BOARD_ZONESTAR_ZM3E4          4063  // Zonestar ZM3E4 V1 (STM32F103VC)
+#define BOARD_ZONESTAR_ZM3E4V2        4064  // Zonestar ZM3E4 V2 (STM32F103VC)
+#define BOARD_ERYONE_ERY32_MINI       4065  // Eryone Ery32 mini (STM32F103VE)
+#define BOARD_PANDA_PI_V29            4066  // Panda Pi V2.9 - Standalone (STM32F103RC)
 
 //
 // ARM Cortex-M4F
@@ -395,7 +397,7 @@
 #define BOARD_BTT_GTR_V1_0            4214  // BigTreeTech GTR v1.0 (STM32F407IGT)
 #define BOARD_BTT_OCTOPUS_V1_0        4215  // BigTreeTech Octopus v1.0 (STM32F446ZE)
 #define BOARD_BTT_OCTOPUS_V1_1        4216  // BigTreeTech Octopus v1.1 (STM32F446ZE)
-#define BOARD_BTT_OCTOPUS_PRO_V1_0    4217  // BigTreeTech Octopus Pro v1.0 (STM32F446ZE/STM32F429ZG)
+#define BOARD_BTT_OCTOPUS_PRO_V1_0    4217  // BigTreeTech Octopus Pro v1.0 (STM32F446ZE / STM32F429ZG)
 #define BOARD_LERDGE_K                4218  // Lerdge K (STM32F407ZG)
 #define BOARD_LERDGE_S                4219  // Lerdge S (STM32F407VE)
 #define BOARD_LERDGE_X                4220  // Lerdge X (STM32F407VE)
@@ -408,17 +410,18 @@
 #define BOARD_MKS_ROBIN_PRO_V2        4227  // MKS Robin Pro V2 (STM32F407VE)
 #define BOARD_MKS_ROBIN_NANO_V3       4228  // MKS Robin Nano V3 (STM32F407VG)
 #define BOARD_MKS_ROBIN_NANO_V3_1     4229  // MKS Robin Nano V3.1 (STM32F407VE)
-#define BOARD_MKS_MONSTER8            4230  // MKS Monster8 (STM32F407VG)
-#define BOARD_ANET_ET4                4231  // ANET ET4 V1.x (STM32F407VG)
-#define BOARD_ANET_ET4P               4232  // ANET ET4P V1.x (STM32F407VG)
-#define BOARD_FYSETC_CHEETAH_V20      4233  // FYSETC Cheetah V2.0
-#define BOARD_TH3D_EZBOARD_V2         4234  // TH3D EZBoard v2.0
-#define BOARD_INDEX_REV03             4235  // Index PnP Controller REV03 (STM32F407VE/VG)
-#define BOARD_MKS_ROBIN_NANO_V1_3_F4  4236  // MKS Robin Nano V1.3 and MKS Robin Nano-S V1.3 (STM32F407VE)
-#define BOARD_MKS_EAGLE               4237  // MKS Eagle (STM32F407VE)
-#define BOARD_ARTILLERY_RUBY          4238  // Artillery Ruby (STM32F401RC)
-#define BOARD_FYSETC_SPIDER_V2_2      4239  // FYSETC Spider V2.2 (STM32F446VE)
-#define BOARD_CREALITY_V24S1_301F4    4240  // Creality v2.4.S1_301F4 (STM32F401RC) as found in the Ender-3 S1 F4
+#define BOARD_MKS_MONSTER8_V1         4230  // MKS Monster8 V1 (STM32F407VE)
+#define BOARD_MKS_MONSTER8_V2         4231  // MKS Monster8 V2 (STM32F407VE)
+#define BOARD_ANET_ET4                4232  // ANET ET4 V1.x (STM32F407VG)
+#define BOARD_ANET_ET4P               4233  // ANET ET4P V1.x (STM32F407VG)
+#define BOARD_FYSETC_CHEETAH_V20      4234  // FYSETC Cheetah V2.0 (STM32F401RC)
+#define BOARD_TH3D_EZBOARD_V2         4235  // TH3D EZBoard v2.0 (STM32F405RG)
+#define BOARD_OPULO_LUMEN_REV3        4236  // Opulo Lumen PnP Controller REV3 (STM32F407VE / STM32F407VG)
+#define BOARD_MKS_ROBIN_NANO_V1_3_F4  4237  // MKS Robin Nano V1.3 and MKS Robin Nano-S V1.3 (STM32F407VE)
+#define BOARD_MKS_EAGLE               4238  // MKS Eagle (STM32F407VE)
+#define BOARD_ARTILLERY_RUBY          4239  // Artillery Ruby (STM32F401RC)
+#define BOARD_FYSETC_SPIDER_V2_2      4240  // FYSETC Spider V2.2 (STM32F446VE)
+#define BOARD_CREALITY_V24S1_301F4    4241  // Creality v2.4.S1_301F4 (STM32F401RC) as found in the Ender-3 S1 F4
 
 //
 // ARM Cortex M7
@@ -428,9 +431,10 @@
 #define BOARD_TEENSY41                5001  // Teensy 4.1
 #define BOARD_T41U5XBB                5002  // T41U5XBB Teensy 4.1 breakout board
 #define BOARD_NUCLEO_F767ZI           5003  // ST NUCLEO-F767ZI Dev Board
-#define BOARD_BTT_SKR_SE_BX           5004  // BigTreeTech SKR SE BX (STM32H743II)
-#define BOARD_BTT_SKR_V3_0            5005  // BigTreeTech SKR V3.0 (STM32H743VG)
-#define BOARD_BTT_SKR_V3_0_EZ         5006  // BigTreeTech SKR V3.0 EZ (STM32H743VG)
+#define BOARD_BTT_SKR_SE_BX_V2        5004  // BigTreeTech SKR SE BX V2.0 (STM32H743II)
+#define BOARD_BTT_SKR_SE_BX_V3        5005  // BigTreeTech SKR SE BX V3.0 (STM32H743II)
+#define BOARD_BTT_SKR_V3_0            5006  // BigTreeTech SKR V3.0 (STM32H743VG)
+#define BOARD_BTT_SKR_V3_0_EZ         5007  // BigTreeTech SKR V3.0 EZ (STM32H743VG)
 
 //
 // Espressif ESP32 WiFi

Marlin/src/core/drivers.h

@@ -63,9 +63,6 @@
 #define AXIS_DRIVER_TYPE_I(T) _AXIS_DRIVER_TYPE(I,T)
 #define AXIS_DRIVER_TYPE_J(T) _AXIS_DRIVER_TYPE(J,T)
 #define AXIS_DRIVER_TYPE_K(T) _AXIS_DRIVER_TYPE(K,T)
-#define AXIS_DRIVER_TYPE_U(T) _AXIS_DRIVER_TYPE(U,T)
-#define AXIS_DRIVER_TYPE_V(T) _AXIS_DRIVER_TYPE(V,T)
-#define AXIS_DRIVER_TYPE_W(T) _AXIS_DRIVER_TYPE(W,T)
 
 #define AXIS_DRIVER_TYPE_X2(T) (HAS_X2_STEPPER && _AXIS_DRIVER_TYPE(X2,T))
 #define AXIS_DRIVER_TYPE_Y2(T) (HAS_DUAL_Y_STEPPERS && _AXIS_DRIVER_TYPE(Y2,T))
@@ -90,7 +87,6 @@
 
 #define HAS_DRIVER(T) (  AXIS_DRIVER_TYPE_X(T)  || AXIS_DRIVER_TYPE_Y(T)  || AXIS_DRIVER_TYPE_Z(T)  \
                       || AXIS_DRIVER_TYPE_I(T)  || AXIS_DRIVER_TYPE_J(T)  || AXIS_DRIVER_TYPE_K(T)  \
-                      || AXIS_DRIVER_TYPE_U(T)  || AXIS_DRIVER_TYPE_V(T)  || AXIS_DRIVER_TYPE_W(T)  \
                       || AXIS_DRIVER_TYPE_X2(T) || AXIS_DRIVER_TYPE_Y2(T) || AXIS_DRIVER_TYPE_Z2(T) \
                       || AXIS_DRIVER_TYPE_Z3(T) || AXIS_DRIVER_TYPE_Z4(T) || HAS_E_DRIVER(T) )
 
@@ -165,7 +161,6 @@
                           || AXIS_HAS_##T(Y) || AXIS_HAS_##T(Y2) \
                           || AXIS_HAS_##T(Z) || AXIS_HAS_##T(Z2) || AXIS_HAS_##T(Z3) || AXIS_HAS_##T(Z4) \
                           || AXIS_HAS_##T(I) || AXIS_HAS_##T(J)  || AXIS_HAS_##T(K) \
-                          || AXIS_HAS_##T(U) || AXIS_HAS_##T(V)  || AXIS_HAS_##T(W) \
                           || E_AXIS_HAS(T) )
 
 #if ANY_AXIS_HAS(STEALTHCHOP)

Marlin/src/core/language.h

@@ -227,10 +227,6 @@
 #define STR_PID_DEBUG                       " PID_DEBUG "
 #define STR_PID_DEBUG_INPUT                 ": Input "
 #define STR_PID_DEBUG_OUTPUT                " Output "
-#define STR_PID_DEBUG_PTERM                 " pTerm "
-#define STR_PID_DEBUG_ITERM                 " iTerm "
-#define STR_PID_DEBUG_DTERM                 " dTerm "
-#define STR_PID_DEBUG_CTERM                 " cTerm "
 #define STR_INVALID_EXTRUDER_NUM            " - Invalid extruder number !"
 #define STR_MPC_AUTOTUNE                    "MPC Autotune"
 #define STR_MPC_AUTOTUNE_START              " start for " STR_E
@@ -457,54 +453,6 @@
   #define STR_K   ""
 #endif
 
-#if HAS_U_AXIS
-  #if AXIS7_NAME == 'U'
-    #define STR_U "U"
-    #define STR_U_MIN "u_min"
-    #define STR_U_MAX "u_max"
-  #elif AXIS7_NAME == 'V'
-    #define STR_U "V"
-    #define STR_U_MIN "v_min"
-    #define STR_U_MAX "v_max"
-  #elif AXIS7_NAME == 'W'
-    #define STR_U "W"
-    #define STR_U_MIN "w_min"
-    #define STR_U_MAX "w_max"
-  #else
-    #error "AXIS7_NAME can only be one of 'U', 'V', or 'W'."
-  #endif
-#else
-  #define STR_U   ""
-#endif
-
-#if HAS_V_AXIS
-  #if AXIS8_NAME == 'V'
-    #define STR_V "V"
-    #define STR_V_MIN "v_min"
-    #define STR_V_MAX "v_max"
-  #elif AXIS8_NAME == 'W'
-    #define STR_V "W"
-    #define STR_V_MIN "w_min"
-    #define STR_V_MAX "w_max"
-  #else
-    #error "AXIS8_NAME can only be one of 'V', or 'W'."
-  #endif
-#else
-  #define STR_V   ""
-#endif
-
-#if HAS_W_AXIS
-  #if AXIS9_NAME == 'W'
-    #define STR_W "W"
-    #define STR_W_MIN "w_min"
-    #define STR_W_MAX "w_max"
-  #else
-    #error "AXIS9_NAME can only be 'W'."
-  #endif
-#else
-  #define STR_W   ""
-#endif
-
 #if EITHER(HAS_MARLINUI_HD44780, IS_TFTGLCD_PANEL)
 
   // Custom characters defined in the first 8 characters of the LCD

Marlin/src/core/macros.h

@@ -39,36 +39,24 @@
 #define _ISTOP_  0x04
 #define _JSTOP_  0x05
 #define _KSTOP_  0x06
-#define _USTOP_  0x07
-#define _VSTOP_  0x08
-#define _WSTOP_  0x09
 #define _XMIN_   0x11
 #define _YMIN_   0x12
 #define _ZMIN_   0x13
 #define _IMIN_   0x14
 #define _JMIN_   0x15
 #define _KMIN_   0x16
-#define _UMIN_   0x17
-#define _VMIN_   0x18
-#define _WMIN_   0x19
 #define _XMAX_   0x21
 #define _YMAX_   0x22
 #define _ZMAX_   0x23
 #define _IMAX_   0x24
 #define _JMAX_   0x25
 #define _KMAX_   0x26
-#define _UMAX_   0x27
-#define _VMAX_   0x28
-#define _WMAX_   0x29
 #define _XDIAG_  0x31
 #define _YDIAG_  0x32
 #define _ZDIAG_  0x33
 #define _IDIAG_  0x34
 #define _JDIAG_  0x35
 #define _KDIAG_  0x36
-#define _UDIAG_  0x37
-#define _VDIAG_  0x38
-#define _WDIAG_  0x39
 #define _E0DIAG_ 0xE0
 #define _E1DIAG_ 0xE1
 #define _E2DIAG_ 0xE2
@@ -644,8 +632,8 @@
 #define IS_PROBE(V...) SECOND(V, 0)     // Get the second item passed, or 0
 #define PROBE() ~, 1                    // Second item will be 1 if this is passed
 #define _NOT_0 PROBE()
-#define NOT(x) IS_PROBE(_CAT(_NOT_, x)) // NOT('0') gets '1'. Anything else gets '0'.
-#define _BOOL(x) NOT(NOT(x))            // NOT('0') gets '0'. Anything else gets '1'.
+#define NOT(x) IS_PROBE(_CAT(_NOT_, x)) //   NOT('0') gets '1'. Anything else gets '0'.
+#define _BOOL(x) NOT(NOT(x))            // _BOOL('0') gets '0'. Anything else gets '1'.
 
 #define IF_ELSE(TF) _IF_ELSE(_BOOL(TF))
 #define _IF_ELSE(TF) _CAT(_IF_, TF)
@@ -659,7 +647,6 @@
 #define HAS_ARGS(V...) _BOOL(FIRST(_END_OF_ARGUMENTS_ V)())
 #define _END_OF_ARGUMENTS_() 0
 
-
 // Simple Inline IF Macros, friendly to use in other macro definitions
 #define IF(O, A, B) ((O) ? (A) : (B))
 #define IF_0(O, A) IF(O, A, 0)

Marlin/src/core/serial.cpp

@@ -72,8 +72,8 @@ void serial_print_P(PGM_P str) {
   while (const char c = pgm_read_byte(str++)) SERIAL_CHAR(c);
 }
 
-void serial_echo_start()  { static PGMSTR(echomagic, "echo:"); serial_print_P(echomagic); }
-void serial_error_start() { static PGMSTR(errormagic, "Error:"); serial_print_P(errormagic); }
+void serial_echo_start()  { serial_print(F("echo:")); }
+void serial_error_start() { serial_print(F("Error:")); }
 
 void serial_spaces(uint8_t count) { count *= (PROPORTIONAL_FONT_RATIO); while (count--) SERIAL_CHAR(' '); }
 
@@ -104,7 +104,7 @@ void print_bin(uint16_t val) {
 void print_pos(NUM_AXIS_ARGS(const_float_t), FSTR_P const prefix/*=nullptr*/, FSTR_P const suffix/*=nullptr*/) {
   if (prefix) serial_print(prefix);
   SERIAL_ECHOPGM_P(
-    LIST_N(DOUBLE(NUM_AXES), SP_X_STR, x, SP_Y_STR, y, SP_Z_STR, z, SP_I_STR, i, SP_J_STR, j, SP_K_STR, k, SP_U_STR, u, SP_V_STR, v, SP_W_STR, w)
+    LIST_N(DOUBLE(NUM_AXES), SP_X_STR, x, SP_Y_STR, y, SP_Z_STR, z, SP_I_STR, i, SP_J_STR, j, SP_K_STR, k)
   );
   if (suffix) serial_print(suffix); else SERIAL_EOL();
 }

Marlin/src/core/types.h

@@ -42,12 +42,13 @@ struct IF<true, L, R> { typedef L type; };
 #define NUM_AXIS_LIST_1(V)  LIST_N_1(NUM_AXES, V)
 #define NUM_AXIS_ARRAY(V...) { NUM_AXIS_LIST(V) }
 #define NUM_AXIS_ARRAY_1(V)  { NUM_AXIS_LIST_1(V) }
-#define NUM_AXIS_ARGS(T...) NUM_AXIS_LIST(T x, T y, T z, T i, T j, T k, T u, T v, T w)
-#define NUM_AXIS_ELEM(O)    NUM_AXIS_LIST(O.x, O.y, O.z, O.i, O.j, O.k, O.u, O.v, O.w)
-#define NUM_AXIS_DEFS(T,V)  NUM_AXIS_LIST(T x=V, T y=V, T z=V, T i=V, T j=V, T k=V, T u=V, T v=V, T w=V)
-#define MAIN_AXIS_NAMES     NUM_AXIS_LIST(X, Y, Z, I, J, K, U, V, W)
+#define NUM_AXIS_ARGS(T...) NUM_AXIS_LIST(T x, T y, T z, T i, T j, T k)
+#define NUM_AXIS_ELEM(O)    NUM_AXIS_LIST(O.x, O.y, O.z, O.i, O.j, O.k)
+#define NUM_AXIS_DEFS(T,V)  NUM_AXIS_LIST(T x=V, T y=V, T z=V, T i=V, T j=V, T k=V)
+
+#define MAIN_AXIS_NAMES     NUM_AXIS_LIST(X, Y, Z, I, J, K)
 #define MAIN_AXIS_MAP(F)    MAP(F, MAIN_AXIS_NAMES)
-#define STR_AXES_MAIN       NUM_AXIS_GANG("X", "Y", "Z", STR_I, STR_J, STR_K, STR_U, STR_V, STR_W)
+#define STR_AXES_MAIN       NUM_AXIS_GANG("X", "Y", "Z", STR_I, STR_J, STR_K)
 
 #define LOGICAL_AXIS_GANG(E,V...) NUM_AXIS_GANG(V) GANG_ITEM_E(E)
 #define LOGICAL_AXIS_CODE(E,V...) NUM_AXIS_CODE(V) CODE_ITEM_E(E)
@@ -55,12 +56,14 @@ struct IF<true, L, R> { typedef L type; };
 #define LOGICAL_AXIS_LIST_1(V)    NUM_AXIS_LIST_1(V) LIST_ITEM_E(V)
 #define LOGICAL_AXIS_ARRAY(E,V...) { LOGICAL_AXIS_LIST(E,V) }
 #define LOGICAL_AXIS_ARRAY_1(V)    { LOGICAL_AXIS_LIST_1(V) }
-#define LOGICAL_AXIS_ARGS(T...) LOGICAL_AXIS_LIST(T e, T x, T y, T z, T i, T j, T k, T u, T v, T w)
-#define LOGICAL_AXIS_ELEM(O)    LOGICAL_AXIS_LIST(O.e, O.x, O.y, O.z, O.i, O.j, O.k, O.u, O.v, O.w)
-#define LOGICAL_AXIS_DECL(T,V)  LOGICAL_AXIS_LIST(T e=V, T x=V, T y=V, T z=V, T i=V, T j=V, T k=V, T u=V, T v=V, T w=V)
-#define LOGICAL_AXIS_NAMES      LOGICAL_AXIS_LIST(E, X, Y, Z, I, J, K, U, V, W)
+#define LOGICAL_AXIS_ARGS(T...) LOGICAL_AXIS_LIST(T e, T x, T y, T z, T i, T j, T k)
+#define LOGICAL_AXIS_ELEM(O)    LOGICAL_AXIS_LIST(O.e, O.x, O.y, O.z, O.i, O.j, O.k)
+#define LOGICAL_AXIS_DECL(T,V)  LOGICAL_AXIS_LIST(T e=V, T x=V, T y=V, T z=V, T i=V, T j=V, T k=V)
+
+#define LOGICAL_AXIS_NAMES      LOGICAL_AXIS_LIST(E, X, Y, Z, I, J, K)
 #define LOGICAL_AXIS_MAP(F)     MAP(F, LOGICAL_AXIS_NAMES)
-#define STR_AXES_LOGICAL     LOGICAL_AXIS_GANG("E", "X", "Y", "Z", STR_I, STR_J, STR_K, STR_U, STR_V, STR_W)
+
+#define STR_AXES_LOGICAL LOGICAL_AXIS_GANG("E", "X", "Y", "Z", STR_I, STR_J, STR_K)
 
 #define XYZ_GANG(V...) GANG_N(PRIMARY_LINEAR_AXES, V)
 #define XYZ_CODE(V...) CODE_N(PRIMARY_LINEAR_AXES, V)
@@ -68,10 +71,6 @@ struct IF<true, L, R> { typedef L type; };
 #define SECONDARY_AXIS_GANG(V...) GANG_N(SECONDARY_AXES, V)
 #define SECONDARY_AXIS_CODE(V...) CODE_N(SECONDARY_AXES, V)
 
-#if HAS_ROTATIONAL_AXES
-  #define ROTATIONAL_AXIS_GANG(V...) GANG_N(ROTATIONAL_AXES, V)
-#endif
-
 #if HAS_EXTRUDERS
   #define LIST_ITEM_E(N) , N
   #define CODE_ITEM_E(N) ; N
@@ -82,7 +81,7 @@ struct IF<true, L, R> { typedef L type; };
   #define GANG_ITEM_E(N)
 #endif
 
-#define AXIS_COLLISION(L) (AXIS4_NAME == L || AXIS5_NAME == L || AXIS6_NAME == L || AXIS7_NAME == L || AXIS8_NAME == L || AXIS9_NAME == L)
+#define AXIS_COLLISION(L) (AXIS4_NAME == L || AXIS5_NAME == L || AXIS6_NAME == L)
 
 // General Flags for some number of states
 template<size_t N>
@@ -99,8 +98,8 @@ struct Flags {
   void set(const int n)                    { b |=  (bits_t)_BV(n); }
   void clear(const int n)                  { b &= ~(bits_t)_BV(n); }
   bool test(const int n) const             { return TEST(b, n); }
-  bool operator[](const int n)             { return test(n); }
-  bool operator[](const int n) const       { return test(n); }
+  const bool operator[](const int n)       { return test(n); }
+  const bool operator[](const int n) const { return test(n); }
   int size() const                         { return sizeof(b); }
 };
 
@@ -113,8 +112,8 @@ struct Flags<1> {
   void set(const int)                     { b = true; }
   void clear(const int)                   { b = false; }
   bool test(const int) const              { return b; }
-  bool operator[](const int)              { return b; }
-  bool operator[](const int) const        { return b; }
+  bool& operator[](const int)             { return b; }
+  bool  operator[](const int) const       { return b; }
   int size() const                        { return sizeof(b); }
 };
 
@@ -147,7 +146,7 @@ typedef struct AxisFlags {
 enum AxisEnum : uint8_t {
 
   // Linear axes may be controlled directly or indirectly
-  NUM_AXIS_LIST(X_AXIS, Y_AXIS, Z_AXIS, I_AXIS, J_AXIS, K_AXIS, U_AXIS, V_AXIS, W_AXIS)
+  NUM_AXIS_LIST(X_AXIS, Y_AXIS, Z_AXIS, I_AXIS, J_AXIS, K_AXIS)
 
   // Extruder axes may be considered distinctly
   #define _EN_ITEM(N) , E##N##_AXIS
@@ -457,68 +456,59 @@ template<typename T>
 struct XYZval {
   union {
     struct { T NUM_AXIS_ARGS(); };
-    struct { T NUM_AXIS_LIST(a, b, c, _i, _j, _k, _u, _v, _w); };
+    struct { T NUM_AXIS_LIST(a, b, c, _i, _j, _k); };
     T pos[NUM_AXES];
   };
 
   // Set all to 0
-  FI void reset()                                      { NUM_AXIS_GANG(x =, y =, z =, i =, j =, k =, u =, v =, w =) 0; }
+  FI void reset()                                      { NUM_AXIS_GANG(x =, y =, z =, i =, j =, k =) 0; }
 
   // Setters taking struct types and arrays
   FI void set(const T px)                              { x = px; }
   FI void set(const T px, const T py)                  { x = px; y = py; }
   FI void set(const XYval<T> pxy)                      { x = pxy.x; y = pxy.y; }
-  FI void set(const XYval<T> pxy, const T pz)          { NUM_AXIS_CODE(x = pxy.x, y = pxy.y, z = pz, NOOP, NOOP, NOOP, NOOP, NOOP, NOOP); }
+  FI void set(const XYval<T> pxy, const T pz)          { NUM_AXIS_CODE(x = pxy.x, y = pxy.y, z = pz, NOOP, NOOP, NOOP); }
   FI void set(const T (&arr)[XY])                      { x = arr[0]; y = arr[1]; }
   #if HAS_Z_AXIS
-    FI void set(const T (&arr)[NUM_AXES])              { NUM_AXIS_CODE(x = arr[0], y = arr[1], z = arr[2], i = arr[3], j = arr[4], k = arr[5], u = arr[6], v = arr[7], w = arr[8]); }
-    FI void set(NUM_AXIS_ARGS(const T))                { NUM_AXIS_CODE(a = x,      b = y,      c = z,     _i = i,     _j = j,     _k = k,     _u = u,     _v = v,     _w = w   ); }
+    FI void set(const T (&arr)[NUM_AXES])              { NUM_AXIS_CODE(x = arr[0], y = arr[1], z = arr[2], i = arr[3], j = arr[4], k = arr[5]); }
+    FI void set(NUM_AXIS_ARGS(const T))                { NUM_AXIS_CODE(a = x,      b = y,      c = z,     _i = i,     _j = j,     _k = k); }
   #endif
   #if LOGICAL_AXES > NUM_AXES
-    FI void set(const T (&arr)[LOGICAL_AXES])          { NUM_AXIS_CODE(x = arr[0], y = arr[1], z = arr[2], i = arr[3], j = arr[4], k = arr[5], u = arr[6], v = arr[7], w = arr[8]); }
-    FI void set(LOGICAL_AXIS_ARGS(const T))            { NUM_AXIS_CODE(a = x,      b = y,      c = z,     _i = i,     _j = j,     _k = k,     _u = u,     _v = v,     _w = w   ); }
+    FI void set(const T (&arr)[LOGICAL_AXES])          { NUM_AXIS_CODE(x = arr[0], y = arr[1], z = arr[2], i = arr[3], j = arr[4], k = arr[5]); }
+    FI void set(LOGICAL_AXIS_ARGS(const T))            { NUM_AXIS_CODE(a = x,      b = y,      c = z,     _i = i,     _j = j,     _k = k); }
     #if DISTINCT_AXES > LOGICAL_AXES
-      FI void set(const T (&arr)[DISTINCT_AXES])       { NUM_AXIS_CODE(x = arr[0], y = arr[1], z = arr[2], i = arr[3], j = arr[4], k = arr[5], u = arr[6], v = arr[7], w = arr[8]); }
+      FI void set(const T (&arr)[DISTINCT_AXES])       { NUM_AXIS_CODE(x = arr[0], y = arr[1], z = arr[2], i = arr[3], j = arr[4], k = arr[5]); }
     #endif
   #endif
   #if HAS_I_AXIS
-    FI void set(const T px, const T py, const T pz) { x = px; y = py; z = pz; }
+    FI void set(const T px, const T py, const T pz)                         { x = px; y = py; z = pz; }
   #endif
   #if HAS_J_AXIS
-    FI void set(const T px, const T py, const T pz, const T pi) { x = px; y = py; z = pz; i = pi; }
+    FI void set(const T px, const T py, const T pz, const T pi)             { x = px; y = py; z = pz; i = pi; }
   #endif
   #if HAS_K_AXIS
     FI void set(const T px, const T py, const T pz, const T pi, const T pj) { x = px; y = py; z = pz; i = pi; j = pj; }
   #endif
-  #if HAS_U_AXIS
-    FI void set(const T px, const T py, const T pz, const T pi, const T pj, const T pk) { x = px; y = py; z = pz; i = pi; j = pj; k = pk; }
-  #endif
-  #if HAS_V_AXIS
-    FI void set(const T px, const T py, const T pz, const T pi, const T pj, const T pk, const T pm) { x = px; y = py; z = pz; i = pi; j = pj; k = pk; u = pu; }
-  #endif
-  #if HAS_W_AXIS
-    FI void set(const T px, const T py, const T pz, const T pi, const T pj, const T pk, const T pm, const T po) { x = px; y = py; z = pz; i = pi; j = pj; k = pk; u = pu; v = pv; }
-  #endif
 
   // Length reduced to one dimension
-  FI T magnitude()                               const { return (T)sqrtf(NUM_AXIS_GANG(x*x, + y*y, + z*z, + i*i, + j*j, + k*k, + u*u, + v*v, + w*w)); }
+  FI T magnitude()                               const { return (T)sqrtf(NUM_AXIS_GANG(x*x, + y*y, + z*z, + i*i, + j*j, + k*k)); }
   // Pointer to the data as a simple array
   FI operator T* ()                                    { return pos; }
   // If any element is true then it's true
-  FI operator bool()                                   { return NUM_AXIS_GANG(x, || y, || z, || i, || j, || k, || u, || v, || w); }
+  FI operator bool()                                   { return NUM_AXIS_GANG(x, || y, || z, || i, || j, || k); }
 
   // Explicit copy and copies with conversion
   FI XYZval<T>          copy()                   const { XYZval<T> o = *this; return o; }
-  FI XYZval<T>           ABS()                   const { return NUM_AXIS_ARRAY(T(_ABS(x)), T(_ABS(y)), T(_ABS(z)), T(_ABS(i)), T(_ABS(j)), T(_ABS(k)), T(_ABS(u)), T(_ABS(v)), T(_ABS(w))); }
-  FI XYZval<int16_t>   asInt()                         { return NUM_AXIS_ARRAY(int16_t(x), int16_t(y), int16_t(z), int16_t(i), int16_t(j), int16_t(k), int16_t(u), int16_t(v), int16_t(w)); }
-  FI XYZval<int16_t>   asInt()                   const { return NUM_AXIS_ARRAY(int16_t(x), int16_t(y), int16_t(z), int16_t(i), int16_t(j), int16_t(k), int16_t(u), int16_t(v), int16_t(w)); }
-  FI XYZval<int32_t>  asLong()                         { return NUM_AXIS_ARRAY(int32_t(x), int32_t(y), int32_t(z), int32_t(i), int32_t(j), int32_t(k), int32_t(u), int32_t(v), int32_t(w)); }
-  FI XYZval<int32_t>  asLong()                   const { return NUM_AXIS_ARRAY(int32_t(x), int32_t(y), int32_t(z), int32_t(i), int32_t(j), int32_t(k), int32_t(u), int32_t(v), int32_t(w)); }
-  FI XYZval<int32_t>  ROUNDL()                         { return NUM_AXIS_ARRAY(int32_t(LROUND(x)), int32_t(LROUND(y)), int32_t(LROUND(z)), int32_t(LROUND(i)), int32_t(LROUND(j)), int32_t(LROUND(k)), int32_t(LROUND(u)), int32_t(LROUND(v)), int32_t(LROUND(w))); }
-  FI XYZval<int32_t>  ROUNDL()                   const { return NUM_AXIS_ARRAY(int32_t(LROUND(x)), int32_t(LROUND(y)), int32_t(LROUND(z)), int32_t(LROUND(i)), int32_t(LROUND(j)), int32_t(LROUND(k)), int32_t(LROUND(u)), int32_t(LROUND(v)), int32_t(LROUND(w))); }
-  FI XYZval<float>   asFloat()                         { return NUM_AXIS_ARRAY(static_cast<float>(x), static_cast<float>(y), static_cast<float>(z), static_cast<float>(i), static_cast<float>(j), static_cast<float>(k), static_cast<float>(u), static_cast<float>(v), static_cast<float>(w)); }
-  FI XYZval<float>   asFloat()                   const { return NUM_AXIS_ARRAY(static_cast<float>(x), static_cast<float>(y), static_cast<float>(z), static_cast<float>(i), static_cast<float>(j), static_cast<float>(k), static_cast<float>(u), static_cast<float>(v), static_cast<float>(w)); }
-  FI XYZval<float> reciprocal()                  const { return NUM_AXIS_ARRAY(_RECIP(x),  _RECIP(y),  _RECIP(z),  _RECIP(i),  _RECIP(j),  _RECIP(k),  _RECIP(u),  _RECIP(v),  _RECIP(w)); }
+  FI XYZval<T>           ABS()                   const { return NUM_AXIS_ARRAY(T(_ABS(x)), T(_ABS(y)), T(_ABS(z)), T(_ABS(i)), T(_ABS(j)), T(_ABS(k))); }
+  FI XYZval<int16_t>   asInt()                         { return NUM_AXIS_ARRAY(int16_t(x), int16_t(y), int16_t(z), int16_t(i), int16_t(j), int16_t(k)); }
+  FI XYZval<int16_t>   asInt()                   const { return NUM_AXIS_ARRAY(int16_t(x), int16_t(y), int16_t(z), int16_t(i), int16_t(j), int16_t(k)); }
+  FI XYZval<int32_t>  asLong()                         { return NUM_AXIS_ARRAY(int32_t(x), int32_t(y), int32_t(z), int32_t(i), int32_t(j), int32_t(k)); }
+  FI XYZval<int32_t>  asLong()                   const { return NUM_AXIS_ARRAY(int32_t(x), int32_t(y), int32_t(z), int32_t(i), int32_t(j), int32_t(k)); }
+  FI XYZval<int32_t>  ROUNDL()                         { return NUM_AXIS_ARRAY(int32_t(LROUND(x)), int32_t(LROUND(y)), int32_t(LROUND(z)), int32_t(LROUND(i)), int32_t(LROUND(j)), int32_t(LROUND(k))); }
+  FI XYZval<int32_t>  ROUNDL()                   const { return NUM_AXIS_ARRAY(int32_t(LROUND(x)), int32_t(LROUND(y)), int32_t(LROUND(z)), int32_t(LROUND(i)), int32_t(LROUND(j)), int32_t(LROUND(k))); }
+  FI XYZval<float>   asFloat()                         { return NUM_AXIS_ARRAY(static_cast<float>(x), static_cast<float>(y), static_cast<float>(z), static_cast<float>(i), static_cast<float>(j), static_cast<float>(k)); }
+  FI XYZval<float>   asFloat()                   const { return NUM_AXIS_ARRAY(static_cast<float>(x), static_cast<float>(y), static_cast<float>(z), static_cast<float>(i), static_cast<float>(j), static_cast<float>(k)); }
+  FI XYZval<float> reciprocal()                  const { return NUM_AXIS_ARRAY(_RECIP(x),  _RECIP(y),  _RECIP(z),  _RECIP(i),  _RECIP(j),  _RECIP(k)); }
 
   // Marlin workspace shifting is done with G92 and M206
   FI XYZval<float> asLogical()                   const { XYZval<float> o = asFloat(); toLogical(o); return o; }
@@ -529,7 +519,7 @@ struct XYZval {
   FI operator const XYval<T>&()                  const { return *(const XYval<T>*)this; }
 
   // Cast to a type with more fields by making a new object
-  FI operator       XYZEval<T>()                 const { return NUM_AXIS_ARRAY(x, y, z, i, j, k, u, v, w); }
+  FI operator       XYZEval<T>()                 const { return NUM_AXIS_ARRAY(x, y, z, i, j, k); }
 
   // Accessor via an AxisEnum (or any integer) [index]
   FI       T&   operator[](const int n)                { return pos[n]; }
@@ -541,66 +531,66 @@ struct XYZval {
   FI XYZval<T>& operator= (const XYZEval<T> &rs)       { set(NUM_AXIS_ELEM(rs)); return *this; }
 
   // Override other operators to get intuitive behaviors
-  FI XYZval<T>  operator+ (const XYval<T>   &rs) const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x += rs.x, ls.y += rs.y, NOOP        , NOOP        , NOOP        , NOOP        , NOOP        , NOOP        , NOOP        ); return ls; }
-  FI XYZval<T>  operator+ (const XYval<T>   &rs)       { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x += rs.x, ls.y += rs.y, NOOP        , NOOP        , NOOP        , NOOP        , NOOP        , NOOP        , NOOP        ); return ls; }
-  FI XYZval<T>  operator- (const XYval<T>   &rs) const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x -= rs.x, ls.y -= rs.y, NOOP        , NOOP        , NOOP        , NOOP        , NOOP        , NOOP        , NOOP        ); return ls; }
-  FI XYZval<T>  operator- (const XYval<T>   &rs)       { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x -= rs.x, ls.y -= rs.y, NOOP        , NOOP        , NOOP        , NOOP        , NOOP        , NOOP        , NOOP        ); return ls; }
-  FI XYZval<T>  operator* (const XYval<T>   &rs) const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x *= rs.x, ls.y *= rs.y, NOOP        , NOOP        , NOOP        , NOOP        , NOOP        , NOOP        , NOOP        ); return ls; }
-  FI XYZval<T>  operator* (const XYval<T>   &rs)       { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x *= rs.x, ls.y *= rs.y, NOOP        , NOOP        , NOOP        , NOOP        , NOOP        , NOOP        , NOOP        ); return ls; }
-  FI XYZval<T>  operator/ (const XYval<T>   &rs) const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x /= rs.x, ls.y /= rs.y, NOOP        , NOOP        , NOOP        , NOOP        , NOOP        , NOOP        , NOOP        ); return ls; }
-  FI XYZval<T>  operator/ (const XYval<T>   &rs)       { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x /= rs.x, ls.y /= rs.y, NOOP        , NOOP        , NOOP        , NOOP        , NOOP        , NOOP        , NOOP        ); return ls; }
-  FI XYZval<T>  operator+ (const XYZval<T>  &rs) const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x += rs.x, ls.y += rs.y, ls.z += rs.z, ls.i += rs.i, ls.j += rs.j, ls.k += rs.k, ls.u += rs.u, ls.v += rs.v, ls.w += rs.w); return ls; }
-  FI XYZval<T>  operator+ (const XYZval<T>  &rs)       { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x += rs.x, ls.y += rs.y, ls.z += rs.z, ls.i += rs.i, ls.j += rs.j, ls.k += rs.k, ls.u += rs.u, ls.v += rs.v, ls.w += rs.w); return ls; }
-  FI XYZval<T>  operator- (const XYZval<T>  &rs) const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x -= rs.x, ls.y -= rs.y, ls.z -= rs.z, ls.i -= rs.i, ls.j -= rs.j, ls.k -= rs.k, ls.u -= rs.u, ls.v -= rs.v, ls.w -= rs.w); return ls; }
-  FI XYZval<T>  operator- (const XYZval<T>  &rs)       { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x -= rs.x, ls.y -= rs.y, ls.z -= rs.z, ls.i -= rs.i, ls.j -= rs.j, ls.k -= rs.k, ls.u -= rs.u, ls.v -= rs.v, ls.w -= rs.w); return ls; }
-  FI XYZval<T>  operator* (const XYZval<T>  &rs) const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x *= rs.x, ls.y *= rs.y, ls.z *= rs.z, ls.i *= rs.i, ls.j *= rs.j, ls.k *= rs.k, ls.u *= rs.u, ls.v *= rs.v, ls.w *= rs.w); return ls; }
-  FI XYZval<T>  operator* (const XYZval<T>  &rs)       { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x *= rs.x, ls.y *= rs.y, ls.z *= rs.z, ls.i *= rs.i, ls.j *= rs.j, ls.k *= rs.k, ls.u *= rs.u, ls.v *= rs.v, ls.w *= rs.w); return ls; }
-  FI XYZval<T>  operator/ (const XYZval<T>  &rs) const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x /= rs.x, ls.y /= rs.y, ls.z /= rs.z, ls.i /= rs.i, ls.j /= rs.j, ls.k /= rs.k, ls.u /= rs.u, ls.v /= rs.v, ls.w /= rs.w); return ls; }
-  FI XYZval<T>  operator/ (const XYZval<T>  &rs)       { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x /= rs.x, ls.y /= rs.y, ls.z /= rs.z, ls.i /= rs.i, ls.j /= rs.j, ls.k /= rs.k, ls.u /= rs.u, ls.v /= rs.v, ls.w /= rs.w); return ls; }
-  FI XYZval<T>  operator+ (const XYZEval<T> &rs) const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x += rs.x, ls.y += rs.y, ls.z += rs.z, ls.i += rs.i, ls.j += rs.j, ls.k += rs.k, ls.u += rs.u, ls.v += rs.v, ls.w += rs.w); return ls; }
-  FI XYZval<T>  operator+ (const XYZEval<T> &rs)       { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x += rs.x, ls.y += rs.y, ls.z += rs.z, ls.i += rs.i, ls.j += rs.j, ls.k += rs.k, ls.u += rs.u, ls.v += rs.v, ls.w += rs.w); return ls; }
-  FI XYZval<T>  operator- (const XYZEval<T> &rs) const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x -= rs.x, ls.y -= rs.y, ls.z -= rs.z, ls.i -= rs.i, ls.j -= rs.j, ls.k -= rs.k, ls.u -= rs.u, ls.v -= rs.v, ls.w -= rs.w); return ls; }
-  FI XYZval<T>  operator- (const XYZEval<T> &rs)       { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x -= rs.x, ls.y -= rs.y, ls.z -= rs.z, ls.i -= rs.i, ls.j -= rs.j, ls.k -= rs.k, ls.u -= rs.u, ls.v -= rs.v, ls.w -= rs.w); return ls; }
-  FI XYZval<T>  operator* (const XYZEval<T> &rs) const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x *= rs.x, ls.y *= rs.y, ls.z *= rs.z, ls.i *= rs.i, ls.j *= rs.j, ls.k *= rs.k, ls.u *= rs.u, ls.v *= rs.v, ls.w *= rs.w); return ls; }
-  FI XYZval<T>  operator* (const XYZEval<T> &rs)       { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x *= rs.x, ls.y *= rs.y, ls.z *= rs.z, ls.i *= rs.i, ls.j *= rs.j, ls.k *= rs.k, ls.u *= rs.u, ls.v *= rs.v, ls.w *= rs.w); return ls; }
-  FI XYZval<T>  operator/ (const XYZEval<T> &rs) const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x /= rs.x, ls.y /= rs.y, ls.z /= rs.z, ls.i /= rs.i, ls.j /= rs.j, ls.k /= rs.k, ls.u /= rs.u, ls.v /= rs.v, ls.w /= rs.w); return ls; }
-  FI XYZval<T>  operator/ (const XYZEval<T> &rs)       { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x /= rs.x, ls.y /= rs.y, ls.z /= rs.z, ls.i /= rs.i, ls.j /= rs.j, ls.k /= rs.k, ls.u /= rs.u, ls.v /= rs.v, ls.w /= rs.w); return ls; }
-  FI XYZval<T>  operator* (const float &v)       const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x *= v,    ls.y *= v,    ls.z *= v,    ls.i *= v,    ls.j *= v,    ls.k *= v,    ls.u *= v,    ls.v *= v,    ls.w *= v   ); return ls; }
-  FI XYZval<T>  operator* (const float &v)             { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x *= v,    ls.y *= v,    ls.z *= v,    ls.i *= v,    ls.j *= v,    ls.k *= v,    ls.u *= v,    ls.v *= v,    ls.w *= v   ); return ls; }
-  FI XYZval<T>  operator* (const int &v)         const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x *= v,    ls.y *= v,    ls.z *= v,    ls.i *= v,    ls.j *= v,    ls.k *= v,    ls.u *= v,    ls.v *= v,    ls.w *= v   ); return ls; }
-  FI XYZval<T>  operator* (const int &v)               { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x *= v,    ls.y *= v,    ls.z *= v,    ls.i *= v,    ls.j *= v,    ls.k *= v,    ls.u *= v,    ls.v *= v,    ls.w *= v   ); return ls; }
-  FI XYZval<T>  operator/ (const float &v)       const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x /= v,    ls.y /= v,    ls.z /= v,    ls.i /= v,    ls.j /= v,    ls.k /= v,    ls.u /= v,    ls.v /= v,    ls.w /= v   ); return ls; }
-  FI XYZval<T>  operator/ (const float &v)             { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x /= v,    ls.y /= v,    ls.z /= v,    ls.i /= v,    ls.j /= v,    ls.k /= v,    ls.u /= v,    ls.v /= v,    ls.w /= v   ); return ls; }
-  FI XYZval<T>  operator/ (const int &v)         const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x /= v,    ls.y /= v,    ls.z /= v,    ls.i /= v,    ls.j /= v,    ls.k /= v,    ls.u /= v,    ls.v /= v,    ls.w /= v   ); return ls; }
-  FI XYZval<T>  operator/ (const int &v)               { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x /= v,    ls.y /= v,    ls.z /= v,    ls.i /= v,    ls.j /= v,    ls.k /= v,    ls.u /= v,    ls.v /= v,    ls.w /= v   ); return ls; }
-  FI XYZval<T>  operator>>(const int &v)         const { XYZval<T> ls = *this; NUM_AXIS_CODE(_RS(ls.x),    _RS(ls.y),    _RS(ls.z),    _RS(ls.i),    _RS(ls.j),    _RS(ls.k),    _RS(ls.u),    _RS(ls.v),    _RS(ls.w)   ); return ls; }
-  FI XYZval<T>  operator>>(const int &v)               { XYZval<T> ls = *this; NUM_AXIS_CODE(_RS(ls.x),    _RS(ls.y),    _RS(ls.z),    _RS(ls.i),    _RS(ls.j),    _RS(ls.k),    _RS(ls.u),    _RS(ls.v),    _RS(ls.w)   ); return ls; }
-  FI XYZval<T>  operator<<(const int &v)         const { XYZval<T> ls = *this; NUM_AXIS_CODE(_LS(ls.x),    _LS(ls.y),    _LS(ls.z),    _LS(ls.i),    _LS(ls.j),    _LS(ls.k),    _LS(ls.u),    _LS(ls.v),    _LS(ls.w)   ); return ls; }
-  FI XYZval<T>  operator<<(const int &v)               { XYZval<T> ls = *this; NUM_AXIS_CODE(_LS(ls.x),    _LS(ls.y),    _LS(ls.z),    _LS(ls.i),    _LS(ls.j),    _LS(ls.k),    _LS(ls.u),    _LS(ls.v),    _LS(ls.w)   ); return ls; }
-  FI const XYZval<T> operator-()                 const { XYZval<T> o = *this; NUM_AXIS_CODE(o.x = -x, o.y = -y, o.z = -z, o.i = -i, o.j = -j, o.k = -k, o.u = -u, o.v = -v, o.w = -w); return o; }
-  FI XYZval<T>       operator-()                       { XYZval<T> o = *this; NUM_AXIS_CODE(o.x = -x, o.y = -y, o.z = -z, o.i = -i, o.j = -j, o.k = -k, o.u = -u, o.v = -v, o.w = -w); return o; }
+  FI XYZval<T>  operator+ (const XYval<T>   &rs) const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x += rs.x, ls.y += rs.y, NOOP        , NOOP        , NOOP        , NOOP        ); return ls; }
+  FI XYZval<T>  operator+ (const XYval<T>   &rs)       { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x += rs.x, ls.y += rs.y, NOOP        , NOOP        , NOOP        , NOOP        ); return ls; }
+  FI XYZval<T>  operator- (const XYval<T>   &rs) const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x -= rs.x, ls.y -= rs.y, NOOP        , NOOP        , NOOP        , NOOP        ); return ls; }
+  FI XYZval<T>  operator- (const XYval<T>   &rs)       { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x -= rs.x, ls.y -= rs.y, NOOP        , NOOP        , NOOP        , NOOP        ); return ls; }
+  FI XYZval<T>  operator* (const XYval<T>   &rs) const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x *= rs.x, ls.y *= rs.y, NOOP        , NOOP        , NOOP        , NOOP        ); return ls; }
+  FI XYZval<T>  operator* (const XYval<T>   &rs)       { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x *= rs.x, ls.y *= rs.y, NOOP        , NOOP        , NOOP        , NOOP        ); return ls; }
+  FI XYZval<T>  operator/ (const XYval<T>   &rs) const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x /= rs.x, ls.y /= rs.y, NOOP        , NOOP        , NOOP        , NOOP        ); return ls; }
+  FI XYZval<T>  operator/ (const XYval<T>   &rs)       { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x /= rs.x, ls.y /= rs.y, NOOP        , NOOP        , NOOP        , NOOP        ); return ls; }
+  FI XYZval<T>  operator+ (const XYZval<T>  &rs) const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x += rs.x, ls.y += rs.y, ls.z += rs.z, ls.i += rs.i, ls.j += rs.j, ls.k += rs.k); return ls; }
+  FI XYZval<T>  operator+ (const XYZval<T>  &rs)       { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x += rs.x, ls.y += rs.y, ls.z += rs.z, ls.i += rs.i, ls.j += rs.j, ls.k += rs.k); return ls; }
+  FI XYZval<T>  operator- (const XYZval<T>  &rs) const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x -= rs.x, ls.y -= rs.y, ls.z -= rs.z, ls.i -= rs.i, ls.j -= rs.j, ls.k -= rs.k); return ls; }
+  FI XYZval<T>  operator- (const XYZval<T>  &rs)       { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x -= rs.x, ls.y -= rs.y, ls.z -= rs.z, ls.i -= rs.i, ls.j -= rs.j, ls.k -= rs.k); return ls; }
+  FI XYZval<T>  operator* (const XYZval<T>  &rs) const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x *= rs.x, ls.y *= rs.y, ls.z *= rs.z, ls.i *= rs.i, ls.j *= rs.j, ls.k *= rs.k); return ls; }
+  FI XYZval<T>  operator* (const XYZval<T>  &rs)       { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x *= rs.x, ls.y *= rs.y, ls.z *= rs.z, ls.i *= rs.i, ls.j *= rs.j, ls.k *= rs.k); return ls; }
+  FI XYZval<T>  operator/ (const XYZval<T>  &rs) const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x /= rs.x, ls.y /= rs.y, ls.z /= rs.z, ls.i /= rs.i, ls.j /= rs.j, ls.k /= rs.k); return ls; }
+  FI XYZval<T>  operator/ (const XYZval<T>  &rs)       { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x /= rs.x, ls.y /= rs.y, ls.z /= rs.z, ls.i /= rs.i, ls.j /= rs.j, ls.k /= rs.k); return ls; }
+  FI XYZval<T>  operator+ (const XYZEval<T> &rs) const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x += rs.x, ls.y += rs.y, ls.z += rs.z, ls.i += rs.i, ls.j += rs.j, ls.k += rs.k); return ls; }
+  FI XYZval<T>  operator+ (const XYZEval<T> &rs)       { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x += rs.x, ls.y += rs.y, ls.z += rs.z, ls.i += rs.i, ls.j += rs.j, ls.k += rs.k); return ls; }
+  FI XYZval<T>  operator- (const XYZEval<T> &rs) const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x -= rs.x, ls.y -= rs.y, ls.z -= rs.z, ls.i -= rs.i, ls.j -= rs.j, ls.k -= rs.k); return ls; }
+  FI XYZval<T>  operator- (const XYZEval<T> &rs)       { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x -= rs.x, ls.y -= rs.y, ls.z -= rs.z, ls.i -= rs.i, ls.j -= rs.j, ls.k -= rs.k); return ls; }
+  FI XYZval<T>  operator* (const XYZEval<T> &rs) const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x *= rs.x, ls.y *= rs.y, ls.z *= rs.z, ls.i *= rs.i, ls.j *= rs.j, ls.k *= rs.k); return ls; }
+  FI XYZval<T>  operator* (const XYZEval<T> &rs)       { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x *= rs.x, ls.y *= rs.y, ls.z *= rs.z, ls.i *= rs.i, ls.j *= rs.j, ls.k *= rs.k); return ls; }
+  FI XYZval<T>  operator/ (const XYZEval<T> &rs) const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x /= rs.x, ls.y /= rs.y, ls.z /= rs.z, ls.i /= rs.i, ls.j /= rs.j, ls.k /= rs.k); return ls; }
+  FI XYZval<T>  operator/ (const XYZEval<T> &rs)       { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x /= rs.x, ls.y /= rs.y, ls.z /= rs.z, ls.i /= rs.i, ls.j /= rs.j, ls.k /= rs.k); return ls; }
+  FI XYZval<T>  operator* (const float &v)       const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x *= v,    ls.y *= v,    ls.z *= v,    ls.i *= v,    ls.j *= v,    ls.k *= v   ); return ls; }
+  FI XYZval<T>  operator* (const float &v)             { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x *= v,    ls.y *= v,    ls.z *= v,    ls.i *= v,    ls.j *= v,    ls.k *= v   ); return ls; }
+  FI XYZval<T>  operator* (const int &v)         const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x *= v,    ls.y *= v,    ls.z *= v,    ls.i *= v,    ls.j *= v,    ls.k *= v   ); return ls; }
+  FI XYZval<T>  operator* (const int &v)               { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x *= v,    ls.y *= v,    ls.z *= v,    ls.i *= v,    ls.j *= v,    ls.k *= v   ); return ls; }
+  FI XYZval<T>  operator/ (const float &v)       const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x /= v,    ls.y /= v,    ls.z /= v,    ls.i /= v,    ls.j /= v,    ls.k /= v   ); return ls; }
+  FI XYZval<T>  operator/ (const float &v)             { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x /= v,    ls.y /= v,    ls.z /= v,    ls.i /= v,    ls.j /= v,    ls.k /= v   ); return ls; }
+  FI XYZval<T>  operator/ (const int &v)         const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x /= v,    ls.y /= v,    ls.z /= v,    ls.i /= v,    ls.j /= v,    ls.k /= v   ); return ls; }
+  FI XYZval<T>  operator/ (const int &v)               { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x /= v,    ls.y /= v,    ls.z /= v,    ls.i /= v,    ls.j /= v,    ls.k /= v   ); return ls; }
+  FI XYZval<T>  operator>>(const int &v)         const { XYZval<T> ls = *this; NUM_AXIS_CODE(_RS(ls.x),    _RS(ls.y),    _RS(ls.z),    _RS(ls.i),    _RS(ls.j),    _RS(ls.k)   ); return ls; }
+  FI XYZval<T>  operator>>(const int &v)               { XYZval<T> ls = *this; NUM_AXIS_CODE(_RS(ls.x),    _RS(ls.y),    _RS(ls.z),    _RS(ls.i),    _RS(ls.j),    _RS(ls.k)   ); return ls; }
+  FI XYZval<T>  operator<<(const int &v)         const { XYZval<T> ls = *this; NUM_AXIS_CODE(_LS(ls.x),    _LS(ls.y),    _LS(ls.z),    _LS(ls.i),    _LS(ls.j),    _LS(ls.k)   ); return ls; }
+  FI XYZval<T>  operator<<(const int &v)               { XYZval<T> ls = *this; NUM_AXIS_CODE(_LS(ls.x),    _LS(ls.y),    _LS(ls.z),    _LS(ls.i),    _LS(ls.j),    _LS(ls.k)   ); return ls; }
+  FI const XYZval<T> operator-()                 const { XYZval<T> o = *this; NUM_AXIS_CODE(o.x = -x, o.y = -y, o.z = -z, o.i = -i, o.j = -j, o.k = -k); return o; }
+  FI XYZval<T>       operator-()                       { XYZval<T> o = *this; NUM_AXIS_CODE(o.x = -x, o.y = -y, o.z = -z, o.i = -i, o.j = -j, o.k = -k); return o; }
 
   // Modifier operators
-  FI XYZval<T>& operator+=(const XYval<T>   &rs)       { NUM_AXIS_CODE(x += rs.x, y += rs.y, NOOP,      NOOP,      NOOP,      NOOP,      NOOP,      NOOP,      NOOP     ); return *this; }
-  FI XYZval<T>& operator-=(const XYval<T>   &rs)       { NUM_AXIS_CODE(x -= rs.x, y -= rs.y, NOOP,      NOOP,      NOOP,      NOOP,      NOOP,      NOOP,      NOOP     ); return *this; }
-  FI XYZval<T>& operator*=(const XYval<T>   &rs)       { NUM_AXIS_CODE(x *= rs.x, y *= rs.y, NOOP,      NOOP,      NOOP,      NOOP,      NOOP,      NOOP,      NOOP     ); return *this; }
-  FI XYZval<T>& operator/=(const XYval<T>   &rs)       { NUM_AXIS_CODE(x /= rs.x, y /= rs.y, NOOP,      NOOP,      NOOP,      NOOP,      NOOP,      NOOP,      NOOP     ); return *this; }
-  FI XYZval<T>& operator+=(const XYZval<T>  &rs)       { NUM_AXIS_CODE(x += rs.x, y += rs.y, z += rs.z, i += rs.i, j += rs.j, k += rs.k, u += rs.u, v += rs.v, w += rs.w); return *this; }
-  FI XYZval<T>& operator-=(const XYZval<T>  &rs)       { NUM_AXIS_CODE(x -= rs.x, y -= rs.y, z -= rs.z, i -= rs.i, j -= rs.j, k -= rs.k, u -= rs.u, v -= rs.v, w -= rs.w); return *this; }
-  FI XYZval<T>& operator*=(const XYZval<T>  &rs)       { NUM_AXIS_CODE(x *= rs.x, y *= rs.y, z *= rs.z, i *= rs.i, j *= rs.j, k *= rs.k, u *= rs.u, v *= rs.v, w *= rs.w); return *this; }
-  FI XYZval<T>& operator/=(const XYZval<T>  &rs)       { NUM_AXIS_CODE(x /= rs.x, y /= rs.y, z /= rs.z, i /= rs.i, j /= rs.j, k /= rs.k, u /= rs.u, v /= rs.v, w /= rs.w); return *this; }
-  FI XYZval<T>& operator+=(const XYZEval<T> &rs)       { NUM_AXIS_CODE(x += rs.x, y += rs.y, z += rs.z, i += rs.i, j += rs.j, k += rs.k, u += rs.u, v += rs.v, w += rs.w); return *this; }
-  FI XYZval<T>& operator-=(const XYZEval<T> &rs)       { NUM_AXIS_CODE(x -= rs.x, y -= rs.y, z -= rs.z, i -= rs.i, j -= rs.j, k -= rs.k, u -= rs.u, v -= rs.v, w -= rs.w); return *this; }
-  FI XYZval<T>& operator*=(const XYZEval<T> &rs)       { NUM_AXIS_CODE(x *= rs.x, y *= rs.y, z *= rs.z, i *= rs.i, j *= rs.j, k *= rs.k, u *= rs.u, v *= rs.v, w *= rs.w); return *this; }
-  FI XYZval<T>& operator/=(const XYZEval<T> &rs)       { NUM_AXIS_CODE(x /= rs.x, y /= rs.y, z /= rs.z, i /= rs.i, j /= rs.j, k /= rs.k, u /= rs.u, v /= rs.v, w /= rs.w); return *this; }
-  FI XYZval<T>& operator*=(const float &v)             { NUM_AXIS_CODE(x *= v,    y *= v,    z *= v,    i *= v,    j *= v,    k *= v,    u *= v,    v *= v,    w *= v);    return *this; }
-  FI XYZval<T>& operator*=(const int &v)               { NUM_AXIS_CODE(x *= v,    y *= v,    z *= v,    i *= v,    j *= v,    k *= v,    u *= v,    v *= v,    w *= v);    return *this; }
-  FI XYZval<T>& operator>>=(const int &v)              { NUM_AXIS_CODE(_RS(x),    _RS(y),    _RS(z),    _RS(i),    _RS(j),    _RS(k),    _RS(u),    _RS(v),    _RS(w));    return *this; }
-  FI XYZval<T>& operator<<=(const int &v)              { NUM_AXIS_CODE(_LS(x),    _LS(y),    _LS(z),    _LS(i),    _LS(j),    _LS(k),    _LS(u),    _LS(v),    _LS(w));    return *this; }
+  FI XYZval<T>& operator+=(const XYval<T>   &rs)       { NUM_AXIS_CODE(x += rs.x, y += rs.y, NOOP,      NOOP,      NOOP,      NOOP     ); return *this; }
+  FI XYZval<T>& operator-=(const XYval<T>   &rs)       { NUM_AXIS_CODE(x -= rs.x, y -= rs.y, NOOP,      NOOP,      NOOP,      NOOP     ); return *this; }
+  FI XYZval<T>& operator*=(const XYval<T>   &rs)       { NUM_AXIS_CODE(x *= rs.x, y *= rs.y, NOOP,      NOOP,      NOOP,      NOOP     ); return *this; }
+  FI XYZval<T>& operator/=(const XYval<T>   &rs)       { NUM_AXIS_CODE(x /= rs.x, y /= rs.y, NOOP,      NOOP,      NOOP,      NOOP     ); return *this; }
+  FI XYZval<T>& operator+=(const XYZval<T>  &rs)       { NUM_AXIS_CODE(x += rs.x, y += rs.y, z += rs.z, i += rs.i, j += rs.j, k += rs.k); return *this; }
+  FI XYZval<T>& operator-=(const XYZval<T>  &rs)       { NUM_AXIS_CODE(x -= rs.x, y -= rs.y, z -= rs.z, i -= rs.i, j -= rs.j, k -= rs.k); return *this; }
+  FI XYZval<T>& operator*=(const XYZval<T>  &rs)       { NUM_AXIS_CODE(x *= rs.x, y *= rs.y, z *= rs.z, i *= rs.i, j *= rs.j, k *= rs.k); return *this; }
+  FI XYZval<T>& operator/=(const XYZval<T>  &rs)       { NUM_AXIS_CODE(x /= rs.x, y /= rs.y, z /= rs.z, i /= rs.i, j /= rs.j, k /= rs.k); return *this; }
+  FI XYZval<T>& operator+=(const XYZEval<T> &rs)       { NUM_AXIS_CODE(x += rs.x, y += rs.y, z += rs.z, i += rs.i, j += rs.j, k += rs.k); return *this; }
+  FI XYZval<T>& operator-=(const XYZEval<T> &rs)       { NUM_AXIS_CODE(x -= rs.x, y -= rs.y, z -= rs.z, i -= rs.i, j -= rs.j, k -= rs.k); return *this; }
+  FI XYZval<T>& operator*=(const XYZEval<T> &rs)       { NUM_AXIS_CODE(x *= rs.x, y *= rs.y, z *= rs.z, i *= rs.i, j *= rs.j, k *= rs.k); return *this; }
+  FI XYZval<T>& operator/=(const XYZEval<T> &rs)       { NUM_AXIS_CODE(x /= rs.x, y /= rs.y, z /= rs.z, i /= rs.i, j /= rs.j, k /= rs.k); return *this; }
+  FI XYZval<T>& operator*=(const float &v)             { NUM_AXIS_CODE(x *= v,    y *= v,    z *= v,    i *= v,    j *= v,    k *= v);    return *this; }
+  FI XYZval<T>& operator*=(const int &v)               { NUM_AXIS_CODE(x *= v,    y *= v,    z *= v,    i *= v,    j *= v,    k *= v);    return *this; }
+  FI XYZval<T>& operator>>=(const int &v)              { NUM_AXIS_CODE(_RS(x),    _RS(y),    _RS(z),    _RS(i),    _RS(j),    _RS(k));    return *this; }
+  FI XYZval<T>& operator<<=(const int &v)              { NUM_AXIS_CODE(_LS(x),    _LS(y),    _LS(z),    _LS(i),    _LS(j),    _LS(k));    return *this; }
 
   // Exact comparisons. For floats a "NEAR" operation may be better.
-  FI bool       operator==(const XYZEval<T> &rs)       { return true NUM_AXIS_GANG(&& x == rs.x, && y == rs.y, && z == rs.z, && i == rs.i, && j == rs.j, && k == rs.k, && u == rs.u, && v == rs.v, && w == rs.w); }
-  FI bool       operator==(const XYZEval<T> &rs) const { return true NUM_AXIS_GANG(&& x == rs.x, && y == rs.y, && z == rs.z, && i == rs.i, && j == rs.j, && k == rs.k, && u == rs.u, && v == rs.v, && w == rs.w); }
+  FI bool       operator==(const XYZEval<T> &rs)       { return true NUM_AXIS_GANG(&& x == rs.x, && y == rs.y, && z == rs.z, && i == rs.i, && j == rs.j, && k == rs.k); }
+  FI bool       operator==(const XYZEval<T> &rs) const { return true NUM_AXIS_GANG(&& x == rs.x, && y == rs.y, && z == rs.z, && i == rs.i, && j == rs.j, && k == rs.k); }
   FI bool       operator!=(const XYZEval<T> &rs)       { return !operator==(rs); }
   FI bool       operator!=(const XYZEval<T> &rs) const { return !operator==(rs); }
 };
@@ -612,66 +602,56 @@ template<typename T>
 struct XYZEval {
   union {
     struct { T LOGICAL_AXIS_ARGS(); };
-    struct { T LOGICAL_AXIS_LIST(_e, a, b, c, _i, _j, _k, _u, _v, _w); };
+    struct { T LOGICAL_AXIS_LIST(_e, a, b, c, _i, _j, _k); };
     T pos[LOGICAL_AXES];
   };
   // Reset all to 0
-  FI void reset()                     { LOGICAL_AXIS_GANG(e =, x =, y =, z =, i =, j =, k =, u =, v =, w =) 0; }
+  FI void reset()                     { LOGICAL_AXIS_GANG(e =, x =, y =, z =, i =, j =, k =) 0; }
 
   // Setters for some number of linear axes, not all
-  FI void set(const T px)                                                                                       { x = px; }
-  FI void set(const T px, const T py)                                                                           { x = px; y = py; }
+  FI void set(const T px)                                                   { x = px; }
+  FI void set(const T px, const T py)                                       { x = px; y = py; }
   #if HAS_I_AXIS
-    FI void set(const T px, const T py, const T pz)                                                             { x = px; y = py; z = pz; }
+    FI void set(const T px, const T py, const T pz)                         { x = px; y = py; z = pz; }
   #endif
   #if HAS_J_AXIS
-    FI void set(const T px, const T py, const T pz, const T pi)                                                 { x = px; y = py; z = pz; i = pi; }
+    FI void set(const T px, const T py, const T pz, const T pi)             { x = px; y = py; z = pz; i = pi; }
   #endif
   #if HAS_K_AXIS
-    FI void set(const T px, const T py, const T pz, const T pi, const T pj)                                     { x = px; y = py; z = pz; i = pi; j = pj; }
+    FI void set(const T px, const T py, const T pz, const T pi, const T pj) { x = px; y = py; z = pz; i = pi; j = pj; }
   #endif
-  #if HAS_U_AXIS
-    FI void set(const T px, const T py, const T pz, const T pi, const T pj, const T pk)                         { x = px; y = py; z = pz; i = pi; j = pj; k = pk; }
-  #endif
-  #if HAS_V_AXIS
-    FI void set(const T px, const T py, const T pz, const T pi, const T pj, const T pk, const T pm)             { x = px; y = py; z = pz; i = pi; j = pj; k = pk; u = pu; }
-  #endif
-  #if HAS_W_AXIS
-    FI void set(const T px, const T py, const T pz, const T pi, const T pj, const T pk, const T pm, const T po) { x = px; y = py; z = pz; i = pi; j = pj; k = pk; u = pm; v = pv; }
-  #endif
-
   // Setters taking struct types and arrays
-  FI void set(const XYval<T> pxy)                           { x = pxy.x; y = pxy.y; }
-  FI void set(const XYZval<T> pxyz)                         { set(NUM_AXIS_ELEM(pxyz)); }
+  FI void set(const XYval<T> pxy)                  { x = pxy.x; y = pxy.y; }
+  FI void set(const XYZval<T> pxyz)                { set(NUM_AXIS_ELEM(pxyz)); }
   #if HAS_Z_AXIS
-    FI void set(NUM_AXIS_ARGS(const T))                     { NUM_AXIS_CODE(a = x, b = y, c = z, _i = i, _j = j, _k = k, _u = u, _v = v, _w = w); }
+    FI void set(NUM_AXIS_ARGS(const T))            { NUM_AXIS_CODE(a = x, b = y, c = z, _i = i, _j = j, _k = k); }
   #endif
-  FI void set(const XYval<T> pxy, const T pz)               { set(pxy); TERN_(HAS_Z_AXIS, z = pz); }
+  FI void set(const XYval<T> pxy, const T pz)      { set(pxy); TERN_(HAS_Z_AXIS, z = pz); }
   #if LOGICAL_AXES > NUM_AXES
     FI void set(const XYval<T> pxy, const T pz, const T pe) { set(pxy, pz); e = pe; }
-    FI void set(const XYZval<T> pxyz, const T pe)           { set(pxyz); e = pe; }
-    FI void set(LOGICAL_AXIS_ARGS(const T))                 { LOGICAL_AXIS_CODE(_e = e, a = x, b = y, c = z, _i = i, _j = j, _k = k, _u = u, _v = v, _w = w); }
+    FI void set(const XYZval<T> pxyz, const T pe)  { set(pxyz); e = pe; }
+    FI void set(LOGICAL_AXIS_ARGS(const T))        { LOGICAL_AXIS_CODE(_e = e, a = x, b = y, c = z, _i = i, _j = j, _k = k); }
   #endif
 
   // Length reduced to one dimension
-  FI T magnitude()                                 const { return (T)sqrtf(LOGICAL_AXIS_GANG(+ e*e, + x*x, + y*y, + z*z, + i*i, + j*j, + k*k, + u*u, + v*v, + w*w)); }
+  FI T magnitude()                                 const { return (T)sqrtf(LOGICAL_AXIS_GANG(+ e*e, + x*x, + y*y, + z*z, + i*i, + j*j, + k*k)); }
   // Pointer to the data as a simple array
   FI operator T* ()                                      { return pos; }
   // If any element is true then it's true
-  FI operator bool()                                     { return 0 LOGICAL_AXIS_GANG(|| e, || x, || y, || z, || i, || j, || k, || u, || v, || w); }
+  FI operator bool()                                     { return 0 LOGICAL_AXIS_GANG(|| e, || x, || y, || z, || i, || j, || k); }
 
   // Explicit copy and copies with conversion
-  FI XYZEval<T>          copy()  const { XYZEval<T> v = *this; return v; }
-  FI XYZEval<T>           ABS()  const { return LOGICAL_AXIS_ARRAY(T(_ABS(e)), T(_ABS(x)), T(_ABS(y)), T(_ABS(z)), T(_ABS(i)), T(_ABS(j)), T(_ABS(k)), T(_ABS(u)), T(_ABS(v)), T(_ABS(w))); }
-  FI XYZEval<int16_t>   asInt()        { return LOGICAL_AXIS_ARRAY(int16_t(e), int16_t(x), int16_t(y), int16_t(z), int16_t(i), int16_t(j), int16_t(k), int16_t(u), int16_t(v), int16_t(w)); }
-  FI XYZEval<int16_t>   asInt()  const { return LOGICAL_AXIS_ARRAY(int16_t(e), int16_t(x), int16_t(y), int16_t(z), int16_t(i), int16_t(j), int16_t(k), int16_t(u), int16_t(v), int16_t(w)); }
-  FI XYZEval<int32_t>  asLong()        { return LOGICAL_AXIS_ARRAY(int32_t(e), int32_t(x), int32_t(y), int32_t(z), int32_t(i), int32_t(j), int32_t(k), int32_t(u), int32_t(v), int32_t(w)); }
-  FI XYZEval<int32_t>  asLong()  const { return LOGICAL_AXIS_ARRAY(int32_t(e), int32_t(x), int32_t(y), int32_t(z), int32_t(i), int32_t(j), int32_t(k), int32_t(u), int32_t(v), int32_t(w)); }
-  FI XYZEval<int32_t>  ROUNDL()        { return LOGICAL_AXIS_ARRAY(int32_t(LROUND(e)), int32_t(LROUND(x)), int32_t(LROUND(y)), int32_t(LROUND(z)), int32_t(LROUND(i)), int32_t(LROUND(j)), int32_t(LROUND(k)), int32_t(LROUND(u)), int32_t(LROUND(v)), int32_t(LROUND(w))); }
-  FI XYZEval<int32_t>  ROUNDL()  const { return LOGICAL_AXIS_ARRAY(int32_t(LROUND(e)), int32_t(LROUND(x)), int32_t(LROUND(y)), int32_t(LROUND(z)), int32_t(LROUND(i)), int32_t(LROUND(j)), int32_t(LROUND(k)), int32_t(LROUND(u)), int32_t(LROUND(v)), int32_t(LROUND(w))); }
-  FI XYZEval<float>   asFloat()        { return LOGICAL_AXIS_ARRAY(static_cast<float>(e), static_cast<float>(x), static_cast<float>(y), static_cast<float>(z), static_cast<float>(i), static_cast<float>(j), static_cast<float>(k), static_cast<float>(u), static_cast<float>(v), static_cast<float>(w)); }
-  FI XYZEval<float>   asFloat()  const { return LOGICAL_AXIS_ARRAY(static_cast<float>(e), static_cast<float>(x), static_cast<float>(y), static_cast<float>(z), static_cast<float>(i), static_cast<float>(j), static_cast<float>(k), static_cast<float>(u), static_cast<float>(v), static_cast<float>(w)); }
-  FI XYZEval<float> reciprocal() const { return LOGICAL_AXIS_ARRAY(_RECIP(e),  _RECIP(x),  _RECIP(y),  _RECIP(z),  _RECIP(i),  _RECIP(j),  _RECIP(k),  _RECIP(u),  _RECIP(v),  _RECIP(w)); }
+  FI XYZEval<T>          copy()  const { XYZEval<T> o = *this; return o; }
+  FI XYZEval<T>           ABS()  const { return LOGICAL_AXIS_ARRAY(T(_ABS(e)), T(_ABS(x)), T(_ABS(y)), T(_ABS(z)), T(_ABS(i)), T(_ABS(j)), T(_ABS(k))); }
+  FI XYZEval<int16_t>   asInt()        { return LOGICAL_AXIS_ARRAY(int16_t(e), int16_t(x), int16_t(y), int16_t(z), int16_t(i), int16_t(j), int16_t(k)); }
+  FI XYZEval<int16_t>   asInt()  const { return LOGICAL_AXIS_ARRAY(int16_t(e), int16_t(x), int16_t(y), int16_t(z), int16_t(i), int16_t(j), int16_t(k)); }
+  FI XYZEval<int32_t>  asLong()        { return LOGICAL_AXIS_ARRAY(int32_t(e), int32_t(x), int32_t(y), int32_t(z), int32_t(i), int32_t(j), int32_t(k)); }
+  FI XYZEval<int32_t>  asLong()  const { return LOGICAL_AXIS_ARRAY(int32_t(e), int32_t(x), int32_t(y), int32_t(z), int32_t(i), int32_t(j), int32_t(k)); }
+  FI XYZEval<int32_t>  ROUNDL()        { return LOGICAL_AXIS_ARRAY(int32_t(LROUND(e)), int32_t(LROUND(x)), int32_t(LROUND(y)), int32_t(LROUND(z)), int32_t(LROUND(i)), int32_t(LROUND(j)), int32_t(LROUND(k))); }
+  FI XYZEval<int32_t>  ROUNDL()  const { return LOGICAL_AXIS_ARRAY(int32_t(LROUND(e)), int32_t(LROUND(x)), int32_t(LROUND(y)), int32_t(LROUND(z)), int32_t(LROUND(i)), int32_t(LROUND(j)), int32_t(LROUND(k))); }
+  FI XYZEval<float>   asFloat()        { return LOGICAL_AXIS_ARRAY(static_cast<float>(e), static_cast<float>(x), static_cast<float>(y), static_cast<float>(z), static_cast<float>(i), static_cast<float>(j), static_cast<float>(k)); }
+  FI XYZEval<float>   asFloat()  const { return LOGICAL_AXIS_ARRAY(static_cast<float>(e), static_cast<float>(x), static_cast<float>(y), static_cast<float>(z), static_cast<float>(i), static_cast<float>(j), static_cast<float>(k)); }
+  FI XYZEval<float> reciprocal() const { return LOGICAL_AXIS_ARRAY(_RECIP(e),  _RECIP(x),  _RECIP(y),  _RECIP(z),  _RECIP(i),  _RECIP(j),  _RECIP(k)); }
 
   // Marlin workspace shifting is done with G92 and M206
   FI XYZEval<float> asLogical()  const { XYZEval<float> o = asFloat(); toLogical(o); return o; }
@@ -688,7 +668,7 @@ struct XYZEval {
   FI const T&    operator[](const int n)            const { return pos[n]; }
 
   // Assignment operator overrides do the expected thing
-  FI XYZEval<T>& operator= (const T v)                    { set(LIST_N_1(NUM_AXES, v)); return *this; }
+  FI XYZEval<T>& operator= (const T v)                    { set(LOGICAL_AXIS_LIST_1(v)); return *this; }
   FI XYZEval<T>& operator= (const XYval<T>   &rs)         { set(rs.x, rs.y); return *this; }
   FI XYZEval<T>& operator= (const XYZval<T>  &rs)         { set(NUM_AXIS_ELEM(rs)); return *this; }
 
@@ -701,57 +681,57 @@ struct XYZEval {
   FI XYZEval<T>  operator* (const XYval<T>   &rs)         { XYZEval<T> ls = *this; ls.x *= rs.x; ls.y *= rs.y; return ls; }
   FI XYZEval<T>  operator/ (const XYval<T>   &rs)   const { XYZEval<T> ls = *this; ls.x /= rs.x; ls.y /= rs.y; return ls; }
   FI XYZEval<T>  operator/ (const XYval<T>   &rs)         { XYZEval<T> ls = *this; ls.x /= rs.x; ls.y /= rs.y; return ls; }
-  FI XYZEval<T>  operator+ (const XYZval<T>  &rs)   const { XYZval<T>  ls = *this; NUM_AXIS_CODE(ls.x += rs.x, ls.y += rs.y, ls.z += rs.z, ls.i += rs.i, ls.j += rs.j, ls.k += rs.k, ls.u += rs.u, ls.v += rs.v, ls.w += rs.w); return ls; }
-  FI XYZEval<T>  operator+ (const XYZval<T>  &rs)         { XYZval<T>  ls = *this; NUM_AXIS_CODE(ls.x += rs.x, ls.y += rs.y, ls.z += rs.z, ls.i += rs.i, ls.j += rs.j, ls.k += rs.k, ls.u += rs.u, ls.v += rs.v, ls.w += rs.w); return ls; }
-  FI XYZEval<T>  operator- (const XYZval<T>  &rs)   const { XYZval<T>  ls = *this; NUM_AXIS_CODE(ls.x -= rs.x, ls.y -= rs.y, ls.z -= rs.z, ls.i -= rs.i, ls.j -= rs.j, ls.k -= rs.k, ls.u -= rs.u, ls.v -= rs.v, ls.w -= rs.w); return ls; }
-  FI XYZEval<T>  operator- (const XYZval<T>  &rs)         { XYZval<T>  ls = *this; NUM_AXIS_CODE(ls.x -= rs.x, ls.y -= rs.y, ls.z -= rs.z, ls.i -= rs.i, ls.j -= rs.j, ls.k -= rs.k, ls.u -= rs.u, ls.v -= rs.v, ls.w -= rs.w); return ls; }
-  FI XYZEval<T>  operator* (const XYZval<T>  &rs)   const { XYZval<T>  ls = *this; NUM_AXIS_CODE(ls.x *= rs.x, ls.y *= rs.y, ls.z *= rs.z, ls.i *= rs.i, ls.j *= rs.j, ls.k *= rs.k, ls.u *= rs.u, ls.v *= rs.v, ls.w *= rs.w); return ls; }
-  FI XYZEval<T>  operator* (const XYZval<T>  &rs)         { XYZval<T>  ls = *this; NUM_AXIS_CODE(ls.x *= rs.x, ls.y *= rs.y, ls.z *= rs.z, ls.i *= rs.i, ls.j *= rs.j, ls.k *= rs.k, ls.u *= rs.u, ls.v *= rs.v, ls.w *= rs.w); return ls; }
-  FI XYZEval<T>  operator/ (const XYZval<T>  &rs)   const { XYZval<T>  ls = *this; NUM_AXIS_CODE(ls.x /= rs.x, ls.y /= rs.y, ls.z /= rs.z, ls.i /= rs.i, ls.j /= rs.j, ls.k /= rs.k, ls.u /= rs.u, ls.v /= rs.v, ls.w /= rs.w); return ls; }
-  FI XYZEval<T>  operator/ (const XYZval<T>  &rs)         { XYZval<T>  ls = *this; NUM_AXIS_CODE(ls.x /= rs.x, ls.y /= rs.y, ls.z /= rs.z, ls.i /= rs.i, ls.j /= rs.j, ls.k /= rs.k, ls.u /= rs.u, ls.v /= rs.v, ls.w /= rs.w); return ls; }
-  FI XYZEval<T>  operator+ (const XYZEval<T>  &rs)  const { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e += rs.e, ls.x += rs.x, ls.y += rs.y, ls.z += rs.z, ls.i += rs.i, ls.j += rs.j, ls.k += rs.k, ls.u += rs.u, ls.v += rs.v, ls.w += rs.w); return ls; }
-  FI XYZEval<T>  operator+ (const XYZEval<T>  &rs)        { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e += rs.e, ls.x += rs.x, ls.y += rs.y, ls.z += rs.z, ls.i += rs.i, ls.j += rs.j, ls.k += rs.k, ls.u += rs.u, ls.v += rs.v, ls.w += rs.w); return ls; }
-  FI XYZEval<T>  operator- (const XYZEval<T>  &rs)  const { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e -= rs.e, ls.x -= rs.x, ls.y -= rs.y, ls.z -= rs.z, ls.i -= rs.i, ls.j -= rs.j, ls.k -= rs.k, ls.u -= rs.u, ls.v -= rs.v, ls.w -= rs.w); return ls; }
-  FI XYZEval<T>  operator- (const XYZEval<T>  &rs)        { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e -= rs.e, ls.x -= rs.x, ls.y -= rs.y, ls.z -= rs.z, ls.i -= rs.i, ls.j -= rs.j, ls.k -= rs.k, ls.u -= rs.u, ls.v -= rs.v, ls.w -= rs.w); return ls; }
-  FI XYZEval<T>  operator* (const XYZEval<T>  &rs)  const { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e *= rs.e, ls.x *= rs.x, ls.y *= rs.y, ls.z *= rs.z, ls.i *= rs.i, ls.j *= rs.j, ls.k *= rs.k, ls.u *= rs.u, ls.v *= rs.v, ls.w *= rs.w); return ls; }
-  FI XYZEval<T>  operator* (const XYZEval<T>  &rs)        { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e *= rs.e, ls.x *= rs.x, ls.y *= rs.y, ls.z *= rs.z, ls.i *= rs.i, ls.j *= rs.j, ls.k *= rs.k, ls.u *= rs.u, ls.v *= rs.v, ls.w *= rs.w); return ls; }
-  FI XYZEval<T>  operator/ (const XYZEval<T>  &rs)  const { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e /= rs.e, ls.x /= rs.x, ls.y /= rs.y, ls.z /= rs.z, ls.i /= rs.i, ls.j /= rs.j, ls.k /= rs.k, ls.u /= rs.u, ls.v /= rs.v, ls.w /= rs.w); return ls; }
-  FI XYZEval<T>  operator/ (const XYZEval<T>  &rs)        { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e /= rs.e, ls.x /= rs.x, ls.y /= rs.y, ls.z /= rs.z, ls.i /= rs.i, ls.j /= rs.j, ls.k /= rs.k, ls.u /= rs.u, ls.v /= rs.v, ls.w /= rs.w); return ls; }
-  FI XYZEval<T>  operator* (const float &v)         const { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e *= v,    ls.x *= v,    ls.y *= v,    ls.z *= v,    ls.i *= v,    ls.j *= v,    ls.k *= v,    ls.u *= v,    ls.v *= v,    ls.w *= v   ); return ls; }
-  FI XYZEval<T>  operator* (const float &v)               { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e *= v,    ls.x *= v,    ls.y *= v,    ls.z *= v,    ls.i *= v,    ls.j *= v,    ls.k *= v,    ls.u *= v,    ls.v *= v,    ls.w *= v   ); return ls; }
-  FI XYZEval<T>  operator* (const int &v)           const { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e *= v,    ls.x *= v,    ls.y *= v,    ls.z *= v,    ls.i *= v,    ls.j *= v,    ls.k *= v,    ls.u *= v,    ls.v *= v,    ls.w *= v   ); return ls; }
-  FI XYZEval<T>  operator* (const int &v)                 { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e *= v,    ls.x *= v,    ls.y *= v,    ls.z *= v,    ls.i *= v,    ls.j *= v,    ls.k *= v,    ls.u *= v,    ls.v *= v,    ls.w *= v   ); return ls; }
-  FI XYZEval<T>  operator/ (const float &v)         const { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e /= v,    ls.x /= v,    ls.y /= v,    ls.z /= v,    ls.i /= v,    ls.j /= v,    ls.k /= v,    ls.u /= v,    ls.v /= v,    ls.w /= v   ); return ls; }
-  FI XYZEval<T>  operator/ (const float &v)               { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e /= v,    ls.x /= v,    ls.y /= v,    ls.z /= v,    ls.i /= v,    ls.j /= v,    ls.k /= v,    ls.u /= v,    ls.v /= v,    ls.w /= v   ); return ls; }
-  FI XYZEval<T>  operator/ (const int &v)           const { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e /= v,    ls.x /= v,    ls.y /= v,    ls.z /= v,    ls.i /= v,    ls.j /= v,    ls.k /= v,    ls.u /= v,    ls.v /= v,    ls.w /= v   ); return ls; }
-  FI XYZEval<T>  operator/ (const int &v)                 { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e /= v,    ls.x /= v,    ls.y /= v,    ls.z /= v,    ls.i /= v,    ls.j /= v,    ls.k /= v,    ls.u /= v,    ls.v /= v,    ls.w /= v   ); return ls; }
-  FI XYZEval<T>  operator>>(const int &v)           const { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(_RS(ls.e),    _RS(ls.x),    _RS(ls.y),    _RS(ls.z),    _RS(ls.i),    _RS(ls.j),    _RS(ls.k),    _RS(ls.u),    _RS(ls.v),    _RS(ls.w)   ); return ls; }
-  FI XYZEval<T>  operator>>(const int &v)                 { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(_RS(ls.e),    _RS(ls.x),    _RS(ls.y),    _RS(ls.z),    _RS(ls.i),    _RS(ls.j),    _RS(ls.k),    _RS(ls.u),    _RS(ls.v),    _RS(ls.w)   ); return ls; }
-  FI XYZEval<T>  operator<<(const int &v)           const { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(_LS(ls.e),    _LS(ls.x),    _LS(ls.y),    _LS(ls.z),    _LS(ls.i),    _LS(ls.j),    _LS(ls.k),    _LS(ls.u),    _LS(ls.v),    _LS(ls.w)   ); return ls; }
-  FI XYZEval<T>  operator<<(const int &v)                 { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(_LS(ls.e),    _LS(ls.x),    _LS(ls.y),    _LS(ls.z),    _LS(ls.i),    _LS(ls.j),    _LS(ls.k),    _LS(ls.u),    _LS(ls.v),    _LS(ls.w)   ); return ls; }
-  FI const XYZEval<T> operator-()                   const { return LOGICAL_AXIS_ARRAY(-e, -x, -y, -z, -i, -j, -k, -u, -v, -w); }
-  FI       XYZEval<T> operator-()                         { return LOGICAL_AXIS_ARRAY(-e, -x, -y, -z, -i, -j, -k, -u, -v, -w); }
+  FI XYZEval<T>  operator+ (const XYZval<T>  &rs)   const { XYZval<T>  ls = *this; NUM_AXIS_CODE(ls.x += rs.x, ls.y += rs.y, ls.z += rs.z, ls.i += rs.i, ls.j += rs.j, ls.k += rs.k); return ls; }
+  FI XYZEval<T>  operator+ (const XYZval<T>  &rs)         { XYZval<T>  ls = *this; NUM_AXIS_CODE(ls.x += rs.x, ls.y += rs.y, ls.z += rs.z, ls.i += rs.i, ls.j += rs.j, ls.k += rs.k); return ls; }
+  FI XYZEval<T>  operator- (const XYZval<T>  &rs)   const { XYZval<T>  ls = *this; NUM_AXIS_CODE(ls.x -= rs.x, ls.y -= rs.y, ls.z -= rs.z, ls.i -= rs.i, ls.j -= rs.j, ls.k -= rs.k); return ls; }
+  FI XYZEval<T>  operator- (const XYZval<T>  &rs)         { XYZval<T>  ls = *this; NUM_AXIS_CODE(ls.x -= rs.x, ls.y -= rs.y, ls.z -= rs.z, ls.i -= rs.i, ls.j -= rs.j, ls.k -= rs.k); return ls; }
+  FI XYZEval<T>  operator* (const XYZval<T>  &rs)   const { XYZval<T>  ls = *this; NUM_AXIS_CODE(ls.x *= rs.x, ls.y *= rs.y, ls.z *= rs.z, ls.i *= rs.i, ls.j *= rs.j, ls.k *= rs.k); return ls; }
+  FI XYZEval<T>  operator* (const XYZval<T>  &rs)         { XYZval<T>  ls = *this; NUM_AXIS_CODE(ls.x *= rs.x, ls.y *= rs.y, ls.z *= rs.z, ls.i *= rs.i, ls.j *= rs.j, ls.k *= rs.k); return ls; }
+  FI XYZEval<T>  operator/ (const XYZval<T>  &rs)   const { XYZval<T>  ls = *this; NUM_AXIS_CODE(ls.x /= rs.x, ls.y /= rs.y, ls.z /= rs.z, ls.i /= rs.i, ls.j /= rs.j, ls.k /= rs.k); return ls; }
+  FI XYZEval<T>  operator/ (const XYZval<T>  &rs)         { XYZval<T>  ls = *this; NUM_AXIS_CODE(ls.x /= rs.x, ls.y /= rs.y, ls.z /= rs.z, ls.i /= rs.i, ls.j /= rs.j, ls.k /= rs.k); return ls; }
+  FI XYZEval<T>  operator+ (const XYZEval<T>  &rs)  const { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e += rs.e, ls.x += rs.x, ls.y += rs.y, ls.z += rs.z, ls.i += rs.i, ls.j += rs.j, ls.k += rs.k); return ls; }
+  FI XYZEval<T>  operator+ (const XYZEval<T>  &rs)        { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e += rs.e, ls.x += rs.x, ls.y += rs.y, ls.z += rs.z, ls.i += rs.i, ls.j += rs.j, ls.k += rs.k); return ls; }
+  FI XYZEval<T>  operator- (const XYZEval<T>  &rs)  const { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e -= rs.e, ls.x -= rs.x, ls.y -= rs.y, ls.z -= rs.z, ls.i -= rs.i, ls.j -= rs.j, ls.k -= rs.k); return ls; }
+  FI XYZEval<T>  operator- (const XYZEval<T>  &rs)        { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e -= rs.e, ls.x -= rs.x, ls.y -= rs.y, ls.z -= rs.z, ls.i -= rs.i, ls.j -= rs.j, ls.k -= rs.k); return ls; }
+  FI XYZEval<T>  operator* (const XYZEval<T>  &rs)  const { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e *= rs.e, ls.x *= rs.x, ls.y *= rs.y, ls.z *= rs.z, ls.i *= rs.i, ls.j *= rs.j, ls.k *= rs.k); return ls; }
+  FI XYZEval<T>  operator* (const XYZEval<T>  &rs)        { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e *= rs.e, ls.x *= rs.x, ls.y *= rs.y, ls.z *= rs.z, ls.i *= rs.i, ls.j *= rs.j, ls.k *= rs.k); return ls; }
+  FI XYZEval<T>  operator/ (const XYZEval<T>  &rs)  const { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e /= rs.e, ls.x /= rs.x, ls.y /= rs.y, ls.z /= rs.z, ls.i /= rs.i, ls.j /= rs.j, ls.k /= rs.k); return ls; }
+  FI XYZEval<T>  operator/ (const XYZEval<T>  &rs)        { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e /= rs.e, ls.x /= rs.x, ls.y /= rs.y, ls.z /= rs.z, ls.i /= rs.i, ls.j /= rs.j, ls.k /= rs.k); return ls; }
+  FI XYZEval<T>  operator* (const float &v)         const { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e *= v,    ls.x *= v,    ls.y *= v,    ls.z *= v,    ls.i *= v,    ls.j *= v,    ls.k *= v   ); return ls; }
+  FI XYZEval<T>  operator* (const float &v)               { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e *= v,    ls.x *= v,    ls.y *= v,    ls.z *= v,    ls.i *= v,    ls.j *= v,    ls.k *= v   ); return ls; }
+  FI XYZEval<T>  operator* (const int &v)           const { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e *= v,    ls.x *= v,    ls.y *= v,    ls.z *= v,    ls.i *= v,    ls.j *= v,    ls.k *= v   ); return ls; }
+  FI XYZEval<T>  operator* (const int &v)                 { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e *= v,    ls.x *= v,    ls.y *= v,    ls.z *= v,    ls.i *= v,    ls.j *= v,    ls.k *= v   ); return ls; }
+  FI XYZEval<T>  operator/ (const float &v)         const { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e /= v,    ls.x /= v,    ls.y /= v,    ls.z /= v,    ls.i /= v,    ls.j /= v,    ls.k /= v   ); return ls; }
+  FI XYZEval<T>  operator/ (const float &v)               { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e /= v,    ls.x /= v,    ls.y /= v,    ls.z /= v,    ls.i /= v,    ls.j /= v,    ls.k /= v   ); return ls; }
+  FI XYZEval<T>  operator/ (const int &v)           const { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e /= v,    ls.x /= v,    ls.y /= v,    ls.z /= v,    ls.i /= v,    ls.j /= v,    ls.k /= v   ); return ls; }
+  FI XYZEval<T>  operator/ (const int &v)                 { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e /= v,    ls.x /= v,    ls.y /= v,    ls.z /= v,    ls.i /= v,    ls.j /= v,    ls.k /= v   ); return ls; }
+  FI XYZEval<T>  operator>>(const int &v)           const { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(_RS(ls.e),    _RS(ls.x),    _RS(ls.y),    _RS(ls.z),    _RS(ls.i),    _RS(ls.j),    _RS(ls.k)   ); return ls; }
+  FI XYZEval<T>  operator>>(const int &v)                 { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(_RS(ls.e),    _RS(ls.x),    _RS(ls.y),    _RS(ls.z),    _RS(ls.i),    _RS(ls.j),    _RS(ls.k)   ); return ls; }
+  FI XYZEval<T>  operator<<(const int &v)           const { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(_LS(ls.e),    _LS(ls.x),    _LS(ls.y),    _LS(ls.z),    _LS(ls.i),    _LS(ls.j),    _LS(ls.k)   ); return ls; }
+  FI XYZEval<T>  operator<<(const int &v)                 { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(_LS(ls.e),    _LS(ls.x),    _LS(ls.y),    _LS(ls.z),    _LS(ls.i),    _LS(ls.j),    _LS(ls.k)   ); return ls; }
+  FI const XYZEval<T> operator-()                   const { return LOGICAL_AXIS_ARRAY(-e, -x, -y, -z, -i, -j, -k); }
+  FI       XYZEval<T> operator-()                         { return LOGICAL_AXIS_ARRAY(-e, -x, -y, -z, -i, -j, -k); }
 
   // Modifier operators
   FI XYZEval<T>& operator+=(const XYval<T>   &rs)         { x += rs.x; y += rs.y; return *this; }
   FI XYZEval<T>& operator-=(const XYval<T>   &rs)         { x -= rs.x; y -= rs.y; return *this; }
   FI XYZEval<T>& operator*=(const XYval<T>   &rs)         { x *= rs.x; y *= rs.y; return *this; }
   FI XYZEval<T>& operator/=(const XYval<T>   &rs)         { x /= rs.x; y /= rs.y; return *this; }
-  FI XYZEval<T>& operator+=(const XYZval<T>  &rs)         { NUM_AXIS_CODE(x += rs.x, y += rs.y, z += rs.z, i += rs.i, j += rs.j, k += rs.k, u += rs.u, v += rs.v, w += rs.w); return *this; }
-  FI XYZEval<T>& operator-=(const XYZval<T>  &rs)         { NUM_AXIS_CODE(x -= rs.x, y -= rs.y, z -= rs.z, i -= rs.i, j -= rs.j, k -= rs.k, u -= rs.u, v -= rs.v, w -= rs.w); return *this; }
-  FI XYZEval<T>& operator*=(const XYZval<T>  &rs)         { NUM_AXIS_CODE(x *= rs.x, y *= rs.y, z *= rs.z, i *= rs.i, j *= rs.j, k *= rs.k, u *= rs.u, v *= rs.v, w *= rs.w); return *this; }
-  FI XYZEval<T>& operator/=(const XYZval<T>  &rs)         { NUM_AXIS_CODE(x /= rs.x, y /= rs.y, z /= rs.z, i /= rs.i, j /= rs.j, k /= rs.k, u /= rs.u, v /= rs.v, w /= rs.w); return *this; }
-  FI XYZEval<T>& operator+=(const XYZEval<T> &rs)         { LOGICAL_AXIS_CODE(e += rs.e, x += rs.x, y += rs.y, z += rs.z, i += rs.i, j += rs.j, k += rs.k, u += rs.u, v += rs.v, w += rs.w); return *this; }
-  FI XYZEval<T>& operator-=(const XYZEval<T> &rs)         { LOGICAL_AXIS_CODE(e -= rs.e, x -= rs.x, y -= rs.y, z -= rs.z, i -= rs.i, j -= rs.j, k -= rs.k, u -= rs.u, v -= rs.v, w -= rs.w); return *this; }
-  FI XYZEval<T>& operator*=(const XYZEval<T> &rs)         { LOGICAL_AXIS_CODE(e *= rs.e, x *= rs.x, y *= rs.y, z *= rs.z, i *= rs.i, j *= rs.j, k *= rs.k, u *= rs.u, v *= rs.v, w *= rs.w); return *this; }
-  FI XYZEval<T>& operator/=(const XYZEval<T> &rs)         { LOGICAL_AXIS_CODE(e /= rs.e, x /= rs.x, y /= rs.y, z /= rs.z, i /= rs.i, j /= rs.j, k /= rs.k, u /= rs.u, v /= rs.v, w /= rs.w); return *this; }
-  FI XYZEval<T>& operator*=(const T &v)                   { LOGICAL_AXIS_CODE(e *= v,    x *= v,    y *= v,    z *= v,    i *= v,    j *= v,    k *= v,    u *= v,    v *= v,    w *= v);    return *this; }
-  FI XYZEval<T>& operator>>=(const int &v)                { LOGICAL_AXIS_CODE(_RS(e),    _RS(x),    _RS(y),    _RS(z),    _RS(i),    _RS(j),    _RS(k),    _RS(u),    _RS(v),    _RS(w));    return *this; }
-  FI XYZEval<T>& operator<<=(const int &v)                { LOGICAL_AXIS_CODE(_LS(e),    _LS(x),    _LS(y),    _LS(z),    _LS(i),    _LS(j),    _LS(k),    _LS(u),    _LS(v),    _LS(w));    return *this; }
+  FI XYZEval<T>& operator+=(const XYZval<T>  &rs)         { NUM_AXIS_CODE(x += rs.x, y += rs.y, z += rs.z, i += rs.i, j += rs.j, k += rs.k); return *this; }
+  FI XYZEval<T>& operator-=(const XYZval<T>  &rs)         { NUM_AXIS_CODE(x -= rs.x, y -= rs.y, z -= rs.z, i -= rs.i, j -= rs.j, k -= rs.k); return *this; }
+  FI XYZEval<T>& operator*=(const XYZval<T>  &rs)         { NUM_AXIS_CODE(x *= rs.x, y *= rs.y, z *= rs.z, i *= rs.i, j *= rs.j, k *= rs.k); return *this; }
+  FI XYZEval<T>& operator/=(const XYZval<T>  &rs)         { NUM_AXIS_CODE(x /= rs.x, y /= rs.y, z /= rs.z, i /= rs.i, j /= rs.j, k /= rs.k); return *this; }
+  FI XYZEval<T>& operator+=(const XYZEval<T> &rs)         { LOGICAL_AXIS_CODE(e += rs.e, x += rs.x, y += rs.y, z += rs.z, i += rs.i, j += rs.j, k += rs.k); return *this; }
+  FI XYZEval<T>& operator-=(const XYZEval<T> &rs)         { LOGICAL_AXIS_CODE(e -= rs.e, x -= rs.x, y -= rs.y, z -= rs.z, i -= rs.i, j -= rs.j, k -= rs.k); return *this; }
+  FI XYZEval<T>& operator*=(const XYZEval<T> &rs)         { LOGICAL_AXIS_CODE(e *= rs.e, x *= rs.x, y *= rs.y, z *= rs.z, i *= rs.i, j *= rs.j, k *= rs.k); return *this; }
+  FI XYZEval<T>& operator/=(const XYZEval<T> &rs)         { LOGICAL_AXIS_CODE(e /= rs.e, x /= rs.x, y /= rs.y, z /= rs.z, i /= rs.i, j /= rs.j, k /= rs.k); return *this; }
+  FI XYZEval<T>& operator*=(const T &v)                   { LOGICAL_AXIS_CODE(e *= v,    x *= v,    y *= v,    z *= v,    i *= v,    j *= v,    k *= v);    return *this; }
+  FI XYZEval<T>& operator>>=(const int &v)                { LOGICAL_AXIS_CODE(_RS(e),    _RS(x),    _RS(y),    _RS(z),    _RS(i),    _RS(j),    _RS(k));    return *this; }
+  FI XYZEval<T>& operator<<=(const int &v)                { LOGICAL_AXIS_CODE(_LS(e),    _LS(x),    _LS(y),    _LS(z),    _LS(i),    _LS(j),    _LS(k));    return *this; }
 
   // Exact comparisons. For floats a "NEAR" operation may be better.
-  FI bool        operator==(const XYZval<T>  &rs)         { return true NUM_AXIS_GANG(&& x == rs.x, && y == rs.y, && z == rs.z, && i == rs.i, && j == rs.j, && k == rs.k, && u == rs.u, && v == rs.v, && w == rs.w); }
-  FI bool        operator==(const XYZval<T>  &rs)   const { return true NUM_AXIS_GANG(&& x == rs.x, && y == rs.y, && z == rs.z, && i == rs.i, && j == rs.j, && k == rs.k, && u == rs.u, && v == rs.v, && w == rs.w); }
+  FI bool        operator==(const XYZval<T>  &rs)         { return true NUM_AXIS_GANG(&& x == rs.x, && y == rs.y, && z == rs.z, && i == rs.i, && j == rs.j, && k == rs.k); }
+  FI bool        operator==(const XYZval<T>  &rs)   const { return true NUM_AXIS_GANG(&& x == rs.x, && y == rs.y, && z == rs.z, && i == rs.i, && j == rs.j, && k == rs.k); }
   FI bool        operator!=(const XYZval<T>  &rs)         { return !operator==(rs); }
   FI bool        operator!=(const XYZval<T>  &rs)   const { return !operator==(rs); }
 };

Marlin/src/core/utility.cpp

@@ -29,10 +29,10 @@ void safe_delay(millis_t ms) {
   while (ms > 50) {
     ms -= 50;
     delay(50);
-    thermalManager.manage_heater();
+    thermalManager.task();
   }
   delay(ms);
-  thermalManager.manage_heater(); // This keeps us safe if too many small safe_delay() calls are made
+  thermalManager.task(); // This keeps us safe if too many small safe_delay() calls are made
 }
 
 // A delay to provide brittle hosts time to receive bytes
@@ -51,7 +51,7 @@ void safe_delay(millis_t ms) {
 
   #include "../module/probe.h"
   #include "../module/motion.h"
-  #include "../module/stepper.h"
+  #include "../module/planner.h"
   #include "../libs/numtostr.h"
   #include "../feature/bedlevel/bedlevel.h"
 
@@ -132,11 +132,10 @@ void safe_delay(millis_t ms) {
         #else
           #if ENABLED(AUTO_BED_LEVELING_UBL)
             SERIAL_ECHOPGM("UBL Adjustment Z");
-            const float rz = bedlevel.get_z_correction(current_position);
           #elif ENABLED(AUTO_BED_LEVELING_BILINEAR)
             SERIAL_ECHOPGM("ABL Adjustment Z");
-            const float rz = bedlevel.get_z_correction(current_position);
           #endif
+          const float rz = bedlevel.get_z_correction(current_position);
           SERIAL_ECHO(ftostr43sign(rz, '+'));
           #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
             if (planner.z_fade_height) {
@@ -156,11 +155,13 @@ void safe_delay(millis_t ms) {
       SERIAL_ECHOPGM("Mesh Bed Leveling");
       if (planner.leveling_active) {
         SERIAL_ECHOLNPGM(" (enabled)");
-        SERIAL_ECHOPGM("MBL Adjustment Z", ftostr43sign(bedlevel.get_z(current_position), '+'));
+        const float z_offset = bedlevel.get_z_offset(),
+                    z_correction = bedlevel.get_z_correction(current_position);
+        SERIAL_ECHOPGM("MBL Adjustment Z", ftostr43sign(z_offset + z_correction, '+'));
         #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
           if (planner.z_fade_height) {
             SERIAL_ECHOPGM(" (", ftostr43sign(
-              bedlevel.get_z(current_position, planner.fade_scaling_factor_for_z(current_position.z)), '+'
+              z_offset + z_correction * planner.fade_scaling_factor_for_z(current_position.z), '+'
             ));
             SERIAL_CHAR(')');
           }

Marlin/src/core/utility.h

@@ -59,6 +59,11 @@ void safe_delay(millis_t ms);           // Delay ensuring that temperatures are
   #define log_machine_info() NOOP
 #endif
 
+/**
+ * A restorer instance remembers a variable's value before setting a
+ * new value, then restores the old value when it goes out of scope.
+ * Put operator= on your type to get extended behavior on value change.
+ */
 template<typename T>
 class restorer {
   T& ref_;
@@ -78,12 +83,12 @@ public:
 constexpr uint8_t ui8_to_percent(const uint8_t i) { return (int(i) * 100 + 127) / 255; }
 
 // Axis names for G-code parsing, reports, etc.
-const xyze_char_t axis_codes LOGICAL_AXIS_ARRAY('E', 'X', 'Y', 'Z', AXIS4_NAME, AXIS5_NAME, AXIS6_NAME, AXIS7_NAME, AXIS8_NAME, AXIS9_NAME);
+const xyze_char_t axis_codes LOGICAL_AXIS_ARRAY('E', 'X', 'Y', 'Z', AXIS4_NAME, AXIS5_NAME, AXIS6_NAME);
 #if NUM_AXES <= XYZ && !HAS_EXTRUDERS
   #define AXIS_CHAR(A) ((char)('X' + A))
   #define IAXIS_CHAR AXIS_CHAR
 #else
-  const xyze_char_t iaxis_codes LOGICAL_AXIS_ARRAY('E', 'X', 'Y', 'Z', 'I', 'J', 'K', 'U', 'V', 'W');
+  const xyze_char_t iaxis_codes LOGICAL_AXIS_ARRAY('E', 'X', 'Y', 'Z', 'I', 'J', 'K');
   #define AXIS_CHAR(A) axis_codes[A]
   #define IAXIS_CHAR(A) iaxis_codes[A]
 #endif

Marlin/src/feature/bedlevel/bedlevel.cpp

@@ -154,7 +154,7 @@ void reset_bed_level() {
       #endif
       LOOP_L_N(x, sx) {
         SERIAL_CHAR(' ');
-        const float offset = values[x * sx + y];
+        const float offset = values[x * sy + y];
         if (!isnan(offset)) {
           if (offset >= 0) SERIAL_CHAR('+');
           SERIAL_ECHO_F(offset, int(precision));

Marlin/src/feature/bedlevel/ubl/ubl_G29.cpp

@@ -31,7 +31,6 @@
 #include "../../../libs/hex_print.h"
 #include "../../../module/settings.h"
 #include "../../../lcd/marlinui.h"
-#include "../../../module/stepper.h"
 #include "../../../module/planner.h"
 #include "../../../module/motion.h"
 #include "../../../module/probe.h"
@@ -317,42 +316,6 @@ void unified_bed_leveling::G29() {
     // Send 'N' to force homing before G29 (internal only)
     if (axes_should_home() || parser.seen_test('N')) gcode.home_all_axes();
     TERN_(HAS_MULTI_HOTEND, if (active_extruder != 0) tool_change(0, true));
-
-    // Position bed horizontally and Z probe vertically.
-    #if    defined(SAFE_BED_LEVELING_START_X) || defined(SAFE_BED_LEVELING_START_Y) || defined(SAFE_BED_LEVELING_START_Z) \
-        || defined(SAFE_BED_LEVELING_START_I) || defined(SAFE_BED_LEVELING_START_J) || defined(SAFE_BED_LEVELING_START_K) \
-        || defined(SAFE_BED_LEVELING_START_U) || defined(SAFE_BED_LEVELING_START_V) || defined(SAFE_BED_LEVELING_START_W)
-      xyze_pos_t safe_position = current_position;
-      #ifdef SAFE_BED_LEVELING_START_X
-        safe_position.x = SAFE_BED_LEVELING_START_X;
-      #endif
-      #ifdef SAFE_BED_LEVELING_START_Y
-        safe_position.y = SAFE_BED_LEVELING_START_Y;
-      #endif
-      #ifdef SAFE_BED_LEVELING_START_Z
-        safe_position.z = SAFE_BED_LEVELING_START_Z;
-      #endif
-      #ifdef SAFE_BED_LEVELING_START_I
-        safe_position.i = SAFE_BED_LEVELING_START_I;
-      #endif
-      #ifdef SAFE_BED_LEVELING_START_J
-        safe_position.j = SAFE_BED_LEVELING_START_J;
-      #endif
-      #ifdef SAFE_BED_LEVELING_START_K
-        safe_position.k = SAFE_BED_LEVELING_START_K;
-      #endif
-      #ifdef SAFE_BED_LEVELING_START_U
-        safe_position.u = SAFE_BED_LEVELING_START_U;
-      #endif
-      #ifdef SAFE_BED_LEVELING_START_V
-        safe_position.v = SAFE_BED_LEVELING_START_V;
-      #endif
-      #ifdef SAFE_BED_LEVELING_START_W
-        safe_position.w = SAFE_BED_LEVELING_START_W;
-      #endif
-
-      do_blocking_move_to(safe_position);
-    #endif
   }
 
   // Invalidate one or more nearby mesh points, possibly all.

Marlin/src/feature/bedlevel/ubl/ubl_motion.cpp

@@ -26,7 +26,6 @@
 
 #include "../bedlevel.h"
 #include "../../../module/planner.h"
-#include "../../../module/stepper.h"
 #include "../../../module/motion.h"
 
 #if ENABLED(DELTA)
@@ -36,8 +35,18 @@
 #include "../../../MarlinCore.h"
 #include <math.h>
 
+//#define DEBUG_UBL_MOTION
+#define DEBUG_OUT ENABLED(DEBUG_UBL_MOTION)
+#include "../../../core/debug_out.h"
+
 #if !UBL_SEGMENTED
 
+  // TODO: The first and last parts of a move might result in very short segment(s)
+  //       after getting split on the cell boundary, so moves like that should not
+  //       get split. This will be most common for moves that start/end near the
+  //       corners of cells. To fix the issue, simply check if the start/end of the line
+  //       is very close to a cell boundary in advance and don't split the line there.
+
   void unified_bed_leveling::line_to_destination_cartesian(const_feedRate_t scaled_fr_mm_s, const uint8_t extruder) {
     /**
      * Much of the nozzle movement will be within the same cell. So we will do as little computation
@@ -176,7 +185,9 @@
           dest.z += z0;
           planner.buffer_segment(dest, scaled_fr_mm_s, extruder);
 
-        } //else printf("FIRST MOVE PRUNED  ");
+        }
+        else
+          DEBUG_ECHOLNPGM("[ubl] skip Y segment");
       }
 
       // At the final destination? Usually not, but when on a Y Mesh Line it's completed.
@@ -225,7 +236,9 @@
           dest.z += z0;
           if (!planner.buffer_segment(dest, scaled_fr_mm_s, extruder)) break;
 
-        } //else printf("FIRST MOVE PRUNED  ");
+        }
+        else
+          DEBUG_ECHOLNPGM("[ubl] skip Y segment");
       }
 
       if (xy_pos_t(current_position) != xy_pos_t(end))
@@ -360,11 +373,12 @@
     #endif
 
     NOLESS(segments, 1U);                                                            // Must have at least one segment
-    const float inv_segments = 1.0f / segments,                                      // Reciprocal to save calculation
-                segment_xyz_mm = SQRT(cart_xy_mm_2 + sq(total.z)) * inv_segments;    // Length of each segment
+    const float inv_segments = 1.0f / segments;                                      // Reciprocal to save calculation
 
+    // Add hints to help optimize the move
+    PlannerHints hints(SQRT(cart_xy_mm_2 + sq(total.z)) * inv_segments);             // Length of each segment
     #if ENABLED(SCARA_FEEDRATE_SCALING)
-      const float inv_duration = scaled_fr_mm_s / segment_xyz_mm;
+      hints.inv_duration = scaled_fr_mm_s / hints.millimeters;
     #endif
 
     xyze_float_t diff = total * inv_segments;
@@ -378,13 +392,9 @@
     if (!planner.leveling_active || !planner.leveling_active_at_z(destination.z)) {
       while (--segments) {
         raw += diff;
-        planner.buffer_line(raw, scaled_fr_mm_s, active_extruder, segment_xyz_mm
-          OPTARG(SCARA_FEEDRATE_SCALING, inv_duration)
-        );
+        planner.buffer_line(raw, scaled_fr_mm_s, active_extruder, hints);
       }
-      planner.buffer_line(destination, scaled_fr_mm_s, active_extruder, segment_xyz_mm
-        OPTARG(SCARA_FEEDRATE_SCALING, inv_duration)
-      );
+      planner.buffer_line(destination, scaled_fr_mm_s, active_extruder, hints);
       return false; // Did not set current from destination
     }
 
@@ -453,7 +463,7 @@
           TERN_(ENABLE_LEVELING_FADE_HEIGHT, * fade_scaling_factor); // apply fade factor to interpolated height
 
         const float oldz = raw.z; raw.z += z_cxcy;
-        planner.buffer_line(raw, scaled_fr_mm_s, active_extruder, segment_xyz_mm OPTARG(SCARA_FEEDRATE_SCALING, inv_duration) );
+        planner.buffer_line(raw, scaled_fr_mm_s, active_extruder, hints);
         raw.z = oldz;
 
         if (segments == 0)                        // done with last segment

Marlin/src/feature/bltouch.cpp

@@ -45,7 +45,7 @@ void stop();
 
 bool BLTouch::command(const BLTCommand cmd, const millis_t &ms) {
   if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPGM("BLTouch Command :", cmd);
-  MOVE_SERVO(Z_PROBE_SERVO_NR, cmd);
+  servo[Z_PROBE_SERVO_NR].move(cmd);
   safe_delay(_MAX(ms, (uint32_t)BLTOUCH_DELAY)); // BLTOUCH_DELAY is also the *minimum* delay
   return triggered();
 }

Marlin/src/feature/dac/dac_dac084s085.cpp

@@ -11,7 +11,6 @@
 #include "dac_dac084s085.h"
 
 #include "../../MarlinCore.h"
-#include "../../module/stepper.h"
 #include "../../HAL/shared/Delay.h"
 
 dac084s085::dac084s085() { }

Marlin/src/feature/direct_stepping.cpp

@@ -143,14 +143,16 @@ namespace DirectStepping {
           // special case for 8-bit, check if rolled back to 0
           if (Cfg::DIRECTIONAL || !write_page_size) { // full 256 bytes
             if (write_byte_idx) return true;
-          } else {
-            if (write_byte_idx < write_page_size) return true;
           }
-        } else if (Cfg::DIRECTIONAL) {
-          if (write_byte_idx != Cfg::PAGE_SIZE) return true;
-        } else {
-          if (write_byte_idx < write_page_size) return true;
+          else if (write_byte_idx < write_page_size)
+            return true;
         }
+        else if (Cfg::DIRECTIONAL) {
+          if (write_byte_idx != Cfg::PAGE_SIZE)
+            return true;
+        }
+        else if (write_byte_idx < write_page_size)
+          return true;
 
         state = State::CHECKSUM;
         return true;
@@ -161,11 +163,10 @@ namespace DirectStepping {
         return true;
       }
       case State::UNFAIL:
-        if (c == 0) {
+        if (c == 0)
           set_page_state(write_page_idx, PageState::FREE);
-        } else {
+        else
           fatal_error = true;
-        }
         state = State::MONITOR;
         return true;
     }

Marlin/src/feature/fwretract.cpp

@@ -34,7 +34,6 @@ FWRetract fwretract; // Single instance - this calls the constructor
 
 #include "../module/motion.h"
 #include "../module/planner.h"
-#include "../module/stepper.h"
 
 #include "../gcode/gcode.h"
 

Marlin/src/feature/joystick.cpp

@@ -172,8 +172,9 @@ Joystick joystick;
       current_position += move_dist;
       apply_motion_limits(current_position);
       const float length = sqrt(hypot2);
+      PlannerHints hints(length);
       injecting_now = true;
-      planner.buffer_line(current_position, length / seg_time, active_extruder, length);
+      planner.buffer_line(current_position, length / seg_time, active_extruder, hints);
       injecting_now = false;
     }
   }

Marlin/src/feature/max7219.cpp

@@ -44,7 +44,6 @@
 #include "max7219.h"
 
 #include "../module/planner.h"
-#include "../module/stepper.h"
 #include "../MarlinCore.h"
 #include "../HAL/shared/Delay.h"
 

Marlin/src/feature/pause.cpp

@@ -35,10 +35,13 @@
 #include "../gcode/gcode.h"
 #include "../module/motion.h"
 #include "../module/planner.h"
-#include "../module/stepper.h"
 #include "../module/printcounter.h"
 #include "../module/temperature.h"
 
+#if HAS_EXTRUDERS
+  #include "../module/stepper.h"
+#endif
+
 #if ENABLED(AUTO_BED_LEVELING_UBL)
   #include "bedlevel/bedlevel.h"
 #endif
@@ -63,7 +66,7 @@
 
 #include "../lcd/marlinui.h"
 
-#if HAS_BUZZER
+#if HAS_SOUND
   #include "../libs/buzzer.h"
 #endif
 
@@ -98,7 +101,7 @@ fil_change_settings_t fc_settings[EXTRUDERS];
   #define _PMSG(L) L##_LCD
 #endif
 
-#if HAS_BUZZER
+#if HAS_SOUND
   static void impatient_beep(const int8_t max_beep_count, const bool restart=false) {
 
     if (TERN0(HAS_MARLINUI_MENU, pause_mode == PAUSE_MODE_PAUSE_PRINT)) return;
@@ -711,9 +714,13 @@ void resume_print(const_float_t slow_load_length/*=0*/, const_float_t fast_load_
 
   TERN_(HAS_FILAMENT_SENSOR, runout.reset());
 
-  TERN(DWIN_LCD_PROUI, DWIN_Print_Resume(), ui.reset_status());
-  TERN_(HAS_MARLINUI_MENU, ui.return_to_status());
-  TERN_(DWIN_LCD_PROUI, HMI_ReturnScreen());
+  #if ENABLED(DWIN_LCD_PROUI)
+    DWIN_Print_Resume();
+    HMI_ReturnScreen();
+  #else
+    ui.reset_status();
+    ui.return_to_status();
+  #endif
 }
 
 #endif // ADVANCED_PAUSE_FEATURE

Marlin/src/feature/power.cpp

@@ -30,7 +30,7 @@
 
 #include "power.h"
 #include "../module/planner.h"
-#include "../module/stepper.h"
+#include "../module/stepper/indirection.h" // for restore_stepper_drivers
 #include "../module/temperature.h"
 #include "../MarlinCore.h"
 
@@ -46,6 +46,7 @@ Power powerManager;
 bool Power::psu_on;
 
 #if ENABLED(AUTO_POWER_CONTROL)
+  #include "../module/stepper.h"
   #include "../module/temperature.h"
 
   #if BOTH(USE_CONTROLLER_FAN, AUTO_POWER_CONTROLLERFAN)

Marlin/src/feature/power_monitor.cpp

@@ -53,7 +53,7 @@ PowerMonitor power_monitor; // Single instance - this calls the constructor
     void PowerMonitor::draw_current() {
       const float amps = getAmps();
       lcd_put_u8str(amps < 100 ? ftostr31ns(amps) : ui16tostr4rj((uint16_t)amps));
-      lcd_put_wchar('A');
+      lcd_put_lchar('A');
     }
   #endif
 
@@ -61,7 +61,7 @@ PowerMonitor power_monitor; // Single instance - this calls the constructor
     void PowerMonitor::draw_voltage() {
       const float volts = getVolts();
       lcd_put_u8str(volts < 100 ? ftostr31ns(volts) : ui16tostr4rj((uint16_t)volts));
-      lcd_put_wchar('V');
+      lcd_put_lchar('V');
     }
   #endif
 
@@ -69,7 +69,7 @@ PowerMonitor power_monitor; // Single instance - this calls the constructor
     void PowerMonitor::draw_power() {
       const float power = getPower();
       lcd_put_u8str(power < 100 ? ftostr31ns(power) : ui16tostr4rj((uint16_t)power));
-      lcd_put_wchar('W');
+      lcd_put_lchar('W');
     }
   #endif
 

Marlin/src/feature/power_monitor.h

@@ -32,7 +32,7 @@ struct pm_lpf_t {
   uint32_t filter_buf;
   float value;
   void add_sample(const uint16_t sample) {
-    filter_buf = filter_buf - (filter_buf >> K_VALUE) + (uint32_t(sample) << K_SCALE);
+    filter_buf += (uint32_t(sample) << K_SCALE) - (filter_buf >> K_VALUE);
   }
   void capture() {
     value = filter_buf * (SCALE * (1.0f / (1UL << (PM_K_VALUE + PM_K_SCALE))));

Marlin/src/feature/spindle_laser.cpp

@@ -39,18 +39,26 @@
 #endif
 
 SpindleLaser cutter;
-uint8_t SpindleLaser::power,
+bool SpindleLaser::enable_state;                                      // Virtual enable state, controls enable pin if present and or apply power if > 0
+uint8_t SpindleLaser::power,                                          // Actual power output 0-255 ocr or "0 = off" > 0 = "on"
         SpindleLaser::last_power_applied; // = 0                      // Basic power state tracking
-#if ENABLED(LASER_FEATURE)
-  cutter_test_pulse_t SpindleLaser::testPulse = 50;                   // Test fire Pulse time ms value.
-#endif
-bool SpindleLaser::isReady;                                           // Ready to apply power setting from the UI to OCR
-cutter_power_t SpindleLaser::menuPower,                               // Power set via LCD menu in PWM, PERCENT, or RPM
-               SpindleLaser::unitPower;                               // LCD status power in PWM, PERCENT, or RPM
 
-#if ENABLED(MARLIN_DEV_MODE)
-  cutter_frequency_t SpindleLaser::frequency;                         // PWM frequency setting; range: 2K - 50K
+#if ENABLED(LASER_FEATURE)
+  cutter_test_pulse_t SpindleLaser::testPulse = 50;                   // (ms) Test fire pulse default duration
+  uint8_t SpindleLaser::last_block_power; // = 0                      // Track power changes for dynamic inline power
+  feedRate_t SpindleLaser::feedrate_mm_m = 1500,
+             SpindleLaser::last_feedrate_mm_m; // = 0                 // (mm/min) Track feedrate changes for dynamic power
 #endif
+
+bool SpindleLaser::isReadyForUI = false;                              // Ready to apply power setting from the UI to OCR
+CutterMode SpindleLaser::cutter_mode = CUTTER_MODE_STANDARD;          // Default is standard mode
+
+constexpr cutter_cpower_t SpindleLaser::power_floor;
+cutter_power_t SpindleLaser::menuPower = 0,                           // Power value via LCD menu in PWM, PERCENT, or RPM based on configured format set by CUTTER_POWER_UNIT.
+               SpindleLaser::unitPower = 0;                           // Unit power is in PWM, PERCENT, or RPM based on CUTTER_POWER_UNIT.
+
+cutter_frequency_t SpindleLaser::frequency;                           // PWM frequency setting; range: 2K - 50K
+
 #define SPINDLE_LASER_PWM_OFF TERN(SPINDLE_LASER_PWM_INVERT, 255, 0)
 
 /**
@@ -58,21 +66,21 @@ cutter_power_t SpindleLaser::menuPower,                               // Power s
  */
 void SpindleLaser::init() {
   #if ENABLED(SPINDLE_SERVO)
-    MOVE_SERVO(SPINDLE_SERVO_NR, SPINDLE_SERVO_MIN);
+    servo[SPINDLE_SERVO_NR].move(SPINDLE_SERVO_MIN);
   #else
     OUT_WRITE(SPINDLE_LASER_ENA_PIN, !SPINDLE_LASER_ACTIVE_STATE);    // Init spindle to off
   #endif
   #if ENABLED(SPINDLE_CHANGE_DIR)
     OUT_WRITE(SPINDLE_DIR_PIN, SPINDLE_INVERT_DIR);                   // Init rotation to clockwise (M3)
   #endif
+  #if ENABLED(HAL_CAN_SET_PWM_FREQ) && SPINDLE_LASER_FREQUENCY
+    frequency = SPINDLE_LASER_FREQUENCY;
+    hal.set_pwm_frequency(pin_t(SPINDLE_LASER_PWM_PIN), SPINDLE_LASER_FREQUENCY);
+  #endif
   #if ENABLED(SPINDLE_LASER_USE_PWM)
     SET_PWM(SPINDLE_LASER_PWM_PIN);
     hal.set_pwm_duty(pin_t(SPINDLE_LASER_PWM_PIN), SPINDLE_LASER_PWM_OFF); // Set to lowest speed
   #endif
-  #if ENABLED(HAL_CAN_SET_PWM_FREQ) && SPINDLE_LASER_FREQUENCY
-    hal.set_pwm_frequency(pin_t(SPINDLE_LASER_PWM_PIN), SPINDLE_LASER_FREQUENCY);
-    TERN_(MARLIN_DEV_MODE, frequency = SPINDLE_LASER_FREQUENCY);
-  #endif
   #if ENABLED(AIR_EVACUATION)
     OUT_WRITE(AIR_EVACUATION_PIN, !AIR_EVACUATION_ACTIVE);            // Init Vacuum/Blower OFF
   #endif
@@ -90,7 +98,7 @@ void SpindleLaser::init() {
    */
   void SpindleLaser::_set_ocr(const uint8_t ocr) {
     #if ENABLED(HAL_CAN_SET_PWM_FREQ) && SPINDLE_LASER_FREQUENCY
-      hal.set_pwm_frequency(pin_t(SPINDLE_LASER_PWM_PIN), TERN(MARLIN_DEV_MODE, frequency, SPINDLE_LASER_FREQUENCY));
+      hal.set_pwm_frequency(pin_t(SPINDLE_LASER_PWM_PIN), frequency);
     #endif
     hal.set_pwm_duty(pin_t(SPINDLE_LASER_PWM_PIN), ocr ^ SPINDLE_LASER_PWM_OFF);
   }
@@ -107,35 +115,41 @@ void SpindleLaser::init() {
 #endif // SPINDLE_LASER_USE_PWM
 
 /**
- * Apply power for laser/spindle
+ * Apply power for Laser or Spindle
  *
  * Apply cutter power value for PWM, Servo, and on/off pin.
  *
- * @param opwr Power value. Range 0 to MAX. When 0 disable spindle/laser.
+ * @param opwr Power value. Range 0 to MAX.
  */
 void SpindleLaser::apply_power(const uint8_t opwr) {
-  if (opwr == last_power_applied) return;
-  last_power_applied = opwr;
-  power = opwr;
-  #if ENABLED(SPINDLE_LASER_USE_PWM)
-    if (cutter.unitPower == 0 && CUTTER_UNIT_IS(RPM)) {
-      ocr_off();
-      isReady = false;
-    }
-    else if (ENABLED(CUTTER_POWER_RELATIVE) || enabled()) {
-      set_ocr(power);
-      isReady = true;
-    }
-    else {
-      ocr_off();
-      isReady = false;
-    }
-  #elif ENABLED(SPINDLE_SERVO)
-    MOVE_SERVO(SPINDLE_SERVO_NR, power);
-  #else
-    WRITE(SPINDLE_LASER_ENA_PIN, enabled() ? SPINDLE_LASER_ACTIVE_STATE : !SPINDLE_LASER_ACTIVE_STATE);
-    isReady = true;
-  #endif
+  if (enabled() || opwr == 0) {                                   // 0 check allows us to disable where no ENA pin exists
+    // Test and set the last power used to improve performance
+    if (opwr == last_power_applied) return;
+    last_power_applied = opwr;
+    // Handle PWM driven or just simple on/off
+    #if ENABLED(SPINDLE_LASER_USE_PWM)
+      if (CUTTER_UNIT_IS(RPM) && unitPower == 0)
+        ocr_off();
+      else if (ENABLED(CUTTER_POWER_RELATIVE) || enabled() || opwr == 0) {
+        set_ocr(opwr);
+        isReadyForUI = true;
+      }
+      else
+        ocr_off();
+    #elif ENABLED(SPINDLE_SERVO)
+      MOVE_SERVO(SPINDLE_SERVO_NR, power);
+    #else
+      WRITE(SPINDLE_LASER_ENA_PIN, enabled() ? SPINDLE_LASER_ACTIVE_STATE : !SPINDLE_LASER_ACTIVE_STATE);
+      isReadyForUI = true;
+    #endif
+  }
+  else {
+    #if PIN_EXISTS(SPINDLE_LASER_ENA)
+      WRITE(SPINDLE_LASER_ENA_PIN, !SPINDLE_LASER_ACTIVE_STATE);
+    #endif
+    isReadyForUI = false; // Only used for UI display updates.
+    TERN_(SPINDLE_LASER_USE_PWM, ocr_off());
+  }
 }
 
 #if ENABLED(SPINDLE_CHANGE_DIR)

Marlin/src/feature/spindle_laser.h

@@ -34,85 +34,97 @@
   #include "../libs/buzzer.h"
 #endif
 
-#if ENABLED(LASER_POWER_INLINE)
-  #include "../module/planner.h"
-#endif
+// Inline laser power
+#include "../module/planner.h"
 
 #define PCT_TO_PWM(X) ((X) * 255 / 100)
 #define PCT_TO_SERVO(X) ((X) * 180 / 100)
 
+// Laser/Cutter operation mode
+enum CutterMode : int8_t {
+  CUTTER_MODE_ERROR = -1,
+  CUTTER_MODE_STANDARD,     // M3 power is applied directly and waits for planner moves to sync.
+  CUTTER_MODE_CONTINUOUS,   // M3 or G1/2/3 move power is controlled within planner blocks, set with 'M3 I', cleared with 'M5 I'.
+  CUTTER_MODE_DYNAMIC       // M4 laser power is proportional to the feed rate, set with 'M4 I', cleared with 'M5 I'.
+};
+
 class SpindleLaser {
 public:
-  static const inline uint8_t pct_to_ocr(const_float_t pct) { return uint8_t(PCT_TO_PWM(pct)); }
+  static CutterMode cutter_mode;
+
+  static constexpr uint8_t pct_to_ocr(const_float_t pct) { return uint8_t(PCT_TO_PWM(pct)); }
 
   // cpower = configured values (e.g., SPEED_POWER_MAX)
-
   // Convert configured power range to a percentage
-  static const inline uint8_t cpwr_to_pct(const cutter_cpower_t cpwr) {
-    constexpr cutter_cpower_t power_floor = TERN(CUTTER_POWER_RELATIVE, SPEED_POWER_MIN, 0),
-                              power_range = SPEED_POWER_MAX - power_floor;
-    return cpwr ? round(100.0f * (cpwr - power_floor) / power_range) : 0;
+  static constexpr cutter_cpower_t power_floor = TERN(CUTTER_POWER_RELATIVE, SPEED_POWER_MIN, 0);
+  static constexpr uint8_t cpwr_to_pct(const cutter_cpower_t cpwr) {
+    return cpwr ? round(100.0f * (cpwr - power_floor) / (SPEED_POWER_MAX - power_floor)) : 0;
   }
 
-  // Convert a cpower (e.g., SPEED_POWER_STARTUP) to unit power (upwr, upower),
-  // which can be PWM, Percent, Servo angle, or RPM (rel/abs).
-  static const inline cutter_power_t cpwr_to_upwr(const cutter_cpower_t cpwr) { // STARTUP power to Unit power
-    const cutter_power_t upwr = (
+  // Convert config defines from RPM to %, angle or PWM when in Spindle mode
+  // and convert from PERCENT to PWM when in Laser mode
+  static constexpr cutter_power_t cpwr_to_upwr(const cutter_cpower_t cpwr) { // STARTUP power to Unit power
+    return (
       #if ENABLED(SPINDLE_FEATURE)
-        // Spindle configured values are in RPM
+        // Spindle configured define values are in RPM
         #if CUTTER_UNIT_IS(RPM)
-          cpwr                            // to RPM
-        #elif CUTTER_UNIT_IS(PERCENT)     // to PCT
-          cpwr_to_pct(cpwr)
-        #elif CUTTER_UNIT_IS(SERVO)       // to SERVO angle
-          PCT_TO_SERVO(cpwr_to_pct(cpwr))
-        #else                             // to PWM
-          PCT_TO_PWM(cpwr_to_pct(cpwr))
+          cpwr                            // to same
+        #elif CUTTER_UNIT_IS(PERCENT)
+          cpwr_to_pct(cpwr)               // to Percent
+        #elif CUTTER_UNIT_IS(SERVO)
+          PCT_TO_SERVO(cpwr_to_pct(cpwr)) // to SERVO angle
+        #else
+          PCT_TO_PWM(cpwr_to_pct(cpwr))   // to PWM
         #endif
       #else
-        // Laser configured values are in PCT
+        // Laser configured define values are in Percent
         #if CUTTER_UNIT_IS(PWM255)
-          PCT_TO_PWM(cpwr)
+          PCT_TO_PWM(cpwr)                // to PWM
         #else
-          cpwr                            // to RPM/PCT
+          cpwr                            // to same
         #endif
       #endif
     );
-    return upwr;
   }
 
-  static const cutter_power_t mpower_min() { return cpwr_to_upwr(SPEED_POWER_MIN); }
-  static const cutter_power_t mpower_max() { return cpwr_to_upwr(SPEED_POWER_MAX); }
+  static constexpr cutter_power_t mpower_min() { return cpwr_to_upwr(SPEED_POWER_MIN); }
+  static constexpr cutter_power_t mpower_max() { return cpwr_to_upwr(SPEED_POWER_MAX); }
 
   #if ENABLED(LASER_FEATURE)
-    static cutter_test_pulse_t testPulse; // Test fire Pulse ms value
+    static cutter_test_pulse_t testPulse;                 // (ms) Test fire pulse duration
+    static uint8_t last_block_power;                      // Track power changes for dynamic power
+
+    static feedRate_t feedrate_mm_m, last_feedrate_mm_m;  // (mm/min) Track feedrate changes for dynamic power
+    static bool laser_feedrate_changed() {
+      const bool changed = last_feedrate_mm_m != feedrate_mm_m;
+      if (changed) last_feedrate_mm_m = feedrate_mm_m;
+      return changed;
+    }
   #endif
 
-  static bool isReady;                    // Ready to apply power setting from the UI to OCR
+  static bool isReadyForUI;               // Ready to apply power setting from the UI to OCR
+  static bool enable_state;
   static uint8_t power,
                  last_power_applied;      // Basic power state tracking
 
-  #if ENABLED(MARLIN_DEV_MODE)
-    static cutter_frequency_t frequency;  // Set PWM frequency; range: 2K-50K
-  #endif
+  static cutter_frequency_t frequency;  // Set PWM frequency; range: 2K-50K
 
   static cutter_power_t menuPower,        // Power as set via LCD menu in PWM, Percentage or RPM
                         unitPower;        // Power as displayed status in PWM, Percentage or RPM
 
   static void init();
 
-  #if ENABLED(MARLIN_DEV_MODE)
+  #if ENABLED(HAL_CAN_SET_PWM_FREQ) && SPINDLE_LASER_FREQUENCY
     static void refresh_frequency() { hal.set_pwm_frequency(pin_t(SPINDLE_LASER_PWM_PIN), frequency); }
   #endif
 
   // Modifying this function should update everywhere
   static bool enabled(const cutter_power_t opwr) { return opwr > 0; }
-  static bool enabled() { return enabled(power); }
+  static bool enabled() { return enable_state; }
 
   static void apply_power(const uint8_t inpow);
 
   FORCE_INLINE static void refresh() { apply_power(power); }
-  FORCE_INLINE static void set_power(const uint8_t upwr) { power = upwr; refresh(); }
 
   #if ENABLED(SPINDLE_LASER_USE_PWM)
 
@@ -123,7 +135,6 @@ public:
     public:
 
     static void set_ocr(const uint8_t ocr);
-    static void ocr_set_power(const uint8_t ocr) { power = ocr; set_ocr(ocr); }
     static void ocr_off();
 
     /**
@@ -141,78 +152,76 @@ public:
       );
     }
 
-    /**
-     * Correct power to configured range
-     */
-    static cutter_power_t power_to_range(const cutter_power_t pwr) {
-      return power_to_range(pwr, _CUTTER_POWER(CUTTER_POWER_UNIT));
-    }
-
-    static cutter_power_t power_to_range(const cutter_power_t pwr, const uint8_t pwrUnit) {
-      static constexpr float
-        min_pct = TERN(CUTTER_POWER_RELATIVE, 0, TERN(SPINDLE_FEATURE, round(100.0f * (SPEED_POWER_MIN) / (SPEED_POWER_MAX)), SPEED_POWER_MIN)),
-        max_pct = TERN(SPINDLE_FEATURE, 100, SPEED_POWER_MAX);
-      if (pwr <= 0) return 0;
-      cutter_power_t upwr;
-      switch (pwrUnit) {
-        case _CUTTER_POWER_PWM255:
-          upwr = cutter_power_t(
-              (pwr < pct_to_ocr(min_pct)) ? pct_to_ocr(min_pct) // Use minimum if set below
-            : (pwr > pct_to_ocr(max_pct)) ? pct_to_ocr(max_pct) // Use maximum if set above
-            :  pwr
-          );
-          break;
-        case _CUTTER_POWER_PERCENT:
-          upwr = cutter_power_t(
-              (pwr < min_pct) ? min_pct                         // Use minimum if set below
-            : (pwr > max_pct) ? max_pct                         // Use maximum if set above
-            :  pwr                                              // PCT
-          );
-          break;
-        case _CUTTER_POWER_RPM:
-          upwr = cutter_power_t(
-              (pwr < SPEED_POWER_MIN) ? SPEED_POWER_MIN         // Use minimum if set below
-            : (pwr > SPEED_POWER_MAX) ? SPEED_POWER_MAX         // Use maximum if set above
-            : pwr                                               // Calculate OCR value
-          );
-          break;
-        default: break;
-      }
-      return upwr;
-    }
-
   #endif // SPINDLE_LASER_USE_PWM
 
   /**
-   * Enable/Disable spindle/laser
-   * @param enable true = enable; false = disable
+   * Correct power to configured range
    */
-  static void set_enabled(const bool enable) {
-    uint8_t value = 0;
-    if (enable) {
-      #if ENABLED(SPINDLE_LASER_USE_PWM)
-        if (power)
-          value = power;
-        else if (unitPower)
-          value = upower_to_ocr(cpwr_to_upwr(SPEED_POWER_STARTUP));
-      #else
-        value = 255;
-      #endif
+  static cutter_power_t power_to_range(const cutter_power_t pwr, const uint8_t pwrUnit=_CUTTER_POWER(CUTTER_POWER_UNIT)) {
+    static constexpr float
+      min_pct = TERN(CUTTER_POWER_RELATIVE, 0, TERN(SPINDLE_FEATURE, round(100.0f * (SPEED_POWER_MIN) / (SPEED_POWER_MAX)), SPEED_POWER_MIN)),
+      max_pct = TERN(SPINDLE_FEATURE, 100, SPEED_POWER_MAX);
+    if (pwr <= 0) return 0;
+    cutter_power_t upwr;
+    switch (pwrUnit) {
+      case _CUTTER_POWER_PWM255: {  // PWM
+        const uint8_t pmin = pct_to_ocr(min_pct), pmax = pct_to_ocr(max_pct);
+        upwr = cutter_power_t(constrain(pwr, pmin, pmax));
+      } break;
+      case _CUTTER_POWER_PERCENT:   // Percent
+        upwr = cutter_power_t(constrain(pwr, min_pct, max_pct));
+        break;
+      case _CUTTER_POWER_RPM:       // Calculate OCR value
+        upwr = cutter_power_t(constrain(pwr, SPEED_POWER_MIN, SPEED_POWER_MAX));
+        break;
+      default: break;
     }
-    set_power(value);
+    return upwr;
   }
 
-  static void disable() { isReady = false; set_enabled(false); }
-
   /**
-   * Wait for spindle to spin up or spin down
+   * Enable Laser or Spindle output.
+   * It's important to prevent changing the power output value during inline cutter operation.
+   * Inline power is adjusted in the planner to support LASER_TRAP_POWER and CUTTER_MODE_DYNAMIC mode.
    *
-   * @param on true = state to on; false = state to off.
+   * This method accepts one of the following control states:
+   *
+   *  - For CUTTER_MODE_STANDARD the cutter power is either full on/off or ocr-based and it will apply
+   *    SPEED_POWER_STARTUP if no value is assigned.
+   *
+   *  - For CUTTER_MODE_CONTINUOUS inline and power remains where last set and the cutter output enable flag is set.
+   *
+   *  - CUTTER_MODE_DYNAMIC is also inline-based and it just sets the enable output flag.
+   *
+   *  - For CUTTER_MODE_ERROR set the output enable_state flag directly and set power to 0 for any mode.
+   *    This mode allows a global power shutdown action to occur.
    */
-  static void power_delay(const bool on) {
-    #if DISABLED(LASER_POWER_INLINE)
-      safe_delay(on ? SPINDLE_LASER_POWERUP_DELAY : SPINDLE_LASER_POWERDOWN_DELAY);
+  static void set_enabled(const bool enable) {
+    switch (cutter_mode) {
+      case CUTTER_MODE_STANDARD:
+        apply_power(enable ? TERN(SPINDLE_LASER_USE_PWM, (power ?: (unitPower ? upower_to_ocr(cpwr_to_upwr(SPEED_POWER_STARTUP)) : 0)), 255) : 0);
+        break;
+      case CUTTER_MODE_CONTINUOUS:
+        TERN_(LASER_FEATURE, set_inline_enabled(enable));
+        break;
+      case CUTTER_MODE_DYNAMIC:
+        TERN_(LASER_FEATURE, set_inline_enabled(enable));
+        break;
+      case CUTTER_MODE_ERROR: // Error mode, no enable and kill power.
+        enable_state = false;
+        apply_power(0);
+    }
+    #if SPINDLE_LASER_ENA_PIN
+      WRITE(SPINDLE_LASER_ENA_PIN, enable ? SPINDLE_LASER_ACTIVE_STATE : !SPINDLE_LASER_ACTIVE_STATE);
     #endif
+    enable_state = enable;
+  }
+
+  static void disable() { isReadyForUI = false; set_enabled(false); }
+
+  // Wait for spindle/laser to startup or shutdown
+  static void power_delay(const bool on) {
+    safe_delay(on ? SPINDLE_LASER_POWERUP_DELAY : SPINDLE_LASER_POWERDOWN_DELAY);
   }
 
   #if ENABLED(SPINDLE_CHANGE_DIR)
@@ -224,122 +233,97 @@ public:
   #endif
 
   #if ENABLED(AIR_EVACUATION)
-    static void air_evac_enable();         // Turn On Cutter Vacuum or Laser Blower motor
-    static void air_evac_disable();        // Turn Off Cutter Vacuum or Laser Blower motor
-    static void air_evac_toggle();         // Toggle Cutter Vacuum or Laser Blower motor
-    static bool air_evac_state() {  // Get current state
+    static void air_evac_enable();     // Turn On Cutter Vacuum or Laser Blower motor
+    static void air_evac_disable();    // Turn Off Cutter Vacuum or Laser Blower motor
+    static void air_evac_toggle();     // Toggle Cutter Vacuum or Laser Blower motor
+    static bool air_evac_state() {     // Get current state
       return (READ(AIR_EVACUATION_PIN) == AIR_EVACUATION_ACTIVE);
     }
   #endif
 
   #if ENABLED(AIR_ASSIST)
-    static void air_assist_enable();         // Turn on air assist
-    static void air_assist_disable();        // Turn off air assist
-    static void air_assist_toggle();         // Toggle air assist
-    static bool air_assist_state() {  // Get current state
+    static void air_assist_enable();   // Turn on air assist
+    static void air_assist_disable();  // Turn off air assist
+    static void air_assist_toggle();   // Toggle air assist
+    static bool air_assist_state() {   // Get current state
       return (READ(AIR_ASSIST_PIN) == AIR_ASSIST_ACTIVE);
     }
   #endif
 
   #if HAS_MARLINUI_MENU
-    static void enable_with_dir(const bool reverse) {
-      isReady = true;
-      const uint8_t ocr = TERN(SPINDLE_LASER_USE_PWM, upower_to_ocr(menuPower), 255);
-      if (menuPower)
-        power = ocr;
-      else
-        menuPower = cpwr_to_upwr(SPEED_POWER_STARTUP);
-      unitPower = menuPower;
-      set_reverse(reverse);
-      set_enabled(true);
-    }
-    FORCE_INLINE static void enable_forward() { enable_with_dir(false); }
-    FORCE_INLINE static void enable_reverse() { enable_with_dir(true); }
-    FORCE_INLINE static void enable_same_dir() { enable_with_dir(is_reverse()); }
+
+    #if ENABLED(SPINDLE_FEATURE)
+      static void enable_with_dir(const bool reverse) {
+        isReadyForUI = true;
+        const uint8_t ocr = TERN(SPINDLE_LASER_USE_PWM, upower_to_ocr(menuPower), 255);
+        if (menuPower)
+          power = ocr;
+        else
+          menuPower = cpwr_to_upwr(SPEED_POWER_STARTUP);
+        unitPower = menuPower;
+        set_reverse(reverse);
+        set_enabled(true);
+      }
+      FORCE_INLINE static void enable_forward() { enable_with_dir(false); }
+      FORCE_INLINE static void enable_reverse() { enable_with_dir(true); }
+      FORCE_INLINE static void enable_same_dir() { enable_with_dir(is_reverse()); }
+    #endif // SPINDLE_FEATURE
 
     #if ENABLED(SPINDLE_LASER_USE_PWM)
       static void update_from_mpower() {
-        if (isReady) power = upower_to_ocr(menuPower);
+        if (isReadyForUI) power = upower_to_ocr(menuPower);
         unitPower = menuPower;
       }
     #endif
 
     #if ENABLED(LASER_FEATURE)
+      // Toggle the laser on/off with menuPower. Apply SPEED_POWER_STARTUP if it was 0 on entry.
+      static void laser_menu_toggle(const bool state) {
+        set_enabled(state);
+        if (state) {
+          if (!menuPower) menuPower = cpwr_to_upwr(SPEED_POWER_STARTUP);
+          power = upower_to_ocr(menuPower);
+          apply_power(power);
+        }
+      }
+
       /**
        * Test fire the laser using the testPulse ms duration
        * Also fires with any PWM power that was previous set
        * If not set defaults to 80% power
        */
       static void test_fire_pulse() {
-        TERN_(HAS_BEEPER, buzzer.tone(30, 3000));
-        enable_forward();                  // Turn Laser on (Spindle speak but same funct)
+        BUZZ(30, 3000);
+        cutter_mode = CUTTER_MODE_STANDARD;// Menu needs standard mode.
+        laser_menu_toggle(true);           // Laser On
         delay(testPulse);                  // Delay for time set by user in pulse ms menu screen.
-        disable();                         // Turn laser off
+        laser_menu_toggle(false);          // Laser Off
       }
-    #endif
+    #endif // LASER_FEATURE
 
   #endif // HAS_MARLINUI_MENU
 
-  #if ENABLED(LASER_POWER_INLINE)
-    /**
-     * Inline power adds extra fields to the planner block
-     * to handle laser power and scale to movement speed.
-     */
+  #if ENABLED(LASER_FEATURE)
 
-    // Force disengage planner power control
-    static void inline_disable() {
-      isReady = false;
-      unitPower = 0;
-      planner.laser_inline.status.isPlanned = false;
-      planner.laser_inline.status.isEnabled = false;
-      planner.laser_inline.power = 0;
+    // Dynamic mode rate calculation
+    static uint8_t calc_dynamic_power() {
+      if (feedrate_mm_m > 65535) return 255;         // Too fast, go always on
+      uint16_t rate = uint16_t(feedrate_mm_m);       // 16 bits from the G-code parser float input
+      rate >>= 8;                                    // Take the G-code input e.g. F40000 and shift off the lower bits to get an OCR value from 1-255
+      return uint8_t(rate);
     }
 
     // Inline modes of all other functions; all enable planner inline power control
-    static void set_inline_enabled(const bool enable) {
-      if (enable)
-        inline_power(255);
-      else {
-        isReady = false;
-        unitPower = menuPower = 0;
-        planner.laser_inline.status.isPlanned = false;
-        TERN(SPINDLE_LASER_USE_PWM, inline_ocr_power, inline_power)(0);
-      }
-    }
+    static void set_inline_enabled(const bool enable) { planner.laser_inline.status.isEnabled = enable;}
 
     // Set the power for subsequent movement blocks
-    static void inline_power(const cutter_power_t upwr) {
-      unitPower = menuPower = upwr;
-      #if ENABLED(SPINDLE_LASER_USE_PWM)
-        #if ENABLED(SPEED_POWER_RELATIVE) && !CUTTER_UNIT_IS(RPM) // relative mode does not turn laser off at 0, except for RPM
-          planner.laser_inline.status.isEnabled = true;
-          planner.laser_inline.power = upower_to_ocr(upwr);
-          isReady = true;
-        #else
-          inline_ocr_power(upower_to_ocr(upwr));
-        #endif
-      #else
-        planner.laser_inline.status.isEnabled = enabled(upwr);
-        planner.laser_inline.power = upwr;
-        isReady = enabled(upwr);
-      #endif
+    static void inline_power(const cutter_power_t cpwr) {
+      TERN(SPINDLE_LASER_USE_PWM, power = planner.laser_inline.power = cpwr, planner.laser_inline.power = cpwr > 0 ? 255 : 0);
     }
 
-    static void inline_direction(const bool) { /* never */ }
+  #endif // LASER_FEATURE
 
-    #if ENABLED(SPINDLE_LASER_USE_PWM)
-      static void inline_ocr_power(const uint8_t ocrpwr) {
-        isReady = ocrpwr > 0;
-        planner.laser_inline.status.isEnabled = ocrpwr > 0;
-        planner.laser_inline.power = ocrpwr;
-      }
-    #endif
-  #endif // LASER_POWER_INLINE
-
-  static void kill() {
-    TERN_(LASER_POWER_INLINE, inline_disable());
-    disable();
-  }
+  static void kill() { disable(); }
 };
 
 extern SpindleLaser cutter;

Marlin/src/feature/spindle_laser_types.h

@@ -74,12 +74,10 @@ typedef IF<(SPEED_POWER_MAX > 255), uint16_t, uint8_t>::type cutter_cpower_t;
   #endif
 #endif
 
+typedef uint16_t cutter_frequency_t;
+
 #if ENABLED(LASER_FEATURE)
   typedef uint16_t cutter_test_pulse_t;
   #define CUTTER_MENU_PULSE_TYPE uint16_3
-#endif
-
-#if ENABLED(MARLIN_DEV_MODE)
-  typedef uint16_t cutter_frequency_t;
   #define CUTTER_MENU_FREQUENCY_TYPE uint16_5
 #endif

Marlin/src/feature/stepper_driver_safety.cpp

@@ -65,18 +65,15 @@ void stepper_driver_backward_check() {
   TEST_BACKWARD(I,   8);
   TEST_BACKWARD(J,   9);
   TEST_BACKWARD(K,  10);
-  TEST_BACKWARD(U,  11);
-  TEST_BACKWARD(V,  12);
-  TEST_BACKWARD(W,  13);
 
-  TEST_BACKWARD(E0, 14);
-  TEST_BACKWARD(E1, 15);
-  TEST_BACKWARD(E2, 16);
-  TEST_BACKWARD(E3, 17);
-  TEST_BACKWARD(E4, 18);
-  TEST_BACKWARD(E5, 19);
-  TEST_BACKWARD(E6, 20);
-  TEST_BACKWARD(E7, 21);
+  TEST_BACKWARD(E0, 11);
+  TEST_BACKWARD(E1, 12);
+  TEST_BACKWARD(E2, 13);
+  TEST_BACKWARD(E3, 14);
+  TEST_BACKWARD(E4, 15);
+  TEST_BACKWARD(E5, 16);
+  TEST_BACKWARD(E6, 17);
+  TEST_BACKWARD(E7, 18);
 
   if (!axis_plug_backward)
     WRITE(SAFE_POWER_PIN, HIGH);
@@ -106,18 +103,15 @@ void stepper_driver_backward_report() {
   REPORT_BACKWARD(I,   8);
   REPORT_BACKWARD(J,   9);
   REPORT_BACKWARD(K,  10);
-  REPORT_BACKWARD(U,  11);
-  REPORT_BACKWARD(V,  12);
-  REPORT_BACKWARD(W,  13);
 
-  REPORT_BACKWARD(E0, 14);
-  REPORT_BACKWARD(E1, 15);
-  REPORT_BACKWARD(E2, 16);
-  REPORT_BACKWARD(E3, 17);
-  REPORT_BACKWARD(E4, 18);
-  REPORT_BACKWARD(E5, 19);
-  REPORT_BACKWARD(E6, 20);
-  REPORT_BACKWARD(E7, 21);
+  REPORT_BACKWARD(E0, 11);
+  REPORT_BACKWARD(E1, 12);
+  REPORT_BACKWARD(E2, 13);
+  REPORT_BACKWARD(E3, 14);
+  REPORT_BACKWARD(E4, 15);
+  REPORT_BACKWARD(E5, 16);
+  REPORT_BACKWARD(E6, 17);
+  REPORT_BACKWARD(E7, 18);
 }
 
 #endif // HAS_DRIVER_SAFE_POWER_PROTECT

Marlin/src/feature/tmc_util.cpp

@@ -33,17 +33,12 @@
 #include "../gcode/gcode.h"
 
 #if ENABLED(TMC_DEBUG)
-  #include "../module/planner.h"
   #include "../libs/hex_print.h"
   #if ENABLED(MONITOR_DRIVER_STATUS)
     static uint16_t report_tmc_status_interval; // = 0
   #endif
 #endif
 
-#if HAS_MARLINUI_MENU
-  #include "../module/stepper.h"
-#endif
-
 /**
  * Check for over temperature or short to ground error flags.
  * Report and log warning of overtemperature condition.
@@ -429,18 +424,6 @@
         if (monitor_tmc_driver(stepperK, need_update_error_counters, need_debug_reporting))
           step_current_down(stepperK);
       #endif
-      #if AXIS_IS_TMC(U)
-        if (monitor_tmc_driver(stepperU, need_update_error_counters, need_debug_reporting))
-          step_current_down(stepperU);
-      #endif
-      #if AXIS_IS_TMC(V)
-        if (monitor_tmc_driver(stepperV, need_update_error_counters, need_debug_reporting))
-          step_current_down(stepperV);
-      #endif
-      #if AXIS_IS_TMC(W)
-        if (monitor_tmc_driver(stepperW, need_update_error_counters, need_debug_reporting))
-          step_current_down(stepperW);
-      #endif
 
       #if AXIS_IS_TMC(E0)
         (void)monitor_tmc_driver(stepperE0, need_update_error_counters, need_debug_reporting);
@@ -821,15 +804,6 @@
     #if AXIS_IS_TMC(K)
       if (k) tmc_status(stepperK, n);
     #endif
-    #if AXIS_IS_TMC(U)
-      if (u) tmc_status(stepperU, n);
-    #endif
-    #if AXIS_IS_TMC(V)
-      if (v) tmc_status(stepperV, n);
-    #endif
-    #if AXIS_IS_TMC(W)
-      if (w) tmc_status(stepperW, n);
-    #endif
 
     if (TERN0(HAS_EXTRUDERS, e)) {
       #if AXIS_IS_TMC(E0)
@@ -904,15 +878,6 @@
     #if AXIS_IS_TMC(K)
       if (k) tmc_parse_drv_status(stepperK, n);
     #endif
-    #if AXIS_IS_TMC(U)
-      if (u) tmc_parse_drv_status(stepperU, n);
-    #endif
-    #if AXIS_IS_TMC(V)
-      if (v) tmc_parse_drv_status(stepperV, n);
-    #endif
-    #if AXIS_IS_TMC(W)
-      if (w) tmc_parse_drv_status(stepperW, n);
-    #endif
 
     if (TERN0(HAS_EXTRUDERS, e)) {
       #if AXIS_IS_TMC(E0)
@@ -1118,15 +1083,6 @@
     #if AXIS_IS_TMC(K)
       if (k) tmc_get_registers(stepperK, n);
     #endif
-    #if AXIS_IS_TMC(U)
-      if (u) tmc_get_registers(stepperU, n);
-    #endif
-    #if AXIS_IS_TMC(V)
-      if (v) tmc_get_registers(stepperV, n);
-    #endif
-    #if AXIS_IS_TMC(W)
-      if (w) tmc_get_registers(stepperW, n);
-    #endif
 
     if (TERN0(HAS_EXTRUDERS, e)) {
       #if AXIS_IS_TMC(E0)
@@ -1283,15 +1239,6 @@ void test_tmc_connection(LOGICAL_AXIS_ARGS(const bool)) {
   #if AXIS_IS_TMC(K)
     if (k) axis_connection += test_connection(stepperK);
   #endif
-  #if AXIS_IS_TMC(U)
-    if (u) axis_connection += test_connection(stepperU);
-  #endif
-  #if AXIS_IS_TMC(V)
-    if (v) axis_connection += test_connection(stepperV);
-  #endif
-  #if AXIS_IS_TMC(W)
-    if (w) axis_connection += test_connection(stepperW);
-  #endif
 
   if (TERN0(HAS_EXTRUDERS, e)) {
     #if AXIS_IS_TMC(E0)
@@ -1361,15 +1308,6 @@ void test_tmc_connection(LOGICAL_AXIS_ARGS(const bool)) {
     #if AXIS_HAS_SPI(K)
       SET_CS_PIN(K);
     #endif
-    #if AXIS_HAS_SPI(U)
-      SET_CS_PIN(U);
-    #endif
-    #if AXIS_HAS_SPI(V)
-      SET_CS_PIN(V);
-    #endif
-    #if AXIS_HAS_SPI(W)
-      SET_CS_PIN(W);
-    #endif
     #if AXIS_HAS_SPI(E0)
       SET_CS_PIN(E0);
     #endif

Marlin/src/gcode/bedlevel/G26.cpp

@@ -107,7 +107,6 @@
 
 #include "../../MarlinCore.h"
 #include "../../module/planner.h"
-#include "../../module/stepper.h"
 #include "../../module/motion.h"
 #include "../../module/tool_change.h"
 #include "../../module/temperature.h"
@@ -306,7 +305,7 @@ typedef struct {
         LIMIT(e.x, X_MIN_POS + 1, X_MAX_POS - 1);
       #endif
 
-      if (position_is_reachable(s.x, s.y) && position_is_reachable(e.x, e.y))
+      if (position_is_reachable(s) && position_is_reachable(e))
         print_line_from_here_to_there(s, e);
     }
   }

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

@@ -32,7 +32,6 @@
 #include "../../../feature/bedlevel/bedlevel.h"
 #include "../../../module/motion.h"
 #include "../../../module/planner.h"
-#include "../../../module/stepper.h"
 #include "../../../module/probe.h"
 #include "../../queue.h"
 
@@ -453,42 +452,6 @@ G29_TYPE GcodeSuite::G29() {
       #endif
     }
 
-    // Position bed horizontally and Z probe vertically.
-    #if    defined(SAFE_BED_LEVELING_START_X) || defined(SAFE_BED_LEVELING_START_Y) || defined(SAFE_BED_LEVELING_START_Z) \
-        || defined(SAFE_BED_LEVELING_START_I) || defined(SAFE_BED_LEVELING_START_J) || defined(SAFE_BED_LEVELING_START_K) \
-        || defined(SAFE_BED_LEVELING_START_U) || defined(SAFE_BED_LEVELING_START_V) || defined(SAFE_BED_LEVELING_START_W)
-      xyze_pos_t safe_position = current_position;
-      #ifdef SAFE_BED_LEVELING_START_X
-        safe_position.x = SAFE_BED_LEVELING_START_X;
-      #endif
-      #ifdef SAFE_BED_LEVELING_START_Y
-        safe_position.y = SAFE_BED_LEVELING_START_Y;
-      #endif
-      #ifdef SAFE_BED_LEVELING_START_Z
-        safe_position.z = SAFE_BED_LEVELING_START_Z;
-      #endif
-      #ifdef SAFE_BED_LEVELING_START_I
-        safe_position.i = SAFE_BED_LEVELING_START_I;
-      #endif
-      #ifdef SAFE_BED_LEVELING_START_J
-        safe_position.j = SAFE_BED_LEVELING_START_J;
-      #endif
-      #ifdef SAFE_BED_LEVELING_START_K
-        safe_position.k = SAFE_BED_LEVELING_START_K;
-      #endif
-      #ifdef SAFE_BED_LEVELING_START_U
-        safe_position.u = SAFE_BED_LEVELING_START_U;
-      #endif
-      #ifdef SAFE_BED_LEVELING_START_V
-        safe_position.v = SAFE_BED_LEVELING_START_V;
-      #endif
-      #ifdef SAFE_BED_LEVELING_START_W
-        safe_position.w = SAFE_BED_LEVELING_START_W;
-      #endif
-
-      do_blocking_move_to(safe_position);
-    #endif
-
     // Disable auto bed leveling during G29.
     // Be formal so G29 can be done successively without G28.
     if (!no_action) set_bed_leveling_enabled(false);

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

@@ -36,7 +36,7 @@
 #include "../../../libs/buzzer.h"
 #include "../../../lcd/marlinui.h"
 #include "../../../module/motion.h"
-#include "../../../module/stepper.h"
+#include "../../../module/planner.h"
 
 #if ENABLED(EXTENSIBLE_UI)
   #include "../../../lcd/extui/ui_api.h"
@@ -106,43 +106,6 @@ void GcodeSuite::G29() {
         queue.inject(parser.seen_test('N') ? F("G28" TERN(CAN_SET_LEVELING_AFTER_G28, "L0", "") "\nG29S2") : F("G29S2"));
         TERN_(EXTENSIBLE_UI, ExtUI::onLevelingStart());
         TERN_(DWIN_LCD_PROUI, DWIN_LevelingStart());
-
-        // Position bed horizontally and Z probe vertically.
-        #if    defined(SAFE_BED_LEVELING_START_X) || defined(SAFE_BED_LEVELING_START_Y) || defined(SAFE_BED_LEVELING_START_Z) \
-            || defined(SAFE_BED_LEVELING_START_I) || defined(SAFE_BED_LEVELING_START_J) || defined(SAFE_BED_LEVELING_START_K) \
-            || defined(SAFE_BED_LEVELING_START_U) || defined(SAFE_BED_LEVELING_START_V) || defined(SAFE_BED_LEVELING_START_W)
-          xyze_pos_t safe_position = current_position;
-          #ifdef SAFE_BED_LEVELING_START_X
-            safe_position.x = SAFE_BED_LEVELING_START_X;
-          #endif
-          #ifdef SAFE_BED_LEVELING_START_Y
-            safe_position.y = SAFE_BED_LEVELING_START_Y;
-          #endif
-          #ifdef SAFE_BED_LEVELING_START_Z
-            safe_position.z = SAFE_BED_LEVELING_START_Z;
-          #endif
-          #ifdef SAFE_BED_LEVELING_START_I
-            safe_position.i = SAFE_BED_LEVELING_START_I;
-          #endif
-          #ifdef SAFE_BED_LEVELING_START_J
-            safe_position.j = SAFE_BED_LEVELING_START_J;
-          #endif
-          #ifdef SAFE_BED_LEVELING_START_K
-            safe_position.k = SAFE_BED_LEVELING_START_K;
-          #endif
-          #ifdef SAFE_BED_LEVELING_START_U
-            safe_position.u = SAFE_BED_LEVELING_START_U;
-          #endif
-          #ifdef SAFE_BED_LEVELING_START_V
-            safe_position.v = SAFE_BED_LEVELING_START_V;
-          #endif
-          #ifdef SAFE_BED_LEVELING_START_W
-            safe_position.w = SAFE_BED_LEVELING_START_W;
-          #endif
-
-          do_blocking_move_to(safe_position);
-        #endif
-
         return;
       }
       state = MeshNext;

Marlin/src/gcode/calibrate/G28.cpp

@@ -24,8 +24,9 @@
 
 #include "../gcode.h"
 
-#include "../../module/stepper.h"
 #include "../../module/endstops.h"
+#include "../../module/planner.h"
+#include "../../module/stepper.h" // for various
 
 #if HAS_MULTI_HOTEND
   #include "../../module/tool_change.h"
@@ -59,7 +60,7 @@
   #include "../../libs/L64XX/L64XX_Marlin.h"
 #endif
 
-#if ENABLED(LASER_MOVE_G28_OFF)
+#if ENABLED(LASER_FEATURE)
   #include "../../feature/spindle_laser.h"
 #endif
 
@@ -169,7 +170,7 @@
       motion_state.jerk_state = planner.max_jerk;
       planner.max_jerk.set(0, 0 OPTARG(DELTA, 0));
     #endif
-    planner.reset_acceleration_rates();
+    planner.refresh_acceleration_rates();
     return motion_state;
   }
 
@@ -178,7 +179,7 @@
     planner.settings.max_acceleration_mm_per_s2[Y_AXIS] = motion_state.acceleration.y;
     TERN_(DELTA, planner.settings.max_acceleration_mm_per_s2[Z_AXIS] = motion_state.acceleration.z);
     TERN_(HAS_CLASSIC_JERK, planner.max_jerk = motion_state.jerk_state);
-    planner.reset_acceleration_rates();
+    planner.refresh_acceleration_rates();
   }
 
 #endif // IMPROVE_HOMING_RELIABILITY
@@ -205,7 +206,12 @@ void GcodeSuite::G28() {
   DEBUG_SECTION(log_G28, "G28", DEBUGGING(LEVELING));
   if (DEBUGGING(LEVELING)) log_machine_info();
 
-  TERN_(LASER_MOVE_G28_OFF, cutter.set_inline_enabled(false));  // turn off laser
+  /*
+   * Set the laser power to false to stop the planner from processing the current power setting.
+   */
+  #if ENABLED(LASER_FEATURE)
+    planner.laser_inline.status.isPowered = false;
+  #endif
 
   #if ENABLED(DUAL_X_CARRIAGE)
     bool IDEX_saved_duplication_state = extruder_duplication_enabled;
@@ -258,7 +264,7 @@ void GcodeSuite::G28() {
   reset_stepper_timeout();
 
   #define HAS_CURRENT_HOME(N) (defined(N##_CURRENT_HOME) && N##_CURRENT_HOME != N##_CURRENT)
-  #if HAS_CURRENT_HOME(X) || HAS_CURRENT_HOME(X2) || HAS_CURRENT_HOME(Y) || HAS_CURRENT_HOME(Y2) || (ENABLED(DELTA) && HAS_CURRENT_HOME(Z)) || HAS_CURRENT_HOME(I) || HAS_CURRENT_HOME(J) || HAS_CURRENT_HOME(K) || HAS_CURRENT_HOME(U) || HAS_CURRENT_HOME(V) || HAS_CURRENT_HOME(W)
+  #if HAS_CURRENT_HOME(X) || HAS_CURRENT_HOME(X2) || HAS_CURRENT_HOME(Y) || HAS_CURRENT_HOME(Y2) || (ENABLED(DELTA) && HAS_CURRENT_HOME(Z)) || HAS_CURRENT_HOME(I) || HAS_CURRENT_HOME(J) || HAS_CURRENT_HOME(K)
     #define HAS_HOMING_CURRENT 1
   #endif
 
@@ -286,6 +292,21 @@ void GcodeSuite::G28() {
       stepperY2.rms_current(Y2_CURRENT_HOME);
       if (DEBUGGING(LEVELING)) debug_current(F(STR_Y2), tmc_save_current_Y2, Y2_CURRENT_HOME);
     #endif
+    #if HAS_CURRENT_HOME(I)
+      const int16_t tmc_save_current_I = stepperI.getMilliamps();
+      stepperI.rms_current(I_CURRENT_HOME);
+      if (DEBUGGING(LEVELING)) debug_current(F(STR_I), tmc_save_current_I, I_CURRENT_HOME);
+    #endif
+    #if HAS_CURRENT_HOME(J)
+      const int16_t tmc_save_current_J = stepperJ.getMilliamps();
+      stepperJ.rms_current(J_CURRENT_HOME);
+      if (DEBUGGING(LEVELING)) debug_current(F(STR_J), tmc_save_current_J, J_CURRENT_HOME);
+    #endif
+    #if HAS_CURRENT_HOME(K)
+      const int16_t tmc_save_current_K = stepperK.getMilliamps();
+      stepperK.rms_current(K_CURRENT_HOME);
+      if (DEBUGGING(LEVELING)) debug_current(F(STR_K), tmc_save_current_K, K_CURRENT_HOME);
+    #endif
     #if HAS_CURRENT_HOME(Z) && ENABLED(DELTA)
       const int16_t tmc_save_current_Z = stepperZ.getMilliamps();
       stepperZ.rms_current(Z_CURRENT_HOME);
@@ -306,21 +327,6 @@ void GcodeSuite::G28() {
       stepperK.rms_current(K_CURRENT_HOME);
       if (DEBUGGING(LEVELING)) debug_current(F(STR_K), tmc_save_current_K, K_CURRENT_HOME);
     #endif
-    #if HAS_CURRENT_HOME(U)
-      const int16_t tmc_save_current_U = stepperU.getMilliamps();
-      stepperU.rms_current(U_CURRENT_HOME);
-      if (DEBUGGING(LEVELING)) debug_current(F(STR_U), tmc_save_current_U, U_CURRENT_HOME);
-    #endif
-    #if HAS_CURRENT_HOME(V)
-      const int16_t tmc_save_current_V = stepperV.getMilliamps();
-      stepperV.rms_current(V_CURRENT_HOME);
-      if (DEBUGGING(LEVELING)) debug_current(F(STR_V), tmc_save_current_V, V_CURRENT_HOME);
-    #endif
-    #if HAS_CURRENT_HOME(W)
-      const int16_t tmc_save_current_W = stepperW.getMilliamps();
-      stepperW.rms_current(W_CURRENT_HOME);
-      if (DEBUGGING(LEVELING)) debug_current(F(STR_W), tmc_save_current_W, W_CURRENT_HOME);
-    #endif
     #if SENSORLESS_STALLGUARD_DELAY
       safe_delay(SENSORLESS_STALLGUARD_DELAY); // Short delay needed to settle
     #endif
@@ -369,26 +375,21 @@ void GcodeSuite::G28() {
     const bool homeZ = TERN0(HAS_Z_AXIS, parser.seen_test('Z')),
                NUM_AXIS_LIST(              // Other axes should be homed before Z safe-homing
                  needX = _UNSAFE(X), needY = _UNSAFE(Y), needZ = false, // UNUSED
-                 needI = _UNSAFE(I), needJ = _UNSAFE(J), needK = _UNSAFE(K),
-                 needU = _UNSAFE(U), needV = _UNSAFE(V), needW = _UNSAFE(W)
+                 needI = _UNSAFE(I), needJ = _UNSAFE(J), needK = _UNSAFE(K)
                ),
                NUM_AXIS_LIST(              // Home each axis if needed or flagged
                  homeX = needX || parser.seen_test('X'),
                  homeY = needY || parser.seen_test('Y'),
                  homeZZ = homeZ,
-                 homeI = needI || parser.seen_test(AXIS4_NAME), homeJ = needJ || parser.seen_test(AXIS5_NAME),
-                 homeK = needK || parser.seen_test(AXIS6_NAME), homeU = needU || parser.seen_test(AXIS7_NAME),
-                 homeV = needV || parser.seen_test(AXIS8_NAME), homeW = needW || parser.seen_test(AXIS9_NAME)
+                 homeI = needI || parser.seen_test(AXIS4_NAME), homeJ = needJ || parser.seen_test(AXIS5_NAME), homeK = needK || parser.seen_test(AXIS6_NAME)
                ),
                home_all = NUM_AXIS_GANG(   // Home-all if all or none are flagged
                     homeX == homeX, && homeY == homeX, && homeZ == homeX,
-                 && homeI == homeX, && homeJ == homeX, && homeK == homeX,
-                 && homeU == homeX, && homeV == homeX, && homeW == homeX
+                 && homeI == homeX, && homeJ == homeX, && homeK == homeX
                ),
                NUM_AXIS_LIST(
                  doX = home_all || homeX, doY = home_all || homeY, doZ = home_all || homeZ,
-                 doI = home_all || homeI, doJ = home_all || homeJ, doK = home_all || homeK,
-                 doU = home_all || homeU, doV = home_all || homeV, doW = home_all || homeW
+                 doI = home_all || homeI, doJ = home_all || homeJ, doK = home_all || homeK
                );
 
     #if HAS_Z_AXIS
@@ -402,7 +403,7 @@ void GcodeSuite::G28() {
     const bool seenR = parser.seenval('R');
     const float z_homing_height = seenR ? parser.value_linear_units() : Z_HOMING_HEIGHT;
 
-    if (z_homing_height && (seenR || NUM_AXIS_GANG(doX, || doY, || TERN0(Z_SAFE_HOMING, doZ), || doI, || doJ, || doK, || doU, || doV, || doW))) {
+    if (z_homing_height && (seenR || NUM_AXIS_GANG(doX, || doY, || TERN0(Z_SAFE_HOMING, doZ), || doI, || doJ, || doK))) {
       // Raise Z before homing any other axes and z is not already high enough (never lower z)
       if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("Raise Z (before homing) by ", z_homing_height);
       do_z_clearance(z_homing_height);
@@ -442,53 +443,35 @@ void GcodeSuite::G28() {
       #endif
     }
 
-    #if BOTH(FOAMCUTTER_XYUV, HAS_I_AXIS)
-      // Home I (after X)
-      if (doI) homeaxis(I_AXIS);
-    #endif
-
     // Home Y (after X)
     if (DISABLED(HOME_Y_BEFORE_X) && doY)
       homeaxis(Y_AXIS);
 
-    #if BOTH(FOAMCUTTER_XYUV, HAS_J_AXIS)
-      // Home J (after Y)
-      if (doJ) homeaxis(J_AXIS);
-    #endif
-
     TERN_(IMPROVE_HOMING_RELIABILITY, end_slow_homing(saved_motion_state));
 
-    #if ENABLED(FOAMCUTTER_XYUV)
-      // skip homing of unused Z axis for foamcutters
-      if (doZ) set_axis_is_at_home(Z_AXIS);
-    #else
-      // Home Z last if homing towards the bed
-      #if HAS_Z_AXIS && DISABLED(HOME_Z_FIRST)
-        if (doZ) {
-          #if EITHER(Z_MULTI_ENDSTOPS, Z_STEPPER_AUTO_ALIGN)
-            stepper.set_all_z_lock(false);
-            stepper.set_separate_multi_axis(false);
-          #endif
+    // Home Z last if homing towards the bed
+    #if HAS_Z_AXIS && DISABLED(HOME_Z_FIRST)
+      if (doZ) {
+        #if EITHER(Z_MULTI_ENDSTOPS, Z_STEPPER_AUTO_ALIGN)
+          stepper.set_all_z_lock(false);
+          stepper.set_separate_multi_axis(false);
+        #endif
 
-          #if ENABLED(Z_SAFE_HOMING)
-            if (TERN1(POWER_LOSS_RECOVERY, !parser.seen_test('H'))) home_z_safely(); else homeaxis(Z_AXIS);
-          #else
-            homeaxis(Z_AXIS);
-          #endif
-          probe.move_z_after_homing();
-        }
-      #endif
-
-      SECONDARY_AXIS_CODE(
-        if (doI) homeaxis(I_AXIS),
-        if (doJ) homeaxis(J_AXIS),
-        if (doK) homeaxis(K_AXIS),
-        if (doU) homeaxis(U_AXIS),
-        if (doV) homeaxis(V_AXIS),
-        if (doW) homeaxis(W_AXIS)
-      );
+        #if ENABLED(Z_SAFE_HOMING)
+          if (TERN1(POWER_LOSS_RECOVERY, !parser.seen_test('H'))) home_z_safely(); else homeaxis(Z_AXIS);
+        #else
+          homeaxis(Z_AXIS);
+        #endif
+        probe.move_z_after_homing();
+      }
     #endif
 
+    SECONDARY_AXIS_CODE(
+      if (doI) homeaxis(I_AXIS),
+      if (doJ) homeaxis(J_AXIS),
+      if (doK) homeaxis(K_AXIS)
+    );
+
     sync_plan_position();
 
   #endif
@@ -570,15 +553,6 @@ void GcodeSuite::G28() {
     #if HAS_CURRENT_HOME(K)
       stepperK.rms_current(tmc_save_current_K);
     #endif
-    #if HAS_CURRENT_HOME(U)
-      stepperU.rms_current(tmc_save_current_U);
-    #endif
-    #if HAS_CURRENT_HOME(V)
-      stepperV.rms_current(tmc_save_current_V);
-    #endif
-    #if HAS_CURRENT_HOME(W)
-      stepperW.rms_current(tmc_save_current_W);
-    #endif
     #if SENSORLESS_STALLGUARD_DELAY
       safe_delay(SENSORLESS_STALLGUARD_DELAY); // Short delay needed to settle
     #endif
@@ -602,7 +576,7 @@ void GcodeSuite::G28() {
     // If not, this will need a PROGMEM directive and an accessor.
     #define _EN_ITEM(N) , E_AXIS
     static constexpr AxisEnum L64XX_axis_xref[MAX_L64XX] = {
-      NUM_AXIS_LIST(X_AXIS, Y_AXIS, Z_AXIS, I_AXIS, J_AXIS, K_AXIS, U_AXIS, V_AXIS, W_AXIS),
+      NUM_AXIS_LIST(X_AXIS, Y_AXIS, Z_AXIS, I_AXIS, J_AXIS, K_AXIS),
       X_AXIS, Y_AXIS, Z_AXIS, Z_AXIS, Z_AXIS
       REPEAT(E_STEPPERS, _EN_ITEM)
     };

Marlin/src/gcode/calibrate/G33.cpp

@@ -27,7 +27,7 @@
 #include "../gcode.h"
 #include "../../module/delta.h"
 #include "../../module/motion.h"
-#include "../../module/stepper.h"
+#include "../../module/planner.h"
 #include "../../module/endstops.h"
 #include "../../lcd/marlinui.h"
 
@@ -437,7 +437,7 @@ void GcodeSuite::G33() {
   const bool stow_after_each = parser.seen_test('E');
 
   #if HAS_DELTA_SENSORLESS_PROBING
-    probe.test_sensitivity.set(!parser.seen_test('X'), !parser.seen_test('Y'), !parser.seen_test('Z'));
+    probe.test_sensitivity = { !parser.seen_test('X'), !parser.seen_test('Y'), !parser.seen_test('Z') };
     const bool do_save_offset_adj = parser.seen_test('S');
   #endif
 

Marlin/src/gcode/calibrate/G34.cpp

@@ -26,9 +26,12 @@
 
 #include "../gcode.h"
 #include "../../module/motion.h"
-#include "../../module/stepper.h"
 #include "../../module/endstops.h"
 
+#if ANY(HAS_MOTOR_CURRENT_SPI, HAS_MOTOR_CURRENT_PWM, HAS_TRINAMIC_CONFIG)
+  #include "../../module/stepper.h"
+#endif
+
 #if HAS_LEVELING
   #include "../../feature/bedlevel/bedlevel.h"
 #endif

Marlin/src/gcode/calibrate/G34_M422.cpp

@@ -224,13 +224,15 @@ void GcodeSuite::G34() {
           // Safe clearance even on an incline
           if ((iteration == 0 || i > 0) && z_probe > current_position.z) do_blocking_move_to_z(z_probe);
 
+          xy_pos_t &ppos = z_stepper_align.xy[iprobe];
+
           if (DEBUGGING(LEVELING))
-            DEBUG_ECHOLNPGM_P(PSTR("Probing X"), z_stepper_align.xy[iprobe].x, SP_Y_STR, z_stepper_align.xy[iprobe].y);
+            DEBUG_ECHOLNPGM_P(PSTR("Probing X"), ppos.x, SP_Y_STR, ppos.y);
 
           // Probe a Z height for each stepper.
           // Probing sanity check is disabled, as it would trigger even in normal cases because
           // current_position.z has been manually altered in the "dirty trick" above.
-          const float z_probed_height = probe.probe_at_point(z_stepper_align.xy[iprobe], raise_after, 0, true, false);
+          const float z_probed_height = probe.probe_at_point(DIFF_TERN(HAS_HOME_OFFSET, ppos, xy_pos_t(home_offset)), raise_after, 0, true, false);
           if (isnan(z_probed_height)) {
             SERIAL_ECHOLNPGM("Probing failed");
             LCD_MESSAGE(MSG_LCD_PROBING_FAILED);

Marlin/src/gcode/calibrate/G425.cpp

@@ -85,19 +85,10 @@
 #if ALL(HAS_K_AXIS, CALIBRATION_MEASURE_KMIN, CALIBRATION_MEASURE_KMAX)
   #define HAS_K_CENTER 1
 #endif
-#if ALL(HAS_U_AXIS, CALIBRATION_MEASURE_UMIN, CALIBRATION_MEASURE_UMAX)
-  #define HAS_U_CENTER 1
-#endif
-#if ALL(HAS_V_AXIS, CALIBRATION_MEASURE_VMIN, CALIBRATION_MEASURE_VMAX)
-  #define HAS_V_CENTER 1
-#endif
-#if ALL(HAS_W_AXIS, CALIBRATION_MEASURE_WMIN, CALIBRATION_MEASURE_WMAX)
-  #define HAS_W_CENTER 1
-#endif
 
 enum side_t : uint8_t {
   TOP, RIGHT, FRONT, LEFT, BACK, NUM_SIDES,
-  LIST_N(DOUBLE(SECONDARY_AXES), IMINIMUM, IMAXIMUM, JMINIMUM, JMAXIMUM, KMINIMUM, KMAXIMUM, UMINIMUM, UMAXIMUM, VMINIMUM, VMAXIMUM, WMINIMUM, WMAXIMUM)
+  LIST_N(DOUBLE(SECONDARY_AXES), IMINIMUM, IMAXIMUM, JMINIMUM, JMAXIMUM, KMINIMUM, KMAXIMUM)
 };
 
 static constexpr xyz_pos_t true_center CALIBRATION_OBJECT_CENTER;
@@ -291,15 +282,6 @@ inline void probe_side(measurements_t &m, const float uncertainty, const side_t
     #if HAS_K_AXIS && AXIS_CAN_CALIBRATE(K)
       _PCASE(K);
     #endif
-    #if HAS_U_AXIS && AXIS_CAN_CALIBRATE(U)
-      _PCASE(U);
-    #endif
-    #if HAS_V_AXIS && AXIS_CAN_CALIBRATE(V)
-      _PCASE(V);
-    #endif
-    #if HAS_W_AXIS && AXIS_CAN_CALIBRATE(W)
-      _PCASE(W);
-    #endif
     default: return;
   }
 
@@ -353,12 +335,6 @@ inline void probe_sides(measurements_t &m, const float uncertainty) {
   TERN_(CALIBRATION_MEASURE_JMAX,  probe_side(m, uncertainty, JMAXIMUM, probe_top_at_edge));
   TERN_(CALIBRATION_MEASURE_KMIN,  probe_side(m, uncertainty, KMINIMUM, probe_top_at_edge));
   TERN_(CALIBRATION_MEASURE_KMAX,  probe_side(m, uncertainty, KMAXIMUM, probe_top_at_edge));
-  TERN_(CALIBRATION_MEASURE_UMIN,  probe_side(m, uncertainty, UMINIMUM, probe_top_at_edge));
-  TERN_(CALIBRATION_MEASURE_UMAX,  probe_side(m, uncertainty, UMAXIMUM, probe_top_at_edge));
-  TERN_(CALIBRATION_MEASURE_VMIN,  probe_side(m, uncertainty, VMINIMUM, probe_top_at_edge));
-  TERN_(CALIBRATION_MEASURE_VMAX,  probe_side(m, uncertainty, VMAXIMUM, probe_top_at_edge));
-  TERN_(CALIBRATION_MEASURE_WMIN,  probe_side(m, uncertainty, WMINIMUM, probe_top_at_edge));
-  TERN_(CALIBRATION_MEASURE_WMAX,  probe_side(m, uncertainty, WMAXIMUM, probe_top_at_edge));
 
   // Compute the measured center of the calibration object.
   TERN_(HAS_X_CENTER, m.obj_center.x = (m.obj_side[LEFT]     + m.obj_side[RIGHT])    / 2);
@@ -366,9 +342,6 @@ inline void probe_sides(measurements_t &m, const float uncertainty) {
   TERN_(HAS_I_CENTER, m.obj_center.i = (m.obj_side[IMINIMUM] + m.obj_side[IMAXIMUM]) / 2);
   TERN_(HAS_J_CENTER, m.obj_center.j = (m.obj_side[JMINIMUM] + m.obj_side[JMAXIMUM]) / 2);
   TERN_(HAS_K_CENTER, m.obj_center.k = (m.obj_side[KMINIMUM] + m.obj_side[KMAXIMUM]) / 2);
-  TERN_(HAS_U_CENTER, m.obj_center.u = (m.obj_side[UMINIMUM] + m.obj_side[UMAXIMUM]) / 2);
-  TERN_(HAS_V_CENTER, m.obj_center.v = (m.obj_side[VMINIMUM] + m.obj_side[VMAXIMUM]) / 2);
-  TERN_(HAS_W_CENTER, m.obj_center.w = (m.obj_side[WMINIMUM] + m.obj_side[WMAXIMUM]) / 2);
 
   // Compute the outside diameter of the nozzle at the height
   // at which it makes contact with the calibration object
@@ -385,10 +358,7 @@ inline void probe_sides(measurements_t &m, const float uncertainty) {
     m.pos_error.z = true_center.z - m.obj_center.z,
     m.pos_error.i = TERN0(HAS_I_CENTER, true_center.i - m.obj_center.i),
     m.pos_error.j = TERN0(HAS_J_CENTER, true_center.j - m.obj_center.j),
-    m.pos_error.k = TERN0(HAS_K_CENTER, true_center.k - m.obj_center.k),
-    m.pos_error.u = TERN0(HAS_U_CENTER, true_center.u - m.obj_center.u),
-    m.pos_error.v = TERN0(HAS_V_CENTER, true_center.v - m.obj_center.v),
-    m.pos_error.w = TERN0(HAS_W_CENTER, true_center.w - m.obj_center.w)
+    m.pos_error.k = TERN0(HAS_K_CENTER, true_center.k - m.obj_center.k)
   );
 }
 
@@ -436,30 +406,6 @@ inline void probe_sides(measurements_t &m, const float uncertainty) {
         SERIAL_ECHOLNPGM("  " STR_K_MAX ": ", m.obj_side[KMAXIMUM]);
       #endif
     #endif
-    #if HAS_U_AXIS
-      #if ENABLED(CALIBRATION_MEASURE_UMIN)
-        SERIAL_ECHOLNPGM("  " STR_U_MIN ": ", m.obj_side[UMINIMUM]);
-      #endif
-      #if ENABLED(CALIBRATION_MEASURE_UMAX)
-        SERIAL_ECHOLNPGM("  " STR_U_MAX ": ", m.obj_side[UMAXIMUM]);
-      #endif
-    #endif
-    #if HAS_V_AXIS
-      #if ENABLED(CALIBRATION_MEASURE_VMIN)
-        SERIAL_ECHOLNPGM("  " STR_V_MIN ": ", m.obj_side[VMINIMUM]);
-      #endif
-      #if ENABLED(CALIBRATION_MEASURE_VMAX)
-        SERIAL_ECHOLNPGM("  " STR_V_MAX ": ", m.obj_side[VMAXIMUM]);
-      #endif
-    #endif
-    #if HAS_W_AXIS
-      #if ENABLED(CALIBRATION_MEASURE_WMIN)
-        SERIAL_ECHOLNPGM("  " STR_W_MIN ": ", m.obj_side[WMINIMUM]);
-      #endif
-      #if ENABLED(CALIBRATION_MEASURE_WMAX)
-        SERIAL_ECHOLNPGM("  " STR_W_MAX ": ", m.obj_side[WMAXIMUM]);
-      #endif
-    #endif
     SERIAL_EOL();
   }
 
@@ -481,15 +427,6 @@ inline void probe_sides(measurements_t &m, const float uncertainty) {
     #if HAS_K_CENTER
       SERIAL_ECHOLNPGM_P(SP_K_STR, m.obj_center.k);
     #endif
-    #if HAS_U_CENTER
-      SERIAL_ECHOLNPGM_P(SP_U_STR, m.obj_center.u);
-    #endif
-    #if HAS_V_CENTER
-      SERIAL_ECHOLNPGM_P(SP_V_STR, m.obj_center.v);
-    #endif
-    #if HAS_W_CENTER
-      SERIAL_ECHOLNPGM_P(SP_W_STR, m.obj_center.w);
-    #endif
     SERIAL_EOL();
   }
 
@@ -538,30 +475,6 @@ inline void probe_sides(measurements_t &m, const float uncertainty) {
         SERIAL_ECHOLNPGM("  " STR_K_MAX ": ", m.backlash[KMAXIMUM]);
       #endif
     #endif
-    #if HAS_U_AXIS && AXIS_CAN_CALIBRATE(U)
-      #if ENABLED(CALIBRATION_MEASURE_UMIN)
-        SERIAL_ECHOLNPGM("  " STR_U_MIN ": ", m.backlash[UMINIMUM]);
-      #endif
-      #if ENABLED(CALIBRATION_MEASURE_UMAX)
-        SERIAL_ECHOLNPGM("  " STR_U_MAX ": ", m.backlash[UMAXIMUM]);
-      #endif
-    #endif
-    #if HAS_V_AXIS && AXIS_CAN_CALIBRATE(V)
-      #if ENABLED(CALIBRATION_MEASURE_VMIN)
-        SERIAL_ECHOLNPGM("  " STR_V_MIN ": ", m.backlash[VMINIMUM]);
-      #endif
-      #if ENABLED(CALIBRATION_MEASURE_VMAX)
-        SERIAL_ECHOLNPGM("  " STR_V_MAX ": ", m.backlash[VMAXIMUM]);
-      #endif
-    #endif
-    #if HAS_W_AXIS && AXIS_CAN_CALIBRATE(W)
-      #if ENABLED(CALIBRATION_MEASURE_WMIN)
-        SERIAL_ECHOLNPGM("  " STR_W_MIN ": ", m.backlash[WMINIMUM]);
-      #endif
-      #if ENABLED(CALIBRATION_MEASURE_WMAX)
-        SERIAL_ECHOLNPGM("  " STR_W_MAX ": ", m.backlash[WMAXIMUM]);
-      #endif
-    #endif
     SERIAL_EOL();
   }
 
@@ -585,16 +498,7 @@ inline void probe_sides(measurements_t &m, const float uncertainty) {
       SERIAL_ECHOLNPGM_P(SP_J_STR, m.pos_error.j);
     #endif
     #if HAS_K_CENTER && AXIS_CAN_CALIBRATE(K)
-      SERIAL_ECHOLNPGM_P(SP_K_STR, m.pos_error.k);
-    #endif
-    #if HAS_U_CENTER && AXIS_CAN_CALIBRATE(U)
-      SERIAL_ECHOLNPGM_P(SP_U_STR, m.pos_error.u);
-    #endif
-    #if HAS_V_CENTER && AXIS_CAN_CALIBRATE(V)
-      SERIAL_ECHOLNPGM_P(SP_V_STR, m.pos_error.v);
-    #endif
-    #if HAS_W_CENTER && AXIS_CAN_CALIBRATE(W)
-      SERIAL_ECHOLNPGM_P(SP_W_STR, m.pos_error.w);
+      SERIAL_ECHOLNPGM_P(SP_Z_STR, m.pos_error.z);
     #endif
     SERIAL_EOL();
   }
@@ -683,30 +587,6 @@ inline void calibrate_backlash(measurements_t &m, const float uncertainty) {
         backlash.set_distance_mm(K_AXIS, m.backlash[KMAXIMUM]);
       #endif
 
-      #if HAS_U_CENTER
-        backlash.distance_mm.u = (m.backlash[UMINIMUM] + m.backlash[UMAXIMUM]) / 2;
-      #elif ENABLED(CALIBRATION_MEASURE_UMIN)
-        backlash.distance_mm.u = m.backlash[UMINIMUM];
-      #elif ENABLED(CALIBRATION_MEASURE_UMAX)
-        backlash.distance_mm.u = m.backlash[UMAXIMUM];
-      #endif
-
-      #if HAS_V_CENTER
-        backlash.distance_mm.v = (m.backlash[VMINIMUM] + m.backlash[VMAXIMUM]) / 2;
-      #elif ENABLED(CALIBRATION_MEASURE_VMIN)
-        backlash.distance_mm.v = m.backlash[VMINIMUM];
-      #elif ENABLED(CALIBRATION_MEASURE_UMAX)
-        backlash.distance_mm.v = m.backlash[VMAXIMUM];
-      #endif
-
-      #if HAS_W_CENTER
-        backlash.distance_mm.w = (m.backlash[WMINIMUM] + m.backlash[WMAXIMUM]) / 2;
-      #elif ENABLED(CALIBRATION_MEASURE_WMIN)
-        backlash.distance_mm.w = m.backlash[WMINIMUM];
-      #elif ENABLED(CALIBRATION_MEASURE_WMAX)
-        backlash.distance_mm.w = m.backlash[WMAXIMUM];
-      #endif
-
     #endif // BACKLASH_GCODE
   }
 
@@ -719,8 +599,7 @@ inline void calibrate_backlash(measurements_t &m, const float uncertainty) {
       TEMPORARY_BACKLASH_SMOOTHING(0.0f);
       const xyz_float_t move = NUM_AXIS_ARRAY(
         AXIS_CAN_CALIBRATE(X) * 3, AXIS_CAN_CALIBRATE(Y) * 3, AXIS_CAN_CALIBRATE(Z) * 3,
-        AXIS_CAN_CALIBRATE(I) * 3, AXIS_CAN_CALIBRATE(J) * 3, AXIS_CAN_CALIBRATE(K) * 3,
-        AXIS_CAN_CALIBRATE(U) * 3, AXIS_CAN_CALIBRATE(V) * 3, AXIS_CAN_CALIBRATE(W) * 3
+        AXIS_CAN_CALIBRATE(I) * 3, AXIS_CAN_CALIBRATE(J) * 3, AXIS_CAN_CALIBRATE(K) * 3
       );
       current_position += move; calibration_move();
       current_position -= move; calibration_move();
@@ -771,9 +650,6 @@ inline void calibrate_toolhead(measurements_t &m, const float uncertainty, const
   TERN_(HAS_I_CENTER, update_measurements(m, I_AXIS));
   TERN_(HAS_J_CENTER, update_measurements(m, J_AXIS));
   TERN_(HAS_K_CENTER, update_measurements(m, K_AXIS));
-  TERN_(HAS_U_CENTER, update_measurements(m, U_AXIS));
-  TERN_(HAS_V_CENTER, update_measurements(m, V_AXIS));
-  TERN_(HAS_W_CENTER, update_measurements(m, W_AXIS));
 
   sync_plan_position();
 }

Marlin/src/gcode/calibrate/M425.cpp

@@ -115,12 +115,9 @@ void GcodeSuite::M425_report(const bool forReplay/*=true*/) {
         SP_X_STR, LINEAR_UNIT(backlash.get_distance_mm(X_AXIS)),
         SP_Y_STR, LINEAR_UNIT(backlash.get_distance_mm(Y_AXIS)),
         SP_Z_STR, LINEAR_UNIT(backlash.get_distance_mm(Z_AXIS)),
-        SP_I_STR, I_AXIS_UNIT(backlash.get_distance_mm(I_AXIS)),
-        SP_J_STR, J_AXIS_UNIT(backlash.get_distance_mm(J_AXIS)),
-        SP_K_STR, K_AXIS_UNIT(backlash.get_distance_mm(K_AXIS)),
-        SP_U_STR, U_AXIS_UNIT(backlash.get_distance_mm(U_AXIS)),
-        SP_V_STR, V_AXIS_UNIT(backlash.get_distance_mm(V_AXIS)),
-        SP_W_STR, W_AXIS_UNIT(backlash.get_distance_mm(W_AXIS))
+        SP_I_STR, LINEAR_UNIT(backlash.get_distance_mm(I_AXIS)),
+        SP_J_STR, LINEAR_UNIT(backlash.get_distance_mm(J_AXIS)),
+        SP_K_STR, LINEAR_UNIT(backlash.get_distance_mm(K_AXIS))
       )
   );
 }

Marlin/src/gcode/calibrate/M665.cpp

@@ -86,13 +86,13 @@
    *
    * Parameters:
    *
-   *   S[segments-per-second] - Segments-per-second
+   *   S[segments]          - Segments-per-second
    *
    * Without NO_WORKSPACE_OFFSETS:
    *
-   *   P[theta-psi-offset]    - Theta-Psi offset, added to the shoulder (A/X) angle
-   *   T[theta-offset]        - Theta     offset, added to the elbow    (B/Y) angle
-   *   Z[z-offset]            - Z offset, added to Z
+   *   P[theta-psi-offset]  - Theta-Psi offset, added to the shoulder (A/X) angle
+   *   T[theta-offset]      - Theta     offset, added to the elbow    (B/Y) angle
+   *   Z[z-offset]          - Z offset, added to Z
    *
    *   A, P, and X are all aliases for the shoulder angle
    *   B, T, and Y are all aliases for the elbow angle
@@ -152,18 +152,35 @@
    *
    * Parameters:
    *
-   *   S[segments-per-second] - Segments-per-second
+   *   S[segments]  - Segments-per-second
+   *   L[left]      - Work area minimum X
+   *   R[right]     - Work area maximum X
+   *   T[top]       - Work area maximum Y
+   *   B[bottom]    - Work area minimum Y
+   *   H[length]    - Maximum belt length
    */
   void GcodeSuite::M665() {
-    if (parser.seenval('S'))
-      segments_per_second = parser.value_float();
-    else
-      M665_report();
+    if (!parser.seen_any()) return M665_report();
+    if (parser.seenval('S')) segments_per_second = parser.value_float();
+    if (parser.seenval('L')) draw_area_min.x = parser.value_linear_units();
+    if (parser.seenval('R')) draw_area_max.x = parser.value_linear_units();
+    if (parser.seenval('T')) draw_area_max.y = parser.value_linear_units();
+    if (parser.seenval('B')) draw_area_min.y = parser.value_linear_units();
+    if (parser.seenval('H')) polargraph_max_belt_len = parser.value_linear_units();
+    draw_area_size.x = draw_area_max.x - draw_area_min.x;
+    draw_area_size.y = draw_area_max.y - draw_area_min.y;
   }
 
   void GcodeSuite::M665_report(const bool forReplay/*=true*/) {
-    report_heading_etc(forReplay, F(STR_POLARGRAPH_SETTINGS " (" STR_S_SEG_PER_SEC ")"));
-    SERIAL_ECHOLNPGM("  M665 S", segments_per_second);
+    report_heading_etc(forReplay, F(STR_POLARGRAPH_SETTINGS));
+    SERIAL_ECHOLNPGM_P(
+      PSTR("  M665 S"), LINEAR_UNIT(segments_per_second),
+      PSTR(" L"), LINEAR_UNIT(draw_area_min.x),
+      PSTR(" R"), LINEAR_UNIT(draw_area_max.x),
+      SP_T_STR, LINEAR_UNIT(draw_area_max.y),
+      SP_B_STR, LINEAR_UNIT(draw_area_min.y),
+      PSTR(" H"), LINEAR_UNIT(polargraph_max_belt_len)
+    );
   }
 
 #endif

Marlin/src/gcode/config/M200-M205.cpp

@@ -148,12 +148,9 @@ void GcodeSuite::M201_report(const bool forReplay/*=true*/) {
       PSTR("  M201 X"), LINEAR_UNIT(planner.settings.max_acceleration_mm_per_s2[X_AXIS]),
       SP_Y_STR, LINEAR_UNIT(planner.settings.max_acceleration_mm_per_s2[Y_AXIS]),
       SP_Z_STR, LINEAR_UNIT(planner.settings.max_acceleration_mm_per_s2[Z_AXIS]),
-      SP_I_STR, I_AXIS_UNIT(planner.settings.max_acceleration_mm_per_s2[I_AXIS]),
-      SP_J_STR, J_AXIS_UNIT(planner.settings.max_acceleration_mm_per_s2[J_AXIS]),
-      SP_K_STR, K_AXIS_UNIT(planner.settings.max_acceleration_mm_per_s2[K_AXIS]),
-      SP_U_STR, U_AXIS_UNIT(planner.settings.max_acceleration_mm_per_s2[U_AXIS]),
-      SP_V_STR, V_AXIS_UNIT(planner.settings.max_acceleration_mm_per_s2[V_AXIS]),
-      SP_W_STR, W_AXIS_UNIT(planner.settings.max_acceleration_mm_per_s2[W_AXIS])
+      SP_I_STR, LINEAR_UNIT(planner.settings.max_acceleration_mm_per_s2[I_AXIS]),
+      SP_J_STR, LINEAR_UNIT(planner.settings.max_acceleration_mm_per_s2[J_AXIS]),
+      SP_K_STR, LINEAR_UNIT(planner.settings.max_acceleration_mm_per_s2[K_AXIS])
     )
     #if HAS_EXTRUDERS && DISABLED(DISTINCT_E_FACTORS)
       , SP_E_STR, VOLUMETRIC_UNIT(planner.settings.max_acceleration_mm_per_s2[E_AXIS])
@@ -198,10 +195,7 @@ void GcodeSuite::M203_report(const bool forReplay/*=true*/) {
       SP_Z_STR, LINEAR_UNIT(planner.settings.max_feedrate_mm_s[Z_AXIS]),
       SP_I_STR, LINEAR_UNIT(planner.settings.max_feedrate_mm_s[I_AXIS]),
       SP_J_STR, LINEAR_UNIT(planner.settings.max_feedrate_mm_s[J_AXIS]),
-      SP_K_STR, LINEAR_UNIT(planner.settings.max_feedrate_mm_s[K_AXIS]),
-      SP_U_STR, LINEAR_UNIT(planner.settings.max_feedrate_mm_s[U_AXIS]),
-      SP_V_STR, LINEAR_UNIT(planner.settings.max_feedrate_mm_s[V_AXIS]),
-      SP_W_STR, LINEAR_UNIT(planner.settings.max_feedrate_mm_s[W_AXIS])
+      SP_K_STR, LINEAR_UNIT(planner.settings.max_feedrate_mm_s[K_AXIS])
     )
     #if HAS_EXTRUDERS && DISABLED(DISTINCT_E_FACTORS)
       , SP_E_STR, VOLUMETRIC_UNIT(planner.settings.max_feedrate_mm_s[E_AXIS])
@@ -288,12 +282,9 @@ void GcodeSuite::M205() {
       if (parser.seenval('X')) planner.set_max_jerk(X_AXIS, parser.value_linear_units()),
       if (parser.seenval('Y')) planner.set_max_jerk(Y_AXIS, parser.value_linear_units()),
       if ((seenZ = parser.seenval('Z'))) planner.set_max_jerk(Z_AXIS, parser.value_linear_units()),
-      if (parser.seenval(AXIS4_NAME)) planner.set_max_jerk(I_AXIS, parser.TERN(AXIS4_ROTATES, value_float, value_linear_units)()),
-      if (parser.seenval(AXIS5_NAME)) planner.set_max_jerk(J_AXIS, parser.TERN(AXIS5_ROTATES, value_float, value_linear_units)()),
-      if (parser.seenval(AXIS6_NAME)) planner.set_max_jerk(K_AXIS, parser.TERN(AXIS6_ROTATES, value_float, value_linear_units)()),
-      if (parser.seenval(AXIS7_NAME)) planner.set_max_jerk(U_AXIS, parser.TERN(AXIS7_ROTATES, value_float, value_linear_units)()),
-      if (parser.seenval(AXIS8_NAME)) planner.set_max_jerk(V_AXIS, parser.TERN(AXIS8_ROTATES, value_float, value_linear_units)()),
-      if (parser.seenval(AXIS9_NAME)) planner.set_max_jerk(W_AXIS, parser.TERN(AXIS9_ROTATES, value_float, value_linear_units)())
+      if (parser.seenval(AXIS4_NAME)) planner.set_max_jerk(I_AXIS, parser.value_linear_units()),
+      if (parser.seenval(AXIS5_NAME)) planner.set_max_jerk(J_AXIS, parser.value_linear_units()),
+      if (parser.seenval(AXIS6_NAME)) planner.set_max_jerk(K_AXIS, parser.value_linear_units())
     );
     #if HAS_MESH && DISABLED(LIMITED_JERK_EDITING)
       if (seenZ && planner.max_jerk.z <= 0.1f)
@@ -309,8 +300,7 @@ void GcodeSuite::M205_report(const bool forReplay/*=true*/) {
     #if HAS_CLASSIC_JERK
       NUM_AXIS_GANG(
         " X<max_jerk>", " Y<max_jerk>", " Z<max_jerk>",
-        " " STR_I "<max_jerk>", " " STR_J "<max_jerk>", " " STR_K "<max_jerk>",
-        " " STR_U "<max_jerk>", " " STR_V "<max_jerk>", " " STR_W "<max_jerk>"
+        " " STR_I "<max_jerk>", " " STR_J "<max_jerk>", " " STR_K "<max_jerk>"
       )
     #endif
     TERN_(HAS_CLASSIC_E_JERK, " E<max_jerk>")
@@ -328,12 +318,9 @@ void GcodeSuite::M205_report(const bool forReplay/*=true*/) {
         SP_X_STR, LINEAR_UNIT(planner.max_jerk.x),
         SP_Y_STR, LINEAR_UNIT(planner.max_jerk.y),
         SP_Z_STR, LINEAR_UNIT(planner.max_jerk.z),
-        SP_I_STR, I_AXIS_UNIT(planner.max_jerk.i),
-        SP_J_STR, J_AXIS_UNIT(planner.max_jerk.j),
-        SP_K_STR, K_AXIS_UNIT(planner.max_jerk.k),
-        SP_U_STR, U_AXIS_UNIT(planner.max_jerk.u),
-        SP_V_STR, V_AXIS_UNIT(planner.max_jerk.v),
-        SP_W_STR, W_AXIS_UNIT(planner.max_jerk.w)
+        SP_I_STR, LINEAR_UNIT(planner.max_jerk.i),
+        SP_J_STR, LINEAR_UNIT(planner.max_jerk.j),
+        SP_K_STR, LINEAR_UNIT(planner.max_jerk.k)
       )
       #if HAS_CLASSIC_E_JERK
         , SP_E_STR, LINEAR_UNIT(planner.max_jerk.e)

Marlin/src/gcode/config/M217.cpp

@@ -53,9 +53,6 @@
  *  I[linear]     Park I (Requires TOOLCHANGE_PARK and NUM_AXES >= 4)
  *  J[linear]     Park J (Requires TOOLCHANGE_PARK and NUM_AXES >= 5)
  *  K[linear]     Park K (Requires TOOLCHANGE_PARK and NUM_AXES >= 6)
- *  C[linear]     Park U (Requires TOOLCHANGE_PARK and NUM_AXES >= 7)
- *  H[linear]     Park V (Requires TOOLCHANGE_PARK and NUM_AXES >= 8)
- *  O[linear]     Park W (Requires TOOLCHANGE_PARK and NUM_AXES >= 9)
  *  Z[linear]     Z Raise
  *  F[speed]      Fan Speed 0-255
  *  D[seconds]    Fan time
@@ -98,22 +95,13 @@ void GcodeSuite::M217() {
       if (parser.seenval('Y')) { const int16_t v = parser.value_linear_units(); toolchange_settings.change_point.y = constrain(v, Y_MIN_POS, Y_MAX_POS); }
     #endif
     #if HAS_I_AXIS
-      if (parser.seenval('I')) { const int16_t v = parser.TERN(AXIS4_ROTATES, value_int, value_linear_units)(); toolchange_settings.change_point.i = constrain(v, I_MIN_POS, I_MAX_POS); }
+      if (parser.seenval('I')) { const int16_t v = parser.value_linear_units(); toolchange_settings.change_point.i = constrain(v, I_MIN_POS, I_MAX_POS); }
     #endif
     #if HAS_J_AXIS
-      if (parser.seenval('J')) { const int16_t v = parser.TERN(AXIS5_ROTATES, value_int, value_linear_units)(); toolchange_settings.change_point.j = constrain(v, J_MIN_POS, J_MAX_POS); }
+      if (parser.seenval('J')) { const int16_t v = parser.value_linear_units(); toolchange_settings.change_point.j = constrain(v, J_MIN_POS, J_MAX_POS); }
     #endif
     #if HAS_K_AXIS
-      if (parser.seenval('K')) { const int16_t v = parser.TERN(AXIS6_ROTATES, value_int, value_linear_units)(); toolchange_settings.change_point.k = constrain(v, K_MIN_POS, K_MAX_POS); }
-    #endif
-    #if HAS_U_AXIS
-      if (parser.seenval('C')) { const int16_t v = parser.TERN(AXIS7_ROTATES, value_int, value_linear_units)(); toolchange_settings.change_point.u = constrain(v, U_MIN_POS, U_MAX_POS); }
-    #endif
-    #if HAS_V_AXIS
-      if (parser.seenval('H')) { const int16_t v = parser.TERN(AXIS8_ROTATES, value_int, value_linear_units)(); toolchange_settings.change_point.v = constrain(v, V_MIN_POS, V_MAX_POS); }
-    #endif
-    #if HAS_W_AXIS
-      if (parser.seenval('O')) { const int16_t v = parser.TERN(AXIS9_ROTATES, value_int, value_linear_units)(); toolchange_settings.change_point.w = constrain(v, W_MIN_POS, W_MAX_POS); }
+      if (parser.seenval('K')) { const int16_t v = parser.value_linear_units(); toolchange_settings.change_point.k = constrain(v, K_MIN_POS, K_MAX_POS); }
     #endif
   #endif
 
@@ -179,6 +167,7 @@ void GcodeSuite::M217_report(const bool forReplay/*=true*/) {
     #endif
 
     #if ENABLED(TOOLCHANGE_PARK)
+    {
       SERIAL_ECHOPGM(" W", LINEAR_UNIT(toolchange_settings.enable_park));
       SERIAL_ECHOPGM_P(
             SP_X_STR, LINEAR_UNIT(toolchange_settings.change_point.x)
@@ -186,16 +175,14 @@ void GcodeSuite::M217_report(const bool forReplay/*=true*/) {
           , SP_Y_STR, LINEAR_UNIT(toolchange_settings.change_point.y)
         #endif
         #if SECONDARY_AXES >= 1
-          , LIST_N(DOUBLE(SECONDARY_AXES)
-              , SP_I_STR,   I_AXIS_UNIT(toolchange_settings.change_point.i)
-              , SP_J_STR,   J_AXIS_UNIT(toolchange_settings.change_point.j)
-              , SP_K_STR,   K_AXIS_UNIT(toolchange_settings.change_point.k)
-              , SP_C_STR,   U_AXIS_UNIT(toolchange_settings.change_point.u)
-              , PSTR(" H"), V_AXIS_UNIT(toolchange_settings.change_point.v)
-              , PSTR(" O"), W_AXIS_UNIT(toolchange_settings.change_point.w)
+          , LIST_N(DOUBLE(SECONDARY_AXES),
+              SP_I_STR, I_AXIS_UNIT(toolchange_settings.change_point.i),
+              SP_J_STR, J_AXIS_UNIT(toolchange_settings.change_point.j),
+              SP_K_STR, K_AXIS_UNIT(toolchange_settings.change_point.k)
             )
         #endif
       );
+    }
     #endif
 
     #if ENABLED(TOOLCHANGE_FS_PRIME_FIRST_USED)

Marlin/src/gcode/config/M43.cpp

@@ -198,10 +198,10 @@ inline void servo_probe_test() {
       uint8_t i = 0;
       SERIAL_ECHOLNPGM(". Deploy & stow 4 times");
       do {
-        MOVE_SERVO(probe_index, servo_angles[Z_PROBE_SERVO_NR][0]); // Deploy
+        servo[probe_index].move(servo_angles[Z_PROBE_SERVO_NR][0]); // Deploy
         safe_delay(500);
         deploy_state = READ(PROBE_TEST_PIN);
-        MOVE_SERVO(probe_index, servo_angles[Z_PROBE_SERVO_NR][1]); // Stow
+        servo[probe_index].move(servo_angles[Z_PROBE_SERVO_NR][1]); // Stow
         safe_delay(500);
         stow_state = READ(PROBE_TEST_PIN);
       } while (++i < 4);
@@ -226,7 +226,7 @@ inline void servo_probe_test() {
     }
 
     // Ask the user for a trigger event and measure the pulse width.
-    MOVE_SERVO(probe_index, servo_angles[Z_PROBE_SERVO_NR][0]); // Deploy
+    servo[probe_index].move(servo_angles[Z_PROBE_SERVO_NR][0]); // Deploy
     safe_delay(500);
     SERIAL_ECHOLNPGM("** Please trigger probe within 30 sec **");
     uint16_t probe_counter = 0;
@@ -256,7 +256,7 @@ inline void servo_probe_test() {
         }
         else SERIAL_ECHOLNPGM("FAIL: Noise detected - please re-run test");
 
-        MOVE_SERVO(probe_index, servo_angles[Z_PROBE_SERVO_NR][1]); // Stow
+        servo[probe_index].move(servo_angles[Z_PROBE_SERVO_NR][1]); // Stow
         return;
       }
     }

Marlin/src/gcode/config/M540.cpp

@@ -25,7 +25,7 @@
 #if ENABLED(SD_ABORT_ON_ENDSTOP_HIT)
 
 #include "../gcode.h"
-#include "../../module/stepper.h"
+#include "../../module/planner.h"
 
 /**
  * M540: Set whether SD card print should abort on endstop hit (M540 S<0|1>)

Marlin/src/gcode/config/M92.cpp

@@ -24,7 +24,7 @@
 #include "../../module/planner.h"
 
 /**
- * M92: Set axis steps-per-unit for one or more axes, X, Y, Z, [I, [J, [K, [U, [V, [W,]]]]]] and E.
+ * M92: Set axis steps-per-unit for one or more axes, X, Y, Z, [I, [J, [K]]] and E.
  *      (Follows the same syntax as G92)
  *
  *      With multiple extruders use T to specify which one.
@@ -96,13 +96,10 @@ void GcodeSuite::M92_report(const bool forReplay/*=true*/, const int8_t e/*=-1*/
     PSTR("  M92 X"), LINEAR_UNIT(planner.settings.axis_steps_per_mm[X_AXIS]),
     SP_Y_STR, LINEAR_UNIT(planner.settings.axis_steps_per_mm[Y_AXIS]),
     SP_Z_STR, LINEAR_UNIT(planner.settings.axis_steps_per_mm[Z_AXIS]),
-    SP_I_STR, I_AXIS_UNIT(planner.settings.axis_steps_per_mm[I_AXIS]),
-    SP_J_STR, J_AXIS_UNIT(planner.settings.axis_steps_per_mm[J_AXIS]),
-    SP_K_STR, K_AXIS_UNIT(planner.settings.axis_steps_per_mm[K_AXIS]),
-    SP_U_STR, U_AXIS_UNIT(planner.settings.axis_steps_per_mm[U_AXIS]),
-    SP_V_STR, V_AXIS_UNIT(planner.settings.axis_steps_per_mm[V_AXIS]),
-    SP_W_STR, W_AXIS_UNIT(planner.settings.axis_steps_per_mm[W_AXIS])
-  ));
+    SP_I_STR, LINEAR_UNIT(planner.settings.axis_steps_per_mm[I_AXIS]),
+    SP_J_STR, LINEAR_UNIT(planner.settings.axis_steps_per_mm[J_AXIS]),
+    SP_K_STR, LINEAR_UNIT(planner.settings.axis_steps_per_mm[K_AXIS]))
+  );
   #if HAS_EXTRUDERS && DISABLED(DISTINCT_E_FACTORS)
     SERIAL_ECHOPGM_P(SP_E_STR, VOLUMETRIC_UNIT(planner.settings.axis_steps_per_mm[E_AXIS]));
   #endif

Marlin/src/gcode/control/M17_M18_M84.cpp

@@ -24,6 +24,7 @@
 #include "../../MarlinCore.h" // for stepper_inactive_time, disable_e_steppers
 #include "../../lcd/marlinui.h"
 #include "../../module/motion.h" // for e_axis_mask
+#include "../../module/planner.h"
 #include "../../module/stepper.h"
 
 #if ENABLED(AUTO_BED_LEVELING_UBL)
@@ -53,10 +54,7 @@ inline stepper_flags_t selected_axis_bits() {
     | (parser.seen_test('Z')        << Z_AXIS),
     | (parser.seen_test(AXIS4_NAME) << I_AXIS),
     | (parser.seen_test(AXIS5_NAME) << J_AXIS),
-    | (parser.seen_test(AXIS6_NAME) << K_AXIS),
-    | (parser.seen_test(AXIS7_NAME) << U_AXIS),
-    | (parser.seen_test(AXIS8_NAME) << V_AXIS),
-    | (parser.seen_test(AXIS9_NAME) << W_AXIS)
+    | (parser.seen_test(AXIS6_NAME) << K_AXIS)
   );
   return selected;
 }

Marlin/src/gcode/control/M226.cpp

@@ -26,7 +26,7 @@
 
 #include "../gcode.h"
 #include "../../MarlinCore.h" // for pin_is_protected and idle()
-#include "../../module/stepper.h"
+#include "../../module/planner.h"
 
 void protected_pin_err();
 

Marlin/src/gcode/control/M280.cpp

@@ -56,14 +56,14 @@ void GcodeSuite::M280() {
             while (PENDING(now, end)) {
               safe_delay(50);
               now = _MIN(millis(), end);
-              MOVE_SERVO(servo_index, LROUND(aold + (anew - aold) * (float(now - start) / t)));
+              servo[servo_index].move(LROUND(aold + (anew - aold) * (float(now - start) / t)));
             }
           }
         #endif // POLARGRAPH
-        MOVE_SERVO(servo_index, anew);
+        servo[servo_index].move(anew);
       }
       else
-        DETACH_SERVO(servo_index);
+        servo[servo_index].detach();
     }
     else
       SERIAL_ECHO_MSG(" Servo ", servo_index, ": ", servo[servo_index].read());

Marlin/src/gcode/control/M282.cpp

@@ -36,7 +36,7 @@ void GcodeSuite::M282() {
 
   const int servo_index = parser.value_int();
   if (WITHIN(servo_index, 0, NUM_SERVOS - 1))
-    DETACH_SERVO(servo_index);
+    servo[servo_index].detach();
   else
     SERIAL_ECHO_MSG("Servo ", servo_index, " out of range");
 

Marlin/src/gcode/control/M3-M5.cpp

@@ -26,22 +26,32 @@
 
 #include "../gcode.h"
 #include "../../feature/spindle_laser.h"
-#include "../../module/stepper.h"
+#include "../../module/planner.h"
 
 /**
  * Laser:
  *  M3 - Laser ON/Power (Ramped power)
- *  M4 - Laser ON/Power (Continuous power)
+ *  M4 - Laser ON/Power (Ramped power)
+ *  M5 - Set power output to 0 (leaving inline mode unchanged).
+ *
+ *  M3I - Enable continuous inline power to be processed by the planner, with power
+ *        calculated and set in the planner blocks, processed inline during stepping.
+ *        Within inline mode M3 S-Values will set the power for the next moves e.g. G1 X10 Y10 powers on with the last S-Value.
+ *        M3I must be set before using planner-synced M3 inline S-Values (LASER_POWER_SYNC).
+ *
+ *  M4I - Set dynamic mode which calculates laser power OCR based on the current feedrate.
+ *
+ *  M5I - Clear inline mode and set power to 0.
  *
  * Spindle:
  *  M3 - Spindle ON (Clockwise)
  *  M4 - Spindle ON (Counter-clockwise)
+ *  M5 - Spindle OFF
  *
  * Parameters:
- *  S<power> - Set power. S0 will turn the spindle/laser off, except in relative mode.
- *  O<ocr>   - Set power and OCR (oscillator count register)
+ *  S<power> - Set power. S0 will turn the spindle/laser off.
  *
- *  If no PWM pin is defined then M3/M4 just turns it on.
+ *  If no PWM pin is defined then M3/M4 just turns it on or off.
  *
  *  At least 12.8kHz (50Hz * 256) is needed for Spindle PWM.
  *  Hardware PWM is required on AVR. ISRs are too slow.
@@ -70,77 +80,77 @@ void GcodeSuite::M3_M4(const bool is_M4) {
     reset_stepper_timeout(); // Reset timeout to allow subsequent G-code to power the laser (imm.)
   #endif
 
-  #if EITHER(SPINDLE_LASER_USE_PWM, SPINDLE_SERVO)
-    auto get_s_power = [] {
-      if (parser.seenval('S')) {
-        const float spwr = parser.value_float();
-        #if ENABLED(SPINDLE_SERVO)
-          cutter.unitPower = spwr;
-        #else
-          cutter.unitPower = TERN(SPINDLE_LASER_USE_PWM,
-                                cutter.power_to_range(cutter_power_t(round(spwr))),
-                                spwr > 0 ? 255 : 0);
-        #endif
-      }
-      else
-        cutter.unitPower = cutter.cpwr_to_upwr(SPEED_POWER_STARTUP);
-      return cutter.unitPower;
-    };
+  if (cutter.cutter_mode == CUTTER_MODE_STANDARD)
+    planner.synchronize();   // Wait for previous movement commands (G0/G1/G2/G3) to complete before changing power
+
+  #if ENABLED(LASER_FEATURE)
+    if (parser.seen_test('I')) {
+      cutter.cutter_mode = is_M4 ? CUTTER_MODE_DYNAMIC : CUTTER_MODE_CONTINUOUS;
+      cutter.inline_power(0);
+      cutter.set_enabled(true);
+    }
   #endif
 
-  #if ENABLED(LASER_POWER_INLINE)
-    if (parser.seen('I') == DISABLED(LASER_POWER_INLINE_INVERT)) {
-      // Laser power in inline mode
-      cutter.inline_direction(is_M4); // Should always be unused
-      #if ENABLED(SPINDLE_LASER_USE_PWM)
-        if (parser.seenval('O')) {
-          cutter.unitPower = cutter.power_to_range(parser.value_byte(), 0);
-          cutter.inline_ocr_power(cutter.unitPower); // The OCR is a value from 0 to 255 (uint8_t)
-        }
-        else
-          cutter.inline_power(cutter.upower_to_ocr(get_s_power()));
+  auto get_s_power = [] {
+    float u;
+    if (parser.seenval('S')) {
+      const float v = parser.value_float();
+      u = TERN(LASER_POWER_TRAP, v, cutter.power_to_range(v));
+    }
+    else if (cutter.cutter_mode == CUTTER_MODE_STANDARD)
+      u = cutter.cpwr_to_upwr(SPEED_POWER_STARTUP);
+
+    cutter.menuPower = cutter.unitPower = u;
+
+    // PWM not implied, power converted to OCR from unit definition and on/off if not PWM.
+    cutter.power = TERN(SPINDLE_LASER_USE_PWM, cutter.upower_to_ocr(u), u > 0 ? 255 : 0);
+    return u;
+  };
+
+  if (cutter.cutter_mode == CUTTER_MODE_CONTINUOUS || cutter.cutter_mode == CUTTER_MODE_DYNAMIC) {  // Laser power in inline mode
+    #if ENABLED(LASER_FEATURE)
+      planner.laser_inline.status.isPowered = true;                                                 // M3 or M4 is powered either way
+      get_s_power();                                                                                // Update cutter.power if seen
+      #if ENABLED(LASER_POWER_SYNC)
+        // With power sync we only set power so it does not effect queued inline power sets
+        planner.buffer_sync_block(BLOCK_BIT_LASER_PWR);                                            // Send the flag, queueing inline power
       #else
-        cutter.set_inline_enabled(true);
+        planner.synchronize();
+        cutter.inline_power(cutter.power);
       #endif
-      return;
-    }
-    // Non-inline, standard case
-    cutter.inline_disable(); // Prevent future blocks re-setting the power
-  #endif
-
-  planner.synchronize();   // Wait for previous movement commands (G0/G0/G2/G3) to complete before changing power
-  cutter.set_reverse(is_M4);
-
-  #if ENABLED(SPINDLE_LASER_USE_PWM)
-    if (parser.seenval('O')) {
-      cutter.unitPower = cutter.power_to_range(parser.value_byte(), 0);
-      cutter.ocr_set_power(cutter.unitPower); // The OCR is a value from 0 to 255 (uint8_t)
-    }
-    else
-      cutter.set_power(cutter.upower_to_ocr(get_s_power()));
-  #elif ENABLED(SPINDLE_SERVO)
-    cutter.set_power(get_s_power());
-  #else
+    #endif
+  }
+  else {
     cutter.set_enabled(true);
-  #endif
-  cutter.menuPower = cutter.unitPower;
+    get_s_power();
+    cutter.apply_power(
+      #if ENABLED(SPINDLE_SERVO)
+        cutter.unitPower
+      #elif ENABLED(SPINDLE_LASER_USE_PWM)
+        cutter.upower_to_ocr(cutter.unitPower)
+      #else
+        cutter.unitPower > 0 ? 255 : 0
+      #endif
+    );
+    TERN_(SPINDLE_CHANGE_DIR, cutter.set_reverse(is_M4));
+  }
 }
 
 /**
  * M5 - Cutter OFF (when moves are complete)
  */
 void GcodeSuite::M5() {
-  #if ENABLED(LASER_POWER_INLINE)
-    if (parser.seen('I') == DISABLED(LASER_POWER_INLINE_INVERT)) {
-      cutter.set_inline_enabled(false); // Laser power in inline mode
-      return;
-    }
-    // Non-inline, standard case
-    cutter.inline_disable(); // Prevent future blocks re-setting the power
-  #endif
   planner.synchronize();
-  cutter.set_enabled(false);
-  cutter.menuPower = cutter.unitPower;
+  cutter.power = 0;
+  cutter.apply_power(0);                          // M5 just kills power, leaving inline mode unchanged
+  if (cutter.cutter_mode != CUTTER_MODE_STANDARD) {
+    if (parser.seen_test('I')) {
+      TERN_(LASER_FEATURE, cutter.inline_power(cutter.power));
+      cutter.set_enabled(false);                  // Needs to happen while we are in inline mode to clear inline power.
+      cutter.cutter_mode = CUTTER_MODE_STANDARD;  // Switch from inline to standard mode.
+    }
+  }
+  cutter.set_enabled(false);                      // Disable enable output setting
 }
 
 #endif // HAS_CUTTER

Marlin/src/gcode/control/M400.cpp

@@ -21,7 +21,7 @@
  */
 
 #include "../gcode.h"
-#include "../../module/stepper.h"
+#include "../../module/planner.h"
 
 /**
  * M400: Finish all moves

Marlin/src/gcode/control/M605.cpp

@@ -28,7 +28,6 @@
 
 #include "../gcode.h"
 #include "../../module/motion.h"
-#include "../../module/stepper.h"
 #include "../../module/tool_change.h"
 #include "../../module/planner.h"
 

Marlin/src/gcode/feature/L6470/M906.cpp

@@ -211,7 +211,7 @@ void L64XX_report_current(L64XX &motor, const L64XX_axis_t axis) {
  *     1 - monitor only X2, Y2, Z2
  *     2 - monitor only Z3
  *     3 - monitor only Z4
- * Xxxx, Yxxx, Zxxx, Axxx, Bxxx, Cxxx, Uxxx, Vxxx, Wxxx, Exxx - axis to change (optional)
+ * Xxxx, Yxxx, Zxxx, Axxx, Bxxx, Cxxx, Exxx - axis to change (optional)
  *     L6474 - current in mA (4A max)
  *     All others - 0-255
  *
@@ -285,25 +285,6 @@ void GcodeSuite::M906() {
           break;
       #endif
 
-      #if AXIS_IS_L64XX(I)
-        case I_AXIS: L6470_SET_KVAL_HOLD(I); break;
-      #endif
-      #if AXIS_IS_L64XX(J)
-        case J_AXIS: L6470_SET_KVAL_HOLD(J); break;
-      #endif
-      #if AXIS_IS_L64XX(K)
-        case K_AXIS: L6470_SET_KVAL_HOLD(K); break;
-      #endif
-      #if AXIS_IS_L64XX(U)
-        case U_AXIS: L6470_SET_KVAL_HOLD(U); break;
-      #endif
-      #if AXIS_IS_L64XX(V)
-        case V_AXIS: L6470_SET_KVAL_HOLD(V); break;
-      #endif
-      #if AXIS_IS_L64XX(W)
-        case W_AXIS: L6470_SET_KVAL_HOLD(W); break;
-      #endif
-
       #if AXIS_IS_L64XX(E0) || AXIS_IS_L64XX(E1) || AXIS_IS_L64XX(E2) || AXIS_IS_L64XX(E3) || AXIS_IS_L64XX(E4) || AXIS_IS_L64XX(E5) || AXIS_IS_L64XX(E6) || AXIS_IS_L64XX(E7)
         case E_AXIS: {
           const int8_t eindex = get_target_e_stepper_from_command(-2);
@@ -365,24 +346,6 @@ void GcodeSuite::M906() {
     #if AXIS_IS_L64XX(Z4)
       L64XX_REPORT_CURRENT(Z4);
     #endif
-    #if AXIS_IS_L64XX(I)
-      L64XX_REPORT_CURRENT(I);
-    #endif
-    #if AXIS_IS_L64XX(J)
-      L64XX_REPORT_CURRENT(J);
-    #endif
-    #if AXIS_IS_L64XX(K)
-      L64XX_REPORT_CURRENT(K);
-    #endif
-    #if AXIS_IS_L64XX(U)
-      L64XX_REPORT_CURRENT(U);
-    #endif
-    #if AXIS_IS_L64XX(V)
-      L64XX_REPORT_CURRENT(V);
-    #endif
-    #if AXIS_IS_L64XX(W)
-      L64XX_REPORT_CURRENT(W);
-    #endif
     #if AXIS_IS_L64XX(E0)
       L64XX_REPORT_CURRENT(E0);
     #endif

Marlin/src/gcode/feature/advance/M900.cpp

@@ -26,7 +26,6 @@
 
 #include "../../gcode.h"
 #include "../../../module/planner.h"
-#include "../../../module/stepper.h"
 
 #if ENABLED(EXTRA_LIN_ADVANCE_K)
   float other_extruder_advance_K[EXTRUDERS];

Marlin/src/gcode/feature/digipot/M907-M910.cpp

@@ -39,7 +39,7 @@
 #endif
 
 /**
- * M907: Set digital trimpot motor current using axis codes X [Y] [Z] [I] [J] [K] [U] [V] [W] [E]
+ * M907: Set digital trimpot motor current using axis codes X [Y] [Z] [I] [J] [K] [E]
  *   B<current> - Special case for E1 (Requires DIGIPOTSS_PIN or DIGIPOT_MCP4018 or DIGIPOT_MCP4451)
  *   C<current> - Special case for E2 (Requires DIGIPOTSS_PIN or DIGIPOT_MCP4018 or DIGIPOT_MCP4451)
  *   S<current> - Set current in mA for all axes (Requires DIGIPOTSS_PIN or DIGIPOT_MCP4018 or DIGIPOT_MCP4451), or
@@ -52,7 +52,7 @@ void GcodeSuite::M907() {
       return M907_report();
 
     if (parser.seenval('S')) LOOP_L_N(i, MOTOR_CURRENT_COUNT) stepper.set_digipot_current(i, parser.value_int());
-    LOOP_LOGICAL_AXES(i) if (parser.seenval(IAXIS_CHAR(i))) stepper.set_digipot_current(i, parser.value_int());    // X Y Z (I J K U V W) E (map to drivers according to DIGIPOT_CHANNELS. Default with NUM_AXES 3: map X Y Z E to X Y Z E0)
+    LOOP_LOGICAL_AXES(i) if (parser.seenval(IAXIS_CHAR(i))) stepper.set_digipot_current(i, parser.value_int());    // X Y Z (I J K) E (map to drivers according to DIGIPOT_CHANNELS. Default with NUM_AXES 3: map X Y Z E to X Y Z E0)
     // Additional extruders use B,C.
     // TODO: Change these parameters because 'E' is used and D should be reserved for debugging. B<index>?
     #if E_STEPPERS >= 2
@@ -64,15 +64,15 @@ void GcodeSuite::M907() {
 
   #elif HAS_MOTOR_CURRENT_PWM
 
-    #if ANY_PIN(MOTOR_CURRENT_PWM_X, MOTOR_CURRENT_PWM_Y, MOTOR_CURRENT_PWM_XY, MOTOR_CURRENT_PWM_I, MOTOR_CURRENT_PWM_J, MOTOR_CURRENT_PWM_K, MOTOR_CURRENT_PWM_U, MOTOR_CURRENT_PWM_V, MOTOR_CURRENT_PWM_W)
-      #define HAS_X_Y_XY_I_J_K_U_V_W 1
+    #if ANY_PIN(MOTOR_CURRENT_PWM_X, MOTOR_CURRENT_PWM_Y, MOTOR_CURRENT_PWM_XY, MOTOR_CURRENT_PWM_I, MOTOR_CURRENT_PWM_J, MOTOR_CURRENT_PWM_K)
+      #define HAS_X_Y_XY_I_J_K 1
     #endif
 
-    #if HAS_X_Y_XY_I_J_K_U_V_W || ANY_PIN(MOTOR_CURRENT_PWM_E, MOTOR_CURRENT_PWM_Z)
+    #if HAS_X_Y_XY_I_J_K || ANY_PIN(MOTOR_CURRENT_PWM_E, MOTOR_CURRENT_PWM_Z)
 
       if (!parser.seen("S"
-        #if HAS_X_Y_XY_I_J_K_U_V_W
-          "XY" SECONDARY_AXIS_GANG("I", "J", "K", "U", "V", "W")
+        #if HAS_X_Y_XY_I_J_K
+          "XY" SECONDARY_AXIS_GANG("I", "J", "K")
         #endif
         #if PIN_EXISTS(MOTOR_CURRENT_PWM_Z)
           "Z"
@@ -84,11 +84,10 @@ void GcodeSuite::M907() {
 
       if (parser.seenval('S')) LOOP_L_N(a, MOTOR_CURRENT_COUNT) stepper.set_digipot_current(a, parser.value_int());
 
-      #if HAS_X_Y_XY_I_J_K_U_V_W
+      #if HAS_X_Y_XY_I_J_K
         if (NUM_AXIS_GANG(
                parser.seenval('X'), || parser.seenval('Y'), || false,
-            || parser.seenval('I'), || parser.seenval('J'), || parser.seenval('K'),
-            || parser.seenval('U'), || parser.seenval('V'), || parser.seenval('W')
+            || parser.seenval('I'), || parser.seenval('J'), || parser.seenval('K')
         )) stepper.set_digipot_current(0, parser.value_int());
       #endif
       #if PIN_EXISTS(MOTOR_CURRENT_PWM_Z)
@@ -105,11 +104,11 @@ void GcodeSuite::M907() {
   #if HAS_MOTOR_CURRENT_I2C
     // this one uses actual amps in floating point
     if (parser.seenval('S')) LOOP_L_N(q, DIGIPOT_I2C_NUM_CHANNELS) digipot_i2c.set_current(q, parser.value_float());
-      LOOP_LOGICAL_AXES(i) if (parser.seenval(IAXIS_CHAR(i))) digipot_i2c.set_current(i, parser.value_float());      // X Y Z (I J K U V W) E (map to drivers according to pots adresses. Default with NUM_AXES 3 X Y Z E: map to X Y Z E0)
+      LOOP_LOGICAL_AXES(i) if (parser.seenval(IAXIS_CHAR(i))) digipot_i2c.set_current(i, parser.value_float());      // X Y Z (I J K) E (map to drivers according to pots adresses. Default with NUM_AXES 3 X Y Z E: map to X Y Z E0)
     // Additional extruders use B,C,D.
     // TODO: Change these parameters because 'E' is used and because 'D' should be reserved for debugging. B<index>?
     #if E_STEPPERS >= 2
-      for (uint8_t i = E_AXIS + 1; i < _MAX(DIGIPOT_I2C_NUM_CHANNELS, (NUM_AXES + 3)); i++)
+      for (uint8_t i = E_AXIS + 1; i <= _MIN(DIGIPOT_I2C_NUM_CHANNELS - 1, E_AXIS + 3); i++) // Up to B=E1 C=E2 D=E3
         if (parser.seenval('B' + i - (E_AXIS + 1))) digipot_i2c.set_current(i, parser.value_float());
     #endif
   #endif
@@ -119,7 +118,7 @@ void GcodeSuite::M907() {
       const float dac_percent = parser.value_float();
       LOOP_LOGICAL_AXES(i) stepper_dac.set_current_percent(i, dac_percent);
     }
-    LOOP_LOGICAL_AXES(i) if (parser.seenval(IAXIS_CHAR(i))) stepper_dac.set_current_percent(i, parser.value_float());   // X Y Z (I J K U V W) E (map to drivers according to DAC_STEPPER_ORDER. Default with NUM_AXES 3: X Y Z E map to X Y Z E0)
+    LOOP_LOGICAL_AXES(i) if (parser.seenval(IAXIS_CHAR(i))) stepper_dac.set_current_percent(i, parser.value_float());   // X Y Z (I J K) E (map to drivers according to DAC_STEPPER_ORDER. Default with NUM_AXES 3: X Y Z E map to X Y Z E0)
   #endif
 }
 
@@ -129,13 +128,13 @@ void GcodeSuite::M907() {
     report_heading_etc(forReplay, F(STR_STEPPER_MOTOR_CURRENTS));
     #if HAS_MOTOR_CURRENT_PWM
       SERIAL_ECHOLNPGM_P(                                     // PWM-based has 3 values:
-          PSTR("  M907 X"), stepper.motor_current_setting[0]  // X, Y, (I, J, K, U, V, W)
+          PSTR("  M907 X"), stepper.motor_current_setting[0]  // X, Y, (I, J, K)
         , SP_Z_STR,         stepper.motor_current_setting[1]  // Z
         , SP_E_STR,         stepper.motor_current_setting[2]  // E
       );
     #elif HAS_MOTOR_CURRENT_SPI
       SERIAL_ECHOPGM("  M907");                               // SPI-based has 5 values:
-      LOOP_LOGICAL_AXES(q) {                                  // X Y Z (I J K U V W) E (map to X Y Z (I J K U V W) E0 by default)
+      LOOP_LOGICAL_AXES(q) {                                  // X Y Z (I J K) E (map to X Y Z (I J K) E0 by default)
         SERIAL_CHAR(' ', IAXIS_CHAR(q));
         SERIAL_ECHO(stepper.motor_current_setting[q]);
       }

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

@@ -53,8 +53,7 @@ void GcodeSuite::G60() {
     DEBUG_ECHOLNPGM_P(
       LIST_N(DOUBLE(NUM_AXES),
         SP_X_LBL, pos.x, SP_Y_LBL, pos.y, SP_Z_LBL, pos.z,
-        SP_I_LBL, pos.i, SP_J_LBL, pos.j, SP_K_LBL, pos.k,
-        SP_U_LBL, pos.u, SP_V_LBL, pos.v, SP_W_LBL, pos.w
+        SP_I_LBL, pos.i, SP_J_LBL, pos.j, SP_K_LBL, pos.k
       )
       #if HAS_EXTRUDERS
         , SP_E_LBL, pos.e

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

@@ -52,9 +52,6 @@
  *    A<pos>    = Override park position A (requires AXIS*_NAME 'A')
  *    B<pos>    = Override park position B (requires AXIS*_NAME 'B')
  *    C<pos>    = Override park position C (requires AXIS*_NAME 'C')
- *    U<pos>    = Override park position U (requires AXIS*_NAME 'U')
- *    V<pos>    = Override park position V (requires AXIS*_NAME 'V')
- *    W<pos>    = Override park position W (requires AXIS*_NAME 'W')
  *    Z<linear> = Override Z raise
  *
  *  With an LCD menu:
@@ -71,12 +68,9 @@ void GcodeSuite::M125() {
     if (parser.seenval('X')) park_point.x = RAW_X_POSITION(parser.linearval('X')),
     if (parser.seenval('Y')) park_point.y = RAW_Y_POSITION(parser.linearval('Y')),
     NOOP,
-    if (parser.seenval(AXIS4_NAME)) park_point.i = RAW_X_POSITION(parser.linearval(AXIS4_NAME)),
-    if (parser.seenval(AXIS5_NAME)) park_point.j = RAW_X_POSITION(parser.linearval(AXIS5_NAME)),
-    if (parser.seenval(AXIS6_NAME)) park_point.k = RAW_X_POSITION(parser.linearval(AXIS6_NAME)),
-    if (parser.seenval(AXIS7_NAME)) park_point.u = RAW_X_POSITION(parser.linearval(AXIS7_NAME)),
-    if (parser.seenval(AXIS8_NAME)) park_point.v = RAW_X_POSITION(parser.linearval(AXIS8_NAME)),
-    if (parser.seenval(AXIS9_NAME)) park_point.w = RAW_X_POSITION(parser.linearval(AXIS9_NAME))
+    if (parser.seenval(AXIS4_NAME)) park_point.i = RAW_I_POSITION(parser.linearval(AXIS4_NAME)),
+    if (parser.seenval(AXIS5_NAME)) park_point.j = RAW_J_POSITION(parser.linearval(AXIS5_NAME)),
+    if (parser.seenval(AXIS6_NAME)) park_point.k = RAW_K_POSITION(parser.linearval(AXIS6_NAME))
   );
 
   // Lift Z axis

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

@@ -59,9 +59,6 @@
  *  I[position] - Move to this I position (instead of NOZZLE_PARK_POINT.i)
  *  J[position] - Move to this J position (instead of NOZZLE_PARK_POINT.j)
  *  K[position] - Move to this K position (instead of NOZZLE_PARK_POINT.k)
- *  C[position] - Move to this U position (instead of NOZZLE_PARK_POINT.u)
- *  H[position] - Move to this V position (instead of NOZZLE_PARK_POINT.v)
- *  O[position] - Move to this W position (instead of NOZZLE_PARK_POINT.w)
  *  U[distance] - Retract distance for removal (manual reload)
  *  L[distance] - Extrude distance for insertion (manual reload)
  *  B[count]    - Number of times to beep, -1 for indefinite (if equipped with a buzzer)
@@ -129,10 +126,7 @@ void GcodeSuite::M600() {
     if (parser.seenval('Z')) park_point.z = parser.linearval('Z'),    // Lift Z axis
     if (parser.seenval('I')) park_point.i = parser.linearval('I'),
     if (parser.seenval('J')) park_point.j = parser.linearval('J'),
-    if (parser.seenval('K')) park_point.k = parser.linearval('K'),
-    if (parser.seenval('C')) park_point.u = parser.linearval('C'),    // U axis
-    if (parser.seenval('H')) park_point.v = parser.linearval('H'),    // V axis
-    if (parser.seenval('O')) park_point.w = parser.linearval('O')     // W axis
+    if (parser.seenval('K')) park_point.k = parser.linearval('K')
   );
 
   #if HAS_HOTEND_OFFSET && NONE(DUAL_X_CARRIAGE, DELTA)

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

@@ -107,7 +107,7 @@ void GcodeSuite::M701() {
     constexpr float     purge_length = ADVANCED_PAUSE_PURGE_LENGTH,
                     slow_load_length = FILAMENT_CHANGE_SLOW_LOAD_LENGTH;
         const float fast_load_length = ABS(parser.seenval('L') ? parser.value_axis_units(E_AXIS)
-                                                            : fc_settings[active_extruder].load_length);
+                                                               : fc_settings[active_extruder].load_length);
     load_filament(
       slow_load_length, fast_load_length, purge_length,
       FILAMENT_CHANGE_ALERT_BEEPS,

Marlin/src/gcode/feature/trinamic/M122.cpp

@@ -26,7 +26,7 @@
 
 #include "../../gcode.h"
 #include "../../../feature/tmc_util.h"
-#include "../../../module/stepper/indirection.h"
+#include "../../../module/stepper/indirection.h" // for restore_stepper_drivers
 
 /**
  * M122: Debug TMC drivers