Merge branch 'LulzbotTestBase' into LulzbotUniversalTools

TODO : Sanity checks, Finish DAC mode, Test on Rambo

.gitattributes

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

.github/workflows/test-builds.yml

@@ -36,25 +36,22 @@ jobs:
         # Base Environments
 
         - DUE
-        - DUE_archim
         - esp32
         - linux_native
         - mega2560
-        - at90usb1286_dfu
         - teensy31
         - teensy35
-        - teensy41
         - SAMD51_grandcentral_m4
 
         # 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 +61,38 @@ 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 +114,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

@@ -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
 
 ############
@@ -197,115 +170,110 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1100)
 else ifeq ($(HARDWARE_MOTHERBOARD),1101)
 # Velleman K8400 Controller (derived from 3Drag Controller)
 else ifeq ($(HARDWARE_MOTHERBOARD),1102)
-# Velleman K8600 Controller (Vertex Nano)
+# Velleman K8600 Controller (derived from 3Drag Controller)
 else ifeq ($(HARDWARE_MOTHERBOARD),1103)
-# Velleman K8800 Controller (Vertex Delta)
-else ifeq ($(HARDWARE_MOTHERBOARD),1104)
 # 2PrintBeta BAM&DICE with STK drivers
-else ifeq ($(HARDWARE_MOTHERBOARD),1105)
+else ifeq ($(HARDWARE_MOTHERBOARD),1104)
 # 2PrintBeta BAM&DICE Due with STK drivers
-else ifeq ($(HARDWARE_MOTHERBOARD),1106)
+else ifeq ($(HARDWARE_MOTHERBOARD),1105)
 # MKS BASE v1.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1107)
+else ifeq ($(HARDWARE_MOTHERBOARD),1106)
 # MKS v1.4 with A4982 stepper drivers
-else ifeq ($(HARDWARE_MOTHERBOARD),1108)
+else ifeq ($(HARDWARE_MOTHERBOARD),1107)
 # MKS v1.5 with Allegro A4982 stepper drivers
-else ifeq ($(HARDWARE_MOTHERBOARD),1109)
+else ifeq ($(HARDWARE_MOTHERBOARD),1108)
 # MKS v1.6 with Allegro A4982 stepper drivers
-else ifeq ($(HARDWARE_MOTHERBOARD),1110)
+else ifeq ($(HARDWARE_MOTHERBOARD),1109)
 # MKS BASE 1.0 with Heroic HR4982 stepper drivers
-else ifeq ($(HARDWARE_MOTHERBOARD),1111)
+else ifeq ($(HARDWARE_MOTHERBOARD),1110)
 # MKS GEN v1.3 or 1.4
-else ifeq ($(HARDWARE_MOTHERBOARD),1112)
+else ifeq ($(HARDWARE_MOTHERBOARD),1111)
 # MKS GEN L
-else ifeq ($(HARDWARE_MOTHERBOARD),1113)
+else ifeq ($(HARDWARE_MOTHERBOARD),1112)
 # zrib V2.0 control board (Chinese knock off RAMPS replica)
-else ifeq ($(HARDWARE_MOTHERBOARD),1114)
+else ifeq ($(HARDWARE_MOTHERBOARD),1113)
 # BigTreeTech or BIQU KFB2.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1115)
+else ifeq ($(HARDWARE_MOTHERBOARD),1114)
 # Felix 2.0+ Electronics Board (RAMPS like)
-else ifeq ($(HARDWARE_MOTHERBOARD),1116)
+else ifeq ($(HARDWARE_MOTHERBOARD),1115)
 # Invent-A-Part RigidBoard
-else ifeq ($(HARDWARE_MOTHERBOARD),1117)
+else ifeq ($(HARDWARE_MOTHERBOARD),1116)
 # Invent-A-Part RigidBoard V2
-else ifeq ($(HARDWARE_MOTHERBOARD),1118)
+else ifeq ($(HARDWARE_MOTHERBOARD),1117)
 # Sainsmart 2-in-1 board
-else ifeq ($(HARDWARE_MOTHERBOARD),1119)
+else ifeq ($(HARDWARE_MOTHERBOARD),1118)
 # Ultimaker
-else ifeq ($(HARDWARE_MOTHERBOARD),1120)
+else ifeq ($(HARDWARE_MOTHERBOARD),1119)
 # Ultimaker (Older electronics. Pre 1.5.4. This is rare)
-else ifeq ($(HARDWARE_MOTHERBOARD),1121)
+else ifeq ($(HARDWARE_MOTHERBOARD),1120)
-  MCU              ?= atmega1280
+  MCU ?= atmega1280
-  PROG_MCU         ?= m1280
 
 # Azteeg X3
-else ifeq ($(HARDWARE_MOTHERBOARD),1122)
+else ifeq ($(HARDWARE_MOTHERBOARD),1121)
 # Azteeg X3 Pro
-else ifeq ($(HARDWARE_MOTHERBOARD),1123)
+else ifeq ($(HARDWARE_MOTHERBOARD),1122)
 # Ultimainboard 2.x (Uses TEMP_SENSOR 20)
-else ifeq ($(HARDWARE_MOTHERBOARD),1124)
+else ifeq ($(HARDWARE_MOTHERBOARD),1123)
 # Rumba
-else ifeq ($(HARDWARE_MOTHERBOARD),1125)
+else ifeq ($(HARDWARE_MOTHERBOARD),1124)
 # Raise3D Rumba
-else ifeq ($(HARDWARE_MOTHERBOARD),1126)
+else ifeq ($(HARDWARE_MOTHERBOARD),1125)
 # Rapide Lite RL200 Rumba
-else ifeq ($(HARDWARE_MOTHERBOARD),1127)
+else ifeq ($(HARDWARE_MOTHERBOARD),1126)
 # Formbot T-Rex 2 Plus
-else ifeq ($(HARDWARE_MOTHERBOARD),1128)
+else ifeq ($(HARDWARE_MOTHERBOARD),1127)
 # Formbot T-Rex 3
-else ifeq ($(HARDWARE_MOTHERBOARD),1129)
+else ifeq ($(HARDWARE_MOTHERBOARD),1128)
 # Formbot Raptor
-else ifeq ($(HARDWARE_MOTHERBOARD),1130)
+else ifeq ($(HARDWARE_MOTHERBOARD),1129)
 # Formbot Raptor 2
-else ifeq ($(HARDWARE_MOTHERBOARD),1131)
+else ifeq ($(HARDWARE_MOTHERBOARD),1130)
 # bq ZUM Mega 3D
-else ifeq ($(HARDWARE_MOTHERBOARD),1132)
+else ifeq ($(HARDWARE_MOTHERBOARD),1131)
 # MakeBoard Mini v2.1.2 is a control board sold by MicroMake
-else ifeq ($(HARDWARE_MOTHERBOARD),1133)
+else ifeq ($(HARDWARE_MOTHERBOARD),1132)
 # TriGorilla Anycubic version 1.3 based on RAMPS EFB
-else ifeq ($(HARDWARE_MOTHERBOARD),1134)
+else ifeq ($(HARDWARE_MOTHERBOARD),1133)
 # TriGorilla Anycubic version 1.4 based on RAMPS EFB
-else ifeq ($(HARDWARE_MOTHERBOARD),1135)
+else ifeq ($(HARDWARE_MOTHERBOARD),1134)
 # TriGorilla Anycubic version 1.4 Rev 1.1
-else ifeq ($(HARDWARE_MOTHERBOARD),1136)
+else ifeq ($(HARDWARE_MOTHERBOARD),1135)
 # Creality: Ender-4, CR-8
-else ifeq ($(HARDWARE_MOTHERBOARD),1137)
+else ifeq ($(HARDWARE_MOTHERBOARD),1136)
 # Creality: CR10S, CR20, CR-X
-else ifeq ($(HARDWARE_MOTHERBOARD),1138)
+else ifeq ($(HARDWARE_MOTHERBOARD),1137)
 # Dagoma F5
-else ifeq ($(HARDWARE_MOTHERBOARD),1139)
+else ifeq ($(HARDWARE_MOTHERBOARD),1138)
 # FYSETC F6 1.3
-else ifeq ($(HARDWARE_MOTHERBOARD),1140)
+else ifeq ($(HARDWARE_MOTHERBOARD),1139)
 # FYSETC F6 1.5
-else ifeq ($(HARDWARE_MOTHERBOARD),1141)
+else ifeq ($(HARDWARE_MOTHERBOARD),1140)
 # Duplicator i3 Plus
-else ifeq ($(HARDWARE_MOTHERBOARD),1142)
+else ifeq ($(HARDWARE_MOTHERBOARD),1141)
 # VORON
-else ifeq ($(HARDWARE_MOTHERBOARD),1143)
+else ifeq ($(HARDWARE_MOTHERBOARD),1142)
 # TRONXY V3 1.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1144)
+else ifeq ($(HARDWARE_MOTHERBOARD),1143)
 # Z-Bolt X Series
-else ifeq ($(HARDWARE_MOTHERBOARD),1145)
+else ifeq ($(HARDWARE_MOTHERBOARD),1144)
 # TT OSCAR
-else ifeq ($(HARDWARE_MOTHERBOARD),1146)
+else ifeq ($(HARDWARE_MOTHERBOARD),1145)
 # Overlord/Overlord Pro
-else ifeq ($(HARDWARE_MOTHERBOARD),1147)
+else ifeq ($(HARDWARE_MOTHERBOARD),1146)
 # ADIMLab Gantry v1
-else ifeq ($(HARDWARE_MOTHERBOARD),1148)
+else ifeq ($(HARDWARE_MOTHERBOARD),1147)
 # ADIMLab Gantry v2
-else ifeq ($(HARDWARE_MOTHERBOARD),1149)
+else ifeq ($(HARDWARE_MOTHERBOARD),1148)
 # BIQU Tango V1
-else ifeq ($(HARDWARE_MOTHERBOARD),1150)
+else ifeq ($(HARDWARE_MOTHERBOARD),1149)
 # MKS GEN L V2
-else ifeq ($(HARDWARE_MOTHERBOARD),1151)
+else ifeq ($(HARDWARE_MOTHERBOARD),1150)
-# MKS GEN L V2.1
-else ifeq ($(HARDWARE_MOTHERBOARD),1152)
 # Copymaster 3D
-else ifeq ($(HARDWARE_MOTHERBOARD),1153)
+else ifeq ($(HARDWARE_MOTHERBOARD),1151)
 # Ortur 4
-else ifeq ($(HARDWARE_MOTHERBOARD),1154)
+else ifeq ($(HARDWARE_MOTHERBOARD),1152)
 # Tenlog D3 Hero
-else ifeq ($(HARDWARE_MOTHERBOARD),1155)
+else ifeq ($(HARDWARE_MOTHERBOARD),1153)
 
 #
 # RAMBo and derivatives
@@ -378,11 +346,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
@@ -392,57 +358,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
@@ -452,61 +407,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
@@ -516,60 +460,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
 
@@ -579,8 +514,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)
@@ -611,36 +545,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
@@ -712,23 +637,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)
@@ -770,23 +685,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="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)
@@ -812,20 +721,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
@@ -841,7 +746,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
@@ -942,7 +847,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:
@@ -956,7 +861,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

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -28,25 +28,25 @@
 /**
  * Marlin release version identifier
  */
-#define SHORT_BUILD_VERSION "2.0.7_SX1"
+#define SHORT_BUILD_VERSION "LulzbotUnified - 2.0.6"
 
 /**
  * Verbose version identifier which should contain a reference to the location
  * from where the binary was downloaded or the source code was compiled.
  */
-#define DETAILED_BUILD_VERSION SHORT_BUILD_VERSION " TM3D"
+#define DETAILED_BUILD_VERSION SHORT_BUILD_VERSION " Rev2"
 
 /**
  * The STRING_DISTRIBUTION_DATE represents when the binary file was built,
  * here we define this default string as the date where the latest release
  * version was tagged.
  */
-#define STRING_DISTRIBUTION_DATE "2021-01-03"
+#define STRING_DISTRIBUTION_DATE "2020-08-09"
 
 /**
  * Defines a generic printer name to be output to the LCD after booting Marlin.
  */
-#define MACHINE_NAME "TM3D SX4"
+//#define MACHINE_NAME "3D Printer"
 
 /**
  * The SOURCE_CODE_URL is the location where users will find the Marlin Source
@@ -54,7 +54,7 @@
  * has a distinct Github fork— the Source Code URL should just be the main
  * Marlin repository.
  */
-#define SOURCE_CODE_URL "https://github.com/InsanityAutomation/Marlin/tree/TM_SX4_2.0"
+//#define SOURCE_CODE_URL "https://github.com/MarlinFirmware/Marlin"
 
 /**
  * Default generic printer UUID.
@@ -65,12 +65,14 @@
  * The WEBSITE_URL is the location where users can get more information such as
  * documentation about a specific Marlin release.
  */
-#define WEBSITE_URL "tinymachines3d.com"
+//#define WEBSITE_URL "https://marlinfw.org"
 
 /**
  * Set the vendor info the serial USB interface, if changable
  * Currently only supported by DUE platform
  */
-//#define USB_DEVICE_VENDOR_ID           0x0000
+#if ENABLED(TazPro)
-//#define USB_DEVICE_PRODUCT_ID          0x0000
+  #define USB_DEVICE_VENDOR_ID 0x27b1 // <-- changed
-//#define USB_DEVICE_MANUFACTURE_NAME    WEBSITE_URL
+  #define USB_DEVICE_PRODUCT_ID 0x0001 // <-- changed
+#endif
+//#define  USB_DEVICE_MANUFACTURE_NAME    WEBSITE_URL

Marlin/_Bootscreen.h

@@ -29,65 +29,75 @@
  *  - 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  128
+#define CUSTOM_BOOTSCREEN_BMPWIDTH  60
-#define CUSTOM_BOOTSCREEN_INVERTED
+#define CUSTOM_BOOTSCREEN_BMPHEIGHT 64
 
-const unsigned char custom_start_bmp[] PROGMEM = {
+const unsigned char custom_start_bmp[574] PROGMEM = {
-  B11111101,B01010101,B01010101,B01010101,B01010101,B01010101,B01011111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-  B11111110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-  B11111101,B00000000,B00000000,B00000111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-  B11111110,B00000111,B11000000,B00000101,B01010101,B01010101,B01010101,B01010101,B01010101,B01011111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-  B11111100,B00001010,B00100000,B00000110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+0x0, 0x0, 0x0, 0xc, 0x0, 0x0, 0x0, 0x0,
-  B11111110,B00010100,B00010000,B00000101,B00000000,B00000000,B00000111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+0x0, 0x0, 0x0, 0xc, 0x0, 0x0, 0x0, 0x0,
-  B11111100,B00101000,B00001000,B00000110,B00000111,B11000000,B00000101,B01010101,B01010101,B01010101,B01010101,B01010101,B01011111,B11111111,B11111111,B11111111,
+0x0, 0x0, 0x0, 0x12, 0x0, 0x0, 0x0, 0x0,
-  B11111110,B01010100,B00000100,B00000100,B00001010,B00100000,B00000110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,B11111111,B11111111,B11111111,
+0x0, 0x0, 0x0, 0x23, 0x0, 0x0, 0x0, 0x0,
-  B11111100,B01100000,B00000100,B00000110,B00010100,B00010000,B00000101,B00000000,B00000000,B00000111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+0x0, 0x0, 0x0, 0x21, 0x0, 0x0, 0x0, 0x0,
-  B11111110,B01010000,B00000100,B00000100,B00101000,B00001000,B00000110,B00000111,B11000000,B00000101,B01010101,B01010101,B01010101,B01010101,B01010101,B01011111,
+0x0, 0x0, 0x0, 0x4c, 0x80, 0x0, 0x0, 0x0,
-  B11111100,B01100000,B00000100,B00000110,B01010100,B00000100,B00000100,B00001010,B00100000,B00000110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,
+0x0, 0x0, 0x0, 0x5e, 0x80, 0x0, 0x0, 0x0,
-  B11111110,B01010100,B00000100,B00011100,B01100000,B00000100,B00000110,B00010100,B00010000,B00000101,B00000000,B00000000,B00000000,B00000000,B00000000,B00011111,
+0x0, 0x0, 0x0, 0x92, 0x40, 0x0, 0x0, 0x0,
-  B11111100,B00101000,B00001000,B00101110,B01010000,B00000100,B00000100,B00101000,B00001000,B00000110,B00000111,B11000000,B00000000,B00000001,B11110000,B00111111,
+0x0, 0x0, 0x0, 0xa1, 0x40, 0x0, 0x0, 0x0,
-  B11111110,B00010100,B00010000,B01010100,B01100000,B00000100,B00000110,B01010100,B00000100,B00000100,B00001010,B00100000,B00000000,B00000010,B00001000,B00011111,
+0x0, 0x0, 0x1, 0x21, 0x20, 0x0, 0x0, 0x0,
-  B11111100,B00001010,B00100000,B01100110,B01010100,B00000100,B00011100,B01100000,B00000100,B00000110,B00010100,B00010000,B00000000,B00000101,B00000100,B00111111,
+0x0, 0x0, 0x2, 0x7f, 0x90, 0x0, 0x0, 0x0,
-  B11111110,B00000111,B11000000,B01010100,B00101000,B00001000,B00101110,B01010000,B00000100,B00000100,B00101000,B00001000,B00000000,B00001010,B00000010,B00011111,
+0x0, 0x0, 0x2, 0x0, 0x10, 0x0, 0x0, 0x0,
-  B11111100,B00000000,B00000000,B00101110,B00010100,B00010000,B01010100,B01100000,B00000100,B00000110,B01010100,B00000100,B00000000,B00010101,B00000001,B00111111,
+0x0, 0x0, 0x7, 0xff, 0xf8, 0x0, 0x0, 0x0,
-  B11111110,B00000000,B00000000,B00011100,B00001010,B00100000,B01100110,B01010100,B00000100,B00011100,B01100000,B00000100,B00000000,B00011000,B00000001,B00011111,
+0x0, 0x0, 0x4, 0x0, 0x8, 0x0, 0x0, 0x0,
-  B11111100,B00000000,B00000000,B00000110,B00000111,B11000000,B01010100,B00101000,B00001000,B00101110,B01010000,B00000100,B00000000,B00010100,B00000001,B00111111,
+0x0, 0x0, 0x8, 0x0, 0x4, 0x0, 0x0, 0x0,
-  B11111110,B00000000,B00000000,B00000100,B00000000,B00000000,B00101110,B00010100,B00010000,B01010100,B01100000,B00000100,B00000000,B00011000,B00000001,B00011111,
+0x0, 0x0, 0x8, 0x0, 0x6, 0x0, 0x0, 0x0,
-  B11111100,B11111111,B11111111,B11111110,B00000000,B00000000,B00011100,B00001010,B00100000,B01100110,B01010100,B00000100,B00011100,B00010101,B00000001,B00111111,
+0x0, 0x0, 0x10, 0x0, 0x2, 0x0, 0x0, 0x0,
-  B11111110,B11010101,B01010101,B01010100,B00000000,B00000000,B00000110,B00000111,B11000000,B01010100,B00101000,B00001000,B00101010,B00001010,B00000010,B00011111,
+0x0, 0x0, 0x30, 0x1e, 0x1, 0x0, 0x0, 0x0,
-  B11111100,B10000100,B00010000,B01000110,B00000000,B00000000,B00000100,B00000000,B00000000,B00101110,B00010100,B00010000,B01010001,B00000101,B00000100,B00111111,
+0x0, 0x0, 0x20, 0x7f, 0x81, 0x0, 0x0, 0x0,
-  B11111110,B11000100,B00010000,B01000100,B11111111,B11111111,B11111110,B00000000,B00000000,B00011100,B00001010,B00100000,B01100001,B00000010,B10001000,B00011111,
+0x0, 0x0, 0x41, 0xff, 0xe0, 0x80, 0x0, 0x0,
-  B11111100,B10000100,B00010000,B01000110,B11010101,B01010101,B01010100,B00000000,B00000000,B00000110,B00000111,B11000000,B01010001,B00000001,B11110000,B00111111,
+0x0, 0x0, 0x43, 0xfc, 0xf0, 0x80, 0x0, 0x0,
-  B11111110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000110,B00000000,B00000000,B00000100,B00000000,B00000000,B00101010,B00000000,B00000000,B00011111,
+0x0, 0x0, 0x87, 0x3b, 0x78, 0x40, 0x0, 0x0,
-  B11111100,B11000100,B00010000,B01000110,B11000100,B00010000,B01000100,B11111111,B11111111,B11111110,B00000000,B00000000,B00011100,B00000000,B00000000,B00111111,
+0x0, 0x1, 0x8e, 0xdb, 0xfc, 0x60, 0x0, 0x0,
-  B11111110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000110,B11010101,B01010101,B01010100,B00000000,B00000000,B00000000,B00000000,B00000000,B00011111,
+0x0, 0x1, 0xf, 0xeb, 0xcc, 0x20, 0x0, 0x0,
-  B11111100,B11010101,B01010101,B01010110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,
+0x0, 0x2, 0x1f, 0xed, 0xb6, 0x10, 0x0, 0x0,
-  B11111100,B11111111,B11111111,B11111100,B11000100,B00010000,B01000110,B11000100,B00010000,B01000100,B11111111,B11111111,B11111111,B11111111,B11111111,B10011111,
+0x0, 0x2, 0x1f, 0xde, 0xb6, 0x10, 0x0, 0x0,
-  B11111110,B00000000,B00000000,B00000110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000110,B11010101,B01010101,B01010101,B01010101,B01010101,B10111111,
+0x0, 0x4, 0x39, 0xcd, 0x7f, 0x8, 0x0, 0x0,
-  B11111101,B01010101,B01010101,B01010100,B11010101,B01010101,B01010110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000001,B00000100,B00010000,B10011111,
+0x0, 0x4, 0x36, 0xe0, 0xff, 0x8, 0x0, 0x0,
-  B11111111,B11111111,B11111111,B11111100,B11111111,B11111111,B11111100,B11000100,B00010000,B01000110,B11000100,B00010000,B01000001,B00000100,B00010001,B10111111,
+0x0, 0x8, 0x7e, 0xc0, 0xbb, 0x84, 0x0, 0x0,
-  B11111111,B11111111,B11111111,B11111110,B00000000,B00000000,B00000110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000001,B00000100,B00010000,B10011111,
+0x0, 0x18, 0x7f, 0x0, 0x5d, 0x86, 0x0, 0x0,
-  B11111111,B11111111,B11111111,B11111101,B01010101,B01010101,B01010100,B11010101,B01010101,B01010110,B10000100,B00010000,B01000001,B00000100,B00010000,B10011111,
+0x0, 0x10, 0x7f, 0xc0, 0xed, 0x82, 0x0, 0x0,
-  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111100,B11111111,B11111111,B11111100,B11000100,B00010000,B01000001,B00000100,B00010001,B10111111,
+0x0, 0x20, 0x3c, 0xc0, 0x73, 0x1, 0x0, 0x0,
-  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111110,B00000000,B00000000,B00000110,B10000100,B00010000,B01000001,B00000100,B00010000,B10011111,
+0x0, 0x20, 0x3b, 0x33, 0x7f, 0x1, 0x0, 0x0,
-  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111101,B01010101,B01010101,B01010100,B11010101,B01010101,B01010101,B01010101,B01010101,B10111111,
+0x0, 0x70, 0x1b, 0xe7, 0x7e, 0x3, 0x80, 0x0,
-  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111100,B11111111,B11111111,B11111111,B11111111,B11111111,B10011111,
+0x0, 0xc8, 0x1d, 0xee, 0xde, 0x4, 0xc0, 0x0,
-  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,
+0x0, 0x88, 0xf, 0xde, 0xdc, 0x4, 0x40, 0x0,
-  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111101,B01010101,B01010101,B01010101,B01010101,B01010101,B01011111,
+0x1, 0x24, 0xf, 0xdf, 0x3c, 0x9, 0x20, 0x0,
-  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+0x1, 0x26, 0x7, 0xdb, 0xf8, 0x19, 0x20, 0x0,
-  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+0x2, 0x72, 0x3, 0xe7, 0xf0, 0x13, 0x90, 0x0,
-  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+0x2, 0x51, 0x1, 0xff, 0xe0, 0x22, 0x90, 0x0,
-  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
+0x4, 0x89, 0x0, 0x7f, 0x80, 0x24, 0x48, 0x0,
-  B11100000,B00101110,B11111011,B01111101,B11111011,B11111011,B11001111,B11000001,B11011111,B10111011,B00111110,B11000000,B11100001,B11111110,B00111100,B00011111,
+0x9, 0x4, 0x80, 0x1e, 0x0, 0x48, 0x24, 0x0,
-  B11111101,B11101110,B01111011,B00111001,B11111001,B11110011,B11001111,B10011110,B11011111,B10111011,B00111110,B11011111,B11011110,B11111100,B11011101,B11100111,
+0xb, 0xfe, 0x40, 0x0, 0x0, 0xdf, 0xf4, 0x0,
-  B11111101,B11101110,B00111011,B10111011,B11111001,B11101011,B11010111,B10111111,B01011111,B10111011,B01011110,B11011111,B11011110,B11111101,B11101101,B11110111,
+0x10, 0x0, 0x40, 0x0, 0x0, 0x80, 0x2, 0x0,
-  B11111101,B11101110,B10111011,B11010011,B11111010,B11101011,B10110111,B00111111,B11011111,B10111011,B01001110,B11011111,B11011111,B11111111,B11001101,B11110011,
+0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x0,
-  B11111101,B11101110,B11011011,B11000111,B11111010,B11101011,B10111011,B01111111,B11000000,B00111011,B01101110,B11000000,B11100011,B11111111,B00011101,B11110011,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-  B11111101,B11101110,B11001011,B11101111,B11111010,B11011011,B10111011,B01111111,B11011111,B10111011,B01100110,B11011111,B11111000,B11111111,B11001101,B11110011,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-  B11111101,B11101110,B11101011,B11101111,B11111011,B01011011,B00000011,B00111111,B01011111,B10111011,B01110110,B11011111,B11111110,B01111111,B11101101,B11110011,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-  B11111101,B11101110,B11110011,B11101111,B11111011,B01011011,B01111001,B10111110,B11011111,B10111011,B01111010,B11011111,B11011110,B01111101,B11101101,B11110111,
+0x10, 0x22, 0x10, 0x3c, 0x3c, 0xe, 0x1f, 0x0,
-  B11111101,B11101110,B11110011,B11101111,B11111011,B10111010,B11111101,B10011110,B11011111,B10111011,B01111100,B11011111,B11011110,B11111101,B11001101,B11100111,
+0x10, 0x22, 0x10, 0x4, 0x22, 0x11, 0x4, 0x0,
-  B11111101,B11101110,B11111011,B11101111,B11111011,B10111010,B11111101,B11000001,B11011111,B10111011,B01111110,B11000000,B11100000,B11111110,B00011100,B00011111
+0x10, 0x22, 0x10, 0x8, 0x22, 0x11, 0x4, 0x0,
+0x10, 0x22, 0x10, 0x8, 0x3c, 0x11, 0x4, 0x0,
+0x10, 0x22, 0x10, 0x10, 0x22, 0x11, 0x4, 0x0,
+0x10, 0x22, 0x10, 0x20, 0x22, 0x11, 0x4, 0x0,
+0x1e, 0x1c, 0x1e, 0x3c, 0x3c, 0xe, 0x4, 0x0,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0
 };

Marlin/_Statusscreen.h

@@ -1,74 +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            3
-#define STATUS_LOGO_WIDTH       24
-
-const unsigned char status_logo_bmp[] PROGMEM = {
-  B11111111,B11111111,B11111111,
-  B10000000,B00000000,B00000001,
-  B10001110,B00000000,B11100001,
-  B10011111,B00000001,B11110001,
-  B10010011,B10000001,B00111001,
-  B10011111,B10000001,B11111001,
-  B10011111,B10000001,B11111001,
-  B10011111,B10111001,B11111001,
-  B10001111,B00101000,B11110001,
-  B10000000,B00111000,B00000001,
-  B10000000,B00000000,B00000001,
-  B10011111,B11111111,B11111001,
-  B10010001,B01110100,B10011001,
-  B10011011,B00000110,B10101001,
-  B10011011,B01010100,B10101001,
-  B10011011,B01010110,B10101001,
-  B10011011,B01010100,B10011001,
-  B10011111,B11111111,B11111001,
-  B11111111,B11111111,B11111111
-};
-
-//
-// Use default bitmaps
-//
-#define STATUS_HOTEND_ANIM
-#define STATUS_BED_ANIM
-#if HOTENDS < 2
-  #define STATUS_LOGO_X          8
-  #define STATUS_HEATERS_X      40
-  #define STATUS_BED_X          72
-#else
-  #define STATUS_LOGO_X          0
-  #define STATUS_HEATERS_X      32
-  #define STATUS_BED_X          80
-#endif

Marlin/src/HAL/AVR/HAL.h

@@ -15,7 +15,6 @@
  *
  * 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
 
@@ -82,29 +81,54 @@ typedef int8_t pin_t;
 
 // Serial ports
 #ifdef USBCON
-  #define MYSERIAL0 TERN(BLUETOOTH, bluetoothSerial, Serial)
+  #if ENABLED(BLUETOOTH)
+    #define MYSERIAL0 bluetoothSerial
+  #else
+    #define MYSERIAL0 Serial
+  #endif
+  #define NUM_SERIAL 1
 #else
   #if !WITHIN(SERIAL_PORT, -1, 3)
     #error "SERIAL_PORT must be from -1 to 3. Please update your configuration."
   #endif
+
   #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."
+    #elif SERIAL_PORT_2 == SERIAL_PORT
+      #error "SERIAL_PORT_2 must be different than SERIAL_PORT. Please update your configuration."
     #endif
     #define MYSERIAL1 customizedSerial2
+    #define NUM_SERIAL 2
+  #else
+    #define NUM_SERIAL 1
   #endif
 #endif
 
-#ifdef LCD_SERIAL_PORT
+#ifdef DGUS_SERIAL_PORT
-  #if !WITHIN(LCD_SERIAL_PORT, -1, 3)
+  #if !WITHIN(DGUS_SERIAL_PORT, -1, 3)
-    #error "LCD_SERIAL_PORT must be from -1 to 3. Please update your configuration."
+    #error "DGUS_SERIAL_PORT must be from -1 to 3. Please update your configuration."
+  #elif DGUS_SERIAL_PORT == SERIAL_PORT
+    #error "DGUS_SERIAL_PORT must be different than SERIAL_PORT. Please update your configuration."
+  #elif defined(SERIAL_PORT_2) && DGUS_SERIAL_PORT == SERIAL_PORT_2
+    #error "DGUS_SERIAL_PORT must be different than SERIAL_PORT_2. Please update your configuration."
   #endif
-  #define LCD_SERIAL lcdSerial
+  #define DGUS_SERIAL internalDgusSerial
-  #if HAS_DGUS_LCD
+
-    #define SERIAL_GET_TX_BUFFER_FREE() LCD_SERIAL.get_tx_buffer_free()
+  #define DGUS_SERIAL_GET_TX_BUFFER_FREE DGUS_SERIAL.get_tx_buffer_free
+#endif
+
+#ifdef ANYCUBIC_LCD_SERIAL_PORT
+  #if !WITHIN(ANYCUBIC_LCD_SERIAL_PORT, -1, 3)
+    #error "ANYCUBIC_LCD_SERIAL_PORT must be from -1 to 3. Please update your configuration."
+  #elif ANYCUBIC_LCD_SERIAL_PORT == SERIAL_PORT
+    #error "ANYCUBIC_LCD_SERIAL_PORT must be different than SERIAL_PORT. Please update your configuration."
+  #elif defined(SERIAL_PORT_2) && ANYCUBIC_LCD_SERIAL_PORT == SERIAL_PORT_2
+    #error "ANYCUBIC_LCD_SERIAL_PORT must be different than SERIAL_PORT_2. Please update your configuration."
   #endif
+  #define ANYCUBIC_LCD_SERIAL anycubicLcdSerial
 #endif
 
 // ------------------------
@@ -120,18 +144,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.h

@@ -48,11 +48,11 @@
 
   // These are macros to build serial port register names for the selected SERIAL_PORT (C preprocessor
   // requires two levels of indirection to expand macro values properly)
-  #define SERIAL_REGNAME(registerbase,number,suffix) _SERIAL_REGNAME(registerbase,number,suffix)
+  #define SERIAL_REGNAME(registerbase,number,suffix) SERIAL_REGNAME_INTERNAL(registerbase,number,suffix)
   #if SERIAL_PORT == 0 && (!defined(UBRR0H) || !defined(UDR0)) // use un-numbered registers if necessary
-    #define _SERIAL_REGNAME(registerbase,number,suffix) registerbase##suffix
+    #define SERIAL_REGNAME_INTERNAL(registerbase,number,suffix) registerbase##suffix
   #else
-    #define _SERIAL_REGNAME(registerbase,number,suffix) registerbase##number##suffix
+    #define SERIAL_REGNAME_INTERNAL(registerbase,number,suffix) registerbase##number##suffix
   #endif
 
   // Registers used by MarlinSerial class (expanded depending on selected serial port)
@@ -217,12 +217,10 @@
       static ring_buffer_pos_t available();
       static void write(const uint8_t c);
       static void flushTX();
-      #if HAS_DGUS_LCD
+      #ifdef DGUS_SERIAL_PORT
         static ring_buffer_pos_t get_tx_buffer_free();
       #endif
 
-      static inline bool emergency_parser_enabled() { return Cfg::EMERGENCYPARSER; }
-
       FORCE_INLINE static uint8_t dropped() { return Cfg::DROPPED_RX ? rx_dropped_bytes : 0; }
       FORCE_INLINE static uint8_t buffer_overruns() { return Cfg::RX_OVERRUNS ? rx_buffer_overruns : 0; }
       FORCE_INLINE static uint8_t framing_errors() { return Cfg::RX_FRAMING_ERRORS ? rx_framing_errors : 0; }
@@ -280,50 +278,55 @@
 
 #endif // !USBCON
 
-#ifdef MMU2_SERIAL_PORT
+#ifdef INTERNAL_SERIAL_PORT
   template <uint8_t serial>
-  struct MMU2SerialCfg {
+  struct MarlinInternalSerialCfg {
     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_OVERRUNS       = 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;
   };
 
-  extern MarlinSerial<MMU2SerialCfg<MMU2_SERIAL_PORT>> mmuSerial;
+  extern MarlinSerial<MarlinInternalSerialCfg<INTERNAL_SERIAL_PORT>> internalSerial;
 #endif
 
-#ifdef LCD_SERIAL_PORT
+#ifdef DGUS_SERIAL_PORT
-
   template <uint8_t serial>
-  struct LCDSerialCfg {
+  struct MarlinInternalSerialCfg {
-    static constexpr int PORT                 = serial;
+    static constexpr int PORT               = serial;
-    static constexpr bool XONOFF              = false;
+    static constexpr unsigned int RX_SIZE   = DGUS_RX_BUFFER_SIZE;
-    static constexpr bool EMERGENCYPARSER     = ENABLED(EMERGENCY_PARSER);
+    static constexpr unsigned int TX_SIZE   = DGUS_TX_BUFFER_SIZE;
-    static constexpr bool DROPPED_RX          = false;
+    static constexpr bool XONOFF            = false;
-    static constexpr bool RX_FRAMING_ERRORS   = false;
+    static constexpr bool EMERGENCYPARSER   = false;
-    static constexpr bool MAX_RX_QUEUED       = false;
+    static constexpr bool DROPPED_RX        = false;
-    #if HAS_DGUS_LCD
+    static constexpr bool RX_OVERRUNS       = BOTH(HAS_DGUS_LCD, DGUS_SERIAL_STATS_RX_BUFFER_OVERRUNS);
-      static constexpr unsigned int RX_SIZE   = DGUS_RX_BUFFER_SIZE;
+    static constexpr bool RX_FRAMING_ERRORS = false;
-      static constexpr unsigned int TX_SIZE   = DGUS_TX_BUFFER_SIZE;
+    static constexpr bool MAX_RX_QUEUED     = false;
-      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
   };
 
-  extern MarlinSerial<LCDSerialCfg<LCD_SERIAL_PORT>> lcdSerial;
+  extern MarlinSerial<MarlinInternalSerialCfg<DGUS_SERIAL_PORT>> internalDgusSerial;
+#endif
 
+#ifdef ANYCUBIC_LCD_SERIAL_PORT
+  template <uint8_t serial>
+  struct AnycubicLcdSerialCfg {
+    static constexpr int PORT               = serial;
+    static constexpr unsigned int RX_SIZE   = 64;
+    static constexpr unsigned int TX_SIZE   = 128;
+    static constexpr bool XONOFF            = false;
+    static constexpr bool EMERGENCYPARSER   = false;
+    static constexpr bool DROPPED_RX        = false;
+    static constexpr bool RX_OVERRUNS       = false;
+    static constexpr bool RX_FRAMING_ERRORS = false;
+    static constexpr bool MAX_RX_QUEUED     = false;
+  };
+
+  extern MarlinSerial<AnycubicLcdSerialCfg<ANYCUBIC_LCD_SERIAL_PORT>> anycubicLcdSerial;
 #endif
 
 // Use the UART for Bluetooth in AT90USB configurations

Marlin/src/HAL/AVR/Servo.cpp

@@ -48,6 +48,7 @@
  * readMicroseconds()    - Get the last-written servo pulse width in microseconds.
  * attached()            - Return true if a servo is attached.
  * detach()              - Stop an attached servo from pulsing its i/o pin.
+ *
  */
 
 #ifdef __AVR__

Marlin/src/HAL/AVR/ServoTimers.h

@@ -59,12 +59,10 @@
 // Say which 16 bit timers can be used and in what order
 #if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
   //#define _useTimer1
+  #define _useTimer3
   #define _useTimer4
-  #if NUM_SERVOS > SERVOS_PER_TIMER
+  #if !HAS_MOTOR_CURRENT_PWM
-    #define _useTimer3
+    #define _useTimer5 // Timer 5 is used for motor current PWM and can't be used for servos.
-    #if !HAS_MOTOR_CURRENT_PWM && SERVOS > 2 * SERVOS_PER_TIMER
-      #define _useTimer5 // Timer 5 is used for motor current PWM and can't be used for servos.
-    #endif
   #endif
 #elif defined(__AVR_ATmega32U4__)
   #define _useTimer3

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

@@ -29,17 +29,11 @@
 
 #include <avr/io.h>
 
-#if defined(__AVR_AT90USB1287__) || defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB1286P__) || defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB646P__) || defined(__AVR_AT90USB647__)
+#define AVR_AT90USB1286_FAMILY (defined(__AVR_AT90USB1287__) || defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB1286P__) || defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB646P__) || defined(__AVR_AT90USB647__))
-  #define AVR_AT90USB1286_FAMILY 1
+#define AVR_ATmega1284_FAMILY (defined(__AVR_ATmega644__) || defined(__AVR_ATmega644P__) || defined(__AVR_ATmega644PA__) || defined(__AVR_ATmega1284P__))
-#elif defined(__AVR_ATmega644__) || defined(__AVR_ATmega644P__) || defined(__AVR_ATmega644PA__) || defined(__AVR_ATmega1284P__)
+#define AVR_ATmega2560_FAMILY (defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__))
-  #define AVR_ATmega1284_FAMILY 1
+#define AVR_ATmega2561_FAMILY (defined(__AVR_ATmega1281__) || defined(__AVR_ATmega2561__))
-#elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
+#define AVR_ATmega328_FAMILY (defined(__AVR_ATmega168__) || defined(__AVR_ATmega328__) || defined(__AVR_ATmega328P__))
-  #define AVR_ATmega2560_FAMILY 1
-#elif defined(__AVR_ATmega1281__) || defined(__AVR_ATmega2561__)
-  #define AVR_ATmega2561_FAMILY 1
-#elif defined(__AVR_ATmega168__) || defined(__AVR_ATmega328__) || defined(__AVR_ATmega328P__)
-  #define AVR_ATmega328_FAMILY 1
-#endif
 
 /**
  * Include Ports and Functions

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

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

Marlin/src/HAL/AVR/pinsDebug.h

@@ -26,9 +26,7 @@
 
 #define NUMBER_PINS_TOTAL NUM_DIGITAL_PINS
 
-#if MB(BQ_ZUM_MEGA_3D, MIGHTYBOARD_REVE, MINIRAMBO, SCOOVO_X9H, TRIGORILLA_14)
+#define AVR_ATmega2560_FAMILY_PLUS_70 MB(BQ_ZUM_MEGA_3D, MIGHTYBOARD_REVE, MINIRAMBO, SCOOVO_X9H)
-  #define AVR_ATmega2560_FAMILY_PLUS_70 1
-#endif
 
 #if AVR_AT90USB1286_FAMILY
 

Marlin/src/HAL/AVR/pinsDebug_plus_70.h

@@ -22,12 +22,15 @@
  * Structures for 2560 family boards that use more than 70 pins
  */
 
-#if MB(BQ_ZUM_MEGA_3D, MINIRAMBO, SCOOVO_X9H, TRIGORILLA_14)
+#undef NUM_DIGITAL_PINS
-  #undef NUM_DIGITAL_PINS
+#if MB(BQ_ZUM_MEGA_3D)
   #define NUM_DIGITAL_PINS            85
 #elif MB(MIGHTYBOARD_REVE)
-  #undef NUM_DIGITAL_PINS
   #define NUM_DIGITAL_PINS            80
+#elif MB(MINIRAMBO)
+  #define NUM_DIGITAL_PINS            85
+#elif MB(SCOOVO_X9H)
+  #define NUM_DIGITAL_PINS            85
 #endif
 
 #define PA 1

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/AVR/timers.h

@@ -15,7 +15,6 @@
  *
  * 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
 

Marlin/src/HAL/AVR/u8g_com_HAL_AVR_sw_spi.cpp

@@ -57,7 +57,7 @@
 
 #include "../../inc/MarlinConfigPre.h"
 
-#if HAS_MARLINUI_U8GLIB
+#if HAS_GRAPHICAL_LCD
 
 #include "../shared/Marduino.h"
 #include "../shared/Delay.h"
@@ -189,5 +189,5 @@ uint8_t u8g_com_HAL_AVR_sw_sp_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void
   return 1;
 }
 
-#endif // HAS_MARLINUI_U8GLIB
+#endif // HAS_GRAPHICAL_LCD
 #endif // ARDUINO_ARCH_SAM

Marlin/src/HAL/DUE/HAL.cpp

@@ -19,7 +19,9 @@
  */
 
 /**
- * HAL for Arduino Due and compatible (SAM3X8E)
+ * Description: HAL for Arduino Due and compatible (SAM3X8E)
+ *
+ * For ARDUINO_ARCH_SAM
  */
 
 #ifdef ARDUINO_ARCH_SAM

Marlin/src/HAL/DUE/HAL.h

@@ -22,7 +22,9 @@
 #pragma once
 
 /**
- * HAL for Arduino Due and compatible (SAM3X8E)
+ * Description: HAL for Arduino Due and compatible (SAM3X8E)
+ *
+ * For ARDUINO_ARCH_SAM
  */
 
 #define CPU_32_BIT
@@ -36,36 +38,59 @@
 
 #include <stdint.h>
 
-#define _MSERIAL(X) Serial##X
-#define MSERIAL(X) _MSERIAL(X)
-#define Serial0 Serial
-
 // Define MYSERIAL0/1 before MarlinSerial includes!
 #if SERIAL_PORT == -1 || ENABLED(EMERGENCY_PARSER)
   #define MYSERIAL0 customizedSerial1
-#elif WITHIN(SERIAL_PORT, 0, 3)
+#elif SERIAL_PORT == 0
-  #define MYSERIAL0 MSERIAL(SERIAL_PORT)
+  #define MYSERIAL0 Serial
+#elif SERIAL_PORT == 1
+  #define MYSERIAL0 Serial1
+#elif SERIAL_PORT == 2
+  #define MYSERIAL0 Serial2
+#elif SERIAL_PORT == 3
+  #define MYSERIAL0 Serial3
 #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)
+  #if SERIAL_PORT_2 == SERIAL_PORT
+    #error "SERIAL_PORT_2 must be different from SERIAL_PORT. Please update your configuration."
+  #elif SERIAL_PORT_2 == -1 || ENABLED(EMERGENCY_PARSER)
     #define MYSERIAL1 customizedSerial2
-  #elif WITHIN(SERIAL_PORT_2, 0, 3)
+  #elif SERIAL_PORT_2 == 0
-    #define MYSERIAL1 MSERIAL(SERIAL_PORT_2)
+    #define MYSERIAL1 Serial
+  #elif SERIAL_PORT_2 == 1
+    #define MYSERIAL1 Serial1
+  #elif SERIAL_PORT_2 == 2
+    #define MYSERIAL1 Serial2
+  #elif SERIAL_PORT_2 == 3
+    #define MYSERIAL1 Serial3
   #else
     #error "SERIAL_PORT_2 must be from -1 to 3. Please update your configuration."
   #endif
+  #define NUM_SERIAL 2
+#else
+  #define NUM_SERIAL 1
 #endif
 
-#ifdef LCD_SERIAL_PORT
+#ifdef DGUS_SERIAL_PORT
-  #if LCD_SERIAL_PORT == -1
+  #if DGUS_SERIAL_PORT == SERIAL_PORT
-    #define LCD_SERIAL lcdSerial
+    #error "DGUS_SERIAL_PORT must be different from SERIAL_PORT. Please update your configuration."
-  #elif WITHIN(LCD_SERIAL_PORT, 0, 3)
+  #elif defined(SERIAL_PORT_2) && DGUS_SERIAL_PORT == SERIAL_PORT_2
-    #define LCD_SERIAL MSERIAL(LCD_SERIAL_PORT)
+    #error "DGUS_SERIAL_PORT must be different than SERIAL_PORT_2. Please update your configuration."
+  #elif DGUS_SERIAL_PORT == -1
+    #define DGUS_SERIAL internalDgusSerial
+  #elif DGUS_SERIAL_PORT == 0
+    #define DGUS_SERIAL Serial
+  #elif DGUS_SERIAL_PORT == 1
+    #define DGUS_SERIAL Serial1
+  #elif DGUS_SERIAL_PORT == 2
+    #define DGUS_SERIAL Serial2
+  #elif DGUS_SERIAL_PORT == 3
+    #define DGUS_SERIAL Serial3
   #else
-    #error "LCD_SERIAL_PORT must be from -1 to 3. Please update your configuration."
+    #error "DGUS_SERIAL_PORT must be from -1 to 3. Please update your configuration."
   #endif
 #endif
 
@@ -105,15 +130,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)
@@ -153,16 +176,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_SPI.cpp

@@ -30,7 +30,7 @@
  */
 
 /**
- * HAL for Arduino Due and compatible (SAM3X8E)
+ * Description: HAL for Arduino Due and compatible (SAM3X8E)
  *
  * For ARDUINO_ARCH_SAM
  */
@@ -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,15 +225,15 @@
   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;
@@ -245,15 +245,15 @@
   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_4cycles(spiDelayCyclesX4);
 
-      b |= (READ(SD_MISO_PIN) != 0);
+      b |= (READ(MISO_PIN) != 0);
 
-      WRITE(SD_SCK_PIN, LOW);
+      WRITE(SCK_PIN, LOW);
       __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);
     }
@@ -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,27 +575,27 @@
 
       // 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);
       SPI_Enable(SPI0);
 
       SET_OUTPUT(DAC0_SYNC);
-      #if HAS_MULTI_EXTRUDER
+      #if EXTRUDERS > 1
         SET_OUTPUT(DAC1_SYNC);
         WRITE(DAC1_SYNC, HIGH);
       #endif
@@ -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);
 
@@ -759,6 +759,7 @@
      *
      *  All of the above can be avoided by defining FORCE_SOFT_SPI to force the
      *  display to use software SPI.
+     *
      */
 
     void spiInit(uint8_t spiRate=6) {  // Default to slowest rate if not specified)

Marlin/src/HAL/DUE/MarlinSerial.h

@@ -122,8 +122,6 @@ public:
   static void write(const uint8_t c);
   static void flushTX();
 
-  static inline bool emergency_parser_enabled() { return Cfg::EMERGENCYPARSER; }
-
   FORCE_INLINE static uint8_t dropped() { return Cfg::DROPPED_RX ? rx_dropped_bytes : 0; }
   FORCE_INLINE static uint8_t buffer_overruns() { return Cfg::RX_OVERRUNS ? rx_buffer_overruns : 0; }
   FORCE_INLINE static uint8_t framing_errors() { return Cfg::RX_FRAMING_ERRORS ? rx_framing_errors : 0; }

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

@@ -52,23 +52,25 @@
  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
  */
 
 #ifdef __SAM3X8E__
 
 #include "../../../inc/MarlinConfigPre.h"
 
-#if HAS_MARLINUI_U8GLIB
+#if HAS_GRAPHICAL_LCD
 
 #include <U8glib.h>
 
 #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 +101,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) */
@@ -139,6 +145,6 @@ uint8_t u8g_com_HAL_DUE_shared_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_va
   return 1;
 }
 
-#endif // HAS_MARLINUI_U8GLIB
+#endif // HAS_GRAPHICAL_LCD
 
-#endif // __SAM3X8E__
+#endif //__SAM3X8E__

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

@@ -145,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

@@ -57,7 +57,10 @@
 
 #include "../../../inc/MarlinConfigPre.h"
 
-#if HAS_MARLINUI_U8GLIB && DISABLED(U8GLIB_ST7920)
+#if HAS_GRAPHICAL_LCD && DISABLED(U8GLIB_ST7920)
+
+#undef SPI_SPEED
+#define SPI_SPEED 2  // About 2 MHz
 
 #include "u8g_com_HAL_DUE_sw_spi_shared.h"
 
@@ -141,5 +144,5 @@ uint8_t u8g_com_HAL_DUE_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void
   return 1;
 }
 
-#endif // HAS_MARLINUI_U8GLIB && !U8GLIB_ST7920
+#endif // HAS_GRAPHICAL_LCD && !U8GLIB_ST7920
 #endif // ARDUINO_ARCH_SAM

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

@@ -57,7 +57,7 @@
 
 #include "../../../inc/MarlinConfigPre.h"
 
-#if HAS_MARLINUI_U8GLIB
+#if HAS_GRAPHICAL_LCD
 
 #include "../../shared/Delay.h"
 
@@ -108,5 +108,5 @@ void u8g_spiSend_sw_DUE_mode_3(uint8_t val) { // 3.5MHz
   }
 }
 
-#endif // HAS_MARLINUI_U8GLIB
+#endif // HAS_GRAPHICAL_LCD
 #endif // ARDUINO_ARCH_SAM

Marlin/src/HAL/DUE/eeprom_flash.cpp

@@ -53,6 +53,7 @@
  * per page. We can't emulate EE endurance with FLASH for all
  * bytes, but we can emulate endurance for a given percent of
  * bytes.
+ *
  */
 
 //#define EE_EMU_DEBUG
@@ -60,7 +61,7 @@
 #define EEPROMSize     4096
 #define PagesPerGroup   128
 #define GroupCount        2
-#define PageSize        256U
+#define PageSize        256u
 
  /* Flash storage */
 typedef struct FLASH_SECTOR {
@@ -996,7 +997,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

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

Marlin/src/HAL/DUE/pinsDebug.h

@@ -179,4 +179,5 @@ void pwm_details(int32_t pin) {
  * ----------------+--------
  *  ID             |  PB11
  *  VBOF           |  PB10
+ *
  */

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

@@ -21,7 +21,9 @@
  */
 
 /**
- * HAL Timers for Arduino Due and compatible (SAM3X8E)
+ * Description: HAL for Arduino Due and compatible (SAM3X8E)
+ *
+ * For ARDUINO_ARCH_SAM
  */
 
 #ifdef ARDUINO_ARCH_SAM

Marlin/src/HAL/DUE/timers.h

@@ -21,7 +21,9 @@
 #pragma once
 
 /**
- * HAL Timers for Arduino Due and compatible (SAM3X8E)
+ * HAL for Arduino Due and compatible (SAM3X8E)
+ *
+ * For ARDUINO_ARCH_SAM
  */
 
 #include <stdint.h>

Marlin/src/HAL/DUE/upload_extra_script.py

@@ -14,5 +14,5 @@ if current_OS == 'Windows':
 
 	# Use bossac.exe on Windows
 	env.Replace(
-	    UPLOADCMD="bossac --info --unlock --write --verify --reset --erase -U false --boot $SOURCE"
+	    UPLOADCMD="bossac --info --unlock --write --verify --reset --erase -U false --boot"
 	)

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

@@ -93,5 +93,5 @@
 #define USB_VBOF_GPIO               (PIO_PB10_IDX)
 #define USB_VBOF_FLAGS              (PIO_PERIPH_A | PIO_DEFAULT)
 /*! Active level of the USB_VBOF output pin. */
-#define USB_VBOF_ACTIVE_STATE       LOW
+#define USB_VBOF_ACTIVE_LEVEL       LOW
 /* ------------------------------------------------------------------------ */

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

@@ -173,11 +173,11 @@
 #   define __always_inline   __forceinline
 #elif (defined __GNUC__)
 #ifdef __always_inline
-# undef __always_inline
+#	undef __always_inline
 #endif
-# define __always_inline   inline __attribute__((__always_inline__))
+#	define __always_inline   inline __attribute__((__always_inline__))
 #elif (defined __ICCARM__)
-# define __always_inline   _Pragma("inline=forced")
+#	define __always_inline   _Pragma("inline=forced")
 #endif
 
 /**
@@ -188,11 +188,11 @@
  * heuristics and not inline the function.
  */
 #ifdef __CC_ARM
-# define __no_inline   __attribute__((noinline))
+#   define __no_inline   __attribute__((noinline))
 #elif (defined __GNUC__)
-# define __no_inline   __attribute__((__noinline__))
+#	define __no_inline   __attribute__((__noinline__))
 #elif (defined __ICCARM__)
-# define __no_inline   _Pragma("inline=never")
+#	define __no_inline   _Pragma("inline=never")
 #endif
 
 /*! \brief This macro is used to test fatal errors.
@@ -211,9 +211,9 @@
 #  else
 #undef TEST_SUITE_DEFINE_ASSERT_MACRO
 #    define Assert(expr) \
-  {\
+	{\
-    if (!(expr)) while (true);\
+		if (!(expr)) while (true);\
-  }
+	}
 #  endif
 #else
 #  define Assert(expr) ((void) 0)
@@ -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
@@ -1106,16 +1106,17 @@ static inline uint16_t convert_byte_array_to_16_bit(uint8_t *data)
 /* Converts a 8 Byte array into a 32-Bit value */
 static inline uint32_t convert_byte_array_to_32_bit(uint8_t *data)
 {
-  union
+	union
-  {
+	{
-    uint32_t u32;
+		uint32_t u32;
-    uint8_t u8[8];
+		uint8_t u8[8];
-  }long_addr;
+	}long_addr;
-  uint8_t index;
+	uint8_t index;
-  for (index = 0; index < 4; index++) {
+	for (index = 0; index < 4; index++)
-    long_addr.u8[index] = *data++;
+	{
-  }
+		long_addr.u8[index] = *data++;
-  return long_addr.u32;
+	}
+	return long_addr.u32;
 }
 
 /**

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

@@ -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;
     }
@@ -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/HAL.cpp

@@ -86,7 +86,7 @@ volatile int numPWMUsed = 0,
 
 #endif
 
-void HAL_init() { TERN_(I2S_STEPPER_STREAM, i2s_init()); }
+void HAL_init() { i2s_init(); }
 
 void HAL_init_board() {
 

Marlin/src/HAL/ESP32/HAL.h

@@ -15,12 +15,11 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
  */
 #pragma once
 
 /**
- * HAL for Espressif ESP32 WiFi
+ * Description: HAL for Espressif ESP32 WiFi
  */
 
 #define CPU_32_BIT
@@ -59,6 +58,9 @@ extern portMUX_TYPE spinlock;
   #else
     #define MYSERIAL1 webSocketSerial
   #endif
+  #define NUM_SERIAL 2
+#else
+  #define NUM_SERIAL 1
 #endif
 
 #define CRITICAL_SECTION_START() portENTER_CRITICAL(&spinlock)
@@ -96,20 +98,12 @@ 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);
 
@@ -163,14 +157,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/WebSocketSerial.cpp

@@ -86,7 +86,7 @@ int RingBuffer::read() {
 ring_buffer_pos_t RingBuffer::read(uint8_t *buffer) {
    ring_buffer_pos_t len = available();
 
-  for (ring_buffer_pos_t i = 0; read_index != write_index; i++) {
+  for(ring_buffer_pos_t i = 0; read_index != write_index; i++) {
     buffer[i] = data[read_index];
     read_index = NEXT_INDEX(read_index, size);
   }
@@ -139,8 +139,9 @@ size_t WebSocketSerial::write(const uint8_t c) {
 
 size_t WebSocketSerial::write(const uint8_t* buffer, size_t size) {
   size_t written = 0;
-  for (size_t i = 0; i < size; i++)
+  for(size_t i = 0; i < size; i++) {
     written += write(buffer[i]);
+  }
   return written;
 }
 

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/ota.h

@@ -15,7 +15,6 @@
  *
  * 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
 

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.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;
@@ -91,11 +97,9 @@ typedef uint64_t hal_timer_t;
   #define HAL_PWM_TIMER_ISR() extern "C" void pwmTC_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();
-}
 
 // ------------------------
 // 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,22 +23,12 @@
 
 #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
@@ -48,7 +38,7 @@
 
 // String helper
 #ifndef PGMSTR
-  #define PGMSTR(NAM,STR) const char NAM[] = STR
+  #define PGMSTR(NAM,STR) constexpr char NAM[] = STR
 #endif
 
 inline void watchdog_refresh() {

Marlin/src/HAL/LINUX/HAL.cpp

@@ -27,13 +27,18 @@
 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>
@@ -62,6 +62,7 @@ uint8_t _getc();
 
 extern HalSerial usb_serial;
 #define MYSERIAL0 usb_serial
+#define NUM_SERIAL 1
 
 #define ST7920_DELAY_1 DELAY_NS(600)
 #define ST7920_DELAY_2 DELAY_NS(750)
@@ -79,16 +80,10 @@ extern HalSerial 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,8 +102,6 @@ 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);

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/include/Arduino.h

@@ -67,11 +67,8 @@ 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" {
+extern "C" void GpioDisableInt(uint32_t port, uint32_t pin);
-  void GpioEnableInt(uint32_t port, uint32_t pin, uint32_t mode);
-  void GpioDisableInt(uint32_t port, uint32_t pin);
-}
 
 // Program Memory
 #define pgm_read_ptr(addr)        (*((void**)(addr)))
@@ -95,7 +92,9 @@ using std::memcpy;
 #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

@@ -33,6 +33,7 @@
  * Generic RingBuffer
  * T type of the buffer array
  * S size of the buffer (must be power of 2)
+ *
  */
 template <typename T, uint32_t S> class RingBuffer {
 public:
@@ -78,7 +79,6 @@ public:
 
   #if ENABLED(EMERGENCY_PARSER)
     EmergencyParser::State emergency_state;
-    static inline bool emergency_parser_enabled() { return true; }
   #endif
 
   HalSerial() { host_connected = true; }

Marlin/src/HAL/LINUX/main.cpp

@@ -19,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 (;;) {
@@ -65,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);
@@ -87,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;
@@ -106,7 +107,7 @@ int main() {
   std::thread write_serial (write_serial_thread);
   std::thread read_serial (read_serial_thread);
 
-  #ifdef MYSERIAL0
+  #if NUM_SERIAL > 0
     MYSERIAL0.begin(BAUDRATE);
     SERIAL_ECHOLNPGM("x86_64 Initialized");
     SERIAL_FLUSHTX();

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/servo_private.h

@@ -45,6 +45,7 @@
  *           Version 2 Copyright (c) 2009 Michael Margolis.  All right reserved.
  *
  * The only modification was to update/delete macros to match the LPC176x.
+ *
  */
 
 #include <stdint.h>

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_GRAPHICAL_LCD, 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/HAL.cpp

@@ -32,13 +32,18 @@
 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

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,35 +63,58 @@ extern "C" volatile uint32_t _millis;
   #define ST7920_DELAY_3 DELAY_NS(750)
 #endif
 
-#define _MSERIAL(X) MSerial##X
-#define MSERIAL(X) _MSERIAL(X)
-#define MSerial0 MSerial
-
 #if SERIAL_PORT == -1
   #define MYSERIAL0 UsbSerial
-#elif WITHIN(SERIAL_PORT, 0, 3)
+#elif SERIAL_PORT == 0
-  #define MYSERIAL0 MSERIAL(SERIAL_PORT)
+  #define MYSERIAL0 MSerial
+#elif SERIAL_PORT == 1
+  #define MYSERIAL0 MSerial1
+#elif SERIAL_PORT == 2
+  #define MYSERIAL0 MSerial2
+#elif SERIAL_PORT == 3
+  #define MYSERIAL0 MSerial3
 #else
   #error "SERIAL_PORT must be from -1 to 3. Please update your configuration."
 #endif
 
 #ifdef SERIAL_PORT_2
-  #if SERIAL_PORT_2 == -1
+  #if SERIAL_PORT_2 == SERIAL_PORT
+    #error "SERIAL_PORT_2 must be different than SERIAL_PORT. Please update your configuration."
+  #elif SERIAL_PORT_2 == -1
     #define MYSERIAL1 UsbSerial
-  #elif WITHIN(SERIAL_PORT_2, 0, 3)
+  #elif SERIAL_PORT_2 == 0
-    #define MYSERIAL1 MSERIAL(SERIAL_PORT_2)
+    #define MYSERIAL1 MSerial
+  #elif SERIAL_PORT_2 == 1
+    #define MYSERIAL1 MSerial1
+  #elif SERIAL_PORT_2 == 2
+    #define MYSERIAL1 MSerial2
+  #elif SERIAL_PORT_2 == 3
+    #define MYSERIAL1 MSerial3
   #else
     #error "SERIAL_PORT_2 must be from -1 to 3. Please update your configuration."
   #endif
+  #define NUM_SERIAL 2
+#else
+  #define NUM_SERIAL 1
 #endif
 
-#ifdef LCD_SERIAL_PORT
+#ifdef DGUS_SERIAL_PORT
-  #if LCD_SERIAL_PORT == -1
+  #if DGUS_SERIAL_PORT == SERIAL_PORT
-    #define LCD_SERIAL UsbSerial
+    #error "DGUS_SERIAL_PORT must be different than SERIAL_PORT. Please update your configuration."
-  #elif WITHIN(LCD_SERIAL_PORT, 0, 3)
+  #elif defined(SERIAL_PORT_2) && DGUS_SERIAL_PORT == SERIAL_PORT_2
-    #define LCD_SERIAL MSERIAL(LCD_SERIAL_PORT)
+    #error "DGUS_SERIAL_PORT must be different than SERIAL_PORT_2. Please update your configuration."
+  #elif DGUS_SERIAL_PORT == -1
+    #define DGUS_SERIAL UsbSerial
+  #elif DGUS_SERIAL_PORT == 0
+    #define DGUS_SERIAL MSerial
+  #elif DGUS_SERIAL_PORT == 1
+    #define DGUS_SERIAL MSerial1
+  #elif DGUS_SERIAL_PORT == 2
+    #define DGUS_SERIAL MSerial2
+  #elif DGUS_SERIAL_PORT == 3
+    #define DGUS_SERIAL MSerial3
   #else
-    #error "LCD_SERIAL_PORT must be from -1 to 3. Please update your configuration."
+    #error "DGUS_SERIAL_PORT must be from -1 to 3. Please update your configuration."
   #endif
 #endif
 
@@ -104,16 +130,10 @@ extern "C" volatile uint32_t _millis;
 //
 // 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
@@ -203,17 +223,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
-
-#ifndef strcat_P
-  #define strcat_P(a, b) strcat((a), (b))
-#endif
-
-#ifndef strcpy_P
-  #define strcpy_P(a, b) strcpy((a), (b))
-#endif

Marlin/src/HAL/LPC1768/HAL_SPI.cpp

@@ -30,7 +30,7 @@
  */
 
 /**
- * Hardware SPI and Software SPI implementations are included in this file.
+ * Hardware SPI and a software SPI implementations are included in this file.
  * The hardware SPI runs faster and has higher throughput but is not compatible
  * with some LCD interfaces/adapters.
  *
@@ -39,10 +39,10 @@
  * Some of the LCD interfaces/adapters result in the LCD SPI and the SD card
  * SPI sharing pins. The SCK, MOSI & MISO pins can NOT be set/cleared with
  * WRITE nor digitalWrite when the hardware SPI module within the LPC17xx is
- * active. If any of these pins are shared then the software SPI must be used.
+ * active.  If any of these pins are shared then the software SPI must be used.
  *
- * A more sophisticated hardware SPI can be found at the following link.
+ * A more sophisticated hardware SPI can be found at the following link.  This
- * This implementation has not been fully debugged.
+ * implementation has not been fully debugged.
  * https://github.com/MarlinFirmware/Marlin/tree/071c7a78f27078fd4aee9a3ef365fcf5e143531e
  */
 
@@ -51,37 +51,27 @@
 #include "../../inc/MarlinConfig.h"
 #include <SPI.h>
 
-// Hardware SPI and SPIClass
-#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,31 +96,78 @@
 
 #else
 
-  #ifndef HAL_SPI_SPEED
+  // Hardware SPI
-    #ifdef SD_SPI_SPEED
+
-      #define HAL_SPI_SPEED SD_SPI_SPEED
+  #include <lpc17xx_pinsel.h>
+  #include <lpc17xx_ssp.h>
+  #include <lpc17xx_clkpwr.h>
+
+  // decide which HW SPI device to use
+  #ifndef LPC_HW_SPI_DEV
+    #if (SCK_PIN == P0_07 && MISO_PIN == P0_08 && MOSI_PIN == P0_09)
+      #define LPC_HW_SPI_DEV 1
     #else
-      #define HAL_SPI_SPEED SPI_FULL_SPEED
+      #if (SCK_PIN == P0_15 && MISO_PIN == P0_17 && MOSI_PIN == P0_18)
+        #define LPC_HW_SPI_DEV 0
+      #else
+        #error "Invalid pins selected for hardware SPI"
+      #endif
     #endif
   #endif
+  #if (LPC_HW_SPI_DEV == 0)
+    #define LPC_SSPn LPC_SSP0
+  #else
+    #define LPC_SSPn LPC_SSP1
+  #endif
 
-  void spiBegin() { spiInit(HAL_SPI_SPEED); } // Set up SCK, MOSI & MISO pins for SSP0
+  void spiBegin() {  // setup SCK, MOSI & MISO pins for SSP0
+    PINSEL_CFG_Type PinCfg;  // data structure to hold init values
+    PinCfg.Funcnum = 2;
+    PinCfg.OpenDrain = 0;
+    PinCfg.Pinmode = 0;
+    PinCfg.Pinnum = LPC176x::pin_bit(SCK_PIN);
+    PinCfg.Portnum = LPC176x::pin_port(SCK_PIN);
+    PINSEL_ConfigPin(&PinCfg);
+    SET_OUTPUT(SCK_PIN);
+
+    PinCfg.Pinnum = LPC176x::pin_bit(MISO_PIN);
+    PinCfg.Portnum = LPC176x::pin_port(MISO_PIN);
+    PINSEL_ConfigPin(&PinCfg);
+    SET_INPUT(MISO_PIN);
+
+    PinCfg.Pinnum = LPC176x::pin_bit(MOSI_PIN);
+    PinCfg.Portnum = LPC176x::pin_port(MOSI_PIN);
+    PINSEL_ConfigPin(&PinCfg);
+    SET_OUTPUT(MOSI_PIN);
+    // divide PCLK by 2 for SSP0
+    CLKPWR_SetPCLKDiv(LPC_HW_SPI_DEV == 0 ? CLKPWR_PCLKSEL_SSP0 : CLKPWR_PCLKSEL_SSP1, CLKPWR_PCLKSEL_CCLK_DIV_2);
+    spiInit(0);
+    SSP_Cmd(LPC_SSPn, ENABLE);  // start SSP running
+  }
 
   void spiInit(uint8_t spiRate) {
-    #if SD_MISO_PIN == BOARD_SPI1_MISO_PIN
+    // table to convert Marlin spiRates (0-5 plus default) into bit rates
-      SPI.setModule(1);
+    uint32_t Marlin_speed[7]; // CPSR is always 2
-    #elif SD_MISO_PIN == BOARD_SPI2_MISO_PIN
+    Marlin_speed[0] = 8333333; //(SCR:  2)  desired: 8,000,000  actual: 8,333,333  +4.2%  SPI_FULL_SPEED
-      SPI.setModule(2);
+    Marlin_speed[1] = 4166667; //(SCR:  5)  desired: 4,000,000  actual: 4,166,667  +4.2%  SPI_HALF_SPEED
-    #endif
+    Marlin_speed[2] = 2083333; //(SCR: 11)  desired: 2,000,000  actual: 2,083,333  +4.2%  SPI_QUARTER_SPEED
-    SPI.setDataSize(DATA_SIZE_8BIT);
+    Marlin_speed[3] = 1000000; //(SCR: 24)  desired: 1,000,000  actual: 1,000,000         SPI_EIGHTH_SPEED
-    SPI.setDataMode(SPI_MODE0);
+    Marlin_speed[4] =  500000; //(SCR: 49)  desired:   500,000  actual:   500,000         SPI_SPEED_5
-
+    Marlin_speed[5] =  250000; //(SCR: 99)  desired:   250,000  actual:   250,000         SPI_SPEED_6
-    SPI.setClock(SPISettings::spiRate2Clock(spiRate));
+    Marlin_speed[6] =  125000; //(SCR:199)  desired:   125,000  actual:   125,000         Default from HAL.h
-    SPI.begin();
+    // setup for SPI mode
+    SSP_CFG_Type HW_SPI_init; // data structure to hold init values
+    SSP_ConfigStructInit(&HW_SPI_init);  // set values for SPI mode
+    HW_SPI_init.ClockRate = Marlin_speed[_MIN(spiRate, 6)]; // put in the specified bit rate
+    HW_SPI_init.Mode |= SSP_CR1_SSP_EN;
+    SSP_Init(LPC_SSPn, &HW_SPI_init);  // puts the values into the proper bits in the SSP0 registers
   }
 
   static uint8_t doio(uint8_t b) {
-    return SPI.transfer(b & 0x00FF) & 0x00FF;
+    /* send and receive a single byte */
+    SSP_SendData(LPC_SSPn, b & 0x00FF);
+    while (SSP_GetStatus(LPC_SSPn, SSP_STAT_BUSY));  // wait for it to finish
+    return SSP_ReceiveData(LPC_SSPn) & 0x00FF;
   }
 
   void spiSend(uint8_t b) { doio(b); }
@@ -139,9 +176,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 +192,9 @@
     for (uint16_t i = 0; i < nbyte; i++) buf[i] = doio(0xFF);
   }
 
-  uint8_t spiTransfer(uint8_t b) { return doio(b); }
+  static uint8_t spiTransfer(uint8_t b) {
+    return doio(b);
+  }
 
   // Write from buffer to SPI
   void spiSendBlock(uint8_t token, const uint8_t* buf) {
@@ -162,251 +203,38 @@
       (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
 
-/**
+void SPIClass::begin() { spiBegin(); }
- * @brief Wait until TXE (tx empty) flag is set and BSY (busy) flag unset.
- */
-static inline void waitSpiTxEnd(LPC_SSP_TypeDef *spi_d) {
-  while (SSP_GetStatus(spi_d, SSP_STAT_TXFIFO_EMPTY) == RESET) { /* nada */ } // wait until TXE=1
-  while (SSP_GetStatus(spi_d, SSP_STAT_BUSY) == SET) { /* nada */ }     // wait until BSY=0
-}
-
-// Retain the pin init state of the SPI, to avoid init more than once,
-// even if more instances of SPIClass exist
-static bool spiInitialised[BOARD_NR_SPI] = { false };
-
-SPIClass::SPIClass(uint8_t device) {
-  // Init things specific to each SPI device
-  // clock divider setup is a bit of hack, and needs to be improved at a later date.
-
-  #if BOARD_NR_SPI >= 1
-    _settings[0].spi_d = LPC_SSP0;
-    _settings[0].dataMode = SPI_MODE0;
-    _settings[0].dataSize = DATA_SIZE_8BIT;
-    _settings[0].clock = SPI_CLOCK_MAX;
-    //_settings[0].clockDivider = determine_baud_rate(_settings[0].spi_d, _settings[0].clock);
-  #endif
-
-  #if BOARD_NR_SPI >= 2
-    _settings[1].spi_d = LPC_SSP1;
-    _settings[1].dataMode = SPI_MODE0;
-    _settings[1].dataSize = DATA_SIZE_8BIT;
-    _settings[1].clock = SPI_CLOCK_MAX;
-    //_settings[1].clockDivider = determine_baud_rate(_settings[1].spi_d, _settings[1].clock);
-  #endif
-
-  setModule(device);
-
-  // Init the GPDMA controller
-  // TODO: call once in the constructor? or each time?
-  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) ||
-      (_currentSetting->spi_d == LPC_SSP1 && spiInitialised[1] == false)) {
-    pin_t sck, miso, mosi;
-    if (_currentSetting->spi_d == LPC_SSP0) {
-      sck = BOARD_SPI1_SCK_PIN;
-      miso = BOARD_SPI1_MISO_PIN;
-      mosi = BOARD_SPI1_MOSI_PIN;
-      spiInitialised[0] = true;
-    }
-    else if (_currentSetting->spi_d == LPC_SSP1) {
-      sck = BOARD_SPI2_SCK_PIN;
-      miso = BOARD_SPI2_MISO_PIN;
-      mosi = BOARD_SPI2_MOSI_PIN;
-      spiInitialised[1] = true;
-    }
-    PINSEL_CFG_Type PinCfg;  // data structure to hold init values
-    PinCfg.Funcnum = 2;
-    PinCfg.OpenDrain = 0;
-    PinCfg.Pinmode = 0;
-    PinCfg.Pinnum = LPC176x::pin_bit(sck);
-    PinCfg.Portnum = LPC176x::pin_port(sck);
-    PINSEL_ConfigPin(&PinCfg);
-    SET_OUTPUT(sck);
-
-    PinCfg.Pinnum = LPC176x::pin_bit(miso);
-    PinCfg.Portnum = LPC176x::pin_port(miso);
-    PINSEL_ConfigPin(&PinCfg);
-    SET_INPUT(miso);
-
-    PinCfg.Pinnum = LPC176x::pin_bit(mosi);
-    PinCfg.Portnum = LPC176x::pin_port(mosi);
-    PINSEL_ConfigPin(&PinCfg);
-    SET_OUTPUT(mosi);
-  }
-
-  updateSettings();
-  SSP_Cmd(_currentSetting->spi_d, ENABLE);  // start SSP running
-}
 
 void SPIClass::beginTransaction(const SPISettings &cfg) {
-  setBitOrder(cfg.bitOrder);
+  uint8_t spiRate;
-  setDataMode(cfg.dataMode);
+  switch (cfg.spiRate()) {
-  setDataSize(cfg.dataSize);
+    case 8000000: spiRate = 0; break;
-  //setClockDivider(determine_baud_rate(_currentSetting->spi_d, settings.clock));
+    case 4000000: spiRate = 1; break;
-  begin();
+    case 2000000: spiRate = 2; break;
+    case 1000000: spiRate = 3; break;
+    case  500000: spiRate = 4; break;
+    case  250000: spiRate = 5; break;
+    case  125000: spiRate = 6; break;
+    default: spiRate = 2; break;
+  }
+  spiInit(spiRate);
 }
 
-uint8_t SPIClass::transfer(const uint16_t b) {
+uint8_t SPIClass::transfer(const uint8_t B) { return spiTransfer(B); }
-  // Send and receive a single byte
-  SSP_ReceiveData(_currentSetting->spi_d); // read any previous data
-  SSP_SendData(_currentSetting->spi_d, b);
-  waitSpiTxEnd(_currentSetting->spi_d);  // wait for it to finish
-  return SSP_ReceiveData(_currentSetting->spi_d);
-}
 
 uint16_t SPIClass::transfer16(const uint16_t data) {
-  return (transfer((data >> 8) & 0xFF) << 8) | (transfer(data & 0xFF) & 0xFF);
+  return (transfer((data >> 8) & 0xFF) << 8)
+       | (transfer(data & 0xFF) & 0xFF);
 }
 
-void SPIClass::end() {
+SPIClass SPI;
-  // Neither is needed for Marlin
-  //SSP_Cmd(_currentSetting->spi_d, DISABLE);
-  //SSP_DeInit(_currentSetting->spi_d);
-}
-
-void SPIClass::send(uint8_t data) {
-  SSP_SendData(_currentSetting->spi_d, data);
-}
-
-void SPIClass::dmaSend(void *buf, uint16_t length, bool minc) {
-  //TODO: LPC dma can only write 0xFFF bytes at once.
-  GPDMA_Channel_CFG_Type GPDMACfg;
-
-  /* Configure GPDMA channel 0 -------------------------------------------------------------*/
-  /* DMA Channel 0 */
-  GPDMACfg.ChannelNum = 0;
-  // Source memory
-  GPDMACfg.SrcMemAddr = (uint32_t)buf;
-  // Destination memory - Not used
-  GPDMACfg.DstMemAddr = 0;
-  // Transfer size
-  GPDMACfg.TransferSize = length;
-  // Transfer width
-  GPDMACfg.TransferWidth = (_currentSetting->dataSize == DATA_SIZE_16BIT) ? GPDMA_WIDTH_HALFWORD : GPDMA_WIDTH_BYTE;
-  // Transfer type
-  GPDMACfg.TransferType = GPDMA_TRANSFERTYPE_M2P;
-  // Source connection - unused
-  GPDMACfg.SrcConn = 0;
-  // Destination connection
-  GPDMACfg.DstConn = (_currentSetting->spi_d == LPC_SSP0) ? GPDMA_CONN_SSP0_Tx : GPDMA_CONN_SSP1_Tx;
-
-  GPDMACfg.DMALLI = 0;
-
-  // Enable dma on SPI
-  SSP_DMACmd(_currentSetting->spi_d, SSP_DMA_TX, ENABLE);
-
-  // Only increase memory if minc is true
-  GPDMACfg.MemoryIncrease = (minc ? GPDMA_DMACCxControl_SI : 0);
-
-  // Setup channel with given parameter
-  GPDMA_Setup(&GPDMACfg);
-
-  // Enable DMA
-  GPDMA_ChannelCmd(0, ENABLE);
-
-  // Wait for data transfer
-  while (!GPDMA_IntGetStatus(GPDMA_STAT_RAWINTTC, 0) && !GPDMA_IntGetStatus(GPDMA_STAT_RAWINTERR, 0)) { }
-
-  // Clear err and int
-  GPDMA_ClearIntPending (GPDMA_STATCLR_INTTC, 0);
-  GPDMA_ClearIntPending (GPDMA_STATCLR_INTERR, 0);
-
-  // Disable DMA
-  GPDMA_ChannelCmd(0, DISABLE);
-
-  waitSpiTxEnd(_currentSetting->spi_d);
-
-  SSP_DMACmd(_currentSetting->spi_d, SSP_DMA_TX, DISABLE);
-}
-
-uint16_t SPIClass::read() {
-  return SSP_ReceiveData(_currentSetting->spi_d);
-}
-
-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::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::setDataMode(uint8_t dataMode) { _currentSetting->dataMode = dataMode; }
-
-void SPIClass::setDataSize(uint32_t dataSize) { _currentSetting->dataSize = dataSize; }
-
-/**
- * Set up/tear down
- */
-void SPIClass::updateSettings() {
-  //SSP_DeInit(_currentSetting->spi_d); //todo: need force de init?!
-
-  // Divide PCLK by 2 for SSP0
-  //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
-  HW_SPI_init.ClockRate = _currentSetting->clock;
-  HW_SPI_init.Databit = _currentSetting->dataSize;
-
-  /**
-   * SPI Mode  CPOL  CPHA  Shift SCK-edge  Capture SCK-edge
-   * 0       0     0     Falling     Rising
-   * 1       0     1     Rising      Falling
-   * 2       1     0     Rising      Falling
-   * 3       1     1     Falling     Rising
-   */
-  switch (_currentSetting->dataMode) {
-    case SPI_MODE0:
-      HW_SPI_init.CPHA = SSP_CPHA_FIRST;
-      HW_SPI_init.CPOL = SSP_CPOL_HI;
-      break;
-    case SPI_MODE1:
-      HW_SPI_init.CPHA = SSP_CPHA_SECOND;
-      HW_SPI_init.CPOL = SSP_CPOL_HI;
-      break;
-    case SPI_MODE2:
-      HW_SPI_init.CPHA = SSP_CPHA_FIRST;
-      HW_SPI_init.CPOL = SSP_CPOL_LO;
-      break;
-    case SPI_MODE3:
-      HW_SPI_init.CPHA = SSP_CPHA_SECOND;
-      HW_SPI_init.CPOL = SSP_CPOL_LO;
-      break;
-    default:
-      break;
-  }
-
-  // TODO: handle bitOrder
-  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
-  SPIClass SPI(1);
-#elif SD_MISO_PIN == BOARD_SPI2_MISO_PIN
-  SPIClass SPI(2);
-#endif
 
 #endif // TARGET_LPC1768

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,21 +24,32 @@
 #include "../../inc/MarlinConfigPre.h"
 #include "MarlinSerial.h"
 
-#if USING_SERIAL_0
+#if (defined(SERIAL_PORT) && SERIAL_PORT == 0) || (defined(SERIAL_PORT_2) && SERIAL_PORT_2 == 0) || (defined(DGUS_SERIAL_PORT) && DGUS_SERIAL_PORT == 0)
   MarlinSerial MSerial(LPC_UART0);
-  extern "C" void UART0_IRQHandler() { MSerial.IRQHandler(); }
+  extern "C" void UART0_IRQHandler() {
+    MSerial.IRQHandler();
+  }
 #endif
-#if USING_SERIAL_1
+
+#if SERIAL_PORT == 1 || SERIAL_PORT_2 == 1 || DGUS_SERIAL_PORT == 1
   MarlinSerial MSerial1((LPC_UART_TypeDef *) LPC_UART1);
-  extern "C" void UART1_IRQHandler() { MSerial1.IRQHandler(); }
+  extern "C" void UART1_IRQHandler() {
+    MSerial1.IRQHandler();
+  }
 #endif
-#if USING_SERIAL_2
+
+#if SERIAL_PORT == 2 || SERIAL_PORT_2 == 2 || DGUS_SERIAL_PORT == 2
   MarlinSerial MSerial2(LPC_UART2);
-  extern "C" void UART2_IRQHandler() { MSerial2.IRQHandler(); }
+  extern "C" void UART2_IRQHandler() {
+    MSerial2.IRQHandler();
+  }
 #endif
-#if USING_SERIAL_3
+
+#if SERIAL_PORT == 3 || SERIAL_PORT_2 == 3 || DGUS_SERIAL_PORT == 3
   MarlinSerial MSerial3(LPC_UART3);
-  extern "C" void UART3_IRQHandler() { MSerial3.IRQHandler(); }
+  extern "C" void UART3_IRQHandler() {
+    MSerial3.IRQHandler();
+  }
 #endif
 
 #endif // TARGET_LPC1768

Marlin/src/HAL/LPC1768/MarlinSerial.h

@@ -57,7 +57,6 @@ public:
     }
 
     EmergencyParser::State emergency_state;
-    static inline bool emergency_parser_enabled() { return true; }
   #endif
 };
 

Marlin/src/HAL/LPC1768/Servo.h

@@ -46,6 +46,7 @@
  *           Version 2 Copyright (c) 2009 Michael Margolis.  All right reserved.
  *
  * The only modification was to update/delete macros to match the LPC176x.
+ *
  */
 
 #include <Servo.h>

Marlin/src/HAL/LPC1768/eeprom_flash.cpp

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

@@ -143,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

@@ -21,6 +21,6 @@
  */
 #pragma once
 
-#if HAS_FSMC_TFT
+#if HAS_SPI_TFT || HAS_FSMC_TFT
-  #error "Sorry! FSMC TFT displays are not current available for HAL/LPC1768."
+  #error "Sorry! TFT displays are not available for HAL/LPC1768."
 #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/SanityCheck.h

@@ -24,7 +24,7 @@
 #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 < 2002
   #error "framework-arduino-lpc176x package is out of date, Please update the PlatformIO platforms, frameworks and libraries."
 #endif
 
@@ -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
@@ -89,16 +89,13 @@ static_assert(DISABLED(BAUD_RATE_GCODE), "BAUD_RATE_GCODE is not yet supported o
  * Serial2 | P0_10 | P0_11 |
  * Serial3 | P0_00 | P0_01 |
  */
-#define ANY_TX(N,V...) DO(IS_TX##N,||,V)
+#if (defined(SERIAL_PORT) && SERIAL_PORT == 0) || (defined(SERIAL_PORT_2) && SERIAL_PORT_2 == 0) || (defined(DGUS_SERIAL_PORT) && DGUS_SERIAL_PORT == 0)
-#define ANY_RX(N,V...) DO(IS_RX##N,||,V)
-
-#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,67 +103,60 @@ static_assert(DISABLED(BAUD_RATE_GCODE), "BAUD_RATE_GCODE is not yet supported o
   #undef IS_RX0
 #endif
 
-#if USING_SERIAL_1
+#if SERIAL_PORT == 1 || SERIAL_PORT_2 == 1 || DGUS_SERIAL_PORT == 1
   #define IS_TX1(P) (P == P0_15)
   #define IS_RX1(P) (P == P0_16)
-  #define _IS_TX1_1 IS_TX1
-  #define _IS_RX1_1 IS_RX1
   #if IS_TX1(TMC_SW_SCK)
     #error "Serial port pins (1) conflict with other pins!"
-  #elif HAS_WIRED_LCD
+  #elif HAS_SPI_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) \
+    #elif IS_TX1(SCK_PIN) || IS_TX1(LCD_PINS_D4) || IS_TX1(DOGLCD_SCK) || IS_TX1(LCD_RESET_PIN) || IS_TX1(LCD_PINS_RS) || IS_TX1(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)
+      || IS_RX1(LCD_SDSS) || IS_RX1(LCD_PINS_RS) || IS_RX1(MISO_PIN) || IS_RX1(DOGLCD_A0) || IS_RX1(SS_PIN) || IS_RX1(LCD_SDSS) || IS_RX1(DOGLCD_CS) || IS_RX1(LCD_RESET_PIN) || IS_RX1(LCD_BACKLIGHT_PIN)
       #error "Serial port pins (1) conflict with LCD pins!"
     #endif
   #endif
   #undef IS_TX1
   #undef IS_RX1
-  #undef _IS_TX1_1
-  #undef _IS_RX1_1
 #endif
 
-#if USING_SERIAL_2
+#if SERIAL_PORT == 2 || SERIAL_PORT_2 == 2 || DGUS_SERIAL_PORT == 2
   #define IS_TX2(P) (P == P0_10)
   #define IS_RX2(P) (P == P0_11)
-  #define _IS_TX2_1 IS_TX2
+  #if  IS_TX2(X2_ENABLE_PIN) || IS_RX2(X2_DIR_PIN) || IS_RX2(X2_STEP_PIN) || (AXIS_HAS_SPI(X2) && IS_TX2(X2_CS_PIN))
-  #define _IS_RX2_1 IS_RX2
-  #if IS_TX2(X2_ENABLE_PIN) || ANY_RX(2, X2_DIR_PIN, X2_STEP_PIN) || (AXIS_HAS_SPI(X2) && IS_TX2(X2_CS_PIN))
     #error "Serial port pins (2) conflict with X2 pins!"
-  #elif IS_TX2(Y2_ENABLE_PIN) || ANY_RX(2, Y2_DIR_PIN, Y2_STEP_PIN) || (AXIS_HAS_SPI(Y2) && IS_TX2(Y2_CS_PIN))
+  #elif IS_TX2(Y2_ENABLE_PIN) || IS_RX2(Y2_DIR_PIN) || IS_RX2(Y2_STEP_PIN) || (AXIS_HAS_SPI(Y2) && IS_TX2(Y2_CS_PIN))
     #error "Serial port pins (2) conflict with Y2 pins!"
-  #elif IS_TX2(Z2_ENABLE_PIN) || ANY_RX(2, Z2_DIR_PIN, Z2_STEP_PIN) || (AXIS_HAS_SPI(Z2) && IS_TX2(Z2_CS_PIN))
+  #elif IS_TX2(Z2_ENABLE_PIN) || IS_RX2(Z2_DIR_PIN) || IS_RX2(Z2_STEP_PIN) || (AXIS_HAS_SPI(Z2) && IS_TX2(Z2_CS_PIN))
     #error "Serial port pins (2) conflict with Z2 pins!"
-  #elif IS_TX2(Z3_ENABLE_PIN) || ANY_RX(2, Z3_DIR_PIN, Z3_STEP_PIN) || (AXIS_HAS_SPI(Z3) && IS_TX2(Z3_CS_PIN))
+  #elif IS_TX2(Z3_ENABLE_PIN) || IS_RX2(Z3_DIR_PIN) || IS_RX2(Z3_STEP_PIN) || (AXIS_HAS_SPI(Z3) && IS_TX2(Z3_CS_PIN))
     #error "Serial port pins (2) conflict with Z3 pins!"
-  #elif IS_TX2(Z4_ENABLE_PIN) || ANY_RX(2, Z4_DIR_PIN, Z4_STEP_PIN) || (AXIS_HAS_SPI(Z4) && IS_TX2(Z4_CS_PIN))
+  #elif IS_TX2(Z4_ENABLE_PIN) || IS_RX2(Z4_DIR_PIN) || IS_RX2(Z4_STEP_PIN) || (AXIS_HAS_SPI(Z4) && IS_TX2(Z4_CS_PIN))
     #error "Serial port pins (2) conflict with Z4 pins!"
-  #elif ANY_RX(2, X_DIR_PIN, Y_DIR_PIN)
+  #elif IS_RX2(X_DIR_PIN) || IS_RX2(Y_DIR_PIN)
     #error "Serial port pins (2) conflict with other pins!"
   #elif Y_HOME_DIR < 0 && IS_TX2(Y_STOP_PIN)
     #error "Serial port pins (2) conflict with Y endstop pin!"
   #elif HAS_CUSTOM_PROBE_PIN && IS_TX2(Z_MIN_PROBE_PIN)
     #error "Serial port pins (2) conflict with probe pin!"
-  #elif ANY_TX(2, X_ENABLE_PIN, Y_ENABLE_PIN) || ANY_RX(2, X_DIR_PIN, Y_DIR_PIN)
+  #elif IS_TX2(X_ENABLE_PIN) || IS_RX2(X_DIR_PIN) || IS_TX2(Y_ENABLE_PIN) || IS_RX2(Y_DIR_PIN)
     #error "Serial port pins (2) conflict with X/Y stepper pins!"
-  #elif HAS_MULTI_EXTRUDER && (IS_TX2(E1_ENABLE_PIN) || (AXIS_HAS_SPI(E1) && IS_TX2(E1_CS_PIN)))
+  #elif EXTRUDERS > 1 && (IS_TX2(E1_ENABLE_PIN) || (AXIS_HAS_SPI(E1) && IS_TX2(E1_CS_PIN)))
     #error "Serial port pins (2) conflict with E1 stepper pins!"
-  #elif EXTRUDERS && ANY_RX(2, E0_DIR_PIN, E0_STEP_PIN)
+  #elif EXTRUDERS && (IS_RX2(E0_DIR_PIN) || IS_RX2(E0_STEP_PIN))
     #error "Serial port pins (2) conflict with E stepper pins!"
   #endif
   #undef IS_TX2
   #undef IS_RX2
-  #undef _IS_TX2_1
-  #undef _IS_RX2_1
 #endif
 
-#if USING_SERIAL_3
+#if SERIAL_PORT == 3 || SERIAL_PORT_2 == 3 || DGUS_SERIAL_PORT == 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)
     #error "Serial port pins (3) conflict with X endstop pins!"
-  #elif PIN_IS_TX3(Y_SERIAL_TX) || PIN_IS_TX3(Y_SERIAL_RX) || PIN_IS_RX3(X_SERIAL_TX) || PIN_IS_RX3(X_SERIAL_RX)
+  #elif PIN_IS_TX3(Y_SERIAL_TX) || PIN_IS_TX3(Y_SERIAL_RX) \
+    ||  PIN_IS_RX3(X_SERIAL_TX) || PIN_IS_RX3(X_SERIAL_RX)
     #error "Serial port pins (3) conflict with X/Y axis UART pins!"
   #elif PIN_IS_TX3(X2_DIR) || PIN_IS_RX3(X2_STEP)
     #error "Serial port pins (3) conflict with X2 pins!"
@@ -178,20 +168,17 @@ static_assert(DISABLED(BAUD_RATE_GCODE), "BAUD_RATE_GCODE is not yet supported o
     #error "Serial port pins (3) conflict with Z3 pins!"
   #elif PIN_IS_TX3(Z4_DIR) || PIN_IS_RX3(Z4_STEP)
     #error "Serial port pins (3) conflict with Z4 pins!"
-  #elif HAS_MULTI_EXTRUDER && (PIN_IS_TX3(E1_DIR) || PIN_IS_RX3(E1_STEP))
+  #elif EXTRUDERS > 1 && (PIN_IS_TX3(E1_DIR) || PIN_IS_RX3(E1_STEP))
     #error "Serial port pins (3) conflict with E1 pins!"
   #endif
   #undef PIN_IS_TX3
   #undef PIN_IS_RX3
 #endif
 
-#undef ANY_TX
-#undef ANY_RX
-
 //
 // 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 +192,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
@@ -227,7 +214,7 @@ static_assert(DISABLED(BAUD_RATE_GCODE), "BAUD_RATE_GCODE is not yet supported o
       #error "One or more i2c (1) pins overlaps with Z3 pins! Disable i2c peripherals."
     #elif PIN_IS_SDA1(Z4_DIR) || PIN_IS_SCL1(Z4_STEP)
       #error "One or more i2c (1) pins overlaps with Z4 pins! Disable i2c peripherals."
-    #elif HAS_MULTI_EXTRUDER && (PIN_IS_SDA1(E1_DIR) || PIN_IS_SCL1(E1_STEP))
+    #elif EXTRUDERS > 1 && (PIN_IS_SDA1(E1_DIR) || PIN_IS_SCL1(E1_STEP))
       #error "One or more i2c (1) pins overlaps with E1 pins! Disable i2c peripherals."
     #endif
     #undef PIN_IS_SDA1
@@ -253,9 +240,9 @@ static_assert(DISABLED(BAUD_RATE_GCODE), "BAUD_RATE_GCODE is not yet supported o
       #error "i2c SDA2 overlaps with Z3 enable pin! Disable i2c peripherals."
     #elif PIN_IS_SDA2(Z4_ENABLE)
       #error "i2c SDA2 overlaps with Z4 enable pin! Disable i2c peripherals."
-    #elif HAS_MULTI_EXTRUDER && PIN_IS_SDA2(E1_ENABLE)
+    #elif EXTRUDERS > 1 && PIN_IS_SDA2(E1_ENABLE)
       #error "i2c SDA2 overlaps with E1 enable pin! Disable i2c peripherals."
-    #elif HAS_MULTI_EXTRUDER && AXIS_HAS_SPI(E1) && PIN_IS_SDA2(E1_CS)
+    #elif EXTRUDERS > 1 && AXIS_HAS_SPI(E1) && PIN_IS_SDA2(E1_CS)
       #error "i2c SDA2 overlaps with E1 CS pin! Disable i2c peripherals."
     #elif EXTRUDERS && (PIN_IS_SDA2(E0_STEP) || PIN_IS_SDA2(E0_DIR))
       #error "i2c SCL2 overlaps with E0 STEP/DIR pin! Disable i2c peripherals."

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

@@ -24,159 +24,25 @@
 #include "../../shared/HAL_SPI.h"
 
 #include <stdint.h>
-#include <lpc17xx_ssp.h>
-#include <lpc17xx_gpdma.h>
 
-//#define MSBFIRST 1
+#define MSBFIRST 1
-
+#define SPI_MODE3 0
-#define SPI_MODE0 0
-#define SPI_MODE1 1
-#define SPI_MODE2 2
-#define SPI_MODE3 3
-
-#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_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_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_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_MAX SPI_CLOCK_DIV2
-
-#define BOARD_NR_SPI 2
-
-//#define BOARD_SPI1_NSS_PIN      PA4 ?!
-#define BOARD_SPI1_SCK_PIN      P0_15
-#define BOARD_SPI1_MISO_PIN     P0_17
-#define BOARD_SPI1_MOSI_PIN     P0_18
-
-//#define BOARD_SPI2_NSS_PIN      PB12 ?!
-#define BOARD_SPI2_SCK_PIN      P0_07
-#define BOARD_SPI2_MISO_PIN     P0_08
-#define BOARD_SPI2_MOSI_PIN     P0_09
 
 class SPISettings {
-public:
+  public:
-  SPISettings(uint32_t spiRate, int inBitOrder, int inDataMode) {
+    SPISettings(uint32_t speed, int, int) : spi_speed(speed) {};
-    init_AlwaysInline(spiRate2Clock(spiRate), inBitOrder, inDataMode, DATA_SIZE_8BIT);
+    uint32_t spiRate() const { return spi_speed; }
-  }
+  private:
-  SPISettings(uint32_t inClock, uint8_t inBitOrder, uint8_t inDataMode, uint32_t inDataSize) {
+    uint32_t spi_speed;
-    if (__builtin_constant_p(inClock))
-      init_AlwaysInline(inClock, inBitOrder, inDataMode, inDataSize);
-    else
-      init_MightInline(inClock, inBitOrder, inDataMode, inDataSize);
-  }
-  SPISettings() {
-    init_AlwaysInline(4000000, MSBFIRST, SPI_MODE0, DATA_SIZE_8BIT);
-  }
-
-  //uint32_t spiRate() const { return spi_speed; }
-
-  static inline uint32_t spiRate2Clock(uint32_t spiRate) {
-    uint32_t Marlin_speed[7]; // CPSR is always 2
-    Marlin_speed[0] = 8333333; //(SCR:  2)  desired: 8,000,000  actual: 8,333,333  +4.2%  SPI_FULL_SPEED
-    Marlin_speed[1] = 4166667; //(SCR:  5)  desired: 4,000,000  actual: 4,166,667  +4.2%  SPI_HALF_SPEED
-    Marlin_speed[2] = 2083333; //(SCR: 11)  desired: 2,000,000  actual: 2,083,333  +4.2%  SPI_QUARTER_SPEED
-    Marlin_speed[3] = 1000000; //(SCR: 24)  desired: 1,000,000  actual: 1,000,000         SPI_EIGHTH_SPEED
-    Marlin_speed[4] =  500000; //(SCR: 49)  desired:   500,000  actual:   500,000         SPI_SPEED_5
-    Marlin_speed[5] =  250000; //(SCR: 99)  desired:   250,000  actual:   250,000         SPI_SPEED_6
-    Marlin_speed[6] =  125000; //(SCR:199)  desired:   125,000  actual:   125,000         Default from HAL.h
-    return Marlin_speed[spiRate > 6 ? 6 : spiRate];
-  }
-
-private:
-  void init_MightInline(uint32_t inClock, uint8_t inBitOrder, uint8_t inDataMode, uint32_t inDataSize) {
-    init_AlwaysInline(inClock, inBitOrder, inDataMode, inDataSize);
-  }
-  void init_AlwaysInline(uint32_t inClock, uint8_t inBitOrder, uint8_t inDataMode, uint32_t inDataSize) __attribute__((__always_inline__)) {
-    clock    = inClock;
-    bitOrder = inBitOrder;
-    dataMode = inDataMode;
-    dataSize = inDataSize;
-  }
-
-  //uint32_t spi_speed;
-  uint32_t clock;
-  uint32_t dataSize;
-  //uint32_t clockDivider;
-  uint8_t bitOrder;
-  uint8_t dataMode;
-  LPC_SSP_TypeDef *spi_d;
-
-  friend class SPIClass;
 };
 
-/**
- * @brief Wirish SPI interface.
- *
- * This is the same interface is available across HAL
- *
- * This implementation uses software slave management, so the caller
- * is responsible for controlling the slave select line.
- */
 class SPIClass {
-public:
+  public:
-  /**
+    void begin();
-   * @param spiPortNumber Number of the SPI port to manage.
+    void beginTransaction(const SPISettings&);
-   */
+    void endTransaction() {};
-  SPIClass(uint8_t spiPortNumber);
+    uint8_t transfer(uint8_t data);
-
+    uint16_t transfer16(uint16_t data);
-  /**
-   * 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
-   */
-  void begin();
-
-  /**
-   * Disable the current SPI device
-   */
-  void end();
-
-  void beginTransaction(const SPISettings&);
-  void endTransaction() {}
-
-  // Transfer using 1 "Data Size"
-  uint8_t transfer(uint16_t data);
-  // Transfer 2 bytes in 8 bit mode
-  uint16_t transfer16(uint16_t data);
-
-  void send(uint8_t data);
-
-  uint16_t read();
-  void read(uint8_t *buf, uint32_t len);
-
-  void dmaSend(void *buf, uint16_t length, bool minc);
-
-  /**
-   * @brief Sets the number of the SPI peripheral to be used by
-   *        this HardwareSPI instance.
-   *
-   * @param spi_num Number of the SPI port. 1-2 in low density devices
-   *     or 1-3 in high density devices.
-   */
-  void setModule(uint8_t device);
-
-  void setClock(uint32_t clock);
-  void setBitOrder(uint8_t bitOrder);
-  void setDataMode(uint8_t dataMode);
-  void setDataSize(uint32_t ds);
-
-  inline uint32_t getDataSize() { return _currentSetting->dataSize; }
-
-private:
-  SPISettings _settings[BOARD_NR_SPI];
-  SPISettings *_currentSetting;
-
-  void updateSettings();
 };
 
 extern SPIClass SPI;

Marlin/src/HAL/LPC1768/main.cpp

@@ -31,18 +31,17 @@
 #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(); }
 
@@ -90,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
 
@@ -123,7 +122,7 @@ void HAL_init() {
   delay(1000);                              // Give OS time to notice
   USB_Connect(TRUE);
 
-  #if HAS_SD_HOST_DRIVE
+  #if DISABLED(NO_SD_HOST_DRIVE)
     MSC_SD_Init(0);                         // Enable USB SD card access
   #endif
 

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_GRAPHICAL_LCD) && (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

@@ -1,153 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-
-#include "../../../inc/MarlinConfig.h"
-
-#if HAS_SPI_TFT
-
-#include "tft_spi.h"
-
-//TFT_SPI tft;
-
-SPIClass TFT_SPI::SPIx(1);
-
-#define TFT_CS_H  WRITE(TFT_CS_PIN, HIGH)
-#define TFT_CS_L  WRITE(TFT_CS_PIN, LOW)
-
-#define TFT_DC_H  WRITE(TFT_DC_PIN, HIGH)
-#define TFT_DC_L  WRITE(TFT_DC_PIN, LOW)
-
-#define TFT_RST_H WRITE(TFT_RESET_PIN, HIGH)
-#define TFT_RST_L WRITE(TFT_RESET_PIN, LOW)
-
-#define TFT_BLK_H WRITE(TFT_BACKLIGHT_PIN, HIGH)
-#define TFT_BLK_L WRITE(TFT_BACKLIGHT_PIN, LOW)
-
-void TFT_SPI::Init() {
-  #if PIN_EXISTS(TFT_RESET)
-    SET_OUTPUT(TFT_RESET_PIN);
-    TFT_RST_H;
-    delay(100);
-  #endif
-
-  #if PIN_EXISTS(TFT_BACKLIGHT)
-    SET_OUTPUT(TFT_BACKLIGHT_PIN);
-    TFT_BLK_H;
-  #endif
-
-  SET_OUTPUT(TFT_DC_PIN);
-  SET_OUTPUT(TFT_CS_PIN);
-
-  TFT_DC_H;
-  TFT_CS_H;
-
-  /**
-   * STM32F1 APB2 = 72MHz, APB1 = 36MHz, max SPI speed of this MCU if 18Mhz
-   * STM32F1 has 3 SPI ports, SPI1 in APB2, SPI2/SPI3 in APB1
-   * so the minimum prescale of SPI1 is DIV4, SPI2/SPI3 is DIV2
-   */
-  #if 0
-    #if SPI_DEVICE == 1
-     #define SPI_CLOCK_MAX SPI_CLOCK_DIV4
-    #else
-     #define SPI_CLOCK_MAX SPI_CLOCK_DIV2
-    #endif
-    uint8_t  clock;
-    uint8_t spiRate = SPI_FULL_SPEED;
-    switch (spiRate) {
-     case SPI_FULL_SPEED:    clock = SPI_CLOCK_MAX ;  break;
-     case SPI_HALF_SPEED:    clock = SPI_CLOCK_DIV4 ; break;
-     case SPI_QUARTER_SPEED: clock = SPI_CLOCK_DIV8 ; break;
-     case SPI_EIGHTH_SPEED:  clock = SPI_CLOCK_DIV16; break;
-     case SPI_SPEED_5:       clock = SPI_CLOCK_DIV32; break;
-     case SPI_SPEED_6:       clock = SPI_CLOCK_DIV64; break;
-     default:                clock = SPI_CLOCK_DIV2;  // Default from the SPI library
-    }
-  #endif
-
-  #if TFT_MISO_PIN == BOARD_SPI1_MISO_PIN
-    SPIx.setModule(1);
-  #elif TFT_MISO_PIN == BOARD_SPI2_MISO_PIN
-    SPIx.setModule(2);
-  #endif
-  SPIx.setClock(SPI_CLOCK_MAX_TFT);
-  SPIx.setBitOrder(MSBFIRST);
-  SPIx.setDataMode(SPI_MODE0);
-}
-
-void TFT_SPI::DataTransferBegin(uint16_t DataSize) {
-  SPIx.setDataSize(DataSize);
-  SPIx.begin();
-  TFT_CS_L;
-}
-
-uint32_t TFT_SPI::GetID() {
-  uint32_t id;
-  id = ReadID(LCD_READ_ID);
-  if ((id & 0xFFFF) == 0 || (id & 0xFFFF) == 0xFFFF)
-    id = ReadID(LCD_READ_ID4);
-  return id;
-}
-
-uint32_t TFT_SPI::ReadID(uint16_t Reg) {
-  uint32_t data = 0;
-
-  #if PIN_EXISTS(TFT_MISO)
-    uint8_t d = 0;
-    SPIx.setDataSize(DATASIZE_8BIT);
-    SPIx.setClock(SPI_CLOCK_DIV64);
-    SPIx.begin();
-    TFT_CS_L;
-    WriteReg(Reg);
-
-    LOOP_L_N(i, 4) {
-      SPIx.read((uint8_t*)&d, 1);
-      data = (data << 8) | d;
-    }
-
-    DataTransferEnd();
-    SPIx.setClock(SPI_CLOCK_MAX_TFT);
-  #endif
-
-  return data >> 7;
-}
-
-bool TFT_SPI::isBusy() {
-  return false;
-}
-
-void TFT_SPI::Abort() {
-  DataTransferEnd();
-}
-
-void TFT_SPI::Transmit(uint16_t Data) {
-  SPIx.transfer(Data);
-}
-
-void TFT_SPI::TransmitDMA(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Count) {
-  DataTransferBegin(DATASIZE_16BIT); //16
-  TFT_DC_H;
-  SPIx.dmaSend(Data, Count, MemoryIncrease);
-  DataTransferEnd();
-}
-
-#endif // HAS_SPI_TFT

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

@@ -1,77 +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 "../../../inc/MarlinConfig.h"
-
-#include <SPI.h>
-#include <lpc17xx_ssp.h>
-// #include <lpc17xx_gpdma.h>
-
-#ifndef LCD_READ_ID
-  #define LCD_READ_ID  0x04   // Read display identification information (0xD3 on ILI9341)
-#endif
-#ifndef LCD_READ_ID4
-  #define LCD_READ_ID4 0xD3   // Read display identification information (0xD3 on ILI9341)
-#endif
-
-#define DATASIZE_8BIT    SSP_DATABIT_8
-#define DATASIZE_16BIT   SSP_DATABIT_16
-#define TFT_IO_DRIVER TFT_SPI
-
-#define DMA_MINC_ENABLE 1
-#define DMA_MINC_DISABLE 0
-
-class TFT_SPI {
-private:
-  static uint32_t ReadID(uint16_t Reg);
-  static void Transmit(uint16_t Data);
-  static void TransmitDMA(uint32_t MemoryIncrease, uint16_t *Data, uint16_t Count);
-
-public:
-  static SPIClass SPIx;
-
-  static void Init();
-  static uint32_t GetID();
-  static bool isBusy();
-  static void Abort();
-
-  static void DataTransferBegin(uint16_t DataWidth = DATASIZE_16BIT);
-  static void DataTransferEnd() { OUT_WRITE(TFT_CS_PIN, HIGH); SPIx.end(); };
-  static void DataTransferAbort();
-
-  static void WriteData(uint16_t Data) { Transmit(Data); }
-  static void WriteReg(uint16_t Reg) { OUT_WRITE(TFT_A0_PIN, LOW); Transmit(Reg); OUT_WRITE(TFT_A0_PIN, HIGH); }
-
-  static void WriteSequence(uint16_t *Data, uint16_t Count) { TransmitDMA(DMA_MINC_ENABLE, Data, Count); }
-  // static void WriteMultiple(uint16_t Color, uint16_t Count) { static uint16_t Data; Data = Color; TransmitDMA(DMA_MINC_DISABLE, &Data, Count); }
-  static void WriteMultiple(uint16_t Color, uint32_t Count) {
-    static uint16_t Data; Data = Color;
-    //LPC dma can only write 0xFFF bytes at once.
-    #define MAX_DMA_SIZE (0xFFF - 1)
-    while (Count > 0) {
-      TransmitDMA(DMA_MINC_DISABLE, &Data, Count > MAX_DMA_SIZE ? MAX_DMA_SIZE : Count);
-      Count = Count > MAX_DMA_SIZE ? Count - MAX_DMA_SIZE : 0;
-    }
-    #undef MAX_DMA_SIZE
-  }
-};

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

@@ -1,131 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-
-#include "../../../inc/MarlinConfig.h"
-
-#if HAS_TFT_XPT2046 || HAS_TOUCH_BUTTONS
-
-#include "xpt2046.h"
-#include <SPI.h>
-
-uint16_t delta(uint16_t a, uint16_t b) { return a > b ? a - b : b - a; }
-
-#if ENABLED(TOUCH_BUTTONS_HW_SPI)
-  #include <SPI.h>
-
-  SPIClass XPT2046::SPIx(TOUCH_BUTTONS_HW_SPI_DEVICE);
-
-  static void touch_spi_init(uint8_t spiRate) {
-    XPT2046::SPIx.setModule(TOUCH_BUTTONS_HW_SPI_DEVICE);
-    XPT2046::SPIx.setClock(SPI_CLOCK_DIV128);
-    XPT2046::SPIx.setBitOrder(MSBFIRST);
-    XPT2046::SPIx.setDataMode(SPI_MODE0);
-    XPT2046::SPIx.setDataSize(DATA_SIZE_8BIT);
-  }
-#endif
-
-void XPT2046::Init() {
-  SET_INPUT(TOUCH_MISO_PIN);
-  SET_OUTPUT(TOUCH_MOSI_PIN);
-  SET_OUTPUT(TOUCH_SCK_PIN);
-  OUT_WRITE(TOUCH_CS_PIN, HIGH);
-
-  #if PIN_EXISTS(TOUCH_INT)
-    // Optional Pendrive interrupt pin
-    SET_INPUT(TOUCH_INT_PIN);
-  #endif
-
-  TERN_(TOUCH_BUTTONS_HW_SPI, touch_spi_init(SPI_SPEED_6));
-
-  // Read once to enable pendrive status pin
-  getRawData(XPT2046_X);
-}
-
-bool XPT2046::isTouched() {
-  return isBusy() ? false : (
-    #if PIN_EXISTS(TOUCH_INT)
-      READ(TOUCH_INT_PIN) != HIGH
-    #else
-      getRawData(XPT2046_Z1) >= XPT2046_Z1_THRESHOLD
-    #endif
-  );
-}
-
-bool XPT2046::getRawPoint(int16_t *x, int16_t *y) {
-  if (isBusy()) return false;
-  if (!isTouched()) return false;
-  *x = getRawData(XPT2046_X);
-  *y = getRawData(XPT2046_Y);
-  return isTouched();
-}
-
-uint16_t XPT2046::getRawData(const XPTCoordinate coordinate) {
-  uint16_t data[3];
-
-  DataTransferBegin();
-  TERN_(TOUCH_BUTTONS_HW_SPI, SPIx.begin());
-
-  for (uint16_t i = 0; i < 3 ; i++) {
-    IO(coordinate);
-    data[i] = (IO() << 4) | (IO() >> 4);
-  }
-
-  TERN_(TOUCH_BUTTONS_HW_SPI, SPIx.end());
-  DataTransferEnd();
-
-  uint16_t delta01 = delta(data[0], data[1]),
-           delta02 = delta(data[0], data[2]),
-           delta12 = delta(data[1], data[2]);
-
-  if (delta01 > delta02 || delta01 > delta12)
-    data[delta02 > delta12 ? 0 : 1] = data[2];
-
-  return (data[0] + data[1]) >> 1;
-}
-
-uint16_t XPT2046::IO(uint16_t data) {
-  return TERN(TOUCH_BUTTONS_HW_SPI, HardwareIO, SoftwareIO)(data);
-}
-
-extern uint8_t spiTransfer(uint8_t b);
-
-#if ENABLED(TOUCH_BUTTONS_HW_SPI)
-  uint16_t XPT2046::HardwareIO(uint16_t data) {
-    return SPIx.transfer(data & 0xFF);
-  }
-#endif
-
-uint16_t XPT2046::SoftwareIO(uint16_t data) {
-  uint16_t result = 0;
-
-  for (uint8_t j = 0x80; j; j >>= 1) {
-    WRITE(TOUCH_SCK_PIN, LOW);
-    WRITE(TOUCH_MOSI_PIN, data & j ? HIGH : LOW);
-    if (READ(TOUCH_MISO_PIN)) result |= j;
-    WRITE(TOUCH_SCK_PIN, HIGH);
-  }
-  WRITE(TOUCH_SCK_PIN, LOW);
-
-  return result;
-}
-
-#endif // HAS_TFT_XPT2046

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

@@ -1,83 +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 "../../../inc/MarlinConfig.h"
-
-#if ENABLED(TOUCH_BUTTONS_HW_SPI)
-  #include <SPI.h>
-#endif
-
-#ifndef TOUCH_MISO_PIN
-  #define TOUCH_MISO_PIN SD_MISO_PIN
-#endif
-#ifndef TOUCH_MOSI_PIN
-  #define TOUCH_MOSI_PIN SD_MOSI_PIN
-#endif
-#ifndef TOUCH_SCK_PIN
-  #define TOUCH_SCK_PIN  SD_SCK_PIN
-#endif
-#ifndef TOUCH_CS_PIN
-  #define TOUCH_CS_PIN   SD_SS_PIN
-#endif
-#ifndef TOUCH_INT_PIN
-  #define TOUCH_INT_PIN  -1
-#endif
-
-#define XPT2046_DFR_MODE        0x00
-#define XPT2046_SER_MODE        0x04
-#define XPT2046_CONTROL         0x80
-
-enum XPTCoordinate : uint8_t {
-  XPT2046_X  = 0x10 | XPT2046_CONTROL | XPT2046_DFR_MODE,
-  XPT2046_Y  = 0x50 | XPT2046_CONTROL | XPT2046_DFR_MODE,
-  XPT2046_Z1 = 0x30 | XPT2046_CONTROL | XPT2046_DFR_MODE,
-  XPT2046_Z2 = 0x40 | XPT2046_CONTROL | XPT2046_DFR_MODE,
-};
-
-#if !defined(XPT2046_Z1_THRESHOLD)
-  #define XPT2046_Z1_THRESHOLD 10
-#endif
-
-class XPT2046 {
-private:
-  static bool isBusy() { return false; }
-
-  static uint16_t getRawData(const XPTCoordinate coordinate);
-  static bool isTouched();
-
-  static inline void DataTransferBegin() { WRITE(TOUCH_CS_PIN, LOW); };
-  static inline void DataTransferEnd() { WRITE(TOUCH_CS_PIN, HIGH); };
-  #if ENABLED(TOUCH_BUTTONS_HW_SPI)
-    static uint16_t HardwareIO(uint16_t data);
-  #endif
-  static uint16_t SoftwareIO(uint16_t data);
-  static uint16_t IO(uint16_t data = 0);
-
-public:
-  #if ENABLED(TOUCH_BUTTONS_HW_SPI)
-    static SPIClass SPIx;
-  #endif
-
-  static void Init();
-  static bool getRawPoint(int16_t *x, int16_t *y);
-};

Marlin/src/HAL/LPC1768/timers.h

@@ -21,6 +21,7 @@
 #pragma once
 
 /**
+ *
  * HAL For LPC1768
  */
 

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

@@ -57,18 +57,15 @@
 
 #include "../../../inc/MarlinConfigPre.h"
 
-#if HAS_MARLINUI_U8GLIB
+#if HAS_GRAPHICAL_LCD
 
 #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) */
@@ -124,6 +124,6 @@ uint8_t u8g_com_HAL_LPC1768_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val,
   return 1;
 }
 
-#endif // HAS_MARLINUI_U8GLIB
+#endif // HAS_GRAPHICAL_LCD
 
 #endif // TARGET_LPC1768

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

@@ -77,7 +77,7 @@
 
 #include "../../../inc/MarlinConfigPre.h"
 
-#if HAS_MARLINUI_U8GLIB
+#if HAS_GRAPHICAL_LCD
 
 #include <U8glib.h>
 
@@ -193,6 +193,6 @@ uint8_t u8g_com_HAL_LPC1768_ssd_hw_i2c_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_v
   return 1;
 }
 
-#endif // HAS_MARLINUI_U8GLIB
+#endif // HAS_GRAPHICAL_LCD
 
 #endif // TARGET_LPC1768

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

@@ -57,7 +57,7 @@
 
 #include "../../../inc/MarlinConfigPre.h"
 
-#if HAS_MARLINUI_U8GLIB
+#if HAS_GRAPHICAL_LCD
 
 #include <U8glib.h>
 #include "../../shared/HAL_SPI.h"
@@ -133,6 +133,6 @@ uint8_t u8g_com_HAL_LPC1768_ST7920_hw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t ar
   return 1;
 }
 
-#endif // HAS_MARLINUI_U8GLIB
+#endif // HAS_GRAPHICAL_LCD
 
 #endif // TARGET_LPC1768

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

@@ -62,11 +62,9 @@
 #include <U8glib.h>
 #include <SoftwareSPI.h>
 #include "../../shared/Delay.h"
-#include "../../shared/HAL_SPI.h"
 
-#ifndef LCD_SPI_SPEED
+#undef SPI_SPEED
-  #define LCD_SPI_SPEED SPI_EIGHTH_SPEED  // About 1 MHz
+#define SPI_SPEED 3  // About 1 MHz
-#endif
 
 static pin_t SCK_pin_ST7920_HAL, MOSI_pin_ST7920_HAL_HAL;
 static uint8_t SPI_speed = 0;
@@ -94,7 +92,7 @@ uint8_t u8g_com_HAL_LPC1768_ST7920_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t ar
       u8g_SetPIOutput(u8g, U8G_PI_MOSI);
       u8g_Delay(5);
 
-      SPI_speed = swSpiInit(LCD_SPI_SPEED, SCK_pin_ST7920_HAL, MOSI_pin_ST7920_HAL_HAL);
+      SPI_speed = swSpiInit(SPI_SPEED, SCK_pin_ST7920_HAL, MOSI_pin_ST7920_HAL_HAL);
 
       u8g_SetPILevel(u8g, U8G_PI_CS, 0);
       u8g_SetPILevel(u8g, U8G_PI_SCK, 0);

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

@@ -57,14 +57,12 @@
 
 #include "../../../inc/MarlinConfigPre.h"
 
-#if HAS_MARLINUI_U8GLIB && DISABLED(U8GLIB_ST7920)
+#if HAS_GRAPHICAL_LCD && DISABLED(U8GLIB_ST7920)
 
 #include <SoftwareSPI.h>
-#include "../../shared/HAL_SPI.h"
 
-#ifndef LCD_SPI_SPEED
+#undef SPI_SPEED
-  #define LCD_SPI_SPEED SPI_QUARTER_SPEED  // About 2 MHz
+#define SPI_SPEED 2  // About 2 MHz
-#endif
 
 #include <Arduino.h>
 #include <algorithm>
@@ -147,7 +145,7 @@ uint8_t u8g_com_HAL_LPC1768_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val,
       u8g_SetPIOutput(u8g, U8G_PI_CS);
       u8g_SetPIOutput(u8g, U8G_PI_A0);
       if (U8G_PIN_NONE != u8g->pin_list[U8G_PI_RESET]) u8g_SetPIOutput(u8g, U8G_PI_RESET);
-      SPI_speed = swSpiInit(LCD_SPI_SPEED, u8g->pin_list[U8G_PI_SCK], u8g->pin_list[U8G_PI_MOSI]);
+      SPI_speed = swSpiInit(SPI_SPEED, u8g->pin_list[U8G_PI_SCK], u8g->pin_list[U8G_PI_MOSI]);
       u8g_SetPILevel(u8g, U8G_PI_SCK, 0);
       u8g_SetPILevel(u8g, U8G_PI_MOSI, 0);
       break;
@@ -205,5 +203,5 @@ uint8_t u8g_com_HAL_LPC1768_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val,
   return 1;
 }
 
-#endif // HAS_MARLINUI_U8GLIB && !U8GLIB_ST7920
+#endif // HAS_GRAPHICAL_LCD && !U8GLIB_ST7920
 #endif // TARGET_LPC1768

Marlin/src/HAL/LPC1768/upload_extra_script.py

@@ -23,50 +23,63 @@ def print_error(e):
 		  %(e, env.get('PIOENV')))
 
 try:
-	#
-	# Find a disk for upload
-	#
-	upload_disk = 'Disk not found'
-	target_file_found = False
-	target_drive_found = False
 	if current_OS == 'Windows':
 		#
 		# platformio.ini will accept this for a Windows upload port designation: 'upload_port = L:'
 		#   Windows - doesn't care about the disk's name, only cares about the drive letter
+		#
+
+		#
+		# get all drives on this computer
+		#
 		import subprocess
-		from ctypes import windll
+		# typical result (string): 'Drives: C:\ D:\ E:\ F:\ G:\ H:\ I:\ J:\ K:\ L:\ M:\ Y:\ Z:\'
-		import string
+		driveStr = str(subprocess.check_output("fsutil fsinfo drives"))
-
+		# typical result (string): 'C:\ D:\ E:\ F:\ G:\ H:\ I:\ J:\ K:\ L:\ M:\ Y:\ Z:\'
-		# getting list of drives
+		# driveStr = driveStr.strip().lstrip('Drives: ') <- Doesn't work in other Languages as English. In German is "Drives:" = "Laufwerke:"
-		# https://stackoverflow.com/questions/827371/is-there-a-way-to-list-all-the-available-drive-letters-in-python
+		FirstFound = driveStr.find(':',0,-1)         # Find the first ":" and
-		drives = []
+		driveStr = driveStr[FirstFound + 1 : -1]     # truncate to the rest
-		bitmask = windll.kernel32.GetLogicalDrives()
+		# typical result (array of stings): ['C:\\', 'D:\\', 'E:\\', 'F:\\',
-		for letter in string.ascii_uppercase:
+		# 'G:\\', 'H:\\', 'I:\\', 'J:\\', 'K:\\', 'L:\\', 'M:\\', 'Y:\\', 'Z:\\']
-			if bitmask & 1:
+		drives = driveStr.split()
-				drives.append(letter)
-			bitmask >>= 1
 
+		upload_disk = 'Disk not found'
+		target_file_found = False
+		target_drive_found = False
 		for drive in drives:
-			final_drive_name = drive + ':\\'
+			final_drive_name = drive.strip().rstrip('\\')   # typical result (string): 'C:'
-			# print ('disc check: {}'.format(final_drive_name))
 			try:
 				volume_info = str(subprocess.check_output('cmd /C dir ' + final_drive_name, stderr=subprocess.STDOUT))
 			except Exception as e:
-				print ('error:{}'.format(e))
 				continue
 			else:
-				if target_drive in volume_info and not target_file_found:  # set upload if not found target file yet
+				if target_drive in volume_info and target_file_found == False:  # set upload if not found target file yet
 					target_drive_found = True
 					upload_disk = final_drive_name
 				if target_filename in volume_info:
-					if not target_file_found:
+					if target_file_found == False:
 						upload_disk = final_drive_name
 					target_file_found = True
 
+		#
+		# set upload_port to drive if found
+		#
+
+		if target_file_found == True or target_drive_found == True:
+			env.Replace(
+				UPLOAD_PORT=upload_disk
+			)
+			print('upload disk: ', upload_disk)
+		else:
+			print_error('Autodetect Error')
+
 	elif current_OS == 'Linux':
 		#
 		# platformio.ini will accept this for a Linux upload port designation: 'upload_port = /media/media_name/drive'
 		#
+		upload_disk = 'Disk not found'
+		target_file_found = False
+		target_drive_found = False
 		drives = os.listdir(os.path.join(os.sep, 'media', getpass.getuser()))
 		if target_drive in drives:  # If target drive is found, use it.
 			target_drive_found = True
@@ -88,15 +101,22 @@ try:
 
 		if target_file_found or target_drive_found:
 			env.Replace(
-				UPLOAD_FLAGS="-P$UPLOAD_PORT"
+				UPLOAD_FLAGS="-P$UPLOAD_PORT",
+				UPLOAD_PORT=upload_disk
 			)
+			print('upload disk: ', upload_disk)
+		else:
+			print_error('Autodetect Error')
 
 	elif current_OS == 'Darwin':  # MAC
 		#
 		# platformio.ini will accept this for a OSX upload port designation: 'upload_port = /media/media_name/drive'
 		#
+		upload_disk = 'Disk not found'
 		drives = os.listdir('/Volumes')  # human readable names
-		if target_drive in drives and not target_file_found:  # set upload if not found target file yet
+		target_file_found = False
+		target_drive_found = False
+		if target_drive in drives and target_file_found == False:  # set upload if not found target file yet
 			target_drive_found = True
 			upload_disk = '/Volumes/' + target_drive + '/'
 		for drive in drives:
@@ -106,18 +126,20 @@ try:
 				continue
 			else:
 				if target_filename in filenames:
-					if not target_file_found:
+					if target_file_found == False:
 						upload_disk = '/Volumes/' + drive + '/'
 					target_file_found = True
+		#
+		# set upload_port to drive if found
+		#
 
-	#
+		if target_file_found == True or target_drive_found == True:
-	# Set upload_port to drive if found
+			env.Replace(
-	#
+				UPLOAD_PORT=upload_disk
-	if target_file_found or target_drive_found:
+			)
-		env.Replace(UPLOAD_PORT=upload_disk)
+			print('\nupload disk: ', upload_disk, '\n')
-		print('\nUpload disk: ', upload_disk, '\n')
+		else:
-	else:
+			print_error('Autodetect Error')
-		print_error('Autodetect Error')
 
 except Exception as e:
 	print_error(str(e))