Almacenamiento con ESP32

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:

1. se agrega la librería #include <inttypes.h>
2. 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?

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

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");
}

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");
}