基于esp32实现键值对存储读写c程序例程

luoqice

已于 2025-04-28 14:39:17 修改

阅读量481

点赞数 5

CC 4.0 BY-SA版权

分类专栏： esp32 文章标签： c语言开发语言

于 2025-04-27 23:33:46 首次发布

本文链接：https://blog.youkuaiyun.com/luoqice/article/details/147571181

esp32 专栏收录该内容

18 篇文章

订阅专栏

在基于 ESP32 的系统中，我们可以使用 NVS（Non-Volatile Storage，非易失性存储）来实现系统配置参数的掉电存储和读写。NVS 是 ESP32 提供的一种存储机制，允许我们将键值对数据存储在闪存中，即使设备掉电，数据也不会丢失。
以下是一个简单的 C 程序例程，展示了如何使用 NVS 进行系统配置参数的读写：

#include <stdio.h>
#include "nvs_flash.h"
#include "nvs.h"

// 定义一个函数用于写入配置参数
esp_err_t write_config_parameter(const char* key, int value) {
    // 打开 NVS 命名空间
    nvs_handle_t my_handle;
    esp_err_t err = nvs_open("storage", NVS_READWRITE, &my_handle);
    if (err != ESP_OK) {
        printf("Error (%s) opening NVS handle!\n", esp_err_to_name(err));
        return err;
    }

    // 写入参数
    err = nvs_set_i32(my_handle, key, value);
    if (err != ESP_OK) {
        printf("Error (%s) writing to NVS!\n", esp_err_to_name(err));
    } else {
        // 提交更改
        err = nvs_commit(my_handle);
        if (err != ESP_OK) {
            printf("Error (%s) committing to NVS!\n", esp_err_to_name(err));
        }
    }

    // 关闭 NVS 句柄
    nvs_close(my_handle);
    return err;
}

// 定义一个函数用于读取配置参数
esp_err_t read_config_parameter(const char* key, int* value) {
    // 打开 NVS 命名空间
    nvs_handle_t my_handle;
    esp_err_t err = nvs_open("storage", NVS_READONLY, &my_handle);
    if (err != ESP_OK) {
        printf("Error (%s) opening NVS handle!\n", esp_err_to_name(err));
        return err;
    }

    // 读取参数
    err = nvs_get_i32(my_handle, key, value);
    switch (err) {
        case ESP_OK:
            printf("Read parameter %s: %d\n", key, *value);
            break;
        case ESP_ERR_NVS_NOT_FOUND:
            printf("Parameter %s not found!\n", key);
            break;
        default :
            printf("Error (%s) reading from NVS!\n", esp_err_to_name(err));
    }

    // 关闭 NVS 句柄
    nvs_close(my_handle);
    return err;
}

void app_main() {
    // 初始化 NVS
    esp_err_t err = nvs_flash_init();
    if (err == ESP_ERR_NVS_NO_FREE_PAGES || err == ESP_ERR_NVS_NEW_VERSION_FOUND) {
        // NVS 分区被截断，需要擦除并重试
        ESP_ERROR_CHECK(nvs_flash_erase());
        err = nvs_flash_init();
    }
    ESP_ERROR_CHECK(err);

    // 定义要读写的键和值
    const char* key = "config_param";
    int write_value = 123;

    // 写入配置参数
    err = write_config_parameter(key, write_value);
    if (err == ESP_OK) {
        printf("Parameter %s written successfully!\n", key);
    }

    // 读取配置参数
    int read_value;
    err = read_config_parameter(key, &read_value);
    if (err == ESP_OK) {
        printf("Parameter %s read successfully: %d\n", key, read_value);
    }
}

代码说明：
1. 初始化 NVS：在 app_main 函数中，我们首先调用 nvs_flash_init() 来初始化 NVS。如果 NVS 分区被截断或有新版本，我们需要擦除并重试。
2. 写入配置参数：write_config_parameter 函数用于将一个整数参数写入 NVS。我们首先打开 NVS 命名空间，然后使用 nvs_set_i32 写入参数，最后调用 nvs_commit 提交更改。
3. 读取配置参数：read_config_parameter 函数用于从 NVS 中读取一个整数参数。我们打开 NVS 命名空间，使用 nvs_get_i32 读取参数，并根据返回值进行相应的处理。
4. 主函数：在 app_main 函数中，我们调用 write_config_parameter 写入一个参数，然后调用 read_config_parameter 读取该参数，并打印结果。
注意事项：
• 这个例程只是一个简单的示例，实际应用中可能需要处理更多的数据类型和错误情况。
• NVS 有一定的存储空间限制，需要合理使用。
• 在写入和读取参数时，要确保键的唯一性。

=====================大容量数据存储方案==============================

在ESP32中备份OTA升级的bin文件，下面为你分析不同存储方案以及是否可以使用NVS（Non-Volatile Storage）：

NVS（非易失性存储）

不适合的原因

容量限制：NVS主要用于存储少量的键值对数据，比如设备的配置信息、校准参数等。ESP32的NVS分区通常容量较小（一般只有几十KB），而OTA升级的bin文件通常较大（可能有几百KB甚至几MB），NVS无法满足存储bin文件的容量需求。
设计目的：NVS是为了方便存储和管理小型的、频繁读写的配置数据而设计的，并非用于存储大文件。它的读写操作是基于键值对的，不适合处理大尺寸的二进制数据。

其他可行的存储方案及对应库

内置闪存（使用SPIFFS或LittleFS）

特点：ESP32自带一定容量的内置闪存（常见4MB、8MB等），无需额外硬件，读写速度较快，但容量有限。

对应库及使用说明

SPIFFS（SPI Flash File System）：早期常用于ESP32的文件系统。使用时，需要在代码里进行初始化，之后就能像操作普通文件系统一样读写文件。

#include "esp_spiffs.h"
#include <stdio.h>

void init_spiffs() {
    esp_vfs_spiffs_conf_t conf = {
      .base_path = "/spiffs",
      .partition_label = NULL,
      .max_files = 5,
      .format_if_mount_failed = true
    };
    esp_err_t ret = esp_vfs_spiffs_register(&conf);
    if (ret != ESP_OK) {
        if (ret == ESP_FAIL) {
            printf("Failed to mount or format filesystem\n");
        } else if (ret == ESP_ERR_NOT_FOUND) {
            printf("Failed to find SPIFFS partition\n");
        } else {
            printf("Failed to initialize SPIFFS (%s)\n", esp_err_to_name(ret));
        }
    }
}

void backup_bin_file(const uint8_t* bin_data, size_t data_size) {
    FILE* f = fopen("/spiffs/ota_backup.bin", "w");
    if (f == NULL) {
        printf("Failed to open file for writing\n");
        return;
    }
    fwrite(bin_data, 1, data_size, f);
    fclose(f);
}

LittleFS：是一种较新的文件系统，相比SPIFFS有更好的性能和稳定性。使用方式与SPIFFS类似，先初始化，再进行文件操作。

#include "esp_littlefs.h"
#include <stdio.h>

esp_err_t init_littlefs() {
    esp_vfs_littlefs_conf_t conf = {
      .base_path = "/littlefs",
      .partition_label = NULL,
      .format_if_mount_failed = true,
      .dont_mount = false
    };
    esp_err_t err = esp_vfs_littlefs_register(&conf);
    if (err != ESP_OK) {
        if (err == ESP_FAIL) {
            printf("Failed to mount or format filesystem\n");
        } else if (err == ESP_ERR_NOT_FOUND) {
            printf("Failed to find LittleFS partition\n");
        } else {
            printf("Failed to initialize LittleFS (%s)\n", esp_err_to_name(err));
        }
        return err;
    }
    return ESP_OK;
}

void backup_bin_to_littlefs(const uint8_t* bin_data, size_t data_size) {
    if (init_littlefs() == ESP_OK) {
        FILE* f = fopen("/littlefs/ota_backup.bin", "w");
        if (f == NULL) {
            printf("Failed to open file for writing\n");
            return;
        }
        fwrite(bin_data, 1, data_size, f);
        fclose(f);
    }
}

外部SD卡

特点：有较大存储容量，可备份多个OTA升级bin文件，成本较低，但读写速度相对内置闪存可能较慢，且需要额外引脚用于SPI通信。
对应库及使用说明：使用ESP-IDF的SD卡驱动库，要先进行SD卡初始化，然后进行文件操作。

#include "driver/sdmmc_host.h"
#include "sdmmc_cmd.h"
#include <stdio.h>

void backup_to_sd(const uint8_t* bin_data, size_t data_size) {
    sdmmc_host_t host = SDMMC_HOST_DEFAULT();
    sdmmc_slot_config_t slot_config = SDMMC_SLOT_CONFIG_DEFAULT();

    esp_err_t err = esp_vfs_fat_sdmmc_mount("/sdcard", &host, &slot_config, NULL);
    if (err != ESP_OK) {
        if (err == ESP_FAIL) {
            printf("Failed to mount filesystem. If you want the card to be formatted, set format_if_mount_failed = true.\n");
        } else {
            printf("Failed to initialize the card (%s). Make sure SD card lines have pull - up resistors in place.\n", esp_err_to_name(err));
        }
        return;
    }

    FILE* f = fopen("/sdcard/ota_backup.bin", "w");
    if (f == NULL) {
        printf("Failed to open file for writing\n");
    } else {
        fwrite(bin_data, 1, data_size, f);
        fclose(f);
    }
}

外部SPI Flash

特点：通过SPI接口连接外部SPI Flash芯片可扩展存储容量，读写速度较快，体积小，但需要额外的SPI Flash芯片和相应驱动程序。
对应库及使用说明：使用ESP-IDF的SPI Flash驱动库，依据具体的SPI Flash芯片型号进行配置和操作，不同芯片操作方式有差异，具体代码需参考芯片数据手册。