Update Configuration.h

Update _Statusscreen.h
2019-08-01 17:11:08 -04:00 · 2019-07-31 22:19:01 -04:00 · 2019-07-31 22:04:49 -04:00 · 2019-07-31 21:59:28 -04:00 · 2019-07-31 21:58:38 -04:00 · 2019-07-31 21:58:24 -04:00
1450 changed files with 57519 additions and 282745 deletions
@@ -0,0 +1,274 @@
+# 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
+            #
+            # Back up pins_RAMPS.h
+            #
+            backup_ramps
+
+            env_backup
+
+            #################################
+            # Build all sample configurations
+            #################################
+
+            echo testing megaatmega2560 targets...
+            export TEST_PLATFORM="-e megaatmega2560"
+            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 FolgerTech/i3-2020
+            use_example_configs FolgerTech/i3-2020
+            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
+            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}
+            restore_configs
+            # Requires manual load of https://github.com/stawel/SlowSoftI2CMaster
+            #use_example_configs wt150
+            #build_marlin_pio ./ ${TEST_PLATFORM}
+            #restore_configs
+            echo testing melzi targets...
+            export TEST_PLATFORM="-e melzi"
+            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}
+            restore_configs
+
+            echo testing rambo targets...
+            export TEST_PLATFORM="-e rambo"
+            echo use_example_configs AlephObjects/TAZ4
+            use_example_configs AlephObjects/TAZ4
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+
+            echo testing at90usb1286_* targets...
+            export TEST_PLATFORM="-e at90usb1286_dfu"
+            #echo se_example_configs delta/kossel_pro
+            #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}
+            restore_configs
+
+            echo testing sanguino_atmega644p targets...
+            export TEST_PLATFORM="-e sanguino_atmega644p"
+            echo use_example_configs tvrrug/Round2
+            use_example_configs tvrrug/Round2
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+
+            echo testing LPC1768 targets...
+            export TEST_PLATFORM="-e LPC1768"
+            echo use_example_configs Mks/Sbase
+            use_example_configs Mks/Sbase
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo testing STM32F1 targets...
+            export TEST_PLATFORM="-e STM32F1"
+            restore_configs
+            echo use_example_configs STM32F10
+            use_example_configs STM32F10
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs stm32f103ret6
+            use_example_configs stm32f103ret6
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+
+            echo testing DUE targets...
+            export TEST_PLATFORM="-e DUE"
+            #echo use_example_configs UltiMachine/Archim2
+            #use_example_configs UltiMachine/Archim2
+            #build_marlin_pio ./ ${TEST_PLATFORM}
+            #restore_configs
+
+            #
+            # 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" }}
@@ -1 +0,0 @@
-custom: http://www.thinkyhead.com/donate-to-marlin
@@ -2,7 +2,7 @@

 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/bugfix-2.0.x/.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 the Marlin Firmware forum at http://forums.reprap.org/list.php?415 or the Marlin Facebook Group https://www.facebook.com/groups/1049718498464482/ or the Marlin Discord Server https://discord.gg/n5NJ59y.
+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/.

 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.

@@ -1,25 +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: source ./buildroot/bin/bump_date
@@ -1,100 +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
-        - megaatmega2560
-        - teensy31
-        - teensy35
-
-        # Extended AVR Environments
-
-        - FYSETC_F6_13
-        - megaatmega1280
-        - rambo
-        - sanguino_atmega1284p
-        - sanguino_atmega644p
-
-        # Extended STM32 Environments
-
-        - STM32F103RC_bigtree
-        - STM32F103RC_bigtree_USB
-        - STM32F103RE_bigtree
-        - STM32F103RE_bigtree_USB
-        - STM32F103RC_fysetc
-        - jgaurora_a5s_a1
-        - STM32F103VE_longer
-        - STM32F407VE_black
-        - BIGTREE_SKR_PRO
-        - mks_robin
-        - ARMED
-
-        # 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
-        #- SAMD51_grandcentral_m4
-
-    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: |
-        chmod +x buildroot/bin/*
-        chmod +x buildroot/share/tests/*
-        export PATH=./buildroot/bin/:./buildroot/share/tests/:${PATH}
-        run_tests . ${{ matrix.test-platform }}
@@ -0,0 +1,62 @@
+dist: xenial
+sudo: require
+
+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="DUE"
+  - TEST_PLATFORM="LPC1768"
+  - TEST_PLATFORM="LPC1769"
+  - TEST_PLATFORM="STM32F1"
+  - TEST_PLATFORM="teensy35"
+  - TEST_PLATFORM="linux_native"
+  - TEST_PLATFORM="esp32"
+
+addons:
+  apt:
+    sources:
+      - ubuntu-toolchain-r-test
+    packages:
+      - g++-7
+
+before_install:
+  - sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-7 90
+  #
+  # Fetch the tag information for the current branch
+  - git fetch origin --tags
+  #
+  # Publish the buildroot script folder
+  - chmod +x ${TRAVIS_BUILD_DIR}/buildroot/bin/*
+  - chmod +x ${TRAVIS_BUILD_DIR}/buildroot/share/tests/*
+  - export PATH=${TRAVIS_BUILD_DIR}/buildroot/bin/:${TRAVIS_BUILD_DIR}/buildroot/share/tests/:${PATH}
+
+install:
+  #- pip install -U platformio
+  - pip install -U https://github.com/platformio/platformio-core/archive/master.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:
+  - run_tests ${TRAVIS_BUILD_DIR} ${TEST_PLATFORM}
@@ -92,9 +92,6 @@ U8GLIB             ?= 1
 # this defines whether to include the Trinamic TMCStepper library
 TMC                ?= 1

-# this defines whether to include the AdaFruit NeoPixel library
-NEOPIXEL           ?= 0
-
 ############
 # Try to automatically determine whether RELOC_WORKAROUND is needed based
 # on GCC versions:
@@ -188,7 +185,7 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1109)
 else ifeq ($(HARDWARE_MOTHERBOARD),1110)
 # zrib V2.0 control board (Chinese knock off RAMPS replica)
 else ifeq ($(HARDWARE_MOTHERBOARD),1111)
-# BigTreeTech or BIQU KFB2.0
+# Bigtreetech or BIQU KFB2.0
 else ifeq ($(HARDWARE_MOTHERBOARD),1112)
 # Felix 2.0+ Electronics Board (RAMPS like)
 else ifeq ($(HARDWARE_MOTHERBOARD),1113)
@@ -240,7 +237,7 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1134)
 else ifeq ($(HARDWARE_MOTHERBOARD),1135)
 # Dagoma F5
 else ifeq ($(HARDWARE_MOTHERBOARD),1136)
-# FYSETC F6
+# Fysetc F6
 else ifeq ($(HARDWARE_MOTHERBOARD),1137)
 # Duplicator i3 Plus
 else ifeq ($(HARDWARE_MOTHERBOARD),1138)
@@ -250,18 +247,6 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1139)
 else ifeq ($(HARDWARE_MOTHERBOARD),1140)
 # Z-Bolt X Series
 else ifeq ($(HARDWARE_MOTHERBOARD),1141)
-# TT OSCAR
-else ifeq ($(HARDWARE_MOTHERBOARD),1142)
-# Overlord/Overlord Pro
-else ifeq ($(HARDWARE_MOTHERBOARD),1143)
-# ADIMLab Gantry v1
-else ifeq ($(HARDWARE_MOTHERBOARD),1144)
-# ADIMLab Gantry v2
-else ifeq ($(HARDWARE_MOTHERBOARD),1145)
-# BIQU Tango V1
-else ifeq ($(HARDWARE_MOTHERBOARD),1146)
-# MKS GEN L V2
-else ifeq ($(HARDWARE_MOTHERBOARD),1147)

 #
 # RAMBo and derivatives
@@ -288,54 +273,50 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1205)
 else ifeq ($(HARDWARE_MOTHERBOARD),1300)
 # Cartesio CN Controls V12
 else ifeq ($(HARDWARE_MOTHERBOARD),1301)
-# Cartesio CN Controls V15
-else ifeq ($(HARDWARE_MOTHERBOARD),1302)
 # Cheaptronic v1.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1303)
+else ifeq ($(HARDWARE_MOTHERBOARD),1302)
 # Cheaptronic v2.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1304)
+else ifeq ($(HARDWARE_MOTHERBOARD),1303)
 # Makerbot Mightyboard Revision E
-else ifeq ($(HARDWARE_MOTHERBOARD),1305)
+else ifeq ($(HARDWARE_MOTHERBOARD),1304)
 # Megatronics
-else ifeq ($(HARDWARE_MOTHERBOARD),1306)
+else ifeq ($(HARDWARE_MOTHERBOARD),1305)
 # Megatronics v2.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1307)
+else ifeq ($(HARDWARE_MOTHERBOARD),1306)
 # Megatronics v3.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1308)
+else ifeq ($(HARDWARE_MOTHERBOARD),1307)
 # Megatronics v3.1
-else ifeq ($(HARDWARE_MOTHERBOARD),1309)
+else ifeq ($(HARDWARE_MOTHERBOARD),1308)
 # Megatronics v3.2
-else ifeq ($(HARDWARE_MOTHERBOARD),1310)
+else ifeq ($(HARDWARE_MOTHERBOARD),1309)
 # Elefu Ra Board (v3)
-else ifeq ($(HARDWARE_MOTHERBOARD),1311)
+else ifeq ($(HARDWARE_MOTHERBOARD),1310)
 # Leapfrog
-else ifeq ($(HARDWARE_MOTHERBOARD),1312)
+else ifeq ($(HARDWARE_MOTHERBOARD),1311)
 # Mega controller
-else ifeq ($(HARDWARE_MOTHERBOARD),1313)
+else ifeq ($(HARDWARE_MOTHERBOARD),1312)
 # Geeetech GT2560 Rev B for Mecreator2
-else ifeq ($(HARDWARE_MOTHERBOARD),1314)
+else ifeq ($(HARDWARE_MOTHERBOARD),1313)
 # Geeetech GT2560 Rev. A
-else ifeq ($(HARDWARE_MOTHERBOARD),1315)
+else ifeq ($(HARDWARE_MOTHERBOARD),1314)
 # Geeetech GT2560 Rev. A+ (with auto level probe)
-else ifeq ($(HARDWARE_MOTHERBOARD),1316)
+else ifeq ($(HARDWARE_MOTHERBOARD),1315)
 # Geeetech GT2560 Rev B for A10(M/D)
-else ifeq ($(HARDWARE_MOTHERBOARD),1317)
+else ifeq ($(HARDWARE_MOTHERBOARD),1316)
 # Geeetech GT2560 Rev B for A20(M/D)
-else ifeq ($(HARDWARE_MOTHERBOARD),1318)
+else ifeq ($(HARDWARE_MOTHERBOARD),1317)
 # Einstart retrofit
-else ifeq ($(HARDWARE_MOTHERBOARD),1319)
+else ifeq ($(HARDWARE_MOTHERBOARD),1318)
 # Wanhao 0ne+ i3 Mini
-else ifeq ($(HARDWARE_MOTHERBOARD),1320)
+else ifeq ($(HARDWARE_MOTHERBOARD),1319)

 #
 # ATmega1281, ATmega2561
 #

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

 #
@@ -700,7 +681,7 @@ 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 \
+CTUNING = -fsigned-char -funsigned-bitfields -fpack-struct -fno-exceptions \
          -fshort-enums -ffunction-sections -fdata-sections
 ifneq ($(HARDWARE_MOTHERBOARD),)
  CTUNING += -DMOTHERBOARD=${HARDWARE_MOTHERBOARD}
@@ -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

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

 /**
 * Custom Status Screen bitmap
@@ -34,17 +33,29 @@
 //
 // Status Screen Logo bitmap
 //
-#define STATUS_LOGO_Y           10
-#define STATUS_LOGO_WIDTH       40
+#define STATUS_LOGO_Y            3
+#define STATUS_LOGO_WIDTH       24

 const unsigned char status_logo_bmp[] PROGMEM = {
-  B01110000,B00000000,B00001000,B00000011,B10001110,
-  B10001000,B00000000,B00001000,B00000100,B01010001,
-  B10001010,B11000111,B00111110,B00000100,B01010001,
-  B11111011,B00101000,B10001000,B00000111,B11001110,
-  B10001010,B00101111,B00001000,B00000100,B01010001,
-  B10001010,B00101000,B00001000,B00000100,B01010001,
-  B10001010,B00100111,B00000110,B00000100,B01001110
+  B11111111,B11111111,B11111111,
+  B10000000,B00000000,B00000001,
+  B10001110,B00000000,B11100001,
+  B10011111,B00000001,B11110001,
+  B10010011,B10000001,B00111001,
+  B10011111,B10000001,B11111001,
+  B10011111,B10000001,B11111001,
+  B10011111,B10111001,B11111001,
+  B10001111,B00101000,B11110001,
+  B10000000,B00111000,B00000001,
+  B10000000,B00000000,B00000001,
+  B10011111,B11111111,B11111001,
+  B10010001,B01110100,B10011001,
+  B10011011,B00000110,B10101001,
+  B10011011,B01010100,B10101001,
+  B10011011,B01010110,B10101001,
+  B10011011,B01010100,B10011001,
+  B10011111,B11111111,B11111001,
+  B11111111,B11111111,B11111111
 };

 //
@@ -52,5 +63,12 @@ const unsigned char status_logo_bmp[] PROGMEM = {
 //
 #define STATUS_HOTEND_ANIM
 #define STATUS_BED_ANIM
-#define STATUS_HEATERS_X      48
-#define STATUS_BED_X          74
+#if HOTENDS < 2
+  #define STATUS_LOGO_X          8
+  #define STATUS_HEATERS_X      40
+  #define STATUS_BED_X          72
+#else
+  #define STATUS_LOGO_X          0
+  #define STATUS_HEATERS_X      32
+  #define STATUS_BED_X          80
+#endif
@@ -24,11 +24,3 @@
 #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
-}
@@ -35,7 +35,7 @@
 // Public functions
 // ------------------------

-void HAL_init() {
+void HAL_init(void) {
  // Init Servo Pins
  #define INIT_SERVO(N) OUT_WRITE(SERVO##N##_PIN, LOW)
  #if HAS_SERVO_0
@@ -20,12 +20,12 @@

 #include "../shared/Marduino.h"
 #include "../shared/HAL_SPI.h"
-#include "fastio.h"
-#include "watchdog.h"
-#include "math.h"
+#include "fastio_AVR.h"
+#include "watchdog_AVR.h"
+#include "math_AVR.h"

 #ifdef USBCON
-  #include <HardwareSerial.h>
+  #include "HardwareSerial.h"
 #else
  #define HardwareSerial_h // Hack to prevent HardwareSerial.h header inclusion
  #include "MarlinSerial.h"
@@ -38,14 +38,6 @@
 #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)
-#endif
-
 // ------------------------
 // Defines
 // ------------------------
@@ -113,21 +105,18 @@ typedef int8_t pin_t;
 // Public functions
 // ------------------------

-void HAL_init();
+void HAL_init(void);

-//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
@@ -154,7 +143,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
@@ -206,9 +196,9 @@ FORCE_INLINE void HAL_timer_start(const uint8_t timer_num, const uint32_t) {

 /* 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() { \
+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 */ \
@@ -275,13 +265,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() { \
+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 */ \
@@ -341,7 +331,7 @@ void TIMER0_COMPB_vect() { \
    : \
  ); \
 } \
-void TIMER0_COMPB_vect_bottom()
+void TIMER0_COMPB_vect_bottom(void)

 // ADC
 #ifdef DIDR2
@@ -350,7 +340,7 @@ void TIMER0_COMPB_vect_bottom()
  #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
@@ -365,7 +355,6 @@ inline void HAL_adc_init() {
  #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)

@@ -33,7 +33,7 @@

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

-void spiBegin() {
+void spiBegin(void) {
  OUT_WRITE(SS_PIN, HIGH);
  SET_OUTPUT(SCK_PIN);
  SET_INPUT(MISO_PIN);
@@ -81,7 +81,7 @@ void spiBegin() {
  }

  /** SPI receive a byte */
-  uint8_t spiRec() {
+  uint8_t spiRec(void) {
    SPDR = 0xFF;
    while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
    return SPDR;
@@ -184,10 +184,15 @@ void spiBegin() {
  // 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) {
+    UNUSED(spiRate);  // nothing to do
+  }

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

  // Soft SPI receive byte
  uint8_t spiRec() {
@@ -271,7 +271,7 @@

  // (called with TX irqs disabled)
  template<typename Cfg>
-  FORCE_INLINE void MarlinSerial<Cfg>::_tx_udr_empty_irq() {
+  FORCE_INLINE void MarlinSerial<Cfg>::_tx_udr_empty_irq(void) {
    if (Cfg::TX_SIZE > 0) {
      // Read positions
      uint8_t t = tx_buffer.tail;
@@ -363,13 +363,13 @@
  }

  template<typename Cfg>
-  int MarlinSerial<Cfg>::peek() {
+  int MarlinSerial<Cfg>::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<Cfg>::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
@@ -412,13 +412,13 @@
  }

  template<typename Cfg>
-  typename MarlinSerial<Cfg>::ring_buffer_pos_t MarlinSerial<Cfg>::available() {
+  typename MarlinSerial<Cfg>::ring_buffer_pos_t MarlinSerial<Cfg>::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);
  }

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

    // Set the tail to the head:
    //  - Read the RX head index in a safe way. (See atomic_read_rx_head.)
@@ -505,7 +505,7 @@
  }

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

    if (Cfg::TX_SIZE == 0) {
      // No bytes written, no need to flush. This special case is needed since there's
@@ -595,7 +595,7 @@
  }

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

    FORCE_INLINE static void store_rxd_char();
-    FORCE_INLINE static void _tx_udr_empty_irq();
+    FORCE_INLINE static void _tx_udr_empty_irq(void);

    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 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();
+      static void flushTX(void);

      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; }
@@ -245,7 +245,7 @@
      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:
@@ -53,8 +53,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__)
@@ -41,60 +41,44 @@
 #include <stdint.h>

 // One ISR for all EXT-Interrupts
-void endstop_ISR() { endstops.update(); }
+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 (D14, D15).
+ * 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)
-
-  #define digitalPinHasPCICR(p)   (WITHIN(p, 10, 15) || WITHIN(p, 50, 53) || WITHIN(p, 62, 69))
-
  #undef  digitalPinToPCICR
-  #define digitalPinToPCICR(p)    (digitalPinHasPCICR(p) ? (&PCICR) : nullptr)
-
+  #define digitalPinToPCICR(p)    ( WITHIN(p, 10, 15) || \
+                                    WITHIN(p, 50, 53) || \
+                                    WITHIN(p, 62, 69) ? &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)
-
+  #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)
-
+  #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!"
-
+  #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) {
-  if (digitalPinHasPCICR(pin)) {
+  if (digitalPinToPCMSK(pin) != nullptr) {
    SBI(*digitalPinToPCMSK(pin), digitalPinToPCMSKbit(pin));  // enable pin
    SBI(PCIFR, digitalPinToPCICRbit(pin)); // clear any outstanding interrupt
    SBI(PCICR, digitalPinToPCICRbit(pin)); // enable interrupt for the group
@@ -118,125 +102,154 @@ void pciSetup(const int8_t pin) {
  ISR(PCINT3_vect, ISR_ALIASOF(PCINT0_vect));
 #endif

-void setup_endstop_interrupts() {
-  #define _ATTACH(P) attachInterrupt(digitalPinToInterrupt(P), endstop_ISR, CHANGE)
+void setup_endstop_interrupts( void ) {
+
  #if HAS_X_MAX
-    #if (digitalPinToInterrupt(X_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(X_MAX_PIN);
+    #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
-      static_assert(digitalPinHasPCICR(X_MAX_PIN), "X_MAX_PIN is not interrupt-capable");
-      pciSetup(X_MAX_PIN);
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(X_MAX_PIN), "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)
-      _ATTACH(X_MIN_PIN);
+      attachInterrupt(digitalPinToInterrupt(X_MIN_PIN), endstop_ISR, CHANGE);
    #else
-      static_assert(digitalPinHasPCICR(X_MIN_PIN), "X_MIN_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(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);
+      attachInterrupt(digitalPinToInterrupt(Y_MAX_PIN), endstop_ISR, CHANGE);
    #else
-      static_assert(digitalPinHasPCICR(Y_MAX_PIN), "Y_MAX_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(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);
+      attachInterrupt(digitalPinToInterrupt(Y_MIN_PIN), endstop_ISR, CHANGE);
    #else
-      static_assert(digitalPinHasPCICR(Y_MIN_PIN), "Y_MIN_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(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);
+      attachInterrupt(digitalPinToInterrupt(Z_MAX_PIN), endstop_ISR, CHANGE);
    #else
-      static_assert(digitalPinHasPCICR(Z_MAX_PIN), "Z_MAX_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(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);
+      attachInterrupt(digitalPinToInterrupt(Z_MIN_PIN), endstop_ISR, CHANGE);
    #else
-      static_assert(digitalPinHasPCICR(Z_MIN_PIN), "Z_MIN_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(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);
+      attachInterrupt(digitalPinToInterrupt(X2_MAX_PIN), endstop_ISR, CHANGE);
    #else
-      static_assert(digitalPinHasPCICR(X2_MAX_PIN), "X2_MAX_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(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);
+      attachInterrupt(digitalPinToInterrupt(X2_MIN_PIN), endstop_ISR, CHANGE);
    #else
-      static_assert(digitalPinHasPCICR(X2_MIN_PIN), "X2_MIN_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(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);
+      attachInterrupt(digitalPinToInterrupt(Y2_MAX_PIN), endstop_ISR, CHANGE);
    #else
-      static_assert(digitalPinHasPCICR(Y2_MAX_PIN), "Y2_MAX_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(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);
+      attachInterrupt(digitalPinToInterrupt(Y2_MIN_PIN), endstop_ISR, CHANGE);
    #else
-      static_assert(digitalPinHasPCICR(Y2_MIN_PIN), "Y2_MIN_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(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);
+      attachInterrupt(digitalPinToInterrupt(Z2_MAX_PIN), endstop_ISR, CHANGE);
    #else
-      static_assert(digitalPinHasPCICR(Z2_MAX_PIN), "Z2_MAX_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(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);
+      attachInterrupt(digitalPinToInterrupt(Z2_MIN_PIN), endstop_ISR, CHANGE);
    #else
-      static_assert(digitalPinHasPCICR(Z2_MIN_PIN), "Z2_MIN_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(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);
+      attachInterrupt(digitalPinToInterrupt(Z3_MAX_PIN), endstop_ISR, CHANGE);
    #else
-      static_assert(digitalPinHasPCICR(Z3_MAX_PIN), "Z3_MAX_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(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);
+      attachInterrupt(digitalPinToInterrupt(Z3_MIN_PIN), endstop_ISR, CHANGE);
    #else
-      static_assert(digitalPinHasPCICR(Z3_MIN_PIN), "Z3_MIN_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Z3_MIN_PIN), "Z3_MIN_PIN is not interrupt-capable");
      pciSetup(Z3_MIN_PIN);
    #endif
  #endif
+
  #if HAS_Z_MIN_PROBE_PIN
    #if (digitalPinToInterrupt(Z_MIN_PROBE_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z_MIN_PROBE_PIN);
+      attachInterrupt(digitalPinToInterrupt(Z_MIN_PROBE_PIN), endstop_ISR, CHANGE);
    #else
-      static_assert(digitalPinHasPCICR(Z_MIN_PROBE_PIN), "Z_MIN_PROBE_PIN is not interrupt-capable");
+      // 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), "Z_MIN_PROBE_PIN is not interrupt-capable");
      pciSetup(Z_MIN_PROBE_PIN);
    #endif
  #endif
@@ -23,7 +23,7 @@

 #include "../../inc/MarlinConfigPre.h"

-#if ENABLED(FAST_PWM_FAN) || SPINDLE_LASER_PWM
+#if ENABLED(FAST_PWM_FAN)

 #include "HAL.h"

@@ -59,19 +59,19 @@ Timer get_pwm_timer(const pin_t pin) {
      #ifdef TCCR2
        case TIMER2: {
          Timer timer = {
-            /*TCCRnQ*/  { &TCCR2, nullptr, nullptr },
-            /*OCRnQ*/   { (uint16_t*)&OCR2, nullptr, nullptr },
+            /*TCCRnQ*/  { &TCCR2, nullptr, nullptr},
+            /*OCRnQ*/   { (uint16_t*)&OCR2, nullptr, nullptr},
            /*ICRn*/      nullptr,
            /*n, q*/      2, 0
          };
        }
-      #elif defined(TCCR2A)
+      #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 },
+              /*TCCRnQ*/  { &TCCR2A,  &TCCR2B,  nullptr},
+              /*OCRnQ*/   { (uint16_t*)&OCR2A, (uint16_t*)&OCR2B, nullptr},
              /*ICRn*/      nullptr,
              /*n, q*/      2, 1
            };
@@ -81,8 +81,8 @@ Timer get_pwm_timer(const pin_t pin) {
          case TIMER2B:   ++q;
          case TIMER2A: {
            Timer timer = {
-              /*TCCRnQ*/  { &TCCR2A,  &TCCR2B,  nullptr },
-              /*OCRnQ*/   { (uint16_t*)&OCR2A, (uint16_t*)&OCR2B, nullptr },
+              /*TCCRnQ*/  { &TCCR2A,  &TCCR2B,  nullptr},
+              /*OCRnQ*/   { (uint16_t*)&OCR2A, (uint16_t*)&OCR2B, nullptr},
              /*ICRn*/      nullptr,
                            2, q
            };
@@ -91,24 +91,13 @@ Timer get_pwm_timer(const pin_t pin) {
        #endif
      #endif
    #endif
-    #ifdef OCR3C
+    #ifdef TCCR3A
      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 },
+          /*TCCRnQ*/  { &TCCR3A,  &TCCR3B,  &TCCR3C},
+          /*OCRnQ*/   { &OCR3A,   &OCR3B,   &OCR3C},
          /*ICRn*/      &ICR3,
          /*n, q*/      3, q
        };
@@ -120,8 +109,8 @@ Timer get_pwm_timer(const pin_t pin) {
      case TIMER4B:   ++q;
      case TIMER4A: {
        Timer timer = {
-          /*TCCRnQ*/  { &TCCR4A,  &TCCR4B,  &TCCR4C },
-          /*OCRnQ*/   { &OCR4A,   &OCR4B,   &OCR4C },
+          /*TCCRnQ*/  { &TCCR4A,  &TCCR4B,  &TCCR4C},
+          /*OCRnQ*/   { &OCR4A,   &OCR4B,   &OCR4C},
          /*ICRn*/      &ICR4,
          /*n, q*/      4, q
        };
@@ -133,7 +122,7 @@ Timer get_pwm_timer(const pin_t pin) {
      case TIMER5B:   ++q;
      case TIMER5A: {
        Timer timer = {
-          /*TCCRnQ*/  { &TCCR5A,  &TCCR5B,  &TCCR5C },
+          /*TCCRnQ*/  { &TCCR5A,  &TCCR5B,  &TCCR5C},
          /*OCRnQ*/   { &OCR5A,   &OCR5B,   &OCR5C },
          /*ICRn*/      &ICR5,
          /*n, q*/      5, q
@@ -143,8 +132,8 @@ Timer get_pwm_timer(const pin_t pin) {
    #endif
  }
  Timer timer = {
-      /*TCCRnQ*/  { nullptr, nullptr, nullptr },
-      /*OCRnQ*/   { nullptr, nullptr, nullptr },
+      /*TCCRnQ*/  { nullptr, nullptr, nullptr},
+      /*OCRnQ*/   { nullptr, nullptr, nullptr},
      /*ICRn*/      nullptr,
                    0, 0
  };
@@ -278,5 +267,5 @@ void set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size/*=255
  }
 }

-#endif // FAST_PWM_FAN || SPINDLE_LASER_PWM
+#endif // FAST_PWM_FAN
 #endif // __AVR__
@@ -29,7 +29,7 @@
 *   Logical Pin   : 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 | 78 79 80 xx xx 84 85 71 70 xx xx xx xx xx 81 82 83 xx xx 72 72 75 76 77 74 xx xx xx xx xx
 */

-#include "../fastio.h"
+#include "../fastio_AVR.h"

 // change for your board
 #define DEBUG_LED   DIO21
@@ -28,7 +28,7 @@
 *   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"
+#include "../fastio_AVR.h"

 // change for your board
 #define DEBUG_LED   DIO46
@@ -28,7 +28,7 @@
 *   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"
+#include "../fastio_AVR.h"

 #define DEBUG_LED   AIO5

@@ -54,7 +54,7 @@
 *                        +--------+
 */

-#include "../fastio.h"
+#include "../fastio_AVR.h"

 #define DEBUG_LED   DIO0

@@ -29,7 +29,7 @@
 *            The logical pins 46 and 47 are not supported by Teensyduino, but are supported below as E2 and E3
 */

-#include "../fastio.h"
+#include "../fastio_AVR.h"

 // change for your board
 #define DEBUG_LED   DIO31 /* led D5 red */
@@ -26,7 +26,7 @@

 #ifdef __AVR__

-#include "fastio.h"
+#include "fastio_AVR.h"

 #ifdef FASTIO_EXT_START

@@ -39,7 +39,7 @@
 * 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"
+    #error "USE_OCR2A_AS_TOP does not apply to devices with a single output TIMER2"
 #endif

 /**
@@ -26,10 +26,7 @@

 #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 +35,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 +43,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)
@@ -234,9 +227,18 @@ static void print_is_also_tied() { SERIAL_ECHOPGM(" is also tied to this pin");
 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);
-  SERIAL_CHAR('A' + Z);
-  SERIAL_ECHOPAIR(": ", int((*TCCRA >> (6 - Z * 2)) & 0x03));
+  SERIAL_CHAR(N + '0');
+  switch (Z) {
+    case 'A':
+      SERIAL_ECHOPAIR("A: ", ((*TCCRA & (_BV(7) | _BV(6))) >> 6));
+      break;
+    case 'B':
+      SERIAL_ECHOPAIR("B: ", ((*TCCRA & (_BV(5) | _BV(4))) >> 4));
+      break;
+    case 'C':
+      SERIAL_ECHOPAIR("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
@@ -131,7 +131,7 @@ void initISR(timer16_Sequence_t timer) {
      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
@@ -26,7 +26,7 @@

 #if ENABLED(USE_WATCHDOG)

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

 #include "../../Marlin.h"

@@ -28,4 +28,4 @@ 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(); }
@@ -42,7 +42,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 );
@@ -235,7 +235,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 +248,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 +261,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 +274,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 +287,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 +300,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 +314,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 +327,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")
@@ -31,12 +31,12 @@

 #ifdef ARDUINO_ARCH_SAM

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

 #if ENABLED(EEPROM_SETTINGS) && NONE(I2C_EEPROM, SPI_EEPROM)

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

 #define EEPROMSize     4096
 #define PagesPerGroup   128
@@ -922,7 +922,8 @@ static void ee_Init() {
      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);
@@ -943,7 +944,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

@@ -952,7 +953,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
@@ -991,7 +993,7 @@ void eeprom_read_block(void* __dst, const void* __src, size_t __n) {
  }
 }

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

@@ -42,7 +42,7 @@ uint16_t HAL_adc_result;
 // ------------------------

 // HAL initialization task
-void HAL_init() {
+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
@@ -51,20 +51,20 @@ void HAL_init() {
 }

 // HAL idle task
-void HAL_idletask() {
+void HAL_idletask(void) {
  // Perform USB stack housekeeping
  usb_task_idle();
 }

 // Disable interrupts
-void cli() { noInterrupts(); }
+void cli(void) { noInterrupts(); }

 // Enable interrupts
-void sei() { interrupts(); }
+void sei(void) { interrupts(); }

-void HAL_clear_reset_source() { }
+void HAL_clear_reset_source(void) { }

-uint8_t HAL_get_reset_source() {
+uint8_t HAL_get_reset_source(void) {
  switch ((RSTC->RSTC_SR >> 8) & 0x07) {
    case 0: return RST_POWER_ON;
    case 1: return RST_BACKUP;
@@ -87,7 +87,7 @@ extern "C" {
 // 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);
+  return (int)&free_memory - (heap_end ? heap_end : (int)&_ebss);
 }

 // ------------------------
@@ -98,7 +98,7 @@ void HAL_adc_start_conversion(const uint8_t adc_pin) {
  HAL_adc_result = analogRead(adc_pin);
 }

-uint16_t HAL_adc_get_result() {
+uint16_t HAL_adc_get_result(void) {
  // nop
  return HAL_adc_result;
 }
@@ -32,51 +32,34 @@
 #include "../shared/Marduino.h"
 #include "../shared/math_32bit.h"
 #include "../shared/HAL_SPI.h"
-#include "fastio.h"
-#include "watchdog.h"
-#include "timers.h"
+#include "fastio_Due.h"
+#include "watchdog_Due.h"
+#include "HAL_timers_Due.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."
+// Serial ports
+#if !WITHIN(SERIAL_PORT, -1, 3)
+  #error "SERIAL_PORT must be from -1 to 3"
 #endif

+// MYSERIAL0 required before MarlinSerial includes!
+#define MYSERIAL0 customizedSerial1
+
 #ifdef SERIAL_PORT_2
-  #if SERIAL_PORT_2 == SERIAL_PORT
-    #error "SERIAL_PORT_2 must be different from SERIAL_PORT. Please update your configuration."
-  #endif
-  #if 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."
+  #if !WITHIN(SERIAL_PORT_2, -1, 3)
+    #error "SERIAL_PORT_2 must be from -1 to 3"
+  #elif SERIAL_PORT_2 == SERIAL_PORT
+    #error "SERIAL_PORT_2 must be different than SERIAL_PORT"
  #endif
  #define NUM_SERIAL 2
+  #define MYSERIAL1 customizedSerial2
 #else
  #define NUM_SERIAL 1
 #endif

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

 // On AVR this is in math.h?
 #define square(x) ((x)*(x))
@@ -105,11 +88,22 @@ typedef int8_t pin_t;
 #define ENABLE_ISRS()  __enable_irq()
 #define DISABLE_ISRS() __disable_irq()

-void cli();                     // Disable interrupts
-void sei();                     // Enable interrupts
+void cli(void);                     // Disable interrupts
+void sei(void);                     // Enable interrupts

-void HAL_clear_reset_source();  // clear reset reason
-uint8_t HAL_get_reset_source(); // get reset reason
+void HAL_clear_reset_source(void);  // clear reset reason
+uint8_t HAL_get_reset_source(void); // get reset reason
+
+//
+// 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
@@ -130,15 +124,14 @@ extern uint16_t HAL_adc_result;     // result of last ADC conversion

 #define HAL_ANALOG_SELECT(pin)

-inline void HAL_adc_init() {}//todo
+inline void HAL_adc_init(void) {}//todo

 #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);
-uint16_t HAL_adc_get_result();
+uint16_t HAL_adc_get_result(void);

 //
 // Pin Map
@@ -156,23 +149,19 @@ void noTone(const pin_t _pin);

 // Enable hooks into idle and setup for HAL
 #define HAL_IDLETASK 1
-void HAL_idletask();
-void HAL_init();
+void HAL_idletask(void);
+void HAL_init(void);

 //
 // Utility functions
 //
 void _delay_ms(const int delay);
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-function"
-int freeMemory();
-#pragma GCC diagnostic pop
+int freeMemory(void);

 #ifdef __cplusplus
  extern "C" {
 #endif
-char *dtostrf(double __val, signed char __width, unsigned char __prec, char *__s);
+char *dtostrf (double __val, signed char __width, unsigned char __prec, char *__s);
 #ifdef __cplusplus
  }
 #endif
@@ -151,12 +151,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
+  static uint8_t spiTransferRx0(uint8_t bout) { // 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);
+    UNUSED(bout);

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

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

@@ -34,7 +34,7 @@
 #include "../../inc/MarlinConfig.h"
 #include "HAL.h"

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

 // ------------------------
 // Local defines
@@ -50,7 +50,7 @@ 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
+  { TC1, 0, TC3_IRQn,  0}, // 3
  { TC1, 1, TC4_IRQn, 15}, // 4 - temperature
  { TC1, 2, TC5_IRQn,  3}, // 5 - [servo timer3]
  { TC2, 0, TC6_IRQn, 14}, // 6 - tone
@@ -39,9 +39,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 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,9 +61,7 @@ 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_STEP_TIMER_ISR()  void TC2_Handler()
 #define HAL_TEMP_TIMER_ISR()  void TC4_Handler()
 #define HAL_TONE_TIMER_ISR()  void TC6_Handler()

@@ -34,7 +34,7 @@

 #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
@@ -48,7 +48,7 @@ static DeviceVectors ram_tab = { nullptr };
 * 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;

@@ -37,7 +37,7 @@
 #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);
@@ -31,7 +31,7 @@

 #if SERIAL_PORT == -1

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

 #if ENABLED(EMERGENCY_PARSER)
  #include "../../feature/emergency_parser.h"
@@ -39,11 +39,11 @@

 // 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,14 @@ static int pending_char = -1;
 #endif

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

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

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

@@ -80,7 +83,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 +107,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 +115,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::flushTX(void) { }

 void MarlinSerialUSB::write(const uint8_t c) {

@@ -183,7 +186,7 @@ void MarlinSerialUSB::print(double n, int digits) {
  printFloat(n, digits);
 }

-void MarlinSerialUSB::println() {
+void MarlinSerialUSB::println(void) {
  print('\r');
  print('\n');
 }
@@ -43,11 +43,11 @@ 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 void flushTX(void);
+  static bool available(void);
  static void write(const uint8_t c);

  #if ENABLED(SERIAL_STATS_DROPPED_RX)
@@ -80,7 +80,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:
@@ -29,8 +29,8 @@

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

-#include "MarlinSerial.h"
-#include "InterruptVectors.h"
+#include "MarlinSerial_Due.h"
+#include "InterruptVectors_Due.h"
 #include "../../Marlin.h"

 template<typename Cfg> typename MarlinSerial<Cfg>::ring_buffer_r MarlinSerial<Cfg>::rx_buffer = { 0, 0, { 0 } };
@@ -178,7 +178,7 @@ FORCE_INLINE void MarlinSerial<Cfg>::store_rxd_char() {
 }

 template<typename Cfg>
-FORCE_INLINE void MarlinSerial<Cfg>::_tx_thr_empty_irq() {
+FORCE_INLINE void MarlinSerial<Cfg>::_tx_thr_empty_irq(void) {
  if (Cfg::TX_SIZE > 0) {
    // Read positions
    uint8_t t = tx_buffer.tail;
@@ -221,7 +221,7 @@ FORCE_INLINE void MarlinSerial<Cfg>::_tx_thr_empty_irq() {
 }

 template<typename Cfg>
-void MarlinSerial<Cfg>::UART_ISR() {
+void MarlinSerial<Cfg>::UART_ISR(void) {
  const uint32_t status = HWUART->UART_SR;

  // Data received?
@@ -308,13 +308,13 @@ void MarlinSerial<Cfg>::end() {
 }

 template<typename Cfg>
-int MarlinSerial<Cfg>::peek() {
+int MarlinSerial<Cfg>::peek(void) {
  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() {
+int MarlinSerial<Cfg>::read(void) {

  const ring_buffer_pos_t h = rx_buffer.head;
  ring_buffer_pos_t t = rx_buffer.tail;
@@ -354,13 +354,13 @@ int MarlinSerial<Cfg>::read() {
 }

 template<typename Cfg>
-typename MarlinSerial<Cfg>::ring_buffer_pos_t MarlinSerial<Cfg>::available() {
+typename MarlinSerial<Cfg>::ring_buffer_pos_t MarlinSerial<Cfg>::available(void) {
  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() {
+void MarlinSerial<Cfg>::flush(void) {
  rx_buffer.tail = rx_buffer.head;

  if (Cfg::XONOFF) {
@@ -431,7 +431,7 @@ void MarlinSerial<Cfg>::write(const uint8_t c) {
 }

 template<typename Cfg>
-void MarlinSerial<Cfg>::flushTX() {
+void MarlinSerial<Cfg>::flushTX(void) {
  // TX

  if (Cfg::TX_SIZE == 0) {
@@ -520,7 +520,7 @@ void MarlinSerial<Cfg>::print(double n, int digits) {
 }

 template<typename Cfg>
-void MarlinSerial<Cfg>::println() {
+void MarlinSerial<Cfg>::println(void) {
  print('\r');
  print('\n');
 }
@@ -108,19 +108,19 @@ protected:
  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();
+  FORCE_INLINE static void _tx_thr_empty_irq(void);
+  static void UART_ISR(void);

 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 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();
+  static void flushTX(void);

  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; }
@@ -149,7 +149,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:
@@ -36,8 +36,8 @@
 //!#define _useTimer4
 #define _useTimer5

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

 /*
  TC0, chan 0 => TC0_Handler
@@ -56,19 +56,19 @@ static volatile int8_t Channel[_Nbr_16timers];              // counter for the s
 void Servo_Handler(timer16_Sequence_t timer, Tc *pTc, uint8_t channel);

 #ifdef _useTimer1
-  void HANDLER_FOR_TIMER1() { Servo_Handler(_timer1, TC_FOR_TIMER1, CHANNEL_FOR_TIMER1); }
+  void HANDLER_FOR_TIMER1(void) { Servo_Handler(_timer1, TC_FOR_TIMER1, CHANNEL_FOR_TIMER1); }
 #endif
 #ifdef _useTimer2
-  void HANDLER_FOR_TIMER2() { Servo_Handler(_timer2, TC_FOR_TIMER2, CHANNEL_FOR_TIMER2); }
+  void HANDLER_FOR_TIMER2(void) { Servo_Handler(_timer2, TC_FOR_TIMER2, CHANNEL_FOR_TIMER2); }
 #endif
 #ifdef _useTimer3
-  void HANDLER_FOR_TIMER3() { Servo_Handler(_timer3, TC_FOR_TIMER3, CHANNEL_FOR_TIMER3); }
+  void HANDLER_FOR_TIMER3(void) { Servo_Handler(_timer3, TC_FOR_TIMER3, CHANNEL_FOR_TIMER3); }
 #endif
 #ifdef _useTimer4
-  void HANDLER_FOR_TIMER4() { Servo_Handler(_timer4, TC_FOR_TIMER4, CHANNEL_FOR_TIMER4); }
+  void HANDLER_FOR_TIMER4(void) { Servo_Handler(_timer4, TC_FOR_TIMER4, CHANNEL_FOR_TIMER4); }
 #endif
 #ifdef _useTimer5
-  void HANDLER_FOR_TIMER5() { Servo_Handler(_timer5, TC_FOR_TIMER5, CHANNEL_FOR_TIMER5); }
+  void HANDLER_FOR_TIMER5(void) { Servo_Handler(_timer5, TC_FOR_TIMER5, CHANNEL_FOR_TIMER5); }
 #endif

 void Servo_Handler(timer16_Sequence_t timer, Tc *tc, uint8_t channel) {
@@ -5,8 +5,6 @@
 * Based on Sprinter and grbl.
 * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
 *
- * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
- *
 * 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
@@ -31,7 +29,7 @@

 #include "../../inc/MarlinConfig.h"
 #include "HAL.h"
-#include "timers.h"
+#include "HAL_timers_Due.h"

 static pin_t tone_pin;
 volatile static int32_t toggles;
@@ -71,7 +71,7 @@ void spiSend(uint8_t b);
 void spiSend(const uint8_t* buf, size_t n);

 #include "../../shared/Marduino.h"
-#include "../fastio.h"
+#include "../fastio_Due.h"

 void u8g_SetPIOutput_DUE_hw_spi(u8g_t *u8g, uint8_t pin_index) {
   PIO_Configure(g_APinDescription[u8g->pin_list[pin_index]].pPort, PIO_OUTPUT_1,
@@ -23,7 +23,6 @@

 #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);
@@ -38,46 +38,45 @@
 #include "../../module/endstops.h"

 // One ISR for all EXT-Interrupts
-void endstop_ISR() { endstops.update(); }
+void endstop_ISR(void) { endstops.update(); }

 /**
 *  Endstop interrupts for Due based targets.
 *  On Due, all pins support external interrupt capability.
 */

-void setup_endstop_interrupts() {
-  #define _ATTACH(P) attachInterrupt(digitalPinToInterrupt(P), endstop_ISR, CHANGE)
+void setup_endstop_interrupts(void) {
  #if HAS_X_MAX
-    _ATTACH(X_MAX_PIN);
+    attachInterrupt(digitalPinToInterrupt(X_MAX_PIN), endstop_ISR, CHANGE); // assign it
  #endif
  #if HAS_X_MIN
-    _ATTACH(X_MIN_PIN);
+    attachInterrupt(digitalPinToInterrupt(X_MIN_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Y_MAX
-    _ATTACH(Y_MAX_PIN);
+    attachInterrupt(digitalPinToInterrupt(Y_MAX_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Y_MIN
-    _ATTACH(Y_MIN_PIN);
+    attachInterrupt(digitalPinToInterrupt(Y_MIN_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Z_MAX
-    _ATTACH(Z_MAX_PIN);
+    attachInterrupt(digitalPinToInterrupt(Z_MAX_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Z_MIN
-     _ATTACH(Z_MIN_PIN);
+     attachInterrupt(digitalPinToInterrupt(Z_MIN_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Z2_MAX
-    _ATTACH(Z2_MAX_PIN);
+    attachInterrupt(digitalPinToInterrupt(Z2_MAX_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Z2_MIN
-    _ATTACH(Z2_MIN_PIN);
+    attachInterrupt(digitalPinToInterrupt(Z2_MIN_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Z3_MAX
-    _ATTACH(Z3_MAX_PIN);
+    attachInterrupt(digitalPinToInterrupt(Z3_MAX_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Z3_MIN
-    _ATTACH(Z3_MIN_PIN);
+    attachInterrupt(digitalPinToInterrupt(Z3_MIN_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Z_MIN_PROBE_PIN
-    _ATTACH(Z_MIN_PROBE_PIN);
+    attachInterrupt(digitalPinToInterrupt(Z_MIN_PROBE_PIN), endstop_ISR, CHANGE);
  #endif
 }
@@ -70,7 +70,7 @@
  const uint32_t mask = MASK(DIO ## IO ## _PIN); \
  if (V) port->PIO_SODR = mask; \
  else port->PIO_CODR = mask; \
-}while(0)
+} while(0)

 // Toggle a pin
 #define _TOGGLE(IO) _WRITE(IO, !READ(IO))
@@ -33,7 +33,7 @@
  #define E2END 0xFFF // Default to Flash emulated EEPROM size (EepromEmulation_Due.cpp)
 #endif

-extern void eeprom_flush();
+extern void eeprom_flush(void);

 bool PersistentStore::access_start() { return true; }

@@ -112,7 +112,7 @@
 * \def unused
 * \brief Marking \a v as a unused parameter or value.
 */
-#define unused(v)          do { (void)(v); }while(0)
+#define unused(v)          do { (void)(v); } while(0)

 /**
 * \def barrier
@@ -169,7 +169,7 @@
 * heuristics and inline the function no matter how big it thinks it
 * becomes.
 */
-#ifdef __CC_ARM
+#if defined(__CC_ARM)
 #   define __always_inline   __forceinline
 #elif (defined __GNUC__)
 #ifdef __always_inline
@@ -187,7 +187,7 @@
 * This annotation instructs the compiler to ignore its inlining
 * heuristics and not inline the function.
 */
-#ifdef __CC_ARM
+#if defined(__CC_ARM)
 #   define __no_inline   __attribute__((noinline))
 #elif (defined __GNUC__)
 #	define __no_inline   __attribute__((__noinline__))
@@ -204,7 +204,7 @@
 *
 * \param expr  Expression to evaluate and supposed to be nonzero.
 */
-#ifdef _ASSERT_ENABLE_
+#if defined(_ASSERT_ENABLE_)
 #  if defined(TEST_SUITE_DEFINE_ASSERT_MACRO)
     // Assert() is defined in unit_test/suite.h
 #    include "unit_test/suite.h"
@@ -230,7 +230,7 @@

 /* Define NO_INIT attribute */
 #if 0 //ndef NO_INIT
-#ifdef __CC_ARM
+#if defined   ( __CC_ARM   )
 #   define NO_INIT __attribute__((zero_init))
 #elif defined ( __ICCARM__ )
 #   define NO_INIT __no_init
@@ -262,7 +262,7 @@
 //! @{
 typedef unsigned char           Bool; //!< Boolean.
 #ifndef __cplusplus
-#ifndef __bool_true_false_are_defined
+#if !defined(__bool_true_false_are_defined)
 typedef unsigned char           bool; //!< Boolean.
 #endif
 #endif
@@ -443,9 +443,9 @@ typedef struct
 #define DISABLE   0
 #define ENABLE    1
 #ifndef __cplusplus
-#ifndef __bool_true_false_are_defined
-#define false (1==0)
-#define true (1==1)
+#if !defined(__bool_true_false_are_defined)
+#define false 0
+#define true 1
 #endif
 #endif
 #ifndef PASS
@@ -998,14 +998,14 @@ typedef U8                  Byte;       //!< 8-bit unsigned integer.
 #endif  // #ifndef __ASSEMBLY__


-#ifdef __ICCARM__
+#if defined(__ICCARM__)
 #define SHORTENUM           __packed
 #elif defined(__GNUC__)
 #define SHORTENUM           __attribute__((packed))
 #endif

 /* No operation */
-#ifdef __ICCARM__
+#if defined(__ICCARM__)
 #define nop()               __no_operation()
 #elif defined(__GNUC__)
 #define nop()               (__NOP())
@@ -48,7 +48,9 @@
 #define _CONF_USB_H_

 #undef UNUSED                           /* To avoid a macro clash as macros.h already defines it */
-#include "../../../inc/MarlinConfigPre.h"
+#include "../../../core/macros.h"       /* For ENABLED()/DISABLED() */
+#include "../../../core/boards.h"       /* For MB() */
+#include "../../../../Configuration.h"  /* For CUSTOM_MACHINE_NAME definition - We just need the name, no C++ allowed! */
 #include "compiler.h"

 /**
@@ -57,6 +59,8 @@
 */

 //! Device definition (mandatory)
+#define  USB_DEVICE_VENDOR_ID             0x03EB /* ATMEL VID */
+#define  USB_DEVICE_PRODUCT_ID            0x2424 /* MSC / CDC */
 #define  USB_DEVICE_MAJOR_VERSION         1
 #define  USB_DEVICE_MINOR_VERSION         0
 #define  USB_DEVICE_POWER                 100 // Consumption on Vbus line (mA)
@@ -66,6 +70,15 @@
 //  (USB_CONFIG_ATTR_REMOTE_WAKEUP|USB_CONFIG_ATTR_SELF_POWERED)
 //  (USB_CONFIG_ATTR_REMOTE_WAKEUP|USB_CONFIG_ATTR_BUS_POWERED)

+//! USB Device string definitions (Optional)
+#define  USB_DEVICE_MANUFACTURE_NAME      "marlinfw.org"
+#ifdef CUSTOM_MACHINE_NAME
+  #define  USB_DEVICE_PRODUCT_NAME        CUSTOM_MACHINE_NAME
+#else
+  #define  USB_DEVICE_PRODUCT_NAME        "3D Printer"
+#endif
+#define  USB_DEVICE_SERIAL_NAME           "123985739853"
+
 /**
 * Device speeds support
 * Low speed not supported by CDC and MSC
@@ -61,27 +61,27 @@ extern "C" {
 * Below BOARD_XXX macros are related to the specific board, and
 * should be defined by the board code, otherwise default value are used.
 */
-#ifndef BOARD_FREQ_SLCK_XTAL
+#if !defined(BOARD_FREQ_SLCK_XTAL)
 #  warning The board slow clock xtal frequency has not been defined.
 #  define BOARD_FREQ_SLCK_XTAL      (32768UL)
 #endif

-#ifndef BOARD_FREQ_SLCK_BYPASS
+#if !defined(BOARD_FREQ_SLCK_BYPASS)
 #  warning The board slow clock bypass frequency has not been defined.
 #  define BOARD_FREQ_SLCK_BYPASS    (32768UL)
 #endif

-#ifndef BOARD_FREQ_MAINCK_XTAL
+#if !defined(BOARD_FREQ_MAINCK_XTAL)
 #  warning The board main clock xtal frequency has not been defined.
 #  define BOARD_FREQ_MAINCK_XTAL    (12000000UL)
 #endif

-#ifndef BOARD_FREQ_MAINCK_BYPASS
+#if !defined(BOARD_FREQ_MAINCK_BYPASS)
 #  warning The board main clock bypass frequency has not been defined.
 #  define BOARD_FREQ_MAINCK_BYPASS  (12000000UL)
 #endif

-#ifndef BOARD_OSC_STARTUP_US
+#if !defined(BOARD_OSC_STARTUP_US)
 #  warning The board main clock xtal startup time has not been defined.
 #  define BOARD_OSC_STARTUP_US      (15625UL)
 #endif
@@ -15,14 +15,11 @@ extern "C" {

 #define SD_MMC_BLOCK_SIZE 512

-void sd_mmc_spi_mem_init() {
+void sd_mmc_spi_mem_init(void) {
 }

-Ctrl_status sd_mmc_spi_test_unit_ready() {
-  #ifdef DISABLE_DUE_SD_MMC
-    return CTRL_NO_PRESENT;
-  #endif
-  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted())
+Ctrl_status sd_mmc_spi_test_unit_ready(void) {
+  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isDetected())
    return CTRL_NO_PRESENT;
  return CTRL_GOOD;
 }
@@ -30,18 +27,25 @@ Ctrl_status sd_mmc_spi_test_unit_ready() {
 // NOTE: This function is defined as returning the address of the last block
 // in the card, which is cardSize() - 1
 Ctrl_status sd_mmc_spi_read_capacity(uint32_t *nb_sector) {
-  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted())
+  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isDetected())
    return CTRL_NO_PRESENT;
  *nb_sector = card.getSd2Card().cardSize() - 1;
  return CTRL_GOOD;
 }

-bool sd_mmc_spi_unload(bool) { return true; }
+bool sd_mmc_spi_unload(bool unload) {
+  UNUSED(unload);
+  return true;
+}

-bool sd_mmc_spi_wr_protect() { return false; }
+bool sd_mmc_spi_wr_protect(void) {
+  return false;
+}

-bool sd_mmc_spi_removal() {
-  return (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted());
+bool sd_mmc_spi_removal(void) {
+  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isDetected())
+    return true;
+  return false;
 }

 #if ACCESS_USB == true
@@ -58,10 +62,7 @@ uint8_t sector_buf[SD_MMC_BLOCK_SIZE];
 // #define DEBUG_MMC

 Ctrl_status sd_mmc_spi_usb_read_10(uint32_t addr, uint16_t nb_sector) {
-  #ifdef DISABLE_DUE_SD_MMC
-    return CTRL_NO_PRESENT;
-  #endif
-  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted())
+  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isDetected())
    return CTRL_NO_PRESENT;

  #ifdef DEBUG_MMC
@@ -98,10 +99,7 @@ Ctrl_status sd_mmc_spi_usb_read_10(uint32_t addr, uint16_t nb_sector) {
 }

 Ctrl_status sd_mmc_spi_usb_write_10(uint32_t addr, uint16_t nb_sector) {
-  #ifdef DISABLE_DUE_SD_MMC
-    return CTRL_NO_PRESENT;
-  #endif
-  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted())
+  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isDetected())
    return CTRL_NO_PRESENT;

  #ifdef DEBUG_MMC
@@ -43,12 +43,12 @@
 * \asf_license_stop
 *
 */
-
 /*
 * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
 */
-#ifndef _SPC_PROTOCOL_H_
-#define _SPC_PROTOCOL_H_
+#ifndef  _SPC_PROTOCOL_H_
+#define  _SPC_PROTOCOL_H_
+

 /**
 * \ingroup usb_msc_protocol
@@ -94,11 +94,11 @@ typedef struct {
 	uint16_t payload_size;

 	//! Callback called after reception of ZLP from setup request
-	void (*callback)(void);
+	void (*callback) (void);

 	//! Callback called when the buffer given (.payload) is full or empty.
 	//! This one return false to abort data transfer, or true with a new buffer in .payload.
-	bool (*over_under_run)(void);
+	bool(*over_under_run) (void);
 } udd_ctrl_request_t;
 extern udd_ctrl_request_t udd_g_ctrlreq;

@@ -123,7 +123,7 @@ extern udd_ctrl_request_t udd_g_ctrlreq;
 * Registered by routine udd_ep_wait_stall_clear()
 * Callback called when endpoint stall is cleared.
 */
-typedef void (*udd_callback_halt_cleared_t)(void);
+typedef void (*udd_callback_halt_cleared_t) (void);

 /**
 * \brief End of transfer callback function type.
@@ -82,7 +82,7 @@ typedef struct {
 	 *
 	 * \return \c 1 if function was successfully done, otherwise \c 0.
 	 */
-	bool (*enable)(void);
+	bool(*enable) (void);

 	/**
 	 * \brief Disable the interface.
@@ -95,7 +95,7 @@ typedef struct {
 	 * - the device is detached from the host (i.e. Vbus is no
 	 *   longer present)
 	 */
-	void (*disable)(void);
+	void (*disable) (void);

 	/**
 	 * \brief Handle a control request directed at an interface.
@@ -108,7 +108,7 @@ typedef struct {
 	 *
 	 * \return \c 1 if this interface supports the SETUP request, otherwise \c 0.
 	 */
-	bool (*setup)(void);
+	bool(*setup) (void);

 	/**
 	 * \brief Returns the current setting of the selected interface.
@@ -117,12 +117,12 @@ typedef struct {
 	 *
 	 * \return alternate setting of selected interface
 	 */
-	uint8_t (*getsetting)(void);
+	uint8_t(*getsetting) (void);

 	/**
 	 * \brief To signal that a SOF is occurred
 	 */
-	void (*sof_notify)(void);
+	void(*sof_notify) (void);
 } udi_api_t;

 //@}
@@ -55,7 +55,7 @@
 #include "udi.h"

 // Check the number of port
-#ifndef UDI_CDC_PORT_NB
+#ifndef  UDI_CDC_PORT_NB
 # define  UDI_CDC_PORT_NB 1
 #endif
 #if (UDI_CDC_PORT_NB < 1) || (UDI_CDC_PORT_NB > 7)
@@ -50,7 +50,7 @@
 #include "usb_protocol_cdc.h"
 #include "conf_usb.h"

-#ifndef UDI_CDC_PORT_NB
+#ifndef  UDI_CDC_PORT_NB
 # define  UDI_CDC_PORT_NB 1
 #endif

@@ -45,11 +45,10 @@

 #ifdef ARDUINO_ARCH_SAM

-#include <Arduino.h>
-#include <Reset.h>
-
 #include "conf_usb.h"
 #include "udc.h"
+#include <Arduino.h>
+#include <Reset.h>

 #if ENABLED(SDSUPPORT)
  static volatile bool main_b_msc_enable = false;
@@ -24,7 +24,7 @@

 #include "../../inc/MarlinConfig.h"
 #include "../../Marlin.h"
-#include "watchdog.h"
+#include "watchdog_Due.h"

 // Override Arduino runtime to either config or disable the watchdog
 //
@@ -32,7 +32,7 @@
 // process, because watchdog initialization at hardware reset on SAM3X8E
 // is unreliable, and there is risk of unintended resets if we delay
 // that initialization to a later time.
-void watchdogSetup() {
+void watchdogSetup(void) {

  #if ENABLED(USE_WATCHDOG)

@@ -106,7 +106,7 @@ void watchdogSetup() {
  // Initialize watchdog - On SAM3X, Watchdog was already configured
  //  and enabled or disabled at startup, so no need to reconfigure it
  //  here.
-  void watchdog_init() {
+  void watchdog_init(void) {
    // Reset watchdog to start clean
    WDT_Restart(WDT);
  }
@@ -30,4 +30,4 @@ 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() { watchdogReset(); }
+inline void watchdog_reset() { watchdogReset(); }
@@ -29,7 +29,7 @@ class FlushableHardwareSerial : public HardwareSerial {
 public:
  FlushableHardwareSerial(int uart_nr);

-  inline void flushTX() { /* No need to flush the hardware serial, but defined here for compatibility. */ }
+  inline void flushTX(void) { /* No need to flush the hardware serial, but defined here for compatibility. */ }
 };

 extern FlushableHardwareSerial flushableSerial;
@@ -23,14 +23,14 @@
 #ifdef ARDUINO_ARCH_ESP32

 #include "HAL.h"
-#include "timers.h"
+#include "HAL_timers_ESP32.h"
 #include <rom/rtc.h>
 #include <driver/adc.h>
 #include <esp_adc_cal.h>

 #include "../../inc/MarlinConfigPre.h"

-#if ENABLED(WEBSUPPORT)
+#if EITHER(EEPROM_SETTINGS, WEBSUPPORT)
  #include "spiffs.h"
 #endif

@@ -78,12 +78,12 @@ volatile int numPWMUsed = 0,
 // Public functions
 // ------------------------

-void HAL_init() {
+void HAL_init(void) {
  i2s_init();
 }

-void HAL_init_board() {
-  #if ENABLED(WEBSUPPORT)
+void HAL_init_board(void) {
+  #if EITHER(EEPROM_SETTINGS, WEBSUPPORT)
    spiffs_init();
  #endif

@@ -99,15 +99,15 @@ void HAL_init_board() {
  #endif
 }

-void HAL_idletask() {
+void HAL_idletask(void) {
  #if ENABLED(OTASUPPORT)
    OTA_handle();
  #endif
 }

-void HAL_clear_reset_source() { }
+void HAL_clear_reset_source(void) { }

-uint8_t HAL_get_reset_source() { return rtc_get_reset_reason(1); }
+uint8_t HAL_get_reset_source(void) { return rtc_get_reset_reason(1); }

 void _delay_ms(int delay_ms) { delay(delay_ms); }

@@ -187,21 +187,19 @@ void HAL_adc_start_conversion(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;
+    adc1_set_attenuation(chan, 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;
+    adc1_set_attenuation(chan, 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;
+    adc1_set_attenuation(chan, ADC_ATTEN_DB_6);
  else if (mv > thresholds[ADC_ATTEN_DB_6] - 50)
-    atten = ADC_ATTEN_DB_11;
-  else return;
+    adc1_set_attenuation(chan, ADC_ATTEN_DB_11);

-  adc1_set_attenuation(chan, atten);
+  HAL_adc_result = mv * 1023.0 / 3300.0;
 }

 void analogWrite(pin_t pin, int value) {
@@ -30,11 +30,11 @@
 #include "../shared/math_32bit.h"
 #include "../shared/HAL_SPI.h"

-#include "fastio.h"
-#include "watchdog.h"
+#include "fastio_ESP32.h"
+#include "watchdog_ESP32.h"
 #include "i2s.h"

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

 #include "WebSocketSerial.h"
 #include "FlushableHardwareSerial.h"
@@ -85,17 +85,14 @@ extern uint16_t HAL_adc_result;
 // ------------------------

 // clear reset reason
-void HAL_clear_reset_source();
+void HAL_clear_reset_source (void);

 // reset reason
-uint8_t HAL_get_reset_source();
+uint8_t HAL_get_reset_source(void);

 void _delay_ms(int delay);

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

 void analogWrite(pin_t pin, int value);

@@ -108,10 +105,9 @@ void eeprom_update_block (const void *__src, void *__dst, size_t __n);
 // ADC
 #define HAL_ANALOG_SELECT(pin)

-void HAL_adc_init();
+void HAL_adc_init(void);

 #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

@@ -124,6 +120,6 @@ void HAL_adc_start_conversion(uint8_t adc_pin);
 // 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();
+void HAL_idletask(void);
+void HAL_init(void);
+void HAL_init_board(void);
@@ -25,32 +25,32 @@

 #if HAS_SERVOS

-#include "Servo.h"
+#include "HAL_Servo_ESP32.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++;
+  this->channel = channel_next_free++;
 }

-int8_t Servo::attach(const int inPin) {
-  if (channel >= CHANNEL_MAX_NUM) return -1;
-  if (pin > 0) pin = inPin;
+int8_t Servo::attach(const int pin) {
+  if (this->channel >= CHANNEL_MAX_NUM) return -1;
+  if (pin > 0) this->pin = pin;

-  ledcSetup(channel, 50, 16); // channel X, 50 Hz, 16-bit depth
-  ledcAttachPin(pin, channel);
+  ledcSetup(this->channel, 50, 16); // channel X, 50 Hz, 16-bit depth
+  ledcAttachPin(this->pin, this->channel);
  return true;
 }

-void Servo::detach() { ledcDetachPin(pin); }
+void Servo::detach() { ledcDetachPin(this->pin); }

-int Servo::read() { return degrees; }
+int Servo::read() { return this->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);
+  this->degrees = constrain(inDegrees, MIN_ANGLE, MAX_ANGLE);
+  int us = map(this->degrees, MIN_ANGLE, MAX_ANGLE, MIN_PULSE_WIDTH, MAX_PULSE_WIDTH);
  int duty = map(us, 0, TAU_USEC, 0, MAX_COMPARE);
  ledcWrite(channel, duty);
 }
@@ -58,11 +58,11 @@ void Servo::write(int inDegrees) {
 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 (this->attach(0) >= 0) {
+    this->write(value);
+    safe_delay(servo_delay[this->channel]);
    #if ENABLED(DEACTIVATE_SERVOS_AFTER_MOVE)
-      detach();
+      this->detach();
    #endif
  }
 }
@@ -27,9 +27,8 @@
 #include "../shared/HAL_SPI.h"
 #include <pins_arduino.h>
 #include "spi_pins.h"
-#include <SPI.h>
-
 #include "../../core/macros.h"
+#include <SPI.h>

 // ------------------------
 // Public Variables
@@ -80,7 +79,7 @@ void spiInit(uint8_t spiRate) {
  SPI.begin();
 }

-uint8_t spiRec() {
+uint8_t spiRec(void) {
  SPI.beginTransaction(spiConfig);
  uint8_t returnByte = SPI.transfer(0xFF);
  SPI.endTransaction();
@@ -23,14 +23,14 @@
 #ifdef ARDUINO_ARCH_ESP32

 #include <stdio.h>
-#include <esp_types.h>
-#include <soc/timer_group_struct.h>
-#include <driver/periph_ctrl.h>
-#include <driver/timer.h>
+#include "esp_types.h"
+#include "soc/timer_group_struct.h"
+#include "driver/periph_ctrl.h"
+#include "driver/timer.h"

 #include "HAL.h"

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

 // ------------------------
 // Local defines
@@ -22,7 +22,7 @@
 #pragma once

 #include <stdint.h>
-#include <driver/timer.h>
+#include "driver/timer.h"

 // Includes needed to get I2S_STEPPER_STREAM. Note that pins.h
 // is included in case this header is being included early.
@@ -51,8 +51,8 @@ typedef uint64_t hal_timer_t;
  #define STEPPER_TIMER_TICKS_PER_US ((STEPPER_TIMER_RATE) / 1000000) // stepper timer ticks per µs // wrong would be 0.25
 #else
  #define STEPPER_TIMER_PRESCALE     40
-  #define STEPPER_TIMER_RATE         ((HAL_TIMER_RATE) / (STEPPER_TIMER_PRESCALE)) // frequency of stepper timer, 2MHz
-  #define STEPPER_TIMER_TICKS_PER_US ((STEPPER_TIMER_RATE) / 1000000)              // stepper timer ticks per µs
+  #define STEPPER_TIMER_RATE         (HAL_TIMER_RATE / STEPPER_TIMER_PRESCALE) // frequency of stepper timer, 2MHz
+  #define STEPPER_TIMER_TICKS_PER_US ((STEPPER_TIMER_RATE) / 1000000)          // stepper timer ticks per µs
 #endif

 #define STEP_TIMER_MIN_INTERVAL   8 // minimum time in µs between stepper interrupts
@@ -79,13 +79,13 @@ typedef uint64_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)

-#define HAL_TEMP_TIMER_ISR() extern "C" void tempTC_Handler()
-#define HAL_STEP_TIMER_ISR() extern "C" void stepTC_Handler()
-#define HAL_PWM_TIMER_ISR() extern "C" void pwmTC_Handler()
+#define HAL_TEMP_TIMER_ISR() extern "C" void tempTC_Handler(void)
+#define HAL_STEP_TIMER_ISR() extern "C" void stepTC_Handler(void)
+#define HAL_PWM_TIMER_ISR() extern "C" void pwmTC_Handler(void)

-extern "C" void tempTC_Handler();
-extern "C" void stepTC_Handler();
-extern "C" void pwmTC_Handler();
+extern "C" void tempTC_Handler(void);
+extern "C" void stepTC_Handler(void);
+extern "C" void pwmTC_Handler(void);

 // ------------------------
 // Types
@@ -95,7 +95,7 @@ typedef struct {
  timer_group_t  group;
  timer_idx_t    idx;
  uint32_t       divider;
-  void           (*fn)();
+  void           (*fn)(void);
 } tTimerConfig;

 // ------------------------
@@ -66,15 +66,15 @@ ring_buffer_pos_t RingBuffer::write(const uint8_t *buffer, ring_buffer_pos_t siz
  return written;
 }

-int RingBuffer::available() {
+int RingBuffer::available(void) {
  return (size - read_index + write_index) & (size - 1);
 }

-int RingBuffer::peek() {
+int RingBuffer::peek(void) {
  return available() ? data[read_index] : -1;
 }

-int RingBuffer::read() {
+int RingBuffer::read(void) {
  if (available()) {
    const int ret = data[read_index];
    read_index = NEXT_INDEX(read_index, size);
@@ -94,7 +94,7 @@ ring_buffer_pos_t RingBuffer::read(uint8_t *buffer) {
  return len;
 }

-void RingBuffer::flush() { read_index = write_index; }
+void RingBuffer::flush(void) { read_index = write_index; }

 // WebSocketSerial impl
 WebSocketSerial::WebSocketSerial()
@@ -120,10 +120,10 @@ void WebSocketSerial::begin(const long baud_setting) {
 }

 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(); }
+int WebSocketSerial::peek(void) { return rx_buffer.peek(); }
+int WebSocketSerial::read(void) { return rx_buffer.read(); }
+int WebSocketSerial::available(void) { return rx_buffer.available(); }
+void WebSocketSerial::flush(void) { rx_buffer.flush(); }

 size_t WebSocketSerial::write(const uint8_t c) {
  size_t ret = tx_buffer.write(c);
@@ -145,7 +145,7 @@ size_t WebSocketSerial::write(const uint8_t* buffer, size_t size) {
  return written;
 }

-void WebSocketSerial::flushTX() {
+void WebSocketSerial::flushTX(void) {
  // No need to do anything as there's no benefit to sending partial lines over the websocket connection.
 }

@@ -23,18 +23,16 @@

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

-#include <Stream.h>
+#include "Stream.h"

+#ifndef RX_BUFFER_SIZE
+  #define RX_BUFFER_SIZE 128
+#endif
 #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
+#if TX_BUFFER_SIZE <= 0
+  #error "TX_BUFFER_SIZE is required for the WebSocket."
 #endif

 typedef uint16_t ring_buffer_pos_t;
@@ -47,11 +45,11 @@ public:
  RingBuffer(ring_buffer_pos_t size);
  ~RingBuffer();

-  int available();
-  int peek();
-  int read();
+  int available(void);
+  int peek(void);
+  int read(void);
  ring_buffer_pos_t read(uint8_t *buffer);
-  void flush();
+  void flush(void);
  ring_buffer_pos_t write(const uint8_t c);
  ring_buffer_pos_t write(const uint8_t* buffer, ring_buffer_pos_t size);
 };
@@ -64,11 +62,11 @@ public:
  WebSocketSerial();
  void begin(const long);
  void end();
-  int available();
-  int peek();
-  int read();
-  void flush();
-  void flushTX();
+  int available(void);
+  int peek(void);
+  int read(void);
+  void flush(void);
+  void flushTX(void);
  size_t write(const uint8_t c);
  size_t write(const uint8_t* buffer, size_t size);

@@ -38,41 +38,40 @@
 #include "../../module/endstops.h"

 // One ISR for all EXT-Interrupts
-void ICACHE_RAM_ATTR endstop_ISR() { endstops.update(); }
+void ICACHE_RAM_ATTR endstop_ISR(void) { endstops.update(); }

-void setup_endstop_interrupts() {
-  #define _ATTACH(P) attachInterrupt(digitalPinToInterrupt(P), endstop_ISR, CHANGE)
+void setup_endstop_interrupts(void) {
  #if HAS_X_MAX
-    _ATTACH(X_MAX_PIN);
+    attachInterrupt(digitalPinToInterrupt(X_MAX_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_X_MIN
-    _ATTACH(X_MIN_PIN);
+    attachInterrupt(digitalPinToInterrupt(X_MIN_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Y_MAX
-    _ATTACH(Y_MAX_PIN);
+    attachInterrupt(digitalPinToInterrupt(Y_MAX_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Y_MIN
-    _ATTACH(Y_MIN_PIN);
+    attachInterrupt(digitalPinToInterrupt(Y_MIN_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Z_MAX
-    _ATTACH(Z_MAX_PIN);
+    attachInterrupt(digitalPinToInterrupt(Z_MAX_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Z_MIN
-     _ATTACH(Z_MIN_PIN);
+     attachInterrupt(digitalPinToInterrupt(Z_MIN_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Z2_MAX
-    _ATTACH(Z2_MAX_PIN);
+    attachInterrupt(digitalPinToInterrupt(Z2_MAX_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Z2_MIN
-    _ATTACH(Z2_MIN_PIN);
+    attachInterrupt(digitalPinToInterrupt(Z2_MIN_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Z3_MAX
-    _ATTACH(Z3_MAX_PIN);
+    attachInterrupt(digitalPinToInterrupt(Z3_MAX_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Z3_MIN
-    _ATTACH(Z3_MIN_PIN);
+    attachInterrupt(digitalPinToInterrupt(Z3_MIN_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Z_MIN_PROBE_PIN
-    _ATTACH(Z_MIN_PROBE_PIN);
+    attachInterrupt(digitalPinToInterrupt(Z_MIN_PROBE_PIN), endstop_ISR, CHANGE);
  #endif
 }
@@ -26,10 +26,10 @@
 #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 "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
@@ -27,7 +27,7 @@
 #include <ESPmDNS.h>
 #include <WiFiUdp.h>
 #include <ArduinoOTA.h>
-#include <driver/timer.h>
+#include "driver/timer.h"

 void OTA_init() {
  ArduinoOTA
@@ -1,63 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * 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
@@ -0,0 +1,106 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * 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 <SPIFFS.h>
+#include <FS.h>
+#include "spiffs.h"
+
+#define HAL_ESP32_EEPROM_SIZE 4096
+#define HAL_ESP32_EEPROM_FILE_PATH "/eeprom.dat"
+
+File eeprom_file;
+
+bool PersistentStore::access_start() {
+  if (spiffs_initialized) {
+    eeprom_file = SPIFFS.open(HAL_ESP32_EEPROM_FILE_PATH, "r+");
+
+    size_t file_size = eeprom_file.size();
+    if (file_size < HAL_ESP32_EEPROM_SIZE) {
+      SERIAL_ECHO_MSG("SPIFFS EEPROM settings file " HAL_ESP32_EEPROM_FILE_PATH " is too small or did not exist, expanding.");
+      SERIAL_ECHO_START(); SERIAL_ECHOLNPAIR(" file size: ", file_size, ", required size: ", HAL_ESP32_EEPROM_SIZE);
+
+      // mode r+ does not allow to expand the file (at least on ESP32 SPIFFS9, so we close, reopen "a", append, close, reopen "r+"
+      eeprom_file.close();
+
+      eeprom_file = SPIFFS.open(HAL_ESP32_EEPROM_FILE_PATH, "a");
+      for (size_t i = eeprom_file.size(); i < HAL_ESP32_EEPROM_SIZE; i++)
+        eeprom_file.write(0xFF);
+      eeprom_file.close();
+
+      eeprom_file = SPIFFS.open(HAL_ESP32_EEPROM_FILE_PATH, "r+");
+      file_size = eeprom_file.size();
+      if (file_size < HAL_ESP32_EEPROM_SIZE) {
+        SERIAL_ERROR_MSG("Failed to expand " HAL_ESP32_EEPROM_FILE_PATH " to required size. SPIFFS partition full?");
+        SERIAL_ERROR_START(); SERIAL_ECHOLNPAIR(" file size: ", file_size, ", required size: ", HAL_ESP32_EEPROM_SIZE);
+        SERIAL_ERROR_START(); SERIAL_ECHOLNPAIR(" SPIFFS used bytes: ", SPIFFS.usedBytes(), ", total bytes: ", SPIFFS.totalBytes());
+      }
+    }
+    return true;
+  }
+  return false;
+}
+
+bool PersistentStore::access_finish() {
+  eeprom_file.close();
+  return true;
+}
+
+bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
+  if (!eeprom_file.seek(pos)) return true; // return true for any error
+  if (eeprom_file.write(value, size) != size) return true;
+
+  crc16(crc, value, size);
+  pos += size;
+
+  return false;
+}
+
+bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
+  if (!eeprom_file.seek(pos)) return true; // return true for any error
+
+  if (writing) {
+    if (eeprom_file.read(value, size) != size) return true;
+    crc16(crc, value, size);
+  }
+  else {
+    uint8_t tmp[size];
+    if (eeprom_file.read(tmp, size) != size) return true;
+    crc16(crc, tmp, size);
+  }
+
+  pos += size;
+
+  return false;
+}
+
+size_t PersistentStore::capacity() { return HAL_ESP32_EEPROM_SIZE; }
+
+#endif // EEPROM_SETTINGS
+#endif // ARDUINO_ARCH_ESP32
@@ -24,7 +24,7 @@

 #include "../../inc/MarlinConfigPre.h"

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

 #include "../../core/serial.h"

@@ -26,13 +26,13 @@

 #if ENABLED(USE_WATCHDOG)

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

-void watchdogSetup() {
+void watchdogSetup(void) {
  // do whatever. don't remove this function.
 }

-void watchdog_init() {
+void watchdog_init(void) {
  // TODO
 }

@@ -21,18 +21,8 @@
 */
 #pragma once

-#ifdef __cplusplus
-  extern "C" {
-#endif
-
-    esp_err_t esp_task_wdt_reset();
-
-#ifdef __cplusplus
-  }
-#endif
-
 // Initialize watchdog with a 4 second interrupt time
 void watchdog_init();

 // Reset watchdog.
-inline void HAL_watchdog_refresh() { esp_task_wdt_reset(); }
+inline void watchdog_reset() { }
@@ -22,18 +22,16 @@

 #ifdef ARDUINO_ARCH_ESP32

-#include <SPIFFS.h>
-#undef DISABLED  // esp32-hal-gpio.h
-
 #include "../../inc/MarlinConfigPre.h"

 #if ENABLED(WEBSUPPORT)

+#include <SPIFFS.h>
 #include "wifi.h"

 AsyncEventSource events("/events"); // event source (Server-Sent events)

-void onNotFound(AsyncWebServerRequest *request) {
+void onNotFound(AsyncWebServerRequest *request){
  request->send(404);
 }

@@ -31,10 +31,10 @@ HalSerial usb_serial;
 extern "C" void u8g_xMicroDelay(uint16_t val) {
  DELAY_US(val);
 }
-extern "C" void u8g_MicroDelay() {
+extern "C" void u8g_MicroDelay(void) {
  u8g_xMicroDelay(1);
 }
-extern "C" void u8g_10MicroDelay() {
+extern "C" void u8g_10MicroDelay(void) {
  u8g_xMicroDelay(10);
 }
 extern "C" void u8g_Delay(uint16_t val) {
@@ -51,7 +51,7 @@ int freeMemory() {
 // ADC
 // ------------------------

-void HAL_adc_init() {
+void HAL_adc_init(void) {

 }

@@ -64,18 +64,18 @@ void HAL_adc_start_conversion(const uint8_t ch) {
  active_ch = ch;
 }

-bool HAL_adc_finished() {
+bool HAL_adc_finished(void) {
  return true;
 }

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

-void HAL_pwm_init() {
+void HAL_pwm_init(void) {

 }

@@ -56,7 +56,7 @@ uint8_t _getc();
 #include "../shared/HAL_SPI.h"
 #include "fastio.h"
 #include "watchdog.h"
-#include "timers.h"
+#include "HAL_timers.h"
 #include "serial.h"

 #define SHARED_SERVOS HAS_SERVOS
@@ -78,29 +78,29 @@ extern HalSerial usb_serial;
 #define ENABLE_ISRS()
 #define DISABLE_ISRS()

-inline void HAL_init() {}
+inline void HAL_init(void) { }

 // Utility functions
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-function"
-int freeMemory();
-#pragma GCC diagnostic pop
+int freeMemory(void);
+
+// SPI: Extended functions which take 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);

 // ADC
 #define HAL_ANALOG_SELECT(pin) HAL_adc_enable_channel(pin)
 #define HAL_START_ADC(pin)     HAL_adc_start_conversion(pin)
-#define HAL_ADC_RESOLUTION     10
 #define HAL_READ_ADC()         HAL_adc_get_result()
 #define HAL_ADC_READY()        true

-void HAL_adc_init();
+void HAL_adc_init(void);
 void HAL_adc_enable_channel(int pin);
 void HAL_adc_start_conversion(const uint8_t adc_pin);
-uint16_t HAL_adc_get_result();
-
-// Reset source
-inline void HAL_clear_reset_source(void) {}
-inline uint8_t HAL_get_reset_source(void) { return RST_POWER_ON; }
+uint16_t HAL_adc_get_result(void);

 /* ---------------- Delay in cycles */
 FORCE_INLINE static void DELAY_CYCLES(uint64_t x) {
@@ -25,7 +25,7 @@
 #include "hardware/Timer.h"

 #include "../../inc/MarlinConfig.h"
-#include "timers.h"
+#include "HAL_timers.h"

 /**
 * Use POSIX signals to attempt to emulate Interrupts
@@ -37,7 +37,7 @@ HAL_TEMP_TIMER_ISR();

 Timer timers[2];

-void HAL_timer_init() {
+void HAL_timer_init(void) {
  timers[0].init(0, STEPPER_TIMER_RATE, TIMER0_IRQHandler);
  timers[1].init(1, TEMP_TIMER_RATE, TIMER1_IRQHandler);
 }
@@ -59,16 +59,16 @@ 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)

-#define HAL_STEP_TIMER_ISR()  extern "C" void TIMER0_IRQHandler()
-#define HAL_TEMP_TIMER_ISR()  extern "C" void TIMER1_IRQHandler()
+#define HAL_STEP_TIMER_ISR()  extern "C" void TIMER0_IRQHandler(void)
+#define HAL_TEMP_TIMER_ISR()  extern "C" void TIMER1_IRQHandler(void)

 // PWM timer
 #define HAL_PWM_TIMER
-#define HAL_PWM_TIMER_ISR()   extern "C" void TIMER3_IRQHandler()
+#define HAL_PWM_TIMER_ISR()   extern "C" void TIMER3_IRQHandler(void)
 #define HAL_PWM_TIMER_IRQn


-void HAL_timer_init();
+void HAL_timer_init(void);
 void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency);

 void HAL_timer_set_compare(const uint8_t timer_num, const hal_timer_t compare);
@@ -28,8 +28,8 @@
 #include "../shared/Delay.h"

 // Interrupts
-void cli() { } // Disable
-void sei() { } // Enable
+void cli(void) { } // Disable
+void sei(void) { }  // Enable

 // Time functions
 void _delay_ms(const int delay_ms) {
@@ -90,7 +90,7 @@ void eeprom_read_block(void *__dst, const void *__src, size_t __n) { }

 void eeprom_update_block(const void *__src, void *__dst, size_t __n) { }

-char *dtostrf(double __val, signed char __width, unsigned char __prec, char *__s) {
+char *dtostrf (double __val, signed char __width, unsigned char __prec, char *__s) {
  char format_string[20];
  snprintf(format_string, 20, "%%%d.%df", __width, __prec);
  sprintf(__s, format_string, __val);
@@ -49,6 +49,8 @@ typedef uint8_t byte;
 #define PGM_P const char *

 // Used for libraries, preprocessor, and constants
+#define min(a,b) ((a)<(b)?(a):(b))
+#define max(a,b) ((a)>(b)?(a):(b))
 #define abs(x) ((x)>0?(x):-(x))

 #ifndef isnan
@@ -63,9 +65,9 @@ typedef uint8_t byte;
 #define constrain(value, arg_min, arg_max) ((value) < (arg_min) ? (arg_min) :((value) > (arg_max) ? (arg_max) : (value)))

 //Interrupts
-void cli(); // Disable
-void sei(); // Enable
-void attachInterrupt(uint32_t pin, void (*callback)(), uint32_t mode);
+void cli(void); // Disable
+void sei(void); // Enable
+void attachInterrupt(uint32_t pin, void (*callback)(void), uint32_t mode);
 void detachInterrupt(uint32_t pin);
 extern "C" void GpioEnableInt(uint32_t port, uint32_t pin, uint32_t mode);
 extern "C" void GpioDisableInt(uint32_t port, uint32_t pin);
@@ -109,13 +111,13 @@ uint16_t analogRead(pin_t);
 // 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);
+void eeprom_read_block (void *__dst, const void *__src, size_t __n);
+void eeprom_update_block (const void *__src, void *__dst, size_t __n);

 int32_t random(int32_t);
 int32_t random(int32_t, int32_t);
 void randomSeed(uint32_t);

-char *dtostrf(double __val, signed char __width, unsigned char __prec, char *__s);
+char *dtostrf (double __val, signed char __width, unsigned char __prec, char *__s);

 int map(uint16_t x, uint16_t in_min, uint16_t in_max, uint16_t out_min, uint16_t out_max);
@@ -83,9 +83,9 @@ public:

  HalSerial() { host_connected = true; }

-  void begin(int32_t) {}
+  void begin(int32_t baud) { }

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

  int peek() {
    uint8_t value;
@@ -108,11 +108,11 @@ public:

  void flush() { receive_buffer.clear(); }

-  uint8_t availableForWrite() {
+  uint8_t availableForWrite(void){
    return transmit_buffer.free() > 255 ? 255 : (uint8_t)transmit_buffer.free();
  }

-  void flushTX() {
+  void flushTX(void){
    if (host_connected)
      while (transmit_buffer.available()) { /* nada */ }
  }
@@ -142,10 +142,10 @@ public:
  void print_bin(uint32_t value, uint8_t num_digits) {
    uint32_t mask = 1 << (num_digits -1);
    for (uint8_t i = 0; i < num_digits; i++) {
-      if (!(i %  4) && i) write(' ');
-      if (!(i % 16) && i) write(' ');
-      if (value & mask)   write('1');
-      else                write('0');
+      if (!(i % 4) && i)    write(' ');
+      if (!(i % 16)  && i)  write(' ');
+      if (value & mask)     write('1');
+      else                  write('0');
      value <<= 1;
    }
  }
@@ -200,7 +200,7 @@ public:
  void println(unsigned long value, int nbase = 0) { print(value, nbase); println(); }
  void println(float value, int round = 6) { printf("%f\n" , value); }
  void println(double value, int round = 6) { printf("%f\n" , value); }
-  void println() { print('\n'); }
+  void println(void) { print('\n'); }

  volatile RingBuffer<uint8_t, 128> receive_buffer;
  volatile RingBuffer<uint8_t, 128> transmit_buffer;
@@ -104,7 +104,7 @@ void simulation_loop() {
  }
 }

-int main() {
+int main(void) {
  std::thread write_serial (write_serial_thread);
  std::thread read_serial (read_serial_thread);

@@ -61,7 +61,7 @@ bool PersistentStore::access_finish() {
  return true;
 }

-bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
+bool PersistentStore::write_data(int &pos, const uint8_t *value, const size_t size, uint16_t *crc) {
  std::size_t bytes_written = 0;

  for (std::size_t i = 0; i < size; i++) {
@@ -28,9 +28,19 @@

 #include "watchdog.h"

-void watchdog_init() {}
-void HAL_watchdog_refresh() {}
+void watchdog_init(void) {}

-#endif
+void HAL_clear_reset_source(void) {}
+
+uint8_t HAL_get_reset_source(void) {
+  return RST_POWER_ON;
+}
+
+void watchdog_reset() {}
+
+#else
+  void HAL_clear_reset_source(void) {}
+  uint8_t HAL_get_reset_source(void) { return RST_POWER_ON; }
+#endif // USE_WATCHDOG

 #endif // __PLAT_LINUX__
@@ -23,5 +23,7 @@

 #define WDT_TIMEOUT   4000000 // 4 second timeout

-void watchdog_init();
-void HAL_watchdog_refresh();
+void watchdog_init(void);
+void watchdog_reset(void);
+void HAL_clear_reset_source(void);
+uint8_t HAL_get_reset_source(void);
@@ -44,7 +44,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) {
 }

 // Send character through UART with no interrupts
@@ -210,7 +210,7 @@ void HardFault_HandlerC(unsigned long *sp, unsigned long lr, unsigned long cause
 }

 extern "C" {
-__attribute__((naked)) void NMI_Handler() {
+__attribute__((naked)) void NMI_Handler(void) {
  __asm__ __volatile__ (
    ".syntax unified" "\n\t"
    A("tst lr, #4")
@@ -223,7 +223,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")
@@ -236,7 +236,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")
@@ -249,7 +249,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")
@@ -262,7 +262,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")
@@ -275,7 +275,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")
@@ -289,7 +289,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_IRQHandler() {
+__attribute__((naked)) void WDT_IRQHandler(void) {
  __asm__ __volatile__ (
    ".syntax unified" "\n\t"
    A("tst lr, #4")
@@ -302,7 +302,7 @@ __attribute__((naked)) void WDT_IRQHandler() {
  );
 }

-__attribute__((naked)) void RSTC_Handler() {
+__attribute__((naked)) void RSTC_Handler(void) {
  __asm__ __volatile__ (
    ".syntax unified" "\n\t"
    A("tst lr, #4")
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
InsanityAutomation	364684f60e	Update Configuration.h	2019-08-01 17:11:08 -04:00
InsanityAutomation	9f81c7622b	Update Configuration.h	2019-07-31 22:19:01 -04:00
InsanityAutomation	f344131699	Update _Statusscreen.h	2019-07-31 22:04:49 -04:00
InsanityAutomation	9b27abdb09	Update Configuration_adv.h	2019-07-31 21:59:28 -04:00
InsanityAutomation	c8ee607092	Update Configuration.h	2019-07-31 21:58:38 -04:00
InsanityAutomation	a130e08b3c	Update Configuration.h	2019-07-31 21:58:24 -04:00
InsanityAutomation	dc0cf5861a	Update Configuration_adv.h	2019-07-31 21:52:54 -04:00
InsanityAutomation	0196385a92	Update Configuration_adv.h	2019-07-31 21:51:05 -04:00
InsanityAutomation	0df276d871	Update Configuration.h	2019-07-31 21:39:02 -04:00
InsanityAutomation	baf8b6288c	Fix y endstop	2019-07-31 21:36:35 -04:00
InsanityAutomation	e6d3289dba	Bump	2019-07-31 20:02:22 -04:00
InsanityAutomation	43ad3cb6a0	Fix dual z issue	2019-07-11 23:27:14 -04:00
InsanityAutomation	22fda76fdc	Update HAL.cpp	2019-07-11 22:43:51 -04:00
InsanityAutomation	e62e389bec	Bump to head	2019-07-11 22:01:58 -04:00
InsanityAutomation	b1c20a6aa7	Initial Commit	2019-07-07 15:25:59 -04:00
InsanityAutomation	831e72453d	Update Configuration_adv.h	2019-07-06 09:35:34 -04:00
InsanityAutomation	ecd9c1370b	Update Configuration.h	2019-07-05 22:09:24 -04:00
InsanityAutomation	a5886798be	Update Configuration.h	2019-07-02 18:02:38 -04:00
InsanityAutomation	5b7e2f7055	Update Configuration.h	2019-07-01 23:00:23 -04:00
InsanityAutomation	5b8f71b846	SKR13 addition	2019-07-01 19:55:30 -04:00
InsanityAutomation	ac7dae7b49	Bump to head	2019-06-01 10:18:15 -04:00
InsanityAutomation	2fd98ab17c	Update Configuration.h	2019-06-01 10:04:11 -04:00
InsanityAutomation	c1e57e3a9b	Update Configuration.h	2019-04-27 09:42:49 -04:00
InsanityAutomation	7232bdd883	Update pause.cpp	2019-04-25 20:41:45 -04:00
InsanityAutomation	e4cad11951	Add commission menu	2019-03-31 10:42:02 -04:00
InsanityAutomation	d923c018b8	Update Configuration.h	2019-03-30 18:03:11 -04:00
InsanityAutomation	e3f6f1b12c	MRRF Bump	2019-03-29 17:43:34 -04:00
InsanityAutomation	ec2c721ca2	Bump	2019-02-19 18:44:42 -05:00
InsanityAutomation	919d7f8999	Bump	2019-01-16 11:07:15 -05:00
InsanityAutomation	8573625fab	add runout options	2019-01-13 16:35:15 -05:00
InsanityAutomation	900bb1aba3	Merge pull request #18 from InsanityAutomation/More-SD-Pause-Fixes More sd pause fixes	2019-01-13 16:12:18 -05:00
InsanityAutomation	5927818234	feed rate and park	2019-01-13 16:11:22 -05:00
InsanityAutomation	8be2aa0ef4	Initial commit	2019-01-13 14:35:45 -05:00
InsanityAutomation	6284eaf17d	Make M25 work as well	2019-01-12 23:36:12 -05:00
InsanityAutomation	5094b167d4	Update menu_main.cpp	2019-01-12 19:40:20 -05:00
InsanityAutomation	42e9e85282	Merge branch 'bugfix-2.0.x' into More-SD-Pause-Fixes	2019-01-12 19:34:02 -05:00
InsanityAutomation	eb0bf22d09	Update menu_main.cpp	2019-01-12 19:32:52 -05:00
InsanityAutomation	57e51e0d7d	Bump	2019-01-12 19:00:23 -05:00
Scott Lahteine	3358333e22	Remove extra lcd_advanced_pause_show_message call	2019-01-12 17:14:33 -06:00
Scott Lahteine	a7a6503917	Update menu_main.cpp	2019-01-12 17:04:00 -06:00
Scott Lahteine	acbe72c239	Remove extra defer_status_screen(false), refresh()	2019-01-12 17:00:53 -06:00
InsanityAutomation	dbac603128	Update menu_main.cpp	2019-01-12 17:09:22 -05:00
				`@@ -1 +0,0 @@`
				`custom: http://www.thinkyhead.com/donate-to-marlin`