00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #ifndef SdFat_h
00021 #define SdFat_h
00022
00026 #include <avr/pgmspace.h>
00027 #include "Sd2Card.h"
00028 #include "FatStructs.h"
00029 #include "Print.h"
00030
00034 #define ALLOW_DEPRECATED_FUNCTIONS 1
00035
00036
00037 class SdVolume;
00038
00039
00040
00041
00043 uint8_t const LS_DATE = 1;
00045 uint8_t const LS_SIZE = 2;
00047 uint8_t const LS_R = 4;
00048
00049
00051 uint8_t const O_READ = 0X01;
00053 uint8_t const O_RDONLY = O_READ;
00055 uint8_t const O_WRITE = 0X02;
00057 uint8_t const O_WRONLY = O_WRITE;
00059 uint8_t const O_RDWR = (O_READ | O_WRITE);
00061 uint8_t const O_ACCMODE = (O_READ | O_WRITE);
00063 uint8_t const O_APPEND = 0X04;
00065 uint8_t const O_SYNC = 0X08;
00067 uint8_t const O_CREAT = 0X10;
00069 uint8_t const O_EXCL = 0X20;
00071 uint8_t const O_TRUNC = 0X40;
00072
00073
00075 uint8_t const T_ACCESS = 1;
00077 uint8_t const T_CREATE = 2;
00079 uint8_t const T_WRITE = 4;
00080
00082 uint8_t const FAT_FILE_TYPE_CLOSED = 0;
00084 uint8_t const FAT_FILE_TYPE_NORMAL = 1;
00086 uint8_t const FAT_FILE_TYPE_ROOT16 = 2;
00088 uint8_t const FAT_FILE_TYPE_ROOT32 = 3;
00090 uint8_t const FAT_FILE_TYPE_SUBDIR = 4;
00092 uint8_t const FAT_FILE_TYPE_MIN_DIR = FAT_FILE_TYPE_ROOT16;
00093
00095 static inline uint16_t FAT_DATE(uint16_t year, uint8_t month, uint8_t day) {
00096 return (year - 1980) << 9 | month << 5 | day;
00097 }
00099 static inline uint16_t FAT_YEAR(uint16_t fatDate) {
00100 return 1980 + (fatDate >> 9);
00101 }
00103 static inline uint8_t FAT_MONTH(uint16_t fatDate) {
00104 return (fatDate >> 5) & 0XF;
00105 }
00107 static inline uint8_t FAT_DAY(uint16_t fatDate) {
00108 return fatDate & 0X1F;
00109 }
00111 static inline uint16_t FAT_TIME(uint8_t hour, uint8_t minute, uint8_t second) {
00112 return hour << 11 | minute << 5 | second >> 1;
00113 }
00115 static inline uint8_t FAT_HOUR(uint16_t fatTime) {
00116 return fatTime >> 11;
00117 }
00119 static inline uint8_t FAT_MINUTE(uint16_t fatTime) {
00120 return(fatTime >> 5) & 0X3F;
00121 }
00123 static inline uint8_t FAT_SECOND(uint16_t fatTime) {
00124 return 2*(fatTime & 0X1F);
00125 }
00127 uint16_t const FAT_DEFAULT_DATE = ((2000 - 1980) << 9) | (1 << 5) | 1;
00129 uint16_t const FAT_DEFAULT_TIME = (1 << 11);
00130
00135 class SdFile : public Print {
00136 public:
00138 SdFile(void) : type_(FAT_FILE_TYPE_CLOSED) {}
00144 bool writeError;
00149 void clearUnbufferedRead(void) {
00150 flags_ &= ~F_FILE_UNBUFFERED_READ;
00151 }
00152 uint8_t close(void);
00153 uint8_t contiguousRange(uint32_t* bgnBlock, uint32_t* endBlock);
00154 uint8_t createContiguous(SdFile* dirFile,
00155 const char* fileName, uint32_t size);
00157 uint32_t curCluster(void) const {return curCluster_;}
00159 uint32_t curPosition(void) const {return curPosition_;}
00188 static void dateTimeCallback(
00189 void (*dateTime)(uint16_t* date, uint16_t* time)) {
00190 dateTime_ = dateTime;
00191 }
00195 static void dateTimeCallbackCancel(void) {
00196
00197 dateTime_ = 0;
00198 }
00200 uint32_t dirBlock(void) const {return dirBlock_;}
00201 uint8_t dirEntry(dir_t* dir);
00203 uint8_t dirIndex(void) const {return dirIndex_;}
00204 static void dirName(const dir_t& dir, char* name);
00206 uint32_t fileSize(void) const {return fileSize_;}
00208 uint32_t firstCluster(void) const {return firstCluster_;}
00210 uint8_t isDir(void) const {return type_ >= FAT_FILE_TYPE_MIN_DIR;}
00212 uint8_t isFile(void) const {return type_ == FAT_FILE_TYPE_NORMAL;}
00214 uint8_t isOpen(void) const {return type_ != FAT_FILE_TYPE_CLOSED;}
00216 uint8_t isSubDir(void) const {return type_ == FAT_FILE_TYPE_SUBDIR;}
00218 uint8_t isRoot(void) const {
00219 return type_ == FAT_FILE_TYPE_ROOT16 || type_ == FAT_FILE_TYPE_ROOT32;
00220 }
00221 void ls(uint8_t flags = 0, uint8_t indent = 0);
00222 uint8_t makeDir(SdFile* dir, const char* dirName);
00223 uint8_t open(SdFile* dirFile, uint16_t index, uint8_t oflag);
00224 uint8_t open(SdFile* dirFile, const char* fileName, uint8_t oflag);
00225
00226 uint8_t openRoot(SdVolume* vol);
00227 static void printDirName(const dir_t& dir, uint8_t width);
00228 static void printFatDate(uint16_t fatDate);
00229 static void printFatTime(uint16_t fatTime);
00230 static void printTwoDigits(uint8_t v);
00237 int16_t read(void) {
00238 uint8_t b;
00239 return read(&b, 1) == 1 ? b : -1;
00240 }
00241 int16_t read(void* buf, uint16_t nbyte);
00242 int8_t readDir(dir_t* dir);
00243 static uint8_t remove(SdFile* dirFile, const char* fileName);
00244 uint8_t remove(void);
00246 void rewind(void) {
00247 curPosition_ = curCluster_ = 0;
00248 }
00249 uint8_t rmDir(void);
00250 uint8_t rmRfStar(void);
00252 uint8_t seekCur(uint32_t pos) {
00253 return seekSet(curPosition_ + pos);
00254 }
00259 uint8_t seekEnd(void) {return seekSet(fileSize_);}
00260 uint8_t seekSet(uint32_t pos);
00267 void setUnbufferedRead(void) {
00268 if (isFile()) flags_ |= F_FILE_UNBUFFERED_READ;
00269 }
00270 uint8_t timestamp(uint8_t flag, uint16_t year, uint8_t month, uint8_t day,
00271 uint8_t hour, uint8_t minute, uint8_t second);
00272 uint8_t sync(void);
00278 uint8_t type(void) const {return type_;}
00279 uint8_t truncate(uint32_t size);
00281 uint8_t unbufferedRead(void) const {
00282 return flags_ & F_FILE_UNBUFFERED_READ;
00283 }
00285 SdVolume* volume(void) const {return vol_;}
00286 void write(uint8_t b);
00287 int16_t write(const void* buf, uint16_t nbyte);
00288 void write(const char* str);
00289 void write_P(PGM_P str);
00290 void writeln_P(PGM_P str);
00291
00292 #if ALLOW_DEPRECATED_FUNCTIONS
00293
00297 uint8_t contiguousRange(uint32_t& bgnBlock, uint32_t& endBlock) {
00298 return contiguousRange(&bgnBlock, &endBlock);
00299 }
00304 uint8_t createContiguous(SdFile& dirFile,
00305 const char* fileName, uint32_t size) {
00306 return createContiguous(&dirFile, fileName, size);
00307 }
00308
00314 static void dateTimeCallback(
00315 void (*dateTime)(uint16_t& date, uint16_t& time)) {
00316 oldDateTime_ = dateTime;
00317 dateTime_ = dateTime ? oldToNew : 0;
00318 }
00320 uint8_t dirEntry(dir_t& dir) {return dirEntry(&dir);}
00324 uint8_t makeDir(SdFile& dir, const char* dirName) {
00325 return makeDir(&dir, dirName);
00326 }
00330 uint8_t open(SdFile& dirFile,
00331 const char* fileName, uint8_t oflag) {
00332 return open(&dirFile, fileName, oflag);
00333 }
00335 uint8_t open(SdFile& dirFile, const char* fileName) {
00336 return open(dirFile, fileName, O_RDWR);
00337 }
00341 uint8_t open(SdFile& dirFile, uint16_t index, uint8_t oflag) {
00342 return open(&dirFile, index, oflag);
00343 }
00345 uint8_t openRoot(SdVolume& vol) {return openRoot(&vol);}
00346
00348 int8_t readDir(dir_t& dir) {return readDir(&dir);}
00352 static uint8_t remove(SdFile& dirFile, const char* fileName) {
00353 return remove(&dirFile, fileName);
00354 }
00355
00356
00357 private:
00358 static void (*oldDateTime_)(uint16_t& date, uint16_t& time);
00359 static void oldToNew(uint16_t* date, uint16_t* time) {
00360 uint16_t d;
00361 uint16_t t;
00362 oldDateTime_(d, t);
00363 *date = d;
00364 *time = t;
00365 }
00366 #endif // ALLOW_DEPRECATED_FUNCTIONS
00367 private:
00368
00369
00370 static uint8_t const F_OFLAG = (O_ACCMODE | O_APPEND | O_SYNC);
00371
00372 static uint8_t const F_UNUSED = 0X30;
00373
00374 static uint8_t const F_FILE_UNBUFFERED_READ = 0X40;
00375
00376 static uint8_t const F_FILE_DIR_DIRTY = 0X80;
00377
00378
00379 #if ((F_UNUSED | F_FILE_UNBUFFERED_READ | F_FILE_DIR_DIRTY) & F_OFLAG)
00380 #error flags_ bits conflict
00381 #endif // flags_ bits
00382
00383
00384 uint8_t flags_;
00385 uint8_t type_;
00386 uint32_t curCluster_;
00387 uint32_t curPosition_;
00388 uint32_t dirBlock_;
00389 uint8_t dirIndex_;
00390 uint32_t fileSize_;
00391 uint32_t firstCluster_;
00392 SdVolume* vol_;
00393
00394
00395 uint8_t addCluster(void);
00396 uint8_t addDirCluster(void);
00397 dir_t* cacheDirEntry(uint8_t action);
00398 static void (*dateTime_)(uint16_t* date, uint16_t* time);
00399 static uint8_t make83Name(const char* str, uint8_t* name);
00400 uint8_t openCachedEntry(uint8_t cacheIndex, uint8_t oflags);
00401 dir_t* readDirCache(void);
00402 };
00403
00404
00408 union cache_t {
00410 uint8_t data[512];
00412 uint16_t fat16[256];
00414 uint32_t fat32[128];
00416 dir_t dir[16];
00418 mbr_t mbr;
00420 fbs_t fbs;
00421 };
00422
00427 class SdVolume {
00428 public:
00430 SdVolume(void) :allocSearchStart_(2), fatType_(0) {}
00434 static uint8_t* cacheClear(void) {
00435 cacheFlush();
00436 cacheBlockNumber_ = 0XFFFFFFFF;
00437 return cacheBuffer_.data;
00438 }
00450 uint8_t init(Sd2Card* dev) { return init(dev, 1) ? true : init(dev, 0);}
00451 uint8_t init(Sd2Card* dev, uint8_t part);
00452
00453
00455 uint8_t blocksPerCluster(void) const {return blocksPerCluster_;}
00457 uint32_t blocksPerFat(void) const {return blocksPerFat_;}
00459 uint32_t clusterCount(void) const {return clusterCount_;}
00461 uint8_t clusterSizeShift(void) const {return clusterSizeShift_;}
00463 uint32_t dataStartBlock(void) const {return dataStartBlock_;}
00465 uint8_t fatCount(void) const {return fatCount_;}
00467 uint32_t fatStartBlock(void) const {return fatStartBlock_;}
00469 uint8_t fatType(void) const {return fatType_;}
00471 uint32_t rootDirEntryCount(void) const {return rootDirEntryCount_;}
00474 uint32_t rootDirStart(void) const {return rootDirStart_;}
00476 static Sd2Card* sdCard(void) {return sdCard_;}
00477
00478 #if ALLOW_DEPRECATED_FUNCTIONS
00479
00481 uint8_t init(Sd2Card& dev) {return init(&dev);}
00482
00484 uint8_t init(Sd2Card& dev, uint8_t part) {
00485 return init(&dev, part);
00486 }
00487 #endif // ALLOW_DEPRECATED_FUNCTIONS
00488
00489 private:
00490
00491 friend class SdFile;
00492
00493
00494 static uint8_t const CACHE_FOR_READ = 0;
00495
00496 static uint8_t const CACHE_FOR_WRITE = 1;
00497
00498 static cache_t cacheBuffer_;
00499 static uint32_t cacheBlockNumber_;
00500 static Sd2Card* sdCard_;
00501 static uint8_t cacheDirty_;
00502 static uint32_t cacheMirrorBlock_;
00503
00504 uint32_t allocSearchStart_;
00505 uint8_t blocksPerCluster_;
00506 uint32_t blocksPerFat_;
00507 uint32_t clusterCount_;
00508 uint8_t clusterSizeShift_;
00509 uint32_t dataStartBlock_;
00510 uint8_t fatCount_;
00511 uint32_t fatStartBlock_;
00512 uint8_t fatType_;
00513 uint16_t rootDirEntryCount_;
00514 uint32_t rootDirStart_;
00515
00516 uint8_t allocContiguous(uint32_t count, uint32_t* curCluster);
00517 uint8_t blockOfCluster(uint32_t position) const {
00518 return (position >> 9) & (blocksPerCluster_ - 1);}
00519 uint32_t clusterStartBlock(uint32_t cluster) const {
00520 return dataStartBlock_ + ((cluster - 2) << clusterSizeShift_);}
00521 uint32_t blockNumber(uint32_t cluster, uint32_t position) const {
00522 return clusterStartBlock(cluster) + blockOfCluster(position);}
00523 static uint8_t cacheFlush(void);
00524 static uint8_t cacheRawBlock(uint32_t blockNumber, uint8_t action);
00525 static void cacheSetDirty(void) {cacheDirty_ |= CACHE_FOR_WRITE;}
00526 static uint8_t cacheZeroBlock(uint32_t blockNumber);
00527 uint8_t chainSize(uint32_t beginCluster, uint32_t* size) const;
00528 uint8_t fatGet(uint32_t cluster, uint32_t* value) const;
00529 uint8_t fatPut(uint32_t cluster, uint32_t value);
00530 uint8_t fatPutEOC(uint32_t cluster) {
00531 return fatPut(cluster, 0x0FFFFFFF);
00532 }
00533 uint8_t freeChain(uint32_t cluster);
00534 uint8_t isEOC(uint32_t cluster) const {
00535 return cluster >= (fatType_ == 16 ? FAT16EOC_MIN : FAT32EOC_MIN);
00536 }
00537 uint8_t readBlock(uint32_t block, uint8_t* dst) {
00538 return sdCard_->readBlock(block, dst);}
00539 uint8_t readData(uint32_t block, uint16_t offset,
00540 uint16_t count, uint8_t* dst) {
00541 return sdCard_->readData(block, offset, count, dst);
00542 }
00543 uint8_t writeBlock(uint32_t block, const uint8_t* dst) {
00544 return sdCard_->writeBlock(block, dst);
00545 }
00546 };
00547 #endif // SdFat_h