Fit task code for updated Max7219

Max7219 RTOS changes
Add M101 command for RTOS
2018-09-10 04:16:25 -05:00 · 2018-09-10 04:14:37 -05:00 · 2018-09-10 04:12:01 -05:00 · 2018-09-10 04:12:01 -05:00 · 2018-09-10 04:11:42 -05:00
1941 changed files with 379413 additions and 491376 deletions
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -0,0 +1,293 @@
+# Python CircleCI 2.0 configuration file
+#
+# Check https://circleci.com/docs/2.0/language-python/ for more details
+#
+version: 2
+jobs:
+  build:
+    docker:
+      # specify the version you desire here
+      # use `-browsers` prefix for selenium tests, e.g. `3.6.1-browsers`
+      - image: circleci/python:2.7.13
+
+      # Specify service dependencies here if necessary
+      # CircleCI maintains a library of pre-built images
+      # documented at https://circleci.com/docs/2.0/circleci-images/
+      # - image: circleci/postgres:9.4
+    environment:
+      TEST_PLATFORM: "-e megaatmega2560"
+
+    working_directory: ~/Marlin
+
+    steps:
+      - checkout
+
+      - restore_cache:
+          paths:
+          - ~/.platformio
+          - ~/Marlin/.piolibdeps
+          keys:
+          - v1-dependencies-{{ checksum "~/Marlin/platformio.ini" }}
+          # fallback to using the latest cache if no exact match is found
+          - v1-dependencies-
+
+      - run:
+          name: install dependencies
+          command: |
+            sudo pip install -U platformio
+
+      # run tests!
+      - run:
+          name: run tests
+          command: |
+            #
+            #
+            # Fetch the tag information for the current branch
+            ls -la
+            git fetch origin --tags
+            #
+            # Publish the buildroot script folder
+            chmod +x buildroot/bin/*
+            export PATH=`pwd`/buildroot/bin/:${PATH}
+
+            # Generate custom version include
+            generate_version ./Marlin/src/inc
+            cat ./Marlin/src/inc/_Version.h
+            #
+            # Backup pins_RAMPS.h
+            #
+            cp Marlin/src/pins/pins_RAMPS.h Marlin/src/pins/pins_RAMPS.h.backup
+            #
+
+            env_backup
+
+            #################################
+            # Build all sample configurations
+            #################################
+
+            echo testing megaatmega2560 targets...
+            export TEST_PLATFORM="-e megaatmega2560"
+            restore_configs
+            echo use_example_configs adafruit/ST7565
+            use_example_configs adafruit/ST7565
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs BQ/Hephestos
+            use_example_configs BQ/Hephestos
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs BQ/Hephestos_2
+            use_example_configs BQ/Hephestos_2
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs BQ/WITBOX
+            use_example_configs BQ/WITBOX
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs AliExpress/CL-260
+            use_example_configs AliExpress/CL-260
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs Cartesio
+            use_example_configs Cartesio
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs delta/FLSUN/auto_calibrate
+            use_example_configs delta/FLSUN/auto_calibrate
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs delta/FLSUN/kossel_mini
+            use_example_configs delta/FLSUN/kossel_mini
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs delta/generic
+            use_example_configs delta/generic
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs delta/kossel_mini
+            use_example_configs delta/kossel_mini
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs delta/kossel_xl
+            use_example_configs delta/kossel_xl
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs Felix
+            use_example_configs Felix
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs Felix/DUAL
+            use_example_configs Felix/DUAL
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs gCreate/gMax1.5+
+            use_example_configs gCreate/gMax1.5+
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs Geeetech/GT2560
+            use_example_configs Geeetech/GT2560
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs Geeetech/I3_Pro_X-GT2560
+            use_example_configs Geeetech/I3_Pro_X-GT2560
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs Infitary/i3-M508
+            use_example_configs Infitary/i3-M508
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            #
+            # Disabled due to compile failure on E0_AUTO_FAN_PIN PB8
+            #
+            #  use_example_configs Malyan/M200
+            #  build_marlin_pio ./ ${TEST_PLATFORM}
+            #  restore_configs
+            echo use_example_configs Micromake/C1/basic
+            use_example_configs Micromake/C1/basic
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs Micromake/C1/enhanced
+            use_example_configs Micromake/C1/enhanced
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs RepRapWorld/Megatronics
+            use_example_configs RepRapWorld/Megatronics
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs RigidBot
+            use_example_configs RigidBot
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs SCARA
+            use_example_configs SCARA
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs Velleman/K8200
+            use_example_configs Velleman/K8200
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs Velleman/K8400/Dual-head
+            use_example_configs Velleman/K8400/Dual-head
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs Velleman/K8400
+            use_example_configs Velleman/K8400
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs Wanhao/Duplicator6
+            use_example_configs Wanhao/Duplicator6
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            #
+            # Disabled due to compile failure on https://github.com/stawel/SlowSoftI2CMaster
+            #
+            #  - Requires https://github.com/stawel/SlowSoftI2CMaster
+            #  restore_configs
+            #  use_example_configs wt150
+            #  build_marlin_pio ./ ${TEST_PLATFORM}
+
+
+            echo testing anet10 targets...
+            export TEST_PLATFORM="-e anet10"
+            restore_configs
+            echo use_example_configs Anet/A6
+            use_example_configs Anet/A6
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs Anet/A8
+            use_example_configs Anet/A8
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs Creality/CR-10
+            use_example_configs Creality/CR-10
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs Malyan/M150
+            use_example_configs Malyan/M150
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs Sanguinololu
+            use_example_configs Sanguinololu
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs TinyBoy2
+            use_example_configs TinyBoy2
+            build_marlin_pio ./ ${TEST_PLATFORM}
+
+
+            echo testing rambo targets...
+            export TEST_PLATFORM="-e rambo"
+            restore_configs
+            echo use_example_configs AlephObjects/TAZ4
+            use_example_configs AlephObjects/TAZ4
+            build_marlin_pio ./ ${TEST_PLATFORM}
+
+
+            echo testing teensy20 targets...
+            export TEST_PLATFORM="-e teensy20"
+            #
+            # Disabled due to Z_MIN_PIN related compile failure
+            #
+            #  restore_configs
+            #  use_example_configs delta/kossel_pro
+            #  build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs makibox
+            use_example_configs makibox
+            build_marlin_pio ./ ${TEST_PLATFORM}
+
+
+            echo testing sanguino_atmega644p targets...
+            export TEST_PLATFORM="-e sanguino_atmega644p"
+            restore_configs
+            echo use_example_configs tvrrug/Round2
+            use_example_configs tvrrug/Round2
+            build_marlin_pio ./ ${TEST_PLATFORM}
+
+
+            echo testing LPC1768 targets...
+            export TEST_PLATFORM="-e LPC1768"
+            restore_configs
+            echo use_example_configs FolgerTech/i3-2020
+            use_example_configs FolgerTech/i3-2020
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs Mks/Sbase
+            use_example_configs Mks/Sbase
+            build_marlin_pio ./ ${TEST_PLATFORM}
+
+            #
+            # Disabled due to numerous compile failures
+            #
+            #  echo testing STM32F1 targets...
+            #  export TEST_PLATFORM="-e STM32F1"
+            #  restore_configs
+            #  use_example_configs STM32F10
+            #  build_marlin_pio ./ ${TEST_PLATFORM}
+            #  restore_configs
+            #  use_example_configs stm32f103ret6
+            #  build_marlin_pio ./ ${TEST_PLATFORM}
+
+
+            #
+            # Disabled due do pin related compile failures
+            #
+            #  echo testing DUE targets...
+            #  export TEST_PLATFORM="-e DUE"
+            #  restore_configs
+            #  use_example_configs UltiMachine/Archim2
+            #  build_marlin_pio ./ ${TEST_PLATFORM}
+
+            #
+            # Remove temp files from dependencies tree prior to caching
+            rm -rf ~/Marlin/.piolibdeps/_tmp_*
+
+            #
+            # Restore the environment
+            #
+            env_restore
+
+      - save_cache:
+          paths:
+          - ~/.platformio
+          - ~/Marlin/.piolibdeps
+          key: v1-dependencies-{{ checksum "~/Marlin/platformio.ini" }}
--- a/.editorconfig
+++ b/.editorconfig
@@ -1,19 +0,0 @@
-# editorconfig.org
-root = true
-
-[{*.patch,syntax_test_*}]
-trim_trailing_whitespace = false
-
-[{*.c,*.cpp,*.h}]
-charset = utf-8
-
-[{*.c,*.cpp,*.h,Makefile}]
-trim_trailing_whitespace = true
-insert_final_newline = true
-end_of_line = lf
-indent_style = space
-indent_size = 2
-
-[{*.py,*.conf,*.sublime-project}]
-indent_style = tab
-indent_size = 4
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -1,3 +0,0 @@
-github: [thinkyhead]
-patreon: thinkyhead
-custom: ["http://www.thinkyhead.com/donate-to-marlin"]
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -1,43 +0,0 @@
---
-name: Bug report
-about: Report a bug in Marlin
-title: "[BUG] (short description)"
-labels: ''
-assignees: ''
-
---
-
-<!--
-
-Have you read Marlin's Code of Conduct? By filing an Issue, you are expected to comply with it, including treating everyone with respect: https://github.com/MarlinFirmware/Marlin/blob/master/.github/code_of_conduct.md
-
-Do you want to ask a question? Are you looking for support? Please don't post here. Instead please use one of the support links at https://github.com/MarlinFirmware/Marlin/issues/new/choose
-
-Before filing an issue be sure to test the "bugfix" branches to see whether the issue has been resolved.
-
-->
-
-### Bug Description
-
-<!-- Description of the bug -->
-
-### My Configurations
-
-**Required:** Please include a ZIP file containing your `Configuration.h` and `Configuration_adv.h` files.
-
-### Steps to Reproduce
-
-<!-- Please describe the steps needed to reproduce the issue -->
-
-1. [First Step]
-2. [Second Step]
-3. [and so on...]
-
-**Expected behavior:** [What you expect to happen]
-
-**Actual behavior:** [What actually happens]
-
-#### Additional Information
-
-* Provide pictures or links to videos that clearly demonstrate the issue.
-* See [How Can I Contribute](#how-can-i-contribute) for additional guidelines.
--- a/.github/ISSUE_TEMPLATE/config.yml
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -1,17 +0,0 @@
-blank_issues_enabled: false
-contact_links:
-  - name: Marlin Documentation
-    url: http://marlinfw.org/
-    about: Lots of documentation on installing and using Marlin.
-  - name: MarlinFirmware Facebook group
-    url: https://www.facebook.com/groups/1049718498464482
-    about: Please ask and answer questions here.
-  - name: Marlin on Discord
-    url: https://discord.gg/n5NJ59y
-    about: Join the Discord server for support and discussion.
-  - name: Marlin Discussion Forum
-    url: http://forums.reprap.org/list.php?415
-    about: A searchable web forum hosted by RepRap dot org.
-  - name: Marlin Videos on YouTube
-    url: https://www.youtube.com/results?search_query=marlin+firmware
-    about: Tutorials and more from Marlin users all around the world. Great for new users!
--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -1,35 +0,0 @@
---
-name: Feature request
-about: Request a Feature
-title: "[FR] (feature request title)"
-labels: ''
-assignees: ''
-
---
-
-<!--
-
-Have you read Marlin's Code of Conduct? By filing an Issue, you are expected to comply with it, including treating everyone with respect: https://github.com/MarlinFirmware/Marlin/blob/master/.github/code_of_conduct.md
-
-Do you want to ask a question? Are you looking for support? Please don't post here. Instead please use one of the support links at https://github.com/MarlinFirmware/Marlin/issues/new/choose
-
-Before filing an issue be sure to test the "bugfix" branches to see whether the issue has been resolved.
-
-->
-
-### Description
-
-<!-- Description of the requested feature -->
-
-### Feature Workflow
-
-<!-- Please describe the feature's behavior, user interaction, etc. -->
-
-1. [First Action]
-2. [Second Action]
-3. [and so on...]
-
-#### Additional Information
-
-* Provide pictures or links that demonstrate a similar feature or concept.
-* See [How Can I Contribute](#how-can-i-contribute) for additional guidelines.
--- a/.github/issue_template.md
+++ b/.github/issue_template.md
@@ -1,16 +1,31 @@
-# NO SUPPORT REQUESTS PLEASE
+<!--

-Support Requests posted here will be automatically closed!
+Have you read Marlin's Code of Conduct? By filing an Issue, you are expected to comply with it, including treating everyone with respect: https://github.com/MarlinFirmware/Marlin/blob/master/.github/code_of_conduct.md

-This Issue Queue is for Marlin bug reports and development-related issues, and we prefer not to handle user-support questions here. See https://github.com/MarlinFirmware/Marlin/blob/1.1.x/.github/contributing.md#i-dont-want-to-read-this-whole-thing-i-just-have-a-question.
+Do you want to ask a question? Are you looking for support? Please don't post here. Instead please use the Marlin Firmware forum at http://forums.reprap.org/list.php?415 or the Marlin Facebook Group https://www.facebook.com/groups/1049718498464482/.

-For best results getting help with configuration and troubleshooting, please use the following resources:
+Before filing an issue be sure to test the 1.1 and/or 2.0 "bugfix" branches to see whether the issue is already addressed.

- RepRap.org Marlin Forum http://forums.reprap.org/list.php?415
- Tom's 3D Forums https://discuss.toms3d.org/
- Facebook Group "Marlin Firmware" https://www.facebook.com/groups/1049718498464482/
- Facebook Group "Marlin Firmware for 3D Printers" https://www.facebook.com/groups/3Dtechtalk/
- Marlin Configuration https://www.youtube.com/results?search_query=marlin+configuration on YouTube
- Marlin Discord server. Join link: https://discord.gg/n5NJ59y
+-->

-After seeking help from the community, if the consensus points to to a bug in Marlin, then you should post a Bug Report at https://github.com/MarlinFirmware/Marlin/issues/new/choose).
+### Description
+
+<!-- Description of the bug or requested feature -->
+
+### Steps to Reproduce
+
+<!-- If this is a Bug Report, please describe the steps needed to reproduce the issue -->
+
+1. [First Step]
+2. [Second Step]
+3. [and so on...]
+
+**Expected behavior:** [What you expect to happen]
+
+**Actual behavior:** [What actually happens]
+
+#### Additional Information
+
+* Include a ZIP file containing your `Configuration.h` and `Configuration_adv.h` files.
+* Provide pictures or links to videos that clearly demonstrate the issue.
+* See [How Can I Contribute](#how-can-i-contribute) for additional guidelines.
--- a/.github/workflows/bad-target.md
+++ b/.github/workflows/bad-target.md
@@ -1,7 +0,0 @@
-Thanks for your contribution! Unfortunately we can't accept PRs directed at release branches. We make patches to the bugfix branches and only later do we push them out as releases.
-
-Please redo this PR starting with the `bugfix-2.0.x` branch and be careful to target `bugfix-2.0.x` when resubmitting the PR.
-
-It may help to set your fork's default branch to `bugfix-2.0.x`.
-
-See [this page](http://marlinfw.org/docs/development/getting_started_pull_requests.html) for full instructions.
--- a/.github/workflows/bump-date.yml
+++ b/.github/workflows/bump-date.yml
@@ -1,34 +0,0 @@
-#
-# bump-date.yml
-# Bump the distribution date once per day
-#
-
-name: Bump Distribution Date
-
-on:
-  schedule:
-    - cron: '0 0 * * *'
-
-jobs:
-  bump_date:
-
-    runs-on: ubuntu-latest
-
-    steps:
-
-    - name: Check out bugfix-2.0.x
-      uses: actions/checkout@v2
-      with:
-        ref: bugfix-2.0.x
-
-    - name: Bump Distribution Date
-      run: |
-        # Inline Bump Script
-        [[ "$GITHUB_REPOSITORY" == "MarlinFirmware/Marlin" ]] || exit 0
-        DIST=$( date +"%Y-%m-%d" )
-        eval "sed -E -i 's/(#define +STRING_DISTRIBUTION_DATE) .*$/\1 \"$DIST\"/g' Marlin/src/inc/Version.h" && \
-        git config user.name "${GITHUB_ACTOR}" && \
-        git config user.email "${GITHUB_ACTOR}@users.noreply.github.com" && \
-        git add . && \
-        git commit -m "[cron] Bump distribution date ($DIST)" && \
-        git push
--- a/.github/workflows/check-pr.yml
+++ b/.github/workflows/check-pr.yml
@@ -1,27 +0,0 @@
-#
-# comment-pr.yml
-# Add a comment to any PR directed to a release branch
-#
-
-name: PR Bad Target
-
-on:
-  pull_request:
-    branches:
-    - 1.0.x
-    - 1.1.x
-    - 2.0.x
-
-jobs:
-  bad_target:
-
-    name: PR Bad Target
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v1
-      - uses: harupy/comment-on-pr@master
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          filename: bad-target.md
--- a/.github/workflows/test-builds.yml
+++ b/.github/workflows/test-builds.yml
@@ -1,104 +0,0 @@
-#
-# test-builds.yml
-# Do test builds to catch compile errors
-#
-
-name: CI
-
-on:
-  pull_request:
-    branches:
-    - bugfix-2.0.x
-    - dev-2.1.x
-    paths-ignore:
-    - config/**
-    - data/**
-    - docs/**
-    - '**/*.md'
-
-jobs:
-  test_builds:
-
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        test-platform:
-        # Base Environments
-
-        - DUE
-        - esp32
-        - linux_native
-        - mega2560
-        - teensy31
-        - teensy35
-        - SAMD51_grandcentral_m4
-
-        # Extended AVR Environments
-
-        - FYSETC_F6_13
-        - mega1280
-        - rambo
-        - sanguino1284p
-        - sanguino644p
-
-        # Extended STM32 Environments
-
-        - STM32F103RC_btt
-        - STM32F103RC_btt_USB
-        - STM32F103RE_btt
-        - STM32F103RE_btt_USB
-        - STM32F103RC_fysetc
-        - jgaurora_a5s_a1
-        - STM32F103VE_longer
-        - STM32F407VE_black
-        - BIGTREE_SKR_PRO
-        - BIGTREE_GTR_V1_0
-        - mks_robin
-        - ARMED
-        - FYSETC_S6
-
-        # Put lengthy tests last
-
-        - LPC1768
-        - LPC1769
-
-        # STM32 with non-STM framework. both broken for now. they should use HAL_STM32 which is working.
-
-        #- STM32F4
-        #- STM32F7
-
-        # Non-working environment tests
-
-        #- BIGTREE_BTT002
-        #- at90usb1286_cdc
-        #- at90usb1286_dfu
-        #- STM32F103CB_malyan
-        #- mks_robin_lite
-        #- mks_robin_mini
-        #- mks_robin_nano
-
-    steps:
-
-    - name: Select Python 3.7
-      uses: actions/setup-python@v1
-      with:
-        python-version: '3.7' # Version range or exact version of a Python version to use, using semvers version range syntax.
-        architecture: 'x64' # optional x64 or x86. Defaults to x64 if not specified
-
-    - name: Install PlatformIO
-      run: |
-        pip install -U https://github.com/platformio/platformio-core/archive/master.zip
-        platformio update
-
-    - name: Check out the PR
-      uses: actions/checkout@v2
-
-    - name: Run ${{ matrix.test-platform }} Tests
-      run: |
-        # Inline tests script
-        [[ "$GITHUB_REPOSITORY" == "MarlinFirmware/Marlin" ]] || exit 0
-        chmod +x buildroot/bin/*
-        chmod +x buildroot/share/tests/*
-        export PATH=./buildroot/bin/:./buildroot/share/tests/:${PATH}
-        run_tests . ${{ matrix.test-platform }}
--- a/.gitignore
+++ b/.gitignore
@@ -1,9 +1,9 @@
 #
 # Marlin 3D Printer Firmware
-# Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+# Copyright (C) 2017 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 #
 # Based on Sprinter and grbl.
-# Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+# 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
@@ -146,9 +146,6 @@ Marlin/*/*/readme.txt
 Marlin/*/*/*/readme.txt
 Marlin/*/*/*/*/readme.txt

-# Secure Credentials
-Configuration_Secure.h
-
 #Visual Studio
 *.sln
 *.vcxproj
@@ -174,13 +171,3 @@ CMakeListsPrivate.txt

 #CLion
 cmake-build-*
-
-#Eclipse
-.project
-.cproject
-.pydevproject
-.settings
-.classpath
-
-#Python
-__pycache__
--- a/.travis.yml
+++ b/.travis.yml
@@ -0,0 +1,52 @@
+dist: trusty
+sudo: false
+
+language: python
+python:
+  - "2.7"
+
+notifications:
+  email: false
+
+# Cache PlatformIO packages using Travis CI container-based infrastructure
+sudo: false
+cache:
+  pip: true
+  directories:
+  - "~/.platformio"
+
+env:
+  - TEST_PLATFORM="megaatmega2560"
+  - TEST_PLATFORM="LPC1768"
+  - TEST_PLATFORM="DUE"
+  - TEST_PLATFORM="STM32F1"
+  - TEST_PLATFORM="teensy35"
+
+before_install:
+  #
+  # Fetch the tag information for the current branch
+  - git fetch origin --tags
+  #
+  # Publish the buildroot script folder
+  - chmod +x ${TRAVIS_BUILD_DIR}/buildroot/bin/*
+  - export PATH=${TRAVIS_BUILD_DIR}/buildroot/bin/:${PATH}
+  - chmod +x ${TRAVIS_BUILD_DIR}/buildroot/share/tests/*
+  - export PATH=${TRAVIS_BUILD_DIR}/buildroot/share/tests/:${PATH}
+
+install:
+  #- pip install -U platformio
+  - pip install -U https://github.com/platformio/platformio-core/archive/develop.zip
+
+before_script:
+  # Update PlatformIO packages
+  - platformio update
+  #
+  # Change current working directory to the build dir
+  - cd ${TRAVIS_BUILD_DIR}
+  #
+  # Generate custom version include
+  - generate_version ${TRAVIS_BUILD_DIR}/Marlin/src/inc
+  - cat ${TRAVIS_BUILD_DIR}/Marlin/src/inc/_Version.h
+  #
+script:
+  - start_tests ${TRAVIS_BUILD_DIR} ${TEST_PLATFORM}
--- a/6
+++ b/6
@@ -3,7 +3,7 @@
                    GNU GENERAL PUBLIC LICENSE
                       Version 3, 29 June 2007

- Copyright (c) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

@@ -634,7 +634,7 @@ state the exclusion of warranty; and each file should have at least
 the "copyright" line and a pointer to where the full notice is found.

    {one line to give the program's name and a brief idea of what it does.}
-    Copyright (c) {year}  {name of author}
+    Copyright (C) {year}  {name of author}

    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
@@ -654,7 +654,7 @@ Also add information on how to contact you by electronic and paper mail.
  If the program does terminal interaction, make it output a short
 notice like this when it starts in an interactive mode:

-    {project}  Copyright (c) {year}  {fullname}
+    {project}  Copyright (C) {year}  {fullname}
    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    This is free software, and you are welcome to redistribute it
    under certain conditions; type `show c' for details.
--- a/Marlin/Configuration.h
+++ b/Marlin/Configuration.h
--- a/Marlin/Configuration_adv.h
+++ b/Marlin/Configuration_adv.h
--- a/Marlin/Makefile
+++ b/Marlin/Makefile
@@ -89,11 +89,8 @@ WIRE               ?= 0
 # this defines if U8GLIB is needed (may require RELOC_WORKAROUND)
 U8GLIB             ?= 1

-# this defines whether to include the Trinamic TMCStepper library
-TMC                ?= 1
-
-# this defines whether to include the AdaFruit NeoPixel library
-NEOPIXEL           ?= 0
+# this defines whether to include the Trinamic TMC2630Stepper
+TMC2630            ?= 1

 ############
 # Try to automatically determine whether RELOC_WORKAROUND is needed based
@@ -106,7 +103,7 @@ CC_PATCHLEVEL:=$(shell $(CC) -dM -E - < /dev/null | grep __GNUC_PATCHLEVEL__ | c
 CC_VER:=$(shell echo $$(( $(CC_MAJ) * 10000 + $(CC_MIN) * 100 + $(CC_PATCHLEVEL) )))
 ifeq ($(shell test $(CC_VER) -lt 40901 && echo 1),1)
  @echo This version of GCC is likely broken. Enabling relocation workaround.
-  RELOC_WORKAROUND = 1
+	RELOC_WORKAROUND = 1
 endif

 ############################################################################
@@ -125,371 +122,288 @@ ifeq ($(HARDWARE_MOTHERBOARD),0)
 #

 # MEGA/RAMPS up to 1.2
-else ifeq ($(HARDWARE_MOTHERBOARD),1000)
+else ifeq ($(HARDWARE_MOTHERBOARD),3)

 # RAMPS 1.3 (Power outputs: Hotend, Fan, Bed)
-else ifeq ($(HARDWARE_MOTHERBOARD),1010)
+else ifeq ($(HARDWARE_MOTHERBOARD),33)
 # RAMPS 1.3 (Power outputs: Hotend0, Hotend1, Bed)
-else ifeq ($(HARDWARE_MOTHERBOARD),1011)
+else ifeq ($(HARDWARE_MOTHERBOARD),34)
 # RAMPS 1.3 (Power outputs: Hotend, Fan0, Fan1)
-else ifeq ($(HARDWARE_MOTHERBOARD),1012)
+else ifeq ($(HARDWARE_MOTHERBOARD),35)
 # RAMPS 1.3 (Power outputs: Hotend0, Hotend1, Fan)
-else ifeq ($(HARDWARE_MOTHERBOARD),1013)
+else ifeq ($(HARDWARE_MOTHERBOARD),36)
 # RAMPS 1.3 (Power outputs: Spindle, Controller Fan)
-else ifeq ($(HARDWARE_MOTHERBOARD),1014)
+else ifeq ($(HARDWARE_MOTHERBOARD),38)

 # RAMPS 1.4 (Power outputs: Hotend, Fan, Bed)
-else ifeq ($(HARDWARE_MOTHERBOARD),1020)
+else ifeq ($(HARDWARE_MOTHERBOARD),43)
 # RAMPS 1.4 (Power outputs: Hotend0, Hotend1, Bed)
-else ifeq ($(HARDWARE_MOTHERBOARD),1021)
+else ifeq ($(HARDWARE_MOTHERBOARD),44)
 # RAMPS 1.4 (Power outputs: Hotend, Fan0, Fan1)
-else ifeq ($(HARDWARE_MOTHERBOARD),1022)
+else ifeq ($(HARDWARE_MOTHERBOARD),45)
 # RAMPS 1.4 (Power outputs: Hotend0, Hotend1, Fan)
-else ifeq ($(HARDWARE_MOTHERBOARD),1023)
+else ifeq ($(HARDWARE_MOTHERBOARD),46)
 # RAMPS 1.4 (Power outputs: Spindle, Controller Fan)
-else ifeq ($(HARDWARE_MOTHERBOARD),1024)
+else ifeq ($(HARDWARE_MOTHERBOARD),48)

 # RAMPS Plus 3DYMY (Power outputs: Hotend, Fan, Bed)
-else ifeq ($(HARDWARE_MOTHERBOARD),1030)
+else ifeq ($(HARDWARE_MOTHERBOARD),143)
 # RAMPS Plus 3DYMY (Power outputs: Hotend0, Hotend1, Bed)
-else ifeq ($(HARDWARE_MOTHERBOARD),1031)
+else ifeq ($(HARDWARE_MOTHERBOARD),144)
 # RAMPS Plus 3DYMY (Power outputs: Hotend, Fan0, Fan1)
-else ifeq ($(HARDWARE_MOTHERBOARD),1032)
+else ifeq ($(HARDWARE_MOTHERBOARD),145)
 # RAMPS Plus 3DYMY (Power outputs: Hotend0, Hotend1, Fan)
-else ifeq ($(HARDWARE_MOTHERBOARD),1033)
+else ifeq ($(HARDWARE_MOTHERBOARD),146)
 # RAMPS Plus 3DYMY (Power outputs: Spindle, Controller Fan)
-else ifeq ($(HARDWARE_MOTHERBOARD),1034)
+else ifeq ($(HARDWARE_MOTHERBOARD),148)

 #
 # RAMPS Derivatives - ATmega1280, ATmega2560
 #

 # 3Drag Controller
-else ifeq ($(HARDWARE_MOTHERBOARD),1100)
+else ifeq ($(HARDWARE_MOTHERBOARD),77)
 # Velleman K8200 Controller (derived from 3Drag Controller)
-else ifeq ($(HARDWARE_MOTHERBOARD),1101)
+else ifeq ($(HARDWARE_MOTHERBOARD),78)
 # Velleman K8400 Controller (derived from 3Drag Controller)
-else ifeq ($(HARDWARE_MOTHERBOARD),1102)
+else ifeq ($(HARDWARE_MOTHERBOARD),79)
 # 2PrintBeta BAM&DICE with STK drivers
-else ifeq ($(HARDWARE_MOTHERBOARD),1103)
+else ifeq ($(HARDWARE_MOTHERBOARD),401)
 # 2PrintBeta BAM&DICE Due with STK drivers
-else ifeq ($(HARDWARE_MOTHERBOARD),1104)
+else ifeq ($(HARDWARE_MOTHERBOARD),402)
 # MKS BASE v1.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1105)
-# MKS v1.4 with A4982 stepper drivers
-else ifeq ($(HARDWARE_MOTHERBOARD),1106)
+else ifeq ($(HARDWARE_MOTHERBOARD),40)
 # MKS v1.5 with Allegro A4982 stepper drivers
-else ifeq ($(HARDWARE_MOTHERBOARD),1107)
-# MKS v1.6 with Allegro A4982 stepper drivers
-else ifeq ($(HARDWARE_MOTHERBOARD),1108)
-
+else ifeq ($(HARDWARE_MOTHERBOARD),405)
 # MKS BASE 1.0 with Heroic HR4982 stepper drivers
-else ifeq ($(HARDWARE_MOTHERBOARD),1109)
+else ifeq ($(HARDWARE_MOTHERBOARD),41)
 # MKS GEN v1.3 or 1.4
-else ifeq ($(HARDWARE_MOTHERBOARD),1110)
+else ifeq ($(HARDWARE_MOTHERBOARD),47)
 # MKS GEN L
-else ifeq ($(HARDWARE_MOTHERBOARD),1111)
+else ifeq ($(HARDWARE_MOTHERBOARD),53)
 # zrib V2.0 control board (Chinese knock off RAMPS replica)
-else ifeq ($(HARDWARE_MOTHERBOARD),1112)
-# BigTreeTech or BIQU KFB2.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1113)
+else ifeq ($(HARDWARE_MOTHERBOARD),504)
 # Felix 2.0+ Electronics Board (RAMPS like)
-else ifeq ($(HARDWARE_MOTHERBOARD),1114)
+else ifeq ($(HARDWARE_MOTHERBOARD),37)
 # Invent-A-Part RigidBoard
-else ifeq ($(HARDWARE_MOTHERBOARD),1115)
+else ifeq ($(HARDWARE_MOTHERBOARD),42)
 # Invent-A-Part RigidBoard V2
-else ifeq ($(HARDWARE_MOTHERBOARD),1116)
+else ifeq ($(HARDWARE_MOTHERBOARD),52)
 # Sainsmart 2-in-1 board
-else ifeq ($(HARDWARE_MOTHERBOARD),1117)
+else ifeq ($(HARDWARE_MOTHERBOARD),49)
 # Ultimaker
-else ifeq ($(HARDWARE_MOTHERBOARD),1118)
+else ifeq ($(HARDWARE_MOTHERBOARD),7)
 # Ultimaker (Older electronics. Pre 1.5.4. This is rare)
-else ifeq ($(HARDWARE_MOTHERBOARD),1119)
-  MCU ?= atmega1280
-
+else ifeq ($(HARDWARE_MOTHERBOARD),71)
+MCU ?= atmega1280
 # Azteeg X3
-else ifeq ($(HARDWARE_MOTHERBOARD),1120)
+else ifeq ($(HARDWARE_MOTHERBOARD),67)
 # Azteeg X3 Pro
-else ifeq ($(HARDWARE_MOTHERBOARD),1121)
+else ifeq ($(HARDWARE_MOTHERBOARD),68)
 # Ultimainboard 2.x (Uses TEMP_SENSOR 20)
-else ifeq ($(HARDWARE_MOTHERBOARD),1122)
+else ifeq ($(HARDWARE_MOTHERBOARD),72)
 # Rumba
-else ifeq ($(HARDWARE_MOTHERBOARD),1123)
-# Raise3D Rumba
-else ifeq ($(HARDWARE_MOTHERBOARD),1124)
-# Rapide Lite RL200 Rumba
-else ifeq ($(HARDWARE_MOTHERBOARD),1125)
-# Formbot T-Rex 2 Plus
-else ifeq ($(HARDWARE_MOTHERBOARD),1126)
-# Formbot T-Rex 3
-else ifeq ($(HARDWARE_MOTHERBOARD),1127)
-# Formbot Raptor
-else ifeq ($(HARDWARE_MOTHERBOARD),1128)
-# Formbot Raptor 2
-else ifeq ($(HARDWARE_MOTHERBOARD),1129)
+else ifeq ($(HARDWARE_MOTHERBOARD),80)
 # bq ZUM Mega 3D
-else ifeq ($(HARDWARE_MOTHERBOARD),1130)
+else ifeq ($(HARDWARE_MOTHERBOARD),503)
 # MakeBoard Mini v2.1.2 is a control board sold by MicroMake
-else ifeq ($(HARDWARE_MOTHERBOARD),1131)
+else ifeq ($(HARDWARE_MOTHERBOARD),431)
 # TriGorilla Anycubic version 1.3 based on RAMPS EFB
-else ifeq ($(HARDWARE_MOTHERBOARD),1132)
+else ifeq ($(HARDWARE_MOTHERBOARD),343)
 # TriGorilla Anycubic version 1.4 based on RAMPS EFB
-else ifeq ($(HARDWARE_MOTHERBOARD),1133)
-# TriGorilla Anycubic version 1.4 Rev 1.1
-else ifeq ($(HARDWARE_MOTHERBOARD),1134)
+else ifeq ($(HARDWARE_MOTHERBOARD),443)
 # Creality: Ender-4, CR-8
-else ifeq ($(HARDWARE_MOTHERBOARD),1135)
-# Creality: CR10S, CR20, CR-X
-else ifeq ($(HARDWARE_MOTHERBOARD),1136)
-# Dagoma F5
-else ifeq ($(HARDWARE_MOTHERBOARD),1137)
-# FYSETC F6 1.3
-else ifeq ($(HARDWARE_MOTHERBOARD),1138)
-# FYSETC F6 1.5
-else ifeq ($(HARDWARE_MOTHERBOARD),1139)
-# Duplicator i3 Plus
-else ifeq ($(HARDWARE_MOTHERBOARD),1140)
-# VORON
-else ifeq ($(HARDWARE_MOTHERBOARD),1141)
-# TRONXY V3 1.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1142)
-# Z-Bolt X Series
-else ifeq ($(HARDWARE_MOTHERBOARD),1143)
-# TT OSCAR
-else ifeq ($(HARDWARE_MOTHERBOARD),1144)
-# Overlord/Overlord Pro
-else ifeq ($(HARDWARE_MOTHERBOARD),1145)
-# ADIMLab Gantry v1
-else ifeq ($(HARDWARE_MOTHERBOARD),1146)
-# ADIMLab Gantry v2
-else ifeq ($(HARDWARE_MOTHERBOARD),1147)
-# BIQU Tango V1
-else ifeq ($(HARDWARE_MOTHERBOARD),1148)
-# MKS GEN L V2
-else ifeq ($(HARDWARE_MOTHERBOARD),1149)
-
-#
-# RAMBo and derivatives
-#
-
-# Rambo
-else ifeq ($(HARDWARE_MOTHERBOARD),1200)
-# Mini-Rambo
-else ifeq ($(HARDWARE_MOTHERBOARD),1201)
-# Mini-Rambo 1.0a
-else ifeq ($(HARDWARE_MOTHERBOARD),1202)
-# Einsy Rambo
-else ifeq ($(HARDWARE_MOTHERBOARD),1203)
-# Einsy Retro
-else ifeq ($(HARDWARE_MOTHERBOARD),1204)
-# abee Scoovo X9H
-else ifeq ($(HARDWARE_MOTHERBOARD),1205)
+else ifeq ($(HARDWARE_MOTHERBOARD),243)

 #
 # Other ATmega1280, ATmega2560
 #

 # Cartesio CN Controls V11
-else ifeq ($(HARDWARE_MOTHERBOARD),1300)
+else ifeq ($(HARDWARE_MOTHERBOARD),111)
 # Cartesio CN Controls V12
-else ifeq ($(HARDWARE_MOTHERBOARD),1301)
-# Cartesio CN Controls V15
-else ifeq ($(HARDWARE_MOTHERBOARD),1302)
+else ifeq ($(HARDWARE_MOTHERBOARD),112)
 # Cheaptronic v1.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1303)
+else ifeq ($(HARDWARE_MOTHERBOARD),2)
 # Cheaptronic v2.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1304)
+else ifeq ($(HARDWARE_MOTHERBOARD),21)
 # Makerbot Mightyboard Revision E
-else ifeq ($(HARDWARE_MOTHERBOARD),1305)
+else ifeq ($(HARDWARE_MOTHERBOARD),200)
 # Megatronics
-else ifeq ($(HARDWARE_MOTHERBOARD),1306)
+else ifeq ($(HARDWARE_MOTHERBOARD),70)
 # Megatronics v2.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1307)
+else ifeq ($(HARDWARE_MOTHERBOARD),701)
 # Megatronics v3.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1308)
+else ifeq ($(HARDWARE_MOTHERBOARD),703)
 # Megatronics v3.1
-else ifeq ($(HARDWARE_MOTHERBOARD),1309)
-# Megatronics v3.2
-else ifeq ($(HARDWARE_MOTHERBOARD),1310)
+else ifeq ($(HARDWARE_MOTHERBOARD),704)
+# Rambo
+else ifeq ($(HARDWARE_MOTHERBOARD),301)
+# Mini-Rambo
+else ifeq ($(HARDWARE_MOTHERBOARD),302)
+# Mini-Rambo 1.0a
+else ifeq ($(HARDWARE_MOTHERBOARD),303)
+# Einsy Rambo
+else ifeq ($(HARDWARE_MOTHERBOARD),304)
+# Einsy Retro
+else ifeq ($(HARDWARE_MOTHERBOARD),305)
 # Elefu Ra Board (v3)
-else ifeq ($(HARDWARE_MOTHERBOARD),1311)
+else ifeq ($(HARDWARE_MOTHERBOARD),21)
 # Leapfrog
-else ifeq ($(HARDWARE_MOTHERBOARD),1312)
+else ifeq ($(HARDWARE_MOTHERBOARD),999)
 # Mega controller
-else ifeq ($(HARDWARE_MOTHERBOARD),1313)
-# Geeetech GT2560 Rev B for Mecreator2
-else ifeq ($(HARDWARE_MOTHERBOARD),1314)
+else ifeq ($(HARDWARE_MOTHERBOARD),310)
+# abee Scoovo X9H
+else ifeq ($(HARDWARE_MOTHERBOARD),321)
 # Geeetech GT2560 Rev. A
-else ifeq ($(HARDWARE_MOTHERBOARD),1315)
+else ifeq ($(HARDWARE_MOTHERBOARD),74)
 # Geeetech GT2560 Rev. A+ (with auto level probe)
-else ifeq ($(HARDWARE_MOTHERBOARD),1316)
-# Geeetech GT2560 Rev B for A10(M/D)
-else ifeq ($(HARDWARE_MOTHERBOARD),1317)
-# Geeetech GT2560 Rev B for A20(M/D)
-else ifeq ($(HARDWARE_MOTHERBOARD),1318)
-# Einstart retrofit
-else ifeq ($(HARDWARE_MOTHERBOARD),1319)
-# Wanhao 0ne+ i3 Mini
-else ifeq ($(HARDWARE_MOTHERBOARD),1320)
+else ifeq ($(HARDWARE_MOTHERBOARD),75)

 #
 # ATmega1281, ATmega2561
 #

-# Minitronics v1.0/1.1
-else ifeq ($(HARDWARE_MOTHERBOARD),1400)
-  MCU              ?= atmega1281
-# Silvergate v1.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1401)
-  MCU              ?= atmega1281
+else ifeq ($(HARDWARE_MOTHERBOARD),702)
+MCU              ?= atmega1281
+else ifeq ($(HARDWARE_MOTHERBOARD),25)
+MCU              ?= atmega1281

 #
 # Sanguinololu and Derivatives - ATmega644P, ATmega1284P
 #

 # Sanguinololu < 1.2
-else ifeq ($(HARDWARE_MOTHERBOARD),1500)
-  HARDWARE_VARIANT ?= Sanguino
-  MCU              ?= atmega644p
+else ifeq ($(HARDWARE_MOTHERBOARD),6)
+HARDWARE_VARIANT ?= Sanguino
+MCU              ?= atmega644p
 # Sanguinololu 1.2 and above
-else ifeq ($(HARDWARE_MOTHERBOARD),1501)
-  HARDWARE_VARIANT ?= Sanguino
-  MCU              ?= atmega644p
+else ifeq ($(HARDWARE_MOTHERBOARD),62)
+HARDWARE_VARIANT ?= Sanguino
+MCU              ?= atmega644p
 # Melzi
-else ifeq ($(HARDWARE_MOTHERBOARD),1502)
-  HARDWARE_VARIANT ?= Sanguino
-  MCU              ?= atmega644p
+else ifeq ($(HARDWARE_MOTHERBOARD),63)
+HARDWARE_VARIANT ?= Sanguino
+MCU              ?= atmega644p
 # Melzi with ATmega1284 (MaKr3d version)
-else ifeq ($(HARDWARE_MOTHERBOARD),1503)
-  HARDWARE_VARIANT ?= Sanguino
-  MCU              ?= atmega1284p
+else ifeq ($(HARDWARE_MOTHERBOARD),66)
+HARDWARE_VARIANT ?= Sanguino
+MCU              ?= atmega1284p
 # Melzi Creality3D board (for CR-10 etc)
-else ifeq ($(HARDWARE_MOTHERBOARD),1504)
-  HARDWARE_VARIANT ?= Sanguino
-  MCU              ?= atmega1284p
+else ifeq ($(HARDWARE_MOTHERBOARD),89)
+HARDWARE_VARIANT ?= Sanguino
+MCU              ?= atmega1284p
 # Melzi Malyan M150 board
-else ifeq ($(HARDWARE_MOTHERBOARD),1505)
-  HARDWARE_VARIANT ?= Sanguino
-  MCU              ?= atmega1284p
+else ifeq ($(HARDWARE_MOTHERBOARD),92)
+HARDWARE_VARIANT ?= Sanguino
+MCU              ?= atmega1284p
 # Tronxy X5S
-else ifeq ($(HARDWARE_MOTHERBOARD),1506)
-  HARDWARE_VARIANT ?= Sanguino
-  MCU              ?= atmega1284p
+else ifeq ($(HARDWARE_MOTHERBOARD),505)
+HARDWARE_VARIANT ?= Sanguino
+MCU              ?= atmega1284p
 # STB V1.1
-else ifeq ($(HARDWARE_MOTHERBOARD),1507)
-  HARDWARE_VARIANT ?= Sanguino
-  MCU              ?= atmega1284p
+else ifeq ($(HARDWARE_MOTHERBOARD),64)
+HARDWARE_VARIANT ?= Sanguino
+MCU              ?= atmega1284p
 # Azteeg X1
-else ifeq ($(HARDWARE_MOTHERBOARD),1508)
-  HARDWARE_VARIANT ?= Sanguino
-  MCU              ?= atmega1284p
+else ifeq ($(HARDWARE_MOTHERBOARD),65)
+HARDWARE_VARIANT ?= Sanguino
+MCU              ?= atmega1284p
 # Anet 1.0 (Melzi clone)
-else ifeq ($(HARDWARE_MOTHERBOARD),1509)
-  HARDWARE_VARIANT ?= Sanguino
-  MCU              ?= atmega1284p
+else ifeq ($(HARDWARE_MOTHERBOARD),69)
+HARDWARE_VARIANT ?= Sanguino
+MCU              ?= atmega1284p

 #
 # Other ATmega644P, ATmega644, ATmega1284P
 #

 # Gen3 Monolithic Electronics
-else ifeq ($(HARDWARE_MOTHERBOARD),1600)
-  HARDWARE_VARIANT ?= Sanguino
-  MCU              ?= atmega644p
+else ifeq ($(HARDWARE_MOTHERBOARD),22)
+HARDWARE_VARIANT ?= Sanguino
+MCU              ?= atmega644p
 # Gen3+
-else ifeq ($(HARDWARE_MOTHERBOARD),1601)
-  HARDWARE_VARIANT ?= Sanguino
-  MCU              ?= atmega644p
+else ifeq ($(HARDWARE_MOTHERBOARD),9)
+HARDWARE_VARIANT ?= Sanguino
+MCU              ?= atmega644p
 # Gen6
-else ifeq ($(HARDWARE_MOTHERBOARD),1602)
-  HARDWARE_VARIANT ?= Gen6
-  MCU              ?= atmega644p
+else ifeq ($(HARDWARE_MOTHERBOARD),5)
+HARDWARE_VARIANT ?= Gen6
+MCU              ?= atmega644p
 # Gen6 deluxe
-else ifeq ($(HARDWARE_MOTHERBOARD),1603)
-  HARDWARE_VARIANT ?= Gen6
-  MCU              ?= atmega644p
+else ifeq ($(HARDWARE_MOTHERBOARD),51)
+HARDWARE_VARIANT ?= Gen6
+MCU              ?= atmega644p
 # Gen7 custom (Alfons3 Version)
-else ifeq ($(HARDWARE_MOTHERBOARD),1604)
-  HARDWARE_VARIANT ?= Gen7
-  MCU              ?= atmega644
-  F_CPU            ?= 20000000
+else ifeq ($(HARDWARE_MOTHERBOARD),10)
+HARDWARE_VARIANT ?= Gen7
+MCU              ?= atmega644
+F_CPU            ?= 20000000
 # Gen7 v1.1, v1.2
-else ifeq ($(HARDWARE_MOTHERBOARD),1605)
-  HARDWARE_VARIANT ?= Gen7
-  MCU              ?= atmega644p
-  F_CPU            ?= 20000000
+else ifeq ($(HARDWARE_MOTHERBOARD),11)
+HARDWARE_VARIANT ?= Gen7
+MCU              ?= atmega644p
+F_CPU            ?= 20000000
 # Gen7 v1.3
-else ifeq ($(HARDWARE_MOTHERBOARD),1606)
-  HARDWARE_VARIANT ?= Gen7
-  MCU              ?= atmega644p
-  F_CPU            ?= 20000000
+else ifeq ($(HARDWARE_MOTHERBOARD),12)
+HARDWARE_VARIANT ?= Gen7
+MCU              ?= atmega644p
+F_CPU            ?= 20000000
 # Gen7 v1.4
-else ifeq ($(HARDWARE_MOTHERBOARD),1607)
-  HARDWARE_VARIANT ?= Gen7
-  MCU              ?= atmega1284p
-  F_CPU            ?= 20000000
+else ifeq ($(HARDWARE_MOTHERBOARD),13)
+HARDWARE_VARIANT ?= Gen7
+MCU              ?= atmega1284p
+F_CPU            ?= 20000000
 # Alpha OMCA board
-else ifeq ($(HARDWARE_MOTHERBOARD),1608)
-  HARDWARE_VARIANT ?= SanguinoA
-  MCU              ?= atmega644
+else ifeq ($(HARDWARE_MOTHERBOARD),90)
+HARDWARE_VARIANT ?= SanguinoA
+MCU              ?= atmega644
 # Final OMCA board
-else ifeq ($(HARDWARE_MOTHERBOARD),1609)
-  HARDWARE_VARIANT ?= Sanguino
-  MCU              ?= atmega644p
+else ifeq ($(HARDWARE_MOTHERBOARD),91)
+HARDWARE_VARIANT ?= Sanguino
+MCU              ?= atmega644p
 # Sethi 3D_1
-else ifeq ($(HARDWARE_MOTHERBOARD),1610)
-  HARDWARE_VARIANT ?= Sanguino
-  MCU              ?= atmega644p
+else ifeq ($(HARDWARE_MOTHERBOARD),20)
+HARDWARE_VARIANT ?= Sanguino
+MCU              ?= atmega644p

 #
 # Teensyduino - AT90USB1286, AT90USB1286P
 #

 # Teensylu
-else ifeq ($(HARDWARE_MOTHERBOARD),1700)
-  HARDWARE_VARIANT ?= Teensy
-  MCU              ?= at90usb1286
+else ifeq ($(HARDWARE_MOTHERBOARD),8)
+HARDWARE_VARIANT ?= Teensy
+MCU              ?= at90usb1286
 # Printrboard (AT90USB1286)
-else ifeq ($(HARDWARE_MOTHERBOARD),1701)
-  HARDWARE_VARIANT ?= Teensy
-  MCU              ?= at90usb1286
+else ifeq ($(HARDWARE_MOTHERBOARD),81)
+HARDWARE_VARIANT ?= Teensy
+MCU              ?= at90usb1286
 # Printrboard Revision F (AT90USB1286)
-else ifeq ($(HARDWARE_MOTHERBOARD),1702)
-  HARDWARE_VARIANT ?= Teensy
-  MCU              ?= at90usb1286
+else ifeq ($(HARDWARE_MOTHERBOARD),811)
+HARDWARE_VARIANT ?= Teensy
+MCU              ?= at90usb1286
 # Brainwave (AT90USB646)
-else ifeq ($(HARDWARE_MOTHERBOARD),1703)
-  HARDWARE_VARIANT ?= Teensy
-  MCU              ?= at90usb646
+else ifeq ($(HARDWARE_MOTHERBOARD),82)
+HARDWARE_VARIANT ?= Teensy
+MCU              ?= at90usb646
 # Brainwave Pro (AT90USB1286)
-else ifeq ($(HARDWARE_MOTHERBOARD),1704)
-  HARDWARE_VARIANT ?= Teensy
-  MCU              ?= at90usb1286
+else ifeq ($(HARDWARE_MOTHERBOARD),83)
+HARDWARE_VARIANT ?= Teensy
+MCU              ?= at90usb1286
 # SAV Mk-I (AT90USB1286)
-else ifeq ($(HARDWARE_MOTHERBOARD),1705)
-  HARDWARE_VARIANT ?= Teensy
-  MCU              ?= at90usb1286
+else ifeq ($(HARDWARE_MOTHERBOARD),84)
+HARDWARE_VARIANT ?= Teensy
+MCU              ?= at90usb1286
 # Teensy++2.0 (AT90USB1286)
-else ifeq ($(HARDWARE_MOTHERBOARD),1706)
-  HARDWARE_VARIANT ?= Teensy
-  MCU              ?= at90usb1286
+else ifeq ($(HARDWARE_MOTHERBOARD),85)
+HARDWARE_VARIANT ?= Teensy
+MCU              ?= at90usb1286
 # 5DPrint D8 Driver Board
-else ifeq ($(HARDWARE_MOTHERBOARD),1707)
-  HARDWARE_VARIANT ?= Teensy
-  MCU              ?= at90usb1286
+else ifeq ($(HARDWARE_MOTHERBOARD),88)
+HARDWARE_VARIANT ?= Teensy
+MCU              ?= at90usb1286

-# UltiMachine Archim1 (with DRV8825 drivers)
-else ifeq ($(HARDWARE_MOTHERBOARD),3023)
-  HARDWARE_VARIANT ?= archim
-  MCPU              = cortex-m3
-  F_CPU             = 84000000L
-  IS_MCU            = 0
-# UltiMachine Archim2 (with TMC2130 drivers)
-else ifeq ($(HARDWARE_MOTHERBOARD),3024)
-  HARDWARE_VARIANT ?= archim
-  MCPU              = cortex-m3
-  F_CPU             = 84000000L
-  IS_MCU            = 0
 endif

 # Be sure to regenerate speed_lookuptable.h with create_speed_lookuptable.py
@@ -497,22 +411,9 @@ endif
 # Set to 16Mhz if not yet set.
 F_CPU ?= 16000000

-# Set to microcontroller if IS_MCU not yet set
-IS_MCU ?= 1
-
-ifeq ($(IS_MCU),1)
-  # Set to arduino, ATmega2560 if not yet set.
-  HARDWARE_VARIANT ?= arduino
-  MCU ?= atmega2560
-
-  TOOL_PREFIX = avr
-  MCU_FLAGS   = -mmcu=$(MCU)
-  SIZE_FLAGS  = --mcu=$(MCU) -C
-else
-  TOOL_PREFIX = arm-none-eabi
-  CPU_FLAGS   = -mthumb -mcpu=$(MCPU)
-  SIZE_FLAGS  = -A
-endif
+# Set to arduino, ATmega2560 if not yet set.
+HARDWARE_VARIANT ?= arduino
+MCU ?= atmega2560

 # Arduino contained the main source code for the Arduino
 # Libraries, the "hardware variant" are for boards
@@ -533,19 +434,19 @@ VPATH = .
 VPATH += $(BUILD_DIR)
 VPATH += $(HARDWARE_SRC)

+# U8glib
+VPATH += $(ARDUINO_USER_DIR)/libraries/U8glib
+VPATH += $(ARDUINO_USER_DIR)/libraries/U8glib/clib
+
 ifeq ($(HARDWARE_VARIANT), $(filter $(HARDWARE_VARIANT),arduino Teensy Sanguino))
 VPATH += $(ARDUINO_INSTALL_DIR)/hardware/marlin/avr/libraries/LiquidCrystal/src
 VPATH += $(ARDUINO_INSTALL_DIR)/hardware/marlin/avr/libraries/SPI
 endif

-ifeq ($(IS_MCU),1)
-  VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/cores/arduino
-
-  VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/SPI
-  VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/SPI/src
-  VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/SoftwareSerial/src
-endif
+VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/cores/arduino

+VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/SPI
+VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/libraries/SPI/src
 VPATH += $(ARDUINO_INSTALL_DIR)/libraries/LiquidCrystal/src
 ifeq ($(LIQUID_TWI2), 1)
 VPATH += $(ARDUINO_INSTALL_DIR)/libraries/Wire
@@ -561,90 +462,71 @@ VPATH += $(ARDUINO_INSTALL_DIR)/libraries/Adafruit_NeoPixel
 endif
 ifeq ($(U8GLIB), 1)
 VPATH += $(ARDUINO_INSTALL_DIR)/libraries/U8glib
-VPATH += $(ARDUINO_INSTALL_DIR)/libraries/U8glib/csrc
-VPATH += $(ARDUINO_INSTALL_DIR)/libraries/U8glib/cppsrc
-VPATH += $(ARDUINO_INSTALL_DIR)/libraries/U8glib/fntsrc
+VPATH += $(ARDUINO_INSTALL_DIR)/libraries/U8glib/clib
 endif
-ifeq ($(TMC), 1)
-VPATH += $(ARDUINO_INSTALL_DIR)/libraries/TMCStepper/src
-VPATH += $(ARDUINO_INSTALL_DIR)/libraries/TMCStepper/src/source
+ifeq ($(TMC2630), 1)
+VPATH += $(ARDUINO_INSTALL_DIR)/libraries/TMC2130Stepper/src
+VPATH += $(ARDUINO_INSTALL_DIR)/libraries/TMC2130Stepper/src/source
 endif

 ifeq ($(HARDWARE_VARIANT), arduino)
-  HARDWARE_SUB_VARIANT ?= mega
-  VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/variants/$(HARDWARE_SUB_VARIANT)
-else ifeq ($(HARDWARE_VARIANT), Sanguino)
-  VPATH += $(ARDUINO_INSTALL_DIR)/hardware/marlin/avr/variants/sanguino
-else ifeq ($(HARDWARE_VARIANT), archim)
-  VPATH   += $(ARDUINO_INSTALL_DIR)/packages/ultimachine/hardware/sam/1.6.9-b/system/libsam
-  VPATH   += $(ARDUINO_INSTALL_DIR)/packages/ultimachine/hardware/sam/1.6.9-b/system/CMSIS/CMSIS/Include/
-  VPATH   += $(ARDUINO_INSTALL_DIR)/packages/ultimachine/hardware/sam/1.6.9-b/system/CMSIS/Device/ATMEL/
-  VPATH   += $(ARDUINO_INSTALL_DIR)/packages/ultimachine/hardware/sam/1.6.9-b/cores/arduino
-  VPATH   += $(ARDUINO_INSTALL_DIR)/packages/ultimachine/hardware/sam/1.6.9-b/cores/arduino/avr
-  VPATH   += $(ARDUINO_INSTALL_DIR)/packages/ultimachine/hardware/sam/1.6.9-b/cores/arduino/USB
-  VPATH   += $(ARDUINO_INSTALL_DIR)/packages/ultimachine/hardware/sam/1.6.9-b/libraries/Wire/src
-  VPATH   += $(ARDUINO_INSTALL_DIR)/packages/ultimachine/hardware/sam/1.6.9-b/libraries/SPI/src
-  VPATH   += $(ARDUINO_INSTALL_DIR)/packages/ultimachine/hardware/sam/1.6.9-b/libraries/U8glib/src/clib
-  VPATH   += $(ARDUINO_INSTALL_DIR)/packages/ultimachine/hardware/sam/1.6.9-b/variants/archim
-  LDSCRIPT = $(ARDUINO_INSTALL_DIR)/packages/ultimachine/hardware/sam/1.6.9-b/variants/archim/linker_scripts/gcc/flash.ld
-  LDLIBS   = $(ARDUINO_INSTALL_DIR)/packages/ultimachine/hardware/sam/1.6.9-b/variants/archim/libsam_sam3x8e_gcc_rel.a
+HARDWARE_SUB_VARIANT ?= mega
+VPATH += $(ARDUINO_INSTALL_DIR)/hardware/arduino/avr/variants/$(HARDWARE_SUB_VARIANT)
 else
-  HARDWARE_SUB_VARIANT ?= standard
-  VPATH += $(ARDUINO_INSTALL_DIR)/hardware/$(HARDWARE_VARIANT)/variants/$(HARDWARE_SUB_VARIANT)
+ifeq ($(HARDWARE_VARIANT), Sanguino)
+VPATH += $(ARDUINO_INSTALL_DIR)/hardware/marlin/avr/variants/sanguino
+else
+HARDWARE_SUB_VARIANT ?= standard
+VPATH += $(ARDUINO_INSTALL_DIR)/hardware/$(HARDWARE_VARIANT)/variants/$(HARDWARE_SUB_VARIANT)
+endif
 endif
-
 LIB_SRC = wiring.c \
-  wiring_analog.c wiring_digital.c \
-  wiring_shift.c WInterrupts.c hooks.c
-
-ifeq ($(HARDWARE_VARIANT), archim)
-  LIB_ASRC += wiring_pulse_asm.S
-else
-  LIB_SRC += wiring_pulse.c
-endif
+	wiring_analog.c wiring_digital.c \
+	wiring_pulse.c \
+	wiring_shift.c WInterrupts.c hooks.c

 ifeq ($(HARDWARE_VARIANT), Teensy)
-  LIB_SRC = wiring.c
-  VPATH += $(ARDUINO_INSTALL_DIR)/hardware/teensy/cores/teensy
+LIB_SRC = wiring.c
+VPATH += $(ARDUINO_INSTALL_DIR)/hardware/teensy/cores/teensy
 endif

-LIB_CXXSRC = WMath.cpp WString.cpp Print.cpp SPI.cpp
+LIB_CXXSRC = WMath.cpp WString.cpp Print.cpp SPI.cpp Tone.cpp

 ifeq ($(NEOPIXEL), 1)
-  LIB_CXXSRC += Adafruit_NeoPixel.cpp
+LIB_CXXSRC += Adafruit_NeoPixel.cpp
 endif

 ifeq ($(LIQUID_TWI2), 0)
-  LIB_CXXSRC += LiquidCrystal.cpp
+LIB_CXXSRC += LiquidCrystal.cpp
 else
-  LIB_SRC += twi.c
-  LIB_CXXSRC += Wire.cpp LiquidTWI2.cpp
+LIB_SRC += twi.c
+LIB_CXXSRC += Wire.cpp LiquidTWI2.cpp
 endif

 ifeq ($(WIRE), 1)
-  LIB_SRC += twi.c
-  LIB_CXXSRC += Wire.cpp
+LIB_SRC += twi.c
+LIB_CXXSRC += Wire.cpp
 endif

 ifeq ($(U8GLIB), 1)
-  LIB_CXXSRC += U8glib.cpp
-  LIB_SRC += u8g_ll_api.c u8g_bitmap.c u8g_clip.c u8g_com_null.c u8g_delay.c u8g_page.c u8g_pb.c u8g_pb16h1.c u8g_rect.c u8g_state.c u8g_font.c u8g_font_6x13.c u8g_font_04b_03.c u8g_font_5x8.c
+LIB_CXXSRC += U8glib.cpp
+LIB_SRC += u8g_ll_api.c u8g_bitmap.c u8g_clip.c u8g_com_null.c u8g_delay.c u8g_page.c u8g_pb.c u8g_pb16h1.c u8g_rect.c u8g_state.c u8g_font.c u8g_font_data.c
 endif

-ifeq ($(TMC), 1)
-  LIB_CXXSRC += TMCStepper.cpp COOLCONF.cpp DRV_STATUS.cpp IHOLD_IRUN.cpp CHOPCONF.cpp GCONF.cpp PWMCONF.cpp DRV_CONF.cpp DRVCONF.cpp DRVCTRL.cpp DRVSTATUS.cpp ENCMODE.cpp RAMP_STAT.cpp SGCSCONF.cpp SHORT_CONF.cpp SMARTEN.cpp SW_MODE.cpp SW_SPI.cpp TMC2130Stepper.cpp TMC2208Stepper.cpp TMC2209Stepper.cpp TMC2660Stepper.cpp TMC5130Stepper.cpp TMC5160Stepper.cpp
+ifeq ($(TMC2630), 1)
+LIB_CXXSRC += TMC2130Stepper.cpp TMC2130Stepper_COOLCONF.cpp TMC2130Stepper_DRV_STATUS.cpp TMC2130Stepper_IHOLD_IRUN.cpp TMC2130Stepper_CHOPCONF.cpp TMC2130Stepper_GCONF.cpp  TMC2130Stepper_PWMCONF.cpp SW_SPI.cpp
 endif

 ifeq ($(RELOC_WORKAROUND), 1)
-  LD_PREFIX=-nodefaultlibs
-  LD_SUFFIX=-lm -lgcc -lc -lgcc
+LD_PREFIX=-nodefaultlibs
+LD_SUFFIX=-lm -lgcc -lc -lgcc
 endif

 #Check for Arduino 1.0.0 or higher and use the correct source files for that version
 ifeq ($(shell [ $(ARDUINO_VERSION) -ge 100 ] && echo true), true)
-  LIB_CXXSRC += main.cpp
+LIB_CXXSRC += main.cpp
 else
-  LIB_SRC += pins_arduino.c main.c
+LIB_SRC += pins_arduino.c main.c
 endif

 FORMAT = ihex
@@ -662,81 +544,62 @@ OPT = s
 DEFINES ?=

 # Program settings
-CC = $(AVR_TOOLS_PATH)$(TOOL_PREFIX)-gcc
-CXX = $(AVR_TOOLS_PATH)$(TOOL_PREFIX)-g++
-OBJCOPY = $(AVR_TOOLS_PATH)$(TOOL_PREFIX)-objcopy
-OBJDUMP = $(AVR_TOOLS_PATH)$(TOOL_PREFIX)-objdump
-AR  = $(AVR_TOOLS_PATH)$(TOOL_PREFIX)-ar
-SIZE = $(AVR_TOOLS_PATH)$(TOOL_PREFIX)-size
-NM = $(AVR_TOOLS_PATH)$(TOOL_PREFIX)-nm
+CC = $(AVR_TOOLS_PATH)avr-gcc
+CXX = $(AVR_TOOLS_PATH)avr-g++
+OBJCOPY = $(AVR_TOOLS_PATH)avr-objcopy
+OBJDUMP = $(AVR_TOOLS_PATH)avr-objdump
+AR  = $(AVR_TOOLS_PATH)avr-ar
+SIZE = $(AVR_TOOLS_PATH)avr-size
+NM = $(AVR_TOOLS_PATH)avr-nm
 AVRDUDE = avrdude
 REMOVE = rm -f
 MV = mv -f

 # Place -D or -U options here
-CDEFS    = -DF_CPU=$(F_CPU) ${addprefix -D , $(DEFINES)} -DARDUINO=$(ARDUINO_VERSION)
+CDEFS    = -DF_CPU=$(F_CPU) ${addprefix -D , $(DEFINES)}
 CXXDEFS  = $(CDEFS)

 ifeq ($(HARDWARE_VARIANT), Teensy)
-  CDEFS  += -DUSB_SERIAL
-  LIB_SRC    += usb.c pins_teensy.c
-  LIB_CXXSRC += usb_api.cpp
-
-else ifeq ($(HARDWARE_VARIANT), archim)
-  CDEFS      += -DARDUINO_SAM_ARCHIM -DARDUINO_ARCH_SAM -D__SAM3X8E__ -DUSB_VID=0x27b1 -DUSB_PID=0x0001 -DUSBCON '-DUSB_MANUFACTURER="UltiMachine"' '-DUSB_PRODUCT="Archim"'
-  LIB_CXXSRC += variant.cpp IPAddress.cpp Reset.cpp RingBuffer.cpp Stream.cpp UARTClass.cpp  USARTClass.cpp abi.cpp new.cpp watchdog.cpp CDC.cpp PluggableUSB.cpp  USBCore.cpp
-  LIB_SRC    += cortex_handlers.c iar_calls_sam3.c syscalls_sam3.c dtostrf.c itoa.c
-
-  ifeq ($(U8GLIB), 1)
-    LIB_SRC += u8g_com_api.c u8g_pb32h1.c
-  endif
+CDEFS  += -DUSB_SERIAL
+LIB_SRC    += usb.c pins_teensy.c
+LIB_CXXSRC += usb_api.cpp
 endif

 # Add all the source directories as include directories too
 CINCS = ${addprefix -I ,${VPATH}}
 CXXINCS = ${addprefix -I ,${VPATH}}

-# Silence warnings for library code (won't work for .h files, unfortunately)
-LIBWARN = -w -Wno-packed-bitfield-compat
-
 # Compiler flag to set the C/CPP Standard level.
 CSTANDARD = -std=gnu99
 CXXSTANDARD = -std=gnu++11
 CDEBUG = -g$(DEBUG)
-CWARN   = -Wall -Wstrict-prototypes -Wno-packed-bitfield-compat -Wno-pragmas -Wunused-parameter
-CXXWARN = -Wall                     -Wno-packed-bitfield-compat -Wno-pragmas -Wunused-parameter
-CTUNING = -fsigned-char -funsigned-bitfields -fno-exceptions \
-          -fshort-enums -ffunction-sections -fdata-sections
+CWARN = -Wall -Wstrict-prototypes
+CTUNING = -w -fsigned-char -funsigned-bitfields -fpack-struct \
+	-fshort-enums -ffunction-sections -fdata-sections -flto \
+	-DARDUINO=$(ARDUINO_VERSION)
 ifneq ($(HARDWARE_MOTHERBOARD),)
-  CTUNING += -DMOTHERBOARD=${HARDWARE_MOTHERBOARD}
+CTUNING += -DMOTHERBOARD=${HARDWARE_MOTHERBOARD}
 endif
 #CEXTRA = -Wa,-adhlns=$(<:.c=.lst)
-CXXEXTRA = -fno-use-cxa-atexit -fno-threadsafe-statics -fno-rtti
-CFLAGS := $(CDEBUG) $(CDEFS) $(CINCS) -O$(OPT) $(CEXTRA)   $(CTUNING) $(CSTANDARD)
-CXXFLAGS :=         $(CDEFS) $(CINCS) -O$(OPT) $(CXXEXTRA) $(CTUNING) $(CXXSTANDARD)
-ASFLAGS :=          $(CDEFS)
+CEXTRA = -fno-use-cxa-atexit -fno-threadsafe-statics
+
+CFLAGS := $(CDEBUG) $(CDEFS) $(CINCS) -O$(OPT) $(CWARN) $(CEXTRA) $(CTUNING) $(CSTANDARD)
+CXXFLAGS :=         $(CDEFS) $(CINCS) -O$(OPT) -Wall    $(CEXTRA) $(CTUNING) $(CXXSTANDARD)
 #ASFLAGS = -Wa,-adhlns=$(<:.S=.lst),-gstabs
-ifeq ($(HARDWARE_VARIANT), archim)
-  LD_PREFIX = -Wl,--gc-sections,-Map,Marlin.ino.map,--cref,--check-sections,--entry=Reset_Handler,--unresolved-symbols=report-all,--warn-common,--warn-section-align
-  LD_SUFFIX = $(LDLIBS)
-  LDFLAGS   = -lm -T$(LDSCRIPT) -u _sbrk -u link -u _close -u _fstat -u _isatty -u _lseek -u _read -u _write -u _exit -u kill -u _getpid
-else
-  LD_PREFIX = -Wl,--gc-sections,--relax
-  LDFLAGS   = -lm
-  CTUNING   += -flto
-endif
+LDFLAGS = -lm
+

 # Programming support using avrdude. Settings and variables.
 AVRDUDE_PORT = $(UPLOAD_PORT)
 AVRDUDE_WRITE_FLASH = -Uflash:w:$(BUILD_DIR)/$(TARGET).hex:i
 ifeq ($(shell uname -s), Linux)
-  AVRDUDE_CONF = /etc/avrdude/avrdude.conf
+AVRDUDE_CONF = /etc/avrdude/avrdude.conf
 else
-  AVRDUDE_CONF = $(ARDUINO_INSTALL_DIR)/hardware/tools/avr/etc/avrdude.conf
+AVRDUDE_CONF = $(ARDUINO_INSTALL_DIR)/hardware/tools/avr/etc/avrdude.conf
 endif
 AVRDUDE_FLAGS = -D -C$(AVRDUDE_CONF) \
-  -p$(MCU) -P$(AVRDUDE_PORT) -c$(AVRDUDE_PROGRAMMER) \
-  -b$(UPLOAD_RATE)
+	-p$(MCU) -P$(AVRDUDE_PORT) -c$(AVRDUDE_PROGRAMMER) \
+	-b$(UPLOAD_RATE)

 # Since Marlin 2.0, the source files may be distributed into several
 # different directories, so it is necessary to find them recursively
@@ -756,17 +619,17 @@ LST = $(LIB_ASRC:.S=.lst) $(LIB_CXXSRC:.cpp=.lst) $(LIB_SRC:.c=.lst)

 # Combine all necessary flags and optional flags.
 # Add target processor to flags.
-ALL_CFLAGS   = $(MCU_FLAGS) $(CPU_FLAGS) $(CFLAGS) -I.
-ALL_CXXFLAGS = $(MCU_FLAGS) $(CPU_FLAGS) $(CXXFLAGS)
-ALL_ASFLAGS  = $(MCU_FLAGS) $(CPU_FLAGS) $(ASFLAGS) -x assembler-with-cpp
+ALL_CFLAGS = -mmcu=$(MCU) -I. $(CFLAGS)
+ALL_CXXFLAGS = -mmcu=$(MCU) $(CXXFLAGS)
+ALL_ASFLAGS = -mmcu=$(MCU) -x assembler-with-cpp $(ASFLAGS)

 # set V=1 (eg, "make V=1") to print the full commands etc.
 ifneq ($V,1)
-  Pecho=@echo
-  P=@
+ Pecho=@echo
+ P=@
 else
-  Pecho=@:
-  P=
+ Pecho=@:
+ P=
 endif

 # Create required build hierarchy if it does not exist
@@ -776,10 +639,9 @@ $(shell mkdir -p $(dir $(OBJ)))
 # Default target.
 all: sizeafter

-build: elf hex bin
+build: elf hex

 elf: $(BUILD_DIR)/$(TARGET).elf
-bin: $(BUILD_DIR)/$(TARGET).bin
 hex: $(BUILD_DIR)/$(TARGET).hex
 eep: $(BUILD_DIR)/$(TARGET).eep
 lss: $(BUILD_DIR)/$(TARGET).lss
@@ -796,9 +658,9 @@ ifeq (${AVRDUDE_PROGRAMMER}, arduino)
 	stty -hup < $(UPLOAD_PORT); true
 endif

-# Display size of file.
+	# Display size of file.
 HEXSIZE = $(SIZE) --target=$(FORMAT) $(BUILD_DIR)/$(TARGET).hex
-ELFSIZE = $(SIZE)  $(SIZE_FLAGS) $(BUILD_DIR)/$(TARGET).elf; \
+ELFSIZE = $(SIZE) --mcu=$(MCU) -C $(BUILD_DIR)/$(TARGET).elf; \
          $(SIZE)  $(BUILD_DIR)/$(TARGET).elf
 sizebefore:
 	$P if [ -f $(BUILD_DIR)/$(TARGET).elf ]; then echo; echo $(MSG_SIZE_BEFORE); $(HEXSIZE); echo; fi
@@ -809,10 +671,10 @@ sizeafter: build

 # Convert ELF to COFF for use in debugging / simulating in AVR Studio or VMLAB.
 COFFCONVERT=$(OBJCOPY) --debugging \
-  --change-section-address .data-0x800000 \
-  --change-section-address .bss-0x800000 \
-  --change-section-address .noinit-0x800000 \
-  --change-section-address .eeprom-0x810000
+	--change-section-address .data-0x800000 \
+	--change-section-address .bss-0x800000 \
+	--change-section-address .noinit-0x800000 \
+	--change-section-address .eeprom-0x810000


 coff: $(BUILD_DIR)/$(TARGET).elf
@@ -823,20 +685,16 @@ extcoff: $(TARGET).elf
 	$(COFFCONVERT) -O coff-ext-avr $(BUILD_DIR)/$(TARGET).elf $(TARGET).cof


-.SUFFIXES: .elf .hex .eep .lss .sym .bin
+.SUFFIXES: .elf .hex .eep .lss .sym
 .PRECIOUS: .o

 .elf.hex:
 	$(Pecho) "  COPY  $@"
 	$P $(OBJCOPY) -O $(FORMAT) -R .eeprom $< $@

-.elf.bin:
-	$(Pecho) "  COPY  $@"
-	$P $(OBJCOPY) -O binary -R .eeprom $< $@
-
 .elf.eep:
 	-$(OBJCOPY) -j .eeprom --set-section-flags=.eeprom="alloc,load" \
-    --change-section-lma .eeprom=0 -O $(FORMAT) $< $@
+		--change-section-lma .eeprom=0 -O $(FORMAT) $< $@

 # Create extended listing file from ELF output file.
 .elf.lss:
@@ -846,36 +704,32 @@ extcoff: $(TARGET).elf
 .elf.sym:
 	$(NM) -n $< > $@

-# Link: create ELF output file from library.
+	# Link: create ELF output file from library.

 $(BUILD_DIR)/$(TARGET).elf: $(OBJ) Configuration.h
 	$(Pecho) "  CXX   $@"
-	$P $(CC) $(LD_PREFIX) $(ALL_CXXFLAGS) -o $@ -L. $(OBJ) $(LDFLAGS) $(LD_SUFFIX)
+	$P $(CC) $(LD_PREFIX) $(ALL_CXXFLAGS) -Wl,--gc-sections,--relax -o $@ -L. $(OBJ) $(LDFLAGS) $(LD_SUFFIX)

 # Object files that were found in "src" will be stored in $(BUILD_DIR)
 # in directories that mirror the structure of "src"

 $(BUILD_DIR)/%.o: %.c Configuration.h Configuration_adv.h $(MAKEFILE)
 	$(Pecho) "  CC    $<"
-	$P $(CC) -MMD -c $(ALL_CFLAGS) $(CWARN) $< -o $@
+	$P $(CC) -MMD -c $(ALL_CFLAGS) $< -o $@

 $(BUILD_DIR)/%.o: %.cpp Configuration.h Configuration_adv.h $(MAKEFILE)
 	$(Pecho) "  CXX   $<"
-	$P $(CXX) -MMD -c $(ALL_CXXFLAGS) $(CXXWARN) $< -o $@
+	$P $(CXX) -MMD -c $(ALL_CXXFLAGS) $< -o $@

 # Object files for Arduino libs will be created in $(BUILD_DIR)/arduino

 $(BUILD_DIR)/arduino/%.o: %.c Configuration.h Configuration_adv.h $(MAKEFILE)
 	$(Pecho) "  CC    $<"
-	$P $(CC) -MMD -c $(ALL_CFLAGS) $(LIBWARN) $< -o $@
+	$P $(CC) -MMD -c $(ALL_CFLAGS) $< -o $@

 $(BUILD_DIR)/arduino/%.o: %.cpp Configuration.h Configuration_adv.h $(MAKEFILE)
 	$(Pecho) "  CXX   $<"
-	$P $(CXX) -MMD -c $(ALL_CXXFLAGS)  $(LIBWARN) $< -o $@
-
-$(BUILD_DIR)/arduino/%.o: %.S $(MAKEFILE)
-	$(Pecho) "  CXX   $<"
-	$P $(CXX) -MMD -c $(ALL_ASFLAGS) $< -o $@
+	$P $(CXX) -MMD -c $(ALL_CXXFLAGS) $< -o $@

 # Target: clean project.
 clean:
@@ -883,7 +737,7 @@ clean:
 	$P rm -rf $(BUILD_DIR)


-.PHONY: all build elf hex eep lss sym program coff extcoff clean depend sizebefore sizeafter
+.PHONY:	all build elf hex eep lss sym program coff extcoff clean depend sizebefore sizeafter

 # Automaticaly include the dependency files created by gcc
 -include ${patsubst %.o, %.d, ${OBJ}}
--- a/Marlin/Marlin.ino
+++ b/Marlin/Marlin.ino
@@ -3,7 +3,7 @@

  Marlin Firmware

-  (c) 2011-2019 MarlinFirmware
+  (c) 2011-2018 MarlinFirmware
  Portions of Marlin are (c) by their respective authors.
  All code complies with GPLv2 and/or GPLv3

--- a/Marlin/Version.h
+++ b/Marlin/Version.h
@@ -1,76 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-////////////////////////////
-// VENDOR VERSION EXAMPLE //
-////////////////////////////
-
-/**
- * Marlin release version identifier
- */
-//#define SHORT_BUILD_VERSION "2.0.5.1"
-
-/**
- * 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 " (Github)"
-
-/**
- * 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 "2020-01-31"
-
-/**
- * Defines a generic printer name to be output to the LCD after booting Marlin.
- */
-//#define MACHINE_NAME "3D Printer"
-
-/**
- * The SOURCE_CODE_URL is the location where users will find the Marlin Source
- * Code which is installed on the device. In most cases —unless the manufacturer
- * has a distinct Github fork— the Source Code URL should just be the main
- * Marlin repository.
- */
-//#define SOURCE_CODE_URL "https://github.com/MarlinFirmware/Marlin"
-
-/**
- * Default generic printer UUID.
- */
-//#define DEFAULT_MACHINE_UUID "cede2a2f-41a2-4748-9b12-c55c62f367ff"
-
-/**
- * The WEBSITE_URL is the location where users can get more information such as
- * documentation about a specific Marlin release.
- */
-//#define WEBSITE_URL "http://marlinfw.org"
-
-/**
- * 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
-//#define  USB_DEVICE_MANUFACTURE_NAME    WEBSITE_URL
--- a/Marlin/src/HAL/AVR/HAL.cpp
+++ b/Marlin/src/HAL/AVR/HAL.cpp
@@ -1,79 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifdef __AVR__
-
-#include "../../inc/MarlinConfig.h"
-#include "HAL.h"
-
-// ------------------------
-// Public Variables
-// ------------------------
-
-//uint8_t MCUSR;
-
-// ------------------------
-// Public functions
-// ------------------------
-
-void HAL_init() {
-  // Init Servo Pins
-  #define INIT_SERVO(N) OUT_WRITE(SERVO##N##_PIN, LOW)
-  #if HAS_SERVO_0
-    INIT_SERVO(0);
-  #endif
-  #if HAS_SERVO_1
-    INIT_SERVO(1);
-  #endif
-  #if HAS_SERVO_2
-    INIT_SERVO(2);
-  #endif
-  #if HAS_SERVO_3
-    INIT_SERVO(3);
-  #endif
-}
-
-#if ENABLED(SDSUPPORT)
-
-  #include "../../sd/SdFatUtil.h"
-  int freeMemory() { return SdFatUtil::FreeRam(); }
-
-#else // !SDSUPPORT
-
-extern "C" {
-  extern char __bss_end;
-  extern char __heap_start;
-  extern void* __brkval;
-
-  int freeMemory() {
-    int free_memory;
-    if ((int)__brkval == 0)
-      free_memory = ((int)&free_memory) - ((int)&__bss_end);
-    else
-      free_memory = ((int)&free_memory) - ((int)__brkval);
-    return free_memory;
-  }
-}
-
-#endif // !SDSUPPORT
-
-#endif // __AVR__
--- a/Marlin/src/HAL/AVR/MarlinSerial.h
+++ b/Marlin/src/HAL/AVR/MarlinSerial.h
@@ -1,318 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-/**
- * MarlinSerial.h - Hardware serial library for Wiring
- * Copyright (c) 2006 Nicholas Zambetti.  All right reserved.
- *
- * Modified 28 September 2010 by Mark Sproul
- * Modified 14 February 2016 by Andreas Hardtung (added tx buffer)
- * Modified 01 October 2017 by Eduardo José Tagle (added XON/XOFF)
- * Templatized 01 October 2018 by Eduardo José Tagle to allow multiple instances
- */
-
-#include <WString.h>
-
-#include "../../inc/MarlinConfigPre.h"
-
-#ifndef SERIAL_PORT
-  #define SERIAL_PORT 0
-#endif
-
-#ifndef USBCON
-
-  // The presence of the UBRRH register is used to detect a UART.
-  #define UART_PRESENT(port) ((port == 0 && (defined(UBRRH) || defined(UBRR0H))) || \
-                              (port == 1 && defined(UBRR1H)) || (port == 2 && defined(UBRR2H)) || \
-                              (port == 3 && defined(UBRR3H)))
-
-  // These are macros to build serial port register names for the selected SERIAL_PORT (C preprocessor
-  // requires two levels of indirection to expand macro values properly)
-  #define SERIAL_REGNAME(registerbase,number,suffix) SERIAL_REGNAME_INTERNAL(registerbase,number,suffix)
-  #if SERIAL_PORT == 0 && (!defined(UBRR0H) || !defined(UDR0)) // use un-numbered registers if necessary
-    #define SERIAL_REGNAME_INTERNAL(registerbase,number,suffix) registerbase##suffix
-  #else
-    #define SERIAL_REGNAME_INTERNAL(registerbase,number,suffix) registerbase##number##suffix
-  #endif
-
-  // Registers used by MarlinSerial class (expanded depending on selected serial port)
-
-  // Templated 8bit register (generic)
-  #define UART_REGISTER_DECL_BASE(registerbase, suffix) \
-    template<int portNr> struct R_##registerbase##x##suffix {}
-
-  // Templated 8bit register (specialization for each port)
-  #define UART_REGISTER_DECL(port, registerbase, suffix) \
-    template<> struct R_##registerbase##x##suffix<port> { \
-      constexpr R_##registerbase##x##suffix(int) {} \
-      FORCE_INLINE void operator=(uint8_t newVal) const { SERIAL_REGNAME(registerbase,port,suffix) = newVal; } \
-      FORCE_INLINE operator uint8_t() const { return SERIAL_REGNAME(registerbase,port,suffix); } \
-    }
-
-  // Templated 1bit register (generic)
-  #define UART_BIT_DECL_BASE(registerbase, suffix, bit) \
-    template<int portNr>struct B_##bit##x {}
-
-  // Templated 1bit register (specialization for each port)
-  #define UART_BIT_DECL(port, registerbase, suffix, bit) \
-    template<> struct B_##bit##x<port> { \
-      constexpr B_##bit##x(int) {} \
-      FORCE_INLINE void operator=(int newVal) const { \
-        if (newVal) \
-          SBI(SERIAL_REGNAME(registerbase,port,suffix),SERIAL_REGNAME(bit,port,)); \
-        else \
-          CBI(SERIAL_REGNAME(registerbase,port,suffix),SERIAL_REGNAME(bit,port,)); \
-      } \
-      FORCE_INLINE operator bool() const { return TEST(SERIAL_REGNAME(registerbase,port,suffix),SERIAL_REGNAME(bit,port,)); } \
-    }
-
-  #define UART_DECL_BASE() \
-    UART_REGISTER_DECL_BASE(UCSR,A);\
-    UART_REGISTER_DECL_BASE(UDR,);\
-    UART_REGISTER_DECL_BASE(UBRR,H);\
-    UART_REGISTER_DECL_BASE(UBRR,L);\
-    UART_BIT_DECL_BASE(UCSR,B,RXEN);\
-    UART_BIT_DECL_BASE(UCSR,B,TXEN);\
-    UART_BIT_DECL_BASE(UCSR,A,TXC);\
-    UART_BIT_DECL_BASE(UCSR,B,RXCIE);\
-    UART_BIT_DECL_BASE(UCSR,A,UDRE);\
-    UART_BIT_DECL_BASE(UCSR,A,FE);\
-    UART_BIT_DECL_BASE(UCSR,A,DOR);\
-    UART_BIT_DECL_BASE(UCSR,B,UDRIE);\
-    UART_BIT_DECL_BASE(UCSR,A,RXC);\
-    UART_BIT_DECL_BASE(UCSR,A,U2X)
-
-  #define UART_DECL(port) \
-    UART_REGISTER_DECL(port,UCSR,A);\
-    UART_REGISTER_DECL(port,UDR,);\
-    UART_REGISTER_DECL(port,UBRR,H);\
-    UART_REGISTER_DECL(port,UBRR,L);\
-    UART_BIT_DECL(port,UCSR,B,RXEN);\
-    UART_BIT_DECL(port,UCSR,B,TXEN);\
-    UART_BIT_DECL(port,UCSR,A,TXC);\
-    UART_BIT_DECL(port,UCSR,B,RXCIE);\
-    UART_BIT_DECL(port,UCSR,A,UDRE);\
-    UART_BIT_DECL(port,UCSR,A,FE);\
-    UART_BIT_DECL(port,UCSR,A,DOR);\
-    UART_BIT_DECL(port,UCSR,B,UDRIE);\
-    UART_BIT_DECL(port,UCSR,A,RXC);\
-    UART_BIT_DECL(port,UCSR,A,U2X)
-
-  // Declare empty templates
-  UART_DECL_BASE();
-
-  // And all the specializations for each possible serial port
-  #if UART_PRESENT(0)
-    UART_DECL(0);
-  #endif
-  #if UART_PRESENT(1)
-    UART_DECL(1);
-  #endif
-  #if UART_PRESENT(2)
-    UART_DECL(2);
-  #endif
-  #if UART_PRESENT(3)
-    UART_DECL(3);
-  #endif
-
-  #define DEC 10
-  #define HEX 16
-  #define OCT 8
-  #define BIN 2
-  #define BYTE 0
-
-  // Templated type selector
-  template<bool b, typename T, typename F> struct TypeSelector { typedef T type;} ;
-  template<typename T, typename F> struct TypeSelector<false, T, F> { typedef F type; };
-
-  template<typename Cfg>
-  class MarlinSerial {
-  protected:
-    // Registers
-    static constexpr R_UCSRxA<Cfg::PORT> R_UCSRA = 0;
-    static constexpr R_UDRx<Cfg::PORT>   R_UDR   = 0;
-    static constexpr R_UBRRxH<Cfg::PORT> R_UBRRH = 0;
-    static constexpr R_UBRRxL<Cfg::PORT> R_UBRRL = 0;
-
-    // Bits
-    static constexpr B_RXENx<Cfg::PORT>  B_RXEN  = 0;
-    static constexpr B_TXENx<Cfg::PORT>  B_TXEN  = 0;
-    static constexpr B_TXCx<Cfg::PORT>   B_TXC   = 0;
-    static constexpr B_RXCIEx<Cfg::PORT> B_RXCIE = 0;
-    static constexpr B_UDREx<Cfg::PORT>  B_UDRE  = 0;
-    static constexpr B_FEx<Cfg::PORT>    B_FE    = 0;
-    static constexpr B_DORx<Cfg::PORT>   B_DOR   = 0;
-    static constexpr B_UDRIEx<Cfg::PORT> B_UDRIE = 0;
-    static constexpr B_RXCx<Cfg::PORT>   B_RXC   = 0;
-    static constexpr B_U2Xx<Cfg::PORT>   B_U2X   = 0;
-
-    // Base size of type on buffer size
-    typedef typename TypeSelector<(Cfg::RX_SIZE>256), uint16_t, uint8_t>::type ring_buffer_pos_t;
-
-    struct ring_buffer_r {
-      volatile ring_buffer_pos_t head, tail;
-      unsigned char buffer[Cfg::RX_SIZE];
-    };
-
-    struct ring_buffer_t {
-      volatile uint8_t head, tail;
-      unsigned char buffer[Cfg::TX_SIZE];
-    };
-
-    static ring_buffer_r rx_buffer;
-    static ring_buffer_t tx_buffer;
-    static bool _written;
-
-    static constexpr uint8_t XON_XOFF_CHAR_SENT = 0x80,  // XON / XOFF Character was sent
-                             XON_XOFF_CHAR_MASK = 0x1F;  // XON / XOFF character to send
-
-    // XON / XOFF character definitions
-    static constexpr uint8_t XON_CHAR  = 17, XOFF_CHAR = 19;
-    static uint8_t xon_xoff_state,
-                   rx_dropped_bytes,
-                   rx_buffer_overruns,
-                   rx_framing_errors;
-    static ring_buffer_pos_t rx_max_enqueued;
-
-    static FORCE_INLINE ring_buffer_pos_t atomic_read_rx_head();
-
-    static volatile bool rx_tail_value_not_stable;
-    static volatile uint16_t rx_tail_value_backup;
-
-    static FORCE_INLINE void atomic_set_rx_tail(ring_buffer_pos_t value);
-    static FORCE_INLINE ring_buffer_pos_t atomic_read_rx_tail();
-
-    public:
-
-    FORCE_INLINE static void store_rxd_char();
-    FORCE_INLINE static void _tx_udr_empty_irq();
-
-    public:
-      MarlinSerial() {};
-      static void begin(const long);
-      static void end();
-      static int peek();
-      static int read();
-      static void flush();
-      static ring_buffer_pos_t available();
-      static void write(const uint8_t c);
-      static void flushTX();
-      #ifdef DGUS_SERIAL_PORT
-        static ring_buffer_pos_t get_tx_buffer_free();
-      #endif
-
-      FORCE_INLINE static uint8_t dropped() { return Cfg::DROPPED_RX ? rx_dropped_bytes : 0; }
-      FORCE_INLINE static uint8_t buffer_overruns() { return Cfg::RX_OVERRUNS ? rx_buffer_overruns : 0; }
-      FORCE_INLINE static uint8_t framing_errors() { return Cfg::RX_FRAMING_ERRORS ? rx_framing_errors : 0; }
-      FORCE_INLINE static ring_buffer_pos_t rxMaxEnqueued() { return Cfg::MAX_RX_QUEUED ? rx_max_enqueued : 0; }
-
-      FORCE_INLINE static void write(const char* str) { while (*str) write(*str++); }
-      FORCE_INLINE static void write(const uint8_t* buffer, size_t size) { while (size--) write(*buffer++); }
-      FORCE_INLINE static void print(const String& s) { for (int i = 0; i < (int)s.length(); i++) write(s[i]); }
-      FORCE_INLINE static void print(const char* str) { write(str); }
-
-      static void print(char, int = BYTE);
-      static void print(unsigned char, int = BYTE);
-      static void print(int, int = DEC);
-      static void print(unsigned int, int = DEC);
-      static void print(long, int = DEC);
-      static void print(unsigned long, int = DEC);
-      static void print(double, int = 2);
-
-      static void println(const String& s);
-      static void println(const char[]);
-      static void println(char, int = BYTE);
-      static void println(unsigned char, int = BYTE);
-      static void println(int, int = DEC);
-      static void println(unsigned int, int = DEC);
-      static void println(long, int = DEC);
-      static void println(unsigned long, int = DEC);
-      static void println(double, int = 2);
-      static void println();
-      operator bool() { return true; }
-
-    private:
-      static void printNumber(unsigned long, const uint8_t);
-      static void printFloat(double, uint8_t);
-  };
-
-  template <uint8_t serial>
-  struct MarlinSerialCfg {
-    static constexpr int PORT               = serial;
-    static constexpr unsigned int RX_SIZE   = RX_BUFFER_SIZE;
-    static constexpr unsigned int TX_SIZE   = TX_BUFFER_SIZE;
-    static constexpr bool XONOFF            = ENABLED(SERIAL_XON_XOFF);
-    static constexpr bool EMERGENCYPARSER   = ENABLED(EMERGENCY_PARSER);
-    static constexpr bool DROPPED_RX        = ENABLED(SERIAL_STATS_DROPPED_RX);
-    static constexpr bool RX_OVERRUNS       = ENABLED(SERIAL_STATS_RX_BUFFER_OVERRUNS);
-    static constexpr bool RX_FRAMING_ERRORS = ENABLED(SERIAL_STATS_RX_FRAMING_ERRORS);
-    static constexpr bool MAX_RX_QUEUED     = ENABLED(SERIAL_STATS_MAX_RX_QUEUED);
-  };
-  extern MarlinSerial<MarlinSerialCfg<SERIAL_PORT>> customizedSerial1;
-
-  #ifdef SERIAL_PORT_2
-
-    extern MarlinSerial<MarlinSerialCfg<SERIAL_PORT_2>> customizedSerial2;
-
-  #endif
-
-#endif // !USBCON
-
-#ifdef INTERNAL_SERIAL_PORT
-  template <uint8_t serial>
-  struct MarlinInternalSerialCfg {
-    static constexpr int PORT               = serial;
-    static constexpr unsigned int RX_SIZE   = 32;
-    static constexpr unsigned int TX_SIZE   = 32;
-    static constexpr bool XONOFF            = false;
-    static constexpr bool EMERGENCYPARSER   = false;
-    static constexpr bool DROPPED_RX        = false;
-    static constexpr bool RX_OVERRUNS       = false;
-    static constexpr bool RX_FRAMING_ERRORS = false;
-    static constexpr bool MAX_RX_QUEUED     = false;
-  };
-
-  extern MarlinSerial<MarlinInternalSerialCfg<INTERNAL_SERIAL_PORT>> internalSerial;
-#endif
-
-#ifdef DGUS_SERIAL_PORT
-  template <uint8_t serial>
-  struct MarlinInternalSerialCfg {
-    static constexpr int PORT               = serial;
-    static constexpr unsigned int RX_SIZE   = 128;
-    static constexpr unsigned int TX_SIZE   = 48;
-    static constexpr bool XONOFF            = false;
-    static constexpr bool EMERGENCYPARSER   = false;
-    static constexpr bool DROPPED_RX        = false;
-    static constexpr bool RX_OVERRUNS       = HAS_DGUS_LCD && ENABLED(DGUS_SERIAL_STATS_RX_BUFFER_OVERRUNS);
-    static constexpr bool RX_FRAMING_ERRORS = false;
-    static constexpr bool MAX_RX_QUEUED     = false;
-  };
-
-  extern MarlinSerial<MarlinInternalSerialCfg<DGUS_SERIAL_PORT>> internalDgusSerial;
-#endif
-
-// Use the UART for Bluetooth in AT90USB configurations
-#if defined(USBCON) && ENABLED(BLUETOOTH)
-  extern HardwareSerial bluetoothSerial;
-#endif
--- a/Marlin/src/HAL/AVR/endstop_interrupts.h
+++ b/Marlin/src/HAL/AVR/endstop_interrupts.h
@@ -1,261 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-/**
- * Endstop Interrupts
- *
- * Without endstop interrupts the endstop pins must be polled continually in
- * the temperature-ISR via endstops.update(), most of the time finding no change.
- * With this feature endstops.update() is called only when we know that at
- * least one endstop has changed state, saving valuable CPU cycles.
- *
- * This feature only works when all used endstop pins can generate either an
- * 'external interrupt' or a 'pin change interrupt'.
- *
- * Test whether pins issue interrupts on your board by flashing 'pin_interrupt_test.ino'.
- * (Located in Marlin/buildroot/share/pin_interrupt_test/pin_interrupt_test.ino)
- */
-
-#include "../../module/endstops.h"
-
-#include <stdint.h>
-
-// One ISR for all EXT-Interrupts
-void endstop_ISR() { endstops.update(); }
-
-/**
- * Patch for pins_arduino.h (...\Arduino\hardware\arduino\avr\variants\mega\pins_arduino.h)
- *
- * These macros for the Arduino MEGA do not include the two connected pins on Port J (D14, D15).
- * So we extend them here because these are the normal pins for Y_MIN and Y_MAX on RAMPS.
- * There are more PCI-enabled processor pins on Port J, but they are not connected to Arduino MEGA.
- */
-#if defined(ARDUINO_AVR_MEGA2560) || defined(ARDUINO_AVR_MEGA)
-
-  #define digitalPinHasPCICR(p)   (WITHIN(p, 10, 15) || WITHIN(p, 50, 53) || WITHIN(p, 62, 69))
-
-  #undef  digitalPinToPCICR
-  #define digitalPinToPCICR(p)    (digitalPinHasPCICR(p) ? (&PCICR) : nullptr)
-
-  #undef  digitalPinToPCICRbit
-  #define digitalPinToPCICRbit(p) (WITHIN(p, 10, 13) || WITHIN(p, 50, 53) ? 0 : \
-                                   WITHIN(p, 14, 15) ? 1 : \
-                                   WITHIN(p, 62, 69) ? 2 : \
-                                   0)
-
-  #undef  digitalPinToPCMSK
-  #define digitalPinToPCMSK(p)    (WITHIN(p, 10, 13) || WITHIN(p, 50, 53) ? (&PCMSK0) : \
-                                   WITHIN(p, 14, 15) ? (&PCMSK1) : \
-                                   WITHIN(p, 62, 69) ? (&PCMSK2) : \
-                                   nullptr)
-
-  #undef  digitalPinToPCMSKbit
-  #define digitalPinToPCMSKbit(p) (WITHIN(p, 10, 13) ? ((p) - 6) : \
-                                   (p) == 14 || (p) == 51 ? 2 : \
-                                   (p) == 15 || (p) == 52 ? 1 : \
-                                   (p) == 50 ? 3 : \
-                                   (p) == 53 ? 0 : \
-                                   WITHIN(p, 62, 69) ? ((p) - 62) : \
-                                   0)
-
-#elif defined(__AVR_ATmega164A__) || defined(__AVR_ATmega164P__) || defined(__AVR_ATmega324A__) || \
-      defined(__AVR_ATmega324P__) || defined(__AVR_ATmega324PA__) || defined(__AVR_ATmega324PB__) || \
-      defined(__AVR_ATmega644A__) || defined(__AVR_ATmega644P__) || defined(__AVR_ATmega1284__) || \
-      defined(__AVR_ATmega1284P__)
-
-  #define digitalPinHasPCICR(p)   WITHIN(p, 0, NUM_DIGITAL_PINS)
-
-#else
-
-  #error "Unsupported AVR variant!"
-
-#endif
-
-
-// Install Pin change interrupt for a pin. Can be called multiple times.
-void pciSetup(const int8_t pin) {
-  if (digitalPinHasPCICR(pin)) {
-    SBI(*digitalPinToPCMSK(pin), digitalPinToPCMSKbit(pin));  // enable pin
-    SBI(PCIFR, digitalPinToPCICRbit(pin)); // clear any outstanding interrupt
-    SBI(PCICR, digitalPinToPCICRbit(pin)); // enable interrupt for the group
-  }
-}
-
-// Handlers for pin change interrupts
-#ifdef PCINT0_vect
-  ISR(PCINT0_vect) { endstop_ISR(); }
-#endif
-
-#ifdef PCINT1_vect
-  ISR(PCINT1_vect, ISR_ALIASOF(PCINT0_vect));
-#endif
-
-#ifdef PCINT2_vect
-  ISR(PCINT2_vect, ISR_ALIASOF(PCINT0_vect));
-#endif
-
-#ifdef PCINT3_vect
-  ISR(PCINT3_vect, ISR_ALIASOF(PCINT0_vect));
-#endif
-
-void setup_endstop_interrupts() {
-  #define _ATTACH(P) attachInterrupt(digitalPinToInterrupt(P), endstop_ISR, CHANGE)
-  #if HAS_X_MAX
-    #if (digitalPinToInterrupt(X_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(X_MAX_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(X_MAX_PIN), "X_MAX_PIN is not interrupt-capable");
-      pciSetup(X_MAX_PIN);
-    #endif
-  #endif
-  #if HAS_X_MIN
-    #if (digitalPinToInterrupt(X_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(X_MIN_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(X_MIN_PIN), "X_MIN_PIN is not interrupt-capable");
-      pciSetup(X_MIN_PIN);
-    #endif
-  #endif
-  #if HAS_Y_MAX
-    #if (digitalPinToInterrupt(Y_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Y_MAX_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(Y_MAX_PIN), "Y_MAX_PIN is not interrupt-capable");
-      pciSetup(Y_MAX_PIN);
-    #endif
-  #endif
-  #if HAS_Y_MIN
-    #if (digitalPinToInterrupt(Y_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Y_MIN_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(Y_MIN_PIN), "Y_MIN_PIN is not interrupt-capable");
-      pciSetup(Y_MIN_PIN);
-    #endif
-  #endif
-  #if HAS_Z_MAX
-    #if (digitalPinToInterrupt(Z_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z_MAX_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(Z_MAX_PIN), "Z_MAX_PIN is not interrupt-capable");
-      pciSetup(Z_MAX_PIN);
-    #endif
-  #endif
-  #if HAS_Z_MIN
-    #if (digitalPinToInterrupt(Z_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z_MIN_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(Z_MIN_PIN), "Z_MIN_PIN is not interrupt-capable");
-      pciSetup(Z_MIN_PIN);
-    #endif
-  #endif
-  #if HAS_X2_MAX
-    #if (digitalPinToInterrupt(X2_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(X2_MAX_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(X2_MAX_PIN), "X2_MAX_PIN is not interrupt-capable");
-      pciSetup(X2_MAX_PIN);
-    #endif
-  #endif
-  #if HAS_X2_MIN
-    #if (digitalPinToInterrupt(X2_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(X2_MIN_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(X2_MIN_PIN), "X2_MIN_PIN is not interrupt-capable");
-      pciSetup(X2_MIN_PIN);
-    #endif
-  #endif
-  #if HAS_Y2_MAX
-    #if (digitalPinToInterrupt(Y2_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Y2_MAX_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(Y2_MAX_PIN), "Y2_MAX_PIN is not interrupt-capable");
-      pciSetup(Y2_MAX_PIN);
-    #endif
-  #endif
-  #if HAS_Y2_MIN
-    #if (digitalPinToInterrupt(Y2_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Y2_MIN_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(Y2_MIN_PIN), "Y2_MIN_PIN is not interrupt-capable");
-      pciSetup(Y2_MIN_PIN);
-    #endif
-  #endif
-  #if HAS_Z2_MAX
-    #if (digitalPinToInterrupt(Z2_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z2_MAX_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(Z2_MAX_PIN), "Z2_MAX_PIN is not interrupt-capable");
-      pciSetup(Z2_MAX_PIN);
-    #endif
-  #endif
-  #if HAS_Z2_MIN
-    #if (digitalPinToInterrupt(Z2_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z2_MIN_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(Z2_MIN_PIN), "Z2_MIN_PIN is not interrupt-capable");
-      pciSetup(Z2_MIN_PIN);
-    #endif
-  #endif
-  #if HAS_Z3_MAX
-    #if (digitalPinToInterrupt(Z3_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z3_MAX_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(Z3_MAX_PIN), "Z3_MAX_PIN is not interrupt-capable");
-      pciSetup(Z3_MAX_PIN);
-    #endif
-  #endif
-  #if HAS_Z3_MIN
-    #if (digitalPinToInterrupt(Z3_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z3_MIN_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(Z3_MIN_PIN), "Z3_MIN_PIN is not interrupt-capable");
-      pciSetup(Z3_MIN_PIN);
-    #endif
-  #endif
-  #if HAS_Z4_MAX
-    #if (digitalPinToInterrupt(Z4_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z4_MAX_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(Z4_MAX_PIN), "Z4_MAX_PIN is not interrupt-capable");
-      pciSetup(Z4_MAX_PIN);
-    #endif
-  #endif
-  #if HAS_Z4_MIN
-    #if (digitalPinToInterrupt(Z4_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z4_MIN_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(Z4_MIN_PIN), "Z4_MIN_PIN is not interrupt-capable");
-      pciSetup(Z4_MIN_PIN);
-    #endif
-  #endif
-  #if HAS_Z_MIN_PROBE_PIN
-    #if (digitalPinToInterrupt(Z_MIN_PROBE_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z_MIN_PROBE_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(Z_MIN_PROBE_PIN), "Z_MIN_PROBE_PIN is not interrupt-capable");
-      pciSetup(Z_MIN_PROBE_PIN);
-    #endif
-  #endif
-
-  // If we arrive here without raising an assertion, each pin has either an EXT-interrupt or a PCI.
-}
--- a/Marlin/src/HAL/AVR/fast_pwm.cpp
+++ b/Marlin/src/HAL/AVR/fast_pwm.cpp
@@ -1,282 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#ifdef __AVR__
-
-#include "../../inc/MarlinConfigPre.h"
-
-#if ENABLED(FAST_PWM_FAN) || SPINDLE_LASER_PWM
-
-#include "HAL.h"
-
-struct Timer {
-  volatile uint8_t* TCCRnQ[3];  // max 3 TCCR registers per timer
-  volatile uint16_t* OCRnQ[3];  // max 3 OCR registers per timer
-  volatile uint16_t* ICRn;      // max 1 ICR register per timer
-  uint8_t n;                    // the timer number [0->5]
-  uint8_t q;                    // the timer output [0->2] (A->C)
-};
-
-/**
- * get_pwm_timer
- *  Get the timer information and register of the provided pin.
- *  Return a Timer struct containing this information.
- *  Used by set_pwm_frequency, set_pwm_duty
- */
-Timer get_pwm_timer(const pin_t pin) {
-  uint8_t q = 0;
-  switch (digitalPinToTimer(pin)) {
-    // Protect reserved timers (TIMER0 & TIMER1)
-    #ifdef TCCR0A
-      #if !AVR_AT90USB1286_FAMILY
-        case TIMER0A:
-      #endif
-      case TIMER0B:
-    #endif
-    #ifdef TCCR1A
-      case TIMER1A: case TIMER1B:
-    #endif
-                                        break;
-    #if defined(TCCR2) || defined(TCCR2A)
-      #ifdef TCCR2
-        case TIMER2: {
-          Timer timer = {
-            /*TCCRnQ*/  { &TCCR2, nullptr, nullptr },
-            /*OCRnQ*/   { (uint16_t*)&OCR2, nullptr, nullptr },
-            /*ICRn*/      nullptr,
-            /*n, q*/      2, 0
-          };
-        }
-      #elif defined(TCCR2A)
-        #if ENABLED(USE_OCR2A_AS_TOP)
-          case TIMER2A:   break; // protect TIMER2A
-          case TIMER2B: {
-            Timer timer = {
-              /*TCCRnQ*/  { &TCCR2A,  &TCCR2B,  nullptr },
-              /*OCRnQ*/   { (uint16_t*)&OCR2A, (uint16_t*)&OCR2B, nullptr },
-              /*ICRn*/      nullptr,
-              /*n, q*/      2, 1
-            };
-            return timer;
-          }
-        #else
-          case TIMER2B:   ++q;
-          case TIMER2A: {
-            Timer timer = {
-              /*TCCRnQ*/  { &TCCR2A,  &TCCR2B,  nullptr },
-              /*OCRnQ*/   { (uint16_t*)&OCR2A, (uint16_t*)&OCR2B, nullptr },
-              /*ICRn*/      nullptr,
-                            2, q
-            };
-            return timer;
-          }
-        #endif
-      #endif
-    #endif
-    #ifdef OCR3C
-      case TIMER3C:   ++q;
-      case TIMER3B:   ++q;
-      case TIMER3A: {
-        Timer timer = {
-          /*TCCRnQ*/  { &TCCR3A,  &TCCR3B,  &TCCR3C },
-          /*OCRnQ*/   { &OCR3A,   &OCR3B,   &OCR3C },
-          /*ICRn*/      &ICR3,
-          /*n, q*/      3, q
-        };
-        return timer;
-      }
-    #elif defined(OCR3B)
-      case TIMER3B:   ++q;
-      case TIMER3A: {
-        Timer timer = {
-          /*TCCRnQ*/  { &TCCR3A,  &TCCR3B,  nullptr },
-          /*OCRnQ*/   { &OCR3A,   &OCR3B,  nullptr },
-          /*ICRn*/      &ICR3,
-          /*n, q*/      3, q
-        };
-        return timer;
-      }
-    #endif
-    #ifdef TCCR4A
-      case TIMER4C:   ++q;
-      case TIMER4B:   ++q;
-      case TIMER4A: {
-        Timer timer = {
-          /*TCCRnQ*/  { &TCCR4A,  &TCCR4B,  &TCCR4C },
-          /*OCRnQ*/   { &OCR4A,   &OCR4B,   &OCR4C },
-          /*ICRn*/      &ICR4,
-          /*n, q*/      4, q
-        };
-        return timer;
-      }
-    #endif
-    #ifdef TCCR5A
-      case TIMER5C:   ++q;
-      case TIMER5B:   ++q;
-      case TIMER5A: {
-        Timer timer = {
-          /*TCCRnQ*/  { &TCCR5A,  &TCCR5B,  &TCCR5C },
-          /*OCRnQ*/   { &OCR5A,   &OCR5B,   &OCR5C },
-          /*ICRn*/      &ICR5,
-          /*n, q*/      5, q
-        };
-        return timer;
-      }
-    #endif
-  }
-  Timer timer = {
-      /*TCCRnQ*/  { nullptr, nullptr, nullptr },
-      /*OCRnQ*/   { nullptr, nullptr, nullptr },
-      /*ICRn*/      nullptr,
-                    0, 0
-  };
-  return timer;
-}
-
-void set_pwm_frequency(const pin_t pin, int f_desired) {
-  Timer timer = get_pwm_timer(pin);
-  if (timer.n == 0) return; // Don't proceed if protected timer or not recognised
-  uint16_t size;
-  if (timer.n == 2) size = 255; else size = 65535;
-
-  uint16_t res = 255;   // resolution (TOP value)
-  uint8_t j = 0;        // prescaler index
-  uint8_t wgm = 1;      // waveform generation mode
-
-  // Calculating the prescaler and resolution to use to achieve closest frequency
-  if (f_desired != 0) {
-    int f = (F_CPU) / (2 * 1024 * size) + 1; // Initialize frequency as lowest (non-zero) achievable
-    uint16_t prescaler[] = { 0, 1, 8, /*TIMER2 ONLY*/32, 64, /*TIMER2 ONLY*/128, 256, 1024 };
-
-    // loop over prescaler values
-    LOOP_S_L_N(i, 1, 8) {
-      uint16_t res_temp_fast = 255, res_temp_phase_correct = 255;
-      if (timer.n == 2) {
-        // No resolution calculation for TIMER2 unless enabled USE_OCR2A_AS_TOP
-        #if ENABLED(USE_OCR2A_AS_TOP)
-          const uint16_t rtf = (F_CPU) / (prescaler[i] * f_desired);
-          res_temp_fast = rtf - 1;
-          res_temp_phase_correct = rtf / 2;
-        #endif
-      }
-      else {
-        // Skip TIMER2 specific prescalers when not TIMER2
-        if (i == 3 || i == 5) continue;
-        const uint16_t rtf = (F_CPU) / (prescaler[i] * f_desired);
-        res_temp_fast = rtf - 1;
-        res_temp_phase_correct = rtf / 2;
-      }
-
-      LIMIT(res_temp_fast, 1u, size);
-      LIMIT(res_temp_phase_correct, 1u, size);
-      // Calculate frequencies of test prescaler and resolution values
-      const int f_temp_fast = (F_CPU) / (prescaler[i] * (1 + res_temp_fast)),
-                f_temp_phase_correct = (F_CPU) / (2 * prescaler[i] * res_temp_phase_correct),
-                f_diff = ABS(f - f_desired),
-                f_fast_diff = ABS(f_temp_fast - f_desired),
-                f_phase_diff = ABS(f_temp_phase_correct - f_desired);
-
-      // If FAST values are closest to desired f
-      if (f_fast_diff < f_diff && f_fast_diff <= f_phase_diff) {
-        // Remember this combination
-        f = f_temp_fast;
-        res = res_temp_fast;
-        j = i;
-        // Set the Wave Generation Mode to FAST PWM
-        if (timer.n == 2) {
-          wgm = (
-            #if ENABLED(USE_OCR2A_AS_TOP)
-              WGM2_FAST_PWM_OCR2A
-            #else
-              WGM2_FAST_PWM
-            #endif
-          );
-        }
-        else wgm = WGM_FAST_PWM_ICRn;
-      }
-      // If PHASE CORRECT values are closes to desired f
-      else if (f_phase_diff < f_diff) {
-        f = f_temp_phase_correct;
-        res = res_temp_phase_correct;
-        j = i;
-        // Set the Wave Generation Mode to PWM PHASE CORRECT
-        if (timer.n == 2) {
-          wgm = (
-            #if ENABLED(USE_OCR2A_AS_TOP)
-              WGM2_PWM_PC_OCR2A
-            #else
-              WGM2_PWM_PC
-            #endif
-          );
-        }
-        else wgm = WGM_PWM_PC_ICRn;
-      }
-    }
-  }
-  _SET_WGMnQ(timer.TCCRnQ, wgm);
-  _SET_CSn(timer.TCCRnQ, j);
-
-  if (timer.n == 2) {
-    #if ENABLED(USE_OCR2A_AS_TOP)
-      _SET_OCRnQ(timer.OCRnQ, 0, res);  // Set OCR2A value (TOP) = res
-    #endif
-  }
-  else
-    _SET_ICRn(timer.ICRn, res);         // Set ICRn value (TOP) = res
-}
-
-void set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size/*=255*/, const bool invert/*=false*/) {
-  // If v is 0 or v_size (max), digitalWrite to LOW or HIGH.
-  // Note that digitalWrite also disables pwm output for us (sets COM bit to 0)
-  if (v == 0)
-    digitalWrite(pin, invert);
-  else if (v == v_size)
-    digitalWrite(pin, !invert);
-  else {
-    Timer timer = get_pwm_timer(pin);
-    if (timer.n == 0) return; // Don't proceed if protected timer or not recognised
-    // Set compare output mode to CLEAR -> SET or SET -> CLEAR (if inverted)
-    _SET_COMnQ(timer.TCCRnQ, (timer.q
-        #ifdef TCCR2
-          + (timer.q == 2) // COM20 is on bit 4 of TCCR2, thus requires q + 1 in the macro
-        #endif
-      ), COM_CLEAR_SET + invert
-    );
-
-    uint16_t top;
-    if (timer.n == 2) { // if TIMER2
-      top = (
-        #if ENABLED(USE_OCR2A_AS_TOP)
-          *timer.OCRnQ[0] // top = OCR2A
-        #else
-          255 // top = 0xFF (max)
-        #endif
-      );
-    }
-    else
-      top = *timer.ICRn; // top = ICRn
-
-    _SET_OCRnQ(timer.OCRnQ, timer.q, v * float(top / v_size)); // Scale 8/16-bit v to top value
-  }
-}
-
-#endif // FAST_PWM_FAN || SPINDLE_LASER_PWM
-#endif // __AVR__
--- a/Marlin/src/HAL/AVR/fastio.cpp
+++ b/Marlin/src/HAL/AVR/fastio.cpp
@@ -1,238 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * Fast I/O for extended pins
- */
-
-#ifdef __AVR__
-
-#include "fastio.h"
-
-#ifdef FASTIO_EXT_START
-
-#include "../shared/Marduino.h"
-
-#define _IS_EXT(P) WITHIN(P, FASTIO_EXT_START, FASTIO_EXT_END)
-
-void extDigitalWrite(const int8_t pin, const uint8_t state) {
-  #define _WCASE(N) case N: WRITE(N, state); break
-  switch (pin) {
-    default: digitalWrite(pin, state);
-    #if _IS_EXT(70)
-      _WCASE(70);
-    #endif
-    #if _IS_EXT(71)
-      _WCASE(71);
-    #endif
-    #if _IS_EXT(72)
-      _WCASE(72);
-    #endif
-    #if _IS_EXT(73)
-      _WCASE(73);
-    #endif
-    #if _IS_EXT(74)
-      _WCASE(74);
-    #endif
-    #if _IS_EXT(75)
-      _WCASE(75);
-    #endif
-    #if _IS_EXT(76)
-      _WCASE(76);
-    #endif
-    #if _IS_EXT(77)
-      _WCASE(77);
-    #endif
-    #if _IS_EXT(78)
-      _WCASE(78);
-    #endif
-    #if _IS_EXT(79)
-      _WCASE(79);
-    #endif
-    #if _IS_EXT(80)
-      _WCASE(80);
-    #endif
-    #if _IS_EXT(81)
-      _WCASE(81);
-    #endif
-    #if _IS_EXT(82)
-      _WCASE(82);
-    #endif
-    #if _IS_EXT(83)
-      _WCASE(83);
-    #endif
-    #if _IS_EXT(84)
-      _WCASE(84);
-    #endif
-    #if _IS_EXT(85)
-      _WCASE(85);
-    #endif
-    #if _IS_EXT(86)
-      _WCASE(86);
-    #endif
-    #if _IS_EXT(87)
-      _WCASE(87);
-    #endif
-    #if _IS_EXT(88)
-      _WCASE(88);
-    #endif
-    #if _IS_EXT(89)
-      _WCASE(89);
-    #endif
-    #if _IS_EXT(90)
-      _WCASE(90);
-    #endif
-    #if _IS_EXT(91)
-      _WCASE(91);
-    #endif
-    #if _IS_EXT(92)
-      _WCASE(92);
-    #endif
-    #if _IS_EXT(93)
-      _WCASE(93);
-    #endif
-    #if _IS_EXT(94)
-      _WCASE(94);
-    #endif
-    #if _IS_EXT(95)
-      _WCASE(95);
-    #endif
-    #if _IS_EXT(96)
-      _WCASE(96);
-    #endif
-    #if _IS_EXT(97)
-      _WCASE(97);
-    #endif
-    #if _IS_EXT(98)
-      _WCASE(98);
-    #endif
-    #if _IS_EXT(99)
-      _WCASE(99);
-    #endif
-    #if _IS_EXT(100)
-      _WCASE(100);
-    #endif
-  }
-}
-
-uint8_t extDigitalRead(const int8_t pin) {
-  #define _RCASE(N) case N: return READ(N)
-  switch (pin) {
-    default: return digitalRead(pin);
-    #if _IS_EXT(70)
-      _RCASE(70);
-    #endif
-    #if _IS_EXT(71)
-      _RCASE(71);
-    #endif
-    #if _IS_EXT(72)
-      _RCASE(72);
-    #endif
-    #if _IS_EXT(73)
-      _RCASE(73);
-    #endif
-    #if _IS_EXT(74)
-      _RCASE(74);
-    #endif
-    #if _IS_EXT(75)
-      _RCASE(75);
-    #endif
-    #if _IS_EXT(76)
-      _RCASE(76);
-    #endif
-    #if _IS_EXT(77)
-      _RCASE(77);
-    #endif
-    #if _IS_EXT(78)
-      _RCASE(78);
-    #endif
-    #if _IS_EXT(79)
-      _RCASE(79);
-    #endif
-    #if _IS_EXT(80)
-      _RCASE(80);
-    #endif
-    #if _IS_EXT(81)
-      _RCASE(81);
-    #endif
-    #if _IS_EXT(82)
-      _RCASE(82);
-    #endif
-    #if _IS_EXT(83)
-      _RCASE(83);
-    #endif
-    #if _IS_EXT(84)
-      _RCASE(84);
-    #endif
-    #if _IS_EXT(85)
-      _RCASE(85);
-    #endif
-    #if _IS_EXT(86)
-      _RCASE(86);
-    #endif
-    #if _IS_EXT(87)
-      _RCASE(87);
-    #endif
-    #if _IS_EXT(88)
-      _RCASE(88);
-    #endif
-    #if _IS_EXT(89)
-      _RCASE(89);
-    #endif
-    #if _IS_EXT(90)
-      _RCASE(90);
-    #endif
-    #if _IS_EXT(91)
-      _RCASE(91);
-    #endif
-    #if _IS_EXT(92)
-      _RCASE(92);
-    #endif
-    #if _IS_EXT(93)
-      _RCASE(93);
-    #endif
-    #if _IS_EXT(94)
-      _RCASE(94);
-    #endif
-    #if _IS_EXT(95)
-      _RCASE(95);
-    #endif
-    #if _IS_EXT(96)
-      _RCASE(96);
-    #endif
-    #if _IS_EXT(97)
-      _RCASE(97);
-    #endif
-    #if _IS_EXT(98)
-      _RCASE(98);
-    #endif
-    #if _IS_EXT(99)
-      _RCASE(99);
-    #endif
-    #if _IS_EXT(100)
-      _RCASE(100);
-    #endif
-  }
-}
-
-#endif // FASTIO_EXT_START
-#endif // __AVR__
--- a/Marlin/src/HAL/AVR/inc/Conditionals_LCD.h
+++ b/Marlin/src/HAL/AVR/inc/Conditionals_LCD.h
@@ -1,22 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#pragma once
--- a/Marlin/src/HAL/AVR/inc/Conditionals_adv.h
+++ b/Marlin/src/HAL/AVR/inc/Conditionals_adv.h
@@ -1,22 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#pragma once
--- a/Marlin/src/HAL/AVR/inc/Conditionals_post.h
+++ b/Marlin/src/HAL/AVR/inc/Conditionals_post.h
@@ -1,22 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#pragma once
--- a/Marlin/src/HAL/AVR/inc/SanityCheck.h
+++ b/Marlin/src/HAL/AVR/inc/SanityCheck.h
@@ -1,65 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-/**
- * Test AVR-specific configuration values for errors at compile-time.
- */
-
-/**
- * Digipot requirement
- */
- #if ENABLED(DIGIPOT_MCP4018)
-  #if !defined(DIGIPOTS_I2C_SDA_X) || !defined(DIGIPOTS_I2C_SDA_Y) || !defined(DIGIPOTS_I2C_SDA_Z) \
-    || !defined(DIGIPOTS_I2C_SDA_E0) || !defined(DIGIPOTS_I2C_SDA_E1)
-      #error "DIGIPOT_MCP4018 requires DIGIPOTS_I2C_SDA_* pins to be defined."
-  #endif
-#endif
-
-/**
- * Checks for FAST PWM
- */
-#if ENABLED(FAST_PWM_FAN) && (ENABLED(USE_OCR2A_AS_TOP) && defined(TCCR2))
-  #error "USE_OCR2A_AS_TOP does not apply to devices with a single output TIMER2"
-#endif
-
-/**
- * Sanity checks for Spindle / Laser PWM
- */
-#if ENABLED(SPINDLE_LASER_PWM)
-  #if SPINDLE_LASER_PWM_PIN == 4 || WITHIN(SPINDLE_LASER_PWM_PIN, 11, 13)
-    #error "Counter/Timer for SPINDLE_LASER_PWM_PIN is used by a system interrupt."
-  #elif NUM_SERVOS > 0 && (WITHIN(SPINDLE_LASER_PWM_PIN, 2, 3) || SPINDLE_LASER_PWM_PIN == 5)
-    #error "Counter/Timer for SPINDLE_LASER_PWM_PIN is used by the servo system."
-  #endif
-#endif
-
-/**
- * The Trinamic library includes SoftwareSerial.h, leading to a compile error.
- */
-#if HAS_TRINAMIC_CONFIG && ENABLED(ENDSTOP_INTERRUPTS_FEATURE)
-  #error "TMCStepper includes SoftwareSerial.h which is incompatible with ENDSTOP_INTERRUPTS_FEATURE. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
-#endif
-
-#if HAS_TMC_SW_SERIAL && ENABLED(MONITOR_DRIVER_STATUS)
-  #error "MONITOR_DRIVER_STATUS causes performance issues when used with SoftwareSerial-connected drivers. Disable MONITOR_DRIVER_STATUS or use hardware serial to continue."
-#endif
--- a/Marlin/src/HAL/AVR/u8g_com_HAL_AVR_sw_spi.cpp
+++ b/Marlin/src/HAL/AVR/u8g_com_HAL_AVR_sw_spi.cpp
@@ -1,193 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * Based on u8g_com_st7920_hw_spi.c
- *
- * Universal 8bit Graphics Library
- *
- * Copyright (c) 2011, olikraus@gmail.com
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- *
- *  * Redistributions of source code must retain the above copyright notice, this list
- *    of conditions and the following disclaimer.
- *
- *  * Redistributions in binary form must reproduce the above copyright notice, this
- *    list of conditions and the following disclaimer in the documentation and/or other
- *    materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#if defined(ARDUINO) && !defined(ARDUINO_ARCH_STM32) && !defined(ARDUINO_ARCH_SAM)
-
-#include "../../inc/MarlinConfigPre.h"
-
-#if HAS_GRAPHICAL_LCD
-
-#include "../shared/Marduino.h"
-#include "../shared/Delay.h"
-
-#include <U8glib.h>
-
-uint8_t u8g_bitData, u8g_bitNotData, u8g_bitClock, u8g_bitNotClock;
-volatile uint8_t *u8g_outData, *u8g_outClock;
-
-static void u8g_com_arduino_init_shift_out(uint8_t dataPin, uint8_t clockPin) {
-  u8g_outData = portOutputRegister(digitalPinToPort(dataPin));
-  u8g_outClock = portOutputRegister(digitalPinToPort(clockPin));
-  u8g_bitData = digitalPinToBitMask(dataPin);
-  u8g_bitClock = digitalPinToBitMask(clockPin);
-
-  u8g_bitNotClock = u8g_bitClock;
-  u8g_bitNotClock ^= 0xFF;
-
-  u8g_bitNotData = u8g_bitData;
-  u8g_bitNotData ^= 0xFF;
-}
-
-void u8g_spiSend_sw_AVR_mode_0(uint8_t val) {
-  uint8_t bitData = u8g_bitData,
-          bitNotData = u8g_bitNotData,
-          bitClock = u8g_bitClock,
-          bitNotClock = u8g_bitNotClock;
-  volatile uint8_t *outData = u8g_outData,
-                   *outClock = u8g_outClock;
-  U8G_ATOMIC_START();
-  LOOP_L_N(i, 8) {
-    if (val & 0x80)
-      *outData |= bitData;
-    else
-      *outData &= bitNotData;
-    *outClock |= bitClock;
-    val <<= 1;
-    *outClock &= bitNotClock;
-  }
-  U8G_ATOMIC_END();
-}
-
-void u8g_spiSend_sw_AVR_mode_3(uint8_t val) {
-  uint8_t bitData = u8g_bitData,
-          bitNotData = u8g_bitNotData,
-          bitClock = u8g_bitClock,
-          bitNotClock = u8g_bitNotClock;
-  volatile uint8_t *outData = u8g_outData,
-                   *outClock = u8g_outClock;
-  U8G_ATOMIC_START();
-  LOOP_L_N(i, 8) {
-    *outClock &= bitNotClock;
-    if (val & 0x80)
-      *outData |= bitData;
-    else
-      *outData &= bitNotData;
-    *outClock |= bitClock;
-    val <<= 1;
-  }
-  U8G_ATOMIC_END();
-}
-
-
-#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
-#endif
-
-uint8_t u8g_com_HAL_AVR_sw_sp_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) {
-  switch (msg) {
-    case U8G_COM_MSG_INIT:
-      u8g_com_arduino_init_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK]);
-      u8g_com_arduino_assign_pin_output_high(u8g);
-      u8g_com_arduino_digital_write(u8g, U8G_PI_SCK, 0);
-      u8g_com_arduino_digital_write(u8g, U8G_PI_MOSI, 0);
-      break;
-
-    case U8G_COM_MSG_STOP:
-      break;
-
-    case U8G_COM_MSG_RESET:
-      if (U8G_PIN_NONE != u8g->pin_list[U8G_PI_RESET]) u8g_com_arduino_digital_write(u8g, U8G_PI_RESET, arg_val);
-      break;
-
-    case U8G_COM_MSG_CHIP_SELECT:
-      #if ENABLED(FYSETC_MINI_12864)           // LCD SPI is running mode 3 while SD card is running mode 0
-        if (arg_val) {                         //   SCK idle state needs to be set to the proper idle state before
-                                               //   the next chip select goes active
-          u8g_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);
-        }
-        else {
-          u8g_com_arduino_digital_write(u8g, U8G_PI_CS, HIGH);
-          u8g_com_arduino_digital_write(u8g, U8G_PI_SCK, 0);  // Set SCK to mode 0 idle state after CS goes inactive
-        }
-      #else
-        u8g_com_arduino_digital_write(u8g, U8G_PI_CS, !arg_val);
-      #endif
-      break;
-
-    case U8G_COM_MSG_WRITE_BYTE:
-      SPISEND_SW_AVR(arg_val);
-      break;
-
-    case U8G_COM_MSG_WRITE_SEQ: {
-        uint8_t *ptr = (uint8_t *)arg_ptr;
-        while (arg_val > 0) {
-          SPISEND_SW_AVR(*ptr++);
-          arg_val--;
-        }
-      }
-      break;
-
-      case U8G_COM_MSG_WRITE_SEQ_P: {
-        uint8_t *ptr = (uint8_t *)arg_ptr;
-        while (arg_val > 0) {
-          SPISEND_SW_AVR(u8g_pgm_read(ptr));
-          ptr++;
-          arg_val--;
-        }
-      }
-      break;
-
-    case U8G_COM_MSG_ADDRESS:                     /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
-      u8g_com_arduino_digital_write(u8g, U8G_PI_A0, arg_val);
-      break;
-  }
-  return 1;
-}
-
-#endif // HAS_GRAPHICAL_LCD
-#endif // ARDUINO_ARCH_SAM
--- a/Marlin/src/HAL/DUE/HAL.cpp
+++ b/Marlin/src/HAL/DUE/HAL.cpp
@@ -1,106 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- * Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * 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/>.
- */
-
-/**
- * Description: HAL for Arduino Due and compatible (SAM3X8E)
- *
- * For ARDUINO_ARCH_SAM
- */
-
-#ifdef ARDUINO_ARCH_SAM
-
-#include "../../inc/MarlinConfig.h"
-#include "HAL.h"
-
-#include <Wire.h>
-#include "usb/usb_task.h"
-
-// ------------------------
-// Public Variables
-// ------------------------
-
-uint16_t HAL_adc_result;
-
-// ------------------------
-// Public functions
-// ------------------------
-
-// HAL initialization task
-void HAL_init() {
-  // Initialize the USB stack
-  #if ENABLED(SDSUPPORT)
-    OUT_WRITE(SDSS, HIGH);  // Try to set SDSS inactive before any other SPI users start up
-  #endif
-  usb_task_init();
-}
-
-// HAL idle task
-void HAL_idletask() {
-  // Perform USB stack housekeeping
-  usb_task_idle();
-}
-
-// Disable interrupts
-void cli() { noInterrupts(); }
-
-// Enable interrupts
-void sei() { interrupts(); }
-
-void HAL_clear_reset_source() { }
-
-uint8_t HAL_get_reset_source() {
-  switch ((RSTC->RSTC_SR >> 8) & 0x07) {
-    case 0: return RST_POWER_ON;
-    case 1: return RST_BACKUP;
-    case 2: return RST_WATCHDOG;
-    case 3: return RST_SOFTWARE;
-    case 4: return RST_EXTERNAL;
-    default: return 0;
-  }
-}
-
-void _delay_ms(const int delay_ms) {
-  // Todo: port for Due?
-  delay(delay_ms);
-}
-
-extern "C" {
-  extern unsigned int _ebss; // 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)&_ebss);
-}
-
-// ------------------------
-// ADC
-// ------------------------
-
-void HAL_adc_start_conversion(const uint8_t ch) {
-  HAL_adc_result = analogRead(ch);
-}
-
-uint16_t HAL_adc_get_result() {
-  // nop
-  return HAL_adc_result;
-}
-
-#endif // ARDUINO_ARCH_SAM
--- a/Marlin/src/HAL/DUE/HAL.h
+++ b/Marlin/src/HAL/DUE/HAL.h
@@ -1,198 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- *
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- * Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
- * Copyright (c) 2015-2016 Nico Tonnhofer wurstnase.reprap@gmail.com
- *
- * 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/>.
- *
- */
-#pragma once
-
-/**
- * Description: HAL for Arduino Due and compatible (SAM3X8E)
- *
- * For ARDUINO_ARCH_SAM
- */
-
-#define CPU_32_BIT
-
-#include "../shared/Marduino.h"
-#include "../shared/math_32bit.h"
-#include "../shared/HAL_SPI.h"
-#include "fastio.h"
-#include "watchdog.h"
-#include "timers.h"
-
-#include <stdint.h>
-
-// Define MYSERIAL0/1 before MarlinSerial includes!
-#if SERIAL_PORT == -1
-  #define MYSERIAL0 customizedSerial1
-#elif SERIAL_PORT == 0
-  #define MYSERIAL0 Serial
-#elif SERIAL_PORT == 1
-  #define MYSERIAL0 Serial1
-#elif SERIAL_PORT == 2
-  #define MYSERIAL0 Serial2
-#elif SERIAL_PORT == 3
-  #define MYSERIAL0 Serial3
-#else
-  #error "The required SERIAL_PORT must be from -1 to 3. Please update your configuration."
-#endif
-
-#ifdef SERIAL_PORT_2
-  #if SERIAL_PORT_2 == SERIAL_PORT
-    #error "SERIAL_PORT_2 must be different from SERIAL_PORT. Please update your configuration."
-  #elif SERIAL_PORT_2 == -1
-    #define MYSERIAL1 customizedSerial2
-  #elif SERIAL_PORT_2 == 0
-    #define MYSERIAL1 Serial
-  #elif SERIAL_PORT_2 == 1
-    #define MYSERIAL1 Serial1
-  #elif SERIAL_PORT_2 == 2
-    #define MYSERIAL1 Serial2
-  #elif SERIAL_PORT_2 == 3
-    #define MYSERIAL1 Serial3
-  #else
-    #error "SERIAL_PORT_2 must be from -1 to 3. Please update your configuration."
-  #endif
-  #define NUM_SERIAL 2
-#else
-  #define NUM_SERIAL 1
-#endif
-
-#ifdef DGUS_SERIAL_PORT
-  #if DGUS_SERIAL_PORT == SERIAL_PORT
-    #error "DGUS_SERIAL_PORT must be different from SERIAL_PORT. Please update your configuration."
-  #elif defined(SERIAL_PORT_2) && DGUS_SERIAL_PORT == SERIAL_PORT_2
-    #error "DGUS_SERIAL_PORT must be different than SERIAL_PORT_2. Please update your configuration."
-  #elif DGUS_SERIAL_PORT == -1
-    #define DGUS_SERIAL internalDgusSerial
-  #elif DGUS_SERIAL_PORT == 0
-    #define DGUS_SERIAL Serial
-  #elif DGUS_SERIAL_PORT == 1
-    #define DGUS_SERIAL Serial1
-  #elif DGUS_SERIAL_PORT == 2
-    #define DGUS_SERIAL Serial2
-  #elif DGUS_SERIAL_PORT == 3
-    #define DGUS_SERIAL Serial3
-  #else
-    #error "DGUS_SERIAL_PORT must be from -1 to 3. Please update your configuration."
-  #endif
-#endif
-
-
-#include "MarlinSerial.h"
-#include "MarlinSerialUSB.h"
-
-// On AVR this is in math.h?
-#define square(x) ((x)*(x))
-
-#ifndef strncpy_P
-  #define strncpy_P(dest, src, num) strncpy((dest), (src), (num))
-#endif
-
-// Fix bug in pgm_read_ptr
-#undef pgm_read_ptr
-#define pgm_read_ptr(addr) (*((void**)(addr)))
-#undef pgm_read_word
-#define pgm_read_word(addr) (*((uint16_t*)(addr)))
-
-typedef int8_t pin_t;
-
-#define SHARED_SERVOS HAS_SERVOS
-#define HAL_SERVO_LIB Servo
-
-//
-// Interrupts
-//
-#define CRITICAL_SECTION_START()  uint32_t primask = __get_PRIMASK(); __disable_irq()
-#define CRITICAL_SECTION_END()    if (!primask) __enable_irq()
-#define ISRS_ENABLED() (!__get_PRIMASK())
-#define ENABLE_ISRS()  __enable_irq()
-#define DISABLE_ISRS() __disable_irq()
-
-void cli();                     // Disable interrupts
-void sei();                     // Enable interrupts
-
-void HAL_clear_reset_source();  // clear reset reason
-uint8_t HAL_get_reset_source(); // get reset reason
-
-//
-// EEPROM
-//
-void eeprom_write_byte(uint8_t *pos, unsigned char value);
-uint8_t eeprom_read_byte(uint8_t *pos);
-void eeprom_read_block (void *__dst, const void *__src, size_t __n);
-void eeprom_update_block (const void *__src, void *__dst, size_t __n);
-
-//
-// ADC
-//
-extern uint16_t HAL_adc_result;     // result of last ADC conversion
-
-#ifndef analogInputToDigitalPin
-  #define analogInputToDigitalPin(p) ((p < 12u) ? (p) + 54u : -1)
-#endif
-
-#define HAL_ANALOG_SELECT(ch)
-
-inline void HAL_adc_init() {}//todo
-
-#define HAL_START_ADC(ch)   HAL_adc_start_conversion(ch)
-#define HAL_ADC_RESOLUTION  10
-#define HAL_READ_ADC()      HAL_adc_result
-#define HAL_ADC_READY()     true
-
-void HAL_adc_start_conversion(const uint8_t ch);
-uint16_t HAL_adc_get_result();
-
-//
-// Pin Map
-//
-#define GET_PIN_MAP_PIN(index) index
-#define GET_PIN_MAP_INDEX(pin) pin
-#define PARSED_PIN_INDEX(code, dval) parser.intval(code, dval)
-
-//
-// Tone
-//
-void toneInit();
-void tone(const pin_t _pin, const unsigned int frequency, const unsigned long duration=0);
-void noTone(const pin_t _pin);
-
-// Enable hooks into idle and setup for HAL
-#define HAL_IDLETASK 1
-void HAL_idletask();
-void HAL_init();
-
-//
-// Utility functions
-//
-void _delay_ms(const int delay);
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-function"
-int freeMemory();
-#pragma GCC diagnostic pop
-
-#ifdef __cplusplus
-  extern "C" {
-#endif
-char *dtostrf(double __val, signed char __width, unsigned char __prec, char *__s);
-#ifdef __cplusplus
-  }
-#endif
--- a/Marlin/src/HAL/DUE/MarlinSerial.cpp
+++ b/Marlin/src/HAL/DUE/MarlinSerial.cpp
@@ -1,651 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * MarlinSerial_Due.cpp - Hardware serial library for Arduino DUE
- * Copyright (c) 2017 Eduardo José Tagle. All right reserved
- * Based on MarlinSerial for AVR, copyright (c) 2006 Nicholas Zambetti.  All right reserved.
- */
-#ifdef ARDUINO_ARCH_SAM
-
-#include "../../inc/MarlinConfig.h"
-
-#include "MarlinSerial.h"
-#include "InterruptVectors.h"
-#include "../../MarlinCore.h"
-
-template<typename Cfg> typename MarlinSerial<Cfg>::ring_buffer_r MarlinSerial<Cfg>::rx_buffer = { 0, 0, { 0 } };
-template<typename Cfg> typename MarlinSerial<Cfg>::ring_buffer_t MarlinSerial<Cfg>::tx_buffer = { 0 };
-template<typename Cfg> bool     MarlinSerial<Cfg>::_written = false;
-template<typename Cfg> uint8_t  MarlinSerial<Cfg>::xon_xoff_state = MarlinSerial<Cfg>::XON_XOFF_CHAR_SENT | MarlinSerial<Cfg>::XON_CHAR;
-template<typename Cfg> uint8_t  MarlinSerial<Cfg>::rx_dropped_bytes = 0;
-template<typename Cfg> uint8_t  MarlinSerial<Cfg>::rx_buffer_overruns = 0;
-template<typename Cfg> uint8_t  MarlinSerial<Cfg>::rx_framing_errors = 0;
-template<typename Cfg> typename MarlinSerial<Cfg>::ring_buffer_pos_t MarlinSerial<Cfg>::rx_max_enqueued = 0;
-
-// A SW memory barrier, to ensure GCC does not overoptimize loops
-#define sw_barrier() asm volatile("": : :"memory");
-
-#include "../../feature/e_parser.h"
-
-// (called with RX interrupts disabled)
-template<typename Cfg>
-FORCE_INLINE void MarlinSerial<Cfg>::store_rxd_char() {
-
-  static EmergencyParser::State emergency_state; // = EP_RESET
-
-  // Get the tail - Nothing can alter its value while we are at this ISR
-  const ring_buffer_pos_t t = rx_buffer.tail;
-
-  // Get the head pointer
-  ring_buffer_pos_t h = rx_buffer.head;
-
-  // Get the next element
-  ring_buffer_pos_t i = (ring_buffer_pos_t)(h + 1) & (ring_buffer_pos_t)(Cfg::RX_SIZE - 1);
-
-  // Read the character from the USART
-  uint8_t c = HWUART->UART_RHR;
-
-  if (Cfg::EMERGENCYPARSER) emergency_parser.update(emergency_state, c);
-
-  // If the character is to be stored at the index just before the tail
-  // (such that the head would advance to the current tail), the RX FIFO is
-  // full, so don't write the character or advance the head.
-  if (i != t) {
-    rx_buffer.buffer[h] = c;
-    h = i;
-  }
-  else if (Cfg::DROPPED_RX && !++rx_dropped_bytes)
-    --rx_dropped_bytes;
-
-  const ring_buffer_pos_t rx_count = (ring_buffer_pos_t)(h - t) & (ring_buffer_pos_t)(Cfg::RX_SIZE - 1);
-  // Calculate count of bytes stored into the RX buffer
-
-  // Keep track of the maximum count of enqueued bytes
-  if (Cfg::MAX_RX_QUEUED) NOLESS(rx_max_enqueued, rx_count);
-
-  if (Cfg::XONOFF) {
-    // If the last char that was sent was an XON
-    if ((xon_xoff_state & XON_XOFF_CHAR_MASK) == XON_CHAR) {
-
-      // Bytes stored into the RX buffer
-      const ring_buffer_pos_t rx_count = (ring_buffer_pos_t)(h - t) & (ring_buffer_pos_t)(Cfg::RX_SIZE - 1);
-
-      // If over 12.5% of RX buffer capacity, send XOFF before running out of
-      // RX buffer space .. 325 bytes @ 250kbits/s needed to let the host react
-      // and stop sending bytes. This translates to 13mS propagation time.
-      if (rx_count >= (Cfg::RX_SIZE) / 8) {
-
-        // At this point, definitely no TX interrupt was executing, since the TX isr can't be preempted.
-        // Don't enable the TX interrupt here as a means to trigger the XOFF char, because if it happens
-        // to be in the middle of trying to disable the RX interrupt in the main program, eventually the
-        // enabling of the TX interrupt could be undone. The ONLY reliable thing this can do to ensure
-        // the sending of the XOFF char is to send it HERE AND NOW.
-
-        // About to send the XOFF char
-        xon_xoff_state = XOFF_CHAR | XON_XOFF_CHAR_SENT;
-
-        // Wait until the TX register becomes empty and send it - Here there could be a problem
-        // - While waiting for the TX register to empty, the RX register could receive a new
-        //   character. This must also handle that situation!
-        uint32_t status;
-        while (!((status = HWUART->UART_SR) & UART_SR_TXRDY)) {
-
-          if (status & UART_SR_RXRDY) {
-            // We received a char while waiting for the TX buffer to be empty - Receive and process it!
-
-            i = (ring_buffer_pos_t)(h + 1) & (ring_buffer_pos_t)(Cfg::RX_SIZE - 1);
-
-            // Read the character from the USART
-            c = HWUART->UART_RHR;
-
-            if (Cfg::EMERGENCYPARSER) emergency_parser.update(emergency_state, c);
-
-            // If the character is to be stored at the index just before the tail
-            // (such that the head would advance to the current tail), the FIFO is
-            // full, so don't write the character or advance the head.
-            if (i != t) {
-              rx_buffer.buffer[h] = c;
-              h = i;
-            }
-            else if (Cfg::DROPPED_RX && !++rx_dropped_bytes)
-              --rx_dropped_bytes;
-          }
-          sw_barrier();
-        }
-
-        HWUART->UART_THR = XOFF_CHAR;
-
-        // At this point there could be a race condition between the write() function
-        // and this sending of the XOFF char. This interrupt could happen between the
-        // wait to be empty TX buffer loop and the actual write of the character. Since
-        // the TX buffer is full because it's sending the XOFF char, the only way to be
-        // sure the write() function will succeed is to wait for the XOFF char to be
-        // completely sent. Since an extra character could be received during the wait
-        // it must also be handled!
-        while (!((status = HWUART->UART_SR) & UART_SR_TXRDY)) {
-
-          if (status & UART_SR_RXRDY) {
-            // A char arrived while waiting for the TX buffer to be empty - Receive and process it!
-
-            i = (ring_buffer_pos_t)(h + 1) & (ring_buffer_pos_t)(Cfg::RX_SIZE - 1);
-
-            // Read the character from the USART
-            c = HWUART->UART_RHR;
-
-            if (Cfg::EMERGENCYPARSER) emergency_parser.update(emergency_state, c);
-
-            // If the character is to be stored at the index just before the tail
-            // (such that the head would advance to the current tail), the FIFO is
-            // full, so don't write the character or advance the head.
-            if (i != t) {
-              rx_buffer.buffer[h] = c;
-              h = i;
-            }
-            else if (Cfg::DROPPED_RX && !++rx_dropped_bytes)
-              --rx_dropped_bytes;
-          }
-          sw_barrier();
-        }
-
-        // At this point everything is ready. The write() function won't
-        // have any issues writing to the UART TX register if it needs to!
-      }
-    }
-  }
-
-  // Store the new head value
-  rx_buffer.head = h;
-}
-
-template<typename Cfg>
-FORCE_INLINE void MarlinSerial<Cfg>::_tx_thr_empty_irq() {
-  if (Cfg::TX_SIZE > 0) {
-    // Read positions
-    uint8_t t = tx_buffer.tail;
-    const uint8_t h = tx_buffer.head;
-
-    if (Cfg::XONOFF) {
-      // If an XON char is pending to be sent, do it now
-      if (xon_xoff_state == XON_CHAR) {
-
-        // Send the character
-        HWUART->UART_THR = XON_CHAR;
-
-        // Remember we sent it.
-        xon_xoff_state = XON_CHAR | XON_XOFF_CHAR_SENT;
-
-        // If nothing else to transmit, just disable TX interrupts.
-        if (h == t) HWUART->UART_IDR = UART_IDR_TXRDY;
-
-        return;
-      }
-    }
-
-    // If nothing to transmit, just disable TX interrupts. This could
-    // happen as the result of the non atomicity of the disabling of RX
-    // interrupts that could end reenabling TX interrupts as a side effect.
-    if (h == t) {
-      HWUART->UART_IDR = UART_IDR_TXRDY;
-      return;
-    }
-
-    // There is something to TX, Send the next byte
-    const uint8_t c = tx_buffer.buffer[t];
-    t = (t + 1) & (Cfg::TX_SIZE - 1);
-    HWUART->UART_THR = c;
-    tx_buffer.tail = t;
-
-    // Disable interrupts if there is nothing to transmit following this byte
-    if (h == t) HWUART->UART_IDR = UART_IDR_TXRDY;
-  }
-}
-
-template<typename Cfg>
-void MarlinSerial<Cfg>::UART_ISR() {
-  const uint32_t status = HWUART->UART_SR;
-
-  // Data received?
-  if (status & UART_SR_RXRDY) store_rxd_char();
-
-  if (Cfg::TX_SIZE > 0) {
-    // Something to send, and TX interrupts are enabled (meaning something to send)?
-    if ((status & UART_SR_TXRDY) && (HWUART->UART_IMR & UART_IMR_TXRDY)) _tx_thr_empty_irq();
-  }
-
-  // Acknowledge errors
-  if ((status & UART_SR_OVRE) || (status & UART_SR_FRAME)) {
-    if (Cfg::DROPPED_RX && (status & UART_SR_OVRE) && !++rx_dropped_bytes) --rx_dropped_bytes;
-    if (Cfg::RX_OVERRUNS && (status & UART_SR_OVRE) && !++rx_buffer_overruns) --rx_buffer_overruns;
-    if (Cfg::RX_FRAMING_ERRORS && (status & UART_SR_FRAME) && !++rx_framing_errors) --rx_framing_errors;
-
-    // TODO: error reporting outside ISR
-    HWUART->UART_CR = UART_CR_RSTSTA;
-  }
-}
-
-// Public Methods
-template<typename Cfg>
-void MarlinSerial<Cfg>::begin(const long baud_setting) {
-
-  // Disable UART interrupt in NVIC
-  NVIC_DisableIRQ( HWUART_IRQ );
-
-  // We NEED memory barriers to ensure Interrupts are actually disabled!
-  // ( https://dzone.com/articles/nvic-disabling-interrupts-on-arm-cortex-m-and-the )
-  __DSB();
-  __ISB();
-
-  // Disable clock
-  pmc_disable_periph_clk( HWUART_IRQ_ID );
-
-  // Configure PMC
-  pmc_enable_periph_clk( HWUART_IRQ_ID );
-
-  // Disable PDC channel
-  HWUART->UART_PTCR = UART_PTCR_RXTDIS | UART_PTCR_TXTDIS;
-
-  // Reset and disable receiver and transmitter
-  HWUART->UART_CR = UART_CR_RSTRX | UART_CR_RSTTX | UART_CR_RXDIS | UART_CR_TXDIS;
-
-  // Configure mode: 8bit, No parity, 1 bit stop
-  HWUART->UART_MR = UART_MR_CHMODE_NORMAL | US_MR_CHRL_8_BIT | US_MR_NBSTOP_1_BIT | UART_MR_PAR_NO;
-
-  // Configure baudrate (asynchronous, no oversampling)
-  HWUART->UART_BRGR = (SystemCoreClock / (baud_setting << 4));
-
-  // Configure interrupts
-  HWUART->UART_IDR = 0xFFFFFFFF;
-  HWUART->UART_IER = UART_IER_RXRDY | UART_IER_OVRE | UART_IER_FRAME;
-
-  // Install interrupt handler
-  install_isr(HWUART_IRQ, UART_ISR);
-
-  // Configure priority. We need a very high priority to avoid losing characters
-  // and we need to be able to preempt the Stepper ISR and everything else!
-  // (this could probably be fixed by using DMA with the Serial port)
-  NVIC_SetPriority(HWUART_IRQ, 1);
-
-  // Enable UART interrupt in NVIC
-  NVIC_EnableIRQ(HWUART_IRQ);
-
-  // Enable receiver and transmitter
-  HWUART->UART_CR = UART_CR_RXEN | UART_CR_TXEN;
-
-  if (Cfg::TX_SIZE > 0) _written = false;
-}
-
-template<typename Cfg>
-void MarlinSerial<Cfg>::end() {
-  // Disable UART interrupt in NVIC
-  NVIC_DisableIRQ( HWUART_IRQ );
-
-  // We NEED memory barriers to ensure Interrupts are actually disabled!
-  // ( https://dzone.com/articles/nvic-disabling-interrupts-on-arm-cortex-m-and-the )
-  __DSB();
-  __ISB();
-
-  pmc_disable_periph_clk( HWUART_IRQ_ID );
-}
-
-template<typename Cfg>
-int MarlinSerial<Cfg>::peek() {
-  const int v = rx_buffer.head == rx_buffer.tail ? -1 : rx_buffer.buffer[rx_buffer.tail];
-  return v;
-}
-
-template<typename Cfg>
-int MarlinSerial<Cfg>::read() {
-
-  const ring_buffer_pos_t h = rx_buffer.head;
-  ring_buffer_pos_t t = rx_buffer.tail;
-
-  if (h == t) return -1;
-
-  int v = rx_buffer.buffer[t];
-  t = (ring_buffer_pos_t)(t + 1) & (Cfg::RX_SIZE - 1);
-
-  // Advance tail
-  rx_buffer.tail = t;
-
-  if (Cfg::XONOFF) {
-    // If the XOFF char was sent, or about to be sent...
-    if ((xon_xoff_state & XON_XOFF_CHAR_MASK) == XOFF_CHAR) {
-      // Get count of bytes in the RX buffer
-      const ring_buffer_pos_t rx_count = (ring_buffer_pos_t)(h - t) & (ring_buffer_pos_t)(Cfg::RX_SIZE - 1);
-      // When below 10% of RX buffer capacity, send XON before running out of RX buffer bytes
-      if (rx_count < (Cfg::RX_SIZE) / 10) {
-        if (Cfg::TX_SIZE > 0) {
-          // Signal we want an XON character to be sent.
-          xon_xoff_state = XON_CHAR;
-          // Enable TX isr.
-          HWUART->UART_IER = UART_IER_TXRDY;
-        }
-        else {
-          // If not using TX interrupts, we must send the XON char now
-          xon_xoff_state = XON_CHAR | XON_XOFF_CHAR_SENT;
-          while (!(HWUART->UART_SR & UART_SR_TXRDY)) sw_barrier();
-          HWUART->UART_THR = XON_CHAR;
-        }
-      }
-    }
-  }
-
-  return v;
-}
-
-template<typename Cfg>
-typename MarlinSerial<Cfg>::ring_buffer_pos_t MarlinSerial<Cfg>::available() {
-  const ring_buffer_pos_t h = rx_buffer.head, t = rx_buffer.tail;
-  return (ring_buffer_pos_t)(Cfg::RX_SIZE + h - t) & (Cfg::RX_SIZE - 1);
-}
-
-template<typename Cfg>
-void MarlinSerial<Cfg>::flush() {
-  rx_buffer.tail = rx_buffer.head;
-
-  if (Cfg::XONOFF) {
-    if ((xon_xoff_state & XON_XOFF_CHAR_MASK) == XOFF_CHAR) {
-      if (Cfg::TX_SIZE > 0) {
-        // Signal we want an XON character to be sent.
-        xon_xoff_state = XON_CHAR;
-        // Enable TX isr.
-        HWUART->UART_IER = UART_IER_TXRDY;
-      }
-      else {
-        // If not using TX interrupts, we must send the XON char now
-        xon_xoff_state = XON_CHAR | XON_XOFF_CHAR_SENT;
-        while (!(HWUART->UART_SR & UART_SR_TXRDY)) sw_barrier();
-        HWUART->UART_THR = XON_CHAR;
-      }
-    }
-  }
-}
-
-template<typename Cfg>
-void MarlinSerial<Cfg>::write(const uint8_t c) {
-  _written = true;
-
-  if (Cfg::TX_SIZE == 0) {
-    while (!(HWUART->UART_SR & UART_SR_TXRDY)) sw_barrier();
-    HWUART->UART_THR = c;
-  }
-  else {
-
-    // If the TX interrupts are disabled and the data register
-    // is empty, just write the byte to the data register and
-    // be done. This shortcut helps significantly improve the
-    // effective datarate at high (>500kbit/s) bitrates, where
-    // interrupt overhead becomes a slowdown.
-    // Yes, there is a race condition between the sending of the
-    // XOFF char at the RX isr, but it is properly handled there
-    if (!(HWUART->UART_IMR & UART_IMR_TXRDY) && (HWUART->UART_SR & UART_SR_TXRDY)) {
-      HWUART->UART_THR = c;
-      return;
-    }
-
-    const uint8_t i = (tx_buffer.head + 1) & (Cfg::TX_SIZE - 1);
-
-    // If global interrupts are disabled (as the result of being called from an ISR)...
-    if (!ISRS_ENABLED()) {
-
-      // Make room by polling if it is possible to transmit, and do so!
-      while (i == tx_buffer.tail) {
-        // If we can transmit another byte, do it.
-        if (HWUART->UART_SR & UART_SR_TXRDY) _tx_thr_empty_irq();
-        // Make sure compiler rereads tx_buffer.tail
-        sw_barrier();
-      }
-    }
-    else {
-      // Interrupts are enabled, just wait until there is space
-      while (i == tx_buffer.tail) sw_barrier();
-    }
-
-    // Store new char. head is always safe to move
-    tx_buffer.buffer[tx_buffer.head] = c;
-    tx_buffer.head = i;
-
-    // Enable TX isr - Non atomic, but it will eventually enable TX isr
-    HWUART->UART_IER = UART_IER_TXRDY;
-  }
-}
-
-template<typename Cfg>
-void MarlinSerial<Cfg>::flushTX() {
-  // TX
-
-  if (Cfg::TX_SIZE == 0) {
-    // No bytes written, no need to flush. This special case is needed since there's
-    // no way to force the TXC (transmit complete) bit to 1 during initialization.
-    if (!_written) return;
-
-    // Wait until everything was transmitted
-    while (!(HWUART->UART_SR & UART_SR_TXEMPTY)) sw_barrier();
-
-    // At this point nothing is queued anymore (DRIE is disabled) and
-    // the hardware finished transmission (TXC is set).
-
-  }
-  else {
-    // If we have never written a byte, no need to flush. This special
-    // case is needed since there is no way to force the TXC (transmit
-    // complete) bit to 1 during initialization
-    if (!_written) return;
-
-    // If global interrupts are disabled (as the result of being called from an ISR)...
-    if (!ISRS_ENABLED()) {
-
-      // Wait until everything was transmitted - We must do polling, as interrupts are disabled
-      while (tx_buffer.head != tx_buffer.tail || !(HWUART->UART_SR & UART_SR_TXEMPTY)) {
-        // If there is more space, send an extra character
-        if (HWUART->UART_SR & UART_SR_TXRDY) _tx_thr_empty_irq();
-        sw_barrier();
-      }
-
-    }
-    else {
-      // Wait until everything was transmitted
-      while (tx_buffer.head != tx_buffer.tail || !(HWUART->UART_SR & UART_SR_TXEMPTY)) sw_barrier();
-    }
-
-    // At this point nothing is queued anymore (DRIE is disabled) and
-    // the hardware finished transmission (TXC is set).
-  }
-}
-
-/**
- * Imports from print.h
- */
-
-template<typename Cfg>
-void MarlinSerial<Cfg>::print(char c, int base) {
-  print((long)c, base);
-}
-
-template<typename Cfg>
-void MarlinSerial<Cfg>::print(unsigned char b, int base) {
-  print((unsigned long)b, base);
-}
-
-template<typename Cfg>
-void MarlinSerial<Cfg>::print(int n, int base) {
-  print((long)n, base);
-}
-
-template<typename Cfg>
-void MarlinSerial<Cfg>::print(unsigned int n, int base) {
-  print((unsigned long)n, base);
-}
-
-template<typename Cfg>
-void MarlinSerial<Cfg>::print(long n, int base) {
-  if (base == 0) write(n);
-  else if (base == 10) {
-    if (n < 0) { print('-'); n = -n; }
-    printNumber(n, 10);
-  }
-  else
-    printNumber(n, base);
-}
-
-template<typename Cfg>
-void MarlinSerial<Cfg>::print(unsigned long n, int base) {
-  if (base == 0) write(n);
-  else printNumber(n, base);
-}
-
-template<typename Cfg>
-void MarlinSerial<Cfg>::print(double n, int digits) {
-  printFloat(n, digits);
-}
-
-template<typename Cfg>
-void MarlinSerial<Cfg>::println() {
-  print('\r');
-  print('\n');
-}
-
-template<typename Cfg>
-void MarlinSerial<Cfg>::println(const String& s) {
-  print(s);
-  println();
-}
-
-template<typename Cfg>
-void MarlinSerial<Cfg>::println(const char c[]) {
-  print(c);
-  println();
-}
-
-template<typename Cfg>
-void MarlinSerial<Cfg>::println(char c, int base) {
-  print(c, base);
-  println();
-}
-
-template<typename Cfg>
-void MarlinSerial<Cfg>::println(unsigned char b, int base) {
-  print(b, base);
-  println();
-}
-
-template<typename Cfg>
-void MarlinSerial<Cfg>::println(int n, int base) {
-  print(n, base);
-  println();
-}
-
-template<typename Cfg>
-void MarlinSerial<Cfg>::println(unsigned int n, int base) {
-  print(n, base);
-  println();
-}
-
-template<typename Cfg>
-void MarlinSerial<Cfg>::println(long n, int base) {
-  print(n, base);
-  println();
-}
-
-template<typename Cfg>
-void MarlinSerial<Cfg>::println(unsigned long n, int base) {
-  print(n, base);
-  println();
-}
-
-template<typename Cfg>
-void MarlinSerial<Cfg>::println(double n, int digits) {
-  print(n, digits);
-  println();
-}
-
-// Private Methods
-template<typename Cfg>
-void MarlinSerial<Cfg>::printNumber(unsigned long n, uint8_t base) {
-  if (n) {
-    unsigned char buf[8 * sizeof(long)]; // Enough space for base 2
-    int8_t i = 0;
-    while (n) {
-      buf[i++] = n % base;
-      n /= base;
-    }
-    while (i--)
-      print((char)(buf[i] + (buf[i] < 10 ? '0' : 'A' - 10)));
-  }
-  else
-    print('0');
-}
-
-template<typename Cfg>
-void MarlinSerial<Cfg>::printFloat(double number, uint8_t digits) {
-  // Handle negative numbers
-  if (number < 0.0) {
-    print('-');
-    number = -number;
-  }
-
-  // Round correctly so that print(1.999, 2) prints as "2.00"
-  double rounding = 0.5;
-  LOOP_L_N(i, digits) rounding *= 0.1;
-  number += rounding;
-
-  // Extract the integer part of the number and print it
-  unsigned long int_part = (unsigned long)number;
-  double remainder = number - (double)int_part;
-  print(int_part);
-
-  // Print the decimal point, but only if there are digits beyond
-  if (digits) {
-    print('.');
-    // Extract digits from the remainder one at a time
-    while (digits--) {
-      remainder *= 10.0;
-      int toPrint = int(remainder);
-      print(toPrint);
-      remainder -= toPrint;
-    }
-  }
-}
-
-// If not using the USB port as serial port
-#if SERIAL_PORT >= 0
-
-  // Preinstantiate
-  template class MarlinSerial<MarlinSerialCfg<SERIAL_PORT>>;
-
-  // Instantiate
-  MarlinSerial<MarlinSerialCfg<SERIAL_PORT>> customizedSerial1;
-
-#endif
-
-#ifdef SERIAL_PORT_2
-
-  // Preinstantiate
-  template class MarlinSerial<MarlinSerialCfg<SERIAL_PORT_2>>;
-
-  // Instantiate
-  MarlinSerial<MarlinSerialCfg<SERIAL_PORT_2>> customizedSerial2;
-
-#endif
-
-#endif // ARDUINO_ARCH_SAM
--- a/Marlin/src/HAL/DUE/MarlinSerial.h
+++ b/Marlin/src/HAL/DUE/MarlinSerial.h
@@ -1,184 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-/**
- * MarlinSerial_Due.h - Hardware serial library for Arduino DUE
- * Copyright (c) 2017 Eduardo José Tagle. All right reserved
- * Based on MarlinSerial for AVR, copyright (c) 2006 Nicholas Zambetti.  All right reserved.
- */
-
-#include <WString.h>
-
-#include "../../inc/MarlinConfigPre.h"
-
-#define DEC 10
-#define HEX 16
-#define OCT 8
-#define BIN 2
-
-// Define constants and variables for buffering incoming serial data.  We're
-// using a ring buffer (I think), in which rx_buffer_head is the index of the
-// location to which to write the next incoming character and rx_buffer_tail
-// is the index of the location from which to read.
-// 256 is the max limit due to uint8_t head and tail. Use only powers of 2. (...,16,32,64,128,256)
-#ifndef RX_BUFFER_SIZE
-  #define RX_BUFFER_SIZE 128
-#endif
-#ifndef TX_BUFFER_SIZE
-  #define TX_BUFFER_SIZE 32
-#endif
-
-//#if ENABLED(SERIAL_XON_XOFF) && RX_BUFFER_SIZE < 1024
-//  #error "SERIAL_XON_XOFF requires RX_BUFFER_SIZE >= 1024 for reliable transfers without drops."
-//#elif RX_BUFFER_SIZE && (RX_BUFFER_SIZE < 2 || !IS_POWER_OF_2(RX_BUFFER_SIZE))
-//  #error "RX_BUFFER_SIZE must be a power of 2 greater than 1."
-//#elif TX_BUFFER_SIZE && (TX_BUFFER_SIZE < 2 || TX_BUFFER_SIZE > 256 || !IS_POWER_OF_2(TX_BUFFER_SIZE))
-//  #error "TX_BUFFER_SIZE must be 0, a power of 2 greater than 1, and no greater than 256."
-//#endif
-
-// Templated type selector
-template<bool b, typename T, typename F> struct TypeSelector { typedef T type;} ;
-template<typename T, typename F> struct TypeSelector<false, T, F> { typedef F type; };
-
-// Templated structure wrapper
-template<typename S, unsigned int addr> struct StructWrapper {
-  constexpr StructWrapper(int) {}
-  FORCE_INLINE S* operator->() const { return (S*)addr; }
-};
-
-template<typename Cfg>
-class MarlinSerial {
-protected:
-  // Information for all supported UARTs
-  static constexpr uint32_t BASES[] = {0x400E0800U, 0x40098000U, 0x4009C000U, 0x400A0000U, 0x400A4000U};
-  static constexpr IRQn_Type IRQS[] = {  UART_IRQn, USART0_IRQn, USART1_IRQn, USART2_IRQn, USART3_IRQn};
-  static constexpr int    IRQ_IDS[] = {    ID_UART,   ID_USART0,   ID_USART1,   ID_USART2,   ID_USART3};
-
-  // Alias for shorter code
-  static constexpr StructWrapper<Uart,BASES[Cfg::PORT]> HWUART = 0;
-  static constexpr IRQn_Type HWUART_IRQ = IRQS[Cfg::PORT];
-  static constexpr int HWUART_IRQ_ID = IRQ_IDS[Cfg::PORT];
-
-  // Base size of type on buffer size
-  typedef typename TypeSelector<(Cfg::RX_SIZE>256), uint16_t, uint8_t>::type ring_buffer_pos_t;
-
-  struct ring_buffer_r {
-    volatile ring_buffer_pos_t head, tail;
-    unsigned char buffer[Cfg::RX_SIZE];
-  };
-
-  struct ring_buffer_t {
-    volatile uint8_t head, tail;
-    unsigned char buffer[Cfg::TX_SIZE];
-  };
-
-  static ring_buffer_r rx_buffer;
-  static ring_buffer_t tx_buffer;
-  static bool _written;
-
-  static constexpr uint8_t XON_XOFF_CHAR_SENT = 0x80,  // XON / XOFF Character was sent
-                           XON_XOFF_CHAR_MASK = 0x1F;  // XON / XOFF character to send
-
-  // XON / XOFF character definitions
-  static constexpr uint8_t XON_CHAR  = 17, XOFF_CHAR = 19;
-  static uint8_t xon_xoff_state,
-                 rx_dropped_bytes,
-                 rx_buffer_overruns,
-                 rx_framing_errors;
-  static ring_buffer_pos_t rx_max_enqueued;
-
-  FORCE_INLINE static void store_rxd_char();
-  FORCE_INLINE static void _tx_thr_empty_irq();
-  static void UART_ISR();
-
-public:
-  MarlinSerial() {};
-  static void begin(const long);
-  static void end();
-  static int peek();
-  static int read();
-  static void flush();
-  static ring_buffer_pos_t available();
-  static void write(const uint8_t c);
-  static void flushTX();
-
-  FORCE_INLINE static uint8_t dropped() { return Cfg::DROPPED_RX ? rx_dropped_bytes : 0; }
-  FORCE_INLINE static uint8_t buffer_overruns() { return Cfg::RX_OVERRUNS ? rx_buffer_overruns : 0; }
-  FORCE_INLINE static uint8_t framing_errors() { return Cfg::RX_FRAMING_ERRORS ? rx_framing_errors : 0; }
-  FORCE_INLINE static ring_buffer_pos_t rxMaxEnqueued() { return Cfg::MAX_RX_QUEUED ? rx_max_enqueued : 0; }
-
-  FORCE_INLINE static void write(const char* str) { while (*str) write(*str++); }
-  FORCE_INLINE static void write(const uint8_t* buffer, size_t size) { while (size--) write(*buffer++); }
-  FORCE_INLINE static void print(const String& s) { for (int i = 0; i < (int)s.length(); i++) write(s[i]); }
-  FORCE_INLINE static void print(const char* str) { write(str); }
-
-  static void print(char, int = 0);
-  static void print(unsigned char, int = 0);
-  static void print(int, int = DEC);
-  static void print(unsigned int, int = DEC);
-  static void print(long, int = DEC);
-  static void print(unsigned long, int = DEC);
-  static void print(double, int = 2);
-
-  static void println(const String& s);
-  static void println(const char[]);
-  static void println(char, int = 0);
-  static void println(unsigned char, int = 0);
-  static void println(int, int = DEC);
-  static void println(unsigned int, int = DEC);
-  static void println(long, int = DEC);
-  static void println(unsigned long, int = DEC);
-  static void println(double, int = 2);
-  static void println();
-  operator bool() { return true; }
-
-private:
-  static void printNumber(unsigned long, const uint8_t);
-  static void printFloat(double, uint8_t);
-};
-
-// Serial port configuration
-template <uint8_t serial>
-struct MarlinSerialCfg {
-  static constexpr int PORT               = serial;
-  static constexpr unsigned int RX_SIZE   = RX_BUFFER_SIZE;
-  static constexpr unsigned int TX_SIZE   = TX_BUFFER_SIZE;
-  static constexpr bool XONOFF            = ENABLED(SERIAL_XON_XOFF);
-  static constexpr bool EMERGENCYPARSER   = ENABLED(EMERGENCY_PARSER);
-  static constexpr bool DROPPED_RX        = ENABLED(SERIAL_STATS_DROPPED_RX);
-  static constexpr bool RX_OVERRUNS       = ENABLED(SERIAL_STATS_RX_BUFFER_OVERRUNS);
-  static constexpr bool RX_FRAMING_ERRORS = ENABLED(SERIAL_STATS_RX_FRAMING_ERRORS);
-  static constexpr bool MAX_RX_QUEUED     = ENABLED(SERIAL_STATS_MAX_RX_QUEUED);
-};
-
-#if SERIAL_PORT >= 0
-
-  extern MarlinSerial<MarlinSerialCfg<SERIAL_PORT>> customizedSerial1;
-
-#endif // SERIAL_PORT >= 0
-
-#ifdef SERIAL_PORT_2
-
-  extern MarlinSerial<MarlinSerialCfg<SERIAL_PORT_2>> customizedSerial2;
-
-#endif
--- a/Marlin/src/HAL/DUE/dogm/u8g_com_HAL_DUE_sw_spi.cpp
+++ b/Marlin/src/HAL/DUE/dogm/u8g_com_HAL_DUE_sw_spi.cpp
@@ -1,148 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * Based on u8g_com_std_sw_spi.c
- *
- * Universal 8bit Graphics Library
- *
- * Copyright (c) 2015, olikraus@gmail.com
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- *
- *  * Redistributions of source code must retain the above copyright notice, this list
- *    of conditions and the following disclaimer.
- *
- *  * Redistributions in binary form must reproduce the above copyright notice, this
- *    list of conditions and the following disclaimer in the documentation and/or other
- *    materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifdef ARDUINO_ARCH_SAM
-
-#include "../../../inc/MarlinConfigPre.h"
-
-#if HAS_GRAPHICAL_LCD && DISABLED(U8GLIB_ST7920)
-
-#undef SPI_SPEED
-#define SPI_SPEED 2  // About 2 MHz
-
-#include "u8g_com_HAL_DUE_sw_spi_shared.h"
-
-#include "../../shared/Marduino.h"
-#include "../../shared/Delay.h"
-
-#include <U8glib.h>
-
-#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
-#endif
-
-uint8_t u8g_com_HAL_DUE_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) {
-  switch (msg) {
-    case U8G_COM_MSG_INIT:
-      SCK_pPio = g_APinDescription[u8g->pin_list[U8G_PI_SCK]].pPort;
-      SCK_dwMask = g_APinDescription[u8g->pin_list[U8G_PI_SCK]].ulPin;
-      MOSI_pPio = g_APinDescription[u8g->pin_list[U8G_PI_MOSI]].pPort;
-      MOSI_dwMask = g_APinDescription[u8g->pin_list[U8G_PI_MOSI]].ulPin;
-      u8g_SetPIOutput_DUE(u8g, U8G_PI_SCK);
-      u8g_SetPIOutput_DUE(u8g, U8G_PI_MOSI);
-      u8g_SetPIOutput_DUE(u8g, U8G_PI_CS);
-      u8g_SetPIOutput_DUE(u8g, U8G_PI_A0);
-      if (U8G_PIN_NONE != u8g->pin_list[U8G_PI_RESET]) u8g_SetPIOutput_DUE(u8g, U8G_PI_RESET);
-      u8g_SetPILevel_DUE(u8g, U8G_PI_SCK, 0);
-      u8g_SetPILevel_DUE(u8g, U8G_PI_MOSI, 0);
-      break;
-
-    case U8G_COM_MSG_STOP:
-      break;
-
-    case U8G_COM_MSG_RESET:
-      if (U8G_PIN_NONE != u8g->pin_list[U8G_PI_RESET]) u8g_SetPILevel_DUE(u8g, U8G_PI_RESET, arg_val);
-      break;
-
-    case U8G_COM_MSG_CHIP_SELECT:
-      #if ENABLED(FYSETC_MINI_12864)           // LCD SPI is running mode 3 while SD card is running mode 0
-        if (arg_val) {                        //   SCK idle state needs to be set to the proper idle state before
-                                               //   the next chip select goes active
-          u8g_SetPILevel_DUE(u8g, U8G_PI_SCK, 1);  //set SCK to mode 3 idle state before CS goes active
-          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
-        }
-      #else
-        u8g_SetPILevel_DUE(u8g, U8G_PI_CS, !arg_val);
-      #endif
-      break;
-
-    case U8G_COM_MSG_WRITE_BYTE:
-      SPISEND_SW_DUE(arg_val);
-      break;
-
-    case U8G_COM_MSG_WRITE_SEQ: {
-        uint8_t *ptr = (uint8_t *)arg_ptr;
-        while (arg_val > 0) {
-          SPISEND_SW_DUE(*ptr++);
-          arg_val--;
-        }
-      }
-      break;
-
-      case U8G_COM_MSG_WRITE_SEQ_P: {
-        uint8_t *ptr = (uint8_t *)arg_ptr;
-        while (arg_val > 0) {
-          SPISEND_SW_DUE(u8g_pgm_read(ptr));
-          ptr++;
-          arg_val--;
-        }
-      }
-      break;
-
-    case U8G_COM_MSG_ADDRESS:                     /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
-      u8g_SetPILevel_DUE(u8g, U8G_PI_A0, arg_val);
-      break;
-  }
-  return 1;
-}
-
-#endif // HAS_GRAPHICAL_LCD && !U8GLIB_ST7920
-#endif // ARDUINO_ARCH_SAM
--- a/Marlin/src/HAL/DUE/dogm/u8g_com_HAL_DUE_sw_spi_shared.cpp
+++ b/Marlin/src/HAL/DUE/dogm/u8g_com_HAL_DUE_sw_spi_shared.cpp
@@ -1,112 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * Based on u8g_com_st7920_hw_spi.c
- *
- * Universal 8bit Graphics Library
- *
- * Copyright (c) 2011, olikraus@gmail.com
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- *
- *  * Redistributions of source code must retain the above copyright notice, this list
- *    of conditions and the following disclaimer.
- *
- *  * Redistributions in binary form must reproduce the above copyright notice, this
- *    list of conditions and the following disclaimer in the documentation and/or other
- *    materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifdef ARDUINO_ARCH_SAM
-
-#include "../../../inc/MarlinConfigPre.h"
-
-#if HAS_GRAPHICAL_LCD
-
-#include "../../shared/Delay.h"
-
-#include <U8glib.h>
-
-#include "u8g_com_HAL_DUE_sw_spi_shared.h"
-
-void u8g_SetPIOutput_DUE(u8g_t *u8g, uint8_t pin_index) {
-  PIO_Configure(g_APinDescription[u8g->pin_list[pin_index]].pPort, PIO_OUTPUT_1,
-    g_APinDescription[u8g->pin_list[pin_index]].ulPin, g_APinDescription[u8g->pin_list[pin_index]].ulPinConfiguration);  // OUTPUT
-}
-
-void u8g_SetPILevel_DUE(u8g_t *u8g, uint8_t pin_index, uint8_t level) {
-  volatile Pio* port = g_APinDescription[u8g->pin_list[pin_index]].pPort;
-  uint32_t mask = g_APinDescription[u8g->pin_list[pin_index]].ulPin;
-  if (level) port->PIO_SODR = mask; else port->PIO_CODR = mask;
-}
-
-Pio *SCK_pPio, *MOSI_pPio;
-uint32_t SCK_dwMask, MOSI_dwMask;
-
-void u8g_spiSend_sw_DUE_mode_0(uint8_t val) { // 3MHz
-  LOOP_L_N(i, 8) {
-    if (val & 0x80)
-      MOSI_pPio->PIO_SODR = MOSI_dwMask;
-    else
-      MOSI_pPio->PIO_CODR = MOSI_dwMask;
-    DELAY_NS(48);
-    SCK_pPio->PIO_SODR = SCK_dwMask;
-    DELAY_NS(905);
-    val <<= 1;
-    SCK_pPio->PIO_CODR = SCK_dwMask;
-  }
-}
-
-void u8g_spiSend_sw_DUE_mode_3(uint8_t val) { // 3.5MHz
-  LOOP_L_N(i, 8) {
-    SCK_pPio->PIO_CODR = SCK_dwMask;
-    DELAY_NS(50);
-    if (val & 0x80)
-      MOSI_pPio->PIO_SODR = MOSI_dwMask;
-    else
-      MOSI_pPio->PIO_CODR = MOSI_dwMask;
-    val <<= 1;
-    DELAY_NS(10);
-    SCK_pPio->PIO_SODR = SCK_dwMask;
-    DELAY_NS(70);
-  }
-}
-
-#endif // HAS_GRAPHICAL_LCD
-#endif // ARDUINO_ARCH_SAM
--- a/Marlin/src/HAL/DUE/dogm/u8g_com_HAL_DUE_sw_spi_shared.h
+++ b/Marlin/src/HAL/DUE/dogm/u8g_com_HAL_DUE_sw_spi_shared.h
@@ -1,35 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-#include "../../../inc/MarlinConfigPre.h"
-#include "../../shared/Marduino.h"
-#include <U8glib.h>
-
-void u8g_SetPIOutput_DUE(u8g_t *u8g, uint8_t pin_index);
-void u8g_SetPILevel_DUE(u8g_t *u8g, uint8_t pin_index, uint8_t level);
-
-void u8g_spiSend_sw_DUE_mode_0(uint8_t val);
-void u8g_spiSend_sw_DUE_mode_3(uint8_t val);
-
-extern Pio *SCK_pPio, *MOSI_pPio;
-extern uint32_t SCK_dwMask, MOSI_dwMask;
--- a/Marlin/src/HAL/DUE/fastio/G2_PWM.cpp
+++ b/Marlin/src/HAL/DUE/fastio/G2_PWM.cpp
@@ -1,145 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * The PWM module is only used to generate interrupts at specified times. It
- * is NOT used to directly toggle pins. The ISR writes to the pin assigned to
- * that interrupt.
- *
- * All PWMs use the same repetition rate.  The G2 needs about 10KHz min in order to
- * not have obvious ripple on the Vref signals.
- *
- * The data structures are setup to minimize the computation done by the ISR which
- * minimizes ISR execution time.  Execution times are 0.8 to 1.1 microseconds.
- *
- * FIve PWM interrupt sources are used.  Channel 0 sets the base period.  All Vref
- * signals are set active when this counter overflows and resets to zero.  The compare
- * values in channels 1-4 are set to give the desired duty cycle for that Vref pin.
- * When counter 0 matches the compare value then that channel generates an interrupt.
- * The ISR checks the source of the interrupt and sets the corresponding pin inactive.
- *
- * Some jitter in the Vref signal is OK so the interrupt priority is left at its default value.
- */
-
-#include "../../../inc/MarlinConfig.h"
-
-#if MB(PRINTRBOARD_G2)
-
-#include "G2_PWM.h"
-
-volatile uint32_t *SODR_A = &PIOA->PIO_SODR,
-                  *SODR_B = &PIOB->PIO_SODR,
-                  *CODR_A = &PIOA->PIO_CODR,
-                  *CODR_B = &PIOB->PIO_CODR;
-
-PWM_map ISR_table[NUM_PWMS] = PWM_MAP_INIT;
-
-void Stepper::digipot_init() {
-
-  OUT_WRITE(MOTOR_CURRENT_PWM_X_PIN, 0);  // init pins
-  OUT_WRITE(MOTOR_CURRENT_PWM_Y_PIN, 0);
-  OUT_WRITE(MOTOR_CURRENT_PWM_Z_PIN, 0);
-  OUT_WRITE(MOTOR_CURRENT_PWM_E_PIN, 0);
-
-  #define WPKEY          (0x50574D << 8) // “PWM” in ASCII
-  #define WPCMD_DIS_SW   0  // command to disable Write Protect SW
-  #define WPRG_ALL       (PWM_WPCR_WPRG0 | PWM_WPCR_WPRG1 | PWM_WPCR_WPRG2 | PWM_WPCR_WPRG3 | PWM_WPCR_WPRG4 | PWM_WPCR_WPRG5)  // all Write Protect Groups
-
-  #define PWM_CLOCK_F    F_CPU / 1000000UL   // set clock to 1MHz
-
-  PMC->PMC_PCER1 = PMC_PCER1_PID36;                       // enable PWM controller clock (disabled on power up)
-
-  PWM->PWM_WPCR = WPKEY | WPRG_ALL | WPCMD_DIS_SW;        // enable setting of all PWM registers
-  PWM->PWM_CLK = PWM_CLOCK_F;                             // enable CLK_A and set it to 1MHz, leave CLK_B disabled
-  PWM->PWM_CH_NUM[0].PWM_CMR = 0b1011;                    // set channel 0 to Clock A input & to left aligned
-  PWM->PWM_CH_NUM[1].PWM_CMR = 0b1011;                    // set channel 1 to Clock A input & to left aligned
-  PWM->PWM_CH_NUM[2].PWM_CMR = 0b1011;                    // set channel 2 to Clock A input & to left aligned
-  PWM->PWM_CH_NUM[3].PWM_CMR = 0b1011;                    // set channel 3 to Clock A input & to left aligned
-  PWM->PWM_CH_NUM[4].PWM_CMR = 0b1011;                    // set channel 4 to Clock A input & to left aligned
-
-  PWM->PWM_CH_NUM[0].PWM_CPRD = PWM_PERIOD_US;            // set channel 0 Period
-
-  PWM->PWM_IER2 = PWM_IER1_CHID0;                         // generate interrupt when counter0 overflows
-  PWM->PWM_IER2 = PWM_IER2_CMPM0 | PWM_IER2_CMPM1 | PWM_IER2_CMPM2 | PWM_IER2_CMPM3 | PWM_IER2_CMPM4;        // generate interrupt on compare event
-
-  PWM->PWM_CMP[1].PWM_CMPV = 0x010000000LL | G2_VREF_COUNT(G2_VREF(motor_current_setting[0]));   // interrupt when counter0 == CMPV - used to set Motor 1 PWM inactive
-  PWM->PWM_CMP[2].PWM_CMPV = 0x010000000LL | G2_VREF_COUNT(G2_VREF(motor_current_setting[0]));   // interrupt when counter0 == CMPV - used to set Motor 2 PWM inactive
-  PWM->PWM_CMP[3].PWM_CMPV = 0x010000000LL | G2_VREF_COUNT(G2_VREF(motor_current_setting[1]));   // interrupt when counter0 == CMPV - used to set Motor 3 PWM inactive
-  PWM->PWM_CMP[4].PWM_CMPV = 0x010000000LL | G2_VREF_COUNT(G2_VREF(motor_current_setting[2]));   // interrupt when counter0 == CMPV - used to set Motor 4 PWM inactive
-
-  PWM->PWM_CMP[1].PWM_CMPM = 0x0001;  // enable compare event
-  PWM->PWM_CMP[2].PWM_CMPM = 0x0001;  // enable compare event
-  PWM->PWM_CMP[3].PWM_CMPM = 0x0001;  // enable compare event
-  PWM->PWM_CMP[4].PWM_CMPM = 0x0001;  // enable compare event
-
-  PWM->PWM_SCM = PWM_SCM_UPDM_MODE0 | PWM_SCM_SYNC0 | PWM_SCM_SYNC1 | PWM_SCM_SYNC2 | PWM_SCM_SYNC3 | PWM_SCM_SYNC4; // sync 1-4 with 0, use mode 0 for updates
-
-  PWM->PWM_ENA = PWM_ENA_CHID0 | PWM_ENA_CHID1 | PWM_ENA_CHID2 | PWM_ENA_CHID3 | PWM_ENA_CHID4;         // enable the channels used by G2
-  PWM->PWM_IER1 = PWM_IER1_CHID0 | PWM_IER1_CHID1 | PWM_IER1_CHID2 | PWM_IER1_CHID3 | PWM_IER1_CHID4;        // enable interrupts for the channels used by G2
-
-  NVIC_EnableIRQ(PWM_IRQn);     // Enable interrupt handler
-  NVIC_SetPriority(PWM_IRQn, NVIC_EncodePriority(0, 10, 0));  // normal priority for PWM module (can stand some jitter on the Vref signals)
-}
-
-void Stepper::digipot_current(const uint8_t driver, const int16_t current) {
-
-  if (!(PWM->PWM_CH_NUM[0].PWM_CPRD == PWM_PERIOD_US)) digipot_init();  // Init PWM system if needed
-
-  switch (driver) {
-    case 0: PWM->PWM_CMP[1].PWM_CMPVUPD = 0x010000000LL | G2_VREF_COUNT(G2_VREF(current));    // update X & Y
-            PWM->PWM_CMP[2].PWM_CMPVUPD = 0x010000000LL | G2_VREF_COUNT(G2_VREF(current));
-            PWM->PWM_CMP[1].PWM_CMPMUPD = 0x0001;  // enable compare event
-            PWM->PWM_CMP[2].PWM_CMPMUPD = 0x0001;  // enable compare event
-            PWM->PWM_SCUC = PWM_SCUC_UPDULOCK; // tell the PWM controller to update the values on the next cycle
-            break;
-    case 1: PWM->PWM_CMP[3].PWM_CMPVUPD = 0x010000000LL | G2_VREF_COUNT(G2_VREF(current));    // update Z
-            PWM->PWM_CMP[3].PWM_CMPMUPD = 0x0001;  // enable compare event
-            PWM->PWM_SCUC = PWM_SCUC_UPDULOCK; // tell the PWM controller to update the values on the next cycle
-            break;
-    default:PWM->PWM_CMP[4].PWM_CMPVUPD = 0x010000000LL | G2_VREF_COUNT(G2_VREF(current));    // update E
-            PWM->PWM_CMP[4].PWM_CMPMUPD = 0x0001;  // enable compare event
-            PWM->PWM_SCUC = PWM_SCUC_UPDULOCK; // tell the PWM controller to update the values on the next cycle
-            break;
-  }
-}
-
-volatile uint32_t PWM_ISR1_STATUS, PWM_ISR2_STATUS;
-
-void PWM_Handler() {
-  PWM_ISR1_STATUS = PWM->PWM_ISR1;
-  PWM_ISR2_STATUS = PWM->PWM_ISR2;
-  if (PWM_ISR1_STATUS & PWM_IER1_CHID0) {                           // CHAN_0 interrupt
-    *ISR_table[0].set_register = ISR_table[0].write_mask;                                          // set X to active
-    *ISR_table[1].set_register = ISR_table[1].write_mask;                                          // set Y to active
-    *ISR_table[2].set_register = ISR_table[2].write_mask;                                          // set Z to active
-    *ISR_table[3].set_register = ISR_table[3].write_mask;                                          // set E to active
-  }
-  else {
-    if (PWM_ISR2_STATUS & PWM_IER2_CMPM1)  *ISR_table[0].clr_register = ISR_table[0].write_mask;   // set X to inactive
-    if (PWM_ISR2_STATUS & PWM_IER2_CMPM2)  *ISR_table[1].clr_register = ISR_table[1].write_mask;   // set Y to inactive
-    if (PWM_ISR2_STATUS & PWM_IER2_CMPM3)  *ISR_table[2].clr_register = ISR_table[2].write_mask;   // set Z to inactive
-    if (PWM_ISR2_STATUS & PWM_IER2_CMPM4)  *ISR_table[3].clr_register = ISR_table[3].write_mask;   // set E to inactive
-  }
-  return;
-}
-
-#endif // PRINTRBOARD_G2
--- a/Marlin/src/HAL/DUE/fastio/G2_PWM.h
+++ b/Marlin/src/HAL/DUE/fastio/G2_PWM.h
@@ -1,78 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-/**
- * This module is stripped down version of the LPC1768_PWM.h file from
- * PR #7500. It is hardwired for the PRINTRBOARD_G2 Motor Current needs.
- */
-
-#include "../../../inc/MarlinConfigPre.h"
-#include "../../../module/stepper.h"
-//C:\Users\bobku\Documents\GitHub\Marlin-Bob-2\Marlin\src\module\stepper.h
-//C:\Users\bobku\Documents\GitHub\Marlin-Bob-2\Marlin\src\HAL\HAL_DUE\G2_PWM.h
-
-#define PWM_PERIOD_US  100  // base repetition rate in micro seconds
-
-typedef struct {       // holds the data needed by the ISR to control the Vref pin
-  volatile uint32_t* set_register;
-  volatile uint32_t* clr_register;
-  uint32_t write_mask;
-} PWM_map;
-
-#define G2_VREF(I) (uint32_t)(I * 5 * 0.15)   // desired Vref * 1000 (scaled so don't loose accuracy in next step)
-
-#define G2_VREF_COUNT(Q) (uint32_t)map(constrain(Q, 500, 3.3 * 1000), 0, 3.3 * 1000, 0, PWM_PERIOD_US)  // under 500  the results are very non-linear
-
-extern volatile uint32_t *SODR_A, *SODR_B, *CODR_A, *CODR_B;
-
-#define _PIN(IO) (DIO ## IO ## _PIN)
-
-#define PWM_MAP_INIT_ROW(IO,ZZ) { ZZ == 'A' ? SODR_A : SODR_B,  ZZ == 'A' ? CODR_A : CODR_B, 1 << _PIN(IO) }
-
-
-#define PWM_MAP_INIT {  PWM_MAP_INIT_ROW(MOTOR_CURRENT_PWM_X_PIN, 'B'), \
-                        PWM_MAP_INIT_ROW(MOTOR_CURRENT_PWM_Y_PIN, 'B'), \
-                        PWM_MAP_INIT_ROW(MOTOR_CURRENT_PWM_Z_PIN, 'B'), \
-                        PWM_MAP_INIT_ROW(MOTOR_CURRENT_PWM_E_PIN, 'A'), \
-                     };
-
-#define NUM_PWMS 4
-
-extern PWM_map ISR_table[NUM_PWMS];
-
-extern uint32_t motor_current_setting[3];
-
-#define IR_BIT(p) (WITHIN(p, 0, 3) ? (p) : (p) + 4)
-#define COPY_ACTIVE_TABLE() do{ LOOP_L_N(i, 6) work_table[i] = active_table[i]; }while(0)
-
-#define PWM_MR0 19999         // base repetition rate minus one count - 20mS
-#define PWM_PR 24             // prescaler value - prescaler divide by 24 + 1  -  1 MHz output
-#define PWM_PCLKSEL0 0x00     // select clock source for prescaler - defaults to 25MHz on power up
-                              // 0: 25MHz, 1: 100MHz, 2: 50MHz, 3: 12.5MHZ to PWM1 prescaler
-#define MR0_MARGIN 200        // if channel value too close to MR0 the system locks up
-
-extern bool PWM_table_swap;   // flag to tell the ISR that the tables have been swapped
-
-#define HAL_G2_PWM_ISR  void PWM_Handler()
-
-extern volatile uint32_t PWM_ISR1_STATUS, PWM_ISR2_STATUS;
--- a/Marlin/src/HAL/DUE/fastio/G2_pins.h
+++ b/Marlin/src/HAL/DUE/fastio/G2_pins.h
@@ -1,278 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-#include <stdint.h>
-
-/**
- * This file contains the custom port/pin definitions for the PRINTRBOARD_G2
- * motherboard. This motherboard uses the SAM3X8C which is a subset of the
- * SAM3X8E used in the DUE board.  It uses port/pin pairs that are not
- * available using the DUE definitions.
- *
- * The first part is a copy of the pin descriptions in the
- * "variants\arduino_due_x\variant.cpp" file but with pins 34-41 replaced by
- * the G2 pins.
- *
- * The second part is the FASTIO port/pin definitions.
- *
- * THESE PINS CAN ONLY BE ACCESSED VIA FASTIO COMMANDS.
- */
-
-/*
-  Copyright (c) 2011 Arduino.  All right reserved.
-
-  This library is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License as published by the Free Software Foundation; either
-  version 2.1 of the License, or (at your option) any later version.
-
-  This library 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 Lesser General Public License for more details.
-
-  You should have received a copy of the GNU Lesser General Public
-  License along with this library; if not, write to the Free Software
-  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-*/
-
-typedef struct _G2_PinDescription {
-  Pio* pPort;
-  uint32_t ulPin;
-  uint32_t ulPeripheralId;
-  EPioType ulPinType;
-  uint32_t ulPinConfiguration;
-  uint32_t ulPinAttribute;
-  EAnalogChannel ulAnalogChannel; /* Analog pin in the Arduino context (label on the board) */
-  EAnalogChannel ulADCChannelNumber; /* ADC Channel number in the SAM device */
-  EPWMChannel ulPWMChannel;
-  ETCChannel ulTCChannel;
-} G2_PinDescription;
-
-/**
- * This section is a copy of the pin descriptions in the "variants\arduino_due_x\variant.cpp" file
- * with pins 34-41 replaced by the G2 pins.
- */
-
-/**
- * Pins descriptions
- */
-const G2_PinDescription G2_g_APinDescription[] = {
-  // 0 .. 53 - Digital pins
-  // ----------------------
-  // 0/1 - UART (Serial)
-  { PIOA, PIO_PA8A_URXD,     ID_PIOA, PIO_PERIPH_A, PIO_DEFAULT,  PIN_ATTR_DIGITAL,                 NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // URXD
-  { PIOA, PIO_PA9A_UTXD,     ID_PIOA, PIO_PERIPH_A, PIO_DEFAULT,  PIN_ATTR_DIGITAL,                 NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // UTXD
-
-  // 2
-  { PIOB, PIO_PB25B_TIOA0,   ID_PIOB, PIO_PERIPH_B, PIO_DEFAULT, (PIN_ATTR_DIGITAL|PIN_ATTR_TIMER), NO_ADC, NO_ADC, NOT_ON_PWM,  TC0_CHA0     }, // TIOA0
-  { PIOC, PIO_PC28B_TIOA7,   ID_PIOC, PIO_PERIPH_B, PIO_DEFAULT, (PIN_ATTR_DIGITAL|PIN_ATTR_TIMER), NO_ADC, NO_ADC, NOT_ON_PWM,  TC2_CHA7     }, // TIOA7
-  { PIOC, PIO_PC26B_TIOB6,   ID_PIOC, PIO_PERIPH_B, PIO_DEFAULT, (PIN_ATTR_DIGITAL|PIN_ATTR_TIMER), NO_ADC, NO_ADC, NOT_ON_PWM,  TC2_CHB6     }, // TIOB6
-
-  // 5
-  { PIOC, PIO_PC25B_TIOA6,   ID_PIOC, PIO_PERIPH_B, PIO_DEFAULT, (PIN_ATTR_DIGITAL|PIN_ATTR_TIMER), NO_ADC, NO_ADC, NOT_ON_PWM,  TC2_CHA6     }, // TIOA6
-  { PIOC, PIO_PC24B_PWML7,   ID_PIOC, PIO_PERIPH_B, PIO_DEFAULT, (PIN_ATTR_DIGITAL|PIN_ATTR_PWM),   NO_ADC, NO_ADC, PWM_CH7,     NOT_ON_TIMER }, // PWML7
-  { PIOC, PIO_PC23B_PWML6,   ID_PIOC, PIO_PERIPH_B, PIO_DEFAULT, (PIN_ATTR_DIGITAL|PIN_ATTR_PWM),   NO_ADC, NO_ADC, PWM_CH6,     NOT_ON_TIMER }, // PWML6
-  { PIOC, PIO_PC22B_PWML5,   ID_PIOC, PIO_PERIPH_B, PIO_DEFAULT, (PIN_ATTR_DIGITAL|PIN_ATTR_PWM),   NO_ADC, NO_ADC, PWM_CH5,     NOT_ON_TIMER }, // PWML5
-  { PIOC, PIO_PC21B_PWML4,   ID_PIOC, PIO_PERIPH_B, PIO_DEFAULT, (PIN_ATTR_DIGITAL|PIN_ATTR_PWM),   NO_ADC, NO_ADC, PWM_CH4,     NOT_ON_TIMER }, // PWML4
-  // 10
-  { PIOC, PIO_PC29B_TIOB7,   ID_PIOC, PIO_PERIPH_B, PIO_DEFAULT, (PIN_ATTR_DIGITAL|PIN_ATTR_TIMER), NO_ADC, NO_ADC, NOT_ON_PWM,  TC2_CHB7     }, // TIOB7
-  { PIOD, PIO_PD7B_TIOA8,    ID_PIOD, PIO_PERIPH_B, PIO_DEFAULT, (PIN_ATTR_DIGITAL|PIN_ATTR_TIMER), NO_ADC, NO_ADC, NOT_ON_PWM,  TC2_CHA8     }, // TIOA8
-  { PIOD, PIO_PD8B_TIOB8,    ID_PIOD, PIO_PERIPH_B, PIO_DEFAULT, (PIN_ATTR_DIGITAL|PIN_ATTR_TIMER), NO_ADC, NO_ADC, NOT_ON_PWM,  TC2_CHB8     }, // TIOB8
-
-  // 13 - AMBER LED
-  { PIOB, PIO_PB27B_TIOB0,   ID_PIOB, PIO_PERIPH_B, PIO_DEFAULT, (PIN_ATTR_DIGITAL|PIN_ATTR_TIMER), NO_ADC, NO_ADC, NOT_ON_PWM,  TC0_CHB0     }, // TIOB0
-
-  // 14/15 - USART3 (Serial3)
-  { PIOD, PIO_PD4B_TXD3,     ID_PIOD, PIO_PERIPH_B, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // TXD3
-  { PIOD, PIO_PD5B_RXD3,     ID_PIOD, PIO_PERIPH_B, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // RXD3
-
-  // 16/17 - USART1 (Serial2)
-  { PIOA, PIO_PA13A_TXD1,    ID_PIOA, PIO_PERIPH_A, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // TXD1
-  { PIOA, PIO_PA12A_RXD1,    ID_PIOA, PIO_PERIPH_A, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // RXD1
-
-  // 18/19 - USART0 (Serial1)
-  { PIOA, PIO_PA11A_TXD0,    ID_PIOA, PIO_PERIPH_A, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // TXD0
-  { PIOA, PIO_PA10A_RXD0,    ID_PIOA, PIO_PERIPH_A, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // RXD0
-
-  // 20/21 - TWI1
-  { PIOB, PIO_PB12A_TWD1,    ID_PIOB, PIO_PERIPH_A, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // TWD1 - SDA0
-  { PIOB, PIO_PB13A_TWCK1,   ID_PIOB, PIO_PERIPH_A, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // TWCK1 - SCL0
-
-  // 22
-  { PIOB, PIO_PB26,          ID_PIOB, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // PIN 22
-  { PIOA, PIO_PA14,          ID_PIOA, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // PIN 23
-  { PIOA, PIO_PA15,          ID_PIOA, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // PIN 24
-  { PIOD, PIO_PD0,           ID_PIOD, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // PIN 25
-
-  // 26
-  { PIOD, PIO_PD1,           ID_PIOD, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // PIN 26
-  { PIOD, PIO_PD2,           ID_PIOD, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // PIN 27
-  { PIOD, PIO_PD3,           ID_PIOD, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // PIN 28
-  { PIOD, PIO_PD6,           ID_PIOD, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // PIN 29
-
-  // 30
-  { PIOD, PIO_PD9,           ID_PIOD, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // PIN 30
-  { PIOA, PIO_PA7,           ID_PIOA, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // PIN 31
-  { PIOD, PIO_PD10,          ID_PIOD, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // PIN 32
-  { PIOC, PIO_PC1,           ID_PIOC, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // PIN 33
-
-  // 34
-
-  // start of custom pins
-  { PIOA, PIO_PA29,          ID_PIOA, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // PIN 34  Y_STEP_PIN
-  { PIOB, PIO_PB1,           ID_PIOB, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // PIN 35  Y_DIR_PIN
-  { PIOB, PIO_PB0,           ID_PIOB, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // PIN 36  Y_ENABLE_PIN
-  { PIOB, PIO_PB22,          ID_PIOB, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // PIN 37  E0_ENABLE_PIN
-  { PIOB, PIO_PB11,          ID_PIOB, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // PIN 38  E0_MS1_PIN
-  { PIOB, PIO_PB10,          ID_PIOB, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // PIN 39  E0_MS3_PIN
-  { PIOA, PIO_PA5,           ID_PIOA, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // PIN 40  HEATER_0_PIN
-  { PIOB, PIO_PB24,          ID_PIOB, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // PIN 41  HEATER_BED_PIN
-  // end of custom pins
-
-  // 42
-  { PIOA, PIO_PA19,          ID_PIOA, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // PIN 42
-  { PIOA, PIO_PA20,          ID_PIOA, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // PIN 43
-  { PIOC, PIO_PC19,          ID_PIOC, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // PIN 44
-  { PIOC, PIO_PC18,          ID_PIOC, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // PIN 45
-
-  // 46
-  { PIOC, PIO_PC17,          ID_PIOC, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // PIN 46
-  { PIOC, PIO_PC16,          ID_PIOC, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // PIN 47
-  { PIOC, PIO_PC15,          ID_PIOC, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // PIN 48
-  { PIOC, PIO_PC14,          ID_PIOC, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // PIN 49
-
-  // 50
-  { PIOC, PIO_PC13,          ID_PIOC, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // PIN 50
-  { PIOC, PIO_PC12,          ID_PIOC, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // PIN 51
-  { PIOB, PIO_PB21,          ID_PIOB, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // PIN 52
-  { PIOB, PIO_PB14,          ID_PIOB, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // PIN 53
-
-
-  // 54 .. 65 - Analog pins
-  // ----------------------
-  { PIOA, PIO_PA16X1_AD7,    ID_PIOA, PIO_INPUT,    PIO_DEFAULT, PIN_ATTR_ANALOG,                   ADC0,   ADC7,   NOT_ON_PWM,  NOT_ON_TIMER }, // AD0
-  { PIOA, PIO_PA24X1_AD6,    ID_PIOA, PIO_INPUT,    PIO_DEFAULT, PIN_ATTR_ANALOG,                   ADC1,   ADC6,   NOT_ON_PWM,  NOT_ON_TIMER }, // AD1
-  { PIOA, PIO_PA23X1_AD5,    ID_PIOA, PIO_INPUT,    PIO_DEFAULT, PIN_ATTR_ANALOG,                   ADC2,   ADC5,   NOT_ON_PWM,  NOT_ON_TIMER }, // AD2
-  { PIOA, PIO_PA22X1_AD4,    ID_PIOA, PIO_INPUT,    PIO_DEFAULT, PIN_ATTR_ANALOG,                   ADC3,   ADC4,   NOT_ON_PWM,  NOT_ON_TIMER }, // AD3
-  // 58
-  { PIOA, PIO_PA6X1_AD3,     ID_PIOA, PIO_INPUT,    PIO_DEFAULT, PIN_ATTR_ANALOG,                   ADC4,   ADC3,   NOT_ON_PWM,  TC0_CHB2     }, // AD4
-  { PIOA, PIO_PA4X1_AD2,     ID_PIOA, PIO_INPUT,    PIO_DEFAULT, PIN_ATTR_ANALOG,                   ADC5,   ADC2,   NOT_ON_PWM,  NOT_ON_TIMER }, // AD5
-  { PIOA, PIO_PA3X1_AD1,     ID_PIOA, PIO_INPUT,    PIO_DEFAULT, PIN_ATTR_ANALOG,                   ADC6,   ADC1,   NOT_ON_PWM,  TC0_CHB1     }, // AD6
-  { PIOA, PIO_PA2X1_AD0,     ID_PIOA, PIO_INPUT,    PIO_DEFAULT, PIN_ATTR_ANALOG,                   ADC7,   ADC0,   NOT_ON_PWM,  TC0_CHA1     }, // AD7
-  // 62
-  { PIOB, PIO_PB17X1_AD10,   ID_PIOB, PIO_INPUT,    PIO_DEFAULT, PIN_ATTR_ANALOG,                   ADC8,   ADC10,  NOT_ON_PWM,  NOT_ON_TIMER }, // AD8
-  { PIOB, PIO_PB18X1_AD11,   ID_PIOB, PIO_INPUT,    PIO_DEFAULT, PIN_ATTR_ANALOG,                   ADC9,   ADC11,  NOT_ON_PWM,  NOT_ON_TIMER }, // AD9
-  { PIOB, PIO_PB19X1_AD12,   ID_PIOB, PIO_INPUT,    PIO_DEFAULT, PIN_ATTR_ANALOG,                   ADC10,  ADC12,  NOT_ON_PWM,  NOT_ON_TIMER }, // AD10
-  { PIOB, PIO_PB20X1_AD13,   ID_PIOB, PIO_INPUT,    PIO_DEFAULT, PIN_ATTR_ANALOG,                   ADC11,  ADC13,  NOT_ON_PWM,  NOT_ON_TIMER }, // AD11
-
-  // 66/67 - DAC0/DAC1
-  { PIOB, PIO_PB15X1_DAC0,   ID_PIOB, PIO_INPUT,    PIO_DEFAULT, PIN_ATTR_ANALOG,                   ADC12,  DA0,    NOT_ON_PWM,  NOT_ON_TIMER }, // DAC0
-  { PIOB, PIO_PB16X1_DAC1,   ID_PIOB, PIO_INPUT,    PIO_DEFAULT, PIN_ATTR_ANALOG,                   ADC13,  DA1,    NOT_ON_PWM,  NOT_ON_TIMER }, // DAC1
-
-  // 68/69 - CANRX0/CANTX0
-  { PIOA, PIO_PA1A_CANRX0,   ID_PIOA, PIO_PERIPH_A, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  ADC14,  NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // CANRX
-  { PIOA, PIO_PA0A_CANTX0,   ID_PIOA, PIO_PERIPH_A, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  ADC15,  NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // CANTX
-
-  // 70/71 - TWI0
-  { PIOA, PIO_PA17A_TWD0,    ID_PIOA, PIO_PERIPH_A, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // TWD0 - SDA1
-  { PIOA, PIO_PA18A_TWCK0,   ID_PIOA, PIO_PERIPH_A, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // TWCK0 - SCL1
-
-  // 72/73 - LEDs
-  { PIOC, PIO_PC30,          ID_PIOC, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // LED AMBER RXL
-  { PIOA, PIO_PA21,          ID_PIOA, PIO_OUTPUT_0, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // LED AMBER TXL
-
-  // 74/75/76 - SPI
-  { PIOA, PIO_PA25A_SPI0_MISO,ID_PIOA,PIO_PERIPH_A, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // MISO
-  { PIOA, PIO_PA26A_SPI0_MOSI,ID_PIOA,PIO_PERIPH_A, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // MOSI
-  { PIOA, PIO_PA27A_SPI0_SPCK,ID_PIOA,PIO_PERIPH_A, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // SPCK
-
-  // 77 - SPI CS0
-  { PIOA, PIO_PA28A_SPI0_NPCS0,ID_PIOA,PIO_PERIPH_A,PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // NPCS0
-
-  // 78 - SPI CS3 (unconnected)
-  { PIOB, PIO_PB23B_SPI0_NPCS3,ID_PIOB,PIO_PERIPH_B,PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // NPCS3
-
-  // 79 .. 84 - "All pins" masks
-
-  // 79 - TWI0 all pins
-  { PIOA, PIO_PA17A_TWD0|PIO_PA18A_TWCK0, ID_PIOA, PIO_PERIPH_A, PIO_DEFAULT, (PIN_ATTR_DIGITAL|PIN_ATTR_COMBO), NO_ADC, NO_ADC, NOT_ON_PWM, NOT_ON_TIMER },
-  // 80 - TWI1 all pins
-  { PIOB, PIO_PB12A_TWD1|PIO_PB13A_TWCK1, ID_PIOB, PIO_PERIPH_A, PIO_DEFAULT, (PIN_ATTR_DIGITAL|PIN_ATTR_COMBO), NO_ADC, NO_ADC, NOT_ON_PWM, NOT_ON_TIMER },
-  // 81 - UART (Serial) all pins
-  { PIOA, PIO_PA8A_URXD|PIO_PA9A_UTXD, ID_PIOA, PIO_PERIPH_A, PIO_DEFAULT, (PIN_ATTR_DIGITAL|PIN_ATTR_COMBO), NO_ADC, NO_ADC, NOT_ON_PWM, NOT_ON_TIMER },
-  // 82 - USART0 (Serial1) all pins
-  { PIOA, PIO_PA11A_TXD0|PIO_PA10A_RXD0, ID_PIOA, PIO_PERIPH_A, PIO_DEFAULT, (PIN_ATTR_DIGITAL|PIN_ATTR_COMBO), NO_ADC, NO_ADC, NOT_ON_PWM, NOT_ON_TIMER },
-  // 83 - USART1 (Serial2) all pins
-  { PIOA, PIO_PA13A_TXD1|PIO_PA12A_RXD1, ID_PIOA, PIO_PERIPH_A, PIO_DEFAULT, (PIN_ATTR_DIGITAL|PIN_ATTR_COMBO), NO_ADC, NO_ADC, NOT_ON_PWM, NOT_ON_TIMER },
-  // 84 - USART3 (Serial3) all pins
-  { PIOD, PIO_PD4B_TXD3|PIO_PD5B_RXD3, ID_PIOD, PIO_PERIPH_B, PIO_DEFAULT, (PIN_ATTR_DIGITAL|PIN_ATTR_COMBO), NO_ADC, NO_ADC, NOT_ON_PWM, NOT_ON_TIMER },
-
-  // 85 - USB
-  { PIOB, PIO_PB11A_UOTGID|PIO_PB10A_UOTGVBOF, ID_PIOB, PIO_PERIPH_A, PIO_DEFAULT, PIN_ATTR_DIGITAL,NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // ID - VBOF
-
-  // 86 - SPI CS2
-  { PIOB, PIO_PB21B_SPI0_NPCS2, ID_PIOB, PIO_PERIPH_B, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // NPCS2
-
-  // 87 - SPI CS1
-  { PIOA, PIO_PA29A_SPI0_NPCS1, ID_PIOA, PIO_PERIPH_A, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // NPCS1
-
-  // 88/89 - CANRX1/CANTX1 (same physical pin for 66/53)
-  { PIOB, PIO_PB15A_CANRX1,     ID_PIOB, PIO_PERIPH_A, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // CANRX1
-  { PIOB, PIO_PB14A_CANTX1,     ID_PIOB, PIO_PERIPH_A, PIO_DEFAULT, PIN_ATTR_DIGITAL,                  NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER }, // CANTX1
-
-  // 90 .. 91 - "All CAN pins" masks
-  // 90 - CAN0 all pins
-  { PIOA, PIO_PA1A_CANRX0|PIO_PA0A_CANTX0, ID_PIOA, PIO_PERIPH_A, PIO_DEFAULT, (PIN_ATTR_DIGITAL|PIN_ATTR_COMBO), NO_ADC,  NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER },
-  // 91 - CAN1 all pins
-  { PIOB, PIO_PB15A_CANRX1|PIO_PB14A_CANTX1, ID_PIOB, PIO_PERIPH_A, PIO_DEFAULT, (PIN_ATTR_DIGITAL|PIN_ATTR_COMBO), NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER },
-
-  // END
-  { nullptr, 0, 0, PIO_NOT_A_PIN, PIO_DEFAULT, 0, NO_ADC, NO_ADC, NOT_ON_PWM, NOT_ON_TIMER }
-};
-
-// This section replaces the FASTIO definitions of pins 34-41
-
-#define DIO34_PIN 29
-#define DIO34_WPORT PIOA  // only available via FASTIO      //       34 PA29 - Y_STEP_PIN
-
-#define DIO35_PIN 1
-#define DIO35_WPORT PIOB  // only available via FASTIO      //       35 PAB1 - Y_DIR_PIN
-
-#define DIO36_PIN 0
-#define DIO36_WPORT PIOB  // only available via FASTIO      //       36 PB0 - Y_ENABLE_PIN
-
-#define DIO37_PIN 22
-#define DIO37_WPORT PIOB  // only available via FASTIO      //       37 PB22 - E0_ENABLE_PIN
-
-#define DIO38_PIN 11
-#define DIO38_WPORT PIOB  // only available via FASTIO      //       38 PB11 - E0_MS1_PIN
-
-#define DIO39_PIN 10
-#define DIO39_WPORT PIOB  // only available via FASTIO      //       39 PB10 - E0_MS3_PIN
-
-#define DIO40_PIN 5
-#define DIO40_WPORT PIOA  // only available via FASTIO      //       40 PA5  - HEATER_0_PIN
-
-#define DIO41_PIN 24
-#define DIO41_WPORT PIOB  // only available via FASTIO      //       41 PB24 - HEATER_BED_PIN
--- a/Marlin/src/HAL/DUE/inc/Conditionals_LCD.h
+++ b/Marlin/src/HAL/DUE/inc/Conditionals_LCD.h
@@ -1,22 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#pragma once
--- a/Marlin/src/HAL/DUE/inc/Conditionals_adv.h
+++ b/Marlin/src/HAL/DUE/inc/Conditionals_adv.h
@@ -1,22 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#pragma once
--- a/Marlin/src/HAL/ESP32/FlushableHardwareSerial.cpp
+++ b/Marlin/src/HAL/ESP32/FlushableHardwareSerial.cpp
@@ -1,33 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#include "FlushableHardwareSerial.h"
-
-#ifdef ARDUINO_ARCH_ESP32
-
-FlushableHardwareSerial::FlushableHardwareSerial(int uart_nr)
-    : HardwareSerial(uart_nr)
-{}
-
-FlushableHardwareSerial flushableSerial(0);
-
-#endif // ARDUINO_ARCH_ESP32
--- a/Marlin/src/HAL/ESP32/FlushableHardwareSerial.h
+++ b/Marlin/src/HAL/ESP32/FlushableHardwareSerial.h
@@ -1,37 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-#ifdef ARDUINO_ARCH_ESP32
-
-#include <HardwareSerial.h>
-
-class FlushableHardwareSerial : public HardwareSerial {
-public:
-  FlushableHardwareSerial(int uart_nr);
-
-  inline void flushTX() { /* No need to flush the hardware serial, but defined here for compatibility. */ }
-};
-
-extern FlushableHardwareSerial flushableSerial;
-
-#endif // ARDUINO_ARCH_ESP32
--- a/Marlin/src/HAL/ESP32/HAL.cpp
+++ b/Marlin/src/HAL/ESP32/HAL.cpp
@@ -1,303 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifdef ARDUINO_ARCH_ESP32
-
-#include "HAL.h"
-#include "timers.h"
-#include <rom/rtc.h>
-#include <driver/adc.h>
-#include <esp_adc_cal.h>
-#include <HardwareSerial.h>
-
-#include "../../inc/MarlinConfigPre.h"
-
-#if ENABLED(WIFISUPPORT)
-  #include <ESPAsyncWebServer.h>
-  #include "wifi.h"
-  #if ENABLED(OTASUPPORT)
-    #include "ota.h"
-  #endif
-  #if ENABLED(WEBSUPPORT)
-    #include "spiffs.h"
-    #include "web.h"
-  #endif
-#endif
-
-// ------------------------
-// Externs
-// ------------------------
-
-portMUX_TYPE spinlock = portMUX_INITIALIZER_UNLOCKED;
-
-// ------------------------
-// Local defines
-// ------------------------
-
-#define V_REF 1100
-
-// ------------------------
-// Public Variables
-// ------------------------
-
-uint16_t HAL_adc_result;
-
-// ------------------------
-// Private Variables
-// ------------------------
-
-esp_adc_cal_characteristics_t characteristics[ADC_ATTEN_MAX];
-adc_atten_t attenuations[ADC1_CHANNEL_MAX] = {};
-uint32_t thresholds[ADC_ATTEN_MAX];
-volatile int numPWMUsed = 0,
-             pwmPins[MAX_PWM_PINS],
-             pwmValues[MAX_PWM_PINS];
-
-// ------------------------
-// Public functions
-// ------------------------
-
-#if ENABLED(WIFI_CUSTOM_COMMAND)
-
-  bool wifi_custom_command(char * const command_ptr) {
-    #if ENABLED(ESP3D_WIFISUPPORT)
-      return esp3dlib.parse(command_ptr);
-    #else
-      UNUSED(command_ptr);
-      return false;
-    #endif
-  }
-
-#endif
-
-void HAL_init() { i2s_init(); }
-
-void HAL_init_board() {
-
-  #if ENABLED(ESP3D_WIFISUPPORT)
-    esp3dlib.init();
-  #elif ENABLED(WIFISUPPORT)
-    wifi_init();
-    #if ENABLED(OTASUPPORT)
-      OTA_init();
-    #endif
-    #if ENABLED(WEBSUPPORT)
-      spiffs_init();
-      web_init();
-    #endif
-    server.begin();
-  #endif
-
-  // ESP32 uses a GPIO matrix that allows pins to be assigned to hardware serial ports.
-  // The following code initializes hardware Serial1 and Serial2 to use user-defined pins
-  // if they have been defined.
-  #if defined(HARDWARE_SERIAL1_RX) && defined(HARDWARE_SERIAL1_TX)
-    HardwareSerial Serial1(1);
-    #ifdef TMC_BAUD_RATE  // use TMC_BAUD_RATE for Serial1 if defined
-      Serial1.begin(TMC_BAUD_RATE, SERIAL_8N1, HARDWARE_SERIAL1_RX, HARDWARE_SERIAL1_TX);
-    #else  // use default BAUDRATE if TMC_BAUD_RATE not defined
-      Serial1.begin(BAUDRATE, SERIAL_8N1, HARDWARE_SERIAL1_RX, HARDWARE_SERIAL1_TX);
-    #endif
-  #endif
-  #if defined(HARDWARE_SERIAL2_RX) && defined(HARDWARE_SERIAL2_TX)
-    HardwareSerial Serial2(2);
-    #ifdef TMC_BAUD_RATE  // use TMC_BAUD_RATE for Serial1 if defined
-      Serial2.begin(TMC_BAUD_RATE, SERIAL_8N1, HARDWARE_SERIAL2_RX, HARDWARE_SERIAL2_TX);
-    #else  // use default BAUDRATE if TMC_BAUD_RATE not defined
-      Serial2.begin(BAUDRATE, SERIAL_8N1, HARDWARE_SERIAL2_RX, HARDWARE_SERIAL2_TX);
-    #endif
-  #endif
-
-}
-
-void HAL_idletask() {
-  #if BOTH(WIFISUPPORT, OTASUPPORT)
-    OTA_handle();
-  #endif
-  #if ENABLED(ESP3D_WIFISUPPORT)
-    esp3dlib.idletask();
-  #endif
-}
-
-void HAL_clear_reset_source() { }
-
-uint8_t HAL_get_reset_source() { return rtc_get_reset_reason(1); }
-
-void _delay_ms(int delay_ms) { delay(delay_ms); }
-
-// return free memory between end of heap (or end bss) and whatever is current
-int freeMemory() { return ESP.getFreeHeap(); }
-
-// ------------------------
-// ADC
-// ------------------------
-#define ADC1_CHANNEL(pin) ADC1_GPIO ## pin ## _CHANNEL
-
-adc1_channel_t get_channel(int pin) {
-  switch (pin) {
-    case 39: return ADC1_CHANNEL(39);
-    case 36: return ADC1_CHANNEL(36);
-    case 35: return ADC1_CHANNEL(35);
-    case 34: return ADC1_CHANNEL(34);
-    case 33: return ADC1_CHANNEL(33);
-    case 32: return ADC1_CHANNEL(32);
-  }
-  return ADC1_CHANNEL_MAX;
-}
-
-void adc1_set_attenuation(adc1_channel_t chan, adc_atten_t atten) {
-  if (attenuations[chan] != atten) {
-    adc1_config_channel_atten(chan, atten);
-    attenuations[chan] = atten;
-  }
-}
-
-void HAL_adc_init() {
-  // Configure ADC
-  adc1_config_width(ADC_WIDTH_12Bit);
-
-  // Configure channels only if used as (re-)configuring a pin for ADC that is used elsewhere might have adverse effects
-  #if HAS_TEMP_ADC_0
-    adc1_set_attenuation(get_channel(TEMP_0_PIN), ADC_ATTEN_11db);
-  #endif
-  #if HAS_TEMP_ADC_1
-    adc1_set_attenuation(get_channel(TEMP_1_PIN), ADC_ATTEN_11db);
-  #endif
-  #if HAS_TEMP_ADC_2
-    adc1_set_attenuation(get_channel(TEMP_2_PIN), ADC_ATTEN_11db);
-  #endif
-  #if HAS_TEMP_ADC_3
-    adc1_set_attenuation(get_channel(TEMP_3_PIN), ADC_ATTEN_11db);
-  #endif
-  #if HAS_TEMP_ADC_4
-    adc1_set_attenuation(get_channel(TEMP_4_PIN), ADC_ATTEN_11db);
-  #endif
-  #if HAS_TEMP_ADC_5
-    adc1_set_attenuation(get_channel(TEMP_5_PIN), ADC_ATTEN_11db);
-  #endif
-  #if HAS_TEMP_ADC_6
-    adc2_set_attenuation(get_channel(TEMP_6_PIN), ADC_ATTEN_11db);
-  #endif
-  #if HAS_TEMP_ADC_7
-    adc3_set_attenuation(get_channel(TEMP_7_PIN), ADC_ATTEN_11db);
-  #endif
-  #if HAS_HEATED_BED
-    adc1_set_attenuation(get_channel(TEMP_BED_PIN), ADC_ATTEN_11db);
-  #endif
-  #if HAS_TEMP_CHAMBER
-    adc1_set_attenuation(get_channel(TEMP_CHAMBER_PIN), ADC_ATTEN_11db);
-  #endif
-  #if ENABLED(FILAMENT_WIDTH_SENSOR)
-    adc1_set_attenuation(get_channel(FILWIDTH_PIN), ADC_ATTEN_11db);
-  #endif
-
-  // Note that adc2 is shared with the WiFi module, which has higher priority, so the conversion may fail.
-  // That's why we're not setting it up here.
-
-  // Calculate ADC characteristics (i.e., gain and offset factors for each attenuation level)
-  for (int i = 0; i < ADC_ATTEN_MAX; i++) {
-    esp_adc_cal_characterize(ADC_UNIT_1, (adc_atten_t)i, ADC_WIDTH_BIT_12, V_REF, &characteristics[i]);
-
-    // Change attenuation 100mV below the calibrated threshold
-    thresholds[i] = esp_adc_cal_raw_to_voltage(4095, &characteristics[i]);
-  }
-}
-
-void HAL_adc_start_conversion(const uint8_t adc_pin) {
-  const adc1_channel_t chan = get_channel(adc_pin);
-  uint32_t mv;
-  esp_adc_cal_get_voltage((adc_channel_t)chan, &characteristics[attenuations[chan]], &mv);
-  HAL_adc_result = mv * 1023.0 / 3300.0;
-
-  // Change the attenuation level based on the new reading
-  adc_atten_t atten;
-  if (mv < thresholds[ADC_ATTEN_DB_0] - 100)
-    atten = ADC_ATTEN_DB_0;
-  else if (mv > thresholds[ADC_ATTEN_DB_0] - 50 && mv < thresholds[ADC_ATTEN_DB_2_5] - 100)
-    atten = ADC_ATTEN_DB_2_5;
-  else if (mv > thresholds[ADC_ATTEN_DB_2_5] - 50 && mv < thresholds[ADC_ATTEN_DB_6] - 100)
-    atten = ADC_ATTEN_DB_6;
-  else if (mv > thresholds[ADC_ATTEN_DB_6] - 50)
-    atten = ADC_ATTEN_DB_11;
-  else return;
-
-  adc1_set_attenuation(chan, atten);
-}
-
-void analogWrite(pin_t pin, int value) {
-  // Use ledc hardware for internal pins
-  if (pin < 34) {
-    static int cnt_channel = 1, pin_to_channel[40] = { 0 };
-    if (pin_to_channel[pin] == 0) {
-      ledcAttachPin(pin, cnt_channel);
-      ledcSetup(cnt_channel, 490, 8);
-      ledcWrite(cnt_channel, value);
-      pin_to_channel[pin] = cnt_channel++;
-    }
-    ledcWrite(pin_to_channel[pin], value);
-    return;
-  }
-
-  int idx = -1;
-
-  // Search Pin
-  for (int i = 0; i < numPWMUsed; ++i)
-    if (pwmPins[i] == pin) { idx = i; break; }
-
-  // not found ?
-  if (idx < 0) {
-    // No slots remaining
-    if (numPWMUsed >= MAX_PWM_PINS) return;
-
-    // Take new slot for pin
-    idx = numPWMUsed;
-    pwmPins[idx] = pin;
-    // Start timer on first use
-    if (idx == 0) HAL_timer_start(PWM_TIMER_NUM, PWM_TIMER_FREQUENCY);
-
-    ++numPWMUsed;
-  }
-
-  // Use 7bit internal value - add 1 to have 100% high at 255
-  pwmValues[idx] = (value + 1) / 2;
-}
-
-// Handle PWM timer interrupt
-HAL_PWM_TIMER_ISR() {
-  HAL_timer_isr_prologue(PWM_TIMER_NUM);
-
-  static uint8_t count = 0;
-
-  for (int i = 0; i < numPWMUsed; ++i) {
-    if (count == 0)                   // Start of interval
-      WRITE(pwmPins[i], pwmValues[i] ? HIGH : LOW);
-    else if (pwmValues[i] == count)   // End of duration
-      WRITE(pwmPins[i], LOW);
-  }
-
-  // 128 for 7 Bit resolution
-  count = (count + 1) & 0x7F;
-
-  HAL_timer_isr_epilogue(PWM_TIMER_NUM);
-}
-
-#endif // ARDUINO_ARCH_ESP32
--- a/Marlin/src/HAL/ESP32/HAL.h
+++ b/Marlin/src/HAL/ESP32/HAL.h
@@ -1,180 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- * Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * 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/>.
- */
-#pragma once
-
-/**
- * Description: HAL for Espressif ESP32 WiFi
- */
-
-#define CPU_32_BIT
-
-#include <stdint.h>
-
-#include "../shared/Marduino.h"
-#include "../shared/math_32bit.h"
-#include "../shared/HAL_SPI.h"
-
-#include "fastio.h"
-#include "watchdog.h"
-#include "i2s.h"
-
-#include "timers.h"
-
-#if ENABLED(WIFISUPPORT)
-  #include "WebSocketSerial.h"
-#endif
-
-#if ENABLED(ESP3D_WIFISUPPORT)
-  #include "esp3dlib.h"
-#endif
-
-#include "FlushableHardwareSerial.h"
-
-// ------------------------
-// Defines
-// ------------------------
-
-extern portMUX_TYPE spinlock;
-
-#define MYSERIAL0 flushableSerial
-
-#if EITHER(WIFISUPPORT, ESP3D_WIFISUPPORT)
-  #if ENABLED(ESP3D_WIFISUPPORT)
-    #define MYSERIAL1 Serial2Socket
-  #else
-    #define MYSERIAL1 webSocketSerial
-  #endif
-  #define NUM_SERIAL 2
-#else
-  #define NUM_SERIAL 1
-#endif
-
-#define CRITICAL_SECTION_START() portENTER_CRITICAL(&spinlock)
-#define CRITICAL_SECTION_END()   portEXIT_CRITICAL(&spinlock)
-#define ISRS_ENABLED() (spinlock.owner == portMUX_FREE_VAL)
-#define ENABLE_ISRS()  if (spinlock.owner != portMUX_FREE_VAL) portEXIT_CRITICAL(&spinlock)
-#define DISABLE_ISRS() portENTER_CRITICAL(&spinlock)
-
-// Fix bug in pgm_read_ptr
-#undef pgm_read_ptr
-#define pgm_read_ptr(addr) (*(addr))
-
-// ------------------------
-// Types
-// ------------------------
-
-typedef int16_t pin_t;
-
-#define HAL_SERVO_LIB Servo
-
-// ------------------------
-// Public Variables
-// ------------------------
-
-/** result of last ADC conversion */
-extern uint16_t HAL_adc_result;
-
-// ------------------------
-// Public functions
-// ------------------------
-
-// clear reset reason
-void HAL_clear_reset_source();
-
-// reset reason
-uint8_t HAL_get_reset_source();
-
-void _delay_ms(int delay);
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-function"
-int freeMemory();
-#pragma GCC diagnostic pop
-
-void analogWrite(pin_t pin, int value);
-
-// EEPROM
-void eeprom_write_byte(uint8_t *pos, unsigned char value);
-uint8_t eeprom_read_byte(uint8_t *pos);
-void eeprom_read_block (void *__dst, const void *__src, size_t __n);
-void eeprom_update_block (const void *__src, void *__dst, size_t __n);
-
-// ADC
-#define HAL_ANALOG_SELECT(pin)
-
-void HAL_adc_init();
-
-#define HAL_START_ADC(pin)  HAL_adc_start_conversion(pin)
-#define HAL_ADC_RESOLUTION  10
-#define HAL_READ_ADC()      HAL_adc_result
-#define HAL_ADC_READY()     true
-
-void HAL_adc_start_conversion(const uint8_t adc_pin);
-
-#define GET_PIN_MAP_PIN(index) index
-#define GET_PIN_MAP_INDEX(pin) pin
-#define PARSED_PIN_INDEX(code, dval) parser.intval(code, dval)
-
-// Enable hooks into idle and setup for HAL
-#define HAL_IDLETASK 1
-#define BOARD_INIT() HAL_init_board();
-void HAL_idletask();
-void HAL_init();
-void HAL_init_board();
-
-//
-// Delay in cycles (used by DELAY_NS / DELAY_US)
-//
-FORCE_INLINE static void DELAY_CYCLES(uint32_t x) {
-  unsigned long start, ccount, stop;
-
-  /**
-   * It's important to care for race conditions (and overflows) here.
-   * Race condition example: If `stop` calculates to being close to the upper boundary of
-   * `uint32_t` and if at the same time a longer loop interruption kicks in (e.g. due to other
-   * FreeRTOS tasks or interrupts), `ccount` might overflow (and therefore be below `stop` again)
-   * without the loop ever being able to notice that `ccount` had already been above `stop` once
-   * (and that therefore the number of cycles to delay has already passed).
-   * As DELAY_CYCLES (through DELAY_NS / DELAY_US) is used by software SPI bit banging to drive
-   * LCDs and therefore might be called very, very often, this seemingly improbable situation did
-   * actually happen in reality. It resulted in apparently random print pauses of ~17.9 seconds
-   * (0x100000000 / 240 MHz) or multiples thereof, essentially ruining the current print by causing
-   * large blobs of filament.
-   */
-
-  __asm__ __volatile__ ( "rsr     %0, ccount" : "=a" (start) );
-  stop = start + x;
-  ccount = start;
-
-  if (stop >= start) {
-    // no overflow, so only loop while in between start and stop:
-    // 0x00000000 -----------------start****stop-- 0xffffffff
-    while (ccount >= start && ccount < stop) {
-      __asm__ __volatile__ ( "rsr     %0, ccount" : "=a" (ccount) );
-    }
-  }
-  else {
-    // stop did overflow, so only loop while outside of stop and start:
-    // 0x00000000 **stop-------------------start** 0xffffffff
-    while (ccount >= start || ccount < stop) {
-      __asm__ __volatile__ ( "rsr     %0, ccount" : "=a" (ccount) );
-    }
-  }
-
-}
--- a/Marlin/src/HAL/ESP32/Servo.cpp
+++ b/Marlin/src/HAL/ESP32/Servo.cpp
@@ -1,71 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#ifdef ARDUINO_ARCH_ESP32
-
-#include "../../inc/MarlinConfig.h"
-
-#if HAS_SERVOS
-
-#include "Servo.h"
-
-// Adjacent channels (0/1, 2/3 etc.) share the same timer and therefore the same frequency and resolution settings on ESP32,
-// so we only allocate servo channels up high to avoid side effects with regards to analogWrite (fans, leds, laser pwm etc.)
-int Servo::channel_next_free = 12;
-
-Servo::Servo() {
-  channel = channel_next_free++;
-}
-
-int8_t Servo::attach(const int inPin) {
-  if (channel >= CHANNEL_MAX_NUM) return -1;
-  if (inPin > 0) pin = inPin;
-
-  ledcSetup(channel, 50, 16); // channel X, 50 Hz, 16-bit depth
-  ledcAttachPin(pin, channel);
-  return true;
-}
-
-void Servo::detach() { ledcDetachPin(pin); }
-
-int Servo::read() { return degrees; }
-
-void Servo::write(int inDegrees) {
-  degrees = constrain(inDegrees, MIN_ANGLE, MAX_ANGLE);
-  int us = map(degrees, MIN_ANGLE, MAX_ANGLE, MIN_PULSE_WIDTH, MAX_PULSE_WIDTH);
-  int duty = map(us, 0, TAU_USEC, 0, MAX_COMPARE);
-  ledcWrite(channel, duty);
-}
-
-void Servo::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(0) >= 0) {
-    write(value);
-    safe_delay(servo_delay[channel]);
-    #if ENABLED(DEACTIVATE_SERVOS_AFTER_MOVE)
-      detach();
-    #endif
-  }
-}
-#endif // HAS_SERVOS
-
-#endif // ARDUINO_ARCH_ESP32
--- a/Marlin/src/HAL/ESP32/Servo.h
+++ b/Marlin/src/HAL/ESP32/Servo.h
@@ -1,49 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-#include <Arduino.h>
-
-class Servo {
-  static const int MIN_ANGLE =   0,
-                   MAX_ANGLE = 180,
-                   MIN_PULSE_WIDTH =  544,  // Shortest pulse sent to a servo
-                   MAX_PULSE_WIDTH = 2400,  // Longest pulse sent to a servo
-                   TAU_MSEC = 20,
-                   TAU_USEC = (TAU_MSEC * 1000),
-                   MAX_COMPARE = ((1 << 16) - 1), // 65535
-                   CHANNEL_MAX_NUM = 16;
-
-public:
-  Servo();
-  int8_t attach(const int pin);   // attach the given pin to the next free channel, set pinMode, return channel number (-1 on fail)
-  void detach();
-  void write(int degrees);        // set angle
-  void move(const int degrees);   // attach the servo, then move to value
-  int read();                     // returns current pulse width as an angle between 0 and 180 degrees
-
-private:
-  static int channel_next_free;
-  int channel;
-  int pin;
-  int degrees;
-};
--- a/Marlin/src/HAL/ESP32/WebSocketSerial.cpp
+++ b/Marlin/src/HAL/ESP32/WebSocketSerial.cpp
@@ -1,153 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#ifdef ARDUINO_ARCH_ESP32
-
-#include "../../inc/MarlinConfigPre.h"
-
-#if ENABLED(WIFISUPPORT)
-
-#include "WebSocketSerial.h"
-#include "wifi.h"
-#include <ESPAsyncWebServer.h>
-
-WebSocketSerial webSocketSerial;
-AsyncWebSocket ws("/ws"); // TODO Move inside the class.
-
-// RingBuffer impl
-
-#define NEXT_INDEX(I, SIZE) ((I + 1) & (ring_buffer_pos_t)(SIZE - 1))
-
-RingBuffer::RingBuffer(ring_buffer_pos_t size)
-  : data(new uint8_t[size]),
-    size(size),
-    read_index(0),
-    write_index(0)
-{}
-
-RingBuffer::~RingBuffer() { delete[] data; }
-
-ring_buffer_pos_t RingBuffer::write(const uint8_t c) {
-  const ring_buffer_pos_t n = NEXT_INDEX(write_index, size);
-
-  if (n != read_index) {
-    this->data[write_index] = c;
-    write_index = n;
-    return 1;
-  }
-
-  // TODO: buffer is full, handle?
-  return 0;
-}
-
-ring_buffer_pos_t RingBuffer::write(const uint8_t *buffer, ring_buffer_pos_t size) {
-  ring_buffer_pos_t written = 0;
-  for (ring_buffer_pos_t i = 0; i < size; i++) {
-    written += write(buffer[i]);
-  }
-  return written;
-}
-
-int RingBuffer::available() {
-  return (size - read_index + write_index) & (size - 1);
-}
-
-int RingBuffer::peek() {
-  return available() ? data[read_index] : -1;
-}
-
-int RingBuffer::read() {
-  if (available()) {
-    const int ret = data[read_index];
-    read_index = NEXT_INDEX(read_index, size);
-    return ret;
-  }
-  return -1;
-}
-
-ring_buffer_pos_t RingBuffer::read(uint8_t *buffer) {
-   ring_buffer_pos_t len = available();
-
-  for(ring_buffer_pos_t i = 0; read_index != write_index; i++) {
-    buffer[i] = data[read_index];
-    read_index = NEXT_INDEX(read_index, size);
-  }
-
-  return len;
-}
-
-void RingBuffer::flush() { read_index = write_index; }
-
-// WebSocketSerial impl
-WebSocketSerial::WebSocketSerial()
-    : rx_buffer(RingBuffer(RX_BUFFER_SIZE)),
-      tx_buffer(RingBuffer(TX_BUFFER_SIZE))
-{}
-
-void WebSocketSerial::begin(const long baud_setting) {
-  ws.onEvent([this](AsyncWebSocket *server, AsyncWebSocketClient *client, AwsEventType type, void *arg, uint8_t *data, size_t len) {
-    switch (type) {
-      case WS_EVT_CONNECT: client->ping(); break; // client connected
-      case WS_EVT_DISCONNECT:                     // client disconnected
-      case WS_EVT_ERROR:                          // error was received from the other end
-      case WS_EVT_PONG: break;                    // pong message was received (in response to a ping request maybe)
-      case WS_EVT_DATA: {                         // data packet
-        AwsFrameInfo * info = (AwsFrameInfo*)arg;
-        if (info->opcode == WS_TEXT || info->message_opcode == WS_TEXT)
-          this->rx_buffer.write(data, len);
-      }
-    }
-  });
-  server.addHandler(&ws);
-}
-
-void WebSocketSerial::end() { }
-int WebSocketSerial::peek() { return rx_buffer.peek(); }
-int WebSocketSerial::read() { return rx_buffer.read(); }
-int WebSocketSerial::available() { return rx_buffer.available(); }
-void WebSocketSerial::flush() { rx_buffer.flush(); }
-
-size_t WebSocketSerial::write(const uint8_t c) {
-  size_t ret = tx_buffer.write(c);
-
-  if (ret && c == '\n') {
-    uint8_t tmp[TX_BUFFER_SIZE];
-    ring_buffer_pos_t size = tx_buffer.read(tmp);
-    ws.textAll(tmp, size);
-  }
-
-  return ret;
-}
-
-size_t WebSocketSerial::write(const uint8_t* buffer, size_t size) {
-  size_t written = 0;
-  for(size_t i = 0; i < size; i++) {
-    written += write(buffer[i]);
-  }
-  return written;
-}
-
-void WebSocketSerial::flushTX() {
-  // No need to do anything as there's no benefit to sending partial lines over the websocket connection.
-}
-
-#endif // WIFISUPPORT
-#endif // ARDUINO_ARCH_ESP32
--- a/Marlin/src/HAL/ESP32/WebSocketSerial.h
+++ b/Marlin/src/HAL/ESP32/WebSocketSerial.h
@@ -1,86 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-#include "../../inc/MarlinConfig.h"
-
-#include <Stream.h>
-
-#ifndef TX_BUFFER_SIZE
-  #define TX_BUFFER_SIZE 32
-#endif
-#if ENABLED(WIFISUPPORT)
-  #ifndef RX_BUFFER_SIZE
-    #define RX_BUFFER_SIZE 128
-  #endif
-  #if TX_BUFFER_SIZE <= 0
-    #error "TX_BUFFER_SIZE is required for the WebSocket."
-  #endif
-#endif
-
-typedef uint16_t ring_buffer_pos_t;
-
-class RingBuffer {
-  uint8_t *data;
-  ring_buffer_pos_t size, read_index, write_index;
-
-public:
-  RingBuffer(ring_buffer_pos_t size);
-  ~RingBuffer();
-
-  int available();
-  int peek();
-  int read();
-  ring_buffer_pos_t read(uint8_t *buffer);
-  void flush();
-  ring_buffer_pos_t write(const uint8_t c);
-  ring_buffer_pos_t write(const uint8_t* buffer, ring_buffer_pos_t size);
-};
-
-class WebSocketSerial: public Stream {
-  RingBuffer rx_buffer;
-  RingBuffer tx_buffer;
-
-public:
-  WebSocketSerial();
-  void begin(const long);
-  void end();
-  int available();
-  int peek();
-  int read();
-  void flush();
-  void flushTX();
-  size_t write(const uint8_t c);
-  size_t write(const uint8_t* buffer, size_t size);
-
-  operator bool() { return true; }
-
-  #if ENABLED(SERIAL_STATS_DROPPED_RX)
-    FORCE_INLINE uint32_t dropped() { return 0; }
-  #endif
-
-  #if ENABLED(SERIAL_STATS_MAX_RX_QUEUED)
-    FORCE_INLINE int rxMaxEnqueued() { return 0; }
-  #endif
-};
-
-extern WebSocketSerial webSocketSerial;
--- a/Marlin/src/HAL/ESP32/fastio.h
+++ b/Marlin/src/HAL/ESP32/fastio.h
@@ -1,84 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-#include "i2s.h"
-
-/**
- * Utility functions
- */
-
-// I2S expander pin mapping.
-#define IS_I2S_EXPANDER_PIN(IO) TEST(IO, 7)
-#define I2S_EXPANDER_PIN_INDEX(IO) (IO & 0x7F)
-
-// Set pin as input
-#define _SET_INPUT(IO)          pinMode(IO, INPUT)
-
-// Set pin as output
-#define _SET_OUTPUT(IO)         pinMode(IO, OUTPUT)
-
-// Set pin as input with pullup mode
-#define _PULLUP(IO, v)          pinMode(IO, v ? INPUT_PULLUP : INPUT)
-
-// Read a pin wrapper
-#define READ(IO)                (IS_I2S_EXPANDER_PIN(IO) ? i2s_state(I2S_EXPANDER_PIN_INDEX(IO)) : digitalRead(IO))
-
-// Write to a pin wrapper
-#define WRITE(IO, v)            (IS_I2S_EXPANDER_PIN(IO) ? i2s_write(I2S_EXPANDER_PIN_INDEX(IO), v) : digitalWrite(IO, v))
-
-// Set pin as input wrapper
-#define SET_INPUT(IO)           _SET_INPUT(IO)
-
-// Set pin as input with pullup wrapper
-#define SET_INPUT_PULLUP(IO)    do{ _SET_INPUT(IO); _PULLUP(IO, HIGH); }while(0)
-
-// Set pin as output wrapper
-#define SET_OUTPUT(IO)          do{ _SET_OUTPUT(IO); }while(0)
-
-// Set pin as PWM
-#define SET_PWM(IO)             SET_OUTPUT(IO)
-
-// Set pin as output and init
-#define OUT_WRITE(IO,V)         do{ _SET_OUTPUT(IO); WRITE(IO,V); }while(0)
-
-// digitalRead/Write wrappers
-#define extDigitalRead(IO)      digitalRead(IO)
-#define extDigitalWrite(IO,V)   digitalWrite(IO,V)
-
-// PWM outputs
-#define PWM_PIN(P)              (P < 34 || P > 127) // NOTE Pins >= 34 are input only on ESP32, so they can't be used for output.
-
-// Toggle pin value
-#define TOGGLE(IO)              WRITE(IO, !READ(IO))
-
-//
-// Ports and functions
-//
-
-// UART
-#define RXD        3
-#define TXD        1
-
-// TWI (I2C)
-#define SCL        5
-#define SDA        4
--- a/Marlin/src/HAL/ESP32/i2s.cpp
+++ b/Marlin/src/HAL/ESP32/i2s.cpp
@@ -1,343 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#ifdef ARDUINO_ARCH_ESP32
-
-#include "../../inc/MarlinConfigPre.h"
-
-#include "i2s.h"
-
-#include "../shared/Marduino.h"
-#include <driver/periph_ctrl.h>
-#include <rom/lldesc.h>
-#include <soc/i2s_struct.h>
-#include <freertos/queue.h>
-#include "../../module/stepper.h"
-
-#define DMA_BUF_COUNT 8                                // number of DMA buffers to store data
-#define DMA_BUF_LEN   4092                             // maximum size in bytes
-#define I2S_SAMPLE_SIZE 4                              // 4 bytes, 32 bits per sample
-#define DMA_SAMPLE_COUNT DMA_BUF_LEN / I2S_SAMPLE_SIZE // number of samples per buffer
-
-typedef enum {
-  I2S_NUM_0 = 0x0,  /*!< I2S 0*/
-  I2S_NUM_1 = 0x1,  /*!< I2S 1*/
-  I2S_NUM_MAX,
-} i2s_port_t;
-
-typedef struct {
-  uint32_t     **buffers;
-  uint32_t     *current;
-  uint32_t     rw_pos;
-  lldesc_t     **desc;
-  xQueueHandle queue;
-} i2s_dma_t;
-
-static portMUX_TYPE i2s_spinlock[I2S_NUM_MAX] = {portMUX_INITIALIZER_UNLOCKED, portMUX_INITIALIZER_UNLOCKED};
-static i2s_dev_t* I2S[I2S_NUM_MAX] = {&I2S0, &I2S1};
-static i2s_dma_t dma;
-
-// output value
-uint32_t i2s_port_data = 0;
-
-#define I2S_ENTER_CRITICAL()  portENTER_CRITICAL(&i2s_spinlock[i2s_num])
-#define I2S_EXIT_CRITICAL()   portEXIT_CRITICAL(&i2s_spinlock[i2s_num])
-
-static inline void gpio_matrix_out_check(uint32_t gpio, uint32_t signal_idx, bool out_inv, bool oen_inv) {
-  //if pin = -1, do not need to configure
-  if (gpio != -1) {
-    PIN_FUNC_SELECT(GPIO_PIN_MUX_REG[gpio], PIN_FUNC_GPIO);
-    gpio_set_direction((gpio_num_t)gpio, (gpio_mode_t)GPIO_MODE_DEF_OUTPUT);
-    gpio_matrix_out(gpio, signal_idx, out_inv, oen_inv);
-  }
-}
-
-static esp_err_t i2s_reset_fifo(i2s_port_t i2s_num) {
-  I2S_ENTER_CRITICAL();
-  I2S[i2s_num]->conf.rx_fifo_reset = 1;
-  I2S[i2s_num]->conf.rx_fifo_reset = 0;
-  I2S[i2s_num]->conf.tx_fifo_reset = 1;
-  I2S[i2s_num]->conf.tx_fifo_reset = 0;
-  I2S_EXIT_CRITICAL();
-
-  return ESP_OK;
-}
-
-esp_err_t i2s_start(i2s_port_t i2s_num) {
-  //start DMA link
-  I2S_ENTER_CRITICAL();
-  i2s_reset_fifo(i2s_num);
-
-  //reset dma
-  I2S[i2s_num]->lc_conf.in_rst = 1;
-  I2S[i2s_num]->lc_conf.in_rst = 0;
-  I2S[i2s_num]->lc_conf.out_rst = 1;
-  I2S[i2s_num]->lc_conf.out_rst = 0;
-
-  I2S[i2s_num]->conf.tx_reset = 1;
-  I2S[i2s_num]->conf.tx_reset = 0;
-  I2S[i2s_num]->conf.rx_reset = 1;
-  I2S[i2s_num]->conf.rx_reset = 0;
-
-  I2S[i2s_num]->int_clr.val = 0xFFFFFFFF;
-  I2S[i2s_num]->out_link.start = 1;
-  I2S[i2s_num]->conf.tx_start = 1;
-  I2S_EXIT_CRITICAL();
-
-  return ESP_OK;
-}
-
-esp_err_t i2s_stop(i2s_port_t i2s_num) {
-  I2S_ENTER_CRITICAL();
-  I2S[i2s_num]->out_link.stop = 1;
-  I2S[i2s_num]->conf.tx_start = 0;
-
-  I2S[i2s_num]->int_clr.val = I2S[i2s_num]->int_st.val; //clear pending interrupt
-  I2S_EXIT_CRITICAL();
-
-  return ESP_OK;
-}
-
-static void IRAM_ATTR i2s_intr_handler_default(void *arg) {
-  int dummy;
-  lldesc_t *finish_desc;
-  portBASE_TYPE high_priority_task_awoken = pdFALSE;
-
-  if (I2S0.int_st.out_eof) {
-    // Get the descriptor of the last item in the linkedlist
-    finish_desc = (lldesc_t*) I2S0.out_eof_des_addr;
-
-    // If the queue is full it's because we have an underflow,
-    // more than buf_count isr without new data, remove the front buffer
-    if (xQueueIsQueueFullFromISR(dma.queue))
-      xQueueReceiveFromISR(dma.queue, &dummy, &high_priority_task_awoken);
-
-    xQueueSendFromISR(dma.queue, (void *)(&finish_desc->buf), &high_priority_task_awoken);
-  }
-
-  if (high_priority_task_awoken == pdTRUE) portYIELD_FROM_ISR();
-
-  // clear interrupt
-  I2S0.int_clr.val = I2S0.int_st.val; //clear pending interrupt
-}
-
-void stepperTask(void* parameter) {
-  uint32_t remaining = 0;
-
-  while (1) {
-    xQueueReceive(dma.queue, &dma.current, portMAX_DELAY);
-    dma.rw_pos = 0;
-
-    while (dma.rw_pos < DMA_SAMPLE_COUNT) {
-      // Fill with the port data post pulse_phase until the next step
-      if (remaining) {
-        i2s_push_sample();
-        remaining--;
-      }
-      else {
-        Stepper::pulse_phase_isr();
-        remaining = Stepper::block_phase_isr();
-      }
-    }
-  }
-}
-
-int i2s_init() {
-  periph_module_enable(PERIPH_I2S0_MODULE);
-
-  /**
-   * Each i2s transfer will take
-   *   fpll = PLL_D2_CLK      -- clka_en = 0
-   *
-   *   fi2s = fpll / N + b/a  -- N = clkm_div_num
-   *   fi2s = 160MHz / 2
-   *   fi2s = 80MHz
-   *
-   *   fbclk = fi2s / M   -- M = tx_bck_div_num
-   *   fbclk = 80MHz / 2
-   *   fbclk = 40MHz
-   *
-   *   fwclk = fbclk / 32
-   *
-   *   for fwclk = 250kHz (4µS pulse time)
-   *      N = 10
-   *      M = 20
-   */
-
-  // Allocate the array of pointers to the buffers
-  dma.buffers = (uint32_t **)malloc(sizeof(uint32_t*) * DMA_BUF_COUNT);
-  if (dma.buffers == nullptr) return -1;
-
-  // Allocate each buffer that can be used by the DMA controller
-  for (int buf_idx = 0; buf_idx < DMA_BUF_COUNT; buf_idx++) {
-    dma.buffers[buf_idx] = (uint32_t*) heap_caps_calloc(1, DMA_BUF_LEN, MALLOC_CAP_DMA);
-    if (dma.buffers[buf_idx] == nullptr) return -1;
-  }
-
-  // Allocate the array of DMA descriptors
-  dma.desc = (lldesc_t**) malloc(sizeof(lldesc_t*) * DMA_BUF_COUNT);
-  if (dma.desc == nullptr) return -1;
-
-  // Allocate each DMA descriptor that will be used by the DMA controller
-  for (int buf_idx = 0; buf_idx < DMA_BUF_COUNT; buf_idx++) {
-    dma.desc[buf_idx] = (lldesc_t*) heap_caps_malloc(sizeof(lldesc_t), MALLOC_CAP_DMA);
-    if (dma.desc[buf_idx] == nullptr) return -1;
-  }
-
-  // Initialize
-  for (int buf_idx = 0; buf_idx < DMA_BUF_COUNT; buf_idx++) {
-    dma.desc[buf_idx]->owner = 1;
-    dma.desc[buf_idx]->eof = 1; // set to 1 will trigger the interrupt
-    dma.desc[buf_idx]->sosf = 0;
-    dma.desc[buf_idx]->length = DMA_BUF_LEN;
-    dma.desc[buf_idx]->size = DMA_BUF_LEN;
-    dma.desc[buf_idx]->buf = (uint8_t *) dma.buffers[buf_idx];
-    dma.desc[buf_idx]->offset = 0;
-    dma.desc[buf_idx]->empty = (uint32_t)((buf_idx < (DMA_BUF_COUNT - 1)) ? (dma.desc[buf_idx + 1]) : dma.desc[0]);
-  }
-
-  dma.queue = xQueueCreate(DMA_BUF_COUNT, sizeof(uint32_t *));
-
-  // Set the first DMA descriptor
-  I2S0.out_link.addr = (uint32_t)dma.desc[0];
-
-  // stop i2s
-  i2s_stop(I2S_NUM_0);
-
-  // configure I2S data port interface.
-  i2s_reset_fifo(I2S_NUM_0);
-
-  //reset i2s
-  I2S0.conf.tx_reset = 1;
-  I2S0.conf.tx_reset = 0;
-  I2S0.conf.rx_reset = 1;
-  I2S0.conf.rx_reset = 0;
-
-  //reset dma
-  I2S0.lc_conf.in_rst = 1;
-  I2S0.lc_conf.in_rst = 0;
-  I2S0.lc_conf.out_rst = 1;
-  I2S0.lc_conf.out_rst = 0;
-
-  //Enable and configure DMA
-  I2S0.lc_conf.check_owner = 0;
-  I2S0.lc_conf.out_loop_test = 0;
-  I2S0.lc_conf.out_auto_wrback = 0;
-  I2S0.lc_conf.out_data_burst_en = 0;
-  I2S0.lc_conf.outdscr_burst_en = 0;
-  I2S0.lc_conf.out_no_restart_clr = 0;
-  I2S0.lc_conf.indscr_burst_en = 0;
-  I2S0.lc_conf.out_eof_mode = 1;
-
-  I2S0.conf2.lcd_en = 0;
-  I2S0.conf2.camera_en = 0;
-  I2S0.pdm_conf.pcm2pdm_conv_en = 0;
-  I2S0.pdm_conf.pdm2pcm_conv_en = 0;
-
-  I2S0.fifo_conf.dscr_en = 0;
-
-  I2S0.conf_chan.tx_chan_mod = (
-    #if ENABLED(I2S_STEPPER_SPLIT_STREAM)
-      4
-    #else
-      0
-    #endif
-  );
-  I2S0.fifo_conf.tx_fifo_mod = 0;
-  I2S0.conf.tx_mono = 0;
-
-  I2S0.conf_chan.rx_chan_mod = 0;
-  I2S0.fifo_conf.rx_fifo_mod = 0;
-  I2S0.conf.rx_mono = 0;
-
-  I2S0.fifo_conf.dscr_en = 1; //connect dma to fifo
-
-  I2S0.conf.tx_start = 0;
-  I2S0.conf.rx_start = 0;
-
-  I2S0.conf.tx_msb_right = 1;
-  I2S0.conf.tx_right_first = 1;
-
-  I2S0.conf.tx_slave_mod = 0; // Master
-  I2S0.fifo_conf.tx_fifo_mod_force_en = 1;
-
-  I2S0.pdm_conf.rx_pdm_en = 0;
-  I2S0.pdm_conf.tx_pdm_en = 0;
-
-  I2S0.conf.tx_short_sync = 0;
-  I2S0.conf.rx_short_sync = 0;
-  I2S0.conf.tx_msb_shift = 0;
-  I2S0.conf.rx_msb_shift = 0;
-
-  // set clock
-  I2S0.clkm_conf.clka_en = 0;       // Use PLL/2 as reference
-  I2S0.clkm_conf.clkm_div_num = 10; // minimum value of 2, reset value of 4, max 256
-  I2S0.clkm_conf.clkm_div_a = 0;    // 0 at reset, what about divide by 0? (not an issue)
-  I2S0.clkm_conf.clkm_div_b = 0;    // 0 at reset
-
-  // fbck = fi2s / tx_bck_div_num
-  I2S0.sample_rate_conf.tx_bck_div_num = 2; // minimum value of 2 defaults to 6
-
-  // Enable TX interrupts
-  I2S0.int_ena.out_eof = 1;
-  I2S0.int_ena.out_dscr_err = 0;
-  I2S0.int_ena.out_total_eof = 0;
-  I2S0.int_ena.out_done = 0;
-
-  // Allocate and Enable the I2S interrupt
-  intr_handle_t i2s_isr_handle;
-  esp_intr_alloc(ETS_I2S0_INTR_SOURCE, 0, i2s_intr_handler_default, nullptr, &i2s_isr_handle);
-  esp_intr_enable(i2s_isr_handle);
-
-  // Create the task that will feed the buffer
-  xTaskCreatePinnedToCore(stepperTask, "StepperTask", 10000, nullptr, 1, nullptr, CONFIG_ARDUINO_RUNNING_CORE); // run I2S stepper task on same core as rest of Marlin
-
-  // Route the i2s pins to the appropriate GPIO
-  gpio_matrix_out_check(I2S_DATA, I2S0O_DATA_OUT23_IDX, 0, 0);
-  gpio_matrix_out_check(I2S_BCK, I2S0O_BCK_OUT_IDX, 0, 0);
-  gpio_matrix_out_check(I2S_WS, I2S0O_WS_OUT_IDX, 0, 0);
-
-  // Start the I2S peripheral
-  return i2s_start(I2S_NUM_0);
-}
-
-void i2s_write(uint8_t pin, uint8_t val) {
-  #if ENABLED(I2S_STEPPER_SPLIT_STREAM)
-    if (pin >= 16) {
-      SET_BIT_TO(I2S0.conf_single_data, pin, val);
-      return;
-    }
-  #endif
-  SET_BIT_TO(i2s_port_data, pin, val);
-}
-
-uint8_t i2s_state(uint8_t pin) {
-  #if ENABLED(I2S_STEPPER_SPLIT_STREAM)
-    if (pin >= 16) return TEST(I2S0.conf_single_data, pin);
-  #endif
-  return TEST(i2s_port_data, pin);
-}
-
-void i2s_push_sample() {
-  dma.current[dma.rw_pos++] = i2s_port_data;
-}
-
-#endif // ARDUINO_ARCH_ESP32
--- a/Marlin/src/HAL/ESP32/i2s.h
+++ b/Marlin/src/HAL/ESP32/i2s.h
@@ -1,35 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-#include <stdint.h>
-
-// current value of the outputs provided over i2s
-extern uint32_t i2s_port_data;
-
-int i2s_init();
-
-uint8_t i2s_state(uint8_t pin);
-
-void i2s_write(uint8_t pin, uint8_t val);
-
-void i2s_push_sample();
--- a/Marlin/src/HAL/ESP32/inc/Conditionals_LCD.h
+++ b/Marlin/src/HAL/ESP32/inc/Conditionals_LCD.h
@@ -1,22 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#pragma once
--- a/Marlin/src/HAL/ESP32/inc/Conditionals_adv.h
+++ b/Marlin/src/HAL/ESP32/inc/Conditionals_adv.h
@@ -1,22 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#pragma once
--- a/Marlin/src/HAL/ESP32/inc/Conditionals_post.h
+++ b/Marlin/src/HAL/ESP32/inc/Conditionals_post.h
@@ -1,27 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-// If no real EEPROM, Flash emulation, or SRAM emulation is available fall back to SD emulation
-#if ENABLED(EEPROM_SETTINGS) && NONE(USE_REAL_EEPROM, FLASH_EEPROM_EMULATION, SRAM_EEPROM_EMULATION)
-  #define SDCARD_EEPROM_EMULATION
-#endif
--- a/Marlin/src/HAL/ESP32/inc/SanityCheck.h
+++ b/Marlin/src/HAL/ESP32/inc/SanityCheck.h
@@ -1,38 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-#if ENABLED(EMERGENCY_PARSER)
-  #error "EMERGENCY_PARSER is not yet implemented for ESP32. Disable EMERGENCY_PARSER to continue."
-#endif
-
-#if ENABLED(FAST_PWM_FAN)
-  #error "FAST_PWM_FAN is not yet implemented for this platform."
-#endif
-
-#if HAS_TMC_SW_SERIAL
-  #error "TMC220x Software Serial is not supported on this platform."
-#endif
-
-#if BOTH(WIFISUPPORT, ESP3D_WIFISUPPORT)
-  #error "Only enable one WiFi option, either WIFISUPPORT or ESP3D_WIFISUPPORT."
-#endif
--- a/Marlin/src/HAL/ESP32/persistent_store_impl.cpp
+++ b/Marlin/src/HAL/ESP32/persistent_store_impl.cpp
@@ -1,63 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifdef ARDUINO_ARCH_ESP32
-
-#include "../../inc/MarlinConfig.h"
-
-#if ENABLED(EEPROM_SETTINGS) && DISABLED(FLASH_EEPROM_EMULATION)
-
-#include "../shared/persistent_store_api.h"
-#include "EEPROM.h"
-
-#define EEPROM_SIZE 4096
-
-bool PersistentStore::access_start() {
-  return EEPROM.begin(EEPROM_SIZE);
-}
-
-bool PersistentStore::access_finish() {
-  EEPROM.end();
-  return true;
-}
-
-bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
-  for (size_t i = 0; i < size; i++) {
-    EEPROM.write(pos++, value[i]);
-    crc16(crc, &value[i], 1);
-  }
-  return false;
-}
-
-bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
-  for (size_t i = 0; i < size; i++) {
-    uint8_t c = EEPROM.read(pos++);
-    if (writing) value[i] = c;
-    crc16(crc, &c, 1);
-  }
-  return false;
-}
-
-size_t PersistentStore::capacity() { return EEPROM_SIZE; }
-
-#endif // EEPROM_SETTINGS
-#endif // ARDUINO_ARCH_ESP32
--- a/Marlin/src/HAL/ESP32/spiffs.cpp
+++ b/Marlin/src/HAL/ESP32/spiffs.cpp
@@ -1,44 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifdef ARDUINO_ARCH_ESP32
-
-#include "../../inc/MarlinConfigPre.h"
-
-#if BOTH(WIFISUPPORT, WEBSUPPORT)
-
-#include "../../core/serial.h"
-
-#include <FS.h>
-#include <SPIFFS.h>
-
-bool spiffs_initialized;
-
-void spiffs_init() {
-  if (SPIFFS.begin(true))  // formatOnFail = true
-    spiffs_initialized = true;
-  else
-    SERIAL_ERROR_MSG("SPIFFS mount failed");
-}
-
-#endif // WIFISUPPORT && WEBSUPPORT
-#endif // ARDUINO_ARCH_ESP32
--- a/Marlin/src/HAL/ESP32/spiffs.h
+++ b/Marlin/src/HAL/ESP32/spiffs.h
@@ -1,26 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-extern bool spiffs_initialized;
-
-void spiffs_init();
--- a/Marlin/src/HAL/ESP32/web.cpp
+++ b/Marlin/src/HAL/ESP32/web.cpp
@@ -1,48 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifdef ARDUINO_ARCH_ESP32
-
-#include "../../inc/MarlinConfigPre.h"
-
-#if BOTH(WIFISUPPORT, WEBSUPPORT)
-
-#include "../../inc/MarlinConfig.h"
-
-#undef DISABLED  // esp32-hal-gpio.h
-#include <SPIFFS.h>
-#include "wifi.h"
-
-AsyncEventSource events("/events"); // event source (Server-Sent events)
-
-void onNotFound(AsyncWebServerRequest *request) {
-  request->send(404);
-}
-
-void web_init() {
-  server.addHandler(&events);       // attach AsyncEventSource
-  server.serveStatic("/", SPIFFS, "/www").setDefaultFile("index.html");
-  server.onNotFound(onNotFound);
-}
-
-#endif // WIFISUPPORT && WEBSUPPORT
-#endif // ARDUINO_ARCH_ESP32
--- a/Marlin/src/HAL/ESP32/web.h
+++ b/Marlin/src/HAL/ESP32/web.h
@@ -1,24 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-void web_init();
--- a/Marlin/src/HAL/ESP32/wifi.cpp
+++ b/Marlin/src/HAL/ESP32/wifi.cpp
@@ -1,67 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifdef ARDUINO_ARCH_ESP32
-
-#include "../../core/serial.h"
-#include "../../inc/MarlinConfigPre.h"
-
-#if ENABLED(WIFISUPPORT)
-
-#include <WiFi.h>
-#include <ESPmDNS.h>
-#include <ESPAsyncWebServer.h>
-#include "wifi.h"
-
-AsyncWebServer server(80);
-
-#ifndef WIFI_HOSTNAME
-  #define WIFI_HOSTNAME DEFAULT_WIFI_HOSTNAME
-#endif
-
-void wifi_init() {
-
-  SERIAL_ECHO_MSG("Starting WiFi...");
-
-  WiFi.mode(WIFI_STA);
-  WiFi.begin(WIFI_SSID, WIFI_PWD);
-
-  while (WiFi.waitForConnectResult() != WL_CONNECTED) {
-    SERIAL_ERROR_MSG("Unable to connect to WiFi with SSID '" WIFI_SSID "', restarting.");
-    delay(5000);
-    ESP.restart();
-  }
-
-  delay(10);
-  if (!MDNS.begin(WIFI_HOSTNAME)) {
-    SERIAL_ERROR_MSG("Unable to start mDNS with hostname '" WIFI_HOSTNAME "', restarting.");
-    delay(5000);
-    ESP.restart();
-  }
-
-  MDNS.addService("http", "tcp", 80);
-
-  SERIAL_ECHOLNPAIR("Successfully connected to WiFi with SSID '" WIFI_SSID "', hostname: '" WIFI_HOSTNAME "', IP address: ", WiFi.localIP().toString().c_str());
-}
-
-#endif // WIFISUPPORT
-#endif // ARDUINO_ARCH_ESP32
--- a/Marlin/src/HAL/ESP32/wifi.h
+++ b/Marlin/src/HAL/ESP32/wifi.h
@@ -1,30 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-#include <ESPAsyncWebServer.h>
-
-extern AsyncWebServer server;
-
-#define DEFAULT_WIFI_HOSTNAME "marlin"
-
-void wifi_init();
--- a/Marlin/src/HAL/HAL.h
+++ b/Marlin/src/HAL/HAL.h
@@ -1,34 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-#include "platforms.h"
-
-#include HAL_PATH(.,HAL.h)
-
-#define HAL_ADC_RANGE _BV(HAL_ADC_RESOLUTION)
-
-inline void watchdog_refresh() {
-  #if ENABLED(USE_WATCHDOG)
-    HAL_watchdog_refresh();
-  #endif
-}
--- a/Marlin/src/HAL/HAL_AVR/HAL.cpp
+++ b/Marlin/src/HAL/HAL_AVR/HAL.cpp
@@ -0,0 +1,94 @@
+/* **************************************************************************
+
+ Marlin 3D Printer Firmware
+ Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+
+ Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ 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/>.
+
+****************************************************************************/
+
+#ifdef __AVR__
+
+// --------------------------------------------------------------------------
+// Includes
+// --------------------------------------------------------------------------
+
+#include "../../inc/MarlinConfig.h"
+#include "HAL.h"
+
+// --------------------------------------------------------------------------
+// Externals
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Local defines
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Types
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Variables
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Public Variables
+// --------------------------------------------------------------------------
+
+//uint8_t MCUSR;
+
+// --------------------------------------------------------------------------
+// Private Variables
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Function prototypes
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Private functions
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Public functions
+// --------------------------------------------------------------------------
+
+#if ENABLED(SDSUPPORT)
+
+  #include "../../sd/SdFatUtil.h"
+  int freeMemory() { return SdFatUtil::FreeRam(); }
+
+#else // !SDSUPPORT
+
+extern "C" {
+  extern char __bss_end;
+  extern char __heap_start;
+  extern void* __brkval;
+
+  int freeMemory() {
+    int free_memory;
+    if ((int)__brkval == 0)
+      free_memory = ((int)&free_memory) - ((int)&__bss_end);
+    else
+      free_memory = ((int)&free_memory) - ((int)__brkval);
+    return free_memory;
+  }
+}
+
+#endif // !SDSUPPORT
+
+#endif // __AVR__
--- a/Marlin/src/HAL/HAL_AVR/HAL.h
+++ b/Marlin/src/HAL/HAL_AVR/HAL.h
@@ -1,6 +1,6 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 * Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
 *
 * This program is free software: you can redistribute it and/or modify
@@ -16,45 +16,44 @@
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
-#pragma once

-#include "../shared/Marduino.h"
-#include "../shared/HAL_SPI.h"
-#include "fastio.h"
-#include "watchdog.h"
-#include "math.h"
+#ifndef _HAL_AVR_H_
+#define _HAL_AVR_H_

-#ifdef USBCON
-  #include <HardwareSerial.h>
-#else
-  #define HardwareSerial_h // Hack to prevent HardwareSerial.h header inclusion
-  #include "MarlinSerial.h"
-#endif
+// --------------------------------------------------------------------------
+// Includes
+// --------------------------------------------------------------------------

 #include <stdint.h>
+
+#include <Arduino.h>
+
 #include <util/delay.h>
 #include <avr/eeprom.h>
 #include <avr/pgmspace.h>
 #include <avr/interrupt.h>
 #include <avr/io.h>

-#ifndef pgm_read_ptr
-  // Compatibility for avr-libc 1.8.0-4.1 included with Ubuntu for
-  // Windows Subsystem for Linux on Windows 10 as of 10/18/2019
-  #define pgm_read_ptr_far(address_long) (void*)__ELPM_word((uint32_t)(address_long))
-  #define pgm_read_ptr_near(address_short) (void*)__LPM_word((uint16_t)(address_short))
-  #define pgm_read_ptr(address_short) pgm_read_ptr_near(address_short)
+#include "../shared/HAL_SPI.h"
+#include "fastio_AVR.h"
+#include "watchdog_AVR.h"
+#include "math_AVR.h"
+
+#ifdef USBCON
+  #include "HardwareSerial.h"
+#else
+  #include "MarlinSerial.h"
 #endif

-// ------------------------
+// --------------------------------------------------------------------------
 // Defines
-// ------------------------
+// --------------------------------------------------------------------------

 //#define analogInputToDigitalPin(IO) IO

 #ifndef CRITICAL_SECTION_START
-  #define CRITICAL_SECTION_START()  unsigned char _sreg = SREG; cli()
-  #define CRITICAL_SECTION_END()    SREG = _sreg
+  #define CRITICAL_SECTION_START  unsigned char _sreg = SREG; cli()
+  #define CRITICAL_SECTION_END    SREG = _sreg
 #endif
 #define ISRS_ENABLED() TEST(SREG, SREG_I)
 #define ENABLE_ISRS()  sei()
@@ -63,84 +62,49 @@
 // On AVR this is in math.h?
 //#define square(x) ((x)*(x))

-// ------------------------
+// --------------------------------------------------------------------------
 // Types
-// ------------------------
+// --------------------------------------------------------------------------

 typedef uint16_t hal_timer_t;
 #define HAL_TIMER_TYPE_MAX 0xFFFF

 typedef int8_t pin_t;

-#define SHARED_SERVOS HAS_SERVOS
 #define HAL_SERVO_LIB Servo

-// ------------------------
+// --------------------------------------------------------------------------
 // Public Variables
-// ------------------------
+// --------------------------------------------------------------------------

 //extern uint8_t MCUSR;

-// Serial ports
+#define NUM_SERIAL 1
+
 #ifdef USBCON
  #if ENABLED(BLUETOOTH)
    #define MYSERIAL0 bluetoothSerial
  #else
    #define MYSERIAL0 Serial
  #endif
-  #define NUM_SERIAL 1
 #else
-  #if !WITHIN(SERIAL_PORT, -1, 3)
-    #error "SERIAL_PORT must be from -1 to 3. Please update your configuration."
-  #endif
-
-  #define MYSERIAL0 customizedSerial1
-
-  #ifdef SERIAL_PORT_2
-    #if !WITHIN(SERIAL_PORT_2, -1, 3)
-      #error "SERIAL_PORT_2 must be from -1 to 3. Please update your configuration."
-    #elif SERIAL_PORT_2 == SERIAL_PORT
-      #error "SERIAL_PORT_2 must be different than SERIAL_PORT. Please update your configuration."
-    #endif
-    #define MYSERIAL1 customizedSerial2
-    #define NUM_SERIAL 2
-  #else
-    #define NUM_SERIAL 1
-  #endif
+  #define MYSERIAL0 customizedSerial
 #endif

-#ifdef DGUS_SERIAL_PORT
-  #if !WITHIN(DGUS_SERIAL_PORT, -1, 3)
-    #error "DGUS_SERIAL_PORT must be from -1 to 3. Please update your configuration."
-  #elif DGUS_SERIAL_PORT == SERIAL_PORT
-    #error "DGUS_SERIAL_PORT must be different than SERIAL_PORT. Please update your configuration."
-  #elif defined(SERIAL_PORT_2) && DGUS_SERIAL_PORT == SERIAL_PORT_2
-    #error "DGUS_SERIAL_PORT must be different than SERIAL_PORT_2. Please update your configuration."
-  #endif
-  #define DGUS_SERIAL internalDgusSerial
-
-  #define DGUS_SERIAL_GET_TX_BUFFER_FREE DGUS_SERIAL.get_tx_buffer_free
-#endif
-
-// ------------------------
+// --------------------------------------------------------------------------
 // Public functions
-// ------------------------
+// --------------------------------------------------------------------------

-void HAL_init();
-
-//void cli();
+//void cli(void);

 //void _delay_ms(const int delay);

-inline void HAL_clear_reset_source() { MCUSR = 0; }
-inline uint8_t HAL_get_reset_source() { return MCUSR; }
+inline void HAL_clear_reset_source(void) { MCUSR = 0; }
+inline uint8_t HAL_get_reset_source(void) { return MCUSR; }

-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-function"
 extern "C" {
-  int freeMemory();
+  int freeMemory(void);
 }
-#pragma GCC diagnostic pop

 // timers
 #define HAL_TIMER_RATE          ((F_CPU) / 8)    // i.e., 2MHz or 2.5MHz
@@ -167,7 +131,8 @@ extern "C" {
 #define DISABLE_TEMPERATURE_INTERRUPT()    CBI(TIMSK0, OCIE0B)
 #define TEMPERATURE_ISR_ENABLED()         TEST(TIMSK0, OCIE0B)

-FORCE_INLINE void HAL_timer_start(const uint8_t timer_num, const uint32_t) {
+FORCE_INLINE void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
+  UNUSED(frequency);
  switch (timer_num) {
    case STEP_TIMER_NUM:
      // waveform generation = 0100 = CTC
@@ -203,7 +168,7 @@ FORCE_INLINE void HAL_timer_start(const uint8_t timer_num, const uint32_t) {
 #define TIMER_OCR_0             OCR0A
 #define TIMER_COUNTER_0         TCNT0

-#define _CAT(a,V...) a##V
+#define _CAT(a, ...) a ## __VA_ARGS__
 #define HAL_timer_set_compare(timer, compare) (_CAT(TIMER_OCR_, timer) = compare)
 #define HAL_timer_get_compare(timer) _CAT(TIMER_OCR_, timer)
 #define HAL_timer_get_count(timer) _CAT(TIMER_COUNTER_, timer)
@@ -218,10 +183,10 @@ FORCE_INLINE void HAL_timer_start(const uint8_t timer_num, const uint32_t) {
 #define HAL_timer_isr_epilogue(TIMER_NUM)

 /* 18 cycles maximum latency */
-#define HAL_STEP_TIMER_ISR() \
-extern "C" void TIMER1_COMPA_vect() __attribute__ ((signal, naked, used, externally_visible)); \
-extern "C" void TIMER1_COMPA_vect_bottom() asm ("TIMER1_COMPA_vect_bottom") __attribute__ ((used, externally_visible, noinline)); \
-void TIMER1_COMPA_vect() { \
+#define HAL_STEP_TIMER_ISR \
+extern "C" void TIMER1_COMPA_vect (void) __attribute__ ((signal, naked, used, externally_visible)); \
+extern "C" void TIMER1_COMPA_vect_bottom (void) asm ("TIMER1_COMPA_vect_bottom") __attribute__ ((used, externally_visible, noinline)); \
+void TIMER1_COMPA_vect (void) { \
  __asm__ __volatile__ ( \
    A("push r16")                      /* 2 Save R16 */ \
    A("in r16, __SREG__")              /* 1 Get SREG */ \
@@ -288,13 +253,13 @@ void TIMER1_COMPA_vect() { \
    : \
  ); \
 } \
-void TIMER1_COMPA_vect_bottom()
+void TIMER1_COMPA_vect_bottom(void)

 /* 14 cycles maximum latency */
-#define HAL_TEMP_TIMER_ISR() \
-extern "C" void TIMER0_COMPB_vect() __attribute__ ((signal, naked, used, externally_visible)); \
-extern "C" void TIMER0_COMPB_vect_bottom()  asm ("TIMER0_COMPB_vect_bottom") __attribute__ ((used, externally_visible, noinline)); \
-void TIMER0_COMPB_vect() { \
+#define HAL_TEMP_TIMER_ISR \
+extern "C" void TIMER0_COMPB_vect (void) __attribute__ ((signal, naked, used, externally_visible)); \
+extern "C" void TIMER0_COMPB_vect_bottom(void)  asm ("TIMER0_COMPB_vect_bottom") __attribute__ ((used, externally_visible, noinline)); \
+void TIMER0_COMPB_vect (void) { \
  __asm__ __volatile__ ( \
    A("push r16")                       /* 2 Save R16 */ \
    A("in r16, __SREG__")               /* 1 Get SREG */ \
@@ -354,16 +319,16 @@ void TIMER0_COMPB_vect() { \
    : \
  ); \
 } \
-void TIMER0_COMPB_vect_bottom()
+void TIMER0_COMPB_vect_bottom(void)

 // ADC
 #ifdef DIDR2
-  #define HAL_ANALOG_SELECT(ind) do{ if (ind < 8) SBI(DIDR0, ind); else SBI(DIDR2, ind & 0x07); }while(0)
+  #define HAL_ANALOG_SELECT(pin) do{ if (pin < 8) SBI(DIDR0, pin); else SBI(DIDR2, pin & 0x07); }while(0)
 #else
-  #define HAL_ANALOG_SELECT(ind) SBI(DIDR0, ind);
+  #define HAL_ANALOG_SELECT(pin) do{ SBI(DIDR0, pin); }while(0)
 #endif

-inline void HAL_adc_init() {
+inline void HAL_adc_init(void) {
  ADCSRA = _BV(ADEN) | _BV(ADSC) | _BV(ADIF) | 0x07;
  DIDR0 = 0;
  #ifdef DIDR2
@@ -371,14 +336,13 @@ inline void HAL_adc_init() {
  #endif
 }

-#define SET_ADMUX_ADCSRA(ch) ADMUX = _BV(REFS0) | (ch & 0x07); SBI(ADCSRA, ADSC)
+#define SET_ADMUX_ADCSRA(pin) ADMUX = _BV(REFS0) | (pin & 0x07); SBI(ADCSRA, ADSC)
 #ifdef MUX5
-  #define HAL_START_ADC(ch) if (ch > 7) ADCSRB = _BV(MUX5); else ADCSRB = 0; SET_ADMUX_ADCSRA(ch)
+  #define HAL_START_ADC(pin) if (pin > 7) ADCSRB = _BV(MUX5); else ADCSRB = 0; SET_ADMUX_ADCSRA(pin)
 #else
-  #define HAL_START_ADC(ch) ADCSRB = 0; SET_ADMUX_ADCSRA(ch)
+  #define HAL_START_ADC(pin) ADCSRB = 0; SET_ADMUX_ADCSRA(pin)
 #endif

-#define HAL_ADC_RESOLUTION 10
 #define HAL_READ_ADC()  ADC
 #define HAL_ADC_READY() !TEST(ADCSRA, ADSC)

@@ -388,28 +352,7 @@ inline void HAL_adc_init() {

 #define HAL_SENSITIVE_PINS 0, 1

-#ifdef __AVR_AT90USB1286__
-  #define JTAG_DISABLE() do{ MCUCR = 0x80; MCUCR = 0x80; }while(0)
-#endif
-
 // AVR compatibility
 #define strtof strtod

-/**
- *  set_pwm_frequency
- *  Sets the frequency of the timer corresponding to the provided pin
- *  as close as possible to the provided desired frequency. Internally
- *  calculates the required waveform generation mode, prescaler and
- *  resolution values required and sets the timer registers accordingly.
- *  NOTE that the frequency is applied to all pins on the timer (Ex OC3A, OC3B and OC3B)
- *  NOTE that there are limitations, particularly if using TIMER2. (see Configuration_adv.h -> FAST FAN PWM Settings)
- */
-void set_pwm_frequency(const pin_t pin, int f_desired);
-
-/**
- * set_pwm_duty
- *  Sets the PWM duty cycle of the provided pin to the provided value
- *  Optionally allows inverting the duty cycle [default = false]
- *  Optionally allows changing the maximum size of the provided value to enable finer PWM duty control [default = 255]
- */
-void set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size=255, const bool invert=false);
+#endif // _HAL_AVR_H_
--- a/Marlin/src/HAL/HAL_AVR/HAL_spi_AVR.cpp
+++ b/Marlin/src/HAL/HAL_AVR/HAL_spi_AVR.cpp
@@ -1,9 +1,9 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
 * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * 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
@@ -21,42 +21,57 @@
 */

 /**
- * Adapted from Arduino Sd2Card Library
- * Copyright (c) 2009 by William Greiman
+ * Originally from Arduino Sd2Card Library
+ * Copyright (C) 2009 by William Greiman
 */

 /**
- * HAL for AVR - SPI functions
+ * Description: HAL for AVR - SPI functions
+ *
+ * For __AVR__
 */

 #ifdef __AVR__

+// --------------------------------------------------------------------------
+// Includes
+// --------------------------------------------------------------------------
+
 #include "../../inc/MarlinConfig.h"

-void spiBegin() {
-  OUT_WRITE(SS_PIN, HIGH);
+// --------------------------------------------------------------------------
+// Public Variables
+// --------------------------------------------------------------------------
+
+
+// --------------------------------------------------------------------------
+// Public functions
+// --------------------------------------------------------------------------
+
+void spiBegin (void) {
+  SET_OUTPUT(SS_PIN);
+  WRITE(SS_PIN, HIGH);
  SET_OUTPUT(SCK_PIN);
  SET_INPUT(MISO_PIN);
  SET_OUTPUT(MOSI_PIN);

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

-#if NONE(SOFTWARE_SPI, FORCE_SOFT_SPI)
-
-  // ------------------------
-  // Hardware SPI
-  // ------------------------

+//------------------------------------------------------------------------------
+#if DISABLED(SOFTWARE_SPI)
+  // functions for hardware SPI
+  //------------------------------------------------------------------------------
  // make sure SPCR rate is in expected bits
  #if (SPR0 != 0 || SPR1 != 1)
    #error "unexpected SPCR bits"
@@ -80,13 +95,14 @@ void spiBegin() {
    SPSR = spiRate & 1 || spiRate == 6 ? 0 : _BV(SPI2X);
  }

+  //------------------------------------------------------------------------------
  /** SPI receive a byte */
-  uint8_t spiRec() {
+  uint8_t spiRec(void) {
    SPDR = 0xFF;
    while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
    return SPDR;
  }
-
+  //------------------------------------------------------------------------------
  /** SPI read data  */
  void spiRead(uint8_t* buf, uint16_t nbyte) {
    if (nbyte-- == 0) return;
@@ -99,13 +115,13 @@ void spiBegin() {
    while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
    buf[nbyte] = SPDR;
  }
-
+  //------------------------------------------------------------------------------
  /** SPI send a byte */
  void spiSend(uint8_t b) {
    SPDR = b;
    while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
  }
-
+  //------------------------------------------------------------------------------
  /** SPI send block  */
  void spiSendBlock(uint8_t token, const uint8_t* buf) {
    SPDR = token;
@@ -169,27 +185,32 @@ void spiBegin() {
    // Invert the SPI2X bit
    clockDiv ^= 0x1;

-    SPCR = _BV(SPE) | _BV(MSTR) | ((bitOrder == LSBFIRST) ? _BV(DORD) : 0) |
+    SPCR = _BV(SPE) | _BV(MSTR) | ((bitOrder == SPI_LSBFIRST) ? _BV(DORD) : 0) |
      (dataMode << CPHA) | ((clockDiv >> 1) << SPR0);
    SPSR = clockDiv | 0x01;
  }


-#else // SOFTWARE_SPI || FORCE_SOFT_SPI
-
-  // ------------------------
-  // Software SPI
-  // ------------------------
-
-  // nop to tune soft SPI timing
+       //------------------------------------------------------------------------------
+#else  // SOFTWARE_SPI
+       //------------------------------------------------------------------------------
+  /** nop to tune soft SPI timing */
  #define nop asm volatile ("\tnop\n")

-  void spiInit(uint8_t) { /* do nothing */ }
+  /** Set SPI rate */
+  void spiInit(uint8_t spiRate) {
+    // nothing to do
+    UNUSED(spiRate);
+  }

-  // Begin SPI transaction, set clock, bit order, data mode
-  void spiBeginTransaction(uint32_t spiClock, uint8_t bitOrder, uint8_t dataMode) { /* do nothing */ }
+  /** Begin SPI transaction, set clock, bit order, data mode */
+  void spiBeginTransaction(uint32_t spiClock, uint8_t bitOrder, uint8_t dataMode) {
+    // nothing to do
+    UNUSED(spiBeginTransaction);
+  }

-  // Soft SPI receive byte
+  //------------------------------------------------------------------------------
+  /** Soft SPI receive byte */
  uint8_t spiRec() {
    uint8_t data = 0;
    // no interrupts during byte receive - about 8µs
@@ -197,10 +218,11 @@ void spiBegin() {
    // output pin high - like sending 0xFF
    WRITE(MOSI_PIN, HIGH);

-    LOOP_L_N(i, 8) {
+    for (uint8_t i = 0; i < 8; i++) {
      WRITE(SCK_PIN, HIGH);

-      nop; // adjust so SCK is nice
+      // adjust so SCK is nice
+      nop;
      nop;

      data <<= 1;
@@ -209,45 +231,48 @@ void spiBegin() {

      WRITE(SCK_PIN, LOW);
    }
-
+    // enable interrupts
    sei();
    return data;
  }
-
-  // Soft SPI read 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
+  //------------------------------------------------------------------------------
+  /** Soft SPI send byte */
  void spiSend(uint8_t data) {
    // no interrupts during byte send - about 8µs
    cli();
-    LOOP_L_N(i, 8) {
+    for (uint8_t i = 0; i < 8; i++) {
      WRITE(SCK_PIN, LOW);
+
      WRITE(MOSI_PIN, data & 0x80);
+
      data <<= 1;
+
      WRITE(SCK_PIN, HIGH);
    }
-
-    nop; // hold SCK high for a few ns
+    // hold SCK high for a few ns
+    nop;
    nop;
    nop;
    nop;

    WRITE(SCK_PIN, LOW);
-
+    // enable interrupts
    sei();
  }
-
-  // Soft SPI send block
+  //------------------------------------------------------------------------------
+  /** 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]);
  }
+#endif  // SOFTWARE_SPI

-#endif // SOFTWARE_SPI || FORCE_SOFT_SPI

 #endif // __AVR__
--- a/Marlin/src/HAL/HAL_AVR/MarlinSerial.cpp
+++ b/Marlin/src/HAL/HAL_AVR/MarlinSerial.cpp
@@ -1,9 +1,9 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
 * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * 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
@@ -29,7 +29,6 @@
 * Modified 14 February 2016 by Andreas Hardtung (added tx buffer)
 * Modified 01 October 2017 by Eduardo José Tagle (added XON/XOFF)
 * Modified 10 June 2018 by Eduardo José Tagle (See #10991)
- * Templatized 01 October 2018 by Eduardo José Tagle to allow multiple instances
 */

 #ifdef __AVR__
@@ -41,28 +40,64 @@
 #if !defined(USBCON) && (defined(UBRRH) || defined(UBRR0H) || defined(UBRR1H) || defined(UBRR2H) || defined(UBRR3H))

  #include "MarlinSerial.h"
-  #include "../../MarlinCore.h"
+  #include "../../Marlin.h"

-  template<typename Cfg> typename MarlinSerial<Cfg>::ring_buffer_r MarlinSerial<Cfg>::rx_buffer = { 0, 0, { 0 } };
-  template<typename Cfg> typename MarlinSerial<Cfg>::ring_buffer_t MarlinSerial<Cfg>::tx_buffer = { 0 };
-  template<typename Cfg> bool     MarlinSerial<Cfg>::_written = false;
-  template<typename Cfg> uint8_t  MarlinSerial<Cfg>::xon_xoff_state = MarlinSerial<Cfg>::XON_XOFF_CHAR_SENT | MarlinSerial<Cfg>::XON_CHAR;
-  template<typename Cfg> uint8_t  MarlinSerial<Cfg>::rx_dropped_bytes = 0;
-  template<typename Cfg> uint8_t  MarlinSerial<Cfg>::rx_buffer_overruns = 0;
-  template<typename Cfg> uint8_t  MarlinSerial<Cfg>::rx_framing_errors = 0;
-  template<typename Cfg> typename MarlinSerial<Cfg>::ring_buffer_pos_t MarlinSerial<Cfg>::rx_max_enqueued = 0;
+  struct ring_buffer_r {
+    unsigned char buffer[RX_BUFFER_SIZE];
+    volatile ring_buffer_pos_t head, tail;
+  };
+
+  #if TX_BUFFER_SIZE > 0
+    struct ring_buffer_t {
+      unsigned char buffer[TX_BUFFER_SIZE];
+      volatile uint8_t head, tail;
+    };
+  #endif
+
+  #if UART_PRESENT(SERIAL_PORT)
+    ring_buffer_r rx_buffer = { { 0 }, 0, 0 };
+    #if TX_BUFFER_SIZE > 0
+      ring_buffer_t tx_buffer = { { 0 }, 0, 0 };
+    #endif
+    static bool _written;
+  #endif
+
+  #if ENABLED(SERIAL_XON_XOFF)
+    constexpr uint8_t XON_XOFF_CHAR_SENT = 0x80,  // XON / XOFF Character was sent
+                      XON_XOFF_CHAR_MASK = 0x1F;  // XON / XOFF character to send
+    // XON / XOFF character definitions
+    constexpr uint8_t XON_CHAR  = 17, XOFF_CHAR = 19;
+    uint8_t xon_xoff_state = XON_XOFF_CHAR_SENT | XON_CHAR;
+  #endif
+
+  #if ENABLED(SERIAL_STATS_DROPPED_RX)
+    uint8_t rx_dropped_bytes = 0;
+  #endif
+
+  #if ENABLED(SERIAL_STATS_RX_BUFFER_OVERRUNS)
+    uint8_t rx_buffer_overruns = 0;
+  #endif
+
+  #if ENABLED(SERIAL_STATS_RX_FRAMING_ERRORS)
+    uint8_t rx_framing_errors = 0;
+  #endif
+
+  #if ENABLED(SERIAL_STATS_MAX_RX_QUEUED)
+    ring_buffer_pos_t rx_max_enqueued = 0;
+  #endif

  // A SW memory barrier, to ensure GCC does not overoptimize loops
  #define sw_barrier() asm volatile("": : :"memory");

-  #include "../../feature/e_parser.h"
+  #if ENABLED(EMERGENCY_PARSER)
+    #include "../../feature/emergency_parser.h"
+  #endif

  // "Atomically" read the RX head index value without disabling interrupts:
  // This MUST be called with RX interrupts enabled, and CAN'T be called
  // from the RX ISR itself!
-  template<typename Cfg>
-  FORCE_INLINE typename MarlinSerial<Cfg>::ring_buffer_pos_t MarlinSerial<Cfg>::atomic_read_rx_head() {
-    if (Cfg::RX_SIZE > 256) {
+  FORCE_INLINE ring_buffer_pos_t atomic_read_rx_head() {
+    #if RX_BUFFER_SIZE > 256
      // Keep reading until 2 consecutive reads return the same value,
      // meaning there was no update in-between caused by an interrupt.
      // This works because serial RX interrupts happen at a slower rate
@@ -76,25 +111,23 @@
        sw_barrier();
      } while (vold != vnew);
      return vnew;
-    }
-    else {
+    #else
      // With an 8bit index, reads are always atomic. No need for special handling
      return rx_buffer.head;
-    }
+    #endif
  }

-  template<typename Cfg>
-  volatile bool MarlinSerial<Cfg>::rx_tail_value_not_stable = false;
-  template<typename Cfg>
-  volatile uint16_t MarlinSerial<Cfg>::rx_tail_value_backup = 0;
+  #if RX_BUFFER_SIZE > 256
+    static volatile bool rx_tail_value_not_stable = false;
+    static volatile uint16_t rx_tail_value_backup = 0;
+  #endif

  // Set RX tail index, taking into account the RX ISR could interrupt
  //  the write to this variable in the middle - So a backup strategy
  //  is used to ensure reads of the correct values.
  //    -Must NOT be called from the RX ISR -
-  template<typename Cfg>
-  FORCE_INLINE void MarlinSerial<Cfg>::atomic_set_rx_tail(typename MarlinSerial<Cfg>::ring_buffer_pos_t value) {
-    if (Cfg::RX_SIZE > 256) {
+  FORCE_INLINE void atomic_set_rx_tail(ring_buffer_pos_t value) {
+    #if RX_BUFFER_SIZE > 256
      // Store the new value in the backup
      rx_tail_value_backup = value;
      sw_barrier();
@@ -107,29 +140,29 @@
      // Signal the new value is completely stored into the value
      rx_tail_value_not_stable = false;
      sw_barrier();
-    }
-    else
+    #else
      rx_buffer.tail = value;
+    #endif
  }

  // Get the RX tail index, taking into account the read could be
  //  interrupting in the middle of the update of that index value
  //    -Called from the RX ISR -
-  template<typename Cfg>
-  FORCE_INLINE typename MarlinSerial<Cfg>::ring_buffer_pos_t MarlinSerial<Cfg>::atomic_read_rx_tail() {
-    if (Cfg::RX_SIZE > 256) {
+  FORCE_INLINE ring_buffer_pos_t atomic_read_rx_tail() {
+    #if RX_BUFFER_SIZE > 256
      // If the true index is being modified, return the backup value
      if (rx_tail_value_not_stable) return rx_tail_value_backup;
-    }
+    #endif
    // The true index is stable, return it
    return rx_buffer.tail;
  }

  // (called with RX interrupts disabled)
-  template<typename Cfg>
-  FORCE_INLINE void MarlinSerial<Cfg>::store_rxd_char() {
+  FORCE_INLINE void store_rxd_char() {

-    static EmergencyParser::State emergency_state; // = EP_RESET
+    #if ENABLED(EMERGENCY_PARSER)
+      static EmergencyParser::State emergency_state; // = EP_RESET
+    #endif

    // Get the tail - Nothing can alter its value while this ISR is executing, but there's
    // a chance that this ISR interrupted the main process while it was updating the index.
@@ -140,17 +173,27 @@
    ring_buffer_pos_t h = rx_buffer.head;

    // Get the next element
-    ring_buffer_pos_t i = (ring_buffer_pos_t)(h + 1) & (ring_buffer_pos_t)(Cfg::RX_SIZE - 1);
+    ring_buffer_pos_t i = (ring_buffer_pos_t)(h + 1) & (ring_buffer_pos_t)(RX_BUFFER_SIZE - 1);

-    // This must read the R_UCSRA register before reading the received byte to detect error causes
-    if (Cfg::DROPPED_RX && B_DOR && !++rx_dropped_bytes) --rx_dropped_bytes;
-    if (Cfg::RX_OVERRUNS && B_DOR && !++rx_buffer_overruns) --rx_buffer_overruns;
-    if (Cfg::RX_FRAMING_ERRORS && B_FE && !++rx_framing_errors) --rx_framing_errors;
+    // This must read the M_UCSRxA register before reading the received byte to detect error causes
+    #if ENABLED(SERIAL_STATS_DROPPED_RX)
+      if (TEST(M_UCSRxA, M_DORx) && !++rx_dropped_bytes) --rx_dropped_bytes;
+    #endif
+
+    #if ENABLED(SERIAL_STATS_RX_BUFFER_OVERRUNS)
+      if (TEST(M_UCSRxA, M_DORx) && !++rx_buffer_overruns) --rx_buffer_overruns;
+    #endif
+
+    #if ENABLED(SERIAL_STATS_RX_FRAMING_ERRORS)
+      if (TEST(M_UCSRxA, M_FEx) && !++rx_framing_errors) --rx_framing_errors;
+    #endif

    // Read the character from the USART
-    uint8_t c = R_UDR;
+    uint8_t c = M_UDRx;

-    if (Cfg::EMERGENCYPARSER) emergency_parser.update(emergency_state, c);
+    #if ENABLED(EMERGENCY_PARSER)
+      emergency_parser.update(emergency_state, c);
+    #endif

    // If the character is to be stored at the index just before the tail
    // (such that the head would advance to the current tail), the RX FIFO is
@@ -159,28 +202,29 @@
      rx_buffer.buffer[h] = c;
      h = i;
    }
-    else if (Cfg::DROPPED_RX && !++rx_dropped_bytes)
-      --rx_dropped_bytes;
+    #if ENABLED(SERIAL_STATS_DROPPED_RX)
+      else if (!++rx_dropped_bytes) --rx_dropped_bytes;
+    #endif

-    if (Cfg::MAX_RX_QUEUED) {
+    #if ENABLED(SERIAL_STATS_MAX_RX_QUEUED)
      // Calculate count of bytes stored into the RX buffer
-      const ring_buffer_pos_t rx_count = (ring_buffer_pos_t)(h - t) & (ring_buffer_pos_t)(Cfg::RX_SIZE - 1);
+      const ring_buffer_pos_t rx_count = (ring_buffer_pos_t)(h - t) & (ring_buffer_pos_t)(RX_BUFFER_SIZE - 1);

      // Keep track of the maximum count of enqueued bytes
      NOLESS(rx_max_enqueued, rx_count);
-    }
+    #endif

-    if (Cfg::XONOFF) {
+    #if ENABLED(SERIAL_XON_XOFF)
      // If the last char that was sent was an XON
      if ((xon_xoff_state & XON_XOFF_CHAR_MASK) == XON_CHAR) {

        // Bytes stored into the RX buffer
-        const ring_buffer_pos_t rx_count = (ring_buffer_pos_t)(h - t) & (ring_buffer_pos_t)(Cfg::RX_SIZE - 1);
+        const ring_buffer_pos_t rx_count = (ring_buffer_pos_t)(h - t) & (ring_buffer_pos_t)(RX_BUFFER_SIZE - 1);

        // If over 12.5% of RX buffer capacity, send XOFF before running out of
        // RX buffer space .. 325 bytes @ 250kbits/s needed to let the host react
        // and stop sending bytes. This translates to 13mS propagation time.
-        if (rx_count >= (Cfg::RX_SIZE) / 8) {
+        if (rx_count >= (RX_BUFFER_SIZE) / 8) {

          // At this point, definitely no TX interrupt was executing, since the TX ISR can't be preempted.
          // Don't enable the TX interrupt here as a means to trigger the XOFF char, because if it happens
@@ -194,17 +238,19 @@
          // Wait until the TX register becomes empty and send it - Here there could be a problem
          // - While waiting for the TX register to empty, the RX register could receive a new
          //   character. This must also handle that situation!
-          while (!B_UDRE) {
+          while (!TEST(M_UCSRxA, M_UDREx)) {

-            if (B_RXC) {
+            if (TEST(M_UCSRxA,M_RXCx)) {
              // A char arrived while waiting for the TX buffer to be empty - Receive and process it!

-              i = (ring_buffer_pos_t)(h + 1) & (ring_buffer_pos_t)(Cfg::RX_SIZE - 1);
+              i = (ring_buffer_pos_t)(h + 1) & (ring_buffer_pos_t)(RX_BUFFER_SIZE - 1);

              // Read the character from the USART
-              c = R_UDR;
+              c = M_UDRx;

-              if (Cfg::EMERGENCYPARSER) emergency_parser.update(emergency_state, c);
+              #if ENABLED(EMERGENCY_PARSER)
+                emergency_parser.update(emergency_state, c);
+              #endif

              // If the character is to be stored at the index just before the tail
              // (such that the head would advance to the current tail), the FIFO is
@@ -213,18 +259,19 @@
                rx_buffer.buffer[h] = c;
                h = i;
              }
-              else if (Cfg::DROPPED_RX && !++rx_dropped_bytes)
-                --rx_dropped_bytes;
+              #if ENABLED(SERIAL_STATS_DROPPED_RX)
+                else if (!++rx_dropped_bytes) --rx_dropped_bytes;
+              #endif
            }
            sw_barrier();
          }

-          R_UDR = XOFF_CHAR;
+          M_UDRx = XOFF_CHAR;

          // Clear the TXC bit -- "can be cleared by writing a one to its bit
          // location". This makes sure flush() won't return until the bytes
          // actually got written
-          B_TXC = 1;
+          SBI(M_UCSRxA, M_TXCx);

          // At this point there could be a race condition between the write() function
          // and this sending of the XOFF char. This interrupt could happen between the
@@ -233,18 +280,19 @@
          // sure the write() function will succeed is to wait for the XOFF char to be
          // completely sent. Since an extra character could be received during the wait
          // it must also be handled!
-          while (!B_UDRE) {
+          while (!TEST(M_UCSRxA, M_UDREx)) {

-            if (B_RXC) {
+            if (TEST(M_UCSRxA,M_RXCx)) {
              // A char arrived while waiting for the TX buffer to be empty - Receive and process it!

-              i = (ring_buffer_pos_t)(h + 1) & (ring_buffer_pos_t)(Cfg::RX_SIZE - 1);
+              i = (ring_buffer_pos_t)(h + 1) & (ring_buffer_pos_t)(RX_BUFFER_SIZE - 1);

              // Read the character from the USART
-              c = R_UDR;
+              c = M_UDRx;

-              if (Cfg::EMERGENCYPARSER)
+              #if ENABLED(EMERGENCY_PARSER)
                emergency_parser.update(emergency_state, c);
+              #endif

              // If the character is to be stored at the index just before the tail
              // (such that the head would advance to the current tail), the FIFO is
@@ -253,8 +301,9 @@
                rx_buffer.buffer[h] = c;
                h = i;
              }
-              else if (Cfg::DROPPED_RX && !++rx_dropped_bytes)
-                --rx_dropped_bytes;
+              #if ENABLED(SERIAL_STATS_DROPPED_RX)
+                else if (!++rx_dropped_bytes) --rx_dropped_bytes;
+              #endif
            }
            sw_barrier();
          }
@@ -263,68 +312,78 @@
          // have any issues writing to the UART TX register if it needs to!
        }
      }
-    }
+    #endif // SERIAL_XON_XOFF

    // Store the new head value - The main loop will retry until the value is stable
    rx_buffer.head = h;
  }

-  // (called with TX irqs disabled)
-  template<typename Cfg>
-  FORCE_INLINE void MarlinSerial<Cfg>::_tx_udr_empty_irq() {
-    if (Cfg::TX_SIZE > 0) {
+  #if TX_BUFFER_SIZE > 0
+
+    // (called with TX irqs disabled)
+    FORCE_INLINE void _tx_udr_empty_irq(void) {
+
      // Read positions
      uint8_t t = tx_buffer.tail;
      const uint8_t h = tx_buffer.head;

-      if (Cfg::XONOFF) {
+      #if ENABLED(SERIAL_XON_XOFF)
        // If an XON char is pending to be sent, do it now
        if (xon_xoff_state == XON_CHAR) {

          // Send the character
-          R_UDR = XON_CHAR;
+          M_UDRx = XON_CHAR;

          // clear the TXC bit -- "can be cleared by writing a one to its bit
          // location". This makes sure flush() won't return until the bytes
          // actually got written
-          B_TXC = 1;
+          SBI(M_UCSRxA, M_TXCx);

          // Remember we sent it.
          xon_xoff_state = XON_CHAR | XON_XOFF_CHAR_SENT;

          // If nothing else to transmit, just disable TX interrupts.
-          if (h == t) B_UDRIE = 0; // (Non-atomic, could be reenabled by the main program, but eventually this will succeed)
+          if (h == t) CBI(M_UCSRxB, M_UDRIEx); // (Non-atomic, could be reenabled by the main program, but eventually this will succeed)

          return;
        }
-      }
+      #endif

      // If nothing to transmit, just disable TX interrupts. This could
      // happen as the result of the non atomicity of the disabling of RX
      // interrupts that could end reenabling TX interrupts as a side effect.
      if (h == t) {
-        B_UDRIE = 0; // (Non-atomic, could be reenabled by the main program, but eventually this will succeed)
+        CBI(M_UCSRxB, M_UDRIEx); // (Non-atomic, could be reenabled by the main program, but eventually this will succeed)
        return;
      }

      // There is something to TX, Send the next byte
      const uint8_t c = tx_buffer.buffer[t];
-      t = (t + 1) & (Cfg::TX_SIZE - 1);
-      R_UDR = c;
+      t = (t + 1) & (TX_BUFFER_SIZE - 1);
+      M_UDRx = c;
      tx_buffer.tail = t;

      // Clear the TXC bit (by writing a one to its bit location).
      // Ensures flush() won't return until the bytes are actually written/
-      B_TXC = 1;
+      SBI(M_UCSRxA, M_TXCx);

      // Disable interrupts if there is nothing to transmit following this byte
-      if (h == t) B_UDRIE = 0; // (Non-atomic, could be reenabled by the main program, but eventually this will succeed)
+      if (h == t) CBI(M_UCSRxB, M_UDRIEx); // (Non-atomic, could be reenabled by the main program, but eventually this will succeed)
    }
-  }
+
+    #ifdef M_USARTx_UDRE_vect
+      ISR(M_USARTx_UDRE_vect) { _tx_udr_empty_irq(); }
+    #endif
+
+  #endif // TX_BUFFER_SIZE
+
+  #ifdef M_USARTx_RX_vect
+    ISR(M_USARTx_RX_vect) { store_rxd_char(); }
+  #endif

  // Public Methods
-  template<typename Cfg>
-  void MarlinSerial<Cfg>::begin(const long baud) {
+
+  void MarlinSerial::begin(const long baud) {
    uint16_t baud_setting;
    bool useU2X = true;

@@ -335,41 +394,41 @@
      if (baud == 57600) useU2X = false;
    #endif

-    R_UCSRA = 0;
    if (useU2X) {
-      B_U2X = 1;
+      M_UCSRxA = _BV(M_U2Xx);
      baud_setting = (F_CPU / 4 / baud - 1) / 2;
    }
-    else
+    else {
+      M_UCSRxA = 0;
      baud_setting = (F_CPU / 8 / baud - 1) / 2;
+    }

    // assign the baud_setting, a.k.a. ubbr (USART Baud Rate Register)
-    R_UBRRH = baud_setting >> 8;
-    R_UBRRL = baud_setting;
+    M_UBRRxH = baud_setting >> 8;
+    M_UBRRxL = baud_setting;

-    B_RXEN = 1;
-    B_TXEN = 1;
-    B_RXCIE = 1;
-    if (Cfg::TX_SIZE > 0) B_UDRIE = 0;
+    SBI(M_UCSRxB, M_RXENx);
+    SBI(M_UCSRxB, M_TXENx);
+    SBI(M_UCSRxB, M_RXCIEx);
+    #if TX_BUFFER_SIZE > 0
+      CBI(M_UCSRxB, M_UDRIEx);
+    #endif
    _written = false;
  }

-  template<typename Cfg>
-  void MarlinSerial<Cfg>::end() {
-    B_RXEN = 0;
-    B_TXEN = 0;
-    B_RXCIE = 0;
-    B_UDRIE = 0;
+  void MarlinSerial::end() {
+    CBI(M_UCSRxB, M_RXENx);
+    CBI(M_UCSRxB, M_TXENx);
+    CBI(M_UCSRxB, M_RXCIEx);
+    CBI(M_UCSRxB, M_UDRIEx);
  }

-  template<typename Cfg>
-  int MarlinSerial<Cfg>::peek() {
+  int MarlinSerial::peek(void) {
    const ring_buffer_pos_t h = atomic_read_rx_head(), t = rx_buffer.tail;
    return h == t ? -1 : rx_buffer.buffer[t];
  }

-  template<typename Cfg>
-  int MarlinSerial<Cfg>::read() {
+  int MarlinSerial::read(void) {
    const ring_buffer_pos_t h = atomic_read_rx_head();

    // Read the tail. Main thread owns it, so it is safe to directly read it
@@ -380,45 +439,42 @@

    // Get the next char
    const int v = rx_buffer.buffer[t];
-    t = (ring_buffer_pos_t)(t + 1) & (Cfg::RX_SIZE - 1);
+    t = (ring_buffer_pos_t)(t + 1) & (RX_BUFFER_SIZE - 1);

    // Advance tail - Making sure the RX ISR will always get an stable value, even
    // if it interrupts the writing of the value of that variable in the middle.
    atomic_set_rx_tail(t);

-    if (Cfg::XONOFF) {
+    #if ENABLED(SERIAL_XON_XOFF)
      // If the XOFF char was sent, or about to be sent...
      if ((xon_xoff_state & XON_XOFF_CHAR_MASK) == XOFF_CHAR) {
        // Get count of bytes in the RX buffer
-        const ring_buffer_pos_t rx_count = (ring_buffer_pos_t)(h - t) & (ring_buffer_pos_t)(Cfg::RX_SIZE - 1);
-        if (rx_count < (Cfg::RX_SIZE) / 10) {
-          if (Cfg::TX_SIZE > 0) {
+        const ring_buffer_pos_t rx_count = (ring_buffer_pos_t)(h - t) & (ring_buffer_pos_t)(RX_BUFFER_SIZE - 1);
+        if (rx_count < (RX_BUFFER_SIZE) / 10) {
+          #if TX_BUFFER_SIZE > 0
            // Signal we want an XON character to be sent.
            xon_xoff_state = XON_CHAR;
            // Enable TX ISR. Non atomic, but it will eventually enable them
-            B_UDRIE = 1;
-          }
-          else {
+            SBI(M_UCSRxB, M_UDRIEx);
+          #else
            // If not using TX interrupts, we must send the XON char now
            xon_xoff_state = XON_CHAR | XON_XOFF_CHAR_SENT;
-            while (!B_UDRE) sw_barrier();
-            R_UDR = XON_CHAR;
-          }
+            while (!TEST(M_UCSRxA, M_UDREx)) sw_barrier();
+            M_UDRx = XON_CHAR;
+          #endif
        }
      }
-    }
+    #endif

    return v;
  }

-  template<typename Cfg>
-  typename MarlinSerial<Cfg>::ring_buffer_pos_t MarlinSerial<Cfg>::available() {
+  ring_buffer_pos_t MarlinSerial::available(void) {
    const ring_buffer_pos_t h = atomic_read_rx_head(), t = rx_buffer.tail;
-    return (ring_buffer_pos_t)(Cfg::RX_SIZE + h - t) & (Cfg::RX_SIZE - 1);
+    return (ring_buffer_pos_t)(RX_BUFFER_SIZE + h - t) & (RX_BUFFER_SIZE - 1);
  }

-  template<typename Cfg>
-  void MarlinSerial<Cfg>::flush() {
+  void MarlinSerial::flush(void) {

    // Set the tail to the head:
    //  - Read the RX head index in a safe way. (See atomic_read_rx_head.)
@@ -426,36 +482,26 @@
    //    if it interrupts the writing of the value of that variable in the middle.
    atomic_set_rx_tail(atomic_read_rx_head());

-    if (Cfg::XONOFF) {
+    #if ENABLED(SERIAL_XON_XOFF)
      // If the XOFF char was sent, or about to be sent...
      if ((xon_xoff_state & XON_XOFF_CHAR_MASK) == XOFF_CHAR) {
-        if (Cfg::TX_SIZE > 0) {
+        #if TX_BUFFER_SIZE > 0
          // Signal we want an XON character to be sent.
          xon_xoff_state = XON_CHAR;
          // Enable TX ISR. Non atomic, but it will eventually enable it.
-          B_UDRIE = 1;
-        }
-        else {
+          SBI(M_UCSRxB, M_UDRIEx);
+        #else
          // If not using TX interrupts, we must send the XON char now
          xon_xoff_state = XON_CHAR | XON_XOFF_CHAR_SENT;
-          while (!B_UDRE) sw_barrier();
-          R_UDR = XON_CHAR;
-        }
+          while (!TEST(M_UCSRxA, M_UDREx)) sw_barrier();
+          M_UDRx = XON_CHAR;
+        #endif
      }
-    }
+    #endif
  }

-  template<typename Cfg>
-  void MarlinSerial<Cfg>::write(const uint8_t c) {
-    if (Cfg::TX_SIZE == 0) {
-
-      _written = true;
-      while (!B_UDRE) sw_barrier();
-      R_UDR = c;
-
-    }
-    else {
-
+  #if TX_BUFFER_SIZE > 0
+    void MarlinSerial::write(const uint8_t c) {
      _written = true;

      // If the TX interrupts are disabled and the data register
@@ -465,17 +511,17 @@
      // interrupt overhead becomes a slowdown.
      // Yes, there is a race condition between the sending of the
      // XOFF char at the RX ISR, but it is properly handled there
-      if (!B_UDRIE && B_UDRE) {
-        R_UDR = c;
+      if (!TEST(M_UCSRxB, M_UDRIEx) && TEST(M_UCSRxA, M_UDREx)) {
+        M_UDRx = c;

        // clear the TXC bit -- "can be cleared by writing a one to its bit
        // location". This makes sure flush() won't return until the bytes
        // actually got written
-        B_TXC = 1;
+        SBI(M_UCSRxA, M_TXCx);
        return;
      }

-      const uint8_t i = (tx_buffer.head + 1) & (Cfg::TX_SIZE - 1);
+      const uint8_t i = (tx_buffer.head + 1) & (TX_BUFFER_SIZE - 1);

      // If global interrupts are disabled (as the result of being called from an ISR)...
      if (!ISRS_ENABLED()) {
@@ -484,7 +530,7 @@
        while (i == tx_buffer.tail) {

          // If we can transmit another byte, do it.
-          if (B_UDRE) _tx_udr_empty_irq();
+          if (TEST(M_UCSRxA, M_UDREx)) _tx_udr_empty_irq();

          // Make sure compiler rereads tx_buffer.tail
          sw_barrier();
@@ -492,7 +538,7 @@
      }
      else {
        // Interrupts are enabled, just wait until there is space
-        while (i == tx_buffer.tail) sw_barrier();
+        while (i == tx_buffer.tail) { sw_barrier(); }
      }

      // Store new char. head is always safe to move
@@ -500,27 +546,10 @@
      tx_buffer.head = i;

      // Enable TX ISR - Non atomic, but it will eventually enable TX ISR
-      B_UDRIE = 1;
+      SBI(M_UCSRxB, M_UDRIEx);
    }
-  }
-
-  template<typename Cfg>
-  void MarlinSerial<Cfg>::flushTX() {
-
-    if (Cfg::TX_SIZE == 0) {
-      // No bytes written, no need to flush. This special case is needed since there's
-      // no way to force the TXC (transmit complete) bit to 1 during initialization.
-      if (!_written) return;
-
-      // Wait until everything was transmitted
-      while (!B_TXC) sw_barrier();
-
-      // At this point nothing is queued anymore (DRIE is disabled) and
-      // the hardware finished transmission (TXC is set).
-
-    }
-    else {

+    void MarlinSerial::flushTX(void) {
      // No bytes written, no need to flush. This special case is needed since there's
      // no way to force the TXC (transmit complete) bit to 1 during initialization.
      if (!_written) return;
@@ -529,10 +558,11 @@
      if (!ISRS_ENABLED()) {

        // Wait until everything was transmitted - We must do polling, as interrupts are disabled
-        while (tx_buffer.head != tx_buffer.tail || !B_TXC) {
+        while (tx_buffer.head != tx_buffer.tail || !TEST(M_UCSRxA, M_TXCx)) {

          // If there is more space, send an extra character
-          if (B_UDRE) _tx_udr_empty_irq();
+          if (TEST(M_UCSRxA, M_UDREx))
+            _tx_udr_empty_irq();

          sw_barrier();
        }
@@ -540,40 +570,55 @@
      }
      else {
        // Wait until everything was transmitted
-        while (tx_buffer.head != tx_buffer.tail || !B_TXC) sw_barrier();
+        while (tx_buffer.head != tx_buffer.tail || !TEST(M_UCSRxA, M_TXCx)) sw_barrier();
      }

      // At this point nothing is queued anymore (DRIE is disabled) and
      // the hardware finished transmission (TXC is set).
    }
-  }
+
+  #else // TX_BUFFER_SIZE == 0
+
+    void MarlinSerial::write(const uint8_t c) {
+      _written = true;
+      while (!TEST(M_UCSRxA, M_UDREx)) sw_barrier();
+      M_UDRx = c;
+    }
+
+    void MarlinSerial::flushTX(void) {
+      // No bytes written, no need to flush. This special case is needed since there's
+      // no way to force the TXC (transmit complete) bit to 1 during initialization.
+      if (!_written) return;
+
+      // Wait until everything was transmitted
+      while (!TEST(M_UCSRxA, M_TXCx)) sw_barrier();
+
+      // At this point nothing is queued anymore (DRIE is disabled) and
+      // the hardware finished transmission (TXC is set).
+    }
+  #endif // TX_BUFFER_SIZE == 0

  /**
   * Imports from print.h
   */

-  template<typename Cfg>
-  void MarlinSerial<Cfg>::print(char c, int base) {
+  void MarlinSerial::print(char c, int base) {
    print((long)c, base);
  }

-  template<typename Cfg>
-  void MarlinSerial<Cfg>::print(unsigned char b, int base) {
+  void MarlinSerial::print(unsigned char b, int base) {
    print((unsigned long)b, base);
  }

-  template<typename Cfg>
-  void MarlinSerial<Cfg>::print(int n, int base) {
+  void MarlinSerial::print(int n, int base) {
    print((long)n, base);
  }

-  template<typename Cfg>
-  void MarlinSerial<Cfg>::print(unsigned int n, int base) {
+  void MarlinSerial::print(unsigned int n, int base) {
    print((unsigned long)n, base);
  }

-  template<typename Cfg>
-  void MarlinSerial<Cfg>::print(long n, int base) {
+  void MarlinSerial::print(long n, int base) {
    if (base == 0) write(n);
    else if (base == 10) {
      if (n < 0) { print('-'); n = -n; }
@@ -583,81 +628,68 @@
      printNumber(n, base);
  }

-  template<typename Cfg>
-  void MarlinSerial<Cfg>::print(unsigned long n, int base) {
+  void MarlinSerial::print(unsigned long n, int base) {
    if (base == 0) write(n);
    else printNumber(n, base);
  }

-  template<typename Cfg>
-  void MarlinSerial<Cfg>::print(double n, int digits) {
+  void MarlinSerial::print(double n, int digits) {
    printFloat(n, digits);
  }

-  template<typename Cfg>
-  void MarlinSerial<Cfg>::println() {
+  void MarlinSerial::println(void) {
    print('\r');
    print('\n');
  }

-  template<typename Cfg>
-  void MarlinSerial<Cfg>::println(const String& s) {
+  void MarlinSerial::println(const String& s) {
    print(s);
    println();
  }

-  template<typename Cfg>
-  void MarlinSerial<Cfg>::println(const char c[]) {
+  void MarlinSerial::println(const char c[]) {
    print(c);
    println();
  }

-  template<typename Cfg>
-  void MarlinSerial<Cfg>::println(char c, int base) {
+  void MarlinSerial::println(char c, int base) {
    print(c, base);
    println();
  }

-  template<typename Cfg>
-  void MarlinSerial<Cfg>::println(unsigned char b, int base) {
+  void MarlinSerial::println(unsigned char b, int base) {
    print(b, base);
    println();
  }

-  template<typename Cfg>
-  void MarlinSerial<Cfg>::println(int n, int base) {
+  void MarlinSerial::println(int n, int base) {
    print(n, base);
    println();
  }

-  template<typename Cfg>
-  void MarlinSerial<Cfg>::println(unsigned int n, int base) {
+  void MarlinSerial::println(unsigned int n, int base) {
    print(n, base);
    println();
  }

-  template<typename Cfg>
-  void MarlinSerial<Cfg>::println(long n, int base) {
+  void MarlinSerial::println(long n, int base) {
    print(n, base);
    println();
  }

-  template<typename Cfg>
-  void MarlinSerial<Cfg>::println(unsigned long n, int base) {
+  void MarlinSerial::println(unsigned long n, int base) {
    print(n, base);
    println();
  }

-  template<typename Cfg>
-  void MarlinSerial<Cfg>::println(double n, int digits) {
+  void MarlinSerial::println(double n, int digits) {
    print(n, digits);
    println();
  }

  // Private Methods

-  template<typename Cfg>
-  void MarlinSerial<Cfg>::printNumber(unsigned long n, uint8_t base) {
+  void MarlinSerial::printNumber(unsigned long n, uint8_t base) {
    if (n) {
      unsigned char buf[8 * sizeof(long)]; // Enough space for base 2
      int8_t i = 0;
@@ -672,8 +704,7 @@
      print('0');
  }

-  template<typename Cfg>
-  void MarlinSerial<Cfg>::printFloat(double number, uint8_t digits) {
+  void MarlinSerial::printFloat(double number, uint8_t digits) {
    // Handle negative numbers
    if (number < 0.0) {
      print('-');
@@ -682,7 +713,9 @@

    // Round correctly so that print(1.999, 2) prints as "2.00"
    double rounding = 0.5;
-    LOOP_L_N(i, digits) rounding *= 0.1;
+    for (uint8_t i = 0; i < digits; ++i)
+      rounding *= 0.1;
+
    number += rounding;

    // Extract the integer part of the number and print it
@@ -703,87 +736,11 @@
    }
  }

-  // Hookup ISR handlers
-  ISR(SERIAL_REGNAME(USART,SERIAL_PORT,_RX_vect)) {
-    MarlinSerial<MarlinSerialCfg<SERIAL_PORT>>::store_rxd_char();
-  }
-
-  ISR(SERIAL_REGNAME(USART,SERIAL_PORT,_UDRE_vect)) {
-    MarlinSerial<MarlinSerialCfg<SERIAL_PORT>>::_tx_udr_empty_irq();
-  }
-
  // Preinstantiate
-  template class MarlinSerial<MarlinSerialCfg<SERIAL_PORT>>;
-
-  // Instantiate
-  MarlinSerial<MarlinSerialCfg<SERIAL_PORT>> customizedSerial1;
-
-  #ifdef SERIAL_PORT_2
-
-    // Hookup ISR handlers
-    ISR(SERIAL_REGNAME(USART,SERIAL_PORT_2,_RX_vect)) {
-      MarlinSerial<MarlinSerialCfg<SERIAL_PORT_2>>::store_rxd_char();
-    }
-
-    ISR(SERIAL_REGNAME(USART,SERIAL_PORT_2,_UDRE_vect)) {
-      MarlinSerial<MarlinSerialCfg<SERIAL_PORT_2>>::_tx_udr_empty_irq();
-    }
-
-    // Preinstantiate
-    template class MarlinSerial<MarlinSerialCfg<SERIAL_PORT_2>>;
-
-    // Instantiate
-    MarlinSerial<MarlinSerialCfg<SERIAL_PORT_2>> customizedSerial2;
-
-  #endif
+  MarlinSerial customizedSerial;

 #endif // !USBCON && (UBRRH || UBRR0H || UBRR1H || UBRR2H || UBRR3H)

-#ifdef INTERNAL_SERIAL_PORT
-
-  ISR(SERIAL_REGNAME(USART,INTERNAL_SERIAL_PORT,_RX_vect)) {
-    MarlinSerial<MarlinInternalSerialCfg<INTERNAL_SERIAL_PORT>>::store_rxd_char();
-  }
-
-  ISR(SERIAL_REGNAME(USART,INTERNAL_SERIAL_PORT,_UDRE_vect)) {
-    MarlinSerial<MarlinInternalSerialCfg<INTERNAL_SERIAL_PORT>>::_tx_udr_empty_irq();
-  }
-
-  // Preinstantiate
-  template class MarlinSerial<MarlinInternalSerialCfg<INTERNAL_SERIAL_PORT>>;
-
-  // Instantiate
-  MarlinSerial<MarlinInternalSerialCfg<INTERNAL_SERIAL_PORT>> internalSerial;
-
-#endif
-
-#ifdef DGUS_SERIAL_PORT
-
-  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.
-                            h = tx_buffer.head;  // next pos for queue.
-    int ret = t - h - 1;
-    if (ret < 0) ret += Cfg::TX_SIZE + 1;
-    return ret;
-  }
-
-  ISR(SERIAL_REGNAME(USART,DGUS_SERIAL_PORT,_RX_vect)) {
-    MarlinSerial<MarlinInternalSerialCfg<DGUS_SERIAL_PORT>>::store_rxd_char();
-  }
-
-  ISR(SERIAL_REGNAME(USART,DGUS_SERIAL_PORT,_UDRE_vect)) {
-    MarlinSerial<MarlinInternalSerialCfg<DGUS_SERIAL_PORT>>::_tx_udr_empty_irq();
-  }
-
-  // Preinstantiate
-  template class MarlinSerial<MarlinInternalSerialCfg<DGUS_SERIAL_PORT>>;
-
-  // Instantiate
-  MarlinSerial<MarlinInternalSerialCfg<DGUS_SERIAL_PORT>> internalDgusSerial;
-
-#endif
-
 // For AT90USB targets use the UART for BT interfacing
 #if defined(USBCON) && ENABLED(BLUETOOTH)
  HardwareSerial bluetoothSerial;
--- a/Marlin/src/HAL/HAL_AVR/MarlinSerial.h
+++ b/Marlin/src/HAL/HAL_AVR/MarlinSerial.h
@@ -0,0 +1,177 @@
+/**
+ * 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/>.
+ *
+ */
+
+/**
+ * MarlinSerial.h - Hardware serial library for Wiring
+ * Copyright (c) 2006 Nicholas Zambetti.  All right reserved.
+ *
+ * Modified 28 September 2010 by Mark Sproul
+ * Modified 14 February 2016 by Andreas Hardtung (added tx buffer)
+ * Modified 01 October 2017 by Eduardo José Tagle (added XON/XOFF)
+ */
+
+#ifndef _MARLINSERIAL_H_
+#define _MARLINSERIAL_H_
+
+#include "../../inc/MarlinConfigPre.h"
+
+#include <WString.h>
+
+#ifndef SERIAL_PORT
+  #define SERIAL_PORT 0
+#endif
+
+// The presence of the UBRRH register is used to detect a UART.
+#define UART_PRESENT(port) ((port == 0 && (defined(UBRRH) || defined(UBRR0H))) || \
+                            (port == 1 && defined(UBRR1H)) || (port == 2 && defined(UBRR2H)) || \
+                            (port == 3 && defined(UBRR3H)))
+
+// These are macros to build serial port register names for the selected SERIAL_PORT (C preprocessor
+// requires two levels of indirection to expand macro values properly)
+#define SERIAL_REGNAME(registerbase,number,suffix) SERIAL_REGNAME_INTERNAL(registerbase,number,suffix)
+#if SERIAL_PORT == 0 && (!defined(UBRR0H) || !defined(UDR0)) // use un-numbered registers if necessary
+  #define SERIAL_REGNAME_INTERNAL(registerbase,number,suffix) registerbase##suffix
+#else
+  #define SERIAL_REGNAME_INTERNAL(registerbase,number,suffix) registerbase##number##suffix
+#endif
+
+// Registers used by MarlinSerial class (expanded depending on selected serial port)
+#define M_UCSRxA           SERIAL_REGNAME(UCSR,SERIAL_PORT,A) // defines M_UCSRxA to be UCSRnA where n is the serial port number
+#define M_UCSRxB           SERIAL_REGNAME(UCSR,SERIAL_PORT,B)
+#define M_RXENx            SERIAL_REGNAME(RXEN,SERIAL_PORT,)
+#define M_TXENx            SERIAL_REGNAME(TXEN,SERIAL_PORT,)
+#define M_TXCx             SERIAL_REGNAME(TXC,SERIAL_PORT,)
+#define M_RXCIEx           SERIAL_REGNAME(RXCIE,SERIAL_PORT,)
+#define M_UDREx            SERIAL_REGNAME(UDRE,SERIAL_PORT,)
+#define M_FEx              SERIAL_REGNAME(FE,SERIAL_PORT,)
+#define M_DORx             SERIAL_REGNAME(DOR,SERIAL_PORT,)
+#define M_UPEx             SERIAL_REGNAME(UPE,SERIAL_PORT,)
+#define M_UDRIEx           SERIAL_REGNAME(UDRIE,SERIAL_PORT,)
+#define M_UDRx             SERIAL_REGNAME(UDR,SERIAL_PORT,)
+#define M_UBRRxH           SERIAL_REGNAME(UBRR,SERIAL_PORT,H)
+#define M_UBRRxL           SERIAL_REGNAME(UBRR,SERIAL_PORT,L)
+#define M_RXCx             SERIAL_REGNAME(RXC,SERIAL_PORT,)
+#define M_USARTx_RX_vect   SERIAL_REGNAME(USART,SERIAL_PORT,_RX_vect)
+#define M_U2Xx             SERIAL_REGNAME(U2X,SERIAL_PORT,)
+#define M_USARTx_UDRE_vect SERIAL_REGNAME(USART,SERIAL_PORT,_UDRE_vect)
+
+#define DEC 10
+#define HEX 16
+#define OCT 8
+#define BIN 2
+#define BYTE 0
+
+#ifndef USBCON
+  // We're using a ring buffer (I think), in which rx_buffer_head is the index of the
+  // location to which to write the next incoming character and rx_buffer_tail is the
+  // index of the location from which to read.
+  #if RX_BUFFER_SIZE > 256
+    typedef uint16_t ring_buffer_pos_t;
+  #else
+    typedef uint8_t ring_buffer_pos_t;
+  #endif
+
+  #if ENABLED(SERIAL_STATS_DROPPED_RX)
+    extern uint8_t rx_dropped_bytes;
+  #endif
+
+  #if ENABLED(SERIAL_STATS_RX_BUFFER_OVERRUNS)
+    extern uint8_t rx_buffer_overruns;
+  #endif
+
+  #if ENABLED(SERIAL_STATS_RX_FRAMING_ERRORS)
+    extern uint8_t rx_framing_errors;
+  #endif
+
+  #if ENABLED(SERIAL_STATS_MAX_RX_QUEUED)
+    extern ring_buffer_pos_t rx_max_enqueued;
+  #endif
+
+  class MarlinSerial {
+
+    public:
+      MarlinSerial() {};
+      static void begin(const long);
+      static void end();
+      static int peek(void);
+      static int read(void);
+      static void flush(void);
+      static ring_buffer_pos_t available(void);
+      static void write(const uint8_t c);
+      static void flushTX(void);
+
+      #if ENABLED(SERIAL_STATS_DROPPED_RX)
+        FORCE_INLINE static uint32_t dropped() { return rx_dropped_bytes; }
+      #endif
+
+      #if ENABLED(SERIAL_STATS_RX_BUFFER_OVERRUNS)
+        FORCE_INLINE static uint32_t buffer_overruns() { return rx_buffer_overruns; }
+      #endif
+
+      #if ENABLED(SERIAL_STATS_RX_FRAMING_ERRORS)
+        FORCE_INLINE static uint32_t framing_errors() { return rx_framing_errors; }
+      #endif
+
+      #if ENABLED(SERIAL_STATS_MAX_RX_QUEUED)
+        FORCE_INLINE static ring_buffer_pos_t rxMaxEnqueued() { return rx_max_enqueued; }
+      #endif
+
+      FORCE_INLINE static void write(const char* str) { while (*str) write(*str++); }
+      FORCE_INLINE static void write(const uint8_t* buffer, size_t size) { while (size--) write(*buffer++); }
+      FORCE_INLINE static void print(const String& s) { for (int i = 0; i < (int)s.length(); i++) write(s[i]); }
+      FORCE_INLINE static void print(const char* str) { write(str); }
+
+      static void print(char, int = BYTE);
+      static void print(unsigned char, int = BYTE);
+      static void print(int, int = DEC);
+      static void print(unsigned int, int = DEC);
+      static void print(long, int = DEC);
+      static void print(unsigned long, int = DEC);
+      static void print(double, int = 2);
+
+      static void println(const String& s);
+      static void println(const char[]);
+      static void println(char, int = BYTE);
+      static void println(unsigned char, int = BYTE);
+      static void println(int, int = DEC);
+      static void println(unsigned int, int = DEC);
+      static void println(long, int = DEC);
+      static void println(unsigned long, int = DEC);
+      static void println(double, int = 2);
+      static void println(void);
+      operator bool() { return true; }
+
+    private:
+      static void printNumber(unsigned long, const uint8_t);
+      static void printFloat(double, uint8_t);
+  };
+
+  extern MarlinSerial customizedSerial;
+
+#endif // !USBCON
+
+// Use the UART for Bluetooth in AT90USB configurations
+#if defined(USBCON) && ENABLED(BLUETOOTH)
+  extern HardwareSerial bluetoothSerial;
+#endif
+
+#endif // _MARLINSERIAL_H_
--- a/Marlin/src/HAL/HAL_AVR/SanityCheck.h
+++ b/Marlin/src/HAL/HAL_AVR/SanityCheck.h
@@ -0,0 +1,117 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016, 2017 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/>.
+ *
+ */
+
+#ifndef _SANITYCHECK_AVR_8_BIT_H_
+#define _SANITYCHECK_AVR_8_BIT_H_
+
+/**
+ * Test AVR specific configuration values for errors at compile-time.
+ */
+
+/**
+ * Digipot requirement
+ */
+ #if ENABLED(DIGIPOT_MCP4018)
+  #if !defined(DIGIPOTS_I2C_SDA_X) || !defined(DIGIPOTS_I2C_SDA_Y) || !defined(DIGIPOTS_I2C_SDA_Z) \
+    || !defined(DIGIPOTS_I2C_SDA_E0) || !defined(DIGIPOTS_I2C_SDA_E1)
+      #error "DIGIPOT_MCP4018 requires DIGIPOTS_I2C_SDA_* pins to be defined."
+  #endif
+#endif
+
+/**
+ * Sanity checks for Spindle / Laser
+ */
+#if ENABLED(SPINDLE_LASER_ENABLE)
+  #if !PIN_EXISTS(SPINDLE_LASER_ENABLE)
+    #error "SPINDLE_LASER_ENABLE requires SPINDLE_LASER_ENABLE_PIN."
+  #elif SPINDLE_DIR_CHANGE && !PIN_EXISTS(SPINDLE_DIR)
+    #error "SPINDLE_DIR_PIN not defined."
+  #elif ENABLED(SPINDLE_LASER_PWM) && PIN_EXISTS(SPINDLE_LASER_PWM)
+    #if !(WITHIN(SPINDLE_LASER_PWM_PIN, 2, 13) || WITHIN(SPINDLE_LASER_PWM_PIN, 44, 46))
+      #error "SPINDLE_LASER_PWM_PIN not assigned to a PWM pin."
+    #elif SPINDLE_LASER_POWERUP_DELAY < 1
+      #error "SPINDLE_LASER_POWERUP_DELAY must be greater than 0."
+    #elif SPINDLE_LASER_POWERDOWN_DELAY < 1
+      #error "SPINDLE_LASER_POWERDOWN_DELAY must be greater than 0."
+    #elif !defined(SPINDLE_LASER_PWM_INVERT)
+      #error "SPINDLE_LASER_PWM_INVERT missing."
+    #elif !defined(SPEED_POWER_SLOPE) || !defined(SPEED_POWER_INTERCEPT) || !defined(SPEED_POWER_MIN) || !defined(SPEED_POWER_MAX)
+      #error "SPINDLE_LASER_PWM equation constant(s) missing."
+    #elif SPINDLE_LASER_PWM_PIN == 4 || WITHIN(SPINDLE_LASER_PWM_PIN, 11, 13)
+      #error "Counter/Timer for SPINDLE_LASER_PWM_PIN is used by a system interrupt."
+    #elif PIN_EXISTS(X_MAX) && X_MAX_PIN == SPINDLE_LASER_PWM_PIN
+      #error "SPINDLE_LASER_PWM pin is in use by X_MAX endstop."
+    #elif PIN_EXISTS(X_MIN) && X_MIN_PIN == SPINDLE_LASER_PWM_PIN
+      #error "SPINDLE_LASER_PWM pin is in use by X_MIN endstop."
+    #elif PIN_EXISTS(Z_STEP) && Z_STEP_PIN == SPINDLE_LASER_PWM_PIN
+      #error "SPINDLE_LASER_PWM pin in use by Z_STEP."
+    #elif NUM_SERVOS > 0 && (WITHIN(SPINDLE_LASER_PWM_PIN, 2, 3) || SPINDLE_LASER_PWM_PIN == 5)
+      #error "Counter/Timer for SPINDLE_LASER_PWM_PIN is used by the servo system."
+    #elif PIN_EXISTS(CASE_LIGHT) && SPINDLE_LASER_PWM_PIN == CASE_LIGHT_PIN
+      #error "SPINDLE_LASER_PWM_PIN is used by CASE_LIGHT_PIN."
+    #elif PIN_EXISTS(E0_AUTO_FAN) && SPINDLE_LASER_PWM_PIN == E0_AUTO_FAN_PIN
+      #error "SPINDLE_LASER_PWM_PIN is used by E0_AUTO_FAN_PIN."
+    #elif PIN_EXISTS(E1_AUTO_FAN) && SPINDLE_LASER_PWM_PIN == E1_AUTO_FAN_PIN
+      #error "SPINDLE_LASER_PWM_PIN is used by E1_AUTO_FAN_PIN."
+    #elif PIN_EXISTS(E2_AUTO_FAN) && SPINDLE_LASER_PWM_PIN == E2_AUTO_FAN_PIN
+      #error "SPINDLE_LASER_PWM_PIN is used by E2_AUTO_FAN_PIN."
+    #elif PIN_EXISTS(E3_AUTO_FAN) && SPINDLE_LASER_PWM_PIN == E3_AUTO_FAN_PIN
+      #error "SPINDLE_LASER_PWM_PIN is used by E3_AUTO_FAN_PIN."
+    #elif PIN_EXISTS(E4_AUTO_FAN) && SPINDLE_LASER_PWM_PIN == E4_AUTO_FAN_PIN
+      #error "SPINDLE_LASER_PWM_PIN is used by E4_AUTO_FAN_PIN."
+    #elif PIN_EXISTS(FAN) && SPINDLE_LASER_PWM_PIN == FAN_PIN
+      #error "SPINDLE_LASER_PWM_PIN is used FAN_PIN."
+    #elif PIN_EXISTS(FAN1) && SPINDLE_LASER_PWM_PIN == FAN1_PIN
+      #error "SPINDLE_LASER_PWM_PIN is used FAN1_PIN."
+    #elif PIN_EXISTS(FAN2) && SPINDLE_LASER_PWM_PIN == FAN2_PIN
+      #error "SPINDLE_LASER_PWM_PIN is used FAN2_PIN."
+    #elif PIN_EXISTS(CONTROLLERFAN) && SPINDLE_LASER_PWM_PIN == CONTROLLERFAN_PIN
+      #error "SPINDLE_LASER_PWM_PIN is used by CONTROLLERFAN_PIN."
+    #elif PIN_EXISTS(MOTOR_CURRENT_PWM_XY) && SPINDLE_LASER_PWM_PIN == MOTOR_CURRENT_PWM_XY_PIN
+      #error "SPINDLE_LASER_PWM_PIN is used by MOTOR_CURRENT_PWM_XY."
+    #elif PIN_EXISTS(MOTOR_CURRENT_PWM_Z) && SPINDLE_LASER_PWM_PIN == MOTOR_CURRENT_PWM_Z_PIN
+      #error "SPINDLE_LASER_PWM_PIN is used by MOTOR_CURRENT_PWM_Z."
+    #elif PIN_EXISTS(MOTOR_CURRENT_PWM_E) && SPINDLE_LASER_PWM_PIN == MOTOR_CURRENT_PWM_E_PIN
+      #error "SPINDLE_LASER_PWM_PIN is used by MOTOR_CURRENT_PWM_E."
+    #endif
+  #endif
+#endif // SPINDLE_LASER_ENABLE
+
+/**
+ * TMC2208 software UART and ENDSTOP_INTERRUPTS both use pin change interrupts (PCI)
+ */
+#if HAS_DRIVER(TMC2208) && ENABLED(ENDSTOP_INTERRUPTS_FEATURE) && !( \
+       defined(X_HARDWARE_SERIAL ) \
+    || defined(X2_HARDWARE_SERIAL) \
+    || defined(Y_HARDWARE_SERIAL ) \
+    || defined(Y2_HARDWARE_SERIAL) \
+    || defined(Z_HARDWARE_SERIAL ) \
+    || defined(Z2_HARDWARE_SERIAL) \
+    || defined(E0_HARDWARE_SERIAL) \
+    || defined(E1_HARDWARE_SERIAL) \
+    || defined(E2_HARDWARE_SERIAL) \
+    || defined(E3_HARDWARE_SERIAL) \
+    || defined(E4_HARDWARE_SERIAL) )
+  #error "Select hardware UART for TMC2208 to use both TMC2208 and ENDSTOP_INTERRUPTS_FEATURE."
+#endif
+
+#endif // _SANITYCHECK_AVR_8_BIT_H_
--- a/Marlin/src/HAL/HAL_AVR/ServoTimers.h
+++ b/Marlin/src/HAL/HAL_AVR/ServoTimers.h
@@ -1,9 +1,9 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
 * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * 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
@@ -19,7 +19,6 @@
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
-#pragma once

 /**
 * ServoTimers.h - Interrupt driven Servo library for Arduino using 16 bit timers- Version 2
@@ -40,6 +39,9 @@
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

+#ifndef _SERVOTIMERS_H_
+#define _SERVOTIMERS_H_
+
 /**
 * Defines for 16 bit timers used with  Servo library
 *
@@ -53,8 +55,8 @@
 * --------------------
 */

-#define TRIM_DURATION           2   // compensation ticks to trim adjust for digitalWrite delays
-#define SERVO_TIMER_PRESCALER   8   // timer prescaler
+#define TRIM_DURATION       2   // compensation ticks to trim adjust for digitalWrite delays
+#define PRESCALER           8   // timer prescaler

 // Say which 16 bit timers can be used and in what order
 #if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
@@ -75,17 +77,19 @@
 #endif

 typedef enum {
-  #ifdef _useTimer1
+  #if ENABLED(_useTimer1)
    _timer1,
  #endif
-  #ifdef _useTimer3
+  #if ENABLED(_useTimer3)
    _timer3,
  #endif
-  #ifdef _useTimer4
+  #if ENABLED(_useTimer4)
    _timer4,
  #endif
-  #ifdef _useTimer5
+  #if ENABLED(_useTimer5)
    _timer5,
  #endif
  _Nbr_16timers
 } timer16_Sequence_t;
+
+#endif // _SERVOTIMERS_H_
--- a/Marlin/src/HAL/HAL_AVR/endstop_interrupts.h
+++ b/Marlin/src/HAL/HAL_AVR/endstop_interrupts.h
@@ -0,0 +1,241 @@
+/**
+ * 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/>.
+ *
+ */
+
+/**
+ * Endstop Interrupts
+ *
+ * Without endstop interrupts the endstop pins must be polled continually in
+ * the temperature-ISR via endstops.update(), most of the time finding no change.
+ * With this feature endstops.update() is called only when we know that at
+ * least one endstop has changed state, saving valuable CPU cycles.
+ *
+ * This feature only works when all used endstop pins can generate either an
+ * 'external interrupt' or a 'pin change interrupt'.
+ *
+ * Test whether pins issue interrupts on your board by flashing 'pin_interrupt_test.ino'.
+ * (Located in Marlin/buildroot/share/pin_interrupt_test/pin_interrupt_test.ino)
+ */
+
+#ifndef _ENDSTOP_INTERRUPTS_H_
+#define _ENDSTOP_INTERRUPTS_H_
+
+#include "../../core/macros.h"
+#include <stdint.h>
+#include "../../module/endstops.h"
+
+// One ISR for all EXT-Interrupts
+void endstop_ISR(void) { endstops.update(); }
+
+/**
+ * Patch for pins_arduino.h (...\Arduino\hardware\arduino\avr\variants\mega\pins_arduino.h)
+ *
+ * These macros for the Arduino MEGA do not include the two connected pins on Port J (D13, D14).
+ * So we extend them here because these are the normal pins for Y_MIN and Y_MAX on RAMPS.
+ * There are more PCI-enabled processor pins on Port J, but they are not connected to Arduino MEGA.
+ */
+#if defined(ARDUINO_AVR_MEGA2560) || defined(ARDUINO_AVR_MEGA)
+  #undef  digitalPinToPCICR
+  #define digitalPinToPCICR(p)    ( WITHIN(p, 10, 15) || \
+                                    WITHIN(p, 50, 53) || \
+                                    WITHIN(p, 62, 69) ? &PCICR : (uint8_t*)0 )
+  #undef  digitalPinToPCICRbit
+  #define digitalPinToPCICRbit(p) ( WITHIN(p, 10, 13) || WITHIN(p, 50, 53) ? 0 : \
+                                    WITHIN(p, 14, 15) ? 1 : \
+                                    WITHIN(p, 62, 69) ? 2 : \
+                                    0 )
+  #undef  digitalPinToPCMSK
+  #define digitalPinToPCMSK(p)    ( WITHIN(p, 10, 13) || WITHIN(p, 50, 53) ? &PCMSK0 : \
+                                    WITHIN(p, 14, 15) ? &PCMSK1 : \
+                                    WITHIN(p, 62, 69) ? &PCMSK2 : \
+                                    (uint8_t *)0 )
+  #undef  digitalPinToPCMSKbit
+  #define digitalPinToPCMSKbit(p) ( WITHIN(p, 10, 13) ? ((p) - 6) : \
+                                    (p) == 14 || (p) == 51 ? 2 : \
+                                    (p) == 15 || (p) == 52 ? 1 : \
+                                    (p) == 50 ? 3 : \
+                                    (p) == 53 ? 0 : \
+                                    WITHIN(p, 62, 69) ? ((p) - 62) : \
+                                    0 )
+#endif
+
+
+// Install Pin change interrupt for a pin. Can be called multiple times.
+void pciSetup(const int8_t pin) {
+  SBI(*digitalPinToPCMSK(pin), digitalPinToPCMSKbit(pin));  // enable pin
+  SBI(PCIFR, digitalPinToPCICRbit(pin)); // clear any outstanding interrupt
+  SBI(PCICR, digitalPinToPCICRbit(pin)); // enable interrupt for the group
+}
+
+
+// Handlers for pin change interrupts
+#ifdef PCINT0_vect
+  ISR(PCINT0_vect) { endstop_ISR(); }
+#endif
+
+#ifdef PCINT1_vect
+  ISR(PCINT1_vect) { endstop_ISR(); }
+#endif
+
+#ifdef PCINT2_vect
+  ISR(PCINT2_vect) { endstop_ISR(); }
+#endif
+
+#ifdef PCINT3_vect
+  ISR(PCINT3_vect) { endstop_ISR(); }
+#endif
+
+void setup_endstop_interrupts( void ) {
+
+  #if HAS_X_MAX
+    #if (digitalPinToInterrupt(X_MAX_PIN) != NOT_AN_INTERRUPT) // if pin has an external interrupt
+      attachInterrupt(digitalPinToInterrupt(X_MAX_PIN), endstop_ISR, CHANGE); // assign it
+    #else
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(X_MAX_PIN) != NULL, "X_MAX_PIN is not interrupt-capable"); // if pin has no pin change interrupt - error
+      pciSetup(X_MAX_PIN);                                                            // assign it
+    #endif
+  #endif
+
+  #if HAS_X_MIN
+    #if (digitalPinToInterrupt(X_MIN_PIN) != NOT_AN_INTERRUPT)
+      attachInterrupt(digitalPinToInterrupt(X_MIN_PIN), endstop_ISR, CHANGE);
+    #else
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(X_MIN_PIN) != NULL, "X_MIN_PIN is not interrupt-capable");
+      pciSetup(X_MIN_PIN);
+    #endif
+  #endif
+
+  #if HAS_Y_MAX
+    #if (digitalPinToInterrupt(Y_MAX_PIN) != NOT_AN_INTERRUPT)
+      attachInterrupt(digitalPinToInterrupt(Y_MAX_PIN), endstop_ISR, CHANGE);
+    #else
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Y_MAX_PIN) != NULL, "Y_MAX_PIN is not interrupt-capable");
+      pciSetup(Y_MAX_PIN);
+    #endif
+  #endif
+
+  #if HAS_Y_MIN
+    #if (digitalPinToInterrupt(Y_MIN_PIN) != NOT_AN_INTERRUPT)
+      attachInterrupt(digitalPinToInterrupt(Y_MIN_PIN), endstop_ISR, CHANGE);
+    #else
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Y_MIN_PIN) != NULL, "Y_MIN_PIN is not interrupt-capable");
+      pciSetup(Y_MIN_PIN);
+    #endif
+  #endif
+
+  #if HAS_Z_MAX
+    #if (digitalPinToInterrupt(Z_MAX_PIN) != NOT_AN_INTERRUPT)
+      attachInterrupt(digitalPinToInterrupt(Z_MAX_PIN), endstop_ISR, CHANGE);
+    #else
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Z_MAX_PIN) != NULL, "Z_MAX_PIN is not interrupt-capable");
+      pciSetup(Z_MAX_PIN);
+    #endif
+  #endif
+
+  #if HAS_Z_MIN
+    #if (digitalPinToInterrupt(Z_MIN_PIN) != NOT_AN_INTERRUPT)
+      attachInterrupt(digitalPinToInterrupt(Z_MIN_PIN), endstop_ISR, CHANGE);
+    #else
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Z_MIN_PIN) != NULL, "Z_MIN_PIN is not interrupt-capable");
+      pciSetup(Z_MIN_PIN);
+    #endif
+  #endif
+
+  #if HAS_X2_MAX
+    #if (digitalPinToInterrupt(X2_MAX_PIN) != NOT_AN_INTERRUPT)
+      attachInterrupt(digitalPinToInterrupt(X2_MAX_PIN), endstop_ISR, CHANGE);
+    #else
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(X2_MAX_PIN) != NULL, "X2_MAX_PIN is not interrupt-capable");
+      pciSetup(X2_MAX_PIN);
+    #endif
+  #endif
+
+  #if HAS_X2_MIN
+    #if (digitalPinToInterrupt(X2_MIN_PIN) != NOT_AN_INTERRUPT)
+      attachInterrupt(digitalPinToInterrupt(X2_MIN_PIN), endstop_ISR, CHANGE);
+    #else
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(X2_MIN_PIN) != NULL, "X2_MIN_PIN is not interrupt-capable");
+      pciSetup(X2_MIN_PIN);
+    #endif
+  #endif
+
+  #if HAS_Y2_MAX
+    #if (digitalPinToInterrupt(Y2_MAX_PIN) != NOT_AN_INTERRUPT)
+      attachInterrupt(digitalPinToInterrupt(Y2_MAX_PIN), endstop_ISR, CHANGE);
+    #else
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Y2_MAX_PIN) != NULL, "Y2_MAX_PIN is not interrupt-capable");
+      pciSetup(Y2_MAX_PIN);
+    #endif
+  #endif
+
+  #if HAS_Y2_MIN
+    #if (digitalPinToInterrupt(Y2_MIN_PIN) != NOT_AN_INTERRUPT)
+      attachInterrupt(digitalPinToInterrupt(Y2_MIN_PIN), endstop_ISR, CHANGE);
+    #else
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Y2_MIN_PIN) != NULL, "Y2_MIN_PIN is not interrupt-capable");
+      pciSetup(Y2_MIN_PIN);
+    #endif
+  #endif
+
+  #if HAS_Z2_MAX
+    #if (digitalPinToInterrupt(Z2_MAX_PIN) != NOT_AN_INTERRUPT)
+      attachInterrupt(digitalPinToInterrupt(Z2_MAX_PIN), endstop_ISR, CHANGE);
+    #else
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Z2_MAX_PIN) != NULL, "Z2_MAX_PIN is not interrupt-capable");
+      pciSetup(Z2_MAX_PIN);
+    #endif
+  #endif
+
+  #if HAS_Z2_MIN
+    #if (digitalPinToInterrupt(Z2_MIN_PIN) != NOT_AN_INTERRUPT)
+      attachInterrupt(digitalPinToInterrupt(Z2_MIN_PIN), endstop_ISR, CHANGE);
+    #else
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Z2_MIN_PIN) != NULL, "Z2_MIN_PIN is not interrupt-capable");
+      pciSetup(Z2_MIN_PIN);
+    #endif
+  #endif
+
+  #if HAS_Z_MIN_PROBE_PIN
+    #if (digitalPinToInterrupt(Z_MIN_PROBE_PIN) != NOT_AN_INTERRUPT)
+      attachInterrupt(digitalPinToInterrupt(Z_MIN_PROBE_PIN), endstop_ISR, CHANGE);
+    #else
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Z_MIN_PROBE_PIN) != NULL, "Z_MIN_PROBE_PIN is not interrupt-capable");
+      pciSetup(Z_MIN_PROBE_PIN);
+    #endif
+  #endif
+
+  // If we arrive here without raising an assertion, each pin has either an EXT-interrupt or a PCI.
+}
+
+#endif // _ENDSTOP_INTERRUPTS_H_
--- a/Marlin/src/HAL/AVR/fastio/fastio_1280.h
+++ b/Marlin/src/HAL/AVR/fastio/fastio_1280.h
--- a/Marlin/src/HAL/AVR/fastio/fastio_1281.h
+++ b/Marlin/src/HAL/AVR/fastio/fastio_1281.h
@@ -1,9 +1,9 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
 * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * 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
@@ -19,7 +19,6 @@
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
-#pragma once

 /**
 * Pin mapping for the 1281 and 2561
@@ -28,7 +27,10 @@
 *   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
 */

-#include "../fastio.h"
+#ifndef _FASTIO_1281_H_
+#define _FASTIO_1281_H_
+
+#include "fastio_AVR.h"

 // change for your board
 #define DEBUG_LED   DIO46
@@ -63,13 +65,13 @@
 #define DIO0_RPORT  PINE
 #define DIO0_WPORT  PORTE
 #define DIO0_DDR    DDRE
-#define DIO0_PWM    nullptr
+#define DIO0_PWM    NULL

 #define DIO1_PIN    PINE1
 #define DIO1_RPORT  PINE
 #define DIO1_WPORT  PORTE
 #define DIO1_DDR    DDRE
-#define DIO1_PWM    nullptr
+#define DIO1_PWM    NULL

 #define DIO2_PIN    PINE4
 #define DIO2_RPORT  PINE
@@ -123,339 +125,339 @@
 #define DIO10_RPORT PINB
 #define DIO10_WPORT PORTB
 #define DIO10_DDR   DDRB
-#define DIO10_PWM   nullptr
+#define DIO10_PWM   NULL

 #define DIO11_PIN   PINB2
 #define DIO11_RPORT PINB
 #define DIO11_WPORT PORTB
 #define DIO11_DDR   DDRB
-#define DIO11_PWM   nullptr
+#define DIO11_PWM   NULL

 #define DIO12_PIN   PINB3
 #define DIO12_RPORT PINB
 #define DIO12_WPORT PORTB
 #define DIO12_DDR   DDRB
-#define DIO12_PWM   nullptr
+#define DIO12_PWM   NULL

 #define DIO13_PIN   PINE2
 #define DIO13_RPORT PINE
 #define DIO13_WPORT PORTE
 #define DIO13_DDR   DDRE
-#define DIO13_PWM   nullptr
+#define DIO13_PWM   NULL

 #define DIO14_PIN   PINE6
 #define DIO14_RPORT PINE
 #define DIO14_WPORT PORTE
 #define DIO14_DDR   DDRE
-#define DIO14_PWM   nullptr
+#define DIO14_PWM   NULL

 #define DIO15_PIN   PINE7
 #define DIO15_RPORT PINE
 #define DIO15_WPORT PORTE
 #define DIO15_DDR   DDRE
-#define DIO15_PWM   nullptr
+#define DIO15_PWM   NULL

 #define DIO16_PIN   PINB0
 #define DIO16_RPORT PINB
 #define DIO16_WPORT PORTB
 #define DIO16_DDR   DDRB
-#define DIO16_PWM   nullptr
+#define DIO16_PWM   NULL

 #define DIO17_PIN   PIND0
 #define DIO17_RPORT PIND
 #define DIO17_WPORT PORTD
 #define DIO17_DDR   DDRD
-#define DIO17_PWM   nullptr
+#define DIO17_PWM   NULL

 #define DIO18_PIN   PIND1
 #define DIO18_RPORT PIND
 #define DIO18_WPORT PORTD
 #define DIO18_DDR   DDRD
-#define DIO18_PWM   nullptr
+#define DIO18_PWM   NULL

 #define DIO19_PIN   PIND2
 #define DIO19_RPORT PIND
 #define DIO19_WPORT PORTD
 #define DIO19_DDR   DDRD
-#define DIO19_PWM   nullptr
+#define DIO19_PWM   NULL

 #define DIO20_PIN   PIND3
 #define DIO20_RPORT PIND
 #define DIO20_WPORT PORTD
 #define DIO20_DDR   DDRD
-#define DIO20_PWM   nullptr
+#define DIO20_PWM   NULL

 #define DIO21_PIN   PIND4
 #define DIO21_RPORT PIND
 #define DIO21_WPORT PORTD
 #define DIO21_DDR   DDRD
-#define DIO21_PWM   nullptr
+#define DIO21_PWM   NULL

 #define DIO22_PIN   PIND5
 #define DIO22_RPORT PIND
 #define DIO22_WPORT PORTD
 #define DIO22_DDR   DDRD
-#define DIO22_PWM   nullptr
+#define DIO22_PWM   NULL

 #define DIO23_PIN   PIND6
 #define DIO23_RPORT PIND
 #define DIO23_WPORT PORTD
 #define DIO23_DDR   DDRD
-#define DIO23_PWM   nullptr
+#define DIO23_PWM   NULL

 #define DIO24_PIN   PIND7
 #define DIO24_RPORT PIND
 #define DIO24_WPORT PORTD
 #define DIO24_DDR   DDRD
-#define DIO24_PWM   nullptr
+#define DIO24_PWM   NULL

 #define DIO25_PIN   PING0
 #define DIO25_RPORT PING
 #define DIO25_WPORT PORTG
 #define DIO25_DDR   DDRG
-#define DIO25_PWM   nullptr
+#define DIO25_PWM   NULL

 #define DIO26_PIN   PING1
 #define DIO26_RPORT PING
 #define DIO26_WPORT PORTG
 #define DIO26_DDR   DDRG
-#define DIO26_PWM   nullptr
+#define DIO26_PWM   NULL

 #define DIO27_PIN   PING2
 #define DIO27_RPORT PING
 #define DIO27_WPORT PORTG
 #define DIO27_DDR   DDRG
-#define DIO27_PWM   nullptr
+#define DIO27_PWM   NULL

 #define DIO28_PIN   PING3
 #define DIO28_RPORT PING
 #define DIO28_WPORT PORTG
 #define DIO28_DDR   DDRG
-#define DIO28_PWM   nullptr
+#define DIO28_PWM   NULL

 #define DIO29_PIN   PING4
 #define DIO29_RPORT PING
 #define DIO29_WPORT PORTG
 #define DIO29_DDR   DDRG
-#define DIO29_PWM   nullptr
+#define DIO29_PWM   NULL

 #define DIO30_PIN   PINC0
 #define DIO30_RPORT PINC
 #define DIO30_WPORT PORTC
 #define DIO30_DDR   DDRC
-#define DIO30_PWM   nullptr
+#define DIO30_PWM   NULL

 #define DIO31_PIN   PINC1
 #define DIO31_RPORT PINC
 #define DIO31_WPORT PORTC
 #define DIO31_DDR   DDRC
-#define DIO31_PWM   nullptr
+#define DIO31_PWM   NULL

 #define DIO32_PIN   PINC2
 #define DIO32_RPORT PINC
 #define DIO32_WPORT PORTC
 #define DIO32_DDR   DDRC
-#define DIO32_PWM   nullptr
+#define DIO32_PWM   NULL

 #define DIO33_PIN   PINC3
 #define DIO33_RPORT PINC
 #define DIO33_WPORT PORTC
 #define DIO33_DDR   DDRC
-#define DIO33_PWM   nullptr
+#define DIO33_PWM   NULL

 #define DIO34_PIN   PINC4
 #define DIO34_RPORT PINC
 #define DIO34_WPORT PORTC
 #define DIO34_DDR   DDRC
-#define DIO34_PWM   nullptr
+#define DIO34_PWM   NULL

 #define DIO35_PIN   PINC5
 #define DIO35_RPORT PINC
 #define DIO35_WPORT PORTC
 #define DIO35_DDR   DDRC
-#define DIO35_PWM   nullptr
+#define DIO35_PWM   NULL

 #define DIO36_PIN   PINC6
 #define DIO36_RPORT PINC
 #define DIO36_WPORT PORTC
 #define DIO36_DDR   DDRC
-#define DIO36_PWM   nullptr
+#define DIO36_PWM   NULL

 #define DIO37_PIN   PINC7
 #define DIO37_RPORT PINC
 #define DIO37_WPORT PORTC
 #define DIO37_DDR   DDRC
-#define DIO37_PWM   nullptr
+#define DIO37_PWM   NULL

 #define DIO38_PIN   PINA0
 #define DIO38_RPORT PINA
 #define DIO38_WPORT PORTA
 #define DIO38_DDR   DDRA
-#define DIO38_PWM   nullptr
+#define DIO38_PWM   NULL

 #define DIO39_PIN   PINA1
 #define DIO39_RPORT PINA
 #define DIO39_WPORT PORTA
 #define DIO39_DDR   DDRA
-#define DIO39_PWM   nullptr
+#define DIO39_PWM   NULL

 #define DIO40_PIN   PINA2
 #define DIO40_RPORT PINA
 #define DIO40_WPORT PORTA
 #define DIO40_DDR   DDRA
-#define DIO40_PWM   nullptr
+#define DIO40_PWM   NULL

 #define DIO41_PIN   PINA3
 #define DIO41_RPORT PINA
 #define DIO41_WPORT PORTA
 #define DIO41_DDR   DDRA
-#define DIO41_PWM   nullptr
+#define DIO41_PWM   NULL

 #define DIO42_PIN   PINA4
 #define DIO42_RPORT PINA
 #define DIO42_WPORT PORTA
 #define DIO42_DDR   DDRA
-#define DIO42_PWM   nullptr
+#define DIO42_PWM   NULL

 #define DIO43_PIN   PINA5
 #define DIO43_RPORT PINA
 #define DIO43_WPORT PORTA
 #define DIO43_DDR   DDRA
-#define DIO43_PWM   nullptr
+#define DIO43_PWM   NULL

 #define DIO44_PIN   PINA6
 #define DIO44_RPORT PINA
 #define DIO44_WPORT PORTA
 #define DIO44_DDR   DDRA
-#define DIO44_PWM   nullptr
+#define DIO44_PWM   NULL

 #define DIO45_PIN   PINA7
 #define DIO45_RPORT PINA
 #define DIO45_WPORT PORTA
 #define DIO45_DDR   DDRA
-#define DIO45_PWM   nullptr
+#define DIO45_PWM   NULL

 #define DIO46_PIN   PINF0
 #define DIO46_RPORT PINF
 #define DIO46_WPORT PORTF
 #define DIO46_DDR   DDRF
-#define DIO46_PWM   nullptr
+#define DIO46_PWM   NULL

 #define DIO47_PIN   PINF1
 #define DIO47_RPORT PINF
 #define DIO47_WPORT PORTF
 #define DIO47_DDR   DDRF
-#define DIO47_PWM   nullptr
+#define DIO47_PWM   NULL

 #define DIO48_PIN   PINF2
 #define DIO48_RPORT PINF
 #define DIO48_WPORT PORTF
 #define DIO48_DDR   DDRF
-#define DIO48_PWM   nullptr
+#define DIO48_PWM   NULL

 #define DIO49_PIN   PINF3
 #define DIO49_RPORT PINF
 #define DIO49_WPORT PORTF
 #define DIO49_DDR   DDRF
-#define DIO49_PWM   nullptr
+#define DIO49_PWM   NULL

 #define DIO50_PIN   PINF4
 #define DIO50_RPORT PINF
 #define DIO50_WPORT PORTF
 #define DIO50_DDR   DDRF
-#define DIO50_PWM   nullptr
+#define DIO50_PWM   NULL

 #define DIO51_PIN   PINF5
 #define DIO51_RPORT PINF
 #define DIO51_WPORT PORTF
 #define DIO51_DDR   DDRF
-#define DIO51_PWM   nullptr
+#define DIO51_PWM   NULL

 #define DIO52_PIN   PINF6
 #define DIO52_RPORT PINF
 #define DIO52_WPORT PORTF
 #define DIO52_DDR   DDRF
-#define DIO52_PWM   nullptr
+#define DIO52_PWM   NULL

 #define DIO53_PIN   PINF7
 #define DIO53_RPORT PINF
 #define DIO53_WPORT PORTF
 #define DIO53_DDR   DDRF
-#define DIO53_PWM   nullptr
+#define DIO53_PWM   NULL

 #undef PA0
 #define PA0_PIN     PINA0
 #define PA0_RPORT   PINA
 #define PA0_WPORT   PORTA
 #define PA0_DDR     DDRA
-#define PA0_PWM     nullptr
+#define PA0_PWM     NULL
 #undef PA1
 #define PA1_PIN     PINA1
 #define PA1_RPORT   PINA
 #define PA1_WPORT   PORTA
 #define PA1_DDR     DDRA
-#define PA1_PWM     nullptr
+#define PA1_PWM     NULL
 #undef PA2
 #define PA2_PIN     PINA2
 #define PA2_RPORT   PINA
 #define PA2_WPORT   PORTA
 #define PA2_DDR     DDRA
-#define PA2_PWM     nullptr
+#define PA2_PWM     NULL
 #undef PA3
 #define PA3_PIN     PINA3
 #define PA3_RPORT   PINA
 #define PA3_WPORT   PORTA
 #define PA3_DDR     DDRA
-#define PA3_PWM     nullptr
+#define PA3_PWM     NULL
 #undef PA4
 #define PA4_PIN     PINA4
 #define PA4_RPORT   PINA
 #define PA4_WPORT   PORTA
 #define PA4_DDR     DDRA
-#define PA4_PWM     nullptr
+#define PA4_PWM     NULL
 #undef PA5
 #define PA5_PIN     PINA5
 #define PA5_RPORT   PINA
 #define PA5_WPORT   PORTA
 #define PA5_DDR     DDRA
-#define PA5_PWM     nullptr
+#define PA5_PWM     NULL
 #undef PA6
 #define PA6_PIN     PINA6
 #define PA6_RPORT   PINA
 #define PA6_WPORT   PORTA
 #define PA6_DDR     DDRA
-#define PA6_PWM     nullptr
+#define PA6_PWM     NULL
 #undef PA7
 #define PA7_PIN     PINA7
 #define PA7_RPORT   PINA
 #define PA7_WPORT   PORTA
 #define PA7_DDR     DDRA
-#define PA7_PWM     nullptr
+#define PA7_PWM     NULL

 #undef PB0
 #define PB0_PIN     PINB0
 #define PB0_RPORT   PINB
 #define PB0_WPORT   PORTB
 #define PB0_DDR     DDRB
-#define PB0_PWM     nullptr
+#define PB0_PWM     NULL
 #undef PB1
 #define PB1_PIN     PINB1
 #define PB1_RPORT   PINB
 #define PB1_WPORT   PORTB
 #define PB1_DDR     DDRB
-#define PB1_PWM     nullptr
+#define PB1_PWM     NULL
 #undef PB2
 #define PB2_PIN     PINB2
 #define PB2_RPORT   PINB
 #define PB2_WPORT   PORTB
 #define PB2_DDR     DDRB
-#define PB2_PWM     nullptr
+#define PB2_PWM     NULL
 #undef PB3
 #define PB3_PIN     PINB3
 #define PB3_RPORT   PINB
 #define PB3_WPORT   PORTB
 #define PB3_DDR     DDRB
-#define PB3_PWM     nullptr
+#define PB3_PWM     NULL
 #undef PB4
 #define PB4_PIN     PINB4
 #define PB4_RPORT   PINB
@@ -467,13 +469,13 @@
 #define PB5_RPORT   PINB
 #define PB5_WPORT   PORTB
 #define PB5_DDR     DDRB
-#define PB5_PWM     nullptr
+#define PB5_PWM     NULL
 #undef PB6
 #define PB6_PIN     PINB6
 #define PB6_RPORT   PINB
 #define PB6_WPORT   PORTB
 #define PB6_DDR     DDRB
-#define PB6_PWM     nullptr
+#define PB6_PWM     NULL
 #undef PB7
 #define PB7_PIN     PINB7
 #define PB7_RPORT   PINB
@@ -486,117 +488,117 @@
 #define PC0_RPORT   PINC
 #define PC0_WPORT   PORTC
 #define PC0_DDR     DDRC
-#define PC0_PWM     nullptr
+#define PC0_PWM     NULL
 #undef PC1
 #define PC1_PIN     PINC1
 #define PC1_RPORT   PINC
 #define PC1_WPORT   PORTC
 #define PC1_DDR     DDRC
-#define PC1_PWM     nullptr
+#define PC1_PWM     NULL
 #undef PC2
 #define PC2_PIN     PINC2
 #define PC2_RPORT   PINC
 #define PC2_WPORT   PORTC
 #define PC2_DDR     DDRC
-#define PC2_PWM     nullptr
+#define PC2_PWM     NULL
 #undef PC3
 #define PC3_PIN     PINC3
 #define PC3_RPORT   PINC
 #define PC3_WPORT   PORTC
 #define PC3_DDR     DDRC
-#define PC3_PWM     nullptr
+#define PC3_PWM     NULL
 #undef PC4
 #define PC4_PIN     PINC4
 #define PC4_RPORT   PINC
 #define PC4_WPORT   PORTC
 #define PC4_DDR     DDRC
-#define PC4_PWM     nullptr
+#define PC4_PWM     NULL
 #undef PC5
 #define PC5_PIN     PINC5
 #define PC5_RPORT   PINC
 #define PC5_WPORT   PORTC
 #define PC5_DDR     DDRC
-#define PC5_PWM     nullptr
+#define PC5_PWM     NULL
 #undef PC6
 #define PC6_PIN     PINC6
 #define PC6_RPORT   PINC
 #define PC6_WPORT   PORTC
 #define PC6_DDR     DDRC
-#define PC6_PWM     nullptr
+#define PC6_PWM     NULL
 #undef PC7
 #define PC7_PIN     PINC7
 #define PC7_RPORT   PINC
 #define PC7_WPORT   PORTC
 #define PC7_DDR     DDRC
-#define PC7_PWM     nullptr
+#define PC7_PWM     NULL

 #undef PD0
 #define PD0_PIN     PIND0
 #define PD0_RPORT   PIND
 #define PD0_WPORT   PORTD
 #define PD0_DDR     DDRD
-#define PD0_PWM     nullptr
+#define PD0_PWM     NULL
 #undef PD1
 #define PD1_PIN     PIND1
 #define PD1_RPORT   PIND
 #define PD1_WPORT   PORTD
 #define PD1_DDR     DDRD
-#define PD1_PWM     nullptr
+#define PD1_PWM     NULL
 #undef PD2
 #define PD2_PIN     PIND2
 #define PD2_RPORT   PIND
 #define PD2_WPORT   PORTD
 #define PD2_DDR     DDRD
-#define PD2_PWM     nullptr
+#define PD2_PWM     NULL
 #undef PD3
 #define PD3_PIN     PIND3
 #define PD3_RPORT   PIND
 #define PD3_WPORT   PORTD
 #define PD3_DDR     DDRD
-#define PD3_PWM     nullptr
+#define PD3_PWM     NULL
 #undef PD4
 #define PD4_PIN     PIND4
 #define PD4_RPORT   PIND
 #define PD4_WPORT   PORTD
 #define PD4_DDR     DDRD
-#define PD4_PWM     nullptr
+#define PD4_PWM     NULL
 #undef PD5
 #define PD5_PIN     PIND5
 #define PD5_RPORT   PIND
 #define PD5_WPORT   PORTD
 #define PD5_DDR     DDRD
-#define PD5_PWM     nullptr
+#define PD5_PWM     NULL
 #undef PD6
 #define PD6_PIN     PIND6
 #define PD6_RPORT   PIND
 #define PD6_WPORT   PORTD
 #define PD6_DDR     DDRD
-#define PD6_PWM     nullptr
+#define PD6_PWM     NULL
 #undef PD7
 #define PD7_PIN     PIND7
 #define PD7_RPORT   PIND
 #define PD7_WPORT   PORTD
 #define PD7_DDR     DDRD
-#define PD7_PWM     nullptr
+#define PD7_PWM     NULL

 #undef PE0
 #define PE0_PIN     PINE0
 #define PE0_RPORT   PINE
 #define PE0_WPORT   PORTE
 #define PE0_DDR     DDRE
-#define PE0_PWM     nullptr
+#define PE0_PWM     NULL
 #undef PE1
 #define PE1_PIN     PINE1
 #define PE1_RPORT   PINE
 #define PE1_WPORT   PORTE
 #define PE1_DDR     DDRE
-#define PE1_PWM     nullptr
+#define PE1_PWM     NULL
 #undef PE2
 #define PE2_PIN     PINE2
 #define PE2_RPORT   PINE
 #define PE2_WPORT   PORTE
 #define PE2_DDR     DDRE
-#define PE2_PWM     nullptr
+#define PE2_PWM     NULL
 #undef PE3
 #define PE3_PIN     PINE3
 #define PE3_RPORT   PINE
@@ -620,96 +622,98 @@
 #define PE6_RPORT   PINE
 #define PE6_WPORT   PORTE
 #define PE6_DDR     DDRE
-#define PE6_PWM     nullptr
+#define PE6_PWM     NULL
 #undef PE7
 #define PE7_PIN     PINE7
 #define PE7_RPORT   PINE
 #define PE7_WPORT   PORTE
 #define PE7_DDR     DDRE
-#define PE7_PWM     nullptr
+#define PE7_PWM     NULL

 #undef PF0
 #define PF0_PIN     PINF0
 #define PF0_RPORT   PINF
 #define PF0_WPORT   PORTF
 #define PF0_DDR     DDRF
-#define PF0_PWM     nullptr
+#define PF0_PWM     NULL
 #undef PF1
 #define PF1_PIN     PINF1
 #define PF1_RPORT   PINF
 #define PF1_WPORT   PORTF
 #define PF1_DDR     DDRF
-#define PF1_PWM     nullptr
+#define PF1_PWM     NULL
 #undef PF2
 #define PF2_PIN     PINF2
 #define PF2_RPORT   PINF
 #define PF2_WPORT   PORTF
 #define PF2_DDR     DDRF
-#define PF2_PWM     nullptr
+#define PF2_PWM     NULL
 #undef PF3
 #define PF3_PIN     PINF3
 #define PF3_RPORT   PINF
 #define PF3_WPORT   PORTF
 #define PF3_DDR     DDRF
-#define PF3_PWM     nullptr
+#define PF3_PWM     NULL
 #undef PF4
 #define PF4_PIN     PINF4
 #define PF4_RPORT   PINF
 #define PF4_WPORT   PORTF
 #define PF4_DDR     DDRF
-#define PF4_PWM     nullptr
+#define PF4_PWM     NULL
 #undef PF5
 #define PF5_PIN     PINF5
 #define PF5_RPORT   PINF
 #define PF5_WPORT   PORTF
 #define PF5_DDR     DDRF
-#define PF5_PWM     nullptr
+#define PF5_PWM     NULL
 #undef PF6
 #define PF6_PIN     PINF6
 #define PF6_RPORT   PINF
 #define PF6_WPORT   PORTF
 #define PF6_DDR     DDRF
-#define PF6_PWM     nullptr
+#define PF6_PWM     NULL
 #undef PF7
 #define PF7_PIN     PINF7
 #define PF7_RPORT   PINF
 #define PF7_WPORT   PORTF
 #define PF7_DDR     DDRF
-#define PF7_PWM     nullptr
+#define PF7_PWM     NULL

 #undef PG0
 #define PG0_PIN     PING0
 #define PG0_RPORT   PING
 #define PG0_WPORT   PORTG
 #define PG0_DDR     DDRG
-#define PG0_PWM     nullptr
+#define PG0_PWM     NULL
 #undef PG1
 #define PG1_PIN     PING1
 #define PG1_RPORT   PING
 #define PG1_WPORT   PORTG
 #define PG1_DDR     DDRG
-#define PG1_PWM     nullptr
+#define PG1_PWM     NULL
 #undef PG2
 #define PG2_PIN     PING2
 #define PG2_RPORT   PING
 #define PG2_WPORT   PORTG
 #define PG2_DDR     DDRG
-#define PG2_PWM     nullptr
+#define PG2_PWM     NULL
 #undef PG3
 #define PG3_PIN     PING3
 #define PG3_RPORT   PING
 #define PG3_WPORT   PORTG
 #define PG3_DDR     DDRG
-#define PG3_PWM     nullptr
+#define PG3_PWM     NULL
 #undef PG4
 #define PG4_PIN     PING4
 #define PG4_RPORT   PING
 #define PG4_WPORT   PORTG
 #define PG4_DDR     DDRG
-#define PG4_PWM     nullptr
+#define PG4_PWM     NULL
 #undef PG5
 #define PG5_PIN     PING5
 #define PG5_RPORT   PING
 #define PG5_WPORT   PORTG
 #define PG5_DDR     DDRG
 #define PG5_PWM     &OCR0B
+
+#endif // _FASTIO_1281_H_
--- a/Marlin/src/HAL/AVR/fastio/fastio_168.h
+++ b/Marlin/src/HAL/AVR/fastio/fastio_168.h
@@ -1,9 +1,9 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
 * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * 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
@@ -19,7 +19,6 @@
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
-#pragma once

 /**
 * Pin mapping for the 168, 328, and 328P
@@ -28,7 +27,10 @@
 *   Port:        B0 B1 B2 B3 B4 B5 C0 C1 C2 C3 C4 C5 C6 C7 D0 D1 D2 D3 D4 D5 D6 D7
 */

-#include "../fastio.h"
+#ifndef _FASTIO_168_H_
+#define _FASTIO_168_H_
+
+#include "fastio_AVR.h"

 #define DEBUG_LED   AIO5

@@ -60,19 +62,19 @@
 #define DIO0_RPORT  PIND
 #define DIO0_WPORT  PORTD
 #define DIO0_DDR    DDRD
-#define DIO0_PWM    nullptr
+#define DIO0_PWM    NULL

 #define DIO1_PIN    PIND1
 #define DIO1_RPORT  PIND
 #define DIO1_WPORT  PORTD
 #define DIO1_DDR    DDRD
-#define DIO1_PWM    nullptr
+#define DIO1_PWM    NULL

 #define DIO2_PIN    PIND2
 #define DIO2_RPORT  PIND
 #define DIO2_WPORT  PORTD
 #define DIO2_DDR    DDRD
-#define DIO2_PWM    nullptr
+#define DIO2_PWM    NULL

 #define DIO3_PIN    PIND3
 #define DIO3_RPORT  PIND
@@ -84,7 +86,7 @@
 #define DIO4_RPORT  PIND
 #define DIO4_WPORT  PORTD
 #define DIO4_DDR    DDRD
-#define DIO4_PWM    nullptr
+#define DIO4_PWM    NULL

 #define DIO5_PIN    PIND5
 #define DIO5_RPORT  PIND
@@ -102,25 +104,25 @@
 #define DIO7_RPORT  PIND
 #define DIO7_WPORT  PORTD
 #define DIO7_DDR    DDRD
-#define DIO7_PWM    nullptr
+#define DIO7_PWM    NULL

 #define DIO8_PIN    PINB0
 #define DIO8_RPORT  PINB
 #define DIO8_WPORT  PORTB
 #define DIO8_DDR    DDRB
-#define DIO8_PWM    nullptr
+#define DIO8_PWM    NULL

 #define DIO9_PIN    PINB1
 #define DIO9_RPORT  PINB
 #define DIO9_WPORT  PORTB
 #define DIO9_DDR    DDRB
-#define DIO9_PWM    nullptr
+#define DIO9_PWM    NULL

 #define DIO10_PIN   PINB2
 #define DIO10_RPORT PINB
 #define DIO10_WPORT PORTB
 #define DIO10_DDR   DDRB
-#define DIO10_PWM   nullptr
+#define DIO10_PWM   NULL

 #define DIO11_PIN   PINB3
 #define DIO11_RPORT PINB
@@ -132,82 +134,82 @@
 #define DIO12_RPORT PINB
 #define DIO12_WPORT PORTB
 #define DIO12_DDR   DDRB
-#define DIO12_PWM   nullptr
+#define DIO12_PWM   NULL

 #define DIO13_PIN   PINB5
 #define DIO13_RPORT PINB
 #define DIO13_WPORT PORTB
 #define DIO13_DDR   DDRB
-#define DIO13_PWM   nullptr
+#define DIO13_PWM   NULL

 #define DIO14_PIN   PINC0
 #define DIO14_RPORT PINC
 #define DIO14_WPORT PORTC
 #define DIO14_DDR   DDRC
-#define DIO14_PWM   nullptr
+#define DIO14_PWM   NULL

 #define DIO15_PIN   PINC1
 #define DIO15_RPORT PINC
 #define DIO15_WPORT PORTC
 #define DIO15_DDR   DDRC
-#define DIO15_PWM   nullptr
+#define DIO15_PWM   NULL

 #define DIO16_PIN   PINC2
 #define DIO16_RPORT PINC
 #define DIO16_WPORT PORTC
 #define DIO16_DDR   DDRC
-#define DIO16_PWM   nullptr
+#define DIO16_PWM   NULL

 #define DIO17_PIN   PINC3
 #define DIO17_RPORT PINC
 #define DIO17_WPORT PORTC
 #define DIO17_DDR   DDRC
-#define DIO17_PWM   nullptr
+#define DIO17_PWM   NULL

 #define DIO18_PIN   PINC4
 #define DIO18_RPORT PINC
 #define DIO18_WPORT PORTC
 #define DIO18_DDR   DDRC
-#define DIO18_PWM   nullptr
+#define DIO18_PWM   NULL

 #define DIO19_PIN   PINC5
 #define DIO19_RPORT PINC
 #define DIO19_WPORT PORTC
 #define DIO19_DDR   DDRC
-#define DIO19_PWM   nullptr
+#define DIO19_PWM   NULL

 #define DIO20_PIN   PINC6
 #define DIO20_RPORT PINC
 #define DIO20_WPORT PORTC
 #define DIO20_DDR   DDRC
-#define DIO20_PWM   nullptr
+#define DIO20_PWM   NULL

 #define DIO21_PIN   PINC7
 #define DIO21_RPORT PINC
 #define DIO21_WPORT PORTC
 #define DIO21_DDR   DDRC
-#define DIO21_PWM   nullptr
+#define DIO21_PWM   NULL

 #undef PB0
 #define PB0_PIN     PINB0
 #define PB0_RPORT   PINB
 #define PB0_WPORT   PORTB
 #define PB0_DDR     DDRB
-#define PB0_PWM     nullptr
+#define PB0_PWM     NULL

 #undef PB1
 #define PB1_PIN     PINB1
 #define PB1_RPORT   PINB
 #define PB1_WPORT   PORTB
 #define PB1_DDR     DDRB
-#define PB1_PWM     nullptr
+#define PB1_PWM     NULL

 #undef PB2
 #define PB2_PIN     PINB2
 #define PB2_RPORT   PINB
 #define PB2_WPORT   PORTB
 #define PB2_DDR     DDRB
-#define PB2_PWM     nullptr
+#define PB2_PWM     NULL

 #undef PB3
 #define PB3_PIN     PINB3
@@ -221,105 +223,105 @@
 #define PB4_RPORT   PINB
 #define PB4_WPORT   PORTB
 #define PB4_DDR     DDRB
-#define PB4_PWM     nullptr
+#define PB4_PWM     NULL

 #undef PB5
 #define PB5_PIN     PINB5
 #define PB5_RPORT   PINB
 #define PB5_WPORT   PORTB
 #define PB5_DDR     DDRB
-#define PB5_PWM     nullptr
+#define PB5_PWM     NULL

 #undef PB6
 #define PB6_PIN     PINB6
 #define PB6_RPORT   PINB
 #define PB6_WPORT   PORTB
 #define PB6_DDR     DDRB
-#define PB6_PWM     nullptr
+#define PB6_PWM     NULL

 #undef PB7
 #define PB7_PIN     PINB7
 #define PB7_RPORT   PINB
 #define PB7_WPORT   PORTB
 #define PB7_DDR     DDRB
-#define PB7_PWM     nullptr
+#define PB7_PWM     NULL

 #undef PC0
 #define PC0_PIN     PINC0
 #define PC0_RPORT   PINC
 #define PC0_WPORT   PORTC
 #define PC0_DDR     DDRC
-#define PC0_PWM     nullptr
+#define PC0_PWM     NULL

 #undef PC1
 #define PC1_PIN     PINC1
 #define PC1_RPORT   PINC
 #define PC1_WPORT   PORTC
 #define PC1_DDR     DDRC
-#define PC1_PWM     nullptr
+#define PC1_PWM     NULL

 #undef PC2
 #define PC2_PIN     PINC2
 #define PC2_RPORT   PINC
 #define PC2_WPORT   PORTC
 #define PC2_DDR     DDRC
-#define PC2_PWM     nullptr
+#define PC2_PWM     NULL

 #undef PC3
 #define PC3_PIN     PINC3
 #define PC3_RPORT   PINC
 #define PC3_WPORT   PORTC
 #define PC3_DDR     DDRC
-#define PC3_PWM     nullptr
+#define PC3_PWM     NULL

 #undef PC4
 #define PC4_PIN     PINC4
 #define PC4_RPORT   PINC
 #define PC4_WPORT   PORTC
 #define PC4_DDR     DDRC
-#define PC4_PWM     nullptr
+#define PC4_PWM     NULL

 #undef PC5
 #define PC5_PIN     PINC5
 #define PC5_RPORT   PINC
 #define PC5_WPORT   PORTC
 #define PC5_DDR     DDRC
-#define PC5_PWM     nullptr
+#define PC5_PWM     NULL

 #undef PC6
 #define PC6_PIN     PINC6
 #define PC6_RPORT   PINC
 #define PC6_WPORT   PORTC
 #define PC6_DDR     DDRC
-#define PC6_PWM     nullptr
+#define PC6_PWM     NULL

 #undef PC7
 #define PC7_PIN     PINC7
 #define PC7_RPORT   PINC
 #define PC7_WPORT   PORTC
 #define PC7_DDR     DDRC
-#define PC7_PWM     nullptr
+#define PC7_PWM     NULL

 #undef PD0
 #define PD0_PIN     PIND0
 #define PD0_RPORT   PIND
 #define PD0_WPORT   PORTD
 #define PD0_DDR     DDRD
-#define PD0_PWM     nullptr
+#define PD0_PWM     NULL

 #undef PD1
 #define PD1_PIN     PIND1
 #define PD1_RPORT   PIND
 #define PD1_WPORT   PORTD
 #define PD1_DDR     DDRD
-#define PD1_PWM     nullptr
+#define PD1_PWM     NULL

 #undef PD2
 #define PD2_PIN     PIND2
 #define PD2_RPORT   PIND
 #define PD2_WPORT   PORTD
 #define PD2_DDR     DDRD
-#define PD2_PWM     nullptr
+#define PD2_PWM     NULL

 #undef PD3
 #define PD3_PIN     PIND3
@@ -333,7 +335,7 @@
 #define PD4_RPORT   PIND
 #define PD4_WPORT   PORTD
 #define PD4_DDR     DDRD
-#define PD4_PWM     nullptr
+#define PD4_PWM     NULL

 #undef PD5
 #define PD5_PIN     PIND5
@@ -354,4 +356,6 @@
 #define PD7_RPORT   PIND
 #define PD7_WPORT   PORTD
 #define PD7_DDR     DDRD
-#define PD7_PWM     nullptr
+#define PD7_PWM     NULL
+
+#endif // _FASTIO_168_H_
--- a/Marlin/src/HAL/AVR/fastio/fastio_644.h
+++ b/Marlin/src/HAL/AVR/fastio/fastio_644.h
@@ -1,9 +1,9 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
 * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * 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
@@ -19,7 +19,6 @@
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
-#pragma once

 /**
 * Pin mapping for the 644, 644p, 644pa, and 1284p
@@ -54,7 +53,10 @@
 *                        +--------+
 */

-#include "../fastio.h"
+#ifndef _FASTIO_644_H_
+#define _FASTIO_644_H_
+
+#include "fastio_AVR.h"

 #define DEBUG_LED   DIO0

@@ -91,462 +93,464 @@
 #define DIO0_RPORT  PINB
 #define DIO0_WPORT  PORTB
 #define DIO0_DDR    DDRB
-#define DIO0_PWM    nullptr
+#define DIO0_PWM    NULL

 #define DIO1_PIN    PINB1
 #define DIO1_RPORT  PINB
 #define DIO1_WPORT  PORTB
 #define DIO1_DDR    DDRB
-#define DIO1_PWM    nullptr
+#define DIO1_PWM    NULL

 #define DIO2_PIN    PINB2
 #define DIO2_RPORT  PINB
 #define DIO2_WPORT  PORTB
 #define DIO2_DDR    DDRB
-#define DIO2_PWM    nullptr
+#define DIO2_PWM    NULL

 #define DIO3_PIN    PINB3
 #define DIO3_RPORT  PINB
 #define DIO3_WPORT  PORTB
 #define DIO3_DDR    DDRB
-#define DIO3_PWM    &OCR0A
+#define DIO3_PWM    OCR0A

 #define DIO4_PIN    PINB4
 #define DIO4_RPORT  PINB
 #define DIO4_WPORT  PORTB
 #define DIO4_DDR    DDRB
-#define DIO4_PWM    &OCR0B
+#define DIO4_PWM    OCR0B

 #define DIO5_PIN    PINB5
 #define DIO5_RPORT  PINB
 #define DIO5_WPORT  PORTB
 #define DIO5_DDR    DDRB
-#define DIO5_PWM    nullptr
+#define DIO5_PWM    NULL

 #define DIO6_PIN    PINB6
 #define DIO6_RPORT  PINB
 #define DIO6_WPORT  PORTB
 #define DIO6_DDR    DDRB
-#define DIO6_PWM    nullptr
+#define DIO6_PWM    NULL

 #define DIO7_PIN    PINB7
 #define DIO7_RPORT  PINB
 #define DIO7_WPORT  PORTB
 #define DIO7_DDR    DDRB
-#define DIO7_PWM    nullptr
+#define DIO7_PWM    NULL

 #define DIO8_PIN    PIND0
 #define DIO8_RPORT  PIND
 #define DIO8_WPORT  PORTD
 #define DIO8_DDR    DDRD
-#define DIO8_PWM    nullptr
+#define DIO8_PWM    NULL

 #define DIO9_PIN    PIND1
 #define DIO9_RPORT  PIND
 #define DIO9_WPORT  PORTD
 #define DIO9_DDR    DDRD
-#define DIO9_PWM    nullptr
+#define DIO9_PWM    NULL

 #define DIO10_PIN   PIND2
 #define DIO10_RPORT PIND
 #define DIO10_WPORT PORTD
 #define DIO10_DDR   DDRD
-#define DIO10_PWM   nullptr
+#define DIO10_PWM   NULL

 #define DIO11_PIN   PIND3
 #define DIO11_RPORT PIND
 #define DIO11_WPORT PORTD
 #define DIO11_DDR   DDRD
-#define DIO11_PWM   nullptr
+#define DIO11_PWM   NULL

 #define DIO12_PIN   PIND4
 #define DIO12_RPORT PIND
 #define DIO12_WPORT PORTD
 #define DIO12_DDR   DDRD
-#define DIO12_PWM   &OCR1B
+#define DIO12_PWM   OCR1B

 #define DIO13_PIN   PIND5
 #define DIO13_RPORT PIND
 #define DIO13_WPORT PORTD
 #define DIO13_DDR   DDRD
-#define DIO13_PWM   &OCR1A
+#define DIO13_PWM   OCR1A

 #define DIO14_PIN   PIND6
 #define DIO14_RPORT PIND
 #define DIO14_WPORT PORTD
 #define DIO14_DDR   DDRD
-#define DIO14_PWM   &OCR2B
+#define DIO14_PWM   OCR2B

 #define DIO15_PIN   PIND7
 #define DIO15_RPORT PIND
 #define DIO15_WPORT PORTD
 #define DIO15_DDR   DDRD
-#define DIO15_PWM   &OCR2A
+#define DIO15_PWM   OCR2A

 #define DIO16_PIN   PINC0
 #define DIO16_RPORT PINC
 #define DIO16_WPORT PORTC
 #define DIO16_DDR   DDRC
-#define DIO16_PWM   nullptr
+#define DIO16_PWM   NULL

 #define DIO17_PIN   PINC1
 #define DIO17_RPORT PINC
 #define DIO17_WPORT PORTC
 #define DIO17_DDR   DDRC
-#define DIO17_PWM   nullptr
+#define DIO17_PWM   NULL

 #define DIO18_PIN   PINC2
 #define DIO18_RPORT PINC
 #define DIO18_WPORT PORTC
 #define DIO18_DDR   DDRC
-#define DIO18_PWM   nullptr
+#define DIO18_PWM   NULL

 #define DIO19_PIN   PINC3
 #define DIO19_RPORT PINC
 #define DIO19_WPORT PORTC
 #define DIO19_DDR   DDRC
-#define DIO19_PWM   nullptr
+#define DIO19_PWM   NULL

 #define DIO20_PIN   PINC4
 #define DIO20_RPORT PINC
 #define DIO20_WPORT PORTC
 #define DIO20_DDR   DDRC
-#define DIO20_PWM   nullptr
+#define DIO20_PWM   NULL

 #define DIO21_PIN   PINC5
 #define DIO21_RPORT PINC
 #define DIO21_WPORT PORTC
 #define DIO21_DDR   DDRC
-#define DIO21_PWM   nullptr
+#define DIO21_PWM   NULL

 #define DIO22_PIN   PINC6
 #define DIO22_RPORT PINC
 #define DIO22_WPORT PORTC
 #define DIO22_DDR   DDRC
-#define DIO22_PWM   nullptr
+#define DIO22_PWM   NULL

 #define DIO23_PIN   PINC7
 #define DIO23_RPORT PINC
 #define DIO23_WPORT PORTC
 #define DIO23_DDR   DDRC
-#define DIO23_PWM   nullptr
+#define DIO23_PWM   NULL

 #define DIO24_PIN   PINA7
 #define DIO24_RPORT PINA
 #define DIO24_WPORT PORTA
 #define DIO24_DDR   DDRA
-#define DIO24_PWM   nullptr
+#define DIO24_PWM   NULL

 #define DIO25_PIN   PINA6
 #define DIO25_RPORT PINA
 #define DIO25_WPORT PORTA
 #define DIO25_DDR   DDRA
-#define DIO25_PWM   nullptr
+#define DIO25_PWM   NULL

 #define DIO26_PIN   PINA5
 #define DIO26_RPORT PINA
 #define DIO26_WPORT PORTA
 #define DIO26_DDR   DDRA
-#define DIO26_PWM   nullptr
+#define DIO26_PWM   NULL

 #define DIO27_PIN   PINA4
 #define DIO27_RPORT PINA
 #define DIO27_WPORT PORTA
 #define DIO27_DDR   DDRA
-#define DIO27_PWM   nullptr
+#define DIO27_PWM   NULL

 #define DIO28_PIN   PINA3
 #define DIO28_RPORT PINA
 #define DIO28_WPORT PORTA
 #define DIO28_DDR   DDRA
-#define DIO28_PWM   nullptr
+#define DIO28_PWM   NULL

 #define DIO29_PIN   PINA2
 #define DIO29_RPORT PINA
 #define DIO29_WPORT PORTA
 #define DIO29_DDR   DDRA
-#define DIO29_PWM   nullptr
+#define DIO29_PWM   NULL

 #define DIO30_PIN   PINA1
 #define DIO30_RPORT PINA
 #define DIO30_WPORT PORTA
 #define DIO30_DDR   DDRA
-#define DIO30_PWM   nullptr
+#define DIO30_PWM   NULL

 #define DIO31_PIN   PINA0
 #define DIO31_RPORT PINA
 #define DIO31_WPORT PORTA
 #define DIO31_DDR   DDRA
-#define DIO31_PWM   nullptr
+#define DIO31_PWM   NULL

 #define AIO0_PIN    PINA0
 #define AIO0_RPORT  PINA
 #define AIO0_WPORT  PORTA
 #define AIO0_DDR    DDRA
-#define AIO0_PWM    nullptr
+#define AIO0_PWM    NULL

 #define AIO1_PIN    PINA1
 #define AIO1_RPORT  PINA
 #define AIO1_WPORT  PORTA
 #define AIO1_DDR    DDRA
-#define AIO1_PWM    nullptr
+#define AIO1_PWM    NULL

 #define AIO2_PIN    PINA2
 #define AIO2_RPORT  PINA
 #define AIO2_WPORT  PORTA
 #define AIO2_DDR    DDRA
-#define AIO2_PWM    nullptr
+#define AIO2_PWM    NULL

 #define AIO3_PIN    PINA3
 #define AIO3_RPORT  PINA
 #define AIO3_WPORT  PORTA
 #define AIO3_DDR    DDRA
-#define AIO3_PWM    nullptr
+#define AIO3_PWM    NULL

 #define AIO4_PIN    PINA4
 #define AIO4_RPORT  PINA
 #define AIO4_WPORT  PORTA
 #define AIO4_DDR    DDRA
-#define AIO4_PWM    nullptr
+#define AIO4_PWM    NULL

 #define AIO5_PIN    PINA5
 #define AIO5_RPORT  PINA
 #define AIO5_WPORT  PORTA
 #define AIO5_DDR    DDRA
-#define AIO5_PWM    nullptr
+#define AIO5_PWM    NULL

 #define AIO6_PIN    PINA6
 #define AIO6_RPORT  PINA
 #define AIO6_WPORT  PORTA
 #define AIO6_DDR    DDRA
-#define AIO6_PWM    nullptr
+#define AIO6_PWM    NULL

 #define AIO7_PIN    PINA7
 #define AIO7_RPORT  PINA
 #define AIO7_WPORT  PORTA
 #define AIO7_DDR    DDRA
-#define AIO7_PWM    nullptr
+#define AIO7_PWM    NULL

 #undef PA0
 #define PA0_PIN     PINA0
 #define PA0_RPORT   PINA
 #define PA0_WPORT   PORTA
 #define PA0_DDR     DDRA
-#define PA0_PWM     nullptr
+#define PA0_PWM     NULL

 #undef PA1
 #define PA1_PIN     PINA1
 #define PA1_RPORT   PINA
 #define PA1_WPORT   PORTA
 #define PA1_DDR     DDRA
-#define PA1_PWM     nullptr
+#define PA1_PWM     NULL

 #undef PA2
 #define PA2_PIN     PINA2
 #define PA2_RPORT   PINA
 #define PA2_WPORT   PORTA
 #define PA2_DDR     DDRA
-#define PA2_PWM     nullptr
+#define PA2_PWM     NULL

 #undef PA3
 #define PA3_PIN     PINA3
 #define PA3_RPORT   PINA
 #define PA3_WPORT   PORTA
 #define PA3_DDR     DDRA
-#define PA3_PWM     nullptr
+#define PA3_PWM     NULL

 #undef PA4
 #define PA4_PIN     PINA4
 #define PA4_RPORT   PINA
 #define PA4_WPORT   PORTA
 #define PA4_DDR     DDRA
-#define PA4_PWM     nullptr
+#define PA4_PWM     NULL

 #undef PA5
 #define PA5_PIN     PINA5
 #define PA5_RPORT   PINA
 #define PA5_WPORT   PORTA
 #define PA5_DDR     DDRA
-#define PA5_PWM     nullptr
+#define PA5_PWM     NULL

 #undef PA6
 #define PA6_PIN     PINA6
 #define PA6_RPORT   PINA
 #define PA6_WPORT   PORTA
 #define PA6_DDR     DDRA
-#define PA6_PWM     nullptr
+#define PA6_PWM     NULL

 #undef PA7
 #define PA7_PIN     PINA7
 #define PA7_RPORT   PINA
 #define PA7_WPORT   PORTA
 #define PA7_DDR     DDRA
-#define PA7_PWM     nullptr
+#define PA7_PWM     NULL

 #undef PB0
 #define PB0_PIN     PINB0
 #define PB0_RPORT   PINB
 #define PB0_WPORT   PORTB
 #define PB0_DDR     DDRB
-#define PB0_PWM     nullptr
+#define PB0_PWM     NULL

 #undef PB1
 #define PB1_PIN     PINB1
 #define PB1_RPORT   PINB
 #define PB1_WPORT   PORTB
 #define PB1_DDR     DDRB
-#define PB1_PWM     nullptr
+#define PB1_PWM     NULL

 #undef PB2
 #define PB2_PIN     PINB2
 #define PB2_RPORT   PINB
 #define PB2_WPORT   PORTB
 #define PB2_DDR     DDRB
-#define PB2_PWM     nullptr
+#define PB2_PWM     NULL

 #undef PB3
 #define PB3_PIN     PINB3
 #define PB3_RPORT   PINB
 #define PB3_WPORT   PORTB
 #define PB3_DDR     DDRB
-#define PB3_PWM     &OCR0A
+#define PB3_PWM     OCR0A

 #undef PB4
 #define PB4_PIN     PINB4
 #define PB4_RPORT   PINB
 #define PB4_WPORT   PORTB
 #define PB4_DDR     DDRB
-#define PB4_PWM     &OCR0B
+#define PB4_PWM     OCR0B

 #undef PB5
 #define PB5_PIN     PINB5
 #define PB5_RPORT   PINB
 #define PB5_WPORT   PORTB
 #define PB5_DDR     DDRB
-#define PB5_PWM     nullptr
+#define PB5_PWM     NULL

 #undef PB6
 #define PB6_PIN     PINB6
 #define PB6_RPORT   PINB
 #define PB6_WPORT   PORTB
 #define PB6_DDR     DDRB
-#define PB6_PWM     nullptr
+#define PB6_PWM     NULL

 #undef PB7
 #define PB7_PIN     PINB7
 #define PB7_RPORT   PINB
 #define PB7_WPORT   PORTB
 #define PB7_DDR     DDRB
-#define PB7_PWM     nullptr
+#define PB7_PWM     NULL

 #undef PC0
 #define PC0_PIN     PINC0
 #define PC0_RPORT   PINC
 #define PC0_WPORT   PORTC
 #define PC0_DDR     DDRC
-#define PC0_PWM     nullptr
+#define PC0_PWM     NULL

 #undef PC1
 #define PC1_PIN     PINC1
 #define PC1_RPORT   PINC
 #define PC1_WPORT   PORTC
 #define PC1_DDR     DDRC
-#define PC1_PWM     nullptr
+#define PC1_PWM     NULL

 #undef PC2
 #define PC2_PIN     PINC2
 #define PC2_RPORT   PINC
 #define PC2_WPORT   PORTC
 #define PC2_DDR     DDRC
-#define PC2_PWM     nullptr
+#define PC2_PWM     NULL

 #undef PC3
 #define PC3_PIN     PINC3
 #define PC3_RPORT   PINC
 #define PC3_WPORT   PORTC
 #define PC3_DDR     DDRC
-#define PC3_PWM     nullptr
+#define PC3_PWM     NULL

 #undef PC4
 #define PC4_PIN     PINC4
 #define PC4_RPORT   PINC
 #define PC4_WPORT   PORTC
 #define PC4_DDR     DDRC
-#define PC4_PWM     nullptr
+#define PC4_PWM     NULL

 #undef PC5
 #define PC5_PIN     PINC5
 #define PC5_RPORT   PINC
 #define PC5_WPORT   PORTC
 #define PC5_DDR     DDRC
-#define PC5_PWM     nullptr
+#define PC5_PWM     NULL

 #undef PC6
 #define PC6_PIN     PINC6
 #define PC6_RPORT   PINC
 #define PC6_WPORT   PORTC
 #define PC6_DDR     DDRC
-#define PC6_PWM     nullptr
+#define PC6_PWM     NULL

 #undef PC7
 #define PC7_PIN     PINC7
 #define PC7_RPORT   PINC
 #define PC7_WPORT   PORTC
 #define PC7_DDR     DDRC
-#define PC7_PWM     nullptr
+#define PC7_PWM     NULL

 #undef PD0
 #define PD0_PIN     PIND0
 #define PD0_RPORT   PIND
 #define PD0_WPORT   PORTD
 #define PD0_DDR     DDRD
-#define PD0_PWM     nullptr
+#define PD0_PWM     NULL

 #undef PD1
 #define PD1_PIN     PIND1
 #define PD1_RPORT   PIND
 #define PD1_WPORT   PORTD
 #define PD1_DDR     DDRD
-#define PD1_PWM     nullptr
+#define PD1_PWM     NULL

 #undef PD2
 #define PD2_PIN     PIND2
 #define PD2_RPORT   PIND
 #define PD2_WPORT   PORTD
 #define PD2_DDR     DDRD
-#define PD2_PWM     nullptr
+#define PD2_PWM     NULL

 #undef PD3
 #define PD3_PIN     PIND3
 #define PD3_RPORT   PIND
 #define PD3_WPORT   PORTD
 #define PD3_DDR     DDRD
-#define PD3_PWM     nullptr
+#define PD3_PWM     NULL

 #undef PD4
 #define PD4_PIN     PIND4
 #define PD4_RPORT   PIND
 #define PD4_WPORT   PORTD
 #define PD4_DDR     DDRD
-#define PD4_PWM     nullptr
+#define PD4_PWM     NULL

 #undef PD5
 #define PD5_PIN     PIND5
 #define PD5_RPORT   PIND
 #define PD5_WPORT   PORTD
 #define PD5_DDR     DDRD
-#define PD5_PWM     nullptr
+#define PD5_PWM     NULL

 #undef PD6
 #define PD6_PIN     PIND6
 #define PD6_RPORT   PIND
 #define PD6_WPORT   PORTD
 #define PD6_DDR     DDRD
-#define PD6_PWM     &OCR2B
+#define PD6_PWM     OCR2B

 #undef PD7
 #define PD7_PIN     PIND7
 #define PD7_RPORT   PIND
 #define PD7_WPORT   PORTD
 #define PD7_DDR     DDRD
-#define PD7_PWM     &OCR2A
+#define PD7_PWM     OCR2A
+
+#endif // _FASTIO_644_H_
--- a/Marlin/src/HAL/AVR/fastio/fastio_AT90USB.h
+++ b/Marlin/src/HAL/AVR/fastio/fastio_AT90USB.h
@@ -1,9 +1,9 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
 * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * 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
@@ -19,7 +19,6 @@
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
-#pragma once

 /**
 * Pin mapping (Teensy) for AT90USB646, 647, 1286, and 1287
@@ -29,7 +28,10 @@
 *            The logical pins 46 and 47 are not supported by Teensyduino, but are supported below as E2 and E3
 */

-#include "../fastio.h"
+#ifndef _FASTIO_AT90USB_H_
+#define _FASTIO_AT90USB_H_
+
+#include "fastio_AVR.h"

 // change for your board
 #define DEBUG_LED   DIO31 /* led D5 red */
@@ -45,325 +47,325 @@
 #define DIO0_PIN    PIND0
 #define DIO0_RPORT  PIND
 #define DIO0_WPORT  PORTD
-#define DIO0_PWM    0
+#define DIO0_PWM    NULL
 #define DIO0_DDR    DDRD

 #define DIO1_PIN    PIND1
 #define DIO1_RPORT  PIND
 #define DIO1_WPORT  PORTD
-#define DIO1_PWM    0
+#define DIO1_PWM    NULL
 #define DIO1_DDR    DDRD

 #define DIO2_PIN    PIND2
 #define DIO2_RPORT  PIND
 #define DIO2_WPORT  PORTD
-#define DIO2_PWM    0
+#define DIO2_PWM    NULL
 #define DIO2_DDR    DDRD

 #define DIO3_PIN    PIND3
 #define DIO3_RPORT  PIND
 #define DIO3_WPORT  PORTD
-#define DIO3_PWM    0
+#define DIO3_PWM    NULL
 #define DIO3_DDR    DDRD

 #define DIO4_PIN    PIND4
 #define DIO4_RPORT  PIND
 #define DIO4_WPORT  PORTD
-#define DIO4_PWM    0
+#define DIO4_PWM    NULL
 #define DIO4_DDR    DDRD

 #define DIO5_PIN    PIND5
 #define DIO5_RPORT  PIND
 #define DIO5_WPORT  PORTD
-#define DIO5_PWM    0
+#define DIO5_PWM    NULL
 #define DIO5_DDR    DDRD

 #define DIO6_PIN    PIND6
 #define DIO6_RPORT  PIND
 #define DIO6_WPORT  PORTD
-#define DIO6_PWM    0
+#define DIO6_PWM    NULL
 #define DIO6_DDR    DDRD

 #define DIO7_PIN    PIND7
 #define DIO7_RPORT  PIND
 #define DIO7_WPORT  PORTD
-#define DIO7_PWM    0
+#define DIO7_PWM    NULL
 #define DIO7_DDR    DDRD

 #define DIO8_PIN    PINE0
 #define DIO8_RPORT  PINE
 #define DIO8_WPORT  PORTE
-#define DIO8_PWM    0
+#define DIO8_PWM    NULL
 #define DIO8_DDR    DDRE

 #define DIO9_PIN    PINE1
 #define DIO9_RPORT  PINE
 #define DIO9_WPORT  PORTE
-#define DIO9_PWM    0
+#define DIO9_PWM    NULL
 #define DIO9_DDR    DDRE

 #define DIO10_PIN   PINC0
 #define DIO10_RPORT PINC
 #define DIO10_WPORT PORTC
-#define DIO10_PWM   0
+#define DIO10_PWM   NULL
 #define DIO10_DDR   DDRC

 #define DIO11_PIN   PINC1
 #define DIO11_RPORT PINC
 #define DIO11_WPORT PORTC
-#define DIO11_PWM   0
+#define DIO11_PWM   NULL
 #define DIO11_DDR   DDRC

 #define DIO12_PIN   PINC2
 #define DIO12_RPORT PINC
 #define DIO12_WPORT PORTC
-#define DIO12_PWM   0
+#define DIO12_PWM   NULL
 #define DIO12_DDR   DDRC

 #define DIO13_PIN   PINC3
 #define DIO13_RPORT PINC
 #define DIO13_WPORT PORTC
-#define DIO13_PWM   0
+#define DIO13_PWM   NULL
 #define DIO13_DDR   DDRC

 #define DIO14_PIN   PINC4
 #define DIO14_RPORT PINC
 #define DIO14_WPORT PORTC
-#define DIO14_PWM   0 // OC3C
+#define DIO14_PWM   NULL
 #define DIO14_DDR   DDRC

 #define DIO15_PIN   PINC5
 #define DIO15_RPORT PINC
 #define DIO15_WPORT PORTC
-#define DIO15_PWM   0 // OC3B
+#define DIO15_PWM   NULL
 #define DIO15_DDR   DDRC

 #define DIO16_PIN   PINC6
 #define DIO16_RPORT PINC
 #define DIO16_WPORT PORTC
-#define DIO16_PWM   0 // OC3A
+#define DIO16_PWM   NULL
 #define DIO16_DDR   DDRC

 #define DIO17_PIN   PINC7
 #define DIO17_RPORT PINC
 #define DIO17_WPORT PORTC
-#define DIO17_PWM   0
+#define DIO17_PWM   NULL
 #define DIO17_DDR   DDRC

 #define DIO18_PIN   PINE6
 #define DIO18_RPORT PINE
 #define DIO18_WPORT PORTE
-#define DIO18_PWM   0
+#define DIO18_PWM   NULL
 #define DIO18_DDR   DDRE

 #define DIO19_PIN   PINE7
 #define DIO19_RPORT PINE
 #define DIO19_WPORT PORTE
-#define DIO19_PWM   0
+#define DIO19_PWM   NULL
 #define DIO19_DDR   DDRE

 #define DIO20_PIN   PINB0
 #define DIO20_RPORT PINB
 #define DIO20_WPORT PORTB
-#define DIO20_PWM   0
+#define DIO20_PWM   NULL
 #define DIO20_DDR   DDRB

 #define DIO21_PIN   PINB1
 #define DIO21_RPORT PINB
 #define DIO21_WPORT PORTB
-#define DIO21_PWM   0
+#define DIO21_PWM   NULL
 #define DIO21_DDR   DDRB

 #define DIO22_PIN   PINB2
 #define DIO22_RPORT PINB
 #define DIO22_WPORT PORTB
-#define DIO22_PWM   0
+#define DIO22_PWM   NULL
 #define DIO22_DDR   DDRB

 #define DIO23_PIN   PINB3
 #define DIO23_RPORT PINB
 #define DIO23_WPORT PORTB
-#define DIO23_PWM   0
+#define DIO23_PWM   NULL
 #define DIO23_DDR   DDRB

 #define DIO24_PIN   PINB4
 #define DIO24_RPORT PINB
 #define DIO24_WPORT PORTB
-#define DIO24_PWM   0 // OC2A
+#define DIO24_PWM   NULL
 #define DIO24_DDR   DDRB

 #define DIO25_PIN   PINB5
 #define DIO25_RPORT PINB
 #define DIO25_WPORT PORTB
-#define DIO25_PWM   0 // OC1A
+#define DIO25_PWM   NULL
 #define DIO25_DDR   DDRB

 #define DIO26_PIN   PINB6
 #define DIO26_RPORT PINB
 #define DIO26_WPORT PORTB
-#define DIO26_PWM   0 // OC1B
+#define DIO26_PWM   NULL
 #define DIO26_DDR   DDRB

 #define DIO27_PIN   PINB7
 #define DIO27_RPORT PINB
 #define DIO27_WPORT PORTB
-#define DIO27_PWM   0 // OC1C
+#define DIO27_PWM   NULL
 #define DIO27_DDR   DDRB

 #define DIO28_PIN   PINA0
 #define DIO28_RPORT PINA
 #define DIO28_WPORT PORTA
-#define DIO28_PWM   0
+#define DIO28_PWM   NULL
 #define DIO28_DDR   DDRA

 #define DIO29_PIN   PINA1
 #define DIO29_RPORT PINA
 #define DIO29_WPORT PORTA
-#define DIO29_PWM   0
+#define DIO29_PWM   NULL
 #define DIO29_DDR   DDRA

 #define DIO30_PIN   PINA2
 #define DIO30_RPORT PINA
 #define DIO30_WPORT PORTA
-#define DIO30_PWM   0
+#define DIO30_PWM   NULL
 #define DIO30_DDR   DDRA

 #define DIO31_PIN   PINA3
 #define DIO31_RPORT PINA
 #define DIO31_WPORT PORTA
-#define DIO31_PWM   0
+#define DIO31_PWM   NULL
 #define DIO31_DDR   DDRA

 #define DIO32_PIN   PINA4
 #define DIO32_RPORT PINA
 #define DIO32_WPORT PORTA
-#define DIO32_PWM   0
+#define DIO32_PWM   NULL
 #define DIO32_DDR   DDRA

 #define DIO33_PIN   PINA5
 #define DIO33_RPORT PINA
 #define DIO33_WPORT PORTA
-#define DIO33_PWM   0
+#define DIO33_PWM   NULL
 #define DIO33_DDR   DDRA

 #define DIO34_PIN   PINA6
 #define DIO34_RPORT PINA
 #define DIO34_WPORT PORTA
-#define DIO34_PWM   0
+#define DIO34_PWM   NULL
 #define DIO34_DDR   DDRA

 #define DIO35_PIN   PINA7
 #define DIO35_RPORT PINA
 #define DIO35_WPORT PORTA
-#define DIO35_PWM   0
+#define DIO35_PWM   NULL
 #define DIO35_DDR   DDRA

 #define DIO36_PIN   PINE4
 #define DIO36_RPORT PINE
 #define DIO36_WPORT PORTE
-#define DIO36_PWM   0
+#define DIO36_PWM   NULL
 #define DIO36_DDR   DDRE

 #define DIO37_PIN   PINE5
 #define DIO37_RPORT PINE
 #define DIO37_WPORT PORTE
-#define DIO37_PWM   0
+#define DIO37_PWM   NULL
 #define DIO37_DDR   DDRE

 #define DIO38_PIN   PINF0
 #define DIO38_RPORT PINF
 #define DIO38_WPORT PORTF
-#define DIO38_PWM   0
+#define DIO38_PWM   NULL
 #define DIO38_DDR   DDRF

 #define DIO39_PIN   PINF1
 #define DIO39_RPORT PINF
 #define DIO39_WPORT PORTF
-#define DIO39_PWM   0
+#define DIO39_PWM   NULL
 #define DIO39_DDR   DDRF

 #define DIO40_PIN   PINF2
 #define DIO40_RPORT PINF
 #define DIO40_WPORT PORTF
-#define DIO40_PWM   0
+#define DIO40_PWM   NULL
 #define DIO40_DDR   DDRF

 #define DIO41_PIN   PINF3
 #define DIO41_RPORT PINF
 #define DIO41_WPORT PORTF
-#define DIO41_PWM   0
+#define DIO41_PWM   NULL
 #define DIO41_DDR   DDRF

 #define DIO42_PIN   PINF4
 #define DIO42_RPORT PINF
 #define DIO42_WPORT PORTF
-#define DIO42_PWM   0
+#define DIO42_PWM   NULL
 #define DIO42_DDR   DDRF

 #define DIO43_PIN   PINF5
 #define DIO43_RPORT PINF
 #define DIO43_WPORT PORTF
-#define DIO43_PWM   0
+#define DIO43_PWM   NULL
 #define DIO43_DDR   DDRF

 #define DIO44_PIN   PINF6
 #define DIO44_RPORT PINF
 #define DIO44_WPORT PORTF
-#define DIO44_PWM   0
+#define DIO44_PWM   NULL
 #define DIO44_DDR   DDRF

 #define DIO45_PIN   PINF7
 #define DIO45_RPORT PINF
 #define DIO45_WPORT PORTF
-#define DIO45_PWM   0
+#define DIO45_PWM   NULL
 #define DIO45_DDR   DDRF

 #define AIO0_PIN    PINF0
 #define AIO0_RPORT  PINF
 #define AIO0_WPORT  PORTF
-#define AIO0_PWM    0
+#define AIO0_PWM    NULL
 #define AIO0_DDR    DDRF

 #define AIO1_PIN    PINF1
 #define AIO1_RPORT  PINF
 #define AIO1_WPORT  PORTF
-#define AIO1_PWM    0
+#define AIO1_PWM    NULL
 #define AIO1_DDR    DDRF

 #define AIO2_PIN    PINF2
 #define AIO2_RPORT  PINF
 #define AIO2_WPORT  PORTF
-#define AIO2_PWM    0
+#define AIO2_PWM    NULL
 #define AIO2_DDR    DDRF

 #define AIO3_PIN    PINF3
 #define AIO3_RPORT  PINF
 #define AIO3_WPORT  PORTF
-#define AIO3_PWM    0
+#define AIO3_PWM    NULL
 #define AIO3_DDR    DDRF

 #define AIO4_PIN    PINF4
 #define AIO4_RPORT  PINF
 #define AIO4_WPORT  PORTF
-#define AIO4_PWM    0
+#define AIO4_PWM    NULL
 #define AIO4_DDR    DDRF

 #define AIO5_PIN    PINF5
 #define AIO5_RPORT  PINF
 #define AIO5_WPORT  PORTF
-#define AIO5_PWM    0
+#define AIO5_PWM    NULL
 #define AIO5_DDR    DDRF

 #define AIO6_PIN    PINF6
 #define AIO6_RPORT  PINF
 #define AIO6_WPORT  PORTF
-#define AIO6_PWM    0
+#define AIO6_PWM    NULL
 #define AIO6_DDR    DDRF

 #define AIO7_PIN    PINF7
 #define AIO7_RPORT  PINF
 #define AIO7_WPORT  PORTF
-#define AIO7_PWM    0
+#define AIO7_PWM    NULL
 #define AIO7_DDR    DDRF

 //-- Begin not supported by Teensyduino
@@ -371,13 +373,13 @@
 #define DIO46_PIN   PINE2
 #define DIO46_RPORT PINE
 #define DIO46_WPORT PORTE
-#define DIO46_PWM   0
+#define DIO46_PWM   NULL
 #define DIO46_DDR   DDRE

 #define DIO47_PIN   PINE3
 #define DIO47_RPORT PINE
 #define DIO47_WPORT PORTE
-#define DIO47_PWM   0
+#define DIO47_PWM   NULL
 #define DIO47_DDR   DDRE

 #define TEENSY_E2   46
@@ -389,300 +391,300 @@
 #define PA0_PIN     PINA0
 #define PA0_RPORT   PINA
 #define PA0_WPORT   PORTA
-#define PA0_PWM     0
+#define PA0_PWM     NULL
 #define PA0_DDR     DDRA
 #undef PA1
 #define PA1_PIN     PINA1
 #define PA1_RPORT   PINA
 #define PA1_WPORT   PORTA
-#define PA1_PWM     0
+#define PA1_PWM     NULL
 #define PA1_DDR     DDRA
 #undef PA2
 #define PA2_PIN     PINA2
 #define PA2_RPORT   PINA
 #define PA2_WPORT   PORTA
-#define PA2_PWM     0
+#define PA2_PWM     NULL
 #define PA2_DDR     DDRA
 #undef PA3
 #define PA3_PIN     PINA3
 #define PA3_RPORT   PINA
 #define PA3_WPORT   PORTA
-#define PA3_PWM     0
+#define PA3_PWM     NULL
 #define PA3_DDR     DDRA
 #undef PA4
 #define PA4_PIN     PINA4
 #define PA4_RPORT   PINA
 #define PA4_WPORT   PORTA
-#define PA4_PWM     0
+#define PA4_PWM     NULL
 #define PA4_DDR     DDRA
 #undef PA5
 #define PA5_PIN     PINA5
 #define PA5_RPORT   PINA
 #define PA5_WPORT   PORTA
-#define PA5_PWM     0
+#define PA5_PWM     NULL
 #define PA5_DDR     DDRA
 #undef PA6
 #define PA6_PIN     PINA6
 #define PA6_RPORT   PINA
 #define PA6_WPORT   PORTA
-#define PA6_PWM     0
+#define PA6_PWM     NULL
 #define PA6_DDR     DDRA
 #undef PA7
 #define PA7_PIN     PINA7
 #define PA7_RPORT   PINA
 #define PA7_WPORT   PORTA
-#define PA7_PWM     0
+#define PA7_PWM     NULL
 #define PA7_DDR     DDRA

 #undef PB0
 #define PB0_PIN     PINB0
 #define PB0_RPORT   PINB
 #define PB0_WPORT   PORTB
-#define PB0_PWM     0
+#define PB0_PWM     NULL
 #define PB0_DDR     DDRB
 #undef PB1
 #define PB1_PIN     PINB1
 #define PB1_RPORT   PINB
 #define PB1_WPORT   PORTB
-#define PB1_PWM     0
+#define PB1_PWM     NULL
 #define PB1_DDR     DDRB
 #undef PB2
 #define PB2_PIN     PINB2
 #define PB2_RPORT   PINB
 #define PB2_WPORT   PORTB
-#define PB2_PWM     0
+#define PB2_PWM     NULL
 #define PB2_DDR     DDRB
 #undef PB3
 #define PB3_PIN     PINB3
 #define PB3_RPORT   PINB
 #define PB3_WPORT   PORTB
-#define PB3_PWM     0
+#define PB3_PWM     NULL
 #define PB3_DDR     DDRB
 #undef PB4
 #define PB4_PIN     PINB4
 #define PB4_RPORT   PINB
 #define PB4_WPORT   PORTB
-#define PB4_PWM     0
+#define PB4_PWM     NULL
 #define PB4_DDR     DDRB
 #undef PB5
 #define PB5_PIN     PINB5
 #define PB5_RPORT   PINB
 #define PB5_WPORT   PORTB
-#define PB5_PWM     0
+#define PB5_PWM     NULL
 #define PB5_DDR     DDRB
 #undef PB6
 #define PB6_PIN     PINB6
 #define PB6_RPORT   PINB
 #define PB6_WPORT   PORTB
-#define PB6_PWM     0
+#define PB6_PWM     NULL
 #define PB6_DDR     DDRB
 #undef PB7
 #define PB7_PIN     PINB7
 #define PB7_RPORT   PINB
 #define PB7_WPORT   PORTB
-#define PB7_PWM     0
+#define PB7_PWM     NULL
 #define PB7_DDR     DDRB

 #undef PC0
 #define PC0_PIN     PINC0
 #define PC0_RPORT   PINC
 #define PC0_WPORT   PORTC
-#define PC0_PWM     0
+#define PC0_PWM     NULL
 #define PC0_DDR     DDRC
 #undef PC1
 #define PC1_PIN     PINC1
 #define PC1_RPORT   PINC
 #define PC1_WPORT   PORTC
-#define PC1_PWM     0
+#define PC1_PWM     NULL
 #define PC1_DDR     DDRC
 #undef PC2
 #define PC2_PIN     PINC2
 #define PC2_RPORT   PINC
 #define PC2_WPORT   PORTC
-#define PC2_PWM     0
+#define PC2_PWM     NULL
 #define PC2_DDR     DDRC
 #undef PC3
 #define PC3_PIN     PINC3
 #define PC3_RPORT   PINC
 #define PC3_WPORT   PORTC
-#define PC3_PWM     0
+#define PC3_PWM     NULL
 #define PC3_DDR     DDRC
 #undef PC4
 #define PC4_PIN     PINC4
 #define PC4_RPORT   PINC
 #define PC4_WPORT   PORTC
-#define PC4_PWM     0
+#define PC4_PWM     NULL
 #define PC4_DDR     DDRC
 #undef PC5
 #define PC5_PIN     PINC5
 #define PC5_RPORT   PINC
 #define PC5_WPORT   PORTC
-#define PC5_PWM     0
+#define PC5_PWM     NULL
 #define PC5_DDR     DDRC
 #undef PC6
 #define PC6_PIN     PINC6
 #define PC6_RPORT   PINC
 #define PC6_WPORT   PORTC
-#define PC6_PWM     0
+#define PC6_PWM     NULL
 #define PC6_DDR     DDRC
 #undef PC7
 #define PC7_PIN     PINC7
 #define PC7_RPORT   PINC
 #define PC7_WPORT   PORTC
-#define PC7_PWM     0
+#define PC7_PWM     NULL
 #define PC7_DDR     DDRC

 #undef PD0
 #define PD0_PIN     PIND0
 #define PD0_RPORT   PIND
 #define PD0_WPORT   PORTD
-#define PD0_PWM     0 // OC0B
+#define PD0_PWM     NULL
 #define PD0_DDR     DDRD
 #undef PD1
 #define PD1_PIN     PIND1
 #define PD1_RPORT   PIND
 #define PD1_WPORT   PORTD
-#define PD1_PWM     0 // OC2B
+#define PD1_PWM     NULL
 #define PD1_DDR     DDRD
 #undef PD2
 #define PD2_PIN     PIND2
 #define PD2_RPORT   PIND
 #define PD2_WPORT   PORTD
-#define PD2_PWM     0
+#define PD2_PWM     NULL
 #define PD2_DDR     DDRD
 #undef PD3
 #define PD3_PIN     PIND3
 #define PD3_RPORT   PIND
 #define PD3_WPORT   PORTD
-#define PD3_PWM     0
+#define PD3_PWM     NULL
 #define PD3_DDR     DDRD
 #undef PD4
 #define PD4_PIN     PIND4
 #define PD4_RPORT   PIND
 #define PD4_WPORT   PORTD
-#define PD4_PWM     0
+#define PD4_PWM     NULL
 #define PD4_DDR     DDRD
 #undef PD5
 #define PD5_PIN     PIND5
 #define PD5_RPORT   PIND
 #define PD5_WPORT   PORTD
-#define PD5_PWM     0
+#define PD5_PWM     NULL
 #define PD5_DDR     DDRD
 #undef PD6
 #define PD6_PIN     PIND6
 #define PD6_RPORT   PIND
 #define PD6_WPORT   PORTD
-#define PD6_PWM     0
+#define PD6_PWM     NULL
 #define PD6_DDR     DDRD
 #undef PD7
 #define PD7_PIN     PIND7
 #define PD7_RPORT   PIND
 #define PD7_WPORT   PORTD
-#define PD7_PWM     0
+#define PD7_PWM     NULL
 #define PD7_DDR     DDRD

 #undef PE0
 #define PE0_PIN     PINE0
 #define PE0_RPORT   PINE
 #define PE0_WPORT   PORTE
-#define PE0_PWM     0
+#define PE0_PWM     NULL
 #define PE0_DDR     DDRE
 #undef PE1
 #define PE1_PIN     PINE1
 #define PE1_RPORT   PINE
 #define PE1_WPORT   PORTE
-#define PE1_PWM     0
+#define PE1_PWM     NULL
 #define PE1_DDR     DDRE
 #undef PE2
 #define PE2_PIN     PINE2
 #define PE2_RPORT   PINE
 #define PE2_WPORT   PORTE
-#define PE2_PWM     0
+#define PE2_PWM     NULL
 #define PE2_DDR     DDRE
 #undef PE3
 #define PE3_PIN     PINE3
 #define PE3_RPORT   PINE
 #define PE3_WPORT   PORTE
-#define PE3_PWM     0
+#define PE3_PWM     NULL
 #define PE3_DDR     DDRE
 #undef PE4
 #define PE4_PIN     PINE4
 #define PE4_RPORT   PINE
 #define PE4_WPORT   PORTE
-#define PE4_PWM     0
+#define PE4_PWM     NULL
 #define PE4_DDR     DDRE
 #undef PE5
 #define PE5_PIN     PINE5
 #define PE5_RPORT   PINE
 #define PE5_WPORT   PORTE
-#define PE5_PWM     0
+#define PE5_PWM     NULL
 #define PE5_DDR     DDRE
 #undef PE6
 #define PE6_PIN     PINE6
 #define PE6_RPORT   PINE
 #define PE6_WPORT   PORTE
-#define PE6_PWM     0
+#define PE6_PWM     NULL
 #define PE6_DDR     DDRE
 #undef PE7
 #define PE7_PIN     PINE7
 #define PE7_RPORT   PINE
 #define PE7_WPORT   PORTE
-#define PE7_PWM     0
+#define PE7_PWM     NULL
 #define PE7_DDR     DDRE

 #undef PF0
 #define PF0_PIN     PINF0
 #define PF0_RPORT   PINF
 #define PF0_WPORT   PORTF
-#define PF0_PWM     0
+#define PF0_PWM     NULL
 #define PF0_DDR     DDRF
 #undef PF1
 #define PF1_PIN     PINF1
 #define PF1_RPORT   PINF
 #define PF1_WPORT   PORTF
-#define PF1_PWM     0
+#define PF1_PWM     NULL
 #define PF1_DDR     DDRF
 #undef PF2
 #define PF2_PIN     PINF2
 #define PF2_RPORT   PINF
 #define PF2_WPORT   PORTF
-#define PF2_PWM     0
+#define PF2_PWM     NULL
 #define PF2_DDR     DDRF
 #undef PF3
 #define PF3_PIN     PINF3
 #define PF3_RPORT   PINF
 #define PF3_WPORT   PORTF
-#define PF3_PWM     0
+#define PF3_PWM     NULL
 #define PF3_DDR     DDRF
 #undef PF4
 #define PF4_PIN     PINF4
 #define PF4_RPORT   PINF
 #define PF4_WPORT   PORTF
-#define PF4_PWM     0
+#define PF4_PWM     NULL
 #define PF4_DDR     DDRF
 #undef PF5
 #define PF5_PIN     PINF5
 #define PF5_RPORT   PINF
 #define PF5_WPORT   PORTF
-#define PF5_PWM     0
+#define PF5_PWM     NULL
 #define PF5_DDR     DDRF
 #undef PF6
 #define PF6_PIN     PINF6
 #define PF6_RPORT   PINF
 #define PF6_WPORT   PORTF
-#define PF6_PWM     0
+#define PF6_PWM     NULL
 #define PF6_DDR     DDRF
 #undef PF7
 #define PF7_PIN     PINF7
 #define PF7_RPORT   PINF
 #define PF7_WPORT   PORTF
-#define PF7_PWM     0
+#define PF7_PWM     NULL
 #define PF7_DDR     DDRF


 /**
- * Some of the pin mapping functions of the Teensduino extension to the Arduino IDE
- * do not function the same as the other Arduino extensions.
+ *  some of the pin mapping functions of the Teensduino extension to the Arduino IDE
+ *  do not function the same as the other Arduino extensions
 */

 //digitalPinToTimer(pin) function works like Arduino but Timers are not defined
@@ -695,3 +697,5 @@
 #define TIMER3A 5
 #define TIMER3B 4
 #define TIMER3C 3
+
+#endif // _FASTIO_AT90USB_H_
--- a/Marlin/src/HAL/HAL_AVR/fastio_AVR.h
+++ b/Marlin/src/HAL/HAL_AVR/fastio_AVR.h
@@ -1,9 +1,9 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
 * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * 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
@@ -19,7 +19,6 @@
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
-#pragma once

 /**
 * Fast I/O Routines for AVR
@@ -27,9 +26,13 @@
 * Contributed by Triffid_Hunter and modified by Kliment, thinkyhead, Bob-the-Kuhn, et.al.
 */

-#include <avr/io.h>
+#ifndef _FASTIO_ARDUINO_H_
+#define _FASTIO_ARDUINO_H_

-#define AVR_AT90USB1286_FAMILY (defined(__AVR_AT90USB1287__) || defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB1286P__) || defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB646P__) || defined(__AVR_AT90USB647__))
+#include <avr/io.h>
+#include "../../core/macros.h"
+
+#define AVR_AT90USB1286_FAMILY (defined(__AVR_AT90USB1287__) || defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB1286P__) || defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB646P__)  || defined(__AVR_AT90USB647__))
 #define AVR_ATmega1284_FAMILY (defined(__AVR_ATmega644__) || defined(__AVR_ATmega644P__) || defined(__AVR_ATmega644PA__) || defined(__AVR_ATmega1284P__))
 #define AVR_ATmega2560_FAMILY (defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__))
 #define AVR_ATmega2561_FAMILY (defined(__AVR_ATmega1281__) || defined(__AVR_ATmega2561__))
@@ -39,15 +42,15 @@
 * Include Ports and Functions
 */
 #if AVR_ATmega328_FAMILY
-  #include "fastio/fastio_168.h"
+  #include "fastio_168.h"
 #elif AVR_ATmega1284_FAMILY
-  #include "fastio/fastio_644.h"
+  #include "fastio_644.h"
 #elif AVR_ATmega2560_FAMILY
-  #include "fastio/fastio_1280.h"
+  #include "fastio_1280.h"
 #elif AVR_AT90USB1286_FAMILY
-  #include "fastio/fastio_AT90USB.h"
+  #include "fastio_AT90USB.h"
 #elif AVR_ATmega2561_FAMILY
-  #include "fastio/fastio_1281.h"
+  #include "fastio_1281.h"
 #else
  #error "No FastIO definition for the selected AVR Board."
 #endif
@@ -80,17 +83,9 @@
 #define _SET_INPUT(IO)        CBI(DIO ## IO ## _DDR, DIO ## IO ## _PIN)
 #define _SET_OUTPUT(IO)       SBI(DIO ## IO ## _DDR, DIO ## IO ## _PIN)

-#define _IS_INPUT(IO)         !TEST(DIO ## IO ## _DDR, DIO ## IO ## _PIN)
-#define _IS_OUTPUT(IO)        TEST(DIO ## IO ## _DDR, DIO ## IO ## _PIN)
-
-// digitalRead/Write wrappers
-#ifdef FASTIO_EXT_START
-  void extDigitalWrite(const int8_t pin, const uint8_t state);
-  uint8_t extDigitalRead(const int8_t pin);
-#else
-  #define extDigitalWrite(IO,V) digitalWrite(IO,V)
-  #define extDigitalRead(IO)    digitalRead(IO)
-#endif
+#define _GET_INPUT(IO)       !TEST(DIO ## IO ## _DDR, DIO ## IO ## _PIN)
+#define _GET_OUTPUT(IO)       TEST(DIO ## IO ## _DDR, DIO ## IO ## _PIN)
+#define _GET_TIMER(IO)        DIO ## IO ## _PWM

 #define READ(IO)              _READ(IO)
 #define WRITE(IO,V)           _WRITE(IO,V)
@@ -100,10 +95,9 @@
 #define SET_INPUT_PULLUP(IO)  do{ _SET_INPUT(IO); _WRITE(IO, HIGH); }while(0)
 #define SET_OUTPUT(IO)        _SET_OUTPUT(IO)

-#define SET_PWM(IO)           SET_OUTPUT(IO)
-
-#define IS_INPUT(IO)          _IS_INPUT(IO)
-#define IS_OUTPUT(IO)         _IS_OUTPUT(IO)
+#define GET_INPUT(IO)         _GET_INPUT(IO)
+#define GET_OUTPUT(IO)        _GET_OUTPUT(IO)
+#define GET_TIMER(IO)         _GET_TIMER(IO)

 #define OUT_WRITE(IO,V)       do{ SET_OUTPUT(IO); WRITE(IO,V); }while(0)

@@ -131,18 +125,6 @@ enum WaveGenMode : char {
  WGM_FAST_PWM_OCRnA   // 15  COM OCnA
 };

-// Wavefore Generation Modes (Timer 2 only)
-enum WaveGenMode2 : char {
-  WGM2_NORMAL,          // 0
-  WGM2_PWM_PC,          // 1
-  WGM2_CTC_OCR2A,       // 2
-  WGM2_FAST_PWM,        // 3
-  WGM2_reserved_1,      // 4
-  WGM2_PWM_PC_OCR2A,    // 5
-  WGM2_reserved_2,      // 6
-  WGM2_FAST_PWM_OCR2A,  // 7
-};
-
 // Compare Modes
 enum CompareMode : char {
  COM_NORMAL,          //  0
@@ -197,11 +179,6 @@ enum ClockSource2 : char {
    TCCR##T##B = (TCCR##T##B & ~(0x3 << WGM##T##2)) | (((int(V) >> 2) & 0x3) << WGM##T##2); \
  }while(0)
 #define SET_WGM(T,V) _SET_WGM(T,WGM_##V)
-// Runtime (see set_pwm_frequency):
-#define _SET_WGMnQ(TCCRnQ, V) do{ \
-    *(TCCRnQ)[0] = (*(TCCRnQ)[0] & ~(0x3 << 0)) | (( int(V)       & 0x3) << 0); \
-    *(TCCRnQ)[1] = (*(TCCRnQ)[1] & ~(0x3 << 3)) | (((int(V) >> 2) & 0x3) << 3); \
-  }while(0)

 // Set Clock Select bits
 // Ex: SET_CS3(PRESCALER_64);
@@ -227,10 +204,6 @@ enum ClockSource2 : char {
 #define SET_CS4(V) _SET_CS4(CS_##V)
 #define SET_CS5(V) _SET_CS5(CS_##V)
 #define SET_CS(T,V) SET_CS##T(V)
-// Runtime (see set_pwm_frequency)
-#define _SET_CSn(TCCRnQ, V) do{ \
-    (*(TCCRnQ)[1] = (*(TCCRnQ[1]) & ~(0x7 << 0)) | ((int(V) & 0x7) << 0)); \
-  }while(0)

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

 // Set Noise Canceler bit
 // Ex: SET_ICNC(2,1)
@@ -272,96 +229,88 @@ enum ClockSource2 : char {
 #define SET_FOCB(T,V) SET_FOC(T,B,V)
 #define SET_FOCC(T,V) SET_FOC(T,C,V)

-#if 0

 /**
 * PWM availability macros
 */

 // Determine which harware PWMs are already in use
-#define _PWM_CHK_FAN_B(P) (P == E0_AUTO_FAN_PIN || P == E1_AUTO_FAN_PIN || P == E2_AUTO_FAN_PIN || P == E3_AUTO_FAN_PIN || P == E4_AUTO_FAN_PIN || P == E5_AUTO_FAN_PIN || P == E6_AUTO_FAN_PIN || P == E7_AUTO_FAN_PIN || P == CHAMBER_AUTO_FAN_PIN)
 #if PIN_EXISTS(CONTROLLER_FAN)
-  #define PWM_CHK_FAN_B(P) (_PWM_CHK_FAN_B(P) || P == CONTROLLER_FAN_PIN)
+  #define PWM_CHK_FAN_B(p) (p == CONTROLLER_FAN_PIN || p == E0_AUTO_FAN_PIN || p ==  E1_AUTO_FAN_PIN || p ==  E2_AUTO_FAN_PIN || p ==  E3_AUTO_FAN_PIN || p ==  E4_AUTO_FAN_PIN || p == CHAMBER_AUTO_FAN_PIN)
 #else
-  #define PWM_CHK_FAN_B(P) _PWM_CHK_FAN_B(P)
+  #define PWM_CHK_FAN_B(p) (p == E0_AUTO_FAN_PIN || p ==  E1_AUTO_FAN_PIN || p ==  E2_AUTO_FAN_PIN || p ==  E3_AUTO_FAN_PIN || p ==  E4_AUTO_FAN_PIN || p == CHAMBER_AUTO_FAN_PIN)
 #endif

-#if ANY_PIN(FAN, FAN1, FAN2, FAN3, FAN4, FAN5, FAN6, FAN7)
-  #if PIN_EXISTS(FAN7)
-    #define PWM_CHK_FAN_A(P) (P == FAN0_PIN || P == FAN1_PIN || P == FAN2_PIN || P == FAN3_PIN || P == FAN4_PIN || P == FAN5_PIN || P == FAN6_PIN || P == FAN7_PIN)
-  #elif PIN_EXISTS(FAN6)
-    #define PWM_CHK_FAN_A(P) (P == FAN0_PIN || P == FAN1_PIN || P == FAN2_PIN || P == FAN3_PIN || P == FAN4_PIN || P == FAN5_PIN || P == FAN6_PIN)
-  #elif PIN_EXISTS(FAN5)
-    #define PWM_CHK_FAN_A(P) (P == FAN0_PIN || P == FAN1_PIN || P == FAN2_PIN || P == FAN3_PIN || P == FAN4_PIN || P == FAN5_PIN)
-  #elif PIN_EXISTS(FAN4)
-    #define PWM_CHK_FAN_A(P) (P == FAN0_PIN || P == FAN1_PIN || P == FAN2_PIN || P == FAN3_PIN || P == FAN4_PIN)
-  #elif PIN_EXISTS(FAN3)
-    #define PWM_CHK_FAN_A(P) (P == FAN0_PIN || P == FAN1_PIN || P == FAN2_PIN || P == FAN3_PIN)
-  #elif PIN_EXISTS(FAN2)
-    #define PWM_CHK_FAN_A(P) (P == FAN0_PIN || P == FAN1_PIN || P == FAN2_PIN)
+#if PIN_EXISTS(FAN) || PIN_EXISTS(FAN1) || PIN_EXISTS(FAN2)
+  #if PIN_EXISTS(FAN2)
+    #define PWM_CHK_FAN_A(p) (p == FAN_PIN || p == FAN1_PIN || p == FAN2_PIN)
  #elif PIN_EXISTS(FAN1)
-    #define PWM_CHK_FAN_A(P) (P == FAN0_PIN || P == FAN1_PIN)
+    #define PWM_CHK_FAN_A(p) (p == FAN_PIN || p == FAN1_PIN)
  #else
-    #define PWM_CHK_FAN_A(P) (P == FAN0_PIN)
+    #define PWM_CHK_FAN_A(p) (p == FAN_PIN)
  #endif
 #else
-  #define PWM_CHK_FAN_A(P) false
+  #define PWM_CHK_FAN_A(p) false
 #endif

 #if HAS_MOTOR_CURRENT_PWM
  #if PIN_EXISTS(MOTOR_CURRENT_PWM_XY)
-    #define PWM_CHK_MOTOR_CURRENT(P) (P == MOTOR_CURRENT_PWM_E || P == MOTOR_CURRENT_PWM_Z || P == MOTOR_CURRENT_PWM_XY)
+    #define PWM_CHK_MOTOR_CURRENT(p) (p == MOTOR_CURRENT_PWM_E || p == MOTOR_CURRENT_PWM_Z || p == MOTOR_CURRENT_PWM_XY)
  #elif PIN_EXISTS(MOTOR_CURRENT_PWM_Z)
-    #define PWM_CHK_MOTOR_CURRENT(P) (P == MOTOR_CURRENT_PWM_E || P == MOTOR_CURRENT_PWM_Z)
+    #define PWM_CHK_MOTOR_CURRENT(p) (p == MOTOR_CURRENT_PWM_E || p == MOTOR_CURRENT_PWM_Z)
  #else
-    #define PWM_CHK_MOTOR_CURRENT(P) (P == MOTOR_CURRENT_PWM_E)
+    #define PWM_CHK_MOTOR_CURRENT(p) (p == MOTOR_CURRENT_PWM_E)
  #endif
 #else
-  #define PWM_CHK_MOTOR_CURRENT(P) false
+  #define PWM_CHK_MOTOR_CURRENT(p) false
 #endif

 #ifdef NUM_SERVOS
  #if AVR_ATmega2560_FAMILY
-    #define PWM_CHK_SERVO(P) (P == 5 || (NUM_SERVOS > 12 && P == 6) || (NUM_SERVOS > 24 && P == 46))  // PWMS 3A, 4A & 5A
+    #define PWM_CHK_SERVO(p) (p == 5 || (NUM_SERVOS > 12 && p == 6) || (NUM_SERVOS > 24 && p == 46))  // PWMS 3A, 4A & 5A
  #elif AVR_ATmega2561_FAMILY
-    #define PWM_CHK_SERVO(P)   (P == 5)  // PWM3A
+    #define PWM_CHK_SERVO(p)   (p == 5)  // PWM3A
  #elif AVR_ATmega1284_FAMILY
-    #define PWM_CHK_SERVO(P)   false
+    #define PWM_CHK_SERVO(p)   false
  #elif AVR_AT90USB1286_FAMILY
-    #define PWM_CHK_SERVO(P)   (P == 16) // PWM3A
+    #define PWM_CHK_SERVO(p)   (p == 16) // PWM3A
  #elif AVR_ATmega328_FAMILY
-    #define PWM_CHK_SERVO(P)   false
+    #define PWM_CHK_SERVO(p)   false
  #endif
 #else
-  #define PWM_CHK_SERVO(P) false
+  #define PWM_CHK_SERVO(p) false
 #endif

 #if ENABLED(BARICUDA)
  #if HAS_HEATER_1 && HAS_HEATER_2
-    #define PWM_CHK_HEATER(P) (P == HEATER_1_PIN || P == HEATER_2_PIN)
+    #define PWM_CHK_HEATER(p) (p == HEATER_1_PIN || p == HEATER_2_PIN)
  #elif HAS_HEATER_1
-    #define PWM_CHK_HEATER(P) (P == HEATER_1_PIN)
+    #define PWM_CHK_HEATER(p) (p == HEATER_1_PIN)
  #endif
 #else
-    #define PWM_CHK_HEATER(P) false
+    #define PWM_CHK_HEATER(p) false
 #endif

-#define PWM_CHK(P) (PWM_CHK_HEATER(P) || PWM_CHK_SERVO(P) || PWM_CHK_MOTOR_CURRENT(P) || PWM_CHK_FAN_A(P) || PWM_CHK_FAN_B(P))
-
-#endif // PWM_CHK is not used in Marlin
+#define PWM_CHK(p) (PWM_CHK_HEATER(p) || PWM_CHK_SERVO(p)  || PWM_CHK_MOTOR_CURRENT(p)\
+                     || PWM_CHK_FAN_A(p) || PWM_CHK_FAN_B(p))

 // define which hardware PWMs are available for the current CPU
 // all timer 1 PWMS deleted from this list because they are never available
 #if AVR_ATmega2560_FAMILY
-  #define PWM_PIN(P)  ((P >= 2 && P <= 10) || P == 13 || P == 44 || P == 45 || P == 46)
+  #define PWM_PINS(p)  ((p >= 2 && p <= 10) || p == 13 || p == 44 || p == 45 || p == 46)
 #elif AVR_ATmega2561_FAMILY
-  #define PWM_PIN(P)  ((P >= 2 && P <= 6) || P == 9)
+  #define PWM_PINS(p)  ((p >= 2 && p <= 6) || p == 9)
 #elif AVR_ATmega1284_FAMILY
-  #define PWM_PIN(P)  (P == 3 || P == 4 || P == 14 || P == 15)
+  #define PWM_PINS(p)  (p == 3 || p == 4 || p == 14 || p == 15)
 #elif AVR_AT90USB1286_FAMILY
-  #define PWM_PIN(P)  (P == 0 || P == 1 || P == 14 || P == 15 || P == 16 || P == 24)
+  #define PWM_PINS(p)  (p == 0 || p == 1 || p == 14 || p == 15 || p == 16 || p == 24)
 #elif AVR_ATmega328_FAMILY
-  #define PWM_PIN(P)  (P == 3 || P == 5 || P == 6 || P == 11)
+  #define PWM_PINS(p)  (p == 3 || p == 5 || p == 6 || p == 11)
 #else
  #error "unknown CPU"
 #endif
+
+// finally - the macro that tells us if a pin is an available hardware PWM
+#define USEABLE_HARDWARE_PWM(p) (PWM_PINS(p) && !PWM_CHK(p))
+
+#endif // _FASTIO_ARDUINO_H_
--- a/Marlin/src/HAL/HAL_AVR/math_AVR.h
+++ b/Marlin/src/HAL/HAL_AVR/math_AVR.h
@@ -1,9 +1,9 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
 * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * 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
@@ -19,7 +19,9 @@
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
-#pragma once
+
+#ifndef _MATH_AVR_H_
+#define _MATH_AVR_H_

 /**
 * Optimized math functions for AVR
@@ -36,9 +38,9 @@
 // D C B A is longIn2
 //
 static FORCE_INLINE uint16_t MultiU24X32toH16(uint32_t longIn1, uint32_t longIn2) {
-  uint8_t tmp1;
-  uint8_t tmp2;
-  uint16_t intRes;
+  register uint8_t tmp1;
+  register uint8_t tmp2;
+  register uint16_t intRes;
  __asm__ __volatile__(
    A("clr %[tmp1]")
    A("mul %A[longIn1], %B[longIn2]")
@@ -90,8 +92,8 @@ static FORCE_INLINE uint16_t MultiU24X32toH16(uint32_t longIn1, uint32_t longIn2
 // r26 to store 0
 // r27 to store the byte 1 of the 24 bit result
 static FORCE_INLINE uint16_t MultiU16X8toH16(uint8_t charIn1, uint16_t intIn2) {
-  uint8_t tmp;
-  uint16_t intRes;
+  register uint8_t tmp;
+  register uint16_t intRes;
  __asm__ __volatile__ (
    A("clr %[tmp]")
    A("mul %[charIn1], %B[intIn2]")
@@ -111,3 +113,5 @@ static FORCE_INLINE uint16_t MultiU16X8toH16(uint8_t charIn1, uint16_t intIn2) {
  );
  return intRes;
 }
+
+#endif // _MATH_AVR_H_
--- a/Marlin/src/HAL/HAL_AVR/persistent_store_eeprom.cpp
+++ b/Marlin/src/HAL/HAL_AVR/persistent_store_eeprom.cpp
@@ -1,9 +1,9 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (C) 2016, 2017 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
 * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * 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
@@ -23,7 +23,7 @@

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

-#if EITHER(EEPROM_SETTINGS, SD_FIRMWARE_UPDATE)
+#if ENABLED(EEPROM_SETTINGS)

 #include "../shared/persistent_store_api.h"

@@ -39,7 +39,8 @@ bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, ui
    if (v != eeprom_read_byte(p)) {
      eeprom_write_byte(p, v);
      if (eeprom_read_byte(p) != v) {
-        SERIAL_ECHO_MSG(STR_ERR_EEPROM_WRITE);
+        SERIAL_ECHO_START();
+        SERIAL_ECHOLNPGM(MSG_ERR_EEPROM_WRITE);
        return true;
      }
    }
@@ -52,7 +53,7 @@ bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, ui

 bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
  do {
-    uint8_t c = eeprom_read_byte((uint8_t*)pos);
+    uint8_t c = eeprom_read_byte((unsigned char*)pos);
    if (writing) *value = c;
    crc16(crc, &c, 1);
    pos++;
@@ -63,5 +64,5 @@ bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t

 size_t PersistentStore::capacity() { return E2END + 1; }

-#endif // EEPROM_SETTINGS || SD_FIRMWARE_UPDATE
+#endif // EEPROM_SETTINGS
 #endif // __AVR__
--- a/Marlin/src/HAL/HAL_AVR/pinsDebug.h
+++ b/Marlin/src/HAL/HAL_AVR/pinsDebug.h
@@ -1,6 +1,9 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (C) 2016, 2017 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
@@ -16,20 +19,19 @@
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
-#pragma once

 /**
 * PWM print routines for Atmel 8 bit AVR CPUs
 */

+#ifndef _PINSDEBUG_AVR_8_BIT_
+#define _PINSDEBUG_AVR_8_BIT_
+
 #include "../../inc/MarlinConfig.h"

 #define NUMBER_PINS_TOTAL NUM_DIGITAL_PINS

-#define AVR_ATmega2560_FAMILY_PLUS_70 MB(BQ_ZUM_MEGA_3D, MIGHTYBOARD_REVE, MINIRAMBO, SCOOVO_X9H)
-
 #if AVR_AT90USB1286_FAMILY
-
  // Working with Teensyduino extension so need to re-define some things
  #include "pinsDebug_Teensyduino.h"
  // Can't use the "digitalPinToPort" function from the Teensyduino type IDEs
@@ -38,9 +40,7 @@
  #define digitalPinToBitMask_DEBUG(p) digitalPinToBitMask(p)
  #define digitalPinToPort_DEBUG(p) digitalPinToPort_Teensy(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)
@@ -48,13 +48,11 @@
  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 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 VALID_PIN(pin) (pin >= 0 && pin < NUM_DIGITAL_PINS ? 1 : 0)
@@ -70,12 +68,12 @@

 void PRINT_ARRAY_NAME(uint8_t x) {
  char *name_mem_pointer = (char*)pgm_read_ptr(&pin_array[x].name);
-  LOOP_L_N(y, MAX_NAME_LENGTH) {
+  for (uint8_t y = 0; y < MAX_NAME_LENGTH; y++) {
    char temp_char = pgm_read_byte(name_mem_pointer + y);
    if (temp_char != 0)
      SERIAL_CHAR(temp_char);
    else {
-      LOOP_L_N(i, MAX_NAME_LENGTH - y) SERIAL_CHAR(' ');
+      for (uint8_t i = 0; i < MAX_NAME_LENGTH - y; i++) SERIAL_CHAR(' ');
      break;
    }
  }
@@ -154,7 +152,7 @@ static bool pwm_status(uint8_t pin) {
    default:
      return false;
  }
-  SERIAL_ECHO_SP(2);
+  SERIAL_PROTOCOL_SP(2);
 } // pwm_status


@@ -226,16 +224,26 @@ const volatile uint8_t* const PWM_OCR[][3] PROGMEM = {

 #define OCR_VAL(T, L)   pgm_read_word(&PWM_OCR[T][L])

-static void err_is_counter()     { SERIAL_ECHOPGM("   non-standard PWM mode"); }
-static void err_is_interrupt()   { SERIAL_ECHOPGM("   compare interrupt enabled"); }
-static void err_prob_interrupt() { SERIAL_ECHOPGM("   overflow interrupt enabled"); }
-static void print_is_also_tied() { SERIAL_ECHOPGM(" is also tied to this pin"); SERIAL_ECHO_SP(14); }
+static void err_is_counter()     { SERIAL_PROTOCOLPGM("   non-standard PWM mode"); }
+static void err_is_interrupt()   { SERIAL_PROTOCOLPGM("   compare interrupt enabled"); }
+static void err_prob_interrupt() { SERIAL_PROTOCOLPGM("   overflow interrupt enabled"); }
+static void print_is_also_tied() { SERIAL_PROTOCOLPGM(" is also tied to this pin"); SERIAL_PROTOCOL_SP(14); }

-inline void com_print(const uint8_t N, const uint8_t Z) {
+void com_print(uint8_t N, uint8_t Z) {
  const uint8_t *TCCRA = (uint8_t*)TCCR_A(N);
-  SERIAL_ECHOPGM("    COM");
-  SERIAL_CHAR('0' + N, Z);
-  SERIAL_ECHOPAIR(": ", int((*TCCRA >> (6 - Z * 2)) & 0x03));
+  SERIAL_PROTOCOLPGM("    COM");
+  SERIAL_PROTOCOLCHAR(N + '0');
+  switch (Z) {
+    case 'A':
+      SERIAL_PROTOCOLPAIR("A: ", ((*TCCRA & (_BV(7) | _BV(6))) >> 6));
+      break;
+    case 'B':
+      SERIAL_PROTOCOLPAIR("B: ", ((*TCCRA & (_BV(5) | _BV(4))) >> 4));
+      break;
+    case 'C':
+      SERIAL_PROTOCOLPAIR("C: ", ((*TCCRA & (_BV(3) | _BV(2))) >> 2));
+      break;
+  }
 }

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

-  SERIAL_ECHOPGM("    TIMER");
-  SERIAL_CHAR(T + '0', L);
-  SERIAL_ECHO_SP(3);
+  SERIAL_PROTOCOLPGM("    TIMER");
+  SERIAL_PROTOCOLCHAR(T + '0');
+  SERIAL_PROTOCOLCHAR(L);
+  SERIAL_PROTOCOL_SP(3);

  if (N == 3) {
    const uint8_t *OCRVAL8 = (uint8_t*)OCR_VAL(T, L - 'A');
@@ -257,22 +266,22 @@ void timer_prefix(uint8_t T, char L, uint8_t N) {  // T - timer    L - pwm  N -
    const uint16_t *OCRVAL16 = (uint16_t*)OCR_VAL(T, L - 'A');
    PWM_PRINT(*OCRVAL16);
  }
-  SERIAL_ECHOPAIR("    WGM: ", WGM);
+  SERIAL_PROTOCOLPAIR("    WGM: ", WGM);
  com_print(T,L);
-  SERIAL_ECHOPAIR("    CS: ", (*TCCRB & (_BV(CS_0) | _BV(CS_1) | _BV(CS_2)) ));
+  SERIAL_PROTOCOLPAIR("    CS: ", (*TCCRB & (_BV(CS_0) | _BV(CS_1) | _BV(CS_2)) ));

-  SERIAL_ECHOPGM("    TCCR");
-  SERIAL_CHAR(T + '0');
-  SERIAL_ECHOPAIR("A: ", *TCCRA);
+  SERIAL_PROTOCOLPGM("    TCCR");
+  SERIAL_PROTOCOLCHAR(T + '0');
+  SERIAL_PROTOCOLPAIR("A: ", *TCCRA);

-  SERIAL_ECHOPGM("    TCCR");
-  SERIAL_CHAR(T + '0');
-  SERIAL_ECHOPAIR("B: ", *TCCRB);
+  SERIAL_PROTOCOLPGM("    TCCR");
+  SERIAL_PROTOCOLCHAR(T + '0');
+  SERIAL_PROTOCOLPAIR("B: ", *TCCRB);

  const uint8_t *TMSK = (uint8_t*)TIMSK(T);
-  SERIAL_ECHOPGM("    TIMSK");
-  SERIAL_CHAR(T + '0');
-  SERIAL_ECHOPAIR(": ", *TMSK);
+  SERIAL_PROTOCOLPGM("    TIMSK");
+  SERIAL_PROTOCOLCHAR(T + '0');
+  SERIAL_PROTOCOLPAIR(": ", *TMSK);

  const uint8_t OCIE = L - 'A' + 1;
  if (N == 3) { if (WGM == 0 || WGM == 2 || WGM ==  4 || WGM ==  6) err_is_counter(); }
@@ -329,28 +338,26 @@ static void pwm_details(uint8_t pin) {
    case NOT_ON_TIMER: break;

  }
-  SERIAL_ECHOPGM("  ");
+  SERIAL_PROTOCOLPGM("  ");

  // on pins that have two PWMs, print info on second PWM
  #if AVR_ATmega2560_FAMILY || AVR_AT90USB1286_FAMILY
    // looking for port B7 - PWMs 0A and 1C
    if (digitalPinToPort_DEBUG(pin) == 'B' - 64 && 0x80 == digitalPinToBitMask_DEBUG(pin)) {
      #if !AVR_AT90USB1286_FAMILY
-        SERIAL_ECHOPGM("\n .");
-        SERIAL_ECHO_SP(18);
-        SERIAL_ECHOPGM("TIMER1C");
+        SERIAL_PROTOCOLPGM("\n .");
+        SERIAL_PROTOCOL_SP(18);
+        SERIAL_PROTOCOLPGM("TIMER1C");
        print_is_also_tied();
        timer_prefix(1, 'C', 4);
      #else
-        SERIAL_ECHOPGM("\n .");
-        SERIAL_ECHO_SP(18);
-        SERIAL_ECHOPGM("TIMER0A");
+        SERIAL_PROTOCOLPGM("\n .");
+        SERIAL_PROTOCOL_SP(18);
+        SERIAL_PROTOCOLPGM("TIMER0A");
        print_is_also_tied();
        timer_prefix(0, 'A', 3);
      #endif
    }
-  #else
-    UNUSED(print_is_also_tied);
  #endif
 } // pwm_details

@@ -367,7 +374,7 @@ static void pwm_details(uint8_t pin) {
  void print_port(int8_t pin) {   // print port number
    #ifdef digitalPinToPort_DEBUG
      uint8_t x;
-      SERIAL_ECHOPGM("  Port: ");
+      SERIAL_PROTOCOLPGM("  Port: ");
      #if AVR_AT90USB1286_FAMILY
        x = (pin == 46 || pin == 47) ? 'E' : digitalPinToPort_DEBUG(pin) + 64;
      #else
@@ -390,7 +397,7 @@ static void pwm_details(uint8_t pin) {
      #endif
      SERIAL_CHAR(x);
    #else
-      SERIAL_ECHO_SP(10);
+      SERIAL_PROTOCOL_SP(10);
    #endif
  }

@@ -398,4 +405,6 @@ static void pwm_details(uint8_t pin) {

 #endif

-#define PRINT_PIN(p) do{ sprintf_P(buffer, PSTR("%3d "), p); SERIAL_ECHO(buffer); }while(0)
+#define PRINT_PIN(p) do {sprintf_P(buffer, PSTR("%3d "), p); SERIAL_ECHO(buffer);} while (0)
+
+#endif // _PINSDEBUG_AVR_8_BIT_
--- a/Marlin/src/HAL/HAL_AVR/pinsDebug_Teensyduino.h
+++ b/Marlin/src/HAL/HAL_AVR/pinsDebug_Teensyduino.h
@@ -1,6 +1,9 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (C) 2017 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
@@ -16,7 +19,9 @@
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
-#pragma once
+
+#ifndef _PINSDEBUG_TEENSYSUINO_H_
+#define _PINSDEBUG_TEENSYSUINO_H_

 //
 //  some of the pin mapping functions of the Teensduino extension to the Arduino IDE
@@ -102,7 +107,9 @@ 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
-                                                // disable the PWMs so we can use it as is
+#define digitalRead_mod(p)  digitalRead(p)   // Teensyduino's version of digitalRead doesn't
+                                             // disable the PWMs so we can use it as is

 // portModeRegister(pin) is OK
+
+#endif // _PINSDEBUG_TEENSYSUINO_H_
--- a/Marlin/src/HAL/HAL_AVR/pinsDebug_plus_70.h
+++ b/Marlin/src/HAL/HAL_AVR/pinsDebug_plus_70.h
@@ -1,6 +1,10 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (C) 2017 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * 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
@@ -16,12 +20,14 @@
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
-#pragma once

 /**
 * Structures for 2560 family boards that use more than 70 pins
 */

+#ifndef _PINSDEBUG_PLUS_70_H_
+#define _PINSDEBUG_PLUS_70_H_
+
 #undef NUM_DIGITAL_PINS
 #if MB(BQ_ZUM_MEGA_3D)
  #define NUM_DIGITAL_PINS            85
@@ -47,7 +53,7 @@

 const uint8_t PROGMEM digital_pin_to_port_PGM_plus_70[] = {
  // PORTLIST
-  // ------------------------
+  // -------------------------------------------
  PE  , // PE 0 ** 0 ** USART0_RX
  PE  , // PE 1 ** 1 ** USART0_TX
  PE  , // PE 4 ** 2 ** PWM2
@@ -140,7 +146,7 @@ const uint8_t PROGMEM digital_pin_to_port_PGM_plus_70[] = {

 const uint8_t PROGMEM digital_pin_to_bit_mask_PGM_plus_70[] = {
  // PIN IN PORT
-  // ------------------------
+  // -------------------------------------------
  _BV( 0 )  , // PE 0 ** 0 ** USART0_RX
  _BV( 1 )  , // PE 1 ** 1 ** USART0_TX
  _BV( 4 )  , // PE 4 ** 2 ** PWM2
@@ -234,7 +240,7 @@ const uint8_t PROGMEM digital_pin_to_bit_mask_PGM_plus_70[] = {

 const uint8_t PROGMEM digital_pin_to_timer_PGM_plus_70[] = {
  // TIMERS
-  // ------------------------
+  // -------------------------------------------
  NOT_ON_TIMER  , // PE 0 ** 0 ** USART0_RX
  NOT_ON_TIMER  , // PE 1 ** 1 ** USART0_TX
  TIMER3B , // PE 4 ** 2 ** PWM2
@@ -330,3 +336,6 @@ const uint8_t PROGMEM digital_pin_to_timer_PGM_plus_70[] = {
 *  PCINT14 J5 76
 *  PCINT15 J6 77
 */
+
+
+#endif // _PINSDEBUG_PLUS_70_H_
--- a/Marlin/src/HAL/HAL_AVR/servo_AVR.cpp
+++ b/Marlin/src/HAL/HAL_AVR/servo_AVR.cpp
@@ -1,9 +1,9 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
 * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * 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
@@ -58,8 +58,8 @@
 #if HAS_SERVOS

 #include <avr/interrupt.h>
+#include <Arduino.h>

-#include "../shared/Marduino.h"
 #include "../shared/servo.h"
 #include "../shared/servo_private.h"

@@ -73,14 +73,14 @@ static inline void handle_interrupts(timer16_Sequence_t timer, volatile uint16_t
    *TCNTn = 0; // channel set to -1 indicated that refresh interval completed so reset the timer
  else {
    if (SERVO_INDEX(timer, Channel[timer]) < ServoCount && SERVO(timer, Channel[timer]).Pin.isActive)
-      extDigitalWrite(SERVO(timer, Channel[timer]).Pin.nbr, LOW); // pulse this channel low if activated
+      digitalWrite(SERVO(timer, Channel[timer]).Pin.nbr, LOW); // pulse this channel low if activated
  }

  Channel[timer]++;    // increment to the next channel
  if (SERVO_INDEX(timer, Channel[timer]) < ServoCount && Channel[timer] < SERVOS_PER_TIMER) {
    *OCRnA = *TCNTn + SERVO(timer, Channel[timer]).ticks;
    if (SERVO(timer, Channel[timer]).Pin.isActive)    // check if activated
-      extDigitalWrite(SERVO(timer, Channel[timer]).Pin.nbr, HIGH); // it's an active channel so pulse it high
+      digitalWrite(SERVO(timer, Channel[timer]).Pin.nbr, HIGH); // it's an active channel so pulse it high
  }
  else {
    // finished all channels so wait for the refresh period to expire before starting over
@@ -95,29 +95,29 @@ static inline void handle_interrupts(timer16_Sequence_t timer, volatile uint16_t
 #ifndef WIRING // Wiring pre-defines signal handlers so don't define any if compiling for the Wiring platform

  // Interrupt handlers for Arduino
-  #ifdef _useTimer1
+  #if ENABLED(_useTimer1)
    SIGNAL(TIMER1_COMPA_vect) { handle_interrupts(_timer1, &TCNT1, &OCR1A); }
  #endif

-  #ifdef _useTimer3
+  #if ENABLED(_useTimer3)
    SIGNAL(TIMER3_COMPA_vect) { handle_interrupts(_timer3, &TCNT3, &OCR3A); }
  #endif

-  #ifdef _useTimer4
+  #if ENABLED(_useTimer4)
    SIGNAL(TIMER4_COMPA_vect) { handle_interrupts(_timer4, &TCNT4, &OCR4A); }
  #endif

-  #ifdef _useTimer5
+  #if ENABLED(_useTimer5)
    SIGNAL(TIMER5_COMPA_vect) { handle_interrupts(_timer5, &TCNT5, &OCR5A); }
  #endif

 #else // WIRING

  // Interrupt handlers for Wiring
-  #ifdef _useTimer1
+  #if ENABLED(_useTimer1)
    void Timer1Service() { handle_interrupts(_timer1, &TCNT1, &OCR1A); }
  #endif
-  #ifdef _useTimer3
+  #if ENABLED(_useTimer3)
    void Timer3Service() { handle_interrupts(_timer3, &TCNT3, &OCR3A); }
  #endif

@@ -126,12 +126,12 @@ static inline void handle_interrupts(timer16_Sequence_t timer, volatile uint16_t
 /****************** end of static functions ******************************/

 void initISR(timer16_Sequence_t timer) {
-  #ifdef _useTimer1
+  #if ENABLED(_useTimer1)
    if (timer == _timer1) {
      TCCR1A = 0;             // normal counting mode
      TCCR1B = _BV(CS11);     // set prescaler of 8
      TCNT1 = 0;              // clear the timer count
-      #if defined(__AVR_ATmega8__) || defined(__AVR_ATmega128__)
+      #if defined(__AVR_ATmega8__)|| defined(__AVR_ATmega128__)
        SBI(TIFR, OCF1A);      // clear any pending interrupts;
        SBI(TIMSK, OCIE1A);    // enable the output compare interrupt
      #else
@@ -145,7 +145,7 @@ void initISR(timer16_Sequence_t timer) {
    }
  #endif

-  #ifdef _useTimer3
+  #if ENABLED(_useTimer3)
    if (timer == _timer3) {
      TCCR3A = 0;             // normal counting mode
      TCCR3B = _BV(CS31);     // set prescaler of 8
@@ -163,7 +163,7 @@ void initISR(timer16_Sequence_t timer) {
    }
  #endif

-  #ifdef _useTimer4
+  #if ENABLED(_useTimer4)
    if (timer == _timer4) {
      TCCR4A = 0;             // normal counting mode
      TCCR4B = _BV(CS41);     // set prescaler of 8
@@ -173,7 +173,7 @@ void initISR(timer16_Sequence_t timer) {
    }
  #endif

-  #ifdef _useTimer5
+  #if ENABLED(_useTimer5)
    if (timer == _timer5) {
      TCCR5A = 0;             // normal counting mode
      TCCR5B = _BV(CS51);     // set prescaler of 8
--- a/Marlin/src/HAL/HAL_AVR/spi_pins.h
+++ b/Marlin/src/HAL/HAL_AVR/spi_pins.h
@@ -1,9 +1,9 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
 * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * 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
@@ -19,7 +19,9 @@
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
-#pragma once
+
+#ifndef _SPI_PINS_H_
+#define _SPI_PINS_H_

 /**
 * Define SPI Pins: SCK, MISO, MOSI, SS
@@ -63,3 +65,6 @@
 #ifndef SS_PIN
  #define SS_PIN   AVR_SS_PIN
 #endif
+
+
+#endif // _SPI_PINS_H_
--- a/Marlin/src/HAL/HAL_AVR/watchdog_AVR.cpp
+++ b/Marlin/src/HAL/HAL_AVR/watchdog_AVR.cpp
@@ -1,9 +1,9 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
 * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * 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
@@ -26,9 +26,9 @@

 #if ENABLED(USE_WATCHDOG)

-#include "watchdog.h"
+#include "watchdog_AVR.h"

-#include "../../MarlinCore.h"
+#include "../../Marlin.h"

 // Initialize watchdog with 8s timeout, if possible. Otherwise, make it 4s.
 void watchdog_init() {
@@ -38,7 +38,7 @@ void watchdog_init() {
    #define WDTO_NS WDTO_4S
  #endif
  #if ENABLED(WATCHDOG_RESET_MANUAL)
-    // Enable the watchdog timer, but only for the interrupt.
+    // We enable the watchdog timer, but only for the interrupt.
    // Take care, as this requires the correct order of operation, with interrupts disabled.
    // See the datasheet of any AVR chip for details.
    wdt_reset();
@@ -62,10 +62,12 @@ void watchdog_init() {
 #if ENABLED(WATCHDOG_RESET_MANUAL)
  ISR(WDT_vect) {
    sei();  // With the interrupt driven serial we need to allow interrupts.
-    SERIAL_ERROR_MSG(STR_WATCHDOG_FIRED);
-    minkill();  // interrupt-safe final kill and infinite loop
+    SERIAL_ERROR_START();
+    SERIAL_ERRORLNPGM("Watchdog barked, please turn off the printer.");
+    kill(PSTR("ERR:Watchdog")); //kill blocks //up to 16 characters so it fits on a 16x2 display
+    while (1); //wait for user or serial reset
  }
-#endif
+#endif // WATCHDOG_RESET_MANUAL

 #endif // USE_WATCHDOG
 #endif // __AVR__
--- a/Marlin/src/HAL/HAL_AVR/watchdog_AVR.h
+++ b/Marlin/src/HAL/HAL_AVR/watchdog_AVR.h
@@ -1,9 +1,9 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
 * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * 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
@@ -19,7 +19,9 @@
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
-#pragma once
+
+#ifndef _WATCHDOG_AVR_H_
+#define _WATCHDOG_AVR_H_

 #include <avr/wdt.h>

@@ -28,4 +30,6 @@ void watchdog_init();

 // Reset watchdog. MUST be called at least every 4 seconds after the
 // first watchdog_init or AVR will go into emergency procedures.
-inline void HAL_watchdog_refresh() { wdt_reset(); }
+inline void watchdog_reset() { wdt_reset(); }
+
+#endif // _WATCHDOG_AVR_H_
--- a/Marlin/src/HAL/HAL_DUE/DebugMonitor_Due.cpp
+++ b/Marlin/src/HAL/HAL_DUE/DebugMonitor_Due.cpp
@@ -1,9 +1,9 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
 * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * 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
@@ -24,12 +24,11 @@

 #include "../../core/macros.h"
 #include "../../core/serial.h"
+#include <stdarg.h>

 #include "../shared/backtrace/unwinder.h"
 #include "../shared/backtrace/unwmemaccess.h"

-#include <stdarg.h>
-
 // Debug monitor that dumps to the Programming port all status when
 // an exception or WDT timeout happens - And then resets the board

@@ -42,7 +41,7 @@
 #define sw_barrier() __asm__ volatile("": : :"memory");

 // (re)initialize UART0 as a monitor output to 250000,n,8,1
-static void TXBegin() {
+static void TXBegin(void) {

  // Disable UART interrupt in NVIC
  NVIC_DisableIRQ( UART_IRQn );
@@ -146,8 +145,8 @@ static const UnwindCallbacks UnwCallbacks = {
  UnwReadW,
  UnwReadH,
  UnwReadB
-  #ifdef UNW_DEBUG
-   , UnwPrintf
+  #if defined(UNW_DEBUG)
+   ,UnwPrintf
  #endif
 };

@@ -235,7 +234,7 @@ void HardFault_HandlerC(unsigned long *sp, unsigned long lr, unsigned long cause
  for (;;) WDT_Restart(WDT);
 }

-__attribute__((naked)) void NMI_Handler() {
+__attribute__((naked)) void NMI_Handler(void) {
  __asm__ __volatile__ (
    ".syntax unified" "\n\t"
    A("tst lr, #4")
@@ -248,7 +247,7 @@ __attribute__((naked)) void NMI_Handler() {
  );
 }

-__attribute__((naked)) void HardFault_Handler() {
+__attribute__((naked)) void HardFault_Handler(void) {
  __asm__ __volatile__ (
    ".syntax unified" "\n\t"
    A("tst lr, #4")
@@ -261,7 +260,7 @@ __attribute__((naked)) void HardFault_Handler() {
  );
 }

-__attribute__((naked)) void MemManage_Handler() {
+__attribute__((naked)) void MemManage_Handler(void) {
  __asm__ __volatile__ (
    ".syntax unified" "\n\t"
    A("tst lr, #4")
@@ -274,7 +273,7 @@ __attribute__((naked)) void MemManage_Handler() {
  );
 }

-__attribute__((naked)) void BusFault_Handler() {
+__attribute__((naked)) void BusFault_Handler(void) {
  __asm__ __volatile__ (
    ".syntax unified" "\n\t"
    A("tst lr, #4")
@@ -287,7 +286,7 @@ __attribute__((naked)) void BusFault_Handler() {
  );
 }

-__attribute__((naked)) void UsageFault_Handler() {
+__attribute__((naked)) void UsageFault_Handler(void) {
  __asm__ __volatile__ (
    ".syntax unified" "\n\t"
    A("tst lr, #4")
@@ -300,7 +299,7 @@ __attribute__((naked)) void UsageFault_Handler() {
  );
 }

-__attribute__((naked)) void DebugMon_Handler() {
+__attribute__((naked)) void DebugMon_Handler(void) {
  __asm__ __volatile__ (
    ".syntax unified" "\n\t"
    A("tst lr, #4")
@@ -314,7 +313,7 @@ __attribute__((naked)) void DebugMon_Handler() {
 }

 /* This is NOT an exception, it is an interrupt handler - Nevertheless, the framing is the same */
-__attribute__((naked)) void WDT_Handler() {
+__attribute__((naked)) void WDT_Handler(void) {
  __asm__ __volatile__ (
    ".syntax unified" "\n\t"
    A("tst lr, #4")
@@ -327,7 +326,7 @@ __attribute__((naked)) void WDT_Handler() {
  );
 }

-__attribute__((naked)) void RSTC_Handler() {
+__attribute__((naked)) void RSTC_Handler(void) {
  __asm__ __volatile__ (
    ".syntax unified" "\n\t"
    A("tst lr, #4")
--- a/Marlin/src/HAL/HAL_DUE/EepromEmulation_Due.cpp
+++ b/Marlin/src/HAL/HAL_DUE/EepromEmulation_Due.cpp
@@ -1,24 +1,3 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */

 /* EEPROM emulation over flash with reduced wear
 *
@@ -52,17 +31,17 @@

 #ifdef ARDUINO_ARCH_SAM

+#include "../shared/persistent_store_api.h"
 #include "../../inc/MarlinConfig.h"

-#if ENABLED(FLASH_EEPROM_EMULATION)
+#if ENABLED(EEPROM_SETTINGS) && DISABLED(I2C_EEPROM) && DISABLED(SPI_EEPROM)

-#include "../shared/Marduino.h"
-#include "../shared/persistent_store_api.h"
+#include <Arduino.h>

 #define EEPROMSize     4096
 #define PagesPerGroup   128
 #define GroupCount        2
-#define PageSize        256u
+#define PageSize        256

 /* Flash storage */
 typedef struct FLASH_SECTOR {
@@ -130,9 +109,9 @@ static const FLASH_SECTOR_T* getFlashStorage(int page) {
  return (const FLASH_SECTOR_T*)&flashStorage[page*PageSize];
 }

-static uint8_t buffer[256] = {0},   // The RAM buffer to accumulate writes
-               curPage = 0,         // Current FLASH page inside the group
-               curGroup = 0xFF;     // Current FLASH group
+static uint8_t buffer[256] = {0};   // The RAM buffer to accumulate writes
+static uint8_t curPage = 0;         // Current FLASH page inside the group
+static uint8_t curGroup = 0xFF;     // Current FLASH group

 //#define EE_EMU_DEBUG
 #ifdef EE_EMU_DEBUG
@@ -141,18 +120,20 @@ static uint8_t buffer[256] = {0},   // The RAM buffer to accumulate writes
    const uint8_t* c = (const uint8_t*) data;
    char buffer[80];

-    sprintf_P(buffer, PSTR("Page: %d (0x%04x)\n"), page, page);
-    SERIAL_ECHO(buffer);
+    sprintf(buffer, "Page: %d (0x%04x)\n", page, page);
+    SERIAL_PROTOCOL(buffer);

    char* p = &buffer[0];
    for (int i = 0; i< PageSize; ++i) {
-      if ((i & 0xF) == 0) p += sprintf_P(p, PSTR("%04x] "), i);
+      if ((i & 15) == 0) {
+        p += sprintf(p,"%04x] ",i);
+      }

-      p += sprintf_P(p, PSTR(" %02x"), c[i]);
-      if ((i & 0xF) == 0xF) {
+      p += sprintf(p," %02x",c[i]);
+      if ((i & 15) == 15) {
        *p++ = '\n';
        *p = 0;
-        SERIAL_ECHO(buffer);
+        SERIAL_PROTOCOL(buffer);
        p = &buffer[0];
      }
    }
@@ -179,7 +160,7 @@ static uint8_t buffer[256] = {0},   // The RAM buffer to accumulate writes
 __attribute__ ((long_call, section (".ramfunc")))
 static bool ee_PageWrite(uint16_t page,const void* data) {

-  uint16_t i;
+  int i;
  uint32_t addrflash = ((uint32_t)getFlashStorage(page));

  // Read the flash contents
@@ -192,14 +173,15 @@ static bool ee_PageWrite(uint16_t page,const void* data) {
  // Programming mode works only with 128-bit (or higher) boundaries. It cannot
  // be used with boundaries lower than 128 bits (8, 16 or 32-bit for example)."
  // All bits that did not change, set them to 1.
-  for (i = 0; i <PageSize >> 2; i++)
+  for (i = 0; i <PageSize >> 2; i++) {
    pageContents[i] = (((uint32_t*)data)[i]) | (~(pageContents[i] ^ ((uint32_t*)data)[i]));
+  }

  #ifdef EE_EMU_DEBUG
    SERIAL_ECHO_START();
-    SERIAL_ECHOLNPAIR("EEPROM PageWrite   ", page);
-    SERIAL_ECHOLNPAIR(" in FLASH address ", (uint32_t)addrflash);
-    SERIAL_ECHOLNPAIR(" base address     ", (uint32_t)getFlashStorage(0));
+    SERIAL_ECHOLNPAIR("EEPROM PageWrite   ",page);
+    SERIAL_ECHOLNPAIR(" in FLASH address ",(uint32_t)addrflash);
+    SERIAL_ECHOLNPAIR(" base address     ",(uint32_t)getFlashStorage(0));
    SERIAL_FLUSH();
  #endif

@@ -225,7 +207,7 @@ static bool ee_PageWrite(uint16_t page,const void* data) {
  uint32_t orgWS = (efc->EEFC_FMR & EEFC_FMR_FWS_Msk) >> EEFC_FMR_FWS_Pos;

  // Set wait states to 6 (SAM errata)
-  efc->EEFC_FMR = (efc->EEFC_FMR & (~EEFC_FMR_FWS_Msk)) | EEFC_FMR_FWS(6);
+  efc->EEFC_FMR = efc->EEFC_FMR & (~EEFC_FMR_FWS_Msk) | EEFC_FMR_FWS(6);

  // Unlock the flash page
  uint32_t status;
@@ -238,14 +220,14 @@ static bool ee_PageWrite(uint16_t page,const void* data) {
  if ((status & EEFC_ERROR_FLAGS) != 0) {

    // Restore original wait states
-    efc->EEFC_FMR = (efc->EEFC_FMR & (~EEFC_FMR_FWS_Msk)) | EEFC_FMR_FWS(orgWS);
+    efc->EEFC_FMR = efc->EEFC_FMR & (~EEFC_FMR_FWS_Msk) | EEFC_FMR_FWS(orgWS);

    // Reenable interrupts
    __enable_irq();

    #ifdef EE_EMU_DEBUG
      SERIAL_ECHO_START();
-      SERIAL_ECHOLNPAIR("EEPROM Unlock failure for page ", page);
+      SERIAL_ECHOLNPAIR("EEPROM Unlock failure for page ",page);
    #endif
    return false;
  }
@@ -265,20 +247,20 @@ static bool ee_PageWrite(uint16_t page,const void* data) {
  if ((status & EEFC_ERROR_FLAGS) != 0) {

    // Restore original wait states
-    efc->EEFC_FMR = (efc->EEFC_FMR & (~EEFC_FMR_FWS_Msk)) | EEFC_FMR_FWS(orgWS);
+    efc->EEFC_FMR = efc->EEFC_FMR & (~EEFC_FMR_FWS_Msk) | EEFC_FMR_FWS(orgWS);

    // Reenable interrupts
    __enable_irq();

    #ifdef EE_EMU_DEBUG
      SERIAL_ECHO_START();
-      SERIAL_ECHOLNPAIR("EEPROM Write failure for page ", page);
+      SERIAL_ECHOLNPAIR("EEPROM Write failure for page ",page);
    #endif
    return false;
  }

  // Restore original wait states
-  efc->EEFC_FMR = (efc->EEFC_FMR & (~EEFC_FMR_FWS_Msk)) | EEFC_FMR_FWS(orgWS);
+  efc->EEFC_FMR = efc->EEFC_FMR & (~EEFC_FMR_FWS_Msk) | EEFC_FMR_FWS(orgWS);

  // Reenable interrupts
  __enable_irq();
@@ -288,7 +270,7 @@ static bool ee_PageWrite(uint16_t page,const void* data) {

    #ifdef EE_EMU_DEBUG
      SERIAL_ECHO_START();
-      SERIAL_ECHOLNPAIR("EEPROM Verify Write failure for page ", page);
+      SERIAL_ECHOLNPAIR("EEPROM Verify Write failure for page ",page);

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

    return false;
@@ -323,7 +305,7 @@ static bool ee_PageWrite(uint16_t page,const void* data) {
 __attribute__ ((long_call, section (".ramfunc")))
 static bool ee_PageErase(uint16_t page) {

-  uint16_t i;
+  int i;
  uint32_t addrflash = ((uint32_t)getFlashStorage(page));

  #ifdef EE_EMU_DEBUG
@@ -356,7 +338,7 @@ static bool ee_PageErase(uint16_t page) {
  uint32_t orgWS = (efc->EEFC_FMR & EEFC_FMR_FWS_Msk) >> EEFC_FMR_FWS_Pos;

  // Set wait states to 6 (SAM errata)
-  efc->EEFC_FMR = (efc->EEFC_FMR & (~EEFC_FMR_FWS_Msk)) | EEFC_FMR_FWS(6);
+  efc->EEFC_FMR = efc->EEFC_FMR & (~EEFC_FMR_FWS_Msk) | EEFC_FMR_FWS(6);

  // Unlock the flash page
  uint32_t status;
@@ -368,7 +350,7 @@ static bool ee_PageErase(uint16_t page) {
  if ((status & EEFC_ERROR_FLAGS) != 0) {

    // Restore original wait states
-    efc->EEFC_FMR = (efc->EEFC_FMR & (~EEFC_FMR_FWS_Msk)) | EEFC_FMR_FWS(orgWS);
+    efc->EEFC_FMR = efc->EEFC_FMR & (~EEFC_FMR_FWS_Msk) | EEFC_FMR_FWS(orgWS);

    // Reenable interrupts
    __enable_irq();
@@ -393,7 +375,7 @@ static bool ee_PageErase(uint16_t page) {
  if ((status & EEFC_ERROR_FLAGS) != 0) {

    // Restore original wait states
-    efc->EEFC_FMR = (efc->EEFC_FMR & (~EEFC_FMR_FWS_Msk)) | EEFC_FMR_FWS(orgWS);
+    efc->EEFC_FMR = efc->EEFC_FMR & (~EEFC_FMR_FWS_Msk) | EEFC_FMR_FWS(orgWS);

    // Reenable interrupts
    __enable_irq();
@@ -406,7 +388,7 @@ static bool ee_PageErase(uint16_t page) {
  }

  // Restore original wait states
-  efc->EEFC_FMR = (efc->EEFC_FMR & (~EEFC_FMR_FWS_Msk)) | EEFC_FMR_FWS(orgWS);
+  efc->EEFC_FMR = efc->EEFC_FMR & (~EEFC_FMR_FWS_Msk) | EEFC_FMR_FWS(orgWS);

  // Reenable interrupts
  __enable_irq();
@@ -439,7 +421,7 @@ static uint8_t ee_Read(uint32_t address, bool excludeRAMBuffer = false) {

  // Check that the value is not contained in the RAM buffer
  if (!excludeRAMBuffer) {
-    uint16_t i = 0;
+    int i = 0;
    while (i <= (PageSize - 4)) { /* (PageSize - 4) because otherwise, there is not enough room for data and headers */

      // Get the address of the block
@@ -480,7 +462,7 @@ static uint8_t ee_Read(uint32_t address, bool excludeRAMBuffer = false) {
    // Get a pointer to the flash page
    uint8_t* pflash = (uint8_t*)getFlashStorage(page + curGroup * PagesPerGroup);

-    uint16_t i = 0;
+    int i = 0;
    while (i <= (PageSize - 4)) { /* (PageSize - 4) because otherwise, there is not enough room for data and headers */

      // Get the address of the block
@@ -494,13 +476,18 @@ static uint8_t ee_Read(uint32_t address, bool excludeRAMBuffer = false) {
        break;

      // Check if data is contained in this block
-      if (address >= baddr && address < (baddr + blen))
-        return pflash[i + 3 + address - baddr]; // Yes, it is contained. Return it!
+      if (address >= baddr &&
+        address < (baddr + blen)) {
+
+        // Yes, it is contained. Return it!
+        return pflash[i + 3 + address - baddr];
+      }

      // As blocks are always sorted, if the starting address of this block is higher
      // than the address we are looking for, break loop now - We wont find the value
      // associated to the address
-      if (baddr > address) break;
+      if (baddr > address)
+        break;

      // Jump to the next block
      i += 3 + blen;
@@ -512,14 +499,14 @@ static uint8_t ee_Read(uint32_t address, bool excludeRAMBuffer = false) {
 }

 static uint32_t ee_GetAddrRange(uint32_t address, bool excludeRAMBuffer = false) {
-  uint32_t baddr,
-           blen,
-           nextAddr = 0xFFFF,
-           nextRange = 0;
+  uint32_t baddr;
+  uint32_t blen;
+  uint32_t nextAddr = 0xFFFF;
+  uint32_t nextRange = 0;

  // Check that the value is not contained in the RAM buffer
  if (!excludeRAMBuffer) {
-    uint16_t i = 0;
+    int i = 0;
    while (i <= (PageSize - 4)) { /* (PageSize - 4) because otherwise, there is not enough room for data and headers */

      // Get the address of the block
@@ -529,11 +516,16 @@ static uint32_t ee_GetAddrRange(uint32_t address, bool excludeRAMBuffer = false)
      blen = buffer[i + 2];

      // If we reach the end of the list, break loop
-      if (blen == 0xFF) break;
+      if (blen == 0xFF)
+        break;

      // Check if address and address + 1 is contained in this block
-      if (address >= baddr && address < (baddr + blen))
-        return address | ((blen - address + baddr) << 16); // Yes, it is contained. Return it!
+      if (address >= baddr &&
+        address < (baddr + blen)) {
+
+        // Yes, it is contained. Return it!
+        return address | ((blen - address + baddr) << 16);
+      }

      // Otherwise, check if we can use it as a limit
      if (baddr > address && baddr < nextAddr) {
@@ -544,7 +536,8 @@ static uint32_t ee_GetAddrRange(uint32_t address, bool excludeRAMBuffer = false)
      // As blocks are always sorted, if the starting address of this block is higher
      // than the address we are looking for, break loop now - We wont find the value
      // associated to the address
-      if (baddr > address) break;
+      if (baddr > address)
+        break;

      // Jump to the next block
      i += 3 + blen;
@@ -560,7 +553,7 @@ static uint32_t ee_GetAddrRange(uint32_t address, bool excludeRAMBuffer = false)
    // Get a pointer to the flash page
    uint8_t* pflash = (uint8_t*)getFlashStorage(page + curGroup * PagesPerGroup);

-    uint16_t i = 0;
+    int i = 0;
    while (i <= (PageSize - 4)) { /* (PageSize - 4) because otherwise, there is not enough room for data and headers */

      // Get the address of the block
@@ -570,11 +563,16 @@ static uint32_t ee_GetAddrRange(uint32_t address, bool excludeRAMBuffer = false)
      blen = pflash[i + 2];

      // If we reach the end of the list, break loop
-      if (blen == 0xFF) break;
+      if (blen == 0xFF)
+        break;

      // Check if data is contained in this block
-      if (address >= baddr && address < (baddr + blen))
-        return address | ((blen - address + baddr) << 16); // Yes, it is contained. Return it!
+      if (address >= baddr &&
+        address < (baddr + blen)) {
+
+        // Yes, it is contained. Return it!
+        return address | ((blen - address + baddr) << 16);
+      }

      // Otherwise, check if we can use it as a limit
      if (baddr > address && baddr < nextAddr) {
@@ -585,7 +583,8 @@ static uint32_t ee_GetAddrRange(uint32_t address, bool excludeRAMBuffer = false)
      // As blocks are always sorted, if the starting address of this block is higher
      // than the address we are looking for, break loop now - We wont find the value
      // associated to the address
-      if (baddr > address) break;
+      if (baddr > address)
+        break;

      // Jump to the next block
      i += 3 + blen;
@@ -597,9 +596,12 @@ static uint32_t ee_GetAddrRange(uint32_t address, bool excludeRAMBuffer = false)
 }

 static bool ee_IsPageClean(int page) {
+
  uint32_t* pflash = (uint32_t*) getFlashStorage(page);
-  for (uint16_t i = 0; i < (PageSize >> 2); ++i)
-    if (*pflash++ != 0xFFFFFFFF) return false;
+  for (int i = 0; i < (PageSize >> 2); ++i) {
+    if (*pflash++ != 0xFFFFFFFF)
+      return false;
+  }
  return true;
 }

@@ -608,7 +610,7 @@ static bool ee_Flush(uint32_t overrideAddress = 0xFFFFFFFF, uint8_t overrideData
  // Check if RAM buffer has something to be written
  bool isEmpty = true;
  uint32_t* p = (uint32_t*) &buffer[0];
-  for (uint16_t j = 0; j < (PageSize >> 2); j++) {
+  for (int j = 0; j < (PageSize >> 2); j++) {
    if (*p++ != 0xFFFFFFFF) {
      isEmpty = false;
      break;
@@ -646,11 +648,13 @@ static bool ee_Flush(uint32_t overrideAddress = 0xFFFFFFFF, uint8_t overrideData
  }

  // We have no space left on the current group - We must compact the values
-  uint16_t i = 0;
+  int i = 0;

  // Compute the next group to use
-  int curwPage = 0, curwGroup = curGroup + 1;
-  if (curwGroup >= GroupCount) curwGroup = 0;
+  int curwPage = 0;
+  int curwGroup = curGroup + 1;
+  if (curwGroup >= GroupCount)
+    curwGroup = 0;

  uint32_t rdAddr = 0;
  do {
@@ -770,11 +774,12 @@ static bool ee_Flush(uint32_t overrideAddress = 0xFFFFFFFF, uint8_t overrideData
 static bool ee_Write(uint32_t address, uint8_t data) {

  // If we were requested an address outside of the emulated range, fail now
-  if (address >= EEPROMSize) return false;
+  if (address >= EEPROMSize)
+    return false;

  // Lets check if we have a block with that data previously defined. Block
  //  start addresses are always sorted in ascending order
-  uint16_t i = 0;
+  int i = 0;
  while (i <= (PageSize - 4)) { /* (PageSize - 4) because otherwise, there is not enough room for data and headers */

    // Get the address of the block
@@ -800,7 +805,8 @@ static bool ee_Write(uint32_t address, uint8_t data) {

    // Maybe we could add it to the front or to the back
    // of this block ?
-    if ((address + 1) == baddr || address == (baddr + blen)) {
+    if ((address + 1) == baddr ||
+      address == (baddr + blen)) {

      // Potentially, it could be done. But we must ensure there is room
      // so we can expand the block. Lets find how much free space remains
@@ -834,9 +840,9 @@ static bool ee_Write(uint32_t address, uint8_t data) {

          // Insert at the end - There is a very interesting thing that could happen here:
          //  Maybe we could coalesce the next block with this block. Let's try to do it!
-          uint16_t inext = i + 3 + blen;
+          int inext = i + 3 + blen;
          if (inext <= (PageSize - 4) &&
-            (buffer[inext] | uint16_t(buffer[inext + 1] << 8)) == (baddr + blen + 1)) {
+            (buffer[inext] | (buffer[inext + 1] << 8)) == (baddr + blen + 1)) {
            // YES! ... we can coalesce blocks! . Do it!

            // Adjust this block header to include the next one
@@ -873,7 +879,8 @@ static bool ee_Write(uint32_t address, uint8_t data) {
    // As blocks are always sorted, if the starting address of this block is higher
    // than the address we are looking for, break loop now - We wont find the value
    // associated to the address
-    if (baddr > address) break;
+    if (baddr > address)
+      break;

    // Jump to the next block
    i += 3 + blen;
@@ -917,17 +924,21 @@ static bool ee_Write(uint32_t address, uint8_t data) {
 static void ee_Init() {

  // Just init once!
-  if (curGroup != 0xFF) return;
+  if (curGroup != 0xFF)
+    return;

  // Clean up the SRAM buffer
  memset(buffer, 0xFF, sizeof(buffer));

  // Now, we must find out the group where settings are stored
-  for (curGroup = 0; curGroup < GroupCount; curGroup++)
-    if (!ee_IsPageClean(curGroup * PagesPerGroup)) break;
+  for (curGroup = 0; curGroup < GroupCount; curGroup++) {
+    if (!ee_IsPageClean(curGroup * PagesPerGroup))
+      break;
+  }

  // If all groups seem to be used, default to first group
-  if (curGroup >= GroupCount) curGroup = 0;
+  if (curGroup >= GroupCount)
+    curGroup = 0;

  #ifdef EE_EMU_DEBUG
    SERIAL_ECHO_START();
@@ -937,13 +948,15 @@ static void ee_Init() {

  // Now, validate that all the other group pages are empty
  for (int grp = 0; grp < GroupCount; grp++) {
-    if (grp == curGroup) continue;
+    if (grp == curGroup)
+      continue;

    for (int page = 0; page < PagesPerGroup; page++) {
      if (!ee_IsPageClean(grp * PagesPerGroup + page)) {
        #ifdef EE_EMU_DEBUG
          SERIAL_ECHO_START();
-          SERIAL_ECHOLNPAIR("EEPROM Page ", page, " not clean on group ", grp);
+          SERIAL_ECHOPAIR("EEPROM Page ",page);
+          SERIAL_ECHOLNPAIR(" not clean on group ",grp);
          SERIAL_FLUSH();
        #endif
        ee_PageErase(grp * PagesPerGroup + page);
@@ -964,7 +977,7 @@ static void ee_Init() {

  #ifdef EE_EMU_DEBUG
    SERIAL_ECHO_START();
-    SERIAL_ECHOLNPAIR("EEPROM Active page: ", curPage);
+    SERIAL_ECHOLNPAIR("EEPROM Active page: ",curPage);
    SERIAL_FLUSH();
  #endif

@@ -973,7 +986,8 @@ static void ee_Init() {
    if (!ee_IsPageClean(curGroup * PagesPerGroup + page)) {
      #ifdef EE_EMU_DEBUG
        SERIAL_ECHO_START();
-        SERIAL_ECHOLNPAIR("EEPROM Page ", page, " not clean on active group ", curGroup);
+        SERIAL_ECHOPAIR("EEPROM Page ",page);
+        SERIAL_ECHOLNPAIR(" not clean on active group ",curGroup);
        SERIAL_FLUSH();
        ee_Dump(curGroup * PagesPerGroup + page, getFlashStorage(curGroup * PagesPerGroup + page));
      #endif
@@ -1012,9 +1026,9 @@ void eeprom_read_block(void* __dst, const void* __src, size_t __n) {
  }
 }

-void eeprom_flush() {
+void eeprom_flush(void) {
  ee_Flush();
 }

-#endif // FLASH_EEPROM_EMULATION
-#endif // ARDUINO_ARCH_AVR
+#endif // ENABLED(EEPROM_SETTINGS) && DISABLED(I2C_EEPROM) && DISABLED(SPI_EEPROM)
+#endif // ARDUINO_ARCH_AVR
--- a/Marlin/src/HAL/HAL_DUE/HAL.cpp
+++ b/Marlin/src/HAL/HAL_DUE/HAL.cpp
@@ -0,0 +1,137 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * 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/>.
+ */
+
+/**
+ * Description: HAL for Arduino Due and compatible (SAM3X8E)
+ *
+ * For ARDUINO_ARCH_SAM
+ */
+
+#ifdef ARDUINO_ARCH_SAM
+
+// --------------------------------------------------------------------------
+// Includes
+// --------------------------------------------------------------------------
+
+#include "HAL.h"
+
+#include <Wire.h>
+#include "usb/usb_task.h"
+
+// --------------------------------------------------------------------------
+// Externals
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Local defines
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Types
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Variables
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Public Variables
+// --------------------------------------------------------------------------
+
+uint16_t HAL_adc_result;
+
+// --------------------------------------------------------------------------
+// Private Variables
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Function prototypes
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Private functions
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Public functions
+// --------------------------------------------------------------------------
+
+// HAL initialization task
+void HAL_init(void) {
+  // Initialize the USB stack
+  #if ENABLED(SDSUPPORT)
+    OUT_WRITE(SDSS, HIGH);  // Try to set SDSS inactive before any other SPI users start up
+  #endif
+  usb_task_init();
+}
+
+// HAL idle task
+void HAL_idletask(void) {
+  // Perform USB stack housekeeping
+  usb_task_idle();
+}
+
+// Disable interrupts
+void cli(void) { noInterrupts(); }
+
+// Enable interrupts
+void sei(void) { interrupts(); }
+
+void HAL_clear_reset_source(void) { }
+
+uint8_t HAL_get_reset_source(void) {
+  switch ((RSTC->RSTC_SR >> 8) & 0x07) {
+    case 0: return RST_POWER_ON;
+    case 1: return RST_BACKUP;
+    case 2: return RST_WATCHDOG;
+    case 3: return RST_SOFTWARE;
+    case 4: return RST_EXTERNAL;
+    default: return 0;
+  }
+}
+
+void _delay_ms(const int delay_ms) {
+  // Todo: port for Due?
+  delay(delay_ms);
+}
+
+extern "C" {
+  extern unsigned int _ebss; // 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 ? heap_end : (int)&_ebss);
+}
+
+// --------------------------------------------------------------------------
+// ADC
+// --------------------------------------------------------------------------
+
+void HAL_adc_start_conversion(const uint8_t adc_pin) {
+  HAL_adc_result = analogRead(adc_pin);
+}
+
+uint16_t HAL_adc_get_result(void) {
+  // nop
+  return HAL_adc_result;
+}
+
+#endif // ARDUINO_ARCH_SAM
--- a/Marlin/src/HAL/HAL_DUE/HAL.h
+++ b/Marlin/src/HAL/HAL_DUE/HAL.h
@@ -0,0 +1,185 @@
+/**
+ * Marlin 3D Printer Firmware
+ *
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
+ * Copyright (c) 2015-2016 Nico Tonnhofer wurstnase.reprap@gmail.com
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * 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/>.
+ *
+ */
+
+/**
+ * Description: HAL for Arduino Due and compatible (SAM3X8E)
+ *
+ * For ARDUINO_ARCH_SAM
+ */
+
+#ifndef _HAL_DUE_H
+#define _HAL_DUE_H
+
+#define CPU_32_BIT
+
+#include <stdint.h>
+
+#include <Arduino.h>
+
+#include "../shared/math_32bit.h"
+#include "../shared/HAL_SPI.h"
+#include "fastio_Due.h"
+#include "watchdog_Due.h"
+#include "HAL_timers_Due.h"
+
+//
+// Defines
+//
+#define NUM_SERIAL 1
+#define MYSERIAL0 customizedSerial
+
+// We need the previous define before the include, or compilation bombs...
+#include "MarlinSerial_Due.h"
+#include "MarlinSerialUSB_Due.h"
+
+#ifndef analogInputToDigitalPin
+  #define analogInputToDigitalPin(p) ((p < 12u) ? (p) + 54u : -1)
+#endif
+
+#define CRITICAL_SECTION_START  uint32_t primask = __get_PRIMASK(); __disable_irq()
+#define CRITICAL_SECTION_END    if (!primask) __enable_irq()
+#define ISRS_ENABLED() (!__get_PRIMASK())
+#define ENABLE_ISRS()  __enable_irq()
+#define DISABLE_ISRS() __disable_irq()
+
+// On AVR this is in math.h?
+#define square(x) ((x)*(x))
+
+#ifndef strncpy_P
+  #define strncpy_P(dest, src, num) strncpy((dest), (src), (num))
+#endif
+
+#ifndef vsnprintf_P
+  #define vsnprintf_P vsnprintf
+#endif
+
+// Fix bug in pgm_read_ptr
+#undef pgm_read_ptr
+#define pgm_read_ptr(addr) (*((void**)(addr)))
+#undef pgm_read_word
+#define pgm_read_word(addr) (*((uint16_t*)(addr)))
+
+#define RST_POWER_ON   1
+#define RST_EXTERNAL   2
+#define RST_BROWN_OUT  4
+#define RST_WATCHDOG   8
+#define RST_JTAG       16
+#define RST_SOFTWARE   32
+#define RST_BACKUP     64
+
+// --------------------------------------------------------------------------
+// Types
+// --------------------------------------------------------------------------
+
+typedef int8_t pin_t;
+
+#define HAL_SERVO_LIB Servo
+
+// --------------------------------------------------------------------------
+// Public Variables
+// --------------------------------------------------------------------------
+
+extern uint16_t HAL_adc_result;     // result of last ADC conversion
+
+void cli(void);                     // Disable interrupts
+void sei(void);                     // Enable interrupts
+
+void HAL_clear_reset_source(void);  // clear reset reason
+uint8_t HAL_get_reset_source(void); // get reset reason
+
+void _delay_ms(const int delay);
+
+int freeMemory(void);
+
+/**
+ * SPI: Extended functions taking a channel number (hardware SPI only)
+ */
+
+// Write single byte to specified SPI channel
+void spiSend(uint32_t chan, byte b);
+
+// Write buffer to specified SPI channel
+void spiSend(uint32_t chan, const uint8_t* buf, size_t n);
+
+// Read single byte from specified SPI channel
+uint8_t spiRec(uint32_t chan);
+
+/**
+ * EEPROM
+ */
+
+void eeprom_write_byte(unsigned char *pos, unsigned char value);
+unsigned char eeprom_read_byte(unsigned char *pos);
+void eeprom_read_block (void *__dst, const void *__src, size_t __n);
+void eeprom_update_block (const void *__src, void *__dst, size_t __n);
+
+/**
+ * ADC
+ */
+
+#define HAL_ANALOG_SELECT(pin)
+
+inline void HAL_adc_init(void) {}//todo
+
+#define HAL_START_ADC(pin)  HAL_adc_start_conversion(pin)
+#define HAL_READ_ADC()      HAL_adc_result
+#define HAL_ADC_READY()     true
+
+void HAL_adc_start_conversion(const uint8_t adc_pin);
+uint16_t HAL_adc_get_result(void);
+uint16_t HAL_getAdcReading(uint8_t chan);
+void HAL_startAdcConversion(uint8_t chan);
+uint8_t HAL_pinToAdcChannel(int pin);
+uint16_t HAL_getAdcFreerun(uint8_t chan, bool wait_for_conversion = false);
+//uint16_t HAL_getAdcSuperSample(uint8_t chan);
+void HAL_enable_AdcFreerun(void);
+//void HAL_disable_AdcFreerun(uint8_t chan);
+
+/**
+ * Pin Map
+ */
+#define GET_PIN_MAP_PIN(index) index
+#define GET_PIN_MAP_INDEX(pin) pin
+#define PARSED_PIN_INDEX(code, dval) parser.intval(code, dval)
+
+/**
+ * Tone
+ */
+void toneInit();
+void tone(const pin_t _pin, const unsigned int frequency, const unsigned long duration=0);
+void noTone(const pin_t _pin);
+
+// Enable hooks into idle and setup for HAL
+#define HAL_IDLETASK 1
+#define HAL_INIT 1
+void HAL_idletask(void);
+void HAL_init(void);
+
+#ifdef __cplusplus
+  extern "C" {
+#endif
+char *dtostrf (double __val, signed char __width, unsigned char __prec, char *__s);
+#ifdef __cplusplus
+  }
+#endif
+
+#endif // _HAL_DUE_H
--- a/Marlin/src/HAL/HAL_DUE/HAL_spi_Due.cpp
+++ b/Marlin/src/HAL/HAL_DUE/HAL_spi_Due.cpp
@@ -1,9 +1,9 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
 * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -22,7 +22,7 @@

 /**
 * Software SPI functions originally from Arduino Sd2Card Library
- * Copyright (c) 2009 by William Greiman
+ * Copyright (C) 2009 by William Greiman
 *
 * Completely rewritten and tuned by Eduardo José Tagle in 2017/2018
 * in ARM thumb2 inline assembler and tuned for maximum speed and performance
@@ -37,18 +37,27 @@

 #ifdef ARDUINO_ARCH_SAM

+// --------------------------------------------------------------------------
+// Includes
+// --------------------------------------------------------------------------
+
 #include "../../inc/MarlinConfig.h"
 #include "../shared/Delay.h"

-// ------------------------
+// --------------------------------------------------------------------------
+// Public Variables
+// --------------------------------------------------------------------------
+
+
+// --------------------------------------------------------------------------
 // Public functions
-// ------------------------
+// --------------------------------------------------------------------------

-#if EITHER(DUE_SOFTWARE_SPI, FORCE_SOFT_SPI)
+#if ENABLED(DUE_SOFTWARE_SPI)

-  // ------------------------
-  // Software SPI
-  // ------------------------
+  // --------------------------------------------------------------------------
+  // software SPI
+  // --------------------------------------------------------------------------

  // Make sure GCC optimizes this file.
  // Note that this line triggers a bug in GCC which is fixed by casting.
@@ -69,11 +78,11 @@

  // run at ~8 .. ~10Mhz - Tx version (Rx data discarded)
  static uint8_t spiTransferTx0(uint8_t bout) { // using Mode 0
-    uint32_t MOSI_PORT_PLUS30 = ((uint32_t) PORT(MOSI_PIN)) + 0x30;  /* SODR of port */
-    uint32_t MOSI_MASK = PIN_MASK(MOSI_PIN);
-    uint32_t SCK_PORT_PLUS30 = ((uint32_t) PORT(SCK_PIN)) + 0x30;    /* SODR of port */
-    uint32_t SCK_MASK = PIN_MASK(SCK_PIN);
-    uint32_t idx = 0;
+    register uint32_t MOSI_PORT_PLUS30 = ((uint32_t) PORT(MOSI_PIN)) + 0x30;  /* SODR of port */
+    register uint32_t MOSI_MASK = PIN_MASK(MOSI_PIN);
+    register uint32_t SCK_PORT_PLUS30 = ((uint32_t) PORT(SCK_PIN)) + 0x30;    /* SODR of port */
+    register uint32_t SCK_MASK = PIN_MASK(SCK_PIN);
+    register uint32_t idx = 0;

    /* Negate bout, as the assembler requires a negated value */
    bout = ~bout;
@@ -151,12 +160,13 @@
    (((uint32_t)(addr) & 0xF0000000) + 0x02000000 + ((uint32_t)(addr)&0xFFFFF)*32 + (bit)*4)

  // run at ~8 .. ~10Mhz - Rx version (Tx line not altered)
-  static uint8_t spiTransferRx0(uint8_t) { // using Mode 0
-    uint32_t bin = 0;
-    uint32_t work = 0;
-    uint32_t BITBAND_MISO_PORT = BITBAND_ADDRESS( ((uint32_t)PORT(MISO_PIN))+0x3C, PIN_SHIFT(MISO_PIN));  /* PDSR of port in bitband area */
-    uint32_t SCK_PORT_PLUS30 = ((uint32_t) PORT(SCK_PIN)) + 0x30;    /* SODR of port */
-    uint32_t SCK_MASK = PIN_MASK(SCK_PIN);
+  static uint8_t spiTransferRx0(uint8_t bout) { // using Mode 0
+    register uint32_t bin = 0;
+    register uint32_t work = 0;
+    register uint32_t BITBAND_MISO_PORT = BITBAND_ADDRESS( ((uint32_t)PORT(MISO_PIN))+0x3C, PIN_SHIFT(MISO_PIN));  /* PDSR of port in bitband area */
+    register uint32_t SCK_PORT_PLUS30 = ((uint32_t) PORT(SCK_PIN)) + 0x30;    /* SODR of port */
+    register uint32_t SCK_MASK = PIN_MASK(SCK_PIN);
+    UNUSED(bout);

    /* The software SPI routine */
    __asm__ __volatile__(
@@ -240,7 +250,7 @@
  }

  // all the others
-  static uint32_t spiDelayCyclesX4 = (F_CPU) / 1000000; // 4µs => 125khz
+  static uint32_t spiDelayCyclesX4 = (F_CPU/1000000); // 4uS => 125khz

  static uint8_t spiTransferX(uint8_t b) { // using Mode 0
    int bits = 8;
@@ -271,12 +281,12 @@

  // Block transfers run at ~8 .. ~10Mhz - Tx version (Rx data discarded)
  static void spiTxBlock0(const uint8_t* ptr, uint32_t todo) {
-    uint32_t MOSI_PORT_PLUS30 = ((uint32_t) PORT(MOSI_PIN)) + 0x30;  /* SODR of port */
-    uint32_t MOSI_MASK = PIN_MASK(MOSI_PIN);
-    uint32_t SCK_PORT_PLUS30 = ((uint32_t) PORT(SCK_PIN)) + 0x30;    /* SODR of port */
-    uint32_t SCK_MASK = PIN_MASK(SCK_PIN);
-    uint32_t work = 0;
-    uint32_t txval = 0;
+    register uint32_t MOSI_PORT_PLUS30 = ((uint32_t) PORT(MOSI_PIN)) + 0x30;  /* SODR of port */
+    register uint32_t MOSI_MASK = PIN_MASK(MOSI_PIN);
+    register uint32_t SCK_PORT_PLUS30 = ((uint32_t) PORT(SCK_PIN)) + 0x30;    /* SODR of port */
+    register uint32_t SCK_MASK = PIN_MASK(SCK_PIN);
+    register uint32_t work = 0;
+    register uint32_t txval = 0;

    /* The software SPI routine */
    __asm__ __volatile__(
@@ -350,11 +360,11 @@
  }

  static void spiRxBlock0(uint8_t* ptr, uint32_t todo) {
-    uint32_t bin = 0;
-    uint32_t work = 0;
-    uint32_t BITBAND_MISO_PORT = BITBAND_ADDRESS( ((uint32_t)PORT(MISO_PIN))+0x3C, PIN_SHIFT(MISO_PIN));  /* PDSR of port in bitband area */
-    uint32_t SCK_PORT_PLUS30 = ((uint32_t) PORT(SCK_PIN)) + 0x30;    /* SODR of port */
-    uint32_t SCK_MASK = PIN_MASK(SCK_PIN);
+    register uint32_t bin = 0;
+    register uint32_t work = 0;
+    register uint32_t BITBAND_MISO_PORT = BITBAND_ADDRESS( ((uint32_t)PORT(MISO_PIN))+0x3C, PIN_SHIFT(MISO_PIN));  /* PDSR of port in bitband area */
+    register uint32_t SCK_PORT_PLUS30 = ((uint32_t) PORT(SCK_PIN)) + 0x30;    /* SODR of port */
+    register uint32_t SCK_MASK = PIN_MASK(SCK_PIN);

    /* The software SPI routine */
    __asm__ __volatile__(
@@ -427,7 +437,7 @@

  static void spiTxBlockX(const uint8_t* buf, uint32_t todo) {
    do {
-      (void)spiTransferTx(*buf++);
+      (void) spiTransferTx(*buf++);
    } while (--todo);
  }

@@ -441,48 +451,77 @@
  static pfnSpiTxBlock spiTxBlock = (pfnSpiTxBlock)spiTxBlockX;
  static pfnSpiRxBlock spiRxBlock = (pfnSpiRxBlock)spiRxBlockX;

-  #if MB(ALLIGATOR)
-    #define _SS_WRITE(S) WRITE(SS_PIN, S)
-  #else
-    #define _SS_WRITE(S) NOOP
-  #endif
-
-  void spiBegin() {
-    SET_OUTPUT(SS_PIN);
-    _SS_WRITE(HIGH);
-    SET_OUTPUT(SCK_PIN);
-    SET_INPUT(MISO_PIN);
-    SET_OUTPUT(MOSI_PIN);
-  }
-
-  uint8_t spiRec() {
-    _SS_WRITE(LOW);
-    WRITE(MOSI_PIN, HIGH); // Output 1s 1
-    uint8_t b = spiTransferRx(0xFF);
-    _SS_WRITE(HIGH);
-    return b;
-  }
-
-  void spiRead(uint8_t* buf, uint16_t nbyte) {
-    if (nbyte) {
-      _SS_WRITE(LOW);
-      WRITE(MOSI_PIN, HIGH); // Output 1s 1
-      spiRxBlock(buf, nbyte);
-      _SS_WRITE(HIGH);
+  #if MB(ALLIGATOR)  // control SDSS pin
+    void spiBegin() {
+      SET_OUTPUT(SS_PIN);
+      WRITE(SS_PIN, HIGH);
+      SET_OUTPUT(SCK_PIN);
+      SET_INPUT(MISO_PIN);
+      SET_OUTPUT(MOSI_PIN);
    }
-  }

-  void spiSend(uint8_t b) {
-    _SS_WRITE(LOW);
-    (void)spiTransferTx(b);
-    _SS_WRITE(HIGH);
-  }
+    uint8_t spiRec() {
+      WRITE(SS_PIN, LOW);
+      WRITE(MOSI_PIN, 1); /* Output 1s 1*/
+      uint8_t b = spiTransferRx(0xFF);
+      WRITE(SS_PIN, HIGH);
+      return b;
+    }
+
+    void spiRead(uint8_t* buf, uint16_t nbyte) {
+      uint32_t todo = nbyte;
+      if (todo == 0) return;
+
+      WRITE(SS_PIN, LOW);
+      WRITE(MOSI_PIN, 1); /* Output 1s 1*/
+      spiRxBlock(buf,nbyte);
+      WRITE(SS_PIN, HIGH);
+    }
+
+    void spiSend(uint8_t b) {
+      WRITE(SS_PIN, LOW);
+      (void) spiTransferTx(b);
+      WRITE(SS_PIN, HIGH);
+    }
+
+    void spiSendBlock(uint8_t token, const uint8_t* buf) {
+      WRITE(SS_PIN, LOW);
+      (void) spiTransferTx(token);
+      spiTxBlock(buf,512);
+      WRITE(SS_PIN, HIGH);
+
+  #else   // let calling routine control SDSS
+    void spiBegin() {
+      SET_OUTPUT(SS_PIN);
+      SET_OUTPUT(SCK_PIN);
+      SET_INPUT(MISO_PIN);
+      SET_OUTPUT(MOSI_PIN);
+    }
+
+    uint8_t spiRec() {
+      WRITE(MOSI_PIN, 1); /* Output 1s 1*/
+      uint8_t b = spiTransferRx(0xFF);
+      return b;
+    }
+
+    void spiRead(uint8_t* buf, uint16_t nbyte) {
+      uint32_t todo = nbyte;
+      if (todo == 0) return;
+
+      WRITE(MOSI_PIN, 1); /* Output 1s 1*/
+      spiRxBlock(buf,nbyte);
+    }
+
+    void spiSend(uint8_t b) {
+      (void) spiTransferTx(b);
+    }
+
+    void spiSendBlock(uint8_t token, const uint8_t* buf) {
+      (void) spiTransferTx(token);
+      spiTxBlock(buf,512);
+
+    #endif

-  void spiSendBlock(uint8_t token, const uint8_t* buf) {
-    _SS_WRITE(LOW);
-    (void)spiTransferTx(token);
-    spiTxBlock(buf, 512);
-    _SS_WRITE(HIGH);
  }

  /**
@@ -510,7 +549,7 @@
        spiRxBlock = (pfnSpiRxBlock)spiRxBlockX;
        break;
      default:
-        spiDelayCyclesX4 = ((F_CPU) / 1000000) >> (6 - spiRate);
+        spiDelayCyclesX4 = (F_CPU/1000000) >> (6 - spiRate);
        spiTransferTx = (pfnSpiTransfer)spiTransferX;
        spiTransferRx = (pfnSpiTransfer)spiTransferX;
        spiTxBlock = (pfnSpiTxBlock)spiTxBlockX;
@@ -518,7 +557,9 @@
        break;
    }

-    _SS_WRITE(HIGH);
+    #if MB(ALLIGATOR)
+      WRITE(SS_PIN, HIGH);
+    #endif
    WRITE(MOSI_PIN, HIGH);
    WRITE(SCK_PIN, LOW);
  }
@@ -532,185 +573,202 @@

 #else // !SOFTWARE_SPI

-  #define WHILE_TX(N) while ((SPI0->SPI_SR & SPI_SR_TDRE) == (N))
-  #define WHILE_RX(N) while ((SPI0->SPI_SR & SPI_SR_RDRF) == (N))
-  #define FLUSH_TX() do{ WHILE_RX(1) SPI0->SPI_RDR; }while(0)
-
  #if MB(ALLIGATOR)

    // slave selects controlled by SPI controller
    // doesn't support changing SPI speeds for SD card

-    // ------------------------
+    // --------------------------------------------------------------------------
    // hardware SPI
-    // ------------------------
-    static bool spiInitialized = false;
-
-    void spiInit(uint8_t spiRate) {
-      if (spiInitialized) return;
-
-      // 8.4 MHz, 4 MHz, 2 MHz, 1 MHz, 0.5 MHz, 0.329 MHz, 0.329 MHz
-      constexpr int spiDivider[] = { 10, 21, 42, 84, 168, 255, 255 };
-      if (spiRate > 6) spiRate = 1;
-
-      // Set SPI mode 1, clock, select not active after transfer, with delay between transfers
-      SPI_ConfigureNPCS(SPI0, SPI_CHAN_DAC,
-                        SPI_CSR_CSAAT | SPI_CSR_SCBR(spiDivider[spiRate]) |
-                        SPI_CSR_DLYBCT(1));
-      // Set SPI mode 0, clock, select not active after transfer, with delay between transfers
-      SPI_ConfigureNPCS(SPI0, SPI_CHAN_EEPROM1, SPI_CSR_NCPHA |
-                        SPI_CSR_CSAAT | SPI_CSR_SCBR(spiDivider[spiRate]) |
-                        SPI_CSR_DLYBCT(1));
-
-      // Set SPI mode 0, clock, select not active after transfer, with delay between transfers
-      SPI_ConfigureNPCS(SPI0, SPI_CHAN, SPI_CSR_NCPHA |
-                        SPI_CSR_CSAAT | SPI_CSR_SCBR(spiDivider[spiRate]) |
-                        SPI_CSR_DLYBCT(1));
-      SPI_Enable(SPI0);
-      spiInitialized = true;
-    }
+    // --------------------------------------------------------------------------
+    // 8.4 MHz, 4 MHz, 2 MHz, 1 MHz, 0.5 MHz, 0.329 MHz, 0.329 MHz
+    int spiDueDividors[] = { 10, 21, 42, 84, 168, 255, 255 };
+    bool spiInitMaded = false;

    void spiBegin() {
-      if (spiInitialized) return;
+      if (spiInitMaded == false) {
+        // Configure SPI pins
+        PIO_Configure(
+           g_APinDescription[SCK_PIN].pPort,
+           g_APinDescription[SCK_PIN].ulPinType,
+           g_APinDescription[SCK_PIN].ulPin,
+           g_APinDescription[SCK_PIN].ulPinConfiguration);
+        PIO_Configure(
+           g_APinDescription[MOSI_PIN].pPort,
+           g_APinDescription[MOSI_PIN].ulPinType,
+           g_APinDescription[MOSI_PIN].ulPin,
+           g_APinDescription[MOSI_PIN].ulPinConfiguration);
+        PIO_Configure(
+           g_APinDescription[MISO_PIN].pPort,
+           g_APinDescription[MISO_PIN].ulPinType,
+           g_APinDescription[MISO_PIN].ulPin,
+           g_APinDescription[MISO_PIN].ulPinConfiguration);

-      // Configure SPI pins
-      PIO_Configure(
-         g_APinDescription[SCK_PIN].pPort,
-         g_APinDescription[SCK_PIN].ulPinType,
-         g_APinDescription[SCK_PIN].ulPin,
-         g_APinDescription[SCK_PIN].ulPinConfiguration);
-      PIO_Configure(
-         g_APinDescription[MOSI_PIN].pPort,
-         g_APinDescription[MOSI_PIN].ulPinType,
-         g_APinDescription[MOSI_PIN].ulPin,
-         g_APinDescription[MOSI_PIN].ulPinConfiguration);
-      PIO_Configure(
-         g_APinDescription[MISO_PIN].pPort,
-         g_APinDescription[MISO_PIN].ulPinType,
-         g_APinDescription[MISO_PIN].ulPin,
-         g_APinDescription[MISO_PIN].ulPinConfiguration);
+        // set master mode, peripheral select, fault detection
+        SPI_Configure(SPI0, ID_SPI0, SPI_MR_MSTR | SPI_MR_MODFDIS | SPI_MR_PS);
+        SPI_Enable(SPI0);

-      // set master mode, peripheral select, fault detection
-      SPI_Configure(SPI0, ID_SPI0, SPI_MR_MSTR | SPI_MR_MODFDIS | SPI_MR_PS);
-      SPI_Enable(SPI0);
+        #if MB(ALLIGATOR)
+          SET_OUTPUT(DAC0_SYNC);
+          #if EXTRUDERS > 1
+            SET_OUTPUT(DAC1_SYNC);
+            WRITE(DAC1_SYNC, HIGH);
+          #endif
+          SET_OUTPUT(SPI_EEPROM1_CS);
+          SET_OUTPUT(SPI_EEPROM2_CS);
+          SET_OUTPUT(SPI_FLASH_CS);
+          WRITE(DAC0_SYNC, HIGH);
+          WRITE(SPI_EEPROM1_CS, HIGH );
+          WRITE(SPI_EEPROM2_CS, HIGH );
+          WRITE(SPI_FLASH_CS, HIGH );
+          WRITE(SS_PIN, HIGH );
+        #endif // MB(ALLIGATOR)

-      SET_OUTPUT(DAC0_SYNC);
-      #if EXTRUDERS > 1
-        SET_OUTPUT(DAC1_SYNC);
-        WRITE(DAC1_SYNC, HIGH);
-      #endif
-      SET_OUTPUT(SPI_EEPROM1_CS);
-      SET_OUTPUT(SPI_EEPROM2_CS);
-      SET_OUTPUT(SPI_FLASH_CS);
-      WRITE(DAC0_SYNC, HIGH);
-      WRITE(SPI_EEPROM1_CS, HIGH);
-      WRITE(SPI_EEPROM2_CS, HIGH);
-      WRITE(SPI_FLASH_CS, HIGH);
-      WRITE(SS_PIN, HIGH);
+        OUT_WRITE(SDSS,0);

-      OUT_WRITE(SDSS, LOW);
+        PIO_Configure(
+          g_APinDescription[SPI_PIN].pPort,
+          g_APinDescription[SPI_PIN].ulPinType,
+          g_APinDescription[SPI_PIN].ulPin,
+          g_APinDescription[SPI_PIN].ulPinConfiguration);

-      PIO_Configure(
-        g_APinDescription[SPI_PIN].pPort,
-        g_APinDescription[SPI_PIN].ulPinType,
-        g_APinDescription[SPI_PIN].ulPin,
-        g_APinDescription[SPI_PIN].ulPinConfiguration
-      );
+        spiInit(1);
+        spiInitMaded = true;
+      }
+    }

-      spiInit(1);
+    void spiInit(uint8_t spiRate) {
+      if (spiInitMaded == false) {
+        if (spiRate > 6) spiRate = 1;
+
+        #if MB(ALLIGATOR)
+          // Set SPI mode 1, clock, select not active after transfer, with delay between transfers
+          SPI_ConfigureNPCS(SPI0, SPI_CHAN_DAC,
+                            SPI_CSR_CSAAT | SPI_CSR_SCBR(spiDueDividors[spiRate]) |
+                            SPI_CSR_DLYBCT(1));
+          // Set SPI mode 0, clock, select not active after transfer, with delay between transfers
+          SPI_ConfigureNPCS(SPI0, SPI_CHAN_EEPROM1, SPI_CSR_NCPHA |
+                            SPI_CSR_CSAAT | SPI_CSR_SCBR(spiDueDividors[spiRate]) |
+                            SPI_CSR_DLYBCT(1));
+        #endif//MB(ALLIGATOR)
+
+        // Set SPI mode 0, clock, select not active after transfer, with delay between transfers
+        SPI_ConfigureNPCS(SPI0, SPI_CHAN, SPI_CSR_NCPHA |
+                          SPI_CSR_CSAAT | SPI_CSR_SCBR(spiDueDividors[spiRate]) |
+                          SPI_CSR_DLYBCT(1));
+        SPI_Enable(SPI0);
+        spiInitMaded = true;
+      }
+    }
+
+    // Write single byte to SPI
+    void spiSend(byte b) {
+      // write byte with address and end transmission flag
+      SPI0->SPI_TDR = (uint32_t)b | SPI_PCS(SPI_CHAN) | SPI_TDR_LASTXFER;
+      // wait for transmit register empty
+      while ((SPI0->SPI_SR & SPI_SR_TDRE) == 0);
+      // wait for receive register
+      while ((SPI0->SPI_SR & SPI_SR_RDRF) == 0);
+      // clear status
+      SPI0->SPI_RDR;
+      //DELAY_US(1U);
+    }
+
+    void spiSend(const uint8_t* buf, size_t n) {
+      if (n == 0) return;
+      for (size_t i = 0; i < n - 1; i++) {
+        SPI0->SPI_TDR = (uint32_t)buf[i] | SPI_PCS(SPI_CHAN);
+        while ((SPI0->SPI_SR & SPI_SR_TDRE) == 0);
+        while ((SPI0->SPI_SR & SPI_SR_RDRF) == 0);
+        SPI0->SPI_RDR;
+        //DELAY_US(1U);
+      }
+      spiSend(buf[n - 1]);
+    }
+
+    void spiSend(uint32_t chan, byte b) {
+      uint8_t dummy_read = 0;
+      // wait for transmit register empty
+      while ((SPI0->SPI_SR & SPI_SR_TDRE) == 0);
+      // write byte with address and end transmission flag
+      SPI0->SPI_TDR = (uint32_t)b | SPI_PCS(chan) | SPI_TDR_LASTXFER;
+      // wait for receive register
+      while ((SPI0->SPI_SR & SPI_SR_RDRF) == 0);
+      // clear status
+      while ((SPI0->SPI_SR & SPI_SR_RDRF) == 1)
+        dummy_read = SPI0->SPI_RDR;
+      UNUSED(dummy_read);
+    }
+
+    void spiSend(uint32_t chan, const uint8_t* buf, size_t n) {
+      uint8_t dummy_read = 0;
+      if (n == 0) return;
+      for (int i = 0; i < (int)n - 1; i++) {
+        while ((SPI0->SPI_SR & SPI_SR_TDRE) == 0);
+        SPI0->SPI_TDR = (uint32_t)buf[i] | SPI_PCS(chan);
+        while ((SPI0->SPI_SR & SPI_SR_RDRF) == 0);
+        while ((SPI0->SPI_SR & SPI_SR_RDRF) == 1)
+          dummy_read = SPI0->SPI_RDR;
+        UNUSED(dummy_read);
+      }
+      spiSend(chan, buf[n - 1]);
    }

    // Read single byte from SPI
    uint8_t spiRec() {
      // write dummy byte with address and end transmission flag
      SPI0->SPI_TDR = 0x000000FF | SPI_PCS(SPI_CHAN) | SPI_TDR_LASTXFER;
+      // wait for transmit register empty
+      while ((SPI0->SPI_SR & SPI_SR_TDRE) == 0);

-      WHILE_TX(0);
-      WHILE_RX(0);
-
+      // wait for receive register
+      while ((SPI0->SPI_SR & SPI_SR_RDRF) == 0);
+      // get byte from receive register
      //DELAY_US(1U);
      return SPI0->SPI_RDR;
    }

    uint8_t spiRec(uint32_t chan) {
-
-      WHILE_TX(0);
-      FLUSH_RX();
+      uint8_t spirec_tmp;
+      // wait for transmit register empty
+      while ((SPI0->SPI_SR & SPI_SR_TDRE) == 0);
+      while ((SPI0->SPI_SR & SPI_SR_RDRF) == 1)
+        spirec_tmp =  SPI0->SPI_RDR;
+        UNUSED(spirec_tmp);

      // write dummy byte with address and end transmission flag
      SPI0->SPI_TDR = 0x000000FF | SPI_PCS(chan) | SPI_TDR_LASTXFER;
-      WHILE_RX(0);

+      // wait for receive register
+      while ((SPI0->SPI_SR & SPI_SR_RDRF) == 0);
+      // get byte from receive register
      return SPI0->SPI_RDR;
    }

    // Read from SPI into buffer
    void spiRead(uint8_t* buf, uint16_t nbyte) {
-      if (!nbyte) return;
-      --nbyte;
+      if (nbyte-- == 0) return;
+
      for (int i = 0; i < nbyte; i++) {
-        //WHILE_TX(0);
+        //while ((SPI0->SPI_SR & SPI_SR_TDRE) == 0);
        SPI0->SPI_TDR = 0x000000FF | SPI_PCS(SPI_CHAN);
-        WHILE_RX(0);
+        while ((SPI0->SPI_SR & SPI_SR_RDRF) == 0);
        buf[i] = SPI0->SPI_RDR;
        //DELAY_US(1U);
      }
      buf[nbyte] = spiRec();
    }

-    // Write single byte to SPI
-    void spiSend(const byte b) {
-      // write byte with address and end transmission flag
-      SPI0->SPI_TDR = (uint32_t)b | SPI_PCS(SPI_CHAN) | SPI_TDR_LASTXFER;
-      WHILE_TX(0);
-      WHILE_RX(0);
-      SPI0->SPI_RDR;
-      //DELAY_US(1U);
-    }
-
-    void spiSend(const uint8_t* buf, size_t nbyte) {
-      if (!nbyte) return;
-      --nbyte;
-      for (size_t i = 0; i < nbyte; i++) {
-        SPI0->SPI_TDR = (uint32_t)buf[i] | SPI_PCS(SPI_CHAN);
-        WHILE_TX(0);
-        WHILE_RX(0);
-        SPI0->SPI_RDR;
-        //DELAY_US(1U);
-      }
-      spiSend(buf[nbyte]);
-    }
-
-    void spiSend(uint32_t chan, byte b) {
-      WHILE_TX(0);
-      // write byte with address and end transmission flag
-      SPI0->SPI_TDR = (uint32_t)b | SPI_PCS(chan) | SPI_TDR_LASTXFER;
-      WHILE_RX(0);
-      FLUSH_RX();
-    }
-
-    void spiSend(uint32_t chan, const uint8_t* buf, size_t nbyte) {
-      if (!nbyte) return;
-      --nbyte;
-      for (size_t i = 0; i < nbyte; i++) {
-        WHILE_TX(0);
-        SPI0->SPI_TDR = (uint32_t)buf[i] | SPI_PCS(chan);
-        WHILE_RX(0);
-        FLUSH_RX();
-      }
-      spiSend(chan, buf[nbyte]);
-    }
-
    // Write from buffer to SPI
    void spiSendBlock(uint8_t token, const uint8_t* buf) {
      SPI0->SPI_TDR = (uint32_t)token | SPI_PCS(SPI_CHAN);
-      WHILE_TX(0);
-      //WHILE_RX(0);
+      while ((SPI0->SPI_SR & SPI_SR_TDRE) == 0);
+      //while ((SPI0->SPI_SR & SPI_SR_RDRF) == 0);
      //SPI0->SPI_RDR;
      for (int i = 0; i < 511; i++) {
        SPI0->SPI_TDR = (uint32_t)buf[i] | SPI_PCS(SPI_CHAN);
-        WHILE_TX(0);
-        WHILE_RX(0);
+        while ((SPI0->SPI_SR & SPI_SR_TDRE) == 0);
+        while ((SPI0->SPI_SR & SPI_SR_RDRF) == 0);
        SPI0->SPI_RDR;
        //DELAY_US(1U);
      }
@@ -722,51 +780,16 @@
      // TODO: to be implemented
    }

-  #else // U8G compatible hardware SPI
+  #else  // U8G compatible hardware SPI

    #define SPI_MODE_0_DUE_HW 2  // DUE CPHA control bit is inverted
    #define SPI_MODE_1_DUE_HW 3
    #define SPI_MODE_2_DUE_HW 0
    #define SPI_MODE_3_DUE_HW 1

-    /**
-     *  The DUE SPI controller is set up so the upper word of the longword
-     *  written to the transmit data register selects which SPI Chip Select
-     *  Register is used. This allows different streams to have different SPI
-     *  settings.
-     *
-     *  In practice it's spooky. Some combinations hang the system, while others
-     *  upset the peripheral device.
-     *
-     *  SPI mode should be the same for all streams. The FYSETC_MINI_12864 gets
-     *  upset if the clock phase changes after chip select goes active.
-     *
-     *  SPI_CSR_CSAAT should be set for all streams. If not the WHILE_TX(0)
-     *  macro returns immediately which can result in the SPI chip select going
-     *  inactive before all the data has been sent.
-     *
-     *  The TMC2130 library uses SPI0->SPI_CSR[3].
-     *
-     *  The U8G hardware SPI uses SPI0->SPI_CSR[0]. The system hangs and/or the
-     *  FYSETC_MINI_12864 gets upset if lower baud rates are used and the SD card
-     *  is inserted or removed.
-     *
-     *  The SD card uses SPI0->SPI_CSR[3]. Efforts were made to use [1] and [2]
-     *  but they all resulted in hangs or garbage on the LCD.
-     *
-     *  The SPI controlled chip selects are NOT enabled in the GPIO controller.
-     *  The application must control the chip select.
-     *
-     *  All of the above can be avoided by defining FORCE_SOFT_SPI to force the
-     *  display to use software SPI.
-     *
-     */
-
    void spiInit(uint8_t spiRate=6) {  // Default to slowest rate if not specified)
-                                       // Also sets U8G SPI rate to 4MHz and the SPI mode to 3
-
      // 8.4 MHz, 4 MHz, 2 MHz, 1 MHz, 0.5 MHz, 0.329 MHz, 0.329 MHz
-      constexpr int spiDivider[] = { 10, 21, 42, 84, 168, 255, 255 };
+      int spiDueDividors[] = { 10, 21, 42, 84, 168, 255, 255 };
      if (spiRate > 6) spiRate = 1;

      // Enable PIOA and SPI0
@@ -774,7 +797,7 @@

      // Disable PIO on A26 and A27
      REG_PIOA_PDR = 0x0C000000;
-      OUT_WRITE(SDSS, HIGH);
+      OUT_WRITE(SDSS, 1);

      // Reset SPI0 (from sam lib)
      SPI0->SPI_CR = SPI_CR_SPIDIS;
@@ -785,32 +808,48 @@
      // TMC2103 compatible setup
      // Master mode, no fault detection, PCS bits in data written to TDR select CSR register
      SPI0->SPI_MR = SPI_MR_MSTR | SPI_MR_PS | SPI_MR_MODFDIS;
-      // SPI mode 3, 8 Bit data transfer, baud rate
-      SPI0->SPI_CSR[3] = SPI_CSR_SCBR(spiDivider[spiRate]) | SPI_CSR_CSAAT | SPI_MODE_3_DUE_HW;  // use same CSR as TMC2130
-      SPI0->SPI_CSR[0] = SPI_CSR_SCBR(spiDivider[1]) | SPI_CSR_CSAAT | SPI_MODE_3_DUE_HW;  // U8G default to 4MHz
+      // SPI mode 0, 8 Bit data transfer, baud rate
+      SPI0->SPI_CSR[3] = SPI_CSR_SCBR(spiDueDividors[spiRate]) | SPI_CSR_CSAAT | SPI_MODE_0_DUE_HW;  // use same CSR as TMC2130
    }

-    void spiBegin() { spiInit(); }
-
    static uint8_t spiTransfer(uint8_t data) {
-      WHILE_TX(0);
-      SPI0->SPI_TDR = (uint32_t)data | 0x00070000UL;  // Add TMC2130 PCS bits to every byte (use SPI0->SPI_CSR[3])
-      WHILE_TX(0);
-      WHILE_RX(0);
+
+      // Wait until tx register is empty
+      while( (SPI0->SPI_SR & SPI_SR_TDRE) == 0 );
+      // Send data
+      SPI0->SPI_TDR = (uint32_t)data | 0x00070000UL;  // Add TMC2130 PCS bits to every byte
+
+      // wait for transmit register empty
+      while ((SPI0->SPI_SR & SPI_SR_TDRE) == 0);
+
+      // wait for receive register
+      while ((SPI0->SPI_SR & SPI_SR_RDRF) == 0);
+      // get byte from receive register
      return SPI0->SPI_RDR;
    }

-    uint8_t spiRec() { return (uint8_t)spiTransfer(0xFF); }
+    void spiBegin() {
+      spiInit();
+    }
+
+    uint8_t spiRec() {
+      uint8_t data = spiTransfer(0xFF);
+      return data;
+    }

    void spiRead(uint8_t* buf, uint16_t nbyte) {
+      if (nbyte == 0) return;
      for (int i = 0; i < nbyte; i++)
        buf[i] = spiTransfer(0xFF);
    }

-    void spiSend(uint8_t data) { spiTransfer(data); }
+    void spiSend(uint8_t data) {
+      spiTransfer(data);
+    }

-    void spiSend(const uint8_t* buf, size_t nbyte) {
-      for (uint16_t i = 0; i < nbyte; i++)
+    void spiSend(const uint8_t* buf, size_t n) {
+      if (n == 0) return;
+      for (uint16_t i = 0; i < n; i++)
        spiTransfer(buf[i]);
    }

--- a/Marlin/src/HAL/HAL_DUE/HAL_timers_Due.cpp
+++ b/Marlin/src/HAL/HAL_DUE/HAL_timers_Due.cpp
@@ -1,7 +1,7 @@
 /**
 * Marlin 3D Printer Firmware
 *
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 * Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
 * Copyright (c) 2015-2016 Nico Tonnhofer wurstnase.reprap@gmail.com
 *
@@ -28,29 +28,43 @@

 #ifdef ARDUINO_ARCH_SAM

-// ------------------------
+// --------------------------------------------------------------------------
 // Includes
-// ------------------------
-#include "../../inc/MarlinConfig.h"
+// --------------------------------------------------------------------------
+
 #include "HAL.h"

-#include "timers.h"
+#include "HAL_timers_Due.h"

-// ------------------------
+// --------------------------------------------------------------------------
+// Externals
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
 // Local defines
-// ------------------------
+// --------------------------------------------------------------------------

 #define NUM_HARDWARE_TIMERS 9

-// ------------------------
+#define PRESCALER 2
+// --------------------------------------------------------------------------
+// Types
+// --------------------------------------------------------------------------
+
+
+// --------------------------------------------------------------------------
+// Public Variables
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
 // Private Variables
-// ------------------------
+// --------------------------------------------------------------------------

 const tTimerConfig TimerConfig [NUM_HARDWARE_TIMERS] = {
  { TC0, 0, TC0_IRQn,  3}, // 0 - [servo timer5]
  { TC0, 1, TC1_IRQn,  0}, // 1
-  { TC0, 2, TC2_IRQn,  2}, // 2 - stepper
-  { TC1, 0, TC3_IRQn,  0}, // 3 - stepper for BOARD_ARCHIM1
+  { TC0, 2, TC2_IRQn,  0}, // 2
+  { TC1, 0, TC3_IRQn,  2}, // 3 - stepper
  { TC1, 1, TC4_IRQn, 15}, // 4 - temperature
  { TC1, 2, TC5_IRQn,  3}, // 5 - [servo timer3]
  { TC2, 0, TC6_IRQn, 14}, // 6 - tone
@@ -58,9 +72,17 @@ const tTimerConfig TimerConfig [NUM_HARDWARE_TIMERS] = {
  { TC2, 2, TC8_IRQn,  0}, // 8
 };

-// ------------------------
+// --------------------------------------------------------------------------
+// Function prototypes
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Private functions
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
 // Public functions
-// ------------------------
+// --------------------------------------------------------------------------

 /*
  Timer_clock1: Prescaler 2 -> 42MHz
--- a/Marlin/src/HAL/HAL_DUE/HAL_timers_Due.h
+++ b/Marlin/src/HAL/HAL_DUE/HAL_timers_Due.h
@@ -1,7 +1,7 @@
 /**
 * Marlin 3D Printer Firmware
 *
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 * Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
 *
 * This program is free software: you can redistribute it and/or modify
@@ -18,7 +18,6 @@
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
-#pragma once

 /**
 * HAL for Arduino Due and compatible (SAM3X8E)
@@ -26,11 +25,18 @@
 * For ARDUINO_ARCH_SAM
 */

+#ifndef _HAL_TIMERS_DUE_H
+#define _HAL_TIMERS_DUE_H
+
+// --------------------------------------------------------------------------
+// Includes
+// --------------------------------------------------------------------------
+
 #include <stdint.h>

-// ------------------------
+// --------------------------------------------------------------------------
 // Defines
-// ------------------------
+// --------------------------------------------------------------------------

 #define FORCE_INLINE __attribute__((always_inline)) inline

@@ -39,9 +45,7 @@ typedef uint32_t hal_timer_t;

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

-#ifndef STEP_TIMER_NUM
-#define STEP_TIMER_NUM 2  // index of timer to use for stepper
-#endif
+#define STEP_TIMER_NUM 3  // index of timer to use for stepper
 #define TEMP_TIMER_NUM 4  // index of timer to use for temperature
 #define PULSE_TIMER_NUM STEP_TIMER_NUM
 #define TONE_TIMER_NUM 6  // index of timer to use for beeper tones
@@ -63,15 +67,13 @@ typedef uint32_t hal_timer_t;
 #define ENABLE_TEMPERATURE_INTERRUPT()  HAL_timer_enable_interrupt(TEMP_TIMER_NUM)
 #define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(TEMP_TIMER_NUM)

-#ifndef HAL_STEP_TIMER_ISR
-  #define HAL_STEP_TIMER_ISR() void TC2_Handler()
-#endif
-#define HAL_TEMP_TIMER_ISR()  void TC4_Handler()
-#define HAL_TONE_TIMER_ISR()  void TC6_Handler()
+#define HAL_STEP_TIMER_ISR  void TC3_Handler()
+#define HAL_TEMP_TIMER_ISR  void TC4_Handler()
+#define HAL_TONE_TIMER_ISR  void TC6_Handler()

-// ------------------------
+// --------------------------------------------------------------------------
 // Types
-// ------------------------
+// --------------------------------------------------------------------------

 typedef struct {
  Tc          *pTimerRegs;
@@ -80,15 +82,15 @@ typedef struct {
  uint8_t     priority;
 } tTimerConfig;

-// ------------------------
+// --------------------------------------------------------------------------
 // Public Variables
-// ------------------------
+// --------------------------------------------------------------------------

 extern const tTimerConfig TimerConfig[];

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

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

@@ -118,3 +120,5 @@ FORCE_INLINE static void HAL_timer_isr_prologue(const uint8_t timer_num) {
 }

 #define HAL_timer_isr_epilogue(TIMER_NUM)
+
+#endif // _HAL_TIMERS_DUE_H
--- a/Marlin/src/HAL/HAL_DUE/InterruptVectors_Due.cpp
+++ b/Marlin/src/HAL/HAL_DUE/InterruptVectors_Due.cpp
@@ -1,9 +1,9 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
 * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * 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
@@ -32,23 +32,22 @@
 */
 #ifdef ARDUINO_ARCH_SAM

-#include "../../inc/MarlinConfig.h"
 #include "HAL.h"
-#include "InterruptVectors.h"
+#include "InterruptVectors_Due.h"

 /* The relocated Exception/Interrupt Table - According to the ARM
   reference manual, alignment to 128 bytes should suffice, but in
   practice, we need alignment to 256 bytes to make this work in all
   cases */
 __attribute__ ((aligned(256)))
-static DeviceVectors ram_tab = { nullptr };
+static DeviceVectors ram_tab = { NULL };

 /**
 * This function checks if the exception/interrupt table is already in SRAM or not.
 * If it is not, then it copies the ROM table to the SRAM and relocates the table
 * by reprogramming the NVIC registers
 */
-static pfnISR_Handler* get_relocated_table_addr() {
+static pfnISR_Handler* get_relocated_table_addr(void) {
  // Get the address of the interrupt/exception table
  uint32_t isrtab = SCB->VTOR;

@@ -63,13 +62,13 @@ static pfnISR_Handler* get_relocated_table_addr() {
  memcpy(&ram_tab, romtab, sizeof(ram_tab));

  // Disable global interrupts
-  CRITICAL_SECTION_START();
+  CRITICAL_SECTION_START;

  // Set the vector table base address to the SRAM copy
  SCB->VTOR = (uint32_t)(&ram_tab);

  // Reenable interrupts
-  CRITICAL_SECTION_END();
+  CRITICAL_SECTION_END;

  // Return the address of the table
  return (pfnISR_Handler*)(&ram_tab);
@@ -80,7 +79,7 @@ pfnISR_Handler install_isr(IRQn_Type irq, pfnISR_Handler newHandler) {
  pfnISR_Handler *isrtab = get_relocated_table_addr();

  // Disable global interrupts
-  CRITICAL_SECTION_START();
+  CRITICAL_SECTION_START;

  // Get the original handler
  pfnISR_Handler oldHandler = isrtab[irq + 16];
@@ -89,7 +88,7 @@ pfnISR_Handler install_isr(IRQn_Type irq, pfnISR_Handler newHandler) {
  isrtab[irq + 16] = newHandler;

  // Reenable interrupts
-  CRITICAL_SECTION_END();
+  CRITICAL_SECTION_END;

  // Return the original one
  return oldHandler;
--- a/Marlin/src/HAL/HAL_DUE/InterruptVectors_Due.h
+++ b/Marlin/src/HAL/HAL_DUE/InterruptVectors_Due.h
@@ -1,9 +1,9 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
 * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * 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
@@ -19,11 +19,12 @@
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
-#pragma once

 /**
 * InterruptVectors_Due.h
 *
+ * Copyright (c) 2017 Eduardo José Tagle. All right reserved
+ *
 * This module relocates the Interrupt vector table to SRAM, allowing new
 * interrupt handlers to be added at runtime. This is required because the
 * Arduino runtime steals interrupt handlers that Marlin MUST use to support
@@ -34,12 +35,18 @@
 * Copyright (c) 2017 Eduardo José Tagle. All right reserved
 */

+#ifndef INTERRUPTVECTORS_DUE_H
+#define INTERRUPTVECTORS_DUE_H
+
+#include "../../inc/MarlinConfig.h"
+
 #ifdef ARDUINO_ARCH_SAM

 // ISR handler type
-typedef void (*pfnISR_Handler)();
+typedef void (*pfnISR_Handler)(void);

 // Install a new interrupt vector handler for the given irq, returning the old one
 pfnISR_Handler install_isr(IRQn_Type irq, pfnISR_Handler newHandler);

 #endif // ARDUINO_ARCH_SAM
+#endif // INTERRUPTVECTORS_DUE_H
--- a/Marlin/src/HAL/HAL_DUE/MarlinSerialUSB_Due.cpp
+++ b/Marlin/src/HAL/HAL_DUE/MarlinSerialUSB_Due.cpp
@@ -1,9 +1,9 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
 * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * 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
@@ -31,19 +31,19 @@

 #if SERIAL_PORT == -1

-#include "MarlinSerialUSB.h"
+#include "MarlinSerialUSB_Due.h"

 #if ENABLED(EMERGENCY_PARSER)
-  #include "../../feature/e_parser.h"
+  #include "../../feature/emergency_parser.h"
 #endif

 // Imports from Atmel USB Stack/CDC implementation
 extern "C" {
-  bool usb_task_cdc_isenabled();
-  bool usb_task_cdc_dtr_active();
-  bool udi_cdc_is_rx_ready();
-  int udi_cdc_getc();
-  bool udi_cdc_is_tx_ready();
+  bool usb_task_cdc_isenabled(void);
+  bool usb_task_cdc_dtr_active(void);
+  bool udi_cdc_is_rx_ready(void);
+  int udi_cdc_getc(void);
+  bool udi_cdc_is_tx_ready(void);
  int udi_cdc_putc(int value);
 };

@@ -55,11 +55,13 @@ static int pending_char = -1;
 #endif

 // Public Methods
-void MarlinSerialUSB::begin(const long) {}
+void MarlinSerialUSB::begin(const long baud_setting) {
+}

-void MarlinSerialUSB::end() {}
+void MarlinSerialUSB::end() {
+}

-int MarlinSerialUSB::peek() {
+int MarlinSerialUSB::peek(void) {
  if (pending_char >= 0)
    return pending_char;

@@ -80,7 +82,7 @@ int MarlinSerialUSB::peek() {
  return pending_char;
 }

-int MarlinSerialUSB::read() {
+int MarlinSerialUSB::read(void) {
  if (pending_char >= 0) {
    int ret = pending_char;
    pending_char = -1;
@@ -104,7 +106,7 @@ int MarlinSerialUSB::read() {
  return c;
 }

-bool MarlinSerialUSB::available() {
+bool MarlinSerialUSB::available(void) {
    /* If Pending chars */
  return pending_char >= 0 ||
    /* or USB CDC enumerated and configured on the PC side and some
@@ -112,8 +114,8 @@ bool MarlinSerialUSB::available() {
      (usb_task_cdc_isenabled() && udi_cdc_is_rx_ready());
 }

-void MarlinSerialUSB::flush() { }
-void MarlinSerialUSB::flushTX() { }
+void MarlinSerialUSB::flush(void) {
+}

 void MarlinSerialUSB::write(const uint8_t c) {

@@ -141,8 +143,8 @@ void MarlinSerialUSB::write(const uint8_t c) {
 }

 /**
- * Imports from print.h
- */
+* Imports from print.h
+*/

 void MarlinSerialUSB::print(char c, int base) {
  print((long)c, base);
@@ -183,7 +185,7 @@ void MarlinSerialUSB::print(double n, int digits) {
  printFloat(n, digits);
 }

-void MarlinSerialUSB::println() {
+void MarlinSerialUSB::println(void) {
  print('\r');
  print('\n');
 }
@@ -259,7 +261,7 @@ void MarlinSerialUSB::printFloat(double number, uint8_t digits) {

  // Round correctly so that print(1.999, 2) prints as "2.00"
  double rounding = 0.5;
-  LOOP_L_N(i, digits)
+  for (uint8_t i = 0; i < digits; ++i)
    rounding *= 0.1;

  number += rounding;
@@ -283,7 +285,7 @@ void MarlinSerialUSB::printFloat(double number, uint8_t digits) {
 }

 // Preinstantiate
-MarlinSerialUSB customizedSerial1;
+MarlinSerialUSB customizedSerial;

 #endif // SERIAL_PORT == -1

--- a/Marlin/src/HAL/HAL_DUE/MarlinSerialUSB_Due.h
+++ b/Marlin/src/HAL/HAL_DUE/MarlinSerialUSB_Due.h
@@ -1,9 +1,9 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
 * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * 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
@@ -19,13 +19,15 @@
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
-#pragma once

 /**
 * MarlinSerialUSB_Due.h - Hardware Serial over USB (CDC) library for Arduino DUE
 * Copyright (c) 2017 Eduardo José Tagle. All right reserved
 */

+#ifndef MARLINSERIALUSB_DUE_H
+#define MARLINSERIALUSB_DUE_H
+
 #include "../../inc/MarlinConfig.h"

 #if SERIAL_PORT == -1
@@ -43,19 +45,18 @@ public:
  MarlinSerialUSB() {};
  static void begin(const long);
  static void end();
-  static int peek();
-  static int read();
-  static void flush();
-  static void flushTX();
-  static bool available();
+  static int peek(void);
+  static int read(void);
+  static void flush(void);
+  static bool available(void);
  static void write(const uint8_t c);

  #if ENABLED(SERIAL_STATS_DROPPED_RX)
-    FORCE_INLINE static uint32_t dropped() { return 0; }
+  FORCE_INLINE static uint32_t dropped() { return 0; }
  #endif

  #if ENABLED(SERIAL_STATS_MAX_RX_QUEUED)
-    FORCE_INLINE static int rxMaxEnqueued() { return 0; }
+  FORCE_INLINE static int rxMaxEnqueued() { return 0; }
  #endif

  FORCE_INLINE static void write(const char* str) { while (*str) write(*str++); }
@@ -80,7 +81,7 @@ public:
  static void println(long, int = DEC);
  static void println(unsigned long, int = DEC);
  static void println(double, int = 2);
-  static void println();
+  static void println(void);
  operator bool() { return true; }

 private:
@@ -88,6 +89,7 @@ private:
  static void printFloat(double, uint8_t);
 };

-extern MarlinSerialUSB customizedSerial1;
+extern MarlinSerialUSB customizedSerial;

 #endif // SERIAL_PORT == -1
+#endif // MARLINSERIAL_DUE_H
--- a/Marlin/src/HAL/HAL_DUE/MarlinSerial_Due.cpp
+++ b/Marlin/src/HAL/HAL_DUE/MarlinSerial_Due.cpp
@@ -0,0 +1,703 @@
+/**
+ * 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/>.
+ *
+ */
+
+/**
+ * MarlinSerial_Due.cpp - Hardware serial library for Arduino DUE
+ * Copyright (c) 2017 Eduardo José Tagle. All right reserved
+ * Based on MarlinSerial for AVR, copyright (c) 2006 Nicholas Zambetti.  All right reserved.
+ */
+#ifdef ARDUINO_ARCH_SAM
+
+#include "../../inc/MarlinConfig.h"
+
+#include "MarlinSerial_Due.h"
+#include "InterruptVectors_Due.h"
+#include "../../Marlin.h"
+
+// If not using the USB port as serial port
+#if SERIAL_PORT >= 0
+
+  // Based on selected port, use the proper configuration
+  #if SERIAL_PORT == 0
+    #define HWUART UART
+    #define HWUART_IRQ UART_IRQn
+    #define HWUART_IRQ_ID ID_UART
+  #elif SERIAL_PORT == 1
+    #define HWUART ((Uart*)USART0)
+    #define HWUART_IRQ USART0_IRQn
+    #define HWUART_IRQ_ID ID_USART0
+  #elif SERIAL_PORT == 2
+    #define HWUART ((Uart*)USART1)
+    #define HWUART_IRQ USART1_IRQn
+    #define HWUART_IRQ_ID ID_USART1
+  #elif SERIAL_PORT == 3
+    #define HWUART ((Uart*)USART2)
+    #define HWUART_IRQ USART2_IRQn
+    #define HWUART_IRQ_ID ID_USART2
+  #elif SERIAL_PORT == 4
+    #define HWUART ((Uart*)USART3)
+    #define HWUART_IRQ USART3_IRQn
+    #define HWUART_IRQ_ID ID_USART3
+  #endif
+
+  struct ring_buffer_r {
+    unsigned char buffer[RX_BUFFER_SIZE];
+    volatile ring_buffer_pos_t head, tail;
+  };
+
+  #if TX_BUFFER_SIZE > 0
+    struct ring_buffer_t {
+      unsigned char buffer[TX_BUFFER_SIZE];
+      volatile uint8_t head, tail;
+    };
+  #endif
+
+  ring_buffer_r rx_buffer = { { 0 }, 0, 0 };
+  #if TX_BUFFER_SIZE > 0
+    ring_buffer_t tx_buffer = { { 0 }, 0, 0 };
+  #endif
+  static bool _written;
+
+  #if ENABLED(SERIAL_XON_XOFF)
+    constexpr uint8_t XON_XOFF_CHAR_SENT = 0x80,  // XON / XOFF Character was sent
+                      XON_XOFF_CHAR_MASK = 0x1F;  // XON / XOFF character to send
+    // XON / XOFF character definitions
+    constexpr uint8_t XON_CHAR  = 17, XOFF_CHAR = 19;
+    uint8_t xon_xoff_state = XON_XOFF_CHAR_SENT | XON_CHAR;
+
+    // Validate that RX buffer size is at least 4096 bytes- According to several experiments, on
+    // the original Arduino Due that uses a ATmega16U2 as USB to serial bridge, due to the introduced
+    // latencies, at least 2959 bytes of RX buffering (when transmitting at 250kbits/s) are required
+    // to avoid overflows.
+
+    #if RX_BUFFER_SIZE < 4096
+      #error Arduino DUE requires at least 4096 bytes of RX buffer to avoid buffer overflows when using XON/XOFF handshake
+    #endif
+  #endif
+
+  #if ENABLED(SERIAL_STATS_DROPPED_RX)
+    uint8_t rx_dropped_bytes = 0;
+  #endif
+
+  #if ENABLED(SERIAL_STATS_RX_BUFFER_OVERRUNS)
+    uint8_t rx_buffer_overruns = 0;
+  #endif
+
+  #if ENABLED(SERIAL_STATS_RX_FRAMING_ERRORS)
+    uint8_t rx_framing_errors = 0;
+  #endif
+
+  #if ENABLED(SERIAL_STATS_MAX_RX_QUEUED)
+    ring_buffer_pos_t rx_max_enqueued = 0;
+  #endif
+
+  // A SW memory barrier, to ensure GCC does not overoptimize loops
+  #define sw_barrier() asm volatile("": : :"memory");
+
+  #if ENABLED(EMERGENCY_PARSER)
+    #include "../../feature/emergency_parser.h"
+  #endif
+
+  // (called with RX interrupts disabled)
+  FORCE_INLINE void store_rxd_char() {
+
+    #if ENABLED(EMERGENCY_PARSER)
+      static EmergencyParser::State emergency_state; // = EP_RESET
+    #endif
+
+    // Get the tail - Nothing can alter its value while we are at this ISR
+    const ring_buffer_pos_t t = rx_buffer.tail;
+
+    // Get the head pointer
+    ring_buffer_pos_t h = rx_buffer.head;
+
+    // Get the next element
+    ring_buffer_pos_t i = (ring_buffer_pos_t)(h + 1) & (ring_buffer_pos_t)(RX_BUFFER_SIZE - 1);
+
+    // Read the character from the USART
+    uint8_t c = HWUART->UART_RHR;
+
+    #if ENABLED(EMERGENCY_PARSER)
+      emergency_parser.update(emergency_state, c);
+    #endif
+
+    // If the character is to be stored at the index just before the tail
+    // (such that the head would advance to the current tail), the RX FIFO is
+    // full, so don't write the character or advance the head.
+    if (i != t) {
+      rx_buffer.buffer[h] = c;
+      h = i;
+    }
+    #if ENABLED(SERIAL_STATS_DROPPED_RX)
+      else if (!++rx_dropped_bytes) --rx_dropped_bytes;
+    #endif
+
+    #if ENABLED(SERIAL_STATS_MAX_RX_QUEUED)
+      const ring_buffer_pos_t rx_count = (ring_buffer_pos_t)(h - t) & (ring_buffer_pos_t)(RX_BUFFER_SIZE - 1);
+      // Calculate count of bytes stored into the RX buffer
+
+      // Keep track of the maximum count of enqueued bytes
+      NOLESS(rx_max_enqueued, rx_count);
+    #endif
+
+    #if ENABLED(SERIAL_XON_XOFF)
+      // If the last char that was sent was an XON
+      if ((xon_xoff_state & XON_XOFF_CHAR_MASK) == XON_CHAR) {
+
+        // Bytes stored into the RX buffer
+        const ring_buffer_pos_t rx_count = (ring_buffer_pos_t)(h - t) & (ring_buffer_pos_t)(RX_BUFFER_SIZE - 1);
+
+        // If over 12.5% of RX buffer capacity, send XOFF before running out of
+        // RX buffer space .. 325 bytes @ 250kbits/s needed to let the host react
+        // and stop sending bytes. This translates to 13mS propagation time.
+        if (rx_count >= (RX_BUFFER_SIZE) / 8) {
+
+          // At this point, definitely no TX interrupt was executing, since the TX isr can't be preempted.
+          // Don't enable the TX interrupt here as a means to trigger the XOFF char, because if it happens
+          // to be in the middle of trying to disable the RX interrupt in the main program, eventually the
+          // enabling of the TX interrupt could be undone. The ONLY reliable thing this can do to ensure
+          // the sending of the XOFF char is to send it HERE AND NOW.
+
+          // About to send the XOFF char
+          xon_xoff_state = XOFF_CHAR | XON_XOFF_CHAR_SENT;
+
+          // Wait until the TX register becomes empty and send it - Here there could be a problem
+          // - While waiting for the TX register to empty, the RX register could receive a new
+          //   character. This must also handle that situation!
+          uint32_t status;
+          while (!((status = HWUART->UART_SR) & UART_SR_TXRDY)) {
+
+            if (status & UART_SR_RXRDY) {
+              // We received a char while waiting for the TX buffer to be empty - Receive and process it!
+
+              i = (ring_buffer_pos_t)(h + 1) & (ring_buffer_pos_t)(RX_BUFFER_SIZE - 1);
+
+              // Read the character from the USART
+              c = HWUART->UART_RHR;
+
+              #if ENABLED(EMERGENCY_PARSER)
+                emergency_parser.update(emergency_state, c);
+              #endif
+
+              // If the character is to be stored at the index just before the tail
+              // (such that the head would advance to the current tail), the FIFO is
+              // full, so don't write the character or advance the head.
+              if (i != t) {
+                rx_buffer.buffer[h] = c;
+                h = i;
+              }
+              #if ENABLED(SERIAL_STATS_DROPPED_RX)
+                else if (!++rx_dropped_bytes) --rx_dropped_bytes;
+              #endif
+            }
+            sw_barrier();
+          }
+
+          HWUART->UART_THR = XOFF_CHAR;
+
+          // At this point there could be a race condition between the write() function
+          // and this sending of the XOFF char. This interrupt could happen between the
+          // wait to be empty TX buffer loop and the actual write of the character. Since
+          // the TX buffer is full because it's sending the XOFF char, the only way to be
+          // sure the write() function will succeed is to wait for the XOFF char to be
+          // completely sent. Since an extra character could be received during the wait
+          // it must also be handled!
+          while (!((status = HWUART->UART_SR) & UART_SR_TXRDY)) {
+
+            if (status & UART_SR_RXRDY) {
+              // A char arrived while waiting for the TX buffer to be empty - Receive and process it!
+
+              i = (ring_buffer_pos_t)(h + 1) & (ring_buffer_pos_t)(RX_BUFFER_SIZE - 1);
+
+              // Read the character from the USART
+              c = HWUART->UART_RHR;
+
+              #if ENABLED(EMERGENCY_PARSER)
+                emergency_parser.update(emergency_state, c);
+              #endif
+
+              // If the character is to be stored at the index just before the tail
+              // (such that the head would advance to the current tail), the FIFO is
+              // full, so don't write the character or advance the head.
+              if (i != t) {
+                rx_buffer.buffer[h] = c;
+                h = i;
+              }
+              #if ENABLED(SERIAL_STATS_DROPPED_RX)
+                else if (!++rx_dropped_bytes) --rx_dropped_bytes;
+              #endif
+            }
+            sw_barrier();
+          }
+
+          // At this point everything is ready. The write() function won't
+          // have any issues writing to the UART TX register if it needs to!
+        }
+      }
+    #endif // SERIAL_XON_XOFF
+
+    // Store the new head value
+    rx_buffer.head = h;
+  }
+
+  #if TX_BUFFER_SIZE > 0
+
+    FORCE_INLINE void _tx_thr_empty_irq(void) {
+      // Read positions
+      uint8_t t = tx_buffer.tail;
+      const uint8_t h = tx_buffer.head;
+
+      #if ENABLED(SERIAL_XON_XOFF)
+        // If an XON char is pending to be sent, do it now
+        if (xon_xoff_state == XON_CHAR) {
+
+          // Send the character
+          HWUART->UART_THR = XON_CHAR;
+
+          // Remember we sent it.
+          xon_xoff_state = XON_CHAR | XON_XOFF_CHAR_SENT;
+
+          // If nothing else to transmit, just disable TX interrupts.
+          if (h == t) HWUART->UART_IDR = UART_IDR_TXRDY;
+
+          return;
+        }
+      #endif
+
+      // If nothing to transmit, just disable TX interrupts. This could
+      // happen as the result of the non atomicity of the disabling of RX
+      // interrupts that could end reenabling TX interrupts as a side effect.
+      if (h == t) {
+        HWUART->UART_IDR = UART_IDR_TXRDY;
+        return;
+      }
+
+      // There is something to TX, Send the next byte
+      const uint8_t c = tx_buffer.buffer[t];
+      t = (t + 1) & (TX_BUFFER_SIZE - 1);
+      HWUART->UART_THR = c;
+      tx_buffer.tail = t;
+
+      // Disable interrupts if there is nothing to transmit following this byte
+      if (h == t) HWUART->UART_IDR = UART_IDR_TXRDY;
+    }
+
+  #endif // TX_BUFFER_SIZE > 0
+
+  static void UART_ISR(void) {
+    const uint32_t status = HWUART->UART_SR;
+
+    // Data received?
+    if (status & UART_SR_RXRDY) store_rxd_char();
+
+    #if TX_BUFFER_SIZE > 0
+      // Something to send, and TX interrupts are enabled (meaning something to send)?
+      if ((status & UART_SR_TXRDY) && (HWUART->UART_IMR & UART_IMR_TXRDY)) _tx_thr_empty_irq();
+    #endif
+
+    // Acknowledge errors
+    if ((status & UART_SR_OVRE) || (status & UART_SR_FRAME)) {
+
+      #if ENABLED(SERIAL_STATS_DROPPED_RX)
+        if (status & UART_SR_OVRE && !++rx_dropped_bytes) --rx_dropped_bytes;
+      #endif
+
+      #if ENABLED(SERIAL_STATS_RX_BUFFER_OVERRUNS)
+        if (status & UART_SR_OVRE && !++rx_buffer_overruns) --rx_buffer_overruns;
+      #endif
+
+      #if ENABLED(SERIAL_STATS_RX_FRAMING_ERRORS)
+        if (status & UART_SR_FRAME && !++rx_framing_errors) --rx_framing_errors;
+      #endif
+
+      // TODO: error reporting outside ISR
+      HWUART->UART_CR = UART_CR_RSTSTA;
+    }
+  }
+
+  // Public Methods
+
+  void MarlinSerial::begin(const long baud_setting) {
+
+    // Disable UART interrupt in NVIC
+    NVIC_DisableIRQ( HWUART_IRQ );
+
+    // We NEED memory barriers to ensure Interrupts are actually disabled!
+    // ( https://dzone.com/articles/nvic-disabling-interrupts-on-arm-cortex-m-and-the )
+    __DSB();
+    __ISB();
+
+    // Disable clock
+    pmc_disable_periph_clk( HWUART_IRQ_ID );
+
+    // Configure PMC
+    pmc_enable_periph_clk( HWUART_IRQ_ID );
+
+    // Disable PDC channel
+    HWUART->UART_PTCR = UART_PTCR_RXTDIS | UART_PTCR_TXTDIS;
+
+    // Reset and disable receiver and transmitter
+    HWUART->UART_CR = UART_CR_RSTRX | UART_CR_RSTTX | UART_CR_RXDIS | UART_CR_TXDIS;
+
+    // Configure mode: 8bit, No parity, 1 bit stop
+    HWUART->UART_MR = UART_MR_CHMODE_NORMAL | US_MR_CHRL_8_BIT | US_MR_NBSTOP_1_BIT | UART_MR_PAR_NO;
+
+    // Configure baudrate (asynchronous, no oversampling)
+    HWUART->UART_BRGR = (SystemCoreClock / (baud_setting << 4));
+
+    // Configure interrupts
+    HWUART->UART_IDR = 0xFFFFFFFF;
+    HWUART->UART_IER = UART_IER_RXRDY | UART_IER_OVRE | UART_IER_FRAME;
+
+    // Install interrupt handler
+    install_isr(HWUART_IRQ, UART_ISR);
+
+    // Configure priority. We need a very high priority to avoid losing characters
+    // and we need to be able to preempt the Stepper ISR and everything else!
+    // (this could probably be fixed by using DMA with the Serial port)
+    NVIC_SetPriority(HWUART_IRQ, 1);
+
+    // Enable UART interrupt in NVIC
+    NVIC_EnableIRQ(HWUART_IRQ);
+
+    // Enable receiver and transmitter
+    HWUART->UART_CR = UART_CR_RXEN | UART_CR_TXEN;
+
+    #if TX_BUFFER_SIZE > 0
+      _written = false;
+    #endif
+  }
+
+  void MarlinSerial::end() {
+    // Disable UART interrupt in NVIC
+    NVIC_DisableIRQ( HWUART_IRQ );
+
+    // We NEED memory barriers to ensure Interrupts are actually disabled!
+    // ( https://dzone.com/articles/nvic-disabling-interrupts-on-arm-cortex-m-and-the )
+    __DSB();
+    __ISB();
+
+    pmc_disable_periph_clk( HWUART_IRQ_ID );
+  }
+
+  int MarlinSerial::peek(void) {
+    const int v = rx_buffer.head == rx_buffer.tail ? -1 : rx_buffer.buffer[rx_buffer.tail];
+    return v;
+  }
+
+  int MarlinSerial::read(void) {
+
+    const ring_buffer_pos_t h = rx_buffer.head;
+    ring_buffer_pos_t t = rx_buffer.tail;
+
+    if (h == t) return -1;
+
+    int v = rx_buffer.buffer[t];
+    t = (ring_buffer_pos_t)(t + 1) & (RX_BUFFER_SIZE - 1);
+
+    // Advance tail
+    rx_buffer.tail = t;
+
+    #if ENABLED(SERIAL_XON_XOFF)
+      // If the XOFF char was sent, or about to be sent...
+      if ((xon_xoff_state & XON_XOFF_CHAR_MASK) == XOFF_CHAR) {
+        // Get count of bytes in the RX buffer
+        const ring_buffer_pos_t rx_count = (ring_buffer_pos_t)(h - t) & (ring_buffer_pos_t)(RX_BUFFER_SIZE - 1);
+        // When below 10% of RX buffer capacity, send XON before running out of RX buffer bytes
+        if (rx_count < (RX_BUFFER_SIZE) / 10) {
+          #if TX_BUFFER_SIZE > 0
+            // Signal we want an XON character to be sent.
+            xon_xoff_state = XON_CHAR;
+            // Enable TX isr.
+            HWUART->UART_IER = UART_IER_TXRDY;
+          #else
+            // If not using TX interrupts, we must send the XON char now
+            xon_xoff_state = XON_CHAR | XON_XOFF_CHAR_SENT;
+            while (!(HWUART->UART_SR & UART_SR_TXRDY)) sw_barrier();
+            HWUART->UART_THR = XON_CHAR;
+          #endif
+        }
+      }
+    #endif
+
+    return v;
+  }
+
+  ring_buffer_pos_t MarlinSerial::available(void) {
+    const ring_buffer_pos_t h = rx_buffer.head, t = rx_buffer.tail;
+    return (ring_buffer_pos_t)(RX_BUFFER_SIZE + h - t) & (RX_BUFFER_SIZE - 1);
+  }
+
+  void MarlinSerial::flush(void) {
+    rx_buffer.tail = rx_buffer.head;
+
+    #if ENABLED(SERIAL_XON_XOFF)
+      if ((xon_xoff_state & XON_XOFF_CHAR_MASK) == XOFF_CHAR) {
+        #if TX_BUFFER_SIZE > 0
+          // Signal we want an XON character to be sent.
+          xon_xoff_state = XON_CHAR;
+          // Enable TX isr.
+          HWUART->UART_IER = UART_IER_TXRDY;
+        #else
+          // If not using TX interrupts, we must send the XON char now
+          xon_xoff_state = XON_CHAR | XON_XOFF_CHAR_SENT;
+          while (!(HWUART->UART_SR & UART_SR_TXRDY)) sw_barrier();
+          HWUART->UART_THR = XON_CHAR;
+        #endif
+      }
+    #endif
+  }
+
+  #if TX_BUFFER_SIZE > 0
+    void MarlinSerial::write(const uint8_t c) {
+      _written = true;
+
+      // If the TX interrupts are disabled and the data register
+      // is empty, just write the byte to the data register and
+      // be done. This shortcut helps significantly improve the
+      // effective datarate at high (>500kbit/s) bitrates, where
+      // interrupt overhead becomes a slowdown.
+      // Yes, there is a race condition between the sending of the
+      // XOFF char at the RX isr, but it is properly handled there
+      if (!(HWUART->UART_IMR & UART_IMR_TXRDY) && (HWUART->UART_SR & UART_SR_TXRDY)) {
+        HWUART->UART_THR = c;
+        return;
+      }
+
+      const uint8_t i = (tx_buffer.head + 1) & (TX_BUFFER_SIZE - 1);
+
+      // If global interrupts are disabled (as the result of being called from an ISR)...
+      if (!ISRS_ENABLED()) {
+
+        // Make room by polling if it is possible to transmit, and do so!
+        while (i == tx_buffer.tail) {
+          // If we can transmit another byte, do it.
+          if (HWUART->UART_SR & UART_SR_TXRDY) _tx_thr_empty_irq();
+          // Make sure compiler rereads tx_buffer.tail
+          sw_barrier();
+        }
+      }
+      else {
+        // Interrupts are enabled, just wait until there is space
+        while (i == tx_buffer.tail) sw_barrier();
+      }
+
+      // Store new char. head is always safe to move
+      tx_buffer.buffer[tx_buffer.head] = c;
+      tx_buffer.head = i;
+
+      // Enable TX isr - Non atomic, but it will eventually enable TX isr
+      HWUART->UART_IER = UART_IER_TXRDY;
+    }
+
+    void MarlinSerial::flushTX(void) {
+      // TX
+
+      // If we have never written a byte, no need to flush. This special
+      // case is needed since there is no way to force the TXC (transmit
+      // complete) bit to 1 during initialization
+      if (!_written) return;
+
+      // If global interrupts are disabled (as the result of being called from an ISR)...
+      if (!ISRS_ENABLED()) {
+
+        // Wait until everything was transmitted - We must do polling, as interrupts are disabled
+        while (tx_buffer.head != tx_buffer.tail || !(HWUART->UART_SR & UART_SR_TXEMPTY)) {
+          // If there is more space, send an extra character
+          if (HWUART->UART_SR & UART_SR_TXRDY) _tx_thr_empty_irq();
+          sw_barrier();
+        }
+
+      }
+      else {
+        // Wait until everything was transmitted
+        while (tx_buffer.head != tx_buffer.tail || !(HWUART->UART_SR & UART_SR_TXEMPTY)) sw_barrier();
+      }
+
+      // At this point nothing is queued anymore (DRIE is disabled) and
+      // the hardware finished transmission (TXC is set).
+    }
+
+  #else // TX_BUFFER_SIZE == 0
+
+    void MarlinSerial::write(const uint8_t c) {
+      _written = true;
+      while (!(HWUART->UART_SR & UART_SR_TXRDY)) sw_barrier();
+      HWUART->UART_THR = c;
+    }
+
+    void MarlinSerial::flushTX(void) {
+      // TX
+
+      // No bytes written, no need to flush. This special case is needed since there's
+      // no way to force the TXC (transmit complete) bit to 1 during initialization.
+      if (!_written) return;
+
+      // Wait until everything was transmitted
+      while (!(HWUART->UART_SR & UART_SR_TXEMPTY)) sw_barrier();
+
+      // At this point nothing is queued anymore (DRIE is disabled) and
+      // the hardware finished transmission (TXC is set).
+    }
+  #endif // TX_BUFFER_SIZE == 0
+
+  /**
+   * Imports from print.h
+   */
+
+  void MarlinSerial::print(char c, int base) {
+    print((long)c, base);
+  }
+
+  void MarlinSerial::print(unsigned char b, int base) {
+    print((unsigned long)b, base);
+  }
+
+  void MarlinSerial::print(int n, int base) {
+    print((long)n, base);
+  }
+
+  void MarlinSerial::print(unsigned int n, int base) {
+    print((unsigned long)n, base);
+  }
+
+  void MarlinSerial::print(long n, int base) {
+    if (base == 0) write(n);
+    else if (base == 10) {
+      if (n < 0) { print('-'); n = -n; }
+      printNumber(n, 10);
+    }
+    else
+      printNumber(n, base);
+  }
+
+  void MarlinSerial::print(unsigned long n, int base) {
+    if (base == 0) write(n);
+    else printNumber(n, base);
+  }
+
+  void MarlinSerial::print(double n, int digits) {
+    printFloat(n, digits);
+  }
+
+  void MarlinSerial::println(void) {
+    print('\r');
+    print('\n');
+  }
+
+  void MarlinSerial::println(const String& s) {
+    print(s);
+    println();
+  }
+
+  void MarlinSerial::println(const char c[]) {
+    print(c);
+    println();
+  }
+
+  void MarlinSerial::println(char c, int base) {
+    print(c, base);
+    println();
+  }
+
+  void MarlinSerial::println(unsigned char b, int base) {
+    print(b, base);
+    println();
+  }
+
+  void MarlinSerial::println(int n, int base) {
+    print(n, base);
+    println();
+  }
+
+  void MarlinSerial::println(unsigned int n, int base) {
+    print(n, base);
+    println();
+  }
+
+  void MarlinSerial::println(long n, int base) {
+    print(n, base);
+    println();
+  }
+
+  void MarlinSerial::println(unsigned long n, int base) {
+    print(n, base);
+    println();
+  }
+
+  void MarlinSerial::println(double n, int digits) {
+    print(n, digits);
+    println();
+  }
+
+  // Private Methods
+
+  void MarlinSerial::printNumber(unsigned long n, uint8_t base) {
+    if (n) {
+      unsigned char buf[8 * sizeof(long)]; // Enough space for base 2
+      int8_t i = 0;
+      while (n) {
+        buf[i++] = n % base;
+        n /= base;
+      }
+      while (i--)
+        print((char)(buf[i] + (buf[i] < 10 ? '0' : 'A' - 10)));
+    }
+    else
+      print('0');
+  }
+
+  void MarlinSerial::printFloat(double number, uint8_t digits) {
+    // Handle negative numbers
+    if (number < 0.0) {
+      print('-');
+      number = -number;
+    }
+
+    // Round correctly so that print(1.999, 2) prints as "2.00"
+    double rounding = 0.5;
+    for (uint8_t i = 0; i < digits; ++i) rounding *= 0.1;
+    number += rounding;
+
+    // Extract the integer part of the number and print it
+    unsigned long int_part = (unsigned long)number;
+    double remainder = number - (double)int_part;
+    print(int_part);
+
+    // Print the decimal point, but only if there are digits beyond
+    if (digits) {
+      print('.');
+      // Extract digits from the remainder one at a time
+      while (digits--) {
+        remainder *= 10.0;
+        int toPrint = int(remainder);
+        print(toPrint);
+        remainder -= toPrint;
+      }
+    }
+  }
+
+  // Preinstantiate
+  MarlinSerial customizedSerial;
+#endif
+
+#endif // ARDUINO_ARCH_SAM
--- a/Marlin/src/HAL/HAL_DUE/MarlinSerial_Due.h
+++ b/Marlin/src/HAL/HAL_DUE/MarlinSerial_Due.h
@@ -0,0 +1,148 @@
+/**
+ * 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/>.
+ *
+ */
+
+/**
+ * MarlinSerial_Due.h - Hardware serial library for Arduino DUE
+ * Copyright (c) 2017 Eduardo José Tagle. All right reserved
+ * Based on MarlinSerial for AVR, copyright (c) 2006 Nicholas Zambetti.  All right reserved.
+ */
+
+#ifndef MARLINSERIAL_DUE_H
+#define MARLINSERIAL_DUE_H
+
+#include "../../inc/MarlinConfig.h"
+
+#if SERIAL_PORT >= 0
+
+#include <WString.h>
+
+#define DEC 10
+#define HEX 16
+#define OCT 8
+#define BIN 2
+
+// Define constants and variables for buffering incoming serial data.  We're
+// using a ring buffer (I think), in which rx_buffer_head is the index of the
+// location to which to write the next incoming character and rx_buffer_tail
+// is the index of the location from which to read.
+// 256 is the max limit due to uint8_t head and tail. Use only powers of 2. (...,16,32,64,128,256)
+#ifndef RX_BUFFER_SIZE
+  #define RX_BUFFER_SIZE 128
+#endif
+#ifndef TX_BUFFER_SIZE
+  #define TX_BUFFER_SIZE 32
+#endif
+
+//#if ENABLED(SERIAL_XON_XOFF) && RX_BUFFER_SIZE < 1024
+//  #error "SERIAL_XON_XOFF requires RX_BUFFER_SIZE >= 1024 for reliable transfers without drops."
+//#elif RX_BUFFER_SIZE && (RX_BUFFER_SIZE < 2 || !IS_POWER_OF_2(RX_BUFFER_SIZE))
+//  #error "RX_BUFFER_SIZE must be a power of 2 greater than 1."
+//#elif TX_BUFFER_SIZE && (TX_BUFFER_SIZE < 2 || TX_BUFFER_SIZE > 256 || !IS_POWER_OF_2(TX_BUFFER_SIZE))
+//  #error "TX_BUFFER_SIZE must be 0, a power of 2 greater than 1, and no greater than 256."
+//#endif
+
+#if RX_BUFFER_SIZE > 256
+  typedef uint16_t ring_buffer_pos_t;
+#else
+  typedef uint8_t ring_buffer_pos_t;
+#endif
+
+#if ENABLED(SERIAL_STATS_DROPPED_RX)
+  extern uint8_t rx_dropped_bytes;
+#endif
+
+#if ENABLED(SERIAL_STATS_RX_BUFFER_OVERRUNS)
+  extern uint8_t rx_buffer_overruns;
+#endif
+
+#if ENABLED(SERIAL_STATS_RX_FRAMING_ERRORS)
+  extern uint8_t rx_framing_errors;
+#endif
+
+#if ENABLED(SERIAL_STATS_MAX_RX_QUEUED)
+  extern ring_buffer_pos_t rx_max_enqueued;
+#endif
+
+class MarlinSerial {
+
+public:
+  MarlinSerial() {};
+  static void begin(const long);
+  static void end();
+  static int peek(void);
+  static int read(void);
+  static void flush(void);
+  static ring_buffer_pos_t available(void);
+  static void write(const uint8_t c);
+  static void flushTX(void);
+
+  #if ENABLED(SERIAL_STATS_DROPPED_RX)
+    FORCE_INLINE static uint32_t dropped() { return rx_dropped_bytes; }
+  #endif
+
+  #if ENABLED(SERIAL_STATS_RX_BUFFER_OVERRUNS)
+    FORCE_INLINE static uint32_t buffer_overruns() { return rx_buffer_overruns; }
+  #endif
+
+  #if ENABLED(SERIAL_STATS_RX_FRAMING_ERRORS)
+    FORCE_INLINE static uint32_t framing_errors() { return rx_framing_errors; }
+  #endif
+
+  #if ENABLED(SERIAL_STATS_MAX_RX_QUEUED)
+    FORCE_INLINE static ring_buffer_pos_t rxMaxEnqueued() { return rx_max_enqueued; }
+  #endif
+
+  FORCE_INLINE static void write(const char* str) { while (*str) write(*str++); }
+  FORCE_INLINE static void write(const uint8_t* buffer, size_t size) { while (size--) write(*buffer++); }
+  FORCE_INLINE static void print(const String& s) { for (int i = 0; i < (int)s.length(); i++) write(s[i]); }
+  FORCE_INLINE static void print(const char* str) { write(str); }
+
+  static void print(char, int = 0);
+  static void print(unsigned char, int = 0);
+  static void print(int, int = DEC);
+  static void print(unsigned int, int = DEC);
+  static void print(long, int = DEC);
+  static void print(unsigned long, int = DEC);
+  static void print(double, int = 2);
+
+  static void println(const String& s);
+  static void println(const char[]);
+  static void println(char, int = 0);
+  static void println(unsigned char, int = 0);
+  static void println(int, int = DEC);
+  static void println(unsigned int, int = DEC);
+  static void println(long, int = DEC);
+  static void println(unsigned long, int = DEC);
+  static void println(double, int = 2);
+  static void println(void);
+  operator bool() { return true; }
+
+private:
+  static void printNumber(unsigned long, const uint8_t);
+  static void printFloat(double, uint8_t);
+};
+
+extern MarlinSerial customizedSerial;
+
+#endif // SERIAL_PORT >= 0
+
+#endif // MARLINSERIAL_DUE_H
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Scott Lahteine	0bdea3f854	Fit task code for updated Max7219	2018-09-10 04:16:25 -05:00
Scott Lahteine	bef6b94b7e	Max7219 RTOS changes	2018-09-10 04:14:37 -05:00
Scott Lahteine	05fe47e59a	Add M101 command for RTOS	2018-09-10 04:12:01 -05:00
Roxy-3D	a1fdfa56f5	Marlin on RTOS	2018-09-10 04:12:01 -05:00
Scott Lahteine	4e3bad6dce	Due HAL tweak	2018-09-10 04:11:42 -05:00