LittleFsStorageManager Class Reference

A LittleFS-based implementation of StorageManager, storing files in flash memory. More...

#include <LittleFsStorageManager.h>

Inheritance diagram for LittleFsStorageManager:

Collaboration diagram for LittleFsStorageManager:

Public Member Functions
	LittleFsStorageManager ()
	Construct the manager and configure the filesystem.
std::unique_ptr< StorageFileReader >	openReader (const std::string &path) override
	open a file for streaming read line access.
bool	mount () override
	Mount the LittleFS filesystem.
bool	unmount () override
	Unmount the LittleFS filesystem.
bool	isMounted () const override
	Check if the filesystem is mounted.
bool	exists (const std::string &path) override
	Check if a file or directory exists.
bool	remove (const std::string &path) override
	Remove a file or directory.
bool	rename (const std::string &from, const std::string &to) override
	Rename a file or directory.
bool	readFile (const std::string &path, std::vector< uint8_t > &out) override
	Read a file into a byte vector.
bool	readFileString (const std::string &path, uint32_t startPosition, uint32_t length, std::string &buffer)
	Read a file string into a memory buffer.
bool	writeFile (const std::string &path, const std::vector< uint8_t > &data) override
	Write a byte vector to a file (overwrite).
bool	writeFile (const std::string &path, const unsigned char *data, size_t size) override
	Write from a raw buffer.
bool	appendToFile (const std::string &path, const uint8_t *data, size_t size) override
	Append data to a file.
bool	streamFile (const std::string &path, std::function< void(const uint8_t *, size_t)> chunkCallback) override
	Stream a file in chunks using a callback.
size_t	getFileSize (const std::string &path) override
	Get the size of a file.
bool	listDirectory (const std::string &path, std::vector< FileInfo > &out) override
	List files in a directory.
bool	createDirectory (const std::string &path) override
	Create a new directory.
bool	removeDirectory (const std::string &path) override
	Remove a directory.
bool	formatStorage () override
	Format the filesystem.
uintptr_t	getFlashBase () const
	get Flash base address
void	formatInner (bool *result)
Public Member Functions inherited from StorageManager
virtual	~StorageManager ()=default

Private Member Functions
void	configure ()
bool	autoMountIfNeeded ()
	Mount automatically if not mounted yet.

Static Private Member Functions
static int	lfs_read_cb (const struct lfs_config *c, lfs_block_t block, lfs_off_t off, void *buffer, lfs_size_t size)
static int	lfs_prog_cb (const struct lfs_config *c, lfs_block_t block, lfs_off_t off, const void *buffer, lfs_size_t size)
static int	lfs_erase_cb (const struct lfs_config *c, lfs_block_t block)
static int	lfs_prog_cb_singlecore (const struct lfs_config *c, lfs_block_t block, lfs_off_t off, const void *buffer, lfs_size_t size)
static int	lfs_erase_cb_singlecore (const struct lfs_config *c, lfs_block_t block)
static int	lfs_prog_cb_multicore (const struct lfs_config *c, lfs_block_t block, lfs_off_t off, const void *buffer, lfs_size_t size)
static int	lfs_erase_cb_multicore (const struct lfs_config *c, lfs_block_t block)
static int	lfs_lock (const struct lfs_config *c)
static int	lfs_unlock (const struct lfs_config *c)

Private Attributes
uintptr_t	flashBase = 0
size_t	flashSize = 0
lfs_t	lfs
struct lfs_config	config
bool	mounted = false

Static Private Attributes
static constexpr uint32_t	FLASH_BASE = 0x101E0000
static constexpr size_t	FLASH_SIZE = 128 * 1024
	128 KB
static constexpr size_t	READ_SIZE = 256
static constexpr size_t	PROG_SIZE = 256
static constexpr size_t	BLOCK_SIZE = 4096
static constexpr size_t	BLOCK_COUNT = FLASH_SIZE / BLOCK_SIZE
static constexpr size_t	CACHE_SIZE = 256
static constexpr size_t	LOOKAHEAD_SIZE = 256
static StaticSemaphore_t	lfs_mutex_buf
static SemaphoreHandle_t	lfs_mutex = xSemaphoreCreateMutexStatic(&lfs_mutex_buf)

Detailed Description

Automatically mounts on first access if not already mounted.

Definition at line 25 of file LittleFsStorageManager.h.

Constructor & Destructor Documentation

LittleFsStorageManager()

LittleFsStorageManager::LittleFsStorageManager

(

)

Definition at line 27 of file LittleFsStorageManager.cpp.

{
    configure();
}

References configure().

Here is the call graph for this function:

Member Function Documentation

appendToFile()

bool LittleFsStorageManager::appendToFile ( const std::string &  path, const uint8_t *  data, size_t  size  )

overridevirtual

Parameters

path	Path to the file.
data	Pointer to data.
size	Size of data in bytes.

Returns

true if appended.

Implements StorageManager.

Definition at line 315 of file LittleFsStorageManager.cpp.

{
    lfs_file_t file;
    if (lfs_file_open(&lfs, &file, path.c_str(), LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) < 0)
    {
        printf("[LittleFS] appendToFile: open failed for '%s'\n", path.c_str());
        lfs_file_close(&lfs, &file);
        return false;
    }
    int written = lfs_file_write(&lfs, &file, data, size);
    if (written < 0)
    {
        printf("[LittleFS] appendToFile: write failed for '%s'\n", path.c_str());
        lfs_file_close(&lfs, &file);
        return false;
    }
    lfs_file_close(&lfs, &file);
    return written == (int)size;
}

References lfs.

autoMountIfNeeded()

bool LittleFsStorageManager::autoMountIfNeeded ( )

private

Returns

true if mounted successfully or already mounted.

configure()

void LittleFsStorageManager::configure ( )

private

Definition at line 169 of file LittleFsStorageManager.cpp.

{
    flashBase = reinterpret_cast<uintptr_t>(&__flash_lfs_start);
    flashSize = reinterpret_cast<uintptr_t>(&__flash_lfs_end) - flashBase;
 
    std::memset(&config, 0, sizeof(config));
 
    config.context = this;
    config.read = lfs_read_cb;
    config.prog = lfs_prog_cb;
    config.erase = lfs_erase_cb;
    config.sync = [](const struct lfs_config *) -> int
    { return 0; };
 
    config.read_size = 256;
    config.prog_size = 256;
    config.block_size = 4096;
    config.block_count = flashSize / config.block_size;
    config.cache_size = 256;
    config.lookahead_size = 256;
    config.block_cycles = 500;
    config.compact_thresh = (lfs_size_t)-1;
#if defined(LFS_THREADSAFE)
    config.lock = lfs_lock;
    config.unlock = lfs_unlock;
#endif
    // printf("[LittleFS] Configured, flash base: 0x%08x, size: %zu bytes (%zu blocks)\n",
    //        static_cast<unsigned>(flashBase), flashSize, config.block_count);
}

References __flash_lfs_end, __flash_lfs_start, config, flashBase, flashSize, lfs_erase_cb(), lfs_lock(), lfs_prog_cb(), lfs_read_cb(), and lfs_unlock().

Referenced by LittleFsStorageManager().

Here is the call graph for this function:

Here is the caller graph for this function:

createDirectory()

bool LittleFsStorageManager::createDirectory ( const std::string &  path )

overridevirtual

Parameters

path	Path of directory.

Returns

true if created.

Implements StorageManager.

Definition at line 403 of file LittleFsStorageManager.cpp.

{
    TRACE("[LittleFS] Creating directory '%s'\n", path.c_str());
    if (lfs_mkdir(&lfs, path.c_str()) < 0)
    {
        printf("[LittleFS] Failed to create directory '%s'\n", path.c_str());
        return false;
    }
    TRACE("[LittleFS] Directory '%s' created successfully\n", path.c_str());
    return true;
}

References lfs, and TRACE.

exists()

bool LittleFsStorageManager::exists ( const std::string &  path )

overridevirtual

Parameters

path	Path to the file or directory.

Returns

true if it exists.

Implements StorageManager.

Definition at line 232 of file LittleFsStorageManager.cpp.

{
    struct lfs_info info;
    int err = lfs_stat(&lfs, path.c_str(), &info);
    return (err == 0);
}

References lfs.

formatInner()

void LittleFsStorageManager::formatInner

(

bool *

result

)

formatStorage()

bool LittleFsStorageManager::formatStorage ( )

overridevirtual

Returns

true if formatted successfully.

Implements StorageManager.

Definition at line 420 of file LittleFsStorageManager.cpp.

{
    // Note that this function will unmount the filesystem before formatting
    // and remount it afterwards if successful.
 
 
    
    bool result = false;
 
    if(mounted)
    {
        TRACE("[LittleFs] Unmounting before format\n");
        unmount();
    }
    int err = lfs_format(&lfs, &config);
    result = (err == 0);
 
    if (result)
    {
        printf("[LittleFs] Format successful\n");
        mount();
    }
    else
    {
        printf("[LittleFs] Format failed\n");
    }
    return result;
}

References config, lfs, mount(), mounted, TRACE, and unmount().

Here is the call graph for this function:

getFileSize()

size_t LittleFsStorageManager::getFileSize ( const std::string &  path )

overridevirtual

Parameters

path	Path to the file.

Returns

Size in bytes, or 0 on error.

Implements StorageManager.

Definition at line 360 of file LittleFsStorageManager.cpp.

{
    lfs_file_t file;
    if (lfs_file_open(&lfs, &file, path.c_str(), LFS_O_RDONLY) < 0)
    {
        printf("[LittleFS] getFileSize: open failed for '%s'\n", path.c_str());
        return 0;
    }
    lfs_soff_t size = lfs_file_size(&lfs, &file);
    lfs_file_close(&lfs, &file);
    return size < 0 ? 0 : size;
}

References lfs.

getFlashBase()

uintptr_t LittleFsStorageManager::getFlashBase ( ) const

inline

Returns

Flash base address

Definition at line 159 of file LittleFsStorageManager.h.

    {
        return flashBase;
    }

References flashBase.

Referenced by lfs_erase_cb_flashsafe(), and lfs_prog_multicore().

Here is the caller graph for this function:

isMounted()

bool LittleFsStorageManager::isMounted ( ) const

overridevirtual

Returns

true if mounted.

Implements StorageManager.

Definition at line 227 of file LittleFsStorageManager.cpp.

{
    return mounted;
}

References mounted.

lfs_erase_cb()

int LittleFsStorageManager::lfs_erase_cb ( const struct lfs_config *  c, lfs_block_t  block  )

staticprivate

Definition at line 110 of file LittleFsStorageManager.cpp.

{
#if (configNUM_CORES > 1)
    return lfs_erase_cb_multicore(c, block);
#else
    return lfs_erase_cb_singlecore(c, block);
#endif
}

References lfs_erase_cb_multicore(), and lfs_erase_cb_singlecore().

Referenced by configure().

Here is the call graph for this function:

Here is the caller graph for this function:

lfs_erase_cb_multicore()

int LittleFsStorageManager::lfs_erase_cb_multicore ( const struct lfs_config *  c, lfs_block_t  block  )

staticprivate

Definition at line 155 of file LittleFsStorageManager.cpp.

{
    auto *self = static_cast<LittleFsStorageManager *>(c->context);
    uintptr_t addr = static_cast<LittleFsStorageManager *>(c->context)->flashBase + block * c->block_size;
    int err = lfs_erase_cb_flashsafe(c, block);
    return err;
}

References flashBase, and lfs_erase_cb_flashsafe().

Referenced by lfs_erase_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

lfs_erase_cb_singlecore()

int LittleFsStorageManager::lfs_erase_cb_singlecore ( const struct lfs_config *  c, lfs_block_t  block  )

staticprivate

Definition at line 119 of file LittleFsStorageManager.cpp.

{
    auto *self = static_cast<LittleFsStorageManager *>(c->context);
    uintptr_t addr = self->flashBase + block * c->block_size;
    uint32_t ints = save_and_disable_interrupts();
    flash_range_erase(addr - XIP_BASE, c->block_size);
    restore_interrupts(ints);
    return 0;
}

References flashBase.

Referenced by lfs_erase_cb().

Here is the caller graph for this function:

lfs_lock()

int LittleFsStorageManager::lfs_lock ( const struct lfs_config *  c )

staticprivate

Definition at line 32 of file LittleFsStorageManager.cpp.

                                                               {
    assert(lfs_mutex != nullptr);
    return (xSemaphoreTake(lfs_mutex, portMAX_DELAY) == pdTRUE) ? 0 : -1;
}

References lfs_mutex.

Referenced by configure().

Here is the caller graph for this function:

lfs_prog_cb()

int LittleFsStorageManager::lfs_prog_cb ( const struct lfs_config *  c, lfs_block_t  block, lfs_off_t  off, const void *  buffer, lfs_size_t  size  )

staticprivate

Definition at line 51 of file LittleFsStorageManager.cpp.

{
 
#if (configNUM_CORES > 1)
    return lfs_prog_cb_multicore(c, block, off, buffer, size);
#else
    return lfs_prog_cb_singlecore(c, block, off, buffer, size);
#endif
}

References lfs_prog_cb_multicore(), and lfs_prog_cb_singlecore().

Referenced by configure().

Here is the call graph for this function:

Here is the caller graph for this function:

lfs_prog_cb_multicore()

int LittleFsStorageManager::lfs_prog_cb_multicore ( const struct lfs_config *  c, lfs_block_t  block, lfs_off_t  off, const void *  buffer, lfs_size_t  size  )

staticprivate

Definition at line 103 of file LittleFsStorageManager.cpp.

{
    auto *self = static_cast<LittleFsStorageManager *>(c->context);
    uintptr_t addr = self->flashBase + block * c->block_size + off;
    return lfs_prog_multicore(c, block, off, buffer, size);
}

References flashBase, and lfs_prog_multicore().

Referenced by lfs_prog_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

lfs_prog_cb_singlecore()

int LittleFsStorageManager::lfs_prog_cb_singlecore ( const struct lfs_config *  c, lfs_block_t  block, lfs_off_t  off, const void *  buffer, lfs_size_t  size  )

staticprivate

Definition at line 62 of file LittleFsStorageManager.cpp.

{
    auto *self = static_cast<LittleFsStorageManager *>(c->context);
    uintptr_t addr = self->flashBase + block * c->block_size + off;
    uint32_t ints = save_and_disable_interrupts();
    flash_range_program(addr - XIP_BASE, reinterpret_cast<const uint8_t *>(buffer), size);
    restore_interrupts(ints);
    return 0;
}

References flashBase.

Referenced by lfs_prog_cb().

Here is the caller graph for this function:

lfs_read_cb()

int LittleFsStorageManager::lfs_read_cb ( const struct lfs_config *  c, lfs_block_t  block, lfs_off_t  off, void *  buffer, lfs_size_t  size  )

staticprivate

Definition at line 41 of file LittleFsStorageManager.cpp.

{
    auto *self = static_cast<LittleFsStorageManager *>(c->context);
    uintptr_t addr = self->flashBase + block * c->block_size + off;
    std::memcpy(buffer, reinterpret_cast<const void *>(addr), size);
    return 0;
}

References flashBase.

Referenced by configure().

Here is the caller graph for this function:

lfs_unlock()

int LittleFsStorageManager::lfs_unlock ( const struct lfs_config *  c )

staticprivate

Definition at line 37 of file LittleFsStorageManager.cpp.

                                                                 {
    return (xSemaphoreGive(lfs_mutex) == pdTRUE) ? 0 : -1;
}

References lfs_mutex.

Referenced by configure().

Here is the caller graph for this function:

listDirectory()

bool LittleFsStorageManager::listDirectory ( const std::string &  path, std::vector< FileInfo > &  out  )

overridevirtual

Parameters

path	Path to directory.
out	Vector to receive file entries.

Returns

true if listed successfully.

Implements StorageManager.

Definition at line 373 of file LittleFsStorageManager.cpp.

{
    if(!mounted)
    {
        mount();
    }
    lfs_dir_t dir;
    struct lfs_info info = {};
 
    if (lfs_dir_open(&lfs, &dir, path.c_str()) < 0)
        return false;  
 
    while (lfs_dir_read(&lfs, &dir, &info) > 0)
    {
        if (strcmp(info.name, ".") == 0 || strcmp(info.name, "..") == 0)
            continue;
 
        FileInfo entry;
        entry.name = info.name;
        entry.size = info.size;
        entry.isDirectory = (info.type == LFS_TYPE_DIR);
        entry.isReadOnly = false;  // LittleFS doesn't expose this, so hardcoded
        out.push_back(entry);
    }
 
    lfs_dir_close(&lfs, &dir);
    return true;
}

References FileInfo::isDirectory, FileInfo::isReadOnly, lfs, mount(), mounted, FileInfo::name, and FileInfo::size.

Here is the call graph for this function:

mount()

bool LittleFsStorageManager::mount ( )

overridevirtual

Returns

true if mounted successfully.

Implements StorageManager.

Definition at line 199 of file LittleFsStorageManager.cpp.

{
    if( mounted)
    {
        TRACE("[LittleFs] Already mounted\n");
        return true;
    }
    TRACE("[LittleFs] Mounting LittleFS...\n");
    int err = lfs_mount(&lfs, &config);
    if (err < 0)
    {
        printf("[LittleFs] Mount failed with error %d\n", err);
        return false;
    }
    TRACE("[LittleFs] Mounted successfully\n");
    return mounted = true;
}

References config, lfs, mounted, and TRACE.

Referenced by formatStorage(), listDirectory(), and openReader().

Here is the caller graph for this function:

openReader()

std::unique_ptr< StorageFileReader > LittleFsStorageManager::openReader ( const std::string &  path )

overridevirtual

Implements StorageManager.

Definition at line 449 of file LittleFsStorageManager.cpp.

                                                                                         {
    if (!mount()) return nullptr;
    auto reader = std::make_unique<LittleFsFileReader>(&lfs);
    if (!reader) {
        return nullptr;
    }
    if (!reader->open(path)) return nullptr;
    return reader;
}

References lfs, and mount().

Here is the call graph for this function:

readFile()

bool LittleFsStorageManager::readFile ( const std::string &  path, std::vector< uint8_t > &  out  )

overridevirtual

Parameters

path	Path to the file.
out	Output vector with file contents.

Returns

true if successful.

Implements StorageManager.

Definition at line 249 of file LittleFsStorageManager.cpp.

{
    lfs_file_t file;
    if (lfs_file_open(&lfs, &file, path.c_str(), LFS_O_RDONLY) < 0)
        return false;
 
    lfs_soff_t size = lfs_file_size(&lfs, &file);
    if (size < 0)
    {
        lfs_file_close(&lfs, &file);
        return false;
    }
 
    out.resize(size);
    int bytes = lfs_file_read(&lfs, &file, out.data(), size);
    lfs_file_close(&lfs, &file);
    return (bytes >= 0) && (bytes == size);
}

References lfs.

readFileString()

bool LittleFsStorageManager::readFileString ( const std::string &  path, uint32_t  startPosition, uint32_t  length, std::string &  buffer  )

virtual

Parameters

path	Path to the file.
startPosition	Start position in the file.
length	Length of data to read.
buffer	Output string to fill with data.

Returns

true if successful.

Implements StorageManager.

Definition at line 268 of file LittleFsStorageManager.cpp.

                                                                                                                            {
    lfs_file_t file;
    if (lfs_file_open(&lfs, &file, path.c_str(), LFS_O_RDONLY) < 0)
        return false;
 
    lfs_soff_t size = lfs_file_size(&lfs, &file);
    if (size < 0 || startPosition >= size)
    {
        lfs_file_close(&lfs, &file);
        return false;
    }
 
    if (startPosition + length > size)
        length = size - startPosition;
 
    buffer.resize(length);
    lfs_file_seek(&lfs, &file, startPosition, LFS_SEEK_SET);
    int bytesRead = lfs_file_read(&lfs, &file, buffer.data(), length);
    lfs_file_close(&lfs, &file);
    return (bytesRead >= 0) && (bytesRead == static_cast<int>(length));
}

References lfs.

remove()

bool LittleFsStorageManager::remove ( const std::string &  path )

overridevirtual

Parameters

path	Path to the file or directory.

Returns

true if removed.

Implements StorageManager.

Definition at line 239 of file LittleFsStorageManager.cpp.

{
    return lfs_remove(&lfs, path.c_str()) == 0;
}

References lfs.

removeDirectory()

bool LittleFsStorageManager::removeDirectory ( const std::string &  path )

overridevirtual

Parameters

path	Path of directory.

Returns

true if removed.

Implements StorageManager.

Definition at line 415 of file LittleFsStorageManager.cpp.

{
    return lfs_remove(&lfs, path.c_str()) == 0;
}

References lfs.

rename()

bool LittleFsStorageManager::rename ( const std::string &  from, const std::string &  to  )

overridevirtual

Parameters

from	Source path.
to	Destination path.

Returns

true if renamed.

Implements StorageManager.

Definition at line 244 of file LittleFsStorageManager.cpp.

{
    return lfs_rename(&lfs, from.c_str(), to.c_str()) == 0;
}

References lfs.

streamFile()

bool LittleFsStorageManager::streamFile ( const std::string &  path, std::function< void(const uint8_t *, size_t)>  chunkCallback  )

overridevirtual

Parameters

path	Path to the file.
chunkCallback	Callback to receive chunks.

Returns

true if streamed successfully.

Implements StorageManager.

Definition at line 335 of file LittleFsStorageManager.cpp.

{
    lfs_file_t file;
    if (lfs_file_open(&lfs, &file, path.c_str(), LFS_O_RDONLY) < 0)
        return false;
 
    uint8_t buf[HTTP_BUFFER_SIZE];
    int readBytes;
    bool success = true;
 
    while ((readBytes = lfs_file_read(&lfs, &file, buf, sizeof(buf))) > 0)
    {
        chunkCallback(buf, readBytes);
    }
 
    if (readBytes < 0)
    {
        printf("[LittleFS] streamFile: read failed for '%s'\n", path.c_str());
        success = false;
    }
 
    lfs_file_close(&lfs, &file);
    return success;
}

References HTTP_BUFFER_SIZE, and lfs.

unmount()

bool LittleFsStorageManager::unmount ( )

overridevirtual

Returns

true if unmounted successfully.

Implements StorageManager.

Definition at line 217 of file LittleFsStorageManager.cpp.

{
    if (mounted)
    {
        lfs_unmount(&lfs);
        mounted = false;
    }
    return true;
}

References lfs, and mounted.

Referenced by formatStorage().

Here is the caller graph for this function:

writeFile() [1/2]

bool LittleFsStorageManager::writeFile ( const std::string &  path, const std::vector< uint8_t > &  data  )

overridevirtual

Parameters

path	Path to the file.
data	Data to write.

Returns

true if successful.

Implements StorageManager.

Definition at line 290 of file LittleFsStorageManager.cpp.

{
    lfs_file_t file;
    if (lfs_file_open(&lfs, &file, path.c_str(), LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) < 0)
        return false;
    int written = lfs_file_write(&lfs, &file, data.data(), data.size());
    int closed = lfs_file_close(&lfs, &file);
    return (written == static_cast<int>(data.size())) && (closed == 0);
}

References lfs.

writeFile() [2/2]

bool LittleFsStorageManager::writeFile ( const std::string &  path, const unsigned char *  data, size_t  size  )

overridevirtual

Implements StorageManager.

Definition at line 300 of file LittleFsStorageManager.cpp.

{
    if (!mounted)
        return false;
 
    lfs_file_t file;
    if (lfs_file_open(&lfs, &file, path.c_str(), LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) < 0)
        return false;
 
    int written = lfs_file_write(&lfs, &file, data, size);
    lfs_file_close(&lfs, &file);
 
    return (written == static_cast<int>(size));
}

References lfs, and mounted.

Member Data Documentation

BLOCK_COUNT

constexpr size_t LittleFsStorageManager::BLOCK_COUNT = FLASH_SIZE / BLOCK_SIZE

staticconstexprprivate

Definition at line 176 of file LittleFsStorageManager.h.

BLOCK_SIZE

constexpr size_t LittleFsStorageManager::BLOCK_SIZE = 4096

staticconstexprprivate

Definition at line 175 of file LittleFsStorageManager.h.

CACHE_SIZE

constexpr size_t LittleFsStorageManager::CACHE_SIZE = 256

staticconstexprprivate

Definition at line 177 of file LittleFsStorageManager.h.

config

struct lfs_config LittleFsStorageManager::config

private

Definition at line 181 of file LittleFsStorageManager.h.

Referenced by configure(), formatStorage(), and mount().

FLASH_BASE

constexpr uint32_t LittleFsStorageManager::FLASH_BASE = 0x101E0000

staticconstexprprivate

Definition at line 170 of file LittleFsStorageManager.h.

FLASH_SIZE

constexpr size_t LittleFsStorageManager::FLASH_SIZE = 128 * 1024

staticconstexprprivate

Definition at line 171 of file LittleFsStorageManager.h.

flashBase

uintptr_t LittleFsStorageManager::flashBase = 0

private

Definition at line 167 of file LittleFsStorageManager.h.

Referenced by configure(), getFlashBase(), lfs_erase_cb_multicore(), lfs_erase_cb_singlecore(), lfs_prog_cb_multicore(), lfs_prog_cb_singlecore(), and lfs_read_cb().

flashSize

size_t LittleFsStorageManager::flashSize = 0

private

Definition at line 168 of file LittleFsStorageManager.h.

Referenced by configure().

lfs

lfs_t LittleFsStorageManager::lfs

private

Definition at line 180 of file LittleFsStorageManager.h.

Referenced by appendToFile(), createDirectory(), exists(), formatStorage(), getFileSize(), listDirectory(), mount(), openReader(), readFile(), readFileString(), remove(), removeDirectory(), rename(), streamFile(), unmount(), writeFile(), and writeFile().

lfs_mutex

SemaphoreHandle_t LittleFsStorageManager::lfs_mutex = xSemaphoreCreateMutexStatic(&lfs_mutex_buf)

staticprivate

Definition at line 188 of file LittleFsStorageManager.h.

Referenced by lfs_lock(), and lfs_unlock().

lfs_mutex_buf

StaticSemaphore_t LittleFsStorageManager::lfs_mutex_buf

staticprivate

Definition at line 187 of file LittleFsStorageManager.h.

LOOKAHEAD_SIZE

constexpr size_t LittleFsStorageManager::LOOKAHEAD_SIZE = 256

staticconstexprprivate

Definition at line 178 of file LittleFsStorageManager.h.

mounted

bool LittleFsStorageManager::mounted = false

private

Definition at line 183 of file LittleFsStorageManager.h.

Referenced by formatStorage(), isMounted(), listDirectory(), mount(), unmount(), and writeFile().

PROG_SIZE

constexpr size_t LittleFsStorageManager::PROG_SIZE = 256

staticconstexprprivate

Definition at line 174 of file LittleFsStorageManager.h.

READ_SIZE

constexpr size_t LittleFsStorageManager::READ_SIZE = 256

staticconstexprprivate

Definition at line 173 of file LittleFsStorageManager.h.

---

The documentation for this class was generated from the following files:

• LittleFsStorageManager.h
• LittleFsStorageManager.cpp