ESP32-nvs-read-write.c

//this sample code reuses nvs_value_sample from Espressif
//the original can be found under ESP-IDF/examples/storage/nvs_rw_value

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

//add your credentials here
#define AZURE_IOT_HUB_FQDN "iotHUBtest.azure-devices.net"
#define AZURE_IOT_DEVICE_ID "DEVICE"
#define AZURE_IOT_DEVICE_SYMMETRIC_KEY "vP3TT3dWsdZr17Z+T1w3eWysS42we0QSnOWs#ovkcFY="
#define SAMPLE_IOT_WIFI_SSID "SSID"
#define SAMPLE_IOT_WIFI_PASSWORD "password"

//select the desired operation
#define STORE_NVS_DATA
#define READ_NVS_DATA

const char HUB_FQDN[]= AZURE_IOT_HUB_FQDN;
char value_HUB_FQDN[32];
size_t value_HUB_FQDN_length=32;

const char DEVICE_ID[]=AZURE_IOT_DEVICE_ID;
char value_DEVICE_ID[32];
size_t value_DEVICE_ID_length=32;

const char DEVICE_SYM_KEY[]=AZURE_IOT_DEVICE_SYMMETRIC_KEY;
char value_DEVICE_SYM_KEY[64];
size_t value_DEVICE_SYM_KEY_length=64;

const char WIFI_SSID[]=SAMPLE_IOT_WIFI_SSID;
char value_WIFI_SSID[32];
size_t value_WIFI_SSID_length=32;

const char WIFI_PASSWORD[]=SAMPLE_IOT_WIFI_PASSWORD;
char value_WIFI_PASSWORD[32];
size_t value_WIFI_PASSWORD_length=32;

void app_main(void)
{
    // Initialize NVS
    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 );

    // Open NVS handle
    printf("\n");
    printf("Opening Non-Volatile Storage (NVS) handle... ");
    nvs_handle_t my_handle;
    err = nvs_open("storage", NVS_READWRITE, &my_handle); 
    if (err != ESP_OK) {
        printf("Error (%s) opening NVS handle!\n", esp_err_to_name(err));
    } else {

        printf("Done\n");
        #ifdef READ_NVS_DATA       

            printf("-------------------------------------\n");
            printf("Reading NVS data... \n");

            err = nvs_get_str(my_handle, "WIFI_SSID", value_WIFI_SSID, &value_WIFI_SSID_length);
            switch (err) {
                case ESP_OK:
                    printf("Read Wifi Credentials SUCCESS=[%s]\n",value_WIFI_SSID);               
                    break;
                case ESP_ERR_NVS_NOT_FOUND:
                    printf("The Wi-Fi SSID value is not initialized yet!\n" );
                    break;
                default :
                    printf("Error reading Wifi Credentials\n" );
            }

            err = nvs_get_str(my_handle, "WIFI_PASSWORD", value_WIFI_PASSWORD, &value_WIFI_PASSWORD_length);
            switch (err) {
                case ESP_OK:
                    printf("Read Wifi Password SUCCESS=[%s]\n",value_WIFI_PASSWORD);               
                    break;
                case ESP_ERR_NVS_NOT_FOUND:
                    printf("The SSID Password value is not initialized yet!\n" );
                    break;
                default :
                    printf("Error reading SSID Password Credentials\n" );
            }

            err = nvs_get_str(my_handle, "HUB_FQDN", value_HUB_FQDN, &value_HUB_FQDN_length);
            switch (err) {
                case ESP_OK:
                    printf("Read HUB FQDN value SUCCESS=[%s]\n",value_HUB_FQDN);
                    break;
                case ESP_ERR_NVS_NOT_FOUND:
                    printf("The HUB FQDN value is not initialized yet!\n" );
                    break;
                default :
                    printf("Error reading HUB FQDN value\n" );
            }

            err = nvs_get_str(my_handle, "DEVICE_ID", value_DEVICE_ID, &value_DEVICE_ID_length);
            switch (err) {
                case ESP_OK:
                    printf("Read Device ID SUCCESS=[%s]\n",value_DEVICE_ID);               
                    break;
                case ESP_ERR_NVS_NOT_FOUND:
                    printf("The Device ID is not initialized yet!\n" );
                    break;
                default :
                    printf("Error reading Device ID\n" );
            }

            err = nvs_get_str(my_handle, "DEVICE_SYM_KEY", value_DEVICE_SYM_KEY, &value_DEVICE_SYM_KEY_length);
            switch (err) {
                case ESP_OK:
                    printf("Read Device Key SUCCESS=[%s]\r\n",value_DEVICE_SYM_KEY);               
                    break;
                case ESP_ERR_NVS_NOT_FOUND:
                    printf("The Device Key value is not initialized yet!\n" );
                    break;
                default :
                    printf("Error reading Device Key\n" );
            }

        #endif

        #ifdef STORE_NVS_DATA
        //TODO: add error handling
 
            // Write
            printf("-------------------------------------\n");
            printf("Writing NVS data... \n");
            
            err = nvs_set_str(my_handle, "WIFI_SSID", WIFI_SSID);
            printf("WIFI_SSID Write result(%s)\n", esp_err_to_name(err));

            err = nvs_set_str(my_handle, "WIFI_PASSWORD", WIFI_PASSWORD);
            printf("WIFI_PASSWORD Write result(%s)\n", esp_err_to_name(err));
            
            err = nvs_set_str(my_handle, "DEVICE_ID", DEVICE_ID);
            printf("DEVICE_ID Write result(%s)\n", esp_err_to_name(err));

            err = nvs_set_str(my_handle, "HUB_FQDN", HUB_FQDN);
            printf("HUB_FQDN Write result(%s)\n", esp_err_to_name(err));

            err = nvs_set_str(my_handle, "DEVICE_SYM_KEY", DEVICE_SYM_KEY);
            printf("DEVICE_SYM_KEY Write result(%s)\n", esp_err_to_name(err));   

            printf("Committing updates in NVS ... ");
            err = nvs_commit(my_handle);
            printf((err != ESP_OK) ? "Failed!\n" : "Done\n");

        #endif

        // Close
        nvs_close(my_handle);
    }

    printf("\n");

    // Restart module
    for (int i = 10; i >= 0; i--) {
        printf("Restarting in %d seconds...\n", i);
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
    printf("Restarting now.\n");
    fflush(stdout);
    esp_restart();
}