2010-11-13 19:42:17 +01:00
|
|
|
/*
|
|
|
|
|
2010-11-13 20:01:37 +01:00
|
|
|
SD - a slightly more friendly wrapper for sdfatlib
|
2010-11-13 19:42:17 +01:00
|
|
|
|
|
|
|
This library aims to expose a subset of SD card functionality
|
|
|
|
in the form of a higher level "wrapper" object.
|
|
|
|
|
|
|
|
License: GNU General Public License V3
|
|
|
|
(Because sdfatlib is licensed with this.)
|
|
|
|
|
|
|
|
(C) Copyright 2010 SparkFun Electronics
|
|
|
|
|
|
|
|
|
|
|
|
This library provides four key benefits:
|
|
|
|
|
2010-11-13 20:01:37 +01:00
|
|
|
* Including `SD.h` automatically creates a global
|
|
|
|
`SD` object which can be interacted with in a similar
|
2010-11-13 19:42:17 +01:00
|
|
|
manner to other standard global objects like `Serial` and `Ethernet`.
|
|
|
|
|
|
|
|
* Boilerplate initialisation code is contained in one method named
|
|
|
|
`begin` and no further objects need to be created in order to access
|
2010-11-13 20:01:37 +01:00
|
|
|
the SD card.
|
2010-11-13 19:42:17 +01:00
|
|
|
|
|
|
|
* Calls to `open` can supply a full path name including parent
|
|
|
|
directories which simplifies interacting with files in subdirectories.
|
|
|
|
|
|
|
|
* Utility methods are provided to determine whether a file exists
|
|
|
|
and to create a directory heirarchy.
|
|
|
|
|
|
|
|
|
|
|
|
Note however that not all functionality provided by the underlying
|
|
|
|
sdfatlib library is exposed.
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
|
|
|
Implementation Notes
|
|
|
|
|
|
|
|
In order to handle multi-directory path traversal, functionality that
|
|
|
|
requires this ability is implemented as callback functions.
|
|
|
|
|
|
|
|
Individual methods call the `walkPath` function which performs the actual
|
|
|
|
directory traversal (swapping between two different directory/file handles
|
|
|
|
along the way) and at each level calls the supplied callback function.
|
|
|
|
|
|
|
|
Some types of functionality will take an action at each level (e.g. exists
|
|
|
|
or make directory) which others will only take an action at the bottom
|
|
|
|
level (e.g. open).
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
2010-11-13 20:01:37 +01:00
|
|
|
#include "SD.h"
|
2010-11-13 19:42:17 +01:00
|
|
|
|
|
|
|
// Used by `getNextPathComponent`
|
|
|
|
#define MAX_COMPONENT_LEN 12 // What is max length?
|
|
|
|
#define PATH_COMPONENT_BUFFER_LEN MAX_COMPONENT_LEN+1
|
|
|
|
|
|
|
|
bool getNextPathComponent(char *path, unsigned int *p_offset,
|
|
|
|
char *buffer) {
|
|
|
|
/*
|
|
|
|
|
|
|
|
Parse individual path components from a path.
|
|
|
|
|
|
|
|
e.g. after repeated calls '/foo/bar/baz' will be split
|
|
|
|
into 'foo', 'bar', 'baz'.
|
|
|
|
|
|
|
|
This is similar to `strtok()` but copies the component into the
|
|
|
|
supplied buffer rather than modifying the original string.
|
|
|
|
|
|
|
|
|
|
|
|
`buffer` needs to be PATH_COMPONENT_BUFFER_LEN in size.
|
|
|
|
|
|
|
|
`p_offset` needs to point to an integer of the offset at
|
|
|
|
which the previous path component finished.
|
|
|
|
|
|
|
|
Returns `true` if more components remain.
|
|
|
|
|
|
|
|
Returns `false` if this is the last component.
|
|
|
|
(This means path ended with 'foo' or 'foo/'.)
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
// TODO: Have buffer local to this function, so we know it's the
|
|
|
|
// correct length?
|
|
|
|
|
|
|
|
int bufferOffset = 0;
|
|
|
|
|
|
|
|
int offset = *p_offset;
|
|
|
|
|
|
|
|
// Skip root or other separator
|
|
|
|
if (path[offset] == '/') {
|
|
|
|
offset++;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Copy the next next path segment
|
|
|
|
while (bufferOffset < MAX_COMPONENT_LEN
|
|
|
|
&& (path[offset] != '/')
|
|
|
|
&& (path[offset] != '\0')) {
|
|
|
|
buffer[bufferOffset++] = path[offset++];
|
|
|
|
}
|
|
|
|
|
|
|
|
buffer[bufferOffset] = '\0';
|
|
|
|
|
|
|
|
// Skip trailing separator so we can determine if this
|
|
|
|
// is the last component in the path or not.
|
|
|
|
if (path[offset] == '/') {
|
|
|
|
offset++;
|
|
|
|
}
|
|
|
|
|
|
|
|
*p_offset = offset;
|
|
|
|
|
|
|
|
return (path[offset] != '\0');
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
boolean walkPath(char *filepath, SdFile& parentDir,
|
|
|
|
boolean (*callback)(SdFile& parentDir,
|
|
|
|
char *filePathComponent,
|
|
|
|
boolean isLastComponent,
|
|
|
|
void *object),
|
|
|
|
void *object = NULL) {
|
|
|
|
/*
|
|
|
|
|
|
|
|
When given a file path (and parent directory--normally root),
|
|
|
|
this function traverses the directories in the path and at each
|
|
|
|
level calls the supplied callback function while also providing
|
|
|
|
the supplied object for context if required.
|
|
|
|
|
|
|
|
e.g. given the path '/foo/bar/baz'
|
|
|
|
the callback would be called at the equivalent of
|
|
|
|
'/foo', '/foo/bar' and '/foo/bar/baz'.
|
|
|
|
|
|
|
|
The implementation swaps between two different directory/file
|
|
|
|
handles as it traverses the directories and does not use recursion
|
|
|
|
in an attempt to use memory efficiently.
|
|
|
|
|
|
|
|
If a callback wishes to stop the directory traversal it should
|
|
|
|
return false--in this case the function will stop the traversal,
|
|
|
|
tidy up and return false.
|
|
|
|
|
|
|
|
If a directory path doesn't exist at some point this function will
|
|
|
|
also return false and not subsequently call the callback.
|
|
|
|
|
|
|
|
If a directory path specified is complete, valid and the callback
|
|
|
|
did not indicate the traversal should be interrupted then this
|
|
|
|
function will return true.
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
SdFile subfile1;
|
|
|
|
SdFile subfile2;
|
|
|
|
|
|
|
|
char buffer[PATH_COMPONENT_BUFFER_LEN];
|
|
|
|
|
|
|
|
unsigned int offset = 0;
|
|
|
|
|
|
|
|
SdFile *p_parent;
|
|
|
|
SdFile *p_child;
|
|
|
|
|
|
|
|
SdFile *p_tmp_sdfile;
|
|
|
|
|
|
|
|
p_child = &subfile1;
|
|
|
|
|
|
|
|
p_parent = &parentDir;
|
|
|
|
|
|
|
|
while (true) {
|
|
|
|
|
|
|
|
boolean moreComponents = getNextPathComponent(filepath, &offset, buffer);
|
|
|
|
|
|
|
|
boolean shouldContinue = callback((*p_parent), buffer, !moreComponents, object);
|
|
|
|
|
|
|
|
if (!shouldContinue) {
|
|
|
|
// TODO: Don't repeat this code?
|
|
|
|
// If it's one we've created then we
|
|
|
|
// don't need the parent handle anymore.
|
|
|
|
if (p_parent != &parentDir) {
|
|
|
|
(*p_parent).close();
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-11-20 20:49:20 +01:00
|
|
|
if (!moreComponents) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2010-11-13 19:42:17 +01:00
|
|
|
boolean exists = (*p_child).open(*p_parent, buffer, O_RDONLY);
|
|
|
|
|
|
|
|
// If it's one we've created then we
|
|
|
|
// don't need the parent handle anymore.
|
|
|
|
if (p_parent != &parentDir) {
|
|
|
|
(*p_parent).close();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Handle case when it doesn't exist and we can't continue...
|
|
|
|
if (exists) {
|
|
|
|
// We alternate between two file handles as we go down
|
|
|
|
// the path.
|
|
|
|
if (p_parent == &parentDir) {
|
|
|
|
p_parent = &subfile2;
|
|
|
|
}
|
|
|
|
|
|
|
|
p_tmp_sdfile = p_parent;
|
|
|
|
p_parent = p_child;
|
|
|
|
p_child = p_tmp_sdfile;
|
|
|
|
} else {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-20 20:49:20 +01:00
|
|
|
if (p_parent != &parentDir) {
|
|
|
|
(*p_parent).close(); // TODO: Return/ handle different?
|
|
|
|
}
|
2010-11-13 19:42:17 +01:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
|
|
|
The callbacks used to implement various functionality follow.
|
|
|
|
|
|
|
|
Each callback is supplied with a parent directory handle,
|
|
|
|
character string with the name of the current file path component,
|
|
|
|
a flag indicating if this component is the last in the path and
|
|
|
|
a pointer to an arbitrary object used for context.
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
boolean callback_pathExists(SdFile& parentDir, char *filePathComponent,
|
|
|
|
boolean isLastComponent, void *object) {
|
|
|
|
/*
|
|
|
|
|
|
|
|
Callback used to determine if a file/directory exists in parent
|
|
|
|
directory.
|
|
|
|
|
|
|
|
Returns true if file path exists.
|
|
|
|
|
|
|
|
*/
|
|
|
|
SdFile child;
|
|
|
|
|
|
|
|
boolean exists = child.open(parentDir, filePathComponent, O_RDONLY);
|
|
|
|
|
|
|
|
if (exists) {
|
|
|
|
child.close();
|
|
|
|
}
|
|
|
|
|
|
|
|
return exists;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
boolean callback_makeDirPath(SdFile& parentDir, char *filePathComponent,
|
|
|
|
boolean isLastComponent, void *object) {
|
|
|
|
/*
|
|
|
|
|
|
|
|
Callback used to create a directory in the parent directory if
|
|
|
|
it does not already exist.
|
|
|
|
|
|
|
|
Returns true if a directory was created or it already existed.
|
|
|
|
|
|
|
|
*/
|
|
|
|
boolean result = false;
|
|
|
|
SdFile child;
|
|
|
|
|
|
|
|
result = callback_pathExists(parentDir, filePathComponent, isLastComponent, object);
|
|
|
|
if (!result) {
|
|
|
|
result = child.makeDir(parentDir, filePathComponent);
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-04-18 23:58:54 +02:00
|
|
|
/*
|
2010-11-13 19:42:17 +01:00
|
|
|
|
|
|
|
boolean callback_openPath(SdFile& parentDir, char *filePathComponent,
|
|
|
|
boolean isLastComponent, void *object) {
|
|
|
|
|
|
|
|
Callback used to open a file specified by a filepath that may
|
|
|
|
specify one or more directories above it.
|
|
|
|
|
2010-11-13 20:01:37 +01:00
|
|
|
Expects the context object to be an instance of `SDClass` and
|
2010-11-13 19:42:17 +01:00
|
|
|
will use the `file` property of the instance to open the requested
|
|
|
|
file/directory with the associated file open mode property.
|
|
|
|
|
|
|
|
Always returns true if the directory traversal hasn't reached the
|
|
|
|
bottom of the directory heirarchy.
|
|
|
|
|
|
|
|
Returns false once the file has been opened--to prevent the traversal
|
|
|
|
from descending further. (This may be unnecessary.)
|
|
|
|
|
|
|
|
if (isLastComponent) {
|
2010-11-20 19:07:59 +01:00
|
|
|
SDClass *p_SD = static_cast<SDClass*>(object);
|
|
|
|
p_SD->file.open(parentDir, filePathComponent, p_SD->fileOpenMode);
|
2010-12-22 22:52:09 +01:00
|
|
|
if (p_SD->fileOpenMode == FILE_WRITE) {
|
|
|
|
p_SD->file.seekSet(p_SD->file.fileSize());
|
|
|
|
}
|
2010-11-13 19:42:17 +01:00
|
|
|
// TODO: Return file open result?
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
2011-04-18 23:58:54 +02:00
|
|
|
*/
|
|
|
|
|
2010-11-13 19:42:17 +01:00
|
|
|
|
|
|
|
|
2010-11-20 19:07:59 +01:00
|
|
|
boolean callback_remove(SdFile& parentDir, char *filePathComponent,
|
|
|
|
boolean isLastComponent, void *object) {
|
|
|
|
if (isLastComponent) {
|
2010-11-20 20:49:20 +01:00
|
|
|
return SdFile::remove(parentDir, filePathComponent);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
boolean callback_rmdir(SdFile& parentDir, char *filePathComponent,
|
|
|
|
boolean isLastComponent, void *object) {
|
|
|
|
if (isLastComponent) {
|
|
|
|
SdFile f;
|
|
|
|
if (!f.open(parentDir, filePathComponent, O_READ)) return false;
|
|
|
|
return f.rmDir();
|
2010-11-20 19:07:59 +01:00
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-11-13 19:42:17 +01:00
|
|
|
|
2010-11-13 20:01:37 +01:00
|
|
|
/* Implementation of class used to create `SDCard` object. */
|
2010-11-13 19:42:17 +01:00
|
|
|
|
2010-11-14 17:48:21 +01:00
|
|
|
|
|
|
|
|
2010-11-20 19:50:45 +01:00
|
|
|
boolean SDClass::begin(uint8_t csPin) {
|
2010-11-13 19:42:17 +01:00
|
|
|
/*
|
|
|
|
|
|
|
|
Performs the initialisation required by the sdfatlib library.
|
|
|
|
|
2010-11-20 19:50:45 +01:00
|
|
|
Return true if initialization succeeds, false otherwise.
|
2010-11-13 19:42:17 +01:00
|
|
|
|
|
|
|
*/
|
2010-11-20 19:50:45 +01:00
|
|
|
return card.init(SPI_HALF_SPEED, csPin) &&
|
|
|
|
volume.init(card) &&
|
|
|
|
root.openRoot(volume);
|
2010-11-13 19:42:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-04-18 23:58:54 +02:00
|
|
|
|
|
|
|
// this little helper is used to traverse paths
|
2011-10-10 17:28:44 +02:00
|
|
|
SdFile SDClass::getParentDir(const char *filepath, int *index) {
|
2011-04-18 23:58:54 +02:00
|
|
|
// get parent directory
|
|
|
|
SdFile d1 = root; // start with the mostparent, root!
|
|
|
|
SdFile d2;
|
|
|
|
|
|
|
|
// we'll use the pointers to swap between the two objects
|
|
|
|
SdFile *parent = &d1;
|
|
|
|
SdFile *subdir = &d2;
|
|
|
|
|
2011-10-10 17:28:44 +02:00
|
|
|
const char *origpath = filepath;
|
2011-04-18 23:58:54 +02:00
|
|
|
|
|
|
|
while (strchr(filepath, '/')) {
|
|
|
|
|
|
|
|
// get rid of leading /'s
|
|
|
|
if (filepath[0] == '/') {
|
|
|
|
filepath++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (! strchr(filepath, '/')) {
|
|
|
|
// it was in the root directory, so leave now
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// extract just the name of the next subdirectory
|
|
|
|
uint8_t idx = strchr(filepath, '/') - filepath;
|
|
|
|
if (idx > 12)
|
|
|
|
idx = 12; // dont let them specify long names
|
|
|
|
char subdirname[13];
|
|
|
|
strncpy(subdirname, filepath, idx);
|
|
|
|
subdirname[idx] = 0;
|
|
|
|
|
|
|
|
// close the subdir (we reuse them) if open
|
|
|
|
subdir->close();
|
|
|
|
if (! subdir->open(parent, subdirname, O_READ)) {
|
|
|
|
// failed to open one of the subdirectories
|
|
|
|
return SdFile();
|
|
|
|
}
|
|
|
|
// move forward to the next subdirectory
|
|
|
|
filepath += idx;
|
|
|
|
|
|
|
|
// we reuse the objects, close it.
|
|
|
|
parent->close();
|
|
|
|
|
|
|
|
// swap the pointers
|
|
|
|
SdFile *t = parent;
|
|
|
|
parent = subdir;
|
|
|
|
subdir = t;
|
|
|
|
}
|
|
|
|
|
|
|
|
*index = (int)(filepath - origpath);
|
|
|
|
// parent is now the parent diretory of the file!
|
|
|
|
return *parent;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-10-10 17:28:44 +02:00
|
|
|
File SDClass::open(const char *filepath, uint8_t mode) {
|
2010-11-13 19:42:17 +01:00
|
|
|
/*
|
|
|
|
|
|
|
|
Open the supplied file path for reading or writing.
|
|
|
|
|
|
|
|
The file content can be accessed via the `file` property of
|
2010-11-13 20:01:37 +01:00
|
|
|
the `SDClass` object--this property is currently
|
2010-11-13 19:42:17 +01:00
|
|
|
a standard `SdFile` object from `sdfatlib`.
|
|
|
|
|
|
|
|
Defaults to read only.
|
|
|
|
|
|
|
|
If `write` is true, default action (when `append` is true) is to
|
|
|
|
append data to the end of the file.
|
|
|
|
|
|
|
|
If `append` is false then the file will be truncated first.
|
|
|
|
|
|
|
|
If the file does not exist and it is opened for writing the file
|
|
|
|
will be created.
|
|
|
|
|
|
|
|
An attempt to open a file for reading that does not exist is an
|
|
|
|
error.
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
2011-04-18 23:58:54 +02:00
|
|
|
int pathidx;
|
|
|
|
|
|
|
|
// do the interative search
|
|
|
|
SdFile parentdir = getParentDir(filepath, &pathidx);
|
|
|
|
// no more subdirs!
|
|
|
|
|
|
|
|
filepath += pathidx;
|
|
|
|
|
|
|
|
if (! filepath[0]) {
|
|
|
|
// it was the directory itself!
|
|
|
|
return File(parentdir, "/");
|
|
|
|
}
|
|
|
|
|
|
|
|
// Open the file itself
|
|
|
|
SdFile file;
|
|
|
|
|
|
|
|
// failed to open a subdir!
|
|
|
|
if (!parentdir.isOpen())
|
|
|
|
return File();
|
|
|
|
|
|
|
|
// there is a special case for the Root directory since its a static dir
|
|
|
|
if (parentdir.isRoot()) {
|
|
|
|
if ( ! file.open(SD.root, filepath, mode)) {
|
|
|
|
// failed to open the file :(
|
|
|
|
return File();
|
|
|
|
}
|
|
|
|
// dont close the root!
|
|
|
|
} else {
|
|
|
|
if ( ! file.open(parentdir, filepath, mode)) {
|
|
|
|
return File();
|
|
|
|
}
|
|
|
|
// close the parent
|
|
|
|
parentdir.close();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mode & (O_APPEND | O_WRITE))
|
|
|
|
file.seekSet(file.fileSize());
|
|
|
|
return File(file, filepath);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
File SDClass::open(char *filepath, uint8_t mode) {
|
|
|
|
//
|
|
|
|
|
|
|
|
Open the supplied file path for reading or writing.
|
|
|
|
|
|
|
|
The file content can be accessed via the `file` property of
|
|
|
|
the `SDClass` object--this property is currently
|
|
|
|
a standard `SdFile` object from `sdfatlib`.
|
|
|
|
|
|
|
|
Defaults to read only.
|
|
|
|
|
|
|
|
If `write` is true, default action (when `append` is true) is to
|
|
|
|
append data to the end of the file.
|
|
|
|
|
|
|
|
If `append` is false then the file will be truncated first.
|
|
|
|
|
|
|
|
If the file does not exist and it is opened for writing the file
|
|
|
|
will be created.
|
|
|
|
|
|
|
|
An attempt to open a file for reading that does not exist is an
|
|
|
|
error.
|
|
|
|
|
|
|
|
//
|
|
|
|
|
2010-11-13 19:42:17 +01:00
|
|
|
// TODO: Allow for read&write? (Possibly not, as it requires seek.)
|
|
|
|
|
2010-11-28 19:43:13 +01:00
|
|
|
fileOpenMode = mode;
|
2010-11-13 19:42:17 +01:00
|
|
|
walkPath(filepath, root, callback_openPath, this);
|
|
|
|
|
2010-11-20 04:30:40 +01:00
|
|
|
return File();
|
2010-11-13 19:42:17 +01:00
|
|
|
|
|
|
|
}
|
2011-04-18 23:58:54 +02:00
|
|
|
*/
|
2010-11-13 19:42:17 +01:00
|
|
|
|
|
|
|
|
2010-11-20 04:30:40 +01:00
|
|
|
//boolean SDClass::close() {
|
|
|
|
// /*
|
|
|
|
//
|
|
|
|
// Closes the file opened by the `open` method.
|
|
|
|
//
|
|
|
|
// */
|
|
|
|
// file.close();
|
|
|
|
//}
|
2010-11-13 19:42:17 +01:00
|
|
|
|
|
|
|
|
2010-11-13 20:01:37 +01:00
|
|
|
boolean SDClass::exists(char *filepath) {
|
2010-11-13 19:42:17 +01:00
|
|
|
/*
|
|
|
|
|
|
|
|
Returns true if the supplied file path exists.
|
|
|
|
|
|
|
|
*/
|
2010-11-20 04:30:40 +01:00
|
|
|
return walkPath(filepath, root, callback_pathExists);
|
2010-11-13 19:42:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-11-20 04:30:40 +01:00
|
|
|
//boolean SDClass::exists(char *filepath, SdFile& parentDir) {
|
|
|
|
// /*
|
|
|
|
//
|
|
|
|
// Returns true if the supplied file path rooted at `parentDir`
|
|
|
|
// exists.
|
|
|
|
//
|
|
|
|
// */
|
|
|
|
// return walkPath(filepath, parentDir, callback_pathExists);
|
|
|
|
//}
|
2010-11-13 19:42:17 +01:00
|
|
|
|
|
|
|
|
2010-11-20 18:31:49 +01:00
|
|
|
boolean SDClass::mkdir(char *filepath) {
|
2010-11-13 19:42:17 +01:00
|
|
|
/*
|
|
|
|
|
|
|
|
Makes a single directory or a heirarchy of directories.
|
|
|
|
|
|
|
|
A rough equivalent to `mkdir -p`.
|
|
|
|
|
|
|
|
*/
|
|
|
|
return walkPath(filepath, root, callback_makeDirPath);
|
|
|
|
}
|
2010-11-13 20:01:37 +01:00
|
|
|
|
2010-11-20 20:49:20 +01:00
|
|
|
boolean SDClass::rmdir(char *filepath) {
|
|
|
|
/*
|
|
|
|
|
2014-10-15 11:53:19 +02:00
|
|
|
Remove a single directory or a heirarchy of directories.
|
2010-11-20 20:49:20 +01:00
|
|
|
|
2014-10-15 11:53:19 +02:00
|
|
|
A rough equivalent to `rm -rf`.
|
2010-11-20 20:49:20 +01:00
|
|
|
|
|
|
|
*/
|
|
|
|
return walkPath(filepath, root, callback_rmdir);
|
|
|
|
}
|
|
|
|
|
|
|
|
boolean SDClass::remove(char *filepath) {
|
|
|
|
return walkPath(filepath, root, callback_remove);
|
2010-11-20 19:07:59 +01:00
|
|
|
}
|
|
|
|
|
2011-04-18 23:58:54 +02:00
|
|
|
|
|
|
|
// allows you to recurse into a directory
|
|
|
|
File File::openNextFile(uint8_t mode) {
|
|
|
|
dir_t p;
|
|
|
|
|
|
|
|
//Serial.print("\t\treading dir...");
|
|
|
|
while (_file->readDir(&p) > 0) {
|
|
|
|
|
|
|
|
// done if past last used entry
|
|
|
|
if (p.name[0] == DIR_NAME_FREE) {
|
|
|
|
//Serial.println("end");
|
|
|
|
return File();
|
|
|
|
}
|
|
|
|
|
|
|
|
// skip deleted entry and entries for . and ..
|
|
|
|
if (p.name[0] == DIR_NAME_DELETED || p.name[0] == '.') {
|
|
|
|
//Serial.println("dots");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// only list subdirectories and files
|
|
|
|
if (!DIR_IS_FILE_OR_SUBDIR(&p)) {
|
|
|
|
//Serial.println("notafile");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// print file name with possible blank fill
|
|
|
|
SdFile f;
|
|
|
|
char name[13];
|
|
|
|
_file->dirName(p, name);
|
|
|
|
//Serial.print("try to open file ");
|
|
|
|
//Serial.println(name);
|
|
|
|
|
|
|
|
if (f.open(_file, name, mode)) {
|
|
|
|
//Serial.println("OK!");
|
|
|
|
return File(f, name);
|
|
|
|
} else {
|
|
|
|
//Serial.println("ugh");
|
|
|
|
return File();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//Serial.println("nothing");
|
|
|
|
return File();
|
|
|
|
}
|
|
|
|
|
|
|
|
void File::rewindDirectory(void) {
|
|
|
|
if (isDirectory())
|
|
|
|
_file->rewind();
|
|
|
|
}
|
|
|
|
|
|
|
|
SDClass SD;
|