4433 lines
125 KiB
C++
4433 lines
125 KiB
C++
/* Arduino SdFat Library
|
|
* Copyright (C) 2012 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/>.
|
|
*/
|
|
#include "Repetier.h"
|
|
#if SDSUPPORT
|
|
#if defined(ARDUINO) && ARDUINO >= 100
|
|
#include "Arduino.h"
|
|
#else
|
|
#include "WProgram.h"
|
|
#define COMPAT_PRE1
|
|
#endif
|
|
//#include <SdFat.h>
|
|
|
|
extern int8_t RFstricmp(const char* s1, const char* s2);
|
|
extern int8_t RFstrnicmp(const char* s1, const char* s2, size_t n);
|
|
|
|
//#define GLENN_DEBUG
|
|
|
|
//------------------------------------------------------------------------------
|
|
//------------------------------------------------------------------------------
|
|
static void pstrPrint(FSTRINGPARAM(str)) {
|
|
Com::printF(str);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
static void pstrPrintln(FSTRINGPARAM(str)) {
|
|
Com::printFLN(str);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
* Initialize an SdFat object.
|
|
*
|
|
* Initializes the SD card, SD volume, and root directory.
|
|
*
|
|
* \param[in] chipSelectPin SD chip select pin. See Sd2Card::init().
|
|
* \param[in] sckRateID value for SPI SCK rate. See Sd2Card::init().
|
|
*
|
|
* \return The value one, true, is returned for success and
|
|
* the value zero, false, is returned for failure.
|
|
*/
|
|
bool SdFat::begin(uint8_t chipSelectPin, uint8_t sckRateID) {
|
|
return card_.init(sckRateID, chipSelectPin) && vol_.init(&card_) && chdir(1);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
/** Change a volume's working directory to root
|
|
*
|
|
* Changes the volume's working directory to the SD's root directory.
|
|
* Optionally set the current working directory to the volume's
|
|
* working directory.
|
|
*
|
|
* \param[in] set_cwd Set the current working directory to this volume's
|
|
* working directory if true.
|
|
*
|
|
* \return The value one, true, is returned for success and
|
|
* the value zero, false, is returned for failure.
|
|
*/
|
|
bool SdFat::chdir(bool set_cwd) {
|
|
if (set_cwd) SdBaseFile::cwd_ = &vwd_;
|
|
if (vwd_.isOpen()) vwd_.close();
|
|
return vwd_.openRoot(&vol_);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Change a volume's working directory
|
|
*
|
|
* Changes the volume working directory to the \a path subdirectory.
|
|
* Optionally set the current working directory to the volume's
|
|
* working directory.
|
|
*
|
|
* Example: If the volume's working directory is "/DIR", chdir("SUB")
|
|
* will change the volume's working directory from "/DIR" to "/DIR/SUB".
|
|
*
|
|
* If path is "/", the volume's working directory will be changed to the
|
|
* root directory
|
|
*
|
|
* \param[in] path The name of the subdirectory.
|
|
*
|
|
* \param[in] set_cwd Set the current working directory to this volume's
|
|
* working directory if true.
|
|
*
|
|
* \return The value one, true, is returned for success and
|
|
* the value zero, false, is returned for failure.
|
|
*/
|
|
bool SdFat::chdir(const char *path, bool set_cwd) {
|
|
SdBaseFile dir;
|
|
if (path[0] == '/' && path[1] == '\0') return chdir(set_cwd);
|
|
|
|
if (!dir.open(&vwd_, path, O_READ)) goto fail;
|
|
if (!dir.isDir()) goto fail;
|
|
vwd_ = dir;
|
|
if (set_cwd) SdBaseFile::cwd_ = &vwd_;
|
|
return true;
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Set the current working directory to a volume's working directory.
|
|
*
|
|
* This is useful with multiple SD cards.
|
|
*
|
|
* The current working directory is changed to this volume's working directory.
|
|
*
|
|
* This is like the Windows/DOS \<drive letter>: command.
|
|
*/
|
|
void SdFat::chvol() {
|
|
SdBaseFile::cwd_ = &vwd_;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** %Print any SD error code and halt. */
|
|
void SdFat::errorHalt() {
|
|
errorPrint();
|
|
while (1);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** %Print msg, any SD error code, and halt.
|
|
*
|
|
* \param[in] msg Message to print.
|
|
*/
|
|
void SdFat::errorHalt(char const* msg) {
|
|
errorPrint(msg);
|
|
while (1);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** %Print msg, any SD error code, and halt.
|
|
*
|
|
* \param[in] msg Message in program space (flash memory) to print.
|
|
*/
|
|
void SdFat::errorHalt_P(FSTRINGPARAM(msg)) {
|
|
errorPrint_P(msg);
|
|
while (1);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** %Print any SD error code. */
|
|
void SdFat::errorPrint() {
|
|
if (!card_.errorCode()) return;
|
|
Com::printFLN(Com::tSDErrorCode,card_.errorCode());
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** %Print msg, any SD error code.
|
|
*
|
|
* \param[in] msg Message to print.
|
|
*/
|
|
void SdFat::errorPrint(char const* msg) {
|
|
Com::printFLN(Com::tError,msg);
|
|
errorPrint();
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** %Print msg, any SD error code.
|
|
*
|
|
* \param[in] msg Message in program space (flash memory) to print.
|
|
*/
|
|
void SdFat::errorPrint_P(FSTRINGPARAM(msg)) {
|
|
Com::printF(Com::tError);
|
|
Com::printFLN(msg);
|
|
errorPrint();
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
* Test for the existence of a file.
|
|
*
|
|
* \param[in] name Name of the file to be tested for.
|
|
*
|
|
* \return true if the file exists else false.
|
|
*/
|
|
bool SdFat::exists(const char* name) {
|
|
return vwd_.exists(name);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** %Print error details and halt after SdFat::init() fails. */
|
|
void SdFat::initErrorHalt() {
|
|
initErrorPrint();
|
|
while (1);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/**Print message, error details, and halt after SdFat::init() fails.
|
|
*
|
|
* \param[in] msg Message to print.
|
|
*/
|
|
void SdFat::initErrorHalt(char const *msg) {
|
|
Com::print(msg);
|
|
Com::println();
|
|
initErrorHalt();
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/**Print message, error details, and halt after SdFat::init() fails.
|
|
*
|
|
* \param[in] msg Message in program space (flash memory) to print.
|
|
*/
|
|
void SdFat::initErrorHalt_P(FSTRINGPARAM(msg)) {
|
|
pstrPrintln(msg);
|
|
initErrorHalt();
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Print error details after SdFat::init() fails. */
|
|
void SdFat::initErrorPrint() {
|
|
if (card_.errorCode()) {
|
|
pstrPrintln(PSTR("Can't access SD card. Do not reformat."));
|
|
if (card_.errorCode() == SD_CARD_ERROR_CMD0) {
|
|
pstrPrintln(PSTR("No card, wrong chip select pin, or SPI problem?"));
|
|
}
|
|
errorPrint();
|
|
} else if (vol_.fatType() == 0) {
|
|
pstrPrintln(PSTR("Invalid format, reformat SD."));
|
|
} else if (!vwd_.isOpen()) {
|
|
pstrPrintln(PSTR("Can't open root directory."));
|
|
} else {
|
|
pstrPrintln(PSTR("No error found."));
|
|
}
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/**Print message and error details and halt after SdFat::init() fails.
|
|
*
|
|
* \param[in] msg Message to print.
|
|
*/
|
|
void SdFat::initErrorPrint(char const *msg) {
|
|
Com::print(msg);
|
|
Com::println();
|
|
initErrorPrint();
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/**Print message and error details after SdFat::init() fails.
|
|
*
|
|
* \param[in] msg Message in program space (flash memory) to print.
|
|
*/
|
|
void SdFat::initErrorPrint_P(FSTRINGPARAM(msg)) {
|
|
pstrPrintln(msg);
|
|
initErrorHalt();
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Make a subdirectory in the volume working directory.
|
|
*
|
|
* \param[in] path A path with a valid 8.3 DOS name for the subdirectory.
|
|
*
|
|
* \param[in] pFlag Create missing parent directories if true.
|
|
*
|
|
* \return The value one, true, is returned for success and
|
|
* the value zero, false, is returned for failure.
|
|
*/
|
|
bool SdFat::mkdir(const char* path, bool pFlag) {
|
|
SdBaseFile sub;
|
|
return sub.mkdir(&vwd_, path, pFlag);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Remove a file from the volume working directory.
|
|
*
|
|
* \param[in] path A path with a valid 8.3 DOS name for the file.
|
|
*
|
|
* \return The value one, true, is returned for success and
|
|
* the value zero, false, is returned for failure.
|
|
*/
|
|
bool SdFat::remove(const char* path) {
|
|
return SdBaseFile::remove(&vwd_, path);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Rename a file or subdirectory.
|
|
*
|
|
* \param[in] oldPath Path name to the file or subdirectory to be renamed.
|
|
*
|
|
* \param[in] newPath New path name of the file or subdirectory.
|
|
*
|
|
* The \a newPath object must not exist before the rename call.
|
|
*
|
|
* The file to be renamed must not be open. The directory entry may be
|
|
* moved and file system corruption could occur if the file is accessed by
|
|
* a file object that was opened before the rename() call.
|
|
*
|
|
* \return The value one, true, is returned for success and
|
|
* the value zero, false, is returned for failure.
|
|
*/
|
|
bool SdFat::rename(const char *oldPath, const char *newPath) {
|
|
SdBaseFile file;
|
|
if (!file.open(oldPath, O_READ)) return false;
|
|
return file.rename(&vwd_, newPath);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Remove a subdirectory from the volume's working directory.
|
|
*
|
|
* \param[in] path A path with a valid 8.3 DOS name for the subdirectory.
|
|
*
|
|
* The subdirectory file will be removed only if it is empty.
|
|
*
|
|
* \return The value one, true, is returned for success and
|
|
* the value zero, false, is returned for failure.
|
|
*/
|
|
bool SdFat::rmdir(const char* path) {
|
|
SdBaseFile sub;
|
|
if (!sub.open(path, O_READ)) return false;
|
|
return sub.rmdir();
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Truncate a file to a specified length. The current file position
|
|
* will be maintained if it is less than or equal to \a length otherwise
|
|
* it will be set to end of file.
|
|
*
|
|
* \param[in] path A path with a valid 8.3 DOS name for the file.
|
|
* \param[in] length The desired length for the file.
|
|
*
|
|
* \return The value one, true, is returned for success and
|
|
* the value zero, false, is returned for failure.
|
|
* Reasons for failure include file is read only, file is a directory,
|
|
* \a length is greater than the current file size or an I/O error occurs.
|
|
*/
|
|
bool SdFat::truncate(const char* path, uint32_t length) {
|
|
SdBaseFile file;
|
|
if (!file.open(path, O_WRITE)) return false;
|
|
return file.truncate(length);
|
|
}
|
|
|
|
// macro for debug
|
|
#define DBG_FAIL_MACRO // Serial.println(__LINE__)
|
|
//------------------------------------------------------------------------------
|
|
// pointer to cwd directory
|
|
SdBaseFile* SdBaseFile::cwd_ = 0;
|
|
// callback function for date/time
|
|
void (*SdBaseFile::dateTime_)(uint16_t* date, uint16_t* time) = 0;
|
|
//------------------------------------------------------------------------------
|
|
// add a cluster to a file
|
|
bool SdBaseFile::addCluster() {
|
|
if (!vol_->allocContiguous(1, &curCluster_)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// if first cluster of file link to directory entry
|
|
if (firstCluster_ == 0) {
|
|
firstCluster_ = curCluster_;
|
|
flags_ |= F_FILE_DIR_DIRTY;
|
|
}
|
|
return true;
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
// Add a cluster to a directory file and zero the cluster.
|
|
// return with first block of cluster in the cache
|
|
cache_t* SdBaseFile::addDirCluster() {
|
|
uint32_t block;
|
|
cache_t* pc;
|
|
// max folder size
|
|
if (fileSize_/sizeof(dir_t) >= 0XFFFF) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
if (!addCluster()) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
block = vol_->clusterStartBlock(curCluster_);
|
|
pc = vol_->cacheFetch(block, SdVolume::CACHE_RESERVE_FOR_WRITE);
|
|
if (!pc) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
memset(pc, 0, 512);
|
|
// zero rest of clusters
|
|
for (uint8_t i = 1; i < vol_->blocksPerCluster_; i++) {
|
|
if (!vol_->writeBlock(block + i, pc->data)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
}
|
|
// Increase directory file size by cluster size
|
|
fileSize_ += 512UL*vol_->blocksPerCluster_;
|
|
return pc;
|
|
|
|
fail:
|
|
return 0;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
// cache a file's directory entry
|
|
// return pointer to cached entry or null for failure
|
|
dir_t* SdBaseFile::cacheDirEntry(uint8_t action) {
|
|
cache_t* pc;
|
|
pc = vol_->cacheFetch(dirBlock_, action);
|
|
if (!pc) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
return pc->dir + dirIndex_;
|
|
fail:
|
|
return 0;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Close a file and force cached data and directory information
|
|
* to be written to the storage device.
|
|
*
|
|
* \return The value one, true, is returned for success and
|
|
* the value zero, false, is returned for failure.
|
|
* Reasons for failure include no file is open or an I/O error.
|
|
*/
|
|
bool SdBaseFile::close() {
|
|
bool rtn = sync();
|
|
type_ = FAT_FILE_TYPE_CLOSED;
|
|
return rtn;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Check for contiguous file and return its raw block range.
|
|
*
|
|
* \param[out] bgnBlock the first block address for the file.
|
|
* \param[out] endBlock the last block address for the file.
|
|
*
|
|
* \return The value one, true, is returned for success and
|
|
* the value zero, false, is returned for failure.
|
|
* Reasons for failure include file is not contiguous, file has zero length
|
|
* or an I/O error occurred.
|
|
*/
|
|
bool SdBaseFile::contiguousRange(uint32_t* bgnBlock, uint32_t* endBlock) {
|
|
// error if no blocks
|
|
if (firstCluster_ == 0) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
for (uint32_t c = firstCluster_; ; c++) {
|
|
uint32_t next;
|
|
if (!vol_->fatGet(c, &next)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// check for contiguous
|
|
if (next != (c + 1)) {
|
|
// error if not end of chain
|
|
if (!vol_->isEOC(next)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
*bgnBlock = vol_->clusterStartBlock(firstCluster_);
|
|
*endBlock = vol_->clusterStartBlock(c)
|
|
+ vol_->blocksPerCluster_ - 1;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Create and open a new contiguous file of a specified size.
|
|
*
|
|
* \note This function only supports short DOS 8.3 names.
|
|
* See open() for more information.
|
|
*
|
|
* \param[in] dirFile The directory where the file will be created.
|
|
* \param[in] path A path with a valid DOS 8.3 file name.
|
|
* \param[in] size The desired file size.
|
|
*
|
|
* \return The value one, true, is returned for success and
|
|
* the value zero, false, is returned for failure.
|
|
* Reasons for failure include \a path contains
|
|
* an invalid DOS 8.3 file name, the FAT volume has not been initialized,
|
|
* a file is already open, the file already exists, the root
|
|
* directory is full or an I/O error.
|
|
*
|
|
*/
|
|
bool SdBaseFile::createContiguous(SdBaseFile* dirFile,
|
|
const char* path, uint32_t size) {
|
|
uint32_t count;
|
|
// don't allow zero length file
|
|
if (size == 0) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
if (!open(dirFile, path, O_CREAT | O_EXCL | O_RDWR)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// calculate number of clusters needed
|
|
count = ((size - 1) >> (vol_->clusterSizeShift_ + 9)) + 1;
|
|
|
|
// allocate clusters
|
|
if (!vol_->allocContiguous(count, &firstCluster_)) {
|
|
remove();
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
fileSize_ = size;
|
|
|
|
// insure sync() will update dir entry
|
|
flags_ |= F_FILE_DIR_DIRTY;
|
|
|
|
return sync();
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Return a file's directory entry.
|
|
*
|
|
* \param[out] dir Location for return of the file's directory entry.
|
|
*
|
|
* \return The value one, true, is returned for success and
|
|
* the value zero, false, is returned for failure.
|
|
*/
|
|
bool SdBaseFile::dirEntry(dir_t* dir) {
|
|
dir_t* p;
|
|
// make sure fields on SD are correct
|
|
if (!sync()) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// read entry
|
|
p = cacheDirEntry(SdVolume::CACHE_FOR_READ);
|
|
if (!p) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// copy to caller's struct
|
|
memcpy(dir, p, sizeof(dir_t));
|
|
return true;
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Format the name field of \a dir into the 13 byte array
|
|
* \a name in standard 8.3 short name format.
|
|
*
|
|
* \param[in] dir The directory structure containing the name.
|
|
* \param[out] name A 13 byte char array for the formatted name.
|
|
*/
|
|
void SdBaseFile::dirName(const dir_t& dir, char* name) {
|
|
uint8_t j = 0;
|
|
for (uint8_t i = 0; i < 11; i++) {
|
|
if (dir.name[i] == ' ') continue;
|
|
if (i == 8) name[j++] = '.';
|
|
name[j++] = dir.name[i];
|
|
}
|
|
name[j] = 0;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Test for the existence of a file in a directory
|
|
*
|
|
* \param[in] name Name of the file to be tested for.
|
|
*
|
|
* The calling instance must be an open directory file.
|
|
*
|
|
* dirFile.exists("TOFIND.TXT") searches for "TOFIND.TXT" in the directory
|
|
* dirFile.
|
|
*
|
|
* \return true if the file exists else false.
|
|
*/
|
|
bool SdBaseFile::exists(const char* name) {
|
|
SdBaseFile file;
|
|
return file.open(this, name, O_READ);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
* Get a string from a file.
|
|
*
|
|
* fgets() reads bytes from a file into the array pointed to by \a str, until
|
|
* \a num - 1 bytes are read, or a delimiter is read and transferred to \a str,
|
|
* or end-of-file is encountered. The string is then terminated
|
|
* with a null byte.
|
|
*
|
|
* fgets() deletes CR, '\\r', from the string. This insures only a '\\n'
|
|
* terminates the string for Windows text files which use CRLF for newline.
|
|
*
|
|
* \param[out] str Pointer to the array where the string is stored.
|
|
* \param[in] num Maximum number of characters to be read
|
|
* (including the final null byte). Usually the length
|
|
* of the array \a str is used.
|
|
* \param[in] delim Optional set of delimiters. The default is "\n".
|
|
*
|
|
* \return For success fgets() returns the length of the string in \a str.
|
|
* If no data is read, fgets() returns zero for EOF or -1 if an error occurred.
|
|
**/
|
|
int16_t SdBaseFile::fgets(char* str, int16_t num, char* delim) {
|
|
char ch;
|
|
int16_t n = 0;
|
|
int16_t r = -1;
|
|
while ((n + 1) < num && (r = read(&ch, 1)) == 1) {
|
|
// delete CR
|
|
if (ch == '\r') continue;
|
|
str[n++] = ch;
|
|
if (!delim) {
|
|
if (ch == '\n') break;
|
|
} else {
|
|
if (strchr(delim, ch)) break;
|
|
}
|
|
}
|
|
if (r < 0) {
|
|
// read error
|
|
return -1;
|
|
}
|
|
str[n] = '\0';
|
|
return n;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Get a file's name
|
|
*
|
|
* \param[out] name An array of 13 characters for the file's name.
|
|
*
|
|
* \return The value one, true, is returned for success and
|
|
* the value zero, false, is returned for failure.
|
|
*/
|
|
bool SdBaseFile::getFilename(char* name) {
|
|
dir_t* p;
|
|
if (!isOpen()) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
if (isRoot()) {
|
|
name[0] = '/';
|
|
name[1] = '\0';
|
|
return true;
|
|
}
|
|
// cache entry
|
|
p = cacheDirEntry(SdVolume::CACHE_FOR_READ);
|
|
if (!p) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// format name
|
|
dirName(*p, name);
|
|
return true;
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
void SdBaseFile::getpos(FatPos_t* pos) {
|
|
pos->position = curPosition_;
|
|
pos->cluster = curCluster_;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** List directory contents to stdOut.
|
|
*
|
|
* \param[in] flags The inclusive OR of
|
|
*
|
|
* LS_DATE - %Print file modification date
|
|
*
|
|
* LS_SIZE - %Print file size.
|
|
*
|
|
* LS_R - Recursive list of subdirectories.
|
|
*/
|
|
void SdBaseFile::ls(uint8_t flags) {
|
|
ls(flags, 0);
|
|
}
|
|
|
|
uint8_t SdBaseFile::lsRecursive(SdBaseFile *parent, uint8_t level, char *findFilename, SdBaseFile *pParentFound)
|
|
{
|
|
dir_t *p = NULL;
|
|
uint8_t cnt=0;
|
|
char *oldpathend = pathend;
|
|
|
|
parent->rewind();
|
|
|
|
while ((p = parent->getLongFilename(p, tempLongFilename, 0, NULL)))
|
|
{
|
|
HAL::pingWatchdog();
|
|
if (! (DIR_IS_FILE(p) || DIR_IS_SUBDIR(p))) continue;
|
|
if (strcmp(tempLongFilename, "..") == 0) continue;
|
|
if( DIR_IS_SUBDIR(p))
|
|
{
|
|
if(level>=SD_MAX_FOLDER_DEPTH) continue; // can't go deeper
|
|
if(level<SD_MAX_FOLDER_DEPTH)
|
|
{
|
|
if (findFilename == NULL)
|
|
{
|
|
if(level)
|
|
{
|
|
Com::print(fullName);
|
|
Com::printF(Com::tSlash);
|
|
}
|
|
Com::print(tempLongFilename);
|
|
Com::printFLN(Com::tSlash); //End with / to mark it as directory entry, so we can see empty directories.
|
|
}
|
|
}
|
|
SdBaseFile next;
|
|
char *tmp;
|
|
|
|
if(level) strcat(fullName, "/");
|
|
|
|
strcat(fullName, tempLongFilename);
|
|
uint16_t index = (parent->curPosition()-31) >> 5;
|
|
|
|
if(next.open(parent, index, O_READ))
|
|
{
|
|
if (next.lsRecursive(&next,level+1, findFilename, pParentFound))
|
|
return true;
|
|
}
|
|
parent->seekSet(32 * (index + 1));
|
|
if ((tmp = strrchr(fullName, '/'))!= NULL)
|
|
*tmp = 0;
|
|
else
|
|
*fullName = 0;
|
|
}
|
|
else
|
|
{
|
|
if (findFilename != NULL)
|
|
{
|
|
int8_t cFullname;
|
|
|
|
cFullname = strlen(fullName);
|
|
if (RFstrnicmp(fullName, findFilename, cFullname) == 0)
|
|
{
|
|
if (cFullname > 0)
|
|
cFullname++;
|
|
if (RFstricmp(tempLongFilename, findFilename+cFullname) == 0)
|
|
{
|
|
if (pParentFound != NULL)
|
|
*pParentFound = *parent;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(level)
|
|
{
|
|
Com::print(fullName);
|
|
Com::printF(Com::tSlash);
|
|
}
|
|
Com::print(tempLongFilename);
|
|
#if SD_EXTENDED_DIR
|
|
Com::printF(Com::tSpace,(long)p->fileSize);
|
|
#endif
|
|
Com::println();
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/** List directory contents.
|
|
*
|
|
* \param[in] pr Print stream for list.
|
|
*
|
|
* \param[in] flags The inclusive OR of
|
|
*
|
|
* LS_DATE - %Print file modification date
|
|
*
|
|
* LS_SIZE - %Print file size.
|
|
*
|
|
* LS_R - Recursive list of subdirectories.
|
|
*
|
|
* \param[in] indent Amount of space before file name. Used for recursive
|
|
* list to indicate subdirectory level.
|
|
*/
|
|
void SdBaseFile::ls(uint8_t flags, uint8_t indent) {
|
|
SdBaseFile parent;
|
|
|
|
rewind();
|
|
*fullName = 0;
|
|
pathend = fullName;
|
|
parent = *this;
|
|
lsRecursive(&parent, 0, NULL, NULL);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
// saves 32 bytes on stack for ls recursion
|
|
// return 0 - EOF, 1 - normal file, or 2 - directory
|
|
int8_t SdBaseFile::lsPrintNext(uint8_t flags, uint8_t indent) {
|
|
dir_t dir;
|
|
uint8_t w = 0;
|
|
while (1) {
|
|
if (read(&dir, sizeof(dir)) != sizeof(dir)) return 0;
|
|
if (dir.name[0] == DIR_NAME_FREE) return 0;
|
|
|
|
// skip deleted entry and entries for . and ..
|
|
if (dir.name[0] != DIR_NAME_DELETED && dir.name[0] != '.'
|
|
&& DIR_IS_FILE_OR_SUBDIR(&dir)) break;
|
|
}
|
|
// indent for dir level
|
|
for (uint8_t i = 0; i < indent; i++) Com::print(' ');
|
|
|
|
printDirName(dir, flags & (LS_DATE | LS_SIZE) ? 14 : 0, true);
|
|
|
|
// print modify date/time if requested
|
|
if (flags & LS_DATE) {
|
|
Com::print(' ');
|
|
printFatDate(dir.lastWriteDate);
|
|
Com::print(' ');
|
|
printFatTime(dir.lastWriteTime);
|
|
}
|
|
// print size if requested
|
|
if (!DIR_IS_SUBDIR(&dir) && (flags & LS_SIZE)) {
|
|
Com::print(' ');
|
|
Com::print(dir.fileSize);
|
|
}
|
|
Com::println();
|
|
return DIR_IS_FILE(&dir) ? 1 : 2;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
// format directory name field from a 8.3 name string
|
|
FSTRINGVALUE(illegalFileChars,"|<>^+=?/[];,*\"\\")
|
|
bool SdBaseFile::make83Name(const char* str, uint8_t* name, const char** ptr) {
|
|
uint8_t c;
|
|
uint8_t n = 7; // max index for part before dot
|
|
uint8_t i = 0;
|
|
// blank fill name and extension
|
|
while (i < 11) name[i++] = ' ';
|
|
i = 0;
|
|
while (*str != '\0' && *str != '/') {
|
|
c = *str++;
|
|
if (c == '.') {
|
|
if (n == 10) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail; // only one dot allowed
|
|
}
|
|
n = 10; // max index for full 8.3 name
|
|
i = 8; // place for extension
|
|
} else {
|
|
// illegal FAT characters
|
|
#define FLASH_ILLEGAL_CHARS
|
|
#ifdef FLASH_ILLEGAL_CHARS
|
|
// store chars in flash
|
|
FSTRINGPARAM(p);
|
|
p = illegalFileChars;
|
|
uint8_t b;
|
|
while ((b = HAL::readFlashByte(p++))) {
|
|
if (b == c) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
}
|
|
#else // FLASH_ILLEGAL_CHARS
|
|
// store chars in RAM
|
|
if (strchr("|<>^+=?/[];,*\"\\", c)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
#endif // FLASH_ILLEGAL_CHARS
|
|
|
|
// check size and only allow ASCII printable characters
|
|
if (i > n || c < 0X20 || c > 0X7E) {
|
|
c = '_';
|
|
}
|
|
// only upper case allowed in 8.3 names - convert lower to upper
|
|
name[i++] = c < 'a' || c > 'z' ? c : c + ('A' - 'a');
|
|
}
|
|
}
|
|
*ptr = str;
|
|
// must have a file name, extension is optional
|
|
return name[0] != ' ';
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Make a new directory.
|
|
*
|
|
* \param[in] parent An open SdFat instance for the directory that will contain
|
|
* the new directory.
|
|
*
|
|
* \param[in] path A path with a valid 8.3 DOS name for the new directory.
|
|
*
|
|
* \param[in] pFlag Create missing parent directories if true.
|
|
*
|
|
* \return The value one, true, is returned for success and
|
|
* the value zero, false, is returned for failure.
|
|
* Reasons for failure include this file is already open, \a parent is not a
|
|
* directory, \a path is invalid or already exists in \a parent.
|
|
*/
|
|
bool SdBaseFile::mkdir(SdBaseFile* parent, const char* path, bool pFlag) {
|
|
|
|
uint8_t dname[LONG_FILENAME_LENGTH+1];
|
|
SdBaseFile newParent;
|
|
|
|
if (openParentReturnFile(parent, path, dname, &newParent, pFlag))
|
|
{
|
|
return mkdir(&newParent, dname);
|
|
}
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
bool SdBaseFile::mkdir(SdBaseFile* parent, const uint8_t *dname) {
|
|
dir_t d;
|
|
|
|
if (!parent->isDir()) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
|
|
// create a normal file
|
|
if (!open(parent, dname, O_CREAT | O_EXCL | O_RDWR, true)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
|
|
// make entry for '.'
|
|
memset(&d, 0, sizeof(d));
|
|
d.creationDate = FAT_DEFAULT_DATE;
|
|
d.creationTime = FAT_DEFAULT_TIME;
|
|
d.lastAccessDate = d.creationDate;
|
|
d.lastWriteDate = d.creationDate;
|
|
d.lastWriteTime = d.creationTime;
|
|
|
|
d.name[0] = '.';
|
|
d.attributes = DIR_ATT_DIRECTORY;
|
|
for (uint8_t i = 1; i < 11; i++) d.name[i] = ' ';
|
|
|
|
if (write(&d, sizeof(dir_t)) < 0)
|
|
goto fail;
|
|
sync();
|
|
|
|
// make entry for '..'
|
|
d.name[1] = '.';
|
|
if (parent->isRoot()) {
|
|
d.firstClusterLow = 0;
|
|
d.firstClusterHigh = 0;
|
|
} else {
|
|
d.firstClusterLow = parent->firstCluster_ & 0XFFFF;
|
|
d.firstClusterHigh = parent->firstCluster_ >> 16;
|
|
}
|
|
if (write(&d, sizeof(dir_t)) < 0)
|
|
goto fail;
|
|
sync();
|
|
memset(&d, 0, sizeof(dir_t));
|
|
if (write(&d, sizeof(dir_t)) < 0)
|
|
goto fail;
|
|
sync();
|
|
// fileSize_ = 0;
|
|
type_ = FAT_FILE_TYPE_SUBDIR;
|
|
flags_ |= F_FILE_DIR_DIRTY;
|
|
return true;
|
|
fail:
|
|
return false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Open a file in the current working directory.
|
|
*
|
|
* \param[in] path A path with a valid 8.3 DOS name for a file to be opened.
|
|
*
|
|
* \param[in] oflag Values for \a oflag are constructed by a bitwise-inclusive
|
|
* OR of open flags. see SdBaseFile::open(SdBaseFile*, const char*, uint8_t).
|
|
*
|
|
* \return The value one, true, is returned for success and
|
|
* the value zero, false, is returned for failure.
|
|
*/
|
|
bool SdBaseFile::open(const char* path, uint8_t oflag) {
|
|
return open(cwd_, path, oflag);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/** Open a file or directory by name.
|
|
*
|
|
* \param[in] dirFile An open SdFat instance for the directory containing the
|
|
* file to be opened.
|
|
*
|
|
* \param[in] path A path with a valid 8.3 DOS name for a file to be opened.
|
|
*
|
|
* \param[in] oflag Values for \a oflag are constructed by a bitwise-inclusive
|
|
* OR of flags from the following list
|
|
*
|
|
* O_READ - Open for reading.
|
|
*
|
|
* O_RDONLY - Same as O_READ.
|
|
*
|
|
* O_WRITE - Open for writing.
|
|
*
|
|
* O_WRONLY - Same as O_WRITE.
|
|
*
|
|
* O_RDWR - Open for reading and writing.
|
|
*
|
|
* O_APPEND - If set, the file offset shall be set to the end of the
|
|
* file prior to each write.
|
|
*
|
|
* O_AT_END - Set the initial position at the end of the file.
|
|
*
|
|
* O_CREAT - If the file exists, this flag has no effect except as noted
|
|
* under O_EXCL below. Otherwise, the file shall be created
|
|
*
|
|
* O_EXCL - If O_CREAT and O_EXCL are set, open() shall fail if the file exists.
|
|
*
|
|
* O_SYNC - Call sync() after each write. This flag should not be used with
|
|
* write(uint8_t), write_P(PGM_P), writelnmkdir_P(PGM_P), or the Arduino Print class.
|
|
* These functions do character at a time writes so sync() will be called
|
|
* after each byte.
|
|
*
|
|
* O_TRUNC - If the file exists and is a regular file, and the file is
|
|
* successfully opened and is not read only, its length shall be truncated to 0.
|
|
*
|
|
* WARNING: A given file must not be opened by more than one SdBaseFile object
|
|
* of file corruption may occur.
|
|
*
|
|
* \note Directory files must be opened read only. Write and truncation is
|
|
* not allowed for directory files.
|
|
*
|
|
* \return The value one, true, is returned for success and
|
|
* the value zero, false, is returned for failure.
|
|
* Reasons for failure include this file is already open, \a dirFile is not
|
|
* a directory, \a path is invalid, the file does not exist
|
|
* or can't be opened in the access mode specified by oflag.
|
|
*/
|
|
|
|
bool SdBaseFile::openParentReturnFile(SdBaseFile* dirFile, const char* path, uint8_t *dname,
|
|
SdBaseFile *newParent, boolean bMakeDirs) {
|
|
SdBaseFile dir1, dir2;
|
|
SdBaseFile *parent = dirFile;
|
|
dir_t *pEntry;
|
|
SdBaseFile *sub = &dir1;
|
|
char *p;
|
|
boolean bFound;
|
|
|
|
#ifdef GLENN_DEBUG
|
|
Commands::checkFreeMemory();
|
|
Commands::writeLowestFreeRAM();
|
|
#endif
|
|
|
|
*dname = 0;
|
|
|
|
if (!dirFile) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// error if already open
|
|
if (isOpen()) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
if (*path == '/') {
|
|
while (*path == '/') path++;
|
|
if (!dirFile->isRoot())
|
|
{
|
|
if (!dir2.openRoot(dirFile->vol_))
|
|
{
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
parent = &dir2;
|
|
}
|
|
}
|
|
// Traverse the Long Directory Name Path until we get to the LEAF (long file name)
|
|
while ((p = strchr(path, '/')) != NULL)
|
|
{
|
|
int8_t cb = p-path;
|
|
|
|
memcpy(dname, path, cb);
|
|
*(dname+cb) = 0;
|
|
|
|
if (*(p+1) == 0)
|
|
goto success;
|
|
#ifdef GLENN_DEBUG
|
|
Commands::checkFreeMemory();
|
|
Commands::writeLowestFreeRAM();
|
|
#endif
|
|
bFound = false;
|
|
if (!sub->open(parent, dname, O_READ, false))
|
|
{
|
|
if (!bMakeDirs)
|
|
return false;
|
|
if (!sub->mkdir(parent, dname))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
if (parent != dirFile) parent->close();
|
|
parent = sub;
|
|
sub = parent != &dir1 ? &dir1 : &dir2;
|
|
path = p+1;
|
|
}
|
|
strcpy((char *)dname, path);
|
|
|
|
success:
|
|
*newParent = *parent;
|
|
#ifdef GLENN_DEBUG
|
|
Commands::checkFreeMemory();
|
|
Commands::writeLowestFreeRAM();
|
|
#endif
|
|
return true;
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
|
|
bool SdBaseFile::open(SdBaseFile* dirFile, const char* path, uint8_t oflag)
|
|
{
|
|
uint8_t dname[LONG_FILENAME_LENGTH+1];
|
|
SdBaseFile parent;
|
|
|
|
if (openParentReturnFile(dirFile, path, dname, &parent, false))
|
|
{
|
|
if (*dname == 0)
|
|
return true;
|
|
return open(&parent, dname, oflag, false);
|
|
}
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
|
|
|
|
uint8_t SdBaseFile::lfn_checksum(const unsigned char *pFCBName)
|
|
{
|
|
int i;
|
|
unsigned char sum = 0;
|
|
|
|
for (i = 11; i; i--)
|
|
sum = ((sum & 1) << 7) + (sum >> 1) + *pFCBName++;
|
|
|
|
return sum;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
// open with filename in dname
|
|
bool SdBaseFile::open(SdBaseFile* dirFile,const uint8_t *dname, uint8_t oflag, bool bDir) {
|
|
bool emptyFound = false;
|
|
uint8_t index = 0;
|
|
dir_t tempDir, *p;
|
|
const char *tempPtr;
|
|
char newName[SHORT_FILENAME_LENGTH+2];
|
|
boolean bShortName = false;
|
|
int8_t cVFATNeeded = -1, wIndex, cVFATFoundCur;
|
|
uint32_t wIndexPos = 0;
|
|
uint8_t cbFilename;
|
|
char *Filename = (char *)dname;
|
|
|
|
#ifdef GLENN_DEBUG
|
|
Com::print("Open File:");
|
|
Com::print((char*)dname);
|
|
Com::println();
|
|
#endif
|
|
vol_ = dirFile->vol_;
|
|
dirFile->rewind();
|
|
// search for file
|
|
|
|
if (oflag & O_CREAT)
|
|
{
|
|
int8_t cb = strlen((char *)dname);
|
|
bShortName = cb < 9;
|
|
cVFATNeeded = (cb / 13) + (cb % 13 == 0 ? 0 : 1);
|
|
}
|
|
|
|
while ((p = dirFile->getLongFilename(p, tempLongFilename, cVFATNeeded, &wIndexPos)))
|
|
{
|
|
HAL::pingWatchdog();
|
|
index = (0XF & ((dirFile->curPosition_-31) >> 5));
|
|
if (RFstricmp(tempLongFilename, (char *)dname) == 0)
|
|
{
|
|
#ifdef GLENN_DEBUG
|
|
Com::print("FFound");
|
|
Com::println();
|
|
#endif
|
|
if (oflag & O_EXCL)
|
|
{
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
return openCachedEntry(index, oflag);
|
|
}
|
|
}
|
|
|
|
// don't create unless O_CREAT and O_WRITE
|
|
if (!(oflag & O_CREAT) || !(oflag & O_WRITE)) {
|
|
goto fail;
|
|
}
|
|
|
|
dirFile->findSpace(&tempDir, cVFATNeeded, &cVFATFoundCur, &wIndexPos);
|
|
if (wIndexPos != 0)
|
|
{
|
|
emptyFound = true;
|
|
#ifdef GLENN_DEBUG
|
|
Com::print("Empty FAT:");
|
|
Com::print((long)wIndexPos);
|
|
Com::println();
|
|
#endif
|
|
index = wIndexPos >> 5;
|
|
}
|
|
else
|
|
{
|
|
// only 512 entries allowed in FAT16 Root Fixed dir
|
|
if (dirFile->type() == FAT_FILE_TYPE_ROOT_FIXED && (dirFile->curPosition_ >> 5) >= 512)
|
|
goto fail;
|
|
cVFATFoundCur = cVFATNeeded + 1;
|
|
if (dirFile->curPosition_ > 0)
|
|
wIndexPos = dirFile->curPosition_-32;
|
|
}
|
|
p = &tempDir;
|
|
|
|
#ifdef GLENN_DEBUG
|
|
Com::print("CurPos:");
|
|
Com::print((long)wIndexPos);
|
|
Com::println();
|
|
#endif
|
|
dirFile->flags_ |= O_WRITE;
|
|
dirFile->seekSet(wIndexPos);
|
|
|
|
// Create LONG FILE NAMES and LONG DIRECTORIES HERE
|
|
// FILL IN MULTIPLE dir_t enteries..
|
|
// DO a test and and make all files created have a long file name of "XXXXXXX <shortname>"
|
|
#ifdef GLENN_DEBUG
|
|
Com::print("At Index:");
|
|
Com::print((long)index);
|
|
Com::print("-");
|
|
Com::print((long)bShortName);
|
|
Com::println();
|
|
|
|
Com::print("Create:");
|
|
Com::print((char *)dname);
|
|
Com::println();
|
|
#endif
|
|
if (!bShortName)
|
|
{
|
|
char *pExt, szExt[5];
|
|
|
|
// Generate 8.3 from longfile name
|
|
if ((pExt = strchr((char *)dname, '.')) != NULL)
|
|
{
|
|
strncpy(szExt, pExt, 4);
|
|
szExt[4] = 0;
|
|
if (pExt > (char*)dname+6)
|
|
pExt = (char*)dname+6;
|
|
}
|
|
else
|
|
{
|
|
szExt[0] = 0;
|
|
pExt = (char*)dname+6;
|
|
}
|
|
uint8_t cb = pExt-(char *)dname;
|
|
memcpy(newName, dname, cb);
|
|
newName[cb] = 0;
|
|
strcat(newName, "~1");
|
|
strcat(newName, szExt);
|
|
}
|
|
else
|
|
{
|
|
strcpy(newName, (char *)dname);
|
|
}
|
|
|
|
uint8_t checksum;
|
|
|
|
make83Name(newName, (uint8_t *)p->name, &tempPtr);
|
|
checksum = lfn_checksum(p->name);
|
|
#ifdef GLENN_DEBUG
|
|
Com::print("Name:");
|
|
Com::print((char *)p->name);
|
|
Com::println();
|
|
#endif
|
|
cbFilename = strlen(Filename);
|
|
|
|
// Write Long File Name VFAT entries to file
|
|
for(uint8_t iBlk=cVFATNeeded;iBlk>0;iBlk--)
|
|
{
|
|
vfat_t *VFAT = (vfat_t *)p;
|
|
uint8_t n;
|
|
|
|
n = (iBlk-1) * 13;
|
|
memset(p, 0, sizeof(dir_t));
|
|
p->attributes = DIR_ATT_LONG_NAME;
|
|
VFAT->sequenceNumber = iBlk | (iBlk == cVFATNeeded ? 0x40 : 0);
|
|
|
|
uint16_t *pName = VFAT->name1;
|
|
|
|
for(int8_t i=0;i<13;i++)
|
|
{
|
|
if (n+i > cbFilename)
|
|
*pName++ = 0xffff;
|
|
else
|
|
*pName++ = (uint16_t)Filename[n+i];
|
|
if (i == 4)
|
|
pName = VFAT->name2;
|
|
else if (i == 10)
|
|
pName = VFAT->name3;
|
|
}
|
|
VFAT->checksum = checksum;
|
|
if (dirFile->write(p, sizeof(dir_t)) < 0)
|
|
goto fail;
|
|
dirFile->sync();
|
|
}
|
|
// END WRITING LONG FILE NAME BLK
|
|
|
|
// Start 8.3 file init
|
|
// initialize as empty file
|
|
memset(p, 0, sizeof(dir_t));
|
|
|
|
make83Name(newName, (uint8_t *)p->name, &tempPtr);
|
|
|
|
p->attributes = bDir ? DIR_ATT_DIRECTORY : DIR_ATT_ARCHIVE;
|
|
|
|
p->creationDate = FAT_DEFAULT_DATE;
|
|
p->creationTime = FAT_DEFAULT_TIME;
|
|
p->lastAccessDate = p->creationDate;
|
|
p->lastWriteDate = p->creationDate;
|
|
p->lastWriteTime = p->creationTime;
|
|
|
|
if (dirFile->write(p, sizeof(dir_t)) < 0)
|
|
goto fail;
|
|
dirFile->sync();
|
|
|
|
memset(p, 0, sizeof(dir_t));
|
|
|
|
if (emptyFound)
|
|
p->name[0] = DIR_NAME_DELETED;
|
|
|
|
for(int8_t i=0;i< cVFATFoundCur - cVFATNeeded;i++)
|
|
{
|
|
if (dirFile->write(p, sizeof(dir_t)) < 0)
|
|
goto fail;
|
|
dirFile->sync();
|
|
}
|
|
return open(dirFile, (wIndexPos >> 5) + (cVFATNeeded), oflag & ~O_EXCL);
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Open a file by index.
|
|
*
|
|
* \param[in] dirFile An open SdFat instance for the directory.
|
|
*
|
|
* \param[in] index The \a index of the directory entry for the file to be
|
|
* opened. The value for \a index is (directory file position)/32.
|
|
*
|
|
* \param[in] oflag Values for \a oflag are constructed by a bitwise-inclusive
|
|
* OR of flags O_READ, O_WRITE, O_TRUNC, and O_SYNC.
|
|
*
|
|
* See open() by path for definition of flags.
|
|
* \return true for success or false for failure.
|
|
*/
|
|
bool SdBaseFile::open(SdBaseFile* dirFile, uint16_t index, uint8_t oflag) {
|
|
dir_t* p;
|
|
|
|
vol_ = dirFile->vol_;
|
|
|
|
// error if already open
|
|
if (isOpen() || !dirFile) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
|
|
// don't open existing file if O_EXCL - user call error
|
|
if (oflag & O_EXCL) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// seek to location of entry
|
|
if (!dirFile->seekSet(32 * index)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// read entry into cache
|
|
p = dirFile->readDirCache();
|
|
if (!p) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// error if empty slot or '.' or '..'
|
|
if (p->name[0] == DIR_NAME_FREE ||
|
|
p->name[0] == DIR_NAME_DELETED || p->name[0] == '.') {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// open cached entry
|
|
return openCachedEntry(index & 0XF, oflag);
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
// open a cached directory entry. Assumes vol_ is initialized
|
|
bool SdBaseFile::openCachedEntry(uint8_t dirIndex, uint8_t oflag) {
|
|
// location of entry in cache
|
|
dir_t* p = &vol_->cacheAddress()->dir[dirIndex];
|
|
|
|
// write or truncate is an error for a directory or read-only file
|
|
if (p->attributes & (DIR_ATT_READ_ONLY | DIR_ATT_DIRECTORY)) {
|
|
// if (oflag & (O_WRITE | O_TRUNC)) {
|
|
// DBG_FAIL_MACRO;
|
|
// goto fail;
|
|
// }
|
|
}
|
|
// remember location of directory entry on SD
|
|
dirBlock_ = vol_->cacheBlockNumber();
|
|
dirIndex_ = dirIndex;
|
|
|
|
// copy first cluster number for directory fields
|
|
firstCluster_ = (uint32_t)p->firstClusterHigh << 16;
|
|
firstCluster_ |= p->firstClusterLow;
|
|
|
|
#ifdef GLENN_DEBUG
|
|
Com::print("CATR:");
|
|
Com::print(firstCluster_);
|
|
Com::print("-");
|
|
Com::print(p->name[0]);
|
|
Com::println();
|
|
#endif
|
|
|
|
// make sure it is a normal file or subdirectory
|
|
if (DIR_IS_FILE(p)) {
|
|
fileSize_ = p->fileSize;
|
|
type_ = FAT_FILE_TYPE_NORMAL;
|
|
} else if (DIR_IS_SUBDIR(p)) {
|
|
if (!setDirSize()) {
|
|
fileSize_= 0;
|
|
}
|
|
type_ = FAT_FILE_TYPE_SUBDIR;
|
|
} else {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// save open flags for read/write
|
|
flags_ = oflag & F_OFLAG;
|
|
|
|
// set to start of file
|
|
curCluster_ = 0;
|
|
curPosition_ = 0;
|
|
if ((oflag & O_TRUNC) && !truncate(0)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
return oflag & O_AT_END ? seekEnd(0) : true;
|
|
|
|
fail:
|
|
type_ = FAT_FILE_TYPE_CLOSED;
|
|
return false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Open the next file or subdirectory in a directory.
|
|
*
|
|
* \param[in] dirFile An open SdFat instance for the directory containing the
|
|
* file to be opened.
|
|
*
|
|
* \param[in] oflag Values for \a oflag are constructed by a bitwise-inclusive
|
|
* OR of flags O_READ, O_WRITE, O_TRUNC, and O_SYNC.
|
|
*
|
|
* See open() by path for definition of flags.
|
|
* \return true for success or false for failure.
|
|
*/
|
|
bool SdBaseFile::openNext(SdBaseFile* dirFile, uint8_t oflag) {
|
|
dir_t* p;
|
|
uint8_t index;
|
|
|
|
if (!dirFile) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// error if already open
|
|
if (isOpen()) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
vol_ = dirFile->vol_;
|
|
|
|
while (1) {
|
|
index = 0XF & (dirFile->curPosition_ >> 5);
|
|
|
|
// read entry into cache
|
|
p = dirFile->readDirCache();
|
|
if (!p) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// done if last entry
|
|
if (p->name[0] == DIR_NAME_FREE) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// skip empty slot or '.' or '..'
|
|
if (p->name[0] == DIR_NAME_DELETED || p->name[0] == '.') {
|
|
continue;
|
|
}
|
|
// must be file or dir
|
|
if (DIR_IS_FILE_OR_SUBDIR(p)) {
|
|
return openCachedEntry(index, oflag);
|
|
}
|
|
}
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Open a directory's parent directory.
|
|
*
|
|
* \param[in] dir Parent of this directory will be opened. Must not be root.
|
|
*
|
|
* \return The value one, true, is returned for success and
|
|
* the value zero, false, is returned for failure.
|
|
*/
|
|
bool SdBaseFile::openParent(SdBaseFile* dir) {
|
|
dir_t entry;
|
|
dir_t* p;
|
|
SdBaseFile file;
|
|
uint32_t c;
|
|
uint32_t cluster;
|
|
uint32_t lbn;
|
|
cache_t* pc;
|
|
// error if already open or dir is root or dir is not a directory
|
|
if (isOpen() || !dir || dir->isRoot() || !dir->isDir()) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
vol_ = dir->vol_;
|
|
// position to '..'
|
|
if (!dir->seekSet(32)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// read '..' entry
|
|
if (dir->read(&entry, sizeof(entry)) != 32) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// verify it is '..'
|
|
if (entry.name[0] != '.' || entry.name[1] != '.') {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// start cluster for '..'
|
|
cluster = entry.firstClusterLow;
|
|
cluster |= (uint32_t)entry.firstClusterHigh << 16;
|
|
if (cluster == 0) return openRoot(vol_);
|
|
// start block for '..'
|
|
lbn = vol_->clusterStartBlock(cluster);
|
|
// first block of parent dir
|
|
pc = vol_->cacheFetch(lbn, SdVolume::CACHE_FOR_READ);
|
|
if (!pc) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
p = &pc->dir[1];
|
|
// verify name for '../..'
|
|
if (p->name[0] != '.' || p->name[1] != '.') {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// '..' is pointer to first cluster of parent. open '../..' to find parent
|
|
if (p->firstClusterHigh == 0 && p->firstClusterLow == 0) {
|
|
if (!file.openRoot(dir->volume())) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
} else {
|
|
if (!file.openCachedEntry(1, O_READ)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
}
|
|
// search for parent in '../..'
|
|
do {
|
|
if (file.readDir(&entry, NULL) != 32) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
c = entry.firstClusterLow;
|
|
c |= (uint32_t)entry.firstClusterHigh << 16;
|
|
} while (c != cluster);
|
|
// open parent
|
|
return open(&file, file.curPosition()/32 - 1, O_READ);
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Open a volume's root directory.
|
|
*
|
|
* \param[in] vol The FAT volume containing the root directory to be opened.
|
|
*
|
|
* \return The value one, true, is returned for success and
|
|
* the value zero, false, is returned for failure.
|
|
* Reasons for failure include the file is already open, the FAT volume has
|
|
* not been initialized or it a FAT12 volume.
|
|
*/
|
|
bool SdBaseFile::openRoot(SdVolume* vol) {
|
|
// error if file is already open
|
|
if (isOpen()) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
vol_ = vol;
|
|
if (vol->fatType() == 16 || (FAT12_SUPPORT && vol->fatType() == 12)) {
|
|
type_ = FAT_FILE_TYPE_ROOT_FIXED;
|
|
firstCluster_ = 0;
|
|
fileSize_ = 32 * vol->rootDirEntryCount();
|
|
} else if (vol->fatType() == 32) {
|
|
type_ = FAT_FILE_TYPE_ROOT32;
|
|
firstCluster_ = vol->rootDirStart();
|
|
if (!setDirSize()) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
} else {
|
|
// volume is not initialized, invalid, or FAT12 without support
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// read only
|
|
flags_ = O_READ;
|
|
|
|
// set to start of file
|
|
curCluster_ = 0;
|
|
curPosition_ = 0;
|
|
|
|
// root has no directory entry
|
|
dirBlock_ = 0;
|
|
dirIndex_ = 0;
|
|
return true;
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Return the next available byte without consuming it.
|
|
*
|
|
* \return The byte if no error and not at eof else -1;
|
|
*/
|
|
int SdBaseFile::peek() {
|
|
FatPos_t pos;
|
|
getpos(&pos);
|
|
int c = read();
|
|
if (c >= 0) setpos(&pos);
|
|
return c;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** %Print the name field of a directory entry in 8.3 format.
|
|
* \param[in] pr Print stream for output.
|
|
* \param[in] dir The directory structure containing the name.
|
|
* \param[in] width Blank fill name if length is less than \a width.
|
|
* \param[in] printSlash Print '/' after directory names if true.
|
|
*/
|
|
void SdBaseFile::printDirName(const dir_t& dir,
|
|
uint8_t width, bool printSlash) {
|
|
uint8_t w = 0;
|
|
for (uint8_t i = 0; i < 11; i++) {
|
|
if (dir.name[i] == ' ')continue;
|
|
if (i == 8) {
|
|
Com::print('.');
|
|
w++;
|
|
}
|
|
Com::print(dir.name[i]);
|
|
w++;
|
|
}
|
|
if (DIR_IS_SUBDIR(&dir) && printSlash) {
|
|
Com::print('/');
|
|
w++;
|
|
}
|
|
while (w < width) {
|
|
Com::print(' ');
|
|
w++;
|
|
}
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
// print uint8_t with width 2
|
|
static void print2u(uint8_t v) {
|
|
if (v < 10) Com::print('0');
|
|
Com::print(v);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Print a file's creation date and time
|
|
*
|
|
* \param[in] pr Print stream for output.
|
|
*
|
|
* \return The value one, true, is returned for success and
|
|
* the value zero, false, is returned for failure.
|
|
*/
|
|
bool SdBaseFile::printCreateDateTime() {
|
|
dir_t dir;
|
|
if (!dirEntry(&dir)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
printFatDate(dir.creationDate);
|
|
Com::print(' ');
|
|
printFatTime(dir.creationTime);
|
|
return true;
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/** %Print a directory date field.
|
|
*
|
|
* Format is yyyy-mm-dd.
|
|
*
|
|
* \param[in] pr Print stream for output.
|
|
* \param[in] fatDate The date field from a directory entry.
|
|
*/
|
|
void SdBaseFile::printFatDate(uint16_t fatDate) {
|
|
Com::print((int)FAT_YEAR(fatDate));
|
|
Com::print('-');
|
|
print2u(FAT_MONTH(fatDate));
|
|
Com::print('-');
|
|
print2u(FAT_DAY(fatDate));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/** %Print a directory time field.
|
|
*
|
|
* Format is hh:mm:ss.
|
|
*
|
|
* \param[in] pr Print stream for output.
|
|
* \param[in] fatTime The time field from a directory entry.
|
|
*/
|
|
void SdBaseFile::printFatTime( uint16_t fatTime) {
|
|
print2u(FAT_HOUR(fatTime));
|
|
Com::print(':');
|
|
print2u(FAT_MINUTE(fatTime));
|
|
Com::print(':');
|
|
print2u(FAT_SECOND(fatTime));
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Print a file's modify date and time
|
|
*
|
|
* \param[in] pr Print stream for output.
|
|
*
|
|
* \return The value one, true, is returned for success and
|
|
* the value zero, false, is returned for failure.
|
|
*/
|
|
bool SdBaseFile::printModifyDateTime() {
|
|
dir_t dir;
|
|
if (!dirEntry(&dir)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
printFatDate(dir.lastWriteDate);
|
|
Com::print(' ');
|
|
printFatTime(dir.lastWriteTime);
|
|
return true;
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
/** Template for SdBaseFile::printField() */
|
|
|
|
template <typename Type>
|
|
|
|
static int printFieldT(SdBaseFile* file, char sign, Type value, char term) {
|
|
char buf[3*sizeof(Type) + 3];
|
|
char* str = &buf[sizeof(buf)];
|
|
|
|
if (term) {
|
|
*--str = term;
|
|
if (term == '\n') {
|
|
*--str = '\r';
|
|
}
|
|
}
|
|
do {
|
|
Type m = value;
|
|
value /= 10;
|
|
*--str = '0' + m - 10*value;
|
|
} while (value);
|
|
if (sign) {
|
|
*--str = sign;
|
|
}
|
|
return file->write(str, &buf[sizeof(buf)] - str);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Print a number followed by a field terminator.
|
|
* \param[in] value The number to be printed.
|
|
* \param[in] term The field terminator. Use '\\n' for CR LF.
|
|
* \return The number of bytes written or -1 if an error occurs.
|
|
*/
|
|
int SdBaseFile::printField(uint16_t value, char term) {
|
|
return printFieldT(this, 0, value, term);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Print a number followed by a field terminator.
|
|
* \param[in] value The number to be printed.
|
|
* \param[in] term The field terminator. Use '\\n' for CR LF.
|
|
* \return The number of bytes written or -1 if an error occurs.
|
|
*/
|
|
int SdBaseFile::printField(int16_t value, char term) {
|
|
char sign = 0;
|
|
if (value < 0) {
|
|
sign = '-';
|
|
value = -value;
|
|
}
|
|
return printFieldT(this, sign, (uint16_t)value, term);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Print a number followed by a field terminator.
|
|
* \param[in] value The number to be printed.
|
|
* \param[in] term The field terminator. Use '\\n' for CR LF.
|
|
* \return The number of bytes written or -1 if an error occurs.
|
|
*/
|
|
int SdBaseFile::printField(uint32_t value, char term) {
|
|
return printFieldT(this, 0, value, term);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Print a number followed by a field terminator.
|
|
* \param[in] value The number to be printed.
|
|
* \param[in] term The field terminator. Use '\\n' for CR LF.
|
|
* \return The number of bytes written or -1 if an error occurs.
|
|
*/
|
|
int SdBaseFile::printField(int32_t value, char term) {
|
|
char sign = 0;
|
|
if (value < 0) {
|
|
sign = '-';
|
|
value = -value;
|
|
}
|
|
return printFieldT(this, sign, (uint32_t)value, term);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//------------------------------------------------------------------------------
|
|
/** Print a file's name
|
|
*
|
|
* \param[in] pr Print stream for output.
|
|
*
|
|
* \return The value one, true, is returned for success and
|
|
* the value zero, false, is returned for failure.
|
|
*/
|
|
bool SdBaseFile::printName() {
|
|
char name[13];
|
|
if (!getFilename(name)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
Com::print(name);
|
|
return true;
|
|
fail:
|
|
return false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Read the next byte from a file.
|
|
*
|
|
* \return For success read returns the next byte in the file as an int.
|
|
* If an error occurs or end of file is reached -1 is returned.
|
|
*/
|
|
int16_t SdBaseFile::read() {
|
|
uint8_t b;
|
|
return read(&b, 1) == 1 ? b : -1;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Read data from a file starting at the current position.
|
|
*
|
|
* \param[out] buf Pointer to the location that will receive the data.
|
|
*
|
|
* \param[in] nbyte Maximum number of bytes to read.
|
|
*
|
|
* \return For success read() returns the number of bytes read.
|
|
* A value less than \a nbyte, including zero, will be returned
|
|
* if end of file is reached.
|
|
* If an error occurs, read() returns -1. Possible errors include
|
|
* read() called before a file has been opened, corrupt file system
|
|
* or an I/O error occurred.
|
|
*/
|
|
int SdBaseFile::read(void* buf, size_t nbyte) {
|
|
uint8_t blockOfCluster;
|
|
uint8_t* dst = reinterpret_cast<uint8_t*>(buf);
|
|
uint16_t offset;
|
|
size_t toRead;
|
|
uint32_t block; // raw device block number
|
|
cache_t* pc;
|
|
|
|
// error if not open or write only
|
|
if (!isOpen() || !(flags_ & O_READ)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// max bytes left in file
|
|
if (nbyte >= (fileSize_ - curPosition_)) {
|
|
nbyte = fileSize_ - curPosition_;
|
|
}
|
|
// amount left to read
|
|
toRead = nbyte;
|
|
while (toRead > 0) {
|
|
size_t n;
|
|
offset = curPosition_ & 0X1FF; // offset in block
|
|
blockOfCluster = vol_->blockOfCluster(curPosition_);
|
|
if (type_ == FAT_FILE_TYPE_ROOT_FIXED) {
|
|
block = vol_->rootDirStart() + (curPosition_ >> 9);
|
|
#ifdef GLENN_DEBUG
|
|
Com::print("RBL:");
|
|
Com::print(block);
|
|
Com::println();
|
|
#endif
|
|
} else {
|
|
if (offset == 0 && blockOfCluster == 0) {
|
|
// start of new cluster
|
|
if (curPosition_ == 0) {
|
|
// use first cluster in file
|
|
curCluster_ = firstCluster_;
|
|
} else {
|
|
// get next cluster from FAT
|
|
if (!vol_->fatGet(curCluster_, &curCluster_)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
}
|
|
}
|
|
block = vol_->clusterStartBlock(curCluster_) + blockOfCluster;
|
|
}
|
|
if (offset != 0 || toRead < 512 || block == vol_->cacheBlockNumber()) {
|
|
// amount to be read from current block
|
|
n = 512 - offset;
|
|
if (n > toRead) n = toRead;
|
|
// read block to cache and copy data to caller
|
|
pc = vol_->cacheFetch(block, SdVolume::CACHE_FOR_READ);
|
|
if (!pc) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
uint8_t* src = pc->data + offset;
|
|
memcpy(dst, src, n);
|
|
} else if (!USE_MULTI_BLOCK_SD_IO || toRead < 1024) {
|
|
// read single block
|
|
n = 512;
|
|
if (!vol_->readBlock(block, dst)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
} else {
|
|
uint8_t nb = toRead >> 9;
|
|
if (type_ != FAT_FILE_TYPE_ROOT_FIXED) {
|
|
uint8_t mb = vol_->blocksPerCluster() - blockOfCluster;
|
|
if (mb < nb) nb = mb;
|
|
}
|
|
n = 512*nb;
|
|
if (vol_->cacheBlockNumber() <= block
|
|
&& block < (vol_->cacheBlockNumber() + nb)) {
|
|
// flush cache if a block is in the cache
|
|
if (!vol_->cacheSync()) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
}
|
|
if (!vol_->sdCard()->readStart(block)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
for (uint8_t b = 0; b < nb; b++) {
|
|
if (!vol_->sdCard()->readData(dst + b*512)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
}
|
|
if (!vol_->sdCard()->readStop()) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
}
|
|
dst += n;
|
|
curPosition_ += n;
|
|
toRead -= n;
|
|
}
|
|
return nbyte;
|
|
|
|
fail:
|
|
return -1;
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
/** Read the next directory entry from a directory file with the long filename
|
|
*
|
|
* \param[out] dir The dir_t struct that will receive the data.
|
|
* \param[out] longFiename The long filename associated with the 8.3 name
|
|
*
|
|
* \return For success getLongFilename() returns a pointer to dir_t
|
|
* A value of zero will be returned if end of file is reached.
|
|
*/
|
|
|
|
|
|
dir_t *SdBaseFile::getLongFilename(dir_t *dir, char *longFilename, int8_t cVFATNeeded, uint32_t *pwIndexPos)
|
|
{
|
|
int16_t n;
|
|
uint8_t bLastPart = true;
|
|
uint8_t checksum;
|
|
|
|
if (longFilename != NULL)
|
|
*longFilename = 0;
|
|
|
|
while (1)
|
|
{
|
|
HAL::pingWatchdog();
|
|
#ifdef GLENN_DEBUG
|
|
Commands::checkFreeMemory();
|
|
Commands::writeLowestFreeRAM();
|
|
#endif
|
|
if (!(dir = readDirCache()))
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
if (dir->name[0] == DIR_NAME_FREE)
|
|
return NULL;
|
|
|
|
if (dir->name[0] == DIR_NAME_0XE5 || dir->name[0] == DIR_NAME_DELETED)
|
|
{
|
|
bLastPart = true;
|
|
if (longFilename != NULL)
|
|
*longFilename = 0;
|
|
continue;
|
|
}
|
|
|
|
if (DIR_IS_LONG_NAME(dir))
|
|
{
|
|
if (longFilename != NULL)
|
|
{
|
|
vfat_t *VFAT = (vfat_t*)dir;
|
|
int8_t nSeq = VFAT->sequenceNumber & 0x1F;
|
|
|
|
// Sanity check the VFAT entry. The first cluster is always set to zero. And the sequence number should be higher then 0
|
|
if (VFAT->firstClusterLow == 0 && nSeq > 0 && nSeq <= MAX_VFAT_ENTRIES)
|
|
{
|
|
n = (nSeq - 1) * 13;
|
|
|
|
longFilename[n+0] = (char)VFAT->name1[0];
|
|
|
|
longFilename[n+1] = (char)VFAT->name1[1];
|
|
longFilename[n+2] = (char)VFAT->name1[2];
|
|
longFilename[n+3] = (char)VFAT->name1[3];
|
|
longFilename[n+4] = (char)VFAT->name1[4];
|
|
longFilename[n+5] = (char)VFAT->name2[0];
|
|
longFilename[n+6] = (char)VFAT->name2[1];
|
|
longFilename[n+7] = (char)VFAT->name2[2];
|
|
longFilename[n+8] = (char)VFAT->name2[3];
|
|
longFilename[n+9] = (char)VFAT->name2[4];
|
|
longFilename[n+10] = (char)VFAT->name2[5];
|
|
longFilename[n+11] = (char)VFAT->name3[0];
|
|
longFilename[n+12] = (char)VFAT->name3[1];
|
|
|
|
if (bLastPart)
|
|
{
|
|
checksum = VFAT->checksum;
|
|
longFilename[n+13] = 0;
|
|
}
|
|
bLastPart = false;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ((dir->attributes & DIR_ATT_HIDDEN || dir->attributes & DIR_ATT_SYSTEM) || (dir->name[0] == '.' && dir->name[1] != '.'))
|
|
{
|
|
bLastPart = true;
|
|
if (longFilename != NULL)
|
|
*longFilename = 0;
|
|
continue;
|
|
}
|
|
if (DIR_IS_FILE(dir) || DIR_IS_SUBDIR(dir))
|
|
{
|
|
if (longFilename && (bLastPart || checksum != lfn_checksum(dir->name)))
|
|
{
|
|
sd.createFilename(longFilename, *dir);
|
|
}
|
|
return dir;
|
|
}
|
|
}
|
|
}
|
|
#ifdef GLENN_DEBUG
|
|
Commands::checkFreeMemory();
|
|
Commands::writeLowestFreeRAM();
|
|
#endif
|
|
return dir;
|
|
}
|
|
|
|
bool SdBaseFile::findSpace(dir_t *dir, int8_t cVFATNeeded, int8_t *pcVFATFound, uint32_t *pwIndexPos)
|
|
{
|
|
int16_t n;
|
|
int8_t cVFATFound = 0;
|
|
// if not a directory file or miss-positioned return an error
|
|
if (!isDir()) return -1;
|
|
|
|
rewind();
|
|
|
|
while (1) {
|
|
HAL::pingWatchdog();
|
|
dir = readDirCache();
|
|
if (!dir) return false;
|
|
// last entry if DIR_NAME_FREE
|
|
if (dir->name[0] == DIR_NAME_FREE) return 0;
|
|
// skip empty entries and entry for . and ..
|
|
#ifdef GLENN_DEBUG
|
|
Com::print("Attr:");
|
|
Com::print((long)dir->attributes);
|
|
Com::print(" ");
|
|
Com::print((long)dir->name[0]);
|
|
Com::println();
|
|
#endif
|
|
|
|
if (dir->name[0] == DIR_NAME_0XE5 || dir->name[0] == DIR_NAME_DELETED)
|
|
{
|
|
if (DIR_IS_LONG_NAME(dir))
|
|
{
|
|
vfat_t *VFAT = (vfat_t*)dir;
|
|
cVFATFound++;
|
|
}
|
|
else
|
|
{
|
|
#ifdef GLENN_DEBUG
|
|
Com::print("Need: ");
|
|
Com::print(cVFATNeeded);
|
|
Com::print(" Got: ");
|
|
Com::print(cVFATFound);
|
|
Com::print(" ");
|
|
Com::println();
|
|
#endif
|
|
if (pwIndexPos != NULL && cVFATNeeded > 0 && cVFATFound >= cVFATNeeded && *pwIndexPos == 0)
|
|
{
|
|
*pwIndexPos = curPosition_-sizeof(dir_t)-(cVFATFound * sizeof(dir_t));
|
|
*pcVFATFound = cVFATFound;
|
|
return true;
|
|
}
|
|
cVFATFound++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cVFATFound = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/** Read the next directory entry from a directory file.
|
|
*
|
|
* \param[out] dir The dir_t struct that will receive the data.
|
|
*
|
|
* \return For success readDir() returns the number of bytes read.
|
|
* A value of zero will be returned if end of file is reached.
|
|
* If an error occurs, readDir() returns -1. Possible errors include
|
|
* readDir() called before a directory has been opened, this is not
|
|
* a directory file or an I/O error occurred.
|
|
*/
|
|
|
|
int8_t SdBaseFile::readDir(dir_t* dir, char* longFilename) {
|
|
int16_t n;
|
|
// if not a directory file or miss-positioned return an error
|
|
if (!isDir() || (0X1F & curPosition_)) return -1;
|
|
|
|
while (1) {
|
|
n = read(dir, sizeof(dir_t));
|
|
if (n != sizeof(dir_t)) return n == 0 ? 0 : -1;
|
|
// last entry if DIR_NAME_FREE
|
|
if (dir->name[0] == DIR_NAME_FREE) return 0;
|
|
// skip empty entries and entry for . and ..
|
|
if (dir->name[0] == DIR_NAME_DELETED || dir->name[0] == '.') continue;
|
|
// return if normal file or subdirectory
|
|
if (DIR_IS_FILE_OR_SUBDIR(dir)) return n;
|
|
}
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
// Read next directory entry into the cache
|
|
// Assumes file is correctly positioned
|
|
dir_t* SdBaseFile::readDirCache() {
|
|
uint8_t i;
|
|
// error if not directory
|
|
if (!isDir()) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// index of entry in cache
|
|
i = (curPosition_ >> 5) & 0XF;
|
|
// use read to locate and cache block
|
|
if (read() < 0) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// advance to next entry
|
|
curPosition_ += 31;
|
|
|
|
// return pointer to entry
|
|
return vol_->cacheAddress()->dir + i;
|
|
|
|
fail:
|
|
return 0;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Remove a file.
|
|
*
|
|
* The directory entry and all data for the file are deleted.
|
|
*
|
|
* \note This function should not be used to delete the 8.3 version of a
|
|
* file that has a long name. For example if a file has the long name
|
|
* "New Text Document.txt" you should not delete the 8.3 name "NEWTEX~1.TXT".
|
|
*
|
|
* \return The value one, true, is returned for success and
|
|
* the value zero, false, is returned for failure.
|
|
* Reasons for failure include the file read-only, is a directory,
|
|
* or an I/O error occurred.
|
|
*/
|
|
bool SdBaseFile::remove() {
|
|
dir_t* d;
|
|
// free any clusters - will fail if read-only or directory
|
|
if (!truncate(0)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// cache directory entry
|
|
d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
|
|
if (!d) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// mark entry deleted
|
|
d->name[0] = DIR_NAME_DELETED;
|
|
|
|
// set this file closed
|
|
type_ = FAT_FILE_TYPE_CLOSED;
|
|
|
|
// write entry to SD
|
|
return vol_->cacheSync();
|
|
return true;
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Remove a file.
|
|
*
|
|
* The directory entry and all data for the file are deleted.
|
|
*
|
|
* \param[in] dirFile The directory that contains the file.
|
|
* \param[in] path Path for the file to be removed.
|
|
*
|
|
* \note This function should not be used to delete the 8.3 version of a
|
|
* file that has a long name. For example if a file has the long name
|
|
* "New Text Document.txt" you should not delete the 8.3 name "NEWTEX~1.TXT".
|
|
*
|
|
* \return The value one, true, is returned for success and
|
|
* the value zero, false, is returned for failure.
|
|
* Reasons for failure include the file is a directory, is read only,
|
|
* \a dirFile is not a directory, \a path is not found
|
|
* or an I/O error occurred.
|
|
*/
|
|
bool SdBaseFile::remove(SdBaseFile* dirFile, const char* path) {
|
|
SdBaseFile file;
|
|
if (!file.open(dirFile, path, O_WRITE)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
return file.remove();
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Rename a file or subdirectory.
|
|
*
|
|
* \param[in] dirFile Directory for the new path.
|
|
* \param[in] newPath New path name for the file/directory.
|
|
*
|
|
* \return The value one, true, is returned for success and
|
|
* the value zero, false, is returned for failure.
|
|
* Reasons for failure include \a dirFile is not open or is not a directory
|
|
* file, newPath is invalid or already exists, or an I/O error occurs.
|
|
*/
|
|
bool SdBaseFile::rename(SdBaseFile* dirFile, const char* newPath) {
|
|
dir_t entry;
|
|
uint32_t dirCluster = 0;
|
|
SdBaseFile file;
|
|
cache_t* pc;
|
|
dir_t* d;
|
|
|
|
// must be an open file or subdirectory
|
|
if (!(isFile() || isSubDir())) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// can't move file
|
|
if (vol_ != dirFile->vol_) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// sync() and cache directory entry
|
|
sync();
|
|
d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
|
|
if (!d) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// save directory entry
|
|
memcpy(&entry, d, sizeof(entry));
|
|
|
|
// mark entry deleted
|
|
d->name[0] = DIR_NAME_DELETED;
|
|
|
|
// make directory entry for new path
|
|
if (isFile()) {
|
|
if (!file.open(dirFile, newPath, O_CREAT | O_EXCL | O_WRITE)) {
|
|
goto restore;
|
|
}
|
|
} else {
|
|
// don't create missing path prefix components
|
|
if (!file.mkdir(dirFile, newPath, false)) {
|
|
goto restore;
|
|
}
|
|
// save cluster containing new dot dot
|
|
dirCluster = file.firstCluster_;
|
|
}
|
|
// change to new directory entry
|
|
dirBlock_ = file.dirBlock_;
|
|
dirIndex_ = file.dirIndex_;
|
|
|
|
// mark closed to avoid possible destructor close call
|
|
file.type_ = FAT_FILE_TYPE_CLOSED;
|
|
|
|
// cache new directory entry
|
|
d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
|
|
if (!d) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// copy all but name field to new directory entry
|
|
memcpy(&d->attributes, &entry.attributes, sizeof(entry) - sizeof(d->name));
|
|
|
|
// update dot dot if directory
|
|
if (dirCluster) {
|
|
// get new dot dot
|
|
uint32_t block = vol_->clusterStartBlock(dirCluster);
|
|
pc = vol_->cacheFetch(block, SdVolume::CACHE_FOR_READ);
|
|
if (!pc) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
memcpy(&entry, &pc->dir[1], sizeof(entry));
|
|
|
|
// free unused cluster
|
|
if (!vol_->freeChain(dirCluster)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// store new dot dot
|
|
block = vol_->clusterStartBlock(firstCluster_);
|
|
pc = vol_->cacheFetch(block, SdVolume::CACHE_FOR_WRITE);
|
|
if (!pc) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
memcpy(&pc->dir[1], &entry, sizeof(entry));
|
|
}
|
|
return vol_->cacheSync();
|
|
|
|
restore:
|
|
d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
|
|
if (!d) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// restore entry
|
|
d->name[0] = entry.name[0];
|
|
vol_->cacheSync();
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Remove a directory file.
|
|
*
|
|
* The directory file will be removed only if it is empty and is not the
|
|
* root directory. rmdir() follows DOS and Windows and ignores the
|
|
* read-only attribute for the directory.
|
|
*
|
|
* \note This function should not be used to delete the 8.3 version of a
|
|
* directory that has a long name. For example if a directory has the
|
|
* long name "New folder" you should not delete the 8.3 name "NEWFOL~1".
|
|
*
|
|
* \return The value one, true, is returned for success and
|
|
* the value zero, false, is returned for failure.
|
|
* Reasons for failure include the file is not a directory, is the root
|
|
* directory, is not empty, or an I/O error occurred.
|
|
*/
|
|
bool SdBaseFile::rmdir() {
|
|
// must be open subdirectory
|
|
if (!isSubDir()) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
rewind();
|
|
|
|
// make sure directory is empty
|
|
while (curPosition_ < fileSize_) {
|
|
dir_t* p = readDirCache();
|
|
if (!p) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// done if past last used entry
|
|
if (p->name[0] == DIR_NAME_FREE) break;
|
|
// skip empty slot, '.' or '..'
|
|
if (p->name[0] == DIR_NAME_DELETED || p->name[0] == '.') continue;
|
|
// error not empty
|
|
if (DIR_IS_FILE_OR_SUBDIR(p)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
}
|
|
// convert empty directory to normal file for remove
|
|
type_ = FAT_FILE_TYPE_NORMAL;
|
|
flags_ |= O_WRITE;
|
|
return remove();
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Recursively delete a directory and all contained files.
|
|
*
|
|
* This is like the Unix/Linux 'rm -rf *' if called with the root directory
|
|
* hence the name.
|
|
*
|
|
* Warning - This will remove all contents of the directory including
|
|
* subdirectories. The directory will then be removed if it is not root.
|
|
* The read-only attribute for files will be ignored.
|
|
*
|
|
* \note This function should not be used to delete the 8.3 version of
|
|
* a directory that has a long name. See remove() and rmdir().
|
|
*
|
|
* \return The value one, true, is returned for success and
|
|
* the value zero, false, is returned for failure.
|
|
*/
|
|
bool SdBaseFile::rmRfStar() {
|
|
uint16_t index;
|
|
SdBaseFile f;
|
|
rewind();
|
|
while (curPosition_ < fileSize_) {
|
|
// remember position
|
|
index = curPosition_/32;
|
|
|
|
dir_t* p = readDirCache();
|
|
if (!p) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// done if past last entry
|
|
if (p->name[0] == DIR_NAME_FREE) break;
|
|
|
|
// skip empty slot or '.' or '..'
|
|
if (p->name[0] == DIR_NAME_DELETED || p->name[0] == '.') continue;
|
|
|
|
// skip if part of long file name or volume label in root
|
|
if (!DIR_IS_FILE_OR_SUBDIR(p)) continue;
|
|
|
|
if (!f.open(this, index, O_READ)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
if (f.isSubDir()) {
|
|
// recursively delete
|
|
if (!f.rmRfStar()) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
} else {
|
|
// ignore read-only
|
|
f.flags_ |= O_WRITE;
|
|
if (!f.remove()) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
}
|
|
// position to next entry if required
|
|
if (curPosition_ != (32UL*(index + 1))) {
|
|
if (!seekSet(32UL*(index + 1))) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
}
|
|
}
|
|
// don't try to delete root
|
|
if (!isRoot()) {
|
|
if (!rmdir()) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
}
|
|
return true;
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Create a file object and open it in the current working directory.
|
|
*
|
|
* \param[in] path A path with a valid 8.3 DOS name for a file to be opened.
|
|
*
|
|
* \param[in] oflag Values for \a oflag are constructed by a bitwise-inclusive
|
|
* OR of open flags. see SdBaseFile::open(SdBaseFile*, const char*, uint8_t).
|
|
*/
|
|
SdBaseFile::SdBaseFile(const char* path, uint8_t oflag) {
|
|
type_ = FAT_FILE_TYPE_CLOSED;
|
|
writeError = false;
|
|
open(path, oflag);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Sets a file's position.
|
|
*
|
|
* \param[in] pos The new position in bytes from the beginning of the file.
|
|
*
|
|
* \return The value one, true, is returned for success and
|
|
* the value zero, false, is returned for failure.
|
|
*/
|
|
bool SdBaseFile::seekSet(uint32_t pos) {
|
|
uint32_t nCur;
|
|
uint32_t nNew;
|
|
// error if file not open or seek past end of file
|
|
if (!isOpen() || pos > fileSize_) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
if (type_ == FAT_FILE_TYPE_ROOT_FIXED) {
|
|
curPosition_ = pos;
|
|
curCluster_ = 0;
|
|
goto done;
|
|
}
|
|
if (pos == 0) {
|
|
// set position to start of file
|
|
curCluster_ = 0;
|
|
curPosition_ = 0;
|
|
goto done;
|
|
}
|
|
// calculate cluster index for cur and new position
|
|
nCur = (curPosition_ - 1) >> (vol_->clusterSizeShift_ + 9);
|
|
nNew = (pos - 1) >> (vol_->clusterSizeShift_ + 9);
|
|
|
|
if (nNew < nCur || curPosition_ == 0) {
|
|
// must follow chain from first cluster
|
|
curCluster_ = firstCluster_;
|
|
} else {
|
|
// advance from curPosition
|
|
nNew -= nCur;
|
|
}
|
|
while (nNew--) {
|
|
if (!vol_->fatGet(curCluster_, &curCluster_)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
}
|
|
curPosition_ = pos;
|
|
|
|
done:
|
|
return true;
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
// set fileSize_ for a directory
|
|
bool SdBaseFile::setDirSize() {
|
|
uint16_t s = 0;
|
|
uint32_t cluster = firstCluster_;
|
|
do {
|
|
if (!vol_->fatGet(cluster, &cluster)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
s += vol_->blocksPerCluster();
|
|
// max size if a directory file is 4096 blocks
|
|
if (s >= 4096) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
} while (!vol_->isEOC(cluster));
|
|
fileSize_ = 512L*s;
|
|
return true;
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//------------------------------------------------------------------------------
|
|
void SdBaseFile::setpos(FatPos_t* pos) {
|
|
curPosition_ = pos->position;
|
|
curCluster_ = pos->cluster;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** The sync() call causes all modified data and directory fields
|
|
* to be written to the storage device.
|
|
*
|
|
* \return The value one, true, is returned for success and
|
|
* the value zero, false, is returned for failure.
|
|
* Reasons for failure include a call to sync() before a file has been
|
|
* opened or an I/O error.
|
|
*/
|
|
bool SdBaseFile::sync() {
|
|
// only allow open files and directories
|
|
if (!isOpen()) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
if (flags_ & F_FILE_DIR_DIRTY) {
|
|
dir_t* d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
|
|
// check for deleted by another open file object
|
|
if (!d || d->name[0] == DIR_NAME_DELETED) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// do not set filesize for dir files
|
|
if (!isDir()) d->fileSize = fileSize_;
|
|
|
|
// update first cluster fields
|
|
d->firstClusterLow = firstCluster_ & 0XFFFF;
|
|
d->firstClusterHigh = firstCluster_ >> 16;
|
|
|
|
// set modify time if user supplied a callback date/time function
|
|
if (dateTime_) {
|
|
dateTime_(&d->lastWriteDate, &d->lastWriteTime);
|
|
d->lastAccessDate = d->lastWriteDate;
|
|
}
|
|
// clear directory dirty
|
|
flags_ &= ~F_FILE_DIR_DIRTY;
|
|
}
|
|
return vol_->cacheSync();
|
|
|
|
fail:
|
|
writeError = true;
|
|
return false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Copy a file's timestamps
|
|
*
|
|
* \param[in] file File to copy timestamps from.
|
|
*
|
|
* \note
|
|
* Modify and access timestamps may be overwritten if a date time callback
|
|
* function has been set by dateTimeCallback().
|
|
*
|
|
* \return The value one, true, is returned for success and
|
|
* the value zero, false, is returned for failure.
|
|
*/
|
|
bool SdBaseFile::timestamp(SdBaseFile* file) {
|
|
dir_t* d;
|
|
dir_t dir;
|
|
|
|
// get timestamps
|
|
if (!file->dirEntry(&dir)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// update directory fields
|
|
if (!sync()) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
|
|
if (!d) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// copy timestamps
|
|
d->lastAccessDate = dir.lastAccessDate;
|
|
d->creationDate = dir.creationDate;
|
|
d->creationTime = dir.creationTime;
|
|
d->creationTimeTenths = dir.creationTimeTenths;
|
|
d->lastWriteDate = dir.lastWriteDate;
|
|
d->lastWriteTime = dir.lastWriteTime;
|
|
|
|
// write back entry
|
|
return vol_->cacheSync();
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Set a file's timestamps in its directory entry.
|
|
*
|
|
* \param[in] flags Values for \a flags are constructed by a bitwise-inclusive
|
|
* OR of flags from the following list
|
|
*
|
|
* T_ACCESS - Set the file's last access date.
|
|
*
|
|
* T_CREATE - Set the file's creation date and time.
|
|
*
|
|
* T_WRITE - Set the file's last write/modification date and time.
|
|
*
|
|
* \param[in] year Valid range 1980 - 2107 inclusive.
|
|
*
|
|
* \param[in] month Valid range 1 - 12 inclusive.
|
|
*
|
|
* \param[in] day Valid range 1 - 31 inclusive.
|
|
*
|
|
* \param[in] hour Valid range 0 - 23 inclusive.
|
|
*
|
|
* \param[in] minute Valid range 0 - 59 inclusive.
|
|
*
|
|
* \param[in] second Valid range 0 - 59 inclusive
|
|
*
|
|
* \note It is possible to set an invalid date since there is no check for
|
|
* the number of days in a month.
|
|
*
|
|
* \note
|
|
* Modify and access timestamps may be overwritten if a date time callback
|
|
* function has been set by dateTimeCallback().
|
|
*
|
|
* \return The value one, true, is returned for success and
|
|
* the value zero, false, is returned for failure.
|
|
*/
|
|
bool SdBaseFile::timestamp(uint8_t flags, uint16_t year, uint8_t month,
|
|
uint8_t day, uint8_t hour, uint8_t minute, uint8_t second) {
|
|
uint16_t dirDate;
|
|
uint16_t dirTime;
|
|
dir_t* d;
|
|
|
|
if (!isOpen()
|
|
|| year < 1980
|
|
|| year > 2107
|
|
|| month < 1
|
|
|| month > 12
|
|
|| day < 1
|
|
|| day > 31
|
|
|| hour > 23
|
|
|| minute > 59
|
|
|| second > 59) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// update directory entry
|
|
if (!sync()) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
|
|
if (!d) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
dirDate = FAT_DATE(year, month, day);
|
|
dirTime = FAT_TIME(hour, minute, second);
|
|
if (flags & T_ACCESS) {
|
|
d->lastAccessDate = dirDate;
|
|
}
|
|
if (flags & T_CREATE) {
|
|
d->creationDate = dirDate;
|
|
d->creationTime = dirTime;
|
|
// seems to be units of 1/100 second not 1/10 as Microsoft states
|
|
d->creationTimeTenths = second & 1 ? 100 : 0;
|
|
}
|
|
if (flags & T_WRITE) {
|
|
d->lastWriteDate = dirDate;
|
|
d->lastWriteTime = dirTime;
|
|
}
|
|
return vol_->cacheSync();
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Truncate a file to a specified length. The current file position
|
|
* will be maintained if it is less than or equal to \a length otherwise
|
|
* it will be set to end of file.
|
|
*
|
|
* \param[in] length The desired length for the file.
|
|
*
|
|
* \return The value one, true, is returned for success and
|
|
* the value zero, false, is returned for failure.
|
|
* Reasons for failure include file is read only, file is a directory,
|
|
* \a length is greater than the current file size or an I/O error occurs.
|
|
*/
|
|
bool SdBaseFile::truncate(uint32_t length) {
|
|
uint32_t newPos;
|
|
// error if not a normal file or read-only
|
|
if (!isFile() || !(flags_ & O_WRITE)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// error if length is greater than current size
|
|
if (length > fileSize_) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// fileSize and length are zero - nothing to do
|
|
if (fileSize_ == 0) return true;
|
|
|
|
// remember position for seek after truncation
|
|
newPos = curPosition_ > length ? length : curPosition_;
|
|
|
|
// position to last cluster in truncated file
|
|
if (!seekSet(length)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
if (length == 0) {
|
|
// free all clusters
|
|
if (!vol_->freeChain(firstCluster_)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
firstCluster_ = 0;
|
|
} else {
|
|
uint32_t toFree;
|
|
if (!vol_->fatGet(curCluster_, &toFree)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
if (!vol_->isEOC(toFree)) {
|
|
// free extra clusters
|
|
if (!vol_->freeChain(toFree)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// current cluster is end of chain
|
|
if (!vol_->fatPutEOC(curCluster_)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
}
|
|
}
|
|
fileSize_ = length;
|
|
|
|
// need to update directory entry
|
|
flags_ |= F_FILE_DIR_DIRTY;
|
|
|
|
if (!sync()) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// set file to correct position
|
|
return seekSet(newPos);
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Write data to an open file.
|
|
*
|
|
* \note Data is moved to the cache but may not be written to the
|
|
* storage device until sync() is called.
|
|
*
|
|
* \param[in] buf Pointer to the location of the data to be written.
|
|
*
|
|
* \param[in] nbyte Number of bytes to write.
|
|
*
|
|
* \return For success write() returns the number of bytes written, always
|
|
* \a nbyte. If an error occurs, write() returns -1. Possible errors
|
|
* include write() is called before a file has been opened, write is called
|
|
* for a read-only file, device is full, a corrupt file system or an I/O error.
|
|
*
|
|
*/
|
|
int SdBaseFile::write(const void* buf, size_t nbyte) {
|
|
// convert void* to uint8_t* - must be before goto statements
|
|
const uint8_t* src = reinterpret_cast<const uint8_t*>(buf);
|
|
cache_t* pc;
|
|
uint8_t cacheOption;
|
|
// number of bytes left to write - must be before goto statements
|
|
size_t nToWrite = nbyte;
|
|
size_t n;
|
|
|
|
#ifdef GLENN_DEBUG
|
|
Com::print("Cur Pos:");
|
|
Com::print(curPosition_);
|
|
Com::println();
|
|
#endif
|
|
|
|
// error if not a normal file or is read-only
|
|
if (/*!isFile() || */!(flags_ & O_WRITE)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
|
|
// seek to end of file if append flag
|
|
if ((flags_ & O_APPEND) && curPosition_ != fileSize_) {
|
|
if (!seekEnd()) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
}
|
|
|
|
while (nToWrite) {
|
|
uint8_t blockOfCluster = vol_->blockOfCluster(curPosition_);
|
|
uint16_t blockOffset = curPosition_ & 0X1FF;
|
|
|
|
#ifdef GLENN_DEBUG
|
|
Com::print("BC");
|
|
Com::print((long)blockOfCluster);
|
|
Com::print("-");
|
|
Com::print((long)blockOffset);
|
|
Com::print("-");
|
|
Com::print((long)curCluster_);
|
|
Com::print("-");
|
|
Com::print((long)firstCluster_);
|
|
Com::print("-");
|
|
Com::print((long)vol_->blocksPerCluster_);
|
|
Com::println();
|
|
#endif
|
|
|
|
if (blockOfCluster == 0 && blockOffset == 0) {
|
|
// start of new cluster
|
|
if (curCluster_ != 0) {
|
|
uint32_t next;
|
|
if (!vol_->fatGet(curCluster_, &next)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
if (vol_->isEOC(next)) {
|
|
// add cluster if at end of chain
|
|
if (!addCluster()) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
} else {
|
|
curCluster_ = next;
|
|
}
|
|
} else {
|
|
if (firstCluster_ == 0) {
|
|
// allocate first cluster of file
|
|
if (!addCluster()) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
} else {
|
|
curCluster_ = firstCluster_;
|
|
}
|
|
}
|
|
}
|
|
// block for data write
|
|
uint32_t block = type_ == FAT_FILE_TYPE_ROOT_FIXED ? vol_->rootDirStart() + (curPosition_ >> 9) : vol_->clusterStartBlock(curCluster_) + blockOfCluster;
|
|
|
|
if (blockOffset != 0 || nToWrite < 512) {
|
|
// partial block - must use cache
|
|
// max space in block
|
|
n = 512 - blockOffset;
|
|
// lesser of space and amount to write
|
|
if (n > nToWrite) n = nToWrite;
|
|
|
|
if (blockOffset == 0 && curPosition_ >= fileSize_) {
|
|
// start of new block don't need to read into cache
|
|
cacheOption = SdVolume::CACHE_RESERVE_FOR_WRITE;
|
|
} else {
|
|
// rewrite part of block
|
|
cacheOption = SdVolume::CACHE_FOR_WRITE;
|
|
}
|
|
#ifdef GLENN_DEBUG
|
|
Com::print("BL:");
|
|
Com::print(block);
|
|
Com::println();
|
|
#endif
|
|
pc = vol_->cacheFetch(block, cacheOption);
|
|
if (!pc) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
uint8_t* dst = pc->data + blockOffset;
|
|
memcpy(dst, src, n);
|
|
if (512 == (n + blockOffset)) {
|
|
if (!vol_->cacheWriteData()) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
}
|
|
} else if (!USE_MULTI_BLOCK_SD_IO || nToWrite < 1024) {
|
|
// use single block write command
|
|
n = 512;
|
|
if (vol_->cacheBlockNumber() == block) {
|
|
vol_->cacheInvalidate();
|
|
}
|
|
if (!vol_->writeBlock(block, src)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
} else {
|
|
// use multiple block write command
|
|
uint8_t maxBlocks = vol_->blocksPerCluster() - blockOfCluster;
|
|
uint8_t nBlock = nToWrite >> 9;
|
|
if (nBlock > maxBlocks) nBlock = maxBlocks;
|
|
|
|
n = 512*nBlock;
|
|
if (!vol_->sdCard()->writeStart(block, nBlock)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
for (uint8_t b = 0; b < nBlock; b++) {
|
|
// invalidate cache if block is in cache
|
|
if ((block + b) == vol_->cacheBlockNumber()) {
|
|
vol_->cacheInvalidate();
|
|
}
|
|
if (!vol_->sdCard()->writeData(src + 512*b)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
}
|
|
if (!vol_->sdCard()->writeStop()) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
}
|
|
curPosition_ += n;
|
|
src += n;
|
|
nToWrite -= n;
|
|
}
|
|
#ifdef GLENN_DEBUG
|
|
Com::print("Cur Pos:");
|
|
Com::print(curPosition_);
|
|
Com::println();
|
|
#endif
|
|
|
|
if (curPosition_ > fileSize_) {
|
|
// update fileSize and insure sync will update dir entry
|
|
fileSize_ = curPosition_;
|
|
flags_ |= F_FILE_DIR_DIRTY;
|
|
} else if (dateTime_ && nbyte) {
|
|
// insure sync will update modified date and time
|
|
flags_ |= F_FILE_DIR_DIRTY;
|
|
}
|
|
|
|
if (flags_ & O_SYNC) {
|
|
if (!sync()) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
}
|
|
return nbyte;
|
|
|
|
fail:
|
|
// return for write error
|
|
writeError = true;
|
|
return -1;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
// suppress cpplint warnings with NOLINT comment
|
|
#if ALLOW_DEPRECATED_FUNCTIONS && !defined(DOXYGEN)
|
|
void (*SdBaseFile::oldDateTime_)(uint16_t& date, uint16_t& time) = 0; // NOLINT
|
|
#endif // ALLOW_DEPRECATED_FUNCTIONS
|
|
|
|
// ============== Sd2Card.cpp =============
|
|
|
|
//==============================================================================
|
|
// debug trace macro
|
|
#define SD_TRACE(m, b)
|
|
// #define SD_TRACE(m, b) Serial.print(m);Serial.println(b);
|
|
// SPI functions
|
|
#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 SPI pins
|
|
*/
|
|
static void spiBegin() {
|
|
HAL::spiBegin();
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
* Initialize hardware SPI
|
|
* Set SCK rate to F_CPU/pow(2, 1 + spiRate) for spiRate [0,6]
|
|
*/
|
|
static void spiInit(uint8_t spiRate) {
|
|
HAL::spiInit(spiRate);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** SPI receive a byte */
|
|
static uint8_t spiRec() {
|
|
return HAL::spiReceive();
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** SPI read data - only one call so force inline */
|
|
static inline __attribute__((always_inline))
|
|
uint8_t spiRec(uint8_t* buf, uint16_t nbyte) {
|
|
HAL::spiReadBlock(buf,nbyte);
|
|
return 0;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** SPI send a byte */
|
|
static void spiSend(uint8_t b) {
|
|
HAL::spiSend(b);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** SPI send block - only one call so force inline */
|
|
static inline __attribute__((always_inline))
|
|
void spiSendBlock(uint8_t token, const uint8_t* buf) {
|
|
HAL::spiSendBlock(token,buf);
|
|
}
|
|
static void spiSend(const uint8_t* buf , size_t n) {
|
|
HAL::spiSend(buf,n);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
#else // SOFTWARE_SPI
|
|
#include <SoftSPI.h>
|
|
static
|
|
SoftSPI<SOFT_SPI_MISO_PIN, SOFT_SPI_MOSI_PIN, SOFT_SPI_SCK_PIN, 0> softSpiBus;
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
* initialize SPI pins
|
|
*/
|
|
static void spiBegin() {
|
|
softSpiBus.begin();
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Soft SPI receive byte */
|
|
static uint8_t spiRec() {
|
|
return softSpiBus.receive();
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Soft SPI read data */
|
|
static uint8_t spiRec(uint8_t* buf, size_t nbyte) {
|
|
for (size_t i = 0; i < nbyte; i++) {
|
|
buf[i] = spiRec();
|
|
}
|
|
return 0;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Soft SPI send byte */
|
|
static void spiSend(uint8_t data) {
|
|
softSpiBus.send(data);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Soft SPI send block */
|
|
static 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
|
|
//==============================================================================
|
|
#if USE_SD_CRC
|
|
// CRC functions
|
|
//------------------------------------------------------------------------------
|
|
static uint8_t CRC7(const uint8_t* data, uint8_t n) {
|
|
uint8_t crc = 0;
|
|
for (uint8_t i = 0; i < n; i++) {
|
|
uint8_t d = data[i];
|
|
for (uint8_t j = 0; j < 8; j++) {
|
|
crc <<= 1;
|
|
if ((d & 0x80) ^ (crc & 0x80)) crc ^= 0x09;
|
|
d <<= 1;
|
|
}
|
|
}
|
|
return (crc << 1) | 1;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
#if USE_SD_CRC == 1
|
|
// slower CRC-CCITT
|
|
// uses the x^16,x^12,x^5,x^1 polynomial.
|
|
static uint16_t CRC_CCITT(const uint8_t *data, size_t n) {
|
|
uint16_t crc = 0;
|
|
for (size_t i = 0; i < n; i++) {
|
|
crc = (uint8_t)(crc >> 8) | (crc << 8);
|
|
crc ^= data[i];
|
|
crc ^= (uint8_t)(crc & 0xff) >> 4;
|
|
crc ^= crc << 12;
|
|
crc ^= (crc & 0xff) << 5;
|
|
}
|
|
return crc;
|
|
}
|
|
#elif USE_SD_CRC > 1 // CRC_CCITT
|
|
//------------------------------------------------------------------------------
|
|
// faster CRC-CCITT
|
|
// uses the x^16,x^12,x^5,x^1 polynomial.
|
|
static const uint16_t crctab[] PROGMEM = {
|
|
0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
|
|
0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
|
|
0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
|
|
0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
|
|
0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
|
|
0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
|
|
0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
|
|
0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
|
|
0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
|
|
0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
|
|
0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
|
|
0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
|
|
0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
|
|
0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
|
|
0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
|
|
0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
|
|
0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
|
|
0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
|
|
0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
|
|
0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
|
|
0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
|
|
0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
|
|
0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
|
|
0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
|
|
0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
|
|
0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
|
|
0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
|
|
0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
|
|
0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
|
|
0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
|
|
0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
|
|
0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
|
|
};
|
|
static uint16_t CRC_CCITT(const uint8_t* data, size_t n) {
|
|
uint16_t crc = 0;
|
|
for (size_t i = 0; i < n; i++) {
|
|
crc = pgm_read_word(&crctab[(crc >> 8 ^ data[i]) & 0XFF]) ^ (crc << 8);
|
|
}
|
|
return crc;
|
|
}
|
|
#endif // CRC_CCITT
|
|
#endif // USE_SD_CRC
|
|
//==============================================================================
|
|
// Sd2Card member functions
|
|
//------------------------------------------------------------------------------
|
|
// 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);
|
|
|
|
uint8_t *pa = reinterpret_cast<uint8_t *>(&arg);
|
|
|
|
#if USE_SD_CRC
|
|
// form message
|
|
uint8_t d[6] = {cmd | 0X40, pa[3], pa[2], pa[1], pa[0]};
|
|
|
|
// add crc
|
|
d[5] = CRC7(d, 5);
|
|
|
|
// send message
|
|
for (uint8_t k = 0; k < 6; k++) spiSend(d[k]);
|
|
#else // USE_SD_CRC
|
|
// send command
|
|
spiSend(cmd | 0x40);
|
|
|
|
// send argument
|
|
for (int8_t i = 3; i >= 0; i--) spiSend(pa[i]);
|
|
|
|
// send CRC - correct for CMD0 with arg zero or CMD8 with arg 0X1AA
|
|
spiSend(cmd == CMD0 ? 0X95 : 0X87);
|
|
#endif // USE_SD_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 = 0X10000L * csd.v2.c_size_high + 0X100L
|
|
* (uint32_t)csd.v2.c_size_mid + csd.v2.c_size_low;
|
|
return (c_size + 1) << 10;
|
|
} else {
|
|
error(SD_CARD_ERROR_BAD_CSD);
|
|
return 0;
|
|
}
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
void Sd2Card::chipSelectHigh() {
|
|
HAL::digitalWrite(chipSelectPin_, HIGH);
|
|
// insure MISO goes high impedance
|
|
HAL::spiSend(0XFF);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
void Sd2Card::chipSelectLow() {
|
|
#ifndef SOFTWARE_SPI
|
|
spiInit(spiRate_);
|
|
#endif // SOFTWARE_SPI
|
|
HAL::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)HAL::timeInMilliseconds();
|
|
uint32_t arg;
|
|
|
|
HAL::pinMode(chipSelectPin_, OUTPUT);
|
|
HAL::digitalWrite(chipSelectPin_, HIGH);
|
|
spiBegin();
|
|
|
|
#ifndef SOFTWARE_SPI
|
|
// 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 < 20; i++) spiSend(0XFF);
|
|
|
|
// command to go idle in SPI mode
|
|
while (cardCommand(CMD0, 0) != R1_IDLE_STATE) {
|
|
if (((uint16_t)HAL::timeInMilliseconds() - t0) > SD_INIT_TIMEOUT) {
|
|
error(SD_CARD_ERROR_CMD0);
|
|
goto fail;
|
|
}
|
|
}
|
|
#if USE_SD_CRC
|
|
if (cardCommand(CMD59, 1) != R1_IDLE_STATE) {
|
|
error(SD_CARD_ERROR_CMD59);
|
|
goto fail;
|
|
}
|
|
#endif // USE_SD_CRC
|
|
// check SD version
|
|
while (1) {
|
|
if (cardCommand(CMD8, 0x1AA) == (R1_ILLEGAL_COMMAND | R1_IDLE_STATE)) {
|
|
type(SD_CARD_TYPE_SD1);
|
|
break;
|
|
}
|
|
for (uint8_t i = 0; i < 4; i++) status_ = spiRec();
|
|
if (status_ == 0XAA) {
|
|
type(SD_CARD_TYPE_SD2);
|
|
break;
|
|
}
|
|
if (((uint16_t)HAL::timeInMilliseconds() - t0) > SD_INIT_TIMEOUT) {
|
|
error(SD_CARD_ERROR_CMD8);
|
|
goto fail;
|
|
}
|
|
}
|
|
// initialize card and send host supports SDHC if SD2
|
|
arg = type() == SD_CARD_TYPE_SD2 ? 0X40000000 : 0;
|
|
|
|
while (cardAcmd(ACMD41, arg) != R1_READY_STATE) {
|
|
// check for timeout
|
|
if (((uint16_t)HAL::timeInMilliseconds() - 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) {
|
|
SD_TRACE("RB", blockNumber);
|
|
// 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, size_t count) {
|
|
uint16_t crc;
|
|
// wait for start block token
|
|
uint16_t t0 = HAL::timeInMilliseconds();
|
|
while ((status_ = spiRec()) == 0XFF) {
|
|
if (((uint16_t)HAL::timeInMilliseconds() - 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
|
|
if (status_ = spiRec(dst, count)) {
|
|
error(SD_CARD_ERROR_SPI_DMA);
|
|
goto fail;
|
|
}
|
|
// get crc
|
|
crc = (spiRec() << 8) | spiRec();
|
|
#if USE_SD_CRC
|
|
if (crc != CRC_CCITT(dst, count)) {
|
|
error(SD_CARD_ERROR_READ_CRC);
|
|
goto fail;
|
|
}
|
|
#endif // USE_SD_CRC
|
|
|
|
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) {
|
|
SD_TRACE("RS", 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, 14].
|
|
*
|
|
* The SPI clock divisor will be set to approximately
|
|
*
|
|
* (2 + (sckRateID & 1)) << ( sckRateID/2)
|
|
*
|
|
* The maximum SPI rate is F_CPU/2 for \a sckRateID = 0 and the rate is
|
|
* F_CPU/128 for \a scsRateID = 12.
|
|
*
|
|
* \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 > MAX_SCK_RATE_ID) {
|
|
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 = HAL::timeInMilliseconds();
|
|
while (spiRec() != 0XFF) {
|
|
if (((uint16_t)HAL::timeInMilliseconds() - 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) {
|
|
SD_TRACE("WB", blockNumber);
|
|
// 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) {
|
|
#if USE_SD_CRC
|
|
uint16_t crc = CRC_CCITT(src, 512);
|
|
#else // USE_SD_CRC
|
|
uint16_t crc = 0XFFFF;
|
|
#endif // USE_SD_CRC
|
|
|
|
spiSend(token);
|
|
spiSend(src, 512);
|
|
spiSend(crc >> 8);
|
|
spiSend(crc & 0XFF);
|
|
|
|
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) {
|
|
SD_TRACE("WS", blockNumber);
|
|
// 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;
|
|
}
|
|
|
|
// =================== SdVolume ===================
|
|
|
|
//------------------------------------------------------------------------------
|
|
#if !USE_MULTIPLE_CARDS
|
|
// raw block cache
|
|
|
|
cache_t SdVolume::cacheBuffer_; // 512 byte cache for Sd2Card
|
|
uint32_t SdVolume::cacheBlockNumber_; // current block number
|
|
uint8_t SdVolume::cacheStatus_; // status of cache block
|
|
uint32_t SdVolume::cacheFatOffset_; // offset for mirrored FAT
|
|
#if USE_SEPARATE_FAT_CACHE
|
|
cache_t SdVolume::cacheFatBuffer_; // 512 byte cache for FAT
|
|
uint32_t SdVolume::cacheFatBlockNumber_; // current Fat block number
|
|
uint8_t SdVolume::cacheFatStatus_; // status of cache Fatblock
|
|
#endif // USE_SEPARATE_FAT_CACHE
|
|
Sd2Card* SdVolume::sdCard_; // pointer to SD card object
|
|
#endif // USE_MULTIPLE_CARDS
|
|
//------------------------------------------------------------------------------
|
|
// find a contiguous group of clusters
|
|
bool SdVolume::allocContiguous(uint32_t count, uint32_t* curCluster) {
|
|
// start of group
|
|
uint32_t bgnCluster;
|
|
// end of group
|
|
uint32_t endCluster;
|
|
// last cluster of FAT
|
|
uint32_t fatEnd = clusterCount_ + 1;
|
|
|
|
// flag to save place to start next search
|
|
bool setStart;
|
|
|
|
// set search start cluster
|
|
if (*curCluster) {
|
|
// try to make file contiguous
|
|
bgnCluster = *curCluster + 1;
|
|
|
|
// don't save new start location
|
|
setStart = false;
|
|
} else {
|
|
// start at likely place for free cluster
|
|
bgnCluster = allocSearchStart_;
|
|
|
|
// save next search start if one cluster
|
|
setStart = count == 1;
|
|
}
|
|
// end of group
|
|
endCluster = bgnCluster;
|
|
|
|
// search the FAT for free clusters
|
|
for (uint32_t n = 0;; n++, endCluster++) {
|
|
// can't find space checked all clusters
|
|
if (n >= clusterCount_) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
|
|
// past end - start from beginning of FAT
|
|
if (endCluster > fatEnd) {
|
|
bgnCluster = endCluster = 2;
|
|
}
|
|
uint32_t f;
|
|
if (!fatGet(endCluster, &f)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
|
|
if (f != 0) {
|
|
// cluster in use try next cluster as bgnCluster
|
|
bgnCluster = endCluster + 1;
|
|
} else if ((endCluster - bgnCluster + 1) == count) {
|
|
// done - found space
|
|
break;
|
|
}
|
|
}
|
|
// mark end of chain
|
|
if (!fatPutEOC(endCluster)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
|
|
// link clusters
|
|
while (endCluster > bgnCluster) {
|
|
if (!fatPut(endCluster - 1, endCluster)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
endCluster--;
|
|
}
|
|
if (*curCluster != 0) {
|
|
// connect chains
|
|
if (!fatPut(*curCluster, bgnCluster)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
}
|
|
// return first cluster number to caller
|
|
*curCluster = bgnCluster;
|
|
// remember possible next free cluster
|
|
if (setStart) allocSearchStart_ = bgnCluster + 1;
|
|
return true;
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
//==============================================================================
|
|
|
|
// cache functions
|
|
|
|
#if USE_SEPARATE_FAT_CACHE
|
|
|
|
//------------------------------------------------------------------------------
|
|
cache_t* SdVolume::cacheFetch(uint32_t blockNumber, uint8_t options) {
|
|
return cacheFetchData(blockNumber, options);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
cache_t* SdVolume::cacheFetchData(uint32_t blockNumber, uint8_t options) {
|
|
if (cacheBlockNumber_ != blockNumber) {
|
|
if (!cacheWriteData()) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
if (!(options & CACHE_OPTION_NO_READ)) {
|
|
#ifdef GLENN_DEBUG
|
|
Com::print("Rd blk:");
|
|
Com::print(blockNumber);
|
|
Com::println();
|
|
#endif
|
|
if (!sdCard_->readBlock(blockNumber, cacheBuffer_.data)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
}
|
|
cacheStatus_ = 0;
|
|
cacheBlockNumber_ = blockNumber;
|
|
}
|
|
cacheStatus_ |= options & CACHE_STATUS_MASK;
|
|
return &cacheBuffer_;
|
|
|
|
fail:
|
|
return 0;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
cache_t* SdVolume::cacheFetchFat(uint32_t blockNumber, uint8_t options) {
|
|
if (cacheFatBlockNumber_ != blockNumber) {
|
|
if (!cacheWriteFat()) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
if (!(options & CACHE_OPTION_NO_READ)) {
|
|
if (!sdCard_->readBlock(blockNumber, cacheFatBuffer_.data)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
}
|
|
cacheFatStatus_ = 0;
|
|
cacheFatBlockNumber_ = blockNumber;
|
|
}
|
|
cacheFatStatus_ |= options & CACHE_STATUS_MASK;
|
|
return &cacheFatBuffer_;
|
|
|
|
fail:
|
|
return 0;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
bool SdVolume::cacheSync() {
|
|
return cacheWriteData() && cacheWriteFat();
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
bool SdVolume::cacheWriteData() {
|
|
if (cacheStatus_ & CACHE_STATUS_DIRTY) {
|
|
if (!sdCard_->writeBlock(cacheBlockNumber_, cacheBuffer_.data)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
cacheStatus_ &= ~CACHE_STATUS_DIRTY;
|
|
}
|
|
return true;
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
bool SdVolume::cacheWriteFat() {
|
|
if (cacheFatStatus_ & CACHE_STATUS_DIRTY) {
|
|
if (!sdCard_->writeBlock(cacheFatBlockNumber_, cacheFatBuffer_.data)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// mirror second FAT
|
|
if (cacheFatOffset_) {
|
|
uint32_t lbn = cacheFatBlockNumber_ + cacheFatOffset_;
|
|
if (!sdCard_->writeBlock(lbn, cacheFatBuffer_.data)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
}
|
|
cacheFatStatus_ &= ~CACHE_STATUS_DIRTY;
|
|
}
|
|
return true;
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
#else // USE_SEPARATE_FAT_CACHE
|
|
//------------------------------------------------------------------------------
|
|
cache_t* SdVolume::cacheFetch(uint32_t blockNumber, uint8_t options) {
|
|
if (cacheBlockNumber_ != blockNumber) {
|
|
if (!cacheSync()) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
if (!(options & CACHE_OPTION_NO_READ)) {
|
|
if (!sdCard_->readBlock(blockNumber, cacheBuffer_.data)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
}
|
|
cacheStatus_ = 0;
|
|
cacheBlockNumber_ = blockNumber;
|
|
}
|
|
cacheStatus_ |= options & CACHE_STATUS_MASK;
|
|
return &cacheBuffer_;
|
|
|
|
fail:
|
|
return 0;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
cache_t* SdVolume::cacheFetchFat(uint32_t blockNumber, uint8_t options) {
|
|
return cacheFetch(blockNumber, options | CACHE_STATUS_FAT_BLOCK);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
bool SdVolume::cacheSync() {
|
|
if (cacheStatus_ & CACHE_STATUS_DIRTY) {
|
|
#ifdef GLENN_DEBUG
|
|
Com::print("Wr blk:");
|
|
Com::print(cacheBlockNumber_);
|
|
Com::println();
|
|
#endif
|
|
if (!sdCard_->writeBlock(cacheBlockNumber_, cacheBuffer_.data)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// mirror second FAT
|
|
if ((cacheStatus_ & CACHE_STATUS_FAT_BLOCK) && cacheFatOffset_) {
|
|
uint32_t lbn = cacheBlockNumber_ + cacheFatOffset_;
|
|
if (!sdCard_->writeBlock(lbn, cacheBuffer_.data)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
}
|
|
cacheStatus_ &= ~CACHE_STATUS_DIRTY;
|
|
}
|
|
return true;
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
bool SdVolume::cacheWriteData() {
|
|
return cacheSync();
|
|
}
|
|
#endif // USE_SEPARATE_FAT_CACHE
|
|
//------------------------------------------------------------------------------
|
|
void SdVolume::cacheInvalidate() {
|
|
cacheBlockNumber_ = 0XFFFFFFFF;
|
|
cacheStatus_ = 0;
|
|
}
|
|
//==============================================================================
|
|
//------------------------------------------------------------------------------
|
|
uint32_t SdVolume::clusterStartBlock(uint32_t cluster) const {
|
|
return dataStartBlock_ + ((cluster - 2)*blocksPerCluster_);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
// Fetch a FAT entry
|
|
bool SdVolume::fatGet(uint32_t cluster, uint32_t* value) {
|
|
uint32_t lba;
|
|
cache_t* pc;
|
|
|
|
// error if reserved cluster of beyond FAT
|
|
|
|
if (cluster < 2 || cluster > (clusterCount_ + 1)) {
|
|
|
|
DBG_FAIL_MACRO;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
if (FAT12_SUPPORT && fatType_ == 12) {
|
|
|
|
uint16_t index = cluster;
|
|
|
|
index += index >> 1;
|
|
|
|
lba = fatStartBlock_ + (index >> 9);
|
|
pc = cacheFetchFat(lba, CACHE_FOR_READ);
|
|
if (!pc) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
index &= 0X1FF;
|
|
uint16_t tmp = pc->data[index];
|
|
index++;
|
|
if (index == 512) {
|
|
pc = cacheFetchFat(lba + 1, CACHE_FOR_READ);
|
|
if (!pc) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
index = 0;
|
|
}
|
|
tmp |= pc->data[index] << 8;
|
|
*value = cluster & 1 ? tmp >> 4 : tmp & 0XFFF;
|
|
return true;
|
|
}
|
|
if (fatType_ == 16) {
|
|
lba = fatStartBlock_ + (cluster >> 8);
|
|
} else if (fatType_ == 32) {
|
|
lba = fatStartBlock_ + (cluster >> 7);
|
|
} else {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
pc = cacheFetchFat(lba, CACHE_FOR_READ);
|
|
if (!pc) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
if (fatType_ == 16) {
|
|
*value = pc->fat16[cluster & 0XFF];
|
|
} else {
|
|
*value = pc->fat32[cluster & 0X7F] & FAT32MASK;
|
|
}
|
|
return true;
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
// Store a FAT entry
|
|
bool SdVolume::fatPut(uint32_t cluster, uint32_t value) {
|
|
uint32_t lba;
|
|
cache_t* pc;
|
|
// error if reserved cluster of beyond FAT
|
|
if (cluster < 2 || cluster > (clusterCount_ + 1)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
if (FAT12_SUPPORT && fatType_ == 12) {
|
|
uint16_t index = cluster;
|
|
index += index >> 1;
|
|
lba = fatStartBlock_ + (index >> 9);
|
|
pc = cacheFetchFat(lba, CACHE_FOR_WRITE);
|
|
if (!pc) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
index &= 0X1FF;
|
|
uint8_t tmp = value;
|
|
if (cluster & 1) {
|
|
tmp = (pc->data[index] & 0XF) | tmp << 4;
|
|
}
|
|
pc->data[index] = tmp;
|
|
|
|
index++;
|
|
if (index == 512) {
|
|
lba++;
|
|
index = 0;
|
|
pc = cacheFetchFat(lba, CACHE_FOR_WRITE);
|
|
if (!pc) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
}
|
|
tmp = value >> 4;
|
|
if (!(cluster & 1)) {
|
|
tmp = ((pc->data[index] & 0XF0)) | tmp >> 4;
|
|
}
|
|
pc->data[index] = tmp;
|
|
return true;
|
|
}
|
|
if (fatType_ == 16) {
|
|
lba = fatStartBlock_ + (cluster >> 8);
|
|
} else if (fatType_ == 32) {
|
|
lba = fatStartBlock_ + (cluster >> 7);
|
|
} else {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
pc = cacheFetchFat(lba, CACHE_FOR_WRITE);
|
|
if (!pc) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// store entry
|
|
if (fatType_ == 16) {
|
|
pc->fat16[cluster & 0XFF] = value;
|
|
} else {
|
|
pc->fat32[cluster & 0X7F] = value;
|
|
}
|
|
return true;
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
// free a cluster chain
|
|
bool SdVolume::freeChain(uint32_t cluster) {
|
|
uint32_t next;
|
|
|
|
// clear free cluster location
|
|
allocSearchStart_ = 2;
|
|
|
|
do {
|
|
if (!fatGet(cluster, &next)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
// free cluster
|
|
if (!fatPut(cluster, 0)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
|
|
cluster = next;
|
|
} while (!isEOC(cluster));
|
|
|
|
return true;
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Volume free space in clusters.
|
|
*
|
|
* \return Count of free clusters for success or -1 if an error occurs.
|
|
*/
|
|
int32_t SdVolume::freeClusterCount() {
|
|
uint32_t free = 0;
|
|
uint32_t lba;
|
|
uint32_t todo = clusterCount_ + 2;
|
|
uint16_t n;
|
|
|
|
if (FAT12_SUPPORT && fatType_ == 12) {
|
|
for (unsigned i = 2; i < todo; i++) {
|
|
uint32_t c;
|
|
if (!fatGet(i, &c)) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
if (c == 0) free++;
|
|
}
|
|
} else if (fatType_ == 16 || fatType_ == 32) {
|
|
lba = fatStartBlock_;
|
|
while (todo) {
|
|
cache_t* pc = cacheFetchFat(lba++, CACHE_FOR_READ);
|
|
if (!pc) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
n = fatType_ == 16 ? 256 : 128;
|
|
if (todo < n) n = todo;
|
|
if (fatType_ == 16) {
|
|
for (uint16_t i = 0; i < n; i++) {
|
|
if (pc->fat16[i] == 0) free++;
|
|
}
|
|
} else {
|
|
for (uint16_t i = 0; i < n; i++) {
|
|
if (pc->fat32[i] == 0) free++;
|
|
}
|
|
}
|
|
todo -= n;
|
|
}
|
|
} else {
|
|
// invalid FAT type
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
return free;
|
|
|
|
fail:
|
|
return -1;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Initialize a FAT volume.
|
|
*
|
|
* \param[in] dev The SD card where the volume is located.
|
|
*
|
|
* \param[in] part The partition to be used. Legal values for \a part are
|
|
* 1-4 to use the corresponding partition on a device formatted with
|
|
* a MBR, Master Boot Record, or zero if the device is formatted as
|
|
* a super floppy with the FAT boot sector in block zero.
|
|
*
|
|
* \return The value one, true, is returned for success and
|
|
* the value zero, false, is returned for failure. Reasons for
|
|
* failure include not finding a valid partition, not finding a valid
|
|
* FAT file system in the specified partition or an I/O error.
|
|
*/
|
|
bool SdVolume::init(Sd2Card* dev, uint8_t part) {
|
|
uint32_t totalBlocks;
|
|
uint32_t volumeStartBlock = 0;
|
|
fat32_boot_t* fbs;
|
|
cache_t* pc;
|
|
sdCard_ = dev;
|
|
fatType_ = 0;
|
|
allocSearchStart_ = 2;
|
|
cacheStatus_ = 0; // cacheSync() will write block if true
|
|
cacheBlockNumber_ = 0XFFFFFFFF;
|
|
cacheFatOffset_ = 0;
|
|
#if USE_SERARATEFAT_CACHE
|
|
cacheFatStatus_ = 0; // cacheSync() will write block if true
|
|
cacheFatBlockNumber_ = 0XFFFFFFFF;
|
|
#endif // USE_SERARATEFAT_CACHE
|
|
// if part == 0 assume super floppy with FAT boot sector in block zero
|
|
// if part > 0 assume mbr volume with partition table
|
|
if (part) {
|
|
if (part > 4) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
pc = cacheFetch(volumeStartBlock, CACHE_FOR_READ);
|
|
if (!pc) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
part_t* p = &pc->mbr.part[part-1];
|
|
if ((p->boot & 0X7F) !=0 ||
|
|
p->totalSectors < 100 ||
|
|
p->firstSector == 0) {
|
|
// not a valid partition
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
volumeStartBlock = p->firstSector;
|
|
}
|
|
pc = cacheFetch(volumeStartBlock, CACHE_FOR_READ);
|
|
if (!pc) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
fbs = &(pc->fbs32);
|
|
if (fbs->bytesPerSector != 512 ||
|
|
fbs->fatCount == 0 ||
|
|
fbs->reservedSectorCount == 0 ||
|
|
fbs->sectorsPerCluster == 0) {
|
|
// not valid FAT volume
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
fatCount_ = fbs->fatCount;
|
|
blocksPerCluster_ = fbs->sectorsPerCluster;
|
|
// determine shift that is same as multiply by blocksPerCluster_
|
|
clusterSizeShift_ = 0;
|
|
while (blocksPerCluster_ != (1 << clusterSizeShift_)) {
|
|
// error if not power of 2
|
|
if (clusterSizeShift_++ > 7) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
}
|
|
blocksPerFat_ = fbs->sectorsPerFat16 ?
|
|
fbs->sectorsPerFat16 : fbs->sectorsPerFat32;
|
|
|
|
if (fatCount_ > 0) cacheFatOffset_ = blocksPerFat_;
|
|
fatStartBlock_ = volumeStartBlock + fbs->reservedSectorCount;
|
|
|
|
// count for FAT16 zero for FAT32
|
|
rootDirEntryCount_ = fbs->rootDirEntryCount;
|
|
|
|
// directory start for FAT16 dataStart for FAT32
|
|
rootDirStart_ = fatStartBlock_ + fbs->fatCount * blocksPerFat_;
|
|
|
|
// data start for FAT16 and FAT32
|
|
dataStartBlock_ = rootDirStart_ + ((32 * fbs->rootDirEntryCount + 511)/512);
|
|
|
|
// total blocks for FAT16 or FAT32
|
|
totalBlocks = fbs->totalSectors16 ?
|
|
fbs->totalSectors16 : fbs->totalSectors32;
|
|
// total data blocks
|
|
clusterCount_ = totalBlocks - (dataStartBlock_ - volumeStartBlock);
|
|
|
|
// divide by cluster size to get cluster count
|
|
clusterCount_ >>= clusterSizeShift_;
|
|
|
|
// FAT type is determined by cluster count
|
|
if (clusterCount_ < 4085) {
|
|
fatType_ = 12;
|
|
if (!FAT12_SUPPORT) {
|
|
DBG_FAIL_MACRO;
|
|
goto fail;
|
|
}
|
|
} else if (clusterCount_ < 65525) {
|
|
fatType_ = 16;
|
|
} else {
|
|
rootDirStart_ = fbs->fat32RootCluster;
|
|
fatType_ = 32;
|
|
}
|
|
return true;
|
|
|
|
fail:
|
|
return false;
|
|
}
|
|
// =============== SdFile.cpp ====================
|
|
|
|
/** Create a file object and open it in the current working directory.
|
|
*
|
|
* \param[in] path A path with a valid 8.3 DOS name for a file to be opened.
|
|
*
|
|
* \param[in] oflag Values for \a oflag are constructed by a bitwise-inclusive
|
|
* OR of open flags. see SdBaseFile::open(SdBaseFile*, const char*, uint8_t).
|
|
*/
|
|
SdFile::SdFile(const char* path, uint8_t oflag) : SdBaseFile(path, oflag) {
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Write data to an open file.
|
|
*
|
|
* \note Data is moved to the cache but may not be written to the
|
|
* storage device until sync() is called.
|
|
*
|
|
* \param[in] buf Pointer to the location of the data to be written.
|
|
*
|
|
* \param[in] nbyte Number of bytes to write.
|
|
*
|
|
* \return For success write() returns the number of bytes written, always
|
|
* \a nbyte. If an error occurs, write() returns -1. Possible errors
|
|
* include write() is called before a file has been opened, write is called
|
|
* for a read-only file, device is full, a corrupt file system or an I/O error.
|
|
*
|
|
*/
|
|
int SdFile::write(const void* buf, size_t nbyte) {
|
|
return SdBaseFile::write(buf, nbyte);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Write a byte to a file. Required by the Arduino Print class.
|
|
* \param[in] b the byte to be written.
|
|
* Use getWriteError to check for errors.
|
|
* \return 1 for success and 0 for failure.
|
|
*/
|
|
#ifdef COMPAT_PRE1
|
|
void SdFile::write(uint8_t b) {
|
|
SdBaseFile::write(&b, 1);
|
|
}
|
|
#else
|
|
size_t SdFile::write(uint8_t b) {
|
|
return SdBaseFile::write(&b, 1) == 1 ? 1 : 0;
|
|
}
|
|
#endif
|
|
|
|
//------------------------------------------------------------------------------
|
|
/** Write a string to a file. Used by the Arduino Print class.
|
|
* \param[in] str Pointer to the string.
|
|
* Use getWriteError to check for errors.
|
|
* \return count of characters written for success or -1 for failure.
|
|
*/
|
|
int SdFile::write(const char* str) {
|
|
return SdBaseFile::write(str, strlen(str));
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Write a PROGMEM string to a file.
|
|
* \param[in] str Pointer to the PROGMEM string.
|
|
* Use getWriteError to check for errors.
|
|
*/
|
|
void SdFile::write_P(FSTRINGPARAM(str)) {
|
|
for (uint8_t c; (c = HAL::readFlashByte(str)); str++) write(c);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** Write a PROGMEM string followed by CR/LF to a file.
|
|
* \param[in] str Pointer to the PROGMEM string.
|
|
* Use getWriteError to check for errors.
|
|
*/
|
|
void SdFile::writeln_P(FSTRINGPARAM(str)) {
|
|
write_P(str);
|
|
write_P(Com::tNewline);
|
|
}
|
|
|
|
// ================ SdFatUtil.cpp ===================
|
|
|
|
//------------------------------------------------------------------------------
|
|
/** Amount of free RAM
|
|
* \return The number of free bytes.
|
|
*/
|
|
int SdFatUtil::FreeRam() {
|
|
extern int __bss_end;
|
|
extern int* __brkval;
|
|
int free_memory;
|
|
if (reinterpret_cast<int>(__brkval) == 0) {
|
|
// if no heap use from end of bss section
|
|
free_memory = reinterpret_cast<int>(&free_memory)
|
|
- reinterpret_cast<int>(&__bss_end);
|
|
} else {
|
|
// use from top of stack to heap
|
|
free_memory = reinterpret_cast<int>(&free_memory)
|
|
- reinterpret_cast<int>(__brkval);
|
|
}
|
|
return free_memory;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
/** %Print a string in flash memory to Serial.
|
|
*
|
|
* \param[in] str Pointer to string stored in flash memory.
|
|
*/
|
|
void SdFatUtil::SerialPrint_P(FSTRINGPARAM(str)) {
|
|
Com::printF(str);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/** %Print a string in flash memory to Serial followed by a CR/LF.
|
|
*
|
|
* \param[in] str Pointer to string stored in flash memory.
|
|
*/
|
|
void SdFatUtil::SerialPrintln_P(FSTRINGPARAM(str)) {
|
|
Com::printFLN(str);
|
|
}
|
|
|
|
// ==============
|
|
|
|
#endif // SDSUPPORT
|
|
|