ESP32使用spiffs实现数据环形存储

最新推荐文章于 2024-04-22 19:15:34 发布
最新推荐文章于 2024-04-22 19:15:34 发布
阅读量417 收藏 2
点赞数
文章标签： log4j
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wuyihao123/article/details/131871905
版权

ESP32提供spiffs文件管理系统，我使用的ESP32-wrover-e有16MB的rom空间，去掉系统所占的空间，完全可以拿剩下的10MB空间来存储日志，数据等消息。下面是我用C语言实现的，环形存储，供大家参考借鉴。

#define FILE_DAY_COUNT 7  //定义7天
#define MAX_ENTRIES_PER_FILE 1750 // 一个文件的最大条数，超过将跳转到下一个文件
#define STORAGE_THRESHOLD 6000  // 当存储空间小于此字节数时，将擦除最旧的文件

typedef struct {
    size_t start; // 指向最旧数据的索引
    size_t end; // 指向最新数据的索引
    size_t entryCount; // 当前文件中的条目计数
    bool nextFileTriggered; // 表示是否需要跳转到下一个文件
} RingBufferIndex;


typedef struct {
    size_t length; // 数据长度
    char data[]; // 数据内容
} DataEntry;


void init_ring_buffer();
bool write_ring_bufferdata(const uint8_t* data, size_t length);
uint8_t* read_ring_bufferdata(size_t* dataLength);
bool trigger_next_file();//跳转到下一个文件
void wipe_oldest_file();// 擦除最旧文件
void print_spiffs_info(const char* partition_label);
void ringbufftest();//单元测试
// 创建一个数组来存储每个文件的RingBufferIndex
RingBufferIndex rbi[FILE_DAY_COUNT];
size_t oldestFileIndex = 0;

void init_ring_buffer() {
    FILE* f = fopen(PROJ_LIB_ROOT "/ringbufindex.txt", "r");
    if (f == NULL) {
        // 文件不存在，创建并用默认值初始化
        memset(&rbi, 0, sizeof(rbi));
        oldestFileIndex = 0;
        for(size_t i = 0; i < FILE_DAY_COUNT; i++) {
            rbi[i].nextFileTriggered = false;
        }
        f = fopen(PROJ_LIB_ROOT "/ringbufindex.txt", "w");
        if (f != NULL) {
            fwrite(&rbi, sizeof(RingBufferIndex), FILE_DAY_COUNT, f);
            fwrite(&oldestFileIndex, sizeof(size_t), 1, f);
            fclose(f);
            OLOGI("Created ringbufindex.txt");
        } else {
            OLOGE("Failed to create ringbufindex.txt");
            return;
        }
    } else {
        // 从文件中读取 rbi 数组和 oldestFileIndex 变量
        fread(&rbi, sizeof(RingBufferIndex), FILE_DAY_COUNT, f);
        fread(&oldestFileIndex, sizeof(size_t), 1, f);
        fclose(f);
        // 打印读取的信息
        OLOGI("Loaded ringbufindex.txt:");
        for (size_t i = 0; i < FILE_DAY_COUNT; i++) {
        OLOGI("rbi[%zu]: start=%zu, end=%zu, entryCount=%zu, nextFileTriggered=%d",
          i, rbi[i].start, rbi[i].end, rbi[i].entryCount, rbi[i].nextFileTriggered);
         }
         OLOGI("oldestFileIndex: %zu", oldestFileIndex);
    }
    // 初始化环形缓冲区文件
    for (size_t i = 0; i < FILE_DAY_COUNT; i++) {
        char filename[30];
        snprintf(filename, sizeof(filename), PROJ_LIB_ROOT "/ringbuffdata_%zu.txt", i);
        f = fopen(filename, "r");
        if (f == NULL) {
            // 数据文件不存在，创建新的
            f = fopen(filename, "w");
            if (f == NULL) {
                OLOGE("Failed to create %s", filename);
                return;
            }
            OLOGI("Created %s", filename);
        }
        fclose(f);
    }
}

//跳转到下一个文件
bool trigger_next_file() {
    // 查找正在写入的文件
    size_t fileIndex;
    for (fileIndex = 0; fileIndex < FILE_DAY_COUNT; fileIndex++) {
        if (!rbi[fileIndex].nextFileTriggered) {
            break;
        }
    }
    // 如果找到，设置nextFileTriggered为true并返回真
    if (fileIndex != FILE_DAY_COUNT) {
        rbi[fileIndex].nextFileTriggered = true;
        return true;
    }
    // 没有找到，记录警告信息并返回假
    OLOGW("Failed to trigger next file, all files are marked as nextFileTriggered");
    return false;
}
// 擦除最旧文件
void wipe_oldest_file() {
    // 获取当前最旧文件的文件名
    char filename[30];
    snprintf(filename, sizeof(filename), PROJ_LIB_ROOT "/ringbuffdata_%zu.txt", oldestFileIndex);

    // 打开文件，并使用 "w" 模式以清空文件
    FILE* f = fopen(filename, "w");
    if (f != NULL) {
        OLOGI("Cleared %s successfully", filename);
        fclose(f);
    } else {
        OLOGW("Failed to clear %s", filename);
        return;
    }

    // 重置对应的 RingBufferIndex
    rbi[oldestFileIndex] = (RingBufferIndex){0, 0, 0, false};

    // 更新 oldestFileIndex
    oldestFileIndex = (oldestFileIndex + 1) % FILE_DAY_COUNT;

    // 将更新后的 oldestFileIndex 和 rbi[] 写回 ringbufindex.txt
    f = fopen(PROJ_LIB_ROOT "/ringbufindex.txt", "w");
    if (f == NULL) {
        OLOGW("Failed to open ringbufindex.txt for writing");
        return;
    }
    fwrite(&rbi, sizeof(RingBufferIndex), FILE_DAY_COUNT, f);
    fwrite(&oldestFileIndex, sizeof(size_t), 1, f);
    fclose(f);
}


bool write_ring_bufferdata(const uint8_t* data, size_t length) {
    // 每次写入之前，都先检查剩余的存储空间
    size_t total_storage = 0;
    size_t used_storage = 0;
    esp_err_t ret = esp_spiffs_info("lib", &total_storage, &used_storage);
    if (ret != ESP_OK) {
        OLOGW("Failed to get partition information");
    } else {
        size_t remaining_storage = total_storage - used_storage;
        if (remaining_storage < STORAGE_THRESHOLD) {
            wipe_oldest_file();
        }
    }
    // 查找有空间的文件
    char filename[30];
    size_t fileIndex;
    
    for (fileIndex = 0; fileIndex < FILE_DAY_COUNT; fileIndex++) {
        if (!rbi[fileIndex].nextFileTriggered && rbi[fileIndex].entryCount < MAX_ENTRIES_PER_FILE) {
            break;
        }
    }
    // 打开文件进行写入
    FILE* f;
    DataEntry entry;
    // 如果所有文件都满了，就覆盖最旧的文件
    if (fileIndex == FILE_DAY_COUNT || rbi[fileIndex].nextFileTriggered)  {
        fileIndex = oldestFileIndex;
        oldestFileIndex = (oldestFileIndex + 1) % FILE_DAY_COUNT;  // 更新最旧文件索引
        rbi[fileIndex] = (RingBufferIndex){0, 0, 0, false};  // 重置该文件的 RingBufferIndex
        snprintf(filename, sizeof(filename), PROJ_LIB_ROOT "/ringbuffdata_%zu.txt", fileIndex);
        f = fopen(filename, "w");  // "w"模式会创建新文件
    } else {
        snprintf(filename, sizeof(filename), PROJ_LIB_ROOT "/ringbuffdata_%zu.txt", fileIndex);
        f = fopen(filename, "a");  // "a"模式会追加数据到文件尾部
    }
    if (f == NULL) {
        OLOGW("Failed to open %s for writing\n", filename);
        return false;
    }
    OLOGI("Writing fileIndex: %zu\n", fileIndex);  // 打印当前的索引
    // 写入数据
    entry.length = length;
    // OLOGI("Writing data: Length: %zu\n", entry.length);  // 打印写入的数据长度
    fwrite(&entry.length, sizeof(entry.length), 1, f);
    fwrite(data, length, 1, f);
    fclose(f);
    // 更新索引
    rbi[fileIndex].end = rbi[fileIndex].end + sizeof(DataEntry) + entry.length;
    rbi[fileIndex].entryCount++;
    // 写入更新后的索引
    f = fopen(PROJ_LIB_ROOT"/ringbufindex.txt", "w");
    if (f == NULL) {
        OLOGW("Failed to open ringbufindex.txt for writing\n");
        return false;
    }
    fwrite(&rbi, sizeof(RingBufferIndex), FILE_DAY_COUNT, f);
    fwrite(&oldestFileIndex, sizeof(size_t), 1, f);
    fclose(f);
    //查看剩余容量
    // print_spiffs_info("lib");
    return true;
}

uint8_t* read_ring_bufferdata(size_t* dataLength) {
    // 查找有数据的文件
    size_t fileIndex = oldestFileIndex;
    if (rbi[fileIndex].entryCount == 0) {
        //考虑未知情况下数据存放不连续，遍历所有文件，mqtt文件有时间戳，上传先后无影响。
        bool allFilesEmpty = true;
        for (size_t i = 0; i < FILE_DAY_COUNT; ++i) {
            if (rbi[i].entryCount != 0) {
                allFilesEmpty = false;
                fileIndex = i;
                oldestFileIndex = i;
                break;
            }
        }
        if (allFilesEmpty) {
            // OLOGI("All files are empty, no data to read");
            return NULL;  // 所有文件都是空的，返回 NULL
        }
    }
    // 获取当前文件名
    char filename[30];
    snprintf(filename, sizeof(filename), PROJ_LIB_ROOT"/ringbuffdata_%zu.txt", fileIndex);
    FILE* f = fopen(filename, "r");
    if (f == NULL) {
        OLOGW("Failed to open %s for reading\n", filename);
        return NULL;
    }
    uint8_t* data = NULL;
    // OLOGI("Reading fileIndex: %zu\n", fileIndex);  // 打印当前的索引
    size_t currentIndex = rbi[fileIndex].start;
    fseek(f, rbi[fileIndex].start, SEEK_SET);
    // while(currentIndex <= rbi[fileIndex].start) {
        // 读取数据长度
        size_t length;
        size_t readItems = fread(&length, sizeof(length), 1, f);
        if(readItems != 1) {
            if(data != NULL) {
                free(data);
            }
            fclose(f);
            OLOGW("Failed to read data length\n");
            return NULL;
        }
        
        if(length > 20480) { // 预期最大数据长度
            if(data != NULL) {
                free(data);
            }
            fclose(f);
            OLOGW("Data length is too big: %zu\n", length);
            return NULL;
        }

        // 重新分配内存并读取数据
        data = (uint8_t*)realloc(data, length);
        *dataLength = length;
        if (data == NULL) {
            fclose(f);
            OLOGW("Failed to allocate memory for data\n");
            return NULL;
        }
        readItems = fread(data, length, 1, f);
        if(readItems != 1) {
            free(data);
            fclose(f);
            OLOGW("Failed to read data\n");
            return NULL;
        }
      
        currentIndex += sizeof(length) + length;
        
    // }
    // OLOGI("read data: Length: %zu\n", *dataLength);  // 打印写入的数据长度
    fclose(f);

    // 更新索引
    rbi[fileIndex].start = rbi[fileIndex].start + sizeof(size_t) + *dataLength;
    // 如果读取了最旧文件的所有数据，就更新最旧文件索引
    if ( currentIndex >=rbi[fileIndex].end ) {
        oldestFileIndex = (oldestFileIndex + 1) % FILE_DAY_COUNT;
        rbi[fileIndex] = (RingBufferIndex){0, 0, 0, false};  // 重置索引
        // 打开并清空文件
        FILE* f = fopen(filename, "w");
        if (f != NULL) {
            OLOGI("Cleared %s", filename);
            fclose(f);
        } else {
            OLOGW("Failed to clear %s", filename);
        }
        // 添加的判断，如果每个文件的条数都为0，则把oldestFileIndex归0,说明数据被全读完了
        bool allFilesEmpty = true;
        for(size_t i = 0; i < FILE_DAY_COUNT; ++i) {
            if(rbi[i].entryCount != 0) {
                allFilesEmpty = false;
                break;
            }
        }
        if(allFilesEmpty) {
            oldestFileIndex = 0;
            // OLOGI("All files are empty, reset oldestFileIndex to 0");
        }
    }
    // 写入更新后的索引
    f = fopen(PROJ_LIB_ROOT"/ringbufindex.txt", "w");
    if (f == NULL) {
        free(data);
        OLOGW("Failed to open ringbufindex.txt for writing\n");
        return NULL;
    }
    fwrite(&rbi, sizeof(RingBufferIndex), FILE_DAY_COUNT, f);
    fwrite(&oldestFileIndex, sizeof(size_t), 1, f);
    fclose(f);
    return data;
}

void print_spiffs_info(const char* partition_label) {
    size_t total_storage = 0;
    size_t used_storage = 0;

    esp_err_t ret = esp_spiffs_info(partition_label, &total_storage, &used_storage);
    
    if (ret != ESP_OK) {
        OLOGW("Failed to get partition information for %s", partition_label);
    } else {
        OLOGI("[ /%s ] : total: %zu, used: %zu", partition_label, total_storage, used_storage);
    }
}

void ringbufftest()
{
    char data[51];
    for (int i = 0; i < 10; i++) {
    sprintf(data, "waring:monitor——data_%d", i);
     if (!write_ring_bufferdata((const uint8_t*) data, strlen(data))) {
        OLOGE("Failed to write data: %s", data);
        fon_sleep(10);
        break;
    }
    }
    trigger_next_file();
    for (int i = 10; i < 20; i++) {
    sprintf(data, "error:monitor——data_%d", i);
     if (!write_ring_bufferdata((const uint8_t*) data, strlen(data))) {
        OLOGE("Failed to write data: %s", data);
        fon_sleep(10);
        break;
    }
    }
    trigger_next_file();
    for (int i = 20; i < 30; i++) {
    sprintf(data, "error:monitor——data_%d", i);
     if (!write_ring_bufferdata((const uint8_t*) data, strlen(data))) {
        OLOGE("Failed to write data: %s", data);
        fon_sleep(10);
        break;
    }
    }
    trigger_next_file();
    for (int i = 30; i < 40; i++) {
    sprintf(data, "error:monitor——data_%d", i);
     if (!write_ring_bufferdata((const uint8_t*) data, strlen(data))) {
        OLOGE("Failed to write data: %s", data);
        fon_sleep(10);
        break;
    }
    }
    trigger_next_file();
    for (int i = 40; i < 50; i++) {
    sprintf(data, "error:monitor——data_%d", i);
     if (!write_ring_bufferdata((const uint8_t*) data, strlen(data))) {
        OLOGE("Failed to write data: %s", data);
        fon_sleep(10);
        break;
    }
    }
    trigger_next_file();
    for (int i = 50; i < 60; i++) {
    sprintf(data, "error:monitor——data_%d", i);
     if (!write_ring_bufferdata((const uint8_t*) data, strlen(data))) {
        OLOGE("Failed to write data: %s", data);
        fon_sleep(10);
        break;
    }
    }
    trigger_next_file();
    for (int i = 60; i < 70; i++) {
    sprintf(data, "error:monitor——data_%d", i);
     if (!write_ring_bufferdata((const uint8_t*) data, strlen(data))) {
        OLOGE("Failed to write data: %s", data);
        fon_sleep(10);
        break;
    }
    }
    // trigger_next_file();
    trigger_next_file();
    for (int i = 70; i < 80; i++) {
    sprintf(data, "error:monitor——data_%d", i);
     if (!write_ring_bufferdata((const uint8_t*) data, strlen(data))) {
        OLOGE("Failed to write data: %s", data);
        fon_sleep(10);
        break;
    }
    }
    trigger_next_file();
    for (int i = 80; i < 90; i++) {
    sprintf(data, "error:monitor——data_%d", i);
     if (!write_ring_bufferdata((const uint8_t*) data, strlen(data))) {
        OLOGE("Failed to write data: %s", data);
        fon_sleep(10);
        break;
    }
    }
     trigger_next_file();
    for (int i = 90; i < 100; i++) {
    sprintf(data, "error:monitor——data_%d", i);
     if (!write_ring_bufferdata((const uint8_t*) data, strlen(data))) {
        OLOGE("Failed to write data: %s", data);
        fon_sleep(10);
        break;
    }
    }
    trigger_next_file();
    for (int i = 100; i < 110; i++) {
    sprintf(data, "error:monitor——data_%d", i);
     if (!write_ring_bufferdata((const uint8_t*) data, strlen(data))) {
        OLOGE("Failed to write data: %s", data);
        fon_sleep(10);
        break;
    }
    }
    trigger_next_file();
    for (int i = 110; i < 120; i++) {
    sprintf(data, "error:monitor——data_%d", i);
     if (!write_ring_bufferdata((const uint8_t*) data, strlen(data))) {
        OLOGE("Failed to write data: %s", data);
        fon_sleep(10);
        break;
    }
    }

    fon_sleep(1000);
    size_t dataLength;
    for (int i = 0; i < 400; i++) {
    uint8_t* read_data = read_ring_bufferdata(&dataLength);
    if (read_data != NULL) {
        // 分配一个新的内存区域来存储字符串，预留一个额外的位置给空字符
        char* temp = (char*) malloc((dataLength + 1) * sizeof(char));
        // 复制字符串并添加空字符
        strncpy(temp, (char*) read_data, dataLength);
        temp[dataLength] = '\0';

        OLOGI("Read from ring buffer: %s", temp);
        free(read_data);  // 释放从 read_ring_bufferdata 分配的内存
        free(temp);  // 释放临时字符串的内存
    } else {
        OLOGI("No more data in ring buffer");
        break;
    }
    }
}

吴一吴
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
ESP32_spiffs_example:将SPIFFS与ESP32 VFS结合使用的完整示例
05-14
将SPIFFS与经过修改的esp_idf一起使用的示例spiffs VFS驱动程序 esp-idf支持spiffs文件系统，但未实现目录支持。 本示例使用修改后的spiffs VFS驱动程序，该驱动程序启用目录支持。 原始esp-idf spiffs驱动程序已通过启用目录的方式进行了修改。 要启用新的spiffs驱动程序，会将esp-idf组件目录中的spiffs目录复制到项目的components目录中。 仅修改了esp_spiffs.c文件以启用目录支持。 标准的mkdir（）和rmdir（）函数已添加到spiffs VFS驱动程序。 还提供了mkspiffs的修改版本，该版本支持使用目录构建spiffs文件系统映像。 特征 目录处理已启用 目录列表功能示例 文件复制功能示例 当使用具有文件名参数的文件相关功能时，必须在文件名中添加前缀/ spiffs / 。 如何建造 与
esp32使用网页实现本地控制
11-07
使用本地访问ESP网页控制ESP。实现离线控制设备。
【快速上手ESP32（基于ESP-IDF&VSCode）】09-Flash存储
最新发布
m0_63235356的博客
04-22 763
关于ESP32中的Flash，我们需要再回顾一下命名规则。我用的是立创开发板设计的板子，芯片型号是ESP32S3R8N8，因此可以知道我这块板子有8MB的Flash，大家可以参照着命名规则看看自己有多大的Flash容量。
ESP32S3 SPIFFS
04-21
ESP32S3 SPIFFS
Arduino ESP32S3 SPIFFS插件
08-30
git上那个只能给ESP32用，不能给ESP32S3用，自己稍微修改了一下，改成支持S3。 注意，这个不再支持ESP32，而且不能和ESP32插件共存。 使用方式， MAC：拷贝到 $HOME/Documents/Arduino/tools/ESP32FS/tool WIN不熟悉，自行解决
物联网嵌入式开发-ESP32通过SPIFFS实现外置SD卡文件的读写（ESP-IDF +VSCode编程）.rar
04-17
1、嵌入式物联网ESP32项目实战开发。例程经过精心编写，简单好用。 2、代码使用Visual Studio Code开发，C语言编程。例程在ESP32-S3上运行。若在其他型号上运行，请自行调整。 3、如果接入其他传感器，请查看发布的其他资料。 4、ESP32与模块的接线，在代码当中均有定义，请自行对照。 5、若硬件差异，请根据自身情况适当调整代码，程序仅供参考。 6、代码有注释说明，请耐心阅读。 7、技术v：349014857;
esp32 怎么分配freertos 堆栈大小_spiffs 文件系统在esp32中的应用
weixin_39866741的博客
11-30 773
spiffs 介绍SPIFFS 是一个开源文件系统，用于 SPI NOR flash 设备的嵌入式文件系统，支持磨损均衡、文件系统一致性检查等功能。spiffs 源码地址​github.comspiffs 特点而我们知道乐鑫的esp32的大部分存储都依赖于SPI flash ，spiffs可以说对于esp32 真可谓是最合适不过的了。因此对于spiffs乐鑫提供了很好的支持，专门提供了工具（spi...
VSCode PlatformIO ESP32S3 SPIFFS报错SPIFFS: mount failed, -10025
weixin_44950113的博客
10-24 2065
编译通过，但是spiffs文件系统不能正常工作，串口打印报错 SPIFFS: mount failed, -10025。
ESP32入门基础之SPIFFS
while（1）
12-13 1489
必填
ESP32开发—文件系统spiffs
da314的博客
03-08 2492
学习了ESP32的文件系统....进行一些总结。
ESP32C3-IDF SPIFFS文件系统
DYR20010308的博客
06-02 432
ESP32C3文件系统
环形字符串的子串遍历
m0_56366502的博客
04-14 601
环形字符串的子串遍历 第一行输入一个环形字符串，尾指向首，第二行输入一个子串，要求在环形字符串中有几种子串的遍历方式。就是这样的：ababab 子串是aba 能遍历几次子串
环形序列——字符串处理
zy的博客
07-31 940
题目：长度为n的环形串有n种表示法，分别为从某个位置开始顺时针得到。在这些表示法中，字典序最小的称为“最小表示”。 输入一个长度为n的环形串，你的任务是输出该环形串的最小表示。 例如，CTCC的最小表示是CCCT，CGAGTCAGCT的最小表示为AGCTCGAGTC。 我的想法和代码（没有实现） #include<stdio.h> #include<string.h> #define maxn 50 int main(){ char s[maxn],head[maxn]
ESP32 文件存储 spiffs
weixin_43808708的博客
05-23 2173
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录一、创建 spiffs 分区1.新建一个自定义 `partitions_example.csv` 分区表2.修改成自定义分区二、main.c 提示：以下使用的是 spiffs 例程 一、创建 spiffs 分区 1.新建一个自定义 partitions_example.csv 分区表 # Name, Type, SubType, Offset, Size, Flags # Note: if you have increas.
环形字符串处理：UVA1584 环状序列
qq_48988844的博客
09-06 1344
题目描述： 长度为n的环状串有n种表示法，分别为从某个位置开始顺时针得到的。在环状串的所有表示法中，字典序最小的称为“最小表示”。 输入一个长度为nn的环状DNA串（只包含A，C，G，T这四种字符）的一种表示法，你的任务是输出该环状串的最小表示。 解题思路： 对于环形序列有两种处理方式： 方式1：把序列s复制一份，与原序列首尾相连，拉长为一个直线串，如 环状序列ATC -> 直线序列ATCATC；或者也可以去复制一份去掉尾元素后，与原序列首尾相连，如 环状序列 AT...
ESP32S3学习——SPIFFS 文件系统
HandBAI的博客
06-23 1282
ESP32S3学习——SPIFFS 文件系统
ESP32-IDF开发实例-SPIFFS数据存取
视觉与物联智能
09-09 1566
ESP32-IDF对SPIFFS提供了非常好的支持。ESP32-IDF还提供专门的工具，如spiffsegn,mkspiffs等，对在ESP32上进行格式化，分区提供良好的支持。 本次实例将通过对SPIFFS接口的调用演示，从而实现数据的存取。
官方文档翻译-ESP32-Virtual filesystem component
xuanze0的博客
03-10 1915
虚拟文件系统组件 概述 Virtual filesystem (VFS) component provides a unified interface for drivers which can perform operations on file-like objects. This can be a real filesystems (FAT, SPIFFS, etc.), or de...
ESP32本地日志系统及通过无线通信获取本地日志
weixin_44055729的博客
09-15 491
ESP32 基于WIFI-MQTT 以及SPIFFS的本地日志系统
esp32 C语言实现spiffs读取文件
05-24
下面是一个示例代码，演示如何在ESP32上使用C语言实现SPIFFS读取文件的功能： ```c #include #include #include "esp_log.h" #include "esp_vfs.h" #include "esp_spiffs.h" #define FILENAME "/spiffs/test.txt...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值