ESP32 Forum

Code: Select all

/*
 * Save any kind of structure into NVS by a Module/Key
 * Module Handler must have a valid value.
 */
esp_err_t ConfigurationHandler::saveDataToModule(nvs_handle *moduleHandler, String key, void* data, size_t size)
{
	Serial.printf("\r\nSaving data with key: '%s'", key.c_str());
	esp_err_t opResult = nvs_set_blob(*moduleHandler, key.c_str(), data, size);

	delay(500);
	opResult = nvs_commit(*moduleHandler);
	delay(500);

	if (opResult == ESP_OK)
		Serial.println("\r\nData saved");
	else
		Serial.println("\r\nData could not be saved");


	return opResult;
}

Code: Select all

/**
 * Defines a Device
 */
struct DeviceNVS
{
	char name[CHAR_NORMAL_ARRAY_SIZE];
	SystemElementId systemElementId;			// enum
	ConnectedDeviceType connectedDeviceType;	// enum
	SystemPinOrMask pinOrMask;					// enum
	uint8_t enabled;
};

Code: Select all

		// Relays
		for (int i=0; i<relays.size(); i++)
		{
			DeviceNVS device = relays.get(i)->toDeviceNVS();
			String key(CONFIGURATION_KEY_RELAYS);
			key += i;
			saveDataToModule(&moduleHandler, key, &device, sizeof(DeviceNVS));
		}

Code: Select all

       return nvs_open("NVS module name here", openMode, moduleHandler);

Code: Select all

SystemNVS (64bytes) -> 1 main struct
   Subsystem_1_NVS (32 bytes) -> 10 max structs (reserve space)
      Sybsystem_1_1_NVS (50 bytes) -> 20 max structs (reserve space)
   Subsystem_2_NVS (16 bytes) -> 5 max structs (reserve space)
   Subsystem_3_NVS  (100 bytes) -> 15 max structs( reserve space)
...
and so on.

Code: Select all

#include "freertos/FreeRTOS.h"
#include "esp_wifi.h"
#include "esp_system.h"
#include "esp_event.h"
#include "esp_event_loop.h"
#include "nvs_flash.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "nvs.h"

const char * MODULE = "TEST_MOD";
const char * KEY = "TEST_KEY";
const int DELAY = 5;
const int NUMBER_OF_TESTS = 100;
const char * tag = "NVS_TESTS";
const char * tagSecond = "SECOND_TASK";

const int SECOND_TASK_CORE = 0;

struct TestNVSStruct
{
	char name[32];
	int myInt;
	float myFloat;	
	int myIntArray[10];
}testStruct;

/** Second Dummy Task */ 
void secondDummyTask(void *data)
{
	for(;;)
	{		
		vTaskDelay(100 / portTICK_PERIOD_MS);
		testStruct.myFloat += testStruct.myInt;
	}
}


/** Main App Task */
void app_main(void)
{
    nvs_flash_init();	
	ESP_LOGI(tag, "STARTING SECOND DUMMY TASK");
	xTaskCreatePinnedToCore(&secondDummyTask, "secondDummyTask", 4096, NULL, 5, NULL, SECOND_TASK_CORE);	
	
	ESP_LOGI(tag, "STARTING NVS TESTS IN 5 SECONDS");
	vTaskDelay(5000 / portTICK_PERIOD_MS);
	int testCompleted = 0;

    while (true) 
	{		
		for (int i=1; i<=NUMBER_OF_TESTS && testCompleted == 0; i++)
		{
			ESP_LOGI(tag, "NVS Test number %d", i);


			testStruct.myInt = i;
			
			nvs_handle moduleHandler;
			ESP_ERROR_CHECK(nvs_open(MODULE, NVS_READWRITE, &moduleHandler));
			vTaskDelay(DELAY / portTICK_PERIOD_MS);			
			ESP_ERROR_CHECK(nvs_set_blob(moduleHandler, KEY, &testStruct, sizeof(testStruct)));
			vTaskDelay(DELAY / portTICK_PERIOD_MS);			
			ESP_ERROR_CHECK(nvs_commit(moduleHandler));	
			vTaskDelay(DELAY / portTICK_PERIOD_MS);
			nvs_close(moduleHandler);	
			ESP_LOGI(tag, "NVS Test number %d Completed, waiting 1 seconds to do next\r\n\r\n", i);			
			
			vTaskDelay(1000 / portTICK_PERIOD_MS);
		}
		
		if (testCompleted == 0)
		{
			ESP_LOGI(tag, "NVS TESTS COMPLETED");
			testCompleted = 1;
		}
		
		vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

Code: Select all

/** Waits until the System is ready for an Update */
void UpdateSystemHelper::waitForSystemUpdatePreparation()
{
	Serial.println("UPDATE STARTED");
	updateRequestACK = false;
	updateInProgress = true;
	delay(50);

	// Wait for Update ACK
	while(!updateRequestACK) // This flag is set by the main app (not the caller to the update)
	{
		Serial.println("Update task waiting for Request ACK");
		delay(100);
	}

	vTaskEnterCritical(&mux);
	delay(50);
	suspendMainTask();
	delay(50);
}


/** Calls the Update to be completed */
void UpdateSystemHelper::updateCompleted()
{
	Serial.println("UPDATE COMPLETED");
	updateInProgress = false;
	updateRequestACK = false;
	vTaskExitCritical(&mux);
	delay(50);
	resumeMainTask();
	delay(50);
}

boolean UpdateSystemHelper::suspendMainTask()
{
	Serial.println("Suspending Main Task");
	vTaskSuspend(mainTaskHandler);
	return true;

}

boolean UpdateSystemHelper::resumeMainTask()
{
	Serial.println("Resuming Main Task");
	vTaskResume(mainTaskHandler);
	return true;
}

Code: Select all

// This code happens in the secondary task (web server)
updateSystem->waitForSystemUpdatePreparation();
esp_err_t opResult = configHandler->saveConfiguration(); // this is where NVS writing happens
updateSystem->updateCompleted();

// This code happens in the main task 
// Check for updates
if (updateSystem.isUpdateInProgress())
{
      updateSystem.acknowledgeUpdateRequest();
      while(updateSystem.isUpdateInProgress())
            delay(250);
}