Almacenamiento con ESP32

Clase 17 de 30 • Curso de IoT: Programación de Microcontroladores ESP32

Gabriel Obregón

student•

Almacenamiento Persistente en la Memoria Flash

En esta sección, exploraremos el uso del entorno de desarrollo y el SDK para trabajar con la memoria persistente en dispositivos con ESP32.

¿Qué es la Memoria Persistente?

La memoria persistente permite almacenar datos de forma permanente, es decir, los datos se conservan incluso si el dispositivo se apaga o pierde energía.

📌 Ejemplos de uso: ✅ Mantener configuraciones tras un reinicio.

✅ Actualizar software sin perder datos previos.

✅ Almacenar credenciales de Wi-Fi para evitar ingresarlas manualmente en cada reinicio.

Ahora, veamos cómo implementarlo en código.

1. Configuración del Entorno

Para trabajar con la memoria persistente en ESP32, utilizaremos Visual Studio Code y agregaremos las siguientes librerías:

#include <stdio.h>

#include "freertos/FreeRTOS.h"

#include "nvs_flash.h"

#include "nvs.h"

📌 Librerías utilizadas:

freertos/FreeRTOS.h → Necesaria para manejar tareas en ESP32.
nvs_flash.h → Permite el control de la memoria flash.
nvs.h → Contiene funciones para gestionar la memoria persistente (NVS = Non-Volatile Storage).

2. Inicialización de la Memoria Flash

Para utilizar la memoria NVS, primero debemos inicializarla con:

esp_err_t err = nvs_flash_init();

printf("NVS Init!\n");

printf((err != ESP_OK) ? "Failed\n" : "Done\n");

📌 ¿Qué hace nvs_flash_init()?

✅ Verifica que la memoria flash esté conectada.

✅ Asegura que todas las direcciones necesarias están disponibles.

✅ Devuelve un código de error en caso de problemas.

3. Creación de una Partición en Memoria

Para mejorar la organización de los datos, crearemos una partición en memoria.

📌 Ejemplo de uso:

Un segmento para configuración de Wi-Fi.
Otro segmento para datos de usuario o aplicación.

Para acceder a una partición de memoria, usamos:

nvs_handle_t my_storage;

err = nvs_open("storage", NVS_READWRITE, &my_storage);

printf("NVS Open\n");

printf((err != ESP_OK) ? "Failed\n" : "Done\n");

4. Escribir Datos en la Memoria Flash

Ahora almacenaremos un número entero (int32_t) en la memoria persistente.

err = nvs_set_i32(my_storage, "number", 10);

printf("NVS Set\n");

printf((err != ESP_OK) ? "Failed\n" : "Done\n");

📌 ¿Qué hace este código? ✅ Almacena el número 10 en la memoria flash.

✅ Asigna la clave "number" para identificarlo.

✅ Verifica si la operación se realizó correctamente.

5. Guardar los Datos de Forma Permanente

En algunas implementaciones, la memoria flash no almacena los datos inmediatamente. Para garantizar que se guarden, usamos:

err = nvs_commit(my_storage);

printf("NVS Commit\n");

printf((err != ESP_OK) ? "Failed\n" : "Done\n");

📌 ¿Qué hace nvs_commit()? ✅ Confirma que los datos queden almacenados de forma permanente.

6. Leer los Datos desde la Memoria Flash

Ahora, recuperaremos el número almacenado:

int32_t number;

err = nvs_get_i32(my_storage, "number", &number);

printf("NVS Get\n");

printf((err != ESP_OK) ? "Failed\n" : "Done\n");

printf("El valor recuperado es: %d\n", number);

📌 ¿Qué hace este código? ✅ Recupera el valor guardado con la clave "number".

✅ Lo almacena en la variable number.

✅ Imprime el valor en la consola.

7. Cerrar la Memoria NVS

Para liberar los recursos, cerramos la memoria:

nvs_close(my_storage);

printf("End\n");

📌 ¿Por qué es importante? ✅ Los dispositivos con ESP32 tienen memoria y procesamiento limitados.

✅ Liberar memoria mejora la eficiencia y previene fugas de recursos.

Julio Cardenas

student•

Con option = 1 el programa crea y escribe en la particion para todos los posibles datos . Leer str es bien confuso, segui el codigo del manual. . Con option = 2 el programa solo lee la particion y sus datos. . Espero que les sirva el codigo.

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "nvs_flash.h"
#include "nvs.h"

int option = 1;
esp_err_t err;
nvs_handle_t storage_h;

int8_t  entero_8;
int16_t entero_16;
int32_t entero_32;
int64_t entero_64;


size_t req_size;


void app_main(void)
{
    printf("The program has started\n");
    
    // Inicia el subsistema NVS
    err = nvs_flash_init();
    printf("NVS init: ");
    printf((err != ESP_OK) ? "Failed\n" : "Done\n");

    //Abre la particion dento de  NVS (Si no existe la crea)
    err = nvs_open(
        "Storage",      //Nombre que se le da a la particion
        NVS_READWRITE , //Modo de acceso
        &storage_h      //Handle para referenciar la particion
    );
    printf("NVS open: ");
    printf((err != ESP_OK) ? "Failed\n" : "Done\n");

    if (option == 1)  //Escribir en la particion
    {   
        //Abre la particion dento de  NVS (Si no existe la crea)
        err = nvs_open(
            "Storage",      //Nombre que se le da a la particion
            NVS_READWRITE , //Modo de acceso
            &storage_h      //Handle para referenciar la particion
        );
        printf("NVS open modo READWRITE: ");
        printf((err != ESP_OK) ? "Failed\n" : "Done\n");
 
        //Escribir un dato en NVS
        err = nvs_set_i8(storage_h,  "Entero_8",  10);           //Diez
        printf("NVS set i8: ");
        printf((err != ESP_OK) ? "Failed\n" : "Done\n");

        err = nvs_set_i16(storage_h, "Entero_16", 10000);        //Diez mil
        printf("NVS set i16: ");
        printf((err != ESP_OK) ? "Failed\n" : "Done\n");

        err = nvs_set_i32(storage_h, "Entero_32", 10000000);     //Diez millones
        printf("NVS set i32: ");
        printf((err != ESP_OK) ? "Failed\n" : "Done\n");

        err = nvs_set_i64(storage_h, "Entero_64", 10000000000);  //Diez mil millones
        printf("NVS set i64: ");
        printf((err != ESP_OK) ? "Failed\n" : "Done\n");

        err = nvs_set_str(storage_h, "Cadena",    "The quick brown fox jumps over the lazy dog 0123456789");   
        printf("NVS set str: ");
        printf((err != ESP_OK) ? "Failed\n" : "Done\n");

        //Forzar la escritura por medio de commit
        err = nvs_commit(storage_h);
        printf("NVS commit: ");
        printf((err != ESP_OK) ? "Failed\n" : "Done\n");

        
    }    
    else
    {
       //Abre la particion solo de lectura
       err = nvs_open(
            "Storage",      //Nombre que se le da a la particion
            NVS_READONLY ,  //Modo de acceso
            &storage_h      //Handle para referenciar la particion
        );
        printf("NVS open modo READONLY: ");
        printf((err != ESP_OK) ? "Failed\n" : "Done\n");
    }

    //Leemos los Datos
    err = nvs_get_i8(storage_h,  "Entero_8",       &entero_8 ); 
    printf("NVS get_i8: ");
    printf((err != ESP_OK) ? "Failed\n" : "Done\n");

    err = nvs_get_i16(storage_h, "Entero_16",      &entero_16 );  
    printf("NVS get_i16: ");
    printf((err != ESP_OK) ? "Failed\n" : "Done\n");

    err = nvs_get_i32(storage_h, "Entero_32",      &entero_32 );  
    printf("NVS get_i32: ");
    printf((err != ESP_OK) ? "Failed\n" : "Done\n");

    err = nvs_get_i64(storage_h, "Entero_64",      &entero_64 );  
    printf("NVS get_i64: ");
    printf((err != ESP_OK) ? "Failed\n" : "Done\n");
       
        
    err = nvs_get_str(storage_h, "Cadena",  NULL, &req_size );
    printf("NVS get_str with NULL: ");
    printf((err != ESP_OK) ? "Failed\n" : "Done\n");

    char* cadena = malloc(req_size);
    err = nvs_get_str(storage_h, "Cadena",  cadena, &req_size );  
    printf("NVS get_str: ");
    printf((err != ESP_OK) ? "Failed\n" : "Done\n");
        

    printf("El valor de entero_8  es: %d\n", entero_8);
    printf("El valor de entero_16 es: %d\n", entero_16);
    printf("El valor de entero_32 es: %ld\n", entero_32);
    printf("El valor de entero_64 es: %lld\n", entero_64);
    printf("El valor de cadena    es: %s\n", cadena);

    nvs_close(storage_h);
    printf("Termino el programa\n");
}

Julio Cardenas

student•

Este es un mapa de memoria de un ESP32 con 8MB de memoria . .

Carlos Andres Betancourt Perez

student•

les comparto mi código optimizando los logs:

//importamos las librerias necesarias
#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "nvs_flash.h"
#include "nvs.h"
#include "esp_log.h"

//declaramos las variables globales
static const char* TAG = "ESP32";

//prototipos de funciones
static void esp_logs(esp_err_t *err, char* ok, char* fail);

void app_main(void) {
   ESP_LOGI(TAG, "Start Application!");

   //inicializamos el driver de NVS
   esp_err_t error;
   error = nvs_flash_init();
   esp_logs(&error, "NVS driver initialized!", "NVS driver initialization failed!!");
   
   //creamos el handle para el nvs
   nvs_handle_t myStorage;
   //creamos una particion en la memoria flash
   error = nvs_open("storage", NVS_READWRITE, &myStorage);
   esp_logs(&error, "NVS Partition created!", "NVS partition create failed!!");
   
   //escribimos un dato de 32 bits en NVS
   error = nvs_set_i32(myStorage, "number", 500);
   esp_logs(&error, "NVS data writed!", "NVS data write failed!!");
   
   //guardamos los datos en NVS
   error = nvs_commit(myStorage);
   esp_logs(&error, "NVS data storaged!", "NVS data storage failed!!");

   //leemos el dato almacenado en nvs
   int32_t myNumber = 0;
   error = nvs_get_i32(myStorage, "number", &myNumber);
   esp_logs(&error, "NVS data readed!", "NVS data read failed!!");
   printf("Number read in NVS is: %ld\n", myNumber);
   nvs_close(myStorage);   //cerramos el NVS
   ESP_LOGW(TAG, "Application END!");
}
//----------------------------------------

static void esp_logs(esp_err_t *err, char* ok, char* fail) {
   if (*err == ESP_OK) ESP_LOGI(TAG, "%s", ok);
   else ESP_LOGE(TAG, "%s", fail);
}
//----------------------------------------

Oswaldo Díaz Ventura

student•

Mi código con buena caligrafía en los printf y la corrección del tipo de dato al imprimir el valor leído de la memoria, es decir, usar %ld en lugar de %d.

#include <stdio.h>
#include "freertos/freeRTOS.h"
#include "nvs_flash.h"
#include "nvs.h"

void app_main(void)
{
    printf("Start!\n");

    esp_err_t err = nvs_flash_init();
    printf("NVS Init: ");
    printf((err != ESP_OK) ? "Failed.\n" : "Done.\n");
    
    nvs_handle_t my_storage;
    err = nvs_open("storage", NVS_READWRITE, &my_storage);
    printf("NVS Open: ");
    printf((err != ESP_OK) ? "Failed.\n" : "Done.\n");

    err = nvs_set_i32(my_storage, "number", 10);
    printf("NVS Set: ");
    printf((err != ESP_OK) ? "Failed.\n" : "Done.\n");

    err = nvs_commit(my_storage);
    printf("NVS Commit: ");
    printf((err != ESP_OK) ? "Failed.\n" : "Done.\n");

    int32_t number1;
    err = nvs_get_i32(my_storage, "number", &number1);
    printf("NVS Get: ");
    printf((err != ESP_OK) ? "Failed.\n" : "Done.\n");

    printf("El valor recuperado es: %ld.\n", number1);
    nvs_close(my_storage);
    printf("End.\n");
}

Juan Felipe Rodriguez Valencia

student•

Les comparto el código de la clase:

#include <stdio.h>
#include "freertos/freeRTOS.h"
#include "nvs_flash.h"
#include "nvs.h"

void app_main(void)
{
    printf("start!\n");

    // inicializar el NVS
    esp_err_t err = nvs_flash_init();    
    printf("NVS init!\n");
    printf((err != ESP_OK) ? "Failed" : "Done");

    // acceder a una partición de NVS
    nvs_handle_t my_storage;
    err = nvs_open("storage", NVS_READWRITE, &my_storage);
    printf("NVS open!.\n");
    printf((err != ESP_OK) ? "Failed" : "Done");

    // Escribir en NVS
    nvs_set_u32(my_storage, "number", 10);
    printf("NVS set\n");
    printf((err != ESP_OK) ? "Failed" : "Done");

    // Guardar en NVS
    nvs_commit(my_storage);
    printf("NVS commit.\n");
    printf((err != ESP_OK) ? "Failed" : "Done");


    // Leer NVS
    int32_t number;
    nvs_get_i32(my_storage, "number", &number);
    printf("NVS get!.\n");
    printf((err != ESP_OK) ? "Failed" : "Done");

    printf("el valor recuperado es: %ld\n", number);

    nvs_close(my_storage);
    printf("end!.\n");
}

Pablo Torres Pérez

student•

Comparto el código de la clase. Solo puse el placeholder %ld por el tipo i32

#include <stdio.h>

#include "freertos/FreeRTOS.h"
// Librerías para manejo de persistencia en memoria
// Permite controlar lo relacionado con la memoria flash
#include "nvs_flash.h"
// Contiene las funciones generales para trabaajar con persistencia
// Non Volatile Storage
#include "nvs.h"

void app_main(void)
{
    printf("Start...\n");
    // Se inicializa el driver de NVS nvs_flash_init
    //  Verfica que todo esté listo para ser utilizado
    //  Verifica que esté conectada la memoria flash
    //  *      * que las ubicaciones en memoria estén disponibles, etc
    //  El framework permite verificar errores con el macro/tipo esp_err_t.
    esp_err_t err = nvs_flash_init();

    printf("NVS Init");
    // If de operador ternario
    // macro ESP_OK que indica si todo está OK
    printf((err != ESP_OK) ? "Failed\n" : " Done\n");

    // Acceder a partición de NVS
    nvs_handle_t my_storage;
    // Abre una partición de NVS
    // "Nombre de partición", tipo de acceso(l, e, le),
    // (&) referencia a la variable de almacenamiento
    err = nvs_open("storage", NVS_READWRITE, &my_storage);
    printf("NVS Open");
    printf((err != ESP_OK) ? "Failed\n" : " Done\n");
    // Escribir en NVS
    err = nvs_set_i32(my_storage, "number", 26);
    printf("NVS Set");
    printf((err != ESP_OK) ? "Failed\n" : " Done\n");

    // Guardar NVS
    err = nvs_commit(my_storage);
    printf("NVS Commit");
    printf((err != ESP_OK) ? "Failed\n" : " Done\n");

    // Leer NVS
    int32_t number;
    err = nvs_get_i32(my_storage, "number", &number);
    printf("NVS Get");
    printf((err != ESP_OK) ? "Failed\n" : " Done\n");

    printf("Valor recuperado es: %ld\n", number);
    // Limpieza
    nvs_close(my_storage);
    printf("End\n");
}

Mariana Valencia Gallego

student•

Esta clase fue muy buena! La explicación clara y los pasos fáciles de seguir

Harrison Malagon

student•

Codigo Funcionando

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "nvs_flash.h"
#include "nvs.h"

void app_main(void)
{
    printf("---Start!---\n");

    // Inicializar el NVS
    esp_err_t err = nvs_flash_init();
    printf("NVS Init!\n");
    printf((err != ESP_OK) ? "Failed\n" : "Done\n");

    // Acceder a una partición de NVS
    nvs_handle_t my_storage;
    err = nvs_open("storage", NVS_READWRITE, &my_storage);
    printf("NVS Open\n");
    printf((err != ESP_OK) ? "Failed\n" : "Done\n");

    // Escribir en NVS
    err = nvs_set_i32(my_storage, "number", 10);
    printf("NVS Set\n");
    printf((err != ESP_OK) ? "Failed\n" : "Done\n");

    // Guardar en NVS
    err = nvs_commit(my_storage);
    printf("NVS Commit\n");
    printf((err != ESP_OK) ? "Failed\n" : "Done\n");

    // Leer NVS
    int32_t number;
    err = nvs_get_i32(my_storage, "number", &number);
    printf("NVS Get\n");
    printf((err != ESP_OK) ? "Failed\n" : "Done\n");

    printf("El valor recuperado es: %ld\n", number);

    // Cerrar partición
    nvs_close(my_storage);

    printf("---END---\n");
}

Martín Gutiérrez Hernández

student•

Hola si tienen la version 5.1 del ESP-IDF probablemente les salga un error al compilar

en la parte de imprimir el valor obtenido por el nvs printf("El valor recuperado es: %d"\n",number);

En la documentación dice que es debido a que se usa otra versión del compilador GCC, la v.11.2, y esto afecta a los datos int32_t y sin signo. Para corregirlos se realizan los siguientes cambios:

se agrega la librería #include <inttypes.h>
se cambian los placeholders %i o %x por %"PRIi32" o%"PRIx" la x representa otro dato.

Así que cambiaríamos el printf por:

printf("El valor recuperado es: %"PRIi32"\n", number);

y agregaríamos la librería anterior.

¿A alguien le paso esto error u alguno otro?

Diana Martinez

student•

También se vale ya sea cambiar el tipo de dato ve las variables a solo int, o el placeholder a long int, %li. Así no se importa ninguna lib adicional ni hay que hacer demasiados cambios.

Harrison Malagon

student•

Me aparecio el mismo error, el problema era el entero:

 printf("El valor recuperado es: %d\n", number);

cambiar a:

printf("El valor recuperado es: %ld\n", number);

Comparto todo el codigo:

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "nvs_flash.h"
#include "nvs.h"

void app_main(void)
{
    printf("Start!\n");

    // Inicializar el NVS
    esp_err_t err = nvs_flash_init();
    printf("NVS Init!\n");
    printf((err != ESP_OK) ? "Failed\n" : "Done\n"); // Agregar salto de línea

    // Acceso a una partición NVS
    nvs_handle_t my_storage;
    err = nvs_open("storage", NVS_READWRITE, &my_storage);
    printf("NVS Open\n");
    printf((err != ESP_OK) ? "Failed\n" : "Done\n"); // Agregar salto de línea

    // Escribir en NVS
    err = nvs_set_i32(my_storage, "number", 10);
    printf("NVS Set\n");
    printf((err != ESP_OK) ? "Failed\n" : "Done\n"); // Agregar salto de línea

    // Guardar en NVS
    err = nvs_commit(my_storage);
    printf("NVS commit\n");
    printf((err != ESP_OK) ? "Failed\n" : "Done\n"); // Agregar salto de línea

    // Leer NVS
    int32_t number;
    err = nvs_get_i32(my_storage, "number", &number); // Corregir el signo "&" y eliminar el símbolo "%" en la cadena de formato
    printf("NVS Get\n");
    printf((err != ESP_OK) ? "Failed\n" : "Done\n"); // Agregar salto de línea

    printf("El valor recuperado es: %d\n", number); // Agregar el valor de "number" en la cadena de formato

    // Cerrar partición
    nvs_close(my_storage);

    printf("---END---\n");
}