Removed interrupt nesting in the stepper ISR.

Add serial checkRx in stepper ISR.
Copied HardwareSerial to MarlinSerial (Needed for checkRx).

diff --git a/Marlin/Configuration.h b/Marlin/Configuration.h
index 3a1983956dc12101f42b15e70c423f8a7df10a83..558044e280e43e9e2a76c70dd5d1427b72fea7f7 100644 (file)
--- a/Marlin/Configuration.h
+++ b/Marlin/Configuration.h
@@ -232,7 +232,7 @@ const bool Z_ENDSTOPS_INVERTING = true; // set to true to invert the logic of th
 
 // minimum time in microseconds that a movement needs to take if the buffer is emptied.   Increase this number if you see blobs while printing high speed & high detail.  It will slowdown on the detailed stuff.
 #define DEFAULT_MINSEGMENTTIME        20000   // Obsolete delete this
-#define DEFAULT_XYJERK                30.0    // (mm/sec)
+#define DEFAULT_XYJERK                20.0    // (mm/sec)
 #define DEFAULT_ZJERK                 0.4     // (mm/sec)
 
 

diff --git a/Marlin/EEPROMwrite.h b/Marlin/EEPROMwrite.h
index 3d559c0269846847a0c5b0564f7ab43feb427ce8..c298c97350801a384829798cbc44767cdbeb09ca 100644 (file)
--- a/Marlin/EEPROMwrite.h
+++ b/Marlin/EEPROMwrite.h
@@ -4,6 +4,7 @@
 #include "Marlin.h"
 #include "planner.h"
 #include "temperature.h"
+
 #include <EEPROM.h>
 
 template <class T> int EEPROM_writeAnything(int &ee, const T& value)

diff --git a/Marlin/Marlin.h b/Marlin/Marlin.h
index acfc3c2fa6ef16ecc90a1aeb4eb51c5208946ac5..57f403dffd0e10b7537c5640350eff572c0fc0e2 100644 (file)
--- a/Marlin/Marlin.h
+++ b/Marlin/Marlin.h
@@ -3,10 +3,12 @@
 
 // Tonokip RepRap firmware rewrite based off of Hydra-mmm firmware.
 // Licence: GPL
+#define  HardwareSerial_h // trick to disable the standard HWserial
 #include <WProgram.h>
 #include "fastio.h"
 #include <avr/pgmspace.h>
 #include "Configuration.h"
+#include "MarlinSerial.h"
 
 //#define SERIAL_ECHO(x) Serial << "echo: " << x;
 //#define SERIAL_ECHOLN(x) Serial << "echo: "<<x<<endl;
@@ -17,10 +19,10 @@
 
 
 
-#define SERIAL_PROTOCOL(x) Serial.print(x);
+#define SERIAL_PROTOCOL(x) MSerial.print(x);
 #define SERIAL_PROTOCOLPGM(x) serialprintPGM(PSTR(x));
-#define SERIAL_PROTOCOLLN(x) {Serial.print(x);Serial.write('\n');}
-#define SERIAL_PROTOCOLLNPGM(x) {serialprintPGM(PSTR(x));Serial.write('\n');}
+#define SERIAL_PROTOCOLLN(x) {MSerial.print(x);MSerial.write('\n');}
+#define SERIAL_PROTOCOLLNPGM(x) {serialprintPGM(PSTR(x));MSerial.write('\n');}
 
 const char errormagic[] PROGMEM ="Error:";
 const char echomagic[] PROGMEM ="echo:";
@@ -46,7 +48,7 @@ inline void serialprintPGM(const char *str)
   char ch=pgm_read_byte(str);
   while(ch)
   {
-    Serial.write(ch);
+    MSerial.write(ch);
     ch=pgm_read_byte(++str);
   }
 }

diff --git a/Marlin/Marlin.pde b/Marlin/Marlin.pde
index 836f5aa9ab78a60c18d9ceceb2f28ba199fc5b92..4c1535bf587c84350784e6917711d30a4215d0f9 100644 (file)
--- a/Marlin/Marlin.pde
+++ b/Marlin/Marlin.pde
@@ -176,6 +176,7 @@ static unsigned long stoptime=0;
 
 static uint8_t tmp_extruder;
 
+
 //===========================================================================
 //=============================ROUTINES=============================
 //===========================================================================
@@ -199,13 +200,6 @@ extern "C"{
   }
 }
 
-
-
-
-
-
-
-
 //adds an command to the main command buffer
 //thats really done in a non-safe way.
 //needs overworking someday
@@ -226,7 +220,7 @@ void enquecommand(const char *cmd)
 
 void setup()
 { 
-  Serial.begin(BAUDRATE);
+  MSerial.begin(BAUDRATE);
   SERIAL_ECHO_START;
   SERIAL_ECHOLNPGM(VERSION_STRING);
   SERIAL_PROTOCOLLNPGM("start");
@@ -289,15 +283,14 @@ void loop()
   manage_heater();
   manage_inactivity(1);
   checkHitEndstops();
-  checkStepperErrors();
   LCD_STATUS;
 }
 
 
 inline void get_command() 
 { 
-  while( Serial.available() > 0  && buflen < BUFSIZE) {
-    serial_char = Serial.read();
+  while( MSerial.available() > 0  && buflen < BUFSIZE) {
+    serial_char = MSerial.read();
     if(serial_char == '\n' || serial_char == '\r' || serial_char == ':' || serial_count >= (MAX_CMD_SIZE - 1) ) 
     {
       if(!serial_count) return; //if empty line
@@ -1039,7 +1032,7 @@ inline void process_commands()
 void FlushSerialRequestResend()
 {
   //char cmdbuffer[bufindr][100]="Resend:";
-  Serial.flush();
+  MSerial.flush();
   SERIAL_PROTOCOLPGM("Resend:");
   SERIAL_PROTOCOLLN(gcode_LastN + 1);
   ClearToSend();
@@ -1088,7 +1081,7 @@ void prepare_move()
     if (destination[Z_AXIS] > Z_MAX_LENGTH) destination[Z_AXIS] = Z_MAX_LENGTH;
   }
 
-  plan_buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], feedrate*feedmultiply/60/100.0);
+  plan_buffer_line(destination[X_AXIS], destination[Y_AXIS], destination[Z_AXIS], destination[E_AXIS], feedrate*feedmultiply/60/100.0, active_extruder);
   for(int8_t i=0; i < NUM_AXIS; i++) {
     current_position[i] = destination[i];
   }
@@ -1098,7 +1091,7 @@ void prepare_arc_move(char isclockwise) {
   float r = hypot(offset[X_AXIS], offset[Y_AXIS]); // Compute arc radius for mc_arc
 
   // Trace the arc
-  mc_arc(current_position, destination, offset, X_AXIS, Y_AXIS, Z_AXIS, feedrate*feedmultiply/60/100.0, r, isclockwise);
+  mc_arc(current_position, destination, offset, X_AXIS, Y_AXIS, Z_AXIS, feedrate*feedmultiply/60/100.0, r, isclockwise, active_extruder);
   
   // As far as the parser is concerned, the position is now == target. In reality the
   // motion control system might still be processing the action and the real tool position
@@ -1108,10 +1101,6 @@ void prepare_arc_move(char isclockwise) {
   }
 }
 
-
-
-
-
 void manage_inactivity(byte debug) 
 { 
   if( (millis()-previous_millis_cmd) >  max_inactive_time ) 

diff --git a/Marlin/MarlinSerial.cpp b/Marlin/MarlinSerial.cpp
new file mode 100644 (file)
index 0000000..fade8b2
--- /dev/null
+++ b/Marlin/MarlinSerial.cpp
@@ -0,0 +1,213 @@
+/*
+  HardwareSerial.cpp - Hardware serial library for Wiring
+  Copyright (c) 2006 Nicholas Zambetti.  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
+  
+  Modified 23 November 2006 by David A. Mellis
+  Modified 28 September 2010 by Mark Sproul
+*/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <inttypes.h>
+#include "wiring.h"
+#include "wiring_private.h"
+
+// this next line disables the entire HardwareSerial.cpp, 
+// this is so I can support Attiny series and any other chip without a uart
+#if defined(UBRRH) || defined(UBRR0H) || defined(UBRR1H) || defined(UBRR2H) || defined(UBRR3H)
+
+#include "MarlinSerial.h"
+
+// Define constants and variables for buffering incoming serial data.  We're
+// using a ring buffer (I think), in which rx_buffer_head is the index of the
+// location to which to write the next incoming character and rx_buffer_tail
+// is the index of the location from which to read.
+#define RX_BUFFER_SIZE 128
+
+struct ring_buffer
+{
+  unsigned char buffer[RX_BUFFER_SIZE];
+  int head;
+  int tail;
+};
+
+#if defined(UBRRH) || defined(UBRR0H)
+  ring_buffer rx_buffer  =  { { 0 }, 0, 0 };
+#endif
+
+
+inline void store_char(unsigned char c, ring_buffer *rx_buffer)
+{
+  int i = (unsigned int)(rx_buffer->head + 1) % RX_BUFFER_SIZE;
+
+  // if we should be storing the received character into the location
+  // just before the tail (meaning that the head would advance to the
+  // current location of the tail), we're about to overflow the buffer
+  // and so we don't write the character or advance the head.
+  if (i != rx_buffer->tail) {
+    rx_buffer->buffer[rx_buffer->head] = c;
+    rx_buffer->head = i;
+  }
+}
+
+
+//#elif defined(SIG_USART_RECV)
+#if defined(USART0_RX_vect)
+  // fixed by Mark Sproul this is on the 644/644p
+  //SIGNAL(SIG_USART_RECV)
+  SIGNAL(USART0_RX_vect)
+  {
+  #if defined(UDR0)
+    unsigned char c  =  UDR0;
+  #elif defined(UDR)
+    unsigned char c  =  UDR;  //  atmega8, atmega32
+  #else
+    #error UDR not defined
+  #endif
+    store_char(c, &rx_buffer);
+  }
+#endif
+
+// Constructors ////////////////////////////////////////////////////////////////
+
+MarlinSerial::MarlinSerial(ring_buffer *rx_buffer,
+  volatile uint8_t *ubrrh, volatile uint8_t *ubrrl,
+  volatile uint8_t *ucsra, volatile uint8_t *ucsrb,
+  volatile uint8_t *udr,
+  uint8_t rxen, uint8_t txen, uint8_t rxcie, uint8_t udre, uint8_t u2x)
+{
+  _rx_buffer = rx_buffer;
+  _ubrrh = ubrrh;
+  _ubrrl = ubrrl;
+  _ucsra = ucsra;
+  _ucsrb = ucsrb;
+  _udr = udr;
+  _rxen = rxen;
+  _txen = txen;
+  _rxcie = rxcie;
+  _udre = udre;
+  _u2x = u2x;
+}
+
+// Public Methods //////////////////////////////////////////////////////////////
+
+void MarlinSerial::begin(long baud)
+{
+  uint16_t baud_setting;
+  bool use_u2x = true;
+
+#if F_CPU == 16000000UL
+  // hardcoded exception for compatibility with the bootloader shipped
+  // with the Duemilanove and previous boards and the firmware on the 8U2
+  // on the Uno and Mega 2560.
+  if (baud == 57600) {
+    use_u2x = false;
+  }
+#endif
+  
+  if (use_u2x) {
+    *_ucsra = 1 << _u2x;
+    baud_setting = (F_CPU / 4 / baud - 1) / 2;
+  } else {
+    *_ucsra = 0;
+    baud_setting = (F_CPU / 8 / baud - 1) / 2;
+  }
+
+  // assign the baud_setting, a.k.a. ubbr (USART Baud Rate Register)
+  *_ubrrh = baud_setting >> 8;
+  *_ubrrl = baud_setting;
+
+  sbi(*_ucsrb, _rxen);
+  sbi(*_ucsrb, _txen);
+  sbi(*_ucsrb, _rxcie);
+}
+
+void MarlinSerial::end()
+{
+  cbi(*_ucsrb, _rxen);
+  cbi(*_ucsrb, _txen);
+  cbi(*_ucsrb, _rxcie);  
+}
+
+int MarlinSerial::available(void)
+{
+  return (unsigned int)(RX_BUFFER_SIZE + _rx_buffer->head - _rx_buffer->tail) % RX_BUFFER_SIZE;
+}
+
+int MarlinSerial::peek(void)
+{
+  if (_rx_buffer->head == _rx_buffer->tail) {
+    return -1;
+  } else {
+    return _rx_buffer->buffer[_rx_buffer->tail];
+  }
+}
+
+int MarlinSerial::read(void)
+{
+  // if the head isn't ahead of the tail, we don't have any characters
+  if (_rx_buffer->head == _rx_buffer->tail) {
+    return -1;
+  } else {
+    unsigned char c = _rx_buffer->buffer[_rx_buffer->tail];
+    _rx_buffer->tail = (unsigned int)(_rx_buffer->tail + 1) % RX_BUFFER_SIZE;
+    return c;
+  }
+}
+
+void MarlinSerial::flush()
+{
+  // don't reverse this or there may be problems if the RX interrupt
+  // occurs after reading the value of rx_buffer_head but before writing
+  // the value to rx_buffer_tail; the previous value of rx_buffer_head
+  // may be written to rx_buffer_tail, making it appear as if the buffer
+  // don't reverse this or there may be problems if the RX interrupt
+  // occurs after reading the value of rx_buffer_head but before writing
+  // the value to rx_buffer_tail; the previous value of rx_buffer_head
+  // may be written to rx_buffer_tail, making it appear as if the buffer
+  // were full, not empty.
+  _rx_buffer->head = _rx_buffer->tail;
+}
+
+void MarlinSerial::write(uint8_t c)
+{
+  while (!((*_ucsra) & (1 << _udre)))
+    ;
+
+  *_udr = c;
+}
+
+void MarlinSerial::checkRx()
+{
+  if((UCSR0A & (1<<RXC0)) != 0) {
+    unsigned char c  =  UDR0;
+    store_char(c, &rx_buffer);
+  }
+}
+
+// Preinstantiate Objects //////////////////////////////////////////////////////
+
+#if defined(UBRR0H) && defined(UBRR0L)
+  MarlinSerial MSerial(&rx_buffer, &UBRR0H, &UBRR0L, &UCSR0A, &UCSR0B, &UDR0, RXEN0, TXEN0, RXCIE0, UDRE0, U2X0);
+#else
+  #error no serial port defined  (port 0)
+#endif
+
+
+#endif // whole file
+

diff --git a/Marlin/MarlinSerial.h b/Marlin/MarlinSerial.h
new file mode 100644 (file)
index 0000000..7945449
--- /dev/null
+++ b/Marlin/MarlinSerial.h
@@ -0,0 +1,66 @@
+/*
+  HardwareSerial.h - Hardware serial library for Wiring
+  Copyright (c) 2006 Nicholas Zambetti.  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
+
+  Modified 28 September 2010 by Mark Sproul
+*/
+
+#ifndef MarlinSerial_h
+#define MarlinSerial_h
+
+#include <inttypes.h>
+
+#include "Stream.h"
+
+struct ring_buffer;
+
+class MarlinSerial : public Stream
+{
+  private:
+    ring_buffer *_rx_buffer;
+    volatile uint8_t *_ubrrh;
+    volatile uint8_t *_ubrrl;
+    volatile uint8_t *_ucsra;
+    volatile uint8_t *_ucsrb;
+    volatile uint8_t *_udr;
+    uint8_t _rxen;
+    uint8_t _txen;
+    uint8_t _rxcie;
+    uint8_t _udre;
+    uint8_t _u2x;
+  public:
+    MarlinSerial(ring_buffer *rx_buffer,
+      volatile uint8_t *ubrrh, volatile uint8_t *ubrrl,
+      volatile uint8_t *ucsra, volatile uint8_t *ucsrb,
+      volatile uint8_t *udr,
+      uint8_t rxen, uint8_t txen, uint8_t rxcie, uint8_t udre, uint8_t u2x);
+    void begin(long);
+    void end();
+    virtual int available(void);
+    virtual int peek(void);
+    virtual int read(void);
+    virtual void flush(void);
+    virtual void write(uint8_t);
+    virtual void checkRx(void);
+    using Print::write; // pull in write(str) and write(buf, size) from Print
+};
+
+#if defined(UBRRH) || defined(UBRR0H)
+  extern MarlinSerial MSerial;
+#endif
+
+#endif

diff --git a/Marlin/Sd2Card.cpp b/Marlin/Sd2Card.cpp
index ab060c121ea012c7734d7208b9a3ee27585b4464..4ca641ef9bad6ded1455b33389a690288dfc481a 100644 (file)
--- a/Marlin/Sd2Card.cpp
+++ b/Marlin/Sd2Card.cpp
@@ -1,642 +1,643 @@
-/* Arduino Sd2Card Library\r
- * Copyright (C) 2009 by William Greiman\r
- *\r
- * This file is part of the Arduino Sd2Card Library\r
- *\r
- * This Library is free software: you can redistribute it and/or modify\r
- * it under the terms of the GNU General Public License as published by\r
- * the Free Software Foundation, either version 3 of the License, or\r
- * (at your option) any later version.\r
- *\r
- * This Library is distributed in the hope that it will be useful,\r
- * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
- * GNU General Public License for more details.\r
- *\r
- * You should have received a copy of the GNU General Public License\r
- * along with the Arduino Sd2Card Library.  If not, see\r
- * <http://www.gnu.org/licenses/>.\r
- */\r
-#if ARDUINO < 100\r
-#include <WProgram.h>\r
-#else  // ARDUINO\r
-#include <Arduino.h>\r
-#endif  // ARDUINO\r
-#include "Sd2Card.h"\r
-//------------------------------------------------------------------------------\r
-#ifndef SOFTWARE_SPI\r
-// functions for hardware SPI\r
-//------------------------------------------------------------------------------\r
-// make sure SPCR rate is in expected bits\r
-#if (SPR0 != 0 || SPR1 != 1)\r
-#error unexpected SPCR bits\r
-#endif\r
-/**\r
- * Initialize hardware SPI\r
- * Set SCK rate to F_CPU/pow(2, 1 + spiRate) for spiRate [0,6]\r
- */\r
-static void spiInit(uint8_t spiRate) {\r
-  // See avr processor documentation\r
-  SPCR = (1 << SPE) | (1 << MSTR) | (spiRate >> 1);\r
-  SPSR = spiRate & 1 || spiRate == 6 ? 0 : 1 << SPI2X;\r
-}\r
-//------------------------------------------------------------------------------\r
-/** SPI receive a byte */\r
-static uint8_t spiRec() {\r
-  SPDR = 0XFF;\r
-  while (!(SPSR & (1 << SPIF)));\r
-  return SPDR;\r
-}\r
-//------------------------------------------------------------------------------\r
-/** SPI read data - only one call so force inline */\r
-static inline __attribute__((always_inline))\r
-  void spiRead(uint8_t* buf, uint16_t nbyte) {\r
-  if (nbyte-- == 0) return;\r
-  SPDR = 0XFF;\r
-  for (uint16_t i = 0; i < nbyte; i++) {\r
-    while (!(SPSR & (1 << SPIF)));\r
-    buf[i] = SPDR;\r
-    SPDR = 0XFF;\r
-  }\r
-  while (!(SPSR & (1 << SPIF)));\r
-  buf[nbyte] = SPDR;\r
-}\r
-//------------------------------------------------------------------------------\r
-/** SPI send a byte */\r
-static void spiSend(uint8_t b) {\r
-  SPDR = b;\r
-  while (!(SPSR & (1 << SPIF)));\r
-}\r
-//------------------------------------------------------------------------------\r
-/** SPI send block - only one call so force inline */\r
-static inline __attribute__((always_inline))\r
-  void spiSendBlock(uint8_t token, const uint8_t* buf) {\r
-  SPDR = token;\r
-  for (uint16_t i = 0; i < 512; i += 2) {\r
-    while (!(SPSR & (1 << SPIF)));\r
-    SPDR = buf[i];\r
-    while (!(SPSR & (1 << SPIF)));\r
-    SPDR = buf[i + 1];\r
-  }\r
-  while (!(SPSR & (1 << SPIF)));\r
-}\r
-//------------------------------------------------------------------------------\r
-#else  // SOFTWARE_SPI\r
-//------------------------------------------------------------------------------\r
-/** nop to tune soft SPI timing */\r
-#define nop asm volatile ("nop\n\t")\r
-//------------------------------------------------------------------------------\r
-/** Soft SPI receive byte */\r
-static uint8_t spiRec() {\r
-  uint8_t data = 0;\r
-  // no interrupts during byte receive - about 8 us\r
-  cli();\r
-  // output pin high - like sending 0XFF\r
-  fastDigitalWrite(SPI_MOSI_PIN, HIGH);\r
-\r
-  for (uint8_t i = 0; i < 8; i++) {\r
-    fastDigitalWrite(SPI_SCK_PIN, HIGH);\r
-\r
-    // adjust so SCK is nice\r
-    nop;\r
-    nop;\r
-\r
-    data <<= 1;\r
-\r
-    if (fastDigitalRead(SPI_MISO_PIN)) data |= 1;\r
-\r
-    fastDigitalWrite(SPI_SCK_PIN, LOW);\r
-  }\r
-  // enable interrupts\r
-  sei();\r
-  return data;\r
-}\r
-//------------------------------------------------------------------------------\r
-/** Soft SPI read data */\r
-static void spiRead(uint8_t* buf, uint16_t nbyte) {\r
-  for (uint16_t i = 0; i < nbyte; i++) {\r
-    buf[i] = spiRec();\r
-  }\r
-}\r
-//------------------------------------------------------------------------------\r
-/** Soft SPI send byte */\r
-static void spiSend(uint8_t data) {\r
-  // no interrupts during byte send - about 8 us\r
-  cli();\r
-  for (uint8_t i = 0; i < 8; i++) {\r
-    fastDigitalWrite(SPI_SCK_PIN, LOW);\r
-\r
-    fastDigitalWrite(SPI_MOSI_PIN, data & 0X80);\r
-\r
-    data <<= 1;\r
-\r
-    fastDigitalWrite(SPI_SCK_PIN, HIGH);\r
-  }\r
-  // hold SCK high for a few ns\r
-  nop;\r
-  nop;\r
-  nop;\r
-  nop;\r
-\r
-  fastDigitalWrite(SPI_SCK_PIN, LOW);\r
-  // enable interrupts\r
-  sei();\r
-}\r
-//------------------------------------------------------------------------------\r
-/** Soft SPI send block */\r
-  void spiSendBlock(uint8_t token, const uint8_t* buf) {\r
-  spiSend(token);\r
-  for (uint16_t i = 0; i < 512; i++) {\r
-    spiSend(buf[i]);\r
-  }\r
-}\r
-#endif  // SOFTWARE_SPI\r
-//------------------------------------------------------------------------------\r
-// send command and return error code.  Return zero for OK\r
-uint8_t Sd2Card::cardCommand(uint8_t cmd, uint32_t arg) {\r
-  // select card\r
-  chipSelectLow();\r
-\r
-  // wait up to 300 ms if busy\r
-  waitNotBusy(300);\r
-\r
-  // send command\r
-  spiSend(cmd | 0x40);\r
-\r
-  // send argument\r
-  for (int8_t s = 24; s >= 0; s -= 8) spiSend(arg >> s);\r
-\r
-  // send CRC\r
-  uint8_t crc = 0XFF;\r
-  if (cmd == CMD0) crc = 0X95;  // correct crc for CMD0 with arg 0\r
-  if (cmd == CMD8) crc = 0X87;  // correct crc for CMD8 with arg 0X1AA\r
-  spiSend(crc);\r
-\r
-  // skip stuff byte for stop read\r
-  if (cmd == CMD12) spiRec();\r
-\r
-  // wait for response\r
-  for (uint8_t i = 0; ((status_ = spiRec()) & 0X80) && i != 0XFF; i++);\r
-  return status_;\r
-}\r
-//------------------------------------------------------------------------------\r
-/**\r
- * Determine the size of an SD flash memory card.\r
- *\r
- * \return The number of 512 byte data blocks in the card\r
- *         or zero if an error occurs.\r
- */\r
-uint32_t Sd2Card::cardSize() {\r
-  csd_t csd;\r
-  if (!readCSD(&csd)) return 0;\r
-  if (csd.v1.csd_ver == 0) {\r
-    uint8_t read_bl_len = csd.v1.read_bl_len;\r
-    uint16_t c_size = (csd.v1.c_size_high << 10)\r
-                      | (csd.v1.c_size_mid << 2) | csd.v1.c_size_low;\r
-    uint8_t c_size_mult = (csd.v1.c_size_mult_high << 1)\r
-                          | csd.v1.c_size_mult_low;\r
-    return (uint32_t)(c_size + 1) << (c_size_mult + read_bl_len - 7);\r
-  } else if (csd.v2.csd_ver == 1) {\r
-    uint32_t c_size = ((uint32_t)csd.v2.c_size_high << 16)\r
-                      | (csd.v2.c_size_mid << 8) | csd.v2.c_size_low;\r
-    return (c_size + 1) << 10;\r
-  } else {\r
-    error(SD_CARD_ERROR_BAD_CSD);\r
-    return 0;\r
-  }\r
-}\r
-//------------------------------------------------------------------------------\r
-void Sd2Card::chipSelectHigh() {\r
-  digitalWrite(chipSelectPin_, HIGH);\r
-}\r
-//------------------------------------------------------------------------------\r
-void Sd2Card::chipSelectLow() {\r
-#ifndef SOFTWARE_SPI\r
-  spiInit(spiRate_);\r
-#endif  // SOFTWARE_SPI\r
-  digitalWrite(chipSelectPin_, LOW);\r
-}\r
-//------------------------------------------------------------------------------\r
-/** Erase a range of blocks.\r
- *\r
- * \param[in] firstBlock The address of the first block in the range.\r
- * \param[in] lastBlock The address of the last block in the range.\r
- *\r
- * \note This function requests the SD card to do a flash erase for a\r
- * range of blocks.  The data on the card after an erase operation is\r
- * either 0 or 1, depends on the card vendor.  The card must support\r
- * single block erase.\r
- *\r
- * \return The value one, true, is returned for success and\r
- * the value zero, false, is returned for failure.\r
- */\r
-bool Sd2Card::erase(uint32_t firstBlock, uint32_t lastBlock) {\r
-  csd_t csd;\r
-  if (!readCSD(&csd)) goto fail;\r
-  // check for single block erase\r
-  if (!csd.v1.erase_blk_en) {\r
-    // erase size mask\r
-    uint8_t m = (csd.v1.sector_size_high << 1) | csd.v1.sector_size_low;\r
-    if ((firstBlock & m) != 0 || ((lastBlock + 1) & m) != 0) {\r
-      // error card can't erase specified area\r
-      error(SD_CARD_ERROR_ERASE_SINGLE_BLOCK);\r
-      goto fail;\r
-    }\r
-  }\r
-  if (type_ != SD_CARD_TYPE_SDHC) {\r
-    firstBlock <<= 9;\r
-    lastBlock <<= 9;\r
-  }\r
-  if (cardCommand(CMD32, firstBlock)\r
-    || cardCommand(CMD33, lastBlock)\r
-    || cardCommand(CMD38, 0)) {\r
-      error(SD_CARD_ERROR_ERASE);\r
-      goto fail;\r
-  }\r
-  if (!waitNotBusy(SD_ERASE_TIMEOUT)) {\r
-    error(SD_CARD_ERROR_ERASE_TIMEOUT);\r
-    goto fail;\r
-  }\r
-  chipSelectHigh();\r
-  return true;\r
-\r
- fail:\r
-  chipSelectHigh();\r
-  return false;\r
-}\r
-//------------------------------------------------------------------------------\r
-/** Determine if card supports single block erase.\r
- *\r
- * \return The value one, true, is returned if single block erase is supported.\r
- * The value zero, false, is returned if single block erase is not supported.\r
- */\r
-bool Sd2Card::eraseSingleBlockEnable() {\r
-  csd_t csd;\r
-  return readCSD(&csd) ? csd.v1.erase_blk_en : false;\r
-}\r
-//------------------------------------------------------------------------------\r
-/**\r
- * Initialize an SD flash memory card.\r
- *\r
- * \param[in] sckRateID SPI clock rate selector. See setSckRate().\r
- * \param[in] chipSelectPin SD chip select pin number.\r
- *\r
- * \return The value one, true, is returned for success and\r
- * the value zero, false, is returned for failure.  The reason for failure\r
- * can be determined by calling errorCode() and errorData().\r
- */\r
-bool Sd2Card::init(uint8_t sckRateID, uint8_t chipSelectPin) {\r
-  errorCode_ = type_ = 0;\r
-  chipSelectPin_ = chipSelectPin;\r
-  // 16-bit init start time allows over a minute\r
-  uint16_t t0 = (uint16_t)millis();\r
-  uint32_t arg;\r
-\r
-  // set pin modes\r
-  pinMode(chipSelectPin_, OUTPUT);\r
-  chipSelectHigh();\r
-  pinMode(SPI_MISO_PIN, INPUT);\r
-  pinMode(SPI_MOSI_PIN, OUTPUT);\r
-  pinMode(SPI_SCK_PIN, OUTPUT);\r
-\r
-#ifndef SOFTWARE_SPI\r
-  // SS must be in output mode even it is not chip select\r
-  pinMode(SS_PIN, OUTPUT);\r
-  // set SS high - may be chip select for another SPI device\r
-#if SET_SPI_SS_HIGH\r
-  digitalWrite(SS_PIN, HIGH);\r
-#endif  // SET_SPI_SS_HIGH\r
-  // set SCK rate for initialization commands\r
-  spiRate_ = SPI_SD_INIT_RATE;\r
-  spiInit(spiRate_);\r
-#endif  // SOFTWARE_SPI\r
-\r
-  // must supply min of 74 clock cycles with CS high.\r
-  for (uint8_t i = 0; i < 10; i++) spiSend(0XFF);\r
-\r
-  // command to go idle in SPI mode\r
-  while ((status_ = cardCommand(CMD0, 0)) != R1_IDLE_STATE) {\r
-    if (((uint16_t)millis() - t0) > SD_INIT_TIMEOUT) {\r
-      error(SD_CARD_ERROR_CMD0);\r
-      goto fail;\r
-    }\r
-  }\r
-  // check SD version\r
-  if ((cardCommand(CMD8, 0x1AA) & R1_ILLEGAL_COMMAND)) {\r
-    type(SD_CARD_TYPE_SD1);\r
-  } else {\r
-    // only need last byte of r7 response\r
-    for (uint8_t i = 0; i < 4; i++) status_ = spiRec();\r
-    if (status_ != 0XAA) {\r
-      error(SD_CARD_ERROR_CMD8);\r
-      goto fail;\r
-    }\r
-    type(SD_CARD_TYPE_SD2);\r
-  }\r
-  // initialize card and send host supports SDHC if SD2\r
-  arg = type() == SD_CARD_TYPE_SD2 ? 0X40000000 : 0;\r
-\r
-  while ((status_ = cardAcmd(ACMD41, arg)) != R1_READY_STATE) {\r
-    // check for timeout\r
-    if (((uint16_t)millis() - t0) > SD_INIT_TIMEOUT) {\r
-      error(SD_CARD_ERROR_ACMD41);\r
-      goto fail;\r
-    }\r
-  }\r
-  // if SD2 read OCR register to check for SDHC card\r
-  if (type() == SD_CARD_TYPE_SD2) {\r
-    if (cardCommand(CMD58, 0)) {\r
-      error(SD_CARD_ERROR_CMD58);\r
-      goto fail;\r
-    }\r
-    if ((spiRec() & 0XC0) == 0XC0) type(SD_CARD_TYPE_SDHC);\r
-    // discard rest of ocr - contains allowed voltage range\r
-    for (uint8_t i = 0; i < 3; i++) spiRec();\r
-  }\r
-  chipSelectHigh();\r
-\r
-#ifndef SOFTWARE_SPI\r
-  return setSckRate(sckRateID);\r
-#else  // SOFTWARE_SPI\r
-  return true;\r
-#endif  // SOFTWARE_SPI\r
-\r
- fail:\r
-  chipSelectHigh();\r
-  return false;\r
-}\r
-//------------------------------------------------------------------------------\r
-/**\r
- * Read a 512 byte block from an SD card.\r
- *\r
- * \param[in] blockNumber Logical block to be read.\r
- * \param[out] dst Pointer to the location that will receive the data.\r
-\r
- * \return The value one, true, is returned for success and\r
- * the value zero, false, is returned for failure.\r
- */\r
-bool Sd2Card::readBlock(uint32_t blockNumber, uint8_t* dst) {\r
-  // use address if not SDHC card\r
-  if (type()!= SD_CARD_TYPE_SDHC) blockNumber <<= 9;\r
-  if (cardCommand(CMD17, blockNumber)) {\r
-    error(SD_CARD_ERROR_CMD17);\r
-    goto fail;\r
-  }\r
-  return readData(dst, 512);\r
-\r
- fail:\r
-  chipSelectHigh();\r
-  return false;\r
-}\r
-//------------------------------------------------------------------------------\r
-/** Read one data block in a multiple block read sequence\r
- *\r
- * \param[in] dst Pointer to the location for the data to be read.\r
- *\r
- * \return The value one, true, is returned for success and\r
- * the value zero, false, is returned for failure.\r
- */\r
-bool Sd2Card::readData(uint8_t *dst) {\r
-  chipSelectLow();\r
-  return readData(dst, 512);\r
-}\r
-//------------------------------------------------------------------------------\r
-bool Sd2Card::readData(uint8_t* dst, uint16_t count) {\r
-  // wait for start block token\r
-  uint16_t t0 = millis();\r
-  while ((status_ = spiRec()) == 0XFF) {\r
-    if (((uint16_t)millis() - t0) > SD_READ_TIMEOUT) {\r
-      error(SD_CARD_ERROR_READ_TIMEOUT);\r
-      goto fail;\r
-    }\r
-  }\r
-  if (status_ != DATA_START_BLOCK) {\r
-    error(SD_CARD_ERROR_READ);\r
-    goto fail;\r
-  }\r
-  // transfer data\r
-  spiRead(dst, count);\r
-\r
-  // discard CRC\r
-  spiRec();\r
-  spiRec();\r
-  chipSelectHigh();\r
-  return true;\r
-\r
- fail:\r
-  chipSelectHigh();\r
-  return false;\r
-}\r
-//------------------------------------------------------------------------------\r
-/** read CID or CSR register */\r
-bool Sd2Card::readRegister(uint8_t cmd, void* buf) {\r
-  uint8_t* dst = reinterpret_cast<uint8_t*>(buf);\r
-  if (cardCommand(cmd, 0)) {\r
-    error(SD_CARD_ERROR_READ_REG);\r
-    goto fail;\r
-  }\r
-  return readData(dst, 16);\r
-\r
- fail:\r
-  chipSelectHigh();\r
-  return false;\r
-}\r
-//------------------------------------------------------------------------------\r
-/** Start a read multiple blocks sequence.\r
- *\r
- * \param[in] blockNumber Address of first block in sequence.\r
- *\r
- * \note This function is used with readData() and readStop() for optimized\r
- * multiple block reads.  SPI chipSelect must be low for the entire sequence.\r
- *\r
- * \return The value one, true, is returned for success and\r
- * the value zero, false, is returned for failure.\r
- */\r
-bool Sd2Card::readStart(uint32_t blockNumber) {\r
-  if (type()!= SD_CARD_TYPE_SDHC) blockNumber <<= 9;\r
-  if (cardCommand(CMD18, blockNumber)) {\r
-    error(SD_CARD_ERROR_CMD18);\r
-    goto fail;\r
-  }\r
-  chipSelectHigh();\r
-  return true;\r
-\r
- fail:\r
-  chipSelectHigh();\r
-  return false;\r
-}\r
-//------------------------------------------------------------------------------\r
-/** End a read multiple blocks sequence.\r
- *\r
-* \return The value one, true, is returned for success and\r
- * the value zero, false, is returned for failure.\r
- */\r
-bool Sd2Card::readStop() {\r
-  chipSelectLow();\r
-  if (cardCommand(CMD12, 0)) {\r
-    error(SD_CARD_ERROR_CMD12);\r
-    goto fail;\r
-  }\r
-  chipSelectHigh();\r
-  return true;\r
-\r
- fail:\r
-  chipSelectHigh();\r
-  return false;\r
-}\r
-//------------------------------------------------------------------------------\r
-/**\r
- * Set the SPI clock rate.\r
- *\r
- * \param[in] sckRateID A value in the range [0, 6].\r
- *\r
- * The SPI clock will be set to F_CPU/pow(2, 1 + sckRateID). The maximum\r
- * SPI rate is F_CPU/2 for \a sckRateID = 0 and the minimum rate is F_CPU/128\r
- * for \a scsRateID = 6.\r
- *\r
- * \return The value one, true, is returned for success and the value zero,\r
- * false, is returned for an invalid value of \a sckRateID.\r
- */\r
-bool Sd2Card::setSckRate(uint8_t sckRateID) {\r
-  if (sckRateID > 6) {\r
-    error(SD_CARD_ERROR_SCK_RATE);\r
-    return false;\r
-  }\r
-  spiRate_ = sckRateID;\r
-  return true;\r
-}\r
-//------------------------------------------------------------------------------\r
-// wait for card to go not busy\r
-bool Sd2Card::waitNotBusy(uint16_t timeoutMillis) {\r
-  uint16_t t0 = millis();\r
-  while (spiRec() != 0XFF) {\r
-    if (((uint16_t)millis() - t0) >= timeoutMillis) goto fail;\r
-  }\r
-  return true;\r
-\r
- fail:\r
-  return false;\r
-}\r
-//------------------------------------------------------------------------------\r
-/**\r
- * Writes a 512 byte block to an SD card.\r
- *\r
- * \param[in] blockNumber Logical block to be written.\r
- * \param[in] src Pointer to the location of the data to be written.\r
- * \return The value one, true, is returned for success and\r
- * the value zero, false, is returned for failure.\r
- */\r
-bool Sd2Card::writeBlock(uint32_t blockNumber, const uint8_t* src) {\r
-  // use address if not SDHC card\r
-  if (type() != SD_CARD_TYPE_SDHC) blockNumber <<= 9;\r
-  if (cardCommand(CMD24, blockNumber)) {\r
-    error(SD_CARD_ERROR_CMD24);\r
-    goto fail;\r
-  }\r
-  if (!writeData(DATA_START_BLOCK, src)) goto fail;\r
-\r
-  // wait for flash programming to complete\r
-  if (!waitNotBusy(SD_WRITE_TIMEOUT)) {\r
-    error(SD_CARD_ERROR_WRITE_TIMEOUT);\r
-    goto fail;\r
-  }\r
-  // response is r2 so get and check two bytes for nonzero\r
-  if (cardCommand(CMD13, 0) || spiRec()) {\r
-    error(SD_CARD_ERROR_WRITE_PROGRAMMING);\r
-    goto fail;\r
-  }\r
-  chipSelectHigh();\r
-  return true;\r
-\r
- fail:\r
-  chipSelectHigh();\r
-  return false;\r
-}\r
-//------------------------------------------------------------------------------\r
-/** Write one data block in a multiple block write sequence\r
- * \param[in] src Pointer to the location of the data to be written.\r
- * \return The value one, true, is returned for success and\r
- * the value zero, false, is returned for failure.\r
- */\r
-bool Sd2Card::writeData(const uint8_t* src) {\r
-  chipSelectLow();\r
-  // wait for previous write to finish\r
-  if (!waitNotBusy(SD_WRITE_TIMEOUT)) goto fail;\r
-  if (!writeData(WRITE_MULTIPLE_TOKEN, src)) goto fail;\r
-  chipSelectHigh();\r
-  return true;\r
-\r
- fail:\r
-  error(SD_CARD_ERROR_WRITE_MULTIPLE);\r
-  chipSelectHigh();\r
-  return false;\r
-}\r
-//------------------------------------------------------------------------------\r
-// send one block of data for write block or write multiple blocks\r
-bool Sd2Card::writeData(uint8_t token, const uint8_t* src) {\r
-  spiSendBlock(token, src);\r
-\r
-  spiSend(0xff);  // dummy crc\r
-  spiSend(0xff);  // dummy crc\r
-\r
-  status_ = spiRec();\r
-  if ((status_ & DATA_RES_MASK) != DATA_RES_ACCEPTED) {\r
-    error(SD_CARD_ERROR_WRITE);\r
-    goto fail;\r
-  }\r
-  return true;\r
-\r
- fail:\r
-  chipSelectHigh();\r
-  return false;\r
-}\r
-//------------------------------------------------------------------------------\r
-/** Start a write multiple blocks sequence.\r
- *\r
- * \param[in] blockNumber Address of first block in sequence.\r
- * \param[in] eraseCount The number of blocks to be pre-erased.\r
- *\r
- * \note This function is used with writeData() and writeStop()\r
- * for optimized multiple block writes.\r
- *\r
- * \return The value one, true, is returned for success and\r
- * the value zero, false, is returned for failure.\r
- */\r
-bool Sd2Card::writeStart(uint32_t blockNumber, uint32_t eraseCount) {\r
-  // send pre-erase count\r
-  if (cardAcmd(ACMD23, eraseCount)) {\r
-    error(SD_CARD_ERROR_ACMD23);\r
-    goto fail;\r
-  }\r
-  // use address if not SDHC card\r
-  if (type() != SD_CARD_TYPE_SDHC) blockNumber <<= 9;\r
-  if (cardCommand(CMD25, blockNumber)) {\r
-    error(SD_CARD_ERROR_CMD25);\r
-    goto fail;\r
-  }\r
-  chipSelectHigh();\r
-  return true;\r
-\r
- fail:\r
-  chipSelectHigh();\r
-  return false;\r
-}\r
-//------------------------------------------------------------------------------\r
-/** End a write multiple blocks sequence.\r
- *\r
-* \return The value one, true, is returned for success and\r
- * the value zero, false, is returned for failure.\r
- */\r
-bool Sd2Card::writeStop() {\r
-  chipSelectLow();\r
-  if (!waitNotBusy(SD_WRITE_TIMEOUT)) goto fail;\r
-  spiSend(STOP_TRAN_TOKEN);\r
-  if (!waitNotBusy(SD_WRITE_TIMEOUT)) goto fail;\r
-  chipSelectHigh();\r
-  return true;\r
-\r
- fail:\r
-  error(SD_CARD_ERROR_STOP_TRAN);\r
-  chipSelectHigh();\r
-  return false;\r
+/* Arduino Sd2Card Library
+ * Copyright (C) 2009 by William Greiman
+ *
+ * This file is part of the Arduino Sd2Card Library
+ *
+ * This Library 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 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with the Arduino Sd2Card Library.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+#if ARDUINO < 100
+#define  HardwareSerial_h // trick to disable the standard HWserial
+#include <WProgram.h>
+#else  // ARDUINO
+#include <Arduino.h>
+#endif  // ARDUINO
+#include "Sd2Card.h"
+//------------------------------------------------------------------------------
+#ifndef 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 = (1 << SPE) | (1 << MSTR) | (spiRate >> 1);
+  SPSR = spiRate & 1 || spiRate == 6 ? 0 : 1 << SPI2X;
+}
+//------------------------------------------------------------------------------
+/** SPI receive a byte */
+static uint8_t spiRec() {
+  SPDR = 0XFF;
+  while (!(SPSR & (1 << SPIF)));
+  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 (!(SPSR & (1 << SPIF)));
+    buf[i] = SPDR;
+    SPDR = 0XFF;
+  }
+  while (!(SPSR & (1 << SPIF)));
+  buf[nbyte] = SPDR;
+}
+//------------------------------------------------------------------------------
+/** SPI send a byte */
+static void spiSend(uint8_t b) {
+  SPDR = b;
+  while (!(SPSR & (1 << SPIF)));
+}
+//------------------------------------------------------------------------------
+/** 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 (!(SPSR & (1 << SPIF)));
+    SPDR = buf[i];
+    while (!(SPSR & (1 << SPIF)));
+    SPDR = buf[i + 1];
+  }
+  while (!(SPSR & (1 << SPIF)));
+}
+//------------------------------------------------------------------------------
+#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
+  fastDigitalWrite(SPI_MOSI_PIN, HIGH);
+
+  for (uint8_t i = 0; i < 8; i++) {
+    fastDigitalWrite(SPI_SCK_PIN, HIGH);
+
+    // adjust so SCK is nice
+    nop;
+    nop;
+
+    data <<= 1;
+
+    if (fastDigitalRead(SPI_MISO_PIN)) data |= 1;
+
+    fastDigitalWrite(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++) {
+    fastDigitalWrite(SPI_SCK_PIN, LOW);
+
+    fastDigitalWrite(SPI_MOSI_PIN, data & 0X80);
+
+    data <<= 1;
+
+    fastDigitalWrite(SPI_SCK_PIN, HIGH);
+  }
+  // hold SCK high for a few ns
+  nop;
+  nop;
+  nop;
+  nop;
+
+  fastDigitalWrite(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) {
+  // select card
+  chipSelectLow();
+
+  // wait up to 300 ms if busy
+  waitNotBusy(300);
+
+  // send command
+  spiSend(cmd | 0x40);
+
+  // send argument
+  for (int8_t s = 24; s >= 0; s -= 8) spiSend(arg >> s);
+
+  // send CRC
+  uint8_t crc = 0XFF;
+  if (cmd == CMD0) crc = 0X95;  // correct crc for CMD0 with arg 0
+  if (cmd == CMD8) crc = 0X87;  // correct crc for CMD8 with arg 0X1AA
+  spiSend(crc);
+
+  // skip stuff byte for stop read
+  if (cmd == CMD12) spiRec();
+
+  // wait for response
+  for (uint8_t i = 0; ((status_ = spiRec()) & 0X80) && i != 0XFF; i++);
+  return status_;
+}
+//------------------------------------------------------------------------------
+/**
+ * Determine the size of an SD flash memory card.
+ *
+ * \return The number of 512 byte data blocks in the card
+ *         or zero if an error occurs.
+ */
+uint32_t Sd2Card::cardSize() {
+  csd_t csd;
+  if (!readCSD(&csd)) return 0;
+  if (csd.v1.csd_ver == 0) {
+    uint8_t read_bl_len = csd.v1.read_bl_len;
+    uint16_t c_size = (csd.v1.c_size_high << 10)
+                      | (csd.v1.c_size_mid << 2) | csd.v1.c_size_low;
+    uint8_t c_size_mult = (csd.v1.c_size_mult_high << 1)
+                          | csd.v1.c_size_mult_low;
+    return (uint32_t)(c_size + 1) << (c_size_mult + read_bl_len - 7);
+  } else if (csd.v2.csd_ver == 1) {
+    uint32_t c_size = ((uint32_t)csd.v2.c_size_high << 16)
+                      | (csd.v2.c_size_mid << 8) | csd.v2.c_size_low;
+    return (c_size + 1) << 10;
+  } else {
+    error(SD_CARD_ERROR_BAD_CSD);
+    return 0;
+  }
+}
+//------------------------------------------------------------------------------
+void Sd2Card::chipSelectHigh() {
+  digitalWrite(chipSelectPin_, HIGH);
+}
+//------------------------------------------------------------------------------
+void Sd2Card::chipSelectLow() {
+#ifndef SOFTWARE_SPI
+  spiInit(spiRate_);
+#endif  // SOFTWARE_SPI
+  digitalWrite(chipSelectPin_, LOW);
+}
+//------------------------------------------------------------------------------
+/** Erase a range of blocks.
+ *
+ * \param[in] firstBlock The address of the first block in the range.
+ * \param[in] lastBlock The address of the last block in the range.
+ *
+ * \note This function requests the SD card to do a flash erase for a
+ * range of blocks.  The data on the card after an erase operation is
+ * either 0 or 1, depends on the card vendor.  The card must support
+ * single block erase.
+ *
+ * \return The value one, true, is returned for success and
+ * the value zero, false, is returned for failure.
+ */
+bool Sd2Card::erase(uint32_t firstBlock, uint32_t lastBlock) {
+  csd_t csd;
+  if (!readCSD(&csd)) goto fail;
+  // check for single block erase
+  if (!csd.v1.erase_blk_en) {
+    // erase size mask
+    uint8_t m = (csd.v1.sector_size_high << 1) | csd.v1.sector_size_low;
+    if ((firstBlock & m) != 0 || ((lastBlock + 1) & m) != 0) {
+      // error card can't erase specified area
+      error(SD_CARD_ERROR_ERASE_SINGLE_BLOCK);
+      goto fail;
+    }
+  }
+  if (type_ != SD_CARD_TYPE_SDHC) {
+    firstBlock <<= 9;
+    lastBlock <<= 9;
+  }
+  if (cardCommand(CMD32, firstBlock)
+    || cardCommand(CMD33, lastBlock)
+    || cardCommand(CMD38, 0)) {
+      error(SD_CARD_ERROR_ERASE);
+      goto fail;
+  }
+  if (!waitNotBusy(SD_ERASE_TIMEOUT)) {
+    error(SD_CARD_ERROR_ERASE_TIMEOUT);
+    goto fail;
+  }
+  chipSelectHigh();
+  return true;
+
+ fail:
+  chipSelectHigh();
+  return false;
+}
+//------------------------------------------------------------------------------
+/** Determine if card supports single block erase.
+ *
+ * \return The value one, true, is returned if single block erase is supported.
+ * The value zero, false, is returned if single block erase is not supported.
+ */
+bool Sd2Card::eraseSingleBlockEnable() {
+  csd_t csd;
+  return readCSD(&csd) ? csd.v1.erase_blk_en : false;
+}
+//------------------------------------------------------------------------------
+/**
+ * Initialize an SD flash memory card.
+ *
+ * \param[in] sckRateID SPI clock rate selector. See setSckRate().
+ * \param[in] chipSelectPin SD chip select pin number.
+ *
+ * \return The value one, true, is returned for success and
+ * the value zero, false, is returned for failure.  The reason for failure
+ * can be determined by calling errorCode() and errorData().
+ */
+bool Sd2Card::init(uint8_t sckRateID, uint8_t chipSelectPin) {
+  errorCode_ = type_ = 0;
+  chipSelectPin_ = chipSelectPin;
+  // 16-bit init start time allows over a minute
+  uint16_t t0 = (uint16_t)millis();
+  uint32_t arg;
+
+  // set pin modes
+  pinMode(chipSelectPin_, OUTPUT);
+  chipSelectHigh();
+  pinMode(SPI_MISO_PIN, INPUT);
+  pinMode(SPI_MOSI_PIN, OUTPUT);
+  pinMode(SPI_SCK_PIN, OUTPUT);
+
+#ifndef SOFTWARE_SPI
+  // SS must be in output mode even it is not chip select
+  pinMode(SS_PIN, OUTPUT);
+  // set SS high - may be chip select for another SPI device
+#if SET_SPI_SS_HIGH
+  digitalWrite(SS_PIN, HIGH);
+#endif  // SET_SPI_SS_HIGH
+  // set SCK rate for initialization commands
+  spiRate_ = SPI_SD_INIT_RATE;
+  spiInit(spiRate_);
+#endif  // SOFTWARE_SPI
+
+  // must supply min of 74 clock cycles with CS high.
+  for (uint8_t i = 0; i < 10; i++) spiSend(0XFF);
+
+  // command to go idle in SPI mode
+  while ((status_ = cardCommand(CMD0, 0)) != R1_IDLE_STATE) {
+    if (((uint16_t)millis() - t0) > SD_INIT_TIMEOUT) {
+      error(SD_CARD_ERROR_CMD0);
+      goto fail;
+    }
+  }
+  // check SD version
+  if ((cardCommand(CMD8, 0x1AA) & R1_ILLEGAL_COMMAND)) {
+    type(SD_CARD_TYPE_SD1);
+  } else {
+    // only need last byte of r7 response
+    for (uint8_t i = 0; i < 4; i++) status_ = spiRec();
+    if (status_ != 0XAA) {
+      error(SD_CARD_ERROR_CMD8);
+      goto fail;
+    }
+    type(SD_CARD_TYPE_SD2);
+  }
+  // initialize card and send host supports SDHC if SD2
+  arg = type() == SD_CARD_TYPE_SD2 ? 0X40000000 : 0;
+
+  while ((status_ = cardAcmd(ACMD41, arg)) != R1_READY_STATE) {
+    // check for timeout
+    if (((uint16_t)millis() - t0) > SD_INIT_TIMEOUT) {
+      error(SD_CARD_ERROR_ACMD41);
+      goto fail;
+    }
+  }
+  // if SD2 read OCR register to check for SDHC card
+  if (type() == SD_CARD_TYPE_SD2) {
+    if (cardCommand(CMD58, 0)) {
+      error(SD_CARD_ERROR_CMD58);
+      goto fail;
+    }
+    if ((spiRec() & 0XC0) == 0XC0) type(SD_CARD_TYPE_SDHC);
+    // discard rest of ocr - contains allowed voltage range
+    for (uint8_t i = 0; i < 3; i++) spiRec();
+  }
+  chipSelectHigh();
+
+#ifndef SOFTWARE_SPI
+  return setSckRate(sckRateID);
+#else  // SOFTWARE_SPI
+  return true;
+#endif  // SOFTWARE_SPI
+
+ fail:
+  chipSelectHigh();
+  return false;
+}
+//------------------------------------------------------------------------------
+/**
+ * Read a 512 byte block from an SD card.
+ *
+ * \param[in] blockNumber Logical block to be read.
+ * \param[out] dst Pointer to the location that will receive the data.
+
+ * \return The value one, true, is returned for success and
+ * the value zero, false, is returned for failure.
+ */
+bool Sd2Card::readBlock(uint32_t blockNumber, uint8_t* dst) {
+  // use address if not SDHC card
+  if (type()!= SD_CARD_TYPE_SDHC) blockNumber <<= 9;
+  if (cardCommand(CMD17, blockNumber)) {
+    error(SD_CARD_ERROR_CMD17);
+    goto fail;
+  }
+  return readData(dst, 512);
+
+ fail:
+  chipSelectHigh();
+  return false;
+}
+//------------------------------------------------------------------------------
+/** Read one data block in a multiple block read sequence
+ *
+ * \param[in] dst Pointer to the location for the data to be read.
+ *
+ * \return The value one, true, is returned for success and
+ * the value zero, false, is returned for failure.
+ */
+bool Sd2Card::readData(uint8_t *dst) {
+  chipSelectLow();
+  return readData(dst, 512);
+}
+//------------------------------------------------------------------------------
+bool Sd2Card::readData(uint8_t* dst, uint16_t count) {
+  // wait for start block token
+  uint16_t t0 = millis();
+  while ((status_ = spiRec()) == 0XFF) {
+    if (((uint16_t)millis() - t0) > SD_READ_TIMEOUT) {
+      error(SD_CARD_ERROR_READ_TIMEOUT);
+      goto fail;
+    }
+  }
+  if (status_ != DATA_START_BLOCK) {
+    error(SD_CARD_ERROR_READ);
+    goto fail;
+  }
+  // transfer data
+  spiRead(dst, count);
+
+  // discard CRC
+  spiRec();
+  spiRec();
+  chipSelectHigh();
+  return true;
+
+ fail:
+  chipSelectHigh();
+  return false;
+}
+//------------------------------------------------------------------------------
+/** read CID or CSR register */
+bool Sd2Card::readRegister(uint8_t cmd, void* buf) {
+  uint8_t* dst = reinterpret_cast<uint8_t*>(buf);
+  if (cardCommand(cmd, 0)) {
+    error(SD_CARD_ERROR_READ_REG);
+    goto fail;
+  }
+  return readData(dst, 16);
+
+ fail:
+  chipSelectHigh();
+  return false;
+}
+//------------------------------------------------------------------------------
+/** Start a read multiple blocks sequence.
+ *
+ * \param[in] blockNumber Address of first block in sequence.
+ *
+ * \note This function is used with readData() and readStop() for optimized
+ * multiple block reads.  SPI chipSelect must be low for the entire sequence.
+ *
+ * \return The value one, true, is returned for success and
+ * the value zero, false, is returned for failure.
+ */
+bool Sd2Card::readStart(uint32_t blockNumber) {
+  if (type()!= SD_CARD_TYPE_SDHC) blockNumber <<= 9;
+  if (cardCommand(CMD18, blockNumber)) {
+    error(SD_CARD_ERROR_CMD18);
+    goto fail;
+  }
+  chipSelectHigh();
+  return true;
+
+ fail:
+  chipSelectHigh();
+  return false;
+}
+//------------------------------------------------------------------------------
+/** End a read multiple blocks sequence.
+ *
+* \return The value one, true, is returned for success and
+ * the value zero, false, is returned for failure.
+ */
+bool Sd2Card::readStop() {
+  chipSelectLow();
+  if (cardCommand(CMD12, 0)) {
+    error(SD_CARD_ERROR_CMD12);
+    goto fail;
+  }
+  chipSelectHigh();
+  return true;
+
+ fail:
+  chipSelectHigh();
+  return false;
+}
+//------------------------------------------------------------------------------
+/**
+ * Set the SPI clock rate.
+ *
+ * \param[in] sckRateID A value in the range [0, 6].
+ *
+ * The SPI clock will be set to F_CPU/pow(2, 1 + sckRateID). The maximum
+ * SPI rate is F_CPU/2 for \a sckRateID = 0 and the minimum rate is F_CPU/128
+ * for \a scsRateID = 6.
+ *
+ * \return The value one, true, is returned for success and the value zero,
+ * false, is returned for an invalid value of \a sckRateID.
+ */
+bool Sd2Card::setSckRate(uint8_t sckRateID) {
+  if (sckRateID > 6) {
+    error(SD_CARD_ERROR_SCK_RATE);
+    return false;
+  }
+  spiRate_ = sckRateID;
+  return true;
+}
+//------------------------------------------------------------------------------
+// wait for card to go not busy
+bool Sd2Card::waitNotBusy(uint16_t timeoutMillis) {
+  uint16_t t0 = millis();
+  while (spiRec() != 0XFF) {
+    if (((uint16_t)millis() - t0) >= timeoutMillis) goto fail;
+  }
+  return true;
+
+ fail:
+  return false;
+}
+//------------------------------------------------------------------------------
+/**
+ * Writes a 512 byte block to an SD card.
+ *
+ * \param[in] blockNumber Logical block to be written.
+ * \param[in] src Pointer to the location of the data to be written.
+ * \return The value one, true, is returned for success and
+ * the value zero, false, is returned for failure.
+ */
+bool Sd2Card::writeBlock(uint32_t blockNumber, const uint8_t* src) {
+  // use address if not SDHC card
+  if (type() != SD_CARD_TYPE_SDHC) blockNumber <<= 9;
+  if (cardCommand(CMD24, blockNumber)) {
+    error(SD_CARD_ERROR_CMD24);
+    goto fail;
+  }
+  if (!writeData(DATA_START_BLOCK, src)) goto fail;
+
+  // wait for flash programming to complete
+  if (!waitNotBusy(SD_WRITE_TIMEOUT)) {
+    error(SD_CARD_ERROR_WRITE_TIMEOUT);
+    goto fail;
+  }
+  // response is r2 so get and check two bytes for nonzero
+  if (cardCommand(CMD13, 0) || spiRec()) {
+    error(SD_CARD_ERROR_WRITE_PROGRAMMING);
+    goto fail;
+  }
+  chipSelectHigh();
+  return true;
+
+ fail:
+  chipSelectHigh();
+  return false;
+}
+//------------------------------------------------------------------------------
+/** Write one data block in a multiple block write sequence
+ * \param[in] src Pointer to the location of the data to be written.
+ * \return The value one, true, is returned for success and
+ * the value zero, false, is returned for failure.
+ */
+bool Sd2Card::writeData(const uint8_t* src) {
+  chipSelectLow();
+  // wait for previous write to finish
+  if (!waitNotBusy(SD_WRITE_TIMEOUT)) goto fail;
+  if (!writeData(WRITE_MULTIPLE_TOKEN, src)) goto fail;
+  chipSelectHigh();
+  return true;
+
+ fail:
+  error(SD_CARD_ERROR_WRITE_MULTIPLE);
+  chipSelectHigh();
+  return false;
+}
+//------------------------------------------------------------------------------
+// send one block of data for write block or write multiple blocks
+bool Sd2Card::writeData(uint8_t token, const uint8_t* src) {
+  spiSendBlock(token, src);
+
+  spiSend(0xff);  // dummy crc
+  spiSend(0xff);  // dummy crc
+
+  status_ = spiRec();
+  if ((status_ & DATA_RES_MASK) != DATA_RES_ACCEPTED) {
+    error(SD_CARD_ERROR_WRITE);
+    goto fail;
+  }
+  return true;
+
+ fail:
+  chipSelectHigh();
+  return false;
+}
+//------------------------------------------------------------------------------
+/** Start a write multiple blocks sequence.
+ *
+ * \param[in] blockNumber Address of first block in sequence.
+ * \param[in] eraseCount The number of blocks to be pre-erased.
+ *
+ * \note This function is used with writeData() and writeStop()
+ * for optimized multiple block writes.
+ *
+ * \return The value one, true, is returned for success and
+ * the value zero, false, is returned for failure.
+ */
+bool Sd2Card::writeStart(uint32_t blockNumber, uint32_t eraseCount) {
+  // send pre-erase count
+  if (cardAcmd(ACMD23, eraseCount)) {
+    error(SD_CARD_ERROR_ACMD23);
+    goto fail;
+  }
+  // use address if not SDHC card
+  if (type() != SD_CARD_TYPE_SDHC) blockNumber <<= 9;
+  if (cardCommand(CMD25, blockNumber)) {
+    error(SD_CARD_ERROR_CMD25);
+    goto fail;
+  }
+  chipSelectHigh();
+  return true;
+
+ fail:
+  chipSelectHigh();
+  return false;
+}
+//------------------------------------------------------------------------------
+/** End a write multiple blocks sequence.
+ *
+* \return The value one, true, is returned for success and
+ * the value zero, false, is returned for failure.
+ */
+bool Sd2Card::writeStop() {
+  chipSelectLow();
+  if (!waitNotBusy(SD_WRITE_TIMEOUT)) goto fail;
+  spiSend(STOP_TRAN_TOKEN);
+  if (!waitNotBusy(SD_WRITE_TIMEOUT)) goto fail;
+  chipSelectHigh();
+  return true;
+
+ fail:
+  error(SD_CARD_ERROR_STOP_TRAN);
+  chipSelectHigh();
+  return false;
 }\r

diff --git a/Marlin/SdBaseFile.cpp b/Marlin/SdBaseFile.cpp
index dda44ec3ca909810bc35532bcb2a0de655fa73ad..a485199b36302cec3b4ff5ac992875fe95d4739b 100644 (file)
--- a/Marlin/SdBaseFile.cpp
+++ b/Marlin/SdBaseFile.cpp
@@ -306,7 +306,7 @@ void SdBaseFile::getpos(fpos_t* pos) {
  * LS_R - Recursive list of subdirectories.
  */
 void SdBaseFile::ls(uint8_t flags) {
-  ls(&Serial, flags, 0);
+  ls(&MSerial, flags, 0);
 }
 //------------------------------------------------------------------------------
 /** List directory contents.
@@ -949,7 +949,7 @@ int SdBaseFile::peek() {
  */
 void SdBaseFile::printDirName(const dir_t& dir,
   uint8_t width, bool printSlash) {
-  printDirName(&Serial, dir, width, printSlash);
+  printDirName(&MSerial, dir, width, printSlash);
 }
 //------------------------------------------------------------------------------
 /** %Print the name field of a directory entry in 8.3 format.
@@ -993,7 +993,7 @@ static void print2u(Print* pr, uint8_t v) {
  * \param[in] fatDate The date field from a directory entry.
  */
 void SdBaseFile::printFatDate(uint16_t fatDate) {
-  printFatDate(&Serial, fatDate);
+  printFatDate(&MSerial, fatDate);
 }
 //------------------------------------------------------------------------------
 /** %Print a directory date field.
@@ -1018,7 +1018,7 @@ void SdBaseFile::printFatDate(Print* pr, uint16_t fatDate) {
  * \param[in] fatTime The time field from a directory entry.
  */
 void SdBaseFile::printFatTime(uint16_t fatTime) {
-  printFatTime(&Serial, fatTime);
+  printFatTime(&MSerial, fatTime);
 }
 //------------------------------------------------------------------------------
 /** %Print a directory time field.
@@ -1044,7 +1044,7 @@ void SdBaseFile::printFatTime(Print* pr, uint16_t fatTime) {
 bool SdBaseFile::printName() {
   char name[13];
   if (!getFilename(name)) return false;
-  Serial.print(name);
+  MSerial.print(name);
   return true;
 }
 //------------------------------------------------------------------------------

diff --git a/Marlin/SdBaseFile.h b/Marlin/SdBaseFile.h
index 9363401c963f11e862e33aece3b3ff6b95bc3c64..e02ec3c7a565d13bc364e95e90b79b4f3ff1c04a 100644 (file)
--- a/Marlin/SdBaseFile.h
+++ b/Marlin/SdBaseFile.h
@@ -25,7 +25,9 @@
  */
 #include <avr/pgmspace.h>
 #if ARDUINO < 100
+#define  HardwareSerial_h // trick to disable the standard HWserial
 #include <WProgram.h>
+#include "MarlinSerial.h"
 #else  // ARDUINO
 #include <Arduino.h>
 #endif  // ARDUINO

diff --git a/Marlin/SdFatUtil.cpp b/Marlin/SdFatUtil.cpp
index 1870980b1db71d80b7d814cde787a8b766f2ef37..7f82a7083b01fcd5b25ee34e3512a2a7e28adea8 100644 (file)
--- a/Marlin/SdFatUtil.cpp
+++ b/Marlin/SdFatUtil.cpp
@@ -62,7 +62,7 @@ void SdFatUtil::println_P(Print* pr, PGM_P str) {
  * \param[in] str Pointer to string stored in flash memory.
  */
 void SdFatUtil::SerialPrint_P(PGM_P str) {
-  print_P(&Serial, str);
+  print_P(&MSerial, str);
 }
 //------------------------------------------------------------------------------
 /** %Print a string in flash memory to Serial followed by a CR/LF.
@@ -70,5 +70,5 @@ void SdFatUtil::SerialPrint_P(PGM_P str) {
  * \param[in] str Pointer to string stored in flash memory.
  */
 void SdFatUtil::SerialPrintln_P(PGM_P str) {
-  println_P(&Serial, str);
+  println_P(&MSerial, str);
 }

diff --git a/Marlin/SdFatUtil.h b/Marlin/SdFatUtil.h
index b4112aa2d9207bda681ee661b2376084ac38c740..c49e77df8526b478f36ea0bcb9af1dd08efbbd36 100644 (file)
--- a/Marlin/SdFatUtil.h
+++ b/Marlin/SdFatUtil.h
@@ -1,46 +1,48 @@
-/* Arduino SdFat Library\r
- * Copyright (C) 2008 by William Greiman\r
- *\r
- * This file is part of the Arduino SdFat Library\r
- *\r
- * This Library is free software: you can redistribute it and/or modify\r
- * it under the terms of the GNU General Public License as published by\r
- * the Free Software Foundation, either version 3 of the License, or\r
- * (at your option) any later version.\r
- *\r
- * This Library is distributed in the hope that it will be useful,\r
- * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
- * GNU General Public License for more details.\r
-\r
- * You should have received a copy of the GNU General Public License\r
- * along with the Arduino SdFat Library.  If not, see\r
- * <http://www.gnu.org/licenses/>.\r
- */\r
-#ifndef SdFatUtil_h\r
-#define SdFatUtil_h\r
-/**\r
- * \file\r
- * \brief Useful utility functions.\r
- */\r
-#include <avr/pgmspace.h>\r
-#if ARDUINO < 100\r
-#include <WProgram.h>\r
-#else  // ARDUINO\r
-#include <Arduino.h>\r
-#endif  // ARDUINO\r
-/** Store and print a string in flash memory.*/\r
-#define PgmPrint(x) SerialPrint_P(PSTR(x))\r
-/** Store and print a string in flash memory followed by a CR/LF.*/\r
-#define PgmPrintln(x) SerialPrintln_P(PSTR(x))\r
-\r
-namespace SdFatUtil {\r
-  int FreeRam();\r
-  void print_P(Print* pr, PGM_P str);\r
-  void println_P(Print* pr, PGM_P str);\r
-  void SerialPrint_P(PGM_P str);\r
-  void SerialPrintln_P(PGM_P str);\r
-}\r
-\r
-using namespace SdFatUtil;  // NOLINT\r
+/* Arduino SdFat Library
+ * Copyright (C) 2008 by William Greiman
+ *
+ * This file is part of the Arduino SdFat Library
+ *
+ * This Library 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 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 General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with the Arduino SdFat Library.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+#ifndef SdFatUtil_h
+#define SdFatUtil_h
+/**
+ * \file
+ * \brief Useful utility functions.
+ */
+#include <avr/pgmspace.h>
+#if ARDUINO < 100
+#define  HardwareSerial_h // trick to disable the standard HWserial
+#include <WProgram.h>
+#include "MarlinSerial.h"
+#else  // ARDUINO
+#include <Arduino.h>
+#endif  // ARDUINO
+/** Store and print a string in flash memory.*/
+#define PgmPrint(x) SerialPrint_P(PSTR(x))
+/** Store and print a string in flash memory followed by a CR/LF.*/
+#define PgmPrintln(x) SerialPrintln_P(PSTR(x))
+
+namespace SdFatUtil {
+  int FreeRam();
+  void print_P(Print* pr, PGM_P str);
+  void println_P(Print* pr, PGM_P str);
+  void SerialPrint_P(PGM_P str);
+  void SerialPrintln_P(PGM_P str);
+}
+
+using namespace SdFatUtil;  // NOLINT
 #endif  // #define SdFatUtil_h\r

diff --git a/Marlin/motion_control.cpp b/Marlin/motion_control.cpp
index ff3f8c2f2df6f88406efebe9db40e1e2667788df..8ecc1a0445e755fbf0ec6f88781f9b2024b1af94 100644 (file)
--- a/Marlin/motion_control.cpp
+++ b/Marlin/motion_control.cpp
@@ -27,7 +27,7 @@
 // The arc is approximated by generating a huge number of tiny, linear segments. The length of each 
 // segment is configured in settings.mm_per_arc_segment.  
 void mc_arc(float *position, float *target, float *offset, uint8_t axis_0, uint8_t axis_1, 
-  uint8_t axis_linear, float feed_rate, float radius, uint8_t isclockwise)
+  uint8_t axis_linear, float feed_rate, float radius, uint8_t isclockwise, uint8_t extruder)
 {      
   //   int acceleration_manager_was_enabled = plan_is_acceleration_manager_enabled();
   //   plan_set_acceleration_manager_enabled(false); // disable acceleration management for the duration of the arc
@@ -123,11 +123,11 @@ void mc_arc(float *position, float *target, float *offset, uint8_t axis_0, uint8
     arc_target[axis_1] = center_axis1 + r_axis1;
     arc_target[axis_linear] += linear_per_segment;
     arc_target[E_AXIS] += extruder_per_segment;
-    plan_buffer_line(arc_target[X_AXIS], arc_target[Y_AXIS], arc_target[Z_AXIS], arc_target[E_AXIS], feed_rate);
+    plan_buffer_line(arc_target[X_AXIS], arc_target[Y_AXIS], arc_target[Z_AXIS], arc_target[E_AXIS], feed_rate, extruder);
     
   }
   // Ensure last segment arrives at target location.
-  plan_buffer_line(target[X_AXIS], target[Y_AXIS], target[Z_AXIS], target[E_AXIS], feed_rate);
+  plan_buffer_line(target[X_AXIS], target[Y_AXIS], target[Z_AXIS], target[E_AXIS], feed_rate, extruder);
 
   //   plan_set_acceleration_manager_enabled(acceleration_manager_was_enabled);
 }

diff --git a/Marlin/motion_control.h b/Marlin/motion_control.h
index 9bcff4bf4c43a7af074d78c30c1badd83a84ad0f..ca50f8098f91a277584cec5e3d43551694c7f9b5 100644 (file)
--- a/Marlin/motion_control.h
+++ b/Marlin/motion_control.h
@@ -27,6 +27,6 @@
 // the direction of helical travel, radius == circle radius, isclockwise boolean. Used
 // for vector transformation direction.
 void mc_arc(float *position, float *target, float *offset, unsigned char axis_0, unsigned char axis_1,
-  unsigned char axis_linear, float feed_rate, float radius, unsigned char isclockwise);
+  unsigned char axis_linear, float feed_rate, float radius, unsigned char isclockwise, uint8_t extruder);
   
 #endif

diff --git a/Marlin/planner.cpp b/Marlin/planner.cpp
index 0f9b1eb9ee93a327ec0c02392926d00df7180c9c..47286983b86227fcfbe5869e834f4687cece934f 100644 (file)
--- a/Marlin/planner.cpp
+++ b/Marlin/planner.cpp
@@ -451,7 +451,7 @@ float junction_deviation = 0.1;
 // Add a new linear movement to the buffer. steps_x, _y and _z is the absolute position in 
 // mm. Microseconds specify how many microseconds the move should take to perform. To aid acceleration
 // calculation the caller must also provide the physical length of the line in millimeters.
-void plan_buffer_line(const float &x, const float &y, const float &z, const float &e,  float feed_rate)
+void plan_buffer_line(const float &x, const float &y, const float &z, const float &e,  float feed_rate, const uint8_t &extruder)
 {
   // Calculate the buffer head after we push this byte
   int next_buffer_head = next_block_index(block_buffer_head);
@@ -527,12 +527,12 @@ void plan_buffer_line(const float &x, const float &y, const float &z, const floa
   else {
        if(feed_rate<minimumfeedrate) feed_rate=minimumfeedrate;
   } 
-  
+
 #ifdef SLOWDOWN
   // slow down when de buffer starts to empty, rather than wait at the corner for a buffer refill
   int moves_queued=(block_buffer_head-block_buffer_tail + BLOCK_BUFFER_SIZE) & (BLOCK_BUFFER_SIZE - 1);
   
-  if(moves_queued < (BLOCK_BUFFER_SIZE * 0.5)) feed_rate = feed_rate*moves_queued / (BLOCK_BUFFER_SIZE * 0.5); 
+  if(moves_queued < (BLOCK_BUFFER_SIZE * 0.5) && moves_queued > 1) feed_rate = feed_rate*moves_queued / (BLOCK_BUFFER_SIZE * 0.5); 
 #endif
 
 /*

diff --git a/Marlin/planner.h b/Marlin/planner.h
index 57c59a0b0f2859cf6937e138b7c34bce3d772f55..8ef8fec17f5454fe4b9bf44afe535778ef702dd3 100644 (file)
--- a/Marlin/planner.h
+++ b/Marlin/planner.h
@@ -66,7 +66,7 @@ void plan_init();
 
 // Add a new linear movement to the buffer. x, y and z is the signed, absolute target position in 
 // millimaters. Feed rate specifies the speed of the motion.
-void plan_buffer_line(const float &x, const float &y, const float &z, const float &e, float feed_rate);
+void plan_buffer_line(const float &x, const float &y, const float &z, const float &e, float feed_rate, const uint8_t &extruder);
 
 // Set position. Used for G92 instructions.
 void plan_set_position(const float &x, const float &y, const float &z, const float &e);

diff --git a/Marlin/stepper.cpp b/Marlin/stepper.cpp
index 491b6e7f2b82c7fdd8c144dfd37e94e35c400cfc..34c7153c643e353e07e9ee2d991834b74c50ee2e 100644 (file)
--- a/Marlin/stepper.cpp
+++ b/Marlin/stepper.cpp
@@ -52,7 +52,7 @@ static long counter_x,       // Counter variables for the bresenham line tracer
             counter_y, 
             counter_z,       
             counter_e;
-static unsigned long step_events_completed; // The number of step events executed in the current block
+volatile static unsigned long step_events_completed; // The number of step events executed in the current block
 #ifdef ADVANCE
   static long advance_rate, advance, final_advance = 0;
   static short old_advance = 0;
@@ -63,6 +63,7 @@ static long acceleration_time, deceleration_time;
 //static unsigned long accelerate_until, decelerate_after, acceleration_rate, initial_rate, final_rate, nominal_rate;
 static unsigned short acc_step_rate; // needed for deccelaration start point
 static char step_loops;
+static unsigned short OCR1A_nominal;
 
 volatile long endstops_trigsteps[3]={0,0,0};
 volatile long endstops_stepsTotal,endstops_stepsDone;
@@ -77,10 +78,6 @@ static bool old_y_max_endstop=false;
 static bool old_z_min_endstop=false;
 static bool old_z_max_endstop=false;
 
-static bool busy_error=false;
-unsigned short OCR1A_error=12345;
-unsigned short OCR1A_nominal;
-
 volatile long count_position[NUM_AXIS] = { 0, 0, 0, 0};
 volatile char count_direction[NUM_AXIS] = { 1, 1, 1, 1};
 
@@ -164,15 +161,6 @@ asm volatile ( \
 #define ENABLE_STEPPER_DRIVER_INTERRUPT()  TIMSK1 |= (1<<OCIE1A)
 #define DISABLE_STEPPER_DRIVER_INTERRUPT() TIMSK1 &= ~(1<<OCIE1A)
 
-void checkStepperErrors()
-{
-  if(busy_error) {
-    SERIAL_ERROR_START
-    SERIAL_ERROR(OCR1A_error);
-    SERIAL_ERRORLNPGM(" ISR overtaking itself.");
-    busy_error = false;
-  }
-}
 
 void checkHitEndstops()
 {
@@ -255,7 +243,7 @@ inline unsigned short calc_timer(unsigned short step_rate) {
     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) { timer = 100; Serial.print("Steprate to high : "); Serial.println(step_rate); }//(20kHz this should never happen)
+  if(timer < 100) { timer = 100; MSerial.print("Steprate to high : "); MSerial.println(step_rate); }//(20kHz this should never happen)
   return timer;
 }
 
@@ -277,17 +265,7 @@ inline void trapezoid_generator_reset() {
 // "The Stepper Driver Interrupt" - This timer interrupt is the workhorse.  
 // It pops blocks from the block_buffer and executes them by pulsing the stepper pins appropriately. 
 ISR(TIMER1_COMPA_vect)
-{        
-  if(busy){ 
-    OCR1A_error = OCR1A;
-    busy_error = true;
-    OCR1A = 30000;
-    return; 
-  } // The busy-flag is used to avoid reentering this interrupt
-
-  busy = true;
-  sei(); // Re enable interrupts (normally disabled while inside an interrupt handler)
-
+{    
   // If there is no current block, attempt to pop one from the buffer
   if (current_block == NULL) {
     // Anything in the buffer?
@@ -304,7 +282,7 @@ ISR(TIMER1_COMPA_vect)
 //      #endif
     } 
     else {
-//      DISABLE_STEPPER_DRIVER_INTERRUPT();
+        OCR1A=2000; // 1kHz.
     }    
   } 
 
@@ -404,8 +382,8 @@ ISR(TIMER1_COMPA_vect)
         count_direction[E_AXIS]=-1;
       }
     #endif //!ADVANCE
-
     for(int8_t i=0; i < step_loops; i++) { // Take multiple steps per interrupt (For high speed moves) 
+    MSerial.checkRx();
     /*
       counter_e += current_block->steps_e;
       if (counter_e > 0) {
@@ -470,6 +448,7 @@ ISR(TIMER1_COMPA_vect)
     unsigned short timer;
     unsigned short step_rate;
     if (step_events_completed <= current_block->accelerate_until) {
+      
       MultiU24X24toH16(acc_step_rate, acceleration_time, current_block->acceleration_rate);
       acc_step_rate += current_block->initial_rate;
       
@@ -519,8 +498,6 @@ ISR(TIMER1_COMPA_vect)
       plan_discard_current_block();
     }   
   } 
-  cli(); // disable interrupts
-  busy=false;
 }
 
 #ifdef ADVANCE