Update FUNDING.yml

.gitattributes

@@ -17,5 +17,3 @@
 *.png binary
 *.jpg binary
 *.fon binary
-*.bin binary
-*.woff binary

.github/FUNDING.yml

@@ -1,3 +1,3 @@
 github: [thinkyhead]
 patreon: thinkyhead
-custom: ["https://www.thinkyhead.com/donate-to-marlin"]
+custom: ["https://www.patreon.com/InsanityAutomation"]

.github/workflows/test-builds.yml

@@ -36,11 +36,9 @@ jobs:
         # Base Environments
 
         - DUE
-        - DUE_archim
         - esp32
         - linux_native
         - mega2560
-        - at90usb1286_dfu
         - teensy31
         - teensy35
         - teensy41
@@ -48,13 +46,13 @@ jobs:
 
         # Extended AVR Environments
 
-        - FYSETC_F6
+        - FYSETC_F6_13
         - mega1280
         - rambo
         - sanguino1284p
         - sanguino644p
 
-        # STM32F1 (Maple) Environments
+        # Extended STM32 Environments
 
         - STM32F103RC_btt
         - STM32F103RC_btt_USB
@@ -64,39 +62,39 @@ jobs:
         - STM32F103RC_meeb
         - jgaurora_a5s_a1
         - STM32F103VE_longer
-        - mks_robin
-        - mks_robin_lite
-        - mks_robin_pro
-        - STM32F103RET6_creality
-        - mks_robin_nano35
-
-        # STM32 (ST) Environments
-
         - STM32F407VE_black
         - STM32F401VE_STEVAL
         - BIGTREE_BTT002
         - BIGTREE_SKR_PRO
         - BIGTREE_GTR_V1_0
+        - mks_robin
         - mks_robin_stm32
         - ARMED
         - FYSETC_S6
         - STM32F070CB_malyan
         - STM32F070RB_malyan
         - malyan_M300
+        - mks_robin_lite
         - FLYF407ZG
         - rumba32
+        - mks_robin_pro
+        - STM32F103RET6_creality
         - LERDGEX
-        - mks_robin_nano35_stm32
+        - mks_robin_nano35
-        - NUCLEO_F767ZI
-        - REMRAM_V1
 
         # Put lengthy tests last
 
         - LPC1768
         - LPC1769
 
+        # STM32 with non-STM framework. both broken for now. they should use HAL_STM32 which is working.
+
+        #- STM32F4
+        #- STM32F7
+
         # Non-working environment tests
         #- at90usb1286_cdc
+        #- at90usb1286_dfu
         #- STM32F103CB_malyan
         #- mks_robin_mini
 
@@ -118,4 +116,8 @@ jobs:
 
     - name: Run ${{ matrix.test-platform }} Tests
       run: |
-        make tests-single-ci TEST_TARGET=${{ matrix.test-platform }}
+        # Inline tests script
+        chmod +x buildroot/bin/*
+        chmod +x buildroot/tests/*
+        export PATH=./buildroot/bin/:./buildroot/tests/:${PATH}
+        run_tests . ${{ matrix.test-platform }}

.gitignore

@@ -19,9 +19,9 @@
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 #
 
-# Generated files
+# Our automatic versioning scheme generates the following file
+# NEVER put it in the repository
 _Version.h
-bdf2u8g
 
 #
 # OS
@@ -77,6 +77,7 @@ tags
 *.out
 *.app
 
+
 #
 # C
 #
@@ -148,7 +149,7 @@ Marlin/*/*/*/*/readme.txt
 # Secure Credentials
 Configuration_Secure.h
 
-# Visual Studio
+#Visual Studio
 *.sln
 *.vcxproj
 *.vcxproj.user
@@ -159,34 +160,27 @@ __vm/
 .vs/
 vc-fileutils.settings
 
-# Visual Studio Code
+#Visual Studio Code
 .vscode
 .vscode/.browse.c_cpp.db*
 .vscode/c_cpp_properties.json
 .vscode/launch.json
 .vscode/*.db
 
-# cmake
+#cmake
 CMakeLists.txt
 src/CMakeLists.txt
 CMakeListsPrivate.txt
 
-# CLion
+#CLion
 cmake-build-*
 
-# Eclipse
+#Eclipse
 .project
 .cproject
 .pydevproject
 .settings
 .classpath
 
-# Python
+#Python
 __pycache__
-
-# IOLogger logs
-*_log.csv
-
-# Simulation / Native
-eeprom.dat
-imgui.ini

Makefile

@@ -1,52 +0,0 @@
-help:
-	@echo "Tasks for local development:"
-	@echo "* tests-single-ci:             Run a single test from inside the CI"
-	@echo "* tests-single-local:          Run a single test locally"
-	@echo "* tests-single-local-docker:   Run a single test locally, using docker-compose"
-	@echo "* tests-all-local:             Run all tests locally"
-	@echo "* tests-all-local-docker:      Run all tests locally, using docker-compose"
-	@echo "* setup-local-docker:          Setup local docker-compose"
-	@echo ""
-	@echo "Options for testing:"
-	@echo "  TEST_TARGET          Set when running tests-single-*, to select the"
-	@echo "                       test. If you set it to ALL it will run all "
-	@echo "                       tests, but some of them are broken: use "
-	@echo "                       tests-all-* instead to run only the ones that "
-	@echo "                       run on GitHub CI"
-	@echo "  ONLY_TEST            Limit tests to only those that contain this, or"
-	@echo "                       the index of the test (1-based)"
-	@echo "  VERBOSE_PLATFORMIO   If you want the full PIO output, set any value"
-	@echo "  GIT_RESET_HARD       Used by CI: reset all local changes. WARNING:"
-	@echo "                       THIS WILL UNDO ANY CHANGES YOU'VE MADE!"
-.PHONY: help
-
-tests-single-ci:
-	export GIT_RESET_HARD=true
-	$(MAKE) tests-single-local TEST_TARGET=$(TEST_TARGET)
-.PHONY: tests-single-ci
-
-tests-single-local:
-	@if ! test -n "$(TEST_TARGET)" ; then echo "***ERROR*** Set TEST_TARGET=<your-module> or use make tests-all-local" ; return 1; fi
-	export PATH=./buildroot/bin/:./buildroot/tests/:${PATH} \
-	  && export VERBOSE_PLATFORMIO=$(VERBOSE_PLATFORMIO) \
-	  && run_tests . $(TEST_TARGET) "$(ONLY_TEST)"
-.PHONY: tests-single-local
-
-tests-single-local-docker:
-	@if ! test -n "$(TEST_TARGET)" ; then echo "***ERROR*** Set TEST_TARGET=<your-module> or use make tests-all-local-docker" ; return 1; fi
-	docker-compose run --rm marlin $(MAKE) tests-single-local TEST_TARGET=$(TEST_TARGET) VERBOSE_PLATFORMIO=$(VERBOSE_PLATFORMIO) GIT_RESET_HARD=$(GIT_RESET_HARD) ONLY_TEST="$(ONLY_TEST)"
-.PHONY: tests-single-local-docker
-
-tests-all-local:
-	export PATH=./buildroot/bin/:./buildroot/tests/:${PATH} \
-	  && export VERBOSE_PLATFORMIO=$(VERBOSE_PLATFORMIO) \
-	  && for TEST_TARGET in $$(./get_test_targets.py) ; do echo "Running tests for $$TEST_TARGET" ; run_tests . $$TEST_TARGET ; done
-.PHONY: tests-all-local
-
-tests-all-local-docker:
-	docker-compose run --rm marlin $(MAKE) tests-all-local VERBOSE_PLATFORMIO=$(VERBOSE_PLATFORMIO) GIT_RESET_HARD=$(GIT_RESET_HARD)
-.PHONY: tests-all-local-docker
-
-setup-local-docker:
-	docker-compose build
-.PHONY: setup-local-docker

Marlin/Makefile

@@ -22,10 +22,8 @@
 #     (e.g. UPLOAD_PORT = /dev/tty.USB0).  If the exact name of this file
 #     changes, you can use * as a wild card (e.g. UPLOAD_PORT = /dev/tty.usb*).
 #
-#  3. Set the line containing "MCU" to match your board's processor. Set
+#  3. Set the line containing "MCU" to match your board's processor.
-#     "PROG_MCU" as the AVR part name corresponding to "MCU". You can use the
+#     Older one's are atmega8 based, newer ones like Arduino Mini, Bluetooth
-#     following command to get a list of correspondences: `avrdude -c alf -p x`
-#     Older boards are atmega8 based, newer ones like Arduino Mini, Bluetooth
 #     or Diecimila have the atmega168.  If you're using a LilyPad Arduino,
 #     change F_CPU to 8000000. If you are using Gen7 electronics, you
 #     probably need to use 20000000. Either way, you must regenerate
@@ -36,18 +34,18 @@
 #  5. Type "make upload", reset your Arduino board, and press enter to
 #     upload your program to the Arduino board.
 #
-# Note that all settings at the top of this file can be overridden from
+# Note that all settings at the top of this file can be overriden from
 # the command line with, for example, "make HARDWARE_MOTHERBOARD=71"
 #
 # To compile for RAMPS (atmega2560) with Arduino 1.6.9 at root/arduino you would use...
 #
 #   make ARDUINO_VERSION=10609 AVR_TOOLS_PATH=/root/arduino/hardware/tools/avr/bin/ \
-#   HARDWARE_MOTHERBOARD=1200 ARDUINO_INSTALL_DIR=/root/arduino
+#   HARDWARE_MOTHERBOARD=33 ARDUINO_INSTALL_DIR=/root/arduino
 #
 # To compile and upload simply add "upload" to the end of the line...
 #
 #   make ARDUINO_VERSION=10609 AVR_TOOLS_PATH=/root/arduino/hardware/tools/avr/bin/ \
-#   HARDWARE_MOTHERBOARD=1200 ARDUINO_INSTALL_DIR=/root/arduino upload
+#   HARDWARE_MOTHERBOARD=33 ARDUINO_INSTALL_DIR=/root/arduino upload
 #
 # If uploading doesn't work try adding the parameter "AVRDUDE_PROGRAMMER=wiring" or
 # start upload manually (using stk500) like so:
@@ -59,26 +57,7 @@
 #
 
 # This defines the board to compile for (see boards.h for your board's ID)
-HARDWARE_MOTHERBOARD ?= 1020
+HARDWARE_MOTHERBOARD ?= 11
-
-ifeq ($(OS),Windows_NT)
-  # Windows
-  ARDUINO_INSTALL_DIR ?= ${HOME}/Arduino
-  ARDUINO_USER_DIR ?= ${HOME}/Arduino
-else
-  UNAME_S := $(shell uname -s)
-  ifeq ($(UNAME_S),Linux)
-    # Linux
-    ARDUINO_INSTALL_DIR ?= /usr/share/arduino
-    ARDUINO_USER_DIR ?= ${HOME}/Arduino
-  endif
-  ifeq ($(UNAME_S),Darwin)
-    # Darwin (macOS)
-    ARDUINO_INSTALL_DIR ?= /Applications/Arduino.app/Contents/Java
-    ARDUINO_USER_DIR ?= ${HOME}/Documents/Arduino
-    AVR_TOOLS_PATH ?= /Applications/Arduino.app/Contents/Java/hardware/tools/avr/bin/
-  endif
-endif
 
 # Arduino source install directory, and version number
 # On most linuxes this will be /usr/share/arduino
@@ -88,38 +67,32 @@ ARDUINO_VERSION      ?= 106
 # The installed Libraries are in the User folder
 ARDUINO_USER_DIR ?= ${HOME}/Arduino
 
-# You can optionally set a path to the avr-gcc tools.
+# You can optionally set a path to the avr-gcc tools. Requires a trailing slash. (ex: /usr/local/avr-gcc/bin)
-# Requires a trailing slash. For example, /usr/local/avr-gcc/bin/
 AVR_TOOLS_PATH ?=
 
-# Programmer configuration
+#Programmer configuration
 UPLOAD_RATE        ?= 57600
 AVRDUDE_PROGRAMMER ?= arduino
-# On most linuxes this will be /dev/ttyACM0 or /dev/ttyACM1
+# on most linuxes this will be /dev/ttyACM0 or /dev/ttyACM1
 UPLOAD_PORT        ?= /dev/ttyUSB0
 
-# Directory used to build files in, contains all the build files, from object
+#Directory used to build files in, contains all the build files, from object files to the final hex file
-# files to the final hex file on linux it is best to put an absolute path
+#on linux it is best to put an absolute path like /home/username/tmp .
-# like /home/username/tmp .
 BUILD_DIR          ?= applet
 
 # This defines whether Liquid_TWI2 support will be built
 LIQUID_TWI2        ?= 0
 
-# This defines if Wire is needed
+# this defines if Wire is needed
 WIRE               ?= 0
 
-# This defines if Tone is needed (i.e SPEAKER is defined in Configuration.h)
+# this defines if U8GLIB is needed (may require RELOC_WORKAROUND)
-# Disabling this (and SPEAKER) saves approximatively 350 bytes of memory.
+U8GLIB             ?= 1
-TONE               ?= 1
 
-# This defines if U8GLIB is needed (may require RELOC_WORKAROUND)
+# this defines whether to include the Trinamic TMCStepper library
-U8GLIB             ?= 0
+TMC                ?= 1
 
-# This defines whether to include the Trinamic TMCStepper library
+# this defines whether to include the AdaFruit NeoPixel library
-TMC                ?= 0
-
-# This defines whether to include the AdaFruit NeoPixel library
 NEOPIXEL           ?= 0
 
 ############
@@ -235,8 +208,7 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1119)
 else ifeq ($(HARDWARE_MOTHERBOARD),1120)
 # Ultimaker (Older electronics. Pre 1.5.4. This is rare)
 else ifeq ($(HARDWARE_MOTHERBOARD),1121)
-  MCU              ?= atmega1280
+  MCU ?= atmega1280
-  PROG_MCU         ?= m1280
 
 # Azteeg X3
 else ifeq ($(HARDWARE_MOTHERBOARD),1122)
@@ -323,8 +295,6 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1203)
 else ifeq ($(HARDWARE_MOTHERBOARD),1204)
 # abee Scoovo X9H
 else ifeq ($(HARDWARE_MOTHERBOARD),1205)
-# Rambo ThinkerV2
-else ifeq ($(HARDWARE_MOTHERBOARD),1206)
 
 #
 # Other ATmega1280, ATmega2560
@@ -380,11 +350,9 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1320)
 # Minitronics v1.0/1.1
 else ifeq ($(HARDWARE_MOTHERBOARD),1400)
   MCU              ?= atmega1281
-  PROG_MCU         ?= m1281
 # Silvergate v1.0
 else ifeq ($(HARDWARE_MOTHERBOARD),1401)
   MCU              ?= atmega1281
-  PROG_MCU         ?= m1281
 
 #
 # Sanguinololu and Derivatives - ATmega644P, ATmega1284P
@@ -394,57 +362,46 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1401)
 else ifeq ($(HARDWARE_MOTHERBOARD),1500)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega644p
-  PROG_MCU         ?= m644p
 # Sanguinololu 1.2 and above
 else ifeq ($(HARDWARE_MOTHERBOARD),1501)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega644p
-  PROG_MCU         ?= m644p
 # Melzi
 else ifeq ($(HARDWARE_MOTHERBOARD),1502)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega644p
-  PROG_MCU         ?= m644p
 # Melzi V2.0
 else ifeq ($(HARDWARE_MOTHERBOARD),1503)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega1284p
-  PROG_MCU         ?= m1284p
 # Melzi with ATmega1284 (MaKr3d version)
 else ifeq ($(HARDWARE_MOTHERBOARD),1504)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega1284p
-  PROG_MCU         ?= m1284p
 # Melzi Creality3D board (for CR-10 etc)
 else ifeq ($(HARDWARE_MOTHERBOARD),1505)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega1284p
-  PROG_MCU         ?= m1284p
 # Melzi Malyan M150 board
 else ifeq ($(HARDWARE_MOTHERBOARD),1506)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega1284p
-  PROG_MCU         ?= m1284p
 # Tronxy X5S
 else ifeq ($(HARDWARE_MOTHERBOARD),1507)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega1284p
-  PROG_MCU         ?= m1284p
 # STB V1.1
 else ifeq ($(HARDWARE_MOTHERBOARD),1508)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega1284p
-  PROG_MCU         ?= m1284p
 # Azteeg X1
 else ifeq ($(HARDWARE_MOTHERBOARD),1509)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega1284p
-  PROG_MCU         ?= m1284p
 # Anet 1.0 (Melzi clone)
 else ifeq ($(HARDWARE_MOTHERBOARD),1510)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega1284p
-  PROG_MCU         ?= m1284p
 
 #
 # Other ATmega644P, ATmega644, ATmega1284P
@@ -454,61 +411,50 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1510)
 else ifeq ($(HARDWARE_MOTHERBOARD),1600)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega644p
-  PROG_MCU         ?= m644p
 # Gen3+
 else ifeq ($(HARDWARE_MOTHERBOARD),1601)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega644p
-  PROG_MCU         ?= m644p
 # Gen6
 else ifeq ($(HARDWARE_MOTHERBOARD),1602)
   HARDWARE_VARIANT ?= Gen6
   MCU              ?= atmega644p
-  PROG_MCU         ?= m644p
 # Gen6 deluxe
 else ifeq ($(HARDWARE_MOTHERBOARD),1603)
   HARDWARE_VARIANT ?= Gen6
   MCU              ?= atmega644p
-  PROG_MCU         ?= m644p
 # Gen7 custom (Alfons3 Version)
 else ifeq ($(HARDWARE_MOTHERBOARD),1604)
   HARDWARE_VARIANT ?= Gen7
   MCU              ?= atmega644
-  PROG_MCU         ?= m644
   F_CPU            ?= 20000000
 # Gen7 v1.1, v1.2
 else ifeq ($(HARDWARE_MOTHERBOARD),1605)
   HARDWARE_VARIANT ?= Gen7
   MCU              ?= atmega644p
-  PROG_MCU         ?= m644p
   F_CPU            ?= 20000000
 # Gen7 v1.3
 else ifeq ($(HARDWARE_MOTHERBOARD),1606)
   HARDWARE_VARIANT ?= Gen7
   MCU              ?= atmega644p
-  PROG_MCU         ?= m644p
   F_CPU            ?= 20000000
 # Gen7 v1.4
 else ifeq ($(HARDWARE_MOTHERBOARD),1607)
   HARDWARE_VARIANT ?= Gen7
   MCU              ?= atmega1284p
-  PROG_MCU         ?= m1284p
   F_CPU            ?= 20000000
 # Alpha OMCA board
 else ifeq ($(HARDWARE_MOTHERBOARD),1608)
   HARDWARE_VARIANT ?= SanguinoA
   MCU              ?= atmega644
-  PROG_MCU         ?= m644
 # Final OMCA board
 else ifeq ($(HARDWARE_MOTHERBOARD),1609)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega644p
-  PROG_MCU         ?= m644p
 # Sethi 3D_1
 else ifeq ($(HARDWARE_MOTHERBOARD),1610)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega644p
-  PROG_MCU         ?= m644p
 
 #
 # Teensyduino - AT90USB1286, AT90USB1286P
@@ -518,60 +464,51 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1610)
 else ifeq ($(HARDWARE_MOTHERBOARD),1700)
   HARDWARE_VARIANT ?= Teensy
   MCU              ?= at90usb1286
-  PROG_MCU         ?= usb1286
 # Printrboard (AT90USB1286)
 else ifeq ($(HARDWARE_MOTHERBOARD),1701)
   HARDWARE_VARIANT ?= Teensy
   MCU              ?= at90usb1286
-  PROG_MCU         ?= usb1286
 # Printrboard Revision F (AT90USB1286)
 else ifeq ($(HARDWARE_MOTHERBOARD),1702)
   HARDWARE_VARIANT ?= Teensy
   MCU              ?= at90usb1286
-  PROG_MCU         ?= usb1286
 # Brainwave (AT90USB646)
 else ifeq ($(HARDWARE_MOTHERBOARD),1703)
   HARDWARE_VARIANT ?= Teensy
   MCU              ?= at90usb646
-  PROG_MCU         ?= usb646
 # Brainwave Pro (AT90USB1286)
 else ifeq ($(HARDWARE_MOTHERBOARD),1704)
   HARDWARE_VARIANT ?= Teensy
   MCU              ?= at90usb1286
-  PROG_MCU         ?= usb1286
 # SAV Mk-I (AT90USB1286)
 else ifeq ($(HARDWARE_MOTHERBOARD),1705)
   HARDWARE_VARIANT ?= Teensy
   MCU              ?= at90usb1286
-  PROG_MCU         ?= usb1286
 # Teensy++2.0 (AT90USB1286)
 else ifeq ($(HARDWARE_MOTHERBOARD),1706)
   HARDWARE_VARIANT ?= Teensy
   MCU              ?= at90usb1286
-  PROG_MCU         ?= usb1286
 # 5DPrint D8 Driver Board
 else ifeq ($(HARDWARE_MOTHERBOARD),1707)
   HARDWARE_VARIANT ?= Teensy
   MCU              ?= at90usb1286
-  PROG_MCU         ?= usb1286
 
 # UltiMachine Archim1 (with DRV8825 drivers)
 else ifeq ($(HARDWARE_MOTHERBOARD),3023)
   HARDWARE_VARIANT ?= archim
   MCPU              = cortex-m3
-  F_CPU             = 84000000
+  F_CPU             = 84000000L
   IS_MCU            = 0
 # UltiMachine Archim2 (with TMC2130 drivers)
 else ifeq ($(HARDWARE_MOTHERBOARD),3024)
   HARDWARE_VARIANT ?= archim
   MCPU              = cortex-m3
-  F_CPU             = 84000000
+  F_CPU             = 84000000L
   IS_MCU            = 0
 endif
 
 # Be sure to regenerate speed_lookuptable.h with create_speed_lookuptable.py
 # if you are setting this to something other than 16MHz
-# Do not put the UL suffix, it's done later on.
 # Set to 16Mhz if not yet set.
 F_CPU ?= 16000000
 
@@ -581,8 +518,7 @@ IS_MCU ?= 1
 ifeq ($(IS_MCU),1)
   # Set to arduino, ATmega2560 if not yet set.
   HARDWARE_VARIANT ?= arduino
-  MCU              ?= atmega2560
+  MCU ?= atmega2560
-  PROG_MCU         ?= m2560
 
   TOOL_PREFIX = avr
   MCU_FLAGS   = -mmcu=$(MCU)
@@ -613,36 +549,27 @@ VPATH += $(BUILD_DIR)
 VPATH += $(HARDWARE_SRC)
 
 ifeq ($(HARDWARE_VARIANT), $(filter $(HARDWARE_VARIANT),arduino Teensy Sanguino))
-  # Old libraries (avr-core 1.6.21 < / Arduino < 1.6.8)
+VPATH += $(ARDUINO_INSTALL_DIR)/hardware/marlin/avr/libraries/LiquidCrystal/src
-  VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/SPI
+VPATH += $(ARDUINO_INSTALL_DIR)/hardware/marlin/avr/libraries/SPI
-  # New libraries (avr-core >= 1.6.21 / Arduino >= 1.6.8)
-  VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/SPI/src
 endif
 
 ifeq ($(IS_MCU),1)
   VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/cores/arduino
 
-  # Old libraries (avr-core 1.6.21 < / Arduino < 1.6.8)
   VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/SPI
-  VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/SoftwareSerial
-  # New libraries (avr-core >= 1.6.21 / Arduino >= 1.6.8)
   VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/SPI/src
   VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/SoftwareSerial/src
 endif
 
 VPATH += $(ARDUINO_INSTALL_DIR)/libraries/LiquidCrystal/src
-
 ifeq ($(LIQUID_TWI2), 1)
-  WIRE   = 1
+VPATH += $(ARDUINO_INSTALL_DIR)/libraries/Wire
-  VPATH += $(ARDUINO_INSTALL_DIR)/libraries/LiquidTWI2
+VPATH += $(ARDUINO_INSTALL_DIR)/libraries/Wire/utility
+VPATH += $(ARDUINO_INSTALL_DIR)/libraries/LiquidTWI2
 endif
 ifeq ($(WIRE), 1)
-  # Old libraries (avr-core 1.6.21 / Arduino < 1.6.8)
+VPATH += $(ARDUINO_INSTALL_DIR)/libraries/Wire
-  VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/Wire
+VPATH += $(ARDUINO_INSTALL_DIR)/libraries/Wire/utility
-  VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/Wire/utility
-  # New libraries (avr-core >= 1.6.21 / Arduino >= 1.6.8)
-  VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/Wire/src
-  VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/Wire/src/utility
 endif
 ifeq ($(NEOPIXEL), 1)
 VPATH += $(ARDUINO_INSTALL_DIR)/libraries/Adafruit_NeoPixel
@@ -714,23 +641,13 @@ ifeq ($(WIRE), 1)
   LIB_CXXSRC += Wire.cpp
 endif
 
-ifeq ($(TONE), 1)
-  LIB_CXXSRC += Tone.cpp
-endif
-
 ifeq ($(U8GLIB), 1)
   LIB_CXXSRC += U8glib.cpp
-  LIB_SRC += u8g_ll_api.c u8g_bitmap.c u8g_clip.c u8g_com_null.c u8g_delay.c \
+  LIB_SRC += u8g_ll_api.c u8g_bitmap.c u8g_clip.c u8g_com_null.c u8g_delay.c u8g_page.c u8g_pb.c u8g_pb16h1.c u8g_rect.c u8g_state.c u8g_font.c u8g_font_6x13.c u8g_font_04b_03.c u8g_font_5x8.c
-    u8g_page.c u8g_pb.c u8g_pb16h1.c u8g_rect.c u8g_state.c u8g_font.c \
-    u8g_font_6x13.c u8g_font_04b_03.c u8g_font_5x8.c
 endif
 
 ifeq ($(TMC), 1)
-  LIB_CXXSRC += TMCStepper.cpp COOLCONF.cpp DRV_STATUS.cpp IHOLD_IRUN.cpp \
+  LIB_CXXSRC += TMCStepper.cpp COOLCONF.cpp DRV_STATUS.cpp IHOLD_IRUN.cpp CHOPCONF.cpp GCONF.cpp PWMCONF.cpp DRV_CONF.cpp DRVCONF.cpp DRVCTRL.cpp DRVSTATUS.cpp ENCMODE.cpp RAMP_STAT.cpp SGCSCONF.cpp SHORT_CONF.cpp SMARTEN.cpp SW_MODE.cpp SW_SPI.cpp TMC2130Stepper.cpp TMC2208Stepper.cpp TMC2209Stepper.cpp TMC2660Stepper.cpp TMC5130Stepper.cpp TMC5160Stepper.cpp
-    CHOPCONF.cpp GCONF.cpp PWMCONF.cpp DRV_CONF.cpp DRVCONF.cpp DRVCTRL.cpp \
-    DRVSTATUS.cpp ENCMODE.cpp RAMP_STAT.cpp SGCSCONF.cpp SHORT_CONF.cpp \
-    SMARTEN.cpp SW_MODE.cpp SW_SPI.cpp TMC2130Stepper.cpp TMC2208Stepper.cpp \
-    TMC2209Stepper.cpp TMC2660Stepper.cpp TMC5130Stepper.cpp TMC5160Stepper.cpp
 endif
 
 ifeq ($(RELOC_WORKAROUND), 1)
@@ -772,23 +689,17 @@ REMOVE = rm -f
 MV = mv -f
 
 # Place -D or -U options here
-CDEFS    = -DF_CPU=$(F_CPU)UL ${addprefix -D , $(DEFINES)} -DARDUINO=$(ARDUINO_VERSION)
+CDEFS    = -DF_CPU=$(F_CPU) ${addprefix -D , $(DEFINES)} -DARDUINO=$(ARDUINO_VERSION)
 CXXDEFS  = $(CDEFS)
 
 ifeq ($(HARDWARE_VARIANT), Teensy)
-  CDEFS      += -DUSB_SERIAL
+  CDEFS  += -DUSB_SERIAL
   LIB_SRC    += usb.c pins_teensy.c
   LIB_CXXSRC += usb_api.cpp
 
 else ifeq ($(HARDWARE_VARIANT), archim)
-  CDEFS      += -DARDUINO_SAM_ARCHIM -DARDUINO_ARCH_SAM -D__SAM3X8E__
+  CDEFS      += -DARDUINO_SAM_ARCHIM -DARDUINO_ARCH_SAM -D__SAM3X8E__ -DUSB_VID=0x27b1 -DUSB_PID=0x0001 -DUSBCON '-DUSB_MANUFACTURER="UltiMachine"' '-DUSB_PRODUCT_STRING="Archim"'
-  CDEFS      += -DUSB_VID=0x27B1 -DUSB_PID=0x0001 -DUSBCON
+  LIB_CXXSRC += variant.cpp IPAddress.cpp Reset.cpp RingBuffer.cpp Stream.cpp UARTClass.cpp  USARTClass.cpp abi.cpp new.cpp watchdog.cpp CDC.cpp PluggableUSB.cpp USBCore.cpp
-  CDEFS      += '-DUSB_MANUFACTURER="UltiMachine"' '-DUSB_PRODUCT_STRING="Archim"'
-
-  LIB_CXXSRC += variant.cpp IPAddress.cpp Reset.cpp RingBuffer.cpp Stream.cpp \
-    UARTClass.cpp  USARTClass.cpp abi.cpp new.cpp watchdog.cpp CDC.cpp \
-    PluggableUSB.cpp USBCore.cpp
-
   LIB_SRC    += cortex_handlers.c iar_calls_sam3.c syscalls_sam3.c dtostrf.c itoa.c
 
   ifeq ($(U8GLIB), 1)
@@ -814,20 +725,16 @@ CTUNING = -fsigned-char -funsigned-bitfields -fno-exceptions \
 ifneq ($(HARDWARE_MOTHERBOARD),)
   CTUNING += -DMOTHERBOARD=${HARDWARE_MOTHERBOARD}
 endif
-
 #CEXTRA = -Wa,-adhlns=$(<:.c=.lst)
 CXXEXTRA = -fno-use-cxa-atexit -fno-threadsafe-statics -fno-rtti
 CFLAGS := $(CDEBUG) $(CDEFS) $(CINCS) -O$(OPT) $(CEXTRA)   $(CTUNING) $(CSTANDARD)
 CXXFLAGS :=         $(CDEFS) $(CINCS) -O$(OPT) $(CXXEXTRA) $(CTUNING) $(CXXSTANDARD)
 ASFLAGS :=          $(CDEFS)
 #ASFLAGS = -Wa,-adhlns=$(<:.S=.lst),-gstabs
-
 ifeq ($(HARDWARE_VARIANT), archim)
   LD_PREFIX = -Wl,--gc-sections,-Map,Marlin.ino.map,--cref,--check-sections,--entry=Reset_Handler,--unresolved-symbols=report-all,--warn-common,--warn-section-align
   LD_SUFFIX = $(LDLIBS)
-
+  LDFLAGS   = -lm -T$(LDSCRIPT) -u _sbrk -u link -u _close -u _fstat -u _isatty -u _lseek -u _read -u _write -u _exit -u kill -u _getpid
-  LDFLAGS   = -lm -T$(LDSCRIPT) -u _sbrk -u link -u _close -u _fstat -u _isatty
-  LDFLAGS  += -u _lseek -u _read -u _write -u _exit -u kill -u _getpid
 else
   LD_PREFIX = -Wl,--gc-sections,--relax
   LDFLAGS   = -lm
@@ -843,7 +750,7 @@ else
   AVRDUDE_CONF = $(ARDUINO_INSTALL_DIR)/hardware/tools/avr/etc/avrdude.conf
 endif
 AVRDUDE_FLAGS = -D -C$(AVRDUDE_CONF) \
-  -p$(PROG_MCU) -P$(AVRDUDE_PORT) -c$(AVRDUDE_PROGRAMMER) \
+  -p$(MCU) -P$(AVRDUDE_PORT) -c$(AVRDUDE_PROGRAMMER) \
   -b$(UPLOAD_RATE)
 
 # Since Marlin 2.0, the source files may be distributed into several
@@ -944,7 +851,7 @@ extcoff: $(TARGET).elf
 
 .elf.eep:
 	-$(OBJCOPY) -j .eeprom --set-section-flags=.eeprom="alloc,load" \
-	  --change-section-lma .eeprom=0 -O $(FORMAT) $< $@
+    --change-section-lma .eeprom=0 -O $(FORMAT) $< $@
 
 # Create extended listing file from ELF output file.
 .elf.lss:
@@ -958,7 +865,7 @@ extcoff: $(TARGET).elf
 
 $(BUILD_DIR)/$(TARGET).elf: $(OBJ) Configuration.h
 	$(Pecho) "  CXX   $@"
-	$P $(CXX) $(LD_PREFIX) $(ALL_CXXFLAGS) -o $@ -L. $(OBJ) $(LDFLAGS) $(LD_SUFFIX)
+	$P $(CC) $(LD_PREFIX) $(ALL_CXXFLAGS) -o $@ -L. $(OBJ) $(LDFLAGS) $(LD_SUFFIX)
 
 # Object files that were found in "src" will be stored in $(BUILD_DIR)
 # in directories that mirror the structure of "src"

Marlin/Version.h

@@ -54,7 +54,7 @@
  * has a distinct Github fork— the Source Code URL should just be the main
  * Marlin repository.
  */
-//#define SOURCE_CODE_URL "github.com/MarlinFirmware/Marlin"
+//#define SOURCE_CODE_URL "https://github.com/MarlinFirmware/Marlin"
 
 /**
  * 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 "https://marlinfw.org"
 
 /**
  * Set the vendor info the serial USB interface, if changable

Marlin/_Bootscreen.h

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

Marlin/_Statusscreen.h

@@ -1,72 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * Custom Status Screen bitmap
- *
- * Place this file in the root with your configuration files
- * and enable CUSTOM_STATUS_SCREEN_IMAGE in Configuration.h.
- *
- * Use the Marlin Bitmap Converter to make your own:
- * http://marlinfw.org/tools/u8glib/converter.html
- */
-
-//
-// Status Screen Logo bitmap
-//
-#define STATUS_LOGO_Y            1
-#define STATUS_LOGO_WIDTH       32
-
-const unsigned char status_logo_bmp[] PROGMEM = {
-  0x00,0x00,0x00,0x00, // ................................
-  0x00,0x00,0x00,0x00, // ................................
-  0x00,0x00,0x00,0x00, // ................................
-  0x00,0x00,0x10,0x00, // ...................#............
-  0x00,0x00,0x06,0x00, // .....................##.........
-  0x00,0x00,0x00,0x00, // ................................
-  0x01,0x00,0x00,0x00, // .......#........................
-  0x08,0x00,0x01,0x00, // ....#..................#........
-  0x01,0x00,0x41,0x00, // .......#.........#.....#........
-  0x01,0x00,0x02,0x00, // .......#..............#.........
-  0x00,0xE0,0x00,0x00, // ........###.....................
-  0x80,0x08,0x10,0x80, // #...........#......#....#.......
-  0x04,0x00,0x00,0x40, // .....#...................#......
-  0x08,0x00,0x08,0x00, // ....#...............#...........
-  0x10,0x04,0x00,0x00, // ...#.........#..................
-  0x00,0x00,0x00,0x30, // ..........................##....
-  0x00,0x00,0x00,0x20, // ..........................#.....
-  0x00,0x01,0xE8,0x20, // ...............####.#.....#.....
-  0x00,0x00,0x00,0x60, // .........................##.....
-  0x00,0x00,0x02,0x00, // ......................#.........
-  0x00,0x08,0x00,0x00, // ............#...................
-  0x00,0x00,0x01,0x20, // .......................#..#.....
-  0x02,0xE8,0x10,0x60, // ......#.###.#......#.....##.....
-  0x00,0x00,0x00,0x40, // .........................#......
-  0x00,0x03,0xC0,0x60, // ..............####.......##.....
-  0x64,0x00,0x10,0x00, // .##..#.............#............
-  0x04,0x03,0xC0,0x00, // .....#........####..............
-  0x02,0x00,0x20,0x00, // ......#...........#.............
-  0x00,0x28,0x00,0x00, // ..........#.#...................
-  0x00,0x08,0x20,0x00, // ............#.....#.............
-  0x00,0x00,0x40,0x00, // .................#..............
-  0x00,0x00,0x00,0x00  // ................................
-};

Marlin/src/HAL/AVR/HAL.cpp

@@ -24,13 +24,6 @@
 #include "../../inc/MarlinConfig.h"
 #include "HAL.h"
 
-#ifdef USBCON
-  DefaultSerial1 MSerial0(false, Serial);
-  #ifdef BLUETOOTH
-    BTSerial btSerial(false, bluetoothSerial);
-  #endif
-#endif
-
 // ------------------------
 // Public Variables
 // ------------------------

Marlin/src/HAL/AVR/HAL.h

@@ -82,36 +82,21 @@ typedef int8_t pin_t;
 
 // Serial ports
 #ifdef USBCON
-  #include "../../core/serial_hook.h"
+  #define MYSERIAL0 TERN(BLUETOOTH, bluetoothSerial, Serial)
-  typedef ForwardSerial1Class< decltype(Serial) > DefaultSerial1;
-  extern DefaultSerial1 MSerial0;
-  #ifdef BLUETOOTH
-    typedef ForwardSerial1Class< decltype(bluetoothSerial) > BTSerial;
-    extern BTSerial btSerial;
-  #endif
-
-  #define MYSERIAL1 TERN(BLUETOOTH, btSerial, MSerial0)
 #else
   #if !WITHIN(SERIAL_PORT, -1, 3)
     #error "SERIAL_PORT must be from -1 to 3. Please update your configuration."
   #endif
-  #define MYSERIAL1 customizedSerial1
+  #define MYSERIAL0 customizedSerial1
 
   #ifdef SERIAL_PORT_2
     #if !WITHIN(SERIAL_PORT_2, -1, 3)
       #error "SERIAL_PORT_2 must be from -1 to 3. Please update your configuration."
     #endif
-    #define MYSERIAL2 customizedSerial2
+    #define MYSERIAL1 customizedSerial2
   #endif
 #endif
 
-#ifdef MMU2_SERIAL_PORT
-  #if !WITHIN(MMU2_SERIAL_PORT, -1, 3)
-    #error "MMU2_SERIAL_PORT must be from -1 to 3. Please update your configuration."
-  #endif
-  #define MMU2_SERIAL mmuSerial
-#endif
-
 #ifdef LCD_SERIAL_PORT
   #if !WITHIN(LCD_SERIAL_PORT, -1, 3)
     #error "LCD_SERIAL_PORT must be from -1 to 3. Please update your configuration."
@@ -135,18 +120,12 @@ void HAL_init();
 inline void HAL_clear_reset_source() { MCUSR = 0; }
 inline uint8_t HAL_get_reset_source() { return MCUSR; }
 
-inline void HAL_reboot() {}  // reboot the board or restart the bootloader
+#pragma GCC diagnostic push
-
+#pragma GCC diagnostic ignored "-Wunused-function"
-#if GCC_VERSION <= 50000
+extern "C" {
-  #pragma GCC diagnostic push
+  int freeMemory();
-  #pragma GCC diagnostic ignored "-Wunused-function"
+}
-#endif
+#pragma GCC diagnostic pop
-
-extern "C" int freeMemory();
-
-#if GCC_VERSION <= 50000
-  #pragma GCC diagnostic pop
-#endif
 
 // ADC
 #ifdef DIDR2

Marlin/src/HAL/AVR/HAL_SPI.cpp

@@ -34,17 +34,17 @@
 #include "../../inc/MarlinConfig.h"
 
 void spiBegin() {
-  OUT_WRITE(SD_SS_PIN, HIGH);
+  OUT_WRITE(SS_PIN, HIGH);
-  SET_OUTPUT(SD_SCK_PIN);
+  SET_OUTPUT(SCK_PIN);
-  SET_INPUT(SD_MISO_PIN);
+  SET_INPUT(MISO_PIN);
-  SET_OUTPUT(SD_MOSI_PIN);
+  SET_OUTPUT(MOSI_PIN);
 
   #if DISABLED(SOFTWARE_SPI)
     // SS must be in output mode even it is not chip select
-    //SET_OUTPUT(SD_SS_PIN);
+    //SET_OUTPUT(SS_PIN);
     // set SS high - may be chip select for another SPI device
     //#if SET_SPI_SS_HIGH
-      //WRITE(SD_SS_PIN, HIGH);
+      //WRITE(SS_PIN, HIGH);
     //#endif
     // set a default rate
     spiInit(1);
@@ -195,19 +195,19 @@ void spiBegin() {
     // no interrupts during byte receive - about 8µs
     cli();
     // output pin high - like sending 0xFF
-    WRITE(SD_MOSI_PIN, HIGH);
+    WRITE(MOSI_PIN, HIGH);
 
     LOOP_L_N(i, 8) {
-      WRITE(SD_SCK_PIN, HIGH);
+      WRITE(SCK_PIN, HIGH);
 
       nop; // adjust so SCK is nice
       nop;
 
       data <<= 1;
 
-      if (READ(SD_MISO_PIN)) data |= 1;
+      if (READ(MISO_PIN)) data |= 1;
 
-      WRITE(SD_SCK_PIN, LOW);
+      WRITE(SCK_PIN, LOW);
     }
 
     sei();
@@ -225,10 +225,10 @@ void spiBegin() {
     // no interrupts during byte send - about 8µs
     cli();
     LOOP_L_N(i, 8) {
-      WRITE(SD_SCK_PIN, LOW);
+      WRITE(SCK_PIN, LOW);
-      WRITE(SD_MOSI_PIN, data & 0x80);
+      WRITE(MOSI_PIN, data & 0x80);
       data <<= 1;
-      WRITE(SD_SCK_PIN, HIGH);
+      WRITE(SCK_PIN, HIGH);
     }
 
     nop; // hold SCK high for a few ns
@@ -236,7 +236,7 @@ void spiBegin() {
     nop;
     nop;
 
-    WRITE(SD_SCK_PIN, LOW);
+    WRITE(SCK_PIN, LOW);
 
     sei();
   }

Marlin/src/HAL/AVR/MarlinSerial.cpp

@@ -454,7 +454,7 @@ void MarlinSerial<Cfg>::flush() {
 }
 
 template<typename Cfg>
-size_t MarlinSerial<Cfg>::write(const uint8_t c) {
+void MarlinSerial<Cfg>::write(const uint8_t c) {
   if (Cfg::TX_SIZE == 0) {
 
     _written = true;
@@ -480,7 +480,7 @@ size_t MarlinSerial<Cfg>::write(const uint8_t c) {
       // location". This makes sure flush() won't return until the bytes
       // actually got written
       B_TXC = 1;
-      return 1;
+      return;
     }
 
     const uint8_t i = (tx_buffer.head + 1) & (Cfg::TX_SIZE - 1);
@@ -510,7 +510,6 @@ size_t MarlinSerial<Cfg>::write(const uint8_t c) {
     // Enable TX ISR - Non atomic, but it will eventually enable TX ISR
     B_UDRIE = 1;
   }
-  return 1;
 }
 
 template<typename Cfg>
@@ -557,6 +556,161 @@ void MarlinSerial<Cfg>::flushTX() {
   }
 }
 
+/**
+ * Imports from print.h
+ */
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::print(char c, int base) {
+  print((long)c, base);
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::print(unsigned char b, int base) {
+  print((unsigned long)b, base);
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::print(int n, int base) {
+  print((long)n, base);
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::print(unsigned int n, int base) {
+  print((unsigned long)n, base);
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::print(long n, int base) {
+  if (base == 0) write(n);
+  else if (base == 10) {
+    if (n < 0) { print('-'); n = -n; }
+    printNumber(n, 10);
+  }
+  else
+    printNumber(n, base);
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::print(unsigned long n, int base) {
+  if (base == 0) write(n);
+  else printNumber(n, base);
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::print(double n, int digits) {
+  printFloat(n, digits);
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println() {
+  print('\r');
+  print('\n');
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(const String& s) {
+  print(s);
+  println();
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(const char c[]) {
+  print(c);
+  println();
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(char c, int base) {
+  print(c, base);
+  println();
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(unsigned char b, int base) {
+  print(b, base);
+  println();
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(int n, int base) {
+  print(n, base);
+  println();
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(unsigned int n, int base) {
+  print(n, base);
+  println();
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(long n, int base) {
+  print(n, base);
+  println();
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(unsigned long n, int base) {
+  print(n, base);
+  println();
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(double n, int digits) {
+  print(n, digits);
+  println();
+}
+
+// Private Methods
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::printNumber(unsigned long n, uint8_t base) {
+  if (n) {
+    unsigned char buf[8 * sizeof(long)]; // Enough space for base 2
+    int8_t i = 0;
+    while (n) {
+      buf[i++] = n % base;
+      n /= base;
+    }
+    while (i--)
+      print((char)(buf[i] + (buf[i] < 10 ? '0' : 'A' - 10)));
+  }
+  else
+    print('0');
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::printFloat(double number, uint8_t digits) {
+  // Handle negative numbers
+  if (number < 0.0) {
+    print('-');
+    number = -number;
+  }
+
+  // Round correctly so that print(1.999, 2) prints as "2.00"
+  double rounding = 0.5;
+  LOOP_L_N(i, digits) rounding *= 0.1;
+  number += rounding;
+
+  // Extract the integer part of the number and print it
+  unsigned long int_part = (unsigned long)number;
+  double remainder = number - (double)int_part;
+  print(int_part);
+
+  // Print the decimal point, but only if there are digits beyond
+  if (digits) {
+    print('.');
+    // Extract digits from the remainder one at a time
+    while (digits--) {
+      remainder *= 10.0;
+      int toPrint = int(remainder);
+      print(toPrint);
+      remainder -= toPrint;
+    }
+  }
+}
+
 // Hookup ISR handlers
 ISR(SERIAL_REGNAME(USART, SERIAL_PORT, _RX_vect)) {
   MarlinSerial<MarlinSerialCfg<SERIAL_PORT>>::store_rxd_char();
@@ -566,9 +720,11 @@ ISR(SERIAL_REGNAME(USART, SERIAL_PORT, _UDRE_vect)) {
   MarlinSerial<MarlinSerialCfg<SERIAL_PORT>>::_tx_udr_empty_irq();
 }
 
-// Because of the template definition above, it's required to instantiate the template to have all methods generated
+// Preinstantiate
-template class MarlinSerial< MarlinSerialCfg<SERIAL_PORT> >;
+template class MarlinSerial<MarlinSerialCfg<SERIAL_PORT>>;
-MSerialT customizedSerial1(MSerialT::HasEmergencyParser);
+
+// Instantiate
+MarlinSerial<MarlinSerialCfg<SERIAL_PORT>> customizedSerial1;
 
 #ifdef SERIAL_PORT_2
 
@@ -581,8 +737,12 @@ MSerialT customizedSerial1(MSerialT::HasEmergencyParser);
     MarlinSerial<MarlinSerialCfg<SERIAL_PORT_2>>::_tx_udr_empty_irq();
   }
 
-  template class MarlinSerial< MarlinSerialCfg<SERIAL_PORT_2> >;
+  // Preinstantiate
-  MSerialT2 customizedSerial2(MSerialT2::HasEmergencyParser);
+  template class MarlinSerial<MarlinSerialCfg<SERIAL_PORT_2>>;
+
+  // Instantiate
+  MarlinSerial<MarlinSerialCfg<SERIAL_PORT_2>> customizedSerial2;
+
 #endif
 
 #ifdef MMU2_SERIAL_PORT
@@ -595,8 +755,12 @@ MSerialT customizedSerial1(MSerialT::HasEmergencyParser);
     MarlinSerial<MMU2SerialCfg<MMU2_SERIAL_PORT>>::_tx_udr_empty_irq();
   }
 
-  template class MarlinSerial< MMU2SerialCfg<MMU2_SERIAL_PORT> >;
+  // Preinstantiate
-  MSerialT3 mmuSerial(MSerialT3::HasEmergencyParser);
+  template class MarlinSerial<MMU2SerialCfg<MMU2_SERIAL_PORT>>;
+
+  // Instantiate
+  MarlinSerial<MMU2SerialCfg<MMU2_SERIAL_PORT>> mmuSerial;
+
 #endif
 
 #ifdef LCD_SERIAL_PORT
@@ -609,8 +773,11 @@ MSerialT customizedSerial1(MSerialT::HasEmergencyParser);
     MarlinSerial<LCDSerialCfg<LCD_SERIAL_PORT>>::_tx_udr_empty_irq();
   }
 
-  template class MarlinSerial< LCDSerialCfg<LCD_SERIAL_PORT> >;
+  // Preinstantiate
-  MSerialT4 lcdSerial(MSerialT4::HasEmergencyParser);
+  template class MarlinSerial<LCDSerialCfg<LCD_SERIAL_PORT>>;
+
+  // Instantiate
+  MarlinSerial<LCDSerialCfg<LCD_SERIAL_PORT>> lcdSerial;
 
   #if HAS_DGUS_LCD
     template<typename Cfg>
@@ -629,7 +796,7 @@ MSerialT customizedSerial1(MSerialT::HasEmergencyParser);
 
 // For AT90USB targets use the UART for BT interfacing
 #if defined(USBCON) && ENABLED(BLUETOOTH)
-  MSerialT5 bluetoothSerial(false);
+  HardwareSerial bluetoothSerial;
 #endif
 
 #endif // __AVR__

Marlin/src/HAL/AVR/MarlinSerial.h

@@ -34,7 +34,6 @@
 #include <WString.h>
 
 #include "../../inc/MarlinConfigPre.h"
-#include "../../core/serial_hook.h"
 
 #ifndef SERIAL_PORT
   #define SERIAL_PORT 0
@@ -136,6 +135,10 @@
     UART_DECL(3);
   #endif
 
+  #define DEC 10
+  #define HEX 16
+  #define OCT 8
+  #define BIN 2
   #define BYTE 0
 
   // Templated type selector
@@ -199,30 +202,60 @@
     static FORCE_INLINE void atomic_set_rx_tail(ring_buffer_pos_t value);
     static FORCE_INLINE ring_buffer_pos_t atomic_read_rx_tail();
 
-  public:
+    public:
+
     FORCE_INLINE static void store_rxd_char();
     FORCE_INLINE static void _tx_udr_empty_irq();
 
-  public:
+    public:
-    static void begin(const long);
+      MarlinSerial() {};
-    static void end();
+      static void begin(const long);
-    static int peek();
+      static void end();
-    static int read();
+      static int peek();
-    static void flush();
+      static int read();
-    static ring_buffer_pos_t available();
+      static void flush();
-    static size_t write(const uint8_t c);
+      static ring_buffer_pos_t available();
-    static void flushTX();
+      static void write(const uint8_t c);
-    #if HAS_DGUS_LCD
+      static void flushTX();
-      static ring_buffer_pos_t get_tx_buffer_free();
+      #if HAS_DGUS_LCD
-    #endif
+        static ring_buffer_pos_t get_tx_buffer_free();
+      #endif
 
-    enum { HasEmergencyParser = Cfg::EMERGENCYPARSER };
+      static inline bool emergency_parser_enabled() { return Cfg::EMERGENCYPARSER; }
-    static inline bool emergency_parser_enabled() { return Cfg::EMERGENCYPARSER; }
 
-    FORCE_INLINE static uint8_t dropped() { return Cfg::DROPPED_RX ? rx_dropped_bytes : 0; }
+      FORCE_INLINE static uint8_t dropped() { return Cfg::DROPPED_RX ? rx_dropped_bytes : 0; }
-    FORCE_INLINE static uint8_t buffer_overruns() { return Cfg::RX_OVERRUNS ? rx_buffer_overruns : 0; }
+      FORCE_INLINE static uint8_t buffer_overruns() { return Cfg::RX_OVERRUNS ? rx_buffer_overruns : 0; }
-    FORCE_INLINE static uint8_t framing_errors() { return Cfg::RX_FRAMING_ERRORS ? rx_framing_errors : 0; }
+      FORCE_INLINE static uint8_t framing_errors() { return Cfg::RX_FRAMING_ERRORS ? rx_framing_errors : 0; }
-    FORCE_INLINE static ring_buffer_pos_t rxMaxEnqueued() { return Cfg::MAX_RX_QUEUED ? rx_max_enqueued : 0; }
+      FORCE_INLINE static ring_buffer_pos_t rxMaxEnqueued() { return Cfg::MAX_RX_QUEUED ? rx_max_enqueued : 0; }
+
+      FORCE_INLINE static void write(const char* str) { while (*str) write(*str++); }
+      FORCE_INLINE static void write(const uint8_t* buffer, size_t size) { while (size--) write(*buffer++); }
+      FORCE_INLINE static void print(const String& s) { for (int i = 0; i < (int)s.length(); i++) write(s[i]); }
+      FORCE_INLINE static void print(const char* str) { write(str); }
+
+      static void print(char, int = BYTE);
+      static void print(unsigned char, int = BYTE);
+      static void print(int, int = DEC);
+      static void print(unsigned int, int = DEC);
+      static void print(long, int = DEC);
+      static void print(unsigned long, int = DEC);
+      static void print(double, int = 2);
+
+      static void println(const String& s);
+      static void println(const char[]);
+      static void println(char, int = BYTE);
+      static void println(unsigned char, int = BYTE);
+      static void println(int, int = DEC);
+      static void println(unsigned int, int = DEC);
+      static void println(long, int = DEC);
+      static void println(unsigned long, int = DEC);
+      static void println(double, int = 2);
+      static void println();
+      operator bool() { return true; }
+
+    private:
+      static void printNumber(unsigned long, const uint8_t);
+      static void printFloat(double, uint8_t);
   };
 
   template <uint8_t serial>
@@ -237,13 +270,12 @@
     static constexpr bool RX_FRAMING_ERRORS = ENABLED(SERIAL_STATS_RX_FRAMING_ERRORS);
     static constexpr bool MAX_RX_QUEUED     = ENABLED(SERIAL_STATS_MAX_RX_QUEUED);
   };
-
+  extern MarlinSerial<MarlinSerialCfg<SERIAL_PORT>> customizedSerial1;
-  typedef Serial1Class< MarlinSerial< MarlinSerialCfg<SERIAL_PORT> > > MSerialT;
-  extern MSerialT customizedSerial1;
 
   #ifdef SERIAL_PORT_2
-    typedef Serial1Class< MarlinSerial< MarlinSerialCfg<SERIAL_PORT_2> > > MSerialT2;
+
-    extern MSerialT2 customizedSerial2;
+    extern MarlinSerial<MarlinSerialCfg<SERIAL_PORT_2>> customizedSerial2;
+
   #endif
 
 #endif // !USBCON
@@ -252,41 +284,49 @@
   template <uint8_t serial>
   struct MMU2SerialCfg {
     static constexpr int PORT               = serial;
-    static constexpr unsigned int RX_SIZE   = 32;
-    static constexpr unsigned int TX_SIZE   = 32;
     static constexpr bool XONOFF            = false;
     static constexpr bool EMERGENCYPARSER   = false;
     static constexpr bool DROPPED_RX        = false;
     static constexpr bool RX_FRAMING_ERRORS = false;
     static constexpr bool MAX_RX_QUEUED     = false;
+    static constexpr unsigned int RX_SIZE   = 32;
+    static constexpr unsigned int TX_SIZE   = 32;
     static constexpr bool RX_OVERRUNS       = false;
   };
 
-  typedef Serial1Class< MarlinSerial< MMU2SerialCfg<MMU2_SERIAL_PORT> > > MSerialT3;
+  extern MarlinSerial<MMU2SerialCfg<MMU2_SERIAL_PORT>> mmuSerial;
-  extern MSerialT3 mmuSerial;
 #endif
 
 #ifdef LCD_SERIAL_PORT
 
   template <uint8_t serial>
   struct LCDSerialCfg {
-    static constexpr int PORT               = serial;
+    static constexpr int PORT                 = serial;
-    static constexpr unsigned int RX_SIZE   = TERN(HAS_DGUS_LCD, DGUS_RX_BUFFER_SIZE,  64);
+    static constexpr bool XONOFF              = false;
-    static constexpr unsigned int TX_SIZE   = TERN(HAS_DGUS_LCD, DGUS_TX_BUFFER_SIZE, 128);
+    static constexpr bool EMERGENCYPARSER     = ENABLED(EMERGENCY_PARSER);
-    static constexpr bool XONOFF            = false;
+    static constexpr bool DROPPED_RX          = false;
-    static constexpr bool EMERGENCYPARSER   = ENABLED(EMERGENCY_PARSER);
+    static constexpr bool RX_FRAMING_ERRORS   = false;
-    static constexpr bool DROPPED_RX        = false;
+    static constexpr bool MAX_RX_QUEUED       = false;
-    static constexpr bool RX_FRAMING_ERRORS = false;
+    #if HAS_DGUS_LCD
-    static constexpr bool MAX_RX_QUEUED     = false;
+      static constexpr unsigned int RX_SIZE   = DGUS_RX_BUFFER_SIZE;
-    static constexpr bool RX_OVERRUNS       = BOTH(HAS_DGUS_LCD, SERIAL_STATS_RX_BUFFER_OVERRUNS);
+      static constexpr unsigned int TX_SIZE   = DGUS_TX_BUFFER_SIZE;
+      static constexpr bool RX_OVERRUNS       = ENABLED(SERIAL_STATS_RX_BUFFER_OVERRUNS);
+    #elif EITHER(ANYCUBIC_LCD_I3MEGA, ANYCUBIC_LCD_CHIRON)
+      static constexpr unsigned int RX_SIZE   = 64;
+      static constexpr unsigned int TX_SIZE   = 128;
+      static constexpr bool RX_OVERRUNS       = false;
+    #else
+      static constexpr unsigned int RX_SIZE   = 64;
+      static constexpr unsigned int TX_SIZE   = 128;
+      static constexpr bool RX_OVERRUNS       = false
+    #endif
   };
 
-  typedef Serial1Class< MarlinSerial< LCDSerialCfg<LCD_SERIAL_PORT> > > MSerialT4;
+  extern MarlinSerial<LCDSerialCfg<LCD_SERIAL_PORT>> lcdSerial;
-  extern MSerialT4 lcdSerial;
+
 #endif
 
 // Use the UART for Bluetooth in AT90USB configurations
 #if defined(USBCON) && ENABLED(BLUETOOTH)
-  typedef Serial1Class<HardwareSerial> MSerialT5;
+  extern HardwareSerial bluetoothSerial;
-  extern MSerialT5 bluetoothSerial;
 #endif

Marlin/src/HAL/AVR/eeprom.cpp

@@ -59,7 +59,7 @@ bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, ui
   return false;
 }
 
-bool PersistentStore::read_data(int &pos, uint8_t *value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
+bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
   do {
     uint8_t c = eeprom_read_byte((uint8_t*)pos);
     if (writing) *value = c;

Marlin/src/HAL/AVR/endstop_interrupts.h

@@ -124,7 +124,7 @@ void setup_endstop_interrupts() {
     #if (digitalPinToInterrupt(X_MAX_PIN) != NOT_AN_INTERRUPT)
       _ATTACH(X_MAX_PIN);
     #else
-      static_assert(digitalPinHasPCICR(X_MAX_PIN), "X_MAX_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
+      static_assert(digitalPinHasPCICR(X_MAX_PIN), "X_MAX_PIN is not interrupt-capable");
       pciSetup(X_MAX_PIN);
     #endif
   #endif
@@ -132,7 +132,7 @@ void setup_endstop_interrupts() {
     #if (digitalPinToInterrupt(X_MIN_PIN) != NOT_AN_INTERRUPT)
       _ATTACH(X_MIN_PIN);
     #else
-      static_assert(digitalPinHasPCICR(X_MIN_PIN), "X_MIN_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
+      static_assert(digitalPinHasPCICR(X_MIN_PIN), "X_MIN_PIN is not interrupt-capable");
       pciSetup(X_MIN_PIN);
     #endif
   #endif
@@ -140,7 +140,7 @@ void setup_endstop_interrupts() {
     #if (digitalPinToInterrupt(Y_MAX_PIN) != NOT_AN_INTERRUPT)
       _ATTACH(Y_MAX_PIN);
     #else
-      static_assert(digitalPinHasPCICR(Y_MAX_PIN), "Y_MAX_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
+      static_assert(digitalPinHasPCICR(Y_MAX_PIN), "Y_MAX_PIN is not interrupt-capable");
       pciSetup(Y_MAX_PIN);
     #endif
   #endif
@@ -148,7 +148,7 @@ void setup_endstop_interrupts() {
     #if (digitalPinToInterrupt(Y_MIN_PIN) != NOT_AN_INTERRUPT)
       _ATTACH(Y_MIN_PIN);
     #else
-      static_assert(digitalPinHasPCICR(Y_MIN_PIN), "Y_MIN_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
+      static_assert(digitalPinHasPCICR(Y_MIN_PIN), "Y_MIN_PIN is not interrupt-capable");
       pciSetup(Y_MIN_PIN);
     #endif
   #endif
@@ -156,7 +156,7 @@ void setup_endstop_interrupts() {
     #if (digitalPinToInterrupt(Z_MAX_PIN) != NOT_AN_INTERRUPT)
       _ATTACH(Z_MAX_PIN);
     #else
-      static_assert(digitalPinHasPCICR(Z_MAX_PIN), "Z_MAX_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
+      static_assert(digitalPinHasPCICR(Z_MAX_PIN), "Z_MAX_PIN is not interrupt-capable");
       pciSetup(Z_MAX_PIN);
     #endif
   #endif
@@ -164,7 +164,7 @@ void setup_endstop_interrupts() {
     #if (digitalPinToInterrupt(Z_MIN_PIN) != NOT_AN_INTERRUPT)
       _ATTACH(Z_MIN_PIN);
     #else
-      static_assert(digitalPinHasPCICR(Z_MIN_PIN), "Z_MIN_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
+      static_assert(digitalPinHasPCICR(Z_MIN_PIN), "Z_MIN_PIN is not interrupt-capable");
       pciSetup(Z_MIN_PIN);
     #endif
   #endif
@@ -172,7 +172,7 @@ void setup_endstop_interrupts() {
     #if (digitalPinToInterrupt(X2_MAX_PIN) != NOT_AN_INTERRUPT)
       _ATTACH(X2_MAX_PIN);
     #else
-      static_assert(digitalPinHasPCICR(X2_MAX_PIN), "X2_MAX_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
+      static_assert(digitalPinHasPCICR(X2_MAX_PIN), "X2_MAX_PIN is not interrupt-capable");
       pciSetup(X2_MAX_PIN);
     #endif
   #endif
@@ -180,7 +180,7 @@ void setup_endstop_interrupts() {
     #if (digitalPinToInterrupt(X2_MIN_PIN) != NOT_AN_INTERRUPT)
       _ATTACH(X2_MIN_PIN);
     #else
-      static_assert(digitalPinHasPCICR(X2_MIN_PIN), "X2_MIN_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
+      static_assert(digitalPinHasPCICR(X2_MIN_PIN), "X2_MIN_PIN is not interrupt-capable");
       pciSetup(X2_MIN_PIN);
     #endif
   #endif
@@ -188,7 +188,7 @@ void setup_endstop_interrupts() {
     #if (digitalPinToInterrupt(Y2_MAX_PIN) != NOT_AN_INTERRUPT)
       _ATTACH(Y2_MAX_PIN);
     #else
-      static_assert(digitalPinHasPCICR(Y2_MAX_PIN), "Y2_MAX_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
+      static_assert(digitalPinHasPCICR(Y2_MAX_PIN), "Y2_MAX_PIN is not interrupt-capable");
       pciSetup(Y2_MAX_PIN);
     #endif
   #endif
@@ -196,7 +196,7 @@ void setup_endstop_interrupts() {
     #if (digitalPinToInterrupt(Y2_MIN_PIN) != NOT_AN_INTERRUPT)
       _ATTACH(Y2_MIN_PIN);
     #else
-      static_assert(digitalPinHasPCICR(Y2_MIN_PIN), "Y2_MIN_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
+      static_assert(digitalPinHasPCICR(Y2_MIN_PIN), "Y2_MIN_PIN is not interrupt-capable");
       pciSetup(Y2_MIN_PIN);
     #endif
   #endif
@@ -204,7 +204,7 @@ void setup_endstop_interrupts() {
     #if (digitalPinToInterrupt(Z2_MAX_PIN) != NOT_AN_INTERRUPT)
       _ATTACH(Z2_MAX_PIN);
     #else
-      static_assert(digitalPinHasPCICR(Z2_MAX_PIN), "Z2_MAX_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
+      static_assert(digitalPinHasPCICR(Z2_MAX_PIN), "Z2_MAX_PIN is not interrupt-capable");
       pciSetup(Z2_MAX_PIN);
     #endif
   #endif
@@ -212,7 +212,7 @@ void setup_endstop_interrupts() {
     #if (digitalPinToInterrupt(Z2_MIN_PIN) != NOT_AN_INTERRUPT)
       _ATTACH(Z2_MIN_PIN);
     #else
-      static_assert(digitalPinHasPCICR(Z2_MIN_PIN), "Z2_MIN_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
+      static_assert(digitalPinHasPCICR(Z2_MIN_PIN), "Z2_MIN_PIN is not interrupt-capable");
       pciSetup(Z2_MIN_PIN);
     #endif
   #endif
@@ -220,7 +220,7 @@ void setup_endstop_interrupts() {
     #if (digitalPinToInterrupt(Z3_MAX_PIN) != NOT_AN_INTERRUPT)
       _ATTACH(Z3_MAX_PIN);
     #else
-      static_assert(digitalPinHasPCICR(Z3_MAX_PIN), "Z3_MAX_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
+      static_assert(digitalPinHasPCICR(Z3_MAX_PIN), "Z3_MAX_PIN is not interrupt-capable");
       pciSetup(Z3_MAX_PIN);
     #endif
   #endif
@@ -228,7 +228,7 @@ void setup_endstop_interrupts() {
     #if (digitalPinToInterrupt(Z3_MIN_PIN) != NOT_AN_INTERRUPT)
       _ATTACH(Z3_MIN_PIN);
     #else
-      static_assert(digitalPinHasPCICR(Z3_MIN_PIN), "Z3_MIN_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
+      static_assert(digitalPinHasPCICR(Z3_MIN_PIN), "Z3_MIN_PIN is not interrupt-capable");
       pciSetup(Z3_MIN_PIN);
     #endif
   #endif
@@ -236,7 +236,7 @@ void setup_endstop_interrupts() {
     #if (digitalPinToInterrupt(Z4_MAX_PIN) != NOT_AN_INTERRUPT)
       _ATTACH(Z4_MAX_PIN);
     #else
-      static_assert(digitalPinHasPCICR(Z4_MAX_PIN), "Z4_MAX_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
+      static_assert(digitalPinHasPCICR(Z4_MAX_PIN), "Z4_MAX_PIN is not interrupt-capable");
       pciSetup(Z4_MAX_PIN);
     #endif
   #endif
@@ -244,7 +244,7 @@ void setup_endstop_interrupts() {
     #if (digitalPinToInterrupt(Z4_MIN_PIN) != NOT_AN_INTERRUPT)
       _ATTACH(Z4_MIN_PIN);
     #else
-      static_assert(digitalPinHasPCICR(Z4_MIN_PIN), "Z4_MIN_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
+      static_assert(digitalPinHasPCICR(Z4_MIN_PIN), "Z4_MIN_PIN is not interrupt-capable");
       pciSetup(Z4_MIN_PIN);
     #endif
   #endif
@@ -252,7 +252,7 @@ void setup_endstop_interrupts() {
     #if (digitalPinToInterrupt(Z_MIN_PROBE_PIN) != NOT_AN_INTERRUPT)
       _ATTACH(Z_MIN_PROBE_PIN);
     #else
-      static_assert(digitalPinHasPCICR(Z_MIN_PROBE_PIN), "Z_MIN_PROBE_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
+      static_assert(digitalPinHasPCICR(Z_MIN_PROBE_PIN), "Z_MIN_PROBE_PIN is not interrupt-capable");
       pciSetup(Z_MIN_PROBE_PIN);
     #endif
   #endif

Marlin/src/HAL/AVR/fast_pwm.cpp

@@ -185,8 +185,8 @@ void set_pwm_frequency(const pin_t pin, int f_desired) {
         res_temp_phase_correct = rtf / 2;
       }
 
-      LIMIT(res_temp_fast, 1U, size);
+      LIMIT(res_temp_fast, 1u, size);
-      LIMIT(res_temp_phase_correct, 1U, size);
+      LIMIT(res_temp_phase_correct, 1u, size);
       // Calculate frequencies of test prescaler and resolution values
       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),

Marlin/src/HAL/AVR/fastio.h

@@ -285,7 +285,7 @@ enum ClockSource2 : char {
  */
 
 // Determine which harware PWMs are already in use
-#define _PWM_CHK_FAN_B(P) (P == E0_AUTO_FAN_PIN || P == E1_AUTO_FAN_PIN || P == E2_AUTO_FAN_PIN || P == E3_AUTO_FAN_PIN || P == E4_AUTO_FAN_PIN || P == E5_AUTO_FAN_PIN || P == E6_AUTO_FAN_PIN || P == E7_AUTO_FAN_PIN || P == CHAMBER_AUTO_FAN_PIN || P == COOLER_AUTO_FAN_PIN)
+#define _PWM_CHK_FAN_B(P) (P == E0_AUTO_FAN_PIN || P == E1_AUTO_FAN_PIN || P == E2_AUTO_FAN_PIN || P == E3_AUTO_FAN_PIN || P == E4_AUTO_FAN_PIN || P == E5_AUTO_FAN_PIN || P == E6_AUTO_FAN_PIN || P == E7_AUTO_FAN_PIN || P == CHAMBER_AUTO_FAN_PIN)
 #if PIN_EXISTS(CONTROLLER_FAN)
   #define PWM_CHK_FAN_B(P) (_PWM_CHK_FAN_B(P) || P == CONTROLLER_FAN_PIN)
 #else

Marlin/src/HAL/AVR/inc/SanityCheck.h

@@ -56,10 +56,3 @@
 #if BOTH(HAS_TMC_SW_SERIAL, MONITOR_DRIVER_STATUS)
   #error "MONITOR_DRIVER_STATUS causes performance issues when used with SoftwareSerial-connected drivers. Disable MONITOR_DRIVER_STATUS or use hardware serial to continue."
 #endif
-
-/**
- * Postmortem debugging
- */
-#if ENABLED(POSTMORTEM_DEBUGGING)
-  #error "POSTMORTEM_DEBUGGING is not supported on AVR boards."
-#endif

Marlin/src/HAL/AVR/pinsDebug.h

@@ -235,8 +235,8 @@ static void print_is_also_tied() { SERIAL_ECHOPGM(" is also tied to this pin");
 
 inline void com_print(const uint8_t N, const uint8_t Z) {
   const uint8_t *TCCRA = (uint8_t*)TCCR_A(N);
-  SERIAL_ECHOPAIR("    COM", AS_CHAR('0' + N));
+  SERIAL_ECHOPGM("    COM");
-  SERIAL_CHAR(Z);
+  SERIAL_CHAR('0' + N, Z);
   SERIAL_ECHOPAIR(": ", int((*TCCRA >> (6 - Z * 2)) & 0x03));
 }
 
@@ -247,8 +247,8 @@ void timer_prefix(uint8_t T, char L, uint8_t N) {  // T - timer    L - pwm  N -
   uint8_t WGM = (((*TCCRB & _BV(WGM_2)) >> 1) | (*TCCRA & (_BV(WGM_0) | _BV(WGM_1))));
   if (N == 4) WGM |= ((*TCCRB & _BV(WGM_3)) >> 1);
 
-  SERIAL_ECHOPAIR("    TIMER", AS_CHAR(T + '0'));
+  SERIAL_ECHOPGM("    TIMER");
-  SERIAL_CHAR(L);
+  SERIAL_CHAR(T + '0', L);
   SERIAL_ECHO_SP(3);
 
   if (N == 3) {
@@ -262,11 +262,19 @@ void timer_prefix(uint8_t T, char L, uint8_t N) {  // T - timer    L - pwm  N -
   SERIAL_ECHOPAIR("    WGM: ", WGM);
   com_print(T,L);
   SERIAL_ECHOPAIR("    CS: ", (*TCCRB & (_BV(CS_0) | _BV(CS_1) | _BV(CS_2)) ));
-  SERIAL_ECHOPAIR("    TCCR", AS_CHAR(T + '0'), "A: ", *TCCRA);
+
-  SERIAL_ECHOPAIR("    TCCR", AS_CHAR(T + '0'), "B: ", *TCCRB);
+  SERIAL_ECHOPGM("    TCCR");
+  SERIAL_CHAR(T + '0');
+  SERIAL_ECHOPAIR("A: ", *TCCRA);
+
+  SERIAL_ECHOPGM("    TCCR");
+  SERIAL_CHAR(T + '0');
+  SERIAL_ECHOPAIR("B: ", *TCCRB);
 
   const uint8_t *TMSK = (uint8_t*)TIMSK(T);
-  SERIAL_ECHOPAIR("    TIMSK", AS_CHAR(T + '0'), ": ", *TMSK);
+  SERIAL_ECHOPGM("    TIMSK");
+  SERIAL_CHAR(T + '0');
+  SERIAL_ECHOPAIR(": ", *TMSK);
 
   const uint8_t OCIE = L - 'A' + 1;
   if (N == 3) { if (WGM == 0 || WGM == 2 || WGM ==  4 || WGM ==  6) err_is_counter(); }

Marlin/src/HAL/AVR/spi_pins.h

@@ -51,15 +51,15 @@
   #define AVR_SS_PIN   16
 #endif
 
-#ifndef SD_SCK_PIN
+#ifndef SCK_PIN
-  #define SD_SCK_PIN  AVR_SCK_PIN
+  #define SCK_PIN  AVR_SCK_PIN
 #endif
-#ifndef SD_MISO_PIN
+#ifndef MISO_PIN
-  #define SD_MISO_PIN AVR_MISO_PIN
+  #define MISO_PIN AVR_MISO_PIN
 #endif
-#ifndef SD_MOSI_PIN
+#ifndef MOSI_PIN
-  #define SD_MOSI_PIN AVR_MOSI_PIN
+  #define MOSI_PIN AVR_MOSI_PIN
 #endif
-#ifndef SD_SS_PIN
+#ifndef SS_PIN
-  #define SD_SS_PIN   AVR_SS_PIN
+  #define SS_PIN   AVR_SS_PIN
 #endif

Marlin/src/HAL/DUE/DebugMonitor.cpp

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

Marlin/src/HAL/DUE/HAL.cpp

@@ -40,8 +40,6 @@ uint16_t HAL_adc_result;
 // Public functions
 // ------------------------
 
-TERN_(POSTMORTEM_DEBUGGING, extern void install_min_serial());
-
 // HAL initialization task
 void HAL_init() {
   // Initialize the USB stack
@@ -49,7 +47,6 @@ void HAL_init() {
     OUT_WRITE(SDSS, HIGH);  // Try to set SDSS inactive before any other SPI users start up
   #endif
   usb_task_init();
-  TERN_(POSTMORTEM_DEBUGGING, install_min_serial()); // Install the min serial handler
 }
 
 // HAL idle task
@@ -105,18 +102,4 @@ uint16_t HAL_adc_get_result() {
   return HAL_adc_result;
 }
 
-// Forward the default serial ports
-#if ANY_SERIAL_IS(0)
-  DefaultSerial1 MSerial0(false, Serial);
-#endif
-#if ANY_SERIAL_IS(1)
-  DefaultSerial2 MSerial1(false, Serial1);
-#endif
-#if ANY_SERIAL_IS(2)
-  DefaultSerial3 MSerial2(false, Serial2);
-#endif
-#if ANY_SERIAL_IS(3)
-  DefaultSerial4 MSerial3(false, Serial3);
-#endif
-
 #endif // ARDUINO_ARCH_SAM

Marlin/src/HAL/DUE/HAL.h

@@ -36,47 +36,29 @@
 
 #include <stdint.h>
 
-#include "../../core/serial_hook.h"
+#define _MSERIAL(X) Serial##X
-
-typedef ForwardSerial1Class< decltype(Serial) > DefaultSerial1;
-typedef ForwardSerial1Class< decltype(Serial1) > DefaultSerial2;
-typedef ForwardSerial1Class< decltype(Serial2) > DefaultSerial3;
-typedef ForwardSerial1Class< decltype(Serial3) > DefaultSerial4;
-extern DefaultSerial1 MSerial0;
-extern DefaultSerial2 MSerial1;
-extern DefaultSerial3 MSerial2;
-extern DefaultSerial4 MSerial3;
-
-#define _MSERIAL(X) MSerial##X
 #define MSERIAL(X) _MSERIAL(X)
+#define Serial0 Serial
 
-// Define MYSERIAL1/2 before MarlinSerial includes!
+// Define MYSERIAL0/1 before MarlinSerial includes!
 #if SERIAL_PORT == -1 || ENABLED(EMERGENCY_PARSER)
-  #define MYSERIAL1 customizedSerial1
+  #define MYSERIAL0 customizedSerial1
 #elif WITHIN(SERIAL_PORT, 0, 3)
-  #define MYSERIAL1 MSERIAL(SERIAL_PORT)
+  #define MYSERIAL0 MSERIAL(SERIAL_PORT)
 #else
   #error "The required SERIAL_PORT must be from -1 to 3. Please update your configuration."
 #endif
 
 #ifdef SERIAL_PORT_2
   #if SERIAL_PORT_2 == -1 || ENABLED(EMERGENCY_PARSER)
-    #define MYSERIAL2 customizedSerial2
+    #define MYSERIAL1 customizedSerial2
   #elif WITHIN(SERIAL_PORT_2, 0, 3)
-    #define MYSERIAL2 MSERIAL(SERIAL_PORT_2)
+    #define MYSERIAL1 MSERIAL(SERIAL_PORT_2)
   #else
     #error "SERIAL_PORT_2 must be from -1 to 3. Please update your configuration."
   #endif
 #endif
 
-#ifdef MMU2_SERIAL_PORT
-  #if WITHIN(MMU2_SERIAL_PORT, 0, 3)
-    #define MMU2_SERIAL MSERIAL(MMU2_SERIAL_PORT)
-  #else
-    #error "MMU2_SERIAL_PORT must be from 0 to 3. Please update your configuration."
-  #endif
-#endif
-
 #ifdef LCD_SERIAL_PORT
   #if LCD_SERIAL_PORT == -1
     #define LCD_SERIAL lcdSerial
@@ -93,6 +75,16 @@ extern DefaultSerial4 MSerial3;
 // On AVR this is in math.h?
 #define square(x) ((x)*(x))
 
+#ifndef strncpy_P
+  #define strncpy_P(dest, src, num) strncpy((dest), (src), (num))
+#endif
+
+// Fix bug in pgm_read_ptr
+#undef pgm_read_ptr
+#define pgm_read_ptr(addr) (*((void**)(addr)))
+#undef pgm_read_word
+#define pgm_read_word(addr) (*((uint16_t*)(addr)))
+
 typedef int8_t pin_t;
 
 #define SHARED_SERVOS HAS_SERVOS
@@ -113,15 +105,13 @@ void sei();                     // Enable interrupts
 void HAL_clear_reset_source();  // clear reset reason
 uint8_t HAL_get_reset_source(); // get reset reason
 
-inline void HAL_reboot() {}  // reboot the board or restart the bootloader
-
 //
 // ADC
 //
 extern uint16_t HAL_adc_result;     // result of last ADC conversion
 
 #ifndef analogInputToDigitalPin
-  #define analogInputToDigitalPin(p) ((p < 12U) ? (p) + 54U : -1)
+  #define analogInputToDigitalPin(p) ((p < 12u) ? (p) + 54u : -1)
 #endif
 
 #define HAL_ANALOG_SELECT(ch)
@@ -161,16 +151,10 @@ void HAL_init();
 //
 void _delay_ms(const int delay);
 
-#if GCC_VERSION <= 50000
+#pragma GCC diagnostic push
-  #pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-function"
-  #pragma GCC diagnostic ignored "-Wunused-function"
-#endif
-
 int freeMemory();
-
+#pragma GCC diagnostic pop
-#if GCC_VERSION <= 50000
-  #pragma GCC diagnostic pop
-#endif
 
 #ifdef __cplusplus
   extern "C" {

Marlin/src/HAL/DUE/HAL_MinSerial.cpp

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

Marlin/src/HAL/DUE/HAL_SPI.cpp

@@ -69,10 +69,10 @@
 
   // run at ~8 .. ~10Mhz - Tx version (Rx data discarded)
   static uint8_t spiTransferTx0(uint8_t bout) { // using Mode 0
-    uint32_t MOSI_PORT_PLUS30 = ((uint32_t) PORT(SD_MOSI_PIN)) + 0x30;  /* SODR of port */
+    uint32_t MOSI_PORT_PLUS30 = ((uint32_t) PORT(MOSI_PIN)) + 0x30;  /* SODR of port */
-    uint32_t MOSI_MASK = PIN_MASK(SD_MOSI_PIN);
+    uint32_t MOSI_MASK = PIN_MASK(MOSI_PIN);
-    uint32_t SCK_PORT_PLUS30 = ((uint32_t) PORT(SD_SCK_PIN)) + 0x30;    /* SODR of port */
+    uint32_t SCK_PORT_PLUS30 = ((uint32_t) PORT(SCK_PIN)) + 0x30;    /* SODR of port */
-    uint32_t SCK_MASK = PIN_MASK(SD_SCK_PIN);
+    uint32_t SCK_MASK = PIN_MASK(SCK_PIN);
     uint32_t idx = 0;
 
     /* Negate bout, as the assembler requires a negated value */
@@ -154,9 +154,9 @@
   static uint8_t spiTransferRx0(uint8_t) { // using Mode 0
     uint32_t bin = 0;
     uint32_t work = 0;
-    uint32_t BITBAND_MISO_PORT = BITBAND_ADDRESS( ((uint32_t)PORT(SD_MISO_PIN))+0x3C, PIN_SHIFT(SD_MISO_PIN));  /* PDSR of port in bitband area */
+    uint32_t BITBAND_MISO_PORT = BITBAND_ADDRESS( ((uint32_t)PORT(MISO_PIN))+0x3C, PIN_SHIFT(MISO_PIN));  /* PDSR of port in bitband area */
-    uint32_t SCK_PORT_PLUS30 = ((uint32_t) PORT(SD_SCK_PIN)) + 0x30;    /* SODR of port */
+    uint32_t SCK_PORT_PLUS30 = ((uint32_t) PORT(SCK_PIN)) + 0x30;    /* SODR of port */
-    uint32_t SCK_MASK = PIN_MASK(SD_SCK_PIN);
+    uint32_t SCK_MASK = PIN_MASK(SCK_PIN);
 
     /* The software SPI routine */
     __asm__ __volatile__(
@@ -225,36 +225,36 @@
   static uint8_t spiTransfer1(uint8_t b) { // using Mode 0
     int bits = 8;
     do {
-      WRITE(SD_MOSI_PIN, b & 0x80);
+      WRITE(MOSI_PIN, b & 0x80);
       b <<= 1;        // little setup time
 
-      WRITE(SD_SCK_PIN, HIGH);
+      WRITE(SCK_PIN, HIGH);
       DELAY_NS(125);  // 10 cycles @ 84mhz
 
-      b |= (READ(SD_MISO_PIN) != 0);
+      b |= (READ(MISO_PIN) != 0);
 
-      WRITE(SD_SCK_PIN, LOW);
+      WRITE(SCK_PIN, LOW);
       DELAY_NS(125);  // 10 cycles @ 84mhz
     } while (--bits);
     return b;
   }
 
   // all the others
-  static uint32_t spiDelayCyclesX4 = 4 * (F_CPU) / 1000000; // 4µs => 125khz
+  static uint32_t spiDelayCyclesX4 = (F_CPU) / 1000000; // 4µs => 125khz
 
   static uint8_t spiTransferX(uint8_t b) { // using Mode 0
     int bits = 8;
     do {
-      WRITE(SD_MOSI_PIN, b & 0x80);
+      WRITE(MOSI_PIN, b & 0x80);
       b <<= 1; // little setup time
 
-      WRITE(SD_SCK_PIN, HIGH);
+      WRITE(SCK_PIN, HIGH);
-      DELAY_CYCLES(spiDelayCyclesX4);
+      __delay_4cycles(spiDelayCyclesX4);
 
-      b |= (READ(SD_MISO_PIN) != 0);
+      b |= (READ(MISO_PIN) != 0);
 
-      WRITE(SD_SCK_PIN, LOW);
+      WRITE(SCK_PIN, LOW);
-      DELAY_CYCLES(spiDelayCyclesX4);
+      __delay_4cycles(spiDelayCyclesX4);
     } while (--bits);
     return b;
   }
@@ -271,10 +271,10 @@
 
   // Block transfers run at ~8 .. ~10Mhz - Tx version (Rx data discarded)
   static void spiTxBlock0(const uint8_t* ptr, uint32_t todo) {
-    uint32_t MOSI_PORT_PLUS30 = ((uint32_t) PORT(SD_MOSI_PIN)) + 0x30;  /* SODR of port */
+    uint32_t MOSI_PORT_PLUS30 = ((uint32_t) PORT(MOSI_PIN)) + 0x30;  /* SODR of port */
-    uint32_t MOSI_MASK = PIN_MASK(SD_MOSI_PIN);
+    uint32_t MOSI_MASK = PIN_MASK(MOSI_PIN);
-    uint32_t SCK_PORT_PLUS30 = ((uint32_t) PORT(SD_SCK_PIN)) + 0x30;    /* SODR of port */
+    uint32_t SCK_PORT_PLUS30 = ((uint32_t) PORT(SCK_PIN)) + 0x30;    /* SODR of port */
-    uint32_t SCK_MASK = PIN_MASK(SD_SCK_PIN);
+    uint32_t SCK_MASK = PIN_MASK(SCK_PIN);
     uint32_t work = 0;
     uint32_t txval = 0;
 
@@ -352,9 +352,9 @@
   static void spiRxBlock0(uint8_t* ptr, uint32_t todo) {
     uint32_t bin = 0;
     uint32_t work = 0;
-    uint32_t BITBAND_MISO_PORT = BITBAND_ADDRESS( ((uint32_t)PORT(SD_MISO_PIN))+0x3C, PIN_SHIFT(SD_MISO_PIN));  /* PDSR of port in bitband area */
+    uint32_t BITBAND_MISO_PORT = BITBAND_ADDRESS( ((uint32_t)PORT(MISO_PIN))+0x3C, PIN_SHIFT(MISO_PIN));  /* PDSR of port in bitband area */
-    uint32_t SCK_PORT_PLUS30 = ((uint32_t) PORT(SD_SCK_PIN)) + 0x30;    /* SODR of port */
+    uint32_t SCK_PORT_PLUS30 = ((uint32_t) PORT(SCK_PIN)) + 0x30;    /* SODR of port */
-    uint32_t SCK_MASK = PIN_MASK(SD_SCK_PIN);
+    uint32_t SCK_MASK = PIN_MASK(SCK_PIN);
 
     /* The software SPI routine */
     __asm__ __volatile__(
@@ -442,22 +442,22 @@
   static pfnSpiRxBlock spiRxBlock = (pfnSpiRxBlock)spiRxBlockX;
 
   #if MB(ALLIGATOR)
-    #define _SS_WRITE(S) WRITE(SD_SS_PIN, S)
+    #define _SS_WRITE(S) WRITE(SS_PIN, S)
   #else
     #define _SS_WRITE(S) NOOP
   #endif
 
   void spiBegin() {
-    SET_OUTPUT(SD_SS_PIN);
+    SET_OUTPUT(SS_PIN);
     _SS_WRITE(HIGH);
-    SET_OUTPUT(SD_SCK_PIN);
+    SET_OUTPUT(SCK_PIN);
-    SET_INPUT(SD_MISO_PIN);
+    SET_INPUT(MISO_PIN);
-    SET_OUTPUT(SD_MOSI_PIN);
+    SET_OUTPUT(MOSI_PIN);
   }
 
   uint8_t spiRec() {
     _SS_WRITE(LOW);
-    WRITE(SD_MOSI_PIN, HIGH); // Output 1s 1
+    WRITE(MOSI_PIN, HIGH); // Output 1s 1
     uint8_t b = spiTransferRx(0xFF);
     _SS_WRITE(HIGH);
     return b;
@@ -466,7 +466,7 @@
   void spiRead(uint8_t* buf, uint16_t nbyte) {
     if (nbyte) {
       _SS_WRITE(LOW);
-      WRITE(SD_MOSI_PIN, HIGH); // Output 1s 1
+      WRITE(MOSI_PIN, HIGH); // Output 1s 1
       spiRxBlock(buf, nbyte);
       _SS_WRITE(HIGH);
     }
@@ -510,7 +510,7 @@
         spiRxBlock = (pfnSpiRxBlock)spiRxBlockX;
         break;
       default:
-        spiDelayCyclesX4 = ((F_CPU) / 1000000) >> (6 - spiRate) << 2; // spiRate of 2 gives the maximum error with current CPU
+        spiDelayCyclesX4 = ((F_CPU) / 1000000) >> (6 - spiRate);
         spiTransferTx = (pfnSpiTransfer)spiTransferX;
         spiTransferRx = (pfnSpiTransfer)spiTransferX;
         spiTxBlock = (pfnSpiTxBlock)spiTxBlockX;
@@ -519,8 +519,8 @@
     }
 
     _SS_WRITE(HIGH);
-    WRITE(SD_MOSI_PIN, HIGH);
+    WRITE(MOSI_PIN, HIGH);
-    WRITE(SD_SCK_PIN, LOW);
+    WRITE(SCK_PIN, LOW);
   }
 
   /** Begin SPI transaction, set clock, bit order, data mode */
@@ -575,20 +575,20 @@
 
       // Configure SPI pins
       PIO_Configure(
-         g_APinDescription[SD_SCK_PIN].pPort,
+         g_APinDescription[SCK_PIN].pPort,
-         g_APinDescription[SD_SCK_PIN].ulPinType,
+         g_APinDescription[SCK_PIN].ulPinType,
-         g_APinDescription[SD_SCK_PIN].ulPin,
+         g_APinDescription[SCK_PIN].ulPin,
-         g_APinDescription[SD_SCK_PIN].ulPinConfiguration);
+         g_APinDescription[SCK_PIN].ulPinConfiguration);
       PIO_Configure(
-         g_APinDescription[SD_MOSI_PIN].pPort,
+         g_APinDescription[MOSI_PIN].pPort,
-         g_APinDescription[SD_MOSI_PIN].ulPinType,
+         g_APinDescription[MOSI_PIN].ulPinType,
-         g_APinDescription[SD_MOSI_PIN].ulPin,
+         g_APinDescription[MOSI_PIN].ulPin,
-         g_APinDescription[SD_MOSI_PIN].ulPinConfiguration);
+         g_APinDescription[MOSI_PIN].ulPinConfiguration);
       PIO_Configure(
-         g_APinDescription[SD_MISO_PIN].pPort,
+         g_APinDescription[MISO_PIN].pPort,
-         g_APinDescription[SD_MISO_PIN].ulPinType,
+         g_APinDescription[MISO_PIN].ulPinType,
-         g_APinDescription[SD_MISO_PIN].ulPin,
+         g_APinDescription[MISO_PIN].ulPin,
-         g_APinDescription[SD_MISO_PIN].ulPinConfiguration);
+         g_APinDescription[MISO_PIN].ulPinConfiguration);
 
       // set master mode, peripheral select, fault detection
       SPI_Configure(SPI0, ID_SPI0, SPI_MR_MSTR | SPI_MR_MODFDIS | SPI_MR_PS);
@@ -606,7 +606,7 @@
       WRITE(SPI_EEPROM1_CS, HIGH);
       WRITE(SPI_EEPROM2_CS, HIGH);
       WRITE(SPI_FLASH_CS, HIGH);
-      WRITE(SD_SS_PIN, HIGH);
+      WRITE(SS_PIN, HIGH);
 
       OUT_WRITE(SDSS, LOW);
 

Marlin/src/HAL/DUE/MarlinSerial.cpp

@@ -382,7 +382,7 @@ void MarlinSerial<Cfg>::flush() {
 }
 
 template<typename Cfg>
-size_t MarlinSerial<Cfg>::write(const uint8_t c) {
+void MarlinSerial<Cfg>::write(const uint8_t c) {
   _written = true;
 
   if (Cfg::TX_SIZE == 0) {
@@ -400,7 +400,7 @@ size_t MarlinSerial<Cfg>::write(const uint8_t c) {
     // XOFF char at the RX isr, but it is properly handled there
     if (!(HWUART->UART_IMR & UART_IMR_TXRDY) && (HWUART->UART_SR & UART_SR_TXRDY)) {
       HWUART->UART_THR = c;
-      return 1;
+      return;
     }
 
     const uint8_t i = (tx_buffer.head + 1) & (Cfg::TX_SIZE - 1);
@@ -428,7 +428,6 @@ size_t MarlinSerial<Cfg>::write(const uint8_t c) {
     // Enable TX isr - Non atomic, but it will eventually enable TX isr
     HWUART->UART_IER = UART_IER_TXRDY;
   }
-  return 1;
 }
 
 template<typename Cfg>
@@ -474,16 +473,169 @@ void MarlinSerial<Cfg>::flushTX() {
   }
 }
 
+/**
+ * Imports from print.h
+ */
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::print(char c, int base) {
+  print((long)c, base);
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::print(unsigned char b, int base) {
+  print((unsigned long)b, base);
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::print(int n, int base) {
+  print((long)n, base);
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::print(unsigned int n, int base) {
+  print((unsigned long)n, base);
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::print(long n, int base) {
+  if (base == 0) write(n);
+  else if (base == 10) {
+    if (n < 0) { print('-'); n = -n; }
+    printNumber(n, 10);
+  }
+  else
+    printNumber(n, base);
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::print(unsigned long n, int base) {
+  if (base == 0) write(n);
+  else printNumber(n, base);
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::print(double n, int digits) {
+  printFloat(n, digits);
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println() {
+  print('\r');
+  print('\n');
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(const String& s) {
+  print(s);
+  println();
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(const char c[]) {
+  print(c);
+  println();
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(char c, int base) {
+  print(c, base);
+  println();
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(unsigned char b, int base) {
+  print(b, base);
+  println();
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(int n, int base) {
+  print(n, base);
+  println();
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(unsigned int n, int base) {
+  print(n, base);
+  println();
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(long n, int base) {
+  print(n, base);
+  println();
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(unsigned long n, int base) {
+  print(n, base);
+  println();
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::println(double n, int digits) {
+  print(n, digits);
+  println();
+}
+
+// Private Methods
+template<typename Cfg>
+void MarlinSerial<Cfg>::printNumber(unsigned long n, uint8_t base) {
+  if (n) {
+    unsigned char buf[8 * sizeof(long)]; // Enough space for base 2
+    int8_t i = 0;
+    while (n) {
+      buf[i++] = n % base;
+      n /= base;
+    }
+    while (i--)
+      print((char)(buf[i] + (buf[i] < 10 ? '0' : 'A' - 10)));
+  }
+  else
+    print('0');
+}
+
+template<typename Cfg>
+void MarlinSerial<Cfg>::printFloat(double number, uint8_t digits) {
+  // Handle negative numbers
+  if (number < 0.0) {
+    print('-');
+    number = -number;
+  }
+
+  // Round correctly so that print(1.999, 2) prints as "2.00"
+  double rounding = 0.5;
+  LOOP_L_N(i, digits) rounding *= 0.1;
+  number += rounding;
+
+  // Extract the integer part of the number and print it
+  unsigned long int_part = (unsigned long)number;
+  double remainder = number - (double)int_part;
+  print(int_part);
+
+  // Print the decimal point, but only if there are digits beyond
+  if (digits) {
+    print('.');
+    // Extract digits from the remainder one at a time
+    while (digits--) {
+      remainder *= 10.0;
+      int toPrint = int(remainder);
+      print(toPrint);
+      remainder -= toPrint;
+    }
+  }
+}
 
 // If not using the USB port as serial port
 #if SERIAL_PORT >= 0
-  template class MarlinSerial< MarlinSerialCfg<SERIAL_PORT> >;
+  template class MarlinSerial<MarlinSerialCfg<SERIAL_PORT>>;      // Define
-  MSerialT customizedSerial1(MarlinSerialCfg<SERIAL_PORT>::EMERGENCYPARSER);
+  MarlinSerial<MarlinSerialCfg<SERIAL_PORT>> customizedSerial1;   // Instantiate
 #endif
 
 #if defined(SERIAL_PORT_2) && SERIAL_PORT_2 >= 0
-  template class MarlinSerial< MarlinSerialCfg<SERIAL_PORT_2> >;
+  template class MarlinSerial<MarlinSerialCfg<SERIAL_PORT_2>>;    // Define
-  MSerialT2 customizedSerial2(MarlinSerialCfg<SERIAL_PORT_2>::EMERGENCYPARSER);
+  MarlinSerial<MarlinSerialCfg<SERIAL_PORT_2>> customizedSerial2; // Instantiate
 #endif
 
 #endif // ARDUINO_ARCH_SAM

Marlin/src/HAL/DUE/MarlinSerial.h

@@ -30,7 +30,11 @@
 #include <WString.h>
 
 #include "../../inc/MarlinConfigPre.h"
-#include "../../core/serial_hook.h"
+
+#define DEC 10
+#define HEX 16
+#define OCT 8
+#define BIN 2
 
 // Define constants and variables for buffering incoming serial data.  We're
 // using a ring buffer (I think), in which rx_buffer_head is the index of the
@@ -115,7 +119,7 @@ public:
   static int read();
   static void flush();
   static ring_buffer_pos_t available();
-  static size_t write(const uint8_t c);
+  static void write(const uint8_t c);
   static void flushTX();
 
   static inline bool emergency_parser_enabled() { return Cfg::EMERGENCYPARSER; }
@@ -124,6 +128,35 @@ public:
   FORCE_INLINE static uint8_t buffer_overruns() { return Cfg::RX_OVERRUNS ? rx_buffer_overruns : 0; }
   FORCE_INLINE static uint8_t framing_errors() { return Cfg::RX_FRAMING_ERRORS ? rx_framing_errors : 0; }
   FORCE_INLINE static ring_buffer_pos_t rxMaxEnqueued() { return Cfg::MAX_RX_QUEUED ? rx_max_enqueued : 0; }
+
+  FORCE_INLINE static void write(const char* str) { while (*str) write(*str++); }
+  FORCE_INLINE static void write(const uint8_t* buffer, size_t size) { while (size--) write(*buffer++); }
+  FORCE_INLINE static void print(const String& s) { for (int i = 0; i < (int)s.length(); i++) write(s[i]); }
+  FORCE_INLINE static void print(const char* str) { write(str); }
+
+  static void print(char, int = 0);
+  static void print(unsigned char, int = 0);
+  static void print(int, int = DEC);
+  static void print(unsigned int, int = DEC);
+  static void print(long, int = DEC);
+  static void print(unsigned long, int = DEC);
+  static void print(double, int = 2);
+
+  static void println(const String& s);
+  static void println(const char[]);
+  static void println(char, int = 0);
+  static void println(unsigned char, int = 0);
+  static void println(int, int = DEC);
+  static void println(unsigned int, int = DEC);
+  static void println(long, int = DEC);
+  static void println(unsigned long, int = DEC);
+  static void println(double, int = 2);
+  static void println();
+  operator bool() { return true; }
+
+private:
+  static void printNumber(unsigned long, const uint8_t);
+  static void printFloat(double, uint8_t);
 };
 
 // Serial port configuration
@@ -141,11 +174,9 @@ struct MarlinSerialCfg {
 };
 
 #if SERIAL_PORT >= 0
-  typedef Serial1Class< MarlinSerial< MarlinSerialCfg<SERIAL_PORT> > > MSerialT;
+  extern MarlinSerial<MarlinSerialCfg<SERIAL_PORT>> customizedSerial1;
-  extern MSerialT customizedSerial1;
 #endif
 
 #if defined(SERIAL_PORT_2) && SERIAL_PORT_2 >= 0
-  typedef Serial1Class< MarlinSerial< MarlinSerialCfg<SERIAL_PORT_2> > > MSerialT2;
+  extern MarlinSerial<MarlinSerialCfg<SERIAL_PORT_2>> customizedSerial2;
-  extern MSerialT2 customizedSerial2;
 #endif

Marlin/src/HAL/DUE/MarlinSerialUSB.cpp

@@ -33,6 +33,10 @@
 
 #include "MarlinSerialUSB.h"
 
+#if ENABLED(EMERGENCY_PARSER)
+  #include "../../feature/e_parser.h"
+#endif
+
 // Imports from Atmel USB Stack/CDC implementation
 extern "C" {
   bool usb_task_cdc_isenabled();
@@ -46,6 +50,10 @@ extern "C" {
 // Pending character
 static int pending_char = -1;
 
+#if ENABLED(EMERGENCY_PARSER)
+  static EmergencyParser::State emergency_state; // = EP_RESET
+#endif
+
 // Public Methods
 void MarlinSerialUSB::begin(const long) {}
 
@@ -65,7 +73,7 @@ int MarlinSerialUSB::peek() {
 
   pending_char = udi_cdc_getc();
 
-  TERN_(EMERGENCY_PARSER, emergency_parser.update(static_cast<MSerialT*>(this)->emergency_state, (char)pending_char));
+  TERN_(EMERGENCY_PARSER, emergency_parser.update(emergency_state, (char)pending_char));
 
   return pending_char;
 }
@@ -87,27 +95,29 @@ int MarlinSerialUSB::read() {
 
   int c = udi_cdc_getc();
 
-  TERN_(EMERGENCY_PARSER, emergency_parser.update(static_cast<MSerialT*>(this)->emergency_state, (char)c));
+  TERN_(EMERGENCY_PARSER, emergency_parser.update(emergency_state, (char)c));
 
   return c;
 }
 
-int MarlinSerialUSB::available() {
+bool MarlinSerialUSB::available() {
-  if (pending_char > 0) return pending_char;
+    /* If Pending chars */
-  return pending_char == 0 ||
+  return pending_char >= 0 ||
-    // or USB CDC enumerated and configured on the PC side and some bytes where sent to us */
+    /* or USB CDC enumerated and configured on the PC side and some
-    (usb_task_cdc_isenabled() && udi_cdc_is_rx_ready());
+       bytes where sent to us */
+      (usb_task_cdc_isenabled() && udi_cdc_is_rx_ready());
 }
 
 void MarlinSerialUSB::flush() { }
+void MarlinSerialUSB::flushTX() { }
 
-size_t MarlinSerialUSB::write(const uint8_t c) {
+void MarlinSerialUSB::write(const uint8_t c) {
 
   /* Do not even bother sending anything if USB CDC is not enumerated
      or not configured on the PC side or there is no program on the PC
      listening to our messages */
   if (!usb_task_cdc_isenabled() || !usb_task_cdc_dtr_active())
-    return 0;
+    return;
 
   /* Wait until the PC has read the pending to be sent data */
   while (usb_task_cdc_isenabled() &&
@@ -119,20 +129,161 @@ size_t MarlinSerialUSB::write(const uint8_t c) {
      or not configured on the PC side or there is no program on the PC
      listening to our messages at this point */
   if (!usb_task_cdc_isenabled() || !usb_task_cdc_dtr_active())
-    return 0;
+    return;
 
   // Fifo full
   //  udi_cdc_signal_overrun();
   udi_cdc_putc(c);
-  return 1;
+}
+
+/**
+ * Imports from print.h
+ */
+
+void MarlinSerialUSB::print(char c, int base) {
+  print((long)c, base);
+}
+
+void MarlinSerialUSB::print(unsigned char b, int base) {
+  print((unsigned long)b, base);
+}
+
+void MarlinSerialUSB::print(int n, int base) {
+  print((long)n, base);
+}
+
+void MarlinSerialUSB::print(unsigned int n, int base) {
+  print((unsigned long)n, base);
+}
+
+void MarlinSerialUSB::print(long n, int base) {
+  if (base == 0)
+    write(n);
+  else if (base == 10) {
+    if (n < 0) {
+      print('-');
+      n = -n;
+    }
+    printNumber(n, 10);
+  }
+  else
+    printNumber(n, base);
+}
+
+void MarlinSerialUSB::print(unsigned long n, int base) {
+  if (base == 0) write(n);
+  else printNumber(n, base);
+}
+
+void MarlinSerialUSB::print(double n, int digits) {
+  printFloat(n, digits);
+}
+
+void MarlinSerialUSB::println() {
+  print('\r');
+  print('\n');
+}
+
+void MarlinSerialUSB::println(const String& s) {
+  print(s);
+  println();
+}
+
+void MarlinSerialUSB::println(const char c[]) {
+  print(c);
+  println();
+}
+
+void MarlinSerialUSB::println(char c, int base) {
+  print(c, base);
+  println();
+}
+
+void MarlinSerialUSB::println(unsigned char b, int base) {
+  print(b, base);
+  println();
+}
+
+void MarlinSerialUSB::println(int n, int base) {
+  print(n, base);
+  println();
+}
+
+void MarlinSerialUSB::println(unsigned int n, int base) {
+  print(n, base);
+  println();
+}
+
+void MarlinSerialUSB::println(long n, int base) {
+  print(n, base);
+  println();
+}
+
+void MarlinSerialUSB::println(unsigned long n, int base) {
+  print(n, base);
+  println();
+}
+
+void MarlinSerialUSB::println(double n, int digits) {
+  print(n, digits);
+  println();
+}
+
+// Private Methods
+
+void MarlinSerialUSB::printNumber(unsigned long n, uint8_t base) {
+  if (n) {
+    unsigned char buf[8 * sizeof(long)]; // Enough space for base 2
+    int8_t i = 0;
+    while (n) {
+      buf[i++] = n % base;
+      n /= base;
+    }
+    while (i--)
+      print((char)(buf[i] + (buf[i] < 10 ? '0' : 'A' - 10)));
+  }
+  else
+    print('0');
+}
+
+void MarlinSerialUSB::printFloat(double number, uint8_t digits) {
+  // Handle negative numbers
+  if (number < 0.0) {
+    print('-');
+    number = -number;
+  }
+
+  // Round correctly so that print(1.999, 2) prints as "2.00"
+  double rounding = 0.5;
+  LOOP_L_N(i, digits)
+    rounding *= 0.1;
+
+  number += rounding;
+
+  // Extract the integer part of the number and print it
+  unsigned long int_part = (unsigned long)number;
+  double remainder = number - (double)int_part;
+  print(int_part);
+
+  // Print the decimal point, but only if there are digits beyond
+  if (digits) {
+    print('.');
+    // Extract digits from the remainder one at a time
+    while (digits--) {
+      remainder *= 10.0;
+      int toPrint = int(remainder);
+      print(toPrint);
+      remainder -= toPrint;
+    }
+  }
 }
 
 // Preinstantiate
 #if SERIAL_PORT == -1
-  MSerialT customizedSerial1(TERN0(EMERGENCY_PARSER, true));
+  MarlinSerialUSB customizedSerial1;
 #endif
 #if SERIAL_PORT_2 == -1
-  MSerialT customizedSerial2(TERN0(EMERGENCY_PARSER, true));
+  MarlinSerialUSB customizedSerial2;
 #endif
 
 #endif // HAS_USB_SERIAL

Marlin/src/HAL/DUE/MarlinSerialUSB.h

@@ -27,37 +27,73 @@
  */
 
 #include "../../inc/MarlinConfig.h"
+
 #if HAS_USB_SERIAL
 
 #include <WString.h>
-#include "../../core/serial_hook.h"
 
+#define DEC 10
+#define HEX 16
+#define OCT 8
+#define BIN 2
 
-struct MarlinSerialUSB {
+class MarlinSerialUSB {
-  void begin(const long);
+
-  void end();
+public:
-  int peek();
+  MarlinSerialUSB() {};
-  int read();
+  static void begin(const long);
-  void flush();
+  static void end();
-  int available();
+  static int peek();
-  size_t write(const uint8_t c);
+  static int read();
+  static void flush();
+  static void flushTX();
+  static bool available();
+  static void write(const uint8_t c);
 
   #if ENABLED(SERIAL_STATS_DROPPED_RX)
-    FORCE_INLINE uint32_t dropped() { return 0; }
+    FORCE_INLINE static uint32_t dropped() { return 0; }
   #endif
 
   #if ENABLED(SERIAL_STATS_MAX_RX_QUEUED)
-    FORCE_INLINE int rxMaxEnqueued() { return 0; }
+    FORCE_INLINE static int rxMaxEnqueued() { return 0; }
   #endif
+
+  FORCE_INLINE static void write(const char* str) { while (*str) write(*str++); }
+  FORCE_INLINE static void write(const uint8_t* buffer, size_t size) { while (size--) write(*buffer++); }
+  FORCE_INLINE static void print(const String& s) { for (int i = 0; i < (int)s.length(); i++) write(s[i]); }
+  FORCE_INLINE static void print(const char* str) { write(str); }
+
+  static void print(char, int = 0);
+  static void print(unsigned char, int = 0);
+  static void print(int, int = DEC);
+  static void print(unsigned int, int = DEC);
+  static void print(long, int = DEC);
+  static void print(unsigned long, int = DEC);
+  static void print(double, int = 2);
+
+  static void println(const String& s);
+  static void println(const char[]);
+  static void println(char, int = 0);
+  static void println(unsigned char, int = 0);
+  static void println(int, int = DEC);
+  static void println(unsigned int, int = DEC);
+  static void println(long, int = DEC);
+  static void println(unsigned long, int = DEC);
+  static void println(double, int = 2);
+  static void println();
+  operator bool() { return true; }
+
+private:
+  static void printNumber(unsigned long, const uint8_t);
+  static void printFloat(double, uint8_t);
 };
-typedef Serial1Class<MarlinSerialUSB> MSerialT;
 
 #if SERIAL_PORT == -1
-  extern MSerialT customizedSerial1;
+  extern MarlinSerialUSB customizedSerial1;
 #endif
 
 #if SERIAL_PORT_2 == -1
-  extern MSerialT customizedSerial2;
+  extern MarlinSerialUSB customizedSerial2;
 #endif
 
 #endif // HAS_USB_SERIAL

Marlin/src/HAL/DUE/dogm/u8g_com_HAL_DUE_shared_hw_spi.cpp

@@ -64,11 +64,12 @@
 
 #include "../../../MarlinCore.h"
 
-#ifndef LCD_SPI_SPEED
+void spiBegin();
-  #define LCD_SPI_SPEED SPI_QUARTER_SPEED
+void spiInit(uint8_t spiRate);
-#endif
+void spiSend(uint8_t b);
+void spiSend(const uint8_t* buf, size_t n);
 
-#include "../../shared/HAL_SPI.h"
+#include "../../shared/Marduino.h"
 #include "../fastio.h"
 
 void u8g_SetPIOutput_DUE_hw_spi(u8g_t *u8g, uint8_t pin_index) {
@@ -99,7 +100,11 @@ uint8_t u8g_com_HAL_DUE_shared_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_va
 
       spiBegin();
 
-      spiInit(LCD_SPI_SPEED);
+      #ifndef SPI_SPEED
+        #define SPI_SPEED SPI_FULL_SPEED  // use same SPI speed as SD card
+      #endif
+      spiInit(2);
+
       break;
 
     case U8G_COM_MSG_ADDRESS:                     /* define cmd (arg_val = 0) or data mode (arg_val = 1) */

Marlin/src/HAL/DUE/dogm/u8g_com_HAL_DUE_st7920_sw_spi.cpp

@@ -59,7 +59,6 @@
 
 #if ENABLED(U8GLIB_ST7920)
 
-#include "../../../inc/MarlinConfig.h"
 #include "../../shared/Delay.h"
 
 #include <U8glib.h>
@@ -146,7 +145,7 @@ uint8_t u8g_com_HAL_DUE_ST7920_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_va
 }
 
 #if ENABLED(LIGHTWEIGHT_UI)
-  #include "../../../lcd/marlinui.h"
+  #include "../../../lcd/ultralcd.h"
   #include "../../shared/HAL_ST7920.h"
 
   #define ST7920_CS_PIN LCD_PINS_RS

Marlin/src/HAL/DUE/dogm/u8g_com_HAL_DUE_sw_spi.cpp

@@ -59,6 +59,9 @@
 
 #if HAS_MARLINUI_U8GLIB && DISABLED(U8GLIB_ST7920)
 
+#undef SPI_SPEED
+#define SPI_SPEED 2  // About 2 MHz
+
 #include "u8g_com_HAL_DUE_sw_spi_shared.h"
 
 #include "../../shared/Marduino.h"

Marlin/src/HAL/DUE/dogm/u8g_com_HAL_DUE_sw_spi_shared.cpp

@@ -59,7 +59,6 @@
 
 #if HAS_MARLINUI_U8GLIB
 
-#include "../../../inc/MarlinConfig.h"
 #include "../../shared/Delay.h"
 
 #include <U8glib.h>

Marlin/src/HAL/DUE/eeprom_flash.cpp

@@ -60,7 +60,7 @@
 #define EEPROMSize     4096
 #define PagesPerGroup   128
 #define GroupCount        2
-#define PageSize        256U
+#define PageSize        256u
 
  /* Flash storage */
 typedef struct FLASH_SECTOR {
@@ -996,7 +996,7 @@ bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, ui
   return false;
 }
 
-bool PersistentStore::read_data(int &pos, uint8_t *value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
+bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
   do {
     uint8_t c = ee_Read(uint32_t(pos));
     if (writing) *value = c;

Marlin/src/HAL/DUE/eeprom_wired.cpp

@@ -62,7 +62,7 @@ bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, ui
   return false;
 }
 
-bool PersistentStore::read_data(int &pos, uint8_t *value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
+bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
   do {
     uint8_t c = eeprom_read_byte((uint8_t*)pos);
     if (writing) *value = c;

Marlin/src/HAL/DUE/fastio.h

@@ -50,7 +50,7 @@
 #define PWM_PIN(P)              WITHIN(P, 2, 13)
 
 #ifndef MASK
-  #define MASK(PIN) _BV(PIN)
+  #define MASK(PIN) (1 << PIN)
 #endif
 
 /**
@@ -163,9 +163,6 @@
 #define SET_INPUT(IO)        _SET_INPUT(IO)
 // Set pin as input with pullup (wrapper)
 #define SET_INPUT_PULLUP(IO) do{ _SET_INPUT(IO); _PULLUP(IO, HIGH); }while(0)
-// Set pin as input with pulldown (substitution)
-#define SET_INPUT_PULLDOWN   SET_INPUT
-
 // Set pin as output (wrapper) -  reads the pin and sets the output to that value
 #define SET_OUTPUT(IO)       _SET_OUTPUT(IO)
 // Set pin as PWM
@@ -480,7 +477,7 @@
 #define DIO91_PIN 15
 #define DIO91_WPORT PIOB
 
-#ifdef ARDUINO_SAM_ARCHIM
+#if ARDUINO_SAM_ARCHIM
 
   #define DIO92_PIN 11
   #define DIO92_WPORT PIOC

Marlin/src/HAL/DUE/fastio/G2_PWM.cpp

@@ -154,7 +154,7 @@ void Stepper::digipot_init() {
   NVIC_SetPriority(PWM_IRQn, NVIC_EncodePriority(0, 10, 0));  // normal priority for PWM module (can stand some jitter on the Vref signals)
 }
 
-void Stepper::set_digipot_current(const uint8_t driver, const int16_t current) {
+void Stepper::digipot_current(const uint8_t driver, const int16_t current) {
 
   if (!(PWM->PWM_CH_NUM[0].PWM_CPRD == PWM_PERIOD_US)) digipot_init();  // Init PWM system if needed
 

Marlin/src/HAL/DUE/inc/SanityCheck.h

@@ -40,7 +40,7 @@
  * Usually the hardware SPI pins are only available to the LCD. This makes the DUE hard SPI used at the same time
  * as the TMC2130 soft SPI the most common setup.
  */
-#define _IS_HW_SPI(P) (defined(TMC_SW_##P) && (TMC_SW_##P == SD_MOSI_PIN || TMC_SW_##P == SD_MISO_PIN || TMC_SW_##P == SD_SCK_PIN))
+#define _IS_HW_SPI(P) (defined(TMC_SW_##P) && (TMC_SW_##P == MOSI_PIN || TMC_SW_##P == MISO_PIN || TMC_SW_##P == SCK_PIN))
 
 #if ENABLED(SDSUPPORT) && HAS_DRIVER(TMC2130)
   #if ENABLED(TMC_USE_SW_SPI)
@@ -57,5 +57,5 @@
 #endif
 
 #if HAS_TMC_SW_SERIAL
-  #error "TMC220x Software Serial is not supported on the DUE platform."
+  #error "TMC220x Software Serial is not supported on this platform."
 #endif

Marlin/src/HAL/DUE/spi_pins.h

@@ -43,22 +43,22 @@
     #define SPI_PIN         87
     #define SPI_CHAN         1
   #endif
-  #define SD_SCK_PIN        76
+  #define SCK_PIN           76
-  #define SD_MISO_PIN       74
+  #define MISO_PIN          74
-  #define SD_MOSI_PIN       75
+  #define MOSI_PIN          75
 #else
   // defaults
   #define DUE_SOFTWARE_SPI
-  #ifndef SD_SCK_PIN
+  #ifndef SCK_PIN
-    #define SD_SCK_PIN      52
+    #define SCK_PIN           52
   #endif
-  #ifndef SD_MISO_PIN
+  #ifndef MISO_PIN
-    #define SD_MISO_PIN     50
+    #define MISO_PIN          50
   #endif
-  #ifndef SD_MOSI_PIN
+  #ifndef MOSI_PIN
-    #define SD_MOSI_PIN     51
+    #define MOSI_PIN          51
   #endif
 #endif
 
 /* A.28, A.29, B.21, C.26, C.29 */
-#define SD_SS_PIN         SDSS
+#define SS_PIN            SDSS

Marlin/src/HAL/DUE/timers.cpp

@@ -121,7 +121,7 @@ void HAL_timer_disable_interrupt(const uint8_t timer_num) {
 
 // missing from CMSIS: Check if interrupt is enabled or not
 static bool NVIC_GetEnabledIRQ(IRQn_Type IRQn) {
-  return TEST(NVIC->ISER[uint32_t(IRQn) >> 5], uint32_t(IRQn) & 0x1F);
+  return (NVIC->ISER[(uint32_t)(IRQn) >> 5] & (1 << ((uint32_t)(IRQn) & 0x1F))) != 0;
 }
 
 bool HAL_timer_interrupt_enabled(const uint8_t timer_num) {

Marlin/src/HAL/DUE/usb/compiler.h

@@ -609,37 +609,37 @@ typedef struct
 #   define clz(u)              ((u) ? __CLZ(u) : 32)
 #else
 #   define clz(u)              (((u) == 0)          ? 32 : \
-                                ((u) & (1UL << 31)) ?  0 : \
+                                ((u) & (1ul << 31)) ?  0 : \
-                                ((u) & (1UL << 30)) ?  1 : \
+                                ((u) & (1ul << 30)) ?  1 : \
-                                ((u) & (1UL << 29)) ?  2 : \
+                                ((u) & (1ul << 29)) ?  2 : \
-                                ((u) & (1UL << 28)) ?  3 : \
+                                ((u) & (1ul << 28)) ?  3 : \
-                                ((u) & (1UL << 27)) ?  4 : \
+                                ((u) & (1ul << 27)) ?  4 : \
-                                ((u) & (1UL << 26)) ?  5 : \
+                                ((u) & (1ul << 26)) ?  5 : \
-                                ((u) & (1UL << 25)) ?  6 : \
+                                ((u) & (1ul << 25)) ?  6 : \
-                                ((u) & (1UL << 24)) ?  7 : \
+                                ((u) & (1ul << 24)) ?  7 : \
-                                ((u) & (1UL << 23)) ?  8 : \
+                                ((u) & (1ul << 23)) ?  8 : \
-                                ((u) & (1UL << 22)) ?  9 : \
+                                ((u) & (1ul << 22)) ?  9 : \
-                                ((u) & (1UL << 21)) ? 10 : \
+                                ((u) & (1ul << 21)) ? 10 : \
-                                ((u) & (1UL << 20)) ? 11 : \
+                                ((u) & (1ul << 20)) ? 11 : \
-                                ((u) & (1UL << 19)) ? 12 : \
+                                ((u) & (1ul << 19)) ? 12 : \
-                                ((u) & (1UL << 18)) ? 13 : \
+                                ((u) & (1ul << 18)) ? 13 : \
-                                ((u) & (1UL << 17)) ? 14 : \
+                                ((u) & (1ul << 17)) ? 14 : \
-                                ((u) & (1UL << 16)) ? 15 : \
+                                ((u) & (1ul << 16)) ? 15 : \
-                                ((u) & (1UL << 15)) ? 16 : \
+                                ((u) & (1ul << 15)) ? 16 : \
-                                ((u) & (1UL << 14)) ? 17 : \
+                                ((u) & (1ul << 14)) ? 17 : \
-                                ((u) & (1UL << 13)) ? 18 : \
+                                ((u) & (1ul << 13)) ? 18 : \
-                                ((u) & (1UL << 12)) ? 19 : \
+                                ((u) & (1ul << 12)) ? 19 : \
-                                ((u) & (1UL << 11)) ? 20 : \
+                                ((u) & (1ul << 11)) ? 20 : \
-                                ((u) & (1UL << 10)) ? 21 : \
+                                ((u) & (1ul << 10)) ? 21 : \
-                                ((u) & (1UL <<  9)) ? 22 : \
+                                ((u) & (1ul <<  9)) ? 22 : \
-                                ((u) & (1UL <<  8)) ? 23 : \
+                                ((u) & (1ul <<  8)) ? 23 : \
-                                ((u) & (1UL <<  7)) ? 24 : \
+                                ((u) & (1ul <<  7)) ? 24 : \
-                                ((u) & (1UL <<  6)) ? 25 : \
+                                ((u) & (1ul <<  6)) ? 25 : \
-                                ((u) & (1UL <<  5)) ? 26 : \
+                                ((u) & (1ul <<  5)) ? 26 : \
-                                ((u) & (1UL <<  4)) ? 27 : \
+                                ((u) & (1ul <<  4)) ? 27 : \
-                                ((u) & (1UL <<  3)) ? 28 : \
+                                ((u) & (1ul <<  3)) ? 28 : \
-                                ((u) & (1UL <<  2)) ? 29 : \
+                                ((u) & (1ul <<  2)) ? 29 : \
-                                ((u) & (1UL <<  1)) ? 30 : \
+                                ((u) & (1ul <<  1)) ? 30 : \
                                 31)
 #endif
 #endif
@@ -654,38 +654,38 @@ typedef struct
 #if (defined __GNUC__) || (defined __CC_ARM)
 #   define ctz(u)              ((u) ? __builtin_ctz(u) : 32)
 #else
-#   define ctz(u)              ((u) & (1UL <<  0) ?  0 : \
+#   define ctz(u)              ((u) & (1ul <<  0) ?  0 : \
-                                (u) & (1UL <<  1) ?  1 : \
+                                (u) & (1ul <<  1) ?  1 : \
-                                (u) & (1UL <<  2) ?  2 : \
+                                (u) & (1ul <<  2) ?  2 : \
-                                (u) & (1UL <<  3) ?  3 : \
+                                (u) & (1ul <<  3) ?  3 : \
-                                (u) & (1UL <<  4) ?  4 : \
+                                (u) & (1ul <<  4) ?  4 : \
-                                (u) & (1UL <<  5) ?  5 : \
+                                (u) & (1ul <<  5) ?  5 : \
-                                (u) & (1UL <<  6) ?  6 : \
+                                (u) & (1ul <<  6) ?  6 : \
-                                (u) & (1UL <<  7) ?  7 : \
+                                (u) & (1ul <<  7) ?  7 : \
-                                (u) & (1UL <<  8) ?  8 : \
+                                (u) & (1ul <<  8) ?  8 : \
-                                (u) & (1UL <<  9) ?  9 : \
+                                (u) & (1ul <<  9) ?  9 : \
-                                (u) & (1UL << 10) ? 10 : \
+                                (u) & (1ul << 10) ? 10 : \
-                                (u) & (1UL << 11) ? 11 : \
+                                (u) & (1ul << 11) ? 11 : \
-                                (u) & (1UL << 12) ? 12 : \
+                                (u) & (1ul << 12) ? 12 : \
-                                (u) & (1UL << 13) ? 13 : \
+                                (u) & (1ul << 13) ? 13 : \
-                                (u) & (1UL << 14) ? 14 : \
+                                (u) & (1ul << 14) ? 14 : \
-                                (u) & (1UL << 15) ? 15 : \
+                                (u) & (1ul << 15) ? 15 : \
-                                (u) & (1UL << 16) ? 16 : \
+                                (u) & (1ul << 16) ? 16 : \
-                                (u) & (1UL << 17) ? 17 : \
+                                (u) & (1ul << 17) ? 17 : \
-                                (u) & (1UL << 18) ? 18 : \
+                                (u) & (1ul << 18) ? 18 : \
-                                (u) & (1UL << 19) ? 19 : \
+                                (u) & (1ul << 19) ? 19 : \
-                                (u) & (1UL << 20) ? 20 : \
+                                (u) & (1ul << 20) ? 20 : \
-                                (u) & (1UL << 21) ? 21 : \
+                                (u) & (1ul << 21) ? 21 : \
-                                (u) & (1UL << 22) ? 22 : \
+                                (u) & (1ul << 22) ? 22 : \
-                                (u) & (1UL << 23) ? 23 : \
+                                (u) & (1ul << 23) ? 23 : \
-                                (u) & (1UL << 24) ? 24 : \
+                                (u) & (1ul << 24) ? 24 : \
-                                (u) & (1UL << 25) ? 25 : \
+                                (u) & (1ul << 25) ? 25 : \
-                                (u) & (1UL << 26) ? 26 : \
+                                (u) & (1ul << 26) ? 26 : \
-                                (u) & (1UL << 27) ? 27 : \
+                                (u) & (1ul << 27) ? 27 : \
-                                (u) & (1UL << 28) ? 28 : \
+                                (u) & (1ul << 28) ? 28 : \
-                                (u) & (1UL << 29) ? 29 : \
+                                (u) & (1ul << 29) ? 29 : \
-                                (u) & (1UL << 30) ? 30 : \
+                                (u) & (1ul << 30) ? 30 : \
-                                (u) & (1UL << 31) ? 31 : \
+                                (u) & (1ul << 31) ? 31 : \
                                 32)
 #endif
 #endif

Marlin/src/HAL/DUE/usb/sd_mmc_spi_mem.cpp

@@ -68,7 +68,7 @@ Ctrl_status sd_mmc_spi_usb_read_10(uint32_t addr, uint16_t nb_sector) {
   {
     char buffer[80];
     sprintf_P(buffer, PSTR("SDRD: %d @ 0x%08x\n"), nb_sector, addr);
-    PORT_REDIRECT(SERIAL_PORTMASK(0));
+    PORT_REDIRECT(0);
     SERIAL_ECHO(buffer);
   }
   #endif
@@ -84,7 +84,7 @@ Ctrl_status sd_mmc_spi_usb_read_10(uint32_t addr, uint16_t nb_sector) {
     card.getSd2Card().readData(sector_buf);
 
     // RAM -> USB
-    if (!udi_msc_trans_block(true, sector_buf, SD_MMC_BLOCK_SIZE, nullptr)) {
+    if (!udi_msc_trans_block(true, sector_buf, SD_MMC_BLOCK_SIZE, NULL)) {
       card.getSd2Card().readStop();
       return CTRL_FAIL;
     }
@@ -108,7 +108,7 @@ Ctrl_status sd_mmc_spi_usb_write_10(uint32_t addr, uint16_t nb_sector) {
   {
     char buffer[80];
     sprintf_P(buffer, PSTR("SDWR: %d @ 0x%08x\n"), nb_sector, addr);
-    PORT_REDIRECT(SERIAL_PORTMASK(0));
+    PORT_REDIRECT(0);
     SERIAL_ECHO(buffer);
   }
   #endif
@@ -120,7 +120,7 @@ Ctrl_status sd_mmc_spi_usb_write_10(uint32_t addr, uint16_t nb_sector) {
   while (nb_sector--) {
 
     // USB -> RAM
-    if (!udi_msc_trans_block(false, sector_buf, SD_MMC_BLOCK_SIZE, nullptr)) {
+    if (!udi_msc_trans_block(false, sector_buf, SD_MMC_BLOCK_SIZE, NULL)) {
       card.getSd2Card().writeStop();
       return CTRL_FAIL;
     }

Marlin/src/HAL/DUE/watchdog.cpp

@@ -36,7 +36,7 @@ void watchdogSetup() {
   #if ENABLED(USE_WATCHDOG)
 
     // 4 seconds timeout
-    uint32_t timeout = TERN(WATCHDOG_DURATION_8S, 8000, 4000);
+    uint32_t timeout = 4000;
 
     // Calculate timeout value in WDT counter ticks: This assumes
     // the slow clock is running at 32.768 kHz watchdog

Marlin/src/HAL/ESP32/FlushableHardwareSerial.cpp

@@ -20,10 +20,14 @@
  *
  */
 
-#ifdef ARDUINO_ARCH_ESP32
-
 #include "FlushableHardwareSerial.h"
 
-Serial1Class<FlushableHardwareSerial> flushableSerial(false, 0);
+#ifdef ARDUINO_ARCH_ESP32
 
-#endif
+FlushableHardwareSerial::FlushableHardwareSerial(int uart_nr)
+    : HardwareSerial(uart_nr)
+{}
+
+FlushableHardwareSerial flushableSerial(0);
+
+#endif // ARDUINO_ARCH_ESP32

Marlin/src/HAL/ESP32/FlushableHardwareSerial.h

@@ -21,14 +21,17 @@
  */
 #pragma once
 
-#include <HardwareSerial.h>
+#ifdef ARDUINO_ARCH_ESP32
 
-#include "../shared/Marduino.h"
+#include <HardwareSerial.h>
-#include "../../core/serial_hook.h"
 
 class FlushableHardwareSerial : public HardwareSerial {
 public:
-  FlushableHardwareSerial(int uart_nr) : HardwareSerial(uart_nr) {}
+  FlushableHardwareSerial(int uart_nr);
+
+  inline void flushTX() { /* No need to flush the hardware serial, but defined here for compatibility. */ }
 };
 
-extern Serial1Class<FlushableHardwareSerial> flushableSerial;
+extern FlushableHardwareSerial flushableSerial;
+
+#endif // ARDUINO_ARCH_ESP32

Marlin/src/HAL/ESP32/HAL.cpp

@@ -40,10 +40,6 @@
   #endif
 #endif
 
-#if ENABLED(ESP3D_WIFISUPPORT)
-  DefaultSerial1 MSerial0(false, Serial2Socket);
-#endif
-
 // ------------------------
 // Externs
 // ------------------------
@@ -90,6 +86,8 @@ volatile int numPWMUsed = 0,
 
 #endif
 
+void HAL_init() { i2s_init(); }
+
 void HAL_init_board() {
 
   #if ENABLED(ESP3D_WIFISUPPORT)
@@ -124,10 +122,6 @@ void HAL_init_board() {
     #endif
   #endif
 
-  // Initialize the i2s peripheral only if the I2S stepper stream is enabled.
-  // The following initialization is performed after Serial1 and Serial2 are defined as
-  // their native pins might conflict with the i2s stream even when they are remapped.
-  TERN_(I2S_STEPPER_STREAM, i2s_init());
 }
 
 void HAL_idletask() {
@@ -185,7 +179,6 @@ void HAL_adc_init() {
   TERN_(HAS_TEMP_ADC_7, adc3_set_attenuation(get_channel(TEMP_7_PIN), ADC_ATTEN_11db));
   TERN_(HAS_HEATED_BED, adc1_set_attenuation(get_channel(TEMP_BED_PIN), ADC_ATTEN_11db));
   TERN_(HAS_TEMP_CHAMBER, adc1_set_attenuation(get_channel(TEMP_CHAMBER_PIN), ADC_ATTEN_11db));
-  TERN_(HAS_TEMP_COOLER, adc1_set_attenuation(get_channel(TEMP_COOLER_PIN), ADC_ATTEN_11db));
   TERN_(FILAMENT_WIDTH_SENSOR, adc1_set_attenuation(get_channel(FILWIDTH_PIN), ADC_ATTEN_11db));
 
   // Note that adc2 is shared with the WiFi module, which has higher priority, so the conversion may fail.

Marlin/src/HAL/ESP32/HAL.h

@@ -51,15 +51,13 @@
 
 extern portMUX_TYPE spinlock;
 
-#define MYSERIAL1 flushableSerial
+#define MYSERIAL0 flushableSerial
 
 #if EITHER(WIFISUPPORT, ESP3D_WIFISUPPORT)
   #if ENABLED(ESP3D_WIFISUPPORT)
-    typedef ForwardSerial1Class< decltype(Serial2Socket) > DefaultSerial1;
+    #define MYSERIAL1 Serial2Socket
-    extern DefaultSerial1 MSerial0;
-    #define MYSERIAL2 MSerial0
   #else
-    #define MYSERIAL2 webSocketSerial
+    #define MYSERIAL1 webSocketSerial
   #endif
 #endif
 
@@ -69,6 +67,10 @@ extern portMUX_TYPE spinlock;
 #define ENABLE_ISRS()  if (spinlock.owner != portMUX_FREE_VAL) portEXIT_CRITICAL(&spinlock)
 #define DISABLE_ISRS() portENTER_CRITICAL(&spinlock)
 
+// Fix bug in pgm_read_ptr
+#undef pgm_read_ptr
+#define pgm_read_ptr(addr) (*(addr))
+
 // ------------------------
 // Types
 // ------------------------
@@ -88,33 +90,18 @@ extern uint16_t HAL_adc_result;
 // Public functions
 // ------------------------
 
-//
-// Tone
-//
-void toneInit();
-void tone(const pin_t _pin, const unsigned int frequency, const unsigned long duration=0);
-void noTone(const pin_t _pin);
-
 // clear reset reason
 void HAL_clear_reset_source();
 
 // reset reason
 uint8_t HAL_get_reset_source();
 
-inline void HAL_reboot() {}  // reboot the board or restart the bootloader
-
 void _delay_ms(int delay);
 
-#if GCC_VERSION <= 50000
+#pragma GCC diagnostic push
-  #pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-function"
-  #pragma GCC diagnostic ignored "-Wunused-function"
-#endif
-
 int freeMemory();
-
+#pragma GCC diagnostic pop
-#if GCC_VERSION <= 50000
-  #pragma GCC diagnostic pop
-#endif
 
 void analogWrite(pin_t pin, int value);
 
@@ -139,7 +126,7 @@ void HAL_adc_start_conversion(const uint8_t adc_pin);
 #define HAL_IDLETASK 1
 #define BOARD_INIT() HAL_init_board();
 void HAL_idletask();
-inline void HAL_init() {}
+void HAL_init();
 void HAL_init_board();
 
 //
@@ -168,14 +155,14 @@ FORCE_INLINE static void DELAY_CYCLES(uint32_t x) {
 
   if (stop >= start) {
     // no overflow, so only loop while in between start and stop:
-    // 0x00000000 -----------------start****stop-- 0xFFFFFFFF
+    // 0x00000000 -----------------start****stop-- 0xffffffff
     while (ccount >= start && ccount < stop) {
       __asm__ __volatile__ ( "rsr     %0, ccount" : "=a" (ccount) );
     }
   }
   else {
     // stop did overflow, so only loop while outside of stop and start:
-    // 0x00000000 **stop-------------------start** 0xFFFFFFFF
+    // 0x00000000 **stop-------------------start** 0xffffffff
     while (ccount >= start || ccount < stop) {
       __asm__ __volatile__ ( "rsr     %0, ccount" : "=a" (ccount) );
     }

Marlin/src/HAL/ESP32/HAL_SPI.cpp

@@ -53,11 +53,11 @@ static SPISettings spiConfig;
 // ------------------------
 
 void spiBegin() {
-  #if !PIN_EXISTS(SD_SS)
+  #if !PIN_EXISTS(SS)
-    #error "SD_SS_PIN not defined!"
+    #error "SS_PIN not defined!"
   #endif
 
-  OUT_WRITE(SD_SS_PIN, HIGH);
+  OUT_WRITE(SS_PIN, HIGH);
 }
 
 void spiInit(uint8_t spiRate) {

Marlin/src/HAL/ESP32/Servo.h

@@ -30,7 +30,7 @@ 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 = ((1 << 16) - 1), // 65535
                    CHANNEL_MAX_NUM = 16;
 
 public:

Marlin/src/HAL/ESP32/WebSocketSerial.cpp

@@ -29,7 +29,7 @@
 #include "wifi.h"
 #include <ESPAsyncWebServer.h>
 
-MSerialT webSocketSerial(false);
+WebSocketSerial webSocketSerial;
 AsyncWebSocket ws("/ws"); // TODO Move inside the class.
 
 // RingBuffer impl
@@ -144,5 +144,9 @@ size_t WebSocketSerial::write(const uint8_t* buffer, size_t size) {
   return written;
 }
 
+void WebSocketSerial::flushTX() {
+  // No need to do anything as there's no benefit to sending partial lines over the websocket connection.
+}
+
 #endif // WIFISUPPORT
 #endif // ARDUINO_ARCH_ESP32

Marlin/src/HAL/ESP32/WebSocketSerial.h

@@ -22,7 +22,6 @@
 #pragma once
 
 #include "../../inc/MarlinConfig.h"
-#include "../../core/serial_hook.h"
 
 #include <Stream.h>
 
@@ -69,9 +68,12 @@ public:
   int peek();
   int read();
   void flush();
+  void flushTX();
   size_t write(const uint8_t c);
   size_t write(const uint8_t* buffer, size_t size);
 
+  operator bool() { return true; }
+
   #if ENABLED(SERIAL_STATS_DROPPED_RX)
     FORCE_INLINE uint32_t dropped() { return 0; }
   #endif
@@ -81,5 +83,4 @@ public:
   #endif
 };
 
-typedef Serial1Class<WebSocketSerial> MSerialT;
+extern WebSocketSerial webSocketSerial;
-extern MSerialT webSocketSerial;

Marlin/src/HAL/ESP32/eeprom.cpp

@@ -44,7 +44,7 @@ bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, ui
   return false;
 }
 
-bool PersistentStore::read_data(int &pos, uint8_t *value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
+bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
   for (size_t i = 0; i < size; i++) {
     uint8_t c = EEPROM.read(pos++);
     if (writing) value[i] = c;

Marlin/src/HAL/ESP32/fastio.h

@@ -52,9 +52,6 @@
 // Set pin as input with pullup wrapper
 #define SET_INPUT_PULLUP(IO)    do{ _SET_INPUT(IO); _PULLUP(IO, HIGH); }while(0)
 
-// Set pin as input with pulldown (substitution)
-#define SET_INPUT_PULLDOWN      SET_INPUT
-
 // Set pin as output wrapper
 #define SET_OUTPUT(IO)          do{ _SET_OUTPUT(IO); }while(0)
 

Marlin/src/HAL/ESP32/i2s.cpp

@@ -184,7 +184,7 @@ int i2s_init() {
 
   // Allocate the array of pointers to the buffers
   dma.buffers = (uint32_t **)malloc(sizeof(uint32_t*) * DMA_BUF_COUNT);
-  if (!dma.buffers) return -1;
+  if (dma.buffers == nullptr) return -1;
 
   // Allocate each buffer that can be used by the DMA controller
   for (int buf_idx = 0; buf_idx < DMA_BUF_COUNT; buf_idx++) {
@@ -194,7 +194,7 @@ int i2s_init() {
 
   // Allocate the array of DMA descriptors
   dma.desc = (lldesc_t**) malloc(sizeof(lldesc_t*) * DMA_BUF_COUNT);
-  if (!dma.desc) return -1;
+  if (dma.desc == nullptr) return -1;
 
   // Allocate each DMA descriptor that will be used by the DMA controller
   for (int buf_idx = 0; buf_idx < DMA_BUF_COUNT; buf_idx++) {

Marlin/src/HAL/ESP32/inc/SanityCheck.h

@@ -30,13 +30,9 @@
 #endif
 
 #if HAS_TMC_SW_SERIAL
-  #error "TMC220x Software Serial is not supported on ESP32."
+  #error "TMC220x Software Serial is not supported on this platform."
 #endif
 
 #if BOTH(WIFISUPPORT, ESP3D_WIFISUPPORT)
   #error "Only enable one WiFi option, either WIFISUPPORT or ESP3D_WIFISUPPORT."
 #endif
-
-#if ENABLED(POSTMORTEM_DEBUGGING)
-  #error "POSTMORTEM_DEBUGGING is not yet supported on ESP32."
-#endif

Marlin/src/HAL/ESP32/spi_pins.h

@@ -18,7 +18,7 @@
  */
 #pragma once
 
-#define SD_SS_PIN   SDSS
+#define SS_PIN   SDSS
-#define SD_SCK_PIN  18
+#define SCK_PIN  18
-#define SD_MISO_PIN 19
+#define MISO_PIN 19
-#define SD_MOSI_PIN 23
+#define MOSI_PIN 23

Marlin/src/HAL/ESP32/timers.cpp

@@ -45,7 +45,7 @@ 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
-  { TIMER_GROUP_1, TIMER_1,    TONE_TIMER_PRESCALE, toneTC_Handler }, // 3 - Tone
+  { TIMER_GROUP_1, TIMER_1,                      1, nullptr }, // 3
 };
 
 // ------------------------

Marlin/src/HAL/ESP32/timers.h

@@ -24,9 +24,15 @@
 #include <stdint.h>
 #include <driver/timer.h>
 
+// Includes needed to get I2S_STEPPER_STREAM. Note that pins.h
+// is included in case this header is being included early.
+#include "../../inc/MarlinConfig.h"
+#include "../../pins/pins.h"
+
 // ------------------------
 // Defines
 // ------------------------
+//
 #define FORCE_INLINE __attribute__((always_inline)) inline
 
 typedef uint64_t hal_timer_t;
@@ -44,9 +50,6 @@ typedef uint64_t hal_timer_t;
 #ifndef PWM_TIMER_NUM
   #define PWM_TIMER_NUM         2  // index of timer to use for PWM outputs
 #endif
-#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
 
@@ -62,8 +65,6 @@ typedef uint64_t hal_timer_t;
 
 #define STEP_TIMER_MIN_INTERVAL   8 // minimum time in µs between stepper interrupts
 
-#define TONE_TIMER_PRESCALE    1000 // Arbitrary value, no idea what i'm doing here
-
 #define TEMP_TIMER_PRESCALE    1000 // prescaler for setting Temp timer, 72Khz
 #define TEMP_TIMER_FREQUENCY   1000 // temperature interrupt frequency
 
@@ -95,16 +96,10 @@ typedef uint64_t hal_timer_t;
 #ifndef HAL_PWM_TIMER_ISR
   #define HAL_PWM_TIMER_ISR() extern "C" void pwmTC_Handler()
 #endif
-#ifndef HAL_TONE_TIMER_ISR
-  #define HAL_TONE_TIMER_ISR() extern "C" void toneTC_Handler()
-#endif
 
-extern "C" {
+extern "C" void tempTC_Handler();
-  void tempTC_Handler();
+extern "C" void stepTC_Handler();
-  void stepTC_Handler();
+extern "C" void pwmTC_Handler();
-  void pwmTC_Handler();
-  void toneTC_Handler();
-}
 
 // ------------------------
 // Types

Marlin/src/HAL/ESP32/watchdog.cpp

@@ -25,8 +25,6 @@
 
 #if ENABLED(USE_WATCHDOG)
 
-#define WDT_TIMEOUT_US TERN(WATCHDOG_DURATION_8S, 8000000, 4000000) // 4 or 8 second timeout
-
 #include "watchdog.h"
 
 void watchdogSetup() {

Marlin/src/HAL/HAL.h

@@ -23,16 +23,18 @@
 
 #include "platforms.h"
 
-#ifndef GCC_VERSION
-  #define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
-#endif
-
 #include HAL_PATH(.,HAL.h)
 
+#ifdef SERIAL_PORT_2
+  #define NUM_SERIAL 2
+#else
+  #define NUM_SERIAL 1
+#endif
+
 #define HAL_ADC_RANGE _BV(HAL_ADC_RESOLUTION)
 
 #ifndef I2C_ADDRESS
-  #define I2C_ADDRESS(A) uint8_t(A)
+  #define I2C_ADDRESS(A) (A)
 #endif
 
 // Needed for AVR sprintf_P PROGMEM extension

Marlin/src/HAL/LINUX/HAL.cpp

@@ -24,16 +24,21 @@
 #include "../../inc/MarlinConfig.h"
 #include "../shared/Delay.h"
 
-MSerialT usb_serial(TERN0(EMERGENCY_PARSER, true));
+HalSerial usb_serial;
 
 // U8glib required functions
-extern "C" {
+extern "C" void u8g_xMicroDelay(uint16_t val) {
-  void u8g_xMicroDelay(uint16_t val) { DELAY_US(val); }
+  DELAY_US(val);
-  void u8g_MicroDelay()              { u8g_xMicroDelay(1); }
+}
-  void u8g_10MicroDelay()            { u8g_xMicroDelay(10); }
+extern "C" void u8g_MicroDelay() {
-  void u8g_Delay(uint16_t val)       { delay(val); }
+  u8g_xMicroDelay(1);
+}
+extern "C" void u8g_10MicroDelay() {
+  u8g_xMicroDelay(10);
+}
+extern "C" void u8g_Delay(uint16_t val) {
+  delay(val);
 }
-
 //************************//
 
 // return free heap space

Marlin/src/HAL/LINUX/HAL.h

@@ -23,7 +23,7 @@
 
 #define CPU_32_BIT
 
-#define F_CPU 100000000UL
+#define F_CPU 100000000
 #define SystemCoreClock F_CPU
 #include <iostream>
 #include <stdint.h>
@@ -60,8 +60,8 @@ uint8_t _getc();
 
 #define SHARED_SERVOS HAS_SERVOS
 
-extern MSerialT usb_serial;
+extern HalSerial usb_serial;
-#define MYSERIAL1 usb_serial
+#define MYSERIAL0 usb_serial
 
 #define ST7920_DELAY_1 DELAY_NS(600)
 #define ST7920_DELAY_2 DELAY_NS(750)
@@ -79,16 +79,10 @@ extern MSerialT usb_serial;
 inline void HAL_init() {}
 
 // Utility functions
-#if GCC_VERSION <= 50000
+#pragma GCC diagnostic push
-  #pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-function"
-  #pragma GCC diagnostic ignored "-Wunused-function"
-#endif
-
 int freeMemory();
-
+#pragma GCC diagnostic pop
-#if GCC_VERSION <= 50000
-  #pragma GCC diagnostic pop
-#endif
 
 // ADC
 #define HAL_ADC_VREF           5.0
@@ -107,9 +101,12 @@ uint16_t HAL_adc_get_result();
 inline void HAL_clear_reset_source(void) {}
 inline uint8_t HAL_get_reset_source(void) { return RST_POWER_ON; }
 
-inline void HAL_reboot() {}  // reboot the board or restart the bootloader
-
 /* ---------------- Delay in cycles */
 FORCE_INLINE static void DELAY_CYCLES(uint64_t x) {
   Clock::delayCycles(x);
 }
+
+// Add strcmp_P if missing
+#ifndef strcmp_P
+  #define strcmp_P(a, b) strcmp((a), (b))
+#endif

Marlin/src/HAL/LINUX/eeprom.cpp

@@ -40,7 +40,7 @@ size_t PersistentStore::capacity() { return MARLIN_EEPROM_SIZE; }
 bool PersistentStore::access_start() {
   const char eeprom_erase_value = 0xFF;
   FILE * eeprom_file = fopen(filename, "rb");
-  if (!eeprom_file) return false;
+  if (eeprom_file == nullptr) return false;
 
   fseek(eeprom_file, 0L, SEEK_END);
   std::size_t file_size = ftell(eeprom_file);
@@ -59,7 +59,7 @@ bool PersistentStore::access_start() {
 
 bool PersistentStore::access_finish() {
   FILE * eeprom_file = fopen(filename, "wb");
-  if (!eeprom_file) return false;
+  if (eeprom_file == nullptr) return false;
   fwrite(buffer, sizeof(uint8_t), sizeof(buffer), eeprom_file);
   fclose(eeprom_file);
   return true;
@@ -78,7 +78,7 @@ bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, ui
   return (bytes_written != size);  // return true for any error
 }
 
-bool PersistentStore::read_data(int &pos, uint8_t *value, const size_t size, uint16_t *crc, const bool writing/*=true*/) {
+bool PersistentStore::read_data(int &pos, uint8_t* value, const size_t size, uint16_t *crc, const bool writing/*=true*/) {
   std::size_t bytes_read = 0;
   if (writing) {
     for (std::size_t i = 0; i < size; i++) {

Marlin/src/HAL/LINUX/hardware/Gpio.h

@@ -86,10 +86,10 @@ public:
     GpioEvent::Type evt_type = value > 1 ? GpioEvent::SET_VALUE : value > pin_map[pin].value ? GpioEvent::RISE : value < pin_map[pin].value ? GpioEvent::FALL : GpioEvent::NOP;
     pin_map[pin].value = value;
     GpioEvent evt(Clock::nanos(), pin, evt_type);
-    if (pin_map[pin].cb) {
+    if (pin_map[pin].cb != nullptr) {
       pin_map[pin].cb->interrupt(evt);
     }
-    if (Gpio::logger) Gpio::logger->log(evt);
+    if (Gpio::logger != nullptr) Gpio::logger->log(evt);
   }
 
   static uint16_t get(pin_type pin) {
@@ -105,8 +105,8 @@ public:
     if (!valid_pin(pin)) return;
     pin_map[pin].mode = value;
     GpioEvent evt(Clock::nanos(), pin, GpioEvent::Type::SETM);
-    if (pin_map[pin].cb) pin_map[pin].cb->interrupt(evt);
+    if (pin_map[pin].cb != nullptr) pin_map[pin].cb->interrupt(evt);
-    if (Gpio::logger) Gpio::logger->log(evt);
+    if (Gpio::logger != nullptr) Gpio::logger->log(evt);
   }
 
   static uint8_t getMode(pin_type pin) {
@@ -118,8 +118,8 @@ public:
     if (!valid_pin(pin)) return;
     pin_map[pin].dir = value;
     GpioEvent evt(Clock::nanos(), pin, GpioEvent::Type::SETD);
-    if (pin_map[pin].cb) pin_map[pin].cb->interrupt(evt);
+    if (pin_map[pin].cb != nullptr) pin_map[pin].cb->interrupt(evt);
-    if (Gpio::logger) Gpio::logger->log(evt);
+    if (Gpio::logger != nullptr) Gpio::logger->log(evt);
   }
 
   static uint8_t getDir(pin_type pin) {

Marlin/src/HAL/LINUX/inc/SanityCheck.h

@@ -35,9 +35,5 @@
 #endif
 
 #if HAS_TMC_SW_SERIAL
-  #error "TMC220x Software Serial is not supported on LINUX."
+  #error "TMC220x Software Serial is not supported on this platform."
-#endif
-
-#if ENABLED(POSTMORTEM_DEBUGGING)
-  #error "POSTMORTEM_DEBUGGING is not yet supported on LINUX."
 #endif

Marlin/src/HAL/LINUX/include/Arduino.h

@@ -67,14 +67,34 @@ void cli(); // Disable
 void sei(); // Enable
 void attachInterrupt(uint32_t pin, void (*callback)(), uint32_t mode);
 void detachInterrupt(uint32_t pin);
+extern "C" void GpioEnableInt(uint32_t port, uint32_t pin, uint32_t mode);
+extern "C" void GpioDisableInt(uint32_t port, uint32_t pin);
 
-extern "C" {
+// Program Memory
-  void GpioEnableInt(uint32_t port, uint32_t pin, uint32_t mode);
+#define pgm_read_ptr(addr)        (*((void**)(addr)))
-  void GpioDisableInt(uint32_t port, uint32_t pin);
+#define pgm_read_byte_near(addr)  (*((uint8_t*)(addr)))
-}
+#define pgm_read_float_near(addr) (*((float*)(addr)))
+#define pgm_read_word_near(addr)  (*((uint16_t*)(addr)))
+#define pgm_read_dword_near(addr) (*((uint32_t*)(addr)))
+#define pgm_read_byte(addr)       pgm_read_byte_near(addr)
+#define pgm_read_float(addr)      pgm_read_float_near(addr)
+#define pgm_read_word(addr)       pgm_read_word_near(addr)
+#define pgm_read_dword(addr)      pgm_read_dword_near(addr)
+
+using std::memcpy;
+#define memcpy_P memcpy
+#define sprintf_P sprintf
+#define strstr_P strstr
+#define strncpy_P strncpy
+#define vsnprintf_P vsnprintf
+#define strcpy_P strcpy
+#define snprintf_P snprintf
+#define strlen_P strlen
 
 // Time functions
-extern "C" void delay(const int milis);
+extern "C" {
+  void delay(const int milis);
+}
 void _delay_ms(const int delay);
 void delayMicroseconds(unsigned long);
 uint32_t millis();

Marlin/src/HAL/LINUX/include/serial.h

@@ -25,7 +25,6 @@
 #if ENABLED(EMERGENCY_PARSER)
   #include "../../../feature/e_parser.h"
 #endif
-#include "../../../core/serial_hook.h"
 
 #include <stdarg.h>
 #include <stdio.h>
@@ -74,11 +73,19 @@ private:
   volatile uint32_t index_read;
 };
 
-struct HalSerial {
+class HalSerial {
+public:
+
+  #if ENABLED(EMERGENCY_PARSER)
+    EmergencyParser::State emergency_state;
+    static inline bool emergency_parser_enabled() { return true; }
+  #endif
+
   HalSerial() { host_connected = true; }
 
   void begin(int32_t) {}
-  void end()          {}
+
+  void end() {}
 
   int peek() {
     uint8_t value;
@@ -93,7 +100,7 @@ struct HalSerial {
     return transmit_buffer.write(c);
   }
 
-  bool connected() { return host_connected; }
+  operator bool() { return host_connected; }
 
   uint16_t available() {
     return (uint16_t)receive_buffer.available();
@@ -110,9 +117,92 @@ struct HalSerial {
       while (transmit_buffer.available()) { /* nada */ }
   }
 
+  void printf(const char *format, ...) {
+    static char buffer[256];
+    va_list vArgs;
+    va_start(vArgs, format);
+    int length = vsnprintf((char *) buffer, 256, (char const *) format, vArgs);
+    va_end(vArgs);
+    if (length > 0 && length < 256) {
+      if (host_connected) {
+        for (int i = 0; i < length;) {
+          if (transmit_buffer.write(buffer[i])) {
+            ++i;
+          }
+        }
+      }
+    }
+  }
+
+  #define DEC 10
+  #define HEX 16
+  #define OCT 8
+  #define BIN 2
+
+  void print_bin(uint32_t value, uint8_t num_digits) {
+    uint32_t mask = 1 << (num_digits -1);
+    for (uint8_t i = 0; i < num_digits; i++) {
+      if (!(i %  4) && i) write(' ');
+      if (!(i % 16) && i) write(' ');
+      if (value & mask)   write('1');
+      else                write('0');
+      value <<= 1;
+    }
+  }
+
+  void print(const char value[]) { printf("%s" , value); }
+  void print(char value, int nbase = 0) {
+    if (nbase == BIN) print_bin(value, 8);
+    else if (nbase == OCT) printf("%3o", value);
+    else if (nbase == HEX) printf("%2X", value);
+    else if (nbase == DEC ) printf("%d", value);
+    else printf("%c" , value);
+  }
+  void print(unsigned char value, int nbase = 0) {
+    if (nbase == BIN) print_bin(value, 8);
+    else if (nbase == OCT) printf("%3o", value);
+    else if (nbase == HEX) printf("%2X", value);
+    else printf("%u" , value);
+  }
+  void print(int value, int nbase = 0) {
+    if (nbase == BIN) print_bin(value, 16);
+    else if (nbase == OCT) printf("%6o", value);
+    else if (nbase == HEX) printf("%4X", value);
+    else printf("%d", value);
+  }
+  void print(unsigned int value, int nbase = 0) {
+    if (nbase == BIN) print_bin(value, 16);
+    else if (nbase == OCT) printf("%6o", value);
+    else if (nbase == HEX) printf("%4X", value);
+    else printf("%u" , value);
+  }
+  void print(long value, int nbase = 0) {
+    if (nbase == BIN) print_bin(value, 32);
+    else if (nbase == OCT) printf("%11o", value);
+    else if (nbase == HEX) printf("%8X", value);
+    else printf("%ld" , value);
+  }
+  void print(unsigned long value, int nbase = 0) {
+    if (nbase == BIN) print_bin(value, 32);
+    else if (nbase == OCT) printf("%11o", value);
+    else if (nbase == HEX) printf("%8X", value);
+    else printf("%lu" , value);
+  }
+  void print(float value, int round = 6)  { printf("%f" , value); }
+  void print(double value, int round = 6) { printf("%f" , value); }
+
+  void println(const char value[]) { printf("%s\n" , value); }
+  void println(char value, int nbase = 0) { print(value, nbase); println(); }
+  void println(unsigned char value, int nbase = 0) { print(value, nbase); println(); }
+  void println(int value, int nbase = 0) { print(value, nbase); println(); }
+  void println(unsigned int value, int nbase = 0) { print(value, nbase); println(); }
+  void println(long value, int nbase = 0) { print(value, nbase); println(); }
+  void println(unsigned long value, int nbase = 0) { print(value, nbase); println(); }
+  void println(float value, int round = 6) { printf("%f\n" , value); }
+  void println(double value, int round = 6) { printf("%f\n" , value); }
+  void println() { print('\n'); }
+
   volatile RingBuffer<uint8_t, 128> receive_buffer;
   volatile RingBuffer<uint8_t, 128> transmit_buffer;
   volatile bool host_connected;
 };
-
-typedef Serial1Class<HalSerial> MSerialT;

Marlin/src/HAL/LINUX/main.cpp

@@ -1,5 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
+ *
  * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * This program is free software: you can redistribute it and/or modify
@@ -18,23 +19,22 @@
  */
 #ifdef __PLAT_LINUX__
 
-//#define GPIO_LOGGING // Full GPIO and Positional Logging
+extern void setup();
+extern void loop();
+
+#include <thread>
+
+#include <iostream>
+#include <fstream>
 
 #include "../../inc/MarlinConfig.h"
+#include <stdio.h>
+#include <stdarg.h>
 #include "../shared/Delay.h"
 #include "hardware/IOLoggerCSV.h"
 #include "hardware/Heater.h"
 #include "hardware/LinearAxis.h"
 
-#include <stdio.h>
-#include <stdarg.h>
-#include <thread>
-#include <iostream>
-#include <fstream>
-
-extern void setup();
-extern void loop();
-
 // simple stdout / stdin implementation for fake serial port
 void write_serial_thread() {
   for (;;) {
@@ -64,6 +64,8 @@ void simulation_loop() {
   LinearAxis z_axis(Z_ENABLE_PIN, Z_DIR_PIN, Z_STEP_PIN, Z_MIN_PIN, Z_MAX_PIN);
   LinearAxis extruder0(E0_ENABLE_PIN, E0_DIR_PIN, E0_STEP_PIN, P_NC, P_NC);
 
+  //#define GPIO_LOGGING // Full GPIO and Positional Logging
+
   #ifdef GPIO_LOGGING
     IOLoggerCSV logger("all_gpio_log.csv");
     Gpio::attachLogger(&logger);
@@ -86,7 +88,7 @@ void simulation_loop() {
 
     #ifdef GPIO_LOGGING
       if (x_axis.position != x || y_axis.position != y || z_axis.position != z) {
-        uint64_t update = _MAX(x_axis.last_update, y_axis.last_update, z_axis.last_update);
+        uint64_t update = MAX3(x_axis.last_update, y_axis.last_update, z_axis.last_update);
         position_log << update << ", " << x_axis.position << ", " << y_axis.position << ", " << z_axis.position << std::endl;
         position_log.flush();
         x = x_axis.position;
@@ -105,8 +107,8 @@ int main() {
   std::thread write_serial (write_serial_thread);
   std::thread read_serial (read_serial_thread);
 
-  #ifdef MYSERIAL1
+  #ifdef MYSERIAL0
-    MYSERIAL1.begin(BAUDRATE);
+    MYSERIAL0.begin(BAUDRATE);
     SERIAL_ECHOLNPGM("x86_64 Initialized");
     SERIAL_FLUSHTX();
   #endif

Marlin/src/HAL/LINUX/pinsDebug.h

@@ -26,15 +26,15 @@
  */
 
 #define NUMBER_PINS_TOTAL NUM_DIGITAL_PINS
-#define pwm_details(pin)    NOOP          // (do nothing)
+#define pwm_details(pin) pin = pin    // do nothing  // print PWM details
-#define pwm_status(pin)     false         // Print a pin's PWM status. Return true if it's currently a PWM pin.
+#define pwm_status(pin) false //Print a pin's PWM status. Return true if it's currently a PWM pin.
-#define IS_ANALOG(P)        (DIGITAL_PIN_TO_ANALOG_PIN(P) >= 0 ? 1 : 0)
+#define IS_ANALOG(P) (DIGITAL_PIN_TO_ANALOG_PIN(P) >= 0 ? 1 : 0)
 #define digitalRead_mod(p)  digitalRead(p)
 #define PRINT_PORT(p)
-#define GET_ARRAY_PIN(p)    pin_array[p].pin
+#define 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(p) do{ sprintf_P(buffer, PSTR("%3d "), p); SERIAL_ECHO(buffer); }while(0)
-#define MULTI_NAME_PAD  16 // space needed to be pretty if not first name assigned to a pin
+#define MULTI_NAME_PAD 16 // space needed to be pretty if not first name assigned to a pin
 
 // active ADC function/mode/code values for PINSEL registers
 constexpr int8_t ADC_pin_mode(pin_t pin) {

Marlin/src/HAL/LINUX/spi_pins.h

@@ -24,32 +24,31 @@
 #include "../../core/macros.h"
 #include "../../inc/MarlinConfigPre.h"
 
-#if BOTH(HAS_MARLINUI_U8GLIB, SDSUPPORT) && (LCD_PINS_D4 == SD_SCK_PIN || LCD_PINS_ENABLE == SD_MOSI_PIN || DOGLCD_SCK == SD_SCK_PIN || DOGLCD_MOSI == SD_MOSI_PIN)
+#if BOTH(HAS_MARLINUI_U8GLIB, SDSUPPORT) && (LCD_PINS_D4 == SCK_PIN || LCD_PINS_ENABLE == MOSI_PIN || DOGLCD_SCK == SCK_PIN || DOGLCD_MOSI == MOSI_PIN)
   #define LPC_SOFTWARE_SPI  // If the SD card and LCD adapter share the same SPI pins, then software SPI is currently
                             // needed due to the speed and mode required for communicating with each device being different.
                             // This requirement can be removed if the SPI access to these devices is updated to use
                             // spiBeginTransaction.
 #endif
 
-// Onboard SD
+/** onboard SD card */
-//#define SD_SCK_PIN     P0_07
+//#define SCK_PIN           P0_07
-//#define SD_MISO_PIN    P0_08
+//#define MISO_PIN          P0_08
-//#define SD_MOSI_PIN    P0_09
+//#define MOSI_PIN          P0_09
-//#define SD_SS_PIN      P0_06
+//#define SS_PIN            P0_06
-
+/** external */
-// External SD
+#ifndef SCK_PIN
-#ifndef SD_SCK_PIN
+  #define SCK_PIN           50
-  #define SD_SCK_PIN        50
 #endif
-#ifndef SD_MISO_PIN
+#ifndef MISO_PIN
-  #define SD_MISO_PIN       51
+  #define MISO_PIN          51
 #endif
-#ifndef SD_MOSI_PIN
+#ifndef MOSI_PIN
-  #define SD_MOSI_PIN       52
+  #define MOSI_PIN          52
 #endif
-#ifndef SD_SS_PIN
+#ifndef SS_PIN
-  #define SD_SS_PIN         53
+  #define SS_PIN            53
 #endif
 #ifndef SDSS
-  #define SDSS       SD_SS_PIN
+  #define SDSS              SS_PIN
 #endif

Marlin/src/HAL/LINUX/watchdog.cpp

@@ -27,8 +27,6 @@
 
 #include "watchdog.h"
 
-#define WDT_TIMEOUT_US TERN(WATCHDOG_DURATION_8S, 8000000, 4000000) // 4 or 8 second timeout
-
 void watchdog_init() {}
 void HAL_watchdog_refresh() {}
 

Marlin/src/HAL/LINUX/watchdog.h

@@ -21,5 +21,7 @@
  */
 #pragma once
 
+#define WDT_TIMEOUT   4000000 // 4 second timeout
+
 void watchdog_init();
 void HAL_watchdog_refresh();

Marlin/src/HAL/LPC1768/DebugMonitor.cpp

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

Marlin/src/HAL/LPC1768/HAL.cpp

@@ -29,18 +29,21 @@
   #include "watchdog.h"
 #endif
 
-DefaultSerial1 USBSerial(false, UsbSerial);
-
 uint32_t HAL_adc_reading = 0;
 
 // U8glib required functions
-extern "C" {
+extern "C" void u8g_xMicroDelay(uint16_t val) {
-  void u8g_xMicroDelay(uint16_t val) { DELAY_US(val); }
+  DELAY_US(val);
-  void u8g_MicroDelay()              { u8g_xMicroDelay(1); }
+}
-  void u8g_10MicroDelay()            { u8g_xMicroDelay(10); }
+extern "C" void u8g_MicroDelay() {
-  void u8g_Delay(uint16_t val)       { delay(val); }
+  u8g_xMicroDelay(1);
+}
+extern "C" void u8g_10MicroDelay() {
+  u8g_xMicroDelay(10);
+}
+extern "C" void u8g_Delay(uint16_t val) {
+  delay(val);
 }
-
 //************************//
 
 // return free heap space
@@ -63,12 +66,7 @@ int16_t PARSED_PIN_INDEX(const char code, const int16_t dval) {
   return ind > -1 ? ind : dval;
 }
 
-void flashFirmware(const int16_t) {
+void flashFirmware(const int16_t) { NVIC_SystemReset(); }
-  delay(500);          // Give OS time to disconnect
-  USB_Connect(false);  // USB clear connection
-  delay(1000);         // Give OS time to notice
-  NVIC_SystemReset();
-}
 
 void HAL_clear_reset_source(void) {
   TERN_(USE_WATCHDOG, watchdog_clear_timeout_flag());

Marlin/src/HAL/LPC1768/HAL.h

@@ -47,6 +47,9 @@ extern "C" volatile uint32_t _millis;
 #include <pinmapping.h>
 #include <CDCSerial.h>
 
+// i2c uses 8-bit shifted address
+#define I2C_ADDRESS(A) uint8_t((A) << 1)
+
 //
 // Default graphical display delays
 //
@@ -60,43 +63,31 @@ extern "C" volatile uint32_t _millis;
   #define ST7920_DELAY_3 DELAY_NS(750)
 #endif
 
-typedef ForwardSerial1Class< decltype(UsbSerial) > DefaultSerial1;
-extern DefaultSerial1 USBSerial;
-
 #define _MSERIAL(X) MSerial##X
 #define MSERIAL(X) _MSERIAL(X)
+#define MSerial0 MSerial
 
 #if SERIAL_PORT == -1
-  #define MYSERIAL1 USBSerial
+  #define MYSERIAL0 UsbSerial
 #elif WITHIN(SERIAL_PORT, 0, 3)
-  #define MYSERIAL1 MSERIAL(SERIAL_PORT)
+  #define MYSERIAL0 MSERIAL(SERIAL_PORT)
 #else
   #error "SERIAL_PORT must be from -1 to 3. Please update your configuration."
 #endif
 
 #ifdef SERIAL_PORT_2
   #if SERIAL_PORT_2 == -1
-    #define MYSERIAL2 USBSerial
+    #define MYSERIAL1 UsbSerial
   #elif WITHIN(SERIAL_PORT_2, 0, 3)
-    #define MYSERIAL2 MSERIAL(SERIAL_PORT_2)
+    #define MYSERIAL1 MSERIAL(SERIAL_PORT_2)
   #else
     #error "SERIAL_PORT_2 must be from -1 to 3. Please update your configuration."
   #endif
 #endif
 
-#ifdef MMU2_SERIAL_PORT
-  #if MMU2_SERIAL_PORT == -1
-    #define MMU2_SERIAL USBSerial
-  #elif WITHIN(MMU2_SERIAL_PORT, 0, 3)
-    #define MMU2_SERIAL MSERIAL(MMU2_SERIAL_PORT)
-  #else
-    #error "MMU2_SERIAL_PORT must be from -1 to 3. Please update your configuration."
-  #endif
-#endif
-
 #ifdef LCD_SERIAL_PORT
   #if LCD_SERIAL_PORT == -1
-    #define LCD_SERIAL USBSerial
+    #define LCD_SERIAL UsbSerial
   #elif WITHIN(LCD_SERIAL_PORT, 0, 3)
     #define LCD_SERIAL MSERIAL(LCD_SERIAL_PORT)
   #else
@@ -116,16 +107,10 @@ extern DefaultSerial1 USBSerial;
 //
 // Utility functions
 //
-#if GCC_VERSION <= 50000
+#pragma GCC diagnostic push
-  #pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-function"
-  #pragma GCC diagnostic ignored "-Wunused-function"
-#endif
-
 int freeMemory();
-
+#pragma GCC diagnostic pop
-#if GCC_VERSION <= 50000
-  #pragma GCC diagnostic pop
-#endif
 
 //
 // ADC API
@@ -215,4 +200,7 @@ void set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size=255,
 void HAL_clear_reset_source(void);
 uint8_t HAL_get_reset_source(void);
 
-inline void HAL_reboot() {}  // reboot the board or restart the bootloader
+// Add strcmp_P if missing
+#ifndef strcmp_P
+  #define strcmp_P(a, b) strcmp((a), (b))
+#endif

Marlin/src/HAL/LPC1768/HAL_MinSerial.cpp

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

Marlin/src/HAL/LPC1768/HAL_SPI.cpp

@@ -55,33 +55,27 @@
 #include <lpc17xx_pinsel.h>
 #include <lpc17xx_clkpwr.h>
 
-#include "../shared/HAL_SPI.h"
-
 // ------------------------
 // Public functions
 // ------------------------
 #if ENABLED(LPC_SOFTWARE_SPI)
 
-  // Software SPI
-
   #include <SoftwareSPI.h>
 
-  #ifndef HAL_SPI_SPEED
+  // Software SPI
-    #define HAL_SPI_SPEED SPI_FULL_SPEED
-  #endif
 
-  static uint8_t SPI_speed = HAL_SPI_SPEED;
+  static uint8_t SPI_speed = 0;
 
   static uint8_t spiTransfer(uint8_t b) {
-    return swSpiTransfer(b, SPI_speed, SD_SCK_PIN, SD_MISO_PIN, SD_MOSI_PIN);
+    return swSpiTransfer(b, SPI_speed, SCK_PIN, MISO_PIN, MOSI_PIN);
   }
 
   void spiBegin() {
-    swSpiBegin(SD_SCK_PIN, SD_MISO_PIN, SD_MOSI_PIN);
+    swSpiBegin(SCK_PIN, MISO_PIN, MOSI_PIN);
   }
 
   void spiInit(uint8_t spiRate) {
-    SPI_speed = swSpiInit(spiRate, SD_SCK_PIN, SD_MOSI_PIN);
+    SPI_speed = swSpiInit(spiRate, SCK_PIN, MOSI_PIN);
   }
 
   uint8_t spiRec() { return spiTransfer(0xFF); }
@@ -106,20 +100,14 @@
 
 #else
 
-  #ifndef HAL_SPI_SPEED
+  void spiBegin() {  // setup SCK, MOSI & MISO pins for SSP0
-    #ifdef SD_SPI_SPEED
+    spiInit(SPI_SPEED);
-      #define HAL_SPI_SPEED SD_SPI_SPEED
+  }
-    #else
-      #define HAL_SPI_SPEED SPI_FULL_SPEED
-    #endif
-  #endif
-
-  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
+    #if MISO_PIN == BOARD_SPI1_MISO_PIN
       SPI.setModule(1);
-    #elif SD_MISO_PIN == BOARD_SPI2_MISO_PIN
+    #elif MISO_PIN == BOARD_SPI2_MISO_PIN
       SPI.setModule(2);
     #endif
     SPI.setDataSize(DATA_SIZE_8BIT);
@@ -139,9 +127,11 @@
     for (uint16_t i = 0; i < nbyte; i++) doio(buf[i]);
   }
 
-  void spiSend(uint32_t chan, byte b) {}
+  void spiSend(uint32_t chan, byte b) {
+  }
 
-  void spiSend(uint32_t chan, const uint8_t* buf, size_t nbyte) {}
+  void spiSend(uint32_t chan, const uint8_t* buf, size_t nbyte) {
+  }
 
   // Read single byte from SPI
   uint8_t spiRec() { return doio(0xFF); }
@@ -153,7 +143,9 @@
     for (uint16_t i = 0; i < nbyte; i++) buf[i] = doio(0xFF);
   }
 
-  uint8_t spiTransfer(uint8_t b) { return doio(b); }
+  uint8_t spiTransfer(uint8_t b) {
+    return doio(b);
+  }
 
   // Write from buffer to SPI
   void spiSendBlock(uint8_t token, const uint8_t* buf) {
@@ -162,9 +154,10 @@
       (void)spiTransfer(buf[i]);
   }
 
-  // Begin SPI transaction, set clock, bit order, data mode
+  /** Begin SPI transaction, set clock, bit order, data mode */
   void spiBeginTransaction(uint32_t spiClock, uint8_t bitOrder, uint8_t dataMode) {
-    // TODO: Implement this method
+    // TODO: to be implemented
+
   }
 
 #endif // LPC_SOFTWARE_SPI
@@ -208,15 +201,6 @@ SPIClass::SPIClass(uint8_t device) {
   GPDMA_Init();
 }
 
-SPIClass::SPIClass(pin_t mosi, pin_t miso, pin_t sclk, pin_t ssel) {
-  #if BOARD_NR_SPI >= 1
-    if (mosi == BOARD_SPI1_MOSI_PIN) SPIClass(1);
-  #endif
-  #if BOARD_NR_SPI >= 2
-    if (mosi == BOARD_SPI2_MOSI_PIN) SPIClass(2);
-  #endif
-}
-
 void SPIClass::begin() {
   // Init the SPI pins in the first begin call
   if ((_currentSetting->spi_d == LPC_SSP0 && spiInitialised[0] == false) ||
@@ -279,9 +263,8 @@ uint16_t SPIClass::transfer16(const uint16_t data) {
 }
 
 void SPIClass::end() {
-  // Neither is needed for Marlin
+  // SSP_Cmd(_currentSetting->spi_d, DISABLE);  // stop device or SSP_DeInit?
-  //SSP_Cmd(_currentSetting->spi_d, DISABLE);
+  SSP_DeInit(_currentSetting->spi_d);
-  //SSP_DeInit(_currentSetting->spi_d);
 }
 
 void SPIClass::send(uint8_t data) {
@@ -347,15 +330,25 @@ void SPIClass::read(uint8_t *buf, uint32_t len) {
   for (uint16_t i = 0; i < len; i++) buf[i] = transfer(0xFF);
 }
 
-void SPIClass::setClock(uint32_t clock) { _currentSetting->clock = clock; }
+void SPIClass::setClock(uint32_t clock) {
+  _currentSetting->clock = clock;
+}
 
-void SPIClass::setModule(uint8_t device) { _currentSetting = &_settings[device - 1]; } // SPI channels are called 1, 2, and 3 but the array is zero-indexed
+void SPIClass::setModule(uint8_t device) {
+  _currentSetting = &_settings[device - 1];// SPI channels are called 1 2 and 3 but the array is zero indexed
+}
 
-void SPIClass::setBitOrder(uint8_t bitOrder) { _currentSetting->bitOrder = bitOrder; }
+void SPIClass::setBitOrder(uint8_t bitOrder) {
+  _currentSetting->bitOrder = bitOrder;
+}
 
-void SPIClass::setDataMode(uint8_t dataMode) { _currentSetting->dataMode = dataMode; }
+void SPIClass::setDataMode(uint8_t dataMode) {
+  _currentSetting->dataMode = dataMode;
+}
 
-void SPIClass::setDataSize(uint32_t dataSize) { _currentSetting->dataSize = dataSize; }
+void SPIClass::setDataSize(uint32_t ds) {
+  _currentSetting->dataSize = ds;
+}
 
 /**
  * Set up/tear down
@@ -363,8 +356,8 @@ void SPIClass::setDataSize(uint32_t dataSize) { _currentSetting->dataSize = data
 void SPIClass::updateSettings() {
   //SSP_DeInit(_currentSetting->spi_d); //todo: need force de init?!
 
-  // Divide PCLK by 2 for SSP0
+  // divide PCLK by 2 for SSP0
-  //CLKPWR_SetPCLKDiv(_currentSetting->spi_d == LPC_SSP0 ? CLKPWR_PCLKSEL_SSP0 : CLKPWR_PCLKSEL_SSP1, CLKPWR_PCLKSEL_CCLK_DIV_2);
+  CLKPWR_SetPCLKDiv(_currentSetting->spi_d == LPC_SSP0 ? CLKPWR_PCLKSEL_SSP0 : CLKPWR_PCLKSEL_SSP1, CLKPWR_PCLKSEL_CCLK_DIV_2);
 
   SSP_CFG_Type HW_SPI_init; // data structure to hold init values
   SSP_ConfigStructInit(&HW_SPI_init);  // set values for SPI mode
@@ -403,9 +396,9 @@ void SPIClass::updateSettings() {
   SSP_Init(_currentSetting->spi_d, &HW_SPI_init);  // puts the values into the proper bits in the SSP0 registers
 }
 
-#if SD_MISO_PIN == BOARD_SPI1_MISO_PIN
+#if MISO_PIN == BOARD_SPI1_MISO_PIN
   SPIClass SPI(1);
-#elif SD_MISO_PIN == BOARD_SPI2_MISO_PIN
+#elif MISO_PIN == BOARD_SPI2_MISO_PIN
   SPIClass SPI(2);
 #endif
 

Marlin/src/HAL/LPC1768/MarlinSPI.h

@@ -1,45 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-#include <SPI.h>
-
-/**
- * Marlin currently requires 3 SPI classes:
- *
- * SPIClass:
- *  This class is normally provided by frameworks and has a semi-default interface.
- *  This is needed because some libraries reference it globally.
- *
- * SPISettings:
- *  Container for SPI configs for SPIClass. As above, libraries may reference it globally.
- *
- * These two classes are often provided by frameworks so we cannot extend them to add
- * useful methods for Marlin.
- *
- * MarlinSPI:
- *  Provides the default SPIClass interface plus some Marlin goodies such as a simplified
- *  interface for SPI DMA transfer.
- *
- */
-
-using MarlinSPI = SPIClass;

Marlin/src/HAL/LPC1768/MarlinSerial.cpp

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

Marlin/src/HAL/LPC1768/MarlinSerial.h

@@ -28,7 +28,6 @@
 #if ENABLED(EMERGENCY_PARSER)
   #include "../../feature/e_parser.h"
 #endif
-#include "../../core/serial_hook.h"
 
 #ifndef SERIAL_PORT
   #define SERIAL_PORT 0
@@ -42,26 +41,27 @@
 
 class MarlinSerial : public HardwareSerial<RX_BUFFER_SIZE, TX_BUFFER_SIZE> {
 public:
-  MarlinSerial(LPC_UART_TypeDef *UARTx) : HardwareSerial<RX_BUFFER_SIZE, TX_BUFFER_SIZE>(UARTx) { }
+  MarlinSerial(LPC_UART_TypeDef *UARTx) :
+    HardwareSerial<RX_BUFFER_SIZE, TX_BUFFER_SIZE>(UARTx)
+    #if ENABLED(EMERGENCY_PARSER)
+      , emergency_state(EmergencyParser::State::EP_RESET)
+    #endif
+    { }
 
   void end() {}
 
   #if ENABLED(EMERGENCY_PARSER)
-    bool recv_callback(const char c) override;
+    bool recv_callback(const char c) override {
+      emergency_parser.update(emergency_state, c);
+      return true; // do not discard character
+    }
+
+    EmergencyParser::State emergency_state;
+    static inline bool emergency_parser_enabled() { return true; }
   #endif
 };
 
-// On LPC176x framework, HardwareSerial does not implement the same interface as Arduino's Serial, so overloads
+extern MarlinSerial MSerial;
-// of 'available' and 'read' method are not used in this multiple inheritance scenario.
+extern MarlinSerial MSerial1;
-// Instead, use a ForwardSerial here that adapts the interface.
+extern MarlinSerial MSerial2;
-typedef ForwardSerial1Class<MarlinSerial> MSerialT;
+extern MarlinSerial MSerial3;
-extern MSerialT MSerial0;
-extern MSerialT MSerial1;
-extern MSerialT MSerial2;
-extern MSerialT MSerial3;
-
-// Consequently, we can't use a RuntimeSerial either. The workaround would be to use a RuntimeSerial<ForwardSerial<MarlinSerial>> type here
-// Right now, let's ignore this until it's actually required.
-#if ENABLED(SERIAL_RUNTIME_HOOK)
-  #error "SERIAL_RUNTIME_HOOK is not yet supported for LPC176x."
-#endif

Marlin/src/HAL/LPC1768/eeprom_flash.cpp

@@ -25,7 +25,7 @@
  * Emulate EEPROM storage using Flash Memory
  *
  * Use a single 32K flash sector to store EEPROM data. To reduce the
- * number of erase operations a simple "leveling" scheme is used that
+ * number of erase operations a simple "levelling" scheme is used that
  * maintains a number of EEPROM "slots" within the larger flash sector.
  * Each slot is used in turn and the entire sector is only erased when all
  * slots have been used.
@@ -119,7 +119,7 @@ bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, ui
   return false;  // return true for any error
 }
 
-bool PersistentStore::read_data(int &pos, uint8_t *value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
+bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
   const uint8_t * const buff = writing ? &value[0] : &ram_eeprom[pos];
   if (writing) for (size_t i = 0; i < size; i++) value[i] = ram_eeprom[pos + i];
   crc16(crc, buff, size);

Marlin/src/HAL/LPC1768/eeprom_sdcard.cpp

@@ -83,16 +83,17 @@ bool PersistentStore::access_finish() {
 static void debug_rw(const bool write, int &pos, const uint8_t *value, const size_t size, const FRESULT s, const size_t total=0) {
   PGM_P const rw_str = write ? PSTR("write") : PSTR("read");
   SERIAL_CHAR(' ');
-  SERIAL_ECHOPGM_P(rw_str);
+  serialprintPGM(rw_str);
-  SERIAL_ECHOLNPAIR("_data(", pos, ",", value, ",", size, ", ...)");
+  SERIAL_ECHOLNPAIR("_data(", pos, ",", int(value), ",", int(size), ", ...)");
   if (total) {
     SERIAL_ECHOPGM(" f_");
-    SERIAL_ECHOPGM_P(rw_str);
+    serialprintPGM(rw_str);
-    SERIAL_ECHOPAIR("()=", s, "\n size=", size, "\n bytes_");
+    SERIAL_ECHOPAIR("()=", int(s), "\n size=", int(size), "\n bytes_");
-    SERIAL_ECHOLNPAIR_P(write ? PSTR("written=") : PSTR("read="), total);
+    serialprintPGM(write ? PSTR("written=") : PSTR("read="));
+    SERIAL_ECHOLN(total);
   }
   else
-    SERIAL_ECHOLNPAIR(" f_lseek()=", s);
+    SERIAL_ECHOLNPAIR(" f_lseek()=", int(s));
 }
 
 // File function return codes for type FRESULT. This goes away soon, but
@@ -142,7 +143,7 @@ bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, ui
   return bytes_written != size;  // return true for any error
 }
 
-bool PersistentStore::read_data(int &pos, uint8_t *value, const size_t size, uint16_t *crc, const bool writing/*=true*/) {
+bool PersistentStore::read_data(int &pos, uint8_t* value, const size_t size, uint16_t *crc, const bool writing/*=true*/) {
   if (!eeprom_file_open) return true;
   UINT bytes_read = 0;
   FRESULT s;

Marlin/src/HAL/LPC1768/eeprom_wired.cpp

@@ -64,7 +64,7 @@ bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, ui
   return false;
 }
 
-bool PersistentStore::read_data(int &pos, uint8_t *value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
+bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
   do {
     // Read from external EEPROM
     const uint8_t c = eeprom_read_byte((uint8_t*)pos);

Marlin/src/HAL/LPC1768/endstop_interrupts.h

@@ -46,79 +46,79 @@ void setup_endstop_interrupts() {
 
   #if HAS_X_MAX
     #if !LPC1768_PIN_INTERRUPT_M(X_MAX_PIN)
-      #error "X_MAX_PIN is not INTERRUPT-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
+      #error "X_MAX_PIN is not INTERRUPT-capable."
     #endif
     _ATTACH(X_MAX_PIN);
   #endif
   #if HAS_X_MIN
     #if !LPC1768_PIN_INTERRUPT_M(X_MIN_PIN)
-      #error "X_MIN_PIN is not INTERRUPT-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
+      #error "X_MIN_PIN is not INTERRUPT-capable."
     #endif
     _ATTACH(X_MIN_PIN);
   #endif
   #if HAS_Y_MAX
     #if !LPC1768_PIN_INTERRUPT_M(Y_MAX_PIN)
-      #error "Y_MAX_PIN is not INTERRUPT-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
+      #error "Y_MAX_PIN is not INTERRUPT-capable."
     #endif
     _ATTACH(Y_MAX_PIN);
   #endif
   #if HAS_Y_MIN
     #if !LPC1768_PIN_INTERRUPT_M(Y_MIN_PIN)
-      #error "Y_MIN_PIN is not INTERRUPT-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
+      #error "Y_MIN_PIN is not INTERRUPT-capable."
     #endif
     _ATTACH(Y_MIN_PIN);
   #endif
   #if HAS_Z_MAX
     #if !LPC1768_PIN_INTERRUPT_M(Z_MAX_PIN)
-      #error "Z_MAX_PIN is not INTERRUPT-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
+      #error "Z_MAX_PIN is not INTERRUPT-capable."
     #endif
     _ATTACH(Z_MAX_PIN);
   #endif
   #if HAS_Z_MIN
     #if !LPC1768_PIN_INTERRUPT_M(Z_MIN_PIN)
-      #error "Z_MIN_PIN is not INTERRUPT-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
+      #error "Z_MIN_PIN is not INTERRUPT-capable."
     #endif
      _ATTACH(Z_MIN_PIN);
   #endif
   #if HAS_Z2_MAX
     #if !LPC1768_PIN_INTERRUPT_M(Z2_MAX_PIN)
-      #error "Z2_MAX_PIN is not INTERRUPT-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
+      #error "Z2_MAX_PIN is not INTERRUPT-capable."
     #endif
     _ATTACH(Z2_MAX_PIN);
   #endif
   #if HAS_Z2_MIN
     #if !LPC1768_PIN_INTERRUPT_M(Z2_MIN_PIN)
-      #error "Z2_MIN_PIN is not INTERRUPT-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
+      #error "Z2_MIN_PIN is not INTERRUPT-capable."
     #endif
     _ATTACH(Z2_MIN_PIN);
   #endif
   #if HAS_Z3_MAX
     #if !LPC1768_PIN_INTERRUPT_M(Z3_MAX_PIN)
-      #error "Z3_MIN_PIN is not INTERRUPT-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
+      #error "Z3_MIN_PIN is not INTERRUPT-capable."
     #endif
     _ATTACH(Z3_MAX_PIN);
   #endif
   #if HAS_Z3_MIN
     #if !LPC1768_PIN_INTERRUPT_M(Z3_MIN_PIN)
-      #error "Z3_MIN_PIN is not INTERRUPT-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
+      #error "Z3_MIN_PIN is not INTERRUPT-capable."
     #endif
     _ATTACH(Z3_MIN_PIN);
   #endif
   #if HAS_Z4_MAX
     #if !LPC1768_PIN_INTERRUPT_M(Z4_MAX_PIN)
-      #error "Z4_MIN_PIN is not INTERRUPT-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
+      #error "Z4_MIN_PIN is not INTERRUPT-capable."
     #endif
     _ATTACH(Z4_MAX_PIN);
   #endif
   #if HAS_Z4_MIN
     #if !LPC1768_PIN_INTERRUPT_M(Z4_MIN_PIN)
-      #error "Z4_MIN_PIN is not INTERRUPT-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
+      #error "Z4_MIN_PIN is not INTERRUPT-capable."
     #endif
     _ATTACH(Z4_MIN_PIN);
   #endif
   #if HAS_Z_MIN_PROBE_PIN
     #if !LPC1768_PIN_INTERRUPT_M(Z_MIN_PROBE_PIN)
-      #error "Z_MIN_PROBE_PIN is not INTERRUPT-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
+      #error "Z_MIN_PROBE_PIN is not INTERRUPT-capable."
     #endif
     _ATTACH(Z_MIN_PROBE_PIN);
   #endif

Marlin/src/HAL/LPC1768/inc/Conditionals_LCD.h

@@ -24,3 +24,10 @@
 #if HAS_FSMC_TFT
   #error "Sorry! FSMC TFT displays are not current available for HAL/LPC1768."
 #endif
+
+// This emulated DOGM has 'touch/xpt2046', not 'tft/xpt2046'
+#if ENABLED(TOUCH_SCREEN) && !HAS_GRAPHICAL_TFT
+  #undef TOUCH_SCREEN
+  #undef TOUCH_SCREEN_CALIBRATION
+  #define HAS_TOUCH_XPT2046 1
+#endif

Marlin/src/HAL/LPC1768/inc/Conditionals_adv.h

@@ -20,7 +20,3 @@
  *
  */
 #pragma once
-
-#if DISABLED(NO_SD_HOST_DRIVE)
-  #define HAS_SD_HOST_DRIVE 1
-#endif

Marlin/src/HAL/LPC1768/inc/Conditionals_post.h

@@ -26,9 +26,3 @@
 #elif EITHER(I2C_EEPROM, SPI_EEPROM)
   #define USE_SHARED_EEPROM 1
 #endif
-
-// LPC1768 boards seem to lose steps when saving to EEPROM during print (issue #20785)
-// TODO: Which other boards are incompatible?
-#if defined(MCU_LPC1768) && PRINTCOUNTER_SAVE_INTERVAL > 0
-  #define PRINTCOUNTER_SYNC 1
-#endif

Marlin/src/HAL/LPC1768/inc/SanityCheck.h

@@ -24,14 +24,14 @@
 #if PIO_PLATFORM_VERSION < 1001
   #error "nxplpc-arduino-lpc176x package is out of date, Please update the PlatformIO platforms, frameworks and libraries. You may need to remove the platform and let it reinstall automatically."
 #endif
-#if PIO_FRAMEWORK_VERSION < 2006
+#if PIO_FRAMEWORK_VERSION < 2005
   #error "framework-arduino-lpc176x package is out of date, Please update the PlatformIO platforms, frameworks and libraries."
 #endif
 
 /**
  * Detect an old pins file by checking for old ADC pins values.
  */
-#define _OLD_TEMP_PIN(P) PIN_EXISTS(P) && _CAT(P,_PIN) <= 7 && !WITHIN(_CAT(P,_PIN), TERN(LPC1768_IS_SKRV1_3, 0, 2), 3)  // Include P0_00 and P0_01 for SKR V1.3 board
+#define _OLD_TEMP_PIN(P) PIN_EXISTS(P) && _CAT(P,_PIN) <= 7 && _CAT(P,_PIN) != 2 && _CAT(P,_PIN) != 3
 #if _OLD_TEMP_PIN(TEMP_BED)
   #error "TEMP_BED_PIN must be defined using the Pn_nn or Pn_nn_An format. (See the included pins files)."
 #elif _OLD_TEMP_PIN(TEMP_0)
@@ -72,7 +72,7 @@ static_assert(!(NUM_SERVOS && ENABLED(FAST_PWM_FAN)), "BLTOUCH and Servos are in
 //#endif
 
 #if MB(RAMPS_14_RE_ARM_EFB, RAMPS_14_RE_ARM_EEB, RAMPS_14_RE_ARM_EFF, RAMPS_14_RE_ARM_EEF, RAMPS_14_RE_ARM_SF)
-  #if IS_RRD_FG_SC && HAS_DRIVER(TMC2130) && DISABLED(TMC_USE_SW_SPI)
+  #if ENABLED(REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER) && HAS_DRIVER(TMC2130) && DISABLED(TMC_USE_SW_SPI)
     #error "Re-ARM with REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER and TMC2130 requires TMC_USE_SW_SPI."
   #endif
 #endif
@@ -92,13 +92,13 @@ static_assert(DISABLED(BAUD_RATE_GCODE), "BAUD_RATE_GCODE is not yet supported o
 #define ANY_TX(N,V...) DO(IS_TX##N,||,V)
 #define ANY_RX(N,V...) DO(IS_RX##N,||,V)
 
-#if ANY_SERIAL_IS(0)
+#if USING_SERIAL_0
   #define IS_TX0(P) (P == P0_02)
   #define IS_RX0(P) (P == P0_03)
   #if IS_TX0(TMC_SW_MISO) || IS_RX0(TMC_SW_MOSI)
     #error "Serial port pins (0) conflict with Trinamic SPI pins!"
-  #elif HAS_PRUSA_MMU1 && (IS_TX0(E_MUX1_PIN) || IS_RX0(E_MUX0_PIN))
+  #elif ENABLED(MK2_MULTIPLEXER) && (IS_TX0(E_MUX1_PIN) || IS_RX0(E_MUX0_PIN))
-    #error "Serial port pins (0) conflict with Multi-Material-Unit multiplexer pins!"
+    #error "Serial port pins (0) conflict with MK2 multiplexer pins!"
   #elif (AXIS_HAS_SPI(X) && IS_TX0(X_CS_PIN)) || (AXIS_HAS_SPI(Y) && IS_RX0(Y_CS_PIN))
     #error "Serial port pins (0) conflict with X/Y axis SPI pins!"
   #endif
@@ -106,7 +106,7 @@ static_assert(DISABLED(BAUD_RATE_GCODE), "BAUD_RATE_GCODE is not yet supported o
   #undef IS_RX0
 #endif
 
-#if ANY_SERIAL_IS(1)
+#if USING_SERIAL_1
   #define IS_TX1(P) (P == P0_15)
   #define IS_RX1(P) (P == P0_16)
   #define _IS_TX1_1 IS_TX1
@@ -116,8 +116,8 @@ static_assert(DISABLED(BAUD_RATE_GCODE), "BAUD_RATE_GCODE is not yet supported o
   #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) \
+    #elif ANY_TX(1, SCK_PIN, LCD_PINS_D4, DOGLCD_SCK, LCD_RESET_PIN, LCD_PINS_RS, SHIFT_CLK) \
-       || ANY_RX(1, LCD_SDSS, LCD_PINS_RS, SD_MISO_PIN, DOGLCD_A0, SD_SS_PIN, LCD_SDSS, DOGLCD_CS, LCD_RESET_PIN, LCD_BACKLIGHT_PIN)
+       || ANY_RX(1, LCD_SDSS, LCD_PINS_RS, MISO_PIN, DOGLCD_A0, SS_PIN, LCD_SDSS, DOGLCD_CS, LCD_RESET_PIN, LCD_BACKLIGHT_PIN)
       #error "Serial port pins (1) conflict with LCD pins!"
     #endif
   #endif
@@ -127,7 +127,7 @@ static_assert(DISABLED(BAUD_RATE_GCODE), "BAUD_RATE_GCODE is not yet supported o
   #undef _IS_RX1_1
 #endif
 
-#if ANY_SERIAL_IS(2)
+#if USING_SERIAL_2
   #define IS_TX2(P) (P == P0_10)
   #define IS_RX2(P) (P == P0_11)
   #define _IS_TX2_1 IS_TX2
@@ -161,7 +161,7 @@ static_assert(DISABLED(BAUD_RATE_GCODE), "BAUD_RATE_GCODE is not yet supported o
   #undef _IS_RX2_1
 #endif
 
-#if ANY_SERIAL_IS(3)
+#if USING_SERIAL_3
   #define PIN_IS_TX3(P) (PIN_EXISTS(P) && P##_PIN == P0_00)
   #define PIN_IS_RX3(P) (P##_PIN == P0_01)
   #if PIN_IS_TX3(X_MIN) || PIN_IS_RX3(X_MAX)
@@ -191,7 +191,7 @@ static_assert(DISABLED(BAUD_RATE_GCODE), "BAUD_RATE_GCODE is not yet supported o
 //
 // Flag any i2c pin conflicts
 //
-#if ANY(HAS_MOTOR_CURRENT_I2C, HAS_MOTOR_CURRENT_DAC, EXPERIMENTAL_I2CBUS, I2C_POSITION_ENCODERS, PCA9632, I2C_EEPROM)
+#if ANY(HAS_I2C_DIGIPOT, DAC_STEPPER_CURRENT, EXPERIMENTAL_I2CBUS, I2C_POSITION_ENCODERS, PCA9632, I2C_EEPROM)
   #define USEDI2CDEV_M 1  // <Arduino>/Wire.cpp
 
   #if USEDI2CDEV_M == 0         // P0_27 [D57] (AUX-1) .......... P0_28 [D58] (AUX-1)
@@ -205,8 +205,8 @@ static_assert(DISABLED(BAUD_RATE_GCODE), "BAUD_RATE_GCODE is not yet supported o
       #error "SDA0 overlaps with BEEPER_PIN!"
     #elif IS_SCL0(BTN_ENC)
       #error "SCL0 overlaps with Encoder Button!"
-    #elif IS_SCL0(SD_SS_PIN)
+    #elif IS_SCL0(SS_PIN)
-      #error "SCL0 overlaps with SD_SS_PIN!"
+      #error "SCL0 overlaps with SS_PIN!"
     #elif IS_SCL0(LCD_SDSS)
       #error "SCL0 overlaps with LCD_SDSS!"
     #endif
@@ -270,7 +270,7 @@ static_assert(DISABLED(BAUD_RATE_GCODE), "BAUD_RATE_GCODE is not yet supported o
 #endif
 
 #if ENABLED(SERIAL_STATS_MAX_RX_QUEUED)
-  #error "SERIAL_STATS_MAX_RX_QUEUED is not supported on LPC176x."
+  #error "SERIAL_STATS_MAX_RX_QUEUED is not supported on this platform."
 #elif ENABLED(SERIAL_STATS_DROPPED_RX)
-  #error "SERIAL_STATS_DROPPED_RX is not supported on LPX176x."
+  #error "SERIAL_STATS_DROPPED_RX is not supported on this platform."
 #endif

Marlin/src/HAL/LPC1768/include/SPI.h

@@ -37,14 +37,13 @@
 #define DATA_SIZE_8BIT SSP_DATABIT_8
 #define DATA_SIZE_16BIT SSP_DATABIT_16
 
-#define SPI_CLOCK_MAX_TFT  30000000UL
+#define SPI_CLOCK_DIV2   8333333 //(SCR:  2)  desired: 8,000,000  actual: 8,333,333  +4.2%  SPI_FULL_SPEED
-#define SPI_CLOCK_DIV2     8333333 //(SCR:  2)  desired: 8,000,000  actual: 8,333,333  +4.2%  SPI_FULL_SPEED
+#define SPI_CLOCK_DIV4   4166667 //(SCR:  5)  desired: 4,000,000  actual: 4,166,667  +4.2%  SPI_HALF_SPEED
-#define SPI_CLOCK_DIV4     4166667 //(SCR:  5)  desired: 4,000,000  actual: 4,166,667  +4.2%  SPI_HALF_SPEED
+#define SPI_CLOCK_DIV8   2083333 //(SCR: 11)  desired: 2,000,000  actual: 2,083,333  +4.2%  SPI_QUARTER_SPEED
-#define SPI_CLOCK_DIV8     2083333 //(SCR: 11)  desired: 2,000,000  actual: 2,083,333  +4.2%  SPI_QUARTER_SPEED
+#define SPI_CLOCK_DIV16  1000000 //(SCR: 24)  desired: 1,000,000  actual: 1,000,000         SPI_EIGHTH_SPEED
-#define SPI_CLOCK_DIV16    1000000 //(SCR: 24)  desired: 1,000,000  actual: 1,000,000         SPI_EIGHTH_SPEED
+#define SPI_CLOCK_DIV32   500000 //(SCR: 49)  desired:   500,000  actual:   500,000         SPI_SPEED_5
-#define SPI_CLOCK_DIV32     500000 //(SCR: 49)  desired:   500,000  actual:   500,000         SPI_SPEED_5
+#define SPI_CLOCK_DIV64   250000 //(SCR: 99)  desired:   250,000  actual:   250,000         SPI_SPEED_6
-#define SPI_CLOCK_DIV64     250000 //(SCR: 99)  desired:   250,000  actual:   250,000         SPI_SPEED_6
+#define SPI_CLOCK_DIV128  125000 //(SCR:199)  desired:   125,000  actual:   125,000         Default from HAL.h
-#define SPI_CLOCK_DIV128    125000 //(SCR:199)  desired:   125,000  actual:   125,000         Default from HAL.h
 
 #define SPI_CLOCK_MAX SPI_CLOCK_DIV2
 
@@ -126,11 +125,6 @@ public:
    */
   SPIClass(uint8_t spiPortNumber);
 
-  /**
-   * Init using pins
-   */
-  SPIClass(pin_t mosi, pin_t miso, pin_t sclk, pin_t ssel = (pin_t)-1);
-
   /**
    * Select and configure the current selected SPI device to use
    */

Marlin/src/HAL/LPC1768/main.cpp

@@ -31,23 +31,20 @@
 #include <CDCSerial.h>
 #include <usb/mscuser.h>
 
+extern "C" {
+  #include <debug_frmwrk.h>
+}
+
+#include "../../sd/cardreader.h"
 #include "../../inc/MarlinConfig.h"
 #include "../../core/millis_t.h"
 
-#include "../../sd/cardreader.h"
-
 extern uint32_t MSC_SD_Init(uint8_t pdrv);
-
+extern "C" int isLPC1769();
-extern "C" {
+extern "C" void disk_timerproc();
-  #include <debug_frmwrk.h>
-  extern "C" int isLPC1769();
-  extern "C" void disk_timerproc();
-}
 
 void SysTick_Callback() { disk_timerproc(); }
 
-TERN_(POSTMORTEM_DEBUGGING, extern void install_min_serial());
-
 void HAL_init() {
 
   // Init LEDs
@@ -92,11 +89,11 @@ void HAL_init() {
   //debug_frmwrk_init();
   //_DBG("\n\nDebug running\n");
   // Initialize the SD card chip select pins as soon as possible
-  #if PIN_EXISTS(SD_SS)
+  #if PIN_EXISTS(SS)
-    OUT_WRITE(SD_SS_PIN, HIGH);
+    OUT_WRITE(SS_PIN, HIGH);
   #endif
 
-  #if PIN_EXISTS(ONBOARD_SD_CS) && ONBOARD_SD_CS_PIN != SD_SS_PIN
+  #if PIN_EXISTS(ONBOARD_SD_CS) && ONBOARD_SD_CS_PIN != SS_PIN
     OUT_WRITE(ONBOARD_SD_CS_PIN, HIGH);
   #endif
 
@@ -121,11 +118,13 @@ void HAL_init() {
   #endif
 
   USB_Init();                               // USB Initialization
-  USB_Connect(false);                       // USB clear connection
+  USB_Connect(FALSE);                       // USB clear connection
   delay(1000);                              // Give OS time to notice
-  USB_Connect(true);
+  USB_Connect(TRUE);
 
-  TERN_(HAS_SD_HOST_DRIVE, MSC_SD_Init(0)); // Enable USB SD card access
+  #if DISABLED(NO_SD_HOST_DRIVE)
+    MSC_SD_Init(0);                         // Enable USB SD card access
+  #endif
 
   const millis_t usb_timeout = millis() + 2000;
   while (!USB_Configuration && PENDING(millis(), usb_timeout)) {
@@ -137,8 +136,6 @@ void HAL_init() {
   }
 
   HAL_timer_init();
-
-  TERN_(POSTMORTEM_DEBUGGING, install_min_serial()); // Install the min serial handler
 }
 
 // HAL idle task

Marlin/src/HAL/LPC1768/spi_pins.h

@@ -23,7 +23,7 @@
 
 #include "../../core/macros.h"
 
-#if BOTH(SDSUPPORT, HAS_MARLINUI_U8GLIB) && (LCD_PINS_D4 == SD_SCK_PIN || LCD_PINS_ENABLE == SD_MOSI_PIN || DOGLCD_SCK == SD_SCK_PIN || DOGLCD_MOSI == SD_MOSI_PIN)
+#if BOTH(SDSUPPORT, HAS_MARLINUI_U8GLIB) && (LCD_PINS_D4 == SCK_PIN || LCD_PINS_ENABLE == MOSI_PIN || DOGLCD_SCK == SCK_PIN || DOGLCD_MOSI == MOSI_PIN)
   #define LPC_SOFTWARE_SPI  // If the SD card and LCD adapter share the same SPI pins, then software SPI is currently
                             // needed due to the speed and mode required for communicating with each device being different.
                             // This requirement can be removed if the SPI access to these devices is updated to use
@@ -31,24 +31,24 @@
 #endif
 
 /** onboard SD card */
-//#define SD_SCK_PIN        P0_07
+//#define SCK_PIN           P0_07
-//#define SD_MISO_PIN       P0_08
+//#define MISO_PIN          P0_08
-//#define SD_MOSI_PIN       P0_09
+//#define MOSI_PIN          P0_09
-//#define SD_SS_PIN         P0_06
+//#define SS_PIN            P0_06
 /** external */
-#ifndef SD_SCK_PIN
+#ifndef SCK_PIN
-  #define SD_SCK_PIN        P0_15
+  #define SCK_PIN           P0_15
 #endif
-#ifndef SD_MISO_PIN
+#ifndef MISO_PIN
-  #define SD_MISO_PIN       P0_17
+  #define MISO_PIN          P0_17
 #endif
-#ifndef SD_MOSI_PIN
+#ifndef MOSI_PIN
-  #define SD_MOSI_PIN       P0_18
+  #define MOSI_PIN          P0_18
 #endif
-#ifndef SD_SS_PIN
+#ifndef SS_PIN
-  #define SD_SS_PIN         P1_23
+  #define SS_PIN            P1_23
 #endif
 #if !defined(SDSS) || SDSS == P_NC // gets defaulted in pins.h
   #undef SDSS
-  #define SDSS          SD_SS_PIN
+  #define SDSS              SS_PIN
 #endif

Marlin/src/HAL/LPC1768/tft/tft_spi.cpp

@@ -89,7 +89,7 @@ void TFT_SPI::Init() {
   #elif TFT_MISO_PIN == BOARD_SPI2_MISO_PIN
     SPIx.setModule(2);
   #endif
-  SPIx.setClock(SPI_CLOCK_MAX_TFT);
+  SPIx.setClock(SPI_CLOCK_MAX);
   SPIx.setBitOrder(MSBFIRST);
   SPIx.setDataMode(SPI_MODE0);
 }
@@ -125,7 +125,7 @@ uint32_t TFT_SPI::ReadID(uint16_t Reg) {
     }
 
     DataTransferEnd();
-    SPIx.setClock(SPI_CLOCK_MAX_TFT);
+    SPIx.setClock(SPI_CLOCK_MAX);
   #endif
 
   return data >> 7;

Marlin/src/HAL/LPC1768/tft/tft_spi.h

@@ -36,7 +36,7 @@
 
 #define DATASIZE_8BIT    SSP_DATABIT_8
 #define DATASIZE_16BIT   SSP_DATABIT_16
-#define TFT_IO_DRIVER TFT_SPI
+#define TFT_IO TFT_SPI
 
 #define DMA_MINC_ENABLE 1
 #define DMA_MINC_DISABLE 0

Marlin/src/HAL/LPC1768/tft/xpt2046.cpp

@@ -1,9 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 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
@@ -22,7 +19,7 @@
 
 #include "../../../inc/MarlinConfig.h"
 
-#if HAS_TFT_XPT2046 || HAS_TOUCH_BUTTONS
+#if HAS_TFT_XPT2046 || HAS_TOUCH_XPT2046
 
 #include "xpt2046.h"
 #include <SPI.h>

Marlin/src/HAL/LPC1768/tft/xpt2046.h

@@ -1,9 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 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
@@ -28,16 +25,16 @@
 #endif
 
 #ifndef TOUCH_MISO_PIN
-  #define TOUCH_MISO_PIN SD_MISO_PIN
+  #define TOUCH_MISO_PIN MISO_PIN
 #endif
 #ifndef TOUCH_MOSI_PIN
-  #define TOUCH_MOSI_PIN SD_MOSI_PIN
+  #define TOUCH_MOSI_PIN MOSI_PIN
 #endif
 #ifndef TOUCH_SCK_PIN
-  #define TOUCH_SCK_PIN  SD_SCK_PIN
+  #define TOUCH_SCK_PIN  SCK_PIN
 #endif
 #ifndef TOUCH_CS_PIN
-  #define TOUCH_CS_PIN   SD_SS_PIN
+  #define TOUCH_CS_PIN   CS_PIN
 #endif
 #ifndef TOUCH_INT_PIN
   #define TOUCH_INT_PIN  -1

Marlin/src/HAL/LPC1768/timers.h

@@ -152,7 +152,7 @@ FORCE_INLINE static void HAL_timer_disable_interrupt(const uint8_t timer_num) {
 
 // This function is missing from CMSIS
 FORCE_INLINE static bool NVIC_GetEnableIRQ(IRQn_Type IRQn) {
-  return TEST(NVIC->ISER[uint32_t(IRQn) >> 5], uint32_t(IRQn) & 0x1F);
+  return (NVIC->ISER[((uint32_t)IRQn) >> 5] & (1 << ((uint32_t)IRQn) & 0x1F)) != 0;
 }
 
 FORCE_INLINE static bool HAL_timer_interrupt_enabled(const uint8_t timer_num) {

Marlin/src/HAL/LPC1768/u8g/u8g_com_HAL_LPC1768_hw_spi.cpp

@@ -62,13 +62,10 @@
 #include <U8glib.h>
 #include "../../shared/HAL_SPI.h"
 
-#ifndef LCD_SPI_SPEED
+void spiBegin();
-  #ifdef SD_SPI_SPEED
+void spiInit(uint8_t spiRate);
-    #define LCD_SPI_SPEED SD_SPI_SPEED    // Assume SPI speed shared with SD
+void spiSend(uint8_t b);
-  #else
+void spiSend(const uint8_t* buf, size_t n);
-    #define LCD_SPI_SPEED SPI_FULL_SPEED  // Use full speed if SD speed is not supplied
-  #endif
-#endif
 
 uint8_t u8g_com_HAL_LPC1768_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) {
   switch (msg) {
@@ -84,7 +81,10 @@ uint8_t u8g_com_HAL_LPC1768_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val,
       u8g_SetPIOutput(u8g, U8G_PI_RESET);
       u8g_Delay(5);
       spiBegin();
-      spiInit(LCD_SPI_SPEED);
+      #ifndef SPI_SPEED
+        #define SPI_SPEED SPI_FULL_SPEED  // use same SPI speed as SD card
+      #endif
+      spiInit(SPI_SPEED);
       break;
 
     case U8G_COM_MSG_ADDRESS:                     /* define cmd (arg_val = 0) or data mode (arg_val = 1) */