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
1775 changed files with 40297 additions and 85894 deletions
@@ -4,10 +4,10 @@ root = true
 [{*.patch,syntax_test_*}]
 trim_trailing_whitespace = false

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

-[{*.c,*.cpp,*.h,*.ino,Makefile}]
+[{*.c,*.cpp,*.h,Makefile}]
 trim_trailing_whitespace = true
 insert_final_newline = true
 end_of_line = lf
@@ -1,43 +0,0 @@
---
-name: Bug report
-about: Report a bug in Marlin
-title: "[BUG] (short description)"
-labels: ''
-assignees: ''
-
---
-
-<!--
-
-Have you read Marlin's Code of Conduct? By filing an Issue, you are expected to comply with it, including treating everyone with respect: https://github.com/MarlinFirmware/Marlin/blob/master/.github/code_of_conduct.md
-
-Do you want to ask a question? Are you looking for support? Please don't post here. Instead please use one of the support links at https://github.com/MarlinFirmware/Marlin/issues/new/choose
-
-Before filing an issue be sure to test the "bugfix" branches to see whether the issue has been resolved.
-
-->
-
-### Bug Description
-
-<!-- Description of the bug -->
-
-### My Configurations
-
-**Required:** Please include a ZIP file containing your `Configuration.h` and `Configuration_adv.h` files.
-
-### Steps to Reproduce
-
-<!-- Please describe the steps needed to reproduce the issue -->
-
-1. [First Step]
-2. [Second Step]
-3. [and so on...]
-
-**Expected behavior:** [What you expect to happen]
-
-**Actual behavior:** [What actually happens]
-
-#### Additional Information
-
-* Provide pictures or links to videos that clearly demonstrate the issue.
-* See [How Can I Contribute](#how-can-i-contribute) for additional guidelines.
@@ -1,17 +0,0 @@
-blank_issues_enabled: false
-contact_links:
-  - name: Marlin Documentation
-    url: http://marlinfw.org/
-    about: Lots of documentation on installing and using Marlin.
-  - name: MarlinFirmware Facebook group
-    url: https://www.facebook.com/groups/1049718498464482
-    about: Please ask and answer questions here.
-  - name: Marlin on Discord
-    url: https://discord.gg/n5NJ59y
-    about: Join the Discord server for support and discussion.
-  - name: Marlin Discussion Forum
-    url: http://forums.reprap.org/list.php?415
-    about: A searchable web forum hosted by RepRap dot org.
-  - name: Marlin Videos on YouTube
-    url: https://www.youtube.com/results?search_query=marlin+firmware
-    about: Tutorials and more from Marlin users all around the world. Great for new users!
@@ -1,35 +0,0 @@
---
-name: Feature request
-about: Request a Feature
-title: "[FR] (feature request title)"
-labels: ''
-assignees: ''
-
---
-
-<!--
-
-Have you read Marlin's Code of Conduct? By filing an Issue, you are expected to comply with it, including treating everyone with respect: https://github.com/MarlinFirmware/Marlin/blob/master/.github/code_of_conduct.md
-
-Do you want to ask a question? Are you looking for support? Please don't post here. Instead please use one of the support links at https://github.com/MarlinFirmware/Marlin/issues/new/choose
-
-Before filing an issue be sure to test the "bugfix" branches to see whether the issue has been resolved.
-
-->
-
-### Description
-
-<!-- Description of the requested feature -->
-
-### Feature Workflow
-
-<!-- Please describe the feature's behavior, user interaction, etc. -->
-
-1. [First Action]
-2. [Second Action]
-3. [and so on...]
-
-#### Additional Information
-
-* Provide pictures or links that demonstrate a similar feature or concept.
-* See [How Can I Contribute](#how-can-i-contribute) for additional guidelines.
@@ -1,7 +0,0 @@
-Thanks for your contribution! Unfortunately we can't accept PRs directed at release branches. We make patches to the bugfix branches and only later do we push them out as releases.
-
-Please redo this PR starting with the `bugfix-2.0.x` branch and be careful to target `bugfix-2.0.x` when resubmitting the PR.
-
-It may help to set your fork's default branch to `bugfix-2.0.x`.
-
-See [this page](http://marlinfw.org/docs/development/getting_started_pull_requests.html) for full instructions.
@@ -1,34 +0,0 @@
-#
-# bump-date.yml
-# Bump the distribution date once per day
-#
-
-name: Bump Distribution Date
-
-on:
-  schedule:
-    - cron: '0 0 * * *'
-
-jobs:
-  bump_date:
-
-    runs-on: ubuntu-latest
-
-    steps:
-
-    - name: Check out bugfix-2.0.x
-      uses: actions/checkout@v2
-      with:
-        ref: bugfix-2.0.x
-
-    - name: Bump Distribution Date
-      run: |
-        # Inline Bump Script
-        [[ "$GITHUB_REPOSITORY" == "MarlinFirmware/Marlin" ]] || exit 0
-        DIST=$( date +"%Y-%m-%d" )
-        eval "sed -E -i 's/(#define +STRING_DISTRIBUTION_DATE) .*$/\1 \"$DIST\"/g' Marlin/src/inc/Version.h" && \
-        git config user.name "${GITHUB_ACTOR}" && \
-        git config user.email "${GITHUB_ACTOR}@users.noreply.github.com" && \
-        git add . && \
-        git commit -m "[cron] Bump distribution date ($DIST)" && \
-        git push
@@ -1,27 +0,0 @@
-#
-# comment-pr.yml
-# Add a comment to any PR directed to a release branch
-#
-
-name: PR Bad Target
-
-on:
-  pull_request:
-    branches:
-    - 1.0.x
-    - 1.1.x
-    - 2.0.x
-
-jobs:
-  bad_target:
-
-    name: PR Bad Target
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v1
-      - uses: harupy/comment-on-pr@master
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          filename: bad-target.md
@@ -56,33 +56,28 @@ jobs:

        # STM32F1 (Maple) Environments

-        #- STM32F103RC_btt_maple
-        - STM32F103RC_btt_USB_maple
-        - STM32F103RC_fysetc_maple
+        - STM32F103RC_btt
+        - STM32F103RC_btt_USB
+        - STM32F103RE_btt
+        - STM32F103RE_btt_USB
+        - STM32F103RC_fysetc
        - STM32F103RC_meeb
-        - jgaurora_a5s_a1_maple
-        - STM32F103VE_longer_maple
-        #- mks_robin_maple
-        - mks_robin_lite_maple
-        - mks_robin_pro_maple
-        #- mks_robin_nano35_maple
-        #- STM32F103RET6_creality_maple
-        - STM32F103VE_ZM3E4V2_USB_maple
+        - jgaurora_a5s_a1
+        - STM32F103VE_longer
+        - mks_robin
+        - mks_robin_lite
+        - mks_robin_pro
+        - STM32F103RET6_creality
+        - mks_robin_nano35

        # STM32 (ST) Environments

-        - STM32F103RC_btt
-        #- STM32F103RC_btt_USB
-        - STM32F103RE_btt
-        - STM32F103RE_btt_USB
-        - STM32F103RET6_creality
-        - STM32F103VE_longer
        - STM32F407VE_black
        - STM32F401VE_STEVAL
        - BIGTREE_BTT002
        - BIGTREE_SKR_PRO
        - BIGTREE_GTR_V1_0
-        - mks_robin
+        - mks_robin_stm32
        - ARMED
        - FYSETC_S6
        - STM32F070CB_malyan
@@ -91,12 +86,9 @@ jobs:
        - FLYF407ZG
        - rumba32
        - LERDGEX
-        - LERDGEK
-        - mks_robin_nano35
+        - mks_robin_nano35_stm32
        - NUCLEO_F767ZI
        - REMRAM_V1
-        - BTT_SKR_SE_BX
-        - chitu_f103

        # Put lengthy tests last

@@ -106,30 +98,12 @@ jobs:
        # Non-working environment tests
        #- at90usb1286_cdc
        #- STM32F103CB_malyan
-        #- STM32F103RE
        #- mks_robin_mini

    steps:

-    - name: Check out the PR
-      uses: actions/checkout@v2
-
-    - name: Cache pip
-      uses: actions/cache@v2
-      with:
-        path: ~/.cache/pip
-        key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
-        restore-keys: |
-          ${{ runner.os }}-pip-
-
-    - name: Cache PlatformIO
-      uses: actions/cache@v2
-      with:
-        path: ~/.platformio
-        key: ${{ runner.os }}-${{ hashFiles('**/lockfiles') }}
-
    - name: Select Python 3.7
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v1
      with:
        python-version: '3.7' # Version range or exact version of a Python version to use, using semvers version range syntax.
        architecture: 'x64' # optional x64 or x86. Defaults to x64 if not specified
@@ -139,6 +113,9 @@ jobs:
        pip install -U https://github.com/platformio/platformio-core/archive/develop.zip
        platformio update

+    - name: Check out the PR
+      uses: actions/checkout@v2
+
    - name: Run ${{ matrix.test-platform }} Tests
      run: |
        make tests-single-ci TEST_TARGET=${{ matrix.test-platform }}
@@ -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
@@ -122,6 +122,29 @@ tags
 .gcc-flags.json
 /lib/

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

@@ -143,11 +166,7 @@ vc-fileutils.settings
 .vscode/launch.json
 .vscode/*.db

-#Simulation
-imgui.ini
-eeprom.dat
-
-#cmake
+# cmake
 CMakeLists.txt
 src/CMakeLists.txt
 CMakeListsPrivate.txt
@@ -110,7 +110,7 @@ LIQUID_TWI2        ?= 0
 WIRE               ?= 0

 # This defines if Tone is needed (i.e SPEAKER is defined in Configuration.h)
-# Disabling this (and SPEAKER) saves approximately 350 bytes of memory.
+# Disabling this (and SPEAKER) saves approximatively 350 bytes of memory.
 TONE               ?= 1

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

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

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

-# Automatically include the dependency files created by gcc
+# Automaticaly include the dependency files created by gcc
 -include ${patsubst %.o, %.d, ${OBJ}}
@@ -41,7 +41,7 @@
 * here we define this default string as the date where the latest release
 * version was tagged.
 */
-//#define STRING_DISTRIBUTION_DATE "2021-08-08"
+//#define STRING_DISTRIBUTION_DATE "2019-07-10"

 /**
 * Defines a generic printer name to be output to the LCD after booting Marlin.
@@ -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
 // ------------------------
@@ -58,15 +51,6 @@ void HAL_init() {
  #endif
 }

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

  #include "../../sd/SdFatUtil.h"
@@ -82,46 +82,31 @@ 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 0 to 3, or -1 for USB Serial."
+    #error "SERIAL_PORT must be from -1 to 3. Please update your configuration."
  #endif
-  #define MYSERIAL1 customizedSerial1
+  #define MYSERIAL0 customizedSerial1

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

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

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

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

 #if GCC_VERSION <= 50000
  #pragma GCC diagnostic push
@@ -186,7 +171,7 @@ inline void HAL_adc_init() {
 #define GET_PIN_MAP_INDEX(pin) pin
 #define PARSED_PIN_INDEX(code, dval) parser.intval(code, dval)

-#define HAL_SENSITIVE_PINS 0, 1,
+#define HAL_SENSITIVE_PINS 0, 1

 #ifdef __AVR_AT90USB1286__
  #define JTAG_DISABLE() do{ MCUCR = 0x80; MCUCR = 0x80; }while(0)
@@ -88,7 +88,7 @@ void spiBegin() {
  }

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

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

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

  // Soft SPI send block
-  void spiSendBlock(uint8_t token, const uint8_t *buf) {
+  void spiSendBlock(uint8_t token, const uint8_t* buf) {
    spiSend(token);
    for (uint16_t i = 0; i < 512; i++)
      spiSend(buf[i]);
@@ -556,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();
@@ -565,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> >;
-MSerialT1 customizedSerial1(MSerialT1::HasEmergencyParser);
+// Preinstantiate
+template class MarlinSerial<MarlinSerialCfg<SERIAL_PORT>>;
+
+// Instantiate
+MarlinSerial<MarlinSerialCfg<SERIAL_PORT>> customizedSerial1;

 #ifdef SERIAL_PORT_2

@@ -580,26 +737,13 @@ MSerialT1 customizedSerial1(MSerialT1::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>>;

-#endif // SERIAL_PORT_2
+  // Instantiate
+  MarlinSerial<MarlinSerialCfg<SERIAL_PORT_2>> customizedSerial2;

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

 #ifdef MMU2_SERIAL_PORT

@@ -611,10 +755,13 @@ MSerialT1 customizedSerial1(MSerialT1::HasEmergencyParser);
    MarlinSerial<MMU2SerialCfg<MMU2_SERIAL_PORT>>::_tx_udr_empty_irq();
  }

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

-#endif // MMU2_SERIAL_PORT
+  // Instantiate
+  MarlinSerial<MMU2SerialCfg<MMU2_SERIAL_PORT>> mmuSerial;
+
+#endif

 #ifdef LCD_SERIAL_PORT

@@ -626,8 +773,11 @@ MSerialT1 customizedSerial1(MSerialT1::HasEmergencyParser);
    MarlinSerial<LCDSerialCfg<LCD_SERIAL_PORT>>::_tx_udr_empty_irq();
  }

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

  #if HAS_DGUS_LCD
    template<typename Cfg>
@@ -640,13 +790,13 @@ MSerialT1 customizedSerial1(MSerialT1::HasEmergencyParser);
    }
  #endif

-#endif // LCD_SERIAL_PORT
+#endif

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

 // For AT90USB targets use the UART for BT interfacing
 #if defined(USBCON) && ENABLED(BLUETOOTH)
-  MSerialBT bluetoothSerial(false);
+  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 void 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,18 +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> > > MSerialT1;
-  extern MSerialT1 customizedSerial1;
+  extern MarlinSerial<MarlinSerialCfg<SERIAL_PORT>> customizedSerial1;

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

-  #ifdef SERIAL_PORT_3
-    typedef Serial1Class< MarlinSerial< MarlinSerialCfg<SERIAL_PORT_3> > > MSerialT3;
-    extern MSerialT3 customizedSerial3;
+    extern MarlinSerial<MarlinSerialCfg<SERIAL_PORT_2>> customizedSerial2;
+
  #endif

 #endif // !USBCON
@@ -257,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> > > MSerialMMU2;
-  extern MSerialMMU2 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> > > MSerialLCD;
-  extern MSerialLCD 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> MSerialBT;
-  extern MSerialBT bluetoothSerial;
+  extern HardwareSerial bluetoothSerial;
 #endif
@@ -40,13 +40,13 @@ bool PersistentStore::access_start()  { return true; }
 bool PersistentStore::access_finish() { return true; }

 bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
-  uint16_t written = 0;
  while (size--) {
    uint8_t * const p = (uint8_t * const)pos;
    uint8_t v = *value;
-    if (v != eeprom_read_byte(p)) { // EEPROM has only ~100,000 write cycles, so only write bytes that have changed!
+    // EEPROM has only ~100,000 write cycles,
+    // so only write bytes that have changed!
+    if (v != eeprom_read_byte(p)) {
      eeprom_write_byte(p, v);
-      if (++written & 0x7F) delay(2); else safe_delay(2); // Avoid triggering watchdog during long EEPROM writes
      if (eeprom_read_byte(p) != v) {
        SERIAL_ECHO_MSG(STR_ERR_EEPROM_WRITE);
        return true;
@@ -168,51 +168,6 @@ void setup_endstop_interrupts() {
      pciSetup(Z_MIN_PIN);
    #endif
  #endif
-  #if HAS_I_MAX
-    #if (digitalPinToInterrupt(I_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(I_MAX_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(I_MAX_PIN), "I_MAX_PIN is not interrupt-capable");
-      pciSetup(I_MAX_PIN);
-    #endif
-  #elif HAS_I_MIN
-    #if (digitalPinToInterrupt(I_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(I_MIN_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(I_MIN_PIN), "I_MIN_PIN is not interrupt-capable");
-      pciSetup(I_MIN_PIN);
-    #endif
-  #endif
-  #if HAS_J_MAX
-    #if (digitalPinToInterrupt(J_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(J_MAX_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(J_MAX_PIN), "J_MAX_PIN is not interrupt-capable");
-      pciSetup(J_MAX_PIN);
-    #endif
-  #elif HAS_J_MIN
-    #if (digitalPinToInterrupt(J_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(J_MIN_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(J_MIN_PIN), "J_MIN_PIN is not interrupt-capable");
-      pciSetup(J_MIN_PIN);
-    #endif
-  #endif
-  #if HAS_K_MAX
-    #if (digitalPinToInterrupt(K_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(K_MAX_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(K_MAX_PIN), "K_MAX_PIN is not interrupt-capable");
-      pciSetup(K_MAX_PIN);
-    #endif
-  #elif HAS_K_MIN
-    #if (digitalPinToInterrupt(K_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(K_MIN_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(K_MIN_PIN), "K_MIN_PIN is not interrupt-capable");
-      pciSetup(K_MIN_PIN);
-    #endif
-  #endif
  #if HAS_X2_MAX
    #if (digitalPinToInterrupt(X2_MAX_PIN) != NOT_AN_INTERRUPT)
      _ATTACH(X2_MAX_PIN);
@@ -301,5 +256,6 @@ void setup_endstop_interrupts() {
      pciSetup(Z_MIN_PROBE_PIN);
    #endif
  #endif
+
  // If we arrive here without raising an assertion, each pin has either an EXT-interrupt or a PCI.
 }
@@ -241,7 +241,7 @@ uint8_t extDigitalRead(const int8_t pin) {
 *
 * DC values -1.0 to 1.0. Negative duty cycle inverts the pulse.
 */
-uint16_t set_pwm_frequency_hz(const_float_t hz, const float dca, const float dcb, const float dcc) {
+uint16_t set_pwm_frequency_hz(const float &hz, const float dca, const float dcb, const float dcc) {
  float count = 0;
  if (hz > 0 && (dca || dcb || dcc)) {
    count = float(F_CPU) / hz;            // 1x prescaler, TOP for 16MHz base freq.
@@ -284,8 +284,8 @@ enum ClockSource2 : char {
 * PWM availability macros
 */

-// Determine which hardware 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)
+// 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)
 #if PIN_EXISTS(CONTROLLER_FAN)
  #define PWM_CHK_FAN_B(P) (_PWM_CHK_FAN_B(P) || P == CONTROLLER_FAN_PIN)
 #else
@@ -56,10 +56,3 @@
 #if BOTH(HAS_TMC_SW_SERIAL, MONITOR_DRIVER_STATUS)
  #error "MONITOR_DRIVER_STATUS causes performance issues when used with SoftwareSerial-connected drivers. Disable MONITOR_DRIVER_STATUS or use hardware serial to continue."
 #endif
-
-/**
- * Postmortem debugging
- */
-#if ENABLED(POSTMORTEM_DEBUGGING)
-  #error "POSTMORTEM_DEBUGGING is not supported on AVR boards."
-#endif
@@ -38,7 +38,7 @@
  // portModeRegister takes a different argument
  #define digitalPinToTimer_DEBUG(p) digitalPinToTimer(p)
  #define digitalPinToBitMask_DEBUG(p) digitalPinToBitMask(p)
-  #define digitalPinToPort_DEBUG(p) digitalPinToPort(p)
+  #define digitalPinToPort_DEBUG(p) digitalPinToPort_Teensy(p)
  #define GET_PINMODE(pin) (*portModeRegister(pin) & digitalPinToBitMask_DEBUG(pin))

 #elif AVR_ATmega2560_FAMILY_PLUS_70   // So we can access/display all the pins on boards using more than 70
@@ -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(); }
@@ -62,7 +62,7 @@
 #include "../shared/Marduino.h"
 #include "../shared/Delay.h"

-#include <U8glib-HAL.h>
+#include <U8glib.h>

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

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

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

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

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

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

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

 #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."
+    #error "MMU2_SERIAL_PORT must be from 0 to 3. Please update your configuration."
  #endif
 #endif

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

@@ -100,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
@@ -120,7 +113,7 @@ void sei();                     // Enable interrupts
 void HAL_clear_reset_source();  // clear reset reason
 uint8_t HAL_get_reset_source(); // get reset reason

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

 //
 // ADC
@@ -1,91 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#ifdef ARDUINO_ARCH_SAM
-
-#include "../../inc/MarlinConfigPre.h"
-
-#if ENABLED(POSTMORTEM_DEBUGGING)
-
-#include "../shared/HAL_MinSerial.h"
-
-#include <stdarg.h>
-
-static void TXBegin() {
-  // Disable UART interrupt in NVIC
-  NVIC_DisableIRQ( UART_IRQn );
-
-  // We NEED memory barriers to ensure Interrupts are actually disabled!
-  // ( https://dzone.com/articles/nvic-disabling-interrupts-on-arm-cortex-m-and-the )
-  __DSB();
-  __ISB();
-
-  // Disable clock
-  pmc_disable_periph_clk( ID_UART );
-
-  // Configure PMC
-  pmc_enable_periph_clk( ID_UART );
-
-  // Disable PDC channel
-  UART->UART_PTCR = UART_PTCR_RXTDIS | UART_PTCR_TXTDIS;
-
-  // Reset and disable receiver and transmitter
-  UART->UART_CR = UART_CR_RSTRX | UART_CR_RSTTX | UART_CR_RXDIS | UART_CR_TXDIS;
-
-  // Configure mode: 8bit, No parity, 1 bit stop
-  UART->UART_MR = UART_MR_CHMODE_NORMAL | US_MR_CHRL_8_BIT | US_MR_NBSTOP_1_BIT | UART_MR_PAR_NO;
-
-  // Configure baudrate (asynchronous, no oversampling) to BAUDRATE bauds
-  UART->UART_BRGR = (SystemCoreClock / (BAUDRATE << 4));
-
-  // Enable receiver and transmitter
-  UART->UART_CR = UART_CR_RXEN | UART_CR_TXEN;
-}
-
-// A SW memory barrier, to ensure GCC does not overoptimize loops
-#define sw_barrier() __asm__ volatile("": : :"memory");
-static void TX(char c) {
-  while (!(UART->UART_SR & UART_SR_TXRDY)) { WDT_Restart(WDT); sw_barrier(); };
-  UART->UART_THR = c;
-}
-
-void install_min_serial() {
-  HAL_min_serial_init = &TXBegin;
-  HAL_min_serial_out = &TX;
-}
-
-#if DISABLED(DYNAMIC_VECTORTABLE)
-extern "C" {
-  __attribute__((naked)) void JumpHandler_ASM() {
-    __asm__ __volatile__ (
-      "b CommonHandler_ASM\n"
-    );
-  }
-  void __attribute__((naked, alias("JumpHandler_ASM"))) HardFault_Handler();
-  void __attribute__((naked, alias("JumpHandler_ASM"))) BusFault_Handler();
-  void __attribute__((naked, alias("JumpHandler_ASM"))) UsageFault_Handler();
-  void __attribute__((naked, alias("JumpHandler_ASM"))) MemManage_Handler();
-  void __attribute__((naked, alias("JumpHandler_ASM"))) NMI_Handler();
-}
-#endif
-
-#endif // POSTMORTEM_DEBUGGING
-#endif // ARDUINO_ARCH_SAM
@@ -56,8 +56,8 @@
  #pragma GCC optimize (3)

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

  /* ---------------- Macros to be able to access definitions from asm */
  #define _PORT(IO) DIO ##  IO ## _WPORT
@@ -240,7 +240,7 @@
  }

  // all the others
-  static uint16_t spiDelayNS = 4000; // 4000ns => 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_NS(spiDelayNS);
+      __delay_4cycles(spiDelayCyclesX4);

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

      WRITE(SD_SCK_PIN, LOW);
-      DELAY_NS(spiDelayNS);
+      __delay_4cycles(spiDelayCyclesX4);
    } while (--bits);
    return b;
  }
@@ -270,7 +270,7 @@
  static pfnSpiTransfer spiTransferTx = (pfnSpiTransfer)spiTransferX;

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

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

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

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

-  // Pointers to generic functions for block transfers
+  // Pointers to generic functions for block tranfers
  static pfnSpiTxBlock spiTxBlock = (pfnSpiTxBlock)spiTxBlockX;
  static pfnSpiRxBlock spiRxBlock = (pfnSpiRxBlock)spiRxBlockX;

@@ -463,7 +463,7 @@
    return b;
  }

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

-  void spiSendBlock(uint8_t token, const uint8_t *buf) {
+  void spiSendBlock(uint8_t token, const uint8_t* buf) {
    _SS_WRITE(LOW);
    (void)spiTransferTx(token);
    spiTxBlock(buf, 512);
@@ -510,7 +510,7 @@
        spiRxBlock = (pfnSpiRxBlock)spiRxBlockX;
        break;
      default:
-        spiDelayNS = 4000 >> (6 - spiRate); // 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;
@@ -645,7 +645,7 @@
    }

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

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

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

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

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

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

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

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

-    void spiSendBlock(uint8_t token, const uint8_t *buf) {
+    void spiSendBlock(uint8_t token, const uint8_t* buf) {
      spiTransfer(token);
      for (uint16_t i = 0; i < 512; i++)
        spiTransfer(buf[i]);
@@ -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,21 +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 defined(SERIAL_PORT) && SERIAL_PORT >= 0
-  template class MarlinSerial< MarlinSerialCfg<SERIAL_PORT> >;
-  MSerialT1 customizedSerial1(MarlinSerialCfg<SERIAL_PORT>::EMERGENCYPARSER);
+#if SERIAL_PORT >= 0
+  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);
-#endif
-
-#if defined(SERIAL_PORT_3) && SERIAL_PORT_3 >= 0
-  template class MarlinSerial< MarlinSerialCfg<SERIAL_PORT_3> >;
-  MSerialT3 customizedSerial3(MarlinSerialCfg<SERIAL_PORT_3>::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
@@ -140,17 +173,10 @@ struct MarlinSerialCfg {
  static constexpr bool MAX_RX_QUEUED     = ENABLED(SERIAL_STATS_MAX_RX_QUEUED);
 };

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

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

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

@@ -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<MSerialT1*>(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<MSerialT1*>(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,23 +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
-  MSerialT1 customizedSerial1(TERN0(EMERGENCY_PARSER, true));
+  MarlinSerialUSB customizedSerial1;
 #endif
 #if SERIAL_PORT_2 == -1
-  MSerialT2 customizedSerial2(TERN0(EMERGENCY_PARSER, true));
-#endif
-#if SERIAL_PORT_3 == -1
-  MSerialT3 customizedSerial3(TERN0(EMERGENCY_PARSER, true));
+  MarlinSerialUSB customizedSerial2;
 #endif

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

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

 #include <WString.h>

-struct MarlinSerialUSB {
-  void begin(const long);
-  void end();
-  int peek();
-  int read();
-  void flush();
-  int available();
-  size_t write(const uint8_t c);
+#define DEC 10
+#define HEX 16
+#define OCT 8
+#define BIN 2
+
+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);
 };

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

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

-#if SERIAL_PORT_3 == -1
-  typedef Serial1Class<MarlinSerialUSB> MSerialT3;
-  extern MSerialT3 customizedSerial3;
-#endif
+#endif // HAS_USB_SERIAL
@@ -60,7 +60,7 @@

 #if HAS_MARLINUI_U8GLIB

-#include <U8glib-HAL.h>
+#include <U8glib.h>

 #include "../../../MarlinCore.h"

@@ -59,10 +59,9 @@

 #if ENABLED(U8GLIB_ST7920)

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

-#include <U8glib-HAL.h>
+#include <U8glib.h>

 #include "u8g_com_HAL_DUE_sw_spi_shared.h"

@@ -64,7 +64,7 @@
 #include "../../shared/Marduino.h"
 #include "../../shared/Delay.h"

-#include <U8glib-HAL.h>
+#include <U8glib.h>

 #if ENABLED(FYSETC_MINI_12864)
  #define SPISEND_SW_DUE u8g_spiSend_sw_DUE_mode_3
@@ -59,10 +59,9 @@

 #if HAS_MARLINUI_U8GLIB

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

-#include <U8glib-HAL.h>
+#include <U8glib.h>

 #include "u8g_com_HAL_DUE_sw_spi_shared.h"

@@ -23,7 +23,7 @@

 #include "../../../inc/MarlinConfigPre.h"
 #include "../../shared/Marduino.h"
-#include <U8glib-HAL.h>
+#include <U8glib.h>

 void u8g_SetPIOutput_DUE(u8g_t *u8g, uint8_t pin_index);
 void u8g_SetPILevel_DUE(u8g_t *u8g, uint8_t pin_index, uint8_t level);
@@ -135,11 +135,11 @@ static uint8_t buffer[256] = {0},   // The RAM buffer to accumulate writes
 #define DEBUG_OUT ENABLED(EE_EMU_DEBUG)
 #include "../../core/debug_out.h"

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

  #ifdef EE_EMU_DEBUG

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

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

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

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

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

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

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

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

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

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

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

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

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

 #if HAS_TMC_SW_SERIAL
-  #error "TMC220x Software Serial is not supported on the DUE platform."
+  #error "TMC220x Software Serial is not supported on this platform."
 #endif
@@ -71,7 +71,7 @@
 /* ------------------------------------------------------------------------ */

 /**
- * \page arduino_due_x_board_info "Arduino Due/X - Board information"
+ * \page arduino_due_x_board_info "Arduino Due/X - Board informations"
 * This page lists several definition related to the board description.
 *
 */
@@ -32,7 +32,7 @@ Ctrl_status sd_mmc_spi_test_unit_ready() {
 Ctrl_status sd_mmc_spi_read_capacity(uint32_t *nb_sector) {
  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted())
    return CTRL_NO_PRESENT;
-  *nb_sector = card.diskIODriver()->cardSize() - 1;
+  *nb_sector = card.getSd2Card().cardSize() - 1;
  return CTRL_GOOD;
 }

@@ -68,30 +68,30 @@ 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

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

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

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

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

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

  // Done
  return CTRL_GOOD;
@@ -108,12 +108,12 @@ 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

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

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

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

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

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

  // Done
  return CTRL_GOOD;
@@ -74,7 +74,7 @@
 #define   SD_MMC_REMOVING      2


-//---- CONTROL FUNCTIONS ----
+//---- CONTROL FONCTIONS ----
 //!
 //! @brief This function initializes the hw/sw resources required to drive the SD_MMC_SPI.
 //!/
@@ -134,7 +134,7 @@ extern bool           sd_mmc_spi_wr_protect(void);
 extern bool           sd_mmc_spi_removal(void);


-//---- ACCESS DATA FUNCTIONS ----
+//---- ACCESS DATA FONCTIONS ----

 #if ACCESS_USB == true
 // Standard functions for open in read/write mode the device
@@ -90,7 +90,7 @@ typedef struct {
 	//! This buffer must be word align for DATA IN phase (use prefix COMPILER_WORD_ALIGNED for buffer)
 	uint8_t *payload;

-	//! Size of buffer to send or fill, and content the number of byte transferred
+	//! Size of buffer to send or fill, and content the number of byte transfered
 	uint16_t payload_size;

 	//! Callback called after reception of ZLP from setup request
@@ -132,10 +132,10 @@ typedef void (*udd_callback_halt_cleared_t)(void);
 *
 * \param status     UDD_EP_TRANSFER_OK, if transfer is complete
 * \param status     UDD_EP_TRANSFER_ABORT, if transfer is aborted
- * \param n          number of data transferred
+ * \param n          number of data transfered
 */
 typedef void (*udd_callback_trans_t) (udd_ep_status_t status,
-		iram_size_t nb_transferred, udd_ep_id_t ep);
+		iram_size_t nb_transfered, udd_ep_id_t ep);

 /**
 * \brief Authorizes the VBUS event
@@ -303,7 +303,7 @@ bool udd_ep_wait_stall_clear(udd_ep_id_t ep,
 * The driver uses a specific DMA USB to transfer data
 * from internal RAM to endpoint, if this one is available.
 * When the transfer is finished or aborted (stall, reset, ...), the \a callback is called.
- * The \a callback returns the transfer status and eventually the number of byte transferred.
+ * The \a callback returns the transfer status and eventually the number of byte transfered.
 * Note: The control endpoint is not authorized.
 *
 * \param ep            The ID of the endpoint to use
@@ -162,7 +162,7 @@ static void udi_cdc_ctrl_state_notify(uint8_t port, udd_ep_id_t ep);
 *
 * \param status     UDD_EP_TRANSFER_OK, if transfer finished
 * \param status     UDD_EP_TRANSFER_ABORT, if transfer aborted
- * \param n          number of data transferred
+ * \param n          number of data transfered
 */
 static void udi_cdc_serial_state_msg_sent(udd_ep_status_t status, iram_size_t n, udd_ep_id_t ep);

@@ -200,7 +200,7 @@ static void udi_cdc_data_received(udd_ep_status_t status, iram_size_t n, udd_ep_
 *
 * \param status     UDD_EP_TRANSFER_OK, if transfer finished
 * \param status     UDD_EP_TRANSFER_ABORT, if transfer aborted
- * \param n          number of data transferred
+ * \param n          number of data transfered
 */
 static void udi_cdc_data_sent(udd_ep_status_t status, iram_size_t n, udd_ep_id_t ep);

@@ -675,11 +675,11 @@ iram_size_t udi_cdc_multi_write_buf(uint8_t port, const void* buf, iram_size_t s
 *   - \code // Waits and gets a value on CDC line
 	int udi_cdc_getc(void);
 	// Reads a RAM buffer on CDC line
-	iram_size_t udi_cdc_read_buf(int *buf, iram_size_t size);
+	iram_size_t udi_cdc_read_buf(int* buf, iram_size_t size);
 	// Puts a byte on CDC line
 	int udi_cdc_putc(int value);
 	// Writes a RAM buffer on CDC line
-	iram_size_t udi_cdc_write_buf(const int *buf, iram_size_t size); \endcode
+	iram_size_t udi_cdc_write_buf(const int* buf, iram_size_t size); \endcode
 *
 * \section udi_cdc_use_cases Advanced use cases
 * For more advanced use of the UDI CDC module, see the following use cases:
@@ -106,7 +106,7 @@ extern "C" {
 */
 //@{
 #  if UDI_CDC_PORT_NB > 2
-#    error USBB, UDP, UDPHS and UOTGHS interfaces have not enough endpoints.
+#    error USBB, UDP, UDPHS and UOTGHS interfaces have not enought endpoints.
 #  endif
 #define  UDI_CDC_DATA_EP_IN_0          (1 | USB_EP_DIR_IN)  // TX
 #define  UDI_CDC_DATA_EP_OUT_0         (2 | USB_EP_DIR_OUT) // RX
@@ -173,7 +173,7 @@ static void udi_msc_cbw_wait(void);
 *
 * \param status       UDD_EP_TRANSFER_OK, if transfer is finished
 * \param status       UDD_EP_TRANSFER_ABORT, if transfer is aborted
- * \param nb_received  number of data transferred
+ * \param nb_received  number of data transfered
 */
 static void udi_msc_cbw_received(udd_ep_status_t status,
    iram_size_t nb_received, udd_ep_id_t ep);
@@ -211,7 +211,7 @@ static void udi_msc_data_send(uint8_t * buffer, uint8_t buf_size);
 *
 * \param status     UDD_EP_TRANSFER_OK, if transfer finish
 * \param status     UDD_EP_TRANSFER_ABORT, if transfer aborted
- * \param nb_sent    number of data transferred
+ * \param nb_sent    number of data transfered
 */
 static void udi_msc_data_sent(udd_ep_status_t status, iram_size_t nb_sent,
    udd_ep_id_t ep);
@@ -244,7 +244,7 @@ void udi_msc_csw_send(void);
 *
 * \param status     UDD_EP_TRANSFER_OK, if transfer is finished
 * \param status     UDD_EP_TRANSFER_ABORT, if transfer is aborted
- * \param nb_sent    number of data transferred
+ * \param nb_sent    number of data transfered
 */
 static void udi_msc_csw_sent(udd_ep_status_t status, iram_size_t nb_sent,
    udd_ep_id_t ep);
@@ -463,7 +463,7 @@ uint8_t udi_msc_getsetting(void)
 static void udi_msc_cbw_invalid(void)
 {
  if (!udi_msc_b_cbw_invalid)
-    return; // Don't re-stall endpoint if error reset by setup
+    return; // Don't re-stall endpoint if error reseted by setup
  udd_ep_set_halt(UDI_MSC_EP_OUT);
  // If stall cleared then re-stall it. Only Setup MSC Reset can clear it
  udd_ep_wait_stall_clear(UDI_MSC_EP_OUT, udi_msc_cbw_invalid);
@@ -472,7 +472,7 @@ static void udi_msc_cbw_invalid(void)
 static void udi_msc_csw_invalid(void)
 {
  if (!udi_msc_b_cbw_invalid)
-    return; // Don't re-stall endpoint if error reset by setup
+    return; // Don't re-stall endpoint if error reseted by setup
  udd_ep_set_halt(UDI_MSC_EP_IN);
  // If stall cleared then re-stall it. Only Setup MSC Reset can clear it
  udd_ep_wait_stall_clear(UDI_MSC_EP_IN, udi_msc_csw_invalid);
@@ -325,7 +325,7 @@ static void udd_sleep_mode(bool b_idle)
 /**
 * \name Control endpoint low level management routine.
 *
- * This function performs control endpoint management.
+ * This function performs control endpoint mangement.
 * It handle the SETUP/DATA/HANDSHAKE phases of a control transaction.
 */
 //@{
@@ -397,9 +397,9 @@ static void udd_ctrl_endofrequest(void);
 /**
 * \brief Main interrupt routine for control endpoint
 *
- * This switches control endpoint events to correct sub function.
+ * This switchs control endpoint events to correct sub function.
 *
- * \return \c 1 if an event about control endpoint is occurred, otherwise \c 0.
+ * \return \c 1 if an event about control endpoint is occured, otherwise \c 0.
 */
 static bool udd_ctrl_interrupt(void);

@@ -410,7 +410,7 @@ static bool udd_ctrl_interrupt(void);
 * \name Management of bulk/interrupt/isochronous endpoints
 *
 * The UDD manages the data transfer on endpoints:
- * - Start data transfer on endpoint with USB Device DMA
+ * - Start data tranfer on endpoint with USB Device DMA
 * - Send a ZLP packet if requested
 * - Call callback registered to signal end of transfer
 * The transfer abort and stall feature are supported.
@@ -431,7 +431,7 @@ typedef struct {
 	uint8_t *buf;
 	//! Size of buffer to send or fill
 	iram_size_t buf_size;
-	//!< Size of data transferred
+	//!< Size of data transfered
 	iram_size_t buf_cnt;
 	//!< Size of data loaded (or prepared for DMA) last time
 	iram_size_t buf_load;
@@ -486,7 +486,7 @@ static void udd_ep_finish_job(udd_ep_job_t * ptr_job, bool b_abort, uint8_t ep_n

 #ifdef UDD_EP_DMA_SUPPORTED
 	/**
-	 * \brief Start the next transfer if necessary or complete the job associated.
+	 * \brief Start the next transfer if necessary or complet the job associated.
 	 *
 	 * \param ep endpoint number without direction flag
 	 */
@@ -496,9 +496,9 @@ static void udd_ep_finish_job(udd_ep_job_t * ptr_job, bool b_abort, uint8_t ep_n
 /**
 * \brief Main interrupt routine for bulk/interrupt/isochronous endpoints
 *
- * This switches endpoint events to correct sub function.
+ * This switchs endpoint events to correct sub function.
 *
- * \return \c 1 if an event about bulk/interrupt/isochronous endpoints has occurred, otherwise \c 0.
+ * \return \c 1 if an event about bulk/interrupt/isochronous endpoints has occured, otherwise \c 0.
 */
 static bool udd_ep_interrupt(void);

@@ -520,7 +520,7 @@ static bool udd_ep_interrupt(void);
 *
 * Note:
 * Here, the global interrupt mask is not clear when an USB interrupt is enabled
- * because this one can not be occurred during the USB ISR (=during INTX is masked).
+ * because this one can not be occured during the USB ISR (=during INTX is masked).
 * See Technical reference $3.8.3 Masking interrupt requests in peripheral modules.
 */
 #ifdef UHD_ENABLE
@@ -787,7 +787,7 @@ void udd_attach(void)
 	udd_sleep_mode(true);
 	otg_unfreeze_clock();

-	// This section of clock check can be improved with a check of
+	// This section of clock check can be improved with a chek of
 	// USB clock source via sysclk()
 	// Check USB clock because the source can be a PLL
 	while (!Is_otg_clock_usable());
@@ -803,7 +803,7 @@ void udd_attach(void)
 #ifdef USB_DEVICE_HS_SUPPORT
 	udd_enable_msof_interrupt();
 #endif
-	// Reset following interrupts flag
+	// Reset following interupts flag
 	udd_ack_reset();
 	udd_ack_sof();
 	udd_ack_msof();
@@ -902,7 +902,7 @@ bool udd_ep_alloc(udd_ep_id_t ep, uint8_t bmAttributes,
 	}
 	dbg_print("alloc(%x, %d) ", ep, MaxEndpointSize);

-	// Bank choice
+	// Bank choise
 	switch (bmAttributes & USB_EP_TYPE_MASK) {
 	case USB_EP_TYPE_ISOCHRONOUS:
 		nb_bank = UDD_ISOCHRONOUS_NB_BANK(ep);
@@ -1228,7 +1228,7 @@ bool udd_ep_wait_stall_clear(udd_ep_id_t ep,

 	if (Is_udd_endpoint_stall_requested(ep)
 			|| ptr_job->stall_requested) {
-		// Endpoint halted then registers the callback
+		// Endpoint halted then registes the callback
 		ptr_job->busy = true;
 		ptr_job->call_nohalt = callback;
 	} else {
@@ -1386,7 +1386,7 @@ static void udd_ctrl_setup_received(void)

 	// Decode setup request
 	if (udc_process_setup() == false) {
-		// Setup request unknown then stall it
+		// Setup request unknow then stall it
 		udd_ctrl_stall_data();
 		udd_ack_setup_received(0);
 		return;
@@ -1447,7 +1447,7 @@ static void udd_ctrl_in_sent(void)
 		udd_ctrl_prev_payload_buf_cnt += udd_ctrl_payload_buf_cnt;
 		if ((udd_g_ctrlreq.req.wLength == udd_ctrl_prev_payload_buf_cnt)
 					|| b_shortpacket) {
-			// All data requested are transferred or a short packet has been sent
+			// All data requested are transfered or a short packet has been sent
 			// then it is the end of data phase.
 			// Generate an OUT ZLP for handshake phase.
 			udd_ctrl_send_zlp_out();
@@ -1516,7 +1516,7 @@ static void udd_ctrl_out_received(void)
 			// End of SETUP request:
 			// - Data IN Phase aborted,
 			// - or last Data IN Phase hidden by ZLP OUT sending quiclky,
-			// - or ZLP OUT received normally.
+			// - or ZLP OUT received normaly.
 			udd_ctrl_endofrequest();
 		} else {
 			// Protocol error during SETUP request
@@ -1544,7 +1544,7 @@ static void udd_ctrl_out_received(void)
 					(udd_ctrl_prev_payload_buf_cnt +
 							udd_ctrl_payload_buf_cnt))) {
 		// End of reception because it is a short packet
-		// Before send ZLP, call intermediate callback
+		// Before send ZLP, call intermediat calback
 		// in case of data receiv generate a stall
 		udd_g_ctrlreq.payload_size = udd_ctrl_payload_buf_cnt;
 		if (NULL != udd_g_ctrlreq.over_under_run) {
@@ -1565,7 +1565,7 @@ static void udd_ctrl_out_received(void)
 	if (udd_g_ctrlreq.payload_size == udd_ctrl_payload_buf_cnt) {
 		// Overrun then request a new payload buffer
 		if (!udd_g_ctrlreq.over_under_run) {
-			// No callback available to request a new payload buffer
+			// No callback availabled to request a new payload buffer
 			udd_ctrl_stall_data();
 			// Ack reception of OUT to replace NAK by a STALL
 			udd_ack_out_received(0);
@@ -1805,7 +1805,7 @@ static void udd_ep_trans_done(udd_ep_id_t ep)
 			// transfer size of UDD_ENDPOINT_MAX_TRANS Bytes
 			next_trans = UDD_ENDPOINT_MAX_TRANS;

-			// Set 0 to transfer the maximum
+			// Set 0 to tranfer the maximum
 			udd_dma_ctrl = UOTGHS_DEVDMACONTROL_BUFF_LENGTH(0);
 		} else {
 			udd_dma_ctrl = UOTGHS_DEVDMACONTROL_BUFF_LENGTH(next_trans);
@@ -1850,7 +1850,7 @@ static void udd_ep_trans_done(udd_ep_id_t ep)
 		}
 		cpu_irq_restore(flags);

-		// Here a ZLP has been received
+		// Here a ZLP has been recieved
 		// and the DMA transfer must be not started.
 		// It is the end of transfer
 		ptr_job->buf_size = ptr_job->buf_cnt;
@@ -1991,13 +1991,13 @@ static bool udd_ep_interrupt(void)
 			}
 			dbg_print("dma%x: ", ep);
 			udd_disable_endpoint_dma_interrupt(ep);
-			// Save number of data no transferred
+			// Save number of data no transfered
 			nb_remaining = (udd_endpoint_dma_get_status(ep) &
 					UOTGHS_DEVDMASTATUS_BUFF_COUNT_Msk)
 					>> UOTGHS_DEVDMASTATUS_BUFF_COUNT_Pos;
 			if (nb_remaining) {
 				// Transfer no complete (short packet or ZLP) then:
-				// Update number of data transferred
+				// Update number of data transfered
 				ptr_job->buf_cnt -= nb_remaining;
 				// Set transfer complete to stop the transfer
 				ptr_job->buf_size = ptr_job->buf_cnt;
@@ -2056,7 +2056,7 @@ static bool udd_ep_interrupt(void)
 				udd_disable_endpoint_interrupt(ep);

 				Assert(ptr_job->stall_requested);
-				// A stall has been requested during background transfer
+				// A stall has been requested during backgound transfer
 				ptr_job->stall_requested = false;
 				udd_disable_endpoint_bank_autoswitch(ep);
 				udd_enable_stall_handshake(ep);
@@ -130,7 +130,7 @@ struct usb_msc_cbw {
 struct usb_msc_csw {
 	le32_t dCSWSignature;	//!< Must contain 'USBS'
 	le32_t dCSWTag;	//!< Same as dCBWTag
-	le32_t dCSWDataResidue;	//!< Number of bytes not transferred
+	le32_t dCSWDataResidue;	//!< Number of bytes not transfered
 	uint8_t bCSWStatus;	//!< Status code
 };

@@ -264,7 +264,7 @@ bool usb_task_extra_string(void) {
 ** Handle device requests that the ASF stack doesn't
 */
 bool usb_task_other_requests(void) {
-  uint8_t *ptr = 0;
+  uint8_t* ptr = 0;
  uint16_t size = 0;

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

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

      // And copy it to the proper place, expanding it to unicode
      sptr = &diam[0];
@@ -20,10 +20,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() {
@@ -141,8 +135,6 @@ void HAL_clear_reset_source() { }

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

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

 // return free memory between end of heap (or end bss) and whatever is current
@@ -187,7 +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
 // ------------------------
@@ -101,7 +103,7 @@ void HAL_clear_reset_source();
 // reset reason
 uint8_t HAL_get_reset_source();

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

 void _delay_ms(int delay);

@@ -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();

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

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

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

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

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

-size_t WebSocketSerial::write(const uint8_t *buffer, size_t size) {
+size_t WebSocketSerial::write(const uint8_t* buffer, size_t size) {
  size_t written = 0;
  for (size_t i = 0; i < size; i++)
    written += write(buffer[i]);
  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>

@@ -54,7 +53,7 @@ public:
  ring_buffer_pos_t read(uint8_t *buffer);
  void flush();
  ring_buffer_pos_t write(const uint8_t c);
-  ring_buffer_pos_t write(const uint8_t *buffer, ring_buffer_pos_t size);
+  ring_buffer_pos_t write(const uint8_t* buffer, ring_buffer_pos_t size);
 };

 class WebSocketSerial: public Stream {
@@ -69,8 +68,11 @@ 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);
+  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; }
@@ -81,5 +83,4 @@ public:
  #endif
 };

-typedef Serial1Class<WebSocketSerial> MSerialWebSocketT;
-extern MSerialWebSocketT webSocketSerial;
+extern WebSocketSerial webSocketSerial;
@@ -59,10 +59,4 @@ void setup_endstop_interrupts() {
  TERN_(HAS_Z4_MAX, _ATTACH(Z4_MAX_PIN));
  TERN_(HAS_Z4_MIN, _ATTACH(Z4_MIN_PIN));
  TERN_(HAS_Z_MIN_PROBE_PIN, _ATTACH(Z_MIN_PROBE_PIN));
-  TERN_(HAS_I_MAX, _ATTACH(I_MAX_PIN));
-  TERN_(HAS_I_MIN, _ATTACH(I_MIN_PIN));
-  TERN_(HAS_J_MAX, _ATTACH(J_MAX_PIN));
-  TERN_(HAS_J_MIN, _ATTACH(J_MIN_PIN));
-  TERN_(HAS_K_MAX, _ATTACH(K_MAX_PIN));
-  TERN_(HAS_K_MIN, _ATTACH(K_MIN_PIN));
 }
@@ -139,7 +139,7 @@ static void IRAM_ATTR i2s_intr_handler_default(void *arg) {
  I2S0.int_clr.val = I2S0.int_st.val; //clear pending interrupt
 }

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

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

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

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

 #include HAL_PATH(.,HAL.h)

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

 #ifndef I2C_ADDRESS
@@ -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" {
@@ -73,6 +73,4 @@ void HAL_pwm_init() {

 }

-void HAL_reboot() { /* Reset the application state and GPIO */ }
-
 #endif // __PLAT_LINUX__
@@ -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)
@@ -107,9 +107,14 @@ uint16_t HAL_adc_get_result();
 inline void HAL_clear_reset_source(void) {}
 inline uint8_t HAL_get_reset_source(void) { return RST_POWER_ON; }

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

 /* ---------------- Delay in cycles */
 FORCE_INLINE static void DELAY_CYCLES(uint64_t x) {
  Clock::delayCycles(x);
 }
+
+// Add strcmp_P if missing
+#ifndef strcmp_P
+  #define strcmp_P(a, b) strcmp((a), (b))
+#endif
@@ -40,7 +40,7 @@ struct GpioEvent {
  pin_type pin_id;
  GpioEvent::Type event;

-  GpioEvent(uint64_t timestamp, pin_type pin_id, GpioEvent::Type event) {
+  GpioEvent(uint64_t timestamp, pin_type pin_id, GpioEvent::Type event){
    this->timestamp = timestamp;
    this->pin_id = pin_id;
    this->event = event;
@@ -54,7 +54,7 @@ void Heater::update() {
 }

 void Heater::interrupt(GpioEvent ev) {
-  // unused
+  // ununsed
 }

 #endif // __PLAT_LINUX__
@@ -51,7 +51,7 @@ void LinearAxis::update() {
 }

 void LinearAxis::interrupt(GpioEvent ev) {
-  if (ev.pin_id == step_pin && !Gpio::pin_map[enable_pin].value) {
+  if (ev.pin_id == step_pin && !Gpio::pin_map[enable_pin].value){
    if (ev.event == GpioEvent::RISE) {
      last_update = ev.timestamp;
      position += -1 + 2 * Gpio::pin_map[dir_pin].value;
@@ -52,7 +52,7 @@ public:
    return (*(intptr_t*)timerid);
  }

-  static void handler(int sig, siginfo_t *si, void *uc) {
+  static void handler(int sig, siginfo_t *si, void *uc){
    Timer* _this = (Timer*)si->si_value.sival_ptr;
    _this->avg_error += (Clock::nanos() - _this->start_time) - _this->period; //high_resolution_clock is also limited in precision, but best we have
    _this->avg_error /= 2; //very crude precision analysis (actually within +-500ns usually)
@@ -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,6 +25,43 @@

 #include "../../../gcode/parser.h"

+uint8_t analog_offset = NUM_DIGITAL_PINS - NUM_ANALOG_INPUTS;
+
+// Get the digital pin for an analog index
+pin_t analogInputToDigitalPin(const int8_t p) {
+  return (WITHIN(p, 0, NUM_ANALOG_INPUTS) ? analog_offset + p : P_NC);
+}
+
+// Return the index of a pin number
+int16_t GET_PIN_MAP_INDEX(const pin_t pin) {
+  return pin;
+}
+
+// Test whether the pin is valid
+bool VALID_PIN(const pin_t p) {
+  return WITHIN(p, 0, NUM_DIGITAL_PINS);
+}
+
+// Get the analog index for a digital pin
+int8_t DIGITAL_PIN_TO_ANALOG_PIN(const pin_t p) {
+  return (WITHIN(p, analog_offset, NUM_DIGITAL_PINS) ? p - analog_offset : P_NC);
+}
+
+// Test whether the pin is PWM
+bool PWM_PIN(const pin_t p) {
+  return false;
+}
+
+// Test whether the pin is interruptable
+bool INTERRUPT_PIN(const pin_t p) {
+  return false;
+}
+
+// Get the pin number at the given index
+pin_t GET_PIN_MAP_PIN(const int16_t ind) {
+  return ind;
+}
+
 int16_t PARSED_PIN_INDEX(const char code, const int16_t dval) {
  return parser.intval(code, dval);
 }
@@ -34,32 +34,26 @@ constexpr uint8_t NUM_ANALOG_INPUTS = 16;

 #define HAL_SENSITIVE_PINS

-constexpr uint8_t analog_offset = NUM_DIGITAL_PINS - NUM_ANALOG_INPUTS;
-
 // Get the digital pin for an analog index
-constexpr pin_t analogInputToDigitalPin(const int8_t p) {
-  return (WITHIN(p, 0, NUM_ANALOG_INPUTS) ? analog_offset + p : P_NC);
-}
-
-// Get the analog index for a digital pin
-constexpr int8_t DIGITAL_PIN_TO_ANALOG_PIN(const pin_t p) {
-  return (WITHIN(p, analog_offset, NUM_DIGITAL_PINS) ? p - analog_offset : P_NC);
-}
+pin_t analogInputToDigitalPin(const int8_t p);

 // Return the index of a pin number
-constexpr int16_t GET_PIN_MAP_INDEX(const pin_t pin) { return pin; }
+int16_t GET_PIN_MAP_INDEX(const pin_t pin);

 // Test whether the pin is valid
-constexpr bool VALID_PIN(const pin_t p) { return WITHIN(p, 0, NUM_DIGITAL_PINS); }
+bool VALID_PIN(const pin_t p);
+
+// Get the analog index for a digital pin
+int8_t DIGITAL_PIN_TO_ANALOG_PIN(const pin_t p);

 // Test whether the pin is PWM
-constexpr bool PWM_PIN(const pin_t p) { return false; }
+bool PWM_PIN(const pin_t p);

-// Test whether the pin is interruptible
-constexpr bool INTERRUPT_PIN(const pin_t p) { return false; }
+// Test whether the pin is interruptable
+bool INTERRUPT_PIN(const pin_t p);

 // Get the pin number at the given index
-constexpr pin_t GET_PIN_MAP_PIN(const int16_t ind) { return ind; }
+pin_t GET_PIN_MAP_PIN(const int16_t ind);

 // Parse a G-code word into a pin index
 int16_t PARSED_PIN_INDEX(const char code, const int16_t dval);
@@ -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
-  HAL_reboot();
-}
+void flashFirmware(const int16_t) { NVIC_SystemReset(); }

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

-void HAL_reboot() { NVIC_SystemReset(); }
-
 #endif // TARGET_LPC1768
@@ -60,60 +60,45 @@ 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 0 to 3. You can also use -1 if the board supports Native USB."
+  #error "SERIAL_PORT must be from -1 to 3. Please update your configuration."
 #endif

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

 #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
-    #error "MMU2_SERIAL_PORT must be from 0 to 3. You can also use -1 if the board supports Native USB."
+    #error "MMU2_SERIAL_PORT must be from -1 to 3. Please update your configuration."
  #endif
 #endif

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

@@ -198,7 +183,7 @@ constexpr pin_t GET_PIN_MAP_PIN(const int16_t index) {
 // Parse a G-code word into a pin index
 int16_t PARSED_PIN_INDEX(const char code, const int16_t dval);
 // P0.6 thru P0.9 are for the onboard SD card
-#define HAL_SENSITIVE_PINS P0_06, P0_07, P0_08, P0_09,
+#define HAL_SENSITIVE_PINS P0_06, P0_07, P0_08, P0_09

 #define HAL_IDLETASK 1
 void HAL_idletask();
@@ -228,4 +213,17 @@ void set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size=255,
 void HAL_clear_reset_source(void);
 uint8_t HAL_get_reset_source(void);

-void HAL_reboot();
+inline void HAL_reboot() {}  // reboot the board or restart the bootloader
+
+// 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,51 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#ifdef TARGET_LPC1768
-
-#include "../../inc/MarlinConfig.h"
-#include "HAL.h"
-
-#if ENABLED(POSTMORTEM_DEBUGGING)
-
-#include "../shared/HAL_MinSerial.h"
-#include <debug_frmwrk.h>
-
-static void TX(char c) { _DBC(c); }
-void install_min_serial() { HAL_min_serial_out = &TX; }
-
-#if DISABLED(DYNAMIC_VECTORTABLE)
-extern "C" {
-  __attribute__((naked)) void JumpHandler_ASM() {
-    __asm__ __volatile__ (
-      "b CommonHandler_ASM\n"
-    );
-  }
-  void __attribute__((naked, alias("JumpHandler_ASM"))) HardFault_Handler();
-  void __attribute__((naked, alias("JumpHandler_ASM"))) BusFault_Handler();
-  void __attribute__((naked, alias("JumpHandler_ASM"))) UsageFault_Handler();
-  void __attribute__((naked, alias("JumpHandler_ASM"))) MemManage_Handler();
-  void __attribute__((naked, alias("JumpHandler_ASM"))) NMI_Handler();
-}
-#endif
-
-#endif // POSTMORTEM_DEBUGGING
-#endif // TARGET_LPC1768
@@ -66,7 +66,11 @@

  #include <SoftwareSPI.h>

-  static uint8_t SPI_speed = SPI_FULL_SPEED;
+  #ifndef HAL_SPI_SPEED
+    #define HAL_SPI_SPEED SPI_FULL_SPEED
+  #endif
+
+  static uint8_t SPI_speed = HAL_SPI_SPEED;

  static uint8_t spiTransfer(uint8_t b) {
    return swSpiTransfer(b, SPI_speed, SD_SCK_PIN, SD_MISO_PIN, SD_MOSI_PIN);
@@ -89,12 +93,12 @@

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

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

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

 #else

-  #ifdef SD_SPI_SPEED
-    #define INIT_SPI_SPEED SD_SPI_SPEED
-  #else
-    #define INIT_SPI_SPEED SPI_FULL_SPEED
+  #ifndef HAL_SPI_SPEED
+    #ifdef SD_SPI_SPEED
+      #define HAL_SPI_SPEED SD_SPI_SPEED
+    #else
+      #define HAL_SPI_SPEED SPI_FULL_SPEED
+    #endif
  #endif

-  void spiBegin() { spiInit(INIT_SPI_SPEED); } // Set up SCK, MOSI & MISO pins for SSP0
+  void spiBegin() { spiInit(HAL_SPI_SPEED); } // Set up SCK, MOSI & MISO pins for SSP0

  void spiInit(uint8_t spiRate) {
    #if SD_MISO_PIN == BOARD_SPI1_MISO_PIN
@@ -129,13 +135,13 @@

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

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

  void spiSend(uint32_t chan, byte b) {}

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

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

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

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

-#include "../../inc/MarlinConfig.h"
-
-#if USING_HW_SERIAL0
-  MarlinSerial _MSerial0(LPC_UART0);
-  MSerialT MSerial0(true, _MSerial0);
-  extern "C" void UART0_IRQHandler() { _MSerial0.IRQHandler(); }
+#if USING_SERIAL_0
+  MarlinSerial MSerial(LPC_UART0);
+  extern "C" void UART0_IRQHandler() { MSerial.IRQHandler(); }
 #endif
-#if USING_HW_SERIAL1
-  MarlinSerial _MSerial1((LPC_UART_TypeDef *) LPC_UART1);
-  MSerialT MSerial1(true, _MSerial1);
-  extern "C" void UART1_IRQHandler() { _MSerial1.IRQHandler(); }
+#if USING_SERIAL_1
+  MarlinSerial MSerial1((LPC_UART_TypeDef *) LPC_UART1);
+  extern "C" void UART1_IRQHandler() { MSerial1.IRQHandler(); }
 #endif
-#if USING_HW_SERIAL2
-  MarlinSerial _MSerial2(LPC_UART2);
-  MSerialT MSerial2(true, _MSerial2);
-  extern "C" void UART2_IRQHandler() { _MSerial2.IRQHandler(); }
+#if USING_SERIAL_2
+  MarlinSerial MSerial2(LPC_UART2);
+  extern "C" void UART2_IRQHandler() { MSerial2.IRQHandler(); }
 #endif
-#if USING_HW_SERIAL3
-  MarlinSerial _MSerial3(LPC_UART3);
-  MSerialT MSerial3(true, _MSerial3);
-  extern "C" void UART3_IRQHandler() { _MSerial3.IRQHandler(); }
-#endif
-
-#if ENABLED(EMERGENCY_PARSER)
-
-  bool MarlinSerial::recv_callback(const char c) {
-    // Need to figure out which serial port we are and react in consequence (Marlin does not have CONTAINER_OF macro)
-    if (false) {}
-    #if USING_HW_SERIAL0
-      else if (this == &_MSerial0) emergency_parser.update(MSerial0.emergency_state, c);
-    #endif
-    #if USING_HW_SERIAL1
-      else if (this == &_MSerial1) emergency_parser.update(MSerial1.emergency_state, c);
-    #endif
-    #if USING_HW_SERIAL2
-      else if (this == &_MSerial2) emergency_parser.update(MSerial2.emergency_state, c);
-    #endif
-    #if USING_HW_SERIAL3
-      else if (this == &_MSerial3) emergency_parser.update(MSerial3.emergency_state, c);
-    #endif
-    return true;
-  }
-
+#if 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. Ignore for now 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
@@ -42,22 +42,25 @@ bool PersistentStore::access_start()  { eeprom_init(); return true; }
 bool PersistentStore::access_finish() { return true; }

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

@@ -65,6 +68,7 @@ bool PersistentStore::read_data(int &pos, uint8_t *value, size_t size, uint16_t
  do {
    // Read from external EEPROM
    const uint8_t c = eeprom_read_byte((uint8_t*)pos);
+
    if (writing) *value = c;
    crc16(crc, &c, 1);
    pos++;
@@ -122,37 +122,4 @@ void setup_endstop_interrupts() {
    #endif
    _ATTACH(Z_MIN_PROBE_PIN);
  #endif
-  #if HAS_I_MAX
-    #if !LPC1768_PIN_INTERRUPT_M(I_MAX_PIN)
-      #error "I_MAX_PIN is not INTERRUPT-capable."
-    #endif
-    _ATTACH(I_MAX_PIN);
-  #elif HAS_I_MIN
-    #if !LPC1768_PIN_INTERRUPT_M(I_MIN_PIN)
-      #error "I_MIN_PIN is not INTERRUPT-capable."
-    #endif
-    _ATTACH(I_MIN_PIN);
-  #endif
-  #if HAS_J_MAX
-    #if !LPC1768_PIN_INTERRUPT_M(J_MAX_PIN)
-      #error "J_MAX_PIN is not INTERRUPT-capable."
-    #endif
-    _ATTACH(J_MAX_PIN);
-  #elif HAS_J_MIN
-    #if !LPC1768_PIN_INTERRUPT_M(J_MIN_PIN)
-      #error "J_MIN_PIN is not INTERRUPT-capable."
-    #endif
-    _ATTACH(J_MIN_PIN);
-  #endif
-  #if HAS_K_MAX
-    #if !LPC1768_PIN_INTERRUPT_M(K_MAX_PIN)
-      #error "K_MAX_PIN is not INTERRUPT-capable."
-    #endif
-    _ATTACH(K_MAX_PIN);
-  #elif HAS_K_MIN
-    #if !LPC1768_PIN_INTERRUPT_M(K_MIN_PIN)
-      #error "K_MIN_PIN is not INTERRUPT-capable."
-    #endif
-    _ATTACH(K_MIN_PIN);
-  #endif
 }
@@ -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 USING_HW_SERIAL0
+#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 USING_HW_SERIAL1
+#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 USING_HW_SERIAL2
+#if USING_SERIAL_2
  #define IS_TX2(P) (P == P0_10)
  #define IS_RX2(P) (P == P0_11)
  #define _IS_TX2_1 IS_TX2
@@ -144,9 +144,9 @@ static_assert(DISABLED(BAUD_RATE_GCODE), "BAUD_RATE_GCODE is not yet supported o
    #error "Serial port pins (2) conflict with Z4 pins!"
  #elif ANY_RX(2, X_DIR_PIN, Y_DIR_PIN)
    #error "Serial port pins (2) conflict with other pins!"
-  #elif Y_HOME_TO_MIN && IS_TX2(Y_STOP_PIN)
+  #elif Y_HOME_DIR < 0 && IS_TX2(Y_STOP_PIN)
    #error "Serial port pins (2) conflict with Y endstop pin!"
-  #elif USES_Z_MIN_PROBE_PIN && IS_TX2(Z_MIN_PROBE_PIN)
+  #elif HAS_CUSTOM_PROBE_PIN && IS_TX2(Z_MIN_PROBE_PIN)
    #error "Serial port pins (2) conflict with probe pin!"
  #elif ANY_TX(2, X_ENABLE_PIN, Y_ENABLE_PIN) || ANY_RX(2, X_DIR_PIN, Y_DIR_PIN)
    #error "Serial port pins (2) conflict with X/Y stepper pins!"
@@ -161,7 +161,7 @@ static_assert(DISABLED(BAUD_RATE_GCODE), "BAUD_RATE_GCODE is not yet supported o
  #undef _IS_RX2_1
 #endif

-#if USING_HW_SERIAL3
+#if 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)
@@ -237,7 +237,7 @@ static_assert(DISABLED(BAUD_RATE_GCODE), "BAUD_RATE_GCODE is not yet supported o
    #define PIN_IS_SCL2(P) (P##_PIN == P0_11)
    #if PIN_IS_SDA2(Y_STOP)
      #error "i2c SDA2 overlaps with Y endstop pin!"
-    #elif USES_Z_MIN_PROBE_PIN && PIN_IS_SDA2(Z_MIN_PROBE)
+    #elif HAS_CUSTOM_PROBE_PIN && PIN_IS_SDA2(Z_MIN_PROBE)
      #error "i2c SDA2 overlaps with Z probe pin!"
    #elif PIN_IS_SDA2(X_ENABLE) || PIN_IS_SDA2(Y_ENABLE)
      #error "i2c SDA2 overlaps with X/Y ENABLE pin!"
@@ -270,7 +270,7 @@ static_assert(DISABLED(BAUD_RATE_GCODE), "BAUD_RATE_GCODE is not yet supported o
 #endif

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

 void SysTick_Callback() { disk_timerproc(); }

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

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

  USB_Init();                               // USB Initialization
-  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
@@ -22,7 +22,7 @@

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

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

 #include "xpt2046.h"
 #include <SPI.h>
@@ -54,7 +54,7 @@ enum XPTCoordinate : uint8_t {
  XPT2046_Z2 = 0x40 | XPT2046_CONTROL | XPT2046_DFR_MODE,
 };

-#ifndef XPT2046_Z1_THRESHOLD
+#if !defined(XPT2046_Z1_THRESHOLD)
  #define XPT2046_Z1_THRESHOLD 10
 #endif

@@ -59,7 +59,7 @@

 #if HAS_MARLINUI_U8GLIB

-#include <U8glib-HAL.h>
+#include <U8glib.h>
 #include "../../shared/HAL_SPI.h"

 #ifndef LCD_SPI_SPEED
@@ -79,7 +79,7 @@

 #if HAS_MARLINUI_U8GLIB

-#include <U8glib-HAL.h>
+#include <U8glib.h>

 #define I2C_SLA         (0x3C*2)
 //#define I2C_CMD_MODE  0x080
@@ -59,14 +59,14 @@

 #if HAS_MARLINUI_U8GLIB

-#include <U8glib-HAL.h>
+#include <U8glib.h>
 #include "../../shared/HAL_SPI.h"
 #include "../../shared/Delay.h"

 void spiBegin();
 void spiInit(uint8_t spiRate);
 void spiSend(uint8_t b);
-void spiSend(const uint8_t *buf, size_t n);
+void spiSend(const uint8_t* buf, size_t n);

 static uint8_t rs_last_state = 255;

@@ -59,7 +59,7 @@

 #if ENABLED(U8GLIB_ST7920)

-#include <U8glib-HAL.h>
+#include <U8glib.h>
 #include <SoftwareSPI.h>
 #include "../../shared/Delay.h"
 #include "../../shared/HAL_SPI.h"
@@ -71,7 +71,7 @@
 #include <LPC17xx.h>
 #include <gpio.h>

-#include <U8glib-HAL.h>
+#include <U8glib.h>

 uint8_t swSpiTransfer_mode_0(uint8_t b, const uint8_t spi_speed, const pin_t sck_pin, const pin_t miso_pin, const pin_t mosi_pin ) {

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

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

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

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

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

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

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

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

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

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

 EmergencyParser::State emergency_state;

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

--- 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