My Marlin configs for Fabrikator Mini and CTC i3 Pro B
Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.

SdBaseFile.h 18KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489
  1. /* Arduino SdFat Library
  2. * Copyright (C) 2009 by William Greiman
  3. *
  4. * This file is part of the Arduino SdFat Library
  5. *
  6. * This Library is free software: you can redistribute it and/or modify
  7. * it under the terms of the GNU General Public License as published by
  8. * the Free Software Foundation, either version 3 of the License, or
  9. * (at your option) any later version.
  10. *
  11. * This Library is distributed in the hope that it will be useful,
  12. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14. * GNU General Public License for more details.
  15. *
  16. * You should have received a copy of the GNU General Public License
  17. * along with the Arduino SdFat Library. If not, see
  18. * <http://www.gnu.org/licenses/>.
  19. */
  20. #ifndef SdBaseFile_h
  21. #define SdBaseFile_h
  22. /**
  23. * \file
  24. * \brief SdBaseFile class
  25. */
  26. #include <avr/pgmspace.h>
  27. #if ARDUINO < 100
  28. #include <WProgram.h>
  29. #else // ARDUINO
  30. #include <Arduino.h>
  31. #endif // ARDUINO
  32. #include "SdFatConfig.h"
  33. #include "SdVolume.h"
  34. //------------------------------------------------------------------------------
  35. /**
  36. * \struct fpos_t
  37. * \brief internal type for istream
  38. * do not use in user apps
  39. */
  40. struct fpos_t {
  41. /** stream position */
  42. uint32_t position;
  43. /** cluster for position */
  44. uint32_t cluster;
  45. fpos_t() : position(0), cluster(0) {}
  46. };
  47. // use the gnu style oflag in open()
  48. /** open() oflag for reading */
  49. uint8_t const O_READ = 0X01;
  50. /** open() oflag - same as O_IN */
  51. uint8_t const O_RDONLY = O_READ;
  52. /** open() oflag for write */
  53. uint8_t const O_WRITE = 0X02;
  54. /** open() oflag - same as O_WRITE */
  55. uint8_t const O_WRONLY = O_WRITE;
  56. /** open() oflag for reading and writing */
  57. uint8_t const O_RDWR = (O_READ | O_WRITE);
  58. /** open() oflag mask for access modes */
  59. uint8_t const O_ACCMODE = (O_READ | O_WRITE);
  60. /** The file offset shall be set to the end of the file prior to each write. */
  61. uint8_t const O_APPEND = 0X04;
  62. /** synchronous writes - call sync() after each write */
  63. uint8_t const O_SYNC = 0X08;
  64. /** truncate the file to zero length */
  65. uint8_t const O_TRUNC = 0X10;
  66. /** set the initial position at the end of the file */
  67. uint8_t const O_AT_END = 0X20;
  68. /** create the file if nonexistent */
  69. uint8_t const O_CREAT = 0X40;
  70. /** If O_CREAT and O_EXCL are set, open() shall fail if the file exists */
  71. uint8_t const O_EXCL = 0X80;
  72. // SdBaseFile class static and const definitions
  73. // flags for ls()
  74. /** ls() flag to print modify date */
  75. uint8_t const LS_DATE = 1;
  76. /** ls() flag to print file size */
  77. uint8_t const LS_SIZE = 2;
  78. /** ls() flag for recursive list of subdirectories */
  79. uint8_t const LS_R = 4;
  80. // flags for timestamp
  81. /** set the file's last access date */
  82. uint8_t const T_ACCESS = 1;
  83. /** set the file's creation date and time */
  84. uint8_t const T_CREATE = 2;
  85. /** Set the file's write date and time */
  86. uint8_t const T_WRITE = 4;
  87. // values for type_
  88. /** This file has not been opened. */
  89. uint8_t const FAT_FILE_TYPE_CLOSED = 0;
  90. /** A normal file */
  91. uint8_t const FAT_FILE_TYPE_NORMAL = 1;
  92. /** A FAT12 or FAT16 root directory */
  93. uint8_t const FAT_FILE_TYPE_ROOT_FIXED = 2;
  94. /** A FAT32 root directory */
  95. uint8_t const FAT_FILE_TYPE_ROOT32 = 3;
  96. /** A subdirectory file*/
  97. uint8_t const FAT_FILE_TYPE_SUBDIR = 4;
  98. /** Test value for directory type */
  99. uint8_t const FAT_FILE_TYPE_MIN_DIR = FAT_FILE_TYPE_ROOT_FIXED;
  100. /** date field for FAT directory entry
  101. * \param[in] year [1980,2107]
  102. * \param[in] month [1,12]
  103. * \param[in] day [1,31]
  104. *
  105. * \return Packed date for dir_t entry.
  106. */
  107. static inline uint16_t FAT_DATE(uint16_t year, uint8_t month, uint8_t day) {
  108. return (year - 1980) << 9 | month << 5 | day;
  109. }
  110. /** year part of FAT directory date field
  111. * \param[in] fatDate Date in packed dir format.
  112. *
  113. * \return Extracted year [1980,2107]
  114. */
  115. static inline uint16_t FAT_YEAR(uint16_t fatDate) {
  116. return 1980 + (fatDate >> 9);
  117. }
  118. /** month part of FAT directory date field
  119. * \param[in] fatDate Date in packed dir format.
  120. *
  121. * \return Extracted month [1,12]
  122. */
  123. static inline uint8_t FAT_MONTH(uint16_t fatDate) {
  124. return (fatDate >> 5) & 0XF;
  125. }
  126. /** day part of FAT directory date field
  127. * \param[in] fatDate Date in packed dir format.
  128. *
  129. * \return Extracted day [1,31]
  130. */
  131. static inline uint8_t FAT_DAY(uint16_t fatDate) {
  132. return fatDate & 0X1F;
  133. }
  134. /** time field for FAT directory entry
  135. * \param[in] hour [0,23]
  136. * \param[in] minute [0,59]
  137. * \param[in] second [0,59]
  138. *
  139. * \return Packed time for dir_t entry.
  140. */
  141. static inline uint16_t FAT_TIME(uint8_t hour, uint8_t minute, uint8_t second) {
  142. return hour << 11 | minute << 5 | second >> 1;
  143. }
  144. /** hour part of FAT directory time field
  145. * \param[in] fatTime Time in packed dir format.
  146. *
  147. * \return Extracted hour [0,23]
  148. */
  149. static inline uint8_t FAT_HOUR(uint16_t fatTime) {
  150. return fatTime >> 11;
  151. }
  152. /** minute part of FAT directory time field
  153. * \param[in] fatTime Time in packed dir format.
  154. *
  155. * \return Extracted minute [0,59]
  156. */
  157. static inline uint8_t FAT_MINUTE(uint16_t fatTime) {
  158. return(fatTime >> 5) & 0X3F;
  159. }
  160. /** second part of FAT directory time field
  161. * Note second/2 is stored in packed time.
  162. *
  163. * \param[in] fatTime Time in packed dir format.
  164. *
  165. * \return Extracted second [0,58]
  166. */
  167. static inline uint8_t FAT_SECOND(uint16_t fatTime) {
  168. return 2*(fatTime & 0X1F);
  169. }
  170. /** Default date for file timestamps is 1 Jan 2000 */
  171. uint16_t const FAT_DEFAULT_DATE = ((2000 - 1980) << 9) | (1 << 5) | 1;
  172. /** Default time for file timestamp is 1 am */
  173. uint16_t const FAT_DEFAULT_TIME = (1 << 11);
  174. //------------------------------------------------------------------------------
  175. /**
  176. * \class SdBaseFile
  177. * \brief Base class for SdFile with Print and C++ streams.
  178. */
  179. class SdBaseFile {
  180. public:
  181. /** Create an instance. */
  182. SdBaseFile() : writeError(false), type_(FAT_FILE_TYPE_CLOSED) {}
  183. SdBaseFile(const char* path, uint8_t oflag);
  184. ~SdBaseFile() {if(isOpen()) close();}
  185. /**
  186. * writeError is set to true if an error occurs during a write().
  187. * Set writeError to false before calling print() and/or write() and check
  188. * for true after calls to print() and/or write().
  189. */
  190. bool writeError;
  191. //----------------------------------------------------------------------------
  192. // helpers for stream classes
  193. /** get position for streams
  194. * \param[out] pos struct to receive position
  195. */
  196. void getpos(fpos_t* pos);
  197. /** set position for streams
  198. * \param[out] pos struct with value for new position
  199. */
  200. void setpos(fpos_t* pos);
  201. //----------------------------------------------------------------------------
  202. bool close();
  203. bool contiguousRange(uint32_t* bgnBlock, uint32_t* endBlock);
  204. bool createContiguous(SdBaseFile* dirFile,
  205. const char* path, uint32_t size);
  206. /** \return The current cluster number for a file or directory. */
  207. uint32_t curCluster() const {return curCluster_;}
  208. /** \return The current position for a file or directory. */
  209. uint32_t curPosition() const {return curPosition_;}
  210. /** \return Current working directory */
  211. static SdBaseFile* cwd() {return cwd_;}
  212. /** Set the date/time callback function
  213. *
  214. * \param[in] dateTime The user's call back function. The callback
  215. * function is of the form:
  216. *
  217. * \code
  218. * void dateTime(uint16_t* date, uint16_t* time) {
  219. * uint16_t year;
  220. * uint8_t month, day, hour, minute, second;
  221. *
  222. * // User gets date and time from GPS or real-time clock here
  223. *
  224. * // return date using FAT_DATE macro to format fields
  225. * *date = FAT_DATE(year, month, day);
  226. *
  227. * // return time using FAT_TIME macro to format fields
  228. * *time = FAT_TIME(hour, minute, second);
  229. * }
  230. * \endcode
  231. *
  232. * Sets the function that is called when a file is created or when
  233. * a file's directory entry is modified by sync(). All timestamps,
  234. * access, creation, and modify, are set when a file is created.
  235. * sync() maintains the last access date and last modify date/time.
  236. *
  237. * See the timestamp() function.
  238. */
  239. static void dateTimeCallback(
  240. void (*dateTime)(uint16_t* date, uint16_t* time)) {
  241. dateTime_ = dateTime;
  242. }
  243. /** Cancel the date/time callback function. */
  244. static void dateTimeCallbackCancel() {dateTime_ = 0;}
  245. bool dirEntry(dir_t* dir);
  246. static void dirName(const dir_t& dir, char* name);
  247. bool exists(const char* name);
  248. int16_t fgets(char* str, int16_t num, char* delim = 0);
  249. /** \return The total number of bytes in a file or directory. */
  250. uint32_t fileSize() const {return fileSize_;}
  251. /** \return The first cluster number for a file or directory. */
  252. uint32_t firstCluster() const {return firstCluster_;}
  253. bool getFilename(char* name);
  254. /** \return True if this is a directory else false. */
  255. bool isDir() const {return type_ >= FAT_FILE_TYPE_MIN_DIR;}
  256. /** \return True if this is a normal file else false. */
  257. bool isFile() const {return type_ == FAT_FILE_TYPE_NORMAL;}
  258. /** \return True if this is an open file/directory else false. */
  259. bool isOpen() const {return type_ != FAT_FILE_TYPE_CLOSED;}
  260. /** \return True if this is a subdirectory else false. */
  261. bool isSubDir() const {return type_ == FAT_FILE_TYPE_SUBDIR;}
  262. /** \return True if this is the root directory. */
  263. bool isRoot() const {
  264. return type_ == FAT_FILE_TYPE_ROOT_FIXED || type_ == FAT_FILE_TYPE_ROOT32;
  265. }
  266. void ls(Print* pr, uint8_t flags = 0, uint8_t indent = 0);
  267. void ls(uint8_t flags = 0);
  268. bool mkdir(SdBaseFile* dir, const char* path, bool pFlag = true);
  269. // alias for backward compactability
  270. bool makeDir(SdBaseFile* dir, const char* path) {
  271. return mkdir(dir, path, false);
  272. }
  273. bool open(SdBaseFile* dirFile, uint16_t index, uint8_t oflag);
  274. bool open(SdBaseFile* dirFile, const char* path, uint8_t oflag);
  275. bool open(const char* path, uint8_t oflag = O_READ);
  276. bool openNext(SdBaseFile* dirFile, uint8_t oflag);
  277. bool openRoot(SdVolume* vol);
  278. int peek();
  279. static void printFatDate(uint16_t fatDate);
  280. static void printFatDate(Print* pr, uint16_t fatDate);
  281. static void printFatTime(uint16_t fatTime);
  282. static void printFatTime(Print* pr, uint16_t fatTime);
  283. bool printName();
  284. int16_t read();
  285. int16_t read(void* buf, uint16_t nbyte);
  286. int8_t readDir(dir_t* dir);
  287. static bool remove(SdBaseFile* dirFile, const char* path);
  288. bool remove();
  289. /** Set the file's current position to zero. */
  290. void rewind() {seekSet(0);}
  291. bool rename(SdBaseFile* dirFile, const char* newPath);
  292. bool rmdir();
  293. // for backward compatibility
  294. bool rmDir() {return rmdir();}
  295. bool rmRfStar();
  296. /** Set the files position to current position + \a pos. See seekSet().
  297. * \param[in] offset The new position in bytes from the current position.
  298. * \return true for success or false for failure.
  299. */
  300. bool seekCur(int32_t offset) {
  301. return seekSet(curPosition_ + offset);
  302. }
  303. /** Set the files position to end-of-file + \a offset. See seekSet().
  304. * \param[in] offset The new position in bytes from end-of-file.
  305. * \return true for success or false for failure.
  306. */
  307. bool seekEnd(int32_t offset = 0) {return seekSet(fileSize_ + offset);}
  308. bool seekSet(uint32_t pos);
  309. bool sync();
  310. bool timestamp(SdBaseFile* file);
  311. bool timestamp(uint8_t flag, uint16_t year, uint8_t month, uint8_t day,
  312. uint8_t hour, uint8_t minute, uint8_t second);
  313. /** Type of file. You should use isFile() or isDir() instead of type()
  314. * if possible.
  315. *
  316. * \return The file or directory type.
  317. */
  318. uint8_t type() const {return type_;}
  319. bool truncate(uint32_t size);
  320. /** \return SdVolume that contains this file. */
  321. SdVolume* volume() const {return vol_;}
  322. int16_t write(const void* buf, uint16_t nbyte);
  323. //------------------------------------------------------------------------------
  324. private:
  325. // allow SdFat to set cwd_
  326. friend class SdFat;
  327. // global pointer to cwd dir
  328. static SdBaseFile* cwd_;
  329. // data time callback function
  330. static void (*dateTime_)(uint16_t* date, uint16_t* time);
  331. // bits defined in flags_
  332. // should be 0X0F
  333. static uint8_t const F_OFLAG = (O_ACCMODE | O_APPEND | O_SYNC);
  334. // sync of directory entry required
  335. static uint8_t const F_FILE_DIR_DIRTY = 0X80;
  336. // private data
  337. uint8_t flags_; // See above for definition of flags_ bits
  338. uint8_t fstate_; // error and eof indicator
  339. uint8_t type_; // type of file see above for values
  340. uint32_t curCluster_; // cluster for current file position
  341. uint32_t curPosition_; // current file position in bytes from beginning
  342. uint32_t dirBlock_; // block for this files directory entry
  343. uint8_t dirIndex_; // index of directory entry in dirBlock
  344. uint32_t fileSize_; // file size in bytes
  345. uint32_t firstCluster_; // first cluster of file
  346. SdVolume* vol_; // volume where file is located
  347. /** experimental don't use */
  348. bool openParent(SdBaseFile* dir);
  349. // private functions
  350. bool addCluster();
  351. bool addDirCluster();
  352. dir_t* cacheDirEntry(uint8_t action);
  353. int8_t lsPrintNext(Print *pr, uint8_t flags, uint8_t indent);
  354. static bool make83Name(const char* str, uint8_t* name, const char** ptr);
  355. bool mkdir(SdBaseFile* parent, const uint8_t dname[11]);
  356. bool open(SdBaseFile* dirFile, const uint8_t dname[11], uint8_t oflag);
  357. bool openCachedEntry(uint8_t cacheIndex, uint8_t oflags);
  358. dir_t* readDirCache();
  359. //------------------------------------------------------------------------------
  360. // to be deleted
  361. static void printDirName(const dir_t& dir,
  362. uint8_t width, bool printSlash);
  363. static void printDirName(Print* pr, const dir_t& dir,
  364. uint8_t width, bool printSlash);
  365. //------------------------------------------------------------------------------
  366. // Deprecated functions - suppress cpplint warnings with NOLINT comment
  367. #if ALLOW_DEPRECATED_FUNCTIONS && !defined(DOXYGEN)
  368. public:
  369. /** \deprecated Use:
  370. * bool contiguousRange(uint32_t* bgnBlock, uint32_t* endBlock);
  371. * \param[out] bgnBlock the first block address for the file.
  372. * \param[out] endBlock the last block address for the file.
  373. * \return true for success or false for failure.
  374. */
  375. bool contiguousRange(uint32_t& bgnBlock, uint32_t& endBlock) { // NOLINT
  376. return contiguousRange(&bgnBlock, &endBlock);
  377. }
  378. /** \deprecated Use:
  379. * bool createContiguous(SdBaseFile* dirFile,
  380. * const char* path, uint32_t size)
  381. * \param[in] dirFile The directory where the file will be created.
  382. * \param[in] path A path with a valid DOS 8.3 file name.
  383. * \param[in] size The desired file size.
  384. * \return true for success or false for failure.
  385. */
  386. bool createContiguous(SdBaseFile& dirFile, // NOLINT
  387. const char* path, uint32_t size) {
  388. return createContiguous(&dirFile, path, size);
  389. }
  390. /** \deprecated Use:
  391. * static void dateTimeCallback(
  392. * void (*dateTime)(uint16_t* date, uint16_t* time));
  393. * \param[in] dateTime The user's call back function.
  394. */
  395. static void dateTimeCallback(
  396. void (*dateTime)(uint16_t& date, uint16_t& time)) { // NOLINT
  397. oldDateTime_ = dateTime;
  398. dateTime_ = dateTime ? oldToNew : 0;
  399. }
  400. /** \deprecated Use: bool dirEntry(dir_t* dir);
  401. * \param[out] dir Location for return of the file's directory entry.
  402. * \return true for success or false for failure.
  403. */
  404. bool dirEntry(dir_t& dir) {return dirEntry(&dir);} // NOLINT
  405. /** \deprecated Use:
  406. * bool mkdir(SdBaseFile* dir, const char* path);
  407. * \param[in] dir An open SdFat instance for the directory that will contain
  408. * the new directory.
  409. * \param[in] path A path with a valid 8.3 DOS name for the new directory.
  410. * \return true for success or false for failure.
  411. */
  412. bool mkdir(SdBaseFile& dir, const char* path) { // NOLINT
  413. return mkdir(&dir, path);
  414. }
  415. /** \deprecated Use:
  416. * bool open(SdBaseFile* dirFile, const char* path, uint8_t oflag);
  417. * \param[in] dirFile An open SdFat instance for the directory containing the
  418. * file to be opened.
  419. * \param[in] path A path with a valid 8.3 DOS name for the file.
  420. * \param[in] oflag Values for \a oflag are constructed by a bitwise-inclusive
  421. * OR of flags O_READ, O_WRITE, O_TRUNC, and O_SYNC.
  422. * \return true for success or false for failure.
  423. */
  424. bool open(SdBaseFile& dirFile, // NOLINT
  425. const char* path, uint8_t oflag) {
  426. return open(&dirFile, path, oflag);
  427. }
  428. /** \deprecated Do not use in new apps
  429. * \param[in] dirFile An open SdFat instance for the directory containing the
  430. * file to be opened.
  431. * \param[in] path A path with a valid 8.3 DOS name for a file to be opened.
  432. * \return true for success or false for failure.
  433. */
  434. bool open(SdBaseFile& dirFile, const char* path) { // NOLINT
  435. return open(dirFile, path, O_RDWR);
  436. }
  437. /** \deprecated Use:
  438. * bool open(SdBaseFile* dirFile, uint16_t index, uint8_t oflag);
  439. * \param[in] dirFile An open SdFat instance for the directory.
  440. * \param[in] index The \a index of the directory entry for the file to be
  441. * opened. The value for \a index is (directory file position)/32.
  442. * \param[in] oflag Values for \a oflag are constructed by a bitwise-inclusive
  443. * OR of flags O_READ, O_WRITE, O_TRUNC, and O_SYNC.
  444. * \return true for success or false for failure.
  445. */
  446. bool open(SdBaseFile& dirFile, uint16_t index, uint8_t oflag) { // NOLINT
  447. return open(&dirFile, index, oflag);
  448. }
  449. /** \deprecated Use: bool openRoot(SdVolume* vol);
  450. * \param[in] vol The FAT volume containing the root directory to be opened.
  451. * \return true for success or false for failure.
  452. */
  453. bool openRoot(SdVolume& vol) {return openRoot(&vol);} // NOLINT
  454. /** \deprecated Use: int8_t readDir(dir_t* dir);
  455. * \param[out] dir The dir_t struct that will receive the data.
  456. * \return bytes read for success zero for eof or -1 for failure.
  457. */
  458. int8_t readDir(dir_t& dir) {return readDir(&dir);} // NOLINT
  459. /** \deprecated Use:
  460. * static uint8_t remove(SdBaseFile* dirFile, const char* path);
  461. * \param[in] dirFile The directory that contains the file.
  462. * \param[in] path The name of the file to be removed.
  463. * \return true for success or false for failure.
  464. */
  465. static bool remove(SdBaseFile& dirFile, const char* path) { // NOLINT
  466. return remove(&dirFile, path);
  467. }
  468. //------------------------------------------------------------------------------
  469. // rest are private
  470. private:
  471. static void (*oldDateTime_)(uint16_t& date, uint16_t& time); // NOLINT
  472. static void oldToNew(uint16_t* date, uint16_t* time) {
  473. uint16_t d;
  474. uint16_t t;
  475. oldDateTime_(d, t);
  476. *date = d;
  477. *time = t;
  478. }
  479. #endif // ALLOW_DEPRECATED_FUNCTIONS
  480. };
  481. #endif // SdBaseFile_h