alvinlollo/Studuino
1
0
Fork 0
Code Issues 2 Actions Projects 1 Releases Activity

initial commit

Browse Source
This commit is contained in:
alvinlollo
2026-09-25 10:48:51 +10:00
commit b90beea8ae
1020 changed files with 131665 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libraries/WaveHC/FatReader.h
+217
View File
@@ -0,0 +1,217 @@
/* Arduino FatReader Library
* Copyright (C) 2009 by William Greiman
*
* This file is part of the Arduino FatReader 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 FatReader Library. If not, see
* <http://www.gnu.org/licenses/>.
*/
#ifndef FatReader_h
#define FatReader_h
#include <FatStructs.h>
#include <SdReader.h>
// flags for ls()
/** ls() flag to print modify date */
#define LS_FLAG_FRAGMENTED 1
/** ls() flag to print file size */
#define LS_SIZE 2
/** ls() flag for recursive list of subdirectories */
#define LS_R 4
// offsets for structures used in volume init
/** Offset to BIOS Parameter Block in FAT Boot Sector */
#define BPB_OFFSET 11
/** Byte count for part of BIOS Parameter Block to be read by init() */
#define BPB_COUNT 37
/** offset to partition table in mbr */
#define PART_OFFSET (512 - 64 - 2)
// format dir.name into name[13] as standard 8.3 string
void dirName(dir_t &dir, char name[]);
// Print name field of dir_t struct in 8.3 format
void printEntryName(dir_t &dir);
//------------------------------------------------------------------------------
/** \class FatVolume
* \brief FatVolume provides access to FAT volumes.
*/
class FatVolume {
/** Allow FatReader access to FatVolume private data. */
friend class FatReader;
uint8_t blocksPerCluster_;
uint32_t blocksPerFat_;
uint32_t clusterCount_;
uint32_t dataStartBlock_;
uint8_t fatCount_;
uint32_t fatStartBlock_;
uint8_t fatType_;
SdReader *rawDevice_;
uint16_t rootDirEntryCount_;
uint32_t rootDirStart_;
uint32_t totalBlocks_;
uint8_t chainIsContiguous(uint32_t cluster);
uint32_t chainSize(uint32_t cluster);
uint8_t isEOC(uint32_t cluster) {
return cluster >= (fatType_ == 16 ? FAT16EOC_MIN : FAT32EOC_MIN);
}
uint32_t nextCluster(uint32_t cluster);
uint8_t rawRead(uint32_t block, uint16_t offset, uint8_t *dst,
uint16_t count) {
return rawDevice_->readData(block, offset, dst, count);
}
uint8_t validCluster(uint32_t cluster) {
return (1 < cluster && cluster < (clusterCount_ + 2));
}
public:
/** Create an instance of FatVolume */
FatVolume(void) : fatType_(0) {}
/**
* Initialize a FAT volume. Try partition one first then try super
* floppy format.
*
* \param[in] dev The SdReader where the volume is located.
*
* \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 or an I/O error.
*/
uint8_t init(SdReader &dev) { return init(dev, 1) ? 1 : init(dev, 0); }
uint8_t init(SdReader &dev, uint8_t part);
// inline functions that return volume info
/** \return The volume's cluster size in blocks. */
uint8_t blocksPerCluster(void) { return blocksPerCluster_; }
/** \return The number of blocks in one FAT. */
uint32_t blocksPerFat(void) { return blocksPerFat_; }
/** \return The total number of clusters in the volume. */
uint32_t clusterCount(void) { return clusterCount_; }
/** \return The logical block number for the start of file data. */
uint32_t dataStartBlock(void) { return dataStartBlock_; }
/** \return The number of FAT structures on the volume. */
uint8_t fatCount(void) { return fatCount_; }
/** \return The logical block number for the start of the first FAT. */
uint32_t fatStartBlock(void) { return fatStartBlock_; }
/** \return The FAT type of the volume. Values are 12, 16 or 32. */
uint8_t fatType(void) { return fatType_; }
/*!
@brief Raw device for this volume
@returns the raw device
*/
SdReader *rawDevice(void) { return rawDevice_; }
/** \return The number of entries in the root directory for FAT16 volumes. */
uint32_t rootDirEntryCount(void) { return rootDirEntryCount_; }
/** \return The logical block number for the start of the root directory
on FAT16 volumes or the first cluster number on FAT32 volumes. */
uint32_t rootDirStart(void) { return rootDirStart_; }
/** \return The total number of blocks in the volume. */
uint32_t totalBlocks(void) { return totalBlocks_; }
};
//------------------------------------------------------------------------------
/** \class FatReader
* \brief FatReader implements a minimal FAT16/FAT32 file reader class.
*/
class FatReader {
// values for type_
/** File is contiguous file */
#define FILE_IS_CONTIGUOUS 0X08
/** File type mask */
#define FILE_TYPE_MASK 0X07
/** This FatReader has not been opened. */
#define FILE_TYPE_CLOSED 0X00
/** FatReader for a file */
#define FILE_TYPE_NORMAL 0X01
/** FatReader for a FAT16 root directory */
#define FILE_TYPE_ROOT16 0X02
/** FatReader for a FAT32 root directory */
#define FILE_TYPE_ROOT32 0X03
/** FatReader for a subdirectory */
#define FILE_TYPE_SUBDIR 0X04
/** Test value for directory type */
#define FILE_TYPE_MIN_DIR FILE_TYPE_ROOT16
uint8_t type_;
uint32_t fileSize_;
uint32_t readCluster_;
uint32_t readPosition_;
uint32_t firstCluster_;
FatVolume *vol_;
int16_t readBlockData(uint8_t *dst, uint16_t count);
void lsR(dir_t &d, uint8_t flags, uint8_t indent);
public:
/** Create an instance of FatReader. */
FatReader(void) : type_(FILE_TYPE_CLOSED) {}
void ls(uint8_t flags = 0);
uint8_t openRoot(FatVolume &vol);
uint8_t open(FatVolume &vol, dir_t &dir);
uint8_t open(FatReader &dir, char *name);
uint8_t open(FatReader &dir, uint16_t index);
void optimizeContiguous(void);
int16_t read(void *buf, uint16_t count);
int8_t readDir(dir_t &dir);
void rewind(void);
uint8_t seekCur(uint32_t pos);
// inline functions
/** Close this instance of FatReader. */
void close(void) { type_ = FILE_TYPE_CLOSED; }
/** \return The total number of bytes in a file or directory. */
uint32_t fileSize(void) { return fileSize_; }
/**
* Type of this FatReader. You should use isFile() or isDir()
* instead of type() if possible.
*
* \return The file or directory type.
*/
uint8_t fileType(void) { return type_ & FILE_TYPE_MASK; }
/** \return The first cluster number for a file or directory. */
uint32_t firstCluster(void) { return firstCluster_; }
/**
* \return True if the bit for optimized reads is set.
* See optimizeContiguous(). */
uint8_t isContiguous(void) { return type_ & FILE_IS_CONTIGUOUS; }
/** \return True if this is a FatReader for a directory else false */
uint8_t isDir(void) { return fileType() >= FILE_TYPE_MIN_DIR; }
/** \return True if this is a FatReader for a file else false */
uint8_t isFile(void) { return fileType() == FILE_TYPE_NORMAL; }
/** \return True if FatReader is for an open file/directory else false */
uint8_t isOpen(void) { return fileType() != FILE_TYPE_CLOSED; }
/** \return The current cluster number for a file or directory. */
uint32_t readCluster(void) { return readCluster_; }
/** \return The read position for a file or directory. */
uint32_t readPosition(void) { return readPosition_; }
/**
* Set the read position for a file or directory to \a pos.
*
* \param[in] pos The new read 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.
*/
uint8_t seekSet(uint32_t pos) {
if (pos >= readPosition_)
return seekCur(pos - readPosition_);
rewind();
return seekCur(pos);
}
/*!
@brief get the parent volume
@returns the parent volume
*/
FatVolume *volume(void) { return vol_; }
};
#endif // FatReader_h