visus
/
teensy-sd
ウォッチ 1
スター 0
フォーク 0
コード 課題 0 プルリクエスト 0 リリース 0 Wiki アクティビティ
59 コミット
1 ブランチ
ツリー: 3d18f19aaa
teensy-sd/utility/Sd2Card.cpp

539 行
16KB
Raw Blame 履歴 

  1. /* Arduino Sd2Card Library

  2.  * Copyright (C) 2009 by William Greiman

  3.  *

  4.  * This file is part of the Arduino Sd2Card Library

  5.  *

  6.  * This Library is free software: you can redistribute it and/or modify

  7.  * it under the terms of the GNU General Public License as published by

  8.  * the Free Software Foundation, either version 3 of the License, or

  9.  * (at your option) any later version.

  10.  *

  11.  * This Library is distributed in the hope that it will be useful,

  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  14.  * GNU General Public License for more details.

  15.  *

  16.  * You should have received a copy of the GNU General Public License

  17.  * along with the Arduino Sd2Card Library.  If not, see

  18.  * <http://www.gnu.org/licenses/>.

  19.  */

  20. #include <Arduino.h>

  21. #include <SPI.h>

  22. #include "Sd2Card.h"

  23. 

  24. #ifdef SPI_HAS_TRANSACTION

  25. static SPISettings settings;

  26. #endif

  27. 

  28. 

  29. 

  30. #if defined(__MK20DX128__) || defined(__MK20DX256__) || defined(__MK64FX512__) || defined(__MK66FX1M0__)

  31. #define USE_TEENSY3_SPI

  32. 

  33. // Teensy 3.0 functions  (copied from sdfatlib20130629)

  34. #include <kinetis.h>

  35. // Limit initial fifo to three entries to avoid fifo overrun

  36. #define SPI_INITIAL_FIFO_DEPTH 3

  37. // define some symbols that are not in mk20dx128.h

  38. #ifndef SPI_SR_RXCTR

  39. #define SPI_SR_RXCTR 0XF0

  40. #endif  // SPI_SR_RXCTR

  41. #ifndef SPI_PUSHR_CONT

  42. #define SPI_PUSHR_CONT 0X80000000

  43. #endif   // SPI_PUSHR_CONT

  44. #ifndef SPI_PUSHR_CTAS

  45. #define SPI_PUSHR_CTAS(n) (((n) & 7) << 28)

  46. #endif  // SPI_PUSHR_CTAS

  47. 

  48. static void spiBegin() {

  49.   SIM_SCGC6 |= SIM_SCGC6_SPI0;

  50. }

  51. 

  52. static void spiInit(uint8_t spiRate) {

  53.   switch (spiRate) {

  54.     // the top 2 speeds are set to 24 MHz, for the SD library defaults

  55.     case 0:  settings = SPISettings(24000000, MSBFIRST, SPI_MODE0); break;

  56.     case 1:  settings = SPISettings(24000000, MSBFIRST, SPI_MODE0); break;

  57.     case 2:  settings = SPISettings(8000000, MSBFIRST, SPI_MODE0); break;

  58.     case 3:  settings = SPISettings(4000000, MSBFIRST, SPI_MODE0); break;

  59.     case 4:  settings = SPISettings(3000000, MSBFIRST, SPI_MODE0); break;

  60.     case 5:  settings = SPISettings(2000000, MSBFIRST, SPI_MODE0); break;

  61.     default: settings = SPISettings(400000, MSBFIRST, SPI_MODE0);

  62.   }

  63.   SPI.begin();

  64. }

  65. 

  66. /** SPI receive a byte */

  67. static  uint8_t spiRec() {

  68.   SPI0_MCR |= SPI_MCR_CLR_RXF;

  69.   SPI0_SR = SPI_SR_TCF;

  70.   SPI0_PUSHR = 0xFF;

  71.   while (!(SPI0_SR & SPI_SR_TCF)) {}

  72.   return SPI0_POPR;

  73. }

  74. /** SPI receive multiple bytes */

  75. static uint8_t spiRec(uint8_t* buf, size_t len) {

  76.   // clear any data in RX FIFO

  77.   SPI0_MCR = SPI_MCR_MSTR | SPI_MCR_CLR_RXF | SPI_MCR_PCSIS(0x1F);

  78.   // use 16 bit frame to avoid TD delay between frames

  79.   // get one byte if len is odd

  80.   if (len & 1) {

  81.     *buf++ = spiRec();

  82.     len--;

  83.   }

  84.   // initial number of words to push into TX FIFO

  85.   int nf = len/2 < SPI_INITIAL_FIFO_DEPTH ? len/2 : SPI_INITIAL_FIFO_DEPTH;

  86.   for (int i = 0; i < nf; i++) {

  87.     SPI0_PUSHR = SPI_PUSHR_CONT | SPI_PUSHR_CTAS(1) | 0XFFFF;

  88.   }

  89.   uint8_t* limit = buf + len - 2*nf;

  90.   while (buf < limit) {

  91.     while (!(SPI0_SR & SPI_SR_RXCTR)) {}

  92.     SPI0_PUSHR = SPI_PUSHR_CONT | SPI_PUSHR_CTAS(1) | 0XFFFF;

  93.     uint16_t w = SPI0_POPR;

  94.     *buf++ = w >> 8;

  95.     *buf++ = w & 0XFF;

  96.   }

  97.   // limit for rest of RX data

  98.   limit += 2*nf;

  99.   while (buf < limit) {

  100.     while (!(SPI0_SR & SPI_SR_RXCTR)) {}

  101.     uint16_t w = SPI0_POPR;

  102.     *buf++ = w >> 8;

  103.     *buf++ = w & 0XFF;

  104.   }

  105.   return 0;

  106. }

  107. static void spiRecIgnore(size_t len) {

  108.   // clear any data in RX FIFO

  109.   SPI0_MCR = SPI_MCR_MSTR | SPI_MCR_CLR_RXF | SPI_MCR_PCSIS(0x1F);

  110.   // use 16 bit frame to avoid TD delay between frames

  111.   // get one byte if len is odd

  112.   if (len & 1) {

  113.     spiRec();

  114.     len--;

  115.   }

  116.   // initial number of words to push into TX FIFO

  117.   int nf = len/2 < SPI_INITIAL_FIFO_DEPTH ? len/2 : SPI_INITIAL_FIFO_DEPTH;

  118.   for (int i = 0; i < nf; i++) {

  119.     SPI0_PUSHR = SPI_PUSHR_CONT | SPI_PUSHR_CTAS(1) | 0XFFFF;

  120.     len -= 2;

  121.   }

  122.   //uint8_t* limit = buf + len - 2*nf;

  123.   //while (buf < limit) {

  124.   while (len > 0) {

  125.     while (!(SPI0_SR & SPI_SR_RXCTR)) {}

  126.     SPI0_PUSHR = SPI_PUSHR_CONT | SPI_PUSHR_CTAS(1) | 0XFFFF;

  127.     SPI0_POPR;

  128.     len -= 2;

  129.   }

  130.   // limit for rest of RX data

  131.   while (nf > 0) {

  132.     while (!(SPI0_SR & SPI_SR_RXCTR)) {}

  133.     SPI0_POPR;

  134.     nf--;

  135.   }

  136. }

  137. /** SPI send a byte */

  138. static void spiSend(uint8_t b) {

  139.   SPI0_MCR |= SPI_MCR_CLR_RXF;

  140.   SPI0_SR = SPI_SR_TCF;

  141.   SPI0_PUSHR = b;

  142.   while (!(SPI0_SR & SPI_SR_TCF)) {}

  143. }

  144. /** SPI send multiple bytes */

  145. 

  146. #elif defined(__IMXRT1052__)  || defined(__IMXRT1062__)

  147.  #define USE_TEENSY4_SPI

  148.  

  149.  static void spiInit(uint8_t spiRate) {

  150.   switch (spiRate) {

  151.     // the top 2 speeds are set to 24 MHz, for the SD library defaults

  152.     case 0:  settings = SPISettings(25200000, MSBFIRST, SPI_MODE0); break;

  153.     case 1:  settings = SPISettings(24000000, MSBFIRST, SPI_MODE0); break;

  154.     case 2:  settings = SPISettings(8000000, MSBFIRST, SPI_MODE0); break;

  155.     case 3:  settings = SPISettings(4000000, MSBFIRST, SPI_MODE0); break;

  156.     case 4:  settings = SPISettings(3000000, MSBFIRST, SPI_MODE0); break;

  157.     case 5:  settings = SPISettings(2000000, MSBFIRST, SPI_MODE0); break;

  158.     default: settings = SPISettings(400000, MSBFIRST, SPI_MODE0);

  159.   }

  160.   SPI.begin();

  161. } 

  162. 

  163.  static void spiSend(uint8_t b) {

  164. 	SPI.transfer(b);

  165.  }

  166.  

  167.  static  uint8_t spiRec(void) {

  168. 	return SPI.transfer(0xff);

  169.  }

  170.  

  171.  static void spiRec(uint8_t* buf, size_t len) {

  172. 	SPI.transfer(buf, len);	

  173.  }

  174.  

  175.  static void spiRecIgnore(size_t len) {

  176. 	for (size_t i=0; i < len; i++) 

  177. 		SPI.transfer(0xff);

  178.  }

  179.  

  180. //------------------------------------------------------------------------------

  181. #else

  182. // functions for hardware SPI

  183. /** Send a byte to the card */

  184. static void spiSend(uint8_t b) {

  185.   SPDR = b;

  186.   while (!(SPSR & (1 << SPIF)));

  187. }

  188. /** Receive a byte from the card */

  189. static  uint8_t spiRec(void) {

  190.   spiSend(0XFF);

  191.   return SPDR;

  192. }

  193. 

  194. #endif

  195. 

  196. 

  197. 

  198. 

  199. //------------------------------------------------------------------------------

  200. // send command and return error code.  Return zero for OK

  201. uint8_t Sd2Card::cardCommand(uint8_t cmd, uint32_t arg)

  202. {

  203.   // wait up to 300 ms if busy

  204.   waitNotBusy(300);

  205. 

  206.   // send command

  207.   spiSend(cmd | 0x40);

  208. 

  209.   // send argument

  210.   for (int8_t s = 24; s >= 0; s -= 8) spiSend(arg >> s);

  211. 

  212.   // send CRC

  213.   uint8_t crc = 0XFF;

  214.   if (cmd == CMD0) crc = 0X95;  // correct crc for CMD0 with arg 0

  215.   if (cmd == CMD8) crc = 0X87;  // correct crc for CMD8 with arg 0X1AA

  216.   spiSend(crc);

  217. 

  218.   // wait for response

  219.   for (uint8_t i = 0; ((status_ = spiRec()) & 0X80) && i != 0XFF; i++);

  220.   return status_;

  221. }

  222. //------------------------------------------------------------------------------

  223. #ifdef SPI_HAS_TRANSACTION

  224. static uint8_t chip_select_asserted = 0;

  225. #endif

  226. void Sd2Card::chipSelectHigh(void) {

  227.   digitalWrite(chipSelectPin_, HIGH);

  228. #ifdef SPI_HAS_TRANSACTION

  229.   if (chip_select_asserted) {

  230.     chip_select_asserted = 0;

  231.     SPI.endTransaction();

  232.   }

  233. #endif

  234. }

  235. //------------------------------------------------------------------------------

  236. void Sd2Card::chipSelectLow(void) {

  237. #ifdef SPI_HAS_TRANSACTION

  238.   if (!chip_select_asserted) {

  239.     chip_select_asserted = 1;

  240.     SPI.beginTransaction(settings);

  241.   }

  242. #endif

  243.   digitalWrite(chipSelectPin_, LOW);

  244. }

  245. //------------------------------------------------------------------------------

  246. /**

  247.  * Initialize an SD flash memory card.

  248.  *

  249.  * \param[in] sckRateID SPI clock rate selector. See setSckRate().

  250.  * \param[in] chipSelectPin SD chip select pin number.

  251.  *

  252.  * \return The value one, true, is returned for success and

  253.  * the value zero, false, is returned for failure.

  254.  */

  255. uint8_t Sd2Card::SD_init(uint8_t sckRateID, uint8_t chipSelectPin) {

  256.   type_ = 0;

  257.   chipSelectPin_ = chipSelectPin;

  258.   // 16-bit init start time allows over a minute

  259.   unsigned int t0 = millis();

  260.   uint32_t arg;

  261. 

  262.   digitalWrite(chipSelectPin_, HIGH);

  263.   pinMode(chipSelectPin_, OUTPUT);

  264.   digitalWrite(chipSelectPin_, HIGH);

  265. 

  266. #if defined(USE_TEENSY3_SPI)

  267.   spiBegin();

  268.   spiInit(6);

  269. #elif defined(USE_TEENSY4_SPI)

  270.   spiInit(6);

  271.   pinMode(SS_PIN, OUTPUT);

  272.   digitalWrite(SS_PIN, HIGH); // disable any SPI device using hardware SS pin  

  273. #else

  274.   // set pin modes

  275.   pinMode(SPI_MISO_PIN, INPUT);

  276.   pinMode(SPI_MOSI_PIN, OUTPUT);

  277.   pinMode(SPI_SCK_PIN, OUTPUT);

  278.   // SS must be in output mode even it is not chip select

  279.   pinMode(SS_PIN, OUTPUT);

  280.   digitalWrite(SS_PIN, HIGH); // disable any SPI device using hardware SS pin

  281.   // Enable SPI, Master, clock rate f_osc/128

  282.   SPCR = (1 << SPE) | (1 << MSTR) | (1 << SPR1) | (1 << SPR0);

  283.   // clear double speed

  284.   SPSR &= ~(1 << SPI2X);

  285. #ifdef SPI_HAS_TRANSACTION

  286.   settings = SPISettings(250000, MSBFIRST, SPI_MODE0);

  287. #endif

  288. #endif  // not USE_TEENSY3_SPI

  289.   // must supply min of 74 clock cycles with CS high.

  290. #ifdef SPI_HAS_TRANSACTION

  291.   SPI.beginTransaction(settings);

  292. #endif

  293.   for (uint8_t i = 0; i < 10; i++) spiSend(0XFF);

  294. #ifdef SPI_HAS_TRANSACTION

  295.   SPI.endTransaction();

  296. #endif

  297.   chipSelectLow();

  298.   // command to go idle in SPI mode

  299.   while ((status_ = cardCommand(CMD0, 0)) != R1_IDLE_STATE) {

  300.     unsigned int d = millis() - t0;

  301.     if (d > SD_INIT_TIMEOUT) {

  302.       goto fail; // SD_CARD_ERROR_CMD0

  303.     }

  304.   }

  305.   // check SD version

  306.   if ((cardCommand(CMD8, 0x1AA) & R1_ILLEGAL_COMMAND)) {

  307.     type_ = SD_CARD_TYPE_SD1;

  308.   } else {

  309.     // only need last byte of r7 response

  310.     for (uint8_t i = 0; i < 4; i++) status_ = spiRec();

  311.     if (status_ != 0XAA) {

  312.       goto fail; // SD_CARD_ERROR_CMD8

  313.     }

  314.     type_ = SD_CARD_TYPE_SD2;

  315.   }

  316.   // initialize card and send host supports SDHC if SD2

  317.   arg = (type_ == SD_CARD_TYPE_SD2) ? 0X40000000 : 0;

  318.   while ((status_ = cardAcmd(ACMD41, arg)) != R1_READY_STATE) {

  319.     // check for timeout

  320.     unsigned int d = millis() - t0;

  321.     if (d > SD_INIT_TIMEOUT) {

  322.       goto fail; // SD_CARD_ERROR_ACMD41

  323.     }

  324.   }

  325.   // if SD2 read OCR register to check for SDHC card

  326.   if (type_ == SD_CARD_TYPE_SD2) {

  327.     if (cardCommand(CMD58, 0)) {

  328.       goto fail; // SD_CARD_ERROR_CMD58

  329.     }

  330.     if ((spiRec() & 0XC0) == 0XC0) type_ = SD_CARD_TYPE_SDHC;

  331.     // discard rest of ocr - contains allowed voltage range

  332.     for (uint8_t i = 0; i < 3; i++) spiRec();

  333.   }

  334.   chipSelectHigh();

  335.   return setSckRate(sckRateID);

  336. 

  337. fail:

  338.   chipSelectHigh();

  339.   return false;

  340. }

  341. //------------------------------------------------------------------------------

  342. /**

  343.  * Read a 512 byte block from an SD card device.

  344.  *

  345.  * \param[in] block Logical block to be read.

  346.  * \param[out] dst Pointer to the location that will receive the data.

  347. 

  348.  * \return The value one, true, is returned for success and

  349.  * the value zero, false, is returned for failure.

  350.  */

  351. uint8_t Sd2Card::SD_readBlock(uint32_t block, uint8_t* dst)

  352. {

  353.   // use address if not SDHC card

  354.   if (type_ != SD_CARD_TYPE_SDHC) block <<= 9;

  355.   chipSelectLow();

  356.   if (cardCommand(CMD17, block)) {

  357.     goto fail; // SD_CARD_ERROR_CMD17

  358.   }

  359.   if (!waitStartBlock()) {

  360.     goto fail;

  361.   }

  362. #if defined(USE_TEENSY3_SPI) | defined(USE_TEENSY4_SPI)

  363.   spiRec(dst, 512);

  364.   spiRecIgnore(2);

  365. #else  // OPTIMIZE_HARDWARE_SPI

  366.   // start first spi transfer

  367.   SPDR = 0XFF;

  368.   // transfer data

  369.   for (uint16_t i = 0; i < 511; i++) {

  370.     while (!(SPSR & (1 << SPIF)));

  371.     dst[i] = SPDR;

  372.     SPDR = 0XFF;

  373.   }

  374.   // wait for last byte

  375.   while (!(SPSR & (1 << SPIF)));

  376.   dst[511] = SPDR;

  377.   // skip CRC bytes

  378.   spiRec();

  379.   spiRec();

  380. #endif

  381.   chipSelectHigh();

  382.   return true;

  383. 

  384.  fail:

  385.   chipSelectHigh();

  386.   return false;

  387. }

  388. //------------------------------------------------------------------------------

  389. /**

  390.  * Set the SPI clock rate.

  391.  *

  392.  * \param[in] sckRateID A value in the range [0, 6].

  393.  *

  394.  * 0 = 8 MHz

  395.  * 1 = 4 MHz

  396.  * 2 = 2 MHz

  397.  * 3 = 1 MHz

  398.  * 4 = 500 kHz

  399.  * 5 = 125 kHz

  400.  * 6 = 63 kHz

  401.  *

  402.  * The SPI clock will be set to F_CPU/pow(2, 1 + sckRateID). The maximum

  403.  * SPI rate is F_CPU/2 for \a sckRateID = 0 and the minimum rate is F_CPU/128

  404.  * for \a scsRateID = 6.

  405.  *

  406.  * \return The value one, true, is returned for success and the value zero,

  407.  * false, is returned for an invalid value of \a sckRateID.

  408.  */

  409. uint8_t Sd2Card::setSckRate(uint8_t sckRateID) {

  410. #if defined(USE_TEENSY3_SPI) || defined(USE_TEENSY4_SPI)

  411.   spiInit(sckRateID);

  412.   return true;

  413. #else

  414.   if (sckRateID > 6) sckRateID = 6;

  415.   // see avr processor datasheet for SPI register bit definitions

  416.   if ((sckRateID & 1) || sckRateID == 6) {

  417.     SPSR &= ~(1 << SPI2X);

  418.   } else {

  419.     SPSR |= (1 << SPI2X);

  420.   }

  421.   SPCR &= ~((1 <<SPR1) | (1 << SPR0));

  422.   SPCR |= (sckRateID & 4 ? (1 << SPR1) : 0)

  423.     | (sckRateID & 2 ? (1 << SPR0) : 0);

  424. #ifdef SPI_HAS_TRANSACTION

  425.   switch (sckRateID) {

  426.     case 0:  settings = SPISettings(8000000, MSBFIRST, SPI_MODE0); break;

  427.     case 1:  settings = SPISettings(4000000, MSBFIRST, SPI_MODE0); break;

  428.     case 2:  settings = SPISettings(2000000, MSBFIRST, SPI_MODE0); break;

  429.     case 3:  settings = SPISettings(1000000, MSBFIRST, SPI_MODE0); break;

  430.     case 4:  settings = SPISettings(500000, MSBFIRST, SPI_MODE0); break;

  431.     case 5:  settings = SPISettings(250000, MSBFIRST, SPI_MODE0); break;

  432.     default: settings = SPISettings(125000, MSBFIRST, SPI_MODE0);

  433.   }

  434. #endif

  435.   return true;

  436. #endif

  437. }

  438. //------------------------------------------------------------------------------

  439. // wait for card to go not busy

  440. uint8_t Sd2Card::waitNotBusy(unsigned int timeoutMillis) {

  441.   unsigned int t0 = millis();

  442.   unsigned int d;

  443.   do {

  444.     if (spiRec() == 0XFF) return true;

  445.     d = millis() - t0;

  446.   }

  447.   while (d < timeoutMillis);

  448.   return false;

  449. }

  450. //------------------------------------------------------------------------------

  451. /** Wait for start block token */

  452. uint8_t Sd2Card::waitStartBlock(void) {

  453.   unsigned int t0 = millis();

  454.   while ((status_ = spiRec()) == 0XFF) {

  455.     unsigned int d = millis() - t0;

  456.     if (d > SD_READ_TIMEOUT) {

  457.       return false; // SD_CARD_ERROR_READ_TIMEOUT

  458.     }

  459.   }

  460.   if (status_ != DATA_START_BLOCK) {

  461.     return false; // SD_CARD_ERROR_READ

  462.   }

  463.   return true;

  464. }

  465. //------------------------------------------------------------------------------

  466. /**

  467.  * Writes a 512 byte block to an SD card.

  468.  *

  469.  * \param[in] blockNumber Logical block to be written.

  470.  * \param[in] src Pointer to the location of the data to be written.

  471.  * \return The value one, true, is returned for success and

  472.  * the value zero, false, is returned for failure.

  473.  */

  474. uint8_t Sd2Card::SD_writeBlock(uint32_t blockNumber, const uint8_t* src) {

  475. #if SD_PROTECT_BLOCK_ZERO

  476.   // don't allow write to first block

  477.   if (blockNumber == 0) {

  478.     goto fail; // SD_CARD_ERROR_WRITE_BLOCK_ZERO

  479.   }

  480. #endif  // SD_PROTECT_BLOCK_ZERO

  481. 

  482.   // use address if not SDHC card

  483.   if (type_ != SD_CARD_TYPE_SDHC) blockNumber <<= 9;

  484.   chipSelectLow();

  485.   if (cardCommand(CMD24, blockNumber)) {

  486.     goto fail; // SD_CARD_ERROR_CMD24

  487.   }

  488.   if (!writeData(DATA_START_BLOCK, src)) goto fail;

  489. 

  490.   // wait for flash programming to complete

  491.   if (!waitNotBusy(SD_WRITE_TIMEOUT)) {

  492.     goto fail; // SD_CARD_ERROR_WRITE_TIMEOUT

  493.   }

  494.   // response is r2 so get and check two bytes for nonzero

  495.   if (cardCommand(CMD13, 0) || spiRec()) {

  496.     goto fail; // SD_CARD_ERROR_WRITE_PROGRAMMING

  497.   }

  498.   chipSelectHigh();

  499.   return true;

  500. 

  501.  fail:

  502.   chipSelectHigh();

  503.   return false;

  504. }

  505. //------------------------------------------------------------------------------

  506. // send one block of data for write block or write multiple blocks

  507. uint8_t Sd2Card::writeData(uint8_t token, const uint8_t* src) {

  508. #if defined(OPTIMIZE_HARDWARE_SPI) && !defined(USE_TEENSY4_SPI)

  509. 

  510.   // send data - optimized loop

  511.   SPDR = token;

  512. 

  513.   // send two byte per iteration

  514.   for (uint16_t i = 0; i < 512; i += 2) {

  515.     while (!(SPSR & (1 << SPIF)));

  516.     SPDR = src[i];

  517.     while (!(SPSR & (1 << SPIF)));

  518.     SPDR = src[i+1];

  519.   }

  520. 

  521.   // wait for last data byte

  522.   while (!(SPSR & (1 << SPIF)));

  523. 

  524. #else  // OPTIMIZE_HARDWARE_SPI

  525.   spiSend(token);

  526.   for (uint16_t i = 0; i < 512; i++) {

  527.     spiSend(src[i]); 

  528.   }

  529. #endif  // OPTIMIZE_HARDWARE_SPI

  530.   spiSend(0xff);  // dummy crc

  531.   spiSend(0xff);  // dummy crc

  532. 

  533.   status_ = spiRec();

  534.   if ((status_ & DATA_RES_MASK) != DATA_RES_ACCEPTED) {

  535.     return false; // SD_CARD_ERROR_WRITE

  536.   }

  537.   return true;

  538. }