Blame | Last modification | View Log | RSS feed
/*** Marlin 3D Printer Firmware* Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]** Based on Sprinter and grbl.* Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm** This program 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 program 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 this program. If not, see <http://www.gnu.org/licenses/>.**//*** \file* \brief SdBaseFile class*//*** Arduino SdFat Library* Copyright (C) 2009 by William Greiman** This file is part of the Arduino Sd2Card Library*/#ifndef _SDBASEFILE_H_#define _SDBASEFILE_H_#include "SdFatConfig.h"#include "SdVolume.h"#include <stdint.h>/*** \struct filepos_t* \brief internal type for istream* do not use in user apps*/struct filepos_t {uint32_t position; // stream byte positionuint32_t cluster; // cluster of positionfilepos_t() : position(0), cluster(0) {}};// use the gnu style oflag in open()uint8_t const O_READ = 0x01, // open() oflag for readingO_RDONLY = O_READ, // open() oflag - same as O_INO_WRITE = 0x02, // open() oflag for writeO_WRONLY = O_WRITE, // open() oflag - same as O_WRITEO_RDWR = (O_READ | O_WRITE), // open() oflag for reading and writingO_ACCMODE = (O_READ | O_WRITE), // open() oflag mask for access modesO_APPEND = 0x04, // The file offset shall be set to the end of the file prior to each write.O_SYNC = 0x08, // Synchronous writes - call sync() after each writeO_TRUNC = 0x10, // Truncate the file to zero lengthO_AT_END = 0x20, // Set the initial position at the end of the fileO_CREAT = 0x40, // Create the file if nonexistentO_EXCL = 0x80; // If O_CREAT and O_EXCL are set, open() shall fail if the file exists// SdBaseFile class static and const definitions// flags for ls()uint8_t const LS_DATE = 1, // ls() flag to print modify dateLS_SIZE = 2, // ls() flag to print file sizeLS_R = 4; // ls() flag for recursive list of subdirectories// flags for timestampuint8_t const T_ACCESS = 1, // Set the file's last access dateT_CREATE = 2, // Set the file's creation date and timeT_WRITE = 4; // Set the file's write date and time// values for type_uint8_t const FAT_FILE_TYPE_CLOSED = 0, // This file has not been opened.FAT_FILE_TYPE_NORMAL = 1, // A normal fileFAT_FILE_TYPE_ROOT_FIXED = 2, // A FAT12 or FAT16 root directoryFAT_FILE_TYPE_ROOT32 = 3, // A FAT32 root directoryFAT_FILE_TYPE_SUBDIR = 4, // A subdirectory fileFAT_FILE_TYPE_MIN_DIR = FAT_FILE_TYPE_ROOT_FIXED; // Test value for directory type/*** date field for FAT directory entry* \param[in] year [1980,2107]* \param[in] month [1,12]* \param[in] day [1,31]** \return Packed date for dir_t entry.*/static inline uint16_t FAT_DATE(uint16_t year, uint8_t month, uint8_t day) { return (year - 1980) << 9 | month << 5 | day; }/*** year part of FAT directory date field* \param[in] fatDate Date in packed dir format.** \return Extracted year [1980,2107]*/static inline uint16_t FAT_YEAR(uint16_t fatDate) { return 1980 + (fatDate >> 9); }/*** month part of FAT directory date field* \param[in] fatDate Date in packed dir format.** \return Extracted month [1,12]*/static inline uint8_t FAT_MONTH(uint16_t fatDate) { return (fatDate >> 5) & 0XF; }/*** day part of FAT directory date field* \param[in] fatDate Date in packed dir format.** \return Extracted day [1,31]*/static inline uint8_t FAT_DAY(uint16_t fatDate) { return fatDate & 0x1F; }/*** time field for FAT directory entry* \param[in] hour [0,23]* \param[in] minute [0,59]* \param[in] second [0,59]** \return Packed time for dir_t entry.*/static inline uint16_t FAT_TIME(uint8_t hour, uint8_t minute, uint8_t second) { return hour << 11 | minute << 5 | second >> 1; }/*** hour part of FAT directory time field* \param[in] fatTime Time in packed dir format.** \return Extracted hour [0,23]*/static inline uint8_t FAT_HOUR(uint16_t fatTime) { return fatTime >> 11; }/*** minute part of FAT directory time field* \param[in] fatTime Time in packed dir format.** \return Extracted minute [0,59]*/static inline uint8_t FAT_MINUTE(uint16_t fatTime) { return (fatTime >> 5) & 0x3F; }/*** second part of FAT directory time field* Note second/2 is stored in packed time.** \param[in] fatTime Time in packed dir format.** \return Extracted second [0,58]*/static inline uint8_t FAT_SECOND(uint16_t fatTime) { return 2 * (fatTime & 0x1F); }// Default date for file timestamps is 1 Jan 2000uint16_t const FAT_DEFAULT_DATE = ((2000 - 1980) << 9) | (1 << 5) | 1;// Default time for file timestamp is 1 amuint16_t const FAT_DEFAULT_TIME = (1 << 11);/*** \class SdBaseFile* \brief Base class for SdFile with Print and C++ streams.*/class SdBaseFile {public:SdBaseFile() : writeError(false), type_(FAT_FILE_TYPE_CLOSED) {}SdBaseFile(const char* path, uint8_t oflag);~SdBaseFile() { if (isOpen()) close(); }/*** writeError is set to true if an error occurs during a write().* Set writeError to false before calling print() and/or write() and check* for true after calls to print() and/or write().*/bool writeError;// helpers for stream classes/*** get position for streams* \param[out] pos struct to receive position*/void getpos(filepos_t* pos);/*** set position for streams* \param[out] pos struct with value for new position*/void setpos(filepos_t* pos);bool close();bool contiguousRange(uint32_t* bgnBlock, uint32_t* endBlock);bool createContiguous(SdBaseFile* dirFile,const char* path, uint32_t size);/*** \return The current cluster number for a file or directory.*/uint32_t curCluster() const { return curCluster_; }/*** \return The current position for a file or directory.*/uint32_t curPosition() const { return curPosition_; }/*** \return Current working directory*/static SdBaseFile* cwd() { return cwd_; }/*** Set the date/time callback function** \param[in] dateTime The user's call back function. The callback* function is of the form:** \code* void dateTime(uint16_t* date, uint16_t* time) {* uint16_t year;* uint8_t month, day, hour, minute, second;** // User gets date and time from GPS or real-time clock here** // return date using FAT_DATE macro to format fields* *date = FAT_DATE(year, month, day);** // return time using FAT_TIME macro to format fields* *time = FAT_TIME(hour, minute, second);* }* \endcode** Sets the function that is called when a file is created or when* a file's directory entry is modified by sync(). All timestamps,* access, creation, and modify, are set when a file is created.* sync() maintains the last access date and last modify date/time.** See the timestamp() function.*/static void dateTimeCallback(void (*dateTime)(uint16_t* date, uint16_t* time)) {dateTime_ = dateTime;}/*** Cancel the date/time callback function.*/static void dateTimeCallbackCancel() { dateTime_ = 0; }bool dirEntry(dir_t* dir);static void dirName(const dir_t& dir, char* name);bool exists(const char* name);int16_t fgets(char* str, int16_t num, char* delim = 0);/*** \return The total number of bytes in a file or directory.*/uint32_t fileSize() const { return fileSize_; }/*** \return The first cluster number for a file or directory.*/uint32_t firstCluster() const { return firstCluster_; }/*** \return True if this is a directory else false.*/bool isDir() const { return type_ >= FAT_FILE_TYPE_MIN_DIR; }/*** \return True if this is a normal file else false.*/bool isFile() const { return type_ == FAT_FILE_TYPE_NORMAL; }/*** \return True if this is an open file/directory else false.*/bool isOpen() const { return type_ != FAT_FILE_TYPE_CLOSED; }/*** \return True if this is a subdirectory else false.*/bool isSubDir() const { return type_ == FAT_FILE_TYPE_SUBDIR; }/*** \return True if this is the root directory.*/bool isRoot() const { return type_ == FAT_FILE_TYPE_ROOT_FIXED || type_ == FAT_FILE_TYPE_ROOT32; }bool getFilename(char * const name);void ls(uint8_t flags = 0, uint8_t indent = 0);bool mkdir(SdBaseFile* dir, const char* path, bool pFlag = true);bool open(SdBaseFile* dirFile, uint16_t index, uint8_t oflag);bool open(SdBaseFile* dirFile, const char* path, uint8_t oflag);bool open(const char* path, uint8_t oflag = O_READ);bool openNext(SdBaseFile* dirFile, uint8_t oflag);bool openRoot(SdVolume* vol);int peek();static void printFatDate(uint16_t fatDate);static void printFatTime(uint16_t fatTime);bool printName();int16_t read();int16_t read(void* buf, uint16_t nbyte);int8_t readDir(dir_t* dir, char* longFilename);static bool remove(SdBaseFile* dirFile, const char* path);bool remove();/*** Set the file's current position to zero.*/void rewind() { seekSet(0); }bool rename(SdBaseFile* dirFile, const char* newPath);bool rmdir();bool rmRfStar();/*** Set the files position to current position + \a pos. See seekSet().* \param[in] offset The new position in bytes from the current position.* \return true for success or false for failure.*/bool seekCur(const int32_t offset) { return seekSet(curPosition_ + offset); }/*** Set the files position to end-of-file + \a offset. See seekSet().* \param[in] offset The new position in bytes from end-of-file.* \return true for success or false for failure.*/bool seekEnd(const int32_t offset = 0) { return seekSet(fileSize_ + offset); }bool seekSet(const uint32_t pos);bool sync();bool timestamp(SdBaseFile* file);bool timestamp(uint8_t flag, uint16_t year, uint8_t month, uint8_t day,uint8_t hour, uint8_t minute, uint8_t second);/*** Type of file. Use isFile() or isDir() instead of type() if possible.** \return The file or directory type.*/uint8_t type() const { return type_; }bool truncate(uint32_t size);/*** \return SdVolume that contains this file.*/SdVolume* volume() const { return vol_; }int16_t write(const void* buf, uint16_t nbyte);private:friend class SdFat; // allow SdFat to set cwd_static SdBaseFile* cwd_; // global pointer to cwd dir// data time callback functionstatic void (*dateTime_)(uint16_t* date, uint16_t* time);// bits defined in flags_static uint8_t const F_OFLAG = (O_ACCMODE | O_APPEND | O_SYNC), // should be 0x0FF_FILE_DIR_DIRTY = 0x80; // sync of directory entry required// private datauint8_t flags_; // See above for definition of flags_ bitsuint8_t fstate_; // error and eof indicatoruint8_t type_; // type of file see above for valuesuint32_t curCluster_; // cluster for current file positionuint32_t curPosition_; // current file position in bytes from beginninguint32_t dirBlock_; // block for this files directory entryuint8_t dirIndex_; // index of directory entry in dirBlockuint32_t fileSize_; // file size in bytesuint32_t firstCluster_; // first cluster of fileSdVolume* vol_; // volume where file is located/*** EXPERIMENTAL - Don't use!*///bool openParent(SdBaseFile* dir);// private functionsbool addCluster();bool addDirCluster();dir_t* cacheDirEntry(uint8_t action);int8_t lsPrintNext(uint8_t flags, uint8_t indent);static bool make83Name(const char* str, uint8_t* name, const char** ptr);bool mkdir(SdBaseFile* parent, const uint8_t dname[11]);bool open(SdBaseFile* dirFile, const uint8_t dname[11], uint8_t oflag);bool openCachedEntry(uint8_t cacheIndex, uint8_t oflags);dir_t* readDirCache();};#endif // _SDBASEFILE_H_