Update pins_GMARSH_EBAB.h

Put in or for spi pins on 208 package
Initial Commit
2021-01-23 11:48:02 -05:00 · 2021-01-19 14:31:52 -05:00 · 2021-01-19 14:31:44 -05:00
901 changed files with 14638 additions and 31573 deletions
@@ -19,9 +19,9 @@
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 #

-# Generated files
+# Our automatic versioning scheme generates the following file
+# NEVER put it in the repository
 _Version.h
-bdf2u8g

 #
 # OS
@@ -1,4 +1,5 @@
- /** Marlin 3D Printer Firmware
+/**
+ * Marlin 3D Printer Firmware
 * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
 * Based on Sprinter and grbl.
@@ -41,34 +42,35 @@
 //===========================================================================

 /**
- * Here are some useful links to help get your machine configured and calibrated:
+ * Here are some standard links for getting your machine calibrated:
 *
- * Example Configs:     https://github.com/MarlinFirmware/Configurations/branches/all
- *
- * Průša Calculator:    https://blog.prusaprinters.org/calculator_3416/
- *
- * Calibration Guides:  https://reprap.org/wiki/Calibration
- *                      https://reprap.org/wiki/Triffid_Hunter%27s_Calibration_Guide
- *                      https://sites.google.com/site/repraplogphase/calibration-of-your-reprap
- *                      https://youtu.be/wAL9d7FgInk
- *
- * Calibration Objects: https://www.thingiverse.com/thing:5573
- *                      https://www.thingiverse.com/thing:1278865
+ * https://reprap.org/wiki/Calibration
+ * https://youtu.be/wAL9d7FgInk
+ * http://calculator.josefprusa.cz
+ * https://reprap.org/wiki/Triffid_Hunter%27s_Calibration_Guide
+ * https://www.thingiverse.com/thing:5573
+ * https://sites.google.com/site/repraplogphase/calibration-of-your-reprap
+ * https://www.thingiverse.com/thing:298812
 */

 //===========================================================================
-//========================== DELTA / SCARA / TPARA ==========================
+//============================= DELTA Printer ===============================
 //===========================================================================
+// For a Delta printer, start with one of the configuration files in the config/examples/delta directory
+// from https://github.com/MarlinFirmware/Configurations/branches/all and customize for your machine.
 //
-// Download configurations from the link above and customize for your machine.
-// Examples are located in config/examples/delta, .../SCARA, and .../TPARA.
-//
+
 //===========================================================================
+//============================= SCARA Printer ===============================
+//===========================================================================
+// For a SCARA printer, start with one of the configuration files in the config/examples/SCARA directory
+// from https://github.com/MarlinFirmware/Configurations/branches/all and customize for your machine.
+//

 // @section info

 // Author info of this build printed to the host during boot and M115
-#define STRING_CONFIG_H_AUTHOR "3DXtech / Insanity Automation" // Who made the changes.
+#define STRING_CONFIG_H_AUTHOR "(none, default config)" // Who made the changes.
 //#define CUSTOM_VERSION_FILE Version.h // Path from the root directory (no quotes)

 /**
@@ -126,7 +128,7 @@

 // Choose the name from boards.h that matches your setup
 #ifndef MOTHERBOARD
-  #define MOTHERBOARD BOARD_INTAMSYS40
+  #define MOTHERBOARD BOARD_GMARSH_EBAB
 #endif

 // Name displayed in the LCD "Ready" message and Info menu
@@ -162,8 +164,8 @@
 *   PRUSA_MMU1      : Průša MMU1 (The "multiplexer" version)
 *   PRUSA_MMU2      : Průša MMU2
 *   PRUSA_MMU2S     : Průša MMU2S (Requires MK3S extruder with motion sensor, EXTRUDERS = 5)
- *   SMUFF_EMU_MMU2  : Technik Gegg SMuFF (Průša MMU2 emulation mode)
- *   SMUFF_EMU_MMU2S : Technik Gegg SMuFF (Průša MMU2S emulation mode)
+ *   SMUFF_EMU_MMU2  : Technik Gegg SMUFF (Průša MMU2 emulation mode)
+ *   SMUFF_EMU_MMU2S : Technik Gegg SMUFF (Průša MMU2S emulation mode)
 *
 * Requires NOZZLE_PARK_FEATURE to park print head in case MMU unit fails.
 * See additional options in Configuration_adv.h.
@@ -310,29 +312,27 @@
 * Enable and connect the power supply to the PS_ON_PIN.
 * Specify whether the power supply is active HIGH or active LOW.
 */
-#define PSU_CONTROL
+//#define PSU_CONTROL
 //#define PSU_NAME "Power Supply"

 #if ENABLED(PSU_CONTROL)
-  #define PSU_ACTIVE_STATE HIGH      // Set 'LOW' for ATX, 'HIGH' for X-Box
+  #define PSU_ACTIVE_STATE LOW      // Set 'LOW' for ATX, 'HIGH' for X-Box

  //#define PSU_DEFAULT_OFF         // Keep power off until enabled directly with M80
-  #define PSU_POWERUP_DELAY 250   // (ms) Delay for the PSU to warm up to full power
+  //#define PSU_POWERUP_DELAY 250   // (ms) Delay for the PSU to warm up to full power

  //#define PSU_POWERUP_GCODE  "M355 S1"  // G-code to run after power-on (e.g., case light on)
  //#define PSU_POWEROFF_GCODE "M355 S0"  // G-code to run before power-off (e.g., case light off)

-  #define AUTO_POWER_CONTROL      // Enable automatic control of the PS_ON pin
+  //#define AUTO_POWER_CONTROL      // Enable automatic control of the PS_ON pin
  #if ENABLED(AUTO_POWER_CONTROL)
    #define AUTO_POWER_FANS         // Turn on PSU if fans need power
    #define AUTO_POWER_E_FANS
    #define AUTO_POWER_CONTROLLERFAN
    #define AUTO_POWER_CHAMBER_FAN
-    #define AUTO_POWER_COOLER_FAN
-    #define AUTO_POWER_E_TEMP        50 // (°C) Turn on PSU if any extruder is over this temperature
-    #define AUTO_POWER_CHAMBER_TEMP  30 // (°C) Turn on PSU if the chamber is over this temperature
-    //#define AUTO_POWER_COOLER_TEMP   26 // (°C) Turn on PSU if the cooler is over this temperature
-    #define POWER_TIMEOUT              120 // (s) Turn off power if the machine is idle for this duration
+    //#define AUTO_POWER_E_TEMP        50 // (°C) Turn on PSU if any extruder is over this temperature
+    //#define AUTO_POWER_CHAMBER_TEMP  30 // (°C) Turn on PSU if the chamber is over this temperature
+    #define POWER_TIMEOUT              30 // (s) Turn off power if the machine is idle for this duration
    //#define POWER_OFF_DELAY          60 // (s) Delay of poweroff after M81 command. Useful to let fans run for extra time.
  #endif
 #endif
@@ -408,7 +408,7 @@
 *   998 : Dummy Table that ALWAYS reads 25°C or the temperature defined below.
 *   999 : Dummy Table that ALWAYS reads 100°C or the temperature defined below.
 */
-#define TEMP_SENSOR_0 20
+#define TEMP_SENSOR_0 1
 #define TEMP_SENSOR_1 0
 #define TEMP_SENSOR_2 0
 #define TEMP_SENSOR_3 0
@@ -416,13 +416,12 @@
 #define TEMP_SENSOR_5 0
 #define TEMP_SENSOR_6 0
 #define TEMP_SENSOR_7 0
-#define TEMP_SENSOR_BED 1
+#define TEMP_SENSOR_BED 0
 #define TEMP_SENSOR_PROBE 0
-#define TEMP_SENSOR_CHAMBER 1
-#define TEMP_SENSOR_COOLER 0
+#define TEMP_SENSOR_CHAMBER 0

 // Dummy thermistor constant temperature readings, for use with 998 and 999
-#define DUMMY_THERMISTOR_998_VALUE  25
+#define DUMMY_THERMISTOR_998_VALUE 25
 #define DUMMY_THERMISTOR_999_VALUE 100

 // Resistor values when using MAX31865 sensors (-5) on TEMP_SENSOR_0 / 1
@@ -436,18 +435,14 @@
 //#define TEMP_SENSOR_1_AS_REDUNDANT
 #define MAX_REDUNDANT_TEMP_SENSOR_DIFF 10

-#define TEMP_RESIDENCY_TIME      3  // (seconds) Time to wait for hotend to "settle" in M109
-#define TEMP_WINDOW              3  // (°C) Temperature proximity for the "temperature reached" timer
-#define TEMP_HYSTERESIS          5  // (°C) Temperature proximity considered "close enough" to the target
+#define TEMP_RESIDENCY_TIME     10  // (seconds) Time to wait for hotend to "settle" in M109
+#define TEMP_WINDOW              1  // (°C) Temperature proximity for the "temperature reached" timer
+#define TEMP_HYSTERESIS          3  // (°C) Temperature proximity considered "close enough" to the target

-#define TEMP_BED_RESIDENCY_TIME  5  // (seconds) Time to wait for bed to "settle" in M190
+#define TEMP_BED_RESIDENCY_TIME 10  // (seconds) Time to wait for bed to "settle" in M190
 #define TEMP_BED_WINDOW          1  // (°C) Temperature proximity for the "temperature reached" timer
 #define TEMP_BED_HYSTERESIS      3  // (°C) Temperature proximity considered "close enough" to the target

-#define TEMP_CHAMBER_RESIDENCY_TIME 10  // (seconds) Time to wait for chamber to "settle" in M191
-#define TEMP_CHAMBER_WINDOW      1  // (°C) Temperature proximity for the "temperature reached" timer
-#define TEMP_CHAMBER_HYSTERESIS  5  // (°C) Temperature proximity considered "close enough" to the target
-
 // Below this temperature the heater will be switched off
 // because it probably indicates a broken thermistor wire.
 #define HEATER_0_MINTEMP   5
@@ -459,12 +454,11 @@
 #define HEATER_6_MINTEMP   5
 #define HEATER_7_MINTEMP   5
 #define BED_MINTEMP        5
-#define CHAMBER_MINTEMP    5

 // Above this temperature the heater will be switched off.
 // This can protect components from overheating, but NOT from shorts and failures.
 // (Use MINTEMP for thermistor short/failure protection.)
-#define HEATER_0_MAXTEMP 415
+#define HEATER_0_MAXTEMP 275
 #define HEATER_1_MAXTEMP 275
 #define HEATER_2_MAXTEMP 275
 #define HEATER_3_MAXTEMP 275
@@ -473,16 +467,6 @@
 #define HEATER_6_MAXTEMP 275
 #define HEATER_7_MAXTEMP 275
 #define BED_MAXTEMP      150
-#define CHAMBER_MAXTEMP  80
-
-/**
- * Thermal Overshoot
- * During heatup (and printing) the temperature can often "overshoot" the target by many degrees
- * (especially before PID tuning). Setting the target temperature too close to MAXTEMP guarantees
- * a MAXTEMP shutdown! Use these values to forbid temperatures being set too close to MAXTEMP.
- */
-#define HOTEND_OVERSHOOT 15   // (°C) Forbid temperatures over MAXTEMP - OVERSHOOT
-#define BED_OVERSHOOT    10   // (°C) Forbid temperatures over MAXTEMP - OVERSHOOT

 //===========================================================================
 //============================= PID Settings ================================
@@ -496,8 +480,8 @@
 #define PID_K1 0.95      // Smoothing factor within any PID loop

 #if ENABLED(PIDTEMP)
-  #define PID_EDIT_MENU         // Add PID editing to the "Advanced Settings" menu. (~700 bytes of PROGMEM)
-  #define PID_AUTOTUNE_MENU     // Add PID auto-tuning to the "Advanced Settings" menu. (~250 bytes of PROGMEM)
+  //#define PID_EDIT_MENU         // Add PID editing to the "Advanced Settings" menu. (~700 bytes of PROGMEM)
+  //#define PID_AUTOTUNE_MENU     // Add PID auto-tuning to the "Advanced Settings" menu. (~250 bytes of PROGMEM)
  //#define PID_PARAMS_PER_HOTEND // Uses separate PID parameters for each extruder (useful for mismatched extruders)
                                  // Set/get with gcode: M301 E[extruder number, 0-2]

@@ -508,9 +492,9 @@
    #define DEFAULT_Ki_LIST {   1.08,   1.08 }
    #define DEFAULT_Kd_LIST { 114.00, 114.00 }
  #else
-    #define DEFAULT_Kp 10.5
-  #define DEFAULT_Ki 0.45
-  #define DEFAULT_Kd 70
+    #define DEFAULT_Kp  22.20
+    #define DEFAULT_Ki   1.08
+    #define DEFAULT_Kd 114.00
  #endif
 #endif // PIDTEMP

@@ -531,7 +515,7 @@
 * heater. If your configuration is significantly different than this and you don't understand
 * the issues involved, don't use bed PID until someone else verifies that your hardware works.
 */
-#define PIDTEMPBED
+//#define PIDTEMPBED

 //#define BED_LIMIT_SWITCHING

@@ -547,60 +531,16 @@
  //#define MIN_BED_POWER 0
  //#define PID_BED_DEBUG // Sends debug data to the serial port.

-  //120V 250W silicone heater into 4mm borosilicate (MendelMax 1.5+)
-  //from FOPDT model - kp=.39 Tp=405 Tdead=66, Tc set to 79.2, aggressive factor of .15 (vs .1, 1, 10)
-  #define DEFAULT_bedKp 104.28
-  #define DEFAULT_bedKi 20.53
-  #define DEFAULT_bedKd 353.10
+  // 120V 250W silicone heater into 4mm borosilicate (MendelMax 1.5+)
+  // from FOPDT model - kp=.39 Tp=405 Tdead=66, Tc set to 79.2, aggressive factor of .15 (vs .1, 1, 10)
+  #define DEFAULT_bedKp 10.00
+  #define DEFAULT_bedKi .023
+  #define DEFAULT_bedKd 305.4

  // FIND YOUR OWN: "M303 E-1 C8 S90" to run autotune on the bed at 90 degreesC for 8 cycles.
 #endif // PIDTEMPBED

-//===========================================================================
-//==================== PID > Chamber Temperature Control ====================
-//===========================================================================
-
-/**
- * PID Chamber Heating
- *
- * If this option is enabled set PID constants below.
- * If this option is disabled, bang-bang will be used and CHAMBER_LIMIT_SWITCHING will enable
- * hysteresis.
- *
- * The PID frequency will be the same as the extruder PWM.
- * If PID_dT is the default, and correct for the hardware/configuration, that means 7.689Hz,
- * which is fine for driving a square wave into a resistive load and does not significantly
- * impact FET heating. This also works fine on a Fotek SSR-10DA Solid State Relay into a 200W
- * heater. If your configuration is significantly different than this and you don't understand
- * the issues involved, don't use chamber PID until someone else verifies that your hardware works.
- */
-//#define PIDTEMPCHAMBER
-//#define CHAMBER_LIMIT_SWITCHING
-
-/**
- * Max Chamber Power
- * Applies to all forms of chamber control (PID, bang-bang, and bang-bang with hysteresis).
- * When set to any value below 255, enables a form of PWM to the chamber heater that acts like a divider
- * so don't use it unless you are OK with PWM on your heater. (See the comment on enabling PIDTEMPCHAMBER)
- */
-#define MAX_CHAMBER_POWER 255 // limits duty cycle to chamber heater; 255=full current
-
-#if ENABLED(PIDTEMPCHAMBER)
-  #define MIN_CHAMBER_POWER 0
-  //#define PID_CHAMBER_DEBUG // Sends debug data to the serial port.
-
-  // Lasko "MyHeat Personal Heater" (200w) modified with a Fotek SSR-10DA to control only the heating element
-  // and placed inside the small Creality printer enclosure tent.
-  //
-  #define DEFAULT_chamberKp 37.04
-  #define DEFAULT_chamberKi 1.40
-  #define DEFAULT_chamberKd 655.17
-  // M309 P37.04 I1.04 D655.17
-
-  // FIND YOUR OWN: "M303 E-2 C8 S50" to run autotune on the chamber at 50 degreesC for 8 cycles.
-#endif // PIDTEMPCHAMBER
-
-#if ANY(PIDTEMP, PIDTEMPBED, PIDTEMPCHAMBER)
+#if EITHER(PIDTEMP, PIDTEMPBED)
  //#define PID_DEBUG             // Sends debug data to the serial port. Use 'M303 D' to toggle activation.
  //#define PID_OPENLOOP          // Puts PID in open loop. M104/M140 sets the output power from 0 to PID_MAX
  //#define SLOW_PWM_HEATERS      // PWM with very low frequency (roughly 0.125Hz=8s) and minimum state time of approximately 1s useful for heaters driven by a relay
@@ -647,7 +587,6 @@
 #define THERMAL_PROTECTION_HOTENDS // Enable thermal protection for all extruders
 #define THERMAL_PROTECTION_BED     // Enable thermal protection for the heated bed
 #define THERMAL_PROTECTION_CHAMBER // Enable thermal protection for the heated chamber
-#define THERMAL_PROTECTION_COOLER  // Enable thermal protection for the laser cooling

 //===========================================================================
 //============================= Mechanical Settings =========================
@@ -708,13 +647,13 @@
 #endif

 // Mechanical endstop with COM to ground and NC to Signal uses "false" here (most common setup).
-#define X_MIN_ENDSTOP_INVERTING true // Set to true to invert the logic of the endstop.
-#define Y_MIN_ENDSTOP_INVERTING true // Set to true to invert the logic of the endstop.
-#define Z_MIN_ENDSTOP_INVERTING true // Set to true to invert the logic of the endstop.
-#define X_MAX_ENDSTOP_INVERTING true // Set to true to invert the logic of the endstop.
-#define Y_MAX_ENDSTOP_INVERTING true // Set to true to invert the logic of the endstop.
-#define Z_MAX_ENDSTOP_INVERTING true // Set to true to invert the logic of the endstop.
-#define Z_MIN_PROBE_ENDSTOP_INVERTING true // Set to true to invert the logic of the probe.
+#define X_MIN_ENDSTOP_INVERTING false // Set to true to invert the logic of the endstop.
+#define Y_MIN_ENDSTOP_INVERTING false // Set to true to invert the logic of the endstop.
+#define Z_MIN_ENDSTOP_INVERTING false // Set to true to invert the logic of the endstop.
+#define X_MAX_ENDSTOP_INVERTING false // Set to true to invert the logic of the endstop.
+#define Y_MAX_ENDSTOP_INVERTING false // Set to true to invert the logic of the endstop.
+#define Z_MAX_ENDSTOP_INVERTING false // Set to true to invert the logic of the endstop.
+#define Z_MIN_PROBE_ENDSTOP_INVERTING false // Set to true to invert the logic of the probe.

 /**
 * Stepper Drivers
@@ -797,14 +736,14 @@
 * Override with M92
 *                                      X, Y, Z, E0 [, E1[, E2...]]
 */
-#define DEFAULT_AXIS_STEPS_PER_UNIT   { 80, 80, 800, 92.6 }
+#define DEFAULT_AXIS_STEPS_PER_UNIT   { 80, 80, 400, 500 }

 /**
 * Default Max Feed Rate (mm/s)
 * Override with M203
 *                                      X, Y, Z, E0 [, E1[, E2...]]
 */
-#define DEFAULT_MAX_FEEDRATE          { 300, 300, 20, 70 }
+#define DEFAULT_MAX_FEEDRATE          { 300, 300, 5, 25 }

 //#define LIMITED_MAX_FR_EDITING        // Limit edit via M203 or LCD to DEFAULT_MAX_FEEDRATE * 2
 #if ENABLED(LIMITED_MAX_FR_EDITING)
@@ -817,7 +756,7 @@
 * Override with M201
 *                                      X, Y, Z, E0 [, E1[, E2...]]
 */
-#define DEFAULT_MAX_ACCELERATION      { 9000, 9000, 100, 10000 }
+#define DEFAULT_MAX_ACCELERATION      { 3000, 3000, 100, 10000 }

 //#define LIMITED_MAX_ACCEL_EDITING     // Limit edit via M201 or LCD to DEFAULT_MAX_ACCELERATION * 2
 #if ENABLED(LIMITED_MAX_ACCEL_EDITING)
@@ -844,7 +783,7 @@
 * When changing speed and direction, if the difference is less than the
 * value set here, it may happen instantaneously.
 */
-#define CLASSIC_JERK
+//#define CLASSIC_JERK
 #if ENABLED(CLASSIC_JERK)
  #define DEFAULT_XJERK 10.0
  #define DEFAULT_YJERK 10.0
@@ -881,7 +820,7 @@
 *
 * See https://github.com/synthetos/TinyG/wiki/Jerk-Controlled-Motion-Explained
 */
-#define S_CURVE_ACCELERATION
+//#define S_CURVE_ACCELERATION

 //===========================================================================
 //============================= Z Probe Options =============================
@@ -1054,13 +993,13 @@
 #define PROBING_MARGIN 10

 // X and Y axis travel speed (mm/min) between probes
-#define XY_PROBE_FEEDRATE (133*60)
+#define XY_PROBE_SPEED (133*60)

 // Feedrate (mm/min) for the first approach when double-probing (MULTIPLE_PROBING == 2)
-#define Z_PROBE_FEEDRATE_FAST (4*60)
+#define Z_PROBE_SPEED_FAST (4*60)

 // Feedrate (mm/min) for the "accurate" probe of each point
-#define Z_PROBE_FEEDRATE_SLOW (Z_PROBE_FEEDRATE_FAST / 2)
+#define Z_PROBE_SPEED_SLOW (Z_PROBE_SPEED_FAST / 2)

 /**
 * Probe Activation Switch
@@ -1123,8 +1062,8 @@
 #define Z_PROBE_LOW_POINT          -2 // Farthest distance below the trigger-point to go before stopping

 // For M851 give a range for adjusting the Z probe offset
-#define Z_PROBE_OFFSET_RANGE_MIN -9
-#define Z_PROBE_OFFSET_RANGE_MAX 9
+#define Z_PROBE_OFFSET_RANGE_MIN -20
+#define Z_PROBE_OFFSET_RANGE_MAX 20

 // Enable the M48 repeatability test to test probe accuracy
 //#define Z_MIN_PROBE_REPEATABILITY_TEST
@@ -1145,7 +1084,6 @@
 //#define PROBING_HEATERS_OFF       // Turn heaters off when probing
 #if ENABLED(PROBING_HEATERS_OFF)
  //#define WAIT_FOR_BED_HEATER     // Wait for bed to heat back up between probes (to improve accuracy)
-  //#define WAIT_FOR_HOTEND         // Wait for hotend to heat back up between probes (to improve accuracy & prevent cold extrude)
 #endif
 //#define PROBING_FANS_OFF          // Turn fans off when probing
 //#define PROBING_STEPPERS_OFF      // Turn steppers off (unless needed to hold position) when probing
@@ -1182,9 +1120,9 @@
 // @section machine

 // Invert the stepper direction. Change (or reverse the motor connector) if an axis goes the wrong way.
-#define INVERT_X_DIR true
-#define INVERT_Y_DIR false
-#define INVERT_Z_DIR true
+#define INVERT_X_DIR false
+#define INVERT_Y_DIR true
+#define INVERT_Z_DIR false

 // @section extruder

@@ -1202,13 +1140,7 @@

 //#define NO_MOTION_BEFORE_HOMING // Inhibit movement until all axes have been homed. Also enable HOME_AFTER_DEACTIVATE for extra safety.
 //#define HOME_AFTER_DEACTIVATE   // Require rehoming after steppers are deactivated. Also enable NO_MOTION_BEFORE_HOMING for extra safety.
-
-/**
- * Set Z_IDLE_HEIGHT if the Z-Axis moves on its own when steppers are disabled.
- *  - Use a low value (i.e., Z_MIN_POS) if the nozzle falls down to the bed.
- *  - Use a large value (i.e., Z_MAX_POS) if the bed falls down, away from the nozzle.
- */
-//#define Z_IDLE_HEIGHT Z_HOME_POS
+//#define UNKNOWN_Z_NO_RAISE      // Don't raise Z (lower the bed) if Z is "unknown." For beds that fall when Z is powered off.

 //#define Z_HOMING_HEIGHT  4      // (mm) Minimal Z height before homing (G28) for Z clearance above the bed, clamps, ...
                                  // Be sure to have this much clearance over your Z_MAX_POS to prevent grinding.
@@ -1224,8 +1156,8 @@
 // @section machine

 // The size of the print bed
-#define X_BED_SIZE 260
-#define Y_BED_SIZE 260
+#define X_BED_SIZE 200
+#define Y_BED_SIZE 200

 // Travel limits (mm) after homing, corresponding to endstop positions.
 #define X_MIN_POS 0
@@ -1233,7 +1165,7 @@
 #define Z_MIN_POS 0
 #define X_MAX_POS X_BED_SIZE
 #define Y_MAX_POS Y_BED_SIZE
-#define Z_MAX_POS 260
+#define Z_MAX_POS 200

 /**
 * Software Endstops
@@ -1261,7 +1193,7 @@
 #endif

 #if EITHER(MIN_SOFTWARE_ENDSTOPS, MAX_SOFTWARE_ENDSTOPS)
-  #define SOFT_ENDSTOPS_MENU_ITEM  // Enable/Disable software endstops from the LCD
+  //#define SOFT_ENDSTOPS_MENU_ITEM  // Enable/Disable software endstops from the LCD
 #endif

 /**
@@ -1277,7 +1209,7 @@
 * RAMPS-based boards use SERVO3_PIN for the first runout sensor.
 * For other boards you may need to define FIL_RUNOUT_PIN, FIL_RUNOUT2_PIN, etc.
 */
-#define FILAMENT_RUNOUT_SENSOR
+//#define FILAMENT_RUNOUT_SENSOR
 #if ENABLED(FILAMENT_RUNOUT_SENSOR)
  #define FIL_RUNOUT_ENABLED_DEFAULT true // Enable the sensor on startup. Override with M412 followed by M500.
  #define NUM_RUNOUT_SENSORS   1          // Number of sensors, up to one per extruder. Define a FIL_RUNOUT#_PIN for each.
@@ -1285,8 +1217,6 @@
  #define FIL_RUNOUT_STATE     LOW        // Pin state indicating that filament is NOT present.
  #define FIL_RUNOUT_PULLUP               // Use internal pullup for filament runout pins.
  //#define FIL_RUNOUT_PULLDOWN           // Use internal pulldown for filament runout pins.
-  //#define WATCH_ALL_RUNOUT_SENSORS      // Execute runout script on any triggering sensor, not only for the active extruder.
-                                          // This is automatically enabled for MIXING_EXTRUDERs.

  // Override individually if the runout sensors vary
  //#define FIL_RUNOUT1_STATE LOW
@@ -1321,15 +1251,14 @@
  //#define FIL_RUNOUT8_PULLUP
  //#define FIL_RUNOUT8_PULLDOWN

-  // Commands to execute on filament runout.
-  // With multiple runout sensors use the %c placeholder for the current tool in commands (e.g., "M600 T%c")
-  // NOTE: After 'M412 H1' the host handles filament runout and this script does not apply.
+  // Set one or more commands to execute on filament runout.
+  // (After 'M412 H' Marlin will ask the host to handle the process.)
  #define FILAMENT_RUNOUT_SCRIPT "M600"

  // After a runout is detected, continue printing this length of filament
  // before executing the runout script. Useful for a sensor at the end of
  // a feed tube. Requires 4 bytes SRAM per sensor, plus 4 bytes overhead.
-  #define FILAMENT_RUNOUT_DISTANCE_MM 5
+  //#define FILAMENT_RUNOUT_DISTANCE_MM 25

  #ifdef FILAMENT_RUNOUT_DISTANCE_MM
    // Enable this option to use an encoder disc that toggles the runout pin
@@ -1381,14 +1310,14 @@
 //#define AUTO_BED_LEVELING_LINEAR
 //#define AUTO_BED_LEVELING_BILINEAR
 //#define AUTO_BED_LEVELING_UBL
-#define MESH_BED_LEVELING
+//#define MESH_BED_LEVELING

 /**
 * Normally G28 leaves leveling disabled on completion. Enable one of
 * these options to restore the prior leveling state or to always enable
 * leveling immediately after G28.
 */
-#define RESTORE_LEVELING_AFTER_G28
+//#define RESTORE_LEVELING_AFTER_G28
 //#define ENABLE_LEVELING_AFTER_G28

 /**
@@ -1425,14 +1354,13 @@
  /**
   * Enable the G26 Mesh Validation Pattern tool.
   */
-  #define G26_MESH_VALIDATION
+  //#define G26_MESH_VALIDATION
  #if ENABLED(G26_MESH_VALIDATION)
    #define MESH_TEST_NOZZLE_SIZE    0.4  // (mm) Diameter of primary nozzle.
-    #define MESH_TEST_LAYER_HEIGHT   0.2  // (mm) Default layer height for G26.
-    #define MESH_TEST_HOTEND_TEMP  205    // (°C) Default nozzle temperature for G26.
-    #define MESH_TEST_BED_TEMP      60    // (°C) Default bed temperature for G26.
-    #define G26_XY_FEEDRATE         20    // (mm/s) Feedrate for G26 XY moves.
-    #define G26_XY_FEEDRATE_TRAVEL 100    // (mm/s) Feedrate for G26 XY travel moves.
+    #define MESH_TEST_LAYER_HEIGHT   0.2  // (mm) Default layer height for the G26 Mesh Validation Tool.
+    #define MESH_TEST_HOTEND_TEMP  205    // (°C) Default nozzle temperature for the G26 Mesh Validation Tool.
+    #define MESH_TEST_BED_TEMP      60    // (°C) Default bed temperature for the G26 Mesh Validation Tool.
+    #define G26_XY_FEEDRATE         20    // (mm/s) Feedrate for XY Moves for the G26 Mesh Validation Tool.
    #define G26_RETRACT_MULTIPLIER   1.0  // G26 Q (retraction) used by default between mesh test elements.
  #endif

@@ -1490,7 +1418,7 @@
  //===========================================================================

  #define MESH_INSET 10          // Set Mesh bounds as an inset region of the bed
-  #define GRID_MAX_POINTS_X 5    // Don't use more than 7 points per axis, implementation limited.
+  #define GRID_MAX_POINTS_X 3    // Don't use more than 7 points per axis, implementation limited.
  #define GRID_MAX_POINTS_Y GRID_MAX_POINTS_X

  //#define MESH_G28_REST_ORIGIN // After homing all axes ('G28' or 'G28 XYZ') rest Z at Z_MIN_POS
@@ -1501,16 +1429,16 @@
 * Add a bed leveling sub-menu for ABL or MBL.
 * Include a guided procedure if manual probing is enabled.
 */
-#define LCD_BED_LEVELING
+//#define LCD_BED_LEVELING

 #if ENABLED(LCD_BED_LEVELING)
  #define MESH_EDIT_Z_STEP  0.025 // (mm) Step size while manually probing Z axis.
  #define LCD_PROBE_Z_RANGE 4     // (mm) Z Range centered on Z_MIN_POS for LCD Z adjustment
-  #define MESH_EDIT_MENU        // Add a menu to edit mesh points
+  //#define MESH_EDIT_MENU        // Add a menu to edit mesh points
 #endif

 // Add a menu item to move between bed corners for manual bed adjustment
-#define LEVEL_BED_CORNERS
+//#define LEVEL_BED_CORNERS

 #if ENABLED(LEVEL_BED_CORNERS)
  #define LEVEL_CORNERS_INSET_LFRB { 30, 30, 30, 30 } // (mm) Left, Front, Right, Back insets
@@ -1655,12 +1583,12 @@
 *   M501 - Read settings from EEPROM. (i.e., Throw away unsaved changes)
 *   M502 - Revert settings to "factory" defaults. (Follow with M500 to init the EEPROM.)
 */
-#define EEPROM_SETTINGS     // Persistent storage with M500 and M501
+//#define EEPROM_SETTINGS     // Persistent storage with M500 and M501
 //#define DISABLE_M503        // Saves ~2700 bytes of PROGMEM. Disable for release!
 #define EEPROM_CHITCHAT       // Give feedback on EEPROM commands. Disable to save PROGMEM.
 #define EEPROM_BOOT_SILENT    // Keep M503 quiet and only give errors during first load
 #if ENABLED(EEPROM_SETTINGS)
-  #define EEPROM_AUTO_INIT  // Init EEPROM automatically on any errors.
+  //#define EEPROM_AUTO_INIT  // Init EEPROM automatically on any errors.
 #endif

 //
@@ -1685,19 +1613,15 @@

 // @section temperature

-//
-// Preheat Constants - Up to 5 are supported without changes
-//
+// Preheat Constants
 #define PREHEAT_1_LABEL       "PLA"
 #define PREHEAT_1_TEMP_HOTEND 180
 #define PREHEAT_1_TEMP_BED     70
-#define PREHEAT_1_TEMP_CHAMBER 35
 #define PREHEAT_1_FAN_SPEED     0 // Value from 0 to 255

 #define PREHEAT_2_LABEL       "ABS"
 #define PREHEAT_2_TEMP_HOTEND 240
 #define PREHEAT_2_TEMP_BED    110
-#define PREHEAT_2_TEMP_CHAMBER 45
 #define PREHEAT_2_FAN_SPEED     0 // Value from 0 to 255

 /**
@@ -1711,11 +1635,11 @@
 *    P1  Raise the nozzle always to Z-park height.
 *    P2  Raise the nozzle by Z-park amount, limited to Z_MAX_POS.
 */
-#define NOZZLE_PARK_FEATURE
+//#define NOZZLE_PARK_FEATURE

 #if ENABLED(NOZZLE_PARK_FEATURE)
  // Specify a park position as { X, Y, Z_raise }
-  #define NOZZLE_PARK_POINT { (X_CENTER), (Y_CENTER), 20 }
+  #define NOZZLE_PARK_POINT { (X_MIN_POS + 10), (Y_MAX_POS - 10), 20 }
  //#define NOZZLE_PARK_X_ONLY          // X move only is required to park
  //#define NOZZLE_PARK_Y_ONLY          // Y move only is required to park
  #define NOZZLE_PARK_Z_RAISE_MIN   2   // (mm) Always raise Z by at least this distance
@@ -1829,9 +1753,6 @@
 * View the current statistics with M78.
 */
 //#define PRINTCOUNTER
-#if ENABLED(PRINTCOUNTER)
-  #define PRINTCOUNTER_SAVE_INTERVAL 60 // (minutes) EEPROM save interval during print
-#endif

 /**
 * Password
@@ -1876,9 +1797,9 @@
 * Select the language to display on the LCD. These languages are available:
 *
 *   en, an, bg, ca, cz, da, de, el, el_gr, es, eu, fi, fr, gl, hr, hu, it,
- *   jp_kana, ko_KR, nl, pl, pt, pt_br, ro, ru, sk, sv, tr, uk, vi, zh_CN, zh_TW
+ *   jp_kana, ko_KR, nl, pl, pt, pt_br, ro, ru, sk, tr, uk, vi, zh_CN, zh_TW, test
 *
- * :{ 'en':'English', 'an':'Aragonese', 'bg':'Bulgarian', 'ca':'Catalan', 'cz':'Czech', 'da':'Danish', 'de':'German', 'el':'Greek', 'el_gr':'Greek (Greece)', 'es':'Spanish', 'eu':'Basque-Euskera', 'fi':'Finnish', 'fr':'French', 'gl':'Galician', 'hr':'Croatian', 'hu':'Hungarian', 'it':'Italian', 'jp_kana':'Japanese', 'ko_KR':'Korean (South Korea)', 'nl':'Dutch', 'pl':'Polish', 'pt':'Portuguese', 'pt_br':'Portuguese (Brazilian)', 'ro':'Romanian', 'ru':'Russian', 'sk':'Slovak', 'sv':'Swedish', 'tr':'Turkish', 'uk':'Ukrainian', 'vi':'Vietnamese', 'zh_CN':'Chinese (Simplified)', 'zh_TW':'Chinese (Traditional)' }
+ * :{ 'en':'English', 'an':'Aragonese', 'bg':'Bulgarian', 'ca':'Catalan', 'cz':'Czech', 'da':'Danish', 'de':'German', 'el':'Greek', 'el_gr':'Greek (Greece)', 'es':'Spanish', 'eu':'Basque-Euskera', 'fi':'Finnish', 'fr':'French', 'gl':'Galician', 'hr':'Croatian', 'hu':'Hungarian', 'it':'Italian', 'jp_kana':'Japanese', 'ko_KR':'Korean (South Korea)', 'nl':'Dutch', 'pl':'Polish', 'pt':'Portuguese', 'pt_br':'Portuguese (Brazilian)', 'ro':'Romanian', 'ru':'Russian', 'sk':'Slovak', 'tr':'Turkish', 'uk':'Ukrainian', 'vi':'Vietnamese', 'zh_CN':'Chinese (Simplified)', 'zh_TW':'Chinese (Traditional)', 'test':'TEST' }
 */
 #define LCD_LANGUAGE en

@@ -1989,7 +1910,7 @@
 //
 // Add individual axis homing items (Home X, Home Y, and Home Z) to the LCD menu.
 //
-#define INDIVIDUAL_AXIS_HOMING_MENU
+//#define INDIVIDUAL_AXIS_HOMING_MENU

 //
 // SPEAKER/BUZZER
@@ -1997,7 +1918,7 @@
 // If you have a speaker that can produce tones, enable it here.
 // By default Marlin assumes you have a buzzer with a fixed frequency.
 //
-#define SPEAKER
+//#define SPEAKER

 //
 // The duration and frequency for the UI feedback sound.
@@ -2022,14 +1943,6 @@
 //
 //#define REPRAP_DISCOUNT_SMART_CONTROLLER

-//
-// GT2560 (YHCB2004) LCD Display
-//
-// Requires Testato, Koepel softwarewire library and
-// Andriy Golovnya's LiquidCrystal_AIP31068 library.
-//
-//#define YHCB2004
-
 //
 // Original RADDS LCD Display+Encoder+SDCardReader
 // http://doku.radds.org/dokumentation/lcd-display/
@@ -2178,12 +2091,7 @@
 // RepRapDiscount FULL GRAPHIC Smart Controller
 // https://reprap.org/wiki/RepRapDiscount_Full_Graphic_Smart_Controller
 //
-#define REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER
-
-//
-// K.3D Full Graphic Smart Controller
-//
-//#define K3D_FULL_GRAPHIC_SMART_CONTROLLER
+//#define REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER

 //
 // ReprapWorld Graphical LCD
@@ -2322,7 +2230,7 @@
 //#define OLED_PANEL_TINYBOY2

 //
-// MKS OLED 1.3" 128×64 Full Graphics Controller
+// MKS OLED 1.3" 128×64 FULL GRAPHICS CONTROLLER
 // https://reprap.org/wiki/MKS_12864OLED
 //
 // Tiny, but very sharp OLED display
@@ -2331,7 +2239,7 @@
 //#define MKS_12864OLED_SSD1306  // Uses the SSD1306 controller

 //
-// Zonestar OLED 128×64 Full Graphics Controller
+// Zonestar OLED 128×64 FULL GRAPHICS CONTROLLER
 //
 //#define ZONESTAR_12864LCD           // Graphical (DOGM) with ST7920 controller
 //#define ZONESTAR_12864OLED          // 1.3" OLED with SH1106 controller (default)
@@ -2348,15 +2256,10 @@
 //#define OVERLORD_OLED

 //
-// FYSETC OLED 2.42" 128×64 Full Graphics Controller with WS2812 RGB
+// FYSETC OLED 2.42" 128×64 FULL GRAPHICS CONTROLLER with WS2812 RGB
 // Where to find : https://www.aliexpress.com/item/4000345255731.html
 //#define FYSETC_242_OLED_12864   // Uses the SSD1309 controller

-//
-// K.3D SSD1309 OLED 2.42" 128×64 Full Graphics Controller
-//
-//#define K3D_242_OLED_CONTROLLER   // Software SPI
-
 //=============================================================================
 //========================== Extensible UI Displays ===========================
 //=============================================================================
@@ -2369,7 +2272,6 @@
 //#define DGUS_LCD_UI_ORIGIN
 //#define DGUS_LCD_UI_FYSETC
 //#define DGUS_LCD_UI_HIPRECY
-//#define DGUS_LCD_UI_MKS

 //
 // Touch-screen LCD for Malyan M200/M300 printers
@@ -2395,14 +2297,6 @@
  //#define ANYCUBIC_LCD_DEBUG
 #endif

-//
-// 320x240 Nextion 2.8" serial TFT Resistive Touch Screen NX3224T028
-//
-//#define NEXTION_TFT
-#if ENABLED(NEXTION_TFT)
-  #define LCD_SERIAL_PORT 1  // Default is 1 for Nextion
-#endif
-
 //
 // Third-party or vendor-customized controller interfaces.
 // Sources should be installed in 'src/lcd/extui'.
@@ -2559,10 +2453,6 @@
  //#define TOUCH_OFFSET_Y        257
  //#define TOUCH_ORIENTATION TOUCH_LANDSCAPE

-  #if BOTH(TOUCH_SCREEN_CALIBRATION, EEPROM_SETTINGS)
-    #define TOUCH_CALIBRATION_AUTO_SAVE // Auto save successful calibration values to EEPROM
-  #endif
-
  #if ENABLED(TFT_COLOR_UI)
    //#define SINGLE_TOUCH_NAVIGATION
  #endif
@@ -2679,7 +2569,6 @@
  // Use a single NeoPixel LED for static (background) lighting
  //#define NEOPIXEL_BKGD_LED_INDEX  0               // Index of the LED to use
  //#define NEOPIXEL_BKGD_COLOR { 255, 255, 255, 0 } // R, G, B, W
-  //#define NEOPIXEL_BKGD_ALWAYS_ON                  // Keep the backlight on when other NeoPixels are off
 #endif

 /**
@@ -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
@@ -1,103 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * Custom Bitmap for splashscreen
- *
- * You may use one of the following tools to generate the C++ bitmap array from
- * a black and white image:
- *
- *  - http://www.marlinfw.org/tools/u8glib/converter.html
- *  - http://www.digole.com/tools/PicturetoC_Hex_converter.php
- */
-#include <avr/pgmspace.h>
-
-#define CUSTOM_BOOTSCREEN_TIMEOUT   2500
-#define CUSTOM_BOOTSCREEN_BMPWIDTH  125
-//#define CUSTOM_BOOTSCREEN_INVERTED
-
-const unsigned char custom_start_bmp[] PROGMEM = {
-  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // ..............................................................##................................................................
-  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x60,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // ..............................................................##.##.............................................................
-  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x88,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // ................................................................#...#...........................................................
-  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE7,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // ................................................................###..###........................................................
-  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x71,0x80,0x00,0x00,0x00,0x00,0x00,0x00, // .................................................................###...##.......................................................
-  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x30,0x40,0x00,0x00,0x00,0x00,0x00,0x00, // ..................................................................##.....#......................................................
-  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3C,0x20,0x00,0x00,0x00,0x00,0x00,0x00, // ..................................................................####....#.....................................................
-  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0x20,0x00,0x00,0x00,0x00,0x00,0x00, // ................................................................########..#.....................................................
-  0x00,0x00,0x00,0x00,0x00,0x01,0xF8,0x00,0x87,0xF8,0x00,0x00,0x00,0x00,0x00,0x00, // ...............................................######...........#....########...................................................
-  0x00,0x00,0x00,0x00,0x00,0x03,0x0C,0x00,0x83,0xE0,0x00,0x00,0x00,0x00,0x00,0x00, // ..............................................##....##..........#.....#####.....................................................
-  0x00,0x00,0x00,0x00,0x00,0x06,0x0C,0x00,0x81,0xC0,0x00,0x00,0x00,0x00,0x00,0x00, // .............................................##.....##..........#......###......................................................
-  0x00,0x00,0x00,0x00,0x00,0x0C,0x06,0x00,0x80,0xE3,0x00,0x00,0x00,0x00,0x00,0x00, // ............................................##.......##.........#.......###...##................................................
-  0x00,0x00,0x00,0x00,0x00,0x18,0x06,0x00,0x80,0x6F,0x80,0x00,0x00,0x00,0x00,0x00, // ...........................................##........##.........#........##.#####...............................................
-  0x00,0x00,0x00,0x00,0x1C,0x38,0x02,0x00,0x80,0x3C,0xC0,0x00,0x00,0x00,0x00,0x00, // ...................................###....###.........#.........#.........####..##..............................................
-  0x00,0x00,0x00,0x00,0x1F,0x30,0x03,0x00,0xC0,0x3C,0x60,0x00,0x00,0x00,0x00,0x00, // ...................................#####..##..........##........##........####...##.............................................
-  0x00,0x00,0x00,0x00,0x77,0xB0,0x02,0xFF,0x60,0x3C,0x30,0x00,0x00,0x00,0x00,0x00, // .................................###.####.##..........#.########.##.......####....##............................................
-  0x00,0x00,0x00,0x00,0xE0,0xF8,0x06,0xFF,0xB0,0x3C,0x18,0x00,0x00,0x00,0x00,0x00, // ................................###.....#####........##.#########.##......####.....##...........................................
-  0x00,0x00,0x00,0x00,0xC0,0xD8,0x0D,0x81,0x98,0x1C,0x08,0x00,0x00,0x00,0x00,0x00, // ................................##......##.##.......##.##......##..##......###......#...........................................
-  0x00,0x00,0x00,0x03,0x80,0xD8,0x09,0x80,0xDC,0xFC,0x08,0x00,0x00,0x00,0x00,0x00, // ..............................###.......##.##.......#..##.......##.###..######......#...........................................
-  0x00,0x00,0x00,0x02,0x00,0xD8,0x1B,0x00,0x6F,0xE4,0x0C,0x00,0x00,0x00,0x00,0x00, // ..............................#.........##.##......##.##.........##.#######..#......##..........................................
-  0x00,0x00,0x00,0x02,0x00,0xDF,0xFB,0x00,0x37,0x06,0x0C,0x00,0x00,0x00,0x00,0x00, // ..............................#.........##.##########.##..........##.###.....##.....##..........................................
-  0x00,0x00,0x00,0x06,0x00,0xE7,0xF6,0x00,0x18,0x03,0x04,0x00,0x00,0x00,0x00,0x00, // .............................##.........###..#######.##............##.........##.....#..........................................
-  0x00,0x00,0x00,0x06,0x00,0xE0,0x0E,0x00,0x18,0x0F,0x04,0x00,0x00,0x00,0x00,0x00, // .............................##.........###.........###............##.......####.....#..........................................
-  0x00,0x00,0x00,0x06,0x00,0xC0,0x2E,0x00,0x1B,0xFF,0xC6,0x00,0x00,0x00,0x00,0x00, // .............................##.........##........#.###............##.############...##.........................................
-  0x3F,0xFC,0x1F,0xF6,0x7D,0x81,0xE6,0x00,0x1B,0xC7,0xC6,0x00,0x00,0x00,0x00,0x00, // ..############.....#########.##..#####.##......####..##............##.####...#####...##.........................................
-  0x7F,0xFE,0x3F,0xFF,0x1F,0x8F,0xC3,0xFF,0xFF,0xFF,0xFC,0x1F,0xFF,0x38,0x03,0xC0, // .##############...##############...######...######....################################.....#############..###.........####......
-  0xFF,0xFF,0xFF,0xFF,0x8F,0x1F,0xC7,0xFF,0xFF,0xFF,0xF8,0xFF,0xFF,0x3C,0x03,0xE0, // #################################...####...#######...################################...################..####........#####.....
-  0x10,0x0F,0xF0,0x0F,0x8F,0xFF,0x83,0xFF,0xF7,0xFF,0xF8,0xFF,0xFC,0x3C,0x03,0xE0, // ...#........########........#####...#############.....##############.################...##############....####........#####.....
-  0x00,0x0F,0xF0,0x07,0xFF,0xFF,0x01,0x9E,0x27,0xFC,0xC2,0xF8,0x00,0x3E,0x03,0xE0, // ............########.........###################.......##..####...#..#########..##....#.#####.............#####.......#####.....
-  0x0F,0xFF,0xF0,0x03,0xDF,0xFE,0x01,0xCE,0x6C,0xFC,0x47,0xF8,0x00,0x3F,0xFF,0xE0, // ....################..........####.############........###..###..##.##..######...#...########.............#################.....
-  0x1F,0xFF,0xF0,0x03,0xC3,0xFC,0x00,0xFF,0xCC,0xFF,0xFF,0xF0,0x00,0x3F,0xFF,0xE0, // ...#################..........####....########..........##########..##..####################..............#################.....
-  0x1F,0xFF,0xF0,0x03,0xC3,0xFC,0x00,0x0E,0x1C,0xFF,0xF9,0xE0,0x00,0x3F,0xFF,0xE0, // ...#################..........####....########..............###....###..#############..####...............#################.....
-  0x00,0x0F,0xF0,0x0F,0xC7,0xFC,0x00,0x0E,0x1C,0xFF,0xF1,0xE0,0x00,0x3F,0xFF,0xE0, // ............########........######...#########..............###....###..############...####...............#################.....
-  0x00,0x0F,0xF8,0x0F,0x87,0xFE,0x00,0x0E,0x0C,0xF8,0xF0,0xF0,0x00,0x3C,0x03,0xE0, // ............#########.......#####....##########.............###.....##..#####...####....####..............####........#####.....
-  0x7F,0xFF,0xFF,0xFF,0xBF,0x8F,0x00,0x3F,0xE6,0xF8,0xE0,0xFC,0x00,0x3C,0x03,0xE0, // .################################.#######...####..........#########..##.#####...###.....######............####........#####.....
-  0x7F,0xFF,0xFF,0xFF,0xFF,0x07,0xC0,0xFF,0xE7,0xFF,0xFC,0xFF,0xFF,0x3C,0x03,0xE0, // .#######################################.....#####......###########..#################..################..####........#####.....
-  0xFF,0xFF,0xFF,0xFF,0xFE,0x03,0xE0,0x8E,0x33,0xFF,0xFC,0x1F,0xFF,0x3C,0x03,0xE0, // #######################################.......#####.....#...###...##..################.....#############..####........#####.....
-  0x7F,0xFC,0x3F,0xF0,0x3C,0x01,0xF1,0x9E,0x31,0xFF,0xF9,0x0F,0xFE,0x3C,0x03,0xC0, // .#############....##########......####.........#####...##..####...##...##############..#....###########...####........####......
-  0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x00,0x19,0xFF,0xC1,0x00,0x00,0x00,0x00,0x00, // ......................................................##...........##..###########.....#........................................
-  0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x00,0x0C,0xE0,0xC1,0x00,0x00,0x00,0x00,0x00, // ......................................................##............##..###.....##.....#........................................
-  0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x00,0x0C,0x00,0x42,0x00,0x00,0x00,0x00,0x00, // .....................................................##.............##...........#....#.........................................
-  0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x00,0x06,0x01,0x62,0x00,0x00,0x00,0x00,0x00, // .....................................................##..............##........#.##...#.........................................
-  0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x00,0x06,0x3F,0x62,0x00,0x00,0x00,0x00,0x00, // ....................................................##...............##...######.##...#.........................................
-  0x00,0x00,0x00,0x00,0x00,0x38,0x0E,0x00,0x0D,0xFD,0xEE,0x00,0x00,0x00,0x00,0x00, // ..........................................###.......###.............##.#######.####.###.........................................
-  0x00,0x00,0x00,0x00,0x00,0x7F,0xE6,0x00,0x19,0x81,0xFC,0x00,0x00,0x00,0x00,0x00, // .........................................##########..##............##..##......#######..........................................
-  0x00,0x00,0x00,0x00,0x00,0xEF,0xF7,0x00,0x1B,0x01,0xF0,0x00,0x00,0x00,0x00,0x00, // ........................................###.########.###...........##.##.......#####............................................
-  0x00,0x00,0x00,0x00,0x00,0xC0,0x33,0x00,0x33,0x01,0xC8,0x00,0x00,0x00,0x00,0x00, // ........................................##........##..##..........##..##.......###..#...........................................
-  0x00,0x00,0x00,0x00,0x00,0x80,0x1B,0x00,0x36,0x01,0x98,0x00,0x00,0x00,0x00,0x00, // ........................................#..........##.##..........##.##........##..##...........................................
-  0x00,0x00,0x00,0x00,0x01,0x80,0x0D,0xFF,0xEC,0x01,0xF0,0x00,0x00,0x00,0x00,0x00, // .......................................##...........##.############.##.........#####............................................
-  0x00,0x00,0x00,0x00,0x01,0x00,0x0E,0xFF,0xD8,0x01,0xE0,0x00,0x00,0x00,0x00,0x00, // .......................................#............###.##########.##..........####.............................................
-  0x00,0x00,0x00,0x01,0xF1,0x80,0x06,0x60,0x38,0x07,0xA0,0x00,0x00,0x00,0x00,0x00, // ...............................#####...##............##..##.......###........####.#.............................................
-  0x00,0x00,0x00,0x01,0xFD,0x80,0x03,0x00,0x18,0x05,0x40,0x00,0x00,0x00,0x00,0x00, // ...............................#######.##.............##...........##........#.#.#..............................................
-  0x00,0x00,0x00,0x01,0x8F,0xC0,0x06,0xFF,0xDC,0x0A,0x80,0x00,0x00,0x00,0x00,0x00, // ...............................##...######...........##.##########.###......#.#.#...............................................
-  0x00,0x00,0x00,0x00,0x81,0xE0,0x0C,0xFF,0xCC,0x1F,0x00,0x00,0x00,0x00,0x00,0x00, // ................................#......####.........##..##########..##.....#####................................................
-  0x00,0x00,0x00,0x00,0x81,0xF0,0x0D,0x80,0x6C,0xFE,0x00,0x00,0x00,0x00,0x00,0x00, // ................................#......#####........##.##........##.##..#######.................................................
-  0x00,0x00,0x00,0x00,0x40,0xFE,0x1B,0x00,0x67,0x8C,0x00,0x00,0x00,0x00,0x00,0x00, // .................................#......#######....##.##.........##..####...##..................................................
-  0x00,0x00,0x00,0x00,0x20,0x7F,0xF6,0x00,0x20,0x18,0x00,0x00,0x00,0x00,0x00,0x00, // ..................................#......###########.##...........#........##...................................................
-  0x00,0x00,0x00,0x00,0x10,0x30,0x6E,0x00,0x3F,0xF0,0x00,0x00,0x00,0x00,0x00,0x00, // ...................................#......##.....##.###...........##########....................................................
-  0x00,0x00,0x00,0x00,0x04,0x30,0x0E,0x00,0xFF,0xA0,0x00,0x00,0x00,0x00,0x00,0x00, // .....................................#....##........###.........#########.#.....................................................
-  0x00,0x00,0x00,0x00,0x03,0x30,0x06,0x00,0xE1,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // ......................................##..##.........##.........###....#........................................................
-  0x00,0x00,0x00,0x00,0x01,0xF0,0x03,0x03,0xE2,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // .......................................#####..........##......#####...#.........................................................
-  0x00,0x00,0x00,0x00,0x00,0x00,0x01,0xFF,0x88,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // .......................................................##########...#...........................................................
-  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x30,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // ..............................................................#...##............................................................
-  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00  // .............................................................###................................................................
-};
@@ -1,72 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * Custom Status Screen bitmap
- *
- * Place this file in the root with your configuration files
- * and enable CUSTOM_STATUS_SCREEN_IMAGE in Configuration.h.
- *
- * Use the Marlin Bitmap Converter to make your own:
- * http://marlinfw.org/tools/u8glib/converter.html
- */
-
-//
-// Status Screen Logo bitmap
-//
-#define STATUS_LOGO_Y            1
-#define STATUS_LOGO_WIDTH       32
-
-const unsigned char status_logo_bmp[] PROGMEM = {
-  0x00,0x00,0x00,0x00, // ................................
-  0x00,0x00,0x00,0x00, // ................................
-  0x00,0x00,0x00,0x00, // ................................
-  0x00,0x00,0x10,0x00, // ...................#............
-  0x00,0x00,0x06,0x00, // .....................##.........
-  0x00,0x00,0x00,0x00, // ................................
-  0x01,0x00,0x00,0x00, // .......#........................
-  0x08,0x00,0x01,0x00, // ....#..................#........
-  0x01,0x00,0x41,0x00, // .......#.........#.....#........
-  0x01,0x00,0x02,0x00, // .......#..............#.........
-  0x00,0xE0,0x00,0x00, // ........###.....................
-  0x80,0x08,0x10,0x80, // #...........#......#....#.......
-  0x04,0x00,0x00,0x40, // .....#...................#......
-  0x08,0x00,0x08,0x00, // ....#...............#...........
-  0x10,0x04,0x00,0x00, // ...#.........#..................
-  0x00,0x00,0x00,0x30, // ..........................##....
-  0x00,0x00,0x00,0x20, // ..........................#.....
-  0x00,0x01,0xE8,0x20, // ...............####.#.....#.....
-  0x00,0x00,0x00,0x60, // .........................##.....
-  0x00,0x00,0x02,0x00, // ......................#.........
-  0x00,0x08,0x00,0x00, // ............#...................
-  0x00,0x00,0x01,0x20, // .......................#..#.....
-  0x02,0xE8,0x10,0x60, // ......#.###.#......#.....##.....
-  0x00,0x00,0x00,0x40, // .........................#......
-  0x00,0x03,0xC0,0x60, // ..............####.......##.....
-  0x64,0x00,0x10,0x00, // .##..#.............#............
-  0x04,0x03,0xC0,0x00, // .....#........####..............
-  0x02,0x00,0x20,0x00, // ......#...........#.............
-  0x00,0x28,0x00,0x00, // ..........#.#...................
-  0x00,0x08,0x20,0x00, // ............#.....#.............
-  0x00,0x00,0x40,0x00, // .................#..............
-  0x00,0x00,0x00,0x00  // ................................
-};
@@ -24,13 +24,6 @@
 #include "../../inc/MarlinConfig.h"
 #include "HAL.h"

-#ifdef USBCON
-  DefaultSerial1 MSerial0(false, Serial);
-  #ifdef BLUETOOTH
-    BTSerial btSerial(false, bluetoothSerial);
-  #endif
-#endif
-
 // ------------------------
 // Public Variables
 // ------------------------
@@ -82,26 +82,18 @@ typedef int8_t pin_t;

 // Serial ports
 #ifdef USBCON
-  #include "../../core/serial_hook.h"
-  typedef ForwardSerial1Class< decltype(Serial) > DefaultSerial1;
-  extern DefaultSerial1 MSerial0;
-  #ifdef BLUETOOTH
-    typedef ForwardSerial1Class< decltype(bluetoothSerial) > BTSerial;
-    extern BTSerial btSerial;
-  #endif
-
-  #define MYSERIAL1 TERN(BLUETOOTH, btSerial, MSerial0)
+  #define MYSERIAL0 TERN(BLUETOOTH, bluetoothSerial, Serial)
 #else
  #if !WITHIN(SERIAL_PORT, -1, 3)
    #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 -1 to 3. Please update your configuration."
    #endif
-    #define MYSERIAL2 customizedSerial2
+    #define MYSERIAL1 customizedSerial2
  #endif
 #endif

@@ -454,7 +454,7 @@ void MarlinSerial<Cfg>::flush() {
 }

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

    _written = true;
@@ -480,7 +480,7 @@ size_t 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 1;
+      return;
    }

    const uint8_t i = (tx_buffer.head + 1) & (Cfg::TX_SIZE - 1);
@@ -510,7 +510,6 @@ size_t 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>
@@ -557,6 +556,161 @@ void MarlinSerial<Cfg>::flushTX() {
  }
 }

+/**
+ * Imports from print.h
+ */
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::print(char c, int base) {
+  print((long)c, base);
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::print(unsigned char b, int base) {
+  print((unsigned long)b, base);
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::print(int n, int base) {
+  print((long)n, base);
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::print(unsigned int n, int base) {
+  print((unsigned long)n, base);
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::print(long n, int base) {
+  if (base == 0) write(n);
+  else if (base == 10) {
+    if (n < 0) { print('-'); n = -n; }
+    printNumber(n, 10);
+  }
+  else
+    printNumber(n, base);
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::print(unsigned long n, int base) {
+  if (base == 0) write(n);
+  else printNumber(n, base);
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::print(double n, int digits) {
+  printFloat(n, digits);
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println() {
+  print('\r');
+  print('\n');
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(const String& s) {
+  print(s);
+  println();
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(const char c[]) {
+  print(c);
+  println();
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(char c, int base) {
+  print(c, base);
+  println();
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(unsigned char b, int base) {
+  print(b, base);
+  println();
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(int n, int base) {
+  print(n, base);
+  println();
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(unsigned int n, int base) {
+  print(n, base);
+  println();
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(long n, int base) {
+  print(n, base);
+  println();
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(unsigned long n, int base) {
+  print(n, base);
+  println();
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(double n, int digits) {
+  print(n, digits);
+  println();
+}
+
+// Private Methods
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::printNumber(unsigned long n, uint8_t base) {
+  if (n) {
+    unsigned char buf[8 * sizeof(long)]; // Enough space for base 2
+    int8_t i = 0;
+    while (n) {
+      buf[i++] = n % base;
+      n /= base;
+    }
+    while (i--)
+      print((char)(buf[i] + (buf[i] < 10 ? '0' : 'A' - 10)));
+  }
+  else
+    print('0');
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::printFloat(double number, uint8_t digits) {
+  // Handle negative numbers
+  if (number < 0.0) {
+    print('-');
+    number = -number;
+  }
+
+  // Round correctly so that print(1.999, 2) prints as "2.00"
+  double rounding = 0.5;
+  LOOP_L_N(i, digits) rounding *= 0.1;
+  number += rounding;
+
+  // Extract the integer part of the number and print it
+  unsigned long int_part = (unsigned long)number;
+  double remainder = number - (double)int_part;
+  print(int_part);
+
+  // Print the decimal point, but only if there are digits beyond
+  if (digits) {
+    print('.');
+    // Extract digits from the remainder one at a time
+    while (digits--) {
+      remainder *= 10.0;
+      int toPrint = int(remainder);
+      print(toPrint);
+      remainder -= toPrint;
+    }
+  }
+}
+
 // Hookup ISR handlers
 ISR(SERIAL_REGNAME(USART, SERIAL_PORT, _RX_vect)) {
  MarlinSerial<MarlinSerialCfg<SERIAL_PORT>>::store_rxd_char();
@@ -566,9 +720,11 @@ 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
-template class MarlinSerial< MarlinSerialCfg<SERIAL_PORT> >;
-MSerialT customizedSerial1(MSerialT::HasEmergencyParser);
+// Preinstantiate
+template class MarlinSerial<MarlinSerialCfg<SERIAL_PORT>>;
+
+// Instantiate
+MarlinSerial<MarlinSerialCfg<SERIAL_PORT>> customizedSerial1;

 #ifdef SERIAL_PORT_2

@@ -581,8 +737,12 @@ MSerialT customizedSerial1(MSerialT::HasEmergencyParser);
    MarlinSerial<MarlinSerialCfg<SERIAL_PORT_2>>::_tx_udr_empty_irq();
  }

-  template class MarlinSerial< MarlinSerialCfg<SERIAL_PORT_2> >;
-  MSerialT2 customizedSerial2(MSerialT2::HasEmergencyParser);
+  // Preinstantiate
+  template class MarlinSerial<MarlinSerialCfg<SERIAL_PORT_2>>;
+
+  // Instantiate
+  MarlinSerial<MarlinSerialCfg<SERIAL_PORT_2>> customizedSerial2;
+
 #endif

 #ifdef MMU2_SERIAL_PORT
@@ -595,8 +755,12 @@ MSerialT customizedSerial1(MSerialT::HasEmergencyParser);
    MarlinSerial<MMU2SerialCfg<MMU2_SERIAL_PORT>>::_tx_udr_empty_irq();
  }

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

 #ifdef LCD_SERIAL_PORT
@@ -609,8 +773,11 @@ MSerialT customizedSerial1(MSerialT::HasEmergencyParser);
    MarlinSerial<LCDSerialCfg<LCD_SERIAL_PORT>>::_tx_udr_empty_irq();
  }

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

  #if HAS_DGUS_LCD
    template<typename Cfg>
@@ -629,7 +796,7 @@ MSerialT customizedSerial1(MSerialT::HasEmergencyParser);

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

 #endif // __AVR__
@@ -34,7 +34,6 @@
 #include <WString.h>

 #include "../../inc/MarlinConfigPre.h"
-#include "../../core/serial_hook.h"

 #ifndef SERIAL_PORT
  #define SERIAL_PORT 0
@@ -136,6 +135,10 @@
    UART_DECL(3);
  #endif

+  #define DEC 10
+  #define HEX 16
+  #define OCT 8
+  #define BIN 2
  #define BYTE 0

  // Templated type selector
@@ -199,30 +202,60 @@
    static FORCE_INLINE void atomic_set_rx_tail(ring_buffer_pos_t value);
    static FORCE_INLINE ring_buffer_pos_t atomic_read_rx_tail();

-  public:
+    public:
+
    FORCE_INLINE static void store_rxd_char();
    FORCE_INLINE static void _tx_udr_empty_irq();

-  public:
-    static void begin(const long);
-    static void end();
-    static int peek();
-    static int read();
-    static void flush();
-    static ring_buffer_pos_t available();
-    static size_t write(const uint8_t c);
-    static void flushTX();
-    #if HAS_DGUS_LCD
-      static ring_buffer_pos_t get_tx_buffer_free();
-    #endif
+    public:
+      MarlinSerial() {};
+      static void begin(const long);
+      static void end();
+      static int peek();
+      static int read();
+      static void flush();
+      static ring_buffer_pos_t available();
+      static void write(const uint8_t c);
+      static void flushTX();
+      #if HAS_DGUS_LCD
+        static ring_buffer_pos_t get_tx_buffer_free();
+      #endif

-    enum { HasEmergencyParser = Cfg::EMERGENCYPARSER };
-    static inline bool emergency_parser_enabled() { return Cfg::EMERGENCYPARSER; }
+      static inline bool emergency_parser_enabled() { return Cfg::EMERGENCYPARSER; }

-    FORCE_INLINE static uint8_t dropped() { return Cfg::DROPPED_RX ? rx_dropped_bytes : 0; }
-    FORCE_INLINE static uint8_t buffer_overruns() { return Cfg::RX_OVERRUNS ? rx_buffer_overruns : 0; }
-    FORCE_INLINE static uint8_t framing_errors() { return Cfg::RX_FRAMING_ERRORS ? rx_framing_errors : 0; }
-    FORCE_INLINE static ring_buffer_pos_t rxMaxEnqueued() { return Cfg::MAX_RX_QUEUED ? rx_max_enqueued : 0; }
+      FORCE_INLINE static uint8_t dropped() { return Cfg::DROPPED_RX ? rx_dropped_bytes : 0; }
+      FORCE_INLINE static uint8_t buffer_overruns() { return Cfg::RX_OVERRUNS ? rx_buffer_overruns : 0; }
+      FORCE_INLINE static uint8_t framing_errors() { return Cfg::RX_FRAMING_ERRORS ? rx_framing_errors : 0; }
+      FORCE_INLINE static ring_buffer_pos_t rxMaxEnqueued() { return Cfg::MAX_RX_QUEUED ? rx_max_enqueued : 0; }
+
+      FORCE_INLINE static void write(const char* str) { while (*str) write(*str++); }
+      FORCE_INLINE static void write(const uint8_t* buffer, size_t size) { while (size--) write(*buffer++); }
+      FORCE_INLINE static void print(const String& s) { for (int i = 0; i < (int)s.length(); i++) write(s[i]); }
+      FORCE_INLINE static void print(const char* str) { write(str); }
+
+      static void print(char, int = BYTE);
+      static void print(unsigned char, int = BYTE);
+      static void print(int, int = DEC);
+      static void print(unsigned int, int = DEC);
+      static void print(long, int = DEC);
+      static void print(unsigned long, int = DEC);
+      static void print(double, int = 2);
+
+      static void println(const String& s);
+      static void println(const char[]);
+      static void println(char, int = BYTE);
+      static void println(unsigned char, int = BYTE);
+      static void println(int, int = DEC);
+      static void println(unsigned int, int = DEC);
+      static void println(long, int = DEC);
+      static void println(unsigned long, int = DEC);
+      static void println(double, int = 2);
+      static void println();
+      operator bool() { return true; }
+
+    private:
+      static void printNumber(unsigned long, const uint8_t);
+      static void printFloat(double, uint8_t);
  };

  template <uint8_t serial>
@@ -237,13 +270,12 @@
    static constexpr bool RX_FRAMING_ERRORS = ENABLED(SERIAL_STATS_RX_FRAMING_ERRORS);
    static constexpr bool MAX_RX_QUEUED     = ENABLED(SERIAL_STATS_MAX_RX_QUEUED);
  };
-
-  typedef Serial1Class< MarlinSerial< MarlinSerialCfg<SERIAL_PORT> > > MSerialT;
-  extern MSerialT customizedSerial1;
+  extern MarlinSerial<MarlinSerialCfg<SERIAL_PORT>> customizedSerial1;

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

 #endif // !USBCON
@@ -252,41 +284,49 @@
  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> > > MSerialT3;
-  extern MSerialT3 mmuSerial;
+  extern MarlinSerial<MMU2SerialCfg<MMU2_SERIAL_PORT>> 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
+      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> > > MSerialT4;
-  extern MSerialT4 lcdSerial;
+  extern MarlinSerial<LCDSerialCfg<LCD_SERIAL_PORT>> lcdSerial;
+
 #endif

 // Use the UART for Bluetooth in AT90USB configurations
 #if defined(USBCON) && ENABLED(BLUETOOTH)
-  typedef Serial1Class<HardwareSerial> MSerialT5;
-  extern MSerialT5 bluetoothSerial;
+  extern HardwareSerial bluetoothSerial;
 #endif
@@ -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
@@ -235,8 +235,8 @@ static void print_is_also_tied() { SERIAL_ECHOPGM(" is also tied to this pin");

 inline void com_print(const uint8_t N, const uint8_t Z) {
  const uint8_t *TCCRA = (uint8_t*)TCCR_A(N);
-  SERIAL_ECHOPAIR("    COM", AS_CHAR('0' + N));
-  SERIAL_CHAR(Z);
+  SERIAL_ECHOPGM("    COM");
+  SERIAL_CHAR('0' + N, Z);
  SERIAL_ECHOPAIR(": ", int((*TCCRA >> (6 - Z * 2)) & 0x03));
 }

@@ -247,8 +247,8 @@ void timer_prefix(uint8_t T, char L, uint8_t N) {  // T - timer    L - pwm  N -
  uint8_t WGM = (((*TCCRB & _BV(WGM_2)) >> 1) | (*TCCRA & (_BV(WGM_0) | _BV(WGM_1))));
  if (N == 4) WGM |= ((*TCCRB & _BV(WGM_3)) >> 1);

-  SERIAL_ECHOPAIR("    TIMER", AS_CHAR(T + '0'));
-  SERIAL_CHAR(L);
+  SERIAL_ECHOPGM("    TIMER");
+  SERIAL_CHAR(T + '0', L);
  SERIAL_ECHO_SP(3);

  if (N == 3) {
@@ -262,11 +262,19 @@ void timer_prefix(uint8_t T, char L, uint8_t N) {  // T - timer    L - pwm  N -
  SERIAL_ECHOPAIR("    WGM: ", WGM);
  com_print(T,L);
  SERIAL_ECHOPAIR("    CS: ", (*TCCRB & (_BV(CS_0) | _BV(CS_1) | _BV(CS_2)) ));
-  SERIAL_ECHOPAIR("    TCCR", AS_CHAR(T + '0'), "A: ", *TCCRA);
-  SERIAL_ECHOPAIR("    TCCR", AS_CHAR(T + '0'), "B: ", *TCCRB);
+
+  SERIAL_ECHOPGM("    TCCR");
+  SERIAL_CHAR(T + '0');
+  SERIAL_ECHOPAIR("A: ", *TCCRA);
+
+  SERIAL_ECHOPGM("    TCCR");
+  SERIAL_CHAR(T + '0');
+  SERIAL_ECHOPAIR("B: ", *TCCRB);

  const uint8_t *TMSK = (uint8_t*)TIMSK(T);
-  SERIAL_ECHOPAIR("    TIMSK", AS_CHAR(T + '0'), ": ", *TMSK);
+  SERIAL_ECHOPGM("    TIMSK");
+  SERIAL_CHAR(T + '0');
+  SERIAL_ECHOPAIR(": ", *TMSK);

  const uint8_t OCIE = L - 'A' + 1;
  if (N == 3) { if (WGM == 0 || WGM == 2 || WGM ==  4 || WGM ==  6) err_is_counter(); }
@@ -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
@@ -105,18 +102,4 @@ uint16_t HAL_adc_get_result() {
  return HAL_adc_result;
 }

-// Forward the default serial ports
-#if ANY_SERIAL_IS(0)
-  DefaultSerial1 MSerial0(false, Serial);
-#endif
-#if ANY_SERIAL_IS(1)
-  DefaultSerial2 MSerial1(false, Serial1);
-#endif
-#if ANY_SERIAL_IS(2)
-  DefaultSerial3 MSerial2(false, Serial2);
-#endif
-#if ANY_SERIAL_IS(3)
-  DefaultSerial4 MSerial3(false, Serial3);
-#endif
-
 #endif // ARDUINO_ARCH_SAM
@@ -36,34 +36,24 @@

 #include <stdint.h>

-#include "../../core/serial_hook.h"
-
-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;
-
-#define _MSERIAL(X) MSerial##X
+#define _MSERIAL(X) Serial##X
 #define MSERIAL(X) _MSERIAL(X)
+#define Serial0 Serial

-// Define MYSERIAL1/2 before MarlinSerial includes!
+// 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 -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 -1 to 3. Please update your configuration."
  #endif
@@ -71,7 +61,7 @@ extern DefaultSerial4 MSerial3;

 #ifdef MMU2_SERIAL_PORT
  #if WITHIN(MMU2_SERIAL_PORT, 0, 3)
-    #define MMU2_SERIAL MSERIAL(MMU2_SERIAL_PORT)
+    #define MMU2_SERIAL MSERIAL(SERIAL_PORT)
  #else
    #error "MMU2_SERIAL_PORT must be from 0 to 3. Please update your configuration."
  #endif
@@ -93,6 +83,16 @@ extern DefaultSerial4 MSerial3;
 // On AVR this is in math.h?
 #define square(x) ((x)*(x))

+#ifndef strncpy_P
+  #define strncpy_P(dest, src, num) strncpy((dest), (src), (num))
+#endif
+
+// Fix bug in pgm_read_ptr
+#undef pgm_read_ptr
+#define pgm_read_ptr(addr) (*((void**)(addr)))
+#undef pgm_read_word
+#define pgm_read_word(addr) (*((uint16_t*)(addr)))
+
 typedef int8_t pin_t;

 #define SHARED_SERVOS HAS_SERVOS
@@ -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
@@ -240,7 +240,7 @@
  }

  // all the others
-  static uint32_t spiDelayCyclesX4 = 4 * (F_CPU) / 1000000; // 4µs => 125khz
+  static uint32_t spiDelayCyclesX4 = (F_CPU) / 1000000; // 4µs => 125khz

  static uint8_t spiTransferX(uint8_t b) { // using Mode 0
    int bits = 8;
@@ -249,12 +249,12 @@
      b <<= 1; // little setup time

      WRITE(SD_SCK_PIN, HIGH);
-      DELAY_CYCLES(spiDelayCyclesX4);
+      __delay_4cycles(spiDelayCyclesX4);

      b |= (READ(SD_MISO_PIN) != 0);

      WRITE(SD_SCK_PIN, LOW);
-      DELAY_CYCLES(spiDelayCyclesX4);
+      __delay_4cycles(spiDelayCyclesX4);
    } while (--bits);
    return b;
  }
@@ -510,7 +510,7 @@
        spiRxBlock = (pfnSpiRxBlock)spiRxBlockX;
        break;
      default:
-        spiDelayCyclesX4 = ((F_CPU) / 1000000) >> (6 - spiRate) << 2; // spiRate of 2 gives the maximum error with current CPU
+        spiDelayCyclesX4 = ((F_CPU) / 1000000) >> (6 - spiRate);
        spiTransferTx = (pfnSpiTransfer)spiTransferX;
        spiTransferRx = (pfnSpiTransfer)spiTransferX;
        spiTxBlock = (pfnSpiTxBlock)spiTxBlockX;
@@ -382,7 +382,7 @@ void MarlinSerial<Cfg>::flush() {
 }

 template<typename Cfg>
-size_t MarlinSerial<Cfg>::write(const uint8_t c) {
+void MarlinSerial<Cfg>::write(const uint8_t c) {
  _written = true;

  if (Cfg::TX_SIZE == 0) {
@@ -400,7 +400,7 @@ size_t MarlinSerial<Cfg>::write(const uint8_t c) {
    // XOFF char at the RX isr, but it is properly handled there
    if (!(HWUART->UART_IMR & UART_IMR_TXRDY) && (HWUART->UART_SR & UART_SR_TXRDY)) {
      HWUART->UART_THR = c;
-      return 1;
+      return;
    }

    const uint8_t i = (tx_buffer.head + 1) & (Cfg::TX_SIZE - 1);
@@ -428,7 +428,6 @@ size_t MarlinSerial<Cfg>::write(const uint8_t c) {
    // Enable TX isr - Non atomic, but it will eventually enable TX isr
    HWUART->UART_IER = UART_IER_TXRDY;
  }
-  return 1;
 }

 template<typename Cfg>
@@ -474,16 +473,169 @@ void MarlinSerial<Cfg>::flushTX() {
  }
 }

+/**
+ * Imports from print.h
+ */
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::print(char c, int base) {
+  print((long)c, base);
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::print(unsigned char b, int base) {
+  print((unsigned long)b, base);
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::print(int n, int base) {
+  print((long)n, base);
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::print(unsigned int n, int base) {
+  print((unsigned long)n, base);
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::print(long n, int base) {
+  if (base == 0) write(n);
+  else if (base == 10) {
+    if (n < 0) { print('-'); n = -n; }
+    printNumber(n, 10);
+  }
+  else
+    printNumber(n, base);
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::print(unsigned long n, int base) {
+  if (base == 0) write(n);
+  else printNumber(n, base);
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::print(double n, int digits) {
+  printFloat(n, digits);
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println() {
+  print('\r');
+  print('\n');
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(const String& s) {
+  print(s);
+  println();
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(const char c[]) {
+  print(c);
+  println();
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(char c, int base) {
+  print(c, base);
+  println();
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(unsigned char b, int base) {
+  print(b, base);
+  println();
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(int n, int base) {
+  print(n, base);
+  println();
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(unsigned int n, int base) {
+  print(n, base);
+  println();
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(long n, int base) {
+  print(n, base);
+  println();
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(unsigned long n, int base) {
+  print(n, base);
+  println();
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(double n, int digits) {
+  print(n, digits);
+  println();
+}
+
+// Private Methods
+template<typename Cfg>
+void MarlinSerial<Cfg>::printNumber(unsigned long n, uint8_t base) {
+  if (n) {
+    unsigned char buf[8 * sizeof(long)]; // Enough space for base 2
+    int8_t i = 0;
+    while (n) {
+      buf[i++] = n % base;
+      n /= base;
+    }
+    while (i--)
+      print((char)(buf[i] + (buf[i] < 10 ? '0' : 'A' - 10)));
+  }
+  else
+    print('0');
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::printFloat(double number, uint8_t digits) {
+  // Handle negative numbers
+  if (number < 0.0) {
+    print('-');
+    number = -number;
+  }
+
+  // Round correctly so that print(1.999, 2) prints as "2.00"
+  double rounding = 0.5;
+  LOOP_L_N(i, digits) rounding *= 0.1;
+  number += rounding;
+
+  // Extract the integer part of the number and print it
+  unsigned long int_part = (unsigned long)number;
+  double remainder = number - (double)int_part;
+  print(int_part);
+
+  // Print the decimal point, but only if there are digits beyond
+  if (digits) {
+    print('.');
+    // Extract digits from the remainder one at a time
+    while (digits--) {
+      remainder *= 10.0;
+      int toPrint = int(remainder);
+      print(toPrint);
+      remainder -= toPrint;
+    }
+  }
+}

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

 #if defined(SERIAL_PORT_2) && SERIAL_PORT_2 >= 0
-  template class MarlinSerial< MarlinSerialCfg<SERIAL_PORT_2> >;
-  MSerialT2 customizedSerial2(MarlinSerialCfg<SERIAL_PORT_2>::EMERGENCYPARSER);
+  template class MarlinSerial<MarlinSerialCfg<SERIAL_PORT_2>>;    // Define
+  MarlinSerial<MarlinSerialCfg<SERIAL_PORT_2>> customizedSerial2; // Instantiate
 #endif

 #endif // ARDUINO_ARCH_SAM
@@ -30,7 +30,11 @@
 #include <WString.h>

 #include "../../inc/MarlinConfigPre.h"
-#include "../../core/serial_hook.h"
+
+#define DEC 10
+#define HEX 16
+#define OCT 8
+#define BIN 2

 // Define constants and variables for buffering incoming serial data.  We're
 // using a ring buffer (I think), in which rx_buffer_head is the index of the
@@ -115,7 +119,7 @@ public:
  static int read();
  static void flush();
  static ring_buffer_pos_t available();
-  static size_t write(const uint8_t c);
+  static void write(const uint8_t c);
  static void flushTX();

  static inline bool emergency_parser_enabled() { return Cfg::EMERGENCYPARSER; }
@@ -124,6 +128,35 @@ public:
  FORCE_INLINE static uint8_t buffer_overruns() { return Cfg::RX_OVERRUNS ? rx_buffer_overruns : 0; }
  FORCE_INLINE static uint8_t framing_errors() { return Cfg::RX_FRAMING_ERRORS ? rx_framing_errors : 0; }
  FORCE_INLINE static ring_buffer_pos_t rxMaxEnqueued() { return Cfg::MAX_RX_QUEUED ? rx_max_enqueued : 0; }
+
+  FORCE_INLINE static void write(const char* str) { while (*str) write(*str++); }
+  FORCE_INLINE static void write(const uint8_t* buffer, size_t size) { while (size--) write(*buffer++); }
+  FORCE_INLINE static void print(const String& s) { for (int i = 0; i < (int)s.length(); i++) write(s[i]); }
+  FORCE_INLINE static void print(const char* str) { write(str); }
+
+  static void print(char, int = 0);
+  static void print(unsigned char, int = 0);
+  static void print(int, int = DEC);
+  static void print(unsigned int, int = DEC);
+  static void print(long, int = DEC);
+  static void print(unsigned long, int = DEC);
+  static void print(double, int = 2);
+
+  static void println(const String& s);
+  static void println(const char[]);
+  static void println(char, int = 0);
+  static void println(unsigned char, int = 0);
+  static void println(int, int = DEC);
+  static void println(unsigned int, int = DEC);
+  static void println(long, int = DEC);
+  static void println(unsigned long, int = DEC);
+  static void println(double, int = 2);
+  static void println();
+  operator bool() { return true; }
+
+private:
+  static void printNumber(unsigned long, const uint8_t);
+  static void printFloat(double, uint8_t);
 };

 // Serial port configuration
@@ -141,11 +174,9 @@ struct MarlinSerialCfg {
 };

 #if SERIAL_PORT >= 0
-  typedef Serial1Class< MarlinSerial< MarlinSerialCfg<SERIAL_PORT> > > MSerialT;
-  extern MSerialT customizedSerial1;
+  extern MarlinSerial<MarlinSerialCfg<SERIAL_PORT>> customizedSerial1;
 #endif

 #if defined(SERIAL_PORT_2) && SERIAL_PORT_2 >= 0
-  typedef Serial1Class< MarlinSerial< MarlinSerialCfg<SERIAL_PORT_2> > > MSerialT2;
-  extern MSerialT2 customizedSerial2;
+  extern MarlinSerial<MarlinSerialCfg<SERIAL_PORT_2>> customizedSerial2;
 #endif
@@ -33,6 +33,10 @@

 #include "MarlinSerialUSB.h"

+#if ENABLED(EMERGENCY_PARSER)
+  #include "../../feature/e_parser.h"
+#endif
+
 // Imports from Atmel USB Stack/CDC implementation
 extern "C" {
  bool usb_task_cdc_isenabled();
@@ -46,6 +50,10 @@ extern "C" {
 // Pending character
 static int pending_char = -1;

+#if ENABLED(EMERGENCY_PARSER)
+  static EmergencyParser::State emergency_state; // = EP_RESET
+#endif
+
 // Public Methods
 void MarlinSerialUSB::begin(const long) {}

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

  pending_char = udi_cdc_getc();

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

  return pending_char;
 }
@@ -87,27 +95,29 @@ int MarlinSerialUSB::read() {

  int c = udi_cdc_getc();

-  TERN_(EMERGENCY_PARSER, emergency_parser.update(static_cast<MSerialT*>(this)->emergency_state, (char)c));
+  TERN_(EMERGENCY_PARSER, emergency_parser.update(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() { }
+void MarlinSerialUSB::flushTX() { }

-size_t MarlinSerialUSB::write(const uint8_t c) {
+void MarlinSerialUSB::write(const uint8_t c) {

  /* Do not even bother sending anything if USB CDC is not enumerated
     or not configured on the PC side or there is no program on the PC
     listening to our messages */
  if (!usb_task_cdc_isenabled() || !usb_task_cdc_dtr_active())
-    return 0;
+    return;

  /* Wait until the PC has read the pending to be sent data */
  while (usb_task_cdc_isenabled() &&
@@ -119,20 +129,161 @@ size_t MarlinSerialUSB::write(const uint8_t c) {
     or not configured on the PC side or there is no program on the PC
     listening to our messages at this point */
  if (!usb_task_cdc_isenabled() || !usb_task_cdc_dtr_active())
-    return 0;
+    return;

  // Fifo full
  //  udi_cdc_signal_overrun();
  udi_cdc_putc(c);
-  return 1;
+}
+
+/**
+ * Imports from print.h
+ */
+
+void MarlinSerialUSB::print(char c, int base) {
+  print((long)c, base);
+}
+
+void MarlinSerialUSB::print(unsigned char b, int base) {
+  print((unsigned long)b, base);
+}
+
+void MarlinSerialUSB::print(int n, int base) {
+  print((long)n, base);
+}
+
+void MarlinSerialUSB::print(unsigned int n, int base) {
+  print((unsigned long)n, base);
+}
+
+void MarlinSerialUSB::print(long n, int base) {
+  if (base == 0)
+    write(n);
+  else if (base == 10) {
+    if (n < 0) {
+      print('-');
+      n = -n;
+    }
+    printNumber(n, 10);
+  }
+  else
+    printNumber(n, base);
+}
+
+void MarlinSerialUSB::print(unsigned long n, int base) {
+  if (base == 0) write(n);
+  else printNumber(n, base);
+}
+
+void MarlinSerialUSB::print(double n, int digits) {
+  printFloat(n, digits);
+}
+
+void MarlinSerialUSB::println() {
+  print('\r');
+  print('\n');
+}
+
+void MarlinSerialUSB::println(const String& s) {
+  print(s);
+  println();
+}
+
+void MarlinSerialUSB::println(const char c[]) {
+  print(c);
+  println();
+}
+
+void MarlinSerialUSB::println(char c, int base) {
+  print(c, base);
+  println();
+}
+
+void MarlinSerialUSB::println(unsigned char b, int base) {
+  print(b, base);
+  println();
+}
+
+void MarlinSerialUSB::println(int n, int base) {
+  print(n, base);
+  println();
+}
+
+void MarlinSerialUSB::println(unsigned int n, int base) {
+  print(n, base);
+  println();
+}
+
+void MarlinSerialUSB::println(long n, int base) {
+  print(n, base);
+  println();
+}
+
+void MarlinSerialUSB::println(unsigned long n, int base) {
+  print(n, base);
+  println();
+}
+
+void MarlinSerialUSB::println(double n, int digits) {
+  print(n, digits);
+  println();
+}
+
+// Private Methods
+
+void MarlinSerialUSB::printNumber(unsigned long n, uint8_t base) {
+  if (n) {
+    unsigned char buf[8 * sizeof(long)]; // Enough space for base 2
+    int8_t i = 0;
+    while (n) {
+      buf[i++] = n % base;
+      n /= base;
+    }
+    while (i--)
+      print((char)(buf[i] + (buf[i] < 10 ? '0' : 'A' - 10)));
+  }
+  else
+    print('0');
+}
+
+void MarlinSerialUSB::printFloat(double number, uint8_t digits) {
+  // Handle negative numbers
+  if (number < 0.0) {
+    print('-');
+    number = -number;
+  }
+
+  // Round correctly so that print(1.999, 2) prints as "2.00"
+  double rounding = 0.5;
+  LOOP_L_N(i, digits)
+    rounding *= 0.1;
+
+  number += rounding;
+
+  // Extract the integer part of the number and print it
+  unsigned long int_part = (unsigned long)number;
+  double remainder = number - (double)int_part;
+  print(int_part);
+
+  // Print the decimal point, but only if there are digits beyond
+  if (digits) {
+    print('.');
+    // Extract digits from the remainder one at a time
+    while (digits--) {
+      remainder *= 10.0;
+      int toPrint = int(remainder);
+      print(toPrint);
+      remainder -= toPrint;
+    }
+  }
 }

 // Preinstantiate
 #if SERIAL_PORT == -1
-  MSerialT customizedSerial1(TERN0(EMERGENCY_PARSER, true));
+  MarlinSerialUSB customizedSerial1;
 #endif
 #if SERIAL_PORT_2 == -1
-  MSerialT customizedSerial2(TERN0(EMERGENCY_PARSER, true));
+  MarlinSerialUSB customizedSerial2;
 #endif

 #endif // HAS_USB_SERIAL
@@ -27,37 +27,73 @@
 */

 #include "../../inc/MarlinConfig.h"
+
 #if HAS_USB_SERIAL

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

+#define DEC 10
+#define HEX 16
+#define OCT 8
+#define BIN 2

-struct MarlinSerialUSB {
-  void begin(const long);
-  void end();
-  int peek();
-  int read();
-  void flush();
-  int available();
-  size_t write(const uint8_t c);
+class MarlinSerialUSB {
+
+public:
+  MarlinSerialUSB() {};
+  static void begin(const long);
+  static void end();
+  static int peek();
+  static int read();
+  static void flush();
+  static void flushTX();
+  static bool available();
+  static void write(const uint8_t c);

  #if ENABLED(SERIAL_STATS_DROPPED_RX)
-    FORCE_INLINE uint32_t dropped() { return 0; }
+    FORCE_INLINE static uint32_t dropped() { return 0; }
  #endif

  #if ENABLED(SERIAL_STATS_MAX_RX_QUEUED)
-    FORCE_INLINE int rxMaxEnqueued() { return 0; }
+    FORCE_INLINE static int rxMaxEnqueued() { return 0; }
  #endif
+
+  FORCE_INLINE static void write(const char* str) { while (*str) write(*str++); }
+  FORCE_INLINE static void write(const uint8_t* buffer, size_t size) { while (size--) write(*buffer++); }
+  FORCE_INLINE static void print(const String& s) { for (int i = 0; i < (int)s.length(); i++) write(s[i]); }
+  FORCE_INLINE static void print(const char* str) { write(str); }
+
+  static void print(char, int = 0);
+  static void print(unsigned char, int = 0);
+  static void print(int, int = DEC);
+  static void print(unsigned int, int = DEC);
+  static void print(long, int = DEC);
+  static void print(unsigned long, int = DEC);
+  static void print(double, int = 2);
+
+  static void println(const String& s);
+  static void println(const char[]);
+  static void println(char, int = 0);
+  static void println(unsigned char, int = 0);
+  static void println(int, int = DEC);
+  static void println(unsigned int, int = DEC);
+  static void println(long, int = DEC);
+  static void println(unsigned long, int = DEC);
+  static void println(double, int = 2);
+  static void println();
+  operator bool() { return true; }
+
+private:
+  static void printNumber(unsigned long, const uint8_t);
+  static void printFloat(double, uint8_t);
 };
-typedef Serial1Class<MarlinSerialUSB> MSerialT;

 #if SERIAL_PORT == -1
-  extern MSerialT customizedSerial1;
+  extern MarlinSerialUSB customizedSerial1;
 #endif

 #if SERIAL_PORT_2 == -1
-  extern MSerialT customizedSerial2;
+  extern MarlinSerialUSB customizedSerial2;
 #endif

 #endif // HAS_USB_SERIAL
@@ -59,7 +59,6 @@

 #if ENABLED(U8GLIB_ST7920)

-#include "../../../inc/MarlinConfig.h"
 #include "../../shared/Delay.h"

 #include <U8glib.h>
@@ -59,7 +59,6 @@

 #if HAS_MARLINUI_U8GLIB

-#include "../../../inc/MarlinConfig.h"
 #include "../../shared/Delay.h"

 #include <U8glib.h>
@@ -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
@@ -68,7 +68,7 @@ Ctrl_status sd_mmc_spi_usb_read_10(uint32_t addr, uint16_t nb_sector) {
  {
    char buffer[80];
    sprintf_P(buffer, PSTR("SDRD: %d @ 0x%08x\n"), nb_sector, addr);
-    PORT_REDIRECT(SERIAL_PORTMASK(0));
+    PORT_REDIRECT(0);
    SERIAL_ECHO(buffer);
  }
  #endif
@@ -108,7 +108,7 @@ Ctrl_status sd_mmc_spi_usb_write_10(uint32_t addr, uint16_t nb_sector) {
  {
    char buffer[80];
    sprintf_P(buffer, PSTR("SDWR: %d @ 0x%08x\n"), nb_sector, addr);
-    PORT_REDIRECT(SERIAL_PORTMASK(0));
+    PORT_REDIRECT(0);
    SERIAL_ECHO(buffer);
  }
  #endif
@@ -20,10 +20,14 @@
 *
 */

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

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

-#endif
+FlushableHardwareSerial::FlushableHardwareSerial(int uart_nr)
+    : HardwareSerial(uart_nr)
+{}
+
+FlushableHardwareSerial flushableSerial(0);
+
+#endif // ARDUINO_ARCH_ESP32
@@ -21,14 +21,17 @@
 */
 #pragma once

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

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

 class FlushableHardwareSerial : public HardwareSerial {
 public:
-  FlushableHardwareSerial(int uart_nr) : HardwareSerial(uart_nr) {}
+  FlushableHardwareSerial(int uart_nr);
+
+  inline void flushTX() { /* No need to flush the hardware serial, but defined here for compatibility. */ }
 };

-extern Serial1Class<FlushableHardwareSerial> flushableSerial;
+extern FlushableHardwareSerial flushableSerial;
+
+#endif // ARDUINO_ARCH_ESP32
@@ -40,10 +40,6 @@
  #endif
 #endif

-#if ENABLED(ESP3D_WIFISUPPORT)
-  DefaultSerial1 MSerial0(false, Serial2Socket);
-#endif
-
 // ------------------------
 // Externs
 // ------------------------
@@ -90,6 +86,8 @@ volatile int numPWMUsed = 0,

 #endif

+void HAL_init() { TERN_(I2S_STEPPER_STREAM, i2s_init()); }
+
 void HAL_init_board() {

  #if ENABLED(ESP3D_WIFISUPPORT)
@@ -124,10 +122,6 @@ void HAL_init_board() {
    #endif
  #endif

-  // Initialize the i2s peripheral only if the I2S stepper stream is enabled.
-  // The following initialization is performed after Serial1 and Serial2 are defined as
-  // their native pins might conflict with the i2s stream even when they are remapped.
-  TERN_(I2S_STEPPER_STREAM, i2s_init());
 }

 void HAL_idletask() {
@@ -185,7 +179,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,13 @@

 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
+    #define MYSERIAL1 Serial2Socket
  #else
-    #define MYSERIAL2 webSocketSerial
+    #define MYSERIAL1 webSocketSerial
  #endif
 #endif

@@ -69,6 +67,10 @@ extern portMUX_TYPE spinlock;
 #define ENABLE_ISRS()  if (spinlock.owner != portMUX_FREE_VAL) portEXIT_CRITICAL(&spinlock)
 #define DISABLE_ISRS() portENTER_CRITICAL(&spinlock)

+// Fix bug in pgm_read_ptr
+#undef pgm_read_ptr
+#define pgm_read_ptr(addr) (*(addr))
+
 // ------------------------
 // Types
 // ------------------------
@@ -139,7 +141,7 @@ void HAL_adc_start_conversion(const uint8_t adc_pin);
 #define HAL_IDLETASK 1
 #define BOARD_INIT() HAL_init_board();
 void HAL_idletask();
-inline void HAL_init() {}
+void HAL_init();
 void HAL_init_board();

 //
@@ -29,7 +29,7 @@
 #include "wifi.h"
 #include <ESPAsyncWebServer.h>

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

 // RingBuffer impl
@@ -144,5 +144,9 @@ size_t WebSocketSerial::write(const uint8_t* buffer, size_t size) {
  return written;
 }

+void WebSocketSerial::flushTX() {
+  // No need to do anything as there's no benefit to sending partial lines over the websocket connection.
+}
+
 #endif // WIFISUPPORT
 #endif // ARDUINO_ARCH_ESP32
@@ -22,7 +22,6 @@
 #pragma once

 #include "../../inc/MarlinConfig.h"
-#include "../../core/serial_hook.h"

 #include <Stream.h>

@@ -69,9 +68,12 @@ public:
  int peek();
  int read();
  void flush();
+  void flushTX();
  size_t write(const uint8_t c);
  size_t write(const uint8_t* buffer, size_t size);

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

-typedef Serial1Class<WebSocketSerial> MSerialT;
-extern MSerialT webSocketSerial;
+extern WebSocketSerial webSocketSerial;
@@ -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
@@ -24,7 +24,7 @@
 #include "../../inc/MarlinConfig.h"
 #include "../shared/Delay.h"

-MSerialT usb_serial(TERN0(EMERGENCY_PARSER, true));
+HalSerial usb_serial;

 // U8glib required functions
 extern "C" {
@@ -60,8 +60,8 @@ uint8_t _getc();

 #define SHARED_SERVOS HAS_SERVOS

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

 #define ST7920_DELAY_1 DELAY_NS(600)
 #define ST7920_DELAY_2 DELAY_NS(750)
@@ -113,3 +113,8 @@ inline void HAL_reboot() {}  // reboot the board or restart the bootloader
 FORCE_INLINE static void DELAY_CYCLES(uint64_t x) {
  Clock::delayCycles(x);
 }
+
+// Add strcmp_P if missing
+#ifndef strcmp_P
+  #define strcmp_P(a, b) strcmp((a), (b))
+#endif
@@ -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
@@ -73,6 +73,27 @@ extern "C" {
  void GpioDisableInt(uint32_t port, uint32_t pin);
 }

+// Program Memory
+#define pgm_read_ptr(addr)        (*((void**)(addr)))
+#define pgm_read_byte_near(addr)  (*((uint8_t*)(addr)))
+#define pgm_read_float_near(addr) (*((float*)(addr)))
+#define pgm_read_word_near(addr)  (*((uint16_t*)(addr)))
+#define pgm_read_dword_near(addr) (*((uint32_t*)(addr)))
+#define pgm_read_byte(addr)       pgm_read_byte_near(addr)
+#define pgm_read_float(addr)      pgm_read_float_near(addr)
+#define pgm_read_word(addr)       pgm_read_word_near(addr)
+#define pgm_read_dword(addr)      pgm_read_dword_near(addr)
+
+using std::memcpy;
+#define memcpy_P memcpy
+#define sprintf_P sprintf
+#define strstr_P strstr
+#define strncpy_P strncpy
+#define vsnprintf_P vsnprintf
+#define strcpy_P strcpy
+#define snprintf_P snprintf
+#define strlen_P strlen
+
 // Time functions
 extern "C" void delay(const int milis);
 void _delay_ms(const int delay);
@@ -25,7 +25,6 @@
 #if ENABLED(EMERGENCY_PARSER)
  #include "../../../feature/e_parser.h"
 #endif
-#include "../../../core/serial_hook.h"

 #include <stdarg.h>
 #include <stdio.h>
@@ -74,11 +73,19 @@ private:
  volatile uint32_t index_read;
 };

-struct HalSerial {
+class HalSerial {
+public:
+
+  #if ENABLED(EMERGENCY_PARSER)
+    EmergencyParser::State emergency_state;
+    static inline bool emergency_parser_enabled() { return true; }
+  #endif
+
  HalSerial() { host_connected = true; }

  void begin(int32_t) {}
-  void end()          {}
+
+  void end() {}

  int peek() {
    uint8_t value;
@@ -93,7 +100,7 @@ struct HalSerial {
    return transmit_buffer.write(c);
  }

-  bool connected() { return host_connected; }
+  operator bool() { return host_connected; }

  uint16_t available() {
    return (uint16_t)receive_buffer.available();
@@ -110,9 +117,92 @@ struct HalSerial {
      while (transmit_buffer.available()) { /* nada */ }
  }

+  void printf(const char *format, ...) {
+    static char buffer[256];
+    va_list vArgs;
+    va_start(vArgs, format);
+    int length = vsnprintf((char *) buffer, 256, (char const *) format, vArgs);
+    va_end(vArgs);
+    if (length > 0 && length < 256) {
+      if (host_connected) {
+        for (int i = 0; i < length;) {
+          if (transmit_buffer.write(buffer[i])) {
+            ++i;
+          }
+        }
+      }
+    }
+  }
+
+  #define DEC 10
+  #define HEX 16
+  #define OCT 8
+  #define BIN 2
+
+  void print_bin(uint32_t value, uint8_t num_digits) {
+    uint32_t mask = 1 << (num_digits -1);
+    for (uint8_t i = 0; i < num_digits; i++) {
+      if (!(i %  4) && i) write(' ');
+      if (!(i % 16) && i) write(' ');
+      if (value & mask)   write('1');
+      else                write('0');
+      value <<= 1;
+    }
+  }
+
+  void print(const char value[]) { printf("%s" , value); }
+  void print(char value, int nbase = 0) {
+    if (nbase == BIN) print_bin(value, 8);
+    else if (nbase == OCT) printf("%3o", value);
+    else if (nbase == HEX) printf("%2X", value);
+    else if (nbase == DEC ) printf("%d", value);
+    else printf("%c" , value);
+  }
+  void print(unsigned char value, int nbase = 0) {
+    if (nbase == BIN) print_bin(value, 8);
+    else if (nbase == OCT) printf("%3o", value);
+    else if (nbase == HEX) printf("%2X", value);
+    else printf("%u" , value);
+  }
+  void print(int value, int nbase = 0) {
+    if (nbase == BIN) print_bin(value, 16);
+    else if (nbase == OCT) printf("%6o", value);
+    else if (nbase == HEX) printf("%4X", value);
+    else printf("%d", value);
+  }
+  void print(unsigned int value, int nbase = 0) {
+    if (nbase == BIN) print_bin(value, 16);
+    else if (nbase == OCT) printf("%6o", value);
+    else if (nbase == HEX) printf("%4X", value);
+    else printf("%u" , value);
+  }
+  void print(long value, int nbase = 0) {
+    if (nbase == BIN) print_bin(value, 32);
+    else if (nbase == OCT) printf("%11o", value);
+    else if (nbase == HEX) printf("%8X", value);
+    else printf("%ld" , value);
+  }
+  void print(unsigned long value, int nbase = 0) {
+    if (nbase == BIN) print_bin(value, 32);
+    else if (nbase == OCT) printf("%11o", value);
+    else if (nbase == HEX) printf("%8X", value);
+    else printf("%lu" , value);
+  }
+  void print(float value, int round = 6)  { printf("%f" , value); }
+  void print(double value, int round = 6) { printf("%f" , value); }
+
+  void println(const char value[]) { printf("%s\n" , value); }
+  void println(char value, int nbase = 0) { print(value, nbase); println(); }
+  void println(unsigned char value, int nbase = 0) { print(value, nbase); println(); }
+  void println(int value, int nbase = 0) { print(value, nbase); println(); }
+  void println(unsigned int value, int nbase = 0) { print(value, nbase); println(); }
+  void println(long value, int nbase = 0) { print(value, nbase); println(); }
+  void println(unsigned long value, int nbase = 0) { print(value, nbase); println(); }
+  void println(float value, int round = 6) { printf("%f\n" , value); }
+  void println(double value, int round = 6) { printf("%f\n" , value); }
+  void println() { print('\n'); }
+
  volatile RingBuffer<uint8_t, 128> receive_buffer;
  volatile RingBuffer<uint8_t, 128> transmit_buffer;
  volatile bool host_connected;
 };
-
-typedef Serial1Class<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,8 +29,6 @@
  #include "watchdog.h"
 #endif

-DefaultSerial1 USBSerial(false, UsbSerial);
-
 uint32_t HAL_adc_reading = 0;

 // U8glib required functions
@@ -63,12 +61,7 @@ int16_t PARSED_PIN_INDEX(const char code, const int16_t dval) {
  return ind > -1 ? ind : dval;
 }

-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
-  NVIC_SystemReset();
-}
+void flashFirmware(const int16_t) { NVIC_SystemReset(); }

 void HAL_clear_reset_source(void) {
  TERN_(USE_WATCHDOG, watchdog_clear_timeout_flag());
@@ -60,25 +60,23 @@ extern "C" volatile uint32_t _millis;
  #define ST7920_DELAY_3 DELAY_NS(750)
 #endif

-typedef ForwardSerial1Class< decltype(UsbSerial) > DefaultSerial1;
-extern DefaultSerial1 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 -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 -1 to 3. Please update your configuration."
  #endif
@@ -86,7 +84,7 @@ extern DefaultSerial1 USBSerial;

 #ifdef MMU2_SERIAL_PORT
  #if MMU2_SERIAL_PORT == -1
-    #define MMU2_SERIAL USBSerial
+    #define MMU2_SERIAL UsbSerial
  #elif WITHIN(MMU2_SERIAL_PORT, 0, 3)
    #define MMU2_SERIAL MSERIAL(MMU2_SERIAL_PORT)
  #else
@@ -96,7 +94,7 @@ extern DefaultSerial1 USBSerial;

 #ifdef LCD_SERIAL_PORT
  #if LCD_SERIAL_PORT == -1
-    #define LCD_SERIAL USBSerial
+    #define LCD_SERIAL UsbSerial
  #elif WITHIN(LCD_SERIAL_PORT, 0, 3)
    #define LCD_SERIAL MSERIAL(LCD_SERIAL_PORT)
  #else
@@ -216,3 +214,16 @@ void HAL_clear_reset_source(void);
 uint8_t HAL_get_reset_source(void);

 inline void HAL_reboot() {}  // reboot the board or restart the bootloader
+
+// Add strcmp_P if missing
+#ifndef strcmp_P
+  #define strcmp_P(a, b) strcmp((a), (b))
+#endif
+
+#ifndef strcat_P
+  #define strcat_P(a, b) strcat((a), (b))
+#endif
+
+#ifndef strcpy_P
+  #define strcpy_P(a, b) strcpy((a), (b))
+#endif
@@ -1,50 +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 "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
@@ -24,47 +24,21 @@
 #include "../../inc/MarlinConfigPre.h"
 #include "MarlinSerial.h"

-#if ANY_SERIAL_IS(0)
-  MarlinSerial _MSerial(LPC_UART0);
-  MSerialT MSerial0(true, _MSerial);
-  extern "C" void UART0_IRQHandler() { _MSerial.IRQHandler(); }
+#if USING_SERIAL_0
+  MarlinSerial MSerial(LPC_UART0);
+  extern "C" void UART0_IRQHandler() { MSerial.IRQHandler(); }
 #endif
-#if ANY_SERIAL_IS(1)
-  MarlinSerial _MSerial1((LPC_UART_TypeDef *) LPC_UART1);
-  MSerialT MSerial1(true, _MSerial1);
-  extern "C" void UART1_IRQHandler() { _MSerial1.IRQHandler(); }
+#if USING_SERIAL_1
+  MarlinSerial MSerial1((LPC_UART_TypeDef *) LPC_UART1);
+  extern "C" void UART1_IRQHandler() { MSerial1.IRQHandler(); }
 #endif
-#if ANY_SERIAL_IS(2)
-  MarlinSerial _MSerial2(LPC_UART2);
-  MSerialT MSerial2(true, _MSerial2);
-  extern "C" void UART2_IRQHandler() { _MSerial2.IRQHandler(); }
+#if USING_SERIAL_2
+  MarlinSerial MSerial2(LPC_UART2);
+  extern "C" void UART2_IRQHandler() { MSerial2.IRQHandler(); }
 #endif
-#if ANY_SERIAL_IS(3)
-  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 ANY_SERIAL_IS(0)
-      else if (this == &_MSerial) emergency_parser.update(MSerial0.emergency_state, c);
-    #endif
-    #if ANY_SERIAL_IS(1)
-      else if (this == &_MSerial1) emergency_parser.update(MSerial1.emergency_state, c);
-    #endif
-    #if ANY_SERIAL_IS(2)
-      else if (this == &_MSerial2) emergency_parser.update(MSerial2.emergency_state, c);
-    #endif
-    #if ANY_SERIAL_IS(3)
-      else if (this == &_MSerial3) emergency_parser.update(MSerial3.emergency_state, c);
-    #endif
-    return true;
-  }
-
+#if USING_SERIAL_3
+  MarlinSerial MSerial3(LPC_UART3);
+  extern "C" void UART3_IRQHandler() { MSerial3.IRQHandler(); }
 #endif

 #endif // TARGET_LPC1768
@@ -28,7 +28,6 @@
 #if ENABLED(EMERGENCY_PARSER)
  #include "../../feature/e_parser.h"
 #endif
-#include "../../core/serial_hook.h"

 #ifndef SERIAL_PORT
  #define SERIAL_PORT 0
@@ -42,26 +41,27 @@

 class MarlinSerial : public HardwareSerial<RX_BUFFER_SIZE, TX_BUFFER_SIZE> {
 public:
-  MarlinSerial(LPC_UART_TypeDef *UARTx) : HardwareSerial<RX_BUFFER_SIZE, TX_BUFFER_SIZE>(UARTx) { }
+  MarlinSerial(LPC_UART_TypeDef *UARTx) :
+    HardwareSerial<RX_BUFFER_SIZE, TX_BUFFER_SIZE>(UARTx)
+    #if ENABLED(EMERGENCY_PARSER)
+      , emergency_state(EmergencyParser::State::EP_RESET)
+    #endif
+    { }

  void end() {}

  #if ENABLED(EMERGENCY_PARSER)
-    bool recv_callback(const char c) override;
+    bool recv_callback(const char c) override {
+      emergency_parser.update(emergency_state, c);
+      return true; // do not discard character
+    }
+
+    EmergencyParser::State emergency_state;
+    static inline bool emergency_parser_enabled() { return true; }
  #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;
-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
-// Right now, let's ignore this until it's actually required.
-#if ENABLED(SERIAL_RUNTIME_HOOK)
-  #error "SERIAL_RUNTIME_HOOK is not yet supported for LPC176x."
-#endif
+extern MarlinSerial MSerial;
+extern MarlinSerial MSerial1;
+extern MarlinSerial MSerial2;
+extern MarlinSerial MSerial3;
@@ -83,16 +83,17 @@ 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);
-  SERIAL_ECHOLNPAIR("_data(", pos, ",", value, ",", size, ", ...)");
+  serialprintPGM(rw_str);
+  SERIAL_ECHOLNPAIR("_data(", pos, ",", int(value), ",", int(size), ", ...)");
  if (total) {
    SERIAL_ECHOPGM(" f_");
-    SERIAL_ECHOPGM_P(rw_str);
-    SERIAL_ECHOPAIR("()=", s, "\n size=", size, "\n bytes_");
-    SERIAL_ECHOLNPAIR_P(write ? PSTR("written=") : PSTR("read="), total);
+    serialprintPGM(rw_str);
+    SERIAL_ECHOPAIR("()=", int(s), "\n size=", int(size), "\n bytes_");
+    serialprintPGM(write ? PSTR("written=") : PSTR("read="));
+    SERIAL_ECHOLN(total);
  }
  else
-    SERIAL_ECHOLNPAIR(" f_lseek()=", s);
+    SERIAL_ECHOLNPAIR(" f_lseek()=", int(s));
 }

 // File function return codes for type FRESULT. This goes away soon, but
@@ -26,9 +26,3 @@
 #elif EITHER(I2C_EEPROM, SPI_EEPROM)
  #define USE_SHARED_EEPROM 1
 #endif
-
-// 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
-  #define PRINTCOUNTER_SYNC 1
-#endif
@@ -31,7 +31,7 @@
 /**
 * Detect an old pins file by checking for old ADC pins values.
 */
-#define _OLD_TEMP_PIN(P) PIN_EXISTS(P) && _CAT(P,_PIN) <= 7 && !WITHIN(_CAT(P,_PIN), TERN(LPC1768_IS_SKRV1_3, 0, 2), 3)  // Include P0_00 and P0_01 for SKR V1.3 board
+#define _OLD_TEMP_PIN(P) PIN_EXISTS(P) && _CAT(P,_PIN) <= 7 && _CAT(P,_PIN) != 2 && _CAT(P,_PIN) != 3
 #if _OLD_TEMP_PIN(TEMP_BED)
  #error "TEMP_BED_PIN must be defined using the Pn_nn or Pn_nn_An format. (See the included pins files)."
 #elif _OLD_TEMP_PIN(TEMP_0)
@@ -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 ANY_SERIAL_IS(0)
+#if USING_SERIAL_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 ANY_SERIAL_IS(1)
+#if USING_SERIAL_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 ANY_SERIAL_IS(2)
+#if USING_SERIAL_2
  #define IS_TX2(P) (P == P0_10)
  #define IS_RX2(P) (P == P0_11)
  #define _IS_TX2_1 IS_TX2
@@ -161,7 +161,7 @@ static_assert(DISABLED(BAUD_RATE_GCODE), "BAUD_RATE_GCODE is not yet supported o
  #undef _IS_RX2_1
 #endif

-#if ANY_SERIAL_IS(3)
+#if USING_SERIAL_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
@@ -121,11 +119,13 @@ void HAL_init() {
  #endif

  USB_Init();                               // USB Initialization
-  USB_Connect(false);                       // USB clear connection
+  USB_Connect(FALSE);                       // USB clear connection
  delay(1000);                              // Give OS time to notice
-  USB_Connect(true);
+  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
@@ -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")
@@ -31,8 +33,9 @@ try:
 		#
 		# 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
+		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
@@ -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;
 }

@@ -24,24 +24,6 @@
 #include <Adafruit_ZeroDMA.h>
 #include <wiring_private.h>

-#ifdef ADAFRUIT_GRAND_CENTRAL_M4
-  #if ANY_SERIAL_IS(-1)
-    DefaultSerial1 MSerial0(false, Serial);
-  #endif
-  #if ANY_SERIAL_IS(0)
-    DefaultSerial2 MSerial1(false, Serial1);
-  #endif
-  #if ANY_SERIAL_IS(1)
-    DefaultSerial3 MSerial2(false, Serial2);
-  #endif
-  #if ANY_SERIAL_IS(2)
-    DefaultSerial4 MSerial3(false, Serial3);
-  #endif
-  #if ANY_SERIAL_IS(3)
-    DefaultSerial5 MSerial4(false, Serial4);
-  #endif
-#endif
-
 // ------------------------
 // Local defines
 // ------------------------
@@ -57,7 +39,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 +48,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 +126,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 +166,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 +214,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 +263,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
@@ -32,36 +32,26 @@
  #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;

-  // MYSERIAL1 required before MarlinSerial includes!
+  // MYSERIAL0 required before MarlinSerial includes!

-  #define __MSERIAL(X) MSerial##X
+  #define __MSERIAL(X) Serial##X
  #define _MSERIAL(X) __MSERIAL(X)
  #define MSERIAL(X) _MSERIAL(INCREMENT(X))

  #if SERIAL_PORT == -1
-    #define MYSERIAL1 MSerial0
+    #define MYSERIAL0 Serial
  #elif WITHIN(SERIAL_PORT, 0, 3)
-    #define MYSERIAL1 MSERIAL(SERIAL_PORT)
+    #define MYSERIAL0 MSERIAL(SERIAL_PORT)
  #else
    #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 Serial
    #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 -1 to 3. Please update your configuration."
    #endif
@@ -69,7 +59,7 @@

  #ifdef MMU2_SERIAL_PORT
    #if MMU2_SERIAL_PORT == -1
-      #define MMU2_SERIAL MSerial0
+      #define MMU2_SERIAL Serial
    #elif WITHIN(MMU2_SERIAL_PORT, 0, 3)
      #define MMU2_SERIAL MSERIAL(MMU2_SERIAL_PORT)
    #else
@@ -79,7 +69,7 @@

  #ifdef LCD_SERIAL_PORT
    #if LCD_SERIAL_PORT == -1
-      #define LCD_SERIAL MSerial0
+      #define LCD_SERIAL Serial
    #elif WITHIN(LCD_SERIAL_PORT, 0, 3)
      #define LCD_SERIAL MSERIAL(LCD_SERIAL_PORT)
    #else
@@ -27,24 +27,24 @@

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

-#if ANY_SERIAL_IS(1)
-  UartT Serial2(false, &sercom4, PIN_SERIAL2_RX, PIN_SERIAL2_TX, PAD_SERIAL2_RX, PAD_SERIAL2_TX);
+#if USING_SERIAL_1
+  Uart Serial2(&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(); }
  void SERCOM4_2_Handler() { Serial2.IrqHandler(); }
  void SERCOM4_3_Handler() { Serial2.IrqHandler(); }
 #endif

-#if ANY_SERIAL_IS(2)
-  UartT Serial3(false, &sercom1, PIN_SERIAL3_RX, PIN_SERIAL3_TX, PAD_SERIAL3_RX, PAD_SERIAL3_TX);
+#if USING_SERIAL_2
+  Uart Serial3(&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(); }
  void SERCOM1_2_Handler() { Serial3.IrqHandler(); }
  void SERCOM1_3_Handler() { Serial3.IrqHandler(); }
 #endif

-#if ANY_SERIAL_IS(3)
-  UartT Serial4(false, &sercom5, PIN_SERIAL4_RX, PIN_SERIAL4_TX, PAD_SERIAL4_RX, PAD_SERIAL4_TX);
+#if USING_SERIAL_3
+  Uart Serial4(&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(); }
  void SERCOM5_2_Handler() { Serial4.IrqHandler(); }
@@ -20,10 +20,6 @@
 */
 #pragma once

-#include "../../core/serial_hook.h"
-
-typedef Serial1Class<Uart> UartT;
-
-extern UartT Serial2;
-extern UartT Serial3;
-extern UartT Serial4;
+extern Uart Serial2;
+extern Uart Serial3;
+extern Uart Serial4;
@@ -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
@@ -28,10 +28,6 @@
 #include "../../inc/MarlinConfig.h"
 #include "../shared/Delay.h"

-#ifdef USBCON
-  DefaultSerial1 MSerial0(false, SerialUSB);
-#endif
-
 #if ENABLED(SRAM_EEPROM_EMULATION)
  #if STM32F7xx
    #include <stm32f7xx_ll_pwr.h>
@@ -42,11 +38,6 @@
  #endif
 #endif

-#if HAS_SD_HOST_DRIVE
-  #include "msc_sd.h"
-  #include "usbd_cdc_if.h"
-#endif
-
 // ------------------------
 // Public Variables
 // ------------------------
@@ -57,18 +48,21 @@ uint16_t HAL_adc_result;
 // Public functions
 // ------------------------

-TERN_(POSTMORTEM_DEBUGGING, extern void install_min_serial());
+// Needed for DELAY_NS() / DELAY_US() on CORTEX-M7
+#if (defined(__arm__) || defined(__thumb__)) && __CORTEX_M == 7
+  // HAL pre-initialization task
+  // Force the preinit function to run between the premain() and main() function
+  // of the STM32 arduino core
+  __attribute__((constructor (102)))
+  void HAL_preinit() {
+    enableCycleCounter();
+  }
+#endif

 // 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
@@ -90,21 +84,6 @@ void HAL_init() {
  #if ENABLED(EMERGENCY_PARSER) && USBD_USE_CDC
    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
-}
-
-// HAL idle task
-void HAL_idletask() {
-  #if HAS_SHARED_MEDIA
-    // Stm32duino currently doesn't have a "loop/idle" method
-    CDC_resume_receive();
-    CDC_continue_transmit();
-  #endif
 }

 void HAL_clear_reset_source() { __HAL_RCC_CLEAR_RESET_FLAGS(); }
@@ -39,9 +39,6 @@

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

 // ------------------------
@@ -51,18 +48,18 @@
 #define MSERIAL(X) _MSERIAL(X)

 #if SERIAL_PORT == -1
-  #define MYSERIAL1 MSerial0
+  #define MYSERIAL0 SerialUSB
 #elif WITHIN(SERIAL_PORT, 1, 6)
-  #define MYSERIAL1 MSERIAL(SERIAL_PORT)
+  #define MYSERIAL0 MSERIAL(SERIAL_PORT)
 #else
  #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 SerialUSB
  #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 -1 or from 1 to 6. Please update your configuration."
  #endif
@@ -70,7 +67,7 @@

 #ifdef MMU2_SERIAL_PORT
  #if MMU2_SERIAL_PORT == -1
-    #define MMU2_SERIAL MSerial0
+    #define MMU2_SERIAL SerialUSB
  #elif WITHIN(MMU2_SERIAL_PORT, 1, 6)
    #define MMU2_SERIAL MSERIAL(MMU2_SERIAL_PORT)
  #else
@@ -80,7 +77,7 @@

 #ifdef LCD_SERIAL_PORT
  #if LCD_SERIAL_PORT == -1
-    #define LCD_SERIAL MSerial0
+    #define LCD_SERIAL SerialUSB
  #elif WITHIN(LCD_SERIAL_PORT, 1, 6)
    #define LCD_SERIAL MSERIAL(LCD_SERIAL_PORT)
  #else
@@ -109,6 +106,14 @@
 // On AVR this is in math.h?
 #define square(x) ((x)*(x))

+#ifndef strncpy_P
+  #define strncpy_P(dest, src, num) strncpy((dest), (src), (num))
+#endif
+
+// Fix bug in pgm_read_ptr
+#undef pgm_read_ptr
+#define pgm_read_ptr(addr) (*(addr))
+
 // ------------------------
 // Types
 // ------------------------
@@ -135,8 +140,6 @@ extern uint16_t HAL_adc_result;

 // Enable hooks into  setup for HAL
 void HAL_init();
-#define HAL_IDLETASK 1
-void HAL_idletask();

 // Clear reset reason
 void HAL_clear_reset_source();
@@ -194,7 +197,6 @@ void flashFirmware(const int16_t);
 typedef void (*systickCallback_t)(void);
 void systick_attach_callback(systickCallback_t cb);
 void HAL_SYSTICK_Callback();
-
 extern volatile uint32_t systick_uptime_millis;

 #define HAL_CAN_SET_PWM_FREQ   // This HAL supports PWM Frequency adjustment
@@ -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;
-    nvicBase->ICER[nvicIndex / 32] |= _BV32(nvicIndex % 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();
-
-    // 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
@@ -51,28 +51,18 @@ static SPISettings spiConfig;
    OUT_WRITE(SD_MOSI_PIN, HIGH);
  }

-  // Use function with compile-time value so we can actually reach the desired frequency
-  // Need to adjust this a little bit: on a 72MHz clock, we have 14ns/clock
-  // and we'll use ~3 cycles to jump to the method and going back, so it'll take ~40ns from the given clock here
-  #define CALLING_COST_NS  (3U * 1000000000U) / (F_CPU)
-  void (*delaySPIFunc)();
-  void delaySPI_125()  { DELAY_NS(125 - CALLING_COST_NS); }
-  void delaySPI_250()  { DELAY_NS(250 - CALLING_COST_NS); }
-  void delaySPI_500()  { DELAY_NS(500 - CALLING_COST_NS); }
-  void delaySPI_1000() { DELAY_NS(1000 - CALLING_COST_NS); }
-  void delaySPI_2000() { DELAY_NS(2000 - CALLING_COST_NS); }
-  void delaySPI_4000() { DELAY_NS(4000 - CALLING_COST_NS); }
+  static uint16_t delay_STM32_soft_spi;

  void spiInit(uint8_t spiRate) {
    // Use datarates Marlin uses
    switch (spiRate) {
-      case SPI_FULL_SPEED:   delaySPIFunc =  &delaySPI_125; break;  // desired: 8,000,000  actual: ~1.1M
-      case SPI_HALF_SPEED:   delaySPIFunc =  &delaySPI_125; break;  // desired: 4,000,000  actual: ~1.1M
-      case SPI_QUARTER_SPEED:delaySPIFunc =  &delaySPI_250; break;  // desired: 2,000,000  actual: ~890K
-      case SPI_EIGHTH_SPEED: delaySPIFunc =  &delaySPI_500; break;  // desired: 1,000,000  actual: ~590K
-      case SPI_SPEED_5:      delaySPIFunc = &delaySPI_1000; break;  // desired:   500,000  actual: ~360K
-      case SPI_SPEED_6:      delaySPIFunc = &delaySPI_2000; break;  // desired:   250,000  actual: ~210K
-      default:               delaySPIFunc = &delaySPI_4000; break;  // desired:   125,000  actual: ~123K
+      case SPI_FULL_SPEED:   delay_STM32_soft_spi =  125; break;  // desired: 8,000,000  actual: ~1.1M
+      case SPI_HALF_SPEED:   delay_STM32_soft_spi =  125; break;  // desired: 4,000,000  actual: ~1.1M
+      case SPI_QUARTER_SPEED:delay_STM32_soft_spi =  250; break;  // desired: 2,000,000  actual: ~890K
+      case SPI_EIGHTH_SPEED: delay_STM32_soft_spi =  500; break;  // desired: 1,000,000  actual: ~590K
+      case SPI_SPEED_5:      delay_STM32_soft_spi = 1000; break;  // desired:   500,000  actual: ~360K
+      case SPI_SPEED_6:      delay_STM32_soft_spi = 2000; break;  // desired:   250,000  actual: ~210K
+      default:               delay_STM32_soft_spi = 4000; break;  // desired:   125,000  actual: ~123K
    }
    SPI.begin();
  }
@@ -85,9 +75,9 @@ static SPISettings spiConfig;
      WRITE(SD_SCK_PIN, LOW);
      WRITE(SD_MOSI_PIN, b & 0x80);

-      delaySPIFunc();
+      DELAY_NS(delay_STM32_soft_spi);
      WRITE(SD_SCK_PIN, HIGH);
-      delaySPIFunc();
+      DELAY_NS(delay_STM32_soft_spi);

      b <<= 1;        // little setup time
      b |= (READ(SD_MISO_PIN) != 0);
@@ -35,7 +35,7 @@

 #define DECLARE_SERIAL_PORT(ser_num) \
  void _rx_complete_irq_ ## ser_num (serial_t * obj); \
-  MSerialT MSerial ## ser_num (true, USART ## ser_num, &_rx_complete_irq_ ## ser_num); \
+  MarlinSerial MSerial ## ser_num (USART ## ser_num, &_rx_complete_irq_ ## ser_num); \
  void _rx_complete_irq_ ## ser_num (serial_t * obj) { MSerial ## ser_num ._rx_complete_irq(obj); }

 #define DECLARE_SERIAL_PORT_EXP(ser_num) DECLARE_SERIAL_PORT(ser_num)
@@ -81,7 +81,7 @@ void MarlinSerial::_rx_complete_irq(serial_t *obj) {
    }

    #if ENABLED(EMERGENCY_PARSER)
-      emergency_parser.update(static_cast<MSerialT*>(this)->emergency_state, c);
+      emergency_parser.update(emergency_state, c);
    #endif
  }
 }
@@ -24,15 +24,21 @@
  #include "../../feature/e_parser.h"
 #endif

-#include "../../core/serial_hook.h"
-
 typedef void (*usart_rx_callback_t)(serial_t * obj);

-struct MarlinSerial : public HardwareSerial {
+class MarlinSerial : public HardwareSerial {
+public:
  MarlinSerial(void* peripheral, usart_rx_callback_t rx_callback) :
      HardwareSerial(peripheral), _rx_callback(rx_callback)
+      #if ENABLED(EMERGENCY_PARSER)
+        , emergency_state(EmergencyParser::State::EP_RESET)
+      #endif
  { }

+  #if ENABLED(EMERGENCY_PARSER)
+    static inline bool emergency_parser_enabled() { return true; }
+  #endif
+
  void begin(unsigned long baud, uint8_t config);
  inline void begin(unsigned long baud) { begin(baud, SERIAL_8N1); }

@@ -40,17 +46,19 @@ struct MarlinSerial : public HardwareSerial {

 protected:
  usart_rx_callback_t _rx_callback;
+  #if ENABLED(EMERGENCY_PARSER)
+    EmergencyParser::State emergency_state;
+  #endif
 };

-typedef Serial1Class<MarlinSerial> MSerialT;
-extern MSerialT MSerial1;
-extern MSerialT MSerial2;
-extern MSerialT MSerial3;
-extern MSerialT MSerial4;
-extern MSerialT MSerial5;
-extern MSerialT MSerial6;
-extern MSerialT MSerial7;
-extern MSerialT MSerial8;
-extern MSerialT MSerial9;
-extern MSerialT MSerial10;
-extern MSerialT MSerialLP1;
+extern MarlinSerial MSerial1;
+extern MarlinSerial MSerial2;
+extern MarlinSerial MSerial3;
+extern MarlinSerial MSerial4;
+extern MarlinSerial MSerial5;
+extern MarlinSerial MSerial6;
+extern MarlinSerial MSerial7;
+extern MarlinSerial MSerial8;
+extern MarlinSerial MSerial9;
+extern MarlinSerial MSerial10;
+extern MarlinSerial MSerialLP1;
@@ -163,6 +163,7 @@
    GPIO_InitStruct.Pin = GPIO_PIN_2;
    HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);

+
    #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
@@ -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
@@ -61,9 +61,7 @@
    #define FLASH_UNIT_SIZE       0x20000 // 128kB
  #endif

-  #ifndef FLASH_ADDRESS_START
-    #define FLASH_ADDRESS_START   (FLASH_END - ((FLASH_SECTOR_TOTAL - (FLASH_SECTOR)) * (FLASH_UNIT_SIZE)) + 1)
-  #endif
+  #define FLASH_ADDRESS_START     (FLASH_END - ((FLASH_SECTOR_TOTAL - (FLASH_SECTOR)) * (FLASH_UNIT_SIZE)) + 1)
  #define FLASH_ADDRESS_END       (FLASH_ADDRESS_START + FLASH_UNIT_SIZE  - 1)

  #define EEPROM_SLOTS            ((FLASH_UNIT_SIZE) / (MARLIN_EEPROM_SIZE))
@@ -21,12 +21,6 @@
 */
 #pragma once

-#if defined(USBD_USE_CDC_MSC) && DISABLED(NO_SD_HOST_DRIVE)
+#if defined(USBD_USE_CDC_COMPOSITE) && 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,9 +47,9 @@
 #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(STM32F4xx, STM32F1xx)
@@ -1,112 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- *
- * Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- * Copyright (c) 2019 BigTreeTech [https://github.com/bigtreetech]
- *
- * 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.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#include "../../inc/MarlinConfigPre.h"
-
-#if defined(ARDUINO_ARCH_STM32) && !defined(STM32GENERIC) && HAS_SD_HOST_DRIVE
-
-#include "msc_sd.h"
-#include "../shared/Marduino.h"
-#include "usbd_core.h"
-#include <USB.h>
-#include <USBMscHandler.h>
-
-#define BLOCK_SIZE 512
-#define PRODUCT_ID 0x29
-
-#include "../../sd/cardreader.h"
-
-class Sd2CardUSBMscHandler : public USBMscHandler {
-public:
-  bool GetCapacity(uint32_t *pBlockNum, uint16_t *pBlockSize) {
-    *pBlockNum = card.getSd2Card().cardSize();
-    *pBlockSize = BLOCK_SIZE;
-    return true;
-  }
-
-  bool Write(uint8_t *pBuf, uint32_t blkAddr, uint16_t blkLen) {
-    auto sd2card = card.getSd2Card();
-    // single block
-    if (blkLen == 1) {
-      watchdog_refresh();
-      sd2card.writeBlock(blkAddr, pBuf);
-      return true;
-    }
-
-    // multi block optmization
-    sd2card.writeStart(blkAddr, blkLen);
-    while (blkLen--) {
-      watchdog_refresh();
-      sd2card.writeData(pBuf);
-      pBuf += BLOCK_SIZE;
-    }
-    sd2card.writeStop();
-    return true;
-  }
-
-  bool Read(uint8_t *pBuf, uint32_t blkAddr, uint16_t blkLen) {
-    auto sd2card = card.getSd2Card();
-    // single block
-    if (blkLen == 1) {
-      watchdog_refresh();
-      sd2card.readBlock(blkAddr, pBuf);
-      return true;
-    }
-
-    // multi block optmization
-    sd2card.readStart(blkAddr);
-    while (blkLen--) {
-      watchdog_refresh();
-      sd2card.readData(pBuf);
-      pBuf += BLOCK_SIZE;
-    }
-    sd2card.readStop();
-    return true;
-  }
-
-  bool IsReady() {
-    return card.isMounted();
-  }
-};
-
-Sd2CardUSBMscHandler usbMscHandler;
-
-/* USB Mass storage Standard Inquiry Data */
-uint8_t  Marlin_STORAGE_Inquirydata[] = { /* 36 */
-  /* LUN 0 */
-  0x00,
-  0x80,
-  0x02,
-  0x02,
-  (STANDARD_INQUIRY_DATA_LEN - 5),
-  0x00,
-  0x00,
-  0x00,
-  'M', 'A', 'R', 'L', 'I', 'N', ' ', ' ', /* Manufacturer : 8 bytes */
-  'P', 'r', 'o', 'd', 'u', 'c', 't', ' ', /* Product      : 16 Bytes */
-  ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
-  '0', '.', '0', '1',                     /* Version      : 4 Bytes */
-};
-
-USBMscHandler *pSingleMscHandler = &usbMscHandler;
-
-void MSC_SD_init() {
-  USBDevice.end();
-  delay(200);
-  USBDevice.begin();
-  USBDevice.registerMscHandlers(1, &pSingleMscHandler, Marlin_STORAGE_Inquirydata);
-}
-
-#endif // __STM32F1__ && HAS_SD_HOST_DRIVE
@@ -1,18 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- *
- * Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- * Copyright (c) 2019 BigTreeTech [https://github.com/bigtreetech]
- *
- * 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.
- *
- * 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
-
-void MSC_SD_init();
@@ -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();
@@ -84,32 +84,6 @@

 #if defined(SERIAL_USB) && !HAS_SD_HOST_DRIVE
  USBSerial SerialUSB;
-  DefaultSerial1 MSerial0(true, SerialUSB);
-
-  #if ENABLED(EMERGENCY_PARSER)
-    #include "../libmaple/usb/stm32f1/usb_reg_map.h"
-    #include "libmaple/usb_cdcacm.h"
-    // The original callback is not called (no way to retrieve address).
-    // That callback detects a special STM32 reset sequence: this functionality is not essential
-    // as M997 achieves the same.
-    void my_rx_callback(unsigned int, void*) {
-      // max length of 16 is enough to contain all emergency commands
-      uint8 buf[16];
-
-      //rx is usbSerialPart.endpoints[2]
-      uint16 len = usb_get_ep_rx_count(USB_CDCACM_RX_ENDP);
-      uint32 total = usb_cdcacm_data_available();
-
-      if (len == 0 || total == 0 || !WITHIN(total, len, COUNT(buf)))
-        return;
-
-      // cannot get character by character due to bug in composite_cdcacm_peek_ex
-      len = usb_cdcacm_peek(buf, total);
-
-      for (uint32 i = 0; i < len; i++)
-        emergency_parser.update(MSerial0.emergency_state, buf[i + total - len]);
-    }
-  #endif
 #endif

 uint16_t HAL_adc_result;
@@ -132,9 +106,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 +163,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 +246,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)
@@ -287,15 +253,12 @@ void HAL_init() {
  #endif
  #if HAS_SD_HOST_DRIVE
    MSC_SD_init();
-  #elif BOTH(SERIAL_USB, EMERGENCY_PARSER)
-    usb_cdcacm_set_hooks(USB_CDCACM_HOOK_RX, my_rx_callback);
  #endif
  #if PIN_EXISTS(USB_CONNECT)
    OUT_WRITE(USB_CONNECT_PIN, !USB_CONNECT_INVERTING);  // USB clear connection
    delay(1000);                                         // Give OS time to notice
    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 +354,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
@@ -61,11 +61,8 @@
 #endif

 #ifdef SERIAL_USB
-  typedef ForwardSerial1Class< USBSerial > DefaultSerial1;
-  extern DefaultSerial1 MSerial0;
-
  #if !HAS_SD_HOST_DRIVE
-    #define UsbSerial MSerial0
+    #define UsbSerial Serial
  #else
    #define UsbSerial MarlinCompositeSerial
  #endif
@@ -81,9 +78,9 @@
 #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
@@ -92,9 +89,9 @@

 #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
@@ -155,6 +152,14 @@ void HAL_idletask();
 // On AVR this is in math.h?
 #define square(x) ((x)*(x))

+#ifndef strncpy_P
+  #define strncpy_P(dest, src, num) strncpy((dest), (src), (num))
+#endif
+
+// Fix bug in pgm_read_ptr
+#undef pgm_read_ptr
+#define pgm_read_ptr(addr) (*(addr))
+
 #define RST_POWER_ON   1
 #define RST_EXTERNAL   2
 #define RST_BROWN_OUT  4
@@ -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
-    //NVIC_BASE->ICER[1] |= _BV(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__
@@ -28,7 +28,7 @@

 // Copied from ~/.platformio/packages/framework-arduinoststm32-maple/STM32F1/system/libmaple/usart_private.h
 // Changed to handle Emergency Parser
-static inline __always_inline void my_usart_irq(ring_buffer *rb, ring_buffer *wb, usart_reg_map *regs, MSerialT &serial) {
+static inline __always_inline void my_usart_irq(ring_buffer *rb, ring_buffer *wb, usart_reg_map *regs, MarlinSerial &serial) {
 /* Handle RXNEIE and TXEIE interrupts.
  * RXNE signifies availability of a byte in DR.
  *
@@ -90,20 +90,20 @@ constexpr bool serial_handles_emergency(int port) {
  ;
 }

-#define DEFINE_HWSERIAL_MARLIN(name, n)     \
-  MSerialT name(serial_handles_emergency(n),\
-            USART##n,                       \
-            BOARD_USART##n##_TX_PIN,        \
-            BOARD_USART##n##_RX_PIN);       \
-  extern "C" void __irq_usart##n(void) {    \
+#define DEFINE_HWSERIAL_MARLIN(name, n)   \
+  MarlinSerial name(USART##n,             \
+            BOARD_USART##n##_TX_PIN,      \
+            BOARD_USART##n##_RX_PIN,      \
+            serial_handles_emergency(n)); \
+  extern "C" void __irq_usart##n(void) {  \
    my_usart_irq(USART##n->rb, USART##n->wb, USART##n##_BASE, MSerial##n); \
  }

 #define DEFINE_HWSERIAL_UART_MARLIN(name, n) \
-  MSerialT name(serial_handles_emergency(n), \
-          UART##n,                           \
+  MarlinSerial name(UART##n,                 \
          BOARD_USART##n##_TX_PIN,           \
-          BOARD_USART##n##_RX_PIN);          \
+          BOARD_USART##n##_RX_PIN,           \
+          serial_handles_emergency(n));      \
  extern "C" void __irq_usart##n(void) {     \
    my_usart_irq(UART##n->rb, UART##n->wb, UART##n##_BASE, MSerial##n); \
  }
@@ -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
@@ -26,13 +26,28 @@
 #include <WString.h>

 #include "../../inc/MarlinConfigPre.h"
-#include "../../core/serial_hook.h"
+#if ENABLED(EMERGENCY_PARSER)
+  #include "../../feature/e_parser.h"
+#endif

 // Increase priority of serial interrupts, to reduce overflow errors
 #define UART_IRQ_PRIO 1

-struct MarlinSerial : public HardwareSerial {
-  MarlinSerial(struct usart_dev *usart_device, uint8 tx_pin, uint8 rx_pin) : HardwareSerial(usart_device, tx_pin, rx_pin) { }
+class MarlinSerial : public HardwareSerial {
+public:
+  #if ENABLED(EMERGENCY_PARSER)
+    const bool ep_enabled;
+    EmergencyParser::State emergency_state;
+    inline bool emergency_parser_enabled() { return ep_enabled; }
+  #endif
+
+  MarlinSerial(struct usart_dev *usart_device, uint8 tx_pin, uint8 rx_pin, bool TERN_(EMERGENCY_PARSER, ep_capable)) :
+    HardwareSerial(usart_device, tx_pin, rx_pin)
+    #if ENABLED(EMERGENCY_PARSER)
+      , ep_enabled(ep_capable)
+      , emergency_state(EmergencyParser::State::EP_RESET)
+    #endif
+    { }

  #ifdef UART_IRQ_PRIO
    // Shadow the parent methods to set IRQ priority after begin()
@@ -47,12 +62,10 @@ struct MarlinSerial : public HardwareSerial {
  #endif
 };

-typedef Serial1Class<MarlinSerial> MSerialT;
-
-extern MSerialT MSerial1;
-extern MSerialT MSerial2;
-extern MSerialT MSerial3;
+extern MarlinSerial MSerial1;
+extern MarlinSerial MSerial2;
+extern MarlinSerial MSerial3;
 #if EITHER(STM32_HIGH_DENSITY, STM32_XL_DENSITY)
-  extern MSerialT MSerial4;
-  extern MSerialT MSerial5;
+  extern MarlinSerial MSerial4;
+  extern MarlinSerial MSerial5;
 #endif
@@ -40,7 +40,7 @@ void eeprom_init() { BL24CXX::init(); }
 // Public functions
 // ------------------------

-void eeprom_write_byte(uint8_t *pos, uint8_t value) {
+void eeprom_write_byte(uint8_t *pos, unsigned char value) {
  const unsigned eeprom_address = (unsigned)pos;
  return BL24CXX::writeOneByte(eeprom_address, value);
 }
@@ -34,9 +34,9 @@
 #endif

 #if ENABLED(SERIAL_STATS_MAX_RX_QUEUED)
-  #error "SERIAL_STATS_MAX_RX_QUEUED is not supported on the STM32F1 platform."
+  #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 the STM32F1 platform."
+  #error "SERIAL_STATS_DROPPED_RX is not supported on this platform."
 #endif

 #if ENABLED(NEOPIXEL_LED)
@@ -19,12 +19,11 @@

 #include "msc_sd.h"
 #include "SPI.h"
-#include "usb_reg_map.h"

 #define PRODUCT_ID 0x29

 USBMassStorage MarlinMSC;
-Serial1Class<USBCompositeSerial> MarlinCompositeSerial(true);
+MarlinUSBCompositeSerial MarlinCompositeSerial;

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

@@ -42,28 +41,14 @@ Serial1Class<USBCompositeSerial> MarlinCompositeSerial(true);
 #endif

 #if ENABLED(EMERGENCY_PARSER)
+  void (*real_rx_callback)(void);

-  // The original callback is not called (no way to retrieve address).
-  // That callback detects a special STM32 reset sequence: this functionality is not essential
-  // as M997 achieves the same.
-  void my_rx_callback(unsigned int, void*) {
-    // max length of 16 is enough to contain all emergency commands
-    uint8 buf[16];
-
-    //rx is usbSerialPart.endpoints[2]
-    uint16 len = usb_get_ep_rx_count(usbSerialPart.endpoints[2].address);
-    uint32 total = composite_cdcacm_data_available();
-
-    if (len == 0 || total == 0 || !WITHIN(total, len, COUNT(buf)))
-      return;
-
-    // cannot get character by character due to bug in composite_cdcacm_peek_ex
-    len = composite_cdcacm_peek(buf, total);
-
-    for (uint32 i = 0; i < len; i++)
-      emergency_parser.update(MarlinCompositeSerial.emergency_state, buf[i+total-len]);
+  void my_rx_callback(void) {
+    real_rx_callback();
+    int len = MarlinCompositeSerial.available();
+    while (len-- > 0) // >0 because available() may return a negative value
+      emergency_parser.update(MarlinCompositeSerial.emergency_state, MarlinCompositeSerial.peek());
  }
-
 #endif

 void MSC_SD_init() {
@@ -88,7 +73,9 @@ void MSC_SD_init() {
  MarlinCompositeSerial.registerComponent();
  USBComposite.begin();
  #if ENABLED(EMERGENCY_PARSER)
-    composite_cdcacm_set_hooks(USBHID_CDCACM_HOOK_RX, my_rx_callback);
+    //rx is usbSerialPart.endpoints[2]
+    real_rx_callback = usbSerialPart.endpoints[2].callback;
+    usbSerialPart.endpoints[2].callback = my_rx_callback;
  #endif
 }

@@ -18,9 +18,25 @@
 #include <USBComposite.h>

 #include "../../inc/MarlinConfigPre.h"
-#include "../../core/serial_hook.h"
+#if ENABLED(EMERGENCY_PARSER)
+  #include "../../feature/e_parser.h"
+#endif
+
+class MarlinUSBCompositeSerial : public USBCompositeSerial {
+public:
+  MarlinUSBCompositeSerial() : USBCompositeSerial()
+    #if ENABLED(EMERGENCY_PARSER)
+      , emergency_state(EmergencyParser::State::EP_RESET)
+    #endif
+    { }
+
+  #if ENABLED(EMERGENCY_PARSER)
+    EmergencyParser::State emergency_state;
+    inline bool emergency_parser_enabled() { return true; }
+  #endif
+};

 extern USBMassStorage MarlinMSC;
-extern Serial1Class<USBCompositeSerial> MarlinCompositeSerial;
+extern MarlinUSBCompositeSerial MarlinCompositeSerial;

 void MSC_SD_init();
@@ -31,13 +31,6 @@

 #include <Wire.h>

-#define _IMPLEMENT_SERIAL(X) DefaultSerial##X MSerial##X(false, Serial##X)
-#define IMPLEMENT_SERIAL(X)  _IMPLEMENT_SERIAL(X)
-#if WITHIN(SERIAL_PORT, 0, 3)
-  IMPLEMENT_SERIAL(SERIAL_PORT);
-#endif
-USBSerialType USBSerial(false, SerialUSB);
-
 uint16_t HAL_adc_result;

 static const uint8_t pin2sc1a[] = {
@@ -50,25 +50,14 @@
  #define IS_TEENSY32 1
 #endif

-#include "../../core/serial_hook.h"
-
-#define Serial0 Serial
-#define _DECLARE_SERIAL(X) \
-  typedef ForwardSerial1Class<decltype(Serial##X)> DefaultSerial##X; \
-  extern DefaultSerial##X MSerial##X
-#define DECLARE_SERIAL(X) _DECLARE_SERIAL(X)
-
-typedef ForwardSerial1Class<decltype(SerialUSB)> USBSerialType;
-extern USBSerialType USBSerial;
-
-#define _MSERIAL(X) MSerial##X
+#define _MSERIAL(X) Serial##X
 #define MSERIAL(X) _MSERIAL(X)
+#define Serial0 Serial

 #if SERIAL_PORT == -1
-  #define MYSERIAL1 USBSerial
+  #define MYSERIAL0 SerialUSB
 #elif WITHIN(SERIAL_PORT, 0, 3)
-  DECLARE_SERIAL(SERIAL_PORT);
-  #define MYSERIAL1 MSERIAL(SERIAL_PORT)
+  #define MYSERIAL0 MSERIAL(SERIAL_PORT)
 #endif

 #define HAL_SERVO_LIB libServo
@@ -85,6 +74,17 @@ typedef int8_t pin_t;
 #define ENABLE_ISRS()  __enable_irq()
 #define DISABLE_ISRS() __disable_irq()

+#ifndef strncpy_P
+  #define strncpy_P(dest, src, num) strncpy((dest), (src), (num))
+#endif
+
+// Fix bug in pgm_read_ptr
+#undef pgm_read_ptr
+#define pgm_read_ptr(addr) (*((void**)(addr)))
+// Add type-checking to pgm_read_word
+#undef pgm_read_word
+#define pgm_read_word(addr) (*((uint16_t*)(addr)))
+
 inline void HAL_init() {}

 // Clear the reset reason
@@ -34,9 +34,5 @@
 #endif

 #if HAS_TMC_SW_SERIAL
-  #error "TMC220x Software Serial is not supported on Teensy 3.1/3.2."
-#endif
-
-#if ENABLED(POSTMORTEM_DEBUGGING)
-  #error "POSTMORTEM_DEBUGGING is not yet supported on Teensy 3.1/3.2."
+  #error "TMC220x Software Serial is not supported on this platform."
 #endif
@@ -31,14 +31,6 @@

 #include <Wire.h>

-#define _IMPLEMENT_SERIAL(X) DefaultSerial##X MSerial##X(false, Serial##X)
-#define IMPLEMENT_SERIAL(X)  _IMPLEMENT_SERIAL(X)
-#if WITHIN(SERIAL_PORT, 0, 3)
-  IMPLEMENT_SERIAL(SERIAL_PORT);
-#endif
-
-USBSerialType USBSerial(false, SerialUSB);
-
 uint16_t HAL_adc_result, HAL_adc_select;

 static const uint8_t pin2sc1a[] = {
@@ -53,25 +53,14 @@
  #define IS_TEENSY35 1
 #endif

-#include "../../core/serial_hook.h"
-
-#define Serial0 Serial
-#define _DECLARE_SERIAL(X) \
-  typedef ForwardSerial1Class<decltype(Serial##X)> DefaultSerial##X; \
-  extern DefaultSerial##X MSerial##X
-#define DECLARE_SERIAL(X) _DECLARE_SERIAL(X)
-
-typedef ForwardSerial1Class<decltype(SerialUSB)> USBSerialType;
-extern USBSerialType USBSerial;
-
-#define _MSERIAL(X) MSerial##X
+#define _MSERIAL(X) Serial##X
 #define MSERIAL(X) _MSERIAL(X)
+#define Serial0 Serial

 #if SERIAL_PORT == -1
-  #define MYSERIAL1 USBSerial
+  #define MYSERIAL0 SerialUSB
 #elif WITHIN(SERIAL_PORT, 0, 3)
-  #define MYSERIAL1 MSERIAL(SERIAL_PORT)
-  DECLARE_SERIAL(SERIAL_PORT);
+  #define MYSERIAL0 MSERIAL(SERIAL_PORT)
 #endif

 #define HAL_SERVO_LIB libServo
@@ -91,6 +80,17 @@ typedef int8_t pin_t;
 #undef sq
 #define sq(x) ((x)*(x))

+#ifndef strncpy_P
+  #define strncpy_P(dest, src, num) strncpy((dest), (src), (num))
+#endif
+
+// Fix bug in pgm_read_ptr
+#undef pgm_read_ptr
+#define pgm_read_ptr(addr) (*((void**)(addr)))
+// Add type-checking to pgm_read_word
+#undef pgm_read_word
+#define pgm_read_word(addr) (*((uint16_t*)(addr)))
+
 inline void HAL_init() {}

 // Clear reset reason
@@ -34,9 +34,5 @@
 #endif

 #if HAS_TMC_SW_SERIAL
-  #error "TMC220x Software Serial is not supported on Teensy 3.5/3.6."
-#endif
-
-#if ENABLED(POSTMORTEM_DEBUGGING)
-  #error "POSTMORTEM_DEBUGGING is not yet supported on Teensy 3.5/3.6."
+  #error "TMC220x Software Serial is not supported on this platform."
 #endif
@@ -32,13 +32,6 @@

 #include <Wire.h>

-#define _IMPLEMENT_SERIAL(X) DefaultSerial##X MSerial##X(false, Serial##X)
-#define IMPLEMENT_SERIAL(X)  _IMPLEMENT_SERIAL(X)
-#if WITHIN(SERIAL_PORT, 0, 3)
-  IMPLEMENT_SERIAL(SERIAL_PORT);
-#endif
-USBSerialType USBSerial(false, SerialUSB);
-
 uint16_t HAL_adc_result, HAL_adc_select;

 static const uint8_t pin2sc1a[] = {
@@ -37,10 +37,6 @@
 #include <stdint.h>
 #include <util/atomic.h>

-#if HAS_ETHERNET
-  #include "../../feature/ethernet.h"
-#endif
-
 //#define ST7920_DELAY_1 DELAY_NS(600)
 //#define ST7920_DELAY_2 DELAY_NS(750)
 //#define ST7920_DELAY_3 DELAY_NS(750)
@@ -55,35 +51,25 @@
  #define IS_TEENSY41 1
 #endif

-#include "../../core/serial_hook.h"
-#define Serial0 Serial
-#define _DECLARE_SERIAL(X) \
-  typedef ForwardSerial1Class<decltype(Serial##X)> DefaultSerial##X; \
-  extern DefaultSerial##X MSerial##X
-#define DECLARE_SERIAL(X) _DECLARE_SERIAL(X)
-
-typedef ForwardSerial1Class<decltype(SerialUSB)> USBSerialType;
-extern USBSerialType USBSerial;
-
-#define _MSERIAL(X) MSerial##X
+#define _MSERIAL(X) Serial##X
 #define MSERIAL(X) _MSERIAL(X)
+#define Serial0 Serial

 #if SERIAL_PORT == -1
-  #define MYSERIAL1 SerialUSB
+  #define MYSERIAL0 SerialUSB
 #elif WITHIN(SERIAL_PORT, 0, 8)
-  DECLARE_SERIAL(SERIAL_PORT);
-  #define MYSERIAL1 MSERIAL(SERIAL_PORT)
+  #define MYSERIAL0 MSERIAL(SERIAL_PORT)
 #else
  #error "The required SERIAL_PORT must be from -1 to 8. Please update your configuration."
 #endif

 #ifdef SERIAL_PORT_2
  #if SERIAL_PORT_2 == -1
-    #define MYSERIAL2 usbSerial
+    #define MYSERIAL1 usbSerial
  #elif SERIAL_PORT_2 == -2
-    #define MYSERIAL2 ethernet.telnetClient
+    #define MYSERIAL1 ethernet.telnetClient
  #elif WITHIN(SERIAL_PORT_2, 0, 8)
-    #define MYSERIAL2 MSERIAL(SERIAL_PORT_2)
+    #define MYSERIAL1 MSERIAL(SERIAL_PORT_2)
  #else
    #error "SERIAL_PORT_2 must be from -2 to 8. Please update your configuration."
  #endif
@@ -106,10 +92,21 @@ typedef int8_t pin_t;
 #undef sq
 #define sq(x) ((x)*(x))

+#ifndef strncpy_P
+  #define strncpy_P(dest, src, num) strncpy((dest), (src), (num))
+#endif
+
 // Don't place string constants in PROGMEM
 #undef PSTR
 #define PSTR(str) ({static const char *data = (str); &data[0];})

+// Fix bug in pgm_read_ptr
+#undef pgm_read_ptr
+#define pgm_read_ptr(addr) (*((void**)(addr)))
+// Add type-checking to pgm_read_word
+#undef pgm_read_word
+#define pgm_read_word(addr) (*((uint16_t*)(addr)))
+
 // Enable hooks into idle and setup for HAL
 #define HAL_IDLETASK 1
 FORCE_INLINE void HAL_idletask() {}
@@ -34,9 +34,5 @@
 #endif

 #if HAS_TMC_SW_SERIAL
-  #error "TMC220x Software Serial is not supported on Teensy 4.0/4.1."
-#endif
-
-#if ENABLED(POSTMORTEM_DEBUGGING)
-  #error "POSTMORTEM_DEBUGGING is not yet supported on Teensy 4.0/4.1."
+  #error "TMC220x Software Serial is not supported on this platform."
 #endif
@@ -1,175 +0,0 @@
-/**
- * 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/>.
- *
- */
-#include "Delay.h"
-
-#include "../../inc/MarlinConfig.h"
-
-#if defined(__arm__) || defined(__thumb__)
-
-  static uint32_t ASM_CYCLES_PER_ITERATION = 4;   // Initial bet which will be adjusted in calibrate_delay_loop
-
-  // Simple assembler loop counting down
-  void delay_asm(uint32_t cy) {
-    cy = _MAX(cy / ASM_CYCLES_PER_ITERATION, 1U); // Zero is forbidden here
-    __asm__ __volatile__(
-      A(".syntax unified") // is to prevent CM0,CM1 non-unified syntax
-      L("1")
-      A("subs %[cnt],#1")
-      A("bne 1b")
-      : [cnt]"+r"(cy)   // output: +r means input+output
-      :                 // input:
-      : "cc"            // clobbers:
-    );
-  }
-
-  // We can't use CMSIS since it's not available on all platform, so fallback to hardcoded register values
-  #define HW_REG(X)   *(volatile uint32_t *)(X)
-  #define _DWT_CTRL   0xE0001000
-  #define _DWT_CYCCNT 0xE0001004      // CYCCNT is 32bits, takes 37s or so to wrap.
-  #define _DEM_CR     0xE000EDFC
-  #define _LAR        0xE0001FB0
-
-  // Use hardware cycle counter instead, it's much safer
-  void delay_dwt(uint32_t count) {
-    // Reuse the ASM_CYCLES_PER_ITERATION variable to avoid wasting another useless variable
-    uint32_t start = HW_REG(_DWT_CYCCNT) - ASM_CYCLES_PER_ITERATION, elapsed;
-    do {
-      elapsed = HW_REG(_DWT_CYCCNT) - start;
-    } while (elapsed < count);
-  }
-
-  // Pointer to asm function, calling the functions has a ~20 cycles overhead
-  DelayImpl DelayCycleFnc = delay_asm;
-
-  void calibrate_delay_loop() {
-    // Check if we have a working DWT implementation in the CPU (see https://developer.arm.com/documentation/ddi0439/b/Data-Watchpoint-and-Trace-Unit/DWT-Programmers-Model)
-    if (!HW_REG(_DWT_CTRL)) {
-      // No DWT present, so fallback to plain old ASM nop counting
-      // Unfortunately, we don't exactly know how many iteration it'll take to decrement a counter in a loop
-      // It depends on the CPU architecture, the code current position (flash vs SRAM)
-      // So, instead of wild guessing and making mistake, instead
-      // compute it once for all
-      ASM_CYCLES_PER_ITERATION = 1;
-      // We need to fetch some reference clock before waiting
-      cli();
-        uint32_t start = micros();
-        delay_asm(1000); // On a typical CPU running in MHz, waiting 1000 "unknown cycles" means it'll take between 1ms to 6ms, that's perfectly acceptable
-        uint32_t end = micros();
-      sei();
-      uint32_t expectedCycles = (end - start) * ((F_CPU) / 1000000UL); // Convert microseconds to cycles
-      // Finally compute the right scale
-      ASM_CYCLES_PER_ITERATION = (uint32_t)(expectedCycles / 1000);
-
-      // No DWT present, likely a Cortex M0 so NOP counting is our best bet here
-      DelayCycleFnc = delay_asm;
-    }
-    else {
-      // Enable DWT counter
-      // From https://stackoverflow.com/a/41188674/1469714
-      HW_REG(_DEM_CR) = HW_REG(_DEM_CR) | 0x01000000;   // Enable trace
-      #if __CORTEX_M == 7
-        HW_REG(_LAR) = 0xC5ACCE55;                      // Unlock access to DWT registers, see https://developer.arm.com/documentation/ihi0029/e/ section B2.3.10
-      #endif
-      HW_REG(_DWT_CYCCNT) = 0;                          // Clear DWT cycle counter
-      HW_REG(_DWT_CTRL) = HW_REG(_DWT_CTRL) | 1;        // Enable DWT cycle counter
-
-      // Then calibrate the constant offset from the counter
-      ASM_CYCLES_PER_ITERATION = 0;
-      uint32_t s = HW_REG(_DWT_CYCCNT);
-      uint32_t e = HW_REG(_DWT_CYCCNT);  // (e - s) contains the number of cycle required to read the cycle counter
-      delay_dwt(0);
-      uint32_t f = HW_REG(_DWT_CYCCNT);  // (f - e) contains the delay to call the delay function + the time to read the cycle counter
-      ASM_CYCLES_PER_ITERATION = (f - e) - (e - s);
-
-      // Use safer DWT function
-      DelayCycleFnc = delay_dwt;
-    }
-  }
-
-  #if ENABLED(MARLIN_DEV_MODE)
-    void dump_delay_accuracy_check() {
-      auto report_call_time = [](PGM_P const name, PGM_P const unit, const uint32_t cycles, const uint32_t total, const bool do_flush=true) {
-        SERIAL_ECHOPGM("Calling ");
-        SERIAL_ECHOPGM_P(name);
-        SERIAL_ECHOLNPAIR(" for ", cycles);
-        SERIAL_ECHOPGM_P(unit);
-        SERIAL_ECHOLNPAIR(" took: ", total);
-        SERIAL_ECHOPGM_P(unit);
-        if (do_flush) SERIAL_FLUSHTX();
-      };
-
-      uint32_t s, e;
-
-      SERIAL_ECHOLNPAIR("Computed delay calibration value: ", ASM_CYCLES_PER_ITERATION);
-      SERIAL_FLUSH();
-      // Display the results of the calibration above
-      constexpr uint32_t testValues[] = { 1, 5, 10, 20, 50, 100, 150, 200, 350, 500, 750, 1000 };
-      for (auto i : testValues) {
-        s = micros(); DELAY_US(i); e = micros();
-        report_call_time(PSTR("delay"), PSTR("us"), i, e - s);
-      }
-
-      if (HW_REG(_DWT_CTRL)) {
-        for (auto i : testValues) {
-          s = HW_REG(_DWT_CYCCNT); DELAY_CYCLES(i); e = HW_REG(_DWT_CYCCNT);
-          report_call_time(PSTR("runtime delay"), PSTR("cycles"), i, e - s);
-        }
-
-        // Measure the delay to call a real function compared to a function pointer
-        s = HW_REG(_DWT_CYCCNT); delay_dwt(1); e = HW_REG(_DWT_CYCCNT);
-        report_call_time(PSTR("delay_dwt"), PSTR("cycles"), 1, e - s);
-
-        static PGMSTR(dcd, "DELAY_CYCLES directly ");
-
-        s = HW_REG(_DWT_CYCCNT); DELAY_CYCLES( 1); e = HW_REG(_DWT_CYCCNT);
-        report_call_time(dcd, PSTR("cycles"),  1, e - s, false);
-
-        s = HW_REG(_DWT_CYCCNT); DELAY_CYCLES( 5); e = HW_REG(_DWT_CYCCNT);
-        report_call_time(dcd, PSTR("cycles"),  5, e - s, false);
-
-        s = HW_REG(_DWT_CYCCNT); DELAY_CYCLES(10); e = HW_REG(_DWT_CYCCNT);
-        report_call_time(dcd, PSTR("cycles"), 10, e - s, false);
-
-        s = HW_REG(_DWT_CYCCNT); DELAY_CYCLES(20); e = HW_REG(_DWT_CYCCNT);
-        report_call_time(dcd, PSTR("cycles"), 20, e - s, false);
-
-        s = HW_REG(_DWT_CYCCNT); DELAY_CYCLES(50); e = HW_REG(_DWT_CYCCNT);
-        report_call_time(dcd, PSTR("cycles"), 50, e - s, false);
-
-        s = HW_REG(_DWT_CYCCNT); DELAY_CYCLES(100); e = HW_REG(_DWT_CYCCNT);
-        report_call_time(dcd, PSTR("cycles"), 100, e - s, false);
-
-        s = HW_REG(_DWT_CYCCNT); DELAY_CYCLES(200); e = HW_REG(_DWT_CYCCNT);
-        report_call_time(dcd, PSTR("cycles"), 200, e - s, false);
-      }
-    }
-  #endif // MARLIN_DEV_MODE
-
-
-#else
-
-  void calibrate_delay_loop() {}
-  #if ENABLED(MARLIN_DEV_MODE)
-    void dump_delay_accuracy_check() { SERIAL_ECHOPGM_P(PSTR("N/A on this platform")); }
-  #endif
-
-#endif
@@ -21,8 +21,6 @@
 */
 #pragma once

-#include "../../inc/MarlinConfigPre.h"
-
 /**
 * Busy wait delay cycles routines:
 *
@@ -33,68 +31,79 @@

 #include "../../core/macros.h"

-void calibrate_delay_loop();
-
 #if defined(__arm__) || defined(__thumb__)

-  // We want to have delay_cycle function with the lowest possible overhead, so we adjust at the function at runtime based on the current CPU best feature
-  typedef void (*DelayImpl)(uint32_t);
-  extern DelayImpl DelayCycleFnc;
+  #if __CORTEX_M == 7

-  // I've measured 36 cycles on my system to call the cycle waiting method, but it shouldn't change much to have a bit more margin, it only consume a bit more flash
-  #define TRIP_POINT_FOR_CALLING_FUNCTION   40
+    // Cortex-M3 through M7 can use the cycle counter of the DWT unit
+    // https://www.anthonyvh.com/2017/05/18/cortex_m-cycle_counter/

-  // A simple recursive template class that output exactly one 'nop' of code per recursion
-  template <int N> struct NopWriter {
-    FORCE_INLINE static void build() {
-      __asm__ __volatile__("nop");
-      NopWriter<N-1>::build();
+    FORCE_INLINE static void enableCycleCounter() {
+      CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;
+
+      #if __CORTEX_M == 7
+        DWT->LAR = 0xC5ACCE55; // Unlock DWT on the M7
+      #endif
+
+      DWT->CYCCNT = 0;
+      DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;
    }
-  };
-  // End the loop
-  template <> struct NopWriter<0> { FORCE_INLINE static void build() {} };

-  namespace Private {
-    // Split recursing template in 2 different class so we don't reach the maximum template instantiation depth limit
-    template <bool belowTP, int N> struct Helper {
-      FORCE_INLINE static void build() {
-        DelayCycleFnc(N - 2); //  Approximative cost of calling the function (might be off by one or 2 cycles)
-      }
-    };
+    FORCE_INLINE volatile uint32_t getCycleCount() { return DWT->CYCCNT; }

-    template <int N> struct Helper<true, N> {
-      FORCE_INLINE static void build() {
-        NopWriter<N - 1>::build();
-      }
-    };
-
-    template <> struct Helper<true, 0> {
-      FORCE_INLINE static void build() {}
-    };
-
-  }
-  // Select a behavior based on the constexpr'ness of the parameter
-  // If called with a compile-time parameter, then write as many NOP as required to reach the asked cycle count
-  // (there is some tripping point here to start looping when it's more profitable than gruntly executing NOPs)
-  // If not called from a compile-time parameter, fallback to a runtime loop counting version instead
-  template <bool compileTime, int Cycles>
-  struct SmartDelay {
-    FORCE_INLINE SmartDelay(int) {
-      if (Cycles == 0) return;
-      Private::Helper<Cycles < TRIP_POINT_FOR_CALLING_FUNCTION, Cycles>::build();
+    FORCE_INLINE static void DELAY_CYCLES(const uint32_t x) {
+      const uint32_t endCycles = getCycleCount() + x;
+      while (PENDING(getCycleCount(), endCycles)) {}
    }
-  };
-  // Runtime version below. There is no way this would run under less than ~TRIP_POINT_FOR_CALLING_FUNCTION cycles
-  template <int T>
-  struct SmartDelay<false, T> {
-    FORCE_INLINE SmartDelay(int v) { DelayCycleFnc(v); }
-  };

-  #define DELAY_CYCLES(X) do { SmartDelay<IS_CONSTEXPR(X), IS_CONSTEXPR(X) ? X : 0> _smrtdly_X(X); } while(0)
+  #else

-  // For delay in microseconds, no smart delay selection is required, directly call the delay function
-  // Teensy compiler is too old and does not accept smart delay compile-time / run-time selection correctly
-  #define DELAY_US(x) DelayCycleFnc((x) * ((F_CPU) / 1000000UL))
+    // https://blueprints.launchpad.net/gcc-arm-embedded/+spec/delay-cycles
+
+    #define nop() __asm__ __volatile__("nop;\n\t":::)
+
+    FORCE_INLINE static void __delay_4cycles(uint32_t cy) { // +1 cycle
+      #if ARCH_PIPELINE_RELOAD_CYCLES < 2
+        #define EXTRA_NOP_CYCLES A("nop")
+      #else
+        #define EXTRA_NOP_CYCLES ""
+      #endif
+
+      __asm__ __volatile__(
+        A(".syntax unified") // is to prevent CM0,CM1 non-unified syntax
+        L("1")
+        A("subs %[cnt],#1")
+        EXTRA_NOP_CYCLES
+        A("bne 1b")
+        : [cnt]"+r"(cy)   // output: +r means input+output
+        :                 // input:
+        : "cc"            // clobbers:
+      );
+    }
+
+    // Delay in cycles
+    FORCE_INLINE static void DELAY_CYCLES(uint32_t x) {
+
+      if (__builtin_constant_p(x)) {
+        #define MAXNOPS 4
+
+        if (x <= (MAXNOPS)) {
+          switch (x) { case 4: nop(); case 3: nop(); case 2: nop(); case 1: nop(); }
+        }
+        else { // because of +1 cycle inside delay_4cycles
+          const uint32_t rem = (x - 1) % (MAXNOPS);
+          switch (rem) { case 3: nop(); case 2: nop(); case 1: nop(); }
+          if ((x = (x - 1) / (MAXNOPS)))
+            __delay_4cycles(x); // if need more then 4 nop loop is more optimal
+        }
+        #undef MAXNOPS
+      }
+      else if ((x >>= 2))
+        __delay_4cycles(x);
+    }
+    #undef nop
+
+  #endif

 #elif defined(__AVR__)

@@ -135,15 +144,10 @@ void calibrate_delay_loop();
  }
  #undef nop

-  // Delay in microseconds
-  #define DELAY_US(x) DELAY_CYCLES((x) * ((F_CPU) / 1000000UL))
-
 #elif defined(__PLAT_LINUX__) || defined(ESP32)

-  // DELAY_CYCLES specified inside platform
+  // specified inside platform

-  // Delay in microseconds
-  #define DELAY_US(x) DELAY_CYCLES((x) * ((F_CPU) / 1000000UL))
 #else

  #error "Unsupported MCU architecture"
@@ -153,5 +157,5 @@ void calibrate_delay_loop();
 // Delay in nanoseconds
 #define DELAY_NS(x) DELAY_CYCLES((x) * ((F_CPU) / 1000000UL) / 1000UL)

-
-
+// Delay in microseconds
+#define DELAY_US(x) DELAY_CYCLES((x) * ((F_CPU) / 1000000UL))
@@ -1,33 +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/>.
- *
- */
-#include "HAL_MinSerial.h"
-
-#if ENABLED(POSTMORTEM_DEBUGGING)
-
-void HAL_min_serial_init_default() {}
-void HAL_min_serial_out_default(char ch) { SERIAL_CHAR(ch); }
-void (*HAL_min_serial_init)() = &HAL_min_serial_init_default;
-void (*HAL_min_serial_out)(char) = &HAL_min_serial_out_default;
-
-bool MinSerial::force_using_default_output = false;
-
-#endif
@@ -1,79 +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 "../../core/serial.h"
-#include <stdint.h>
-
-// Serial stuff here
-// Inside an exception handler, the CPU state is not safe, we can't expect the handler to resume
-// and the software to continue. UART communication can't rely on later callback/interrupt as it might never happen.
-// So, you need to provide some method to send one byte to the usual UART with the interrupts disabled
-// By default, the method uses SERIAL_CHAR but it's 100% guaranteed to break (couldn't be worse than nothing...)7
-extern void (*HAL_min_serial_init)();
-extern void (*HAL_min_serial_out)(char ch);
-
-struct MinSerial {
-  static bool force_using_default_output;
-  // Serial output
-  static void TX(char ch) {
-    if (force_using_default_output)
-      SERIAL_CHAR(ch);
-    else
-      HAL_min_serial_out(ch);
-  }
-  // Send String through UART
-  static void TX(const char* s) { while (*s) TX(*s++); }
-  // Send a digit through UART
-  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 through 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 through 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]);
-  }
-  static void init() { if (!force_using_default_output) HAL_min_serial_init(); }
-};
@@ -81,5 +81,3 @@
 #ifndef UNUSED
  #define UNUSED(x) ((void)(x))
 #endif
-
-#include "progmem.h"
@@ -25,7 +25,7 @@
 #include "unwinder.h"
 #include "unwmemaccess.h"

-#include "../HAL_MinSerial.h"
+#include "../../../core/serial.h"
 #include <stdarg.h>

 // Dump a backtrace entry
@@ -34,12 +34,10 @@ static bool UnwReportOut(void* ctx, const UnwReport* bte) {

  (*p)++;

-  const uint32_t a = bte->address, f = bte->function;
-  MinSerial::TX('#');    MinSerial::TXDec(*p);    MinSerial::TX(" : ");
-  MinSerial::TX(bte->name?:"unknown");            MinSerial::TX('@');   MinSerial::TXHex(f);
-  MinSerial::TX('+');    MinSerial::TXDec(a - f);
-  MinSerial::TX(" PC:"); MinSerial::TXHex(a);
-  MinSerial::TX('\n');
+  SERIAL_CHAR('#'); SERIAL_PRINT(*p, DEC); SERIAL_ECHOPGM(" : ");
+  SERIAL_ECHOPGM(bte->name ? bte->name : "unknown"); SERIAL_ECHOPGM("@0x"); SERIAL_PRINT(bte->function, HEX);
+  SERIAL_CHAR('+'); SERIAL_PRINT(bte->address - bte->function,DEC);
+  SERIAL_ECHOPGM(" PC:"); SERIAL_PRINT(bte->address,HEX); SERIAL_CHAR('\n');
  return true;
 }

@@ -50,7 +48,7 @@ static bool UnwReportOut(void* ctx, const UnwReport* bte) {
    va_start(argptr, format);
    vsprintf(dest, format, argptr);
    va_end(argptr);
-    MinSerial::TX(&dest[0]);
+    TX(&dest[0]);
  }
 #endif

@@ -65,10 +63,10 @@ static const UnwindCallbacks UnwCallbacks = {
  #endif
 };

-// Perform a backtrace to the serial port
 void backtrace() {

-  unsigned long sp = 0, lr = 0, pc = 0;
+  UnwindFrame btf;
+  uint32_t sp = 0, lr = 0, pc = 0;

  // Capture the values of the registers to perform the traceback
  __asm__ __volatile__ (
@@ -81,12 +79,6 @@ void backtrace() {
    ::
  );

-  backtrace_ex(sp, lr, pc);
-}
-
-void backtrace_ex(unsigned long sp, unsigned long lr, unsigned long pc) {
-  UnwindFrame btf;
-
  // Fill the traceback structure
  btf.sp = sp;
  btf.fp = btf.sp;
@@ -94,7 +86,7 @@ void backtrace_ex(unsigned long sp, unsigned long lr, unsigned long pc) {
  btf.pc = pc | 1; // Force Thumb, as CORTEX only support it

  // Perform a backtrace
-  MinSerial::TX("Backtrace:");
+  SERIAL_ERROR_MSG("Backtrace:");
  int ctr = 0;
  UnwindStart(&btf, &UnwCallbacks, &ctr);
 }
@@ -103,4 +95,4 @@ void backtrace_ex(unsigned long sp, unsigned long lr, unsigned long pc) {

 void backtrace() {}

-#endif // __arm__ || __thumb__
+#endif
@@ -23,6 +23,3 @@

 // Perform a backtrace to the serial port
 void backtrace();
-
-// Perform a backtrace to the serial port
-void backtrace_ex(unsigned long sp, unsigned long lr, unsigned long pc);
@@ -41,16 +41,27 @@
  #define START_FLASH_ADDR  0x00000000
  #define END_FLASH_ADDR    0x00080000

+#elif 0
+
+  // For STM32F103CBT6
+  //  SRAM  (0x20000000 - 0x20005000) (20kb)
+  //  FLASH (0x00000000 - 0x00020000) (128kb)
+  //
+  #define START_SRAM_ADDR   0x20000000
+  #define END_SRAM_ADDR     0x20005000
+  #define START_FLASH_ADDR  0x00000000
+  #define END_FLASH_ADDR    0x00020000
+
 #elif defined(__STM32F1__) || defined(STM32F1xx) || defined(STM32F0xx)

  // For STM32F103ZET6/STM32F103VET6/STM32F0xx
  //  SRAM  (0x20000000 - 0x20010000) (64kb)
-  //  FLASH (0x08000000 - 0x08080000) (512kb)
+  //  FLASH (0x00000000 - 0x00080000) (512kb)
  //
  #define START_SRAM_ADDR   0x20000000
  #define END_SRAM_ADDR     0x20010000
-  #define START_FLASH_ADDR  0x08000000
-  #define END_FLASH_ADDR    0x08080000
+  #define START_FLASH_ADDR  0x00000000
+  #define END_FLASH_ADDR    0x00080000

 #elif defined(STM32F4) || defined(STM32F4xx)

@@ -131,57 +142,20 @@
  #define START_FLASH_ADDR  0x00000000
  #define END_FLASH_ADDR    0x00100000

-#else
-  // Generic ARM code, that's testing if an access to the given address would cause a fault or not
-  // It can't guarantee an address is in RAM or Flash only, but we usually don't care
-
-  #define NVIC_FAULT_STAT         0xE000ED28  // Configurable Fault Status Reg.
-  #define NVIC_CFG_CTRL           0xE000ED14  // Configuration Control Register
-  #define NVIC_FAULT_STAT_BFARV   0x00008000  // BFAR is valid
-  #define NVIC_CFG_CTRL_BFHFNMIGN 0x00000100  // Ignore bus fault in NMI/fault
-  #define HW_REG(X)  (*((volatile unsigned long *)(X)))
-
-  static bool validate_addr(uint32_t read_address) {
-    bool     works = true;
-    uint32_t intDisabled = 0;
-    // Read current interrupt state
-    __asm__ __volatile__ ("MRS %[result], PRIMASK\n\t" : [result]"=r"(intDisabled) :: ); // 0 is int enabled, 1 for disabled
-
-    // Clear bus fault indicator first (write 1 to clear)
-    HW_REG(NVIC_FAULT_STAT) |= NVIC_FAULT_STAT_BFARV;
-    // Ignore bus fault interrupt
-    HW_REG(NVIC_CFG_CTRL) |= NVIC_CFG_CTRL_BFHFNMIGN;
-    // Disable interrupts if not disabled previously
-    if (!intDisabled) __asm__ __volatile__ ("CPSID f");
-    // Probe address
-    *(volatile uint32_t*)read_address;
-    // Check if a fault happened
-    if ((HW_REG(NVIC_FAULT_STAT) & NVIC_FAULT_STAT_BFARV) != 0)
-      works = false;
-    // Enable interrupts again if previously disabled
-    if (!intDisabled) __asm__ __volatile__ ("CPSIE f");
-    // Enable fault interrupt flag
-    HW_REG(NVIC_CFG_CTRL) &= ~NVIC_CFG_CTRL_BFHFNMIGN;
-
-    return works;
-  }
-
 #endif

-#ifdef START_SRAM_ADDR
-  static bool validate_addr(uint32_t addr) {
+static bool validate_addr(uint32_t addr) {

-    // Address must be in SRAM range
-    if (addr >= START_SRAM_ADDR && addr < END_SRAM_ADDR)
-      return true;
+  // Address must be in SRAM range
+  if (addr >= START_SRAM_ADDR && addr < END_SRAM_ADDR)
+    return true;

-    // Or in FLASH range
-    if (addr >= START_FLASH_ADDR && addr < END_FLASH_ADDR)
-      return true;
+  // Or in FLASH range
+  if (addr >= START_FLASH_ADDR && addr < END_FLASH_ADDR)
+    return true;

-    return false;
-  }
-#endif
+  return false;
+}

 bool UnwReadW(const uint32_t a, uint32_t *v) {
  if (!validate_addr(a))
@@ -1,379 +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) 2020 Cyril Russo
- *
- * 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/>.
- *
- */
-
-/***************************************************************************
- * ARM CPU Exception handler
- ***************************************************************************/
-
-#if defined(__arm__) || defined(__thumb__)
-
-
-/*
-  On ARM CPUs exception handling is quite powerful.
-
-  By default, upon a crash, the CPU enters the handlers that have a higher priority than any other interrupts,
-  so, in effect, no (real) interrupt can "interrupt" the handler (it's acting like if interrupts were disabled).
-
-  If the handler is not called as re-entrant (that is, if the crash is not happening inside an interrupt or an handler),
-  then it'll patch the return address to a dumping function (resume_from_fault) and save the crash state.
-  The CPU will exit the handler and, as such, re-allow the other interrupts, and jump to the dumping function.
-  In this function, the usual serial port (USB / HW) will be used to dump the crash (no special configuration required).
-
-  The only case where it requires hardware UART is when it's crashing in an interrupt or a crash handler.
-  In that case, instead of returning to the resume_from_fault function (and thus, re-enabling interrupts),
-  it jumps to this function directly (so with interrupts disabled), after changing the behavior of the serial output
-  wrapper to use the HW uart (and in effect, calling MinSerial::init which triggers a warning if you are using
-  a USB serial port).
-
-  In the case you have a USB serial port, this part will be disabled, and only that part (so that's the reason for
-  the warning).
-  This means that you can't have a crash report if the crash happens in an interrupt or an handler if you are using
-  a USB serial port since it's physically impossible.
-  You will get a crash report in all other cases.
-*/
-
-#include "exception_hook.h"
-#include "../backtrace/backtrace.h"
-#include "../HAL_MinSerial.h"
-
-#define HW_REG(X)  (*((volatile unsigned long *)(X)))
-
-// Default function use the CPU VTOR register to get the vector table.
-// Accessing the CPU VTOR register is done in assembly since it's the only way that's common to all current tool
-unsigned long get_vtor() { return HW_REG(0xE000ED08); } // Even if it looks like an error, it is not an error
-void * hook_get_hardfault_vector_address(unsigned vtor)  { return (void*)(vtor + 0x03); }
-void * hook_get_memfault_vector_address(unsigned vtor)   { return (void*)(vtor + 0x04); }
-void * hook_get_busfault_vector_address(unsigned vtor)   { return (void*)(vtor + 0x05); }
-void * hook_get_usagefault_vector_address(unsigned vtor) { return (void*)(vtor + 0x06); }
-void * hook_get_reserved_vector_address(unsigned vtor)   { return (void*)(vtor + 0x07); }
-
-// Common exception frame for ARM, should work for all ARM CPU
-// Described here (modified for convenience): https://interrupt.memfault.com/blog/cortex-m-fault-debug
-struct __attribute__((packed)) ContextStateFrame {
-  uint32_t r0;
-  uint32_t r1;
-  uint32_t r2;
-  uint32_t r3;
-  uint32_t r12;
-  uint32_t lr;
-  uint32_t pc;
-  uint32_t xpsr;
-};
-
-struct __attribute__((packed)) ContextSavedFrame {
-  uint32_t R0;
-  uint32_t R1;
-  uint32_t R2;
-  uint32_t R3;
-  uint32_t R12;
-  uint32_t LR;
-  uint32_t PC;
-  uint32_t XPSR;
-
-  uint32_t CFSR;
-  uint32_t HFSR;
-  uint32_t DFSR;
-  uint32_t AFSR;
-  uint32_t MMAR;
-  uint32_t BFAR;
-
-  uint32_t ESP;
-  uint32_t ELR;
-};
-
-#if DISABLED(STM32F0xx)
-  extern "C"
-  __attribute__((naked)) void CommonHandler_ASM() {
-    __asm__ __volatile__ (
-      // Bit 2 of LR tells which stack pointer to use (either main or process, only main should be used anyway)
-      "tst lr, #4\n"
-      "ite eq\n"
-      "mrseq r0, msp\n"
-      "mrsne r0, psp\n"
-      // Save the LR in use when being interrupted
-      "mov r1, lr\n"
-      // Get the exception number from the ICSR register
-      "ldr r2, =0xE000ED00\n"
-      "ldr r2, [r2, #4]\n"
-      "b CommonHandler_C\n"
-    );
-  }
-#else // Cortex M0 does not support conditional mov and testing with a constant, so let's have a specific handler for it
-  extern "C"
-  __attribute__((naked)) void CommonHandler_ASM() {
-    __asm__ __volatile__ (
-      ".syntax unified\n"
-      // Save the LR in use when being interrupted
-      "mov  r1, lr\n"
-      // Get the exception number from the ICSR register
-      "ldr  r2, =0xE000ED00\n"
-      "ldr  r2, [r2, #4]\n"
-      "movs r0, #4\n"
-      "tst  r1, r0\n"
-      "beq _MSP\n"
-      "mrs  r0, psp\n"
-      "b CommonHandler_C\n"
-      "_MSP:\n"
-      "mrs  r0, msp\n"
-      "b CommonHandler_C\n"
-    );
-  }
-
-  #if DISABLED(DYNAMIC_VECTORTABLE) // Cortex M0 requires the handler's address to be within 32kB to the actual function to be able to branch to it
-    extern "C" {
-      void __attribute__((naked, alias("CommonHandler_ASM"), nothrow)) __exc_hardfault();
-      void __attribute__((naked, alias("CommonHandler_ASM"), nothrow)) __exc_busfault();
-      void __attribute__((naked, alias("CommonHandler_ASM"), nothrow)) __exc_usagefault();
-      void __attribute__((naked, alias("CommonHandler_ASM"), nothrow)) __exc_memmanage();
-      void __attribute__((naked, alias("CommonHandler_ASM"), nothrow)) __exc_nmi();
-      void __attribute__((naked, alias("CommonHandler_ASM"), nothrow)) __stm32reservedexception7();
-      void __attribute__((naked, alias("CommonHandler_ASM"), nothrow)) __stm32reservedexception8();
-      void __attribute__((naked, alias("CommonHandler_ASM"), nothrow)) __stm32reservedexception9();
-      void __attribute__((naked, alias("CommonHandler_ASM"), nothrow)) __stm32reservedexception10();
-      void __attribute__((naked, alias("CommonHandler_ASM"), nothrow)) __stm32reservedexception13();
-    }
-    //TODO When going off from libmaple, you'll need to replace those by the one from STM32/HAL_MinSerial.cpp
-  #endif
-#endif
-
-// Must be a macro to avoid creating a function frame
-#define HALT_IF_DEBUGGING()             \
-  do {                                  \
-    if (HW_REG(0xE000EDF0) & _BV(0)) {  \
-      __asm("bkpt 1");                  \
-    }                                   \
-} while (0)
-
-// Resume from a fault (if possible) so we can still use interrupt based code for serial output
-// In that case, we will not jump back to the faulty code, but instead to a dumping code and then a
-// basic loop with watchdog calling or manual resetting
-static ContextSavedFrame savedFrame;
-static uint8_t           lastCause;
-bool resume_from_fault() {
-  static const char* causestr[] = { "Thread", "Rsvd", "NMI", "Hard", "Mem", "Bus", "Usage", "7", "8", "9", "10", "SVC", "Dbg", "13", "PendSV", "SysTk", "IRQ" };
-  // Reinit the serial link (might only work if implemented in each of your boards)
-  MinSerial::init();
-
-  MinSerial::TX("\n\n## Software Fault detected ##\n");
-  MinSerial::TX("Cause: "); MinSerial::TX(causestr[min(lastCause, (uint8_t)16)]); MinSerial::TX('\n');
-
-  MinSerial::TX("R0   : "); MinSerial::TXHex(savedFrame.R0);   MinSerial::TX('\n');
-  MinSerial::TX("R1   : "); MinSerial::TXHex(savedFrame.R1);   MinSerial::TX('\n');
-  MinSerial::TX("R2   : "); MinSerial::TXHex(savedFrame.R2);   MinSerial::TX('\n');
-  MinSerial::TX("R3   : "); MinSerial::TXHex(savedFrame.R3);   MinSerial::TX('\n');
-  MinSerial::TX("R12  : "); MinSerial::TXHex(savedFrame.R12);  MinSerial::TX('\n');
-  MinSerial::TX("LR   : "); MinSerial::TXHex(savedFrame.LR);   MinSerial::TX('\n');
-  MinSerial::TX("PC   : "); MinSerial::TXHex(savedFrame.PC);   MinSerial::TX('\n');
-  MinSerial::TX("PSR  : "); MinSerial::TXHex(savedFrame.XPSR); MinSerial::TX('\n');
-
-  // Configurable Fault Status Register
-  // Consists of MMSR, BFSR and UFSR
-  MinSerial::TX("CFSR : "); MinSerial::TXHex(savedFrame.CFSR); MinSerial::TX('\n');
-
-  // Hard Fault Status Register
-  MinSerial::TX("HFSR : "); MinSerial::TXHex(savedFrame.HFSR); MinSerial::TX('\n');
-
-  // Debug Fault Status Register
-  MinSerial::TX("DFSR : "); MinSerial::TXHex(savedFrame.DFSR); MinSerial::TX('\n');
-
-  // Auxiliary Fault Status Register
-  MinSerial::TX("AFSR : "); MinSerial::TXHex(savedFrame.AFSR); MinSerial::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
-  MinSerial::TX("MMAR : "); MinSerial::TXHex(savedFrame.MMAR); MinSerial::TX('\n');
-
-  // Bus Fault Address Register
-  MinSerial::TX("BFAR : "); MinSerial::TXHex(savedFrame.BFAR); MinSerial::TX('\n');
-
-  MinSerial::TX("ExcLR: "); MinSerial::TXHex(savedFrame.ELR); MinSerial::TX('\n');
-  MinSerial::TX("ExcSP: "); MinSerial::TXHex(savedFrame.ESP); MinSerial::TX('\n');
-
-  // The stack pointer is pushed by 8 words upon entering an exception, so we need to revert this
-  backtrace_ex(savedFrame.ESP + 8*4, savedFrame.LR, savedFrame.PC);
-
-  // Call the last resort function here
-  hook_last_resort_func();
-
-  const uint32_t start = millis(), end = start + 100; // 100ms should be enough
-  // We need to wait for the serial buffers to be output but we don't know for how long
-  // So we'll just need to refresh the watchdog for a while and then stop for the system to reboot
-  uint32_t last = start;
-  while (PENDING(last, end)) {
-    watchdog_refresh();
-    while (millis() == last) { /* nada */ }
-    last = millis();
-    MinSerial::TX('.');
-  }
-
-  // Reset now by reinstantiating the bootloader's vector table
-  HW_REG(0xE000ED08) = 0;
-  // Restart watchdog
-  #if DISABLED(USE_WATCHDOG)
-    // No watchdog, let's perform ARMv7 reset instead by writing to AIRCR register with VECTKEY set to SYSRESETREQ
-    HW_REG(0xE000ED0C) = (HW_REG(0xE000ED0C) & 0x0000FFFF) | 0x05FA0004;
-  #endif
-
-  while(1) {} // Bad luck, nothing worked
-}
-
-// Make sure the compiler does not optimize the frame argument away
-extern "C"
-__attribute__((optimize("O0")))
-void CommonHandler_C(ContextStateFrame * frame, unsigned long lr, unsigned long cause) {
-
-  // If you are using it'll stop here
-  HALT_IF_DEBUGGING();
-
-  // Save the state to backtrace later on (don't call memcpy here since the stack can be corrupted)
-  savedFrame.R0  = frame->r0;
-  savedFrame.R1  = frame->r1;
-  savedFrame.R2  = frame->r2;
-  savedFrame.R3  = frame->r3;
-  savedFrame.R12 = frame->r12;
-  savedFrame.LR  = frame->lr;
-  savedFrame.PC  = frame->pc;
-  savedFrame.XPSR= frame->xpsr;
-  lastCause = cause & 0x1FF;
-
-  volatile uint32_t &CFSR = HW_REG(0xE000ED28);
-  savedFrame.CFSR = CFSR;
-  savedFrame.HFSR = HW_REG(0xE000ED2C);
-  savedFrame.DFSR = HW_REG(0xE000ED30);
-  savedFrame.AFSR = HW_REG(0xE000ED3C);
-  savedFrame.MMAR = HW_REG(0xE000ED34);
-  savedFrame.BFAR = HW_REG(0xE000ED38);
-  savedFrame.ESP  = (unsigned long)frame; // Even on return, this should not be overwritten by the CPU
-  savedFrame.ELR  = lr;
-
-  // First check if we can resume from this exception to our own handler safely
-  // If we can, then we don't need to disable interrupts and the usual serial code
-  // can be used
-
-  //const uint32_t non_usage_fault_mask = 0x0000FFFF;
-  //const bool non_usage_fault_occurred = (CFSR & non_usage_fault_mask) != 0;
-  // the bottom 8 bits of the xpsr hold the exception number of the
-  // executing exception or 0 if the processor is in Thread mode
-  const bool faulted_from_exception = ((frame->xpsr & 0xFF) != 0);
-  if (!faulted_from_exception) { // Not sure about the non_usage_fault, we want to try anyway, don't we ? && !non_usage_fault_occurred)
-    // Try to resume to our handler here
-    CFSR |= CFSR; // The ARM programmer manual says you must write to 1 all fault bits to clear them so this instruction is correct
-    // The frame will not be valid when returning anymore, let's clean it
-    savedFrame.CFSR = 0;
-
-    frame->pc = (uint32_t)resume_from_fault; // Patch where to return to
-    frame->lr = 0xDEADBEEF;  // If our handler returns (it shouldn't), let's make it trigger an exception immediately
-    frame->xpsr = _BV(24);   // Need to clean the PSR register to thumb II only
-    MinSerial::force_using_default_output = true;
-    return; // The CPU will resume in our handler hopefully, and we'll try to use default serial output
-  }
-
-  // Sorry, we need to emergency code here since the fault is too dangerous to recover from
-  MinSerial::force_using_default_output = false;
-  resume_from_fault();
-}
-
-void hook_cpu_exceptions() {
-  #if ENABLED(DYNAMIC_VECTORTABLE)
-    // On ARM 32bits CPU, the vector table is like this:
-    // 0x0C => Hardfault
-    // 0x10 => MemFault
-    // 0x14 => BusFault
-    // 0x18 => UsageFault
-
-    // Unfortunately, it's usually run from flash, and we can't write to flash here directly to hook our instruction
-    // We could set an hardware breakpoint, and hook on the fly when it's being called, but this
-    // is hard to get right and would probably break debugger when attached
-
-    // So instead, we'll allocate a new vector table filled with the previous value except
-    // for the fault we are interested in.
-    // Now, comes the issue to figure out what is the current vector table size
-    // There is nothing telling us what is the vector table as it's per-cpu vendor specific.
-    // BUT: we are being called at the end of the setup, so we assume the setup is done
-    // Thus, we can read the current vector table until we find an address that's not in flash, and it would mark the
-    // end of the vector table (skipping the fist entry obviously)
-    // The position of the program in flash is expected to be at 0x08xxx xxxx on all known platform for ARM and the
-    // flash size is available via register 0x1FFFF7E0 on STM32 family, but it's not the case for all ARM boards
-    // (accessing this register might trigger a fault if it's not implemented).
-
-    // So we'll simply mask the top 8 bits of the first handler as an hint of being in the flash or not -that's poor and will
-    // probably break if the flash happens to be more than 128MB, but in this case, we are not magician, we need help from outside.
-
-    unsigned long * vecAddr = (unsigned long*)get_vtor();
-    SERIAL_ECHO("Vector table addr: ");
-    SERIAL_PRINTLN(get_vtor(), HEX);
-
-    #ifdef VECTOR_TABLE_SIZE
-      uint32_t vec_size = VECTOR_TABLE_SIZE;
-      alignas(128) static unsigned long vectable[VECTOR_TABLE_SIZE] ;
-    #else
-      #ifndef IS_IN_FLASH
-        #define IS_IN_FLASH(X) (((unsigned long)X & 0xFF000000) == 0x08000000)
-      #endif
-
-      // When searching for the end of the vector table, this acts as a limit not to overcome
-      #ifndef VECTOR_TABLE_SENTINEL
-        #define VECTOR_TABLE_SENTINEL 80
-      #endif
-
-      // Find the vector table size
-      uint32_t vec_size = 1;
-      while (IS_IN_FLASH(vecAddr[vec_size]) && vec_size < VECTOR_TABLE_SENTINEL)
-        vec_size++;
-
-      // We failed to find a valid vector table size, let's abort hooking up
-      if (vec_size == VECTOR_TABLE_SENTINEL) return;
-      // Poor method that's wasting RAM here, but allocating with malloc and alignment would be worst
-      // 128 bytes alignement is required for writing the VTOR register
-      alignas(128) static unsigned long vectable[VECTOR_TABLE_SENTINEL];
-
-      SERIAL_ECHO("Detected vector table size: ");
-      SERIAL_PRINTLN(vec_size, HEX);
-    #endif
-
-    uint32_t defaultFaultHandler = vecAddr[(unsigned)7];
-    // Copy the current vector table into the new table
-    for (uint32_t i = 0; i < vec_size; i++) {
-      vectable[i] = vecAddr[i];
-      // Replace all default handler by our own handler
-      if (vectable[i] == defaultFaultHandler)
-        vectable[i] = (unsigned long)&CommonHandler_ASM;
-    }
-
-    // Let's hook now with our functions
-    vectable[(unsigned long)hook_get_hardfault_vector_address(0)]  = (unsigned long)&CommonHandler_ASM;
-    vectable[(unsigned long)hook_get_memfault_vector_address(0)]   = (unsigned long)&CommonHandler_ASM;
-    vectable[(unsigned long)hook_get_busfault_vector_address(0)]   = (unsigned long)&CommonHandler_ASM;
-    vectable[(unsigned long)hook_get_usagefault_vector_address(0)] = (unsigned long)&CommonHandler_ASM;
-
-    // Finally swap with our own vector table
-    // This is supposed to be atomic, but let's do that with interrupt disabled
-
-    HW_REG(0xE000ED08) = (unsigned long)vectable | _BV32(29); // 29th bit is for telling the CPU the table is now in SRAM (should be present already)
-
-    SERIAL_ECHOLN("Installed fault handlers");
-  #endif
-}
-
-#endif // __arm__ || __thumb__
@@ -1,28 +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/>.
- *
- */
-#include "exception_hook.h"
-
-void * __attribute__((weak)) hook_get_hardfault_vector_address(unsigned) { return 0; }
-void * __attribute__((weak)) hook_get_memfault_vector_address(unsigned) { return 0; }
-void * __attribute__((weak)) hook_get_busfault_vector_address(unsigned) { return 0; }
-void * __attribute__((weak)) hook_get_usagefault_vector_address(unsigned) { return 0; }
-void __attribute__((weak)) hook_last_resort_func() {}
@@ -1,54 +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
-
-/* Here is the expected behavior of a system producing a CPU exception with this hook installed:
-   1. Before the system is crashed
-     1.1 Upon validation (not done yet in this code, but we could be using DEBUG flags here to allow/disallow hooking)
-     1.2 Install the hook by overwriting the vector table exception handler with the hooked function
-   2. Upon system crash (for example, by a dereference of a NULL pointer or anything else)
-     2.1 The CPU triggers its exception and jump into the vector table for the exception type
-     2.2 Instead of finding the default handler, it finds the updated pointer to our hook
-     2.3 The CPU jumps into our hook function (likely a naked function to keep all information about crash point intact)
-     2.4 The hook (naked) function saves the important registers (stack pointer, program counter, current mode) and jumps to a common exception handler (in C)
-     2.5 The common exception handler dumps the registers on the serial link and perform a backtrace around the crashing point
-     2.6 Once the backtrace is performed the last resort function is called (platform specific).
-         On some platform with a LCD screen, this might display the crash information as a QR code or as text for the
-         user to capture by taking a picture
-     2.7 The CPU is reset and/or halted by triggering a debug breakpoint if a debugger is attached */
-
-// Hook into CPU exception interrupt table to call the backtracing code upon an exception
-// Most platform will simply do nothing here, but those who can will install/overwrite the default exception handler
-// with a more performant exception handler
-void hook_cpu_exceptions();
-
-// Some platform might deal without a hard fault handler, in that case, return 0 in your platform here or skip implementing it
-void * __attribute__((weak)) hook_get_hardfault_vector_address(unsigned base_address);
-// Some platform might deal without a memory management fault handler, in that case, return 0 in your platform here or skip implementing it
-void * __attribute__((weak)) hook_get_memfault_vector_address(unsigned base_address);
-// Some platform might deal without a bus fault handler, in that case, return 0 in your platform here or skip implementing it
-void * __attribute__((weak)) hook_get_busfault_vector_address(unsigned base_address);
-// Some platform might deal without a usage fault handler, in that case, return 0 in your platform here or skip implementing it
-void * __attribute__((weak)) hook_get_usagefault_vector_address(unsigned base_address);
-
-// Last resort function that can be called after the exception handler was called.
-void __attribute__((weak)) hook_last_resort_func();
@@ -25,5 +25,5 @@
 // EEPROM
 //
 void eeprom_init();
-void eeprom_write_byte(uint8_t *pos, uint8_t value);
+void eeprom_write_byte(uint8_t *pos, unsigned char value);
 uint8_t eeprom_read_byte(uint8_t *pos);
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
InsanityAutomation	aac6724398	Update pins_GMARSH_EBAB.h	2021-01-23 11:48:02 -05:00
InsanityAutomation	8bab8954c4	Put in or for spi pins on 208 package	2021-01-19 14:31:52 -05:00
InsanityAutomation	9bdc1187d0	Initial Commit	2021-01-19 14:31:44 -05:00