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系统静态与动态建立任务
wangjie36的博客
11-25 2444
一，静态建立任务 1，定义任务函数（一个无限循环且不带返回值的函数） 任务必须是死循环，否则任务将经过 LR 返回，如果 LR 指向了非法内存就会产生HardFault_Handler，而 FreeRTOS 指向一个死循环，那么任务返回以后就在死循环中执行，这样子的任务是不安全的。编程因此避免这种状况，任务通常都是死循环而且无返回值的。若是任务，执行一次以后就进行删除，则不影响系统运行，所以，只执行一次的任务在执行完毕要记得及时删除。数组任务里面的延时函数必须使用 FreeRTOS 里面提供...
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 961
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配置文件详解
立创梁山派--移植开源的SFUD万能的串行 Flash 通用驱动库
最新发布
m0_63472758的博客
07-22 1354
关于SFUD库的介绍，其开源链接()已经详细的阐述了.这里是截取自它的一部分介绍：SFUD 是一款开源的串行 SPI Flash 通用驱动库。由于现有市面的串行 Flash 种类居多，各个 Flash 的规格及命令存在差异， SFUD 就是为了解决这些 Flash 的差异现状而设计，让我们的产品能够支持不同品牌及规格的 Flash，提高了涉及到 Flash 功能的软件的可重用性及可扩展性，同时也可以规避 Flash 缺货或停产给产品所带来的风险。
FreeRTOS-系统配置与裁剪
咸鱼很渴的博客
08-22 3674
FreeRTOS-系统配置与裁剪 在使用FreeRTOS的时候，我们可以根据自己的需要来配置和裁剪FreeRTOS。我们在FreeRTOSConfig.h文件中完成对FreeRTOS系统的裁剪，通过裁剪来减少系统占用RAM和ROM的大小。所谓裁剪其实就是对FreeRTOS中的函数和一些变量、结构体等选择性的定义。 FreeRTOS裁剪原理 FreeRTOS裁剪主要就是用到了条件编译的方法，其实不仅仅是FreeRTOS是这样，很多RTOS系统都是采用这样的方法。所谓条件编译就是当该部分满足条件的时候
STM32F407移植Little vGL系统，freeRTOS系统，FATFS文件系统
mygod2008ok的专栏
04-09 1万+
准备freeRTOS源码和一个简单的工程 链接：https://pan.baidu.com/s/1hgyQqoDqDuETEHr_I80M8Q 提取码：e890 另外还需要准备一个简单的工程，这里使用一个空工程来完成移植 已移植好的stm32f103ve例程下载链接： 开始移植 在led闪烁工程中新建一个文件夹，并命名为freeRTOS 2.将准备好的freeRTOS...
FreeRTOS实时操作系统（一）RTOS、堆栈的基本概念、map文件解析
贾saisai的博客
06-16 3048
最近买了把75系列的机械键盘，没有数字区域，想起来稚辉君曾经做过一把客制化键盘，于是下载了资料准备学一学，网上很多开源的都是用的ATMEGA32U4制作的，稚辉君用stm32f103cbtx就做出来了，让我很佩服，打开资料后发现软件部分涉及到了操作系统，于是打算学一下FreeRTOS。大部分还是参考正点原子的教程，本篇只是一些基本概念，无具体代码内容学习免费的实时操作系统（Real-time operating system for microcontrollers）
Arduino运行FreeRTOS操作系统
Tonyの博客
04-24 1万+
当Arduino遇上FreeRTOS实时操作系统
STM32F429+SFUD+LittleFS实现文件系统文件读写
09-15
单片机使用正点原子的STM32F429核心板，移植了SFUD来驱动spiFlash，移植了LittleFS文件系统，实现官方的demo，每次main运行时更新一个名为boot_count的文件，程序可以在任何时候被中断，而不会丢失它已经启动了多少...
文件系统移植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等。这些芯片广泛应用于嵌入式系统中，作为存储数据或程序的非易失性...
RT-Thread记录（十六、SFUD组件 — SPI Flash的读写）
不浮夸，不将就，认真对待学知识的我们
06-05 2376
从刚学完的 SPI 设备开始，测试学习一些 RT-Thread 常用的组件与软件包。
移植FreeModbus到FreeRTOS系统上
开发学习过程中一点经验积累
01-01 7235
实测连接西门子的组态屏运行正常 1、串口驱动移植 portserial.c BOOL xMBPortSerialInit(UCHAR ucPORT, ULONG ulBaudRate, UCHAR ucDataBits, eMBParity eParity) { modubs_user_usart_init(); __HAL_UART_DISABLE( &amp;amp;huart...
FreeRTOS命令行接口CLI移植
开发学习过程中一点经验积累
01-06 7145
主要包含4个源文件，FreeRTOS_CLK.c、Sample-CLI-command.c、uart_console.c、console_user.c，FreeRTOS_CLK.c、Sample-CLI-command.c不用修改修改直接包含进工程，Sample-CLI-command.c为使用命令行的打印任务状态及向命令操作传感2个或3个参数的示例。 uart_console.c为命令行接口的串...
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、付费专栏及课程。

余额充值