Also see: How to read ESP32 NVS value into std::string

Writing a std::string into NVS is pretty easy. You can just use .c_str() to obtain a const char* pointer and then proceed as shown in How to write string (const char*) to ESP32 NVS

You can use this utility function to write a string (const char*) into the NVS:

bool NVSWriteString(nvs_handle_t nvs, const std::string& key, const std::string& value) {
    esp_err_t err;
    if((err = nvs_set_blob(nvs, key.c_str(), value.data(), value.size())) != ESP_OK) {
        Serial.printf("Failed to write NVS key %s: %srn", key, esp_err_to_name(err));
        return false;
    }
    return true;
}

Usage example

This example is based on How to initialize NVS on ESP32. Most importantly, it assumes you have already initialized the NVS and myNVS exists and is valid.

char mySerialNo[128] = {0};

_NVS_WriteString(myNVS, "SerialNo", "0000001");

This will write the value 0000001 to the NVS with key SerialNo

Note that NVS strings are length-delimited (as in: The length is stored in the NVS) and not neccessarily NUL-terminated. This code does not store the NUL terminator in NVS.

You can find the size of a value stored in ESP32 NVS by running nvs_get_blob() with length set to a pointer to a variable with content 0, and out_value set to nullptr. nvs_get_str() works as well, the only difference is the type of the out_value argument, which does not matter at all.

It’s easier to understand if you look at this example function:

size_t NVSGetSize(nvs_handle_t nvs, const char* key) {
    esp_err_t err;
    size_t valueSize = 0;
    if((err = nvs_get_str(nvs, key, nullptr, &valueSize)) != ESP_OK) {
        if(err == ESP_ERR_NVS_NOT_FOUND) {
            // Not found, no error
            return 0;
        } else {
             // Actual error, log & return 0
            printf("Failed to get size of NVS key %s: %s\r\n", key, esp_err_to_name(err));
            return 0;
        }
    }
    return valueSize;
}

Usage example

This assumes that you have setup myNvs as we have shown in our previous post How to initialize NVS on ESP32

size_t myKeySize = NVSGetSize(myNvs, "MyKey");

Also see: How to read string (const char*) from ESP32 NVS

You can use this utility function to write a string (const char*) into the NVS:

bool _NVS_WriteString(nvs_handle_t nvs, const char* key, const char* value) {
    esp_err_t err;
    if((err = nvs_set_str(nvs, key, value)) != ESP_OK) {
        Serial.printf("Failed to write NVS key %s: %s\r\n", key, esp_err_to_name(err));
        return false;
    }
    return true;
}

Usage example

This example is based on How to initialize NVS on ESP32. Most importantly, it assumes you have already initialized the NVS and myNVS exists and is valid.

char mySerialNo[128] = {0};

_NVS_WriteString(myNVS, "SerialNo", "0000001");

This will write the value 0000001 to the NVS with key SerialNo

Note that NVS strings are length-delimited (as in: The length is stored in the NVS) and not neccessarily NUL-terminated. This code does not store the NUL terminator in NVS.

Also see: How to write string (const char*) to ESP32 NVS

You can use this utility function to read a string:

bool _NVS_ReadString(nvs_handle_t nvs, const char* key, char* value, size_t maxSize) {
    esp_err_t err;
    if((err = nvs_get_str(nvs, key, value, &maxSize)) != ESP_OK) {
        Serial.printf("Failed to read NVS key %s: %s\r\n", key, esp_err_to_name(err));
        return false;
    }
    return true;
}

Usage example

This example is based on How to initialize NVS on ESP32. Most importantly, it assumes you have already initialized the NVS and myNVS exists and is valid.

char mySerialNo[128] = {0};

_NVS_ReadString(myNVS, "SerialNo", mySerialNo, 128-1);

This will read the NVS entry with key SerialNo into the buffer mySerialNo. Note that we are using 128-1 as size, even though the buffer has a size of 128. This is to ensure that there is ALWAYS a terminating NUL character at the last value of the buffer.

Note that NVS strings are length-delimited (as in: The length is stored in the NVS) and not neccessarily NUL-terminated. I recommend to not store the NUL terminator in the NVS.

First, include the ESP32 NVS library using:

#include <nvs.h>

Globally, declare

nvs_handle_t myNVS = 0;

Then you can

void InitNVS() {
    esp_err_t err;
    if((err = nvs_open("MyLabel", NVS_READWRITE, &myNVS)) != ESP_OK) {
        Serial.printf("Failed to open NVS: %s\r\n", esp_err_to_name(err));
        return;
    }
}

You can choose MyLabel arbitrarily, as long as the string isn’t too long. My recommendation is to choose a unique identifier for your application.