verbose on debug

Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>

.aiderignore

@@ -0,0 +1,21 @@
+# Build artifacts
+buildroot/
+*.o
+*.a
+*.so
+*.dylib
+*.dll
+*.exe
+
+# Web assets
+*.min.js
+*.min.css
+
+# Generated files
+__pycache__/
+*.pyc
+.DS_Store
+
+# IDE files
+.vscode/
+.idea/

.github/ISSUE_TEMPLATE/config.yml

@@ -7,7 +7,7 @@ contact_links:
     url: https://www.facebook.com/groups/1049718498464482
     about: Please ask and answer questions here.
   - name: 🕹 Marlin on Discord
-    url: https://discord.gg/n5NJ59y
+    url: https://discord.com/servers/marlin-firmware-461605380783472640
     about: Join the Discord server for support and discussion.
   - name: 🔗 Marlin Discussion Forum
     url: https://reprap.org/forum/list.php?415

.github/contributing.md

@@ -43,7 +43,7 @@ We have a Message Board and a Facebook group where our knowledgable user communi
 
 If chat is more your speed, you can join the MarlinFirmware Discord server:
 
-* Use the link https://discord.gg/n5NJ59y to join up as a General User.
+* Use the link https://discord.com/servers/marlin-firmware-461605380783472640 to join up as a General User.
 * Even though our Discord is pretty active, it may take a while for community members to respond — please be patient!
 * Use the `#general` channel for general questions or discussion about Marlin.
 * Other channels exist for certain topics or are limited to Patrons. Check the channel list.

.github/workflows/auto-label.yml

@@ -14,7 +14,7 @@ jobs:
   autolabel:
     name: Auto Label
     if: github.repository == 'MarlinFirmware/Marlin'
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
     - name: Auto Label for [BUG]
       uses: actions/github-script@v7

.github/workflows/bump-date.yml

@@ -14,7 +14,7 @@ jobs:
     name: Bump Distribution Date
     if: github.repository == 'MarlinFirmware/Marlin'
 
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
 
     steps:
 

.github/workflows/check-pr.yml

@@ -18,7 +18,7 @@ jobs:
     name: PR Bad Target
     if: github.repository == 'MarlinFirmware/Marlin'
 
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
 
     steps:
     - uses: superbrothers/close-pull-request@v3

.github/workflows/ci-build-tests.yml

@@ -14,6 +14,8 @@ on:
     - config/**
     - data/**
     - docs/**
+    - test/**
+    - Marlin/tests/**
     - '**/*.md'
   push:
     branches:
@@ -23,6 +25,8 @@ on:
     - config/**
     - data/**
     - docs/**
+    - test/**
+    - Marlin/tests/**
     - '**/*.md'
 
 jobs:
@@ -30,14 +34,19 @@ jobs:
     name: Build Test
     if: github.repository == 'MarlinFirmware/Marlin'
 
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
 
     strategy:
+      fail-fast: true
       matrix:
         test-platform:
 
+        # RP2040
+        - SKR_Pico
+
         # Native
         - linux_native
+        - simulator_linux_release
 
         # AVR
         - mega2560
@@ -100,9 +109,9 @@ jobs:
 
         # STM32F4
         - ARMED
-        - BIGTREE_BTT002
-        - BIGTREE_GTR_V1_0
-        - BIGTREE_SKR_PRO
+        - BTT_BTT002
+        - BTT_GTR_V1_0
+        - BTT_SKR_PRO
         - FLYF407ZG
         - FYSETC_S6
         - LERDGEK
@@ -177,6 +186,13 @@ jobs:
         pio upgrade --dev
         pio pkg update --global
 
+    - name: Install Simulator dependencies
+      run: |
+        sudo apt-get install build-essential
+        sudo apt-get install libsdl2-dev
+        sudo apt-get install libsdl2-net-dev
+        sudo apt-get install libglm-dev
+
     - name: Run ${{ matrix.test-platform }} Tests
       run: |
         make tests-single-ci TEST_TARGET=${{ matrix.test-platform }}

.github/workflows/ci-unit-tests.yml

@@ -36,7 +36,7 @@ jobs:
     # pulls them into additional branches.
     if: github.repository == 'MarlinFirmware/Marlin'
 
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
 
     steps:
     - name: Check out the PR

.github/workflows/ci-validate-boards.yml

@@ -0,0 +1,48 @@
+#
+# ci-validate-boards.yml
+# Validate boards.h to make sure it's all set up correctly
+#
+
+name: CI - Validate boards.h
+
+# We can do the on: section as two items, one for pull requests and one for pushes...
+on:
+  pull_request:
+    branches:
+    - bugfix-2.1.x
+    paths:
+    - 'Marlin/src/core/boards.h'
+  push:
+    branches:
+    - bugfix-2.1.x
+    paths:
+    - 'Marlin/src/core/boards.h'
+
+jobs:
+  validate_pins_files:
+    name: Validate boards.h
+    if: github.repository == 'MarlinFirmware/Marlin'
+
+    runs-on: ubuntu-22.04
+
+    steps:
+    - name: Check out the PR
+      uses: actions/checkout@v4
+
+    - name: Cache pip
+      uses: actions/cache@v4
+      with:
+        path: ~/.cache/pip
+        key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
+        restore-keys: |
+          ${{ runner.os }}-pip-
+
+    - name: Select Python 3.9
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.9'
+        architecture: 'x64'
+
+    - name: Validate core/boards.h
+      run: |
+        make validate-boards -j

.github/workflows/ci-validate-pins.yml

@@ -0,0 +1,51 @@
+#
+# ci-validate-pins.yml
+# Validate that all of the pins files are unchanged by pinsformat.py
+#
+
+name: CI - Validate Pins Files
+
+on:
+  pull_request:
+    branches:
+    - bugfix-2.1.x
+    # Cannot be enabled on 2.1.x until it contains the unit test framework
+    #- 2.1.x
+    paths:
+    - 'Marlin/src/pins/*/**'
+  push:
+    branches:
+    - bugfix-2.1.x
+    # Cannot be enabled on 2.1.x until it contains the unit test framework
+    #- 2.1.x
+    paths:
+    - 'Marlin/src/pins/*/**'
+
+jobs:
+  validate_pins_files:
+    name: Validate Pins Files
+    if: github.repository == 'MarlinFirmware/Marlin'
+
+    runs-on: ubuntu-22.04
+
+    steps:
+    - name: Check out the PR
+      uses: actions/checkout@v4
+
+    - name: Cache pip
+      uses: actions/cache@v4
+      with:
+        path: ~/.cache/pip
+        key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
+        restore-keys: |
+          ${{ runner.os }}-pip-
+
+    - name: Select Python 3.9
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.9'
+        architecture: 'x64'
+
+    - name: Validate all pins files
+      run: |
+        make validate-pins -j

.github/workflows/clean-closed.yml

@@ -13,7 +13,7 @@ on:
 
 jobs:
   remove_label:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
 
     strategy:
       matrix:

.github/workflows/close-stale.yml

@@ -14,7 +14,7 @@ jobs:
     name: Close Stale Issues
     if: github.repository == 'MarlinFirmware/Marlin'
 
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
 
     steps:
     - uses: actions/stale@v9

.github/workflows/lock-closed.yml

@@ -14,7 +14,7 @@ jobs:
     name: Lock Closed Issues
     if: github.repository == 'MarlinFirmware/Marlin'
 
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
 
     steps:
     - uses: dessant/lock-threads@v5

.github/workflows/unlock-reopened.yml

@@ -14,7 +14,7 @@ jobs:
     name: Unlock Reopened
     if: github.repository == 'MarlinFirmware/Marlin'
 
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
 
     steps:
     - uses: OSDKDev/unlock-issues@v1.1

.gitignore

@@ -125,6 +125,7 @@ vc-fileutils.settings
 # Visual Studio Code
 .vscode/*
 !.vscode/extensions.json
+*.code-workspace
 
 # Simulation files
 imgui.ini
@@ -168,3 +169,6 @@ __pycache__
 tags
 *.logs
 *.bak
+.aider*
+!.aiderignore
+.env

.zed/settings.json

@@ -0,0 +1,16 @@
+/**
+ * Marlin-specific settings for Zed
+ *
+ * For a full list of overridable settings, and general information on folder-specific settings,
+ * see the documentation: https://zed.dev/docs/configuring-zed#settings-files
+ */
+{
+  "languages": {
+    "C": {
+      "enable_language_server": false
+    },
+    "C++": {
+      "enable_language_server": false
+    }
+  }
+}

Makefile

@@ -2,22 +2,24 @@ SCRIPTS_DIR := buildroot/share/scripts
 CONTAINER_RT_BIN := docker
 CONTAINER_RT_OPTS := --rm -v $(PWD):/code -v platformio-cache:/root/.platformio
 CONTAINER_IMAGE := marlin-dev
+UNIT_TEST_CONFIG ?= default
 
 help:
 	@echo "Tasks for local development:"
-	@echo "make marlin                    : Build marlin for the configured board"
-	@echo "make format-pins               : Reformat all pins files"
+	@echo "make marlin                    : Build Marlin for the configured board"
+	@echo "make format-pins -j            : Reformat all pins files (-j for parallel execution)"
+	@echo "make validate-pins -j          : Validate all pins files, fails if any require reformatting"
+	@echo "make validate-boards -j        : Validate boards.h and pins.h for standards compliance"
 	@echo "make tests-single-ci           : Run a single test from inside the CI"
 	@echo "make tests-single-local        : Run a single test locally"
 	@echo "make tests-single-local-docker : Run a single test locally, using docker"
 	@echo "make tests-all-local           : Run all tests locally"
 	@echo "make tests-all-local-docker    : Run all tests locally, using docker"
-#	@echo "make unit-test-single-ci      : Run a single code test from inside the CI"
-#	@echo "make unit-test-single-local   : Run a single code test locally"
-#	@echo "make unit-test-single-local-docker : Run a single code test locally, using docker-compose"
+	@echo "make unit-test-single-local    : Run unit tests for a single config locally"
+	@echo "make unit-test-single-local-docker : Run unit tests for a single config locally, using docker"
 	@echo "make unit-test-all-local      : Run all code tests locally"
-	@echo "make unit-test-all-local-docker : Run all code tests locally, using docker-compose"
-	@echo "make setup-local-docker        : Setup local docker-compose"
+	@echo "make unit-test-all-local-docker : Run all code tests locally, using docker"
+	@echo "make setup-local-docker        : Setup local docker using buildx"
 	@echo ""
 	@echo "Options for testing:"
 	@echo "  TEST_TARGET          Set when running tests-single-*, to select the"
@@ -27,6 +29,9 @@ help:
 	@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 "  UNIT_TEST_CONFIG     Set the name of the config from the test folder, without"
+	@echo "                       the leading number. Default is 'default'". Used with the
+	@echo "                       unit-test-single-* tasks"
 	@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!"
@@ -51,27 +56,29 @@ tests-single-local-docker:
 	$(CONTAINER_RT_BIN) run $(CONTAINER_RT_OPTS) $(CONTAINER_IMAGE) make tests-single-local TEST_TARGET=$(TEST_TARGET) VERBOSE_PLATFORMIO=$(VERBOSE_PLATFORMIO) GIT_RESET_HARD=$(GIT_RESET_HARD) ONLY_TEST="$(ONLY_TEST)"
 
 tests-all-local:
+	@python -c "import yaml" 2>/dev/null || (echo 'pyyaml module is not installed. Install it with "python -m pip install pyyaml"' && exit 1)
 	export PATH="./buildroot/bin/:./buildroot/tests/:${PATH}" \
 	  && export VERBOSE_PLATFORMIO=$(VERBOSE_PLATFORMIO) \
-	  && for TEST_TARGET in $$($(SCRIPTS_DIR)/get_test_targets.py) ; do echo "Running tests for $$TEST_TARGET" ; run_tests . $$TEST_TARGET ; done
+	  && for TEST_TARGET in $$(python $(SCRIPTS_DIR)/get_test_targets.py) ; do \
+	    if [ "$$TEST_TARGET" = "linux_native" ] && [ "$$(uname)" = "Darwin" ]; then \
+	      echo "Skipping tests for $$TEST_TARGET on macOS" ; \
+	      continue ; \
+	    fi ; \
+	    echo "Running tests for $$TEST_TARGET" ; \
+	    run_tests . $$TEST_TARGET || exit 1 ; \
+	    sleep 5; \
+	  done
 
 tests-all-local-docker:
 	@if ! $(CONTAINER_RT_BIN) images -q $(CONTAINER_IMAGE) > /dev/null ; then $(MAKE) setup-local-docker ; fi
 	$(CONTAINER_RT_BIN) run $(CONTAINER_RT_OPTS) $(CONTAINER_IMAGE) make tests-all-local VERBOSE_PLATFORMIO=$(VERBOSE_PLATFORMIO) GIT_RESET_HARD=$(GIT_RESET_HARD)
 
-#unit-test-single-ci:
-#	export GIT_RESET_HARD=true
-#	$(MAKE) unit-test-single-local TEST_TARGET=$(TEST_TARGET)
+unit-test-single-local:
+	platformio run -t marlin_$(UNIT_TEST_CONFIG) -e linux_native_test
 
-# TODO: How can we limit tests with ONLY_TEST with platformio?
-#unit-test-single-local:
-#	@if ! test -n "$(TEST_TARGET)" ; then echo "***ERROR*** Set TEST_TARGET=<your-module> or use make unit-test-all-local" ; return 1; fi
-#	platformio run -t marlin_$(TEST_TARGET)
-
-#unit-test-single-local-docker:
-#	@if ! test -n "$(TEST_TARGET)" ; then echo "***ERROR*** Set TEST_TARGET=<your-module> or use make unit-test-all-local-docker" ; return 1; fi
-#	@if ! $(CONTAINER_RT_BIN) images -q $(CONTAINER_IMAGE) > /dev/null ; then $(MAKE) setup-local-docker ; fi
-#	$(CONTAINER_RT_BIN) run $(CONTAINER_RT_OPTS)  $(CONTAINER_IMAGE) make unit-test-single-local TEST_TARGET=$(TEST_TARGET) ONLY_TEST="$(ONLY_TEST)"
+unit-test-single-local-docker:
+	@if ! $(CONTAINER_RT_BIN) images -q $(CONTAINER_IMAGE) > /dev/null ; then $(MAKE) setup-local-docker ; fi
+	$(CONTAINER_RT_BIN) run $(CONTAINER_RT_OPTS)  $(CONTAINER_IMAGE) make unit-test-single-local UNIT_TEST_CONFIG=$(UNIT_TEST_CONFIG)
 
 unit-test-all-local:
 	platformio run -t test-marlin -e linux_native_test
@@ -85,7 +92,22 @@ setup-local-docker:
 
 PINS := $(shell find Marlin/src/pins -mindepth 2 -name '*.h')
 
+.PHONY: $(PINS) format-pins validate-pins
+
 $(PINS): %:
-	@echo "Formatting $@" && node $(SCRIPTS_DIR)/pinsformat.js $@
+	@echo "Formatting $@"
+	@python $(SCRIPTS_DIR)/pinsformat.py $< $@
 
 format-pins: $(PINS)
+
+validate-pins: format-pins
+	@echo "Validating pins files"
+	@git diff --exit-code || (git status && echo "\nError: Pins files are not formatted correctly. Run \"make format-pins\" to fix.\n" && exit 1)
+
+BOARDS_FILE := Marlin/src/core/boards.h
+
+.PHONY: validate-boards
+
+validate-boards:
+	@echo "Validating boards.h file"
+	@python $(SCRIPTS_DIR)/validate_boards.py $(BOARDS_FILE) || (echo "\nError: boards.h file is not valid. Please check and correct it.\n" && exit 1)

Marlin/Makefile

@@ -187,6 +187,17 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1033)
 # RAMPS Plus 3DYMY (Power outputs: Spindle, Controller Fan)
 else ifeq ($(HARDWARE_MOTHERBOARD),1034)
 
+# RAMPS 1.6+ (Power outputs: Hotend, Fan, Bed)
+else ifeq ($(HARDWARE_MOTHERBOARD),1035)
+# RAMPS 1.6+ (Power outputs: Hotend0, Hotend1, Bed)
+else ifeq ($(HARDWARE_MOTHERBOARD),1036)
+# RAMPS 1.6+ (Power outputs: Hotend, Fan0, Fan1)
+else ifeq ($(HARDWARE_MOTHERBOARD),1037)
+# RAMPS 1.6+ (Power outputs: Hotend0, Hotend1, Fan)
+else ifeq ($(HARDWARE_MOTHERBOARD),1038)
+# RAMPS 1.6+ (Power outputs: Spindle, Controller Fan)
+else ifeq ($(HARDWARE_MOTHERBOARD),1039)
+
 #
 # RAMPS Derivatives - ATmega1280, ATmega2560
 #
@@ -221,108 +232,113 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1112)
 else ifeq ($(HARDWARE_MOTHERBOARD),1113)
 # BigTreeTech or BIQU KFB2.0
 else ifeq ($(HARDWARE_MOTHERBOARD),1114)
-# zrib V2.0 (Chinese RAMPS replica)
+# Zonestar zrib V2.0 (Chinese RAMPS replica)
 else ifeq ($(HARDWARE_MOTHERBOARD),1115)
-# zrib V5.2 (Chinese RAMPS replica)
+# Zonestar zrib V5.2 (Chinese RAMPS replica)
 else ifeq ($(HARDWARE_MOTHERBOARD),1116)
-# Felix 2.0+ Electronics Board (RAMPS like)
+# Zonestar zrib V5.3 (Chinese RAMPS replica)
 else ifeq ($(HARDWARE_MOTHERBOARD),1117)
-# Invent-A-Part RigidBoard
+# Felix 2.0+ Electronics Board (RAMPS like)
 else ifeq ($(HARDWARE_MOTHERBOARD),1118)
-# Invent-A-Part RigidBoard V2
+# Invent-A-Part RigidBoard
 else ifeq ($(HARDWARE_MOTHERBOARD),1119)
-# Sainsmart 2-in-1 board
+# Invent-A-Part RigidBoard V2
 else ifeq ($(HARDWARE_MOTHERBOARD),1120)
-# Ultimaker
+# Sainsmart 2-in-1 board
 else ifeq ($(HARDWARE_MOTHERBOARD),1121)
-# Ultimaker (Older electronics. Pre 1.5.4. This is rare)
+# Ultimaker
 else ifeq ($(HARDWARE_MOTHERBOARD),1122)
+# Ultimaker (Older electronics. Pre 1.5.4. This is rare)
+else ifeq ($(HARDWARE_MOTHERBOARD),1123)
   MCU              ?= atmega1280
   PROG_MCU         ?= m1280
 # Azteeg X3
-else ifeq ($(HARDWARE_MOTHERBOARD),1123)
-# Azteeg X3 Pro
 else ifeq ($(HARDWARE_MOTHERBOARD),1124)
-# Ultimainboard 2.x (Uses TEMP_SENSOR 20)
+# Azteeg X3 Pro
 else ifeq ($(HARDWARE_MOTHERBOARD),1125)
-# Rumba
+# Ultimainboard 2.x (Uses TEMP_SENSOR 20)
 else ifeq ($(HARDWARE_MOTHERBOARD),1126)
-# Raise3D N series Rumba derivative
+# Rumba
 else ifeq ($(HARDWARE_MOTHERBOARD),1127)
-# Rapide Lite 200 (v1, low-cost RUMBA clone with drv)
+# Raise3D N series Rumba derivative
 else ifeq ($(HARDWARE_MOTHERBOARD),1128)
-# Formbot T-Rex 2 Plus
+# Rapide Lite 200 (v1, low-cost RUMBA clone with drv)
 else ifeq ($(HARDWARE_MOTHERBOARD),1129)
-# Formbot T-Rex 3
+# Formbot T-Rex 2 Plus
 else ifeq ($(HARDWARE_MOTHERBOARD),1130)
-# Formbot Raptor
+# Formbot T-Rex 3
 else ifeq ($(HARDWARE_MOTHERBOARD),1131)
-# Formbot Raptor 2
+# Formbot Raptor
 else ifeq ($(HARDWARE_MOTHERBOARD),1132)
-# bq ZUM Mega 3D
+# Formbot Raptor 2
 else ifeq ($(HARDWARE_MOTHERBOARD),1133)
-# MakeBoard Mini v2.1.2 by MicroMake
+# bq ZUM Mega 3D
 else ifeq ($(HARDWARE_MOTHERBOARD),1134)
-# TriGorilla Anycubic version 1.3-based on RAMPS EFB
+# MakeBoard Mini v2.1.2 by MicroMake
 else ifeq ($(HARDWARE_MOTHERBOARD),1135)
-#   ... Ver 1.4
+# TriGorilla Anycubic version 1.3-based on RAMPS EFB
 else ifeq ($(HARDWARE_MOTHERBOARD),1136)
-#   ... Rev 1.1 (new servo pin order)
+#   ... Ver 1.4
 else ifeq ($(HARDWARE_MOTHERBOARD),1137)
-# Creality: Ender-4, CR-8
+#   ... Rev 1.1 (new servo pin order)
 else ifeq ($(HARDWARE_MOTHERBOARD),1138)
-# Creality: CR10S, CR20, CR-X
+# Creality: Ender-4, CR-8
 else ifeq ($(HARDWARE_MOTHERBOARD),1139)
-# Dagoma F5
+# Creality: CR10S, CR20, CR-X
 else ifeq ($(HARDWARE_MOTHERBOARD),1140)
-# FYSETC F6 1.3
+# Dagoma F5
 else ifeq ($(HARDWARE_MOTHERBOARD),1141)
-# FYSETC F6 1.4
+# Dagoma D6 (as found in the Dagoma DiscoUltimate V2 TMC)
 else ifeq ($(HARDWARE_MOTHERBOARD),1142)
-# Wanhao Duplicator i3 Plus
+# FYSETC F6 1.3
 else ifeq ($(HARDWARE_MOTHERBOARD),1143)
-# VORON Design
+# FYSETC F6 1.4
 else ifeq ($(HARDWARE_MOTHERBOARD),1144)
-# Tronxy TRONXY-V3-1.0
+# Wanhao Duplicator i3 Plus
 else ifeq ($(HARDWARE_MOTHERBOARD),1145)
-# Z-Bolt X Series
+# VORON Design
 else ifeq ($(HARDWARE_MOTHERBOARD),1146)
-# TT OSCAR
+# Tronxy TRONXY-V3-1.0
 else ifeq ($(HARDWARE_MOTHERBOARD),1147)
-# Overlord/Overlord Pro
+# Z-Bolt X Series
 else ifeq ($(HARDWARE_MOTHERBOARD),1148)
-# ADIMLab Gantry v1
+# TT OSCAR
 else ifeq ($(HARDWARE_MOTHERBOARD),1149)
-# ADIMLab Gantry v2
-else ifeq ($(HARDWARE_MOTHERBOARD),1150)
 # BIQU Tango V1
-else ifeq ($(HARDWARE_MOTHERBOARD),1151)
+else ifeq ($(HARDWARE_MOTHERBOARD),1150)
 # MKS GEN L V2
-else ifeq ($(HARDWARE_MOTHERBOARD),1152)
+else ifeq ($(HARDWARE_MOTHERBOARD),1151)
 # MKS GEN L V2.1
-else ifeq ($(HARDWARE_MOTHERBOARD),1153)
+else ifeq ($(HARDWARE_MOTHERBOARD),1152)
 # Copymaster 3D
-else ifeq ($(HARDWARE_MOTHERBOARD),1154)
+else ifeq ($(HARDWARE_MOTHERBOARD),1153)
 # Ortur 4
-else ifeq ($(HARDWARE_MOTHERBOARD),1155)
+else ifeq ($(HARDWARE_MOTHERBOARD),1154)
 # Tenlog D3 Hero IDEX printer
+else ifeq ($(HARDWARE_MOTHERBOARD),1155)
+# Tenlog D3, D5, D6 IDEX Printer
 else ifeq ($(HARDWARE_MOTHERBOARD),1156)
-# Tenlog D3,5,6 Pro IDEX printers
-else ifeq ($(HARDWARE_MOTHERBOARD),1157)
 # Ramps S 1.2 by Sakul.cz (Power outputs: Hotend0, Hotend1, Fan, Bed)
-else ifeq ($(HARDWARE_MOTHERBOARD),1158)
+else ifeq ($(HARDWARE_MOTHERBOARD),1157)
 # Ramps S 1.2 by Sakul.cz (Power outputs: Hotend0, Hotend1, Hotend2, Bed)
-else ifeq ($(HARDWARE_MOTHERBOARD),1159)
+else ifeq ($(HARDWARE_MOTHERBOARD),1158)
 # Ramps S 1.2 by Sakul.cz (Power outputs: Hotend, Fan0, Fan1, Bed)
-else ifeq ($(HARDWARE_MOTHERBOARD),1160)
+else ifeq ($(HARDWARE_MOTHERBOARD),1159)
 # Longer LK1 PRO / Alfawise U20 Pro (PRO version)
-else ifeq ($(HARDWARE_MOTHERBOARD),1161)
+else ifeq ($(HARDWARE_MOTHERBOARD),1160)
 # Longer LKx PRO / Alfawise Uxx Pro (PRO version)
-else ifeq ($(HARDWARE_MOTHERBOARD),1162)
-# Zonestar zrib V5.3 (Chinese RAMPS replica)
-else ifeq ($(HARDWARE_MOTHERBOARD),1163)
+else ifeq ($(HARDWARE_MOTHERBOARD),1161)
 # Pxmalion Core I3
+else ifeq ($(HARDWARE_MOTHERBOARD),1162)
+# Panowin Cutlass (as found in the Panowin F1)
+else ifeq ($(HARDWARE_MOTHERBOARD),1163)
+# Kodama Bardo V1.x (as found in the Kodama Trinus)
 else ifeq ($(HARDWARE_MOTHERBOARD),1164)
+# XTLW MFF V1.0
+else ifeq ($(HARDWARE_MOTHERBOARD),1165)
+# XTLW MFF V2.0
+else ifeq ($(HARDWARE_MOTHERBOARD),1166)
+
 
 #
 # RAMBo and derivatives
@@ -340,7 +356,7 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1203)
 else ifeq ($(HARDWARE_MOTHERBOARD),1204)
 # abee Scoovo X9H
 else ifeq ($(HARDWARE_MOTHERBOARD),1205)
-# Rambo ThinkerV2
+# ThinkerV2
 else ifeq ($(HARDWARE_MOTHERBOARD),1206)
 
 #
@@ -383,30 +399,40 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1315)
 else ifeq ($(HARDWARE_MOTHERBOARD),1316)
 # Geeetech GT2560 Rev B for A10(M/T/D)
 else ifeq ($(HARDWARE_MOTHERBOARD),1317)
-# Geeetech GT2560 Rev B for A10(M/T/D)
-else ifeq ($(HARDWARE_MOTHERBOARD),1318)
 # Geeetech GT2560 Rev B for Mecreator2
+else ifeq ($(HARDWARE_MOTHERBOARD),1318)
+# Geeetech GT2560 Rev B for A20(M/T/D)
 else ifeq ($(HARDWARE_MOTHERBOARD),1319)
-# Geeetech GT2560 Rev B for A20(M/T/D)
+# Geeetech GT2560 Rev B for A10(M/T/D)
 else ifeq ($(HARDWARE_MOTHERBOARD),1320)
-# Einstart retrofit
-else ifeq ($(HARDWARE_MOTHERBOARD),1321)
-# Wanhao 0ne+ i3 Mini
-else ifeq ($(HARDWARE_MOTHERBOARD),1322)
-# Leapfrog Xeed 2015
-else ifeq ($(HARDWARE_MOTHERBOARD),1323)
-# PICA Shield (original version)
-else ifeq ($(HARDWARE_MOTHERBOARD),1324)
-# PICA Shield (rev C or later)
-else ifeq ($(HARDWARE_MOTHERBOARD),1325)
-# Intamsys 4.0 (Funmat HT)
-else ifeq ($(HARDWARE_MOTHERBOARD),1326)
-# Malyan M180 Mainboard Version 2 (no display function, direct G-code only)
-else ifeq ($(HARDWARE_MOTHERBOARD),1327)
 # Geeetech GT2560 Rev B for A20(M/T/D)
+else ifeq ($(HARDWARE_MOTHERBOARD),1321)
+# Einstart retrofit
+else ifeq ($(HARDWARE_MOTHERBOARD),1322)
+# Wanhao 0ne+ i3 Mini
+else ifeq ($(HARDWARE_MOTHERBOARD),1323)
+# Overlord/Overlord Pro
+else ifeq ($(HARDWARE_MOTHERBOARD),1324)
+# ADIMLab Gantry v1
+else ifeq ($(HARDWARE_MOTHERBOARD),1325)
+# ADIMLab Gantry v2
+else ifeq ($(HARDWARE_MOTHERBOARD),1326)
+# Leapfrog Xeed 2015
+else ifeq ($(HARDWARE_MOTHERBOARD),1327)
+# PICA Shield (original version)
 else ifeq ($(HARDWARE_MOTHERBOARD),1328)
-# Mega controller & Protoneer CNC Shield V3.00
+# PICA Shield (rev C or later)
 else ifeq ($(HARDWARE_MOTHERBOARD),1329)
+# Intamsys 4.0 (Funmat HT)
+else ifeq ($(HARDWARE_MOTHERBOARD),1330)
+# Malyan M180 Mainboard Version 2 (no display function, direct G-code only)
+else ifeq ($(HARDWARE_MOTHERBOARD),1331)
+# Mega controller & Protoneer CNC Shield V3.00
+else ifeq ($(HARDWARE_MOTHERBOARD),1332)
+# WEEDO 62A board (TINA2, Monoprice Cadet, etc.)
+else ifeq ($(HARDWARE_MOTHERBOARD),1333)
+# Geeetech GT2560 V4.1B for A10(M/T/D)
+else ifeq ($(HARDWARE_MOTHERBOARD),1334)
 
 #
 # ATmega1281, ATmega2561
@@ -440,7 +466,7 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1502)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega644p
   PROG_MCU         ?= m644p
-# Melzi V2.0
+# Melzi V2
 else ifeq ($(HARDWARE_MOTHERBOARD),1503)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega1284p
@@ -450,36 +476,41 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1504)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega1284p
   PROG_MCU         ?= m1284p
-# Melzi Creality3D board (for CR-10 etc)
+# Melzi Creality3D (for CR-10 etc)
 else ifeq ($(HARDWARE_MOTHERBOARD),1505)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega1284p
   PROG_MCU         ?= m1284p
-# Melzi Malyan M150 board
+# Melzi Creality3D (for Ender-2)
 else ifeq ($(HARDWARE_MOTHERBOARD),1506)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega1284p
   PROG_MCU         ?= m1284p
-# Tronxy X5S
+# Melzi Malyan M150
 else ifeq ($(HARDWARE_MOTHERBOARD),1507)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega1284p
   PROG_MCU         ?= m1284p
-# STB V1.1
+# Tronxy X5S
 else ifeq ($(HARDWARE_MOTHERBOARD),1508)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega1284p
   PROG_MCU         ?= m1284p
-# Azteeg X1
+# STB V1.1
 else ifeq ($(HARDWARE_MOTHERBOARD),1509)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega1284p
   PROG_MCU         ?= m1284p
-# Anet 1.0 (Melzi clone)
+# Azteeg X1
 else ifeq ($(HARDWARE_MOTHERBOARD),1510)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega1284p
   PROG_MCU         ?= m1284p
+# Anet 1.0 (Melzi clone)
+else ifeq ($(HARDWARE_MOTHERBOARD),1511)
+  HARDWARE_VARIANT ?= Sanguino
+  MCU              ?= atmega1284p
+  PROG_MCU         ?= m1284p
 # ZoneStar ZMIB V2
 else ifeq ($(HARDWARE_MOTHERBOARD),1511)
   HARDWARE_VARIANT ?= Sanguino
@@ -995,7 +1026,7 @@ extcoff: $(TARGET).elf
 	$(NM) -n $< > $@
 
 # Link: create ELF output file from library.
-
+LDFLAGS+= -Wl,-V
 $(BUILD_DIR)/$(TARGET).elf: $(OBJ) Configuration.h
 	$(Pecho) "  CXX   $@"
 	$P $(CXX) $(LD_PREFIX) $(ALL_CXXFLAGS) -o $@ -L. $(OBJ) $(LDFLAGS) $(LD_SUFFIX)

Marlin/Version.h

@@ -16,7 +16,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 #pragma once
@@ -28,177 +28,32 @@
 /**
  * Marlin release version identifier
  */
-#define SHORT_BUILD_VERSION "DW7.4.9"
+//#define SHORT_BUILD_VERSION "bugfix-2.1.x"
 
 /**
  * Verbose version identifier which should contain a reference to the location
  * from where the binary was downloaded or the source code was compiled.
  */
-
-#if(ENABLED(MachineMini))
-  #define VerChar1 "M"
-#elif(ENABLED(MachineEnder2))
-  #define VerChar1 "E2"
-#elif(ENABLED(MachineEnder2Pro))
-  #define VerChar1 "E2P"
-#elif(ENABLED(MachineEnder3))
-  #define VerChar1 "E3"
-#elif ENABLED(MachineEnder3V2)
-  #define VerChar1 "E3V2"
-#elif ENABLED(MachineEnder3S1)
-  #define VerChar1 "E3S1"
-#elif ENABLED(MachineEnder3Max)
-  #define VerChar1 "E3M"
-#elif(ENABLED(MachineEnder4))
-  #define VerChar1 "E4"
-#elif(ENABLED(MachineEnder5))
-  #define VerChar1 "E5"
-#elif(ENABLED(MachineEnder6))
-  #define VerChar1 "E6"
-#elif(ENABLED(MachineEnder7))
-  #define VerChar1 "E7"
-#elif(ENABLED(MachineSermoonD1))
-  #define VerChar1 "D1"
-#elif(ENABLED(MachineEnder5Plus))
-  #define VerChar1 "E5P"
-#elif(ENABLED(MachineCR20))
-  #define VerChar1 "2"
-#elif(ENABLED(MachineCR10Orig))
-  #define VerChar1 "O"
-#elif(ENABLED(MachineCR10Std))
-  #define VerChar1 "S"
-#elif(ENABLED(MachineCRX))
-  #define VerChar1 "X"
-#elif(ENABLED(MachineCR6))
-  #define VerChar1 "CR6"
-#elif(ENABLED(MachineCR5))
-  #define VerChar1 "CR5"
-#elif(ENABLED(MachineCR6Max))
-  #define VerChar1 "CR6M"
-#elif(ENABLED(MachineS4))
-  #define VerChar1 "4"
-#elif(ENABLED(MachineS5) || ENABLED(MachineCR10Max))
-  #define VerChar1 "5"
-#elif ENABLED(MachineCR2020)
-  #define VerChar1 "20"
-#elif(ENABLED(MachineCR30))
-  #define VerChar1 "CR30"
-#endif
-
-#if(ENABLED(HotendStock))
-#define VerChar2 "S"
-#elif(ENABLED(HotendE3D))
-#define VerChar2 "E"
-#elif ENABLED(HotendMosquito)
-#define VerChar2 "M"
-#endif
-
-#if(ENABLED(HotendAllMetal))
-#define VerChar3 "M"
-#else
-#define VerChar3 "S"
-#endif
-
-
-#if(ENABLED(BedAC))
-#define VerChar4 "A"
-#elif(ENABLED(BedDC))
-#define VerChar4 "D"
-#else
-#define VerChar4 "N"
-#endif
-
-#if(ENABLED(ABL_EZABL))
-#define VerChar5 "A"
-#elif(ENABLED(ABL_BLTOUCH))
-#define VerChar5 "B"
-#else
-#define VerChar5 "N"
-#endif
-
-#if(ENABLED(ABL_UBL))
-#define VerChar6 "U"
-#elif(ENABLED(ABL_BI))
-#define VerChar6 "B"
-#else
-#define VerChar6 "N"
-#endif
-
-#define DETAILED_BUILD_VERSION SHORT_BUILD_VERSION " TM3D " VerChar1 VerChar2 VerChar3 VerChar4 VerChar5 VerChar6
+//#define DETAILED_BUILD_VERSION SHORT_BUILD_VERSION
 
 /**
  * The STRING_DISTRIBUTION_DATE represents when the binary file was built,
  * here we define this default string as the date where the latest release
  * version was tagged.
  */
-#define STRING_DISTRIBUTION_DATE "2024-04-08"
+//#define STRING_DISTRIBUTION_DATE "2024-11-04"
+
+/**
+ * The protocol for communication to the host. Protocol indicates communication
+ * standards such as the use of ASCII, "echo:" and "error:" line prefixes, etc.
+ * (Other behaviors are given by the firmware version and capabilities report.)
+ */
+//#define PROTOCOL_VERSION "1.0"
 
 /**
  * Defines a generic printer name to be output to the LCD after booting Marlin.
  */
-#if(ENABLED(MachineMini))
-  #define CUSTOM_MACHINE_NAME "Mini SuPeR"
-#elif(ENABLED(MachineCR10Smart))
-  #define CUSTOM_MACHINE_NAME "TM3D CR10Smart"
-#elif(ENABLED(MachineCR10SmartPro))
-  #define CUSTOM_MACHINE_NAME "TM3D CR10SmartPro"
-#elif(ENABLED(MachineEnder2))
-  #define CUSTOM_MACHINE_NAME "TM3D Ender2"
-#elif(ENABLED(MachineEnder2Pro))
-  #define CUSTOM_MACHINE_NAME "TM3D Ender2 Pro"
-#elif(ENABLED(MachineEnder3))
-  #define CUSTOM_MACHINE_NAME "TM3D Ender3"
-#elif(ENABLED(MachineEnder3Max))
-  #define CUSTOM_MACHINE_NAME "TM3D E3Max"
-#elif(ENABLED(MachineEnder6))
-  #define CUSTOM_MACHINE_NAME "TM3D Ender6"
-#elif(ENABLED(MachineEnder7))
-  #define CUSTOM_MACHINE_NAME "TM3D Ender7"
-#elif(ENABLED(MachineEnder3V2))
-  #define CUSTOM_MACHINE_NAME "TM3D Ender3V2"
-#elif(ENABLED(MachineEnder3S1))
-  #define CUSTOM_MACHINE_NAME "TM3D Ender3S1"
-#elif(ENABLED(MachineEnder4))
-  #define CUSTOM_MACHINE_NAME "TM3D Ender4"
-#elif(ENABLED(MachineEnder5))
-  #define CUSTOM_MACHINE_NAME "TM3D Ender5"
-#elif(ENABLED(MachineEnder5Plus))
-  #define CUSTOM_MACHINE_NAME "TM3D E5 Plus"
-#elif(ENABLED(MachineCR20))
-  #define CUSTOM_MACHINE_NAME "SuPeR CR-20"
-#elif(ENABLED(MachineCR10Orig))
-  #define CUSTOM_MACHINE_NAME "SuPeR CR-10"
-#elif(ENABLED(MachineCRX))
-  #define CUSTOM_MACHINE_NAME "TM3D CR-X"
-#elif ENABLED(MachineCR10SProV2)
-  #define CUSTOM_MACHINE_NAME "TM3D 10SProV2"
-#elif(ENABLED(MachineCR10SPro))
-  #define CUSTOM_MACHINE_NAME "TM3D 10S Pro"
-#elif(ENABLED(MachineCR10Max))
-  #define CUSTOM_MACHINE_NAME "TM3D Max"
-#elif(ENABLED(MachineCR10SV3))
-  #define CUSTOM_MACHINE_NAME "TM3D CR10V3"
-#elif(ENABLED(MachineCR10SV2))
-  #define CUSTOM_MACHINE_NAME "TM3D CR10V2"
-#elif(ENABLED(MachineCR10Std))
-  #define CUSTOM_MACHINE_NAME "300 SuPeR"
-#elif(ENABLED(MachineS4))
-  #define CUSTOM_MACHINE_NAME "400 SuPeR"
-#elif(ENABLED(MachineS5))
-  #define CUSTOM_MACHINE_NAME "500 SuPeR"
-#elif ENABLED(MachineCR2020)
-  #define CUSTOM_MACHINE_NAME "TM3D 2020"
-#elif ENABLED(MachineSermoonD1)
-  #define CUSTOM_MACHINE_NAME "SermoonD1"
-#elif ENABLED(MachineCR5)
-  #define CUSTOM_MACHINE_NAME "CR5 Pro"
-#elif ENABLED(MachineCR6)
-  #define CUSTOM_MACHINE_NAME "CR6"
-#elif ENABLED(MachineCR6Max)
-  #define CUSTOM_MACHINE_NAME "CR6 Max"
-#elif ENABLED(MachineCR30)
-  #define CUSTOM_MACHINE_NAME "CR30 Printmill"
-#endif
+//#define MACHINE_NAME "3D Printer"
 
 /**
  * The SOURCE_CODE_URL is the location where users will find the Marlin Source
@@ -206,7 +61,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/CrealityDwin_2.0"
+//#define SOURCE_CODE_URL "github.com/MarlinFirmware/Marlin"
 
 /**
  * Default generic printer UUID.
@@ -217,12 +72,12 @@
  * 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 "marlinfw.org"
 
 /**
- * Set the vendor info the serial USB interface, if changable
- * Currently only supported by DUE platform
+ * Set the vendor info the serial USB interface, if changeable.
+ * Currently only supported by DUE platform.
  */
-//#define  USB_DEVICE_VENDOR_ID           0x0000
-//#define  USB_DEVICE_PRODUCT_ID          0x0000
-//#define  USB_DEVICE_MANUFACTURE_NAME    WEBSITE_URL
+//#define USB_DEVICE_VENDOR_ID           0x0000
+//#define USB_DEVICE_PRODUCT_ID          0x0000
+//#define USB_DEVICE_MANUFACTURE_NAME    WEBSITE_URL

Marlin/_Bootscreen.h

@@ -1,93 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * Custom Bitmap for splashscreen
- *
- * You may use one of the following tools to generate the C++ bitmap array from
- * a black and white image:
- *
- *  - http://www.marlinfw.org/tools/u8glib/converter.html
- *  - http://www.digole.com/tools/PicturetoC_Hex_converter.php
- */
-
-#define CUSTOM_BOOTSCREEN_TIMEOUT   2500
-#define CUSTOM_BOOTSCREEN_BMPWIDTH  128
-#define CUSTOM_BOOTSCREEN_INVERTED
-
-const unsigned char custom_start_bmp[] PROGMEM = {
-  B11111101,B01010101,B01010101,B01010101,B01010101,B01010101,B01011111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
-  B11111110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
-  B11111101,B00000000,B00000000,B00000111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
-  B11111110,B00000111,B11000000,B00000101,B01010101,B01010101,B01010101,B01010101,B01010101,B01011111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
-  B11111100,B00001010,B00100000,B00000110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
-  B11111110,B00010100,B00010000,B00000101,B00000000,B00000000,B00000111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
-  B11111100,B00101000,B00001000,B00000110,B00000111,B11000000,B00000101,B01010101,B01010101,B01010101,B01010101,B01010101,B01011111,B11111111,B11111111,B11111111,
-  B11111110,B01010100,B00000100,B00000100,B00001010,B00100000,B00000110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,B11111111,B11111111,B11111111,
-  B11111100,B01100000,B00000100,B00000110,B00010100,B00010000,B00000101,B00000000,B00000000,B00000111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
-  B11111110,B01010000,B00000100,B00000100,B00101000,B00001000,B00000110,B00000111,B11000000,B00000101,B01010101,B01010101,B01010101,B01010101,B01010101,B01011111,
-  B11111100,B01100000,B00000100,B00000110,B01010100,B00000100,B00000100,B00001010,B00100000,B00000110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,
-  B11111110,B01010100,B00000100,B00011100,B01100000,B00000100,B00000110,B00010100,B00010000,B00000101,B00000000,B00000000,B00000000,B00000000,B00000000,B00011111,
-  B11111100,B00101000,B00001000,B00101110,B01010000,B00000100,B00000100,B00101000,B00001000,B00000110,B00000111,B11000000,B00000000,B00000001,B11110000,B00111111,
-  B11111110,B00010100,B00010000,B01010100,B01100000,B00000100,B00000110,B01010100,B00000100,B00000100,B00001010,B00100000,B00000000,B00000010,B00001000,B00011111,
-  B11111100,B00001010,B00100000,B01100110,B01010100,B00000100,B00011100,B01100000,B00000100,B00000110,B00010100,B00010000,B00000000,B00000101,B00000100,B00111111,
-  B11111110,B00000111,B11000000,B01010100,B00101000,B00001000,B00101110,B01010000,B00000100,B00000100,B00101000,B00001000,B00000000,B00001010,B00000010,B00011111,
-  B11111100,B00000000,B00000000,B00101110,B00010100,B00010000,B01010100,B01100000,B00000100,B00000110,B01010100,B00000100,B00000000,B00010101,B00000001,B00111111,
-  B11111110,B00000000,B00000000,B00011100,B00001010,B00100000,B01100110,B01010100,B00000100,B00011100,B01100000,B00000100,B00000000,B00011000,B00000001,B00011111,
-  B11111100,B00000000,B00000000,B00000110,B00000111,B11000000,B01010100,B00101000,B00001000,B00101110,B01010000,B00000100,B00000000,B00010100,B00000001,B00111111,
-  B11111110,B00000000,B00000000,B00000100,B00000000,B00000000,B00101110,B00010100,B00010000,B01010100,B01100000,B00000100,B00000000,B00011000,B00000001,B00011111,
-  B11111100,B11111111,B11111111,B11111110,B00000000,B00000000,B00011100,B00001010,B00100000,B01100110,B01010100,B00000100,B00011100,B00010101,B00000001,B00111111,
-  B11111110,B11010101,B01010101,B01010100,B00000000,B00000000,B00000110,B00000111,B11000000,B01010100,B00101000,B00001000,B00101010,B00001010,B00000010,B00011111,
-  B11111100,B10000100,B00010000,B01000110,B00000000,B00000000,B00000100,B00000000,B00000000,B00101110,B00010100,B00010000,B01010001,B00000101,B00000100,B00111111,
-  B11111110,B11000100,B00010000,B01000100,B11111111,B11111111,B11111110,B00000000,B00000000,B00011100,B00001010,B00100000,B01100001,B00000010,B10001000,B00011111,
-  B11111100,B10000100,B00010000,B01000110,B11010101,B01010101,B01010100,B00000000,B00000000,B00000110,B00000111,B11000000,B01010001,B00000001,B11110000,B00111111,
-  B11111110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000110,B00000000,B00000000,B00000100,B00000000,B00000000,B00101010,B00000000,B00000000,B00011111,
-  B11111100,B11000100,B00010000,B01000110,B11000100,B00010000,B01000100,B11111111,B11111111,B11111110,B00000000,B00000000,B00011100,B00000000,B00000000,B00111111,
-  B11111110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000110,B11010101,B01010101,B01010100,B00000000,B00000000,B00000000,B00000000,B00000000,B00011111,
-  B11111100,B11010101,B01010101,B01010110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,
-  B11111100,B11111111,B11111111,B11111100,B11000100,B00010000,B01000110,B11000100,B00010000,B01000100,B11111111,B11111111,B11111111,B11111111,B11111111,B10011111,
-  B11111110,B00000000,B00000000,B00000110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000110,B11010101,B01010101,B01010101,B01010101,B01010101,B10111111,
-  B11111101,B01010101,B01010101,B01010100,B11010101,B01010101,B01010110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000001,B00000100,B00010000,B10011111,
-  B11111111,B11111111,B11111111,B11111100,B11111111,B11111111,B11111100,B11000100,B00010000,B01000110,B11000100,B00010000,B01000001,B00000100,B00010001,B10111111,
-  B11111111,B11111111,B11111111,B11111110,B00000000,B00000000,B00000110,B10000100,B00010000,B01000100,B10000100,B00010000,B01000001,B00000100,B00010000,B10011111,
-  B11111111,B11111111,B11111111,B11111101,B01010101,B01010101,B01010100,B11010101,B01010101,B01010110,B10000100,B00010000,B01000001,B00000100,B00010000,B10011111,
-  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111100,B11111111,B11111111,B11111100,B11000100,B00010000,B01000001,B00000100,B00010001,B10111111,
-  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111110,B00000000,B00000000,B00000110,B10000100,B00010000,B01000001,B00000100,B00010000,B10011111,
-  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111101,B01010101,B01010101,B01010100,B11010101,B01010101,B01010101,B01010101,B01010101,B10111111,
-  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111100,B11111111,B11111111,B11111111,B11111111,B11111111,B10011111,
-  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111110,B00000000,B00000000,B00000000,B00000000,B00000000,B00111111,
-  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111101,B01010101,B01010101,B01010101,B01010101,B01010101,B01011111,
-  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
-  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
-  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
-  B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,B11111111,
-  B11100000,B00101110,B11111011,B01111101,B11111011,B11111011,B11001111,B11000001,B11011111,B10111011,B00111110,B11000000,B11100001,B11111110,B00111100,B00011111,
-  B11111101,B11101110,B01111011,B00111001,B11111001,B11110011,B11001111,B10011110,B11011111,B10111011,B00111110,B11011111,B11011110,B11111100,B11011101,B11100111,
-  B11111101,B11101110,B00111011,B10111011,B11111001,B11101011,B11010111,B10111111,B01011111,B10111011,B01011110,B11011111,B11011110,B11111101,B11101101,B11110111,
-  B11111101,B11101110,B10111011,B11010011,B11111010,B11101011,B10110111,B00111111,B11011111,B10111011,B01001110,B11011111,B11011111,B11111111,B11001101,B11110011,
-  B11111101,B11101110,B11011011,B11000111,B11111010,B11101011,B10111011,B01111111,B11000000,B00111011,B01101110,B11000000,B11100011,B11111111,B00011101,B11110011,
-  B11111101,B11101110,B11001011,B11101111,B11111010,B11011011,B10111011,B01111111,B11011111,B10111011,B01100110,B11011111,B11111000,B11111111,B11001101,B11110011,
-  B11111101,B11101110,B11101011,B11101111,B11111011,B01011011,B00000011,B00111111,B01011111,B10111011,B01110110,B11011111,B11111110,B01111111,B11101101,B11110011,
-  B11111101,B11101110,B11110011,B11101111,B11111011,B01011011,B01111001,B10111110,B11011111,B10111011,B01111010,B11011111,B11011110,B01111101,B11101101,B11110111,
-  B11111101,B11101110,B11110011,B11101111,B11111011,B10111010,B11111101,B10011110,B11011111,B10111011,B01111100,B11011111,B11011110,B11111101,B11001101,B11100111,
-  B11111101,B11101110,B11111011,B11101111,B11111011,B10111010,B11111101,B11000001,B11011111,B10111011,B01111110,B11000000,B11100000,B11111110,B00011100,B00011111
-};

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

@@ -129,11 +129,11 @@ typedef Servo hal_servo_t;
   #endif
 #endif
 
-#ifdef MMU2_SERIAL_PORT
-  #if !WITHIN(MMU2_SERIAL_PORT, 0, 3)
-    #error "MMU2_SERIAL_PORT must be from 0 to 3"
+#ifdef MMU_SERIAL_PORT
+  #if !WITHIN(MMU_SERIAL_PORT, 0, 3)
+    #error "MMU_SERIAL_PORT must be from 0 to 3"
   #endif
-  #define MMU2_SERIAL mmuSerial
+  #define MMU_SERIAL mmuSerial
 #endif
 
 #ifdef LCD_SERIAL_PORT
@@ -141,8 +141,8 @@ typedef Servo hal_servo_t;
     #error "LCD_SERIAL_PORT must be from 0 to 3."
   #endif
   #define LCD_SERIAL lcdSerial
-  #if HAS_DGUS_LCD || ENABLED(DGUS_LCD_UI_CREALITY_TOUCH) || ENABLED(EXTENSIBLE_UI)
-    #define SERIAL_GET_TX_BUFFER_FREE() LCD_SERIAL.get_tx_buffer_free()
+  #if ANY(HAS_DGUS_LCD, EXTENSIBLE_UI)
+    #define LCD_SERIAL_TX_BUFFER_FREE() LCD_SERIAL.get_tx_buffer_free()
   #endif
 #endif
 
@@ -159,7 +159,7 @@ typedef Servo hal_servo_t;
 #define GET_PIN_MAP_INDEX(pin) pin
 #define PARSED_PIN_INDEX(code, dval) parser.intval(code, dval)
 
-#define HAL_SENSITIVE_PINS 0, 1,
+#define HAL_SENSITIVE_PINS 0, 1
 
 #ifdef __AVR_AT90USB1286__
   #define JTAG_DISABLE() do{ MCUCR = 0x80; MCUCR = 0x80; }while(0)

Marlin/src/HAL/AVR/MarlinSerial.cpp

@@ -601,20 +601,20 @@ MSerialT1 customizedSerial1(MSerialT1::HasEmergencyParser);
 
 #endif // SERIAL_PORT_3
 
-#ifdef MMU2_SERIAL_PORT
+#ifdef MMU_SERIAL_PORT
 
-  ISR(SERIAL_REGNAME(USART, MMU2_SERIAL_PORT, _RX_vect)) {
-    MarlinSerial<MMU2SerialCfg<MMU2_SERIAL_PORT>>::store_rxd_char();
+  ISR(SERIAL_REGNAME(USART, MMU_SERIAL_PORT, _RX_vect)) {
+    MarlinSerial<MMU2SerialCfg<MMU_SERIAL_PORT>>::store_rxd_char();
   }
 
-  ISR(SERIAL_REGNAME(USART, MMU2_SERIAL_PORT, _UDRE_vect)) {
-    MarlinSerial<MMU2SerialCfg<MMU2_SERIAL_PORT>>::_tx_udr_empty_irq();
+  ISR(SERIAL_REGNAME(USART, MMU_SERIAL_PORT, _UDRE_vect)) {
+    MarlinSerial<MMU2SerialCfg<MMU_SERIAL_PORT>>::_tx_udr_empty_irq();
   }
 
-  template class MarlinSerial< MMU2SerialCfg<MMU2_SERIAL_PORT> >;
+  template class MarlinSerial< MMU2SerialCfg<MMU_SERIAL_PORT> >;
   MSerialMMU2 mmuSerial(MSerialMMU2::HasEmergencyParser);
 
-#endif // MMU2_SERIAL_PORT
+#endif // MMU_SERIAL_PORT
 
 #ifdef LCD_SERIAL_PORT
 
@@ -629,7 +629,7 @@ MSerialT1 customizedSerial1(MSerialT1::HasEmergencyParser);
   template class MarlinSerial< LCDSerialCfg<LCD_SERIAL_PORT> >;
   MSerialLCD lcdSerial(MSerialLCD::HasEmergencyParser);
 
-  #if HAS_DGUS_LCD || ENABLED(DGUS_LCD_UI_CREALITY_TOUCH) || ENABLED(EXTENSIBLE_UI)
+  #if ANY(HAS_DGUS_LCD, EXTENSIBLE_UI)
     template<typename Cfg>
     typename MarlinSerial<Cfg>::ring_buffer_pos_t MarlinSerial<Cfg>::get_tx_buffer_free() {
       const ring_buffer_pos_t t = tx_buffer.tail,  // next byte to send.

Marlin/src/HAL/AVR/MarlinSerial.h

@@ -205,7 +205,7 @@
     static ring_buffer_pos_t available();
     static void write(const uint8_t c);
     static void flushTX();
-    #if HAS_DGUS_LCD || ENABLED(DGUS_LCD_UI_CREALITY_TOUCH) || ENABLED(EXTENSIBLE_UI)
+    #if ANY(HAS_DGUS_LCD, EXTENSIBLE_UI)
       static ring_buffer_pos_t get_tx_buffer_free();
     #endif
 
@@ -246,7 +246,7 @@
 
 #endif // !USBCON
 
-#ifdef MMU2_SERIAL_PORT
+#ifdef MMU_SERIAL_PORT
   template <uint8_t serial>
   struct MMU2SerialCfg {
     static constexpr int PORT               = serial;
@@ -260,7 +260,7 @@
     static constexpr bool RX_OVERRUNS       = false;
   };
 
-  typedef Serial1Class< MarlinSerial< MMU2SerialCfg<MMU2_SERIAL_PORT> > > MSerialMMU2;
+  typedef Serial1Class< MarlinSerial< MMU2SerialCfg<MMU_SERIAL_PORT> > > MSerialMMU2;
   extern MSerialMMU2 mmuSerial;
 #endif
 
@@ -276,7 +276,7 @@
     static constexpr bool DROPPED_RX        = false;
     static constexpr bool RX_FRAMING_ERRORS = false;
     static constexpr bool MAX_RX_QUEUED     = false;
-    static constexpr bool RX_OVERRUNS       = (ANY(HAS_DGUS_LCD, SERIAL_STATS_RX_BUFFER_OVERRUNS) || ENABLED(DWINOS_4));
+    static constexpr bool RX_OVERRUNS       = ALL(HAS_DGUS_LCD, SERIAL_STATS_RX_BUFFER_OVERRUNS);
   };
 
   typedef Serial1Class< MarlinSerial< LCDSerialCfg<LCD_SERIAL_PORT> > > MSerialLCD;

Marlin/src/HAL/AVR/endstop_interrupts.h

@@ -345,6 +345,14 @@ void setup_endstop_interrupts() {
       pciSetup(Z_MIN_PROBE_PIN);
     #endif
   #endif
+  #if USE_CALIBRATION
+    #if (digitalPinToInterrupt(CALIBRATION_PIN) != NOT_AN_INTERRUPT)
+      _ATTACH(CALIBRATION_PIN);
+    #else
+      static_assert(digitalPinHasPCICR(CALIBRATION_PIN), "CALIBRATION_PIN is not interrupt-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue.");
+      pciSetup(CALIBRATION_PIN);
+    #endif
+  #endif
 
   // If we arrive here without raising an assertion, each pin has either an EXT-interrupt or a PCI.
 }

Marlin/src/HAL/AVR/fast_pwm.cpp

@@ -150,7 +150,7 @@ void MarlinHAL::set_pwm_frequency(const pin_t pin, const uint16_t f_desired) {
       else {
         if (p == 32 || p == 128) continue;                    // Skip TIMER2 specific prescalers when not TIMER2
         const uint16_t rft = (F_CPU) / (p * f_desired);
-        DEBUG_ECHOLNPGM("(Not Timer 2) F_CPU=" STRINGIFY(F_CPU), " prescaler=", p, " f_desired=", f_desired);
+        DEBUG_ECHOLNPGM("(Not Timer 2) F_CPU=", STRINGIFY(F_CPU), " prescaler=", p, " f_desired=", f_desired);
         res_fast_temp = rft - 1;
         res_pc_temp = rft / 2;
       }

Marlin/src/HAL/AVR/fastio/fastio_1280.h

@@ -28,9 +28,6 @@
  *   Port          : E0 E1 E4 E5 G5 E3 H3 H4 H5 H6 B4 B5 B6 B7 J1 J0 H1 H0 D3 D2 D1 D0 A0 A1 A2 A3 A4 A5 A6 A7 C7 C6 C5 C4 C3 C2 C1 C0 D7 G2 G1 G0 L7 L6 L5 L4 L3 L2 L1 L0 B3 B2 B1 B0 F0 F1 F2 F3 F4 F5 F6 F7 K0 K1 K2 K3 K4 K5 K6 K7 | E2 E6 E7 xx xx H2 H7 G3 G4 xx xx xx xx xx D4 D5 D6 xx xx J2 J3 J4 J5 J6 J7 xx xx xx xx xx
  *   Logical Pin   : 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 | 78 79 80 xx xx 84 85 71 70 xx xx xx xx xx 81 82 83 xx xx 72 73 75 76 77 74 xx xx xx xx xx
  *   Analog Input  :                                                                                                                                                                    0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
- *
- * Arduino Pin Layout video: https://youtu.be/rIqeVCX09FA
- * AVR alternate pin function overview video: https://youtu.be/1yd8wuI5Plg
  */
 
 #include "../fastio.h"

Marlin/src/HAL/AVR/fastio/fastio_1281.h

@@ -26,9 +26,6 @@
  *
  *   Logical Pin: 38 39 40 41 42 43 44 45 16 10 11 12 06 07 08 09 30 31 32 33 34 35 36 37 17 18 19 20 21 22 23 24 00 01 13 05 02 03 14 15 46 47 48 49 50 51 52 53 25 26 27 28 29 04
  *   Port:        A0 A1 A2 A3 A4 A5 A6 A7 B0 B1 B2 B3 B4 B5 B6 B7 C0 C1 C2 C3 C4 C5 C6 C7 D0 D1 D2 D3 D4 D5 D6 D7 E0 E1 E2 E3 E4 E5 E6 E7 F0 F1 F2 F3 F4 F5 F6 F7 G0 G1 G2 G3 G4 G5
- *
- * Arduino Pin Layout video: https://youtu.be/rIqeVCX09FA
- * AVR alternate pin function overview video: https://youtu.be/1yd8wuI5Plg
  */
 
 #include "../fastio.h"

Marlin/src/HAL/AVR/fastio/fastio_168.h

@@ -26,9 +26,6 @@
  *
  *   Logical Pin: 08 09 10 11 12 13 14 15 16 17 18 19 20 21 00 01 02 03 04 05 06 07
  *   Port:        B0 B1 B2 B3 B4 B5 C0 C1 C2 C3 C4 C5 C6 C7 D0 D1 D2 D3 D4 D5 D6 D7
- *
- * Arduino Pin Layout video: https://youtu.be/rIqeVCX09FA
- * AVR alternate pin function overview video: https://youtu.be/1yd8wuI5Plg
  */
 
 #include "../fastio.h"

Marlin/src/HAL/AVR/fastio/fastio_644.h

@@ -26,9 +26,6 @@
  *
  *   Logical Pin: 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
  *   Port:        B0 B1 B2 B3 B4 B5 B6 B7 D0 D1 D2 D3 D4 D5 D6 D7 C0 C1 C2 C3 C4 C5 C6 C7 A7 A6 A5 A4 A3 A2 A1 A0
- *
- * Arduino Pin Layout video: https://youtu.be/rIqeVCX09FA
- * AVR alternate pin function overview video: https://youtu.be/1yd8wuI5Plg
  */
 
 /**                        ATMega644

Marlin/src/HAL/AVR/fastio/fastio_AT90USB.h

@@ -26,10 +26,7 @@
  *
  *   Logical Pin: 28 29 30 31 32 33 34 35 20 21 22 23 24 25 26 27 10 11 12 13 14 15 16 17 00 01 02 03 04 05 06 07 08 09(46*47)36 37 18 19 38 39 40 41 42 43 44 45
  *   Port:        A0 A1 A2 A3 A4 A5 A6 A7 B0 B1 B2 B3 B4 B5 B6 B7 C0 C1 C2 C3 C4 C5 C6 C7 D0 D1 D2 D3 D4 D5 D6 D7 E0 E1 E2 E3 E4 E5 E6 E7 F0 F1 F2 F3 F4 F5 F6 F7
- *            The logical pins 46 and 47 are not supported by Teensyduino, but are supported below as E2 and E3
- *
- * Arduino Pin Layout video: https://youtu.be/rIqeVCX09FA
- * AVR alternate pin function overview video: https://youtu.be/1yd8wuI5Plg
+ *            Logical pins 46-47 aren't supported by Teensyduino, but are supported below as E2 and E3
  */
 
 #include "../fastio.h"

Marlin/src/HAL/AVR/pinsDebug.h

@@ -22,7 +22,23 @@
 #pragma once
 
 /**
- * PWM print routines for Atmel 8 bit AVR CPUs
+ * Pins Debugging for Atmel 8 bit AVR CPUs
+ *
+ *   - NUMBER_PINS_TOTAL
+ *   - MULTI_NAME_PAD
+ *   - getPinByIndex(index)
+ *   - printPinNameByIndex(index)
+ *   - getPinIsDigitalByIndex(index)
+ *   - digitalPinToAnalogIndex(pin)
+ *   - getValidPinMode(pin)
+ *   - isValidPin(pin)
+ *   - isAnalogPin(pin)
+ *   - digitalRead_mod(pin)
+ *   - pwm_status(pin)
+ *   - printPinPWM(pin)
+ *   - printPinPort(pin)
+ *   - printPinNumber(pin)
+ *   - printPinAnalog(pin)
  */
 
 #include "../../inc/MarlinConfig.h"
@@ -39,44 +55,44 @@
   #include "pinsDebug_Teensyduino.h"
   // Can't use the "digitalPinToPort" function from the Teensyduino type IDEs
   // portModeRegister takes a different argument
-  #define digitalPinToTimer_DEBUG(p) digitalPinToTimer(p)
-  #define digitalPinToBitMask_DEBUG(p) digitalPinToBitMask(p)
-  #define digitalPinToPort_DEBUG(p) digitalPinToPort(p)
-  #define GET_PINMODE(pin) (*portModeRegister(pin) & digitalPinToBitMask_DEBUG(pin))
+  #define digitalPinToTimer_DEBUG(P) digitalPinToTimer(P)
+  #define digitalPinToBitMask_DEBUG(P) digitalPinToBitMask(P)
+  #define digitalPinToPort_DEBUG(P) digitalPinToPort(P)
+  #define getValidPinMode(P) (*portModeRegister(P) & digitalPinToBitMask_DEBUG(P))
 
 #elif AVR_ATmega2560_FAMILY_PLUS_70   // So we can access/display all the pins on boards using more than 70
 
   #include "pinsDebug_plus_70.h"
-  #define digitalPinToTimer_DEBUG(p) digitalPinToTimer_plus_70(p)
-  #define digitalPinToBitMask_DEBUG(p) digitalPinToBitMask_plus_70(p)
-  #define digitalPinToPort_DEBUG(p) digitalPinToPort_plus_70(p)
-  bool GET_PINMODE(int8_t pin) {return *portModeRegister(digitalPinToPort_DEBUG(pin)) & digitalPinToBitMask_DEBUG(pin); }
+  #define digitalPinToTimer_DEBUG(P) digitalPinToTimer_plus_70(P)
+  #define digitalPinToBitMask_DEBUG(P) digitalPinToBitMask_plus_70(P)
+  #define digitalPinToPort_DEBUG(P) digitalPinToPort_plus_70(P)
+  bool getValidPinMode(pin_t pin) {return *portModeRegister(digitalPinToPort_DEBUG(pin)) & digitalPinToBitMask_DEBUG(pin); }
 
 #else
 
-  #define digitalPinToTimer_DEBUG(p) digitalPinToTimer(p)
-  #define digitalPinToBitMask_DEBUG(p) digitalPinToBitMask(p)
-  #define digitalPinToPort_DEBUG(p) digitalPinToPort(p)
-  bool GET_PINMODE(int8_t pin) {return *portModeRegister(digitalPinToPort_DEBUG(pin)) & digitalPinToBitMask_DEBUG(pin); }
-  #define GET_ARRAY_PIN(p) pgm_read_byte(&pin_array[p].pin)
+  #define digitalPinToTimer_DEBUG(P) digitalPinToTimer(P)
+  #define digitalPinToBitMask_DEBUG(P) digitalPinToBitMask(P)
+  #define digitalPinToPort_DEBUG(P) digitalPinToPort(P)
+  bool getValidPinMode(pin_t pin) {return *portModeRegister(digitalPinToPort_DEBUG(pin)) & digitalPinToBitMask_DEBUG(pin); }
+  #define getPinByIndex(x) pgm_read_byte(&pin_array[x].pin)
 
 #endif
 
-#define VALID_PIN(pin) (pin >= 0 && pin < NUM_DIGITAL_PINS ? 1 : 0)
+#define isValidPin(P) (P >= 0 && P < NUMBER_PINS_TOTAL)
 #if AVR_ATmega1284_FAMILY
-  #define IS_ANALOG(P) WITHIN(P, analogInputToDigitalPin(7), analogInputToDigitalPin(0))
-  #define DIGITAL_PIN_TO_ANALOG_PIN(P) int(IS_ANALOG(P) ? (P) - analogInputToDigitalPin(7) : -1)
+  #define isAnalogPin(P) WITHIN(P, analogInputToDigitalPin(7), analogInputToDigitalPin(0))
+  #define digitalPinToAnalogIndex(P) int(isAnalogPin(P) ? (P) - analogInputToDigitalPin(7) : -1)
 #else
   #define _ANALOG1(P) WITHIN(P, analogInputToDigitalPin(0), analogInputToDigitalPin(7))
   #define _ANALOG2(P) WITHIN(P, analogInputToDigitalPin(8), analogInputToDigitalPin(15))
-  #define IS_ANALOG(P) (_ANALOG1(P) || _ANALOG2(P))
-  #define DIGITAL_PIN_TO_ANALOG_PIN(P) int(_ANALOG1(P) ? (P) - analogInputToDigitalPin(0) : _ANALOG2(P) ? (P) - analogInputToDigitalPin(8) + 8 : -1)
+  #define isAnalogPin(P) (_ANALOG1(P) || _ANALOG2(P))
+  #define digitalPinToAnalogIndex(P) int(_ANALOG1(P) ? (P) - analogInputToDigitalPin(0) : _ANALOG2(P) ? (P) - analogInputToDigitalPin(8) + 8 : -1)
 #endif
-#define GET_ARRAY_PIN(p) pgm_read_byte(&pin_array[p].pin)
+#define getPinByIndex(x) pgm_read_byte(&pin_array[x].pin)
 #define MULTI_NAME_PAD 26 // space needed to be pretty if not first name assigned to a pin
 
-void PRINT_ARRAY_NAME(uint8_t x) {
-  PGM_P const name_mem_pointer = (PGM_P)pgm_read_ptr(&pin_array[x].name);
+void printPinNameByIndex(const uint8_t index) {
+  PGM_P const name_mem_pointer = (PGM_P)pgm_read_ptr(&pin_array[index].name);
   for (uint8_t y = 0; y < MAX_NAME_LENGTH; ++y) {
     char temp_char = pgm_read_byte(name_mem_pointer + y);
     if (temp_char != 0)
@@ -88,7 +104,7 @@ void PRINT_ARRAY_NAME(uint8_t x) {
   }
 }
 
-#define GET_ARRAY_IS_DIGITAL(x)   pgm_read_byte(&pin_array[x].is_digital)
+#define getPinIsDigitalByIndex(x)   pgm_read_byte(&pin_array[x].is_digital)
 
 #if defined(__AVR_ATmega1284P__)  // 1284 IDE extensions set this to the number of
   #undef NUM_DIGITAL_PINS         // digital only pins while all other CPUs have it
@@ -109,7 +125,7 @@ void PRINT_ARRAY_NAME(uint8_t x) {
  * Print a pin's PWM status.
  * Return true if it's currently a PWM pin.
  */
-bool pwm_status(uint8_t pin) {
+bool pwm_status(const uint8_t pin) {
   char buffer[20];   // for the sprintf statements
 
   switch (digitalPinToTimer_DEBUG(pin)) {
@@ -276,7 +292,7 @@ void timer_prefix(uint8_t T, char L, uint8_t N) {  // T - timer    L - pwm  N -
   if (TEST(*TMSK, TOIE)) err_prob_interrupt();
 }
 
-void pwm_details(uint8_t pin) {
+void printPinPWM(const uint8_t pin) {
   switch (digitalPinToTimer_DEBUG(pin)) {
 
     #if ABTEST(0)
@@ -347,7 +363,7 @@ void pwm_details(uint8_t pin) {
   #else
     UNUSED(print_is_also_tied);
   #endif
-} // pwm_details
+} // printPinPWM
 
 #ifndef digitalRead_mod                   // Use Teensyduino's version of digitalRead - it doesn't disable the PWMs
   int digitalRead_mod(const pin_t pin) {  // same as digitalRead except the PWM stop section has been removed
@@ -356,7 +372,7 @@ void pwm_details(uint8_t pin) {
   }
 #endif
 
-void print_port(const pin_t pin) {   // print port number
+void printPinPort(const pin_t pin) {   // print port number
   #ifdef digitalPinToPort_DEBUG
     uint8_t x;
     SERIAL_ECHOPGM("  Port: ");
@@ -386,7 +402,7 @@ void print_port(const pin_t pin) {   // print port number
   #endif
 }
 
-#define PRINT_PIN(p) do{ sprintf_P(buffer, PSTR("%3d "), p); SERIAL_ECHO(buffer); }while(0)
-#define PRINT_PIN_ANALOG(p) do{ sprintf_P(buffer, PSTR(" (A%2d)  "), DIGITAL_PIN_TO_ANALOG_PIN(pin)); SERIAL_ECHO(buffer); }while(0)
+#define printPinNumber(P) do{ sprintf_P(buffer, PSTR("%3d "), P); SERIAL_ECHO(buffer); }while(0)
+#define printPinAnalog(P) do{ sprintf_P(buffer, PSTR(" (A%2d)  "), digitalPinToAnalogIndex(P)); SERIAL_ECHO(buffer); }while(0)
 
 #undef ABTEST

Marlin/src/HAL/AVR/pinsDebug_Teensyduino.h

@@ -102,7 +102,7 @@ const uint8_t PROGMEM digital_pin_to_port_PGM[] = {
 
 // digitalPinToBitMask(pin) is OK
 
-#define digitalRead_mod(p)  extDigitalRead(p)   // Teensyduino's version of digitalRead doesn't
+#define digitalRead_mod(P)  extDigitalRead(P)   // Teensyduino's version of digitalRead doesn't
                                                 // disable the PWMs so we can use it as is
 
 // portModeRegister(pin) is OK

Marlin/src/HAL/AVR/u8g_com_HAL_AVR_sw_spi.cpp

@@ -120,7 +120,7 @@ void u8g_spiSend_sw_AVR_mode_3(uint8_t val) {
   U8G_ATOMIC_END();
 }
 
-#if ENABLED(FYSETC_MINI_12864)
+#if U8G_SPI_USE_MODE_3
   #define SPISEND_SW_AVR u8g_spiSend_sw_AVR_mode_3
 #else
   #define SPISEND_SW_AVR u8g_spiSend_sw_AVR_mode_0
@@ -143,9 +143,9 @@ uint8_t u8g_com_HAL_AVR_sw_sp_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void
       break;
 
     case U8G_COM_MSG_CHIP_SELECT:
-      #if ENABLED(FYSETC_MINI_12864)           // LCD SPI is running mode 3 while SD card is running mode 0
-        if (arg_val) {                         //   SCK idle state needs to be set to the proper idle state before
-                                               //   the next chip select goes active
+      #if U8G_SPI_USE_MODE_3                                  // LCD SPI is running mode 3 while SD card is running mode 0
+        if (arg_val) {                                        // SCK idle state needs to be set to the proper idle state before
+                                                              //  the next chip select goes active
           u8g_com_arduino_digital_write(u8g, U8G_PI_SCK, 1);  // Set SCK to mode 3 idle state before CS goes active
           u8g_com_arduino_digital_write(u8g, U8G_PI_CS, LOW);
         }

Marlin/src/HAL/DUE/HAL.h

@@ -81,11 +81,11 @@ extern DefaultSerial4 MSerial3;
   #endif
 #endif
 
-#ifdef MMU2_SERIAL_PORT
-  #if WITHIN(MMU2_SERIAL_PORT, 0, 3)
-    #define MMU2_SERIAL MSERIAL(MMU2_SERIAL_PORT)
+#ifdef MMU_SERIAL_PORT
+  #if WITHIN(MMU_SERIAL_PORT, 0, 3)
+    #define MMU_SERIAL MSERIAL(MMU_SERIAL_PORT)
   #else
-    #error "MMU2_SERIAL_PORT must be from 0 to 3."
+    #error "MMU_SERIAL_PORT must be from 0 to 3."
   #endif
 #endif
 
@@ -127,7 +127,7 @@ typedef Servo hal_servo_t;
 #define HAL_ADC_RESOLUTION  10
 
 #ifndef analogInputToDigitalPin
-  #define analogInputToDigitalPin(p) ((p < 12U) ? (p) + 54U : -1)
+  #define analogInputToDigitalPin(p) pin_t((p < 12U) ? (p) + 54U : -1)
 #endif
 
 //

Marlin/src/HAL/DUE/Servo.cpp

@@ -50,7 +50,7 @@
 static Flags<_Nbr_16timers> DisablePending; // ISR should disable the timer at the next timer reset
 
 // ------------------------
-/// Interrupt handler for the TC0 channel 1.
+// Interrupt handler for the TC0 channel 1.
 // ------------------------
 void Servo_Handler(const timer16_Sequence_t, Tc*, const uint8_t);
 

Marlin/src/HAL/DUE/endstop_interrupts.h

@@ -64,6 +64,7 @@ void setup_endstop_interrupts() {
   TERN_(USE_Z4_MAX,      _ATTACH(Z4_MAX_PIN));
   TERN_(USE_Z4_MIN,      _ATTACH(Z4_MIN_PIN));
   TERN_(USE_Z_MIN_PROBE, _ATTACH(Z_MIN_PROBE_PIN));
+  TERN_(USE_CALIBRATION, _ATTACH(CALIBRATION_PIN));
   TERN_(USE_I_MAX,       _ATTACH(I_MAX_PIN));
   TERN_(USE_I_MIN,       _ATTACH(I_MIN_PIN));
   TERN_(USE_J_MAX,       _ATTACH(J_MAX_PIN));

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

@@ -61,7 +61,7 @@
 #else
   #define G2_PWM_Z 0
 #endif
-#if PIN_EXISTS(MOTOR_CURRENT_PWM_E)
+#if HAS_MOTOR_CURRENT_PWM_E
   #define G2_PWM_E 1
 #else
   #define G2_PWM_E 0

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

@@ -68,16 +68,15 @@
  * 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_SPI_##P) && (TMC_SPI_##P == SD_MOSI_PIN || TMC_SPI_##P == SD_MISO_PIN || TMC_SPI_##P == SD_SCK_PIN))
-
 #if HAS_MEDIA && HAS_DRIVER(TMC2130)
-  #if ENABLED(TMC_USE_SW_SPI)
-    #if DISABLED(SOFTWARE_SPI) && (_IS_HW_SPI(MOSI) || _IS_HW_SPI(MISO) || _IS_HW_SPI(SCK))
-      #error "DUE hardware SPI is required but is incompatible with TMC2130 software SPI. Either disable TMC_USE_SW_SPI or use separate pins for the two SPIs."
-    #endif
-  #elif ENABLED(SOFTWARE_SPI)
+  #define _IS_HW_SPI(P) (defined(TMC_SPI_##P) && (TMC_SPI_##P == SD_MOSI_PIN || TMC_SPI_##P == SD_MISO_PIN || TMC_SPI_##P == SD_SCK_PIN))
+  #if DISABLED(SOFTWARE_SPI) && ENABLED(TMC_USE_SW_SPI) && (_IS_HW_SPI(MOSI) || _IS_HW_SPI(MISO) || _IS_HW_SPI(SCK))
+    #error "DUE hardware SPI is required but is incompatible with TMC2130 software SPI. Either disable TMC_USE_SW_SPI or use separate pins for the two SPIs."
+  #endif
+  #if ENABLED(SOFTWARE_SPI) && DISABLED(TMC_USE_SW_SPI)
     #error "DUE software SPI is required but is incompatible with TMC2130 hardware SPI. Enable TMC_USE_SW_SPI to fix."
   #endif
+  #undef _IS_HW_SPI
 #endif
 
 #if ENABLED(FAST_PWM_FAN) || SPINDLE_LASER_FREQUENCY

Marlin/src/HAL/DUE/pinsDebug.h

@@ -19,13 +19,26 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
+#pragma once
 
 /**
- * Support routines for Due
- */
-
-/**
- * Translation of routines & variables used by pinsDebug.h
+ * Pins Debugging for DUE
+ *
+ *   - NUMBER_PINS_TOTAL
+ *   - MULTI_NAME_PAD
+ *   - getPinByIndex(index)
+ *   - printPinNameByIndex(index)
+ *   - getPinIsDigitalByIndex(index)
+ *   - digitalPinToAnalogIndex(pin)
+ *   - getValidPinMode(pin)
+ *   - isValidPin(pin)
+ *   - isAnalogPin(pin)
+ *   - digitalRead_mod(pin)
+ *   - pwm_status(pin)
+ *   - printPinPWM(pin)
+ *   - printPinPort(pin)
+ *   - printPinNumber(pin)
+ *   - printPinAnalog(pin)
  */
 
 #include "../shared/Marduino.h"
@@ -63,20 +76,20 @@
 
 #define NUMBER_PINS_TOTAL PINS_COUNT
 
-#define digitalRead_mod(p) extDigitalRead(p)  // AVR digitalRead disabled PWM before it read the 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("%02d"), p); SERIAL_ECHO(buffer); }while(0)
-#define PRINT_PIN_ANALOG(p) do{ sprintf_P(buffer, PSTR(" (A%2d)  "), DIGITAL_PIN_TO_ANALOG_PIN(pin)); SERIAL_ECHO(buffer); }while(0)
-#define GET_ARRAY_PIN(p) pin_array[p].pin
-#define GET_ARRAY_IS_DIGITAL(p) pin_array[p].is_digital
-#define VALID_PIN(pin) (pin >= 0 && pin < int8_t(NUMBER_PINS_TOTAL))
-#define DIGITAL_PIN_TO_ANALOG_PIN(p) int(p - analogInputToDigitalPin(0))
-#define IS_ANALOG(P) WITHIN(P, char(analogInputToDigitalPin(0)), char(analogInputToDigitalPin(NUM_ANALOG_INPUTS - 1)))
-#define pwm_status(pin) (((g_pinStatus[pin] & 0xF) == PIN_STATUS_PWM) && \
-                        ((g_APinDescription[pin].ulPinAttribute & PIN_ATTR_PWM) == PIN_ATTR_PWM))
+#define digitalRead_mod(P) extDigitalRead(P)  // AVR digitalRead disabled PWM before it read the pin
+#define printPinNameByIndex(x) do{ sprintf_P(buffer, PSTR("%-" STRINGIFY(MAX_NAME_LENGTH) "s"), pin_array[x].name); SERIAL_ECHO(buffer); }while(0)
+#define printPinNumber(P) do{ sprintf_P(buffer, PSTR("%02d"), P); SERIAL_ECHO(buffer); }while(0)
+#define printPinAnalog(P) do{ sprintf_P(buffer, PSTR(" (A%2d)  "), digitalPinToAnalogIndex(P)); SERIAL_ECHO(buffer); }while(0)
+#define getPinByIndex(x) pin_array[x].pin
+#define getPinIsDigitalByIndex(x) pin_array[x].is_digital
+#define isValidPin(P) (P >= 0 && P < pin_t(NUMBER_PINS_TOTAL))
+#define digitalPinToAnalogIndex(P) int(P - analogInputToDigitalPin(0))
+#define isAnalogPin(P) WITHIN(P, pin_t(analogInputToDigitalPin(0)), pin_t(analogInputToDigitalPin(NUM_ANALOG_INPUTS - 1)))
+#define pwm_status(P) (((g_pinStatus[P] & 0xF) == PIN_STATUS_PWM) && \
+                        ((g_APinDescription[P].ulPinAttribute & PIN_ATTR_PWM) == PIN_ATTR_PWM))
 #define MULTI_NAME_PAD 14 // space needed to be pretty if not first name assigned to a pin
 
-bool GET_PINMODE(int8_t pin) {  // 1: output, 0: input
+bool getValidPinMode(const pin_t pin) {  // 1: output, 0: input
   volatile Pio* port = g_APinDescription[pin].pPort;
   uint32_t mask = g_APinDescription[pin].ulPin;
   uint8_t pin_status = g_pinStatus[pin] & 0xF;
@@ -85,14 +98,14 @@ bool GET_PINMODE(int8_t pin) {  // 1: output, 0: input
           || pwm_status(pin));
 }
 
-void pwm_details(int32_t pin) {
+void printPinPWM(const int32_t pin) {
   if (pwm_status(pin)) {
     uint32_t chan = g_APinDescription[pin].ulPWMChannel;
     SERIAL_ECHOPGM("PWM = ", PWM_INTERFACE->PWM_CH_NUM[chan].PWM_CDTY);
   }
 }
 
-void print_port(const pin_t) {}
+void printPinPort(const pin_t) {}
 
 /**
  * DUE Board pin   |  PORT  | Label

Marlin/src/HAL/DUE/spi_pins.h

@@ -24,7 +24,7 @@
 /**
  * Define SPI Pins: SCK, MISO, MOSI, SS
  *
- * Available chip select pins for HW SPI are 4 10 52 77
+ * Available chip select pins for HW SPI are 4 10 52 77 87
  */
 #if SDSS == 4 || SDSS == 10 || SDSS == 52 || SDSS == 77 || SDSS == 87
   #if SDSS == 4

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

@@ -66,7 +66,7 @@
 
 #include <U8glib-HAL.h>
 
-#if ENABLED(FYSETC_MINI_12864)
+#if U8G_SPI_USE_MODE_3
   #define SPISEND_SW_DUE u8g_spiSend_sw_DUE_mode_3
 #else
   #define SPISEND_SW_DUE u8g_spiSend_sw_DUE_mode_0
@@ -96,15 +96,15 @@ uint8_t u8g_com_HAL_DUE_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void
       break;
 
     case U8G_COM_MSG_CHIP_SELECT:
-      #if ENABLED(FYSETC_MINI_12864)           // LCD SPI is running mode 3 while SD card is running mode 0
-        if (arg_val) {                        //   SCK idle state needs to be set to the proper idle state before
-                                               //   the next chip select goes active
-          u8g_SetPILevel_DUE(u8g, U8G_PI_SCK, 1);  //set SCK to mode 3 idle state before CS goes active
+      #if U8G_SPI_USE_MODE_3                        // LCD SPI is running mode 3 while SD card is running mode 0
+        if (arg_val) {                              // SCK idle state needs to be set to the proper idle state before
+                                                    //  the next chip select goes active
+          u8g_SetPILevel_DUE(u8g, U8G_PI_SCK, 1);   // Set SCK to mode 3 idle state before CS goes active
           u8g_SetPILevel_DUE(u8g, U8G_PI_CS, LOW);
         }
         else {
           u8g_SetPILevel_DUE(u8g, U8G_PI_CS, HIGH);
-          u8g_SetPILevel_DUE(u8g, U8G_PI_SCK, 0); //set SCK to mode 0 idle state after CS goes inactive
+          u8g_SetPILevel_DUE(u8g, U8G_PI_SCK, 0);   // Set SCK to mode 0 idle state after CS goes inactive
         }
       #else
         u8g_SetPILevel_DUE(u8g, U8G_PI_CS, !arg_val);

Marlin/src/HAL/DUE/upload_extra_script.py

@@ -11,7 +11,7 @@ if pioutil.is_pio_build():
 
     if current_OS == 'Windows':
 
-        Import("env")
+        env = pioutil.env
 
         # Use bossac.exe on Windows
         env.Replace(

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

@@ -18,30 +18,30 @@ extern "C" {
 void sd_mmc_spi_mem_init() {
 }
 
-Ctrl_status sd_mmc_spi_test_unit_ready() {
-  #ifdef DISABLE_DUE_SD_MMC
-    return CTRL_NO_PRESENT;
-  #endif
-  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted())
-    return CTRL_NO_PRESENT;
-  return CTRL_GOOD;
-}
-
-// NOTE: This function is defined as returning the address of the last block
-// in the card, which is cardSize() - 1
-Ctrl_status sd_mmc_spi_read_capacity(uint32_t *nb_sector) {
-  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted())
-    return CTRL_NO_PRESENT;
-  *nb_sector = card.diskIODriver()->cardSize() - 1;
-  return CTRL_GOOD;
+inline bool media_ready() {
+  return IS_SD_MOUNTED() && IS_SD_INSERTED() && !IS_SD_FILE_OPEN() && !IS_SD_PRINTING();
 }
 
 bool sd_mmc_spi_unload(bool) { return true; }
 
 bool sd_mmc_spi_wr_protect() { return false; }
 
-bool sd_mmc_spi_removal() {
-  return (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted());
+bool sd_mmc_spi_removal() { return !media_ready(); }
+
+Ctrl_status sd_mmc_spi_test_unit_ready() {
+  #ifdef DISABLE_DUE_SD_MMC
+    return CTRL_NO_PRESENT;
+  #endif
+  if (sd_mmc_spi_removal()) return CTRL_NO_PRESENT;
+  return CTRL_GOOD;
+}
+
+// NOTE: This function is defined as returning the address of the last block
+// in the card, which is cardSize() - 1
+Ctrl_status sd_mmc_spi_read_capacity(uint32_t *nb_sector) {
+  if (sd_mmc_spi_removal()) return CTRL_NO_PRESENT;
+  *nb_sector = card.diskIODriver()->cardSize() - 1;
+  return CTRL_GOOD;
 }
 
 #if ACCESS_USB == true
@@ -61,8 +61,7 @@ Ctrl_status sd_mmc_spi_usb_read_10(uint32_t addr, uint16_t nb_sector) {
   #ifdef DISABLE_DUE_SD_MMC
     return CTRL_NO_PRESENT;
   #endif
-  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted())
-    return CTRL_NO_PRESENT;
+  if (sd_mmc_spi_removal()) return CTRL_NO_PRESENT;
 
   #ifdef DEBUG_MMC
   {
@@ -101,8 +100,7 @@ Ctrl_status sd_mmc_spi_usb_write_10(uint32_t addr, uint16_t nb_sector) {
   #ifdef DISABLE_DUE_SD_MMC
     return CTRL_NO_PRESENT;
   #endif
-  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted())
-    return CTRL_NO_PRESENT;
+  if (sd_mmc_spi_removal()) return CTRL_NO_PRESENT;
 
   #ifdef DEBUG_MMC
   {

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

@@ -74,7 +74,7 @@
 //!
 //! @brief This function initializes the hw/sw resources required to drive the SD_MMC_SPI.
 //!/
-extern void           sd_mmc_spi_mem_init(void);
+void sd_mmc_spi_mem_init();
 
 //!
 //! @brief This function tests the state of the SD_MMC memory and sends it to the Host.
@@ -87,7 +87,7 @@ extern void           sd_mmc_spi_mem_init(void);
 //!   Media not present    ->    CTRL_NO_PRESENT
 //!   Media has changed    ->    CTRL_BUSY
 //!/
-extern Ctrl_status    sd_mmc_spi_test_unit_ready(void);
+Ctrl_status sd_mmc_spi_test_unit_ready();
 
 //!
 //! @brief This function gives the address of the last valid sector.
@@ -98,7 +98,7 @@ extern Ctrl_status    sd_mmc_spi_test_unit_ready(void);
 //!   Media ready          ->  CTRL_GOOD
 //!   Media not present    ->  CTRL_NO_PRESENT
 //!/
-extern Ctrl_status    sd_mmc_spi_read_capacity(uint32_t *nb_sector);
+Ctrl_status sd_mmc_spi_read_capacity(uint32_t *nb_sector);
 
 /*! \brief Unload/Load the SD/MMC card selected
  *
@@ -109,7 +109,7 @@ extern Ctrl_status    sd_mmc_spi_read_capacity(uint32_t *nb_sector);
  *
  * \return \c true if unload/load done success.
  */
-extern bool sd_mmc_spi_unload(bool unload);
+bool sd_mmc_spi_unload(bool unload);
 
 //!
 //! @brief This function returns the write protected status of the memory.
@@ -120,14 +120,14 @@ extern bool sd_mmc_spi_unload(bool unload);
 //!
 //! @return false  -> the memory is not write-protected (always)
 //!/
-extern bool           sd_mmc_spi_wr_protect(void);
+bool sd_mmc_spi_wr_protect();
 
 //!
 //! @brief This function tells if the memory has been removed or not.
 //!
 //! @return false  -> The memory isn't removed
 //!
-extern bool           sd_mmc_spi_removal(void);
+bool sd_mmc_spi_removal();
 
 //---- ACCESS DATA FUNCTIONS ----
 
@@ -147,7 +147,7 @@ extern bool           sd_mmc_spi_removal(void);
 //!   It is ready    ->    CTRL_GOOD
 //!   A error occur  ->    CTRL_FAIL
 //!
-extern Ctrl_status    sd_mmc_spi_usb_read_10(uint32_t addr, uint16_t nb_sector);
+Ctrl_status sd_mmc_spi_usb_read_10(uint32_t addr, uint16_t nb_sector);
 
 //! This function initializes the SD/MMC memory for a write operation
 //!
@@ -161,7 +161,7 @@ extern Ctrl_status    sd_mmc_spi_usb_read_10(uint32_t addr, uint16_t nb_sector);
 //!   It is ready    ->    CTRL_GOOD
 //!   An error occurs  ->    CTRL_FAIL
 //!
-extern Ctrl_status    sd_mmc_spi_usb_write_10(uint32_t addr, uint16_t nb_sector);
+Ctrl_status sd_mmc_spi_usb_write_10(uint32_t addr, uint16_t nb_sector);
 
 #endif // #if ACCESS_USB == true
 

Marlin/src/HAL/ESP32/HAL.cpp

@@ -209,16 +209,17 @@ int MarlinHAL::freeMemory() { return ESP.getFreeHeap(); }
 // ADC
 // ------------------------
 
-#define ADC1_CHANNEL(pin) ADC1_GPIO ## pin ## _CHANNEL
-
+// https://docs.espressif.com/projects/esp-idf/en/release-v4.4/esp32/api-reference/peripherals/adc.html
 adc1_channel_t get_channel(int pin) {
   switch (pin) {
-    case 39: return ADC1_CHANNEL(39);
-    case 36: return ADC1_CHANNEL(36);
-    case 35: return ADC1_CHANNEL(35);
-    case 34: return ADC1_CHANNEL(34);
-    case 33: return ADC1_CHANNEL(33);
-    case 32: return ADC1_CHANNEL(32);
+    case 39: return ADC1_CHANNEL_3;
+    case 36: return ADC1_CHANNEL_0;
+    case 35: return ADC1_CHANNEL_7;
+    case 34: return ADC1_CHANNEL_6;
+    case 33: return ADC1_CHANNEL_5;
+    case 32: return ADC1_CHANNEL_4;
+    case 37: return ADC1_CHANNEL_1;
+    case 38: return ADC1_CHANNEL_2;
   }
   return ADC1_CHANNEL_MAX;
 }

Marlin/src/HAL/ESP32/endstop_interrupts.h

@@ -59,6 +59,7 @@ void setup_endstop_interrupts() {
   TERN_(USE_Z4_MAX,      _ATTACH(Z4_MAX_PIN));
   TERN_(USE_Z4_MIN,      _ATTACH(Z4_MIN_PIN));
   TERN_(USE_Z_MIN_PROBE, _ATTACH(Z_MIN_PROBE_PIN));
+  TERN_(USE_CALIBRATION, _ATTACH(CALIBRATION_PIN));
   TERN_(USE_I_MAX,       _ATTACH(I_MAX_PIN));
   TERN_(USE_I_MIN,       _ATTACH(I_MIN_PIN));
   TERN_(USE_J_MAX,       _ATTACH(J_MAX_PIN));

Marlin/src/HAL/ESP32/fastio.h

@@ -37,6 +37,10 @@
 // Set pin as output
 #define _SET_OUTPUT(IO)         pinMode(IO, OUTPUT)
 
+// TODO: Store set modes in an array and use those to get the mode
+#define _IS_OUTPUT(IO)           true
+#define _IS_INPUT(IO)            true
+
 // Set pin as input with pullup mode
 #define _PULLUP(IO, v)          pinMode(IO, v ? INPUT_PULLUP : INPUT)
 
@@ -70,6 +74,9 @@
 // Set pin as output and init
 #define OUT_WRITE(IO,V)         do{ _SET_OUTPUT(IO); WRITE(IO,V); }while(0)
 
+#define IS_OUTPUT(IO)            _IS_OUTPUT(IO)
+#define IS_INPUT(IO)             _IS_INPUT(IO)
+
 // digitalRead/Write wrappers
 #define extDigitalRead(IO)      digitalRead(IO)
 #define extDigitalWrite(IO,V)   digitalWrite(IO,V)

Marlin/src/HAL/ESP32/i2s.cpp

@@ -152,7 +152,7 @@ void stepperTask(void *parameter) {
     xQueueReceive(dma.queue, &dma.current, portMAX_DELAY);
     dma.rw_pos = 0;
 
-    const bool using_ftMotion = TERN0(FT_MOTION, ftMotion.cfg.mode);
+    const bool using_ftMotion = TERN0(FT_MOTION, ftMotion.cfg.active);
 
     while (dma.rw_pos < DMA_SAMPLE_COUNT) {
 

Marlin/src/HAL/ESP32/ota.cpp

@@ -22,11 +22,15 @@
 
 #ifdef ARDUINO_ARCH_ESP32
 
+#include <WiFi.h>
+
+#undef ENABLED
+#undef DISABLED
+
 #include "../../inc/MarlinConfigPre.h"
 
 #if ALL(WIFISUPPORT, OTASUPPORT)
 
-#include <WiFi.h>
 #include <ESPmDNS.h>
 #include <WiFiUdp.h>
 #include <ArduinoOTA.h>

Marlin/src/HAL/ESP32/pinsDebug.h

@@ -0,0 +1,71 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2024 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
+
+#error "PINS_DEBUGGING is not yet supported for ESP32!"
+
+/**
+ * Pins Debugging for ESP32
+ *
+ *   - NUMBER_PINS_TOTAL
+ *   - MULTI_NAME_PAD
+ *   - getPinByIndex(index)
+ *   - printPinNameByIndex(index)
+ *   - getPinIsDigitalByIndex(index)
+ *   - digitalPinToAnalogIndex(pin)
+ *   - getValidPinMode(pin)
+ *   - isValidPin(pin)
+ *   - isAnalogPin(pin)
+ *   - digitalRead_mod(pin)
+ *   - pwm_status(pin)
+ *   - printPinPWM(pin)
+ *   - printPinPort(pin)
+ *   - printPinNumber(pin)
+ *   - printPinAnalog(pin)
+ */
+
+#define NUMBER_PINS_TOTAL NUM_DIGITAL_PINS
+#define MULTI_NAME_PAD 16 // space needed to be pretty if not first name assigned to a pin
+
+#define digitalRead_mod(P) extDigitalRead(P)
+#define printPinNameByIndex(x) do{ sprintf_P(buffer, PSTR("%-" STRINGIFY(MAX_NAME_LENGTH) "s"), pin_array[x].name); SERIAL_ECHO(buffer); }while(0)
+#define printPinNumber(P) do{ sprintf_P(buffer, PSTR("%02d"), P); SERIAL_ECHO(buffer); }while(0)
+#define printPinAnalog(P) do{ sprintf_P(buffer, PSTR(" (A%2d)  "), digitalPinToAnalogIndex(P)); SERIAL_ECHO(buffer); }while(0)
+#define getPinByIndex(x) pin_array[x].pin
+#define getPinIsDigitalByIndex(x) pin_array[x].is_digital
+#define isValidPin(P) (P >= 0 && P < pin_t(NUMBER_PINS_TOTAL))
+#define digitalPinToAnalogIndex(P) int(P - analogInputToDigitalPin(0))
+#define isAnalogPin(P) WITHIN(P, pin_t(analogInputToDigitalPin(0)), pin_t(analogInputToDigitalPin(NUM_ANALOG_INPUTS - 1)))
+bool pwm_status(const pin_t) { return false; }
+
+void printPinPort(const pin_t) {}
+
+static bool getValidPinMode(const pin_t pin) {
+  return isValidPin(pin) && !IS_INPUT(pin);
+}
+
+void printPinPWM(const int32_t pin) {
+  if (pwm_status(pin)) {
+    //uint32_t chan = g_APinDescription[pin].ulPWMChannel TODO when fast pwm is operative;
+    //SERIAL_ECHOPGM("PWM = ", duty);
+  }
+}

Marlin/src/HAL/ESP32/timers.cpp

@@ -90,7 +90,7 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
   config.counter_en  = TIMER_PAUSE;
   config.alarm_en    = TIMER_ALARM_EN;
   config.intr_type   = TIMER_INTR_LEVEL;
-  config.auto_reload = true;
+  config.auto_reload = TIMER_AUTORELOAD_EN;
 
   // Select and initialize the timer
   timer_init(timer.group, timer.idx, &config);

Marlin/src/HAL/ESP32/timers.h

@@ -53,12 +53,11 @@ typedef uint64_t hal_timer_t;
 #if ENABLED(I2S_STEPPER_STREAM)
   #define STEPPER_TIMER_PRESCALE     1
   #define STEPPER_TIMER_RATE         250000                           // 250khz, 4µs pulses of i2s word clock
-  #define STEPPER_TIMER_TICKS_PER_US ((STEPPER_TIMER_RATE) / 1000000) // stepper timer ticks per µs // wrong would be 0.25
 #else
   #define STEPPER_TIMER_PRESCALE     40
   #define STEPPER_TIMER_RATE         ((HAL_TIMER_RATE) / (STEPPER_TIMER_PRESCALE)) // frequency of stepper timer, 2MHz
-  #define STEPPER_TIMER_TICKS_PER_US ((STEPPER_TIMER_RATE) / 1000000)              // stepper timer ticks per µs
 #endif
+#define STEPPER_TIMER_TICKS_PER_US   ((STEPPER_TIMER_RATE) / 1000000) // stepper timer ticks per µs
 
 #define STEP_TIMER_MIN_INTERVAL   8 // minimum time in µs between stepper interrupts
 

Marlin/src/HAL/HC32/HAL.h

@@ -114,22 +114,19 @@
 // Misc. Functions
 //
 #ifndef analogInputToDigitalPin
-#define analogInputToDigitalPin(p) (p)
+  #define analogInputToDigitalPin(p) pin_t(p)
 #endif
 
-#define CRITICAL_SECTION_START        \
-  uint32_t primask = __get_PRIMASK(); \
-  (void)__iCliRetVal()
+#define CRITICAL_SECTION_START()        \
+  const bool irqon = !__get_PRIMASK();  \
+  __disable_irq();                      \
+  __DSB();
+#define CRITICAL_SECTION_END()          \
+  __DSB();                              \
+  if (irqon) __enable_irq();
 
-#define CRITICAL_SECTION_END \
-  if (!primask)              \
-  (void)__iSeiRetVal()
-
-// Disable interrupts
-#define cli() noInterrupts()
-
-// Enable interrupts
-#define sei() interrupts()
+#define cli() __disable_irq()
+#define sei() __enable_irq()
 
 // bss_end alias
 #define __bss_end __bss_end__
@@ -142,12 +139,31 @@
 // ADC
 //
 #define HAL_ADC_VREF_MV 3300
-#define HAL_ADC_RESOLUTION 10
+#define HAL_ADC_RESOLUTION 12
 
 #define GET_PIN_MAP_PIN(index) index
 #define GET_PIN_MAP_INDEX(pin) pin
 #define PARSED_PIN_INDEX(code, dval) parser.intval(code, dval)
 
+//
+// Debug port disable
+// JTMS / SWDIO = PA13
+// JTCK / SWCLK = PA14
+// JTDI         = PA15
+// JTDO         = PB3
+// NJTRST       = PB4
+//
+#define DBG_SWCLK _BV(0)
+#define DBG_SWDIO _BV(1)
+#define DBG_TDO   _BV(2)
+#define DBG_TDI   _BV(3)
+#define DBG_TRST  _BV(4)
+#define DBG_ALL (DBG_SWCLK | DBG_SWDIO | DBG_TDO | DBG_TDI | DBG_TRST)
+
+#define JTAGSWD_RESET() PORT_DebugPortSetting(DBG_ALL, Enable);
+#define JTAG_DISABLE() PORT_DebugPortSetting(DBG_TDO | DBG_TDI | DBG_TRST, Disable);
+#define JTAGSWD_DISABLE() PORT_DebugPortSetting(DBG_ALL, Disable);
+
 //
 // MarlinHAL implementation
 //

Marlin/src/HAL/HC32/MarlinHAL.cpp

@@ -232,7 +232,9 @@ int MarlinHAL::freeMemory() {
   return &top - _sbrk(0);
 }
 
-void MarlinHAL::adc_init() {}
+void MarlinHAL::adc_init() {
+  analogReadResolution(HAL_ADC_RESOLUTION);
+}
 
 void MarlinHAL::adc_enable(const pin_t pin) {
   #if TEMP_SENSOR_SOC

Marlin/src/HAL/HC32/MarlinSerial.h

@@ -31,8 +31,8 @@
 
 struct MarlinSerial : public Usart {
   MarlinSerial(
-    struct usart_config_t *usart_device, 
-    gpio_pin_t tx_pin, 
+    struct usart_config_t *usart_device,
+    gpio_pin_t tx_pin,
     gpio_pin_t rx_pin
     #if ENABLED(SERIAL_DMA)
     , M4_DMA_TypeDef *dma_unit = nullptr,

Marlin/src/HAL/HC32/app_config.h

@@ -1,6 +1,6 @@
 /**
  * app_config.h is included by the hc32f460 arduino build script for every source file.
- * it is used to configure the arduino core (and ddl) automatically according 
+ * it is used to configure the arduino core (and ddl) automatically according
  * to the settings in Configuration.h and Configuration_adv.h.
  */
 #pragma once
@@ -44,7 +44,7 @@
 #define DISABLE_SERIAL_GLOBALS 1
 
 // increase the size of the Usart buffers (both RX and TX)
-// NOTE: 
+// NOTE:
 // the heap usage will increase by (SERIAL_BUFFER_SIZE - 64) * "number of serial ports used"
 // if running out of heap, the system may become unstable
 //#define SERIAL_BUFFER_SIZE 256
@@ -64,7 +64,12 @@
 // redirect printf to host serial
 #define REDIRECT_PRINTF_TO_SERIAL 1
 
-// FIXME override F_CPU to PCLK1, as marlin freaks out otherwise
-#define F_CPU (SYSTEM_CLOCK_FREQUENCIES.pclk1)
+// F_CPU must be known at compile time, but on HC32F460 it's not.
+// Thus we assume HCLK to be 200MHz, as that's what is configured in
+// 'core_hook_sysclock_init' in 'sysclock.cpp'.
+// If you face issues with this assumption, please double-check with the values
+// printed by 'MarlinHAL::HAL_clock_frequencies_dump'.
+// see also: HAL_TIMER_RATE in timers.h
+#define F_CPU 200000000 // 200MHz HCLK
 
 #endif // _HC32_APP_CONFIG_H_

Marlin/src/HAL/HC32/endstop_interrupts.cpp

@@ -101,12 +101,14 @@ void setup_endstop_interrupts() {
 
   SETUP(Z_MIN_PROBE);
 
+  SETUP(CALIBRATION);
+
   #undef SETUP
 }
 
 // Ensure 1 - 10 IRQs are registered
 // Disable some endstops if you encounter this error
-#define ENDSTOPS_INTERRUPTS_COUNT COUNT_ENABLED(USE_X_MAX, USE_X_MIN, USE_X2_MAX, USE_X2_MIN, USE_Y_MAX, USE_Y_MIN, USE_Y2_MAX, USE_Y2_MIN, USE_Z_MAX, USE_Z_MIN, USE_Z2_MAX, USE_Z2_MIN, USE_Z3_MAX, USE_Z3_MIN, USE_Z4_MAX, USE_Z4_MIN, USE_Z_MIN_PROBE)
+#define ENDSTOPS_INTERRUPTS_COUNT COUNT_ENABLED(USE_X_MAX, USE_X_MIN, USE_X2_MAX, USE_X2_MIN, USE_Y_MAX, USE_Y_MIN, USE_Y2_MAX, USE_Y2_MIN, USE_Z_MAX, USE_Z_MIN, USE_Z2_MAX, USE_Z2_MIN, USE_Z3_MAX, USE_Z3_MIN, USE_Z4_MAX, USE_Z4_MIN, USE_Z_MIN_PROBE, USE_CALIBRATION)
 #if ENDSTOPS_INTERRUPTS_COUNT > 10
   #error "Too many endstop interrupts! HC32F460 only supports 10 endstop interrupts."
 #elif ENDSTOPS_INTERRUPTS_COUNT == 0

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

@@ -30,7 +30,7 @@
 #endif
 
 #if ARDUINO_CORE_VERSION_INT < GET_VERSION_INT(1, 1, 0)
-  // because we use app_config.h introduced in arduino core version 1.1.0, the 
+  // because we use app_config.h introduced in arduino core version 1.1.0, the
   // HAL is not compatible with older versions
   #error "The HC32 HAL is not compatible with Arduino Core versions < 1.1.0. Consider updating the Arduino Core."
 #endif
@@ -94,8 +94,10 @@
     #error "SERIAL_DMA requires USART_RX_DMA_SUPPORT to be enabled in the arduino core."
   #endif
 
-  // USART_RX_DMA_SUPPORT does not implement core_hook_usart_rx_irq, which is required for the emergency parser
-  #if ENABLED(EMERGENCY_PARSER)
+  // Before arduino core version 1.2.0, USART_RX_DMA_SUPPORT did not implement 
+  // core_hook_usart_rx_irq, which is required for the emergency parser.
+  // With 1.2.0, this was fixed (see https://github.com/shadow578/framework-arduino-hc32f46x/pull/25).
+  #if ENABLED(EMERGENCY_PARSER) && ARDUINO_CORE_VERSION_INT < GET_VERSION_INT(1, 2, 0)
     #error "EMERGENCY_PARSER is not supported with SERIAL_DMA. Please disable either SERIAL_DMA or EMERGENCY_PARSER."
   #endif
 

Marlin/src/HAL/HC32/pinsDebug.h

@@ -18,41 +18,47 @@
  */
 #pragma once
 
+/**
+ * Pins Debugging for HC32
+ *
+ *   - NUMBER_PINS_TOTAL
+ *   - MULTI_NAME_PAD
+ *   - getPinByIndex(index)
+ *   - printPinNameByIndex(index)
+ *   - getPinIsDigitalByIndex(index)
+ *   - digitalPinToAnalogIndex(pin)
+ *   - getValidPinMode(pin)
+ *   - isValidPin(pin)
+ *   - isAnalogPin(pin)
+ *   - digitalRead_mod(pin)
+ *   - pwm_status(pin)
+ *   - printPinPWM(pin)
+ *   - printPinPort(pin)
+ *   - printPinNumber(pin)
+ *   - printPinAnalog(pin)
+ */
+
 #include "../../inc/MarlinConfig.h"
 #include "fastio.h"
 #include <drivers/timera/timera_pwm.h>
 
-//
-// Translation of routines & variables used by pinsDebug.h
-//
 #ifndef BOARD_NR_GPIO_PINS
   #error "Expected BOARD_NR_GPIO_PINS not found."
 #endif
 
 #define NUM_DIGITAL_PINS BOARD_NR_GPIO_PINS
 #define NUMBER_PINS_TOTAL BOARD_NR_GPIO_PINS
-#define VALID_PIN(pin) IS_GPIO_PIN(pin)
+#define isValidPin(P) IS_GPIO_PIN(P)
 
 // Note: pin_array is defined in `Marlin/src/pins/pinsDebug.h`, and since this file is included
 // after it, it is available in this file as well.
-#define GET_ARRAY_PIN(p) pin_t(pin_array[p].pin)
-#define digitalRead_mod(p) extDigitalRead(p)
-#define PRINT_PIN(p)                              \
-  do {                                            \
-    sprintf_P(buffer, PSTR("%3hd "), int16_t(p)); \
-    SERIAL_ECHO(buffer);                          \
-  } while (0)
-#define PRINT_PIN_ANALOG(p)                                               \
-  do {                                                                    \
-    sprintf_P(buffer, PSTR(" (A%2d)  "), DIGITAL_PIN_TO_ANALOG_PIN(pin)); \
-    SERIAL_ECHO(buffer);                                                  \
-  } while (0)
-#define PRINT_PORT(p) print_port(p)
-#define PRINT_ARRAY_NAME(x)                                                          \
-  do {                                                                               \
-    sprintf_P(buffer, PSTR("%-" STRINGIFY(MAX_NAME_LENGTH) "s"), pin_array[x].name); \
-    SERIAL_ECHO(buffer);                                                             \
-  } while (0)
+#define getPinByIndex(x) pin_t(pin_array[x].pin)
+#define digitalRead_mod(P) extDigitalRead(P)
+
+#define printPinNumber(P) do{ sprintf_P(buffer, PSTR("%3hd "), int16_t(P)); SERIAL_ECHO(buffer); }while(0)
+#define printPinAnalog(P) do{ sprintf_P(buffer, PSTR(" (A%2d)  "), digitalPinToAnalogIndex(P)); SERIAL_ECHO(buffer); }while(0)
+
+#define printPinNameByIndex(x) do{ sprintf_P(buffer, PSTR("%-" STRINGIFY(MAX_NAME_LENGTH) "s"), pin_array[x].name); SERIAL_ECHO(buffer); }while(0)
 
 #define MULTI_NAME_PAD 21 // Space needed to be pretty if not first name assigned to a pin
 
@@ -71,14 +77,14 @@
   #define M43_NEVER_TOUCH(Q) (IS_HOST_USART_PIN(Q) || IS_OSC_PIN(Q))
 #endif
 
-static pin_t DIGITAL_PIN_TO_ANALOG_PIN(pin_t pin) {
-  if (!VALID_PIN(pin)) return -1;
+int8_t digitalPinToAnalogIndex(const pin_t pin) {
+  if (!isValidPin(pin)) return -1;
   const int8_t adc_channel = int8_t(PIN_MAP[pin].adc_info.channel);
   return pin_t(adc_channel);
 }
 
-static bool IS_ANALOG(pin_t pin) {
-  if (!VALID_PIN(pin)) return false;
+bool isAnalogPin(pin_t pin) {
+  if (!isValidPin(pin)) return false;
 
   if (PIN_MAP[pin].adc_info.channel != ADC_PIN_INVALID)
     return _GET_MODE(pin) == INPUT_ANALOG && !M43_NEVER_TOUCH(pin);
@@ -86,13 +92,13 @@ static bool IS_ANALOG(pin_t pin) {
   return false;
 }
 
-static bool GET_PINMODE(const pin_t pin) {
-  return VALID_PIN(pin) && !IS_INPUT(pin);
+bool getValidPinMode(const pin_t pin) {
+  return isValidPin(pin) && !IS_INPUT(pin);
 }
 
-static bool GET_ARRAY_IS_DIGITAL(const int16_t array_pin) {
-  const pin_t pin = GET_ARRAY_PIN(array_pin);
-  return (!IS_ANALOG(pin));
+bool getPinIsDigitalByIndex(const int16_t index) {
+  const pin_t pin = getPinByIndex(index);
+  return (!isAnalogPin(pin));
 }
 
 /**
@@ -117,7 +123,7 @@ bool pwm_status(const pin_t pin) {
   return timera_is_unit_initialized(unit) && timera_is_channel_active(unit, channel) && getPinMode(pin) == OUTPUT_PWM;
 }
 
-void pwm_details(const pin_t pin) {
+void printPinPWM(const pin_t pin) {
   // Get timer assignment for pin
   timera_config_t *unit;
   en_timera_channel_t channel;
@@ -161,7 +167,7 @@ void pwm_details(const pin_t pin) {
   }
 }
 
-void print_port(pin_t pin) {
+void printPinPort(pin_t pin) {
   const char port = 'A' + char(pin >> 4); // Pin div 16
   const int16_t gbit = PIN_MAP[pin].bit_pos;
   char buffer[8];

Marlin/src/HAL/HC32/sysclock.cpp

@@ -96,29 +96,44 @@ void core_hook_sysclock_init() {
     #endif
   #endif
 
-  // Setup clock divisors for sysclk = 200 MHz:
+  // sysclk is now configured according to F_CPU (i.e., 200MHz PLL output)
+  const uint32_t sysclock = F_CPU;
+
+  // Setup clock divisors for sysclk = 200 MHz
   // Note: PCLK1 is used for step+temp timers, and need to be kept at 50 MHz (until there is a better solution)
-  stc_clk_sysclk_cfg_t sysClkConf = {
+  constexpr stc_clk_sysclk_cfg_t sysClkConf = {
       .enHclkDiv = ClkSysclkDiv1,  // HCLK  = 200 MHz (CPU)
       .enExclkDiv = ClkSysclkDiv2, // EXCLK = 100 MHz (SDIO)
-      .enPclk0Div = ClkSysclkDiv1, // PCLK0 = 200 MHz (Timer6 (not used))
+      .enPclk0Div = ClkSysclkDiv2, // PCLK0 = 100 MHz (Timer6 (not used))
       .enPclk1Div = ClkSysclkDiv4, // PCLK1 = 50 MHz (USART, SPI, I2S, Timer0 (step+temp), TimerA (Servo))
-      .enPclk2Div = ClkSysclkDiv4, // PCLK2 = 50 MHz (ADC)
-      .enPclk3Div = ClkSysclkDiv4, // PCLK3 = 50 MHz (I2C, WDT)
+      .enPclk2Div = ClkSysclkDiv8, // PCLK2 = 25 MHz (ADC)
+      .enPclk3Div = ClkSysclkDiv8, // PCLK3 = 25 MHz (I2C, WDT)
       .enPclk4Div = ClkSysclkDiv2, // PCLK4 = 100 MHz (ADC ctl)
   };
+
+  #if ARDUINO_CORE_VERSION_INT >= GET_VERSION_INT(1, 2, 0)
+    assert_system_clocks_valid<
+      sysclock,
+      sysClkConf.enHclkDiv,
+      sysClkConf.enPclk0Div,
+      sysClkConf.enPclk1Div,
+      sysClkConf.enPclk2Div,
+      sysClkConf.enPclk3Div,
+      sysClkConf.enPclk4Div,
+      sysClkConf.enExclkDiv
+    >();
+  #endif
+
   sysclock_set_clock_dividers(&sysClkConf);
 
   // Set power mode
-  #define POWER_MODE_SYSTEM_CLOCK 200000000 // 200 MHz
-  power_mode_update_pre(POWER_MODE_SYSTEM_CLOCK);
+  power_mode_update_pre(sysclock);
 
   // Switch to MPLL as sysclk source
   CLK_SetSysClkSource(CLKSysSrcMPLL);
 
   // Set power mode
-  power_mode_update_post(POWER_MODE_SYSTEM_CLOCK);
-  #undef POWER_MODE_SYSTEM_CLOCK
+  power_mode_update_post(sysclock);
 }
 
 #endif // ARDUINO_ARCH_HC32

Marlin/src/HAL/HC32/timers.h

@@ -38,44 +38,48 @@ extern Timer0 step_timer;
 // Timer Configurations
 //
 
-// TODO: some calculations (step irq min_step_rate) require the timer rate to be known at compile time
-//       this is not possible with the HC32F460, as the timer rate depends on PCLK1
-//       as a workaround, PCLK1 = 50MHz is assumed (check with clock dump in MarlinHAL::init())
-#define HAL_TIMER_RATE 50000000 // 50MHz
-// #define HAL_TIMER_RATE TIMER0_BASE_FREQUENCY
-
-// TODO: CYCLES_PER_MICROSECOND seems to be used by Marlin to calculate the number of cycles per microsecond in the timer ISRs
-//       by default, it uses F_CPU, but since that is not known at compile time for HC32, we overwrite it here
-#undef CYCLES_PER_MICROSECOND
-#define CYCLES_PER_MICROSECOND (HAL_TIMER_RATE / 1000000UL)
+/**
+ * HAL_TIMER_RATE must be known at compile time since it's used to calculate
+ * STEPPER_TIMER_RATE, which is used in 'constexpr' calculations.
+ * On the HC32F460 the timer rate depends on PCLK1, which is derived from the
+ * system clock configured at runtime. As a workaround, we use the existing
+ * assumption of a 200MHz clock, defining F_CPU as 200000000, then configure PCLK1
+ * as F_CPU with a divider of 4 in 'sysclock.cpp::core_hook_sysclock_init'.
+ *
+ * If you face issues with this assumption, please double-check with the values
+ * printed by 'MarlinHAL::HAL_clock_frequencies_dump'.
+ *
+ * TODO: If the 'constexpr' requirement is ever lifted, use TIMER0_BASE_FREQUENCY instead
+ */
+#define HAL_TIMER_RATE (F_CPU / 4) // i.e., 50MHz
+//#define HAL_TIMER_RATE TIMER0_BASE_FREQUENCY
 
 // Temperature timer
-#define TEMP_TIMER_NUM (&temp_timer)
-#define TEMP_TIMER_PRIORITY DDL_IRQ_PRIORITY_02
-#define TEMP_TIMER_PRESCALE 16ul
-#define TEMP_TIMER_RATE 1000                 // 1kHz
-#define TEMP_TIMER_FREQUENCY TEMP_TIMER_RATE // Alias for Marlin
+#define TEMP_TIMER_NUM        (&temp_timer)
+#define TEMP_TIMER_PRIORITY   DDL_IRQ_PRIORITY_02
+#define TEMP_TIMER_PRESCALE     16UL          // 12.5MHz
+#define TEMP_TIMER_RATE       1000            // 1kHz
+#define TEMP_TIMER_FREQUENCY  TEMP_TIMER_RATE // 1kHz also
 
 // Stepper timer
-#define STEP_TIMER_NUM (&step_timer)
-#define STEP_TIMER_PRIORITY DDL_IRQ_PRIORITY_01
-#define STEPPER_TIMER_PRESCALE 16ul
+#define STEP_TIMER_NUM         (&step_timer)
+#define STEP_TIMER_PRIORITY    DDL_IRQ_PRIORITY_00  // Top priority, nothing else uses it
+#define STEPPER_TIMER_PRESCALE  16UL                // 12.5MHz
 
-// TODO: STEPPER_TIMER_RATE seems to work fine like this, but requires further testing...
-#define STEPPER_TIMER_RATE (HAL_TIMER_RATE / STEPPER_TIMER_PRESCALE) // 50MHz / 16 = 3.125MHz
-#define STEPPER_TIMER_TICKS_PER_US (STEPPER_TIMER_RATE / 1000000)
+#define STEPPER_TIMER_RATE (HAL_TIMER_RATE / STEPPER_TIMER_PRESCALE)  // 50MHz / 16 = 3.125MHz
+#define STEPPER_TIMER_TICKS_PER_US (STEPPER_TIMER_RATE / 1000000UL)   // Integer 3
 
 // Pulse timer (== stepper timer)
-#define PULSE_TIMER_NUM STEP_TIMER_NUM
-#define PULSE_TIMER_PRESCALE STEPPER_TIMER_PRESCALE
-#define PULSE_TIMER_TICKS_PER_US STEPPER_TIMER_TICKS_PER_US
+#define PULSE_TIMER_NUM           STEP_TIMER_NUM
+#define PULSE_TIMER_PRESCALE      STEPPER_TIMER_PRESCALE
+#define PULSE_TIMER_TICKS_PER_US  STEPPER_TIMER_TICKS_PER_US
 
 //
 // Channel aliases
 //
-#define MF_TIMER_TEMP TEMP_TIMER_NUM
-#define MF_TIMER_STEP STEP_TIMER_NUM
-#define MF_TIMER_PULSE PULSE_TIMER_NUM
+#define MF_TIMER_TEMP   TEMP_TIMER_NUM
+#define MF_TIMER_STEP   STEP_TIMER_NUM
+#define MF_TIMER_PULSE  PULSE_TIMER_NUM
 
 //
 // HAL functions

Marlin/src/HAL/HC32/u8g/u8g_com_HAL_HC32_sw_spi.cpp

@@ -82,7 +82,7 @@ static inline uint8_t swSpiTransfer_mode_3(uint8_t b, const uint8_t spi_speed, c
 }
 
 static void u8g_sw_spi_shift_out(uint8_t val) {
-  #if ANY(FYSETC_MINI_12864, MKS_MINI_12864)
+  #if U8G_SPI_USE_MODE_3
     swSpiTransfer_mode_3(val, SPI_speed);
   #else
     swSpiTransfer_mode_0(val, SPI_speed);
@@ -116,15 +116,15 @@ uint8_t u8g_com_HAL_HC32_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, voi
       break;
 
     case U8G_COM_MSG_CHIP_SELECT:
-      #if ANY(FYSETC_MINI_12864, MKS_MINI_12864) // This LCD SPI is running mode 3 while SD card is running mode 0
-        if (arg_val) {                           // SCK idle state needs to be set to the proper idle state before
-                                                 // the next chip select goes active
-          WRITE(DOGLCD_SCK, HIGH);               // Set SCK to mode 3 idle state before CS goes active
+      #if U8G_SPI_USE_MODE_3        // This LCD SPI is running mode 3 while SD card is running mode 0
+        if (arg_val) {              // SCK idle state needs to be set to the proper idle state before
+                                    //  the next chip select goes active
+          WRITE(DOGLCD_SCK, HIGH);  // Set SCK to mode 3 idle state before CS goes active
           WRITE(DOGLCD_CS, LOW);
         }
         else {
           WRITE(DOGLCD_CS, HIGH);
-          WRITE(DOGLCD_SCK, LOW);  // Set SCK to mode 0 idle state after CS goes inactive
+          WRITE(DOGLCD_SCK, LOW);   // Set SCK to mode 0 idle state after CS goes inactive
         }
       #else
         WRITE(DOGLCD_CS, !arg_val);

Marlin/src/HAL/LINUX/HAL.cpp

@@ -52,7 +52,7 @@ uint8_t MarlinHAL::active_ch = 0;
 
 uint16_t MarlinHAL::adc_value() {
   const pin_t pin = analogInputToDigitalPin(active_ch);
-  if (!VALID_PIN(pin)) return 0;
+  if (!isValidPin(pin)) return 0;
   return uint16_t((Gpio::get(pin) >> 2) & 0x3FF); // return 10bit value as Marlin expects
 }
 

Marlin/src/HAL/LINUX/arduino.cpp

@@ -49,28 +49,28 @@ extern "C" void delay(const int msec) {
 // IO functions
 // As defined by Arduino INPUT(0x0), OUTPUT(0x1), INPUT_PULLUP(0x2)
 void pinMode(const pin_t pin, const uint8_t mode) {
-  if (!VALID_PIN(pin)) return;
+  if (!isValidPin(pin)) return;
   Gpio::setMode(pin, mode);
 }
 
 void digitalWrite(pin_t pin, uint8_t pin_status) {
-  if (!VALID_PIN(pin)) return;
+  if (!isValidPin(pin)) return;
   Gpio::set(pin, pin_status);
 }
 
 bool digitalRead(pin_t pin) {
-  if (!VALID_PIN(pin)) return false;
+  if (!isValidPin(pin)) return false;
   return Gpio::get(pin);
 }
 
 void analogWrite(pin_t pin, int pwm_value) {  // 1 - 254: pwm_value, 0: LOW, 255: HIGH
-  if (!VALID_PIN(pin)) return;
+  if (!isValidPin(pin)) return;
   Gpio::set(pin, pwm_value);
 }
 
 uint16_t analogRead(pin_t adc_pin) {
-  if (!VALID_PIN(DIGITAL_PIN_TO_ANALOG_PIN(adc_pin))) return 0;
-  return Gpio::get(DIGITAL_PIN_TO_ANALOG_PIN(adc_pin));
+  if (!isValidPin(digitalPinToAnalogIndex(adc_pin))) return 0;
+  return Gpio::get(digitalPinToAnalogIndex(adc_pin));
 }
 
 char *dtostrf(double __val, signed char __width, unsigned char __prec, char *__s) {

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

@@ -37,29 +37,29 @@ constexpr uint8_t NUM_ANALOG_INPUTS = 16;
 constexpr uint8_t analog_offset = NUM_DIGITAL_PINS - NUM_ANALOG_INPUTS;
 
 // Get the digital pin for an analog index
-constexpr pin_t analogInputToDigitalPin(const int8_t p) {
-  return (WITHIN(p, 0, NUM_ANALOG_INPUTS) ? analog_offset + p : P_NC);
+constexpr pin_t analogInputToDigitalPin(const int8_t a) {
+  return (WITHIN(a, 0, NUM_ANALOG_INPUTS - 1) ? analog_offset + a : P_NC);
 }
 
 // Get the analog index for a digital pin
-constexpr int8_t DIGITAL_PIN_TO_ANALOG_PIN(const pin_t p) {
-  return (WITHIN(p, analog_offset, NUM_DIGITAL_PINS) ? p - analog_offset : P_NC);
+constexpr int8_t digitalPinToAnalogIndex(const pin_t pin) {
+  return (WITHIN(pin, analog_offset, NUM_DIGITAL_PINS - 1) ? pin - analog_offset : P_NC);
 }
 
 // Return the index of a pin number
 constexpr int16_t GET_PIN_MAP_INDEX(const pin_t pin) { return pin; }
 
 // Test whether the pin is valid
-constexpr bool VALID_PIN(const pin_t p) { return WITHIN(p, 0, NUM_DIGITAL_PINS); }
+constexpr bool isValidPin(const pin_t pin) { return WITHIN(pin, 0, NUM_DIGITAL_PINS - 1); }
 
 // Test whether the pin is PWM
-constexpr bool PWM_PIN(const pin_t p) { return false; }
+constexpr bool PWM_PIN(const pin_t) { return false; }
 
 // Test whether the pin is interruptible
-constexpr bool INTERRUPT_PIN(const pin_t p) { return false; }
+constexpr bool INTERRUPT_PIN(const pin_t) { return false; }
 
 // Get the pin number at the given index
-constexpr pin_t GET_PIN_MAP_PIN(const int16_t ind) { return ind; }
+constexpr pin_t GET_PIN_MAP_PIN(const int16_t index) { return pin_t(index); }
 
 // Parse a G-code word into a pin index
 int16_t PARSED_PIN_INDEX(const char code, const int16_t dval);

Marlin/src/HAL/LINUX/pinsDebug.h

@@ -19,30 +19,50 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
+#pragma once
 
 /**
- * Support routines for X86_64
- */
-
-/**
- * Translation of routines & variables used by pinsDebug.h
+ * Pins Debugging for Linux Native
+ *
+ *   - NUMBER_PINS_TOTAL
+ *   - MULTI_NAME_PAD
+ *   - getPinByIndex(index)
+ *   - printPinNameByIndex(index)
+ *   - getPinIsDigitalByIndex(index)
+ *   - digitalPinToAnalogIndex(pin)
+ *   - getValidPinMode(pin)
+ *   - isValidPin(pin)
+ *   - isAnalogPin(pin)
+ *   - digitalRead_mod(pin)
+ *   - pwm_status(pin)
+ *   - printPinPWM(pin)
+ *   - printPinPort(pin)
+ *   - printPinNumber(pin)
+ *   - printPinAnalog(pin)
  */
 
 #define NUMBER_PINS_TOTAL   NUM_DIGITAL_PINS
-#define IS_ANALOG(P)        (DIGITAL_PIN_TO_ANALOG_PIN(P) >= 0 ? 1 : 0)
-#define digitalRead_mod(p)  digitalRead(p)
-#define GET_ARRAY_PIN(p)    pin_array[p].pin
-#define PRINT_ARRAY_NAME(x) do{ sprintf_P(buffer, PSTR("%-" STRINGIFY(MAX_NAME_LENGTH) "s"), pin_array[x].name); SERIAL_ECHO(buffer); }while(0)
-#define PRINT_PIN(p)        do{ sprintf_P(buffer, PSTR("%3d "), p); SERIAL_ECHO(buffer); }while(0)
-#define PRINT_PIN_ANALOG(p) do{ sprintf_P(buffer, PSTR(" (A%2d)  "), DIGITAL_PIN_TO_ANALOG_PIN(pin)); SERIAL_ECHO(buffer); }while(0)
 #define MULTI_NAME_PAD      16 // space needed to be pretty if not first name assigned to a pin
 
+#define getPinByIndex(x) pin_array[x].pin
+
+#define printPinNameByIndex(x) do{ sprintf_P(buffer, PSTR("%-" STRINGIFY(MAX_NAME_LENGTH) "s"), pin_array[x].name); SERIAL_ECHO(buffer); }while(0)
+
 // active ADC function/mode/code values for PINSEL registers
-constexpr int8_t ADC_pin_mode(pin_t pin) { return -1; }
+constexpr int8_t ADC_pin_mode(const pin_t) { return -1; }
 
-int8_t get_pin_mode(const pin_t pin) { return VALID_PIN(pin) ? 0 : -1; }
+// The pin and index are the same on this platform
+bool getPinIsDigitalByIndex(const pin_t pin) {
+  return (!isAnalogPin(pin) || get_pin_mode(pin) != ADC_pin_mode(pin));
+}
 
-bool GET_PINMODE(const pin_t pin) {
+#define isAnalogPin(P) (digitalPinToAnalogIndex(P) >= 0)
+
+#define digitalRead_mod(P) digitalRead(P)
+
+int8_t get_pin_mode(const pin_t pin) { return isValidPin(pin) ? 0 : -1; }
+
+bool getValidPinMode(const pin_t pin) {
   const int8_t pin_mode = get_pin_mode(pin);
   if (pin_mode == -1 || pin_mode == ADC_pin_mode(pin)) // Invalid pin or active analog pin
     return false;
@@ -50,11 +70,11 @@ bool GET_PINMODE(const pin_t pin) {
   return (Gpio::getMode(pin) != 0); // Input/output state
 }
 
-bool GET_ARRAY_IS_DIGITAL(const pin_t pin) {
-  return (!IS_ANALOG(pin) || get_pin_mode(pin) != ADC_pin_mode(pin));
-}
-
-void pwm_details(const pin_t pin) {}
+void printPinPWM(const pin_t) {}
 bool pwm_status(const pin_t) { return false; }
 
-void print_port(const pin_t) {}
+void printPinPort(const pin_t) {}
+
+#define printPinNumber(P) do{ sprintf_P(buffer, PSTR("%3d "), P); SERIAL_ECHO(buffer); }while(0)
+
+#define printPinAnalog(P) do{ sprintf_P(buffer, PSTR(" (A%2d)  "), digitalPinToAnalogIndex(P)); SERIAL_ECHO(buffer); }while(0)

Marlin/src/HAL/LINUX/spi_pins.h

@@ -28,12 +28,6 @@
                         // spiBeginTransaction.
 #endif
 
-// Onboard SD
-//#define SD_SCK_PIN     P0_07
-//#define SD_MISO_PIN    P0_08
-//#define SD_MOSI_PIN    P0_09
-//#define SD_SS_PIN      P0_06
-
 // External SD
 #ifndef SD_SCK_PIN
   #define SD_SCK_PIN        50

Marlin/src/HAL/LPC1768/HAL.h

@@ -82,13 +82,13 @@ extern DefaultSerial1 USBSerial;
   #endif
 #endif
 
-#ifdef MMU2_SERIAL_PORT
-  #if MMU2_SERIAL_PORT == -1
-    #define MMU2_SERIAL USBSerial
-  #elif WITHIN(MMU2_SERIAL_PORT, 0, 3)
-    #define MMU2_SERIAL MSERIAL(MMU2_SERIAL_PORT)
+#ifdef MMU_SERIAL_PORT
+  #if MMU_SERIAL_PORT == -1
+    #define MMU_SERIAL USBSerial
+  #elif WITHIN(MMU_SERIAL_PORT, 0, 3)
+    #define MMU_SERIAL MSERIAL(MMU_SERIAL_PORT)
   #else
-    #error "MMU2_SERIAL_PORT must be from 0 to 3. You can also use -1 if the board supports Native USB."
+    #error "MMU_SERIAL_PORT must be from 0 to 3. You can also use -1 if the board supports Native USB."
   #endif
 #endif
 
@@ -100,7 +100,7 @@ extern DefaultSerial1 USBSerial;
   #else
     #error "LCD_SERIAL_PORT must be from 0 to 3. You can also use -1 if the board supports Native USB."
   #endif
-  #if HAS_DGUS_LCD || ENABLED(DWINOS_4)
+  #if ANY(HAS_DGUS_LCD, EXTENSIBLE_UI)
     #define LCD_SERIAL_TX_BUFFER_FREE() LCD_SERIAL.available()
   #endif
 #endif
@@ -137,12 +137,12 @@ extern DefaultSerial1 USBSerial;
 //
 
 // Test whether the pin is valid
-constexpr bool VALID_PIN(const pin_t pin) {
+constexpr bool isValidPin(const pin_t pin) {
   return LPC176x::pin_is_valid(pin);
 }
 
 // Get the analog index for a digital pin
-constexpr int8_t DIGITAL_PIN_TO_ANALOG_PIN(const pin_t pin) {
+constexpr int8_t digitalPinToAnalogIndex(const pin_t pin) {
   return (LPC176x::pin_is_valid(pin) && LPC176x::pin_has_adc(pin)) ? pin : -1;
 }
 
@@ -159,7 +159,7 @@ constexpr pin_t GET_PIN_MAP_PIN(const int16_t index) {
 // Parse a G-code word into a pin index
 int16_t PARSED_PIN_INDEX(const char code, const int16_t dval);
 // P0.6 thru P0.9 are for the onboard SD card
-#define HAL_SENSITIVE_PINS P0_06, P0_07, P0_08, P0_09,
+#define HAL_SENSITIVE_PINS P0_06, P0_07, P0_08, P0_09
 
 // ------------------------
 // Defines

Marlin/src/HAL/LPC1768/endstop_interrupts.h

@@ -146,6 +146,12 @@ void setup_endstop_interrupts() {
     #endif
     _ATTACH(Z_MIN_PROBE_PIN);
   #endif
+  #if USE_CALIBRATION
+    #if !LPC1768_PIN_INTERRUPT_M(CALIBRATION_PIN)
+      #error "CALIBRATION_PIN is not INTERRUPT-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
+    #endif
+    _ATTACH(CALIBRATION_PIN);
+  #endif
   #if USE_I_MAX
     #if !LPC1768_PIN_INTERRUPT_M(I_MAX_PIN)
       #error "I_MAX_PIN is not INTERRUPT-capable. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."

Marlin/src/HAL/LPC1768/fast_pwm.cpp

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

Marlin/src/HAL/LPC1768/fastio.h

@@ -66,7 +66,7 @@
 #define _WRITE(IO,V)          WRITE_PIN(IO,V)
 
 /// toggle a pin
-#define _TOGGLE(IO)           _WRITE(IO, !READ(IO))
+#define _TOGGLE(IO)           LPC176x::gpio_toggle(IO)
 
 /// set pin as input
 #define _SET_INPUT(IO)        SET_DIR_INPUT(IO)

Marlin/src/HAL/LPC1768/pinsDebug.h

@@ -19,22 +19,35 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
+#pragma once
 
 /**
- * Support routines for LPC1768
- */
-
-/**
- * Translation of routines & variables used by pinsDebug.h
+ * Pins Debugging for LPC1768/9
+ *
+ *   - NUMBER_PINS_TOTAL
+ *   - MULTI_NAME_PAD
+ *   - getPinByIndex(index)
+ *   - printPinNameByIndex(index)
+ *   - getPinIsDigitalByIndex(index)
+ *   - digitalPinToAnalogIndex(pin)
+ *   - getValidPinMode(pin)
+ *   - isValidPin(pin)
+ *   - isAnalogPin(pin)
+ *   - digitalRead_mod(pin)
+ *   - pwm_status(pin)
+ *   - printPinPWM(pin)
+ *   - printPinPort(pin)
+ *   - printPinNumber(pin)
+ *   - printPinAnalog(pin)
  */
 
 #define NUMBER_PINS_TOTAL NUM_DIGITAL_PINS
-#define IS_ANALOG(P) (DIGITAL_PIN_TO_ANALOG_PIN(P) >= 0 ? 1 : 0)
-#define digitalRead_mod(p) extDigitalRead(p)
-#define GET_ARRAY_PIN(p) pin_array[p].pin
-#define PRINT_ARRAY_NAME(x) do{ sprintf_P(buffer, PSTR("%-" STRINGIFY(MAX_NAME_LENGTH) "s"), pin_array[x].name); SERIAL_ECHO(buffer); }while(0)
-#define PRINT_PIN(p) do{ sprintf_P(buffer, PSTR("P%d_%02d"), LPC176x::pin_port(p), LPC176x::pin_bit(p)); SERIAL_ECHO(buffer); }while(0)
-#define PRINT_PIN_ANALOG(p) do{ sprintf_P(buffer, PSTR("_A%d     "), LPC176x::pin_get_adc_channel(pin)); SERIAL_ECHO(buffer); }while(0)
+#define isAnalogPin(P) (digitalPinToAnalogIndex(P) >= 0)
+#define digitalRead_mod(P) extDigitalRead(P)
+#define getPinByIndex(x) pin_array[x].pin
+#define printPinNameByIndex(x) do{ sprintf_P(buffer, PSTR("%-" STRINGIFY(MAX_NAME_LENGTH) "s"), pin_array[x].name); SERIAL_ECHO(buffer); }while(0)
+#define printPinNumber(P) do{ sprintf_P(buffer, PSTR("P%d_%02d"), LPC176x::pin_port(P), LPC176x::pin_bit(P)); SERIAL_ECHO(buffer); }while(0)
+#define printPinAnalog(P) do{ sprintf_P(buffer, PSTR("_A%d     "), LPC176x::pin_get_adc_channel(P)); SERIAL_ECHO(buffer); }while(0)
 #define MULTI_NAME_PAD 17 // space needed to be pretty if not first name assigned to a pin
 
 // pins that will cause hang/reset/disconnect in M43 Toggle and Watch utilities
@@ -42,15 +55,15 @@
   #define M43_NEVER_TOUCH(Q) ((Q) == P0_29 || (Q) == P0_30 || (Q) == P2_09)  // USB pins
 #endif
 
-bool GET_PINMODE(const pin_t pin) {
+bool getValidPinMode(const pin_t pin) {
   if (!LPC176x::pin_is_valid(pin) || LPC176x::pin_adc_enabled(pin)) // Invalid pin or active analog pin
     return false;
 
   return LPC176x::gpio_direction(pin);
 }
 
-#define GET_ARRAY_IS_DIGITAL(x) ((bool) pin_array[x].is_digital)
+#define getPinIsDigitalByIndex(x) ((bool) pin_array[x].is_digital)
 
-void print_port(const pin_t) {}
-void pwm_details(const pin_t) {}
+void printPinPort(const pin_t) {}
+void printPinPWM(const pin_t) {}
 bool pwm_status(const pin_t) { return false; }

Marlin/src/HAL/LPC1768/spi_pins.h

@@ -28,12 +28,13 @@
                         // spiBeginTransaction.
 #endif
 
-/** onboard SD card */
-//#define SD_SCK_PIN        P0_07
-//#define SD_MISO_PIN       P0_08
-//#define SD_MOSI_PIN       P0_09
-//#define SD_SS_PIN         P0_06
-/** external */
+// Onboard SD
+//#define SD_SCK_PIN     P0_07
+//#define SD_MISO_PIN    P0_08
+//#define SD_MOSI_PIN    P0_09
+//#define SD_SS_PIN      P0_06
+
+// External SD
 #ifndef SD_SCK_PIN
   #define SD_SCK_PIN        P0_15
 #endif

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

@@ -132,7 +132,7 @@ uint8_t swSpiTransfer_mode_3(uint8_t b, const uint8_t spi_speed, const pin_t sck
 static uint8_t SPI_speed = 0;
 
 static void u8g_sw_spi_shift_out(uint8_t dataPin, uint8_t clockPin, uint8_t val) {
-  #if ANY(FYSETC_MINI_12864, MKS_MINI_12864)
+  #if U8G_SPI_USE_MODE_3
     swSpiTransfer_mode_3(val, SPI_speed, clockPin, -1, dataPin);
   #else
     swSpiTransfer_mode_0(val, SPI_speed, clockPin, -1, dataPin);
@@ -160,15 +160,15 @@ uint8_t u8g_com_HAL_LPC1768_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val,
       break;
 
     case U8G_COM_MSG_CHIP_SELECT:
-      #if ANY(FYSETC_MINI_12864, MKS_MINI_12864)  // LCD SPI is running mode 3 while SD card is running mode 0
-        if (arg_val) {                            //   SCK idle state needs to be set to the proper idle state before
-                                                  //   the next chip select goes active
-          u8g_SetPILevel(u8g, U8G_PI_SCK, 1);     // Set SCK to mode 3 idle state before CS goes active
+      #if U8G_SPI_USE_MODE_3                    // LCD SPI is running mode 3 while SD card is running mode 0
+        if (arg_val) {                          // SCK idle state needs to be set to the proper idle state before
+                                                //  the next chip select goes active
+          u8g_SetPILevel(u8g, U8G_PI_SCK, 1);   // Set SCK to mode 3 idle state before CS goes active
           u8g_SetPILevel(u8g, U8G_PI_CS, LOW);
         }
         else {
           u8g_SetPILevel(u8g, U8G_PI_CS, HIGH);
-          u8g_SetPILevel(u8g, U8G_PI_SCK, 0);  // Set SCK to mode 0 idle state after CS goes inactive
+          u8g_SetPILevel(u8g, U8G_PI_SCK, 0);   // Set SCK to mode 0 idle state after CS goes inactive
         }
       #else
         u8g_SetPILevel(u8g, U8G_PI_CS, !arg_val);

Marlin/src/HAL/LPC1768/upload_extra_script.py

@@ -13,9 +13,9 @@ if pioutil.is_pio_build():
     target_drive = "REARM"
 
     import platform
-
     current_OS = platform.system()
-    Import("env")
+
+    env = pioutil.env
 
     def print_error(e):
         print('\nUnable to find destination disk (%s)\n' \

Marlin/src/HAL/NATIVE_SIM/HAL.h

@@ -87,11 +87,11 @@ extern MSerialT serial_stream_3;
   #endif
 #endif
 
-#ifdef MMU2_SERIAL_PORT
-  #if WITHIN(MMU2_SERIAL_PORT, 0, 3)
-    #define MMU2_SERIAL MSERIAL(MMU2_SERIAL_PORT)
+#ifdef MMU_SERIAL_PORT
+  #if WITHIN(MMU_SERIAL_PORT, 0, 3)
+    #define MMU_SERIAL MSERIAL(MMU_SERIAL_PORT)
   #else
-    #error "MMU2_SERIAL_PORT must be from 0 to 3. Please update your configuration."
+    #error "MMU_SERIAL_PORT must be from 0 to 3. Please update your configuration."
   #endif
 #endif
 

Marlin/src/HAL/NATIVE_SIM/pinsDebug.cpp

@@ -25,11 +25,11 @@
 #include "../../inc/MarlinConfig.h"
 #include "pinsDebug.h"
 
-int8_t ADC_pin_mode(pin_t pin) { return -1; }
+int8_t ADC_pin_mode(const pin_t) { return -1; }
 
-int8_t get_pin_mode(const pin_t pin) { return VALID_PIN(pin) ? 0 : -1; }
+int8_t get_pin_mode(const pin_t pin) { return isValidPin(pin) ? 0 : -1; }
 
-bool GET_PINMODE(const pin_t pin) {
+bool getValidPinMode(const pin_t pin) {
   const int8_t pin_mode = get_pin_mode(pin);
   if (pin_mode == -1 || pin_mode == ADC_pin_mode(pin)) // Invalid pin or active analog pin
     return false;
@@ -37,12 +37,13 @@ bool GET_PINMODE(const pin_t pin) {
   return (Gpio::getMode(pin) != 0); // Input/output state
 }
 
-bool GET_ARRAY_IS_DIGITAL(const pin_t pin) {
-  return !IS_ANALOG(pin) || get_pin_mode(pin) != ADC_pin_mode(pin);
+// The pin and index are the same on this platform
+bool getPinIsDigitalByIndex(const pin_t pin) {
+  return !isAnalogPin(pin) || get_pin_mode(pin) != ADC_pin_mode(pin);
 }
 
-void print_port(const pin_t) {}
-void pwm_details(const pin_t) {}
+void printPinPort(const pin_t) {}
+void printPinPWM(const pin_t) {}
 bool pwm_status(const pin_t) { return false; }
 
 #endif

Marlin/src/HAL/NATIVE_SIM/pinsDebug.h

@@ -19,30 +19,43 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
-
-/**
- * Support routines for X86_64
- */
 #pragma once
 
 /**
- * Translation of routines & variables used by pinsDebug.h
+ * Pins Debugging for x86_64
+ *
+ *   - NUMBER_PINS_TOTAL
+ *   - MULTI_NAME_PAD
+ *   - getPinByIndex(index)
+ *   - printPinNameByIndex(index)
+ *   - getPinIsDigitalByIndex(index)
+ *   - digitalPinToAnalogIndex(pin)
+ *   - getValidPinMode(pin)
+ *   - isValidPin(pin)
+ *   - isAnalogPin(pin)
+ *   - digitalRead_mod(pin)
+ *   - pwm_status(pin)
+ *   - printPinPWM(pin)
+ *   - printPinPort(pin)
+ *   - printPinNumber(pin)
+ *   - printPinAnalog(pin)
  */
 
 #define NUMBER_PINS_TOTAL NUM_DIGITAL_PINS
-#define IS_ANALOG(P) (DIGITAL_PIN_TO_ANALOG_PIN(P) >= 0 ? 1 : 0)
-#define digitalRead_mod(p)  digitalRead(p)
-#define GET_ARRAY_PIN(p) pin_array[p].pin
-#define PRINT_ARRAY_NAME(x) do{ sprintf_P(buffer, PSTR("%-" STRINGIFY(MAX_NAME_LENGTH) "s"), pin_array[x].name); SERIAL_ECHO(buffer); }while(0)
-#define PRINT_PIN(p) do{ sprintf_P(buffer, PSTR("%3d "), p); SERIAL_ECHO(buffer); }while(0)
-#define PRINT_PIN_ANALOG(p) do{ sprintf_P(buffer, PSTR(" (A%2d)  "), DIGITAL_PIN_TO_ANALOG_PIN(pin)); SERIAL_ECHO(buffer); }while(0)
+#define isValidPin(P) (P >= 0 && P < pin_t(NUMBER_PINS_TOTAL))
+#define isAnalogPin(P) (digitalPinToAnalogIndex(P) >= 0)
+#define digitalRead_mod(P)  digitalRead(P)
+#define getPinByIndex(x) pin_array[x].pin
+#define printPinNameByIndex(x) do{ sprintf_P(buffer, PSTR("%-" STRINGIFY(MAX_NAME_LENGTH) "s"), pin_array[x].name); SERIAL_ECHO(buffer); }while(0)
+#define printPinNumber(P) do{ sprintf_P(buffer, PSTR("%3d "), P); SERIAL_ECHO(buffer); }while(0)
+#define printPinAnalog(P) do{ sprintf_P(buffer, PSTR(" (A%2d)  "), digitalPinToAnalogIndex(P)); SERIAL_ECHO(buffer); }while(0)
 #define MULTI_NAME_PAD 16 // space needed to be pretty if not first name assigned to a pin
 
 // Active ADC function/mode/code values for PINSEL registers
-int8_t ADC_pin_mode(pin_t pin);
-int8_t get_pin_mode(const pin_t pin);
-bool GET_PINMODE(const pin_t pin);
-bool GET_ARRAY_IS_DIGITAL(const pin_t pin);
-void print_port(const pin_t);
-void pwm_details(const pin_t);
+int8_t ADC_pin_mode(const pin_t);
+int8_t get_pin_mode(const pin_t);
+bool getValidPinMode(const pin_t);
+bool getPinIsDigitalByIndex(const pin_t);
+void printPinPort(const pin_t);
+void printPinPWM(const pin_t);
 bool pwm_status(const pin_t);

Marlin/src/HAL/NATIVE_SIM/u8g/u8g_com_sw_spi.cpp

@@ -131,7 +131,7 @@ static uint8_t swSpiInit(const uint8_t spi_speed, const uint8_t clk_pin, const u
 }
 
 static void u8g_sw_spi_shift_out(uint8_t dataPin, uint8_t clockPin, uint8_t val) {
-  #if ANY(FYSETC_MINI_12864, MKS_MINI_12864)
+  #if U8G_SPI_USE_MODE_3
     swSpiTransfer_mode_3(val, SPI_speed, clockPin, -1, dataPin);
   #else
     swSpiTransfer_mode_0(val, SPI_speed, clockPin, -1, dataPin);
@@ -159,15 +159,15 @@ uint8_t u8g_com_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_pt
       break;
 
     case U8G_COM_MSG_CHIP_SELECT:
-      #if ANY(FYSETC_MINI_12864, MKS_MINI_12864)  // LCD SPI is running mode 3 while SD card is running mode 0
-        if (arg_val) {                            //   SCK idle state needs to be set to the proper idle state before
-                                                  //   the next chip select goes active
-          u8g_SetPILevel(u8g, U8G_PI_SCK, 1);     // Set SCK to mode 3 idle state before CS goes active
+      #if U8G_SPI_USE_MODE_3                    // LCD SPI is running mode 3 while SD card is running mode 0
+        if (arg_val) {                          // SCK idle state needs to be set to the proper idle state before
+                                                //  the next chip select goes active
+          u8g_SetPILevel(u8g, U8G_PI_SCK, 1);   // Set SCK to mode 3 idle state before CS goes active
           u8g_SetPILevel(u8g, U8G_PI_CS, LOW);
         }
         else {
           u8g_SetPILevel(u8g, U8G_PI_CS, HIGH);
-          u8g_SetPILevel(u8g, U8G_PI_SCK, 0);  // Set SCK to mode 0 idle state after CS goes inactive
+          u8g_SetPILevel(u8g, U8G_PI_SCK, 0);   // Set SCK to mode 0 idle state after CS goes inactive
         }
       #else
         u8g_SetPILevel(u8g, U8G_PI_CS, !arg_val);

Marlin/src/HAL/RP2040/HAL.cpp

@@ -0,0 +1,188 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2024 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 "../platforms.h"
+
+#ifdef __PLAT_RP2040__
+
+#include "HAL.h"
+//#include "usb_serial.h"
+
+#include "../../inc/MarlinConfig.h"
+#include "../shared/Delay.h"
+
+extern "C" {
+  #include "pico/bootrom.h"
+  #include "hardware/watchdog.h"
+}
+
+#if HAS_SD_HOST_DRIVE
+  #include "msc_sd.h"
+  #include "usbd_cdc_if.h"
+#endif
+
+// ------------------------
+// Public Variables
+// ------------------------
+
+volatile uint16_t adc_result;
+
+// ------------------------
+// Public functions
+// ------------------------
+
+TERN_(POSTMORTEM_DEBUGGING, extern void install_min_serial());
+
+// HAL initialization task
+void MarlinHAL::init() {
+  // Ensure F_CPU is a constant expression.
+  // If the compiler breaks here, it means that delay code that should compute at compile time will not work.
+  // So better safe than sorry here.
+  constexpr int cpuFreq = F_CPU;
+  UNUSED(cpuFreq);
+
+  #undef SDSS
+  #define SDSS 2
+  #define PIN_EXISTS_(P1,P2) (defined(P1##P2) && P1##P2 >= 0)
+  #if HAS_MEDIA && DISABLED(SDIO_SUPPORT) && PIN_EXISTS_(SDSS,)
+    OUT_WRITE(SDSS, HIGH); // Try to set SDSS inactive before any other SPI users start up
+  #endif
+
+  #if PIN_EXISTS(LED)
+    OUT_WRITE(LED_PIN, LOW);
+  #endif
+
+  #if ENABLED(SRAM_EEPROM_EMULATION)
+    // __HAL_RCC_PWR_CLK_ENABLE();
+    // HAL_PWR_EnableBkUpAccess();           // Enable access to backup SRAM
+    // __HAL_RCC_BKPSRAM_CLK_ENABLE();
+    // LL_PWR_EnableBkUpRegulator();         // Enable backup regulator
+    // while (!LL_PWR_IsActiveFlag_BRR());   // Wait until backup regulator is initialized
+  #endif
+
+  HAL_timer_init();
+
+  #if ENABLED(EMERGENCY_PARSER) && USBD_USE_CDC
+    USB_Hook_init();
+  #endif
+
+  TERN_(POSTMORTEM_DEBUGGING, install_min_serial());    // Install the min serial handler
+
+  TERN_(HAS_SD_HOST_DRIVE, MSC_SD_init());              // Enable USB SD card access
+
+  #if PIN_EXISTS(USB_CONNECT)
+    OUT_WRITE(USB_CONNECT_PIN, !USB_CONNECT_INVERTING); // USB clear connection
+    delay_ms(1000);                                        // Give OS time to notice
+    WRITE(USB_CONNECT_PIN, USB_CONNECT_INVERTING);
+  #endif
+}
+
+uint8_t MarlinHAL::get_reset_source() {
+  return watchdog_enable_caused_reboot() ? RST_WATCHDOG : 0;
+}
+
+void MarlinHAL::reboot() { watchdog_reboot(0, 0, 1); }
+
+// ------------------------
+// Watchdog Timer
+// ------------------------
+
+#if ENABLED(USE_WATCHDOG)
+
+  #define WDT_TIMEOUT_US TERN(WATCHDOG_DURATION_8S, 8000000, 4000000) // 4 or 8 second timeout
+
+  extern "C" {
+    #include "hardware/watchdog.h"
+  }
+
+  void MarlinHAL::watchdog_init() {
+    #if DISABLED(DISABLE_WATCHDOG_INIT)
+      static_assert(WDT_TIMEOUT_US > 1000, "WDT Timout is too small, aborting");
+      watchdog_enable(WDT_TIMEOUT_US/1000, true);
+    #endif
+  }
+
+  void MarlinHAL::watchdog_refresh() {
+    watchdog_update();
+    #if DISABLED(PINS_DEBUGGING) && PIN_EXISTS(LED)
+      TOGGLE(LED_PIN);  // heartbeat indicator
+    #endif
+  }
+
+#endif
+
+// ------------------------
+// ADC
+// ------------------------
+
+volatile bool MarlinHAL::adc_has_result = false;
+
+void MarlinHAL::adc_init() {
+  analogReadResolution(HAL_ADC_RESOLUTION);
+  ::adc_init();
+  adc_fifo_setup(true, false, 1, false, false);
+  irq_set_exclusive_handler(ADC_IRQ_FIFO, adc_exclusive_handler);
+  irq_set_enabled(ADC_IRQ_FIFO, true);
+  adc_irq_set_enabled(true);
+}
+
+void MarlinHAL::adc_enable(const pin_t pin) {
+  if (pin >= A0 && pin <= A3)
+    adc_gpio_init(pin);
+  else if (pin == HAL_ADC_MCU_TEMP_DUMMY_PIN)
+    adc_set_temp_sensor_enabled(true);
+}
+
+void MarlinHAL::adc_start(const pin_t pin) {
+  adc_has_result = false;
+  // Select an ADC input. 0...3 are GPIOs 26...29 respectively.
+  adc_select_input(pin == HAL_ADC_MCU_TEMP_DUMMY_PIN ? 4 : pin - A0);
+  adc_run(true);
+}
+
+void MarlinHAL::adc_exclusive_handler() {
+  adc_run(false); // Disable since we only want one result
+  irq_clear(ADC_IRQ_FIFO); // Clear the IRQ
+
+  if (adc_fifo_get_level() >= 1) {
+    adc_result = adc_fifo_get(); // Pop the result
+    adc_fifo_drain();
+    adc_has_result = true; // Signal the end of the conversion
+  }
+}
+
+uint16_t MarlinHAL::adc_value() { return adc_result; }
+
+// Reset the system to initiate a firmware flash
+void flashFirmware(const int16_t) { hal.reboot(); }
+
+extern "C" {
+  void * _sbrk(int incr);
+  extern unsigned int __bss_end__; // end of bss section
+}
+
+// Return free memory between end of heap (or end bss) and whatever is current
+int freeMemory() {
+  int free_memory, heap_end = (int)_sbrk(0);
+  return (int)&free_memory - (heap_end ?: (int)&__bss_end__);
+}
+
+#endif // __PLAT_RP2040__

Marlin/src/HAL/RP2040/HAL.h

@@ -0,0 +1,250 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2024 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+#pragma once
+
+#define CPU_32_BIT
+
+#ifndef F_CPU
+  #define F_CPU (XOSC_MHZ * 1000000UL)
+#endif
+
+#include "arduino_extras.h"
+#include "../../core/macros.h"
+#include "../shared/Marduino.h"
+#include "../shared/math_32bit.h"
+#include "../shared/HAL_SPI.h"
+#include "fastio.h"
+//#include "Servo.h"
+#include "watchdog.h"
+#include "MarlinSerial.h"
+
+#include "../../inc/MarlinConfigPre.h"
+
+#include <stdint.h>
+
+// ------------------------
+// Serial ports
+// ------------------------
+
+#include "../../core/serial_hook.h"
+typedef ForwardSerial1Class< decltype(Serial) > DefaultSerial1;
+extern DefaultSerial1 MSerial0;
+
+#define _MSERIAL(X) MSerial##X
+#define MSERIAL(X) _MSERIAL(X)
+
+#if SERIAL_PORT == -1
+  #define MYSERIAL1 MSerial0
+#elif WITHIN(SERIAL_PORT, 0, 6)
+  #define MYSERIAL1 MSERIAL(SERIAL_PORT)
+#else
+  #error "SERIAL_PORT must be from 0 to 6. You can also use -1 if the board supports Native USB."
+#endif
+
+#ifdef SERIAL_PORT_2
+  #if SERIAL_PORT_2 == -1
+    #define MYSERIAL2 MSerial0
+  #elif WITHIN(SERIAL_PORT_2, 0, 6)
+    #define MYSERIAL2 MSERIAL(SERIAL_PORT_2)
+  #else
+    #error "SERIAL_PORT_2 must be from 0 to 6. You can also use -1 if the board supports Native USB."
+  #endif
+#endif
+
+#ifdef SERIAL_PORT_3
+  #if SERIAL_PORT_3 == -1
+    #define MYSERIAL3 MSerial0
+  #elif WITHIN(SERIAL_PORT_3, 0, 6)
+    #define MYSERIAL3 MSERIAL(SERIAL_PORT_3)
+  #else
+    #error "SERIAL_PORT_3 must be from 0 to 6. You can also use -1 if the board supports Native USB."
+  #endif
+#endif
+
+#ifdef MMU2_SERIAL_PORT
+  #if MMU2_SERIAL_PORT == -1
+    #define MMU2_SERIAL MSerial0
+  #elif WITHIN(MMU2_SERIAL_PORT, 0, 6)
+    #define MMU2_SERIAL MSERIAL(MMU2_SERIAL_PORT)
+  #else
+    #error "MMU2_SERIAL_PORT must be from 0 to 6. You can also use -1 if the board supports Native USB."
+  #endif
+#endif
+
+#ifdef LCD_SERIAL_PORT
+  #if LCD_SERIAL_PORT == -1
+    #define LCD_SERIAL MSerial0
+  #elif WITHIN(LCD_SERIAL_PORT, 0, 6)
+    #define LCD_SERIAL MSERIAL(LCD_SERIAL_PORT)
+  #else
+    #error "LCD_SERIAL_PORT must be from 0 to 6. You can also use -1 if the board supports Native USB."
+  #endif
+  #if HAS_DGUS_LCD
+    #define SERIAL_GET_TX_BUFFER_FREE() LCD_SERIAL.availableForWrite()
+  #endif
+#endif
+
+// ------------------------
+// Defines
+// ------------------------
+
+/**
+ * TODO: review this to return 1 for pins that are not analog input
+ */
+#ifndef analogInputToDigitalPin
+  #define analogInputToDigitalPin(p) (p)
+#endif
+
+#define CRITICAL_SECTION_START()  uint32_t primask = __get_PRIMASK(); __disable_irq()
+#define CRITICAL_SECTION_END()    if (!primask) __enable_irq()
+#define cli() __disable_irq()
+#define sei() __enable_irq()
+
+// ------------------------
+// Types
+// ------------------------
+
+template <bool, class L, class R> struct IFPIN { typedef R type; };
+template <class L, class R> struct IFPIN<true, L, R> { typedef L type; };
+typedef IFPIN<sizeof(pin_size_t) == 1, int8_t, int16_t>::type pin_t;
+
+class libServo;
+typedef libServo hal_servo_t;
+#define PAUSE_SERVO_OUTPUT() libServo::pause_all_servos()
+#define RESUME_SERVO_OUTPUT() libServo::resume_all_servos()
+
+// ------------------------
+// ADC
+// ------------------------
+
+#define HAL_ADC_VREF         3.3
+#ifdef ADC_RESOLUTION
+  #define HAL_ADC_RESOLUTION ADC_RESOLUTION
+#else
+  #define HAL_ADC_RESOLUTION 12
+#endif
+// ADC index 4 is the MCU temperature
+#define HAL_ADC_MCU_TEMP_DUMMY_PIN 127
+
+//
+// Pin Mapping for M42, M43, M226
+//
+#define GET_PIN_MAP_PIN(index) index
+#define GET_PIN_MAP_INDEX(pin) pin
+#define PARSED_PIN_INDEX(code, dval) parser.intval(code, dval)
+
+#ifndef PLATFORM_M997_SUPPORT
+  #define PLATFORM_M997_SUPPORT
+#endif
+void flashFirmware(const int16_t);
+
+// Maple Compatibility
+typedef void (*systickCallback_t)(void);
+void systick_attach_callback(systickCallback_t cb);
+void HAL_SYSTICK_Callback();
+
+extern volatile uint32_t systick_uptime_millis;
+
+#define HAL_CAN_SET_PWM_FREQ   // This HAL supports PWM Frequency adjustment
+#define PWM_FREQUENCY 1000     // Default PWM frequency when set_pwm_duty() is called without set_pwm_frequency()
+
+// ------------------------
+// Class Utilities
+// ------------------------
+
+int freeMemory();
+
+// ------------------------
+// MarlinHAL Class
+// ------------------------
+
+class MarlinHAL {
+public:
+
+  // Earliest possible init, before setup()
+  MarlinHAL() {}
+
+  // Watchdog
+  static void watchdog_init()    IF_DISABLED(USE_WATCHDOG, {});
+  static void watchdog_refresh() IF_DISABLED(USE_WATCHDOG, {});
+
+  static void init();          // Called early in setup()
+  static void init_board() {}  // Called less early in setup()
+  static void reboot();        // Restart the firmware from 0x0
+
+  // Interrupts
+  static bool isr_state() { return !__get_PRIMASK(); }
+  static void isr_on()  { __enable_irq(); }
+  static void isr_off() { __disable_irq(); }
+
+  static void delay_ms(const int ms) { ::delay(ms); }
+
+  // Tasks, called from idle()
+  static void idletask() {}
+
+  // Reset
+  static uint8_t get_reset_source();
+  static void clear_reset_source() {}
+
+  // Free SRAM
+  static int freeMemory() { return ::freeMemory(); }
+
+  //
+  // ADC Methods
+  //
+
+  // Called by Temperature::init once at startup
+  static void adc_init();
+
+  // Called by Temperature::init for each sensor at startup
+  static void adc_enable(const pin_t pin);
+
+  // Begin ADC sampling on the given pin. Called from Temperature::isr!
+  static void adc_start(const pin_t pin);
+
+  // This ADC runs a periodic task
+  static void adc_exclusive_handler();
+
+  // Is the ADC ready for reading?
+  static volatile bool adc_has_result;
+  static bool adc_ready() { return adc_has_result; }
+
+  // The current value of the ADC register
+  static uint16_t adc_value();
+
+  /**
+   * Set the PWM duty cycle for the pin to the given value.
+   * Optionally invert the duty cycle [default = false]
+   * Optionally change the scale of the provided value to enable finer PWM duty control [default = 255]
+   */
+  static void set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size=255, const bool invert=false);
+
+  /**
+   * Set the frequency of the timer for the given pin as close as
+   * possible to the provided desired frequency. Internally calculate
+   * the required waveform generation mode, prescaler, and resolution
+   * values and set timer registers accordingly.
+   * NOTE that the frequency is applied to all pins on the timer (Ex OC3A, OC3B and OC3B)
+   * NOTE that there are limitations, particularly if using TIMER2. (see Configuration_adv.h -> FAST_PWM_FAN Settings)
+   */
+  static void set_pwm_frequency(const pin_t pin, const uint16_t f_desired);
+};

Marlin/src/HAL/RP2040/HAL_MinSerial.cpp

@@ -0,0 +1,69 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2024 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 "../platforms.h"
+
+#ifdef __PLAT_RP2040__
+
+#include "../../inc/MarlinConfigPre.h"
+
+#if ENABLED(POSTMORTEM_DEBUGGING)
+
+#include "../shared/HAL_MinSerial.h"
+
+
+static void TXBegin() {
+  #if !WITHIN(SERIAL_PORT, -1, 2)
+    #warning "Using POSTMORTEM_DEBUGGING requires a physical U(S)ART hardware in case of severe error."
+    #warning "Disabling the severe error reporting feature currently because the used serial port is not a HW port."
+  #else
+    #if SERIAL_PORT == -1
+      USBSerial.begin(BAUDRATE);
+    #elif SERIAL_PORT == 0
+      USBSerial.begin(BAUDRATE);
+    #elif SERIAL_PORT == 1
+      Serial1.begin(BAUDRATE);
+    #endif
+  #endif
+}
+
+static void TX(char b){
+    #if SERIAL_PORT == -1
+      USBSerial
+    #elif SERIAL_PORT == 0
+      USBSerial
+    #elif SERIAL_PORT == 1
+      Serial1
+    #endif
+    .write(b);
+}
+
+// A SW memory barrier, to ensure GCC does not overoptimize loops
+#define sw_barrier() __asm__ volatile("": : :"memory");
+
+
+void install_min_serial() {
+  HAL_min_serial_init = &TXBegin;
+  HAL_min_serial_out = &TX;
+}
+
+#endif // POSTMORTEM_DEBUGGING
+#endif // __PLAT_RP2040__

Marlin/src/HAL/RP2040/HAL_SPI.cpp

@@ -0,0 +1,228 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2024 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 "../platforms.h"
+
+#ifdef __PLAT_RP2040__
+
+#include "../../inc/MarlinConfig.h"
+
+#include <SPI.h>
+
+// ------------------------
+// Public Variables
+// ------------------------
+
+static SPISettings spiConfig;
+
+// ------------------------
+// Public functions
+// ------------------------
+
+#if ENABLED(SOFTWARE_SPI)
+
+  // ------------------------
+  // Software SPI
+  // ------------------------
+
+  #include "../shared/Delay.h"
+
+  void spiBegin(void) {
+    OUT_WRITE(SD_SS_PIN, HIGH);
+    OUT_WRITE(SD_SCK_PIN, HIGH);
+    SET_INPUT(SD_MISO_PIN);
+    OUT_WRITE(SD_MOSI_PIN, HIGH);
+  }
+
+  // Use function with compile-time value so we can actually reach the desired frequency
+  // Need to adjust this a little bit: on a 72MHz clock, we have 14ns/clock
+  // and we'll use ~3 cycles to jump to the method and going back, so it'll take ~40ns from the given clock here
+  #define CALLING_COST_NS  (3U * 1000000000U) / (F_CPU)
+  void (*delaySPIFunc)();
+  void delaySPI_125()  { DELAY_NS(125 - CALLING_COST_NS); }
+  void delaySPI_250()  { DELAY_NS(250 - CALLING_COST_NS); }
+  void delaySPI_500()  { DELAY_NS(500 - CALLING_COST_NS); }
+  void delaySPI_1000() { DELAY_NS(1000 - CALLING_COST_NS); }
+  void delaySPI_2000() { DELAY_NS(2000 - CALLING_COST_NS); }
+  void delaySPI_4000() { DELAY_NS(4000 - CALLING_COST_NS); }
+
+  void spiInit(uint8_t spiRate) {
+    // Use datarates Marlin uses
+    switch (spiRate) {
+      case SPI_FULL_SPEED:   delaySPIFunc =  &delaySPI_125; break;  // desired: 8,000,000  actual: ~1.1M
+      case SPI_HALF_SPEED:   delaySPIFunc =  &delaySPI_125; break;  // desired: 4,000,000  actual: ~1.1M
+      case SPI_QUARTER_SPEED:delaySPIFunc =  &delaySPI_250; break;  // desired: 2,000,000  actual: ~890K
+      case SPI_EIGHTH_SPEED: delaySPIFunc =  &delaySPI_500; break;  // desired: 1,000,000  actual: ~590K
+      case SPI_SPEED_5:      delaySPIFunc = &delaySPI_1000; break;  // desired:   500,000  actual: ~360K
+      case SPI_SPEED_6:      delaySPIFunc = &delaySPI_2000; break;  // desired:   250,000  actual: ~210K
+      default:               delaySPIFunc = &delaySPI_4000; break;  // desired:   125,000  actual: ~123K
+    }
+    SPI.begin();
+  }
+
+  // Begin SPI transaction, set clock, bit order, data mode
+  void spiBeginTransaction(uint32_t spiClock, uint8_t bitOrder, uint8_t dataMode) { /* do nothing */ }
+
+  uint8_t HAL_SPI_RP2040_SpiTransfer_Mode_3(uint8_t b) { // using Mode 3
+    for (uint8_t bits = 8; bits--;) {
+      WRITE(SD_SCK_PIN, LOW);
+      WRITE(SD_MOSI_PIN, b & 0x80);
+
+      delaySPIFunc();
+      WRITE(SD_SCK_PIN, HIGH);
+      delaySPIFunc();
+
+      b <<= 1;        // little setup time
+      b |= (READ(SD_MISO_PIN) != 0);
+    }
+    DELAY_NS(125);
+    return b;
+  }
+
+  // Soft SPI receive byte
+  uint8_t spiRec() {
+    hal.isr_off();  // No interrupts during byte receive
+    const uint8_t data = HAL_SPI_RP2040_SpiTransfer_Mode_3(0xFF);
+    hal.isr_on();   // Enable interrupts
+    return data;
+  }
+
+  // Soft SPI read data
+  void spiRead(uint8_t *buf, uint16_t nbyte) {
+    for (uint16_t i = 0; i < nbyte; i++)
+      buf[i] = spiRec();
+  }
+
+  // Soft SPI send byte
+  void spiSend(uint8_t data) {
+    hal.isr_off();                            // No interrupts during byte send
+    HAL_SPI_RP2040_SpiTransfer_Mode_3(data);  // Don't care what is received
+    hal.isr_on();                             // Enable interrupts
+  }
+
+  // Soft SPI send block
+  void spiSendBlock(uint8_t token, const uint8_t *buf) {
+    spiSend(token);
+    for (uint16_t i = 0; i < 512; i++)
+      spiSend(buf[i]);
+  }
+
+#else
+
+  // ------------------------
+  // Hardware SPI
+  // ------------------------
+
+  /**
+   * VGPV SPI speed start and PCLK2/2, by default 108/2 = 54Mhz
+   */
+
+  /**
+   * @brief  Begin SPI port setup
+   *
+   * @return Nothing
+   *
+   * @details Only configures SS pin since stm32duino creates and initialize the SPI object
+   */
+  void spiBegin() {
+    #if PIN_EXISTS(SD_SS)
+      OUT_WRITE(SD_SS_PIN, HIGH);
+    #endif
+  }
+
+  // Configure SPI for specified SPI speed
+  void spiInit(uint8_t spiRate) {
+    // Use datarates Marlin uses
+    uint32_t clock;
+    switch (spiRate) {
+      case SPI_FULL_SPEED:    clock = 20000000; break; // 13.9mhz=20000000  6.75mhz=10000000  3.38mhz=5000000  .833mhz=1000000
+      case SPI_HALF_SPEED:    clock =  5000000; break;
+      case SPI_QUARTER_SPEED: clock =  2500000; break;
+      case SPI_EIGHTH_SPEED:  clock =  1250000; break;
+      case SPI_SPEED_5:       clock =   625000; break;
+      case SPI_SPEED_6:       clock =   300000; break;
+      default:
+        clock = 4000000; // Default from the SPI library
+    }
+    spiConfig = SPISettings(clock, MSBFIRST, SPI_MODE0);
+
+    //SPI.setMISO(SD_MISO_PIN); //todo: implement? bad interface
+    //SPI.setMOSI(SD_MOSI_PIN);
+    //SPI.setSCLK(SD_SCK_PIN);
+
+    SPI.begin();
+  }
+
+  /**
+   * @brief  Receives a single byte from the SPI port.
+   *
+   * @return Byte received
+   *
+   * @details
+   */
+  uint8_t spiRec() {
+    uint8_t returnByte = SPI.transfer(0xFF);
+    return returnByte;
+  }
+
+  /**
+   * @brief  Receive a number of bytes from the SPI port to a buffer
+   *
+   * @param  buf   Pointer to starting address of buffer to write to.
+   * @param  nbyte Number of bytes to receive.
+   * @return Nothing
+   *
+   * @details Uses DMA
+   */
+  void spiRead(uint8_t *buf, uint16_t nbyte) {
+    if (nbyte == 0) return;
+    memset(buf, 0xFF, nbyte);
+    SPI.transfer(buf, nbyte);
+  }
+
+  /**
+   * @brief  Send a single byte on SPI port
+   *
+   * @param  b Byte to send
+   *
+   * @details
+   */
+  void spiSend(uint8_t b) {
+    SPI.transfer(b);
+  }
+
+  /**
+   * @brief  Write token and then write from 512 byte buffer to SPI (for SD card)
+   *
+   * @param  buf   Pointer with buffer start address
+   * @return Nothing
+   *
+   * @details Use DMA
+   */
+  void spiSendBlock(uint8_t token, const uint8_t *buf) {
+    //uint8_t rxBuf[512];
+    //SPI.transfer(token);
+    SPI.transfer((uint8_t*)buf, 512); //implement? bad interface
+  }
+
+#endif // SOFTWARE_SPI
+
+#endif // __PLAT_RP2040__

Marlin/src/HAL/RP2040/MarlinSerial.cpp

@@ -0,0 +1,39 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2024 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 "../platforms.h"
+
+#ifdef __PLAT_RP2040__
+
+#include "../../inc/MarlinConfig.h"
+#include "MarlinSerial.h"
+
+#if ENABLED(EMERGENCY_PARSER)
+  #include "../../feature/e_parser.h"
+#endif
+
+#define _IMPLEMENT_SERIAL(X) DefaultSerial##X MSerial##X(false, Serial##X)
+#define IMPLEMENT_SERIAL(X)  _IMPLEMENT_SERIAL(X)
+#if WITHIN(SERIAL_PORT, 0, 3)
+  IMPLEMENT_SERIAL(SERIAL_PORT);
+#endif
+
+#endif // __PLAT_RP2040__

Marlin/src/HAL/RP2040/MarlinSerial.h

@@ -0,0 +1,52 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2024 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/MarlinConfigPre.h"
+
+#if ENABLED(EMERGENCY_PARSER)
+  #include "../../feature/e_parser.h"
+#endif
+
+#include "../../core/serial_hook.h"
+
+#define Serial0 Serial
+#define _DECLARE_SERIAL(X) \
+  typedef ForwardSerial1Class<decltype(Serial##X)> DefaultSerial##X; \
+  extern DefaultSerial##X MSerial##X
+#define DECLARE_SERIAL(X) _DECLARE_SERIAL(X)
+
+typedef ForwardSerial1Class<decltype(SerialUSB)> USBSerialType;
+extern USBSerialType USBSerial;
+
+#define _MSERIAL(X) MSerial##X
+#define MSERIAL(X) _MSERIAL(X)
+
+#if SERIAL_PORT == -1
+ // #define MYSERIAL1 USBSerial this is already done in the HAL
+#elif WITHIN(SERIAL_PORT, 0, 3)
+ #define MYSERIAL1 MSERIAL(SERIAL_PORT)
+  DECLARE_SERIAL(SERIAL_PORT);
+#else
+  #error "SERIAL_PORT must be from 0 to 3, or -1 for Native USB."
+#endif
+

Marlin/src/HAL/RP2040/README.md

@@ -0,0 +1 @@
+# RP2040 Hardware Interface

Marlin/src/HAL/RP2040/Servo.cpp

@@ -0,0 +1,93 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2024 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 "../platforms.h"
+
+#ifdef __PLAT_RP2040__
+
+#include "../../inc/MarlinConfig.h"
+
+#if HAS_SERVOS
+
+#include "Servo.h"
+
+static uint_fast8_t servoCount = 0;
+static libServo *servos[NUM_SERVOS] = {0};
+constexpr millis_t servoDelay[] = SERVO_DELAY;
+static_assert(COUNT(servoDelay) == NUM_SERVOS, "SERVO_DELAY must be an array NUM_SERVOS long.");
+
+libServo::libServo()
+: delay(servoDelay[servoCount]),
+  was_attached_before_pause(false),
+  value_before_pause(0)
+{
+  servos[servoCount++] = this;
+}
+
+int8_t libServo::attach(const int pin) {
+  if (servoCount >= MAX_SERVOS) return -1;
+  if (pin > 0) servo_pin = pin;
+  auto result = pico_servo.attach(servo_pin);
+  return result;
+}
+
+int8_t libServo::attach(const int pin, const int min, const int max) {
+  if (servoCount >= MAX_SERVOS) return -1;
+  if (pin > 0) servo_pin = pin;
+  auto result = pico_servo.attach(servo_pin, min, max);
+  return result;
+}
+
+void libServo::move(const int value) {
+  if (attach(0) >= 0) {
+    pico_servo.write(value);
+    safe_delay(delay);
+    TERN_(DEACTIVATE_SERVOS_AFTER_MOVE, detach());
+  }
+}
+
+void libServo::pause() {
+  was_attached_before_pause = pico_servo.attached();
+  if (was_attached_before_pause) {
+    value_before_pause = pico_servo.read();
+    pico_servo.detach();
+  }
+}
+
+void libServo::resume() {
+  if (was_attached_before_pause) {
+    attach();
+    move(value_before_pause);
+  }
+}
+
+void libServo::pause_all_servos() {
+  for (auto& servo : servos)
+    if (servo) servo->pause();
+}
+
+void libServo::resume_all_servos() {
+  for (auto& servo : servos)
+    if (servo) servo->resume();
+}
+
+#endif // HAS_SERVOS
+#endif // __PLAT_RP2040__

Marlin/src/HAL/RP2040/Servo.h

@@ -0,0 +1,77 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2024 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 <Servo.h>
+
+#if 1
+
+#include "../../core/millis_t.h"
+
+// Inherit and expand on the official library
+class libServo {
+  public:
+    libServo();
+    int8_t attach(const int pin = 0); // pin == 0 uses value from previous call
+    int8_t attach(const int pin, const int min, const int max);
+    void detach() { pico_servo.detach(); }
+    int read() { return pico_servo.read(); }
+    void move(const int value);
+
+    void pause();
+    void resume();
+
+    static void pause_all_servos();
+    static void resume_all_servos();
+    static void setInterruptPriority(uint32_t preemptPriority, uint32_t subPriority);
+
+  private:
+    Servo pico_servo;
+
+    int servo_pin = 0;
+    millis_t delay = 0;
+
+    bool was_attached_before_pause;
+    int value_before_pause;
+};
+
+#else
+
+class libServo: public Servo {
+  public:
+  void move(const int value) {
+    constexpr uint16_t servo_delay[] = SERVO_DELAY;
+    static_assert(COUNT(servo_delay) == NUM_SERVOS, "SERVO_DELAY must be an array NUM_SERVOS long.");
+
+    if (attach(servo_info[servoIndex].Pin.nbr) >= 0) {    // try to reattach
+      write(value);
+      safe_delay(servo_delay[servoIndex]); // delay to allow servo to reach position
+      TERN_(DEACTIVATE_SERVOS_AFTER_MOVE, detach());
+    }
+
+  }
+};
+
+class libServo;
+typedef libServo hal_servo_t;
+
+#endif

Marlin/src/HAL/RP2040/arduino_extras.cpp

@@ -0,0 +1,33 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2024 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+#ifdef __PLAT_RP2040__
+
+#include <iostream>
+
+char *dtostrf(double __val, signed char __width, unsigned char __prec, char *__s) {
+  char format_string[20];
+  snprintf(format_string, 20, "%%%d.%df", __width, __prec);
+  sprintf(__s, format_string, __val);
+  return __s;
+}
+
+#endif // __PLAT_RP2040__

Marlin/src/HAL/RP2040/arduino_extras.h

@@ -0,0 +1,29 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2024 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 <stddef.h>
+// #include <stdint.h>
+// #include <math.h>
+// #include <cstring>
+
+char *dtostrf(double __val, signed char __width, unsigned char __prec, char *__s);

Marlin/src/HAL/RP2040/eeprom_flash.cpp

@@ -0,0 +1,88 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2024 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 "../platforms.h"
+
+#ifdef __PLAT_RP2040__
+
+#include "../../inc/MarlinConfig.h"
+
+#if ENABLED(FLASH_EEPROM_EMULATION)
+
+#include "../shared/eeprom_api.h"
+
+// NOTE: The Bigtreetech SKR Pico has an onboard W25Q16 flash module
+
+// Use EEPROM.h for compatibility, for now.
+#include <EEPROM.h>
+
+static bool eeprom_data_written = false;
+
+#ifndef MARLIN_EEPROM_SIZE
+  #define MARLIN_EEPROM_SIZE size_t(E2END + 1)
+#endif
+size_t PersistentStore::capacity() { return MARLIN_EEPROM_SIZE; }
+
+bool PersistentStore::access_start() {
+  EEPROM.begin(); // Avoid EEPROM.h warning (do nothing)
+  eeprom_buffer_fill();
+  return true;
+}
+
+bool PersistentStore::access_finish() {
+  if (eeprom_data_written) {
+    TERN_(HAS_PAUSE_SERVO_OUTPUT, PAUSE_SERVO_OUTPUT());
+    hal.isr_off();
+    eeprom_buffer_flush();
+    hal.isr_on();
+    TERN_(HAS_PAUSE_SERVO_OUTPUT, RESUME_SERVO_OUTPUT());
+    eeprom_data_written = false;
+  }
+  return true;
+}
+
+bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
+  while (size--) {
+    uint8_t v = *value;
+    if (v != eeprom_buffered_read_byte(pos)) {
+      eeprom_buffered_write_byte(pos, v);
+      eeprom_data_written = true;
+    }
+    crc16(crc, &v, 1);
+    pos++;
+    value++;
+  }
+  return false;
+}
+
+bool PersistentStore::read_data(int &pos, uint8_t *value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
+  do {
+    const uint8_t c = eeprom_buffered_read_byte(pos);
+    if (writing) *value = c;
+    crc16(crc, &c, 1);
+    pos++;
+    value++;
+  } while (--size);
+  return false;
+}
+
+#endif // FLASH_EEPROM_EMULATION
+#endif // __PLAT_RP2040__

Marlin/src/HAL/RP2040/eeprom_wired.cpp

@@ -0,0 +1,79 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2024 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 "../platforms.h"
+
+#ifdef __PLAT_RP2040__
+
+#include "../../inc/MarlinConfig.h"
+
+#if USE_WIRED_EEPROM
+
+/**
+ * PersistentStore for Arduino-style EEPROM interface
+ * with simple implementations supplied by Marlin.
+ */
+
+#include "../shared/eeprom_if.h"
+#include "../shared/eeprom_api.h"
+
+#ifndef MARLIN_EEPROM_SIZE
+  #define MARLIN_EEPROM_SIZE size_t(E2END + 1)
+#endif
+size_t PersistentStore::capacity() { return MARLIN_EEPROM_SIZE; }
+
+bool PersistentStore::access_start()  { eeprom_init(); return true; }
+bool PersistentStore::access_finish() { return true; }
+
+bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
+  uint16_t written = 0;
+  while (size--) {
+    uint8_t v = *value;
+    uint8_t * const p = (uint8_t * const)pos;
+    if (v != eeprom_read_byte(p)) { // EEPROM has only ~100,000 write cycles, so only write bytes that have changed!
+      eeprom_write_byte(p, v);
+      if (++written & 0x7F) delay(2); else safe_delay(2); // Avoid triggering watchdog during long EEPROM writes
+      if (eeprom_read_byte(p) != v) {
+        SERIAL_ECHO_MSG(STR_ERR_EEPROM_WRITE);
+        return true;
+      }
+    }
+    crc16(crc, &v, 1);
+    pos++;
+    value++;
+  }
+  return false;
+}
+
+bool PersistentStore::read_data(int &pos, uint8_t *value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
+  do {
+    // Read from either external EEPROM, program flash or Backup SRAM
+    const uint8_t c = eeprom_read_byte((uint8_t*)pos);
+    if (writing) *value = c;
+    crc16(crc, &c, 1);
+    pos++;
+    value++;
+  } while (--size);
+  return false;
+}
+
+#endif // USE_WIRED_EEPROM
+#endif // __PLAT_RP2040__

Marlin/src/HAL/RP2040/endstop_interrupts.h

@@ -0,0 +1,60 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2024 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 "../../module/endstops.h"
+
+// One ISR for all EXT-Interrupts
+void endstop_ISR() { endstops.update(); }
+
+void setup_endstop_interrupts() {
+  #define _ATTACH(P) attachInterrupt(digitalPinToInterrupt(P), endstop_ISR, CHANGE)
+  TERN_(USE_X_MAX, _ATTACH(X_MAX_PIN));
+  TERN_(USE_X_MIN, _ATTACH(X_MIN_PIN));
+  TERN_(USE_Y_MAX, _ATTACH(Y_MAX_PIN));
+  TERN_(USE_Y_MIN, _ATTACH(Y_MIN_PIN));
+  TERN_(USE_Z_MAX, _ATTACH(Z_MAX_PIN));
+  TERN_(HAS_Z_MIN_PIN, _ATTACH(Z_MIN_PIN));
+  TERN_(USE_X2_MAX, _ATTACH(X2_MAX_PIN));
+  TERN_(USE_X2_MIN, _ATTACH(X2_MIN_PIN));
+  TERN_(USE_Y2_MAX, _ATTACH(Y2_MAX_PIN));
+  TERN_(USE_Y2_MIN, _ATTACH(Y2_MIN_PIN));
+  TERN_(USE_Z2_MAX, _ATTACH(Z2_MAX_PIN));
+  TERN_(USE_Z2_MIN, _ATTACH(Z2_MIN_PIN));
+  TERN_(USE_Z3_MAX, _ATTACH(Z3_MAX_PIN));
+  TERN_(USE_Z3_MIN, _ATTACH(Z3_MIN_PIN));
+  TERN_(USE_Z4_MAX, _ATTACH(Z4_MAX_PIN));
+  TERN_(USE_Z4_MIN, _ATTACH(Z4_MIN_PIN));
+  TERN_(USE_Z_MIN_PROBE_PIN, _ATTACH(Z_MIN_PROBE_PIN));
+  TERN_(USE_I_MAX, _ATTACH(I_MAX_PIN));
+  TERN_(USE_I_MIN, _ATTACH(I_MIN_PIN));
+  TERN_(USE_J_MAX, _ATTACH(J_MAX_PIN));
+  TERN_(USE_J_MIN, _ATTACH(J_MIN_PIN));
+  TERN_(USE_K_MAX, _ATTACH(K_MAX_PIN));
+  TERN_(USE_K_MIN, _ATTACH(K_MIN_PIN));
+  TERN_(USE_U_MAX, _ATTACH(U_MAX_PIN));
+  TERN_(USE_U_MIN, _ATTACH(U_MIN_PIN));
+  TERN_(USE_V_MAX, _ATTACH(V_MAX_PIN));
+  TERN_(USE_V_MIN, _ATTACH(V_MIN_PIN));
+  TERN_(USE_W_MAX, _ATTACH(W_MAX_PIN));
+  TERN_(USE_W_MIN, _ATTACH(W_MIN_PIN));
+}

Marlin/src/HAL/RP2040/fast_pwm.cpp

@@ -0,0 +1,43 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2024 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 "../platforms.h"
+
+#ifdef __PLAT_RP2040__
+
+#include "../../inc/MarlinConfigPre.h"
+
+#include "HAL.h"
+#include "pinDefinitions.h"
+
+void MarlinHAL::set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size/*=255*/, const bool invert/*=false*/) {
+  analogWrite(pin, v);
+}
+
+void MarlinHAL::set_pwm_frequency(const pin_t pin, const uint16_t f_desired) {
+  mbed::PwmOut* pwm = digitalPinToPwm(pin);
+  if (pwm != NULL) delete pwm;
+  pwm = new mbed::PwmOut(digitalPinToPinName(pin));
+  digitalPinToPwm(pin) = pwm;
+  pwm->period_ms(1000 / f_desired);
+}
+
+#endif // __PLAT_RP2040__

Marlin/src/HAL/RP2040/fastio.cpp

@@ -0,0 +1,32 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2024 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 "../platforms.h"
+
+#ifdef __PLAT_RP2040__
+
+#include "../../inc/MarlinConfig.h"
+
+void FastIO_init() {
+
+}
+
+#endif // __PLAT_RP2040__

Marlin/src/HAL/RP2040/fastio.h

@@ -0,0 +1,87 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2024 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+#pragma once
+
+/**
+ * Fast I/O interfaces for RP2040
+ * These use GPIO register access for fast port manipulation.
+ */
+
+// ------------------------
+// Public Variables
+// ------------------------
+
+
+// ------------------------
+// Public functions
+// ------------------------
+
+void FastIO_init(); // Must be called before using fast io macros
+#define FASTIO_INIT() FastIO_init()
+
+// ------------------------
+// Defines
+// ------------------------
+
+#define _BV32(b) (1UL << (b))
+
+#ifndef PWM
+  #define PWM OUTPUT
+#endif
+
+#define _WRITE(IO, V) digitalWrite((IO), (V))
+
+#define _READ(IO)               digitalRead(IO)
+#define _TOGGLE(IO)             digitalWrite(IO, !digitalRead(IO))
+
+#define _GET_MODE(IO)
+#define _SET_MODE(IO,M)         pinMode(IO, M)
+#define _SET_OUTPUT(IO)         pinMode(IO, OUTPUT)                               //!< Output Push Pull Mode & GPIO_NOPULL
+#define _SET_OUTPUT_OD(IO)      pinMode(IO, OUTPUT_OPEN_DRAIN)
+
+#define WRITE(IO,V)             _WRITE(IO,V)
+#define READ(IO)                _READ(IO)
+#define TOGGLE(IO)              _TOGGLE(IO)
+
+#define OUT_WRITE(IO,V)         do{ _SET_OUTPUT(IO); WRITE(IO,V); }while(0)
+#define OUT_WRITE_OD(IO,V)      do{ _SET_OUTPUT_OD(IO); WRITE(IO,V); }while(0)
+
+#define SET_INPUT(IO)           _SET_MODE(IO, INPUT)                              //!< Input Floating Mode
+#define SET_INPUT_PULLUP(IO)    _SET_MODE(IO, INPUT_PULLUP)                       //!< Input with Pull-up activation
+#define SET_INPUT_PULLDOWN(IO)  _SET_MODE(IO, INPUT_PULLDOWN)                     //!< Input with Pull-down activation
+#define SET_OUTPUT(IO)          OUT_WRITE(IO, LOW)
+#define SET_PWM(IO)             _SET_MODE(IO, PWM)
+
+#define IS_INPUT(IO)
+#define IS_OUTPUT(IO)
+
+#define PWM_PIN(P)              true //digitalPinHasPWM(P)
+#define NO_COMPILE_TIME_PWM
+
+// digitalRead/Write wrappers
+#define extDigitalRead(IO)    digitalRead(IO)
+#define extDigitalWrite(IO,V) digitalWrite(IO,V)
+
+#undef I2C_SDA
+#define I2C_SDA_PIN PIN_WIRE_SDA
+#undef I2C_SCL
+#define I2C_SCL_PIN PIN_WIRE_SCL

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

@@ -0,0 +1,22 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2024 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