LittleFsStorageManager.h

Go to the documentation of this file.

 
#pragma once
 
#include "StorageManager.h"
#include "lfs.h"
#include <vector>
#include <string>
#include <FreeRTOS.h> // for FreeRTOS types and functions
#include <semphr.h>   // for SemaphoreHandle_t, StaticSemaphore_t, xSemaphoreCreateMutexStatic, xSemaphoreTake, xSemaphoreGive
 
class LittleFsStorageManager : public StorageManager
{
public:
    LittleFsStorageManager();
 
    std::unique_ptr<StorageFileReader> openReader(const std::string& path) override;
 
    bool mount() override;
 
    bool unmount() override;
 
    bool isMounted() const override;
 
    bool exists(const std::string &path) override;
 
    bool remove(const std::string &path) override;
 
    bool rename(const std::string &from, const std::string &to) override;
 
    bool readFile(const std::string &path, std::vector<uint8_t> &out) override;
 
    bool readFileString(const std::string &path, uint32_t startPosition, uint32_t length, std::string &buffer);
 
    bool writeFile(const std::string &path, const std::vector<uint8_t> &data) override;
    bool writeFile(const std::string& path, const unsigned char* data, size_t size) override;
 
    bool appendToFile(const std::string &path, const uint8_t *data, size_t size) override;
 
    bool streamFile(const std::string &path, std::function<void(const uint8_t *, size_t)> chunkCallback) override;
 
    size_t getFileSize(const std::string &path) override;
 
    bool listDirectory(const std::string &path, std::vector<FileInfo> &out) override;
 
    bool createDirectory(const std::string &path) override;
 
    bool removeDirectory(const std::string &path) override;
 
    bool formatStorage() override;
 
    uintptr_t getFlashBase() const
    {
        return flashBase;
    }
 
    void formatInner(bool *result);
 
private:
    uintptr_t flashBase = 0;
    size_t flashSize = 0;
 
    static constexpr uint32_t FLASH_BASE = 0x101E0000;
    static constexpr size_t FLASH_SIZE = 128 * 1024; 
 
    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;
 
    lfs_t lfs;
    struct lfs_config config;
 
    bool mounted = false;
 
    // --- LittleFS Thread Safety Lock (FreeRTOS mutex, statically allocated) ---
 
    static StaticSemaphore_t lfs_mutex_buf;
    static SemaphoreHandle_t lfs_mutex;
 
    void configure();
    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);
 
    bool autoMountIfNeeded();
};