fix inits

Update controllerfan.cpp

Makefile

@@ -27,7 +27,7 @@ tests-single-ci:
 
 tests-single-local:
 	@if ! test -n "$(TEST_TARGET)" ; then echo "***ERROR*** Set TEST_TARGET=<your-module> or use make tests-all-local" ; return 1; fi
-	export PATH="./buildroot/bin/:./buildroot/tests/:${PATH}" \
+	export PATH=./buildroot/bin/:./buildroot/tests/:${PATH} \
 	  && export VERBOSE_PLATFORMIO=$(VERBOSE_PLATFORMIO) \
 	  && run_tests . $(TEST_TARGET) "$(ONLY_TEST)"
 .PHONY: tests-single-local
@@ -38,7 +38,7 @@ tests-single-local-docker:
 .PHONY: tests-single-local-docker
 
 tests-all-local:
-	export PATH="./buildroot/bin/:./buildroot/tests/:${PATH}" \
+	export PATH=./buildroot/bin/:./buildroot/tests/:${PATH} \
 	  && export VERBOSE_PLATFORMIO=$(VERBOSE_PLATFORMIO) \
 	  && for TEST_TARGET in $$(./get_test_targets.py) ; do echo "Running tests for $$TEST_TARGET" ; run_tests . $$TEST_TARGET ; done
 .PHONY: tests-all-local

Marlin/Configuration.h

@@ -3059,7 +3059,7 @@
 //#define MKS_ROBIN_TFT_V1_1R
 
 //
-// 480x320, 3.5", FSMC Stock Display from Tronxy
+// 480x320, 3.5", FSMC Stock Display from TronxXY
 //
 //#define TFT_TRONXY_X5SA
 

Marlin/Configuration_adv.h

@@ -552,10 +552,14 @@
   #endif
 #endif
 
-// When first starting the main fan, run it at full speed for the
+/**
-// given number of milliseconds.  This gets the fan spinning reliably
+ * Fan Kickstart
-// before setting a PWM value. (Does not work with software PWM for fan on Sanguinololu)
+ * When part cooling or controller fans first start, run at a speed that
-//#define FAN_KICKSTART_TIME 100
+ * gets it spinning reliably for a short time before setting the requested speed.
+ * (Does not work on Sanguinololu with FAN_SOFT_PWM.)
+ */
+//#define FAN_KICKSTART_TIME  100  // (ms)
+//#define FAN_KICKSTART_POWER 180  // 64-255
 
 // Some coolers may require a non-zero "off" state.
 //#define FAN_OFF_PWM  1

Marlin/Version.h

@@ -41,7 +41,7 @@
  * here we define this default string as the date where the latest release
  * version was tagged.
  */
-//#define STRING_DISTRIBUTION_DATE "2022-10-18"
+//#define STRING_DISTRIBUTION_DATE "2022-10-12"
 
 /**
  * Defines a generic printer name to be output to the LCD after booting Marlin.

Marlin/src/HAL/AVR/fastio.h

@@ -293,11 +293,11 @@ enum ClockSource2 : uint8_t {
 
 #if HAS_MOTOR_CURRENT_PWM
   #if PIN_EXISTS(MOTOR_CURRENT_PWM_XY)
-    #define PWM_CHK_MOTOR_CURRENT(P) (P == MOTOR_CURRENT_PWM_E || P == MOTOR_CURRENT_PWM_E0  || P == MOTOR_CURRENT_PWM_E1 || P == MOTOR_CURRENT_PWM_Z || P == MOTOR_CURRENT_PWM_XY)
+    #define PWM_CHK_MOTOR_CURRENT(P) (P == MOTOR_CURRENT_PWM_E || P == MOTOR_CURRENT_PWM_Z || P == MOTOR_CURRENT_PWM_XY)
   #elif PIN_EXISTS(MOTOR_CURRENT_PWM_Z)
-    #define PWM_CHK_MOTOR_CURRENT(P) (P == MOTOR_CURRENT_PWM_E || P == MOTOR_CURRENT_PWM_E0  || P == MOTOR_CURRENT_PWM_E1 || P == MOTOR_CURRENT_PWM_Z)
+    #define PWM_CHK_MOTOR_CURRENT(P) (P == MOTOR_CURRENT_PWM_E || P == MOTOR_CURRENT_PWM_Z)
   #else
-    #define PWM_CHK_MOTOR_CURRENT(P) (P == MOTOR_CURRENT_PWM_E || P == MOTOR_CURRENT_PWM_E0  || P == MOTOR_CURRENT_PWM_E1)
+    #define PWM_CHK_MOTOR_CURRENT(P) (P == MOTOR_CURRENT_PWM_E)
   #endif
 #else
   #define PWM_CHK_MOTOR_CURRENT(P) false

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

@@ -37,22 +37,22 @@
   || X_ENA_PIN  == N || Y_ENA_PIN  == N || Z_ENA_PIN  == N \
   || BTN_EN1    == N || BTN_EN2    == N \
 )
-#if SERIAL_IN_USE(0)
+#if CONF_SERIAL_IS(0)
   // D0-D1. No known conflicts.
 #endif
 #if NOT_TARGET(__AVR_ATmega644P__, __AVR_ATmega1284P__)
-  #if SERIAL_IN_USE(1) && (CHECK_SERIAL_PIN(18) || CHECK_SERIAL_PIN(19))
+  #if CONF_SERIAL_IS(1) && (CHECK_SERIAL_PIN(18) || CHECK_SERIAL_PIN(19))
     #error "Serial Port 1 pin D18 and/or D19 conflicts with another pin on the board."
   #endif
 #else
-  #if SERIAL_IN_USE(1) && (CHECK_SERIAL_PIN(10) || CHECK_SERIAL_PIN(11))
+  #if CONF_SERIAL_IS(1) && (CHECK_SERIAL_PIN(10) || CHECK_SERIAL_PIN(11))
     #error "Serial Port 1 pin D10 and/or D11 conflicts with another pin on the board."
   #endif
 #endif
-#if SERIAL_IN_USE(2) && (CHECK_SERIAL_PIN(16) || CHECK_SERIAL_PIN(17))
+#if CONF_SERIAL_IS(2) && (CHECK_SERIAL_PIN(16) || CHECK_SERIAL_PIN(17))
   #error "Serial Port 2 pin D16 and/or D17 conflicts with another pin on the board."
 #endif
-#if SERIAL_IN_USE(3) && (CHECK_SERIAL_PIN(14) || CHECK_SERIAL_PIN(15))
+#if CONF_SERIAL_IS(3) && (CHECK_SERIAL_PIN(14) || CHECK_SERIAL_PIN(15))
   #error "Serial Port 3 pin D14 and/or D15 conflicts with another pin on the board."
 #endif
 #undef CHECK_SERIAL_PIN

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

@@ -36,15 +36,15 @@
   || X_DIR_PIN  == N || Y_DIR_PIN  == N || Z_DIR_PIN  == N \
   || X_ENA_PIN  == N || Y_ENA_PIN  == N || Z_ENA_PIN  == N \
 )
-#if SERIAL_IN_USE(0) // D0-D1. No known conflicts.
+#if CONF_SERIAL_IS(0) // D0-D1. No known conflicts.
 #endif
-#if SERIAL_IN_USE(1) && (CHECK_SERIAL_PIN(18) || CHECK_SERIAL_PIN(19))
+#if CONF_SERIAL_IS(1) && (CHECK_SERIAL_PIN(18) || CHECK_SERIAL_PIN(19))
   #error "Serial Port 1 pin D18 and/or D19 conflicts with another pin on the board."
 #endif
-#if SERIAL_IN_USE(2) && (CHECK_SERIAL_PIN(16) || CHECK_SERIAL_PIN(17))
+#if CONF_SERIAL_IS(2) && (CHECK_SERIAL_PIN(16) || CHECK_SERIAL_PIN(17))
   #error "Serial Port 2 pin D16 and/or D17 conflicts with another pin on the board."
 #endif
-#if SERIAL_IN_USE(3) && (CHECK_SERIAL_PIN(14) || CHECK_SERIAL_PIN(15))
+#if CONF_SERIAL_IS(3) && (CHECK_SERIAL_PIN(14) || CHECK_SERIAL_PIN(15))
   #error "Serial Port 3 pin D14 and/or D15 conflicts with another pin on the board."
 #endif
 #undef CHECK_SERIAL_PIN

Marlin/src/HAL/DUE/upload_extra_script.py

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

Marlin/src/HAL/STM32/eeprom_flash.cpp

@@ -95,7 +95,7 @@
   static_assert(IS_FLASH_SECTOR(FLASH_SECTOR), "FLASH_SECTOR is invalid");
   static_assert(IS_POWER_OF_2(FLASH_UNIT_SIZE), "FLASH_UNIT_SIZE should be a power of 2, please check your chip's spec sheet");
 
-#endif // FLASH_EEPROM_LEVELING
+#endif
 
 static bool eeprom_data_written = false;
 
@@ -189,15 +189,15 @@ bool PersistentStore::access_finish() {
 
       UNLOCK_FLASH();
 
-      uint32_t offset = 0,
+      uint32_t offset = 0;
-               address = SLOT_ADDRESS(current_slot),
+      uint32_t address = SLOT_ADDRESS(current_slot);
-               address_end = address + MARLIN_EEPROM_SIZE,
+      uint32_t address_end = address + MARLIN_EEPROM_SIZE;
-               data = 0;
+      uint32_t data = 0;
 
       bool success = true;
 
       while (address < address_end) {
-        memcpy(&data, ram_eeprom + offset, sizeof(data));
+        memcpy(&data, ram_eeprom + offset, sizeof(uint32_t));
         status = HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, address, data);
         if (status == HAL_OK) {
           address += sizeof(uint32_t);
@@ -221,8 +221,7 @@ bool PersistentStore::access_finish() {
 
       return success;
 
-    #else !FLASH_EEPROM_LEVELING
+    #else
-
       // The following was written for the STM32F4 but may work with other MCUs as well.
       // Most STM32F4 flash does not allow reading from flash during erase operations.
       // This takes about a second on a STM32F407 with a 128kB sector used as EEPROM.
@@ -236,8 +235,7 @@ bool PersistentStore::access_finish() {
       TERN_(HAS_PAUSE_SERVO_OUTPUT, RESUME_SERVO_OUTPUT());
 
       eeprom_data_written = false;
-
+    #endif
-    #endif // !FLASH_EEPROM_LEVELING
   }
 
   return true;

Marlin/src/core/boards.h

@@ -426,7 +426,6 @@
 #define BOARD_OPULO_LUMEN_REV4        4241  // Opulo Lumen PnP Controller REV4 (STM32F407VE / STM32F407VG)
 #define BOARD_FYSETC_SPIDER_KING407   4242  // FYSETC Spider King407 (STM32F407ZG)
 #define BOARD_MKS_SKIPR_V1            4243  // MKS SKIPR v1.0 all-in-one board (STM32F407VE)
-#define BOARD_TRONXY_V10              4244  // TRONXY V10 (STM32F446ZE)
 
 //
 // ARM Cortex M7

Marlin/src/core/types.h

@@ -226,8 +226,8 @@ typedef const_float_t const_celsius_float_t;
 // Helpers
 #define _RECIP(N) ((N) ? 1.0f / static_cast<float>(N) : 0.0f)
 #define _ABS(N) ((N) < 0 ? -(N) : (N))
-#define _LS(N)  (N = (T)(uint32_t(N) << p))
+#define _LS(N)  (N = (T)(uint32_t(N) << v))
-#define _RS(N)  (N = (T)(uint32_t(N) >> p))
+#define _RS(N)  (N = (T)(uint32_t(N) >> v))
 #define FI FORCE_INLINE
 
 // Forward declarations
@@ -348,9 +348,9 @@ struct XYval {
   // If any element is true then it's true
   FI operator bool()                                    { return x || y; }
   // Smallest element
-  FI T small()                                    const { return _MIN(x, y); }
+  FI T _min()                                     const { return _MIN(x, y); }
   // Largest element
-  FI T large()                                    const { return _MAX(x, y); }
+  FI T _max()                                     const { return _MAX(x, y); }
 
   // Explicit copy and copies with conversion
   FI XYval<T>           copy()                    const { return *this; }
@@ -409,18 +409,18 @@ struct XYval {
   FI XYval<T>  operator* (const XYZEval<T> &rs)         { XYval<T> ls = *this; ls.x *= rs.x; ls.y *= rs.y; return ls; }
   FI XYval<T>  operator/ (const XYZEval<T> &rs)   const { XYval<T> ls = *this; ls.x /= rs.x; ls.y /= rs.y; return ls; }
   FI XYval<T>  operator/ (const XYZEval<T> &rs)         { XYval<T> ls = *this; ls.x /= rs.x; ls.y /= rs.y; return ls; }
-  FI XYval<T>  operator* (const float &p)         const { XYval<T> ls = *this; ls.x *= p;    ls.y *= p;    return ls; }
+  FI XYval<T>  operator* (const float &v)         const { XYval<T> ls = *this; ls.x *= v;    ls.y *= v;    return ls; }
-  FI XYval<T>  operator* (const float &p)               { XYval<T> ls = *this; ls.x *= p;    ls.y *= p;    return ls; }
+  FI XYval<T>  operator* (const float &v)               { XYval<T> ls = *this; ls.x *= v;    ls.y *= v;    return ls; }
-  FI XYval<T>  operator* (const int &p)           const { XYval<T> ls = *this; ls.x *= p;    ls.y *= p;    return ls; }
+  FI XYval<T>  operator* (const int &v)           const { XYval<T> ls = *this; ls.x *= v;    ls.y *= v;    return ls; }
-  FI XYval<T>  operator* (const int &p)                 { XYval<T> ls = *this; ls.x *= p;    ls.y *= p;    return ls; }
+  FI XYval<T>  operator* (const int &v)                 { XYval<T> ls = *this; ls.x *= v;    ls.y *= v;    return ls; }
-  FI XYval<T>  operator/ (const float &p)         const { XYval<T> ls = *this; ls.x /= p;    ls.y /= p;    return ls; }
+  FI XYval<T>  operator/ (const float &v)         const { XYval<T> ls = *this; ls.x /= v;    ls.y /= v;    return ls; }
-  FI XYval<T>  operator/ (const float &p)               { XYval<T> ls = *this; ls.x /= p;    ls.y /= p;    return ls; }
+  FI XYval<T>  operator/ (const float &v)               { XYval<T> ls = *this; ls.x /= v;    ls.y /= v;    return ls; }
-  FI XYval<T>  operator/ (const int &p)           const { XYval<T> ls = *this; ls.x /= p;    ls.y /= p;    return ls; }
+  FI XYval<T>  operator/ (const int &v)           const { XYval<T> ls = *this; ls.x /= v;    ls.y /= v;    return ls; }
-  FI XYval<T>  operator/ (const int &p)                 { XYval<T> ls = *this; ls.x /= p;    ls.y /= p;    return ls; }
+  FI XYval<T>  operator/ (const int &v)                 { XYval<T> ls = *this; ls.x /= v;    ls.y /= v;    return ls; }
-  FI XYval<T>  operator>>(const int &p)           const { XYval<T> ls = *this; _RS(ls.x);    _RS(ls.y);    return ls; }
+  FI XYval<T>  operator>>(const int &v)           const { XYval<T> ls = *this; _RS(ls.x);    _RS(ls.y);    return ls; }
-  FI XYval<T>  operator>>(const int &p)                 { XYval<T> ls = *this; _RS(ls.x);    _RS(ls.y);    return ls; }
+  FI XYval<T>  operator>>(const int &v)                 { XYval<T> ls = *this; _RS(ls.x);    _RS(ls.y);    return ls; }
-  FI XYval<T>  operator<<(const int &p)           const { XYval<T> ls = *this; _LS(ls.x);    _LS(ls.y);    return ls; }
+  FI XYval<T>  operator<<(const int &v)           const { XYval<T> ls = *this; _LS(ls.x);    _LS(ls.y);    return ls; }
-  FI XYval<T>  operator<<(const int &p)                 { XYval<T> ls = *this; _LS(ls.x);    _LS(ls.y);    return ls; }
+  FI XYval<T>  operator<<(const int &v)                 { XYval<T> ls = *this; _LS(ls.x);    _LS(ls.y);    return ls; }
   FI const XYval<T> operator-()                   const { XYval<T> o = *this; o.x = -x; o.y = -y; return o; }
   FI XYval<T>       operator-()                         { XYval<T> o = *this; o.x = -x; o.y = -y; return o; }
 
@@ -434,10 +434,10 @@ struct XYval {
   FI XYval<T>& operator+=(const XYZEval<T> &rs)         { x += rs.x; y += rs.y; return *this; }
   FI XYval<T>& operator-=(const XYZEval<T> &rs)         { x -= rs.x; y -= rs.y; return *this; }
   FI XYval<T>& operator*=(const XYZEval<T> &rs)         { x *= rs.x; y *= rs.y; return *this; }
-  FI XYval<T>& operator*=(const float &p)               { x *= p;    y *= p;    return *this; }
+  FI XYval<T>& operator*=(const float &v)               { x *= v;    y *= v;    return *this; }
-  FI XYval<T>& operator*=(const int &p)                 { x *= p;    y *= p;    return *this; }
+  FI XYval<T>& operator*=(const int &v)                 { x *= v;    y *= v;    return *this; }
-  FI XYval<T>& operator>>=(const int &p)                { _RS(x);    _RS(y);    return *this; }
+  FI XYval<T>& operator>>=(const int &v)                { _RS(x);    _RS(y);    return *this; }
-  FI XYval<T>& operator<<=(const int &p)                { _LS(x);    _LS(y);    return *this; }
+  FI XYval<T>& operator<<=(const int &v)                { _LS(x);    _LS(y);    return *this; }
 
   // Exact comparisons. For floats a "NEAR" operation may be better.
   FI bool      operator==(const XYval<T>   &rs)   const { return x == rs.x && y == rs.y; }
@@ -505,9 +505,9 @@ struct XYZval {
   // 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); }
   // Smallest element
-  FI T small()                                   const { return _MIN(NUM_AXIS_LIST(x, y, z, i, j, k, u, v, w)); }
+  FI T _min()                                    const { return _MIN(NUM_AXIS_LIST(x, y, z, i, j, k, u, v, w)); }
   // Largest element
-  FI T large()                                   const { return _MAX(NUM_AXIS_LIST(x, y, z, i, j, k, u, v, w)); }
+  FI T _max()                                    const { return _MAX(NUM_AXIS_LIST(x, y, z, i, j, k, u, v, w)); }
 
   // Explicit copy and copies with conversion
   FI XYZval<T>          copy()                   const { XYZval<T> o = *this; return o; }
@@ -567,18 +567,18 @@ struct XYZval {
   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 &p)       const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x *= p,    ls.y *= p,    ls.z *= p,    ls.i *= p,    ls.j *= p,    ls.k *= p,    ls.u *= p,    ls.v *= p,    ls.w *= p   ); 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 &p)             { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x *= p,    ls.y *= p,    ls.z *= p,    ls.i *= p,    ls.j *= p,    ls.k *= p,    ls.u *= p,    ls.v *= p,    ls.w *= p   ); 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 &p)         const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x *= p,    ls.y *= p,    ls.z *= p,    ls.i *= p,    ls.j *= p,    ls.k *= p,    ls.u *= p,    ls.v *= p,    ls.w *= p   ); 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 &p)               { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x *= p,    ls.y *= p,    ls.z *= p,    ls.i *= p,    ls.j *= p,    ls.k *= p,    ls.u *= p,    ls.v *= p,    ls.w *= p   ); 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 &p)       const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x /= p,    ls.y /= p,    ls.z /= p,    ls.i /= p,    ls.j /= p,    ls.k /= p,    ls.u /= p,    ls.v /= p,    ls.w /= p   ); 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 &p)             { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x /= p,    ls.y /= p,    ls.z /= p,    ls.i /= p,    ls.j /= p,    ls.k /= p,    ls.u /= p,    ls.v /= p,    ls.w /= p   ); 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 &p)         const { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x /= p,    ls.y /= p,    ls.z /= p,    ls.i /= p,    ls.j /= p,    ls.k /= p,    ls.u /= p,    ls.v /= p,    ls.w /= p   ); 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 &p)               { XYZval<T> ls = *this; NUM_AXIS_CODE(ls.x /= p,    ls.y /= p,    ls.z /= p,    ls.i /= p,    ls.j /= p,    ls.k /= p,    ls.u /= p,    ls.v /= p,    ls.w /= p   ); 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 &p)         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)         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 &p)               { 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 &p)         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)         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 &p)               { 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; }
 
@@ -595,10 +595,10 @@ struct XYZval {
   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 &p)             { NUM_AXIS_CODE(x *= p,    y *= p,    z *= p,    i *= p,    j *= p,    k *= p,    u *= p,    v *= p,    w *= p);    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 &p)               { NUM_AXIS_CODE(x *= p,    y *= p,    z *= p,    i *= p,    j *= p,    k *= p,    u *= p,    v *= p,    w *= p);    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 &p)              { 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(_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 &p)              { 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 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; }
 
   // Exact comparisons. For floats a "NEAR" operation may be better.
   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); }
@@ -654,15 +654,15 @@ struct XYZEval {
   #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, + u*u, + v*v, + w*w)); }
   // Pointer to the data as a simple array
-  FI operator T* ()                                     { return pos; }
+  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, || u, || v, || w); }
   // Smallest element
-  FI T small()                                    const { return _MIN(LOGICAL_AXIS_LIST(e, x, y, z, i, j, k, u, v, w)); }
+  FI T _min()                                      const { return _MIN(LOGICAL_AXIS_LIST(e, x, y, z, i, j, k, u, v, w)); }
   // Largest element
-  FI T large()                                    const { return _MAX(LOGICAL_AXIS_LIST(e, x, y, z, i, j, k, u, v, w)); }
+  FI T _max()                                      const { return _MAX(LOGICAL_AXIS_LIST(e, x, y, z, i, j, k, u, v, w)); }
 
   // Explicit copy and copies with conversion
   FI XYZEval<T>          copy()  const { XYZEval<T> v = *this; return v; }
@@ -688,76 +688,76 @@ struct XYZEval {
   FI operator const XYZval<T>&() const { return *(const XYZval<T>*)this; }
 
   // Accessor via an AxisEnum (or any integer) [index]
-  FI       T&    operator[](const int n)                { return pos[n]; }
+  FI       T&    operator[](const int n)                  { return pos[n]; }
-  FI const T&    operator[](const int n)          const { return pos[n]; }
+  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(LOGICAL_AXIS_LIST_1(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 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; }
+  FI XYZEval<T>& operator= (const XYZval<T>  &rs)         { set(NUM_AXIS_ELEM(rs)); return *this; }
 
   // Override other operators to get intuitive behaviors
-  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)   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 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)   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 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)   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 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)   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 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)   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)         { 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)   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)         { 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)   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)         { 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)   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)         { 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)  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)        { 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)  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)        { 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)  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)        { 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)  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)        { 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 &p)       const { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e *= p,    ls.x *= p,    ls.y *= p,    ls.z *= p,    ls.i *= p,    ls.j *= p,    ls.k *= p,    ls.u *= p,    ls.v *= p,    ls.w *= p   ); 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 &p)             { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e *= p,    ls.x *= p,    ls.y *= p,    ls.z *= p,    ls.i *= p,    ls.j *= p,    ls.k *= p,    ls.u *= p,    ls.v *= p,    ls.w *= p   ); 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 &p)         const { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e *= p,    ls.x *= p,    ls.y *= p,    ls.z *= p,    ls.i *= p,    ls.j *= p,    ls.k *= p,    ls.u *= p,    ls.v *= p,    ls.w *= p   ); 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 &p)               { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e *= p,    ls.x *= p,    ls.y *= p,    ls.z *= p,    ls.i *= p,    ls.j *= p,    ls.k *= p,    ls.u *= p,    ls.v *= p,    ls.w *= p   ); 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 &p)       const { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e /= p,    ls.x /= p,    ls.y /= p,    ls.z /= p,    ls.i /= p,    ls.j /= p,    ls.k /= p,    ls.u /= p,    ls.v /= p,    ls.w /= p   ); 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 &p)             { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e /= p,    ls.x /= p,    ls.y /= p,    ls.z /= p,    ls.i /= p,    ls.j /= p,    ls.k /= p,    ls.u /= p,    ls.v /= p,    ls.w /= p   ); 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 &p)         const { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e /= p,    ls.x /= p,    ls.y /= p,    ls.z /= p,    ls.i /= p,    ls.j /= p,    ls.k /= p,    ls.u /= p,    ls.v /= p,    ls.w /= p   ); 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 &p)               { XYZEval<T> ls = *this; LOGICAL_AXIS_CODE(ls.e /= p,    ls.x /= p,    ls.y /= p,    ls.z /= p,    ls.i /= p,    ls.j /= p,    ls.k /= p,    ls.u /= p,    ls.v /= p,    ls.w /= p   ); 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 &p)         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)           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 &p)               { 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 &p)         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)           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 &p)               { 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 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-()                         { return LOGICAL_AXIS_ARRAY(-e, -x, -y, -z, -i, -j, -k, -u, -v, -w); }
 
   // 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 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 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 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 &p)                 { LOGICAL_AXIS_CODE(e *= p,    x *= p,    y *= p,    z *= p,    i *= p,    j *= p,    k *= p,    u *= p,    v *= p,    w *= p);    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 &p)              { 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(_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 &p)              { 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 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; }
 
   // Exact comparisons. For floats a "NEAR" operation may be better.
-  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)   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) const { return true LOGICAL_AXIS_GANG(&& 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); }
+  FI bool        operator==(const XYZEval<T> &rs)   const { return true LOGICAL_AXIS_GANG(&& 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); }
-  FI bool        operator!=(const XYZval<T>  &rs) const { return !operator==(rs); }
+  FI bool        operator!=(const XYZval<T>  &rs)   const { return !operator==(rs); }
-  FI bool        operator!=(const XYZEval<T> &rs) const { return !operator==(rs); }
+  FI bool        operator!=(const XYZEval<T> &rs)   const { return !operator==(rs); }
 };
 
 #undef _RECIP

Marlin/src/feature/controllerfan.cpp

@@ -72,6 +72,22 @@ void ControllerFan::update() {
       ? settings.active_speed : settings.idle_speed
     );
 
+    speed = CALC_FAN_SPEED(speed);
+
+    #if FAN_KICKSTART_TIME
+      static millis_t fan_kick_end = 0;
+      if (speed > FAN_OFF_PWM) {
+        if (!fan_kick_end) {
+          fan_kick_end = ms + FAN_KICKSTART_TIME; // May be longer based on slow update interval for controller fn check. Sets minimum
+          speed = FAN_KICKSTART_POWER;
+        }
+        else if (PENDING(ms, fan_kick_end))
+          speed = FAN_KICKSTART_POWER;
+      }
+      else
+        fan_kick_end = 0;
+    #endif
+
     #if ENABLED(FAN_SOFT_PWM)
       thermalManager.soft_pwm_controller_speed = speed;
     #else

Marlin/src/feature/host_actions.cpp

@@ -111,29 +111,20 @@ void HostUI::action(FSTR_P const fstr, const bool eol) {
     if (eol) SERIAL_EOL();
   }
 
-  void HostUI::prompt_plus(const bool pgm, FSTR_P const ptype, const char * const str, const char extra_char/*='\0'*/) {
+  void HostUI::prompt_plus(FSTR_P const ptype, FSTR_P const fstr, const char extra_char/*='\0'*/) {
     prompt(ptype, false);
     PORT_REDIRECT(SerialMask::All);
     SERIAL_CHAR(' ');
-    if (pgm)
+    SERIAL_ECHOF(fstr);
-      SERIAL_ECHOPGM_P(str);
-    else
-      SERIAL_ECHO(str);
     if (extra_char != '\0') SERIAL_CHAR(extra_char);
     SERIAL_EOL();
   }
-
   void HostUI::prompt_begin(const PromptReason reason, FSTR_P const fstr, const char extra_char/*='\0'*/) {
     prompt_end();
     host_prompt_reason = reason;
     prompt_plus(F("begin"), fstr, extra_char);
   }
-  void HostUI::prompt_begin(const PromptReason reason, const char * const cstr, const char extra_char/*='\0'*/) {
+  void HostUI::prompt_button(FSTR_P const fstr) { prompt_plus(F("button"), fstr); }
-    prompt_end();
-    host_prompt_reason = reason;
-    prompt_plus(F("begin"), cstr, extra_char);
-  }
-
   void HostUI::prompt_end() { prompt(F("end")); }
   void HostUI::prompt_show() { prompt(F("show")); }
 
@@ -142,26 +133,14 @@ void HostUI::action(FSTR_P const fstr, const bool eol) {
     if (btn2) prompt_button(btn2);
     prompt_show();
   }
-
-  void HostUI::prompt_button(FSTR_P const fstr) { prompt_plus(F("button"), fstr); }
-  void HostUI::prompt_button(const char * const cstr) { prompt_plus(F("button"), cstr); }
-
   void HostUI::prompt_do(const PromptReason reason, FSTR_P const fstr, FSTR_P const btn1/*=nullptr*/, FSTR_P const btn2/*=nullptr*/) {
     prompt_begin(reason, fstr);
     _prompt_show(btn1, btn2);
   }
-  void HostUI::prompt_do(const PromptReason reason, const char * const cstr, FSTR_P const btn1/*=nullptr*/, FSTR_P const btn2/*=nullptr*/) {
-    prompt_begin(reason, cstr);
-    _prompt_show(btn1, btn2);
-  }
   void HostUI::prompt_do(const PromptReason reason, FSTR_P const fstr, const char extra_char, FSTR_P const btn1/*=nullptr*/, FSTR_P const btn2/*=nullptr*/) {
     prompt_begin(reason, fstr, extra_char);
     _prompt_show(btn1, btn2);
   }
-  void HostUI::prompt_do(const PromptReason reason, const char * const cstr, const char extra_char, FSTR_P const btn1/*=nullptr*/, FSTR_P const btn2/*=nullptr*/) {
-    prompt_begin(reason, cstr, extra_char);
-    _prompt_show(btn1, btn2);
-  }
 
   #if ENABLED(ADVANCED_PAUSE_FEATURE)
     void HostUI::filament_load_prompt() {

Marlin/src/feature/host_actions.h

@@ -79,14 +79,7 @@ class HostUI {
   #if ENABLED(HOST_PROMPT_SUPPORT)
     private:
     static void prompt(FSTR_P const ptype, const bool eol=true);
-    static void prompt_plus(const bool pgm, FSTR_P const ptype, const char * const str, const char extra_char='\0');
+    static void prompt_plus(FSTR_P const ptype, FSTR_P const fstr, const char extra_char='\0');
-    static void prompt_plus(FSTR_P const ptype, FSTR_P const fstr, const char extra_char='\0') {
-      prompt_plus(true, ptype, FTOP(fstr), extra_char);
-    }
-    static void prompt_plus(FSTR_P const ptype, const char * const cstr, const char extra_char='\0') {
-      prompt_plus(false, ptype, cstr, extra_char);
-    }
-
     static void prompt_show();
     static void _prompt_show(FSTR_P const btn1, FSTR_P const btn2);
 
@@ -100,17 +93,10 @@ class HostUI {
     static void notify(const char * const message);
 
     static void prompt_begin(const PromptReason reason, FSTR_P const fstr, const char extra_char='\0');
-    static void prompt_begin(const PromptReason reason, const char * const cstr, const char extra_char='\0');
-    static void prompt_end();
-
     static void prompt_button(FSTR_P const fstr);
-    static void prompt_button(const char * const cstr);
+    static void prompt_end();
-
     static void prompt_do(const PromptReason reason, FSTR_P const pstr, FSTR_P const btn1=nullptr, FSTR_P const btn2=nullptr);
-    static void prompt_do(const PromptReason reason, const char * const cstr, FSTR_P const btn1=nullptr, FSTR_P const btn2=nullptr);
     static void prompt_do(const PromptReason reason, FSTR_P const pstr, const char extra_char, FSTR_P const btn1=nullptr, FSTR_P const btn2=nullptr);
-    static void prompt_do(const PromptReason reason, const char * const cstr, const char extra_char, FSTR_P const btn1=nullptr, FSTR_P const btn2=nullptr);
-
     static void prompt_open(const PromptReason reason, FSTR_P const pstr, FSTR_P const btn1=nullptr, FSTR_P const btn2=nullptr) {
       if (host_prompt_reason == PROMPT_NOT_DEFINED) prompt_do(reason, pstr, btn1, btn2);
     }

Marlin/src/feature/mmu/mmu2.cpp

@@ -54,8 +54,7 @@ MMU2 mmu2;
 #define MMU_CMD_TIMEOUT 45000UL // 45s timeout for mmu commands (except P0)
 #define MMU_P0_TIMEOUT 3000UL   // Timeout for P0 command: 3seconds
 
-#define MMU2_SEND(S) tx_str(F(S "\n"))
+#define MMU2_COMMAND(S) tx_str(F(S "\n"))
-#define MMU2_RECV(S) rx_str(F(S "\n"))
 
 #if ENABLED(MMU_EXTRUDER_SENSOR)
   uint8_t mmu_idl_sens = 0;
@@ -132,7 +131,7 @@ void MMU2::reset() {
     safe_delay(20);
     WRITE(MMU2_RST_PIN, HIGH);
   #else
-    MMU2_SEND("X0");  // Send soft reset
+    MMU2_COMMAND("X0"); // Send soft reset
   #endif
 }
 
@@ -158,9 +157,11 @@ void MMU2::mmu_loop() {
     case -1:
       if (rx_start()) {
         prev_P0_request = millis();   // Initialize finda sensor timeout
+
         DEBUG_ECHOLNPGM("MMU => 'start'");
         DEBUG_ECHOLNPGM("MMU <= 'S1'");
-        MMU2_SEND("S1");    // Read Version
+
+        MMU2_COMMAND("S1");   // Read Version
         state = -2;
       }
       else if (millis() > 30000) { // 30sec after reset disable MMU
@@ -172,8 +173,10 @@ void MMU2::mmu_loop() {
     case -2:
       if (rx_ok()) {
         sscanf(rx_buffer, "%huok\n", &version);
+
         DEBUG_ECHOLNPGM("MMU => ", version, "\nMMU <= 'S2'");
-        MMU2_SEND("S2");    // Read Build Number
+
+        MMU2_COMMAND("S2");   // Read Build Number
         state = -3;
       }
       break;
@@ -188,12 +191,14 @@ void MMU2::mmu_loop() {
 
         #if ENABLED(MMU2_MODE_12V)
           DEBUG_ECHOLNPGM("MMU <= 'M1'");
-          MMU2_SEND("M1");    // Stealth Mode
+
+          MMU2_COMMAND("M1");   // Stealth Mode
           state = -5;
 
         #else
           DEBUG_ECHOLNPGM("MMU <= 'P0'");
-          MMU2_SEND("P0");    // Read FINDA
+
+          MMU2_COMMAND("P0");   // Read FINDA
           state = -4;
         #endif
       }
@@ -204,8 +209,10 @@ void MMU2::mmu_loop() {
       // response to M1
       if (rx_ok()) {
         DEBUG_ECHOLNPGM("MMU => ok");
+
         DEBUG_ECHOLNPGM("MMU <= 'P0'");
-        MMU2_SEND("P0");    // Read FINDA
+
+        MMU2_COMMAND("P0");   // Read FINDA
         state = -4;
       }
       break;
@@ -243,13 +250,14 @@ void MMU2::mmu_loop() {
         else if (cmd == MMU_CMD_C0) {
           // continue loading
           DEBUG_ECHOLNPGM("MMU <= 'C0'");
-          MMU2_SEND("C0");
+          MMU2_COMMAND("C0");
           state = 3; // wait for response
         }
         else if (cmd == MMU_CMD_U0) {
           // unload current
           DEBUG_ECHOLNPGM("MMU <= 'U0'");
-          MMU2_SEND("U0");
+
+          MMU2_COMMAND("U0");
           state = 3; // wait for response
         }
         else if (WITHIN(cmd, MMU_CMD_E0, MMU_CMD_E0 + EXTRUDERS - 1)) {
@@ -262,7 +270,7 @@ void MMU2::mmu_loop() {
         else if (cmd == MMU_CMD_R0) {
           // recover after eject
           DEBUG_ECHOLNPGM("MMU <= 'R0'");
-          MMU2_SEND("R0");
+          MMU2_COMMAND("R0");
           state = 3; // wait for response
         }
         else if (WITHIN(cmd, MMU_CMD_F0, MMU_CMD_F0 + EXTRUDERS - 1)) {
@@ -277,7 +285,7 @@ void MMU2::mmu_loop() {
         cmd = MMU_CMD_NONE;
       }
       else if (ELAPSED(millis(), prev_P0_request + 300)) {
-        MMU2_SEND("P0");  // Read FINDA
+        MMU2_COMMAND("P0"); // Read FINDA
         state = 2; // wait for response
       }
 
@@ -306,7 +314,7 @@ void MMU2::mmu_loop() {
         if (mmu_idl_sens) {
           if (FILAMENT_PRESENT() && mmu_loading_flag) {
             DEBUG_ECHOLNPGM("MMU <= 'A'");
-            MMU2_SEND("A");   // send 'abort' request
+            MMU2_COMMAND("A"); // send 'abort' request
             mmu_idl_sens = 0;
             DEBUG_ECHOLNPGM("MMU IDLER_SENSOR = 0 - ABORT");
           }
@@ -319,9 +327,9 @@ void MMU2::mmu_loop() {
           const bool keep_trying = !mmu2s_triggered && last_cmd == MMU_CMD_C0;
           if (keep_trying) {
             // MMU ok received but filament sensor not triggered, retrying...
-            DEBUG_ECHOLNPGM("MMU => 'ok' (no filament in gears)");
+            DEBUG_ECHOLNPGM("MMU => 'ok' (filament not present in gears)");
             DEBUG_ECHOLNPGM("MMU <= 'C0' (keep trying)");
-            MMU2_SEND("C0");
+            MMU2_COMMAND("C0");
           }
         #else
           constexpr bool keep_trying = false;
@@ -353,7 +361,7 @@ void MMU2::mmu_loop() {
  */
 bool MMU2::rx_start() {
   // check for start message
-  return MMU2_RECV("start");
+  return rx_str(F("start\n"));
 }
 
 /**
@@ -432,7 +440,7 @@ void MMU2::clear_rx_buffer() {
  * Check if we received 'ok' from MMU
  */
 bool MMU2::rx_ok() {
-  if (MMU2_RECV("ok")) {
+  if (rx_str(F("ok\n"))) {
     prev_P0_request = millis();
     return true;
   }
@@ -665,7 +673,7 @@ static void mmu2_not_responding() {
         // When (T0 rx->ok) load is ready, but in fact it did not load
         // successfully or an overload created pressure in the extruder.
         // Send (C0) to load more and move E_AXIS a little to release pressure.
-        if ((fil_present = FILAMENT_PRESENT())) MMU2_SEND("A");
+        if ((fil_present = FILAMENT_PRESENT())) MMU2_COMMAND("A");
       } while (!fil_present && PENDING(millis(), expire_ms));
       stepper.disable_extruder();
       manage_response(true, true);
@@ -874,7 +882,7 @@ void MMU2::filament_runout() {
     if (cmd == MMU_CMD_NONE && last_cmd == MMU_CMD_C0) {
       if (present && !mmu2s_triggered) {
         DEBUG_ECHOLNPGM("MMU <= 'A'");
-        MMU2_SEND("A");
+        tx_str(F("A\n"));
       }
       // Slowly spin the extruder during C0
       else {

Marlin/src/gcode/calibrate/M665.cpp

@@ -167,6 +167,8 @@
     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*/) {

Marlin/src/gcode/control/M993_M994.cpp

@@ -22,7 +22,7 @@
 
 #include "../../inc/MarlinConfig.h"
 
-#if ALL(SPI_FLASH, SDSUPPORT, MARLIN_DEV_MODE)
+#if ALL(HAS_SPI_FLASH, SDSUPPORT, MARLIN_DEV_MODE)
 
 #include "../gcode.h"
 #include "../../sd/cardreader.h"
@@ -85,4 +85,4 @@ void GcodeSuite::M994() {
   card.closefile();
 }
 
-#endif // SPI_FLASH && SDSUPPORT && MARLIN_DEV_MODE
+#endif // HAS_SPI_FLASH && SDSUPPORT && MARLIN_DEV_MODE

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

@@ -197,12 +197,8 @@ void GcodeSuite::M569_report(const bool forReplay/*=true*/) {
   if (chop_x2 || chop_y2 || chop_z2) {
     say_M569(forReplay, F("I1"));
     if (chop_x2) SERIAL_ECHOPGM_P(SP_X_STR);
-    #if HAS_Y_AXIS
+    if (chop_y2) SERIAL_ECHOPGM_P(SP_Y_STR);
-      if (chop_y2) SERIAL_ECHOPGM_P(SP_Y_STR);
+    if (chop_z2) SERIAL_ECHOPGM_P(SP_Z_STR);
-    #endif
-    #if HAS_Z_AXIS
-      if (chop_z2) SERIAL_ECHOPGM_P(SP_Z_STR);
-    #endif
     SERIAL_EOL();
   }
 

Marlin/src/gcode/gcode.cpp

@@ -600,9 +600,7 @@ void GcodeSuite::process_parsed_command(const bool no_ok/*=false*/) {
         case 108: M108(); break;                                  // M108: Cancel Waiting
         case 112: M112(); break;                                  // M112: Full Shutdown
         case 410: M410(); break;                                  // M410: Quickstop - Abort all the planned moves.
-        #if ENABLED(HOST_PROMPT_SUPPORT)
+        TERN_(HOST_PROMPT_SUPPORT, case 876:)                     // M876: Handle Host prompt responses
-          case 876: M876(); break;                                // M876: Handle Host prompt responses
-        #endif
       #else
         case 108: case 112: case 410:
         TERN_(HOST_PROMPT_SUPPORT, case 876:)
@@ -795,10 +793,6 @@ void GcodeSuite::process_parsed_command(const bool no_ok/*=false*/) {
         case 250: M250(); break;                                  // M250: Set LCD contrast
       #endif
 
-      #if HAS_GCODE_M255
-        case 255: M255(); break;                                  // M255: Set LCD Sleep/Backlight Timeout (Minutes)
-      #endif
-
       #if HAS_LCD_BRIGHTNESS
         case 256: M256(); break;                                  // M256: Set LCD brightness
       #endif
@@ -1053,7 +1047,7 @@ void GcodeSuite::process_parsed_command(const bool no_ok/*=false*/) {
         case 422: M422(); break;                                  // M422: Set Z Stepper automatic alignment position using probe
       #endif
 
-      #if ALL(SPI_FLASH, SDSUPPORT, MARLIN_DEV_MODE)
+      #if ALL(HAS_SPI_FLASH, SDSUPPORT, MARLIN_DEV_MODE)
         case 993: M993(); break;                                  // M993: Backup SPI Flash to SD
         case 994: M994(); break;                                  // M994: Load a Backup from SD to SPI Flash
       #endif

Marlin/src/gcode/gcode.h

@@ -1194,7 +1194,7 @@ private:
     static void M995();
   #endif
 
-  #if BOTH(SPI_FLASH, SDSUPPORT)
+  #if BOTH(HAS_SPI_FLASH, SDSUPPORT)
     static void M993();
     static void M994();
   #endif

Marlin/src/gcode/host/M115.cpp

@@ -222,41 +222,24 @@ void GcodeSuite::M115() {
 
     // Machine Geometry
     #if ENABLED(M115_GEOMETRY_REPORT)
-      constexpr xyz_pos_t bmin{0},
+      const xyz_pos_t bmin = { 0, 0, 0 },
-                          bmax = ARRAY_N(NUM_AXES, X_BED_SIZE, Y_BED_SIZE, Z_MAX_POS, I_MAX_POS, J_MAX_POS, K_MAX_POS, U_MAX_POS, V_MAX_POS, W_MAX_POS),
+                      bmax = { X_BED_SIZE , Y_BED_SIZE, Z_MAX_POS },
-                          dmin = ARRAY_N(NUM_AXES, X_MIN_POS,  Y_MIN_POS,  Z_MIN_POS, I_MIN_POS, J_MIN_POS, K_MIN_POS, U_MIN_POS, V_MIN_POS, W_MIN_POS),
+                      dmin = { X_MIN_POS, Y_MIN_POS, Z_MIN_POS },
-                          dmax = ARRAY_N(NUM_AXES, X_MAX_POS,  Y_MAX_POS,  Z_MAX_POS, I_MAX_POS, J_MAX_POS, K_MAX_POS, U_MAX_POS, V_MAX_POS, W_MAX_POS);
+                      dmax = { X_MAX_POS, Y_MAX_POS, Z_MAX_POS };
       xyz_pos_t cmin = bmin, cmax = bmax;
       apply_motion_limits(cmin);
       apply_motion_limits(cmax);
       const xyz_pos_t lmin = dmin.asLogical(), lmax = dmax.asLogical(),
                       wmin = cmin.asLogical(), wmax = cmax.asLogical();
-
       SERIAL_ECHOLNPGM(
         "area:{"
           "full:{"
-            LIST_N(DOUBLE(NUM_AXES),
+            "min:{x:", lmin.x, ",y:", lmin.y, ",z:", lmin.z, "},"
-              "min:{x:", lmin.x, ",y:", lmin.y, ",z:", lmin.z,
+            "max:{x:", lmax.x, ",y:", lmax.y, ",z:", lmax.z, "}"
-                  ",i:", lmin.i, ",j:", lmin.j, ",k:", lmin.k,
-                  ",u:", lmin.u, ",v:", lmin.v, ",w:", lmin.w
-            ),
-            LIST_N(DOUBLE(NUM_AXES),
-              "max:{x:", lmax.x, ",y:", lmax.y, ",z:", lmax.z,
-                  ",i:", lmax.i, ",j:", lmax.j, ",k:", lmax.k,
-                  ",u:", lmax.u, ",v:", lmax.v, ",w:", lmax.w
-            ),
           "},"
           "work:{"
-            LIST_N(DOUBLE(NUM_AXES),
+            "min:{x:", wmin.x, ",y:", wmin.y, ",z:", wmin.z, "},"
-              "min:{x:", wmin.x, ",y:", wmin.y, ",z:", wmin.z,
+            "max:{x:", wmax.x, ",y:", wmax.y, ",z:", wmax.z, "}",
-                  ",i:", wmin.i, ",j:", wmin.j, ",k:", wmin.k,
-                  ",u:", wmin.u, ",v:", wmin.v, ",w:", wmin.w
-            ),
-            LIST_N(DOUBLE(NUM_AXES),
-              "max:{x:", wmax.x, ",y:", wmax.y, ",z:", wmax.z,
-                  ",i:", wmax.i, ",j:", wmax.j, ",k:", wmax.k,
-                  ",u:", wmax.u, ",v:", wmax.v, ",w:", wmax.w
-            ),
           "}"
         "}"
       );

Marlin/src/gcode/lcd/M0_M1.cpp

@@ -85,12 +85,7 @@ void GcodeSuite::M0_M1() {
 
   #endif
 
-  #if ENABLED(HOST_PROMPT_SUPPORT)
+  TERN_(HOST_PROMPT_SUPPORT, hostui.prompt_do(PROMPT_USER_CONTINUE, parser.codenum ? F("M1 Stop") : F("M0 Stop"), FPSTR(CONTINUE_STR)));
-    if (parser.string_arg)
-      hostui.prompt_do(PROMPT_USER_CONTINUE, parser.string_arg, FPSTR(CONTINUE_STR));
-    else
-      hostui.prompt_do(PROMPT_USER_CONTINUE, parser.codenum ? F("M1 Stop") : F("M0 Stop"), FPSTR(CONTINUE_STR));
-  #endif
 
   TERN_(HAS_RESUME_CONTINUE, wait_for_user_response(ms));
 

Marlin/src/inc/Conditionals_LCD.h

@@ -1204,61 +1204,45 @@
 #elif X_HOME_DIR < 0
   #define X_HOME_TO_MIN 1
 #endif
-#if HAS_Y_AXIS
+#if Y_HOME_DIR > 0
-  #if Y_HOME_DIR > 0
+  #define Y_HOME_TO_MAX 1
-    #define Y_HOME_TO_MAX 1
+#elif Y_HOME_DIR < 0
-  #elif Y_HOME_DIR < 0
+  #define Y_HOME_TO_MIN 1
-    #define Y_HOME_TO_MIN 1
-  #endif
 #endif
-#if HAS_Z_AXIS
+#if Z_HOME_DIR > 0
-  #if Z_HOME_DIR > 0
+  #define Z_HOME_TO_MAX 1
-    #define Z_HOME_TO_MAX 1
+#elif Z_HOME_DIR < 0
-  #elif Z_HOME_DIR < 0
+  #define Z_HOME_TO_MIN 1
-    #define Z_HOME_TO_MIN 1
-  #endif
 #endif
-#if HAS_I_AXIS
+#if I_HOME_DIR > 0
-  #if I_HOME_DIR > 0
+  #define I_HOME_TO_MAX 1
-    #define I_HOME_TO_MAX 1
+#elif I_HOME_DIR < 0
-  #elif I_HOME_DIR < 0
+  #define I_HOME_TO_MIN 1
-    #define I_HOME_TO_MIN 1
-  #endif
 #endif
-#if HAS_J_AXIS
+#if J_HOME_DIR > 0
-  #if J_HOME_DIR > 0
+  #define J_HOME_TO_MAX 1
-    #define J_HOME_TO_MAX 1
+#elif J_HOME_DIR < 0
-  #elif J_HOME_DIR < 0
+  #define J_HOME_TO_MIN 1
-    #define J_HOME_TO_MIN 1
-  #endif
 #endif
-#if HAS_K_AXIS
+#if K_HOME_DIR > 0
-  #if K_HOME_DIR > 0
+  #define K_HOME_TO_MAX 1
-    #define K_HOME_TO_MAX 1
+#elif K_HOME_DIR < 0
-  #elif K_HOME_DIR < 0
+  #define K_HOME_TO_MIN 1
-    #define K_HOME_TO_MIN 1
-  #endif
 #endif
-#if HAS_U_AXIS
+#if U_HOME_DIR > 0
-  #if U_HOME_DIR > 0
+  #define U_HOME_TO_MAX 1
-    #define U_HOME_TO_MAX 1
+#elif U_HOME_DIR < 0
-  #elif U_HOME_DIR < 0
+  #define U_HOME_TO_MIN 1
-    #define U_HOME_TO_MIN 1
-  #endif
 #endif
-#if HAS_V_AXIS
+#if V_HOME_DIR > 0
-  #if V_HOME_DIR > 0
+  #define V_HOME_TO_MAX 1
-    #define V_HOME_TO_MAX 1
+#elif V_HOME_DIR < 0
-  #elif V_HOME_DIR < 0
+  #define V_HOME_TO_MIN 1
-    #define V_HOME_TO_MIN 1
-  #endif
 #endif
-#if HAS_W_AXIS
+#if W_HOME_DIR > 0
-  #if W_HOME_DIR > 0
+  #define W_HOME_TO_MAX 1
-    #define W_HOME_TO_MAX 1
+#elif W_HOME_DIR < 0
-  #elif W_HOME_DIR < 0
+  #define W_HOME_TO_MIN 1
-    #define W_HOME_TO_MIN 1
-  #endif
 #endif
 
 /**
@@ -1512,7 +1496,7 @@
   #endif
 #elif ENABLED(TFT_GENERIC)
   #define TFT_DEFAULT_ORIENTATION (TFT_EXCHANGE_XY | TFT_INVERT_X | TFT_INVERT_Y)
-  #if NONE(TFT_RES_320x240, TFT_RES_480x272, TFT_RES_480x320, TFT_RES_1024x600)
+  #if NONE(TFT_RES_320x240, TFT_RES_480x272, TFT_RES_480x320)
     #define TFT_RES_320x240
   #endif
   #if NONE(TFT_INTERFACE_FSMC, TFT_INTERFACE_SPI)
@@ -1590,8 +1574,6 @@
   #elif TFT_HEIGHT == 600
     #if ENABLED(TFT_INTERFACE_LTDC)
       #define TFT_1024x600_LTDC
-    #else
-      #define TFT_1024x600_SIM  // "Simulation" - for testing purposes only
     #endif
   #endif
 #endif
@@ -1602,7 +1584,7 @@
   #define HAS_UI_480x320 1
 #elif EITHER(TFT_480x272, TFT_480x272_SPI)
   #define HAS_UI_480x272 1
-#elif EITHER(TFT_1024x600_LTDC, TFT_1024x600_SIM)
+#elif defined(TFT_1024x600_LTDC)
   #define HAS_UI_1024x600 1
 #endif
 #if ANY(HAS_UI_320x240, HAS_UI_480x320, HAS_UI_480x272)

Marlin/src/inc/Conditionals_adv.h

@@ -1074,3 +1074,14 @@
 #if ANY(DISABLE_INACTIVE_X, DISABLE_INACTIVE_Y, DISABLE_INACTIVE_Z, DISABLE_INACTIVE_I, DISABLE_INACTIVE_J, DISABLE_INACTIVE_K, DISABLE_INACTIVE_U, DISABLE_INACTIVE_V, DISABLE_INACTIVE_W, DISABLE_INACTIVE_E)
   #define HAS_DISABLE_INACTIVE_AXIS 1
 #endif
+
+// Fan Kickstart
+#if FAN_KICKSTART_TIME && !defined(FAN_KICKSTART_POWER)
+  #define FAN_KICKSTART_POWER 180
+#endif
+
+#if FAN_MIN_PWM == 0 && FAN_MAX_PWM == 255
+  #define CALC_FAN_SPEED(f) (f ?: FAN_OFF_PWM)
+#else
+  #define CALC_FAN_SPEED(f) (f ? map(f, 1, 255, FAN_MIN_PWM, FAN_MAX_PWM) : FAN_OFF_PWM)
+#endif

Marlin/src/inc/Conditionals_post.h

@@ -155,7 +155,7 @@
   #define W_BED_SIZE W_MAX_LENGTH
 #endif
 
-// Require 0,0 bed center for Delta, SCARA, and Polargraph
+// Require 0,0 bed center for Delta and SCARA
 #if IS_KINEMATIC
   #define BED_CENTER_AT_0_0
 #endif
@@ -2446,7 +2446,7 @@
 //
 
 // Flag the indexed hardware serial ports in use
-#define SERIAL_IN_USE(N) (  (defined(SERIAL_PORT)      && SERIAL_PORT == N) \
+#define CONF_SERIAL_IS(N) (  (defined(SERIAL_PORT)      && SERIAL_PORT == N) \
                           || (defined(SERIAL_PORT_2)    && SERIAL_PORT_2 == N) \
                           || (defined(SERIAL_PORT_3)    && SERIAL_PORT_3 == N) \
                           || (defined(MMU2_SERIAL_PORT) && MMU2_SERIAL_PORT == N) \
@@ -2454,7 +2454,7 @@
 
 // Flag the named hardware serial ports in use
 #define TMC_UART_IS(A,N) (defined(A##_HARDWARE_SERIAL) && (CAT(HW_,A##_HARDWARE_SERIAL) == HW_Serial##N || CAT(HW_,A##_HARDWARE_SERIAL) == HW_MSerial##N))
-#define ANY_SERIAL_IS(N) (  SERIAL_IN_USE(N) \
+#define ANY_SERIAL_IS(N) (  CONF_SERIAL_IS(N) \
                          || TMC_UART_IS(X,  N) || TMC_UART_IS(Y , N) || TMC_UART_IS(Z , N) \
                          || TMC_UART_IS(I,  N) || TMC_UART_IS(J , N) || TMC_UART_IS(K , N) \
                          || TMC_UART_IS(U,  N) || TMC_UART_IS(V , N) || TMC_UART_IS(W , N) \
@@ -2481,7 +2481,7 @@
 #define HW_MSerial9  518
 #define HW_MSerial10 519
 
-#if SERIAL_IN_USE(-1)
+#if CONF_SERIAL_IS(-1)
   #define USING_HW_SERIALUSB 1
 #endif
 #if ANY_SERIAL_IS(0)
@@ -3605,13 +3605,13 @@
   #endif
 #endif
 
-#if EITHER(HAS_MARLINUI_MENU, TOUCH_UI_FTDI_EVE)
+#if HAS_MARLINUI_MENU
   // LCD timeout to status screen default is 15s
   #ifndef LCD_TIMEOUT_TO_STATUS
     #define LCD_TIMEOUT_TO_STATUS 15000
   #endif
   #if LCD_TIMEOUT_TO_STATUS
-    #define HAS_SCREEN_TIMEOUT 1
+    #define SCREENS_CAN_TIME_OUT 1
   #endif
 #endif
 

Marlin/src/inc/SanityCheck.h

@@ -829,7 +829,7 @@ static_assert(Y_MAX_LENGTH >= Y_BED_SIZE, "Movement bounds (Y_MIN_POS, Y_MAX_POS
 /**
  * Granular software endstops (Marlin >= 1.1.7)
  */
-#if ENABLED(MIN_SOFTWARE_ENDSTOPS) && NONE(MIN_SOFTWARE_ENDSTOP_Z, POLARGRAPH)
+#if ENABLED(MIN_SOFTWARE_ENDSTOPS) && DISABLED(MIN_SOFTWARE_ENDSTOP_Z)
   #if IS_KINEMATIC
     #error "MIN_SOFTWARE_ENDSTOPS on DELTA/SCARA also requires MIN_SOFTWARE_ENDSTOP_Z."
   #elif NONE(MIN_SOFTWARE_ENDSTOP_X, MIN_SOFTWARE_ENDSTOP_Y)
@@ -837,7 +837,7 @@ static_assert(Y_MAX_LENGTH >= Y_BED_SIZE, "Movement bounds (Y_MIN_POS, Y_MAX_POS
   #endif
 #endif
 
-#if ENABLED(MAX_SOFTWARE_ENDSTOPS) && NONE(MAX_SOFTWARE_ENDSTOP_Z, POLARGRAPH)
+#if ENABLED(MAX_SOFTWARE_ENDSTOPS) && DISABLED(MAX_SOFTWARE_ENDSTOP_Z)
   #if IS_KINEMATIC
     #error "MAX_SOFTWARE_ENDSTOPS on DELTA/SCARA also requires MAX_SOFTWARE_ENDSTOP_Z."
   #elif NONE(MAX_SOFTWARE_ENDSTOP_X, MAX_SOFTWARE_ENDSTOP_Y)
@@ -1513,6 +1513,11 @@ static_assert(Y_MAX_LENGTH >= Y_BED_SIZE, "Movement bounds (Y_MIN_POS, Y_MAX_POS
   #error "To use BED_LIMIT_SWITCHING you must disable PIDTEMPBED."
 #endif
 
+// Fan Kickstart
+#if FAN_KICKSTART_TIME && defined(FAN_KICKSTART_POWER) && !WITHIN(FAN_KICKSTART_POWER, 64, 255)
+  #error "FAN_KICKSTART_POWER must be an integer from 64 to 255."
+#endif
+
 /**
  * Synchronous M106/M107 checks
  */
@@ -2641,7 +2646,7 @@ static_assert(Y_MAX_LENGTH >= Y_BED_SIZE, "Movement bounds (Y_MIN_POS, Y_MAX_POS
 #define _PLUG_UNUSED_TEST(A,P) (DISABLED(USE_##P##MIN_PLUG, USE_##P##MAX_PLUG) \
   && !(ENABLED(A##_DUAL_ENDSTOPS) && WITHIN(A##2_USE_ENDSTOP, _##P##MAX_, _##P##MIN_)) \
   && !(ENABLED(A##_MULTI_ENDSTOPS) && WITHIN(A##2_USE_ENDSTOP, _##P##MAX_, _##P##MIN_)) )
-#define _AXIS_PLUG_UNUSED_TEST(A) (HAS_##A##_A NUM_AXIS_GANG(&& _PLUG_UNUSED_TEST(A,X), && _PLUG_UNUSED_TEST(A,Y), && _PLUG_UNUSED_TEST(A,Z), \
+#define _AXIS_PLUG_UNUSED_TEST(A) (1 NUM_AXIS_GANG(&& _PLUG_UNUSED_TEST(A,X), && _PLUG_UNUSED_TEST(A,Y), && _PLUG_UNUSED_TEST(A,Z), \
                                                       && _PLUG_UNUSED_TEST(A,I), && _PLUG_UNUSED_TEST(A,J), && _PLUG_UNUSED_TEST(A,K), \
                                                       && _PLUG_UNUSED_TEST(A,U), && _PLUG_UNUSED_TEST(A,V), && _PLUG_UNUSED_TEST(A,W) ) )
 
@@ -2656,22 +2661,22 @@ static_assert(Y_MAX_LENGTH >= Y_BED_SIZE, "Movement bounds (Y_MIN_POS, Y_MAX_POS
   #if _AXIS_PLUG_UNUSED_TEST(Z)
     #error "You must enable USE_ZMIN_PLUG or USE_ZMAX_PLUG."
   #endif
-  #if _AXIS_PLUG_UNUSED_TEST(I)
+  #if HAS_I_AXIS && _AXIS_PLUG_UNUSED_TEST(I)
     #error "You must enable USE_IMIN_PLUG or USE_IMAX_PLUG."
   #endif
-  #if _AXIS_PLUG_UNUSED_TEST(J)
+  #if HAS_J_AXIS && _AXIS_PLUG_UNUSED_TEST(J)
     #error "You must enable USE_JMIN_PLUG or USE_JMAX_PLUG."
   #endif
-  #if _AXIS_PLUG_UNUSED_TEST(K)
+  #if HAS_K_AXIS && _AXIS_PLUG_UNUSED_TEST(K)
     #error "You must enable USE_KMIN_PLUG or USE_KMAX_PLUG."
   #endif
-  #if _AXIS_PLUG_UNUSED_TEST(U)
+  #if HAS_U_AXIS && _AXIS_PLUG_UNUSED_TEST(U)
     #error "You must enable USE_UMIN_PLUG or USE_UMAX_PLUG."
   #endif
-  #if _AXIS_PLUG_UNUSED_TEST(V)
+  #if HAS_V_AXIS && _AXIS_PLUG_UNUSED_TEST(V)
     #error "You must enable USE_VMIN_PLUG or USE_VMAX_PLUG."
   #endif
-  #if _AXIS_PLUG_UNUSED_TEST(W)
+  #if HAS_W_AXIS && _AXIS_PLUG_UNUSED_TEST(W)
     #error "You must enable USE_WMIN_PLUG or USE_WMAX_PLUG."
   #endif
 
@@ -2685,29 +2690,29 @@ static_assert(Y_MAX_LENGTH >= Y_BED_SIZE, "Movement bounds (Y_MIN_POS, Y_MAX_POS
       #error "Enable USE_YMIN_PLUG when homing Y to MIN."
     #elif Y_HOME_TO_MAX && DISABLED(USE_YMAX_PLUG)
       #error "Enable USE_YMAX_PLUG when homing Y to MAX."
-    #elif I_HOME_TO_MIN && DISABLED(USE_IMIN_PLUG)
+    #elif HAS_I_AXIS && I_HOME_TO_MIN && DISABLED(USE_IMIN_PLUG)
       #error "Enable USE_IMIN_PLUG when homing I to MIN."
-    #elif I_HOME_TO_MAX && DISABLED(USE_IMAX_PLUG)
+    #elif HAS_I_AXIS && I_HOME_TO_MAX && DISABLED(USE_IMAX_PLUG)
       #error "Enable USE_IMAX_PLUG when homing I to MAX."
-    #elif J_HOME_TO_MIN && DISABLED(USE_JMIN_PLUG)
+    #elif HAS_J_AXIS && J_HOME_TO_MIN && DISABLED(USE_JMIN_PLUG)
       #error "Enable USE_JMIN_PLUG when homing J to MIN."
-    #elif J_HOME_TO_MAX && DISABLED(USE_JMAX_PLUG)
+    #elif HAS_J_AXIS && J_HOME_TO_MAX && DISABLED(USE_JMAX_PLUG)
       #error "Enable USE_JMAX_PLUG when homing J to MAX."
-    #elif K_HOME_TO_MIN && DISABLED(USE_KMIN_PLUG)
+    #elif HAS_K_AXIS && K_HOME_TO_MIN && DISABLED(USE_KMIN_PLUG)
       #error "Enable USE_KMIN_PLUG when homing K to MIN."
-    #elif K_HOME_TO_MAX && DISABLED(USE_KMAX_PLUG)
+    #elif HAS_K_AXIS && K_HOME_TO_MAX && DISABLED(USE_KMAX_PLUG)
       #error "Enable USE_KMAX_PLUG when homing K to MAX."
-    #elif U_HOME_TO_MIN && DISABLED(USE_UMIN_PLUG)
+    #elif HAS_U_AXIS && U_HOME_TO_MIN && DISABLED(USE_UMIN_PLUG)
       #error "Enable USE_UMIN_PLUG when homing U to MIN."
-    #elif U_HOME_TO_MAX && DISABLED(USE_UMAX_PLUG)
+    #elif HAS_U_AXIS && U_HOME_TO_MAX && DISABLED(USE_UMAX_PLUG)
       #error "Enable USE_UMAX_PLUG when homing U to MAX."
-    #elif V_HOME_TO_MIN && DISABLED(USE_VMIN_PLUG)
+    #elif HAS_V_AXIS && V_HOME_TO_MIN && DISABLED(USE_VMIN_PLUG)
       #error "Enable USE_VMIN_PLUG when homing V to MIN."
-    #elif V_HOME_TO_MAX && DISABLED(USE_VMAX_PLUG)
+    #elif HAS_V_AXIS && V_HOME_TO_MAX && DISABLED(USE_VMAX_PLUG)
       #error "Enable USE_VMAX_PLUG when homing V to MAX."
-    #elif W_HOME_TO_MIN && DISABLED(USE_WMIN_PLUG)
+    #elif HAS_W_AXIS && W_HOME_TO_MIN && DISABLED(USE_WMIN_PLUG)
       #error "Enable USE_WMIN_PLUG when homing W to MIN."
-    #elif W_HOME_TO_MAX && DISABLED(USE_WMAX_PLUG)
+    #elif HAS_W_AXIS && W_HOME_TO_MAX && DISABLED(USE_WMAX_PLUG)
       #error "Enable USE_WMAX_PLUG when homing W to MAX."
     #endif
   #endif
@@ -3106,7 +3111,7 @@ static_assert(Y_MAX_LENGTH >= Y_BED_SIZE, "Movement bounds (Y_MIN_POS, Y_MAX_POS
  * Display Sleep is not supported by these common displays
  */
 #if HAS_DISPLAY_SLEEP
-  #if ANY(IS_U8GLIB_LM6059_AF, IS_U8GLIB_ST7565_64128, REPRAPWORLD_GRAPHICAL_LCD, FYSETC_MINI, CR10_STOCKDISPLAY, ENDER2_STOCKDISPLAY, MINIPANEL)
+  #if ANY(IS_U8GLIB_LM6059_AF, IS_U8GLIB_ST7565_64128, REPRAPWORLD_GRAPHICAL_LCD, FYSETC_MINI, ENDER2_STOCKDISPLAY, MINIPANEL)
     #error "DISPLAY_SLEEP_MINUTES is not supported by your display."
   #elif !WITHIN(DISPLAY_SLEEP_MINUTES, 0, 255)
     #error "DISPLAY_SLEEP_MINUTES must be between 0 and 255."
@@ -3565,8 +3570,8 @@ static_assert(Y_MAX_LENGTH >= Y_BED_SIZE, "Movement bounds (Y_MIN_POS, Y_MAX_POS
     #error "SENSORLESS_HOMING on DELTA currently requires STEALTHCHOP_XY and STEALTHCHOP_Z."
   #elif ENDSTOP_NOISE_THRESHOLD
     #error "SENSORLESS_HOMING is incompatible with ENDSTOP_NOISE_THRESHOLD."
-  #elif !(X_SENSORLESS || Y_SENSORLESS || Z_SENSORLESS || I_SENSORLESS || J_SENSORLESS || K_SENSORLESS || U_SENSORLESS || V_SENSORLESS || W_SENSORLESS)
+  #elif !(X_SENSORLESS || Y_SENSORLESS || Z_SENSORLESS)
-    #error "SENSORLESS_HOMING requires a TMC stepper driver with StallGuard on X, Y, Z, I, J, K, U, V, or W axes."
+    #error "SENSORLESS_HOMING requires a TMC stepper driver with StallGuard on X, Y, or Z axes."
   #endif
 
   #undef X_ENDSTOP_INVERTING

Marlin/src/inc/Version.h

@@ -42,7 +42,7 @@
  * version was tagged.
  */
 #ifndef STRING_DISTRIBUTION_DATE
-  #define STRING_DISTRIBUTION_DATE "2022-10-18"
+  #define STRING_DISTRIBUTION_DATE "2022-10-12"
 #endif
 
 /**

Marlin/src/lcd/buttons.h

@@ -26,7 +26,7 @@
 #if ((!HAS_ADC_BUTTONS && IS_NEWPANEL) || BUTTONS_EXIST(EN1, EN2)) && !IS_TFTGLCD_PANEL
   #define HAS_ENCODER_WHEEL 1
 #endif
-#if (HAS_ENCODER_WHEEL || ANY_BUTTON(ENC, BACK, UP, DOWN, LEFT, RIGHT)) && DISABLED(TOUCH_UI_FTDI_EVE)
+#if (HAS_ENCODER_WHEEL || ANY_BUTTON(ENC, BACK, UP, DWN, LFT, RT)) && DISABLED(TOUCH_UI_FTDI_EVE)
   #define HAS_DIGITAL_BUTTONS 1
 #endif
 #if !HAS_ADC_BUTTONS && (IS_RRW_KEYPAD || (HAS_WIRED_LCD && !IS_NEWPANEL))
@@ -190,18 +190,18 @@
 #else
   #define _BUTTON_PRESSED_UP false
 #endif
-#if BUTTON_EXISTS(DOWN)
+#if BUTTON_EXISTS(DWN)
-  #define _BUTTON_PRESSED_DWN _BUTTON_PRESSED(DOWN)
+  #define _BUTTON_PRESSED_DWN _BUTTON_PRESSED(DWN)
 #else
   #define _BUTTON_PRESSED_DWN false
 #endif
-#if BUTTON_EXISTS(LEFT)
+#if BUTTON_EXISTS(LFT)
-  #define _BUTTON_PRESSED_LFT _BUTTON_PRESSED(LEFT)
+  #define _BUTTON_PRESSED_LFT _BUTTON_PRESSED(LFT)
 #else
   #define _BUTTON_PRESSED_LFT false
 #endif
-#if BUTTON_EXISTS(RIGHT)
+#if BUTTON_EXISTS(RT)
-  #define _BUTTON_PRESSED_RT _BUTTON_PRESSED(RIGHT)
+  #define _BUTTON_PRESSED_RT _BUTTON_PRESSED(RT)
 #else
   #define _BUTTON_PRESSED_RT false
 #endif

Marlin/src/lcd/dogm/status_screen_DOGM.cpp

@@ -438,7 +438,7 @@ FORCE_INLINE void _draw_axis_value(const AxisEnum axis, const char *value, const
   else if (axis_should_home(axis))
     while (const char c = *value++) lcd_put_lchar(c <= '.' ? c : '?');
   else if (NONE(HOME_AFTER_DEACTIVATE, DISABLE_REDUCED_ACCURACY_WARNING) && !axis_is_trusted(axis))
-    lcd_put_u8str(TERN0(HAS_Z_AXIS, axis == Z_AXIS) ? F("       ") : F("    "));
+    lcd_put_u8str(axis == Z_AXIS ? F("       ") : F("    "));
   else
     lcd_put_u8str(value);
 }
@@ -500,13 +500,7 @@ FORCE_INLINE void _draw_axis_value(const AxisEnum axis, const char *value, const
  */
 void MarlinUI::draw_status_screen() {
   constexpr int xystorage = TERN(INCH_MODE_SUPPORT, 8, 5);
-  static char xstring[TERN(LCD_SHOW_E_TOTAL, 12, xystorage)];
+  static char xstring[TERN(LCD_SHOW_E_TOTAL, 12, xystorage)], ystring[xystorage], zstring[8];
-  #if HAS_Y_AXIS
-    static char ystring[xystorage];
-  #endif
-  #if HAS_Z_AXIS
-    static char zstring[8];
-  #endif
 
   #if ENABLED(FILAMENT_LCD_DISPLAY)
     static char wstring[5], mstring[4];
@@ -531,9 +525,7 @@ void MarlinUI::draw_status_screen() {
 
     const xyz_pos_t lpos = current_position.asLogical();
     const bool is_inch = parser.using_inch_units();
-    #if HAS_Z_AXIS
+    strcpy(zstring, is_inch ? ftostr42_52(LINEAR_UNIT(lpos.z)) : ftostr52sp(lpos.z));
-      strcpy(zstring, is_inch ? ftostr42_52(LINEAR_UNIT(lpos.z)) : ftostr52sp(lpos.z));
-    #endif
 
     if (show_e_total) {
       #if ENABLED(LCD_SHOW_E_TOTAL)
@@ -543,7 +535,7 @@ void MarlinUI::draw_status_screen() {
     }
     else {
       strcpy(xstring, is_inch ? ftostr53_63(LINEAR_UNIT(lpos.x)) : ftostr4sign(lpos.x));
-      TERN_(HAS_Y_AXIS, strcpy(ystring, is_inch ? ftostr53_63(LINEAR_UNIT(lpos.y)) : ftostr4sign(lpos.y)));
+      strcpy(ystring, is_inch ? ftostr53_63(LINEAR_UNIT(lpos.y)) : ftostr4sign(lpos.y));
     }
 
     #if ENABLED(FILAMENT_LCD_DISPLAY)
@@ -866,14 +858,12 @@ void MarlinUI::draw_status_screen() {
         }
         else {
           _draw_axis_value(X_AXIS, xstring, blink);
-          TERN_(HAS_Y_AXIS, _draw_axis_value(Y_AXIS, ystring, blink));
+          _draw_axis_value(Y_AXIS, ystring, blink);
         }
 
       #endif
 
-      #if HAS_Z_AXIS
+      _draw_axis_value(Z_AXIS, zstring, blink);
-        _draw_axis_value(Z_AXIS, zstring, blink);
-      #endif
 
       #if NONE(XYZ_NO_FRAME, XYZ_HOLLOW_FRAME)
         u8g.setColorIndex(1); // black on white

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

@@ -45,16 +45,15 @@ bool BaseScreen::buttonStyleCallback(CommandProcessor &cmd, uint8_t tag, uint8_t
     return false;
   }
 
-  #if HAS_SCREEN_TIMEOUT
+  #if SCREENS_CAN_TIME_OUT
     if (EventLoop::get_pressed_tag() != 0) {
-      #if ENABLED(TOUCH_UI_DEBUG)
-        SERIAL_ECHO_MSG("buttonStyleCallback, resetting timeout");
-      #endif
       reset_menu_timeout();
     }
   #endif
 
-  if (buttonIsPressed(tag)) options = OPT_FLAT;
+  if (buttonIsPressed(tag)) {
+    options = OPT_FLAT;
+  }
 
   if (style & cmd.STYLE_DISABLED) {
     cmd.tag(0);
@@ -66,10 +65,7 @@ bool BaseScreen::buttonStyleCallback(CommandProcessor &cmd, uint8_t tag, uint8_t
 }
 
 void BaseScreen::onIdle() {
-  #if HAS_SCREEN_TIMEOUT
+  #if SCREENS_CAN_TIME_OUT
-    if (EventLoop::get_pressed_tag() != 0)
-      reset_menu_timeout();
-
     if ((millis() - last_interaction) > LCD_TIMEOUT_TO_STATUS) {
       reset_menu_timeout();
       #if ENABLED(TOUCH_UI_DEBUG)
@@ -81,10 +77,10 @@ void BaseScreen::onIdle() {
 }
 
 void BaseScreen::reset_menu_timeout() {
-  TERN_(HAS_SCREEN_TIMEOUT, last_interaction = millis());
+  TERN_(SCREENS_CAN_TIME_OUT, last_interaction = millis());
 }
 
-#if HAS_SCREEN_TIMEOUT
+#if SCREENS_CAN_TIME_OUT
   uint32_t BaseScreen::last_interaction;
 #endif
 

Marlin/src/lcd/extui/ftdi_eve_touch_ui/generic/base_screen.h

@@ -27,7 +27,7 @@
 
 class BaseScreen : public UIScreen {
   protected:
-    #if HAS_SCREEN_TIMEOUT
+    #if SCREENS_CAN_TIME_OUT
       static uint32_t last_interaction;
     #endif
 

Marlin/src/lcd/extui/mks_ui/SPIFlashStorage.cpp

@@ -27,8 +27,8 @@
 #include "../../../inc/MarlinConfig.h"
 #include "SPIFlashStorage.h"
 
-#if DISABLED(SPI_FLASH)
+#if !HAS_SPI_FLASH
-  #error "SPI_FLASH is required with TFT_LVGL_UI."
+  #error "HAS_SPI_FLASH is required with TFT_LVGL_UI."
 #endif
 
 extern W25QXXFlash W25QXX;

Marlin/src/lcd/extui/mks_ui/tft_lvgl_configuration.cpp

@@ -482,14 +482,14 @@ void lv_encoder_pin_init() {
   #if BUTTON_EXISTS(UP)
     SET_INPUT(BTN_UP);
   #endif
-  #if BUTTON_EXISTS(DOWN)
+  #if BUTTON_EXISTS(DWN)
-    SET_INPUT(BTN_DOWN);
+    SET_INPUT(BTN_DWN);
   #endif
-  #if BUTTON_EXISTS(LEFT)
+  #if BUTTON_EXISTS(LFT)
-    SET_INPUT(BTN_LEFT);
+    SET_INPUT(BTN_LFT);
   #endif
-  #if BUTTON_EXISTS(RIGHT)
+  #if BUTTON_EXISTS(RT)
-    SET_INPUT(BTN_RIGHT);
+    SET_INPUT(BTN_RT);
   #endif
 }
 

Marlin/src/lcd/language/language_en.h

@@ -418,12 +418,6 @@ namespace Language_en {
   LSTR MSG_FILAMENT_DIAM_E                = _UxGT("Fil. Dia. *");
   LSTR MSG_FILAMENT_UNLOAD                = _UxGT("Unload mm");
   LSTR MSG_FILAMENT_LOAD                  = _UxGT("Load mm");
-  LSTR MSG_SEGMENTS_PER_SECOND            = _UxGT("Segments/Sec");
-  LSTR MSG_DRAW_MIN_X                     = _UxGT("Draw Min X");
-  LSTR MSG_DRAW_MAX_X                     = _UxGT("Draw Max X");
-  LSTR MSG_DRAW_MIN_Y                     = _UxGT("Draw Min Y");
-  LSTR MSG_DRAW_MAX_Y                     = _UxGT("Draw Max Y");
-  LSTR MSG_MAX_BELT_LEN                   = _UxGT("Max Belt Len");
   LSTR MSG_ADVANCE_K                      = _UxGT("Advance K");
   LSTR MSG_ADVANCE_K_E                    = _UxGT("Advance K *");
   LSTR MSG_CONTRAST                       = _UxGT("LCD Contrast");

Marlin/src/lcd/marlinui.cpp

@@ -227,14 +227,14 @@ void MarlinUI::init() {
     #if BUTTON_EXISTS(UP)
       SET_INPUT(BTN_UP);
     #endif
-    #if BUTTON_EXISTS(DOWN)
+    #if BUTTON_EXISTS(DWN)
-      SET_INPUT(BTN_DOWN);
+      SET_INPUT(BTN_DWN);
     #endif
     #if BUTTON_EXISTS(LFT)
-      SET_INPUT(BTN_LEFT);
+      SET_INPUT(BTN_LFT);
     #endif
     #if BUTTON_EXISTS(RT)
-      SET_INPUT(BTN_RIGHT);
+      SET_INPUT(BTN_RT);
     #endif
   #endif
 
@@ -316,7 +316,7 @@ void MarlinUI::init() {
     #endif
   #endif
 
-  #if HAS_SCREEN_TIMEOUT
+  #if SCREENS_CAN_TIME_OUT
     bool MarlinUI::defer_return_to_status;
     millis_t MarlinUI::return_to_status_ms = 0;
   #endif
@@ -1171,7 +1171,7 @@ void MarlinUI::init() {
           NOLESS(max_display_update_time, millis() - ms);
       }
 
-      #if HAS_SCREEN_TIMEOUT
+      #if SCREENS_CAN_TIME_OUT
         // Return to Status Screen after a timeout
         if (on_status_screen() || defer_return_to_status)
           reset_status_timeout(ms);
@@ -1303,7 +1303,7 @@ void MarlinUI::init() {
           //
           // Directional buttons
           //
-          #if ANY_BUTTON(UP, DOWN, LEFT, RIGHT)
+          #if ANY_BUTTON(UP, DWN, LFT, RT)
 
             const int8_t pulses = epps * encoderDirection;
 
@@ -1311,20 +1311,20 @@ void MarlinUI::init() {
               encoderDiff = (ENCODER_STEPS_PER_MENU_ITEM) * pulses;
               next_button_update_ms = now + 300;
             }
-            else if (BUTTON_PRESSED(DOWN)) {
+            else if (BUTTON_PRESSED(DWN)) {
               encoderDiff = -(ENCODER_STEPS_PER_MENU_ITEM) * pulses;
               next_button_update_ms = now + 300;
             }
-            else if (BUTTON_PRESSED(LEFT)) {
+            else if (BUTTON_PRESSED(LFT)) {
               encoderDiff = -pulses;
               next_button_update_ms = now + 300;
             }
-            else if (BUTTON_PRESSED(RIGHT)) {
+            else if (BUTTON_PRESSED(RT)) {
               encoderDiff = pulses;
               next_button_update_ms = now + 300;
             }
 
-          #endif // UP || DOWN || LEFT || RIGHT
+          #endif // UP || DWN || LFT || RT
 
           buttons = (newbutton | TERN0(HAS_SLOW_BUTTONS, slow_buttons)
             #if BOTH(HAS_TOUCH_BUTTONS, HAS_ENCODER_ACTION)
@@ -1726,7 +1726,7 @@ void MarlinUI::init() {
     );
   }
 
-  #if LCD_WITH_BLINK && DISABLED(HAS_GRAPHICAL_TFT)
+  #if LCD_WITH_BLINK
     typedef void (*PrintProgress_t)();
     void MarlinUI::rotate_progress() { // Renew and redraw all enabled progress strings
       const PrintProgress_t progFunc[] = {

Marlin/src/lcd/marlinui.h

@@ -545,7 +545,7 @@ public:
   #endif
 
   static void reset_status_timeout(const millis_t ms) {
-    TERN(HAS_SCREEN_TIMEOUT, return_to_status_ms = ms + LCD_TIMEOUT_TO_STATUS, UNUSED(ms));
+    TERN(SCREENS_CAN_TIME_OUT, return_to_status_ms = ms + LCD_TIMEOUT_TO_STATUS, UNUSED(ms));
   }
 
   #if HAS_MARLINUI_MENU
@@ -596,11 +596,11 @@ public:
     #endif
 
     FORCE_INLINE static bool screen_is_sticky() {
-      return TERN1(HAS_SCREEN_TIMEOUT, defer_return_to_status);
+      return TERN1(SCREENS_CAN_TIME_OUT, defer_return_to_status);
     }
 
     FORCE_INLINE static void defer_status_screen(const bool defer=true) {
-      TERN(HAS_SCREEN_TIMEOUT, defer_return_to_status = defer, UNUSED(defer));
+      TERN(SCREENS_CAN_TIME_OUT, defer_return_to_status = defer, UNUSED(defer));
     }
 
     static void goto_previous_screen_no_defer() {
@@ -778,7 +778,7 @@ public:
 
 private:
 
-  #if HAS_SCREEN_TIMEOUT
+  #if SCREENS_CAN_TIME_OUT
     static millis_t return_to_status_ms;
     static bool defer_return_to_status;
   #else

Marlin/src/lcd/menu/menu.cpp

@@ -61,7 +61,7 @@ typedef struct {
   screenFunc_t menu_function;     // The screen's function
   uint32_t encoder_position;      // The position of the encoder
   int8_t top_line, items;         // The amount of scroll, and the number of items
-  #if HAS_SCREEN_TIMEOUT
+  #if SCREENS_CAN_TIME_OUT
     bool sticky;                  // The screen is sticky
   #endif
 } menuPosition;
@@ -89,7 +89,7 @@ void MarlinUI::return_to_status() { goto_screen(status_screen); }
 
 void MarlinUI::push_current_screen() {
   if (screen_history_depth < COUNT(screen_history))
-    screen_history[screen_history_depth++] = { currentScreen, encoderPosition, encoderTopLine, screen_items OPTARG(HAS_SCREEN_TIMEOUT, screen_is_sticky()) };
+    screen_history[screen_history_depth++] = { currentScreen, encoderPosition, encoderTopLine, screen_items OPTARG(SCREENS_CAN_TIME_OUT, screen_is_sticky()) };
 }
 
 void MarlinUI::_goto_previous_screen(TERN_(TURBO_BACK_MENU_ITEM, const bool is_back/*=false*/)) {
@@ -102,7 +102,7 @@ void MarlinUI::_goto_previous_screen(TERN_(TURBO_BACK_MENU_ITEM, const bool is_b
       is_back ? 0 : sh.top_line,
       sh.items
     );
-    defer_status_screen(TERN_(HAS_SCREEN_TIMEOUT, sh.sticky));
+    defer_status_screen(TERN_(SCREENS_CAN_TIME_OUT, sh.sticky));
   }
   else
     return_to_status();

Marlin/src/lcd/menu/menu_advanced.cpp

@@ -222,10 +222,10 @@ void menu_backlash();
   void apply_PID_p(const int8_t e) {
     switch (e) {
       #if ENABLED(PIDTEMPBED)
-        case H_BED: thermalManager.temp_bed.pid.set_Kp(raw_Kp); break;
+        case H_BED: thermalManager.temp_bed.pid.set_Ki(raw_Ki); break;
       #endif
       #if ENABLED(PIDTEMPCHAMBER)
-        case H_CHAMBER: thermalManager.temp_chamber.pid.set_Kp(raw_Kp); break;
+        case H_CHAMBER: thermalManager.temp_chamber.pid.set_Ki(raw_Ki); break;
       #endif
       default:
         #if ENABLED(PIDTEMP)
@@ -477,9 +477,7 @@ void menu_backlash();
 
   // M201 / M204 Accelerations
   void menu_advanced_acceleration() {
-    float max_accel = planner.settings.max_acceleration_mm_per_s2[A_AXIS];
+    const float max_accel = _MAX(planner.settings.max_acceleration_mm_per_s2[A_AXIS], planner.settings.max_acceleration_mm_per_s2[B_AXIS], planner.settings.max_acceleration_mm_per_s2[C_AXIS]);
-    TERN_(HAS_Y_AXIS, NOLESS(max_accel, planner.settings.max_acceleration_mm_per_s2[B_AXIS]));
-    TERN_(HAS_Z_AXIS, NOLESS(max_accel, planner.settings.max_acceleration_mm_per_s2[C_AXIS]));
 
     // M201 settings
     constexpr xyze_ulong_t max_accel_edit =
@@ -634,20 +632,10 @@ void menu_advanced_settings() {
 
   #if DISABLED(SLIM_LCD_MENUS)
 
-    #if ENABLED(POLARGRAPH)
-      // M665 - Polargraph Settings
-      if (!is_busy) {
-        EDIT_ITEM_FAST(float4, MSG_SEGMENTS_PER_SECOND, &segments_per_second, 100, 9999);               // M665 S
-        EDIT_ITEM_FAST(float51sign, MSG_DRAW_MIN_X, &draw_area_min.x, X_MIN_POS, draw_area_max.x - 10); // M665 L
-        EDIT_ITEM_FAST(float51sign, MSG_DRAW_MAX_X, &draw_area_max.x, draw_area_min.x + 10, X_MAX_POS); // M665 R
-        EDIT_ITEM_FAST(float51sign, MSG_DRAW_MIN_Y, &draw_area_min.y, Y_MIN_POS, draw_area_max.y - 10); // M665 T
-        EDIT_ITEM_FAST(float51sign, MSG_DRAW_MAX_Y, &draw_area_max.y, draw_area_min.y + 10, Y_MAX_POS); // M665 B
-        EDIT_ITEM_FAST(float51sign, MSG_MAX_BELT_LEN, &polargraph_max_belt_len, 500, 2000);             // M665 H
-      }
-    #endif
-
     #if HAS_M206_COMMAND
-      // M428 - Set Home Offsets
+      //
+      // Set Home Offsets
+      //
       ACTION_ITEM(MSG_SET_HOME_OFFSETS, []{ queue.inject(F("M428")); ui.return_to_status(); });
     #endif
 

Marlin/src/lcd/menu/menu_motion.cpp

@@ -28,7 +28,7 @@
 
 #if HAS_MARLINUI_MENU
 
-#define LARGE_AREA_TEST ((X_BED_SIZE) >= 1000 || TERN0(HAS_Y_AXIS, (Y_BED_SIZE) >= 1000) || TERN0(HAS_Z_AXIS, (Z_MAX_POS) >= 1000))
+#define LARGE_AREA_TEST ((X_BED_SIZE) >= 1000 || (Y_BED_SIZE) >= 1000 || (Z_MAX_POS) >= 1000)
 
 #include "menu_item.h"
 #include "menu_addon.h"
@@ -160,10 +160,8 @@ void _menu_move_distance(const AxisEnum axis, const screenFunc_t func, const int
     SUBMENU(MSG_MOVE_10MM, []{ _goto_manual_move(10);    });
     SUBMENU(MSG_MOVE_1MM,  []{ _goto_manual_move( 1);    });
     SUBMENU(MSG_MOVE_01MM, []{ _goto_manual_move( 0.1f); });
-    #if HAS_Z_AXIS
+    if (axis == Z_AXIS && (FINE_MANUAL_MOVE) > 0.0f && (FINE_MANUAL_MOVE) < 0.1f)
-      if (axis == Z_AXIS && (FINE_MANUAL_MOVE) > 0.0f && (FINE_MANUAL_MOVE) < 0.1f)
+      SUBMENU_f(F(STRINGIFY(FINE_MANUAL_MOVE)), MSG_MOVE_N_MM, []{ _goto_manual_move(float(FINE_MANUAL_MOVE)); });
-        SUBMENU_f(F(STRINGIFY(FINE_MANUAL_MOVE)), MSG_MOVE_N_MM, []{ _goto_manual_move(float(FINE_MANUAL_MOVE)); });
-    #endif
   }
   END_MENU();
 }

Marlin/src/libs/W25Qxx.cpp

@@ -22,7 +22,7 @@
 
 #include "../inc/MarlinConfig.h"
 
-#if ENABLED(SPI_FLASH)
+#if HAS_SPI_FLASH
 
 #include "W25Qxx.h"
 
@@ -380,4 +380,4 @@ void W25QXXFlash::SPI_FLASH_BufferRead(uint8_t *pBuffer, uint32_t ReadAddr, uint
   SPI_FLASH_CS_H();
 }
 
-#endif // SPI_FLASH
+#endif // HAS_SPI_FLASH

Marlin/src/module/motion.cpp

@@ -341,6 +341,7 @@ void report_current_position_projected() {
       can_reach = (
            a < polargraph_max_belt_len + 1
         && b < polargraph_max_belt_len + 1
+        && (a + b) > _MIN(draw_area_size.x, draw_area_size.y)
       );
 
     #endif
@@ -561,8 +562,7 @@ void do_blocking_move_to(NUM_AXIS_ARGS(const float), const_feedRate_t fr_mm_s/*=
     const feedRate_t w_feedrate = fr_mm_s ?: homing_feedrate(W_AXIS)
   );
 
-  #if IS_KINEMATIC && DISABLED(POLARGRAPH)
+  #if IS_KINEMATIC
-    // kinematic machines are expected to home to a point 1.5x their range? never reachable.
     if (!position_is_reachable(x, y)) return;
     destination = current_position;          // sync destination at the start
   #endif
@@ -919,16 +919,11 @@ void restore_feedrate_and_scaling() {
         constexpr xy_pos_t offs{0};
       #endif
 
-      #if ENABLED(POLARGRAPH)
+      if (TERN1(IS_SCARA, axis_was_homed(X_AXIS) && axis_was_homed(Y_AXIS))) {
-        LIMIT(target.x, draw_area_min.x, draw_area_max.x);
+        const float dist_2 = HYPOT2(target.x - offs.x, target.y - offs.y);
-        LIMIT(target.y, draw_area_min.y, draw_area_max.y);
+        if (dist_2 > delta_max_radius_2)
-      #else
+          target *= float(delta_max_radius / SQRT(dist_2)); // 200 / 300 = 0.66
-        if (TERN1(IS_SCARA, axis_was_homed(X_AXIS) && axis_was_homed(Y_AXIS))) {
+      }
-          const float dist_2 = HYPOT2(target.x - offs.x, target.y - offs.y);
-          if (dist_2 > delta_max_radius_2)
-            target *= float(delta_max_radius / SQRT(dist_2)); // 200 / 300 = 0.66
-        }
-      #endif
 
     #else
 

Marlin/src/module/planner.cpp

@@ -1282,16 +1282,10 @@ void Planner::recalculate(TERN_(HINTS_SAFE_EXIT_SPEED, const_float_t safe_exit_s
 
   void Planner::sync_fan_speeds(uint8_t (&fan_speed)[FAN_COUNT]) {
 
-    #if FAN_MIN_PWM != 0 || FAN_MAX_PWM != 255
-      #define CALC_FAN_SPEED(f) (fan_speed[f] ? map(fan_speed[f], 1, 255, FAN_MIN_PWM, FAN_MAX_PWM) : FAN_OFF_PWM)
-    #else
-      #define CALC_FAN_SPEED(f) (fan_speed[f] ?: FAN_OFF_PWM)
-    #endif
-
     #if ENABLED(FAN_SOFT_PWM)
-      #define _FAN_SET(F) thermalManager.soft_pwm_amount_fan[F] = CALC_FAN_SPEED(F);
+      #define _FAN_SET(F) thermalManager.soft_pwm_amount_fan[F] = CALC_FAN_SPEED(fan_speed[F]);
     #else
-      #define _FAN_SET(F) hal.set_pwm_duty(pin_t(FAN##F##_PIN), CALC_FAN_SPEED(F));
+      #define _FAN_SET(F) hal.set_pwm_duty(pin_t(FAN##F##_PIN), CALC_FAN_SPEED(fan_speed[F]));
     #endif
     #define FAN_SET(F) do{ kickstart_fan(fan_speed, ms, F); _FAN_SET(F); }while(0)
 
@@ -1306,13 +1300,13 @@ void Planner::recalculate(TERN_(HINTS_SAFE_EXIT_SPEED, const_float_t safe_exit_s
 
     void Planner::kickstart_fan(uint8_t (&fan_speed)[FAN_COUNT], const millis_t &ms, const uint8_t f) {
       static millis_t fan_kick_end[FAN_COUNT] = { 0 };
-      if (fan_speed[f]) {
+      if (fan_speed[f] > FAN_OFF_PWM) {
         if (fan_kick_end[f] == 0) {
           fan_kick_end[f] = ms + FAN_KICKSTART_TIME;
-          fan_speed[f] = 255;
+          fan_speed[f] = FAN_KICKSTART_POWER;
         }
         else if (PENDING(ms, fan_kick_end[f]))
-          fan_speed[f] = 255;
+          fan_speed[f] = FAN_KICKSTART_POWER;
       }
       else
         fan_kick_end[f] = 0;
@@ -2244,6 +2238,7 @@ bool Planner::_populate_block(
 
   TERN_(MIXING_EXTRUDER, mixer.populate_block(block->b_color));
 
+
   #if HAS_FAN
     FANS_LOOP(i) block->fan_speed[i] = thermalManager.fan_speed[i];
   #endif

Marlin/src/module/polargraph.cpp

@@ -37,12 +37,17 @@
 #include "../lcd/marlinui.h"
 #include "../MarlinCore.h"
 
-// Initialized by settings.load()
+float segments_per_second; // Initialized by settings.load()
-float segments_per_second, polargraph_max_belt_len;
+
-xy_pos_t draw_area_min, draw_area_max;
+xy_pos_t draw_area_min = { X_MIN_POS, Y_MIN_POS },
+         draw_area_max = { X_MAX_POS, Y_MAX_POS };
+
+xy_float_t draw_area_size = { X_MAX_POS - X_MIN_POS, Y_MAX_POS - Y_MIN_POS };
+
+float polargraph_max_belt_len = HYPOT(draw_area_size.x, draw_area_size.y);
 
 void inverse_kinematics(const xyz_pos_t &raw) {
-  const float x1 = raw.x - draw_area_min.x, x2 = draw_area_max.x - raw.x, y = raw.y - draw_area_max.y;
+  const float x1 = raw.x - (draw_area_min.x), x2 = (draw_area_max.x) - raw.x, y = raw.y - (draw_area_max.y);
   delta.set(HYPOT(x1, y), HYPOT(x2, y), raw.z);
 }
 

Marlin/src/module/polargraph.h

@@ -30,6 +30,7 @@
 
 extern float segments_per_second;
 extern xy_pos_t draw_area_min, draw_area_max;
+extern xy_float_t draw_area_size;
 extern float polargraph_max_belt_len;
 
 void inverse_kinematics(const xyz_pos_t &raw);

Marlin/src/module/probe.h

@@ -146,7 +146,7 @@ public:
 
   #else
 
-    static constexpr xyz_pos_t offset = xyz_pos_t(NUM_AXIS_ARRAY_1(0)); // See #16767
+    static constexpr xyz_pos_t offset = xyz_pos_t(NUM_AXIS_ARRAY(0, 0, 0, 0, 0, 0)); // See #16767
 
     static bool set_deployed(const bool) { return false; }
 

Marlin/src/module/settings.cpp

@@ -257,7 +257,7 @@ typedef struct SettingsDataStruct {
   // HAS_BED_PROBE
   //
 
-  xyz_pos_t probe_offset;                               // M851 X Y Z
+  xyz_pos_t probe_offset;
 
   //
   // ABL_PLANAR
@@ -330,11 +330,7 @@ typedef struct SettingsDataStruct {
             delta_diagonal_rod;                         // M665 L
       abc_float_t delta_tower_angle_trim,               // M665 X Y Z
                   delta_diagonal_rod_trim;              // M665 A B C
-    #elif ENABLED(POLARGRAPH)
-      xy_pos_t draw_area_min, draw_area_max;            // M665 L R T B
-      float polargraph_max_belt_len;                    // M665 H
     #endif
-
   #endif
 
   //
@@ -472,7 +468,7 @@ typedef struct SettingsDataStruct {
   //
   // SKEW_CORRECTION
   //
-  skew_factor_t planner_skew_factor;                    // M852 I J K
+  skew_factor_t planner_skew_factor;                    // M852 I J K  planner.skew_factor
 
   //
   // ADVANCED_PAUSE_FEATURE
@@ -1005,11 +1001,6 @@ void MarlinSettings::postprocess() {
         EEPROM_WRITE(delta_diagonal_rod);        // 1 float
         EEPROM_WRITE(delta_tower_angle_trim);    // 3 floats
         EEPROM_WRITE(delta_diagonal_rod_trim);   // 3 floats
-      #elif ENABLED(POLARGRAPH)
-        _FIELD_TEST(draw_area_min);
-        EEPROM_WRITE(draw_area_min);             // 2 floats
-        EEPROM_WRITE(draw_area_max);             // 2 floats
-        EEPROM_WRITE(polargraph_max_belt_len);   // 1 float
       #endif
     }
     #endif
@@ -1444,14 +1435,6 @@ void MarlinSettings::postprocess() {
     _FIELD_TEST(planner_skew_factor);
     EEPROM_WRITE(planner.skew_factor);
 
-    //
-    // POLARGRAPH
-    //
-    #if ENABLED(POLARGRAPH)
-      _FIELD_TEST(polargraph_max_belt_len);
-      EEPROM_WRITE(polargraph_max_belt_len);
-    #endif
-
     //
     // Advanced Pause filament load & unload lengths
     //
@@ -1953,11 +1936,6 @@ void MarlinSettings::postprocess() {
           EEPROM_READ(delta_diagonal_rod);        // 1 float
           EEPROM_READ(delta_tower_angle_trim);    // 3 floats
           EEPROM_READ(delta_diagonal_rod_trim);   // 3 floats
-        #elif ENABLED(POLARGRAPH)
-          _FIELD_TEST(draw_area_min);
-          EEPROM_READ(draw_area_min);             // 2 floats
-          EEPROM_READ(draw_area_max);             // 2 floats
-          EEPROM_READ(polargraph_max_belt_len);   // 1 float
         #endif
       }
       #endif
@@ -3018,10 +2996,6 @@ void MarlinSettings::reset() {
       delta_diagonal_rod = DELTA_DIAGONAL_ROD;
       delta_tower_angle_trim = dta;
       delta_diagonal_rod_trim = ddr;
-    #elif ENABLED(POLARGRAPH)
-      draw_area_min.set(X_MIN_POS, Y_MIN_POS);
-      draw_area_max.set(X_MAX_POS, Y_MAX_POS);
-      polargraph_max_belt_len = POLARGRAPH_MAX_BELT_LEN;
     #endif
   #endif
 
@@ -3518,7 +3492,9 @@ void MarlinSettings::reset() {
     //
     // LCD Preheat Settings
     //
-    TERN_(HAS_PREHEAT, gcode.M145_report(forReplay));
+    #if HAS_PREHEAT
+      gcode.M145_report(forReplay);
+    #endif
 
     //
     // PID

Marlin/src/module/temperature.cpp

@@ -30,7 +30,6 @@
 #include "../MarlinCore.h"
 #include "../HAL/shared/Delay.h"
 #include "../lcd/marlinui.h"
-#include "../gcode/gcode.h"
 
 #include "temperature.h"
 #include "endstops.h"
@@ -64,6 +63,10 @@
   #include "../feature/host_actions.h"
 #endif
 
+#if EITHER(HAS_TEMP_SENSOR, LASER_FEATURE)
+  #include "../gcode/gcode.h"
+#endif
+
 #if ENABLED(NOZZLE_PARK_FEATURE)
   #include "../libs/nozzle.h"
 #endif
@@ -306,19 +309,19 @@ PGMSTR(str_t_heating_failed, STR_T_HEATING_FAILED);
 #endif
 
 #if EITHER(AUTO_POWER_E_FANS, HAS_FANCHECK)
-  uint8_t Temperature::autofan_speed[HOTENDS]; // = { 0 }
+  uint8_t Temperature::autofan_speed[HOTENDS] = ARRAY_N_1(HOTENDS, FAN_OFF_PWM);
 #endif
 
 #if ENABLED(AUTO_POWER_CHAMBER_FAN)
-  uint8_t Temperature::chamberfan_speed; // = 0
+  uint8_t Temperature::chamberfan_speed = FAN_OFF_PWM;
 #endif
 
 #if ENABLED(AUTO_POWER_COOLER_FAN)
-  uint8_t Temperature::coolerfan_speed; // = 0
+  uint8_t Temperature::coolerfan_speed = FAN_OFF_PWM;
 #endif
 
 #if BOTH(FAN_SOFT_PWM, USE_CONTROLLER_FAN)
-  uint8_t Temperature::soft_pwm_controller_speed;
+  uint8_t Temperature::soft_pwm_controller_speed = FAN_OFF_PWM;
 #endif
 
 // Init fans according to whether they're native PWM or Software PWM
@@ -342,11 +345,11 @@ PGMSTR(str_t_heating_failed, STR_T_HEATING_FAILED);
 // HAS_FAN does not include CONTROLLER_FAN
 #if HAS_FAN
 
-  uint8_t Temperature::fan_speed[FAN_COUNT]; // = { 0 }
+  uint8_t Temperature::fan_speed[FAN_COUNT] = ARRAY_N_1(FAN_COUNT, FAN_OFF_PWM);
 
   #if ENABLED(EXTRA_FAN_SPEED)
 
-    Temperature::extra_fan_t Temperature::extra_fan_speed[FAN_COUNT];
+    Temperature::extra_fan_t Temperature::extra_fan_speed[FAN_COUNT] = ARRAY_N_1(FAN_COUNT, FAN_OFF_PWM);
 
     /**
      * Handle the M106 P<fan> T<speed> command:
@@ -373,7 +376,7 @@ PGMSTR(str_t_heating_failed, STR_T_HEATING_FAILED);
 
   #if EITHER(PROBING_FANS_OFF, ADVANCED_PAUSE_FANS_PAUSE)
     bool Temperature::fans_paused; // = false;
-    uint8_t Temperature::saved_fan_speed[FAN_COUNT]; // = { 0 }
+    uint8_t Temperature::saved_fan_speed[FAN_COUNT] = ARRAY_N_1(FAN_COUNT, FAN_OFF_PWM);
   #endif
 
   #if ENABLED(ADAPTIVE_FAN_SLOWING)

Marlin/src/module/tool_change.cpp

@@ -917,7 +917,7 @@ void fast_line_to_current(const AxisEnum fr_axis) { _line_to_current(fr_axis, 0.
     #if HAS_FAN && TOOLCHANGE_FS_FAN >= 0
       thermalManager.fan_speed[TOOLCHANGE_FS_FAN] = toolchange_settings.fan_speed;
       gcode.dwell(SEC_TO_MS(toolchange_settings.fan_time));
-      thermalManager.fan_speed[TOOLCHANGE_FS_FAN] = 0;
+      thermalManager.fan_speed[TOOLCHANGE_FS_FAN] = FAN_OFF_PWM;
     #endif
   }
 

Marlin/src/pins/linux/pins_RAMPS_LINUX.h

@@ -396,8 +396,8 @@
 
   #define SD_DETECT_PIN                       41
 
-  #define SPI_FLASH
+  #define HAS_SPI_FLASH                        1
-  #if ENABLED(SPI_FLASH)
+  #if HAS_SPI_FLASH
     #define SPI_DEVICE                         1
     #define SPI_FLASH_SIZE             0x1000000  // 16MB
     #define SPI_FLASH_CS_PIN                  31
@@ -450,19 +450,6 @@
       #ifndef TOUCH_OFFSET_Y
         #define TOUCH_OFFSET_Y                 1
       #endif
-    #elif ENABLED(TFT_RES_1024x600)
-      #ifndef TOUCH_CALIBRATION_X
-        #define TOUCH_CALIBRATION_X        65533
-      #endif
-      #ifndef TOUCH_CALIBRATION_Y
-        #define TOUCH_CALIBRATION_Y        38399
-      #endif
-      #ifndef TOUCH_OFFSET_X
-        #define TOUCH_OFFSET_X                 2
-      #endif
-      #ifndef TOUCH_OFFSET_Y
-        #define TOUCH_OFFSET_Y                 1
-      #endif
     #endif
   #endif
 

Marlin/src/pins/mega/pins_EINSTART-S.h

@@ -101,9 +101,9 @@
 // LCD Display input pins
 //
 #define BTN_UP                                25
-#define BTN_DOWN                              26
+#define BTN_DWN                               26
-#define BTN_LEFT                              27
+#define BTN_LFT                               27
-#define BTN_RIGHT                             28
+#define BTN_RT                                28
 
 // 'OK' button
 #define BTN_ENC                               29

Marlin/src/pins/mega/pins_MIGHTYBOARD_REVE.h

@@ -203,13 +203,14 @@
 
     #define BTN_EN2                           75  // J4, UP
     #define BTN_EN1                           73  // J3, DOWN
-    // STOP button connected as KILL_PIN
+    //STOP button connected as KILL_PIN
-    #define KILL_PIN                          14  // J1, RIGHT (not connected)
+    #define KILL_PIN                          14  // J1, RIGHT
+    //KILL - not connected
 
     #define BEEPER_PIN                         8  // H5, SD_WP
 
-    // Onboard leds
+    //on board leds
-    #define STAT_LED_RED_PIN          SERVO0_PIN  // C1 (1280-EX1, DEBUG2)
+    #define STAT_LED_RED_LED          SERVO0_PIN  // C1 (1280-EX1, DEBUG2)
     #define STAT_LED_BLUE_PIN         SERVO1_PIN  // C0 (1280-EX2, DEBUG3)
 
   #else
@@ -219,9 +220,9 @@
     #define SR_STROBE_PIN                     33  // C4
 
     #define BTN_UP                            75  // J4
-    #define BTN_DOWN                          73  // J3
+    #define BTN_DWN                           73  // J3
-    #define BTN_LEFT                          72  // J2
+    #define BTN_LFT                           72  // J2
-    #define BTN_RIGHT                         14  // J1
+    #define BTN_RT                            14  // J1
 
     // Disable encoder
     #undef BTN_EN1

Marlin/src/pins/mega/pins_OVERLORD.h

@@ -135,7 +135,7 @@
 #if IS_NEWPANEL
   #define BTN_ENC                             16  // Enter Pin
   #define BTN_UP                              19  // Button UP Pin
-  #define BTN_DOWN                            17  // Button DOWN Pin
+  #define BTN_DWN                             17  // Button DOWN Pin
 #endif
 
 // Additional connectors/pins on the Overlord V1.X board

Marlin/src/pins/pins.h

@@ -711,8 +711,6 @@
   #include "stm32f4/pins_FYSETC_SPIDER_KING407.h" // STM32F4                              env:FYSETC_SPIDER_KING407
 #elif MB(MKS_SKIPR_V1)
   #include "stm32f4/pins_MKS_SKIPR_V1_0.h"      // STM32F4                                env:mks_skipr_v1 env:mks_skipr_v1_nobootloader
-#elif MB(TRONXY_V10)
-  #include "stm32f4/pins_TRONXY_V10.h"          // STM32F4                                env:STM32F446_tronxy
 
 //
 // ARM Cortex M7

Marlin/src/pins/pinsDebug.h

@@ -45,23 +45,23 @@
 #define REPORT_NAME_ANALOG(COUNTER, NAME) _ADD_PIN(#NAME, COUNTER)
 
 #include "pinsDebug_list.h"
-#line 49
+#line 48
 
 // manually add pins that have names that are macros which don't play well with these macros
 #if ANY(AVR_ATmega2560_FAMILY, AVR_ATmega1284_FAMILY, ARDUINO_ARCH_SAM, TARGET_LPC1768)
-  #if SERIAL_IN_USE(0)
+  #if CONF_SERIAL_IS(0)
     static const char RXD_NAME_0[] PROGMEM = { "RXD0" };
     static const char TXD_NAME_0[] PROGMEM = { "TXD0" };
   #endif
-  #if SERIAL_IN_USE(1)
+  #if CONF_SERIAL_IS(1)
     static const char RXD_NAME_1[] PROGMEM = { "RXD1" };
     static const char TXD_NAME_1[] PROGMEM = { "TXD1" };
   #endif
-  #if SERIAL_IN_USE(2)
+  #if CONF_SERIAL_IS(2)
     static const char RXD_NAME_2[] PROGMEM = { "RXD2" };
     static const char TXD_NAME_2[] PROGMEM = { "TXD2" };
   #endif
-  #if SERIAL_IN_USE(3)
+  #if CONF_SERIAL_IS(3)
     static const char RXD_NAME_3[] PROGMEM = { "RXD3" };
     static const char TXD_NAME_3[] PROGMEM = { "TXD3" };
   #endif
@@ -99,7 +99,7 @@ const PinInfo pin_array[] PROGMEM = {
    *     2 bytes containing the digital/analog bool flag
    */
 
-  #if SERIAL_IN_USE(0)
+  #if CONF_SERIAL_IS(0)
     #if EITHER(AVR_ATmega2560_FAMILY, ARDUINO_ARCH_SAM)
       { RXD_NAME_0, 0, true },
       { TXD_NAME_0, 1, true },
@@ -112,7 +112,7 @@ const PinInfo pin_array[] PROGMEM = {
     #endif
   #endif
 
-  #if SERIAL_IN_USE(1)
+  #if CONF_SERIAL_IS(1)
     #if EITHER(AVR_ATmega2560_FAMILY, ARDUINO_ARCH_SAM)
       { RXD_NAME_1, 19, true },
       { TXD_NAME_1, 18, true },
@@ -130,7 +130,7 @@ const PinInfo pin_array[] PROGMEM = {
     #endif
   #endif
 
-  #if SERIAL_IN_USE(2)
+  #if CONF_SERIAL_IS(2)
     #if EITHER(AVR_ATmega2560_FAMILY, ARDUINO_ARCH_SAM)
       { RXD_NAME_2, 17, true },
       { TXD_NAME_2, 16, true },
@@ -145,7 +145,7 @@ const PinInfo pin_array[] PROGMEM = {
     #endif
   #endif
 
-  #if SERIAL_IN_USE(3)
+  #if CONF_SERIAL_IS(3)
     #if EITHER(AVR_ATmega2560_FAMILY, ARDUINO_ARCH_SAM)
       { RXD_NAME_3, 15, true },
       { TXD_NAME_3, 14, true },
@@ -164,7 +164,7 @@ const PinInfo pin_array[] PROGMEM = {
   #endif
 
   #include "pinsDebug_list.h"
-  #line 168
+  #line 167
 
 };
 

Marlin/src/pins/ramps/pins_RIGIDBOARD.h

@@ -103,9 +103,9 @@
 
   // Direction buttons
   #define BTN_UP                              37
-  #define BTN_DOWN                            35
+  #define BTN_DWN                             35
-  #define BTN_LEFT                            33
+  #define BTN_LFT                             33
-  #define BTN_RIGHT                           32
+  #define BTN_RT                              32
 
   // 'R' button
   #undef BTN_ENC

Marlin/src/pins/ramps/pins_ULTIMAIN_2.h

@@ -107,8 +107,8 @@
 #define SDSS                                  53
 #define SD_DETECT_PIN                         39
 #define LED_PIN                                8
-//#define SAFETY_TRIGGERED_PIN                28  // PIN to detect the safety circuit has triggered
+#define SAFETY_TRIGGERED_PIN                  28  // PIN to detect the safety circuit has triggered
-//#define MAIN_VOLTAGE_MEASURE_PIN            14  // ANALOG PIN to measure the main voltage, with a 100k - 4k7 resitor divider.
+#define MAIN_VOLTAGE_MEASURE_PIN              14  // ANALOG PIN to measure the main voltage, with a 100k - 4k7 resitor divider.
 
 //
 // LCD / Controller

Marlin/src/pins/ramps/pins_ZRIB_V20.h

@@ -28,20 +28,31 @@
 
 #include "pins_MKS_GEN_13.h" // ... RAMPS
 
+#define ZRIB_V20_D6_PIN                        6  // Fan
+#define ZRIB_V20_D9_PIN                        9  // Fan2
+#define ZRIB_V20_A10_PIN                      10
+#define ZRIB_V20_D16_PIN                      16
+#define ZRIB_V20_D17_PIN                      17
+#define ZRIB_V20_D23_PIN                      23
+#define ZRIB_V20_D25_PIN                      25
+#define ZRIB_V20_D27_PIN                      27
+#define ZRIB_V20_D29_PIN                      29
+#define ZRIB_V20_D37_PIN                      37
+
 //
 // Auto fans
 //
 #ifndef E0_AUTO_FAN_PIN
-  #define E0_AUTO_FAN_PIN                      6  // Fan
+  #define E0_AUTO_FAN_PIN        ZRIB_V20_D6_PIN
 #endif
 #ifndef E1_AUTO_FAN_PIN
-  #define E1_AUTO_FAN_PIN                      6
+  #define E1_AUTO_FAN_PIN        ZRIB_V20_D6_PIN
 #endif
 #ifndef E2_AUTO_FAN_PIN
-  #define E2_AUTO_FAN_PIN                      6
+  #define E2_AUTO_FAN_PIN        ZRIB_V20_D6_PIN
 #endif
 #ifndef E3_AUTO_FAN_PIN
-  #define E3_AUTO_FAN_PIN                      6
+  #define E3_AUTO_FAN_PIN        ZRIB_V20_D6_PIN
 #endif
 
 #ifndef FILWIDTH_PIN
@@ -65,12 +76,12 @@
   #undef BTN_EN2
   #undef BTN_ENC
 
-  #define LCD_PINS_RS                         16
+  #define LCD_PINS_RS           ZRIB_V20_D16_PIN
-  #define LCD_PINS_ENABLE                     17
+  #define LCD_PINS_ENABLE       ZRIB_V20_D17_PIN
-  #define LCD_PINS_D4                         23
+  #define LCD_PINS_D4           ZRIB_V20_D23_PIN
-  #define LCD_PINS_D5                         25
+  #define LCD_PINS_D5           ZRIB_V20_D25_PIN
-  #define LCD_PINS_D6                         27
+  #define LCD_PINS_D6           ZRIB_V20_D27_PIN
-  #define LCD_PINS_D7                         29
+  #define LCD_PINS_D7           ZRIB_V20_D29_PIN
-  #define ADC_KEYPAD_PIN                      10  // Analog Input
+  #define ADC_KEYPAD_PIN        ZRIB_V20_A10_PIN
-  #define BEEPER_PIN                          37
+  #define BEEPER_PIN            ZRIB_V20_D37_PIN
 #endif

Marlin/src/pins/stm32f1/pins_CHITU3D_common.h

@@ -114,8 +114,8 @@
 #endif
 
 // SPI Flash
-#define SPI_FLASH
+#define HAS_SPI_FLASH                          1
-#if ENABLED(SPI_FLASH)
+#if HAS_SPI_FLASH
   #define SPI_FLASH_SIZE                0x200000  // 2MB
 #endif
 

Marlin/src/pins/stm32f1/pins_FLSUN_HISPEED.h

@@ -68,8 +68,8 @@
 #define SPI_DEVICE                             2
 
 // SPI Flash
-#define SPI_FLASH
+#define HAS_SPI_FLASH                          1
-#if ENABLED(SPI_FLASH)
+#if HAS_SPI_FLASH
   // SPI 2
   #define SPI_FLASH_CS_PIN                  PB12  // SPI2_NSS / Flash chip-select
   #define SPI_FLASH_MOSI_PIN                PB15

Marlin/src/pins/stm32f1/pins_LONGER3D_LK.h

@@ -183,7 +183,7 @@
 //
 #if NO_EEPROM_SELECTED
   //#define SPI_EEPROM
-  //#define SPI_FLASH                             // need MARLIN_DEV_MODE for M993/M994 EEPROM backup tests
+  //#define HAS_SPI_FLASH                      1  // need MARLIN_DEV_MODE for M993/M994 eeprom backup tests
   #define FLASH_EEPROM_EMULATION
 #endif
 
@@ -196,7 +196,7 @@
   #define EEPROM_MOSI_PIN    BOARD_SPI1_MOSI_PIN  // PA7 pin 32
   #define EEPROM_PAGE_SIZE               0x1000U  // 4K (from datasheet)
   #define MARLIN_EEPROM_SIZE 16UL * (EEPROM_PAGE_SIZE)   // Limit to 64K for now...
-#elif ENABLED(SPI_FLASH)
+#elif HAS_SPI_FLASH
   #define SPI_FLASH_SIZE                0x40000U  // limit to 256K (M993 will reboot with 512)
   #define SPI_FLASH_CS_PIN                  PC5
   #define SPI_FLASH_MOSI_PIN                PA7

Marlin/src/pins/stm32f1/pins_MKS_ROBIN.h

@@ -272,8 +272,8 @@
 //
 // W25Q64 64Mb (8MB) SPI flash
 //
-#define SPI_FLASH
+#define HAS_SPI_FLASH                          1
-#if ENABLED(SPI_FLASH)
+#if HAS_SPI_FLASH
   #define SPI_FLASH_SIZE                0x800000  // 8MB
   #define SPI_FLASH_CS_PIN                  PG9
   #define SPI_FLASH_MOSI_PIN                PB15

Marlin/src/pins/stm32f1/pins_MKS_ROBIN_E3P.h

@@ -377,8 +377,8 @@
 
 #endif // HAS_WIRED_LCD && !HAS_SPI_TFT
 
-#define SPI_FLASH
+#define HAS_SPI_FLASH                          1
-#if ENABLED(SPI_FLASH)
+#if HAS_SPI_FLASH
   #define SPI_FLASH_SIZE               0x1000000  // 16MB
   #define SPI_FLASH_CS_PIN                  PB12
   #define SPI_FLASH_MOSI_PIN                PB15

Marlin/src/pins/stm32f1/pins_MKS_ROBIN_MINI.h

@@ -196,8 +196,8 @@
   #endif
 #endif
 
-#define SPI_FLASH
+#define HAS_SPI_FLASH                          1
-#if ENABLED(SPI_FLASH)
+#if HAS_SPI_FLASH
   #define SPI_FLASH_SIZE               0x1000000  // 16MB
   #define SPI_FLASH_CS_PIN                  PB12  // Flash chip-select
   #define SPI_FLASH_MOSI_PIN                PB15

Marlin/src/pins/stm32f1/pins_MKS_ROBIN_NANO_V2.h

@@ -379,8 +379,8 @@
 
 #endif // HAS_WIRED_LCD && !HAS_SPI_TFT
 
-#define SPI_FLASH
+#define HAS_SPI_FLASH                          1
-#if ENABLED(SPI_FLASH)
+#if HAS_SPI_FLASH
   #define SPI_FLASH_SIZE               0x1000000  // 16MB
   #define SPI_FLASH_CS_PIN                  PB12
   #define SPI_FLASH_MOSI_PIN                PB15

Marlin/src/pins/stm32f1/pins_MKS_ROBIN_NANO_common.h

@@ -208,8 +208,8 @@
   #define TFT_BUFFER_SIZE                  14400
 #endif
 
-#define SPI_FLASH
+#define HAS_SPI_FLASH                          1
-#if ENABLED(SPI_FLASH)
+#if HAS_SPI_FLASH
   #define SPI_FLASH_SIZE               0x1000000  // 16MB
   #define SPI_FLASH_CS_PIN                  PB12
   #define SPI_FLASH_MOSI_PIN                PB15

Marlin/src/pins/stm32f1/pins_MKS_ROBIN_PRO.h

@@ -308,8 +308,8 @@
   #define BOARD_ST7920_DELAY_3               125
 #endif
 
-#define SPI_FLASH
+#define HAS_SPI_FLASH                          1
-#if ENABLED(SPI_FLASH)
+#if HAS_SPI_FLASH
   #define SPI_FLASH_SIZE               0x1000000  // 16MB
   #define SPI_FLASH_CS_PIN                  PB12  // Flash chip-select
   #define SPI_FLASH_MOSI_PIN                PB15

Marlin/src/pins/stm32f4/pins_BTT_OCTOPUS_V1_common.h

@@ -28,7 +28,7 @@
 
 // Onboard I2C EEPROM
 #define I2C_EEPROM
-#define MARLIN_EEPROM_SIZE                0x1000  // 4K (AT24C32)
+#define MARLIN_EEPROM_SIZE                0x1000  // 4KB (AT24C32)
 #define I2C_SCL_PIN                         PB8
 #define I2C_SDA_PIN                         PB9
 

Marlin/src/pins/stm32f4/pins_BTT_SKR_MINI_E3_V3_0_1.h

@@ -49,7 +49,7 @@
   #define SOFT_I2C_EEPROM                         // Force the use of Software I2C
   #define I2C_SCL_PIN                       PB8
   #define I2C_SDA_PIN                       PB9
-  #define MARLIN_EEPROM_SIZE              0x1000  // 4K
+  #define MARLIN_EEPROM_SIZE              0x1000  // 4KB
 #endif
 
 //

Marlin/src/pins/stm32f4/pins_MKS_ROBIN_NANO_V3_common.h

@@ -225,7 +225,7 @@
 
 #define SPI_FLASH
 #if ENABLED(SPI_FLASH)
-  #define SPI_FLASH
+  #define HAS_SPI_FLASH                        1
   #define SPI_DEVICE                           2
   #define SPI_FLASH_SIZE               0x1000000
   #define SPI_FLASH_CS_PIN                  PB12

Marlin/src/pins/stm32f4/pins_MKS_ROBIN_PRO_V2.h

@@ -273,7 +273,7 @@
 //
 // LCD / Controller
 #define SPI_FLASH
-#define SPI_FLASH
+#define HAS_SPI_FLASH                          1
 #define SPI_DEVICE                             2
 #define SPI_FLASH_SIZE                 0x1000000
 #if ENABLED(SPI_FLASH)

Marlin/src/pins/stm32f4/pins_MKS_SKIPR_V1_0.h

@@ -35,7 +35,7 @@
 
 // Onboard I2C EEPROM
 #define I2C_EEPROM
-#define MARLIN_EEPROM_SIZE                0x1000  // 4K (AT24C32)
+#define MARLIN_EEPROM_SIZE                0x1000  // 4KB (AT24C32)
 #define I2C_SCL_PIN                         PB8
 #define I2C_SDA_PIN                         PB9
 

Marlin/src/pins/stm32f4/pins_TH3D_EZBOARD_V2.h

@@ -24,10 +24,6 @@
 #define ALLOW_STM32DUINO
 #include "env_validate.h"
 
-#if HOTENDS > 1 || E_STEPPERS > 1
-  #error "TH3D EZBoard only supports 1 hotend / E stepper."
-#endif
-
 #define BOARD_INFO_NAME   "TH3D EZBoard V2"
 #define BOARD_WEBSITE_URL "th3dstudio.com"
 

Marlin/src/pins/stm32f4/pins_TRONXY_V10.h

@@ -1,266 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2022 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-#include "env_validate.h"
-
-#if HOTENDS > 3 || E_STEPPERS > 3
-  #error "Tronxy V10 supports up to 3 hotends / E steppers."
-#endif
-
-#define BOARD_INFO_NAME      "Tronxy V10"
-#define DEFAULT_MACHINE_NAME BOARD_INFO_NAME
-
-#define STEP_TIMER                             6
-#define TEMP_TIMER                            14
-
-//
-// Servos
-//
-//#define SERVO0_PIN                        PB10
-
-//
-// EEPROM
-//
-#if NO_EEPROM_SELECTED
-  #undef NO_EEPROM_SELECTED
-  #if TRONXY_UI > 0
-    #define EEPROM_AT24CXX
-  #else
-    #define FLASH_EEPROM_EMULATION
-  #endif
-#endif
-
-#if ENABLED(FLASH_EEPROM_EMULATION)
-  // SoC Flash (framework-arduinoststm32-maple/STM32F1/libraries/EEPROM/EEPROM.h)
-  #define EEPROM_START_ADDRESS (0x8000000UL + (512 * 1024) - 2 * EEPROM_PAGE_SIZE)
-  #define EEPROM_PAGE_SIZE     (0x800U)           // 2KB, but will use 2x more (4KB)
-  #define MARLIN_EEPROM_SIZE    EEPROM_PAGE_SIZE
-#else
-  #if ENABLED(EEPROM_AT24CXX)
-    #define AT24CXX_SCL                     PB8
-    #define AT24CXX_SDA                     PB9
-    #define AT24CXX_WP                      PB7
-  #else
-    #define I2C_EEPROM                            // AT24C32
-  #endif
-  #define MARLIN_EEPROM_SIZE              0x1000  // 4K
-#endif
-
-//
-// SPI Flash
-//
-//#define SPI_FLASH
-#if ENABLED(SPI_FLASH)
-  #define SPI_FLASH_SIZE                0x200000  // 2MB
-  #define W25QXX_CS_PIN                     PG15  // SPI2
-  #define W25QXX_MOSI_PIN                   PB5
-  #define W25QXX_MISO_PIN                   PB4
-  #define W25QXX_SCK_PIN                    PB3
-#endif
-
-//
-// Limit Switches
-//
-#define X_MIN_PIN                           PC15
-#define X_MAX_PIN                           PB0
-#define Y_STOP_PIN                          PC14
-
-#ifndef Z_MIN_PROBE_PIN
-  #define Z_MIN_PROBE_PIN                   PE3
-#endif
-
-#if ENABLED(DUAL_Z_ENDSTOP_PROBE)
-  #if NUM_Z_STEPPERS > 1 && Z_HOME_TO_MAX         // Swap Z1/Z2 for dual Z with max homing
-    #define Z_MIN_PIN                       PF11
-    #define Z_MAX_PIN                       PC13
-  #else
-    #define Z_MIN_PIN                       PC13
-    #define Z_MAX_PIN                       PF11
-  #endif
-#else
-  #ifndef Z_STOP_PIN
-    #define Z_STOP_PIN                      PC13
-  #endif
-#endif
-//
-// Filament Sensors
-//
-#ifndef FIL_RUNOUT_PIN
-  #define FIL_RUNOUT_PIN                    PE6   // MT_DET
-#endif
-#ifndef FIL_RUNOUT2_PIN
-  #define FIL_RUNOUT2_PIN                   PF12
-#endif
-
-//
-// Steppers
-//
-#define X_ENABLE_PIN                        PF0
-#define X_STEP_PIN                          PE5
-#define X_DIR_PIN                           PF1
-
-#define Y_ENABLE_PIN                        PF5
-#define Y_STEP_PIN                          PF9
-#define Y_DIR_PIN                           PF3
-
-#define Z_ENABLE_PIN                        PA5
-#define Z_STEP_PIN                          PA6
-#define Z_DIR_PIN                           PF15
-
-#define E0_ENABLE_PIN                       PF14
-#define E0_STEP_PIN                         PB1
-#define E0_DIR_PIN                          PF13
-
-#define E1_ENABLE_PIN                       PG5
-#define E1_STEP_PIN                         PD12
-#define E1_DIR_PIN                          PG4
-
-#define E2_ENABLE_PIN                       PF7
-#define E2_STEP_PIN                         PF6
-#define E2_DIR_PIN                          PF4
-
-//
-// Temperature Sensors
-//
-#define TEMP_0_PIN                          PC3   // TH1
-#define TEMP_BED_PIN                        PC2   // TB1
-
-//
-// Heaters / Fans
-//
-#define HEATER_0_PIN                        PG7   // HEATER1
-#define HEATER_BED_PIN                      PE2   // HOT BED
-//#define HEATER_BED_INVERTING              true
-
-#define FAN_PIN                             PG0   // FAN0
-#define FAN1_PIN                            PB6   // FAN1
-#define FAN2_PIN                            PG9   // FAN2
-#define FAN3_PIN                            PF10  // FAN3
-#define CONTROLLER_FAN_PIN                  PD7   // BOARD FAN
-#define FAN_SOFT_PWM
-
-//
-// Laser / Spindle
-//
-#if HAS_CUTTER
-  #define SPINDLE_LASER_ENA_PIN             PB11  // wifi:TX
-  #if ENABLED(SPINDLE_LASER_USE_PWM)
-    #define SPINDLE_LASER_PWM_PIN           PB10  // wifi:RX-TIM2_CH3
-    // The PWM pin definition const PinMap PinMap_PWM[] in PeripheralPins.c must be compounded here
-    // See PWM_PIN(x) definition for details
-  #endif
-#endif
-
-//
-// Misc
-//
-#define BEEPER_PIN                          PA8
-
-//#define LED_PIN                           PG10
-#define PS_ON_PIN                           PG10  // Temporarily switch the machine with LED simulation
-
-#if ENABLED(TRONXY_BACKUP_POWER)
-  #define POWER_LOSS_PIN                    PF11  // Configure as drop-down input
-#else
-  #define POWER_LOSS_PIN                    PE1   // Output of LM393 comparator, configured as pullup
-#endif
-//#define POWER_LM393_PIN                   PE0   // +V for the LM393 comparator, configured as output high
-
-#if ENABLED(TFT_TRONXY_X5SA)
-  #error "TFT_TRONXY_X5SA is not yet supported."
-#endif
-
-#if 0
-
-//
-// TFT with FSMC interface
-//
-#if HAS_FSMC_TFT
-  #define TFT_RESET_PIN                     PB12
-  #define TFT_BACKLIGHT_PIN                 PG8
-
-  #define LCD_USE_DMA_FSMC                        // Use DMA transfers to send data to the TFT
-  #define FSMC_DMA_DEV                      DMA2
-  #define FSMC_DMA_CHANNEL               DMA_CH5
-
-  #define TFT_CS_PIN                        PG12
-  #define TFT_RS_PIN                        PG2
-
-  //#define TFT_WIDTH                        480
-  //#define TFT_HEIGHT                       320
-  //#define TFT_PIXEL_OFFSET_X                48
-  //#define TFT_PIXEL_OFFSET_Y                32
-  //#define TFT_DRIVER                   ILI9488
-  //#define TFT_BUFFER_SIZE                14400
-
-  #if NEED_TOUCH_PINS
-    #define TOUCH_CS_PIN                    PD11  // SPI1_NSS
-    #define TOUCH_SCK_PIN                   PB13  // SPI1_SCK
-    #define TOUCH_MISO_PIN                  PB14  // SPI1_MISO
-    #define TOUCH_MOSI_PIN                  PB15  // SPI1_MOSI
-  #endif
-
-  #if (LCD_CHIP_INDEX == 1 && (TRONXY_UI == 1 || TRONXY_UI == 2)) || LCD_CHIP_INDEX == 3
-    #define TOUCH_CALIBRATION_X           -17181
-    #define TOUCH_CALIBRATION_Y            11434
-    #define TOUCH_OFFSET_X                   501
-    #define TOUCH_OFFSET_Y                    -9
-  #elif LCD_CHIP_INDEX == 1 && TRONXY_UI == 4
-    #define TOUCH_CALIBRATION_X            11166
-    #define TOUCH_CALIBRATION_Y            17162
-    #define TOUCH_OFFSET_X                   -10
-    #define TOUCH_OFFSET_Y                   -16
-  #elif LCD_CHIP_INDEX == 4 && TRONXY_UI == 3
-    //#define TOUCH_CALIBRATION_X           8781
-    //#define TOUCH_CALIBRATION_Y          11773
-    //#define TOUCH_OFFSET_X                 -17
-    //#define TOUCH_OFFSET_Y                 -16
-    // Upside-down
-    #define TOUCH_CALIBRATION_X            -8553
-    #define TOUCH_CALIBRATION_Y           -11667
-    #define TOUCH_OFFSET_X                   253
-    #define TOUCH_OFFSET_Y                   331
-  #elif LCD_CHIP_INDEX == 2
-    #define TOUCH_CALIBRATION_X            17184
-    #define TOUCH_CALIBRATION_Y            10604
-    #define TOUCH_OFFSET_X                   -31
-    #define TOUCH_OFFSET_Y                   -29
-  #endif
-#endif
-
-#endif
-
-//
-// SD Card
-//
-#define SDIO_SUPPORT
-#define SD_DETECT_PIN                       -1    // PF0, but not connected
-#define SDIO_CLOCK                       4500000
-#define SDIO_READ_RETRIES                     16
-
-#define SDIO_D0_PIN                         PC8
-#define SDIO_D1_PIN                         PC9
-#define SDIO_D2_PIN                         PC10
-#define SDIO_D3_PIN                         PC11
-#define SDIO_CK_PIN                         PC12
-#define SDIO_CMD_PIN                        PD2

Marlin/src/pins/stm32h7/pins_BTT_SKR_V3_0_common.h

@@ -46,7 +46,7 @@
   #define SOFT_I2C_EEPROM                         // Force the use of Software I2C
   #define I2C_SCL_PIN                       PA14
   #define I2C_SDA_PIN                       PA13
-  #define MARLIN_EEPROM_SIZE              0x1000  // 4K
+  #define MARLIN_EEPROM_SIZE              0x1000  // 4KB
 #endif
 
 //

buildroot/share/PlatformIO/boards/marlin_STM32F446ZET_tronxy.json

@@ -1,35 +0,0 @@
-{
-  "build": {
-    "cpu": "cortex-m4",
-    "extra_flags": "-DSTM32F446xx",
-    "f_cpu": "180000000L",
-    "mcu": "stm32f446zet6",
-    "variant": "MARLIN_F446Zx_TRONXY"
-  },
-  "connectivity": [
-    "can"
-  ],
-  "debug": {
-    "jlink_device": "STM32F446ZE",
-    "openocd_target": "stm32f4x",
-    "svd_path": "STM32F446x.svd"
-  },
-  "frameworks": [
-    "arduino",
-    "stm32cube"
-  ],
-  "name": "STM32F446ZE (128k RAM. 512k Flash)",
-  "upload": {
-    "maximum_ram_size": 131072,
-    "maximum_size": 524288,
-    "protocol": "stlink",
-    "protocols": [
-      "jlink",
-      "stlink",
-      "blackmagic",
-      "serial"
-    ]
-  },
-  "url": "https://www.st.com/en/microcontrollers-microprocessors/stm32f446.html",
-  "vendor": "Generic"
-}

buildroot/share/PlatformIO/scripts/STM32F103RC_MEEB_3DP.py

@@ -4,16 +4,16 @@
 import pioutil
 if pioutil.is_pio_build():
 
-    Import("env", "projenv")
+	Import("env", "projenv")
 
-    flash_size = 0
+	flash_size = 0
-    vect_tab_addr = 0
+	vect_tab_addr = 0
 
-    for define in env['CPPDEFINES']:
+	for define in env['CPPDEFINES']:
-        if define[0] == "VECT_TAB_ADDR":
+		if define[0] == "VECT_TAB_ADDR":
-            vect_tab_addr = define[1]
+			vect_tab_addr = define[1]
-        if define[0] == "STM32_FLASH_SIZE":
+		if define[0] == "STM32_FLASH_SIZE":
-            flash_size = define[1]
+			flash_size = define[1]
 
-    print('Use the {0:s} address as the marlin app entry point.'.format(vect_tab_addr))
+	print('Use the {0:s} address as the marlin app entry point.'.format(vect_tab_addr))
-    print('Use the {0:d}KB flash version of stm32f103rct6 chip.'.format(flash_size))
+	print('Use the {0:d}KB flash version of stm32f103rct6 chip.'.format(flash_size))

buildroot/share/PlatformIO/scripts/STM32F103RC_fysetc.py

@@ -3,25 +3,25 @@
 #
 import pioutil
 if pioutil.is_pio_build():
-    from os.path import join
+	from os.path import join
-    from os.path import expandvars
+	from os.path import expandvars
-    Import("env")
+	Import("env")
 
-    # Custom HEX from ELF
+	# Custom HEX from ELF
-    env.AddPostAction(
+	env.AddPostAction(
-        join("$BUILD_DIR", "${PROGNAME}.elf"),
+		join("$BUILD_DIR", "${PROGNAME}.elf"),
-        env.VerboseAction(" ".join([
+		env.VerboseAction(" ".join([
-            "$OBJCOPY", "-O ihex", "$TARGET",
+			"$OBJCOPY", "-O ihex", "$TARGET",
-            "\"" + join("$BUILD_DIR", "${PROGNAME}.hex") + "\"", # Note: $BUILD_DIR is a full path
+			"\"" + join("$BUILD_DIR", "${PROGNAME}.hex") + "\"", # Note: $BUILD_DIR is a full path
-        ]), "Building $TARGET"))
+		]), "Building $TARGET"))
 
-    # In-line command with arguments
+	# In-line command with arguments
-    UPLOAD_TOOL="stm32flash"
+	UPLOAD_TOOL="stm32flash"
-    platform = env.PioPlatform()
+	platform = env.PioPlatform()
-    if platform.get_package_dir("tool-stm32duino") != None:
+	if platform.get_package_dir("tool-stm32duino") != None:
-        UPLOAD_TOOL=expandvars("\"" + join(platform.get_package_dir("tool-stm32duino"),"stm32flash","stm32flash") + "\"")
+		UPLOAD_TOOL=expandvars("\"" + join(platform.get_package_dir("tool-stm32duino"),"stm32flash","stm32flash") + "\"")
 
-    env.Replace(
+	env.Replace(
-        UPLOADER=UPLOAD_TOOL,
+		UPLOADER=UPLOAD_TOOL,
-        UPLOADCMD=expandvars(UPLOAD_TOOL + " -v -i rts,-dtr,dtr -R -b 115200 -g 0x8000000 -w \"" + join("$BUILD_DIR","${PROGNAME}.hex")+"\"" + " $UPLOAD_PORT")
+		UPLOADCMD=expandvars(UPLOAD_TOOL + " -v -i rts,-dtr,dtr -R -b 115200 -g 0x8000000 -w \"" + join("$BUILD_DIR","${PROGNAME}.hex")+"\"" + " $UPLOAD_PORT")
-    )
+	)

buildroot/share/PlatformIO/scripts/STM32F1_create_variant.py

@@ -3,29 +3,29 @@
 #
 import pioutil
 if pioutil.is_pio_build():
-    import shutil,marlin
+	import shutil,marlin
-    from pathlib import Path
+	from pathlib import Path
 
-    Import("env")
+	Import("env")
-    platform = env.PioPlatform()
+	platform = env.PioPlatform()
-    board = env.BoardConfig()
+	board = env.BoardConfig()
 
-    FRAMEWORK_DIR = Path(platform.get_package_dir("framework-arduinoststm32-maple"))
+	FRAMEWORK_DIR = Path(platform.get_package_dir("framework-arduinoststm32-maple"))
-    assert FRAMEWORK_DIR.is_dir()
+	assert FRAMEWORK_DIR.is_dir()
 
-    source_root = Path("buildroot/share/PlatformIO/variants")
+	source_root = Path("buildroot/share/PlatformIO/variants")
-    assert source_root.is_dir()
+	assert source_root.is_dir()
 
-    variant = board.get("build.variant")
+	variant = board.get("build.variant")
-    variant_dir = FRAMEWORK_DIR / "STM32F1/variants" / variant
+	variant_dir = FRAMEWORK_DIR / "STM32F1/variants" / variant
 
-    source_dir = source_root / variant
+	source_dir = source_root / variant
-    assert source_dir.is_dir()
+	assert source_dir.is_dir()
 
-    if variant_dir.is_dir():
+	if variant_dir.is_dir():
-        shutil.rmtree(variant_dir)
+		shutil.rmtree(variant_dir)
 
-    if not variant_dir.is_dir():
+	if not variant_dir.is_dir():
-        variant_dir.mkdir()
+		variant_dir.mkdir()
 
-    marlin.copytree(source_dir, variant_dir)
+	marlin.copytree(source_dir, variant_dir)

buildroot/share/PlatformIO/variants/MARLIN_ARTILLERY_RUBY/hal_conf_custom.h

@@ -5,8 +5,8 @@
   ******************************************************************************
   * @attention
   *
-  * Copyright (c) 2017 STMicroelectronics.
+  * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics.
-  * All rights reserved.
+  * All rights reserved.</center></h2>
   *
   * This software component is licensed by ST under BSD 3-Clause license,
   * the "License"; You may not use this file except in compliance with the

buildroot/share/PlatformIO/variants/MARLIN_ARTILLERY_RUBY/ldscript.ld

@@ -20,7 +20,7 @@
 *****************************************************************************
 ** @attention
 **
-** Copyright (c) 2014 Ac6
+** <h2><center>&copy; COPYRIGHT(c) 2014 Ac6</center></h2>
 **
 ** Redistribution and use in source and binary forms, with or without modification,
 ** are permitted provided that the following conditions are met:

buildroot/share/PlatformIO/variants/MARLIN_ARTILLERY_RUBY/startup.S

@@ -16,7 +16,7 @@
   ******************************************************************************
   * @attention
   *
-  * Copyright (c) 2015 STMicroelectronics
+  * <h2><center>&copy; COPYRIGHT 2015 STMicroelectronics</center></h2>
   *
   * Redistribution and use in source and binary forms, with or without modification,
   * are permitted provided that the following conditions are met:

buildroot/share/PlatformIO/variants/MARLIN_BIGTREE_BTT002/ldscript.ld

@@ -21,7 +21,7 @@
 *****************************************************************************
 ** @attention
 **
-** Copyright (c) 2014 Ac6
+** <h2><center>&copy; COPYRIGHT(c) 2014 Ac6</center></h2>
 **
 ** Redistribution and use in source and binary forms, with or without modification,
 ** are permitted provided that the following conditions are met:

buildroot/share/PlatformIO/variants/MARLIN_BIGTREE_E3_RRF/ldscript.ld

@@ -21,7 +21,7 @@
 *****************************************************************************
 ** @attention
 **
-** Copyright (c) 2014 Ac6
+** <h2><center>&copy; COPYRIGHT(c) 2014 Ac6</center></h2>
 **
 ** Redistribution and use in source and binary forms, with or without modification,
 ** are permitted provided that the following conditions are met:

buildroot/share/PlatformIO/variants/MARLIN_BIGTREE_GTR_V1/ldscript.ld

@@ -21,7 +21,7 @@
 *****************************************************************************
 ** @attention
 **
-** Copyright (c) 2014 Ac6
+** <h2><center>&copy; COPYRIGHT(c) 2014 Ac6</center></h2>
 **
 ** Redistribution and use in source and binary forms, with or without modification,
 ** are permitted provided that the following conditions are met:

buildroot/share/PlatformIO/variants/MARLIN_BIGTREE_OCTOPUS_PRO_V1_F429/ldscript.ld

@@ -21,7 +21,7 @@
 *****************************************************************************
 ** @attention
 **
-** Copyright (c) 2014 Ac6
+** <h2><center>&copy; COPYRIGHT(c) 2014 Ac6</center></h2>
 **
 ** Redistribution and use in source and binary forms, with or without modification,
 ** are permitted provided that the following conditions are met:

buildroot/share/PlatformIO/variants/MARLIN_BIGTREE_OCTOPUS_V1/ldscript.ld

@@ -21,7 +21,7 @@
 *****************************************************************************
 ** @attention
 **
-** Copyright (c) 2014 Ac6
+** <h2><center>&copy; COPYRIGHT(c) 2014 Ac6</center></h2>
 **
 ** Redistribution and use in source and binary forms, with or without modification,
 ** are permitted provided that the following conditions are met:

buildroot/share/PlatformIO/variants/MARLIN_BIGTREE_SKR_PRO_11/ldscript.ld

@@ -21,7 +21,7 @@
 *****************************************************************************
 ** @attention
 **
-** Copyright (c) 2014 Ac6
+** <h2><center>&copy; COPYRIGHT(c) 2014 Ac6</center></h2>
 **
 ** Redistribution and use in source and binary forms, with or without modification,
 ** are permitted provided that the following conditions are met:

buildroot/share/PlatformIO/variants/MARLIN_BTT_SKR_SE_BX/hal_conf_extra.h

@@ -5,8 +5,8 @@
   ******************************************************************************
   * @attention
   *
-  * Copyright (c) 2017 STMicroelectronics.
+  * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics.
-  * All rights reserved.
+  * All rights reserved.</center></h2>
   *
   * This software component is licensed by ST under BSD 3-Clause license,
   * the "License"; You may not use this file except in compliance with the

buildroot/share/PlatformIO/variants/MARLIN_BTT_SKR_SE_BX/ldscript.ld

@@ -26,7 +26,7 @@
 *****************************************************************************
 ** @attention
 **
-** Copyright (c) 2019 STMicroelectronics
+** <h2><center>&copy; COPYRIGHT(c) 2019 STMicroelectronics</center></h2>
 **
 ** Redistribution and use in source and binary forms, with or without modification,
 ** are permitted provided that the following conditions are met:

buildroot/share/PlatformIO/variants/MARLIN_CREALITY_STM32F401RC/hal_conf_custom.h

@@ -5,8 +5,8 @@
   ******************************************************************************
   * @attention
   *
-  * Copyright (c) 2017 STMicroelectronics.
+  * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics.
-  * All rights reserved.
+  * All rights reserved.</center></h2>
   *
   * This software component is licensed by ST under BSD 3-Clause license,
   * the "License"; You may not use this file except in compliance with the

buildroot/share/PlatformIO/variants/MARLIN_CREALITY_STM32F401RC/ldscript.ld

@@ -21,7 +21,7 @@
 *****************************************************************************
 ** @attention
 **
-** Copyright (c) 2014 Ac6
+** <h2><center>&copy; COPYRIGHT(c) 2014 Ac6</center></h2>
 **
 ** Redistribution and use in source and binary forms, with or without modification,
 ** are permitted provided that the following conditions are met:
@@ -184,4 +184,4 @@ SECTIONS
   }
 
   .ARM.attributes 0 : { *(.ARM.attributes) }
-}
+}

buildroot/share/PlatformIO/variants/MARLIN_F103Rx/ldscript.ld

@@ -23,7 +23,7 @@
 *****************************************************************************
 ** @attention
 **
-** Copyright (c) 2019 STMicroelectronics
+** <h2><center>&copy; COPYRIGHT(c) 2019 STMicroelectronics</center></h2>
 **
 ** Redistribution and use in source and binary forms, with or without modification,
 ** are permitted provided that the following conditions are met:

buildroot/share/PlatformIO/variants/MARLIN_F103VE_LONGER/ldscript.ld

@@ -22,7 +22,7 @@
 *****************************************************************************
 ** @attention
 **
-** Copyright (c) 2019 STMicroelectronics
+** <h2><center>&copy; COPYRIGHT(c) 2019 STMicroelectronics</center></h2>
 **
 ** Redistribution and use in source and binary forms, with or without modification,
 ** are permitted provided that the following conditions are met:

buildroot/share/PlatformIO/variants/MARLIN_F103Vx/ldscript.ld

@@ -23,7 +23,7 @@
 *****************************************************************************
 ** @attention
 **
-** Copyright (c) 2019 STMicroelectronics
+** <h2><center>&copy; COPYRIGHT(c) 2019 STMicroelectronics</center></h2>
 **
 ** Redistribution and use in source and binary forms, with or without modification,
 ** are permitted provided that the following conditions are met:

buildroot/share/PlatformIO/variants/MARLIN_F103Zx/hal_conf_custom.h

@@ -5,8 +5,8 @@
   ******************************************************************************
   * @attention
   *
-  * Copyright (c) 2017 STMicroelectronics.
+  * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics.
-  * All rights reserved.
+  * All rights reserved.</center></h2>
   *
   * This software component is licensed by ST under BSD 3-Clause license,
   * the "License"; You may not use this file except in compliance with the

buildroot/share/PlatformIO/variants/MARLIN_F103Zx/ldscript.ld

@@ -23,7 +23,7 @@
 *****************************************************************************
 ** @attention
 **
-** Copyright (c) 2019 STMicroelectronics
+** <h2><center>&copy; COPYRIGHT(c) 2019 STMicroelectronics</center></h2>
 **
 ** Redistribution and use in source and binary forms, with or without modification,
 ** are permitted provided that the following conditions are met:

buildroot/share/PlatformIO/variants/MARLIN_F401RC/ldscript.ld

@@ -13,8 +13,8 @@
  ******************************************************************************
  * @attention
  *
- * Copyright (c) 2020 STMicroelectronics.
+ * <h2><center>&copy; Copyright (c) 2020 STMicroelectronics.
- * All rights reserved.
+ * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under BSD 3-Clause license,
  * the "License"; You may not use this file except in compliance with the

buildroot/share/PlatformIO/variants/MARLIN_F407VE/hal_conf_custom.h

@@ -5,8 +5,8 @@
   ******************************************************************************
   * @attention
   *
-  * Copyright (c) 2017 STMicroelectronics.
+  * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics.
-  * All rights reserved.
+  * All rights reserved.</center></h2>
   *
   * This software component is licensed by ST under BSD 3-Clause license,
   * the "License"; You may not use this file except in compliance with the

buildroot/share/PlatformIO/variants/MARLIN_F407VE/ldscript.ld

@@ -21,7 +21,7 @@
 *****************************************************************************
 ** @attention
 **
-** Copyright (c) 2014 Ac6
+** <h2><center>&copy; COPYRIGHT(c) 2014 Ac6</center></h2>
 **
 ** Redistribution and use in source and binary forms, with or without modification,
 ** are permitted provided that the following conditions are met: