littlefs与sfud串行flash通用驱动建立FreeRTOS文件系统

已于 2023-10-10 11:53:09 修改
阅读量4.5k 收藏 13
点赞数 1
分类专栏： FreeRTOS 文章标签： 网络 服务器 运维
于 2019-02-13 22:59:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dmjkun/article/details/87215164
版权

littlefs文件系统体积很小，很适合经常断电重启的嵌入式场合，使用过程没发现过文件损坏或数据丢失的问题。
主要由fs_spi.c文件与mid_fs.c文件连接两部分的代码，fs_spi.c初始化SPI Flash文件的硬件接口，按需要修改就行

/** 
* @file         midfs.c 
* @brief        provide file operations API for user,bridging the sfud and littleFS. 
* @details  	formate and mount the spi flash file system. 
* @author       ken deng 
* @date     	2019-01-07 
* @version  	A001 
* @par Copyright (c):  
* @par History:          
*   version: ken deng, 2019-01-07, create\n 
*/  

#include "string.h"
#include "mid_fs.h"
#include "system.h"
#include "sfud.h"
#include "fs_spi.h"

//#undef MID_FS_DEBUG

#ifdef MID_FS_DEBUG
    #define	midfs_log(...) do{if(DEBUG(DEBUG_ENABLE)){DBG_LOG("[MIDFS](%ld) ",__LINE__);DBG_LOG(__VA_ARGS__);}}while(0)
    #define midfs_usr(...) do{if(DEBUG(DEBUG_ENABLE)){DBG_LOG("[MIDFS] ");DBG_USR(__VA_ARGS__);}}while(0)
    #define midfs_err(...) do{if(DEBUG(DEBUG_ENABLE)){DBG_LOG("[MIDFS] ");DBG_ERR(__VA_ARGS__);}}while(0)
    #define midfs_dump(...) if(DEBUG(DEBUG_ENABLE)){DBG_DUMP(__VA_ARGS__);}
#else
    #define midfs_log(...)
    #define midfs_usr(...)
    #define midfs_err(...)
    #define midfs_dump(...)
#endif


static SemaphoreHandle_t    midfs_mutex;
static FS_TYPE_STRUCT 		mid_fs;
const sfud_flash *flash;	

/** 
* midfs lock mutex.
* none. 
* @param[in]   none.
* @param[out]  noen.
* @retval  none.
* @par TAG 
*      reserved 
* @par other 
*      none 
* @par modify
*      ken 2019-01-07 create
*/
void midfs_lock( void )
{
    xSemaphoreTake( midfs_mutex, portMAX_DELAY );
}

/** 
* midfs unlock mutex.
* none. 
* @param[in]   none.
* @param[out]  noen.
* @retval  none.
* @par TAG 
*      reserved 
* @par other 
*      none 
* @par modify
*      ken 2019-01-07 create
*/
void midfs_unlock( void )
{
    xSemaphoreGive( midfs_mutex );
}

/** 
* midfs mutex init.
* none. 
* @param[in]   none.
* @param[out]  noen.
* @retval  none.
* @par TAG 
*      reserved 
* @par other 
*      none 
* @par modify
*      ken 2019-01-07 create
*/
void midfs_lock_init( void )
{
    midfs_mutex = xSemaphoreCreateMutex();
}

/** 
* liffleFS call the sfud read port.
* none. 
* @param[in]   c:lfs_conifg struct , block:block address, off: address offset, buffer:read buffer, size:read size.
* @param[out]  noen.
* @retval  none.
* @par TAG 
*      reserved 
* @par other 
*      none 
* @par modify
*      ken 2019-01-07 create
*/
int32_t midfs_lfs_read( const struct lfs_config *c, lfs_block_t block,  lfs_off_t off, void *buffer, lfs_size_t size )
{
    uint32_t addr = FS_START_ADDR + c->block_size * block + off;
    sfud_read( flash, addr, size, buffer );
    return 0;
}

/** 
* liffleFS call the sfud write port.
* none. 
* @param[in]   c:lfs_conifg struct , block:block address, off: address offset, buffer:write buffer, size:write size.
* @param[out]  noen.
* @retval  none.
* @par TAG 
*      reserved 
* @par other 
*      none 
* @par modify
*      ken 2019-01-07 create
*/
static int32_t midfs_lfs_write( const struct lfs_config *c, lfs_block_t block, lfs_off_t off, const void *buffer,
                             lfs_size_t size )
{
    uint32_t addr = FS_START_ADDR +  c->block_size * block + off;
    sfud_write( flash, addr, size, buffer );
    return 0;
}

/** 
* liffleFS call the sfud erase port.
* none. 
* @param[in]   c:lfs_conifg struct , block:block address .
* @param[out]  noen.
* @retval  none.
* @par TAG 
*      reserved 
* @par other 
*      none 
* @par modify
*      ken 2019-01-07 create
*/
static int32_t midfs_lfs_erase( const struct lfs_config *c, lfs_block_t block )
{
    uint32_t addr = FS_START_ADDR +  c->block_size * block;
    sfud_erase( flash, addr, c->block_size );
    return 0;
}

/** 
* liffleFS call the sfud sync port.
* none. 
* @param[in]   c:lfs_conifg struct.
* @param[out]  noen.
* @retval  none.
* @par TAG 
*      reserved 
* @par other 
*      none 
* @par modify
*      ken 2019-01-07 create
*/
static int32_t midfs_lfs_sync( const struct lfs_config *c )
{
    return 0;
}

/** 
* search the dirctory tree.
* none. 
* @param[in]   lfs: lfs struct, path;path.
* @param[out]  noen.
* @retval  none.
* @par TAG 
*      reserved 
* @par other 
*      none 
* @par modify
*      ken 2019-01-07 create
*/
int midfs_lfs_ls( lfs_t *lfs, const char *path )
{
    lfs_dir_t dir;
    int err = lfs_dir_open( lfs, &dir, path );
    if( err )
    {
        return err;
    }
    struct lfs_info info;
    while( true )
    {
        int res = lfs_dir_read( lfs, &dir, &info );
        if( res < 0 )
        {
            return res;
        }
        if( res == 0 )
        {
            break;
        }
        midfs_log( "\t%s", info.name );
        switch( info.type )
        {
            case LFS_TYPE_REG:
                midfs_log( "\t\t%u Byte \r\n", info.size );
                break;
            case LFS_TYPE_DIR:
                midfs_log( "\t\t\tdir\r\n" );
                break;
            default:
                midfs_log( "?\r\n" );
                break;
        }
    }
    err = lfs_dir_close( lfs, &dir );
    if( err )
    {
        return err;
    }
    return 0;
}

const struct lfs_config lfs_cfg =
{
    // block device operations
    .read  = midfs_lfs_read,
    .prog  = midfs_lfs_write,
    .erase = midfs_lfs_erase,
    .sync  = midfs_lfs_sync,

    // block device configuration
    .read_size = 256,
    .prog_size = 256,
    .block_size = 4096,
    .block_count = LFSCFG_BLOCK_COUNT,
    .lookahead =  LFSCFG_LOOKAHEAD
};

/** 
* mount the file system.
* none. 
* @param[in]   none.
* @param[out]  noen.
* @retval  none.
* @par TAG 
*      reserved 
* @par other 
*      none 
* @par modify
*      ken 2019-01-07 create
*/
void midfs_mount( void )

{
    FILE_HANDLER fp;
    int err;
    //HAL_Delay(5000);
    err = lfs_mount( &mid_fs, &lfs_cfg );
    if( !err )
    {
        err = midfs_fopen( &fp, FNAME_MARK_LFS_FORMAT, "r" );
        midfs_fclose(&fp);
    }
    // reformat if we can't mount the filesystem
    // this should only happen on the first boot
//		err = 1;
    if( err )
    {
        if( err < 0 )
            lfs_unmount( &mid_fs );
        midfs_log( "LittleFS start Format!!\r\n" );
        lfs_format( &mid_fs, &lfs_cfg );
        err = lfs_mount( &mid_fs, &lfs_cfg );
        midfs_fopen( &fp, FNAME_MARK_LFS_FORMAT, "w" );
        midfs_fclose(&fp);
    }
    if( err )
        midfs_log( "LittleFS mounte Fail(%d)!!\r\n", err );
    else
        midfs_log( "LittleFS mounted\r\n" );
    //ls();
}


//void midfs_check( void )
//{
//    uint32_t total = 0, used = 0;
    SPIFFS_info( &mid_fs, &total, &used );
//    if( used > total )
//    {
//        //    SPIFFS_check( &fs );
//        //    SPIFFS_check( &fs );
//    }
//    midfs_usr( "midfs: used %d of %d Bytes\r\n", used, total );
//}

/** 
* print all the file infomation of root directory.
* none. 
* @param[in]   void.
* @param[out]  noen.
* @retval  none.
* @par TAG 
*      reserved 
* @par other 
*      none 
* @par modify
*      ken 2019-01-07 create
*/
void midfs_ls( void )
{
    midfs_log( "\r\nfiles on [\\]\r\n" );
    midfs_lock( );
    midfs_lfs_ls( &mid_fs,  "/" );
    midfs_unlock( );
    midfs_log( "\r\n\r\n" );
}

/** 
* open file.
* none. 
* @param[in]   fp:open file hander, path:path of the file, mode:read write mode.
* @param[out]  noen.
* @retval  >0:open file ok, <0:open file failed
* @par TAG 
*      reserved 
* @par other 
*      none 
* @par modify
*      ken 2019-01-07 create
*/
int midfs_fopen( FILE_HANDLER *fp, char *path, char *mode )
{
    int res = 0;
    uint32_t create = 0, modify = 0, state = 0;
    if( strstr( mode, "w" ) != 0 )
        create = 1;
    if( strstr( mode, "+" ) != 0 )
        modify = 1;
    if( create )
        state |= MIDFS_O_CREAT;
    if( modify )
        state |= MIDFS_O_MODIFY;
    if( state == 0 )
        state |= MIDFS_O_RDONLY;
#if (FS_USE_TYPE == FS_USE_SPIFFS)
    *fp = SPIFFS_open( &myfs.fs, path, state, 0 );
    if( *fp < 0 )
        res =  SPIFFS_errno( &myfs.fs );
#endif
#if (FS_USE_TYPE == FS_USE_LFS)
    midfs_lock();
    res = lfs_file_open( &mid_fs, fp, path, state );
    midfs_unlock();
    if( res )
        res = -1;
#endif
	midfs_log( "\nFOPEN(%s, %s) = %d\n", path, mode, res );
    return res;
}

/** 
* close file hander. 
* none. 
* @param[in]   fp:file hander.
* @param[out]  noen.
* @retval  read successful lenghth
* @par TAG 
*      reserved 
* @par other 
*      none 
* @par modify
*      ken 2019-01-07 create
*/
int midfs_fclose( FILE_HANDLER *fp )
{
    int res = 0;
    midfs_log( "\nFCLOSE(fp:%d)\n", *fp );
#if (FS_USE_TYPE == FS_USE_SPIFFS)
    res =  SPIFFS_close( &myfs.fs, *fp );
#endif
#if (FS_USE_TYPE == FS_USE_LFS)
    midfs_lock();
    res = lfs_file_close( &mid_fs, fp );
    midfs_unlock();
#endif
    return res;
}

/** 
* read data from file. 
* none. 
* @param[in]   fp:file hander, size: read len, dst:data source.
* @param[out]  noen.
* @retval  read successful lenghth
* @par TAG 
*      reserved 
* @par other 
*      none 
* @par modify
*      ken 2019-01-07 create
*/
uint32_t midfs_fread( FILE_HANDLER *fp, uint32_t size, void *dst )
{
    int ret = 0;
#if (FS_USE_TYPE == FS_USE_SPIFFS)
    ret = SPIFFS_read( &myfs.fs, *fp, dst, size );
#endif
#if (FS_USE_TYPE == FS_USE_LFS)
    midfs_lock();
    ret = lfs_file_read( &mid_fs, fp, dst, size );
    midfs_unlock();
#endif
	midfs_log( "\r\nFREAD(fp:%08x, %u) = %d b\r\n", fp, size, ret );
    return ret;
}

/** 
* write data to file. 
* none. 
* @param[in]   fp:file hander, size: write len, src:data source.
* @param[out]  noen.
* @retval  write successful lenghth
* @par TAG 
*      reserved 
* @par other 
*      none 
* @par modify
*      ken 2019-01-07 create
*/
uint32_t midfs_fwrite( FILE_HANDLER *fp, uint32_t size, void *src )
{
    uint32_t ret = 0;
#if (FS_USE_TYPE == FS_USE_SPIFFS)
    ret = SPIFFS_write( &myfs.fs, *fp, src, size );
#endif
#if (FS_USE_TYPE == FS_USE_LFS)
    midfs_lock();
    ret = lfs_file_write( &mid_fs, fp, src, size );
    midfs_unlock();
#endif
	midfs_log( "\nFWRITE(fp:%08x, %d) = %d\n", fp, size, ret );
    return ret;
}

/** 
* seek file position. 
* none. 
* @param[in]   fp:file hander, offset:offset, from: start position.
* @param[out]  noen.
* @retval  file position
* @par TAG 
*      reserved 
* @par other 
*      none 
* @par modify
*      ken 2019-01-07 create
*/
int32_t midfs_fseek( FILE_HANDLER *fp, uint32_t offset, uint32_t from )
{
    uint32_t p;
    switch( from )
    {
        case SEEK_SET:
            from = MIDFS_SEEK_SET;
            break;
        case SEEK_CUR:
            from = MIDFS_SEEK_CUR;
            break;
        case SEEK_END:
            from = MIDFS_SEEK_END;
            break;
        default:
            return -1;
    }
#if (FS_USE_TYPE == FS_USE_SPIFFS)
    p = SPIFFS_lseek( &myfs.fs, *fp, offset, from );
#endif
#if (FS_USE_TYPE == FS_USE_LFS)
    midfs_lock();
    p = lfs_file_seek( &mid_fs, fp, offset, from );
    midfs_unlock();
#endif
	midfs_log( "\nFSEEK(fp:%08x, %d, %d) = %d\n", fp, offset, from, p );
    return p;
}

/** 
* read file size. 
* read file size from SPI flash. 
* @param[in]   fp:file hander.
* @param[out]  noen.
* @retval  file size in byte
* @par TAG 
*      reserved 
* @par other 
*      none 
* @par modify
*      ken 2019-01-07 create
*/
uint32_t midfs_fsize( FILE_HANDLER *fp )
{
    uint32_t ret;
    ret = midfs_fseek( fp, 0, SEEK_END );
	midfs_log( "\nFSIZE(fp:%d) = %d\n", fp, ret );
    return ret;
}

/** 
* delete file. 
* delete file from SPI flash. 
* @param[in]   fname:file name string.
* @param[out]  noen.
* @retval  0 success, others failed
* @par TAG 
*      reserved 
* @par other 
*      none 
* @par modify
*      ken 2019-01-07 create
*/
int midfs_fremove( char *fname )
{
    int res = 0;
#if (FS_USE_TYPE == FS_USE_SPIFFS)
    res = SPIFFS_remove( &myfs.fs, fname );
#endif
#if (FS_USE_TYPE == FS_USE_LFS)
    midfs_lock();
    res = lfs_remove( &mid_fs, fname );
    midfs_unlock();
#endif
    return res;
}

/** 
* midfs initial. 
* if the spi flash file system had not formated, format it and mount. 
* @param[in]   fname:file name string.
* @param[out]  noen.
* @retval  0 success, others failed
* @par TAG 
*      reserved 
* @par other 
*      none 
* @par modify
*      ken 2019-01-07 create
*/
void mid_fs_init( void )
{
	fs_spi_init();
    if( sfud_init() == SFUD_SUCCESS )
    {
        flash = sfud_get_device_table() + 0;
#ifdef SPIFLASH_TEST
        sfud_test( 111, sizeof( sfud_test_buf ), sfud_test_buf );
#endif
        midfs_lock_init();
        midfs_mount();
//        midfs_check();
		
        midfs_ls();
        midfs_log( "MID FS init done!\r\n" );
    }
}

const struct lfs_config lfs_cfg 将sfud的操作接口影射到lifffs读写函数，重建midfs_open,midfs_close,midfs_read,midfs_write等用户操作函数，在多任务工作下，关键地方使用的互斥量
源码打包下载：https://download.csdn.net/download/dmjkun/10956215

纵向深耕
关注
  • 1
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
FreeRTOS笔记（一)简介
m0_58575472的博客
11-21 2147
操作系统是一个控制程序，负责协调分配计算资源和内存资源给不同的应用程序使用，并防止系统出现故障。操作系统通过一个调度算法和内存管理算法尽可能把资源公平且有效率地分配给不同的程序。应用程序通过调用操作系统提供的API接口获得相应资源完成指定的任务。任务（应用程序）的调度管理堆栈和内存管理文件管理队列管理中断和定时器管理资源管理输入输出管理。
STM32F429+SFUD+LittleFS实现文件系统文件读写
09-15
单片机使用正点原子的STM32F429核心板，移植了SFUD来驱动spiFlash，移植了LittleFS文件系统，实现官方的demo，每次main运行时更新一个名为boot_count的文件，程序可以在任何时候被中断，而不会丢失它已经启动了多少...
stm32f407_freertos_littlefs_sufd_25Q64_easylog_segger_rtt
03-28
https://github.com/ARMmbed/littlefs https://github.com/armink/SFUD https://github.com/armink/EasyLogger
LittleFs的移植和使用
热门推荐
LuoLuoSheShuiShe的博客
10-31 1万+
由于前段时间换了一个开发平台，而之前使用的平台的文件系统是Fats，但是明显感觉文件的写入速度比较慢，应该是内部默认是64Kflash擦除，在网上偶然看到关于littlefs的文章，所以此次将整个移植过程贴出来供大家参考。 1.移植过程参考 https://blog.csdn.net/skyfreedoms/article/details/5837067 https://blog.csdn.net...
littlefs性能分析终极完整版
最新发布
xuxuluo的博客
06-18 955
sysio（系统I/O）系统I/O通常指的是直接使用操作系统提供的系统调用来进行文件I/O操作。它提供了对文件描述符（file descriptors）的操作，这是Unix-like系统中的核心概念。系统I/O函数，如openreadwriteclose等，是底层I/O操作的基础，它们直接与内核交互。系统I/O通常比标准I/O更快，因为它减少了中间层，但它也要求程序员处理更多的细节，如错误处理和缓冲管理。stdio（标准I/O）标准I/O是C语言标准库提供的一组高级I/O函数，如fopen。
FreeRTOS 学习小记
qq_34152804的博客
11-10 121
FreeConfig.h配置文件详解
初学littlefs文件系统
weixin_45270358的博客
12-14 8480
一个为微控制器设计的小故障安全文件系统。掉电恢复能力: 设计用于处理随机电源故障。所有文件操作都有很强的写时拷贝保证，如果断电，文件系统将恢复到上一次已知的良好状态。动态磨损均衡: 设计考虑到闪存，并提供动态块磨损均衡。此外，littlefs可以检测坏块并在它们周围工作。有限RAM/ROM: 被设计为使用少量内存。RAM的使用是严格限制的，这意味着RAM的使用不会随着文件系统的增长而改变。文件系统不包含无界递归，动态内存仅限于可静态提供的可配置缓冲区。
minIni移植到littlefs
欲盖弥彰1314
06-10 636
minIni 是一个用于读取和写入 INI 文件的库。 github : https://github.com/compuphase/minIniminIni特点：1、minIni 大约是 950 行代码 (包括注释)，是一个真正的 “迷你” INI 文件解析器，非常容易移植到各种嵌入式平台。2、minIni 不需要标准 C/C++ 库中的 文件 I/O 函数，且允许通过宏配置要选择文件 I/O 接口。3、minIni 仅使用 stack ，完全不使用动态内存（malloc）。有 C++ binding,
基于STM32F103的Littlefs文件系统移植
xiashui3350的博客
10-29 4685
移植平台: 正点原子STM32F1精英版V1.41 MCU：STM32F103ZET6 SPI Falsh:W25Q128 LittleFS是ARM mbedOS的官方推荐文件系统，具有轻量级，掉电安全的特性。 参考文档 CSDN LittleFS博客 GitHub开源项目-LittleFS 文件系统移植 首先去Github上下载最新发型版本的LittleFs源码,我下载的是V2.2.1版本，并阅读README文档了解移植详情，因为README.md文档讲解很有限，所以下面会在移植过程中做出补充。在.
LittleFS文件系统移植和使用记录
weixin_43908815的博客
04-25 7298
在使用单片机设计的系统中经常使用价格低廉的存储方案为SPI FLASH（W25Qxx），在单片机中使用最多的文件系统为FatFS，但对于W25Qxx存储芯片来说FatFS并不是一个好的方案，原因如下：1、FatFS不支持擦写均衡，LittleFS支持，Flash扇区有擦写寿命，如果一直擦写一个扇区会很快将一个扇区擦写坏。2、FatFS不支持掉电保存功能，LittleFS支持，如果在写入数据时掉电虽然不会保存本次写入的数据但也不会丢失上次写入之前的数据。
文件系统移植TX2440A
04-10
Yaffs2（Yet Another Flash File System 2）是一种用于闪存设备上的文件系统，特别适用于嵌入式系统。它支持断电保护和磨损均衡等特性，能够有效地管理NAND闪存。 **移植步骤** 1. **下载源码** 首先从官方网址...
spiffs_littlefs_fatfs_easyflash.rar
03-11
这个压缩包"spiffs_littlefs_fatfs_easyflash.rar"包含了四个主要的文件系统实现，分别是SPIFFS、LittleFS、FATFS和EasyFlash。下面将对这些文件系统进行详细介绍。 1. SPIFFS (SPI Flash File System) SPIFFS是专...
GD32F450，含文件系统fatfs，操作系统FreeRTOS
12-27
5. **ff14b版本**：针对FreeRTOS优化的FAT文件系统实现，确保在实时环境下稳定高效地读写文件。 这些技术结合在一起，构建了一个能够执行文件操作和实时任务的嵌入式系统，常见于需要进行数据存储和处理的智能设备...
STM32 SPI flash 驱动程序，包括自动擦除写入接口 支持HAL，FreeRtos下使用
09-07
STM32 SPI Flash驱动程序是用于与SPI接口的闪存芯片进行通信的软件模块，这里主要涉及的是W25Q系列的SPI Flash，如W25Q64、W25Q128和W25Q256等。这些芯片广泛应用于嵌入式系统中，作为存储数据或程序的非易失性...
FreeRTOS源码阅读笔记-1-FreeRTOS简介
weixin_47564449的博客
07-04 713
FreeRTOS源码阅读笔记
STM32H7B0VBT6使用Free RTOS配置SD卡+Fatfs文件管理系统
Jack的小窝
05-26 3615
STM32H7B0VBT6使用Free RTOS配置SD卡+Fatfs文件管理系统，记录配置过程
MM32F3273G8P火龙果开发板MindSDK开发教程19 - littlefs文件系统的移植
weixin_43932857的博客
06-14 813
LittleFS 由ARM官方发布，ARM mbedOS的官方推荐文件系统，具有轻量级，掉电安全的特性。主要用在微控制器和flash上，特点如下：掉电恢复，在写入时即使复位或者掉电也可以恢复到上一个正确的状态。擦写均衡，有效延长flash的使用寿命。例如W25QXX系列的spi接口的flash，擦写次数大概在10万次，如果是操作flash比较频繁那么这10万次很快就会到达上限从而导致芯片废掉。有限的RAM/ROM，相对于FATFS节省ROM和RAM空间。
文件操作中file.seek()方法
weixin_30784501的博客
12-29 2644
摘要： file.seek()可以将文件游标移动到文件的任意位置，本文具体的file.seek()文件游标移动操作方法、 file.seek()方法标准格式是：seek(offset,whence=0) offset：开始偏移量，也就是代表需要移动偏移的字节数。 whence：给offset参数一个定义，表示要从哪个位置开始偏移；0代表从文件开头开始算起，1代表从当前位置开始算起，...
littlefs系列：重要的数据结构
nstcl的博客
03-15 4110
1、文件类型 // File types enum lfs_type { // file types LFS_TYPE_REG = 0x001, LFS_TYPE_DIR = 0x002, // internally used types LFS_TYPE_SPLICE = 0x400, ...
freertos文件系统组件
08-24
FreeRTOS文件系统组件是一个开源的嵌入式文件系统，用于在嵌入式系统中管理文件和目录。它提供了一组API，可以方便地进行文件的创建、删除、打开、关闭、读取和写入操作。 FreeRTOS文件系统组件可以在多种存储设备上使用，包括RAM、ROM、NAND Flash、NOR Flash等。它采用了模块化设计和轻量级的实现，旨在尽可能地减少资源开销。因此，在资源有限的嵌入式设备上，使用FreeRTOS文件系统组件可以实现高效的文件管理。 FreeRTOS文件系统组件支持文件和目录的层次结构，可以创建多级目录，并在目录下创建、读取和写入文件。它还提供了文件权限控制的功能，可以限制对某些文件或目录的访问权限。 FreeRTOS文件系统组件还支持文件的缓存和异步操作。通过合理地管理文件缓存，可以提高文件的读写性能。而异步操作允许在进行文件操作时，同时执行其他任务，提高系统的并发性和响应能力。 总之，FreeRTOS文件系统组件是一个功能强大、灵活可扩展的嵌入式文件系统，可以帮助开发者在嵌入式系统中进行有效的文件管理。无论是小型的嵌入式系统还是大型的嵌入式应用，都可以使用FreeRTOS文件系统组件实现文件的读写和管理。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

纵向深耕

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值