Update Configuration.h

2019-09-16 22:13:50 -04:00 · 2019-09-06 23:52:00 -04:00 · 2019-09-06 23:50:03 -04:00 · 2019-09-06 23:44:14 -04:00 · 2019-08-28 09:44:02 -04:00 · 2019-08-25 13:07:10 -04:00
946 changed files with 144367 additions and 8810 deletions
@@ -242,12 +242,12 @@ jobs:
            echo testing STM32F1 targets...
            export TEST_PLATFORM="-e STM32F1"
            restore_configs
-            echo use_example_configs STM32F10
-            use_example_configs STM32F10
+            echo use_example_configs STM32/STM32F10
+            use_example_configs STM32/STM32F10
            build_marlin_pio ./ ${TEST_PLATFORM}
            restore_configs
-            echo use_example_configs stm32f103ret6
-            use_example_configs stm32f103ret6
+            echo use_example_configs STM32/stm32f103ret6
+            use_example_configs STM32/stm32f103ret6
            build_marlin_pio ./ ${TEST_PLATFORM}
            restore_configs

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

 Have you read Marlin's Code of Conduct? By filing an Issue, you are expected to comply with it, including treating everyone with respect: https://github.com/MarlinFirmware/Marlin/blob/bugfix-2.0.x/.github/code_of_conduct.md

-Do you want to ask a question? Are you looking for support? Please don't post here. Instead please use the Marlin Firmware forum at http://forums.reprap.org/list.php?415 or the Marlin Facebook Group https://www.facebook.com/groups/1049718498464482/.
+Do you want to ask a question? Are you looking for support? Please don't post here. Instead please use the Marlin Firmware forum at http://forums.reprap.org/list.php?415 or the Marlin Facebook Group https://www.facebook.com/groups/1049718498464482/ or the Marlin Discord Server https://discord.gg/n5NJ59y.

 Before filing an issue be sure to test the 1.1 and/or 2.0 "bugfix" branches to see whether the issue is already addressed.

@@ -1,39 +1,28 @@
-dist: xenial
-sudo: require
+dist: bionic
+sudo: false

 language: python
 python:
-  - "2.7"
+  - "3.7"

 notifications:
  email: false

-# Cache PlatformIO packages using Travis CI container-based infrastructure
-sudo: false
-cache:
-  pip: true
-  directories:
-  - "~/.platformio"
-
 env:
  - TEST_PLATFORM="megaatmega2560"
  - TEST_PLATFORM="DUE"
  - TEST_PLATFORM="LPC1768"
  - TEST_PLATFORM="LPC1769"
  - TEST_PLATFORM="STM32F1"
+  - TEST_PLATFORM="teensy31"
  - TEST_PLATFORM="teensy35"
  - TEST_PLATFORM="linux_native"
  - TEST_PLATFORM="esp32"
-
-addons:
-  apt:
-    sources:
-      - ubuntu-toolchain-r-test
-    packages:
-      - g++-7
+  - TEST_PLATFORM="alfawise_U20"
+  - TEST_PLATFORM="black_stm32f407ve"
+  - TEST_PLATFORM="adafruit_grandcentral_m4"

 before_install:
-  - sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-7 90
  #
  # Fetch the tag information for the current branch
  - git fetch origin --tags
@@ -137,8 +137,8 @@
 * THERMAL_PROTECTION_HYSTERESIS and/or THERMAL_PROTECTION_PERIOD
 */
 #if ENABLED(THERMAL_PROTECTION_HOTENDS)
-  #define THERMAL_PROTECTION_PERIOD 120        // Seconds
-  #define THERMAL_PROTECTION_HYSTERESIS 4     // Degrees Celsius
+  #define THERMAL_PROTECTION_PERIOD 210        // Seconds
+  #define THERMAL_PROTECTION_HYSTERESIS 10     // Degrees Celsius

  #define ADAPTIVE_FAN_SLOWING              // Slow part cooling fan if temperature drops
  #if BOTH(ADAPTIVE_FAN_SLOWING, PIDTEMP)
@@ -157,22 +157,22 @@
   * and/or decrease WATCH_TEMP_INCREASE. WATCH_TEMP_INCREASE should not be set
   * below 2.
   */
-  #define WATCH_TEMP_PERIOD 120                // Seconds
-  #define WATCH_TEMP_INCREASE 4               // Degrees Celsius
+  #define WATCH_TEMP_PERIOD 210               // Seconds
+  #define WATCH_TEMP_INCREASE 2               // Degrees Celsius
 #endif

 /**
 * Thermal Protection parameters for the bed are just as above for hotends.
 */
 #if ENABLED(THERMAL_PROTECTION_BED)
-  #define THERMAL_PROTECTION_BED_PERIOD 240    // Seconds
-  #define THERMAL_PROTECTION_BED_HYSTERESIS 4 // Degrees Celsius
+  #define THERMAL_PROTECTION_BED_PERIOD 300    // Seconds
+  #define THERMAL_PROTECTION_BED_HYSTERESIS 2 // Degrees Celsius

  /**
   * As described above, except for the bed (M140/M190/M303).
   */
-  #define WATCH_BED_TEMP_PERIOD 240                // Seconds
-  #define WATCH_BED_TEMP_INCREASE 4               // Degrees Celsius
+  #define WATCH_BED_TEMP_PERIOD 60                // Seconds
+  #define WATCH_BED_TEMP_INCREASE 2               // Degrees Celsius
 #endif

 /**
@@ -215,7 +215,7 @@
 #endif

 // Show extra position information in M114
-//#define M114_DETAIL
+#define M114_DETAIL

 // Show Temperature ADC value
 // Enable for M105 to include ADC values read from temperature sensors.
@@ -279,15 +279,16 @@
 */
 //#define USE_CONTROLLER_FAN
 #if ENABLED(USE_CONTROLLER_FAN)
-  //#define CONTROLLER_FAN_PIN -1        // Set a custom pin for the controller fan
-  #define CONTROLLERFAN_SECS 60          // Duration in seconds for the fan to run after all motors are disabled
-  #define CONTROLLERFAN_SPEED 255        // 255 == full speed
+  //#define CONTROLLER_FAN_PIN -1           // Set a custom pin for the controller fan
+  #define CONTROLLERFAN_SECS 60             // Duration in seconds for the fan to run after all motors are disabled
+  #define CONTROLLERFAN_SPEED 255           // 255 == full speed
+  //#define CONTROLLERFAN_SPEED_Z_ONLY 127  // Reduce noise on machines that keep Z enabled
 #endif

 // When first starting the main fan, run it at full speed for the
 // given number of milliseconds.  This gets the fan spinning reliably
 // before setting a PWM value. (Does not work with software PWM for fan on Sanguinololu)
-//#define FAN_KICKSTART_TIME 100
+#define FAN_KICKSTART_TIME 100

 /**
 * PWM Fan Scaling
@@ -345,7 +346,11 @@
 * Multiple extruders can be assigned to the same pin in which case
 * the fan will turn on when any selected extruder is above the threshold.
 */
-#define E0_AUTO_FAN_PIN -1
+#if ENABLED(RAPTOR2)
+  #define E0_AUTO_FAN_PIN 9
+#else
+  #define E0_AUTO_FAN_PIN -1
+#endif
 #define E1_AUTO_FAN_PIN -1
 #define E2_AUTO_FAN_PIN -1
 #define E3_AUTO_FAN_PIN -1
@@ -372,14 +377,14 @@
 /**
 * M355 Case Light on-off / brightness
 */
-//#define CASE_LIGHT_ENABLE
+#define CASE_LIGHT_ENABLE
 #if ENABLED(CASE_LIGHT_ENABLE)
-  //#define CASE_LIGHT_PIN 4                  // Override the default pin if needed
+  #define CASE_LIGHT_PIN 5                  // Override the default pin if needed
  #define INVERT_CASE_LIGHT false             // Set true if Case Light is ON when pin is LOW
  #define CASE_LIGHT_DEFAULT_ON true          // Set default power-up state on
-  #define CASE_LIGHT_DEFAULT_BRIGHTNESS 105   // Set default power-up brightness (0-255, requires PWM pin)
-  //#define CASE_LIGHT_MENU                   // Add Case Light options to the LCD menu
-  //#define CASE_LIGHT_NO_BRIGHTNESS          // Disable brightness control. Enable for non-PWM lighting.
+  #define CASE_LIGHT_DEFAULT_BRIGHTNESS 255   // Set default power-up brightness (0-255, requires PWM pin)
+  #define CASE_LIGHT_MENU                   // Add Case Light options to the LCD menu
+  #define CASE_LIGHT_NO_BRIGHTNESS          // Disable brightness control. Enable for non-PWM lighting.
  //#define CASE_LIGHT_USE_NEOPIXEL           // Use Neopixel LED as case light, requires NEOPIXEL_LED.
  #if ENABLED(CASE_LIGHT_USE_NEOPIXEL)
    #define CASE_LIGHT_NEOPIXEL_COLOR { 255, 255, 255, 255 } // { Red, Green, Blue, White }
@@ -438,9 +443,7 @@
  #endif
 #endif

-#if ENABLED(DUAL_Z)
-  #define Z_DUAL_STEPPER_DRIVERS
-#endif
+//#define Z_DUAL_STEPPER_DRIVERS
 #if ENABLED(Z_DUAL_STEPPER_DRIVERS)
  //#define Z_DUAL_ENDSTOPS
  #if ENABLED(Z_DUAL_ENDSTOPS)
@@ -518,16 +521,16 @@
 // Homing hits each endstop, retracts by these distances, then does a slower bump.
 #define X_HOME_BUMP_MM 5
 #define Y_HOME_BUMP_MM 5
-#define Z_HOME_BUMP_MM 5
+#define Z_HOME_BUMP_MM 2
 #define HOMING_BUMP_DIVISOR { 2, 2, 4 }  // Re-Bump Speed Divisor (Divides the Homing Feedrate)
-//#define QUICK_HOME                     // If homing includes X and Y, do a diagonal move initially
+#define QUICK_HOME                     // If homing includes X and Y, do a diagonal move initially
 //#define HOMING_BACKOFF_MM { 2, 2, 2 }  // (mm) Move away from the endstops after homing

 // When G28 is called, this option will make Y home before X
 //#define HOME_Y_BEFORE_X

 // Enable this if X or Y can't home without homing the other axis first.
-#define CODEPENDENT_XY_HOMING
+//#define CODEPENDENT_XY_HOMING

 #if ENABLED(BLTOUCH)
  /**
@@ -600,20 +603,18 @@
 * Z Steppers Auto-Alignment
 * Add the G34 command to align multiple Z steppers using a bed probe.
 */
-#if ENABLED(DUAL_Z)
-  #define Z_STEPPER_AUTO_ALIGN
-#endif
+//#define Z_STEPPER_AUTO_ALIGN
 #if ENABLED(Z_STEPPER_AUTO_ALIGN)
  // Define probe X and Y positions for Z1, Z2 [, Z3]
-  #define Z_STEPPER_ALIGN_X { 50, 350 }
-  #define Z_STEPPER_ALIGN_Y { 200, 200 }
+  #define Z_STEPPER_ALIGN_X { 10, 150, 290 }
+  #define Z_STEPPER_ALIGN_Y { 290, 10, 290 }
  // Set number of iterations to align
  #define Z_STEPPER_ALIGN_ITERATIONS 3
  // Enable to restore leveling setup after operation
  #define RESTORE_LEVELING_AFTER_G34

  // On a 300mm bed a 5% grade would give a misalignment of ~1.5cm
-  #define G34_MAX_GRADE  15  // (%) Maximum incline G34 will handle
+  #define G34_MAX_GRADE  5  // (%) Maximum incline G34 will handle

  // Use the amplification factor to de-/increase correction step.
  // In case the stepper (spindle) position is further out than the test point
@@ -654,16 +655,17 @@

 #if EITHER(ULTIPANEL, EXTENSIBLE_UI)
  #define MANUAL_FEEDRATE { 50*60, 50*60, 4*60, 60 } // Feedrates for manual moves along X, Y, Z, E from panel
+  #define SHORT_MANUAL_Z_MOVE 0.025 // (mm) Smallest manual Z move (< 0.1mm)
  #if ENABLED(ULTIPANEL)
    #define MANUAL_E_MOVES_RELATIVE // Display extruder move distance rather than "position"
    #define ULTIPANEL_FEEDMULTIPLY  // Encoder sets the feedrate multiplier on the Status Screen
  #endif
 #endif

-// @section extras
+// @section motion

-// minimum time in microseconds that a movement needs to take if the buffer is emptied.
-#define DEFAULT_MINSEGMENTTIME        20000
+// Minimum time that a segment needs to take if the buffer is emptied
+#define DEFAULT_MINSEGMENTTIME        20000   // (ms)

 // If defined the movements slow down when the look ahead buffer is only half full
 #define SLOWDOWN
@@ -770,9 +772,8 @@
 * vibration and surface artifacts. The algorithm adapts to provide the best possible step smoothing at the
 * lowest stepping frequencies.
 */
-#if ENABLED(SKR13)
-  #define ADAPTIVE_STEP_SMOOTHING
-#endif
+//#define ADAPTIVE_STEP_SMOOTHING
+
 /**
 * Custom Microstepping
 * Override as-needed for your setup. Up to 3 MS pins are supported.
@@ -854,20 +855,47 @@
  #define FEEDRATE_CHANGE_BEEP_FREQUENCY 440
 #endif

-// Include a page of printer information in the LCD Main Menu
-#define LCD_INFO_MENU
+#if HAS_LCD_MENU
+
+  // Include a page of printer information in the LCD Main Menu
+  //#define LCD_INFO_MENU
+  #if ENABLED(LCD_INFO_MENU)
+    //#define LCD_PRINTER_INFO_IS_BOOTSCREEN // Show bootscreen(s) instead of Printer Info pages
+  #endif
+
+  // BACK menu items keep the highlight at the top
+  //#define TURBO_BACK_MENU_ITEM
+
+  /**
+   * LED Control Menu
+   * Add LED Control to the LCD menu
+   */
+  //#define LED_CONTROL_MENU
+  #if ENABLED(LED_CONTROL_MENU)
+    #define LED_COLOR_PRESETS                 // Enable the Preset Color menu option
+    #if ENABLED(LED_COLOR_PRESETS)
+      #define LED_USER_PRESET_RED        255  // User defined RED value
+      #define LED_USER_PRESET_GREEN      128  // User defined GREEN value
+      #define LED_USER_PRESET_BLUE         0  // User defined BLUE value
+      #define LED_USER_PRESET_WHITE      255  // User defined WHITE value
+      #define LED_USER_PRESET_BRIGHTNESS 255  // User defined intensity
+      //#define LED_USER_PRESET_STARTUP       // Have the printer display the user preset color on startup
+    #endif
+  #endif
+
+#endif // HAS_LCD_MENU

 // Scroll a longer status message into view
 #define STATUS_MESSAGE_SCROLLING

 // On the Info Screen, display XY with one decimal place when possible
-//#define LCD_DECIMAL_SMALL_XY
+#define LCD_DECIMAL_SMALL_XY

 // The timeout (in ms) to return to the status screen from sub-menus
-//#define LCD_TIMEOUT_TO_STATUS 15000
+#define LCD_TIMEOUT_TO_STATUS 15000

 // Add an 'M73' G-code to set the current percentage
-//#define LCD_SET_PROGRESS_MANUALLY
+#define LCD_SET_PROGRESS_MANUALLY

 #if HAS_CHARACTER_LCD && HAS_PRINT_PROGRESS
  //#define LCD_PROGRESS_BAR              // Show a progress bar on HD44780 LCDs for SD printing
@@ -880,23 +908,6 @@
  #endif
 #endif

-/**
- * LED Control Menu
- * Enable this feature to add LED Control to the LCD menu
- */
-//#define LED_CONTROL_MENU
-#if ENABLED(LED_CONTROL_MENU)
-  #define LED_COLOR_PRESETS                 // Enable the Preset Color menu option
-  #if ENABLED(LED_COLOR_PRESETS)
-    #define LED_USER_PRESET_RED        255  // User defined RED value
-    #define LED_USER_PRESET_GREEN      128  // User defined GREEN value
-    #define LED_USER_PRESET_BLUE         0  // User defined BLUE value
-    #define LED_USER_PRESET_WHITE      255  // User defined WHITE value
-    #define LED_USER_PRESET_BRIGHTNESS 255  // User defined intensity
-    //#define LED_USER_PRESET_STARTUP       // Have the printer display the user preset color on startup
-  #endif
-#endif // LED_CONTROL_MENU
-
 #if ENABLED(SDSUPPORT)

  // Some RAMPS and other boards don't detect when an SD card is inserted. You can work
@@ -917,7 +928,7 @@

  //#define MENU_ADDAUTOSTART               // Add a menu option to run auto#.g files

-  #define EVENT_GCODE_SD_STOP "G28XY"       // G-code to run on Stop Print (e.g., "G28XY" or "G27")
+  #define EVENT_GCODE_SD_STOP "G1X0Y0"       // G-code to run on Stop Print (e.g., "G28XY" or "G27")

  /**
   * Continue after Power-Loss (Creality3D)
@@ -927,12 +938,11 @@
   * an option on the LCD screen to continue the print from the last-known
   * point in the file.
   */
-  #if ENABLED(SKR13)
-    #define POWER_LOSS_RECOVERY
-  #endif
+  //#define POWER_LOSS_RECOVERY
  #if ENABLED(POWER_LOSS_RECOVERY)
    //#define POWER_LOSS_PIN         44 // Pin to detect power loss
    //#define POWER_LOSS_STATE     HIGH // State of pin indicating power loss
+    //#define POWER_LOSS_PULL           // Set pullup / pulldown as appropriate
    //#define POWER_LOSS_PURGE_LEN   20 // (mm) Length of filament to purge on resume
    //#define POWER_LOSS_RETRACT_LEN 10 // (mm) Length of filament to retract on fail. Requires backup power.

@@ -1012,17 +1022,31 @@
   * equivalent MAX3421E breakout board. The USB thumb drive will appear
   * to Marlin as an SD card.
   *
-   * The MAX3421E must be assigned the same pins as the SD card reader, with
+   * The MAX3421E can be assigned the same pins as the SD card reader, with
   * the following pin mapping:
   *
   *    SCLK, MOSI, MISO --> SCLK, MOSI, MISO
-   *    INT              --> SD_DETECT_PIN
+   *    INT              --> SD_DETECT_PIN [1]
   *    SS               --> SDSS
+   *
+   * [1] On AVR an interrupt-capable pin is best for UHS3 compatibility.
   */
  //#define USB_FLASH_DRIVE_SUPPORT
  #if ENABLED(USB_FLASH_DRIVE_SUPPORT)
-    #define USB_CS_PIN         SDSS
-    #define USB_INTR_PIN       SD_DETECT_PIN
+    #define USB_CS_PIN    SDSS
+    #define USB_INTR_PIN  SD_DETECT_PIN
+
+    /**
+     * USB Host Shield Library
+     *
+     * - UHS2 uses no interrupts and has been production-tested
+     *   on a LulzBot TAZ Pro with a 32-bit Archim board.
+     *
+     * - UHS3 is newer code with better USB compatibility. But it
+     *   is less tested and is known to interfere with Servos.
+     *   [1] This requires USB_INTR_PIN to be interrupt-capable.
+     */
+    //#define USE_UHS3_USB
  #endif

  /**
@@ -1044,8 +1068,7 @@
  // Add an optimized binary file transfer mode, initiated with 'M28 B1'
  //#define BINARY_FILE_TRANSFER

-
-  #ifdef TARGET_LPC1768
+  #if HAS_SDCARD_CONNECTION
    /**
     * Set this option to one of the following (or the board's defaults apply):
     *
@@ -1055,7 +1078,7 @@
     *
     * :[ 'LCD', 'ONBOARD', 'CUSTOM_CABLE' ]
     */
-    #define SDCARD_CONNECTION ONBOARD
+    //#define SDCARD_CONNECTION LCD
  #endif

 #endif // SDSUPPORT
@@ -1080,7 +1103,7 @@
 */
 #if HAS_GRAPHICAL_LCD
  // Show SD percentage next to the progress bar
-  //#define DOGM_SD_PERCENT
+  #define DOGM_SD_PERCENT

  // Enable to save many cycles by drawing a hollow frame on the Info Screen
  #define XYZ_HOLLOW_FRAME
@@ -1138,16 +1161,63 @@
  //#define STATUS_FAN_FRAMES 3       // :[0,1,2,3,4] Number of fan animation frames
  //#define STATUS_HEAT_PERCENT       // Show heating in a progress bar
  #define BOOT_MARLIN_LOGO_SMALL    // Show a smaller Marlin logo on the Boot Screen (saving 399 bytes of flash)
+  //#define BOOT_MARLIN_LOGO_ANIMATED // Animated Marlin logo. Costs ~‭3260 (or ~940) bytes of PROGMEM.

  // Frivolous Game Options
-  #if ENABLED(SKR13)
-    #define MARLIN_BRICKOUT
-    #define MARLIN_INVADERS
-    #define MARLIN_SNAKE
-  #endif
+  //#define MARLIN_BRICKOUT
+  //#define MARLIN_INVADERS
+  //#define MARLIN_SNAKE
+  //#define GAMES_EASTER_EGG          // Add extra blank lines above the "Games" sub-menu

 #endif // HAS_GRAPHICAL_LCD

+//
+// Lulzbot Touch UI
+//
+#if ENABLED(LULZBOT_TOUCH_UI)
+  // Display board used
+  //#define LCD_FTDI_VM800B35A        // FTDI 3.5" with FT800 (320x240)
+  //#define LCD_4DSYSTEMS_4DLCD_FT843 // 4D Systems 4.3" (480x272)
+  //#define LCD_HAOYU_FT800CB         // Haoyu with 4.3" or 5" (480x272)
+  //#define LCD_HAOYU_FT810CB         // Haoyu with 5" (800x480)
+  //#define LCD_ALEPHOBJECTS_CLCD_UI  // Aleph Objects Color LCD UI
+
+  // Correct the resolution if not using the stock TFT panel.
+  //#define TOUCH_UI_320x240
+  //#define TOUCH_UI_480x272
+  //#define TOUCH_UI_800x480
+
+  // Mappings for boards with a standard RepRapDiscount Display connector
+  //#define AO_EXP1_PINMAP    // AlephObjects CLCD UI EXP1 mapping
+  //#define AO_EXP2_PINMAP    // AlephObjects CLCD UI EXP2 mapping
+  //#define CR10_TFT_PINMAP   // Rudolph Riedel's CR10 pin mapping
+  //#define OTHER_PIN_LAYOUT  // Define pins manually below
+  #if ENABLED(OTHER_PIN_LAYOUT)
+    // The pins for CS and MOD_RESET (PD) must be chosen.
+    #define CLCD_MOD_RESET  9
+    #define CLCD_SPI_CS    10
+
+    // If using software SPI, specify pins for SCLK, MOSI, MISO
+    //#define CLCD_USE_SOFT_SPI
+    #if ENABLED(CLCD_USE_SOFT_SPI)
+      #define CLCD_SOFT_SPI_MOSI 11
+      #define CLCD_SOFT_SPI_MISO 12
+      #define CLCD_SOFT_SPI_SCLK 13
+    #endif
+  #endif
+
+  // Display Orientation. An inverted (i.e. upside-down) display
+  // is supported on the FT800. The FT810 and beyond also support
+  // portrait and mirrored orientations.
+  //#define TOUCH_UI_INVERTED
+  //#define TOUCH_UI_PORTRAIT
+  //#define TOUCH_UI_MIRRORED
+
+  // Use a numeric passcode for "Screen lock" keypad.
+  // (recommended for smaller displays)
+  //#define TOUCH_UI_PASSCODE
+#endif
+
 // @section safety

 /**
@@ -1178,7 +1248,7 @@
  //#define BABYSTEP_WITHOUT_HOMING
  //#define BABYSTEP_XY                     // Also enable X/Y Babystepping. Not supported on DELTA!
  #define BABYSTEP_INVERT_Z false           // Change if Z babysteps should go the other way
-  #define BABYSTEP_MULTIPLICATOR  10         // Babysteps are very small. Increase for faster motion.
+  #define BABYSTEP_MULTIPLICATOR  (Z_STEPSMM / 40)         // Babysteps are very small. Increase for faster motion.

  #define DOUBLECLICK_FOR_Z_BABYSTEPPING  // Double-click on the Status Screen for Z Babystepping.
  #if ENABLED(DOUBLECLICK_FOR_Z_BABYSTEPPING)
@@ -1196,7 +1266,7 @@
  #define BABYSTEP_ZPROBE_OFFSET          // Combine M851 Z and Babystepping
  #if ENABLED(BABYSTEP_ZPROBE_OFFSET)
    //#define BABYSTEP_HOTEND_Z_OFFSET      // For multiple hotends, babystep relative Z offsets
-    //#define BABYSTEP_ZPROBE_GFX_OVERLAY   // Enable graphical overlay on Z-offset editor
+    #define BABYSTEP_ZPROBE_GFX_OVERLAY   // Enable graphical overlay on Z-offset editor
  #endif
 #endif

@@ -1218,12 +1288,12 @@
 * See http://marlinfw.org/docs/features/lin_advance.html for full instructions.
 * Mention @Sebastianv650 on GitHub to alert the author of any issues.
 */
-#if DISABLED(SKR13)
+#if(DISABLED(E_2208))
  #define LIN_ADVANCE
 #endif
 #if ENABLED(LIN_ADVANCE)
  //#define EXTRA_LIN_ADVANCE_K // Enable for second linear advance constants
-  #define LIN_ADVANCE_K 0.0    // Unit: mm compression per 1mm/s extruder speed
+  #define LIN_ADVANCE_K 0.00    // Unit: mm compression per 1mm/s extruder speed
  //#define LA_DEBUG            // If enabled, this will generate debug information output over USB.
 #endif

@@ -1241,9 +1311,7 @@
 * Repeatedly attempt G29 leveling until it succeeds.
 * Stop after G29_MAX_RETRIES attempts.
 */
-#if DISABLED(UBL)
-  #define G29_RETRY_AND_RECOVER
-#endif
+//#define G29_RETRY_AND_RECOVER
 #if ENABLED(G29_RETRY_AND_RECOVER)
  #define G29_MAX_RETRIES 3
  #define G29_HALT_ON_FAILURE
@@ -1252,7 +1320,7 @@
   * between attempts, and after the maximum number of retries have been tried.
   */
  #define G29_SUCCESS_COMMANDS "M117 Bed leveling done."
-  #define G29_RECOVER_COMMANDS "M117 Probe failed.\nG28\n"
+  #define G29_RECOVER_COMMANDS "M117 Probe failed. Rewiping.\nG28\nG12 P0 S12 T0"
  #define G29_FAILURE_COMMANDS "M117 Bed leveling failed.\nG0 Z10\nM300 P25 S880\nM300 P50 S0\nM300 P25 S880\nM300 P50 S0\nM300 P25 S880\nM300 P50 S0\nG4 S1"

 #endif
@@ -1378,6 +1446,9 @@
  //#define SERIAL_XON_XOFF
 #endif

+// Add M575 G-code to change the baud rate
+//#define BAUD_RATE_GCODE
+
 #if ENABLED(SDSUPPORT)
  // Enable this option to collect and display the maximum
  // RX queue usage after transferring a file to SD.
@@ -1398,7 +1469,7 @@
 // Therefore some clients abort after 30 seconds in a timeout.
 // Some other clients start sending commands while receiving a 'wait'.
 // This "wait" is only sent when the buffer is empty. 1 second is a good value here.
-#define NO_TIMEOUTS 1000 // Milliseconds
+//#define NO_TIMEOUTS 1000 // Milliseconds

 // Some clients will have this feature soon. This could make the NO_TIMEOUTS unnecessary.
 #define ADVANCED_OK
@@ -1508,7 +1579,7 @@
                                                  // 0 to disable start loading and skip to fast load only
  #define FILAMENT_CHANGE_FAST_LOAD_FEEDRATE   6  // (mm/s) Load filament feedrate. This can be pretty fast.
  #define FILAMENT_CHANGE_FAST_LOAD_ACCEL     25  // (mm/s^2) Lower acceleration may allow a faster feedrate.
-  #define FILAMENT_CHANGE_FAST_LOAD_LENGTH     0  // (mm) Load length of filament, from extruder gear to nozzle.
+  #define FILAMENT_CHANGE_FAST_LOAD_LENGTH     2  // (mm) Load length of filament, from extruder gear to nozzle.
                                                  //   For Bowden, the full length of the tube and nozzle.
                                                  //   For direct drive, the full length of the nozzle.
  //#define ADVANCED_PAUSE_CONTINUOUS_PURGE       // Purge continuously up to the purge length until interrupted.
@@ -1517,7 +1588,7 @@
                                                  //   Set to 0 for manual extrusion.
                                                  //   Filament can be extruded repeatedly from the Filament Change menu
                                                  //   until extrusion is consistent, and to purge old filament.
-  #define ADVANCED_PAUSE_RESUME_PRIME          0  // (mm) Extra distance to prime nozzle after returning from park.
+  #define ADVANCED_PAUSE_RESUME_PRIME          2  // (mm) Extra distance to prime nozzle after returning from park.
  #define ADVANCED_PAUSE_FANS_PAUSE             // Turn off print-cooling fans while the machine is paused.

                                                  // Filament Unload does a Retract, Delay, and Purge first:
@@ -1526,11 +1597,11 @@
  #define FILAMENT_UNLOAD_PURGE_LENGTH         8  // (mm) An unretract is done, then this length is purged.

  #define PAUSE_PARK_NOZZLE_TIMEOUT           45  // (seconds) Time limit before the nozzle is turned off for safety.
-  #define FILAMENT_CHANGE_ALERT_BEEPS         10  // Number of alert beeps to play when a response is needed.
+  #define FILAMENT_CHANGE_ALERT_BEEPS         2  // Number of alert beeps to play when a response is needed.
  #define PAUSE_PARK_NO_STEPPER_TIMEOUT           // Enable for XYZ steppers to stay powered on during filament change.

  #define PARK_HEAD_ON_PAUSE                    // Park the nozzle during pause and filament change.
-  #define HOME_BEFORE_FILAMENT_CHANGE           // Ensure homing has been completed prior to parking for filament change
+  //#define HOME_BEFORE_FILAMENT_CHANGE           // Ensure homing has been completed prior to parking for filament change

  #define FILAMENT_LOAD_UNLOAD_GCODES           // Add M701/M702 Load/Unload G-codes, plus Load/Unload in the LCD Prepare menu.
  #define FILAMENT_UNLOAD_ALL_EXTRUDERS         // Allow M702 to unload all extruders above a minimum target temp (as set by M302)
@@ -1763,6 +1834,9 @@
   *       1 | HIGH | LOW
   *       2 | LOW  | HIGH
   *       3 | HIGH | HIGH
+   *
+   * Set *_SERIAL_TX_PIN and *_SERIAL_RX_PIN to match for all drivers
+   * on the same serial port, either here or in your board's pins file.
   */
  #define  X_SLAVE_ADDRESS 0
  #define  Y_SLAVE_ADDRESS 0
@@ -1809,7 +1883,7 @@
   * Define you own with
   * { <off_time[1..15]>, <hysteresis_end[-3..12]>, hysteresis_start[1..8] }
   */
-  #define CHOPPER_TIMING CHOPPER_DEFAULT_24V
+  #define CHOPPER_TIMING CHOPPER_DEFAULT_12V

  /**
   * Monitor Trinamic drivers for error conditions,
@@ -1837,7 +1911,7 @@
   * STEALTHCHOP_(XY|Z|E) must be enabled to use HYBRID_THRESHOLD.
   * M913 X/Y/Z/E to live tune the setting
   */
-  #define HYBRID_THRESHOLD
+  //#define HYBRID_THRESHOLD

  #define X_HYBRID_THRESHOLD     100  // [mm/s]
  #define X2_HYBRID_THRESHOLD    100
@@ -1854,17 +1928,25 @@
  #define E5_HYBRID_THRESHOLD     30

  /**
+   * Use StallGuard2 to home / probe X, Y, Z.
+   *
   * TMC2130, TMC2160, TMC2209, TMC2660, TMC5130, and TMC5160 only
-   * Use StallGuard2 to sense an obstacle and trigger an endstop.
   * Connect the stepper driver's DIAG1 pin to the X/Y endstop pin.
   * X, Y, and Z homing will always be done in spreadCycle mode.
   *
-   * X/Y/Z_STALL_SENSITIVITY is used for tuning the trigger sensitivity.
-   * Higher values make the system LESS sensitive.
-   * Lower value make the system MORE sensitive.
-   * Too low values can lead to false positives, while too high values will collide the axis without triggering.
-   * It is advised to set X/Y/Z_HOME_BUMP_MM to 0.
-   * M914 X/Y/Z to live tune the setting
+   * X/Y/Z_STALL_SENSITIVITY is used to tune the trigger sensitivity.
+   * Use M914 X Y Z to live-adjust the sensitivity.
+   *  Higher: LESS sensitive. (Too high => failure to trigger)
+   *   Lower: MORE sensitive. (Too low  => false positives)
+   *
+   * It is recommended to set [XYZ]_HOME_BUMP_MM to 0.
+   *
+   * SPI_ENDSTOPS  *** Beta feature! *** TMC2130 Only ***
+   * Poll the driver through SPI to determine load when homing.
+   * Removes the need for a wire from DIAG1 to an endstop pin.
+   *
+   * IMPROVE_HOMING_RELIABILITY tunes acceleration and jerk when
+   * homing and adds a guard period for endstop triggering.
   */
  //#define SENSORLESS_HOMING // StallGuard capable drivers only

@@ -1881,6 +1963,8 @@
    #define X_STALL_SENSITIVITY  8
    #define Y_STALL_SENSITIVITY  8
    //#define Z_STALL_SENSITIVITY  8
+    //#define SPI_ENDSTOPS              // TMC2130 only
+    //#define IMPROVE_HOMING_RELIABILITY
  #endif

  /**
@@ -2136,13 +2220,15 @@
 * See http://marlinfw.org/docs/configuration/laser_spindle.html for more config details.
 */
 //#define SPINDLE_FEATURE
-//#define LASER_FEATURE
+#if ENABLED(RAPTOR2)
+  #define LASER_FEATURE
+#endif
 #if EITHER(SPINDLE_FEATURE, LASER_FEATURE)
-  #define SPINDLE_LASER_ACTIVE_HIGH     false  // Set to "true" if the on/off function is active HIGH
-  #define SPINDLE_LASER_PWM             true   // Set to "true" if your controller supports setting the speed/power
+  #define SPINDLE_LASER_ACTIVE_HIGH     true  // Set to "true" if the on/off function is active HIGH
+  #define SPINDLE_LASER_PWM             false   // Set to "true" if your controller supports setting the speed/power
  #define SPINDLE_LASER_PWM_INVERT      true   // Set to "true" if the speed/power goes up when you want it to go slower
-  #define SPINDLE_LASER_POWERUP_DELAY   5000   // (ms) Delay to allow the spindle/laser to come up to speed/power
-  #define SPINDLE_LASER_POWERDOWN_DELAY 5000   // (ms) Delay to allow the spindle to stop
+  #define SPINDLE_LASER_POWERUP_DELAY   1   // (ms) Delay to allow the spindle/laser to come up to speed/power
+  #define SPINDLE_LASER_POWERDOWN_DELAY 1   // (ms) Delay to allow the spindle to stop

  #if ENABLED(SPINDLE_FEATURE)
    //#define SPINDLE_CHANGE_DIR               // Enable if your spindle controller can change spindle direction
@@ -2235,6 +2321,13 @@
 */
 #define EXTENDED_CAPABILITIES_REPORT

+/**
+ * Expected Printer Check
+ * Add the M16 G-code to compare a string to the MACHINE_NAME.
+ * M16 with a non-matching string causes the printer to halt.
+ */
+//#define EXPECTED_PRINTER_CHECK
+
 /**
 * Disable all Volumetric extrusion options
 */
@@ -2289,6 +2382,13 @@
  //#define VARIABLE_G0_FEEDRATE // The G0 feedrate is set by F in G0 motion mode
 #endif

+/**
+ * Startup commands
+ *
+ * Execute certain G-code commands immediately after power-on.
+ */
+//#define STARTUP_COMMANDS "M17 Z"
+
 /**
 * G-code Macros
 *
@@ -2304,37 +2404,32 @@
 /**
 * User-defined menu items that execute custom GCode
 */
+
 #define CUSTOM_USER_MENUS
 #if ENABLED(CUSTOM_USER_MENUS)
  //#define USER_SCRIPT_DONE "M117 User Script Done"
+  #define CUSTOM_USER_MENU_TITLE "Leveling Tools"
  #define USER_SCRIPT_AUDIBLE_FEEDBACK
  #define USER_SCRIPT_RETURN  // Return to status screen after a script
-  #define CUSTOM_USER_MENU_TITLE "Leveling Tools"

-  #define CommBedTmp "65"
-  #if ENABLED(DUAL_Z)
-    #define ALIGN_CMD "G34I3\n"
-  #else
-    #define ALIGN_CMD ""
-  #endif
  #define USER_DESC_1 "Setup"
-  #if (ENABLED(UBL))
-    #define USER_GCODE_1 "M190S" CommBedTmp"\nG28\n" ALIGN_CMD "G29P1\nG29S1\nG29S0\n G29F0.0\nG29A\nG28\nM109S225\nG1X150Y150\nG1Z0\nM500\nM400\nM77\nM117 Set Z Offset"
+  #if ENABLED(UBL)
+    #define USER_GCODE_1 "M190S75\nG28\nG29P1\nG29P3\nM109S215\nG29S1\nG29S0\nG29F0.0\nG29A\nG28\nG1X150Y150F5000\nG1Z0\nM500\nM400\nM117 Set Z Offset"
  #else
-    #define USER_GCODE_1 "M190S" CommBedTmp"\n M117 Probing....\nM104S225\nG28\n" ALIGN_CMD "G29\nM400\nG28\nM420S1\nM109S225\nG1X100Y100\nG1Z0\nM500\nM400\nM77\nM117 Set Z Offset"
+    #define USER_GCODE_1 "M190S75\nG28\nG29\nM400\nM109S215\nG28\nM420S1\nG1X100Y100F5000\nG1Z0\nM500\nM117 Set Z Offset"
  #endif

  #define USER_DESC_2 "PID Tune"
-  #define USER_GCODE_2 "M106 S128 \n M303 C8 S225 E1 U \n M500 \n M117 PID Tune Done"
+  #define USER_GCODE_2 "G28\nG1X200Y200Z5\nM106S128\nM303C8S215E1U\nM500\nM117 PID Tune Done"

  #define USER_DESC_3 "Prep for Z Adjust"
-  #define USER_GCODE_3 "M190 S" CommBedTmp" \n M104 S235 \n G28 \n G29 L1 \n G1 X100 Y 100 \n G1 Z0"
+  #define USER_GCODE_3 "M190S75\nM104S215\nG28\nG29L1\nG1 X100Y100F5000\nG1Z0"

  #define USER_DESC_4 "Store Settings"
  #define USER_GCODE_4 "M500\nM117 Settings Stored"

-  //#define USER_DESC_5 "Run Mesh Validation"
-  //#define USER_GCODE_5 "G26"
+  #define USER_DESC_5 "Run Mesh Validation"
+  #define USER_GCODE_5 "G26"
 #endif

 /**
@@ -2458,6 +2553,7 @@
  #define MAX7219_ROTATE       0   // Rotate the display clockwise (in multiples of +/- 90°)
                                   // connector at:  right=0   bottom=-90  top=90  left=180
  //#define MAX7219_REVERSE_ORDER  // The individual LED matrix units may be in reversed order
+  //#define MAX7219_SIDE_BY_SIDE   // Big chip+matrix boards can be chained side-by-side

  /**
   * Sample debug features
@@ -248,75 +248,68 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1140)
 # Z-Bolt X Series
 else ifeq ($(HARDWARE_MOTHERBOARD),1141)

-#
-# RAMBo and derivatives
-#
-
-# Rambo
-else ifeq ($(HARDWARE_MOTHERBOARD),1200)
-# Mini-Rambo
-else ifeq ($(HARDWARE_MOTHERBOARD),1201)
-# Mini-Rambo 1.0a
-else ifeq ($(HARDWARE_MOTHERBOARD),1202)
-# Einsy Rambo
-else ifeq ($(HARDWARE_MOTHERBOARD),1203)
-# Einsy Retro
-else ifeq ($(HARDWARE_MOTHERBOARD),1204)
-# abee Scoovo X9H
-else ifeq ($(HARDWARE_MOTHERBOARD),1205)
-
 #
 # Other ATmega1280, ATmega2560
 #

 # Cartesio CN Controls V11
-else ifeq ($(HARDWARE_MOTHERBOARD),1300)
+else ifeq ($(HARDWARE_MOTHERBOARD),1200)
 # Cartesio CN Controls V12
-else ifeq ($(HARDWARE_MOTHERBOARD),1301)
+else ifeq ($(HARDWARE_MOTHERBOARD),1201)
 # Cheaptronic v1.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1302)
+else ifeq ($(HARDWARE_MOTHERBOARD),1202)
 # Cheaptronic v2.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1303)
+else ifeq ($(HARDWARE_MOTHERBOARD),1203)
 # Makerbot Mightyboard Revision E
-else ifeq ($(HARDWARE_MOTHERBOARD),1304)
+else ifeq ($(HARDWARE_MOTHERBOARD),1204)
 # Megatronics
-else ifeq ($(HARDWARE_MOTHERBOARD),1305)
+else ifeq ($(HARDWARE_MOTHERBOARD),1205)
 # Megatronics v2.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1306)
+else ifeq ($(HARDWARE_MOTHERBOARD),1206)
 # Megatronics v3.0
-else ifeq ($(HARDWARE_MOTHERBOARD),1307)
+else ifeq ($(HARDWARE_MOTHERBOARD),1207)
 # Megatronics v3.1
-else ifeq ($(HARDWARE_MOTHERBOARD),1308)
+else ifeq ($(HARDWARE_MOTHERBOARD),1208)
 # Megatronics v3.2
-else ifeq ($(HARDWARE_MOTHERBOARD),1309)
+else ifeq ($(HARDWARE_MOTHERBOARD),1209)
+# Rambo
+else ifeq ($(HARDWARE_MOTHERBOARD),1210)
+# Mini-Rambo
+else ifeq ($(HARDWARE_MOTHERBOARD),1211)
+# Mini-Rambo 1.0a
+else ifeq ($(HARDWARE_MOTHERBOARD),1212)
+# Einsy Rambo
+else ifeq ($(HARDWARE_MOTHERBOARD),1213)
+# Einsy Retro
+else ifeq ($(HARDWARE_MOTHERBOARD),1214)
 # Elefu Ra Board (v3)
-else ifeq ($(HARDWARE_MOTHERBOARD),1310)
+else ifeq ($(HARDWARE_MOTHERBOARD),1215)
 # Leapfrog
-else ifeq ($(HARDWARE_MOTHERBOARD),1311)
+else ifeq ($(HARDWARE_MOTHERBOARD),1216)
 # Mega controller
-else ifeq ($(HARDWARE_MOTHERBOARD),1312)
+else ifeq ($(HARDWARE_MOTHERBOARD),1217)
+# abee Scoovo X9H
+else ifeq ($(HARDWARE_MOTHERBOARD),1218)
 # Geeetech GT2560 Rev B for Mecreator2
-else ifeq ($(HARDWARE_MOTHERBOARD),1313)
+else ifeq ($(HARDWARE_MOTHERBOARD),1219)
 # Geeetech GT2560 Rev. A
-else ifeq ($(HARDWARE_MOTHERBOARD),1314)
+else ifeq ($(HARDWARE_MOTHERBOARD),1220)
 # Geeetech GT2560 Rev. A+ (with auto level probe)
-else ifeq ($(HARDWARE_MOTHERBOARD),1315)
+else ifeq ($(HARDWARE_MOTHERBOARD),1221)
 # Geeetech GT2560 Rev B for A10(M/D)
-else ifeq ($(HARDWARE_MOTHERBOARD),1316)
+else ifeq ($(HARDWARE_MOTHERBOARD),1222)
 # Geeetech GT2560 Rev B for A20(M/D)
-else ifeq ($(HARDWARE_MOTHERBOARD),1317)
+else ifeq ($(HARDWARE_MOTHERBOARD),1223)
 # Einstart retrofit
-else ifeq ($(HARDWARE_MOTHERBOARD),1318)
-# Wanhao 0ne+ i3 Mini
-else ifeq ($(HARDWARE_MOTHERBOARD),1319)
+else ifeq ($(HARDWARE_MOTHERBOARD),1224)

 #
 # ATmega1281, ATmega2561
 #

-else ifeq ($(HARDWARE_MOTHERBOARD),1400)
+else ifeq ($(HARDWARE_MOTHERBOARD),1300)
  MCU              ?= atmega1281
-else ifeq ($(HARDWARE_MOTHERBOARD),1410)
+else ifeq ($(HARDWARE_MOTHERBOARD),1310)
  MCU              ?= atmega1281

 #
@@ -324,43 +317,43 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1410)
 #

 # Sanguinololu < 1.2
-else ifeq ($(HARDWARE_MOTHERBOARD),1500)
+else ifeq ($(HARDWARE_MOTHERBOARD),1400)
  HARDWARE_VARIANT ?= Sanguino
  MCU              ?= atmega644p
 # Sanguinololu 1.2 and above
-else ifeq ($(HARDWARE_MOTHERBOARD),1501)
+else ifeq ($(HARDWARE_MOTHERBOARD),1401)
  HARDWARE_VARIANT ?= Sanguino
  MCU              ?= atmega644p
 # Melzi
-else ifeq ($(HARDWARE_MOTHERBOARD),1502)
+else ifeq ($(HARDWARE_MOTHERBOARD),1402)
  HARDWARE_VARIANT ?= Sanguino
  MCU              ?= atmega644p
 # Melzi with ATmega1284 (MaKr3d version)
-else ifeq ($(HARDWARE_MOTHERBOARD),1503)
+else ifeq ($(HARDWARE_MOTHERBOARD),1403)
  HARDWARE_VARIANT ?= Sanguino
  MCU              ?= atmega1284p
 # Melzi Creality3D board (for CR-10 etc)
-else ifeq ($(HARDWARE_MOTHERBOARD),1504)
+else ifeq ($(HARDWARE_MOTHERBOARD),1404)
  HARDWARE_VARIANT ?= Sanguino
  MCU              ?= atmega1284p
 # Melzi Malyan M150 board
-else ifeq ($(HARDWARE_MOTHERBOARD),1505)
+else ifeq ($(HARDWARE_MOTHERBOARD),1405)
  HARDWARE_VARIANT ?= Sanguino
  MCU              ?= atmega1284p
 # Tronxy X5S
-else ifeq ($(HARDWARE_MOTHERBOARD),1506)
+else ifeq ($(HARDWARE_MOTHERBOARD),1406)
  HARDWARE_VARIANT ?= Sanguino
  MCU              ?= atmega1284p
 # STB V1.1
-else ifeq ($(HARDWARE_MOTHERBOARD),1507)
+else ifeq ($(HARDWARE_MOTHERBOARD),1407)
  HARDWARE_VARIANT ?= Sanguino
  MCU              ?= atmega1284p
 # Azteeg X1
-else ifeq ($(HARDWARE_MOTHERBOARD),1508)
+else ifeq ($(HARDWARE_MOTHERBOARD),1408)
  HARDWARE_VARIANT ?= Sanguino
  MCU              ?= atmega1284p
 # Anet 1.0 (Melzi clone)
-else ifeq ($(HARDWARE_MOTHERBOARD),1509)
+else ifeq ($(HARDWARE_MOTHERBOARD),1409)
  HARDWARE_VARIANT ?= Sanguino
  MCU              ?= atmega1284p

@@ -369,51 +362,51 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1509)
 #

 # Gen3 Monolithic Electronics
-else ifeq ($(HARDWARE_MOTHERBOARD),1600)
+else ifeq ($(HARDWARE_MOTHERBOARD),1500)
  HARDWARE_VARIANT ?= Sanguino
  MCU              ?= atmega644p
 # Gen3+
-else ifeq ($(HARDWARE_MOTHERBOARD),1601)
+else ifeq ($(HARDWARE_MOTHERBOARD),1501)
  HARDWARE_VARIANT ?= Sanguino
  MCU              ?= atmega644p
 # Gen6
-else ifeq ($(HARDWARE_MOTHERBOARD),1602)
+else ifeq ($(HARDWARE_MOTHERBOARD),1502)
  HARDWARE_VARIANT ?= Gen6
  MCU              ?= atmega644p
 # Gen6 deluxe
-else ifeq ($(HARDWARE_MOTHERBOARD),1603)
+else ifeq ($(HARDWARE_MOTHERBOARD),1503)
  HARDWARE_VARIANT ?= Gen6
  MCU              ?= atmega644p
 # Gen7 custom (Alfons3 Version)
-else ifeq ($(HARDWARE_MOTHERBOARD),1604)
+else ifeq ($(HARDWARE_MOTHERBOARD),1504)
  HARDWARE_VARIANT ?= Gen7
  MCU              ?= atmega644
  F_CPU            ?= 20000000
 # Gen7 v1.1, v1.2
-else ifeq ($(HARDWARE_MOTHERBOARD),1605)
+else ifeq ($(HARDWARE_MOTHERBOARD),1505)
  HARDWARE_VARIANT ?= Gen7
  MCU              ?= atmega644p
  F_CPU            ?= 20000000
 # Gen7 v1.3
-else ifeq ($(HARDWARE_MOTHERBOARD),1606)
+else ifeq ($(HARDWARE_MOTHERBOARD),1506)
  HARDWARE_VARIANT ?= Gen7
  MCU              ?= atmega644p
  F_CPU            ?= 20000000
 # Gen7 v1.4
-else ifeq ($(HARDWARE_MOTHERBOARD),1607)
+else ifeq ($(HARDWARE_MOTHERBOARD),1507)
  HARDWARE_VARIANT ?= Gen7
  MCU              ?= atmega1284p
  F_CPU            ?= 20000000
 # Alpha OMCA board
-else ifeq ($(HARDWARE_MOTHERBOARD),1608)
+else ifeq ($(HARDWARE_MOTHERBOARD),1508)
  HARDWARE_VARIANT ?= SanguinoA
  MCU              ?= atmega644
 # Final OMCA board
-else ifeq ($(HARDWARE_MOTHERBOARD),1609)
+else ifeq ($(HARDWARE_MOTHERBOARD),1509)
  HARDWARE_VARIANT ?= Sanguino
  MCU              ?= atmega644p
 # Sethi 3D_1
-else ifeq ($(HARDWARE_MOTHERBOARD),1610)
+else ifeq ($(HARDWARE_MOTHERBOARD),1510)
  HARDWARE_VARIANT ?= Sanguino
  MCU              ?= atmega644p

@@ -422,35 +415,35 @@ else ifeq ($(HARDWARE_MOTHERBOARD),1610)
 #

 # Teensylu
-else ifeq ($(HARDWARE_MOTHERBOARD),1700)
+else ifeq ($(HARDWARE_MOTHERBOARD),1600)
  HARDWARE_VARIANT ?= Teensy
  MCU              ?= at90usb1286
 # Printrboard (AT90USB1286)
-else ifeq ($(HARDWARE_MOTHERBOARD),1701)
+else ifeq ($(HARDWARE_MOTHERBOARD),1601)
  HARDWARE_VARIANT ?= Teensy
  MCU              ?= at90usb1286
 # Printrboard Revision F (AT90USB1286)
-else ifeq ($(HARDWARE_MOTHERBOARD),1702)
+else ifeq ($(HARDWARE_MOTHERBOARD),1602)
  HARDWARE_VARIANT ?= Teensy
  MCU              ?= at90usb1286
 # Brainwave (AT90USB646)
-else ifeq ($(HARDWARE_MOTHERBOARD),1703)
+else ifeq ($(HARDWARE_MOTHERBOARD),1603)
  HARDWARE_VARIANT ?= Teensy
  MCU              ?= at90usb646
 # Brainwave Pro (AT90USB1286)
-else ifeq ($(HARDWARE_MOTHERBOARD),1704)
+else ifeq ($(HARDWARE_MOTHERBOARD),1604)
  HARDWARE_VARIANT ?= Teensy
  MCU              ?= at90usb1286
 # SAV Mk-I (AT90USB1286)
-else ifeq ($(HARDWARE_MOTHERBOARD),1705)
+else ifeq ($(HARDWARE_MOTHERBOARD),1605)
  HARDWARE_VARIANT ?= Teensy
  MCU              ?= at90usb1286
 # Teensy++2.0 (AT90USB1286)
-else ifeq ($(HARDWARE_MOTHERBOARD),1706)
+else ifeq ($(HARDWARE_MOTHERBOARD),1606)
  HARDWARE_VARIANT ?= Teensy
  MCU              ?= at90usb1286
 # 5DPrint D8 Driver Board
-else ifeq ($(HARDWARE_MOTHERBOARD),1707)
+else ifeq ($(HARDWARE_MOTHERBOARD),1607)
  HARDWARE_VARIANT ?= Teensy
  MCU              ?= at90usb1286

@@ -29,65 +29,78 @@
 *  - 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
+#define CUSTOM_BOOTSCREEN_BMPHEIGHT 64

 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
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFD, 0x55, 0x55, 0x55, 0x55, 0x55, 0x5F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFD, 0x00, 0x00, 0x07, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFE, 0x07, 0xC0, 0x05, 0x55, 0x55, 0x55, 0x55, 0x55, 0x5F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFC, 0x0A, 0x20, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFE, 0x14, 0x10, 0x05, 0x00, 0x00, 0x07, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFC, 0x28, 0x08, 0x06, 0x07, 0xC0, 0x05, 0x55, 0x55, 0x55, 0x55, 0x55, 0x5F, 0xFF, 0xFF, 0xFF,
+0xFE, 0x54, 0x04, 0x04, 0x0A, 0x20, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xFF, 0xFF, 0xFF,
+0xFC, 0x60, 0x04, 0x06, 0x14, 0x10, 0x05, 0x00, 0x00, 0x07, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFE, 0x50, 0x04, 0x04, 0x28, 0x08, 0x06, 0x07, 0xC0, 0x05, 0x55, 0x55, 0x55, 0x55, 0x55, 0x5F,
+0xFC, 0x60, 0x04, 0x06, 0x54, 0x04, 0x04, 0x0A, 0x20, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F,
+0xFE, 0x54, 0x04, 0x1C, 0x60, 0x04, 0x06, 0x14, 0x10, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F,
+0xFC, 0x28, 0x08, 0x2E, 0x50, 0x04, 0x04, 0x28, 0x08, 0x06, 0x07, 0xC0, 0x00, 0x01, 0xF0, 0x3F,
+0xFE, 0x14, 0x10, 0x54, 0x60, 0x04, 0x06, 0x54, 0x04, 0x04, 0x0A, 0x20, 0x00, 0x02, 0x08, 0x1F,
+0xFC, 0x0A, 0x20, 0x66, 0x54, 0x04, 0x1C, 0x60, 0x04, 0x06, 0x14, 0x10, 0x00, 0x05, 0x04, 0x3F,
+0xFE, 0x07, 0xC0, 0x54, 0x28, 0x08, 0x2E, 0x50, 0x04, 0x04, 0x28, 0x08, 0x00, 0x0A, 0x02, 0x1F,
+0xFC, 0x00, 0x00, 0x2E, 0x14, 0x10, 0x54, 0x60, 0x04, 0x06, 0x54, 0x04, 0x00, 0x15, 0x01, 0x3F,
+0xFE, 0x00, 0x00, 0x1C, 0x0A, 0x20, 0x66, 0x54, 0x04, 0x1C, 0x60, 0x04, 0x00, 0x18, 0x01, 0x1F,
+0xFC, 0x00, 0x00, 0x06, 0x07, 0xC0, 0x54, 0x28, 0x08, 0x2E, 0x50, 0x04, 0x00, 0x14, 0x01, 0x3F,
+0xFE, 0x00, 0x00, 0x04, 0x00, 0x00, 0x2E, 0x14, 0x10, 0x54, 0x60, 0x04, 0x00, 0x18, 0x01, 0x1F,
+0xFC, 0xFF, 0xFF, 0xFE, 0x00, 0x00, 0x1C, 0x0A, 0x20, 0x66, 0x54, 0x04, 0x1C, 0x15, 0x01, 0x3F,
+0xFE, 0xD5, 0x55, 0x54, 0x00, 0x00, 0x06, 0x07, 0xC0, 0x54, 0x28, 0x08, 0x2A, 0x0A, 0x02, 0x1F,
+0xFC, 0x84, 0x10, 0x46, 0x00, 0x00, 0x04, 0x00, 0x00, 0x2E, 0x14, 0x10, 0x51, 0x05, 0x04, 0x3F,
+0xFE, 0xC4, 0x10, 0x44, 0xFF, 0xFF, 0xFE, 0x00, 0x00, 0x1C, 0x0A, 0x20, 0x61, 0x02, 0x88, 0x1F,
+0xFC, 0x84, 0x10, 0x46, 0xD5, 0x55, 0x54, 0x00, 0x00, 0x06, 0x07, 0xC0, 0x51, 0x01, 0xF0, 0x3F,
+0xFE, 0x84, 0x10, 0x44, 0x84, 0x10, 0x46, 0x00, 0x00, 0x04, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x1F,
+0xFC, 0xC4, 0x10, 0x46, 0xC4, 0x10, 0x44, 0xFF, 0xFF, 0xFE, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x3F,
+0xFE, 0x84, 0x10, 0x44, 0x84, 0x10, 0x46, 0xD5, 0x55, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F,
+0xFC, 0xD5, 0x55, 0x56, 0x84, 0x10, 0x44, 0x84, 0x10, 0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F,
+0xFC, 0xFF, 0xFF, 0xFC, 0xC4, 0x10, 0x46, 0xC4, 0x10, 0x44, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x9F,
+0xFE, 0x00, 0x00, 0x06, 0x84, 0x10, 0x44, 0x84, 0x10, 0x46, 0xD5, 0x55, 0x55, 0x55, 0x55, 0xBF,
+0xFD, 0x55, 0x55, 0x54, 0xD5, 0x55, 0x56, 0x84, 0x10, 0x44, 0x84, 0x10, 0x41, 0x04, 0x10, 0x9F,
+0xFF, 0xFF, 0xFF, 0xFC, 0xFF, 0xFF, 0xFC, 0xC4, 0x10, 0x46, 0xC4, 0x10, 0x41, 0x04, 0x11, 0xBF,
+0xFF, 0xFF, 0xFF, 0xFE, 0x00, 0x00, 0x06, 0x84, 0x10, 0x44, 0x84, 0x10, 0x41, 0x04, 0x10, 0x9F,
+0xFF, 0xFF, 0xFF, 0xFD, 0x55, 0x55, 0x54, 0xD5, 0x55, 0x56, 0x84, 0x10, 0x41, 0x04, 0x10, 0x9F,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xFF, 0xFF, 0xFC, 0xC4, 0x10, 0x41, 0x04, 0x11, 0xBF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0x00, 0x00, 0x06, 0x84, 0x10, 0x41, 0x04, 0x10, 0x9F,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFD, 0x55, 0x55, 0x54, 0xD5, 0x55, 0x55, 0x55, 0x55, 0xBF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x9F,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFD, 0x55, 0x55, 0x55, 0x55, 0x55, 0x5F,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xE0, 0x2E, 0xFB, 0x7D, 0xFB, 0xFB, 0xCF, 0xC1, 0xDF, 0xBB, 0x3E, 0xC0, 0xE1, 0xFE, 0x3C, 0x1F,
+0xFD, 0xEE, 0x7B, 0x39, 0xF9, 0xF3, 0xCF, 0x9E, 0xDF, 0xBB, 0x3E, 0xDF, 0xDE, 0xFC, 0xDD, 0xE7,
+0xFD, 0xEE, 0x3B, 0xBB, 0xF9, 0xEB, 0xD7, 0xBF, 0x5F, 0xBB, 0x5E, 0xDF, 0xDE, 0xFD, 0xED, 0xF7,
+0xFD, 0xEE, 0xBB, 0xD3, 0xFA, 0xEB, 0xB7, 0x3F, 0xDF, 0xBB, 0x4E, 0xDF, 0xDF, 0xFF, 0xCD, 0xF3,
+0xFD, 0xEE, 0xDB, 0xC7, 0xFA, 0xEB, 0xBB, 0x7F, 0xC0, 0x3B, 0x6E, 0xC0, 0xE3, 0xFF, 0x1D, 0xF3,
+0xFD, 0xEE, 0xCB, 0xEF, 0xFA, 0xDB, 0xBB, 0x7F, 0xDF, 0xBB, 0x66, 0xDF, 0xF8, 0xFF, 0xCD, 0xF3,
+0xFD, 0xEE, 0xEB, 0xEF, 0xFB, 0x5B, 0x03, 0x3F, 0x5F, 0xBB, 0x76, 0xDF, 0xFE, 0x7F, 0xED, 0xF3,
+0xFD, 0xEE, 0xF3, 0xEF, 0xFB, 0x5B, 0x79, 0xBE, 0xDF, 0xBB, 0x7A, 0xDF, 0xDE, 0x7D, 0xED, 0xF7,
+0xFD, 0xEE, 0xF3, 0xEF, 0xFB, 0xBA, 0xFD, 0x9E, 0xDF, 0xBB, 0x7C, 0xDF, 0xDE, 0xFD, 0xCD, 0xE7,
+0xFD, 0xEE, 0xFB, 0xEF, 0xFB, 0xBA, 0xFD, 0xC1, 0xDF, 0xBB, 0x7E, 0xC0, 0xE0, 0xFE, 0x1C, 0x1F,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
 };
+
+
+
@@ -1,36 +0,0 @@
-
-This directory is intended for the project specific (private) libraries.
-PlatformIO will compile them to static libraries and link to executable file.
-
-The source code of each library should be placed in separate directory, like
-"lib/private_lib/[here are source files]".
-
-For example, see how can be organized `Foo` and `Bar` libraries:
-
-|--lib
-|  |--Bar
-|  |  |--docs
-|  |  |--examples
-|  |  |--src
-|  |     |- Bar.c
-|  |     |- Bar.h
-|  |--Foo
-|  |  |- Foo.c
-|  |  |- Foo.h
-|  |- readme.txt --> THIS FILE
-|- platformio.ini
-|--src
-   |- main.c
-
-Then in `src/main.c` you should use:
-
-#include <Foo.h>
-#include <Bar.h>
-
-// rest H/C/CPP code
-
-PlatformIO will find your libraries automatically, configure preprocessor's
-include paths and build them.
-
-More information about PlatformIO Library Dependency Finder
- http://docs.platformio.org/page/librarymanager/ldf.html
@@ -114,9 +114,12 @@ void HAL_init(void);
 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(void);
 }
+#pragma GCC diagnostic pop

 // timers
 #define HAL_TIMER_RATE          ((F_CPU) / 8)    // i.e., 2MHz or 2.5MHz
@@ -53,8 +53,8 @@
 * --------------------
 */

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

 // Say which 16 bit timers can be used and in what order
 #if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
@@ -31,12 +31,12 @@

 #ifdef ARDUINO_ARCH_SAM

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

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

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

 #define EEPROMSize     4096
 #define PagesPerGroup   128
@@ -156,12 +156,16 @@ void HAL_init(void);
 // Utility functions
 //
 void _delay_ms(const int delay);
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-function"
 int freeMemory(void);
+#pragma GCC diagnostic pop

 #ifdef __cplusplus
  extern "C" {
 #endif
-char *dtostrf (double __val, signed char __width, unsigned char __prec, char *__s);
+char *dtostrf(double __val, signed char __width, unsigned char __prec, char *__s);
 #ifdef __cplusplus
  }
 #endif
@@ -36,8 +36,8 @@
 //!#define _useTimer4
 #define _useTimer5

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

 /*
  TC0, chan 0 => TC0_Handler
@@ -5,6 +5,8 @@
 * Based on Sprinter and grbl.
 * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
 *
+ * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
+ *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
@@ -23,6 +23,7 @@

 #include "../../../inc/MarlinConfigPre.h"
 #include "../../shared/Marduino.h"
+#include <U8glib.h>

 void u8g_SetPIOutput_DUE(u8g_t *u8g, uint8_t pin_index);
 void u8g_SetPILevel_DUE(u8g_t *u8g, uint8_t pin_index, uint8_t level);
@@ -70,7 +70,7 @@
  const uint32_t mask = MASK(DIO ## IO ## _PIN); \
  if (V) port->PIO_SODR = mask; \
  else port->PIO_CODR = mask; \
-} while(0)
+}while(0)

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

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


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

 /* No operation */
-#if defined(__ICCARM__)
+#ifdef __ICCARM__
 #define nop()               __no_operation()
 #elif defined(__GNUC__)
 #define nop()               (__NOP())
@@ -92,7 +92,10 @@ uint8_t HAL_get_reset_source(void);

 void _delay_ms(int delay);

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

 void analogWrite(pin_t pin, int value);

@@ -81,7 +81,10 @@ extern HalSerial usb_serial;
 inline void HAL_init(void) { }

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

 // SPI: Extended functions which take a channel number (hardware SPI only)
 /** Write single byte to specified SPI channel */
@@ -142,10 +142,10 @@ public:
  void print_bin(uint32_t value, uint8_t num_digits) {
    uint32_t mask = 1 << (num_digits -1);
    for (uint8_t i = 0; i < num_digits; i++) {
-      if (!(i % 4) && i)    write(' ');
-      if (!(i % 16)  && i)  write(' ');
-      if (value & mask)     write('1');
-      else                  write('0');
+      if (!(i %  4) && i) write(' ');
+      if (!(i % 16) && i) write(' ');
+      if (value & mask)   write('1');
+      else                write('0');
      value <<= 1;
    }
  }
@@ -61,7 +61,7 @@ bool PersistentStore::access_finish() {
  return true;
 }

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

  for (std::size_t i = 0; i < size; i++) {
@@ -111,7 +111,10 @@ extern "C" volatile uint32_t _millis;
 //
 // Utility functions
 //
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-function"
 int freeMemory(void);
+#pragma GCC diagnostic pop

 //
 // SPI: Extended functions taking a channel number (Hardware SPI only)
@@ -146,11 +149,6 @@ using FilteredADC = LPC176x::ADC<ADC_LOWPASS_K_VALUE, ADC_MEDIAN_FILTER_SIZE>;
 #define HAL_READ_ADC()         FilteredADC::get_result()
 #define HAL_ADC_READY()        FilteredADC::finished_conversion()

-// A grace period to allow ADC readings to stabilize, preventing false alarms
-#ifndef THERMAL_PROTECTION_GRACE_PERIOD
-  #define THERMAL_PROTECTION_GRACE_PERIOD 1000
-#endif
-
 // Parse a G-code word into a pin index
 int16_t PARSED_PIN_INDEX(const char code, const int16_t dval);
 // P0.6 thru P0.9 are for the onboard SD card
@@ -125,7 +125,7 @@ static void debug_rw(const bool write, int &pos, const uint8_t *value, const siz
 //    FR_INVALID_PARAMETER     /* (19) Given parameter is invalid */
 //  } FRESULT;

-bool PersistentStore::write_data(int &pos, const uint8_t *value, const size_t size, uint16_t *crc) {
+bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
  if (!eeprom_file_open) return true;
  FRESULT s;
  UINT bytes_written = 0;
@@ -17,7 +17,7 @@ def print_error(e):
    print('\nUnable to find destination disk (' + e + ')\n' \
          'Please select it in platformio.ini using the upload_port keyword ' \
          '(https://docs.platformio.org/en/latest/projectconf/section_env_upload.html) ' \
-          'or copy the firmware (.pioenvs/' + env.get('PIOENV') + '/firmware.bin) manually to the appropriate disk\n')
+          'or copy the firmware (.pio/build/' + env.get('PIOENV') + '/firmware.bin) manually to the appropriate disk\n')

 try:
    if current_OS == 'Windows':
@@ -1,13 +1,37 @@
+/**
+ * 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 TARGET_LPC1768
+
 #include "../../inc/MarlinConfigPre.h"

 #if ENABLED(EMERGENCY_PARSER)
-  #include "../../feature/emergency_parser.h"
-  EmergencyParser::State emergency_state;
-  bool CDC_RecvCallback(const char buffer) {
-    emergency_parser.update(emergency_state, buffer);
-    return true;
-  }
-#endif // ENABLED(EMERGENCY_PARSER)

+#include "../../feature/emergency_parser.h"
+EmergencyParser::State emergency_state;
+bool CDC_RecvCallback(const char buffer) {
+  emergency_parser.update(emergency_state, buffer);
+  return true;
+}
+
+#endif // EMERGENCY_PARSER
 #endif // TARGET_LPC1768
@@ -1,7 +1,7 @@
 /**
 * Marlin 3D Printer Firmware
 *
- * Copyright (C) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * This program is free software: you can redistribute it and/or modify
@@ -59,12 +59,12 @@
 #else
  #define GET_TEMP_5_ADC()          -1
 #endif
-#if HAS_HEATED_BED
+#if HAS_TEMP_ADC_BED
  #define GET_BED_ADC()             PIN_TO_ADC(TEMP_BED_PIN)
 #else
  #define GET_BED_ADC()             -1
 #endif
-#if HAS_HEATED_CHAMBER
+#if HAS_TEMP_ADC_CHAMBER
  #define GET_CHAMBER_ADC()         PIN_TO_ADC(TEMP_CHAMBER_PIN)
 #else
  #define GET_CHAMBER_ADC()         -1
@@ -193,8 +193,8 @@ uint16_t HAL_adc_result;
  uint16_t HAL_adc_results[COUNT(adc_pins)];

  #if ADC0_IS_REQUIRED
-    Adafruit_ZeroDMA adc0ProgramDMA,
-                     adc0ReadDMA;
+    Adafruit_ZeroDMA adc0DMAProgram,
+                     adc0DMARead;

    const HAL_DMA_DAC_Registers adc0_dma_regs_list[] = {
      #if GET_TEMP_0_ADC() == 0
@@ -233,8 +233,8 @@ uint16_t HAL_adc_result;
  #endif // ADC0_IS_REQUIRED

  #if ADC1_IS_REQUIRED
-    Adafruit_ZeroDMA adc1ProgramDMA,
-                     adc1ReadDMA;
+    Adafruit_ZeroDMA adc1DMAProgram,
+                     adc1DMARead;

    const HAL_DMA_DAC_Registers adc1_dma_regs_list[] = {
      #if GET_TEMP_0_ADC() == 1
@@ -284,11 +284,11 @@ uint16_t HAL_adc_result;
    DmacDescriptor *descriptor;

    #if ADC0_IS_REQUIRED
-      adc0ProgramDMA.setTrigger(ADC0_DMAC_ID_SEQ);
-      adc0ProgramDMA.setAction(DMA_TRIGGER_ACTON_BEAT);
-      adc0ProgramDMA.loop(true);
-      if (adc0ProgramDMA.allocate() == DMA_STATUS_OK) {
-        descriptor = adc0ProgramDMA.addDescriptor(
+      adc0DMAProgram.setTrigger(ADC0_DMAC_ID_SEQ);
+      adc0DMAProgram.setAction(DMA_TRIGGER_ACTON_BEAT);
+      adc0DMAProgram.loop(true);
+      if (adc0DMAProgram.allocate() == DMA_STATUS_OK) {
+        descriptor = adc0DMAProgram.addDescriptor(
          (void *)adc0_dma_regs_list,         // SRC
          (void *)&ADC0->DSEQDATA.reg,        // DEST
          sizeof(adc0_dma_regs_list) / 4,     // CNT
@@ -300,14 +300,14 @@ uint16_t HAL_adc_result;
        );
        if (descriptor != nullptr)
          descriptor->BTCTRL.bit.EVOSEL = DMA_EVENT_OUTPUT_BEAT;
-        adc0ProgramDMA.startJob();
+        adc0DMAProgram.startJob();
      }

-      adc0ReadDMA.setTrigger(ADC0_DMAC_ID_RESRDY);
-      adc0ReadDMA.setAction(DMA_TRIGGER_ACTON_BEAT);
-      adc0ReadDMA.loop(true);
-      if (adc0ReadDMA.allocate() == DMA_STATUS_OK) {
-        adc0ReadDMA.addDescriptor(
+      adc0DMARead.setTrigger(ADC0_DMAC_ID_RESRDY);
+      adc0DMARead.setAction(DMA_TRIGGER_ACTON_BEAT);
+      adc0DMARead.loop(true);
+      if (adc0DMARead.allocate() == DMA_STATUS_OK) {
+        adc0DMARead.addDescriptor(
          (void *)&ADC0->RESULT.reg,          // SRC
          &HAL_adc_results,                   // DEST
          ADC0_AINCOUNT,                      // CNT
@@ -317,15 +317,15 @@ uint16_t HAL_adc_result;
          DMA_ADDRESS_INCREMENT_STEP_SIZE_1,  // STEPSIZE
          DMA_STEPSEL_DST                     // STEPSEL
        );
-        adc0ReadDMA.startJob();
+        adc0DMARead.startJob();
      }
    #endif
    #if ADC1_IS_REQUIRED
-      adc1ProgramDMA.setTrigger(ADC1_DMAC_ID_SEQ);
-      adc1ProgramDMA.setAction(DMA_TRIGGER_ACTON_BEAT);
-      adc1ProgramDMA.loop(true);
-      if (adc1ProgramDMA.allocate() == DMA_STATUS_OK) {
-        descriptor = adc1ProgramDMA.addDescriptor(
+      adc1DMAProgram.setTrigger(ADC1_DMAC_ID_SEQ);
+      adc1DMAProgram.setAction(DMA_TRIGGER_ACTON_BEAT);
+      adc1DMAProgram.loop(true);
+      if (adc1DMAProgram.allocate() == DMA_STATUS_OK) {
+        descriptor = adc1DMAProgram.addDescriptor(
          (void *)adc1_dma_regs_list,         // SRC
          (void *)&ADC1->DSEQDATA.reg,        // DEST
          sizeof(adc1_dma_regs_list) / 4,     // CNT
@@ -337,14 +337,14 @@ uint16_t HAL_adc_result;
        );
        if (descriptor != nullptr)
          descriptor->BTCTRL.bit.EVOSEL = DMA_EVENT_OUTPUT_BEAT;
-        adc1ProgramDMA.startJob();
+        adc1DMAProgram.startJob();
      }

-      adc1ReadDMA.setTrigger(ADC1_DMAC_ID_RESRDY);
-      adc1ReadDMA.setAction(DMA_TRIGGER_ACTON_BEAT);
-      adc1ReadDMA.loop(true);
-      if (adc1ReadDMA.allocate() == DMA_STATUS_OK) {
-        adc1ReadDMA.addDescriptor(
+      adc1DMARead.setTrigger(ADC1_DMAC_ID_RESRDY);
+      adc1DMARead.setAction(DMA_TRIGGER_ACTON_BEAT);
+      adc1DMARead.loop(true);
+      if (adc1DMARead.allocate() == DMA_STATUS_OK) {
+        adc1DMARead.addDescriptor(
          (void *)&ADC1->RESULT.reg,          // SRC
          &HAL_adc_results[ADC0_AINCOUNT],    // DEST
          ADC1_AINCOUNT,                      // CNT
@@ -354,11 +354,11 @@ uint16_t HAL_adc_result;
          DMA_ADDRESS_INCREMENT_STEP_SIZE_1,  // STEPSIZE
          DMA_STEPSEL_DST                     // STEPSEL
        );
-        adc1ReadDMA.startJob();
+        adc1DMARead.startJob();
      }
    #endif

-    DMAC->PRICTRL0.bit.RRLVLEN0 = true;                         // Activate round robin for DMA channels used by ADCs
+    DMAC->PRICTRL0.bit.RRLVLEN0 = true;                         // Activate round robin for DMA channels required by ADCs
  }

 #endif // DMA_IS_REQUIRED
@@ -1,7 +1,7 @@
 /**
 * Marlin 3D Printer Firmware
 *
- * Copyright (C) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * This program is free software: you can redistribute it and/or modify
@@ -76,7 +76,8 @@

 typedef int8_t pin_t;

-//#define HAL_SERVO_LIB Servo
+#define SHARED_SERVOS HAS_SERVOS
+#define HAL_SERVO_LIB Servo

 //
 // Interrupts
@@ -131,11 +132,17 @@ void noTone(const pin_t _pin);

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

 //
 // Utility functions
 //
 FORCE_INLINE void _delay_ms(const int delay_ms) { delay(delay_ms); }
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-function"
 int freeMemory(void);
+#pragma GCC diagnostic pop
@@ -1,7 +1,7 @@
 /**
 * Marlin 3D Printer Firmware
 *
- * Copyright (C) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * This program is free software: you can redistribute it and/or modify
@@ -1,7 +1,7 @@
 /**
 * Marlin 3D Printer Firmware
 *
- * Copyright (C) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * This program is free software: you can redistribute it and/or modify
@@ -40,8 +40,8 @@
 const tTimerConfig TimerConfig[NUM_HARDWARE_TIMERS] = {
  { TC0, TC0_IRQn, TC_PRIORITY(0) },
  { TC1, TC1_IRQn, TC_PRIORITY(1) },
-  { TC2, TC2_IRQn, TC_PRIORITY(2) },
-  { TC3, TC3_IRQn, TC_PRIORITY(3) },
+  { TC2, TC2_IRQn, TC_PRIORITY(2) },  // Reserved by framework tone function
+  { TC3, TC3_IRQn, TC_PRIORITY(3) },  // Reserved by servo library
  { TC4, TC4_IRQn, TC_PRIORITY(4) },
  { TC5, TC5_IRQn, TC_PRIORITY(5) },
  { TC6, TC6_IRQn, TC_PRIORITY(6) },
@@ -1,7 +1,7 @@
 /**
 * Marlin 3D Printer Firmware
 *
- * Copyright (C) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * This program is free software: you can redistribute it and/or modify
@@ -33,13 +33,12 @@ typedef uint32_t hal_timer_t;

 #define STEP_TIMER_NUM      0  // index of timer to use for stepper (also +1 for 32bits counter)
 #define PULSE_TIMER_NUM     STEP_TIMER_NUM
-#define TONE_TIMER_NUM      2  // index of timer to use for beeper tones (also +1 for 32bits counter)
 #define TEMP_TIMER_NUM      4  // index of timer to use for temperature (also +1 for 32bits counter)

 #define TEMP_TIMER_FREQUENCY   1000 // temperature interrupt frequency

 #define STEPPER_TIMER_RATE          HAL_TIMER_RATE   // frequency of stepper timer (HAL_TIMER_RATE / STEPPER_TIMER_PRESCALE)
-#define STEPPER_TIMER_TICKS_PER_US  ((STEPPER_TIMER_RATE) / 1000000) // stepper timer ticks per µs
+#define STEPPER_TIMER_TICKS_PER_US  ((STEPPER_TIMER_RATE) / 1000000) // stepper timer ticks per µs
 #define STEPPER_TIMER_PRESCALE      (CYCLES_PER_MICROSECOND / STEPPER_TIMER_TICKS_PER_US)

 #define PULSE_TIMER_RATE          STEPPER_TIMER_RATE
@@ -53,9 +52,10 @@ 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 TC_PRIORITY(t)        (t == STEP_TIMER_NUM || t == PULSE_TIMER_NUM) ? 2     \
-                               : (t == TEMP_TIMER_NUM) ? 6                          \
-                               : (t == TONE_TIMER_NUM) ? 5 : 7
+#define TC_PRIORITY(t)        (t == STEP_TIMER_NUM || t == PULSE_TIMER_NUM) ? 2   \
+                               : (t == TEMP_TIMER_NUM) ? 6                        \
+                               : 7
+
 #define _TC_HANDLER(t)        void TC##t##_Handler()
 #define TC_HANDLER(t)         _TC_HANDLER(t)
 #define HAL_STEP_TIMER_ISR()  TC_HANDLER(STEP_TIMER_NUM)
@@ -63,7 +63,6 @@ typedef uint32_t hal_timer_t;
  #define HAL_PULSE_TIMER_ISR()  TC_HANDLER(PULSE_TIMER_NUM)
 #endif
 #define HAL_TEMP_TIMER_ISR()  TC_HANDLER(TEMP_TIMER_NUM)
-#define HAL_TONE_TIMER_ISR()  TC_HANDLER(TONE_TIMER_NUM)

 // --------------------------------------------------------------------------
 // Types
@@ -1,7 +1,7 @@
 /**
 * Marlin 3D Printer Firmware
 *
- * Copyright (C) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * This program is free software: you can redistribute it and/or modify
@@ -1,7 +1,7 @@
 /**
 * Marlin 3D Printer Firmware
 *
- * Copyright (C) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * This program is free software: you can redistribute it and/or modify
@@ -1,7 +1,7 @@
 /**
 * Marlin 3D Printer Firmware
 *
- * Copyright (C) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * This program is free software: you can redistribute it and/or modify
@@ -20,8 +20,8 @@
 */
 #pragma once

-#define SYNC(sc)    while (sc) {   \
-                      asm("");     \
+#define SYNC(sc)    while (sc) {  \
+                      asm("");    \
                    }

 // Get SAMD port/pin from specified arduino pin
@@ -0,0 +1,39 @@
+/**
+ * Marlin 3D Printer Firmware
+ *
+ * Copyright (C) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (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
+
+#define _useTimer1
+#define _useTimer2
+
+#define TRIM_DURATION           5   // compensation ticks to trim adjust for digitalWrite delays
+#define SERVO_TIMER_PRESCALER   64  // timer prescaler factor to 64 (avoid overflowing 16-bit clock counter, at 120MHz this is 1831 ticks per millisecond
+
+#define SERVO_TC                3
+
+typedef enum {
+  #ifdef _useTimer1
+    _timer1,
+  #endif
+  #ifdef _useTimer2
+    _timer2,
+  #endif
+  _Nbr_16timers
+} timer16_Sequence_t;
@@ -0,0 +1,226 @@
+/**
+ * Marlin 3D Printer Firmware
+ *
+ * Copyright (C) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (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/>.
+ *
+ */
+
+/**
+ * This comes from Arduino library which at the moment is buggy and uncompilable
+ */
+
+#ifdef __SAMD51__
+
+#include "../../inc/MarlinConfig.h"
+
+#if HAS_SERVOS
+
+#include "../shared/Marduino.h"
+#include "../shared/servo.h"
+#include "../shared/servo_private.h"
+#include "SAMD51.h"
+#include "HAL_timers_SAMD51.h"
+
+#define __TC_GCLK_ID(t)         TC##t##_GCLK_ID
+#define _TC_GCLK_ID(t)          __TC_GCLK_ID(t)
+#define TC_GCLK_ID              _TC_GCLK_ID(SERVO_TC)
+
+#define _TC_PRESCALER(d)        TC_CTRLA_PRESCALER_DIV##d##_Val
+#define TC_PRESCALER(d)         _TC_PRESCALER(d)
+
+#define __SERVO_IRQn(t)         TC##t##_IRQn
+#define _SERVO_IRQn(t)          __SERVO_IRQn(t)
+#define SERVO_IRQn              _SERVO_IRQn(SERVO_TC)
+
+#define HAL_SERVO_TIMER_ISR()   TC_HANDLER(SERVO_TC)
+
+#define TIMER_TCCHANNEL(t)      ((t) & 1)
+#define TC_COUNTER_START_VAL    0xFFFF
+
+
+static volatile int8_t currentServoIndex[_Nbr_16timers];    // index for the servo being pulsed for each timer (or -1 if refresh interval)
+
+FORCE_INLINE static uint16_t getTimerCount() {
+  Tc * const tc = TimerConfig[SERVO_TC].pTimer;
+
+  tc->COUNT16.CTRLBSET.reg = TC_CTRLBCLR_CMD_READSYNC;
+  SYNC(tc->COUNT16.SYNCBUSY.bit.CTRLB || tc->COUNT16.SYNCBUSY.bit.COUNT);
+
+  return tc->COUNT16.COUNT.reg;
+}
+
+// ----------------------------
+// Interrupt handler for the TC
+// ----------------------------
+HAL_SERVO_TIMER_ISR() {
+  Tc * const tc = TimerConfig[SERVO_TC].pTimer;
+  const timer16_Sequence_t timer =
+    #ifndef _useTimer1
+      _timer2
+    #elif !defined(_useTimer2)
+      _timer1
+    #else
+      (tc->COUNT16.INTFLAG.reg & tc->COUNT16.INTENSET.reg & TC_INTFLAG_MC0) ? _timer1 : _timer2
+    #endif
+  ;
+  const uint8_t tcChannel = TIMER_TCCHANNEL(timer);
+
+  if (currentServoIndex[timer] < 0) {
+    #if defined(_useTimer1) && defined(_useTimer2)
+      if (currentServoIndex[timer ^ 1] >= 0) {
+        // Wait for both channels
+        // Clear the interrupt
+        tc->COUNT16.INTFLAG.reg = (tcChannel == 0) ? TC_INTFLAG_MC0 : TC_INTFLAG_MC1;
+        return;
+      }
+    #endif
+    tc->COUNT16.COUNT.reg = TC_COUNTER_START_VAL;
+    SYNC(tc->COUNT16.SYNCBUSY.bit.COUNT);
+  }
+  else if (SERVO_INDEX(timer, currentServoIndex[timer]) < ServoCount && SERVO(timer, currentServoIndex[timer]).Pin.isActive)
+    digitalWrite(SERVO(timer, currentServoIndex[timer]).Pin.nbr, LOW);      // pulse this channel low if activated
+
+  // Select the next servo controlled by this timer
+  currentServoIndex[timer]++;
+
+  if (SERVO_INDEX(timer, currentServoIndex[timer]) < ServoCount && currentServoIndex[timer] < SERVOS_PER_TIMER) {
+    if (SERVO(timer, currentServoIndex[timer]).Pin.isActive)                // check if activated
+      digitalWrite(SERVO(timer, currentServoIndex[timer]).Pin.nbr, HIGH);   // it's an active channel so pulse it high
+
+    tc->COUNT16.CC[tcChannel].reg = getTimerCount() - (uint16_t)SERVO(timer, currentServoIndex[timer]).ticks;
+  }
+  else {
+    // finished all channels so wait for the refresh period to expire before starting over
+    currentServoIndex[timer] = -1;   // this will get incremented at the end of the refresh period to start again at the first channel
+
+    const uint16_t tcCounterValue = getTimerCount();
+
+    if ((TC_COUNTER_START_VAL - tcCounterValue) + 4UL < usToTicks(REFRESH_INTERVAL))  // allow a few ticks to ensure the next OCR1A not missed
+      tc->COUNT16.CC[tcChannel].reg = TC_COUNTER_START_VAL - (uint16_t)usToTicks(REFRESH_INTERVAL);
+    else
+      tc->COUNT16.CC[tcChannel].reg = (uint16_t)(tcCounterValue - 4UL);               // at least REFRESH_INTERVAL has elapsed
+  }
+  if (tcChannel == 0) {
+    SYNC(tc->COUNT16.SYNCBUSY.bit.CC0);
+    // Clear the interrupt
+    tc->COUNT16.INTFLAG.reg = TC_INTFLAG_MC0;
+  }
+  else {
+    SYNC(tc->COUNT16.SYNCBUSY.bit.CC1);
+    // Clear the interrupt
+    tc->COUNT16.INTFLAG.reg = TC_INTFLAG_MC1;
+  }
+}
+
+void initISR(timer16_Sequence_t timer) {
+  Tc * const tc = TimerConfig[SERVO_TC].pTimer;
+  const uint8_t tcChannel = TIMER_TCCHANNEL(timer);
+
+  static bool initialized = false;  // Servo TC has been initialized
+  if (!initialized) {
+    NVIC_DisableIRQ(SERVO_IRQn);
+
+    // Disable the timer
+    tc->COUNT16.CTRLA.bit.ENABLE = false;
+    SYNC(tc->COUNT16.SYNCBUSY.bit.ENABLE);
+
+    // Select GCLK0 as timer/counter input clock source
+    GCLK->PCHCTRL[TC_GCLK_ID].bit.CHEN = false;
+    SYNC(GCLK->PCHCTRL[TC_GCLK_ID].bit.CHEN);
+    GCLK->PCHCTRL[TC_GCLK_ID].reg = GCLK_PCHCTRL_GEN_GCLK0 | GCLK_PCHCTRL_CHEN;   // 120MHz startup code programmed
+    SYNC(!GCLK->PCHCTRL[TC_GCLK_ID].bit.CHEN);
+
+    // Reset the timer
+    tc->COUNT16.CTRLA.bit.SWRST = true;
+    SYNC(tc->COUNT16.SYNCBUSY.bit.SWRST);
+    SYNC(tc->COUNT16.CTRLA.bit.SWRST);
+
+    // Set timer counter mode to 16 bits
+    tc->COUNT16.CTRLA.reg = TC_CTRLA_MODE_COUNT16;
+
+    // Set timer counter mode as normal PWM
+    tc->COUNT16.WAVE.bit.WAVEGEN = TCC_WAVE_WAVEGEN_NPWM_Val;
+
+    // Set the prescaler factor
+    tc->COUNT16.CTRLA.bit.PRESCALER = TC_PRESCALER(SERVO_TIMER_PRESCALER);
+
+    // Count down
+    tc->COUNT16.CTRLBSET.reg = TC_CTRLBCLR_DIR;
+    SYNC(tc->COUNT16.SYNCBUSY.bit.CTRLB);
+
+    // Reset all servo indexes
+    memset((void *)currentServoIndex, 0xFF, sizeof(currentServoIndex));
+
+    // Configure interrupt request
+    NVIC_ClearPendingIRQ(SERVO_IRQn);
+    NVIC_SetPriority(SERVO_IRQn, 5);
+    NVIC_EnableIRQ(SERVO_IRQn);
+
+    initialized = true;
+  }
+
+  if (!tc->COUNT16.CTRLA.bit.ENABLE) {
+    // Reset the timer counter
+    tc->COUNT16.COUNT.reg = TC_COUNTER_START_VAL;
+    SYNC(tc->COUNT16.SYNCBUSY.bit.COUNT);
+
+    // Enable the timer and start it
+    tc->COUNT16.CTRLA.bit.ENABLE = true;
+    SYNC(tc->COUNT16.SYNCBUSY.bit.ENABLE);
+  }
+  // First interrupt request after 1 ms
+  tc->COUNT16.CC[tcChannel].reg = getTimerCount() - (uint16_t)usToTicks(1000UL);
+
+  if (tcChannel == 0 ) {
+    SYNC(tc->COUNT16.SYNCBUSY.bit.CC0);
+
+    // Clear pending match interrupt
+    tc->COUNT16.INTFLAG.reg = TC_INTENSET_MC0;
+    // Enable the match channel interrupt request
+    tc->COUNT16.INTENSET.reg = TC_INTENSET_MC0;
+  }
+  else {
+    SYNC(tc->COUNT16.SYNCBUSY.bit.CC1);
+
+    // Clear pending match interrupt
+    tc->COUNT16.INTFLAG.reg = TC_INTENSET_MC1;
+    // Enable the match channel interrupt request
+    tc->COUNT16.INTENSET.reg = TC_INTENSET_MC1;
+  }
+}
+
+void finISR(timer16_Sequence_t timer) {
+  Tc * const tc = TimerConfig[SERVO_TC].pTimer;
+  const uint8_t tcChannel = TIMER_TCCHANNEL(timer);
+
+  // Disable the match channel interrupt request
+  tc->COUNT16.INTENCLR.reg = (tcChannel == 0) ? TC_INTENCLR_MC0 : TC_INTENCLR_MC1;
+
+  if (true
+    #if defined(_useTimer1) && defined(_useTimer2)
+      && (tc->COUNT16.INTENCLR.reg & (TC_INTENCLR_MC0|TC_INTENCLR_MC1)) == 0
+    #endif
+  ) {
+    // Disable the timer if not used
+    tc->COUNT16.CTRLA.bit.ENABLE = false;
+    SYNC(tc->COUNT16.SYNCBUSY.bit.ENABLE);
+  }
+}
+
+#endif // HAS_SERVOS
+
+#endif // __SAMD51__
@@ -1,59 +0,0 @@
-/**
- * Marlin 3D Printer Firmware
- *
- * Copyright (C) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
- * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-/**
- * Description: Tone function for Arduino Due and compatible (SAM3X8E)
- * Derived from http://forum.arduino.cc/index.php?topic=136500.msg2903012#msg2903012
- */
-
-#ifdef __SAMD51__
-
-#include "../../inc/MarlinConfig.h"
-#include "HAL_timers_SAMD51.h"
-
-static pin_t tone_pin;
-volatile static int32_t toggles;
-
-void tone(const pin_t _pin, const unsigned int frequency, const unsigned long duration) {
-  tone_pin = _pin;
-  toggles = 2 * frequency * duration / 1000;
-  HAL_timer_start(TONE_TIMER_NUM, 2 * frequency);
-}
-
-void noTone(const pin_t _pin) {
-  HAL_timer_disable_interrupt(TONE_TIMER_NUM);
-  extDigitalWrite(_pin, LOW);
-}
-
-HAL_TONE_TIMER_ISR() {
-  static bool pin_state = false;
-  HAL_timer_isr_prologue(TONE_TIMER_NUM);
-
-  if (toggles) {
-    toggles--;
-    extDigitalWrite(tone_pin, (pin_state = !pin_state));
-  }
-  else noTone(tone_pin);                         // turn off interrupt
-
-  HAL_timer_isr_epilogue(TONE_TIMER_NUM);
-}
-
-#endif // __SAMD51__
@@ -1,7 +1,7 @@
 /**
 * Marlin 3D Printer Firmware
 *
- * Copyright (C) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * This program is free software: you can redistribute it and/or modify
@@ -1,7 +1,7 @@
 /**
 * Marlin 3D Printer Firmware
 *
- * Copyright (C) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * This program is free software: you can redistribute it and/or modify
@@ -243,6 +243,7 @@
  #define DIO5_PIN    PIN_PC21
  #define DIO16_PIN   PIN_PC22
  #define DIO17_PIN   PIN_PC23
+  #define DIO88_PIN   PIN_PC24    // NEOPIXEL
  // PORTD
  #define DIO22_PIN   PIN_PD12
  #define DIO6_PIN    PIN_PD20
@@ -1,7 +1,7 @@
 /**
 * Marlin 3D Printer Firmware
 *
- * Copyright (C) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * This program is free software: you can redistribute it and/or modify
@@ -32,7 +32,7 @@
 #endif

 #if ENABLED(EMERGENCY_PARSER)
-  #error "EMERGENCY_PARSER is not yet implemented for STM32F4. Disable EMERGENCY_PARSER to continue."
+  #error "EMERGENCY_PARSER is not yet implemented for SAMD51. Disable EMERGENCY_PARSER to continue."
 #endif

 #if ENABLED(SDIO_SUPPORT)
@@ -1,7 +1,7 @@
 /**
 * Marlin 3D Printer Firmware
 *
- * Copyright (C) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * This program is free software: you can redistribute it and/or modify
@@ -1,7 +1,7 @@
 /**
 * Marlin 3D Printer Firmware
 *
- * Copyright (C) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * This program is free software: you can redistribute it and/or modify
@@ -1,7 +1,7 @@
 /**
 * Marlin 3D Printer Firmware
 *
- * Copyright (C) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * This program is free software: you can redistribute it and/or modify
@@ -1,7 +1,7 @@
 /**
 * Marlin 3D Printer Firmware
 *
- * Copyright (C) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * This program is free software: you can redistribute it and/or modify
@@ -1,7 +1,7 @@
 /**
 * Marlin 3D Printer Firmware
 *
- * Copyright (C) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 * SAMD51 HAL developed by Giuliano Zaro (AKA GMagician)
 *
 * This program is free software: you can redistribute it and/or modify
@@ -136,7 +136,7 @@ typedef int16_t pin_t;
 // Public Variables
 // ------------------------

-/** result of last ADC conversion */
+// result of last ADC conversion
 extern uint16_t HAL_adc_result;

 // ------------------------
@@ -149,30 +149,35 @@ extern uint16_t HAL_adc_result;
 // Enable hooks into  setup for HAL
 void HAL_init(void);

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

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

 void _delay_ms(const int delay);

 extern "C" char* _sbrk(int incr);

+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-function"
+
 static inline int freeMemory() {
  volatile char top;
  return &top - reinterpret_cast<char*>(_sbrk(0));
 }

+#pragma GCC diagnostic pop
+
 //
 // SPI: Extended functions which take a channel number (hardware SPI only)
 //

-/** Write single byte to specified SPI channel */
+// Write single byte to specified SPI channel
 void spiSend(uint32_t chan, byte b);
-/** Write buffer to specified SPI channel */
+// Write buffer to specified SPI channel
 void spiSend(uint32_t chan, const uint8_t* buf, size_t n);
-/** Read single byte from specified SPI channel */
+// Read single byte from specified SPI channel
 uint8_t spiRec(uint32_t chan);

 //
@@ -182,8 +187,8 @@ uint8_t spiRec(uint32_t chan);
 // Wire library should work for i2c EEPROMs
 void eeprom_write_byte(uint8_t *pos, unsigned char value);
 uint8_t eeprom_read_byte(uint8_t *pos);
-void eeprom_read_block (void *__dst, const void *__src, size_t __n);
-void eeprom_update_block (const void *__src, void *__dst, size_t __n);
+void eeprom_read_block(void *__dst, const void *__src, size_t __n);
+void eeprom_update_block(const void *__src, void *__dst, size_t __n);

 //
 // ADC
@@ -22,7 +22,6 @@
 */
 #if defined(ARDUINO_ARCH_STM32) && !defined(STM32GENERIC)

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

 #include <SPI.h>
@@ -73,16 +72,22 @@ void spiInit(uint8_t spiRate) {
  // Use datarates Marlin uses
  uint32_t clock;
  switch (spiRate) {
-  case SPI_FULL_SPEED:    clock = 20000000; break; // 13.9mhz=20000000  6.75mhz=10000000  3.38mhz=5000000  .833mhz=1000000
-  case SPI_HALF_SPEED:    clock =  5000000; break;
-  case SPI_QUARTER_SPEED: clock =  2500000; break;
-  case SPI_EIGHTH_SPEED:  clock =  1250000; break;
-  case SPI_SPEED_5:       clock =   625000; break;
-  case SPI_SPEED_6:       clock =   300000; break;
-  default:
-    clock = 4000000; // Default from the SPI library
+    case SPI_FULL_SPEED:    clock = 20000000; break; // 13.9mhz=20000000  6.75mhz=10000000  3.38mhz=5000000  .833mhz=1000000
+    case SPI_HALF_SPEED:    clock =  5000000; break;
+    case SPI_QUARTER_SPEED: clock =  2500000; break;
+    case SPI_EIGHTH_SPEED:  clock =  1250000; break;
+    case SPI_SPEED_5:       clock =   625000; break;
+    case SPI_SPEED_6:       clock =   300000; break;
+    default:
+      clock = 4000000; // Default from the SPI library
  }
  spiConfig = SPISettings(clock, MSBFIRST, SPI_MODE0);
+  #if defined(MISO_PIN) && defined(SDSS) && defined(MOSI_PIN) && defined(SCK_PIN)
+    SPI.setMISO(MISO_PIN);
+    SPI.setSSEL(SDSS);
+    SPI.setMOSI(MOSI_PIN);
+    SPI.setSCLK(SCK_PIN);
+  #endif
  SPI.begin();
 }

@@ -32,8 +32,6 @@

 #define NUM_HARDWARE_TIMERS 2

-//#define PRESCALER 1
-
 // ------------------------
 // Private Variables
 // ------------------------
@@ -53,7 +53,7 @@ void FastIO_init(); // Must be called before using fast io macros
  #define _WRITE(IO, V) do { \
    if (V) FastIOPortMap[STM_PORT(digitalPin[IO])]->BSRR = _BV32(STM_PIN(digitalPin[IO])) ; \
    else   FastIOPortMap[STM_PORT(digitalPin[IO])]->BRR  = _BV32(STM_PIN(digitalPin[IO])) ; \
-  } while(0)
+  }while(0)
 #else
  #define _WRITE(IO, V) (FastIOPortMap[STM_PORT(digitalPin[IO])]->BSRR = _BV32(STM_PIN(digitalPin[IO]) + (V ? 0 : 16)))
 #endif
@@ -24,24 +24,24 @@

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

-#if ENABLED(EEPROM_SETTINGS)
+#if ENABLED(EEPROM_SETTINGS) && ANY(FLASH_EEPROM_EMULATION, SRAM_EEPROM_EMULATION, SPI_EEPROM, I2C_EEPROM)

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

-#if NONE(SRAM_EEPROM_EMULATION, SPI_EEPROM, I2C_EEPROM)
+#if ENABLED(FLASH_EEPROM_EMULATION)
  #include <EEPROM.h>
  static bool eeprom_data_written = false;
 #endif

 bool PersistentStore::access_start() {
-  #if NONE(SRAM_EEPROM_EMULATION, SPI_EEPROM, I2C_EEPROM)
+  #if ENABLED(FLASH_EEPROM_EMULATION)
    eeprom_buffer_fill();
  #endif
  return true;
 }

 bool PersistentStore::access_finish() {
-  #if NONE(SRAM_EEPROM_EMULATION, SPI_EEPROM, I2C_EEPROM)
+  #if ENABLED(FLASH_EEPROM_EMULATION)
    if (eeprom_data_written) {
      eeprom_buffer_flush();
      eeprom_data_written = false;
@@ -66,7 +66,7 @@ bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, ui
          return true;
        }
      }
-    #elif DISABLED(SRAM_EEPROM_EMULATION)
+    #elif ENABLED(FLASH_EEPROM_EMULATION)
      eeprom_buffered_write_byte(pos, v);
    #else
      *(__IO uint8_t *)(BKPSRAM_BASE + (uint8_t * const)pos) = v;
@@ -76,7 +76,7 @@ bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, ui
    pos++;
    value++;
  };
-  #if NONE(SRAM_EEPROM_EMULATION, SPI_EEPROM, I2C_EEPROM)
+  #if ENABLED(FLASH_EEPROM_EMULATION)
    eeprom_data_written = true;
  #endif

@@ -89,7 +89,7 @@ bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t
    const uint8_t c = (
      #if EITHER(SPI_EEPROM, I2C_EEPROM)
        eeprom_read_byte((uint8_t*)pos)
-      #elif DISABLED(SRAM_EEPROM_EMULATION)
+      #elif ENABLED(FLASH_EEPROM_EMULATION)
        eeprom_buffered_read_byte(pos)
      #else
        (*(__IO uint8_t *)(BKPSRAM_BASE + ((uint8_t*)pos)))
@@ -105,14 +105,14 @@ bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t
 }

 size_t PersistentStore::capacity() {
-  #if EITHER(SPI_EEPROM, I2C_EEPROM)
-    return E2END + 1;
-  #elif DISABLED(SRAM_EEPROM_EMULATION)
-    return E2END + 1;
-  #else
-    return 4096; // 4kB
-  #endif
+  return (
+    #if ENABLED(SRAM_EEPROM_EMULATION)
+      4096 // 4kB
+    #else
+      E2END + 1
+    #endif
+  );
 }

-#endif // EEPROM_SETTINGS
+#endif // EEPROM_SETTINGS && (FLASH_EEPROM_EMULATION || SRAM_EEPROM_EMULATION || SPI_EEPROM || I2C_EEPROM)
 #endif // ARDUINO_ARCH_STM32 && !STM32GENERIC
@@ -0,0 +1,103 @@
+/**
+ * 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/>.
+ *
+ */
+
+/**
+ * Implementation of EEPROM settings in SD Card
+ */
+
+#if defined(ARDUINO_ARCH_STM32) && !defined(STM32GENERIC)
+
+#include "../../inc/MarlinConfig.h"
+
+#if ENABLED(EEPROM_SETTINGS) && NONE(FLASH_EEPROM_EMULATION, SRAM_EEPROM_EMULATION, SPI_EEPROM, I2C_EEPROM)
+
+#include "../shared/persistent_store_api.h"
+
+#ifndef E2END
+  #define E2END 0xFFF // 4KB
+#endif
+#define HAL_EEPROM_SIZE int(E2END + 1)
+
+#define _ALIGN(x) __attribute__ ((aligned(x)))
+static char _ALIGN(4) HAL_eeprom_data[HAL_EEPROM_SIZE];
+
+#if ENABLED(SDSUPPORT)
+
+  #include "../../sd/cardreader.h"
+
+  #define EEPROM_FILENAME "eeprom.dat"
+
+  bool PersistentStore::access_start() {
+    if (!card.isDetected()) return false;
+
+    SdFile file, root = card.getroot();
+    if (!file.open(&root, EEPROM_FILENAME, O_RDONLY))
+      return true;
+
+    int bytes_read = file.read(HAL_eeprom_data, HAL_EEPROM_SIZE);
+    if (bytes_read < 0) return false;
+    for (; bytes_read < HAL_EEPROM_SIZE; bytes_read++)
+      HAL_eeprom_data[bytes_read] = 0xFF;
+    file.close();
+    return true;
+  }
+
+  bool PersistentStore::access_finish() {
+    if (!card.isDetected()) return false;
+
+    SdFile file, root = card.getroot();
+    int bytes_written = 0;
+    if (file.open(&root, EEPROM_FILENAME, O_CREAT | O_WRITE | O_TRUNC)) {
+      bytes_written = file.write(HAL_eeprom_data, HAL_EEPROM_SIZE);
+      file.close();
+    }
+    return (bytes_written == HAL_EEPROM_SIZE);
+  }
+
+#else // !SDSUPPORT
+
+  #error "Please define an EEPROM, a SDCARD or disable EEPROM_SETTINGS."
+
+#endif // !SDSUPPORT
+
+bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
+  for (size_t i = 0; i < size; i++)
+    HAL_eeprom_data[pos + i] = value[i];
+  crc16(crc, value, size);
+  pos += size;
+  return false;
+}
+
+bool PersistentStore::read_data(int &pos, uint8_t* value, const size_t size, uint16_t *crc, const bool writing/*=true*/) {
+  for (size_t i = 0; i < size; i++) {
+    uint8_t c = HAL_eeprom_data[pos + i];
+    if (writing) value[i] = c;
+    crc16(crc, &c, 1);
+  }
+  pos += size;
+  return false;
+}
+
+size_t PersistentStore::capacity() { return HAL_EEPROM_SIZE; }
+
+#endif // EEPROM_SETTINGS
+#endif // STM32
@@ -189,7 +189,7 @@ void port_print(const pin_t Ard_num) {
  for (Index = 0; Index < NUMBER_PINS_TOTAL; Index++)
    if (Ard_num == GET_PIN_MAP_PIN_M43(Index)) break;

-  char * const ppa = pin_xref[Index].Port_pin_alpha;
+  const char * ppa = pin_xref[Index].Port_pin_alpha;
  sprintf_P(buffer, PSTR("%s"), ppa);
  SERIAL_ECHO(buffer);
  if (ppa[3] == '\0') SERIAL_CHAR(' ');
@@ -93,7 +93,7 @@ uint16_t HAL_adc_result;
 // ------------------------
 STM32ADC adc(ADC1);

-uint8_t adc_pins[] = {
+const uint8_t adc_pins[] = {
  #if HAS_TEMP_ADC_0
    TEMP_0_PIN,
  #endif
@@ -270,7 +270,7 @@ void HAL_adc_init(void) {
  #else
    adc.setSampleRate(ADC_SMPR_41_5); // 41.5 ADC cycles
  #endif
-  adc.setPins(adc_pins, ADC_PIN_COUNT);
+  adc.setPins((uint8_t *)adc_pins, ADC_PIN_COUNT);
  adc.setDMA(HAL_adc_results, (uint16_t)ADC_PIN_COUNT, (uint32_t)(DMA_MINC_MODE | DMA_CIRC_MODE), nullptr);
  adc.setScanMode();
  adc.setContinuous();
@@ -158,7 +158,7 @@ typedef int8_t pin_t;
 // Public Variables
 // ------------------------

-/** result of last ADC conversion */
+// Result of last ADC conversion
 extern uint16_t HAL_adc_result;

 // ------------------------
@@ -174,14 +174,17 @@ extern uint16_t HAL_adc_result;
 // Memory related
 #define __bss_end __bss_end__

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

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

 void _delay_ms(const int delay);

+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-function"
+
 /*
 extern "C" {
  int freeMemory(void);
@@ -189,6 +192,7 @@ extern "C" {
 */

 extern "C" char* _sbrk(int incr);
+
 /*
 static int freeMemory() {
  volatile int top;
@@ -197,9 +201,6 @@ static int freeMemory() {
 }
 */

-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-function"
-
 static int freeMemory() {
  volatile char top;
  return &top - reinterpret_cast<char*>(_sbrk(0));
@@ -211,11 +212,11 @@ static int freeMemory() {
 // SPI: Extended functions which take a channel number (hardware SPI only)
 //

-/** Write single byte to specified SPI channel */
+// Write single byte to specified SPI channel
 void spiSend(uint32_t chan, byte b);
-/** Write buffer to specified SPI channel */
+// Write buffer to specified SPI channel
 void spiSend(uint32_t chan, const uint8_t* buf, size_t n);
-/** Read single byte from specified SPI channel */
+// Read single byte from specified SPI channel
 uint8_t spiRec(uint32_t chan);

 //
@@ -33,7 +33,7 @@
 #ifdef __STM32F1__

 #include "../../inc/MarlinConfig.h"
-#include <SPI.h>
+#include "SPI.h"

 // ------------------------
 // Public functions
@@ -64,10 +64,9 @@
 * @details Only configures SS pin since libmaple creates and initialize the SPI object
 */
 void spiBegin() {
-  #if !PIN_EXISTS(SS)
-    #error "SS_PIN not defined!"
+  #if PIN_EXISTS(SS)
+    OUT_WRITE(SS_PIN, HIGH);
  #endif
-  OUT_WRITE(SS_PIN, HIGH);
 }

 /**
@@ -0,0 +1,741 @@
+/******************************************************************************
+ * The MIT License
+ *
+ * Copyright (c) 2010 Perry Hung.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy,
+ * modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *****************************************************************************/
+
+/**
+ * @author Marti Bolivar <mbolivar@leaflabs.com>
+ * @brief Wirish SPI implementation.
+ */
+
+#ifdef __STM32F1__
+
+#include "SPI.h"
+
+#include <libmaple/timer.h>
+#include <libmaple/util.h>
+#include <libmaple/rcc.h>
+
+#include <boards.h>
+#include <wirish.h>
+
+/** Time in ms for DMA receive timeout */
+#define DMA_TIMEOUT 100
+
+#if CYCLES_PER_MICROSECOND != 72
+  #warning "Unexpected clock speed; SPI frequency calculation will be incorrect"
+#endif
+
+struct spi_pins {
+  uint8_t nss;
+  uint8_t sck;
+  uint8_t miso;
+  uint8_t mosi;
+};
+
+static const spi_pins* dev_to_spi_pins(spi_dev *dev);
+static void configure_gpios(spi_dev *dev, bool as_master);
+static spi_baud_rate determine_baud_rate(spi_dev *dev, uint32_t freq);
+
+#if (BOARD_NR_SPI >= 3) && !defined(STM32_HIGH_DENSITY)
+  #error "The SPI library is misconfigured: 3 SPI ports only available on high density STM32 devices"
+#endif
+
+static const spi_pins board_spi_pins[] __FLASH__ = {
+  #if BOARD_NR_SPI >= 1
+  { BOARD_SPI1_NSS_PIN,
+    BOARD_SPI1_SCK_PIN,
+    BOARD_SPI1_MISO_PIN,
+    BOARD_SPI1_MOSI_PIN },
+  #endif
+  #if BOARD_NR_SPI >= 2
+  { BOARD_SPI2_NSS_PIN,
+    BOARD_SPI2_SCK_PIN,
+    BOARD_SPI2_MISO_PIN,
+    BOARD_SPI2_MOSI_PIN },
+  #endif
+  #if BOARD_NR_SPI >= 3
+  { BOARD_SPI3_NSS_PIN,
+    BOARD_SPI3_SCK_PIN,
+    BOARD_SPI3_MISO_PIN,
+    BOARD_SPI3_MOSI_PIN },
+  #endif
+};
+
+#if BOARD_NR_SPI >= 1
+  static void (*_spi1_this);
+#endif
+#if BOARD_NR_SPI >= 2
+  static void (*_spi2_this);
+#endif
+#if BOARD_NR_SPI >= 3
+  static void (*_spi3_this);
+#endif
+
+/**
+ * Constructor
+ */
+SPIClass::SPIClass(uint32_t spi_num) {
+  _currentSetting=&_settings[spi_num-1];// SPI channels are called 1 2 and 3 but the array is zero indexed
+
+  switch (spi_num) {
+    #if BOARD_NR_SPI >= 1
+      case 1:
+        _currentSetting->spi_d = SPI1;
+        _spi1_this = (void*)this;
+        break;
+    #endif
+    #if BOARD_NR_SPI >= 2
+      case 2:
+        _currentSetting->spi_d = SPI2;
+        _spi2_this = (void*)this;
+        break;
+    #endif
+    #if BOARD_NR_SPI >= 3
+      case 3:
+        _currentSetting->spi_d = SPI3;
+        _spi3_this = (void*)this;
+        break;
+    #endif
+    default: ASSERT(0);
+  }
+
+  // Init things specific to each SPI device
+  // clock divider setup is a bit of hack, and needs to be improved at a later date.
+  #if BOARD_NR_SPI >= 1
+    _settings[0].spi_d = SPI1;
+    _settings[0].clockDivider = determine_baud_rate(_settings[0].spi_d, _settings[0].clock);
+    _settings[0].spiDmaDev = DMA1;
+    _settings[0].spiTxDmaChannel = DMA_CH3;
+    _settings[0].spiRxDmaChannel = DMA_CH2;
+  #endif
+  #if BOARD_NR_SPI >= 2
+    _settings[1].spi_d = SPI2;
+    _settings[1].clockDivider = determine_baud_rate(_settings[1].spi_d, _settings[1].clock);
+    _settings[1].spiDmaDev = DMA1;
+    _settings[1].spiTxDmaChannel = DMA_CH5;
+    _settings[1].spiRxDmaChannel = DMA_CH4;
+  #endif
+  #if BOARD_NR_SPI >= 3
+    _settings[2].spi_d = SPI3;
+    _settings[2].clockDivider = determine_baud_rate(_settings[2].spi_d, _settings[2].clock);
+    _settings[2].spiDmaDev = DMA2;
+    _settings[2].spiTxDmaChannel = DMA_CH2;
+    _settings[2].spiRxDmaChannel = DMA_CH1;
+  #endif
+
+  // added for DMA callbacks.
+  _currentSetting->state = SPI_STATE_IDLE;
+}
+
+/*
+ * Set up/tear down
+ */
+void SPIClass::updateSettings() {
+  uint32_t flags = ((_currentSetting->bitOrder == MSBFIRST ? SPI_FRAME_MSB : SPI_FRAME_LSB) | _currentSetting->dataSize | SPI_SW_SLAVE | SPI_SOFT_SS);
+  spi_master_enable(_currentSetting->spi_d, (spi_baud_rate)_currentSetting->clockDivider, (spi_mode)_currentSetting->dataMode, flags);
+}
+
+void SPIClass::begin() {
+  spi_init(_currentSetting->spi_d);
+  configure_gpios(_currentSetting->spi_d, 1);
+  updateSettings();
+  // added for DMA callbacks.
+  _currentSetting->state = SPI_STATE_READY;
+}
+
+void SPIClass::beginSlave() {
+  spi_init(_currentSetting->spi_d);
+  configure_gpios(_currentSetting->spi_d, 0);
+  uint32_t flags = ((_currentSetting->bitOrder == MSBFIRST ? SPI_FRAME_MSB : SPI_FRAME_LSB) | _currentSetting->dataSize);
+  spi_slave_enable(_currentSetting->spi_d, (spi_mode)_currentSetting->dataMode, flags);
+  // added for DMA callbacks.
+  _currentSetting->state = SPI_STATE_READY;
+}
+
+void SPIClass::end() {
+  if (!spi_is_enabled(_currentSetting->spi_d))
+    return;
+
+  // Follows RM0008's sequence for disabling a SPI in master/slave
+  // full duplex mode.
+  while (spi_is_rx_nonempty(_currentSetting->spi_d)) {
+    // FIXME [0.1.0] remove this once you have an interrupt based driver
+    volatile uint16_t rx __attribute__((unused)) = spi_rx_reg(_currentSetting->spi_d);
+  }
+  while (!spi_is_tx_empty(_currentSetting->spi_d)) {};
+  while (spi_is_busy(_currentSetting->spi_d)) {};
+
+  spi_peripheral_disable(_currentSetting->spi_d);
+  // added for DMA callbacks.
+  // Need to add unsetting the callbacks for the DMA channels.
+  _currentSetting->state = SPI_STATE_IDLE;
+}
+
+/* Roger Clark added  3 functions */
+void SPIClass::setClockDivider(uint32_t clockDivider) {
+  _currentSetting->clockDivider = clockDivider;
+  uint32_t cr1 = _currentSetting->spi_d->regs->CR1 & ~(SPI_CR1_BR);
+  _currentSetting->spi_d->regs->CR1 = cr1 | (clockDivider & SPI_CR1_BR);
+}
+
+void SPIClass::setBitOrder(BitOrder bitOrder) {
+  _currentSetting->bitOrder = bitOrder;
+  uint32_t cr1 = _currentSetting->spi_d->regs->CR1 & ~(SPI_CR1_LSBFIRST);
+  if (bitOrder == LSBFIRST) cr1 |= SPI_CR1_LSBFIRST;
+  _currentSetting->spi_d->regs->CR1 = cr1;
+}
+
+/*  Victor Perez. Added to test changing datasize from 8 to 16 bit modes on the fly.
+* Input parameter should be SPI_CR1_DFF set to 0 or 1 on a 32bit word.
+*
+*/
+void SPIClass::setDataSize(uint32_t datasize) {
+  _currentSetting->dataSize = datasize;
+  uint32_t cr1 = _currentSetting->spi_d->regs->CR1 & ~(SPI_CR1_DFF);
+  uint8_t en = spi_is_enabled(_currentSetting->spi_d);
+  spi_peripheral_disable(_currentSetting->spi_d);
+  _currentSetting->spi_d->regs->CR1 = cr1 | (datasize & SPI_CR1_DFF) | en;
+}
+
+void SPIClass::setDataMode(uint8_t dataMode) {
+  /* Notes:
+  As far as I can tell, the AVR numbers for dataMode appear to match the numbers required by the STM32
+  From the AVR doc http://www.atmel.com/images/doc2585.pdf section 2.4
+  SPI Mode  CPOL  CPHA  Shift SCK-edge  Capture SCK-edge
+  0       0     0     Falling     Rising
+  1       0     1     Rising      Falling
+  2       1     0     Rising      Falling
+  3       1     1     Falling     Rising
+
+  On the STM32 it appears to be
+
+  bit 1 - CPOL : Clock polarity
+    (This bit should not be changed when communication is ongoing)
+    0 : CLK to 0 when idle
+    1 : CLK to 1 when idle
+
+  bit 0 - CPHA : Clock phase
+    (This bit should not be changed when communication is ongoing)
+    0 : The first clock transition is the first data capture edge
+    1 : The second clock transition is the first data capture edge
+
+  If someone finds this is not the case or sees a logic error with this let me know ;-)
+  */
+  _currentSetting->dataMode = dataMode;
+  uint32_t cr1 = _currentSetting->spi_d->regs->CR1 & ~(SPI_CR1_CPOL|SPI_CR1_CPHA);
+  _currentSetting->spi_d->regs->CR1 = cr1 | (dataMode & (SPI_CR1_CPOL|SPI_CR1_CPHA));
+}
+
+void SPIClass::beginTransaction(uint8_t pin, SPISettings settings) {
+  setBitOrder(settings.bitOrder);
+  setDataMode(settings.dataMode);
+  setDataSize(settings.dataSize);
+  setClockDivider(determine_baud_rate(_currentSetting->spi_d, settings.clock));
+  begin();
+}
+
+void SPIClass::beginTransactionSlave(SPISettings settings) {
+  setBitOrder(settings.bitOrder);
+  setDataMode(settings.dataMode);
+  setDataSize(settings.dataSize);
+  beginSlave();
+}
+
+void SPIClass::endTransaction() { }
+
+
+/*
+ * I/O
+ */
+
+uint16_t SPIClass::read() {
+  while ( spi_is_rx_nonempty(_currentSetting->spi_d)==0 ) ;
+  return (uint16)spi_rx_reg(_currentSetting->spi_d);
+}
+
+void SPIClass::read(uint8_t *buf, uint32_t len) {
+  if (len == 0) return;
+  spi_rx_reg(_currentSetting->spi_d);   // clear the RX buffer in case a byte is waiting on it.
+  spi_reg_map * regs = _currentSetting->spi_d->regs;
+  // start sequence: write byte 0
+  regs->DR = 0x00FF;            // write the first byte
+  // main loop
+  while ( (--len) ) {
+    while( !(regs->SR & SPI_SR_TXE) ); // wait for TXE flag
+    noInterrupts();    // go atomic level - avoid interrupts to surely get the previously received data
+    regs->DR = 0x00FF; // write the next data item to be transmitted into the SPI_DR register. This clears the TXE flag.
+    while ( !(regs->SR & SPI_SR_RXNE) ); // wait till data is available in the DR register
+    *buf++ = (uint8)(regs->DR); // read and store the received byte. This clears the RXNE flag.
+    interrupts();      // let systick do its job
+  }
+  // read remaining last byte
+  while ( !(regs->SR & SPI_SR_RXNE) ) {} // wait till data is available in the Rx register
+  *buf++ = (uint8)(regs->DR);  // read and store the received byte
+}
+
+void SPIClass::write(uint16_t data) {
+  /* Added for 16bit data Victor Perez. Roger Clark
+   * Improved speed by just directly writing the single byte to the SPI data reg and wait for completion,
+   * by taking the Tx code from transfer(byte)
+   * This almost doubles the speed of this function.
+   */
+  spi_tx_reg(_currentSetting->spi_d, data); // write the data to be transmitted into the SPI_DR register (this clears the TXE flag)
+  while (spi_is_tx_empty(_currentSetting->spi_d) == 0); // "5. Wait until TXE=1 ..."
+  while (spi_is_busy(_currentSetting->spi_d) != 0); // "... and then wait until BSY=0 before disabling the SPI."
+}
+
+void SPIClass::write16(uint16_t data) {
+  // Added by stevestrong: write two consecutive bytes in 8 bit mode (DFF=0)
+  spi_tx_reg(_currentSetting->spi_d, data>>8); // write high byte
+  while (spi_is_tx_empty(_currentSetting->spi_d) == 0); // Wait until TXE=1
+  spi_tx_reg(_currentSetting->spi_d, data); // write low byte
+  while (spi_is_tx_empty(_currentSetting->spi_d) == 0); // Wait until TXE=1
+  while (spi_is_busy(_currentSetting->spi_d) != 0); // wait until BSY=0
+}
+
+void SPIClass::write(uint16_t data, uint32_t n) {
+  // Added by stevstrong: Repeatedly send same data by the specified number of times
+  spi_reg_map * regs = _currentSetting->spi_d->regs;
+  while ( (n--)>0 ) {
+    regs->DR = data; // write the data to be transmitted into the SPI_DR register (this clears the TXE flag)
+    while ( (regs->SR & SPI_SR_TXE)==0 ) ; // wait till Tx empty
+  }
+  while ( (regs->SR & SPI_SR_BSY) != 0); // wait until BSY=0 before returning
+}
+
+void SPIClass::write(const void *data, uint32_t length) {
+  spi_dev * spi_d = _currentSetting->spi_d;
+  spi_tx(spi_d, data, length); // data can be array of bytes or words
+  while (spi_is_tx_empty(spi_d) == 0); // "5. Wait until TXE=1 ..."
+  while (spi_is_busy(spi_d) != 0); // "... and then wait until BSY=0 before disabling the SPI."
+}
+
+uint8_t SPIClass::transfer(uint8_t byte) const {
+  spi_dev * spi_d = _currentSetting->spi_d;
+  spi_rx_reg(spi_d); // read any previous data
+  spi_tx_reg(spi_d, byte); // Write the data item to be transmitted into the SPI_DR register
+  while (spi_is_tx_empty(spi_d) == 0); // "5. Wait until TXE=1 ..."
+  while (spi_is_busy(spi_d) != 0); // "... and then wait until BSY=0 before disabling the SPI."
+  return (uint8)spi_rx_reg(spi_d); // "... and read the last received data."
+}
+
+uint16_t SPIClass::transfer16(uint16_t data) const {
+  // Modified by stevestrong: write & read two consecutive bytes in 8 bit mode (DFF=0)
+  // This is more effective than two distinct byte transfers
+  spi_dev * spi_d = _currentSetting->spi_d;
+  spi_rx_reg(spi_d);                   // read any previous data
+  spi_tx_reg(spi_d, data>>8);          // write high byte
+  while (spi_is_tx_empty(spi_d) == 0); // wait until TXE=1
+  while (spi_is_busy(spi_d) != 0);     // wait until BSY=0
+  uint16_t ret = spi_rx_reg(spi_d)<<8; // read and shift high byte
+  spi_tx_reg(spi_d, data);             // write low byte
+  while (spi_is_tx_empty(spi_d) == 0); // wait until TXE=1
+  while (spi_is_busy(spi_d) != 0);     // wait until BSY=0
+  ret += spi_rx_reg(spi_d);            // read low byte
+  return ret;
+}
+
+/*  Roger Clark and Victor Perez, 2015
+* Performs a DMA SPI transfer with at least a receive buffer.
+* If a TX buffer is not provided, FF is sent over and over for the lenght of the transfer.
+* On exit TX buffer is not modified, and RX buffer cotains the received data.
+* Still in progress.
+*/
+void SPIClass::dmaTransferSet(const void *transmitBuf, void *receiveBuf) {
+  dma_init(_currentSetting->spiDmaDev);
+  //spi_rx_dma_enable(_currentSetting->spi_d);
+  //spi_tx_dma_enable(_currentSetting->spi_d);
+  dma_xfer_size dma_bit_size = (_currentSetting->dataSize==DATA_SIZE_16BIT) ? DMA_SIZE_16BITS : DMA_SIZE_8BITS;
+  dma_setup_transfer(_currentSetting->spiDmaDev, _currentSetting->spiRxDmaChannel, &_currentSetting->spi_d->regs->DR,
+      dma_bit_size, receiveBuf, dma_bit_size, (DMA_MINC_MODE | DMA_TRNS_CMPLT ));// receive buffer DMA
+  if (!transmitBuf) {
+    transmitBuf = &ff;
+    dma_setup_transfer(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel, &_currentSetting->spi_d->regs->DR,
+        dma_bit_size, (volatile void*)transmitBuf, dma_bit_size, (DMA_FROM_MEM));// Transmit FF repeatedly
+  }
+  else {
+    dma_setup_transfer(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel, &_currentSetting->spi_d->regs->DR,
+        dma_bit_size, (volatile void*)transmitBuf, dma_bit_size, (DMA_MINC_MODE |  DMA_FROM_MEM ));// Transmit buffer DMA
+  }
+  dma_set_priority(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel, DMA_PRIORITY_LOW);
+  dma_set_priority(_currentSetting->spiDmaDev, _currentSetting->spiRxDmaChannel, DMA_PRIORITY_VERY_HIGH);
+}
+
+uint8_t SPIClass::dmaTransferRepeat(uint16_t length) {
+  if (length == 0) return 0;
+  if (spi_is_rx_nonempty(_currentSetting->spi_d) == 1) spi_rx_reg(_currentSetting->spi_d);
+  _currentSetting->state = SPI_STATE_TRANSFER;
+  dma_set_num_transfers(_currentSetting->spiDmaDev, _currentSetting->spiRxDmaChannel, length);
+  dma_set_num_transfers(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel, length);
+  dma_enable(_currentSetting->spiDmaDev, _currentSetting->spiRxDmaChannel);// enable receive
+  dma_enable(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel);// enable transmit
+  spi_rx_dma_enable(_currentSetting->spi_d);
+  spi_tx_dma_enable(_currentSetting->spi_d);
+  if (_currentSetting->receiveCallback)
+    return 0;
+
+  //uint32_t m = millis();
+  uint8_t b = 0;
+  uint32_t m = millis();
+  while ((dma_get_isr_bits(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel) & DMA_ISR_TCIF1) == 0) {
+    //Avoid interrupts and just loop waiting for the flag to be set.
+    if ((millis() - m) > DMA_TIMEOUT) { b = 2; break; }
+  }
+
+  while (spi_is_tx_empty(_currentSetting->spi_d) == 0); // "5. Wait until TXE=1 ..."
+  while (spi_is_busy(_currentSetting->spi_d) != 0); // "... and then wait until BSY=0 before disabling the SPI."
+  spi_tx_dma_disable(_currentSetting->spi_d);
+  spi_rx_dma_disable(_currentSetting->spi_d);
+  dma_disable(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel);
+  dma_disable(_currentSetting->spiDmaDev, _currentSetting->spiRxDmaChannel);
+  dma_clear_isr_bits(_currentSetting->spiDmaDev, _currentSetting->spiRxDmaChannel);
+  dma_clear_isr_bits(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel);
+  _currentSetting->state = SPI_STATE_READY;
+  return b;
+}
+
+/* Roger Clark and Victor Perez, 2015
+ * Performs a DMA SPI transfer with at least a receive buffer.
+ * If a TX buffer is not provided, FF is sent over and over for the length of the transfer.
+ * On exit TX buffer is not modified, and RX buffer contains the received data.
+ * Still in progress.
+ */
+uint8_t SPIClass::dmaTransfer(const void *transmitBuf, void *receiveBuf, uint16_t length) {
+  dmaTransferSet(transmitBuf, receiveBuf);
+  return dmaTransferRepeat(length);
+}
+
+/* Roger Clark and Victor Perez, 2015
+ * Performs a DMA SPI send using a TX buffer.
+ * On exit TX buffer is not modified.
+ * Still in progress.
+ * 2016 - stevstrong - reworked to automatically detect bit size from SPI setting
+ */
+void SPIClass::dmaSendSet(const void * transmitBuf, bool minc) {
+  uint32_t flags = ( (DMA_MINC_MODE*minc) | DMA_FROM_MEM | DMA_TRNS_CMPLT);
+  dma_init(_currentSetting->spiDmaDev);
+  dma_xfer_size dma_bit_size = (_currentSetting->dataSize==DATA_SIZE_16BIT) ? DMA_SIZE_16BITS : DMA_SIZE_8BITS;
+  dma_setup_transfer(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel, &_currentSetting->spi_d->regs->DR, dma_bit_size,
+             (volatile void*)transmitBuf, dma_bit_size, flags);// Transmit buffer DMA
+  dma_set_priority(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel, DMA_PRIORITY_LOW);
+}
+
+uint8_t SPIClass::dmaSendRepeat(uint16_t length) {
+  if (length == 0) return 0;
+
+  dma_clear_isr_bits(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel);
+  dma_set_num_transfers(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel, length);
+  _currentSetting->state = SPI_STATE_TRANSMIT;
+  dma_enable(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel);// enable transmit
+  spi_tx_dma_enable(_currentSetting->spi_d);
+  if (_currentSetting->transmitCallback)
+    return 0;
+
+  uint32_t m = millis();
+  uint8_t b = 0;
+  while ((dma_get_isr_bits(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel) & DMA_ISR_TCIF1)==0) {
+    //Avoid interrupts and just loop waiting for the flag to be set.
+    if ((millis() - m) > DMA_TIMEOUT) { b = 2; break; }
+  }
+  while (spi_is_tx_empty(_currentSetting->spi_d) == 0); // "5. Wait until TXE=1 ..."
+  while (spi_is_busy(_currentSetting->spi_d) != 0); // "... and then wait until BSY=0 before disabling the SPI."
+  spi_tx_dma_disable(_currentSetting->spi_d);
+  dma_disable(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel);
+  dma_clear_isr_bits(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel);
+  _currentSetting->state = SPI_STATE_READY;
+  return b;
+}
+
+uint8_t SPIClass::dmaSend(const void * transmitBuf, uint16_t length, bool minc) {
+  dmaSendSet(transmitBuf, minc);
+  return dmaSendRepeat(length);
+}
+
+uint8_t SPIClass::dmaSendAsync(const void * transmitBuf, uint16_t length, bool minc) {
+  uint8_t b = 0;
+
+  if (_currentSetting->state != SPI_STATE_READY) {
+    uint32_t m = millis();
+    while ((dma_get_isr_bits(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel) & DMA_ISR_TCIF1)==0) {
+      //Avoid interrupts and just loop waiting for the flag to be set.
+      //delayMicroseconds(10);
+      if ((millis() - m) > DMA_TIMEOUT) { b = 2; break; }
+    }
+
+    while (spi_is_tx_empty(_currentSetting->spi_d) == 0); // "5. Wait until TXE=1 ..."
+    while (spi_is_busy(_currentSetting->spi_d) != 0); // "... and then wait until BSY=0 before disabling the SPI."
+    spi_tx_dma_disable(_currentSetting->spi_d);
+    dma_disable(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel);
+    _currentSetting->state = SPI_STATE_READY;
+  }
+
+  if (length == 0) return 0;
+  uint32_t flags = ( (DMA_MINC_MODE*minc) | DMA_FROM_MEM | DMA_TRNS_CMPLT);
+
+  dma_init(_currentSetting->spiDmaDev);
+  // TX
+  dma_xfer_size dma_bit_size = (_currentSetting->dataSize==DATA_SIZE_16BIT) ? DMA_SIZE_16BITS : DMA_SIZE_8BITS;
+  dma_setup_transfer(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel, &_currentSetting->spi_d->regs->DR,
+      dma_bit_size, (volatile void*)transmitBuf, dma_bit_size, flags);// Transmit buffer DMA
+  dma_set_num_transfers(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel, length);
+  dma_clear_isr_bits(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel);
+  dma_enable(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel);// enable transmit
+  spi_tx_dma_enable(_currentSetting->spi_d);
+
+  _currentSetting->state = SPI_STATE_TRANSMIT;
+  return b;
+}
+
+
+/**
+ *  New functions added to manage callbacks.
+ *  Victor Perez 2017
+ */
+void SPIClass::onReceive(void(*callback)(void)) {
+  _currentSetting->receiveCallback = callback;
+  if (callback) {
+    switch (_currentSetting->spi_d->clk_id) {
+    #if BOARD_NR_SPI >= 1
+    case RCC_SPI1:
+      dma_attach_interrupt(_currentSetting->spiDmaDev, _currentSetting->spiRxDmaChannel, &SPIClass::_spi1EventCallback);
+      break;
+    #endif
+    #if BOARD_NR_SPI >= 2
+    case RCC_SPI2:
+      dma_attach_interrupt(_currentSetting->spiDmaDev, _currentSetting->spiRxDmaChannel, &SPIClass::_spi2EventCallback);
+      break;
+    #endif
+    #if BOARD_NR_SPI >= 3
+    case RCC_SPI3:
+      dma_attach_interrupt(_currentSetting->spiDmaDev, _currentSetting->spiRxDmaChannel, &SPIClass::_spi3EventCallback);
+      break;
+    #endif
+    default:
+      ASSERT(0);
+    }
+  }
+  else {
+    dma_detach_interrupt(_currentSetting->spiDmaDev, _currentSetting->spiRxDmaChannel);
+  }
+}
+
+void SPIClass::onTransmit(void(*callback)(void)) {
+  _currentSetting->transmitCallback = callback;
+  if (callback) {
+    switch (_currentSetting->spi_d->clk_id) {
+    #if BOARD_NR_SPI >= 1
+    case RCC_SPI1:
+      dma_attach_interrupt(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel, &SPIClass::_spi1EventCallback);
+      break;
+    #endif
+    #if BOARD_NR_SPI >= 2
+     case RCC_SPI2:
+      dma_attach_interrupt(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel, &SPIClass::_spi2EventCallback);
+      break;
+    #endif
+    #if BOARD_NR_SPI >= 3
+    case RCC_SPI3:
+      dma_attach_interrupt(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel, &SPIClass::_spi3EventCallback);
+      break;
+    #endif
+    default:
+      ASSERT(0);
+    }
+  }
+  else {
+    dma_detach_interrupt(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel);
+  }
+}
+
+/**
+ * TODO: check if better to first call the customer code, next disable the DMA requests.
+ * Also see if we need to check whether callbacks are set or not, may be better to be checked
+ * during the initial setup and only set the callback to EventCallback if they are set.
+ */
+void SPIClass::EventCallback() {
+  while (spi_is_tx_empty(_currentSetting->spi_d) == 0); // "5. Wait until TXE=1 ..."
+  while (spi_is_busy(_currentSetting->spi_d) != 0); // "... and then wait until BSY=0"
+  switch (_currentSetting->state) {
+  case SPI_STATE_TRANSFER:
+    while (spi_is_rx_nonempty(_currentSetting->spi_d));
+    _currentSetting->state = SPI_STATE_READY;
+    spi_tx_dma_disable(_currentSetting->spi_d);
+    spi_rx_dma_disable(_currentSetting->spi_d);
+    //dma_disable(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel);
+    //dma_disable(_currentSetting->spiDmaDev, _currentSetting->spiRxDmaChannel);
+    if (_currentSetting->receiveCallback)
+      _currentSetting->receiveCallback();
+    break;
+  case SPI_STATE_TRANSMIT:
+    _currentSetting->state = SPI_STATE_READY;
+    spi_tx_dma_disable(_currentSetting->spi_d);
+    //dma_disable(_currentSetting->spiDmaDev, _currentSetting->spiTxDmaChannel);
+    if (_currentSetting->transmitCallback)
+      _currentSetting->transmitCallback();
+    break;
+  default:
+    break;
+  }
+}
+
+void SPIClass::attachInterrupt() {
+  // Should be enableInterrupt()
+}
+
+void SPIClass::detachInterrupt() {
+  // Should be disableInterrupt()
+}
+
+/*
+ * Pin accessors
+ */
+
+uint8_t SPIClass::misoPin() {
+  return dev_to_spi_pins(_currentSetting->spi_d)->miso;
+}
+
+uint8_t SPIClass::mosiPin() {
+  return dev_to_spi_pins(_currentSetting->spi_d)->mosi;
+}
+
+uint8_t SPIClass::sckPin() {
+  return dev_to_spi_pins(_currentSetting->spi_d)->sck;
+}
+
+uint8_t SPIClass::nssPin() {
+  return dev_to_spi_pins(_currentSetting->spi_d)->nss;
+}
+
+/*
+ * Deprecated functions
+ */
+
+uint8_t SPIClass::send(uint8_t data) {
+  this->write(data);
+  return 1;
+}
+
+uint8_t SPIClass::send(uint8_t *buf, uint32_t len) {
+  this->write(buf, len);
+  return len;
+}
+
+uint8_t SPIClass::recv() {
+  return this->read();
+}
+
+/*
+ * DMA call back functions, one per port.
+ */
+#if BOARD_NR_SPI >= 1
+  void SPIClass::_spi1EventCallback() {
+    reinterpret_cast<class SPIClass*>(_spi1_this)->EventCallback();
+  }
+#endif
+#if BOARD_NR_SPI >= 2
+  void SPIClass::_spi2EventCallback() {
+    reinterpret_cast<class SPIClass*>(_spi2_this)->EventCallback();
+  }
+#endif
+#if BOARD_NR_SPI >= 3
+  void SPIClass::_spi3EventCallback() {
+    reinterpret_cast<class SPIClass*>(_spi3_this)->EventCallback();
+  }
+#endif
+
+/*
+ * Auxiliary functions
+ */
+static const spi_pins* dev_to_spi_pins(spi_dev *dev) {
+  switch (dev->clk_id) {
+    #if BOARD_NR_SPI >= 1
+      case RCC_SPI1: return board_spi_pins;
+    #endif
+    #if BOARD_NR_SPI >= 2
+      case RCC_SPI2: return board_spi_pins + 1;
+    #endif
+    #if BOARD_NR_SPI >= 3
+      case RCC_SPI3: return board_spi_pins + 2;
+    #endif
+    default: return NULL;
+  }
+}
+
+static void disable_pwm(const stm32_pin_info *i) {
+  if (i->timer_device)
+    timer_set_mode(i->timer_device, i->timer_channel, TIMER_DISABLED);
+}
+
+static void configure_gpios(spi_dev *dev, bool as_master) {
+  const spi_pins *pins = dev_to_spi_pins(dev);
+  if (!pins) return;
+
+  const stm32_pin_info *nssi = &PIN_MAP[pins->nss],
+                       *scki = &PIN_MAP[pins->sck],
+                       *misoi = &PIN_MAP[pins->miso],
+                       *mosii = &PIN_MAP[pins->mosi];
+
+  disable_pwm(nssi);
+  disable_pwm(scki);
+  disable_pwm(misoi);
+  disable_pwm(mosii);
+
+  spi_config_gpios(dev, as_master, nssi->gpio_device, nssi->gpio_bit,
+  scki->gpio_device, scki->gpio_bit, misoi->gpio_bit,
+  mosii->gpio_bit);
+}
+
+static const spi_baud_rate baud_rates[8] __FLASH__ = {
+  SPI_BAUD_PCLK_DIV_2,
+  SPI_BAUD_PCLK_DIV_4,
+  SPI_BAUD_PCLK_DIV_8,
+  SPI_BAUD_PCLK_DIV_16,
+  SPI_BAUD_PCLK_DIV_32,
+  SPI_BAUD_PCLK_DIV_64,
+  SPI_BAUD_PCLK_DIV_128,
+  SPI_BAUD_PCLK_DIV_256,
+};
+
+/*
+* Note: This assumes you're on a LeafLabs-style board
+* (CYCLES_PER_MICROSECOND == 72, APB2 at 72MHz, APB1 at 36MHz).
+*/
+static spi_baud_rate determine_baud_rate(spi_dev *dev, uint32_t freq) {
+  uint32_t clock = 0;
+  switch (rcc_dev_clk(dev->clk_id)) {
+    case RCC_AHB:
+    case RCC_APB2: clock = STM32_PCLK2; break; // 72 Mhz
+    case RCC_APB1: clock = STM32_PCLK1; break; // 36 Mhz
+  }
+  clock >>= 1;
+
+  uint8_t i = 0;
+  while (i < 7 && freq < clock) { clock >>= 1; i++; }
+  return baud_rates[i];
+}
+
+SPIClass SPI(1);
+
+#endif // __STM32F1__
@@ -0,0 +1,409 @@
+/******************************************************************************
+ * The MIT License
+ *
+ * Copyright (c) 2010 Perry Hung.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy,
+ * modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *****************************************************************************/
+#pragma once
+
+#include <libmaple/libmaple_types.h>
+#include <libmaple/spi.h>
+#include <libmaple/dma.h>
+
+#include <boards.h>
+#include <stdint.h>
+#include <wirish.h>
+
+// SPI_HAS_TRANSACTION means SPI has
+//   - beginTransaction()
+//   - endTransaction()
+//   - usingInterrupt()
+//   - SPISetting(clock, bitOrder, dataMode)
+//#define SPI_HAS_TRANSACTION
+
+#define SPI_CLOCK_DIV2   SPI_BAUD_PCLK_DIV_2
+#define SPI_CLOCK_DIV4   SPI_BAUD_PCLK_DIV_4
+#define SPI_CLOCK_DIV8   SPI_BAUD_PCLK_DIV_8
+#define SPI_CLOCK_DIV16  SPI_BAUD_PCLK_DIV_16
+#define SPI_CLOCK_DIV32  SPI_BAUD_PCLK_DIV_32
+#define SPI_CLOCK_DIV64  SPI_BAUD_PCLK_DIV_64
+#define SPI_CLOCK_DIV128 SPI_BAUD_PCLK_DIV_128
+#define SPI_CLOCK_DIV256 SPI_BAUD_PCLK_DIV_256
+
+/*
+ * Roger Clark. 20150106
+ * Commented out redundant AVR defined
+ *
+#define SPI_MODE_MASK 0x0C     // CPOL = bit 3, CPHA = bit 2 on SPCR
+#define SPI_CLOCK_MASK 0x03    // SPR1 = bit 1, SPR0 = bit 0 on SPCR
+#define SPI_2XCLOCK_MASK 0x01  // SPI2X = bit 0 on SPSR
+
+// define SPI_AVR_EIMSK for AVR boards with external interrupt pins
+#if defined(EIMSK)
+  #define SPI_AVR_EIMSK EIMSK
+#elif defined(GICR)
+  #define SPI_AVR_EIMSK GICR
+#elif defined(GIMSK)
+  #define SPI_AVR_EIMSK GIMSK
+#endif
+*/
+
+#ifndef STM32_LSBFIRST
+  #define STM32_LSBFIRST 0
+#endif
+#ifndef STM32_MSBFIRST
+  #define STM32_MSBFIRST 1
+#endif
+
+// PC13 or PA4
+#define BOARD_SPI_DEFAULT_SS PA4
+//#define BOARD_SPI_DEFAULT_SS PC13
+
+#define SPI_MODE0 SPI_MODE_0
+#define SPI_MODE1 SPI_MODE_1
+#define SPI_MODE2 SPI_MODE_2
+#define SPI_MODE3 SPI_MODE_3
+
+#define DATA_SIZE_8BIT SPI_CR1_DFF_8_BIT
+#define DATA_SIZE_16BIT SPI_CR1_DFF_16_BIT
+
+typedef enum {
+  SPI_STATE_IDLE,
+  SPI_STATE_READY,
+  SPI_STATE_RECEIVE,
+  SPI_STATE_TRANSMIT,
+  SPI_STATE_TRANSFER
+} spi_mode_t;
+
+class SPISettings {
+public:
+  SPISettings(uint32_t clock, BitOrder bitOrder, uint8_t dataMode) {
+    if (__builtin_constant_p(clock))
+      init_AlwaysInline(clock, bitOrder, dataMode, DATA_SIZE_8BIT);
+    else
+      init_MightInline(clock, bitOrder, dataMode, DATA_SIZE_8BIT);
+  }
+  SPISettings(uint32_t clock, BitOrder bitOrder, uint8_t dataMode, uint32_t dataSize) {
+    if (__builtin_constant_p(clock))
+      init_AlwaysInline(clock, bitOrder, dataMode, dataSize);
+    else
+      init_MightInline(clock, bitOrder, dataMode, dataSize);
+  }
+  SPISettings(uint32_t clock) {
+    if (__builtin_constant_p(clock))
+      init_AlwaysInline(clock, MSBFIRST, SPI_MODE0, DATA_SIZE_8BIT);
+    else
+      init_MightInline(clock, MSBFIRST, SPI_MODE0, DATA_SIZE_8BIT);
+  }
+  SPISettings() {
+    init_AlwaysInline(4000000, MSBFIRST, SPI_MODE0, DATA_SIZE_8BIT);
+  }
+private:
+  void init_MightInline(uint32_t clock, BitOrder bitOrder, uint8_t dataMode, uint32_t dataSize) {
+    init_AlwaysInline(clock, bitOrder, dataMode, dataSize);
+  }
+  void init_AlwaysInline(uint32_t clock, BitOrder bitOrder, uint8_t dataMode, uint32_t dataSize) __attribute__((__always_inline__)) {
+    this->clock = clock;
+    this->bitOrder = bitOrder;
+    this->dataMode = dataMode;
+    this->dataSize = dataSize;
+  }
+  uint32_t clock;
+  uint32_t dataSize;
+  uint32_t clockDivider;
+  BitOrder bitOrder;
+  uint8_t dataMode;
+  uint8_t _SSPin;
+  volatile spi_mode_t state;
+  spi_dev *spi_d;
+  dma_channel spiRxDmaChannel, spiTxDmaChannel;
+  dma_dev* spiDmaDev;
+  void (*receiveCallback)(void) = NULL;
+  void (*transmitCallback)(void) = NULL;
+
+  friend class SPIClass;
+};
+
+/*
+ * Kept for compat.
+ */
+static const uint8_t ff = 0xFF;
+
+/**
+ * @brief Wirish SPI interface.
+ *
+ * This implementation uses software slave management, so the caller
+ * is responsible for controlling the slave select line.
+ */
+class SPIClass {
+
+public:
+  /**
+   * @param spiPortNumber Number of the SPI port to manage.
+   */
+  SPIClass(uint32_t spiPortNumber);
+
+  /**
+   * @brief Equivalent to begin(SPI_1_125MHZ, MSBFIRST, 0).
+   */
+  void begin();
+
+  /**
+   * @brief Turn on a SPI port and set its GPIO pin modes for use as a slave.
+   *
+   * SPI port is enabled in full duplex mode, with software slave management.
+   *
+   * @param bitOrder Either LSBFIRST (little-endian) or MSBFIRST(big-endian)
+   * @param mode SPI mode to use
+   */
+  void beginSlave(uint32_t bitOrder, uint32_t mode);
+
+  /**
+   * @brief Equivalent to beginSlave(MSBFIRST, 0).
+   */
+  void beginSlave();
+
+  /**
+   * @brief Disables the SPI port, but leaves its GPIO pin modes unchanged.
+   */
+  void end();
+
+  void beginTransaction(SPISettings settings) { beginTransaction(BOARD_SPI_DEFAULT_SS, settings); }
+  void beginTransaction(uint8_t pin, SPISettings settings);
+  void endTransaction();
+
+  void beginTransactionSlave(SPISettings settings);
+
+  void setClockDivider(uint32_t clockDivider);
+  void setBitOrder(BitOrder bitOrder);
+  void setDataMode(uint8_t dataMode);
+
+  // SPI Configuration methods
+  void attachInterrupt();
+  void detachInterrupt();
+
+  /* Victor Perez. Added to change datasize from 8 to 16 bit modes on the fly.
+   * Input parameter should be SPI_CR1_DFF set to 0 or 1 on a 32bit word.
+   * Requires an added function spi_data_size on STM32F1 / cores / maple / libmaple / spi.c
+   */
+  void setDataSize(uint32_t ds);
+
+  /* Victor Perez 2017. Added to set and clear callback functions for callback
+   * on DMA transfer completion.
+   * onReceive used to set the callback in case of dmaTransfer (tx/rx), once rx is completed
+   * onTransmit used to set the callback in case of dmaSend (tx only). That function
+   * will NOT be called in case of TX/RX
+   */
+  void onReceive(void(*)(void));
+  void onTransmit(void(*)(void));
+
+  /*
+   * I/O
+   */
+
+  /**
+   * @brief Return the next unread byte/word.
+   *
+   * If there is no unread byte/word waiting, this function will block
+   * until one is received.
+   */
+  uint16_t read();
+
+  /**
+   * @brief Read length bytes, storing them into buffer.
+   * @param buffer Buffer to store received bytes into.
+   * @param length Number of bytes to store in buffer. This
+   *               function will block until the desired number of
+   *               bytes have been read.
+   */
+  void read(uint8_t *buffer, uint32_t length);
+
+  /**
+   * @brief Transmit one byte/word.
+   * @param data to transmit.
+   */
+  void write(uint16_t data);
+  void write16(uint16_t data); // write 2 bytes in 8 bit mode (DFF=0)
+
+  /**
+   * @brief Transmit one byte/word a specified number of times.
+   * @param data to transmit.
+   */
+  void write(uint16_t data, uint32_t n);
+
+  /**
+   * @brief Transmit multiple bytes/words.
+   * @param buffer Bytes/words to transmit.
+   * @param length Number of bytes/words in buffer to transmit.
+   */
+  void write(const void * buffer, uint32_t length);
+
+  /**
+   * @brief Transmit a byte, then return the next unread byte.
+   *
+   * This function transmits before receiving.
+   *
+   * @param data Byte to transmit.
+   * @return Next unread byte.
+   */
+  uint8_t transfer(uint8_t data) const;
+  uint16_t transfer16(uint16_t data) const;
+
+  /**
+   * @brief Sets up a DMA Transfer for "length" bytes.
+   * The transfer mode (8 or 16 bit mode) is evaluated from the SPI peripheral setting.
+   *
+   * This function transmits and receives to buffers.
+   *
+   * @param transmitBuf buffer Bytes to transmit. If passed as 0, it sends FF repeatedly for "length" bytes
+   * @param receiveBuf buffer Bytes to save received data.
+   * @param length Number of bytes in buffer to transmit.
+   */
+  uint8_t dmaTransfer(const void * transmitBuf, void * receiveBuf, uint16_t length);
+  void dmaTransferSet(const void *transmitBuf, void *receiveBuf);
+  uint8_t dmaTransferRepeat(uint16_t length);
+
+  /**
+   * @brief Sets up a DMA Transmit for SPI 8 or 16 bit transfer mode.
+   * The transfer mode (8 or 16 bit mode) is evaluated from the SPI peripheral setting.
+   *
+   * This function only transmits and does not care about the RX fifo.
+   *
+   * @param data buffer half words to transmit,
+   * @param length Number of bytes in buffer to transmit.
+   * @param minc Set to use Memory Increment mode, clear to use Circular mode.
+   */
+  uint8_t dmaSend(const void * transmitBuf, uint16_t length, bool minc = 1);
+  void dmaSendSet(const void * transmitBuf, bool minc);
+  uint8_t dmaSendRepeat(uint16_t length);
+
+  uint8_t dmaSendAsync(const void * transmitBuf, uint16_t length, bool minc = 1);
+  /*
+   * Pin accessors
+   */
+
+  /**
+   * @brief Return the number of the MISO (master in, slave out) pin
+   */
+  uint8_t misoPin();
+
+  /**
+   * @brief Return the number of the MOSI (master out, slave in) pin
+   */
+  uint8_t mosiPin();
+
+  /**
+   * @brief Return the number of the SCK (serial clock) pin
+   */
+  uint8_t sckPin();
+
+  /**
+   * @brief Return the number of the NSS (slave select) pin
+   */
+  uint8_t nssPin();
+
+  /* Escape hatch */
+
+  /**
+   * @brief Get a pointer to the underlying libmaple spi_dev for
+   *        this HardwareSPI instance.
+   */
+  spi_dev* c_dev(void) { return _currentSetting->spi_d; }
+
+  spi_dev* dev() { return _currentSetting->spi_d; }
+
+  /**
+   * @brief Sets the number of the SPI peripheral to be used by
+   *        this HardwareSPI instance.
+   *
+   * @param spi_num Number of the SPI port. 1-2 in low density devices
+   *     or 1-3 in high density devices.
+   */
+  void setModule(int spi_num) {
+    _currentSetting=&_settings[spi_num-1];// SPI channels are called 1 2 and 3 but the array is zero indexed
+  }
+
+  /* -- The following methods are deprecated --------------------------- */
+
+  /**
+   * @brief Deprecated.
+   *
+   * Use HardwareSPI::transfer() instead.
+   *
+   * @see HardwareSPI::transfer()
+   */
+  uint8_t send(uint8_t data);
+
+  /**
+   * @brief Deprecated.
+   *
+   * Use HardwareSPI::write() in combination with
+   * HardwareSPI::read() (or HardwareSPI::transfer()) instead.
+   *
+   * @see HardwareSPI::write()
+   * @see HardwareSPI::read()
+   * @see HardwareSPI::transfer()
+   */
+  uint8_t send(uint8_t *data, uint32_t length);
+
+  /**
+   * @brief Deprecated.
+   *
+   * Use HardwareSPI::read() instead.
+   *
+   * @see HardwareSPI::read()
+   */
+  uint8_t recv();
+
+private:
+
+  SPISettings _settings[BOARD_NR_SPI];
+  SPISettings *_currentSetting;
+
+  void updateSettings();
+
+  /*
+   * Functions added for DMA transfers with Callback.
+   * Experimental.
+   */
+
+  void EventCallback();
+
+  #if BOARD_NR_SPI >= 1
+    static void _spi1EventCallback();
+  #endif
+  #if BOARD_NR_SPI >= 2
+    static void _spi2EventCallback();
+  #endif
+  #if BOARD_NR_SPI >= 3
+    static void _spi3EventCallback();
+  #endif
+  /*
+  spi_dev *spi_d;
+  uint8_t _SSPin;
+  uint32_t clockDivider;
+  uint8_t dataMode;
+  BitOrder bitOrder;
+  */
+};
+
+extern SPIClass SPI;
@@ -0,0 +1,60 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * 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/>.
+ *
+ */
+#if defined(__STM32F1__) && !defined(HAVE_SW_SERIAL)
+
+/**
+ * Empty class for Software Serial implementation (Custom RX/TX pins)
+ *
+ * TODO: Optionally use https://github.com/FYSETC/SoftwareSerialM if TMC UART is wanted
+ */
+
+#include "SoftwareSerial.h"
+
+// Constructor
+
+SoftwareSerial::SoftwareSerial(int8_t RX_pin, int8_t TX_pin) {}
+
+// Public
+
+void SoftwareSerial::begin(const uint32_t baudrate) {
+}
+
+bool SoftwareSerial::available() {
+  return false;
+}
+
+uint8_t SoftwareSerial::read() {
+  return 0;
+}
+
+uint16_t SoftwareSerial::write(uint8_t byte) {
+  return 0;
+}
+
+void SoftwareSerial::flush() {}
+
+void SoftwareSerial::listen() {
+  listening = true;
+}
+
+void SoftwareSerial::stopListening() {
+  listening = false;
+}
+
+#endif //__STM32F1__
@@ -0,0 +1,42 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#pragma once
+
+#include <stdint.h>
+
+#define SW_SERIAL_PLACEHOLDER 1
+
+class SoftwareSerial {
+public:
+  SoftwareSerial(int8_t RX_pin, int8_t TX_pin);
+
+  void begin(const uint32_t baudrate);
+
+  bool available();
+
+  uint8_t read();
+  uint16_t write(uint8_t byte);
+  void flush();
+
+  void listen();
+  void stopListening();
+
+protected:
+  bool listening;
+};
@@ -38,8 +38,8 @@
 #define _SET_OUTPUT(IO)       _SET_MODE(IO, GPIO_OUTPUT_PP)
 #define _SET_OUTPUT_OD(IO)    _SET_MODE(IO, GPIO_OUTPUT_OD)

-#define OUT_WRITE(IO,V)       do{ _SET_OUTPUT(IO); WRITE(IO,V); } while(0)
-#define OUT_WRITE_OD(IO,V)    do{ _SET_OUTPUT_OD(IO); WRITE(IO,V); } while(0)
+#define OUT_WRITE(IO,V)       do{ _SET_OUTPUT(IO); WRITE(IO,V); }while(0)
+#define OUT_WRITE_OD(IO,V)    do{ _SET_OUTPUT_OD(IO); WRITE(IO,V); }while(0)

 #define SET_INPUT(IO)         _SET_MODE(IO, GPIO_INPUT_FLOATING)
 #define SET_INPUT_PULLUP(IO)  _SET_MODE(IO, GPIO_INPUT_PU)
@@ -26,7 +26,18 @@

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

-bool PersistentStore::access_start() { return true; }
+bool PersistentStore::access_start() {
+  #if ENABLED(SPI_EEPROM)
+    #if SPI_CHAN_EEPROM1 == 1
+      SET_OUTPUT(BOARD_SPI1_SCK_PIN);
+      SET_OUTPUT(BOARD_SPI1_MOSI_PIN);
+      SET_INPUT(BOARD_SPI1_MISO_PIN);
+      SET_OUTPUT(SPI_EEPROM1_CS);
+    #endif
+    spiInit(0);
+  #endif
+  return true;
+}
 bool PersistentStore::access_finish() { return true; }

 bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
@@ -42,7 +42,6 @@
 // Store settings in the last two pages
 // Flash pages must be erased before writing, so keep track.
 bool firstWrite = false;
-uint32_t pageBase = EEPROM_START_ADDRESS;

 bool PersistentStore::access_start() {
  firstWrite = true;
@@ -55,7 +54,7 @@ bool PersistentStore::access_finish() {
  return true;
 }

-bool PersistentStore::write_data(int &pos, const uint8_t *value, const size_t size, uint16_t *crc) {
+bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
  FLASH_Status status;

  if (firstWrite) {
@@ -67,42 +66,27 @@ bool PersistentStore::write_data(int &pos, const uint8_t *value, const size_t si
    firstWrite = false;
  }

-  // First write full words
-  int i = 0;
-  int wordsToWrite = size / sizeof(uint16_t);
-  uint16_t* wordBuffer = (uint16_t *)value;
-  while (wordsToWrite) {
-    status = FLASH_ProgramHalfWord(pageBase + pos + (i * 2), wordBuffer[i]);
-    if (status != FLASH_COMPLETE) return true;
-    wordsToWrite--;
-    i++;
-  }
-
-  // Now, write any remaining single byte
-  const uint16_t odd = size & 1;
-  if (odd) {
-    uint16_t temp = value[size - 1];
-    status = FLASH_ProgramHalfWord(pageBase + pos + i, temp);
-    if (status != FLASH_COMPLETE) return true;
+  for (size_t i = 0; i < size; i++) {
+    if (FLASH_ProgramHalfWord(EEPROM_PAGE0_BASE + (pos + i) * 2, value[i]) != FLASH_COMPLETE)
+      return true;
  }

  crc16(crc, value, size);
-  pos += size + odd;
+  pos += size;
  return false;
 }

 bool PersistentStore::read_data(int &pos, uint8_t* value, const size_t size, uint16_t *crc, const bool writing/*=true*/) {
-  for (uint16_t i = 0; i < size; i++) {
-    byte* accessPoint = (byte*)(pageBase + pos + i);
-    uint8_t c = *accessPoint;
-    if (writing) value[i] = c;
-    crc16(crc, &c, 1);
+  for (size_t i = 0; i < size; i++) {
+    uint8_t v = *(uint16_t *)(EEPROM_PAGE0_BASE + (pos + i) * 2);
+    if (writing) value[i] = v;
+    crc16(crc, &v, 1);
  }
-  pos += ((size + 1) & ~1); // i.e., size+(size&1), round up odd values
+  pos += size;
  return false;
 }

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

 #endif // EEPROM_SETTINGS && EEPROM FLASH
 #endif // __STM32F1__
@@ -22,6 +22,7 @@

 /**
 * HAL for stm32duino.com based on Libmaple and compatible (STM32F1)
+ * Implementation of EEPROM settings in SD Card
 */

 #ifdef __STM32F1__
@@ -35,9 +36,10 @@
 #ifndef E2END
  #define E2END 0xFFF // 4KB
 #endif
-#define HAL_STM32F1_EEPROM_SIZE (E2END + 1)
+#define HAL_EEPROM_SIZE (E2END + 1)

-static char HAL_STM32F1_eeprom_content[HAL_STM32F1_EEPROM_SIZE];
+#define _ALIGN(x) __attribute__ ((aligned(x))) // SDIO uint32_t* compat.
+static char _ALIGN(4) HAL_eeprom_data[HAL_EEPROM_SIZE];

 #if ENABLED(SDSUPPORT)

@@ -50,12 +52,12 @@ static char HAL_STM32F1_eeprom_content[HAL_STM32F1_EEPROM_SIZE];

    SdFile file, root = card.getroot();
    if (!file.open(&root, EEPROM_FILENAME, O_RDONLY))
-      return false;
+      return true; // false aborts the save

-    int16_t bytes_read = file.read(HAL_STM32F1_eeprom_content, HAL_STM32F1_EEPROM_SIZE);
+    int bytes_read = file.read(HAL_eeprom_data, HAL_EEPROM_SIZE);
    if (bytes_read < 0) return false;
-    for (; bytes_read < HAL_STM32F1_EEPROM_SIZE; bytes_read++)
-      HAL_STM32F1_eeprom_content[bytes_read] = 0xFF;
+    for (; bytes_read < HAL_EEPROM_SIZE; bytes_read++)
+      HAL_eeprom_data[bytes_read] = 0xFF;
    file.close();
    return true;
  }
@@ -64,12 +66,12 @@ static char HAL_STM32F1_eeprom_content[HAL_STM32F1_EEPROM_SIZE];
    if (!card.isDetected()) return false;

    SdFile file, root = card.getroot();
-    int16_t bytes_written = 0;
+    int bytes_written = 0;
    if (file.open(&root, EEPROM_FILENAME, O_CREAT | O_WRITE | O_TRUNC)) {
-      bytes_written = file.write(HAL_STM32F1_eeprom_content, HAL_STM32F1_EEPROM_SIZE);
+      bytes_written = file.write(HAL_eeprom_data, HAL_EEPROM_SIZE);
      file.close();
    }
-    return (bytes_written == HAL_STM32F1_EEPROM_SIZE);
+    return (bytes_written == HAL_EEPROM_SIZE);
  }

 #else // !SDSUPPORT
@@ -78,9 +80,9 @@ static char HAL_STM32F1_eeprom_content[HAL_STM32F1_EEPROM_SIZE];

 #endif // !SDSUPPORT

-bool PersistentStore::write_data(int &pos, const uint8_t *value, const size_t size, uint16_t *crc) {
+bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
  for (size_t i = 0; i < size; i++)
-    HAL_STM32F1_eeprom_content[pos + i] = value[i];
+    HAL_eeprom_data[pos + i] = value[i];
  crc16(crc, value, size);
  pos += size;
  return false;
@@ -88,7 +90,7 @@ bool PersistentStore::write_data(int &pos, const uint8_t *value, const size_t si

 bool PersistentStore::read_data(int &pos, uint8_t* value, const size_t size, uint16_t *crc, const bool writing/*=true*/) {
  for (size_t i = 0; i < size; i++) {
-    uint8_t c = HAL_STM32F1_eeprom_content[pos + i];
+    uint8_t c = HAL_eeprom_data[pos + i];
    if (writing) value[i] = c;
    crc16(crc, &c, 1);
  }
@@ -96,7 +98,7 @@ bool PersistentStore::read_data(int &pos, uint8_t* value, const size_t size, uin
  return false;
 }

-size_t PersistentStore::capacity() { return HAL_STM32F1_EEPROM_SIZE; }
+size_t PersistentStore::capacity() { return HAL_EEPROM_SIZE; }

 #endif // EEPROM_SETTINGS

@@ -37,7 +37,7 @@

 #include <stdint.h>

-#ifdef defined(STM32F4) && USBCON
+#if defined(STM32F4) && USBCON
  #include <USBSerial.h>
 #endif

@@ -100,8 +100,6 @@
  #define NUM_SERIAL 1
 #endif

-#define _BV(b) (1 << (b))
-
 /**
 * TODO: review this to return 1 for pins that are not analog input
 */
@@ -142,7 +140,7 @@ typedef int8_t pin_t;
 // Public Variables
 // ------------------------

-/** result of last ADC conversion */
+// Result of last ADC conversion
 extern uint16_t HAL_adc_result;

 // ------------------------
@@ -154,14 +152,17 @@ extern uint16_t HAL_adc_result;

 inline void HAL_init(void) { }

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

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

 void _delay_ms(const int delay);

+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-function"
+
 /*
 extern "C" {
  int freeMemory(void);
@@ -183,15 +184,17 @@ static int freeMemory() {
  return &top - reinterpret_cast<char*>(_sbrk(0));
 }

+#pragma GCC diagnostic pop
+
 //
 // SPI: Extended functions which take a channel number (hardware SPI only)
 //

-/** Write single byte to specified SPI channel */
+// Write single byte to specified SPI channel
 void spiSend(uint32_t chan, byte b);
-/** Write buffer to specified SPI channel */
+// Write buffer to specified SPI channel
 void spiSend(uint32_t chan, const uint8_t* buf, size_t n);
-/** Read single byte from specified SPI channel */
+// Read single byte from specified SPI channel
 uint8_t spiRec(uint32_t chan);

 //
@@ -33,8 +33,6 @@
 #define STEP_TIMER_IRQ_ID TIM5_IRQn
 #define TEMP_TIMER_IRQ_ID TIM7_IRQn

-//#define PRESCALER 1
-
 // ------------------------
 // Private Variables
 // ------------------------
@@ -55,56 +53,40 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
    switch (timer_num) {
      case STEP_TIMER_NUM:
        // STEPPER TIMER TIM5 - use a 32bit timer
-        #ifdef STM32GENERIC
-          __HAL_RCC_TIM5_CLK_ENABLE();
-          TimerHandle[timer_num].handle.Instance            = TIM5;
-          TimerHandle[timer_num].handle.Init.Prescaler      = step_prescaler;
-          TimerHandle[timer_num].handle.Init.CounterMode    = TIM_COUNTERMODE_UP;
-          TimerHandle[timer_num].handle.Init.ClockDivision  = TIM_CLOCKDIVISION_DIV1;
-          TimerHandle[timer_num].callback = (uint32_t)TC5_Handler;
-        #else
-          TimerHandle[timer_num].timer = TIM5;
-          TimerHandle[timer_num].irqHandle = TC5_Handler;
-          TimerHandleInit(&TimerHandle[timer_num], (((HAL_TIMER_RATE) / step_prescaler) / frequency) - 1, step_prescaler);
-        #endif
+        __HAL_RCC_TIM5_CLK_ENABLE();
+        TimerHandle[timer_num].handle.Instance            = TIM5;
+        TimerHandle[timer_num].handle.Init.Prescaler      = step_prescaler;
+        TimerHandle[timer_num].handle.Init.CounterMode    = TIM_COUNTERMODE_UP;
+        TimerHandle[timer_num].handle.Init.ClockDivision  = TIM_CLOCKDIVISION_DIV1;
+        TimerHandle[timer_num].callback = (uint32_t)TC5_Handler;
        HAL_NVIC_SetPriority(STEP_TIMER_IRQ_ID, 1, 0);
        break;

      case TEMP_TIMER_NUM:
        // TEMP TIMER TIM7 - any available 16bit Timer (1 already used for PWM)
-        #ifdef STM32GENERIC
-          __HAL_RCC_TIM7_CLK_ENABLE();
-          TimerHandle[timer_num].handle.Instance            = TIM7;
-          TimerHandle[timer_num].handle.Init.Prescaler      = temp_prescaler;
-          TimerHandle[timer_num].handle.Init.CounterMode    = TIM_COUNTERMODE_UP;
-          TimerHandle[timer_num].handle.Init.ClockDivision  = TIM_CLOCKDIVISION_DIV1;
-          TimerHandle[timer_num].callback = (uint32_t)TC7_Handler;
-        #else
-          TimerHandle[timer_num].timer = TIM7;
-          TimerHandle[timer_num].irqHandle = TC7_Handler;
-          TimerHandleInit(&TimerHandle[timer_num], (((HAL_TIMER_RATE) / temp_prescaler) / frequency) - 1, temp_prescaler);
-        #endif
+        __HAL_RCC_TIM7_CLK_ENABLE();
+        TimerHandle[timer_num].handle.Instance            = TIM7;
+        TimerHandle[timer_num].handle.Init.Prescaler      = temp_prescaler;
+        TimerHandle[timer_num].handle.Init.CounterMode    = TIM_COUNTERMODE_UP;
+        TimerHandle[timer_num].handle.Init.ClockDivision  = TIM_CLOCKDIVISION_DIV1;
+        TimerHandle[timer_num].callback = (uint32_t)TC7_Handler;
        HAL_NVIC_SetPriority(TEMP_TIMER_IRQ_ID, 2, 0);
        break;
    }
    timers_initialized[timer_num] = true;
  }

-  #ifdef STM32GENERIC
-    TimerHandle[timer_num].handle.Init.Period = (((HAL_TIMER_RATE) / TimerHandle[timer_num].handle.Init.Prescaler) / frequency) - 1;
-    if (HAL_TIM_Base_Init(&TimerHandle[timer_num].handle) == HAL_OK)
-      HAL_TIM_Base_Start_IT(&TimerHandle[timer_num].handle);
-  #endif
+  TimerHandle[timer_num].handle.Init.Period = (((HAL_TIMER_RATE) / TimerHandle[timer_num].handle.Init.Prescaler) / frequency) - 1;
+  if (HAL_TIM_Base_Init(&TimerHandle[timer_num].handle) == HAL_OK)
+    HAL_TIM_Base_Start_IT(&TimerHandle[timer_num].handle);
 }

-#ifdef STM32GENERIC
-  extern "C" void TIM5_IRQHandler() {
-    ((void(*)(void))TimerHandle[0].callback)();
-  }
-  extern "C" void TIM7_IRQHandler() {
-    ((void(*)(void))TimerHandle[1].callback)();
-  }
-#endif
+extern "C" void TIM5_IRQHandler() {
+  ((void(*)(void))TimerHandle[0].callback)();
+}
+extern "C" void TIM7_IRQHandler() {
+  ((void(*)(void))TimerHandle[1].callback)();
+}

 void HAL_timer_enable_interrupt(const uint8_t timer_num) {
  switch (timer_num) {
@@ -59,8 +59,9 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
      timerConfig[0].IRQ_Id = TIM5_IRQn;
      timerConfig[0].callback = (uint32_t)TC5_Handler;
      HAL_NVIC_SetPriority(timerConfig[0].IRQ_Id, 1, 0);
-      SET_OUTPUT(STEPPER_ENABLE_PIN);
-      WRITE(STEPPER_ENABLE_PIN);
+      #if PIN_EXISTS(STEPPER_ENABLE)
+        OUT_WRITE(STEPPER_ENABLE_PIN, HIGH);
+      #endif
      break;
    case TEMP_TIMER_NUM:
      //TEMP TIMER TIM7 // any available 16bit Timer (1 already used for PWM)
@@ -189,7 +189,6 @@ void TMC26XStepper::start() {
  pinMode(step_pin, OUTPUT);
  pinMode(dir_pin, OUTPUT);
  pinMode(cs_pin, OUTPUT);
-  //SET_OUTPUT(STEPPER_ENABLE_PIN);
  extDigitalWrite(step_pin, LOW);
  extDigitalWrite(dir_pin, LOW);
  extDigitalWrite(cs_pin, HIGH);
@@ -68,7 +68,7 @@ static uint16_t EE_VerifyPageFullWriteVariable(uint16_t VirtAddress, uint16_t Da
 static uint16_t EE_PageTransfer(uint16_t VirtAddress, uint16_t Data);
 static uint16_t EE_VerifyPageFullyErased(uint32_t Address);

-/**
+ /**
  * @brief  Restore the pages to a known good state in case of page's status
  *   corruption after a power loss.
  * @param  None.
@@ -86,6 +86,8 @@ uint16_t EE_Initialize(void) {
  pEraseInit.NbSectors = 1;
  pEraseInit.VoltageRange = VOLTAGE_RANGE;

+  HAL_StatusTypeDef FlashStatus; // = HAL_OK
+
  /* Check for invalid header states and repair if necessary */
  uint32_t SectorError;
  switch (PageStatus0) {
@@ -135,7 +137,7 @@ uint16_t EE_Initialize(void) {
          }
        }
        /* Mark Page0 as valid */
-        HAL_StatusTypeDef FlashStatus = HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, PAGE0_BASE_ADDRESS, VALID_PAGE);
+        FlashStatus = HAL_FLASH_Program(TYPEPROGRAM_HALFWORD, PAGE0_BASE_ADDRESS, VALID_PAGE);
        /* If program operation was failed, a Flash error code is returned */
        if (FlashStatus != HAL_OK) return FlashStatus;
        pEraseInit.Sector = PAGE1_ID;
@@ -27,8 +27,6 @@
 * These use GPIO functions instead of Direct Port Manipulation, as on AVR.
 */

-#define _BV(b) (1 << (b))
-
 #define READ(IO)                digitalRead(IO)
 #define WRITE(IO,V)             digitalWrite(IO,V)

@@ -66,127 +64,141 @@

 #define _STM32_PIN(P,PN) ((PORT##P * 16) + PN)

-#define PA0  _STM32_PIN(A,  0)
-#define PA1  _STM32_PIN(A,  1)
-#define PA2  _STM32_PIN(A,  2)
-#define PA3  _STM32_PIN(A,  3)
-#define PA4  _STM32_PIN(A,  4)
-#define PA5  _STM32_PIN(A,  5)
-#define PA6  _STM32_PIN(A,  6)
-#define PA7  _STM32_PIN(A,  7)
-#define PA8  _STM32_PIN(A,  8)
-#define PA9  _STM32_PIN(A,  9)
-#define PA10 _STM32_PIN(A, 10)
-#define PA11 _STM32_PIN(A, 11)
-#define PA12 _STM32_PIN(A, 12)
-#define PA13 _STM32_PIN(A, 13)
-#define PA14 _STM32_PIN(A, 14)
-#define PA15 _STM32_PIN(A, 15)
+#ifndef PA0
+  #define PA0  _STM32_PIN(A,  0)
+  #define PA1  _STM32_PIN(A,  1)
+  #define PA2  _STM32_PIN(A,  2)
+  #define PA3  _STM32_PIN(A,  3)
+  #define PA4  _STM32_PIN(A,  4)
+  #define PA5  _STM32_PIN(A,  5)
+  #define PA6  _STM32_PIN(A,  6)
+  #define PA7  _STM32_PIN(A,  7)
+  #define PA8  _STM32_PIN(A,  8)
+  #define PA9  _STM32_PIN(A,  9)
+  #define PA10 _STM32_PIN(A, 10)
+  #define PA11 _STM32_PIN(A, 11)
+  #define PA12 _STM32_PIN(A, 12)
+  #define PA13 _STM32_PIN(A, 13)
+  #define PA14 _STM32_PIN(A, 14)
+  #define PA15 _STM32_PIN(A, 15)
+#endif

-#define PB0  _STM32_PIN(B,  0)
-#define PB1  _STM32_PIN(B,  1)
-#define PB2  _STM32_PIN(B,  2)
-#define PB3  _STM32_PIN(B,  3)
-#define PB4  _STM32_PIN(B,  4)
-#define PB5  _STM32_PIN(B,  5)
-#define PB6  _STM32_PIN(B,  6)
-#define PB7  _STM32_PIN(B,  7)
-#define PB8  _STM32_PIN(B,  8)
-#define PB9  _STM32_PIN(B,  9)
-#define PB10 _STM32_PIN(B, 10)
-#define PB11 _STM32_PIN(B, 11)
-#define PB12 _STM32_PIN(B, 12)
-#define PB13 _STM32_PIN(B, 13)
-#define PB14 _STM32_PIN(B, 14)
-#define PB15 _STM32_PIN(B, 15)
+#ifndef PB0
+  #define PB0  _STM32_PIN(B,  0)
+  #define PB1  _STM32_PIN(B,  1)
+  #define PB2  _STM32_PIN(B,  2)
+  #define PB3  _STM32_PIN(B,  3)
+  #define PB4  _STM32_PIN(B,  4)
+  #define PB5  _STM32_PIN(B,  5)
+  #define PB6  _STM32_PIN(B,  6)
+  #define PB7  _STM32_PIN(B,  7)
+  #define PB8  _STM32_PIN(B,  8)
+  #define PB9  _STM32_PIN(B,  9)
+  #define PB10 _STM32_PIN(B, 10)
+  #define PB11 _STM32_PIN(B, 11)
+  #define PB12 _STM32_PIN(B, 12)
+  #define PB13 _STM32_PIN(B, 13)
+  #define PB14 _STM32_PIN(B, 14)
+  #define PB15 _STM32_PIN(B, 15)
+#endif

-#define PC0  _STM32_PIN(C,  0)
-#define PC1  _STM32_PIN(C,  1)
-#define PC2  _STM32_PIN(C,  2)
-#define PC3  _STM32_PIN(C,  3)
-#define PC4  _STM32_PIN(C,  4)
-#define PC5  _STM32_PIN(C,  5)
-#define PC6  _STM32_PIN(C,  6)
-#define PC7  _STM32_PIN(C,  7)
-#define PC8  _STM32_PIN(C,  8)
-#define PC9  _STM32_PIN(C,  9)
-#define PC10 _STM32_PIN(C, 10)
-#define PC11 _STM32_PIN(C, 11)
-#define PC12 _STM32_PIN(C, 12)
-#define PC13 _STM32_PIN(C, 13)
-#define PC14 _STM32_PIN(C, 14)
-#define PC15 _STM32_PIN(C, 15)
+#ifndef PC0
+  #define PC0  _STM32_PIN(C,  0)
+  #define PC1  _STM32_PIN(C,  1)
+  #define PC2  _STM32_PIN(C,  2)
+  #define PC3  _STM32_PIN(C,  3)
+  #define PC4  _STM32_PIN(C,  4)
+  #define PC5  _STM32_PIN(C,  5)
+  #define PC6  _STM32_PIN(C,  6)
+  #define PC7  _STM32_PIN(C,  7)
+  #define PC8  _STM32_PIN(C,  8)
+  #define PC9  _STM32_PIN(C,  9)
+  #define PC10 _STM32_PIN(C, 10)
+  #define PC11 _STM32_PIN(C, 11)
+  #define PC12 _STM32_PIN(C, 12)
+  #define PC13 _STM32_PIN(C, 13)
+  #define PC14 _STM32_PIN(C, 14)
+  #define PC15 _STM32_PIN(C, 15)
+#endif

-#define PD0  _STM32_PIN(D,  0)
-#define PD1  _STM32_PIN(D,  1)
-#define PD2  _STM32_PIN(D,  2)
-#define PD3  _STM32_PIN(D,  3)
-#define PD4  _STM32_PIN(D,  4)
-#define PD5  _STM32_PIN(D,  5)
-#define PD6  _STM32_PIN(D,  6)
-#define PD7  _STM32_PIN(D,  7)
-#define PD8  _STM32_PIN(D,  8)
-#define PD9  _STM32_PIN(D,  9)
-#define PD10 _STM32_PIN(D, 10)
-#define PD11 _STM32_PIN(D, 11)
-#define PD12 _STM32_PIN(D, 12)
-#define PD13 _STM32_PIN(D, 13)
-#define PD14 _STM32_PIN(D, 14)
-#define PD15 _STM32_PIN(D, 15)
+#ifndef PD0
+  #define PD0  _STM32_PIN(D,  0)
+  #define PD1  _STM32_PIN(D,  1)
+  #define PD2  _STM32_PIN(D,  2)
+  #define PD3  _STM32_PIN(D,  3)
+  #define PD4  _STM32_PIN(D,  4)
+  #define PD5  _STM32_PIN(D,  5)
+  #define PD6  _STM32_PIN(D,  6)
+  #define PD7  _STM32_PIN(D,  7)
+  #define PD8  _STM32_PIN(D,  8)
+  #define PD9  _STM32_PIN(D,  9)
+  #define PD10 _STM32_PIN(D, 10)
+  #define PD11 _STM32_PIN(D, 11)
+  #define PD12 _STM32_PIN(D, 12)
+  #define PD13 _STM32_PIN(D, 13)
+  #define PD14 _STM32_PIN(D, 14)
+  #define PD15 _STM32_PIN(D, 15)
+#endif

-#define PE0  _STM32_PIN(E,  0)
-#define PE1  _STM32_PIN(E,  1)
-#define PE2  _STM32_PIN(E,  2)
-#define PE3  _STM32_PIN(E,  3)
-#define PE4  _STM32_PIN(E,  4)
-#define PE5  _STM32_PIN(E,  5)
-#define PE6  _STM32_PIN(E,  6)
-#define PE7  _STM32_PIN(E,  7)
-#define PE8  _STM32_PIN(E,  8)
-#define PE9  _STM32_PIN(E,  9)
-#define PE10 _STM32_PIN(E, 10)
-#define PE11 _STM32_PIN(E, 11)
-#define PE12 _STM32_PIN(E, 12)
-#define PE13 _STM32_PIN(E, 13)
-#define PE14 _STM32_PIN(E, 14)
-#define PE15 _STM32_PIN(E, 15)
+#ifndef PE0
+  #define PE0  _STM32_PIN(E,  0)
+  #define PE1  _STM32_PIN(E,  1)
+  #define PE2  _STM32_PIN(E,  2)
+  #define PE3  _STM32_PIN(E,  3)
+  #define PE4  _STM32_PIN(E,  4)
+  #define PE5  _STM32_PIN(E,  5)
+  #define PE6  _STM32_PIN(E,  6)
+  #define PE7  _STM32_PIN(E,  7)
+  #define PE8  _STM32_PIN(E,  8)
+  #define PE9  _STM32_PIN(E,  9)
+  #define PE10 _STM32_PIN(E, 10)
+  #define PE11 _STM32_PIN(E, 11)
+  #define PE12 _STM32_PIN(E, 12)
+  #define PE13 _STM32_PIN(E, 13)
+  #define PE14 _STM32_PIN(E, 14)
+  #define PE15 _STM32_PIN(E, 15)
+#endif

 #ifdef STM32F7
-  #define PORTF 5
-  #define PORTG 6

-  #define PF0  _STM32_PIN(F,  0)
-  #define PF1  _STM32_PIN(F,  1)
-  #define PF2  _STM32_PIN(F,  2)
-  #define PF3  _STM32_PIN(F,  3)
-  #define PF4  _STM32_PIN(F,  4)
-  #define PF5  _STM32_PIN(F,  5)
-  #define PF6  _STM32_PIN(F,  6)
-  #define PF7  _STM32_PIN(F,  7)
-  #define PF8  _STM32_PIN(F,  8)
-  #define PF9  _STM32_PIN(F,  9)
-  #define PF10 _STM32_PIN(F, 10)
-  #define PF11 _STM32_PIN(F, 11)
-  #define PF12 _STM32_PIN(F, 12)
-  #define PF13 _STM32_PIN(F, 13)
-  #define PF14 _STM32_PIN(F, 14)
-  #define PF15 _STM32_PIN(F, 15)
+  #ifndef PF0
+    #define PORTF 5
+    #define PF0  _STM32_PIN(F,  0)
+    #define PF1  _STM32_PIN(F,  1)
+    #define PF2  _STM32_PIN(F,  2)
+    #define PF3  _STM32_PIN(F,  3)
+    #define PF4  _STM32_PIN(F,  4)
+    #define PF5  _STM32_PIN(F,  5)
+    #define PF6  _STM32_PIN(F,  6)
+    #define PF7  _STM32_PIN(F,  7)
+    #define PF8  _STM32_PIN(F,  8)
+    #define PF9  _STM32_PIN(F,  9)
+    #define PF10 _STM32_PIN(F, 10)
+    #define PF11 _STM32_PIN(F, 11)
+    #define PF12 _STM32_PIN(F, 12)
+    #define PF13 _STM32_PIN(F, 13)
+    #define PF14 _STM32_PIN(F, 14)
+    #define PF15 _STM32_PIN(F, 15)
+  #endif

-  #define PG0  _STM32_PIN(G,  0)
-  #define PG1  _STM32_PIN(G,  1)
-  #define PG2  _STM32_PIN(G,  2)
-  #define PG3  _STM32_PIN(G,  3)
-  #define PG4  _STM32_PIN(G,  4)
-  #define PG5  _STM32_PIN(G,  5)
-  #define PG6  _STM32_PIN(G,  6)
-  #define PG7  _STM32_PIN(G,  7)
-  #define PG8  _STM32_PIN(G,  8)
-  #define PG9  _STM32_PIN(G,  9)
-  #define PG10 _STM32_PIN(G, 10)
-  #define PG11 _STM32_PIN(G, 11)
-  #define PG12 _STM32_PIN(G, 12)
-  #define PG13 _STM32_PIN(G, 13)
-  #define PG14 _STM32_PIN(G, 14)
-  #define PG15 _STM32_PIN(G, 15)
+  #ifndef PG0
+    #define PORTG 6
+    #define PG0  _STM32_PIN(G,  0)
+    #define PG1  _STM32_PIN(G,  1)
+    #define PG2  _STM32_PIN(G,  2)
+    #define PG3  _STM32_PIN(G,  3)
+    #define PG4  _STM32_PIN(G,  4)
+    #define PG5  _STM32_PIN(G,  5)
+    #define PG6  _STM32_PIN(G,  6)
+    #define PG7  _STM32_PIN(G,  7)
+    #define PG8  _STM32_PIN(G,  8)
+    #define PG9  _STM32_PIN(G,  9)
+    #define PG10 _STM32_PIN(G, 10)
+    #define PG11 _STM32_PIN(G, 11)
+    #define PG12 _STM32_PIN(G, 12)
+    #define PG13 _STM32_PIN(G, 13)
+    #define PG14 _STM32_PIN(G, 14)
+    #define PG15 _STM32_PIN(G, 15)
+  #endif

 #endif // STM32GENERIC && STM32F7
@@ -19,19 +19,17 @@
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
+#pragma once

 /**
 * Description: HAL for Teensy 3.5 and Teensy 3.6
 */

-#pragma once
-
 #define CPU_32_BIT

 #include "../shared/Marduino.h"
-
-#include "../math_32bit.h"
-#include "../HAL_SPI.h"
+#include "../shared/math_32bit.h"
+#include "../shared/HAL_SPI.h"

 #include "fastio_Teensy.h"
 #include "watchdog_Teensy.h"
@@ -99,9 +97,12 @@ uint8_t HAL_get_reset_source(void);

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

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

 // SPI: Extended functions which take a channel number (hardware SPI only)

@@ -24,13 +24,10 @@

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

-namespace HAL {
-namespace PersistentStore {
+bool PersistentStore::access_start() { return true; }
+bool PersistentStore::access_finish() { return true; }

-bool access_start() { return true; }
-bool access_finish() { return true; }
-
-bool write_data(int &pos, const uint8_t *value, uint16_t size, uint16_t *crc) {
+bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
  while (size--) {
    uint8_t * const p = (uint8_t * const)pos;
    uint8_t v = *value;
@@ -50,7 +47,7 @@ bool write_data(int &pos, const uint8_t *value, uint16_t size, uint16_t *crc) {
  return false;
 }

-bool read_data(int &pos, uint8_t* value, uint16_t size, uint16_t *crc, const bool writing/*=true*/) {
+bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
  do {
    uint8_t c = eeprom_read_byte((uint8_t*)pos);
    if (writing) *value = c;
@@ -61,8 +58,5 @@ bool read_data(int &pos, uint8_t* value, uint16_t size, uint16_t *crc, const boo
  return false;
 }

-} // PersistentStore
-} // HAL
-
 #endif // EEPROM_SETTINGS
 #endif // __MK20DX256__
@@ -95,24 +95,27 @@ typedef int8_t pin_t;

 inline void HAL_init(void) { }

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

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

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

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

 // SPI: Extended functions which take a channel number (hardware SPI only)
-/** Write single byte to specified SPI channel */
+// Write single byte to specified SPI channel
 void spiSend(uint32_t chan, byte b);
-/** Write buffer to specified SPI channel */
+// Write buffer to specified SPI channel
 void spiSend(uint32_t chan, const uint8_t* buf, size_t n);
-/** Read single byte from specified SPI channel */
+// Read single byte from specified SPI channel
 uint8_t spiRec(uint32_t chan);

 // ADC
@@ -1,50 +0,0 @@
-#if defined(__MK64FX512__) || defined(__MK66FX1M0__)
-
-#include "../../inc/MarlinConfig.h"
-
-#if ENABLED(EEPROM_SETTINGS)
-
-#include "../shared/persistent_store_api.h"
-
-namespace HAL {
-namespace PersistentStore {
-
-bool access_start() { return true; }
-bool access_finish() { return true; }
-
-bool write_data(int &pos, const uint8_t *value, uint16_t size, uint16_t *crc) {
-  while (size--) {
-    uint8_t * const p = (uint8_t * const)pos;
-    uint8_t v = *value;
-    // EEPROM has only ~100,000 write cycles,
-    // so only write bytes that have changed!
-    if (v != eeprom_read_byte(p)) {
-      eeprom_write_byte(p, v);
-      if (eeprom_read_byte(p) != v) {
-        SERIAL_ECHO_MSG(MSG_ERR_EEPROM_WRITE);
-        return true;
-      }
-    }
-    crc16(crc, &v, 1);
-    pos++;
-    value++;
-  };
-  return false;
-}
-
-bool read_data(int &pos, uint8_t* value, uint16_t size, uint16_t *crc, const bool writing/*=true*/) {
-  do {
-    uint8_t c = eeprom_read_byte((uint8_t*)pos);
-    if (writing) *value = c;
-    crc16(crc, &c, 1);
-    pos++;
-    value++;
-  } while (--size);
-  return false;
-}
-
-} // PersistentStore
-} // HAL
-
-#endif // EEPROM_SETTINGS
-#endif // __MK64FX512__ || __MK66FX1M0__
@@ -16,8 +16,7 @@
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
-
-#ifndef HAL_PINSDEBUG_TEENSY_H
+#pragma once

 #define NUMBER_PINS_TOTAL NUM_DIGITAL_PINS
 #define MULTI_NAME_PAD 16 // space needed to be pretty if not first name assigned to a pin
@@ -103,5 +102,3 @@ bool HAL_pwm_status(int8_t pin) {
 }

 static void HAL_pwm_details(uint8_t pin) { /* TODO */ }
-
-#endif
@@ -116,9 +116,8 @@ void Servo::detach() {
 }

 void Servo::write(int value) {
-  if (value < MIN_PULSE_WIDTH) { // treat values less than 544 as angles in degrees (valid values in microseconds are handled as microseconds)
+  if (value < MIN_PULSE_WIDTH)    // treat values less than 544 as angles in degrees (valid values in microseconds are handled as microseconds)
    value = map(constrain(value, 0, 180), 0, 180, SERVO_MIN(), SERVO_MAX());
-  }
  this->writeMicroseconds(value);
 }

@@ -140,7 +139,7 @@ void Servo::writeMicroseconds(int value) {
 int Servo::read() { return map(this->readMicroseconds() + 1, SERVO_MIN(), SERVO_MAX(), 0, 180); }

 int Servo::readMicroseconds() {
-  return (this->servoIndex == INVALID_SERVO) ? 0 : ticksToUs(servo_info[this->servoIndex].ticks) + TRIM_DURATION;
+  return (this->servoIndex == INVALID_SERVO) ? 0 : ticksToUs(servo_info[this->servoIndex].ticks) + (TRIM_DURATION);
 }

 bool Servo::attached() { return servo_info[this->servoIndex].Pin.isActive; }
@@ -84,10 +84,10 @@
 #else
  #include <stdint.h>

-  #if defined(__AVR__) || defined(ARDUINO_ARCH_SAM)
+  #if defined(__AVR__) || defined(ARDUINO_ARCH_SAM) || defined (__SAMD51__)
    // we're good to go
  #else
-    #error "This library only supports boards with an AVR or SAM3X processor."
+    #error "This library only supports boards with an AVR, SAM3X or SAMD51 processor."
  #endif

  #define Servo_VERSION           2     // software version of this library
@@ -47,8 +47,10 @@
  #include "../HAL_AVR/ServoTimers.h"
 #elif defined(ARDUINO_ARCH_SAM)
  #include "../HAL_DUE/ServoTimers.h"
+#elif defined(__SAMD51__)
+  #include "../HAL_SAMD51/ServoTimers.h"
 #else
-  #error "This library only supports boards with an AVR or SAM3X processor."
+  #error "This library only supports boards with an AVR, SAM3X or SAMD51 processor."
 #endif

 // Macros
@@ -64,10 +66,8 @@
 #define INVALID_SERVO         255     // flag indicating an invalid servo index

 // Convert microseconds to ticks and back (PRESCALER depends on architecture)
-#define usToTicks(_us)    (clockCyclesPerMicrosecond() * (_us) / (PRESCALER))
-#define ticksToUs(_ticks) (unsigned(_ticks) * (PRESCALER) / clockCyclesPerMicrosecond())
-
-//#define NBR_TIMERS        ((MAX_SERVOS) / (SERVOS_PER_TIMER))
+#define usToTicks(_us)    (clockCyclesPerMicrosecond() * (_us) / (SERVO_TIMER_PRESCALER))
+#define ticksToUs(_ticks) (unsigned(_ticks) * (SERVO_TIMER_PRESCALER) / clockCyclesPerMicrosecond())

 // convenience macros
 #define SERVO_INDEX_TO_TIMER(_servo_nbr) ((timer16_Sequence_t)(_servo_nbr / (SERVOS_PER_TIMER))) // returns the timer controlling this servo
@@ -78,7 +78,7 @@
 // Types

 typedef struct {
-  uint8_t nbr        : 6 ;            // a pin number from 0 to 63
+  uint8_t nbr        : 7 ;            // a pin number from 0 to 127
  uint8_t isActive   : 1 ;            // true if this channel is enabled, pin not pulsed if false
 } ServoPin_t;

@@ -65,7 +65,7 @@
  #include "feature/host_actions.h"
 #endif

-#if HAS_BUZZER && DISABLED(LCD_USE_I2C_BUZZER)
+#if USE_BEEPER
  #include "libs/buzzer.h"
 #endif

@@ -290,6 +290,15 @@ void enable_all_steppers() {
  enable_E5();
 }

+void enable_e_steppers() {
+  enable_E0();
+  enable_E1();
+  enable_E2();
+  enable_E3();
+  enable_E4();
+  enable_E5();
+}
+
 void disable_e_steppers() {
  disable_E0();
  disable_E1();
@@ -539,28 +548,28 @@ void manage_inactivity(const bool ignore_stepper_queue/*=false*/) {
      #if ENABLED(SWITCHING_EXTRUDER)
        bool oldstatus;
        switch (active_extruder) {
-          default: oldstatus = E0_ENABLE_READ; enable_E0(); break;
+          default: oldstatus = E0_ENABLE_READ(); enable_E0(); break;
          #if E_STEPPERS > 1
-            case 2: case 3: oldstatus = E1_ENABLE_READ; enable_E1(); break;
+            case 2: case 3: oldstatus = E1_ENABLE_READ(); enable_E1(); break;
            #if E_STEPPERS > 2
-              case 4: case 5: oldstatus = E2_ENABLE_READ; enable_E2(); break;
+              case 4: case 5: oldstatus = E2_ENABLE_READ(); enable_E2(); break;
            #endif // E_STEPPERS > 2
          #endif // E_STEPPERS > 1
        }
      #else // !SWITCHING_EXTRUDER
        bool oldstatus;
        switch (active_extruder) {
-          default: oldstatus = E0_ENABLE_READ; enable_E0(); break;
+          default: oldstatus = E0_ENABLE_READ(); enable_E0(); break;
          #if E_STEPPERS > 1
-            case 1: oldstatus = E1_ENABLE_READ; enable_E1(); break;
+            case 1: oldstatus = E1_ENABLE_READ(); enable_E1(); break;
            #if E_STEPPERS > 2
-              case 2: oldstatus = E2_ENABLE_READ; enable_E2(); break;
+              case 2: oldstatus = E2_ENABLE_READ(); enable_E2(); break;
              #if E_STEPPERS > 3
-                case 3: oldstatus = E3_ENABLE_READ; enable_E3(); break;
+                case 3: oldstatus = E3_ENABLE_READ(); enable_E3(); break;
                #if E_STEPPERS > 4
-                  case 4: oldstatus = E4_ENABLE_READ; enable_E4(); break;
+                  case 4: oldstatus = E4_ENABLE_READ(); enable_E4(); break;
                  #if E_STEPPERS > 5
-                    case 5: oldstatus = E5_ENABLE_READ; enable_E5(); break;
+                    case 5: oldstatus = E5_ENABLE_READ(); enable_E5(); break;
                  #endif // E_STEPPERS > 5
                #endif // E_STEPPERS > 4
              #endif // E_STEPPERS > 3
@@ -659,6 +668,18 @@ void idle(
    bool no_stepper_sleep/*=false*/
  #endif
 ) {
+
+  #if ENABLED(SPI_ENDSTOPS)
+    if (endstops.tmc_spi_homing.any
+      #if ENABLED(IMPROVE_HOMING_RELIABILITY)
+        && ELAPSED(millis(), sg_guard_period)
+      #endif
+    ) {
+      for (uint8_t i = 4; i--;) // Read SGT 4 times per idle loop
+        if (endstops.tmc_spi_homing_check()) break;
+    }
+  #endif
+
  #if ENABLED(MAX7219_DEBUG)
    max7219.idle_tasks();
  #endif
@@ -681,7 +702,7 @@ void idle(
    print_job_timer.tick();
  #endif

-  #if HAS_BUZZER && DISABLED(LCD_USE_I2C_BUZZER)
+  #if USE_BEEPER
    buzzer.tick();
  #endif

@@ -865,6 +886,10 @@ void setup() {
    runout.setup();
  #endif

+  #if ENABLED(POWER_LOSS_RECOVERY)
+    recovery.setup();
+  #endif
+
  setup_killpin();

  #if HAS_TMC220x
@@ -1105,6 +1130,10 @@ void setup() {
    init_closedloop();
  #endif

+  #ifdef STARTUP_COMMANDS
+    queue.inject_P(PSTR(STARTUP_COMMANDS));
+  #endif
+
  #if ENABLED(INIT_SDCARD_ON_BOOT) && !HAS_SPI_LCD
    card.beginautostart();
  #endif
@@ -1130,6 +1159,8 @@ void loop() {

  for (;;) {

+    idle(); // Do an idle first so boot is slightly faster
+
    #if ENABLED(SDSUPPORT)

      card.checkautostart();
@@ -1161,6 +1192,5 @@ void loop() {
    if (queue.length < BUFSIZE) queue.get_available_commands();
    queue.advance();
    endstops.event_handler();
-    idle();
  }
 }
@@ -316,6 +316,7 @@ void manage_inactivity(const bool ignore_stepper_queue=false);
 /**
 * The axis order in all axis related arrays is X, Y, Z, E
 */
+void enable_e_steppers();
 void enable_all_steppers();
 void disable_e_stepper(const uint8_t e);
 void disable_e_steppers();
@@ -94,6 +94,9 @@
 #define BOARD_TRONXY_V3_1_0           1140  // Tronxy TRONXY-V3-1.0
 #define BOARD_Z_BOLT_X_SERIES         1141  // Z-Bolt X Series
 #define BOARD_TT_OSCAR                1142  // TT OSCAR
+#define BOARD_OVERLORD                1143  // Overlord/Overlord Pro
+#define BOARD_HJC2560C_REV1           1144  // ADIMLab Granty v1
+#define BOARD_HJC2560C_REV2           1145  // ADIMLab Granty v2

 //
 // RAMBo and derivatives
@@ -112,24 +115,25 @@

 #define BOARD_CNCONTROLS_11           1300  // Cartesio CN Controls V11
 #define BOARD_CNCONTROLS_12           1301  // Cartesio CN Controls V12
-#define BOARD_CHEAPTRONIC             1302  // Cheaptronic v1.0
-#define BOARD_CHEAPTRONIC_V2          1303  // Cheaptronic v2.0
-#define BOARD_MIGHTYBOARD_REVE        1304  // Makerbot Mightyboard Revision E
-#define BOARD_MEGATRONICS             1305  // Megatronics
-#define BOARD_MEGATRONICS_2           1306  // Megatronics v2.0
-#define BOARD_MEGATRONICS_3           1307  // Megatronics v3.0
-#define BOARD_MEGATRONICS_31          1308  // Megatronics v3.1
-#define BOARD_MEGATRONICS_32          1309  // Megatronics v3.2
-#define BOARD_ELEFU_3                 1310  // Elefu Ra Board (v3)
-#define BOARD_LEAPFROG                1311  // Leapfrog
-#define BOARD_MEGACONTROLLER          1312  // Mega controller
-#define BOARD_GT2560_REV_A            1313  // Geeetech GT2560 Rev. A
-#define BOARD_GT2560_REV_A_PLUS       1314  // Geeetech GT2560 Rev. A+ (with auto level probe)
-#define BOARD_GT2560_V3               1315  // Geeetech GT2560 Rev B for A10(M/D)
-#define BOARD_GT2560_V3_MC2           1316  // Geeetech GT2560 Rev B for Mecreator2
-#define BOARD_GT2560_V3_A20           1317  // Geeetech GT2560 Rev B for A20(M/D)
-#define BOARD_EINSTART_S              1318  // Einstart retrofit
-#define BOARD_WANHAO_ONEPLUS          1319  // Wanhao 0ne+ i3 Mini
+#define BOARD_CNCONTROLS_15           1302  // Cartesio CN Controls V15
+#define BOARD_CHEAPTRONIC             1303  // Cheaptronic v1.0
+#define BOARD_CHEAPTRONIC_V2          1304  // Cheaptronic v2.0
+#define BOARD_MIGHTYBOARD_REVE        1305  // Makerbot Mightyboard Revision E
+#define BOARD_MEGATRONICS             1306  // Megatronics
+#define BOARD_MEGATRONICS_2           1307  // Megatronics v2.0
+#define BOARD_MEGATRONICS_3           1308  // Megatronics v3.0
+#define BOARD_MEGATRONICS_31          1309  // Megatronics v3.1
+#define BOARD_MEGATRONICS_32          1310  // Megatronics v3.2
+#define BOARD_ELEFU_3                 1311  // Elefu Ra Board (v3)
+#define BOARD_LEAPFROG                1312  // Leapfrog
+#define BOARD_MEGACONTROLLER          1313  // Mega controller
+#define BOARD_GT2560_REV_A            1314  // Geeetech GT2560 Rev. A
+#define BOARD_GT2560_REV_A_PLUS       1315  // Geeetech GT2560 Rev. A+ (with auto level probe)
+#define BOARD_GT2560_V3               1316  // Geeetech GT2560 Rev B for A10(M/D)
+#define BOARD_GT2560_V3_MC2           1317  // Geeetech GT2560 Rev B for Mecreator2
+#define BOARD_GT2560_V3_A20           1318  // Geeetech GT2560 Rev B for A20(M/D)
+#define BOARD_EINSTART_S              1319  // Einstart retrofit
+#define BOARD_WANHAO_ONEPLUS          1320  // Wanhao 0ne+ i3 Mini

 //
 // ATmega1281, ATmega2561
@@ -289,6 +293,7 @@
 #define BOARD_BLACK_STM32F407ZE       4205  // BLACK_STM32F407ZE
 #define BOARD_STEVAL                  4206  // STEVAL-3DP001V1 3D PRINTER BOARD
 #define BOARD_BIGTREE_SKR_PRO_V1_1    4207  // BigTreeTech SKR Pro v1.1 (STM32F407ZG)
+#define BOARD_BIGTREE_BTT002_V1_0     4208  // BigTreeTech BTT002 v1.0 (STM32F407VE)

 //
 // ARM Cortex M7
@@ -67,12 +67,14 @@

 #define AXIS_DRIVER_TYPE(A,T) AXIS_DRIVER_TYPE_##A(T)

+#define HAS_E_DRIVER(T) (  AXIS_DRIVER_TYPE_E0(T) || AXIS_DRIVER_TYPE_E1(T) \
+                        || AXIS_DRIVER_TYPE_E2(T) || AXIS_DRIVER_TYPE_E3(T) \
+                        || AXIS_DRIVER_TYPE_E4(T) || AXIS_DRIVER_TYPE_E5(T) )
+
 #define HAS_DRIVER(T) (    AXIS_DRIVER_TYPE_X(T)  || AXIS_DRIVER_TYPE_X2(T) \
                        || AXIS_DRIVER_TYPE_Y(T)  || AXIS_DRIVER_TYPE_Y2(T) \
                        || AXIS_DRIVER_TYPE_Z(T)  || AXIS_DRIVER_TYPE_Z2(T) || AXIS_DRIVER_TYPE_Z3(T) \
-                        || AXIS_DRIVER_TYPE_E0(T) || AXIS_DRIVER_TYPE_E1(T) \
-                        || AXIS_DRIVER_TYPE_E2(T) || AXIS_DRIVER_TYPE_E3(T) \
-                        || AXIS_DRIVER_TYPE_E4(T) || AXIS_DRIVER_TYPE_E5(T) )
+                        || HAS_E_DRIVER(T) )

 // Test for supported TMC drivers that require advanced configuration
 // Does not match standalone configurations
@@ -67,6 +67,7 @@
 // sk         Slovak
 // tr         Turkish
 // uk         Ukrainian
+// vi         Vietnamese
 // zh_CN      Chinese (Simplified)
 // zh_TW      Chinese (Traditional)

@@ -118,24 +118,24 @@
  // Using GCC extensions, but Travis GCC version does not like it and gives
  //  "error: statement-expressions are not allowed outside functions nor in template-argument lists"
  #define NOLESS(v, n) \
-    do { \
+    do{ \
      __typeof__(n) _n = (n); \
      if (v < _n) v = _n; \
-    } while(0)
+    }while(0)

  #define NOMORE(v, n) \
-    do { \
+    do{ \
      __typeof__(n) _n = (n); \
      if (v > _n) v = _n; \
-    } while(0)
+    }while(0)

  #define LIMIT(v, n1, n2) \
-    do { \
+    do{ \
      __typeof__(n1) _n1 = (n1); \
      __typeof__(n2) _n2 = (n2); \
      if (v < _n1) v = _n1; \
      else if (v > _n2) v = _n2; \
-    } while(0)
+    }while(0)

 #endif

@@ -184,5 +184,5 @@ void print_bin(const uint16_t val);

 void print_xyz(PGM_P const prefix, PGM_P const suffix, const float x, const float y, const float z);
 void print_xyz(PGM_P const prefix, PGM_P const suffix, const float xyz[]);
-#define SERIAL_POS(SUFFIX,VAR) do { print_xyz(PSTR("  " STRINGIFY(VAR) "="), PSTR(" : " SUFFIX "\n"), VAR); } while(0)
-#define SERIAL_XYZ(PREFIX,V...) do { print_xyz(PSTR(PREFIX), nullptr, V); } while(0)
+#define SERIAL_POS(SUFFIX,VAR) do { print_xyz(PSTR("  " STRINGIFY(VAR) "="), PSTR(" : " SUFFIX "\n"), VAR); }while(0)
+#define SERIAL_XYZ(PREFIX,V...) do { print_xyz(PSTR(PREFIX), nullptr, V); }while(0)
@@ -37,7 +37,7 @@ Babystep babystep;

 volatile int16_t Babystep::todo[BS_TODO_AXIS(Z_AXIS) + 1];

-#if HAS_LCD_MENU
+#if HAS_LCD_MENU || ENABLED(EXTENSIBLE_UI)
  int16_t Babystep::accum;
  #if ENABLED(BABYSTEP_DISPLAY_TOTAL)
    int16_t Babystep::axis_total[BS_TOTAL_AXIS(Z_AXIS) + 1];
@@ -75,7 +75,7 @@ void Babystep::add_steps(const AxisEnum axis, const int16_t distance) {

  if (!CAN_BABYSTEP(axis)) return;

-  #if HAS_LCD_MENU
+  #if HAS_LCD_MENU || ENABLED(EXTENSIBLE_UI)
    accum += distance; // Count up babysteps for the UI
    #if ENABLED(BABYSTEP_DISPLAY_TOTAL)
      axis_total[BS_TOTAL_AXIS(axis)] += distance;
@@ -30,7 +30,7 @@
  #define BS_TODO_AXIS(A) 0
 #endif

-#if HAS_LCD_MENU && ENABLED(BABYSTEP_DISPLAY_TOTAL)
+#if (HAS_LCD_MENU || ENABLED(EXTENSIBLE_UI)) && ENABLED(BABYSTEP_DISPLAY_TOTAL)
  #if ENABLED(BABYSTEP_XY)
    #define BS_TOTAL_AXIS(A) A
  #else
@@ -41,7 +41,7 @@
 class Babystep {
 public:
  static volatile int16_t todo[BS_TODO_AXIS(Z_AXIS) + 1];
-  #if HAS_LCD_MENU
+  #if HAS_LCD_MENU || ENABLED(EXTENSIBLE_UI)
    static int16_t accum;                                     // Total babysteps in current edit
    #if ENABLED(BABYSTEP_DISPLAY_TOTAL)
      static int16_t axis_total[BS_TOTAL_AXIS(Z_AXIS) + 1];   // Total babysteps since G28
@@ -752,17 +752,18 @@
      save_ubl_active_state_and_disable();  // No bed level correction so only raw data is obtained
      DEPLOY_PROBE();

-      uint16_t count = GRID_MAX_POINTS, current = 1;
+      uint8_t count = GRID_MAX_POINTS;

      do {
-        current = (GRID_MAX_POINTS) - count + 1;
-
        if (do_ubl_mesh_map) display_map(g29_map_type);

-        SERIAL_ECHOLNPAIR("\nProbing mesh point ", current, "/", GRID_MAX_POINTS, ".\n");
-        #if HAS_LCD_MENU
-          ui.status_printf_P(0, PSTR(MSG_LCD_PROBING_MESH " %i/%i"), current, int(GRID_MAX_POINTS));
+        const int current = (GRID_MAX_POINTS) - count + 1;
+        SERIAL_ECHOLNPAIR("\nProbing mesh point ", current, "/", int(GRID_MAX_POINTS), ".\n");
+        #if HAS_DISPLAY
+          ui.status_printf_P(0, PSTR(MSG_PROBING_MESH " %i/%i"), current, int(GRID_MAX_POINTS));
+        #endif

+        #if HAS_LCD_MENU
          if (ui.button_pressed()) {
            ui.quick_feedback(false); // Preserve button state for click-and-hold
            SERIAL_ECHOLNPGM("\nMesh only partially populated.\n");
@@ -1405,7 +1406,7 @@

      if (do_3_pt_leveling) {
        SERIAL_ECHOLNPGM("Tilting mesh (1/3)");
-        #if HAS_LCD_MENU
+        #if HAS_DISPLAY
          ui.status_printf_P(0, PSTR(MSG_LCD_TILTING_MESH " 1/3"));
        #endif

@@ -1424,7 +1425,7 @@

        if (!abort_flag) {
          SERIAL_ECHOLNPGM("Tilting mesh (2/3)");
-          #if HAS_LCD_MENU
+          #if HAS_DISPLAY
            ui.status_printf_P(0, PSTR(MSG_LCD_TILTING_MESH " 2/3"));
          #endif

@@ -1444,7 +1445,7 @@

        if (!abort_flag) {
          SERIAL_ECHOLNPGM("Tilting mesh (3/3)");
-          #if HAS_LCD_MENU
+          #if HAS_DISPLAY
            ui.status_printf_P(0, PSTR(MSG_LCD_TILTING_MESH " 3/3"));
          #endif

@@ -1485,7 +1486,7 @@

            if (!abort_flag) {
              SERIAL_ECHOLNPAIR("Tilting mesh point ", current, "/", total_points, "\n");
-              #if HAS_LCD_MENU
+              #if HAS_DISPLAY
                ui.status_printf_P(0, PSTR(MSG_LCD_TILTING_MESH " %i/%i"), current, total_points);
              #endif

@@ -1498,8 +1499,7 @@
                DEBUG_ECHO_F(rx, 7);
                DEBUG_CHAR(',');
                DEBUG_ECHO_F(ry, 7);
-                DEBUG_ECHOPGM(")   logical: ");
-                DEBUG_CHAR('(');
+                DEBUG_ECHOPGM(")   logical: (");
                DEBUG_ECHO_F(LOGICAL_X_POSITION(rx), 7);
                DEBUG_CHAR(',');
                DEBUG_ECHO_F(LOGICAL_Y_POSITION(ry), 7);
@@ -0,0 +1,36 @@
+/**
+ * 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/>.
+ *
+ */
+
+#include "../inc/MarlinConfigPre.h"
+
+#if ENABLED(BINARY_FILE_TRANSFER)
+
+#include "../sd/cardreader.h"
+#include "binary_protocol.h"
+
+char* SDFileTransferProtocol::Packet::Open::data = nullptr;
+size_t SDFileTransferProtocol::data_waiting, SDFileTransferProtocol::transfer_timeout, SDFileTransferProtocol::idle_timeout;
+bool SDFileTransferProtocol::transfer_active, SDFileTransferProtocol::dummy_transfer, SDFileTransferProtocol::compression;
+
+BinaryStream binaryStream[NUM_SERIAL];
+
+#endif // BINARY_FILE_TRANSFER
@@ -0,0 +1,471 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+#pragma once
+
+#include "../inc/MarlinConfig.h"
+
+#define BINARY_STREAM_COMPRESSION
+
+#if ENABLED(BINARY_STREAM_COMPRESSION)
+  #include "../libs/heatshrink/heatshrink_decoder.h"
+#endif
+
+inline bool bs_serial_data_available(const uint8_t index) {
+  switch (index) {
+    case 0: return MYSERIAL0.available();
+    #if NUM_SERIAL > 1
+      case 1: return MYSERIAL1.available();
+    #endif
+  }
+  return false;
+}
+
+inline int bs_read_serial(const uint8_t index) {
+  switch (index) {
+    case 0: return MYSERIAL0.read();
+    #if NUM_SERIAL > 1
+      case 1: return MYSERIAL1.read();
+    #endif
+  }
+  return -1;
+}
+
+#if ENABLED(BINARY_STREAM_COMPRESSION)
+  static heatshrink_decoder hsd;
+  static uint8_t decode_buffer[512] = {};
+#endif
+
+class SDFileTransferProtocol  {
+private:
+  struct Packet {
+    struct [[gnu::packed]] Open {
+      static bool validate(char* buffer, size_t length) {
+        return (length > sizeof(Open) && buffer[length - 1] == '\0');
+      }
+      static Open& decode(char* buffer) {
+        data = &buffer[2];
+        return *reinterpret_cast<Open*>(buffer);
+      }
+      bool compression_enabled() { return compression & 0x1; }
+      bool dummy_transfer() { return dummy & 0x1; }
+      static char* filename() { return data; }
+      private:
+        uint8_t dummy, compression;
+        static char* data;  // variable length strings complicate things
+    };
+  };
+
+  static bool file_open(char* filename) {
+    if (!dummy_transfer) {
+      card.initsd();
+      card.openFile(filename, false);
+      if (!card.isFileOpen()) return false;
+    }
+    transfer_active = true;
+    data_waiting = 0;
+    #if ENABLED(BINARY_STREAM_COMPRESSION)
+      heatshrink_decoder_reset(&hsd);
+    #endif
+    return true;
+  }
+
+  static bool file_write(char* buffer, const size_t length) {
+    #if ENABLED(BINARY_STREAM_COMPRESSION)
+      if (compression) {
+        size_t total_processed = 0, processed_count = 0;
+        HSD_poll_res presult;
+
+        while (total_processed < length) {
+          heatshrink_decoder_sink(&hsd, reinterpret_cast<uint8_t*>(&buffer[total_processed]), length - total_processed, &processed_count);
+          total_processed += processed_count;
+          do {
+            presult = heatshrink_decoder_poll(&hsd, &decode_buffer[data_waiting], sizeof(decode_buffer) - data_waiting, &processed_count);
+            data_waiting += processed_count;
+            if (data_waiting == sizeof(decode_buffer)) {
+              if (!dummy_transfer)
+                if (card.write(decode_buffer, data_waiting) < 0) {
+                  return false;
+                }
+              data_waiting = 0;
+            }
+          } while (presult == HSDR_POLL_MORE);
+        }
+        return true;
+      }
+    #endif
+    return (dummy_transfer || card.write(buffer, length) >= 0);
+  }
+
+  static bool file_close() {
+    if (!dummy_transfer) {
+      #if ENABLED(BINARY_STREAM_COMPRESSION)
+        // flush any buffered data
+        if (data_waiting) {
+          if (card.write(decode_buffer, data_waiting) < 0) return false;
+          data_waiting = 0;
+        }
+      #endif
+      card.closefile();
+      card.release();
+    }
+    #if ENABLED(BINARY_STREAM_COMPRESSION)
+      heatshrink_decoder_finish(&hsd);
+    #endif
+    transfer_active = false;
+    return true;
+  }
+
+  static void transfer_abort() {
+    if (!dummy_transfer) {
+      card.closefile();
+      card.removeFile(card.filename);
+      card.release();
+      #if ENABLED(BINARY_STREAM_COMPRESSION)
+        heatshrink_decoder_finish(&hsd);
+      #endif
+    }
+    transfer_active = false;
+    return;
+  }
+
+  enum class FileTransfer : uint8_t { QUERY, OPEN, CLOSE, WRITE, ABORT };
+
+  static size_t data_waiting, transfer_timeout, idle_timeout;
+  static bool transfer_active, dummy_transfer, compression;
+
+public:
+
+  static void idle() {
+    // If a transfer is interrupted and a file is left open, abort it after TIMEOUT ms
+    const millis_t ms = millis();
+    if (transfer_active && ELAPSED(ms, idle_timeout)) {
+      idle_timeout = ms + IDLE_PERIOD;
+      if (ELAPSED(ms, transfer_timeout)) transfer_abort();
+    }
+  }
+
+  static void process(uint8_t packet_type, char* buffer, const uint16_t length) {
+    transfer_timeout = millis() + TIMEOUT;
+    switch (static_cast<FileTransfer>(packet_type)) {
+      case FileTransfer::QUERY:
+        SERIAL_ECHOPAIR("PFT:version:", VERSION_MAJOR, ".", VERSION_MINOR, ".", VERSION_PATCH);
+        #if ENABLED(BINARY_STREAM_COMPRESSION)
+          SERIAL_ECHOLNPAIR(":compresion:heatshrink,", HEATSHRINK_STATIC_WINDOW_BITS, ",", HEATSHRINK_STATIC_LOOKAHEAD_BITS);
+        #else
+          SERIAL_ECHOLNPGM(":compresion:none");
+        #endif
+        break;
+      case FileTransfer::OPEN:
+        if (transfer_active)
+          SERIAL_ECHOLNPGM("PFT:busy");
+        else {
+          if (Packet::Open::validate(buffer, length)) {
+            auto packet = Packet::Open::decode(buffer);
+            compression = packet.compression_enabled();
+            dummy_transfer = packet.dummy_transfer();
+            if (file_open(packet.filename())) {
+              SERIAL_ECHOLNPGM("PFT:success");
+              break;
+            }
+          }
+          SERIAL_ECHOLNPGM("PFT:fail");
+        }
+        break;
+      case FileTransfer::CLOSE:
+        if (transfer_active) {
+          if (file_close())
+            SERIAL_ECHOLNPGM("PFT:success");
+          else
+            SERIAL_ECHOLNPGM("PFT:ioerror");
+        }
+        else SERIAL_ECHOLNPGM("PFT:invalid");
+        break;
+      case FileTransfer::WRITE:
+        if (!transfer_active)
+          SERIAL_ECHOLNPGM("PFT:invalid");
+        else if (!file_write(buffer, length))
+          SERIAL_ECHOLNPGM("PFT:ioerror");
+        break;
+      case FileTransfer::ABORT:
+        transfer_abort();
+        SERIAL_ECHOLNPGM("PFT:success");
+        break;
+      default:
+        SERIAL_ECHOLNPGM("PTF:invalid");
+        break;
+    }
+  }
+
+  static const uint16_t VERSION_MAJOR = 0, VERSION_MINOR = 1, VERSION_PATCH = 0, TIMEOUT = 10000, IDLE_PERIOD = 1000;
+};
+
+class BinaryStream {
+public:
+  enum class Protocol : uint8_t { CONTROL, FILE_TRANSFER };
+
+  enum class ProtocolControl : uint8_t { SYNC = 1, CLOSE };
+
+  enum class StreamState : uint8_t { PACKET_RESET, PACKET_WAIT, PACKET_HEADER, PACKET_DATA, PACKET_FOOTER,
+                                     PACKET_PROCESS, PACKET_RESEND, PACKET_TIMEOUT, PACKET_ERROR };
+
+  struct Packet { // 10 byte protocol overhead, ascii with checksum and line number has a minimum of 7 increasing with line
+    struct [[gnu::packed]]  Header {
+      static constexpr uint16_t HEADER_TOKEN = 0xB5AD;
+      uint16_t token;       // packet start token
+      uint8_t sync;         // stream sync, resend id and packet loss detection
+      uint8_t meta;         // 4 bit protocol,
+                            // 4 bit packet type
+      uint16_t size;        // data length
+      uint16_t checksum;    // header checksum
+
+      uint8_t protocol() { return (meta >> 4) & 0xF; }
+      uint8_t type() { return meta & 0xF; }
+      void reset() { token = 0; sync = 0; meta = 0; size = 0; checksum = 0; }
+    };
+
+    struct [[gnu::packed]] Footer {
+      uint16_t checksum; // full packet checksum
+      void reset() { checksum = 0; }
+    };
+
+    uint8_t header_data[sizeof(Header)],
+            footer_data[sizeof(Footer)];
+    uint32_t bytes_received;
+    uint16_t checksum, header_checksum;
+    millis_t timeout;
+    char* buffer;
+
+    Header& header() { return *reinterpret_cast<Header*>(header_data); }
+    Footer& footer() { return *reinterpret_cast<Footer*>(footer_data); }
+    void reset() {
+      header().reset();
+      footer().reset();
+      bytes_received = 0;
+      checksum = 0;
+      header_checksum = 0;
+      timeout = millis() + PACKET_MAX_WAIT;
+      buffer = nullptr;
+    }
+  } packet{};
+
+  void reset() {
+    sync = 0;
+    packet_retries = 0;
+    buffer_next_index = 0;
+  }
+
+  // fletchers 16 checksum
+  uint32_t checksum(uint32_t cs, uint8_t value) {
+    uint16_t cs_low = (((cs & 0xFF) + value) % 255);
+    return ((((cs >> 8) + cs_low) % 255) << 8)  | cs_low;
+  }
+
+  // read the next byte from the data stream keeping track of
+  // whether the stream times out from data starvation
+  // takes the data variable by reference in order to return status
+  bool stream_read(uint8_t& data) {
+    if (stream_state != StreamState::PACKET_WAIT && ELAPSED(millis(), packet.timeout)) {
+      stream_state = StreamState::PACKET_TIMEOUT;
+      return false;
+    }
+    if (!bs_serial_data_available(card.transfer_port_index)) return false;
+    data = bs_read_serial(card.transfer_port_index);
+    packet.timeout = millis() + PACKET_MAX_WAIT;
+    return true;
+  }
+
+  template<const size_t buffer_size>
+  void receive(char (&buffer)[buffer_size]) {
+    uint8_t data = 0;
+    millis_t transfer_window = millis() + RX_TIMESLICE;
+
+    #if ENABLED(SDSUPPORT)
+      PORT_REDIRECT(card.transfer_port_index);
+    #endif
+
+    while (PENDING(millis(), transfer_window)) {
+      switch (stream_state) {
+         /**
+          * Data stream packet handling
+          */
+        case StreamState::PACKET_RESET:
+          packet.reset();
+          stream_state = StreamState::PACKET_WAIT;
+        case StreamState::PACKET_WAIT:
+          if (!stream_read(data)) { idle(); return; }  // no active packet so don't wait
+          packet.header_data[1] = data;
+          if (packet.header().token == Packet::Header::HEADER_TOKEN) {
+            packet.bytes_received = 2;
+            stream_state = StreamState::PACKET_HEADER;
+          }
+          else {
+            // stream corruption drop data
+            packet.header_data[0] = data;
+          }
+          break;
+        case StreamState::PACKET_HEADER:
+          if (!stream_read(data)) break;
+
+          packet.header_data[packet.bytes_received++] = data;
+          packet.checksum = checksum(packet.checksum, data);
+
+          // header checksum calculation can't contain the checksum
+          if (packet.bytes_received == sizeof(Packet::Header) - 2)
+            packet.header_checksum = packet.checksum;
+
+          if (packet.bytes_received == sizeof(Packet::Header)) {
+            if (packet.header().checksum == packet.header_checksum) {
+              // The SYNC control packet is a special case in that it doesn't require the stream sync to be correct
+              if (static_cast<Protocol>(packet.header().protocol()) == Protocol::CONTROL && static_cast<ProtocolControl>(packet.header().type()) == ProtocolControl::SYNC) {
+                  SERIAL_ECHOLNPAIR("ss", sync, ",", buffer_size, ",", VERSION_MAJOR, ".", VERSION_MINOR, ".", VERSION_PATCH);
+                  stream_state = StreamState::PACKET_RESET;
+                  break;
+              }
+              if (packet.header().sync == sync) {
+                buffer_next_index = 0;
+                packet.bytes_received = 0;
+                if (packet.header().size) {
+                  stream_state = StreamState::PACKET_DATA;
+                  packet.buffer = static_cast<char *>(&buffer[0]); // multipacket buffering not implemented, always allocate whole buffer to packet
+                }
+                else
+                  stream_state = StreamState::PACKET_PROCESS;
+              }
+              else if (packet.header().sync == sync - 1) {           // ok response must have been lost
+                SERIAL_ECHOLNPAIR("ok", packet.header().sync);  // transmit valid packet received and drop the payload
+                stream_state = StreamState::PACKET_RESET;
+              }
+              else if (packet_retries) {
+                stream_state = StreamState::PACKET_RESET; // could be packets already buffered on flow controlled connections, drop them without ack
+              }
+              else {
+                SERIAL_ECHO_MSG("Datastream packet out of order");
+                stream_state = StreamState::PACKET_RESEND;
+              }
+            }
+            else {
+              SERIAL_ECHO_START();
+              SERIAL_ECHOLNPAIR("Packet Header(", packet.header().sync, "?) Corrupt");
+              stream_state = StreamState::PACKET_RESEND;
+            }
+          }
+          break;
+        case StreamState::PACKET_DATA:
+          if (!stream_read(data)) break;
+
+          if (buffer_next_index < buffer_size)
+            packet.buffer[buffer_next_index] = data;
+          else {
+            SERIAL_ECHO_MSG("Datastream packet data buffer overrun");
+            stream_state = StreamState::PACKET_ERROR;
+            break;
+          }
+
+          packet.checksum = checksum(packet.checksum, data);
+          packet.bytes_received++;
+          buffer_next_index++;
+
+          if (packet.bytes_received == packet.header().size) {
+            stream_state = StreamState::PACKET_FOOTER;
+            packet.bytes_received = 0;
+          }
+          break;
+        case StreamState::PACKET_FOOTER:
+          if (!stream_read(data)) break;
+
+          packet.footer_data[packet.bytes_received++] = data;
+          if (packet.bytes_received == sizeof(Packet::Footer)) {
+            if (packet.footer().checksum == packet.checksum) {
+              stream_state = StreamState::PACKET_PROCESS;
+            }
+            else {
+              SERIAL_ECHO_START();
+              SERIAL_ECHOLNPAIR("Packet(", packet.header().sync, ") Payload Corrupt");
+              stream_state = StreamState::PACKET_RESEND;
+            }
+          }
+          break;
+        case StreamState::PACKET_PROCESS:
+          sync++;
+          packet_retries = 0;
+          bytes_received += packet.header().size;
+
+          SERIAL_ECHOLNPAIR("ok", packet.header().sync); // transmit valid packet received
+          dispatch();
+          stream_state = StreamState::PACKET_RESET;
+          break;
+        case StreamState::PACKET_RESEND:
+          if (packet_retries < MAX_RETRIES || MAX_RETRIES == 0) {
+            packet_retries++;
+            stream_state = StreamState::PACKET_RESET;
+            SERIAL_ECHO_START();
+            SERIAL_ECHOLNPAIR("Resend request ", int(packet_retries));
+            SERIAL_ECHOLNPAIR("rs", sync);
+          }
+          else
+            stream_state = StreamState::PACKET_ERROR;
+          break;
+        case StreamState::PACKET_TIMEOUT:
+          SERIAL_ECHO_MSG("Datastream timeout");
+          stream_state = StreamState::PACKET_RESEND;
+          break;
+        case StreamState::PACKET_ERROR:
+          SERIAL_ECHOLNPAIR("fe", packet.header().sync);
+          reset(); // reset everything, resync required
+          stream_state = StreamState::PACKET_RESET;
+          break;
+      }
+    }
+  }
+
+  void dispatch() {
+    switch(static_cast<Protocol>(packet.header().protocol())) {
+      case Protocol::CONTROL:
+        switch(static_cast<ProtocolControl>(packet.header().type())) {
+          case ProtocolControl::CLOSE: // revert back to ASCII mode
+            card.flag.binary_mode = false;
+            break;
+          default:
+            SERIAL_ECHO_MSG("Unknown BinaryProtocolControl Packet");
+        }
+        break;
+      case Protocol::FILE_TRANSFER:
+        SDFileTransferProtocol::process(packet.header().type(), packet.buffer, packet.header().size); // send user data to be processed
+      break;
+      default:
+        SERIAL_ECHO_MSG("Unsupported Binary Protocol");
+    }
+  }
+
+  void idle() {
+    // Some Protocols may need periodic updates without new data
+    SDFileTransferProtocol::idle();
+  }
+
+  static const uint16_t PACKET_MAX_WAIT = 500, RX_TIMESLICE = 20, MAX_RETRIES = 0, VERSION_MAJOR = 0, VERSION_MINOR = 1, VERSION_PATCH = 0;
+  uint8_t  packet_retries, sync;
+  uint16_t buffer_next_index;
+  uint32_t bytes_received;
+  StreamState stream_state = StreamState::PACKET_RESET;
+};
+
+extern BinaryStream binaryStream[NUM_SERIAL];
@@ -36,35 +36,37 @@ void controllerfan_update() {
  if (ELAPSED(ms, nextMotorCheck)) {
    nextMotorCheck = ms + 2500UL; // Not a time critical function, so only check every 2.5s

+    const bool xory = X_ENABLE_READ() == X_ENABLE_ON || Y_ENABLE_READ() == Y_ENABLE_ON;
+
    // If any of the drivers or the bed are enabled...
-    if (X_ENABLE_READ == X_ENABLE_ON || Y_ENABLE_READ == Y_ENABLE_ON || Z_ENABLE_READ == Z_ENABLE_ON
+    if (xory || Z_ENABLE_READ() == Z_ENABLE_ON
      #if HAS_HEATED_BED
        || thermalManager.temp_bed.soft_pwm_amount > 0
      #endif
        #if HAS_X2_ENABLE
-          || X2_ENABLE_READ == X_ENABLE_ON
+          || X2_ENABLE_READ() == X_ENABLE_ON
        #endif
        #if HAS_Y2_ENABLE
-          || Y2_ENABLE_READ == Y_ENABLE_ON
+          || Y2_ENABLE_READ() == Y_ENABLE_ON
        #endif
        #if HAS_Z2_ENABLE
-          || Z2_ENABLE_READ == Z_ENABLE_ON
+          || Z2_ENABLE_READ() == Z_ENABLE_ON
        #endif
        #if HAS_Z3_ENABLE
-          || Z3_ENABLE_READ == Z_ENABLE_ON
+          || Z3_ENABLE_READ() == Z_ENABLE_ON
        #endif
        #if E_STEPPERS
-          || E0_ENABLE_READ == E_ENABLE_ON
+          || E0_ENABLE_READ() == E_ENABLE_ON
          #if E_STEPPERS > 1
-            || E1_ENABLE_READ == E_ENABLE_ON
+            || E1_ENABLE_READ() == E_ENABLE_ON
            #if E_STEPPERS > 2
-              || E2_ENABLE_READ == E_ENABLE_ON
+              || E2_ENABLE_READ() == E_ENABLE_ON
              #if E_STEPPERS > 3
-                || E3_ENABLE_READ == E_ENABLE_ON
+                || E3_ENABLE_READ() == E_ENABLE_ON
                #if E_STEPPERS > 4
-                  || E4_ENABLE_READ == E_ENABLE_ON
+                  || E4_ENABLE_READ() == E_ENABLE_ON
                  #if E_STEPPERS > 5
-                    || E5_ENABLE_READ == E_ENABLE_ON
+                    || E5_ENABLE_READ() == E_ENABLE_ON
                  #endif // E_STEPPERS > 5
                #endif // E_STEPPERS > 4
              #endif // E_STEPPERS > 3
@@ -76,12 +78,17 @@ void controllerfan_update() {
    }

    // Fan off if no steppers have been enabled for CONTROLLERFAN_SECS seconds
-    uint8_t speed = (!lastMotorOn || ELAPSED(ms, lastMotorOn + (CONTROLLERFAN_SECS) * 1000UL)) ? 0 : CONTROLLERFAN_SPEED;
-    controllerfan_speed = speed;
+    controllerfan_speed = (!lastMotorOn || ELAPSED(ms, lastMotorOn + (CONTROLLERFAN_SECS) * 1000UL)) ? 0 : (
+      #ifdef CONTROLLERFAN_SPEED_Z_ONLY
+        xory ? CONTROLLERFAN_SPEED : CONTROLLERFAN_SPEED_Z_ONLY
+      #else
+        CONTROLLERFAN_SPEED
+      #endif
+    );

-    // allows digital or PWM fan output to be used (see M42 handling)
-    WRITE(CONTROLLER_FAN_PIN, speed);
-    analogWrite(pin_t(CONTROLLER_FAN_PIN), speed);
+    // Allow digital or PWM fan output (see M42 handling)
+    WRITE(CONTROLLER_FAN_PIN, controllerfan_speed);
+    analogWrite(pin_t(CONTROLLER_FAN_PIN), controllerfan_speed);
  }
 }

@@ -37,8 +37,6 @@
  #include "runout.h"
 #endif

-extern bool wait_for_user;
-
 void host_action(const char * const pstr, const bool eol) {
  SERIAL_ECHOPGM("//action:");
  serialprintPGM(pstr);
@@ -66,6 +64,10 @@ void host_action(const char * const pstr, const bool eol) {

 #if ENABLED(HOST_PROMPT_SUPPORT)

+  #if HAS_RESUME_CONTINUE
+    extern bool wait_for_user;
+  #endif
+
  PromptReason host_prompt_reason = PROMPT_NOT_DEFINED;

  void host_action_prompt(const char * const ptype, const bool eol=true) {
@@ -141,8 +143,10 @@ void host_action(const char * const pstr, const bool eol) {
        }
        break;
      case PROMPT_USER_CONTINUE:
+        #if HAS_RESUME_CONTINUE
+          wait_for_user = false;
+        #endif
        msg = PSTR("FILAMENT_RUNOUT_CONTINUE");
-        wait_for_user = false;
        break;
      case PROMPT_PAUSE_RESUME:
        msg = PSTR("LCD_PAUSE_RESUME");
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				`custom: http://www.thinkyhead.com/donate-to-marlin`