Update Configuration_adv.h

Merge branch 'bugfix-2.0.x' into FunmatHT
Merge branch 'bugfix-2.0.x' of https://github.com/MarlinFirmware/Marlin into bugfix-2.0.x
2021-03-20 13:42:07 -04:00 · 2021-03-20 12:30:49 -04:00 · 2021-03-20 11:16:35 -04:00 · 2021-03-20 11:16:23 -04:00 · 2021-03-12 16:16:33 -05:00 · 2020-08-01 12:56:16 -04:00
1448 changed files with 29124 additions and 55063 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
@@ -56,31 +56,28 @@ jobs:

        # STM32F1 (Maple) Environments

-        #- STM32F103RC_btt_maple
-        - STM32F103RC_btt_USB_maple
+        - STM32F103RC_btt
+        - STM32F103RC_btt_USB
+        - STM32F103RE_btt
+        - STM32F103RE_btt_USB
        - STM32F103RC_fysetc
        - STM32F103RC_meeb
        - jgaurora_a5s_a1
        - STM32F103VE_longer
-        #- mks_robin_maple
+        - mks_robin
        - mks_robin_lite
        - mks_robin_pro
-        #- mks_robin_nano35_maple
-        #- STM32F103RET6_creality_maple
+        - STM32F103RET6_creality
+        - mks_robin_nano35

        # STM32 (ST) Environments

-        - STM32F103RC_btt
-        #- STM32F103RC_btt_USB
-        - STM32F103RE_btt
-        - STM32F103RE_btt_USB
-        - STM32F103RET6_creality
        - STM32F407VE_black
        - STM32F401VE_STEVAL
        - BIGTREE_BTT002
        - BIGTREE_SKR_PRO
        - BIGTREE_GTR_V1_0
-        - mks_robin
+        - mks_robin_stm32
        - ARMED
        - FYSETC_S6
        - STM32F070CB_malyan
@@ -89,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

@@ -104,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
@@ -137,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 }}
@@ -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
@@ -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)
@@ -993,5 +993,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-07-31"
+//#define STRING_DISTRIBUTION_DATE "2019-07-10"

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

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

  #include "../../sd/SdFatUtil.h"
@@ -93,35 +93,28 @@ typedef int8_t pin_t;
  #define MYSERIAL1 TERN(BLUETOOTH, btSerial, MSerial0)
 #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

  #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
-  #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 +135,7 @@ void HAL_init();
 inline void HAL_clear_reset_source() { MCUSR = 0; }
 inline uint8_t HAL_get_reset_source() { return MCUSR; }

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

 #if GCC_VERSION <= 50000
  #pragma GCC diagnostic push
@@ -186,7 +179,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]);
@@ -454,7 +454,7 @@ void MarlinSerial<Cfg>::flush() {
 }

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

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

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

 template<typename Cfg>
@@ -567,7 +568,7 @@ ISR(SERIAL_REGNAME(USART, SERIAL_PORT, _UDRE_vect)) {

 // 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);
+MSerialT customizedSerial1(MSerialT::HasEmergencyParser);

 #ifdef SERIAL_PORT_2

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

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

 #ifdef MMU2_SERIAL_PORT

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

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

 #ifdef LCD_SERIAL_PORT

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

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

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

-#endif // LCD_SERIAL_PORT
+#endif

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

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

 #endif // __AVR__
@@ -210,7 +210,7 @@
    static int read();
    static void flush();
    static ring_buffer_pos_t available();
-    static void write(const uint8_t c);
+    static size_t write(const uint8_t c);
    static void flushTX();
    #if HAS_DGUS_LCD
      static ring_buffer_pos_t get_tx_buffer_free();
@@ -238,19 +238,14 @@
    static constexpr bool MAX_RX_QUEUED     = ENABLED(SERIAL_STATS_MAX_RX_QUEUED);
  };

-  typedef Serial1Class< MarlinSerial< MarlinSerialCfg<SERIAL_PORT> > > MSerialT1;
-  extern MSerialT1 customizedSerial1;
+  typedef Serial1Class< MarlinSerial< MarlinSerialCfg<SERIAL_PORT> > > MSerialT;
+  extern MSerialT 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;
-  #endif
-
 #endif // !USBCON

 #ifdef MMU2_SERIAL_PORT
@@ -267,8 +262,8 @@
    static constexpr bool RX_OVERRUNS       = false;
  };

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

 #ifdef LCD_SERIAL_PORT
@@ -286,12 +281,12 @@
    static constexpr bool RX_OVERRUNS       = BOTH(HAS_DGUS_LCD, SERIAL_STATS_RX_BUFFER_OVERRUNS);
  };

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

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

 bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
-  uint16_t written = 0;
  while (size--) {
    uint8_t * const p = (uint8_t * const)pos;
    uint8_t v = *value;
-    if (v != eeprom_read_byte(p)) { // EEPROM has only ~100,000 write cycles, so only write bytes that have changed!
+    // EEPROM has only ~100,000 write cycles,
+    // so only write bytes that have changed!
+    if (v != eeprom_read_byte(p)) {
      eeprom_write_byte(p, v);
-      if (++written & 0x7F) delay(2); else safe_delay(2); // Avoid triggering watchdog during long EEPROM writes
      if (eeprom_read_byte(p) != v) {
        SERIAL_ECHO_MSG(STR_ERR_EEPROM_WRITE);
        return true;
@@ -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.
@@ -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
@@ -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;
@@ -77,8 +77,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);
@@ -108,16 +106,16 @@ uint16_t HAL_adc_get_result() {
 }

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

@@ -50,12 +50,13 @@ extern DefaultSerial4 MSerial3;
 #define _MSERIAL(X) MSerial##X
 #define MSERIAL(X) _MSERIAL(X)

+// Define MYSERIAL1/2 before MarlinSerial includes!
 #if SERIAL_PORT == -1 || ENABLED(EMERGENCY_PARSER)
  #define MYSERIAL1 customizedSerial1
 #elif WITHIN(SERIAL_PORT, 0, 3)
  #define MYSERIAL1 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
@@ -64,17 +65,7 @@ extern DefaultSerial4 MSerial3;
  #elif WITHIN(SERIAL_PORT_2, 0, 3)
    #define MYSERIAL2 MSERIAL(SERIAL_PORT_2)
  #else
-    #error "SERIAL_PORT_2 must be from 0 to 3, or -1 for USB Serial."
-  #endif
-#endif
-
-#ifdef SERIAL_PORT_3
-  #if SERIAL_PORT_3 == -1 || ENABLED(EMERGENCY_PARSER)
-    #define MYSERIAL3 customizedSerial3
-  #elif WITHIN(SERIAL_PORT_3, 0, 3)
-    #define MYSERIAL3 MSERIAL(SERIAL_PORT_3)
-  #else
-    #error "SERIAL_PORT_3 must be from 0 to 3, or -1 for USB Serial."
+    #error "SERIAL_PORT_2 must be from -1 to 3. Please update your configuration."
  #endif
 #endif

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

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

@@ -120,7 +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
@@ -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 = 4 * (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_CYCLES(spiDelayCyclesX4);

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

      WRITE(SD_SCK_PIN, LOW);
-      DELAY_NS(spiDelayNS);
+      DELAY_CYCLES(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,13 +425,13 @@
    );
  }

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

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

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

-  void spiSendBlock(uint8_t token, const uint8_t *buf) {
+  void spiSendBlock(uint8_t token, const uint8_t* buf) {
    _SS_WRITE(LOW);
    (void)spiTransferTx(token);
    spiTxBlock(buf, 512);
@@ -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) << 2; // spiRate of 2 gives the maximum error with current CPU
        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]);
@@ -476,9 +476,9 @@ void MarlinSerial<Cfg>::flushTX() {


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

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

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

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

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

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

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

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

  pending_char = udi_cdc_getc();

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

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

  int c = udi_cdc_getc();

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

  return c;
 }
@@ -129,13 +129,10 @@ size_t MarlinSerialUSB::write(const uint8_t c) {

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

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

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

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

 struct MarlinSerialUSB {
  void begin(const long);
@@ -48,18 +50,14 @@ struct MarlinSerialUSB {
    FORCE_INLINE int rxMaxEnqueued() { return 0; }
  #endif
 };
+typedef Serial1Class<MarlinSerialUSB> MSerialT;

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

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

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

 #if HAS_MARLINUI_U8GLIB

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

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

@@ -62,7 +62,7 @@
 #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
@@ -62,7 +62,7 @@
 #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!!
 */

@@ -32,7 +32,7 @@ Ctrl_status sd_mmc_spi_test_unit_ready() {
 Ctrl_status sd_mmc_spi_read_capacity(uint32_t *nb_sector) {
  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted())
    return CTRL_NO_PRESENT;
-  *nb_sector = card.diskIODriver()->cardSize() - 1;
+  *nb_sector = card.getSd2Card().cardSize() - 1;
  return CTRL_GOOD;
 }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      // And copy it to the proper place, expanding it to unicode
      sptr = &diam[0];
@@ -141,8 +141,6 @@ void HAL_clear_reset_source() { }

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

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

 // return free memory between end of heap (or end bss) and whatever is current
@@ -101,7 +101,7 @@ void HAL_clear_reset_source();
 // reset reason
 uint8_t HAL_get_reset_source();

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

 void _delay_ms(int delay);

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

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

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

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

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

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

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

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

-typedef Serial1Class<WebSocketSerial> MSerialWebSocketT;
-extern MSerialWebSocketT webSocketSerial;
+typedef Serial1Class<WebSocketSerial> MSerialT;
+extern MSerialT 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) {
@@ -73,6 +73,4 @@ void HAL_pwm_init() {

 }

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

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

 /* ---------------- Delay in cycles */
 FORCE_INLINE static void DELAY_CYCLES(uint64_t x) {
@@ -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;
@@ -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)
@@ -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 interruptable
-constexpr bool INTERRUPT_PIN(const pin_t p) { return false; }
+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);
@@ -67,7 +67,7 @@ void flashFirmware(const int16_t) {
  delay(500);          // Give OS time to disconnect
  USB_Connect(false);  // USB clear connection
  delay(1000);         // Give OS time to notice
-  HAL_reboot();
+  NVIC_SystemReset();
 }

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

-void HAL_reboot() { NVIC_SystemReset(); }
-
 #endif // TARGET_LPC1768
@@ -71,7 +71,7 @@ extern DefaultSerial1 USBSerial;
 #elif WITHIN(SERIAL_PORT, 0, 3)
  #define MYSERIAL1 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
@@ -80,17 +80,7 @@ extern DefaultSerial1 USBSerial;
  #elif WITHIN(SERIAL_PORT_2, 0, 3)
    #define MYSERIAL2 MSERIAL(SERIAL_PORT_2)
  #else
-    #error "SERIAL_PORT_2 must be from 0 to 3. You can also use -1 if the board supports Native USB."
-  #endif
-#endif
-
-#ifdef SERIAL_PORT_3
-  #if SERIAL_PORT_3 == -1
-    #define MYSERIAL3 USBSerial
-  #elif WITHIN(SERIAL_PORT_3, 0, 3)
-    #define MYSERIAL3 MSERIAL(SERIAL_PORT_3)
-  #else
-    #error "SERIAL_PORT_3 must be from 0 to 3. You can also use -1 if the board supports Native USB."
+    #error "SERIAL_PORT_2 must be from -1 to 3. Please update your configuration."
  #endif
 #endif

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

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

@@ -198,7 +185,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 +215,4 @@ void set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size=255,
 void HAL_clear_reset_source(void);
 uint8_t HAL_get_reset_source(void);

-void HAL_reboot();
+inline void HAL_reboot() {}  // reboot the board or restart the bootloader
@@ -21,7 +21,6 @@
 */
 #ifdef TARGET_LPC1768

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

 #if ENABLED(POSTMORTEM_DEBUGGING)
@@ -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,26 +21,25 @@
 */
 #ifdef TARGET_LPC1768

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

-#include "../../inc/MarlinConfig.h"
-
-#if USING_HW_SERIAL0
-  MarlinSerial _MSerial0(LPC_UART0);
-  MSerialT MSerial0(true, _MSerial0);
-  extern "C" void UART0_IRQHandler() { _MSerial0.IRQHandler(); }
+#if ANY_SERIAL_IS(0)
+  MarlinSerial _MSerial(LPC_UART0);
+  MSerialT MSerial0(true, _MSerial);
+  extern "C" void UART0_IRQHandler() { _MSerial.IRQHandler(); }
 #endif
-#if USING_HW_SERIAL1
+#if ANY_SERIAL_IS(1)
  MarlinSerial _MSerial1((LPC_UART_TypeDef *) LPC_UART1);
  MSerialT MSerial1(true, _MSerial1);
  extern "C" void UART1_IRQHandler() { _MSerial1.IRQHandler(); }
 #endif
-#if USING_HW_SERIAL2
+#if ANY_SERIAL_IS(2)
  MarlinSerial _MSerial2(LPC_UART2);
  MSerialT MSerial2(true, _MSerial2);
  extern "C" void UART2_IRQHandler() { _MSerial2.IRQHandler(); }
 #endif
-#if USING_HW_SERIAL3
+#if ANY_SERIAL_IS(3)
  MarlinSerial _MSerial3(LPC_UART3);
  MSerialT MSerial3(true, _MSerial3);
  extern "C" void UART3_IRQHandler() { _MSerial3.IRQHandler(); }
@@ -51,16 +50,16 @@
  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);
+    #if ANY_SERIAL_IS(0)
+      else if (this == &_MSerial) emergency_parser.update(MSerial0.emergency_state, c);
    #endif
-    #if USING_HW_SERIAL1
+    #if ANY_SERIAL_IS(1)
      else if (this == &_MSerial1) emergency_parser.update(MSerial1.emergency_state, c);
    #endif
-    #if USING_HW_SERIAL2
+    #if ANY_SERIAL_IS(2)
      else if (this == &_MSerial2) emergency_parser.update(MSerial2.emergency_state, c);
    #endif
-    #if USING_HW_SERIAL3
+    #if ANY_SERIAL_IS(3)
      else if (this == &_MSerial3) emergency_parser.update(MSerial3.emergency_state, c);
    #endif
    return true;
@@ -60,8 +60,8 @@ 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.
+// Consequently, we can't use a RuntimeSerial either. The workaround would be to use a RuntimeSerial<ForwardSerial<MarlinSerial>> type here
+// Right now, let's ignore this until it's actually required.
 #if ENABLED(SERIAL_RUNTIME_HOOK)
  #error "SERIAL_RUNTIME_HOOK is not yet supported for LPC176x."
 #endif
@@ -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
 }
@@ -92,7 +92,7 @@ static_assert(DISABLED(BAUD_RATE_GCODE), "BAUD_RATE_GCODE is not yet supported o
 #define ANY_TX(N,V...) DO(IS_TX##N,||,V)
 #define ANY_RX(N,V...) DO(IS_RX##N,||,V)

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

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

-#if USING_HW_SERIAL2
+#if ANY_SERIAL_IS(2)
  #define IS_TX2(P) (P == P0_10)
  #define IS_RX2(P) (P == P0_11)
  #define _IS_TX2_1 IS_TX2
@@ -144,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 ANY_SERIAL_IS(3)
  #define PIN_IS_TX3(P) (PIN_EXISTS(P) && P##_PIN == P0_00)
  #define PIN_IS_RX3(P) (P##_PIN == P0_01)
  #if PIN_IS_TX3(X_MIN) || PIN_IS_RX3(X_MAX)
@@ -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!"
@@ -117,7 +117,7 @@ void HAL_init() {
    PinCfg.Pinmode = 2;    // no pull-up/pull-down
    PINSEL_ConfigPin(&PinCfg);
    // now set CLKOUT_EN bit
-    SBI(LPC_SC->CLKOUTCFG, 8);
+    LPC_SC->CLKOUTCFG |= (1<<8);
  #endif

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

@@ -20,104 +20,101 @@ 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,string
+		from ctypes import windll

-			# 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))
@@ -1,217 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- *
- * Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- * Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
- * Copyright (c) 2015-2016 Nico Tonnhofer wurstnase.reprap@gmail.com
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-#define CPU_32_BIT
-#define HAL_IDLETASK
-void HAL_idletask();
-
-#define F_CPU 100000000
-#define SystemCoreClock F_CPU
-#include <stdint.h>
-#include <stdarg.h>
-
-#undef min
-#undef max
-
-#include <algorithm>
-#include "pinmapping.h"
-
-void _printf (const  char *format, ...);
-void _putc(uint8_t c);
-uint8_t _getc();
-
-//extern "C" volatile uint32_t _millis;
-
-//arduino: Print.h
-#define DEC 10
-#define HEX 16
-#define OCT  8
-#define BIN  2
-//arduino: binary.h (weird defines)
-#define B01 1
-#define B10 2
-
-#include "../shared/Marduino.h"
-#include "../shared/math_32bit.h"
-#include "../shared/HAL_SPI.h"
-#include "fastio.h"
-#include "watchdog.h"
-#include "serial.h"
-
-#define SHARED_SERVOS HAS_SERVOS
-
-extern MSerialT serial_stream_0;
-extern MSerialT serial_stream_1;
-extern MSerialT serial_stream_2;
-extern MSerialT serial_stream_3;
-
-#define _MSERIAL(X) serial_stream_##X
-#define MSERIAL(X) _MSERIAL(X)
-
-#if WITHIN(SERIAL_PORT, 0, 3)
-  #define MYSERIAL1 MSERIAL(SERIAL_PORT)
-#else
-  #error "SERIAL_PORT must be from 0 to 3. Please update your configuration."
-#endif
-
-#ifdef SERIAL_PORT_2
-  #if WITHIN(SERIAL_PORT_2, 0, 3)
-    #define MYSERIAL2 MSERIAL(SERIAL_PORT_2)
-  #else
-    #error "SERIAL_PORT_2 must be from 0 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)
-  #else
-    #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)
-    #define LCD_SERIAL MSERIAL(LCD_SERIAL_PORT)
-  #else
-    #error "LCD_SERIAL_PORT must be from 0 to 3. Please update your configuration."
-  #endif
-#endif
-
-
-#define ST7920_DELAY_1 DELAY_NS(600)
-#define ST7920_DELAY_2 DELAY_NS(750)
-#define ST7920_DELAY_3 DELAY_NS(750)
-
-//
-// Interrupts
-//
-#define CRITICAL_SECTION_START()
-#define CRITICAL_SECTION_END()
-#define ISRS_ENABLED()
-#define ENABLE_ISRS()
-#define DISABLE_ISRS()
-
-inline void HAL_init() {}
-
-// Utility functions
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-function"
-int freeMemory();
-#pragma GCC diagnostic pop
-
-// ADC
-#define HAL_ADC_VREF           5.0
-#define HAL_ADC_RESOLUTION    10
-#define HAL_ANALOG_SELECT(ch) HAL_adc_enable_channel(ch)
-#define HAL_START_ADC(ch)     HAL_adc_start_conversion(ch)
-#define HAL_READ_ADC()        HAL_adc_get_result()
-#define HAL_ADC_READY()       true
-
-void HAL_adc_init();
-void HAL_adc_enable_channel(const uint8_t ch);
-void HAL_adc_start_conversion(const uint8_t ch);
-uint16_t HAL_adc_get_result();
-
-// Reset source
-inline void HAL_clear_reset_source(void) {}
-inline uint8_t HAL_get_reset_source(void) { return RST_POWER_ON; }
-
-/* ---------------- Delay in cycles */
-
-#define DELAY_CYCLES(x) Kernel::delayCycles(x)
-#define SYSTEM_YIELD() Kernel::yield()
-
-// Maple Compatibility
-typedef void (*systickCallback_t)(void);
-void systick_attach_callback(systickCallback_t cb);
-extern volatile uint32_t systick_uptime_millis;
-
-// Marlin uses strstr in constexpr context, this is not supported, workaround by defining constexpr versions of the required functions.
-#define strstr(a, b) strstr_constexpr((a), (b))
-
-constexpr inline std::size_t strlen_constexpr(const char* str) {
-  // https://github.com/gcc-mirror/gcc/blob/5c7634a0e5f202935aa6c11b6ea953b8bf80a00a/libstdc%2B%2B-v3/include/bits/char_traits.h#L329
-  if (str != nullptr) {
-    std::size_t i = 0;
-    while (str[i] != '\0') {
-      ++i;
-    }
-
-    return i;
-  }
-
-  return 0;
-}
-
-constexpr inline int strncmp_constexpr(const char* lhs, const char* rhs, std::size_t count) {
-  // https://github.com/gcc-mirror/gcc/blob/13b9cbfc32fe3ac4c81c4dd9c42d141c8fb95db4/libstdc%2B%2B-v3/include/bits/char_traits.h#L655
-  if (lhs == nullptr || rhs == nullptr) {
-    return rhs != nullptr ? -1 : 1;
-  }
-
-  for (std::size_t i = 0; i < count; ++i) {
-    if (lhs[i] != rhs[i]) {
-      return lhs[i] < rhs[i] ? -1 : 1;
-    } else if (lhs[i] == '\0') {
-      return 0;
-    }
-  }
-
-  return 0;
-}
-
-constexpr inline const char* strstr_constexpr(const char* str, const char* target) {
-  // https://github.com/freebsd/freebsd/blob/master/sys/libkern/strstr.c
-  if (char c = target != nullptr ? *target++ : '\0'; c != '\0' && str != nullptr) {
-    std::size_t len = strlen_constexpr(target);
-    do {
-      char sc = {};
-      do {
-        if ((sc = *str++) == '\0') {
-          return nullptr;
-        }
-      } while (sc != c);
-    } while (strncmp_constexpr(str, target, len) != 0);
-    --str;
-  }
-
-  return str;
-}
-
-constexpr inline char* strstr_constexpr(char* str, const char* target) {
-  // https://github.com/freebsd/freebsd/blob/master/sys/libkern/strstr.c
-  if (char c = target != nullptr ? *target++ : '\0'; c != '\0' && str != nullptr) {
-    std::size_t len = strlen_constexpr(target);
-    do {
-      char sc = {};
-      do {
-        if ((sc = *str++) == '\0') {
-          return nullptr;
-        }
-      } while (sc != c);
-    } while (strncmp_constexpr(str, target, len) != 0);
-    --str;
-  }
-  return str;
-}
@@ -1,26 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- *
- * Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- * Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
- * Copyright (c) 2015-2016 Nico Tonnhofer wurstnase.reprap@gmail.com
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-#include <SPI.h>
-
-using MarlinSPI = SPIClass;
@@ -1,111 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-/**
- * Fast I/O Routines for X86_64
- */
-
-#include "../shared/Marduino.h"
-#include <pinmapping.h>
-
-#define SET_DIR_INPUT(IO)     Gpio::setDir(IO, 1)
-#define SET_DIR_OUTPUT(IO)    Gpio::setDir(IO, 0)
-
-#define SET_MODE(IO, mode)    Gpio::setMode(IO, mode)
-
-#define WRITE_PIN_SET(IO)     Gpio::set(IO)
-#define WRITE_PIN_CLR(IO)     Gpio::clear(IO)
-
-#define READ_PIN(IO)          Gpio::get(IO)
-#define WRITE_PIN(IO,V)       Gpio::set(IO, V)
-
-/**
- * Magic I/O routines
- *
- * Now you can simply SET_OUTPUT(STEP); WRITE(STEP, HIGH); WRITE(STEP, LOW);
- *
- * Why double up on these macros? see http://gcc.gnu.org/onlinedocs/cpp/Stringification.html
- */
-
-/// Read a pin
-#define _READ(IO)             READ_PIN(IO)
-
-/// Write to a pin
-#define _WRITE(IO,V)          WRITE_PIN(IO,V)
-
-/// toggle a pin
-#define _TOGGLE(IO)          _WRITE(IO, !READ(IO))
-
-/// set pin as input
-#define _SET_INPUT(IO)        SET_DIR_INPUT(IO)
-
-/// set pin as output
-#define _SET_OUTPUT(IO)       SET_DIR_OUTPUT(IO)
-
-/// set pin as input with pullup mode
-#define _PULLUP(IO,V)         pinMode(IO, (V) ? INPUT_PULLUP : INPUT)
-
-/// set pin as input with pulldown mode
-#define _PULLDOWN(IO,V)       pinMode(IO, (V) ? INPUT_PULLDOWN : INPUT)
-
-// hg42: all pins can be input or output (I hope)
-// hg42: undefined pins create compile error (IO, is no pin)
-// hg42: currently not used, but was used by pinsDebug
-
-/// check if pin is an input
-#define _IS_INPUT(IO)         (IO >= 0)
-
-/// check if pin is an output
-#define _IS_OUTPUT(IO)        (IO >= 0)
-
-/// Read a pin wrapper
-#define READ(IO)             _READ(IO)
-
-/// Write to a pin wrapper
-#define WRITE(IO,V)          _WRITE(IO,V)
-
-/// toggle a pin wrapper
-#define TOGGLE(IO)           _TOGGLE(IO)
-
-/// set pin as input wrapper
-#define SET_INPUT(IO)        _SET_INPUT(IO)
-/// set pin as input with pullup wrapper
-#define SET_INPUT_PULLUP(IO)  do{ _SET_INPUT(IO); _PULLUP(IO, HIGH); }while(0)
-/// set pin as input with pulldown wrapper
-#define SET_INPUT_PULLDOWN(IO) do{ _SET_INPUT(IO); _PULLDOWN(IO, HIGH); }while(0)
-/// set pin as output wrapper  -  reads the pin and sets the output to that value
-#define SET_OUTPUT(IO)        do{ _WRITE(IO, _READ(IO)); _SET_OUTPUT(IO); }while(0)
-// set pin as PWM
-#define SET_PWM(IO)           SET_OUTPUT(IO)
-
-/// check if pin is an input wrapper
-#define IS_INPUT(IO)         _IS_INPUT(IO)
-/// check if pin is an output wrapper
-#define IS_OUTPUT(IO)        _IS_OUTPUT(IO)
-
-// Shorthand
-#define OUT_WRITE(IO,V)       do{ SET_OUTPUT(IO); WRITE(IO,V); }while(0)
-
-// digitalRead/Write wrappers
-#define extDigitalRead(IO)    digitalRead(IO)
-#define extDigitalWrite(IO,V) digitalWrite(IO,V)
@@ -1,22 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
@@ -1,31 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-// Add strcmp_P if missing
-#ifndef strcmp_P
-  #define strcmp_P(a, b) strcmp((a), (b))
-#endif
-
-#ifndef strcat_P
-  #define strcat_P(dest, src) strcat((dest), (src))
-#endif
@@ -1,22 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
@@ -1,43 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-/**
- * Test X86_64-specific configuration values for errors at compile-time.
- */
-
-// Emulating RAMPS
-#if ENABLED(SPINDLE_LASER_PWM) && !(SPINDLE_LASER_PWM_PIN == 4 || SPINDLE_LASER_PWM_PIN == 6 || SPINDLE_LASER_PWM_PIN == 11)
-  #error "SPINDLE_LASER_PWM_PIN must use SERVO0, SERVO1 or SERVO3 connector"
-#endif
-
-#if ENABLED(FAST_PWM_FAN) || SPINDLE_LASER_FREQUENCY
-  #error "Features requiring Hardware PWM (FAST_PWM_FAN, SPINDLE_LASER_FREQUENCY) are not yet supported on LINUX."
-#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."
-#endif
@@ -1,59 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * 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/>.
- *
- */
-
-/**
- * Support routines for X86_64
- */
-
-/**
- * Translation of routines & variables used by pinsDebug.h
- */
-
-#define NUMBER_PINS_TOTAL NUM_DIGITAL_PINS
-#define pwm_details(pin) pin = pin    // do nothing  // print PWM details
-#define pwm_status(pin) false //Print a pin's PWM status. Return true if it's currently a PWM pin.
-#define IS_ANALOG(P) (DIGITAL_PIN_TO_ANALOG_PIN(P) >= 0 ? 1 : 0)
-#define digitalRead_mod(p)  digitalRead(p)
-#define PRINT_PORT(p)
-#define GET_ARRAY_PIN(p) pin_array[p].pin
-#define PRINT_ARRAY_NAME(x) do{ sprintf_P(buffer, PSTR("%-" STRINGIFY(MAX_NAME_LENGTH) "s"), pin_array[x].name); SERIAL_ECHO(buffer); }while(0)
-#define PRINT_PIN(p) do{ sprintf_P(buffer, PSTR("%3d "), p); SERIAL_ECHO(buffer); }while(0)
-#define MULTI_NAME_PAD 16 // space needed to be pretty if not first name assigned to a pin
-
-// active ADC function/mode/code values for PINSEL registers
-constexpr int8_t ADC_pin_mode(pin_t pin) {
-  return (-1);
-}
-
-int8_t get_pin_mode(pin_t pin) {
-  if (!VALID_PIN(pin)) return -1;
-  return 0;
-}
-
-bool GET_PINMODE(pin_t pin) {
-  int8_t pin_mode = get_pin_mode(pin);
-  if (pin_mode == -1 || pin_mode == ADC_pin_mode(pin)) // found an invalid pin or active analog pin
-    return false;
-
-  return (Gpio::getMode(pin) != 0); //input/output state
-}
-
-bool GET_ARRAY_IS_DIGITAL(pin_t pin) {
-  return (!IS_ANALOG(pin) || get_pin_mode(pin) != ADC_pin_mode(pin));
-}
@@ -1,80 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-/**
- * servo.h - Interrupt driven Servo library for Arduino using 16 bit timers- Version 2
- * Copyright (c) 2009 Michael Margolis.  All right reserved.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library 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
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- */
-
-/**
- * Based on "servo.h - Interrupt driven Servo library for Arduino using 16 bit timers -
- *           Version 2 Copyright (c) 2009 Michael Margolis.  All right reserved.
- *
- * The only modification was to update/delete macros to match the LPC176x.
- *
- */
-
-#include <stdint.h>
-
-// Macros
-//values in microseconds
-#define MIN_PULSE_WIDTH       544     // the shortest pulse sent to a servo
-#define MAX_PULSE_WIDTH      2400     // the longest pulse sent to a servo
-#define DEFAULT_PULSE_WIDTH  1500     // default pulse width when servo is attached
-#define REFRESH_INTERVAL    20000     // minimum time to refresh servos in microseconds
-
-#define MAX_SERVOS             4
-
-#define INVALID_SERVO         255     // flag indicating an invalid servo index
-
-
-// Types
-
-typedef struct {
-  uint8_t nbr        : 8 ;            // a pin number from 0 to 254 (255 signals invalid pin)
-  uint8_t isActive   : 1 ;            // true if this channel is enabled, pin not pulsed if false
-} ServoPin_t;
-
-typedef struct {
-  ServoPin_t Pin;
-  unsigned int pulse_width;           // pulse width in microseconds
-} ServoInfo_t;
-
-// Global variables
-
-extern uint8_t ServoCount;
-extern ServoInfo_t servo_info[MAX_SERVOS];
@@ -1,55 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-#include "../../core/macros.h"
-#include "../../inc/MarlinConfigPre.h"
-
-#if BOTH(HAS_MARLINUI_U8GLIB, SDSUPPORT) && (LCD_PINS_D4 == SD_SCK_PIN || LCD_PINS_ENABLE == SD_MOSI_PIN || DOGLCD_SCK == SD_SCK_PIN || DOGLCD_MOSI == SD_MOSI_PIN)
-  #define LPC_SOFTWARE_SPI  // If the SD card and LCD adapter share the same SPI pins, then software SPI is currently
-                            // needed due to the speed and mode required for communicating with each device being different.
-                            // This requirement can be removed if the SPI access to these devices is updated to use
-                            // spiBeginTransaction.
-#endif
-
-// Onboard SD
-//#define SD_SCK_PIN     P0_07
-//#define SD_MISO_PIN    P0_08
-//#define SD_MOSI_PIN    P0_09
-//#define SD_SS_PIN      P0_06
-
-// External SD
-#ifndef SD_SCK_PIN
-  #define SD_SCK_PIN        50
-#endif
-#ifndef SD_MISO_PIN
-  #define SD_MISO_PIN       51
-#endif
-#ifndef SD_MOSI_PIN
-  #define SD_MOSI_PIN       52
-#endif
-#ifndef SD_SS_PIN
-  #define SD_SS_PIN         53
-#endif
-#ifndef SDSS
-  #define SDSS       SD_SS_PIN
-#endif
@@ -1,64 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-#include "../../../inc/MarlinConfig.h"
-
-#ifndef LCD_READ_ID
-  #define LCD_READ_ID  0x04   // Read display identification information (0xD3 on ILI9341)
-#endif
-#ifndef LCD_READ_ID4
-  #define LCD_READ_ID4 0xD3   // Read display identification information (0xD3 on ILI9341)
-#endif
-
-#define DATASIZE_8BIT    8
-#define DATASIZE_16BIT   16
-#define TFT_IO_DRIVER TFT_SPI
-
-#define DMA_MINC_ENABLE 1
-#define DMA_MINC_DISABLE 0
-
-class TFT_SPI {
-private:
-  static uint32_t ReadID(uint16_t Reg);
-  static void Transmit(uint16_t Data);
-  static void TransmitDMA(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Count);
-
-public:
-  // static SPIClass SPIx;
-
-  static void Init();
-  static uint32_t GetID();
-  static bool isBusy();
-  static void Abort();
-
-  static void DataTransferBegin(uint16_t DataWidth = DATASIZE_16BIT);
-  static void DataTransferEnd();
-  static void DataTransferAbort();
-
-  static void WriteData(uint16_t Data);
-  static void WriteReg(uint16_t Reg);
-
-  static void WriteSequence(uint16_t *Data, uint16_t Count);
-  // static void WriteMultiple(uint16_t Color, uint16_t Count);
-  static void WriteMultiple(uint16_t Color, uint32_t Count);
-};
@@ -1,80 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-#include "../../../inc/MarlinConfig.h"
-
-#if ENABLED(TOUCH_BUTTONS_HW_SPI)
-  #include <SPI.h>
-#endif
-
-#ifndef TOUCH_MISO_PIN
-  #define TOUCH_MISO_PIN SD_MISO_PIN
-#endif
-#ifndef TOUCH_MOSI_PIN
-  #define TOUCH_MOSI_PIN SD_MOSI_PIN
-#endif
-#ifndef TOUCH_SCK_PIN
-  #define TOUCH_SCK_PIN  SD_SCK_PIN
-#endif
-#ifndef TOUCH_CS_PIN
-  #define TOUCH_CS_PIN   SD_SS_PIN
-#endif
-#ifndef TOUCH_INT_PIN
-  #define TOUCH_INT_PIN  -1
-#endif
-
-#define XPT2046_DFR_MODE        0x00
-#define XPT2046_SER_MODE        0x04
-#define XPT2046_CONTROL         0x80
-
-enum XPTCoordinate : uint8_t {
-  XPT2046_X  = 0x10 | XPT2046_CONTROL | XPT2046_DFR_MODE,
-  XPT2046_Y  = 0x50 | XPT2046_CONTROL | XPT2046_DFR_MODE,
-  XPT2046_Z1 = 0x30 | XPT2046_CONTROL | XPT2046_DFR_MODE,
-  XPT2046_Z2 = 0x40 | XPT2046_CONTROL | XPT2046_DFR_MODE,
-};
-
-#if !defined(XPT2046_Z1_THRESHOLD)
-  #define XPT2046_Z1_THRESHOLD 10
-#endif
-
-class XPT2046 {
-private:
-  static bool isBusy() { return false; }
-
-  static uint16_t getRawData(const XPTCoordinate coordinate);
-  static bool isTouched();
-
-  static inline void DataTransferBegin();
-  static inline void DataTransferEnd();
-  #if ENABLED(TOUCH_BUTTONS_HW_SPI)
-    static uint16_t HardwareIO(uint16_t data);
-  #endif
-  static uint16_t SoftwareIO(uint16_t data);
-  static uint16_t IO(uint16_t data = 0);
-
-public:
-  #if ENABLED(TOUCH_BUTTONS_HW_SPI)
-    static SPIClass SPIx;
-  #endif
-
-  static void Init();
-  static bool getRawPoint(int16_t *x, int16_t *y);
-};
@@ -1,91 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- *
- * Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- * Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-/**
- * HAL timers for Linux X86_64
- */
-
-#include <stdint.h>
-
-// ------------------------
-// Defines
-// ------------------------
-
-#define FORCE_INLINE __attribute__((always_inline)) inline
-
-typedef uint64_t hal_timer_t;
-#define HAL_TIMER_TYPE_MAX 0xFFFFFFFFFFFFFFFF
-
-#define HAL_TIMER_RATE         ((SystemCoreClock) / 4)  // frequency of timers peripherals
-
-#ifndef STEP_TIMER_NUM
-  #define STEP_TIMER_NUM        0  // Timer Index for Stepper
-#endif
-#ifndef PULSE_TIMER_NUM
-  #define PULSE_TIMER_NUM       STEP_TIMER_NUM
-#endif
-#ifndef TEMP_TIMER_NUM
-  #define TEMP_TIMER_NUM        1  // Timer Index for Temperature
-#endif
-#ifndef SYSTICK_TIMER_NUM
-  #define SYSTICK_TIMER_NUM     2 // Timer Index for Systick
-#endif
-#define SYSTICK_TIMER_FREQUENCY 1000
-
-#define TEMP_TIMER_RATE        1000000
-#define TEMP_TIMER_FREQUENCY   1000 // temperature interrupt frequency
-
-#define STEPPER_TIMER_RATE     HAL_TIMER_RATE   // frequency of stepper timer (HAL_TIMER_RATE / STEPPER_TIMER_PRESCALE)
-#define STEPPER_TIMER_TICKS_PER_US ((STEPPER_TIMER_RATE) / 1000000) // stepper timer ticks per µs
-#define STEPPER_TIMER_PRESCALE (CYCLES_PER_MICROSECOND / STEPPER_TIMER_TICKS_PER_US)
-
-#define PULSE_TIMER_RATE       STEPPER_TIMER_RATE   // frequency of pulse timer
-#define PULSE_TIMER_PRESCALE   STEPPER_TIMER_PRESCALE
-#define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US
-
-#define ENABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_enable_interrupt(STEP_TIMER_NUM)
-#define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(STEP_TIMER_NUM)
-#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(STEP_TIMER_NUM)
-
-#define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(TEMP_TIMER_NUM)
-#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(TEMP_TIMER_NUM)
-
-#ifndef HAL_STEP_TIMER_ISR
-  #define HAL_STEP_TIMER_ISR()  extern "C" void TIMER0_IRQHandler()
-#endif
-#ifndef HAL_TEMP_TIMER_ISR
-  #define HAL_TEMP_TIMER_ISR()  extern "C" void TIMER1_IRQHandler()
-#endif
-
-void HAL_timer_init();
-void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency);
-
-void HAL_timer_set_compare(const uint8_t timer_num, const hal_timer_t compare);
-hal_timer_t HAL_timer_get_compare(const uint8_t timer_num);
-hal_timer_t HAL_timer_get_count(const uint8_t timer_num);
-
-void HAL_timer_enable_interrupt(const uint8_t timer_num);
-void HAL_timer_disable_interrupt(const uint8_t timer_num);
-bool HAL_timer_interrupt_enabled(const uint8_t timer_num);
-
-#define HAL_timer_isr_prologue(TIMER_NUM)
-#define HAL_timer_isr_epilogue(TIMER_NUM)
@@ -1,52 +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/>.
- *
- */
-
-// adapted from  I2C/master/master.c example
-//   https://www-users.cs.york.ac.uk/~pcc/MCP/HAPR-Course-web/CMSIS/examples/html/master_8c_source.html
-
-#ifdef __PLAT_NATIVE_SIM__
-
-#include <cstdint>
-
-#ifdef __cplusplus
-  extern "C" {
-#endif
-
-uint8_t u8g_i2c_start(const uint8_t sla) {
-  return 1;
-}
-
-void u8g_i2c_init(const uint8_t clock_option) {
-}
-
-uint8_t u8g_i2c_send_byte(uint8_t data) {
-  return 1;
-}
-
-void u8g_i2c_stop() {
-}
-
-#ifdef __cplusplus
-  }
-#endif
-
-#endif // __PLAT_NATIVE_SIM__
@@ -1,37 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-#ifdef __cplusplus
-  extern "C" {
-#endif
-
-void u8g_i2c_init(const uint8_t clock_options);
-//uint8_t u8g_i2c_wait(uint8_t mask, uint8_t pos);
-uint8_t u8g_i2c_start(uint8_t sla);
-uint8_t u8g_i2c_send_byte(uint8_t data);
-void u8g_i2c_stop();
-
-#ifdef __cplusplus
-  }
-#endif
-
@@ -1,44 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-void usleep(uint64_t microsec);
-// The following are optional depending on the platform.
-
-// definitions of HAL specific com and device drivers.
-uint8_t u8g_com_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr);
-uint8_t u8g_com_ST7920_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr);
-
-// connect U8g com generic com names to the desired driver
-#define U8G_COM_SW_SPI u8g_com_sw_spi_fn
-#define U8G_COM_ST7920_SW_SPI u8g_com_ST7920_sw_spi_fn
-
-// let these default for now
-#define U8G_COM_HW_SPI u8g_com_null_fn
-#define U8G_COM_ST7920_HW_SPI u8g_com_null_fn
-#define U8G_COM_SSD_I2C u8g_com_null_fn
-#define U8G_COM_PARALLEL u8g_com_null_fn
-#define U8G_COM_T6963 u8g_com_null_fn
-#define U8G_COM_FAST_PARALLEL u8g_com_null_fn
-#define U8G_COM_UC_I2C u8g_com_null_fn
-
-
@@ -1,43 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-/**
- * LCD delay routines - used by all the drivers.
- *
- * These are based on the LPC1768 routines.
- *
- * Couldn't just call exact copies because the overhead
- * results in a one microsecond delay taking about 4µS.
- */
-
-#ifdef __cplusplus
-  extern "C" {
-#endif
-
-void U8g_delay(int msec);
-void u8g_MicroDelay();
-void u8g_10MicroDelay();
-
-#ifdef __cplusplus
-  }
-#endif
@@ -1,52 +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/>.
- *
- */
-
-/**
- * Low level pin manipulation routines - used by all the drivers.
- *
- * These are based on the LPC1768 pinMode, digitalRead & digitalWrite routines.
- *
- * Couldn't just call exact copies because the overhead killed the LCD update speed
- * With an intermediate level the softspi was running in the 10-20kHz range which
- * resulted in using about about 25% of the CPU's time.
- */
-
-#ifdef __PLAT_NATIVE_SIM__
-
-#include "../fastio.h"
-#include "LCD_pin_routines.h"
-
-#ifdef __cplusplus
-  extern "C" {
-#endif
-void u8g_SetPinOutput(uint8_t internal_pin_number){SET_DIR_OUTPUT(internal_pin_number);}
-void u8g_SetPinInput(uint8_t internal_pin_number){SET_DIR_INPUT(internal_pin_number);}
-void u8g_SetPinLevel(uint8_t  pin, uint8_t  pin_status){WRITE_PIN(pin, pin_status);}
-uint8_t u8g_GetPinLevel(uint8_t pin){return READ_PIN(pin);}
-void usleep(uint64_t microsec){
-assert(false); // why we here?
-}
-#ifdef __cplusplus
-  }
-#endif
-
-#endif // __PLAT_NATIVE_SIM__
@@ -1,46 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-/**
- * Low level pin manipulation routines - used by all the drivers.
- *
- * These are based on the LPC1768 pinMode, digitalRead & digitalWrite routines.
- *
- * Couldn't just call exact copies because the overhead killed the LCD update speed
- * With an intermediate level the softspi was running in the 10-20kHz range which
- * resulted in using about about 25% of the CPU's time.
- */
-
-
-#ifdef __cplusplus
-  extern "C" {
-#endif
-
-void u8g_SetPinOutput(uint8_t internal_pin_number);
-void u8g_SetPinInput(uint8_t internal_pin_number);
-void u8g_SetPinLevel(uint8_t  pin, uint8_t  pin_status);
-uint8_t u8g_GetPinLevel(uint8_t pin);
-
-#ifdef __cplusplus
-  }
-#endif
@@ -1,171 +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/>.
- *
- */
-
-/**
- * Based on u8g_com_st7920_hw_spi.c
- *
- * Universal 8bit Graphics Library
- *
- * Copyright (c) 2011, olikraus@gmail.com
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- *
- *  * Redistributions of source code must retain the above copyright notice, this list
- *    of conditions and the following disclaimer.
- *
- *  * Redistributions in binary form must reproduce the above copyright notice, this
- *    list of conditions and the following disclaimer in the documentation and/or other
- *    materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifdef __PLAT_NATIVE_SIM__
-
-#include "../../../inc/MarlinConfig.h"
-
-#if ENABLED(U8GLIB_ST7920)
-
-#include <U8glib.h>
-#include "../../shared/Delay.h"
-
-#undef SPI_SPEED
-#define SPI_SPEED 6
-#define SPI_DELAY_CYCLES (1 + SPI_SPEED * 10)
-
-static pin_t SCK_pin_ST7920_HAL, MOSI_pin_ST7920_HAL_HAL;
-static uint8_t SPI_speed = 0;
-
-static uint8_t swSpiTransfer(uint8_t b, const uint8_t spi_speed, const pin_t sck_pin, const pin_t miso_pin, const pin_t mosi_pin) {
-  for (uint8_t i = 0; i < 8; i++) {
-    WRITE_PIN(mosi_pin, !!(b & 0x80));
-    DELAY_CYCLES(SPI_SPEED);
-    WRITE_PIN(sck_pin, HIGH);
-    DELAY_CYCLES(SPI_SPEED);
-    b <<= 1;
-    if (miso_pin >= 0 && READ_PIN(miso_pin)) b |= 1;
-    WRITE_PIN(sck_pin, LOW);
-    DELAY_CYCLES(SPI_SPEED);
-  }
-  return b;
-}
-
-static uint8_t swSpiInit(const uint8_t spiRate, const pin_t sck_pin, const pin_t mosi_pin) {
-  WRITE_PIN(mosi_pin, HIGH);
-  WRITE_PIN(sck_pin, LOW);
-  return spiRate;
-}
-
-static void u8g_com_st7920_write_byte_sw_spi(uint8_t rs, uint8_t val) {
-  static uint8_t rs_last_state = 255;
-  if (rs != rs_last_state) {
-    // Transfer Data (FA) or Command (F8)
-    swSpiTransfer(rs ? 0x0FA : 0x0F8, SPI_speed, SCK_pin_ST7920_HAL, -1, MOSI_pin_ST7920_HAL_HAL);
-    rs_last_state = rs;
-    DELAY_US(40); // Give the controller time to process the data: 20 is bad, 30 is OK, 40 is safe
-  }
-  swSpiTransfer(val & 0x0F0, SPI_speed, SCK_pin_ST7920_HAL, -1, MOSI_pin_ST7920_HAL_HAL);
-  swSpiTransfer(val << 4, SPI_speed, SCK_pin_ST7920_HAL, -1, MOSI_pin_ST7920_HAL_HAL);
-}
-#ifdef __cplusplus
-  extern "C" {
-#endif
-
-uint8_t u8g_com_ST7920_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) {
-  switch (msg) {
-    case U8G_COM_MSG_INIT:
-      SCK_pin_ST7920_HAL = u8g->pin_list[U8G_PI_SCK];
-      MOSI_pin_ST7920_HAL_HAL = u8g->pin_list[U8G_PI_MOSI];
-
-      u8g_SetPIOutput(u8g, U8G_PI_CS);
-      u8g_SetPIOutput(u8g, U8G_PI_SCK);
-      u8g_SetPIOutput(u8g, U8G_PI_MOSI);
-      u8g_Delay(5);
-
-      SPI_speed = swSpiInit(SPI_SPEED, SCK_pin_ST7920_HAL, MOSI_pin_ST7920_HAL_HAL);
-
-      u8g_SetPILevel(u8g, U8G_PI_CS, 0);
-      u8g_SetPILevel(u8g, U8G_PI_SCK, 0);
-      u8g_SetPILevel(u8g, U8G_PI_MOSI, 0);
-
-      u8g->pin_list[U8G_PI_A0_STATE] = 0;       /* initial RS state: command mode */
-      break;
-
-    case U8G_COM_MSG_STOP:
-      break;
-
-    case U8G_COM_MSG_RESET:
-       if (U8G_PIN_NONE != u8g->pin_list[U8G_PI_RESET]) u8g_SetPILevel(u8g, U8G_PI_RESET, arg_val);
-      break;
-
-    case U8G_COM_MSG_ADDRESS:                     /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
-      u8g->pin_list[U8G_PI_A0_STATE] = arg_val;
-      break;
-
-    case U8G_COM_MSG_CHIP_SELECT:
-      if (U8G_PIN_NONE != u8g->pin_list[U8G_PI_CS]) u8g_SetPILevel(u8g, U8G_PI_CS, arg_val);  //note: the st7920 has an active high chip select
-      break;
-
-    case U8G_COM_MSG_WRITE_BYTE:
-      u8g_com_st7920_write_byte_sw_spi(u8g->pin_list[U8G_PI_A0_STATE], arg_val);
-      break;
-
-    case U8G_COM_MSG_WRITE_SEQ: {
-        uint8_t *ptr = (uint8_t*) arg_ptr;
-        while (arg_val > 0) {
-          u8g_com_st7920_write_byte_sw_spi(u8g->pin_list[U8G_PI_A0_STATE], *ptr++);
-          arg_val--;
-        }
-      }
-      break;
-
-      case U8G_COM_MSG_WRITE_SEQ_P: {
-        uint8_t *ptr = (uint8_t*) arg_ptr;
-        while (arg_val > 0) {
-          u8g_com_st7920_write_byte_sw_spi(u8g->pin_list[U8G_PI_A0_STATE], *ptr++);
-          arg_val--;
-        }
-      }
-      break;
-  }
-  return 1;
-}
-#ifdef __cplusplus
-  }
-#endif
-
-#endif // U8GLIB_ST7920
-#endif // TARGET_LPC1768
@@ -1,215 +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/>.
- *
- */
-
-/**
- * Based on u8g_com_std_sw_spi.c
- *
- * Universal 8bit Graphics Library
- *
- * Copyright (c) 2015, olikraus@gmail.com
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- *
- *  * Redistributions of source code must retain the above copyright notice, this list
- *    of conditions and the following disclaimer.
- *
- *  * Redistributions in binary form must reproduce the above copyright notice, this
- *    list of conditions and the following disclaimer in the documentation and/or other
- *    materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifdef __PLAT_NATIVE_SIM__
-
-#include "../../../inc/MarlinConfig.h"
-
-#if HAS_MARLINUI_U8GLIB && DISABLED(U8GLIB_ST7920)
-
-#undef SPI_SPEED
-#define SPI_SPEED 2  // About 2 MHz
-
-#include <Arduino.h>
-#include <U8glib.h>
-
-#ifdef __cplusplus
-  extern "C" {
-#endif
-
-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 ) {
-  LOOP_L_N(i, 8) {
-    if (spi_speed == 0) {
-      WRITE_PIN(mosi_pin, !!(b & 0x80));
-      WRITE_PIN(sck_pin, HIGH);
-      b <<= 1;
-      if (miso_pin >= 0 && READ_PIN(miso_pin)) b |= 1;
-      WRITE_PIN(sck_pin, LOW);
-    }
-    else {
-      const uint8_t state = (b & 0x80) ? HIGH : LOW;
-      LOOP_L_N(j, spi_speed)
-        WRITE_PIN(mosi_pin, state);
-
-      LOOP_L_N(j, spi_speed + (miso_pin >= 0 ? 0 : 1))
-        WRITE_PIN(sck_pin, HIGH);
-
-      b <<= 1;
-      if (miso_pin >= 0 && READ_PIN(miso_pin)) b |= 1;
-
-      LOOP_L_N(j, spi_speed)
-        WRITE_PIN(sck_pin, LOW);
-    }
-  }
-
-  return b;
-}
-
-uint8_t swSpiTransfer_mode_3(uint8_t b, const uint8_t spi_speed, const pin_t sck_pin, const pin_t miso_pin, const pin_t mosi_pin ) {
-
-  LOOP_L_N(i, 8) {
-    const uint8_t state = (b & 0x80) ? HIGH : LOW;
-    if (spi_speed == 0) {
-      WRITE_PIN(sck_pin, LOW);
-      WRITE_PIN(mosi_pin, state);
-      WRITE_PIN(mosi_pin, state);  // need some setup time
-      WRITE_PIN(sck_pin, HIGH);
-    }
-    else {
-      LOOP_L_N(j, spi_speed + (miso_pin >= 0 ? 0 : 1))
-        WRITE_PIN(sck_pin, LOW);
-
-      LOOP_L_N(j, spi_speed)
-        WRITE_PIN(mosi_pin, state);
-
-      LOOP_L_N(j, spi_speed)
-        WRITE_PIN(sck_pin, HIGH);
-    }
-    b <<= 1;
-    if (miso_pin >= 0 && READ_PIN(miso_pin)) b |= 1;
-  }
-
-  return b;
-}
-
-static uint8_t SPI_speed = 0;
-
-static uint8_t swSpiInit(const uint8_t spi_speed, const uint8_t clk_pin, const uint8_t mosi_pin) {
-    return spi_speed;
-}
-
-static void u8g_sw_spi_shift_out(uint8_t dataPin, uint8_t clockPin, uint8_t val) {
-  #if EITHER(FYSETC_MINI_12864, MKS_MINI_12864)
-    swSpiTransfer_mode_3(val, SPI_speed, clockPin, -1, dataPin);
-  #else
-    swSpiTransfer_mode_0(val, SPI_speed, clockPin, -1, dataPin);
-  #endif
-}
-
-uint8_t u8g_com_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) {
-  switch (msg) {
-    case U8G_COM_MSG_INIT:
-      u8g_SetPIOutput(u8g, U8G_PI_SCK);
-      u8g_SetPIOutput(u8g, U8G_PI_MOSI);
-      u8g_SetPIOutput(u8g, U8G_PI_CS);
-      u8g_SetPIOutput(u8g, U8G_PI_A0);
-      if (U8G_PIN_NONE != u8g->pin_list[U8G_PI_RESET]) u8g_SetPIOutput(u8g, U8G_PI_RESET);
-      SPI_speed = swSpiInit(SPI_SPEED, u8g->pin_list[U8G_PI_SCK], u8g->pin_list[U8G_PI_MOSI]);
-      u8g_SetPILevel(u8g, U8G_PI_SCK, 0);
-      u8g_SetPILevel(u8g, U8G_PI_MOSI, 0);
-      break;
-
-    case U8G_COM_MSG_STOP:
-      break;
-
-    case U8G_COM_MSG_RESET:
-      if (U8G_PIN_NONE != u8g->pin_list[U8G_PI_RESET]) u8g_SetPILevel(u8g, U8G_PI_RESET, arg_val);
-      break;
-
-    case U8G_COM_MSG_CHIP_SELECT:
-      #if EITHER(FYSETC_MINI_12864, MKS_MINI_12864)  // LCD SPI is running mode 3 while SD card is running mode 0
-        if (arg_val) {                               //   SCK idle state needs to be set to the proper idle state before
-                                                     //   the next chip select goes active
-          u8g_SetPILevel(u8g, U8G_PI_SCK, 1);        // Set SCK to mode 3 idle state before CS goes active
-          u8g_SetPILevel(u8g, U8G_PI_CS, LOW);
-        }
-        else {
-          u8g_SetPILevel(u8g, U8G_PI_CS, HIGH);
-          u8g_SetPILevel(u8g, U8G_PI_SCK, 0);  // Set SCK to mode 0 idle state after CS goes inactive
-        }
-      #else
-        u8g_SetPILevel(u8g, U8G_PI_CS, !arg_val);
-      #endif
-      break;
-
-    case U8G_COM_MSG_WRITE_BYTE:
-      u8g_sw_spi_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK], arg_val);
-      break;
-
-    case U8G_COM_MSG_WRITE_SEQ: {
-        uint8_t *ptr = (uint8_t *)arg_ptr;
-        while (arg_val > 0) {
-          u8g_sw_spi_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK], *ptr++);
-          arg_val--;
-        }
-      }
-      break;
-
-      case U8G_COM_MSG_WRITE_SEQ_P: {
-        uint8_t *ptr = (uint8_t *)arg_ptr;
-        while (arg_val > 0) {
-          u8g_sw_spi_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK], u8g_pgm_read(ptr));
-          ptr++;
-          arg_val--;
-        }
-      }
-      break;
-
-    case U8G_COM_MSG_ADDRESS:                     /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
-      u8g_SetPILevel(u8g, U8G_PI_A0, arg_val);
-      break;
-  }
-  return 1;
-}
-
-#ifdef __cplusplus
-  }
-#endif
-
-#elif !ANY(TFT_COLOR_UI, TFT_CLASSIC_UI, TFT_LVGL_UI, HAS_MARLINUI_HD44780) && HAS_MARLINUI_U8GLIB
-  #include <U8glib.h>
-  uint8_t u8g_com_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) {return 0;}
-#endif // HAS_MARLINUI_U8GLIB && !U8GLIB_ST7920
-#endif // __PLAT_NATIVE_SIM__
@@ -1,27 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2021 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-#define WDT_TIMEOUT   4000000 // 4 second timeout
-
-void watchdog_init();
-void HAL_watchdog_refresh();
@@ -25,19 +25,19 @@
 #include <wiring_private.h>

 #ifdef ADAFRUIT_GRAND_CENTRAL_M4
-  #if USING_HW_SERIALUSB
+  #if ANY_SERIAL_IS(-1)
    DefaultSerial1 MSerial0(false, Serial);
  #endif
-  #if USING_HW_SERIAL0
+  #if ANY_SERIAL_IS(0)
    DefaultSerial2 MSerial1(false, Serial1);
  #endif
-  #if USING_HW_SERIAL1
+  #if ANY_SERIAL_IS(1)
    DefaultSerial3 MSerial2(false, Serial2);
  #endif
-  #if USING_HW_SERIAL2
+  #if ANY_SERIAL_IS(2)
    DefaultSerial4 MSerial3(false, Serial3);
  #endif
-  #if USING_HW_SERIAL3
+  #if ANY_SERIAL_IS(3)
    DefaultSerial5 MSerial4(false, Serial4);
  #endif
 #endif
@@ -436,8 +436,6 @@ uint8_t HAL_get_reset_source() {
 }
 #pragma pop_macro("WDT")

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

@@ -43,6 +43,8 @@
  extern DefaultSerial4 MSerial3;
  extern DefaultSerial5 MSerial4;

+  // MYSERIAL1 required before MarlinSerial includes!
+
  #define __MSERIAL(X) MSerial##X
  #define _MSERIAL(X) __MSERIAL(X)
  #define MSERIAL(X) _MSERIAL(INCREMENT(X))
@@ -52,7 +54,7 @@
  #elif WITHIN(SERIAL_PORT, 0, 3)
    #define MYSERIAL1 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
@@ -61,7 +63,7 @@
    #elif WITHIN(SERIAL_PORT_2, 0, 3)
      #define MYSERIAL2 MSERIAL(SERIAL_PORT_2)
    #else
-      #error "SERIAL_PORT_2 must be from 0 to 3. You can also use -1 if the board supports Native USB."
+      #error "SERIAL_PORT_2 must be from -1 to 3. Please update your configuration."
    #endif
  #endif

@@ -71,7 +73,7 @@
    #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

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

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

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

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

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

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

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

-#if USING_HW_SERIAL3
+#if ANY_SERIAL_IS(3)
  UartT Serial4(false, &sercom5, PIN_SERIAL4_RX, PIN_SERIAL4_TX, PAD_SERIAL4_RX, PAD_SERIAL4_TX);
  void SERCOM5_0_Handler() { Serial4.IrqHandler(); }
  void SERCOM5_1_Handler() { Serial4.IrqHandler(); }
@@ -41,13 +41,12 @@ bool PersistentStore::access_start()  { eeprom_init(); return true; }
 bool PersistentStore::access_finish() { return true; }

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

 #include "../../module/endstops.h"

-#define MATCH_EILINE(P1,P2) (P1 != P2 && PIN_TO_EILINE(P1) == PIN_TO_EILINE(P2))
-#define MATCH_X_MAX_EILINE(P)   TERN0(HAS_X_MAX,  DEFER4(MATCH_EILINE)(P, X_MAX_PIN))
-#define MATCH_X_MIN_EILINE(P)   TERN0(HAS_X_MIN,  DEFER4(MATCH_EILINE)(P, X_MIN_PIN))
-#define MATCH_Y_MAX_EILINE(P)   TERN0(HAS_Y_MAX,  DEFER4(MATCH_EILINE)(P, Y_MAX_PIN))
-#define MATCH_Y_MIN_EILINE(P)   TERN0(HAS_Y_MIN,  DEFER4(MATCH_EILINE)(P, Y_MIN_PIN))
-#define MATCH_Z_MAX_EILINE(P)   TERN0(HAS_Z_MAX,  DEFER4(MATCH_EILINE)(P, Z_MAX_PIN))
-#define MATCH_Z_MIN_EILINE(P)   TERN0(HAS_Z_MIN,  DEFER4(MATCH_EILINE)(P, Z_MIN_PIN))
-#define MATCH_I_MAX_EILINE(P)   TERN0(HAS_I_MAX,  DEFER4(MATCH_EILINE)(P, I_MAX_PIN))
-#define MATCH_I_MIN_EILINE(P)   TERN0(HAS_I_MIN,  DEFER4(MATCH_EILINE)(P, I_MIN_PIN))
-#define MATCH_J_MAX_EILINE(P)   TERN0(HAS_J_MAX,  DEFER4(MATCH_EILINE)(P, J_MAX_PIN))
-#define MATCH_J_MIN_EILINE(P)   TERN0(HAS_J_MIN,  DEFER4(MATCH_EILINE)(P, J_MIN_PIN))
-#define MATCH_K_MAX_EILINE(P)   TERN0(HAS_K_MAX,  DEFER4(MATCH_EILINE)(P, K_MAX_PIN))
-#define MATCH_K_MIN_EILINE(P)   TERN0(HAS_K_MIN,  DEFER4(MATCH_EILINE)(P, K_MIN_PIN))
-#define MATCH_Z2_MAX_EILINE(P)  TERN0(HAS_Z2_MAX, DEFER4(MATCH_EILINE)(P, Z2_MAX_PIN))
-#define MATCH_Z2_MIN_EILINE(P)  TERN0(HAS_Z2_MIN, DEFER4(MATCH_EILINE)(P, Z2_MIN_PIN))
-#define MATCH_Z3_MAX_EILINE(P)  TERN0(HAS_Z3_MAX, DEFER4(MATCH_EILINE)(P, Z3_MAX_PIN))
-#define MATCH_Z3_MIN_EILINE(P)  TERN0(HAS_Z3_MIN, DEFER4(MATCH_EILINE)(P, Z3_MIN_PIN))
-#define MATCH_Z4_MAX_EILINE(P)  TERN0(HAS_Z4_MAX, DEFER4(MATCH_EILINE)(P, Z4_MAX_PIN))
-#define MATCH_Z4_MIN_EILINE(P)  TERN0(HAS_Z4_MIN, DEFER4(MATCH_EILINE)(P, Z4_MIN_PIN))
-#define MATCH_Z_MIN_PROBE_EILINE(P) TERN0(HAS_Z_MIN_PROBE_PIN, DEFER4(MATCH_EILINE)(P, Z_MIN_PROBE_PIN))
-
-#define AVAILABLE_EILINE(P) ( PIN_TO_EILINE(P) != -1    \
-  && !MATCH_X_MAX_EILINE(P) && !MATCH_X_MIN_EILINE(P)   \
-  && !MATCH_Y_MAX_EILINE(P) && !MATCH_Y_MIN_EILINE(P)   \
-  && !MATCH_Z_MAX_EILINE(P) && !MATCH_Z_MIN_EILINE(P)   \
-  && !MATCH_I_MAX_EILINE(P) && !MATCH_I_MIN_EILINE(P)   \
-  && !MATCH_J_MAX_EILINE(P) && !MATCH_J_MIN_EILINE(P)   \
-  && !MATCH_K_MAX_EILINE(P) && !MATCH_K_MIN_EILINE(P)   \
-  && !MATCH_Z2_MAX_EILINE(P) && !MATCH_Z2_MIN_EILINE(P) \
-  && !MATCH_Z3_MAX_EILINE(P) && !MATCH_Z3_MIN_EILINE(P) \
-  && !MATCH_Z4_MAX_EILINE(P) && !MATCH_Z4_MIN_EILINE(P) \
-  && !MATCH_Z_MIN_PROBE_EILINE(P) )
+#define MATCH_EILINE(P1,P2)     (P1 != P2 && PIN_TO_EILINE(P1) == PIN_TO_EILINE(P2))
+#if HAS_X_MAX
+  #define MATCH_X_MAX_EILINE(P) MATCH_EILINE(P, X_MAX_PIN)
+#else
+  #define MATCH_X_MAX_EILINE(P) false
+#endif
+#if HAS_X_MIN
+  #define MATCH_X_MIN_EILINE(P) MATCH_EILINE(P, X_MIN_PIN)
+#else
+  #define MATCH_X_MIN_EILINE(P) false
+#endif
+#if HAS_Y_MAX
+   #define MATCH_Y_MAX_EILINE(P) MATCH_EILINE(P, Y_MAX_PIN)
+#else
+   #define MATCH_Y_MAX_EILINE(P) false
+#endif
+#if HAS_Y_MIN
+  #define MATCH_Y_MIN_EILINE(P) MATCH_EILINE(P, Y_MIN_PIN)
+#else
+  #define MATCH_Y_MIN_EILINE(P) false
+#endif
+#if HAS_Z_MAX
+   #define MATCH_Z_MAX_EILINE(P) MATCH_EILINE(P, Z_MAX_PIN)
+#else
+  #define MATCH_Z_MAX_EILINE(P) false
+#endif
+#if HAS_Z_MIN
+  #define MATCH_Z_MIN_EILINE(P) MATCH_EILINE(P, Z_MIN_PIN)
+#else
+  #define MATCH_Z_MIN_EILINE(P) false
+#endif
+#if HAS_Z2_MAX
+  #define MATCH_Z2_MAX_EILINE(P) MATCH_EILINE(P, Z2_MAX_PIN)
+#else
+  #define MATCH_Z2_MAX_EILINE(P) false
+#endif
+#if HAS_Z2_MIN
+  #define MATCH_Z2_MIN_EILINE(P) MATCH_EILINE(P, Z2_MIN_PIN)
+#else
+  #define MATCH_Z2_MIN_EILINE(P) false
+#endif
+#if HAS_Z3_MAX
+  #define MATCH_Z3_MAX_EILINE(P) MATCH_EILINE(P, Z3_MAX_PIN)
+#else
+  #define MATCH_Z3_MAX_EILINE(P) false
+#endif
+#if HAS_Z3_MIN
+  #define MATCH_Z3_MIN_EILINE(P) MATCH_EILINE(P, Z3_MIN_PIN)
+#else
+  #define MATCH_Z3_MIN_EILINE(P) false
+#endif
+#if HAS_Z4_MAX
+  #define MATCH_Z4_MAX_EILINE(P) MATCH_EILINE(P, Z4_MAX_PIN)
+#else
+  #define MATCH_Z4_MAX_EILINE(P) false
+#endif
+#if HAS_Z4_MIN
+  #define MATCH_Z4_MIN_EILINE(P) MATCH_EILINE(P, Z4_MIN_PIN)
+#else
+  #define MATCH_Z4_MIN_EILINE(P) false
+#endif
+#if HAS_Z_MIN_PROBE_PIN
+  #define MATCH_Z_MIN_PROBE_EILINE(P)   MATCH_EILINE(P, Z_MIN_PROBE_PIN)
+#else
+  #define MATCH_Z_MIN_PROBE_EILINE(P) false
+#endif
+#define AVAILABLE_EILINE(P)     (PIN_TO_EILINE(P) != -1                                 \
+                                 && !MATCH_X_MAX_EILINE(P) && !MATCH_X_MIN_EILINE(P)    \
+                                 && !MATCH_Y_MAX_EILINE(P) && !MATCH_Y_MIN_EILINE(P)    \
+                                 && !MATCH_Z_MAX_EILINE(P) && !MATCH_Z_MIN_EILINE(P)    \
+                                 && !MATCH_Z2_MAX_EILINE(P) && !MATCH_Z2_MIN_EILINE(P)  \
+                                 && !MATCH_Z3_MAX_EILINE(P) && !MATCH_Z3_MIN_EILINE(P)  \
+                                 && !MATCH_Z4_MAX_EILINE(P) && !MATCH_Z4_MIN_EILINE(P)  \
+                                 && !MATCH_Z_MIN_PROBE_EILINE(P))

 // One ISR for all EXT-Interrupts
 void endstop_ISR() { endstops.update(); }
@@ -162,37 +204,5 @@ void setup_endstop_interrupts() {
      #error "Z_MIN_PROBE_PIN has no EXTINT line available."
    #endif
    _ATTACH(Z_MIN_PROBE_PIN);
-  #elif HAS_I_MAX
-    #if !AVAILABLE_EILINE(I_MAX_PIN)
-      #error "I_MAX_PIN has no EXTINT line available."
-    #endif
-    attachInterrupt(I_MAX_PIN, endstop_ISR, CHANGE);
-  #elif HAS_I_MIN
-    #if !AVAILABLE_EILINE(I_MIN_PIN)
-      #error "I_MIN_PIN has no EXTINT line available."
-    #endif
-    attachInterrupt(I_MIN_PIN, endstop_ISR, CHANGE);
-  #endif
-  #if HAS_J_MAX
-    #if !AVAILABLE_EILINE(J_MAX_PIN)
-      #error "J_MAX_PIN has no EXTINT line available."
-    #endif
-    attachInterrupt(J_MAX_PIN, endstop_ISR, CHANGE);
-  #elif HAS_J_MIN
-    #if !AVAILABLE_EILINE(J_MIN_PIN)
-      #error "J_MIN_PIN has no EXTINT line available."
-    #endif
-    attachInterrupt(J_MIN_PIN, endstop_ISR, CHANGE);
-  #endif
-  #if HAS_K_MAX
-    #if !AVAILABLE_EILINE(K_MAX_PIN)
-      #error "K_MAX_PIN has no EXTINT line available."
-    #endif
-    attachInterrupt(K_MAX_PIN, endstop_ISR, CHANGE);
-  #elif HAS_K_MIN
-    #if !AVAILABLE_EILINE(K_MIN_PIN)
-      #error "K_MIN_PIN has no EXTINT line available."
-    #endif
-    attachInterrupt(K_MIN_PIN, endstop_ISR, CHANGE);
  #endif
 }
@@ -31,8 +31,7 @@
  #error "No custom SD drive cable defined for this board."
 #endif

-#if (defined(TEMP_0_SCK_PIN) && defined(TEMP_0_MISO_PIN) && (TEMP_0_SCK_PIN == SCK1 || TEMP_0_MISO_PIN == MISO1)) || \
-    (defined(TEMP_1_SCK_PIN) && defined(TEMP_1_MISO_PIN) && (TEMP_1_SCK_PIN == SCK1 || TEMP_1_MISO_PIN == MISO1))
+#if defined(MAX6675_SCK_PIN) && defined(MAX6675_DO_PIN) && (MAX6675_SCK_PIN == SCK1 || MAX6675_DO_PIN == MISO1)
  #error "OnBoard SPI BUS can't be shared with other devices."
 #endif

@@ -20,7 +20,7 @@
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 */
-#if defined(ARDUINO_ARCH_STM32) && !defined(STM32GENERIC) && !defined(MAPLE_STM32F1)
+#if defined(ARDUINO_ARCH_STM32) && !defined(STM32GENERIC)

 #include "HAL.h"
 #include "usb_serial.h"
@@ -91,14 +91,10 @@ void HAL_init() {
    USB_Hook_init();
  #endif

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

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

@@ -137,8 +133,6 @@ uint8_t HAL_get_reset_source() {
  ;
 }

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

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

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

 // Maple Compatibility
 volatile uint32_t systick_uptime_millis = 0;
@@ -165,4 +159,4 @@ void HAL_SYSTICK_Callback() {
  if (systick_user_callback) systick_user_callback();
 }

-#endif // ARDUINO_ARCH_STM32 && !STM32GENERIC && !MAPLE_STM32F1
+#endif // ARDUINO_ARCH_STM32 && !STM32GENERIC
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
InsanityAutomation	988140a467	Update Configuration_adv.h	2021-03-20 13:42:07 -04:00
InsanityAutomation	c320503d78	Merge branch 'bugfix-2.0.x' into FunmatHT	2021-03-20 12:30:49 -04:00
InsanityAutomation	d90d15817c	Merge branch 'bugfix-2.0.x' of https://github.com/MarlinFirmware/Marlin into bugfix-2.0.x	2021-03-20 11:16:35 -04:00
InsanityAutomation	4479f438fd	Merge branch 'FunmatHT' of https://github.com/InsanityAutomation/Marlin into FunmatHT	2021-03-20 11:16:23 -04:00
InsanityAutomation	e05616ada1	Merge branch 'bugfix-2.0.x' of https://github.com/MarlinFirmware/Marlin into bugfix-2.0.x	2021-03-12 16:16:33 -05:00
InsanityAutomation	900047298e	Update pins_INTAMSYS40.h	2020-08-01 12:56:16 -04:00
InsanityAutomation	c86c85437f	Update Configuration_adv.h	2020-08-01 12:54:39 -04:00
InsanityAutomation	18d0e1b365	Update Configuration.h	2020-08-01 12:54:38 -04:00
InsanityAutomation	a34b4471b5	more config	2020-08-01 12:54:38 -04:00
InsanityAutomation	ae9372bc16	ITS ALIVE!	2020-08-01 12:53:45 -04:00
InsanityAutomation	848e9ea241	progress	2020-08-01 12:53:39 -04:00
InsanityAutomation	d21d6f6c9e	Support all but motion	2020-08-01 12:52:13 -04:00
InsanityAutomation	b35d0c61b9	Merge branch 'bugfix-2.0.x' of https://github.com/MarlinFirmware/Marlin into bugfix-2.0.x	2020-08-01 12:49:56 -04:00
InsanityAutomation	5c1c99da0c	Update Configuration_adv.h	2020-07-23 11:47:55 -04:00
InsanityAutomation	261778e540	Merge branch 'bugfix-2.0.x' of https://github.com/MarlinFirmware/Marlin into bugfix-2.0.x	2020-03-30 20:11:40 -04:00
InsanityAutomation	6ee6205e18	Update Configuration.h	2020-03-26 12:25:08 -04:00
InsanityAutomation	d47ceb2e8b	more config	2020-03-26 10:55:46 -04:00
InsanityAutomation	75beeb7b25	Update pins_INTAMSYS40.h	2020-03-26 09:54:50 -04:00
InsanityAutomation	522735b858	ITS ALIVE!	2020-03-26 09:54:50 -04:00
InsanityAutomation	4f7d610c96	progress	2020-03-26 09:54:50 -04:00
InsanityAutomation	d2cee0be7a	Support all but motion	2020-03-26 09:54:49 -04:00
InsanityAutomation	20c60fe8f1	Merge branch 'bugfix-2.0.x' of https://github.com/MarlinFirmware/Marlin into bugfix-2.0.x	2020-03-26 09:54:31 -04:00
InsanityAutomation	877b3c65f9	Merge branch 'bugfix-2.0.x' of https://github.com/MarlinFirmware/Marlin into bugfix-2.0.x	2020-03-14 16:28:14 -04:00
InsanityAutomation	aa9b6280ff	Merge branch 'bugfix-2.0.x' of https://github.com/MarlinFirmware/Marlin into bugfix-2.0.x	2020-01-29 23:12:48 -05:00
InsanityAutomation	2a9ecf46a5	Merge branch 'bugfix-2.0.x' of https://github.com/MarlinFirmware/Marlin into bugfix-2.0.x	2020-01-27 20:52:29 -05:00
InsanityAutomation	cf9a8e184e	Merge branch 'bugfix-2.0.x' of https://github.com/MarlinFirmware/Marlin into bugfix-2.0.x	2020-01-18 23:29:55 -05:00
InsanityAutomation	b12fe74d75	Merge branch 'bugfix-2.0.x' of https://github.com/MarlinFirmware/Marlin into bugfix-2.0.x	2020-01-02 23:00:52 -05:00
Scott Lahteine	8b927a283e	Fix binary protocol buffer overrun	2019-10-07 19:13:53 -05:00