Right now even very small writes to a sector write the sector in full to the card, which blocks for a long time. Add logic to wait until the sector buffer is full, or is explicitly flushed by the user.

• add a separate metadata buffer
• find a way to eliminate the need to read in the FAT every time fseek() is called, to reduce unnecessary SD access; maybe set a flag indicating what kind of data is currently in the metadata buffer, and if it's the correct FAT sector, then do nothing
• add a method to 'queue' data
• add a mechanism for explicitly flushing the write buffer
• rewrite fwrite() to wait until sector buffer is full

Currently, it reads a block (even re-reading the current one) every time it's called, as long as the seek pointer is before the EOF.
Example: fread() is called to read 10 bytes. A full 512 byte sector is read in. If the next call only reads another 10 bytes, it should simply copy the data from the sector buffer instead of re-reading the sector.

Some or all errors should return using abort instead of return, so they can be trapped at higher-level calls.

Find out exactly how this is implemented in other systems - the dirent is marked deleted, but what is done with the cluster chain - is it simply overwritten with zeroes?
Alternative implementation is a permanent - clear out the dirent entirely and zero out cluster chain as well as the actual file data.

Only FAT32 is supported currently.

is it dangerous, as written, if there isn't one open when it's called?

Some code exists for this that hasn't yet been committed to the repo
Make sure it can:

• seek to any arbitrary position
• write a block of data to the current position
• enlarge a file (confined to the current sector)
• enlarge a file (confined to the current cluster)
• enlarge a file (allocating cluster(s) as needed)

The dirent # is 1 every iteration except the first, which is 0. It doesn't seem to find the file at dirent 2 even though it's there.

It doesn't check for an existing file with the requested new name; all it does is compare the old and new file name strings. This should still be checked, but a check for a file on disk with the new name needs to be added.

Add in the form of FCreate() or similar.
params: fn_str, attrs

when following the cluster chain, the loop just advances to the next fat sector, if it needs to. Shouldn't this actually go to a specific sector based on the next link in the chain, which might not necessarily be the very next sector?

Well it is technically: it just increments by 4 in the cluster chain-following loop, but the resulting value isn't used. Probably a vestige of older code. Make sure something that used it wasn't erroneously ripped out.

Currently only a vague awareness of the root directory exists. Add the ability to create, remove, rename, chdir to subdirectories.

Set this up so it can be read via pointer - that way a user can independently run e.g., an RTC driver and trigger an update of the current time, and then do some file I/O that can use the current date/time.

Implement a FAT(32) on SD formatting utility.

Needed for overwrite when opening, and truncating a file to 0 bytes.

• change dirent size to 0
• clear cluster chain

Optional mode for fopen(), to indicate to fwrite() that writes should be committed immediately, not deferred until the sector buffer is full.

Currently, the file is fopen()'d to read/use its metadata to mark it for deletion. Rewrite it so it operates directly on the directory entries. This will also mean a check has to be added to make sure the file being deleted isn't the currently open file.

Much like #31, currently, the file is fopen()'d to read/use its metadata to rename it.
Rewrite it so it operates directly on the directory entries.

Some code not committed to the repo exists - make sure it:

• handles common errors (e.g., file not found, I/O error)
• can seek to any arbitrary position
• can read any part of the file, reliably
• can't access beyond the end (or beginning) of the file

Currently, allocating a single cluster is supported. Add support for finding a block of n clusters and allocating them, if possible.

This shouldn't really need anything specific to the block I/O layer, so move the code to fatfs FClose(), and define the VARs there instead.
If something at this layer is needed later, maybe it can be called FCloseEnt()?

The dirents show up as 0/0/-20 00:00:00

The serial object and debug output statements are all always built into the project, making it appear much larger than it is, and also slowing things down. See if it's practical to use the debug functionality in FlexSpin, or only build with debug if a certain preprocessor symbol is defined.

Some code exists for this that hasn't yet been committed to the repo
Make sure it:

• can show the volume label
• list files with their name, size, attributes, date/timestamps
• show total number of files as well as total size
• list subdirectories

This must've broken in one of the updates this weekend.

It shouldn't waste time doing anything if it was called with write length 0 (without having reviewed the code in detail - maybe doing so could even cause problems).

It'd be nice to be able to shrink (or grow) to other arbitrary sizes.

Once stability has been achieved, port to P2/SPIN2.

Modify dirent to rename file.

Right now in e.g., FOpen(), the filename param must be in a certain format in order to successfully find it. Rewrite this to be more lax. Space-pad the filename if less than 8 chars was given, assume the extension is just three spaces if no extension is given, etc.....

• pad short filenames to 8.3 format
• convert full filename to uppercase

A file's cluster chain could continue from one FAT sector to another, but the loop that follows the chain doesn't advance to other sectors. It's actually written pretty naiively, just repeating a number of times equal to the number of clusters the file uses. This could just walk right off the end of the metadata buffer.

When calling fopen(), the write protect bit is now honored if trying to open the file for writing. Before, to change a file's attributes, it could be opened, then the fatfs layer's fset_attrs() called to modify the directory entry cached in RAM's attributes, then written back to disk, but this won't be possible now.

This way, the buffer could optionally be much larger.