Tweak probe preheat to wait for cooldown, bypass block on unload prime

Merge branch 'bugfix-2.0.x' into CR-6Devel
Update probe.cpp
2021-02-14 14:13:41 -05:00 · 2021-02-14 12:06:14 -05:00 · 2021-02-10 14:20:41 -05:00 · 2021-02-10 07:03:48 -05:00 · 2021-02-08 11:16:20 -05:00 · 2021-02-06 12:58:31 -05:00
1431 changed files with 29092 additions and 50578 deletions
@@ -4,10 +4,10 @@ root = true
 [{*.patch,syntax_test_*}]
 trim_trailing_whitespace = false

-[{*.c,*.cpp,*.h,*.ino}]
+[{*.c,*.cpp,*.h}]
 charset = utf-8

-[{*.c,*.cpp,*.h,*.ino,Makefile}]
+[{*.c,*.cpp,*.h,Makefile}]
 trim_trailing_whitespace = true
 insert_final_newline = true
 end_of_line = lf
@@ -72,7 +72,6 @@ jobs:

        # STM32 (ST) Environments

-        - STM32F103RC_btt_stm32
        - STM32F407VE_black
        - STM32F401VE_STEVAL
        - BIGTREE_BTT002
@@ -87,12 +86,9 @@ jobs:
        - FLYF407ZG
        - rumba32
        - LERDGEX
-        - LERDGEK
        - mks_robin_nano35_stm32
        - NUCLEO_F767ZI
        - REMRAM_V1
-        - BTT_SKR_SE_BX
-        - chitu_f103

        # Put lengthy tests last

@@ -102,7 +98,6 @@ jobs:
        # Non-working environment tests
        #- at90usb1286_cdc
        #- STM32F103CB_malyan
-        #- STM32F103RE
        #- mks_robin_mini

    steps:
@@ -122,6 +122,29 @@ tags
 .gcc-flags.json
 /lib/

+# Workaround for Deviot+platformio quirks
+Marlin/lib
+Marlin/platformio.ini
+Marlin/*/platformio.ini
+Marlin/*/*/platformio.ini
+Marlin/*/*/*/platformio.ini
+Marlin/*/*/*/*/platformio.ini
+Marlin/.travis.yml
+Marlin/*/.travis.yml
+Marlin/*/*/.travis.yml
+Marlin/*/*/*/.travis.yml
+Marlin/*/*/*/*/.travis.yml
+Marlin/.gitignore
+Marlin/*/.gitignore
+Marlin/*/*/.gitignore
+Marlin/*/*/*/.gitignore
+Marlin/*/*/*/*/.gitignore
+Marlin/readme.txt
+Marlin/*/readme.txt
+Marlin/*/*/readme.txt
+Marlin/*/*/*/readme.txt
+Marlin/*/*/*/*/readme.txt
+
 # Secure Credentials
 Configuration_Secure.h

@@ -219,7 +219,7 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1111)
 else ifeq ($(HARDWARE_MOTHERBOARD),1112)
 # MKS GEN L
 else ifeq ($(HARDWARE_MOTHERBOARD),1113)
-# zrib V2.0 control board (Chinese RAMPS replica)
+# zrib V2.0 control board (Chinese knock off RAMPS replica)
 else ifeq ($(HARDWARE_MOTHERBOARD),1114)
 # BigTreeTech or BIQU KFB2.0
 else ifeq ($(HARDWARE_MOTHERBOARD),1115)
@@ -323,8 +323,6 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1203)
 else ifeq ($(HARDWARE_MOTHERBOARD),1204)
 # abee Scoovo X9H
 else ifeq ($(HARDWARE_MOTHERBOARD),1205)
-# Rambo ThinkerV2
-else ifeq ($(HARDWARE_MOTHERBOARD),1206)

 #
 # Other ATmega1280, ATmega2560
@@ -993,5 +991,5 @@ clean:

 .PHONY: all build elf hex eep lss sym program coff extcoff clean depend sizebefore sizeafter

-# Automatically include the dependency files created by gcc
+# Automaticaly include the dependency files created by gcc
 -include ${patsubst %.o, %.d, ${OBJ}}
@@ -28,25 +28,25 @@
 /**
 * Marlin release version identifier
 */
-//#define SHORT_BUILD_VERSION "bugfix-2.0.x"
+#define SHORT_BUILD_VERSION "TM3D2.0.7.2-CR6-C"

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

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

 /**
 * Defines a generic printer name to be output to the LCD after booting Marlin.
 */
-//#define MACHINE_NAME "3D Printer"
+#define MACHINE_NAME "TM3D CR-6"

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

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

 /**
 * Set the vendor info the serial USB interface, if changable
@@ -25,7 +25,7 @@
 #include "HAL.h"

 #ifdef USBCON
-  DefaultSerial1 MSerial0(false, Serial);
+  DefaultSerial MSerial(false, Serial);
  #ifdef BLUETOOTH
    BTSerial btSerial(false, bluetoothSerial);
  #endif
@@ -58,15 +58,6 @@ void HAL_init() {
  #endif
 }

-void HAL_reboot() {
-  #if ENABLED(USE_WATCHDOG)
-    while (1) { /* run out the watchdog */ }
-  #else
-    void (*resetFunc)() = 0;  // Declare resetFunc() at address 0
-    resetFunc();              // Jump to address 0
-  #endif
-}
-
 #if ENABLED(SDSUPPORT)

  #include "../../sd/SdFatUtil.h"
@@ -83,48 +83,41 @@ typedef int8_t pin_t;
 // Serial ports
 #ifdef USBCON
  #include "../../core/serial_hook.h"
-  typedef ForwardSerial1Class< decltype(Serial) > DefaultSerial1;
-  extern DefaultSerial1 MSerial0;
+  typedef ForwardSerial0Type< decltype(Serial) > DefaultSerial;
+  extern DefaultSerial MSerial;
  #ifdef BLUETOOTH
-    typedef ForwardSerial1Class< decltype(bluetoothSerial) > BTSerial;
+    typedef ForwardSerial0Type< decltype(bluetoothSerial) > BTSerial;
    extern BTSerial btSerial;
  #endif

-  #define MYSERIAL1 TERN(BLUETOOTH, btSerial, MSerial0)
+  #define MYSERIAL0 TERN(BLUETOOTH, btSerial, MSerial)
 #else
  #if !WITHIN(SERIAL_PORT, -1, 3)
-    #error "SERIAL_PORT must be from 0 to 3, or -1 for USB Serial."
+    #error "SERIAL_PORT must be from -1 to 3. Please update your configuration."
  #endif
-  #define MYSERIAL1 customizedSerial1
+  #define MYSERIAL0 customizedSerial1

  #ifdef SERIAL_PORT_2
    #if !WITHIN(SERIAL_PORT_2, -1, 3)
-      #error "SERIAL_PORT_2 must be from 0 to 3, or -1 for USB Serial."
+      #error "SERIAL_PORT_2 must be from -1 to 3. Please update your configuration."
    #endif
-    #define MYSERIAL2 customizedSerial2
-  #endif
-
-  #ifdef SERIAL_PORT_3
-    #if !WITHIN(SERIAL_PORT_3, -1, 3)
-      #error "SERIAL_PORT_3 must be from 0 to 3, or -1 for USB Serial."
-    #endif
-    #define MYSERIAL3 customizedSerial3
+    #define MYSERIAL1 customizedSerial2
  #endif
 #endif

 #ifdef MMU2_SERIAL_PORT
  #if !WITHIN(MMU2_SERIAL_PORT, -1, 3)
-    #error "MMU2_SERIAL_PORT must be from 0 to 3, or -1 for USB Serial."
+    #error "MMU2_SERIAL_PORT must be from -1 to 3. Please update your configuration."
  #endif
  #define MMU2_SERIAL mmuSerial
 #endif

 #ifdef LCD_SERIAL_PORT
  #if !WITHIN(LCD_SERIAL_PORT, -1, 3)
-    #error "LCD_SERIAL_PORT must be from 0 to 3, or -1 for USB Serial."
+    #error "LCD_SERIAL_PORT must be from -1 to 3. Please update your configuration."
  #endif
  #define LCD_SERIAL lcdSerial
-  #if HAS_DGUS_LCD
+  #if HAS_DGUS_LCD || ENABLED(DGUS_LCD_UI_CREALITY_TOUCH)
    #define SERIAL_GET_TX_BUFFER_FREE() LCD_SERIAL.get_tx_buffer_free()
  #endif
 #endif
@@ -142,7 +135,7 @@ void HAL_init();
 inline void HAL_clear_reset_source() { MCUSR = 0; }
 inline uint8_t HAL_get_reset_source() { return MCUSR; }

-void HAL_reboot();
+inline void HAL_reboot() {}  // reboot the board or restart the bootloader

 #if GCC_VERSION <= 50000
  #pragma GCC diagnostic push
@@ -88,7 +88,7 @@ void spiBegin() {
  }

  /** SPI read data  */
-  void spiRead(uint8_t *buf, uint16_t nbyte) {
+  void spiRead(uint8_t* buf, uint16_t nbyte) {
    if (nbyte-- == 0) return;
    SPDR = 0xFF;
    for (uint16_t i = 0; i < nbyte; i++) {
@@ -107,7 +107,7 @@ void spiBegin() {
  }

  /** SPI send block  */
-  void spiSendBlock(uint8_t token, const uint8_t *buf) {
+  void spiSendBlock(uint8_t token, const uint8_t* buf) {
    SPDR = token;
    for (uint16_t i = 0; i < 512; i += 2) {
      while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
@@ -215,7 +215,7 @@ void spiBegin() {
  }

  // Soft SPI read data
-  void spiRead(uint8_t *buf, uint16_t nbyte) {
+  void spiRead(uint8_t* buf, uint16_t nbyte) {
    for (uint16_t i = 0; i < nbyte; i++)
      buf[i] = spiRec();
  }
@@ -242,7 +242,7 @@ void spiBegin() {
  }

  // Soft SPI send block
-  void spiSendBlock(uint8_t token, const uint8_t *buf) {
+  void spiSendBlock(uint8_t token, const uint8_t* buf) {
    spiSend(token);
    for (uint16_t i = 0; i < 512; i++)
      spiSend(buf[i]);
@@ -454,7 +454,7 @@ void MarlinSerial<Cfg>::flush() {
 }

 template<typename Cfg>
-void MarlinSerial<Cfg>::write(const uint8_t c) {
+size_t MarlinSerial<Cfg>::write(const uint8_t c) {
  if (Cfg::TX_SIZE == 0) {

    _written = true;
@@ -480,7 +480,7 @@ void MarlinSerial<Cfg>::write(const uint8_t c) {
      // location". This makes sure flush() won't return until the bytes
      // actually got written
      B_TXC = 1;
-      return;
+      return 1;
    }

    const uint8_t i = (tx_buffer.head + 1) & (Cfg::TX_SIZE - 1);
@@ -510,6 +510,7 @@ void MarlinSerial<Cfg>::write(const uint8_t c) {
    // Enable TX ISR - Non atomic, but it will eventually enable TX ISR
    B_UDRIE = 1;
  }
+  return 1;
 }

 template<typename Cfg>
@@ -565,9 +566,9 @@ ISR(SERIAL_REGNAME(USART, SERIAL_PORT, _UDRE_vect)) {
  MarlinSerial<MarlinSerialCfg<SERIAL_PORT>>::_tx_udr_empty_irq();
 }

-// Because of the template definition above, it's required to instantiate the template to have all methods generated
+// Because of the template definition above, it's required to instantiate the template to have all method generated
 template class MarlinSerial< MarlinSerialCfg<SERIAL_PORT> >;
-MSerialT1 customizedSerial1(MSerialT1::HasEmergencyParser);
+MSerialT customizedSerial1(MSerialT::HasEmergencyParser);

 #ifdef SERIAL_PORT_2

@@ -582,24 +583,7 @@ MSerialT1 customizedSerial1(MSerialT1::HasEmergencyParser);

  template class MarlinSerial< MarlinSerialCfg<SERIAL_PORT_2> >;
  MSerialT2 customizedSerial2(MSerialT2::HasEmergencyParser);
-
-#endif // SERIAL_PORT_2
-
-#ifdef SERIAL_PORT_3
-
-  // Hookup ISR handlers
-  ISR(SERIAL_REGNAME(USART, SERIAL_PORT_3, _RX_vect)) {
-    MarlinSerial<MarlinSerialCfg<SERIAL_PORT_3>>::store_rxd_char();
-  }
-
-  ISR(SERIAL_REGNAME(USART, SERIAL_PORT_3, _UDRE_vect)) {
-    MarlinSerial<MarlinSerialCfg<SERIAL_PORT_3>>::_tx_udr_empty_irq();
-  }
-
-  template class MarlinSerial< MarlinSerialCfg<SERIAL_PORT_3> >;
-  MSerialT3 customizedSerial3(MSerialT3::HasEmergencyParser);
-
-#endif // SERIAL_PORT_3
+#endif

 #ifdef MMU2_SERIAL_PORT

@@ -612,9 +596,8 @@ MSerialT1 customizedSerial1(MSerialT1::HasEmergencyParser);
  }

  template class MarlinSerial< MMU2SerialCfg<MMU2_SERIAL_PORT> >;
-  MSerialMMU2 mmuSerial(MSerialMMU2::HasEmergencyParser);
-
-#endif // MMU2_SERIAL_PORT
+  MSerialT3 mmuSerial(MSerialT3::HasEmergencyParser);
+#endif

 #ifdef LCD_SERIAL_PORT

@@ -627,9 +610,9 @@ MSerialT1 customizedSerial1(MSerialT1::HasEmergencyParser);
  }

  template class MarlinSerial< LCDSerialCfg<LCD_SERIAL_PORT> >;
-  MSerialLCD lcdSerial(MSerialLCD::HasEmergencyParser);
+  MSerialT4 lcdSerial(MSerialT4::HasEmergencyParser);

-  #if HAS_DGUS_LCD
+  #if HAS_DGUS_LCD || ENABLED(DGUS_LCD_UI_CREALITY_TOUCH)
    template<typename Cfg>
    typename MarlinSerial<Cfg>::ring_buffer_pos_t MarlinSerial<Cfg>::get_tx_buffer_free() {
      const ring_buffer_pos_t t = tx_buffer.tail,  // next byte to send.
@@ -640,13 +623,13 @@ MSerialT1 customizedSerial1(MSerialT1::HasEmergencyParser);
    }
  #endif

-#endif // LCD_SERIAL_PORT
+#endif

 #endif // !USBCON && (UBRRH || UBRR0H || UBRR1H || UBRR2H || UBRR3H)

 // For AT90USB targets use the UART for BT interfacing
 #if defined(USBCON) && ENABLED(BLUETOOTH)
-  MSerialBT bluetoothSerial(false);
+  MSerialT5 bluetoothSerial(false);
 #endif

 #endif // __AVR__
@@ -210,9 +210,9 @@
    static int read();
    static void flush();
    static ring_buffer_pos_t available();
-    static void write(const uint8_t c);
+    static size_t write(const uint8_t c);
    static void flushTX();
-    #if HAS_DGUS_LCD
+    #if HAS_DGUS_LCD || ENABLED(DGUS_LCD_UI_CREALITY_TOUCH)
      static ring_buffer_pos_t get_tx_buffer_free();
    #endif

@@ -238,60 +238,66 @@
    static constexpr bool MAX_RX_QUEUED     = ENABLED(SERIAL_STATS_MAX_RX_QUEUED);
  };

-  typedef Serial1Class< MarlinSerial< MarlinSerialCfg<SERIAL_PORT> > > MSerialT1;
-  extern MSerialT1 customizedSerial1;
+  typedef Serial0Type< MarlinSerial< MarlinSerialCfg<SERIAL_PORT> > > MSerialT;
+  extern MSerialT customizedSerial1;

  #ifdef SERIAL_PORT_2
-    typedef Serial1Class< MarlinSerial< MarlinSerialCfg<SERIAL_PORT_2> > > MSerialT2;
+    typedef Serial0Type< MarlinSerial< MarlinSerialCfg<SERIAL_PORT_2> > > MSerialT2;
    extern MSerialT2 customizedSerial2;
  #endif

-  #ifdef SERIAL_PORT_3
-    typedef Serial1Class< MarlinSerial< MarlinSerialCfg<SERIAL_PORT_3> > > MSerialT3;
-    extern MSerialT3 customizedSerial3;
-  #endif
-
 #endif // !USBCON

 #ifdef MMU2_SERIAL_PORT
  template <uint8_t serial>
  struct MMU2SerialCfg {
    static constexpr int PORT               = serial;
-    static constexpr unsigned int RX_SIZE   = 32;
-    static constexpr unsigned int TX_SIZE   = 32;
    static constexpr bool XONOFF            = false;
    static constexpr bool EMERGENCYPARSER   = false;
    static constexpr bool DROPPED_RX        = false;
    static constexpr bool RX_FRAMING_ERRORS = false;
    static constexpr bool MAX_RX_QUEUED     = false;
+    static constexpr unsigned int RX_SIZE   = 32;
+    static constexpr unsigned int TX_SIZE   = 32;
    static constexpr bool RX_OVERRUNS       = false;
  };

-  typedef Serial1Class< MarlinSerial< MMU2SerialCfg<MMU2_SERIAL_PORT> > > MSerialMMU2;
-  extern MSerialMMU2 mmuSerial;
+  typedef Serial0Type< MarlinSerial< MMU2SerialCfg<MMU2_SERIAL_PORT> > > MSerialT3;
+  extern MSerialT3 mmuSerial;
 #endif

 #ifdef LCD_SERIAL_PORT

  template <uint8_t serial>
  struct LCDSerialCfg {
-    static constexpr int PORT               = serial;
-    static constexpr unsigned int RX_SIZE   = TERN(HAS_DGUS_LCD, DGUS_RX_BUFFER_SIZE,  64);
-    static constexpr unsigned int TX_SIZE   = TERN(HAS_DGUS_LCD, DGUS_TX_BUFFER_SIZE, 128);
-    static constexpr bool XONOFF            = false;
-    static constexpr bool EMERGENCYPARSER   = ENABLED(EMERGENCY_PARSER);
-    static constexpr bool DROPPED_RX        = false;
-    static constexpr bool RX_FRAMING_ERRORS = false;
-    static constexpr bool MAX_RX_QUEUED     = false;
-    static constexpr bool RX_OVERRUNS       = BOTH(HAS_DGUS_LCD, SERIAL_STATS_RX_BUFFER_OVERRUNS);
+    static constexpr int PORT                 = serial;
+    static constexpr bool XONOFF              = false;
+    static constexpr bool EMERGENCYPARSER     = ENABLED(EMERGENCY_PARSER);
+    static constexpr bool DROPPED_RX          = false;
+    static constexpr bool RX_FRAMING_ERRORS   = false;
+    static constexpr bool MAX_RX_QUEUED       = false;
+    #if HAS_DGUS_LCD || ENABLED(DGUS_LCD_UI_CREALITY_TOUCH)
+      static constexpr unsigned int RX_SIZE   = DGUS_RX_BUFFER_SIZE;
+      static constexpr unsigned int TX_SIZE   = DGUS_TX_BUFFER_SIZE;
+      static constexpr bool RX_OVERRUNS       = ENABLED(SERIAL_STATS_RX_BUFFER_OVERRUNS);
+    #elif EITHER(ANYCUBIC_LCD_I3MEGA, ANYCUBIC_LCD_CHIRON)
+      static constexpr unsigned int RX_SIZE   = 64;
+      static constexpr unsigned int TX_SIZE   = 128;
+      static constexpr bool RX_OVERRUNS       = false;
+    #else
+      static constexpr unsigned int RX_SIZE   = 64;
+      static constexpr unsigned int TX_SIZE   = 128;
+      static constexpr bool RX_OVERRUNS       = false
+    #endif
  };

-  typedef Serial1Class< MarlinSerial< LCDSerialCfg<LCD_SERIAL_PORT> > > MSerialLCD;
-  extern MSerialLCD lcdSerial;
+
+  typedef Serial0Type< MarlinSerial< LCDSerialCfg<LCD_SERIAL_PORT> > > MSerialT4;
+  extern MSerialT4 lcdSerial;
 #endif

 // Use the UART for Bluetooth in AT90USB configurations
 #if defined(USBCON) && ENABLED(BLUETOOTH)
-  typedef Serial1Class<HardwareSerial> MSerialBT;
-  extern MSerialBT bluetoothSerial;
+  typedef Serial0Type<HardwareSerial> MSerialT5;
+  extern MSerialT5 bluetoothSerial;
 #endif
@@ -40,13 +40,13 @@ bool PersistentStore::access_start()  { return true; }
 bool PersistentStore::access_finish() { return true; }

 bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
-  uint16_t written = 0;
  while (size--) {
    uint8_t * const p = (uint8_t * const)pos;
    uint8_t v = *value;
-    if (v != eeprom_read_byte(p)) { // EEPROM has only ~100,000 write cycles, so only write bytes that have changed!
+    // EEPROM has only ~100,000 write cycles,
+    // so only write bytes that have changed!
+    if (v != eeprom_read_byte(p)) {
      eeprom_write_byte(p, v);
-      if (++written & 0x7F) delay(2); else safe_delay(2); // Avoid triggering watchdog during long EEPROM writes
      if (eeprom_read_byte(p) != v) {
        SERIAL_ECHO_MSG(STR_ERR_EEPROM_WRITE);
        return true;
@@ -241,7 +241,7 @@ uint8_t extDigitalRead(const int8_t pin) {
 *
 * DC values -1.0 to 1.0. Negative duty cycle inverts the pulse.
 */
-uint16_t set_pwm_frequency_hz(const_float_t hz, const float dca, const float dcb, const float dcc) {
+uint16_t set_pwm_frequency_hz(const float &hz, const float dca, const float dcb, const float dcc) {
  float count = 0;
  if (hz > 0 && (dca || dcb || dcc)) {
    count = float(F_CPU) / hz;            // 1x prescaler, TOP for 16MHz base freq.
@@ -285,7 +285,7 @@ enum ClockSource2 : char {
 */

 // Determine which harware PWMs are already in use
-#define _PWM_CHK_FAN_B(P) (P == E0_AUTO_FAN_PIN || P == E1_AUTO_FAN_PIN || P == E2_AUTO_FAN_PIN || P == E3_AUTO_FAN_PIN || P == E4_AUTO_FAN_PIN || P == E5_AUTO_FAN_PIN || P == E6_AUTO_FAN_PIN || P == E7_AUTO_FAN_PIN || P == CHAMBER_AUTO_FAN_PIN || P == COOLER_AUTO_FAN_PIN)
+#define _PWM_CHK_FAN_B(P) (P == E0_AUTO_FAN_PIN || P == E1_AUTO_FAN_PIN || P == E2_AUTO_FAN_PIN || P == E3_AUTO_FAN_PIN || P == E4_AUTO_FAN_PIN || P == E5_AUTO_FAN_PIN || P == E6_AUTO_FAN_PIN || P == E7_AUTO_FAN_PIN || P == CHAMBER_AUTO_FAN_PIN)
 #if PIN_EXISTS(CONTROLLER_FAN)
  #define PWM_CHK_FAN_B(P) (_PWM_CHK_FAN_B(P) || P == CONTROLLER_FAN_PIN)
 #else
@@ -56,10 +56,3 @@
 #if BOTH(HAS_TMC_SW_SERIAL, MONITOR_DRIVER_STATUS)
  #error "MONITOR_DRIVER_STATUS causes performance issues when used with SoftwareSerial-connected drivers. Disable MONITOR_DRIVER_STATUS or use hardware serial to continue."
 #endif
-
-/**
- * Postmortem debugging
- */
-#if ENABLED(POSTMORTEM_DEBUGGING)
-  #error "POSTMORTEM_DEBUGGING is not supported on AVR boards."
-#endif
@@ -38,7 +38,7 @@
  // portModeRegister takes a different argument
  #define digitalPinToTimer_DEBUG(p) digitalPinToTimer(p)
  #define digitalPinToBitMask_DEBUG(p) digitalPinToBitMask(p)
-  #define digitalPinToPort_DEBUG(p) digitalPinToPort(p)
+  #define digitalPinToPort_DEBUG(p) digitalPinToPort_Teensy(p)
  #define GET_PINMODE(pin) (*portModeRegister(pin) & digitalPinToBitMask_DEBUG(pin))

 #elif AVR_ATmega2560_FAMILY_PLUS_70   // So we can access/display all the pins on boards using more than 70
@@ -0,0 +1,342 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 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/>.
+ *
+ */
+#ifdef ARDUINO_ARCH_SAM
+
+#include "../../core/macros.h"
+#include "../../core/serial.h"
+
+#include "../shared/backtrace/unwinder.h"
+#include "../shared/backtrace/unwmemaccess.h"
+
+#include <stdarg.h>
+
+// Debug monitor that dumps to the Programming port all status when
+// an exception or WDT timeout happens - And then resets the board
+
+// All the Monitor routines must run with interrupts disabled and
+// under an ISR execution context. That is why we cannot reuse the
+// Serial interrupt routines or any C runtime, as we don't know the
+// state we are when running them
+
+// A SW memory barrier, to ensure GCC does not overoptimize loops
+#define sw_barrier() __asm__ volatile("": : :"memory");
+
+// (re)initialize UART0 as a monitor output to 250000,n,8,1
+static void TXBegin() {
+
+  // Disable UART interrupt in NVIC
+  NVIC_DisableIRQ( UART_IRQn );
+
+  // We NEED memory barriers to ensure Interrupts are actually disabled!
+  // ( https://dzone.com/articles/nvic-disabling-interrupts-on-arm-cortex-m-and-the )
+  __DSB();
+  __ISB();
+
+  // Disable clock
+  pmc_disable_periph_clk( ID_UART );
+
+  // Configure PMC
+  pmc_enable_periph_clk( ID_UART );
+
+  // Disable PDC channel
+  UART->UART_PTCR = UART_PTCR_RXTDIS | UART_PTCR_TXTDIS;
+
+  // Reset and disable receiver and transmitter
+  UART->UART_CR = UART_CR_RSTRX | UART_CR_RSTTX | UART_CR_RXDIS | UART_CR_TXDIS;
+
+  // Configure mode: 8bit, No parity, 1 bit stop
+  UART->UART_MR = UART_MR_CHMODE_NORMAL | US_MR_CHRL_8_BIT | US_MR_NBSTOP_1_BIT | UART_MR_PAR_NO;
+
+  // Configure baudrate (asynchronous, no oversampling) to BAUDRATE bauds
+  UART->UART_BRGR = (SystemCoreClock / (BAUDRATE << 4));
+
+  // Enable receiver and transmitter
+  UART->UART_CR = UART_CR_RXEN | UART_CR_TXEN;
+}
+
+// Send character through UART with no interrupts
+static void TX(char c) {
+  while (!(UART->UART_SR & UART_SR_TXRDY)) { WDT_Restart(WDT); sw_barrier(); };
+  UART->UART_THR = c;
+}
+
+// Send String through UART
+static void TX(const char* s) {
+  while (*s) TX(*s++);
+}
+
+static void TXDigit(uint32_t d) {
+  if (d < 10) TX((char)(d+'0'));
+  else if (d < 16) TX((char)(d+'A'-10));
+  else TX('?');
+}
+
+// Send Hex number thru UART
+static void TXHex(uint32_t v) {
+  TX("0x");
+  for (uint8_t i = 0; i < 8; i++, v <<= 4)
+    TXDigit((v >> 28) & 0xF);
+}
+
+// Send Decimal number thru UART
+static void TXDec(uint32_t v) {
+  if (!v) {
+    TX('0');
+    return;
+  }
+
+  char nbrs[14];
+  char *p = &nbrs[0];
+  while (v != 0) {
+    *p++ = '0' + (v % 10);
+    v /= 10;
+  }
+  do {
+    p--;
+    TX(*p);
+  } while (p != &nbrs[0]);
+}
+
+// Dump a backtrace entry
+static bool UnwReportOut(void* ctx, const UnwReport* bte) {
+  int* p = (int*)ctx;
+
+  (*p)++;
+  TX('#'); TXDec(*p); TX(" : ");
+  TX(bte->name?bte->name:"unknown"); TX('@'); TXHex(bte->function);
+  TX('+'); TXDec(bte->address - bte->function);
+  TX(" PC:");TXHex(bte->address); TX('\n');
+  return true;
+}
+
+#ifdef UNW_DEBUG
+  void UnwPrintf(const char* format, ...) {
+    char dest[256];
+    va_list argptr;
+    va_start(argptr, format);
+    vsprintf(dest, format, argptr);
+    va_end(argptr);
+    TX(&dest[0]);
+  }
+#endif
+
+/* Table of function pointers for passing to the unwinder */
+static const UnwindCallbacks UnwCallbacks = {
+  UnwReportOut,
+  UnwReadW,
+  UnwReadH,
+  UnwReadB
+  #ifdef UNW_DEBUG
+   , UnwPrintf
+  #endif
+};
+
+/**
+ * HardFaultHandler_C:
+ * This is called from the HardFault_HandlerAsm with a pointer the Fault stack
+ * as the parameter. We can then read the values from the stack and place them
+ * into local variables for ease of reading.
+ * We then read the various Fault Status and Address Registers to help decode
+ * cause of the fault.
+ * The function ends with a BKPT instruction to force control back into the debugger
+ */
+extern "C"
+void HardFault_HandlerC(unsigned long *sp, unsigned long lr, unsigned long cause) {
+
+  static const char* causestr[] = {
+    "NMI","Hard","Mem","Bus","Usage","Debug","WDT","RSTC"
+  };
+
+  UnwindFrame btf;
+
+  // Dump report to the Programming port (interrupts are DISABLED)
+  TXBegin();
+  TX("\n\n## Software Fault detected ##\n");
+  TX("Cause: "); TX(causestr[cause]); TX('\n');
+
+  TX("R0   : "); TXHex(((unsigned long)sp[0])); TX('\n');
+  TX("R1   : "); TXHex(((unsigned long)sp[1])); TX('\n');
+  TX("R2   : "); TXHex(((unsigned long)sp[2])); TX('\n');
+  TX("R3   : "); TXHex(((unsigned long)sp[3])); TX('\n');
+  TX("R12  : "); TXHex(((unsigned long)sp[4])); TX('\n');
+  TX("LR   : "); TXHex(((unsigned long)sp[5])); TX('\n');
+  TX("PC   : "); TXHex(((unsigned long)sp[6])); TX('\n');
+  TX("PSR  : "); TXHex(((unsigned long)sp[7])); TX('\n');
+
+  // Configurable Fault Status Register
+  // Consists of MMSR, BFSR and UFSR
+  TX("CFSR : "); TXHex((*((volatile unsigned long *)(0xE000ED28)))); TX('\n');
+
+  // Hard Fault Status Register
+  TX("HFSR : "); TXHex((*((volatile unsigned long *)(0xE000ED2C)))); TX('\n');
+
+  // Debug Fault Status Register
+  TX("DFSR : "); TXHex((*((volatile unsigned long *)(0xE000ED30)))); TX('\n');
+
+  // Auxiliary Fault Status Register
+  TX("AFSR : "); TXHex((*((volatile unsigned long *)(0xE000ED3C)))); TX('\n');
+
+  // Read the Fault Address Registers. These may not contain valid values.
+  // Check BFARVALID/MMARVALID to see if they are valid values
+  // MemManage Fault Address Register
+  TX("MMAR : "); TXHex((*((volatile unsigned long *)(0xE000ED34)))); TX('\n');
+
+  // Bus Fault Address Register
+  TX("BFAR : "); TXHex((*((volatile unsigned long *)(0xE000ED38)))); TX('\n');
+
+  TX("ExcLR: "); TXHex(lr); TX('\n');
+  TX("ExcSP: "); TXHex((unsigned long)sp); TX('\n');
+
+  btf.sp = ((unsigned long)sp) + 8*4; // The original stack pointer
+  btf.fp = btf.sp;
+  btf.lr = ((unsigned long)sp[5]);
+  btf.pc = ((unsigned long)sp[6]) | 1; // Force Thumb, as CORTEX only support it
+
+  // Perform a backtrace
+  TX("\nBacktrace:\n\n");
+  int ctr = 0;
+  UnwindStart(&btf, &UnwCallbacks, &ctr);
+
+  // Disable all NVIC interrupts
+  NVIC->ICER[0] = 0xFFFFFFFF;
+  NVIC->ICER[1] = 0xFFFFFFFF;
+
+  // Relocate VTOR table to default position
+  SCB->VTOR = 0;
+
+  // Disable USB
+  otg_disable();
+
+  // Restart watchdog
+  WDT_Restart(WDT);
+
+  // Reset controller
+  NVIC_SystemReset();
+  for (;;) WDT_Restart(WDT);
+}
+
+__attribute__((naked)) void NMI_Handler() {
+  __asm__ __volatile__ (
+    ".syntax unified" "\n\t"
+    A("tst lr, #4")
+    A("ite eq")
+    A("mrseq r0, msp")
+    A("mrsne r0, psp")
+    A("mov r1,lr")
+    A("mov r2,#0")
+    A("b HardFault_HandlerC")
+  );
+}
+
+__attribute__((naked)) void HardFault_Handler() {
+  __asm__ __volatile__ (
+    ".syntax unified" "\n\t"
+    A("tst lr, #4")
+    A("ite eq")
+    A("mrseq r0, msp")
+    A("mrsne r0, psp")
+    A("mov r1,lr")
+    A("mov r2,#1")
+    A("b HardFault_HandlerC")
+  );
+}
+
+__attribute__((naked)) void MemManage_Handler() {
+  __asm__ __volatile__ (
+    ".syntax unified" "\n\t"
+    A("tst lr, #4")
+    A("ite eq")
+    A("mrseq r0, msp")
+    A("mrsne r0, psp")
+    A("mov r1,lr")
+    A("mov r2,#2")
+    A("b HardFault_HandlerC")
+  );
+}
+
+__attribute__((naked)) void BusFault_Handler() {
+  __asm__ __volatile__ (
+    ".syntax unified" "\n\t"
+    A("tst lr, #4")
+    A("ite eq")
+    A("mrseq r0, msp")
+    A("mrsne r0, psp")
+    A("mov r1,lr")
+    A("mov r2,#3")
+    A("b HardFault_HandlerC")
+  );
+}
+
+__attribute__((naked)) void UsageFault_Handler() {
+  __asm__ __volatile__ (
+    ".syntax unified" "\n\t"
+    A("tst lr, #4")
+    A("ite eq")
+    A("mrseq r0, msp")
+    A("mrsne r0, psp")
+    A("mov r1,lr")
+    A("mov r2,#4")
+    A("b HardFault_HandlerC")
+  );
+}
+
+__attribute__((naked)) void DebugMon_Handler() {
+  __asm__ __volatile__ (
+    ".syntax unified" "\n\t"
+    A("tst lr, #4")
+    A("ite eq")
+    A("mrseq r0, msp")
+    A("mrsne r0, psp")
+    A("mov r1,lr")
+    A("mov r2,#5")
+    A("b HardFault_HandlerC")
+  );
+}
+
+/* This is NOT an exception, it is an interrupt handler - Nevertheless, the framing is the same */
+__attribute__((naked)) void WDT_Handler() {
+  __asm__ __volatile__ (
+    ".syntax unified" "\n\t"
+    A("tst lr, #4")
+    A("ite eq")
+    A("mrseq r0, msp")
+    A("mrsne r0, psp")
+    A("mov r1,lr")
+    A("mov r2,#6")
+    A("b HardFault_HandlerC")
+  );
+}
+
+__attribute__((naked)) void RSTC_Handler() {
+  __asm__ __volatile__ (
+    ".syntax unified" "\n\t"
+    A("tst lr, #4")
+    A("ite eq")
+    A("mrseq r0, msp")
+    A("mrsne r0, psp")
+    A("mov r1,lr")
+    A("mov r2,#7")
+    A("b HardFault_HandlerC")
+  );
+}
+
+#endif // ARDUINO_ARCH_SAM
@@ -40,8 +40,6 @@ uint16_t HAL_adc_result;
 // Public functions
 // ------------------------

-TERN_(POSTMORTEM_DEBUGGING, extern void install_min_serial());
-
 // HAL initialization task
 void HAL_init() {
  // Initialize the USB stack
@@ -49,7 +47,6 @@ void HAL_init() {
    OUT_WRITE(SDSS, HIGH);  // Try to set SDSS inactive before any other SPI users start up
  #endif
  usb_task_init();
-  TERN_(POSTMORTEM_DEBUGGING, install_min_serial()); // Install the min serial handler
 }

 // HAL idle task
@@ -77,8 +74,6 @@ uint8_t HAL_get_reset_source() {
  }
 }

-void HAL_reboot() { rstc_start_software_reset(RSTC); }
-
 void _delay_ms(const int delay_ms) {
  // Todo: port for Due?
  delay(delay_ms);
@@ -107,18 +102,11 @@ uint16_t HAL_adc_get_result() {
  return HAL_adc_result;
 }

-// Forward the default serial ports
-#if USING_HW_SERIAL0
-  DefaultSerial1 MSerial0(false, Serial);
-#endif
-#if USING_HW_SERIAL1
-  DefaultSerial2 MSerial1(false, Serial1);
-#endif
-#if USING_HW_SERIAL2
-  DefaultSerial3 MSerial2(false, Serial2);
-#endif
-#if USING_HW_SERIAL3
-  DefaultSerial4 MSerial3(false, Serial3);
-#endif
+// Forward the default serial port
+DefaultSerial MSerial(false, Serial);
+
+DefaultSerial1 MSerial1(false, Serial1);
+DefaultSerial2 MSerial2(false, Serial2);
+DefaultSerial3 MSerial3(false, Serial3);

 #endif // ARDUINO_ARCH_SAM
@@ -37,44 +37,36 @@
 #include <stdint.h>

 #include "../../core/serial_hook.h"
+typedef ForwardSerial0Type< decltype(Serial) > DefaultSerial;
+extern DefaultSerial MSerial;

-typedef ForwardSerial1Class< decltype(Serial) > DefaultSerial1;
-typedef ForwardSerial1Class< decltype(Serial1) > DefaultSerial2;
-typedef ForwardSerial1Class< decltype(Serial2) > DefaultSerial3;
-typedef ForwardSerial1Class< decltype(Serial3) > DefaultSerial4;
-extern DefaultSerial1 MSerial0;
-extern DefaultSerial2 MSerial1;
-extern DefaultSerial3 MSerial2;
-extern DefaultSerial4 MSerial3;
+typedef ForwardSerial0Type< decltype(Serial1) > DefaultSerial1;
+typedef ForwardSerial0Type< decltype(Serial2) > DefaultSerial2;
+typedef ForwardSerial0Type< decltype(Serial3) > DefaultSerial3;
+extern DefaultSerial1 MSerial1;
+extern DefaultSerial2 MSerial2;
+extern DefaultSerial3 MSerial3;

 #define _MSERIAL(X) MSerial##X
 #define MSERIAL(X) _MSERIAL(X)
+#define MSerial0 MSerial

+// Define MYSERIAL0/1 before MarlinSerial includes!
 #if SERIAL_PORT == -1 || ENABLED(EMERGENCY_PARSER)
-  #define MYSERIAL1 customizedSerial1
+  #define MYSERIAL0 customizedSerial1
 #elif WITHIN(SERIAL_PORT, 0, 3)
-  #define MYSERIAL1 MSERIAL(SERIAL_PORT)
+  #define MYSERIAL0 MSERIAL(SERIAL_PORT)
 #else
-  #error "The required SERIAL_PORT must be from 0 to 3, or -1 for USB Serial."
+  #error "The required SERIAL_PORT must be from -1 to 3. Please update your configuration."
 #endif

 #ifdef SERIAL_PORT_2
  #if SERIAL_PORT_2 == -1 || ENABLED(EMERGENCY_PARSER)
-    #define MYSERIAL2 customizedSerial2
+    #define MYSERIAL1 customizedSerial2
  #elif WITHIN(SERIAL_PORT_2, 0, 3)
-    #define MYSERIAL2 MSERIAL(SERIAL_PORT_2)
+    #define MYSERIAL1 MSERIAL(SERIAL_PORT_2)
  #else
-    #error "SERIAL_PORT_2 must be from 0 to 3, or -1 for USB Serial."
-  #endif
-#endif
-
-#ifdef SERIAL_PORT_3
-  #if SERIAL_PORT_3 == -1 || ENABLED(EMERGENCY_PARSER)
-    #define MYSERIAL3 customizedSerial3
-  #elif WITHIN(SERIAL_PORT_3, 0, 3)
-    #define MYSERIAL3 MSERIAL(SERIAL_PORT_3)
-  #else
-    #error "SERIAL_PORT_3 must be from 0 to 3, or -1 for USB Serial."
+    #error "SERIAL_PORT_2 must be from -1 to 3. Please update your configuration."
  #endif
 #endif

@@ -82,15 +74,17 @@ extern DefaultSerial4 MSerial3;
  #if WITHIN(MMU2_SERIAL_PORT, 0, 3)
    #define MMU2_SERIAL MSERIAL(MMU2_SERIAL_PORT)
  #else
-    #error "MMU2_SERIAL_PORT must be from 0 to 3."
+    #error "MMU2_SERIAL_PORT must be from 0 to 3. Please update your configuration."
  #endif
 #endif

 #ifdef LCD_SERIAL_PORT
-  #if WITHIN(LCD_SERIAL_PORT, 0, 3)
+  #if LCD_SERIAL_PORT == -1
+    #define LCD_SERIAL lcdSerial
+  #elif WITHIN(LCD_SERIAL_PORT, 0, 3)
    #define LCD_SERIAL MSERIAL(LCD_SERIAL_PORT)
  #else
-    #error "LCD_SERIAL_PORT must be from 0 to 3."
+    #error "LCD_SERIAL_PORT must be from -1 to 3. Please update your configuration."
  #endif
 #endif

@@ -120,7 +114,7 @@ void sei();                     // Enable interrupts
 void HAL_clear_reset_source();  // clear reset reason
 uint8_t HAL_get_reset_source(); // get reset reason

-void HAL_reboot();
+inline void HAL_reboot() {}  // reboot the board or restart the bootloader

 //
 // ADC
@@ -1,91 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2021 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/>.
- *
- */
-#ifdef ARDUINO_ARCH_SAM
-
-#include "../../inc/MarlinConfigPre.h"
-
-#if ENABLED(POSTMORTEM_DEBUGGING)
-
-#include "../shared/HAL_MinSerial.h"
-
-#include <stdarg.h>
-
-static void TXBegin() {
-  // Disable UART interrupt in NVIC
-  NVIC_DisableIRQ( UART_IRQn );
-
-  // We NEED memory barriers to ensure Interrupts are actually disabled!
-  // ( https://dzone.com/articles/nvic-disabling-interrupts-on-arm-cortex-m-and-the )
-  __DSB();
-  __ISB();
-
-  // Disable clock
-  pmc_disable_periph_clk( ID_UART );
-
-  // Configure PMC
-  pmc_enable_periph_clk( ID_UART );
-
-  // Disable PDC channel
-  UART->UART_PTCR = UART_PTCR_RXTDIS | UART_PTCR_TXTDIS;
-
-  // Reset and disable receiver and transmitter
-  UART->UART_CR = UART_CR_RSTRX | UART_CR_RSTTX | UART_CR_RXDIS | UART_CR_TXDIS;
-
-  // Configure mode: 8bit, No parity, 1 bit stop
-  UART->UART_MR = UART_MR_CHMODE_NORMAL | US_MR_CHRL_8_BIT | US_MR_NBSTOP_1_BIT | UART_MR_PAR_NO;
-
-  // Configure baudrate (asynchronous, no oversampling) to BAUDRATE bauds
-  UART->UART_BRGR = (SystemCoreClock / (BAUDRATE << 4));
-
-  // Enable receiver and transmitter
-  UART->UART_CR = UART_CR_RXEN | UART_CR_TXEN;
-}
-
-// A SW memory barrier, to ensure GCC does not overoptimize loops
-#define sw_barrier() __asm__ volatile("": : :"memory");
-static void TX(char c) {
-  while (!(UART->UART_SR & UART_SR_TXRDY)) { WDT_Restart(WDT); sw_barrier(); };
-  UART->UART_THR = c;
-}
-
-void install_min_serial() {
-  HAL_min_serial_init = &TXBegin;
-  HAL_min_serial_out = &TX;
-}
-
-#if DISABLED(DYNAMIC_VECTORTABLE)
-extern "C" {
-  __attribute__((naked)) void JumpHandler_ASM() {
-    __asm__ __volatile__ (
-      "b CommonHandler_ASM\n"
-    );
-  }
-  void __attribute__((naked, alias("JumpHandler_ASM"))) HardFault_Handler();
-  void __attribute__((naked, alias("JumpHandler_ASM"))) BusFault_Handler();
-  void __attribute__((naked, alias("JumpHandler_ASM"))) UsageFault_Handler();
-  void __attribute__((naked, alias("JumpHandler_ASM"))) MemManage_Handler();
-  void __attribute__((naked, alias("JumpHandler_ASM"))) NMI_Handler();
-}
-#endif
-
-#endif // POSTMORTEM_DEBUGGING
-#endif // ARDUINO_ARCH_SAM
@@ -56,8 +56,8 @@
  #pragma GCC optimize (3)

  typedef uint8_t (*pfnSpiTransfer)(uint8_t b);
-  typedef void    (*pfnSpiRxBlock)(uint8_t *buf, uint32_t nbyte);
-  typedef void    (*pfnSpiTxBlock)(const uint8_t *buf, uint32_t nbyte);
+  typedef void    (*pfnSpiRxBlock)(uint8_t* buf, uint32_t nbyte);
+  typedef void    (*pfnSpiTxBlock)(const uint8_t* buf, uint32_t nbyte);

  /* ---------------- Macros to be able to access definitions from asm */
  #define _PORT(IO) DIO ##  IO ## _WPORT
@@ -270,7 +270,7 @@
  static pfnSpiTransfer spiTransferTx = (pfnSpiTransfer)spiTransferX;

  // Block transfers run at ~8 .. ~10Mhz - Tx version (Rx data discarded)
-  static void spiTxBlock0(const uint8_t *ptr, uint32_t todo) {
+  static void spiTxBlock0(const uint8_t* ptr, uint32_t todo) {
    uint32_t MOSI_PORT_PLUS30 = ((uint32_t) PORT(SD_MOSI_PIN)) + 0x30;  /* SODR of port */
    uint32_t MOSI_MASK = PIN_MASK(SD_MOSI_PIN);
    uint32_t SCK_PORT_PLUS30 = ((uint32_t) PORT(SD_SCK_PIN)) + 0x30;    /* SODR of port */
@@ -349,7 +349,7 @@
    );
  }

-  static void spiRxBlock0(uint8_t *ptr, uint32_t todo) {
+  static void spiRxBlock0(uint8_t* ptr, uint32_t todo) {
    uint32_t bin = 0;
    uint32_t work = 0;
    uint32_t BITBAND_MISO_PORT = BITBAND_ADDRESS( ((uint32_t)PORT(SD_MISO_PIN))+0x3C, PIN_SHIFT(SD_MISO_PIN));  /* PDSR of port in bitband area */
@@ -425,13 +425,13 @@
    );
  }

-  static void spiTxBlockX(const uint8_t *buf, uint32_t todo) {
+  static void spiTxBlockX(const uint8_t* buf, uint32_t todo) {
    do {
      (void)spiTransferTx(*buf++);
    } while (--todo);
  }

-  static void spiRxBlockX(uint8_t *buf, uint32_t todo) {
+  static void spiRxBlockX(uint8_t* buf, uint32_t todo) {
    do {
      *buf++ = spiTransferRx(0xFF);
    } while (--todo);
@@ -463,7 +463,7 @@
    return b;
  }

-  void spiRead(uint8_t *buf, uint16_t nbyte) {
+  void spiRead(uint8_t* buf, uint16_t nbyte) {
    if (nbyte) {
      _SS_WRITE(LOW);
      WRITE(SD_MOSI_PIN, HIGH); // Output 1s 1
@@ -478,7 +478,7 @@
    _SS_WRITE(HIGH);
  }

-  void spiSendBlock(uint8_t token, const uint8_t *buf) {
+  void spiSendBlock(uint8_t token, const uint8_t* buf) {
    _SS_WRITE(LOW);
    (void)spiTransferTx(token);
    spiTxBlock(buf, 512);
@@ -645,7 +645,7 @@
    }

    // Read from SPI into buffer
-    void spiRead(uint8_t *buf, uint16_t nbyte) {
+    void spiRead(uint8_t* buf, uint16_t nbyte) {
      if (!nbyte) return;
      --nbyte;
      for (int i = 0; i < nbyte; i++) {
@@ -668,7 +668,7 @@
      //DELAY_US(1U);
    }

-    void spiSend(const uint8_t *buf, size_t nbyte) {
+    void spiSend(const uint8_t* buf, size_t nbyte) {
      if (!nbyte) return;
      --nbyte;
      for (size_t i = 0; i < nbyte; i++) {
@@ -689,7 +689,7 @@
      FLUSH_RX();
    }

-    void spiSend(uint32_t chan, const uint8_t *buf, size_t nbyte) {
+    void spiSend(uint32_t chan, const uint8_t* buf, size_t nbyte) {
      if (!nbyte) return;
      --nbyte;
      for (size_t i = 0; i < nbyte; i++) {
@@ -702,7 +702,7 @@
    }

    // Write from buffer to SPI
-    void spiSendBlock(uint8_t token, const uint8_t *buf) {
+    void spiSendBlock(uint8_t token, const uint8_t* buf) {
      SPI0->SPI_TDR = (uint32_t)token | SPI_PCS(SPI_CHAN);
      WHILE_TX(0);
      //WHILE_RX(0);
@@ -801,19 +801,19 @@

    uint8_t spiRec() { return (uint8_t)spiTransfer(0xFF); }

-    void spiRead(uint8_t *buf, uint16_t nbyte) {
+    void spiRead(uint8_t* buf, uint16_t nbyte) {
      for (int i = 0; i < nbyte; i++)
        buf[i] = spiTransfer(0xFF);
    }

    void spiSend(uint8_t data) { spiTransfer(data); }

-    void spiSend(const uint8_t *buf, size_t nbyte) {
+    void spiSend(const uint8_t* buf, size_t nbyte) {
      for (uint16_t i = 0; i < nbyte; i++)
        spiTransfer(buf[i]);
    }

-    void spiSendBlock(uint8_t token, const uint8_t *buf) {
+    void spiSendBlock(uint8_t token, const uint8_t* buf) {
      spiTransfer(token);
      for (uint16_t i = 0; i < 512; i++)
        spiTransfer(buf[i]);
@@ -476,9 +476,9 @@ void MarlinSerial<Cfg>::flushTX() {


 // If not using the USB port as serial port
-#if defined(SERIAL_PORT) && SERIAL_PORT >= 0
+#if SERIAL_PORT >= 0
  template class MarlinSerial< MarlinSerialCfg<SERIAL_PORT> >;
-  MSerialT1 customizedSerial1(MarlinSerialCfg<SERIAL_PORT>::EMERGENCYPARSER);
+  MSerialT customizedSerial1(MarlinSerialCfg<SERIAL_PORT>::EMERGENCYPARSER);
 #endif

 #if defined(SERIAL_PORT_2) && SERIAL_PORT_2 >= 0
@@ -486,9 +486,4 @@ void MarlinSerial<Cfg>::flushTX() {
  MSerialT2 customizedSerial2(MarlinSerialCfg<SERIAL_PORT_2>::EMERGENCYPARSER);
 #endif

-#if defined(SERIAL_PORT_3) && SERIAL_PORT_3 >= 0
-  template class MarlinSerial< MarlinSerialCfg<SERIAL_PORT_3> >;
-  MSerialT3 customizedSerial3(MarlinSerialCfg<SERIAL_PORT_3>::EMERGENCYPARSER);
-#endif
-
 #endif // ARDUINO_ARCH_SAM
@@ -140,17 +140,12 @@ struct MarlinSerialCfg {
  static constexpr bool MAX_RX_QUEUED     = ENABLED(SERIAL_STATS_MAX_RX_QUEUED);
 };

-#if defined(SERIAL_PORT) && SERIAL_PORT >= 0
-  typedef Serial1Class< MarlinSerial< MarlinSerialCfg<SERIAL_PORT> > > MSerialT1;
-  extern MSerialT1 customizedSerial1;
+#if SERIAL_PORT >= 0
+  typedef Serial0Type< MarlinSerial< MarlinSerialCfg<SERIAL_PORT> > > MSerialT;
+  extern MSerialT customizedSerial1;
 #endif

 #if defined(SERIAL_PORT_2) && SERIAL_PORT_2 >= 0
-  typedef Serial1Class< MarlinSerial< MarlinSerialCfg<SERIAL_PORT_2> > > MSerialT2;
+  typedef Serial0Type< MarlinSerial< MarlinSerialCfg<SERIAL_PORT_2> > > MSerialT2;
  extern MSerialT2 customizedSerial2;
 #endif
-
-#if defined(SERIAL_PORT_3) && SERIAL_PORT_3 >= 0
-  typedef Serial1Class< MarlinSerial< MarlinSerialCfg<SERIAL_PORT_3> > > MSerialT3;
-  extern MSerialT3 customizedSerial3;
-#endif
@@ -19,13 +19,13 @@
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 */
-#ifdef ARDUINO_ARCH_SAM

 /**
 * MarlinSerial_Due.cpp - Hardware serial library for Arduino DUE
 * Copyright (c) 2017 Eduardo José Tagle. All right reserved
 * Based on MarlinSerial for AVR, copyright (c) 2006 Nicholas Zambetti.  All right reserved.
 */
+#ifdef ARDUINO_ARCH_SAM

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

@@ -65,7 +65,7 @@ int MarlinSerialUSB::peek() {

  pending_char = udi_cdc_getc();

-  TERN_(EMERGENCY_PARSER, emergency_parser.update(static_cast<MSerialT1*>(this)->emergency_state, (char)pending_char));
+  TERN_(EMERGENCY_PARSER, emergency_parser.update(static_cast<MSerialT*>(this)->emergency_state, (char)pending_char));

  return pending_char;
 }
@@ -87,16 +87,17 @@ int MarlinSerialUSB::read() {

  int c = udi_cdc_getc();

-  TERN_(EMERGENCY_PARSER, emergency_parser.update(static_cast<MSerialT1*>(this)->emergency_state, (char)c));
+  TERN_(EMERGENCY_PARSER, emergency_parser.update(static_cast<MSerialT*>(this)->emergency_state, (char)c));

  return c;
 }

-int MarlinSerialUSB::available() {
-  if (pending_char > 0) return pending_char;
-  return pending_char == 0 ||
-    // or USB CDC enumerated and configured on the PC side and some bytes where sent to us */
-    (usb_task_cdc_isenabled() && udi_cdc_is_rx_ready());
+bool MarlinSerialUSB::available() {
+    /* If Pending chars */
+  return pending_char >= 0 ||
+    /* or USB CDC enumerated and configured on the PC side and some
+       bytes where sent to us */
+      (usb_task_cdc_isenabled() && udi_cdc_is_rx_ready());
 }

 void MarlinSerialUSB::flush() { }
@@ -129,13 +130,10 @@ size_t MarlinSerialUSB::write(const uint8_t c) {

 // Preinstantiate
 #if SERIAL_PORT == -1
-  MSerialT1 customizedSerial1(TERN0(EMERGENCY_PARSER, true));
+  MSerialT customizedSerial1(TERN0(EMERGENCY_PARSER, true));
 #endif
 #if SERIAL_PORT_2 == -1
-  MSerialT2 customizedSerial2(TERN0(EMERGENCY_PARSER, true));
-#endif
-#if SERIAL_PORT_3 == -1
-  MSerialT3 customizedSerial3(TERN0(EMERGENCY_PARSER, true));
+  MSerialT customizedSerial2(TERN0(EMERGENCY_PARSER, true));
 #endif

 #endif // HAS_USB_SERIAL
@@ -27,9 +27,11 @@
 */

 #include "../../inc/MarlinConfig.h"
-#include "../../core/serial_hook.h"
+#if HAS_USB_SERIAL

 #include <WString.h>
+#include "../../core/serial_hook.h"
+

 struct MarlinSerialUSB {
  void begin(const long);
@@ -37,7 +39,7 @@ struct MarlinSerialUSB {
  int peek();
  int read();
  void flush();
-  int available();
+  bool available();
  size_t write(const uint8_t c);

  #if ENABLED(SERIAL_STATS_DROPPED_RX)
@@ -48,18 +50,14 @@ struct MarlinSerialUSB {
    FORCE_INLINE int rxMaxEnqueued() { return 0; }
  #endif
 };
+typedef Serial0Type<MarlinSerialUSB> MSerialT;

 #if SERIAL_PORT == -1
-  typedef Serial1Class<MarlinSerialUSB> MSerialT1;
-  extern MSerialT1 customizedSerial1;
+  extern MSerialT customizedSerial1;
 #endif

 #if SERIAL_PORT_2 == -1
-  typedef Serial1Class<MarlinSerialUSB> MSerialT2;
-  extern MSerialT2 customizedSerial2;
+  extern MSerialT customizedSerial2;
 #endif

-#if SERIAL_PORT_3 == -1
-  typedef Serial1Class<MarlinSerialUSB> MSerialT3;
-  extern MSerialT3 customizedSerial3;
-#endif
+#endif // HAS_USB_SERIAL
@@ -135,11 +135,11 @@ static uint8_t buffer[256] = {0},   // The RAM buffer to accumulate writes
 #define DEBUG_OUT ENABLED(EE_EMU_DEBUG)
 #include "../../core/debug_out.h"

-static void ee_Dump(const int page, const void *data) {
+static void ee_Dump(const int page, const void* data) {

  #ifdef EE_EMU_DEBUG

-    const uint8_t *c = (const uint8_t*) data;
+    const uint8_t* c = (const uint8_t*) data;
    char buffer[80];

    sprintf_P(buffer, PSTR("Page: %d (0x%04x)\n"), page, page);
@@ -181,7 +181,7 @@ static void ee_Dump(const int page, const void *data) {
 * @param data    (pointer to the data buffer)
 */
 __attribute__ ((long_call, section (".ramfunc")))
-static bool ee_PageWrite(uint16_t page, const void *data) {
+static bool ee_PageWrite(uint16_t page, const void* data) {

  uint16_t i;
  uint32_t addrflash = uint32_t(getFlashStorage(page));
@@ -293,8 +293,8 @@ static bool ee_PageWrite(uint16_t page, const void *data) {
      ee_Dump(-page, data);

      // Calculate count of changed bits
-      uint32_t *p1 = (uint32_t*)addrflash;
-      uint32_t *p2 = (uint32_t*)data;
+      uint32_t* p1 = (uint32_t*)addrflash;
+      uint32_t* p2 = (uint32_t*)data;
      int count = 0;
      for (i =0; i<PageSize >> 2; i++) {
        if (p1[i] != p2[i]) {
@@ -470,7 +470,7 @@ static uint8_t ee_Read(uint32_t address, bool excludeRAMBuffer=false) {
  for (int page = curPage - 1; page >= 0; --page) {

    // Get a pointer to the flash page
-    uint8_t *pflash = (uint8_t*)getFlashStorage(page + curGroup * PagesPerGroup);
+    uint8_t* pflash = (uint8_t*)getFlashStorage(page + curGroup * PagesPerGroup);

    uint16_t i = 0;
    while (i <= (PageSize - 4)) { /* (PageSize - 4) because otherwise, there is not enough room for data and headers */
@@ -550,7 +550,7 @@ static uint32_t ee_GetAddrRange(uint32_t address, bool excludeRAMBuffer=false) {
  for (int page = curPage - 1; page >= 0; --page) {

    // Get a pointer to the flash page
-    uint8_t *pflash = (uint8_t*)getFlashStorage(page + curGroup * PagesPerGroup);
+    uint8_t* pflash = (uint8_t*)getFlashStorage(page + curGroup * PagesPerGroup);

    uint16_t i = 0;
    while (i <= (PageSize - 4)) { /* (PageSize - 4) because otherwise, there is not enough room for data and headers */
@@ -589,7 +589,7 @@ static uint32_t ee_GetAddrRange(uint32_t address, bool excludeRAMBuffer=false) {
 }

 static bool ee_IsPageClean(int page) {
-  uint32_t *pflash = (uint32_t*) getFlashStorage(page);
+  uint32_t* pflash = (uint32_t*) getFlashStorage(page);
  for (uint16_t i = 0; i < (PageSize >> 2); ++i)
    if (*pflash++ != 0xFFFFFFFF) return false;
  return true;
@@ -599,7 +599,7 @@ static bool ee_Flush(uint32_t overrideAddress = 0xFFFFFFFF, uint8_t overrideData

  // Check if RAM buffer has something to be written
  bool isEmpty = true;
-  uint32_t *p = (uint32_t*) &buffer[0];
+  uint32_t* p = (uint32_t*) &buffer[0];
  for (uint16_t j = 0; j < (PageSize >> 2); j++) {
    if (*p++ != 0xFFFFFFFF) {
      isEmpty = false;
@@ -976,13 +976,14 @@ bool PersistentStore::access_start()  { ee_Init();  return true; }
 bool PersistentStore::access_finish() { ee_Flush(); return true; }

 bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
-  uint16_t written = 0;
  while (size--) {
    uint8_t * const p = (uint8_t * const)pos;
    uint8_t v = *value;
-    if (v != ee_Read(uint32_t(p))) { // EEPROM has only ~100,000 write cycles, so only write bytes that have changed!
+    // EEPROM has only ~100,000 write cycles,
+    // so only write bytes that have changed!
+    if (v != ee_Read(uint32_t(p))) {
      ee_Write(uint32_t(p), v);
-      if (++written & 0x7F) delay(2); else safe_delay(2); // Avoid triggering watchdog during long EEPROM writes
+      delay(2);
      if (ee_Read(uint32_t(p)) != v) {
        SERIAL_ECHO_MSG(STR_ERR_EEPROM_WRITE);
        return true;
@@ -42,13 +42,14 @@ bool PersistentStore::access_start()  { eeprom_init(); return true; }
 bool PersistentStore::access_finish() { return true; }

 bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
-  uint16_t written = 0;
  while (size--) {
    uint8_t * const p = (uint8_t * const)pos;
    uint8_t v = *value;
-    if (v != eeprom_read_byte(p)) { // EEPROM has only ~100,000 write cycles, so only write bytes that have changed!
+    // EEPROM has only ~100,000 write cycles,
+    // so only write bytes that have changed!
+    if (v != eeprom_read_byte(p)) {
      eeprom_write_byte(p, v);
-      if (++written & 0x7F) delay(2); else safe_delay(2); // Avoid triggering watchdog during long EEPROM writes
+      delay(2);
      if (eeprom_read_byte(p) != v) {
        SERIAL_ECHO_MSG(STR_ERR_EEPROM_WRITE);
        return true;
@@ -33,7 +33,7 @@
 * For ARDUINO_ARCH_SAM
 * Note the code here was specifically crafted by disassembling what GCC produces
 * out of it, so GCC is able to optimize it out as much as possible to the least
- * amount of instructions. Be very careful if you modify them, as "clean code"
+ * amount of instructions. Be very carefull if you modify them, as "clean code"
 * leads to less efficient compiled code!!
 */

@@ -57,5 +57,5 @@
 #endif

 #if HAS_TMC_SW_SERIAL
-  #error "TMC220x Software Serial is not supported on the DUE platform."
+  #error "TMC220x Software Serial is not supported on this platform."
 #endif
@@ -32,7 +32,7 @@ Ctrl_status sd_mmc_spi_test_unit_ready() {
 Ctrl_status sd_mmc_spi_read_capacity(uint32_t *nb_sector) {
  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted())
    return CTRL_NO_PRESENT;
-  *nb_sector = card.diskIODriver()->cardSize() - 1;
+  *nb_sector = card.getSd2Card().cardSize() - 1;
  return CTRL_GOOD;
 }

@@ -74,24 +74,24 @@ Ctrl_status sd_mmc_spi_usb_read_10(uint32_t addr, uint16_t nb_sector) {
  #endif

  // Start reading
-  if (!card.diskIODriver()->readStart(addr))
+  if (!card.getSd2Card().readStart(addr))
    return CTRL_FAIL;

  // For each specified sector
  while (nb_sector--) {

    // Read a sector
-    card.diskIODriver()->readData(sector_buf);
+    card.getSd2Card().readData(sector_buf);

    // RAM -> USB
    if (!udi_msc_trans_block(true, sector_buf, SD_MMC_BLOCK_SIZE, nullptr)) {
-      card.diskIODriver()->readStop();
+      card.getSd2Card().readStop();
      return CTRL_FAIL;
    }
  }

  // Stop reading
-  card.diskIODriver()->readStop();
+  card.getSd2Card().readStop();

  // Done
  return CTRL_GOOD;
@@ -113,7 +113,7 @@ Ctrl_status sd_mmc_spi_usb_write_10(uint32_t addr, uint16_t nb_sector) {
  }
  #endif

-  if (!card.diskIODriver()->writeStart(addr, nb_sector))
+  if (!card.getSd2Card().writeStart(addr, nb_sector))
    return CTRL_FAIL;

  // For each specified sector
@@ -121,16 +121,16 @@ Ctrl_status sd_mmc_spi_usb_write_10(uint32_t addr, uint16_t nb_sector) {

    // USB -> RAM
    if (!udi_msc_trans_block(false, sector_buf, SD_MMC_BLOCK_SIZE, nullptr)) {
-      card.diskIODriver()->writeStop();
+      card.getSd2Card().writeStop();
      return CTRL_FAIL;
    }

    // Write a sector
-    card.diskIODriver()->writeData(sector_buf);
+    card.getSd2Card().writeData(sector_buf);
  }

  // Stop writing
-  card.diskIODriver()->writeStop();
+  card.getSd2Card().writeStop();

  // Done
  return CTRL_GOOD;
@@ -675,11 +675,11 @@ iram_size_t udi_cdc_multi_write_buf(uint8_t port, const void* buf, iram_size_t s
 *   - \code // Waits and gets a value on CDC line
 	int udi_cdc_getc(void);
 	// Reads a RAM buffer on CDC line
-	iram_size_t udi_cdc_read_buf(int *buf, iram_size_t size);
+	iram_size_t udi_cdc_read_buf(int* buf, iram_size_t size);
 	// Puts a byte on CDC line
 	int udi_cdc_putc(int value);
 	// Writes a RAM buffer on CDC line
-	iram_size_t udi_cdc_write_buf(const int *buf, iram_size_t size); \endcode
+	iram_size_t udi_cdc_write_buf(const int* buf, iram_size_t size); \endcode
 *
 * \section udi_cdc_use_cases Advanced use cases
 * For more advanced use of the UDI CDC module, see the following use cases:
@@ -264,7 +264,7 @@ bool usb_task_extra_string(void) {
 ** Handle device requests that the ASF stack doesn't
 */
 bool usb_task_other_requests(void) {
-  uint8_t *ptr = 0;
+  uint8_t* ptr = 0;
  uint16_t size = 0;

  if (Udd_setup_type() == USB_REQ_TYPE_VENDOR) {
@@ -322,7 +322,7 @@ void usb_task_init(void) {
      char *sptr;

      // Patch in the filament diameter
-      itoa((int)((DEFAULT_NOMINAL_FILAMENT_DIA) * 1000), diam, 10);
+      sprintf_P(diam, PSTR("%d"), (int)((DEFAULT_NOMINAL_FILAMENT_DIA) * 1000.0));

      // And copy it to the proper place, expanding it to unicode
      sptr = &diam[0];
@@ -20,10 +20,11 @@
 *
 */

-#ifdef ARDUINO_ARCH_ESP32
-
 #include "FlushableHardwareSerial.h"

-Serial1Class<FlushableHardwareSerial> flushableSerial(false, 0);
+#ifdef ARDUINO_ARCH_ESP32

-#endif
+
+Serial0Type<FlushableHardwareSerial> flushableSerial(false, 0);
+
+#endif // ARDUINO_ARCH_ESP32
@@ -21,9 +21,9 @@
 */
 #pragma once

-#include <HardwareSerial.h>
+#ifdef ARDUINO_ARCH_ESP32

-#include "../shared/Marduino.h"
+#include <HardwareSerial.h>
 #include "../../core/serial_hook.h"

 class FlushableHardwareSerial : public HardwareSerial {
@@ -31,4 +31,6 @@ public:
  FlushableHardwareSerial(int uart_nr) : HardwareSerial(uart_nr) {}
 };

-extern Serial1Class<FlushableHardwareSerial> flushableSerial;
+extern Serial0Type<FlushableHardwareSerial> flushableSerial;
+
+#endif // ARDUINO_ARCH_ESP32
@@ -41,7 +41,7 @@
 #endif

 #if ENABLED(ESP3D_WIFISUPPORT)
-  DefaultSerial1 MSerial0(false, Serial2Socket);
+  DefaultSerial MSerial(false, Serial2Socket);
 #endif

 // ------------------------
@@ -141,8 +141,6 @@ void HAL_clear_reset_source() { }

 uint8_t HAL_get_reset_source() { return rtc_get_reset_reason(1); }

-void HAL_reboot() { ESP.restart(); }
-
 void _delay_ms(int delay_ms) { delay(delay_ms); }

 // return free memory between end of heap (or end bss) and whatever is current
@@ -187,7 +185,6 @@ void HAL_adc_init() {
  TERN_(HAS_TEMP_ADC_7, adc3_set_attenuation(get_channel(TEMP_7_PIN), ADC_ATTEN_11db));
  TERN_(HAS_HEATED_BED, adc1_set_attenuation(get_channel(TEMP_BED_PIN), ADC_ATTEN_11db));
  TERN_(HAS_TEMP_CHAMBER, adc1_set_attenuation(get_channel(TEMP_CHAMBER_PIN), ADC_ATTEN_11db));
-  TERN_(HAS_TEMP_COOLER, adc1_set_attenuation(get_channel(TEMP_COOLER_PIN), ADC_ATTEN_11db));
  TERN_(FILAMENT_WIDTH_SENSOR, adc1_set_attenuation(get_channel(FILWIDTH_PIN), ADC_ATTEN_11db));

  // Note that adc2 is shared with the WiFi module, which has higher priority, so the conversion may fail.
@@ -51,15 +51,15 @@

 extern portMUX_TYPE spinlock;

-#define MYSERIAL1 flushableSerial
+#define MYSERIAL0 flushableSerial

 #if EITHER(WIFISUPPORT, ESP3D_WIFISUPPORT)
  #if ENABLED(ESP3D_WIFISUPPORT)
-    typedef ForwardSerial1Class< decltype(Serial2Socket) > DefaultSerial1;
-    extern DefaultSerial1 MSerial0;
-    #define MYSERIAL2 MSerial0
+    typedef ForwardSerial0Type< decltype(Serial2Socket) > DefaultSerial;
+    extern DefaultSerial MSerial;
+    #define MYSERIAL1 MSerial
  #else
-    #define MYSERIAL2 webSocketSerial
+    #define MYSERIAL1 webSocketSerial
  #endif
 #endif

@@ -101,7 +101,7 @@ void HAL_clear_reset_source();
 // reset reason
 uint8_t HAL_get_reset_source();

-void HAL_reboot();
+inline void HAL_reboot() {}  // reboot the board or restart the bootloader

 void _delay_ms(int delay);

@@ -85,7 +85,7 @@ uint8_t spiRec() {
  return returnByte;
 }

-void spiRead(uint8_t *buf, uint16_t nbyte) {
+void spiRead(uint8_t* buf, uint16_t nbyte) {
  SPI.beginTransaction(spiConfig);
  SPI.transferBytes(0, buf, nbyte);
  SPI.endTransaction();
@@ -97,7 +97,7 @@ void spiSend(uint8_t b) {
  SPI.endTransaction();
 }

-void spiSendBlock(uint8_t token, const uint8_t *buf) {
+void spiSendBlock(uint8_t token, const uint8_t* buf) {
  SPI.beginTransaction(spiConfig);
  SPI.transfer(token);
  SPI.writeBytes(const_cast<uint8_t*>(buf), 512);
@@ -29,7 +29,7 @@
 #include "wifi.h"
 #include <ESPAsyncWebServer.h>

-MSerialWebSocketT webSocketSerial(false);
+MSerialT webSocketSerial(false);
 AsyncWebSocket ws("/ws"); // TODO Move inside the class.

 // RingBuffer impl
@@ -137,7 +137,7 @@ size_t WebSocketSerial::write(const uint8_t c) {
  return ret;
 }

-size_t WebSocketSerial::write(const uint8_t *buffer, size_t size) {
+size_t WebSocketSerial::write(const uint8_t* buffer, size_t size) {
  size_t written = 0;
  for (size_t i = 0; i < size; i++)
    written += write(buffer[i]);
@@ -54,7 +54,7 @@ public:
  ring_buffer_pos_t read(uint8_t *buffer);
  void flush();
  ring_buffer_pos_t write(const uint8_t c);
-  ring_buffer_pos_t write(const uint8_t *buffer, ring_buffer_pos_t size);
+  ring_buffer_pos_t write(const uint8_t* buffer, ring_buffer_pos_t size);
 };

 class WebSocketSerial: public Stream {
@@ -70,7 +70,7 @@ public:
  int read();
  void flush();
  size_t write(const uint8_t c);
-  size_t write(const uint8_t *buffer, size_t size);
+  size_t write(const uint8_t* buffer, size_t size);

  #if ENABLED(SERIAL_STATS_DROPPED_RX)
    FORCE_INLINE uint32_t dropped() { return 0; }
@@ -81,5 +81,5 @@ public:
  #endif
 };

-typedef Serial1Class<WebSocketSerial> MSerialWebSocketT;
-extern MSerialWebSocketT webSocketSerial;
+typedef Serial0Type<WebSocketSerial> MSerialT;
+extern MSerialT webSocketSerial;
@@ -139,7 +139,7 @@ static void IRAM_ATTR i2s_intr_handler_default(void *arg) {
  I2S0.int_clr.val = I2S0.int_st.val; //clear pending interrupt
 }

-void stepperTask(void *parameter) {
+void stepperTask(void* parameter) {
  uint32_t remaining = 0;

  while (1) {
@@ -30,13 +30,9 @@
 #endif

 #if HAS_TMC_SW_SERIAL
-  #error "TMC220x Software Serial is not supported on ESP32."
+  #error "TMC220x Software Serial is not supported on this platform."
 #endif

 #if BOTH(WIFISUPPORT, ESP3D_WIFISUPPORT)
  #error "Only enable one WiFi option, either WIFISUPPORT or ESP3D_WIFISUPPORT."
 #endif
-
-#if ENABLED(POSTMORTEM_DEBUGGING)
-  #error "POSTMORTEM_DEBUGGING is not yet supported on ESP32."
-#endif
@@ -29,6 +29,12 @@

 #include HAL_PATH(.,HAL.h)

+#ifdef SERIAL_PORT_2
+  #define NUM_SERIAL 2
+#else
+  #define NUM_SERIAL 1
+#endif
+
 #define HAL_ADC_RANGE _BV(HAL_ADC_RESOLUTION)

 #ifndef I2C_ADDRESS
@@ -73,6 +73,4 @@ void HAL_pwm_init() {

 }

-void HAL_reboot() { /* Reset the application state and GPIO */ }
-
 #endif // __PLAT_LINUX__
@@ -61,7 +61,7 @@ uint8_t _getc();
 #define SHARED_SERVOS HAS_SERVOS

 extern MSerialT usb_serial;
-#define MYSERIAL1 usb_serial
+#define MYSERIAL0 usb_serial

 #define ST7920_DELAY_1 DELAY_NS(600)
 #define ST7920_DELAY_2 DELAY_NS(750)
@@ -107,7 +107,7 @@ uint16_t HAL_adc_get_result();
 inline void HAL_clear_reset_source(void) {}
 inline uint8_t HAL_get_reset_source(void) { return RST_POWER_ON; }

-void HAL_reboot(); // Reset the application state and GPIO
+inline void HAL_reboot() {}  // reboot the board or restart the bootloader

 /* ---------------- Delay in cycles */
 FORCE_INLINE static void DELAY_CYCLES(uint64_t x) {
@@ -35,9 +35,5 @@
 #endif

 #if HAS_TMC_SW_SERIAL
-  #error "TMC220x Software Serial is not supported on LINUX."
-#endif
-
-#if ENABLED(POSTMORTEM_DEBUGGING)
-  #error "POSTMORTEM_DEBUGGING is not yet supported on LINUX."
+  #error "TMC220x Software Serial is not supported on this platform."
 #endif
@@ -115,4 +115,4 @@ struct HalSerial {
  volatile bool host_connected;
 };

-typedef Serial1Class<HalSerial> MSerialT;
+typedef Serial0Type<HalSerial> MSerialT;
@@ -105,8 +105,8 @@ int main() {
  std::thread write_serial (write_serial_thread);
  std::thread read_serial (read_serial_thread);

-  #ifdef MYSERIAL1
-    MYSERIAL1.begin(BAUDRATE);
+  #ifdef MYSERIAL0
+    MYSERIAL0.begin(BAUDRATE);
    SERIAL_ECHOLNPGM("x86_64 Initialized");
    SERIAL_FLUSHTX();
  #endif
@@ -0,0 +1,322 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 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/>.
+ *
+ */
+#ifdef TARGET_LPC1768
+
+#include "../../core/macros.h"
+#include "../../core/serial.h"
+#include <stdarg.h>
+
+#include "../shared/backtrace/unwinder.h"
+#include "../shared/backtrace/unwmemaccess.h"
+#include "watchdog.h"
+#include <debug_frmwrk.h>
+
+
+// Debug monitor that dumps to the Programming port all status when
+// an exception or WDT timeout happens - And then resets the board
+
+// All the Monitor routines must run with interrupts disabled and
+// under an ISR execution context. That is why we cannot reuse the
+// Serial interrupt routines or any C runtime, as we don't know the
+// state we are when running them
+
+// A SW memory barrier, to ensure GCC does not overoptimize loops
+#define sw_barrier() __asm__ volatile("": : :"memory");
+
+// (re)initialize UART0 as a monitor output to 250000,n,8,1
+static void TXBegin() {
+}
+
+// Send character through UART with no interrupts
+static void TX(char c) {
+  _DBC(c);
+}
+
+// Send String through UART
+static void TX(const char* s) {
+  while (*s) TX(*s++);
+}
+
+static void TXDigit(uint32_t d) {
+  if (d < 10) TX((char)(d+'0'));
+  else if (d < 16) TX((char)(d+'A'-10));
+  else TX('?');
+}
+
+// Send Hex number thru UART
+static void TXHex(uint32_t v) {
+  TX("0x");
+  for (uint8_t i = 0; i < 8; i++, v <<= 4)
+    TXDigit((v >> 28) & 0xF);
+}
+
+// Send Decimal number thru UART
+static void TXDec(uint32_t v) {
+  if (!v) {
+    TX('0');
+    return;
+  }
+
+  char nbrs[14];
+  char *p = &nbrs[0];
+  while (v != 0) {
+    *p++ = '0' + (v % 10);
+    v /= 10;
+  }
+  do {
+    p--;
+    TX(*p);
+  } while (p != &nbrs[0]);
+}
+
+// Dump a backtrace entry
+static bool UnwReportOut(void* ctx, const UnwReport* bte) {
+  int* p = (int*)ctx;
+
+  (*p)++;
+  TX('#'); TXDec(*p); TX(" : ");
+  TX(bte->name?bte->name:"unknown"); TX('@'); TXHex(bte->function);
+  TX('+'); TXDec(bte->address - bte->function);
+  TX(" PC:");TXHex(bte->address); TX('\n');
+  return true;
+}
+
+#ifdef UNW_DEBUG
+  void UnwPrintf(const char* format, ...) {
+    char dest[256];
+    va_list argptr;
+    va_start(argptr, format);
+    vsprintf(dest, format, argptr);
+    va_end(argptr);
+    TX(&dest[0]);
+  }
+#endif
+
+/* Table of function pointers for passing to the unwinder */
+static const UnwindCallbacks UnwCallbacks = {
+  UnwReportOut,
+  UnwReadW,
+  UnwReadH,
+  UnwReadB
+  #ifdef UNW_DEBUG
+   ,UnwPrintf
+  #endif
+};
+
+
+/**
+ * HardFaultHandler_C:
+ * This is called from the HardFault_HandlerAsm with a pointer the Fault stack
+ * as the parameter. We can then read the values from the stack and place them
+ * into local variables for ease of reading.
+ * We then read the various Fault Status and Address Registers to help decode
+ * cause of the fault.
+ * The function ends with a BKPT instruction to force control back into the debugger
+ */
+extern "C"
+void HardFault_HandlerC(unsigned long *sp, unsigned long lr, unsigned long cause) {
+
+  static const char* causestr[] = {
+    "NMI","Hard","Mem","Bus","Usage","Debug","WDT","RSTC"
+  };
+
+  UnwindFrame btf;
+
+  // Dump report to the Programming port (interrupts are DISABLED)
+  TXBegin();
+  TX("\n\n## Software Fault detected ##\n");
+  TX("Cause: "); TX(causestr[cause]); TX('\n');
+
+  TX("R0   : "); TXHex(((unsigned long)sp[0])); TX('\n');
+  TX("R1   : "); TXHex(((unsigned long)sp[1])); TX('\n');
+  TX("R2   : "); TXHex(((unsigned long)sp[2])); TX('\n');
+  TX("R3   : "); TXHex(((unsigned long)sp[3])); TX('\n');
+  TX("R12  : "); TXHex(((unsigned long)sp[4])); TX('\n');
+  TX("LR   : "); TXHex(((unsigned long)sp[5])); TX('\n');
+  TX("PC   : "); TXHex(((unsigned long)sp[6])); TX('\n');
+  TX("PSR  : "); TXHex(((unsigned long)sp[7])); TX('\n');
+
+  // Configurable Fault Status Register
+  // Consists of MMSR, BFSR and UFSR
+  TX("CFSR : "); TXHex((*((volatile unsigned long *)(0xE000ED28)))); TX('\n');
+
+  // Hard Fault Status Register
+  TX("HFSR : "); TXHex((*((volatile unsigned long *)(0xE000ED2C)))); TX('\n');
+
+  // Debug Fault Status Register
+  TX("DFSR : "); TXHex((*((volatile unsigned long *)(0xE000ED30)))); TX('\n');
+
+  // Auxiliary Fault Status Register
+  TX("AFSR : "); TXHex((*((volatile unsigned long *)(0xE000ED3C)))); TX('\n');
+
+  // Read the Fault Address Registers. These may not contain valid values.
+  // Check BFARVALID/MMARVALID to see if they are valid values
+  // MemManage Fault Address Register
+  TX("MMAR : "); TXHex((*((volatile unsigned long *)(0xE000ED34)))); TX('\n');
+
+  // Bus Fault Address Register
+  TX("BFAR : "); TXHex((*((volatile unsigned long *)(0xE000ED38)))); TX('\n');
+
+  TX("ExcLR: "); TXHex(lr); TX('\n');
+  TX("ExcSP: "); TXHex((unsigned long)sp); TX('\n');
+
+  btf.sp = ((unsigned long)sp) + 8*4; // The original stack pointer
+  btf.fp = btf.sp;
+  btf.lr = ((unsigned long)sp[5]);
+  btf.pc = ((unsigned long)sp[6]) | 1; // Force Thumb, as CORTEX only support it
+
+  // Perform a backtrace
+  TX("\nBacktrace:\n\n");
+  int ctr = 0;
+  UnwindStart(&btf, &UnwCallbacks, &ctr);
+
+  // Disable all NVIC interrupts
+  NVIC->ICER[0] = 0xFFFFFFFF;
+  NVIC->ICER[1] = 0xFFFFFFFF;
+
+  // Relocate VTOR table to default position
+  SCB->VTOR = 0;
+
+  // Clear cause of reset to prevent entering smoothie bootstrap
+  HAL_clear_reset_source();
+
+  // Restart watchdog
+  #if ENABLED(USE_WATCHDOG)
+    //WDT_Restart(WDT);
+    watchdog_init();
+  #endif
+
+  // Reset controller
+  NVIC_SystemReset();
+
+  // Nothing below here is compiled because NVIC_SystemReset loops forever
+
+  for (;;) { TERN_(USE_WATCHDOG, watchdog_init()); }
+}
+
+extern "C" {
+__attribute__((naked)) void NMI_Handler() {
+  __asm__ __volatile__ (
+    ".syntax unified" "\n\t"
+    A("tst lr, #4")
+    A("ite eq")
+    A("mrseq r0, msp")
+    A("mrsne r0, psp")
+    A("mov r1,lr")
+    A("mov r2,#0")
+    A("b HardFault_HandlerC")
+  );
+}
+
+__attribute__((naked)) void HardFault_Handler() {
+  __asm__ __volatile__ (
+    ".syntax unified" "\n\t"
+    A("tst lr, #4")
+    A("ite eq")
+    A("mrseq r0, msp")
+    A("mrsne r0, psp")
+    A("mov r1,lr")
+    A("mov r2,#1")
+    A("b HardFault_HandlerC")
+  );
+}
+
+__attribute__((naked)) void MemManage_Handler() {
+  __asm__ __volatile__ (
+    ".syntax unified" "\n\t"
+    A("tst lr, #4")
+    A("ite eq")
+    A("mrseq r0, msp")
+    A("mrsne r0, psp")
+    A("mov r1,lr")
+    A("mov r2,#2")
+    A("b HardFault_HandlerC")
+  );
+}
+
+__attribute__((naked)) void BusFault_Handler() {
+  __asm__ __volatile__ (
+    ".syntax unified" "\n\t"
+    A("tst lr, #4")
+    A("ite eq")
+    A("mrseq r0, msp")
+    A("mrsne r0, psp")
+    A("mov r1,lr")
+    A("mov r2,#3")
+    A("b HardFault_HandlerC")
+  );
+}
+
+__attribute__((naked)) void UsageFault_Handler() {
+  __asm__ __volatile__ (
+    ".syntax unified" "\n\t"
+    A("tst lr, #4")
+    A("ite eq")
+    A("mrseq r0, msp")
+    A("mrsne r0, psp")
+    A("mov r1,lr")
+    A("mov r2,#4")
+    A("b HardFault_HandlerC")
+  );
+}
+
+__attribute__((naked)) void DebugMon_Handler() {
+  __asm__ __volatile__ (
+    ".syntax unified" "\n\t"
+    A("tst lr, #4")
+    A("ite eq")
+    A("mrseq r0, msp")
+    A("mrsne r0, psp")
+    A("mov r1,lr")
+    A("mov r2,#5")
+    A("b HardFault_HandlerC")
+  );
+}
+
+/* This is NOT an exception, it is an interrupt handler - Nevertheless, the framing is the same */
+__attribute__((naked)) void WDT_IRQHandler() {
+  __asm__ __volatile__ (
+    ".syntax unified" "\n\t"
+    A("tst lr, #4")
+    A("ite eq")
+    A("mrseq r0, msp")
+    A("mrsne r0, psp")
+    A("mov r1,lr")
+    A("mov r2,#6")
+    A("b HardFault_HandlerC")
+  );
+}
+
+__attribute__((naked)) void RSTC_Handler() {
+  __asm__ __volatile__ (
+    ".syntax unified" "\n\t"
+    A("tst lr, #4")
+    A("ite eq")
+    A("mrseq r0, msp")
+    A("mrsne r0, psp")
+    A("mov r1,lr")
+    A("mov r2,#7")
+    A("b HardFault_HandlerC")
+  );
+}
+}
+#endif // TARGET_LPC1768
@@ -29,7 +29,7 @@
  #include "watchdog.h"
 #endif

-DefaultSerial1 USBSerial(false, UsbSerial);
+DefaultSerial USBSerial(false, UsbSerial);

 uint32_t HAL_adc_reading = 0;

@@ -67,7 +67,7 @@ void flashFirmware(const int16_t) {
  delay(500);          // Give OS time to disconnect
  USB_Connect(false);  // USB clear connection
  delay(1000);         // Give OS time to notice
-  HAL_reboot();
+  NVIC_SystemReset();
 }

 void HAL_clear_reset_source(void) {
@@ -81,6 +81,4 @@ uint8_t HAL_get_reset_source(void) {
  return RST_POWER_ON;
 }

-void HAL_reboot() { NVIC_SystemReset(); }
-
 #endif // TARGET_LPC1768
@@ -60,37 +60,28 @@ extern "C" volatile uint32_t _millis;
  #define ST7920_DELAY_3 DELAY_NS(750)
 #endif

-typedef ForwardSerial1Class< decltype(UsbSerial) > DefaultSerial1;
-extern DefaultSerial1 USBSerial;
+typedef ForwardSerial0Type< decltype(UsbSerial) > DefaultSerial;
+extern DefaultSerial USBSerial;

 #define _MSERIAL(X) MSerial##X
 #define MSERIAL(X) _MSERIAL(X)
+#define MSerial0 MSerial

 #if SERIAL_PORT == -1
-  #define MYSERIAL1 USBSerial
+  #define MYSERIAL0 USBSerial
 #elif WITHIN(SERIAL_PORT, 0, 3)
-  #define MYSERIAL1 MSERIAL(SERIAL_PORT)
+  #define MYSERIAL0 MSERIAL(SERIAL_PORT)
 #else
-  #error "SERIAL_PORT must be from 0 to 3. You can also use -1 if the board supports Native USB."
+  #error "SERIAL_PORT must be from -1 to 3. Please update your configuration."
 #endif

 #ifdef SERIAL_PORT_2
  #if SERIAL_PORT_2 == -1
-    #define MYSERIAL2 USBSerial
+    #define MYSERIAL1 USBSerial
  #elif WITHIN(SERIAL_PORT_2, 0, 3)
-    #define MYSERIAL2 MSERIAL(SERIAL_PORT_2)
+    #define MYSERIAL1 MSERIAL(SERIAL_PORT_2)
  #else
-    #error "SERIAL_PORT_2 must be from 0 to 3. You can also use -1 if the board supports Native USB."
-  #endif
-#endif
-
-#ifdef SERIAL_PORT_3
-  #if SERIAL_PORT_3 == -1
-    #define MYSERIAL3 USBSerial
-  #elif WITHIN(SERIAL_PORT_3, 0, 3)
-    #define MYSERIAL3 MSERIAL(SERIAL_PORT_3)
-  #else
-    #error "SERIAL_PORT_3 must be from 0 to 3. You can also use -1 if the board supports Native USB."
+    #error "SERIAL_PORT_2 must be from -1 to 3. Please update your configuration."
  #endif
 #endif

@@ -100,7 +91,7 @@ extern DefaultSerial1 USBSerial;
  #elif WITHIN(MMU2_SERIAL_PORT, 0, 3)
    #define MMU2_SERIAL MSERIAL(MMU2_SERIAL_PORT)
  #else
-    #error "MMU2_SERIAL_PORT must be from 0 to 3. You can also use -1 if the board supports Native USB."
+    #error "MMU2_SERIAL_PORT must be from -1 to 3. Please update your configuration."
  #endif
 #endif

@@ -110,10 +101,7 @@ extern DefaultSerial1 USBSerial;
  #elif WITHIN(LCD_SERIAL_PORT, 0, 3)
    #define LCD_SERIAL MSERIAL(LCD_SERIAL_PORT)
  #else
-    #error "LCD_SERIAL_PORT must be from 0 to 3. You can also use -1 if the board supports Native USB."
-  #endif
-  #if HAS_DGUS_LCD
-    #define SERIAL_GET_TX_BUFFER_FREE() MSerial0.available()
+    #error "LCD_SERIAL_PORT must be from -1 to 3. Please update your configuration."
  #endif
 #endif

@@ -228,4 +216,4 @@ void set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size=255,
 void HAL_clear_reset_source(void);
 uint8_t HAL_get_reset_source(void);

-void HAL_reboot();
+inline void HAL_reboot() {}  // reboot the board or restart the bootloader
@@ -1,51 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2021 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/>.
- *
- */
-#ifdef TARGET_LPC1768
-
-#include "../../inc/MarlinConfig.h"
-#include "HAL.h"
-
-#if ENABLED(POSTMORTEM_DEBUGGING)
-
-#include "../shared/HAL_MinSerial.h"
-#include <debug_frmwrk.h>
-
-static void TX(char c) { _DBC(c); }
-void install_min_serial() { HAL_min_serial_out = &TX; }
-
-#if DISABLED(DYNAMIC_VECTORTABLE)
-extern "C" {
-  __attribute__((naked)) void JumpHandler_ASM() {
-    __asm__ __volatile__ (
-      "b CommonHandler_ASM\n"
-    );
-  }
-  void __attribute__((naked, alias("JumpHandler_ASM"))) HardFault_Handler();
-  void __attribute__((naked, alias("JumpHandler_ASM"))) BusFault_Handler();
-  void __attribute__((naked, alias("JumpHandler_ASM"))) UsageFault_Handler();
-  void __attribute__((naked, alias("JumpHandler_ASM"))) MemManage_Handler();
-  void __attribute__((naked, alias("JumpHandler_ASM"))) NMI_Handler();
-}
-#endif
-
-#endif // POSTMORTEM_DEBUGGING
-#endif // TARGET_LPC1768
@@ -93,12 +93,12 @@

  void spiSend(uint8_t b) { (void)spiTransfer(b); }

-  void spiSend(const uint8_t *buf, size_t nbyte) {
+  void spiSend(const uint8_t* buf, size_t nbyte) {
    for (uint16_t i = 0; i < nbyte; i++)
      (void)spiTransfer(buf[i]);
  }

-  void spiSendBlock(uint8_t token, const uint8_t *buf) {
+  void spiSendBlock(uint8_t token, const uint8_t* buf) {
    (void)spiTransfer(token);
    for (uint16_t i = 0; i < 512; i++)
      (void)spiTransfer(buf[i]);
@@ -135,13 +135,13 @@

  void spiSend(uint8_t b) { doio(b); }

-  void spiSend(const uint8_t *buf, size_t nbyte) {
+  void spiSend(const uint8_t* buf, size_t nbyte) {
    for (uint16_t i = 0; i < nbyte; i++) doio(buf[i]);
  }

  void spiSend(uint32_t chan, byte b) {}

-  void spiSend(uint32_t chan, const uint8_t *buf, size_t nbyte) {}
+  void spiSend(uint32_t chan, const uint8_t* buf, size_t nbyte) {}

  // Read single byte from SPI
  uint8_t spiRec() { return doio(0xFF); }
@@ -156,7 +156,7 @@
  uint8_t spiTransfer(uint8_t b) { return doio(b); }

  // Write from buffer to SPI
-  void spiSendBlock(uint8_t token, const uint8_t *buf) {
+  void spiSendBlock(uint8_t token, const uint8_t* buf) {
   (void)spiTransfer(token);
    for (uint16_t i = 0; i < 512; i++)
      (void)spiTransfer(buf[i]);
@@ -21,51 +21,24 @@
 */
 #ifdef TARGET_LPC1768

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

-#include "../../inc/MarlinConfig.h"
-
-#if USING_HW_SERIAL0
-  MarlinSerial _MSerial0(LPC_UART0);
-  MSerialT MSerial0(true, _MSerial0);
-  extern "C" void UART0_IRQHandler() { _MSerial0.IRQHandler(); }
+#if ANY_SERIAL_IS(0)
+  MSerialT MSerial(true, LPC_UART0);
+  extern "C" void UART0_IRQHandler() { MSerial.IRQHandler(); }
 #endif
-#if USING_HW_SERIAL1
-  MarlinSerial _MSerial1((LPC_UART_TypeDef *) LPC_UART1);
-  MSerialT MSerial1(true, _MSerial1);
-  extern "C" void UART1_IRQHandler() { _MSerial1.IRQHandler(); }
+#if ANY_SERIAL_IS(1)
+  MSerialT MSerial1(true, (LPC_UART_TypeDef *) LPC_UART1);
+  extern "C" void UART1_IRQHandler() { MSerial1.IRQHandler(); }
 #endif
-#if USING_HW_SERIAL2
-  MarlinSerial _MSerial2(LPC_UART2);
-  MSerialT MSerial2(true, _MSerial2);
-  extern "C" void UART2_IRQHandler() { _MSerial2.IRQHandler(); }
+#if ANY_SERIAL_IS(2)
+  MSerialT MSerial2(true, LPC_UART2);
+  extern "C" void UART2_IRQHandler() { MSerial2.IRQHandler(); }
 #endif
-#if USING_HW_SERIAL3
-  MarlinSerial _MSerial3(LPC_UART3);
-  MSerialT MSerial3(true, _MSerial3);
-  extern "C" void UART3_IRQHandler() { _MSerial3.IRQHandler(); }
-#endif
-
-#if ENABLED(EMERGENCY_PARSER)
-
-  bool MarlinSerial::recv_callback(const char c) {
-    // Need to figure out which serial port we are and react in consequence (Marlin does not have CONTAINER_OF macro)
-    if (false) {}
-    #if USING_HW_SERIAL0
-      else if (this == &_MSerial0) emergency_parser.update(MSerial0.emergency_state, c);
-    #endif
-    #if USING_HW_SERIAL1
-      else if (this == &_MSerial1) emergency_parser.update(MSerial1.emergency_state, c);
-    #endif
-    #if USING_HW_SERIAL2
-      else if (this == &_MSerial2) emergency_parser.update(MSerial2.emergency_state, c);
-    #endif
-    #if USING_HW_SERIAL3
-      else if (this == &_MSerial3) emergency_parser.update(MSerial3.emergency_state, c);
-    #endif
-    return true;
-  }
-
+#if ANY_SERIAL_IS(3)
+  MSerialT MSerial3(true, LPC_UART3);
+  extern "C" void UART3_IRQHandler() { MSerial3.IRQHandler(); }
 #endif

 #endif // TARGET_LPC1768
@@ -47,21 +47,15 @@ public:
  void end() {}

  #if ENABLED(EMERGENCY_PARSER)
-    bool recv_callback(const char c) override;
+    bool recv_callback(const char c) override {
+      emergency_parser.update(static_cast<Serial0Type<MarlinSerial> *>(this)->emergency_state, c);
+      return true; // do not discard character
+    }
  #endif
 };

-// On LPC176x framework, HardwareSerial does not implement the same interface as Arduino's Serial, so overloads
-// of 'available' and 'read' method are not used in this multiple inheritance scenario.
-// Instead, use a ForwardSerial here that adapts the interface.
-typedef ForwardSerial1Class<MarlinSerial> MSerialT;
-extern MSerialT MSerial0;
+typedef Serial0Type<MarlinSerial> MSerialT;
+extern MSerialT MSerial;
 extern MSerialT MSerial1;
 extern MSerialT MSerial2;
 extern MSerialT MSerial3;
-
-// Consequently, we can't use a RuntimeSerial either. The workaround would be to use
-// a RuntimeSerial<ForwardSerial<MarlinSerial>> type here. Ignore for now until it's actually required.
-#if ENABLED(SERIAL_RUNTIME_HOOK)
-  #error "SERIAL_RUNTIME_HOOK is not yet supported for LPC176x."
-#endif
@@ -83,13 +83,14 @@ bool PersistentStore::access_finish() {
 static void debug_rw(const bool write, int &pos, const uint8_t *value, const size_t size, const FRESULT s, const size_t total=0) {
  PGM_P const rw_str = write ? PSTR("write") : PSTR("read");
  SERIAL_CHAR(' ');
-  SERIAL_ECHOPGM_P(rw_str);
+  serialprintPGM(rw_str);
  SERIAL_ECHOLNPAIR("_data(", pos, ",", value, ",", size, ", ...)");
  if (total) {
    SERIAL_ECHOPGM(" f_");
-    SERIAL_ECHOPGM_P(rw_str);
+    serialprintPGM(rw_str);
    SERIAL_ECHOPAIR("()=", s, "\n size=", size, "\n bytes_");
-    SERIAL_ECHOLNPAIR_P(write ? PSTR("written=") : PSTR("read="), total);
+    serialprintPGM(write ? PSTR("written=") : PSTR("read="));
+    SERIAL_ECHOLN(total);
  }
  else
    SERIAL_ECHOLNPAIR(" f_lseek()=", s);
@@ -42,22 +42,25 @@ bool PersistentStore::access_start()  { eeprom_init(); return true; }
 bool PersistentStore::access_finish() { return true; }

 bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
-  uint16_t written = 0;
  while (size--) {
    uint8_t v = *value;
+
+    // EEPROM has only ~100,000 write cycles,
+    // so only write bytes that have changed!
    uint8_t * const p = (uint8_t * const)pos;
-    if (v != eeprom_read_byte(p)) { // EEPROM has only ~100,000 write cycles, so only write bytes that have changed!
+    if (v != eeprom_read_byte(p)) {
      eeprom_write_byte(p, v);
-      if (++written & 0x7F) delay(2); else safe_delay(2); // Avoid triggering watchdog during long EEPROM writes
      if (eeprom_read_byte(p) != v) {
        SERIAL_ECHO_MSG(STR_ERR_EEPROM_WRITE);
        return true;
      }
    }
+
    crc16(crc, &v, 1);
    pos++;
    value++;
-  }
+  };
+
  return false;
 }

@@ -65,6 +68,7 @@ bool PersistentStore::read_data(int &pos, uint8_t *value, size_t size, uint16_t
  do {
    // Read from external EEPROM
    const uint8_t c = eeprom_read_byte((uint8_t*)pos);
+
    if (writing) *value = c;
    crc16(crc, &c, 1);
    pos++;
@@ -30,5 +30,6 @@
 // LPC1768 boards seem to lose steps when saving to EEPROM during print (issue #20785)
 // TODO: Which other boards are incompatible?
 #if defined(MCU_LPC1768) && PRINTCOUNTER_SAVE_INTERVAL > 0
+  #warning "To prevent step loss, motion will pause for PRINTCOUNTER auto-save."
  #define PRINTCOUNTER_SYNC 1
 #endif
@@ -92,7 +92,7 @@ static_assert(DISABLED(BAUD_RATE_GCODE), "BAUD_RATE_GCODE is not yet supported o
 #define ANY_TX(N,V...) DO(IS_TX##N,||,V)
 #define ANY_RX(N,V...) DO(IS_RX##N,||,V)

-#if USING_HW_SERIAL0
+#if ANY_SERIAL_IS(0)
  #define IS_TX0(P) (P == P0_02)
  #define IS_RX0(P) (P == P0_03)
  #if IS_TX0(TMC_SW_MISO) || IS_RX0(TMC_SW_MOSI)
@@ -106,7 +106,7 @@ static_assert(DISABLED(BAUD_RATE_GCODE), "BAUD_RATE_GCODE is not yet supported o
  #undef IS_RX0
 #endif

-#if USING_HW_SERIAL1
+#if ANY_SERIAL_IS(1)
  #define IS_TX1(P) (P == P0_15)
  #define IS_RX1(P) (P == P0_16)
  #define _IS_TX1_1 IS_TX1
@@ -127,7 +127,7 @@ static_assert(DISABLED(BAUD_RATE_GCODE), "BAUD_RATE_GCODE is not yet supported o
  #undef _IS_RX1_1
 #endif

-#if USING_HW_SERIAL2
+#if ANY_SERIAL_IS(2)
  #define IS_TX2(P) (P == P0_10)
  #define IS_RX2(P) (P == P0_11)
  #define _IS_TX2_1 IS_TX2
@@ -144,7 +144,7 @@ static_assert(DISABLED(BAUD_RATE_GCODE), "BAUD_RATE_GCODE is not yet supported o
    #error "Serial port pins (2) conflict with Z4 pins!"
  #elif ANY_RX(2, X_DIR_PIN, Y_DIR_PIN)
    #error "Serial port pins (2) conflict with other pins!"
-  #elif Y_HOME_TO_MIN && IS_TX2(Y_STOP_PIN)
+  #elif Y_HOME_DIR < 0 && IS_TX2(Y_STOP_PIN)
    #error "Serial port pins (2) conflict with Y endstop pin!"
  #elif HAS_CUSTOM_PROBE_PIN && IS_TX2(Z_MIN_PROBE_PIN)
    #error "Serial port pins (2) conflict with probe pin!"
@@ -161,7 +161,7 @@ static_assert(DISABLED(BAUD_RATE_GCODE), "BAUD_RATE_GCODE is not yet supported o
  #undef _IS_RX2_1
 #endif

-#if USING_HW_SERIAL3
+#if ANY_SERIAL_IS(3)
  #define PIN_IS_TX3(P) (PIN_EXISTS(P) && P##_PIN == P0_00)
  #define PIN_IS_RX3(P) (P##_PIN == P0_01)
  #if PIN_IS_TX3(X_MIN) || PIN_IS_RX3(X_MAX)
@@ -270,7 +270,7 @@ static_assert(DISABLED(BAUD_RATE_GCODE), "BAUD_RATE_GCODE is not yet supported o
 #endif

 #if ENABLED(SERIAL_STATS_MAX_RX_QUEUED)
-  #error "SERIAL_STATS_MAX_RX_QUEUED is not supported on LPC176x."
+  #error "SERIAL_STATS_MAX_RX_QUEUED is not supported on this platform."
 #elif ENABLED(SERIAL_STATS_DROPPED_RX)
-  #error "SERIAL_STATS_DROPPED_RX is not supported on LPX176x."
+  #error "SERIAL_STATS_DROPPED_RX is not supported on this platform."
 #endif
@@ -46,8 +46,6 @@ extern "C" {

 void SysTick_Callback() { disk_timerproc(); }

-TERN_(POSTMORTEM_DEBUGGING, extern void install_min_serial());
-
 void HAL_init() {

  // Init LEDs
@@ -117,7 +115,7 @@ void HAL_init() {
    PinCfg.Pinmode = 2;    // no pull-up/pull-down
    PINSEL_ConfigPin(&PinCfg);
    // now set CLKOUT_EN bit
-    SBI(LPC_SC->CLKOUTCFG, 8);
+    LPC_SC->CLKOUTCFG |= (1<<8);
  #endif

  USB_Init();                               // USB Initialization
@@ -125,7 +123,9 @@ void HAL_init() {
  delay(1000);                              // Give OS time to notice
  USB_Connect(true);

-  TERN_(HAS_SD_HOST_DRIVE, MSC_SD_Init(0)); // Enable USB SD card access
+  #if HAS_SD_HOST_DRIVE
+    MSC_SD_Init(0);                         // Enable USB SD card access
+  #endif

  const millis_t usb_timeout = millis() + 2000;
  while (!USB_Configuration && PENDING(millis(), usb_timeout)) {
@@ -137,8 +137,6 @@ void HAL_init() {
  }

  HAL_timer_init();
-
-  TERN_(POSTMORTEM_DEBUGGING, install_min_serial()); // Install the min serial handler
 }

 // HAL idle task
@@ -22,7 +22,7 @@

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

-#if HAS_TFT_XPT2046 || HAS_RES_TOUCH_BUTTONS
+#if HAS_TFT_XPT2046 || HAS_TOUCH_BUTTONS

 #include "xpt2046.h"
 #include <SPI.h>
@@ -66,7 +66,7 @@
 void spiBegin();
 void spiInit(uint8_t spiRate);
 void spiSend(uint8_t b);
-void spiSend(const uint8_t *buf, size_t n);
+void spiSend(const uint8_t* buf, size_t n);

 static uint8_t rs_last_state = 255;

@@ -8,7 +8,9 @@ from __future__ import print_function
 target_filename = "FIRMWARE.CUR"
 target_drive = "REARM"

-import os,getpass,platform
+import os
+import getpass
+import platform

 current_OS = platform.system()
 Import("env")
@@ -20,104 +22,102 @@ def print_error(e):
 		  'or copy the firmware (.pio/build/%s/firmware.bin) manually to the appropriate disk\n' \
 		  %(e, env.get('PIOENV')))

-def before_upload(source, target, env):
-	try:
+try:
+	#
+	# Find a disk for upload
+	#
+	upload_disk = 'Disk not found'
+	target_file_found = False
+	target_drive_found = False
+	if current_OS == 'Windows':
 		#
-		# Find a disk for upload
-		#
-		upload_disk = 'Disk not found'
-		target_file_found = False
-		target_drive_found = False
-		if current_OS == 'Windows':
-			#
-			# platformio.ini will accept this for a Windows upload port designation: 'upload_port = L:'
-			#   Windows - doesn't care about the disk's name, only cares about the drive letter
-			import subprocess,string
-			from ctypes import windll
+		# platformio.ini will accept this for a Windows upload port designation: 'upload_port = L:'
+		#   Windows - doesn't care about the disk's name, only cares about the drive letter
+		import subprocess
+		from ctypes import windll
+		import string

-			# getting list of drives
-			# https://stackoverflow.com/questions/827371/is-there-a-way-to-list-all-the-available-drive-letters-in-python
-			drives = []
-			bitmask = windll.kernel32.GetLogicalDrives()
-			for letter in string.ascii_uppercase:
-				if bitmask & 1:
-					drives.append(letter)
-				bitmask >>= 1
+		# getting list of drives
+		# https://stackoverflow.com/questions/827371/is-there-a-way-to-list-all-the-available-drive-letters-in-python
+		drives = []
+		bitmask = windll.kernel32.GetLogicalDrives()
+		for letter in string.ascii_uppercase:
+			if bitmask & 1:
+				drives.append(letter)
+			bitmask >>= 1

-			for drive in drives:
-				final_drive_name = drive + ':\\'
-				# print ('disc check: {}'.format(final_drive_name))
-				try:
-					volume_info = str(subprocess.check_output('cmd /C dir ' + final_drive_name, stderr=subprocess.STDOUT))
-				except Exception as e:
-					print ('error:{}'.format(e))
-					continue
-				else:
-					if target_drive in volume_info and not target_file_found:  # set upload if not found target file yet
-						target_drive_found = True
-						upload_disk = final_drive_name
-					if target_filename in volume_info:
-						if not target_file_found:
-							upload_disk = final_drive_name
-						target_file_found = True
-
-		elif current_OS == 'Linux':
-			#
-			# platformio.ini will accept this for a Linux upload port designation: 'upload_port = /media/media_name/drive'
-			#
-			drives = os.listdir(os.path.join(os.sep, 'media', getpass.getuser()))
-			if target_drive in drives:  # If target drive is found, use it.
-				target_drive_found = True
-				upload_disk = os.path.join(os.sep, 'media', getpass.getuser(), target_drive) + os.sep
+		for drive in drives:
+			final_drive_name = drive + ':\\'
+			# print ('disc check: {}'.format(final_drive_name))
+			try:
+				volume_info = str(subprocess.check_output('cmd /C dir ' + final_drive_name, stderr=subprocess.STDOUT))
+			except Exception as e:
+				print ('error:{}'.format(e))
+				continue
 			else:
-				for drive in drives:
-					try:
-						files = os.listdir(os.path.join(os.sep, 'media', getpass.getuser(), drive))
-					except:
-						continue
-					else:
-						if target_filename in files:
-							upload_disk = os.path.join(os.sep, 'media', getpass.getuser(), drive) + os.sep
-							target_file_found = True
-							break
-			#
-			# set upload_port to drive if found
-			#
+				if target_drive in volume_info and not target_file_found:  # set upload if not found target file yet
+					target_drive_found = True
+					upload_disk = final_drive_name
+				if target_filename in volume_info:
+					if not target_file_found:
+						upload_disk = final_drive_name
+					target_file_found = True

-			if target_file_found or target_drive_found:
-				env.Replace(
-					UPLOAD_FLAGS="-P$UPLOAD_PORT"
-				)
-
-		elif current_OS == 'Darwin':  # MAC
-			#
-			# platformio.ini will accept this for a OSX upload port designation: 'upload_port = /media/media_name/drive'
-			#
-			drives = os.listdir('/Volumes')  # human readable names
-			if target_drive in drives and not target_file_found:  # set upload if not found target file yet
-				target_drive_found = True
-				upload_disk = '/Volumes/' + target_drive + '/'
+	elif current_OS == 'Linux':
+		#
+		# platformio.ini will accept this for a Linux upload port designation: 'upload_port = /media/media_name/drive'
+		#
+		drives = os.listdir(os.path.join(os.sep, 'media', getpass.getuser()))
+		if target_drive in drives:  # If target drive is found, use it.
+			target_drive_found = True
+			upload_disk = os.path.join(os.sep, 'media', getpass.getuser(), target_drive) + os.sep
+		else:
 			for drive in drives:
 				try:
-					filenames = os.listdir('/Volumes/' + drive + '/')   # will get an error if the drive is protected
+					files = os.listdir(os.path.join(os.sep, 'media', getpass.getuser(), drive))
 				except:
 					continue
 				else:
-					if target_filename in filenames:
-						if not target_file_found:
-							upload_disk = '/Volumes/' + drive + '/'
+					if target_filename in files:
+						upload_disk = os.path.join(os.sep, 'media', getpass.getuser(), drive) + os.sep
 						target_file_found = True
+						break
+		#
+		# set upload_port to drive if found
+		#

-		#
-		# Set upload_port to drive if found
-		#
 		if target_file_found or target_drive_found:
-			env.Replace(UPLOAD_PORT=upload_disk)
-			print('\nUpload disk: ', upload_disk, '\n')
-		else:
-			print_error('Autodetect Error')
+			env.Replace(
+				UPLOAD_FLAGS="-P$UPLOAD_PORT"
+			)

-	except Exception as e:
-		print_error(str(e))
+	elif current_OS == 'Darwin':  # MAC
+		#
+		# platformio.ini will accept this for a OSX upload port designation: 'upload_port = /media/media_name/drive'
+		#
+		drives = os.listdir('/Volumes')  # human readable names
+		if target_drive in drives and not target_file_found:  # set upload if not found target file yet
+			target_drive_found = True
+			upload_disk = '/Volumes/' + target_drive + '/'
+		for drive in drives:
+			try:
+				filenames = os.listdir('/Volumes/' + drive + '/')   # will get an error if the drive is protected
+			except:
+				continue
+			else:
+				if target_filename in filenames:
+					if not target_file_found:
+						upload_disk = '/Volumes/' + drive + '/'
+					target_file_found = True

-env.AddPreAction("upload", before_upload)
+	#
+	# Set upload_port to drive if found
+	#
+	if target_file_found or target_drive_found:
+		env.Replace(UPLOAD_PORT=upload_disk)
+		print('\nUpload disk: ', upload_disk, '\n')
+	else:
+		print_error('Autodetect Error')
+
+except Exception as e:
+	print_error(str(e))
@@ -29,8 +29,8 @@

 EmergencyParser::State emergency_state;

-bool CDC_RecvCallback(const char c) {
-  emergency_parser.update(emergency_state, c);
+bool CDC_RecvCallback(const char buffer) {
+  emergency_parser.update(emergency_state, buffer);
  return true;
 }

@@ -25,21 +25,8 @@
 #include <wiring_private.h>

 #ifdef ADAFRUIT_GRAND_CENTRAL_M4
-  #if USING_HW_SERIALUSB
-    DefaultSerial1 MSerial0(false, Serial);
-  #endif
-  #if USING_HW_SERIAL0
-    DefaultSerial2 MSerial1(false, Serial1);
-  #endif
-  #if USING_HW_SERIAL1
-    DefaultSerial3 MSerial2(false, Serial2);
-  #endif
-  #if USING_HW_SERIAL2
-    DefaultSerial4 MSerial3(false, Serial3);
-  #endif
-  #if USING_HW_SERIAL3
-    DefaultSerial5 MSerial4(false, Serial4);
-  #endif
+  DefaultSerial MSerial(false, Serial);
+  DefaultSerial1 MSerial1(false, Serial1);
 #endif

 // ------------------------
@@ -57,7 +44,6 @@
 #define GET_PROBE_ADC()           TERN(HAS_TEMP_PROBE,        PIN_TO_ADC(TEMP_PROBE_PIN),   -1)
 #define GET_BED_ADC()             TERN(HAS_TEMP_ADC_BED,      PIN_TO_ADC(TEMP_BED_PIN),     -1)
 #define GET_CHAMBER_ADC()         TERN(HAS_TEMP_ADC_CHAMBER,  PIN_TO_ADC(TEMP_CHAMBER_PIN), -1)
-#define GET_COOLER_ADC()          TERN(HAS_TEMP_ADC_COOLER,   PIN_TO_ADC(TEMP_COOLER_PIN),  -1)
 #define GET_FILAMENT_WIDTH_ADC()  TERN(FILAMENT_WIDTH_SENSOR, PIN_TO_ADC(FILWIDTH_PIN),     -1)
 #define GET_BUTTONS_ADC()         TERN(HAS_ADC_BUTTONS,       PIN_TO_ADC(ADC_KEYPAD_PIN),   -1)

@@ -67,7 +53,6 @@
  || GET_PROBE_ADC() == n          \
  || GET_BED_ADC() == n            \
  || GET_CHAMBER_ADC() == n        \
-  || GET_COOLER_ADC() == n         \
  || GET_FILAMENT_WIDTH_ADC() == n \
  || GET_BUTTONS_ADC() == n        \
 )
@@ -146,9 +131,6 @@ uint16_t HAL_adc_result;
    #if GET_CHAMBER_ADC() == 0
      TEMP_CHAMBER_PIN,
    #endif
-    #if GET_COOLER_ADC() == 0
-      TEMP_COOLER_PIN,
-    #endif
    #if GET_FILAMENT_WIDTH_ADC() == 0
      FILWIDTH_PIN,
    #endif
@@ -189,9 +171,6 @@ uint16_t HAL_adc_result;
    #if GET_CHAMBER_ADC() == 1
      TEMP_CHAMBER_PIN,
    #endif
-    #if GET_COOLER_ADC() == 1
-      TEMP_COOLER_PIN,
-    #endif
    #if GET_FILAMENT_WIDTH_ADC() == 1
      FILWIDTH_PIN,
    #endif
@@ -240,9 +219,6 @@ uint16_t HAL_adc_result;
      #if GET_CHAMBER_ADC() == 0
        { PIN_TO_INPUTCTRL(TEMP_CHAMBER_PIN) },
      #endif
-      #if GET_COOLER_ADC() == 0
-        { PIN_TO_INPUTCTRL(TEMP_COOLER_PIN) },
-      #endif
      #if GET_FILAMENT_WIDTH_ADC() == 0
        { PIN_TO_INPUTCTRL(FILWIDTH_PIN) },
      #endif
@@ -292,9 +268,6 @@ uint16_t HAL_adc_result;
      #if GET_CHAMBER_ADC() == 1
        { PIN_TO_INPUTCTRL(TEMP_CHAMBER_PIN) },
      #endif
-      #if GET_COOLER_ADC() == 1
-        { PIN_TO_INPUTCTRL(TEMP_COOLER_PIN) },
-      #endif
      #if GET_FILAMENT_WIDTH_ADC() == 1
        { PIN_TO_INPUTCTRL(FILWIDTH_PIN) },
      #endif
@@ -436,8 +409,6 @@ uint8_t HAL_get_reset_source() {
 }
 #pragma pop_macro("WDT")

-void HAL_reboot() { NVIC_SystemReset(); }
-
 extern "C" {
  void * _sbrk(int incr);

@@ -32,56 +32,52 @@
  #include "MarlinSerial_AGCM4.h"

  // Serial ports
-  typedef ForwardSerial1Class< decltype(Serial) > DefaultSerial1;
-  typedef ForwardSerial1Class< decltype(Serial1) > DefaultSerial2;
-  typedef ForwardSerial1Class< decltype(Serial2) > DefaultSerial3;
-  typedef ForwardSerial1Class< decltype(Serial3) > DefaultSerial4;
-  typedef ForwardSerial1Class< decltype(Serial4) > DefaultSerial5;
-  extern DefaultSerial1 MSerial0;
-  extern DefaultSerial2 MSerial1;
-  extern DefaultSerial3 MSerial2;
-  extern DefaultSerial4 MSerial3;
-  extern DefaultSerial5 MSerial4;
+  typedef ForwardSerial0Type< decltype(Serial) > DefaultSerial;
+  extern DefaultSerial MSerial;
+  typedef ForwardSerial0Type< decltype(Serial1) > DefaultSerial1;
+  extern DefaultSerial1 MSerial1;
+
+  // MYSERIAL0 required before MarlinSerial includes!

  #define __MSERIAL(X) MSerial##X
  #define _MSERIAL(X) __MSERIAL(X)
  #define MSERIAL(X) _MSERIAL(INCREMENT(X))

  #if SERIAL_PORT == -1
-    #define MYSERIAL1 MSerial0
+    #define MYSERIAL0 MSerial
  #elif WITHIN(SERIAL_PORT, 0, 3)
-    #define MYSERIAL1 MSERIAL(SERIAL_PORT)
+    #define MYSERIAL0 MSERIAL(SERIAL_PORT)
  #else
-    #error "SERIAL_PORT must be from 0 to 3. You can also use -1 if the board supports Native USB."
+    #error "SERIAL_PORT must be from -1 to 3. Please update your configuration."
  #endif

  #ifdef SERIAL_PORT_2
    #if SERIAL_PORT_2 == -1
-      #define MYSERIAL2 MSerial0
+      #define MYSERIAL1 MSerial
    #elif WITHIN(SERIAL_PORT_2, 0, 3)
-      #define MYSERIAL2 MSERIAL(SERIAL_PORT_2)
+      #define MYSERIAL1 MSERIAL(SERIAL_PORT_2)
    #else
-      #error "SERIAL_PORT_2 must be from 0 to 3. You can also use -1 if the board supports Native USB."
+      #error "SERIAL_PORT_2 must be from -1 to 3. Please update your configuration."
    #endif
  #endif

  #ifdef MMU2_SERIAL_PORT
    #if MMU2_SERIAL_PORT == -1
-      #define MMU2_SERIAL MSerial0
+      #define MMU2_SERIAL MSerial
    #elif WITHIN(MMU2_SERIAL_PORT, 0, 3)
      #define MMU2_SERIAL MSERIAL(MMU2_SERIAL_PORT)
    #else
-      #error "MMU2_SERIAL_PORT must be from 0 to 3. You can also use -1 if the board supports Native USB."
+      #error "MMU2_SERIAL_PORT must be from -1 to 3. Please update your configuration."
    #endif
  #endif

  #ifdef LCD_SERIAL_PORT
    #if LCD_SERIAL_PORT == -1
-      #define LCD_SERIAL MSerial0
+      #define LCD_SERIAL MSerial
    #elif WITHIN(LCD_SERIAL_PORT, 0, 3)
      #define LCD_SERIAL MSERIAL(LCD_SERIAL_PORT)
    #else
-      #error "LCD_SERIAL_PORT must be from 0 to 3. You can also use -1 if the board supports Native USB."
+      #error "LCD_SERIAL_PORT must be from -1 to 3. Please update your configuration."
    #endif
  #endif

@@ -107,7 +103,7 @@ typedef int8_t pin_t;
 void HAL_clear_reset_source();  // clear reset reason
 uint8_t HAL_get_reset_source(); // get reset reason

-void HAL_reboot();
+inline void HAL_reboot() {}  // reboot the board or restart the bootloader

 //
 // ADC
@@ -103,7 +103,7 @@
   * @param  nbyte Number of bytes to receive.
   * @return Nothing
   */
-  void spiRead(uint8_t *buf, uint16_t nbyte) {
+  void spiRead(uint8_t* buf, uint16_t nbyte) {
    if (nbyte == 0) return;
    memset(buf, 0xFF, nbyte);
    sdSPI.beginTransaction(spiConfig);
@@ -132,7 +132,7 @@
   *
   * @details Uses DMA
   */
-  void spiSendBlock(uint8_t token, const uint8_t *buf) {
+  void spiSendBlock(uint8_t token, const uint8_t* buf) {
    sdSPI.beginTransaction(spiConfig);
    sdSPI.transfer(token);
    sdSPI.transfer((uint8_t*)buf, nullptr, 512);
@@ -27,7 +27,7 @@

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

-#if USING_HW_SERIAL1
+#if ANY_SERIAL_IS(1)
  UartT Serial2(false, &sercom4, PIN_SERIAL2_RX, PIN_SERIAL2_TX, PAD_SERIAL2_RX, PAD_SERIAL2_TX);
  void SERCOM4_0_Handler() { Serial2.IrqHandler(); }
  void SERCOM4_1_Handler() { Serial2.IrqHandler(); }
@@ -35,7 +35,7 @@
  void SERCOM4_3_Handler() { Serial2.IrqHandler(); }
 #endif

-#if USING_HW_SERIAL2
+#if ANY_SERIAL_IS(2)
  UartT Serial3(false, &sercom1, PIN_SERIAL3_RX, PIN_SERIAL3_TX, PAD_SERIAL3_RX, PAD_SERIAL3_TX);
  void SERCOM1_0_Handler() { Serial3.IrqHandler(); }
  void SERCOM1_1_Handler() { Serial3.IrqHandler(); }
@@ -43,7 +43,7 @@
  void SERCOM1_3_Handler() { Serial3.IrqHandler(); }
 #endif

-#if USING_HW_SERIAL3
+#if ANY_SERIAL_IS(3)
  UartT Serial4(false, &sercom5, PIN_SERIAL4_RX, PIN_SERIAL4_TX, PAD_SERIAL4_RX, PAD_SERIAL4_TX);
  void SERCOM5_0_Handler() { Serial4.IrqHandler(); }
  void SERCOM5_1_Handler() { Serial4.IrqHandler(); }
@@ -22,7 +22,7 @@

 #include "../../core/serial_hook.h"

-typedef Serial1Class<Uart> UartT;
+typedef Serial0Type<Uart> UartT;

 extern UartT Serial2;
 extern UartT Serial3;
@@ -41,13 +41,12 @@ bool PersistentStore::access_start()  { eeprom_init(); return true; }
 bool PersistentStore::access_finish() { return true; }

 bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
-  uint16_t written = 0;
  while (size--) {
    const uint8_t v = *value;
    uint8_t * const p = (uint8_t * const)pos;
-    if (v != eeprom_read_byte(p)) { // EEPROM has only ~100,000 write cycles, so only write bytes that have changed!
+    if (v != eeprom_read_byte(p)) {
      eeprom_write_byte(p, v);
-      if (++written & 0x7F) delay(2); else safe_delay(2); // Avoid triggering watchdog during long EEPROM writes
+      delay(2);
      if (eeprom_read_byte(p) != v) {
        SERIAL_ECHO_MSG(STR_ERR_EEPROM_WRITE);
        return true;
@@ -50,7 +50,3 @@
 #if ENABLED(FAST_PWM_FAN) || SPINDLE_LASER_FREQUENCY
  #error "Features requiring Hardware PWM (FAST_PWM_FAN, SPINDLE_LASER_FREQUENCY) are not yet supported on SAMD51."
 #endif
-
-#if ENABLED(POSTMORTEM_DEBUGGING)
-  #error "POSTMORTEM_DEBUGGING is not yet supported on AGCM4."
-#endif
@@ -29,7 +29,7 @@
 #include "../shared/Delay.h"

 #ifdef USBCON
-  DefaultSerial1 MSerial0(false, SerialUSB);
+  DefaultSerial MSerial(false, SerialUSB);
 #endif

 #if ENABLED(SRAM_EEPROM_EMULATION)
@@ -57,18 +57,10 @@ uint16_t HAL_adc_result;
 // Public functions
 // ------------------------

-TERN_(POSTMORTEM_DEBUGGING, extern void install_min_serial());
-
 // HAL initialization task
 void HAL_init() {
  FastIO_init();

-  // Ensure F_CPU is a constant expression.
-  // If the compiler breaks here, it means that delay code that should compute at compile time will not work.
-  // So better safe than sorry here.
-  constexpr int cpuFreq = F_CPU;
-  UNUSED(cpuFreq);
-
  #if ENABLED(SDSUPPORT) && DISABLED(SDIO_SUPPORT) && (defined(SDSS) && SDSS != -1)
    OUT_WRITE(SDSS, HIGH); // Try to set SDSS inactive before any other SPI users start up
  #endif
@@ -91,17 +83,9 @@ void HAL_init() {
    USB_Hook_init();
  #endif

-  TERN_(POSTMORTEM_DEBUGGING, install_min_serial()); // Install the min serial handler
-
  #if HAS_SD_HOST_DRIVE
    MSC_SD_init();                         // Enable USB SD card access
  #endif
-
-  #if PIN_EXISTS(USB_CONNECT)
-    OUT_WRITE(USB_CONNECT_PIN, !USB_CONNECT_INVERTING);  // USB clear connection
-    delay(1000);                                         // Give OS time to notice
-    WRITE(USB_CONNECT_PIN, USB_CONNECT_INVERTING);
-  #endif
 }

 // HAL idle task
@@ -139,8 +123,6 @@ uint8_t HAL_get_reset_source() {
  ;
 }

-void HAL_reboot() { NVIC_SystemReset(); }
-
 void _delay_ms(const int delay_ms) { delay(delay_ms); }

 extern "C" {
@@ -155,8 +137,8 @@ extern "C" {
 void HAL_adc_start_conversion(const uint8_t adc_pin) { HAL_adc_result = analogRead(adc_pin); }
 uint16_t HAL_adc_get_result() { return HAL_adc_result; }

-// Reset the system to initiate a firmware flash
-void flashFirmware(const int16_t) { HAL_reboot(); }
+// Reset the system (to initiate a firmware flash)
+void flashFirmware(const int16_t) { NVIC_SystemReset(); }

 // Maple Compatibility
 volatile uint32_t systick_uptime_millis = 0;
@@ -37,66 +37,56 @@

 #include <stdint.h>

-//
-// Serial Ports
-//
 #ifdef USBCON
  #include <USBSerial.h>
  #include "../../core/serial_hook.h"
-  typedef ForwardSerial1Class< decltype(SerialUSB) > DefaultSerial1;
-  extern DefaultSerial1 MSerial0;
+  typedef ForwardSerial0Type< decltype(SerialUSB) > DefaultSerial;
+  extern DefaultSerial MSerial;
 #endif

+// ------------------------
+// Defines
+// ------------------------
 #define _MSERIAL(X) MSerial##X
 #define MSERIAL(X) _MSERIAL(X)

 #if SERIAL_PORT == -1
-  #define MYSERIAL1 MSerial0
+  #define MYSERIAL0 MSerial
 #elif WITHIN(SERIAL_PORT, 1, 6)
-  #define MYSERIAL1 MSERIAL(SERIAL_PORT)
+  #define MYSERIAL0 MSERIAL(SERIAL_PORT)
 #else
-  #error "SERIAL_PORT must be from 1 to 6. You can also use -1 if the board supports Native USB."
+  #error "SERIAL_PORT must be -1 or from 1 to 6. Please update your configuration."
 #endif

 #ifdef SERIAL_PORT_2
  #if SERIAL_PORT_2 == -1
-    #define MYSERIAL2 MSerial0
+    #define MYSERIAL1 MSerial
  #elif WITHIN(SERIAL_PORT_2, 1, 6)
-    #define MYSERIAL2 MSERIAL(SERIAL_PORT_2)
+    #define MYSERIAL1 MSERIAL(SERIAL_PORT_2)
  #else
-    #error "SERIAL_PORT_2 must be from 1 to 6. You can also use -1 if the board supports Native USB."
-  #endif
-#endif
-
-#ifdef SERIAL_PORT_3
-  #if SERIAL_PORT_3 == -1
-    #define MYSERIAL3 MSerial0
-  #elif WITHIN(SERIAL_PORT_3, 1, 6)
-    #define MYSERIAL3 MSERIAL(SERIAL_PORT_3)
-  #else
-    #error "SERIAL_PORT_3 must be from 1 to 6. You can also use -1 if the board supports Native USB."
+    #error "SERIAL_PORT_2 must be -1 or from 1 to 6. Please update your configuration."
  #endif
 #endif

 #ifdef MMU2_SERIAL_PORT
  #if MMU2_SERIAL_PORT == -1
-    #define MMU2_SERIAL MSerial0
+    #define MMU2_SERIAL MSerial
  #elif WITHIN(MMU2_SERIAL_PORT, 1, 6)
    #define MMU2_SERIAL MSERIAL(MMU2_SERIAL_PORT)
  #else
-    #error "MMU2_SERIAL_PORT must be from 1 to 6. You can also use -1 if the board supports Native USB."
+    #error "MMU2_SERIAL_PORT must be -1 or from 1 to 6. Please update your configuration."
  #endif
 #endif

 #ifdef LCD_SERIAL_PORT
  #if LCD_SERIAL_PORT == -1
-    #define LCD_SERIAL MSerial0
+    #define LCD_SERIAL MSerial
  #elif WITHIN(LCD_SERIAL_PORT, 1, 6)
    #define LCD_SERIAL MSERIAL(LCD_SERIAL_PORT)
  #else
-    #error "LCD_SERIAL_PORT must be from 1 to 6. You can also use -1 if the board supports Native USB."
+    #error "LCD_SERIAL_PORT must be -1 or from 1 to 6. Please update your configuration."
  #endif
-  #if HAS_DGUS_LCD
+  #if HAS_DGUS_LCD || ENABLED(DGUS_LCD_UI_CREALITY_TOUCH)
    #define SERIAL_GET_TX_BUFFER_FREE() LCD_SERIAL.availableForWrite()
  #endif
 #endif
@@ -154,7 +144,7 @@ void HAL_clear_reset_source();
 // Reset reason
 uint8_t HAL_get_reset_source();

-void HAL_reboot();
+inline void HAL_reboot() {}  // reboot the board or restart the bootloader

 void _delay_ms(const int delay);

@@ -1,152 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- * Copyright (c) 2017 Victor Perez
- *
- * 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/>.
- *
- */
-#if defined(ARDUINO_ARCH_STM32) && !defined(STM32GENERIC)
-
-#include "../../inc/MarlinConfigPre.h"
-
-#if ENABLED(POSTMORTEM_DEBUGGING)
-
-#include "../shared/HAL_MinSerial.h"
-#include "watchdog.h"
-
-/* Instruction Synchronization Barrier */
-#define isb() __asm__ __volatile__ ("isb" : : : "memory")
-
-/* Data Synchronization Barrier */
-#define dsb() __asm__ __volatile__ ("dsb" : : : "memory")
-
-// Dumb mapping over the registers of a USART device on STM32
-struct USARTMin {
-  volatile uint32_t SR;
-  volatile uint32_t DR;
-  volatile uint32_t BRR;
-  volatile uint32_t CR1;
-  volatile uint32_t CR2;
-};
-
-#if WITHIN(SERIAL_PORT, 1, 6)
-  // Depending on the CPU, the serial port is different for USART1
-  static const uintptr_t regsAddr[] = {
-    TERN(STM32F1xx, 0x40013800, 0x40011000), // USART1
-    0x40004400, // USART2
-    0x40004800, // USART3
-    0x40004C00, // UART4_BASE
-    0x40005000, // UART5_BASE
-    0x40011400  // USART6
-  };
-  static USARTMin * regs = (USARTMin*)regsAddr[SERIAL_PORT - 1];
-#endif
-
-static void TXBegin() {
-  #if !WITHIN(SERIAL_PORT, 1, 6)
-    #warning "Using POSTMORTEM_DEBUGGING requires a physical U(S)ART hardware in case of severe error."
-    #warning "Disabling the severe error reporting feature currently because the used serial port is not a HW port."
-  #else
-    // This is common between STM32F1/STM32F2 and STM32F4
-    const int nvicUART[] = { /* NVIC_USART1 */ 37, /* NVIC_USART2 */ 38, /* NVIC_USART3 */ 39, /* NVIC_UART4 */ 52, /* NVIC_UART5 */ 53, /* NVIC_USART6 */ 71 };
-    int nvicIndex = nvicUART[SERIAL_PORT - 1];
-
-    struct NVICMin {
-      volatile uint32_t ISER[32];
-      volatile uint32_t ICER[32];
-    };
-
-    NVICMin *nvicBase = (NVICMin*)0xE000E100;
-    SBI32(nvicBase->ICER[nvicIndex >> 5], nvicIndex & 0x1F);
-
-    // We NEED memory barriers to ensure Interrupts are actually disabled!
-    // ( https://dzone.com/articles/nvic-disabling-interrupts-on-arm-cortex-m-and-the )
-    dsb();
-    isb();
-
-    // Example for USART1 disable:  (RCC->APB2ENR &= ~(RCC_APB2ENR_USART1EN))
-    // Too difficult to reimplement here, let's query the STM32duino macro here
-    #if SERIAL_PORT == 1
-      __HAL_RCC_USART1_CLK_DISABLE();
-      __HAL_RCC_USART1_CLK_ENABLE();
-    #elif SERIAL_PORT == 2
-      __HAL_RCC_USART2_CLK_DISABLE();
-      __HAL_RCC_USART2_CLK_ENABLE();
-    #elif SERIAL_PORT == 3
-      __HAL_RCC_USART3_CLK_DISABLE();
-      __HAL_RCC_USART3_CLK_ENABLE();
-    #elif SERIAL_PORT == 4
-      __HAL_RCC_UART4_CLK_DISABLE(); // BEWARE: UART4 and not USART4 here
-      __HAL_RCC_UART4_CLK_ENABLE();
-    #elif SERIAL_PORT == 5
-      __HAL_RCC_UART5_CLK_DISABLE(); // BEWARE: UART5 and not USART5 here
-      __HAL_RCC_UART5_CLK_ENABLE();
-    #elif SERIAL_PORT == 6
-      __HAL_RCC_USART6_CLK_DISABLE();
-      __HAL_RCC_USART6_CLK_ENABLE();
-    #endif
-
-    uint32_t brr = regs->BRR;
-    regs->CR1 = 0; // Reset the USART
-    regs->CR2 = 0; // 1 stop bit
-
-    // If we don't touch the BRR (baudrate register), we don't need to recompute.
-    regs->BRR = brr;
-
-    regs->CR1 = _BV(3) | _BV(13); // 8 bits, no parity, 1 stop bit (TE | UE)
-  #endif
-}
-
-// A SW memory barrier, to ensure GCC does not overoptimize loops
-#define sw_barrier() __asm__ volatile("": : :"memory");
-static void TX(char c) {
-  #if WITHIN(SERIAL_PORT, 1, 6)
-    constexpr uint32_t usart_sr_txe = _BV(7);
-    while (!(regs->SR & usart_sr_txe)) {
-      TERN_(USE_WATCHDOG, HAL_watchdog_refresh());
-      sw_barrier();
-    }
-    regs->DR = c;
-  #else
-    // Let's hope a mystical guru will fix this, one day by writting interrupt-free USB CDC ACM code (or, at least, by polling the registers since interrupt will be queued but will never trigger)
-    // For now, it's completely lost to oblivion.
-  #endif
-}
-
-void install_min_serial() {
-  HAL_min_serial_init = &TXBegin;
-  HAL_min_serial_out = &TX;
-}
-
-#if DISABLED(DYNAMIC_VECTORTABLE) && DISABLED(STM32F0xx) // Cortex M0 can't jump to a symbol that's too far from the current function, so we work around this in exception_arm.cpp
-extern "C" {
-  __attribute__((naked)) void JumpHandler_ASM() {
-    __asm__ __volatile__ (
-      "b CommonHandler_ASM\n"
-    );
-  }
-  void __attribute__((naked, alias("JumpHandler_ASM"), nothrow)) HardFault_Handler();
-  void __attribute__((naked, alias("JumpHandler_ASM"), nothrow)) BusFault_Handler();
-  void __attribute__((naked, alias("JumpHandler_ASM"), nothrow)) UsageFault_Handler();
-  void __attribute__((naked, alias("JumpHandler_ASM"), nothrow)) MemManage_Handler();
-  void __attribute__((naked, alias("JumpHandler_ASM"), nothrow)) NMI_Handler();
-}
-#endif
-
-#endif // POSTMORTEM_DEBUGGING
-#endif // ARDUINO_ARCH_STM32
@@ -193,7 +193,7 @@ static SPISettings spiConfig;
   *
   * @details Uses DMA
   */
-  void spiRead(uint8_t *buf, uint16_t nbyte) {
+  void spiRead(uint8_t* buf, uint16_t nbyte) {
    if (nbyte == 0) return;
    memset(buf, 0xFF, nbyte);
    SPI.transfer(buf, nbyte);
@@ -218,7 +218,7 @@ static SPISettings spiConfig;
   *
   * @details Use DMA
   */
-  void spiSendBlock(uint8_t token, const uint8_t *buf) {
+  void spiSendBlock(uint8_t token, const uint8_t* buf) {
    uint8_t rxBuf[512];
    SPI.transfer(token);
    SPI.transfer((uint8_t*)buf, &rxBuf, 512);
@@ -19,7 +19,7 @@
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 */
-#if defined(ARDUINO_ARCH_STM32) && !defined(STM32GENERIC) && !defined(STM32H7xx)
+#if defined(ARDUINO_ARCH_STM32) && !defined(STM32GENERIC)

 #include "MarlinSPI.h"

@@ -28,6 +28,7 @@
 #ifndef USART4
  #define USART4 UART4
 #endif
+
 #ifndef USART5
  #define USART5 UART5
 #endif
@@ -37,38 +38,22 @@
  MSerialT MSerial ## ser_num (true, USART ## ser_num, &_rx_complete_irq_ ## ser_num); \
  void _rx_complete_irq_ ## ser_num (serial_t * obj) { MSerial ## ser_num ._rx_complete_irq(obj); }

-#if USING_HW_SERIAL1
-  DECLARE_SERIAL_PORT(1)
+#define DECLARE_SERIAL_PORT_EXP(ser_num) DECLARE_SERIAL_PORT(ser_num)
+
+#if defined(SERIAL_PORT) && SERIAL_PORT >= 0
+  DECLARE_SERIAL_PORT_EXP(SERIAL_PORT)
 #endif
-#if USING_HW_SERIAL2
-  DECLARE_SERIAL_PORT(2)
+
+#if defined(SERIAL_PORT_2) && SERIAL_PORT_2 >= 0
+  DECLARE_SERIAL_PORT_EXP(SERIAL_PORT_2)
 #endif
-#if USING_HW_SERIAL3
-  DECLARE_SERIAL_PORT(3)
+
+#if defined(MMU2_SERIAL_PORT) && MMU2_SERIAL_PORT >= 0
+  DECLARE_SERIAL_PORT_EXP(MMU2_SERIAL_PORT)
 #endif
-#if USING_HW_SERIAL4
-  DECLARE_SERIAL_PORT(4)
-#endif
-#if USING_HW_SERIAL5
-  DECLARE_SERIAL_PORT(5)
-#endif
-#if USING_HW_SERIAL6
-  DECLARE_SERIAL_PORT(6)
-#endif
-#if USING_HW_SERIAL7
-  DECLARE_SERIAL_PORT(7)
-#endif
-#if USING_HW_SERIAL8
-  DECLARE_SERIAL_PORT(8)
-#endif
-#if USING_HW_SERIAL9
-  DECLARE_SERIAL_PORT(9)
-#endif
-#if USING_HW_SERIAL10
-  DECLARE_SERIAL_PORT(10)
-#endif
-#if USING_HW_SERIALLP1
-  DECLARE_SERIAL_PORT(LP1)
+
+#if defined(LCD_SERIAL_PORT) && LCD_SERIAL_PORT >= 0
+  DECLARE_SERIAL_PORT_EXP(LCD_SERIAL_PORT)
 #endif

 void MarlinSerial::begin(unsigned long baud, uint8_t config) {
@@ -29,20 +29,20 @@
 typedef void (*usart_rx_callback_t)(serial_t * obj);

 struct MarlinSerial : public HardwareSerial {
-  MarlinSerial(void *peripheral, usart_rx_callback_t rx_callback) :
+  MarlinSerial(void* peripheral, usart_rx_callback_t rx_callback) :
      HardwareSerial(peripheral), _rx_callback(rx_callback)
  { }

  void begin(unsigned long baud, uint8_t config);
  inline void begin(unsigned long baud) { begin(baud, SERIAL_8N1); }

-  void _rx_complete_irq(serial_t *obj);
+  void _rx_complete_irq(serial_t* obj);

 protected:
  usart_rx_callback_t _rx_callback;
 };

-typedef Serial1Class<MarlinSerial> MSerialT;
+typedef Serial0Type<MarlinSerial> MSerialT;
 extern MSerialT MSerial1;
 extern MSerialT MSerial2;
 extern MSerialT MSerial3;
@@ -36,10 +36,9 @@

  // use USB drivers

-  extern "C" {
-    int8_t SD_MSC_Read(uint8_t lun, uint8_t *buf, uint32_t blk_addr, uint16_t blk_len);
-    int8_t SD_MSC_Write(uint8_t lun, uint8_t *buf, uint32_t blk_addr, uint16_t blk_len);
-    extern SD_HandleTypeDef hsd;
+  extern "C" { int8_t SD_MSC_Read(uint8_t lun, uint8_t *buf, uint32_t blk_addr, uint16_t blk_len);
+               int8_t SD_MSC_Write(uint8_t lun, uint8_t *buf, uint32_t blk_addr, uint16_t blk_len);
+               extern SD_HandleTypeDef hsd;
  }

  bool SDIO_Init() {
@@ -76,18 +75,7 @@
    #error "ERROR - Only STM32F103xE, STM32F103xG, STM32F4xx or STM32F7xx CPUs supported"
  #endif

-  // Fixed
-  #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
-
  SD_HandleTypeDef hsd;  // create SDIO structure
-  // F4 supports one DMA for RX and another for TX, but Marlin will never
-  // do read and write at same time, so we use the same DMA for both.
-  DMA_HandleTypeDef hdma_sdio;

  /*
    SDIO_INIT_CLK_DIV is 118
@@ -108,12 +96,12 @@

  // Target Clock, configurable. Default is 18MHz, from STM32F1
  #ifndef SDIO_CLOCK
-    #define SDIO_CLOCK 18000000 // 18 MHz
+    #define SDIO_CLOCK                         18000000       /* 18 MHz */
  #endif

  // SDIO retries, configurable. Default is 3, from STM32F1
  #ifndef SDIO_READ_RETRIES
-    #define SDIO_READ_RETRIES 3
+    #define SDIO_READ_RETRIES                  3
  #endif

  // SDIO Max Clock (naming from STM Manual, don't change)
@@ -132,21 +120,24 @@
  }

  void go_to_transfer_speed() {
+    SD_InitTypeDef Init;
+
    /* Default SDIO peripheral configuration for SD card initialization */
-    hsd.Init.ClockEdge           = hsd.Init.ClockEdge;
-    hsd.Init.ClockBypass         = hsd.Init.ClockBypass;
-    hsd.Init.ClockPowerSave      = hsd.Init.ClockPowerSave;
-    hsd.Init.BusWide             = hsd.Init.BusWide;
-    hsd.Init.HardwareFlowControl = hsd.Init.HardwareFlowControl;
-    hsd.Init.ClockDiv            = clock_to_divider(SDIO_CLOCK);
+    Init.ClockEdge           = hsd.Init.ClockEdge;
+    Init.ClockBypass         = hsd.Init.ClockBypass;
+    Init.ClockPowerSave      = hsd.Init.ClockPowerSave;
+    Init.BusWide             = hsd.Init.BusWide;
+    Init.HardwareFlowControl = hsd.Init.HardwareFlowControl;
+    Init.ClockDiv            = clock_to_divider(SDIO_CLOCK);

    /* Initialize SDIO peripheral interface with default configuration */
-    SDIO_Init(hsd.Instance, hsd.Init);
+    SDIO_Init(hsd.Instance, Init);
  }

  void SD_LowLevel_Init(void) {
    uint32_t tempreg;

+    __HAL_RCC_SDIO_CLK_ENABLE();
    __HAL_RCC_GPIOC_CLK_ENABLE(); //enable GPIO clocks
    __HAL_RCC_GPIOD_CLK_ENABLE(); //enable GPIO clocks

@@ -172,45 +163,11 @@
    GPIO_InitStruct.Pin = GPIO_PIN_2;
    HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);

-    // Setup DMA
-    #if defined(STM32F1xx)
-      hdma_sdio.Init.Mode = DMA_NORMAL;
-      hdma_sdio.Instance = DMA2_Channel4;
-      HAL_NVIC_EnableIRQ(DMA2_Channel4_5_IRQn);
-    #elif defined(STM32F4xx)
-      hdma_sdio.Init.Mode = DMA_PFCTRL;
-      hdma_sdio.Instance = DMA2_Stream3;
-      hdma_sdio.Init.Channel = DMA_CHANNEL_4;
-      hdma_sdio.Init.FIFOMode = DMA_FIFOMODE_ENABLE;
-      hdma_sdio.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;
-      hdma_sdio.Init.MemBurst = DMA_MBURST_INC4;
-      hdma_sdio.Init.PeriphBurst = DMA_PBURST_INC4;
-      HAL_NVIC_EnableIRQ(DMA2_Stream3_IRQn);
-    #endif
-    HAL_NVIC_EnableIRQ(SDIO_IRQn);
-    hdma_sdio.Init.PeriphInc = DMA_PINC_DISABLE;
-    hdma_sdio.Init.MemInc = DMA_MINC_ENABLE;
-    hdma_sdio.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
-    hdma_sdio.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
-    hdma_sdio.Init.Priority = DMA_PRIORITY_LOW;
-    __HAL_LINKDMA(&hsd, hdmarx, hdma_sdio);
-    __HAL_LINKDMA(&hsd, hdmatx, hdma_sdio);
-
-    #if defined(STM32F1xx)
-      __HAL_RCC_SDIO_CLK_ENABLE();
-      __HAL_RCC_DMA2_CLK_ENABLE();
-    #else
-      __HAL_RCC_SDIO_FORCE_RESET();
-      delay(2);
-      __HAL_RCC_SDIO_RELEASE_RESET();
-      delay(2);
-      __HAL_RCC_SDIO_CLK_ENABLE();
-
-      __HAL_RCC_DMA2_FORCE_RESET();
-      delay(2);
-      __HAL_RCC_DMA2_RELEASE_RESET();
-      delay(2);
-      __HAL_RCC_DMA2_CLK_ENABLE();
+    #if DISABLED(STM32F1xx)
+      // TODO: use __HAL_RCC_SDIO_RELEASE_RESET() and __HAL_RCC_SDIO_CLK_ENABLE();
+      RCC->APB2RSTR &= ~RCC_APB2RSTR_SDIORST_Msk;  // take SDIO out of reset
+      RCC->APB2ENR  |=  RCC_APB2RSTR_SDIORST_Msk;  // enable SDIO clock
+      // Enable the DMA2 Clock
    #endif

    //Initialize the SDIO (with initial <400Khz Clock)
@@ -222,7 +179,6 @@

    // Power up the SDIO
    SDIO_PowerState_ON(SDIO);
-    hsd.Instance = SDIO;
  }

  void HAL_SD_MspInit(SD_HandleTypeDef *hsd) { // application specific init
@@ -266,81 +222,107 @@
          if (!status) break;
          if (!--retry_Cnt) return false;   // return failing status if retries are exhausted
        }
-        go_to_transfer_speed();
      }
    #endif

    return true;
  }
+  /*
+  void init_SDIO_pins(void) {
+    GPIO_InitTypeDef GPIO_InitStruct = {0};

-  static bool SDIO_ReadWriteBlock_DMA(uint32_t block, const uint8_t *src, uint8_t *dst) {
-    if (HAL_SD_GetCardState(&hsd) != HAL_SD_CARD_TRANSFER) return false;
+    // SDIO GPIO Configuration
+    // PC8     ------> SDIO_D0
+    // PC12    ------> SDIO_CK
+    // PD2     ------> SDIO_CMD

-    TERN_(USE_WATCHDOG, HAL_watchdog_refresh());
+    GPIO_InitStruct.Pin = GPIO_PIN_8;
+    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+    GPIO_InitStruct.Pull = GPIO_NOPULL;
+    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
+    GPIO_InitStruct.Alternate = GPIO_AF12_SDIO;
+    HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

-    HAL_StatusTypeDef ret;
-    if (src) {
-      hdma_sdio.Init.Direction = DMA_MEMORY_TO_PERIPH;
-      HAL_DMA_Init(&hdma_sdio);
-      ret = HAL_SD_WriteBlocks_DMA(&hsd, (uint8_t *)src, block, 1);
-    }
-    else {
-      hdma_sdio.Init.Direction = DMA_PERIPH_TO_MEMORY;
-      HAL_DMA_Init(&hdma_sdio);
-      ret = HAL_SD_ReadBlocks_DMA(&hsd, (uint8_t *)dst, block, 1);
+    GPIO_InitStruct.Pin = GPIO_PIN_12;
+    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+    GPIO_InitStruct.Pull = GPIO_NOPULL;
+    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
+    GPIO_InitStruct.Alternate = GPIO_AF12_SDIO;
+    HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
+
+    GPIO_InitStruct.Pin = GPIO_PIN_2;
+    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+    GPIO_InitStruct.Pull = GPIO_NOPULL;
+    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
+    GPIO_InitStruct.Alternate = GPIO_AF12_SDIO;
+    HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
+  }
+  */
+  //bool SDIO_init() { return (bool) (SD_SDIO_Init() ? 1 : 0);}
+  //bool SDIO_Init_C() { return (bool) (SD_SDIO_Init() ? 1 : 0);}
+
+  bool SDIO_ReadBlock(uint32_t block, uint8_t *dst) {
+    hsd.Instance = SDIO;
+    uint8_t retryCnt = SDIO_READ_RETRIES;
+
+    bool status;
+    for (;;) {
+      TERN_(USE_WATCHDOG, HAL_watchdog_refresh());
+      status = (bool) HAL_SD_ReadBlocks(&hsd, (uint8_t*)dst, block, 1, 1000);  // read one 512 byte block with 500mS timeout
+      status |= (bool) HAL_SD_GetCardState(&hsd);     // make sure all is OK
+      if (!status) break;       // return passing status
+      if (!--retryCnt) break;   // return failing status if retries are exhausted
    }
+    return status;

-    if (ret != HAL_OK) {
-      HAL_DMA_Abort_IT(&hdma_sdio);
-      HAL_DMA_DeInit(&hdma_sdio);
+    /*
+    return (bool) ((status_read | status_card) ? 1 : 0);
+
+    if (SDIO_GetCardState() != SDIO_CARD_TRANSFER) return false;
+    if (blockAddress >= SdCard.LogBlockNbr) return false;
+    if ((0x03 & (uint32_t)data)) return false; // misaligned data
+
+    if (SdCard.CardType != CARD_SDHC_SDXC) { blockAddress *= 512U; }
+
+    if (!SDIO_CmdReadSingleBlock(blockAddress)) {
+      SDIO_CLEAR_FLAG(SDIO_ICR_CMD_FLAGS);
+      dma_disable(SDIO_DMA_DEV, SDIO_DMA_CHANNEL);
      return false;
    }

-    millis_t timeout = millis() + 500;
-    // Wait the transfer
-    while (hsd.State != HAL_SD_STATE_READY) {
-      if (ELAPSED(millis(), timeout)) {
-        HAL_DMA_Abort_IT(&hdma_sdio);
-        HAL_DMA_DeInit(&hdma_sdio);
-        return false;
-      }
+    while (!SDIO_GET_FLAG(SDIO_STA_DATAEND | SDIO_STA_TRX_ERROR_FLAGS)) {}
+
+    dma_disable(SDIO_DMA_DEV, SDIO_DMA_CHANNEL);
+
+    if (SDIO->STA & SDIO_STA_RXDAVL) {
+      while (SDIO->STA & SDIO_STA_RXDAVL) (void)SDIO->FIFO;
+      SDIO_CLEAR_FLAG(SDIO_ICR_CMD_FLAGS | SDIO_ICR_DATA_FLAGS);
+      return false;
    }

-    while (__HAL_DMA_GET_FLAG(&hdma_sdio, __HAL_DMA_GET_TC_FLAG_INDEX(&hdma_sdio)) != 0
-        || __HAL_DMA_GET_FLAG(&hdma_sdio, __HAL_DMA_GET_TE_FLAG_INDEX(&hdma_sdio)) != 0) { /* nada */ }
-
-    HAL_DMA_Abort_IT(&hdma_sdio);
-    HAL_DMA_DeInit(&hdma_sdio);
-
-    timeout = millis() + 500;
-    while (HAL_SD_GetCardState(&hsd) != HAL_SD_CARD_TRANSFER) if (ELAPSED(millis(), timeout)) return false;
+    if (SDIO_GET_FLAG(SDIO_STA_TRX_ERROR_FLAGS)) {
+      SDIO_CLEAR_FLAG(SDIO_ICR_CMD_FLAGS | SDIO_ICR_DATA_FLAGS);
+      return false;
+    }
+    SDIO_CLEAR_FLAG(SDIO_ICR_CMD_FLAGS | SDIO_ICR_DATA_FLAGS);
+    */

    return true;
  }

-  bool SDIO_ReadBlock(uint32_t block, uint8_t *dst) {
-    uint8_t retries = SDIO_READ_RETRIES;
-    while (retries--) if (SDIO_ReadWriteBlock_DMA(block, NULL, dst)) return true;
-    return false;
-  }
-
  bool SDIO_WriteBlock(uint32_t block, const uint8_t *src) {
-    uint8_t retries = SDIO_READ_RETRIES;
-    while (retries--) if (SDIO_ReadWriteBlock_DMA(block, src, NULL)) return true;
-    return false;
+    hsd.Instance = SDIO;
+    uint8_t retryCnt = SDIO_READ_RETRIES;
+    bool status;
+    for (;;) {
+      status = (bool) HAL_SD_WriteBlocks(&hsd, (uint8_t*)src, block, 1, 500);  // write one 512 byte block with 500mS timeout
+      status |= (bool) HAL_SD_GetCardState(&hsd);     // make sure all is OK
+      if (!status) break;       // return passing status
+      if (!--retryCnt) break;   // return failing status if retries are exhausted
+    }
+    return status;
  }

-  #if defined(STM32F1xx)
-    #define DMA_IRQ_HANDLER DMA2_Channel4_5_IRQHandler
-  #elif defined(STM32F4xx)
-    #define DMA_IRQ_HANDLER DMA2_Stream3_IRQHandler
-  #else
-    #error "Unknown STM32 architecture."
-  #endif
-
-  extern "C" void SDIO_IRQHandler(void) { HAL_SD_IRQHandler(&hsd); }
-  extern "C" void DMA_IRQ_HANDLER(void) { HAL_DMA_IRQHandler(&hdma_sdio); }
-
 #endif // !USBD_USE_CDC_COMPOSITE
 #endif // SDIO_SUPPORT
 #endif // ARDUINO_ARCH_STM32 && !STM32GENERIC
@@ -48,7 +48,7 @@
  #include "stm32_def.h"

  #define DEBUG_OUT ENABLED(EEPROM_CHITCHAT)
-  #include "../../core/debug_out.h"
+  #include "src/core/debug_out.h"

  #ifndef MARLIN_EEPROM_SIZE
    #define MARLIN_EEPROM_SIZE    0x1000 // 4KB
@@ -43,22 +43,25 @@ bool PersistentStore::access_start()  { eeprom_init(); return true; }
 bool PersistentStore::access_finish() { return true; }

 bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
-  uint16_t written = 0;
  while (size--) {
    uint8_t v = *value;
+
+    // EEPROM has only ~100,000 write cycles,
+    // so only write bytes that have changed!
    uint8_t * const p = (uint8_t * const)pos;
-    if (v != eeprom_read_byte(p)) { // EEPROM has only ~100,000 write cycles, so only write bytes that have changed!
+    if (v != eeprom_read_byte(p)) {
      eeprom_write_byte(p, v);
-      if (++written & 0x7F) delay(2); else safe_delay(2); // Avoid triggering watchdog during long EEPROM writes
      if (eeprom_read_byte(p) != v) {
        SERIAL_ECHO_MSG(STR_ERR_EEPROM_WRITE);
        return true;
      }
    }
+
    crc16(crc, &v, 1);
    pos++;
    value++;
-  }
+  };
+
  return false;
 }

@@ -24,9 +24,3 @@
 #if defined(USBD_USE_CDC_MSC) && DISABLED(NO_SD_HOST_DRIVE)
  #define HAS_SD_HOST_DRIVE 1
 #endif
-
-// Fix F_CPU not being a compile-time constant in STSTM32 framework
-#ifdef BOARD_F_CPU
-  #undef F_CPU
-  #define F_CPU BOARD_F_CPU
-#endif
@@ -47,11 +47,11 @@
 #endif

 #if ENABLED(SERIAL_STATS_MAX_RX_QUEUED)
-  #error "SERIAL_STATS_MAX_RX_QUEUED is not supported on STM32."
+  #error "SERIAL_STATS_MAX_RX_QUEUED is not supported on this platform."
 #elif ENABLED(SERIAL_STATS_DROPPED_RX)
-  #error "SERIAL_STATS_DROPPED_RX is not supported on STM32."
+  #error "SERIAL_STATS_DROPPED_RX is not supported on this platform."
 #endif

-#if ANY(TFT_COLOR_UI, TFT_LVGL_UI, TFT_CLASSIC_UI) && NOT_TARGET(STM32H7xx, STM32F4xx, STM32F1xx)
-  #error "TFT_COLOR_UI, TFT_LVGL_UI and TFT_CLASSIC_UI are currently only supported on STM32H7, STM32F4 and STM32F1 hardware."
+#if ANY(TFT_COLOR_UI, TFT_LVGL_UI, TFT_CLASSIC_UI) && NOT_TARGET(STM32F4xx, STM32F1xx)
+  #error "TFT_COLOR_UI, TFT_LVGL_UI and TFT_CLASSIC_UI are currently only supported on STM32F4 and STM32F1 hardware."
 #endif
@@ -30,66 +30,54 @@

 class Sd2CardUSBMscHandler : public USBMscHandler {
 public:
-  DiskIODriver* diskIODriver() {
-    #if ENABLED(MULTI_VOLUME)
-      #if SHARED_VOLUME_IS(SD_ONBOARD)
-        return &card.media_sd_spi;
-      #elif SHARED_VOLUME_IS(USB_FLASH_DRIVE)
-        return &card.media_usbFlashDrive;
-      #endif
-    #else
-      return card.diskIODriver();
-    #endif
-  }
-
  bool GetCapacity(uint32_t *pBlockNum, uint16_t *pBlockSize) {
-    *pBlockNum = diskIODriver()->cardSize();
+    *pBlockNum = card.getSd2Card().cardSize();
    *pBlockSize = BLOCK_SIZE;
    return true;
  }

  bool Write(uint8_t *pBuf, uint32_t blkAddr, uint16_t blkLen) {
-    auto sd2card = diskIODriver();
+    auto sd2card = card.getSd2Card();
    // single block
    if (blkLen == 1) {
      watchdog_refresh();
-      sd2card->writeBlock(blkAddr, pBuf);
+      sd2card.writeBlock(blkAddr, pBuf);
      return true;
    }

    // multi block optmization
-    sd2card->writeStart(blkAddr, blkLen);
+    sd2card.writeStart(blkAddr, blkLen);
    while (blkLen--) {
      watchdog_refresh();
-      sd2card->writeData(pBuf);
+      sd2card.writeData(pBuf);
      pBuf += BLOCK_SIZE;
    }
-    sd2card->writeStop();
+    sd2card.writeStop();
    return true;
  }

  bool Read(uint8_t *pBuf, uint32_t blkAddr, uint16_t blkLen) {
-    auto sd2card = diskIODriver();
+    auto sd2card = card.getSd2Card();
    // single block
    if (blkLen == 1) {
      watchdog_refresh();
-      sd2card->readBlock(blkAddr, pBuf);
+      sd2card.readBlock(blkAddr, pBuf);
      return true;
    }

    // multi block optmization
-    sd2card->readStart(blkAddr);
+    sd2card.readStart(blkAddr);
    while (blkLen--) {
      watchdog_refresh();
-      sd2card->readData(pBuf);
+      sd2card.readData(pBuf);
      pBuf += BLOCK_SIZE;
    }
-    sd2card->readStop();
+    sd2card.readStop();
    return true;
  }

  bool IsReady() {
-    return diskIODriver()->isReady();
+    return card.isMounted();
  }
 };

@@ -117,8 +105,8 @@ USBMscHandler *pSingleMscHandler = &usbMscHandler;
 void MSC_SD_init() {
  USBDevice.end();
  delay(200);
-  USBDevice.registerMscHandlers(1, &pSingleMscHandler, Marlin_STORAGE_Inquirydata);
  USBDevice.begin();
+  USBDevice.registerMscHandlers(1, &pSingleMscHandler, Marlin_STORAGE_Inquirydata);
 }

 #endif // __STM32F1__ && HAS_SD_HOST_DRIVE
@@ -1,202 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2021 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/>.
- *
- */
-#if defined(ARDUINO_ARCH_STM32) && !defined(STM32GENERIC)
-
-#include "../../../inc/MarlinConfig.h"
-
-#if ENABLED(TFT_TOUCH_DEVICE_GT911)
-
-#include "gt911.h"
-#include "pinconfig.h"
-
-SW_IIC::SW_IIC(uint16_t sda, uint16_t scl) {
-  scl_pin = scl;
-  sda_pin = sda;
-}
-
-// Software I2C hardware io init
-void SW_IIC::init() {
-  OUT_WRITE(scl_pin, HIGH);
-  OUT_WRITE(sda_pin, HIGH);
-}
-
-// Software I2C start signal
-void SW_IIC::start() {
-  write_sda(HIGH); // SDA = 1
-  write_scl(HIGH); // SCL = 1
-  iic_delay(2);
-  write_sda(LOW); // SDA = 0
-  iic_delay(1);
-  write_scl(LOW); // SCL = 0  // keep SCL low, avoid false stop caused by level jump caused by SDA switching IN/OUT
-}
-
-// Software I2C stop signal
-void SW_IIC::stop() {
-  write_scl(LOW); // SCL = 0
-  iic_delay(2);
-  write_sda(LOW); // SDA = 0
-  iic_delay(2);
-  write_scl(HIGH); // SCL = 1
-  iic_delay(2);
-  write_sda(HIGH); // SDA = 1
-}
-
-// Software I2C sends ACK or NACK signal
-void SW_IIC::send_ack(bool ack) {
-  write_sda(ack ? LOW : HIGH); // SDA = !ack
-  iic_delay(2);
-  write_scl(HIGH); // SCL = 1
-  iic_delay(2);
-  write_scl(LOW); // SCL = 0
-}
-
-// Software I2C read ACK or NACK signal
-bool SW_IIC::read_ack() {
-  bool error = 0;
-  set_sda_in();
-
-  iic_delay(2);
-
-  write_scl(HIGH); // SCL = 1
-  error = read_sda();
-
-  iic_delay(2);
-
-  write_scl(LOW);  // SCL = 0
-
-  set_sda_out();
-  return error;
-}
-
-void SW_IIC::send_byte(uint8_t txd) {
-  LOOP_L_N(i, 8) {
-    write_sda(txd & 0x80); // write data bit
-    txd <<= 1;
-    iic_delay(1);
-    write_scl(HIGH); // SCL = 1
-    iic_delay(2);
-    write_scl(LOW); // SCL = 0
-    iic_delay(1);
-  }
-
-  read_ack();  // wait ack
-}
-
-uint8_t SW_IIC::read_byte(bool ack) {
-  uint8_t data = 0;
-
-  set_sda_in();
-  LOOP_L_N(i, 8) {
-    write_scl(HIGH); // SCL = 1
-    iic_delay(1);
-    data <<= 1;
-    if (read_sda()) data++;
-    write_scl(LOW); // SCL = 0
-    iic_delay(2);
-  }
-  set_sda_out();
-
-  send_ack(ack);
-
-  return data;
-}
-
-GT911_REG_MAP GT911::reg;
-SW_IIC GT911::sw_iic = SW_IIC(GT911_SW_I2C_SDA_PIN, GT911_SW_I2C_SCL_PIN);
-
-void GT911::write_reg(uint16_t reg, uint8_t reg_len, uint8_t* w_data, uint8_t w_len) {
-  sw_iic.start();
-  sw_iic.send_byte(gt911_slave_address);  // Set IIC Slave address
-  LOOP_L_N(i, reg_len) {  // Set reg address
-    uint8_t r = (reg >> (8 * (reg_len - 1 - i))) & 0xFF;
-    sw_iic.send_byte(r);
-  }
-
-  LOOP_L_N(i, w_len) {  // Write data to reg
-    sw_iic.send_byte(w_data[i]);
-  }
-  sw_iic.stop();
-}
-
-void GT911::read_reg(uint16_t reg, uint8_t reg_len, uint8_t* r_data, uint8_t r_len) {
-  sw_iic.start();
-  sw_iic.send_byte(gt911_slave_address);  // Set IIC Slave address
-  LOOP_L_N(i, reg_len) {  // Set reg address
-    uint8_t r = (reg >> (8 * (reg_len - 1 - i))) & 0xFF;
-    sw_iic.send_byte(r);
-  }
-
-  sw_iic.start();
-  sw_iic.send_byte(gt911_slave_address + 1);  // Set read mode
-
-  LOOP_L_N(i, r_len) {
-    r_data[i] = sw_iic.read_byte(1);  // Read data from reg
-  }
-  sw_iic.stop();
-}
-
-void GT911::Init() {
-  OUT_WRITE(GT911_RST_PIN, LOW);
-  OUT_WRITE(GT911_INT_PIN, LOW);
-  delay(20);
-  WRITE(GT911_RST_PIN, HIGH);
-  SET_INPUT(GT911_INT_PIN);
-
-  sw_iic.init();
-
-  uint8_t clear_reg = 0x0000;
-  write_reg(0x814E, 2, &clear_reg, 2); // Reset to 0 for start
-}
-
-bool GT911::getFirstTouchPoint(int16_t *x, int16_t *y) {
-  read_reg(0x814E, 2, &reg.REG.status, 1);
-
-  if (reg.REG.status & 0x80) {
-    uint8_t clear_reg = 0x00;
-    write_reg(0x814E, 2, &clear_reg, 1); // Reset to 0 for start
-    read_reg(0x8150, 2, reg.map + 2, 8 * (reg.REG.status & 0x0F));
-
-    // First touch point
-    *x = ((reg.REG.point[0].xh & 0x0F) << 8) | reg.REG.point[0].xl;
-    *y = ((reg.REG.point[0].yh & 0x0F) << 8) | reg.REG.point[0].yl;
-    return true;
-  }
-  return false;
-}
-
-bool GT911::getPoint(int16_t *x, int16_t *y) {
-  static bool touched = 0;
-  static int16_t read_x = 0, read_y = 0;
-  static millis_t next_time = 0;
-
-  if (ELAPSED(millis(), next_time)) {
-    touched = getFirstTouchPoint(&read_x, &read_y);
-    next_time = millis() + 20;
-  }
-
-  *x = read_x;
-  *y = read_y;
-  return touched;
-}
-
-#endif // TFT_TOUCH_DEVICE_GT911
-#endif // ARDUINO_ARCH_STM32 && !STM32GENERIC
@@ -1,120 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-#include "../../../inc/MarlinConfig.h"
-
-#define GT911_SLAVE_ADDRESS   0xBA
-
-#if !PIN_EXISTS(GT911_RST)
-  #error "GT911_RST_PIN is not defined."
-#elif !PIN_EXISTS(GT911_INT)
-  #error "GT911_INT_PIN is not defined."
-#elif !PIN_EXISTS(GT911_SW_I2C_SCL)
-  #error "GT911_SW_I2C_SCL_PIN is not defined."
-#elif !PIN_EXISTS(GT911_SW_I2C_SDA)
-  #error "GT911_SW_I2C_SDA_PIN is not defined."
-#endif
-
-class SW_IIC {
-  private:
-    uint16_t scl_pin;
-    uint16_t sda_pin;
-    void write_scl(bool level)
-    {
-      WRITE(scl_pin, level);
-    }
-    void write_sda(bool level)
-    {
-      WRITE(sda_pin, level);
-    }
-    bool read_sda()
-    {
-      return READ(sda_pin);
-    }
-    void set_sda_out()
-    {
-      SET_OUTPUT(sda_pin);
-    }
-    void set_sda_in()
-    {
-      SET_INPUT_PULLUP(sda_pin);
-    }
-    static void iic_delay(uint8_t t)
-    {
-      delayMicroseconds(t);
-    }
-
-  public:
-    SW_IIC(uint16_t sda, uint16_t scl);
-    // setSCL/SDA have to be called before begin()
-    void setSCL(uint16_t scl)
-    {
-      scl_pin = scl;
-    };
-    void setSDA(uint16_t sda)
-    {
-      sda_pin = sda;
-    };
-    void init();                // Initialize the IO port of IIC
-    void start();               // Send IIC start signal
-    void stop();                // Send IIC stop signal
-    void send_byte(uint8_t txd); // IIC sends a byte
-    uint8_t read_byte(bool ack); // IIC reads a byte
-    void send_ack(bool ack);            // IIC sends ACK or NACK signal
-    bool read_ack();
-};
-
-typedef struct __attribute__((__packed__)) {
-  uint8_t xl;
-  uint8_t xh;
-  uint8_t yl;
-  uint8_t yh;
-  uint8_t sizel;
-  uint8_t sizeh;
-  uint8_t reserved;
-  uint8_t track_id;
-} GT911_POINT;
-
-typedef union __attribute__((__packed__)) {
-  uint8_t map[42];
-  struct {
-    uint8_t status;    // 0x814E
-    uint8_t track_id;  // 0x814F
-
-    GT911_POINT point[5]; // [0]:0x8150 - 0x8157 / [1]:0x8158 - 0x815F / [2]:0x8160 - 0x8167 / [3]:0x8168 - 0x816F / [4]:0x8170 - 0x8177
- } REG;
-} GT911_REG_MAP;
-
-class GT911 {
-  private:
-    static const uint8_t gt911_slave_address = GT911_SLAVE_ADDRESS;
-    static GT911_REG_MAP reg;
-    static SW_IIC sw_iic;
-    static void write_reg(uint16_t reg, uint8_t reg_len, uint8_t* w_data, uint8_t w_len);
-    static void read_reg(uint16_t reg, uint8_t reg_len, uint8_t* r_data, uint8_t r_len);
-
-  public:
-    static void Init();
-    static bool getFirstTouchPoint(int16_t *x, int16_t *y);
-    static bool getPoint(int16_t *x, int16_t *y);
-};
@@ -1,387 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2021 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/>.
- *
- */
-#if defined(ARDUINO_ARCH_STM32) && !defined(STM32GENERIC)
-
-#include "../../../inc/MarlinConfig.h"
-
-#if HAS_LTDC_TFT
-
-#include "tft_ltdc.h"
-#include "pinconfig.h"
-
-#define FRAME_BUFFER_ADDRESS 0XC0000000  // SDRAM address
-
-#define SDRAM_TIMEOUT                            ((uint32_t)0xFFFF)
-#define REFRESH_COUNT                            ((uint32_t)0x02A5)  // SDRAM refresh counter
-
-#define SDRAM_MODEREG_BURST_LENGTH_1             ((uint16_t)0x0000)
-#define SDRAM_MODEREG_BURST_LENGTH_2             ((uint16_t)0x0001)
-#define SDRAM_MODEREG_BURST_LENGTH_4             ((uint16_t)0x0002)
-#define SDRAM_MODEREG_BURST_LENGTH_8             ((uint16_t)0x0004)
-#define SDRAM_MODEREG_BURST_TYPE_SEQUENTIAL      ((uint16_t)0x0000)
-#define SDRAM_MODEREG_BURST_TYPE_INTERLEAVED     ((uint16_t)0x0008)
-#define SDRAM_MODEREG_CAS_LATENCY_2              ((uint16_t)0x0020)
-#define SDRAM_MODEREG_CAS_LATENCY_3              ((uint16_t)0x0030)
-#define SDRAM_MODEREG_OPERATING_MODE_STANDARD    ((uint16_t)0x0000)
-#define SDRAM_MODEREG_WRITEBURST_MODE_PROGRAMMED ((uint16_t)0x0000)
-#define SDRAM_MODEREG_WRITEBURST_MODE_SINGLE     ((uint16_t)0x0200)
-
-void SDRAM_Initialization_Sequence(SDRAM_HandleTypeDef *hsdram, FMC_SDRAM_CommandTypeDef *Command) {
-
-  __IO uint32_t tmpmrd =0;
-  /* Step 1:  Configure a clock configuration enable command */
-  Command->CommandMode = FMC_SDRAM_CMD_CLK_ENABLE;
-  Command->CommandTarget = FMC_SDRAM_CMD_TARGET_BANK1;
-  Command->AutoRefreshNumber = 1;
-  Command->ModeRegisterDefinition = 0;
-  /* Send the command */
-  HAL_SDRAM_SendCommand(hsdram, Command, SDRAM_TIMEOUT);
-
-  /* Step 2: Insert 100 us minimum delay */
-  /* Inserted delay is equal to 1 ms due to systick time base unit (ms) */
-  HAL_Delay(1);
-
-  /* Step 3: Configure a PALL (precharge all) command */
-  Command->CommandMode = FMC_SDRAM_CMD_PALL;
-  Command->CommandTarget = FMC_SDRAM_CMD_TARGET_BANK1;
-  Command->AutoRefreshNumber = 1;
-  Command->ModeRegisterDefinition = 0;
-  /* Send the command */
-  HAL_SDRAM_SendCommand(hsdram, Command, SDRAM_TIMEOUT);
-
-  /* Step 4 : Configure a Auto-Refresh command */
-  Command->CommandMode = FMC_SDRAM_CMD_AUTOREFRESH_MODE;
-  Command->CommandTarget = FMC_SDRAM_CMD_TARGET_BANK1;
-  Command->AutoRefreshNumber = 8;
-  Command->ModeRegisterDefinition = 0;
-  /* Send the command */
-  HAL_SDRAM_SendCommand(hsdram, Command, SDRAM_TIMEOUT);
-
-  /* Step 5: Program the external memory mode register */
-  tmpmrd = (uint32_t)(SDRAM_MODEREG_BURST_LENGTH_1          |
-                      SDRAM_MODEREG_BURST_TYPE_SEQUENTIAL   |
-                      SDRAM_MODEREG_CAS_LATENCY_2           |
-                      SDRAM_MODEREG_OPERATING_MODE_STANDARD |
-                      SDRAM_MODEREG_WRITEBURST_MODE_SINGLE);
-
-  Command->CommandMode = FMC_SDRAM_CMD_LOAD_MODE;
-  Command->CommandTarget = FMC_SDRAM_CMD_TARGET_BANK1;
-  Command->AutoRefreshNumber = 1;
-  Command->ModeRegisterDefinition = tmpmrd;
-  /* Send the command */
-  HAL_SDRAM_SendCommand(hsdram, Command, SDRAM_TIMEOUT);
-
-  /* Step 6: Set the refresh rate counter */
-  /* Set the device refresh rate */
-  HAL_SDRAM_ProgramRefreshRate(hsdram, REFRESH_COUNT);
-}
-
-void SDRAM_Config() {
-
-  __HAL_RCC_SYSCFG_CLK_ENABLE();
-  __HAL_RCC_FMC_CLK_ENABLE();
-
-  SDRAM_HandleTypeDef      hsdram;
-  FMC_SDRAM_TimingTypeDef  SDRAM_Timing;
-  FMC_SDRAM_CommandTypeDef command;
-
-  /* Configure the SDRAM device */
-  hsdram.Instance = FMC_SDRAM_DEVICE;
-  hsdram.Init.SDBank             = FMC_SDRAM_BANK1;
-  hsdram.Init.ColumnBitsNumber   = FMC_SDRAM_COLUMN_BITS_NUM_9;
-  hsdram.Init.RowBitsNumber      = FMC_SDRAM_ROW_BITS_NUM_13;
-  hsdram.Init.MemoryDataWidth    = FMC_SDRAM_MEM_BUS_WIDTH_16;
-  hsdram.Init.InternalBankNumber = FMC_SDRAM_INTERN_BANKS_NUM_4;
-  hsdram.Init.CASLatency         = FMC_SDRAM_CAS_LATENCY_2;
-  hsdram.Init.WriteProtection    = FMC_SDRAM_WRITE_PROTECTION_DISABLE;
-  hsdram.Init.SDClockPeriod      = FMC_SDRAM_CLOCK_PERIOD_2;
-  hsdram.Init.ReadBurst          = FMC_SDRAM_RBURST_ENABLE;
-  hsdram.Init.ReadPipeDelay      = FMC_SDRAM_RPIPE_DELAY_0;
-
-  /* Timing configuration for 100Mhz as SDRAM clock frequency (System clock is up to 200Mhz) */
-  SDRAM_Timing.LoadToActiveDelay    = 2;
-  SDRAM_Timing.ExitSelfRefreshDelay = 8;
-  SDRAM_Timing.SelfRefreshTime      = 6;
-  SDRAM_Timing.RowCycleDelay        = 6;
-  SDRAM_Timing.WriteRecoveryTime    = 2;
-  SDRAM_Timing.RPDelay              = 2;
-  SDRAM_Timing.RCDDelay             = 2;
-
-  /* Initialize the SDRAM controller */
-  if (HAL_SDRAM_Init(&hsdram, &SDRAM_Timing) != HAL_OK)
-  {
-    /* Initialization Error */
-  }
-
-  /* Program the SDRAM external device */
-  SDRAM_Initialization_Sequence(&hsdram, &command);
-}
-
-void LTDC_Config() {
-
-  __HAL_RCC_LTDC_CLK_ENABLE();
-  __HAL_RCC_DMA2D_CLK_ENABLE();
-
-  RCC_PeriphCLKInitTypeDef  PeriphClkInitStruct;
-
-  /* The PLL3R is configured to provide the LTDC PCLK clock */
-  /* PLL3_VCO Input = HSE_VALUE / PLL3M = 25Mhz / 5 = 5 Mhz */
-  /* PLL3_VCO Output = PLL3_VCO Input * PLL3N = 5Mhz * 160 = 800 Mhz */
-  /* PLLLCDCLK = PLL3_VCO Output/PLL3R = 800Mhz / 16 = 50Mhz */
-  /* LTDC clock frequency = PLLLCDCLK = 50 Mhz */
-  PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LTDC;
-  PeriphClkInitStruct.PLL3.PLL3M = 5;
-  PeriphClkInitStruct.PLL3.PLL3N = 160;
-  PeriphClkInitStruct.PLL3.PLL3FRACN = 0;
-  PeriphClkInitStruct.PLL3.PLL3P = 2;
-  PeriphClkInitStruct.PLL3.PLL3Q = 2;
-  PeriphClkInitStruct.PLL3.PLL3R = (800 / LTDC_LCD_CLK);
-  PeriphClkInitStruct.PLL3.PLL3VCOSEL = RCC_PLL3VCOWIDE;
-  PeriphClkInitStruct.PLL3.PLL3RGE = RCC_PLL3VCIRANGE_2;
-  HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct);
-
-  LTDC_HandleTypeDef hltdc_F;
-  LTDC_LayerCfgTypeDef pLayerCfg;
-
-  /* LTDC Initialization -------------------------------------------------------*/
-
-  /* Polarity configuration */
-  /* Initialize the horizontal synchronization polarity as active low */
-  hltdc_F.Init.HSPolarity = LTDC_HSPOLARITY_AL;
-  /* Initialize the vertical synchronization polarity as active low */
-  hltdc_F.Init.VSPolarity = LTDC_VSPOLARITY_AL;
-  /* Initialize the data enable polarity as active low */
-  hltdc_F.Init.DEPolarity = LTDC_DEPOLARITY_AL;
-  /* Initialize the pixel clock polarity as input pixel clock */
-  hltdc_F.Init.PCPolarity = LTDC_PCPOLARITY_IPC;
-
-  /* Timing configuration */
-  hltdc_F.Init.HorizontalSync = (LTDC_LCD_HSYNC - 1);
-  hltdc_F.Init.VerticalSync = (LTDC_LCD_VSYNC - 1);
-  hltdc_F.Init.AccumulatedHBP = (LTDC_LCD_HSYNC + LTDC_LCD_HBP - 1);
-  hltdc_F.Init.AccumulatedVBP = (LTDC_LCD_VSYNC + LTDC_LCD_VBP - 1);
-  hltdc_F.Init.AccumulatedActiveH = (TFT_HEIGHT + LTDC_LCD_VSYNC + LTDC_LCD_VBP - 1);
-  hltdc_F.Init.AccumulatedActiveW = (TFT_WIDTH + LTDC_LCD_HSYNC + LTDC_LCD_HBP - 1);
-  hltdc_F.Init.TotalHeigh = (TFT_HEIGHT + LTDC_LCD_VSYNC + LTDC_LCD_VBP + LTDC_LCD_VFP - 1);
-  hltdc_F.Init.TotalWidth = (TFT_WIDTH + LTDC_LCD_HSYNC + LTDC_LCD_HBP + LTDC_LCD_HFP - 1);
-
-  /* Configure R,G,B component values for LCD background color : all black background */
-  hltdc_F.Init.Backcolor.Blue = 0;
-  hltdc_F.Init.Backcolor.Green = 0;
-  hltdc_F.Init.Backcolor.Red = 0;
-
-  hltdc_F.Instance = LTDC;
-
-  /* Layer0 Configuration ------------------------------------------------------*/
-
-  /* Windowing configuration */
-  pLayerCfg.WindowX0 = 0;
-  pLayerCfg.WindowX1 = TFT_WIDTH;
-  pLayerCfg.WindowY0 = 0;
-  pLayerCfg.WindowY1 = TFT_HEIGHT;
-
-  /* Pixel Format configuration*/
-  pLayerCfg.PixelFormat = LTDC_PIXEL_FORMAT_RGB565;
-
-  /* Start Address configuration : frame buffer is located at SDRAM memory */
-  pLayerCfg.FBStartAdress = (uint32_t)(FRAME_BUFFER_ADDRESS);
-
-  /* Alpha constant (255 == totally opaque) */
-  pLayerCfg.Alpha = 255;
-
-  /* Default Color configuration (configure A,R,G,B component values) : no background color */
-  pLayerCfg.Alpha0 = 0; /* fully transparent */
-  pLayerCfg.Backcolor.Blue = 0;
-  pLayerCfg.Backcolor.Green = 0;
-  pLayerCfg.Backcolor.Red = 0;
-
-  /* Configure blending factors */
-  pLayerCfg.BlendingFactor1 = LTDC_BLENDING_FACTOR1_CA;
-  pLayerCfg.BlendingFactor2 = LTDC_BLENDING_FACTOR2_CA;
-
-  /* Configure the number of lines and number of pixels per line */
-  pLayerCfg.ImageWidth  = TFT_WIDTH;
-  pLayerCfg.ImageHeight = TFT_HEIGHT;
-
-  /* Configure the LTDC */
-  if (HAL_LTDC_Init(&hltdc_F) != HAL_OK)
-  {
-    /* Initialization Error */
-  }
-
-  /* Configure the Layer*/
-  if (HAL_LTDC_ConfigLayer(&hltdc_F, &pLayerCfg, 0) != HAL_OK)
-  {
-    /* Initialization Error */
-  }
-}
-
-uint16_t TFT_LTDC::x_min = 0;
-uint16_t TFT_LTDC::x_max = 0;
-uint16_t TFT_LTDC::y_min = 0;
-uint16_t TFT_LTDC::y_max = 0;
-uint16_t TFT_LTDC::x_cur = 0;
-uint16_t TFT_LTDC::y_cur = 0;
-uint8_t TFT_LTDC::reg = 0;
-volatile uint16_t* TFT_LTDC::framebuffer = (volatile uint16_t* )FRAME_BUFFER_ADDRESS;
-
-void TFT_LTDC::Init() {
-
-  // SDRAM pins init
-  for (uint16_t i = 0; PinMap_SDRAM[i].pin != NC; i++)
-    pinmap_pinout(PinMap_SDRAM[i].pin, PinMap_SDRAM);
-
-  // SDRAM peripheral config
-  SDRAM_Config();
-
-  // LTDC pins init
-  for (uint16_t i = 0; PinMap_LTDC[i].pin != NC; i++)
-    pinmap_pinout(PinMap_LTDC[i].pin, PinMap_LTDC);
-
-  // LTDC peripheral config
-  LTDC_Config();
-}
-
-uint32_t TFT_LTDC::GetID() {
-  return 0xABAB;
-}
-
-uint32_t TFT_LTDC::ReadID(tft_data_t Reg) {
-  return 0xABAB;
-}
-
-bool TFT_LTDC::isBusy() {
-  return false;
-}
-
-uint16_t TFT_LTDC::ReadPoint(uint16_t x, uint16_t y) {
-  return framebuffer[(TFT_WIDTH * y) + x];
-}
-
-void TFT_LTDC::DrawPoint(uint16_t x, uint16_t y, uint16_t color) {
-  framebuffer[(TFT_WIDTH * y) + x] = color;
-}
-
-void TFT_LTDC::DrawRect(uint16_t sx, uint16_t sy, uint16_t ex, uint16_t ey, uint16_t color) {
-
-  if (sx == ex || sy == ey) return;
-
-  uint16_t offline = TFT_WIDTH - (ex - sx);
-  uint32_t addr = (uint32_t)&framebuffer[(TFT_WIDTH * sy) + sx];
-
-  CBI(DMA2D->CR, 0);
-  DMA2D->CR = 3 << 16;
-  DMA2D->OPFCCR = 0X02;
-  DMA2D->OOR = offline;
-  DMA2D->OMAR = addr;
-  DMA2D->NLR = (ey - sy) | ((ex - sx) << 16);
-  DMA2D->OCOLR = color;
-  SBI(DMA2D->CR, 0);
-
-  uint32_t timeout = 0;
-  while (!TEST(DMA2D->ISR, 1)) {
-    timeout++;
-    if (timeout > 0x1FFFFF) break;
-  }
-  SBI(DMA2D->IFCR, 1);
-}
-
-void TFT_LTDC::DrawImage(uint16_t sx, uint16_t sy, uint16_t ex, uint16_t ey, uint16_t *colors) {
-
-  if (sx == ex || sy == ey) return;
-
-  uint16_t offline = TFT_WIDTH - (ex - sx);
-  uint32_t addr = (uint32_t)&framebuffer[(TFT_WIDTH * sy) + sx];
-
-  CBI(DMA2D->CR, 0);
-  DMA2D->CR = 0 << 16;
-  DMA2D->FGPFCCR = 0X02;
-  DMA2D->FGOR = 0;
-  DMA2D->OOR = offline;
-  DMA2D->FGMAR = (uint32_t)colors;
-  DMA2D->OMAR = addr;
-  DMA2D->NLR = (ey - sy) | ((ex - sx) << 16);
-  SBI(DMA2D->CR, 0);
-
-  uint32_t timeout = 0;
-  while (!TEST(DMA2D->ISR, 1)) {
-    timeout++;
-    if (timeout > 0x1FFFFF) break;
-  }
-  SBI(DMA2D->IFCR, 1);
-}
-
-void TFT_LTDC::WriteData(uint16_t data) {
-  switch (reg) {
-    case 0x01: x_cur = x_min = data; return;
-    case 0x02: x_max = data; return;
-    case 0x03: y_cur = y_min = data; return;
-    case 0x04: y_max = data; return;
-  }
-  Transmit(data);
-}
-
-void TFT_LTDC::Transmit(tft_data_t Data) {
-  DrawPoint(x_cur, y_cur, Data);
-  x_cur++;
-  if (x_cur > x_max) {
-    x_cur = x_min;
-    y_cur++;
-    if (y_cur > y_max) y_cur = y_min;
-  }
-}
-
-void TFT_LTDC::WriteReg(uint16_t Reg) {
-  reg = Reg;
-}
-
-void TFT_LTDC::TransmitDMA(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Count) {
-
-  while (x_cur != x_min && Count) {
-    Transmit(*Data);
-    if (MemoryIncrease == DMA_PINC_ENABLE) Data++;
-    Count--;
-  }
-
-  uint16_t width = x_max - x_min + 1;
-  uint16_t height = Count / width;
-  uint16_t x_end_cnt = Count - (width * height);
-
-  if (height) {
-    if (MemoryIncrease == DMA_PINC_ENABLE) {
-      DrawImage(x_min, y_cur, x_min + width, y_cur + height, Data);
-      Data += width * height;
-    } else {
-      DrawRect(x_min, y_cur, x_min + width, y_cur + height, *Data);
-    }
-    y_cur += height;
-  }
-
-  while (x_end_cnt) {
-    Transmit(*Data);
-    if (MemoryIncrease == DMA_PINC_ENABLE) Data++;
-    x_end_cnt--;
-  }
-}
-
-#endif // HAS_LTDC_TFT
-#endif // ARDUINO_ARCH_STM32 && !STM32GENERIC
@@ -1,155 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-#include "../../../inc/MarlinConfig.h"
-
-#ifdef STM32H7xx
-  #include "stm32h7xx_hal.h"
-#else
-  #error "LTDC TFT is currently only supported on STM32H7 hardware."
-#endif
-
-#define DATASIZE_8BIT  SPI_DATASIZE_8BIT
-#define DATASIZE_16BIT SPI_DATASIZE_16BIT
-#define TFT_IO_DRIVER  TFT_LTDC
-
-#define TFT_DATASIZE DATASIZE_16BIT
-typedef uint16_t tft_data_t;
-
-class TFT_LTDC {
-  private:
-    static volatile uint16_t *framebuffer;
-    static uint16_t x_min, x_max, y_min, y_max, x_cur, y_cur;
-    static uint8_t reg;
-
-    static uint32_t ReadID(tft_data_t Reg);
-
-    static uint16_t ReadPoint(uint16_t x, uint16_t y);
-    static void DrawPoint(uint16_t x, uint16_t y, uint16_t color);
-    static void DrawRect(uint16_t sx, uint16_t sy, uint16_t ex, uint16_t ey, uint16_t color);
-    static void DrawImage(uint16_t sx, uint16_t sy, uint16_t ex, uint16_t ey, uint16_t *colors);
-    static void Transmit(tft_data_t Data);
-    static void TransmitDMA(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Count);
-
-  public:
-    static void Init();
-    static uint32_t GetID();
-    static bool isBusy();
-    static void Abort() { /*__HAL_DMA_DISABLE(&DMAtx);*/ }
-
-    static void DataTransferBegin(uint16_t DataWidth = TFT_DATASIZE) {}
-    static void DataTransferEnd() {};
-
-    static void WriteData(uint16_t Data);
-    static void WriteReg(uint16_t Reg);
-
-    static void WriteSequence(uint16_t *Data, uint16_t Count) { TransmitDMA(DMA_PINC_ENABLE, Data, Count); }
-    static void WriteMultiple(uint16_t Color, uint16_t Count) { static uint16_t Data; Data = Color; TransmitDMA(DMA_PINC_DISABLE, &Data, Count); }
-    static void WriteMultiple(uint16_t Color, uint32_t Count) {
-      static uint16_t Data; Data = Color;
-      while (Count > 0) {
-        TransmitDMA(DMA_MINC_DISABLE, &Data, Count > 0xFFFF ? 0xFFFF : Count);
-        Count = Count > 0xFFFF ? Count - 0xFFFF : 0;
-      }
-    }
-};
-
-const PinMap PinMap_LTDC[] = {
-  {PF_10, LTDC, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF14_LTDC)}, // LCD_DE
-  {PG_7,  LTDC, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF14_LTDC)}, // LCD_CLK
-  {PI_9,  LTDC, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF14_LTDC)}, // LCD_VSYNC
-  {PI_10, LTDC, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF14_LTDC)}, // LCD_HSYNC
-
-  {PG_6,  LTDC, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF14_LTDC)}, // LCD_R7
-  {PH_12, LTDC, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF14_LTDC)}, // LCD_R6
-  {PH_11, LTDC, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF14_LTDC)}, // LCD_R5
-  {PH_10, LTDC, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF14_LTDC)}, // LCD_R4
-  {PH_9,  LTDC, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF14_LTDC)}, // LCD_R3
-
-  {PI_2,  LTDC, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF14_LTDC)}, // LCD_G7
-  {PI_1,  LTDC, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF14_LTDC)}, // LCD_G6
-  {PI_0,  LTDC, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF14_LTDC)}, // LCD_G5
-  {PH_15, LTDC, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF14_LTDC)}, // LCD_G4
-  {PH_14, LTDC, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF14_LTDC)}, // LCD_G3
-  {PH_13, LTDC, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF14_LTDC)}, // LCD_G2
-
-  {PI_7,  LTDC, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF14_LTDC)}, // LCD_B7
-  {PI_6,  LTDC, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF14_LTDC)}, // LCD_B6
-  {PI_5,  LTDC, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF14_LTDC)}, // LCD_B5
-  {PI_4,  LTDC, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF14_LTDC)}, // LCD_B4
-  {PG_11, LTDC, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF14_LTDC)}, // LCD_B3
-  {NC,    NP,    0}
-};
-
-const PinMap PinMap_SDRAM[] = {
-  {PC_0,  FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_SDNWE
-  {PC_2,  FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_SDNE0
-  {PC_3,  FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_SDCKE0
-  {PE_0,  FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_NBL0
-  {PE_1,  FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_NBL1
-  {PF_11, FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_SDNRAS
-  {PG_8,  FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_SDCLK
-  {PG_15, FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_SDNCAS
-  {PG_4,  FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_BA0
-  {PG_5,  FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_BA1
-  {PD_14, FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_D0
-  {PD_15, FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_D1
-  {PD_0,  FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_D2
-  {PD_1,  FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_D3
-  {PE_7,  FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_D4
-  {PE_8,  FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_D5
-  {PE_9,  FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_D6
-  {PE_10, FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_D7
-  {PE_11, FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_D8
-  {PE_12, FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_D9
-  {PE_13, FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_D10
-  {PE_14, FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_D11
-  {PE_15, FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_D12
-  {PD_8,  FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_D13
-  {PD_9,  FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_D14
-  {PD_10, FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_D15
-  {PF_0,  FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_A0
-  {PF_1,  FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_A1
-  {PF_2,  FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_A2
-  {PF_3,  FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_A3
-  {PF_4,  FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_A4
-  {PF_5,  FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_A5
-  {PF_12, FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_A6
-  {PF_13, FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_A7
-  {PF_14, FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_A8
-  {PF_15, FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_A9
-  {PG_0,  FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_A10
-  {PG_1,  FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_A11
-  {PG_2,  FMC_Bank1_R, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF12_FMC)}, // FMC_A12
-  {NC,    NP,    0}
-};
-
-const PinMap PinMap_QUADSPI[] = {
-  {PB_2,  QUADSPI, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF9_QUADSPI)}, // QUADSPI_CLK
-  {PB_10, QUADSPI, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF9_QUADSPI)}, // QUADSPI_BK1_NCS
-  {PF_6,  QUADSPI, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF9_QUADSPI)}, // QUADSPI_BK1_IO3
-  {PF_7,  QUADSPI, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF9_QUADSPI)}, // QUADSPI_BK1_IO2
-  {PF_8,  QUADSPI, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF10_QUADSPI)}, // QUADSPI_BK1_IO0
-  {PF_9,  QUADSPI, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, GPIO_AF10_QUADSPI)}, // QUADSPI_BK1_IO1
-  {NC,    NP,    0}
-};
@@ -207,12 +207,12 @@ void TFT_SPI::Transmit(uint16_t Data) {
  while ((SPIx.Instance->SR & SPI_FLAG_BSY) == SPI_FLAG_BSY) {}

  if (TFT_MISO_PIN != TFT_MOSI_PIN)
-    __HAL_SPI_CLEAR_OVRFLAG(&SPIx);   // Clear overrun flag in 2 Lines communication mode because received is not read
+    __HAL_SPI_CLEAR_OVRFLAG(&SPIx);   /* Clear overrun flag in 2 Lines communication mode because received is not read */
 }

 void TFT_SPI::TransmitDMA(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Count) {
  // Wait last dma finish, to start another
-  while (isBusy()) { /* nada */ }
+  while(isBusy()) { }

  DMAtx.Init.MemInc = MemoryIncrease;
  HAL_DMA_Init(&DMAtx);
@@ -225,7 +225,7 @@ void TFT_SPI::TransmitDMA(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Coun
  HAL_DMA_Start(&DMAtx, (uint32_t)Data, (uint32_t)&(SPIx.Instance->DR), Count);
  __HAL_SPI_ENABLE(&SPIx);

-  SET_BIT(SPIx.Instance->CR2, SPI_CR2_TXDMAEN);   // Enable Tx DMA Request
+  SET_BIT(SPIx.Instance->CR2, SPI_CR2_TXDMAEN);   /* Enable Tx DMA Request */

  HAL_DMA_PollForTransfer(&DMAtx, HAL_DMA_FULL_TRANSFER, HAL_MAX_DELAY);
  Abort();
@@ -23,7 +23,7 @@

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

-#if HAS_TFT_XPT2046 || HAS_RES_TOUCH_BUTTONS
+#if HAS_TFT_XPT2046 || HAS_TOUCH_BUTTONS

 #include "xpt2046.h"
 #include "pinconfig.h"
@@ -74,7 +74,7 @@
 #elif defined(STM32F401xC) || defined(STM32F401xE)
  #define MCU_STEP_TIMER  9
  #define MCU_TEMP_TIMER 10
-#elif defined(STM32F4xx) || defined(STM32F7xx) || defined(STM32H7xx)
+#elif defined(STM32F4xx) || defined(STM32F7xx)
  #define MCU_STEP_TIMER  6           // STM32F401 has no TIM6, TIM7, or TIM8
  #define MCU_TEMP_TIMER 14           // TIM7 is consumed by Software Serial if used.
 #endif
@@ -21,12 +21,15 @@
 */
 #pragma once

+#include <stdint.h>
 #include "../../inc/MarlinConfig.h"

 // ------------------------
 // Defines
 // ------------------------

+#define FORCE_INLINE __attribute__((always_inline)) inline
+
 // STM32 timers may be 16 or 32 bit. Limiting HAL_TIMER_TYPE_MAX to 16 bits
 // avoids issues with STM32F0 MCUs, which seem to pause timers if UINT32_MAX
 // is written to the register. STM32F4 timers do not manifest this issue,
@@ -110,7 +110,7 @@ uint8_t BulkStorage::Read(uint8_t lun, uint32_t addr, uint16_t bsize, uint8_t bl
 }

 uint8_t BulkStorage::Write(uint8_t lun, uint32_t addr, uint16_t bsize, uint8_t blocks, const uint8_t * buf) {
-  return USBH_MSC_Write(&hUsbHost, lun, addr, const_cast<uint8_t*>(buf), blocks) != USBH_OK;
+  return USBH_MSC_Write(&hUsbHost, lun, addr, const_cast <uint8_t*>(buf), blocks) != USBH_OK;
 }

 #endif // USE_OTG_USB_HOST && USBHOST
@@ -84,7 +84,7 @@

 #if defined(SERIAL_USB) && !HAS_SD_HOST_DRIVE
  USBSerial SerialUSB;
-  DefaultSerial1 MSerial0(true, SerialUSB);
+  DefaultSerial MSerial(true, SerialUSB);

  #if ENABLED(EMERGENCY_PARSER)
    #include "../libmaple/usb/stm32f1/usb_reg_map.h"
@@ -107,7 +107,7 @@
      len = usb_cdcacm_peek(buf, total);

      for (uint32 i = 0; i < len; i++)
-        emergency_parser.update(MSerial0.emergency_state, buf[i + total - len]);
+        emergency_parser.update(MSerial.emergency_state, buf[i + total - len]);
    }
  #endif
 #endif
@@ -132,9 +132,6 @@ const uint8_t adc_pins[] = {
  #if HAS_TEMP_CHAMBER
    TEMP_CHAMBER_PIN,
  #endif
-  #if HAS_TEMP_COOLER
-    TEMP_COOLER_PIN,
-  #endif
  #if HAS_TEMP_ADC_1
    TEMP_1_PIN,
  #endif
@@ -192,9 +189,6 @@ enum TempPinIndex : char {
  #if HAS_TEMP_CHAMBER
    TEMP_CHAMBER,
  #endif
-  #if HAS_TEMP_COOLER
-    TEMP_COOLER_PIN,
-  #endif
  #if HAS_TEMP_ADC_1
    TEMP_1,
  #endif
@@ -278,8 +272,6 @@ static void NVIC_SetPriorityGrouping(uint32_t PriorityGroup) {
  } }
 #endif

-TERN_(POSTMORTEM_DEBUGGING, extern void install_min_serial());
-
 void HAL_init() {
  NVIC_SetPriorityGrouping(0x3);
  #if PIN_EXISTS(LED)
@@ -293,9 +285,8 @@ void HAL_init() {
  #if PIN_EXISTS(USB_CONNECT)
    OUT_WRITE(USB_CONNECT_PIN, !USB_CONNECT_INVERTING);  // USB clear connection
    delay(1000);                                         // Give OS time to notice
-    WRITE(USB_CONNECT_PIN, USB_CONNECT_INVERTING);
+    OUT_WRITE(USB_CONNECT_PIN, USB_CONNECT_INVERTING);
  #endif
-  TERN_(POSTMORTEM_DEBUGGING, install_min_serial());    // Install the minimal serial handler
 }

 // HAL idle task
@@ -391,9 +382,6 @@ void HAL_adc_start_conversion(const uint8_t adc_pin) {
    #if HAS_TEMP_CHAMBER
      case TEMP_CHAMBER_PIN: pin_index = TEMP_CHAMBER; break;
    #endif
-    #if HAS_TEMP_COOLER
-      case TEMP_COOLER_PIN: pin_index = TEMP_COOLER; break;
-    #endif
    #if HAS_TEMP_ADC_1
      case TEMP_1_PIN: pin_index = TEMP_1; break;
    #endif
@@ -453,8 +441,6 @@ void analogWrite(pin_t pin, int pwm_val8) {
    analogWrite(uint8_t(pin), pwm_val8);
 }

-void HAL_reboot() { nvic_sys_reset(); }
-
-void flashFirmware(const int16_t) { HAL_reboot(); }
+void flashFirmware(const int16_t) { nvic_sys_reset(); }

 #endif // __STM32F1__
@@ -36,6 +36,7 @@
 #include "fastio.h"
 #include "watchdog.h"

+
 #include <stdint.h>
 #include <util/atomic.h>

@@ -52,7 +53,7 @@
 // ------------------------

 #ifndef STM32_FLASH_SIZE
-  #if ANY(MCU_STM32F103RE, MCU_STM32F103VE, MCU_STM32F103ZE)
+  #if EITHER(MCU_STM32F103RE, MCU_STM32F103VE)
    #define STM32_FLASH_SIZE 512
  #else
    #define STM32_FLASH_SIZE 256
@@ -60,12 +61,13 @@
 #endif

 #ifdef SERIAL_USB
-  typedef ForwardSerial1Class< USBSerial > DefaultSerial1;
-  extern DefaultSerial1 MSerial0;
-  #if HAS_SD_HOST_DRIVE
-    #define UsbSerial MarlinCompositeSerial
+  typedef ForwardSerial0Type< USBSerial > DefaultSerial;
+  extern DefaultSerial MSerial;
+
+  #if !HAS_SD_HOST_DRIVE
+    #define UsbSerial MSerial
  #else
-    #define UsbSerial MSerial0
+    #define UsbSerial MarlinCompositeSerial
  #endif
 #endif

@@ -79,33 +81,24 @@
 #endif

 #if SERIAL_PORT == -1
-  #define MYSERIAL1 UsbSerial
+  #define MYSERIAL0 UsbSerial
 #elif WITHIN(SERIAL_PORT, 1, NUM_UARTS)
-  #define MYSERIAL1 MSERIAL(SERIAL_PORT)
+  #define MYSERIAL0 MSERIAL(SERIAL_PORT)
+#elif NUM_UARTS == 5
+  #error "SERIAL_PORT must be -1 or from 1 to 5. Please update your configuration."
 #else
-  #define MYSERIAL1 MSERIAL(1) // dummy port
-  static_assert(false, "SERIAL_PORT must be from 1 to " STRINGIFY(NUM_UARTS) ". You can also use -1 if the board supports Native USB.")
+  #error "SERIAL_PORT must be -1 or from 1 to 3. Please update your configuration."
 #endif

 #ifdef SERIAL_PORT_2
  #if SERIAL_PORT_2 == -1
-    #define MYSERIAL2 UsbSerial
+    #define MYSERIAL1 UsbSerial
  #elif WITHIN(SERIAL_PORT_2, 1, NUM_UARTS)
-    #define MYSERIAL2 MSERIAL(SERIAL_PORT_2)
+    #define MYSERIAL1 MSERIAL(SERIAL_PORT_2)
+  #elif NUM_UARTS == 5
+    #error "SERIAL_PORT_2 must be -1 or from 1 to 5. Please update your configuration."
  #else
-    #define MYSERIAL2 MSERIAL(1) // dummy port
-    static_assert(false, "SERIAL_PORT_2 must be from 1 to " STRINGIFY(NUM_UARTS) ". You can also use -1 if the board supports Native USB.")
-  #endif
-#endif
-
-#ifdef SERIAL_PORT_3
-  #if SERIAL_PORT_3 == -1
-    #define MYSERIAL3 UsbSerial
-  #elif WITHIN(SERIAL_PORT_3, 1, NUM_UARTS)
-    #define MYSERIAL3 MSERIAL(SERIAL_PORT_3)
-  #else
-    #define MYSERIAL3 MSERIAL(1) // dummy port
-    static_assert(false, "SERIAL_PORT_3 must be from 1 to " STRINGIFY(NUM_UARTS) ". You can also use -1 if the board supports Native USB.")
+    #error "SERIAL_PORT_2 must be -1 or from 1 to 3. Please update your configuration."
  #endif
 #endif

@@ -114,9 +107,10 @@
    #define MMU2_SERIAL UsbSerial
  #elif WITHIN(MMU2_SERIAL_PORT, 1, NUM_UARTS)
    #define MMU2_SERIAL MSERIAL(MMU2_SERIAL_PORT)
+  #elif NUM_UARTS == 5
+    #error "MMU2_SERIAL_PORT must be -1 or from 1 to 5. Please update your configuration."
  #else
-    #define MMU2_SERIAL MSERIAL(1) // dummy port
-    static_assert(false, "MMU2_SERIAL_PORT must be from 1 to " STRINGIFY(NUM_UARTS) ". You can also use -1 if the board supports Native USB.")
+    #error "MMU2_SERIAL_PORT must be -1 or from 1 to 3. Please update your configuration."
  #endif
 #endif

@@ -125,11 +119,12 @@
    #define LCD_SERIAL UsbSerial
  #elif WITHIN(LCD_SERIAL_PORT, 1, NUM_UARTS)
    #define LCD_SERIAL MSERIAL(LCD_SERIAL_PORT)
+  #elif NUM_UARTS == 5
+    #error "LCD_SERIAL_PORT must be -1 or from 1 to 5. Please update your configuration."
  #else
-    #define LCD_SERIAL MSERIAL(1) // dummy port
-    static_assert(false, "LCD_SERIAL_PORT must be from 1 to " STRINGIFY(NUM_UARTS) ". You can also use -1 if the board supports Native USB.")
+    #error "LCD_SERIAL_PORT must be -1 or from 1 to 3. Please update your configuration."
  #endif
-  #if HAS_DGUS_LCD
+  #if HAS_DGUS_LCD || ENABLED(DGUS_LCD_UI_CREALITY_TOUCH)
    #define SERIAL_GET_TX_BUFFER_FREE() LCD_SERIAL.availableForWrite()
  #endif
 #endif
@@ -200,7 +195,7 @@ void HAL_clear_reset_source();
 // Reset reason
 uint8_t HAL_get_reset_source();

-void HAL_reboot();
+inline void HAL_reboot() {}  // reboot the board or restart the bootloader

 void _delay_ms(const int delay);

@@ -1,118 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- * Copyright (c) 2017 Victor Perez
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#ifdef __STM32F1__
-
-#include "../../inc/MarlinConfigPre.h"
-
-#if ENABLED(POSTMORTEM_DEBUGGING)
-
-#include "../shared/HAL_MinSerial.h"
-#include "watchdog.h"
-
-#include <libmaple/usart.h>
-#include <libmaple/rcc.h>
-#include <libmaple/nvic.h>
-
-/* Instruction Synchronization Barrier */
-#define isb() __asm__ __volatile__ ("isb" : : : "memory")
-
-/* Data Synchronization Barrier */
-#define dsb() __asm__ __volatile__ ("dsb" : : : "memory")
-
-static void TXBegin() {
-  #if !WITHIN(SERIAL_PORT, 1, 6)
-    #warning "Using POSTMORTEM_DEBUGGING requires a physical U(S)ART hardware in case of severe error."
-    #warning "Disabling the severe error reporting feature currently because the used serial port is not a HW port."
-  #else
-    // We use MYSERIAL1 here, so we need to figure out how to get the linked register
-    struct usart_dev* dev = MYSERIAL1.c_dev();
-
-    // Or use this if removing libmaple
-    // int irq = dev->irq_num;
-    // int nvicUART[] = { NVIC_USART1 /* = 37 */, NVIC_USART2 /* = 38 */, NVIC_USART3 /* = 39 */, NVIC_UART4 /* = 52 */, NVIC_UART5 /* = 53 */ };
-    // Disabling irq means setting the bit in the NVIC ICER register located at
-    // Disable UART interrupt in NVIC
-    nvic_irq_disable(dev->irq_num);
-
-    // Use this if removing libmaple
-    //SBI(NVIC_BASE->ICER[1], irq - 32);
-
-    // We NEED memory barriers to ensure Interrupts are actually disabled!
-    // ( https://dzone.com/articles/nvic-disabling-interrupts-on-arm-cortex-m-and-the )
-    dsb();
-    isb();
-
-    rcc_clk_disable(dev->clk_id);
-    rcc_clk_enable(dev->clk_id);
-
-    usart_reg_map *regs = dev->regs;
-    regs->CR1 = 0; // Reset the USART
-    regs->CR2 = 0; // 1 stop bit
-
-    // If we don't touch the BRR (baudrate register), we don't need to recompute. Else we would need to call
-    usart_set_baud_rate(dev, 0, BAUDRATE);
-
-    regs->CR1 = (USART_CR1_TE | USART_CR1_UE); // 8 bits, no parity, 1 stop bit
-  #endif
-}
-
-// A SW memory barrier, to ensure GCC does not overoptimize loops
-#define sw_barrier() __asm__ volatile("": : :"memory");
-static void TX(char c) {
-  #if WITHIN(SERIAL_PORT, 1, 6)
-    struct usart_dev* dev = MYSERIAL1.c_dev();
-    while (!(dev->regs->SR & USART_SR_TXE)) {
-      TERN_(USE_WATCHDOG, HAL_watchdog_refresh());
-      sw_barrier();
-    }
-    dev->regs->DR = c;
-  #endif
-}
-
-void install_min_serial() {
-  HAL_min_serial_init = &TXBegin;
-  HAL_min_serial_out = &TX;
-}
-
-#if DISABLED(DYNAMIC_VECTORTABLE) && DISABLED(STM32F0xx) // Cortex M0 can't branch to a symbol that's too far, so we have a specific hack for them
-extern "C" {
-  __attribute__((naked)) void JumpHandler_ASM() {
-    __asm__ __volatile__ (
-      "b CommonHandler_ASM\n"
-    );
-  }
-  void __attribute__((naked, alias("JumpHandler_ASM"), nothrow)) __exc_hardfault();
-  void __attribute__((naked, alias("JumpHandler_ASM"), nothrow)) __exc_busfault();
-  void __attribute__((naked, alias("JumpHandler_ASM"), nothrow)) __exc_usagefault();
-  void __attribute__((naked, alias("JumpHandler_ASM"), nothrow)) __exc_memmanage();
-  void __attribute__((naked, alias("JumpHandler_ASM"), nothrow)) __exc_nmi();
-  void __attribute__((naked, alias("JumpHandler_ASM"), nothrow)) __stm32reservedexception7();
-  void __attribute__((naked, alias("JumpHandler_ASM"), nothrow)) __stm32reservedexception8();
-  void __attribute__((naked, alias("JumpHandler_ASM"), nothrow)) __stm32reservedexception9();
-  void __attribute__((naked, alias("JumpHandler_ASM"), nothrow)) __stm32reservedexception10();
-  void __attribute__((naked, alias("JumpHandler_ASM"), nothrow)) __stm32reservedexception13();
-}
-#endif
-
-#endif // POSTMORTEM_DEBUGGING
-#endif // __STM32F1__
@@ -123,7 +123,7 @@ uint8_t spiRec() {
 *
 * @details Uses DMA
 */
-void spiRead(uint8_t *buf, uint16_t nbyte) {
+void spiRead(uint8_t* buf, uint16_t nbyte) {
  SPI.dmaTransfer(0, const_cast<uint8_t*>(buf), nbyte);
 }

@@ -146,7 +146,7 @@ void spiSend(uint8_t b) {
 *
 * @details Use DMA
 */
-void spiSendBlock(uint8_t token, const uint8_t *buf) {
+void spiSendBlock(uint8_t token, const uint8_t* buf) {
  SPI.send(token);
  SPI.dmaSend(const_cast<uint8_t*>(buf), 512);
 }
@@ -160,7 +160,7 @@ uint8_t spiRec(uint32_t chan) { return SPI.transfer(0xFF); }
 void spiSend(uint32_t chan, byte b) { SPI.send(b); }

 // Write buffer to specified SPI channel
-void spiSend(uint32_t chan, const uint8_t *buf, size_t n) {
+void spiSend(uint32_t chan, const uint8_t* buf, size_t n) {
  for (size_t p = 0; p < n; p++) spiSend(chan, buf[p]);
 }

@@ -60,7 +60,7 @@ static inline __always_inline void my_usart_irq(ring_buffer *rb, ring_buffer *wb
  }
  else if (srflags & USART_SR_ORE) {
    // overrun and empty data, just do a dummy read to clear ORE
-    // and prevent a raise condition where a continuous interrupt stream (due to ORE set) occurs
+    // and prevent a raise condition where a continous interrupt stream (due to ORE set) occurs
    // (see chapter "Overrun error" ) in STM32 reference manual
    regs->DR;
  }
@@ -134,12 +134,12 @@ constexpr bool IsSerialClassAllowed(const HardwareSerial&) { return false; }
 // If you encounter this error, replace SerialX with MSerialX, for example MSerial3.

 // Non-TMC ports were already validated in HAL.h, so do not require verbose error messages.
+#ifdef MYSERIAL0
+  CHECK_CFG_SERIAL(MYSERIAL0);
+#endif
 #ifdef MYSERIAL1
  CHECK_CFG_SERIAL(MYSERIAL1);
 #endif
-#ifdef MYSERIAL2
-  CHECK_CFG_SERIAL(MYSERIAL2);
-#endif
 #ifdef LCD_SERIAL
  CHECK_CFG_SERIAL(LCD_SERIAL);
 #endif
@@ -47,7 +47,7 @@ struct MarlinSerial : public HardwareSerial {
  #endif
 };

-typedef Serial1Class<MarlinSerial> MSerialT;
+typedef Serial0Type<MarlinSerial> MSerialT;

 extern MSerialT MSerial1;
 extern MSerialT MSerial2;
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
InsanityAutomation	6118d41baa	Tweak probe preheat to wait for cooldown, bypass block on unload prime	2021-02-14 14:13:41 -05:00
InsanityAutomation	09dcc85328	Merge branch 'bugfix-2.0.x' into CR-6Devel	2021-02-14 12:06:14 -05:00
InsanityAutomation	a11f88a44a	Update probe.cpp	2021-02-10 14:20:41 -05:00
InsanityAutomation	c639e9fcc6	preheat and parking tweaks	2021-02-10 07:03:48 -05:00
InsanityAutomation	bfb81d8c92	Merge branch 'bugfix-2.0.x' into CR-6Devel	2021-02-08 11:16:20 -05:00
InsanityAutomation	fbb5a5baf2	Merge branch 'bugfix-2.0.x' into CR-6Devel	2021-02-06 12:58:31 -05:00
InsanityAutomation	83872e7b67	Update Configuration_adv.h	2021-02-06 12:57:44 -05:00
InsanityAutomation	7d4870fb4d	Update temperature.cpp	2021-02-06 12:57:41 -05:00
InsanityAutomation	3cacab40da	Update dwin.cpp	2021-02-02 09:32:51 -05:00
InsanityAutomation	b8d900b70d	Save after leveling explicitly	2021-01-30 18:08:46 -05:00
InsanityAutomation	b4ede61682	Bump to current, fix temp drop, bump version	2021-01-30 15:56:58 -05:00
InsanityAutomation	7e8e06fe2f	Merge branch 'bugfix-2.0.x' into CR-6Devel	2021-01-30 11:03:34 -05:00
InsanityAutomation	0d0beea222	Fix website feed, version	2021-01-19 21:46:56 -05:00
InsanityAutomation	f34a9cc66c	Update DGUSScreenHandler.cpp	2021-01-19 14:27:20 -05:00
InsanityAutomation	c4e0d50ad8	Bump to match community head	2021-01-17 16:56:40 -05:00
InsanityAutomation	bcc28b118c	Merge branch 'bugfix-2.0.x' into CR-6Devel	2021-01-17 13:29:54 -05:00
InsanityAutomation	2e59150dbe	Update Configuration.h	2021-01-09 20:08:14 -05:00
InsanityAutomation	60278bfd75	Update DGUSScreenHandler.cpp	2021-01-01 16:12:11 -05:00
InsanityAutomation	a77735d69a	Misc updates	2020-12-28 23:42:53 -05:00
InsanityAutomation	d03227d564	Minor tweaks	2020-12-27 16:53:14 -05:00
InsanityAutomation	6305bda964	453 board support	2020-12-27 13:08:16 -05:00
InsanityAutomation	e082d40d32	Update DGUSScreenHandler.cpp	2020-12-21 13:13:06 -05:00
InsanityAutomation	c4963d3d77	Update DGUSScreenHandler.cpp	2020-12-20 16:34:58 -05:00
InsanityAutomation	70740fa7b1	Welcome message	2020-12-20 15:03:27 -05:00
InsanityAutomation	226f077a9a	FInish Mesh, fix M117 size	2020-12-20 13:06:06 -05:00
InsanityAutomation	241c27e636	Add mesh value feedback	2020-12-15 13:52:37 -05:00
InsanityAutomation	b7d5374020	Send popup button text	2020-12-15 09:56:39 -05:00
InsanityAutomation	30e0d36bc3	Update Configuration.h	2020-12-14 11:34:07 -05:00
InsanityAutomation	057764766e	Update DGUSDisplayDef.cpp	2020-12-14 10:38:39 -05:00
InsanityAutomation	b5e131b523	Fixups for probe tare, add endstop report and M401	2020-12-13 14:55:50 -05:00
InsanityAutomation	92c60cd22e	Make M600 happy	2020-12-13 12:41:50 -05:00
InsanityAutomation	dd42b65980	Update Configuration.h	2020-12-12 18:49:02 -05:00
InsanityAutomation	f6627c0352	Touchup mesh point updates and M600 fix	2020-12-12 17:44:03 -05:00
InsanityAutomation	2dcdbf6f36	Filament change park and Probing disable heaters	2020-12-12 16:50:16 -05:00
InsanityAutomation	41ccd4a81b	Fix a partial overwrite of a merge, a few tweaks and version info	2020-12-12 16:36:42 -05:00
InsanityAutomation	5f20f8f9c7	CR6 Configs	2020-12-12 15:31:55 -05:00
InsanityAutomation	a4c2e21329	Initial Touchscreen Support	2020-12-12 15:31:45 -05:00
InsanityAutomation	e4714e4d29	Merge branch 'ProbesRequiringEnablePin' into CR-6Devel	2020-12-12 14:04:48 -05:00
InsanityAutomation	af9d36ae6d	Merge branch 'AddMinimumTempForNozzleAsProbe' into CR-6Devel	2020-12-12 14:03:26 -05:00
Jason Smith	c393153243	cleanup	2020-12-08 20:51:57 -08:00
Jason Smith	88613ca7e0	Invert compare, use correct constants, add parens	2020-12-08 20:47:51 -08:00
Jason Smith	88f1e635ac	Get all new PROBE_REQUIRES_MINTEMP code inside #ifs	2020-12-08 20:27:53 -08:00
Jason Smith	0c0f7adfaf	Clarify that PROBE_REQUIRES_MINTEMP_NOZZLE only works with first extruder	2020-12-08 20:27:01 -08:00
Jason Smith	49b53a04b5	Wait for the same hotend that is heating.	2020-12-08 20:26:36 -08:00
Jason Smith	72cdf4a11d	Typos, comments.	2020-12-08 20:15:18 -08:00
Jason Smith	647f776309	Merge remote-tracking branch 'upstream/bugfix-2.0.x' into PRR/20383_AddMinimumTempForNozzleAsProbe	2020-12-08 20:05:28 -08:00
Jason Smith	524eae8e86	explicit return type	2020-12-08 19:59:42 -08:00
Jason Smith	6ce0f3dafb	Fix inconsistent lambda return type	2020-12-08 19:54:31 -08:00
Jason Smith	61a1fb7478	Allow multiple endstops along with new feature, simplify code	2020-12-08 19:40:21 -08:00
Jason Smith	d8fa698b25	Fix missed rename	2020-12-08 01:21:56 -08:00
Jason Smith	5ed93ec18a	Only tare when homing if using probe	2020-12-08 01:18:20 -08:00
Jason Smith	a870ebdf9f	Add compile test for new feature	2020-12-08 01:11:29 -08:00
Jason Smith	0bf9f04a4d	Renames	2020-12-08 01:11:16 -08:00
Jason Smith	0653027c98	Merge remote-tracking branch 'upstream/bugfix-2.0.x' into PRR/20379_ProbesRequiringEnablePin	2020-12-07 21:43:32 -08:00
Victor Mateus Oliveira	5ccfbd44a6	Merge remote-tracking branch 'upstream/bugfix-2.0.x' into pr/20379	2020-12-07 18:00:58 -03:00
InsanityAutomation	26e61f6814	Merge branch 'AddMinimumTempForNozzleAsProbe' of https://github.com/InsanityAutomation/Marlin into AddMinimumTempForNozzleAsProbe	2020-12-06 11:11:34 -05:00
InsanityAutomation	e3982ca308	Set configs disabled, add tests	2020-12-06 11:11:14 -05:00
InsanityAutomation	62b81dc2be	Update nozzle.cpp	2020-12-06 11:08:32 -05:00
InsanityAutomation	1c0770ea5c	Update nozzle.cpp	2020-12-06 11:02:07 -05:00
InsanityAutomation	cfb1c4c9f2	Update LPC1768-tests	2020-12-06 10:55:17 -05:00
InsanityAutomation	438bae5f38	Set configs disabled, add tests	2020-12-06 10:48:13 -05:00
InsanityAutomation	3a7f17d782	Add G12 minimum temp	2020-12-06 10:36:25 -05:00
InsanityAutomation	8394f0c3f4	Generalize function out of nozzle as probe	2020-12-06 10:23:09 -05:00
Scott Lahteine	e8e4a742b0	fix typo	2020-12-05 22:45:04 -06:00
Scott Lahteine	48b61b7cbd	It's not golf	2020-12-05 22:42:15 -06:00
InsanityAutomation	bbdd481dab	Tweak comments	2020-12-05 18:34:58 -05:00
InsanityAutomation	1570559bba	Add safety temperature for nozzle as probe	2020-12-05 18:33:39 -05:00
InsanityAutomation	ae24cfa655	Fix borked search / replace	2020-12-05 17:55:46 -05:00
InsanityAutomation	f583d933eb	Tweaks following PR thread	2020-12-05 17:55:46 -05:00
InsanityAutomation	750bc64202	Add initial support for probes requiring Tare and Enable pins	2020-12-05 17:55:46 -05:00