Clase 17 de 30 • Curso de IoT: Programación de Microcontroladores ESP32
Contenido del curso
Martín Gutiérrez Hernández
Diana Martinez
Harrison Malagon
Harrison Malagon
Julio Cardenas
Mariana Valencia Gallego
Gabriel Obregón
Julio Cardenas
Carlos Andres Betancourt Perez
Oswaldo Díaz Ventura
Juan Felipe Rodriguez Valencia
Pablo Torres Pérez
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:
#include <inttypes.h>%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?
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.
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"); }
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"); }
Este es un mapa de memoria de un ESP32 con 8MB de memoria . .
Esta clase fue muy buena! La explicación clara y los pasos fáciles de seguir
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:
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:
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.
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"); }
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); } //----------------------------------------
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"); }
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"); }
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"); }