Sd2Card.h

Go to the documentation of this file.

/* 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/>.
 */
 
#include "Marlin.h"
#ifdef SDSUPPORT
 
#ifndef Sd2Card_h
#define Sd2Card_h
#include "SdFatConfig.h"
#include "SdInfo.h"
//------------------------------------------------------------------------------
// SPI speed is F_CPU/2^(1 + index), 0 <= index <= 6
uint8_t const SPI_FULL_SPEED = 0;
uint8_t const SPI_HALF_SPEED = 1;
uint8_t const SPI_QUARTER_SPEED = 2;
uint8_t const SPI_EIGHTH_SPEED = 3;
uint8_t const SPI_SIXTEENTH_SPEED = 4;
//------------------------------------------------------------------------------
uint16_t const SD_INIT_TIMEOUT = 2000;
uint16_t const SD_ERASE_TIMEOUT = 10000;
uint16_t const SD_READ_TIMEOUT = 300;
uint16_t const SD_WRITE_TIMEOUT = 600;
//------------------------------------------------------------------------------
// SD card errors
uint8_t const SD_CARD_ERROR_CMD0 = 0X1;
uint8_t const SD_CARD_ERROR_CMD8 = 0X2;
uint8_t const SD_CARD_ERROR_CMD12 = 0X3;
uint8_t const SD_CARD_ERROR_CMD17 = 0X4;
uint8_t const SD_CARD_ERROR_CMD18 = 0X5;
uint8_t const SD_CARD_ERROR_CMD24 = 0X6;
uint8_t const SD_CARD_ERROR_CMD25 = 0X7;
uint8_t const SD_CARD_ERROR_CMD58 = 0X8;
uint8_t const SD_CARD_ERROR_ACMD23 = 0X9;
uint8_t const SD_CARD_ERROR_ACMD41 = 0XA;
uint8_t const SD_CARD_ERROR_BAD_CSD = 0XB;
uint8_t const SD_CARD_ERROR_ERASE = 0XC;
uint8_t const SD_CARD_ERROR_ERASE_SINGLE_BLOCK = 0XD;
uint8_t const SD_CARD_ERROR_ERASE_TIMEOUT = 0XE;
uint8_t const SD_CARD_ERROR_READ = 0XF;
uint8_t const SD_CARD_ERROR_READ_REG = 0X10;
uint8_t const SD_CARD_ERROR_READ_TIMEOUT = 0X11;
uint8_t const SD_CARD_ERROR_STOP_TRAN = 0X12;
uint8_t const SD_CARD_ERROR_WRITE = 0X13;
uint8_t const SD_CARD_ERROR_WRITE_BLOCK_ZERO = 0X14;  // REMOVE - not used
uint8_t const SD_CARD_ERROR_WRITE_MULTIPLE = 0X15;
uint8_t const SD_CARD_ERROR_WRITE_PROGRAMMING = 0X16;
uint8_t const SD_CARD_ERROR_WRITE_TIMEOUT = 0X17;
uint8_t const SD_CARD_ERROR_SCK_RATE = 0X18;
uint8_t const SD_CARD_ERROR_INIT_NOT_CALLED = 0X19;
uint8_t const SD_CARD_ERROR_CRC = 0X20;
uint8_t const SD_CARD_ERROR_FF_TIMEOUT = 0X21;
 
uint8_t const SD_CARD_ERROR_CMD48 = 0x80;
uint8_t const SD_CARD_ERROR_CMD49 = 0x81;
 
//------------------------------------------------------------------------------
// card types
uint8_t const SD_CARD_TYPE_SD1  = 1;
uint8_t const SD_CARD_TYPE_SD2  = 2;
uint8_t const SD_CARD_TYPE_SDHC = 3;
//------------------------------------------------------------------------------
#if MEGA_SOFT_SPI && (defined(__AVR_ATmega1280__)||defined(__AVR_ATmega2560__))
#define SOFTWARE_SPI
#elif USE_SOFTWARE_SPI
#define SOFTWARE_SPI
#endif  // MEGA_SOFT_SPI
//------------------------------------------------------------------------------
// SPI pin definitions - do not edit here - change in SdFatConfig.h
//
#ifdef SOFTWARE_SPI
uint8_t const SPI_MOSI_PIN = SOFT_SPI_MOSI_PIN;
uint8_t const SPI_MISO_PIN = SOFT_SPI_MISO_PIN;
uint8_t const SPI_SCK_PIN = SOFT_SPI_SCK_PIN;
#endif  // SOFTWARE_SPI
//------------------------------------------------------------------------------
class Sd2Card {
 public:
  Sd2Card() : errorCode_(SD_CARD_ERROR_INIT_NOT_CALLED), type_(0), flash_air_compatible_(false) {}
  uint32_t cardSize();
  bool erase(uint32_t firstBlock, uint32_t lastBlock);
  bool eraseSingleBlockEnable();
  void error(uint8_t code) {errorCode_ = code;}
  uint8_t errorCode() const {return errorCode_;}
  uint8_t errorData() const {return status_;}
  bool init(uint8_t sckRateID = SPI_FULL_SPEED);
  bool readBlock(uint32_t block, uint8_t* dst);
  bool readCID(cid_t* cid) {
    return readRegister(CMD10, cid);
  }
  bool readCSD(csd_t* csd) {
    return readRegister(CMD9, csd);
  }
  bool readData(uint8_t *dst);
  bool readStart(uint32_t blockNumber);
  bool readStop();
  bool setSckRate(uint8_t sckRateID);
  int type() const {return type_;}
  bool writeBlock(uint32_t blockNumber, const uint8_t* src);
  bool writeData(const uint8_t* src);
  bool writeStart(uint32_t blockNumber, uint32_t eraseCount);
  bool writeStop();
 
  // Toshiba FlashAir support
  uint8_t readExtMemory(uint8_t mio, uint8_t func, uint32_t addr, uint16_t count, uint8_t* dst);
 
  void setFlashAirCompatible(bool flashAirCompatible) { flash_air_compatible_ = flashAirCompatible; }
  bool getFlashAirCompatible() const { return flash_air_compatible_; }
 
 private:
  //----------------------------------------------------------------------------
  uint8_t errorCode_;
  uint8_t spiRate_;
  uint8_t status_;
  uint8_t type_;
  bool    flash_air_compatible_;
  // private functions
  uint8_t cardAcmd(uint8_t cmd, uint32_t arg) {
    cardCommand(CMD55, 0);
    return cardCommand(cmd, arg);
  }
  uint8_t cardCommand(uint8_t cmd, uint32_t arg);
 
  bool readData(uint8_t* dst, uint16_t count);
  bool readRegister(uint8_t cmd, void* buf);
  void chipSelectHigh();
  void chipSelectLow();
  void type(uint8_t value) {type_ = value;}
  bool waitNotBusy(uint16_t timeoutMillis);
  bool writeData(uint8_t token, const uint8_t* src);
 
 
  // Toshiba FlashAir support
  uint8_t waitStartBlock(void);
  uint8_t readExt(uint32_t arg, uint8_t* dst, uint16_t count);
};
#endif  // Sd2Card_h
 
 
#endif