Merge pull request #55 from g0dsCookie/CrealityDwin_2.0

Fixed include paths

.circleci/config.yml

@@ -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 STM32/STM32F10
+            use_example_configs STM32/STM32F10
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs STM32/stm32f103ret6
+            use_example_configs STM32/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" }}

.editorconfig

@@ -1,19 +0,0 @@
-# editorconfig.org
-root = true
-
-[{*.patch,syntax_test_*}]
-trim_trailing_whitespace = false
-
-[{*.c,*.cpp,*.h}]
-charset = utf-8
-
-[{*.c,*.cpp,*.h,Makefile}]
-trim_trailing_whitespace = true
-insert_final_newline = true
-end_of_line = lf
-indent_style = space
-indent_size = 2
-
-[{*.py,*.conf,*.sublime-project}]
-indent_style = tab
-indent_size = 4

.github/FUNDING.yml

@@ -1,3 +1 @@
-github: [thinkyhead]
-patreon: thinkyhead
-custom: ["http://www.thinkyhead.com/donate-to-marlin"]
+custom: http://www.thinkyhead.com/donate-to-marlin

.github/workflows/test-builds.yml

@@ -1,104 +0,0 @@
-#
-# test-builds.yml
-# Do test builds to catch compile errors
-#
-
-name: CI
-
-on:
-  pull_request:
-    branches:
-    - bugfix-2.0.x
-    - dev-2.1.x
-    paths-ignore:
-    - config/**
-    - data/**
-    - docs/**
-    - '**/*.md'
-
-jobs:
-  test_builds:
-
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        test-platform:
-        # Base Environments
-
-        - DUE
-        - esp32
-        - linux_native
-        - mega2560
-        - teensy31
-        - teensy35
-        - SAMD51_grandcentral_m4
-
-        # Extended AVR Environments
-
-        - FYSETC_F6_13
-        - mega1280
-        - rambo
-        - sanguino1284p
-        - sanguino644p
-
-        # Extended STM32 Environments
-
-        - STM32F103RC_btt
-        - STM32F103RC_btt_USB
-        - STM32F103RE_btt
-        - STM32F103RE_btt_USB
-        - STM32F103RC_fysetc
-        - jgaurora_a5s_a1
-        - STM32F103VE_longer
-        - STM32F407VE_black
-        - BIGTREE_SKR_PRO
-        - BIGTREE_GTR_V1_0
-        - mks_robin
-        - ARMED
-        - FYSETC_S6
-
-        # Put lengthy tests last
-
-        - LPC1768
-        - LPC1769
-
-        # STM32 with non-STM framework. both broken for now. they should use HAL_STM32 which is working.
-
-        #- STM32F4
-        #- STM32F7
-
-        # Non-working environment tests
-
-        #- BIGTREE_BTT002
-        #- at90usb1286_cdc
-        #- at90usb1286_dfu
-        #- STM32F103CB_malyan
-        #- mks_robin_lite
-        #- mks_robin_mini
-        #- mks_robin_nano
-
-    steps:
-
-    - name: Select Python 3.7
-      uses: actions/setup-python@v1
-      with:
-        python-version: '3.7' # Version range or exact version of a Python version to use, using semvers version range syntax.
-        architecture: 'x64' # optional x64 or x86. Defaults to x64 if not specified
-
-    - name: Install PlatformIO
-      run: |
-        pip install -U https://github.com/platformio/platformio-core/archive/master.zip
-        platformio update
-
-    - name: Check out the PR
-      uses: actions/checkout@v2
-
-    - name: Run ${{ matrix.test-platform }} Tests
-      run: |
-        # Inline tests script
-        [[ "$GITHUB_REPOSITORY" == "MarlinFirmware/Marlin" ]] || exit 0
-        chmod +x buildroot/bin/*
-        chmod +x buildroot/share/tests/*
-        export PATH=./buildroot/bin/:./buildroot/share/tests/:${PATH}
-        run_tests . ${{ matrix.test-platform }}

.gitignore

@@ -1,6 +1,6 @@
 #
 # Marlin 3D Printer Firmware
-# Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+# Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 #
 # Based on Sprinter and grbl.
 # Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -146,9 +146,6 @@ Marlin/*/*/readme.txt
 Marlin/*/*/*/readme.txt
 Marlin/*/*/*/*/readme.txt
 
-# Secure Credentials
-Configuration_Secure.h
-
 #Visual Studio
 *.sln
 *.vcxproj

.travis.yml

@@ -9,51 +9,18 @@ notifications:
   email: false
 
 env:
-  # Base Environments
-  - TEST_PLATFORM="DUE"
-  - TEST_PLATFORM="esp32"
-  - TEST_PLATFORM="linux_native"
   - TEST_PLATFORM="megaatmega2560"
-  - TEST_PLATFORM="teensy31"
-  - TEST_PLATFORM="teensy35"
-
-  # Extended AVR Environments
-  - TEST_PLATFORM="FYSETC_F6_13"
-  - TEST_PLATFORM="megaatmega1280"
-  - TEST_PLATFORM="rambo"
-  - TEST_PLATFORM="sanguino_atmega1284p"
-  - TEST_PLATFORM="sanguino_atmega644p"
-
-  # Extended STM32 Environments
-  - TEST_PLATFORM="STM32F103RC_bigtree"
-  - TEST_PLATFORM="STM32F103RC_bigtree_USB"
-  - TEST_PLATFORM="STM32F103RE_bigtree"
-  - TEST_PLATFORM="STM32F103RE_bigtree_USB"
-  - TEST_PLATFORM="STM32F103RC_fysetc"
-  - TEST_PLATFORM="jgaurora_a5s_a1"
-  - TEST_PLATFORM="STM32F103VE_longer"
-  - TEST_PLATFORM="STM32F407VE_black"
-  - TEST_PLATFORM="BIGTREE_SKR_PRO"
-  - TEST_PLATFORM="mks_robin"
-  - TEST_PLATFORM="ARMED"
-
-  # STM32 with non-STM framework. both broken for now. they should use HAL_STM32 which is working.
-  #- TEST_PLATFORM="STM32F4"
-  #- TEST_PLATFORM="STM32F7"
-
-  # Put lengthy tests last
+  - TEST_PLATFORM="DUE"
   - TEST_PLATFORM="LPC1768"
   - TEST_PLATFORM="LPC1769"
-
-  # Non-working environment tests
-  #- TEST_PLATFORM="BIGTREE_BTT002" this board isn't released yet. we need pinout to be sure about what we do
-  #- TEST_PLATFORM="at90usb1286_cdc"
-  #- TEST_PLATFORM="at90usb1286_dfu"
-  #- TEST_PLATFORM="STM32F103CB_malyan"
-  #- TEST_PLATFORM="mks_robin_lite"
-  #- TEST_PLATFORM="mks_robin_mini"
-  #- TEST_PLATFORM="mks_robin_nano"
-  #- TEST_PLATFORM="SAMD51_grandcentral_m4"
+  - TEST_PLATFORM="STM32F1"
+  - TEST_PLATFORM="teensy31"
+  - TEST_PLATFORM="teensy35"
+  - TEST_PLATFORM="linux_native"
+  - TEST_PLATFORM="esp32"
+  - TEST_PLATFORM="alfawise_U20"
+  - TEST_PLATFORM="black_stm32f407ve"
+  - TEST_PLATFORM="adafruit_grandcentral_m4"
 
 before_install:
   #
@@ -77,8 +44,8 @@ before_script:
   - cd ${TRAVIS_BUILD_DIR}
   #
   # Generate custom version include
-  - generate_version ${TRAVIS_BUILD_DIR}/Marlin/
-  - cat ${TRAVIS_BUILD_DIR}/Marlin/Version.h
+  - 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}

Marlin/Makefile

@@ -251,10 +251,6 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1141)
 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)
 
 #
 # RAMBo and derivatives
@@ -281,44 +277,42 @@ 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
@@ -693,7 +687,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}

Marlin/Version.h

@@ -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 "2.0.5_SX4M"
-
-/**
- * Verbose version identifier which should contain a reference to the location
- * from where the binary was downloaded or the source code was compiled.
- */
-#define DETAILED_BUILD_VERSION SHORT_BUILD_VERSION " TM3D"
-
-/**
- * The STRING_DISTRIBUTION_DATE represents when the binary file was built,
- * here we define this default string as the date where the latest release
- * version was tagged.
- */
-#define STRING_DISTRIBUTION_DATE "2020-04-07"
-
-/**
- * Defines a generic printer name to be output to the LCD after booting Marlin.
- */
-#define MACHINE_NAME "TM3D SX4"
-
-/**
- * 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/InsanityAutomation/Marlin/tree/TM_SX4_2.0"
-
-/**
- * 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 "tinymachines3d.com"
-
-/**
- * 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

Marlin/_Bootscreen.h

@@ -29,6 +29,7 @@
  *  - http://www.marlinfw.org/tools/u8glib/converter.html
  *  - http://www.digole.com/tools/PicturetoC_Hex_converter.php
  */
+#include <avr/pgmspace.h>
 
 #define CUSTOM_BOOTSCREEN_TIMEOUT   2500
 #define CUSTOM_BOOTSCREEN_BMPWIDTH  128

Marlin/src/HAL/AVR/endstop_interrupts.h

@@ -1,261 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-/**
- * Endstop Interrupts
- *
- * Without endstop interrupts the endstop pins must be polled continually in
- * the temperature-ISR via endstops.update(), most of the time finding no change.
- * With this feature endstops.update() is called only when we know that at
- * least one endstop has changed state, saving valuable CPU cycles.
- *
- * This feature only works when all used endstop pins can generate either an
- * 'external interrupt' or a 'pin change interrupt'.
- *
- * Test whether pins issue interrupts on your board by flashing 'pin_interrupt_test.ino'.
- * (Located in Marlin/buildroot/share/pin_interrupt_test/pin_interrupt_test.ino)
- */
-
-#include "../../module/endstops.h"
-
-#include <stdint.h>
-
-// One ISR for all EXT-Interrupts
-void endstop_ISR() { endstops.update(); }
-
-/**
- * Patch for pins_arduino.h (...\Arduino\hardware\arduino\avr\variants\mega\pins_arduino.h)
- *
- * These macros for the Arduino MEGA do not include the two connected pins on Port J (D14, D15).
- * So we extend them here because these are the normal pins for Y_MIN and Y_MAX on RAMPS.
- * There are more PCI-enabled processor pins on Port J, but they are not connected to Arduino MEGA.
- */
-#if defined(ARDUINO_AVR_MEGA2560) || defined(ARDUINO_AVR_MEGA)
-
-  #define digitalPinHasPCICR(p)   (WITHIN(p, 10, 15) || WITHIN(p, 50, 53) || WITHIN(p, 62, 69))
-
-  #undef  digitalPinToPCICR
-  #define digitalPinToPCICR(p)    (digitalPinHasPCICR(p) ? (&PCICR) : nullptr)
-
-  #undef  digitalPinToPCICRbit
-  #define digitalPinToPCICRbit(p) (WITHIN(p, 10, 13) || WITHIN(p, 50, 53) ? 0 : \
-                                   WITHIN(p, 14, 15) ? 1 : \
-                                   WITHIN(p, 62, 69) ? 2 : \
-                                   0)
-
-  #undef  digitalPinToPCMSK
-  #define digitalPinToPCMSK(p)    (WITHIN(p, 10, 13) || WITHIN(p, 50, 53) ? (&PCMSK0) : \
-                                   WITHIN(p, 14, 15) ? (&PCMSK1) : \
-                                   WITHIN(p, 62, 69) ? (&PCMSK2) : \
-                                   nullptr)
-
-  #undef  digitalPinToPCMSKbit
-  #define digitalPinToPCMSKbit(p) (WITHIN(p, 10, 13) ? ((p) - 6) : \
-                                   (p) == 14 || (p) == 51 ? 2 : \
-                                   (p) == 15 || (p) == 52 ? 1 : \
-                                   (p) == 50 ? 3 : \
-                                   (p) == 53 ? 0 : \
-                                   WITHIN(p, 62, 69) ? ((p) - 62) : \
-                                   0)
-
-#elif defined(__AVR_ATmega164A__) || defined(__AVR_ATmega164P__) || defined(__AVR_ATmega324A__) || \
-      defined(__AVR_ATmega324P__) || defined(__AVR_ATmega324PA__) || defined(__AVR_ATmega324PB__) || \
-      defined(__AVR_ATmega644A__) || defined(__AVR_ATmega644P__) || defined(__AVR_ATmega1284__) || \
-      defined(__AVR_ATmega1284P__)
-
-  #define digitalPinHasPCICR(p)   WITHIN(p, 0, NUM_DIGITAL_PINS)
-
-#else
-
-  #error "Unsupported AVR variant!"
-
-#endif
-
-
-// Install Pin change interrupt for a pin. Can be called multiple times.
-void pciSetup(const int8_t pin) {
-  if (digitalPinHasPCICR(pin)) {
-    SBI(*digitalPinToPCMSK(pin), digitalPinToPCMSKbit(pin));  // enable pin
-    SBI(PCIFR, digitalPinToPCICRbit(pin)); // clear any outstanding interrupt
-    SBI(PCICR, digitalPinToPCICRbit(pin)); // enable interrupt for the group
-  }
-}
-
-// Handlers for pin change interrupts
-#ifdef PCINT0_vect
-  ISR(PCINT0_vect) { endstop_ISR(); }
-#endif
-
-#ifdef PCINT1_vect
-  ISR(PCINT1_vect, ISR_ALIASOF(PCINT0_vect));
-#endif
-
-#ifdef PCINT2_vect
-  ISR(PCINT2_vect, ISR_ALIASOF(PCINT0_vect));
-#endif
-
-#ifdef PCINT3_vect
-  ISR(PCINT3_vect, ISR_ALIASOF(PCINT0_vect));
-#endif
-
-void setup_endstop_interrupts() {
-  #define _ATTACH(P) attachInterrupt(digitalPinToInterrupt(P), endstop_ISR, CHANGE)
-  #if HAS_X_MAX
-    #if (digitalPinToInterrupt(X_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(X_MAX_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(X_MAX_PIN), "X_MAX_PIN is not interrupt-capable");
-      pciSetup(X_MAX_PIN);
-    #endif
-  #endif
-  #if HAS_X_MIN
-    #if (digitalPinToInterrupt(X_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(X_MIN_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(X_MIN_PIN), "X_MIN_PIN is not interrupt-capable");
-      pciSetup(X_MIN_PIN);
-    #endif
-  #endif
-  #if HAS_Y_MAX
-    #if (digitalPinToInterrupt(Y_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Y_MAX_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(Y_MAX_PIN), "Y_MAX_PIN is not interrupt-capable");
-      pciSetup(Y_MAX_PIN);
-    #endif
-  #endif
-  #if HAS_Y_MIN
-    #if (digitalPinToInterrupt(Y_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Y_MIN_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(Y_MIN_PIN), "Y_MIN_PIN is not interrupt-capable");
-      pciSetup(Y_MIN_PIN);
-    #endif
-  #endif
-  #if HAS_Z_MAX
-    #if (digitalPinToInterrupt(Z_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z_MAX_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(Z_MAX_PIN), "Z_MAX_PIN is not interrupt-capable");
-      pciSetup(Z_MAX_PIN);
-    #endif
-  #endif
-  #if HAS_Z_MIN
-    #if (digitalPinToInterrupt(Z_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z_MIN_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(Z_MIN_PIN), "Z_MIN_PIN is not interrupt-capable");
-      pciSetup(Z_MIN_PIN);
-    #endif
-  #endif
-  #if HAS_X2_MAX
-    #if (digitalPinToInterrupt(X2_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(X2_MAX_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(X2_MAX_PIN), "X2_MAX_PIN is not interrupt-capable");
-      pciSetup(X2_MAX_PIN);
-    #endif
-  #endif
-  #if HAS_X2_MIN
-    #if (digitalPinToInterrupt(X2_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(X2_MIN_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(X2_MIN_PIN), "X2_MIN_PIN is not interrupt-capable");
-      pciSetup(X2_MIN_PIN);
-    #endif
-  #endif
-  #if HAS_Y2_MAX
-    #if (digitalPinToInterrupt(Y2_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Y2_MAX_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(Y2_MAX_PIN), "Y2_MAX_PIN is not interrupt-capable");
-      pciSetup(Y2_MAX_PIN);
-    #endif
-  #endif
-  #if HAS_Y2_MIN
-    #if (digitalPinToInterrupt(Y2_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Y2_MIN_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(Y2_MIN_PIN), "Y2_MIN_PIN is not interrupt-capable");
-      pciSetup(Y2_MIN_PIN);
-    #endif
-  #endif
-  #if HAS_Z2_MAX
-    #if (digitalPinToInterrupt(Z2_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z2_MAX_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(Z2_MAX_PIN), "Z2_MAX_PIN is not interrupt-capable");
-      pciSetup(Z2_MAX_PIN);
-    #endif
-  #endif
-  #if HAS_Z2_MIN
-    #if (digitalPinToInterrupt(Z2_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z2_MIN_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(Z2_MIN_PIN), "Z2_MIN_PIN is not interrupt-capable");
-      pciSetup(Z2_MIN_PIN);
-    #endif
-  #endif
-  #if HAS_Z3_MAX
-    #if (digitalPinToInterrupt(Z3_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z3_MAX_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(Z3_MAX_PIN), "Z3_MAX_PIN is not interrupt-capable");
-      pciSetup(Z3_MAX_PIN);
-    #endif
-  #endif
-  #if HAS_Z3_MIN
-    #if (digitalPinToInterrupt(Z3_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z3_MIN_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(Z3_MIN_PIN), "Z3_MIN_PIN is not interrupt-capable");
-      pciSetup(Z3_MIN_PIN);
-    #endif
-  #endif
-  #if HAS_Z4_MAX
-    #if (digitalPinToInterrupt(Z4_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z4_MAX_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(Z4_MAX_PIN), "Z4_MAX_PIN is not interrupt-capable");
-      pciSetup(Z4_MAX_PIN);
-    #endif
-  #endif
-  #if HAS_Z4_MIN
-    #if (digitalPinToInterrupt(Z4_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z4_MIN_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(Z4_MIN_PIN), "Z4_MIN_PIN is not interrupt-capable");
-      pciSetup(Z4_MIN_PIN);
-    #endif
-  #endif
-  #if HAS_Z_MIN_PROBE_PIN
-    #if (digitalPinToInterrupt(Z_MIN_PROBE_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z_MIN_PROBE_PIN);
-    #else
-      static_assert(digitalPinHasPCICR(Z_MIN_PROBE_PIN), "Z_MIN_PROBE_PIN is not interrupt-capable");
-      pciSetup(Z_MIN_PROBE_PIN);
-    #endif
-  #endif
-
-  // If we arrive here without raising an assertion, each pin has either an EXT-interrupt or a PCI.
-}

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

@@ -1,206 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * The PWM module is only used to generate interrupts at specified times. It
- * is NOT used to directly toggle pins. The ISR writes to the pin assigned to
- * that interrupt.
- *
- * All PWMs use the same repetition rate.  The G2 needs about 10KHz min in order to
- * not have obvious ripple on the Vref signals.
- *
- * The data structures are setup to minimize the computation done by the ISR which
- * minimizes ISR execution time.  Execution times are 0.8 to 1.1 microseconds.
- *
- * FIve PWM interrupt sources are used.  Channel 0 sets the base period.  All Vref
- * signals are set active when this counter overflows and resets to zero.  The compare
- * values in channels 1-4 are set to give the desired duty cycle for that Vref pin.
- * When counter 0 matches the compare value then that channel generates an interrupt.
- * The ISR checks the source of the interrupt and sets the corresponding pin inactive.
- *
- * Some jitter in the Vref signal is OK so the interrupt priority is left at its default value.
- */
-
-#include "../../../inc/MarlinConfig.h"
-
-#if MB(PRINTRBOARD_G2)
-
-#include "G2_PWM.h"
-
-#if PIN_EXISTS(MOTOR_CURRENT_PWM_X)
-  #define G2_PWM_X 1
-#else
-  #define G2_PWM_X 0
-#endif
-#if PIN_EXISTS(MOTOR_CURRENT_PWM_Y)
-  #define G2_PWM_Y 1
-#else
-  #define G2_PWM_Y 0
-#endif
-#if PIN_EXISTS(MOTOR_CURRENT_PWM_Z)
-  #define G2_PWM_Z 1
-#else
-  #define G2_PWM_Z 0
-#endif
-#if PIN_EXISTS(MOTOR_CURRENT_PWM_E)
-  #define G2_PWM_E 1
-#else
-  #define G2_PWM_E 0
-#endif
-#define G2_MASK_X(V) (G2_PWM_X * (V))
-#define G2_MASK_Y(V) (G2_PWM_Y * (V))
-#define G2_MASK_Z(V) (G2_PWM_Z * (V))
-#define G2_MASK_E(V) (G2_PWM_E * (V))
-
-volatile uint32_t *SODR_A = &PIOA->PIO_SODR,
-                  *SODR_B = &PIOB->PIO_SODR,
-                  *CODR_A = &PIOA->PIO_CODR,
-                  *CODR_B = &PIOB->PIO_CODR;
-
-PWM_map ISR_table[NUM_PWMS] = PWM_MAP_INIT;
-
-void Stepper::digipot_init() {
-
-  #if PIN_EXISTS(MOTOR_CURRENT_PWM_X)
-    OUT_WRITE(MOTOR_CURRENT_PWM_X_PIN, 0);  // init pins
-  #endif
-  #if PIN_EXISTS(MOTOR_CURRENT_PWM_Y)
-    OUT_WRITE(MOTOR_CURRENT_PWM_Y_PIN, 0);
-  #endif
-  #if G2_PWM_Z
-    OUT_WRITE(MOTOR_CURRENT_PWM_Z_PIN, 0);
-  #endif
-  #if G2_PWM_E
-    OUT_WRITE(MOTOR_CURRENT_PWM_E_PIN, 0);
-  #endif
-
-  #define WPKEY          (0x50574D << 8) // “PWM” in ASCII
-  #define WPCMD_DIS_SW   0  // command to disable Write Protect SW
-  #define WPRG_ALL       (PWM_WPCR_WPRG0 | PWM_WPCR_WPRG1 | PWM_WPCR_WPRG2 | PWM_WPCR_WPRG3 | PWM_WPCR_WPRG4 | PWM_WPCR_WPRG5)  // all Write Protect Groups
-
-  #define PWM_CLOCK_F    F_CPU / 1000000UL   // set clock to 1MHz
-
-  PMC->PMC_PCER1 = PMC_PCER1_PID36;                       // enable PWM controller clock (disabled on power up)
-
-  PWM->PWM_WPCR = WPKEY | WPRG_ALL | WPCMD_DIS_SW;        // enable setting of all PWM registers
-  PWM->PWM_CLK = PWM_CLOCK_F;                             // enable CLK_A and set it to 1MHz, leave CLK_B disabled
-  PWM->PWM_CH_NUM[0].PWM_CMR = 0b1011;                    // set channel 0 to Clock A input & to left aligned
-  if (G2_PWM_X) PWM->PWM_CH_NUM[1].PWM_CMR = 0b1011;      // set channel 1 to Clock A input & to left aligned
-  if (G2_PWM_Y) PWM->PWM_CH_NUM[2].PWM_CMR = 0b1011;      // set channel 2 to Clock A input & to left aligned
-  if (G2_PWM_Z) PWM->PWM_CH_NUM[3].PWM_CMR = 0b1011;      // set channel 3 to Clock A input & to left aligned
-  if (G2_PWM_E) PWM->PWM_CH_NUM[4].PWM_CMR = 0b1011;      // set channel 4 to Clock A input & to left aligned
-
-  PWM->PWM_CH_NUM[0].PWM_CPRD = PWM_PERIOD_US;            // set channel 0 Period
-
-  PWM->PWM_IER2 = PWM_IER1_CHID0;                         // generate interrupt when counter0 overflows
-  PWM->PWM_IER2 = PWM_IER2_CMPM0
-    | G2_MASK_X(PWM_IER2_CMPM1)
-    | G2_MASK_Y(PWM_IER2_CMPM2)
-    | G2_MASK_Z(PWM_IER2_CMPM3)
-    | G2_MASK_E(PWM_IER2_CMPM4)
-  ; // generate interrupt on compare event
-
-  if (G2_PWM_X) PWM->PWM_CMP[1].PWM_CMPV = 0x010000000LL | G2_VREF_COUNT(G2_VREF(motor_current_setting[0])); // interrupt when counter0 == CMPV - used to set Motor 1 PWM inactive
-  if (G2_PWM_Y) PWM->PWM_CMP[2].PWM_CMPV = 0x010000000LL | G2_VREF_COUNT(G2_VREF(motor_current_setting[0])); // interrupt when counter0 == CMPV - used to set Motor 2 PWM inactive
-  if (G2_PWM_Z) PWM->PWM_CMP[3].PWM_CMPV = 0x010000000LL | G2_VREF_COUNT(G2_VREF(motor_current_setting[1])); // interrupt when counter0 == CMPV - used to set Motor 3 PWM inactive
-  if (G2_PWM_E) PWM->PWM_CMP[4].PWM_CMPV = 0x010000000LL | G2_VREF_COUNT(G2_VREF(motor_current_setting[2])); // interrupt when counter0 == CMPV - used to set Motor 4 PWM inactive
-
-  if (G2_PWM_X) PWM->PWM_CMP[1].PWM_CMPM = 0x0001;  // enable compare event
-  if (G2_PWM_Y) PWM->PWM_CMP[2].PWM_CMPM = 0x0001;  // enable compare event
-  if (G2_PWM_Z) PWM->PWM_CMP[3].PWM_CMPM = 0x0001;  // enable compare event
-  if (G2_PWM_E) PWM->PWM_CMP[4].PWM_CMPM = 0x0001;  // enable compare event
-
-  PWM->PWM_SCM = PWM_SCM_UPDM_MODE0 | PWM_SCM_SYNC0
-    | G2_MASK_X(PWM_SCM_SYNC1)
-    | G2_MASK_Y(PWM_SCM_SYNC2)
-    | G2_MASK_Z(PWM_SCM_SYNC3)
-    | G2_MASK_E(PWM_SCM_SYNC4)
-  ; // sync 1-4 with 0, use mode 0 for updates
-
-  PWM->PWM_ENA = PWM_ENA_CHID0
-    | G2_MASK_X(PWM_ENA_CHID1)
-    | G2_MASK_Y(PWM_ENA_CHID2)
-    | G2_MASK_Z(PWM_ENA_CHID3)
-    | G2_MASK_E(PWM_ENA_CHID4)
-  ; // enable channels used by G2
-
-  PWM->PWM_IER1 = PWM_IER1_CHID0
-    | G2_MASK_X(PWM_IER1_CHID1)
-    | G2_MASK_Y(PWM_IER1_CHID2)
-    | G2_MASK_Z(PWM_IER1_CHID3)
-    | G2_MASK_E(PWM_IER1_CHID4)
-  ; // enable interrupts for channels used by G2
-
-  NVIC_EnableIRQ(PWM_IRQn);     // Enable interrupt handler
-  NVIC_SetPriority(PWM_IRQn, NVIC_EncodePriority(0, 10, 0));  // normal priority for PWM module (can stand some jitter on the Vref signals)
-}
-
-void Stepper::digipot_current(const uint8_t driver, const int16_t current) {
-
-  if (!(PWM->PWM_CH_NUM[0].PWM_CPRD == PWM_PERIOD_US)) digipot_init();  // Init PWM system if needed
-
-  switch (driver) {
-    case 0:
-      if (G2_PWM_X) PWM->PWM_CMP[1].PWM_CMPVUPD = 0x010000000LL | G2_VREF_COUNT(G2_VREF(current));    // update X & Y
-      if (G2_PWM_Y) PWM->PWM_CMP[2].PWM_CMPVUPD = 0x010000000LL | G2_VREF_COUNT(G2_VREF(current));
-      if (G2_PWM_X) PWM->PWM_CMP[1].PWM_CMPMUPD = 0x0001;  // enable compare event
-      if (G2_PWM_Y) PWM->PWM_CMP[2].PWM_CMPMUPD = 0x0001;  // enable compare event
-      if (G2_PWM_X || G2_PWM_Y) PWM->PWM_SCUC = PWM_SCUC_UPDULOCK; // tell the PWM controller to update the values on the next cycle
-      break;
-    case 1:
-      if (G2_PWM_Z) {
-        PWM->PWM_CMP[3].PWM_CMPVUPD = 0x010000000LL | G2_VREF_COUNT(G2_VREF(current));    // update Z
-        PWM->PWM_CMP[3].PWM_CMPMUPD = 0x0001;  // enable compare event
-        PWM->PWM_SCUC = PWM_SCUC_UPDULOCK; // tell the PWM controller to update the values on the next cycle
-      }
-      break;
-    default:
-      if (G2_PWM_E) {
-        PWM->PWM_CMP[4].PWM_CMPVUPD = 0x010000000LL | G2_VREF_COUNT(G2_VREF(current));    // update E
-        PWM->PWM_CMP[4].PWM_CMPMUPD = 0x0001;  // enable compare event
-        PWM->PWM_SCUC = PWM_SCUC_UPDULOCK; // tell the PWM controller to update the values on the next cycle
-      }
-      break;
-  }
-}
-
-volatile uint32_t PWM_ISR1_STATUS, PWM_ISR2_STATUS;
-
-void PWM_Handler() {
-  PWM_ISR1_STATUS = PWM->PWM_ISR1;
-  PWM_ISR2_STATUS = PWM->PWM_ISR2;
-  if (PWM_ISR1_STATUS & PWM_IER1_CHID0) {                                                         // CHAN_0 interrupt
-    if (G2_PWM_X) *ISR_table[0].set_register = ISR_table[0].write_mask;                           // set X to active
-    if (G2_PWM_Y) *ISR_table[1].set_register = ISR_table[1].write_mask;                           // set Y to active
-    if (G2_PWM_Z) *ISR_table[2].set_register = ISR_table[2].write_mask;                           // set Z to active
-    if (G2_PWM_E) *ISR_table[3].set_register = ISR_table[3].write_mask;                           // set E to active
-  }
-  else {
-    if (G2_PWM_X && (PWM_ISR2_STATUS & PWM_IER2_CMPM1)) *ISR_table[0].clr_register = ISR_table[0].write_mask; // set X to inactive
-    if (G2_PWM_Y && (PWM_ISR2_STATUS & PWM_IER2_CMPM2)) *ISR_table[1].clr_register = ISR_table[1].write_mask; // set Y to inactive
-    if (G2_PWM_Z && (PWM_ISR2_STATUS & PWM_IER2_CMPM3)) *ISR_table[2].clr_register = ISR_table[2].write_mask; // set Z to inactive
-    if (G2_PWM_E && (PWM_ISR2_STATUS & PWM_IER2_CMPM4)) *ISR_table[3].clr_register = ISR_table[3].write_mask; // set E to inactive
-  }
-  return;
-}
-
-#endif // PRINTRBOARD_G2

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

@@ -1,28 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-#if USE_FALLBACK_EEPROM
-  #undef SRAM_EEPROM_EMULATION
-  #undef SDCARD_EEPROM_EMULATION
-  #define FLASH_EEPROM_EMULATION
-#endif

Marlin/src/HAL/ESP32/eeprom_impl.cpp

@@ -1,63 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifdef ARDUINO_ARCH_ESP32
-
-#include "../../inc/MarlinConfig.h"
-
-#if USE_WIRED_EEPROM
-
-#include "../shared/eeprom_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 // USE_WIRED_EEPROM
-#endif // ARDUINO_ARCH_ESP32

Marlin/src/HAL/ESP32/inc/Conditionals_post.h

@@ -1,27 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-#undef USE_WIRED_EEPROM
-#if ENABLED(EEPROM_SETTINGS) && DISABLED(FLASH_EEPROM_EMULATION)
-  #define USE_WIRED_EEPROM 1
-#endif

Marlin/src/HAL/ESP32/watchdog.h

@@ -1,38 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-#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(); }

Marlin/src/HAL/HAL.h

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -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
-}

Marlin/src/HAL/HAL_AVR/HAL.cpp

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -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

Marlin/src/HAL/HAL_AVR/HAL.h

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  * Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
  *
  * This program is free software: you can redistribute it and/or modify
@@ -25,7 +25,7 @@
 #include "math.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
 // ------------------------
@@ -53,8 +45,8 @@
 //#define analogInputToDigitalPin(IO) IO
 
 #ifndef CRITICAL_SECTION_START
-  #define CRITICAL_SECTION_START()  unsigned char _sreg = SREG; cli()
-  #define CRITICAL_SECTION_END()    SREG = _sreg
+  #define CRITICAL_SECTION_START  unsigned char _sreg = SREG; cli()
+  #define CRITICAL_SECTION_END    SREG = _sreg
 #endif
 #define ISRS_ENABLED() TEST(SREG, SREG_I)
 #define ENABLE_ISRS()  sei()
@@ -91,54 +83,41 @@ typedef int8_t pin_t;
   #define NUM_SERIAL 1
 #else
   #if !WITHIN(SERIAL_PORT, -1, 3)
-    #error "SERIAL_PORT must be from -1 to 3. Please update your configuration."
+    #error "SERIAL_PORT must be from -1 to 3"
   #endif
 
   #define MYSERIAL0 customizedSerial1
 
   #ifdef SERIAL_PORT_2
     #if !WITHIN(SERIAL_PORT_2, -1, 3)
-      #error "SERIAL_PORT_2 must be from -1 to 3. Please update your configuration."
+      #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. Please update your configuration."
+      #error "SERIAL_PORT_2 must be different than SERIAL_PORT"
     #endif
-    #define MYSERIAL1 customizedSerial2
     #define NUM_SERIAL 2
+    #define MYSERIAL1 customizedSerial2
   #else
     #define NUM_SERIAL 1
   #endif
 #endif
 
-#ifdef DGUS_SERIAL_PORT
-  #if !WITHIN(DGUS_SERIAL_PORT, -1, 3)
-    #error "DGUS_SERIAL_PORT must be from -1 to 3. Please update your configuration."
-  #elif DGUS_SERIAL_PORT == SERIAL_PORT
-    #error "DGUS_SERIAL_PORT must be different than SERIAL_PORT. Please update your configuration."
-  #elif defined(SERIAL_PORT_2) && DGUS_SERIAL_PORT == SERIAL_PORT_2
-    #error "DGUS_SERIAL_PORT must be different than SERIAL_PORT_2. Please update your configuration."
-  #endif
-  #define DGUS_SERIAL internalDgusSerial
-
-  #define DGUS_SERIAL_GET_TX_BUFFER_FREE DGUS_SERIAL.get_tx_buffer_free
-#endif
-
 // ------------------------
 // Public functions
 // ------------------------
 
-void HAL_init();
+void 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
 
@@ -167,7 +146,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
@@ -219,9 +199,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 */ \
@@ -288,13 +268,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 */ \
@@ -354,16 +334,16 @@ void TIMER0_COMPB_vect() { \
     : \
   ); \
 } \
-void TIMER0_COMPB_vect_bottom()
+void TIMER0_COMPB_vect_bottom(void)
 
 // ADC
 #ifdef DIDR2
-  #define HAL_ANALOG_SELECT(ind) do{ if (ind < 8) SBI(DIDR0, ind); else SBI(DIDR2, ind & 0x07); }while(0)
+  #define HAL_ANALOG_SELECT(pin) do{ if (pin < 8) SBI(DIDR0, pin); else SBI(DIDR2, pin & 0x07); }while(0)
 #else
-  #define HAL_ANALOG_SELECT(ind) SBI(DIDR0, ind);
+  #define HAL_ANALOG_SELECT(pin) do{ SBI(DIDR0, pin); }while(0)
 #endif
 
-inline void HAL_adc_init() {
+inline void HAL_adc_init(void) {
   ADCSRA = _BV(ADEN) | _BV(ADSC) | _BV(ADIF) | 0x07;
   DIDR0 = 0;
   #ifdef DIDR2
@@ -371,14 +351,13 @@ inline void HAL_adc_init() {
   #endif
 }
 
-#define SET_ADMUX_ADCSRA(ch) ADMUX = _BV(REFS0) | (ch & 0x07); SBI(ADCSRA, ADSC)
+#define SET_ADMUX_ADCSRA(pin) ADMUX = _BV(REFS0) | (pin & 0x07); SBI(ADCSRA, ADSC)
 #ifdef MUX5
-  #define HAL_START_ADC(ch) if (ch > 7) ADCSRB = _BV(MUX5); else ADCSRB = 0; SET_ADMUX_ADCSRA(ch)
+  #define HAL_START_ADC(pin) if (pin > 7) ADCSRB = _BV(MUX5); else ADCSRB = 0; SET_ADMUX_ADCSRA(pin)
 #else
-  #define HAL_START_ADC(ch) ADCSRB = 0; SET_ADMUX_ADCSRA(ch)
+  #define HAL_START_ADC(pin) ADCSRB = 0; SET_ADMUX_ADCSRA(pin)
 #endif
 
-#define HAL_ADC_RESOLUTION 10
 #define HAL_READ_ADC()  ADC
 #define HAL_ADC_READY() !TEST(ADCSRA, ADSC)
 
@@ -395,8 +374,6 @@ inline void HAL_adc_init() {
 // AVR compatibility
 #define strtof strtod
 
-#define HAL_CAN_SET_PWM_FREQ   // This HAL supports PWM Frequency adjustment
-
 /**
  *  set_pwm_frequency
  *  Sets the frequency of the timer corresponding to the provided pin

Marlin/src/HAL/HAL_AVR/HAL_SPI.cpp

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -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() {
@@ -197,7 +202,7 @@ void spiBegin() {
     // output pin high - like sending 0xFF
     WRITE(MOSI_PIN, HIGH);
 
-    LOOP_L_N(i, 8) {
+    for (uint8_t i = 0; i < 8; i++) {
       WRITE(SCK_PIN, HIGH);
 
       nop; // adjust so SCK is nice
@@ -224,7 +229,7 @@ void spiBegin() {
   void spiSend(uint8_t data) {
     // no interrupts during byte send - about 8µs
     cli();
-    LOOP_L_N(i, 8) {
+    for (uint8_t i = 0; i < 8; i++) {
       WRITE(SCK_PIN, LOW);
       WRITE(MOSI_PIN, data & 0x80);
       data <<= 1;

Marlin/src/HAL/HAL_AVR/MarlinSerial.cpp

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -41,7 +41,7 @@
 #if !defined(USBCON) && (defined(UBRRH) || defined(UBRR0H) || defined(UBRR1H) || defined(UBRR2H) || defined(UBRR3H))
 
   #include "MarlinSerial.h"
-  #include "../../MarlinCore.h"
+  #include "../../Marlin.h"
 
   template<typename Cfg> typename MarlinSerial<Cfg>::ring_buffer_r MarlinSerial<Cfg>::rx_buffer = { 0, 0, { 0 } };
   template<typename Cfg> typename MarlinSerial<Cfg>::ring_buffer_t MarlinSerial<Cfg>::tx_buffer = { 0 };
@@ -55,7 +55,7 @@
   // A SW memory barrier, to ensure GCC does not overoptimize loops
   #define sw_barrier() asm volatile("": : :"memory");
 
-  #include "../../feature/e_parser.h"
+  #include "../../feature/emergency_parser.h"
 
   // "Atomically" read the RX head index value without disabling interrupts:
   // This MUST be called with RX interrupts enabled, and CAN'T be called
@@ -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');
   }
@@ -682,7 +682,7 @@
 
     // Round correctly so that print(1.999, 2) prints as "2.00"
     double rounding = 0.5;
-    LOOP_L_N(i, digits) rounding *= 0.1;
+    for (uint8_t i = 0; i < digits; ++i) rounding *= 0.1;
     number += rounding;
 
     // Extract the integer part of the number and print it
@@ -757,33 +757,6 @@
 
 #endif
 
-#ifdef DGUS_SERIAL_PORT
-
-  template<typename Cfg>
-  typename MarlinSerial<Cfg>::ring_buffer_pos_t MarlinSerial<Cfg>::get_tx_buffer_free() {
-    const ring_buffer_pos_t t = tx_buffer.tail,  // next byte to send.
-                            h = tx_buffer.head;  // next pos for queue.
-    int ret = t - h - 1;
-    if (ret < 0) ret += Cfg::TX_SIZE + 1;
-    return ret;
-  }
-
-  ISR(SERIAL_REGNAME(USART,DGUS_SERIAL_PORT,_RX_vect)) {
-    MarlinSerial<MarlinInternalSerialCfg<DGUS_SERIAL_PORT>>::store_rxd_char();
-  }
-
-  ISR(SERIAL_REGNAME(USART,DGUS_SERIAL_PORT,_UDRE_vect)) {
-    MarlinSerial<MarlinInternalSerialCfg<DGUS_SERIAL_PORT>>::_tx_udr_empty_irq();
-  }
-
-  // Preinstantiate
-  template class MarlinSerial<MarlinInternalSerialCfg<DGUS_SERIAL_PORT>>;
-
-  // Instantiate
-  MarlinSerial<MarlinInternalSerialCfg<DGUS_SERIAL_PORT>> internalDgusSerial;
-
-#endif
-
 // For AT90USB targets use the UART for BT interfacing
 #if defined(USBCON) && ENABLED(BLUETOOTH)
   HardwareSerial bluetoothSerial;

Marlin/src/HAL/HAL_AVR/MarlinSerial.h

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -31,9 +31,9 @@
  * Templatized 01 October 2018 by Eduardo José Tagle to allow multiple instances
  */
 
-#include <WString.h>
+#include "../shared/MarlinSerial.h"
 
-#include "../../inc/MarlinConfigPre.h"
+#include <WString.h>
 
 #ifndef SERIAL_PORT
   #define SERIAL_PORT 0
@@ -205,21 +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();
-      #ifdef DGUS_SERIAL_PORT
-        static ring_buffer_pos_t get_tx_buffer_free();
-      #endif
+      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; }
@@ -248,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:
@@ -261,12 +258,12 @@
     static constexpr int PORT               = serial;
     static constexpr unsigned int RX_SIZE   = RX_BUFFER_SIZE;
     static constexpr unsigned int TX_SIZE   = TX_BUFFER_SIZE;
-    static constexpr bool XONOFF            = ENABLED(SERIAL_XON_XOFF);
-    static constexpr bool EMERGENCYPARSER   = ENABLED(EMERGENCY_PARSER);
-    static constexpr bool DROPPED_RX        = ENABLED(SERIAL_STATS_DROPPED_RX);
-    static constexpr bool RX_OVERRUNS       = ENABLED(SERIAL_STATS_RX_BUFFER_OVERRUNS);
-    static constexpr bool RX_FRAMING_ERRORS = ENABLED(SERIAL_STATS_RX_FRAMING_ERRORS);
-    static constexpr bool MAX_RX_QUEUED     = ENABLED(SERIAL_STATS_MAX_RX_QUEUED);
+    static constexpr bool XONOFF            = bSERIAL_XON_XOFF;
+    static constexpr bool EMERGENCYPARSER   = bEMERGENCY_PARSER;
+    static constexpr bool DROPPED_RX        = bSERIAL_STATS_DROPPED_RX;
+    static constexpr bool RX_OVERRUNS       = bSERIAL_STATS_RX_BUFFER_OVERRUNS;
+    static constexpr bool RX_FRAMING_ERRORS = bSERIAL_STATS_RX_FRAMING_ERRORS;
+    static constexpr bool MAX_RX_QUEUED     = bSERIAL_STATS_MAX_RX_QUEUED;
   };
   extern MarlinSerial<MarlinSerialCfg<SERIAL_PORT>> customizedSerial1;
 
@@ -295,23 +292,6 @@
   extern MarlinSerial<MarlinInternalSerialCfg<INTERNAL_SERIAL_PORT>> internalSerial;
 #endif
 
-#ifdef DGUS_SERIAL_PORT
-  template <uint8_t serial>
-  struct MarlinInternalSerialCfg {
-    static constexpr int PORT               = serial;
-    static constexpr unsigned int RX_SIZE   = 128;
-    static constexpr unsigned int TX_SIZE   = 48;
-    static constexpr bool XONOFF            = false;
-    static constexpr bool EMERGENCYPARSER   = false;
-    static constexpr bool DROPPED_RX        = false;
-    static constexpr bool RX_OVERRUNS       = HAS_DGUS_LCD && ENABLED(DGUS_SERIAL_STATS_RX_BUFFER_OVERRUNS);
-    static constexpr bool RX_FRAMING_ERRORS = false;
-    static constexpr bool MAX_RX_QUEUED     = false;
-  };
-
-  extern MarlinSerial<MarlinInternalSerialCfg<DGUS_SERIAL_PORT>> internalDgusSerial;
-#endif
-
 // Use the UART for Bluetooth in AT90USB configurations
 #if defined(USBCON) && ENABLED(BLUETOOTH)
   extern HardwareSerial bluetoothSerial;

Marlin/src/HAL/HAL_AVR/Servo.cpp

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -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

Marlin/src/HAL/HAL_AVR/ServoTimers.h

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm

Marlin/src/HAL/HAL_AVR/endstop_interrupts.h

@@ -0,0 +1,258 @@
+/**
+ * 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
+
+/**
+ * Endstop Interrupts
+ *
+ * Without endstop interrupts the endstop pins must be polled continually in
+ * the temperature-ISR via endstops.update(), most of the time finding no change.
+ * With this feature endstops.update() is called only when we know that at
+ * least one endstop has changed state, saving valuable CPU cycles.
+ *
+ * This feature only works when all used endstop pins can generate either an
+ * 'external interrupt' or a 'pin change interrupt'.
+ *
+ * Test whether pins issue interrupts on your board by flashing 'pin_interrupt_test.ino'.
+ * (Located in Marlin/buildroot/share/pin_interrupt_test/pin_interrupt_test.ino)
+ */
+
+#include "../../module/endstops.h"
+
+#include <stdint.h>
+
+// One ISR for all EXT-Interrupts
+void endstop_ISR(void) { endstops.update(); }
+
+/**
+ * Patch for pins_arduino.h (...\Arduino\hardware\arduino\avr\variants\mega\pins_arduino.h)
+ *
+ * These macros for the Arduino MEGA do not include the two connected pins on Port J (D13, D14).
+ * So we extend them here because these are the normal pins for Y_MIN and Y_MAX on RAMPS.
+ * There are more PCI-enabled processor pins on Port J, but they are not connected to Arduino MEGA.
+ */
+#if defined(ARDUINO_AVR_MEGA2560) || defined(ARDUINO_AVR_MEGA)
+  #undef  digitalPinToPCICR
+  #define digitalPinToPCICR(p)    ( WITHIN(p, 10, 15) || \
+                                    WITHIN(p, 50, 53) || \
+                                    WITHIN(p, 62, 69) ? &PCICR : nullptr )
+  #undef  digitalPinToPCICRbit
+  #define digitalPinToPCICRbit(p) ( WITHIN(p, 10, 13) || WITHIN(p, 50, 53) ? 0 : \
+                                    WITHIN(p, 14, 15) ? 1 : \
+                                    WITHIN(p, 62, 69) ? 2 : \
+                                    0 )
+  #undef  digitalPinToPCMSK
+  #define digitalPinToPCMSK(p)    ( WITHIN(p, 10, 13) || WITHIN(p, 50, 53) ? &PCMSK0 : \
+                                    WITHIN(p, 14, 15) ? &PCMSK1 : \
+                                    WITHIN(p, 62, 69) ? &PCMSK2 : \
+                                    nullptr )
+  #undef  digitalPinToPCMSKbit
+  #define digitalPinToPCMSKbit(p) ( WITHIN(p, 10, 13) ? ((p) - 6) : \
+                                    (p) == 14 || (p) == 51 ? 2 : \
+                                    (p) == 15 || (p) == 52 ? 1 : \
+                                    (p) == 50 ? 3 : \
+                                    (p) == 53 ? 0 : \
+                                    WITHIN(p, 62, 69) ? ((p) - 62) : \
+                                    0 )
+#endif
+
+
+// Install Pin change interrupt for a pin. Can be called multiple times.
+void pciSetup(const int8_t 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
+  }
+}
+
+// Handlers for pin change interrupts
+#ifdef PCINT0_vect
+  ISR(PCINT0_vect) { endstop_ISR(); }
+#endif
+
+#ifdef PCINT1_vect
+  ISR(PCINT1_vect, ISR_ALIASOF(PCINT0_vect));
+#endif
+
+#ifdef PCINT2_vect
+  ISR(PCINT2_vect, ISR_ALIASOF(PCINT0_vect));
+#endif
+
+#ifdef PCINT3_vect
+  ISR(PCINT3_vect, ISR_ALIASOF(PCINT0_vect));
+#endif
+
+void setup_endstop_interrupts( void ) {
+
+  #if HAS_X_MAX
+    #if (digitalPinToInterrupt(X_MAX_PIN) != NOT_AN_INTERRUPT) // if pin has an external interrupt
+      attachInterrupt(digitalPinToInterrupt(X_MAX_PIN), endstop_ISR, CHANGE); // assign it
+    #else
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(X_MAX_PIN), "X_MAX_PIN is not interrupt-capable"); // if pin has no pin change interrupt - error
+      pciSetup(X_MAX_PIN);                                                            // assign it
+    #endif
+  #endif
+
+  #if HAS_X_MIN
+    #if (digitalPinToInterrupt(X_MIN_PIN) != NOT_AN_INTERRUPT)
+      attachInterrupt(digitalPinToInterrupt(X_MIN_PIN), endstop_ISR, CHANGE);
+    #else
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(X_MIN_PIN), "X_MIN_PIN is not interrupt-capable");
+      pciSetup(X_MIN_PIN);
+    #endif
+  #endif
+
+  #if HAS_Y_MAX
+    #if (digitalPinToInterrupt(Y_MAX_PIN) != NOT_AN_INTERRUPT)
+      attachInterrupt(digitalPinToInterrupt(Y_MAX_PIN), endstop_ISR, CHANGE);
+    #else
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Y_MAX_PIN), "Y_MAX_PIN is not interrupt-capable");
+      pciSetup(Y_MAX_PIN);
+    #endif
+  #endif
+
+  #if HAS_Y_MIN
+    #if (digitalPinToInterrupt(Y_MIN_PIN) != NOT_AN_INTERRUPT)
+      attachInterrupt(digitalPinToInterrupt(Y_MIN_PIN), endstop_ISR, CHANGE);
+    #else
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Y_MIN_PIN), "Y_MIN_PIN is not interrupt-capable");
+      pciSetup(Y_MIN_PIN);
+    #endif
+  #endif
+
+  #if HAS_Z_MAX
+    #if (digitalPinToInterrupt(Z_MAX_PIN) != NOT_AN_INTERRUPT)
+      attachInterrupt(digitalPinToInterrupt(Z_MAX_PIN), endstop_ISR, CHANGE);
+    #else
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Z_MAX_PIN), "Z_MAX_PIN is not interrupt-capable");
+      pciSetup(Z_MAX_PIN);
+    #endif
+  #endif
+
+  #if HAS_Z_MIN
+    #if (digitalPinToInterrupt(Z_MIN_PIN) != NOT_AN_INTERRUPT)
+      attachInterrupt(digitalPinToInterrupt(Z_MIN_PIN), endstop_ISR, CHANGE);
+    #else
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Z_MIN_PIN), "Z_MIN_PIN is not interrupt-capable");
+      pciSetup(Z_MIN_PIN);
+    #endif
+  #endif
+
+  #if HAS_X2_MAX
+    #if (digitalPinToInterrupt(X2_MAX_PIN) != NOT_AN_INTERRUPT)
+      attachInterrupt(digitalPinToInterrupt(X2_MAX_PIN), endstop_ISR, CHANGE);
+    #else
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(X2_MAX_PIN), "X2_MAX_PIN is not interrupt-capable");
+      pciSetup(X2_MAX_PIN);
+    #endif
+  #endif
+
+  #if HAS_X2_MIN
+    #if (digitalPinToInterrupt(X2_MIN_PIN) != NOT_AN_INTERRUPT)
+      attachInterrupt(digitalPinToInterrupt(X2_MIN_PIN), endstop_ISR, CHANGE);
+    #else
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(X2_MIN_PIN), "X2_MIN_PIN is not interrupt-capable");
+      pciSetup(X2_MIN_PIN);
+    #endif
+  #endif
+
+  #if HAS_Y2_MAX
+    #if (digitalPinToInterrupt(Y2_MAX_PIN) != NOT_AN_INTERRUPT)
+      attachInterrupt(digitalPinToInterrupt(Y2_MAX_PIN), endstop_ISR, CHANGE);
+    #else
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Y2_MAX_PIN), "Y2_MAX_PIN is not interrupt-capable");
+      pciSetup(Y2_MAX_PIN);
+    #endif
+  #endif
+
+  #if HAS_Y2_MIN
+    #if (digitalPinToInterrupt(Y2_MIN_PIN) != NOT_AN_INTERRUPT)
+      attachInterrupt(digitalPinToInterrupt(Y2_MIN_PIN), endstop_ISR, CHANGE);
+    #else
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Y2_MIN_PIN), "Y2_MIN_PIN is not interrupt-capable");
+      pciSetup(Y2_MIN_PIN);
+    #endif
+  #endif
+
+  #if HAS_Z2_MAX
+    #if (digitalPinToInterrupt(Z2_MAX_PIN) != NOT_AN_INTERRUPT)
+      attachInterrupt(digitalPinToInterrupt(Z2_MAX_PIN), endstop_ISR, CHANGE);
+    #else
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Z2_MAX_PIN), "Z2_MAX_PIN is not interrupt-capable");
+      pciSetup(Z2_MAX_PIN);
+    #endif
+  #endif
+
+  #if HAS_Z2_MIN
+    #if (digitalPinToInterrupt(Z2_MIN_PIN) != NOT_AN_INTERRUPT)
+      attachInterrupt(digitalPinToInterrupt(Z2_MIN_PIN), endstop_ISR, CHANGE);
+    #else
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Z2_MIN_PIN), "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)
+      attachInterrupt(digitalPinToInterrupt(Z3_MAX_PIN), endstop_ISR, CHANGE);
+    #else
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(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)
+      attachInterrupt(digitalPinToInterrupt(Z3_MIN_PIN), endstop_ISR, CHANGE);
+    #else
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(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)
+      attachInterrupt(digitalPinToInterrupt(Z_MIN_PROBE_PIN), endstop_ISR, CHANGE);
+    #else
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Z_MIN_PROBE_PIN), "Z_MIN_PROBE_PIN is not interrupt-capable");
+      pciSetup(Z_MIN_PROBE_PIN);
+    #endif
+  #endif
+
+  // If we arrive here without raising an assertion, each pin has either an EXT-interrupt or a PCI.
+}

Marlin/src/HAL/HAL_AVR/fast_pwm.cpp

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -23,7 +23,7 @@
 
 #include "../../inc/MarlinConfigPre.h"
 
-#if NEEDS_HARDWARE_PWM // Specific meta-flag for features that mandate PWM
+#if ENABLED(FAST_PWM_FAN)
 
 #include "HAL.h"
 
@@ -59,8 +59,8 @@ 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
           };
@@ -70,8 +70,8 @@ Timer get_pwm_timer(const pin_t pin) {
           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
   };
@@ -167,7 +156,7 @@ void set_pwm_frequency(const pin_t pin, int f_desired) {
     uint16_t prescaler[] = { 0, 1, 8, /*TIMER2 ONLY*/32, 64, /*TIMER2 ONLY*/128, 256, 1024 };
 
     // loop over prescaler values
-    LOOP_S_L_N(i, 1, 8) {
+    for (uint8_t i = 1; i < 8; i++) {
       uint16_t res_temp_fast = 255, res_temp_phase_correct = 255;
       if (timer.n == 2) {
         // No resolution calculation for TIMER2 unless enabled USE_OCR2A_AS_TOP
@@ -278,5 +267,5 @@ void set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size/*=255
   }
 }
 
-#endif // NEEDS_HARDWARE_PWM
+#endif // FAST_PWM_FAN
 #endif // __AVR__

Marlin/src/HAL/HAL_AVR/fastio.cpp

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm

Marlin/src/HAL/HAL_AVR/fastio.h

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -98,9 +98,9 @@
 
 #define SET_INPUT(IO)         _SET_INPUT(IO)
 #define SET_INPUT_PULLUP(IO)  do{ _SET_INPUT(IO); _WRITE(IO, HIGH); }while(0)
-#define SET_INPUT_PULLDOWN    SET_INPUT
 #define SET_OUTPUT(IO)        _SET_OUTPUT(IO)
-#define SET_PWM               SET_OUTPUT
+
+#define SET_PWM(IO)           SET_OUTPUT(IO)
 
 #define IS_INPUT(IO)          _IS_INPUT(IO)
 #define IS_OUTPUT(IO)         _IS_OUTPUT(IO)
@@ -279,25 +279,14 @@ enum ClockSource2 : char {
  */
 
 // Determine which harware PWMs are already in use
-#define _PWM_CHK_FAN_B(P) (P == E0_AUTO_FAN_PIN || P == E1_AUTO_FAN_PIN || P == E2_AUTO_FAN_PIN || P == E3_AUTO_FAN_PIN || P == E4_AUTO_FAN_PIN || P == E5_AUTO_FAN_PIN || P == E6_AUTO_FAN_PIN || P == E7_AUTO_FAN_PIN || P == CHAMBER_AUTO_FAN_PIN)
 #if PIN_EXISTS(CONTROLLER_FAN)
-  #define PWM_CHK_FAN_B(P) (_PWM_CHK_FAN_B(P) || P == CONTROLLER_FAN_PIN)
+  #define PWM_CHK_FAN_B(P) (P == CONTROLLER_FAN_PIN || P == E0_AUTO_FAN_PIN || P == E1_AUTO_FAN_PIN || P == E2_AUTO_FAN_PIN || P == E3_AUTO_FAN_PIN || P == E4_AUTO_FAN_PIN || P == E5_AUTO_FAN_PIN || P == CHAMBER_AUTO_FAN_PIN)
 #else
-  #define PWM_CHK_FAN_B(P) _PWM_CHK_FAN_B(P)
+  #define PWM_CHK_FAN_B(P) (P == E0_AUTO_FAN_PIN || P == E1_AUTO_FAN_PIN || P == E2_AUTO_FAN_PIN || P == E3_AUTO_FAN_PIN || P == E4_AUTO_FAN_PIN || P == E5_AUTO_FAN_PIN || P == CHAMBER_AUTO_FAN_PIN)
 #endif
 
-#if ANY_PIN(FAN, FAN1, FAN2, FAN3, FAN4, FAN5, FAN6, FAN7)
-  #if PIN_EXISTS(FAN7)
-    #define PWM_CHK_FAN_A(P) (P == FAN0_PIN || P == FAN1_PIN || P == FAN2_PIN || P == FAN3_PIN || P == FAN4_PIN || P == FAN5_PIN || P == FAN6_PIN || P == FAN7_PIN)
-  #elif PIN_EXISTS(FAN6)
-    #define PWM_CHK_FAN_A(P) (P == FAN0_PIN || P == FAN1_PIN || P == FAN2_PIN || P == FAN3_PIN || P == FAN4_PIN || P == FAN5_PIN || P == FAN6_PIN)
-  #elif PIN_EXISTS(FAN5)
-    #define PWM_CHK_FAN_A(P) (P == FAN0_PIN || P == FAN1_PIN || P == FAN2_PIN || P == FAN3_PIN || P == FAN4_PIN || P == FAN5_PIN)
-  #elif PIN_EXISTS(FAN4)
-    #define PWM_CHK_FAN_A(P) (P == FAN0_PIN || P == FAN1_PIN || P == FAN2_PIN || P == FAN3_PIN || P == FAN4_PIN)
-  #elif PIN_EXISTS(FAN3)
-    #define PWM_CHK_FAN_A(P) (P == FAN0_PIN || P == FAN1_PIN || P == FAN2_PIN || P == FAN3_PIN)
-  #elif PIN_EXISTS(FAN2)
+#if ANY_PIN(FAN, FAN1, FAN2)
+  #if PIN_EXISTS(FAN2)
     #define PWM_CHK_FAN_A(P) (P == FAN0_PIN || P == FAN1_PIN || P == FAN2_PIN)
   #elif PIN_EXISTS(FAN1)
     #define PWM_CHK_FAN_A(P) (P == FAN0_PIN || P == FAN1_PIN)

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

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -26,7 +26,7 @@
  *
  *   Hardware Pin  : 02 03 06 07 01 05 15 16 17 18 23 24 25 26 64 63 13 12 46 45 44 43 78 77 76 75 74 73 72 71 60 59 58 57 56 55 54 53 50 70 52 51 42 41 40 39 38 37 36 35 22 21 20 19 97 96 95 94 93 92 91 90 89 88 87 86 85 84 83 82 | 04 08 09 10 11 14 27 28 29 30 31 32 33 34 47 48 49 61 62 65 66 67 68 69 79 80 81 98 99 100
  *   Port          : E0 E1 E4 E5 G5 E3 H3 H4 H5 H6 B4 B5 B6 B7 J1 J0 H1 H0 D3 D2 D1 D0 A0 A1 A2 A3 A4 A5 A6 A7 C7 C6 C5 C4 C3 C2 C1 C0 D7 G2 G1 G0 L7 L6 L5 L4 L3 L2 L1 L0 B3 B2 B1 B0 F0 F1 F2 F3 F4 F5 F6 F7 K0 K1 K2 K3 K4 K5 K6 K7 | E2 E6 E7 xx xx H2 H7 G3 G4 xx xx xx xx xx D4 D5 D6 xx xx J2 J3 J4 J5 J6 J7 xx xx xx xx xx
- *   Logical Pin   : 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 | 78 79 80 xx xx 84 85 71 70 xx xx xx xx xx 81 82 83 xx xx 72 73 75 76 77 74 xx xx xx xx xx
+ *   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"

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

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm

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

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm

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

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm

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

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm

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

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm

Marlin/src/HAL/HAL_AVR/inc/Conditionals_adv.h

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm

Marlin/src/HAL/HAL_AVR/inc/Conditionals_post.h

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm

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

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -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
 
 /**
@@ -56,10 +56,6 @@
 /**
  * The Trinamic library includes SoftwareSerial.h, leading to a compile error.
  */
-#if HAS_TRINAMIC_CONFIG && ENABLED(ENDSTOP_INTERRUPTS_FEATURE)
+#if HAS_TRINAMIC && ENABLED(ENDSTOP_INTERRUPTS_FEATURE)
   #error "TMCStepper includes SoftwareSerial.h which is incompatible with ENDSTOP_INTERRUPTS_FEATURE. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
 #endif
-
-#if HAS_TMC_SW_SERIAL && ENABLED(MONITOR_DRIVER_STATUS)
-  #error "MONITOR_DRIVER_STATUS causes performance issues when used with SoftwareSerial-connected drivers. Disable MONITOR_DRIVER_STATUS or use hardware serial to continue."
-#endif

Marlin/src/HAL/HAL_AVR/math.h

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm

Marlin/src/HAL/HAL_AVR/persistent_store_eeprom.cpp

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -25,7 +25,7 @@
 
 #if EITHER(EEPROM_SETTINGS, SD_FIRMWARE_UPDATE)
 
-#include "../shared/eeprom_api.h"
+#include "../shared/persistent_store_api.h"
 
 bool PersistentStore::access_start() { return true; }
 bool PersistentStore::access_finish() { return true; }
@@ -39,7 +39,7 @@ bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, ui
     if (v != eeprom_read_byte(p)) {
       eeprom_write_byte(p, v);
       if (eeprom_read_byte(p) != v) {
-        SERIAL_ECHO_MSG(STR_ERR_EEPROM_WRITE);
+        SERIAL_ECHO_MSG(MSG_ERR_EEPROM_WRITE);
         return true;
       }
     }

Marlin/src/HAL/HAL_AVR/pinsDebug.h

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -26,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)
@@ -70,12 +63,12 @@
 
 void PRINT_ARRAY_NAME(uint8_t x) {
   char *name_mem_pointer = (char*)pgm_read_ptr(&pin_array[x].name);
-  LOOP_L_N(y, MAX_NAME_LENGTH) {
+  for (uint8_t y = 0; y < MAX_NAME_LENGTH; y++) {
     char temp_char = pgm_read_byte(name_mem_pointer + y);
     if (temp_char != 0)
       SERIAL_CHAR(temp_char);
     else {
-      LOOP_L_N(i, MAX_NAME_LENGTH - y) SERIAL_CHAR(' ');
+      for (uint8_t i = 0; i < MAX_NAME_LENGTH - y; i++) SERIAL_CHAR(' ');
       break;
     }
   }
@@ -231,11 +224,21 @@ static void err_is_interrupt()   { SERIAL_ECHOPGM("   compare interrupt enabled"
 static void err_prob_interrupt() { SERIAL_ECHOPGM("   overflow interrupt enabled"); }
 static void print_is_also_tied() { SERIAL_ECHOPGM(" is also tied to this pin"); SERIAL_ECHO_SP(14); }
 
-inline void com_print(const uint8_t N, const uint8_t Z) {
+void com_print(uint8_t N, uint8_t Z) {
   const uint8_t *TCCRA = (uint8_t*)TCCR_A(N);
   SERIAL_ECHOPGM("    COM");
-  SERIAL_CHAR('0' + N, Z);
-  SERIAL_ECHOPAIR(": ", int((*TCCRA >> (6 - Z * 2)) & 0x03));
+  SERIAL_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
@@ -246,7 +249,8 @@ void timer_prefix(uint8_t T, char L, uint8_t N) {  // T - timer    L - pwm  N -
   if (N == 4) WGM |= ((*TCCRB & _BV(WGM_3)) >> 1);
 
   SERIAL_ECHOPGM("    TIMER");
-  SERIAL_CHAR(T + '0', L);
+  SERIAL_CHAR(T + '0');
+  SERIAL_CHAR(L);
   SERIAL_ECHO_SP(3);
 
   if (N == 3) {

Marlin/src/HAL/HAL_AVR/pinsDebug_Teensyduino.h

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * 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

Marlin/src/HAL/HAL_AVR/pinsDebug_plus_70.h

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * 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

Marlin/src/HAL/HAL_AVR/spi_pins.h

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm

Marlin/src/HAL/HAL_AVR/u8g_com_HAL_AVR_sw_spi.cpp

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -88,7 +88,7 @@ void u8g_spiSend_sw_AVR_mode_0(uint8_t val) {
   volatile uint8_t *outData = u8g_outData,
                    *outClock = u8g_outClock;
   U8G_ATOMIC_START();
-  LOOP_L_N(i, 8) {
+  for (uint8_t i = 0; i < 8; i++) {
     if (val & 0x80)
       *outData |= bitData;
     else
@@ -108,7 +108,7 @@ void u8g_spiSend_sw_AVR_mode_3(uint8_t val) {
   volatile uint8_t *outData = u8g_outData,
                    *outClock = u8g_outClock;
   U8G_ATOMIC_START();
-  LOOP_L_N(i, 8) {
+  for (uint8_t i = 0; i < 8; i++) {
     *outClock &= bitNotClock;
     if (val & 0x80)
       *outData |= bitData;

Marlin/src/HAL/HAL_AVR/watchdog.cpp

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -28,7 +28,7 @@
 
 #include "watchdog.h"
 
-#include "../../MarlinCore.h"
+#include "../../Marlin.h"
 
 // Initialize watchdog with 8s timeout, if possible. Otherwise, make it 4s.
 void watchdog_init() {
@@ -62,7 +62,7 @@ void watchdog_init() {
 #if ENABLED(WATCHDOG_RESET_MANUAL)
   ISR(WDT_vect) {
     sei();  // With the interrupt driven serial we need to allow interrupts.
-    SERIAL_ERROR_MSG(STR_WATCHDOG_FIRED);
+    SERIAL_ERROR_MSG(MSG_WATCHDOG_FIRED);
     minkill();  // interrupt-safe final kill and infinite loop
   }
 #endif

Marlin/src/HAL/HAL_AVR/watchdog.h

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -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(); }

Marlin/src/HAL/HAL_DUE/DebugMonitor.cpp

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -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")

Marlin/src/HAL/HAL_DUE/EepromEmulation.cpp

@@ -1,24 +1,3 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
 
 /* EEPROM emulation over flash with reduced wear
  *
@@ -54,10 +33,10 @@
 
 #include "../../inc/MarlinConfig.h"
 
-#if ENABLED(FLASH_EEPROM_EMULATION)
+#if ENABLED(EEPROM_SETTINGS) && NONE(I2C_EEPROM, SPI_EEPROM)
 
 #include "../shared/Marduino.h"
-#include "../shared/eeprom_api.h"
+#include "../shared/persistent_store_api.h"
 
 #define EEPROMSize     4096
 #define PagesPerGroup   128
@@ -943,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);
@@ -964,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
 
@@ -973,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
@@ -1012,9 +993,9 @@ void eeprom_read_block(void* __dst, const void* __src, size_t __n) {
   }
 }
 
-void eeprom_flush() {
+void eeprom_flush(void) {
   ee_Flush();
 }
 
-#endif // FLASH_EEPROM_EMULATION
+#endif // EEPROM_SETTINGS && (!I2C_EEPROM && !SPI_EEPROM)
 #endif // ARDUINO_ARCH_AVR

Marlin/src/HAL/HAL_DUE/HAL.cpp

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  * Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
  *
  * This program is free software: you can redistribute it and/or modify
@@ -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,18 +87,18 @@ 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);
 }
 
 // ------------------------
 // ADC
 // ------------------------
 
-void HAL_adc_start_conversion(const uint8_t ch) {
-  HAL_adc_result = analogRead(ch);
+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;
 }

Marlin/src/HAL/HAL_DUE/HAL.h

@@ -1,7 +1,7 @@
 /**
  * Marlin 3D Printer Firmware
  *
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  * Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
  * Copyright (c) 2015-2016 Nico Tonnhofer wurstnase.reprap@gmail.com
  *
@@ -38,62 +38,26 @@
 
 #include <stdint.h>
 
-// Define MYSERIAL0/1 before MarlinSerial includes!
-#if SERIAL_PORT == -1 || ENABLED(EMERGENCY_PARSER)
-  #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."
-  #elif SERIAL_PORT_2 == -1 || ENABLED(EMERGENCY_PARSER)
-    #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
 
-#ifdef DGUS_SERIAL_PORT
-  #if DGUS_SERIAL_PORT == SERIAL_PORT
-    #error "DGUS_SERIAL_PORT must be different from SERIAL_PORT. Please update your configuration."
-  #elif defined(SERIAL_PORT_2) && DGUS_SERIAL_PORT == SERIAL_PORT_2
-    #error "DGUS_SERIAL_PORT must be different than SERIAL_PORT_2. Please update your configuration."
-  #elif DGUS_SERIAL_PORT == -1
-    #define DGUS_SERIAL internalDgusSerial
-  #elif DGUS_SERIAL_PORT == 0
-    #define DGUS_SERIAL Serial
-  #elif DGUS_SERIAL_PORT == 1
-    #define DGUS_SERIAL Serial1
-  #elif DGUS_SERIAL_PORT == 2
-    #define DGUS_SERIAL Serial2
-  #elif DGUS_SERIAL_PORT == 3
-    #define DGUS_SERIAL Serial3
-  #else
-    #error "DGUS_SERIAL_PORT must be from -1 to 3. Please update your configuration."
-  #endif
-#endif
-
 #include "MarlinSerial.h"
 #include "MarlinSerialUSB.h"
 
@@ -118,17 +82,17 @@ typedef int8_t pin_t;
 //
 // Interrupts
 //
-#define CRITICAL_SECTION_START()  uint32_t primask = __get_PRIMASK(); __disable_irq()
-#define CRITICAL_SECTION_END()    if (!primask) __enable_irq()
+#define CRITICAL_SECTION_START  uint32_t primask = __get_PRIMASK(); __disable_irq()
+#define CRITICAL_SECTION_END    if (!primask) __enable_irq()
 #define ISRS_ENABLED() (!__get_PRIMASK())
 #define ENABLE_ISRS()  __enable_irq()
 #define DISABLE_ISRS() __disable_irq()
 
-void cli();                     // Disable interrupts
-void sei();                     // Enable interrupts
+void 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
 
 //
 // EEPROM
@@ -147,17 +111,16 @@ extern uint16_t HAL_adc_result;     // result of last ADC conversion
   #define analogInputToDigitalPin(p) ((p < 12u) ? (p) + 54u : -1)
 #endif
 
-#define HAL_ANALOG_SELECT(ch)
+#define HAL_ANALOG_SELECT(pin)
 
-inline void HAL_adc_init() {}//todo
+inline void HAL_adc_init(void) {}//todo
 
-#define HAL_START_ADC(ch)   HAL_adc_start_conversion(ch)
-#define HAL_ADC_RESOLUTION  10
+#define HAL_START_ADC(pin)  HAL_adc_start_conversion(pin)
 #define HAL_READ_ADC()      HAL_adc_result
 #define HAL_ADC_READY()     true
 
-void HAL_adc_start_conversion(const uint8_t ch);
-uint16_t HAL_adc_get_result();
+void HAL_adc_start_conversion(const uint8_t adc_pin);
+uint16_t HAL_adc_get_result(void);
 
 //
 // Pin Map
@@ -175,8 +138,8 @@ 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
@@ -185,7 +148,7 @@ void _delay_ms(const int delay);
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wunused-function"
-int freeMemory();
+int freeMemory(void);
 #pragma GCC diagnostic pop
 
 #ifdef __cplusplus

Marlin/src/HAL/HAL_DUE/HAL_SPI.cpp

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -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__(
@@ -240,7 +241,7 @@
   }
 
   // all the others
-  static uint32_t spiDelayCyclesX4 = (F_CPU) / 1000000; // 4µs => 125khz
+  static uint32_t spiDelayCyclesX4 = (F_CPU) / 1000000; // 4uS => 125khz
 
   static uint8_t spiTransferX(uint8_t b) { // using Mode 0
     int bits = 8;
@@ -427,7 +428,7 @@
 
   static void spiTxBlockX(const uint8_t* buf, uint32_t todo) {
     do {
-      (void)spiTransferTx(*buf++);
+      (void) spiTransferTx(*buf++);
     } while (--todo);
   }
 

Marlin/src/HAL/HAL_DUE/InterruptVectors.cpp

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -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;
 
@@ -63,13 +63,13 @@ static pfnISR_Handler* get_relocated_table_addr() {
   memcpy(&ram_tab, romtab, sizeof(ram_tab));
 
   // Disable global interrupts
-  CRITICAL_SECTION_START();
+  CRITICAL_SECTION_START;
 
   // Set the vector table base address to the SRAM copy
   SCB->VTOR = (uint32_t)(&ram_tab);
 
   // Reenable interrupts
-  CRITICAL_SECTION_END();
+  CRITICAL_SECTION_END;
 
   // Return the address of the table
   return (pfnISR_Handler*)(&ram_tab);
@@ -80,7 +80,7 @@ pfnISR_Handler install_isr(IRQn_Type irq, pfnISR_Handler newHandler) {
   pfnISR_Handler *isrtab = get_relocated_table_addr();
 
   // Disable global interrupts
-  CRITICAL_SECTION_START();
+  CRITICAL_SECTION_START;
 
   // Get the original handler
   pfnISR_Handler oldHandler = isrtab[irq + 16];
@@ -89,7 +89,7 @@ pfnISR_Handler install_isr(IRQn_Type irq, pfnISR_Handler newHandler) {
   isrtab[irq + 16] = newHandler;
 
   // Reenable interrupts
-  CRITICAL_SECTION_END();
+  CRITICAL_SECTION_END;
 
   // Return the original one
   return oldHandler;

Marlin/src/HAL/HAL_DUE/InterruptVectors.h

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -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);

Marlin/src/HAL/HAL_DUE/MarlinSerial.cpp

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -31,7 +31,7 @@
 
 #include "MarlinSerial.h"
 #include "InterruptVectors.h"
-#include "../../MarlinCore.h"
+#include "../../Marlin.h"
 
 template<typename Cfg> typename MarlinSerial<Cfg>::ring_buffer_r MarlinSerial<Cfg>::rx_buffer = { 0, 0, { 0 } };
 template<typename Cfg> typename MarlinSerial<Cfg>::ring_buffer_t MarlinSerial<Cfg>::tx_buffer = { 0 };
@@ -45,7 +45,7 @@ template<typename Cfg> typename MarlinSerial<Cfg>::ring_buffer_pos_t MarlinSeria
 // A SW memory barrier, to ensure GCC does not overoptimize loops
 #define sw_barrier() asm volatile("": : :"memory");
 
-#include "../../feature/e_parser.h"
+#include "../../feature/emergency_parser.h"
 
 // (called with RX interrupts disabled)
 template<typename Cfg>
@@ -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');
 }
@@ -606,7 +606,7 @@ void MarlinSerial<Cfg>::printFloat(double number, uint8_t digits) {
 
   // Round correctly so that print(1.999, 2) prints as "2.00"
   double rounding = 0.5;
-  LOOP_L_N(i, digits) rounding *= 0.1;
+  for (uint8_t i = 0; i < digits; ++i) rounding *= 0.1;
   number += rounding;
 
   // Extract the integer part of the number and print it
@@ -629,13 +629,23 @@ void MarlinSerial<Cfg>::printFloat(double number, uint8_t digits) {
 
 // If not using the USB port as serial port
 #if SERIAL_PORT >= 0
-  template class MarlinSerial<MarlinSerialCfg<SERIAL_PORT>>;      // Define
-  MarlinSerial<MarlinSerialCfg<SERIAL_PORT>> customizedSerial1;   // Instantiate
+
+  // Preinstantiate
+  template class MarlinSerial<MarlinSerialCfg<SERIAL_PORT>>;
+
+  // Instantiate
+  MarlinSerial<MarlinSerialCfg<SERIAL_PORT>> customizedSerial1;
+
 #endif
 
-#if defined(SERIAL_PORT_2) && SERIAL_PORT_2 >= 0
-  template class MarlinSerial<MarlinSerialCfg<SERIAL_PORT_2>>;    // Define
-  MarlinSerial<MarlinSerialCfg<SERIAL_PORT_2>> customizedSerial2; // Instantiate
+#ifdef SERIAL_PORT_2
+
+  // Preinstantiate
+  template class MarlinSerial<MarlinSerialCfg<SERIAL_PORT_2>>;
+
+  // Instantiate
+  MarlinSerial<MarlinSerialCfg<SERIAL_PORT_2>> customizedSerial2;
+
 #endif
 
 #endif // ARDUINO_ARCH_SAM

Marlin/src/HAL/HAL_DUE/MarlinSerial.h

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -27,9 +27,9 @@
  * Based on MarlinSerial for AVR, copyright (c) 2006 Nicholas Zambetti.  All right reserved.
  */
 
-#include <WString.h>
+#include "../shared/MarlinSerial.h"
 
-#include "../../inc/MarlinConfigPre.h"
+#include <WString.h>
 
 #define DEC 10
 #define HEX 16
@@ -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:
@@ -163,18 +163,22 @@ struct MarlinSerialCfg {
   static constexpr int PORT               = serial;
   static constexpr unsigned int RX_SIZE   = RX_BUFFER_SIZE;
   static constexpr unsigned int TX_SIZE   = TX_BUFFER_SIZE;
-  static constexpr bool XONOFF            = ENABLED(SERIAL_XON_XOFF);
-  static constexpr bool EMERGENCYPARSER   = ENABLED(EMERGENCY_PARSER);
-  static constexpr bool DROPPED_RX        = ENABLED(SERIAL_STATS_DROPPED_RX);
-  static constexpr bool RX_OVERRUNS       = ENABLED(SERIAL_STATS_RX_BUFFER_OVERRUNS);
-  static constexpr bool RX_FRAMING_ERRORS = ENABLED(SERIAL_STATS_RX_FRAMING_ERRORS);
-  static constexpr bool MAX_RX_QUEUED     = ENABLED(SERIAL_STATS_MAX_RX_QUEUED);
+  static constexpr bool XONOFF            = bSERIAL_XON_XOFF;
+  static constexpr bool EMERGENCYPARSER   = bEMERGENCY_PARSER;
+  static constexpr bool DROPPED_RX        = bSERIAL_STATS_DROPPED_RX;
+  static constexpr bool RX_OVERRUNS       = bSERIAL_STATS_RX_BUFFER_OVERRUNS;
+  static constexpr bool RX_FRAMING_ERRORS = bSERIAL_STATS_RX_FRAMING_ERRORS;
+  static constexpr bool MAX_RX_QUEUED     = bSERIAL_STATS_MAX_RX_QUEUED;
 };
 
 #if SERIAL_PORT >= 0
-  extern MarlinSerial<MarlinSerialCfg<SERIAL_PORT>> customizedSerial1;
-#endif
 
-#if defined(SERIAL_PORT_2) && SERIAL_PORT_2 >= 0
+  extern MarlinSerial<MarlinSerialCfg<SERIAL_PORT>> customizedSerial1;
+
+#endif // SERIAL_PORT >= 0
+
+#ifdef SERIAL_PORT_2
+
   extern MarlinSerial<MarlinSerialCfg<SERIAL_PORT_2>> customizedSerial2;
+
 #endif

Marlin/src/HAL/HAL_DUE/MarlinSerialUSB.cpp

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -29,21 +29,21 @@
 
 #include "../../inc/MarlinConfig.h"
 
-#if HAS_USB_SERIAL
+#if SERIAL_PORT == -1
 
 #include "MarlinSerialUSB.h"
 
 #if ENABLED(EMERGENCY_PARSER)
-  #include "../../feature/e_parser.h"
+  #include "../../feature/emergency_parser.h"
 #endif
 
 // Imports from Atmel USB Stack/CDC implementation
 extern "C" {
-  bool usb_task_cdc_isenabled();
-  bool usb_task_cdc_dtr_active();
-  bool udi_cdc_is_rx_ready();
-  int udi_cdc_getc();
-  bool udi_cdc_is_tx_ready();
+  bool usb_task_cdc_isenabled(void);
+  bool usb_task_cdc_dtr_active(void);
+  bool udi_cdc_is_rx_ready(void);
+  int udi_cdc_getc(void);
+  bool udi_cdc_is_tx_ready(void);
   int udi_cdc_putc(int value);
 };
 
@@ -55,11 +55,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');
 }
@@ -259,7 +262,7 @@ void MarlinSerialUSB::printFloat(double number, uint8_t digits) {
 
   // Round correctly so that print(1.999, 2) prints as "2.00"
   double rounding = 0.5;
-  LOOP_L_N(i, digits)
+  for (uint8_t i = 0; i < digits; ++i)
     rounding *= 0.1;
 
   number += rounding;
@@ -283,12 +286,8 @@ void MarlinSerialUSB::printFloat(double number, uint8_t digits) {
 }
 
 // Preinstantiate
-#if SERIAL_PORT == -1
-  MarlinSerialUSB customizedSerial1;
-#endif
-#if SERIAL_PORT_2 == -1
-  MarlinSerialUSB customizedSerial2;
-#endif
+MarlinSerialUSB customizedSerial1;
+
+#endif // SERIAL_PORT == -1
 
-#endif // HAS_USB_SERIAL
 #endif // ARDUINO_ARCH_SAM

Marlin/src/HAL/HAL_DUE/MarlinSerialUSB.h

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -28,7 +28,7 @@
 
 #include "../../inc/MarlinConfig.h"
 
-#if HAS_USB_SERIAL
+#if SERIAL_PORT == -1
 
 #include <WString.h>
 
@@ -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:
@@ -88,12 +88,6 @@ private:
   static void printFloat(double, uint8_t);
 };
 
-#if SERIAL_PORT == -1
-  extern MarlinSerialUSB customizedSerial1;
-#endif
+extern MarlinSerialUSB customizedSerial1;
 
-#if SERIAL_PORT_2 == -1
-  extern MarlinSerialUSB customizedSerial2;
-#endif
-
-#endif // HAS_USB_SERIAL
+#endif // SERIAL_PORT == -1

Marlin/src/HAL/HAL_DUE/Servo.cpp

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -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) {

Marlin/src/HAL/HAL_DUE/Tone.cpp

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm

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

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -63,7 +63,7 @@
 
 #include <U8glib.h>
 
-#include "../../../MarlinCore.h"
+#include "../../../Marlin.h"
 
 void spiBegin();
 void spiInit(uint8_t spiRate);

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

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm

Marlin/src/HAL/HAL_DUE/dogm/u8g_com_HAL_DUE_sw_spi.cpp

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm

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

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -80,7 +80,7 @@ Pio *SCK_pPio, *MOSI_pPio;
 uint32_t SCK_dwMask, MOSI_dwMask;
 
 void u8g_spiSend_sw_DUE_mode_0(uint8_t val) { // 3MHz
-  LOOP_L_N(i, 8) {
+  for (uint8_t i = 0; i < 8; i++) {
     if (val & 0x80)
       MOSI_pPio->PIO_SODR = MOSI_dwMask;
     else
@@ -94,7 +94,7 @@ void u8g_spiSend_sw_DUE_mode_0(uint8_t val) { // 3MHz
 }
 
 void u8g_spiSend_sw_DUE_mode_3(uint8_t val) { // 3.5MHz
-  LOOP_L_N(i, 8) {
+  for (uint8_t i = 0; i < 8; i++) {
     SCK_pPio->PIO_CODR = SCK_dwMask;
     DELAY_NS(50);
     if (val & 0x80)

Marlin/src/HAL/HAL_DUE/dogm/u8g_com_HAL_DUE_sw_spi_shared.h

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm

Marlin/src/HAL/HAL_DUE/endstop_interrupts.h

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -38,40 +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
+    attachInterrupt(digitalPinToInterrupt(Z3_MAX_PIN), endstop_ISR, CHANGE);
+  #endif
+  #if HAS_Z3_MIN
+    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
 }

Marlin/src/HAL/HAL_DUE/fastio.h

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -166,7 +166,7 @@
 // Set pin as output (wrapper) -  reads the pin and sets the output to that value
 #define SET_OUTPUT(IO)       _SET_OUTPUT(IO)
 // Set pin as PWM
-#define SET_PWM               SET_OUTPUT
+#define SET_PWM(IO)           SET_OUTPUT(IO)
 
 // Check if pin is an input
 #define IS_INPUT(IO)         ((digitalPinToPort(IO)->PIO_OSR & digitalPinToBitMask(IO)) == 0)

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

@@ -0,0 +1,145 @@
+/**
+ * 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/>.
+ *
+ */
+
+/**
+ * The PWM module is only used to generate interrupts at specified times. It
+ * is NOT used to directly toggle pins. The ISR writes to the pin assigned to
+ * that interrupt.
+ *
+ * All PWMs use the same repetition rate.  The G2 needs about 10KHz min in order to
+ * not have obvious ripple on the Vref signals.
+ *
+ * The data structures are setup to minimize the computation done by the ISR which
+ * minimizes ISR execution time.  Execution times are 0.8 to 1.1 microseconds.
+ *
+ * FIve PWM interrupt sources are used.  Channel 0 sets the base period.  All Vref
+ * signals are set active when this counter overflows and resets to zero.  The compare
+ * values in channels 1-4 are set to give the desired duty cycle for that Vref pin.
+ * When counter 0 matches the compare value then that channel generates an interrupt.
+ * The ISR checks the source of the interrupt and sets the corresponding pin inactive.
+ *
+ * Some jitter in the Vref signal is OK so the interrupt priority is left at its default value.
+ */
+
+#include "../../../inc/MarlinConfig.h"
+
+#if MB(PRINTRBOARD_G2)
+
+#include "G2_PWM.h"
+
+volatile uint32_t *SODR_A = &PIOA->PIO_SODR,
+                  *SODR_B = &PIOB->PIO_SODR,
+                  *CODR_A = &PIOA->PIO_CODR,
+                  *CODR_B = &PIOB->PIO_CODR;
+
+PWM_map ISR_table[NUM_PWMS] = PWM_MAP_INIT;
+
+void Stepper::digipot_init() {
+
+  OUT_WRITE(MOTOR_CURRENT_PWM_X_PIN, 0);  // init pins
+  OUT_WRITE(MOTOR_CURRENT_PWM_Y_PIN, 0);
+  OUT_WRITE(MOTOR_CURRENT_PWM_Z_PIN, 0);
+  OUT_WRITE(MOTOR_CURRENT_PWM_E_PIN, 0);
+
+  #define WPKEY          (0x50574D << 8) // “PWM” in ASCII
+  #define WPCMD_DIS_SW   0  // command to disable Write Protect SW
+  #define WPRG_ALL       (PWM_WPCR_WPRG0 | PWM_WPCR_WPRG1 | PWM_WPCR_WPRG2 | PWM_WPCR_WPRG3 | PWM_WPCR_WPRG4 | PWM_WPCR_WPRG5)  // all Write Protect Groups
+
+  #define PWM_CLOCK_F    F_CPU / 1000000UL   // set clock to 1MHz
+
+  PMC->PMC_PCER1 = PMC_PCER1_PID36;                       // enable PWM controller clock (disabled on power up)
+
+  PWM->PWM_WPCR = WPKEY | WPRG_ALL | WPCMD_DIS_SW;        // enable setting of all PWM registers
+  PWM->PWM_CLK = PWM_CLOCK_F;                             // enable CLK_A and set it to 1MHz, leave CLK_B disabled
+  PWM->PWM_CH_NUM[0].PWM_CMR = 0b1011;                    // set channel 0 to Clock A input & to left aligned
+  PWM->PWM_CH_NUM[1].PWM_CMR = 0b1011;                    // set channel 1 to Clock A input & to left aligned
+  PWM->PWM_CH_NUM[2].PWM_CMR = 0b1011;                    // set channel 2 to Clock A input & to left aligned
+  PWM->PWM_CH_NUM[3].PWM_CMR = 0b1011;                    // set channel 3 to Clock A input & to left aligned
+  PWM->PWM_CH_NUM[4].PWM_CMR = 0b1011;                    // set channel 4 to Clock A input & to left aligned
+
+  PWM->PWM_CH_NUM[0].PWM_CPRD = PWM_PERIOD_US;            // set channel 0 Period
+
+  PWM->PWM_IER2 = PWM_IER1_CHID0;                         // generate interrupt when counter0 overflows
+  PWM->PWM_IER2 = PWM_IER2_CMPM0 | PWM_IER2_CMPM1 | PWM_IER2_CMPM2 | PWM_IER2_CMPM3 | PWM_IER2_CMPM4;        // generate interrupt on compare event
+
+  PWM->PWM_CMP[1].PWM_CMPV = 0x010000000LL | G2_VREF_COUNT(G2_VREF(motor_current_setting[0]));   // interrupt when counter0 == CMPV - used to set Motor 1 PWM inactive
+  PWM->PWM_CMP[2].PWM_CMPV = 0x010000000LL | G2_VREF_COUNT(G2_VREF(motor_current_setting[0]));   // interrupt when counter0 == CMPV - used to set Motor 2 PWM inactive
+  PWM->PWM_CMP[3].PWM_CMPV = 0x010000000LL | G2_VREF_COUNT(G2_VREF(motor_current_setting[1]));   // interrupt when counter0 == CMPV - used to set Motor 3 PWM inactive
+  PWM->PWM_CMP[4].PWM_CMPV = 0x010000000LL | G2_VREF_COUNT(G2_VREF(motor_current_setting[2]));   // interrupt when counter0 == CMPV - used to set Motor 4 PWM inactive
+
+  PWM->PWM_CMP[1].PWM_CMPM = 0x0001;  // enable compare event
+  PWM->PWM_CMP[2].PWM_CMPM = 0x0001;  // enable compare event
+  PWM->PWM_CMP[3].PWM_CMPM = 0x0001;  // enable compare event
+  PWM->PWM_CMP[4].PWM_CMPM = 0x0001;  // enable compare event
+
+  PWM->PWM_SCM = PWM_SCM_UPDM_MODE0 | PWM_SCM_SYNC0 | PWM_SCM_SYNC1 | PWM_SCM_SYNC2 | PWM_SCM_SYNC3 | PWM_SCM_SYNC4; // sync 1-4 with 0, use mode 0 for updates
+
+  PWM->PWM_ENA = PWM_ENA_CHID0 | PWM_ENA_CHID1 | PWM_ENA_CHID2 | PWM_ENA_CHID3 | PWM_ENA_CHID4;         // enable the channels used by G2
+  PWM->PWM_IER1 = PWM_IER1_CHID0 | PWM_IER1_CHID1 | PWM_IER1_CHID2 | PWM_IER1_CHID3 | PWM_IER1_CHID4;        // enable interrupts for the channels used by G2
+
+  NVIC_EnableIRQ(PWM_IRQn);     // Enable interrupt handler
+  NVIC_SetPriority(PWM_IRQn, NVIC_EncodePriority(0, 10, 0));  // normal priority for PWM module (can stand some jitter on the Vref signals)
+}
+
+void Stepper::digipot_current(const uint8_t driver, const int16_t current) {
+
+  if (!(PWM->PWM_CH_NUM[0].PWM_CPRD == PWM_PERIOD_US)) digipot_init();  // Init PWM system if needed
+
+  switch (driver) {
+    case 0: PWM->PWM_CMP[1].PWM_CMPVUPD = 0x010000000LL | G2_VREF_COUNT(G2_VREF(current));    // update X & Y
+            PWM->PWM_CMP[2].PWM_CMPVUPD = 0x010000000LL | G2_VREF_COUNT(G2_VREF(current));
+            PWM->PWM_CMP[1].PWM_CMPMUPD = 0x0001;  // enable compare event
+            PWM->PWM_CMP[2].PWM_CMPMUPD = 0x0001;  // enable compare event
+            PWM->PWM_SCUC = PWM_SCUC_UPDULOCK; // tell the PWM controller to update the values on the next cycle
+            break;
+    case 1: PWM->PWM_CMP[3].PWM_CMPVUPD = 0x010000000LL | G2_VREF_COUNT(G2_VREF(current));    // update Z
+            PWM->PWM_CMP[3].PWM_CMPMUPD = 0x0001;  // enable compare event
+            PWM->PWM_SCUC = PWM_SCUC_UPDULOCK; // tell the PWM controller to update the values on the next cycle
+            break;
+    default:PWM->PWM_CMP[4].PWM_CMPVUPD = 0x010000000LL | G2_VREF_COUNT(G2_VREF(current));    // update E
+            PWM->PWM_CMP[4].PWM_CMPMUPD = 0x0001;  // enable compare event
+            PWM->PWM_SCUC = PWM_SCUC_UPDULOCK; // tell the PWM controller to update the values on the next cycle
+            break;
+  }
+}
+
+volatile uint32_t PWM_ISR1_STATUS, PWM_ISR2_STATUS;
+
+void PWM_Handler() {
+  PWM_ISR1_STATUS = PWM->PWM_ISR1;
+  PWM_ISR2_STATUS = PWM->PWM_ISR2;
+  if (PWM_ISR1_STATUS & PWM_IER1_CHID0) {                           // CHAN_0 interrupt
+    *ISR_table[0].set_register = ISR_table[0].write_mask;                                          // set X to active
+    *ISR_table[1].set_register = ISR_table[1].write_mask;                                          // set Y to active
+    *ISR_table[2].set_register = ISR_table[2].write_mask;                                          // set Z to active
+    *ISR_table[3].set_register = ISR_table[3].write_mask;                                          // set E to active
+  }
+  else {
+    if (PWM_ISR2_STATUS & PWM_IER2_CMPM1)  *ISR_table[0].clr_register = ISR_table[0].write_mask;   // set X to inactive
+    if (PWM_ISR2_STATUS & PWM_IER2_CMPM2)  *ISR_table[1].clr_register = ISR_table[1].write_mask;   // set Y to inactive
+    if (PWM_ISR2_STATUS & PWM_IER2_CMPM3)  *ISR_table[2].clr_register = ISR_table[2].write_mask;   // set Z to inactive
+    if (PWM_ISR2_STATUS & PWM_IER2_CMPM4)  *ISR_table[3].clr_register = ISR_table[3].write_mask;   // set E to inactive
+  }
+  return;
+}
+
+#endif // PRINTRBOARD_G2

Marlin/src/HAL/HAL_DUE/fastio/G2_PWM.h

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -63,7 +63,7 @@ extern PWM_map ISR_table[NUM_PWMS];
 extern uint32_t motor_current_setting[3];
 
 #define IR_BIT(p) (WITHIN(p, 0, 3) ? (p) : (p) + 4)
-#define COPY_ACTIVE_TABLE() do{ LOOP_L_N(i, 6) work_table[i] = active_table[i]; }while(0)
+#define COPY_ACTIVE_TABLE() do{ for (uint8_t i = 0; i < 6 ; i++) work_table[i] = active_table[i]; }while(0)
 
 #define PWM_MR0 19999         // base repetition rate minus one count - 20mS
 #define PWM_PR 24             // prescaler value - prescaler divide by 24 + 1  -  1 MHz output

Marlin/src/HAL/HAL_DUE/fastio/G2_pins.h

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm

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

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm

Marlin/src/HAL/HAL_DUE/inc/Conditionals_adv.h

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm

Marlin/src/HAL/HAL_DUE/inc/Conditionals_post.h

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm

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

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
@@ -55,7 +55,3 @@
 #if ENABLED(FAST_PWM_FAN)
   #error "FAST_PWM_FAN is not yet implemented for this platform."
 #endif
-
-#if HAS_TMC_SW_SERIAL
-  #error "TMC220x Software Serial is not supported on this platform."
-#endif

Marlin/src/HAL/HAL_DUE/persistent_store_eeprom.cpp

@@ -1,7 +1,7 @@
 /**
  * Marlin 3D Printer Firmware
  *
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  * Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
  * Copyright (c) 2015-2016 Nico Tonnhofer wurstnase.reprap@gmail.com
  * Copyright (c) 2016 Victor Perez victor_pv@hotmail.com
@@ -27,18 +27,18 @@
 #if ENABLED(EEPROM_SETTINGS)
 
 #include "../../inc/MarlinConfig.h"
-#include "../shared/eeprom_api.h"
+#include "../shared/persistent_store_api.h"
 
-#if !defined(E2END) && ENABLED(FLASH_EEPROM_EMULATION)
+#if !defined(E2END) && NONE(I2C_EEPROM, SPI_EEPROM)
   #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; }
 
 bool PersistentStore::access_finish() {
-  #if ENABLED(FLASH_EEPROM_EMULATION)
+  #if NONE(I2C_EEPROM, SPI_EEPROM)
     eeprom_flush();
   #endif
   return true;
@@ -54,7 +54,7 @@ bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, ui
       eeprom_write_byte(p, v);
       delay(2);
       if (eeprom_read_byte(p) != v) {
-        SERIAL_ECHO_MSG(STR_ERR_EEPROM_WRITE);
+        SERIAL_ECHO_MSG(MSG_ERR_EEPROM_WRITE);
         return true;
       }
     }

Marlin/src/HAL/HAL_DUE/pinsDebug.h

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * 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

Marlin/src/HAL/HAL_DUE/spi_pins.h

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
  * Based on Sprinter and grbl.
  * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm

Marlin/src/HAL/HAL_DUE/timers.cpp

@@ -1,7 +1,7 @@
 /**
  * Marlin 3D Printer Firmware
  *
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  * Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
  * Copyright (c) 2015-2016 Nico Tonnhofer wurstnase.reprap@gmail.com
  *
@@ -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

Marlin/src/HAL/HAL_DUE/timers.h

@@ -1,7 +1,7 @@
 /**
  * Marlin 3D Printer Firmware
  *
- * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  * Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
  *
  * This program is free software: you can redistribute it and/or modify
@@ -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()
 

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

@@ -444,8 +444,8 @@ typedef struct
 #define ENABLE    1
 #ifndef __cplusplus
 #ifndef __bool_true_false_are_defined
-#define false (1==0)
-#define true (1==1)
+#define false 0
+#define true 1
 #endif
 #endif
 #ifndef PASS