Implement HAL and apply macros across code-base

Implement AVR Platform

.gitignore

 
 # PlatformIO files/dirs
 .pio*
-lib/readme.txt
+.pioenvs
+.piolibdeps
+.clang_complete
+.gcc-flags.json
+lib/
 
 #Visual Studio
 *.sln

Marlin/Conditionals_post.h

     #define DEFAULT_KEEPALIVE_INTERVAL 2
   #endif
 
+  #ifdef CPU_32_BIT
+    /**
+     * Hidden options for developer
+     */
+    // Double stepping start from STEP_DOUBLER_FREQUENCY + 1, quad stepping start from STEP_DOUBLER_FREQUENCY * 2 + 1
+    #ifndef STEP_DOUBLER_FREQUENCY
+      #if ENABLED(ADVANCE) || ENABLED(LIN_ADVANCE)
+        #define STEP_DOUBLER_FREQUENCY 60000 // Hz
+      #else
+        #define STEP_DOUBLER_FREQUENCY 80000 // Hz
+      #endif
+    #endif
+    // Disable double / quad stepping
+    //#define DISABLE_MULTI_STEPPING
+  #endif
+
   /**
    * Provide a MAX_AUTORETRACT for older configs
    */
    * MAX_STEP_FREQUENCY differs for TOSHIBA
    */
   #if ENABLED(CONFIG_STEPPERS_TOSHIBA)
-    #define MAX_STEP_FREQUENCY 10000 // Max step frequency for Toshiba Stepper Controllers
+    #ifdef CPU_32_BIT
+      #define MAX_STEP_FREQUENCY STEP_DOUBLER_FREQUENCY // Max step frequency for Toshiba Stepper Controllers, 96kHz is close to maximum for an Arduino Due
+    #else
+      #define MAX_STEP_FREQUENCY 10000 // Max step frequency for Toshiba Stepper Controllers
+    #endif
   #else
-    #define MAX_STEP_FREQUENCY 40000 // Max step frequency for Ultimaker (5000 pps / half step)
+    #ifdef CPU_32_BIT
+      #define MAX_STEP_FREQUENCY (STEP_DOUBLER_FREQUENCY * 4) // Max step frequency for the Due is approx. 330kHz
+    #else
+      #define MAX_STEP_FREQUENCY 40000 // Max step frequency for Ultimaker (5000 pps / half step)
+    #endif
   #endif
 
   // MS1 MS2 Stepper Driver Microstepping mode table
   #define MICROSTEP2 HIGH,LOW
   #define MICROSTEP4 LOW,HIGH
   #define MICROSTEP8 HIGH,HIGH
+  #ifdef __SAM3X8E__
+    #if MB(ALLIGATOR)
+      #define MICROSTEP16 LOW,LOW
+      #define MICROSTEP32 HIGH,HIGH
+    #else
+      #define MICROSTEP16 HIGH,HIGH
+    #endif
+  #else
   #define MICROSTEP16 HIGH,HIGH
+  #endif
 
   /**
    * Advance calculated values
     #define BED_USES_THERMISTOR
   #endif
 
+  #ifdef __SAM3X8E__
+    #define HEATER_USES_AD595 (ENABLED(HEATER_0_USES_AD595) || ENABLED(HEATER_1_USES_AD595) || ENABLED(HEATER_2_USES_AD595) || ENABLED(HEATER_3_USES_AD595))
+  #endif
+
   /**
    * Flags for PID handling
    */
 
   // Stepper pulse duration, in cycles
   #define STEP_PULSE_CYCLES ((MINIMUM_STEPPER_PULSE) * CYCLES_PER_MICROSECOND)
+  #ifdef CPU_32_BIT
+    // Add additional delay for between direction signal and pulse signal of stepper
+    #ifndef STEPPER_DIRECTION_DELAY
+      #define STEPPER_DIRECTION_DELAY 0 // time in microseconds
+    #endif
+  #endif
+
+  #ifndef __SAM3X8E__ //todo: hal: broken hal encapsulation
+    #undef UI_VOLTAGE_LEVEL
+    #undef RADDS_DISPLAY
+    #undef MOTOR_CURRENT
+  #endif
 
   #if ENABLED(SDCARD_SORT_ALPHA)
     #define HAS_FOLDER_SORTING (FOLDER_SORTING || ENABLED(SDSORT_GCODE))
     #endif
   #endif
 
+  // Use float instead of double. Needs profiling.
+  #if defined(ARDUINO_ARCH_SAM) && ENABLED(DELTA_FAST_SQRT)
+    #undef ATAN2
+    #undef FABS
+    #undef POW
+    #undef SQRT
+    #undef CEIL
+    #undef FLOOR
+    #undef LROUND
+    #undef FMOD
+    #define ATAN2(y, x) atan2f(y, x)
+    #define FABS(x) fabsf(x)
+    #define POW(x, y) powf(x, y)
+    #define SQRT(x) sqrtf(x)
+    #define CEIL(x) ceilf(x)
+    #define FLOOR(x) floorf(x)
+    #define LROUND(x) lroundf(x)
+    #define FMOD(x, y) fmodf(x, y)
+  #endif
+
+  #ifdef TEENSYDUINO
+    #undef max
+    #define max(a,b) ((a)>(b)?(a):(b))
+    #undef min
+    #define min(a,b) ((a)<(b)?(a):(b))
+
+    #define NOT_A_PIN 0 // For PINS_DEBUGGING
+  #endif
 #endif // CONDITIONALS_POST_H

Marlin/Marlin.h

 #include <string.h>
 #include <inttypes.h>
 
-#include <util/delay.h>
-#include <avr/pgmspace.h>
-#include <avr/eeprom.h>
-#include <avr/interrupt.h>
-
 #include "MarlinConfig.h"
 
 #ifdef DEBUG_GCODE_PARSER
   #include "gcode.h"
 #endif
+#include "src/HAL/HAL.h"
 
 #include "enum.h"
 #include "types.h"
-#include "fastio.h"
 #include "utility.h"
 #include "serial.h"
 

Marlin/MarlinConfig.h

 #ifndef MARLIN_CONFIG_H
 #define MARLIN_CONFIG_H
 
-#include "fastio.h"
 #include "macros.h"
+#include "src/HAL/HAL.h"
 #include "boards.h"
 #include "Version.h"
 #include "Configuration.h"
 #include "Conditionals_LCD.h"
 #include "Configuration_adv.h"
 #include "pins.h"
-#ifndef USBCON
+#if defined(ARDUINO_ARCH_AVR) && !defined(USBCON)
   #define HardwareSerial_h // trick to disable the standard HWserial
 #endif
-#include "Arduino.h"
 #include "Conditionals_post.h"
 #include "SanityCheck.h"
 

Marlin/Marlin_main.cpp

 #include "cardreader.h"
 #include "configuration_store.h"
 #include "language.h"
-#include "pins_arduino.h"
+#ifdef ARDUINO
+  #include "pins_arduino.h"
+#endif
 #include "math.h"
 #include "nozzle.h"
 #include "duration_t.h"
   #include "buzzer.h"
 #endif
 
-#if ENABLED(USE_WATCHDOG)
-  #include "watchdog.h"
-#endif
-
 #if ENABLED(MAX7219_DEBUG)
   #include "Max7219_Debug_LEDs.h"
 #endif
 #endif
 
 #if HAS_SERVOS
-  #include "servo.h"
+  #include "src/HAL/servo.h"
 #endif
 
 #if HAS_DIGIPOTSS
 #endif
 
 #if ENABLED(ENDSTOP_INTERRUPTS_FEATURE)
-  #include "endstop_interrupts.h"
+  #include "src/HAL/HAL_endstop_interrupts.h"
 #endif
 
 #if ENABLED(M100_FREE_MEMORY_WATCHER)
 static bool send_ok[BUFSIZE];
 
 #if HAS_SERVOS
-  Servo servo[NUM_SERVOS];
+  HAL_SERVO_LIB servo[NUM_SERVOS];
   #define MOVE_SERVO(I, P) servo[I].move(P)
   #if HAS_Z_SERVO_ENDSTOP
     #define DEPLOY_Z_SERVO() MOVE_SERVO(Z_ENDSTOP_SERVO_NR, z_servo_angle[0])
 
 #endif
 
-#if ENABLED(SDSUPPORT)
-  #include "SdFatUtil.h"
-  int freeMemory() { return SdFatUtil::FreeRam(); }
-#else
-extern "C" {
-  extern char __bss_end;
-  extern char __heap_start;
-  extern void* __brkval;
-
-  int freeMemory() {
-    int free_memory;
-    if ((int)__brkval == 0)
-      free_memory = ((int)&free_memory) - ((int)&__bss_end);
-    else
-      free_memory = ((int)&free_memory) - ((int)__brkval);
-    return free_memory;
-  }
-}
-#endif // !SDSUPPORT
-
 #if ENABLED(DIGIPOT_I2C)
   extern void digipot_i2c_set_current(uint8_t channel, float current);
   extern void digipot_i2c_init();
     delta_diagonal_rod_2_tower[C_AXIS] = sq(diagonal_rod + drt[C_AXIS]);
   }
 
-  #if ENABLED(DELTA_FAST_SQRT)
+  #if ENABLED(DELTA_FAST_SQRT) && defined(ARDUINO_ARCH_AVR)
     /**
      * Fast inverse sqrt from Quake III Arena
      * See: https://en.wikipedia.org/wiki/Fast_inverse_square_root
   #endif
 
   MYSERIAL.begin(BAUDRATE);
+  while(!MYSERIAL);
   SERIAL_PROTOCOLLNPGM("start");
   SERIAL_ECHO_START();
 
   // Check startup - does nothing if bootloader sets MCUSR to 0
-  byte mcu = MCUSR;
+  byte mcu = HAL_get_reset_source();
   if (mcu &  1) SERIAL_ECHOLNPGM(MSG_POWERUP);
   if (mcu &  2) SERIAL_ECHOLNPGM(MSG_EXTERNAL_RESET);
   if (mcu &  4) SERIAL_ECHOLNPGM(MSG_BROWNOUT_RESET);
   if (mcu &  8) SERIAL_ECHOLNPGM(MSG_WATCHDOG_RESET);
   if (mcu & 32) SERIAL_ECHOLNPGM(MSG_SOFTWARE_RESET);
-  MCUSR = 0;
+  HAL_clear_reset_source();
+
+  #if ENABLED(USE_WATCHDOG) //reinit watchdog after HAL_get_reset_source call
+    watchdog_init();
+  #endif
 
   SERIAL_ECHOPGM(MSG_MARLIN);
   SERIAL_CHAR(' ');
 
   thermalManager.init();    // Initialize temperature loop
 
-  #if ENABLED(USE_WATCHDOG)
-    watchdog_init();
-  #endif
-
   stepper.init();    // Initialize stepper, this enables interrupts!
   servo_init();
 
   endstops.report_state();
   idle();
 }
-

Marlin/Sd2Card.cpp

 #if ENABLED(SDSUPPORT)
 #include "Sd2Card.h"
 
-#if ENABLED(USE_WATCHDOG)
-  #include "watchdog.h"
-#endif
-
-//------------------------------------------------------------------------------
-#if DISABLED(SOFTWARE_SPI)
-  // functions for hardware SPI
-  //------------------------------------------------------------------------------
-  // make sure SPCR rate is in expected bits
-  #if (SPR0 != 0 || SPR1 != 1)
-    #error "unexpected SPCR bits"
-  #endif
-  /**
-   * Initialize hardware SPI
-   * Set SCK rate to F_CPU/pow(2, 1 + spiRate) for spiRate [0,6]
-   */
-  static void spiInit(uint8_t spiRate) {
-    // See avr processor documentation
-    SPCR = _BV(SPE) | _BV(MSTR) | (spiRate >> 1);
-    SPSR = spiRate & 1 || spiRate == 6 ? 0 : _BV(SPI2X);
-  }
-  //------------------------------------------------------------------------------
-  /** SPI receive a byte */
-  static uint8_t spiRec() {
-    SPDR = 0xFF;
-    while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
-    return SPDR;
-  }
-  //------------------------------------------------------------------------------
-  /** SPI read data - only one call so force inline */
-  static inline __attribute__((always_inline))
-  void spiRead(uint8_t* buf, uint16_t nbyte) {
-    if (nbyte-- == 0) return;
-    SPDR = 0xFF;
-    for (uint16_t i = 0; i < nbyte; i++) {
-      while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
-      buf[i] = SPDR;
-      SPDR = 0xFF;
-    }
-    while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
-    buf[nbyte] = SPDR;
-  }
-  //------------------------------------------------------------------------------
-  /** SPI send a byte */
-  static void spiSend(uint8_t b) {
-    SPDR = b;
-    while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
-  }
-  //------------------------------------------------------------------------------
-  /** SPI send block - only one call so force inline */
-  static inline __attribute__((always_inline))
-  void spiSendBlock(uint8_t token, const uint8_t* buf) {
-    SPDR = token;
-    for (uint16_t i = 0; i < 512; i += 2) {
-      while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
-      SPDR = buf[i];
-      while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
-      SPDR = buf[i + 1];
-    }
-    while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
-  }
-       //------------------------------------------------------------------------------
-#else  // SOFTWARE_SPI
-       //------------------------------------------------------------------------------
-  /** nop to tune soft SPI timing */
-  #define nop asm volatile ("nop\n\t")
-  //------------------------------------------------------------------------------
-  /** Soft SPI receive byte */
-  static uint8_t spiRec() {
-    uint8_t data = 0;
-    // no interrupts during byte receive - about 8 us
-    cli();
-    // output pin high - like sending 0xFF
-    WRITE(SPI_MOSI_PIN, HIGH);
-
-    for (uint8_t i = 0; i < 8; i++) {
-      WRITE(SPI_SCK_PIN, HIGH);
-
-      // adjust so SCK is nice
-      nop;
-      nop;
-
-      data <<= 1;
-
-      if (READ(SPI_MISO_PIN)) data |= 1;
-
-      WRITE(SPI_SCK_PIN, LOW);
-    }
-    // enable interrupts
-    sei();
-    return data;
-  }
-  //------------------------------------------------------------------------------
-  /** Soft SPI read data */
-  static void spiRead(uint8_t* buf, uint16_t nbyte) {
-    for (uint16_t i = 0; i < nbyte; i++)
-      buf[i] = spiRec();
-  }
-  //------------------------------------------------------------------------------
-  /** Soft SPI send byte */
-  static void spiSend(uint8_t data) {
-    // no interrupts during byte send - about 8 us
-    cli();
-    for (uint8_t i = 0; i < 8; i++) {
-      WRITE(SPI_SCK_PIN, LOW);
-
-      WRITE(SPI_MOSI_PIN, data & 0x80);
-
-      data <<= 1;
-
-      WRITE(SPI_SCK_PIN, HIGH);
-    }
-    // hold SCK high for a few ns
-    nop;
-    nop;
-    nop;
-    nop;
-
-    WRITE(SPI_SCK_PIN, LOW);
-    // enable interrupts
-    sei();
-  }
-  //------------------------------------------------------------------------------
-  /** Soft SPI send block */
-  void spiSendBlock(uint8_t token, const uint8_t* buf) {
-    spiSend(token);
-    for (uint16_t i = 0; i < 512; i++)
-      spiSend(buf[i]);
-  }
-#endif  // SOFTWARE_SPI
 //------------------------------------------------------------------------------
 // send command and return error code.  Return zero for OK
 uint8_t Sd2Card::cardCommand(uint8_t cmd, uint32_t arg) {
   #endif
 
   // set pin modes
-  pinMode(chipSelectPin_, OUTPUT);
-  chipSelectHigh();
-  SET_INPUT(SPI_MISO_PIN);
-  SET_OUTPUT(SPI_MOSI_PIN);
-  SET_OUTPUT(SPI_SCK_PIN);
+//todo: should use chipSelectPin ?
+  spiBegin();
 
-  #if DISABLED(SOFTWARE_SPI)
-    // SS must be in output mode even it is not chip select
-    SET_OUTPUT(SS_PIN);
-    // set SS high - may be chip select for another SPI device
-    #if SET_SPI_SS_HIGH
-      WRITE(SS_PIN, HIGH);
-    #endif  // SET_SPI_SS_HIGH
-    // set SCK rate for initialization commands
-    spiRate_ = SPI_SD_INIT_RATE;
-    spiInit(spiRate_);
-  #endif  // SOFTWARE_SPI
+  // set SCK rate for initialization commands
+  spiRate_ = SPI_SD_INIT_RATE;
+  spiInit(spiRate_);
 
   // must supply min of 74 clock cycles with CS high.
   for (uint8_t i = 0; i < 10; i++) spiSend(0xFF);

Marlin/Sd2Card.h

 #include "SdFatConfig.h"
 #include "SdInfo.h"
 //------------------------------------------------------------------------------
-// SPI speed is F_CPU/2^(1 + index), 0 <= index <= 6
-/** Set SCK to max rate of F_CPU/2. See Sd2Card::setSckRate(). */
-uint8_t const SPI_FULL_SPEED = 0;
-/** Set SCK rate to F_CPU/4. See Sd2Card::setSckRate(). */
-uint8_t const SPI_HALF_SPEED = 1;
-/** Set SCK rate to F_CPU/8. See Sd2Card::setSckRate(). */
-uint8_t const SPI_QUARTER_SPEED = 2;
-/** Set SCK rate to F_CPU/16. See Sd2Card::setSckRate(). */
-uint8_t const SPI_EIGHTH_SPEED = 3;
-/** Set SCK rate to F_CPU/32. See Sd2Card::setSckRate(). */
-uint8_t const SPI_SIXTEENTH_SPEED = 4;
-//------------------------------------------------------------------------------
 /** init timeout ms */
 uint16_t const SD_INIT_TIMEOUT = 2000;
 /** erase timeout ms */
 //------------------------------------------------------------------------------
 // SPI pin definitions - do not edit here - change in SdFatConfig.h
 //
+#define SD_CHIP_SELECT_PIN SS_PIN
+
+#if 0
 #if DISABLED(SOFTWARE_SPI)
   // hardware pin defs
   /** The default chip select pin for the SD card is SS. */
   /** SPI Clock pin */
   #define SPI_SCK_PIN SOFT_SPI_SCK_PIN
 #endif  // SOFTWARE_SPI
+
+#endif
+
 //------------------------------------------------------------------------------
 /**
  * \class Sd2Card

Marlin/SdFile.h

 
 #if ENABLED(SDSUPPORT)
 #include "SdBaseFile.h"
-#include <Print.h>
+//todo: HAL: create wrapper for Print?
+//#include <Print.h>
 #ifndef SdFile_h
 #define SdFile_h
 //------------------------------------------------------------------------------
  * \class SdFile
  * \brief SdBaseFile with Print.
  */
-class SdFile : public SdBaseFile, public Print {
+class SdFile : public SdBaseFile/*, public Print*/ {
  public:
   SdFile() {}
   SdFile(const char* name, uint8_t oflag);

Marlin/boards.h

 #define BOARD_BRAINWAVE         82   // Brainwave (AT90USB646)
 #define BOARD_SAV_MKI           83   // SAV Mk-I (AT90USB1286)
 #define BOARD_TEENSY2           84   // Teensy++2.0 (AT90USB1286) - CLI compile: HARDWARE_MOTHERBOARD=84  make
+#define BOARD_TEENSY35_36       841  // Teensy3.5 and Teensy3.6
 #define BOARD_BRAINWAVE_PRO     85   // Brainwave Pro (AT90USB1286)
 #define BOARD_GEN3_PLUS         9    // Gen3+
 #define BOARD_GEN3_MONOLITHIC   22   // Gen3 Monolithic Electronics
 #define BOARD_BAM_DICE_DUE      402  // 2PrintBeta BAM&DICE Due with STK drivers
 #define BOARD_BQ_ZUM_MEGA_3D    503  // bq ZUM Mega 3D
 #define BOARD_ZRIB_V20          504  // zrib V2.0 control board (Chinese knock off RAMPS replica)
+//ARM 32
+#define BOARD_DUE3DOM          1411  // DUE3DOM for Arduino DUE
+#define BOARD_DUE3DOM_MINI     1412  // DUE3DOM MINI for Arduino DUE
+#define BOARD_RADDS            1502  // RADDS
+#define BOARD_RAMPS_FD_V1      1503  // RAMPS-FD v1
+#define BOARD_RAMPS_FD_V2      1504  // RAMPS-FD v2
+#define BOARD_RAMPS_SMART_EFB  1523  // RAMPS-SMART (Power outputs: Hotend, Fan, Bed)
+#define BOARD_RAMPS_SMART_EEB  1524  // RAMPS-SMART (Power outputs: Hotend0, Hotend1, Bed)
+#define BOARD_RAMPS_SMART_EFF  1525  // RAMPS-SMART (Power outputs: Hotend, Fan0, Fan1)
+#define BOARD_RAMPS_SMART_EEF  1526  // RAMPS-SMART (Power outputs: Hotend0, Hotend1, Fan)
+#define BOARD_RAMPS_SMART_SF   1528  // RAMPS-SMART (Power outputs: Spindle, Controller Fan)
+#define BOARD_RAMPS_DUO_EFB    1533  // RAMPS Duo (Power outputs: Hotend, Fan, Bed)
+#define BOARD_RAMPS_DUO_EEB    1534  // RAMPS Duo (Power outputs: Hotend0, Hotend1, Bed)
+#define BOARD_RAMPS_DUO_EFF    1535  // RAMPS Duo (Power outputs: Hotend, Fan0, Fan1)
+#define BOARD_RAMPS_DUO_EEF    1536  // RAMPS Duo (Power outputs: Hotend0, Hotend1, Fan)
+#define BOARD_RAMPS_DUO_SF     1538  // RAMPS Duo (Power outputs: Spindle, Controller Fan)
+#define BOARD_RAMPS4DUE_EFB    1543  // RAMPS4DUE (Power outputs: Hotend, Fan, Bed)
+#define BOARD_RAMPS4DUE_EEB    1544  // RAMPS4DUE (Power outputs: Hotend0, Hotend1, Bed)
+#define BOARD_RAMPS4DUE_EFF    1545  // RAMPS4DUE (Power outputs: Hotend, Fan0, Fan1)
+#define BOARD_RAMPS4DUE_EEF    1546  // RAMPS4DUE (Power outputs: Hotend0, Hotend1, Fan)
+#define BOARD_RAMPS4DUE_SF     1548  // RAMPS4DUE (Power outputs: Spindle, Controller Fan)
+#define BOARD_ALLIGATOR        1602  // Alligator Board R2
 
 #define MB(board) (MOTHERBOARD==BOARD_##board)
 

Marlin/buzzer.h

 #define __BUZZER_H__
 
 #include "types.h"
-#include "fastio.h"
 #include "circularqueue.h"
 #include "temperature.h"
 

Marlin/circularqueue.h

 #ifndef __CIRCULARQUEUE_H__
 #define __CIRCULARQUEUE_H__
 
-#include <Arduino.h>
+#include <stdint.h>
 
 /**
  * @brief   Circular Queue class

Marlin/configuration_store.cpp

 }
 
 #if ENABLED(EEPROM_SETTINGS)
+  #include "src/HAL/persistent_store_api.h"
 
   #define DUMMY_PID_VALUE 3000.0f
-  #define EEPROM_START() int eeprom_index = EEPROM_OFFSET
+  #define EEPROM_START() int eeprom_index = EEPROM_OFFSET; HAL::PersistentStore::access_start()
+  #define EEPROM_FINISH() HAL::PersistentStore::access_finish()
   #define EEPROM_SKIP(VAR) eeprom_index += sizeof(VAR)
-  #define EEPROM_WRITE(VAR) write_data(eeprom_index, (uint8_t*)&VAR, sizeof(VAR), &working_crc)
-  #define EEPROM_READ(VAR) read_data(eeprom_index, (uint8_t*)&VAR, sizeof(VAR), &working_crc)
+  #define EEPROM_WRITE(VAR) HAL::PersistentStore::write_data(eeprom_index, (uint8_t*)&VAR, sizeof(VAR), &working_crc)
+  #define EEPROM_READ(VAR) HAL::PersistentStore::read_data(eeprom_index, (uint8_t*)&VAR, sizeof(VAR), &working_crc)
   #define EEPROM_ASSERT(TST,ERR) if (!(TST)) do{ SERIAL_ERROR_START(); SERIAL_ERRORLNPGM(ERR); eeprom_read_error = true; }while(0)
 
   const char version[4] = EEPROM_VERSION;
     int MarlinSettings::meshes_begin;
   #endif
 
-  void MarlinSettings::write_data(int &pos, const uint8_t *value, uint16_t size, uint16_t *crc) {
-    if (eeprom_error) return;
-    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_START();
-          SERIAL_ECHOLNPGM(MSG_ERR_EEPROM_WRITE);
-          eeprom_error = true;
-          return;
-        }
-      }
-      crc16(crc, &v, 1);
-      pos++;
-      value++;
-    };
-  }
-
-  void MarlinSettings::read_data(int &pos, uint8_t* value, uint16_t size, uint16_t *crc) {
-    if (eeprom_error) return;
-    do {
-      uint8_t c = eeprom_read_byte((unsigned char*)pos);
-      *value = c;
-      crc16(crc, &c, 1);
-      pos++;
-      value++;
-    } while (--size);
-  }
-
   /**
    * M500 - Store Configuration
    */
       if (ubl.state.storage_slot >= 0)
         store_mesh(ubl.state.storage_slot);
     #endif
-
+    EEPROM_FINISH();
     return !eeprom_error;
   }
 
     #if ENABLED(EEPROM_CHITCHAT) && DISABLED(DISABLE_M503)
       report();
     #endif
+    EEPROM_FINISH();
 
     return !eeprom_error;
   }
         uint16_t crc = 0;
         int pos = meshes_end - (slot + 1) * sizeof(ubl.z_values);
 
-        write_data(pos, (uint8_t *)&ubl.z_values, sizeof(ubl.z_values), &crc);
+        HAL::PersistentStore::write_data(pos, (uint8_t *)&ubl.z_values, sizeof(ubl.z_values), &crc);
 
         // Write crc to MAT along with other data, or just tack on to the beginning or end
 
         uint16_t crc = 0;
         int pos = meshes_end - (slot + 1) * sizeof(ubl.z_values);
         uint8_t * const dest = into ? (uint8_t*)into : (uint8_t*)&ubl.z_values;
-        read_data(pos, dest, sizeof(ubl.z_values), &crc);
+        HAL::PersistentStore::read_data(pos, dest, sizeof(ubl.z_values), &crc);
 
         // Compare crc with crc from MAT, or read from end
 

Marlin/configuration_store.h

 
       #endif
 
-      static void write_data(int &pos, const uint8_t *value, uint16_t size, uint16_t *crc);
-      static void read_data(int &pos, uint8_t *value, uint16_t size, uint16_t *crc);
     #endif
 };
 

Marlin/dac_dac084s085.cpp

+/***************************************************************
+ *
+ * External DAC for Alligator Board
+ *
+ ****************************************************************/
+#include "Marlin.h"
+
+#if MB(ALLIGATOR)
+  #include "stepper.h"
+  #include "dac_dac084s085.h"
+
+  dac084s085::dac084s085() {
+    return ;
+  }
+
+  void dac084s085::begin() {
+    uint8_t externalDac_buf[2] = {0x20,0x00};//all off
+
+    // All SPI chip-select HIGH
+    pinMode (DAC0_SYNC, OUTPUT);
+    digitalWrite( DAC0_SYNC , HIGH );
+    #if EXTRUDERS > 1
+      pinMode (DAC1_SYNC, OUTPUT);
+      digitalWrite( DAC1_SYNC , HIGH );
+    #endif
+    digitalWrite( SPI_EEPROM1_CS , HIGH );
+    digitalWrite( SPI_EEPROM2_CS , HIGH );
+    digitalWrite( SPI_FLASH_CS , HIGH );
+    digitalWrite( SS_PIN , HIGH );
+    spiBegin();
+
+    //init onboard DAC
+    delayMicroseconds(2U);
+    digitalWrite( DAC0_SYNC , LOW );
+    delayMicroseconds(2U);
+    digitalWrite( DAC0_SYNC , HIGH );
+    delayMicroseconds(2U);
+    digitalWrite( DAC0_SYNC , LOW );
+
+    spiSend(SPI_CHAN_DAC,externalDac_buf , 2);
+    digitalWrite( DAC0_SYNC , HIGH );
+
+    #if EXTRUDERS > 1
+      //init Piggy DAC
+      delayMicroseconds(2U);
+      digitalWrite( DAC1_SYNC , LOW );
+      delayMicroseconds(2U);
+      digitalWrite( DAC1_SYNC , HIGH );
+      delayMicroseconds(2U);
+      digitalWrite( DAC1_SYNC , LOW );
+
+      spiSend(SPI_CHAN_DAC,externalDac_buf , 2);
+      digitalWrite( DAC1_SYNC , HIGH );
+    #endif
+
+    return;
+  }
+
+  void dac084s085::setValue(uint8_t channel, uint8_t value) {
+    if(channel >= 7) // max channel (X,Y,Z,E0,E1,E2,E3)
+      return;
+    if(value > 255) value = 255;
+
+    uint8_t externalDac_buf[2] = {0x10,0x00};
+
+    if(channel > 3)
+      externalDac_buf[0] |= (7 - channel << 6);
+    else
+      externalDac_buf[0] |= (3 - channel << 6);
+
+    externalDac_buf[0] |= (value>>4);
+    externalDac_buf[1] |= (value<<4);
+    
+    // All SPI chip-select HIGH
+    digitalWrite( DAC0_SYNC , HIGH );
+    #if EXTRUDERS > 1
+      digitalWrite( DAC1_SYNC , HIGH );
+    #endif
+    digitalWrite( SPI_EEPROM1_CS , HIGH );
+    digitalWrite( SPI_EEPROM2_CS , HIGH );
+    digitalWrite( SPI_FLASH_CS , HIGH );
+    digitalWrite( SS_PIN , HIGH );
+
+    if(channel > 3) { // DAC Piggy E1,E2,E3
+
+      digitalWrite(DAC1_SYNC , LOW);
+      delayMicroseconds(2U);
+      digitalWrite(DAC1_SYNC , HIGH);
+      delayMicroseconds(2U);
+      digitalWrite(DAC1_SYNC , LOW);
+    }
+
+    else { // DAC onboard X,Y,Z,E0
+
+      digitalWrite(DAC0_SYNC , LOW);
+      delayMicroseconds(2U);
+      digitalWrite(DAC0_SYNC , HIGH);
+      delayMicroseconds(2U);
+      digitalWrite(DAC0_SYNC , LOW);
+    }
+
+    delayMicroseconds(2U);
+    spiSend(SPI_CHAN_DAC,externalDac_buf , 2);
+
+    return;
+  }
+
+#endif

Marlin/dac_dac084s085.h

+#ifndef dac084s085_h
+#define dac084s085_h
+
+class dac084s085 {
+  public:
+    dac084s085();
+    static void begin(void);
+    static void setValue(uint8_t channel, uint8_t value);
+};
+
+#endif //dac084s085_h

Marlin/hex_print_routines.cpp

 }
 
 char* hex_address(const void * const w) {
-  (void)hex_word((uint16_t)w);
+  (void)hex_word((int)w);
   return _hex;
 }
 

Marlin/macros.h

 #define _O2          __attribute__((optimize("O2")))
 #define _O3          __attribute__((optimize("O3")))
 
-// Bracket code that shouldn't be interrupted
-#ifndef CRITICAL_SECTION_START
-  #define CRITICAL_SECTION_START  unsigned char _sreg = SREG; cli();
-  #define CRITICAL_SECTION_END    SREG = _sreg;
-#endif
 
 // Clock speed factors
 #define CYCLES_PER_MICROSECOND (F_CPU / 1000000L) // 16 or 20

Marlin/pins.h

 #elif MB(5DPRINT)
   #include "pins_5DPRINT.h"           // AT90USB1286
 
+//
+// 32-bit Boards
+//
+
+#elif MB(TEENSY35_36)
+  #include "pins_TEENSY35_36.h"
+#elif MB(DUE3DOM)
+  #include "pins_DUE3DOM.h"
+#elif MB(DUE3DOM_MINI)
+  #include "pins_DUE3DOM_MINI.h"
+#elif MB(RADDS)
+  #include "pins_RADDS.h"
+#elif MB(RAMPS_FD_V1)
+  #include "pins_RAMPS_FD.h"
+#elif MB(RAMPS_FD_V2)
+  #include "pins_RAMPS_FD_V2.h"
+#elif MB(RAMPS_SMART_EFB)
+  #define IS_RAMPS_EFB
+  #include "pins_RAMPS_SMART.h"
+#elif MB(RAMPS_SMART_EEB)
+  #define IS_RAMPS_EEB
+  #include "pins_RAMPS_SMART.h"
+#elif MB(RAMPS_SMART_EFF)
+  #define IS_RAMPS_EFF
+  #include "pins_RAMPS_SMART.h"
+#elif MB(RAMPS_SMART_EEF)
+  #define IS_RAMPS_EEF
+  #include "pins_RAMPS_SMART.h"
+#elif MB(RAMPS_SMART_SF)
+  #define IS_RAMPS_SF
+  #include "pins_RAMPS_SMART.h"
+#elif MB(RAMPS_DUO_EFB)
+  #define IS_RAMPS_EFB
+  #include "pins_RAMPS_DUO.h"
+#elif MB(RAMPS_DUO_EEB)
+  #define IS_RAMPS_EEB
+  #include "pins_RAMPS_DUO.h"
+#elif MB(RAMPS_DUO_EFF)
+  #define IS_RAMPS_EFF
+  #include "pins_RAMPS_DUO.h"
+#elif MB(RAMPS_DUO_EEF)
+  #define IS_RAMPS_EEF
+  #include "pins_RAMPS_DUO.h"
+#elif MB(RAMPS_DUO_SF)
+  #define IS_RAMPS_SF
+  #include "pins_RAMPS_DUO.h"
+#elif MB(RAMPS4DUE_EFB)
+  #define IS_RAMPS_EFB
+  #include "pins_RAMPS4DUE.h"
+#elif MB(RAMPS4DUE_EEB)
+  #define IS_RAMPS_EEB
+  #include "pins_RAMPS4DUE.h"
+#elif MB(RAMPS4DUE_EFF)
+  #define IS_RAMPS_EFF
+  #include "pins_RAMPS4DUE.h"
+#elif MB(RAMPS4DUE_EEF)
+  #define IS_RAMPS_EEF
+  #include "pins_RAMPS4DUE.h"
+#elif MB(RAMPS4DUE_SF)
+  #define IS_RAMPS_SF
+  #include "pins_RAMPS4DUE.h"
+#elif MB(ALLIGATOR)
+  #include "pins_ALLIGATOR_R2.h"
+#elif MB(RAMPS_FD_V1) || MB(RAMPS_FD_V2)
+  #include "pins_RAMPS_FD_v1.h"
+
 #else
   #error "Unknown MOTHERBOARD value set in Configuration.h"
 #endif
 
 #define HAS_DIGIPOTSS (PIN_EXISTS(DIGIPOTSS))
 
-/**
- * Define SPI Pins: SCK, MISO, MOSI, SS
- */
-#if defined(__AVR_ATmega168__) || defined(__AVR_ATmega328__) || defined(__AVR_ATmega328P__)
-  #define AVR_SCK_PIN  13
-  #define AVR_MISO_PIN 12
-  #define AVR_MOSI_PIN 11
-  #define AVR_SS_PIN   10
-#elif defined(__AVR_ATmega644__) || defined(__AVR_ATmega644P__) || defined(__AVR_ATmega644PA__) || defined(__AVR_ATmega1284P__)
-  #define AVR_SCK_PIN  7
-  #define AVR_MISO_PIN 6
-  #define AVR_MOSI_PIN 5
-  #define AVR_SS_PIN   4
-#elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
-  #define AVR_SCK_PIN  52
-  #define AVR_MISO_PIN 50
-  #define AVR_MOSI_PIN 51
-  #define AVR_SS_PIN   53
-#elif defined(__AVR_AT90USB1287__) || defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB647__)
-  #define AVR_SCK_PIN  21
-  #define AVR_MISO_PIN 23
-  #define AVR_MOSI_PIN 22
-  #define AVR_SS_PIN   20
-#elif defined(__AVR_ATmega1281__) || defined(__AVR_ATmega2561__)
-  #define AVR_SCK_PIN  10
-  #define AVR_MISO_PIN 12
-  #define AVR_MOSI_PIN 11
-  #define AVR_SS_PIN   16
-#endif
-
-#ifndef SCK_PIN
-  #define SCK_PIN  AVR_SCK_PIN
-#endif
-#ifndef MISO_PIN
-  #define MISO_PIN AVR_MISO_PIN
-#endif
-#ifndef MOSI_PIN
-  #define MOSI_PIN AVR_MOSI_PIN
-#endif
-#ifndef SS_PIN
-  #define SS_PIN   AVR_SS_PIN
-#endif
+// Note: default SPI pins are defined in the HAL
+
+#include "src/HAL/HAL_spi_pins.h"
+
 
 #endif // __PINS_H__

Marlin/pins_RAMPS.h

  *         7 | 11
  */
 
-#if !defined(__AVR_ATmega1280__) && !defined(__AVR_ATmega2560__)
-  #error "Oops!  Make sure you have 'Arduino Mega' selected from the 'Tools -> Boards' menu."
+#if !defined(IS_RAMPS_SMART) && !defined(IS_RAMPS_DUO) && !defined(IS_RAMPS4DUE)
+  #if !defined(__AVR_ATmega1280__) && !defined(__AVR_ATmega2560__)
+    #error "Oops!  Make sure you have 'Arduino Mega' selected from the 'Tools -> Boards' menu."
+  #endif
 #endif
 
 #ifndef BOARD_NAME

Marlin/planner.cpp

   }
   block->acceleration_steps_per_s2 = accel;
   block->acceleration = accel / steps_per_mm;
-  block->acceleration_rate = (long)(accel * 16777216.0 / ((F_CPU) * 0.125)); // * 8.388608
+  block->acceleration_rate = (long)(accel * 16777216.0 / (HAL_STEPPER_TIMER_RATE)); // 16777216 = <<24
 
   // Initial limit on the segment entry velocity
   float vmax_junction;

Marlin/printcounter.h

 #include "macros.h"
 #include "language.h"
 #include "stopwatch.h"
-#include <avr/eeprom.h>
-
 
 // Print debug messages with M111 S2
 //#define DEBUG_PRINTCOUNTER
      * @brief EEPROM address
      * @details Defines the start offset address where the data is stored.
      */
-    const uint16_t address = 0x32;
-
+    #if ENABLED(I2C_EEPROM) || ENABLED(SPI_EEPROM)
+      // round up address to next page boundary (assuming 32 byte pages)
+      const uint32_t address = 0x40;
+    #elif defined(CPU_32_BIT)
+      const uint32_t address = 0x32;
+    #else
+      const uint16_t address = 0x32;
+    #endif
     /**
      * @brief Interval in seconds between counter updates
      * @details This const value defines what will be the time between each

Marlin/spi.h → Marlin/private_spi.h

  *
  */
 
-#ifndef __SPI_H__
-#define __SPI_H__
+#ifndef __PRIVATE_SPI_H__
+#define __PRIVATE_SPI_H__
 
 #include <stdint.h>
 #include "softspi.h"
 
 };
 
-#endif // __SPI_H__
+#endif // __PRIVATE_SPI_H__

Marlin/serial.h

 #ifndef __SERIAL_H__
 #define __SERIAL_H__
 
-#include "MarlinConfig.h"
+#include "src/HAL/HAL.h"
 
-#ifdef USBCON
-  #include "HardwareSerial.h"
-  #if ENABLED(BLUETOOTH)
-    #define MYSERIAL bluetoothSerial
+//todo: HAL: breaks encapsulation
+// For AVR only, define a serial interface based on configuration
+#ifdef ARDUINO_ARCH_AVR
+  #ifdef USBCON
+    #include "HardwareSerial.h"
+    #if ENABLED(BLUETOOTH)
+      #define MYSERIAL bluetoothSerial
+    #else
+      #define MYSERIAL Serial
+    #endif // BLUETOOTH
   #else
-    #define MYSERIAL Serial
-  #endif // BLUETOOTH
-#else
-  #include "MarlinSerial.h"
-  #define MYSERIAL customizedSerial
+    #include "src/HAL/HAL_AVR/MarlinSerial.h"
+    #define MYSERIAL customizedSerial
+  #endif
 #endif
 
+#include "MarlinConfig.h"
+
 extern const char echomagic[] PROGMEM;
 extern const char errormagic[] PROGMEM;
 

Marlin/src/HAL/HAL.h

+/* **************************************************************************
+
+ Marlin 3D Printer Firmware
+ Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program.  If not, see <http://www.gnu.org/licenses/>.
+****************************************************************************/
+
+/**
+ * Description: HAL wrapper
+ *
+ * Supports platforms :
+ *    ARDUINO_ARCH_SAM : For Arduino Due and other boards based on Atmel SAM3X8E
+ *    ARDUINO_ARCH_AVR : For all Atmel AVR boards
+ */
+
+#ifndef _HAL_H
+#define _HAL_H
+
+#include <stdint.h>
+
+/**
+ * SPI speed where 0 <= index <= 6
+ *
+ * Approximate rates :
+ *
+ *  0 :  8 - 10 MHz
+ *  1 :  4 - 5 MHz
+ *  2 :  2 - 2.5 MHz
+ *  3 :  1 - 1.25 MHz
+ *  4 :  500 - 625 kHz
+ *  5 :  250 - 312 kHz
+ *  6 :  125 - 156 kHz
+ *
+ *  On AVR, actual speed is F_CPU/2^(1 + index).
+ *  On other platforms, speed should be in range given above where possible.
+ */
+
+/** Set SCK to max rate */
+uint8_t const SPI_FULL_SPEED = 0;
+/** Set SCK rate to half max rate. */
+uint8_t const SPI_HALF_SPEED = 1;
+/** Set SCK rate to quarter max rate. */
+uint8_t const SPI_QUARTER_SPEED = 2;
+/** Set SCK rate to 1/8 max rate. */
+uint8_t const SPI_EIGHTH_SPEED = 3;
+/** Set SCK rate to 1/16 of max rate. */
+uint8_t const SPI_SIXTEENTH_SPEED = 4;
+/** Set SCK rate to 1/32 of max rate. */
+uint8_t const SPI_SPEED_5 = 5;
+/** Set SCK rate to 1/64 of max rate. */
+uint8_t const SPI_SPEED_6 = 6;
+
+// Standard SPI functions
+/** Initialise SPI bus */
+void spiBegin(void);
+/** Configure SPI for specified SPI speed */
+void spiInit(uint8_t spiRate);
+/** Write single byte to SPI */
+void spiSend(uint8_t b);
+/** Read single byte from SPI */
+uint8_t spiRec(void);
+/** Read from SPI into buffer */
+void spiRead(uint8_t* buf, uint16_t nbyte);
+/** Write token and then write from 512 byte buffer to SPI (for SD card) */
+void spiSendBlock(uint8_t token, const uint8_t* buf);
+
+#ifdef ARDUINO_ARCH_AVR
+  #include "HAL_AVR/HAL_AVR.h"
+#elif defined(ARDUINO_ARCH_SAM)
+  #define CPU_32_BIT
+  #include "HAL_DUE/HAL_Due.h"
+  #include "math_32bit.h"
+#elif defined(__MK64FX512__) || defined(__MK66FX1M0__)
+  #define CPU_32_BIT
+  #include "HAL_TEENSY35_36/HAL_Teensy.h"
+  #include "math_32bit.h"
+#else
+  #error Unsupported Platform!
+#endif
+
+#endif /* HAL_H_ */

Marlin/src/HAL/HAL_AVR/HAL_AVR.cpp

+/* **************************************************************************
+
+ Marlin 3D Printer Firmware
+ Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+
+ Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
+ 
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+****************************************************************************/
+
+/**
+ * Description: HAL for AVR
+ *
+ * For ARDUINO_ARCH_AVR
+ */
+
+
+#ifdef ARDUINO_ARCH_AVR
+
+// --------------------------------------------------------------------------
+// Includes
+// --------------------------------------------------------------------------
+
+#include "../HAL.h"
+#include "../../../macros.h"
+
+// --------------------------------------------------------------------------
+// Externals
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Local defines
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Types
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Variables
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Public Variables
+// --------------------------------------------------------------------------
+
+//uint8_t MCUSR;
+
+// --------------------------------------------------------------------------
+// Private Variables
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Function prototypes
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Private functions
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Public functions
+// --------------------------------------------------------------------------
+
+#if ENABLED(SDSUPPORT)
+  #include "../../../SdFatUtil.h"
+  int freeMemory() { return SdFatUtil::FreeRam(); }
+#else
+
+extern "C" {
+  extern char __bss_end;
+  extern char __heap_start;
+  extern void* __brkval;
+
+  int freeMemory() {
+    int free_memory;
+    if ((int)__brkval == 0)
+      free_memory = ((int)&free_memory) - ((int)&__bss_end);
+    else
+      free_memory = ((int)&free_memory) - ((int)__brkval);
+    return free_memory;
+  }
+}
+
+#endif //!SDSUPPORT
+
+#endif
+

Marlin/src/HAL/HAL_AVR/HAL_AVR.h

+/* **************************************************************************
+
+ Marlin 3D Printer Firmware
+ Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+
+ Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program.  If not, see <http://www.gnu.org/licenses/>.
+****************************************************************************/
+
+/**
+ * Description: HAL for AVR
+ *
+ * For ARDUINO_ARCH_AVR
+ */
+
+
+#ifndef _HAL_AVR_H
+#define _HAL_AVR_H
+
+// --------------------------------------------------------------------------
+// Includes
+// --------------------------------------------------------------------------
+
+#include <stdint.h>
+
+#include "Arduino.h"
+
+#include <util/delay.h>
+#include <avr/eeprom.h>
+#include <avr/pgmspace.h>
+#include <avr/interrupt.h>
+#include <avr/io.h>
+
+#include "fastio_AVR.h"
+#include "watchdog_AVR.h"
+#include "math_AVR.h"
+
+// --------------------------------------------------------------------------
+// Defines
+// --------------------------------------------------------------------------
+
+//#define analogInputToDigitalPin(IO) IO
+
+#ifndef CRITICAL_SECTION_START
+  #define CRITICAL_SECTION_START  unsigned char _sreg = SREG; cli();
+  #define CRITICAL_SECTION_END    SREG = _sreg;
+#endif
+
+
+// On AVR this is in math.h?
+//#define square(x) ((x)*(x))
+
+// --------------------------------------------------------------------------
+// Types
+// --------------------------------------------------------------------------
+
+#define HAL_TIMER_TYPE uint16_t
+#define HAL_TIMER_TYPE_MAX 0xFFFF
+
+#define HAL_SERVO_LIB Servo
+
+// --------------------------------------------------------------------------
+// Public Variables
+// --------------------------------------------------------------------------
+
+//extern uint8_t MCUSR;
+
+// --------------------------------------------------------------------------
+// Public functions
+// --------------------------------------------------------------------------
+
+//void cli(void);
+
+//void _delay_ms(int delay);
+
+inline void HAL_clear_reset_source(void) { MCUSR = 0; }
+inline uint8_t HAL_get_reset_source(void) { return MCUSR; }
+
+extern "C" {
+  int freeMemory(void);
+}
+
+// eeprom
+//void eeprom_write_byte(unsigned char *pos, unsigned char value);
+//unsigned char eeprom_read_byte(unsigned char *pos);
+
+
+// timers
+#define STEP_TIMER_NUM OCR1A
+#define TEMP_TIMER_NUM 0
+#define TEMP_TIMER_FREQUENCY (F_CPU / 64.0 / 256.0)
+
+#define HAL_TIMER_RATE ((F_CPU) / 8.0)
+#define HAL_STEPPER_TIMER_RATE HAL_TIMER_RATE
+#define STEPPER_TIMER_PRESCALE INT0_PRESCALER
+
+#define ENABLE_STEPPER_DRIVER_INTERRUPT()  SBI(TIMSK1, OCIE1A)
+#define DISABLE_STEPPER_DRIVER_INTERRUPT() CBI(TIMSK1, OCIE1A)
+
+#define ENABLE_TEMPERATURE_INTERRUPT()  SBI(TIMSK0, OCIE0B)
+#define DISABLE_TEMPERATURE_INTERRUPT() CBI(TIMSK0, OCIE0B)
+
+//void HAL_timer_start (uint8_t timer_num, uint32_t frequency);
+#define HAL_timer_start (timer_num,frequency)
+
+//void HAL_timer_set_count (uint8_t timer_num, uint16_t count);
+#define HAL_timer_set_count(timer,count) timer = (count)
+
+#define HAL_timer_get_current_count(timer) timer
+
+//void HAL_timer_isr_prologue (uint8_t timer_num);
+#define HAL_timer_isr_prologue(timer_num)
+
+#define HAL_STEP_TIMER_ISR ISR(TIMER1_COMPA_vect)
+#define HAL_TEMP_TIMER_ISR ISR(TIMER0_COMPB_vect)
+
+#define HAL_ENABLE_ISRs() do { cli(); if (thermalManager.in_temp_isr)DISABLE_TEMPERATURE_INTERRUPT(); else ENABLE_TEMPERATURE_INTERRUPT(); ENABLE_STEPPER_DRIVER_INTERRUPT(); } while(0)
+
+// ADC
+#ifdef DIDR2
+  #define HAL_ANALOG_SELECT(pin) do{ if (pin < 8) SBI(DIDR0, pin); else SBI(DIDR2, pin - 8); }while(0)
+#else
+  #define HAL_ANALOG_SELECT(pin) do{ SBI(DIDR0, pin); }while(0)
+#endif
+
+inline void HAL_adc_init(void) {
+  ADCSRA = _BV(ADEN) | _BV(ADSC) | _BV(ADIF) | 0x07;
+  DIDR0 = 0;
+  #ifdef DIDR2
+    DIDR2 = 0;
+  #endif
+}
+
+#define SET_ADMUX_ADCSRA(pin) ADMUX = _BV(REFS0) | (pin & 0x07); SBI(ADCSRA, ADSC)
+#ifdef MUX5
+  #define HAL_START_ADC(pin) if (pin > 7) ADCSRB = _BV(MUX5); else ADCSRB = 0; SET_ADMUX_ADCSRA(pin)
+#else
+  #define HAL_START_ADC(pin) ADCSRB = 0; SET_ADMUX_ADCSRA(pin)
+#endif
+
+#define HAL_READ_ADC ADC
+
+
+// --------------------------------------------------------------------------
+//
+// --------------------------------------------------------------------------
+
+#endif // _HAL_AVR_H

Marlin/pinsDebug.h → Marlin/src/HAL/HAL_AVR/HAL_pinsDebug_AVR.h

  *
  */
 
+#ifndef HAL_PINSDEBUG_AVR_H
+
+void HAL_print_analog_pin(char buffer[], int8_t pin) {
+  sprintf(buffer, "(A%2d)  ", int(pin - analogInputToDigitalPin(0)));
+}
+
+void HAL_analog_pin_state(char buffer[], int8_t pin) {
+  sprintf(buffer, "Analog in =% 5d", analogRead(pin - analogInputToDigitalPin(0)));
+}
+
 bool endstop_monitor_flag = false;
 
 #define NAME_FORMAT "%-35s"   // one place to specify the format of all the sources of names
 #define REPORT_NAME_DIGITAL(NAME, COUNTER) _ADD_PIN(#NAME, COUNTER)
 #define REPORT_NAME_ANALOG(NAME, COUNTER) _ADD_PIN(#NAME, COUNTER)
 
-#include "pinsDebug_list.h"
+#include "../../../pinsDebug_list.h"
 #line 51
 
 // manually add pins that have names that are macros which don't play well with these macros
     #endif
   #endif
 
-  #include "pinsDebug_list.h"
+  #include "../../../pinsDebug_list.h"
   #line 102
 
 };
  * Print a pin's PWM status.
  * Return true if it's currently a PWM pin.
  */
-static bool pwm_status(uint8_t pin) {
+static bool HAL_pwm_status(uint8_t pin) {
   char buffer[20];   // for the sprintf statements
 
   switch (digitalPinToTimer_DEBUG(pin)) {
   if (TEST(*TMSK, TOIE)) err_prob_interrupt();
 }
 
-static void pwm_details(uint8_t pin) {
+static void HAL_pwm_details(uint8_t pin) {
   switch (digitalPinToTimer_DEBUG(pin)) {
 
     #if defined(TCCR0A) && defined(COM0A1)
                 print_input_or_output(false);
                 SERIAL_PROTOCOL(digitalRead_mod(pin));
               }
-              else if (pwm_status(pin)) {
+              else if (HAL_pwm_status(pin)) {
                 // do nothing
               }
               else {
                 SERIAL_PROTOCOL(digitalRead_mod(pin));
               }
             }
-            if (!multi_name_pin && extended) pwm_details(pin);  // report PWM capabilities only on the first pass & only if doing an extended report
+            if (!multi_name_pin && extended) HAL_pwm_details(pin);  // report PWM capabilities only on the first pass & only if doing an extended report
           }
         }
       }
     SERIAL_EOL();
   }
 }
+
+#endif //HAL_PINSDEBUG_AVR_H

Marlin/src/HAL/HAL_AVR/HAL_spi_AVR.cpp

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/**
+ * Originally from Arduino Sd2Card Library
+ * Copyright (C) 2009 by William Greiman
+ */
+ 
+/**
+ * Description: HAL for AVR - SPI functions
+ *
+ * For ARDUINO_ARCH_AVR
+ */
+
+#ifdef ARDUINO_ARCH_AVR
+
+// --------------------------------------------------------------------------
+// Includes
+// --------------------------------------------------------------------------
+
+#include "../../../MarlinConfig.h"
+
+// --------------------------------------------------------------------------
+// Public Variables
+// --------------------------------------------------------------------------
+
+
+// --------------------------------------------------------------------------
+// Public functions
+// --------------------------------------------------------------------------
+
+void spiBegin (void) {
+  SET_OUTPUT(SS_PIN);
+  WRITE(SS_PIN, HIGH);
+  SET_OUTPUT(SCK_PIN);
+  SET_INPUT(MISO_PIN);
+  SET_OUTPUT(MOSI_PIN);
+
+  #if DISABLED(SOFTWARE_SPI)
+    // SS must be in output mode even it is not chip select
+    SET_OUTPUT(SS_PIN);
+    // set SS high - may be chip select for another SPI device
+    #if SET_SPI_SS_HIGH
+      WRITE(SS_PIN, HIGH);
+    #endif  // SET_SPI_SS_HIGH
+    // set a default rate
+    spiInit(1);
+  #endif  // SOFTWARE_SPI
+}
+
+
+//------------------------------------------------------------------------------
+#if DISABLED(SOFTWARE_SPI)
+  // functions for hardware SPI
+  //------------------------------------------------------------------------------
+  // make sure SPCR rate is in expected bits
+  #if (SPR0 != 0 || SPR1 != 1)
+    #error "unexpected SPCR bits"
+  #endif
+
+  /**
+   * Initialize hardware SPI
+   * Set SCK rate to F_CPU/pow(2, 1 + spiRate) for spiRate [0,6]
+   */
+  void spiInit(uint8_t spiRate) {
+    // See avr processor documentation
+    CBI(
+      #ifdef PRR
+        PRR
+      #elif defined(PRR0)
+        PRR0
+      #endif
+        , PRSPI);
+
+    SPCR = _BV(SPE) | _BV(MSTR) | (spiRate >> 1);
+    SPSR = spiRate & 1 || spiRate == 6 ? 0 : _BV(SPI2X);
+  }
+  //------------------------------------------------------------------------------
+  /** SPI receive a byte */
+  uint8_t spiRec(void) {
+    SPDR = 0XFF;
+    while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
+    return SPDR;
+  }
+  //------------------------------------------------------------------------------
+  /** SPI read data  */
+  void spiRead(uint8_t* buf, uint16_t nbyte) {
+    if (nbyte-- == 0) return;
+    SPDR = 0XFF;
+    for (uint16_t i = 0; i < nbyte; i++) {
+      while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
+      buf[i] = SPDR;
+      SPDR = 0XFF;
+    }
+    while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
+    buf[nbyte] = SPDR;
+  }
+  //------------------------------------------------------------------------------
+  /** SPI send a byte */
+  void spiSend(uint8_t b) {
+    SPDR = b;
+    while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
+  }
+  //------------------------------------------------------------------------------
+  /** SPI send block  */
+  void spiSendBlock(uint8_t token, const uint8_t* buf) {
+    SPDR = token;
+    for (uint16_t i = 0; i < 512; i += 2) {
+      while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
+      SPDR = buf[i];
+      while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
+      SPDR = buf[i + 1];
+    }
+    while (!TEST(SPSR, SPIF)) { /* Intentionally left empty */ }
+  }
+       //------------------------------------------------------------------------------
+#else  // SOFTWARE_SPI
+       //------------------------------------------------------------------------------
+  /** nop to tune soft SPI timing */
+  #define nop asm volatile ("\tnop\n")
+
+  /** Set SPI rate */
+  void spiInit(uint8_t spiRate) {
+    // nothing to do
+    UNUSED(spiRate);
+  }
+
+  //------------------------------------------------------------------------------
+  /** Soft SPI receive byte */
+  uint8_t spiRec() {
+    uint8_t data = 0;
+    // no interrupts during byte receive - about 8 us
+    cli();
+    // output pin high - like sending 0XFF
+    WRITE(MOSI_PIN, HIGH);
+
+    for (uint8_t i = 0; i < 8; i++) {
+      WRITE(SCK_PIN, HIGH);
+
+      // adjust so SCK is nice
+      nop;
+      nop;
+
+      data <<= 1;
+
+      if (READ(MISO_PIN)) data |= 1;
+
+      WRITE(SCK_PIN, LOW);
+    }
+    // enable interrupts
+    sei();
+    return data;
+  }
+  //------------------------------------------------------------------------------
+  /** Soft SPI read data */
+  void spiRead(uint8_t* buf, uint16_t nbyte) {
+    for (uint16_t i = 0; i < nbyte; i++)
+      buf[i] = spiRec();
+  }
+  //------------------------------------------------------------------------------
+  /** Soft SPI send byte */
+  void spiSend(uint8_t data) {
+    // no interrupts during byte send - about 8 us
+    cli();
+    for (uint8_t i = 0; i < 8; i++) {
+      WRITE(SCK_PIN, LOW);
+
+      WRITE(MOSI_PIN, data & 0X80);
+
+      data <<= 1;
+
+      WRITE(SCK_PIN, HIGH);
+    }
+    // hold SCK high for a few ns
+    nop;
+    nop;
+    nop;
+    nop;
+
+    WRITE(SCK_PIN, LOW);
+    // enable interrupts
+    sei();
+  }
+  //------------------------------------------------------------------------------
+  /** Soft SPI send block */
+  void spiSendBlock(uint8_t token, const uint8_t* buf) {
+    spiSend(token);
+    for (uint16_t i = 0; i < 512; i++)
+      spiSend(buf[i]);
+  }
+#endif  // SOFTWARE_SPI
+
+
+#endif // ARDUINO_ARCH_AVR

Marlin/MarlinSerial.cpp → Marlin/src/HAL/HAL_AVR/MarlinSerial.cpp

  * Modified 28 September 2010 by Mark Sproul
  * Modified 14 February 2016 by Andreas Hardtung (added tx buffer)
  */
+#ifdef ARDUINO_ARCH_AVR
 
 #include "MarlinSerial.h"
-#include "Marlin.h"
+#include "../../../Marlin.h"
 
 // Disable HardwareSerial.cpp to support chips without a UART (Attiny, etc.)
 
 
   #if ENABLED(EMERGENCY_PARSER)
 
-    #include "stepper.h"
-    #include "language.h"
+    #include "../../../stepper.h"
+    #include "../../../language.h"
 
     // Currently looking for: M108, M112, M410
     // If you alter the parser please don't forget to update the capabilities in Conditionals_post.h
 #if defined(USBCON) && ENABLED(BLUETOOTH)
   HardwareSerial bluetoothSerial;
 #endif
+
+#endif

Marlin/MarlinSerial.h → Marlin/src/HAL/HAL_AVR/MarlinSerial.h

 #ifndef MARLINSERIAL_H
 #define MARLINSERIAL_H
 
-#include "MarlinConfig.h"
+#include "../../../MarlinConfig.h"
+
+#include <WString.h>
 
 #ifndef SERIAL_PORT
   #define SERIAL_PORT 0
       static void println(unsigned long, int = DEC);
       static void println(double, int = 2);
       static void println(void);
+      operator bool() { return true; }
   };
 
   extern MarlinSerial customizedSerial;

Marlin/src/HAL/HAL_AVR/ServoTimers.h

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/*
+  Servo.h - Interrupt driven Servo library for Arduino using 16 bit timers- Version 2
+  Copyright (c) 2009 Michael Margolis.  All right reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library 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
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+/*
+ * Defines for 16 bit timers used with  Servo library
+ *
+ * If _useTimerX is defined then TimerX is a 16 bit timer on the current board
+ * timer16_Sequence_t enumerates the sequence that the timers should be allocated
+ * _Nbr_16timers indicates how many 16 bit timers are available.
+ */
+
+/**
+ * AVR Only definitions
+ * --------------------
+ */
+
+#define TRIM_DURATION       2    // compensation ticks to trim adjust for digitalWrite delays
+#define PRESCALER           8   // timer prescaler
+
+// Say which 16 bit timers can be used and in what order
+#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
+  //#define _useTimer1
+  #define _useTimer3
+  #define _useTimer4
+  #if !HAS_MOTOR_CURRENT_PWM
+    #define _useTimer5 // Timer 5 is used for motor current PWM and can't be used for servos.
+  #endif
+#elif defined(__AVR_ATmega32U4__)
+  #define _useTimer3
+#elif defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB1286__)
+  #define _useTimer3
+#elif defined(__AVR_ATmega128__) || defined(__AVR_ATmega1281__) || defined(__AVR_ATmega1284P__) || defined(__AVR_ATmega2561__)
+  #define _useTimer3
+#else
+  // everything else
+#endif
+
+typedef enum {
+  #if ENABLED(_useTimer1)
+    _timer1,
+  #endif
+  #if ENABLED(_useTimer3)
+    _timer3,
+  #endif
+  #if ENABLED(_useTimer4)
+    _timer4,
+  #endif
+  #if ENABLED(_useTimer5)
+    _timer5,
+  #endif
+  _Nbr_16timers
+} timer16_Sequence_t;

Marlin/endstop_interrupts.h → Marlin/src/HAL/HAL_AVR/endstop_interrupts.h

 #ifndef _ENDSTOP_INTERRUPTS_H_
 #define _ENDSTOP_INTERRUPTS_H_
 
-#include "macros.h"
+#include "../../../macros.h"
 
 /**
  * Patch for pins_arduino.h (...\Arduino\hardware\arduino\avr\variants\mega\pins_arduino.h)
                                     0 )
 #endif
 
-volatile uint8_t e_hit = 0; // Different from 0 when the endstops should be tested in detail.
-                            // Must be reset to 0 by the test function when finished.
 
 // Install Pin change interrupt for a pin. Can be called multiple times.
 void pciSetup(byte pin) {
   SBI(PCICR, digitalPinToPCICRbit(pin)); // enable interrupt for the group
 }
 
-// This is what is really done inside the interrupts.
-FORCE_INLINE void endstop_ISR_worker( void ) {
-  e_hit = 2; // Because the detection of a e-stop hit has a 1 step debouncer it has to be called at least twice.
-}
-
-// Use one Routine to handle each group
-// One ISR for all EXT-Interrupts
-void endstop_ISR(void) { endstop_ISR_worker(); }
 
 // Handlers for pin change interrupts
 #ifdef PCINT0_vect

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

 #ifndef _FASTIO_1280
 #define _FASTIO_1280
 
-#include "fastio.h"
+#include "fastio_AVR.h"
 
 // change for your board
 #define DEBUG_LED   DIO21

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

 #ifndef _FASTIO_1281
 #define _FASTIO_1281
 
-#include "fastio.h"
+#include "fastio_AVR.h"
 
 // change for your board
 #define DEBUG_LED   DIO46

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

 #ifndef _FASTIO_168
 #define _FASTIO_168
 
-#include "fastio.h"
+#include "fastio_AVR.h"
 
 #define DEBUG_LED   AIO5
 

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

 #ifndef _FASTIO_644
 #define _FASTIO_644
 
-#include "fastio.h"
+#include "fastio_AVR.h"
 
 #define DEBUG_LED   DIO0
 

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

 #ifndef _FASTIO_AT90USB
 #define _FASTIO_AT90USB
 
-#include "fastio.h"
+#include "fastio_AVR.h"
 
 // change for your board
 #define DEBUG_LED   DIO31 /* led D5 red */

Marlin/fastio.h → Marlin/src/HAL/HAL_AVR/fastio_AVR.h

 #define _FASTIO_ARDUINO_H
 
 #include <avr/io.h>
-#include "macros.h"
+#include "../../../macros.h"
 
 #define AVR_AT90USB1286_FAMILY (defined(__AVR_AT90USB1287__) || defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB1286P__) || defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB646P__)  || defined(__AVR_AT90USB647__))
 #define AVR_ATmega1284_FAMILY (defined(__AVR_ATmega644__) || defined(__AVR_ATmega644P__) || defined(__AVR_ATmega644PA__) || defined(__AVR_ATmega1284P__))
 #define AVR_ATmega2561_FAMILY (defined(__AVR_ATmega1281__) || defined(__AVR_ATmega2561__))
 #define AVR_ATmega328_FAMILY (defined(__AVR_ATmega168__) || defined(__AVR_ATmega328__) || defined(__AVR_ATmega328p__))
 
-
 /**
  * Include Ports and Functions
  */
 #endif
 
 #ifndef _BV
-  #define _BV(PIN) (1UL << PIN)
+  #define _BV(bit) (1UL << (bit))
 #endif
 
 /**
   #define PWM_CHK_MOTOR_CURRENT(p) false
 #endif
 
-#if defined(NUM_SERVOS)
+#ifdef NUM_SERVOS
   #if AVR_ATmega2560_FAMILY
     #define PWM_CHK_SERVO(p) ( p == 5 || NUM_SERVOS > 12 && p == 6 || NUM_SERVOS > 24 && p == 46)  //PWMS 3A, 4A & 5A
   #elif AVR_ATmega2561_FAMILY

Marlin/src/HAL/HAL_AVR/math_AVR.h

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef MATH_AVR_H
+#define MATH_AVR_H
+
+/**
+ * Optimized math functions for AVR
+ */
+
+// intRes = longIn1 * longIn2 >> 24
+// uses:
+// r26 to store 0
+// r27 to store bits 16-23 of the 48bit result. The top bit is used to round the two byte result.
+// note that the lower two bytes and the upper byte of the 48bit result are not calculated.
+// this can cause the result to be out by one as the lower bytes may cause carries into the upper ones.
+// B0 A0 are bits 24-39 and are the returned value
+// C1 B1 A1 is longIn1
+// D2 C2 B2 A2 is longIn2
+//
+#define MultiU24X32toH16(intRes, longIn1, longIn2) \
+  asm volatile ( \
+                 "clr r26 \n\t" \
+                 "mul %A1, %B2 \n\t" \
+                 "mov r27, r1 \n\t" \
+                 "mul %B1, %C2 \n\t" \
+                 "movw %A0, r0 \n\t" \
+                 "mul %C1, %C2 \n\t" \
+                 "add %B0, r0 \n\t" \
+                 "mul %C1, %B2 \n\t" \
+                 "add %A0, r0 \n\t" \
+                 "adc %B0, r1 \n\t" \
+                 "mul %A1, %C2 \n\t" \
+                 "add r27, r0 \n\t" \
+                 "adc %A0, r1 \n\t" \
+                 "adc %B0, r26 \n\t" \
+                 "mul %B1, %B2 \n\t" \
+                 "add r27, r0 \n\t" \
+                 "adc %A0, r1 \n\t" \
+                 "adc %B0, r26 \n\t" \
+                 "mul %C1, %A2 \n\t" \
+                 "add r27, r0 \n\t" \
+                 "adc %A0, r1 \n\t" \
+                 "adc %B0, r26 \n\t" \
+                 "mul %B1, %A2 \n\t" \
+                 "add r27, r1 \n\t" \
+                 "adc %A0, r26 \n\t" \
+                 "adc %B0, r26 \n\t" \
+                 "lsr r27 \n\t" \
+                 "adc %A0, r26 \n\t" \
+                 "adc %B0, r26 \n\t" \
+                 "mul %D2, %A1 \n\t" \
+                 "add %A0, r0 \n\t" \
+                 "adc %B0, r1 \n\t" \
+                 "mul %D2, %B1 \n\t" \
+                 "add %B0, r0 \n\t" \
+                 "clr r1 \n\t" \
+                 : \
+                 "=&r" (intRes) \
+                 : \
+                 "d" (longIn1), \
+                 "d" (longIn2) \
+                 : \
+                 "r26" , "r27" \
+               )
+
+// intRes = intIn1 * intIn2 >> 16
+// uses:
+// r26 to store 0
+// r27 to store the byte 1 of the 24 bit result
+#define MultiU16X8toH16(intRes, charIn1, intIn2) \
+  asm volatile ( \
+                 "clr r26 \n\t" \
+                 "mul %A1, %B2 \n\t" \
+                 "movw %A0, r0 \n\t" \
+                 "mul %A1, %A2 \n\t" \
+                 "add %A0, r1 \n\t" \
+                 "adc %B0, r26 \n\t" \
+                 "lsr r0 \n\t" \
+                 "adc %A0, r26 \n\t" \
+                 "adc %B0, r26 \n\t" \
+                 "clr r1 \n\t" \
+                 : \
+                 "=&r" (intRes) \
+                 : \
+                 "d" (charIn1), \
+                 "d" (intIn2) \
+                 : \
+                 "r26" \
+               )
+
+
+#endif

Marlin/src/HAL/HAL_AVR/persistent_store.cpp

+#include "../persistent_store_api.h"
+
+#include "../../../types.h"
+#include "../../../language.h"
+#include "../../../serial.h"
+#include "../../../utility.h"
+
+#ifdef ARDUINO_ARCH_AVR
+#if ENABLED(EEPROM_SETTINGS)
+
+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_START();
+        SERIAL_ECHOLNPGM(MSG_ERR_EEPROM_WRITE);
+        return false;
+      }
+    }
+    crc16(crc, &v, 1);
+    pos++;
+    value++;
+  };
+  return true;
+}
+
+void read_data(int &pos, uint8_t* value, uint16_t size, uint16_t *crc) {
+  do {
+    uint8_t c = eeprom_read_byte((unsigned char*)pos);
+    *value = c;
+    crc16(crc, &c, 1);
+    pos++;
+    value++;
+  } while (--size);
+}
+
+}
+}
+
+#endif // EEPROM_SETTINGS
+#endif // ARDUINO_ARCH_AVR

Marlin/servo.cpp → Marlin/src/HAL/HAL_AVR/servo_AVR.cpp

  *
  */
 
+
 /**
  * servo.cpp - Interrupt driven Servo library for Arduino using 16 bit timers- Version 2
  * Copyright (c) 2009 Michael Margolis.  All right reserved.
  * detach()              - Stop an attached servo from pulsing its i/o pin.
  *
  */
-#include "MarlinConfig.h"
+
+#ifdef ARDUINO_ARCH_AVR
+
+#include "../../../MarlinConfig.h"
 
 #if HAS_SERVOS
 
 #include <avr/interrupt.h>
 #include <Arduino.h>
 
-#include "servo.h"
-
-#define usToTicks(_us)    (( clockCyclesPerMicrosecond()* _us) / 8)     // converts microseconds to tick (assumes prescale of 8)  // 12 Aug 2009
-#define ticksToUs(_ticks) (( (unsigned)_ticks * 8)/ clockCyclesPerMicrosecond() ) // converts from ticks back to microseconds
-
-#define TRIM_DURATION       2                               // compensation ticks to trim adjust for digitalWrite delays // 12 August 2009
-
-//#define NBR_TIMERS        ((MAX_SERVOS) / (SERVOS_PER_TIMER))
+#include "../servo.h"
+#include "../servo_private.h"
 
-static ServoInfo_t servo_info[MAX_SERVOS];                  // static array of servo info structures
 static volatile int8_t Channel[_Nbr_16timers ];             // counter for the servo being pulsed for each timer (or -1 if refresh interval)
 
-uint8_t ServoCount = 0;                                     // the total number of attached servos
-
-
-// convenience macros
-#define SERVO_INDEX_TO_TIMER(_servo_nbr) ((timer16_Sequence_t)(_servo_nbr / (SERVOS_PER_TIMER))) // returns the timer controlling this servo
-#define SERVO_INDEX_TO_CHANNEL(_servo_nbr) (_servo_nbr % (SERVOS_PER_TIMER))       // returns the index of the servo on this timer
-#define SERVO_INDEX(_timer,_channel)  ((_timer*(SERVOS_PER_TIMER)) + _channel)     // macro to access servo index by timer and channel
-#define SERVO(_timer,_channel)  (servo_info[SERVO_INDEX(_timer,_channel)])       // macro to access servo class by timer and channel
-
-#define SERVO_MIN() (MIN_PULSE_WIDTH - this->min * 4)  // minimum value in uS for this servo
-#define SERVO_MAX() (MAX_PULSE_WIDTH - this->max * 4)  // maximum value in uS for this servo
 
 /************ static functions common to all instances ***********************/
 
 
 #endif // WIRING
 
+/****************** end of static functions ******************************/
 
-static void initISR(timer16_Sequence_t timer) {
+void initISR(timer16_Sequence_t timer) {
   #if ENABLED(_useTimer1)
     if (timer == _timer1) {
       TCCR1A = 0;             // normal counting mode
   #endif
 }
 
-static void finISR(timer16_Sequence_t timer) {
+void finISR(timer16_Sequence_t timer) {
   // Disable use of the given timer
   #ifdef WIRING
     if (timer == _timer1) {
   #endif
 }
 
-static bool isTimerActive(timer16_Sequence_t timer) {
-  // returns true if any servo is active on this timer
-  for (uint8_t channel = 0; channel < SERVOS_PER_TIMER; channel++) {
-    if (SERVO(timer, channel).Pin.isActive)
-      return true;
-  }
-  return false;
-}
-
-
-/****************** end of static functions ******************************/
-
-Servo::Servo() {
-  if (ServoCount < MAX_SERVOS) {
-    this->servoIndex = ServoCount++;                    // assign a servo index to this instance
-    servo_info[this->servoIndex].ticks = usToTicks(DEFAULT_PULSE_WIDTH);   // store default values  - 12 Aug 2009
-  }
-  else
-    this->servoIndex = INVALID_SERVO;  // too many servos
-}
-
-int8_t Servo::attach(int pin) {
-  return this->attach(pin, MIN_PULSE_WIDTH, MAX_PULSE_WIDTH);
-}
-
-int8_t Servo::attach(int pin, int min, int max) {
-
-  if (this->servoIndex >= MAX_SERVOS) return -1;
-
-  if (pin > 0) servo_info[this->servoIndex].Pin.nbr = pin;
-  pinMode(servo_info[this->servoIndex].Pin.nbr, OUTPUT); // set servo pin to output
-
-  // todo min/max check: abs(min - MIN_PULSE_WIDTH) /4 < 128
-  this->min = (MIN_PULSE_WIDTH - min) / 4; //resolution of min/max is 4 uS
-  this->max = (MAX_PULSE_WIDTH - max) / 4;
-
-  // initialize the timer if it has not already been initialized
-  timer16_Sequence_t timer = SERVO_INDEX_TO_TIMER(servoIndex);
-  if (!isTimerActive(timer)) initISR(timer);
-  servo_info[this->servoIndex].Pin.isActive = true;  // this must be set after the check for isTimerActive
-
-  return this->servoIndex;
-}
-
-void Servo::detach() {
-  servo_info[this->servoIndex].Pin.isActive = false;
-  timer16_Sequence_t timer = SERVO_INDEX_TO_TIMER(servoIndex);
-  if (!isTimerActive(timer)) finISR(timer);
-}
-
-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)
-    value = map(constrain(value, 0, 180), 0, 180, SERVO_MIN(), SERVO_MAX());
-  }
-  this->writeMicroseconds(value);
-}
-
-void Servo::writeMicroseconds(int value) {
-  // calculate and store the values for the given channel
-  byte channel = this->servoIndex;
-  if (channel < MAX_SERVOS) {  // ensure channel is valid
-    // ensure pulse width is valid
-    value = constrain(value, SERVO_MIN(), SERVO_MAX()) - (TRIM_DURATION);
-    value = usToTicks(value);  // convert to ticks after compensating for interrupt overhead - 12 Aug 2009
-
-    CRITICAL_SECTION_START;
-    servo_info[channel].ticks = value;
-    CRITICAL_SECTION_END;
-  }
-}
-
-// return the value as degrees
-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;
-}
-
-bool Servo::attached() { return servo_info[this->servoIndex].Pin.isActive; }
-
-void Servo::move(int value) {
-  constexpr uint16_t servo_delay[] = SERVO_DELAY;
-  static_assert(COUNT(servo_delay) == NUM_SERVOS, "SERVO_DELAY must be an array NUM_SERVOS long.");
-  if (this->attach(0) >= 0) {
-    this->write(value);
-    delay(servo_delay[this->servoIndex]);
-    #if ENABLED(DEACTIVATE_SERVOS_AFTER_MOVE)
-      this->detach();
-    #endif
-  }
-}
+#endif // HAS_SERVOS
 
-#endif
+#endif // ARDUINO_ARCH_AVR

Marlin/src/HAL/HAL_AVR/spi_pins.h

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016 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/>.
+ *
+ */
+
+#ifndef SPI_PINS_H_
+#define SPI_PINS_H_
+
+/**
+ * Define SPI Pins: SCK, MISO, MOSI, SS
+ */
+#if defined(__AVR_ATmega168__) || defined(__AVR_ATmega328__) || defined(__AVR_ATmega328P__)
+  #define AVR_SCK_PIN  13
+  #define AVR_MISO_PIN 12
+  #define AVR_MOSI_PIN 11
+  #define AVR_SS_PIN   10
+#elif defined(__AVR_ATmega644__) || defined(__AVR_ATmega644P__) || defined(__AVR_ATmega644PA__) || defined(__AVR_ATmega1284P__)
+  #define AVR_SCK_PIN  7
+  #define AVR_MISO_PIN 6
+  #define AVR_MOSI_PIN 5
+  #define AVR_SS_PIN   4
+#elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
+  #define AVR_SCK_PIN  52
+  #define AVR_MISO_PIN 50
+  #define AVR_MOSI_PIN 51
+  #define AVR_SS_PIN   53
+#elif defined(__AVR_AT90USB1287__) || defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB647__)
+  #define AVR_SCK_PIN  21
+  #define AVR_MISO_PIN 23
+  #define AVR_MOSI_PIN 22
+  #define AVR_SS_PIN   20
+#elif defined(__AVR_ATmega1281__) || defined(__AVR_ATmega2561__)
+  #define AVR_SCK_PIN  10
+  #define AVR_MISO_PIN 12
+  #define AVR_MOSI_PIN 11
+  #define AVR_SS_PIN   16
+#endif
+
+#ifndef SCK_PIN
+  #define SCK_PIN  AVR_SCK_PIN
+#endif
+#ifndef MISO_PIN
+  #define MISO_PIN AVR_MISO_PIN
+#endif
+#ifndef MOSI_PIN
+  #define MOSI_PIN AVR_MOSI_PIN
+#endif
+#ifndef SS_PIN
+  #define SS_PIN   AVR_SS_PIN
+#endif
+
+
+#endif /* SPI_PINS_H_ */

Marlin/watchdog.cpp → Marlin/src/HAL/HAL_AVR/watchdog_AVR.cpp

  *
  */
 
-#include "Marlin.h"
+#ifdef ARDUINO_ARCH_AVR
+
+#include "../../../Marlin.h"
 
 #if ENABLED(USE_WATCHDOG)
 
-#include "watchdog.h"
+#include "watchdog_AVR.h"
 
 // Initialize watchdog with a 4 sec interrupt time
 void watchdog_init() {
 #endif // WATCHDOG_RESET_MANUAL
 
 #endif // USE_WATCHDOG
+#endif // ARDUINO_ARCH_AVR

Marlin/watchdog.h → Marlin/src/HAL/HAL_AVR/watchdog_AVR.h

  *
  */
 
-#ifndef WATCHDOG_H
-#define WATCHDOG_H
+#ifndef WATCHDOG_AVR_H
+#define WATCHDOG_AVR_H
+
+//#include "../../../Marlin.h"
 
-#include "Marlin.h"
 #include <avr/wdt.h>
 
 // Initialize watchdog with a 4 second interrupt time

Marlin/src/HAL/HAL_endstop_interrupts.h

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016 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/>.
+ *
+ */
+
+
+#ifndef HAL_ENDSTOP_INTERRUPTS_H_
+#define HAL_ENDSTOP_INTERRUPTS_H_
+
+volatile uint8_t e_hit = 0; // Different from 0 when the endstops should be tested in detail.
+                            // Must be reset to 0 by the test function when finished.
+
+// This is what is really done inside the interrupts.
+FORCE_INLINE void endstop_ISR_worker( void ) {
+  e_hit = 2; // Because the detection of a e-stop hit has a 1 step debouncer it has to be called at least twice.
+}
+
+// One ISR for all EXT-Interrupts
+void endstop_ISR(void) { endstop_ISR_worker(); }
+
+#ifdef ARDUINO_ARCH_AVR
+
+  #include "HAL_AVR/endstop_interrupts.h"
+
+#elif defined(ARDUINO_ARCH_SAM)
+
+  #include "HAL_DUE/endstop_interrupts.h"
+
+#elif IS_32BIT_TEENSY
+
+  #include "HAL_TEENSY35_36/endstop_interrupts.h"
+
+#else
+
+  #error Unsupported Platform!
+
+#endif
+
+#endif /* HAL_ENDSTOP_INTERRUPTS_H_ */

Marlin/src/HAL/HAL_pinsDebug.h

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef HAL_PINSDEBUG_H
+
+#ifdef ARDUINO_ARCH_AVR
+  #include "HAL_AVR/HAL_pinsDebug_AVR.h"
+#elif defined(ARDUINO_ARCH_SAM)
+  #include "HAL_DUE/HAL_pinsDebug_Due.h"
+#elif IS_32BIT_TEENSY
+  #include "HAL_TEENSY35_36/HAL_pinsDebug_Teensy.h"
+#else
+  #error Unsupported Platform!
+#endif
+
+#endif

Marlin/src/HAL/HAL_spi_pins.h

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016 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/>.
+ *
+ */
+
+
+#ifndef HAL_SPI_PINS_H_
+#define HAL_SPI_PINS_H_
+
+#include "MarlinConfig.h"
+
+#ifdef ARDUINO_ARCH_SAM
+  #include "HAL_DUE/spi_pins.h"
+
+#elif defined(IS_32BIT_TEENSY)
+  #include "HAL_TEENSY35_36/spi_pins.h"
+
+#elif defined(ARDUINO_ARCH_AVR)
+  #include "HAL_AVR/spi_pins.h"
+
+#else
+  #error "Unsupported Platform!"
+#endif
+
+#endif /* HAL_SPI_PINS_H_ */

Marlin/src/HAL/I2cEeprom.cpp

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016 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/>.
+ *
+ */
+
+
+/**
+ * Description: functions for I2C connected external EEPROM.
+ * Not platform dependent.
+ */
+
+#include "../../MarlinConfig.h"
+
+#if ENABLED(I2C_EEPROM)
+
+// --------------------------------------------------------------------------
+// Includes
+// --------------------------------------------------------------------------
+
+#include "HAL.h"
+#include <Wire.h>
+
+// --------------------------------------------------------------------------
+// Externals
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Local defines
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Types
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Variables
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Public Variables
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Private Variables
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Function prototypes
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Private functions
+// --------------------------------------------------------------------------
+
+// --------------------------------------------------------------------------
+// Public functions
+// --------------------------------------------------------------------------
+
+static bool eeprom_initialised = false;
+static uint8_t eeprom_device_address = 0x50;
+
+static void eeprom_init(void) {
+  if (!eeprom_initialised) {
+    Wire.begin();
+    eeprom_initialised = true;
+  }
+}
+
+void eeprom_write_byte(unsigned char *pos, unsigned char value) {
+  unsigned eeprom_address = (unsigned) pos;
+
+  eeprom_init();
+
+  Wire.beginTransmission(eeprom_device_address);
+  Wire.write((int)(eeprom_address >> 8));   // MSB
+  Wire.write((int)(eeprom_address & 0xFF)); // LSB
+  Wire.write(value);
+  Wire.endTransmission();
+
+  // wait for write cycle to complete
+  // this could be done more efficiently with "acknowledge polling"
+  delay(5);
+}
+
+// WARNING: address is a page address, 6-bit end will wrap around
+// also, data can be maximum of about 30 bytes, because the Wire library has a buffer of 32 bytes
+void eeprom_update_block(const void* pos, void* eeprom_address, size_t n) {
+  uint8_t eeprom_temp[32] = {0};
+  uint8_t flag = 0;
+
+  eeprom_init();
+
+  Wire.beginTransmission(eeprom_device_address);
+  Wire.write((int)((unsigned)eeprom_address >> 8));   // MSB
+  Wire.write((int)((unsigned)eeprom_address & 0xFF)); // LSB
+  Wire.endTransmission();
+  Wire.requestFrom(eeprom_device_address, (byte)n);
+  for (byte c = 0; c < n; c++) {
+    if (Wire.available()) eeprom_temp[c] = Wire.read();
+    flag |= (eeprom_temp[c] ^ *((uint8_t*)pos + c));
+  }
+
+  if (flag) {
+    Wire.beginTransmission(eeprom_device_address);
+    Wire.write((int)((unsigned)eeprom_address >> 8));   // MSB
+    Wire.write((int)((unsigned)eeprom_address & 0xFF)); // LSB
+    Wire.write((uint8_t*)(pos), n);
+    Wire.endTransmission();
+
+    // wait for write cycle to complete
+    // this could be done more efficiently with "acknowledge polling"
+    delay(5);
+  }
+}
+
+
+unsigned char eeprom_read_byte(unsigned char *pos) {
+  byte data = 0xFF;
+  unsigned eeprom_address = (unsigned) pos;
+
+  eeprom_init ();
+
+  Wire.beginTransmission(eeprom_device_address);
+  Wire.write((int)(eeprom_address >> 8));   // MSB
+  Wire.write((int)(eeprom_address & 0xFF)); // LSB
+  Wire.endTransmission();
+  Wire.requestFrom(eeprom_device_address, (byte)1);
+  if (Wire.available())
+    data = Wire.read();
+  return data;
+}
+
+// maybe let's not read more than 30 or 32 bytes at a time!
+void eeprom_read_block(void* pos, const void* eeprom_address, size_t n) {
+  eeprom_init();
+
+  Wire.beginTransmission(eeprom_device_address);
+  Wire.write((int)((unsigned)eeprom_address >> 8));   // MSB
+  Wire.write((int)((unsigned)eeprom_address & 0xFF)); // LSB
+  Wire.endTransmission();
+  Wire.requestFrom(eeprom_device_address, (byte)n);
+  for (byte c = 0; c < n; c++ )
+    if (Wire.available()) *((uint8_t*)pos + c) = Wire.read();
+}
+
+
+#endif // ENABLED(I2C_EEPROM)
+

Marlin/src/HAL/SpiEeprom.cpp

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016 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/>.
+ *
+ */
+
+/**
+ * Description: functions for SPI connected external EEPROM.
+ * Not platform dependent.
+ */
+
+#include "../../MarlinConfig.h"
+
+#if ENABLED(SPI_EEPROM)
+
+#include "HAL.h"
+
+#define CMD_WREN  6   // WREN
+#define CMD_READ  2   // WRITE
+#define CMD_WRITE 2   // WRITE
+
+uint8_t eeprom_read_byte(uint8_t* pos) {
+  uint8_t v;
+  uint8_t eeprom_temp[3];
+
+  // set read location
+  // begin transmission from device
+  eeprom_temp[0] = CMD_READ;
+  eeprom_temp[1] = ((unsigned)pos>>8) & 0xFF; // addr High
+  eeprom_temp[2] = (unsigned)pos& 0xFF;       // addr Low
+  digitalWrite(SPI_EEPROM1_CS, HIGH);
+  digitalWrite(SPI_EEPROM1_CS, LOW);
+  spiSend(SPI_CHAN_EEPROM1, eeprom_temp, 3);
+
+  v = spiRec(SPI_CHAN_EEPROM1);
+  digitalWrite(SPI_EEPROM1_CS, HIGH);
+  return v;
+}
+
+
+void eeprom_read_block(void* dest, const void* eeprom_address, size_t n) {
+  uint8_t eeprom_temp[3];
+
+  // set read location
+  // begin transmission from device
+  eeprom_temp[0] = CMD_READ;
+  eeprom_temp[1] = ((unsigned)eeprom_address>>8) & 0xFF; // addr High
+  eeprom_temp[2] = (unsigned)eeprom_address& 0xFF;       // addr Low
+  digitalWrite(SPI_EEPROM1_CS, HIGH);
+  digitalWrite(SPI_EEPROM1_CS, LOW);
+  spiSend(SPI_CHAN_EEPROM1, eeprom_temp, 3);
+
+  uint8_t *p_dest = (uint8_t *)dest;
+  while (n--)
+    *p_dest++ = spiRec(SPI_CHAN_EEPROM1);
+  digitalWrite(SPI_EEPROM1_CS, HIGH);
+}
+
+void eeprom_write_byte(uint8_t* pos, uint8_t value) {
+  uint8_t eeprom_temp[3];
+
+  /*write enable*/
+  eeprom_temp[0] = CMD_WREN;
+  digitalWrite(SPI_EEPROM1_CS, LOW);
+  spiSend(SPI_CHAN_EEPROM1, eeprom_temp, 1);
+  digitalWrite(SPI_EEPROM1_CS, HIGH);
+  delay(1);
+
+  /*write addr*/
+  eeprom_temp[0] = CMD_WRITE;
+  eeprom_temp[1] = ((unsigned)pos>>8) & 0xFF;  //addr High
+  eeprom_temp[2] = (unsigned)pos & 0xFF;       //addr Low
+  digitalWrite(SPI_EEPROM1_CS, LOW);
+  spiSend(SPI_CHAN_EEPROM1, eeprom_temp, 3);
+
+  spiSend(SPI_CHAN_EEPROM1, value);
+  digitalWrite(SPI_EEPROM1_CS, HIGH);
+  delay(7);   // wait for page write to complete
+}
+
+void eeprom_update_block(const void* src, void* eeprom_address, size_t n) {
+  uint8_t eeprom_temp[3];
+
+  /*write enable*/
+  eeprom_temp[0] = CMD_WREN;
+  digitalWrite(SPI_EEPROM1_CS, LOW);
+  spiSend(SPI_CHAN_EEPROM1, eeprom_temp, 1);
+  digitalWrite(SPI_EEPROM1_CS, HIGH);
+  delay(1);
+
+  /*write addr*/
+  eeprom_temp[0] = CMD_WRITE;
+  eeprom_temp[1] = ((unsigned)eeprom_address>>8) & 0xFF;  //addr High
+  eeprom_temp[2] = (unsigned)eeprom_address & 0xFF;       //addr Low
+  digitalWrite(SPI_EEPROM1_CS, LOW);
+  spiSend(SPI_CHAN_EEPROM1, eeprom_temp, 3);
+
+  spiSend(SPI_CHAN_EEPROM1, (const uint8_t*)src, n);
+  digitalWrite(SPI_EEPROM1_CS, HIGH);
+  delay(7);   // wait for page write to complete
+}
+
+
+#endif // ENABLED(SPI_EEPROM)

Marlin/src/HAL/math_32bit.h

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef MATH_32BIT_H
+#define MATH_32BIT_H
+
+/**
+ * Math helper functions for 32 bit CPUs
+ */
+
+#define MultiU32X32toH32(intRes, longIn1, longIn2) intRes = ((uint64_t)longIn1 * longIn2 + 0x80000000) >> 32
+#define MultiU32X24toH32(intRes, longIn1, longIn2) intRes = ((uint64_t)longIn1 * longIn2 + 0x00800000) >> 24
+
+#endif

Marlin/src/HAL/persistent_store_api.h

+#ifndef _PERSISTENT_STORE_H_
+#define _PERSISTENT_STORE_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+namespace HAL {
+namespace PersistentStore {
+
+bool access_start();
+bool access_finish();
+bool write_data(int &pos, const uint8_t *value, uint16_t size, uint16_t *crc);
+void read_data(int &pos, uint8_t* value, uint16_t size, uint16_t *crc) ;
+
+}
+}
+
+
+#endif /* _PERSISTANT_STORE_H_ */

Marlin/src/HAL/servo.cpp

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+
+/**
+ * servo.cpp - Interrupt driven Servo library for Arduino using 16 bit timers- Version 2
+ * Copyright (c) 2009 Michael Margolis.  All right reserved.
+ */
+
+/**
+ * A servo is activated by creating an instance of the Servo class passing the desired pin to the attach() method.
+ * The servos are pulsed in the background using the value most recently written using the write() method
+ *
+ * Note that analogWrite of PWM on pins associated with the timer are disabled when the first servo is attached.
+ * Timers are seized as needed in groups of 12 servos - 24 servos use two timers, 48 servos will use four.
+ *
+ * The methods are:
+ *
+ * Servo - Class for manipulating servo motors connected to Arduino pins.
+ *
+ * attach(pin)           - Attach a servo motor to an i/o pin.
+ * attach(pin, min, max) - Attach to a pin, setting min and max values in microseconds
+ *                         Default min is 544, max is 2400
+ *
+ * write()               - Set the servo angle in degrees. (Invalid angles —over MIN_PULSE_WIDTH— are treated as µs.)
+ * writeMicroseconds()   - Set the servo pulse width in microseconds.
+ * move(pin, angle)      - Sequence of attach(pin), write(angle), delay(SERVO_DELAY).
+ *                         With DEACTIVATE_SERVOS_AFTER_MOVE it detaches after SERVO_DELAY.
+ * read()                - Get the last-written servo pulse width as an angle between 0 and 180.
+ * readMicroseconds()    - Get the last-written servo pulse width in microseconds.
+ * attached()            - Return true if a servo is attached.
+ * detach()              - Stop an attached servo from pulsing its i/o pin.
+ *
+ */
+
+
+#include "../../MarlinConfig.h"
+
+#include "HAL.h"
+
+#if HAS_SERVOS && !IS_32BIT_TEENSY
+
+//#include <Arduino.h>
+
+#include "servo.h"
+#include "servo_private.h"
+
+ServoInfo_t servo_info[MAX_SERVOS];                  // static array of servo info structures
+uint8_t ServoCount = 0;                              // the total number of attached servos
+
+
+#define SERVO_MIN() (MIN_PULSE_WIDTH - this->min * 4)  // minimum value in uS for this servo
+#define SERVO_MAX() (MAX_PULSE_WIDTH - this->max * 4)  // maximum value in uS for this servo
+
+/************ static functions common to all instances ***********************/
+
+static boolean isTimerActive(timer16_Sequence_t timer) {
+  // returns true if any servo is active on this timer
+  for (uint8_t channel = 0; channel < SERVOS_PER_TIMER; channel++) {
+    if (SERVO(timer, channel).Pin.isActive)
+      return true;
+  }
+  return false;
+}
+
+/****************** end of static functions ******************************/
+
+Servo::Servo() {
+  if (ServoCount < MAX_SERVOS) {
+    this->servoIndex = ServoCount++;                    // assign a servo index to this instance
+    servo_info[this->servoIndex].ticks = usToTicks(DEFAULT_PULSE_WIDTH);   // store default values  - 12 Aug 2009
+  }
+  else
+    this->servoIndex = INVALID_SERVO;  // too many servos
+}
+
+int8_t Servo::attach(int pin) {
+  return this->attach(pin, MIN_PULSE_WIDTH, MAX_PULSE_WIDTH);
+}
+
+int8_t Servo::attach(int pin, int min, int max) {
+
+  if (this->servoIndex >= MAX_SERVOS) return -1;
+
+  if (pin > 0) servo_info[this->servoIndex].Pin.nbr = pin;
+  pinMode(servo_info[this->servoIndex].Pin.nbr, OUTPUT); // set servo pin to output
+
+  // todo min/max check: abs(min - MIN_PULSE_WIDTH) /4 < 128
+  this->min = (MIN_PULSE_WIDTH - min) / 4; //resolution of min/max is 4 uS
+  this->max = (MAX_PULSE_WIDTH - max) / 4;
+
+  // initialize the timer if it has not already been initialized
+  timer16_Sequence_t timer = SERVO_INDEX_TO_TIMER(servoIndex);
+  if (!isTimerActive(timer)) initISR(timer);
+  servo_info[this->servoIndex].Pin.isActive = true;  // this must be set after the check for isTimerActive
+
+  return this->servoIndex;
+}
+
+void Servo::detach() {
+  servo_info[this->servoIndex].Pin.isActive = false;
+  timer16_Sequence_t timer = SERVO_INDEX_TO_TIMER(servoIndex);
+  if (!isTimerActive(timer)) finISR(timer);
+}
+
+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)
+    value = map(constrain(value, 0, 180), 0, 180, SERVO_MIN(), SERVO_MAX());
+  }
+  this->writeMicroseconds(value);
+}
+
+void Servo::writeMicroseconds(int value) {
+  // calculate and store the values for the given channel
+  byte channel = this->servoIndex;
+  if (channel < MAX_SERVOS) {  // ensure channel is valid
+    // ensure pulse width is valid
+    value = constrain(value, SERVO_MIN(), SERVO_MAX()) - (TRIM_DURATION);
+    value = usToTicks(value);  // convert to ticks after compensating for interrupt overhead - 12 Aug 2009
+
+    CRITICAL_SECTION_START;
+    servo_info[channel].ticks = value;
+    CRITICAL_SECTION_END;
+  }
+}
+
+// return the value as degrees
+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;
+}
+
+bool Servo::attached() { return servo_info[this->servoIndex].Pin.isActive; }
+
+void Servo::move(int value) {
+  constexpr uint16_t servo_delay[] = SERVO_DELAY;
+  static_assert(COUNT(servo_delay) == NUM_SERVOS, "SERVO_DELAY must be an array NUM_SERVOS long.");
+  if (this->attach(0) >= 0) {
+    this->write(value);
+    delay(servo_delay[this->servoIndex]);
+    #if ENABLED(DEACTIVATE_SERVOS_AFTER_MOVE)
+      this->detach();
+    #endif
+  }
+}
+
+#endif // HAS_SERVOS
+

Marlin/servo.h → Marlin/src/HAL/servo.h

 #ifndef servo_h
 #define servo_h
 
-#include <inttypes.h>
+#if IS_32BIT_TEENSY
+  #include "HAL_TEENSY35_36/HAL_Servo_Teensy.h" // Teensy HAL uses an inherited library
+#else
 
-/**
- * Defines for 16 bit timers used with  Servo library
- *
- * If _useTimerX is defined then TimerX is a 16 bit timer on the current board
- * timer16_Sequence_t enumerates the sequence that the timers should be allocated
- * _Nbr_16timers indicates how many 16 bit timers are available.
- *
- */
+#include <inttypes.h>
 
-// Say which 16 bit timers can be used and in what order
-#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
-  //#define _useTimer1 // Timer 1 is used by the stepper ISR
-  #define _useTimer3
-  #define _useTimer4
-  #if !HAS_MOTOR_CURRENT_PWM
-    #define _useTimer5 // Timer 5 is used for motor current PWM and can't be used for servos.
-  #endif
-#elif defined(__AVR_ATmega32U4__)
-  #define _useTimer3
-#elif defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB1286__)
-  #define _useTimer3
-#elif defined(__AVR_ATmega128__) || defined(__AVR_ATmega1281__) || defined(__AVR_ATmega1284P__) || defined(__AVR_ATmega2561__)
-  #define _useTimer3
+#if defined(ARDUINO_ARCH_AVR) || defined(ARDUINO_ARCH_SAM)
+  // we're good to go
 #else
-  // everything else
+  #error "This library only supports boards with an AVR or SAM3X processor."
 #endif
 
-typedef enum {
-  #if ENABLED(_useTimer1)
-    _timer1,
-  #endif
-  #if ENABLED(_useTimer3)
-    _timer3,
-  #endif
-  #if ENABLED(_useTimer4)
-    _timer4,
-  #endif
-  #if ENABLED(_useTimer5)
-    _timer5,
-  #endif
-  _Nbr_16timers
-} timer16_Sequence_t;
-
-
 #define Servo_VERSION           2     // software version of this library
 
-#define MIN_PULSE_WIDTH       544     // the shortest pulse sent to a servo
-#define MAX_PULSE_WIDTH      2400     // the longest pulse sent to a servo
-#define DEFAULT_PULSE_WIDTH  1500     // default pulse width when servo is attached
-#define REFRESH_INTERVAL    20000     // minimum time to refresh servos in microseconds
-
-#define SERVOS_PER_TIMER       12     // the maximum number of servos controlled by one timer
-#define MAX_SERVOS   (_Nbr_16timers  * SERVOS_PER_TIMER)
-
-#define INVALID_SERVO         255     // flag indicating an invalid servo index
-
-typedef struct {
-  uint8_t nbr        : 6 ;            // a pin number from 0 to 63
-  uint8_t isActive   : 1 ;            // true if this channel is enabled, pin not pulsed if false
-} ServoPin_t;
-
-typedef struct {
-  ServoPin_t Pin;
-  unsigned int ticks;
-} ServoInfo_t;
-
 class Servo {
   public:
     Servo();
     int8_t max;                       // maximum is this value times 4 added to MAX_PULSE_WIDTH
 };
 
+#endif // !TEENSY
+
 #endif

Marlin/src/HAL/servo_private.h

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/**
+  servo.h - Interrupt driven Servo library for Arduino using 16 bit timers- Version 2
+  Copyright (c) 2009 Michael Margolis.  All right reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library 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
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef servo_private_h
+#define servo_private_h
+
+#include <inttypes.h>
+
+// Architecture specific include
+#ifdef ARDUINO_ARCH_AVR
+  #include "HAL_AVR/ServoTimers.h"
+#elif defined(ARDUINO_ARCH_SAM)
+  #include "HAL_DUE/ServoTimers.h"
+#else
+  #error "This library only supports boards with an AVR or SAM3X processor."
+#endif
+
+// Macros
+
+#define MIN_PULSE_WIDTH       544     // the shortest pulse sent to a servo
+#define MAX_PULSE_WIDTH      2400     // the longest pulse sent to a servo
+#define DEFAULT_PULSE_WIDTH  1500     // default pulse width when servo is attached
+#define REFRESH_INTERVAL    20000     // minimum time to refresh servos in microseconds
+
+#define SERVOS_PER_TIMER       12     // the maximum number of servos controlled by one timer
+#define MAX_SERVOS   (_Nbr_16timers  * SERVOS_PER_TIMER)
+
+#define INVALID_SERVO         255     // flag indicating an invalid servo index
+
+//
+#define usToTicks(_us)    (( clockCyclesPerMicrosecond()* _us) / PRESCALER)     // converts microseconds to tick (PRESCALER depends on architecture)
+#define ticksToUs(_ticks) (( (unsigned)_ticks * PRESCALER)/ clockCyclesPerMicrosecond() ) // converts from ticks back to microseconds
+
+//#define NBR_TIMERS        ((MAX_SERVOS) / (SERVOS_PER_TIMER))
+
+// convenience macros
+#define SERVO_INDEX_TO_TIMER(_servo_nbr) ((timer16_Sequence_t)(_servo_nbr / (SERVOS_PER_TIMER))) // returns the timer controlling this servo
+#define SERVO_INDEX_TO_CHANNEL(_servo_nbr) (_servo_nbr % (SERVOS_PER_TIMER))       // returns the index of the servo on this timer
+#define SERVO_INDEX(_timer,_channel)  ((_timer*(SERVOS_PER_TIMER)) + _channel)     // macro to access servo index by timer and channel
+#define SERVO(_timer,_channel)  (servo_info[SERVO_INDEX(_timer,_channel)])       // macro to access servo class by timer and channel
+
+// Types
+
+typedef struct {
+  uint8_t nbr        : 6 ;            // a pin number from 0 to 63
+  uint8_t isActive   : 1 ;            // true if this channel is enabled, pin not pulsed if false
+} ServoPin_t;
+
+typedef struct {
+  ServoPin_t Pin;
+  unsigned int ticks;
+} ServoInfo_t;
+
+// Global variables
+
+extern uint8_t ServoCount;
+extern ServoInfo_t servo_info[MAX_SERVOS];
+
+// Public functions
+
+extern void initISR(timer16_Sequence_t timer);
+extern void finISR(timer16_Sequence_t timer);
+
+
+#endif

Marlin/stepper.cpp

 #include "stepper.h"
 #include "endstops.h"
 #include "planner.h"
+#if MB(ALLIGATOR)
+  #include "dac_dac084s085.h"
+#endif
 #include "temperature.h"
 #include "ultralcd.h"
 #include "language.h"
 #include "cardreader.h"
-#include "speed_lookuptable.h"
+#ifdef ARDUINO_ARCH_AVR
+  #include "speed_lookuptable.h"
+#endif
 
 #if HAS_DIGIPOTSS
   #include <SPI.h>
 
 #if ENABLED(ADVANCE) || ENABLED(LIN_ADVANCE)
 
-  constexpr uint16_t ADV_NEVER = 65535;
+  constexpr HAL_TIMER_TYPE ADV_NEVER = HAL_TIMER_TYPE_MAX;
 
-  uint16_t Stepper::nextMainISR = 0,
-           Stepper::nextAdvanceISR = ADV_NEVER,
-           Stepper::eISR_Rate = ADV_NEVER;
+  HAL_TIMER_TYPE Stepper::nextMainISR = 0,
+         Stepper::nextAdvanceISR = ADV_NEVER,
+         Stepper::eISR_Rate = ADV_NEVER;
 
   #if ENABLED(LIN_ADVANCE)
     volatile int Stepper::e_steps[E_STEPPERS];
   long Stepper::counter_m[MIXING_STEPPERS];
 #endif
 
-unsigned short Stepper::acc_step_rate; // needed for deceleration start point
+HAL_TIMER_TYPE Stepper::acc_step_rate; // needed for deceleration start point
 uint8_t Stepper::step_loops, Stepper::step_loops_nominal;
-unsigned short Stepper::OCR1A_nominal;
+HAL_TIMER_TYPE Stepper::OCR1A_nominal;
 
 volatile long Stepper::endstops_trigsteps[XYZ];
 
   #define E_APPLY_STEP(v,Q) E_STEP_WRITE(v)
 #endif
 
-// intRes = longIn1 * longIn2 >> 24
-// uses:
-// r26 to store 0
-// r27 to store bits 16-23 of the 48bit result. The top bit is used to round the two byte result.
-// note that the lower two bytes and the upper byte of the 48bit result are not calculated.
-// this can cause the result to be out by one as the lower bytes may cause carries into the upper ones.
-// B0 A0 are bits 24-39 and are the returned value
-// C1 B1 A1 is longIn1
-// D2 C2 B2 A2 is longIn2
-//
-#define MultiU24X32toH16(intRes, longIn1, longIn2) \
-  asm volatile ( \
-                 "clr r26 \n\t" \
-                 "mul %A1, %B2 \n\t" \
-                 "mov r27, r1 \n\t" \
-                 "mul %B1, %C2 \n\t" \
-                 "movw %A0, r0 \n\t" \
-                 "mul %C1, %C2 \n\t" \
-                 "add %B0, r0 \n\t" \
-                 "mul %C1, %B2 \n\t" \
-                 "add %A0, r0 \n\t" \
-                 "adc %B0, r1 \n\t" \
-                 "mul %A1, %C2 \n\t" \
-                 "add r27, r0 \n\t" \
-                 "adc %A0, r1 \n\t" \
-                 "adc %B0, r26 \n\t" \
-                 "mul %B1, %B2 \n\t" \
-                 "add r27, r0 \n\t" \
-                 "adc %A0, r1 \n\t" \
-                 "adc %B0, r26 \n\t" \
-                 "mul %C1, %A2 \n\t" \
-                 "add r27, r0 \n\t" \
-                 "adc %A0, r1 \n\t" \
-                 "adc %B0, r26 \n\t" \
-                 "mul %B1, %A2 \n\t" \
-                 "add r27, r1 \n\t" \
-                 "adc %A0, r26 \n\t" \
-                 "adc %B0, r26 \n\t" \
-                 "lsr r27 \n\t" \
-                 "adc %A0, r26 \n\t" \
-                 "adc %B0, r26 \n\t" \
-                 "mul %D2, %A1 \n\t" \
-                 "add %A0, r0 \n\t" \
-                 "adc %B0, r1 \n\t" \
-                 "mul %D2, %B1 \n\t" \
-                 "add %B0, r0 \n\t" \
-                 "clr r1 \n\t" \
-                 : \
-                 "=&r" (intRes) \
-                 : \
-                 "d" (longIn1), \
-                 "d" (longIn2) \
-                 : \
-                 "r26" , "r27" \
-               )
-
-// Some useful constants
-
-#define ENABLE_STEPPER_DRIVER_INTERRUPT()  SBI(TIMSK1, OCIE1A)
-#define DISABLE_STEPPER_DRIVER_INTERRUPT() CBI(TIMSK1, OCIE1A)
+
 
 /**
  *         __________________________
  * Stepper Driver Interrupt
  *
  * Directly pulses the stepper motors at high frequency.
+ *
+ * AVR :
  * Timer 1 runs at a base frequency of 2MHz, with this ISR using OCR1A compare mode.
  *
  * OCR1A   Frequency
  *  2000     1 KHz - sleep rate
  *  4000   500  Hz - init rate
  */
-ISR(TIMER1_COMPA_vect) {
+
+HAL_STEP_TIMER_ISR {
+  HAL_timer_isr_prologue(STEP_TIMER_NUM);
   #if ENABLED(ADVANCE) || ENABLED(LIN_ADVANCE)
     Stepper::advance_isr_scheduler();
   #else
   #endif
 }
 
-#define _ENABLE_ISRs() do { cli(); if (thermalManager.in_temp_isr) CBI(TIMSK0, OCIE0B); else SBI(TIMSK0, OCIE0B); ENABLE_STEPPER_DRIVER_INTERRUPT(); } while(0)
-
 void Stepper::isr() {
 
-  uint16_t ocr_val;
+  HAL_TIMER_TYPE ocr_val;
 
   #define ENDSTOP_NOMINAL_OCR_VAL 3000    // check endstops every 1.5ms to guarantee two stepper ISRs within 5ms for BLTouch
   #define OCR_VAL_TOLERANCE 1000          // First max delay is 2.0ms, last min delay is 0.5ms, all others 1.5ms
 
   #if DISABLED(ADVANCE) && DISABLED(LIN_ADVANCE)
     // Disable Timer0 ISRs and enable global ISR again to capture UART events (incoming chars)
-    CBI(TIMSK0, OCIE0B); // Temperature ISR
+    DISABLE_TEMPERATURE_INTERRUPT(); // Temperature ISR
     DISABLE_STEPPER_DRIVER_INTERRUPT();
-    sei();
+    #if !defined(CPU_32_BIT)
+      sei();
+    #endif
   #endif
 
-  #define _SPLIT(L) (ocr_val = (uint16_t)L)
+  #define _SPLIT(L) (ocr_val = (HAL_TIMER_TYPE)L)
   #if ENABLED(ENDSTOP_INTERRUPTS_FEATURE)
     #define SPLIT(L) _SPLIT(L)
   #else                 // sample endstops in between step pulses
       }
 
       _NEXT_ISR(ocr_val);
+      #ifdef CPU_32_BIT
+        //todo: HAL?
+      #else
+        NOLESS(OCR1A, TCNT1 + 16);
+      #endif
 
-      NOLESS(OCR1A, TCNT1 + 16);
-
-      _ENABLE_ISRs(); // re-enable ISRs
+      HAL_ENABLE_ISRs(); // re-enable ISRs
       return;
     }
   #endif
     #ifdef SD_FINISHED_RELEASECOMMAND
       if (!cleaning_buffer_counter && (SD_FINISHED_STEPPERRELEASE)) enqueue_and_echo_commands_P(PSTR(SD_FINISHED_RELEASECOMMAND));
     #endif
-    _NEXT_ISR(200); // Run at max speed - 10 KHz
-    _ENABLE_ISRs(); // re-enable ISRs
+    _NEXT_ISR(HAL_STEPPER_TIMER_RATE / 10000); // Run at max speed - 10 KHz
+    HAL_ENABLE_ISRs(); // re-enable ISRs
     return;
   }
 
       #if ENABLED(Z_LATE_ENABLE)
         if (current_block->steps[Z_AXIS] > 0) {
           enable_Z();
-          _NEXT_ISR(2000); // Run at slow speed - 1 KHz
-          _ENABLE_ISRs(); // re-enable ISRs
+          _NEXT_ISR(HAL_STEPPER_TIMER_RATE / 1000); // Run at slow speed - 1 KHz
+          HAL_ENABLE_ISRs(); // re-enable ISRs
           return;
         }
       #endif
       // #endif
     }
     else {
-      _NEXT_ISR(2000); // Run at slow speed - 1 KHz
-      _ENABLE_ISRs(); // re-enable ISRs
+      _NEXT_ISR(HAL_STEPPER_TIMER_RATE / 1000); // Run at slow speed - 1 KHz
+      HAL_ENABLE_ISRs(); // re-enable ISRs
       return;
     }
   }
      * 10µs = 160 or 200 cycles.
      */
     #if EXTRA_CYCLES_XYZE > 20
-      uint32_t pulse_start = TCNT0;
+      uint32_t pulse_start = HAL_timer_get_current_count(STEP_TIMER_NUM);
     #endif
 
     #if HAS_X_STEP
 
     // For minimum pulse time wait before stopping pulses
     #if EXTRA_CYCLES_XYZE > 20
-      while (EXTRA_CYCLES_XYZE > (uint32_t)(TCNT0 - pulse_start) * (INT0_PRESCALER)) { /* nada */ }
-      pulse_start = TCNT0;
+      while (EXTRA_CYCLES_XYZE > (uint32_t)(HAL_timer_get_current_count(STEP_TIMER_NUM) - pulse_start) * (STEPPER_TIMER_PRESCALE)) { /* nada */ }
+      pulse_start = HAL_timer_get_current_count(STEP_TIMER_NUM);
     #elif EXTRA_CYCLES_XYZE > 0
       DELAY_NOPS(EXTRA_CYCLES_XYZE);
     #endif
 
     // For minimum pulse time wait after stopping pulses also
     #if EXTRA_CYCLES_XYZE > 20
-      if (i) while (EXTRA_CYCLES_XYZE > (uint32_t)(TCNT0 - pulse_start) * (INT0_PRESCALER)) { /* nada */ }
+      if (i) while (EXTRA_CYCLES_XYZE > (uint32_t)(HAL_timer_get_current_count(STEP_TIMER_NUM) - pulse_start) * (STEPPER_TIMER_PRESCALE)) { /* nada */ }
     #elif EXTRA_CYCLES_XYZE > 0
       if (i) DELAY_NOPS(EXTRA_CYCLES_XYZE);
     #endif
   // Calculate new timer value
   if (step_events_completed <= (uint32_t)current_block->accelerate_until) {
 
-    MultiU24X32toH16(acc_step_rate, acceleration_time, current_block->acceleration_rate);
+    #ifdef CPU_32_BIT
+      MultiU32X24toH32(acc_step_rate, acceleration_time, current_block->acceleration_rate);
+    #else
+      MultiU24X32toH16(acc_step_rate, acceleration_time, current_block->acceleration_rate);
+    #endif
     acc_step_rate += current_block->initial_rate;
 
     // upper limit
     NOMORE(acc_step_rate, current_block->nominal_rate);
 
     // step_rate to timer interval
-    const uint16_t timer = calc_timer(acc_step_rate);
+    const HAL_TIMER_TYPE timer = calc_timer(acc_step_rate);
 
     SPLIT(timer);  // split step into multiple ISRs if larger than  ENDSTOP_NOMINAL_OCR_VAL
     _NEXT_ISR(ocr_val);
     #endif // ADVANCE or LIN_ADVANCE
 
     #if ENABLED(ADVANCE) || ENABLED(LIN_ADVANCE)
+      // TODO: HAL
       eISR_Rate = adv_rate(e_steps[TOOL_E_INDEX], timer, step_loops);
     #endif
   }
   else if (step_events_completed > (uint32_t)current_block->decelerate_after) {
-    uint16_t step_rate;
-    MultiU24X32toH16(step_rate, deceleration_time, current_block->acceleration_rate);
+    HAL_TIMER_TYPE step_rate;
+    #ifdef CPU_32_BIT
+      MultiU32X24toH32(step_rate, deceleration_time, current_block->acceleration_rate);
+    #else
+      MultiU24X32toH16(step_rate, deceleration_time, current_block->acceleration_rate);
+    #endif
 
     if (step_rate < acc_step_rate) { // Still decelerating?
       step_rate = acc_step_rate - step_rate;
       step_rate = current_block->final_rate;
 
     // step_rate to timer interval
-    const uint16_t timer = calc_timer(step_rate);
+    const HAL_TIMER_TYPE timer = calc_timer(step_rate);
 
     SPLIT(timer);  // split step into multiple ISRs if larger than  ENDSTOP_NOMINAL_OCR_VAL
     _NEXT_ISR(ocr_val);
 
     SPLIT(OCR1A_nominal);  // split step into multiple ISRs if larger than  ENDSTOP_NOMINAL_OCR_VAL
     _NEXT_ISR(ocr_val);
-
     // ensure we're running at the correct step rate, even if we just came off an acceleration
     step_loops = step_loops_nominal;
   }
 
   #if DISABLED(ADVANCE) && DISABLED(LIN_ADVANCE)
-    NOLESS(OCR1A, TCNT1 + 16);
+    #ifdef CPU_32_BIT
+      // Make sure stepper interrupt does not monopolise CPU by adjusting count to give about 8 us room
+      uint32_t stepper_timer_count = HAL_timer_get_count(STEP_TIMER_NUM);
+      uint32_t stepper_timer_current_count = HAL_timer_get_current_count(STEP_TIMER_NUM) + 8 * HAL_TICKS_PER_US;
+      HAL_timer_set_count(STEP_TIMER_NUM, stepper_timer_count < stepper_timer_current_count ? stepper_timer_current_count : stepper_timer_count);
+    #else
+      NOLESS(OCR1A, TCNT1 + 16);
+    #endif
   #endif
 
   // If current block is finished, reset pointer
     planner.discard_current_block();
   }
   #if DISABLED(ADVANCE) && DISABLED(LIN_ADVANCE)
-    _ENABLE_ISRs(); // re-enable ISRs
+    HAL_ENABLE_ISRs(); // re-enable ISRs
   #endif
 }
 
 
   void Stepper::advance_isr_scheduler() {
     // Disable Timer0 ISRs and enable global ISR again to capture UART events (incoming chars)
-    CBI(TIMSK0, OCIE0B); // Temperature ISR
+    DISABLE_TEMPERATURE_INTERRUPT(); // Temperature ISR
     DISABLE_STEPPER_DRIVER_INTERRUPT();
     sei();
 
     NOLESS(OCR1A, TCNT1 + 16);
 
     // Restore original ISR settings
-    _ENABLE_ISRs();
+    HAL_ENABLE_ISRs();
   }
 
 #endif // ADVANCE or LIN_ADVANCE
     digipot_init();
   #endif
 
+  #if MB(ALLIGATOR)
+    const float motor_current[] = MOTOR_CURRENT;
+    unsigned int digipot_motor = 0;
+    for (uint8_t i = 0; i < 3 + EXTRUDERS; i++) {
+      digipot_motor = 255 * (motor_current[i] / 2.5);
+      dac084s085::setValue(i, digipot_motor);
+    }
+  #endif//MB(ALLIGATOR)
+
   // Init Microstepping Pins
   #if HAS_MICROSTEPS
     microstep_init();
     E_AXIS_INIT(4);
   #endif
 
+#ifdef ARDUINO_ARCH_AVR
   // waveform generation = 0100 = CTC
   SET_WGM(1, CTC_OCRnA);
 
   // Init Stepper ISR to 122 Hz for quick starting
   OCR1A = 0x4000;
   TCNT1 = 0;
+#else
+  // Init Stepper ISR to 122 Hz for quick starting
+  HAL_timer_start (STEP_TIMER_NUM, 122);
+#endif
+
   ENABLE_STEPPER_DRIVER_INTERRUPT();
 
   #if ENABLED(ADVANCE) || ENABLED(LIN_ADVANCE)
       case 4: microstep_ms(driver, MICROSTEP4); break;
       case 8: microstep_ms(driver, MICROSTEP8); break;
       case 16: microstep_ms(driver, MICROSTEP16); break;
+      #if MB(ALLIGATOR)
+        case 32: microstep_ms(driver, MICROSTEP32); break;
+      #endif
     }
   }
 

Marlin/stepper.h

 class Stepper;
 extern Stepper stepper;
 
-// intRes = intIn1 * intIn2 >> 16
-// uses:
-// r26 to store 0
-// r27 to store the byte 1 of the 24 bit result
-#define MultiU16X8toH16(intRes, charIn1, intIn2) \
-  asm volatile ( \
-                 "clr r26 \n\t" \
-                 "mul %A1, %B2 \n\t" \
-                 "movw %A0, r0 \n\t" \
-                 "mul %A1, %A2 \n\t" \
-                 "add %A0, r1 \n\t" \
-                 "adc %B0, r26 \n\t" \
-                 "lsr r0 \n\t" \
-                 "adc %A0, r26 \n\t" \
-                 "adc %B0, r26 \n\t" \
-                 "clr r1 \n\t" \
-                 : \
-                 "=&r" (intRes) \
-                 : \
-                 "d" (charIn1), \
-                 "d" (intIn2) \
-                 : \
-                 "r26" \
-               )
-
 class Stepper {
 
   public:
     static volatile uint32_t step_events_completed; // The number of step events executed in the current block
 
     #if ENABLED(ADVANCE) || ENABLED(LIN_ADVANCE)
-      static uint16_t nextMainISR, nextAdvanceISR, eISR_Rate;
+      static HAL_TIMER_TYPE nextMainISR, nextAdvanceISR, eISR_Rate;
       #define _NEXT_ISR(T) nextMainISR = T
+
       #if ENABLED(LIN_ADVANCE)
         static volatile int e_steps[E_STEPPERS];
         static int final_estep_rate;
         static long old_advance;
       #endif
     #else
-      #define _NEXT_ISR(T) OCR1A = T
+      #define _NEXT_ISR(T) HAL_timer_set_count(STEP_TIMER_NUM, T);
     #endif // ADVANCE or LIN_ADVANCE
 
     static long acceleration_time, deceleration_time;
     //unsigned long accelerate_until, decelerate_after, acceleration_rate, initial_rate, final_rate, nominal_rate;
-    static unsigned short acc_step_rate; // needed for deceleration start point
+    static HAL_TIMER_TYPE acc_step_rate; // needed for deceleration start point
     static uint8_t step_loops, step_loops_nominal;
-    static unsigned short OCR1A_nominal;
+    static HAL_TIMER_TYPE OCR1A_nominal;
 
     static volatile long endstops_trigsteps[XYZ];
     static volatile long endstops_stepsTotal, endstops_stepsDone;
 
   private:
 
-    static FORCE_INLINE unsigned short calc_timer(unsigned short step_rate) {
-      unsigned short timer;
+    static FORCE_INLINE HAL_TIMER_TYPE calc_timer(HAL_TIMER_TYPE step_rate) {
+      HAL_TIMER_TYPE timer;
 
       NOMORE(step_rate, MAX_STEP_FREQUENCY);
 
-      if (step_rate > 20000) { // If steprate > 20kHz >> step 4 times
-        step_rate >>= 2;
-        step_loops = 4;
-      }
-      else if (step_rate > 10000) { // If steprate > 10kHz >> step 2 times
-        step_rate >>= 1;
-        step_loops = 2;
-      }
-      else {
-        step_loops = 1;
-      }
+      // TODO: HAL: tidy this up, use condtionals_post.h
+      #ifdef CPU_32_BIT
+        #if ENABLED(DISABLE_MULTI_STEPPING)
+          step_loops = 1;
+        #else
+          if (step_rate > STEP_DOUBLER_FREQUENCY * 2) { // If steprate > (STEP_DOUBLER_FREQUENCY * 2) kHz >> step 4 times
+            step_rate >>= 2;
+            step_loops = 4;
+          }
+          else if (step_rate > STEP_DOUBLER_FREQUENCY) { // If steprate > STEP_DOUBLER_FREQUENCY kHz >> step 2 times
+            step_rate >>= 1;
+            step_loops = 2;
+          }
+          else {
+            step_loops = 1;
+          }
+        #endif
+      #else
+        if (step_rate > 20000) { // If steprate > 20kHz >> step 4 times
+          step_rate >>= 2;
+          step_loops = 4;
+        }
+        else if (step_rate > 10000) { // If steprate > 10kHz >> step 2 times
+          step_rate >>= 1;
+          step_loops = 2;
+        }
+        else {
+          step_loops = 1;
+        }
+      #endif
+
+      #ifdef CPU_32_BIT
+        // In case of high-performance processor, it is able to calculate in real-time 
+        timer = (uint32_t)(HAL_STEPPER_TIMER_RATE) / step_rate;
+        if (timer < (HAL_STEPPER_TIMER_RATE / (STEP_DOUBLER_FREQUENCY * 2))) { // (STEP_DOUBLER_FREQUENCY * 2 kHz - this should never happen)
+          timer = (HAL_STEPPER_TIMER_RATE / (STEP_DOUBLER_FREQUENCY * 2));
+        }
+      #else
+        NOLESS(step_rate, F_CPU / 500000);
+        step_rate -= F_CPU / 500000; // Correct for minimal speed
+        if (step_rate >= (8 * 256)) { // higher step rate
+          unsigned short table_address = (unsigned short)&speed_lookuptable_fast[(unsigned char)(step_rate >> 8)][0];
+          unsigned char tmp_step_rate = (step_rate & 0x00ff);
+          unsigned short gain = (unsigned short)pgm_read_word_near(table_address + 2);
+          MultiU16X8toH16(timer, tmp_step_rate, gain);
+          timer = (unsigned short)pgm_read_word_near(table_address) - timer;
+        }
+        else { // lower step rates
+          unsigned short table_address = (unsigned short)&speed_lookuptable_slow[0][0];
+          table_address += ((step_rate) >> 1) & 0xfffc;
+          timer = (unsigned short)pgm_read_word_near(table_address);
+          timer -= (((unsigned short)pgm_read_word_near(table_address + 2) * (unsigned char)(step_rate & 0x0007)) >> 3);
+        }
+        if (timer < 100) { // (20kHz - this should never happen)
+          timer = 100;
+          MYSERIAL.print(MSG_STEPPER_TOO_HIGH);
+          MYSERIAL.println(step_rate);
+        }
+      #endif
 
-      NOLESS(step_rate, F_CPU / 500000);
-      step_rate -= F_CPU / 500000; // Correct for minimal speed
-      if (step_rate >= (8 * 256)) { // higher step rate
-        unsigned short table_address = (unsigned short)&speed_lookuptable_fast[(unsigned char)(step_rate >> 8)][0];
-        unsigned char tmp_step_rate = (step_rate & 0x00FF);
-        unsigned short gain = (unsigned short)pgm_read_word_near(table_address + 2);
-        MultiU16X8toH16(timer, tmp_step_rate, gain);
-        timer = (unsigned short)pgm_read_word_near(table_address) - timer;
-      }
-      else { // lower step rates
-        unsigned short table_address = (unsigned short)&speed_lookuptable_slow[0][0];
-        table_address += ((step_rate) >> 1) & 0xFFFC;
-        timer = (unsigned short)pgm_read_word_near(table_address);
-        timer -= (((unsigned short)pgm_read_word_near(table_address + 2) * (unsigned char)(step_rate & 0x0007)) >> 3);
-      }
-      if (timer < 100) { // (20kHz - this should never happen)
-        timer = 100;
-        MYSERIAL.print(MSG_STEPPER_TOO_HIGH);
-        MYSERIAL.println(step_rate);
-      }
       return timer;
     }
 

Marlin/temperature.cpp

 #include "language.h"
 
 #if ENABLED(HEATER_0_USES_MAX6675)
-  #include "spi.h"
+  #include "private_spi.h"
 #endif
 
 #if ENABLED(BABYSTEPPING)
   #include "endstops.h"
 #endif
 
-#if ENABLED(USE_WATCHDOG)
-  #include "watchdog.h"
-#endif
-
 #ifdef K1 // Defined in Configuration.h in the PID settings
   #define K2 (1.0-K1)
 #endif
 
   #endif // HEATER_0_USES_MAX6675
 
-  #ifdef DIDR2
-    #define ANALOG_SELECT(pin) do{ if (pin < 8) SBI(DIDR0, pin); else SBI(DIDR2, pin - 8); }while(0)
-  #else
-    #define ANALOG_SELECT(pin) do{ SBI(DIDR0, pin); }while(0)
-  #endif
+  HAL_adc_init();
 
-  // Set analog inputs
-  ADCSRA = _BV(ADEN) | _BV(ADSC) | _BV(ADIF) | 0x07;
-  DIDR0 = 0;
-  #ifdef DIDR2
-    DIDR2 = 0;
-  #endif
   #if HAS_TEMP_0
-    ANALOG_SELECT(TEMP_0_PIN);
+    HAL_ANALOG_SELECT(TEMP_0_PIN);
   #endif
   #if HAS_TEMP_1
-    ANALOG_SELECT(TEMP_1_PIN);
+    HAL_ANALOG_SELECT(TEMP_1_PIN);
   #endif
   #if HAS_TEMP_2
-    ANALOG_SELECT(TEMP_2_PIN);
+    HAL_ANALOG_SELECT(TEMP_2_PIN);
   #endif
   #if HAS_TEMP_3
-    ANALOG_SELECT(TEMP_3_PIN);
+    HAL_ANALOG_SELECT(TEMP_3_PIN);
   #endif
   #if HAS_TEMP_4
-    ANALOG_SELECT(TEMP_4_PIN);
+    HAL_ANALOG_SELECT(TEMP_4_PIN);
   #endif
   #if HAS_TEMP_BED
-    ANALOG_SELECT(TEMP_BED_PIN);
+    HAL_ANALOG_SELECT(TEMP_BED_PIN);
   #endif
   #if ENABLED(FILAMENT_WIDTH_SENSOR)
-    ANALOG_SELECT(FILWIDTH_PIN);
+    HAL_ANALOG_SELECT(FILWIDTH_PIN);
+  #endif
+
+// todo: HAL: fix abstraction
+  #ifdef ARDUINO_ARCH_AVR
+    // Use timer0 for temperature measurement
+    // Interleave temperature interrupt with millies interrupt
+    OCR0B = 128;
+    SBI(TIMSK0, OCIE0B);
+  #else
+    HAL_timer_start (TEMP_TIMER_NUM, TEMP_TIMER_FREQUENCY);
+    HAL_timer_enable_interrupt (TEMP_TIMER_NUM);
   #endif
 
   #if HAS_AUTO_FAN_0
     #endif
   #endif
 
-  // Use timer0 for temperature measurement
-  // Interleave temperature interrupt with millies interrupt
-  OCR0B = 128;
-  SBI(TIMSK0, OCIE0B);
-
   // Wait for temperature measurement to settle
   delay(250);
 
     uint32_t max6675_temp = 2000;
     #define MAX6675_ERROR_MASK 7
     #define MAX6675_DISCARD_BITS 18
-    #define MAX6675_SPEED_BITS (_BV(SPR1)) // clock ÷ 64
+    #define MAX6675_SPEED_BITS 3  // (_BV(SPR1)) // clock ÷ 64
   #else
     uint16_t max6675_temp = 2000;
     #define MAX6675_ERROR_MASK 4
     #define MAX6675_DISCARD_BITS 3
-    #define MAX6675_SPEED_BITS (_BV(SPR0)) // clock ÷ 16
+    #define MAX6675_SPEED_BITS 2 // (_BV(SPR0)) // clock ÷ 16
   #endif
 
   int Temperature::read_max6675() {
 
     next_max6675_ms = ms + MAX6675_HEAT_INTERVAL;
 
-    CBI(
-      #ifdef PRR
-        PRR
-      #elif defined(PRR0)
-        PRR0
-      #endif
-        , PRSPI);
-    SPCR = _BV(MSTR) | _BV(SPE) | MAX6675_SPEED_BITS;
+    spiBegin();
+    spiInit(MAX6675_SPEED_BITS);
 
     WRITE(MAX6675_SS, 0); // enable TT_MAX6675
 
     // Read a big-endian temperature value
     max6675_temp = 0;
     for (uint8_t i = sizeof(max6675_temp); i--;) {
-      max6675_temp |= max6675_spi.receive();
+      max6675_temp |= spiRec();
       if (i > 0) max6675_temp <<= 8; // shift left if not the last byte
     }
 
  *  - For PINS_DEBUGGING, monitor and report endstop pins
  *  - For ENDSTOP_INTERRUPTS_FEATURE check endstops if flagged
  */
-ISR(TIMER0_COMPB_vect) { Temperature::isr(); }
+HAL_TEMP_TIMER_ISR {
+  HAL_timer_isr_prologue (TEMP_TIMER_NUM);
+  Temperature::isr();
+}
 
 volatile bool Temperature::in_temp_isr = false;
 
   in_temp_isr = true;
 
   // Allow UART and stepper ISRs
-  CBI(TIMSK0, OCIE0B); //Disable Temperature ISR
-  sei();
+  DISABLE_TEMPERATURE_INTERRUPT(); //Disable Temperature ISR
+  #if !defined(CPU_32_BIT)
+    sei();
+  #endif
 
   static int8_t temp_count = -1;
   static ADCSensorState adc_sensor_state = StartupDelay;
    * This gives each ADC 0.9765ms to charge up.
    */
 
-  #define SET_ADMUX_ADCSRA(pin) ADMUX = _BV(REFS0) | (pin & 0x07); SBI(ADCSRA, ADSC)
-  #ifdef MUX5
-    #define START_ADC(pin) if (pin > 7) ADCSRB = _BV(MUX5); else ADCSRB = 0; SET_ADMUX_ADCSRA(pin)
-  #else
-    #define START_ADC(pin) ADCSRB = 0; SET_ADMUX_ADCSRA(pin)
-  #endif
-
   switch (adc_sensor_state) {
 
     case SensorsReady: {
 
     #if HAS_TEMP_0
       case PrepareTemp_0:
-        START_ADC(TEMP_0_PIN);
+        HAL_START_ADC(TEMP_0_PIN);
         break;
       case MeasureTemp_0:
-        raw_temp_value[0] += ADC;
+        raw_temp_value[0] += HAL_READ_ADC;
         break;
     #endif
 
     #if HAS_TEMP_BED
       case PrepareTemp_BED:
-        START_ADC(TEMP_BED_PIN);
+        HAL_START_ADC(TEMP_BED_PIN);
         break;
       case MeasureTemp_BED:
-        raw_temp_bed_value += ADC;
+        raw_temp_bed_value += HAL_READ_ADC;
         break;
     #endif
 
     #if HAS_TEMP_1
       case PrepareTemp_1:
-        START_ADC(TEMP_1_PIN);
+        HAL_START_ADC(TEMP_1_PIN);
         break;
       case MeasureTemp_1:
-        raw_temp_value[1] += ADC;
+        raw_temp_value[1] += HAL_READ_ADC;
         break;
     #endif
 
     #if HAS_TEMP_2
       case PrepareTemp_2:
-        START_ADC(TEMP_2_PIN);
+        HAL_START_ADC(TEMP_2_PIN);
         break;
       case MeasureTemp_2:
-        raw_temp_value[2] += ADC;
+        raw_temp_value[2] += HAL_READ_ADC;
         break;
     #endif
 
     #if HAS_TEMP_3
       case PrepareTemp_3:
-        START_ADC(TEMP_3_PIN);
+        HAL_START_ADC(TEMP_3_PIN);
         break;
       case MeasureTemp_3:
-        raw_temp_value[3] += ADC;
+        raw_temp_value[3] += HAL_READ_ADC;
         break;
     #endif
 
     #if HAS_TEMP_4
       case PrepareTemp_4:
-        START_ADC(TEMP_4_PIN);
+        HAL_START_ADC(TEMP_4_PIN);
         break;
       case MeasureTemp_4:
-        raw_temp_value[4] += ADC;
+        raw_temp_value[4] += HAL_READ_ADC;
         break;
     #endif
 
     #if ENABLED(FILAMENT_WIDTH_SENSOR)
       case Prepare_FILWIDTH:
-        START_ADC(FILWIDTH_PIN);
+        HAL_START_ADC(FILWIDTH_PIN);
       break;
       case Measure_FILWIDTH:
-        if (ADC > 102) { // Make sure ADC is reading > 0.5 volts, otherwise don't read.
+        if (HAL_READ_ADC > 102) { // Make sure ADC is reading > 0.5 volts, otherwise don't read.
           raw_filwidth_value -= (raw_filwidth_value >> 7); // Subtract 1/128th of the raw_filwidth_value
-          raw_filwidth_value += ((unsigned long)ADC << 7); // Add new ADC reading, scaled by 128
+          raw_filwidth_value += ((unsigned long)HAL_READ_ADC << 7); // Add new ADC reading, scaled by 128
         }
       break;
     #endif
     }
   #endif
 
-  cli();
+  #if !defined(CPU_32_BIT)
+    cli();
+  #endif
   in_temp_isr = false;
-  SBI(TIMSK0, OCIE0B); //re-enable Temperature ISR
+  ENABLE_TEMPERATURE_INTERRUPT(); //re-enable Temperature ISR
 }

Marlin/temperature.h

     #endif
 
     #if ENABLED(PIDTEMP) || ENABLED(PIDTEMPBED)
-      #define PID_dT ((OVERSAMPLENR * float(ACTUAL_ADC_SAMPLES)) / (F_CPU / 64.0 / 256.0))
+      #define PID_dT ((OVERSAMPLENR * float(ACTUAL_ADC_SAMPLES)) / TEMP_TIMER_FREQUENCY)
     #endif
 
     #if ENABLED(PIDTEMP)

Marlin/ubl_G29.cpp

         z_values[x][y] -= tmp_z_values[x][y];
   }
 
-  mesh_index_pair unified_bed_leveling::find_closest_mesh_point_of_type(const MeshPointType type, const float &lx, const float &ly, const bool probe_as_reference, unsigned int bits[16], const bool far_flag) {
+  mesh_index_pair unified_bed_leveling::find_closest_mesh_point_of_type(const MeshPointType type, const float &lx, const float &ly, const bool probe_as_reference, uint16_t bits[16], const bool far_flag) {
     mesh_index_pair out_mesh;
     out_mesh.x_index = out_mesh.y_index = -1;
 

Marlin/ubl_motion.cpp

   #include "ubl.h"
   #include "planner.h"
   #include "stepper.h"
-  #include <avr/io.h>
   #include <math.h>
 
   extern float destination[XYZE];
   #endif // UBL_DELTA
 
 #endif // AUTO_BED_LEVELING_UBL
-

Marlin/ultralcd.cpp

     void menu_action_setting_edit_callback_ ## _name(const char * const pstr, _type * const ptr, const _type minValue, const _type maxValue, const screenFunc_t callback, const bool live=false); \
     typedef void _name##_void
 
+  DECLARE_MENU_EDIT_TYPE(uint32_t, long5);
   DECLARE_MENU_EDIT_TYPE(int16_t, int3);
   DECLARE_MENU_EDIT_TYPE(uint8_t, int8);
   DECLARE_MENU_EDIT_TYPE(float, float3);
   DECLARE_MENU_EDIT_TYPE(float, float51);
   DECLARE_MENU_EDIT_TYPE(float, float52);
   DECLARE_MENU_EDIT_TYPE(float, float62);
-  DECLARE_MENU_EDIT_TYPE(uint32_t, long5);
 
   void menu_action_setting_edit_bool(const char* pstr, bool* ptr);
   void menu_action_setting_edit_callback_bool(const char* pstr, bool* ptr, screenFunc_t callbackFunc);
     } \
     typedef void _name
 
+  DEFINE_MENU_EDIT_TYPE(uint32_t, long5, ftostr5rj, 0.01);
   DEFINE_MENU_EDIT_TYPE(int16_t, int3, itostr3, 1);
   DEFINE_MENU_EDIT_TYPE(uint8_t, int8, i8tostr3, 1);
   DEFINE_MENU_EDIT_TYPE(float, float3, ftostr3, 1.0);
   DEFINE_MENU_EDIT_TYPE(float, float51, ftostr51sign, 10.0);
   DEFINE_MENU_EDIT_TYPE(float, float52, ftostr52sign, 100.0);
   DEFINE_MENU_EDIT_TYPE(float, float62, ftostr62rj, 100.0);
-  DEFINE_MENU_EDIT_TYPE(uint32_t, long5, ftostr5rj, 0.01);
 
   /**
    *

Marlin/ultralcd_impl_DOGM.h

     } \
     typedef void _name##_void
 
+  DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(uint32_t, long5, ftostr5rj);
   DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(int16_t, int3, itostr3);
   DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(uint8_t, int8, i8tostr3);
   DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(float, float3, ftostr3);
   DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(float, float51, ftostr51sign);
   DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(float, float52, ftostr52sign);
   DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(float, float62, ftostr62rj);
-  DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(uint32_t, long5, ftostr5rj);
 
   #define lcd_implementation_drawmenu_setting_edit_bool(sel, row, pstr, pstr2, data) lcd_implementation_drawmenu_setting_edit_generic_P(sel, row, pstr, (*(data))?PSTR(MSG_ON):PSTR(MSG_OFF))
   #define lcd_implementation_drawmenu_setting_edit_callback_bool(sel, row, pstr, pstr2, data, callback) lcd_implementation_drawmenu_setting_edit_generic_P(sel, row, pstr, (*(data))?PSTR(MSG_ON):PSTR(MSG_OFF))

Marlin/ultralcd_impl_HD44780.h

     } \
     typedef void _name##_void
 
+  DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(uint32_t, long5, ftostr5rj);
   DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(int16_t, int3, itostr3);
   DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(uint8_t, int8, i8tostr3);
   DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(float, float3, ftostr3);
   DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(float, float51, ftostr51sign);
   DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(float, float52, ftostr52sign);
   DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(float, float62, ftostr62rj);
-  DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(uint32_t, long5, ftostr5rj);
 
   #define lcd_implementation_drawmenu_setting_edit_bool(sel, row, pstr, pstr2, data) lcd_implementation_drawmenu_setting_edit_generic_P(sel, row, pstr, '>', (*(data))?PSTR(MSG_ON):PSTR(MSG_OFF))
   #define lcd_implementation_drawmenu_setting_edit_callback_bool(sel, row, pstr, pstr2, data, callback) lcd_implementation_drawmenu_setting_edit_generic_P(sel, row, pstr, '>', (*(data))?PSTR(MSG_ON):PSTR(MSG_OFF))