Add File::availableForWrite API

Author: sandeepmistry

src/File.cpp

@@ -73,6 +73,13 @@ size_t File::write(const uint8_t *buf, size_t size) {
   return t;
 }
 
+int File::availableForWrite() {
+  if (_file) {
+    return _file->availableForWrite();
+  }
+  return 0;
+}
+
 int File::peek() {
   if (! _file) {
     return 0;

src/SD.h

@@ -35,6 +35,7 @@ namespace SDLib {
       File(void);      // 'empty' constructor
       virtual size_t write(uint8_t);
       virtual size_t write(const uint8_t *buf, size_t size);
+      virtual int availableForWrite();
       virtual int read();
       virtual int peek();
       virtual int available();

src/utility/Sd2Card.cpp

@@ -608,10 +608,11 @@ uint8_t Sd2Card::waitStartBlock(void) {
 
    \param[in] blockNumber Logical block to be written.
    \param[in] src Pointer to the location of the data to be written.
+   \param[in] sync If the write should be synchronous.
    \return The value one, true, is returned for success and
    the value zero, false, is returned for failure.
 */
-uint8_t Sd2Card::writeBlock(uint32_t blockNumber, const uint8_t* src) {
+uint8_t Sd2Card::writeBlock(uint32_t blockNumber, const uint8_t* src, uint8_t sync) {
   #if SD_PROTECT_BLOCK_ZERO
   // don't allow write to first block
   if (blockNumber == 0) {
@@ -631,16 +632,17 @@ uint8_t Sd2Card::writeBlock(uint32_t blockNumber, const uint8_t* src) {
   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;
+  if (sync) {
+    // 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;
@@ -760,3 +762,16 @@ uint8_t Sd2Card::writeStop(void) {
   chipSelectHigh();
   return false;
 }
+//------------------------------------------------------------------------------
+/** Check if the SD card is busy
+
+  \return The value one, true, is returned when is busy and
+   the value zero, false, is returned for when is NOT busy.
+*/
+uint8_t Sd2Card::isBusy(void) {
+  chipSelectLow();
+  byte b = spiRec();
+  chipSelectHigh();
+
+  return (b != 0XFF);
+}

src/utility/Sd2Card.h

@@ -236,10 +236,11 @@ class Sd2Card {
     uint8_t type(void) const {
       return type_;
     }
-    uint8_t writeBlock(uint32_t blockNumber, const uint8_t* src);
+    uint8_t writeBlock(uint32_t blockNumber, const uint8_t* src, uint8_t sync);
     uint8_t writeData(const uint8_t* src);
     uint8_t writeStart(uint32_t blockNumber, uint32_t eraseCount);
     uint8_t writeStop(void);
+    uint8_t isBusy(void);
   private:
     uint32_t block_;
     uint8_t chipSelectPin_;

src/utility/SdFat.h

@@ -320,6 +320,7 @@ class SdFile : public Print {
     void write_P(PGM_P str);
     void writeln_P(PGM_P str);
     #endif
+    int availableForWrite(void);
     //------------------------------------------------------------------------------
     #if ALLOW_DEPRECATED_FUNCTIONS
     // Deprecated functions  - suppress cpplint warnings with NOLINT comment
@@ -610,8 +611,11 @@ class SdVolume {
                      uint16_t count, uint8_t* dst) {
       return sdCard_->readData(block, offset, count, dst);
     }
-    uint8_t writeBlock(uint32_t block, const uint8_t* dst) {
-      return sdCard_->writeBlock(block, dst);
+    uint8_t writeBlock(uint32_t block, const uint8_t* dst, uint8_t sync) {
+      return sdCard_->writeBlock(block, dst, sync);
+    }
+    uint8_t isBusy(void) {
+      return sdCard_->isBusy();
     }
 };
 #endif  // SdFat_h

src/utility/SdFile.cpp

@@ -1383,7 +1383,7 @@ size_t SdFile::write(const void* buf, uint16_t nbyte) {
       if (SdVolume::cacheBlockNumber_ == block) {
         SdVolume::cacheBlockNumber_ = 0XFFFFFFFF;
       }
-      if (!vol_->writeBlock(block, src)) {
+      if (!vol_->writeBlock(block, src, 0)) {
         goto writeErrorReturn;
       }
       src += 512;
@@ -1473,3 +1473,25 @@ void SdFile::writeln_P(PGM_P str) {
   println();
 }
 #endif
+//------------------------------------------------------------------------------
+int SdFile::availableForWrite() {
+  if (!isFile() || !(flags_ & O_WRITE)) {
+    return 0;
+  }
+
+  // seek to end of file if append flag
+  if ((flags_ & O_APPEND) && curPosition_ != fileSize_) {
+    if (!seekEnd()) {
+      return 0;
+    }
+  }
+
+  if (vol_->isBusy()) {
+    return 0;
+  }
+
+  uint16_t blockOffset = curPosition_ & 0X1FF;
+  uint16_t n = 512 - blockOffset;
+
+  return n;
+}

src/utility/SdVolume.cpp

@@ -110,12 +110,12 @@ uint8_t SdVolume::allocContiguous(uint32_t count, uint32_t* curCluster) {
 //------------------------------------------------------------------------------
 uint8_t SdVolume::cacheFlush(void) {
   if (cacheDirty_) {
-    if (!sdCard_->writeBlock(cacheBlockNumber_, cacheBuffer_.data)) {
+    if (!sdCard_->writeBlock(cacheBlockNumber_, cacheBuffer_.data, 1)) {
       return false;
     }
     // mirror FAT tables
     if (cacheMirrorBlock_) {
-      if (!sdCard_->writeBlock(cacheMirrorBlock_, cacheBuffer_.data)) {
+      if (!sdCard_->writeBlock(cacheMirrorBlock_, cacheBuffer_.data, 1)) {
         return false;
       }
       cacheMirrorBlock_ = 0;