Merge branch 'Trex_2.0.x_Devel' of https://github.com/InsanityAutomation/Marlin into Trex_2.0.x_Devel

Bump to current
Reduce ram and SPI speed
2024-06-26 10:53:20 -04:00 · 2024-04-15 14:16:11 -04:00 · 2022-10-23 12:35:46 -04:00 · 2022-10-21 15:29:10 -04:00 · 2022-10-11 11:37:22 -04:00 · 2022-10-11 11:36:31 -04:00
1051 changed files with 24802 additions and 48148 deletions
@@ -1,21 +0,0 @@
-# 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/
@@ -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.com/servers/marlin-firmware-461605380783472640
+    url: https://discord.gg/n5NJ59y
    about: Join the Discord server for support and discussion.
  - name: 🔗 Marlin Discussion Forum
    url: https://reprap.org/forum/list.php?415
@@ -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.com/servers/marlin-firmware-461605380783472640 to join up as a General User.
+* Use the link https://discord.gg/n5NJ59y to join up as a General User.
 * Even though our Discord is pretty active, it may take a while for community members to respond &mdash; 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.
@@ -14,7 +14,7 @@ jobs:
  autolabel:
    name: Auto Label
    if: github.repository == 'MarlinFirmware/Marlin'
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
    steps:
    - name: Auto Label for [BUG]
      uses: actions/github-script@v7
@@ -14,7 +14,7 @@ jobs:
    name: Bump Distribution Date
    if: github.repository == 'MarlinFirmware/Marlin'

-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest

    steps:

@@ -18,7 +18,7 @@ jobs:
    name: PR Bad Target
    if: github.repository == 'MarlinFirmware/Marlin'

-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest

    steps:
    - uses: superbrothers/close-pull-request@v3
@@ -1,73 +0,0 @@
-#
-# ci-unit-tests.yml
-# Build and execute unit tests to catch functional issues in code
-#
-
-name: CI - Unit Tests
-
-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-ignore:
-    - config/**
-    - data/**
-    - docs/**
-    - '**/*.md'
-  push:
-    branches:
-    - bugfix-2.1.x
-    # Cannot be enabled on 2.1.x until it contains the unit test framework
-    #- 2.1.x
-    paths-ignore:
-    - config/**
-    - data/**
-    - docs/**
-    - '**/*.md'
-
-jobs:
-  # This runs all unit tests as a single job. While it should be possible to break this up into
-  # multiple jobs, they currently run quickly and finish long before the compilation tests.
-  run_unit_tests:
-    name: Unit Test
-    # These tests will only be able to run on the bugfix-2.1.x branch, until the next release
-    # pulls them into additional branches.
-    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: Cache PlatformIO
-      uses: actions/cache@v4
-      with:
-        path: ~/.platformio
-        key: ${{ runner.os }}-${{ hashFiles('**/lockfiles') }}
-
-    - name: Select Python 3.9
-      uses: actions/setup-python@v5
-      with:
-        python-version: '3.9'
-        architecture: 'x64'
-
-    - name: Install PlatformIO
-      run: |
-        pip install -U platformio
-        pio upgrade --dev
-        pio pkg update --global
-
-    - name: Run All Unit Tests
-      run: |
-        make unit-test-all-local
@@ -1,48 +0,0 @@
-#
-# 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
@@ -1,51 +0,0 @@
-#
-# 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
@@ -13,7 +13,7 @@ on:

 jobs:
  remove_label:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest

    strategy:
      matrix:
@@ -14,7 +14,7 @@ jobs:
    name: Close Stale Issues
    if: github.repository == 'MarlinFirmware/Marlin'

-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest

    steps:
    - uses: actions/stale@v9
@@ -14,7 +14,7 @@ jobs:
    name: Lock Closed Issues
    if: github.repository == 'MarlinFirmware/Marlin'

-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest

    steps:
    - uses: dessant/lock-threads@v5
@@ -1,9 +1,9 @@
 #
-# ci-build-tests.yml
+# test-builds.yml
 # Do test builds to catch compile errors
 #

-name: CI - Build Tests
+name: CI

 on:
  pull_request:
@@ -14,8 +14,6 @@ on:
    - config/**
    - data/**
    - docs/**
-    - test/**
-    - Marlin/tests/**
    - '**/*.md'
  push:
    branches:
@@ -25,28 +23,21 @@ on:
    - config/**
    - data/**
    - docs/**
-    - test/**
-    - Marlin/tests/**
    - '**/*.md'

 jobs:
  test_builds:
-    name: Build Test
+    name: Run All Tests
    if: github.repository == 'MarlinFirmware/Marlin'

-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest

    strategy:
-      fail-fast: true
      matrix:
        test-platform:

-        # RP2040
-        - SKR_Pico
-
        # Native
        - linux_native
-        - simulator_linux_release

        # AVR
        - mega2560
@@ -109,9 +100,9 @@ jobs:

        # STM32F4
        - ARMED
-        - BTT_BTT002
-        - BTT_GTR_V1_0
-        - BTT_SKR_PRO
+        - BIGTREE_BTT002
+        - BIGTREE_GTR_V1_0
+        - BIGTREE_SKR_PRO
        - FLYF407ZG
        - FYSETC_S6
        - LERDGEK
@@ -186,13 +177,6 @@ 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 }}
@@ -14,7 +14,7 @@ jobs:
    name: Unlock Reopened
    if: github.repository == 'MarlinFirmware/Marlin'

-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest

    steps:
    - uses: OSDKDev/unlock-issues@v1.1
@@ -125,7 +125,6 @@ vc-fileutils.settings
 # Visual Studio Code
 .vscode/*
 !.vscode/extensions.json
-*.code-workspace

 # Simulation files
 imgui.ini
@@ -169,6 +168,3 @@ __pycache__
 tags
 *.logs
 *.bak
-.aider*
-!.aiderignore
-.env
@@ -1,16 +0,0 @@
-/**
- * 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
-    }
-  }
-}
@@ -2,24 +2,17 @@ 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 -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 marlin                    : Build marlin for the configured board"
+	@echo "make format-pins               : Reformat all pins files"
 	@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-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"
-	@echo "make setup-local-docker        : Setup local docker using buildx"
+	@echo "make setup-local-docker        : Build the local docker image"
 	@echo ""
 	@echo "Options for testing:"
 	@echo "  TEST_TARGET          Set when running tests-single-*, to select the"
@@ -29,9 +22,6 @@ 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!"
@@ -53,61 +43,23 @@ tests-single-local:
 tests-single-local-docker:
 	@if ! test -n "$(TEST_TARGET)" ; then echo "***ERROR*** Set TEST_TARGET=<your-module> or use make tests-all-local-docker" ; return 1; fi
 	@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-single-local TEST_TARGET=$(TEST_TARGET) VERBOSE_PLATFORMIO=$(VERBOSE_PLATFORMIO) GIT_RESET_HARD=$(GIT_RESET_HARD) ONLY_TEST="$(ONLY_TEST)"
+	$(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 $$(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
+	  && for TEST_TARGET in $$($(SCRIPTS_DIR)/get_test_targets.py) ; do echo "Running tests for $$TEST_TARGET" ; run_tests . $$TEST_TARGET ; 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-local:
-	platformio run -t marlin_$(UNIT_TEST_CONFIG) -e linux_native_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
-
-unit-test-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 unit-test-all-local
+	$(CONTAINER_RT_BIN) run $(CONTAINER_RT_OPTS) $(CONTAINER_IMAGE) $(MAKE) tests-all-local VERBOSE_PLATFORMIO=$(VERBOSE_PLATFORMIO) GIT_RESET_HARD=$(GIT_RESET_HARD)

 setup-local-docker:
-	$(CONTAINER_RT_BIN) buildx build -t $(CONTAINER_IMAGE) -f docker/Dockerfile .
+	$(CONTAINER_RT_BIN) build -t $(CONTAINER_IMAGE) -f docker/Dockerfile .

 PINS := $(shell find Marlin/src/pins -mindepth 2 -name '*.h')

-.PHONY: $(PINS) format-pins validate-pins
-
 $(PINS): %:
-	@echo "Formatting $@"
-	@python $(SCRIPTS_DIR)/pinsformat.py $< $@
+	@echo "Formatting $@" && node $(SCRIPTS_DIR)/pinsformat.js $@

 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)
@@ -187,17 +187,6 @@ 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
 #
@@ -232,113 +221,108 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1112)
 else ifeq ($(HARDWARE_MOTHERBOARD),1113)
 # BigTreeTech or BIQU KFB2.0
 else ifeq ($(HARDWARE_MOTHERBOARD),1114)
-# Zonestar zrib V2.0 (Chinese RAMPS replica)
+# zrib V2.0 (Chinese RAMPS replica)
 else ifeq ($(HARDWARE_MOTHERBOARD),1115)
-# Zonestar zrib V5.2 (Chinese RAMPS replica)
+# zrib V5.2 (Chinese RAMPS replica)
 else ifeq ($(HARDWARE_MOTHERBOARD),1116)
-# Zonestar zrib V5.3 (Chinese RAMPS replica)
-else ifeq ($(HARDWARE_MOTHERBOARD),1117)
 # Felix 2.0+ Electronics Board (RAMPS like)
-else ifeq ($(HARDWARE_MOTHERBOARD),1118)
+else ifeq ($(HARDWARE_MOTHERBOARD),1117)
 # Invent-A-Part RigidBoard
-else ifeq ($(HARDWARE_MOTHERBOARD),1119)
+else ifeq ($(HARDWARE_MOTHERBOARD),1118)
 # Invent-A-Part RigidBoard V2
-else ifeq ($(HARDWARE_MOTHERBOARD),1120)
+else ifeq ($(HARDWARE_MOTHERBOARD),1119)
 # Sainsmart 2-in-1 board
-else ifeq ($(HARDWARE_MOTHERBOARD),1121)
+else ifeq ($(HARDWARE_MOTHERBOARD),1120)
 # Ultimaker
-else ifeq ($(HARDWARE_MOTHERBOARD),1122)
+else ifeq ($(HARDWARE_MOTHERBOARD),1121)
 # Ultimaker (Older electronics. Pre 1.5.4. This is rare)
-else ifeq ($(HARDWARE_MOTHERBOARD),1123)
+else ifeq ($(HARDWARE_MOTHERBOARD),1122)
  MCU              ?= atmega1280
  PROG_MCU         ?= m1280
 # Azteeg X3
-else ifeq ($(HARDWARE_MOTHERBOARD),1124)
+else ifeq ($(HARDWARE_MOTHERBOARD),1123)
 # Azteeg X3 Pro
-else ifeq ($(HARDWARE_MOTHERBOARD),1125)
+else ifeq ($(HARDWARE_MOTHERBOARD),1124)
 # Ultimainboard 2.x (Uses TEMP_SENSOR 20)
-else ifeq ($(HARDWARE_MOTHERBOARD),1126)
+else ifeq ($(HARDWARE_MOTHERBOARD),1125)
 # Rumba
-else ifeq ($(HARDWARE_MOTHERBOARD),1127)
+else ifeq ($(HARDWARE_MOTHERBOARD),1126)
 # Raise3D N series Rumba derivative
-else ifeq ($(HARDWARE_MOTHERBOARD),1128)
+else ifeq ($(HARDWARE_MOTHERBOARD),1127)
 # Rapide Lite 200 (v1, low-cost RUMBA clone with drv)
-else ifeq ($(HARDWARE_MOTHERBOARD),1129)
+else ifeq ($(HARDWARE_MOTHERBOARD),1128)
 # Formbot T-Rex 2 Plus
-else ifeq ($(HARDWARE_MOTHERBOARD),1130)
+else ifeq ($(HARDWARE_MOTHERBOARD),1129)
 # Formbot T-Rex 3
-else ifeq ($(HARDWARE_MOTHERBOARD),1131)
+else ifeq ($(HARDWARE_MOTHERBOARD),1130)
 # Formbot Raptor
-else ifeq ($(HARDWARE_MOTHERBOARD),1132)
+else ifeq ($(HARDWARE_MOTHERBOARD),1131)
 # Formbot Raptor 2
-else ifeq ($(HARDWARE_MOTHERBOARD),1133)
+else ifeq ($(HARDWARE_MOTHERBOARD),1132)
 # bq ZUM Mega 3D
-else ifeq ($(HARDWARE_MOTHERBOARD),1134)
+else ifeq ($(HARDWARE_MOTHERBOARD),1133)
 # MakeBoard Mini v2.1.2 by MicroMake
-else ifeq ($(HARDWARE_MOTHERBOARD),1135)
+else ifeq ($(HARDWARE_MOTHERBOARD),1134)
 # TriGorilla Anycubic version 1.3-based on RAMPS EFB
-else ifeq ($(HARDWARE_MOTHERBOARD),1136)
+else ifeq ($(HARDWARE_MOTHERBOARD),1135)
 #   ... Ver 1.4
-else ifeq ($(HARDWARE_MOTHERBOARD),1137)
+else ifeq ($(HARDWARE_MOTHERBOARD),1136)
 #   ... Rev 1.1 (new servo pin order)
-else ifeq ($(HARDWARE_MOTHERBOARD),1138)
+else ifeq ($(HARDWARE_MOTHERBOARD),1137)
 # Creality: Ender-4, CR-8
-else ifeq ($(HARDWARE_MOTHERBOARD),1139)
+else ifeq ($(HARDWARE_MOTHERBOARD),1138)
 # Creality: CR10S, CR20, CR-X
-else ifeq ($(HARDWARE_MOTHERBOARD),1140)
+else ifeq ($(HARDWARE_MOTHERBOARD),1139)
 # Dagoma F5
-else ifeq ($(HARDWARE_MOTHERBOARD),1141)
-# Dagoma D6 (as found in the Dagoma DiscoUltimate V2 TMC)
-else ifeq ($(HARDWARE_MOTHERBOARD),1142)
+else ifeq ($(HARDWARE_MOTHERBOARD),1140)
 # FYSETC F6 1.3
-else ifeq ($(HARDWARE_MOTHERBOARD),1143)
+else ifeq ($(HARDWARE_MOTHERBOARD),1141)
 # FYSETC F6 1.4
-else ifeq ($(HARDWARE_MOTHERBOARD),1144)
+else ifeq ($(HARDWARE_MOTHERBOARD),1142)
 # Wanhao Duplicator i3 Plus
-else ifeq ($(HARDWARE_MOTHERBOARD),1145)
+else ifeq ($(HARDWARE_MOTHERBOARD),1143)
 # VORON Design
-else ifeq ($(HARDWARE_MOTHERBOARD),1146)
+else ifeq ($(HARDWARE_MOTHERBOARD),1144)
 # Tronxy TRONXY-V3-1.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1147)
+else ifeq ($(HARDWARE_MOTHERBOARD),1145)
 # Z-Bolt X Series
-else ifeq ($(HARDWARE_MOTHERBOARD),1148)
+else ifeq ($(HARDWARE_MOTHERBOARD),1146)
 # TT OSCAR
+else ifeq ($(HARDWARE_MOTHERBOARD),1147)
+# Overlord/Overlord Pro
+else ifeq ($(HARDWARE_MOTHERBOARD),1148)
+# ADIMLab Gantry v1
 else ifeq ($(HARDWARE_MOTHERBOARD),1149)
-# BIQU Tango V1
+# ADIMLab Gantry v2
 else ifeq ($(HARDWARE_MOTHERBOARD),1150)
-# MKS GEN L V2
+# BIQU Tango V1
 else ifeq ($(HARDWARE_MOTHERBOARD),1151)
-# MKS GEN L V2.1
+# MKS GEN L V2
 else ifeq ($(HARDWARE_MOTHERBOARD),1152)
-# Copymaster 3D
+# MKS GEN L V2.1
 else ifeq ($(HARDWARE_MOTHERBOARD),1153)
-# Ortur 4
+# Copymaster 3D
 else ifeq ($(HARDWARE_MOTHERBOARD),1154)
-# Tenlog D3 Hero IDEX printer
+# Ortur 4
 else ifeq ($(HARDWARE_MOTHERBOARD),1155)
-# Tenlog D3, D5, D6 IDEX Printer
+# Tenlog D3 Hero IDEX printer
 else ifeq ($(HARDWARE_MOTHERBOARD),1156)
-# Ramps S 1.2 by Sakul.cz (Power outputs: Hotend0, Hotend1, Fan, Bed)
+# Tenlog D3,5,6 Pro IDEX printers
 else ifeq ($(HARDWARE_MOTHERBOARD),1157)
-# Ramps S 1.2 by Sakul.cz (Power outputs: Hotend0, Hotend1, Hotend2, Bed)
+# Ramps S 1.2 by Sakul.cz (Power outputs: Hotend0, Hotend1, Fan, Bed)
 else ifeq ($(HARDWARE_MOTHERBOARD),1158)
-# Ramps S 1.2 by Sakul.cz (Power outputs: Hotend, Fan0, Fan1, Bed)
+# Ramps S 1.2 by Sakul.cz (Power outputs: Hotend0, Hotend1, Hotend2, Bed)
 else ifeq ($(HARDWARE_MOTHERBOARD),1159)
-# Longer LK1 PRO / Alfawise U20 Pro (PRO version)
+# Ramps S 1.2 by Sakul.cz (Power outputs: Hotend, Fan0, Fan1, Bed)
 else ifeq ($(HARDWARE_MOTHERBOARD),1160)
-# Longer LKx PRO / Alfawise Uxx Pro (PRO version)
+# Longer LK1 PRO / Alfawise U20 Pro (PRO version)
 else ifeq ($(HARDWARE_MOTHERBOARD),1161)
-# Pxmalion Core I3
+# Longer LKx PRO / Alfawise Uxx Pro (PRO version)
 else ifeq ($(HARDWARE_MOTHERBOARD),1162)
-# Panowin Cutlass (as found in the Panowin F1)
+# Zonestar zrib V5.3 (Chinese RAMPS replica)
 else ifeq ($(HARDWARE_MOTHERBOARD),1163)
-# Kodama Bardo V1.x (as found in the Kodama Trinus)
+# Pxmalion Core I3
 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
@@ -356,7 +340,7 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1203)
 else ifeq ($(HARDWARE_MOTHERBOARD),1204)
 # abee Scoovo X9H
 else ifeq ($(HARDWARE_MOTHERBOARD),1205)
-# ThinkerV2
+# Rambo ThinkerV2
 else ifeq ($(HARDWARE_MOTHERBOARD),1206)

 #
@@ -399,40 +383,30 @@ 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 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 A10(M/T/D)
-else ifeq ($(HARDWARE_MOTHERBOARD),1320)
+else ifeq ($(HARDWARE_MOTHERBOARD),1318)
+# Geeetech GT2560 Rev B for Mecreator2
+else ifeq ($(HARDWARE_MOTHERBOARD),1319)
 # Geeetech GT2560 Rev B for A20(M/T/D)
-else ifeq ($(HARDWARE_MOTHERBOARD),1321)
+else ifeq ($(HARDWARE_MOTHERBOARD),1320)
 # Einstart retrofit
-else ifeq ($(HARDWARE_MOTHERBOARD),1322)
+else ifeq ($(HARDWARE_MOTHERBOARD),1321)
 # 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)
+else ifeq ($(HARDWARE_MOTHERBOARD),1322)
 # Leapfrog Xeed 2015
-else ifeq ($(HARDWARE_MOTHERBOARD),1327)
+else ifeq ($(HARDWARE_MOTHERBOARD),1323)
 # PICA Shield (original version)
-else ifeq ($(HARDWARE_MOTHERBOARD),1328)
+else ifeq ($(HARDWARE_MOTHERBOARD),1324)
 # PICA Shield (rev C or later)
-else ifeq ($(HARDWARE_MOTHERBOARD),1329)
+else ifeq ($(HARDWARE_MOTHERBOARD),1325)
 # Intamsys 4.0 (Funmat HT)
-else ifeq ($(HARDWARE_MOTHERBOARD),1330)
+else ifeq ($(HARDWARE_MOTHERBOARD),1326)
 # Malyan M180 Mainboard Version 2 (no display function, direct G-code only)
-else ifeq ($(HARDWARE_MOTHERBOARD),1331)
+else ifeq ($(HARDWARE_MOTHERBOARD),1327)
+# Geeetech GT2560 Rev B for A20(M/T/D)
+else ifeq ($(HARDWARE_MOTHERBOARD),1328)
 # Mega controller & Protoneer CNC Shield V3.00
-else ifeq ($(HARDWARE_MOTHERBOARD),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)
+else ifeq ($(HARDWARE_MOTHERBOARD),1329)

 #
 # ATmega1281, ATmega2561
@@ -466,7 +440,7 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1502)
  HARDWARE_VARIANT ?= Sanguino
  MCU              ?= atmega644p
  PROG_MCU         ?= m644p
-# Melzi V2
+# Melzi V2.0
 else ifeq ($(HARDWARE_MOTHERBOARD),1503)
  HARDWARE_VARIANT ?= Sanguino
  MCU              ?= atmega1284p
@@ -476,38 +450,33 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1504)
  HARDWARE_VARIANT ?= Sanguino
  MCU              ?= atmega1284p
  PROG_MCU         ?= m1284p
-# Melzi Creality3D (for CR-10 etc)
+# Melzi Creality3D board (for CR-10 etc)
 else ifeq ($(HARDWARE_MOTHERBOARD),1505)
  HARDWARE_VARIANT ?= Sanguino
  MCU              ?= atmega1284p
  PROG_MCU         ?= m1284p
-# Melzi Creality3D (for Ender-2)
+# Melzi Malyan M150 board
 else ifeq ($(HARDWARE_MOTHERBOARD),1506)
  HARDWARE_VARIANT ?= Sanguino
  MCU              ?= atmega1284p
  PROG_MCU         ?= m1284p
-# Melzi Malyan M150
+# Tronxy X5S
 else ifeq ($(HARDWARE_MOTHERBOARD),1507)
  HARDWARE_VARIANT ?= Sanguino
  MCU              ?= atmega1284p
  PROG_MCU         ?= m1284p
-# Tronxy X5S
+# STB V1.1
 else ifeq ($(HARDWARE_MOTHERBOARD),1508)
  HARDWARE_VARIANT ?= Sanguino
  MCU              ?= atmega1284p
  PROG_MCU         ?= m1284p
-# STB V1.1
+# Azteeg X1
 else ifeq ($(HARDWARE_MOTHERBOARD),1509)
  HARDWARE_VARIANT ?= Sanguino
  MCU              ?= atmega1284p
  PROG_MCU         ?= m1284p
-# 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)
+else ifeq ($(HARDWARE_MOTHERBOARD),1510)
  HARDWARE_VARIANT ?= Sanguino
  MCU              ?= atmega1284p
  PROG_MCU         ?= m1284p
@@ -1026,7 +995,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)
@@ -28,32 +28,25 @@
 /**
 * Marlin release version identifier
 */
-//#define SHORT_BUILD_VERSION "bugfix-2.1.x"
+#define SHORT_BUILD_VERSION "2.1.x-TR1"

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

 /**
 * 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-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"
+//#define STRING_DISTRIBUTION_DATE "2024-04-11"

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

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

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

 /**
- * Set the vendor info the serial USB interface, if changeable.
- * Currently only supported by DUE platform.
+ * Set the vendor info the serial USB interface, if changable
+ * Currently only supported by DUE platform
 */
 //#define USB_DEVICE_VENDOR_ID           0x0000
 //#define USB_DEVICE_PRODUCT_ID          0x0000
@@ -0,0 +1,93 @@
+/**
+ * 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
+};
@@ -0,0 +1,74 @@
+/**
+ * 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
@@ -129,11 +129,11 @@ typedef Servo hal_servo_t;
  #endif
 #endif

-#ifdef MMU_SERIAL_PORT
-  #if !WITHIN(MMU_SERIAL_PORT, 0, 3)
-    #error "MMU_SERIAL_PORT must be from 0 to 3"
+#ifdef MMU2_SERIAL_PORT
+  #if !WITHIN(MMU2_SERIAL_PORT, 0, 3)
+    #error "MMU2_SERIAL_PORT must be from 0 to 3"
  #endif
-  #define MMU_SERIAL mmuSerial
+  #define MMU2_SERIAL mmuSerial
 #endif

 #ifdef LCD_SERIAL_PORT
@@ -141,7 +141,7 @@ typedef Servo hal_servo_t;
    #error "LCD_SERIAL_PORT must be from 0 to 3."
  #endif
  #define LCD_SERIAL lcdSerial
-  #if ANY(HAS_DGUS_LCD, EXTENSIBLE_UI)
+  #if HAS_DGUS_LCD
    #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)
@@ -601,20 +601,20 @@ MSerialT1 customizedSerial1(MSerialT1::HasEmergencyParser);

 #endif // SERIAL_PORT_3

-#ifdef MMU_SERIAL_PORT
+#ifdef MMU2_SERIAL_PORT

-  ISR(SERIAL_REGNAME(USART, MMU_SERIAL_PORT, _RX_vect)) {
-    MarlinSerial<MMU2SerialCfg<MMU_SERIAL_PORT>>::store_rxd_char();
+  ISR(SERIAL_REGNAME(USART, MMU2_SERIAL_PORT, _RX_vect)) {
+    MarlinSerial<MMU2SerialCfg<MMU2_SERIAL_PORT>>::store_rxd_char();
  }

-  ISR(SERIAL_REGNAME(USART, MMU_SERIAL_PORT, _UDRE_vect)) {
-    MarlinSerial<MMU2SerialCfg<MMU_SERIAL_PORT>>::_tx_udr_empty_irq();
+  ISR(SERIAL_REGNAME(USART, MMU2_SERIAL_PORT, _UDRE_vect)) {
+    MarlinSerial<MMU2SerialCfg<MMU2_SERIAL_PORT>>::_tx_udr_empty_irq();
  }

-  template class MarlinSerial< MMU2SerialCfg<MMU_SERIAL_PORT> >;
+  template class MarlinSerial< MMU2SerialCfg<MMU2_SERIAL_PORT> >;
  MSerialMMU2 mmuSerial(MSerialMMU2::HasEmergencyParser);

-#endif // MMU_SERIAL_PORT
+#endif // MMU2_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 ANY(HAS_DGUS_LCD, EXTENSIBLE_UI)
+  #if HAS_DGUS_LCD
    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.
@@ -205,7 +205,7 @@
    static ring_buffer_pos_t available();
    static void write(const uint8_t c);
    static void flushTX();
-    #if ANY(HAS_DGUS_LCD, EXTENSIBLE_UI)
+    #if HAS_DGUS_LCD
      static ring_buffer_pos_t get_tx_buffer_free();
    #endif

@@ -246,7 +246,7 @@

 #endif // !USBCON

-#ifdef MMU_SERIAL_PORT
+#ifdef MMU2_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<MMU_SERIAL_PORT> > > MSerialMMU2;
+  typedef Serial1Class< MarlinSerial< MMU2SerialCfg<MMU2_SERIAL_PORT> > > MSerialMMU2;
  extern MSerialMMU2 mmuSerial;
 #endif

@@ -345,14 +345,6 @@ 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.
 }
@@ -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;
      }
@@ -28,6 +28,9 @@
 *   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"
@@ -26,6 +26,9 @@
 *
 *   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"
@@ -26,6 +26,9 @@
 *
 *   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"
@@ -26,6 +26,9 @@
 *
 *   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
@@ -26,7 +26,10 @@
 *
 *   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
- *            Logical pins 46-47 aren't supported by Teensyduino, but are supported below as E2 and E3
+ *            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
 */

 #include "../fastio.h"
@@ -22,23 +22,7 @@
 #pragma once

 /**
- * 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)
+ * PWM print routines for Atmel 8 bit AVR CPUs
 */

 #include "../../inc/MarlinConfig.h"
@@ -55,44 +39,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 getValidPinMode(P) (*portModeRegister(P) & digitalPinToBitMask_DEBUG(P))
+  #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))

 #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 getValidPinMode(pin_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 GET_PINMODE(int8_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 getValidPinMode(pin_t pin) {return *portModeRegister(digitalPinToPort_DEBUG(pin)) & digitalPinToBitMask_DEBUG(pin); }
-  #define getPinByIndex(x) pgm_read_byte(&pin_array[x].pin)
+  #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)

 #endif

-#define isValidPin(P) (P >= 0 && P < NUMBER_PINS_TOTAL)
+#define VALID_PIN(pin) (pin >= 0 && pin < NUM_DIGITAL_PINS ? 1 : 0)
 #if AVR_ATmega1284_FAMILY
-  #define isAnalogPin(P) WITHIN(P, analogInputToDigitalPin(7), analogInputToDigitalPin(0))
-  #define digitalPinToAnalogIndex(P) int(isAnalogPin(P) ? (P) - analogInputToDigitalPin(7) : -1)
+  #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)
 #else
  #define _ANALOG1(P) WITHIN(P, analogInputToDigitalPin(0), analogInputToDigitalPin(7))
  #define _ANALOG2(P) WITHIN(P, analogInputToDigitalPin(8), analogInputToDigitalPin(15))
-  #define isAnalogPin(P) (_ANALOG1(P) || _ANALOG2(P))
-  #define digitalPinToAnalogIndex(P) int(_ANALOG1(P) ? (P) - analogInputToDigitalPin(0) : _ANALOG2(P) ? (P) - analogInputToDigitalPin(8) + 8 : -1)
+  #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)
 #endif
-#define getPinByIndex(x) pgm_read_byte(&pin_array[x].pin)
+#define GET_ARRAY_PIN(p) pgm_read_byte(&pin_array[p].pin)
 #define MULTI_NAME_PAD 26 // space needed to be pretty if not first name assigned to a pin

-void printPinNameByIndex(const uint8_t index) {
-  PGM_P const name_mem_pointer = (PGM_P)pgm_read_ptr(&pin_array[index].name);
+void PRINT_ARRAY_NAME(uint8_t x) {
+  PGM_P const name_mem_pointer = (PGM_P)pgm_read_ptr(&pin_array[x].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)
@@ -104,7 +88,7 @@ void printPinNameByIndex(const uint8_t index) {
  }
 }

-#define getPinIsDigitalByIndex(x)   pgm_read_byte(&pin_array[x].is_digital)
+#define GET_ARRAY_IS_DIGITAL(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
@@ -125,7 +109,7 @@ void printPinNameByIndex(const uint8_t index) {
 * Print a pin's PWM status.
 * Return true if it's currently a PWM pin.
 */
-bool pwm_status(const uint8_t pin) {
+bool pwm_status(uint8_t pin) {
  char buffer[20];   // for the sprintf statements

  switch (digitalPinToTimer_DEBUG(pin)) {
@@ -292,7 +276,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 printPinPWM(const uint8_t pin) {
+void pwm_details(uint8_t pin) {
  switch (digitalPinToTimer_DEBUG(pin)) {

    #if ABTEST(0)
@@ -363,7 +347,7 @@ void printPinPWM(const uint8_t pin) {
  #else
    UNUSED(print_is_also_tied);
  #endif
-} // printPinPWM
+} // pwm_details

 #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
@@ -372,7 +356,7 @@ void printPinPWM(const uint8_t pin) {
  }
 #endif

-void printPinPort(const pin_t pin) {   // print port number
+void print_port(const pin_t pin) {   // print port number
  #ifdef digitalPinToPort_DEBUG
    uint8_t x;
    SERIAL_ECHOPGM("  Port: ");
@@ -402,7 +386,7 @@ void printPinPort(const pin_t pin) {   // print port number
  #endif
 }

-#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 PRINT_PIN(p) do{ sprintf_P(buffer, PSTR("%3d "), p); SERIAL_ECHO(buffer); }while(0)
+#define PRINT_PIN_ANALOG(p) do{ sprintf_P(buffer, PSTR(" (A%2d)  "), DIGITAL_PIN_TO_ANALOG_PIN(pin)); SERIAL_ECHO(buffer); }while(0)

 #undef ABTEST
@@ -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
@@ -120,7 +120,7 @@ void u8g_spiSend_sw_AVR_mode_3(uint8_t val) {
  U8G_ATOMIC_END();
 }

-#if U8G_SPI_USE_MODE_3
+#if ENABLED(FYSETC_MINI_12864)
  #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 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
+      #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_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);
        }
@@ -81,11 +81,11 @@ extern DefaultSerial4 MSerial3;
  #endif
 #endif

-#ifdef MMU_SERIAL_PORT
-  #if WITHIN(MMU_SERIAL_PORT, 0, 3)
-    #define MMU_SERIAL MSERIAL(MMU_SERIAL_PORT)
+#ifdef MMU2_SERIAL_PORT
+  #if WITHIN(MMU2_SERIAL_PORT, 0, 3)
+    #define MMU2_SERIAL MSERIAL(MMU2_SERIAL_PORT)
  #else
-    #error "MMU_SERIAL_PORT must be from 0 to 3."
+    #error "MMU2_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) pin_t((p < 12U) ? (p) + 54U : -1)
+  #define analogInputToDigitalPin(p) ((p < 12U) ? (p) + 54U : -1)
 #endif

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

@@ -64,7 +64,6 @@ 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));
@@ -61,7 +61,7 @@
 #else
  #define G2_PWM_Z 0
 #endif
-#if HAS_MOTOR_CURRENT_PWM_E
+#if PIN_EXISTS(MOTOR_CURRENT_PWM_E)
  #define G2_PWM_E 1
 #else
  #define G2_PWM_E 0
@@ -68,15 +68,16 @@
 * 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)
-  #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)
+  #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)
    #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
@@ -19,26 +19,13 @@
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 */
-#pragma once

 /**
- * 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)
+ * Support routines for Due
+ */
+
+/**
+ * Translation of routines & variables used by pinsDebug.h
 */

 #include "../shared/Marduino.h"
@@ -76,20 +63,20 @@

 #define NUMBER_PINS_TOTAL PINS_COUNT

-#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 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 MULTI_NAME_PAD 14 // space needed to be pretty if not first name assigned to a pin

-bool getValidPinMode(const pin_t pin) {  // 1: output, 0: input
+bool GET_PINMODE(int8_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;
@@ -98,14 +85,14 @@ bool getValidPinMode(const pin_t pin) {  // 1: output, 0: input
          || pwm_status(pin));
 }

-void printPinPWM(const int32_t pin) {
+void pwm_details(int32_t pin) {
  if (pwm_status(pin)) {
    uint32_t chan = g_APinDescription[pin].ulPWMChannel;
    SERIAL_ECHOPGM("PWM = ", PWM_INTERFACE->PWM_CH_NUM[chan].PWM_CDTY);
  }
 }

-void printPinPort(const pin_t) {}
+void print_port(const pin_t) {}

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

 #include <U8glib-HAL.h>

-#if U8G_SPI_USE_MODE_3
+#if ENABLED(FYSETC_MINI_12864)
  #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 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
+      #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
          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);
@@ -11,7 +11,7 @@ if pioutil.is_pio_build():

    if current_OS == 'Windows':

-        env = pioutil.env
+        Import("env")

        # Use bossac.exe on Windows
        env.Replace(
@@ -18,32 +18,32 @@ extern "C" {
 void sd_mmc_spi_mem_init() {
 }

-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 !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;
+  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 (sd_mmc_spi_removal()) return CTRL_NO_PRESENT;
+  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;
 }

+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());
+}
+
 #if ACCESS_USB == true
 /**
 * \name MEM <-> USB Interface
@@ -61,7 +61,8 @@ 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 (sd_mmc_spi_removal()) return CTRL_NO_PRESENT;
+  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted())
+    return CTRL_NO_PRESENT;

  #ifdef DEBUG_MMC
  {
@@ -100,7 +101,8 @@ 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 (sd_mmc_spi_removal()) return CTRL_NO_PRESENT;
+  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted())
+    return CTRL_NO_PRESENT;

  #ifdef DEBUG_MMC
  {
@@ -74,7 +74,7 @@
 //!
 //! @brief This function initializes the hw/sw resources required to drive the SD_MMC_SPI.
 //!/
-void sd_mmc_spi_mem_init();
+extern void           sd_mmc_spi_mem_init(void);

 //!
 //! @brief This function tests the state of the SD_MMC memory and sends it to the Host.
@@ -87,7 +87,7 @@ void sd_mmc_spi_mem_init();
 //!   Media not present    ->    CTRL_NO_PRESENT
 //!   Media has changed    ->    CTRL_BUSY
 //!/
-Ctrl_status sd_mmc_spi_test_unit_ready();
+extern Ctrl_status    sd_mmc_spi_test_unit_ready(void);

 //!
 //! @brief This function gives the address of the last valid sector.
@@ -98,7 +98,7 @@ Ctrl_status sd_mmc_spi_test_unit_ready();
 //!   Media ready          ->  CTRL_GOOD
 //!   Media not present    ->  CTRL_NO_PRESENT
 //!/
-Ctrl_status sd_mmc_spi_read_capacity(uint32_t *nb_sector);
+extern Ctrl_status    sd_mmc_spi_read_capacity(uint32_t *nb_sector);

 /*! \brief Unload/Load the SD/MMC card selected
 *
@@ -109,7 +109,7 @@ Ctrl_status sd_mmc_spi_read_capacity(uint32_t *nb_sector);
 *
 * \return \c true if unload/load done success.
 */
-bool sd_mmc_spi_unload(bool unload);
+extern bool sd_mmc_spi_unload(bool unload);

 //!
 //! @brief This function returns the write protected status of the memory.
@@ -120,14 +120,14 @@ bool sd_mmc_spi_unload(bool unload);
 //!
 //! @return false  -> the memory is not write-protected (always)
 //!/
-bool sd_mmc_spi_wr_protect();
+extern bool           sd_mmc_spi_wr_protect(void);

 //!
 //! @brief This function tells if the memory has been removed or not.
 //!
 //! @return false  -> The memory isn't removed
 //!
-bool sd_mmc_spi_removal();
+extern bool           sd_mmc_spi_removal(void);

 //---- ACCESS DATA FUNCTIONS ----

@@ -147,7 +147,7 @@ bool sd_mmc_spi_removal();
 //!   It is ready    ->    CTRL_GOOD
 //!   A error occur  ->    CTRL_FAIL
 //!
-Ctrl_status sd_mmc_spi_usb_read_10(uint32_t addr, uint16_t nb_sector);
+extern 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 @@ 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
 //!
-Ctrl_status sd_mmc_spi_usb_write_10(uint32_t addr, uint16_t nb_sector);
+extern Ctrl_status    sd_mmc_spi_usb_write_10(uint32_t addr, uint16_t nb_sector);

 #endif // #if ACCESS_USB == true

@@ -209,17 +209,16 @@ int MarlinHAL::freeMemory() { return ESP.getFreeHeap(); }
 // ADC
 // ------------------------

-// https://docs.espressif.com/projects/esp-idf/en/release-v4.4/esp32/api-reference/peripherals/adc.html
+#define ADC1_CHANNEL(pin) ADC1_GPIO ## pin ## _CHANNEL
+
 adc1_channel_t get_channel(int pin) {
  switch (pin) {
-    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;
+    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);
  }
  return ADC1_CHANNEL_MAX;
 }
@@ -59,7 +59,6 @@ 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));
@@ -37,10 +37,6 @@
 // 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)

@@ -74,9 +70,6 @@
 // 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)
@@ -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.active);
+    const bool using_ftMotion = TERN0(FT_MOTION, ftMotion.cfg.mode);

    while (dma.rw_pos < DMA_SAMPLE_COUNT) {

@@ -22,15 +22,11 @@

 #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>
@@ -1,71 +0,0 @@
-/**
- * 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);
-  }
-}
@@ -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 = TIMER_AUTORELOAD_EN;
+  config.auto_reload = true;

  // Select and initialize the timer
  timer_init(timer.group, timer.idx, &config);
@@ -53,11 +53,12 @@ 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

@@ -114,19 +114,22 @@
 // Misc. Functions
 //
 #ifndef analogInputToDigitalPin
-  #define analogInputToDigitalPin(p) pin_t(p)
+#define analogInputToDigitalPin(p) (p)
 #endif

-#define CRITICAL_SECTION_START()        \
-  const bool irqon = !__get_PRIMASK();  \
-  __disable_irq();                      \
-  __DSB();
-#define CRITICAL_SECTION_END()          \
-  __DSB();                              \
-  if (irqon) __enable_irq();
+#define CRITICAL_SECTION_START        \
+  uint32_t primask = __get_PRIMASK(); \
+  (void)__iCliRetVal()

-#define cli() __disable_irq()
-#define sei() __enable_irq()
+#define CRITICAL_SECTION_END \
+  if (!primask)              \
+  (void)__iSeiRetVal()
+
+// Disable interrupts
+#define cli() noInterrupts()
+
+// Enable interrupts
+#define sei() interrupts()

 // bss_end alias
 #define __bss_end __bss_end__
@@ -139,31 +142,12 @@
 // ADC
 //
 #define HAL_ADC_VREF_MV 3300
-#define HAL_ADC_RESOLUTION 12
+#define HAL_ADC_RESOLUTION 10

 #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
 //
@@ -123,11 +123,6 @@ void MarlinHAL::init() {

  // Register min serial
  TERN_(POSTMORTEM_DEBUGGING, install_min_serial());
-
-  // warn if low memory after init
-  if (freeMemory() < 1024) {
-    SERIAL_WARN_MSG("HAL: low memory after init!\n");
-  }
 }

 void MarlinHAL::init_board() {}
@@ -152,31 +147,7 @@ void MarlinHAL::delay_ms(const int ms) {
  delay(ms);
 }

-void MarlinHAL::idletask() {
-  #if ENABLED(MARLIN_DEV_MODE)
-    // check & print serial RX errors
-    MSerialT *serials[] = { &MSerial1, &MSerial2 };
-    for (int serial = 0; serial < 2; serial++) {
-      usart_receive_error_t err = serials[serial]->getReceiveError();
-      if (err != usart_receive_error_t::None) {
-        // "Warning: MSerial[n] RX [Framing|Parity|Overrun] Error"
-        SERIAL_WARN_START();
-        SERIAL_ECHOPGM(" MSerial");
-        SERIAL_ECHO(serial + 1);
-        SERIAL_ECHOPGM(" RX ");
-        switch(err) {
-          case usart_receive_error_t::FramingError: SERIAL_ECHOPGM("Framing"); break;
-          case usart_receive_error_t::ParityError:  SERIAL_ECHOPGM("Parity");  break;
-          case usart_receive_error_t::OverrunError: SERIAL_ECHOPGM("Overrun"); break;
-          case usart_receive_error_t::RxDataDropped: SERIAL_ECHOPGM("DataDropped"); break;
-          default: break;
-        }
-        SERIAL_ECHOPGM(" Error");
-        SERIAL_EOL();
-      }
-    }
-  #endif
-}
+void MarlinHAL::idletask() {}

 uint8_t MarlinHAL::get_reset_source() {
  // Query reset cause from RMU
@@ -232,9 +203,7 @@ int MarlinHAL::freeMemory() {
  return &top - _sbrk(0);
 }

-void MarlinHAL::adc_init() {
-  analogReadResolution(HAL_ADC_RESOLUTION);
-}
+void MarlinHAL::adc_init() {}

 void MarlinHAL::adc_enable(const pin_t pin) {
  #if TEMP_SENSOR_SOC
@@ -46,34 +46,14 @@ constexpr bool serial_handles_emergency(int port) {
 //
 // Define serial ports
 //
-
-// serial port where RX and TX use IRQs
-#define DEFINE_IRQ_SERIAL_MARLIN(name, n)      \
+#define DEFINE_HWSERIAL_MARLIN(name, n)      \
  MSerialT name(serial_handles_emergency(n), \
                &USART##n##_config,          \
                BOARD_USART##n##_TX_PIN,     \
                BOARD_USART##n##_RX_PIN);

-// serial port where RX uses DMA and TX uses IRQs
-// all serial ports use DMA1
-// since there are 4 USARTs and 4 DMA channels, we can use the USART number as the DMA channel
-#define DEFINE_DMA_SERIAL_MARLIN(name, n)      \
-  MSerialT name(serial_handles_emergency(n), \
-                &USART##n##_config,          \
-                BOARD_USART##n##_TX_PIN,     \
-                BOARD_USART##n##_RX_PIN,     \
-                M4_DMA1,                     \
-                ((en_dma_channel_t)(n - 1))); // map USART1 to DMA channel 0, USART2 to DMA channel 1, etc.
-
-#define DEFINE_SERIAL_MARLIN(name, n) TERN(SERIAL_DMA, DEFINE_DMA_SERIAL_MARLIN(name, n), DEFINE_IRQ_SERIAL_MARLIN(name, n))
-
-DEFINE_SERIAL_MARLIN(MSerial1, 1);
-DEFINE_SERIAL_MARLIN(MSerial2, 2);
-
-// TODO: remove this warning when SERIAL_DMA has been tested some more
-#if ENABLED(SERIAL_DMA)
-  #warning "SERIAL_DMA may be unstable on HC32F460."
-#endif
+DEFINE_HWSERIAL_MARLIN(MSerial1, 1);
+DEFINE_HWSERIAL_MARLIN(MSerial2, 2);

 //
 // Serial port assertions
@@ -25,42 +25,17 @@
 #include <drivers/usart/Usart.h>

 // Optionally set uart IRQ priority to reduce overflow errors
-//#define UART_RX_IRQ_PRIO 1
-//#define UART_TX_IRQ_PRIO 1
-//#define UART_RX_DMA_IRQ_PRIO 1
+// #define UART_IRQ_PRIO 1

 struct MarlinSerial : public Usart {
-  MarlinSerial(
-    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,
-    en_dma_channel_t rx_dma_channel = DmaCh0
-    #endif
-  ) : Usart(usart_device, tx_pin, rx_pin) {
-    #if ENABLED(SERIAL_DMA)
-      if (dma_unit != nullptr) {
-        enableRxDma(dma_unit, rx_dma_channel);
-      }
-    #endif
-  }
+  MarlinSerial(struct usart_config_t *usart_device, gpio_pin_t tx_pin, gpio_pin_t rx_pin) : Usart(usart_device, tx_pin, rx_pin) {}

-  #if defined(UART_RX_IRQ_PRIO) || defined(UART_TX_IRQ_PRIO) || defined(UART_RX_DMA_IRQ_PRIO)
+  #ifdef UART_IRQ_PRIO
    void setPriority() {
-      #if defined(UART_RX_IRQ_PRIO)
-        NVIC_SetPriority(c_dev()->interrupts.rx_data_available.interrupt_number, UART_RX_IRQ_PRIO);
-        NVIC_SetPriority(c_dev()->interrupts.rx_error.interrupt_number, UART_RX_IRQ_PRIO);
-      #endif
-
-      #if defined(UART_TX_IRQ_PRIO)
-        NVIC_SetPriority(c_dev()->interrupts.tx_buffer_empty.interrupt_number, UART_TX_IRQ_PRIO);
-        NVIC_SetPriority(c_dev()->interrupts.tx_complete.interrupt_number, UART_TX_IRQ_PRIO);
-      #endif
-
-      #if defined(UART_RX_DMA_IRQ_PRIO) && ENABLED(SERIAL_DMA)
-        NVIC_SetPriority(c_dev()->dma.rx.rx_data_available_dma_btc.interrupt_number, UART_RX_DMA_IRQ_PRIO);
-      #endif
+      NVIC_SetPriority(c_dev()->interrupts.rx_data_available.interrupt_number, UART_IRQ_PRIO);
+      NVIC_SetPriority(c_dev()->interrupts.rx_error.interrupt_number, UART_IRQ_PRIO);
+      NVIC_SetPriority(c_dev()->interrupts.tx_buffer_empty.interrupt_number, UART_IRQ_PRIO);
+      NVIC_SetPriority(c_dev()->interrupts.tx_complete.interrupt_number, UART_IRQ_PRIO);
    }

    void begin(uint32_t baud) {
@@ -72,12 +47,7 @@ struct MarlinSerial : public Usart {
      Usart::begin(baud, config);
      setPriority();
    }
-
-    void begin(uint32_t baud, const stc_usart_uart_init_t *config, const bool rxNoiseFilter = true) {
-      Usart::begin(baud, config, rxNoiseFilter);
-      setPriority();
-    }
-  #endif // UART_RX_IRQ_PRIO || UART_TX_IRQ_PRIO || UART_RX_DMA_IRQ_PRIO
+  #endif
 };

 typedef Serial1Class<MarlinSerial> MSerialT;
@@ -1,75 +0,0 @@
-/**
- * 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
- * to the settings in Configuration.h and Configuration_adv.h.
- */
-#pragma once
-#ifndef _HC32_APP_CONFIG_H_
-#define _HC32_APP_CONFIG_H_
-
-#include "../../inc/MarlinConfigPre.h"
-
-//
-// dev mode
-//
-#if ENABLED(MARLIN_DEV_MODE)
-  #define __DEBUG 1
-  #define __CORE_DEBUG 1
-#endif
-
-//
-// Fault Handlers and Panic
-//
-
-#if ENABLED(POSTMORTEM_DEBUGGING)
-  // disable arduino core fault handler, as we define our own
-  #define CORE_DISABLE_FAULT_HANDLER 1
-#endif
-
-// force-enable panic handler so that we can use our custom one (in MinSerial)
-#define PANIC_ENABLE 1
-
-// use short filenames in ddl debug and core panic output
-#define __DEBUG_SHORT_FILENAMES 1
-#define __PANIC_SHORT_FILENAMES 1
-
-// omit panic messages in core panic output
-#define __OMIT_PANIC_MESSAGE 1
-
-//
-// Usart
-//
-
-// disable serial globals (Serial1, Serial2, ...), as we define our own
-#define DISABLE_SERIAL_GLOBALS 1
-
-// increase the size of the Usart buffers (both RX and TX)
-// 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
-
-// enable support for Usart Clock Divider / Oversampling auto config
-#define USART_AUTO_CLKDIV_OS_CONFIG 1
-
-// enable USART_RX_DMA_SUPPORT core option when SERIAL_DMA is enabled
-#if ENABLED(SERIAL_DMA)
-  #define USART_RX_DMA_SUPPORT 1
-#endif
-
-//
-// Misc.
-//
-
-// redirect printf to host serial
-#define REDIRECT_PRINTF_TO_SERIAL 1
-
-// 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_
@@ -101,14 +101,12 @@ 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, USE_CALIBRATION)
+#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)
 #if ENDSTOPS_INTERRUPTS_COUNT > 10
  #error "Too many endstop interrupts! HC32F460 only supports 10 endstop interrupts."
 #elif ENDSTOPS_INTERRUPTS_COUNT == 0
@@ -20,20 +20,6 @@
 *
 */
 #pragma once
-#include <core_util.h>
-
-#if !defined(ARDUINO_CORE_VERSION_INT) || !defined(GET_VERSION_INT)
-  // version macros were introduced in arduino core version 1.1.0
-  // below that version, we polyfill them
-  #define GET_VERSION_INT(major, minor, patch) ((major * 100000) + (minor * 1000) + patch)
-  #define ARDUINO_CORE_VERSION_INT GET_VERSION_INT(1, 0, 0)
-#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
-  // 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

 #ifndef BOARD_XTAL_FREQUENCY
  #error "BOARD_XTAL_FREQUENCY is required for HC32F460."
@@ -88,20 +74,3 @@
    #error "HC32 HAL uses a custom panic handler. Do not define PANIC_USARTx_TX_PIN."
  #endif
 #endif
-
-#if ENABLED(SERIAL_DMA)
-  #if !defined(USART_RX_DMA_SUPPORT)
-    #error "SERIAL_DMA requires USART_RX_DMA_SUPPORT to be enabled in the arduino core."
-  #endif
-
-  // 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
-
-  #if ARDUINO_CORE_VERSION_INT < GET_VERSION_INT(1, 1, 0)
-    #error "SERIAL_DMA is not supported with arduino core version < 1.1.0."
-  #endif
-#endif
@@ -18,47 +18,41 @@
 */
 #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 isValidPin(P) IS_GPIO_PIN(P)
+#define VALID_PIN(pin) IS_GPIO_PIN(pin)

 // 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 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 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 MULTI_NAME_PAD 21 // Space needed to be pretty if not first name assigned to a pin

@@ -77,14 +71,14 @@
  #define M43_NEVER_TOUCH(Q) (IS_HOST_USART_PIN(Q) || IS_OSC_PIN(Q))
 #endif

-int8_t digitalPinToAnalogIndex(const pin_t pin) {
-  if (!isValidPin(pin)) return -1;
+static pin_t DIGITAL_PIN_TO_ANALOG_PIN(pin_t pin) {
+  if (!VALID_PIN(pin)) return -1;
  const int8_t adc_channel = int8_t(PIN_MAP[pin].adc_info.channel);
  return pin_t(adc_channel);
 }

-bool isAnalogPin(pin_t pin) {
-  if (!isValidPin(pin)) return false;
+static bool IS_ANALOG(pin_t pin) {
+  if (!VALID_PIN(pin)) return false;

  if (PIN_MAP[pin].adc_info.channel != ADC_PIN_INVALID)
    return _GET_MODE(pin) == INPUT_ANALOG && !M43_NEVER_TOUCH(pin);
@@ -92,13 +86,13 @@ bool isAnalogPin(pin_t pin) {
  return false;
 }

-bool getValidPinMode(const pin_t pin) {
-  return isValidPin(pin) && !IS_INPUT(pin);
+static bool GET_PINMODE(const pin_t pin) {
+  return VALID_PIN(pin) && !IS_INPUT(pin);
 }

-bool getPinIsDigitalByIndex(const int16_t index) {
-  const pin_t pin = getPinByIndex(index);
-  return (!isAnalogPin(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));
 }

 /**
@@ -123,7 +117,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 printPinPWM(const pin_t pin) {
+void pwm_details(const pin_t pin) {
  // Get timer assignment for pin
  timera_config_t *unit;
  en_timera_channel_t channel;
@@ -167,7 +161,7 @@ void printPinPWM(const pin_t pin) {
  }
 }

-void printPinPort(pin_t pin) {
+void print_port(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];
@@ -54,7 +54,7 @@
    fn                                              \
  }

-stc_sd_handle_t *handle = nullptr;
+stc_sd_handle_t *handle;

 bool SDIO_Init() {
  // Configure SDIO pins
@@ -66,45 +66,36 @@ bool SDIO_Init() {
  GPIO_SetFunc(BOARD_SDIO_CMD, Func_Sdio);
  GPIO_SetFunc(BOARD_SDIO_DET, Func_Sdio);

-  // If a handle is already initialized, free it before creating a new one
-  // otherwise, we will leak memory, which will eventually crash the system
-  if (handle != nullptr) {
-    delete handle->pstcDmaInitCfg;
-    delete handle->pstcCardInitCfg;
-    delete handle;
-    handle = nullptr;
-  }
-
  // Create DMA configuration
  stc_sdcard_dma_init_t *dmaConf = new stc_sdcard_dma_init_t;
  dmaConf->DMAx = SDIO_DMA_PERIPHERAL;
  dmaConf->enDmaCh = SDIO_DMA_CHANNEL;

-  // Create card configuration
-  // This should be a fairly safe configuration for most cards
-  stc_sdcard_init_t *cardConf = new stc_sdcard_init_t;
-  cardConf->enBusWidth = SdiocBusWidth4Bit;
-  cardConf->enClkFreq = SdiocClk400K;
-  cardConf->enSpeedMode = SdiocNormalSpeedMode;
-  cardConf->pstcInitCfg = nullptr;
-
  // Create handle in DMA mode
  handle = new stc_sd_handle_t;
  handle->SDIOCx = SDIO_PERIPHERAL;
  handle->enDevMode = SdCardDmaMode;
  handle->pstcDmaInitCfg = dmaConf;
-  //handle->pstcCardInitCfg = cardConf; // assigned in SDCARD_Init
+
+  // Create card configuration
+  // This should be a fairly safe configuration for most cards
+  stc_sdcard_init_t cardConf = {
+    .enBusWidth = SdiocBusWidth4Bit,
+    .enClkFreq = SdiocClk400K,
+    .enSpeedMode = SdiocNormalSpeedMode,
+    //.pstcInitCfg = NULL,
+  };

  // Initialize sd card
-  en_result_t rc = SDCARD_Init(handle, cardConf);
+  en_result_t rc = SDCARD_Init(handle, &cardConf);
  if (rc != Ok) printf("SDIO_Init() error (rc=%u)\n", rc);

  return rc == Ok;
 }

 bool SDIO_ReadBlock(uint32_t block, uint8_t *dst) {
-  CORE_ASSERT(handle != nullptr, "SDIO not initialized", return false);
-  CORE_ASSERT(dst != nullptr, "SDIO_ReadBlock dst is NULL", return false);
+  CORE_ASSERT(handle != NULL, "SDIO not initialized");
+  CORE_ASSERT(dst != NULL, "SDIO_ReadBlock dst is NULL");

  WITH_RETRY(SDIO_READ_RETRIES, {
    en_result_t rc = SDCARD_ReadBlocks(handle, block, 1, dst, SDIO_READ_TIMEOUT);
@@ -116,8 +107,8 @@ bool SDIO_ReadBlock(uint32_t block, uint8_t *dst) {
 }

 bool SDIO_WriteBlock(uint32_t block, const uint8_t *src) {
-  CORE_ASSERT(handle != nullptr, "SDIO not initialized", return false);
-  CORE_ASSERT(src != nullptr, "SDIO_WriteBlock src is NULL", return false);
+  CORE_ASSERT(handle != NULL, "SDIO not initialized");
+  CORE_ASSERT(src != NULL, "SDIO_WriteBlock src is NULL");

  WITH_RETRY(SDIO_WRITE_RETRIES, {
    en_result_t rc = SDCARD_WriteBlocks(handle, block, 1, (uint8_t *)src, SDIO_WRITE_TIMEOUT);
@@ -129,12 +120,12 @@ bool SDIO_WriteBlock(uint32_t block, const uint8_t *src) {
 }

 bool SDIO_IsReady() {
-  CORE_ASSERT(handle != nullptr, "SDIO not initialized", return false);
+  CORE_ASSERT(handle != NULL, "SDIO not initialized");
  return bool(handle->stcCardStatus.READY_FOR_DATA);
 }

 uint32_t SDIO_GetCardSize() {
-  CORE_ASSERT(handle != nullptr, "SDIO not initialized", return 0);
+  CORE_ASSERT(handle != NULL, "SDIO not initialized");

  // Multiply number of blocks with block size to get size in bytes
  const uint64_t cardSizeBytes = uint64_t(handle->stcSdCardInfo.u32LogBlockNbr) * uint64_t(handle->stcSdCardInfo.u32LogBlockSize);
@@ -96,44 +96,29 @@ void core_hook_sysclock_init() {
    #endif
  #endif

-  // 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
+  // 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)
-  constexpr stc_clk_sysclk_cfg_t sysClkConf = {
+  stc_clk_sysclk_cfg_t sysClkConf = {
      .enHclkDiv = ClkSysclkDiv1,  // HCLK  = 200 MHz (CPU)
      .enExclkDiv = ClkSysclkDiv2, // EXCLK = 100 MHz (SDIO)
-      .enPclk0Div = ClkSysclkDiv2, // PCLK0 = 100 MHz (Timer6 (not used))
+      .enPclk0Div = ClkSysclkDiv1, // PCLK0 = 200 MHz (Timer6 (not used))
      .enPclk1Div = ClkSysclkDiv4, // PCLK1 = 50 MHz (USART, SPI, I2S, Timer0 (step+temp), TimerA (Servo))
-      .enPclk2Div = ClkSysclkDiv8, // PCLK2 = 25 MHz (ADC)
-      .enPclk3Div = ClkSysclkDiv8, // PCLK3 = 25 MHz (I2C, WDT)
+      .enPclk2Div = ClkSysclkDiv4, // PCLK2 = 50 MHz (ADC)
+      .enPclk3Div = ClkSysclkDiv4, // PCLK3 = 50 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
-  power_mode_update_pre(sysclock);
+  #define POWER_MODE_SYSTEM_CLOCK 200000000 // 200 MHz
+  power_mode_update_pre(POWER_MODE_SYSTEM_CLOCK);

  // Switch to MPLL as sysclk source
  CLK_SetSysClkSource(CLKSysSrcMPLL);

  // Set power mode
-  power_mode_update_post(sysclock);
+  power_mode_update_post(POWER_MODE_SYSTEM_CLOCK);
+  #undef POWER_MODE_SYSTEM_CLOCK
 }

 #endif // ARDUINO_ARCH_HC32
@@ -38,48 +38,44 @@ extern Timer0 step_timer;
 // Timer Configurations
 //

-/**
- * 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
+// 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)

 // Temperature timer
-#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
+#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

 // Stepper timer
-#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
+#define STEP_TIMER_NUM (&step_timer)
+#define STEP_TIMER_PRIORITY DDL_IRQ_PRIORITY_01
+#define STEPPER_TIMER_PRESCALE 16ul

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

 // 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
@@ -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 U8G_SPI_USE_MODE_3
+  #if ANY(FYSETC_MINI_12864, MKS_MINI_12864)
    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 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
+      #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
          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);
@@ -52,7 +52,7 @@ uint8_t MarlinHAL::active_ch = 0;

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

@@ -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 (!isValidPin(pin)) return;
+  if (!VALID_PIN(pin)) return;
  Gpio::setMode(pin, mode);
 }

 void digitalWrite(pin_t pin, uint8_t pin_status) {
-  if (!isValidPin(pin)) return;
+  if (!VALID_PIN(pin)) return;
  Gpio::set(pin, pin_status);
 }

 bool digitalRead(pin_t pin) {
-  if (!isValidPin(pin)) return false;
+  if (!VALID_PIN(pin)) return false;
  return Gpio::get(pin);
 }

 void analogWrite(pin_t pin, int pwm_value) {  // 1 - 254: pwm_value, 0: LOW, 255: HIGH
-  if (!isValidPin(pin)) return;
+  if (!VALID_PIN(pin)) return;
  Gpio::set(pin, pwm_value);
 }

 uint16_t analogRead(pin_t adc_pin) {
-  if (!isValidPin(digitalPinToAnalogIndex(adc_pin))) return 0;
-  return Gpio::get(digitalPinToAnalogIndex(adc_pin));
+  if (!VALID_PIN(DIGITAL_PIN_TO_ANALOG_PIN(adc_pin))) return 0;
+  return Gpio::get(DIGITAL_PIN_TO_ANALOG_PIN(adc_pin));
 }

 char *dtostrf(double __val, signed char __width, unsigned char __prec, char *__s) {
@@ -37,10 +37,7 @@ Timer::Timer() {
 }

 Timer::~Timer() {
-  if (timerid != 0) {
-    timer_delete(timerid);
-    timerid = 0;
-  }
+  timer_delete(timerid);
 }

 void Timer::init(uint32_t sig_id, uint32_t sim_freq, callback_fn* fn) {
@@ -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 a) {
-  return (WITHIN(a, 0, NUM_ANALOG_INPUTS - 1) ? analog_offset + a : P_NC);
+constexpr pin_t analogInputToDigitalPin(const int8_t p) {
+  return (WITHIN(p, 0, NUM_ANALOG_INPUTS) ? analog_offset + p : P_NC);
 }

 // Get the analog index for a digital pin
-constexpr int8_t digitalPinToAnalogIndex(const pin_t pin) {
-  return (WITHIN(pin, analog_offset, NUM_DIGITAL_PINS - 1) ? pin - analog_offset : P_NC);
+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);
 }

 // 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 isValidPin(const pin_t pin) { return WITHIN(pin, 0, NUM_DIGITAL_PINS - 1); }
+constexpr bool VALID_PIN(const pin_t p) { return WITHIN(p, 0, NUM_DIGITAL_PINS); }

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

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

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

 // Parse a G-code word into a pin index
 int16_t PARSED_PIN_INDEX(const char code, const int16_t dval);
@@ -21,7 +21,6 @@
 */

 #ifdef __PLAT_LINUX__
-#ifndef UNIT_TEST

 //#define GPIO_LOGGING // Full GPIO and Positional Logging

@@ -136,5 +135,4 @@ int main() {
  read_serial.join();
 }

-#endif // UNIT_TEST
 #endif // __PLAT_LINUX__
@@ -19,50 +19,30 @@
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 */
-#pragma once

 /**
- * 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)
+ * Support routines for X86_64
+ */
+
+/**
+ * Translation of routines & variables used by pinsDebug.h
 */

 #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(const pin_t) { return -1; }
+constexpr int8_t ADC_pin_mode(pin_t pin) { return -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));
-}
+int8_t get_pin_mode(const pin_t pin) { return VALID_PIN(pin) ? 0 : -1; }

-#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) {
+bool GET_PINMODE(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;
@@ -70,11 +50,11 @@ bool getValidPinMode(const pin_t pin) {
  return (Gpio::getMode(pin) != 0); // Input/output state
 }

-void printPinPWM(const pin_t) {}
+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) {}
 bool pwm_status(const pin_t) { return false; }

-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)
+void print_port(const pin_t) {}
@@ -28,6 +28,12 @@
                        // 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
@@ -82,13 +82,13 @@ extern DefaultSerial1 USBSerial;
  #endif
 #endif

-#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)
+#ifdef MMU2_SERIAL_PORT
+  #if MMU2_SERIAL_PORT == -1
+    #define MMU2_SERIAL USBSerial
+  #elif WITHIN(MMU2_SERIAL_PORT, 0, 3)
+    #define MMU2_SERIAL MSERIAL(MMU2_SERIAL_PORT)
  #else
-    #error "MMU_SERIAL_PORT must be from 0 to 3. You can also use -1 if the board supports Native USB."
+    #error "MMU2_SERIAL_PORT must be from 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 ANY(HAS_DGUS_LCD, EXTENSIBLE_UI)
+  #if HAS_DGUS_LCD
    #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 isValidPin(const pin_t pin) {
+constexpr bool VALID_PIN(const pin_t pin) {
  return LPC176x::pin_is_valid(pin);
 }

 // Get the analog index for a digital pin
-constexpr int8_t digitalPinToAnalogIndex(const pin_t pin) {
+constexpr int8_t DIGITAL_PIN_TO_ANALOG_PIN(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
@@ -146,12 +146,6 @@ 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."
@@ -26,10 +26,8 @@

 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)) {
-    const uint32_t duty = map(invert ? v_size - v : v, 0, v_size, 0, LPC176x::pwm_get_period(pin));
-    LPC176x::pwm_write(pin, duty);
-  }
+  if (LPC176x::pwm_attach_pin(pin))
+    LPC176x::pwm_write_ratio(pin, invert ? 1.0f - (float)v / v_size : (float)v / v_size);  // map 1-254 onto PWM range
 }

 void MarlinHAL::set_pwm_frequency(const pin_t pin, const uint16_t f_desired) {
@@ -66,7 +66,7 @@
 #define _WRITE(IO,V)          WRITE_PIN(IO,V)

 /// toggle a pin
-#define _TOGGLE(IO)           LPC176x::gpio_toggle(IO)
+#define _TOGGLE(IO)           _WRITE(IO, !READ(IO))

 /// set pin as input
 #define _SET_INPUT(IO)        SET_DIR_INPUT(IO)
@@ -19,35 +19,22 @@
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 */
-#pragma once

 /**
- * 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)
+ * Support routines for LPC1768
+ */
+
+/**
+ * Translation of routines & variables used by pinsDebug.h
 */

 #define NUMBER_PINS_TOTAL NUM_DIGITAL_PINS
-#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 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 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
@@ -55,15 +42,15 @@
  #define M43_NEVER_TOUCH(Q) ((Q) == P0_29 || (Q) == P0_30 || (Q) == P2_09)  // USB pins
 #endif

-bool getValidPinMode(const pin_t pin) {
+bool GET_PINMODE(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 getPinIsDigitalByIndex(x) ((bool) pin_array[x].is_digital)
+#define GET_ARRAY_IS_DIGITAL(x) ((bool) pin_array[x].is_digital)

-void printPinPort(const pin_t) {}
-void printPinPWM(const pin_t) {}
+void print_port(const pin_t) {}
+void pwm_details(const pin_t) {}
 bool pwm_status(const pin_t) { return false; }
@@ -28,13 +28,12 @@
                        // 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
+/** 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 */
 #ifndef SD_SCK_PIN
  #define SD_SCK_PIN        P0_15
 #endif
@@ -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 U8G_SPI_USE_MODE_3
+  #if ANY(FYSETC_MINI_12864, MKS_MINI_12864)
    swSpiTransfer_mode_3(val, SPI_speed, clockPin, -1, dataPin);
  #else
    swSpiTransfer_mode_0(val, SPI_speed, clockPin, -1, dataPin);
@@ -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 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
+      #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
          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);
@@ -13,9 +13,9 @@ if pioutil.is_pio_build():
    target_drive = "REARM"

    import platform
-    current_OS = platform.system()

-    env = pioutil.env
+    current_OS = platform.system()
+    Import("env")

    def print_error(e):
        print('\nUnable to find destination disk (%s)\n' \
@@ -87,11 +87,11 @@ extern MSerialT serial_stream_3;
  #endif
 #endif

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

@@ -25,11 +25,11 @@
 #include "../../inc/MarlinConfig.h"
 #include "pinsDebug.h"

-int8_t ADC_pin_mode(const pin_t) { return -1; }
+int8_t ADC_pin_mode(pin_t pin) { return -1; }

-int8_t get_pin_mode(const pin_t pin) { return isValidPin(pin) ? 0 : -1; }
+int8_t get_pin_mode(const pin_t pin) { return VALID_PIN(pin) ? 0 : -1; }

-bool getValidPinMode(const pin_t pin) {
+bool GET_PINMODE(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,13 +37,12 @@ bool getValidPinMode(const pin_t pin) {
  return (Gpio::getMode(pin) != 0); // Input/output state
 }

-// 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_ARRAY_IS_DIGITAL(const pin_t pin) {
+  return !IS_ANALOG(pin) || get_pin_mode(pin) != ADC_pin_mode(pin);
 }

-void printPinPort(const pin_t) {}
-void printPinPWM(const pin_t) {}
+void print_port(const pin_t) {}
+void pwm_details(const pin_t) {}
 bool pwm_status(const pin_t) { return false; }

 #endif
@@ -19,43 +19,30 @@
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 */
+
+/**
+ * Support routines for X86_64
+ */
 #pragma once

 /**
- * 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)
+ * Translation of routines & variables used by pinsDebug.h
 */

 #define NUMBER_PINS_TOTAL NUM_DIGITAL_PINS
-#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 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

 // Active ADC function/mode/code values for PINSEL registers
-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);
+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);
 bool pwm_status(const pin_t);
@@ -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 U8G_SPI_USE_MODE_3
+  #if ANY(FYSETC_MINI_12864, MKS_MINI_12864)
    swSpiTransfer_mode_3(val, SPI_speed, clockPin, -1, dataPin);
  #else
    swSpiTransfer_mode_0(val, SPI_speed, clockPin, -1, dataPin);
@@ -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 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
+      #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
          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);
@@ -1,188 +0,0 @@
-/**
- * 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__
@@ -1,250 +0,0 @@
-/**
- * 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);
-};
@@ -1,69 +0,0 @@
-/**
- * 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__
@@ -1,228 +0,0 @@
-/**
- * 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__
@@ -1,39 +0,0 @@
-/**
- * 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__
@@ -1,52 +0,0 @@
-/**
- * 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
-
@@ -1 +0,0 @@
-# RP2040 Hardware Interface
@@ -1,93 +0,0 @@
-/**
- * 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__
@@ -1,77 +0,0 @@
-/**
- * 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
@@ -1,33 +0,0 @@
-/**
- * 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__
@@ -1,29 +0,0 @@
-/**
- * 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);
@@ -1,88 +0,0 @@
-/**
- * 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__
@@ -1,79 +0,0 @@
-/**
- * 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__
@@ -1,60 +0,0 @@
-/**
- * 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));
-}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
InsanityAutomation	4894f35e39	Merge branch 'Trex_2.0.x_Devel' of https://github.com/InsanityAutomation/Marlin into Trex_2.0.x_Devel	2024-06-26 10:53:20 -04:00
InsanityAutomation	11ae89e290	Bump to current	2024-04-15 14:16:11 -04:00
InsanityAutomation	0e1b62e094	Reduce ram and SPI speed	2022-10-23 12:35:46 -04:00
InsanityAutomation	64ffa0d4f4	Merge branch 'bugfix-2.1.x' into Trex_2.0.x_Devel	2022-10-21 15:29:10 -04:00
InsanityAutomation	e6680ddfdf	Update menu_advanced.cpp	2022-10-11 11:37:22 -04:00
InsanityAutomation	5c0696b51a	updates	2022-10-11 11:36:31 -04:00
InsanityAutomation	d438436f0c	Merge branch 'bugfix-2.1.x' into Trex_2.0.x_Devel	2022-10-10 16:36:53 -04:00
InsanityAutomation	2f322e8084	Update Configuration.h	2022-04-09 11:22:20 -04:00
InsanityAutomation	a3a4da5ff2	Merge branch 'Implement-M591-Configurable-Runout-Sensors' into Trex_2.0.x_Devel	2022-04-05 10:41:19 -04:00
InsanityAutomation	bba892e327	Trim output on slim menus	2022-04-03 17:03:52 -04:00
InsanityAutomation	25172b3acf	M591Fixes	2022-04-03 14:54:16 -04:00
InsanityAutomation	0b6ecbd553	Merge branch 'bugfix-2.0.x' into Implement-M591-Configurable-Runout-Sensors	2022-04-03 10:33:18 -04:00
InsanityAutomation	de6246f826	Merge branch 'Implement-M591-Configurable-Runout-Sensors' of https://github.com/InsanityAutomation/Marlin into Implement-M591-Configurable-Runout-Sensors	2022-04-03 10:32:57 -04:00
Scott Lahteine	e813742ae0	Merge branch 'bugfix-2.0.x' into pr/23899	2022-03-29 03:25:51 -05:00
Scott Lahteine	46c8204990	Extend enum	2022-03-27 19:46:47 -05:00
Scott Lahteine	bdfe4ca4d1	Simplify menu items, use enum, adjust settings	2022-03-26 21:10:16 -05:00
Scott Lahteine	6741f5182d	Simplify menu items, use enum	2022-03-26 18:54:02 -05:00
InsanityAutomation	489b75ae3c	Update menu_advanced.cpp	2022-03-15 12:47:14 -04:00
InsanityAutomation	378fc12628	Add runout menu, small fixes	2022-03-15 12:28:19 -04:00
InsanityAutomation	0cedad36d1	Reorganize config options, remove obsolete option.	2022-03-14 09:29:53 -04:00
Scott Lahteine	07b2480d30	glue for CI test	2022-03-14 00:37:41 -05:00
Scott Lahteine	dd88eb56ee	Allow user to change	2022-03-14 00:37:41 -05:00
Scott Lahteine	fc77afd93e	misc. cleanup	2022-03-14 00:37:41 -05:00
InsanityAutomation	26af3e70bc	Remove obsolete state from tests	2022-03-13 19:51:12 -04:00
InsanityAutomation	0c15e8e751	Fix up pause trigger, adjust config options minor changes	2022-03-13 18:57:24 -04:00
InsanityAutomation	639a2dc0b3	M591 Cleanup and tweaks	2022-03-13 13:48:33 -04:00
InsanityAutomation	91a094d8cb	Update Configuration.h	2022-03-12 15:55:57 -05:00
InsanityAutomation	66efa0b09b	Initial commit - Flexible Runout Configuration M591	2022-03-12 15:54:07 -05:00
InsanityAutomation	3226adf2a6	Update Configuration.h	2022-03-08 17:54:24 -05:00
InsanityAutomation	29822ee60e	Update Configuration_adv.h	2022-03-08 17:54:22 -05:00
InsanityAutomation	442d28485e	Merge branch 'bugfix-2.0.x' into Trex_2.0.x_Devel	2022-03-08 17:32:43 -05:00
InsanityAutomation	29f85afe50	Update settings.cpp	2021-10-14 18:48:59 -04:00
InsanityAutomation	c653a0f423	Merge branch 'BLTouch-HS-Mode-EEPROM' into Trex_2.0.x_Devel	2021-10-14 18:33:57 -04:00
InsanityAutomation	1fab2ef94f	Update menu_tramming.cpp	2021-10-14 14:01:42 -04:00
InsanityAutomation	102c43dcd5	Update G35.cpp	2021-10-14 13:50:56 -04:00
InsanityAutomation	5284f45c62	Update menu_tramming.cpp	2021-10-14 13:41:31 -04:00
InsanityAutomation	9aaa7b1100	Add missing include	2021-10-14 13:34:31 -04:00
Scott Lahteine	a6c4c5a3f7	Update motion.cpp	2021-10-12 22:22:15 -05:00
Scott Lahteine	78c57f2847	Update menu_tramming.cpp	2021-10-12 22:21:43 -05:00
Scott Lahteine	90b0be5e12	Merge 'upstream/bugfix-2.0.x' into pr/22916	2021-10-12 21:45:54 -05:00
Scott Lahteine	c24456353f	Merge 'upstream/bugfix-2.0.x' into pr/22916	2021-10-12 20:20:28 -05:00
InsanityAutomation	9a9a112673	Simplify macro	2021-10-11 22:07:45 -04:00
Scott Lahteine	0977129353	Update planner.cpp	2021-10-11 19:31:52 -04:00
InsanityAutomation	ffa8e0ce60	potentially fix multi nozzle duplication as well	2021-10-11 19:31:42 -04:00
InsanityAutomation	cbaf1af0fe	Followup to IDEX fix	2021-10-10 19:51:56 -04:00
Scott Lahteine	ec7a4eb69e	clean up and fix	2021-10-09 18:57:38 -05:00
InsanityAutomation	4f62ae9764	Return on mode change without deploying	2021-10-09 14:07:11 -04:00
InsanityAutomation	b8dfc53693	Return on mode change without deploying	2021-10-09 14:07:02 -04:00
InsanityAutomation	a30ae0aeca	BLTouch High Speed EEPROM Control	2021-10-09 13:58:45 -04:00
InsanityAutomation	0cc6955ab7	BLTouch High Speed EEPROM Control	2021-10-09 13:58:25 -04:00
InsanityAutomation	32e8f90271	Fix Delay definitions	2021-10-09 11:58:54 -04:00
InsanityAutomation	8b10b829fd	Fix IDEX Mode Positioning	2021-10-09 11:58:45 -04:00
InsanityAutomation	eab8ad6b16	Merge branch 'bugfix-2.0.x' into Trex_2.0.x_Devel	2021-10-09 10:58:30 -04:00
InsanityAutomation	35180fedd8	Merge branch 'bugfix-2.0.x' into Trex_2.0.x_Devel	2021-08-28 14:06:37 -04:00
InsanityAutomation	4ddd6d27c1	trim ram	2021-08-08 14:29:24 -04:00
InsanityAutomation	5b6317dd5b	Update Configuration_adv.h	2021-08-06 20:11:23 -04:00
InsanityAutomation	125e537dd1	Update Configuration.h	2021-08-06 13:10:05 -04:00
InsanityAutomation	1055cd4efa	Merge branch 'bugfix-2.0.x' into Trex_2.0.x_Devel	2021-08-05 22:19:49 -04:00
InsanityAutomation	9b6037515f	Update Configuration.h	2021-07-31 14:47:58 -04:00
InsanityAutomation	6bdc99be5f	Merge branch 'bugfix-2.0.x' into Trex_2.0.x_Devel	2021-07-31 14:38:43 -04:00
InsanityAutomation	d6abfd2523	Fix move directly after G28X	2021-01-01 18:50:47 -05:00
InsanityAutomation	4f0615be7b	Merge branch 'bugfix-2.0.x' into Trex_2.0.x_Devel	2021-01-01 18:50:31 -05:00
InsanityAutomation	dd345679d3	Add display timings for new supplier	2020-11-21 15:16:47 -05:00
InsanityAutomation	b59301894a	Merge branch 'bugfix-2.0.x' into Trex_2.0.x_Devel	2020-11-21 15:09:26 -05:00
InsanityAutomation	3165043527	Merge branch 'bugfix-2.0.x' of https://github.com/MarlinFirmware/Marlin into bugfix-2.0.x	2020-11-21 14:33:24 -05:00
Luu Lac	cd3bf4c766	Fix "autotune" LCD message (#20127 )	2020-11-13 18:48:59 -06:00
Scott Lahteine	30162df320	Optimize M360	2020-11-13 18:47:34 -06:00
InsanityAutomation	2d160b8461	force set directions on all blocks in stepper isr	2020-10-22 09:20:37 -04:00
InsanityAutomation	aa5a7f5c13	Add SKR12Pro Support	2020-10-22 09:19:44 -04:00
InsanityAutomation	e4e9915d84	Update Configuration_adv.h	2020-10-22 09:18:30 -04:00
InsanityAutomation	8fe3650376	Bump to head, fix compile errors	2020-10-22 09:18:30 -04:00
InsanityAutomation	23d024309e	Update runout.cpp	2020-10-22 09:18:30 -04:00
InsanityAutomation	62465cdf23	Disable mesh validation pattern for UBL builds to fit	2020-10-22 09:18:00 -04:00
InsanityAutomation	9eb4fc1cfd	Update Configuration_adv.h	2020-10-22 09:18:00 -04:00
InsanityAutomation	40de56b58b	Bump to head, fix compile errors	2020-10-22 09:18:00 -04:00
InsanityAutomation	4a56689801	Merge branch 'bugfix-2.0.x' of https://github.com/MarlinFirmware/Marlin into bugfix-2.0.x	2020-10-22 09:13:59 -04:00
Scott Lahteine	0216e032be	Host prompt followup	2020-10-19 04:34:14 -05:00
Scott Lahteine	2d8aa0cea1	Tweak a host prompt call	2020-10-19 04:25:48 -05:00