Add a minimum Z change option to power-loss recovery (#13859)

Fix bad commits from around db89fc03

.circleci/config.yml

@@ -54,9 +54,10 @@ jobs:
             generate_version ./Marlin/src/inc
             cat ./Marlin/src/inc/_Version.h
             #
-            # Back up pins_RAMPS.h
+            # Backup pins_RAMPS.h
+            #
+            cp Marlin/src/pins/pins_RAMPS.h Marlin/src/pins/pins_RAMPS.h.backup
             #
-            backup_ramps
 
             env_backup
 
@@ -240,14 +241,14 @@ jobs:
             build_marlin_pio ./ ${TEST_PLATFORM}
             restore_configs
             echo testing STM32F1 targets...
-            export TEST_PLATFORM="-e STM32F103RE"
+            export TEST_PLATFORM="-e STM32F1"
             restore_configs
-            echo use_example_configs STM32/STM32F103RE
-            use_example_configs STM32/STM32F103RE
+            echo use_example_configs STM32F10
+            use_example_configs STM32F10
             build_marlin_pio ./ ${TEST_PLATFORM}
             restore_configs
-            echo use_example_configs STM32/stm32f103ret6
-            use_example_configs STM32/stm32f103ret6
+            echo use_example_configs stm32f103ret6
+            use_example_configs stm32f103ret6
             build_marlin_pio ./ ${TEST_PLATFORM}
             restore_configs
 

.github/FUNDING.yml

@@ -1 +0,0 @@
-custom: http://www.thinkyhead.com/donate-to-marlin

.github/issue_template.md

@@ -1,8 +1,8 @@
 <!--
 
-Have you read Marlin's Code of Conduct? By filing an Issue, you are expected to comply with it, including treating everyone with respect: https://github.com/MarlinFirmware/Marlin/blob/bugfix-2.0.x/.github/code_of_conduct.md
+Have you read Marlin's Code of Conduct? By filing an Issue, you are expected to comply with it, including treating everyone with respect: https://github.com/MarlinFirmware/Marlin/blob/master/.github/code_of_conduct.md
 
-Do you want to ask a question? Are you looking for support? Please don't post here. Instead please use the Marlin Firmware forum at http://forums.reprap.org/list.php?415 or the Marlin Facebook Group https://www.facebook.com/groups/1049718498464482/ or the Marlin Discord Server https://discord.gg/n5NJ59y.
+Do you want to ask a question? Are you looking for support? Please don't post here. Instead please use the Marlin Firmware forum at http://forums.reprap.org/list.php?415 or the Marlin Facebook Group https://www.facebook.com/groups/1049718498464482/.
 
 Before filing an issue be sure to test the 1.1 and/or 2.0 "bugfix" branches to see whether the issue is already addressed.
 

.gitignore

@@ -1,9 +1,9 @@
 #
 # Marlin 3D Printer Firmware
-# Copyright (c) 2019 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
+# 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
@@ -171,13 +171,3 @@ CMakeListsPrivate.txt
 
 #CLion
 cmake-build-*
-
-#Eclipse
-.project
-.cproject
-.pydevproject
-.settings
-.classpath
-
-#Python
-__pycache__

.travis.yml

@@ -1,57 +1,39 @@
-dist: bionic
-sudo: false
+dist: trusty
+sudo: require
 
 language: python
 python:
-  - "3.7"
+  - "2.7"
 
 notifications:
   email: false
 
+# Cache PlatformIO packages using Travis CI container-based infrastructure
+sudo: false
+cache:
+  pip: true
+  directories:
+  - "~/.platformio"
+
 env:
-  # Base Environments
+  - TEST_PLATFORM="megaatmega2560"
   - TEST_PLATFORM="DUE"
-  - TEST_PLATFORM="esp32"
-  - TEST_PLATFORM="linux_native"
   - TEST_PLATFORM="LPC1768"
   - TEST_PLATFORM="LPC1769"
-  - TEST_PLATFORM="megaatmega2560"
-  - TEST_PLATFORM="STM32F103RE"
-  - TEST_PLATFORM="teensy31"
+  #- TEST_PLATFORM="STM32F1"
   - TEST_PLATFORM="teensy35"
+  - TEST_PLATFORM="linux_native"
+  - TEST_PLATFORM="esp32"
 
-  # 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="ARMED"
-  - TEST_PLATFORM="BIGTREE_BTT002"
-  - TEST_PLATFORM="BIGTREE_SKR_PRO"
-  - TEST_PLATFORM="STM32F103RC_bigtree"
-  - TEST_PLATFORM="jgaurora_a5s_a1"
-  - TEST_PLATFORM="STM32F103VE_longer"
-  - TEST_PLATFORM="STM32F407VE_black"
-
-  # Non-working environment tests
-  #- TEST_PLATFORM="at90usb1286_cdc"
-  #- TEST_PLATFORM="at90usb1286_dfu"
-  #- TEST_PLATFORM="STM32F103CB_malyan"
-  #- TEST_PLATFORM="mks_robin"
-  #- TEST_PLATFORM="mks_robin_lite"
-  #- TEST_PLATFORM="mks_robin_mini"
-  #- TEST_PLATFORM="mks_robin_nano"
-  #- TEST_PLATFORM="SAMD51_grandcentral_m4"
-  #- TEST_PLATFORM="STM32F103RC_bigtree"
-  #- TEST_PLATFORM="STM32F103RC_bigtree_USB"
-  #- TEST_PLATFORM="STM32F103RC_fysetc"
-  #- TEST_PLATFORM="STM32F4"
-  #- TEST_PLATFORM="STM32F7"
+addons:
+  apt:
+    sources:
+      - ubuntu-toolchain-r-test
+    packages:
+      - g++-7
 
 before_install:
+  - sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-7 90
   #
   # Fetch the tag information for the current branch
   - git fetch origin --tags
@@ -63,7 +45,7 @@ before_install:
 
 install:
   #- pip install -U platformio
-  - pip install -U https://github.com/platformio/platformio-core/archive/master.zip
+  - pip install -U https://github.com/platformio/platformio-core/archive/develop.zip
 
 before_script:
   # Update PlatformIO packages

LICENSE

@@ -3,7 +3,7 @@
                     GNU GENERAL PUBLIC LICENSE
                        Version 3, 29 June 2007
 
- Copyright (c) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
  Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
 
@@ -634,7 +634,7 @@ state the exclusion of warranty; and each file should have at least
 the "copyright" line and a pointer to where the full notice is found.
 
     {one line to give the program's name and a brief idea of what it does.}
-    Copyright (c) {year}  {name of author}
+    Copyright (C) {year}  {name of author}
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -654,7 +654,7 @@ Also add information on how to contact you by electronic and paper mail.
   If the program does terminal interaction, make it output a short
 notice like this when it starts in an interactive mode:
 
-    {project}  Copyright (c) {year}  {fullname}
+    {project}  Copyright (C) {year}  {fullname}
     This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
     This is free software, and you are welcome to redistribute it
     under certain conditions; type `show c' for details.

Marlin/Makefile

@@ -122,207 +122,180 @@ ifeq ($(HARDWARE_MOTHERBOARD),0)
 #
 
 # MEGA/RAMPS up to 1.2
-else ifeq ($(HARDWARE_MOTHERBOARD),1000)
+else ifeq ($(HARDWARE_MOTHERBOARD),3)
 
 # RAMPS 1.3 (Power outputs: Hotend, Fan, Bed)
-else ifeq ($(HARDWARE_MOTHERBOARD),1010)
+else ifeq ($(HARDWARE_MOTHERBOARD),33)
 # RAMPS 1.3 (Power outputs: Hotend0, Hotend1, Bed)
-else ifeq ($(HARDWARE_MOTHERBOARD),1011)
+else ifeq ($(HARDWARE_MOTHERBOARD),34)
 # RAMPS 1.3 (Power outputs: Hotend, Fan0, Fan1)
-else ifeq ($(HARDWARE_MOTHERBOARD),1012)
+else ifeq ($(HARDWARE_MOTHERBOARD),35)
 # RAMPS 1.3 (Power outputs: Hotend0, Hotend1, Fan)
-else ifeq ($(HARDWARE_MOTHERBOARD),1013)
+else ifeq ($(HARDWARE_MOTHERBOARD),36)
 # RAMPS 1.3 (Power outputs: Spindle, Controller Fan)
-else ifeq ($(HARDWARE_MOTHERBOARD),1014)
+else ifeq ($(HARDWARE_MOTHERBOARD),38)
 
 # RAMPS 1.4 (Power outputs: Hotend, Fan, Bed)
-else ifeq ($(HARDWARE_MOTHERBOARD),1020)
+else ifeq ($(HARDWARE_MOTHERBOARD),43)
 # RAMPS 1.4 (Power outputs: Hotend0, Hotend1, Bed)
-else ifeq ($(HARDWARE_MOTHERBOARD),1021)
+else ifeq ($(HARDWARE_MOTHERBOARD),44)
 # RAMPS 1.4 (Power outputs: Hotend, Fan0, Fan1)
-else ifeq ($(HARDWARE_MOTHERBOARD),1022)
+else ifeq ($(HARDWARE_MOTHERBOARD),45)
 # RAMPS 1.4 (Power outputs: Hotend0, Hotend1, Fan)
-else ifeq ($(HARDWARE_MOTHERBOARD),1023)
+else ifeq ($(HARDWARE_MOTHERBOARD),46)
 # RAMPS 1.4 (Power outputs: Spindle, Controller Fan)
-else ifeq ($(HARDWARE_MOTHERBOARD),1024)
+else ifeq ($(HARDWARE_MOTHERBOARD),48)
 
 # RAMPS Plus 3DYMY (Power outputs: Hotend, Fan, Bed)
-else ifeq ($(HARDWARE_MOTHERBOARD),1030)
+else ifeq ($(HARDWARE_MOTHERBOARD),143)
 # RAMPS Plus 3DYMY (Power outputs: Hotend0, Hotend1, Bed)
-else ifeq ($(HARDWARE_MOTHERBOARD),1031)
+else ifeq ($(HARDWARE_MOTHERBOARD),144)
 # RAMPS Plus 3DYMY (Power outputs: Hotend, Fan0, Fan1)
-else ifeq ($(HARDWARE_MOTHERBOARD),1032)
+else ifeq ($(HARDWARE_MOTHERBOARD),145)
 # RAMPS Plus 3DYMY (Power outputs: Hotend0, Hotend1, Fan)
-else ifeq ($(HARDWARE_MOTHERBOARD),1033)
+else ifeq ($(HARDWARE_MOTHERBOARD),146)
 # RAMPS Plus 3DYMY (Power outputs: Spindle, Controller Fan)
-else ifeq ($(HARDWARE_MOTHERBOARD),1034)
+else ifeq ($(HARDWARE_MOTHERBOARD),148)
 
 #
 # RAMPS Derivatives - ATmega1280, ATmega2560
 #
 
 # 3Drag Controller
-else ifeq ($(HARDWARE_MOTHERBOARD),1100)
+else ifeq ($(HARDWARE_MOTHERBOARD),77)
 # Velleman K8200 Controller (derived from 3Drag Controller)
-else ifeq ($(HARDWARE_MOTHERBOARD),1101)
+else ifeq ($(HARDWARE_MOTHERBOARD),78)
 # Velleman K8400 Controller (derived from 3Drag Controller)
-else ifeq ($(HARDWARE_MOTHERBOARD),1102)
+else ifeq ($(HARDWARE_MOTHERBOARD),79)
 # 2PrintBeta BAM&DICE with STK drivers
-else ifeq ($(HARDWARE_MOTHERBOARD),1103)
+else ifeq ($(HARDWARE_MOTHERBOARD),401)
 # 2PrintBeta BAM&DICE Due with STK drivers
-else ifeq ($(HARDWARE_MOTHERBOARD),1104)
+else ifeq ($(HARDWARE_MOTHERBOARD),402)
 # MKS BASE v1.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1105)
-# MKS v1.4 with A4982 stepper drivers
-else ifeq ($(HARDWARE_MOTHERBOARD),1106)
+else ifeq ($(HARDWARE_MOTHERBOARD),40)
 # MKS v1.5 with Allegro A4982 stepper drivers
-else ifeq ($(HARDWARE_MOTHERBOARD),1107)
+else ifeq ($(HARDWARE_MOTHERBOARD),405)
 # MKS BASE 1.0 with Heroic HR4982 stepper drivers
-else ifeq ($(HARDWARE_MOTHERBOARD),1108)
+else ifeq ($(HARDWARE_MOTHERBOARD),41)
 # MKS GEN v1.3 or 1.4
-else ifeq ($(HARDWARE_MOTHERBOARD),1109)
+else ifeq ($(HARDWARE_MOTHERBOARD),47)
 # MKS GEN L
-else ifeq ($(HARDWARE_MOTHERBOARD),1110)
+else ifeq ($(HARDWARE_MOTHERBOARD),53)
 # zrib V2.0 control board (Chinese knock off RAMPS replica)
-else ifeq ($(HARDWARE_MOTHERBOARD),1111)
-# Bigtreetech or BIQU KFB2.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1112)
+else ifeq ($(HARDWARE_MOTHERBOARD),504)
 # Felix 2.0+ Electronics Board (RAMPS like)
-else ifeq ($(HARDWARE_MOTHERBOARD),1113)
+else ifeq ($(HARDWARE_MOTHERBOARD),37)
 # Invent-A-Part RigidBoard
-else ifeq ($(HARDWARE_MOTHERBOARD),1114)
+else ifeq ($(HARDWARE_MOTHERBOARD),42)
 # Invent-A-Part RigidBoard V2
-else ifeq ($(HARDWARE_MOTHERBOARD),1115)
+else ifeq ($(HARDWARE_MOTHERBOARD),52)
 # Sainsmart 2-in-1 board
-else ifeq ($(HARDWARE_MOTHERBOARD),1116)
+else ifeq ($(HARDWARE_MOTHERBOARD),49)
 # Ultimaker
-else ifeq ($(HARDWARE_MOTHERBOARD),1117)
+else ifeq ($(HARDWARE_MOTHERBOARD),7)
 # Ultimaker (Older electronics. Pre 1.5.4. This is rare)
-else ifeq ($(HARDWARE_MOTHERBOARD),1118)
+else ifeq ($(HARDWARE_MOTHERBOARD),71)
   MCU ?= atmega1280
 
 # Azteeg X3
-else ifeq ($(HARDWARE_MOTHERBOARD),1119)
+else ifeq ($(HARDWARE_MOTHERBOARD),67)
 # Azteeg X3 Pro
-else ifeq ($(HARDWARE_MOTHERBOARD),1120)
+else ifeq ($(HARDWARE_MOTHERBOARD),68)
 # Ultimainboard 2.x (Uses TEMP_SENSOR 20)
-else ifeq ($(HARDWARE_MOTHERBOARD),1121)
+else ifeq ($(HARDWARE_MOTHERBOARD),72)
 # Rumba
-else ifeq ($(HARDWARE_MOTHERBOARD),1122)
+else ifeq ($(HARDWARE_MOTHERBOARD),80)
 # Raise3D Rumba
-else ifeq ($(HARDWARE_MOTHERBOARD),1123)
+else ifeq ($(HARDWARE_MOTHERBOARD),333)
 # Rapide Lite RL200 Rumba
-else ifeq ($(HARDWARE_MOTHERBOARD),1124)
+else ifeq ($(HARDWARE_MOTHERBOARD),801)
 # Formbot T-Rex 2 Plus
-else ifeq ($(HARDWARE_MOTHERBOARD),1125)
+else ifeq ($(HARDWARE_MOTHERBOARD),95)
 # Formbot T-Rex 3
-else ifeq ($(HARDWARE_MOTHERBOARD),1126)
+else ifeq ($(HARDWARE_MOTHERBOARD),96)
 # Formbot Raptor
-else ifeq ($(HARDWARE_MOTHERBOARD),1127)
+else ifeq ($(HARDWARE_MOTHERBOARD),97)
 # Formbot Raptor 2
-else ifeq ($(HARDWARE_MOTHERBOARD),1128)
+else ifeq ($(HARDWARE_MOTHERBOARD),98)
 # bq ZUM Mega 3D
-else ifeq ($(HARDWARE_MOTHERBOARD),1129)
+else ifeq ($(HARDWARE_MOTHERBOARD),503)
 # MakeBoard Mini v2.1.2 is a control board sold by MicroMake
-else ifeq ($(HARDWARE_MOTHERBOARD),1130)
+else ifeq ($(HARDWARE_MOTHERBOARD),431)
 # TriGorilla Anycubic version 1.3 based on RAMPS EFB
-else ifeq ($(HARDWARE_MOTHERBOARD),1131)
+else ifeq ($(HARDWARE_MOTHERBOARD),343)
 # TriGorilla Anycubic version 1.4 based on RAMPS EFB
-else ifeq ($(HARDWARE_MOTHERBOARD),1132)
-# TriGorilla Anycubic version 1.4 Rev 1.1
-else ifeq ($(HARDWARE_MOTHERBOARD),1133)
+else ifeq ($(HARDWARE_MOTHERBOARD),443)
 # Creality: Ender-4, CR-8
-else ifeq ($(HARDWARE_MOTHERBOARD),1134)
+else ifeq ($(HARDWARE_MOTHERBOARD),243)
 # Creality: CR10S, CR20, CR-X
-else ifeq ($(HARDWARE_MOTHERBOARD),1135)
-# Dagoma F5
-else ifeq ($(HARDWARE_MOTHERBOARD),1136)
-# FYSETC F6
-else ifeq ($(HARDWARE_MOTHERBOARD),1137)
+else ifeq ($(HARDWARE_MOTHERBOARD),244)
+# Fysetc F6
+else ifeq ($(HARDWARE_MOTHERBOARD),541)
 # Duplicator i3 Plus
-else ifeq ($(HARDWARE_MOTHERBOARD),1138)
+else ifeq ($(HARDWARE_MOTHERBOARD),31)
 # VORON
-else ifeq ($(HARDWARE_MOTHERBOARD),1139)
+else ifeq ($(HARDWARE_MOTHERBOARD),441)
 # TRONXY V3 1.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1140)
-# Z-Bolt X Series
-else ifeq ($(HARDWARE_MOTHERBOARD),1141)
-# TT OSCAR
-else ifeq ($(HARDWARE_MOTHERBOARD),1142)
-# Overlord/Overlord Pro
-else ifeq ($(HARDWARE_MOTHERBOARD),1143)
-
-#
-# RAMBo and derivatives
-#
-
-# Rambo
-else ifeq ($(HARDWARE_MOTHERBOARD),1200)
-# Mini-Rambo
-else ifeq ($(HARDWARE_MOTHERBOARD),1201)
-# Mini-Rambo 1.0a
-else ifeq ($(HARDWARE_MOTHERBOARD),1202)
-# Einsy Rambo
-else ifeq ($(HARDWARE_MOTHERBOARD),1203)
-# Einsy Retro
-else ifeq ($(HARDWARE_MOTHERBOARD),1204)
-# abee Scoovo X9H
-else ifeq ($(HARDWARE_MOTHERBOARD),1205)
+else ifeq ($(HARDWARE_MOTHERBOARD),442)
 
 #
 # Other ATmega1280, ATmega2560
 #
 
 # Cartesio CN Controls V11
-else ifeq ($(HARDWARE_MOTHERBOARD),1300)
+else ifeq ($(HARDWARE_MOTHERBOARD),111)
 # Cartesio CN Controls V12
-else ifeq ($(HARDWARE_MOTHERBOARD),1301)
+else ifeq ($(HARDWARE_MOTHERBOARD),112)
 # Cheaptronic v1.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1302)
+else ifeq ($(HARDWARE_MOTHERBOARD),2)
 # Cheaptronic v2.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1303)
+else ifeq ($(HARDWARE_MOTHERBOARD),21)
 # Makerbot Mightyboard Revision E
-else ifeq ($(HARDWARE_MOTHERBOARD),1304)
+else ifeq ($(HARDWARE_MOTHERBOARD),200)
 # Megatronics
-else ifeq ($(HARDWARE_MOTHERBOARD),1305)
+else ifeq ($(HARDWARE_MOTHERBOARD),70)
 # Megatronics v2.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1306)
+else ifeq ($(HARDWARE_MOTHERBOARD),701)
 # Megatronics v3.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1307)
+else ifeq ($(HARDWARE_MOTHERBOARD),703)
 # Megatronics v3.1
-else ifeq ($(HARDWARE_MOTHERBOARD),1308)
-# Megatronics v3.2
-else ifeq ($(HARDWARE_MOTHERBOARD),1309)
+else ifeq ($(HARDWARE_MOTHERBOARD),704)
+# Rambo
+else ifeq ($(HARDWARE_MOTHERBOARD),301)
+# Mini-Rambo
+else ifeq ($(HARDWARE_MOTHERBOARD),302)
+# Mini-Rambo 1.0a
+else ifeq ($(HARDWARE_MOTHERBOARD),303)
+# Einsy Rambo
+else ifeq ($(HARDWARE_MOTHERBOARD),304)
+# Einsy Retro
+else ifeq ($(HARDWARE_MOTHERBOARD),305)
 # Elefu Ra Board (v3)
-else ifeq ($(HARDWARE_MOTHERBOARD),1310)
+else ifeq ($(HARDWARE_MOTHERBOARD),21)
 # Leapfrog
-else ifeq ($(HARDWARE_MOTHERBOARD),1311)
+else ifeq ($(HARDWARE_MOTHERBOARD),999)
 # Mega controller
-else ifeq ($(HARDWARE_MOTHERBOARD),1312)
+else ifeq ($(HARDWARE_MOTHERBOARD),310)
+# abee Scoovo X9H
+else ifeq ($(HARDWARE_MOTHERBOARD),321)
 # Geeetech GT2560 Rev B for Mecreator2
-else ifeq ($(HARDWARE_MOTHERBOARD),1313)
+else ifeq ($(HARDWARE_MOTHERBOARD),73)
 # Geeetech GT2560 Rev. A
-else ifeq ($(HARDWARE_MOTHERBOARD),1314)
+else ifeq ($(HARDWARE_MOTHERBOARD),74)
 # Geeetech GT2560 Rev. A+ (with auto level probe)
-else ifeq ($(HARDWARE_MOTHERBOARD),1315)
+else ifeq ($(HARDWARE_MOTHERBOARD),75)
 # Geeetech GT2560 Rev B for A10(M/D)
-else ifeq ($(HARDWARE_MOTHERBOARD),1316)
+else ifeq ($(HARDWARE_MOTHERBOARD),76)
 # Geeetech GT2560 Rev B for A20(M/D)
-else ifeq ($(HARDWARE_MOTHERBOARD),1317)
-# Einstart retrofit
-else ifeq ($(HARDWARE_MOTHERBOARD),1318)
-# Wanhao 0ne+ i3 Mini
-else ifeq ($(HARDWARE_MOTHERBOARD),1319)
+else ifeq ($(HARDWARE_MOTHERBOARD),86)
 
 #
 # ATmega1281, ATmega2561
 #
 
-# Minitronics v1.0/1.1
-else ifeq ($(HARDWARE_MOTHERBOARD),1400)
+else ifeq ($(HARDWARE_MOTHERBOARD),702)
   MCU              ?= atmega1281
-# Silvergate v1.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1401)
+else ifeq ($(HARDWARE_MOTHERBOARD),25)
   MCU              ?= atmega1281
 
 #
@@ -330,43 +303,43 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1401)
 #
 
 # Sanguinololu < 1.2
-else ifeq ($(HARDWARE_MOTHERBOARD),1500)
+else ifeq ($(HARDWARE_MOTHERBOARD),6)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega644p
 # Sanguinololu 1.2 and above
-else ifeq ($(HARDWARE_MOTHERBOARD),1501)
+else ifeq ($(HARDWARE_MOTHERBOARD),62)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega644p
 # Melzi
-else ifeq ($(HARDWARE_MOTHERBOARD),1502)
+else ifeq ($(HARDWARE_MOTHERBOARD),63)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega644p
 # Melzi with ATmega1284 (MaKr3d version)
-else ifeq ($(HARDWARE_MOTHERBOARD),1503)
+else ifeq ($(HARDWARE_MOTHERBOARD),66)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega1284p
 # Melzi Creality3D board (for CR-10 etc)
-else ifeq ($(HARDWARE_MOTHERBOARD),1504)
+else ifeq ($(HARDWARE_MOTHERBOARD),89)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega1284p
 # Melzi Malyan M150 board
-else ifeq ($(HARDWARE_MOTHERBOARD),1505)
+else ifeq ($(HARDWARE_MOTHERBOARD),92)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega1284p
 # Tronxy X5S
-else ifeq ($(HARDWARE_MOTHERBOARD),1506)
+else ifeq ($(HARDWARE_MOTHERBOARD),505)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega1284p
 # STB V1.1
-else ifeq ($(HARDWARE_MOTHERBOARD),1507)
+else ifeq ($(HARDWARE_MOTHERBOARD),64)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega1284p
 # Azteeg X1
-else ifeq ($(HARDWARE_MOTHERBOARD),1508)
+else ifeq ($(HARDWARE_MOTHERBOARD),65)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega1284p
 # Anet 1.0 (Melzi clone)
-else ifeq ($(HARDWARE_MOTHERBOARD),1509)
+else ifeq ($(HARDWARE_MOTHERBOARD),69)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega1284p
 
@@ -375,51 +348,51 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1509)
 #
 
 # Gen3 Monolithic Electronics
-else ifeq ($(HARDWARE_MOTHERBOARD),1600)
+else ifeq ($(HARDWARE_MOTHERBOARD),22)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega644p
 # Gen3+
-else ifeq ($(HARDWARE_MOTHERBOARD),1601)
+else ifeq ($(HARDWARE_MOTHERBOARD),9)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega644p
 # Gen6
-else ifeq ($(HARDWARE_MOTHERBOARD),1602)
+else ifeq ($(HARDWARE_MOTHERBOARD),5)
   HARDWARE_VARIANT ?= Gen6
   MCU              ?= atmega644p
 # Gen6 deluxe
-else ifeq ($(HARDWARE_MOTHERBOARD),1603)
+else ifeq ($(HARDWARE_MOTHERBOARD),51)
   HARDWARE_VARIANT ?= Gen6
   MCU              ?= atmega644p
 # Gen7 custom (Alfons3 Version)
-else ifeq ($(HARDWARE_MOTHERBOARD),1604)
+else ifeq ($(HARDWARE_MOTHERBOARD),10)
   HARDWARE_VARIANT ?= Gen7
   MCU              ?= atmega644
   F_CPU            ?= 20000000
 # Gen7 v1.1, v1.2
-else ifeq ($(HARDWARE_MOTHERBOARD),1605)
+else ifeq ($(HARDWARE_MOTHERBOARD),11)
   HARDWARE_VARIANT ?= Gen7
   MCU              ?= atmega644p
   F_CPU            ?= 20000000
 # Gen7 v1.3
-else ifeq ($(HARDWARE_MOTHERBOARD),1606)
+else ifeq ($(HARDWARE_MOTHERBOARD),12)
   HARDWARE_VARIANT ?= Gen7
   MCU              ?= atmega644p
   F_CPU            ?= 20000000
 # Gen7 v1.4
-else ifeq ($(HARDWARE_MOTHERBOARD),1607)
+else ifeq ($(HARDWARE_MOTHERBOARD),13)
   HARDWARE_VARIANT ?= Gen7
   MCU              ?= atmega1284p
   F_CPU            ?= 20000000
 # Alpha OMCA board
-else ifeq ($(HARDWARE_MOTHERBOARD),1608)
+else ifeq ($(HARDWARE_MOTHERBOARD),90)
   HARDWARE_VARIANT ?= SanguinoA
   MCU              ?= atmega644
 # Final OMCA board
-else ifeq ($(HARDWARE_MOTHERBOARD),1609)
+else ifeq ($(HARDWARE_MOTHERBOARD),91)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega644p
 # Sethi 3D_1
-else ifeq ($(HARDWARE_MOTHERBOARD),1610)
+else ifeq ($(HARDWARE_MOTHERBOARD),20)
   HARDWARE_VARIANT ?= Sanguino
   MCU              ?= atmega644p
 
@@ -428,46 +401,46 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1610)
 #
 
 # Teensylu
-else ifeq ($(HARDWARE_MOTHERBOARD),1700)
+else ifeq ($(HARDWARE_MOTHERBOARD),8)
   HARDWARE_VARIANT ?= Teensy
   MCU              ?= at90usb1286
 # Printrboard (AT90USB1286)
-else ifeq ($(HARDWARE_MOTHERBOARD),1701)
+else ifeq ($(HARDWARE_MOTHERBOARD),81)
   HARDWARE_VARIANT ?= Teensy
   MCU              ?= at90usb1286
 # Printrboard Revision F (AT90USB1286)
-else ifeq ($(HARDWARE_MOTHERBOARD),1702)
+else ifeq ($(HARDWARE_MOTHERBOARD),811)
   HARDWARE_VARIANT ?= Teensy
   MCU              ?= at90usb1286
 # Brainwave (AT90USB646)
-else ifeq ($(HARDWARE_MOTHERBOARD),1703)
+else ifeq ($(HARDWARE_MOTHERBOARD),82)
   HARDWARE_VARIANT ?= Teensy
   MCU              ?= at90usb646
 # Brainwave Pro (AT90USB1286)
-else ifeq ($(HARDWARE_MOTHERBOARD),1704)
+else ifeq ($(HARDWARE_MOTHERBOARD),83)
   HARDWARE_VARIANT ?= Teensy
   MCU              ?= at90usb1286
 # SAV Mk-I (AT90USB1286)
-else ifeq ($(HARDWARE_MOTHERBOARD),1705)
+else ifeq ($(HARDWARE_MOTHERBOARD),84)
   HARDWARE_VARIANT ?= Teensy
   MCU              ?= at90usb1286
 # Teensy++2.0 (AT90USB1286)
-else ifeq ($(HARDWARE_MOTHERBOARD),1706)
+else ifeq ($(HARDWARE_MOTHERBOARD),85)
   HARDWARE_VARIANT ?= Teensy
   MCU              ?= at90usb1286
 # 5DPrint D8 Driver Board
-else ifeq ($(HARDWARE_MOTHERBOARD),1707)
+else ifeq ($(HARDWARE_MOTHERBOARD),88)
   HARDWARE_VARIANT ?= Teensy
   MCU              ?= at90usb1286
 
 # UltiMachine Archim1 (with DRV8825 drivers)
-else ifeq ($(HARDWARE_MOTHERBOARD),3023)
+else ifeq ($(HARDWARE_MOTHERBOARD),1591)
   HARDWARE_VARIANT ?= archim
   MCPU              = cortex-m3
   F_CPU             = 84000000L
   IS_MCU            = 0
 # UltiMachine Archim2 (with TMC2130 drivers)
-else ifeq ($(HARDWARE_MOTHERBOARD),3024)
+else ifeq ($(HARDWARE_MOTHERBOARD),1592)
   HARDWARE_VARIANT ?= archim
   MCPU              = cortex-m3
   F_CPU             = 84000000L
@@ -614,7 +587,7 @@ ifeq ($(U8GLIB), 1)
 endif
 
 ifeq ($(TMC), 1)
-  LIB_CXXSRC += TMCStepper.cpp COOLCONF.cpp DRV_STATUS.cpp IHOLD_IRUN.cpp CHOPCONF.cpp GCONF.cpp PWMCONF.cpp DRV_CONF.cpp DRVCONF.cpp DRVCTRL.cpp DRVSTATUS.cpp ENCMODE.cpp RAMP_STAT.cpp SGCSCONF.cpp SHORT_CONF.cpp SMARTEN.cpp SW_MODE.cpp SW_SPI.cpp TMC2130Stepper.cpp TMC2208Stepper.cpp TMC2209Stepper.cpp TMC2660Stepper.cpp TMC5130Stepper.cpp TMC5160Stepper.cpp
+  LIB_CXXSRC += TMCStepper.cpp COOLCONF.cpp DRV_STATUS.cpp IHOLD_IRUN.cpp CHOPCONF.cpp  GCONF.cpp PWMCONF.cpp DRV_CONF.cpp DRVCONF.cpp DRVCTRL.cpp DRVSTATUS.cpp ENCMODE.cpp  RAMP_STAT.cpp SGCSCONF.cpp SHORT_CONF.cpp SMARTEN.cpp SW_MODE.cpp SW_SPI.cpp TMC2130Stepper.cpp TMC2208Stepper.cpp TMC2660Stepper.cpp TMC5130Stepper.cpp TMC5160Stepper.cpp
 endif
 
 ifeq ($(RELOC_WORKAROUND), 1)
@@ -685,8 +658,8 @@ LIBWARN = -w -Wno-packed-bitfield-compat
 CSTANDARD = -std=gnu99
 CXXSTANDARD = -std=gnu++11
 CDEBUG = -g$(DEBUG)
-CWARN   = -Wall -Wstrict-prototypes -Wno-packed-bitfield-compat -Wno-pragmas -Wunused-parameter
-CXXWARN = -Wall                     -Wno-packed-bitfield-compat -Wno-pragmas -Wunused-parameter
+CWARN   = -Wall -Wstrict-prototypes -Wno-packed-bitfield-compat -Wno-pragmas
+CXXWARN = -Wall                     -Wno-packed-bitfield-compat -Wno-pragmas
 CTUNING = -fsigned-char -funsigned-bitfields -fpack-struct -fno-exceptions \
           -fshort-enums -ffunction-sections -fdata-sections
 ifneq ($(HARDWARE_MOTHERBOARD),)

Marlin/Marlin.ino

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

Marlin/_Bootscreen.h

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

Marlin/_Statusscreen.h

@@ -1,74 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * Custom Status Screen bitmap
- *
- * Place this file in the root with your configuration files
- * and enable CUSTOM_STATUS_SCREEN_IMAGE in Configuration.h.
- *
- * Use the Marlin Bitmap Converter to make your own:
- * http://marlinfw.org/tools/u8glib/converter.html
- */
-
-//
-// Status Screen Logo bitmap
-//
-#define STATUS_LOGO_Y            3
-#define STATUS_LOGO_WIDTH       24
-
-const unsigned char status_logo_bmp[] PROGMEM = {
-  B11111111,B11111111,B11111111,
-  B10000000,B00000000,B00000001,
-  B10001110,B00000000,B11100001,
-  B10011111,B00000001,B11110001,
-  B10010011,B10000001,B00111001,
-  B10011111,B10000001,B11111001,
-  B10011111,B10000001,B11111001,
-  B10011111,B10111001,B11111001,
-  B10001111,B00101000,B11110001,
-  B10000000,B00111000,B00000001,
-  B10000000,B00000000,B00000001,
-  B10011111,B11111111,B11111001,
-  B10010001,B01110100,B10011001,
-  B10011011,B00000110,B10101001,
-  B10011011,B01010100,B10101001,
-  B10011011,B01010110,B10101001,
-  B10011011,B01010100,B10011001,
-  B10011111,B11111111,B11111001,
-  B11111111,B11111111,B11111111
-};
-
-//
-// Use default bitmaps
-//
-#define STATUS_HOTEND_ANIM
-#define STATUS_BED_ANIM
-#if HOTENDS < 2
-  #define STATUS_LOGO_X          8
-  #define STATUS_HEATERS_X      40
-  #define STATUS_BED_X          72
-#else
-  #define STATUS_LOGO_X          0
-  #define STATUS_HEATERS_X      32
-  #define STATUS_BED_X          80
-#endif

Marlin/src/HAL/HAL.h

@@ -1,32 +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
-
-#include "platforms.h"
-
-#include HAL_PATH(.,HAL.h)
-
-inline void watchdog_refresh() {
-  #if ENABLED(USE_WATCHDOG)
-    HAL_watchdog_refresh();
-  #endif
-}

Marlin/src/HAL/HAL_AVR/HAL.cpp

@@ -1,56 +1,71 @@
-/**
- * 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/>.
- *
- */
+/* **************************************************************************
+
+ Marlin 3D Printer Firmware
+ 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
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+****************************************************************************/
 
 #ifdef __AVR__
 
+// --------------------------------------------------------------------------
+// Includes
+// --------------------------------------------------------------------------
+
 #include "../../inc/MarlinConfig.h"
 #include "HAL.h"
 
-// ------------------------
+// --------------------------------------------------------------------------
+// Externals
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Local defines
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Types
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Variables
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
 // Public Variables
-// ------------------------
+// --------------------------------------------------------------------------
 
 //uint8_t MCUSR;
 
-// ------------------------
-// Public functions
-// ------------------------
+// --------------------------------------------------------------------------
+// Private Variables
+// --------------------------------------------------------------------------
 
-void HAL_init() {
-  // Init Servo Pins
-  #define INIT_SERVO(N) OUT_WRITE(SERVO##N##_PIN, LOW)
-  #if HAS_SERVO_0
-    INIT_SERVO(0);
-  #endif
-  #if HAS_SERVO_1
-    INIT_SERVO(1);
-  #endif
-  #if HAS_SERVO_2
-    INIT_SERVO(2);
-  #endif
-  #if HAS_SERVO_3
-    INIT_SERVO(3);
-  #endif
-}
+// --------------------------------------------------------------------------
+// Function prototypes
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Private functions
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Public functions
+// --------------------------------------------------------------------------
 
 #if ENABLED(SDSUPPORT)
 

Marlin/src/HAL/HAL_AVR/HAL.h

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
@@ -18,29 +18,33 @@
  */
 #pragma once
 
+// --------------------------------------------------------------------------
+// Includes
+// --------------------------------------------------------------------------
+
+#include <stdint.h>
+
 #include "../shared/Marduino.h"
 #include "../shared/HAL_SPI.h"
-#include "fastio.h"
-#include "watchdog.h"
-#include "math.h"
+#include "fastio_AVR.h"
+#include "watchdog_AVR.h"
+#include "math_AVR.h"
 
 #ifdef USBCON
   #include "HardwareSerial.h"
 #else
-  #define HardwareSerial_h // Hack to prevent HardwareSerial.h header inclusion
   #include "MarlinSerial.h"
 #endif
 
-#include <stdint.h>
 #include <util/delay.h>
 #include <avr/eeprom.h>
 #include <avr/pgmspace.h>
 #include <avr/interrupt.h>
 #include <avr/io.h>
 
-// ------------------------
+// --------------------------------------------------------------------------
 // Defines
-// ------------------------
+// --------------------------------------------------------------------------
 
 //#define analogInputToDigitalPin(IO) IO
 
@@ -55,21 +59,20 @@
 // On AVR this is in math.h?
 //#define square(x) ((x)*(x))
 
-// ------------------------
+// --------------------------------------------------------------------------
 // Types
-// ------------------------
+// --------------------------------------------------------------------------
 
 typedef uint16_t hal_timer_t;
 #define HAL_TIMER_TYPE_MAX 0xFFFF
 
 typedef int8_t pin_t;
 
-#define SHARED_SERVOS HAS_SERVOS
 #define HAL_SERVO_LIB Servo
 
-// ------------------------
+// --------------------------------------------------------------------------
 // Public Variables
-// ------------------------
+// --------------------------------------------------------------------------
 
 //extern uint8_t MCUSR;
 
@@ -101,25 +104,20 @@ typedef int8_t pin_t;
   #endif
 #endif
 
-// ------------------------
+// --------------------------------------------------------------------------
 // Public functions
-// ------------------------
+// --------------------------------------------------------------------------
 
-void HAL_init();
-
-//void cli();
+//void cli(void);
 
 //void _delay_ms(const int delay);
 
-inline void HAL_clear_reset_source() { MCUSR = 0; }
-inline uint8_t HAL_get_reset_source() { return MCUSR; }
+inline void HAL_clear_reset_source(void) { MCUSR = 0; }
+inline uint8_t HAL_get_reset_source(void) { return MCUSR; }
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-function"
 extern "C" {
-  int freeMemory();
+  int freeMemory(void);
 }
-#pragma GCC diagnostic pop
 
 // timers
 #define HAL_TIMER_RATE          ((F_CPU) / 8)    // i.e., 2MHz or 2.5MHz
@@ -146,7 +144,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
@@ -198,9 +197,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 */ \
@@ -267,13 +266,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 */ \
@@ -333,7 +332,7 @@ void TIMER0_COMPB_vect() { \
     : \
   ); \
 } \
-void TIMER0_COMPB_vect_bottom()
+void TIMER0_COMPB_vect_bottom(void)
 
 // ADC
 #ifdef DIDR2
@@ -342,7 +341,7 @@ void TIMER0_COMPB_vect_bottom()
   #define HAL_ANALOG_SELECT(pin) do{ SBI(DIDR0, pin); }while(0)
 #endif
 
-inline void HAL_adc_init() {
+inline void HAL_adc_init(void) {
   ADCSRA = _BV(ADEN) | _BV(ADSC) | _BV(ADIF) | 0x07;
   DIDR0 = 0;
   #ifdef DIDR2

Marlin/src/HAL/HAL_AVR/HAL_spi_AVR.cpp

@@ -1,9 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,41 +21,56 @@
  */
 
 /**
- * Adapted from Arduino Sd2Card Library
- * Copyright (c) 2009 by William Greiman
+ * Originally from Arduino Sd2Card Library
+ * Copyright (C) 2009 by William Greiman
  */
 
 /**
- * HAL for AVR - SPI functions
+ * Description: HAL for AVR - SPI functions
  */
 
 #ifdef __AVR__
 
+// --------------------------------------------------------------------------
+// Includes
+// --------------------------------------------------------------------------
+
 #include "../../inc/MarlinConfig.h"
 
-void spiBegin() {
-  OUT_WRITE(SS_PIN, HIGH);
+// --------------------------------------------------------------------------
+// Public Variables
+// --------------------------------------------------------------------------
+
+
+// --------------------------------------------------------------------------
+// Public functions
+// --------------------------------------------------------------------------
+
+void spiBegin (void) {
+  SET_OUTPUT(SS_PIN);
+  WRITE(SS_PIN, HIGH);
   SET_OUTPUT(SCK_PIN);
   SET_INPUT(MISO_PIN);
   SET_OUTPUT(MOSI_PIN);
 
   #if DISABLED(SOFTWARE_SPI)
     // SS must be in output mode even it is not chip select
-    //SET_OUTPUT(SS_PIN);
+    SET_OUTPUT(SS_PIN);
     // set SS high - may be chip select for another SPI device
-    //#if SET_SPI_SS_HIGH
-      //WRITE(SS_PIN, HIGH);
-    //#endif
+    #if SET_SPI_SS_HIGH
+      WRITE(SS_PIN, HIGH);
+    #endif  // SET_SPI_SS_HIGH
     // set a default rate
     spiInit(1);
-  #endif
+  #endif  // SOFTWARE_SPI
 }
 
-#if NONE(SOFTWARE_SPI, FORCE_SOFT_SPI)
 
-  // ------------------------
+#if DISABLED(SOFTWARE_SPI)
+
+  //------------------------------------------------------------------------------
   // Hardware SPI
-  // ------------------------
+  //------------------------------------------------------------------------------
 
   // make sure SPCR rate is in expected bits
   #if (SPR0 != 0 || SPR1 != 1)
@@ -81,7 +96,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;
@@ -169,27 +184,28 @@ void spiBegin() {
     // Invert the SPI2X bit
     clockDiv ^= 0x1;
 
-    SPCR = _BV(SPE) | _BV(MSTR) | ((bitOrder == LSBFIRST) ? _BV(DORD) : 0) |
+    SPCR = _BV(SPE) | _BV(MSTR) | ((bitOrder == SPI_LSBFIRST) ? _BV(DORD) : 0) |
       (dataMode << CPHA) | ((clockDiv >> 1) << SPR0);
     SPSR = clockDiv | 0x01;
   }
 
 
-#else // SOFTWARE_SPI || FORCE_SOFT_SPI
+#else
 
-  // ------------------------
-  // Software SPI
-  // ------------------------
-
-  // nop to tune soft SPI timing
+  /** 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 */ }
+  /** Begin SPI transaction, set clock, bit order, data mode */
+  void spiBeginTransaction(uint32_t spiClock, uint8_t bitOrder, uint8_t dataMode) {
+    UNUSED(spiBeginTransaction);  // nothing to do
+  }
 
-  // Soft SPI receive byte
+  /** Soft SPI receive byte */
   uint8_t spiRec() {
     uint8_t data = 0;
     // no interrupts during byte receive - about 8µs
@@ -214,13 +230,13 @@ void spiBegin() {
     return data;
   }
 
-  // Soft SPI read data
+  /** Soft SPI read data */
   void spiRead(uint8_t* buf, uint16_t nbyte) {
     for (uint16_t i = 0; i < nbyte; i++)
       buf[i] = spiRec();
   }
 
-  // Soft SPI send byte
+  /** Soft SPI send byte */
   void spiSend(uint8_t data) {
     // no interrupts during byte send - about 8µs
     cli();
@@ -241,13 +257,13 @@ void spiBegin() {
     sei();
   }
 
-  // Soft SPI send block
+  /** Soft SPI send block */
   void spiSendBlock(uint8_t token, const uint8_t* buf) {
     spiSend(token);
     for (uint16_t i = 0; i < 512; i++)
       spiSend(buf[i]);
   }
 
-#endif // SOFTWARE_SPI || FORCE_SOFT_SPI
+#endif // SOFTWARE_SPI
 
 #endif // __AVR__

Marlin/src/HAL/HAL_AVR/MarlinSerial.cpp

@@ -1,9 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
+ * 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
@@ -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');
   }

Marlin/src/HAL/HAL_AVR/MarlinSerial.h

@@ -1,9 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
+ * 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
@@ -205,18 +205,18 @@
     public:
 
     FORCE_INLINE static void store_rxd_char();
-    FORCE_INLINE static void _tx_udr_empty_irq();
+    FORCE_INLINE static void _tx_udr_empty_irq(void);
 
     public:
       MarlinSerial() {};
       static void begin(const long);
       static void end();
-      static int peek();
-      static int read();
-      static void flush();
-      static ring_buffer_pos_t available();
+      static int peek(void);
+      static int read(void);
+      static void flush(void);
+      static ring_buffer_pos_t available(void);
       static void write(const uint8_t c);
-      static void flushTX();
+      static void flushTX(void);
 
       FORCE_INLINE static uint8_t dropped() { return Cfg::DROPPED_RX ? rx_dropped_bytes : 0; }
       FORCE_INLINE static uint8_t buffer_overruns() { return Cfg::RX_OVERRUNS ? rx_buffer_overruns : 0; }
@@ -245,7 +245,7 @@
       static void println(long, int = DEC);
       static void println(unsigned long, int = DEC);
       static void println(double, int = 2);
-      static void println();
+      static void println(void);
       operator bool() { return true; }
 
     private:
@@ -275,6 +275,7 @@
 
 #endif // !USBCON
 
+
 #ifdef INTERNAL_SERIAL_PORT
   template <uint8_t serial>
   struct MarlinInternalSerialCfg {

Marlin/src/HAL/HAL_AVR/SanityCheck.h

@@ -0,0 +1,111 @@
+/**
+ * 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
+
+/**
+ * Test AVR specific configuration values for errors at compile-time.
+ */
+
+/**
+ * Digipot requirement
+ */
+ #if ENABLED(DIGIPOT_MCP4018)
+  #if !defined(DIGIPOTS_I2C_SDA_X) || !defined(DIGIPOTS_I2C_SDA_Y) || !defined(DIGIPOTS_I2C_SDA_Z) \
+    || !defined(DIGIPOTS_I2C_SDA_E0) || !defined(DIGIPOTS_I2C_SDA_E1)
+      #error "DIGIPOT_MCP4018 requires DIGIPOTS_I2C_SDA_* pins to be defined."
+  #endif
+#endif
+
+/**
+ * Checks for FAST PWM
+ */
+#if ENABLED(FAST_PWM_FAN) && (ENABLED(USE_OCR2A_AS_TOP) && defined(TCCR2))
+    #error "USE_OCR2A_AS_TOP does not apply to devices with a single output TIMER2"
+#endif
+
+/**
+ * Sanity checks for Spindle / Laser
+ */
+#if ENABLED(SPINDLE_LASER_ENABLE)
+  #if !PIN_EXISTS(SPINDLE_LASER_ENA)
+    #error "SPINDLE_LASER_ENABLE requires SPINDLE_LASER_ENA_PIN."
+  #elif SPINDLE_DIR_CHANGE && !PIN_EXISTS(SPINDLE_DIR)
+    #error "SPINDLE_DIR_PIN not defined."
+  #elif ENABLED(SPINDLE_LASER_PWM) && PIN_EXISTS(SPINDLE_LASER_PWM)
+    #if !(WITHIN(SPINDLE_LASER_PWM_PIN, 2, 13) || WITHIN(SPINDLE_LASER_PWM_PIN, 44, 46))
+      #error "SPINDLE_LASER_PWM_PIN not assigned to a PWM pin."
+    #elif SPINDLE_LASER_POWERUP_DELAY < 1
+      #error "SPINDLE_LASER_POWERUP_DELAY must be greater than 0."
+    #elif SPINDLE_LASER_POWERDOWN_DELAY < 1
+      #error "SPINDLE_LASER_POWERDOWN_DELAY must be greater than 0."
+    #elif !defined(SPINDLE_LASER_PWM_INVERT)
+      #error "SPINDLE_LASER_PWM_INVERT missing."
+    #elif !defined(SPEED_POWER_SLOPE) || !defined(SPEED_POWER_INTERCEPT) || !defined(SPEED_POWER_MIN) || !defined(SPEED_POWER_MAX)
+      #error "SPINDLE_LASER_PWM equation constant(s) missing."
+    #elif SPINDLE_LASER_PWM_PIN == 4 || WITHIN(SPINDLE_LASER_PWM_PIN, 11, 13)
+      #error "Counter/Timer for SPINDLE_LASER_PWM_PIN is used by a system interrupt."
+    #elif PIN_EXISTS(X_MAX) && X_MAX_PIN == SPINDLE_LASER_PWM_PIN
+      #error "SPINDLE_LASER_PWM pin is in use by X_MAX endstop."
+    #elif PIN_EXISTS(X_MIN) && X_MIN_PIN == SPINDLE_LASER_PWM_PIN
+      #error "SPINDLE_LASER_PWM pin is in use by X_MIN endstop."
+    #elif PIN_EXISTS(Z_STEP) && Z_STEP_PIN == SPINDLE_LASER_PWM_PIN
+      #error "SPINDLE_LASER_PWM pin in use by Z_STEP."
+    #elif NUM_SERVOS > 0 && (WITHIN(SPINDLE_LASER_PWM_PIN, 2, 3) || SPINDLE_LASER_PWM_PIN == 5)
+      #error "Counter/Timer for SPINDLE_LASER_PWM_PIN is used by the servo system."
+    #elif PIN_EXISTS(CASE_LIGHT) && SPINDLE_LASER_PWM_PIN == CASE_LIGHT_PIN
+      #error "SPINDLE_LASER_PWM_PIN is used by CASE_LIGHT_PIN."
+    #elif PIN_EXISTS(E0_AUTO_FAN) && SPINDLE_LASER_PWM_PIN == E0_AUTO_FAN_PIN
+      #error "SPINDLE_LASER_PWM_PIN is used by E0_AUTO_FAN_PIN."
+    #elif PIN_EXISTS(E1_AUTO_FAN) && SPINDLE_LASER_PWM_PIN == E1_AUTO_FAN_PIN
+      #error "SPINDLE_LASER_PWM_PIN is used by E1_AUTO_FAN_PIN."
+    #elif PIN_EXISTS(E2_AUTO_FAN) && SPINDLE_LASER_PWM_PIN == E2_AUTO_FAN_PIN
+      #error "SPINDLE_LASER_PWM_PIN is used by E2_AUTO_FAN_PIN."
+    #elif PIN_EXISTS(E3_AUTO_FAN) && SPINDLE_LASER_PWM_PIN == E3_AUTO_FAN_PIN
+      #error "SPINDLE_LASER_PWM_PIN is used by E3_AUTO_FAN_PIN."
+    #elif PIN_EXISTS(E4_AUTO_FAN) && SPINDLE_LASER_PWM_PIN == E4_AUTO_FAN_PIN
+      #error "SPINDLE_LASER_PWM_PIN is used by E4_AUTO_FAN_PIN."
+    #elif PIN_EXISTS(E5_AUTO_FAN) && SPINDLE_LASER_PWM_PIN == E5_AUTO_FAN_PIN
+      #error "SPINDLE_LASER_PWM_PIN is used by E5_AUTO_FAN_PIN."
+    #elif PIN_EXISTS(FAN) && SPINDLE_LASER_PWM_PIN == FAN_PIN
+      #error "SPINDLE_LASER_PWM_PIN is used by FAN_PIN."
+    #elif PIN_EXISTS(FAN1) && SPINDLE_LASER_PWM_PIN == FAN1_PIN
+      #error "SPINDLE_LASER_PWM_PIN is used by FAN1_PIN."
+    #elif PIN_EXISTS(FAN2) && SPINDLE_LASER_PWM_PIN == FAN2_PIN
+      #error "SPINDLE_LASER_PWM_PIN is used by FAN2_PIN."
+    #elif PIN_EXISTS(CONTROLLERFAN) && SPINDLE_LASER_PWM_PIN == CONTROLLERFAN_PIN
+      #error "SPINDLE_LASER_PWM_PIN is used by CONTROLLERFAN_PIN."
+    #elif PIN_EXISTS(MOTOR_CURRENT_PWM_XY) && SPINDLE_LASER_PWM_PIN == MOTOR_CURRENT_PWM_XY_PIN
+      #error "SPINDLE_LASER_PWM_PIN is used by MOTOR_CURRENT_PWM_XY."
+    #elif PIN_EXISTS(MOTOR_CURRENT_PWM_Z) && SPINDLE_LASER_PWM_PIN == MOTOR_CURRENT_PWM_Z_PIN
+      #error "SPINDLE_LASER_PWM_PIN is used by MOTOR_CURRENT_PWM_Z."
+    #elif PIN_EXISTS(MOTOR_CURRENT_PWM_E) && SPINDLE_LASER_PWM_PIN == MOTOR_CURRENT_PWM_E_PIN
+      #error "SPINDLE_LASER_PWM_PIN is used by MOTOR_CURRENT_PWM_E."
+    #endif
+  #endif
+#endif // SPINDLE_LASER_ENABLE
+
+/**
+ * The Trinamic library includes SoftwareSerial.h, leading to a compile error.
+ */
+#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

Marlin/src/HAL/HAL_AVR/ServoTimers.h

@@ -1,9 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
+ * 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
@@ -53,8 +53,8 @@
  * --------------------
  */
 
-#define TRIM_DURATION           2   // compensation ticks to trim adjust for digitalWrite delays
-#define SERVO_TIMER_PRESCALER   8   // timer prescaler
+#define TRIM_DURATION       2   // compensation ticks to trim adjust for digitalWrite delays
+#define PRESCALER           8   // timer prescaler
 
 // Say which 16 bit timers can be used and in what order
 #if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
@@ -75,16 +75,16 @@
 #endif
 
 typedef enum {
-  #ifdef _useTimer1
+  #if ENABLED(_useTimer1)
     _timer1,
   #endif
-  #ifdef _useTimer3
+  #if ENABLED(_useTimer3)
     _timer3,
   #endif
-  #ifdef _useTimer4
+  #if ENABLED(_useTimer4)
     _timer4,
   #endif
-  #ifdef _useTimer5
+  #if ENABLED(_useTimer5)
     _timer5,
   #endif
   _Nbr_16timers

Marlin/src/HAL/HAL_AVR/endstop_interrupts.h

@@ -1,9 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
+ * 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
@@ -36,12 +36,12 @@
  * (Located in Marlin/buildroot/share/pin_interrupt_test/pin_interrupt_test.ino)
  */
 
+#include "../../core/macros.h"
+#include <stdint.h>
 #include "../../module/endstops.h"
 
-#include <stdint.h>
-
 // One ISR for all EXT-Interrupts
-void endstop_ISR() { endstops.update(); }
+void endstop_ISR(void) { endstops.update(); }
 
 /**
  * Patch for pins_arduino.h (...\Arduino\hardware\arduino\avr\variants\mega\pins_arduino.h)
@@ -54,7 +54,7 @@ void endstop_ISR() { endstops.update(); }
   #undef  digitalPinToPCICR
   #define digitalPinToPCICR(p)    ( WITHIN(p, 10, 15) || \
                                     WITHIN(p, 50, 53) || \
-                                    WITHIN(p, 62, 69) ? &PCICR : nullptr )
+                                    WITHIN(p, 62, 69) ? &PCICR : (uint8_t*)0 )
   #undef  digitalPinToPCICRbit
   #define digitalPinToPCICRbit(p) ( WITHIN(p, 10, 13) || WITHIN(p, 50, 53) ? 0 : \
                                     WITHIN(p, 14, 15) ? 1 : \
@@ -64,7 +64,7 @@ void endstop_ISR() { endstops.update(); }
   #define digitalPinToPCMSK(p)    ( WITHIN(p, 10, 13) || WITHIN(p, 50, 53) ? &PCMSK0 : \
                                     WITHIN(p, 14, 15) ? &PCMSK1 : \
                                     WITHIN(p, 62, 69) ? &PCMSK2 : \
-                                    nullptr )
+                                    (uint8_t *)0 )
   #undef  digitalPinToPCMSKbit
   #define digitalPinToPCMSKbit(p) ( WITHIN(p, 10, 13) ? ((p) - 6) : \
                                     (p) == 14 || (p) == 51 ? 2 : \
@@ -78,11 +78,9 @@ void endstop_ISR() { endstops.update(); }
 
 // 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
-  }
+  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
@@ -102,125 +100,154 @@ void pciSetup(const int8_t pin) {
   ISR(PCINT3_vect, ISR_ALIASOF(PCINT0_vect));
 #endif
 
-void setup_endstop_interrupts() {
-  #define _ATTACH(P) attachInterrupt(digitalPinToInterrupt(P), endstop_ISR, CHANGE)
+void setup_endstop_interrupts( void ) {
+
   #if HAS_X_MAX
-    #if (digitalPinToInterrupt(X_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(X_MAX_PIN);
+    #if (digitalPinToInterrupt(X_MAX_PIN) != NOT_AN_INTERRUPT) // if pin has an external interrupt
+      attachInterrupt(digitalPinToInterrupt(X_MAX_PIN), endstop_ISR, CHANGE); // assign it
     #else
-      static_assert(digitalPinToPCICR(X_MAX_PIN), "X_MAX_PIN is not interrupt-capable");
-      pciSetup(X_MAX_PIN);
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(X_MAX_PIN) != NULL, "X_MAX_PIN is not interrupt-capable"); // if pin has no pin change interrupt - error
+      pciSetup(X_MAX_PIN);                                                            // assign it
     #endif
   #endif
+
   #if HAS_X_MIN
     #if (digitalPinToInterrupt(X_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(X_MIN_PIN);
+      attachInterrupt(digitalPinToInterrupt(X_MIN_PIN), endstop_ISR, CHANGE);
     #else
-      static_assert(digitalPinToPCICR(X_MIN_PIN), "X_MIN_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(X_MIN_PIN) != NULL, "X_MIN_PIN is not interrupt-capable");
       pciSetup(X_MIN_PIN);
     #endif
   #endif
+
   #if HAS_Y_MAX
     #if (digitalPinToInterrupt(Y_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Y_MAX_PIN);
+      attachInterrupt(digitalPinToInterrupt(Y_MAX_PIN), endstop_ISR, CHANGE);
     #else
-      static_assert(digitalPinToPCICR(Y_MAX_PIN), "Y_MAX_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Y_MAX_PIN) != NULL, "Y_MAX_PIN is not interrupt-capable");
       pciSetup(Y_MAX_PIN);
     #endif
   #endif
+
   #if HAS_Y_MIN
     #if (digitalPinToInterrupt(Y_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Y_MIN_PIN);
+      attachInterrupt(digitalPinToInterrupt(Y_MIN_PIN), endstop_ISR, CHANGE);
     #else
-      static_assert(digitalPinToPCICR(Y_MIN_PIN), "Y_MIN_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Y_MIN_PIN) != NULL, "Y_MIN_PIN is not interrupt-capable");
       pciSetup(Y_MIN_PIN);
     #endif
   #endif
+
   #if HAS_Z_MAX
     #if (digitalPinToInterrupt(Z_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z_MAX_PIN);
+      attachInterrupt(digitalPinToInterrupt(Z_MAX_PIN), endstop_ISR, CHANGE);
     #else
-      static_assert(digitalPinToPCICR(Z_MAX_PIN), "Z_MAX_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Z_MAX_PIN) != NULL, "Z_MAX_PIN is not interrupt-capable");
       pciSetup(Z_MAX_PIN);
     #endif
   #endif
+
   #if HAS_Z_MIN
     #if (digitalPinToInterrupt(Z_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z_MIN_PIN);
+      attachInterrupt(digitalPinToInterrupt(Z_MIN_PIN), endstop_ISR, CHANGE);
     #else
-      static_assert(digitalPinToPCICR(Z_MIN_PIN), "Z_MIN_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Z_MIN_PIN) != NULL, "Z_MIN_PIN is not interrupt-capable");
       pciSetup(Z_MIN_PIN);
     #endif
   #endif
+
   #if HAS_X2_MAX
     #if (digitalPinToInterrupt(X2_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(X2_MAX_PIN);
+      attachInterrupt(digitalPinToInterrupt(X2_MAX_PIN), endstop_ISR, CHANGE);
     #else
-      static_assert(digitalPinToPCICR(X2_MAX_PIN), "X2_MAX_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(X2_MAX_PIN) != NULL, "X2_MAX_PIN is not interrupt-capable");
       pciSetup(X2_MAX_PIN);
     #endif
   #endif
+
   #if HAS_X2_MIN
     #if (digitalPinToInterrupt(X2_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(X2_MIN_PIN);
+      attachInterrupt(digitalPinToInterrupt(X2_MIN_PIN), endstop_ISR, CHANGE);
     #else
-      static_assert(digitalPinToPCICR(X2_MIN_PIN), "X2_MIN_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(X2_MIN_PIN) != NULL, "X2_MIN_PIN is not interrupt-capable");
       pciSetup(X2_MIN_PIN);
     #endif
   #endif
+
   #if HAS_Y2_MAX
     #if (digitalPinToInterrupt(Y2_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Y2_MAX_PIN);
+      attachInterrupt(digitalPinToInterrupt(Y2_MAX_PIN), endstop_ISR, CHANGE);
     #else
-      static_assert(digitalPinToPCICR(Y2_MAX_PIN), "Y2_MAX_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Y2_MAX_PIN) != NULL, "Y2_MAX_PIN is not interrupt-capable");
       pciSetup(Y2_MAX_PIN);
     #endif
   #endif
+
   #if HAS_Y2_MIN
     #if (digitalPinToInterrupt(Y2_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Y2_MIN_PIN);
+      attachInterrupt(digitalPinToInterrupt(Y2_MIN_PIN), endstop_ISR, CHANGE);
     #else
-      static_assert(digitalPinToPCICR(Y2_MIN_PIN), "Y2_MIN_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Y2_MIN_PIN) != NULL, "Y2_MIN_PIN is not interrupt-capable");
       pciSetup(Y2_MIN_PIN);
     #endif
   #endif
+
   #if HAS_Z2_MAX
     #if (digitalPinToInterrupt(Z2_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z2_MAX_PIN);
+      attachInterrupt(digitalPinToInterrupt(Z2_MAX_PIN), endstop_ISR, CHANGE);
     #else
-      static_assert(digitalPinToPCICR(Z2_MAX_PIN), "Z2_MAX_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Z2_MAX_PIN) != NULL, "Z2_MAX_PIN is not interrupt-capable");
       pciSetup(Z2_MAX_PIN);
     #endif
   #endif
+
   #if HAS_Z2_MIN
     #if (digitalPinToInterrupt(Z2_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z2_MIN_PIN);
+      attachInterrupt(digitalPinToInterrupt(Z2_MIN_PIN), endstop_ISR, CHANGE);
     #else
-      static_assert(digitalPinToPCICR(Z2_MIN_PIN), "Z2_MIN_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Z2_MIN_PIN) != NULL, "Z2_MIN_PIN is not interrupt-capable");
       pciSetup(Z2_MIN_PIN);
     #endif
   #endif
+
   #if HAS_Z3_MAX
     #if (digitalPinToInterrupt(Z3_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z3_MAX_PIN);
+      attachInterrupt(digitalPinToInterrupt(Z3_MAX_PIN), endstop_ISR, CHANGE);
     #else
-      static_assert(digitalPinToPCICR(Z3_MAX_PIN), "Z3_MAX_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Z3_MAX_PIN) != NULL, "Z3_MAX_PIN is not interrupt-capable");
       pciSetup(Z3_MAX_PIN);
     #endif
   #endif
+
   #if HAS_Z3_MIN
     #if (digitalPinToInterrupt(Z3_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z3_MIN_PIN);
+      attachInterrupt(digitalPinToInterrupt(Z3_MIN_PIN), endstop_ISR, CHANGE);
     #else
-      static_assert(digitalPinToPCICR(Z3_MIN_PIN), "Z3_MIN_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Z3_MIN_PIN) != NULL, "Z3_MIN_PIN is not interrupt-capable");
       pciSetup(Z3_MIN_PIN);
     #endif
   #endif
+
   #if HAS_Z_MIN_PROBE_PIN
     #if (digitalPinToInterrupt(Z_MIN_PROBE_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z_MIN_PROBE_PIN);
+      attachInterrupt(digitalPinToInterrupt(Z_MIN_PROBE_PIN), endstop_ISR, CHANGE);
     #else
-      static_assert(digitalPinToPCICR(Z_MIN_PROBE_PIN), "Z_MIN_PROBE_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Z_MIN_PROBE_PIN) != NULL, "Z_MIN_PROBE_PIN is not interrupt-capable");
       pciSetup(Z_MIN_PROBE_PIN);
     #endif
   #endif

Marlin/src/HAL/HAL_AVR/fast_pwm.cpp

@@ -1,282 +1,250 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
 #ifdef __AVR__
 
 #include "../../inc/MarlinConfigPre.h"
-
-#if ENABLED(FAST_PWM_FAN)
-
-#include "HAL.h"
-
-struct Timer {
-  volatile uint8_t* TCCRnQ[3];  // max 3 TCCR registers per timer
-  volatile uint16_t* OCRnQ[3];  // max 3 OCR registers per timer
-  volatile uint16_t* ICRn;      // max 1 ICR register per timer
-  uint8_t n;                    // the timer number [0->5]
-  uint8_t q;                    // the timer output [0->2] (A->C)
-};
-
 /**
  * get_pwm_timer
- *  Get the timer information and register of the provided pin.
- *  Return a Timer struct containing this information.
+ *  Grabs timer information and registers of the provided pin
+ *  returns Timer struct containing this information
  *  Used by set_pwm_frequency, set_pwm_duty
+ *
  */
-Timer get_pwm_timer(const pin_t pin) {
-  uint8_t q = 0;
-  switch (digitalPinToTimer(pin)) {
-    // Protect reserved timers (TIMER0 & TIMER1)
-    #ifdef TCCR0A
-      #if !AVR_AT90USB1286_FAMILY
-        case TIMER0A:
+
+#if ENABLED(FAST_PWM_FAN)
+#include "HAL.h"
+
+  struct Timer {
+    volatile uint8_t* TCCRnQ[3];  // max 3 TCCR registers per timer
+    volatile uint16_t* OCRnQ[3];  // max 3 OCR registers per timer
+    volatile uint16_t* ICRn;      // max 1 ICR register per timer
+    uint8_t n;                    // the timer number [0->5]
+    uint8_t q;                    // the timer output [0->2] (A->C)
+  };
+
+  Timer get_pwm_timer(pin_t pin) {
+    uint8_t q = 0;
+    switch (digitalPinToTimer(pin)) {
+      // Protect reserved timers (TIMER0 & TIMER1)
+      #ifdef TCCR0A
+        #if !AVR_AT90USB1286_FAMILY
+          case TIMER0A:
+        #endif
+        case TIMER0B:
       #endif
-      case TIMER0B:
-    #endif
-    #ifdef TCCR1A
-      case TIMER1A: case TIMER1B:
-    #endif
-                                        break;
-    #if defined(TCCR2) || defined(TCCR2A)
-      #ifdef TCCR2
-        case TIMER2: {
-          Timer timer = {
-            /*TCCRnQ*/  { &TCCR2, nullptr, nullptr },
-            /*OCRnQ*/   { (uint16_t*)&OCR2, nullptr, nullptr },
-            /*ICRn*/      nullptr,
-            /*n, q*/      2, 0
-          };
-        }
-      #elif defined(TCCR2A)
-        #if ENABLED(USE_OCR2A_AS_TOP)
-          case TIMER2A:   break; // protect TIMER2A
-          case TIMER2B: {
+      #ifdef TCCR1A
+        case TIMER1A: case TIMER1B:
+      #endif
+                                          break;
+      #if defined(TCCR2) || defined(TCCR2A)
+        #ifdef TCCR2
+          case TIMER2: {
             Timer timer = {
-              /*TCCRnQ*/  { &TCCR2A,  &TCCR2B,  nullptr },
-              /*OCRnQ*/   { (uint16_t*)&OCR2A, (uint16_t*)&OCR2B, nullptr },
-              /*ICRn*/      nullptr,
-              /*n, q*/      2, 1
+              /*TCCRnQ*/  { &TCCR2, NULL, NULL},
+              /*OCRnQ*/   { (uint16_t*)&OCR2, NULL, NULL},
+              /*ICRn*/      NULL,
+              /*n, q*/      2, 0
             };
-            return timer;
-          }
-        #else
-          case TIMER2B:   ++q;
-          case TIMER2A: {
-            Timer timer = {
-              /*TCCRnQ*/  { &TCCR2A,  &TCCR2B,  nullptr },
-              /*OCRnQ*/   { (uint16_t*)&OCR2A, (uint16_t*)&OCR2B, nullptr },
-              /*ICRn*/      nullptr,
-                            2, q
-            };
-            return timer;
           }
+        #elif defined TCCR2A
+          #if ENABLED(USE_OCR2A_AS_TOP)
+            case TIMER2A:   break; // protect TIMER2A
+            case TIMER2B: {
+              Timer timer = {
+                /*TCCRnQ*/  { &TCCR2A,  &TCCR2B,  NULL},
+                /*OCRnQ*/   { (uint16_t*)&OCR2A, (uint16_t*)&OCR2B, NULL},
+                /*ICRn*/      NULL,
+                /*n, q*/      2, 1
+              };
+              return timer;
+            }
+          #else
+            case TIMER2B:   ++q;
+            case TIMER2A: {
+              Timer timer = {
+                /*TCCRnQ*/  { &TCCR2A,  &TCCR2B,  NULL},
+                /*OCRnQ*/   { (uint16_t*)&OCR2A, (uint16_t*)&OCR2B, NULL},
+                /*ICRn*/      NULL,
+                              2, q
+              };
+              return timer;
+            }
+          #endif
         #endif
       #endif
-    #endif
-    #ifdef OCR3C
-      case TIMER3C:   ++q;
-      case TIMER3B:   ++q;
-      case TIMER3A: {
-        Timer timer = {
-          /*TCCRnQ*/  { &TCCR3A,  &TCCR3B,  &TCCR3C },
-          /*OCRnQ*/   { &OCR3A,   &OCR3B,   &OCR3C },
-          /*ICRn*/      &ICR3,
-          /*n, q*/      3, q
-        };
-        return timer;
-      }
-    #elif defined(OCR3B)
-      case TIMER3B:   ++q;
-      case TIMER3A: {
-        Timer timer = {
-          /*TCCRnQ*/  { &TCCR3A,  &TCCR3B,  nullptr },
-          /*OCRnQ*/   { &OCR3A,   &OCR3B,  nullptr },
-          /*ICRn*/      &ICR3,
-          /*n, q*/      3, q
-        };
-        return timer;
-      }
-    #endif
-    #ifdef TCCR4A
-      case TIMER4C:   ++q;
-      case TIMER4B:   ++q;
-      case TIMER4A: {
-        Timer timer = {
-          /*TCCRnQ*/  { &TCCR4A,  &TCCR4B,  &TCCR4C },
-          /*OCRnQ*/   { &OCR4A,   &OCR4B,   &OCR4C },
-          /*ICRn*/      &ICR4,
-          /*n, q*/      4, q
-        };
-        return timer;
-      }
-    #endif
-    #ifdef TCCR5A
-      case TIMER5C:   ++q;
-      case TIMER5B:   ++q;
-      case TIMER5A: {
-        Timer timer = {
-          /*TCCRnQ*/  { &TCCR5A,  &TCCR5B,  &TCCR5C },
-          /*OCRnQ*/   { &OCR5A,   &OCR5B,   &OCR5C },
-          /*ICRn*/      &ICR5,
-          /*n, q*/      5, q
-        };
-        return timer;
-      }
-    #endif
+      #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;
+        }
+      #endif
+      #ifdef TCCR4A
+        case TIMER4C:   ++q;
+        case TIMER4B:   ++q;
+        case TIMER4A: {
+          Timer timer = {
+            /*TCCRnQ*/  { &TCCR4A,  &TCCR4B,  &TCCR4C},
+            /*OCRnQ*/   { &OCR4A,   &OCR4B,   &OCR4C},
+            /*ICRn*/      &ICR4,
+            /*n, q*/      4, q
+          };
+          return timer;
+        }
+      #endif
+      #ifdef TCCR5A
+        case TIMER5C:   ++q;
+        case TIMER5B:   ++q;
+        case TIMER5A: {
+          Timer timer = {
+            /*TCCRnQ*/  { &TCCR5A,  &TCCR5B,  &TCCR5C},
+            /*OCRnQ*/   { &OCR5A,   &OCR5B,   &OCR5C },
+            /*ICRn*/      &ICR5,
+            /*n, q*/      5, q
+          };
+          return timer;
+        }
+      #endif
+    }
+    Timer timer = {
+        /*TCCRnQ*/  { NULL, NULL, NULL},
+        /*OCRnQ*/   { NULL, NULL, NULL},
+        /*ICRn*/      NULL,
+                      0, 0
+    };
+    return timer;
   }
-  Timer timer = {
-      /*TCCRnQ*/  { nullptr, nullptr, nullptr },
-      /*OCRnQ*/   { nullptr, nullptr, nullptr },
-      /*ICRn*/      nullptr,
-                    0, 0
-  };
-  return timer;
-}
 
-void set_pwm_frequency(const pin_t pin, int f_desired) {
-  Timer timer = get_pwm_timer(pin);
-  if (timer.n == 0) return; // Don't proceed if protected timer or not recognised
-  uint16_t size;
-  if (timer.n == 2) size = 255; else size = 65535;
+  void set_pwm_frequency(const pin_t pin, int f_desired) {
+    Timer timer = get_pwm_timer(pin);
+    if (timer.n == 0) return; // Don't proceed if protected timer or not recognised
+    uint16_t size;
+    if (timer.n == 2) size = 255; else size = 65535;
 
-  uint16_t res = 255;   // resolution (TOP value)
-  uint8_t j = 0;        // prescaler index
-  uint8_t wgm = 1;      // waveform generation mode
+    uint16_t res = 255;   // resolution (TOP value)
+    uint8_t j = 0;        // prescaler index
+    uint8_t wgm = 1;      // waveform generation mode
 
-  // Calculating the prescaler and resolution to use to achieve closest frequency
-  if (f_desired != 0) {
-    int f = (F_CPU) / (2 * 1024 * size) + 1; // Initialize frequency as lowest (non-zero) achievable
-    uint16_t prescaler[] = { 0, 1, 8, /*TIMER2 ONLY*/32, 64, /*TIMER2 ONLY*/128, 256, 1024 };
+    // Calculating the prescaler and resolution to use to achieve closest frequency
+    if (f_desired != 0) {
+      int f = (F_CPU) / (2 * 1024 * size) + 1; // Initialize frequency as lowest (non-zero) achievable
+      uint16_t prescaler[] = { 0, 1, 8, /*TIMER2 ONLY*/32, 64, /*TIMER2 ONLY*/128, 256, 1024 };
 
-    // loop over prescaler values
-    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
-        #if ENABLED(USE_OCR2A_AS_TOP)
+      // loop over prescaler values
+      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
+          #if ENABLED(USE_OCR2A_AS_TOP)
+            const uint16_t rtf = (F_CPU) / (prescaler[i] * f_desired);
+            res_temp_fast = rtf - 1;
+            res_temp_phase_correct = rtf / 2;
+          #endif
+        }
+        else {
+          // Skip TIMER2 specific prescalers when not TIMER2
+          if (i == 3 || i == 5) continue;
           const uint16_t rtf = (F_CPU) / (prescaler[i] * f_desired);
           res_temp_fast = rtf - 1;
           res_temp_phase_correct = rtf / 2;
-        #endif
-      }
-      else {
-        // Skip TIMER2 specific prescalers when not TIMER2
-        if (i == 3 || i == 5) continue;
-        const uint16_t rtf = (F_CPU) / (prescaler[i] * f_desired);
-        res_temp_fast = rtf - 1;
-        res_temp_phase_correct = rtf / 2;
-      }
-
-      LIMIT(res_temp_fast, 1u, size);
-      LIMIT(res_temp_phase_correct, 1u, size);
-      // Calculate frequencies of test prescaler and resolution values
-      const int f_temp_fast = (F_CPU) / (prescaler[i] * (1 + res_temp_fast)),
-                f_temp_phase_correct = (F_CPU) / (2 * prescaler[i] * res_temp_phase_correct),
-                f_diff = ABS(f - f_desired),
-                f_fast_diff = ABS(f_temp_fast - f_desired),
-                f_phase_diff = ABS(f_temp_phase_correct - f_desired);
-
-      // If FAST values are closest to desired f
-      if (f_fast_diff < f_diff && f_fast_diff <= f_phase_diff) {
-        // Remember this combination
-        f = f_temp_fast;
-        res = res_temp_fast;
-        j = i;
-        // Set the Wave Generation Mode to FAST PWM
-        if (timer.n == 2) {
-          wgm = (
-            #if ENABLED(USE_OCR2A_AS_TOP)
-              WGM2_FAST_PWM_OCR2A
-            #else
-              WGM2_FAST_PWM
-            #endif
-          );
         }
-        else wgm = WGM_FAST_PWM_ICRn;
-      }
-      // If PHASE CORRECT values are closes to desired f
-      else if (f_phase_diff < f_diff) {
-        f = f_temp_phase_correct;
-        res = res_temp_phase_correct;
-        j = i;
-        // Set the Wave Generation Mode to PWM PHASE CORRECT
-        if (timer.n == 2) {
-          wgm = (
-            #if ENABLED(USE_OCR2A_AS_TOP)
-              WGM2_PWM_PC_OCR2A
-            #else
-              WGM2_PWM_PC
-            #endif
-          );
+
+        LIMIT(res_temp_fast, 1u, size);
+        LIMIT(res_temp_phase_correct, 1u, size);
+        // Calculate frequencies of test prescaler and resolution values
+        const int f_temp_fast = (F_CPU) / (prescaler[i] * (1 + res_temp_fast)),
+                  f_temp_phase_correct = (F_CPU) / (2 * prescaler[i] * res_temp_phase_correct),
+                  f_diff = ABS(f - f_desired),
+                  f_fast_diff = ABS(f_temp_fast - f_desired),
+                  f_phase_diff = ABS(f_temp_phase_correct - f_desired);
+
+        // If FAST values are closest to desired f
+        if (f_fast_diff < f_diff && f_fast_diff <= f_phase_diff) {
+          // Remember this combination
+          f = f_temp_fast;
+          res = res_temp_fast;
+          j = i;
+          // Set the Wave Generation Mode to FAST PWM
+          if (timer.n == 2) {
+            wgm = (
+              #if ENABLED(USE_OCR2A_AS_TOP)
+                WGM2_FAST_PWM_OCR2A
+              #else
+                WGM2_FAST_PWM
+              #endif
+            );
+          }
+          else wgm = WGM_FAST_PWM_ICRn;
+        }
+        // If PHASE CORRECT values are closes to desired f
+        else if (f_phase_diff < f_diff) {
+          f = f_temp_phase_correct;
+          res = res_temp_phase_correct;
+          j = i;
+          // Set the Wave Generation Mode to PWM PHASE CORRECT
+          if (timer.n == 2) {
+            wgm = (
+              #if ENABLED(USE_OCR2A_AS_TOP)
+                WGM2_PWM_PC_OCR2A
+              #else
+                WGM2_PWM_PC
+              #endif
+            );
+          }
+          else wgm = WGM_PWM_PC_ICRn;
         }
-        else wgm = WGM_PWM_PC_ICRn;
       }
     }
-  }
-  _SET_WGMnQ(timer.TCCRnQ, wgm);
-  _SET_CSn(timer.TCCRnQ, j);
+    _SET_WGMnQ(timer.TCCRnQ, wgm);
+    _SET_CSn(timer.TCCRnQ, j);
 
-  if (timer.n == 2) {
-    #if ENABLED(USE_OCR2A_AS_TOP)
-      _SET_OCRnQ(timer.OCRnQ, 0, res);  // Set OCR2A value (TOP) = res
-    #endif
-  }
-  else
-    _SET_ICRn(timer.ICRn, res);         // Set ICRn value (TOP) = res
-}
-
-void set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size/*=255*/, const bool invert/*=false*/) {
-  // If v is 0 or v_size (max), digitalWrite to LOW or HIGH.
-  // Note that digitalWrite also disables pwm output for us (sets COM bit to 0)
-  if (v == 0)
-    digitalWrite(pin, invert);
-  else if (v == v_size)
-    digitalWrite(pin, !invert);
-  else {
-    Timer timer = get_pwm_timer(pin);
-    if (timer.n == 0) return; // Don't proceed if protected timer or not recognised
-    // Set compare output mode to CLEAR -> SET or SET -> CLEAR (if inverted)
-    _SET_COMnQ(timer.TCCRnQ, (timer.q
-        #ifdef TCCR2
-          + (timer.q == 2) // COM20 is on bit 4 of TCCR2, thus requires q + 1 in the macro
-        #endif
-      ), COM_CLEAR_SET + invert
-    );
-
-    uint16_t top;
-    if (timer.n == 2) { // if TIMER2
-      top = (
-        #if ENABLED(USE_OCR2A_AS_TOP)
-          *timer.OCRnQ[0] // top = OCR2A
-        #else
-          255 // top = 0xFF (max)
-        #endif
-      );
+    if (timer.n == 2) {
+      #if ENABLED(USE_OCR2A_AS_TOP)
+        _SET_OCRnQ(timer.OCRnQ, 0, res);  // Set OCR2A value (TOP) = res
+      #endif
     }
     else
-      top = *timer.ICRn; // top = ICRn
-
-    _SET_OCRnQ(timer.OCRnQ, timer.q, v * float(top / v_size)); // Scale 8/16-bit v to top value
+      _SET_ICRn(timer.ICRn, res);         // Set ICRn value (TOP) = res
+  }
+
+  void set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size/*=255*/, const bool invert/*=false*/) {
+    // If v is 0 or v_size (max), digitalWrite to LOW or HIGH.
+    // Note that digitalWrite also disables pwm output for us (sets COM bit to 0)
+    if (v == 0)
+      digitalWrite(pin, invert);
+    else if (v == v_size)
+      digitalWrite(pin, !invert);
+    else {
+      Timer timer = get_pwm_timer(pin);
+      if (timer.n == 0) return; // Don't proceed if protected timer or not recognised
+      // Set compare output mode to CLEAR -> SET or SET -> CLEAR (if inverted)
+      _SET_COMnQ(timer.TCCRnQ, (timer.q
+          #ifdef TCCR2
+            + (timer.q == 2) // COM20 is on bit 4 of TCCR2, thus requires q + 1 in the macro
+          #endif
+        ), COM_CLEAR_SET + invert
+      );
+
+      uint16_t top;
+      if (timer.n == 2) { // if TIMER2
+        top = (
+          #if ENABLED(USE_OCR2A_AS_TOP)
+            *timer.OCRnQ[0] // top = OCR2A
+          #else
+            255 // top = 0xFF (max)
+          #endif
+        );
+      }
+      else
+        top = *timer.ICRn; // top = ICRn
+
+      _SET_OCRnQ(timer.OCRnQ, timer.q, v * float(top / v_size)); // Scale 8/16-bit v to top value
+    }
   }
-}
 
 #endif // FAST_PWM_FAN
 #endif // __AVR__

Marlin/src/HAL/HAL_AVR/fastio_1281.h

@@ -1,9 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
+ * 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
@@ -28,7 +28,7 @@
  *   Port:        A0 A1 A2 A3 A4 A5 A6 A7 B0 B1 B2 B3 B4 B5 B6 B7 C0 C1 C2 C3 C4 C5 C6 C7 D0 D1 D2 D3 D4 D5 D6 D7 E0 E1 E2 E3 E4 E5 E6 E7 F0 F1 F2 F3 F4 F5 F6 F7 G0 G1 G2 G3 G4 G5
  */
 
-#include "../fastio.h"
+#include "fastio_AVR.h"
 
 // change for your board
 #define DEBUG_LED   DIO46
@@ -63,13 +63,13 @@
 #define DIO0_RPORT  PINE
 #define DIO0_WPORT  PORTE
 #define DIO0_DDR    DDRE
-#define DIO0_PWM    nullptr
+#define DIO0_PWM    NULL
 
 #define DIO1_PIN    PINE1
 #define DIO1_RPORT  PINE
 #define DIO1_WPORT  PORTE
 #define DIO1_DDR    DDRE
-#define DIO1_PWM    nullptr
+#define DIO1_PWM    NULL
 
 #define DIO2_PIN    PINE4
 #define DIO2_RPORT  PINE
@@ -123,339 +123,339 @@
 #define DIO10_RPORT PINB
 #define DIO10_WPORT PORTB
 #define DIO10_DDR   DDRB
-#define DIO10_PWM   nullptr
+#define DIO10_PWM   NULL
 
 #define DIO11_PIN   PINB2
 #define DIO11_RPORT PINB
 #define DIO11_WPORT PORTB
 #define DIO11_DDR   DDRB
-#define DIO11_PWM   nullptr
+#define DIO11_PWM   NULL
 
 #define DIO12_PIN   PINB3
 #define DIO12_RPORT PINB
 #define DIO12_WPORT PORTB
 #define DIO12_DDR   DDRB
-#define DIO12_PWM   nullptr
+#define DIO12_PWM   NULL
 
 #define DIO13_PIN   PINE2
 #define DIO13_RPORT PINE
 #define DIO13_WPORT PORTE
 #define DIO13_DDR   DDRE
-#define DIO13_PWM   nullptr
+#define DIO13_PWM   NULL
 
 #define DIO14_PIN   PINE6
 #define DIO14_RPORT PINE
 #define DIO14_WPORT PORTE
 #define DIO14_DDR   DDRE
-#define DIO14_PWM   nullptr
+#define DIO14_PWM   NULL
 
 #define DIO15_PIN   PINE7
 #define DIO15_RPORT PINE
 #define DIO15_WPORT PORTE
 #define DIO15_DDR   DDRE
-#define DIO15_PWM   nullptr
+#define DIO15_PWM   NULL
 
 #define DIO16_PIN   PINB0
 #define DIO16_RPORT PINB
 #define DIO16_WPORT PORTB
 #define DIO16_DDR   DDRB
-#define DIO16_PWM   nullptr
+#define DIO16_PWM   NULL
 
 #define DIO17_PIN   PIND0
 #define DIO17_RPORT PIND
 #define DIO17_WPORT PORTD
 #define DIO17_DDR   DDRD
-#define DIO17_PWM   nullptr
+#define DIO17_PWM   NULL
 
 #define DIO18_PIN   PIND1
 #define DIO18_RPORT PIND
 #define DIO18_WPORT PORTD
 #define DIO18_DDR   DDRD
-#define DIO18_PWM   nullptr
+#define DIO18_PWM   NULL
 
 #define DIO19_PIN   PIND2
 #define DIO19_RPORT PIND
 #define DIO19_WPORT PORTD
 #define DIO19_DDR   DDRD
-#define DIO19_PWM   nullptr
+#define DIO19_PWM   NULL
 
 #define DIO20_PIN   PIND3
 #define DIO20_RPORT PIND
 #define DIO20_WPORT PORTD
 #define DIO20_DDR   DDRD
-#define DIO20_PWM   nullptr
+#define DIO20_PWM   NULL
 
 #define DIO21_PIN   PIND4
 #define DIO21_RPORT PIND
 #define DIO21_WPORT PORTD
 #define DIO21_DDR   DDRD
-#define DIO21_PWM   nullptr
+#define DIO21_PWM   NULL
 
 #define DIO22_PIN   PIND5
 #define DIO22_RPORT PIND
 #define DIO22_WPORT PORTD
 #define DIO22_DDR   DDRD
-#define DIO22_PWM   nullptr
+#define DIO22_PWM   NULL
 
 #define DIO23_PIN   PIND6
 #define DIO23_RPORT PIND
 #define DIO23_WPORT PORTD
 #define DIO23_DDR   DDRD
-#define DIO23_PWM   nullptr
+#define DIO23_PWM   NULL
 
 #define DIO24_PIN   PIND7
 #define DIO24_RPORT PIND
 #define DIO24_WPORT PORTD
 #define DIO24_DDR   DDRD
-#define DIO24_PWM   nullptr
+#define DIO24_PWM   NULL
 
 #define DIO25_PIN   PING0
 #define DIO25_RPORT PING
 #define DIO25_WPORT PORTG
 #define DIO25_DDR   DDRG
-#define DIO25_PWM   nullptr
+#define DIO25_PWM   NULL
 
 #define DIO26_PIN   PING1
 #define DIO26_RPORT PING
 #define DIO26_WPORT PORTG
 #define DIO26_DDR   DDRG
-#define DIO26_PWM   nullptr
+#define DIO26_PWM   NULL
 
 #define DIO27_PIN   PING2
 #define DIO27_RPORT PING
 #define DIO27_WPORT PORTG
 #define DIO27_DDR   DDRG
-#define DIO27_PWM   nullptr
+#define DIO27_PWM   NULL
 
 #define DIO28_PIN   PING3
 #define DIO28_RPORT PING
 #define DIO28_WPORT PORTG
 #define DIO28_DDR   DDRG
-#define DIO28_PWM   nullptr
+#define DIO28_PWM   NULL
 
 #define DIO29_PIN   PING4
 #define DIO29_RPORT PING
 #define DIO29_WPORT PORTG
 #define DIO29_DDR   DDRG
-#define DIO29_PWM   nullptr
+#define DIO29_PWM   NULL
 
 #define DIO30_PIN   PINC0
 #define DIO30_RPORT PINC
 #define DIO30_WPORT PORTC
 #define DIO30_DDR   DDRC
-#define DIO30_PWM   nullptr
+#define DIO30_PWM   NULL
 
 #define DIO31_PIN   PINC1
 #define DIO31_RPORT PINC
 #define DIO31_WPORT PORTC
 #define DIO31_DDR   DDRC
-#define DIO31_PWM   nullptr
+#define DIO31_PWM   NULL
 
 #define DIO32_PIN   PINC2
 #define DIO32_RPORT PINC
 #define DIO32_WPORT PORTC
 #define DIO32_DDR   DDRC
-#define DIO32_PWM   nullptr
+#define DIO32_PWM   NULL
 
 #define DIO33_PIN   PINC3
 #define DIO33_RPORT PINC
 #define DIO33_WPORT PORTC
 #define DIO33_DDR   DDRC
-#define DIO33_PWM   nullptr
+#define DIO33_PWM   NULL
 
 #define DIO34_PIN   PINC4
 #define DIO34_RPORT PINC
 #define DIO34_WPORT PORTC
 #define DIO34_DDR   DDRC
-#define DIO34_PWM   nullptr
+#define DIO34_PWM   NULL
 
 #define DIO35_PIN   PINC5
 #define DIO35_RPORT PINC
 #define DIO35_WPORT PORTC
 #define DIO35_DDR   DDRC
-#define DIO35_PWM   nullptr
+#define DIO35_PWM   NULL
 
 #define DIO36_PIN   PINC6
 #define DIO36_RPORT PINC
 #define DIO36_WPORT PORTC
 #define DIO36_DDR   DDRC
-#define DIO36_PWM   nullptr
+#define DIO36_PWM   NULL
 
 #define DIO37_PIN   PINC7
 #define DIO37_RPORT PINC
 #define DIO37_WPORT PORTC
 #define DIO37_DDR   DDRC
-#define DIO37_PWM   nullptr
+#define DIO37_PWM   NULL
 
 #define DIO38_PIN   PINA0
 #define DIO38_RPORT PINA
 #define DIO38_WPORT PORTA
 #define DIO38_DDR   DDRA
-#define DIO38_PWM   nullptr
+#define DIO38_PWM   NULL
 
 #define DIO39_PIN   PINA1
 #define DIO39_RPORT PINA
 #define DIO39_WPORT PORTA
 #define DIO39_DDR   DDRA
-#define DIO39_PWM   nullptr
+#define DIO39_PWM   NULL
 
 #define DIO40_PIN   PINA2
 #define DIO40_RPORT PINA
 #define DIO40_WPORT PORTA
 #define DIO40_DDR   DDRA
-#define DIO40_PWM   nullptr
+#define DIO40_PWM   NULL
 
 #define DIO41_PIN   PINA3
 #define DIO41_RPORT PINA
 #define DIO41_WPORT PORTA
 #define DIO41_DDR   DDRA
-#define DIO41_PWM   nullptr
+#define DIO41_PWM   NULL
 
 #define DIO42_PIN   PINA4
 #define DIO42_RPORT PINA
 #define DIO42_WPORT PORTA
 #define DIO42_DDR   DDRA
-#define DIO42_PWM   nullptr
+#define DIO42_PWM   NULL
 
 #define DIO43_PIN   PINA5
 #define DIO43_RPORT PINA
 #define DIO43_WPORT PORTA
 #define DIO43_DDR   DDRA
-#define DIO43_PWM   nullptr
+#define DIO43_PWM   NULL
 
 #define DIO44_PIN   PINA6
 #define DIO44_RPORT PINA
 #define DIO44_WPORT PORTA
 #define DIO44_DDR   DDRA
-#define DIO44_PWM   nullptr
+#define DIO44_PWM   NULL
 
 #define DIO45_PIN   PINA7
 #define DIO45_RPORT PINA
 #define DIO45_WPORT PORTA
 #define DIO45_DDR   DDRA
-#define DIO45_PWM   nullptr
+#define DIO45_PWM   NULL
 
 #define DIO46_PIN   PINF0
 #define DIO46_RPORT PINF
 #define DIO46_WPORT PORTF
 #define DIO46_DDR   DDRF
-#define DIO46_PWM   nullptr
+#define DIO46_PWM   NULL
 
 #define DIO47_PIN   PINF1
 #define DIO47_RPORT PINF
 #define DIO47_WPORT PORTF
 #define DIO47_DDR   DDRF
-#define DIO47_PWM   nullptr
+#define DIO47_PWM   NULL
 
 #define DIO48_PIN   PINF2
 #define DIO48_RPORT PINF
 #define DIO48_WPORT PORTF
 #define DIO48_DDR   DDRF
-#define DIO48_PWM   nullptr
+#define DIO48_PWM   NULL
 
 #define DIO49_PIN   PINF3
 #define DIO49_RPORT PINF
 #define DIO49_WPORT PORTF
 #define DIO49_DDR   DDRF
-#define DIO49_PWM   nullptr
+#define DIO49_PWM   NULL
 
 #define DIO50_PIN   PINF4
 #define DIO50_RPORT PINF
 #define DIO50_WPORT PORTF
 #define DIO50_DDR   DDRF
-#define DIO50_PWM   nullptr
+#define DIO50_PWM   NULL
 
 #define DIO51_PIN   PINF5
 #define DIO51_RPORT PINF
 #define DIO51_WPORT PORTF
 #define DIO51_DDR   DDRF
-#define DIO51_PWM   nullptr
+#define DIO51_PWM   NULL
 
 #define DIO52_PIN   PINF6
 #define DIO52_RPORT PINF
 #define DIO52_WPORT PORTF
 #define DIO52_DDR   DDRF
-#define DIO52_PWM   nullptr
+#define DIO52_PWM   NULL
 
 #define DIO53_PIN   PINF7
 #define DIO53_RPORT PINF
 #define DIO53_WPORT PORTF
 #define DIO53_DDR   DDRF
-#define DIO53_PWM   nullptr
+#define DIO53_PWM   NULL
 
 #undef PA0
 #define PA0_PIN     PINA0
 #define PA0_RPORT   PINA
 #define PA0_WPORT   PORTA
 #define PA0_DDR     DDRA
-#define PA0_PWM     nullptr
+#define PA0_PWM     NULL
 #undef PA1
 #define PA1_PIN     PINA1
 #define PA1_RPORT   PINA
 #define PA1_WPORT   PORTA
 #define PA1_DDR     DDRA
-#define PA1_PWM     nullptr
+#define PA1_PWM     NULL
 #undef PA2
 #define PA2_PIN     PINA2
 #define PA2_RPORT   PINA
 #define PA2_WPORT   PORTA
 #define PA2_DDR     DDRA
-#define PA2_PWM     nullptr
+#define PA2_PWM     NULL
 #undef PA3
 #define PA3_PIN     PINA3
 #define PA3_RPORT   PINA
 #define PA3_WPORT   PORTA
 #define PA3_DDR     DDRA
-#define PA3_PWM     nullptr
+#define PA3_PWM     NULL
 #undef PA4
 #define PA4_PIN     PINA4
 #define PA4_RPORT   PINA
 #define PA4_WPORT   PORTA
 #define PA4_DDR     DDRA
-#define PA4_PWM     nullptr
+#define PA4_PWM     NULL
 #undef PA5
 #define PA5_PIN     PINA5
 #define PA5_RPORT   PINA
 #define PA5_WPORT   PORTA
 #define PA5_DDR     DDRA
-#define PA5_PWM     nullptr
+#define PA5_PWM     NULL
 #undef PA6
 #define PA6_PIN     PINA6
 #define PA6_RPORT   PINA
 #define PA6_WPORT   PORTA
 #define PA6_DDR     DDRA
-#define PA6_PWM     nullptr
+#define PA6_PWM     NULL
 #undef PA7
 #define PA7_PIN     PINA7
 #define PA7_RPORT   PINA
 #define PA7_WPORT   PORTA
 #define PA7_DDR     DDRA
-#define PA7_PWM     nullptr
+#define PA7_PWM     NULL
 
 #undef PB0
 #define PB0_PIN     PINB0
 #define PB0_RPORT   PINB
 #define PB0_WPORT   PORTB
 #define PB0_DDR     DDRB
-#define PB0_PWM     nullptr
+#define PB0_PWM     NULL
 #undef PB1
 #define PB1_PIN     PINB1
 #define PB1_RPORT   PINB
 #define PB1_WPORT   PORTB
 #define PB1_DDR     DDRB
-#define PB1_PWM     nullptr
+#define PB1_PWM     NULL
 #undef PB2
 #define PB2_PIN     PINB2
 #define PB2_RPORT   PINB
 #define PB2_WPORT   PORTB
 #define PB2_DDR     DDRB
-#define PB2_PWM     nullptr
+#define PB2_PWM     NULL
 #undef PB3
 #define PB3_PIN     PINB3
 #define PB3_RPORT   PINB
 #define PB3_WPORT   PORTB
 #define PB3_DDR     DDRB
-#define PB3_PWM     nullptr
+#define PB3_PWM     NULL
 #undef PB4
 #define PB4_PIN     PINB4
 #define PB4_RPORT   PINB
@@ -467,13 +467,13 @@
 #define PB5_RPORT   PINB
 #define PB5_WPORT   PORTB
 #define PB5_DDR     DDRB
-#define PB5_PWM     nullptr
+#define PB5_PWM     NULL
 #undef PB6
 #define PB6_PIN     PINB6
 #define PB6_RPORT   PINB
 #define PB6_WPORT   PORTB
 #define PB6_DDR     DDRB
-#define PB6_PWM     nullptr
+#define PB6_PWM     NULL
 #undef PB7
 #define PB7_PIN     PINB7
 #define PB7_RPORT   PINB
@@ -486,117 +486,117 @@
 #define PC0_RPORT   PINC
 #define PC0_WPORT   PORTC
 #define PC0_DDR     DDRC
-#define PC0_PWM     nullptr
+#define PC0_PWM     NULL
 #undef PC1
 #define PC1_PIN     PINC1
 #define PC1_RPORT   PINC
 #define PC1_WPORT   PORTC
 #define PC1_DDR     DDRC
-#define PC1_PWM     nullptr
+#define PC1_PWM     NULL
 #undef PC2
 #define PC2_PIN     PINC2
 #define PC2_RPORT   PINC
 #define PC2_WPORT   PORTC
 #define PC2_DDR     DDRC
-#define PC2_PWM     nullptr
+#define PC2_PWM     NULL
 #undef PC3
 #define PC3_PIN     PINC3
 #define PC3_RPORT   PINC
 #define PC3_WPORT   PORTC
 #define PC3_DDR     DDRC
-#define PC3_PWM     nullptr
+#define PC3_PWM     NULL
 #undef PC4
 #define PC4_PIN     PINC4
 #define PC4_RPORT   PINC
 #define PC4_WPORT   PORTC
 #define PC4_DDR     DDRC
-#define PC4_PWM     nullptr
+#define PC4_PWM     NULL
 #undef PC5
 #define PC5_PIN     PINC5
 #define PC5_RPORT   PINC
 #define PC5_WPORT   PORTC
 #define PC5_DDR     DDRC
-#define PC5_PWM     nullptr
+#define PC5_PWM     NULL
 #undef PC6
 #define PC6_PIN     PINC6
 #define PC6_RPORT   PINC
 #define PC6_WPORT   PORTC
 #define PC6_DDR     DDRC
-#define PC6_PWM     nullptr
+#define PC6_PWM     NULL
 #undef PC7
 #define PC7_PIN     PINC7
 #define PC7_RPORT   PINC
 #define PC7_WPORT   PORTC
 #define PC7_DDR     DDRC
-#define PC7_PWM     nullptr
+#define PC7_PWM     NULL
 
 #undef PD0
 #define PD0_PIN     PIND0
 #define PD0_RPORT   PIND
 #define PD0_WPORT   PORTD
 #define PD0_DDR     DDRD
-#define PD0_PWM     nullptr
+#define PD0_PWM     NULL
 #undef PD1
 #define PD1_PIN     PIND1
 #define PD1_RPORT   PIND
 #define PD1_WPORT   PORTD
 #define PD1_DDR     DDRD
-#define PD1_PWM     nullptr
+#define PD1_PWM     NULL
 #undef PD2
 #define PD2_PIN     PIND2
 #define PD2_RPORT   PIND
 #define PD2_WPORT   PORTD
 #define PD2_DDR     DDRD
-#define PD2_PWM     nullptr
+#define PD2_PWM     NULL
 #undef PD3
 #define PD3_PIN     PIND3
 #define PD3_RPORT   PIND
 #define PD3_WPORT   PORTD
 #define PD3_DDR     DDRD
-#define PD3_PWM     nullptr
+#define PD3_PWM     NULL
 #undef PD4
 #define PD4_PIN     PIND4
 #define PD4_RPORT   PIND
 #define PD4_WPORT   PORTD
 #define PD4_DDR     DDRD
-#define PD4_PWM     nullptr
+#define PD4_PWM     NULL
 #undef PD5
 #define PD5_PIN     PIND5
 #define PD5_RPORT   PIND
 #define PD5_WPORT   PORTD
 #define PD5_DDR     DDRD
-#define PD5_PWM     nullptr
+#define PD5_PWM     NULL
 #undef PD6
 #define PD6_PIN     PIND6
 #define PD6_RPORT   PIND
 #define PD6_WPORT   PORTD
 #define PD6_DDR     DDRD
-#define PD6_PWM     nullptr
+#define PD6_PWM     NULL
 #undef PD7
 #define PD7_PIN     PIND7
 #define PD7_RPORT   PIND
 #define PD7_WPORT   PORTD
 #define PD7_DDR     DDRD
-#define PD7_PWM     nullptr
+#define PD7_PWM     NULL
 
 #undef PE0
 #define PE0_PIN     PINE0
 #define PE0_RPORT   PINE
 #define PE0_WPORT   PORTE
 #define PE0_DDR     DDRE
-#define PE0_PWM     nullptr
+#define PE0_PWM     NULL
 #undef PE1
 #define PE1_PIN     PINE1
 #define PE1_RPORT   PINE
 #define PE1_WPORT   PORTE
 #define PE1_DDR     DDRE
-#define PE1_PWM     nullptr
+#define PE1_PWM     NULL
 #undef PE2
 #define PE2_PIN     PINE2
 #define PE2_RPORT   PINE
 #define PE2_WPORT   PORTE
 #define PE2_DDR     DDRE
-#define PE2_PWM     nullptr
+#define PE2_PWM     NULL
 #undef PE3
 #define PE3_PIN     PINE3
 #define PE3_RPORT   PINE
@@ -620,93 +620,93 @@
 #define PE6_RPORT   PINE
 #define PE6_WPORT   PORTE
 #define PE6_DDR     DDRE
-#define PE6_PWM     nullptr
+#define PE6_PWM     NULL
 #undef PE7
 #define PE7_PIN     PINE7
 #define PE7_RPORT   PINE
 #define PE7_WPORT   PORTE
 #define PE7_DDR     DDRE
-#define PE7_PWM     nullptr
+#define PE7_PWM     NULL
 
 #undef PF0
 #define PF0_PIN     PINF0
 #define PF0_RPORT   PINF
 #define PF0_WPORT   PORTF
 #define PF0_DDR     DDRF
-#define PF0_PWM     nullptr
+#define PF0_PWM     NULL
 #undef PF1
 #define PF1_PIN     PINF1
 #define PF1_RPORT   PINF
 #define PF1_WPORT   PORTF
 #define PF1_DDR     DDRF
-#define PF1_PWM     nullptr
+#define PF1_PWM     NULL
 #undef PF2
 #define PF2_PIN     PINF2
 #define PF2_RPORT   PINF
 #define PF2_WPORT   PORTF
 #define PF2_DDR     DDRF
-#define PF2_PWM     nullptr
+#define PF2_PWM     NULL
 #undef PF3
 #define PF3_PIN     PINF3
 #define PF3_RPORT   PINF
 #define PF3_WPORT   PORTF
 #define PF3_DDR     DDRF
-#define PF3_PWM     nullptr
+#define PF3_PWM     NULL
 #undef PF4
 #define PF4_PIN     PINF4
 #define PF4_RPORT   PINF
 #define PF4_WPORT   PORTF
 #define PF4_DDR     DDRF
-#define PF4_PWM     nullptr
+#define PF4_PWM     NULL
 #undef PF5
 #define PF5_PIN     PINF5
 #define PF5_RPORT   PINF
 #define PF5_WPORT   PORTF
 #define PF5_DDR     DDRF
-#define PF5_PWM     nullptr
+#define PF5_PWM     NULL
 #undef PF6
 #define PF6_PIN     PINF6
 #define PF6_RPORT   PINF
 #define PF6_WPORT   PORTF
 #define PF6_DDR     DDRF
-#define PF6_PWM     nullptr
+#define PF6_PWM     NULL
 #undef PF7
 #define PF7_PIN     PINF7
 #define PF7_RPORT   PINF
 #define PF7_WPORT   PORTF
 #define PF7_DDR     DDRF
-#define PF7_PWM     nullptr
+#define PF7_PWM     NULL
 
 #undef PG0
 #define PG0_PIN     PING0
 #define PG0_RPORT   PING
 #define PG0_WPORT   PORTG
 #define PG0_DDR     DDRG
-#define PG0_PWM     nullptr
+#define PG0_PWM     NULL
 #undef PG1
 #define PG1_PIN     PING1
 #define PG1_RPORT   PING
 #define PG1_WPORT   PORTG
 #define PG1_DDR     DDRG
-#define PG1_PWM     nullptr
+#define PG1_PWM     NULL
 #undef PG2
 #define PG2_PIN     PING2
 #define PG2_RPORT   PING
 #define PG2_WPORT   PORTG
 #define PG2_DDR     DDRG
-#define PG2_PWM     nullptr
+#define PG2_PWM     NULL
 #undef PG3
 #define PG3_PIN     PING3
 #define PG3_RPORT   PING
 #define PG3_WPORT   PORTG
 #define PG3_DDR     DDRG
-#define PG3_PWM     nullptr
+#define PG3_PWM     NULL
 #undef PG4
 #define PG4_PIN     PING4
 #define PG4_RPORT   PING
 #define PG4_WPORT   PORTG
 #define PG4_DDR     DDRG
-#define PG4_PWM     nullptr
+#define PG4_PWM     NULL
 #undef PG5
 #define PG5_PIN     PING5
 #define PG5_RPORT   PING

Marlin/src/HAL/HAL_AVR/fastio_168.h

@@ -1,9 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
+ * 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
@@ -28,7 +28,7 @@
  *   Port:        B0 B1 B2 B3 B4 B5 C0 C1 C2 C3 C4 C5 C6 C7 D0 D1 D2 D3 D4 D5 D6 D7
  */
 
-#include "../fastio.h"
+#include "fastio_AVR.h"
 
 #define DEBUG_LED   AIO5
 
@@ -60,19 +60,19 @@
 #define DIO0_RPORT  PIND
 #define DIO0_WPORT  PORTD
 #define DIO0_DDR    DDRD
-#define DIO0_PWM    nullptr
+#define DIO0_PWM    NULL
 
 #define DIO1_PIN    PIND1
 #define DIO1_RPORT  PIND
 #define DIO1_WPORT  PORTD
 #define DIO1_DDR    DDRD
-#define DIO1_PWM    nullptr
+#define DIO1_PWM    NULL
 
 #define DIO2_PIN    PIND2
 #define DIO2_RPORT  PIND
 #define DIO2_WPORT  PORTD
 #define DIO2_DDR    DDRD
-#define DIO2_PWM    nullptr
+#define DIO2_PWM    NULL
 
 #define DIO3_PIN    PIND3
 #define DIO3_RPORT  PIND
@@ -84,7 +84,7 @@
 #define DIO4_RPORT  PIND
 #define DIO4_WPORT  PORTD
 #define DIO4_DDR    DDRD
-#define DIO4_PWM    nullptr
+#define DIO4_PWM    NULL
 
 #define DIO5_PIN    PIND5
 #define DIO5_RPORT  PIND
@@ -102,25 +102,25 @@
 #define DIO7_RPORT  PIND
 #define DIO7_WPORT  PORTD
 #define DIO7_DDR    DDRD
-#define DIO7_PWM    nullptr
+#define DIO7_PWM    NULL
 
 #define DIO8_PIN    PINB0
 #define DIO8_RPORT  PINB
 #define DIO8_WPORT  PORTB
 #define DIO8_DDR    DDRB
-#define DIO8_PWM    nullptr
+#define DIO8_PWM    NULL
 
 #define DIO9_PIN    PINB1
 #define DIO9_RPORT  PINB
 #define DIO9_WPORT  PORTB
 #define DIO9_DDR    DDRB
-#define DIO9_PWM    nullptr
+#define DIO9_PWM    NULL
 
 #define DIO10_PIN   PINB2
 #define DIO10_RPORT PINB
 #define DIO10_WPORT PORTB
 #define DIO10_DDR   DDRB
-#define DIO10_PWM   nullptr
+#define DIO10_PWM   NULL
 
 #define DIO11_PIN   PINB3
 #define DIO11_RPORT PINB
@@ -132,82 +132,82 @@
 #define DIO12_RPORT PINB
 #define DIO12_WPORT PORTB
 #define DIO12_DDR   DDRB
-#define DIO12_PWM   nullptr
+#define DIO12_PWM   NULL
 
 #define DIO13_PIN   PINB5
 #define DIO13_RPORT PINB
 #define DIO13_WPORT PORTB
 #define DIO13_DDR   DDRB
-#define DIO13_PWM   nullptr
+#define DIO13_PWM   NULL
 
 #define DIO14_PIN   PINC0
 #define DIO14_RPORT PINC
 #define DIO14_WPORT PORTC
 #define DIO14_DDR   DDRC
-#define DIO14_PWM   nullptr
+#define DIO14_PWM   NULL
 
 #define DIO15_PIN   PINC1
 #define DIO15_RPORT PINC
 #define DIO15_WPORT PORTC
 #define DIO15_DDR   DDRC
-#define DIO15_PWM   nullptr
+#define DIO15_PWM   NULL
 
 #define DIO16_PIN   PINC2
 #define DIO16_RPORT PINC
 #define DIO16_WPORT PORTC
 #define DIO16_DDR   DDRC
-#define DIO16_PWM   nullptr
+#define DIO16_PWM   NULL
 
 #define DIO17_PIN   PINC3
 #define DIO17_RPORT PINC
 #define DIO17_WPORT PORTC
 #define DIO17_DDR   DDRC
-#define DIO17_PWM   nullptr
+#define DIO17_PWM   NULL
 
 #define DIO18_PIN   PINC4
 #define DIO18_RPORT PINC
 #define DIO18_WPORT PORTC
 #define DIO18_DDR   DDRC
-#define DIO18_PWM   nullptr
+#define DIO18_PWM   NULL
 
 #define DIO19_PIN   PINC5
 #define DIO19_RPORT PINC
 #define DIO19_WPORT PORTC
 #define DIO19_DDR   DDRC
-#define DIO19_PWM   nullptr
+#define DIO19_PWM   NULL
 
 #define DIO20_PIN   PINC6
 #define DIO20_RPORT PINC
 #define DIO20_WPORT PORTC
 #define DIO20_DDR   DDRC
-#define DIO20_PWM   nullptr
+#define DIO20_PWM   NULL
 
 #define DIO21_PIN   PINC7
 #define DIO21_RPORT PINC
 #define DIO21_WPORT PORTC
 #define DIO21_DDR   DDRC
-#define DIO21_PWM   nullptr
+#define DIO21_PWM   NULL
 
 #undef PB0
 #define PB0_PIN     PINB0
 #define PB0_RPORT   PINB
 #define PB0_WPORT   PORTB
 #define PB0_DDR     DDRB
-#define PB0_PWM     nullptr
+#define PB0_PWM     NULL
 
 #undef PB1
 #define PB1_PIN     PINB1
 #define PB1_RPORT   PINB
 #define PB1_WPORT   PORTB
 #define PB1_DDR     DDRB
-#define PB1_PWM     nullptr
+#define PB1_PWM     NULL
 
 #undef PB2
 #define PB2_PIN     PINB2
 #define PB2_RPORT   PINB
 #define PB2_WPORT   PORTB
 #define PB2_DDR     DDRB
-#define PB2_PWM     nullptr
+#define PB2_PWM     NULL
 
 #undef PB3
 #define PB3_PIN     PINB3
@@ -221,105 +221,105 @@
 #define PB4_RPORT   PINB
 #define PB4_WPORT   PORTB
 #define PB4_DDR     DDRB
-#define PB4_PWM     nullptr
+#define PB4_PWM     NULL
 
 #undef PB5
 #define PB5_PIN     PINB5
 #define PB5_RPORT   PINB
 #define PB5_WPORT   PORTB
 #define PB5_DDR     DDRB
-#define PB5_PWM     nullptr
+#define PB5_PWM     NULL
 
 #undef PB6
 #define PB6_PIN     PINB6
 #define PB6_RPORT   PINB
 #define PB6_WPORT   PORTB
 #define PB6_DDR     DDRB
-#define PB6_PWM     nullptr
+#define PB6_PWM     NULL
 
 #undef PB7
 #define PB7_PIN     PINB7
 #define PB7_RPORT   PINB
 #define PB7_WPORT   PORTB
 #define PB7_DDR     DDRB
-#define PB7_PWM     nullptr
+#define PB7_PWM     NULL
 
 #undef PC0
 #define PC0_PIN     PINC0
 #define PC0_RPORT   PINC
 #define PC0_WPORT   PORTC
 #define PC0_DDR     DDRC
-#define PC0_PWM     nullptr
+#define PC0_PWM     NULL
 
 #undef PC1
 #define PC1_PIN     PINC1
 #define PC1_RPORT   PINC
 #define PC1_WPORT   PORTC
 #define PC1_DDR     DDRC
-#define PC1_PWM     nullptr
+#define PC1_PWM     NULL
 
 #undef PC2
 #define PC2_PIN     PINC2
 #define PC2_RPORT   PINC
 #define PC2_WPORT   PORTC
 #define PC2_DDR     DDRC
-#define PC2_PWM     nullptr
+#define PC2_PWM     NULL
 
 #undef PC3
 #define PC3_PIN     PINC3
 #define PC3_RPORT   PINC
 #define PC3_WPORT   PORTC
 #define PC3_DDR     DDRC
-#define PC3_PWM     nullptr
+#define PC3_PWM     NULL
 
 #undef PC4
 #define PC4_PIN     PINC4
 #define PC4_RPORT   PINC
 #define PC4_WPORT   PORTC
 #define PC4_DDR     DDRC
-#define PC4_PWM     nullptr
+#define PC4_PWM     NULL
 
 #undef PC5
 #define PC5_PIN     PINC5
 #define PC5_RPORT   PINC
 #define PC5_WPORT   PORTC
 #define PC5_DDR     DDRC
-#define PC5_PWM     nullptr
+#define PC5_PWM     NULL
 
 #undef PC6
 #define PC6_PIN     PINC6
 #define PC6_RPORT   PINC
 #define PC6_WPORT   PORTC
 #define PC6_DDR     DDRC
-#define PC6_PWM     nullptr
+#define PC6_PWM     NULL
 
 #undef PC7
 #define PC7_PIN     PINC7
 #define PC7_RPORT   PINC
 #define PC7_WPORT   PORTC
 #define PC7_DDR     DDRC
-#define PC7_PWM     nullptr
+#define PC7_PWM     NULL
 
 #undef PD0
 #define PD0_PIN     PIND0
 #define PD0_RPORT   PIND
 #define PD0_WPORT   PORTD
 #define PD0_DDR     DDRD
-#define PD0_PWM     nullptr
+#define PD0_PWM     NULL
 
 #undef PD1
 #define PD1_PIN     PIND1
 #define PD1_RPORT   PIND
 #define PD1_WPORT   PORTD
 #define PD1_DDR     DDRD
-#define PD1_PWM     nullptr
+#define PD1_PWM     NULL
 
 #undef PD2
 #define PD2_PIN     PIND2
 #define PD2_RPORT   PIND
 #define PD2_WPORT   PORTD
 #define PD2_DDR     DDRD
-#define PD2_PWM     nullptr
+#define PD2_PWM     NULL
 
 #undef PD3
 #define PD3_PIN     PIND3
@@ -333,7 +333,7 @@
 #define PD4_RPORT   PIND
 #define PD4_WPORT   PORTD
 #define PD4_DDR     DDRD
-#define PD4_PWM     nullptr
+#define PD4_PWM     NULL
 
 #undef PD5
 #define PD5_PIN     PIND5
@@ -354,4 +354,4 @@
 #define PD7_RPORT   PIND
 #define PD7_WPORT   PORTD
 #define PD7_DDR     DDRD
-#define PD7_PWM     nullptr
+#define PD7_PWM     NULL

Marlin/src/HAL/HAL_AVR/fastio_644.h

@@ -1,9 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
+ * 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
@@ -54,7 +54,7 @@
  *                        +--------+
  */
 
-#include "../fastio.h"
+#include "fastio_AVR.h"
 
 #define DEBUG_LED   DIO0
 
@@ -91,462 +91,462 @@
 #define DIO0_RPORT  PINB
 #define DIO0_WPORT  PORTB
 #define DIO0_DDR    DDRB
-#define DIO0_PWM    nullptr
+#define DIO0_PWM    NULL
 
 #define DIO1_PIN    PINB1
 #define DIO1_RPORT  PINB
 #define DIO1_WPORT  PORTB
 #define DIO1_DDR    DDRB
-#define DIO1_PWM    nullptr
+#define DIO1_PWM    NULL
 
 #define DIO2_PIN    PINB2
 #define DIO2_RPORT  PINB
 #define DIO2_WPORT  PORTB
 #define DIO2_DDR    DDRB
-#define DIO2_PWM    nullptr
+#define DIO2_PWM    NULL
 
 #define DIO3_PIN    PINB3
 #define DIO3_RPORT  PINB
 #define DIO3_WPORT  PORTB
 #define DIO3_DDR    DDRB
-#define DIO3_PWM    &OCR0A
+#define DIO3_PWM    OCR0A
 
 #define DIO4_PIN    PINB4
 #define DIO4_RPORT  PINB
 #define DIO4_WPORT  PORTB
 #define DIO4_DDR    DDRB
-#define DIO4_PWM    &OCR0B
+#define DIO4_PWM    OCR0B
 
 #define DIO5_PIN    PINB5
 #define DIO5_RPORT  PINB
 #define DIO5_WPORT  PORTB
 #define DIO5_DDR    DDRB
-#define DIO5_PWM    nullptr
+#define DIO5_PWM    NULL
 
 #define DIO6_PIN    PINB6
 #define DIO6_RPORT  PINB
 #define DIO6_WPORT  PORTB
 #define DIO6_DDR    DDRB
-#define DIO6_PWM    nullptr
+#define DIO6_PWM    NULL
 
 #define DIO7_PIN    PINB7
 #define DIO7_RPORT  PINB
 #define DIO7_WPORT  PORTB
 #define DIO7_DDR    DDRB
-#define DIO7_PWM    nullptr
+#define DIO7_PWM    NULL
 
 #define DIO8_PIN    PIND0
 #define DIO8_RPORT  PIND
 #define DIO8_WPORT  PORTD
 #define DIO8_DDR    DDRD
-#define DIO8_PWM    nullptr
+#define DIO8_PWM    NULL
 
 #define DIO9_PIN    PIND1
 #define DIO9_RPORT  PIND
 #define DIO9_WPORT  PORTD
 #define DIO9_DDR    DDRD
-#define DIO9_PWM    nullptr
+#define DIO9_PWM    NULL
 
 #define DIO10_PIN   PIND2
 #define DIO10_RPORT PIND
 #define DIO10_WPORT PORTD
 #define DIO10_DDR   DDRD
-#define DIO10_PWM   nullptr
+#define DIO10_PWM   NULL
 
 #define DIO11_PIN   PIND3
 #define DIO11_RPORT PIND
 #define DIO11_WPORT PORTD
 #define DIO11_DDR   DDRD
-#define DIO11_PWM   nullptr
+#define DIO11_PWM   NULL
 
 #define DIO12_PIN   PIND4
 #define DIO12_RPORT PIND
 #define DIO12_WPORT PORTD
 #define DIO12_DDR   DDRD
-#define DIO12_PWM   &OCR1B
+#define DIO12_PWM   OCR1B
 
 #define DIO13_PIN   PIND5
 #define DIO13_RPORT PIND
 #define DIO13_WPORT PORTD
 #define DIO13_DDR   DDRD
-#define DIO13_PWM   &OCR1A
+#define DIO13_PWM   OCR1A
 
 #define DIO14_PIN   PIND6
 #define DIO14_RPORT PIND
 #define DIO14_WPORT PORTD
 #define DIO14_DDR   DDRD
-#define DIO14_PWM   &OCR2B
+#define DIO14_PWM   OCR2B
 
 #define DIO15_PIN   PIND7
 #define DIO15_RPORT PIND
 #define DIO15_WPORT PORTD
 #define DIO15_DDR   DDRD
-#define DIO15_PWM   &OCR2A
+#define DIO15_PWM   OCR2A
 
 #define DIO16_PIN   PINC0
 #define DIO16_RPORT PINC
 #define DIO16_WPORT PORTC
 #define DIO16_DDR   DDRC
-#define DIO16_PWM   nullptr
+#define DIO16_PWM   NULL
 
 #define DIO17_PIN   PINC1
 #define DIO17_RPORT PINC
 #define DIO17_WPORT PORTC
 #define DIO17_DDR   DDRC
-#define DIO17_PWM   nullptr
+#define DIO17_PWM   NULL
 
 #define DIO18_PIN   PINC2
 #define DIO18_RPORT PINC
 #define DIO18_WPORT PORTC
 #define DIO18_DDR   DDRC
-#define DIO18_PWM   nullptr
+#define DIO18_PWM   NULL
 
 #define DIO19_PIN   PINC3
 #define DIO19_RPORT PINC
 #define DIO19_WPORT PORTC
 #define DIO19_DDR   DDRC
-#define DIO19_PWM   nullptr
+#define DIO19_PWM   NULL
 
 #define DIO20_PIN   PINC4
 #define DIO20_RPORT PINC
 #define DIO20_WPORT PORTC
 #define DIO20_DDR   DDRC
-#define DIO20_PWM   nullptr
+#define DIO20_PWM   NULL
 
 #define DIO21_PIN   PINC5
 #define DIO21_RPORT PINC
 #define DIO21_WPORT PORTC
 #define DIO21_DDR   DDRC
-#define DIO21_PWM   nullptr
+#define DIO21_PWM   NULL
 
 #define DIO22_PIN   PINC6
 #define DIO22_RPORT PINC
 #define DIO22_WPORT PORTC
 #define DIO22_DDR   DDRC
-#define DIO22_PWM   nullptr
+#define DIO22_PWM   NULL
 
 #define DIO23_PIN   PINC7
 #define DIO23_RPORT PINC
 #define DIO23_WPORT PORTC
 #define DIO23_DDR   DDRC
-#define DIO23_PWM   nullptr
+#define DIO23_PWM   NULL
 
 #define DIO24_PIN   PINA7
 #define DIO24_RPORT PINA
 #define DIO24_WPORT PORTA
 #define DIO24_DDR   DDRA
-#define DIO24_PWM   nullptr
+#define DIO24_PWM   NULL
 
 #define DIO25_PIN   PINA6
 #define DIO25_RPORT PINA
 #define DIO25_WPORT PORTA
 #define DIO25_DDR   DDRA
-#define DIO25_PWM   nullptr
+#define DIO25_PWM   NULL
 
 #define DIO26_PIN   PINA5
 #define DIO26_RPORT PINA
 #define DIO26_WPORT PORTA
 #define DIO26_DDR   DDRA
-#define DIO26_PWM   nullptr
+#define DIO26_PWM   NULL
 
 #define DIO27_PIN   PINA4
 #define DIO27_RPORT PINA
 #define DIO27_WPORT PORTA
 #define DIO27_DDR   DDRA
-#define DIO27_PWM   nullptr
+#define DIO27_PWM   NULL
 
 #define DIO28_PIN   PINA3
 #define DIO28_RPORT PINA
 #define DIO28_WPORT PORTA
 #define DIO28_DDR   DDRA
-#define DIO28_PWM   nullptr
+#define DIO28_PWM   NULL
 
 #define DIO29_PIN   PINA2
 #define DIO29_RPORT PINA
 #define DIO29_WPORT PORTA
 #define DIO29_DDR   DDRA
-#define DIO29_PWM   nullptr
+#define DIO29_PWM   NULL
 
 #define DIO30_PIN   PINA1
 #define DIO30_RPORT PINA
 #define DIO30_WPORT PORTA
 #define DIO30_DDR   DDRA
-#define DIO30_PWM   nullptr
+#define DIO30_PWM   NULL
 
 #define DIO31_PIN   PINA0
 #define DIO31_RPORT PINA
 #define DIO31_WPORT PORTA
 #define DIO31_DDR   DDRA
-#define DIO31_PWM   nullptr
+#define DIO31_PWM   NULL
 
 #define AIO0_PIN    PINA0
 #define AIO0_RPORT  PINA
 #define AIO0_WPORT  PORTA
 #define AIO0_DDR    DDRA
-#define AIO0_PWM    nullptr
+#define AIO0_PWM    NULL
 
 #define AIO1_PIN    PINA1
 #define AIO1_RPORT  PINA
 #define AIO1_WPORT  PORTA
 #define AIO1_DDR    DDRA
-#define AIO1_PWM    nullptr
+#define AIO1_PWM    NULL
 
 #define AIO2_PIN    PINA2
 #define AIO2_RPORT  PINA
 #define AIO2_WPORT  PORTA
 #define AIO2_DDR    DDRA
-#define AIO2_PWM    nullptr
+#define AIO2_PWM    NULL
 
 #define AIO3_PIN    PINA3
 #define AIO3_RPORT  PINA
 #define AIO3_WPORT  PORTA
 #define AIO3_DDR    DDRA
-#define AIO3_PWM    nullptr
+#define AIO3_PWM    NULL
 
 #define AIO4_PIN    PINA4
 #define AIO4_RPORT  PINA
 #define AIO4_WPORT  PORTA
 #define AIO4_DDR    DDRA
-#define AIO4_PWM    nullptr
+#define AIO4_PWM    NULL
 
 #define AIO5_PIN    PINA5
 #define AIO5_RPORT  PINA
 #define AIO5_WPORT  PORTA
 #define AIO5_DDR    DDRA
-#define AIO5_PWM    nullptr
+#define AIO5_PWM    NULL
 
 #define AIO6_PIN    PINA6
 #define AIO6_RPORT  PINA
 #define AIO6_WPORT  PORTA
 #define AIO6_DDR    DDRA
-#define AIO6_PWM    nullptr
+#define AIO6_PWM    NULL
 
 #define AIO7_PIN    PINA7
 #define AIO7_RPORT  PINA
 #define AIO7_WPORT  PORTA
 #define AIO7_DDR    DDRA
-#define AIO7_PWM    nullptr
+#define AIO7_PWM    NULL
 
 #undef PA0
 #define PA0_PIN     PINA0
 #define PA0_RPORT   PINA
 #define PA0_WPORT   PORTA
 #define PA0_DDR     DDRA
-#define PA0_PWM     nullptr
+#define PA0_PWM     NULL
 
 #undef PA1
 #define PA1_PIN     PINA1
 #define PA1_RPORT   PINA
 #define PA1_WPORT   PORTA
 #define PA1_DDR     DDRA
-#define PA1_PWM     nullptr
+#define PA1_PWM     NULL
 
 #undef PA2
 #define PA2_PIN     PINA2
 #define PA2_RPORT   PINA
 #define PA2_WPORT   PORTA
 #define PA2_DDR     DDRA
-#define PA2_PWM     nullptr
+#define PA2_PWM     NULL
 
 #undef PA3
 #define PA3_PIN     PINA3
 #define PA3_RPORT   PINA
 #define PA3_WPORT   PORTA
 #define PA3_DDR     DDRA
-#define PA3_PWM     nullptr
+#define PA3_PWM     NULL
 
 #undef PA4
 #define PA4_PIN     PINA4
 #define PA4_RPORT   PINA
 #define PA4_WPORT   PORTA
 #define PA4_DDR     DDRA
-#define PA4_PWM     nullptr
+#define PA4_PWM     NULL
 
 #undef PA5
 #define PA5_PIN     PINA5
 #define PA5_RPORT   PINA
 #define PA5_WPORT   PORTA
 #define PA5_DDR     DDRA
-#define PA5_PWM     nullptr
+#define PA5_PWM     NULL
 
 #undef PA6
 #define PA6_PIN     PINA6
 #define PA6_RPORT   PINA
 #define PA6_WPORT   PORTA
 #define PA6_DDR     DDRA
-#define PA6_PWM     nullptr
+#define PA6_PWM     NULL
 
 #undef PA7
 #define PA7_PIN     PINA7
 #define PA7_RPORT   PINA
 #define PA7_WPORT   PORTA
 #define PA7_DDR     DDRA
-#define PA7_PWM     nullptr
+#define PA7_PWM     NULL
 
 #undef PB0
 #define PB0_PIN     PINB0
 #define PB0_RPORT   PINB
 #define PB0_WPORT   PORTB
 #define PB0_DDR     DDRB
-#define PB0_PWM     nullptr
+#define PB0_PWM     NULL
 
 #undef PB1
 #define PB1_PIN     PINB1
 #define PB1_RPORT   PINB
 #define PB1_WPORT   PORTB
 #define PB1_DDR     DDRB
-#define PB1_PWM     nullptr
+#define PB1_PWM     NULL
 
 #undef PB2
 #define PB2_PIN     PINB2
 #define PB2_RPORT   PINB
 #define PB2_WPORT   PORTB
 #define PB2_DDR     DDRB
-#define PB2_PWM     nullptr
+#define PB2_PWM     NULL
 
 #undef PB3
 #define PB3_PIN     PINB3
 #define PB3_RPORT   PINB
 #define PB3_WPORT   PORTB
 #define PB3_DDR     DDRB
-#define PB3_PWM     &OCR0A
+#define PB3_PWM     OCR0A
 
 #undef PB4
 #define PB4_PIN     PINB4
 #define PB4_RPORT   PINB
 #define PB4_WPORT   PORTB
 #define PB4_DDR     DDRB
-#define PB4_PWM     &OCR0B
+#define PB4_PWM     OCR0B
 
 #undef PB5
 #define PB5_PIN     PINB5
 #define PB5_RPORT   PINB
 #define PB5_WPORT   PORTB
 #define PB5_DDR     DDRB
-#define PB5_PWM     nullptr
+#define PB5_PWM     NULL
 
 #undef PB6
 #define PB6_PIN     PINB6
 #define PB6_RPORT   PINB
 #define PB6_WPORT   PORTB
 #define PB6_DDR     DDRB
-#define PB6_PWM     nullptr
+#define PB6_PWM     NULL
 
 #undef PB7
 #define PB7_PIN     PINB7
 #define PB7_RPORT   PINB
 #define PB7_WPORT   PORTB
 #define PB7_DDR     DDRB
-#define PB7_PWM     nullptr
+#define PB7_PWM     NULL
 
 #undef PC0
 #define PC0_PIN     PINC0
 #define PC0_RPORT   PINC
 #define PC0_WPORT   PORTC
 #define PC0_DDR     DDRC
-#define PC0_PWM     nullptr
+#define PC0_PWM     NULL
 
 #undef PC1
 #define PC1_PIN     PINC1
 #define PC1_RPORT   PINC
 #define PC1_WPORT   PORTC
 #define PC1_DDR     DDRC
-#define PC1_PWM     nullptr
+#define PC1_PWM     NULL
 
 #undef PC2
 #define PC2_PIN     PINC2
 #define PC2_RPORT   PINC
 #define PC2_WPORT   PORTC
 #define PC2_DDR     DDRC
-#define PC2_PWM     nullptr
+#define PC2_PWM     NULL
 
 #undef PC3
 #define PC3_PIN     PINC3
 #define PC3_RPORT   PINC
 #define PC3_WPORT   PORTC
 #define PC3_DDR     DDRC
-#define PC3_PWM     nullptr
+#define PC3_PWM     NULL
 
 #undef PC4
 #define PC4_PIN     PINC4
 #define PC4_RPORT   PINC
 #define PC4_WPORT   PORTC
 #define PC4_DDR     DDRC
-#define PC4_PWM     nullptr
+#define PC4_PWM     NULL
 
 #undef PC5
 #define PC5_PIN     PINC5
 #define PC5_RPORT   PINC
 #define PC5_WPORT   PORTC
 #define PC5_DDR     DDRC
-#define PC5_PWM     nullptr
+#define PC5_PWM     NULL
 
 #undef PC6
 #define PC6_PIN     PINC6
 #define PC6_RPORT   PINC
 #define PC6_WPORT   PORTC
 #define PC6_DDR     DDRC
-#define PC6_PWM     nullptr
+#define PC6_PWM     NULL
 
 #undef PC7
 #define PC7_PIN     PINC7
 #define PC7_RPORT   PINC
 #define PC7_WPORT   PORTC
 #define PC7_DDR     DDRC
-#define PC7_PWM     nullptr
+#define PC7_PWM     NULL
 
 #undef PD0
 #define PD0_PIN     PIND0
 #define PD0_RPORT   PIND
 #define PD0_WPORT   PORTD
 #define PD0_DDR     DDRD
-#define PD0_PWM     nullptr
+#define PD0_PWM     NULL
 
 #undef PD1
 #define PD1_PIN     PIND1
 #define PD1_RPORT   PIND
 #define PD1_WPORT   PORTD
 #define PD1_DDR     DDRD
-#define PD1_PWM     nullptr
+#define PD1_PWM     NULL
 
 #undef PD2
 #define PD2_PIN     PIND2
 #define PD2_RPORT   PIND
 #define PD2_WPORT   PORTD
 #define PD2_DDR     DDRD
-#define PD2_PWM     nullptr
+#define PD2_PWM     NULL
 
 #undef PD3
 #define PD3_PIN     PIND3
 #define PD3_RPORT   PIND
 #define PD3_WPORT   PORTD
 #define PD3_DDR     DDRD
-#define PD3_PWM     nullptr
+#define PD3_PWM     NULL
 
 #undef PD4
 #define PD4_PIN     PIND4
 #define PD4_RPORT   PIND
 #define PD4_WPORT   PORTD
 #define PD4_DDR     DDRD
-#define PD4_PWM     nullptr
+#define PD4_PWM     NULL
 
 #undef PD5
 #define PD5_PIN     PIND5
 #define PD5_RPORT   PIND
 #define PD5_WPORT   PORTD
 #define PD5_DDR     DDRD
-#define PD5_PWM     nullptr
+#define PD5_PWM     NULL
 
 #undef PD6
 #define PD6_PIN     PIND6
 #define PD6_RPORT   PIND
 #define PD6_WPORT   PORTD
 #define PD6_DDR     DDRD
-#define PD6_PWM     &OCR2B
+#define PD6_PWM     OCR2B
 
 #undef PD7
 #define PD7_PIN     PIND7
 #define PD7_RPORT   PIND
 #define PD7_WPORT   PORTD
 #define PD7_DDR     DDRD
-#define PD7_PWM     &OCR2A
+#define PD7_PWM     OCR2A

Marlin/src/HAL/HAL_AVR/fastio_AT90USB.h

@@ -1,9 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -29,7 +29,7 @@
  *            The logical pins 46 and 47 are not supported by Teensyduino, but are supported below as E2 and E3
  */
 
-#include "../fastio.h"
+#include "fastio_AVR.h"
 
 // change for your board
 #define DEBUG_LED   DIO31 /* led D5 red */
@@ -45,325 +45,325 @@
 #define DIO0_PIN    PIND0
 #define DIO0_RPORT  PIND
 #define DIO0_WPORT  PORTD
-#define DIO0_PWM    0
+#define DIO0_PWM    NULL
 #define DIO0_DDR    DDRD
 
 #define DIO1_PIN    PIND1
 #define DIO1_RPORT  PIND
 #define DIO1_WPORT  PORTD
-#define DIO1_PWM    0
+#define DIO1_PWM    NULL
 #define DIO1_DDR    DDRD
 
 #define DIO2_PIN    PIND2
 #define DIO2_RPORT  PIND
 #define DIO2_WPORT  PORTD
-#define DIO2_PWM    0
+#define DIO2_PWM    NULL
 #define DIO2_DDR    DDRD
 
 #define DIO3_PIN    PIND3
 #define DIO3_RPORT  PIND
 #define DIO3_WPORT  PORTD
-#define DIO3_PWM    0
+#define DIO3_PWM    NULL
 #define DIO3_DDR    DDRD
 
 #define DIO4_PIN    PIND4
 #define DIO4_RPORT  PIND
 #define DIO4_WPORT  PORTD
-#define DIO4_PWM    0
+#define DIO4_PWM    NULL
 #define DIO4_DDR    DDRD
 
 #define DIO5_PIN    PIND5
 #define DIO5_RPORT  PIND
 #define DIO5_WPORT  PORTD
-#define DIO5_PWM    0
+#define DIO5_PWM    NULL
 #define DIO5_DDR    DDRD
 
 #define DIO6_PIN    PIND6
 #define DIO6_RPORT  PIND
 #define DIO6_WPORT  PORTD
-#define DIO6_PWM    0
+#define DIO6_PWM    NULL
 #define DIO6_DDR    DDRD
 
 #define DIO7_PIN    PIND7
 #define DIO7_RPORT  PIND
 #define DIO7_WPORT  PORTD
-#define DIO7_PWM    0
+#define DIO7_PWM    NULL
 #define DIO7_DDR    DDRD
 
 #define DIO8_PIN    PINE0
 #define DIO8_RPORT  PINE
 #define DIO8_WPORT  PORTE
-#define DIO8_PWM    0
+#define DIO8_PWM    NULL
 #define DIO8_DDR    DDRE
 
 #define DIO9_PIN    PINE1
 #define DIO9_RPORT  PINE
 #define DIO9_WPORT  PORTE
-#define DIO9_PWM    0
+#define DIO9_PWM    NULL
 #define DIO9_DDR    DDRE
 
 #define DIO10_PIN   PINC0
 #define DIO10_RPORT PINC
 #define DIO10_WPORT PORTC
-#define DIO10_PWM   0
+#define DIO10_PWM   NULL
 #define DIO10_DDR   DDRC
 
 #define DIO11_PIN   PINC1
 #define DIO11_RPORT PINC
 #define DIO11_WPORT PORTC
-#define DIO11_PWM   0
+#define DIO11_PWM   NULL
 #define DIO11_DDR   DDRC
 
 #define DIO12_PIN   PINC2
 #define DIO12_RPORT PINC
 #define DIO12_WPORT PORTC
-#define DIO12_PWM   0
+#define DIO12_PWM   NULL
 #define DIO12_DDR   DDRC
 
 #define DIO13_PIN   PINC3
 #define DIO13_RPORT PINC
 #define DIO13_WPORT PORTC
-#define DIO13_PWM   0
+#define DIO13_PWM   NULL
 #define DIO13_DDR   DDRC
 
 #define DIO14_PIN   PINC4
 #define DIO14_RPORT PINC
 #define DIO14_WPORT PORTC
-#define DIO14_PWM   0 // OC3C
+#define DIO14_PWM   NULL
 #define DIO14_DDR   DDRC
 
 #define DIO15_PIN   PINC5
 #define DIO15_RPORT PINC
 #define DIO15_WPORT PORTC
-#define DIO15_PWM   0 // OC3B
+#define DIO15_PWM   NULL
 #define DIO15_DDR   DDRC
 
 #define DIO16_PIN   PINC6
 #define DIO16_RPORT PINC
 #define DIO16_WPORT PORTC
-#define DIO16_PWM   0 // OC3A
+#define DIO16_PWM   NULL
 #define DIO16_DDR   DDRC
 
 #define DIO17_PIN   PINC7
 #define DIO17_RPORT PINC
 #define DIO17_WPORT PORTC
-#define DIO17_PWM   0
+#define DIO17_PWM   NULL
 #define DIO17_DDR   DDRC
 
 #define DIO18_PIN   PINE6
 #define DIO18_RPORT PINE
 #define DIO18_WPORT PORTE
-#define DIO18_PWM   0
+#define DIO18_PWM   NULL
 #define DIO18_DDR   DDRE
 
 #define DIO19_PIN   PINE7
 #define DIO19_RPORT PINE
 #define DIO19_WPORT PORTE
-#define DIO19_PWM   0
+#define DIO19_PWM   NULL
 #define DIO19_DDR   DDRE
 
 #define DIO20_PIN   PINB0
 #define DIO20_RPORT PINB
 #define DIO20_WPORT PORTB
-#define DIO20_PWM   0
+#define DIO20_PWM   NULL
 #define DIO20_DDR   DDRB
 
 #define DIO21_PIN   PINB1
 #define DIO21_RPORT PINB
 #define DIO21_WPORT PORTB
-#define DIO21_PWM   0
+#define DIO21_PWM   NULL
 #define DIO21_DDR   DDRB
 
 #define DIO22_PIN   PINB2
 #define DIO22_RPORT PINB
 #define DIO22_WPORT PORTB
-#define DIO22_PWM   0
+#define DIO22_PWM   NULL
 #define DIO22_DDR   DDRB
 
 #define DIO23_PIN   PINB3
 #define DIO23_RPORT PINB
 #define DIO23_WPORT PORTB
-#define DIO23_PWM   0
+#define DIO23_PWM   NULL
 #define DIO23_DDR   DDRB
 
 #define DIO24_PIN   PINB4
 #define DIO24_RPORT PINB
 #define DIO24_WPORT PORTB
-#define DIO24_PWM   0 // OC2A
+#define DIO24_PWM   NULL
 #define DIO24_DDR   DDRB
 
 #define DIO25_PIN   PINB5
 #define DIO25_RPORT PINB
 #define DIO25_WPORT PORTB
-#define DIO25_PWM   0 // OC1A
+#define DIO25_PWM   NULL
 #define DIO25_DDR   DDRB
 
 #define DIO26_PIN   PINB6
 #define DIO26_RPORT PINB
 #define DIO26_WPORT PORTB
-#define DIO26_PWM   0 // OC1B
+#define DIO26_PWM   NULL
 #define DIO26_DDR   DDRB
 
 #define DIO27_PIN   PINB7
 #define DIO27_RPORT PINB
 #define DIO27_WPORT PORTB
-#define DIO27_PWM   0 // OC1C
+#define DIO27_PWM   NULL
 #define DIO27_DDR   DDRB
 
 #define DIO28_PIN   PINA0
 #define DIO28_RPORT PINA
 #define DIO28_WPORT PORTA
-#define DIO28_PWM   0
+#define DIO28_PWM   NULL
 #define DIO28_DDR   DDRA
 
 #define DIO29_PIN   PINA1
 #define DIO29_RPORT PINA
 #define DIO29_WPORT PORTA
-#define DIO29_PWM   0
+#define DIO29_PWM   NULL
 #define DIO29_DDR   DDRA
 
 #define DIO30_PIN   PINA2
 #define DIO30_RPORT PINA
 #define DIO30_WPORT PORTA
-#define DIO30_PWM   0
+#define DIO30_PWM   NULL
 #define DIO30_DDR   DDRA
 
 #define DIO31_PIN   PINA3
 #define DIO31_RPORT PINA
 #define DIO31_WPORT PORTA
-#define DIO31_PWM   0
+#define DIO31_PWM   NULL
 #define DIO31_DDR   DDRA
 
 #define DIO32_PIN   PINA4
 #define DIO32_RPORT PINA
 #define DIO32_WPORT PORTA
-#define DIO32_PWM   0
+#define DIO32_PWM   NULL
 #define DIO32_DDR   DDRA
 
 #define DIO33_PIN   PINA5
 #define DIO33_RPORT PINA
 #define DIO33_WPORT PORTA
-#define DIO33_PWM   0
+#define DIO33_PWM   NULL
 #define DIO33_DDR   DDRA
 
 #define DIO34_PIN   PINA6
 #define DIO34_RPORT PINA
 #define DIO34_WPORT PORTA
-#define DIO34_PWM   0
+#define DIO34_PWM   NULL
 #define DIO34_DDR   DDRA
 
 #define DIO35_PIN   PINA7
 #define DIO35_RPORT PINA
 #define DIO35_WPORT PORTA
-#define DIO35_PWM   0
+#define DIO35_PWM   NULL
 #define DIO35_DDR   DDRA
 
 #define DIO36_PIN   PINE4
 #define DIO36_RPORT PINE
 #define DIO36_WPORT PORTE
-#define DIO36_PWM   0
+#define DIO36_PWM   NULL
 #define DIO36_DDR   DDRE
 
 #define DIO37_PIN   PINE5
 #define DIO37_RPORT PINE
 #define DIO37_WPORT PORTE
-#define DIO37_PWM   0
+#define DIO37_PWM   NULL
 #define DIO37_DDR   DDRE
 
 #define DIO38_PIN   PINF0
 #define DIO38_RPORT PINF
 #define DIO38_WPORT PORTF
-#define DIO38_PWM   0
+#define DIO38_PWM   NULL
 #define DIO38_DDR   DDRF
 
 #define DIO39_PIN   PINF1
 #define DIO39_RPORT PINF
 #define DIO39_WPORT PORTF
-#define DIO39_PWM   0
+#define DIO39_PWM   NULL
 #define DIO39_DDR   DDRF
 
 #define DIO40_PIN   PINF2
 #define DIO40_RPORT PINF
 #define DIO40_WPORT PORTF
-#define DIO40_PWM   0
+#define DIO40_PWM   NULL
 #define DIO40_DDR   DDRF
 
 #define DIO41_PIN   PINF3
 #define DIO41_RPORT PINF
 #define DIO41_WPORT PORTF
-#define DIO41_PWM   0
+#define DIO41_PWM   NULL
 #define DIO41_DDR   DDRF
 
 #define DIO42_PIN   PINF4
 #define DIO42_RPORT PINF
 #define DIO42_WPORT PORTF
-#define DIO42_PWM   0
+#define DIO42_PWM   NULL
 #define DIO42_DDR   DDRF
 
 #define DIO43_PIN   PINF5
 #define DIO43_RPORT PINF
 #define DIO43_WPORT PORTF
-#define DIO43_PWM   0
+#define DIO43_PWM   NULL
 #define DIO43_DDR   DDRF
 
 #define DIO44_PIN   PINF6
 #define DIO44_RPORT PINF
 #define DIO44_WPORT PORTF
-#define DIO44_PWM   0
+#define DIO44_PWM   NULL
 #define DIO44_DDR   DDRF
 
 #define DIO45_PIN   PINF7
 #define DIO45_RPORT PINF
 #define DIO45_WPORT PORTF
-#define DIO45_PWM   0
+#define DIO45_PWM   NULL
 #define DIO45_DDR   DDRF
 
 #define AIO0_PIN    PINF0
 #define AIO0_RPORT  PINF
 #define AIO0_WPORT  PORTF
-#define AIO0_PWM    0
+#define AIO0_PWM    NULL
 #define AIO0_DDR    DDRF
 
 #define AIO1_PIN    PINF1
 #define AIO1_RPORT  PINF
 #define AIO1_WPORT  PORTF
-#define AIO1_PWM    0
+#define AIO1_PWM    NULL
 #define AIO1_DDR    DDRF
 
 #define AIO2_PIN    PINF2
 #define AIO2_RPORT  PINF
 #define AIO2_WPORT  PORTF
-#define AIO2_PWM    0
+#define AIO2_PWM    NULL
 #define AIO2_DDR    DDRF
 
 #define AIO3_PIN    PINF3
 #define AIO3_RPORT  PINF
 #define AIO3_WPORT  PORTF
-#define AIO3_PWM    0
+#define AIO3_PWM    NULL
 #define AIO3_DDR    DDRF
 
 #define AIO4_PIN    PINF4
 #define AIO4_RPORT  PINF
 #define AIO4_WPORT  PORTF
-#define AIO4_PWM    0
+#define AIO4_PWM    NULL
 #define AIO4_DDR    DDRF
 
 #define AIO5_PIN    PINF5
 #define AIO5_RPORT  PINF
 #define AIO5_WPORT  PORTF
-#define AIO5_PWM    0
+#define AIO5_PWM    NULL
 #define AIO5_DDR    DDRF
 
 #define AIO6_PIN    PINF6
 #define AIO6_RPORT  PINF
 #define AIO6_WPORT  PORTF
-#define AIO6_PWM    0
+#define AIO6_PWM    NULL
 #define AIO6_DDR    DDRF
 
 #define AIO7_PIN    PINF7
 #define AIO7_RPORT  PINF
 #define AIO7_WPORT  PORTF
-#define AIO7_PWM    0
+#define AIO7_PWM    NULL
 #define AIO7_DDR    DDRF
 
 //-- Begin not supported by Teensyduino
@@ -371,13 +371,13 @@
 #define DIO46_PIN   PINE2
 #define DIO46_RPORT PINE
 #define DIO46_WPORT PORTE
-#define DIO46_PWM   0
+#define DIO46_PWM   NULL
 #define DIO46_DDR   DDRE
 
 #define DIO47_PIN   PINE3
 #define DIO47_RPORT PINE
 #define DIO47_WPORT PORTE
-#define DIO47_PWM   0
+#define DIO47_PWM   NULL
 #define DIO47_DDR   DDRE
 
 #define TEENSY_E2   46
@@ -389,300 +389,300 @@
 #define PA0_PIN     PINA0
 #define PA0_RPORT   PINA
 #define PA0_WPORT   PORTA
-#define PA0_PWM     0
+#define PA0_PWM     NULL
 #define PA0_DDR     DDRA
 #undef PA1
 #define PA1_PIN     PINA1
 #define PA1_RPORT   PINA
 #define PA1_WPORT   PORTA
-#define PA1_PWM     0
+#define PA1_PWM     NULL
 #define PA1_DDR     DDRA
 #undef PA2
 #define PA2_PIN     PINA2
 #define PA2_RPORT   PINA
 #define PA2_WPORT   PORTA
-#define PA2_PWM     0
+#define PA2_PWM     NULL
 #define PA2_DDR     DDRA
 #undef PA3
 #define PA3_PIN     PINA3
 #define PA3_RPORT   PINA
 #define PA3_WPORT   PORTA
-#define PA3_PWM     0
+#define PA3_PWM     NULL
 #define PA3_DDR     DDRA
 #undef PA4
 #define PA4_PIN     PINA4
 #define PA4_RPORT   PINA
 #define PA4_WPORT   PORTA
-#define PA4_PWM     0
+#define PA4_PWM     NULL
 #define PA4_DDR     DDRA
 #undef PA5
 #define PA5_PIN     PINA5
 #define PA5_RPORT   PINA
 #define PA5_WPORT   PORTA
-#define PA5_PWM     0
+#define PA5_PWM     NULL
 #define PA5_DDR     DDRA
 #undef PA6
 #define PA6_PIN     PINA6
 #define PA6_RPORT   PINA
 #define PA6_WPORT   PORTA
-#define PA6_PWM     0
+#define PA6_PWM     NULL
 #define PA6_DDR     DDRA
 #undef PA7
 #define PA7_PIN     PINA7
 #define PA7_RPORT   PINA
 #define PA7_WPORT   PORTA
-#define PA7_PWM     0
+#define PA7_PWM     NULL
 #define PA7_DDR     DDRA
 
 #undef PB0
 #define PB0_PIN     PINB0
 #define PB0_RPORT   PINB
 #define PB0_WPORT   PORTB
-#define PB0_PWM     0
+#define PB0_PWM     NULL
 #define PB0_DDR     DDRB
 #undef PB1
 #define PB1_PIN     PINB1
 #define PB1_RPORT   PINB
 #define PB1_WPORT   PORTB
-#define PB1_PWM     0
+#define PB1_PWM     NULL
 #define PB1_DDR     DDRB
 #undef PB2
 #define PB2_PIN     PINB2
 #define PB2_RPORT   PINB
 #define PB2_WPORT   PORTB
-#define PB2_PWM     0
+#define PB2_PWM     NULL
 #define PB2_DDR     DDRB
 #undef PB3
 #define PB3_PIN     PINB3
 #define PB3_RPORT   PINB
 #define PB3_WPORT   PORTB
-#define PB3_PWM     0
+#define PB3_PWM     NULL
 #define PB3_DDR     DDRB
 #undef PB4
 #define PB4_PIN     PINB4
 #define PB4_RPORT   PINB
 #define PB4_WPORT   PORTB
-#define PB4_PWM     0
+#define PB4_PWM     NULL
 #define PB4_DDR     DDRB
 #undef PB5
 #define PB5_PIN     PINB5
 #define PB5_RPORT   PINB
 #define PB5_WPORT   PORTB
-#define PB5_PWM     0
+#define PB5_PWM     NULL
 #define PB5_DDR     DDRB
 #undef PB6
 #define PB6_PIN     PINB6
 #define PB6_RPORT   PINB
 #define PB6_WPORT   PORTB
-#define PB6_PWM     0
+#define PB6_PWM     NULL
 #define PB6_DDR     DDRB
 #undef PB7
 #define PB7_PIN     PINB7
 #define PB7_RPORT   PINB
 #define PB7_WPORT   PORTB
-#define PB7_PWM     0
+#define PB7_PWM     NULL
 #define PB7_DDR     DDRB
 
 #undef PC0
 #define PC0_PIN     PINC0
 #define PC0_RPORT   PINC
 #define PC0_WPORT   PORTC
-#define PC0_PWM     0
+#define PC0_PWM     NULL
 #define PC0_DDR     DDRC
 #undef PC1
 #define PC1_PIN     PINC1
 #define PC1_RPORT   PINC
 #define PC1_WPORT   PORTC
-#define PC1_PWM     0
+#define PC1_PWM     NULL
 #define PC1_DDR     DDRC
 #undef PC2
 #define PC2_PIN     PINC2
 #define PC2_RPORT   PINC
 #define PC2_WPORT   PORTC
-#define PC2_PWM     0
+#define PC2_PWM     NULL
 #define PC2_DDR     DDRC
 #undef PC3
 #define PC3_PIN     PINC3
 #define PC3_RPORT   PINC
 #define PC3_WPORT   PORTC
-#define PC3_PWM     0
+#define PC3_PWM     NULL
 #define PC3_DDR     DDRC
 #undef PC4
 #define PC4_PIN     PINC4
 #define PC4_RPORT   PINC
 #define PC4_WPORT   PORTC
-#define PC4_PWM     0
+#define PC4_PWM     NULL
 #define PC4_DDR     DDRC
 #undef PC5
 #define PC5_PIN     PINC5
 #define PC5_RPORT   PINC
 #define PC5_WPORT   PORTC
-#define PC5_PWM     0
+#define PC5_PWM     NULL
 #define PC5_DDR     DDRC
 #undef PC6
 #define PC6_PIN     PINC6
 #define PC6_RPORT   PINC
 #define PC6_WPORT   PORTC
-#define PC6_PWM     0
+#define PC6_PWM     NULL
 #define PC6_DDR     DDRC
 #undef PC7
 #define PC7_PIN     PINC7
 #define PC7_RPORT   PINC
 #define PC7_WPORT   PORTC
-#define PC7_PWM     0
+#define PC7_PWM     NULL
 #define PC7_DDR     DDRC
 
 #undef PD0
 #define PD0_PIN     PIND0
 #define PD0_RPORT   PIND
 #define PD0_WPORT   PORTD
-#define PD0_PWM     0 // OC0B
+#define PD0_PWM     NULL
 #define PD0_DDR     DDRD
 #undef PD1
 #define PD1_PIN     PIND1
 #define PD1_RPORT   PIND
 #define PD1_WPORT   PORTD
-#define PD1_PWM     0 // OC2B
+#define PD1_PWM     NULL
 #define PD1_DDR     DDRD
 #undef PD2
 #define PD2_PIN     PIND2
 #define PD2_RPORT   PIND
 #define PD2_WPORT   PORTD
-#define PD2_PWM     0
+#define PD2_PWM     NULL
 #define PD2_DDR     DDRD
 #undef PD3
 #define PD3_PIN     PIND3
 #define PD3_RPORT   PIND
 #define PD3_WPORT   PORTD
-#define PD3_PWM     0
+#define PD3_PWM     NULL
 #define PD3_DDR     DDRD
 #undef PD4
 #define PD4_PIN     PIND4
 #define PD4_RPORT   PIND
 #define PD4_WPORT   PORTD
-#define PD4_PWM     0
+#define PD4_PWM     NULL
 #define PD4_DDR     DDRD
 #undef PD5
 #define PD5_PIN     PIND5
 #define PD5_RPORT   PIND
 #define PD5_WPORT   PORTD
-#define PD5_PWM     0
+#define PD5_PWM     NULL
 #define PD5_DDR     DDRD
 #undef PD6
 #define PD6_PIN     PIND6
 #define PD6_RPORT   PIND
 #define PD6_WPORT   PORTD
-#define PD6_PWM     0
+#define PD6_PWM     NULL
 #define PD6_DDR     DDRD
 #undef PD7
 #define PD7_PIN     PIND7
 #define PD7_RPORT   PIND
 #define PD7_WPORT   PORTD
-#define PD7_PWM     0
+#define PD7_PWM     NULL
 #define PD7_DDR     DDRD
 
 #undef PE0
 #define PE0_PIN     PINE0
 #define PE0_RPORT   PINE
 #define PE0_WPORT   PORTE
-#define PE0_PWM     0
+#define PE0_PWM     NULL
 #define PE0_DDR     DDRE
 #undef PE1
 #define PE1_PIN     PINE1
 #define PE1_RPORT   PINE
 #define PE1_WPORT   PORTE
-#define PE1_PWM     0
+#define PE1_PWM     NULL
 #define PE1_DDR     DDRE
 #undef PE2
 #define PE2_PIN     PINE2
 #define PE2_RPORT   PINE
 #define PE2_WPORT   PORTE
-#define PE2_PWM     0
+#define PE2_PWM     NULL
 #define PE2_DDR     DDRE
 #undef PE3
 #define PE3_PIN     PINE3
 #define PE3_RPORT   PINE
 #define PE3_WPORT   PORTE
-#define PE3_PWM     0
+#define PE3_PWM     NULL
 #define PE3_DDR     DDRE
 #undef PE4
 #define PE4_PIN     PINE4
 #define PE4_RPORT   PINE
 #define PE4_WPORT   PORTE
-#define PE4_PWM     0
+#define PE4_PWM     NULL
 #define PE4_DDR     DDRE
 #undef PE5
 #define PE5_PIN     PINE5
 #define PE5_RPORT   PINE
 #define PE5_WPORT   PORTE
-#define PE5_PWM     0
+#define PE5_PWM     NULL
 #define PE5_DDR     DDRE
 #undef PE6
 #define PE6_PIN     PINE6
 #define PE6_RPORT   PINE
 #define PE6_WPORT   PORTE
-#define PE6_PWM     0
+#define PE6_PWM     NULL
 #define PE6_DDR     DDRE
 #undef PE7
 #define PE7_PIN     PINE7
 #define PE7_RPORT   PINE
 #define PE7_WPORT   PORTE
-#define PE7_PWM     0
+#define PE7_PWM     NULL
 #define PE7_DDR     DDRE
 
 #undef PF0
 #define PF0_PIN     PINF0
 #define PF0_RPORT   PINF
 #define PF0_WPORT   PORTF
-#define PF0_PWM     0
+#define PF0_PWM     NULL
 #define PF0_DDR     DDRF
 #undef PF1
 #define PF1_PIN     PINF1
 #define PF1_RPORT   PINF
 #define PF1_WPORT   PORTF
-#define PF1_PWM     0
+#define PF1_PWM     NULL
 #define PF1_DDR     DDRF
 #undef PF2
 #define PF2_PIN     PINF2
 #define PF2_RPORT   PINF
 #define PF2_WPORT   PORTF
-#define PF2_PWM     0
+#define PF2_PWM     NULL
 #define PF2_DDR     DDRF
 #undef PF3
 #define PF3_PIN     PINF3
 #define PF3_RPORT   PINF
 #define PF3_WPORT   PORTF
-#define PF3_PWM     0
+#define PF3_PWM     NULL
 #define PF3_DDR     DDRF
 #undef PF4
 #define PF4_PIN     PINF4
 #define PF4_RPORT   PINF
 #define PF4_WPORT   PORTF
-#define PF4_PWM     0
+#define PF4_PWM     NULL
 #define PF4_DDR     DDRF
 #undef PF5
 #define PF5_PIN     PINF5
 #define PF5_RPORT   PINF
 #define PF5_WPORT   PORTF
-#define PF5_PWM     0
+#define PF5_PWM     NULL
 #define PF5_DDR     DDRF
 #undef PF6
 #define PF6_PIN     PINF6
 #define PF6_RPORT   PINF
 #define PF6_WPORT   PORTF
-#define PF6_PWM     0
+#define PF6_PWM     NULL
 #define PF6_DDR     DDRF
 #undef PF7
 #define PF7_PIN     PINF7
 #define PF7_RPORT   PINF
 #define PF7_WPORT   PORTF
-#define PF7_PWM     0
+#define PF7_PWM     NULL
 #define PF7_DDR     DDRF
 
 
 /**
- * Some of the pin mapping functions of the Teensduino extension to the Arduino IDE
- * do not function the same as the other Arduino extensions.
+ *  some of the pin mapping functions of the Teensduino extension to the Arduino IDE
+ *  do not function the same as the other Arduino extensions
  */
 
 //digitalPinToTimer(pin) function works like Arduino but Timers are not defined

Marlin/src/HAL/HAL_AVR/fastio_AVR.cpp

@@ -1,9 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -26,7 +26,7 @@
 
 #ifdef __AVR__
 
-#include "fastio.h"
+#include "fastio_AVR.h"
 
 #ifdef FASTIO_EXT_START
 

Marlin/src/HAL/HAL_AVR/fastio_AVR.h

@@ -1,9 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
+ * 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
@@ -28,6 +28,7 @@
  */
 
 #include <avr/io.h>
+#include "../../core/macros.h"
 
 #define AVR_AT90USB1286_FAMILY (defined(__AVR_AT90USB1287__) || defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB1286P__) || defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB646P__) || defined(__AVR_AT90USB647__))
 #define AVR_ATmega1284_FAMILY (defined(__AVR_ATmega644__) || defined(__AVR_ATmega644P__) || defined(__AVR_ATmega644PA__) || defined(__AVR_ATmega1284P__))
@@ -39,15 +40,15 @@
  * Include Ports and Functions
  */
 #if AVR_ATmega328_FAMILY
-  #include "fastio/fastio_168.h"
+  #include "fastio_168.h"
 #elif AVR_ATmega1284_FAMILY
-  #include "fastio/fastio_644.h"
+  #include "fastio_644.h"
 #elif AVR_ATmega2560_FAMILY
-  #include "fastio/fastio_1280.h"
+  #include "fastio_1280.h"
 #elif AVR_AT90USB1286_FAMILY
-  #include "fastio/fastio_AT90USB.h"
+  #include "fastio_AT90USB.h"
 #elif AVR_ATmega2561_FAMILY
-  #include "fastio/fastio_1281.h"
+  #include "fastio_1281.h"
 #else
   #error "No FastIO definition for the selected AVR Board."
 #endif
@@ -80,8 +81,9 @@
 #define _SET_INPUT(IO)        CBI(DIO ## IO ## _DDR, DIO ## IO ## _PIN)
 #define _SET_OUTPUT(IO)       SBI(DIO ## IO ## _DDR, DIO ## IO ## _PIN)
 
-#define _IS_INPUT(IO)         !TEST(DIO ## IO ## _DDR, DIO ## IO ## _PIN)
+#define _IS_INPUT(IO)        !TEST(DIO ## IO ## _DDR, DIO ## IO ## _PIN)
 #define _IS_OUTPUT(IO)        TEST(DIO ## IO ## _DDR, DIO ## IO ## _PIN)
+#define _HAS_TIMER(IO)        DIO ## IO ## _PWM
 
 // digitalRead/Write wrappers
 #ifdef FASTIO_EXT_START
@@ -104,6 +106,7 @@
 
 #define IS_INPUT(IO)          _IS_INPUT(IO)
 #define IS_OUTPUT(IO)         _IS_OUTPUT(IO)
+#define HAS_TIMER(IO)         _HAS_TIMER(IO)
 
 #define OUT_WRITE(IO,V)       do{ SET_OUTPUT(IO); WRITE(IO,V); }while(0)
 
@@ -272,8 +275,6 @@ enum ClockSource2 : char {
 #define SET_FOCB(T,V) SET_FOC(T,B,V)
 #define SET_FOCC(T,V) SET_FOC(T,C,V)
 
-#if 0
-
 /**
  * PWM availability macros
  */
@@ -287,11 +288,11 @@ enum ClockSource2 : char {
 
 #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)
+    #define PWM_CHK_FAN_A(P) (P == FAN_PIN || P == FAN1_PIN || P == FAN2_PIN)
   #elif PIN_EXISTS(FAN1)
-    #define PWM_CHK_FAN_A(P) (P == FAN0_PIN || P == FAN1_PIN)
+    #define PWM_CHK_FAN_A(P) (P == FAN_PIN || P == FAN1_PIN)
   #else
-    #define PWM_CHK_FAN_A(P) (P == FAN0_PIN)
+    #define PWM_CHK_FAN_A(P) (P == FAN_PIN)
   #endif
 #else
   #define PWM_CHK_FAN_A(P) false
@@ -337,8 +338,6 @@ enum ClockSource2 : char {
 
 #define PWM_CHK(P) (PWM_CHK_HEATER(P) || PWM_CHK_SERVO(P) || PWM_CHK_MOTOR_CURRENT(P) || PWM_CHK_FAN_A(P) || PWM_CHK_FAN_B(P))
 
-#endif // PWM_CHK is not used in Marlin
-
 // define which hardware PWMs are available for the current CPU
 // all timer 1 PWMS deleted from this list because they are never available
 #if AVR_ATmega2560_FAMILY
@@ -354,3 +353,5 @@ enum ClockSource2 : char {
 #else
   #error "unknown CPU"
 #endif
+
+#define USEABLE_HARDWARE_PWM(P) (PWM_PIN(P) && !PWM_CHK(P))

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

@@ -1,22 +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

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

@@ -1,22 +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

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

@@ -1,61 +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
-
-/**
- * Test AVR-specific configuration values for errors at compile-time.
- */
-
-/**
- * Digipot requirement
- */
- #if ENABLED(DIGIPOT_MCP4018)
-  #if !defined(DIGIPOTS_I2C_SDA_X) || !defined(DIGIPOTS_I2C_SDA_Y) || !defined(DIGIPOTS_I2C_SDA_Z) \
-    || !defined(DIGIPOTS_I2C_SDA_E0) || !defined(DIGIPOTS_I2C_SDA_E1)
-      #error "DIGIPOT_MCP4018 requires DIGIPOTS_I2C_SDA_* pins to be defined."
-  #endif
-#endif
-
-/**
- * Checks for FAST PWM
- */
-#if ENABLED(FAST_PWM_FAN) && (ENABLED(USE_OCR2A_AS_TOP) && defined(TCCR2))
-    #error "USE_OCR2A_AS_TOP does not apply to devices with a single output TIMER2"
-#endif
-
-/**
- * Sanity checks for Spindle / Laser PWM
- */
-#if ENABLED(SPINDLE_LASER_PWM)
-  #if SPINDLE_LASER_PWM_PIN == 4 || WITHIN(SPINDLE_LASER_PWM_PIN, 11, 13)
-    #error "Counter/Timer for SPINDLE_LASER_PWM_PIN is used by a system interrupt."
-  #elif NUM_SERVOS > 0 && (WITHIN(SPINDLE_LASER_PWM_PIN, 2, 3) || SPINDLE_LASER_PWM_PIN == 5)
-    #error "Counter/Timer for SPINDLE_LASER_PWM_PIN is used by the servo system."
-  #endif
-#endif
-
-/**
- * The Trinamic library includes SoftwareSerial.h, leading to a compile error.
- */
-#if HAS_TRINAMIC && ENABLED(ENDSTOP_INTERRUPTS_FEATURE)
-  #error "TMCStepper includes SoftwareSerial.h which is incompatible with ENDSTOP_INTERRUPTS_FEATURE. Disable ENDSTOP_INTERRUPTS_FEATURE to continue."
-#endif

Marlin/src/HAL/HAL_AVR/math_AVR.h

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

Marlin/src/HAL/HAL_AVR/persistent_store_eeprom.cpp

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

Marlin/src/HAL/HAL_AVR/pinsDebug.h

@@ -1,6 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
  *
  * 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
@@ -227,9 +230,18 @@ static void print_is_also_tied() { SERIAL_ECHOPGM(" is also tied to this pin");
 void com_print(uint8_t N, uint8_t Z) {
   const uint8_t *TCCRA = (uint8_t*)TCCR_A(N);
   SERIAL_ECHOPGM("    COM");
-  SERIAL_CHAR('0' + N);
-  SERIAL_CHAR('A' + Z);
-  SERIAL_ECHOPAIR(": ", int((*TCCRA >> (6 - Z * 2)) & 0x03));
+  SERIAL_CHAR(N + '0');
+  switch (Z) {
+    case 'A':
+      SERIAL_ECHOPAIR("A: ", ((*TCCRA & (_BV(7) | _BV(6))) >> 6));
+      break;
+    case 'B':
+      SERIAL_ECHOPAIR("B: ", ((*TCCRA & (_BV(5) | _BV(4))) >> 4));
+      break;
+    case 'C':
+      SERIAL_ECHOPAIR("C: ", ((*TCCRA & (_BV(3) | _BV(2))) >> 2));
+      break;
+  }
 }
 
 void timer_prefix(uint8_t T, char L, uint8_t N) {  // T - timer    L - pwm  N - WGM bit layout
@@ -344,8 +356,6 @@ static void pwm_details(uint8_t pin) {
         timer_prefix(0, 'A', 3);
       #endif
     }
-  #else
-    UNUSED(print_is_also_tied);
   #endif
 } // pwm_details
 
@@ -393,4 +403,4 @@ static void pwm_details(uint8_t pin) {
 
 #endif
 
-#define PRINT_PIN(p) do{ sprintf_P(buffer, PSTR("%3d "), p); SERIAL_ECHO(buffer); }while(0)
+#define PRINT_PIN(p) do {sprintf_P(buffer, PSTR("%3d "), p); SERIAL_ECHO(buffer);} while (0)

Marlin/src/HAL/HAL_AVR/pinsDebug_Teensyduino.h

@@ -1,6 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
  *
  * 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,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
  *
  * 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
@@ -47,7 +50,7 @@
 
 const uint8_t PROGMEM digital_pin_to_port_PGM_plus_70[] = {
   // PORTLIST
-  // ------------------------
+  // -------------------------------------------
   PE  , // PE 0 ** 0 ** USART0_RX
   PE  , // PE 1 ** 1 ** USART0_TX
   PE  , // PE 4 ** 2 ** PWM2
@@ -140,7 +143,7 @@ const uint8_t PROGMEM digital_pin_to_port_PGM_plus_70[] = {
 
 const uint8_t PROGMEM digital_pin_to_bit_mask_PGM_plus_70[] = {
   // PIN IN PORT
-  // ------------------------
+  // -------------------------------------------
   _BV( 0 )  , // PE 0 ** 0 ** USART0_RX
   _BV( 1 )  , // PE 1 ** 1 ** USART0_TX
   _BV( 4 )  , // PE 4 ** 2 ** PWM2
@@ -234,7 +237,7 @@ const uint8_t PROGMEM digital_pin_to_bit_mask_PGM_plus_70[] = {
 
 const uint8_t PROGMEM digital_pin_to_timer_PGM_plus_70[] = {
   // TIMERS
-  // ------------------------
+  // -------------------------------------------
   NOT_ON_TIMER  , // PE 0 ** 0 ** USART0_RX
   NOT_ON_TIMER  , // PE 1 ** 1 ** USART0_TX
   TIMER3B , // PE 4 ** 2 ** PWM2

Marlin/src/HAL/HAL_AVR/servo_AVR.cpp

@@ -1,9 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
+ * 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
@@ -95,29 +95,29 @@ static inline void handle_interrupts(timer16_Sequence_t timer, volatile uint16_t
 #ifndef WIRING // Wiring pre-defines signal handlers so don't define any if compiling for the Wiring platform
 
   // Interrupt handlers for Arduino
-  #ifdef _useTimer1
+  #if ENABLED(_useTimer1)
     SIGNAL(TIMER1_COMPA_vect) { handle_interrupts(_timer1, &TCNT1, &OCR1A); }
   #endif
 
-  #ifdef _useTimer3
+  #if ENABLED(_useTimer3)
     SIGNAL(TIMER3_COMPA_vect) { handle_interrupts(_timer3, &TCNT3, &OCR3A); }
   #endif
 
-  #ifdef _useTimer4
+  #if ENABLED(_useTimer4)
     SIGNAL(TIMER4_COMPA_vect) { handle_interrupts(_timer4, &TCNT4, &OCR4A); }
   #endif
 
-  #ifdef _useTimer5
+  #if ENABLED(_useTimer5)
     SIGNAL(TIMER5_COMPA_vect) { handle_interrupts(_timer5, &TCNT5, &OCR5A); }
   #endif
 
 #else // WIRING
 
   // Interrupt handlers for Wiring
-  #ifdef _useTimer1
+  #if ENABLED(_useTimer1)
     void Timer1Service() { handle_interrupts(_timer1, &TCNT1, &OCR1A); }
   #endif
-  #ifdef _useTimer3
+  #if ENABLED(_useTimer3)
     void Timer3Service() { handle_interrupts(_timer3, &TCNT3, &OCR3A); }
   #endif
 
@@ -126,12 +126,12 @@ static inline void handle_interrupts(timer16_Sequence_t timer, volatile uint16_t
 /****************** end of static functions ******************************/
 
 void initISR(timer16_Sequence_t timer) {
-  #ifdef _useTimer1
+  #if ENABLED(_useTimer1)
     if (timer == _timer1) {
       TCCR1A = 0;             // normal counting mode
       TCCR1B = _BV(CS11);     // set prescaler of 8
       TCNT1 = 0;              // clear the timer count
-      #if defined(__AVR_ATmega8__) || defined(__AVR_ATmega128__)
+      #if defined(__AVR_ATmega8__)|| defined(__AVR_ATmega128__)
         SBI(TIFR, OCF1A);      // clear any pending interrupts;
         SBI(TIMSK, OCIE1A);    // enable the output compare interrupt
       #else
@@ -145,7 +145,7 @@ void initISR(timer16_Sequence_t timer) {
     }
   #endif
 
-  #ifdef _useTimer3
+  #if ENABLED(_useTimer3)
     if (timer == _timer3) {
       TCCR3A = 0;             // normal counting mode
       TCCR3B = _BV(CS31);     // set prescaler of 8
@@ -163,7 +163,7 @@ void initISR(timer16_Sequence_t timer) {
     }
   #endif
 
-  #ifdef _useTimer4
+  #if ENABLED(_useTimer4)
     if (timer == _timer4) {
       TCCR4A = 0;             // normal counting mode
       TCCR4B = _BV(CS41);     // set prescaler of 8
@@ -173,7 +173,7 @@ void initISR(timer16_Sequence_t timer) {
     }
   #endif
 
-  #ifdef _useTimer5
+  #if ENABLED(_useTimer5)
     if (timer == _timer5) {
       TCCR5A = 0;             // normal counting mode
       TCCR5B = _BV(CS51);     // set prescaler of 8

Marlin/src/HAL/HAL_AVR/spi_pins.h

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

Marlin/src/HAL/HAL_AVR/u8g_com_HAL_AVR_sw_spi.cpp

@@ -1,193 +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/>.
- *
- */
-
-/**
- * Based on u8g_com_st7920_hw_spi.c
- *
- * Universal 8bit Graphics Library
- *
- * Copyright (c) 2011, olikraus@gmail.com
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- *
- *  * Redistributions of source code must retain the above copyright notice, this list
- *    of conditions and the following disclaimer.
- *
- *  * Redistributions in binary form must reproduce the above copyright notice, this
- *    list of conditions and the following disclaimer in the documentation and/or other
- *    materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#if defined(ARDUINO) && !defined(ARDUINO_ARCH_STM32) && !defined(ARDUINO_ARCH_SAM)
-
-#include "../../inc/MarlinConfigPre.h"
-
-#if HAS_GRAPHICAL_LCD
-
-#include "../shared/Marduino.h"
-#include "../shared/Delay.h"
-
-#include <U8glib.h>
-
-uint8_t u8g_bitData, u8g_bitNotData, u8g_bitClock, u8g_bitNotClock;
-volatile uint8_t *u8g_outData, *u8g_outClock;
-
-static void u8g_com_arduino_init_shift_out(uint8_t dataPin, uint8_t clockPin) {
-  u8g_outData = portOutputRegister(digitalPinToPort(dataPin));
-  u8g_outClock = portOutputRegister(digitalPinToPort(clockPin));
-  u8g_bitData = digitalPinToBitMask(dataPin);
-  u8g_bitClock = digitalPinToBitMask(clockPin);
-
-  u8g_bitNotClock = u8g_bitClock;
-  u8g_bitNotClock ^= 0xFF;
-
-  u8g_bitNotData = u8g_bitData;
-  u8g_bitNotData ^= 0xFF;
-}
-
-void u8g_spiSend_sw_AVR_mode_0(uint8_t val) {
-  uint8_t bitData = u8g_bitData,
-          bitNotData = u8g_bitNotData,
-          bitClock = u8g_bitClock,
-          bitNotClock = u8g_bitNotClock;
-  volatile uint8_t *outData = u8g_outData,
-                   *outClock = u8g_outClock;
-  U8G_ATOMIC_START();
-  for (uint8_t i = 0; i < 8; i++) {
-    if (val & 0x80)
-      *outData |= bitData;
-    else
-      *outData &= bitNotData;
-    *outClock |= bitClock;
-    val <<= 1;
-    *outClock &= bitNotClock;
-  }
-  U8G_ATOMIC_END();
-}
-
-void u8g_spiSend_sw_AVR_mode_3(uint8_t val) {
-  uint8_t bitData = u8g_bitData,
-          bitNotData = u8g_bitNotData,
-          bitClock = u8g_bitClock,
-          bitNotClock = u8g_bitNotClock;
-  volatile uint8_t *outData = u8g_outData,
-                   *outClock = u8g_outClock;
-  U8G_ATOMIC_START();
-  for (uint8_t i = 0; i < 8; i++) {
-    *outClock &= bitNotClock;
-    if (val & 0x80)
-      *outData |= bitData;
-    else
-      *outData &= bitNotData;
-    *outClock |= bitClock;
-    val <<= 1;
-  }
-  U8G_ATOMIC_END();
-}
-
-
-#if ENABLED(FYSETC_MINI_12864)
-  #define SPISEND_SW_AVR u8g_spiSend_sw_AVR_mode_3
-#else
-  #define SPISEND_SW_AVR u8g_spiSend_sw_AVR_mode_0
-#endif
-
-uint8_t u8g_com_HAL_AVR_sw_sp_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) {
-  switch (msg) {
-    case U8G_COM_MSG_INIT:
-      u8g_com_arduino_init_shift_out(u8g->pin_list[U8G_PI_MOSI], u8g->pin_list[U8G_PI_SCK]);
-      u8g_com_arduino_assign_pin_output_high(u8g);
-      u8g_com_arduino_digital_write(u8g, U8G_PI_SCK, 0);
-      u8g_com_arduino_digital_write(u8g, U8G_PI_MOSI, 0);
-      break;
-
-    case U8G_COM_MSG_STOP:
-      break;
-
-    case U8G_COM_MSG_RESET:
-      if (U8G_PIN_NONE != u8g->pin_list[U8G_PI_RESET]) u8g_com_arduino_digital_write(u8g, U8G_PI_RESET, arg_val);
-      break;
-
-    case U8G_COM_MSG_CHIP_SELECT:
-      #if ENABLED(FYSETC_MINI_12864)           // LCD SPI is running mode 3 while SD card is running mode 0
-        if (arg_val) {                         //   SCK idle state needs to be set to the proper idle state before
-                                               //   the next chip select goes active
-          u8g_com_arduino_digital_write(u8g, U8G_PI_SCK, 1);  // Set SCK to mode 3 idle state before CS goes active
-          u8g_com_arduino_digital_write(u8g, U8G_PI_CS, LOW);
-        }
-        else {
-          u8g_com_arduino_digital_write(u8g, U8G_PI_CS, HIGH);
-          u8g_com_arduino_digital_write(u8g, U8G_PI_SCK, 0);  // Set SCK to mode 0 idle state after CS goes inactive
-        }
-      #else
-        u8g_com_arduino_digital_write(u8g, U8G_PI_CS, !arg_val);
-      #endif
-      break;
-
-    case U8G_COM_MSG_WRITE_BYTE:
-      SPISEND_SW_AVR(arg_val);
-      break;
-
-    case U8G_COM_MSG_WRITE_SEQ: {
-        uint8_t *ptr = (uint8_t *)arg_ptr;
-        while (arg_val > 0) {
-          SPISEND_SW_AVR(*ptr++);
-          arg_val--;
-        }
-      }
-      break;
-
-      case U8G_COM_MSG_WRITE_SEQ_P: {
-        uint8_t *ptr = (uint8_t *)arg_ptr;
-        while (arg_val > 0) {
-          SPISEND_SW_AVR(u8g_pgm_read(ptr));
-          ptr++;
-          arg_val--;
-        }
-      }
-      break;
-
-    case U8G_COM_MSG_ADDRESS:                     /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
-      u8g_com_arduino_digital_write(u8g, U8G_PI_A0, arg_val);
-      break;
-  }
-  return 1;
-}
-
-#endif // HAS_GRAPHICAL_LCD
-#endif // ARDUINO_ARCH_SAM

Marlin/src/HAL/HAL_AVR/watchdog_AVR.cpp

@@ -1,9 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -26,7 +26,7 @@
 
 #if ENABLED(USE_WATCHDOG)
 
-#include "watchdog.h"
+#include "watchdog_AVR.h"
 
 #include "../../Marlin.h"
 

Marlin/src/HAL/HAL_AVR/watchdog_AVR.h

@@ -1,9 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
+ * 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
@@ -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_Due.cpp

@@ -1,9 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -24,12 +24,11 @@
 
 #include "../../core/macros.h"
 #include "../../core/serial.h"
+#include <stdarg.h>
 
 #include "../shared/backtrace/unwinder.h"
 #include "../shared/backtrace/unwmemaccess.h"
 
-#include <stdarg.h>
-
 // Debug monitor that dumps to the Programming port all status when
 // an exception or WDT timeout happens - And then resets the board
 
@@ -42,7 +41,7 @@
 #define sw_barrier() __asm__ volatile("": : :"memory");
 
 // (re)initialize UART0 as a monitor output to 250000,n,8,1
-static void TXBegin() {
+static void TXBegin(void) {
 
   // Disable UART interrupt in NVIC
   NVIC_DisableIRQ( UART_IRQn );
@@ -235,7 +234,7 @@ void HardFault_HandlerC(unsigned long *sp, unsigned long lr, unsigned long cause
   for (;;) WDT_Restart(WDT);
 }
 
-__attribute__((naked)) void NMI_Handler() {
+__attribute__((naked)) void NMI_Handler(void) {
   __asm__ __volatile__ (
     ".syntax unified" "\n\t"
     A("tst lr, #4")
@@ -248,7 +247,7 @@ __attribute__((naked)) void NMI_Handler() {
   );
 }
 
-__attribute__((naked)) void HardFault_Handler() {
+__attribute__((naked)) void HardFault_Handler(void) {
   __asm__ __volatile__ (
     ".syntax unified" "\n\t"
     A("tst lr, #4")
@@ -261,7 +260,7 @@ __attribute__((naked)) void HardFault_Handler() {
   );
 }
 
-__attribute__((naked)) void MemManage_Handler() {
+__attribute__((naked)) void MemManage_Handler(void) {
   __asm__ __volatile__ (
     ".syntax unified" "\n\t"
     A("tst lr, #4")
@@ -274,7 +273,7 @@ __attribute__((naked)) void MemManage_Handler() {
   );
 }
 
-__attribute__((naked)) void BusFault_Handler() {
+__attribute__((naked)) void BusFault_Handler(void) {
   __asm__ __volatile__ (
     ".syntax unified" "\n\t"
     A("tst lr, #4")
@@ -287,7 +286,7 @@ __attribute__((naked)) void BusFault_Handler() {
   );
 }
 
-__attribute__((naked)) void UsageFault_Handler() {
+__attribute__((naked)) void UsageFault_Handler(void) {
   __asm__ __volatile__ (
     ".syntax unified" "\n\t"
     A("tst lr, #4")
@@ -300,7 +299,7 @@ __attribute__((naked)) void UsageFault_Handler() {
   );
 }
 
-__attribute__((naked)) void DebugMon_Handler() {
+__attribute__((naked)) void DebugMon_Handler(void) {
   __asm__ __volatile__ (
     ".syntax unified" "\n\t"
     A("tst lr, #4")
@@ -314,7 +313,7 @@ __attribute__((naked)) void DebugMon_Handler() {
 }
 
 /* This is NOT an exception, it is an interrupt handler - Nevertheless, the framing is the same */
-__attribute__((naked)) void WDT_Handler() {
+__attribute__((naked)) void WDT_Handler(void) {
   __asm__ __volatile__ (
     ".syntax unified" "\n\t"
     A("tst lr, #4")
@@ -327,7 +326,7 @@ __attribute__((naked)) void WDT_Handler() {
   );
 }
 
-__attribute__((naked)) void RSTC_Handler() {
+__attribute__((naked)) void RSTC_Handler(void) {
   __asm__ __volatile__ (
     ".syntax unified" "\n\t"
     A("tst lr, #4")

Marlin/src/HAL/HAL_DUE/EepromEmulation_Due.cpp

@@ -31,12 +31,12 @@
 
 #ifdef ARDUINO_ARCH_SAM
 
+#include "../shared/persistent_store_api.h"
 #include "../../inc/MarlinConfig.h"
 
-#if ENABLED(EEPROM_SETTINGS) && NONE(I2C_EEPROM, SPI_EEPROM)
+#if ENABLED(EEPROM_SETTINGS) && DISABLED(I2C_EEPROM, SPI_EEPROM)
 
 #include "../shared/Marduino.h"
-#include "../shared/persistent_store_api.h"
 
 #define EEPROMSize     4096
 #define PagesPerGroup   128
@@ -922,7 +922,8 @@ static void ee_Init() {
       if (!ee_IsPageClean(grp * PagesPerGroup + page)) {
         #ifdef EE_EMU_DEBUG
           SERIAL_ECHO_START();
-          SERIAL_ECHOLNPAIR("EEPROM Page ", page, " not clean on group ", grp);
+          SERIAL_ECHOPAIR("EEPROM Page ",page);
+          SERIAL_ECHOLNPAIR(" not clean on group ",grp);
           SERIAL_FLUSH();
         #endif
         ee_PageErase(grp * PagesPerGroup + page);
@@ -943,7 +944,7 @@ static void ee_Init() {
 
   #ifdef EE_EMU_DEBUG
     SERIAL_ECHO_START();
-    SERIAL_ECHOLNPAIR("EEPROM Active page: ", curPage);
+    SERIAL_ECHOLNPAIR("EEPROM Active page: ",curPage);
     SERIAL_FLUSH();
   #endif
 
@@ -952,7 +953,8 @@ static void ee_Init() {
     if (!ee_IsPageClean(curGroup * PagesPerGroup + page)) {
       #ifdef EE_EMU_DEBUG
         SERIAL_ECHO_START();
-        SERIAL_ECHOLNPAIR("EEPROM Page ", page, " not clean on active group ", curGroup);
+        SERIAL_ECHOPAIR("EEPROM Page ",page);
+        SERIAL_ECHOLNPAIR(" not clean on active group ",curGroup);
         SERIAL_FLUSH();
         ee_Dump(curGroup * PagesPerGroup + page, getFlashStorage(curGroup * PagesPerGroup + page));
       #endif
@@ -991,7 +993,7 @@ void eeprom_read_block(void* __dst, const void* __src, size_t __n) {
   }
 }
 
-void eeprom_flush() {
+void eeprom_flush(void) {
   ee_Flush();
 }
 

Marlin/src/HAL/HAL_DUE/G2_PWM.cpp

@@ -1,9 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
+ * 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
@@ -40,7 +40,7 @@
  * Some jitter in the Vref signal is OK so the interrupt priority is left at its default value.
  */
 
-#include "../../../inc/MarlinConfig.h"
+#include "../../inc/MarlinConfig.h"
 
 #if MB(PRINTRBOARD_G2)
 

Marlin/src/HAL/HAL_DUE/G2_PWM.h

@@ -1,9 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,15 +19,14 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  */
-#pragma once
 
 /**
  * This module is stripped down version of the LPC1768_PWM.h file from
  * PR #7500. It is hardwired for the PRINTRBOARD_G2 Motor Current needs.
  */
 
-#include "../../../inc/MarlinConfigPre.h"
-#include "../../../module/stepper.h"
+#include "../../inc/MarlinConfigPre.h"
+#include "../../module/stepper.h"
 //C:\Users\bobku\Documents\GitHub\Marlin-Bob-2\Marlin\src\module\stepper.h
 //C:\Users\bobku\Documents\GitHub\Marlin-Bob-2\Marlin\src\HAL\HAL_DUE\G2_PWM.h
 

Marlin/src/HAL/HAL_DUE/G2_pins.h

@@ -1,9 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
+ * 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
@@ -248,7 +248,7 @@ const G2_PinDescription G2_g_APinDescription[] = {
   { PIOB, PIO_PB15A_CANRX1|PIO_PB14A_CANTX1, ID_PIOB, PIO_PERIPH_A, PIO_DEFAULT, (PIN_ATTR_DIGITAL|PIN_ATTR_COMBO), NO_ADC, NO_ADC, NOT_ON_PWM,  NOT_ON_TIMER },
 
   // END
-  { nullptr, 0, 0, PIO_NOT_A_PIN, PIO_DEFAULT, 0, NO_ADC, NO_ADC, NOT_ON_PWM, NOT_ON_TIMER }
+  { NULL, 0, 0, PIO_NOT_A_PIN, PIO_DEFAULT, 0, NO_ADC, NO_ADC, NOT_ON_PWM, NOT_ON_TIMER }
 };
 
 // This section replaces the FASTIO definitions of pins 34-41

Marlin/src/HAL/HAL_DUE/HAL.cpp

@@ -1,6 +1,6 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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,24 +25,56 @@
 
 #ifdef ARDUINO_ARCH_SAM
 
+// --------------------------------------------------------------------------
+// Includes
+// --------------------------------------------------------------------------
+
 #include "../../inc/MarlinConfig.h"
 #include "HAL.h"
 
 #include <Wire.h>
 #include "usb/usb_task.h"
 
-// ------------------------
+// --------------------------------------------------------------------------
+// Externals
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Local defines
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Types
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Variables
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
 // Public Variables
-// ------------------------
+// --------------------------------------------------------------------------
 
 uint16_t HAL_adc_result;
 
-// ------------------------
+// --------------------------------------------------------------------------
+// Private Variables
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Function prototypes
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Private functions
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
 // Public functions
-// ------------------------
+// --------------------------------------------------------------------------
 
 // HAL initialization task
-void HAL_init() {
+void 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 +83,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 +119,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 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) 2019 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
  *
@@ -32,9 +32,9 @@
 #include "../shared/Marduino.h"
 #include "../shared/math_32bit.h"
 #include "../shared/HAL_SPI.h"
-#include "fastio.h"
-#include "watchdog.h"
-#include "timers.h"
+#include "fastio_Due.h"
+#include "watchdog_Due.h"
+#include "HAL_timers_Due.h"
 
 #include <stdint.h>
 
@@ -58,8 +58,8 @@
   #define NUM_SERIAL 1
 #endif
 
-#include "MarlinSerial.h"
-#include "MarlinSerialUSB.h"
+#include "MarlinSerial_Due.h"
+#include "MarlinSerialUSB_Due.h"
 
 // On AVR this is in math.h?
 #define square(x) ((x)*(x))
@@ -68,15 +68,26 @@
   #define strncpy_P(dest, src, num) strncpy((dest), (src), (num))
 #endif
 
+#ifndef vsnprintf_P
+  #define vsnprintf_P vsnprintf
+#endif
+
 // Fix bug in pgm_read_ptr
 #undef pgm_read_ptr
 #define pgm_read_ptr(addr) (*((void**)(addr)))
 #undef pgm_read_word
 #define pgm_read_word(addr) (*((uint16_t*)(addr)))
 
+#define RST_POWER_ON   1
+#define RST_EXTERNAL   2
+#define RST_BROWN_OUT  4
+#define RST_WATCHDOG   8
+#define RST_JTAG       16
+#define RST_SOFTWARE   32
+#define RST_BACKUP     64
+
 typedef int8_t pin_t;
 
-#define SHARED_SERVOS HAS_SERVOS
 #define HAL_SERVO_LIB Servo
 
 //
@@ -88,11 +99,22 @@ typedef int8_t pin_t;
 #define ENABLE_ISRS()  __enable_irq()
 #define DISABLE_ISRS() __disable_irq()
 
-void cli();                     // Disable interrupts
-void sei();                     // Enable interrupts
+void cli(void);                     // Disable interrupts
+void sei(void);                     // Enable interrupts
 
-void HAL_clear_reset_source();  // clear reset reason
-uint8_t HAL_get_reset_source(); // get reset reason
+void HAL_clear_reset_source(void);  // clear reset reason
+uint8_t HAL_get_reset_source(void); // get reset reason
+
+//
+// SPI: Extended functions taking a channel number (Hardware SPI only)
+//
+
+// Write single byte to specified SPI channel
+void spiSend(uint32_t chan, byte b);
+// Write buffer to specified SPI channel
+void spiSend(uint32_t chan, const uint8_t* buf, size_t n);
+// Read single byte from specified SPI channel
+uint8_t spiRec(uint32_t chan);
 
 //
 // EEPROM
@@ -113,14 +135,21 @@ extern uint16_t HAL_adc_result;     // result of last ADC conversion
 
 #define HAL_ANALOG_SELECT(pin)
 
-inline void HAL_adc_init() {}//todo
+inline void HAL_adc_init(void) {}//todo
 
 #define HAL_START_ADC(pin)  HAL_adc_start_conversion(pin)
 #define HAL_READ_ADC()      HAL_adc_result
 #define HAL_ADC_READY()     true
 
 void HAL_adc_start_conversion(const uint8_t adc_pin);
-uint16_t HAL_adc_get_result();
+uint16_t HAL_adc_get_result(void);
+uint16_t HAL_getAdcReading(uint8_t chan);
+void HAL_startAdcConversion(uint8_t chan);
+uint8_t HAL_pinToAdcChannel(int pin);
+uint16_t HAL_getAdcFreerun(uint8_t chan, bool wait_for_conversion = false);
+//uint16_t HAL_getAdcSuperSample(uint8_t chan);
+void HAL_enable_AdcFreerun(void);
+//void HAL_disable_AdcFreerun(uint8_t chan);
 
 //
 // Pin Map
@@ -138,23 +167,20 @@ void noTone(const pin_t _pin);
 
 // Enable hooks into idle and setup for HAL
 #define HAL_IDLETASK 1
-void HAL_idletask();
-void HAL_init();
+#define HAL_INIT 1
+void HAL_idletask(void);
+void HAL_init(void);
 
 //
 // Utility functions
 //
 void _delay_ms(const int delay);
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-function"
-int freeMemory();
-#pragma GCC diagnostic pop
+int freeMemory(void);
 
 #ifdef __cplusplus
   extern "C" {
 #endif
-char *dtostrf(double __val, signed char __width, unsigned char __prec, char *__s);
+char *dtostrf (double __val, signed char __width, unsigned char __prec, char *__s);
 #ifdef __cplusplus
   }
 #endif

Marlin/src/HAL/HAL_DUE/HAL_spi_Due.cpp

@@ -1,9 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -22,7 +22,7 @@
 
 /**
  * Software SPI functions originally from Arduino Sd2Card Library
- * Copyright (c) 2009 by William Greiman
+ * Copyright (C) 2009 by William Greiman
  *
  * Completely rewritten and tuned by Eduardo José Tagle in 2017/2018
  * in ARM thumb2 inline assembler and tuned for maximum speed and performance
@@ -37,18 +37,27 @@
 
 #ifdef ARDUINO_ARCH_SAM
 
+// --------------------------------------------------------------------------
+// Includes
+// --------------------------------------------------------------------------
+
 #include "../../inc/MarlinConfig.h"
 #include "../shared/Delay.h"
 
-// ------------------------
+// --------------------------------------------------------------------------
+// Public Variables
+// --------------------------------------------------------------------------
+
+
+// --------------------------------------------------------------------------
 // Public functions
-// ------------------------
+// --------------------------------------------------------------------------
 
 #if EITHER(DUE_SOFTWARE_SPI, FORCE_SOFT_SPI)
 
-  // ------------------------
-  // Software SPI
-  // ------------------------
+  // --------------------------------------------------------------------------
+  // software SPI
+  // --------------------------------------------------------------------------
 
   // Make sure GCC optimizes this file.
   // Note that this line triggers a bug in GCC which is fixed by casting.
@@ -151,12 +160,13 @@
     (((uint32_t)(addr) & 0xF0000000) + 0x02000000 + ((uint32_t)(addr)&0xFFFFF)*32 + (bit)*4)
 
   // run at ~8 .. ~10Mhz - Rx version (Tx line not altered)
-  static uint8_t spiTransferRx0(uint8_t) { // using Mode 0
+  static uint8_t spiTransferRx0(uint8_t bout) { // using Mode 0
     uint32_t bin = 0;
     uint32_t work = 0;
     uint32_t BITBAND_MISO_PORT = BITBAND_ADDRESS( ((uint32_t)PORT(MISO_PIN))+0x3C, PIN_SHIFT(MISO_PIN));  /* PDSR of port in bitband area */
     uint32_t SCK_PORT_PLUS30 = ((uint32_t) PORT(SCK_PIN)) + 0x30;    /* SODR of port */
     uint32_t SCK_MASK = PIN_MASK(SCK_PIN);
+    UNUSED(bout);
 
     /* The software SPI routine */
     __asm__ __volatile__(
@@ -427,7 +437,7 @@
 
   static void spiTxBlockX(const uint8_t* buf, uint32_t todo) {
     do {
-      (void)spiTransferTx(*buf++);
+      (void) spiTransferTx(*buf++);
     } while (--todo);
   }
 
@@ -541,9 +551,9 @@
     // slave selects controlled by SPI controller
     // doesn't support changing SPI speeds for SD card
 
-    // ------------------------
+    // --------------------------------------------------------------------------
     // hardware SPI
-    // ------------------------
+    // --------------------------------------------------------------------------
     static bool spiInitialized = false;
 
     void spiInit(uint8_t spiRate) {

Marlin/src/HAL/HAL_DUE/HAL_timers_Due.cpp

@@ -1,7 +1,7 @@
 /**
  * Marlin 3D Printer Firmware
  *
- * Copyright (c) 2019 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
  *
@@ -28,29 +28,43 @@
 
 #ifdef ARDUINO_ARCH_SAM
 
-// ------------------------
+// --------------------------------------------------------------------------
 // Includes
-// ------------------------
+// --------------------------------------------------------------------------
 #include "../../inc/MarlinConfig.h"
 #include "HAL.h"
 
-#include "timers.h"
+#include "HAL_timers_Due.h"
 
-// ------------------------
+// --------------------------------------------------------------------------
+// Externals
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
 // Local defines
-// ------------------------
+// --------------------------------------------------------------------------
 
 #define NUM_HARDWARE_TIMERS 9
 
-// ------------------------
+#define PRESCALER 2
+// --------------------------------------------------------------------------
+// Types
+// --------------------------------------------------------------------------
+
+
+// --------------------------------------------------------------------------
+// Public Variables
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
 // Private Variables
-// ------------------------
+// --------------------------------------------------------------------------
 
 const tTimerConfig TimerConfig [NUM_HARDWARE_TIMERS] = {
   { TC0, 0, TC0_IRQn,  3}, // 0 - [servo timer5]
   { TC0, 1, TC1_IRQn,  0}, // 1
   { TC0, 2, TC2_IRQn,  2}, // 2 - stepper
-  { TC1, 0, TC3_IRQn,  0}, // 3 - stepper for BOARD_ARCHIM1
+  { 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
@@ -58,9 +72,17 @@ const tTimerConfig TimerConfig [NUM_HARDWARE_TIMERS] = {
   { TC2, 2, TC8_IRQn,  0}, // 8
 };
 
-// ------------------------
+// --------------------------------------------------------------------------
+// Function prototypes
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Private functions
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
 // Public functions
-// ------------------------
+// --------------------------------------------------------------------------
 
 /*
   Timer_clock1: Prescaler 2 -> 42MHz

Marlin/src/HAL/HAL_DUE/HAL_timers_Due.h

@@ -1,7 +1,7 @@
 /**
  * Marlin 3D Printer Firmware
  *
- * Copyright (c) 2019 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
@@ -26,11 +26,15 @@
  * For ARDUINO_ARCH_SAM
  */
 
+// --------------------------------------------------------------------------
+// Includes
+// --------------------------------------------------------------------------
+
 #include <stdint.h>
 
-// ------------------------
+// --------------------------------------------------------------------------
 // Defines
-// ------------------------
+// --------------------------------------------------------------------------
 
 #define FORCE_INLINE __attribute__((always_inline)) inline
 
@@ -39,9 +43,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,15 +65,13 @@ typedef uint32_t hal_timer_t;
 #define ENABLE_TEMPERATURE_INTERRUPT()  HAL_timer_enable_interrupt(TEMP_TIMER_NUM)
 #define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(TEMP_TIMER_NUM)
 
-#ifndef HAL_STEP_TIMER_ISR
-  #define HAL_STEP_TIMER_ISR() void TC2_Handler()
-#endif
+#define HAL_STEP_TIMER_ISR()  void TC2_Handler()
 #define HAL_TEMP_TIMER_ISR()  void TC4_Handler()
 #define HAL_TONE_TIMER_ISR()  void TC6_Handler()
 
-// ------------------------
+// --------------------------------------------------------------------------
 // Types
-// ------------------------
+// --------------------------------------------------------------------------
 
 typedef struct {
   Tc          *pTimerRegs;
@@ -80,15 +80,15 @@ typedef struct {
   uint8_t     priority;
 } tTimerConfig;
 
-// ------------------------
+// --------------------------------------------------------------------------
 // Public Variables
-// ------------------------
+// --------------------------------------------------------------------------
 
 extern const tTimerConfig TimerConfig[];
 
-// ------------------------
+// --------------------------------------------------------------------------
 // Public functions
-// ------------------------
+// --------------------------------------------------------------------------
 
 void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency);
 

Marlin/src/HAL/HAL_DUE/InterruptVectors_Due.cpp

@@ -1,9 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
+ * 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
@@ -34,21 +34,21 @@
 
 #include "../../inc/MarlinConfig.h"
 #include "HAL.h"
-#include "InterruptVectors.h"
+#include "InterruptVectors_Due.h"
 
 /* The relocated Exception/Interrupt Table - According to the ARM
    reference manual, alignment to 128 bytes should suffice, but in
    practice, we need alignment to 256 bytes to make this work in all
    cases */
 __attribute__ ((aligned(256)))
-static DeviceVectors ram_tab = { nullptr };
+static DeviceVectors ram_tab = { NULL };
 
 /**
  * This function checks if the exception/interrupt table is already in SRAM or not.
  * If it is not, then it copies the ROM table to the SRAM and relocates the table
  * by reprogramming the NVIC registers
  */
-static pfnISR_Handler* get_relocated_table_addr() {
+static pfnISR_Handler* get_relocated_table_addr(void) {
   // Get the address of the interrupt/exception table
   uint32_t isrtab = SCB->VTOR;
 

Marlin/src/HAL/HAL_DUE/InterruptVectors_Due.h

@@ -1,9 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -24,6 +24,8 @@
 /**
  * InterruptVectors_Due.h
  *
+ * Copyright (c) 2017 Eduardo José Tagle. All right reserved
+ *
  * This module relocates the Interrupt vector table to SRAM, allowing new
  * interrupt handlers to be added at runtime. This is required because the
  * Arduino runtime steals interrupt handlers that Marlin MUST use to support
@@ -37,7 +39,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/MarlinSerialUSB_Due.cpp

@@ -1,9 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -31,7 +31,7 @@
 
 #if SERIAL_PORT == -1
 
-#include "MarlinSerialUSB.h"
+#include "MarlinSerialUSB_Due.h"
 
 #if ENABLED(EMERGENCY_PARSER)
   #include "../../feature/emergency_parser.h"
@@ -39,11 +39,11 @@
 
 // Imports from Atmel USB Stack/CDC implementation
 extern "C" {
-  bool usb_task_cdc_isenabled();
-  bool usb_task_cdc_dtr_active();
-  bool udi_cdc_is_rx_ready();
-  int udi_cdc_getc();
-  bool udi_cdc_is_tx_ready();
+  bool usb_task_cdc_isenabled(void);
+  bool usb_task_cdc_dtr_active(void);
+  bool udi_cdc_is_rx_ready(void);
+  int udi_cdc_getc(void);
+  bool udi_cdc_is_tx_ready(void);
   int udi_cdc_putc(int value);
 };
 
@@ -55,11 +55,13 @@ static int pending_char = -1;
 #endif
 
 // Public Methods
-void MarlinSerialUSB::begin(const long) {}
+void MarlinSerialUSB::begin(const long baud_setting) {
+}
 
-void MarlinSerialUSB::end() {}
+void MarlinSerialUSB::end() {
+}
 
-int MarlinSerialUSB::peek() {
+int MarlinSerialUSB::peek(void) {
   if (pending_char >= 0)
     return pending_char;
 
@@ -80,7 +82,7 @@ int MarlinSerialUSB::peek() {
   return pending_char;
 }
 
-int MarlinSerialUSB::read() {
+int MarlinSerialUSB::read(void) {
   if (pending_char >= 0) {
     int ret = pending_char;
     pending_char = -1;
@@ -104,7 +106,7 @@ int MarlinSerialUSB::read() {
   return c;
 }
 
-bool MarlinSerialUSB::available() {
+bool MarlinSerialUSB::available(void) {
     /* If Pending chars */
   return pending_char >= 0 ||
     /* or USB CDC enumerated and configured on the PC side and some
@@ -112,8 +114,8 @@ bool MarlinSerialUSB::available() {
       (usb_task_cdc_isenabled() && udi_cdc_is_rx_ready());
 }
 
-void MarlinSerialUSB::flush() { }
-void MarlinSerialUSB::flushTX() { }
+void MarlinSerialUSB::flush(void) { }
+void MarlinSerialUSB::flushTX(void) { }
 
 void MarlinSerialUSB::write(const uint8_t c) {
 
@@ -183,7 +185,7 @@ void MarlinSerialUSB::print(double n, int digits) {
   printFloat(n, digits);
 }
 
-void MarlinSerialUSB::println() {
+void MarlinSerialUSB::println(void) {
   print('\r');
   print('\n');
 }

Marlin/src/HAL/HAL_DUE/MarlinSerialUSB_Due.h

@@ -1,9 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
+ * 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
@@ -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:

Marlin/src/HAL/HAL_DUE/MarlinSerial_Due.cpp

@@ -1,9 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -29,8 +29,8 @@
 
 #include "../../inc/MarlinConfig.h"
 
-#include "MarlinSerial.h"
-#include "InterruptVectors.h"
+#include "MarlinSerial_Due.h"
+#include "InterruptVectors_Due.h"
 #include "../../Marlin.h"
 
 template<typename Cfg> typename MarlinSerial<Cfg>::ring_buffer_r MarlinSerial<Cfg>::rx_buffer = { 0, 0, { 0 } };
@@ -178,7 +178,7 @@ FORCE_INLINE void MarlinSerial<Cfg>::store_rxd_char() {
 }
 
 template<typename Cfg>
-FORCE_INLINE void MarlinSerial<Cfg>::_tx_thr_empty_irq() {
+FORCE_INLINE void MarlinSerial<Cfg>::_tx_thr_empty_irq(void) {
   if (Cfg::TX_SIZE > 0) {
     // Read positions
     uint8_t t = tx_buffer.tail;
@@ -221,7 +221,7 @@ FORCE_INLINE void MarlinSerial<Cfg>::_tx_thr_empty_irq() {
 }
 
 template<typename Cfg>
-void MarlinSerial<Cfg>::UART_ISR() {
+void MarlinSerial<Cfg>::UART_ISR(void) {
   const uint32_t status = HWUART->UART_SR;
 
   // Data received?
@@ -308,13 +308,13 @@ void MarlinSerial<Cfg>::end() {
 }
 
 template<typename Cfg>
-int MarlinSerial<Cfg>::peek() {
+int MarlinSerial<Cfg>::peek(void) {
   const int v = rx_buffer.head == rx_buffer.tail ? -1 : rx_buffer.buffer[rx_buffer.tail];
   return v;
 }
 
 template<typename Cfg>
-int MarlinSerial<Cfg>::read() {
+int MarlinSerial<Cfg>::read(void) {
 
   const ring_buffer_pos_t h = rx_buffer.head;
   ring_buffer_pos_t t = rx_buffer.tail;
@@ -354,13 +354,13 @@ int MarlinSerial<Cfg>::read() {
 }
 
 template<typename Cfg>
-typename MarlinSerial<Cfg>::ring_buffer_pos_t MarlinSerial<Cfg>::available() {
+typename MarlinSerial<Cfg>::ring_buffer_pos_t MarlinSerial<Cfg>::available(void) {
   const ring_buffer_pos_t h = rx_buffer.head, t = rx_buffer.tail;
   return (ring_buffer_pos_t)(Cfg::RX_SIZE + h - t) & (Cfg::RX_SIZE - 1);
 }
 
 template<typename Cfg>
-void MarlinSerial<Cfg>::flush() {
+void MarlinSerial<Cfg>::flush(void) {
   rx_buffer.tail = rx_buffer.head;
 
   if (Cfg::XONOFF) {
@@ -431,7 +431,7 @@ void MarlinSerial<Cfg>::write(const uint8_t c) {
 }
 
 template<typename Cfg>
-void MarlinSerial<Cfg>::flushTX() {
+void MarlinSerial<Cfg>::flushTX(void) {
   // TX
 
   if (Cfg::TX_SIZE == 0) {
@@ -520,7 +520,7 @@ void MarlinSerial<Cfg>::print(double n, int digits) {
 }
 
 template<typename Cfg>
-void MarlinSerial<Cfg>::println() {
+void MarlinSerial<Cfg>::println(void) {
   print('\r');
   print('\n');
 }

Marlin/src/HAL/HAL_DUE/MarlinSerial_Due.h

@@ -1,9 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
+ * 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
@@ -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:

Marlin/src/HAL/HAL_DUE/SanityCheck.h

@@ -1,9 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,7 +19,6 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  */
-#pragma once
 
 /**
  * Test Arduino Due specific configuration values for errors at compile-time.

Marlin/src/HAL/HAL_DUE/ServoTimers.h

@@ -36,8 +36,8 @@
 //!#define _useTimer4
 #define _useTimer5
 
-#define TRIM_DURATION             2   // compensation ticks to trim adjust for digitalWrite delays
-#define SERVO_TIMER_PRESCALER     32  // timer prescaler
+#define TRIM_DURATION       2    // compensation ticks to trim adjust for digitalWrite delays
+#define PRESCALER           32   // timer prescaler
 
 /*
   TC0, chan 0 => TC0_Handler
@@ -87,21 +87,5 @@
   #define HANDLER_FOR_TIMER5  TC0_Handler
 #endif
 
-typedef enum : unsigned char {
-  #ifdef _useTimer1
-    _timer1,
-  #endif
-  #ifdef _useTimer2
-    _timer2,
-  #endif
-  #ifdef _useTimer3
-    _timer3,
-  #endif
-  #ifdef _useTimer4
-    _timer4,
-  #endif
-  #ifdef _useTimer5
-    _timer5,
-  #endif
-  _Nbr_16timers
-} timer16_Sequence_t;
+//typedef enum { _timer1, _timer2, _timer3, _timer4, _timer5, _Nbr_16timers } timer16_Sequence_t;
+typedef enum { _timer3, _timer5, _Nbr_16timers } timer16_Sequence_t;

Marlin/src/HAL/HAL_DUE/Servo_Due.cpp

@@ -1,9 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
+ * 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
@@ -50,25 +50,25 @@
 
 static volatile int8_t Channel[_Nbr_16timers];              // counter for the servo being pulsed for each timer (or -1 if refresh interval)
 
-// ------------------------
+//------------------------------------------------------------------------------
 /// Interrupt handler for the TC0 channel 1.
-// ------------------------
+//------------------------------------------------------------------------------
 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) {
@@ -137,7 +137,7 @@ void initISR(timer16_Sequence_t timer) {
   #endif
 }
 
-void finISR(timer16_Sequence_t) {
+void finISR(timer16_Sequence_t timer) {
   #ifdef _useTimer1
     TC_Stop(TC_FOR_TIMER1, CHANNEL_FOR_TIMER1);
   #endif

Marlin/src/HAL/HAL_DUE/Tone.cpp

@@ -1,11 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
- *
- * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -31,7 +29,7 @@
 
 #include "../../inc/MarlinConfig.h"
 #include "HAL.h"
-#include "timers.h"
+#include "HAL_timers_Due.h"
 
 static pin_t tone_pin;
 volatile static int32_t toggles;

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

@@ -1,148 +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/>.
- *
- */
-
-/**
- * Based on u8g_com_std_sw_spi.c
- *
- * Universal 8bit Graphics Library
- *
- * Copyright (c) 2015, olikraus@gmail.com
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- *
- *  * Redistributions of source code must retain the above copyright notice, this list
- *    of conditions and the following disclaimer.
- *
- *  * Redistributions in binary form must reproduce the above copyright notice, this
- *    list of conditions and the following disclaimer in the documentation and/or other
- *    materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifdef ARDUINO_ARCH_SAM
-
-#include "../../../inc/MarlinConfigPre.h"
-
-#if HAS_GRAPHICAL_LCD && DISABLED(U8GLIB_ST7920)
-
-#undef SPI_SPEED
-#define SPI_SPEED 2  // About 2 MHz
-
-#include "u8g_com_HAL_DUE_sw_spi_shared.h"
-
-#include "../../shared/Marduino.h"
-#include "../../shared/Delay.h"
-
-#include <U8glib.h>
-
-#if ENABLED(FYSETC_MINI_12864)
-  #define SPISEND_SW_DUE u8g_spiSend_sw_DUE_mode_3
-#else
-  #define SPISEND_SW_DUE u8g_spiSend_sw_DUE_mode_0
-#endif
-
-uint8_t u8g_com_HAL_DUE_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) {
-  switch (msg) {
-    case U8G_COM_MSG_INIT:
-      SCK_pPio = g_APinDescription[u8g->pin_list[U8G_PI_SCK]].pPort;
-      SCK_dwMask = g_APinDescription[u8g->pin_list[U8G_PI_SCK]].ulPin;
-      MOSI_pPio = g_APinDescription[u8g->pin_list[U8G_PI_MOSI]].pPort;
-      MOSI_dwMask = g_APinDescription[u8g->pin_list[U8G_PI_MOSI]].ulPin;
-      u8g_SetPIOutput_DUE(u8g, U8G_PI_SCK);
-      u8g_SetPIOutput_DUE(u8g, U8G_PI_MOSI);
-      u8g_SetPIOutput_DUE(u8g, U8G_PI_CS);
-      u8g_SetPIOutput_DUE(u8g, U8G_PI_A0);
-      if (U8G_PIN_NONE != u8g->pin_list[U8G_PI_RESET]) u8g_SetPIOutput_DUE(u8g, U8G_PI_RESET);
-      u8g_SetPILevel_DUE(u8g, U8G_PI_SCK, 0);
-      u8g_SetPILevel_DUE(u8g, U8G_PI_MOSI, 0);
-      break;
-
-    case U8G_COM_MSG_STOP:
-      break;
-
-    case U8G_COM_MSG_RESET:
-      if (U8G_PIN_NONE != u8g->pin_list[U8G_PI_RESET]) u8g_SetPILevel_DUE(u8g, U8G_PI_RESET, arg_val);
-      break;
-
-    case U8G_COM_MSG_CHIP_SELECT:
-      #if ENABLED(FYSETC_MINI_12864)           // LCD SPI is running mode 3 while SD card is running mode 0
-        if (arg_val) {                        //   SCK idle state needs to be set to the proper idle state before
-                                               //   the next chip select goes active
-          u8g_SetPILevel_DUE(u8g, U8G_PI_SCK, 1);  //set SCK to mode 3 idle state before CS goes active
-          u8g_SetPILevel_DUE(u8g, U8G_PI_CS, LOW);
-        }
-        else {
-          u8g_SetPILevel_DUE(u8g, U8G_PI_CS, HIGH);
-          u8g_SetPILevel_DUE(u8g, U8G_PI_SCK, 0); //set SCK to mode 0 idle state after CS goes inactive
-        }
-      #else
-        u8g_SetPILevel_DUE(u8g, U8G_PI_CS, !arg_val);
-      #endif
-      break;
-
-    case U8G_COM_MSG_WRITE_BYTE:
-      SPISEND_SW_DUE(arg_val);
-      break;
-
-    case U8G_COM_MSG_WRITE_SEQ: {
-        uint8_t *ptr = (uint8_t *)arg_ptr;
-        while (arg_val > 0) {
-          SPISEND_SW_DUE(*ptr++);
-          arg_val--;
-        }
-      }
-      break;
-
-      case U8G_COM_MSG_WRITE_SEQ_P: {
-        uint8_t *ptr = (uint8_t *)arg_ptr;
-        while (arg_val > 0) {
-          SPISEND_SW_DUE(u8g_pgm_read(ptr));
-          ptr++;
-          arg_val--;
-        }
-      }
-      break;
-
-    case U8G_COM_MSG_ADDRESS:                     /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
-      u8g_SetPILevel_DUE(u8g, U8G_PI_A0, arg_val);
-      break;
-  }
-  return 1;
-}
-
-#endif // HAS_GRAPHICAL_LCD && !U8GLIB_ST7920
-#endif // ARDUINO_ARCH_SAM

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

@@ -1,112 +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/>.
- *
- */
-
-/**
- * Based on u8g_com_st7920_hw_spi.c
- *
- * Universal 8bit Graphics Library
- *
- * Copyright (c) 2011, olikraus@gmail.com
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- *
- *  * Redistributions of source code must retain the above copyright notice, this list
- *    of conditions and the following disclaimer.
- *
- *  * Redistributions in binary form must reproduce the above copyright notice, this
- *    list of conditions and the following disclaimer in the documentation and/or other
- *    materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifdef ARDUINO_ARCH_SAM
-
-#include "../../../inc/MarlinConfigPre.h"
-
-#if HAS_GRAPHICAL_LCD
-
-#include "../../shared/Delay.h"
-
-#include <U8glib.h>
-
-#include "u8g_com_HAL_DUE_sw_spi_shared.h"
-
-void u8g_SetPIOutput_DUE(u8g_t *u8g, uint8_t pin_index) {
-  PIO_Configure(g_APinDescription[u8g->pin_list[pin_index]].pPort, PIO_OUTPUT_1,
-    g_APinDescription[u8g->pin_list[pin_index]].ulPin, g_APinDescription[u8g->pin_list[pin_index]].ulPinConfiguration);  // OUTPUT
-}
-
-void u8g_SetPILevel_DUE(u8g_t *u8g, uint8_t pin_index, uint8_t level) {
-  volatile Pio* port = g_APinDescription[u8g->pin_list[pin_index]].pPort;
-  uint32_t mask = g_APinDescription[u8g->pin_list[pin_index]].ulPin;
-  if (level) port->PIO_SODR = mask; else port->PIO_CODR = mask;
-}
-
-Pio *SCK_pPio, *MOSI_pPio;
-uint32_t SCK_dwMask, MOSI_dwMask;
-
-void u8g_spiSend_sw_DUE_mode_0(uint8_t val) { // 3MHz
-  for (uint8_t i = 0; i < 8; i++) {
-    if (val & 0x80)
-      MOSI_pPio->PIO_SODR = MOSI_dwMask;
-    else
-      MOSI_pPio->PIO_CODR = MOSI_dwMask;
-    DELAY_NS(48);
-    SCK_pPio->PIO_SODR = SCK_dwMask;
-    DELAY_NS(905);
-    val <<= 1;
-    SCK_pPio->PIO_CODR = SCK_dwMask;
-  }
-}
-
-void u8g_spiSend_sw_DUE_mode_3(uint8_t val) { // 3.5MHz
-  for (uint8_t i = 0; i < 8; i++) {
-    SCK_pPio->PIO_CODR = SCK_dwMask;
-    DELAY_NS(50);
-    if (val & 0x80)
-      MOSI_pPio->PIO_SODR = MOSI_dwMask;
-    else
-      MOSI_pPio->PIO_CODR = MOSI_dwMask;
-    val <<= 1;
-    DELAY_NS(10);
-    SCK_pPio->PIO_SODR = SCK_dwMask;
-    DELAY_NS(70);
-  }
-}
-
-#endif // HAS_GRAPHICAL_LCD
-#endif // ARDUINO_ARCH_SAM

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

@@ -1,35 +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
-
-#include "../../../inc/MarlinConfigPre.h"
-#include "../../shared/Marduino.h"
-#include <U8glib.h>
-
-void u8g_SetPIOutput_DUE(u8g_t *u8g, uint8_t pin_index);
-void u8g_SetPILevel_DUE(u8g_t *u8g, uint8_t pin_index, uint8_t level);
-
-void u8g_spiSend_sw_DUE_mode_0(uint8_t val);
-void u8g_spiSend_sw_DUE_mode_3(uint8_t val);
-
-extern Pio *SCK_pPio, *MOSI_pPio;
-extern uint32_t SCK_dwMask, MOSI_dwMask;

Marlin/src/HAL/HAL_DUE/endstop_interrupts.h

@@ -1,9 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
+ * 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
@@ -38,46 +38,45 @@
 #include "../../module/endstops.h"
 
 // One ISR for all EXT-Interrupts
-void endstop_ISR() { endstops.update(); }
+void endstop_ISR(void) { endstops.update(); }
 
 /**
  *  Endstop interrupts for Due based targets.
  *  On Due, all pins support external interrupt capability.
  */
 
-void setup_endstop_interrupts() {
-  #define _ATTACH(P) attachInterrupt(digitalPinToInterrupt(P), endstop_ISR, CHANGE)
+void setup_endstop_interrupts(void) {
   #if HAS_X_MAX
-    _ATTACH(X_MAX_PIN);
+    attachInterrupt(digitalPinToInterrupt(X_MAX_PIN), endstop_ISR, CHANGE); // assign it
   #endif
   #if HAS_X_MIN
-    _ATTACH(X_MIN_PIN);
+    attachInterrupt(digitalPinToInterrupt(X_MIN_PIN), endstop_ISR, CHANGE);
   #endif
   #if HAS_Y_MAX
-    _ATTACH(Y_MAX_PIN);
+    attachInterrupt(digitalPinToInterrupt(Y_MAX_PIN), endstop_ISR, CHANGE);
   #endif
   #if HAS_Y_MIN
-    _ATTACH(Y_MIN_PIN);
+    attachInterrupt(digitalPinToInterrupt(Y_MIN_PIN), endstop_ISR, CHANGE);
   #endif
   #if HAS_Z_MAX
-    _ATTACH(Z_MAX_PIN);
+    attachInterrupt(digitalPinToInterrupt(Z_MAX_PIN), endstop_ISR, CHANGE);
   #endif
   #if HAS_Z_MIN
-     _ATTACH(Z_MIN_PIN);
+     attachInterrupt(digitalPinToInterrupt(Z_MIN_PIN), endstop_ISR, CHANGE);
   #endif
   #if HAS_Z2_MAX
-    _ATTACH(Z2_MAX_PIN);
+    attachInterrupt(digitalPinToInterrupt(Z2_MAX_PIN), endstop_ISR, CHANGE);
   #endif
   #if HAS_Z2_MIN
-    _ATTACH(Z2_MIN_PIN);
+    attachInterrupt(digitalPinToInterrupt(Z2_MIN_PIN), endstop_ISR, CHANGE);
   #endif
   #if HAS_Z3_MAX
-    _ATTACH(Z3_MAX_PIN);
+    attachInterrupt(digitalPinToInterrupt(Z3_MAX_PIN), endstop_ISR, CHANGE);
   #endif
   #if HAS_Z3_MIN
-    _ATTACH(Z3_MIN_PIN);
+    attachInterrupt(digitalPinToInterrupt(Z3_MIN_PIN), endstop_ISR, CHANGE);
   #endif
   #if HAS_Z_MIN_PROBE_PIN
-    _ATTACH(Z_MIN_PROBE_PIN);
+    attachInterrupt(digitalPinToInterrupt(Z_MIN_PROBE_PIN), endstop_ISR, CHANGE);
   #endif
 }

Marlin/src/HAL/HAL_DUE/fastio_Due.h

@@ -1,9 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
+ * 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
@@ -39,8 +39,6 @@
 
 #include <pins_arduino.h>
 
-#include "../../inc/MarlinConfigPre.h"
-
 /**
  * Utility functions
  */
@@ -48,6 +46,7 @@
 // Due has 12 PWMs assigned to logical pins 2-13.
 // 6, 7, 8 & 9 come from the PWM controller. The others come from the timers.
 #define PWM_PIN(P)              WITHIN(P, 2, 13)
+#define USEABLE_HARDWARE_PWM(P) PWM_PIN(P)
 
 #ifndef MASK
   #define MASK(PIN) (1 << PIN)
@@ -64,20 +63,28 @@
 // Read a pin
 #define _READ(IO) bool(DIO ## IO ## _WPORT -> PIO_PDSR & MASK(DIO ## IO ## _PIN))
 
+// Write to a pin
+#define _WRITE_VAR(IO,V) do { \
+  volatile Pio* port = digitalPinToPort(IO); \
+  const uint32_t mask = digitalPinToBitMask(IO); \
+  if (V) port->PIO_SODR = mask; \
+  else port->PIO_CODR = mask; \
+} while(0)
+
 // Write to a pin
 #define _WRITE(IO,V) do { \
   volatile Pio* port = (DIO ##  IO ## _WPORT); \
   const uint32_t mask = MASK(DIO ## IO ## _PIN); \
   if (V) port->PIO_SODR = mask; \
   else port->PIO_CODR = mask; \
-}while(0)
+} while(0)
 
 // Toggle a pin
 #define _TOGGLE(IO) _WRITE(IO, !READ(IO))
 
 #if MB(PRINTRBOARD_G2)
 
-  #include "fastio/G2_pins.h"
+  #include "G2_pins.h"
 
   // Set pin as input
   #define _SET_INPUT(IO) do{ \
@@ -154,6 +161,7 @@
 #define READ(IO)             _READ(IO)
 
 // Write to a pin (wrapper)
+#define WRITE_VAR(IO,V)      _WRITE_VAR(IO,V)
 #define WRITE(IO,V)          _WRITE(IO,V)
 
 // Toggle a pin (wrapper)
@@ -172,6 +180,8 @@
 #define IS_INPUT(IO)         ((digitalPinToPort(IO)->PIO_OSR & digitalPinToBitMask(IO)) == 0)
 // Check if pin is an output
 #define IS_OUTPUT(IO)        ((digitalPinToPort(IO)->PIO_OSR & digitalPinToBitMask(IO)) != 0)
+// Check if pin is a timer - Must be a constexpr
+#define HAS_TIMER(IO)         ((IO) >= 2 && (IO) <= 13)
 
 // Shorthand
 #define OUT_WRITE(IO,V)       { SET_OUTPUT(IO); WRITE(IO,V); }

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

@@ -1,22 +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

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

@@ -1,22 +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

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

@@ -1,22 +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

Marlin/src/HAL/HAL_DUE/persistent_store_eeprom.cpp

@@ -1,7 +1,7 @@
 /**
  * Marlin 3D Printer Firmware
  *
- * Copyright (c) 2019 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
@@ -29,16 +29,16 @@
 #include "../../inc/MarlinConfig.h"
 #include "../shared/persistent_store_api.h"
 
-#if !defined(E2END) && NONE(I2C_EEPROM, SPI_EEPROM)
+#if DISABLED(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 NONE(I2C_EEPROM, SPI_EEPROM)
+  #if DISABLED(I2C_EEPROM, SPI_EEPROM)
     eeprom_flush();
   #endif
   return true;

Marlin/src/HAL/HAL_DUE/pinsDebug.h

@@ -1,6 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
  *
  * 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
@@ -62,8 +65,9 @@
 
 #define digitalRead_mod(p) extDigitalRead(p)  // AVR digitalRead disabled PWM before it read the pin
 #define PRINT_PORT(p)
-#define PRINT_ARRAY_NAME(x) do{ sprintf_P(buffer, PSTR("%-" STRINGIFY(MAX_NAME_LENGTH) "s"), pin_array[x].name); SERIAL_ECHO(buffer); }while(0)
-#define PRINT_PIN(p) do{ sprintf_P(buffer, PSTR("%02d"), p); SERIAL_ECHO(buffer); }while(0)
+#define NAME_FORMAT(p) PSTR("%-##p##s")
+#define PRINT_ARRAY_NAME(x)  do {sprintf_P(buffer, PSTR("%-" STRINGIFY(MAX_NAME_LENGTH) "s"), pin_array[x].name); SERIAL_ECHO(buffer);} while (0)
+#define PRINT_PIN(p) do {sprintf_P(buffer, PSTR("%02d"), p); SERIAL_ECHO(buffer);} while (0)
 #define GET_ARRAY_PIN(p) pin_array[p].pin
 #define GET_ARRAY_IS_DIGITAL(p) pin_array[p].is_digital
 #define VALID_PIN(pin) (pin >= 0 && pin < (int8_t)NUMBER_PINS_TOTAL ? 1 : 0)

Marlin/src/HAL/HAL_DUE/spi_pins.h

@@ -1,9 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -26,22 +26,19 @@
  *
  * Available chip select pins for HW SPI are 4 10 52 77
  */
-#if SDSS == 4 || SDSS == 10 || SDSS == 52 || SDSS == 77 || SDSS == 87
-  #if SDSS == 4
+#if (SDSS == 4) || (SDSS == 10) || (SDSS == 52) || (SDSS == 77)
+  #if (SDSS == 4)
     #define SPI_PIN         87
     #define SPI_CHAN         1
-  #elif SDSS == 10
+  #elif (SDSS == 10)
     #define SPI_PIN         77
     #define SPI_CHAN         0
-  #elif SDSS == 52
+  #elif (SDSS == 52)
     #define SPI_PIN         86
     #define SPI_CHAN         2
-  #elif SDSS == 77
+  #else
     #define SPI_PIN         77
     #define SPI_CHAN         0
-  #else
-    #define SPI_PIN         87
-    #define SPI_CHAN         1
   #endif
   #define SCK_PIN           76
   #define MISO_PIN          74

Marlin/src/HAL/HAL_DUE/u8g_com_HAL_DUE_shared_hw_spi.cpp

@@ -1,9 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,57 +21,66 @@
  */
 
 
-/**
- * Based on u8g_com_msp430_hw_spi.c
- *
- * Universal 8bit Graphics Library
- *
- * Copyright (c) 2012, olikraus@gmail.com
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- *
- * * Redistributions of source code must retain the above copyright notice, this list
- * of conditions and the following disclaimer.
- *
- * * Redistributions in binary form must reproduce the above copyright notice, this
- * list of conditions and the following disclaimer in the documentation and/or other
- * materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
+/*
+
+  based on u8g_com_msp430_hw_spi.c
+
+  Universal 8bit Graphics Library
+
+  Copyright (c) 2012, olikraus@gmail.com
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without modification,
+  are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice, this list
+  of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions and the following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+  CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
 
 #ifdef __SAM3X8E__
 
-#include "../../../inc/MarlinConfigPre.h"
+#include "../../inc/MarlinConfigPre.h"
 
 #if HAS_GRAPHICAL_LCD
 
 #include <U8glib.h>
 
-#include "../../../Marlin.h"
+#include "../../Marlin.h"
+
+#define SPI_FULL_SPEED      0
+#define SPI_HALF_SPEED      1
+#define SPI_QUARTER_SPEED   2
+#define SPI_EIGHTH_SPEED    3
+#define SPI_SIXTEENTH_SPEED 4
+#define SPI_SPEED_5         5
+#define SPI_SPEED_6         6
 
 void spiBegin();
 void spiInit(uint8_t spiRate);
 void spiSend(uint8_t b);
 void spiSend(const uint8_t* buf, size_t n);
 
-#include "../../shared/Marduino.h"
-#include "../fastio.h"
+#include "../shared/Marduino.h"
+#include "fastio_Due.h"
 
 void u8g_SetPIOutput_DUE_hw_spi(u8g_t *u8g, uint8_t pin_index) {
    PIO_Configure(g_APinDescription[u8g->pin_list[pin_index]].pPort, PIO_OUTPUT_1,

Marlin/src/HAL/HAL_DUE/u8g_com_HAL_DUE_st7920_sw_spi.cpp

@@ -1,9 +1,9 @@
 /**
  * Marlin 3D Printer Firmware
- * Copyright (c) 2019 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
+ * 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
@@ -55,28 +55,53 @@
 
 #ifdef ARDUINO_ARCH_SAM
 
-#include "../../../inc/MarlinConfigPre.h"
+#include "../../inc/MarlinConfigPre.h"
 
-#if ENABLED(U8GLIB_ST7920)
+#if HAS_GRAPHICAL_LCD
 
-#include "../../shared/Delay.h"
+#include "../shared/Marduino.h"
+#include "../shared/Delay.h"
 
 #include <U8glib.h>
 
-#include "u8g_com_HAL_DUE_sw_spi_shared.h"
+void u8g_SetPIOutput_DUE(u8g_t *u8g, uint8_t pin_index) {
+  PIO_Configure(g_APinDescription[u8g->pin_list[pin_index]].pPort, PIO_OUTPUT_1,
+    g_APinDescription[u8g->pin_list[pin_index]].ulPin, g_APinDescription[u8g->pin_list[pin_index]].ulPinConfiguration);  // OUTPUT
+}
 
-#define SPISEND_SW_DUE u8g_spiSend_sw_DUE_mode_0
+void u8g_SetPILevel_DUE(u8g_t *u8g, uint8_t pin_index, uint8_t level) {
+  volatile Pio* port = g_APinDescription[u8g->pin_list[pin_index]].pPort;
+  uint32_t mask = g_APinDescription[u8g->pin_list[pin_index]].ulPin;
+  if (level) port->PIO_SODR = mask; else port->PIO_CODR = mask;
+}
+
+Pio *SCK_pPio, *MOSI_pPio;
+uint32_t SCK_dwMask, MOSI_dwMask;
+
+static void spiSend_sw_DUE(uint8_t val) { // 800KHz
+  for (uint8_t i = 0; i < 8; i++) {
+    if (val & 0x80)
+      MOSI_pPio->PIO_SODR = MOSI_dwMask;
+    else
+      MOSI_pPio->PIO_CODR = MOSI_dwMask;
+    DELAY_NS(48);
+    SCK_pPio->PIO_SODR = SCK_dwMask;
+    DELAY_NS(905); // 762 dead, 810 garbage, 858/0 900kHz, 905/1 825k, 953/1 800k, 1000/2 725KHz
+    val <<= 1;
+    SCK_pPio->PIO_CODR = SCK_dwMask;
+  }
+}
 
 static uint8_t rs_last_state = 255;
 
 static void u8g_com_DUE_st7920_write_byte_sw_spi(uint8_t rs, uint8_t val) {
   if (rs != rs_last_state) {  // time to send a command/data byte
     rs_last_state = rs;
-    SPISEND_SW_DUE(rs ? 0x0FA : 0x0F8); // Command or Data
+    spiSend_sw_DUE(rs ? 0x0FA : 0x0F8); // Command or Data
     DELAY_US(40); // give the controller some time to process the data: 20 is bad, 30 is OK, 40 is safe
   }
-  SPISEND_SW_DUE(val & 0xF0);
-  SPISEND_SW_DUE(val << 4);
+  spiSend_sw_DUE(val & 0xF0);
+  spiSend_sw_DUE(val << 4);
 }
 
 uint8_t u8g_com_HAL_DUE_ST7920_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) {
@@ -99,7 +124,7 @@ uint8_t u8g_com_HAL_DUE_ST7920_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_va
 
       u8g_Delay(5);
 
-      u8g->pin_list[U8G_PI_A0_STATE] = 0;       /* initial RS state: command mode */
+      u8g->pin_list[U8G_PI_A0_STATE] = 0;       /* inital RS state: command mode */
       break;
 
     case U8G_COM_MSG_STOP:
@@ -145,8 +170,8 @@ uint8_t u8g_com_HAL_DUE_ST7920_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_va
 }
 
 #if ENABLED(LIGHTWEIGHT_UI)
-  #include "../../../lcd/ultralcd.h"
-  #include "../../shared/HAL_ST7920.h"
+  #include "../../lcd/ultralcd.h"
+  #include "../shared/HAL_ST7920.h"
 
   #define ST7920_CS_PIN LCD_PINS_RS
 
@@ -166,20 +191,20 @@ uint8_t u8g_com_HAL_DUE_ST7920_sw_spi_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_va
   }
 
   void ST7920_set_cmd() {
-    SPISEND_SW_DUE(0xF8);
+    spiSend_sw_DUE(0xF8);
     DELAY_US(40);
   }
 
   void ST7920_set_dat() {
-    SPISEND_SW_DUE(0xFA);
+    spiSend_sw_DUE(0xFA);
     DELAY_US(40);
   }
 
   void ST7920_write_byte(const uint8_t val) {
-    SPISEND_SW_DUE(val & 0xF0);
-    SPISEND_SW_DUE(val << 4);
+    spiSend_sw_DUE(val & 0xF0);
+    spiSend_sw_DUE(val << 4);
   }
 #endif // LIGHTWEIGHT_UI
 
-#endif // U8GLIB_ST7920
+#endif // HAS_GRAPHICAL_LCD
 #endif // ARDUINO_ARCH_SAM

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

@@ -112,7 +112,7 @@
  * \def unused
  * \brief Marking \a v as a unused parameter or value.
  */
-#define unused(v)          do { (void)(v); }while(0)
+#define unused(v)          do { (void)(v); } while(0)
 
 /**
  * \def barrier
@@ -169,7 +169,7 @@
  * heuristics and inline the function no matter how big it thinks it
  * becomes.
  */
-#ifdef __CC_ARM
+#if defined(__CC_ARM)
 #   define __always_inline   __forceinline
 #elif (defined __GNUC__)
 #ifdef __always_inline
@@ -187,7 +187,7 @@
  * This annotation instructs the compiler to ignore its inlining
  * heuristics and not inline the function.
  */
-#ifdef __CC_ARM
+#if defined(__CC_ARM)
 #   define __no_inline   __attribute__((noinline))
 #elif (defined __GNUC__)
 #	define __no_inline   __attribute__((__noinline__))
@@ -204,7 +204,7 @@
  *
  * \param expr  Expression to evaluate and supposed to be nonzero.
  */
-#ifdef _ASSERT_ENABLE_
+#if defined(_ASSERT_ENABLE_)
 #  if defined(TEST_SUITE_DEFINE_ASSERT_MACRO)
      // Assert() is defined in unit_test/suite.h
 #    include "unit_test/suite.h"
@@ -230,7 +230,7 @@
 
 /* Define NO_INIT attribute */
 #if 0 //ndef NO_INIT
-#ifdef __CC_ARM
+#if defined   ( __CC_ARM   )
 #   define NO_INIT __attribute__((zero_init))
 #elif defined ( __ICCARM__ )
 #   define NO_INIT __no_init
@@ -262,7 +262,7 @@
 //! @{
 typedef unsigned char           Bool; //!< Boolean.
 #ifndef __cplusplus
-#ifndef __bool_true_false_are_defined
+#if !defined(__bool_true_false_are_defined)
 typedef unsigned char           bool; //!< Boolean.
 #endif
 #endif
@@ -443,7 +443,7 @@ typedef struct
 #define DISABLE   0
 #define ENABLE    1
 #ifndef __cplusplus
-#ifndef __bool_true_false_are_defined
+#if !defined(__bool_true_false_are_defined)
 #define false 0
 #define true 1
 #endif
@@ -998,14 +998,14 @@ typedef U8                  Byte;       //!< 8-bit unsigned integer.
 #endif  // #ifndef __ASSEMBLY__
 
 
-#ifdef __ICCARM__
+#if defined(__ICCARM__)
 #define SHORTENUM           __packed
 #elif defined(__GNUC__)
 #define SHORTENUM           __attribute__((packed))
 #endif
 
 /* No operation */
-#ifdef __ICCARM__
+#if defined(__ICCARM__)
 #define nop()               __no_operation()
 #elif defined(__GNUC__)
 #define nop()               (__NOP())

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

@@ -61,27 +61,27 @@ extern "C" {
  * Below BOARD_XXX macros are related to the specific board, and
  * should be defined by the board code, otherwise default value are used.
  */
-#ifndef BOARD_FREQ_SLCK_XTAL
+#if !defined(BOARD_FREQ_SLCK_XTAL)
 #  warning The board slow clock xtal frequency has not been defined.
 #  define BOARD_FREQ_SLCK_XTAL      (32768UL)
 #endif
 
-#ifndef BOARD_FREQ_SLCK_BYPASS
+#if !defined(BOARD_FREQ_SLCK_BYPASS)
 #  warning The board slow clock bypass frequency has not been defined.
 #  define BOARD_FREQ_SLCK_BYPASS    (32768UL)
 #endif
 
-#ifndef BOARD_FREQ_MAINCK_XTAL
+#if !defined(BOARD_FREQ_MAINCK_XTAL)
 #  warning The board main clock xtal frequency has not been defined.
 #  define BOARD_FREQ_MAINCK_XTAL    (12000000UL)
 #endif
 
-#ifndef BOARD_FREQ_MAINCK_BYPASS
+#if !defined(BOARD_FREQ_MAINCK_BYPASS)
 #  warning The board main clock bypass frequency has not been defined.
 #  define BOARD_FREQ_MAINCK_BYPASS  (12000000UL)
 #endif
 
-#ifndef BOARD_OSC_STARTUP_US
+#if !defined(BOARD_OSC_STARTUP_US)
 #  warning The board main clock xtal startup time has not been defined.
 #  define BOARD_OSC_STARTUP_US      (15625UL)
 #endif

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

@@ -15,11 +15,11 @@ extern "C" {
 
 #define SD_MMC_BLOCK_SIZE 512
 
-void sd_mmc_spi_mem_init() {
+void sd_mmc_spi_mem_init(void) {
 }
 
-Ctrl_status sd_mmc_spi_test_unit_ready() {
-  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted())
+Ctrl_status sd_mmc_spi_test_unit_ready(void) {
+  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isDetected())
     return CTRL_NO_PRESENT;
   return CTRL_GOOD;
 }
@@ -27,18 +27,24 @@ Ctrl_status sd_mmc_spi_test_unit_ready() {
 // NOTE: This function is defined as returning the address of the last block
 // in the card, which is cardSize() - 1
 Ctrl_status sd_mmc_spi_read_capacity(uint32_t *nb_sector) {
-  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted())
+  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isDetected())
     return CTRL_NO_PRESENT;
   *nb_sector = card.getSd2Card().cardSize() - 1;
   return CTRL_GOOD;
 }
 
-bool sd_mmc_spi_unload(bool) { return true; }
+bool sd_mmc_spi_unload(bool unload) {
+  return true;
+}
 
-bool sd_mmc_spi_wr_protect() { return false; }
+bool sd_mmc_spi_wr_protect(void) {
+  return false;
+}
 
-bool sd_mmc_spi_removal() {
-  return (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted());
+bool sd_mmc_spi_removal(void) {
+  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isDetected())
+    return true;
+  return false;
 }
 
 #if ACCESS_USB == true
@@ -55,7 +61,7 @@ uint8_t sector_buf[SD_MMC_BLOCK_SIZE];
 // #define DEBUG_MMC
 
 Ctrl_status sd_mmc_spi_usb_read_10(uint32_t addr, uint16_t nb_sector) {
-  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted())
+  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isDetected())
     return CTRL_NO_PRESENT;
 
   #ifdef DEBUG_MMC
@@ -92,7 +98,7 @@ Ctrl_status sd_mmc_spi_usb_read_10(uint32_t addr, uint16_t nb_sector) {
 }
 
 Ctrl_status sd_mmc_spi_usb_write_10(uint32_t addr, uint16_t nb_sector) {
-  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isMounted())
+  if (!IS_SD_INSERTED() || IS_SD_PRINTING() || IS_SD_FILE_OPEN() || !card.isDetected())
     return CTRL_NO_PRESENT;
 
   #ifdef DEBUG_MMC

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

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

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

@@ -94,11 +94,11 @@ typedef struct {
 	uint16_t payload_size;
 
 	//! Callback called after reception of ZLP from setup request
-	void (*callback)(void);
+	void (*callback) (void);
 
 	//! Callback called when the buffer given (.payload) is full or empty.
 	//! This one return false to abort data transfer, or true with a new buffer in .payload.
-	bool (*over_under_run)(void);
+	bool(*over_under_run) (void);
 } udd_ctrl_request_t;
 extern udd_ctrl_request_t udd_g_ctrlreq;
 
@@ -123,7 +123,7 @@ extern udd_ctrl_request_t udd_g_ctrlreq;
  * Registered by routine udd_ep_wait_stall_clear()
  * Callback called when endpoint stall is cleared.
  */
-typedef void (*udd_callback_halt_cleared_t)(void);
+typedef void (*udd_callback_halt_cleared_t) (void);
 
 /**
  * \brief End of transfer callback function type.

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

@@ -82,7 +82,7 @@ typedef struct {
 	 *
 	 * \return \c 1 if function was successfully done, otherwise \c 0.
 	 */
-	bool (*enable)(void);
+	bool(*enable) (void);
 
 	/**
 	 * \brief Disable the interface.
@@ -95,7 +95,7 @@ typedef struct {
 	 * - the device is detached from the host (i.e. Vbus is no
 	 *   longer present)
 	 */
-	void (*disable)(void);
+	void (*disable) (void);
 
 	/**
 	 * \brief Handle a control request directed at an interface.
@@ -108,7 +108,7 @@ typedef struct {
 	 *
 	 * \return \c 1 if this interface supports the SETUP request, otherwise \c 0.
 	 */
-	bool (*setup)(void);
+	bool(*setup) (void);
 
 	/**
 	 * \brief Returns the current setting of the selected interface.
@@ -117,12 +117,12 @@ typedef struct {
 	 *
 	 * \return alternate setting of selected interface
 	 */
-	uint8_t (*getsetting)(void);
+	uint8_t(*getsetting) (void);
 
 	/**
 	 * \brief To signal that a SOF is occurred
 	 */
-	void (*sof_notify)(void);
+	void(*sof_notify) (void);
 } udi_api_t;
 
 //@}

Marlin/src/HAL/HAL_DUE/usb/udi_cdc.c

@@ -458,7 +458,7 @@ void udi_cdc_data_sof_notify(void)
 }
 
 
-// ------------------------
+//-------------------------------------------------
 //------- Internal routines to control serial line
 
 static uint8_t udi_cdc_setup_to_port(void)
@@ -579,7 +579,7 @@ static void udi_cdc_serial_state_msg_sent(udd_ep_status_t status, iram_size_t n,
 }
 
 
-// ------------------------
+//-------------------------------------------------
 //------- Internal routines to process data transfer
 
 
@@ -781,7 +781,7 @@ static void udi_cdc_tx_send(uint8_t port)
 }
 
 
-// ------------------------
+//---------------------------------------------
 //------- Application interface
 
 

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

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

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

@@ -50,7 +50,7 @@
 #include "usb_protocol_cdc.h"
 #include "conf_usb.h"
 
-#ifndef UDI_CDC_PORT_NB
+#ifndef  UDI_CDC_PORT_NB
 # define  UDI_CDC_PORT_NB 1
 #endif
 

Marlin/src/HAL/HAL_DUE/usb/udi_composite_desc.c

@@ -67,9 +67,9 @@ UDC_DESC_STORAGE usb_dev_desc_t udc_device_desc = {
   .bLength                   = sizeof(usb_dev_desc_t),
   .bDescriptorType           = USB_DT_DEVICE,
   .bcdUSB                    = LE16(USB_V2_0),
-  .bDeviceClass              = CDC_CLASS_MULTI,
-  .bDeviceSubClass           = CDC_SUBCLASS_ACM,
-  .bDeviceProtocol           = CDC_PROTOCOL_V25TER,
+  .bDeviceClass              = 0,
+  .bDeviceSubClass           = 0,
+  .bDeviceProtocol           = 0,
   .bMaxPacketSize0           = USB_DEVICE_EP_CTRL_SIZE,
   .idVendor                  = LE16(USB_DEVICE_VENDOR_ID),
   .idProduct                 = LE16(USB_DEVICE_PRODUCT_ID),
@@ -101,9 +101,9 @@ UDC_DESC_STORAGE usb_dev_qual_desc_t udc_device_qual = {
   .bLength                   = sizeof(usb_dev_qual_desc_t),
   .bDescriptorType           = USB_DT_DEVICE_QUALIFIER,
   .bcdUSB                    = LE16(USB_V2_0),
-  .bDeviceClass              = CDC_CLASS_MULTI,
-  .bDeviceSubClass           = CDC_SUBCLASS_ACM,
-  .bDeviceProtocol           = CDC_PROTOCOL_V25TER,
+  .bDeviceClass              = 0,
+  .bDeviceSubClass           = 0,
+  .bDeviceProtocol           = 0,
   .bMaxPacketSize0           = USB_DEVICE_EP_CTRL_SIZE,
   .bNumConfigurations        = 1
 };

Marlin/src/HAL/HAL_DUE/usb/udi_msc.c

@@ -457,7 +457,7 @@ uint8_t udi_msc_getsetting(void)
 }
 
 
-// ------------------------
+//---------------------------------------------
 //------- Routines to process CBW packet
 
 static void udi_msc_cbw_invalid(void)
@@ -613,7 +613,7 @@ static bool udi_msc_cbw_validate(uint32_t alloc_len, uint8_t dir_flag)
 }
 
 
-// ------------------------
+//---------------------------------------------
 //------- Routines to process small data packet
 
 static void udi_msc_data_send(uint8_t * buffer, uint8_t buf_size)
@@ -645,7 +645,7 @@ static void udi_msc_data_sent(udd_ep_status_t status, iram_size_t nb_sent,
 }
 
 
-// ------------------------
+//---------------------------------------------
 //------- Routines to process CSW packet
 
 static void udi_msc_csw_process(void)
@@ -691,7 +691,7 @@ static void udi_msc_csw_sent(udd_ep_status_t status, iram_size_t nb_sent,
 }
 
 
-// ------------------------
+//---------------------------------------------
 //------- Routines manage sense data
 
 static void udi_msc_clear_sense(void)
@@ -757,7 +757,7 @@ static void udi_msc_sense_command_invalid(void)
 }
 
 
-// ------------------------
+//---------------------------------------------
 //------- Routines manage SCSI Commands
 
 static void udi_msc_spc_requestsense(void)

Marlin/src/HAL/HAL_DUE/usb/uotghs_device_due.c

@@ -40,7 +40,6 @@
  * \asf_license_stop
  *
  */
-
 /*
  * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
  */
@@ -506,7 +505,7 @@ static bool udd_ep_interrupt(void);
 //@}
 
 
-// ------------------------
+//--------------------------------------------------------
 //--- INTERNAL ROUTINES TO MANAGED GLOBAL EVENTS
 
 /**
@@ -1307,7 +1306,7 @@ void udd_test_mode_packet(void)
 
 
 
-// ------------------------
+//--------------------------------------------------------
 //--- INTERNAL ROUTINES TO MANAGED THE CONTROL ENDPOINT
 
 static void udd_reset_ep_ctrl(void)
@@ -1729,7 +1728,7 @@ static bool udd_ctrl_interrupt(void)
 }
 
 
-// ------------------------
+//--------------------------------------------------------
 //--- INTERNAL ROUTINES TO MANAGED THE BULK/INTERRUPT/ISOCHRONOUS ENDPOINTS
 
 #if (0 != USB_DEVICE_MAX_EP)
@@ -1905,7 +1904,7 @@ static void udd_ep_in_sent(udd_ep_id_t ep)
 		ptr_src = &ptr_job->buf[ptr_job->buf_cnt];
 		nb_remain = ptr_job->buf_size - ptr_job->buf_cnt;
 		// Fill a bank even if no data (ZLP)
-		nb_data = min(nb_remain, pkt_size);
+		nb_data = MIN(nb_remain, pkt_size);
 		// Modify job information
 		ptr_job->buf_cnt += nb_data;
 		ptr_job->buf_load = nb_data;

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

@@ -291,7 +291,7 @@ extern "C" {
   //! available greater size, then applies register format of UOTGHS controller
   //! for endpoint size bit-field.
 #undef udd_format_endpoint_size
-#define udd_format_endpoint_size(size)            (32 - clz(((uint32_t)min(max(size, 8), 1024) << 1) - 1) - 1 - 3)
+#define udd_format_endpoint_size(size)            (32 - clz(((uint32_t)MIN(MAX(size, 8), 1024) << 1) - 1) - 1 - 3)
   //! Configures the selected endpoint size
 #define udd_configure_endpoint_size(ep, size)     (Wr_bitfield(UOTGHS_ARRAY(UOTGHS_DEVEPTCFG[0], ep), UOTGHS_DEVEPTCFG_EPSIZE_Msk, udd_format_endpoint_size(size)))
   //! Gets the configured selected endpoint size