Merge pull request #55 from g0dsCookie/CrealityDwin_2.0

Fixed include paths
Update max bed thermal limits for large dc bed at high temps
2019-09-17 08:58:44 -04:00 · 2019-09-16 22:22:11 -04:00 · 2019-09-09 10:09:54 -04:00 · 2019-09-08 22:52:08 -04:00 · 2019-09-08 19:58:39 -04:00 · 2019-09-08 19:58:28 -04:00
1235 changed files with 202779 additions and 221153 deletions
@@ -0,0 +1,274 @@
+# Python CircleCI 2.0 configuration file
+#
+# Check https://circleci.com/docs/2.0/language-python/ for more details
+#
+version: 2
+jobs:
+  build:
+    docker:
+      # specify the version you desire here
+      # use `-browsers` prefix for selenium tests, e.g. `3.6.1-browsers`
+      - image: circleci/python:2.7.13
+
+      # Specify service dependencies here if necessary
+      # CircleCI maintains a library of pre-built images
+      # documented at https://circleci.com/docs/2.0/circleci-images/
+      # - image: circleci/postgres:9.4
+    environment:
+      TEST_PLATFORM: "-e megaatmega2560"
+
+    working_directory: ~/Marlin
+
+    steps:
+      - checkout
+
+      - restore_cache:
+          paths:
+          - ~/.platformio
+          - ~/Marlin/.piolibdeps
+          keys:
+          - v1-dependencies-{{ checksum "~/Marlin/platformio.ini" }}
+          # fallback to using the latest cache if no exact match is found
+          - v1-dependencies-
+
+      - run:
+          name: install dependencies
+          command: |
+            sudo pip install -U platformio
+
+      # run tests!
+      - run:
+          name: run tests
+          command: |
+            #
+            #
+            # Fetch the tag information for the current branch
+            ls -la
+            git fetch origin --tags
+            #
+            # Publish the buildroot script folder
+            chmod +x buildroot/bin/*
+            export PATH=`pwd`/buildroot/bin/:${PATH}
+
+            # Generate custom version include
+            generate_version ./Marlin/src/inc
+            cat ./Marlin/src/inc/_Version.h
+            #
+            # Back up pins_RAMPS.h
+            #
+            backup_ramps
+
+            env_backup
+
+            #################################
+            # Build all sample configurations
+            #################################
+
+            echo testing megaatmega2560 targets...
+            export TEST_PLATFORM="-e megaatmega2560"
+            echo use_example_configs adafruit/ST7565
+            use_example_configs adafruit/ST7565
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs BQ/Hephestos
+            use_example_configs BQ/Hephestos
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs BQ/Hephestos_2
+            use_example_configs BQ/Hephestos_2
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs BQ/WITBOX
+            use_example_configs BQ/WITBOX
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs AliExpress/CL-260
+            use_example_configs AliExpress/CL-260
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            #echo use_example_configs Cartesio
+            #use_example_configs Cartesio
+            #build_marlin_pio ./ ${TEST_PLATFORM}
+            #restore_configs
+            echo use_example_configs delta/FLSUN/auto_calibrate
+            use_example_configs delta/FLSUN/auto_calibrate
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs delta/FLSUN/kossel_mini
+            use_example_configs delta/FLSUN/kossel_mini
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs delta/generic
+            use_example_configs delta/generic
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs delta/kossel_mini
+            use_example_configs delta/kossel_mini
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs delta/kossel_xl
+            use_example_configs delta/kossel_xl
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs Felix
+            use_example_configs Felix
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs Felix/DUAL
+            use_example_configs Felix/DUAL
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs FolgerTech/i3-2020
+            use_example_configs FolgerTech/i3-2020
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs gCreate/gMax1.5+
+            use_example_configs gCreate/gMax1.5+
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs Geeetech/GT2560
+            use_example_configs Geeetech/GT2560
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            #echo use_example_configs Geeetech/I3_Pro_X-GT2560
+            #use_example_configs Geeetech/I3_Pro_X-GT2560
+            #build_marlin_pio ./ ${TEST_PLATFORM}
+            #restore_configs
+            echo use_example_configs Infitary/i3-M508
+            use_example_configs Infitary/i3-M508
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            use_example_configs Malyan/M200
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs Micromake/C1/basic
+            use_example_configs Micromake/C1/basic
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs Micromake/C1/enhanced
+            use_example_configs Micromake/C1/enhanced
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs RepRapWorld/Megatronics
+            use_example_configs RepRapWorld/Megatronics
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs RigidBot
+            use_example_configs RigidBot
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs SCARA
+            use_example_configs SCARA
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs Velleman/K8200
+            use_example_configs Velleman/K8200
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs Velleman/K8400/Dual-head
+            use_example_configs Velleman/K8400/Dual-head
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs Velleman/K8400
+            use_example_configs Velleman/K8400
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs Wanhao/Duplicator6
+            use_example_configs Wanhao/Duplicator6
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            # Requires manual load of https://github.com/stawel/SlowSoftI2CMaster
+            #use_example_configs wt150
+            #build_marlin_pio ./ ${TEST_PLATFORM}
+            #restore_configs
+            echo testing melzi targets...
+            export TEST_PLATFORM="-e melzi"
+            echo use_example_configs Anet/A6
+            use_example_configs Anet/A6
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs Anet/A8
+            use_example_configs Anet/A8
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs Creality/CR-10
+            use_example_configs Creality/CR-10
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs Malyan/M150
+            use_example_configs Malyan/M150
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs Sanguinololu
+            use_example_configs Sanguinololu
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs TinyBoy2
+            use_example_configs TinyBoy2
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+
+            echo testing rambo targets...
+            export TEST_PLATFORM="-e rambo"
+            echo use_example_configs AlephObjects/TAZ4
+            use_example_configs AlephObjects/TAZ4
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+
+            echo testing at90usb1286_* targets...
+            export TEST_PLATFORM="-e at90usb1286_dfu"
+            #echo se_example_configs delta/kossel_pro
+            #use_example_configs delta/kossel_pro
+            #build_marlin_pio ./ ${TEST_PLATFORM}
+            #restore_configs
+            echo use_example_configs makibox
+            use_example_configs makibox
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+
+            echo testing sanguino_atmega644p targets...
+            export TEST_PLATFORM="-e sanguino_atmega644p"
+            echo use_example_configs tvrrug/Round2
+            use_example_configs tvrrug/Round2
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+
+            echo testing LPC1768 targets...
+            export TEST_PLATFORM="-e LPC1768"
+            echo use_example_configs Mks/Sbase
+            use_example_configs Mks/Sbase
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo testing STM32F1 targets...
+            export TEST_PLATFORM="-e STM32F1"
+            restore_configs
+            echo use_example_configs STM32/STM32F10
+            use_example_configs STM32/STM32F10
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+            echo use_example_configs STM32/stm32f103ret6
+            use_example_configs STM32/stm32f103ret6
+            build_marlin_pio ./ ${TEST_PLATFORM}
+            restore_configs
+
+            echo testing DUE targets...
+            export TEST_PLATFORM="-e DUE"
+            #echo use_example_configs UltiMachine/Archim2
+            #use_example_configs UltiMachine/Archim2
+            #build_marlin_pio ./ ${TEST_PLATFORM}
+            #restore_configs
+
+            #
+            # Remove temp files from dependencies tree prior to caching
+            rm -rf ~/Marlin/.piolibdeps/_tmp_*
+
+            #
+            # Restore the environment
+            #
+            env_restore
+
+      - save_cache:
+          paths:
+          - ~/.platformio
+          - ~/Marlin/.piolibdeps
+          key: v1-dependencies-{{ checksum "~/Marlin/platformio.ini" }}
@@ -1,25 +0,0 @@
-#
-# bump-date.yml
-# Bump the distribution date once per day
-#
-
-name: Bump Distribution Date
-
-on:
-  schedule:
-    - cron:  '0 0 * * *'
-
-jobs:
-  bump_date:
-
-    runs-on: ubuntu-latest
-
-    steps:
-
-    - name: Check out bugfix-2.0.x
-      uses: actions/checkout@v2
-      with:
-        ref: bugfix-2.0.x
-
-    - name: Bump Distribution Date
-      run: source ./buildroot/bin/bump_date
@@ -1,100 +0,0 @@
-#
-# test-builds.yml
-# Do test builds to catch compile errors
-#
-
-name: CI
-
-on:
-  pull_request:
-    branches:
-    - bugfix-2.0.x
-    - dev-2.1.x
-    paths-ignore:
-    - config/**
-    - data/**
-    - docs/**
-    - '**/*.md'
-
-jobs:
-  test_builds:
-
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        test-platform:
-        # Base Environments
-
-        - DUE
-        - esp32
-        - linux_native
-        - megaatmega2560
-        - teensy31
-        - teensy35
-
-        # Extended AVR Environments
-
-        - FYSETC_F6_13
-        - megaatmega1280
-        - rambo
-        - sanguino_atmega1284p
-        - sanguino_atmega644p
-
-        # Extended STM32 Environments
-
-        - STM32F103RC_bigtree
-        - STM32F103RC_bigtree_USB
-        - STM32F103RE_bigtree
-        - STM32F103RE_bigtree_USB
-        - STM32F103RC_fysetc
-        - jgaurora_a5s_a1
-        - STM32F103VE_longer
-        - STM32F407VE_black
-        - BIGTREE_SKR_PRO
-        - mks_robin
-        - ARMED
-
-        # Put lengthy tests last
-
-        - LPC1768
-        - LPC1769
-
-        # STM32 with non-STM framework. both broken for now. they should use HAL_STM32 which is working.
-
-        #- STM32F4
-        #- STM32F7
-
-        # Non-working environment tests
-
-        #- BIGTREE_BTT002
-        #- at90usb1286_cdc
-        #- at90usb1286_dfu
-        #- STM32F103CB_malyan
-        #- mks_robin_lite
-        #- mks_robin_mini
-        #- mks_robin_nano
-        #- SAMD51_grandcentral_m4
-
-    steps:
-
-    - name: Select Python 3.7
-      uses: actions/setup-python@v1
-      with:
-        python-version: '3.7' # Version range or exact version of a Python version to use, using semvers version range syntax.
-        architecture: 'x64' # optional x64 or x86. Defaults to x64 if not specified
-
-    - name: Install PlatformIO
-      run: |
-        pip install -U https://github.com/platformio/platformio-core/archive/master.zip
-        platformio update
-
-    - name: Check out the PR
-      uses: actions/checkout@v2
-
-    - name: Run ${{ matrix.test-platform }} Tests
-      run: |
-        chmod +x buildroot/bin/*
-        chmod +x buildroot/share/tests/*
-        export PATH=./buildroot/bin/:./buildroot/share/tests/:${PATH}
-        run_tests . ${{ matrix.test-platform }}
@@ -0,0 +1,51 @@
+dist: bionic
+sudo: false
+
+language: python
+python:
+  - "3.7"
+
+notifications:
+  email: false
+
+env:
+  - TEST_PLATFORM="megaatmega2560"
+  - TEST_PLATFORM="DUE"
+  - TEST_PLATFORM="LPC1768"
+  - TEST_PLATFORM="LPC1769"
+  - TEST_PLATFORM="STM32F1"
+  - TEST_PLATFORM="teensy31"
+  - TEST_PLATFORM="teensy35"
+  - TEST_PLATFORM="linux_native"
+  - TEST_PLATFORM="esp32"
+  - TEST_PLATFORM="alfawise_U20"
+  - TEST_PLATFORM="black_stm32f407ve"
+  - TEST_PLATFORM="adafruit_grandcentral_m4"
+
+before_install:
+  #
+  # Fetch the tag information for the current branch
+  - git fetch origin --tags
+  #
+  # Publish the buildroot script folder
+  - chmod +x ${TRAVIS_BUILD_DIR}/buildroot/bin/*
+  - chmod +x ${TRAVIS_BUILD_DIR}/buildroot/share/tests/*
+  - export PATH=${TRAVIS_BUILD_DIR}/buildroot/bin/:${TRAVIS_BUILD_DIR}/buildroot/share/tests/:${PATH}
+
+install:
+  #- pip install -U platformio
+  - pip install -U https://github.com/platformio/platformio-core/archive/master.zip
+
+before_script:
+  # Update PlatformIO packages
+  - platformio update
+  #
+  # Change current working directory to the build dir
+  - cd ${TRAVIS_BUILD_DIR}
+  #
+  # Generate custom version include
+  - generate_version ${TRAVIS_BUILD_DIR}/Marlin/src/inc
+  - cat ${TRAVIS_BUILD_DIR}/Marlin/src/inc/_Version.h
+  #
+script:
+  - run_tests ${TRAVIS_BUILD_DIR} ${TEST_PLATFORM}
@@ -92,9 +92,6 @@ U8GLIB             ?= 1
 # this defines whether to include the Trinamic TMCStepper library
 TMC                ?= 1

-# this defines whether to include the AdaFruit NeoPixel library
-NEOPIXEL           ?= 0
-
 ############
 # Try to automatically determine whether RELOC_WORKAROUND is needed based
 # on GCC versions:
@@ -188,7 +185,7 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1109)
 else ifeq ($(HARDWARE_MOTHERBOARD),1110)
 # zrib V2.0 control board (Chinese knock off RAMPS replica)
 else ifeq ($(HARDWARE_MOTHERBOARD),1111)
-# BigTreeTech or BIQU KFB2.0
+# Bigtreetech or BIQU KFB2.0
 else ifeq ($(HARDWARE_MOTHERBOARD),1112)
 # Felix 2.0+ Electronics Board (RAMPS like)
 else ifeq ($(HARDWARE_MOTHERBOARD),1113)
@@ -254,14 +251,6 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1141)
 else ifeq ($(HARDWARE_MOTHERBOARD),1142)
 # Overlord/Overlord Pro
 else ifeq ($(HARDWARE_MOTHERBOARD),1143)
-# ADIMLab Gantry v1
-else ifeq ($(HARDWARE_MOTHERBOARD),1144)
-# ADIMLab Gantry v2
-else ifeq ($(HARDWARE_MOTHERBOARD),1145)
-# BIQU Tango V1
-else ifeq ($(HARDWARE_MOTHERBOARD),1146)
-# MKS GEN L V2
-else ifeq ($(HARDWARE_MOTHERBOARD),1147)

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

 #
 # ATmega1281, ATmega2561
@@ -700,7 +687,7 @@ CXXSTANDARD = -std=gnu++11
 CDEBUG = -g$(DEBUG)
 CWARN   = -Wall -Wstrict-prototypes -Wno-packed-bitfield-compat -Wno-pragmas -Wunused-parameter
 CXXWARN = -Wall                     -Wno-packed-bitfield-compat -Wno-pragmas -Wunused-parameter
-CTUNING = -fsigned-char -funsigned-bitfields -fno-exceptions \
+CTUNING = -fsigned-char -funsigned-bitfields -fpack-struct -fno-exceptions \
          -fshort-enums -ffunction-sections -fdata-sections
 ifneq ($(HARDWARE_MOTHERBOARD),)
  CTUNING += -DMOTHERBOARD=${HARDWARE_MOTHERBOARD}
@@ -1,76 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-#pragma once
-
-////////////////////////////
-// VENDOR VERSION EXAMPLE //
-////////////////////////////
-
-/**
- * Marlin release version identifier
- */
-//#define SHORT_BUILD_VERSION "bugfix-2.0.x"
-
-/**
- * Verbose version identifier which should contain a reference to the location
- * from where the binary was downloaded or the source code was compiled.
- */
-//#define DETAILED_BUILD_VERSION SHORT_BUILD_VERSION " (Github)"
-
-/**
- * The STRING_DISTRIBUTION_DATE represents when the binary file was built,
- * here we define this default string as the date where the latest release
- * version was tagged.
- */
-//#define STRING_DISTRIBUTION_DATE "2019-07-10"
-
-/**
- * Defines a generic printer name to be output to the LCD after booting Marlin.
- */
-//#define MACHINE_NAME "3D Printer"
-
-/**
- * The SOURCE_CODE_URL is the location where users will find the Marlin Source
- * Code which is installed on the device. In most cases —unless the manufacturer
- * has a distinct Github fork— the Source Code URL should just be the main
- * Marlin repository.
- */
-//#define SOURCE_CODE_URL "https://github.com/MarlinFirmware/Marlin"
-
-/**
- * Default generic printer UUID.
- */
-//#define DEFAULT_MACHINE_UUID "cede2a2f-41a2-4748-9b12-c55c62f367ff"
-
-/**
- * The WEBSITE_URL is the location where users can get more information such as
- * documentation about a specific Marlin release.
- */
-//#define WEBSITE_URL "http://marlinfw.org"
-
-/**
- * Set the vendor info the serial USB interface, if changable
- * Currently only supported by DUE platform
- */
-//#define  USB_DEVICE_VENDOR_ID           0x0000
-//#define  USB_DEVICE_PRODUCT_ID          0x0000
-//#define  USB_DEVICE_MANUFACTURE_NAME    WEBSITE_URL
@@ -0,0 +1,94 @@
+/**
+ * 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
+};
@@ -1,9 +1,9 @@
 /**
 * Marlin 3D Printer Firmware
- * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
 * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -19,7 +19,6 @@
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
-#pragma once

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

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

 //
@@ -52,5 +63,12 @@ const unsigned char status_logo_bmp[] PROGMEM = {
 //
 #define STATUS_HOTEND_ANIM
 #define STATUS_BED_ANIM
-#define STATUS_HEATERS_X      48
-#define STATUS_BED_X          74
+#if HOTENDS < 2
+  #define STATUS_LOGO_X          8
+  #define STATUS_HEATERS_X      40
+  #define STATUS_BED_X          72
+#else
+  #define STATUS_LOGO_X          0
+  #define STATUS_HEATERS_X      32
+  #define STATUS_BED_X          80
+#endif
@@ -24,11 +24,3 @@
 #include "platforms.h"

 #include HAL_PATH(.,HAL.h)
-
-#define HAL_ADC_RANGE _BV(HAL_ADC_RESOLUTION)
-
-inline void watchdog_refresh() {
-  #if ENABLED(USE_WATCHDOG)
-    HAL_watchdog_refresh();
-  #endif
-}
@@ -35,7 +35,7 @@
 // Public functions
 // ------------------------

-void HAL_init() {
+void HAL_init(void) {
  // Init Servo Pins
  #define INIT_SERVO(N) OUT_WRITE(SERVO##N##_PIN, LOW)
  #if HAS_SERVO_0
@@ -25,7 +25,7 @@
 #include "math.h"

 #ifdef USBCON
-  #include <HardwareSerial.h>
+  #include "HardwareSerial.h"
 #else
  #define HardwareSerial_h // Hack to prevent HardwareSerial.h header inclusion
  #include "MarlinSerial.h"
@@ -38,14 +38,6 @@
 #include <avr/interrupt.h>
 #include <avr/io.h>

-#ifndef pgm_read_ptr
-  // Compatibility for avr-libc 1.8.0-4.1 included with Ubuntu for
-  // Windows Subsystem for Linux on Windows 10 as of 10/18/2019
-  #define pgm_read_ptr_far(address_long) (void*)__ELPM_word((uint32_t)(address_long))
-  #define pgm_read_ptr_near(address_short) (void*)__LPM_word((uint16_t)(address_short))
-  #define pgm_read_ptr(address_short) pgm_read_ptr_near(address_short)
-#endif
-
 // ------------------------
 // Defines
 // ------------------------
@@ -113,19 +105,19 @@ typedef int8_t pin_t;
 // Public functions
 // ------------------------

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

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

 //void _delay_ms(const int delay);

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

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

@@ -154,7 +146,8 @@ extern "C" {
 #define DISABLE_TEMPERATURE_INTERRUPT()    CBI(TIMSK0, OCIE0B)
 #define TEMPERATURE_ISR_ENABLED()         TEST(TIMSK0, OCIE0B)

-FORCE_INLINE void HAL_timer_start(const uint8_t timer_num, const uint32_t) {
+FORCE_INLINE void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
+  UNUSED(frequency);
  switch (timer_num) {
    case STEP_TIMER_NUM:
      // waveform generation = 0100 = CTC
@@ -206,9 +199,9 @@ FORCE_INLINE void HAL_timer_start(const uint8_t timer_num, const uint32_t) {

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

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

 // ADC
 #ifdef DIDR2
@@ -350,7 +343,7 @@ void TIMER0_COMPB_vect_bottom()
  #define HAL_ANALOG_SELECT(pin) do{ SBI(DIDR0, pin); }while(0)
 #endif

-inline void HAL_adc_init() {
+inline void HAL_adc_init(void) {
  ADCSRA = _BV(ADEN) | _BV(ADSC) | _BV(ADIF) | 0x07;
  DIDR0 = 0;
  #ifdef DIDR2
@@ -365,7 +358,6 @@ inline void HAL_adc_init() {
  #define HAL_START_ADC(pin) ADCSRB = 0; SET_ADMUX_ADCSRA(pin)
 #endif

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

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

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

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

  /** SPI receive a byte */
-  uint8_t spiRec() {
+  uint8_t spiRec(void) {
    SPDR = 0xFF;
    while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
    return SPDR;
@@ -184,10 +184,15 @@ void spiBegin() {
  // nop to tune soft SPI timing
  #define nop asm volatile ("\tnop\n")

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

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

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

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

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

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

    // Read the tail. Main thread owns it, so it is safe to directly read it
@@ -412,13 +412,13 @@
  }

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

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

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

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

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

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

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

    public:
      MarlinSerial() {};
      static void begin(const long);
      static void end();
-      static int peek();
-      static int read();
-      static void flush();
-      static ring_buffer_pos_t available();
+      static int peek(void);
+      static int read(void);
+      static void flush(void);
+      static ring_buffer_pos_t available(void);
      static void write(const uint8_t c);
-      static void flushTX();
+      static void flushTX(void);

      FORCE_INLINE static uint8_t dropped() { return Cfg::DROPPED_RX ? rx_dropped_bytes : 0; }
      FORCE_INLINE static uint8_t buffer_overruns() { return Cfg::RX_OVERRUNS ? rx_buffer_overruns : 0; }
@@ -245,7 +245,7 @@
      static void println(long, int = DEC);
      static void println(unsigned long, int = DEC);
      static void println(double, int = 2);
-      static void println();
+      static void println(void);
      operator bool() { return true; }

    private:
@@ -131,7 +131,7 @@ void initISR(timer16_Sequence_t timer) {
      TCCR1A = 0;             // normal counting mode
      TCCR1B = _BV(CS11);     // set prescaler of 8
      TCNT1 = 0;              // clear the timer count
-      #if defined(__AVR_ATmega8__) || defined(__AVR_ATmega128__)
+      #if defined(__AVR_ATmega8__)|| defined(__AVR_ATmega128__)
        SBI(TIFR, OCF1A);      // clear any pending interrupts;
        SBI(TIMSK, OCIE1A);    // enable the output compare interrupt
      #else
@@ -41,60 +41,44 @@
 #include <stdint.h>

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

 /**
 * Patch for pins_arduino.h (...\Arduino\hardware\arduino\avr\variants\mega\pins_arduino.h)
 *
- * These macros for the Arduino MEGA do not include the two connected pins on Port J (D14, D15).
+ * These macros for the Arduino MEGA do not include the two connected pins on Port J (D13, D14).
 * So we extend them here because these are the normal pins for Y_MIN and Y_MAX on RAMPS.
 * There are more PCI-enabled processor pins on Port J, but they are not connected to Arduino MEGA.
 */
 #if defined(ARDUINO_AVR_MEGA2560) || defined(ARDUINO_AVR_MEGA)
-
-  #define digitalPinHasPCICR(p)   (WITHIN(p, 10, 15) || WITHIN(p, 50, 53) || WITHIN(p, 62, 69))
-
  #undef  digitalPinToPCICR
-  #define digitalPinToPCICR(p)    (digitalPinHasPCICR(p) ? (&PCICR) : nullptr)
-
+  #define digitalPinToPCICR(p)    ( WITHIN(p, 10, 15) || \
+                                    WITHIN(p, 50, 53) || \
+                                    WITHIN(p, 62, 69) ? &PCICR : nullptr )
  #undef  digitalPinToPCICRbit
-  #define digitalPinToPCICRbit(p) (WITHIN(p, 10, 13) || WITHIN(p, 50, 53) ? 0 : \
-                                   WITHIN(p, 14, 15) ? 1 : \
-                                   WITHIN(p, 62, 69) ? 2 : \
-                                   0)
-
+  #define digitalPinToPCICRbit(p) ( WITHIN(p, 10, 13) || WITHIN(p, 50, 53) ? 0 : \
+                                    WITHIN(p, 14, 15) ? 1 : \
+                                    WITHIN(p, 62, 69) ? 2 : \
+                                    0 )
  #undef  digitalPinToPCMSK
-  #define digitalPinToPCMSK(p)    (WITHIN(p, 10, 13) || WITHIN(p, 50, 53) ? (&PCMSK0) : \
-                                   WITHIN(p, 14, 15) ? (&PCMSK1) : \
-                                   WITHIN(p, 62, 69) ? (&PCMSK2) : \
-                                   nullptr)
-
+  #define digitalPinToPCMSK(p)    ( WITHIN(p, 10, 13) || WITHIN(p, 50, 53) ? &PCMSK0 : \
+                                    WITHIN(p, 14, 15) ? &PCMSK1 : \
+                                    WITHIN(p, 62, 69) ? &PCMSK2 : \
+                                    nullptr )
  #undef  digitalPinToPCMSKbit
-  #define digitalPinToPCMSKbit(p) (WITHIN(p, 10, 13) ? ((p) - 6) : \
-                                   (p) == 14 || (p) == 51 ? 2 : \
-                                   (p) == 15 || (p) == 52 ? 1 : \
-                                   (p) == 50 ? 3 : \
-                                   (p) == 53 ? 0 : \
-                                   WITHIN(p, 62, 69) ? ((p) - 62) : \
-                                   0)
-
-#elif defined(__AVR_ATmega164A__) || defined(__AVR_ATmega164P__) || defined(__AVR_ATmega324A__) || \
-      defined(__AVR_ATmega324P__) || defined(__AVR_ATmega324PA__) || defined(__AVR_ATmega324PB__) || \
-      defined(__AVR_ATmega644A__) || defined(__AVR_ATmega644P__) || defined(__AVR_ATmega1284__) || \
-      defined(__AVR_ATmega1284P__)
-
-  #define digitalPinHasPCICR(p)   WITHIN(p, 0, NUM_DIGITAL_PINS)
-
-#else
-
-  #error "Unsupported AVR variant!"
-
+  #define digitalPinToPCMSKbit(p) ( WITHIN(p, 10, 13) ? ((p) - 6) : \
+                                    (p) == 14 || (p) == 51 ? 2 : \
+                                    (p) == 15 || (p) == 52 ? 1 : \
+                                    (p) == 50 ? 3 : \
+                                    (p) == 53 ? 0 : \
+                                    WITHIN(p, 62, 69) ? ((p) - 62) : \
+                                    0 )
 #endif


 // Install Pin change interrupt for a pin. Can be called multiple times.
 void pciSetup(const int8_t pin) {
-  if (digitalPinHasPCICR(pin)) {
+  if (digitalPinToPCMSK(pin) != nullptr) {
    SBI(*digitalPinToPCMSK(pin), digitalPinToPCMSKbit(pin));  // enable pin
    SBI(PCIFR, digitalPinToPCICRbit(pin)); // clear any outstanding interrupt
    SBI(PCICR, digitalPinToPCICRbit(pin)); // enable interrupt for the group
@@ -118,125 +102,154 @@ void pciSetup(const int8_t pin) {
  ISR(PCINT3_vect, ISR_ALIASOF(PCINT0_vect));
 #endif

-void setup_endstop_interrupts() {
-  #define _ATTACH(P) attachInterrupt(digitalPinToInterrupt(P), endstop_ISR, CHANGE)
+void setup_endstop_interrupts( void ) {
+
  #if HAS_X_MAX
-    #if (digitalPinToInterrupt(X_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(X_MAX_PIN);
+    #if (digitalPinToInterrupt(X_MAX_PIN) != NOT_AN_INTERRUPT) // if pin has an external interrupt
+      attachInterrupt(digitalPinToInterrupt(X_MAX_PIN), endstop_ISR, CHANGE); // assign it
    #else
-      static_assert(digitalPinHasPCICR(X_MAX_PIN), "X_MAX_PIN is not interrupt-capable");
-      pciSetup(X_MAX_PIN);
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(X_MAX_PIN), "X_MAX_PIN is not interrupt-capable"); // if pin has no pin change interrupt - error
+      pciSetup(X_MAX_PIN);                                                            // assign it
    #endif
  #endif
+
  #if HAS_X_MIN
    #if (digitalPinToInterrupt(X_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(X_MIN_PIN);
+      attachInterrupt(digitalPinToInterrupt(X_MIN_PIN), endstop_ISR, CHANGE);
    #else
-      static_assert(digitalPinHasPCICR(X_MIN_PIN), "X_MIN_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(X_MIN_PIN), "X_MIN_PIN is not interrupt-capable");
      pciSetup(X_MIN_PIN);
    #endif
  #endif
+
  #if HAS_Y_MAX
    #if (digitalPinToInterrupt(Y_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Y_MAX_PIN);
+      attachInterrupt(digitalPinToInterrupt(Y_MAX_PIN), endstop_ISR, CHANGE);
    #else
-      static_assert(digitalPinHasPCICR(Y_MAX_PIN), "Y_MAX_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Y_MAX_PIN), "Y_MAX_PIN is not interrupt-capable");
      pciSetup(Y_MAX_PIN);
    #endif
  #endif
+
  #if HAS_Y_MIN
    #if (digitalPinToInterrupt(Y_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Y_MIN_PIN);
+      attachInterrupt(digitalPinToInterrupt(Y_MIN_PIN), endstop_ISR, CHANGE);
    #else
-      static_assert(digitalPinHasPCICR(Y_MIN_PIN), "Y_MIN_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Y_MIN_PIN), "Y_MIN_PIN is not interrupt-capable");
      pciSetup(Y_MIN_PIN);
    #endif
  #endif
+
  #if HAS_Z_MAX
    #if (digitalPinToInterrupt(Z_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z_MAX_PIN);
+      attachInterrupt(digitalPinToInterrupt(Z_MAX_PIN), endstop_ISR, CHANGE);
    #else
-      static_assert(digitalPinHasPCICR(Z_MAX_PIN), "Z_MAX_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Z_MAX_PIN), "Z_MAX_PIN is not interrupt-capable");
      pciSetup(Z_MAX_PIN);
    #endif
  #endif
+
  #if HAS_Z_MIN
    #if (digitalPinToInterrupt(Z_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z_MIN_PIN);
+      attachInterrupt(digitalPinToInterrupt(Z_MIN_PIN), endstop_ISR, CHANGE);
    #else
-      static_assert(digitalPinHasPCICR(Z_MIN_PIN), "Z_MIN_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Z_MIN_PIN), "Z_MIN_PIN is not interrupt-capable");
      pciSetup(Z_MIN_PIN);
    #endif
  #endif
+
  #if HAS_X2_MAX
    #if (digitalPinToInterrupt(X2_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(X2_MAX_PIN);
+      attachInterrupt(digitalPinToInterrupt(X2_MAX_PIN), endstop_ISR, CHANGE);
    #else
-      static_assert(digitalPinHasPCICR(X2_MAX_PIN), "X2_MAX_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(X2_MAX_PIN), "X2_MAX_PIN is not interrupt-capable");
      pciSetup(X2_MAX_PIN);
    #endif
  #endif
+
  #if HAS_X2_MIN
    #if (digitalPinToInterrupt(X2_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(X2_MIN_PIN);
+      attachInterrupt(digitalPinToInterrupt(X2_MIN_PIN), endstop_ISR, CHANGE);
    #else
-      static_assert(digitalPinHasPCICR(X2_MIN_PIN), "X2_MIN_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(X2_MIN_PIN), "X2_MIN_PIN is not interrupt-capable");
      pciSetup(X2_MIN_PIN);
    #endif
  #endif
+
  #if HAS_Y2_MAX
    #if (digitalPinToInterrupt(Y2_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Y2_MAX_PIN);
+      attachInterrupt(digitalPinToInterrupt(Y2_MAX_PIN), endstop_ISR, CHANGE);
    #else
-      static_assert(digitalPinHasPCICR(Y2_MAX_PIN), "Y2_MAX_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Y2_MAX_PIN), "Y2_MAX_PIN is not interrupt-capable");
      pciSetup(Y2_MAX_PIN);
    #endif
  #endif
+
  #if HAS_Y2_MIN
    #if (digitalPinToInterrupt(Y2_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Y2_MIN_PIN);
+      attachInterrupt(digitalPinToInterrupt(Y2_MIN_PIN), endstop_ISR, CHANGE);
    #else
-      static_assert(digitalPinHasPCICR(Y2_MIN_PIN), "Y2_MIN_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Y2_MIN_PIN), "Y2_MIN_PIN is not interrupt-capable");
      pciSetup(Y2_MIN_PIN);
    #endif
  #endif
+
  #if HAS_Z2_MAX
    #if (digitalPinToInterrupt(Z2_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z2_MAX_PIN);
+      attachInterrupt(digitalPinToInterrupt(Z2_MAX_PIN), endstop_ISR, CHANGE);
    #else
-      static_assert(digitalPinHasPCICR(Z2_MAX_PIN), "Z2_MAX_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Z2_MAX_PIN), "Z2_MAX_PIN is not interrupt-capable");
      pciSetup(Z2_MAX_PIN);
    #endif
  #endif
+
  #if HAS_Z2_MIN
    #if (digitalPinToInterrupt(Z2_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z2_MIN_PIN);
+      attachInterrupt(digitalPinToInterrupt(Z2_MIN_PIN), endstop_ISR, CHANGE);
    #else
-      static_assert(digitalPinHasPCICR(Z2_MIN_PIN), "Z2_MIN_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Z2_MIN_PIN), "Z2_MIN_PIN is not interrupt-capable");
      pciSetup(Z2_MIN_PIN);
    #endif
  #endif
+
  #if HAS_Z3_MAX
    #if (digitalPinToInterrupt(Z3_MAX_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z3_MAX_PIN);
+      attachInterrupt(digitalPinToInterrupt(Z3_MAX_PIN), endstop_ISR, CHANGE);
    #else
-      static_assert(digitalPinHasPCICR(Z3_MAX_PIN), "Z3_MAX_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Z3_MAX_PIN), "Z3_MAX_PIN is not interrupt-capable");
      pciSetup(Z3_MAX_PIN);
    #endif
  #endif
+
  #if HAS_Z3_MIN
    #if (digitalPinToInterrupt(Z3_MIN_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z3_MIN_PIN);
+      attachInterrupt(digitalPinToInterrupt(Z3_MIN_PIN), endstop_ISR, CHANGE);
    #else
-      static_assert(digitalPinHasPCICR(Z3_MIN_PIN), "Z3_MIN_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Z3_MIN_PIN), "Z3_MIN_PIN is not interrupt-capable");
      pciSetup(Z3_MIN_PIN);
    #endif
  #endif
+
  #if HAS_Z_MIN_PROBE_PIN
    #if (digitalPinToInterrupt(Z_MIN_PROBE_PIN) != NOT_AN_INTERRUPT)
-      _ATTACH(Z_MIN_PROBE_PIN);
+      attachInterrupt(digitalPinToInterrupt(Z_MIN_PROBE_PIN), endstop_ISR, CHANGE);
    #else
-      static_assert(digitalPinHasPCICR(Z_MIN_PROBE_PIN), "Z_MIN_PROBE_PIN is not interrupt-capable");
+      // Not all used endstop/probe -pins can raise interrupts. Please deactivate ENDSTOP_INTERRUPTS or change the pin configuration!
+      static_assert(digitalPinToPCICR(Z_MIN_PROBE_PIN), "Z_MIN_PROBE_PIN is not interrupt-capable");
      pciSetup(Z_MIN_PROBE_PIN);
    #endif
  #endif
@@ -23,7 +23,7 @@

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

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

 #include "HAL.h"

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

-#endif // FAST_PWM_FAN || SPINDLE_LASER_PWM
+#endif // FAST_PWM_FAN
 #endif // __AVR__
@@ -39,7 +39,7 @@
 * Checks for FAST PWM
 */
 #if ENABLED(FAST_PWM_FAN) && (ENABLED(USE_OCR2A_AS_TOP) && defined(TCCR2))
-  #error "USE_OCR2A_AS_TOP does not apply to devices with a single output TIMER2"
+    #error "USE_OCR2A_AS_TOP does not apply to devices with a single output TIMER2"
 #endif

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

 #define NUMBER_PINS_TOTAL NUM_DIGITAL_PINS

-#define AVR_ATmega2560_FAMILY_PLUS_70 MB(BQ_ZUM_MEGA_3D, MIGHTYBOARD_REVE, MINIRAMBO, SCOOVO_X9H)
-
 #if AVR_AT90USB1286_FAMILY
-
  // Working with Teensyduino extension so need to re-define some things
  #include "pinsDebug_Teensyduino.h"
  // Can't use the "digitalPinToPort" function from the Teensyduino type IDEs
@@ -38,9 +35,7 @@
  #define digitalPinToBitMask_DEBUG(p) digitalPinToBitMask(p)
  #define digitalPinToPort_DEBUG(p) digitalPinToPort_Teensy(p)
  #define GET_PINMODE(pin) (*portModeRegister(pin) & digitalPinToBitMask_DEBUG(pin))
-
 #elif AVR_ATmega2560_FAMILY_PLUS_70   // So we can access/display all the pins on boards using more than 70
-
  #include "pinsDebug_plus_70.h"
  #define digitalPinToTimer_DEBUG(p) digitalPinToTimer_plus_70(p)
  #define digitalPinToBitMask_DEBUG(p) digitalPinToBitMask_plus_70(p)
@@ -48,13 +43,11 @@
  bool GET_PINMODE(int8_t pin) {return *portModeRegister(digitalPinToPort_DEBUG(pin)) & digitalPinToBitMask_DEBUG(pin); }

 #else
-
  #define digitalPinToTimer_DEBUG(p) digitalPinToTimer(p)
  #define digitalPinToBitMask_DEBUG(p) digitalPinToBitMask(p)
  #define digitalPinToPort_DEBUG(p) digitalPinToPort(p)
  bool GET_PINMODE(int8_t pin) {return *portModeRegister(digitalPinToPort_DEBUG(pin)) & digitalPinToBitMask_DEBUG(pin); }
  #define GET_ARRAY_PIN(p) pgm_read_byte(&pin_array[p].pin)
-
 #endif

 #define VALID_PIN(pin) (pin >= 0 && pin < NUM_DIGITAL_PINS ? 1 : 0)
@@ -234,9 +227,18 @@ static void print_is_also_tied() { SERIAL_ECHOPGM(" is also tied to this pin");
 void com_print(uint8_t N, uint8_t Z) {
  const uint8_t *TCCRA = (uint8_t*)TCCR_A(N);
  SERIAL_ECHOPGM("    COM");
-  SERIAL_CHAR('0' + N);
-  SERIAL_CHAR('A' + Z);
-  SERIAL_ECHOPAIR(": ", int((*TCCRA >> (6 - Z * 2)) & 0x03));
+  SERIAL_CHAR(N + '0');
+  switch (Z) {
+    case 'A':
+      SERIAL_ECHOPAIR("A: ", ((*TCCRA & (_BV(7) | _BV(6))) >> 6));
+      break;
+    case 'B':
+      SERIAL_ECHOPAIR("B: ", ((*TCCRA & (_BV(5) | _BV(4))) >> 4));
+      break;
+    case 'C':
+      SERIAL_ECHOPAIR("C: ", ((*TCCRA & (_BV(3) | _BV(2))) >> 2));
+      break;
+  }
 }

 void timer_prefix(uint8_t T, char L, uint8_t N) {  // T - timer    L - pwm  N - WGM bit layout
@@ -28,4 +28,4 @@ void watchdog_init();

 // Reset watchdog. MUST be called at least every 4 seconds after the
 // first watchdog_init or AVR will go into emergency procedures.
-inline void HAL_watchdog_refresh() { wdt_reset(); }
+inline void watchdog_reset() { wdt_reset(); }
@@ -42,7 +42,7 @@
 #define sw_barrier() __asm__ volatile("": : :"memory");

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

  // Disable UART interrupt in NVIC
  NVIC_DisableIRQ( UART_IRQn );
@@ -235,7 +235,7 @@ void HardFault_HandlerC(unsigned long *sp, unsigned long lr, unsigned long cause
  for (;;) WDT_Restart(WDT);
 }

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

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

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

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

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

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

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

-__attribute__((naked)) void RSTC_Handler() {
+__attribute__((naked)) void RSTC_Handler(void) {
  __asm__ __volatile__ (
    ".syntax unified" "\n\t"
    A("tst lr, #4")
@@ -922,7 +922,8 @@ static void ee_Init() {
      if (!ee_IsPageClean(grp * PagesPerGroup + page)) {
        #ifdef EE_EMU_DEBUG
          SERIAL_ECHO_START();
-          SERIAL_ECHOLNPAIR("EEPROM Page ", page, " not clean on group ", grp);
+          SERIAL_ECHOPAIR("EEPROM Page ",page);
+          SERIAL_ECHOLNPAIR(" not clean on group ",grp);
          SERIAL_FLUSH();
        #endif
        ee_PageErase(grp * PagesPerGroup + page);
@@ -943,7 +944,7 @@ static void ee_Init() {

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

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

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

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

 // HAL initialization task
-void HAL_init() {
+void HAL_init(void) {
  // Initialize the USB stack
  #if ENABLED(SDSUPPORT)
    OUT_WRITE(SDSS, HIGH);  // Try to set SDSS inactive before any other SPI users start up
@@ -51,20 +51,20 @@ void HAL_init() {
 }

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

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

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

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

-uint8_t HAL_get_reset_source() {
+uint8_t HAL_get_reset_source(void) {
  switch ((RSTC->RSTC_SR >> 8) & 0x07) {
    case 0: return RST_POWER_ON;
    case 1: return RST_BACKUP;
@@ -87,7 +87,7 @@ extern "C" {
 // Return free memory between end of heap (or end bss) and whatever is current
 int freeMemory() {
  int free_memory, heap_end = (int)_sbrk(0);
-  return (int)&free_memory - (heap_end ?: (int)&_ebss);
+  return (int)&free_memory - (heap_end ? heap_end : (int)&_ebss);
 }

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

-uint16_t HAL_adc_get_result() {
+uint16_t HAL_adc_get_result(void) {
  // nop
  return HAL_adc_result;
 }
@@ -38,39 +38,22 @@

 #include <stdint.h>

-// Define MYSERIAL0/1 before MarlinSerial includes!
-#if SERIAL_PORT == -1
-  #define MYSERIAL0 customizedSerial1
-#elif SERIAL_PORT == 0
-  #define MYSERIAL0 Serial
-#elif SERIAL_PORT == 1
-  #define MYSERIAL0 Serial1
-#elif SERIAL_PORT == 2
-  #define MYSERIAL0 Serial2
-#elif SERIAL_PORT == 3
-  #define MYSERIAL0 Serial3
-#else
-  #error "The required SERIAL_PORT must be from -1 to 3. Please update your configuration."
+// Serial ports
+#if !WITHIN(SERIAL_PORT, -1, 3)
+  #error "SERIAL_PORT must be from -1 to 3"
 #endif

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

 //
 // EEPROM
@@ -130,15 +113,14 @@ extern uint16_t HAL_adc_result;     // result of last ADC conversion

 #define HAL_ANALOG_SELECT(pin)

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

 #define HAL_START_ADC(pin)  HAL_adc_start_conversion(pin)
-#define HAL_ADC_RESOLUTION  10
 #define HAL_READ_ADC()      HAL_adc_result
 #define HAL_ADC_READY()     true

 void HAL_adc_start_conversion(const uint8_t adc_pin);
-uint16_t HAL_adc_get_result();
+uint16_t HAL_adc_get_result(void);

 //
 // Pin Map
@@ -156,8 +138,8 @@ void noTone(const pin_t _pin);

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

 //
 // Utility functions
@@ -166,7 +148,7 @@ void _delay_ms(const int delay);

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

 #ifdef __cplusplus
@@ -151,12 +151,13 @@
    (((uint32_t)(addr) & 0xF0000000) + 0x02000000 + ((uint32_t)(addr)&0xFFFFF)*32 + (bit)*4)

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

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

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

@@ -48,7 +48,7 @@ static DeviceVectors ram_tab = { nullptr };
 * If it is not, then it copies the ROM table to the SRAM and relocates the table
 * by reprogramming the NVIC registers
 */
-static pfnISR_Handler* get_relocated_table_addr() {
+static pfnISR_Handler* get_relocated_table_addr(void) {
  // Get the address of the interrupt/exception table
  uint32_t isrtab = SCB->VTOR;

@@ -37,7 +37,7 @@
 #ifdef ARDUINO_ARCH_SAM

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

 // Install a new interrupt vector handler for the given irq, returning the old one
 pfnISR_Handler install_isr(IRQn_Type irq, pfnISR_Handler newHandler);
@@ -178,7 +178,7 @@ FORCE_INLINE void MarlinSerial<Cfg>::store_rxd_char() {
 }

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

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

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

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

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

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

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

 template<typename Cfg>
-void MarlinSerial<Cfg>::flush() {
+void MarlinSerial<Cfg>::flush(void) {
  rx_buffer.tail = rx_buffer.head;

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

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

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

 template<typename Cfg>
-void MarlinSerial<Cfg>::println() {
+void MarlinSerial<Cfg>::println(void) {
  print('\r');
  print('\n');
 }
@@ -108,19 +108,19 @@ protected:
  static ring_buffer_pos_t rx_max_enqueued;

  FORCE_INLINE static void store_rxd_char();
-  FORCE_INLINE static void _tx_thr_empty_irq();
-  static void UART_ISR();
+  FORCE_INLINE static void _tx_thr_empty_irq(void);
+  static void UART_ISR(void);

 public:
  MarlinSerial() {};
  static void begin(const long);
  static void end();
-  static int peek();
-  static int read();
-  static void flush();
-  static ring_buffer_pos_t available();
+  static int peek(void);
+  static int read(void);
+  static void flush(void);
+  static ring_buffer_pos_t available(void);
  static void write(const uint8_t c);
-  static void flushTX();
+  static void flushTX(void);

  FORCE_INLINE static uint8_t dropped() { return Cfg::DROPPED_RX ? rx_dropped_bytes : 0; }
  FORCE_INLINE static uint8_t buffer_overruns() { return Cfg::RX_OVERRUNS ? rx_buffer_overruns : 0; }
@@ -149,7 +149,7 @@ public:
  static void println(long, int = DEC);
  static void println(unsigned long, int = DEC);
  static void println(double, int = 2);
-  static void println();
+  static void println(void);
  operator bool() { return true; }

 private:
@@ -39,11 +39,11 @@

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

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

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

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

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

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

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

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

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

 void MarlinSerialUSB::write(const uint8_t c) {

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

-void MarlinSerialUSB::println() {
+void MarlinSerialUSB::println(void) {
  print('\r');
  print('\n');
 }
@@ -43,11 +43,11 @@ public:
  MarlinSerialUSB() {};
  static void begin(const long);
  static void end();
-  static int peek();
-  static int read();
-  static void flush();
-  static void flushTX();
-  static bool available();
+  static int peek(void);
+  static int read(void);
+  static void flush(void);
+  static void flushTX(void);
+  static bool available(void);
  static void write(const uint8_t c);

  #if ENABLED(SERIAL_STATS_DROPPED_RX)
@@ -80,7 +80,7 @@ public:
  static void println(long, int = DEC);
  static void println(unsigned long, int = DEC);
  static void println(double, int = 2);
-  static void println();
+  static void println(void);
  operator bool() { return true; }

 private:
@@ -56,19 +56,19 @@ static volatile int8_t Channel[_Nbr_16timers];              // counter for the s
 void Servo_Handler(timer16_Sequence_t timer, Tc *pTc, uint8_t channel);

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

 void Servo_Handler(timer16_Sequence_t timer, Tc *tc, uint8_t channel) {
@@ -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
 }
@@ -33,7 +33,7 @@
  #define E2END 0xFFF // Default to Flash emulated EEPROM size (EepromEmulation_Due.cpp)
 #endif

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

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

@@ -50,7 +50,7 @@ const tTimerConfig TimerConfig [NUM_HARDWARE_TIMERS] = {
  { TC0, 0, TC0_IRQn,  3}, // 0 - [servo timer5]
  { TC0, 1, TC1_IRQn,  0}, // 1
  { TC0, 2, TC2_IRQn,  2}, // 2 - stepper
-  { TC1, 0, TC3_IRQn,  0}, // 3 - stepper for BOARD_ARCHIM1
+  { TC1, 0, TC3_IRQn,  0}, // 3
  { TC1, 1, TC4_IRQn, 15}, // 4 - temperature
  { TC1, 2, TC5_IRQn,  3}, // 5 - [servo timer3]
  { TC2, 0, TC6_IRQn, 14}, // 6 - tone
@@ -39,9 +39,7 @@ typedef uint32_t hal_timer_t;

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

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

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

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

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

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

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

+//! USB Device string definitions (Optional)
+#define  USB_DEVICE_MANUFACTURE_NAME      "marlinfw.org"
+#ifdef CUSTOM_MACHINE_NAME
+  #define  USB_DEVICE_PRODUCT_NAME        CUSTOM_MACHINE_NAME
+#else
+  #define  USB_DEVICE_PRODUCT_NAME        "3D Printer"
+#endif
+#define  USB_DEVICE_SERIAL_NAME           "123985739853"
+
 /**
 * Device speeds support
 * Low speed not supported by CDC and MSC
@@ -15,14 +15,11 @@ extern "C" {

 #define SD_MMC_BLOCK_SIZE 512

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

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

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

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

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

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

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

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

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

  #ifdef DEBUG_MMC
@@ -94,11 +94,11 @@ typedef struct {
 	uint16_t payload_size;

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

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

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

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

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

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

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

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

 //@}
@@ -45,11 +45,10 @@

 #ifdef ARDUINO_ARCH_SAM

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

 #if ENABLED(SDSUPPORT)
  static volatile bool main_b_msc_enable = false;
@@ -32,7 +32,7 @@
 // process, because watchdog initialization at hardware reset on SAM3X8E
 // is unreliable, and there is risk of unintended resets if we delay
 // that initialization to a later time.
-void watchdogSetup() {
+void watchdogSetup(void) {

  #if ENABLED(USE_WATCHDOG)

@@ -106,7 +106,7 @@ void watchdogSetup() {
  // Initialize watchdog - On SAM3X, Watchdog was already configured
  //  and enabled or disabled at startup, so no need to reconfigure it
  //  here.
-  void watchdog_init() {
+  void watchdog_init(void) {
    // Reset watchdog to start clean
    WDT_Restart(WDT);
  }
@@ -30,4 +30,4 @@ void watchdog_init();

 // Reset watchdog. MUST be called at least every 4 seconds after the
 // first watchdog_init or AVR will go into emergency procedures.
-inline void HAL_watchdog_refresh() { watchdogReset(); }
+inline void watchdog_reset() { watchdogReset(); }
@@ -29,7 +29,7 @@ class FlushableHardwareSerial : public HardwareSerial {
 public:
  FlushableHardwareSerial(int uart_nr);

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

 extern FlushableHardwareSerial flushableSerial;
@@ -30,7 +30,7 @@

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

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

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

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

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

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

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

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

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

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

@@ -187,21 +187,19 @@ void HAL_adc_start_conversion(uint8_t adc_pin) {
  const adc1_channel_t chan = get_channel(adc_pin);
  uint32_t mv;
  esp_adc_cal_get_voltage((adc_channel_t)chan, &characteristics[attenuations[chan]], &mv);
-  HAL_adc_result = mv * 1023.0 / 3300.0;

  // Change the attenuation level based on the new reading
  adc_atten_t atten;
  if (mv < thresholds[ADC_ATTEN_DB_0] - 100)
-    atten = ADC_ATTEN_DB_0;
+    adc1_set_attenuation(chan, ADC_ATTEN_DB_0);
  else if (mv > thresholds[ADC_ATTEN_DB_0] - 50 && mv < thresholds[ADC_ATTEN_DB_2_5] - 100)
-    atten = ADC_ATTEN_DB_2_5;
+    adc1_set_attenuation(chan, ADC_ATTEN_DB_2_5);
  else if (mv > thresholds[ADC_ATTEN_DB_2_5] - 50 && mv < thresholds[ADC_ATTEN_DB_6] - 100)
-    atten = ADC_ATTEN_DB_6;
+    adc1_set_attenuation(chan, ADC_ATTEN_DB_6);
  else if (mv > thresholds[ADC_ATTEN_DB_6] - 50)
-    atten = ADC_ATTEN_DB_11;
-  else return;
+    adc1_set_attenuation(chan, ADC_ATTEN_DB_11);

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

 void analogWrite(pin_t pin, int value) {
@@ -85,16 +85,16 @@ extern uint16_t HAL_adc_result;
 // ------------------------

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

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

 void _delay_ms(int delay);

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

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

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

 #define HAL_START_ADC(pin)  HAL_adc_start_conversion(pin)
-#define HAL_ADC_RESOLUTION  10
 #define HAL_READ_ADC()      HAL_adc_result
 #define HAL_ADC_READY()     true

@@ -124,6 +123,6 @@ void HAL_adc_start_conversion(uint8_t adc_pin);
 // Enable hooks into idle and setup for HAL
 #define HAL_IDLETASK 1
 #define BOARD_INIT() HAL_init_board();
-void HAL_idletask();
-void HAL_init();
-void HAL_init_board();
+void HAL_idletask(void);
+void HAL_init(void);
+void HAL_init_board(void);
@@ -80,7 +80,7 @@ void spiInit(uint8_t spiRate) {
  SPI.begin();
 }

-uint8_t spiRec() {
+uint8_t spiRec(void) {
  SPI.beginTransaction(spiConfig);
  uint8_t returnByte = SPI.transfer(0xFF);
  SPI.endTransaction();
@@ -32,25 +32,25 @@
 int Servo::channel_next_free = 12;

 Servo::Servo() {
-  channel = channel_next_free++;
+  this->channel = channel_next_free++;
 }

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

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

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

-int Servo::read() { return degrees; }
+int Servo::read() { return this->degrees; }

 void Servo::write(int inDegrees) {
-  degrees = constrain(inDegrees, MIN_ANGLE, MAX_ANGLE);
-  int us = map(degrees, MIN_ANGLE, MAX_ANGLE, MIN_PULSE_WIDTH, MAX_PULSE_WIDTH);
+  this->degrees = constrain(inDegrees, MIN_ANGLE, MAX_ANGLE);
+  int us = map(this->degrees, MIN_ANGLE, MAX_ANGLE, MIN_PULSE_WIDTH, MAX_PULSE_WIDTH);
  int duty = map(us, 0, TAU_USEC, 0, MAX_COMPARE);
  ledcWrite(channel, duty);
 }
@@ -58,11 +58,11 @@ void Servo::write(int inDegrees) {
 void Servo::move(const int value) {
  constexpr uint16_t servo_delay[] = SERVO_DELAY;
  static_assert(COUNT(servo_delay) == NUM_SERVOS, "SERVO_DELAY must be an array NUM_SERVOS long.");
-  if (attach(0) >= 0) {
-    write(value);
-    safe_delay(servo_delay[channel]);
+  if (this->attach(0) >= 0) {
+    this->write(value);
+    safe_delay(servo_delay[this->channel]);
    #if ENABLED(DEACTIVATE_SERVOS_AFTER_MOVE)
-      detach();
+      this->detach();
    #endif
  }
 }
@@ -66,15 +66,15 @@ ring_buffer_pos_t RingBuffer::write(const uint8_t *buffer, ring_buffer_pos_t siz
  return written;
 }

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

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

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

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

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

 void WebSocketSerial::end() { }
-int WebSocketSerial::peek() { return rx_buffer.peek(); }
-int WebSocketSerial::read() { return rx_buffer.read(); }
-int WebSocketSerial::available() { return rx_buffer.available(); }
-void WebSocketSerial::flush() { rx_buffer.flush(); }
+int WebSocketSerial::peek(void) { return rx_buffer.peek(); }
+int WebSocketSerial::read(void) { return rx_buffer.read(); }
+int WebSocketSerial::available(void) { return rx_buffer.available(); }
+void WebSocketSerial::flush(void) { rx_buffer.flush(); }

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

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

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

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

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

+#ifndef RX_BUFFER_SIZE
+  #define RX_BUFFER_SIZE 128
+#endif
 #ifndef TX_BUFFER_SIZE
  #define TX_BUFFER_SIZE 32
 #endif
-#if ENABLED(WIFISUPPORT)
-  #ifndef RX_BUFFER_SIZE
-    #define RX_BUFFER_SIZE 128
-  #endif
-  #if TX_BUFFER_SIZE <= 0
-    #error "TX_BUFFER_SIZE is required for the WebSocket."
-  #endif
+#if TX_BUFFER_SIZE <= 0
+  #error "TX_BUFFER_SIZE is required for the WebSocket."
 #endif

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

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

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

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

-void setup_endstop_interrupts() {
-  #define _ATTACH(P) attachInterrupt(digitalPinToInterrupt(P), endstop_ISR, CHANGE)
+void setup_endstop_interrupts(void) {
  #if HAS_X_MAX
-    _ATTACH(X_MAX_PIN);
+    attachInterrupt(digitalPinToInterrupt(X_MAX_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_X_MIN
-    _ATTACH(X_MIN_PIN);
+    attachInterrupt(digitalPinToInterrupt(X_MIN_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Y_MAX
-    _ATTACH(Y_MAX_PIN);
+    attachInterrupt(digitalPinToInterrupt(Y_MAX_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Y_MIN
-    _ATTACH(Y_MIN_PIN);
+    attachInterrupt(digitalPinToInterrupt(Y_MIN_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Z_MAX
-    _ATTACH(Z_MAX_PIN);
+    attachInterrupt(digitalPinToInterrupt(Z_MAX_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Z_MIN
-     _ATTACH(Z_MIN_PIN);
+     attachInterrupt(digitalPinToInterrupt(Z_MIN_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Z2_MAX
-    _ATTACH(Z2_MAX_PIN);
+    attachInterrupt(digitalPinToInterrupt(Z2_MAX_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Z2_MIN
-    _ATTACH(Z2_MIN_PIN);
+    attachInterrupt(digitalPinToInterrupt(Z2_MIN_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Z3_MAX
-    _ATTACH(Z3_MAX_PIN);
+    attachInterrupt(digitalPinToInterrupt(Z3_MAX_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Z3_MIN
-    _ATTACH(Z3_MIN_PIN);
+    attachInterrupt(digitalPinToInterrupt(Z3_MIN_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Z_MIN_PROBE_PIN
-    _ATTACH(Z_MIN_PROBE_PIN);
+    attachInterrupt(digitalPinToInterrupt(Z_MIN_PROBE_PIN), endstop_ISR, CHANGE);
  #endif
 }
@@ -26,10 +26,10 @@
 #include "i2s.h"

 #include "../shared/Marduino.h"
-#include <driver/periph_ctrl.h>
-#include <rom/lldesc.h>
-#include <soc/i2s_struct.h>
-#include <freertos/queue.h>
+#include "driver/periph_ctrl.h"
+#include "rom/lldesc.h"
+#include "soc/i2s_struct.h"
+#include "freertos/queue.h"
 #include "../../module/stepper.h"

 #define DMA_BUF_COUNT 8                                // number of DMA buffers to store data
@@ -27,7 +27,7 @@
 #include <ESPmDNS.h>
 #include <WiFiUdp.h>
 #include <ArduinoOTA.h>
-#include <driver/timer.h>
+#include "driver/timer.h"

 void OTA_init() {
  ArduinoOTA
@@ -1,63 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- *
- * Based on Sprinter and grbl.
- * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifdef ARDUINO_ARCH_ESP32
-
-#include "../../inc/MarlinConfig.h"
-
-#if ENABLED(EEPROM_SETTINGS) && DISABLED(FLASH_EEPROM_EMULATION)
-
-#include "../shared/persistent_store_api.h"
-#include "EEPROM.h"
-
-#define EEPROM_SIZE 4096
-
-bool PersistentStore::access_start() {
-  return EEPROM.begin(EEPROM_SIZE);
-}
-
-bool PersistentStore::access_finish() {
-  EEPROM.end();
-  return true;
-}
-
-bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
-  for (size_t i = 0; i < size; i++) {
-    EEPROM.write(pos++, value[i]);
-    crc16(crc, &value[i], 1);
-  }
-  return false;
-}
-
-bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
-  for (size_t i = 0; i < size; i++) {
-    uint8_t c = EEPROM.read(pos++);
-    if (writing) value[i] = c;
-    crc16(crc, &c, 1);
-  }
-  return false;
-}
-
-size_t PersistentStore::capacity() { return EEPROM_SIZE; }
-
-#endif // EEPROM_SETTINGS
-#endif // ARDUINO_ARCH_ESP32
@@ -0,0 +1,106 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifdef ARDUINO_ARCH_ESP32
+
+#include "../../inc/MarlinConfig.h"
+
+#if ENABLED(EEPROM_SETTINGS) && DISABLED(FLASH_EEPROM_EMULATION)
+
+#include "../shared/persistent_store_api.h"
+
+#include <SPIFFS.h>
+#include <FS.h>
+#include "spiffs.h"
+
+#define HAL_ESP32_EEPROM_SIZE 4096
+#define HAL_ESP32_EEPROM_FILE_PATH "/eeprom.dat"
+
+File eeprom_file;
+
+bool PersistentStore::access_start() {
+  if (spiffs_initialized) {
+    eeprom_file = SPIFFS.open(HAL_ESP32_EEPROM_FILE_PATH, "r+");
+
+    size_t file_size = eeprom_file.size();
+    if (file_size < HAL_ESP32_EEPROM_SIZE) {
+      SERIAL_ECHO_MSG("SPIFFS EEPROM settings file " HAL_ESP32_EEPROM_FILE_PATH " is too small or did not exist, expanding.");
+      SERIAL_ECHO_START(); SERIAL_ECHOLNPAIR(" file size: ", file_size, ", required size: ", HAL_ESP32_EEPROM_SIZE);
+
+      // mode r+ does not allow to expand the file (at least on ESP32 SPIFFS9, so we close, reopen "a", append, close, reopen "r+"
+      eeprom_file.close();
+
+      eeprom_file = SPIFFS.open(HAL_ESP32_EEPROM_FILE_PATH, "a");
+      for (size_t i = eeprom_file.size(); i < HAL_ESP32_EEPROM_SIZE; i++)
+        eeprom_file.write(0xFF);
+      eeprom_file.close();
+
+      eeprom_file = SPIFFS.open(HAL_ESP32_EEPROM_FILE_PATH, "r+");
+      file_size = eeprom_file.size();
+      if (file_size < HAL_ESP32_EEPROM_SIZE) {
+        SERIAL_ERROR_MSG("Failed to expand " HAL_ESP32_EEPROM_FILE_PATH " to required size. SPIFFS partition full?");
+        SERIAL_ERROR_START(); SERIAL_ECHOLNPAIR(" file size: ", file_size, ", required size: ", HAL_ESP32_EEPROM_SIZE);
+        SERIAL_ERROR_START(); SERIAL_ECHOLNPAIR(" SPIFFS used bytes: ", SPIFFS.usedBytes(), ", total bytes: ", SPIFFS.totalBytes());
+      }
+    }
+    return true;
+  }
+  return false;
+}
+
+bool PersistentStore::access_finish() {
+  eeprom_file.close();
+  return true;
+}
+
+bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
+  if (!eeprom_file.seek(pos)) return true; // return true for any error
+  if (eeprom_file.write(value, size) != size) return true;
+
+  crc16(crc, value, size);
+  pos += size;
+
+  return false;
+}
+
+bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
+  if (!eeprom_file.seek(pos)) return true; // return true for any error
+
+  if (writing) {
+    if (eeprom_file.read(value, size) != size) return true;
+    crc16(crc, value, size);
+  }
+  else {
+    uint8_t tmp[size];
+    if (eeprom_file.read(tmp, size) != size) return true;
+    crc16(crc, tmp, size);
+  }
+
+  pos += size;
+
+  return false;
+}
+
+size_t PersistentStore::capacity() { return HAL_ESP32_EEPROM_SIZE; }
+
+#endif // EEPROM_SETTINGS
+#endif // ARDUINO_ARCH_ESP32
@@ -24,7 +24,7 @@

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

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

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

@@ -23,10 +23,10 @@
 #ifdef ARDUINO_ARCH_ESP32

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

 #include "HAL.h"

@@ -22,7 +22,7 @@
 #pragma once

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

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

 #define STEP_TIMER_MIN_INTERVAL   8 // minimum time in µs between stepper interrupts
@@ -79,13 +79,13 @@ typedef uint64_t hal_timer_t;
 #define ENABLE_TEMPERATURE_INTERRUPT()  HAL_timer_enable_interrupt(TEMP_TIMER_NUM)
 #define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(TEMP_TIMER_NUM)

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

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

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

 // ------------------------
@@ -28,11 +28,11 @@

 #include "watchdog.h"

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

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

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

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

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

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

 }

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

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

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

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

 }

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

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

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

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

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

 /* ---------------- Delay in cycles */
 FORCE_INLINE static void DELAY_CYCLES(uint64_t x) {
@@ -28,8 +28,8 @@
 #include "../shared/Delay.h"

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

 // Time functions
 void _delay_ms(const int delay_ms) {
@@ -63,9 +63,9 @@ typedef uint8_t byte;
 #define constrain(value, arg_min, arg_max) ((value) < (arg_min) ? (arg_min) :((value) > (arg_max) ? (arg_max) : (value)))

 //Interrupts
-void cli(); // Disable
-void sei(); // Enable
-void attachInterrupt(uint32_t pin, void (*callback)(), uint32_t mode);
+void cli(void); // Disable
+void sei(void); // Enable
+void attachInterrupt(uint32_t pin, void (*callback)(void), uint32_t mode);
 void detachInterrupt(uint32_t pin);
 extern "C" void GpioEnableInt(uint32_t port, uint32_t pin, uint32_t mode);
 extern "C" void GpioDisableInt(uint32_t port, uint32_t pin);
@@ -83,9 +83,9 @@ public:

  HalSerial() { host_connected = true; }

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

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

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

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

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

-  void flushTX() {
+  void flushTX(void) {
    if (host_connected)
      while (transmit_buffer.available()) { /* nada */ }
  }
@@ -200,7 +200,7 @@ public:
  void println(unsigned long value, int nbase = 0) { print(value, nbase); println(); }
  void println(float value, int round = 6) { printf("%f\n" , value); }
  void println(double value, int round = 6) { printf("%f\n" , value); }
-  void println() { print('\n'); }
+  void println(void) { print('\n'); }

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

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

@@ -37,7 +37,7 @@ HAL_TEMP_TIMER_ISR();

 Timer timers[2];

-void HAL_timer_init() {
+void HAL_timer_init(void) {
  timers[0].init(0, STEPPER_TIMER_RATE, TIMER0_IRQHandler);
  timers[1].init(1, TEMP_TIMER_RATE, TIMER1_IRQHandler);
 }
@@ -59,16 +59,16 @@ typedef uint32_t hal_timer_t;
 #define ENABLE_TEMPERATURE_INTERRUPT() HAL_timer_enable_interrupt(TEMP_TIMER_NUM)
 #define DISABLE_TEMPERATURE_INTERRUPT() HAL_timer_disable_interrupt(TEMP_TIMER_NUM)

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

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


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

 void HAL_timer_set_compare(const uint8_t timer_num, const hal_timer_t compare);
@@ -28,9 +28,19 @@

 #include "watchdog.h"

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

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

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

 #define WDT_TIMEOUT   4000000 // 4 second timeout

-void watchdog_init();
-void HAL_watchdog_refresh();
+void watchdog_init(void);
+void watchdog_reset(void);
+void HAL_clear_reset_source(void);
+uint8_t HAL_get_reset_source(void);
@@ -44,7 +44,7 @@
 #define sw_barrier() __asm__ volatile("": : :"memory");

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

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

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

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

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

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

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

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

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

-__attribute__((naked)) void RSTC_Handler() {
+__attribute__((naked)) void RSTC_Handler(void) {
  __asm__ __volatile__ (
    ".syntax unified" "\n\t"
    A("tst lr, #4")
@@ -26,20 +26,14 @@
 #include "../shared/Delay.h"
 #include "../../../gcode/parser.h"

-#if ENABLED(USE_WATCHDOG)
-  #include "watchdog.h"
-#endif
-
-uint32_t HAL_adc_reading = 0;
-
 // U8glib required functions
 extern "C" void u8g_xMicroDelay(uint16_t val) {
  DELAY_US(val);
 }
-extern "C" void u8g_MicroDelay() {
+extern "C" void u8g_MicroDelay(void) {
  u8g_xMicroDelay(1);
 }
-extern "C" void u8g_10MicroDelay() {
+extern "C" void u8g_10MicroDelay(void) {
  u8g_xMicroDelay(10);
 }
 extern "C" void u8g_Delay(uint16_t val) {
@@ -63,7 +57,7 @@ int freeMemory() {
 //   return dval if not found or not a valid pin.
 int16_t PARSED_PIN_INDEX(const char code, const int16_t dval) {
  const uint16_t val = (uint16_t)parser.intval(code, -1), port = val / 100, pin = val % 100;
-  const  int16_t ind = (port < ((NUM_DIGITAL_PINS) >> 5) && pin < 32) ? ((port << 5) | pin) : -2;
+  const  int16_t ind = (port < ((NUM_DIGITAL_PINS) >> 5) && pin < 32) ? GET_PIN_MAP_INDEX((port << 5) | pin) : -2;
  return ind > -1 ? ind : dval;
 }

@@ -71,17 +65,4 @@ void flashFirmware(int16_t value) {
  NVIC_SystemReset();
 }

-void HAL_clear_reset_source(void) {
-  #if ENABLED(USE_WATCHDOG)
-    watchdog_clear_timeout_flag();
-  #endif
-}
-
-uint8_t HAL_get_reset_source(void) {
-  #if ENABLED(USE_WATCHDOG)
-    if (watchdog_timed_out()) return RST_WATCHDOG;
-  #endif
-  return RST_POWER_ON;
-}
-
 #endif // TARGET_LPC1768
@@ -28,7 +28,7 @@

 #define CPU_32_BIT

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

 #include <stdint.h>
 #include <stdarg.h>
@@ -113,7 +113,7 @@ extern "C" volatile uint32_t _millis;
 //
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wunused-function"
-int freeMemory();
+int freeMemory(void);
 #pragma GCC diagnostic pop

 //
@@ -131,43 +131,12 @@ int freeMemory();
                                    // K = 6, 565 samples, 500Hz sample rate, 1.13s convergence on full range step
                                    // Memory usage per ADC channel (bytes): 4 (32 Bytes for 8 channels)

-#define HAL_ADC_RESOLUTION     12   // 15 bit maximum, raw temperature is stored as int16_t
-#define HAL_ADC_FILTERED            // Disable oversampling done in Marlin as ADC values already filtered in HAL
-
 using FilteredADC = LPC176x::ADC<ADC_LOWPASS_K_VALUE, ADC_MEDIAN_FILTER_SIZE>;
-extern uint32_t HAL_adc_reading;
-[[gnu::always_inline]] inline void HAL_start_adc(const pin_t pin) {
-  HAL_adc_reading = FilteredADC::read(pin) >> (16 - HAL_ADC_RESOLUTION); // returns 16bit value, reduce to required bits
-}
-[[gnu::always_inline]] inline uint16_t HAL_read_adc() {
-  return HAL_adc_reading;
-}
-
-#define HAL_adc_init()
+#define HAL_adc_init()         FilteredADC::init()
 #define HAL_ANALOG_SELECT(pin) FilteredADC::enable_channel(pin)
-#define HAL_START_ADC(pin)     HAL_start_adc(pin)
-#define HAL_READ_ADC()         HAL_read_adc()
-#define HAL_ADC_READY()        (true)
-
-// Test whether the pin is valid
-constexpr bool VALID_PIN(const pin_t pin) {
-  return LPC176x::pin_is_valid(pin);
-}
-
-// Get the analog index for a digital pin
-constexpr int8_t DIGITAL_PIN_TO_ANALOG_PIN(const pin_t pin) {
-  return (LPC176x::pin_is_valid(pin) && LPC176x::pin_has_adc(pin)) ? pin : -1;
-}
-
-// Return the index of a pin number
-constexpr int16_t GET_PIN_MAP_INDEX(const pin_t pin) {
-  return LPC176x::pin_index(pin);
-}
-
-// Get the pin number at the given index
-constexpr pin_t GET_PIN_MAP_PIN(const int16_t index) {
-  return LPC176x::pin_index(index);
-}
+#define HAL_START_ADC(pin)     FilteredADC::start_conversion(pin)
+#define HAL_READ_ADC()         FilteredADC::get_result()
+#define HAL_ADC_READY()        FilteredADC::finished_conversion()

 // Parse a G-code word into a pin index
 int16_t PARSED_PIN_INDEX(const char code, const int16_t dval);
@@ -175,7 +144,7 @@ int16_t PARSED_PIN_INDEX(const char code, const int16_t dval);
 #define HAL_SENSITIVE_PINS P0_06, P0_07, P0_08, P0_09

 #define HAL_IDLETASK 1
-void HAL_idletask();
+void HAL_idletask(void);

 #define PLATFORM_M997_SUPPORT
 void flashFirmware(int16_t value);
@@ -195,7 +164,3 @@ void set_pwm_frequency(const pin_t pin, int f_desired);
 *  Optionally allows changing the maximum size of the provided value to enable finer PWM duty control [default = 255]
 */
 void set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size=255, const bool invert=false);
-
-// Reset source
-void HAL_clear_reset_source(void);
-uint8_t HAL_get_reset_source(void);
@@ -56,7 +56,7 @@
 // ------------------------
 #if ENABLED(LPC_SOFTWARE_SPI)

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

  // Software SPI

@@ -125,18 +125,18 @@
    PinCfg.Funcnum = 2;
    PinCfg.OpenDrain = 0;
    PinCfg.Pinmode = 0;
-    PinCfg.Pinnum = LPC176x::pin_bit(SCK_PIN);
-    PinCfg.Portnum = LPC176x::pin_port(SCK_PIN);
+    PinCfg.Pinnum = LPC1768_PIN_PIN(SCK_PIN);
+    PinCfg.Portnum = LPC1768_PIN_PORT(SCK_PIN);
    PINSEL_ConfigPin(&PinCfg);
    SET_OUTPUT(SCK_PIN);

-    PinCfg.Pinnum = LPC176x::pin_bit(MISO_PIN);
-    PinCfg.Portnum = LPC176x::pin_port(MISO_PIN);
+    PinCfg.Pinnum = LPC1768_PIN_PIN(MISO_PIN);
+    PinCfg.Portnum = LPC1768_PIN_PORT(MISO_PIN);
    PINSEL_ConfigPin(&PinCfg);
    SET_INPUT(MISO_PIN);

-    PinCfg.Pinnum = LPC176x::pin_bit(MOSI_PIN);
-    PinCfg.Portnum = LPC176x::pin_port(MOSI_PIN);
+    PinCfg.Pinnum = LPC1768_PIN_PIN(MOSI_PIN);
+    PinCfg.Portnum = LPC1768_PIN_PORT(MOSI_PIN);
    PINSEL_ConfigPin(&PinCfg);
    SET_OUTPUT(MOSI_PIN);
    // divide PCLK by 2 for SSP0
@@ -27,28 +27,28 @@

 #if (defined(SERIAL_PORT) && SERIAL_PORT == 0) || (defined(SERIAL_PORT_2) && SERIAL_PORT_2 == 0)
  MarlinSerial MSerial(LPC_UART0);
-  extern "C" void UART0_IRQHandler() {
+  extern "C" void UART0_IRQHandler(void) {
    MSerial.IRQHandler();
  }
 #endif

 #if (defined(SERIAL_PORT) && SERIAL_PORT == 1) || (defined(SERIAL_PORT_2) && SERIAL_PORT_2 == 1)
  MarlinSerial MSerial1((LPC_UART_TypeDef *) LPC_UART1);
-  extern "C" void UART1_IRQHandler() {
+  extern "C" void UART1_IRQHandler(void) {
    MSerial1.IRQHandler();
  }
 #endif

 #if (defined(SERIAL_PORT) && SERIAL_PORT == 2) || (defined(SERIAL_PORT_2) && SERIAL_PORT_2 == 2)
  MarlinSerial MSerial2(LPC_UART2);
-  extern "C" void UART2_IRQHandler() {
+  extern "C" void UART2_IRQHandler(void) {
    MSerial2.IRQHandler();
  }
 #endif

 #if (defined(SERIAL_PORT) && SERIAL_PORT == 3) || (defined(SERIAL_PORT_2) && SERIAL_PORT_2 == 3)
  MarlinSerial MSerial3(LPC_UART3);
-  extern "C" void UART3_IRQHandler() {
+  extern "C" void UART3_IRQHandler(void) {
    MSerial3.IRQHandler();
  }
 #endif
@@ -49,7 +49,7 @@ public:
    {
    }

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

  #if ENABLED(EMERGENCY_PARSER)
    bool recv_callback(const char c) override {
@@ -57,11 +57,11 @@ class libServo: public Servo {
    constexpr uint16_t servo_delay[] = SERVO_DELAY;
    static_assert(COUNT(servo_delay) == NUM_SERVOS, "SERVO_DELAY must be an array NUM_SERVOS long.");

-    if (attach(servo_info[servoIndex].Pin.nbr) >= 0) {    // try to reattach
-      write(value);
-      safe_delay(servo_delay[servoIndex]); // delay to allow servo to reach position
+    if (this->attach(servo_info[this->servoIndex].Pin.nbr) >= 0) {    // try to reattach
+      this->write(value);
+      safe_delay(servo_delay[this->servoIndex]); // delay to allow servo to reach position
      #if ENABLED(DEACTIVATE_SERVOS_AFTER_MOVE)
-        detach();
+        this->detach();
      #endif
    }

@@ -38,76 +38,73 @@
 #include "../../module/endstops.h"

 // One ISR for all EXT-Interrupts
-void endstop_ISR() { endstops.update(); }
-
-void setup_endstop_interrupts() {
-  #define _ATTACH(P) attachInterrupt(digitalPinToInterrupt(P), endstop_ISR, CHANGE)
-  #define LPC1768_PIN_INTERRUPT_M(pin) ((pin >> 0x5 & 0x7) == 0 || (pin >> 0x5 & 0x7) == 2)
+void endstop_ISR(void) { endstops.update(); }

+void setup_endstop_interrupts(void) {
  #if HAS_X_MAX
    #if !LPC1768_PIN_INTERRUPT_M(X_MAX_PIN)
-      #error "X_MAX_PIN is not INTERRUPT-capable."
+      #error "X_MAX_PIN is not an INTERRUPT capable pin."
    #endif
-    _ATTACH(X_MAX_PIN);
+    attachInterrupt(digitalPinToInterrupt(X_MAX_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_X_MIN
    #if !LPC1768_PIN_INTERRUPT_M(X_MIN_PIN)
-      #error "X_MIN_PIN is not INTERRUPT-capable."
+      #error "X_MIN_PIN is not an INTERRUPT capable pin."
    #endif
-    _ATTACH(X_MIN_PIN);
+    attachInterrupt(digitalPinToInterrupt(X_MIN_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Y_MAX
    #if !LPC1768_PIN_INTERRUPT_M(Y_MAX_PIN)
-      #error "Y_MAX_PIN is not INTERRUPT-capable."
+      #error "Y_MAX_PIN is not an INTERRUPT capable pin."
    #endif
-    _ATTACH(Y_MAX_PIN);
+    attachInterrupt(digitalPinToInterrupt(Y_MAX_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Y_MIN
    #if !LPC1768_PIN_INTERRUPT_M(Y_MIN_PIN)
-      #error "Y_MIN_PIN is not INTERRUPT-capable."
+      #error "Y_MIN_PIN is not an INTERRUPT capable pin."
    #endif
-    _ATTACH(Y_MIN_PIN);
+    attachInterrupt(digitalPinToInterrupt(Y_MIN_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Z_MAX
    #if !LPC1768_PIN_INTERRUPT_M(Z_MAX_PIN)
-      #error "Z_MAX_PIN is not INTERRUPT-capable."
+      #error "Z_MAX_PIN is not an INTERRUPT capable pin."
    #endif
-    _ATTACH(Z_MAX_PIN);
+    attachInterrupt(digitalPinToInterrupt(Z_MAX_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Z_MIN
    #if !LPC1768_PIN_INTERRUPT_M(Z_MIN_PIN)
-      #error "Z_MIN_PIN is not INTERRUPT-capable."
+      #error "Z_MIN_PIN is not an INTERRUPT capable pin."
    #endif
-     _ATTACH(Z_MIN_PIN);
+     attachInterrupt(digitalPinToInterrupt(Z_MIN_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Z2_MAX
    #if !LPC1768_PIN_INTERRUPT_M(Z2_MAX_PIN)
-      #error "Z2_MAX_PIN is not INTERRUPT-capable."
+      #error "Z2_MAX_PIN is not an INTERRUPT capable pin."
    #endif
-    _ATTACH(Z2_MAX_PIN);
+    attachInterrupt(digitalPinToInterrupt(Z2_MAX_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Z2_MIN
    #if !LPC1768_PIN_INTERRUPT_M(Z2_MIN_PIN)
-      #error "Z2_MIN_PIN is not INTERRUPT-capable."
+      #error "Z2_MIN_PIN is not an INTERRUPT capable pin."
    #endif
-    _ATTACH(Z2_MIN_PIN);
+    attachInterrupt(digitalPinToInterrupt(Z2_MIN_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Z3_MAX
    #if !LPC1768_PIN_INTERRUPT_M(Z3_MIN_PIN)
-      #error "Z3_MIN_PIN is not INTERRUPT-capable."
+      #error "Z3_MIN_PIN is not an INTERRUPT capable pin."
    #endif
-    _ATTACH(Z3_MAX_PIN);
+    attachInterrupt(digitalPinToInterrupt(Z3_MAX_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Z3_MIN
    #if !LPC1768_PIN_INTERRUPT_M(Z3_MIN_PIN)
-      #error "Z3_MIN_PIN is not INTERRUPT-capable."
+      #error "Z3_MIN_PIN is not an INTERRUPT capable pin."
    #endif
-    _ATTACH(Z3_MIN_PIN);
+    attachInterrupt(digitalPinToInterrupt(Z3_MIN_PIN), endstop_ISR, CHANGE);
  #endif
  #if HAS_Z_MIN_PROBE_PIN
    #if !LPC1768_PIN_INTERRUPT_M(Z_MIN_PROBE_PIN)
-      #error "Z_MIN_PROBE_PIN is not INTERRUPT-capable."
+      #error "Z_MIN_PROBE_PIN is not an INTERRUPT capable pin."
    #endif
-    _ATTACH(Z_MIN_PROBE_PIN);
+    attachInterrupt(digitalPinToInterrupt(Z_MIN_PROBE_PIN), endstop_ISR, CHANGE);
  #endif
 }
@@ -24,17 +24,17 @@

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

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

 #include <pwm.h>

 void set_pwm_frequency(const pin_t pin, int f_desired) {
-  LPC176x::pwm_set_frequency(pin, f_desired);
+  pwm_set_frequency(pin, f_desired);
 }

 void set_pwm_duty(const pin_t pin, const uint16_t v, const uint16_t v_size/*=255*/, const bool invert/*=false*/) {
-  LPC176x::pwm_write_ratio(pin, invert ? 1.0f - (float)v / v_size : (float)v / v_size);
+  pwm_write_ratio(pin, invert ? 1.0f - (float)v / v_size : (float)v / v_size);
 }

-#endif // FAST_PWM_FAN || SPINDLE_LASER_PWM
+#endif // FAST_PWM_FAN
 #endif // TARGET_LPC1768
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
InsanityAutomation	098256d5df	Merge pull request #55 from g0dsCookie/CrealityDwin_2.0 Fixed include paths	2019-09-17 08:58:44 -04:00
InsanityAutomation	a0f00367fe	Update max bed thermal limits for large dc bed at high temps	2019-09-16 22:22:11 -04:00
InsanityAutomation	60cfb42668	dont send octo cancel on timer stop	2019-09-09 10:09:54 -04:00
InsanityAutomation	138de675fe	Add tone	2019-09-08 22:52:08 -04:00
InsanityAutomation	263ca25342	Merge branch 'CrealityDwin_2.0' of https://github.com/InsanityAutomation/Marlin into CrealityDwin_2.0	2019-09-08 19:58:39 -04:00
InsanityAutomation	e4211d2358	Remove obsolete	2019-09-08 19:58:28 -04:00
InsanityAutomation	03897008e4	Add files via upload	2019-09-08 19:58:05 -04:00
InsanityAutomation	9291b46600	Bump	2019-09-08 19:57:39 -04:00
InsanityAutomation	ed5cc1a0c0	Bump with M851XY	2019-09-08 18:38:25 -04:00
InsanityAutomation	769701e64a	Update Configuration.h	2019-09-08 17:40:43 -04:00
InsanityAutomation	4c8f900950	Update Creality_DWIN.cpp	2019-09-08 16:37:12 -04:00
InsanityAutomation	c0f97e7874	Merge branch 'CrealityDwin_2.0' of https://github.com/InsanityAutomation/Marlin into CrealityDwin_2.0	2019-09-07 11:32:17 -04:00
InsanityAutomation	232dec268d	NewRev	2019-09-07 11:32:04 -04:00
InsanityAutomation	6af3951a47	Add files via upload	2019-09-07 11:31:17 -04:00
InsanityAutomation	ea34fa2616	fix extui timers	2019-09-07 10:31:33 -04:00
InsanityAutomation	0e04d7b43d	Update tool_change.cpp	2019-09-06 22:18:05 -04:00
InsanityAutomation	093d3cb32b	revert non working bed leveling disable more tool change	2019-09-06 21:44:59 -04:00
InsanityAutomation	f603a152c7	Merge branch 'CrealityDwin_2.0' of https://github.com/InsanityAutomation/Marlin into CrealityDwin_2.0	2019-09-05 21:33:51 -04:00
InsanityAutomation	cf7e896328	Update Configuration.h	2019-09-05 21:33:46 -04:00
InsanityAutomation	d4ad91c8f2	Add files via upload	2019-09-05 21:20:57 -04:00
InsanityAutomation	e45d5354ea	Add files via upload	2019-09-05 21:11:38 -04:00
InsanityAutomation	4279b78b17	dont compile creality dwin if not enabled	2019-09-05 20:46:59 -04:00
InsanityAutomation	5d24ecb17b	Update Configuration.h	2019-09-05 16:28:13 -04:00
InsanityAutomation	23c7b5018e	Small tweaks	2019-09-05 16:27:35 -04:00
InsanityAutomation	04d499c816	Update Configuration.h	2019-08-30 13:02:16 -04:00
g0dsCookie	e943b54003	Fixed include paths	2019-08-30 15:51:51 +02:00
InsanityAutomation	7d04475e09	Update bltouch.cpp	2019-08-29 14:29:15 -04:00
InsanityAutomation	8c796fcd3b	Update Configuration.h	2019-08-29 14:22:43 -04:00
InsanityAutomation	39997b7710	Update Creality_DWIN.cpp	2019-08-29 13:32:24 -04:00
InsanityAutomation	6ac884ee58	Update Creality_DWIN.cpp	2019-08-29 13:30:23 -04:00
InsanityAutomation	b0829e5745	Update Creality_DWIN.cpp	2019-08-29 12:58:20 -04:00
InsanityAutomation	ed2d955a42	Some ender 5 tweaks	2019-08-29 10:25:34 -04:00
InsanityAutomation	49c78a4b25	Fix Progress, test bltouch servo to 0, set message for z offset change	2019-08-28 17:31:58 -04:00
InsanityAutomation	eb53a1c318	Update Configuration.h	2019-08-28 12:00:24 -04:00
InsanityAutomation	4743bb58e9	Update README.md	2019-08-24 15:02:43 -04:00
InsanityAutomation	27f48c2c46	Update bin file name	2019-08-24 14:54:44 -04:00
InsanityAutomation	9ab228f19d	segmented move change	2019-08-24 00:44:32 -04:00
InsanityAutomation	00d3cdc8a6	Update README.md	2019-08-24 00:37:13 -04:00
InsanityAutomation	384f45dcae	Update README.md	2019-08-24 00:23:11 -04:00
InsanityAutomation	ebc40633a5	Add standard configuration Hex files	2019-08-23 21:42:01 -04:00
InsanityAutomation	61665a4b6f	Update README.md	2019-08-23 21:29:03 -04:00
InsanityAutomation	848020d314	Update README.md	2019-08-23 21:24:51 -04:00
InsanityAutomation	885fe5f573	Update README.md	2019-08-23 21:20:56 -04:00
InsanityAutomation	39f035547a	Update README.md	2019-08-23 21:18:36 -04:00
InsanityAutomation	975141f77e	Tweaks	2019-08-23 21:18:09 -04:00
InsanityAutomation	aa6b6a3b3d	crx pid, tweaks	2019-08-23 19:58:17 -04:00
InsanityAutomation	0b81c1cd14	ExtUI babystep to position without probe	2019-08-23 15:55:26 -04:00
InsanityAutomation	1a1f9562d8	Update README.md	2019-08-23 14:04:29 -04:00
InsanityAutomation	334893f831	Update CR-X_Stock__1.70_Screen.7z	2019-08-23 13:42:49 -04:00
InsanityAutomation	73310d9848	Update README.md	2019-08-23 13:34:23 -04:00
InsanityAutomation	34cce5a26a	Archive TFT files 50mb to 1.5mb	2019-08-23 11:14:54 -04:00
InsanityAutomation	45688c0ae6	Update README.md	2019-08-23 00:25:53 -04:00
InsanityAutomation	420ea1c30e	Update README.md	2019-08-23 00:12:17 -04:00
InsanityAutomation	10a71da890	Update single extruder screens with 2.0 functions	2019-08-22 23:13:14 -04:00
InsanityAutomation	dde5cdfb0b	Update Creality_DWIN.cpp	2019-08-22 21:44:50 -04:00
InsanityAutomation	0fea530069	Tweaks	2019-08-22 20:55:42 -04:00
InsanityAutomation	b55264b5ed	fix status callback	2019-08-22 20:13:02 -04:00
InsanityAutomation	fb1cd0cf3c	TweaksTouchups	2019-08-22 19:39:40 -04:00
InsanityAutomation	6840dcf87d	Update Configuration.h	2019-08-22 14:32:58 -04:00
InsanityAutomation	04f81d0aa4	Update Creality_DWIN.cpp	2019-08-22 13:15:59 -04:00
InsanityAutomation	1884f3754c	Update Creality_DWIN.cpp	2019-08-22 13:04:17 -04:00
InsanityAutomation	8f8511d2e0	tweaks	2019-08-22 12:34:14 -04:00
InsanityAutomation	966ffa295f	bump	2019-08-21 22:31:18 -04:00
InsanityAutomation	63815d9acc	Bump	2019-08-21 20:32:28 -04:00
InsanityAutomation	1b5f70a35e	fix level corners	2019-08-21 20:29:06 -04:00
InsanityAutomation	f6fc94dbc4	sd card continuity bump	2019-08-21 17:17:47 -04:00
InsanityAutomation	06982535d2	Tweaks	2019-08-21 10:45:53 -04:00
InsanityAutomation	f62a5f3ff6	Update Configuration.h	2019-08-21 00:14:46 -04:00
InsanityAutomation	2fc4871bc1	Update Configuration.h	2019-08-21 00:12:42 -04:00
InsanityAutomation	7e5b72bb49	Update Configuration.h	2019-08-20 23:25:52 -04:00
InsanityAutomation	31386be583	throttling	2019-08-20 22:45:47 -04:00
InsanityAutomation	cff4360621	Tweaks	2019-08-20 20:28:39 -04:00
InsanityAutomation	f515f22313	update pid refix old bug	2019-08-20 18:44:20 -04:00
InsanityAutomation	e249e380fc	usability tweaks	2019-08-20 18:12:01 -04:00
InsanityAutomation	9ce076a045	Bump	2019-08-20 17:59:36 -04:00
InsanityAutomation	f70c1d59da	debug	2019-08-20 17:21:49 -04:00
InsanityAutomation	f30bf8ba7d	Update README.md	2019-08-20 14:26:05 -04:00
InsanityAutomation	5e82e4e33d	Update Creality_DWIN.cpp	2019-08-20 14:00:19 -04:00
InsanityAutomation	b54f11859a	Update Creality_DWIN.cpp	2019-08-20 10:20:35 -04:00
InsanityAutomation	5c051a005f	Update README.md	2019-08-19 12:43:19 -04:00
InsanityAutomation	d25e477f76	Update README.md	2019-08-19 12:40:37 -04:00
InsanityAutomation	a1d8f5f79f	Update README.md	2019-08-19 12:39:43 -04:00
InsanityAutomation	fd52a71294	Update README.md	2019-08-19 12:38:59 -04:00
InsanityAutomation	adc60676ae	Update README.md	2019-08-19 10:16:42 -04:00
InsanityAutomation	55a69ca853	Update README.md	2019-08-19 10:15:31 -04:00
InsanityAutomation	e0e42a5f61	cleanup	2019-08-18 23:20:16 -04:00
InsanityAutomation	2b10dfaf52	Update Creality_DWIN.cpp	2019-08-18 23:18:47 -04:00
InsanityAutomation	4599988e2a	One more SD tweak	2019-08-18 23:01:39 -04:00
InsanityAutomation	ea10994180	Tweak sd file select	2019-08-18 22:42:33 -04:00
InsanityAutomation	534a3f39bb	Update Creality_DWIN.cpp	2019-08-18 21:00:40 -04:00
InsanityAutomation	9f04dfb0a1	Change txt to white	2019-08-18 20:42:54 -04:00
InsanityAutomation	34d8f1d81f	Fix swapped icon	2019-08-18 19:14:21 -04:00
InsanityAutomation	005cbbbb17	Update G28.cpp	2019-08-18 19:09:08 -04:00
InsanityAutomation	9dbf731d9a	fix runout trigering oon either sensor	2019-08-18 18:29:04 -04:00
InsanityAutomation	3f752657a7	turn runout back on	2019-08-18 18:04:52 -04:00
InsanityAutomation	dd70e03767	lots of fixes	2019-08-18 18:00:35 -04:00
InsanityAutomation	ecdc3a0911	Tweaks	2019-08-18 14:51:55 -04:00
InsanityAutomation	2416912aef	Bump	2019-08-18 14:48:04 -04:00
InsanityAutomation	6d7220e379	Initial Ender 5 support, migrate max support	2019-08-18 14:44:53 -04:00
InsanityAutomation	80134a4a48	Update Configuration.h	2019-08-18 12:26:37 -04:00
InsanityAutomation	e49bbfef14	Delete DWIN_SET.7z	2019-08-18 10:35:12 -04:00
InsanityAutomation	0c48e709ff	Updates again	2019-08-18 00:45:27 -04:00
InsanityAutomation	38aba644c3	Update	2019-08-17 22:04:51 -04:00
InsanityAutomation	6498c4cf88	Config sync	2019-08-17 20:23:22 -04:00
InsanityAutomation	9948054cb7	Lots of fixes	2019-08-17 19:29:45 -04:00
InsanityAutomation	412e3aa1f6	Update ui_api.cpp	2019-08-17 00:49:32 -04:00
InsanityAutomation	9975799c5f	CRX Works too	2019-08-17 00:18:56 -04:00
InsanityAutomation	5f688304f6	Update Creality_DWIN.cpp	2019-08-16 10:34:17 -04:00
InsanityAutomation	ba919e49fc	Mostly works ok-ish	2019-08-16 00:31:17 -04:00
InsanityAutomation	a2fa854d9c	Bump, filament runout mostly works	2019-08-14 00:24:51 -04:00
InsanityAutomation	518e313260	Update Configuration.h	2019-07-23 22:47:30 -04:00
InsanityAutomation	4e2b4ce9a0	Bump	2019-07-23 22:46:22 -04:00
InsanityAutomation	08b5bdda27	fixes	2019-07-19 10:47:24 -04:00
InsanityAutomation	a9d634fe28	minor tweak	2019-07-19 10:23:45 -04:00
InsanityAutomation	4198b14e2f	Bump to head, some tweaks	2019-07-19 10:21:38 -04:00
InsanityAutomation	615ac13a52	bump to head, misc fixes	2019-06-23 12:06:21 -04:00
InsanityAutomation	8d23b85b47	Update Creality_DWIN.cpp	2019-06-23 11:38:16 -04:00
InsanityAutomation	ad17b23fc8	SD Print Working	2019-05-27 23:57:46 -04:00
InsanityAutomation	3ef237cece	More progress	2019-05-18 14:56:14 -04:00
InsanityAutomation	4c2fe3bad8	Bump and fix mesh define issue	2019-05-15 23:00:26 -04:00
InsanityAutomation	0822bcbff8	Bump in the night	2019-04-25 23:35:43 -04:00
InsanityAutomation	672f1c60fb	progress	2019-04-25 23:23:01 -04:00
InsanityAutomation	3a8c87b511	Update Creality_DWIN.cpp	2019-04-24 21:18:29 -04:00
InsanityAutomation	a43dd70976	Update Configuration.h	2019-04-23 18:39:02 -04:00
InsanityAutomation	e890bdffeb	disable some mesh and bed leveling stuff until API is fixed	2019-04-23 17:57:19 -04:00
InsanityAutomation	eb54bf155a	Bump to head, another couple steps	2019-04-23 17:37:25 -04:00
InsanityAutomation	53e9e8c7b3	close the night...	2019-03-17 01:00:47 -04:00
InsanityAutomation	cddbd1c6b4	Updates	2019-03-17 00:41:55 -04:00
InsanityAutomation	77db45432b	Update Creality_DWIN.cpp	2019-03-17 00:39:00 -04:00
InsanityAutomation	68240d398f	IT COMPILES!!!! without sd card to screen	2019-03-17 00:23:55 -04:00
InsanityAutomation	6a3532bc71	Another Step	2019-03-17 00:05:31 -04:00
InsanityAutomation	a94dedd2cb	Compile fixes	2019-03-16 23:36:26 -04:00
InsanityAutomation	2108715fa6	Update Configuration.h	2019-03-16 22:49:55 -04:00
InsanityAutomation	614c9c6c9d	more	2019-03-16 19:02:40 -04:00
InsanityAutomation	1c658401de	bump	2019-03-16 16:29:28 -04:00
InsanityAutomation	97379d5d53	More updates	2019-03-16 16:03:56 -04:00
InsanityAutomation	3e5a957872	Updates	2019-03-16 13:31:19 -04:00
InsanityAutomation	e9588824bb	10s pro support and basic dwin files to start changes	2019-03-16 13:31:19 -04:00