Initial Commit

Merge branch 'bugfix-2.0.x' of https://github.com/MarlinFirmware/Marlin into bugfix-2.0.x
2021-06-05 18:37:34 -04:00 · 2021-06-05 16:51:34 -04:00 · 2021-05-25 09:22:13 -04:00 · 2021-05-23 15:06:33 -04:00 · 2021-05-16 14:18:43 -04:00 · 2021-05-06 11:55:25 -04:00
1833 changed files with 46937 additions and 158062 deletions
@@ -58,16 +58,15 @@ jobs:

        #- STM32F103RC_btt_maple
        - STM32F103RC_btt_USB_maple
-        - STM32F103RC_fysetc_maple
+        - STM32F103RC_fysetc
        - STM32F103RC_meeb
-        - jgaurora_a5s_a1_maple
-        - STM32F103VE_longer_maple
+        - jgaurora_a5s_a1
+        - STM32F103VE_longer
        #- mks_robin_maple
-        - mks_robin_lite_maple
-        - mks_robin_pro_maple
+        - mks_robin_lite
+        - mks_robin_pro
        #- mks_robin_nano35_maple
-        #- STM32F103RE_creality_maple
-        - STM32F103VE_ZM3E4V2_USB_maple
+        #- STM32F103RET6_creality_maple

        # STM32 (ST) Environments

@@ -75,8 +74,7 @@ jobs:
        #- STM32F103RC_btt_USB
        - STM32F103RE_btt
        - STM32F103RE_btt_USB
-        - STM32F103RE_creality
-        - STM32F103VE_longer
+        - STM32F103RET6_creality
        - STM32F407VE_black
        - STM32F401VE_STEVAL
        - BIGTREE_BTT002
@@ -97,7 +95,6 @@ jobs:
        - REMRAM_V1
        - BTT_SKR_SE_BX
        - chitu_f103
-        - Index_Mobo_Rev03

        # Put lengthy tests last

@@ -112,34 +109,20 @@ jobs:

    steps:

-    - name: Check out the PR
-      uses: actions/checkout@v3
-
-    - name: Cache pip
-      uses: actions/cache@v3
-      with:
-        path: ~/.cache/pip
-        key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
-        restore-keys: |
-          ${{ runner.os }}-pip-
-
-    - name: Cache PlatformIO
-      uses: actions/cache@v3
-      with:
-        path: ~/.platformio
-        key: ${{ runner.os }}-${{ hashFiles('**/lockfiles') }}
-
    - name: Select Python 3.7
-      uses: actions/setup-python@v3
+      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

    - name: Install PlatformIO
      run: |
-        pip install -U https://github.com/platformio/platformio-core/archive/v5.2.5.zip
+        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 }}
@@ -22,16 +22,12 @@
 # Generated files
 _Version.h
 bdf2u8g
-marlin_config.json
-mczip.h
-*.gen
-*.sublime-workspace

 #
 # OS
 #
 applet/
-.DS_Store
+*.DS_Store

 #
 # Misc
@@ -41,6 +37,7 @@ applet/
 *.rej
 *.bak
 *.idea
+*.s
 *.i
 *.ii
 *.swp
@@ -140,19 +137,16 @@ __vm/
 vc-fileutils.settings

 # Visual Studio Code
-.vscode/*
-!.vscode/extensions.json
+.vscode
+.vscode/.browse.c_cpp.db*
+.vscode/c_cpp_properties.json
+.vscode/launch.json
+.vscode/*.db

-#Simulation
-imgui.ini
-eeprom.dat
-spi_flash.bin
-
-#cmake
+# cmake
 CMakeLists.txt
 src/CMakeLists.txt
 CMakeListsPrivate.txt
-build/

 # CLion
 cmake-build-*
@@ -169,3 +163,7 @@ __pycache__

 # IOLogger logs
 *_log.csv
+
+# Simulation / Native
+eeprom.dat
+imgui.ini
@@ -1,11 +0,0 @@
-{
-    // See http://go.microsoft.com/fwlink/?LinkId=827846
-    // for the documentation about the extensions.json format
-    "recommendations": [
-        "marlinfirmware.auto-build",
-        "platformio.platformio-ide"
-    ],
-    "unwantedRecommendations": [
-        "ms-vscode.cpptools-extension-pack"
-    ]
-}
@@ -110,7 +110,7 @@ LIQUID_TWI2        ?= 0
 WIRE               ?= 0

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

 # This defines if U8GLIB is needed (may require RELOC_WORKAROUND)
@@ -132,7 +132,7 @@ CC_MIN:=$(shell $(CC) -dM -E - < /dev/null | grep __GNUC_MINOR__ | cut -f3 -d\ )
 CC_PATCHLEVEL:=$(shell $(CC) -dM -E - < /dev/null | grep __GNUC_PATCHLEVEL__ | cut -f3 -d\ )
 CC_VER:=$(shell echo $$(( $(CC_MAJ) * 10000 + $(CC_MIN) * 100 + $(CC_PATCHLEVEL) )))
 ifeq ($(shell test $(CC_VER) -lt 40901 && echo 1),1)
-  $(warning This GCC version $(CC_VER) is likely broken. Enabling relocation workaround.)
+  @echo This version of GCC is likely broken. Enabling relocation workaround.
  RELOC_WORKAROUND = 1
 endif

@@ -191,134 +191,6 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1034)
 # RAMPS Derivatives - ATmega1280, ATmega2560
 #

-# 3Drag Controller
-else ifeq ($(HARDWARE_MOTHERBOARD),1100)
-# Velleman K8200 Controller (derived from 3Drag Controller)
-else ifeq ($(HARDWARE_MOTHERBOARD),1101)
-# Velleman K8400 Controller (derived from 3Drag Controller)
-else ifeq ($(HARDWARE_MOTHERBOARD),1102)
-# Velleman K8600 Controller (Vertex Nano)
-else ifeq ($(HARDWARE_MOTHERBOARD),1103)
-# Velleman K8800 Controller (Vertex Delta)
-else ifeq ($(HARDWARE_MOTHERBOARD),1104)
-# 2PrintBeta BAM&DICE with STK drivers
-else ifeq ($(HARDWARE_MOTHERBOARD),1105)
-# 2PrintBeta BAM&DICE Due with STK drivers
-else ifeq ($(HARDWARE_MOTHERBOARD),1106)
-# MKS BASE v1.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1107)
-# MKS BASE v1.4 with Allegro A4982 stepper drivers
-else ifeq ($(HARDWARE_MOTHERBOARD),1108)
-# MKS BASE v1.5 with Allegro A4982 stepper drivers
-else ifeq ($(HARDWARE_MOTHERBOARD),1109)
-# MKS BASE v1.6 with Allegro A4982 stepper drivers
-else ifeq ($(HARDWARE_MOTHERBOARD),1110)
-# MKS BASE 1.0 with Heroic HR4982 stepper drivers
-else ifeq ($(HARDWARE_MOTHERBOARD),1111)
-# MKS GEN v1.3 or 1.4
-else ifeq ($(HARDWARE_MOTHERBOARD),1112)
-# MKS GEN L
-else ifeq ($(HARDWARE_MOTHERBOARD),1113)
-# BigTreeTech or BIQU KFB2.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1114)
-# zrib V2.0 (Chinese RAMPS replica)
-else ifeq ($(HARDWARE_MOTHERBOARD),1115)
-# zrib V5.2 (Chinese RAMPS replica)
-else ifeq ($(HARDWARE_MOTHERBOARD),1116)
-# Felix 2.0+ Electronics Board (RAMPS like)
-else ifeq ($(HARDWARE_MOTHERBOARD),1117)
-# Invent-A-Part RigidBoard
-else ifeq ($(HARDWARE_MOTHERBOARD),1118)
-# Invent-A-Part RigidBoard V2
-else ifeq ($(HARDWARE_MOTHERBOARD),1119)
-# Sainsmart 2-in-1 board
-else ifeq ($(HARDWARE_MOTHERBOARD),1120)
-# Ultimaker
-else ifeq ($(HARDWARE_MOTHERBOARD),1121)
-# Ultimaker (Older electronics. Pre 1.5.4. This is rare)
-else ifeq ($(HARDWARE_MOTHERBOARD),1122)
-  MCU              ?= atmega1280
-  PROG_MCU         ?= m1280
-# Azteeg X3
-else ifeq ($(HARDWARE_MOTHERBOARD),1123)
-# Azteeg X3 Pro
-else ifeq ($(HARDWARE_MOTHERBOARD),1124)
-# Ultimainboard 2.x (Uses TEMP_SENSOR 20)
-else ifeq ($(HARDWARE_MOTHERBOARD),1125)
-# Rumba
-else ifeq ($(HARDWARE_MOTHERBOARD),1126)
-# Raise3D N series Rumba derivative
-else ifeq ($(HARDWARE_MOTHERBOARD),1127)
-# Rapide Lite 200 (v1, low-cost RUMBA clone with drv)
-else ifeq ($(HARDWARE_MOTHERBOARD),1128)
-# Formbot T-Rex 2 Plus
-else ifeq ($(HARDWARE_MOTHERBOARD),1129)
-# Formbot T-Rex 3
-else ifeq ($(HARDWARE_MOTHERBOARD),1130)
-# Formbot Raptor
-else ifeq ($(HARDWARE_MOTHERBOARD),1131)
-# Formbot Raptor 2
-else ifeq ($(HARDWARE_MOTHERBOARD),1132)
-# bq ZUM Mega 3D
-else ifeq ($(HARDWARE_MOTHERBOARD),1133)
-# MakeBoard Mini v2.1.2 by MicroMake
-else ifeq ($(HARDWARE_MOTHERBOARD),1134)
-# TriGorilla Anycubic version 1.3-based on RAMPS EFB
-else ifeq ($(HARDWARE_MOTHERBOARD),1135)
-#   ... Ver 1.4
-else ifeq ($(HARDWARE_MOTHERBOARD),1136)
-#   ... Rev 1.1 (new servo pin order)
-else ifeq ($(HARDWARE_MOTHERBOARD),1137)
-# Creality: Ender-4, CR-8
-else ifeq ($(HARDWARE_MOTHERBOARD),1138)
-# Creality: CR10S, CR20, CR-X
-else ifeq ($(HARDWARE_MOTHERBOARD),1139)
-# Dagoma F5
-else ifeq ($(HARDWARE_MOTHERBOARD),1140)
-# FYSETC F6 1.3
-else ifeq ($(HARDWARE_MOTHERBOARD),1141)
-# FYSETC F6 1.4
-else ifeq ($(HARDWARE_MOTHERBOARD),1142)
-# Wanhao Duplicator i3 Plus
-else ifeq ($(HARDWARE_MOTHERBOARD),1143)
-# VORON Design
-else ifeq ($(HARDWARE_MOTHERBOARD),1144)
-# Tronxy TRONXY-V3-1.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1145)
-# Z-Bolt X Series
-else ifeq ($(HARDWARE_MOTHERBOARD),1146)
-# TT OSCAR
-else ifeq ($(HARDWARE_MOTHERBOARD),1147)
-# Overlord/Overlord Pro
-else ifeq ($(HARDWARE_MOTHERBOARD),1148)
-# ADIMLab Gantry v1
-else ifeq ($(HARDWARE_MOTHERBOARD),1149)
-# ADIMLab Gantry v2
-else ifeq ($(HARDWARE_MOTHERBOARD),1150)
-# BIQU Tango V1
-else ifeq ($(HARDWARE_MOTHERBOARD),1151)
-# MKS GEN L V2
-else ifeq ($(HARDWARE_MOTHERBOARD),1152)
-# MKS GEN L V2.1
-else ifeq ($(HARDWARE_MOTHERBOARD),1153)
-# Copymaster 3D
-else ifeq ($(HARDWARE_MOTHERBOARD),1154)
-# Ortur 4
-else ifeq ($(HARDWARE_MOTHERBOARD),1155)
-# Tenlog D3 Hero IDEX printer
-else ifeq ($(HARDWARE_MOTHERBOARD),1156)
-# Ramps S 1.2 by Sakul.cz (Power outputs: Hotend0, Hotend1, Fan, Bed)
-else ifeq ($(HARDWARE_MOTHERBOARD),1157)
-# Ramps S 1.2 by Sakul.cz (Power outputs: Hotend0, Hotend1, Hotend2, Bed)
-else ifeq ($(HARDWARE_MOTHERBOARD),1158)
-# Ramps S 1.2 by Sakul.cz (Power outputs: Hotend, Fan0, Fan1, Bed)
-else ifeq ($(HARDWARE_MOTHERBOARD),1159)
-# Longer LK1 PRO / Alfawise U20 Pro (PRO version)
-else ifeq ($(HARDWARE_MOTHERBOARD),1160)
-# Longer LKx PRO / Alfawise Uxx Pro (PRO version)
-else ifeq ($(HARDWARE_MOTHERBOARD),1161)
-
-
 # 3Drag Controller
 else ifeq ($(HARDWARE_MOTHERBOARD),1100)
 # Velleman K8200 Controller (derived from 3Drag Controller)
@@ -486,38 +358,20 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1311)
 else ifeq ($(HARDWARE_MOTHERBOARD),1312)
 # Mega controller
 else ifeq ($(HARDWARE_MOTHERBOARD),1313)
-# Geeetech GT2560 Rev A
-else ifeq ($(HARDWARE_MOTHERBOARD),1314)
-# Geeetech GT2560 Rev A+ (with auto level probe)
-else ifeq ($(HARDWARE_MOTHERBOARD),1315)
-# Geeetech GT2560 Rev B
-else ifeq ($(HARDWARE_MOTHERBOARD),1316)
-# Geeetech GT2560 Rev B for A10(M/T/D)
-else ifeq ($(HARDWARE_MOTHERBOARD),1317)
-# Geeetech GT2560 Rev B for A10(M/T/D)
-else ifeq ($(HARDWARE_MOTHERBOARD),1318)
 # Geeetech GT2560 Rev B for Mecreator2
-else ifeq ($(HARDWARE_MOTHERBOARD),1319)
-# Geeetech GT2560 Rev B for A20(M/T/D)
-else ifeq ($(HARDWARE_MOTHERBOARD),1320)
+else ifeq ($(HARDWARE_MOTHERBOARD),1314)
+# Geeetech GT2560 Rev. A
+else ifeq ($(HARDWARE_MOTHERBOARD),1315)
+# Geeetech GT2560 Rev. A+ (with auto level probe)
+else ifeq ($(HARDWARE_MOTHERBOARD),1316)
+# Geeetech GT2560 Rev B for A10(M/D)
+else ifeq ($(HARDWARE_MOTHERBOARD),1317)
+# Geeetech GT2560 Rev B for A20(M/D)
+else ifeq ($(HARDWARE_MOTHERBOARD),1318)
 # Einstart retrofit
-else ifeq ($(HARDWARE_MOTHERBOARD),1321)
+else ifeq ($(HARDWARE_MOTHERBOARD),1319)
 # Wanhao 0ne+ i3 Mini
-else ifeq ($(HARDWARE_MOTHERBOARD),1322)
-# Leapfrog Xeed 2015
-else ifeq ($(HARDWARE_MOTHERBOARD),1323)
-# PICA Shield (original version)
-else ifeq ($(HARDWARE_MOTHERBOARD),1324)
-# PICA Shield (rev C or later)
-else ifeq ($(HARDWARE_MOTHERBOARD),1325)
-# Intamsys 4.0 (Funmat HT)
-else ifeq ($(HARDWARE_MOTHERBOARD),1326)
-# Malyan M180 Mainboard Version 2 (no display function, direct gcode only)
-else ifeq ($(HARDWARE_MOTHERBOARD),1327)
-# Geeetech GT2560 Rev B for A20(M/T/D)
-else ifeq ($(HARDWARE_MOTHERBOARD),1328)
-# Mega controller & Protoneer CNC Shield V3.00
-else ifeq ($(HARDWARE_MOTHERBOARD),1329)
+else ifeq ($(HARDWARE_MOTHERBOARD),1320)

 #
 # ATmega1281, ATmega2561
@@ -591,11 +445,6 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1510)
  HARDWARE_VARIANT ?= Sanguino
  MCU              ?= atmega1284p
  PROG_MCU         ?= m1284p
-# ZoneStar ZMIB V2
-else ifeq ($(HARDWARE_MOTHERBOARD),1511)
-  HARDWARE_VARIANT ?= Sanguino
-  MCU              ?= atmega1284p
-  PROG_MCU         ?= m1284p

 #
 # Other ATmega644P, ATmega644, ATmega1284P
@@ -28,25 +28,25 @@
 /**
 * Marlin release version identifier
 */
-//#define SHORT_BUILD_VERSION "bugfix-2.0.x"
+#define SHORT_BUILD_VERSION "2.0.8"

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

 /**
 * The STRING_DISTRIBUTION_DATE represents when the binary file was built,
 * here we define this default string as the date where the latest release
 * version was tagged.
 */
-//#define STRING_DISTRIBUTION_DATE "2022-04-05"
+#define STRING_DISTRIBUTION_DATE "2021-06-05"

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

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

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

 /**
 * Set the vendor info the serial USB interface, if changable
@@ -0,0 +1,113 @@
+/**
+ * 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
+ */
+#pragma once
+
+#define CUSTOM_BOOTSCREEN_TIMEOUT   2500
+#define CUSTOM_BOOTSCREEN_BMPWIDTH  128
+#define CUSTOM_BOOTSCREEN_BMPHEIGHT 64
+
+/**
+ * Made with Marlin Bitmap Converter
+ * https://marlinfw.org/tools/u8glib/converter.html
+ *
+ * This bitmap from 128x64 C/C++ data
+ */
+
+
+#define HMIJ3S_BMPWIDTH  128
+
+const unsigned char custom_start_bmp[] PROGMEM = {
+  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00001111,B11100000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,B11111000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B01111111,B11111100,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B11111111,B11111110,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B11111111,B11111110,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000001,B11111111,B11111111,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000001,B11111111,B11111111,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000001,B11111111,B11111111,B10000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000011,B11111111,B11111111,B11100000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000111,B11111111,B11111111,B11100000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000111,B11111111,B11111111,B11111000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00001111,B11111111,B11111111,B11111000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00011111,B11111111,B11111111,B11111100,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,B11111111,B11111111,B11111110,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B01111111,B11111111,B01111111,B11111111,B10000000,B00000000,B00000000,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B11111111,B11111110,B00011111,B11111111,B11000000,B00000000,B00000000,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B11111111,B11111100,B00001111,B11111111,B11100000,B00000000,B00000000,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000000,B00000001,B11111111,B11111000,B00000011,B11111111,B11110000,B00000000,B00000000,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000000,B00000011,B11111111,B11111000,B00000001,B11111111,B11111000,B00000000,B00000000,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000000,B00000111,B11111111,B11110000,B00000000,B11111111,B11111100,B00000000,B00000000,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000000,B00001111,B11111111,B11100000,B00000000,B00111111,B11111110,B00000000,B00000000,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000000,B00011111,B11111111,B11000000,B00000000,B00001111,B11111111,B00000000,B00000000,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000000,B00011111,B11111111,B10000000,B00000000,B00000111,B11111111,B10000000,B00000000,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,B11111111,B00000000,B00000000,B00000001,B11111111,B11111000,B00000000,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000000,B01111111,B11111111,B00000000,B00000000,B00000000,B11111111,B11111110,B00000000,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000000,B11111111,B11111110,B00000000,B00000000,B00000000,B01111111,B11111111,B00000000,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000001,B11111111,B11111100,B00000000,B00000000,B00000000,B00011111,B11111111,B10000000,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000001,B11111111,B11111000,B00000000,B00000000,B00000000,B00001111,B11111111,B10000000,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000011,B11111111,B11110000,B00000000,B00000000,B00000000,B00000111,B11111111,B10000000,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000111,B11111111,B11100000,B00000000,B00000000,B00000000,B00000111,B11111111,B11100000,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00001111,B11111111,B11100000,B00000000,B00000000,B00000000,B00000011,B11111111,B11111110,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00011111,B11111111,B11000000,B00000000,B00000000,B00000000,B00000001,B11111111,B11111110,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00111111,B11111111,B10000000,B00000000,B00000000,B00000000,B00000000,B11111110,B01111110,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000001,B11111111,B11111111,B00000000,B00000000,B00000000,B00000000,B00000000,B11111000,B00001110,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00001111,B11111111,B11111110,B00000000,B00000000,B00000000,B00000000,B00000000,B11110000,B00001110,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00011111,B11111111,B11111100,B00000000,B00000000,B00000000,B00000000,B00000000,B11100000,B00000110,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00111111,B11111111,B11111100,B00000000,B00000000,B00000000,B00000000,B00000000,B11100000,B00000110,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B01111111,B11111111,B11111000,B00000000,B00000000,B00000000,B00000000,B00000001,B11100000,B00000110,B00000000,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B01111111,B11111111,B11110000,B00000000,B00000000,B00000000,B00000000,B00000001,B11111000,B00000110,B00000000,B00000000,B00000000,
+  B00000000,B00000111,B11111111,B11111111,B11111111,B11100000,B00000000,B00000000,B00000000,B00000000,B00000001,B11111111,B00111110,B00000000,B00000000,B00000000,
+  B00000000,B00011111,B11111111,B11111111,B11111111,B11100000,B00000000,B00000000,B00000000,B00000000,B00000000,B00011111,B11111001,B11110000,B00000000,B00000000,
+  B00000000,B00011111,B11111111,B11111111,B11111111,B11100000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000001,B11111111,B11110000,B00000000,B00000000,
+  B00000000,B00011111,B11111111,B11111111,B11111111,B11100000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000011,B11111111,B11000000,B00000000,B00000000,
+  B00000000,B00011111,B11111111,B11111111,B11111111,B11100000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000011,B11111111,B11100010,B00000000,B00000000,
+  B00000000,B00011111,B11111111,B11111111,B11111111,B11000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B11111111,B11111111,B10000000,B00000000,
+  B00000000,B00011111,B11111111,B11111111,B11111111,B11000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B01000011,B11111111,B11000000,B00000000,
+  B00000000,B00011111,B11111111,B11111111,B11111111,B10000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000111,B11111111,B10000000,B00000000,
+  B00000000,B00011111,B11111111,B11111111,B11111111,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00001111,B11111100,B00000000,B00000000,
+  B00000000,B00001111,B11111111,B11111111,B11111000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00011111,B11111100,B00000000,B00000000,
+  B00011111,B11111111,B11111111,B11111111,B11111111,B11111111,B11100000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000100,B00111100,B00000000,B00000000,
+  B00111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11100000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00111001,B00000000,B00000000,
+  B00111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11100000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B11100001,B11000000,B00000000,
+  B00111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11100000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000001,B11111111,B11110000,B00000000,
+  B00111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11100000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B11111111,B11111100,B00000000,
+  B00111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11100000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B11111111,B11111111,B00000000,
+  B00011111,B11111111,B11111111,B11111111,B11111111,B11111111,B11100000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000111,B11111111,B11100111,B11000000,
+  B00001111,B11111111,B11111111,B11111111,B11111111,B11111111,B10000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000111,B11111111,B11000011,B11110000,
+  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000011,B11011111,B11100001,B10000000,
+  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00001111,B11110000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000111,B11100000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000011,B00000000,B00000000,
+  B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000
+};
@@ -35,32 +35,13 @@
 // Public Variables
 // ------------------------

-// Don't initialize/override variable (which would happen in .init4)
-uint8_t MarlinHAL::reset_reason __attribute__((section(".noinit")));
+//uint8_t MCUSR;

 // ------------------------
 // Public functions
 // ------------------------

-__attribute__((naked))             // Don't output function pro- and epilogue
-__attribute__((used))              // Output the function, even if "not used"
-__attribute__((section(".init3"))) // Put in an early user definable section
-void save_reset_reason() {
-  #if ENABLED(OPTIBOOT_RESET_REASON)
-    __asm__ __volatile__(
-      A("STS %0, r2")
-      : "=m"(hal.reset_reason)
-    );
-  #else
-    hal.reset_reason = MCUSR;
-  #endif
-
-  // Clear within 16ms since WDRF bit enables a 16ms watchdog timer -> Boot loop
-  hal.clear_reset_source();
-  wdt_disable();
-}
-
-void MarlinHAL::init() {
+void HAL_init() {
  // Init Servo Pins
  #define INIT_SERVO(N) OUT_WRITE(SERVO##N##_PIN, LOW)
  #if HAS_SERVO_0
@@ -75,11 +56,9 @@ void MarlinHAL::init() {
  #if HAS_SERVO_3
    INIT_SERVO(3);
  #endif
-
-  init_pwm_timers();   // Init user timers to default frequency - 1000HZ
 }

-void MarlinHAL::reboot() {
+void HAL_reboot() {
  #if ENABLED(USE_WATCHDOG)
    while (1) { /* run out the watchdog */ }
  #else
@@ -95,20 +74,20 @@ void MarlinHAL::reboot() {

 #else // !SDSUPPORT

-  extern "C" {
-    extern char __bss_end;
-    extern char __heap_start;
-    extern void* __brkval;
+extern "C" {
+  extern char __bss_end;
+  extern char __heap_start;
+  extern void* __brkval;

-    int freeMemory() {
-      int free_memory;
-      if ((int)__brkval == 0)
-        free_memory = ((int)&free_memory) - ((int)&__bss_end);
-      else
-        free_memory = ((int)&free_memory) - ((int)__brkval);
-      return free_memory;
-    }
+  int freeMemory() {
+    int free_memory;
+    if ((int)__brkval == 0)
+      free_memory = ((int)&free_memory) - ((int)&__bss_end);
+    else
+      free_memory = ((int)&free_memory) - ((int)__brkval);
+    return free_memory;
  }
+}

 #endif // !SDSUPPORT

@@ -39,19 +39,6 @@
 #include <avr/interrupt.h>
 #include <avr/io.h>

-//
-// Default graphical display delays
-//
-#if F_CPU >= 20000000
-  #define CPU_ST7920_DELAY_1 150
-  #define CPU_ST7920_DELAY_2   0
-  #define CPU_ST7920_DELAY_3 150
-#elif F_CPU == 16000000
-  #define CPU_ST7920_DELAY_1 125
-  #define CPU_ST7920_DELAY_2   0
-  #define CPU_ST7920_DELAY_3 188
-#endif
-
 #ifndef pgm_read_ptr
  // Compatibility for avr-libc 1.8.0-4.1 included with Ubuntu for
  // Windows Subsystem for Linux on Windows 10 as of 10/18/2019
@@ -74,9 +61,9 @@
  #define CRITICAL_SECTION_START()  unsigned char _sreg = SREG; cli()
  #define CRITICAL_SECTION_END()    SREG = _sreg
 #endif
-
-#define HAL_CAN_SET_PWM_FREQ   // This HAL supports PWM Frequency adjustment
-#define PWM_FREQUENCY 1000     // Default PWM frequency when set_pwm_duty() is called without set_pwm_frequency()
+#define ISRS_ENABLED() TEST(SREG, SREG_I)
+#define ENABLE_ISRS()  sei()
+#define DISABLE_ISRS() cli()

 // ------------------------
 // Types
@@ -84,15 +71,16 @@

 typedef int8_t pin_t;

-#define SHARED_SERVOS HAS_SERVOS  // Use shared/servos.cpp
-
-class Servo;
-typedef Servo hal_servo_t;
+#define SHARED_SERVOS HAS_SERVOS
+#define HAL_SERVO_LIB Servo

 // ------------------------
+// Public Variables
+// ------------------------
+
+//extern uint8_t MCUSR;
+
 // Serial ports
-// ------------------------
-
 #ifdef USBCON
  #include "../../core/serial_hook.h"
  typedef ForwardSerial1Class< decltype(Serial) > DefaultSerial1;
@@ -141,20 +129,64 @@ typedef Servo hal_servo_t;
  #endif
 #endif

-//
+// ------------------------
+// Public functions
+// ------------------------
+
+void HAL_init();
+
+//void cli();
+
+//void _delay_ms(const int delay);
+
+inline void HAL_clear_reset_source() { MCUSR = 0; }
+inline uint8_t HAL_get_reset_source() { return MCUSR; }
+
+void HAL_reboot();
+
+#if GCC_VERSION <= 50000
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wunused-function"
+#endif
+
+extern "C" int freeMemory();
+
+#if GCC_VERSION <= 50000
+  #pragma GCC diagnostic pop
+#endif
+
 // ADC
-//
+#ifdef DIDR2
+  #define HAL_ANALOG_SELECT(ind) do{ if (ind < 8) SBI(DIDR0, ind); else SBI(DIDR2, ind & 0x07); }while(0)
+#else
+  #define HAL_ANALOG_SELECT(ind) SBI(DIDR0, ind);
+#endif
+
+inline void HAL_adc_init() {
+  ADCSRA = _BV(ADEN) | _BV(ADSC) | _BV(ADIF) | 0x07;
+  DIDR0 = 0;
+  #ifdef DIDR2
+    DIDR2 = 0;
+  #endif
+}
+
+#define SET_ADMUX_ADCSRA(ch) ADMUX = _BV(REFS0) | (ch & 0x07); SBI(ADCSRA, ADSC)
+#ifdef MUX5
+  #define HAL_START_ADC(ch) if (ch > 7) ADCSRB = _BV(MUX5); else ADCSRB = 0; SET_ADMUX_ADCSRA(ch)
+#else
+  #define HAL_START_ADC(ch) ADCSRB = 0; SET_ADMUX_ADCSRA(ch)
+#endif
+
 #define HAL_ADC_VREF        5.0
 #define HAL_ADC_RESOLUTION 10
+#define HAL_READ_ADC()  ADC
+#define HAL_ADC_READY() !TEST(ADCSRA, ADSC)

-//
-// Pin Mapping for M42, M43, M226
-//
 #define GET_PIN_MAP_PIN(index) index
 #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)
@@ -163,109 +195,23 @@ typedef Servo hal_servo_t;
 // AVR compatibility
 #define strtof strtod

-// ------------------------
-// Class Utilities
-// ------------------------
+#define HAL_CAN_SET_PWM_FREQ   // This HAL supports PWM Frequency adjustment

-#pragma GCC diagnostic push
-#if GCC_VERSION <= 50000
-  #pragma GCC diagnostic ignored "-Wunused-function"
-#endif
+/**
+ *  set_pwm_frequency
+ *  Sets the frequency of the timer corresponding to the provided pin
+ *  as close as possible to the provided desired frequency. Internally
+ *  calculates the required waveform generation mode, prescaler and
+ *  resolution values required and sets the timer registers accordingly.
+ *  NOTE that the frequency is applied to all pins on the timer (Ex OC3A, OC3B and OC3B)
+ *  NOTE that there are limitations, particularly if using TIMER2. (see Configuration_adv.h -> FAST FAN PWM Settings)
+ */
+void set_pwm_frequency(const pin_t pin, int f_desired);

-extern "C" int freeMemory();
-
-#pragma GCC diagnostic pop
-
-// ------------------------
-// MarlinHAL Class
-// ------------------------
-
-class MarlinHAL {
-public:
-
-  // Earliest possible init, before setup()
-  MarlinHAL() {}
-
-  static void init();          // Called early in setup()
-  static void init_board() {}  // Called less early in setup()
-  static void reboot();        // Restart the firmware from 0x0
-
-  // Interrupts
-  static bool isr_state() { return TEST(SREG, SREG_I); }
-  static void isr_on()  { sei(); }
-  static void isr_off() { cli(); }
-
-  static void delay_ms(const int ms) { _delay_ms(ms); }
-
-  // Tasks, called from idle()
-  static void idletask() {}
-
-  // Reset
-  static uint8_t reset_reason;
-  static uint8_t get_reset_source() { return reset_reason; }
-  static void clear_reset_source() { MCUSR = 0; }
-
-  // Free SRAM
-  static int freeMemory() { return ::freeMemory(); }
-
-  //
-  // ADC Methods
-  //
-
-  // Called by Temperature::init once at startup
-  static void adc_init() {
-    ADCSRA = _BV(ADEN) | _BV(ADSC) | _BV(ADIF) | 0x07;
-    DIDR0 = 0;
-    #ifdef DIDR2
-      DIDR2 = 0;
-    #endif
-  }
-
-  // Called by Temperature::init for each sensor at startup
-  static void adc_enable(const uint8_t ch) {
-    #ifdef DIDR2
-      if (ch > 7) { SBI(DIDR2, ch & 0x07); return; }
-    #endif
-    SBI(DIDR0, ch);
-  }
-
-  // Begin ADC sampling on the given channel. Called from Temperature::isr!
-  static void adc_start(const uint8_t ch) {
-    #ifdef MUX5
-      ADCSRB = ch > 7 ? _BV(MUX5) : 0;
-    #else
-      ADCSRB = 0;
-    #endif
-    ADMUX = _BV(REFS0) | (ch & 0x07);
-    SBI(ADCSRA, ADSC);
-  }
-
-  // Is the ADC ready for reading?
-  static bool adc_ready() { return !TEST(ADCSRA, ADSC); }
-
-  // The current value of the ADC register
-  static __typeof__(ADC) adc_value() { return ADC; }
-
-  /**
-   * init_pwm_timers
-   * Set the default frequency for timers 2-5 to 1000HZ
-   */
-  static void init_pwm_timers();
-
-  /**
-   * Set the PWM duty cycle for the pin to the given value.
-   * Optionally invert the duty cycle [default = false]
-   * Optionally change the scale of the provided value to enable finer PWM duty control [default = 255]
-   */
-  static void set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size=255, const bool invert=false);
-
-  /**
-   * Set the frequency of the timer for the given pin as close as
-   * possible to the provided desired frequency. Internally calculate
-   * the required waveform generation mode, prescaler, and resolution
-   * values and set timer registers accordingly.
-   * NOTE that the frequency is applied to all pins on the timer (Ex OC3A, OC3B and OC3B)
-   * NOTE that there are limitations, particularly if using TIMER2. (see Configuration_adv.h -> FAST_PWM_FAN Settings)
-   */
-  static void set_pwm_frequency(const pin_t pin, const uint16_t f_desired);
-};
+/**
+ * set_pwm_duty
+ *  Sets the PWM duty cycle of the provided pin to the provided value
+ *  Optionally allows inverting the duty cycle [default = false]
+ *  Optionally allows changing the maximum size of the provided value to enable finer PWM duty control [default = 255]
+ */
+void set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size=255, const bool invert=false);
@@ -34,21 +34,21 @@
 #include "../../inc/MarlinConfig.h"

 void spiBegin() {
-  #if PIN_EXISTS(SD_SS)
-    // Do not init HIGH for boards with pin 4 used as Fans or Heaters or otherwise, not likely to have multiple SPI devices anyway.
-    #if defined(__AVR_ATmega644__) || defined(__AVR_ATmega644P__) || defined(__AVR_ATmega644PA__) || defined(__AVR_ATmega1284P__)
-      // SS must be in output mode even it is not chip select
-      SET_OUTPUT(SD_SS_PIN);
-    #else
-      // set SS high - may be chip select for another SPI device
-      OUT_WRITE(SD_SS_PIN, HIGH);
-    #endif
-  #endif
+  OUT_WRITE(SD_SS_PIN, HIGH);
  SET_OUTPUT(SD_SCK_PIN);
  SET_INPUT(SD_MISO_PIN);
  SET_OUTPUT(SD_MOSI_PIN);

-  IF_DISABLED(SOFTWARE_SPI, spiInit(SPI_HALF_SPEED));
+  #if DISABLED(SOFTWARE_SPI)
+    // SS must be in output mode even it is not chip select
+    //SET_OUTPUT(SD_SS_PIN);
+    // set SS high - may be chip select for another SPI device
+    //#if SET_SPI_SS_HIGH
+      //WRITE(SD_SS_PIN, HIGH);
+    //#endif
+    // set a default rate
+    spiInit(1);
+  #endif
 }

 #if NONE(SOFTWARE_SPI, FORCE_SOFT_SPI)
@@ -74,8 +74,7 @@ void spiBegin() {
      #elif defined(PRR0)
        PRR0
      #endif
-      , PRSPI
-    );
+        , PRSPI);

    SPCR = _BV(SPE) | _BV(MSTR) | (spiRate >> 1);
    SPSR = spiRate & 1 || spiRate == 6 ? 0 : _BV(SPI2X);
@@ -1,26 +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 <SPI.h>
-
-using MarlinSPI = SPIClass;
@@ -486,7 +486,7 @@ void MarlinSerial<Cfg>::write(const uint8_t c) {
    const uint8_t i = (tx_buffer.head + 1) & (Cfg::TX_SIZE - 1);

    // If global interrupts are disabled (as the result of being called from an ISR)...
-    if (!hal.isr_state()) {
+    if (!ISRS_ENABLED()) {

      // Make room by polling if it is possible to transmit, and do so!
      while (i == tx_buffer.tail) {
@@ -534,7 +534,7 @@ void MarlinSerial<Cfg>::flushTX() {
    if (!_written) return;

    // If global interrupts are disabled (as the result of being called from an ISR)...
-    if (!hal.isr_state()) {
+    if (!ISRS_ENABLED()) {

      // Wait until everything was transmitted - We must do polling, as interrupts are disabled
      while (tx_buffer.head != tx_buffer.tail || !B_TXC) {
@@ -191,13 +191,13 @@
                   rx_framing_errors;
    static ring_buffer_pos_t rx_max_enqueued;

-    FORCE_INLINE static ring_buffer_pos_t atomic_read_rx_head();
+    static FORCE_INLINE ring_buffer_pos_t atomic_read_rx_head();

    static volatile bool rx_tail_value_not_stable;
    static volatile uint16_t rx_tail_value_backup;

-    FORCE_INLINE static void atomic_set_rx_tail(ring_buffer_pos_t value);
-    FORCE_INLINE static ring_buffer_pos_t atomic_read_rx_tail();
+    static FORCE_INLINE void atomic_set_rx_tail(ring_buffer_pos_t value);
+    static FORCE_INLINE ring_buffer_pos_t atomic_read_rx_tail();

  public:
    FORCE_INLINE static void store_rxd_char();
@@ -217,7 +217,7 @@
    #endif

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

    FORCE_INLINE static uint8_t dropped() { return Cfg::DROPPED_RX ? rx_dropped_bytes : 0; }
    FORCE_INLINE static uint8_t buffer_overruns() { return Cfg::RX_OVERRUNS ? rx_buffer_overruns : 0; }
@@ -213,51 +213,6 @@ void setup_endstop_interrupts() {
      pciSetup(K_MIN_PIN);
    #endif
  #endif
-  #if HAS_U_MAX
-    #if (digitalPinToInterrupt(U_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(U_MAX_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(U_MAX_PIN), "U_MAX_PIN is not interrupt-capable");
-      pciSetup(U_MAX_PIN);
-    #endif
-  #elif HAS_U_MIN
-    #if (digitalPinToInterrupt(U_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(U_MIN_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(U_MIN_PIN), "U_MIN_PIN is not interrupt-capable");
-      pciSetup(U_MIN_PIN);
-    #endif
-  #endif
-  #if HAS_V_MAX
-    #if (digitalPinToInterrupt(V_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(V_MAX_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(V_MAX_PIN), "V_MAX_PIN is not interrupt-capable");
-      pciSetup(V_MAX_PIN);
-    #endif
-  #elif HAS_V_MIN
-    #if (digitalPinToInterrupt(V_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(V_MIN_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(V_MIN_PIN), "V_MIN_PIN is not interrupt-capable");
-      pciSetup(V_MIN_PIN);
-    #endif
-  #endif
-  #if HAS_W_MAX
-    #if (digitalPinToInterrupt(W_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(W_MAX_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(W_MAX_PIN), "W_MAX_PIN is not interrupt-capable");
-      pciSetup(W_MAX_PIN);
-    #endif
-  #elif HAS_W_MIN
-    #if (digitalPinToInterrupt(W_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(W_MIN_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(W_MIN_PIN), "W_MIN_PIN is not interrupt-capable");
-      pciSetup(W_MIN_PIN);
-    #endif
-  #endif
  #if HAS_X2_MAX
    #if (digitalPinToInterrupt(X2_MAX_PIN) != NOT_AN_INTERRUPT)
      _ATTACH(X2_MAX_PIN);
@@ -346,6 +301,5 @@ 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.
 }
@@ -21,7 +21,11 @@
 */
 #ifdef __AVR__

-#include "../../inc/MarlinConfig.h"
+#include "../../inc/MarlinConfigPre.h"
+
+#if NEEDS_HARDWARE_PWM // Specific meta-flag for features that mandate PWM
+
+#include "HAL.h"

 struct Timer {
  volatile uint8_t* TCCRnQ[3];  // max 3 TCCR registers per timer
@@ -29,194 +33,250 @@ struct Timer {
  volatile uint16_t* ICRn;      // max 1 ICR register per timer
  uint8_t n;                    // the timer number [0->5]
  uint8_t q;                    // the timer output [0->2] (A->C)
-  bool isPWM;                   // True if pin is a "hardware timer"
-  bool isProtected;             // True if timer is protected
 };

-// Macros for the Timer structure
-#define _SET_WGMnQ(T, V) do{ \
-    *(T.TCCRnQ)[0] = (*(T.TCCRnQ)[0] & ~(0x3 << 0)) | (( int(V)       & 0x3) << 0); \
-    *(T.TCCRnQ)[1] = (*(T.TCCRnQ)[1] & ~(0x3 << 3)) | (((int(V) >> 2) & 0x3) << 3); \
-  }while(0)
-
-// Set TCCR CS bits
-#define _SET_CSn(T, V) (*(T.TCCRnQ)[1] = (*(T.TCCRnQ[1]) & ~(0x7 << 0)) | ((int(V) & 0x7) << 0))
-
-// Set TCCR COM bits
-#define _SET_COMnQ(T, Q, V) (*(T.TCCRnQ)[0] = (*(T.TCCRnQ)[0] & ~(0x3 << (6-2*(Q)))) | (int(V) << (6-2*(Q))))
-
-// Set OCRnQ register
-#define _SET_OCRnQ(T, Q, V) (*(T.OCRnQ)[Q] = int(V) & 0xFFFF)
-
-// Set ICRn register (one per timer)
-#define _SET_ICRn(T, V) (*(T.ICRn) = int(V) & 0xFFFF)
-
 /**
- * Return a Timer struct describing a pin's timer.
+ * get_pwm_timer
+ *  Get the timer information and register of the provided pin.
+ *  Return a Timer struct containing this information.
+ *  Used by set_pwm_frequency, set_pwm_duty
 */
-const Timer get_pwm_timer(const pin_t pin) {
-
+Timer get_pwm_timer(const pin_t pin) {
  uint8_t q = 0;
-
  switch (digitalPinToTimer(pin)) {
+    // Protect reserved timers (TIMER0 & TIMER1)
    #ifdef TCCR0A
-      IF_DISABLED(AVR_AT90USB1286_FAMILY, case TIMER0A:)
+      #if !AVR_AT90USB1286_FAMILY
+        case TIMER0A:
+      #endif
+      case TIMER0B:
    #endif
    #ifdef TCCR1A
      case TIMER1A: case TIMER1B:
    #endif
-
-    break;    // Protect reserved timers (TIMER0 & TIMER1)
-
-    #ifdef TCCR0A
-      case TIMER0B:   // Protected timer, but allow setting the duty cycle on OCR0B for pin D4 only
-        return Timer({ { &TCCR0A, nullptr, nullptr }, { (uint16_t*)&OCR0A, (uint16_t*)&OCR0B, nullptr }, nullptr, 0, 1, true, true });
+                                        break;
+    #if defined(TCCR2) || defined(TCCR2A)
+      #ifdef TCCR2
+        case TIMER2: {
+          Timer timer = {
+            /*TCCRnQ*/  { &TCCR2, nullptr, nullptr },
+            /*OCRnQ*/   { (uint16_t*)&OCR2, nullptr, nullptr },
+            /*ICRn*/      nullptr,
+            /*n, q*/      2, 0
+          };
+        }
+      #elif defined(TCCR2A)
+        #if ENABLED(USE_OCR2A_AS_TOP)
+          case TIMER2A:   break; // protect TIMER2A
+          case TIMER2B: {
+            Timer timer = {
+              /*TCCRnQ*/  { &TCCR2A,  &TCCR2B,  nullptr },
+              /*OCRnQ*/   { (uint16_t*)&OCR2A, (uint16_t*)&OCR2B, nullptr },
+              /*ICRn*/      nullptr,
+              /*n, q*/      2, 1
+            };
+            return timer;
+          }
+        #else
+          case TIMER2B:   ++q;
+          case TIMER2A: {
+            Timer timer = {
+              /*TCCRnQ*/  { &TCCR2A,  &TCCR2B,  nullptr },
+              /*OCRnQ*/   { (uint16_t*)&OCR2A, (uint16_t*)&OCR2B, nullptr },
+              /*ICRn*/      nullptr,
+                            2, q
+            };
+            return timer;
+          }
+        #endif
+      #endif
    #endif
-
-    #if HAS_TCCR2
-      case TIMER2:
-        return Timer({ { &TCCR2, nullptr, nullptr }, { (uint16_t*)&OCR2, nullptr, nullptr }, nullptr, 2, 0, true, false });
-    #elif ENABLED(USE_OCR2A_AS_TOP)
-      case TIMER2A: break; // Protect TIMER2A since its OCR is used by TIMER2B
-      case TIMER2B:
-        return Timer({ { &TCCR2A, &TCCR2B, nullptr }, { (uint16_t*)&OCR2A, (uint16_t*)&OCR2B, nullptr }, nullptr, 2, 1, true, false });
-    #elif defined(TCCR2A)
-      case TIMER2B: ++q; case TIMER2A:
-        return Timer({ { &TCCR2A, &TCCR2B, nullptr }, { (uint16_t*)&OCR2A, (uint16_t*)&OCR2B, nullptr }, nullptr, 2, q, true, false });
-    #endif
-
    #ifdef OCR3C
-      case TIMER3C: ++q; case TIMER3B: ++q; case TIMER3A:
-        return Timer({ { &TCCR3A, &TCCR3B, &TCCR3C }, { &OCR3A, &OCR3B, &OCR3C  }, &ICR3, 3, q, true, false });
+      case TIMER3C:   ++q;
+      case TIMER3B:   ++q;
+      case TIMER3A: {
+        Timer timer = {
+          /*TCCRnQ*/  { &TCCR3A,  &TCCR3B,  &TCCR3C },
+          /*OCRnQ*/   { &OCR3A,   &OCR3B,   &OCR3C },
+          /*ICRn*/      &ICR3,
+          /*n, q*/      3, q
+        };
+        return timer;
+      }
    #elif defined(OCR3B)
-      case TIMER3B: ++q; case TIMER3A:
-        return Timer({ { &TCCR3A, &TCCR3B, nullptr }, { &OCR3A, &OCR3B, nullptr }, &ICR3, 3, q, true, false });
+      case TIMER3B:   ++q;
+      case TIMER3A: {
+        Timer timer = {
+          /*TCCRnQ*/  { &TCCR3A,  &TCCR3B,  nullptr },
+          /*OCRnQ*/   { &OCR3A,   &OCR3B,  nullptr },
+          /*ICRn*/      &ICR3,
+          /*n, q*/      3, q
+        };
+        return timer;
+      }
    #endif
-
    #ifdef TCCR4A
-      case TIMER4C: ++q; case TIMER4B: ++q; case TIMER4A:
-        return Timer({ { &TCCR4A, &TCCR4B, &TCCR4C }, { &OCR4A, &OCR4B, &OCR4C }, &ICR4, 4, q, true, false });
+      case TIMER4C:   ++q;
+      case TIMER4B:   ++q;
+      case TIMER4A: {
+        Timer timer = {
+          /*TCCRnQ*/  { &TCCR4A,  &TCCR4B,  &TCCR4C },
+          /*OCRnQ*/   { &OCR4A,   &OCR4B,   &OCR4C },
+          /*ICRn*/      &ICR4,
+          /*n, q*/      4, q
+        };
+        return timer;
+      }
    #endif
-
    #ifdef TCCR5A
-      case TIMER5C: ++q; case TIMER5B: ++q; case TIMER5A:
-        return Timer({ { &TCCR5A, &TCCR5B, &TCCR5C }, { &OCR5A, &OCR5B, &OCR5C }, &ICR5, 5, q, true, false });
+      case TIMER5C:   ++q;
+      case TIMER5B:   ++q;
+      case TIMER5A: {
+        Timer timer = {
+          /*TCCRnQ*/  { &TCCR5A,  &TCCR5B,  &TCCR5C },
+          /*OCRnQ*/   { &OCR5A,   &OCR5B,   &OCR5C },
+          /*ICRn*/      &ICR5,
+          /*n, q*/      5, q
+        };
+        return timer;
+      }
    #endif
  }
-
-  return Timer();
+  Timer timer = {
+      /*TCCRnQ*/  { nullptr, nullptr, nullptr },
+      /*OCRnQ*/   { nullptr, nullptr, nullptr },
+      /*ICRn*/      nullptr,
+                    0, 0
+  };
+  return timer;
 }

-void MarlinHAL::set_pwm_frequency(const pin_t pin, const uint16_t f_desired) {
-  const Timer timer = get_pwm_timer(pin);
-  if (timer.isProtected || !timer.isPWM) return; // Don't proceed if protected timer or not recognized
+void set_pwm_frequency(const pin_t pin, int f_desired) {
+  Timer timer = get_pwm_timer(pin);
+  if (timer.n == 0) return; // Don't proceed if protected timer or not recognised
+  uint16_t size;
+  if (timer.n == 2) size = 255; else size = 65535;

-  const bool is_timer2 = timer.n == 2;
-  const uint16_t maxtop = is_timer2 ? 0xFF : 0xFFFF;
-
-  uint16_t res = 0xFF;        // resolution (TOP value)
-  uint8_t j = CS_NONE;        // prescaler index
-  uint8_t wgm = WGM_PWM_PC_8; // waveform generation mode
+  uint16_t res = 255;   // resolution (TOP value)
+  uint8_t j = 0;        // prescaler index
+  uint8_t wgm = 1;      // waveform generation mode

  // Calculating the prescaler and resolution to use to achieve closest frequency
  if (f_desired != 0) {
-    constexpr uint16_t prescaler[] = { 1, 8, (32), 64, (128), 256, 1024 };  // (*) are Timer 2 only
-    uint16_t f = (F_CPU) / (2 * 1024 * maxtop) + 1;           // Start with the lowest non-zero frequency achievable (1 or 31)
+    int f = (F_CPU) / (2 * 1024 * size) + 1; // Initialize frequency as lowest (non-zero) achievable
+    uint16_t prescaler[] = { 0, 1, 8, /*TIMER2 ONLY*/32, 64, /*TIMER2 ONLY*/128, 256, 1024 };

-    LOOP_L_N(i, COUNT(prescaler)) {                           // Loop through all prescaler values
-      const uint16_t p = prescaler[i];
-      uint16_t res_fast_temp, res_pc_temp;
-      if (is_timer2) {
-        #if ENABLED(USE_OCR2A_AS_TOP)                         // No resolution calculation for TIMER2 unless enabled USE_OCR2A_AS_TOP
-          const uint16_t rft = (F_CPU) / (p * f_desired);
-          res_fast_temp = rft - 1;
-          res_pc_temp = rft / 2;
-        #else
-          res_fast_temp = res_pc_temp = maxtop;
+    // loop over prescaler values
+    LOOP_S_L_N(i, 1, 8) {
+      uint16_t res_temp_fast = 255, res_temp_phase_correct = 255;
+      if (timer.n == 2) {
+        // No resolution calculation for TIMER2 unless enabled USE_OCR2A_AS_TOP
+        #if ENABLED(USE_OCR2A_AS_TOP)
+          const uint16_t rtf = (F_CPU) / (prescaler[i] * f_desired);
+          res_temp_fast = rtf - 1;
+          res_temp_phase_correct = rtf / 2;
        #endif
      }
      else {
-        if (p == 32 || p == 128) continue;                    // Skip TIMER2 specific prescalers when not TIMER2
-        const uint16_t rft = (F_CPU) / (p * f_desired);
-        res_fast_temp = rft - 1;
-        res_pc_temp = rft / 2;
+        // Skip TIMER2 specific prescalers when not TIMER2
+        if (i == 3 || i == 5) continue;
+        const uint16_t rtf = (F_CPU) / (prescaler[i] * f_desired);
+        res_temp_fast = rtf - 1;
+        res_temp_phase_correct = rtf / 2;
      }

-      LIMIT(res_fast_temp, 1U, maxtop);
-      LIMIT(res_pc_temp, 1U, maxtop);
-
+      LIMIT(res_temp_fast, 1U, size);
+      LIMIT(res_temp_phase_correct, 1U, size);
      // Calculate frequencies of test prescaler and resolution values
-      const uint32_t f_diff      = _MAX(f, f_desired) - _MIN(f, f_desired),
-                     f_fast_temp = (F_CPU) / (p * (1 + res_fast_temp)),
-                     f_fast_diff = _MAX(f_fast_temp, f_desired) - _MIN(f_fast_temp, f_desired),
-                     f_pc_temp   = (F_CPU) / (2 * p * res_pc_temp),
-                     f_pc_diff   = _MAX(f_pc_temp, f_desired) - _MIN(f_pc_temp, f_desired);
+      const int f_temp_fast = (F_CPU) / (prescaler[i] * (1 + res_temp_fast)),
+                f_temp_phase_correct = (F_CPU) / (2 * prescaler[i] * res_temp_phase_correct),
+                f_diff = ABS(f - f_desired),
+                f_fast_diff = ABS(f_temp_fast - f_desired),
+                f_phase_diff = ABS(f_temp_phase_correct - f_desired);

-      if (f_fast_diff < f_diff && f_fast_diff <= f_pc_diff) { // FAST values are closest to desired f
-        // Set the Wave Generation Mode to FAST PWM
-        wgm = is_timer2 ? uint8_t(TERN(USE_OCR2A_AS_TOP, WGM2_FAST_PWM_OCR2A, WGM2_FAST_PWM)) : uint8_t(WGM_FAST_PWM_ICRn);
+      // If FAST values are closest to desired f
+      if (f_fast_diff < f_diff && f_fast_diff <= f_phase_diff) {
        // Remember this combination
-        f = f_fast_temp; res = res_fast_temp; j = i + 1;
+        f = f_temp_fast;
+        res = res_temp_fast;
+        j = i;
+        // Set the Wave Generation Mode to FAST PWM
+        if (timer.n == 2) {
+          wgm = (
+            #if ENABLED(USE_OCR2A_AS_TOP)
+              WGM2_FAST_PWM_OCR2A
+            #else
+              WGM2_FAST_PWM
+            #endif
+          );
+        }
+        else wgm = WGM_FAST_PWM_ICRn;
      }
-      else if (f_pc_diff < f_diff) {                          // PHASE CORRECT values are closes to desired f
+      // If PHASE CORRECT values are closes to desired f
+      else if (f_phase_diff < f_diff) {
+        f = f_temp_phase_correct;
+        res = res_temp_phase_correct;
+        j = i;
        // Set the Wave Generation Mode to PWM PHASE CORRECT
-        wgm = is_timer2 ? uint8_t(TERN(USE_OCR2A_AS_TOP, WGM2_PWM_PC_OCR2A, WGM2_PWM_PC)) : uint8_t(WGM_PWM_PC_ICRn);
-        f = f_pc_temp; res = res_pc_temp; j = i + 1;
+        if (timer.n == 2) {
+          wgm = (
+            #if ENABLED(USE_OCR2A_AS_TOP)
+              WGM2_PWM_PC_OCR2A
+            #else
+              WGM2_PWM_PC
+            #endif
+          );
+        }
+        else wgm = WGM_PWM_PC_ICRn;
      }
    }
  }
+  _SET_WGMnQ(timer.TCCRnQ, wgm);
+  _SET_CSn(timer.TCCRnQ, j);

-  _SET_WGMnQ(timer, wgm);
-  _SET_CSn(timer, j);
-
-  if (is_timer2) {
-    TERN_(USE_OCR2A_AS_TOP, _SET_OCRnQ(timer, 0, res)); // Set OCR2A value (TOP) = res
+  if (timer.n == 2) {
+    #if ENABLED(USE_OCR2A_AS_TOP)
+      _SET_OCRnQ(timer.OCRnQ, 0, res);  // Set OCR2A value (TOP) = res
+    #endif
  }
  else
-    _SET_ICRn(timer, res);                              // Set ICRn value (TOP) = res
+    _SET_ICRn(timer.ICRn, res);         // Set ICRn value (TOP) = res
 }

-void MarlinHAL::set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size/*=255*/, const bool invert/*=false*/) {
+void set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size/*=255*/, const bool invert/*=false*/) {
  // If v is 0 or v_size (max), digitalWrite to LOW or HIGH.
-  // Note that digitalWrite also disables PWM output for us (sets COM bit to 0)
+  // Note that digitalWrite also disables pwm output for us (sets COM bit to 0)
  if (v == 0)
    digitalWrite(pin, invert);
  else if (v == v_size)
    digitalWrite(pin, !invert);
  else {
-    const Timer timer = get_pwm_timer(pin);
-    if (timer.isPWM) {
-      if (timer.n == 0) {
-        _SET_COMnQ(timer, timer.q, COM_CLEAR_SET);  // Only allow a TIMER0B select...
-        _SET_OCRnQ(timer, timer.q, v);              // ...and OCR0B duty update. For output pin D4 no frequency changes are permitted.
-      }
-      else if (!timer.isProtected) {
-        const uint16_t top = timer.n == 2 ? TERN(USE_OCR2A_AS_TOP, *timer.OCRnQ[0], 255) : *timer.ICRn;
-        _SET_COMnQ(timer, SUM_TERN(HAS_TCCR2, timer.q, timer.q == 2), COM_CLEAR_SET + invert);   // COM20 is on bit 4 of TCCR2, so +1 for q==2
-        _SET_OCRnQ(timer, timer.q, uint16_t(uint32_t(v) * top / v_size)); // Scale 8/16-bit v to top value
-      }
+    Timer timer = get_pwm_timer(pin);
+    if (timer.n == 0) return; // Don't proceed if protected timer or not recognised
+    // Set compare output mode to CLEAR -> SET or SET -> CLEAR (if inverted)
+    _SET_COMnQ(timer.TCCRnQ, (timer.q
+        #ifdef TCCR2
+          + (timer.q == 2) // COM20 is on bit 4 of TCCR2, thus requires q + 1 in the macro
+        #endif
+      ), COM_CLEAR_SET + invert
+    );
+
+    uint16_t top;
+    if (timer.n == 2) { // if TIMER2
+      top = (
+        #if ENABLED(USE_OCR2A_AS_TOP)
+          *timer.OCRnQ[0] // top = OCR2A
+        #else
+          255 // top = 0xFF (max)
+        #endif
+      );
    }
    else
-      digitalWrite(pin, v < v_size / 2 ? LOW : HIGH);
+      top = *timer.ICRn; // top = ICRn
+
+    _SET_OCRnQ(timer.OCRnQ, timer.q, v * float(top) / float(v_size)); // Scale 8/16-bit v to top value
  }
 }

-void MarlinHAL::init_pwm_timers() {
-  // Init some timer frequencies to a default 1KHz
-  const pin_t pwm_pin[] = {
-    #ifdef __AVR_ATmega2560__
-      10, 5, 6, 46
-    #elif defined(__AVR_ATmega1280__)
-      12, 31
-    #elif defined(__AVR_ATmega644__) || defined(__AVR_ATmega1284__)
-      15, 6
-    #elif defined(__AVR_AT90USB1286__) || defined(__AVR_mega64) || defined(__AVR_mega128)
-      16, 24
-    #endif
-  };
-
-  LOOP_L_N(i, COUNT(pwm_pin))
-    set_pwm_frequency(pwm_pin[i], 1000);
-}
-
+#endif // NEEDS_HARDWARE_PWM
 #endif // __AVR__
@@ -245,7 +245,7 @@ uint16_t set_pwm_frequency_hz(const_float_t hz, const float dca, const float dcb
  float count = 0;
  if (hz > 0 && (dca || dcb || dcc)) {
    count = float(F_CPU) / hz;            // 1x prescaler, TOP for 16MHz base freq.
-    uint16_t prescaler;                   // Range of 30.5Hz (65535) 64.5kHz (>31)
+    uint16_t prescaler;                   // Range of 30.5Hz (65535) 64.5KHz (>31)

         if (count >= 255. * 256.) { prescaler = 1024; SET_CS(5, PRESCALER_1024); }
    else if (count >= 255. * 64.)  { prescaler = 256;  SET_CS(5,  PRESCALER_256); }
@@ -257,7 +257,7 @@ uint16_t set_pwm_frequency_hz(const_float_t hz, const float dca, const float dcb
    const float pwm_top = round(count);   // Get the rounded count

    ICR5 = (uint16_t)pwm_top - 1;         // Subtract 1 for TOP
-    OCR5A = pwm_top * ABS(dca);           // Update and scale DCs
+    OCR5A = pwm_top * ABS(dca);          // Update and scale DCs
    OCR5B = pwm_top * ABS(dcb);
    OCR5C = pwm_top * ABS(dcc);
    _SET_COM(5, A, dca ? (dca < 0 ? COM_SET_CLEAR : COM_CLEAR_SET) : COM_NORMAL); // Set compare modes
@@ -267,17 +267,17 @@ uint16_t set_pwm_frequency_hz(const_float_t hz, const float dca, const float dcb
    SET_WGM(5, FAST_PWM_ICRn);            // Fast PWM with ICR5 as TOP

    //SERIAL_ECHOLNPGM("Timer 5 Settings:");
-    //SERIAL_ECHOLNPGM("  Prescaler=", prescaler);
-    //SERIAL_ECHOLNPGM("        TOP=", ICR5);
-    //SERIAL_ECHOLNPGM("      OCR5A=", OCR5A);
-    //SERIAL_ECHOLNPGM("      OCR5B=", OCR5B);
-    //SERIAL_ECHOLNPGM("      OCR5C=", OCR5C);
+    //SERIAL_ECHOLNPAIR("  Prescaler=", prescaler);
+    //SERIAL_ECHOLNPAIR("        TOP=", ICR5);
+    //SERIAL_ECHOLNPAIR("      OCR5A=", OCR5A);
+    //SERIAL_ECHOLNPAIR("      OCR5B=", OCR5B);
+    //SERIAL_ECHOLNPAIR("      OCR5C=", OCR5C);
  }
  else {
    // Restore the default for Timer 5
    SET_WGM(5, PWM_PC_8);                 // PWM 8-bit (Phase Correct)
    SET_COMS(5, NORMAL, NORMAL, NORMAL);  // Do nothing
-    SET_CS(5, PRESCALER_64);              // 16MHz / 64 = 250kHz
+    SET_CS(5, PRESCALER_64);              // 16MHz / 64 = 250KHz
    OCR5A = OCR5B = OCR5C = 0;
  }
  return round(count);
@@ -118,7 +118,7 @@
 */

 // Waveform Generation Modes
-enum WaveGenMode : uint8_t {
+enum WaveGenMode : char {
  WGM_NORMAL,          //  0
  WGM_PWM_PC_8,        //  1
  WGM_PWM_PC_9,        //  2
@@ -138,19 +138,19 @@ enum WaveGenMode : uint8_t {
 };

 // Wavefore Generation Modes (Timer 2 only)
-enum WaveGenMode2 : uint8_t {
-  WGM2_NORMAL,         // 0
-  WGM2_PWM_PC,         // 1
-  WGM2_CTC_OCR2A,      // 2
-  WGM2_FAST_PWM,       // 3
-  WGM2_reserved_1,     // 4
-  WGM2_PWM_PC_OCR2A,   // 5
-  WGM2_reserved_2,     // 6
-  WGM2_FAST_PWM_OCR2A, // 7
+enum WaveGenMode2 : char {
+  WGM2_NORMAL,          // 0
+  WGM2_PWM_PC,          // 1
+  WGM2_CTC_OCR2A,       // 2
+  WGM2_FAST_PWM,        // 3
+  WGM2_reserved_1,      // 4
+  WGM2_PWM_PC_OCR2A,    // 5
+  WGM2_reserved_2,      // 6
+  WGM2_FAST_PWM_OCR2A,  // 7
 };

 // Compare Modes
-enum CompareMode : uint8_t {
+enum CompareMode : char {
  COM_NORMAL,          //  0
  COM_TOGGLE,          //  1  Non-PWM: OCnx ... Both PWM (WGM 9,11,14,15): OCnA only ... else NORMAL
  COM_CLEAR_SET,       //  2  Non-PWM: OCnx ... Fast PWM: OCnx/Bottom ... PF-FC: OCnx Up/Down
@@ -158,7 +158,7 @@ enum CompareMode : uint8_t {
 };

 // Clock Sources
-enum ClockSource : uint8_t {
+enum ClockSource : char {
  CS_NONE,             //  0
  CS_PRESCALER_1,      //  1
  CS_PRESCALER_8,      //  2
@@ -170,7 +170,7 @@ enum ClockSource : uint8_t {
 };

 // Clock Sources (Timer 2 only)
-enum ClockSource2 : uint8_t {
+enum ClockSource2 : char {
  CS2_NONE,            //  0
  CS2_PRESCALER_1,     //  1
  CS2_PRESCALER_8,     //  2
@@ -203,33 +203,40 @@ enum ClockSource2 : uint8_t {
    TCCR##T##B = (TCCR##T##B & ~(0x3 << WGM##T##2)) | (((int(V) >> 2) & 0x3) << WGM##T##2); \
  }while(0)
 #define SET_WGM(T,V) _SET_WGM(T,WGM_##V)
+// Runtime (see set_pwm_frequency):
+#define _SET_WGMnQ(TCCRnQ, V) do{ \
+    *(TCCRnQ)[0] = (*(TCCRnQ)[0] & ~(0x3 << 0)) | (( int(V)       & 0x3) << 0); \
+    *(TCCRnQ)[1] = (*(TCCRnQ)[1] & ~(0x3 << 3)) | (((int(V) >> 2) & 0x3) << 3); \
+  }while(0)

 // Set Clock Select bits
 // Ex: SET_CS3(PRESCALER_64);
-#ifdef TCCR2
-  #define HAS_TCCR2 1
-#endif
 #define _SET_CS(T,V) (TCCR##T##B = (TCCR##T##B & ~(0x7 << CS##T##0)) | ((int(V) & 0x7) << CS##T##0))
 #define _SET_CS0(V) _SET_CS(0,V)
 #define _SET_CS1(V) _SET_CS(1,V)
+#ifdef TCCR2
+  #define _SET_CS2(V) (TCCR2 = (TCCR2 & ~(0x7 << CS20)) | (int(V) << CS20))
+#else
+  #define _SET_CS2(V) _SET_CS(2,V)
+#endif
 #define _SET_CS3(V) _SET_CS(3,V)
 #define _SET_CS4(V) _SET_CS(4,V)
 #define _SET_CS5(V) _SET_CS(5,V)
 #define SET_CS0(V) _SET_CS0(CS_##V)
 #define SET_CS1(V) _SET_CS1(CS_##V)
-
-#if HAS_TCCR2
-  #define _SET_CS2(V) (TCCR2 = (TCCR2 & ~(0x7 << CS20)) | (int(V) << CS20))
+#ifdef TCCR2
  #define SET_CS2(V) _SET_CS2(CS2_##V)
 #else
-  #define _SET_CS2(V) _SET_CS(2,V)
  #define SET_CS2(V) _SET_CS2(CS_##V)
 #endif
-
 #define SET_CS3(V) _SET_CS3(CS_##V)
 #define SET_CS4(V) _SET_CS4(CS_##V)
 #define SET_CS5(V) _SET_CS5(CS_##V)
 #define SET_CS(T,V) SET_CS##T(V)
+// Runtime (see set_pwm_frequency)
+#define _SET_CSn(TCCRnQ, V) do{ \
+    (*(TCCRnQ)[1] = (*(TCCRnQ[1]) & ~(0x7 << 0)) | ((int(V) & 0x7) << 0)); \
+  }while(0)

 // Set Compare Mode bits
 // Ex: SET_COMS(4,CLEAR_SET,CLEAR_SET,CLEAR_SET);
@@ -239,6 +246,22 @@ enum ClockSource2 : uint8_t {
 #define SET_COMB(T,V) SET_COM(T,B,V)
 #define SET_COMC(T,V) SET_COM(T,C,V)
 #define SET_COMS(T,V1,V2,V3) do{ SET_COMA(T,V1); SET_COMB(T,V2); SET_COMC(T,V3); }while(0)
+// Runtime (see set_pwm_duty)
+#define _SET_COMnQ(TCCRnQ, Q, V) do{ \
+    (*(TCCRnQ)[0] = (*(TCCRnQ)[0] & ~(0x3 << (6-2*(Q)))) | (int(V) << (6-2*(Q)))); \
+  }while(0)
+
+// Set OCRnQ register
+// Runtime (see set_pwm_duty):
+#define _SET_OCRnQ(OCRnQ, Q, V) do{ \
+    (*(OCRnQ)[(Q)] = (0x0000) | (int(V) & 0xFFFF)); \
+  }while(0)
+
+// Set ICRn register (one per timer)
+// Runtime (see set_pwm_frequency)
+#define _SET_ICRn(ICRn, V) do{ \
+    (*(ICRn) = (0x0000) | (int(V) & 0xFFFF)); \
+  }while(0)

 // Set Noise Canceler bit
 // Ex: SET_ICNC(2,1)
@@ -261,7 +284,7 @@ enum ClockSource2 : uint8_t {
 * PWM availability macros
 */

-// Determine which hardware PWMs are already in use
+// Determine which harware PWMs are already in use
 #define _PWM_CHK_FAN_B(P) (P == E0_AUTO_FAN_PIN || P == E1_AUTO_FAN_PIN || P == E2_AUTO_FAN_PIN || P == E3_AUTO_FAN_PIN || P == E4_AUTO_FAN_PIN || P == E5_AUTO_FAN_PIN || P == E6_AUTO_FAN_PIN || P == E7_AUTO_FAN_PIN || P == CHAMBER_AUTO_FAN_PIN || P == COOLER_AUTO_FAN_PIN)
 #if PIN_EXISTS(CONTROLLER_FAN)
  #define PWM_CHK_FAN_B(P) (_PWM_CHK_FAN_B(P) || P == CONTROLLER_FAN_PIN)
@@ -28,30 +28,22 @@
 /**
 * Checks for FAST PWM
 */
-#if ALL(FAST_PWM_FAN, USE_OCR2A_AS_TOP, HAS_TCCR2)
-  #error "USE_OCR2A_AS_TOP does not apply to devices with a single output TIMER2."
-#endif
-
-/**
- * Checks for SOFT PWM
- */
-#if HAS_FAN0 && FAN_PIN == 9 && DISABLED(FAN_SOFT_PWM) && ENABLED(SPEAKER)
-  #error "FAN_PIN 9 Hardware PWM uses Timer 2 which conflicts with Arduino AVR Tone Timer (for SPEAKER)."
-  #error "Disable SPEAKER or enable FAN_SOFT_PWM."
+#if ENABLED(FAST_PWM_FAN) && (ENABLED(USE_OCR2A_AS_TOP) && defined(TCCR2))
+  #error "USE_OCR2A_AS_TOP does not apply to devices with a single output TIMER2"
 #endif

 /**
 * Sanity checks for Spindle / Laser PWM
 */
-#if ENABLED(SPINDLE_LASER_USE_PWM)
+#if ENABLED(SPINDLE_LASER_PWM)
  #include "../ServoTimers.h"   // Needed to check timer availability (_useTimer3)
  #if SPINDLE_LASER_PWM_PIN == 4 || WITHIN(SPINDLE_LASER_PWM_PIN, 11, 13)
    #error "Counter/Timer for SPINDLE_LASER_PWM_PIN is used by a system interrupt."
  #elif NUM_SERVOS > 0 && defined(_useTimer3) && (WITHIN(SPINDLE_LASER_PWM_PIN, 2, 3) || SPINDLE_LASER_PWM_PIN == 5)
    #error "Counter/Timer for SPINDLE_LASER_PWM_PIN is used by the servo system."
  #endif
-#elif SPINDLE_LASER_FREQUENCY
-  #error "SPINDLE_LASER_FREQUENCY requires SPINDLE_LASER_USE_PWM."
+#elif defined(SPINDLE_LASER_FREQUENCY)
+  #error "SPINDLE_LASER_FREQUENCY requires SPINDLE_LASER_PWM."
 #endif

 /**
@@ -71,7 +63,3 @@
 #if ENABLED(POSTMORTEM_DEBUGGING)
  #error "POSTMORTEM_DEBUGGING is not supported on AVR boards."
 #endif
-
-#if USING_PULLDOWNS
-  #error "PULLDOWN pin mode is not available on AVR boards."
-#endif
@@ -35,7 +35,7 @@
 // C B A is longIn1
 // D C B A is longIn2
 //
-FORCE_INLINE static uint16_t MultiU24X32toH16(uint32_t longIn1, uint32_t longIn2) {
+static FORCE_INLINE uint16_t MultiU24X32toH16(uint32_t longIn1, uint32_t longIn2) {
  uint8_t tmp1;
  uint8_t tmp2;
  uint16_t intRes;
@@ -89,7 +89,7 @@ FORCE_INLINE static uint16_t MultiU24X32toH16(uint32_t longIn1, uint32_t longIn2
 // uses:
 // r26 to store 0
 // r27 to store the byte 1 of the 24 bit result
-FORCE_INLINE static uint16_t MultiU16X8toH16(uint8_t charIn1, uint16_t intIn2) {
+static FORCE_INLINE uint16_t MultiU16X8toH16(uint8_t charIn1, uint16_t intIn2) {
  uint8_t tmp;
  uint16_t intRes;
  __asm__ __volatile__ (
@@ -2,9 +2,6 @@
 * Marlin 3D Printer Firmware
 * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
@@ -74,7 +71,7 @@
 #define MULTI_NAME_PAD 26 // space needed to be pretty if not first name assigned to a pin

 void PRINT_ARRAY_NAME(uint8_t x) {
-  char *name_mem_pointer = (PGM_P)pgm_read_ptr(&pin_array[x].name);
+  char *name_mem_pointer = (char*)pgm_read_ptr(&pin_array[x].name);
  LOOP_L_N(y, MAX_NAME_LENGTH) {
    char temp_char = pgm_read_byte(name_mem_pointer + y);
    if (temp_char != 0)
@@ -102,7 +99,7 @@ void PRINT_ARRAY_NAME(uint8_t x) {
      return true;                                              \
    } else return false

-#define ABTEST(N) defined(TCCR##N##A) && defined(COM##N##A1)
+

 /**
 * Print a pin's PWM status.
@@ -113,7 +110,7 @@ static bool pwm_status(uint8_t pin) {

  switch (digitalPinToTimer_DEBUG(pin)) {

-    #if ABTEST(0)
+    #if defined(TCCR0A) && defined(COM0A1)
      #ifdef TIMER0A
        #if !AVR_AT90USB1286_FAMILY  // not available in Teensyduino type IDEs
          PWM_CASE(0, A);
@@ -122,20 +119,20 @@ static bool pwm_status(uint8_t pin) {
      PWM_CASE(0, B);
    #endif

-    #if ABTEST(1)
+    #if defined(TCCR1A) && defined(COM1A1)
      PWM_CASE(1, A);
      PWM_CASE(1, B);
-      #if defined(COM1C1) && defined(TIMER1C)
-        PWM_CASE(1, C);
-      #endif
+     #if defined(COM1C1) && defined(TIMER1C)
+      PWM_CASE(1, C);
+     #endif
    #endif

-    #if ABTEST(2)
+    #if defined(TCCR2A) && defined(COM2A1)
      PWM_CASE(2, A);
      PWM_CASE(2, B);
    #endif

-    #if ABTEST(3)
+    #if defined(TCCR3A) && defined(COM3A1)
      PWM_CASE(3, A);
      PWM_CASE(3, B);
      #ifdef COM3C1
@@ -149,7 +146,7 @@ static bool pwm_status(uint8_t pin) {
      PWM_CASE(4, C);
    #endif

-    #if ABTEST(5)
+    #if defined(TCCR5A) && defined(COM5A1)
      PWM_CASE(5, A);
      PWM_CASE(5, B);
      PWM_CASE(5, C);
@@ -166,16 +163,16 @@ static bool pwm_status(uint8_t pin) {
 const volatile uint8_t* const PWM_other[][3] PROGMEM = {
    { &TCCR0A, &TCCR0B, &TIMSK0 },
    { &TCCR1A, &TCCR1B, &TIMSK1 },
-  #if ABTEST(2)
+  #if defined(TCCR2A) && defined(COM2A1)
    { &TCCR2A, &TCCR2B, &TIMSK2 },
  #endif
-  #if ABTEST(3)
+  #if defined(TCCR3A) && defined(COM3A1)
    { &TCCR3A, &TCCR3B, &TIMSK3 },
  #endif
  #ifdef TCCR4A
    { &TCCR4A, &TCCR4B, &TIMSK4 },
  #endif
-  #if ABTEST(5)
+  #if defined(TCCR5A) && defined(COM5A1)
    { &TCCR5A, &TCCR5B, &TIMSK5 },
  #endif
 };
@@ -195,11 +192,11 @@ const volatile uint8_t* const PWM_OCR[][3] PROGMEM = {
   { (const uint8_t*)&OCR1A, (const uint8_t*)&OCR1B, 0 },
  #endif

-  #if ABTEST(2)
+  #if defined(TCCR2A) && defined(COM2A1)
    { &OCR2A, &OCR2B, 0 },
  #endif

-  #if ABTEST(3)
+  #if defined(TCCR3A) && defined(COM3A1)
    #ifdef COM3C1
      { (const uint8_t*)&OCR3A, (const uint8_t*)&OCR3B, (const uint8_t*)&OCR3C },
    #else
@@ -211,7 +208,7 @@ const volatile uint8_t* const PWM_OCR[][3] PROGMEM = {
    { (const uint8_t*)&OCR4A, (const uint8_t*)&OCR4B, (const uint8_t*)&OCR4C },
  #endif

-  #if ABTEST(5)
+  #if defined(TCCR5A) && defined(COM5A1)
    { (const uint8_t*)&OCR5A, (const uint8_t*)&OCR5B, (const uint8_t*)&OCR5C },
  #endif
 };
@@ -238,9 +235,9 @@ static void print_is_also_tied() { SERIAL_ECHOPGM(" is also tied to this pin");

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

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

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

@@ -262,14 +259,14 @@ void timer_prefix(uint8_t T, char L, uint8_t N) {  // T - timer    L - pwm  N -
    const uint16_t *OCRVAL16 = (uint16_t*)OCR_VAL(T, L - 'A');
    PWM_PRINT(*OCRVAL16);
  }
-  SERIAL_ECHOPGM("    WGM: ", WGM);
+  SERIAL_ECHOPAIR("    WGM: ", WGM);
  com_print(T,L);
-  SERIAL_ECHOPGM("    CS: ", (*TCCRB & (_BV(CS_0) | _BV(CS_1) | _BV(CS_2)) ));
-  SERIAL_ECHOPGM("    TCCR", AS_DIGIT(T), "A: ", *TCCRA);
-  SERIAL_ECHOPGM("    TCCR", AS_DIGIT(T), "B: ", *TCCRB);
+  SERIAL_ECHOPAIR("    CS: ", (*TCCRB & (_BV(CS_0) | _BV(CS_1) | _BV(CS_2)) ));
+  SERIAL_ECHOPAIR("    TCCR", AS_CHAR(T + '0'), "A: ", *TCCRA);
+  SERIAL_ECHOPAIR("    TCCR", AS_CHAR(T + '0'), "B: ", *TCCRB);

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

  const uint8_t OCIE = L - 'A' + 1;
  if (N == 3) { if (WGM == 0 || WGM == 2 || WGM ==  4 || WGM ==  6) err_is_counter(); }
@@ -281,7 +278,7 @@ void timer_prefix(uint8_t T, char L, uint8_t N) {  // T - timer    L - pwm  N -
 static void pwm_details(uint8_t pin) {
  switch (digitalPinToTimer_DEBUG(pin)) {

-    #if ABTEST(0)
+    #if defined(TCCR0A) && defined(COM0A1)
      #ifdef TIMER0A
        #if !AVR_AT90USB1286_FAMILY  // not available in Teensyduino type IDEs
          case TIMER0A: timer_prefix(0, 'A', 3); break;
@@ -290,7 +287,7 @@ static void pwm_details(uint8_t pin) {
      case TIMER0B: timer_prefix(0, 'B', 3); break;
    #endif

-    #if ABTEST(1)
+    #if defined(TCCR1A) && defined(COM1A1)
      case TIMER1A: timer_prefix(1, 'A', 4); break;
      case TIMER1B: timer_prefix(1, 'B', 4); break;
      #if defined(COM1C1) && defined(TIMER1C)
@@ -298,12 +295,12 @@ static void pwm_details(uint8_t pin) {
      #endif
    #endif

-    #if ABTEST(2)
+    #if defined(TCCR2A) && defined(COM2A1)
      case TIMER2A: timer_prefix(2, 'A', 3); break;
      case TIMER2B: timer_prefix(2, 'B', 3); break;
    #endif

-    #if ABTEST(3)
+    #if defined(TCCR3A) && defined(COM3A1)
      case TIMER3A: timer_prefix(3, 'A', 4); break;
      case TIMER3B: timer_prefix(3, 'B', 4); break;
      #ifdef COM3C1
@@ -317,7 +314,7 @@ static void pwm_details(uint8_t pin) {
      case TIMER4C: timer_prefix(4, 'C', 4); break;
    #endif

-    #if ABTEST(5)
+    #if defined(TCCR5A) && defined(COM5A1)
      case TIMER5A: timer_prefix(5, 'A', 4); break;
      case TIMER5B: timer_prefix(5, 'B', 4); break;
      case TIMER5C: timer_prefix(5, 'C', 4); break;
@@ -351,6 +348,7 @@ static void pwm_details(uint8_t pin) {
  #endif
 } // pwm_details

+
 #ifndef digitalRead_mod                   // Use Teensyduino's version of digitalRead - it doesn't disable the PWMs
  int digitalRead_mod(const int8_t pin) { // same as digitalRead except the PWM stop section has been removed
    const uint8_t port = digitalPinToPort_DEBUG(pin);
@@ -395,6 +393,3 @@ static void pwm_details(uint8_t pin) {
 #endif

 #define PRINT_PIN(p) do{ sprintf_P(buffer, PSTR("%3d "), p); SERIAL_ECHO(buffer); }while(0)
-#define PRINT_PIN_ANALOG(p) do{ sprintf_P(buffer, PSTR(" (A%2d)  "), DIGITAL_PIN_TO_ANALOG_PIN(pin)); SERIAL_ECHO(buffer); }while(0)
-
-#undef ABTEST
@@ -2,9 +2,6 @@
 * Marlin 3D Printer Firmware
 * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
@@ -2,9 +2,6 @@
 * Marlin 3D Printer Firmware
 * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
@@ -34,14 +34,14 @@ typedef uint16_t hal_timer_t;

 #define HAL_TIMER_RATE          ((F_CPU) / 8)    // i.e., 2MHz or 2.5MHz

-#ifndef MF_TIMER_STEP
-  #define MF_TIMER_STEP         1
+#ifndef STEP_TIMER_NUM
+  #define STEP_TIMER_NUM        1
 #endif
-#ifndef MF_TIMER_PULSE
-  #define MF_TIMER_PULSE        MF_TIMER_STEP
+#ifndef PULSE_TIMER_NUM
+  #define PULSE_TIMER_NUM       STEP_TIMER_NUM
 #endif
-#ifndef MF_TIMER_TEMP
-  #define MF_TIMER_TEMP         0
+#ifndef TEMP_TIMER_NUM
+  #define TEMP_TIMER_NUM        0
 #endif

 #define TEMP_TIMER_FREQUENCY    ((F_CPU) / 64.0 / 256.0)
@@ -58,13 +58,13 @@ typedef uint16_t hal_timer_t;
 #define DISABLE_STEPPER_DRIVER_INTERRUPT() CBI(TIMSK1, OCIE1A)
 #define STEPPER_ISR_ENABLED()             TEST(TIMSK1, OCIE1A)

-#define ENABLE_TEMPERATURE_INTERRUPT()     SBI(TIMSK0, OCIE0A)
-#define DISABLE_TEMPERATURE_INTERRUPT()    CBI(TIMSK0, OCIE0A)
-#define TEMPERATURE_ISR_ENABLED()         TEST(TIMSK0, OCIE0A)
+#define ENABLE_TEMPERATURE_INTERRUPT()     SBI(TIMSK0, OCIE0B)
+#define DISABLE_TEMPERATURE_INTERRUPT()    CBI(TIMSK0, OCIE0B)
+#define TEMPERATURE_ISR_ENABLED()         TEST(TIMSK0, OCIE0B)

 FORCE_INLINE void HAL_timer_start(const uint8_t timer_num, const uint32_t) {
  switch (timer_num) {
-    case MF_TIMER_STEP:
+    case STEP_TIMER_NUM:
      // waveform generation = 0100 = CTC
      SET_WGM(1, CTC_OCRnA);

@@ -84,10 +84,10 @@ FORCE_INLINE void HAL_timer_start(const uint8_t timer_num, const uint32_t) {
      TCNT1 = 0;
      break;

-    case MF_TIMER_TEMP:
+    case TEMP_TIMER_NUM:
      // Use timer0 for temperature measurement
      // Interleave temperature interrupt with millies interrupt
-      OCR0A = 128;
+      OCR0B = 128;
      break;
  }
 }
@@ -109,12 +109,12 @@ FORCE_INLINE void HAL_timer_start(const uint8_t timer_num, const uint32_t) {
 * (otherwise, characters will be lost due to UART overflow).
 * Then: Stepper, Endstops, Temperature, and -finally- all others.
 */
-#define HAL_timer_isr_prologue(T) NOOP
-#define HAL_timer_isr_epilogue(T) NOOP
-
-#ifndef HAL_STEP_TIMER_ISR
+#define HAL_timer_isr_prologue(TIMER_NUM)
+#define HAL_timer_isr_epilogue(TIMER_NUM)

 /* 18 cycles maximum latency */
+#ifndef HAL_STEP_TIMER_ISR
+
 #define HAL_STEP_TIMER_ISR() \
 extern "C" void TIMER1_COMPA_vect() __attribute__ ((signal, naked, used, externally_visible)); \
 extern "C" void TIMER1_COMPA_vect_bottom() asm ("TIMER1_COMPA_vect_bottom") __attribute__ ((used, externally_visible, noinline)); \
@@ -180,7 +180,7 @@ void TIMER1_COMPA_vect() { \
    :                                   \
    : [timsk0] "i" ((uint16_t)&TIMSK0), \
      [timsk1] "i" ((uint16_t)&TIMSK1), \
-      [msk0] "M" ((uint8_t)(1<<OCIE0A)),\
+      [msk0] "M" ((uint8_t)(1<<OCIE0B)),\
      [msk1] "M" ((uint8_t)(1<<OCIE1A)) \
    : \
  ); \
@@ -193,9 +193,9 @@ void TIMER1_COMPA_vect_bottom()

 /* 14 cycles maximum latency */
 #define HAL_TEMP_TIMER_ISR() \
-extern "C" void TIMER0_COMPA_vect() __attribute__ ((signal, naked, used, externally_visible)); \
-extern "C" void TIMER0_COMPA_vect_bottom()  asm ("TIMER0_COMPA_vect_bottom") __attribute__ ((used, externally_visible, noinline)); \
-void TIMER0_COMPA_vect() { \
+extern "C" void TIMER0_COMPB_vect() __attribute__ ((signal, naked, used, externally_visible)); \
+extern "C" void TIMER0_COMPB_vect_bottom()  asm ("TIMER0_COMPB_vect_bottom") __attribute__ ((used, externally_visible, noinline)); \
+void TIMER0_COMPB_vect() { \
  __asm__ __volatile__ ( \
    A("push r16")                       /* 2 Save R16 */ \
    A("in r16, __SREG__")               /* 1 Get SREG */ \
@@ -223,7 +223,7 @@ void TIMER0_COMPA_vect() { \
    A("push r30")                       \
    A("push r31")                       \
    A("clr r1")                         /* C runtime expects this register to be 0 */ \
-    A("call TIMER0_COMPA_vect_bottom")  /* Call the bottom handler - No inlining allowed, otherwise registers used are not saved */   \
+    A("call TIMER0_COMPB_vect_bottom")  /* Call the bottom handler - No inlining allowed, otherwise registers used are not saved */   \
    A("pop r31")                        \
    A("pop r30")                        \
    A("pop r27")                        \
@@ -251,10 +251,10 @@ void TIMER0_COMPA_vect() { \
    A("reti")                           /* 4 Return from interrupt */ \
    :                                   \
    : [timsk0] "i"((uint16_t)&TIMSK0),  \
-      [msk0] "M" ((uint8_t)(1<<OCIE0A)) \
+      [msk0] "M" ((uint8_t)(1<<OCIE0B)) \
    : \
  ); \
 } \
-void TIMER0_COMPA_vect_bottom()
+void TIMER0_COMPB_vect_bottom()

 #endif // HAL_TEMP_TIMER_ISR
@@ -62,10 +62,10 @@
 #include "../shared/Marduino.h"
 #include "../shared/Delay.h"

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

-static uint8_t u8g_bitData, u8g_bitNotData, u8g_bitClock, u8g_bitNotClock;
-static volatile uint8_t *u8g_outData, *u8g_outClock;
+uint8_t u8g_bitData, u8g_bitNotData, u8g_bitClock, u8g_bitNotClock;
+volatile uint8_t *u8g_outData, *u8g_outClock;

 static void u8g_com_arduino_init_shift_out(uint8_t dataPin, uint8_t clockPin) {
  u8g_outData = portOutputRegister(digitalPinToPort(dataPin));
@@ -34,7 +34,7 @@
 // Public Variables
 // ------------------------

-uint16_t MarlinHAL::adc_result;
+uint16_t HAL_adc_result;

 // ------------------------
 // Public functions
@@ -42,7 +42,8 @@ uint16_t MarlinHAL::adc_result;

 TERN_(POSTMORTEM_DEBUGGING, extern void install_min_serial());

-void MarlinHAL::init() {
+// HAL initialization task
+void HAL_init() {
  // Initialize the USB stack
  #if ENABLED(SDSUPPORT)
    OUT_WRITE(SDSS, HIGH);  // Try to set SDSS inactive before any other SPI users start up
@@ -51,15 +52,21 @@ void MarlinHAL::init() {
  TERN_(POSTMORTEM_DEBUGGING, install_min_serial()); // Install the min serial handler
 }

-void MarlinHAL::init_board() {
-  #ifdef BOARD_INIT
-    BOARD_INIT();
-  #endif
+// HAL idle task
+void HAL_idletask() {
+  // Perform USB stack housekeeping
+  usb_task_idle();
 }

-void MarlinHAL::idletask() { usb_task_idle(); } // Perform USB stack housekeeping
+// Disable interrupts
+void cli() { noInterrupts(); }

-uint8_t MarlinHAL::get_reset_source() {
+// Enable interrupts
+void sei() { interrupts(); }
+
+void HAL_clear_reset_source() { }
+
+uint8_t HAL_get_reset_source() {
  switch ((RSTC->RSTC_SR >> 8) & 0x07) {
    case 0: return RST_POWER_ON;
    case 1: return RST_BACKUP;
@@ -70,7 +77,12 @@ uint8_t MarlinHAL::get_reset_source() {
  }
 }

-void MarlinHAL::reboot() { rstc_start_software_reset(RSTC); }
+void HAL_reboot() { rstc_start_software_reset(RSTC); }
+
+void _delay_ms(const int delay_ms) {
+  // Todo: port for Due?
+  delay(delay_ms);
+}

 extern "C" {
  extern unsigned int _ebss; // end of bss section
@@ -82,6 +94,19 @@ int freeMemory() {
  return (int)&free_memory - (heap_end ?: (int)&_ebss);
 }

+// ------------------------
+// ADC
+// ------------------------
+
+void HAL_adc_start_conversion(const uint8_t ch) {
+  HAL_adc_result = analogRead(ch);
+}
+
+uint16_t HAL_adc_get_result() {
+  // nop
+  return HAL_adc_result;
+}
+
 // Forward the default serial ports
 #if USING_HW_SERIAL0
  DefaultSerial1 MSerial0(false, Serial);
@@ -38,10 +38,6 @@

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

-// ------------------------
-// Serial ports
-// ------------------------
-
 typedef ForwardSerial1Class< decltype(Serial) > DefaultSerial1;
 typedef ForwardSerial1Class< decltype(Serial1) > DefaultSerial2;
 typedef ForwardSerial1Class< decltype(Serial2) > DefaultSerial3;
@@ -101,38 +97,55 @@ extern DefaultSerial4 MSerial3;
 #include "MarlinSerial.h"
 #include "MarlinSerialUSB.h"

-// ------------------------
-// Types
-// ------------------------
+// On AVR this is in math.h?
+#define square(x) ((x)*(x))

 typedef int8_t pin_t;

-#define SHARED_SERVOS HAS_SERVOS  // Use shared/servos.cpp
-
-class Servo;
-typedef Servo hal_servo_t;
+#define SHARED_SERVOS HAS_SERVOS
+#define HAL_SERVO_LIB Servo

 //
 // Interrupts
 //
-#define sei() noInterrupts()
-#define cli() interrupts()
+#define CRITICAL_SECTION_START()  uint32_t primask = __get_PRIMASK(); __disable_irq()
+#define CRITICAL_SECTION_END()    if (!primask) __enable_irq()
+#define ISRS_ENABLED() (!__get_PRIMASK())
+#define ENABLE_ISRS()  __enable_irq()
+#define DISABLE_ISRS() __disable_irq()

-#define CRITICAL_SECTION_START()  const bool _irqon = hal.isr_state(); hal.isr_off()
-#define CRITICAL_SECTION_END()    if (_irqon) hal.isr_on()
+void cli();                     // Disable interrupts
+void sei();                     // Enable interrupts
+
+void HAL_clear_reset_source();  // clear reset reason
+uint8_t HAL_get_reset_source(); // get reset reason
+
+void HAL_reboot();

 //
 // ADC
 //
-#define HAL_ADC_VREF         3.3
-#define HAL_ADC_RESOLUTION  10
+extern uint16_t HAL_adc_result;     // result of last ADC conversion

 #ifndef analogInputToDigitalPin
  #define analogInputToDigitalPin(p) ((p < 12U) ? (p) + 54U : -1)
 #endif

+#define HAL_ANALOG_SELECT(ch)
+
+inline void HAL_adc_init() {}//todo
+
+#define HAL_ADC_VREF         3.3
+#define HAL_ADC_RESOLUTION  10
+#define HAL_START_ADC(ch)   HAL_adc_start_conversion(ch)
+#define HAL_READ_ADC()      HAL_adc_result
+#define HAL_ADC_READY()     true
+
+void HAL_adc_start_conversion(const uint8_t ch);
+uint16_t HAL_adc_get_result();
+
 //
-// Pin Mapping for M42, M43, M226
+// Pin Map
 //
 #define GET_PIN_MAP_PIN(index) index
 #define GET_PIN_MAP_INDEX(pin) pin
@@ -141,19 +154,30 @@ typedef Servo hal_servo_t;
 //
 // Tone
 //
+void toneInit();
 void tone(const pin_t _pin, const unsigned int frequency, const unsigned long duration=0);
 void noTone(const pin_t _pin);

-// ------------------------
-// Class Utilities
-// ------------------------
+// Enable hooks into idle and setup for HAL
+#define HAL_IDLETASK 1
+void HAL_idletask();
+void HAL_init();
+
+//
+// Utility functions
+//
+void _delay_ms(const int delay);

-#pragma GCC diagnostic push
 #if GCC_VERSION <= 50000
+  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wunused-function"
 #endif

-#pragma GCC diagnostic pop
+int freeMemory();
+
+#if GCC_VERSION <= 50000
+  #pragma GCC diagnostic pop
+#endif

 #ifdef __cplusplus
  extern "C" {
@@ -162,69 +186,3 @@ char *dtostrf(double __val, signed char __width, unsigned char __prec, char *__s
 #ifdef __cplusplus
  }
 #endif
-
-// Return free RAM between end of heap (or end bss) and whatever is current
-int freeMemory();
-
-// ------------------------
-// MarlinHAL Class
-// ------------------------
-
-class MarlinHAL {
-public:
-
-  // Earliest possible init, before setup()
-  MarlinHAL() {}
-
-  static void init();       // Called early in setup()
-  static void init_board(); // Called less early in setup()
-  static void reboot();     // Software reset
-
-  // Interrupts
-  static bool isr_state() { return !__get_PRIMASK(); }
-  static void isr_on()  { __enable_irq(); }
-  static void isr_off() { __disable_irq(); }
-
-  static void delay_ms(const int ms) { delay(ms); }
-
-  // Tasks, called from idle()
-  static void idletask();
-
-  // Reset
-  static uint8_t get_reset_source();
-  static void clear_reset_source() {}
-
-  // Free SRAM
-  static int freeMemory() { return ::freeMemory(); }
-
-  //
-  // ADC Methods
-  //
-
-  static uint16_t adc_result;
-
-  // Called by Temperature::init once at startup
-  static void adc_init() {}
-
-  // Called by Temperature::init for each sensor at startup
-  static void adc_enable(const uint8_t ch) {}
-
-  // Begin ADC sampling on the given channel. Called from Temperature::isr!
-  static void adc_start(const uint8_t ch) { adc_result = analogRead(ch); }
-
-  // Is the ADC ready for reading?
-  static bool adc_ready() { return true; }
-
-  // The current value of the ADC register
-  static uint16_t adc_value() { return adc_result; }
-
-  /**
-   * Set the PWM duty cycle for the pin to the given value.
-   * No inverting the duty cycle in this HAL.
-   * No changing the maximum size of the provided value to enable finer PWM duty control in this HAL.
-   */
-  static void set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t=255, const bool=false) {
-    analogWrite(pin, v);
-  }
-
-};
@@ -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;
  }
@@ -437,7 +437,7 @@
    } while (--todo);
  }

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

@@ -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;
@@ -594,14 +594,18 @@
      SPI_Configure(SPI0, ID_SPI0, SPI_MR_MSTR | SPI_MR_MODFDIS | SPI_MR_PS);
      SPI_Enable(SPI0);

-      SET_OUTPUT(DAC0_SYNC_PIN);
+      SET_OUTPUT(DAC0_SYNC);
      #if HAS_MULTI_EXTRUDER
-        OUT_WRITE(DAC1_SYNC_PIN, HIGH);
+        SET_OUTPUT(DAC1_SYNC);
+        WRITE(DAC1_SYNC, HIGH);
      #endif
-      WRITE(DAC0_SYNC_PIN, HIGH);
-      OUT_WRITE(SPI_EEPROM1_CS_PIN, HIGH);
-      OUT_WRITE(SPI_EEPROM2_CS_PIN, HIGH);
-      OUT_WRITE(SPI_FLASH_CS_PIN, HIGH);
+      SET_OUTPUT(SPI_EEPROM1_CS);
+      SET_OUTPUT(SPI_EEPROM2_CS);
+      SET_OUTPUT(SPI_FLASH_CS);
+      WRITE(DAC0_SYNC, HIGH);
+      WRITE(SPI_EEPROM1_CS, HIGH);
+      WRITE(SPI_EEPROM2_CS, HIGH);
+      WRITE(SPI_FLASH_CS, HIGH);
      WRITE(SD_SS_PIN, HIGH);

      OUT_WRITE(SDSS, LOW);
@@ -1,26 +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 <SPI.h>
-
-using MarlinSPI = SPIClass;
@@ -406,7 +406,7 @@ size_t MarlinSerial<Cfg>::write(const uint8_t c) {
    const uint8_t i = (tx_buffer.head + 1) & (Cfg::TX_SIZE - 1);

    // If global interrupts are disabled (as the result of being called from an ISR)...
-    if (!hal.isr_state()) {
+    if (!ISRS_ENABLED()) {

      // Make room by polling if it is possible to transmit, and do so!
      while (i == tx_buffer.tail) {
@@ -454,7 +454,7 @@ void MarlinSerial<Cfg>::flushTX() {
    if (!_written) return;

    // If global interrupts are disabled (as the result of being called from an ISR)...
-    if (!hal.isr_state()) {
+    if (!ISRS_ENABLED()) {

      // Wait until everything was transmitted - We must do polling, as interrupts are disabled
      while (tx_buffer.head != tx_buffer.tail || !(HWUART->UART_SR & UART_SR_TXEMPTY)) {
@@ -118,7 +118,7 @@ public:
  static size_t write(const uint8_t c);
  static void flushTX();

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

  FORCE_INLINE static uint8_t dropped() { return Cfg::DROPPED_RX ? rx_dropped_bytes : 0; }
  FORCE_INLINE static uint8_t buffer_overruns() { return Cfg::RX_OVERRUNS ? rx_buffer_overruns : 0; }
@@ -41,7 +41,7 @@ extern "C" {
  int udi_cdc_getc();
  bool udi_cdc_is_tx_ready();
  int udi_cdc_putc(int value);
-}
+};

 // Pending character
 static int pending_char = -1;
@@ -35,20 +35,20 @@
 static pin_t tone_pin;
 volatile static int32_t toggles;

-void tone(const pin_t _pin, const unsigned int frequency, const unsigned long duration/*=0*/) {
+void tone(const pin_t _pin, const unsigned int frequency, const unsigned long duration) {
  tone_pin = _pin;
  toggles = 2 * frequency * duration / 1000;
-  HAL_timer_start(MF_TIMER_TONE, 2 * frequency);
+  HAL_timer_start(TONE_TIMER_NUM, 2 * frequency);
 }

 void noTone(const pin_t _pin) {
-  HAL_timer_disable_interrupt(MF_TIMER_TONE);
+  HAL_timer_disable_interrupt(TONE_TIMER_NUM);
  extDigitalWrite(_pin, LOW);
 }

 HAL_TONE_TIMER_ISR() {
  static uint8_t pin_state = 0;
-  HAL_timer_isr_prologue(MF_TIMER_TONE);
+  HAL_timer_isr_prologue(TONE_TIMER_NUM);

  if (toggles) {
    toggles--;
@@ -20,6 +20,7 @@
 *
 */

+
 /**
 * Based on u8g_com_msp430_hw_spi.c
 *
@@ -59,7 +60,7 @@

 #if HAS_MARLINUI_U8GLIB

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

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

@@ -57,12 +57,12 @@

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

-#if IS_U8GLIB_ST7920
+#if ENABLED(U8GLIB_ST7920)

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

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

 #include "u8g_com_HAL_DUE_sw_spi_shared.h"

@@ -182,5 +182,5 @@ uint8_t u8g_com_HAL_DUE_ST7920_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_va
  }
 #endif // LIGHTWEIGHT_UI

-#endif // IS_U8GLIB_ST7920
+#endif // U8GLIB_ST7920
 #endif // ARDUINO_ARCH_SAM
@@ -57,14 +57,14 @@

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

-#if HAS_MARLINUI_U8GLIB && !IS_U8GLIB_ST7920
+#if HAS_MARLINUI_U8GLIB && DISABLED(U8GLIB_ST7920)

 #include "u8g_com_HAL_DUE_sw_spi_shared.h"

 #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
@@ -141,5 +141,5 @@ uint8_t u8g_com_HAL_DUE_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void
  return 1;
 }

-#endif // HAS_MARLINUI_U8GLIB && !IS_U8GLIB_ST7920
+#endif // HAS_MARLINUI_U8GLIB && !U8GLIB_ST7920
 #endif // ARDUINO_ARCH_SAM
@@ -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);
@@ -200,9 +200,9 @@ static bool ee_PageWrite(uint16_t page, const void *data) {
    pageContents[i] = (((uint32_t*)data)[i]) | (~(pageContents[i] ^ ((uint32_t*)data)[i]));

  DEBUG_ECHO_START();
-  DEBUG_ECHOLNPGM("EEPROM PageWrite   ", page);
-  DEBUG_ECHOLNPGM(" in FLASH address ", (uint32_t)addrflash);
-  DEBUG_ECHOLNPGM(" base address     ", (uint32_t)getFlashStorage(0));
+  DEBUG_ECHOLNPAIR("EEPROM PageWrite   ", page);
+  DEBUG_ECHOLNPAIR(" in FLASH address ", (uint32_t)addrflash);
+  DEBUG_ECHOLNPAIR(" base address     ", (uint32_t)getFlashStorage(0));
  DEBUG_FLUSH();

  // Get the page relative to the start of the EFC controller, and the EFC controller to use
@@ -246,7 +246,7 @@ static bool ee_PageWrite(uint16_t page, const void *data) {
    __enable_irq();

    DEBUG_ECHO_START();
-    DEBUG_ECHOLNPGM("EEPROM Unlock failure for page ", page);
+    DEBUG_ECHOLNPAIR("EEPROM Unlock failure for page ", page);
    return false;
  }

@@ -271,7 +271,7 @@ static bool ee_PageWrite(uint16_t page, const void *data) {
    __enable_irq();

    DEBUG_ECHO_START();
-    DEBUG_ECHOLNPGM("EEPROM Write failure for page ", page);
+    DEBUG_ECHOLNPAIR("EEPROM Write failure for page ", page);

    return false;
  }
@@ -287,7 +287,7 @@ static bool ee_PageWrite(uint16_t page, const void *data) {

    #ifdef EE_EMU_DEBUG
      DEBUG_ECHO_START();
-      DEBUG_ECHOLNPGM("EEPROM Verify Write failure for page ", page);
+      DEBUG_ECHOLNPAIR("EEPROM Verify Write failure for page ", page);

      ee_Dump( page, (uint32_t *)addrflash);
      ee_Dump(-page, data);
@@ -306,7 +306,7 @@ static bool ee_PageWrite(uint16_t page, const void *data) {
          }
        }
      }
-      DEBUG_ECHOLNPGM("--> Differing bits: ", count);
+      DEBUG_ECHOLNPAIR("--> Differing bits: ", count);
    #endif

    return false;
@@ -326,9 +326,9 @@ static bool ee_PageErase(uint16_t page) {
  uint32_t addrflash = uint32_t(getFlashStorage(page));

  DEBUG_ECHO_START();
-  DEBUG_ECHOLNPGM("EEPROM PageErase  ", page);
-  DEBUG_ECHOLNPGM(" in FLASH address ", (uint32_t)addrflash);
-  DEBUG_ECHOLNPGM(" base address     ", (uint32_t)getFlashStorage(0));
+  DEBUG_ECHOLNPAIR("EEPROM PageErase  ", page);
+  DEBUG_ECHOLNPAIR(" in FLASH address ", (uint32_t)addrflash);
+  DEBUG_ECHOLNPAIR(" base address     ", (uint32_t)getFlashStorage(0));
  DEBUG_FLUSH();

  // Get the page relative to the start of the EFC controller, and the EFC controller to use
@@ -371,7 +371,7 @@ static bool ee_PageErase(uint16_t page) {
    __enable_irq();

    DEBUG_ECHO_START();
-    DEBUG_ECHOLNPGM("EEPROM Unlock failure for page ",page);
+    DEBUG_ECHOLNPAIR("EEPROM Unlock failure for page ",page);

    return false;
  }
@@ -395,7 +395,7 @@ static bool ee_PageErase(uint16_t page) {
    __enable_irq();

    DEBUG_ECHO_START();
-    DEBUG_ECHOLNPGM("EEPROM Erase failure for page ",page);
+    DEBUG_ECHOLNPAIR("EEPROM Erase failure for page ",page);

    return false;
  }
@@ -411,7 +411,7 @@ static bool ee_PageErase(uint16_t page) {
  for (i = 0; i < PageSize >> 2; i++) {
    if (*aligned_src++ != 0xFFFFFFFF) {
      DEBUG_ECHO_START();
-      DEBUG_ECHOLNPGM("EEPROM Verify Erase failure for page ",page);
+      DEBUG_ECHOLNPAIR("EEPROM Verify Erase failure for page ",page);
      ee_Dump(page, (uint32_t *)addrflash);
      return false;
    }
@@ -922,7 +922,7 @@ static void ee_Init() {
  if (curGroup >= GroupCount) curGroup = 0;

  DEBUG_ECHO_START();
-  DEBUG_ECHOLNPGM("EEPROM Current Group: ",curGroup);
+  DEBUG_ECHOLNPAIR("EEPROM Current Group: ",curGroup);
  DEBUG_FLUSH();

  // Now, validate that all the other group pages are empty
@@ -932,7 +932,7 @@ static void ee_Init() {
    for (int page = 0; page < PagesPerGroup; page++) {
      if (!ee_IsPageClean(grp * PagesPerGroup + page)) {
        DEBUG_ECHO_START();
-        DEBUG_ECHOLNPGM("EEPROM Page ", page, " not clean on group ", grp);
+        DEBUG_ECHOLNPAIR("EEPROM Page ", page, " not clean on group ", grp);
        DEBUG_FLUSH();
        ee_PageErase(grp * PagesPerGroup + page);
      }
@@ -949,14 +949,14 @@ static void ee_Init() {
  }

  DEBUG_ECHO_START();
-  DEBUG_ECHOLNPGM("EEPROM Active page: ", curPage);
+  DEBUG_ECHOLNPAIR("EEPROM Active page: ", curPage);
  DEBUG_FLUSH();

  // Make sure the pages following the first clean one are also clean
  for (int page = curPage + 1; page < PagesPerGroup; page++) {
    if (!ee_IsPageClean(curGroup * PagesPerGroup + page)) {
      DEBUG_ECHO_START();
-      DEBUG_ECHOLNPGM("EEPROM Page ", page, " not clean on active group ", curGroup);
+      DEBUG_ECHOLNPAIR("EEPROM Page ", page, " not clean on active group ", curGroup);
      DEBUG_FLUSH();
      ee_Dump(curGroup * PagesPerGroup + page, getFlashStorage(curGroup * PagesPerGroup + page));
      ee_PageErase(curGroup * PagesPerGroup + page);
@@ -70,10 +70,4 @@ void setup_endstop_interrupts() {
  TERN_(HAS_J_MIN, _ATTACH(J_MIN_PIN));
  TERN_(HAS_K_MAX, _ATTACH(K_MAX_PIN));
  TERN_(HAS_K_MIN, _ATTACH(K_MIN_PIN));
-  TERN_(HAS_U_MAX, _ATTACH(U_MAX_PIN));
-  TERN_(HAS_U_MIN, _ATTACH(U_MIN_PIN));
-  TERN_(HAS_V_MAX, _ATTACH(V_MAX_PIN));
-  TERN_(HAS_V_MIN, _ATTACH(V_MIN_PIN));
-  TERN_(HAS_W_MAX, _ATTACH(W_MAX_PIN));
-  TERN_(HAS_W_MIN, _ATTACH(W_MIN_PIN));
 }
@@ -25,7 +25,7 @@
 * is NOT used to directly toggle pins. The ISR writes to the pin assigned to
 * that interrupt.
 *
- * All PWMs use the same repetition rate.  The G2 needs about 10kHz min in order to
+ * All PWMs use the same repetition rate.  The G2 needs about 10KHz min in order to
 * not have obvious ripple on the Vref signals.
 *
 * The data structures are setup to minimize the computation done by the ISR which
@@ -59,7 +59,3 @@
 #if HAS_TMC_SW_SERIAL
  #error "TMC220x Software Serial is not supported on the DUE platform."
 #endif
-
-#if USING_PULLDOWNS
-  #error "PULLDOWN pin mode is not available on DUE boards."
-#endif
@@ -2,9 +2,6 @@
 * Marlin 3D Printer Firmware
 * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
@@ -53,7 +50,7 @@
 *     The net result is that both the g_pinStatus[pin] array and the PIO_OSR register
 *     needs to be looked at when determining if a pin is an input or an output.
 *
- * b) Due has only pins 6, 7, 8 & 9 enabled for PWMs.  FYI - they run at 1kHz
+ * b) Due has only pins 6, 7, 8 & 9 enabled for PWMs.  FYI - they run at 1KHz
 *
 * c) NUM_DIGITAL_PINS does not include the analog pins
 *
@@ -67,7 +64,6 @@
 #define PRINT_PORT(p)
 #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("%02d"), p); SERIAL_ECHO(buffer); }while(0)
-#define PRINT_PIN_ANALOG(p) do{ sprintf_P(buffer, PSTR(" (A%2d)  "), DIGITAL_PIN_TO_ANALOG_PIN(pin)); SERIAL_ECHO(buffer); }while(0)
 #define GET_ARRAY_PIN(p) pin_array[p].pin
 #define GET_ARRAY_IS_DIGITAL(p) pin_array[p].is_digital
 #define VALID_PIN(pin) (pin >= 0 && pin < (int8_t)NUMBER_PINS_TOTAL ? 1 : 0)
@@ -90,7 +86,7 @@ bool GET_PINMODE(int8_t pin) {  // 1: output, 0: input
 void pwm_details(int32_t pin) {
  if (pwm_status(pin)) {
    uint32_t chan = g_APinDescription[pin].ulPWMChannel;
-    SERIAL_ECHOPGM("PWM = ", PWM_INTERFACE->PWM_CH_NUM[chan].PWM_CDTY);
+    SERIAL_ECHOPAIR("PWM = ", PWM_INTERFACE->PWM_CH_NUM[chan].PWM_CDTY);
  }
 }

@@ -42,7 +42,7 @@
 // Private Variables
 // ------------------------

-const tTimerConfig timer_config[NUM_HARDWARE_TIMERS] = {
+const tTimerConfig TimerConfig [NUM_HARDWARE_TIMERS] = {
  { TC0, 0, TC0_IRQn,  3}, // 0 - [servo timer5]
  { TC0, 1, TC1_IRQn,  0}, // 1
  { TC0, 2, TC2_IRQn,  2}, // 2 - stepper
@@ -66,9 +66,9 @@ const tTimerConfig timer_config[NUM_HARDWARE_TIMERS] = {
 */

 void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
-  Tc *tc = timer_config[timer_num].pTimerRegs;
-  IRQn_Type irq = timer_config[timer_num].IRQ_Id;
-  uint32_t channel = timer_config[timer_num].channel;
+  Tc *tc = TimerConfig[timer_num].pTimerRegs;
+  IRQn_Type irq = TimerConfig[timer_num].IRQ_Id;
+  uint32_t channel = TimerConfig[timer_num].channel;

  // Disable interrupt, just in case it was already enabled
  NVIC_DisableIRQ(irq);
@@ -86,7 +86,7 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {

  pmc_set_writeprotect(false);
  pmc_enable_periph_clk((uint32_t)irq);
-  NVIC_SetPriority(irq, timer_config[timer_num].priority);
+  NVIC_SetPriority(irq, TimerConfig [timer_num].priority);

  // wave mode, reset counter on match with RC,
  TC_Configure(tc, channel, TC_CMR_WAVE | TC_CMR_WAVSEL_UP_RC | TC_CMR_TCCLKS_TIMER_CLOCK1);
@@ -105,12 +105,12 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
 }

 void HAL_timer_enable_interrupt(const uint8_t timer_num) {
-  IRQn_Type irq = timer_config[timer_num].IRQ_Id;
+  IRQn_Type irq = TimerConfig[timer_num].IRQ_Id;
  NVIC_EnableIRQ(irq);
 }

 void HAL_timer_disable_interrupt(const uint8_t timer_num) {
-  IRQn_Type irq = timer_config[timer_num].IRQ_Id;
+  IRQn_Type irq = TimerConfig[timer_num].IRQ_Id;
  NVIC_DisableIRQ(irq);

  // We NEED memory barriers to ensure Interrupts are actually disabled!
@@ -125,7 +125,7 @@ static bool NVIC_GetEnabledIRQ(IRQn_Type IRQn) {
 }

 bool HAL_timer_interrupt_enabled(const uint8_t timer_num) {
-  IRQn_Type irq = timer_config[timer_num].IRQ_Id;
+  IRQn_Type irq = TimerConfig[timer_num].IRQ_Id;
  return NVIC_GetEnabledIRQ(irq);
 }

@@ -37,35 +37,35 @@ typedef uint32_t hal_timer_t;

 #define HAL_TIMER_RATE         ((F_CPU) / 2)    // frequency of timers peripherals

-#ifndef MF_TIMER_STEP
-  #define MF_TIMER_STEP         2  // Timer Index for Stepper
+#ifndef STEP_TIMER_NUM
+  #define STEP_TIMER_NUM        2  // Timer Index for Stepper
 #endif
-#ifndef MF_TIMER_PULSE
-  #define MF_TIMER_PULSE        MF_TIMER_STEP
+#ifndef PULSE_TIMER_NUM
+  #define PULSE_TIMER_NUM       STEP_TIMER_NUM
 #endif
-#ifndef MF_TIMER_TEMP
-  #define MF_TIMER_TEMP         4  // Timer Index for Temperature
+#ifndef TEMP_TIMER_NUM
+  #define TEMP_TIMER_NUM        4  // Timer Index for Temperature
 #endif
-#ifndef MF_TIMER_TONE
-  #define MF_TIMER_TONE         6  // index of timer to use for beeper tones
+#ifndef TONE_TIMER_NUM
+  #define TONE_TIMER_NUM        6  // index of timer to use for beeper tones
 #endif

 #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 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 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(MF_TIMER_STEP)
-#define DISABLE_STEPPER_DRIVER_INTERRUPT()  HAL_timer_disable_interrupt(MF_TIMER_STEP)
-#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(MF_TIMER_STEP)
+#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(MF_TIMER_TEMP)
-#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_TEMP)
+#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() void TC2_Handler()
@@ -92,7 +92,7 @@ typedef struct {
 // Public Variables
 // ------------------------

-extern const tTimerConfig timer_config[];
+extern const tTimerConfig TimerConfig[];

 // ------------------------
 // Public functions
@@ -101,17 +101,17 @@ extern const tTimerConfig timer_config[];
 void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency);

 FORCE_INLINE static void HAL_timer_set_compare(const uint8_t timer_num, const hal_timer_t compare) {
-  const tTimerConfig * const pConfig = &timer_config[timer_num];
+  const tTimerConfig * const pConfig = &TimerConfig[timer_num];
  pConfig->pTimerRegs->TC_CHANNEL[pConfig->channel].TC_RC = compare;
 }

 FORCE_INLINE static hal_timer_t HAL_timer_get_compare(const uint8_t timer_num) {
-  const tTimerConfig * const pConfig = &timer_config[timer_num];
+  const tTimerConfig * const pConfig = &TimerConfig[timer_num];
  return pConfig->pTimerRegs->TC_CHANNEL[pConfig->channel].TC_RC;
 }

 FORCE_INLINE static hal_timer_t HAL_timer_get_count(const uint8_t timer_num) {
-  const tTimerConfig * const pConfig = &timer_config[timer_num];
+  const tTimerConfig * const pConfig = &TimerConfig[timer_num];
  return pConfig->pTimerRegs->TC_CHANNEL[pConfig->channel].TC_CV;
 }

@@ -120,9 +120,9 @@ void HAL_timer_disable_interrupt(const uint8_t timer_num);
 bool HAL_timer_interrupt_enabled(const uint8_t timer_num);

 FORCE_INLINE static void HAL_timer_isr_prologue(const uint8_t timer_num) {
-  const tTimerConfig * const pConfig = &timer_config[timer_num];
+  const tTimerConfig * const pConfig = &TimerConfig[timer_num];
  // Reading the status register clears the interrupt flag
  pConfig->pTimerRegs->TC_CHANNEL[pConfig->channel].TC_SR;
 }

-#define HAL_timer_isr_epilogue(T) NOOP
+#define HAL_timer_isr_epilogue(TIMER_NUM)
@@ -4,16 +4,15 @@
 #  Windows: bossac.exe
 #  Other: leave unchanged
 #
-import pioutil
-if pioutil.is_pio_build():
-	import platform
-	current_OS = platform.system()

-	if current_OS == 'Windows':
+import platform
+current_OS = platform.system()

-		Import("env")
+if current_OS == 'Windows':

-		# Use bossac.exe on Windows
-		env.Replace(
-			UPLOADCMD="bossac --info --unlock --write --verify --reset --erase -U false --boot $SOURCE"
-		)
+	Import("env")
+
+	# Use bossac.exe on Windows
+	env.Replace(
+	    UPLOADCMD="bossac --info --unlock --write --verify --reset --erase -U false --boot $SOURCE"
+	)
@@ -71,7 +71,7 @@
 /* ------------------------------------------------------------------------ */

 /**
- * \page arduino_due_x_board_info "Arduino Due/X - Board information"
+ * \page arduino_due_x_board_info "Arduino Due/X - Board informations"
 * This page lists several definition related to the board description.
 *
 */
@@ -10,7 +10,7 @@

 #include "../../../sd/cardreader.h"
 extern "C" {
-  #include "sd_mmc_spi_mem.h"
+#include "sd_mmc_spi_mem.h"
 }

 #define SD_MMC_BLOCK_SIZE 512
@@ -74,7 +74,7 @@
 #define   SD_MMC_REMOVING      2


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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -28,10 +28,6 @@
 #include <esp_adc_cal.h>
 #include <HardwareSerial.h>

-#if ENABLED(USE_ESP32_TASK_WDT)
-  #include <esp_task_wdt.h>
-#endif
-
 #if ENABLED(WIFISUPPORT)
  #include <ESPAsyncWebServer.h>
  #include "wifi.h"
@@ -52,7 +48,7 @@
 // Externs
 // ------------------------

-portMUX_TYPE MarlinHAL::spinlock = portMUX_INITIALIZER_UNLOCKED;
+portMUX_TYPE spinlock = portMUX_INITIALIZER_UNLOCKED;

 // ------------------------
 // Local defines
@@ -64,7 +60,7 @@ portMUX_TYPE MarlinHAL::spinlock = portMUX_INITIALIZER_UNLOCKED;
 // Public Variables
 // ------------------------

-uint16_t MarlinHAL::adc_result;
+uint16_t HAL_adc_result;

 // ------------------------
 // Private Variables
@@ -73,16 +69,9 @@ uint16_t MarlinHAL::adc_result;
 esp_adc_cal_characteristics_t characteristics[ADC_ATTEN_MAX];
 adc_atten_t attenuations[ADC1_CHANNEL_MAX] = {};
 uint32_t thresholds[ADC_ATTEN_MAX];
-
-volatile int numPWMUsed = 0;
-volatile struct { pin_t pin; int value; } pwmState[MAX_PWM_PINS];
-
-pin_t chan_pin[CHANNEL_MAX_NUM + 1] = { 0 }; // PWM capable IOpins - not 0 or >33 on ESP32
-
-struct {
-  uint32_t freq; // ledcReadFreq doesn't work if a duty hasn't been set yet!
-  uint16_t res;
-} pwmInfo[(CHANNEL_MAX_NUM + 1) / 2];
+volatile int numPWMUsed = 0,
+             pwmPins[MAX_PWM_PINS],
+             pwmValues[MAX_PWM_PINS];

 // ------------------------
 // Public functions
@@ -101,26 +90,8 @@ struct {

 #endif

-#if ENABLED(USE_ESP32_EXIO)
+void HAL_init_board() {

-  HardwareSerial YSerial2(2);
-
-  void Write_EXIO(uint8_t IO, uint8_t v) {
-    if (hal.isr_state()) {
-      hal.isr_off();
-      YSerial2.write(0x80 | (((char)v) << 5) | (IO - 100));
-      hal.isr_on();
-    }
-    else
-      YSerial2.write(0x80 | (((char)v) << 5) | (IO - 100));
-  }
-
-#endif
-
-void MarlinHAL::init_board() {
-  #if ENABLED(USE_ESP32_TASK_WDT)
-    esp_task_wdt_init(10, true);
-  #endif
  #if ENABLED(ESP3D_WIFISUPPORT)
    esp3dlib.init();
  #elif ENABLED(WIFISUPPORT)
@@ -156,33 +127,30 @@ void MarlinHAL::init_board() {
  // Initialize the i2s peripheral only if the I2S stepper stream is enabled.
  // The following initialization is performed after Serial1 and Serial2 are defined as
  // their native pins might conflict with the i2s stream even when they are remapped.
-  #if ENABLED(USE_ESP32_EXIO)
-    YSerial2.begin(460800 * 3, SERIAL_8N1, 16, 17);
-  #elif ENABLED(I2S_STEPPER_STREAM)
-    i2s_init();
-  #endif
+  TERN_(I2S_STEPPER_STREAM, i2s_init());
 }

-void MarlinHAL::idletask() {
+void HAL_idletask() {
  #if BOTH(WIFISUPPORT, OTASUPPORT)
    OTA_handle();
  #endif
  TERN_(ESP3D_WIFISUPPORT, esp3dlib.idletask());
 }

-uint8_t MarlinHAL::get_reset_source() { return rtc_get_reset_reason(1); }
+void HAL_clear_reset_source() { }

-void MarlinHAL::reboot() { ESP.restart(); }
+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
-int MarlinHAL::freeMemory() { return ESP.getFreeHeap(); }
+int freeMemory() { return ESP.getFreeHeap(); }

 // ------------------------
 // ADC
 // ------------------------
-
 #define ADC1_CHANNEL(pin) ADC1_GPIO ## pin ## _CHANNEL

 adc1_channel_t get_channel(int pin) {
@@ -204,24 +172,22 @@ void adc1_set_attenuation(adc1_channel_t chan, adc_atten_t atten) {
  }
 }

-void MarlinHAL::adc_init() {
+void HAL_adc_init() {
  // Configure ADC
  adc1_config_width(ADC_WIDTH_12Bit);

  // Configure channels only if used as (re-)configuring a pin for ADC that is used elsewhere might have adverse effects
-  TERN_(HAS_TEMP_ADC_0,        adc1_set_attenuation(get_channel(TEMP_0_PIN), ADC_ATTEN_11db));
-  TERN_(HAS_TEMP_ADC_1,        adc1_set_attenuation(get_channel(TEMP_1_PIN), ADC_ATTEN_11db));
-  TERN_(HAS_TEMP_ADC_2,        adc1_set_attenuation(get_channel(TEMP_2_PIN), ADC_ATTEN_11db));
-  TERN_(HAS_TEMP_ADC_3,        adc1_set_attenuation(get_channel(TEMP_3_PIN), ADC_ATTEN_11db));
-  TERN_(HAS_TEMP_ADC_4,        adc1_set_attenuation(get_channel(TEMP_4_PIN), ADC_ATTEN_11db));
-  TERN_(HAS_TEMP_ADC_5,        adc1_set_attenuation(get_channel(TEMP_5_PIN), ADC_ATTEN_11db));
-  TERN_(HAS_TEMP_ADC_6,        adc2_set_attenuation(get_channel(TEMP_6_PIN), ADC_ATTEN_11db));
-  TERN_(HAS_TEMP_ADC_7,        adc3_set_attenuation(get_channel(TEMP_7_PIN), ADC_ATTEN_11db));
-  TERN_(HAS_HEATED_BED,        adc1_set_attenuation(get_channel(TEMP_BED_PIN), ADC_ATTEN_11db));
-  TERN_(HAS_TEMP_CHAMBER,      adc1_set_attenuation(get_channel(TEMP_CHAMBER_PIN), ADC_ATTEN_11db));
-  TERN_(HAS_TEMP_PROBE,        adc1_set_attenuation(get_channel(TEMP_PROBE_PIN), ADC_ATTEN_11db));
-  TERN_(HAS_TEMP_COOLER,       adc1_set_attenuation(get_channel(TEMP_COOLER_PIN), ADC_ATTEN_11db));
-  TERN_(HAS_TEMP_BOARD,        adc1_set_attenuation(get_channel(TEMP_BOARD_PIN), ADC_ATTEN_11db));
+  TERN_(HAS_TEMP_ADC_0, adc1_set_attenuation(get_channel(TEMP_0_PIN), ADC_ATTEN_11db));
+  TERN_(HAS_TEMP_ADC_1, adc1_set_attenuation(get_channel(TEMP_1_PIN), ADC_ATTEN_11db));
+  TERN_(HAS_TEMP_ADC_2, adc1_set_attenuation(get_channel(TEMP_2_PIN), ADC_ATTEN_11db));
+  TERN_(HAS_TEMP_ADC_3, adc1_set_attenuation(get_channel(TEMP_3_PIN), ADC_ATTEN_11db));
+  TERN_(HAS_TEMP_ADC_4, adc1_set_attenuation(get_channel(TEMP_4_PIN), ADC_ATTEN_11db));
+  TERN_(HAS_TEMP_ADC_5, adc1_set_attenuation(get_channel(TEMP_5_PIN), ADC_ATTEN_11db));
+  TERN_(HAS_TEMP_ADC_6, adc2_set_attenuation(get_channel(TEMP_6_PIN), ADC_ATTEN_11db));
+  TERN_(HAS_TEMP_ADC_7, adc3_set_attenuation(get_channel(TEMP_7_PIN), ADC_ATTEN_11db));
+  TERN_(HAS_HEATED_BED, adc1_set_attenuation(get_channel(TEMP_BED_PIN), ADC_ATTEN_11db));
+  TERN_(HAS_TEMP_CHAMBER, adc1_set_attenuation(get_channel(TEMP_CHAMBER_PIN), ADC_ATTEN_11db));
+  TERN_(HAS_TEMP_COOLER, adc1_set_attenuation(get_channel(TEMP_COOLER_PIN), ADC_ATTEN_11db));
  TERN_(FILAMENT_WIDTH_SENSOR, adc1_set_attenuation(get_channel(FILWIDTH_PIN), ADC_ATTEN_11db));

  // Note that adc2 is shared with the WiFi module, which has higher priority, so the conversion may fail.
@@ -236,16 +202,11 @@ void MarlinHAL::adc_init() {
  }
 }

-#ifndef ADC_REFERENCE_VOLTAGE
-  #define ADC_REFERENCE_VOLTAGE 3.3
-#endif
-
-void MarlinHAL::adc_start(const pin_t pin) {
-  const adc1_channel_t chan = get_channel(pin);
+void HAL_adc_start_conversion(const uint8_t adc_pin) {
+  const adc1_channel_t chan = get_channel(adc_pin);
  uint32_t mv;
  esp_adc_cal_get_voltage((adc_channel_t)chan, &characteristics[attenuations[chan]], &mv);
-
-  adc_result = mv * isr_float_t(1023) / isr_float_t(ADC_REFERENCE_VOLTAGE) / isr_float_t(1000);
+  HAL_adc_result = mv * 1023.0 / 3300.0;

  // Change the attenuation level based on the new reading
  adc_atten_t atten;
@@ -262,81 +223,25 @@ void MarlinHAL::adc_start(const pin_t pin) {
  adc1_set_attenuation(chan, atten);
 }

-// ------------------------
-// PWM
-// ------------------------
-
-int8_t channel_for_pin(const uint8_t pin) {
-  for (int i = 0; i <= CHANNEL_MAX_NUM; i++)
-    if (chan_pin[i] == pin) return i;
-  return -1;
-}
-
-// get PWM channel for pin - if none then attach a new one
-// return -1 if fail or invalid pin#, channel # (0-15) if success
-int8_t get_pwm_channel(const pin_t pin, const uint32_t freq, const uint16_t res) {
-  if (!WITHIN(pin, 1, MAX_PWM_IOPIN)) return -1; // Not a hardware PWM pin!
-  int8_t cid = channel_for_pin(pin);
-  if (cid >= 0) return cid;
-
-  // Find an empty adjacent channel (same timer & freq/res)
-  for (int i = 0; i <= CHANNEL_MAX_NUM; i++) {
-    if (chan_pin[i] == 0) {
-      if (chan_pin[i ^ 0x1] != 0) {
-        if (pwmInfo[i / 2].freq == freq && pwmInfo[i / 2].res == res) {
-          chan_pin[i] = pin; // Allocate PWM to this channel
-          ledcAttachPin(pin, i);
-          return i;
-        }
-      }
-      else if (cid == -1)    // Pair of empty channels?
-        cid = i & 0xFE;      // Save lower channel number
-    }
-  }
-  // not attached, is an empty timer slot avail?
-  if (cid >= 0) {
-    chan_pin[cid] = pin;
-    pwmInfo[cid / 2].freq = freq;
-    pwmInfo[cid / 2].res = res;
-    ledcSetup(cid, freq, res);
-    ledcAttachPin(pin, cid);
-  }
-  return cid; // -1 if no channel avail
-}
-
-void MarlinHAL::set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size/*=_BV(PWM_RESOLUTION)-1*/, const bool invert/*=false*/) {
-  const int8_t cid = get_pwm_channel(pin, PWM_FREQUENCY, PWM_RESOLUTION);
-  if (cid >= 0) {
-    uint32_t duty = map(invert ? v_size - v : v, 0, v_size, 0, _BV(PWM_RESOLUTION)-1);
-    ledcWrite(cid, duty);
-  }
-}
-
-int8_t MarlinHAL::set_pwm_frequency(const pin_t pin, const uint32_t f_desired) {
-  const int8_t cid = channel_for_pin(pin);
-  if (cid >= 0) {
-    if (f_desired == ledcReadFreq(cid)) return cid; // no freq change
-    ledcDetachPin(chan_pin[cid]);
-    chan_pin[cid] = 0;              // remove old freq channel
-  }
-  return get_pwm_channel(pin, f_desired, PWM_RESOLUTION); // try for new one
-}
-
-// use hardware PWM if avail, if not then ISR
-void analogWrite(const pin_t pin, const uint16_t value, const uint32_t freq/*=PWM_FREQUENCY*/, const uint16_t res/*=8*/) { // always 8 bit resolution!
+void analogWrite(pin_t pin, int value) {
  // Use ledc hardware for internal pins
-  const int8_t cid = get_pwm_channel(pin, freq, res);
-  if (cid >= 0) {
-    ledcWrite(cid, value); // set duty value
+  if (pin < 34) {
+    static int cnt_channel = 1, pin_to_channel[40] = { 0 };
+    if (pin_to_channel[pin] == 0) {
+      ledcAttachPin(pin, cnt_channel);
+      ledcSetup(cnt_channel, 490, 8);
+      ledcWrite(cnt_channel, value);
+      pin_to_channel[pin] = cnt_channel++;
+    }
+    ledcWrite(pin_to_channel[pin], value);
    return;
  }

-  // not a hardware PWM pin OR no PWM channels available
  int idx = -1;

  // Search Pin
  for (int i = 0; i < numPWMUsed; ++i)
-    if (pwmState[i].pin == pin) { idx = i; break; }
+    if (pwmPins[i] == pin) { idx = i; break; }

  // not found ?
  if (idx < 0) {
@@ -345,34 +250,34 @@ void analogWrite(const pin_t pin, const uint16_t value, const uint32_t freq/*=PW

    // Take new slot for pin
    idx = numPWMUsed;
-    pwmState[idx].pin = pin;
+    pwmPins[idx] = pin;
    // Start timer on first use
-    if (idx == 0) HAL_timer_start(MF_TIMER_PWM, PWM_TIMER_FREQUENCY);
+    if (idx == 0) HAL_timer_start(PWM_TIMER_NUM, PWM_TIMER_FREQUENCY);

    ++numPWMUsed;
  }

  // Use 7bit internal value - add 1 to have 100% high at 255
-  pwmState[idx].value = (value + 1) / 2;
+  pwmValues[idx] = (value + 1) / 2;
 }

 // Handle PWM timer interrupt
 HAL_PWM_TIMER_ISR() {
-  HAL_timer_isr_prologue(MF_TIMER_PWM);
+  HAL_timer_isr_prologue(PWM_TIMER_NUM);

  static uint8_t count = 0;

  for (int i = 0; i < numPWMUsed; ++i) {
    if (count == 0)                   // Start of interval
-      digitalWrite(pwmState[i].pin, pwmState[i].value ? HIGH : LOW);
-    else if (pwmState[i].value == count)   // End of duration
-      digitalWrite(pwmState[i].pin, LOW);
+      WRITE(pwmPins[i], pwmValues[i] ? HIGH : LOW);
+    else if (pwmValues[i] == count)   // End of duration
+      WRITE(pwmPins[i], LOW);
  }

  // 128 for 7 Bit resolution
  count = (count + 1) & 0x7F;

-  HAL_timer_isr_epilogue(MF_TIMER_PWM);
+  HAL_timer_isr_epilogue(PWM_TIMER_NUM);
 }

 #endif // ARDUINO_ARCH_ESP32
@@ -49,6 +49,8 @@
 // Defines
 // ------------------------

+extern portMUX_TYPE spinlock;
+
 #define MYSERIAL1 flushableSerial

 #if EITHER(WIFISUPPORT, ESP3D_WIFISUPPORT)
@@ -63,22 +65,24 @@

 #define CRITICAL_SECTION_START() portENTER_CRITICAL(&spinlock)
 #define CRITICAL_SECTION_END()   portEXIT_CRITICAL(&spinlock)
-
-#define HAL_CAN_SET_PWM_FREQ   // This HAL supports PWM Frequency adjustment
-#define PWM_FREQUENCY  1000u   // Default PWM frequency when set_pwm_duty() is called without set_pwm_frequency()
-#define PWM_RESOLUTION   10u   // Default PWM bit resolution
-#define CHANNEL_MAX_NUM  15u   // max PWM channel # to allocate (7 to only use low speed, 15 to use low & high)
-#define MAX_PWM_IOPIN    33u   // hardware pwm pins < 34
+#define ISRS_ENABLED() (spinlock.owner == portMUX_FREE_VAL)
+#define ENABLE_ISRS()  if (spinlock.owner != portMUX_FREE_VAL) portEXIT_CRITICAL(&spinlock)
+#define DISABLE_ISRS() portENTER_CRITICAL(&spinlock)

 // ------------------------
 // Types
 // ------------------------

-typedef double isr_float_t;   // FPU ops are used for single-precision, so use double for ISRs.
 typedef int16_t pin_t;

-class Servo;
-typedef Servo hal_servo_t;
+#define HAL_SERVO_LIB Servo
+
+// ------------------------
+// Public Variables
+// ------------------------
+
+/** result of last ADC conversion */
+extern uint16_t HAL_adc_result;

 // ------------------------
 // Public functions
@@ -87,21 +91,56 @@ typedef Servo hal_servo_t;
 //
 // Tone
 //
+void toneInit();
 void tone(const pin_t _pin, const unsigned int frequency, const unsigned long duration=0);
 void noTone(const pin_t _pin);

-void analogWrite(const pin_t pin, const uint16_t value, const uint32_t freq=PWM_FREQUENCY, const uint16_t res=8);
+// clear reset reason
+void HAL_clear_reset_source();
+
+// reset reason
+uint8_t HAL_get_reset_source();
+
+void HAL_reboot();
+
+void _delay_ms(int delay);
+
+#if GCC_VERSION <= 50000
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wunused-function"
+#endif
+
+int freeMemory();
+
+#if GCC_VERSION <= 50000
+  #pragma GCC diagnostic pop
+#endif
+
+void analogWrite(pin_t pin, int value);
+
+// ADC
+#define HAL_ANALOG_SELECT(pin)
+
+void HAL_adc_init();
+
+#define HAL_ADC_VREF         3.3
+#define HAL_ADC_RESOLUTION  10
+#define HAL_START_ADC(pin)  HAL_adc_start_conversion(pin)
+#define HAL_READ_ADC()      HAL_adc_result
+#define HAL_ADC_READY()     true
+
+void HAL_adc_start_conversion(const uint8_t adc_pin);

-//
-// Pin Mapping for M42, M43, M226
-//
 #define GET_PIN_MAP_PIN(index) index
 #define GET_PIN_MAP_INDEX(pin) pin
 #define PARSED_PIN_INDEX(code, dval) parser.intval(code, dval)

-#if ENABLED(USE_ESP32_EXIO)
-  void Write_EXIO(uint8_t IO, uint8_t v);
-#endif
+// Enable hooks into idle and setup for HAL
+#define HAL_IDLETASK 1
+#define BOARD_INIT() HAL_init_board();
+void HAL_idletask();
+inline void HAL_init() {}
+void HAL_init_board();

 //
 // Delay in cycles (used by DELAY_NS / DELAY_US)
@@ -143,90 +182,3 @@ FORCE_INLINE static void DELAY_CYCLES(uint32_t x) {
  }

 }
-
-// ------------------------
-// Class Utilities
-// ------------------------
-
-#pragma GCC diagnostic push
-#if GCC_VERSION <= 50000
-  #pragma GCC diagnostic ignored "-Wunused-function"
-#endif
-
-int freeMemory();
-
-#pragma GCC diagnostic pop
-
-void _delay_ms(const int ms);
-
-// ------------------------
-// MarlinHAL Class
-// ------------------------
-
-#define HAL_ADC_VREF         3.3
-#define HAL_ADC_RESOLUTION  10
-
-class MarlinHAL {
-public:
-
-  // Earliest possible init, before setup()
-  MarlinHAL() {}
-
-  static void init() {}  // Called early in setup()
-  static void init_board();     // Called less early in setup()
-  static void reboot();         // Restart the firmware
-
-  // Interrupts
-  static portMUX_TYPE spinlock;
-  static bool isr_state() { return spinlock.owner == portMUX_FREE_VAL; }
-  static void isr_on()  { if (spinlock.owner != portMUX_FREE_VAL) portEXIT_CRITICAL(&spinlock); }
-  static void isr_off() { portENTER_CRITICAL(&spinlock); }
-
-  static void delay_ms(const int ms) { _delay_ms(ms); }
-
-  // Tasks, called from idle()
-  static void idletask();
-
-  // Reset
-  static uint8_t get_reset_source();
-  static void clear_reset_source() {}
-
-  // Free SRAM
-  static int freeMemory();
-
-  //
-  // ADC Methods
-  //
-
-  static uint16_t adc_result;
-
-  // Called by Temperature::init once at startup
-  static void adc_init();
-
-  // Called by Temperature::init for each sensor at startup
-  static void adc_enable(const pin_t pin) {}
-
-  // Begin ADC sampling on the given pin. Called from Temperature::isr!
-  static void adc_start(const pin_t pin);
-
-  // Is the ADC ready for reading?
-  static bool adc_ready() { return true; }
-
-  // The current value of the ADC register
-  static uint16_t adc_value() { return adc_result; }
-
-  /**
-   * If not already allocated, allocate a hardware PWM channel
-   * to the pin and set the duty cycle..
-   * Optionally invert the duty cycle [default = false]
-   * Optionally change the scale of the provided value to enable finer PWM duty control [default = 255]
-   */
-  static void set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size=255, const bool invert=false);
-
-  /**
-   * Allocate and set the frequency of a hardware PWM pin
-   * Returns -1 if no pin available.
-   */
-  static int8_t set_pwm_frequency(const pin_t pin, const uint32_t f_desired);
-
-};
@@ -53,9 +53,11 @@ static SPISettings spiConfig;
 // ------------------------

 void spiBegin() {
-  #if ENABLED(SDSUPPORT) && PIN_EXISTS(SD_SS)
-    OUT_WRITE(SD_SS_PIN, HIGH);
+  #if !PIN_EXISTS(SD_SS)
+    #error "SD_SS_PIN not defined!"
  #endif
+
+  OUT_WRITE(SD_SS_PIN, HIGH);
 }

 void spiInit(uint8_t spiRate) {
@@ -1,26 +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 <SPI.h>
-
-using MarlinSPI = SPIClass;
@@ -31,18 +31,20 @@
 // so we only allocate servo channels up high to avoid side effects with regards to analogWrite (fans, leds, laser pwm etc.)
 int Servo::channel_next_free = 12;

-Servo::Servo() {}
+Servo::Servo() {
+  channel = channel_next_free++;
+}

 int8_t Servo::attach(const int inPin) {
+  if (channel >= CHANNEL_MAX_NUM) return -1;
  if (inPin > 0) pin = inPin;
-  channel = get_pwm_channel(pin, 50u, 16u);
-  return channel; // -1 if no PWM avail.
+
+  ledcSetup(channel, 50, 16); // channel X, 50 Hz, 16-bit depth
+  ledcAttachPin(pin, channel);
+  return true;
 }

-// leave channel connected to servo - set duty to zero
-void Servo::detach() {
-  if (channel >= 0) ledcWrite(channel, 0);
-}
+void Servo::detach() { ledcDetachPin(pin); }

 int Servo::read() { return degrees; }

@@ -50,7 +52,7 @@ void Servo::write(int inDegrees) {
  degrees = constrain(inDegrees, MIN_ANGLE, MAX_ANGLE);
  int us = map(degrees, MIN_ANGLE, MAX_ANGLE, MIN_PULSE_WIDTH, MAX_PULSE_WIDTH);
  int duty = map(us, 0, TAU_USEC, 0, MAX_COMPARE);
-  if (channel >= 0) ledcWrite(channel, duty); // don't save duty for servos!
+  ledcWrite(channel, duty);
 }

 void Servo::move(const int value) {
@@ -30,7 +30,8 @@ class Servo {
                   MAX_PULSE_WIDTH = 2400,  // Longest pulse sent to a servo
                   TAU_MSEC = 20,
                   TAU_USEC = (TAU_MSEC * 1000),
-                   MAX_COMPARE = _BV(16) - 1; // 65535
+                   MAX_COMPARE = _BV(16) - 1, // 65535
+                   CHANNEL_MAX_NUM = 16;

 public:
  Servo();
@@ -35,19 +35,19 @@
 static pin_t tone_pin;
 volatile static int32_t toggles;

-void tone(const pin_t _pin, const unsigned int frequency, const unsigned long duration/*=0*/) {
+void tone(const pin_t _pin, const unsigned int frequency, const unsigned long duration) {
  tone_pin = _pin;
  toggles = 2 * frequency * duration / 1000;
-  HAL_timer_start(MF_TIMER_TONE, 2 * frequency);
+  HAL_timer_start(TONE_TIMER_NUM, 2 * frequency);
 }

 void noTone(const pin_t _pin) {
-  HAL_timer_disable_interrupt(MF_TIMER_TONE);
+  HAL_timer_disable_interrupt(TONE_TIMER_NUM);
  WRITE(_pin, LOW);
 }

 HAL_TONE_TIMER_ISR() {
-  HAL_timer_isr_prologue(MF_TIMER_TONE);
+  HAL_timer_isr_prologue(TONE_TIMER_NUM);

  if (toggles) {
    toggles--;
@@ -65,10 +65,4 @@ void setup_endstop_interrupts() {
  TERN_(HAS_J_MIN, _ATTACH(J_MIN_PIN));
  TERN_(HAS_K_MAX, _ATTACH(K_MAX_PIN));
  TERN_(HAS_K_MIN, _ATTACH(K_MIN_PIN));
-  TERN_(HAS_U_MAX, _ATTACH(U_MAX_PIN));
-  TERN_(HAS_U_MIN, _ATTACH(U_MIN_PIN));
-  TERN_(HAS_V_MAX, _ATTACH(V_MAX_PIN));
-  TERN_(HAS_V_MIN, _ATTACH(V_MIN_PIN));
-  TERN_(HAS_W_MAX, _ATTACH(W_MAX_PIN));
-  TERN_(HAS_W_MIN, _ATTACH(W_MIN_PIN));
 }
@@ -1,6 +0,0 @@
-# Name,   Type, SubType, Offset,  Size, Flags
-nvs,      data, nvs,     0x9000,   0x5000,
-otadata,  data, ota,     0xe000,   0x2000,
-app0,     app,  ota_0,   0x10000,  0x180000,
-app1,     app,  ota_1,   0x190000, 0x180000,
-spiffs,   data, spiffs,  0x310000, 0xF0000,
@@ -40,19 +40,13 @@
 // Set pin as input with pullup mode
 #define _PULLUP(IO, v)          pinMode(IO, v ? INPUT_PULLUP : INPUT)

-#if ENABLED(USE_ESP32_EXIO)
-  // Read a pin wrapper
-  #define READ(IO)                digitalRead(IO)
-  // Write to a pin wrapper
-  #define WRITE(IO, v)            (IO >= 100 ? Write_EXIO(IO, v) : digitalWrite(IO, v))
-#else
-  // Read a pin wrapper
-  #define READ(IO)                (IS_I2S_EXPANDER_PIN(IO) ? i2s_state(I2S_EXPANDER_PIN_INDEX(IO)) : digitalRead(IO))
-  // Write to a pin wrapper
-  #define WRITE(IO, v)            (IS_I2S_EXPANDER_PIN(IO) ? i2s_write(I2S_EXPANDER_PIN_INDEX(IO), v) : digitalWrite(IO, v))
-#endif
+// Read a pin wrapper
+#define READ(IO)                (IS_I2S_EXPANDER_PIN(IO) ? i2s_state(I2S_EXPANDER_PIN_INDEX(IO)) : digitalRead(IO))

-// Set pin as input wrapper (0x80 | (v << 5) | (IO - 100))
+// Write to a pin wrapper
+#define WRITE(IO, v)            (IS_I2S_EXPANDER_PIN(IO) ? i2s_write(I2S_EXPANDER_PIN_INDEX(IO), v) : digitalWrite(IO, v))
+
+// Set pin as input wrapper
 #define SET_INPUT(IO)           _SET_INPUT(IO)

 // Set pin as input with pullup wrapper
@@ -23,8 +23,6 @@

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

-#if DISABLED(USE_ESP32_EXIO)
-
 #include "i2s.h"

 #include "../shared/Marduino.h"
@@ -64,9 +62,12 @@ uint32_t i2s_port_data = 0;
 #define I2S_EXIT_CRITICAL()   portEXIT_CRITICAL(&i2s_spinlock[i2s_num])

 static inline void gpio_matrix_out_check(uint32_t gpio, uint32_t signal_idx, bool out_inv, bool oen_inv) {
-  PIN_FUNC_SELECT(GPIO_PIN_MUX_REG[gpio], PIN_FUNC_GPIO);
-  gpio_set_direction((gpio_num_t)gpio, (gpio_mode_t)GPIO_MODE_DEF_OUTPUT);
-  gpio_matrix_out(gpio, signal_idx, out_inv, oen_inv);
+  //if pin = -1, do not need to configure
+  if (gpio != -1) {
+    PIN_FUNC_SELECT(GPIO_PIN_MUX_REG[gpio], PIN_FUNC_GPIO);
+    gpio_set_direction((gpio_num_t)gpio, (gpio_mode_t)GPIO_MODE_DEF_OUTPUT);
+    gpio_matrix_out(gpio, signal_idx, out_inv, oen_inv);
+  }
 }

 static esp_err_t i2s_reset_fifo(i2s_port_t i2s_num) {
@@ -253,7 +254,13 @@ int i2s_init() {

  I2S0.fifo_conf.dscr_en = 0;

-  I2S0.conf_chan.tx_chan_mod = TERN(I2S_STEPPER_SPLIT_STREAM, 4, 0);
+  I2S0.conf_chan.tx_chan_mod = (
+    #if ENABLED(I2S_STEPPER_SPLIT_STREAM)
+      4
+    #else
+      0
+    #endif
+  );
  I2S0.fifo_conf.tx_fifo_mod = 0;
  I2S0.conf.tx_mono = 0;

@@ -304,16 +311,9 @@ int i2s_init() {
  xTaskCreatePinnedToCore(stepperTask, "StepperTask", 10000, nullptr, 1, nullptr, CONFIG_ARDUINO_RUNNING_CORE); // run I2S stepper task on same core as rest of Marlin

  // Route the i2s pins to the appropriate GPIO
-  // If a pin is not defined, no need to configure
-  #if defined(I2S_DATA) && I2S_DATA >= 0
-    gpio_matrix_out_check(I2S_DATA, I2S0O_DATA_OUT23_IDX, 0, 0);
-  #endif
-  #if defined(I2S_BCK) && I2S_BCK >= 0
-    gpio_matrix_out_check(I2S_BCK, I2S0O_BCK_OUT_IDX, 0, 0);
-  #endif
-  #if defined(I2S_WS) && I2S_WS >= 0
-    gpio_matrix_out_check(I2S_WS, I2S0O_WS_OUT_IDX, 0, 0);
-  #endif
+  gpio_matrix_out_check(I2S_DATA, I2S0O_DATA_OUT23_IDX, 0, 0);
+  gpio_matrix_out_check(I2S_BCK, I2S0O_BCK_OUT_IDX, 0, 0);
+  gpio_matrix_out_check(I2S_WS, I2S0O_WS_OUT_IDX, 0, 0);

  // Start the I2S peripheral
  return i2s_start(I2S_NUM_0);
@@ -340,5 +340,4 @@ void i2s_push_sample() {
  dma.current[dma.rw_pos++] = i2s_port_data;
 }

-#endif // !USE_ESP32_EXIO
 #endif // ARDUINO_ARCH_ESP32
@@ -25,8 +25,8 @@
  #error "EMERGENCY_PARSER is not yet implemented for ESP32. Disable EMERGENCY_PARSER to continue."
 #endif

-#if (ENABLED(SPINDLE_LASER_USE_PWM) && SPINDLE_LASER_FREQUENCY > 78125) || (ENABLED(FAST_PWM_FAN_FREQUENCY) && FAST_PWM_FAN_FREQUENCY > 78125)
-  #error "SPINDLE_LASER_FREQUENCY and FAST_PWM_FREQUENCY maximum value is 78125Hz for ESP32."
+#if ENABLED(FAST_PWM_FAN) || SPINDLE_LASER_FREQUENCY
+  #error "Features requiring Hardware PWM (FAST_PWM_FAN, SPINDLE_LASER_FREQUENCY) are not yet supported on ESP32."
 #endif

 #if HAS_TMC_SW_SERIAL
@@ -40,11 +40,3 @@
 #if ENABLED(POSTMORTEM_DEBUGGING)
  #error "POSTMORTEM_DEBUGGING is not yet supported on ESP32."
 #endif
-
-#if MB(MKS_TINYBEE) && ENABLED(FAST_PWM_FAN)
-  #error "FAST_PWM_FAN is not available on TinyBee."
-#endif
-
-#if USING_PULLDOWNS
-  #error "PULLDOWN pin mode is not available on ESP32 boards."
-#endif
@@ -2,9 +2,6 @@
 * Marlin 3D Printer Firmware
 * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
@@ -41,7 +41,7 @@

 static timg_dev_t *TG[2] = {&TIMERG0, &TIMERG1};

-const tTimerConfig timer_config[NUM_HARDWARE_TIMERS] = {
+const tTimerConfig TimerConfig [NUM_HARDWARE_TIMERS] = {
  { TIMER_GROUP_0, TIMER_0, STEPPER_TIMER_PRESCALE, stepTC_Handler }, // 0 - Stepper
  { TIMER_GROUP_0, TIMER_1,    TEMP_TIMER_PRESCALE, tempTC_Handler }, // 1 - Temperature
  { TIMER_GROUP_1, TIMER_0,     PWM_TIMER_PRESCALE, pwmTC_Handler  }, // 2 - PWM
@@ -53,7 +53,7 @@ const tTimerConfig timer_config[NUM_HARDWARE_TIMERS] = {
 // ------------------------

 void IRAM_ATTR timer_isr(void *para) {
-  const tTimerConfig& timer = timer_config[(int)para];
+  const tTimerConfig& timer = TimerConfig[(int)para];

  // Retrieve the interrupt status and the counter value
  // from the timer that reported the interrupt
@@ -81,8 +81,8 @@ void IRAM_ATTR timer_isr(void *para) {
 * @param timer_num timer number to initialize
 * @param frequency frequency of the timer
 */
-void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
-  const tTimerConfig timer = timer_config[timer_num];
+void HAL_timer_start(const uint8_t timer_num, uint32_t frequency) {
+  const tTimerConfig timer = TimerConfig[timer_num];

  timer_config_t config;
  config.divider     = timer.divider;
@@ -115,7 +115,7 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
 * @param count     threshold at which the interrupt is triggered
 */
 void HAL_timer_set_compare(const uint8_t timer_num, hal_timer_t count) {
-  const tTimerConfig timer = timer_config[timer_num];
+  const tTimerConfig timer = TimerConfig[timer_num];
  timer_set_alarm_value(timer.group, timer.idx, count);
 }

@@ -125,7 +125,7 @@ void HAL_timer_set_compare(const uint8_t timer_num, hal_timer_t count) {
 * @return           the timer current threshold for the alarm to be triggered
 */
 hal_timer_t HAL_timer_get_compare(const uint8_t timer_num) {
-  const tTimerConfig timer = timer_config[timer_num];
+  const tTimerConfig timer = TimerConfig[timer_num];

  uint64_t alarm_value;
  timer_get_alarm_value(timer.group, timer.idx, &alarm_value);
@@ -139,7 +139,7 @@ hal_timer_t HAL_timer_get_compare(const uint8_t timer_num) {
 * @return           the current counter of the alarm
 */
 hal_timer_t HAL_timer_get_count(const uint8_t timer_num) {
-  const tTimerConfig timer = timer_config[timer_num];
+  const tTimerConfig timer = TimerConfig[timer_num];
  uint64_t counter_value;
  timer_get_counter_value(timer.group, timer.idx, &counter_value);
  return counter_value;
@@ -150,7 +150,7 @@ hal_timer_t HAL_timer_get_count(const uint8_t timer_num) {
 * @param timer_num timer number to enable interrupts on
 */
 void HAL_timer_enable_interrupt(const uint8_t timer_num) {
-  //const tTimerConfig timer = timer_config[timer_num];
+  //const tTimerConfig timer = TimerConfig[timer_num];
  //timer_enable_intr(timer.group, timer.idx);
 }

@@ -159,12 +159,12 @@ void HAL_timer_enable_interrupt(const uint8_t timer_num) {
 * @param timer_num timer number to disable interrupts on
 */
 void HAL_timer_disable_interrupt(const uint8_t timer_num) {
-  //const tTimerConfig timer = timer_config[timer_num];
+  //const tTimerConfig timer = TimerConfig[timer_num];
  //timer_disable_intr(timer.group, timer.idx);
 }

 bool HAL_timer_interrupt_enabled(const uint8_t timer_num) {
-  const tTimerConfig timer = timer_config[timer_num];
+  const tTimerConfig timer = TimerConfig[timer_num];
  return TG[timer.group]->int_ena.val | BIT(timer_num);
 }

@@ -32,20 +32,20 @@
 typedef uint64_t hal_timer_t;
 #define HAL_TIMER_TYPE_MAX 0xFFFFFFFFFFFFFFFFULL

-#ifndef MF_TIMER_STEP
-  #define MF_TIMER_STEP         0  // Timer Index for Stepper
+#ifndef STEP_TIMER_NUM
+  #define STEP_TIMER_NUM        0  // Timer Index for Stepper
 #endif
-#ifndef MF_TIMER_PULSE
-  #define MF_TIMER_PULSE        MF_TIMER_STEP
+#ifndef PULSE_TIMER_NUM
+  #define PULSE_TIMER_NUM       STEP_TIMER_NUM
 #endif
-#ifndef MF_TIMER_TEMP
-  #define MF_TIMER_TEMP         1  // Timer Index for Temperature
+#ifndef TEMP_TIMER_NUM
+  #define TEMP_TIMER_NUM        1  // Timer Index for Temperature
 #endif
-#ifndef MF_TIMER_PWM
-  #define MF_TIMER_PWM          2  // index of timer to use for PWM outputs
+#ifndef PWM_TIMER_NUM
+  #define PWM_TIMER_NUM         2  // index of timer to use for PWM outputs
 #endif
-#ifndef MF_TIMER_TONE
-  #define MF_TIMER_TONE         3  // index of timer for beeper tones
+#ifndef TONE_TIMER_NUM
+  #define TONE_TIMER_NUM        3  // index of timer for beeper tones
 #endif

 #define HAL_TIMER_RATE APB_CLK_FREQ // frequency of timer peripherals
@@ -79,12 +79,12 @@ typedef uint64_t hal_timer_t;
 #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(MF_TIMER_STEP)
-#define DISABLE_STEPPER_DRIVER_INTERRUPT()  HAL_timer_disable_interrupt(MF_TIMER_STEP)
-#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(MF_TIMER_STEP)
+#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(MF_TIMER_TEMP)
-#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_TEMP)
+#define ENABLE_TEMPERATURE_INTERRUPT()  HAL_timer_enable_interrupt(TEMP_TIMER_NUM)
+#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(TEMP_TIMER_NUM)

 #ifndef HAL_TEMP_TIMER_ISR
  #define HAL_TEMP_TIMER_ISR() extern "C" void tempTC_Handler()
@@ -121,13 +121,13 @@ typedef struct {
 // Public Variables
 // ------------------------

-extern const tTimerConfig timer_config[];
+extern const tTimerConfig TimerConfig[];

 // ------------------------
 // Public functions
 // ------------------------

-void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency);
+void HAL_timer_start (const uint8_t timer_num, uint32_t frequency);
 void HAL_timer_set_compare(const uint8_t timer_num, const hal_timer_t count);
 hal_timer_t HAL_timer_get_compare(const uint8_t timer_num);
 hal_timer_t HAL_timer_get_count(const uint8_t timer_num);
@@ -136,5 +136,5 @@ 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(T) NOOP
-#define HAL_timer_isr_epilogue(T) NOOP
+#define HAL_timer_isr_prologue(TIMER_NUM)
+#define HAL_timer_isr_epilogue(TIMER_NUM)
@@ -1,100 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2022 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * Copypaste of SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#ifdef ARDUINO_ARCH_ESP32
-
-#include "../../inc/MarlinConfigPre.h"
-
-#if ENABLED(FYSETC_MINI_12864_2_1)
-
-#include <U8glib-HAL.h>
-#include "Arduino.h"
-#include "../shared/HAL_SPI.h"
-#include "HAL.h"
-#include "SPI.h"
-
-static SPISettings spiConfig;
-
-#define MDOGLCD_MOSI    23
-#define MDOGLCD_SCK     18
-#define MLCD_RESET_PIN   0
-#define MLCD_PINS_DC     4
-#define MDOGLCD_CS      21
-#define MDOGLCD_A0       4
-
-#ifndef LCD_SPI_SPEED
-  #ifdef SD_SPI_SPEED
-    #define LCD_SPI_SPEED SD_SPI_SPEED    // Assume SPI speed shared with SD
-  #else
-    #define LCD_SPI_SPEED SPI_FULL_SPEED  // Use full speed if SD speed is not supplied
-  #endif
-#endif
-
-uint8_t u8g_eps_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) {
-  static uint8_t msgInitCount = 2; // Ignore all messages until 2nd U8G_COM_MSG_INIT
-  if (msgInitCount) {
-    if (msg == U8G_COM_MSG_INIT) msgInitCount--;
-    if (msgInitCount) return -1;
-  }
-
-  switch (msg) {
-    case U8G_COM_MSG_STOP: break;
-
-    case U8G_COM_MSG_INIT:
-      OUT_WRITE(MDOGLCD_CS, HIGH);
-      OUT_WRITE(MDOGLCD_A0, HIGH);
-      OUT_WRITE(MLCD_RESET_PIN, HIGH);
-      u8g_Delay(5);
-      spiBegin();
-      spiInit(LCD_SPI_SPEED);
-      break;
-
-    case U8G_COM_MSG_ADDRESS:           /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
-      WRITE(MDOGLCD_A0, arg_val ? HIGH : LOW);
-      break;
-
-    case U8G_COM_MSG_CHIP_SELECT:       /* arg_val == 0 means HIGH level of U8G_PI_CS */
-      WRITE(MDOGLCD_CS, arg_val ? LOW : HIGH);
-      break;
-
-    case U8G_COM_MSG_RESET:
-      WRITE(MLCD_RESET_PIN, arg_val);
-      break;
-
-    case U8G_COM_MSG_WRITE_BYTE:
-      spiSend((uint8_t)arg_val);
-      break;
-
-    case U8G_COM_MSG_WRITE_SEQ:
-      uint8_t *ptr = (uint8_t*) arg_ptr;
-      while (arg_val > 0) {
-        spiSend(*ptr++);
-        arg_val--;
-      }
-      break;
-  }
-  return 1;
-}
-
-#endif // FYSETC_MINI_12864_2_1
-#endif // ARDUINO_ARCH_ESP32
@@ -25,7 +25,7 @@
  extern "C" {
 #endif

-  esp_err_t esp_task_wdt_reset();
+    esp_err_t esp_task_wdt_reset();

 #ifdef __cplusplus
  }
@@ -59,7 +59,7 @@ void wifi_init() {

  MDNS.addService("http", "tcp", 80);

-  SERIAL_ECHOLNPGM("Successfully connected to WiFi with SSID '" WIFI_SSID "', hostname: '" WIFI_HOSTNAME "', IP address: ", WiFi.localIP().toString().c_str());
+  SERIAL_ECHOLNPAIR("Successfully connected to WiFi with SSID '" WIFI_SSID "', hostname: '" WIFI_HOSTNAME "', IP address: ", WiFi.localIP().toString().c_str());
 }

 #endif // WIFISUPPORT
@@ -24,10 +24,6 @@
 #include "../../inc/MarlinConfig.h"
 #include "../shared/Delay.h"

-// ------------------------
-// Serial ports
-// ------------------------
-
 MSerialT usb_serial(TERN0(EMERGENCY_PARSER, true));

 // U8glib required functions
@@ -41,21 +37,42 @@ extern "C" {
 //************************//

 // return free heap space
-int freeMemory() { return 0; }
+int freeMemory() {
+  return 0;
+}

 // ------------------------
 // ADC
 // ------------------------

-uint8_t MarlinHAL::active_ch = 0;
+void HAL_adc_init() {

-uint16_t MarlinHAL::adc_value() {
-  const pin_t pin = analogInputToDigitalPin(active_ch);
+}
+
+void HAL_adc_enable_channel(const uint8_t ch) {
+
+}
+
+uint8_t active_ch = 0;
+void HAL_adc_start_conversion(const uint8_t ch) {
+  active_ch = ch;
+}
+
+bool HAL_adc_finished() {
+  return true;
+}
+
+uint16_t HAL_adc_get_result() {
+  pin_t pin = analogInputToDigitalPin(active_ch);
  if (!VALID_PIN(pin)) return 0;
-  const uint16_t data = ((Gpio::get(pin) >> 2) & 0x3FF);
+  uint16_t data = ((Gpio::get(pin) >> 2) & 0x3FF);
  return data;    // return 10bit value as Marlin expects
 }

-void MarlinHAL::reboot() { /* Reset the application state and GPIO */ }
+void HAL_pwm_init() {
+
+}
+
+void HAL_reboot() { /* Reset the application state and GPIO */ }

 #endif // __PLAT_LINUX__
@@ -21,42 +21,25 @@
 */
 #pragma once

-#include <iostream>
-#include <stdint.h>
-#include <stdarg.h>
-#undef min
-#undef max
-#include <algorithm>
-
-#include "hardware/Clock.h"
-
-#include "../shared/Marduino.h"
-#include "../shared/math_32bit.h"
-#include "../shared/HAL_SPI.h"
-#include "fastio.h"
-#include "watchdog.h"
-#include "serial.h"
-
-// ------------------------
-// Defines
-// ------------------------
-
 #define CPU_32_BIT
-#define SHARED_SERVOS HAS_SERVOS  // Use shared/servos.cpp

 #define F_CPU 100000000UL
 #define SystemCoreClock F_CPU
+#include <iostream>
+#include <stdint.h>
+#include <stdarg.h>

-#define DELAY_CYCLES(x) Clock::delayCycles(x)
+#undef min
+#undef max

-#define CPU_ST7920_DELAY_1 600
-#define CPU_ST7920_DELAY_2 750
-#define CPU_ST7920_DELAY_3 750
+#include <algorithm>

-void _printf(const  char *format, ...);
+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
@@ -66,96 +49,67 @@ uint8_t _getc();
 #define B01 1
 #define B10 2

-// ------------------------
-// Serial ports
-// ------------------------
+#include "hardware/Clock.h"
+
+#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 usb_serial;
 #define MYSERIAL1 usb_serial

+#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()

-// ADC
-#define HAL_ADC_VREF           5.0
-#define HAL_ADC_RESOLUTION    10
+inline void HAL_init() {}

-// ------------------------
-// Class Utilities
-// ------------------------
-
-#pragma GCC diagnostic push
+// Utility functions
 #if GCC_VERSION <= 50000
+  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wunused-function"
 #endif

 int freeMemory();

-#pragma GCC diagnostic pop
+#if GCC_VERSION <= 50000
+  #pragma GCC diagnostic pop
+#endif

-// ------------------------
-// MarlinHAL Class
-// ------------------------
+// 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

-class MarlinHAL {
-public:
+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();

-  // Earliest possible init, before setup()
-  MarlinHAL() {}
+// Reset source
+inline void HAL_clear_reset_source(void) {}
+inline uint8_t HAL_get_reset_source(void) { return RST_POWER_ON; }

-  static void init() {}        // Called early in setup()
-  static void init_board() {}  // Called less early in setup()
-  static void reboot();               // Reset the application state and GPIO
+void HAL_reboot(); // Reset the application state and GPIO

-  // Interrupts
-  static bool isr_state() { return true; }
-  static void isr_on()  {}
-  static void isr_off() {}
-
-  static void delay_ms(const int ms) { _delay_ms(ms); }
-
-  // Tasks, called from idle()
-  static void idletask() {}
-
-  // Reset
-  static constexpr uint8_t reset_reason = RST_POWER_ON;
-  static uint8_t get_reset_source() { return reset_reason; }
-  static void clear_reset_source() {}
-
-  // Free SRAM
-  static int freeMemory() { return ::freeMemory(); }
-
-  //
-  // ADC Methods
-  //
-
-  static uint8_t active_ch;
-
-  // Called by Temperature::init once at startup
-  static void adc_init() {}
-
-  // Called by Temperature::init for each sensor at startup
-  static void adc_enable(const uint8_t) {}
-
-  // Begin ADC sampling on the given channel
-  static void adc_start(const uint8_t ch) { active_ch = ch; }
-
-  // Is the ADC ready for reading?
-  static bool adc_ready() { return true; }
-
-  // The current value of the ADC register
-  static uint16_t adc_value();
-
-  /**
-   * Set the PWM duty cycle for the pin to the given value.
-   * No option to change the resolution or invert the duty cycle.
-   */
-  static void set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t=255, const bool=false) {
-    analogWrite(pin, v);
-  }
-
-  static void set_pwm_frequency(const pin_t, int) {}
-};
+/* ---------------- Delay in cycles */
+FORCE_INLINE static void DELAY_CYCLES(uint64_t x) {
+  Clock::delayCycles(x);
+}
@@ -1,26 +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 <SPI.h>
-
-using MarlinSPI = SPIClass;
@@ -31,7 +31,9 @@ void cli() { } // Disable
 void sei() { } // Enable

 // Time functions
-void _delay_ms(const int ms) { delay(ms); }
+void _delay_ms(const int delay_ms) {
+  delay(delay_ms);
+}

 uint32_t millis() {
  return (uint32_t)Clock::millis();
@@ -40,7 +40,7 @@ struct GpioEvent {
  pin_type pin_id;
  GpioEvent::Type event;

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

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

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

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

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

 // Emulating RAMPS
-#if ENABLED(SPINDLE_LASER_USE_PWM) && !(SPINDLE_LASER_PWM_PIN == 4 || SPINDLE_LASER_PWM_PIN == 6 || SPINDLE_LASER_PWM_PIN == 11)
+#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

@@ -59,9 +59,10 @@ typedef uint8_t byte;
 #endif

 #define sq(v) ((v) * (v))
+#define square(v) sq(v)
 #define constrain(value, arg_min, arg_max) ((value) < (arg_min) ? (arg_min) :((value) > (arg_max) ? (arg_max) : (value)))

-// Interrupts
+//Interrupts
 void cli(); // Disable
 void sei(); // Enable
 void attachInterrupt(uint32_t pin, void (*callback)(), uint32_t mode);
@@ -73,8 +74,8 @@ extern "C" {
 }

 // Time functions
-extern "C" void delay(const int ms);
-void _delay_ms(const int ms);
+extern "C" void delay(const int milis);
+void _delay_ms(const int delay);
 void delayMicroseconds(unsigned long);
 uint32_t millis();

@@ -25,6 +25,43 @@

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

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

 #define HAL_SENSITIVE_PINS

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

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

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

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

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

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

 // Parse a G-code word into a pin index
 int16_t PARSED_PIN_INDEX(const char code, const int16_t dval);
@@ -2,9 +2,6 @@
 * Marlin 3D Printer Firmware
 * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
@@ -19,7 +16,6 @@
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 */
-
 #ifdef __PLAT_LINUX__

 //#define GPIO_LOGGING // Full GPIO and Positional Logging
@@ -2,9 +2,6 @@
 * Marlin 3D Printer Firmware
 * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
@@ -37,7 +34,6 @@
 #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 PRINT_PIN_ANALOG(p) do{ sprintf_P(buffer, PSTR(" (A%2d)  "), DIGITAL_PIN_TO_ANALOG_PIN(pin)); 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
@@ -37,14 +37,14 @@ typedef uint32_t hal_timer_t;

 #define HAL_TIMER_RATE         ((SystemCoreClock) / 4)  // frequency of timers peripherals

-#ifndef MF_TIMER_STEP
-  #define MF_TIMER_STEP         0  // Timer Index for Stepper
+#ifndef STEP_TIMER_NUM
+  #define STEP_TIMER_NUM        0  // Timer Index for Stepper
 #endif
-#ifndef MF_TIMER_PULSE
-  #define MF_TIMER_PULSE        MF_TIMER_STEP
+#ifndef PULSE_TIMER_NUM
+  #define PULSE_TIMER_NUM       STEP_TIMER_NUM
 #endif
-#ifndef MF_TIMER_TEMP
-  #define MF_TIMER_TEMP         1  // Timer Index for Temperature
+#ifndef TEMP_TIMER_NUM
+  #define TEMP_TIMER_NUM        1  // Timer Index for Temperature
 #endif

 #define TEMP_TIMER_RATE        1000000
@@ -58,12 +58,12 @@ typedef uint32_t hal_timer_t;
 #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(MF_TIMER_STEP)
-#define DISABLE_STEPPER_DRIVER_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_STEP)
-#define STEPPER_ISR_ENABLED() HAL_timer_interrupt_enabled(MF_TIMER_STEP)
+#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(MF_TIMER_TEMP)
-#define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(MF_TIMER_TEMP)
+#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()
@@ -77,6 +77,7 @@ typedef uint32_t hal_timer_t;
 #define HAL_PWM_TIMER_ISR()   extern "C" void TIMER3_IRQHandler()
 #define HAL_PWM_TIMER_IRQn

+
 void HAL_timer_init();
 void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency);

@@ -92,5 +93,5 @@ 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(T) NOOP
-#define HAL_timer_isr_epilogue(T) NOOP
+#define HAL_timer_isr_prologue(TIMER_NUM)
+#define HAL_timer_isr_epilogue(TIMER_NUM)
@@ -31,7 +31,7 @@

 DefaultSerial1 USBSerial(false, UsbSerial);

-uint32_t MarlinHAL::adc_result = 0;
+uint32_t HAL_adc_reading = 0;

 // U8glib required functions
 extern "C" {
@@ -41,6 +41,8 @@ extern "C" {
  void u8g_Delay(uint16_t val)       { delay(val); }
 }

+//************************//
+
 // return free heap space
 int freeMemory() {
  char stack_end;
@@ -52,27 +54,7 @@ int freeMemory() {
  return result;
 }

-void MarlinHAL::reboot() { NVIC_SystemReset(); }
-
-uint8_t MarlinHAL::get_reset_source() {
-  #if ENABLED(USE_WATCHDOG)
-    if (watchdog_timed_out()) return RST_WATCHDOG;
-  #endif
-  return RST_POWER_ON;
-}
-
-void MarlinHAL::clear_reset_source() {
-  TERN_(USE_WATCHDOG, watchdog_clear_timeout_flag());
-}
-
-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();
-}
-
-// For M42/M43, scan command line for pin code
+// scan command line for code
 //   return index into pin map array if found and the pin is valid.
 //   return dval if not found or not a valid pin.
 int16_t PARSED_PIN_INDEX(const char code, const int16_t dval) {
@@ -81,4 +63,24 @@ int16_t PARSED_PIN_INDEX(const char code, const int16_t dval) {
  return ind > -1 ? ind : dval;
 }

+void flashFirmware(const int16_t) {
+  delay(500);          // Give OS time to disconnect
+  USB_Connect(false);  // USB clear connection
+  delay(1000);         // Give OS time to notice
+  HAL_reboot();
+}
+
+void HAL_clear_reset_source(void) {
+  TERN_(USE_WATCHDOG, watchdog_clear_timeout_flag());
+}
+
+uint8_t HAL_get_reset_source(void) {
+  #if ENABLED(USE_WATCHDOG)
+    if (watchdog_timed_out()) return RST_WATCHDOG;
+  #endif
+  return RST_POWER_ON;
+}
+
+void HAL_reboot() { NVIC_SystemReset(); }
+
 #endif // TARGET_LPC1768
@@ -28,6 +28,8 @@

 #define CPU_32_BIT

+void HAL_init();
+
 #include <stdint.h>
 #include <stdarg.h>
 #include <algorithm>
@@ -45,9 +47,18 @@ extern "C" volatile uint32_t _millis;
 #include <pinmapping.h>
 #include <CDCSerial.h>

-// ------------------------
-// Serial ports
-// ------------------------
+//
+// Default graphical display delays
+//
+#ifndef ST7920_DELAY_1
+  #define ST7920_DELAY_1 DELAY_NS(600)
+#endif
+#ifndef ST7920_DELAY_2
+  #define ST7920_DELAY_2 DELAY_NS(750)
+#endif
+#ifndef ST7920_DELAY_3
+  #define ST7920_DELAY_3 DELAY_NS(750)
+#endif

 typedef ForwardSerial1Class< decltype(UsbSerial) > DefaultSerial1;
 extern DefaultSerial1 USBSerial;
@@ -102,19 +113,35 @@ extern DefaultSerial1 USBSerial;
    #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() LCD_SERIAL.available()
+    #define SERIAL_GET_TX_BUFFER_FREE() MSerial0.available()
  #endif
 #endif

 //
 // Interrupts
 //
-
-#define CRITICAL_SECTION_START()  const bool irqon = !__get_PRIMASK(); __disable_irq()
-#define CRITICAL_SECTION_END()    if (irqon) __enable_irq()
+#define CRITICAL_SECTION_START()  uint32_t primask = __get_PRIMASK(); __disable_irq()
+#define CRITICAL_SECTION_END()    if (!primask) __enable_irq()
+#define ISRS_ENABLED() (!__get_PRIMASK())
+#define ENABLE_ISRS()  __enable_irq()
+#define DISABLE_ISRS() __disable_irq()

 //
-// ADC
+// Utility functions
+//
+#if GCC_VERSION <= 50000
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wunused-function"
+#endif
+
+int freeMemory();
+
+#if GCC_VERSION <= 50000
+  #pragma GCC diagnostic pop
+#endif
+
+//
+// ADC API
 //

 #define ADC_MEDIAN_FILTER_SIZE (23) // Higher values increase step delay (phase shift),
@@ -133,9 +160,20 @@ extern DefaultSerial1 USBSerial;
 #define HAL_ADC_RESOLUTION     12   // 15 bit maximum, raw temperature is stored as int16_t
 #define HAL_ADC_FILTERED            // Disable oversampling done in Marlin as ADC values already filtered in HAL

-//
-// Pin Mapping for M42, M43, M226
-//
+using FilteredADC = LPC176x::ADC<ADC_LOWPASS_K_VALUE, ADC_MEDIAN_FILTER_SIZE>;
+extern uint32_t HAL_adc_reading;
+[[gnu::always_inline]] inline void HAL_start_adc(const pin_t pin) {
+  HAL_adc_reading = FilteredADC::read(pin) >> (16 - HAL_ADC_RESOLUTION); // returns 16bit value, reduce to required bits
+}
+[[gnu::always_inline]] inline uint16_t HAL_read_adc() {
+  return HAL_adc_reading;
+}
+
+#define HAL_adc_init()
+#define HAL_ANALOG_SELECT(pin) FilteredADC::enable_channel(pin)
+#define HAL_START_ADC(pin)     HAL_start_adc(pin)
+#define HAL_READ_ADC()         HAL_read_adc()
+#define HAL_ADC_READY()        (true)

 // Test whether the pin is valid
 constexpr bool VALID_PIN(const pin_t pin) {
@@ -160,103 +198,34 @@ 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

-// ------------------------
-// Defines
-// ------------------------
+#define HAL_IDLETASK 1
+void HAL_idletask();

 #define PLATFORM_M997_SUPPORT
 void flashFirmware(const int16_t);

 #define HAL_CAN_SET_PWM_FREQ   // This HAL supports PWM Frequency adjustment

-// Default graphical display delays
-#define CPU_ST7920_DELAY_1 600
-#define CPU_ST7920_DELAY_2 750
-#define CPU_ST7920_DELAY_3 750
+/**
+ * set_pwm_frequency
+ *  Set the frequency of the timer corresponding to the provided pin
+ *  All Hardware PWM pins run at the same frequency and all
+ *  Software PWM pins run at the same frequency
+ */
+void set_pwm_frequency(const pin_t pin, int f_desired);

-// ------------------------
-// Class Utilities
-// ------------------------
+/**
+ * set_pwm_duty
+ *  Set the PWM duty cycle of the provided pin to the provided value
+ *  Optionally allows inverting the duty cycle [default = false]
+ *  Optionally allows changing the maximum size of the provided value to enable finer PWM duty control [default = 255]
+ */
+void set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size=255, const bool invert=false);

-#pragma GCC diagnostic push
-#if GCC_VERSION <= 50000
-  #pragma GCC diagnostic ignored "-Wunused-function"
-#endif
+// Reset source
+void HAL_clear_reset_source(void);
+uint8_t HAL_get_reset_source(void);

-int freeMemory();
-
-#pragma GCC diagnostic pop
-
-// ------------------------
-// MarlinHAL Class
-// ------------------------
-
-class MarlinHAL {
-public:
-
-  // Earliest possible init, before setup()
-  MarlinHAL() {}
-
-  static void init();                 // Called early in setup()
-  static void init_board() {}  // Called less early in setup()
-  static void reboot();               // Restart the firmware from 0x0
-
-  // Interrupts
-  static bool isr_state() { return !__get_PRIMASK(); }
-  static void isr_on()  { __enable_irq(); }
-  static void isr_off() { __disable_irq(); }
-
-  static void delay_ms(const int ms) { _delay_ms(ms); }
-
-  // Tasks, called from idle()
-  static void idletask();
-
-  // Reset
-  static uint8_t get_reset_source();
-  static void clear_reset_source();
-
-  // Free SRAM
-  static int freeMemory() { return ::freeMemory(); }
-
-  //
-  // ADC Methods
-  //
-
-  using FilteredADC = LPC176x::ADC<ADC_LOWPASS_K_VALUE, ADC_MEDIAN_FILTER_SIZE>;
-
-  // Called by Temperature::init once at startup
-  static void adc_init() {}
-
-  // Called by Temperature::init for each sensor at startup
-  static void adc_enable(const pin_t pin) {
-    FilteredADC::enable_channel(pin);
-  }
-
-  // Begin ADC sampling on the given pin. Called from Temperature::isr!
-  static uint32_t adc_result;
-  static void adc_start(const pin_t pin) {
-    adc_result = FilteredADC::read(pin) >> (16 - HAL_ADC_RESOLUTION); // returns 16bit value, reduce to required bits
-  }
-
-  // Is the ADC ready for reading?
-  static bool adc_ready() { return true; }
-
-  // The current value of the ADC register
-  static uint16_t adc_value() { return uint16_t(adc_result); }
-
-  /**
-   * Set the PWM duty cycle for the pin to the given value.
-   * Optionally invert the duty cycle [default = false]
-   * Optionally change the scale of the provided value to enable finer PWM duty control [default = 255]
-   */
-  static void set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size=255, const bool invert=false);
-
-  /**
-   * Set the frequency of the timer corresponding to the provided pin
-   * All Hardware PWM pins will run at the same frequency and
-   * All Software PWM pins will run at the same frequency
-   */
-  static void set_pwm_frequency(const pin_t pin, const uint16_t f_desired);
-};
+void HAL_reboot();
@@ -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);
@@ -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
@@ -46,8 +46,6 @@ public:

  void end() {}

-  uint8_t availableForWrite(void) { /* flushTX(); */ return TX_BUFFER_SIZE; }
-
  #if ENABLED(EMERGENCY_PARSER)
    bool recv_callback(const char c) override;
  #endif
@@ -65,5 +65,4 @@ class libServo: public Servo {
  }
 };

-class libServo;
-typedef libServo hal_servo_t;
+#define HAL_SERVO_LIB libServo
@@ -1,9 +1,10 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
+ * Copyright (c) 2015-2016 Nico Tonnhofer wurstnase.reprap@gmail.com
+ * Copyright (c) 2016 Victor Perez victor_pv@hotmail.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
@@ -19,19 +20,12 @@
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 */
-
-/**
- * Implementation of EEPROM settings in SD Card
- */
-
 #ifdef TARGET_LPC1768

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

 #if ENABLED(SDCARD_EEPROM_EMULATION)

-//#define DEBUG_SD_EEPROM_EMULATION
-
 #include "../shared/eeprom_api.h"

 #include <chanfs/diskio.h>
@@ -44,11 +38,9 @@ FATFS fat_fs;
 FIL eeprom_file;
 bool eeprom_file_open = false;

-#define EEPROM_FILENAME "eeprom.dat"
 #ifndef MARLIN_EEPROM_SIZE
  #define MARLIN_EEPROM_SIZE size_t(0x1000) // 4KiB of Emulated EEPROM
 #endif
-
 size_t PersistentStore::capacity() { return MARLIN_EEPROM_SIZE; }

 bool PersistentStore::access_start() {
@@ -58,7 +50,7 @@ bool PersistentStore::access_start() {
    MSC_Release_Lock();
    return false;
  }
-  FRESULT res = f_open(&eeprom_file, EEPROM_FILENAME, FA_OPEN_ALWAYS | FA_WRITE | FA_READ);
+  FRESULT res = f_open(&eeprom_file, "eeprom.dat", FA_OPEN_ALWAYS | FA_WRITE | FA_READ);
  if (res) MSC_Release_Lock();

  if (res == FR_OK) {
@@ -89,20 +81,18 @@ bool PersistentStore::access_finish() {
 // This extra chit-chat goes away soon, but is helpful for now
 // to see errors that are happening in read_data / write_data
 static void debug_rw(const bool write, int &pos, const uint8_t *value, const size_t size, const FRESULT s, const size_t total=0) {
-  #if ENABLED(DEBUG_SD_EEPROM_EMULATION)
-    FSTR_P const rw_str = write ? F("write") : F("read");
-    SERIAL_CHAR(' ');
-    SERIAL_ECHOF(rw_str);
-    SERIAL_ECHOLNPGM("_data(", pos, ",", *value, ",", size, ", ...)");
-    if (total) {
-      SERIAL_ECHOPGM(" f_");
-      SERIAL_ECHOF(rw_str);
-      SERIAL_ECHOPGM("()=", s, "\n size=", size, "\n bytes_");
-      SERIAL_ECHOLNF(write ? F("written=") : F("read="), total);
-    }
-    else
-      SERIAL_ECHOLNPGM(" f_lseek()=", s);
-  #endif
+  PGM_P const rw_str = write ? PSTR("write") : PSTR("read");
+  SERIAL_CHAR(' ');
+  SERIAL_ECHOPGM_P(rw_str);
+  SERIAL_ECHOLNPAIR("_data(", pos, ",", value, ",", size, ", ...)");
+  if (total) {
+    SERIAL_ECHOPGM(" f_");
+    SERIAL_ECHOPGM_P(rw_str);
+    SERIAL_ECHOPAIR("()=", s, "\n size=", size, "\n bytes_");
+    SERIAL_ECHOLNPAIR_P(write ? PSTR("written=") : PSTR("read="), total);
+  }
+  else
+    SERIAL_ECHOLNPAIR(" f_lseek()=", s);
 }

 // File function return codes for type FRESULT. This goes away soon, but
@@ -155,37 +155,4 @@ void setup_endstop_interrupts() {
    #endif
    _ATTACH(K_MIN_PIN);
  #endif
-  #if HAS_U_MAX
-    #if !LPC1768_PIN_INTERRUPT_M(U_MAX_PIN)
-      #error "U_MAX_PIN is not INTERRUPT-capable."
-    #endif
-    _ATTACH(U_MAX_PIN);
-  #elif HAS_U_MIN
-    #if !LPC1768_PIN_INTERRUPT_M(U_MIN_PIN)
-      #error "U_MIN_PIN is not INTERRUPT-capable."
-    #endif
-    _ATTACH(U_MIN_PIN);
-  #endif
-  #if HAS_V_MAX
-    #if !LPC1768_PIN_INTERRUPT_M(V_MAX_PIN)
-      #error "V_MAX_PIN is not INTERRUPT-capable."
-    #endif
-    _ATTACH(V_MAX_PIN);
-  #elif HAS_V_MIN
-    #if !LPC1768_PIN_INTERRUPT_M(V_MIN_PIN)
-      #error "V_MIN_PIN is not INTERRUPT-capable."
-    #endif
-    _ATTACH(V_MIN_PIN);
-  #endif
-  #if HAS_W_MAX
-    #if !LPC1768_PIN_INTERRUPT_M(W_MAX_PIN)
-      #error "W_MAX_PIN is not INTERRUPT-capable."
-    #endif
-    _ATTACH(W_MAX_PIN);
-  #elif HAS_W_MIN
-    #if !LPC1768_PIN_INTERRUPT_M(W_MIN_PIN)
-      #error "W_MIN_PIN is not INTERRUPT-capable."
-    #endif
-    _ATTACH(W_MIN_PIN);
-  #endif
 }
@@ -21,17 +21,19 @@
 */
 #ifdef TARGET_LPC1768

-#include "../../inc/MarlinConfig.h"
+#include "../../inc/MarlinConfigPre.h"
+
+#if NEEDS_HARDWARE_PWM // Specific meta-flag for features that mandate PWM
+
 #include <pwm.h>

-void MarlinHAL::set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size/*=255*/, const bool invert/*=false*/) {
-  if (!LPC176x::pin_is_valid(pin)) return;
-  if (LPC176x::pwm_attach_pin(pin))
-    LPC176x::pwm_write_ratio(pin, invert ? 1.0f - (float)v / v_size : (float)v / v_size);  // map 1-254 onto PWM range
-}
-
-void MarlinHAL::set_pwm_frequency(const pin_t pin, const uint16_t f_desired) {
+void set_pwm_frequency(const pin_t pin, int f_desired) {
  LPC176x::pwm_set_frequency(pin, f_desired);
 }

+void set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size/*=255*/, const bool invert/*=false*/) {
+  LPC176x::pwm_write_ratio(pin, invert ? 1.0f - (float)v / v_size : (float)v / v_size);
+}
+
+#endif // NEEDS_HARDWARE_PWM
 #endif // TARGET_LPC1768
@@ -67,7 +67,7 @@ static_assert(!(NUM_SERVOS && ENABLED(FAST_PWM_FAN)), "BLTOUCH and Servos are in
 * Test LPC176x-specific configuration values for errors at compile-time.
 */

-//#if ENABLED(SPINDLE_LASER_USE_PWM) && !(SPINDLE_LASER_PWM_PIN == 4 || SPINDLE_LASER_PWM_PIN == 6 || SPINDLE_LASER_PWM_PIN == 11)
+//#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

@@ -113,7 +113,7 @@ static_assert(DISABLED(BAUD_RATE_GCODE), "BAUD_RATE_GCODE is not yet supported o
  #define _IS_RX1_1 IS_RX1
  #if IS_TX1(TMC_SW_SCK)
    #error "Serial port pins (1) conflict with other pins!"
-  #elif HAS_ROTARY_ENCODER
+  #elif HAS_WIRED_LCD
    #if IS_TX1(BTN_EN2) || IS_RX1(BTN_EN1)
      #error "Serial port pins (1) conflict with Encoder Buttons!"
    #elif ANY_TX(1, SD_SCK_PIN, LCD_PINS_D4, DOGLCD_SCK, LCD_RESET_PIN, LCD_PINS_RS, SHIFT_CLK_PIN) \
@@ -146,7 +146,7 @@ static_assert(DISABLED(BAUD_RATE_GCODE), "BAUD_RATE_GCODE is not yet supported o
    #error "Serial port pins (2) conflict with other pins!"
  #elif Y_HOME_TO_MIN && 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!"
@@ -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!"
@@ -77,7 +77,7 @@ public:

  //uint32_t spiRate() const { return spi_speed; }

-  static uint32_t spiRate2Clock(uint32_t spiRate) {
+  static inline uint32_t spiRate2Clock(uint32_t spiRate) {
    uint32_t Marlin_speed[7]; // CPSR is always 2
    Marlin_speed[0] = 8333333; //(SCR:  2)  desired: 8,000,000  actual: 8,333,333  +4.2%  SPI_FULL_SPEED
    Marlin_speed[1] = 4166667; //(SCR:  5)  desired: 4,000,000  actual: 4,166,667  +4.2%  SPI_HALF_SPEED
@@ -29,7 +29,7 @@

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

-#if ENABLED(DIGIPOT_MCP4451) && MB(MKS_SBASE)
+#if MB(MKS_SBASE)

 #ifdef __cplusplus
  extern "C" {
@@ -37,6 +37,35 @@

 #include "digipot_mcp4451_I2C_routines.h"

+// These two routines are exact copies of the lpc17xx_i2c.c routines.  Couldn't link to
+// to the lpc17xx_i2c.c routines so had to copy them into this file & rename them.
+
+static uint32_t _I2C_Start(LPC_I2C_TypeDef *I2Cx) {
+  // Reset STA, STO, SI
+  I2Cx->I2CONCLR = I2C_I2CONCLR_SIC|I2C_I2CONCLR_STOC|I2C_I2CONCLR_STAC;
+
+  // Enter to Master Transmitter mode
+  I2Cx->I2CONSET = I2C_I2CONSET_STA;
+
+  // Wait for complete
+  while (!(I2Cx->I2CONSET & I2C_I2CONSET_SI));
+  I2Cx->I2CONCLR = I2C_I2CONCLR_STAC;
+  return (I2Cx->I2STAT & I2C_STAT_CODE_BITMASK);
+}
+
+static void _I2C_Stop(LPC_I2C_TypeDef *I2Cx) {
+  // Make sure start bit is not active
+  if (I2Cx->I2CONSET & I2C_I2CONSET_STA)
+    I2Cx->I2CONCLR = I2C_I2CONCLR_STAC;
+
+  I2Cx->I2CONSET = I2C_I2CONSET_STO|I2C_I2CONSET_AA;
+  I2Cx->I2CONCLR = I2C_I2CONCLR_SIC;
+}
+
+I2C_M_SETUP_Type transferMCfg;
+
+#define I2C_status (LPC_I2C1->I2STAT & I2C_STAT_CODE_BITMASK)
+
 uint8_t digipot_mcp4451_start(uint8_t sla) {  // send slave address and write bit
  // Sometimes TX data ACK or NAK status is returned.  That mean the start state didn't
  // happen which means only the value of the slave address was send.  Keep looping until
@@ -73,5 +102,5 @@ uint8_t digipot_mcp4451_send_byte(uint8_t data) {
  }
 #endif

-#endif // DIGIPOT_MCP4451 && MKS_SBASE
+#endif // MB(MKS_SBASE)
 #endif // TARGET_LPC1768
@@ -63,32 +63,6 @@ void configure_i2c(const uint8_t clock_option) {
  I2C_Cmd(I2CDEV_M, I2C_MASTER_MODE, ENABLE);
 }

-//////////////////////////////////////////////////////////////////////////////////////
-// These two routines are exact copies of the lpc17xx_i2c.c routines.  Couldn't link to
-// to the lpc17xx_i2c.c routines so had to copy them into this file & rename them.
-
-uint32_t _I2C_Start(LPC_I2C_TypeDef *I2Cx) {
-  // Reset STA, STO, SI
-  I2Cx->I2CONCLR = I2C_I2CONCLR_SIC|I2C_I2CONCLR_STOC|I2C_I2CONCLR_STAC;
-
-  // Enter to Master Transmitter mode
-  I2Cx->I2CONSET = I2C_I2CONSET_STA;
-
-  // Wait for complete
-  while (!(I2Cx->I2CONSET & I2C_I2CONSET_SI));
-  I2Cx->I2CONCLR = I2C_I2CONCLR_STAC;
-  return (I2Cx->I2STAT & I2C_STAT_CODE_BITMASK);
-}
-
-void _I2C_Stop(LPC_I2C_TypeDef *I2Cx) {
-  /* Make sure start bit is not active */
-  if (I2Cx->I2CONSET & I2C_I2CONSET_STA)
-    I2Cx->I2CONCLR = I2C_I2CONCLR_STAC;
-
-  I2Cx->I2CONSET = I2C_I2CONSET_STO|I2C_I2CONSET_AA;
-  I2Cx->I2CONCLR = I2C_I2CONCLR_SIC;
-}
-
 #ifdef __cplusplus
  }
 #endif
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
InsanityAutomation	2065f1e267	Initial Commit	2021-06-05 18:37:34 -04:00
InsanityAutomation	5a4b2ba5c5	Merge branch 'bugfix-2.0.x' of https://github.com/MarlinFirmware/Marlin into bugfix-2.0.x	2021-06-05 16:51:34 -04:00
InsanityAutomation	a80c371340	Merge branch 'bugfix-2.0.x' of https://github.com/MarlinFirmware/Marlin into bugfix-2.0.x	2021-05-25 09:22:13 -04:00
InsanityAutomation	6d39a6fc55	Merge branch 'bugfix-2.0.x' of https://github.com/MarlinFirmware/Marlin into bugfix-2.0.x	2021-05-23 15:06:33 -04:00
InsanityAutomation	10e5d92dec	Merge branch 'bugfix-2.0.x' of https://github.com/MarlinFirmware/Marlin into bugfix-2.0.x	2021-05-16 14:18:43 -04:00
InsanityAutomation	2e11485da4	Merge branch 'bugfix-2.0.x' of https://github.com/MarlinFirmware/Marlin into bugfix-2.0.x	2021-05-06 11:55:25 -04:00
InsanityAutomation	d305f0a14b	Merge branch 'bugfix-2.0.x' of https://github.com/MarlinFirmware/Marlin into bugfix-2.0.x	2021-05-05 09:46:59 -04:00
Scott Lahteine	5f30e9fe1c	Add MKS_LCD12864B	2021-05-05 08:04:04 -05:00
Scott Lahteine	80c8218d94	Add MKS_LCD12864B	2021-05-05 07:23:52 -05:00
Scott Lahteine	bed2bfdc24	Misc comments	2021-05-05 07:18:05 -05:00
Scott Lahteine	6f2967a8dc	Cleanup, hex formatting	2021-05-05 06:34:02 -05:00