kopia lustrzana https://github.com/espressif/esp-idf
196 wiersze
6.1 KiB
C
196 wiersze
6.1 KiB
C
/* Non-Volatile Storage (NVS) Read and Write a Blob - Example
|
|
|
|
For other examples please check:
|
|
https://github.com/espressif/esp-idf/tree/master/examples
|
|
|
|
This example code is in the Public Domain (or CC0 licensed, at your option.)
|
|
|
|
Unless required by applicable law or agreed to in writing, this
|
|
software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
|
|
CONDITIONS OF ANY KIND, either express or implied.
|
|
*/
|
|
#include <stdio.h>
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/task.h"
|
|
#include "esp_system.h"
|
|
#include "nvs_flash.h"
|
|
#include "nvs.h"
|
|
#include "driver/gpio.h"
|
|
|
|
#define STORAGE_NAMESPACE "storage"
|
|
|
|
#if CONFIG_IDF_TARGET_ESP32C3
|
|
#define BOOT_MODE_PIN GPIO_NUM_9
|
|
#else
|
|
#define BOOT_MODE_PIN GPIO_NUM_0
|
|
#endif //CONFIG_IDF_TARGET_ESP32C3
|
|
|
|
/* Save the number of module restarts in NVS
|
|
by first reading and then incrementing
|
|
the number that has been saved previously.
|
|
Return an error if anything goes wrong
|
|
during this process.
|
|
*/
|
|
esp_err_t save_restart_counter(void)
|
|
{
|
|
nvs_handle_t my_handle;
|
|
esp_err_t err;
|
|
|
|
// Open
|
|
err = nvs_open(STORAGE_NAMESPACE, NVS_READWRITE, &my_handle);
|
|
if (err != ESP_OK) return err;
|
|
|
|
// Read
|
|
int32_t restart_counter = 0; // value will default to 0, if not set yet in NVS
|
|
err = nvs_get_i32(my_handle, "restart_conter", &restart_counter);
|
|
if (err != ESP_OK && err != ESP_ERR_NVS_NOT_FOUND) return err;
|
|
|
|
// Write
|
|
restart_counter++;
|
|
err = nvs_set_i32(my_handle, "restart_conter", restart_counter);
|
|
if (err != ESP_OK) return err;
|
|
|
|
// Commit written value.
|
|
// After setting any values, nvs_commit() must be called to ensure changes are written
|
|
// to flash storage. Implementations may write to storage at other times,
|
|
// but this is not guaranteed.
|
|
err = nvs_commit(my_handle);
|
|
if (err != ESP_OK) return err;
|
|
|
|
// Close
|
|
nvs_close(my_handle);
|
|
return ESP_OK;
|
|
}
|
|
|
|
/* Save new run time value in NVS
|
|
by first reading a table of previously saved values
|
|
and then adding the new value at the end of the table.
|
|
Return an error if anything goes wrong
|
|
during this process.
|
|
*/
|
|
esp_err_t save_run_time(void)
|
|
{
|
|
nvs_handle_t my_handle;
|
|
esp_err_t err;
|
|
|
|
// Open
|
|
err = nvs_open(STORAGE_NAMESPACE, NVS_READWRITE, &my_handle);
|
|
if (err != ESP_OK) return err;
|
|
|
|
// Read the size of memory space required for blob
|
|
size_t required_size = 0; // value will default to 0, if not set yet in NVS
|
|
err = nvs_get_blob(my_handle, "run_time", NULL, &required_size);
|
|
if (err != ESP_OK && err != ESP_ERR_NVS_NOT_FOUND) return err;
|
|
|
|
// Read previously saved blob if available
|
|
uint32_t* run_time = malloc(required_size + sizeof(uint32_t));
|
|
if (required_size > 0) {
|
|
err = nvs_get_blob(my_handle, "run_time", run_time, &required_size);
|
|
if (err != ESP_OK) {
|
|
free(run_time);
|
|
return err;
|
|
}
|
|
}
|
|
|
|
// Write value including previously saved blob if available
|
|
required_size += sizeof(uint32_t);
|
|
run_time[required_size / sizeof(uint32_t) - 1] = xTaskGetTickCount() * portTICK_PERIOD_MS;
|
|
err = nvs_set_blob(my_handle, "run_time", run_time, required_size);
|
|
free(run_time);
|
|
|
|
if (err != ESP_OK) return err;
|
|
|
|
// Commit
|
|
err = nvs_commit(my_handle);
|
|
if (err != ESP_OK) return err;
|
|
|
|
// Close
|
|
nvs_close(my_handle);
|
|
return ESP_OK;
|
|
}
|
|
|
|
/* Read from NVS and print restart counter
|
|
and the table with run times.
|
|
Return an error if anything goes wrong
|
|
during this process.
|
|
*/
|
|
esp_err_t print_what_saved(void)
|
|
{
|
|
nvs_handle_t my_handle;
|
|
esp_err_t err;
|
|
|
|
// Open
|
|
err = nvs_open(STORAGE_NAMESPACE, NVS_READWRITE, &my_handle);
|
|
if (err != ESP_OK) return err;
|
|
|
|
// Read restart counter
|
|
int32_t restart_counter = 0; // value will default to 0, if not set yet in NVS
|
|
err = nvs_get_i32(my_handle, "restart_conter", &restart_counter);
|
|
if (err != ESP_OK && err != ESP_ERR_NVS_NOT_FOUND) return err;
|
|
printf("Restart counter = %d\n", restart_counter);
|
|
|
|
// Read run time blob
|
|
size_t required_size = 0; // value will default to 0, if not set yet in NVS
|
|
// obtain required memory space to store blob being read from NVS
|
|
err = nvs_get_blob(my_handle, "run_time", NULL, &required_size);
|
|
if (err != ESP_OK && err != ESP_ERR_NVS_NOT_FOUND) return err;
|
|
printf("Run time:\n");
|
|
if (required_size == 0) {
|
|
printf("Nothing saved yet!\n");
|
|
} else {
|
|
uint32_t* run_time = malloc(required_size);
|
|
err = nvs_get_blob(my_handle, "run_time", run_time, &required_size);
|
|
if (err != ESP_OK) {
|
|
free(run_time);
|
|
return err;
|
|
}
|
|
for (int i = 0; i < required_size / sizeof(uint32_t); i++) {
|
|
printf("%d: %d\n", i + 1, run_time[i]);
|
|
}
|
|
free(run_time);
|
|
}
|
|
|
|
// Close
|
|
nvs_close(my_handle);
|
|
return ESP_OK;
|
|
}
|
|
|
|
|
|
void app_main(void)
|
|
{
|
|
esp_err_t err = nvs_flash_init();
|
|
if (err == ESP_ERR_NVS_NO_FREE_PAGES || err == ESP_ERR_NVS_NEW_VERSION_FOUND) {
|
|
// NVS partition was truncated and needs to be erased
|
|
// Retry nvs_flash_init
|
|
ESP_ERROR_CHECK(nvs_flash_erase());
|
|
err = nvs_flash_init();
|
|
}
|
|
ESP_ERROR_CHECK( err );
|
|
|
|
err = print_what_saved();
|
|
if (err != ESP_OK) printf("Error (%s) reading data from NVS!\n", esp_err_to_name(err));
|
|
|
|
err = save_restart_counter();
|
|
if (err != ESP_OK) printf("Error (%s) saving restart counter to NVS!\n", esp_err_to_name(err));
|
|
|
|
gpio_reset_pin(BOOT_MODE_PIN);
|
|
gpio_set_direction(BOOT_MODE_PIN, GPIO_MODE_INPUT);
|
|
|
|
/* Read the status of GPIO0. If GPIO0 is LOW for longer than 1000 ms,
|
|
then save module's run time and restart it
|
|
*/
|
|
while (1) {
|
|
if (gpio_get_level(BOOT_MODE_PIN) == 0) {
|
|
vTaskDelay(1000 / portTICK_PERIOD_MS);
|
|
if(gpio_get_level(BOOT_MODE_PIN) == 0) {
|
|
err = save_run_time();
|
|
if (err != ESP_OK) printf("Error (%s) saving run time blob to NVS!\n", esp_err_to_name(err));
|
|
printf("Restarting...\n");
|
|
fflush(stdout);
|
|
esp_restart();
|
|
}
|
|
}
|
|
vTaskDelay(200 / portTICK_PERIOD_MS);
|
|
}
|
|
}
|