【嵌入式】基于FATFS/Littlefs文件系统的日志框架实现

最新推荐文章于 2023-11-06 17:38:08 发布
最新推荐文章于 2023-11-06 17:38:08 发布
阅读量918 收藏 9
点赞数 3
分类专栏： 文件系统 # SD Nand 与 SD卡 文章标签： 日志 log4j FATFS littlefs 文件系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43332314/article/details/131777068
版权

【嵌入式】基于FATFS/Littlefs文件系统的日志框架实现

文章目录

1. 概述

在本人之前的博客中分享了如何移植文件系统，以及关于 FAT文件系统 设计的详细解析，相关文章可跳转至本人文件系统专栏查看： [ 文件系统专栏 ~ 点击跳转 ~ ]

那么在移植好了文件系统之后，我们又应该如何应用文件系统呢？

很多人会说，这个简单，就操作文件嘛！open、read、write、close不就行了吗！当然对于简单的使用，掌握open、read、write、close，去存储一两个文件或者从一两个文件中简单的读取下数据这确实没有什么难度。但在实际应用中，特别是产品开发过程中，往往不只是简单的操作一两个文件就可以的，如果真是这样，那费那么大劲移植文件系统多少有点浪费！

在实际项目开发中，往往需要依托文件系统操作诸多的文件，操作诸多的数据。如通过配置文件配置机器设备信息、通过升级文件进行产品升级、通过存放字库文件实现多语言支持等等，这些都是比较简单的操作，读写不是很频繁，相对来说实现比较简单，还有一类需求读写会相当频繁，且大多数产品内都希望存在的，那便是日志文件，通过日志文件来记录设备的运行数据。日志文件不同于其他功能，其往往需要具备几个基本特性需求：

  • 单个文件大小限制
  • 日志总大小空间占用限制
  • 自动循环覆盖

网上也有一些开源的日志框架，如 Log4j，不过大都是基于 java / c ++ 实现的，虽然功能比较全面，但比较繁杂，且也难以移植应用于嵌入式开发中。而在嵌入式开发中，可能也受限于资源限制，并没有发现不错的基于文件系统的开源日志框架（至少博主目前没有发现，有的话欢迎大家评论区讨论 😄），对于如何实现一个日志框架很多人一下子可能没有头绪，综上，本文将分享一个简单的基于文件系统的日志程序以供大家思考。

2. 设计概要

我们需要实现的日志模块的核心需求为：

  • 单个文件大小限制
  • 日志总大小空间占用限制
  • 自动循环覆盖

对于一个模块，对外仅需提供其操作的接口即可，内部的算法实现均无需对外开放，而对于此日志模块，对外只需提供基本的以下四个接口即可：

  1. 初始化 init
  2. 写日志 write
  3. 读日志 read
  4. 注销 deinit

关于日志存储的核心思想如下：

写数据之前先判断当前操作的文件是否超出单个文件大小限制，如超出大小限制则进行日志轮转，创建一个新的日志文件并判断日志文件总大小是否超出限制，如果超出则删除最早的那一份日志文件

关于日志存储的详细设计如下：

日志文件格式采用：<filename>.log ，当当前文件达到单个文件大小之后，进行文件轮转；

假定当前限制日志每个日志文件大小为2048Byte，最多存储10个文件；

当当前文件达到单个文件大小之后，迭代修改日志文件名：

  • <filename>.log -> <filename>.log.0
  • <filename>.log.0 -> <filename>.log.1
  • <filename>.log.1 -> <filename>.log.2
  • …
  • <filename>.log.8 -> <filename>.log.9
  • 删除 <filename>.log.9

ps:注意实际代码操作的时候，文件修改顺序是反过来的，也就是先 删除 <filename>.log.9 再将<filename>.log.8 -> <filename>.log.9

3. 设计实现

3.1 初始化 init

初始化部分代码主要功能是完成日志数据结构体的构造，并通过传入参数 log_file_cfg_t cfg 配置日志文件的配置信息，如单个日志文件大小、日志文件名、最多存放的日志文件数等内容，日志模块初始化部分代码如下：

log_file_t log_storage_init(log_file_cfg_t cfg)
{
    log_file_t log = NULL;
    log_file_cfg_t log_cfg = NULL;
    log_file_read_t log_read = NULL;

    log = (log_file_t)malloc(sizeof(struct log_file_config));
    if (log == NULL)
        goto error;
    
    log_cfg = (log_file_cfg_t)malloc(sizeof(struct log_file_config));
    if (log_cfg == NULL) {
        free(log);
        log = NULL;
        goto error;
    }

    log_read = (log_file_read_t)malloc(sizeof(struct log_file_read));
    if (log_read == NULL) {
        free(log);
        log = NULL;
        free(log_cfg);
        log_cfg = NULL;
        goto error;
    }

    memcpy(log_cfg, cfg, sizeof(struct log_file_config));
    log_read->rotate_index = 0;
    log_read->file_offset = 0;
    
    log->cfg = log_cfg;
    log->read = log_read;
    log->user_data = NULL;

error:
    return log;
}

3.2 日志写入 write

日志写入部分代码主要分为两大部分，一部分是正常写入，另一部分是文件轮转；当写入的文件超过单个文件大小限制时，即会触发文件轮转操作。

在文件轮转中，主要做的是：创建一个新的日志文件并判断日志文件总大小是否超出限制，如果超出则删除最早的那一份日志文件，具体设计细节可参考上文设计概要中的详细设计部分。

实现代码如下：

static int log_rotate(log_file_t log)
{
    int ret = 0;
    FILE *fp;
    char old_filename[NAME_MAX + 10] = {0};
    char new_filename[NAME_MAX + 10] = {0};

    for (int i = log->cfg->rotate_num; i > 0; i --) {
        memset(old_filename, 0, sizeof(old_filename));
        memset(new_filename, 0, sizeof(new_filename));

        snprintf(old_filename, sizeof(old_filename), i ? "%s_%d.log" : "%s.log", log->cfg->filename, i - 1);
        snprintf(new_filename, sizeof(new_filename), "%s_%d.log", log->cfg->filename, i);

        printf("old:%s new:%s\n", old_filename, new_filename);
        
        if ((fp = fopen(new_filename, "r")) != NULL) {
            if (fclose(fp) != 0) {
                ret = -1;
                goto error;
            }
            if (remove(new_filename) != 0) {
                ret = -2;
                goto error;
            }
        }

        if ((fp = fopen(old_filename, "r")) != NULL) {
            if (fclose(fp) != 0) {
                ret = -1;
                goto error;
            }
            if (rename(old_filename, new_filename) != 0) {
                ret = -3;
                goto error;
            }
        }
    }

error:
    return ret;
}

int log_storage_write(log_file_t log, const unsigned char *buf, unsigned int len)
{
    int ret = 0;
    int file_size = 0;
    char full_filename[NAME_MAX + 5] = {0};
    FILE *fp = NULL;

    if (log == NULL || log->cfg == NULL || log->read == NULL || buf == NULL || len == 0) {
        ret = -1;
        goto param_error;
    }

    snprintf(full_filename, sizeof(full_filename), "%s.log", log->cfg->filename);
    
    printf("fullfilename:%s\n", full_filename);
    log_file_lock();

    fp = fopen(full_filename, "a+b");
    if (fp == NULL) {
        ret = -2;
        goto error;
    }

    fseek(fp, 0L, SEEK_END);
    file_size = ftell(fp);
    printf("file_size:%d\n", file_size);
    if ((file_size + len) > log->cfg->max_size) {
        if (fclose(fp) != 0) {
            ret = -3;
            goto error;
        }

        int j = 0;
        j = log_rotate(log);
        printf("log rotate:%d\n", j);
        fp = fopen(full_filename, "a+b");
        if (fp == NULL) {
            ret = -2;
            goto error;
        }
    }

    if (fwrite(buf, len, 1, fp) != 1) {
        fclose(fp);
        ret = -4;
        goto error;
    }

error:
	if (fp != NULL) {
		if (fclose(fp) != 0) {
			ret = -3;
			goto error;
		}
	}
    log_file_unlock();
param_error:
    return ret;
}

3.3 日志读取 read

此处日志读取在本文主题中非重点设计内容，因此此处做简单设计，通过传入参数判断应该读取哪一份文件之后进行直接读取。设计代码如下：

int log_storage_read(log_file_t log, unsigned int rotate_num, unsigned char *buf, unsigned int *len)
{
    int ret = 0;
    int file_size = 0;
    char full_filename[NAME_MAX + 5] = {0};
    FILE *fp = NULL;

    if (log == NULL || log->cfg == NULL || log->read == NULL || buf == NULL || len == 0) {
        ret = -1;
        goto param_error;
    }

    if (rotate_num == 0)
        snprintf(full_filename, sizeof(full_filename), "%s.log", log->cfg->filename);
    else
        snprintf(full_filename, sizeof(full_filename), "%s.log.%d", log->cfg->filename, rotate_num);

    log_file_lock();

    fp = fopen(full_filename, "a+b");
    if (fp == NULL) {
        ret = -2;
        goto error;
    }
    /* check file length. */
    fseek(fp, 0L, SEEK_END);
    file_size = ftell(fp);
    printf("file_size:%d\n", file_size);
    if (file_size < *len)
        *len = file_size;

    fseek(fp, 0L, SEEK_SET);
    if (fread(buf, *len, 1, fp) != 1) {
        ret = -3;
        fclose(fp);
        goto error;
    }

error:
	if (fp != NULL) {
		if (fclose(fp) != 0) {
			ret = -4;
			goto error;
		}
	}
    log_file_unlock();
param_error:
    return ret;
}

3.4 注销 deinit

注销的主要功能是将我们在 init 时创建的数据结构进行回收，如果模块内部有功能处于打开装填，也应关闭模块的功能，此处我们仅需对 init 时创建的 log_file_t log 数据结构体进行注销、内存回收即可，具体代码实现如下：

int log_storage_deinit(log_file_t log)
{
	if (log == NULL)
		return -1;
	
	if (log->cfg != NULL)
		free(log->cfg);
	if (log->read != NULL)
		free(log->read);
	if (log->user_data != NULL)
		free(log->user_data);
	free(log);
	return 0;
}

3.5 全部代码汇总

日志模块内核头文件：simple_storage.h

#ifndef __SIMPLE_STORAGE_H__
#define __SIMPLE_STORAGE_H__

#define NAME_MAX        40

struct log_file_config {
    const char filename[NAME_MAX];     /* Filename of this type. */
    int max_size;       /* single file max size. */
    int rotate_num;     /* The number of files that support rotate. */
};
typedef struct log_file_config* log_file_cfg_t;

struct log_file_read {
    int rotate_index;   /* The rotate file index. */
    int file_offset;    /* The offset of the currently read file. */
};
typedef struct log_file_read* log_file_read_t;

struct log_file {
    log_file_cfg_t cfg;
    log_file_read_t read;
    void *user_data;
};
typedef struct log_file* log_file_t;


log_file_t log_storage_init(log_file_cfg_t cfg);
int log_storage_write(log_file_t log, const unsigned char *buf, unsigned int len);
int log_storage_read(log_file_t log, unsigned int rotate_num, unsigned char *buf, unsigned int *len);
int log_storage_deinit(log_file_t log);


#endif /* __SIMPLE_STORAGE_H__ */

日志模块内核文件： simple_storage.c

#include "simple_storage.h"
#include "simple_storage_port.h"
#include <stdio.h>
#include <string.h>

log_file_t log_storage_init(log_file_cfg_t cfg)
{
    log_file_t log = NULL;
    log_file_cfg_t log_cfg = NULL;
    log_file_read_t log_read = NULL;

    log = (log_file_t)malloc(sizeof(struct log_file_config));
    if (log == NULL)
        goto error;
    
    log_cfg = (log_file_cfg_t)malloc(sizeof(struct log_file_config));
    if (log_cfg == NULL) {
        free(log);
        log = NULL;
        goto error;
    }

    log_read = (log_file_read_t)malloc(sizeof(struct log_file_read));
    if (log_read == NULL) {
        free(log);
        log = NULL;
        free(log_cfg);
        log_cfg = NULL;
        goto error;
    }

    memcpy(log_cfg, cfg, sizeof(struct log_file_config));
    log_read->rotate_index = 0;
    log_read->file_offset = 0;
    
    log->cfg = log_cfg;
    log->read = log_read;
    log->user_data = NULL;

error:
    return log;
}

static int log_rotate(log_file_t log)
{
    int ret = 0;
    FILE *fp;
    char old_filename[NAME_MAX + 10] = {0};
    char new_filename[NAME_MAX + 10] = {0};

    for (int i = log->cfg->rotate_num; i > 0; i --) {
        memset(old_filename, 0, sizeof(old_filename));
        memset(new_filename, 0, sizeof(new_filename));

        snprintf(old_filename, sizeof(old_filename), i ? "%s_%d.log" : "%s.log", log->cfg->filename, i - 1);
        snprintf(new_filename, sizeof(new_filename), "%s_%d.log", log->cfg->filename, i);

        printf("old:%s new:%s\n", old_filename, new_filename);
        
        if ((fp = fopen(new_filename, "r")) != NULL) {
            if (fclose(fp) != 0) {
                ret = -1;
                goto error;
            }
            if (remove(new_filename) != 0) {
                ret = -2;
                goto error;
            }
        }

        if ((fp = fopen(old_filename, "r")) != NULL) {
            if (fclose(fp) != 0) {
                ret = -1;
                goto error;
            }
            if (rename(old_filename, new_filename) != 0) {
                ret = -3;
                goto error;
            }
        }
    }

error:
    return ret;
}

int log_storage_write(log_file_t log, const unsigned char *buf, unsigned int len)
{
    int ret = 0;
    int file_size = 0;
    char full_filename[NAME_MAX + 5] = {0};
    FILE *fp = NULL;

    if (log == NULL || log->cfg == NULL || log->read == NULL || buf == NULL || len == 0) {
        ret = -1;
        goto param_error;
    }

    snprintf(full_filename, sizeof(full_filename), "%s.log", log->cfg->filename);
    
    printf("fullfilename:%s\n", full_filename);
    log_file_lock();

    fp = fopen(full_filename, "a+b");
    if (fp == NULL) {
        ret = -2;
        goto error;
    }

    fseek(fp, 0L, SEEK_END);
    file_size = ftell(fp);
    printf("file_size:%d\n", file_size);
    if ((file_size + len) > log->cfg->max_size) {
        if (fclose(fp) != 0) {
            ret = -3;
            goto error;
        }

        int j = 0;
        j = log_rotate(log);
        printf("log rotate:%d\n", j);
        fp = fopen(full_filename, "a+b");
        if (fp == NULL) {
            ret = -2;
            goto error;
        }
    }

    if (fwrite(buf, len, 1, fp) != 1) {
        fclose(fp);
        ret = -4;
        goto error;
    }

error:
	if (fp != NULL) {
		if (fclose(fp) != 0) {
			//TODO: check the amount of disk space, delete if there is not enough space.
			ret = -3;
			goto error;
		}
	}
    log_file_unlock();
param_error:
    return ret;
}

int log_storage_read(log_file_t log, unsigned int rotate_num, unsigned char *buf, unsigned int *len)
{
    int ret = 0;
    int file_size = 0;
    char full_filename[NAME_MAX + 5] = {0};
    FILE *fp = NULL;

    if (log == NULL || log->cfg == NULL || log->read == NULL || buf == NULL || len == 0) {
        ret = -1;
        goto param_error;
    }

    if (rotate_num == 0)
        snprintf(full_filename, sizeof(full_filename), "%s.log", log->cfg->filename);
    else
        snprintf(full_filename, sizeof(full_filename), "%s.log.%d", log->cfg->filename, rotate_num);

    log_file_lock();

    fp = fopen(full_filename, "a+b");
    if (fp == NULL) {
        ret = -2;
        goto error;
    }
    /* check file length. */
    fseek(fp, 0L, SEEK_END);
    file_size = ftell(fp);
    printf("file_size:%d\n", file_size);
    if (file_size < *len)
        *len = file_size;

    fseek(fp, 0L, SEEK_SET);
    if (fread(buf, *len, 1, fp) != 1) {
        ret = -3;
        fclose(fp);
        goto error;
    }

error:
	if (fp != NULL) {
		if (fclose(fp) != 0) {
			ret = -4;
			goto error;
		}
	}
    log_file_unlock();
param_error:
    return ret;
}

int log_storage_deinit(log_file_t log)
{
	if (log == NULL)
		return -1;
	
	if (log->cfg != NULL)
		free(log->cfg);
	if (log->read != NULL)
		free(log->read);
	if (log->user_data != NULL)
		free(log->user_data);
	free(log);
	return 0;
}

在日志模块源文件的代码中，我们可以看到实际每次操作文件的时候，都有调用一个函数锁操作，考虑到不同平台的锁操作实现不一样，因此将此部分通过函数导出来，放置在模块的端口文件中。不同的平台、系统根据各自的平台和系统的情况进行实现，如像裸机编程这类不需要进行锁操作的不进行函数实现即可。

日志模块端口头文件：simple_storage_port.c

#ifndef __SIMPLE_STORAGE_PORT_H__
#define __SIMPLE_STORAGE_PORT_H__

int log_file_init(void);
int log_file_lock(void);
int log_file_unlock(void);


#endif /* __SIMPLE_STORAGE_PORT_H__ */

日志模块端口源文件：simple_storage_port.h

#include "simple_storage_port.h"

int log_file_init(void)
{
    return 0;
}

int log_file_lock(void)
{
    return 0;
}

int log_file_unlock(void)
{
    return 0;
}

4. 测试

将以上代码进行运行测试，硬件平台如下：

控制器： stm32f103vet6，野火指南者开发板

存储芯片： CS创世 SD nand，型号：CSNP4GCR01-AMW

文件系统： FATFS，注意此日志不受文件系统限制

操作系统： RT-Thread，此模块与操作系统无关，此处只是方便使用故自行移植了rtthread

在这里插入图片描述

应用层代码如下：

int main(void)
{
	/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
	HAL_Init();
	
	/* USER CODE BEGIN Init */
	
	/* USER CODE END Init */
	
	/* Configure the system clock */
	SystemClock_Config();
	
	/* USER CODE BEGIN SysInit */
	
	/* USER CODE END SysInit */
	
	/* Initialize all configured peripherals */
	MX_GPIO_Init();
	MX_SDIO_SD_Init();
	MX_USART1_UART_Init();
	MX_FATFS_Init();
	
	/* USER CODE BEGIN 2 */
	struct log_file_config log_cfg = {
		.filename = "test",
		.max_size = 2048,
		.rotate_num = 10,
	};
	log_file_t log = NULL;
	log = log_storage_init(&log_cfg);
	if (log == NULL)
		return;
	/* USER CODE END 2 */
	
	/* Infinite loop */
	/* USER CODE BEGIN WHILE */
	unsigned char buf[2048] = {0};
	int len = 0;
	while (1) {
		// ... 省略用户代码
		/* 写入测试 */
		for (int i = 0; i < 2048; i++) {
			log_storage_write(log, "hello world", sizeof("hello world"));
			rt_thread_mdelay(100);
		}
		
		/* 读取测试 */
		len = sizeof(buf);
		memset(buf, 0, sizeof(buf));
		log_storage_read(log, 1, buf, &len);
		for (int i = 0; i < len; i ++)
			rt_kprintf("%c", buf[i]);
		rt_thread_mdelay(1000);
	}
}

测试结果如下：

msg> hello worldhello world hello world hello world hello world hello world hello world hello world hello world ...省略

msh > ls
test.log	   2046
test.log.0     2046
test.log.1     2046
test.log.2     2046
test.log.3     2046
test.log.4     2046

5. 总结

综上便是基于文件系统的简易日志模块设计的全部内容了，虽然简陋了点，但相信对于大部分没有接触过日志系统设计的人来说提供了很好的一条设计思路。

也正因为简易，给大家对于日志系统设计的优化留足了大量的优化空间。比如：

  1. 文件轮转的时候需要对每个文件的文件名进行修改，是否可以有更好的方式不用每个文件都修改呢？
  2. 文件名的设计是不方便阅读的，是否可以引入时间参数？
  3. 文件名设计如何引入了时间参数，当设备RTC备用电池掉电的时候又如何保证文件不会被错误覆盖？
  4. 文件的读取显然优化空间更大，实际上用户不应该传入rotate_num 参数，因为这是模块内部的参数，用户不可感知的
  5. 文件读取如何做到分多次读取一个文件的内容，且不会重复，是顺序读取？

等等，以上只是我简单想到的几点内容，大家不妨思考下如何实现方案更好呢？当然又还有哪些需求是需要引入的呢，也欢迎大家在评论区留言，关注我，后续抽时间再分享下改良版日志系统！！！

创作不易，转载请注明出处！

关注、点赞+收藏，可快速查收博主有关分享！

6. 相关文章推荐

爱出名的狗腿子
关注
  • 3
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
FatFs文件系统中文资料
12-08
FatFS 是一个为小型嵌入式系统设计的通用FAT(File Allocation Table)文件系统模块。FatFs 的编写遵循ANSI C，并且完全 与磁盘I/O 层分开。因此，它独立(不依赖)于硬件架构。它可以被嵌入到低成本的微控制器中，如AVR, 8051, PIC, ARM, Z80, 68K 等等，而不需要做任何修改
spiffs_littlefs_fatfs_easyflash.rar
03-11
文件系统源码包
初学littlefs文件系统
weixin_45270358的博客
12-14 6822
一个为微控制器设计的小故障安全文件系统。掉电恢复能力: 设计用于处理随机电源故障。所有文件操作都有很强的写时拷贝保证，如果断电，文件系统将恢复到上一次已知的良好状态。动态磨损均衡: 设计考虑到闪存，并提供动态块磨损均衡。此外，littlefs可以检测坏块并在它们周围工作。有限RAM/ROM: 被设计为使用少量内存。RAM的使用是严格限制的，这意味着RAM的使用不会随着文件系统的增长而改变。文件系统不包含无界递归，动态内存仅限于可静态提供的可配置缓冲区。
LittleFS：一个完整的嵌入式文件系统介绍、移植使用教程
^_^
09-15 2万+
LittleFS - 一个高度完整的嵌入式文件系统、移植使用教程 1、介绍 源码下载地址：https://github.com/littlefs-project/littlefs/tags 截止2021年9月15日10:21:17，最新版本为2.4.1，当前移植使用教程基于2.4.1版本为例。 LittleFS 由ARM官方发布，ARM mbedOS的官方推荐文件系统，具有轻量级，掉电安全的特性。主要用在微控制器和flash上，特点如下： 掉电恢复，在写入时即使复位或者掉电也可以恢复到上一个正确的状态。
FATFS记录
madao1234的博客
03-18 512
1、基本概念 FATFS是一个完全免费开源的FAT文件系统模块，专门为小型的嵌入式系统而设计。完全用标准C语言编写。 2、FATFS的层次结构
STM32F429+SFUD+LittleFS实现文件系统文件读写
09-15
单片机使用正点原子的STM32F429核心板，移植了SFUD来驱动spiFlash，移植了LittleFS文件系统，实现官方的demo，每次main运行时更新一个名为boot_count的文件，程序可以在任何时候被中断，而不会丢失它已经启动了多少次的跟踪，也不会损坏文件系统。
小型文件系统FatFS和LittleFS对比和区别
strongerHuang
04-26 1万+
关注、星标公众号，不错过精彩内容素材来源：网络编辑整理：strongerHuang对于许多物联网设备而言，拥有一个小型且具有弹性的文件系统至关重要。在MCU上运行的文件系统不多，绝大部分...
深入理解 OpenHarmony liteos_m 文件系统 littleefs
NVG_Haru的博客
11-06 499
通过本文的讲解，相信大家对于 littlefs 文件系统有了较为全面的了解。总的来说，littlefs 是一种极简的文件系统，实现了文件系统基本的数据缓存、掉电恢复、磨损均衡等功能，在资源相对富裕的环境中，开发者们可以对其运行机制甚至存储结构进行“使用空间换时间”的优化策略，提升读写的 IO 性能。学会有效地利用文件系统往往能起到事半功倍的作用，希望开发者能够将所学知识有效应用到未来的开发工作中，从而提高开发工作的效率。
关于littlefs文件系统的效率问题
木牛的博客
08-31 5764
最近在使用littlefs文件系统，由于要跟原系统做兼容 没有使用FAL接口及MTD设备，直接使用lfs操作的块设备， 从官方的资料来看，littlefs有点还是很明显的， 占用资源少，自带磨损均衡等等。。。 移植完成后，测试lfs系统挂载及读写操作都没有问题， 但执行效率极慢，连最基本的ls命令都是一个一个的出， 而同样的工程，换成FAT系统，就完全不一样，效果如下 使用littlefs时的效果 使用fat时的效果 文件使用的是同一个工程，底层SPI驱动都是完全一样的， 不知道为什么会差别
FatFs（通用FAT文件系统模块）下载与介绍
jiabin的博客
09-16 1万+
FatFs介绍 下载地址 源码文件结构分析 FatFs补丁
嵌入式FAT16/FAT32文件系统免费源码下载
06-26
嵌入式FAT文件系统免费源码下载 本版本代码完全兼容FAT16/FAT32文件系统总共两种格式，兼容长文件名， 兼容文字编码GB2312/UNICODE汉字编码（文件名完全支持中文）， 实现了支持子目录，实现了支持文件的读取，写入...
stm32基于HAL库实现sd卡使用fatfs文件系统.zip
05-14
stm32基于HAL库实现sd卡使用fatfs文件系统.zip 计算机专业，软件工程专业，通信工程大学生课程设计 自己大三的时候写的 适合大家做课程设计，写毕业设计也可以参考 基于STM32的课程设计
基于stm32f407 spi flash 移植 fatfs0.15文件系统
最新发布
01-20
基于stm32f407 spi flash 移植 fatfs0.15文件系统
FATFS文件系统复制文件和文件夹
10-22
FATFS文件系统复制文件和文件夹
FatFS文件系统函数说明
05-10
FATFS是一个为小型嵌入式系统设计的通用FAT(File Allocation Table)文件系统模块，本文主要介绍相关的函数及使用方法
鸿蒙轻内核源码分析：文件系统LittleFS
华为云官方博客
02-08 2713
摘要：本文先介绍下LFS文件系统结构体的结构体和全局变量，然后分析下LFS文件操作接口。
FATFS文件系统学习笔记
热门推荐
a568713197的博客
09-01 3万+
什么是文件系统       负责管理和存储文件信息的软件机构，在磁盘上组织文件的方法。 常用的文件系统       FAT/FATFS  小型嵌入式系统       NTFS   WINDOWS       CDFS  光盘       exFAT  更适用于闪存 FATFS优点：免费开源，专门为小型嵌入式系统设计，c编写，支持FAT12, FAT16 与 FAT32，支持多种存储媒...
Mbed OS 文档翻译 之 参考（配置（存储））
XinLiBK的博客
08-14 516
存储 此页面描述了 Mbed OS 中存储的构建时可配置参数。不同的存储模块没有标准的共享配置选项。相反，每个模块都有自己的特定于实现的配置选项。 LittleFS 配置。 NVStore 配置。 以下是 mbed compile --config -v 生成的存储配置参数的完整列表。有关如何使用或覆盖这些设置的详细信息，请参阅配置系统文档。 LittleFS 配置 LittleFS 提...
LittleFS - 一个高度完整的嵌入式文件系统
xk100的专栏
12-28 1万+
LittleFS - 一个高度完整的嵌入式文件系统   拥有小巧灵活的文件系统对许多物联网设备至关重要。使用文件系统并将其与正确的存储技术（如外部闪存或SD卡）配对可能很困难。Mbed操作系统使文件系统的组合变得简单。Mbed OS 5.7既支持FAT文件系统，又引入了高度集成的嵌入式文件系统。这包括对没有自己的磨损平衡控制器的闪存芯片的磨损平衡支持。 LittleFS  - 一个高度完整的...
fatfs和littlefs
05-31
FATFS和LittleFS都是用于在嵌入式系统中实现文件系统的软件库。 FATFS是一种开源的文件系统，广泛用于嵌入式系统中。它最初是由ChaN开发的，支持FAT12、FAT16和FAT32等文件系统格式。FATFS的优点是易于理解和实现，适用于小型嵌入式设备，在低ROM和RAM的限制下，可以提供可靠和高效的文件系统支持。 LittleFS是一种轻量级的嵌入式文件系统，最初由ARM公司开发。它被设计为在资源受限的嵌入式设备上运行，具有较小的代码占用和较低的内存占用。LittleFS支持闪存设备，具有较好的数据保护和快速的文件访问速度。 总的来说，FATFS适用于处理较小的文件系统，而LittleFS则适用于处理更大的文件系统，但需要更高的性能和更好的数据保护。在选择使用哪种文件系统时，需要考虑嵌入式设备的资源限制、应用程序的需求和预算等因素。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

爱出名的狗腿子

你的鼓励就是我最大的动力

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

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

打赏作者

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

抵扣说明：

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

余额充值