1118 lines
28 KiB
C
1118 lines
28 KiB
C
/*
|
|
* nvm.c
|
|
*
|
|
* Created on: Aug 14, 2023
|
|
* Author: Sword
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include "nvs_flash.h"
|
|
#include "nvs.h"
|
|
#include "esp_system.h"
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/task.h"
|
|
#include <string.h>
|
|
#include "hmi.h"
|
|
#include "nvm.h"
|
|
#include "main.h"
|
|
|
|
static const char* TAG = "NVM";
|
|
|
|
#define LOG_LOCAL_LEVEL ESP_LOG_INFO
|
|
#include "esp_log.h"
|
|
|
|
|
|
nvs_handle_t my_handle;
|
|
|
|
RTC_DATA_ATTR static uint8_t last_posted_sector;
|
|
|
|
extern uint8_t onBoarded;
|
|
|
|
|
|
/**/
|
|
void nvm_init(void)
|
|
{
|
|
/* Initialize the dedicated NVS partition */
|
|
esp_err_t ret = nvs_flash_init();
|
|
|
|
/* Check if NVS partition doesn't contain any empty pages or contains data in new format and cannot be recognized by this version of code */
|
|
if((ret == ESP_ERR_NVS_NO_FREE_PAGES) || (ret == ESP_ERR_NVS_NEW_VERSION_FOUND))
|
|
{
|
|
/* If so ----> then erase the NVS partition reinitialize it one more time*/
|
|
ESP_ERROR_CHECK(nvs_flash_erase());
|
|
|
|
/* reinitialize NVS partition one more time */
|
|
ret = nvs_flash_init();
|
|
}
|
|
|
|
//Check that there is no problem with initializing NVS partition
|
|
ESP_ERROR_CHECK(ret);
|
|
}
|
|
|
|
/**/
|
|
void nvm_clear(void)
|
|
{
|
|
/* erase the NVS partition */
|
|
ESP_ERROR_CHECK(nvs_flash_erase());
|
|
}
|
|
|
|
|
|
|
|
/**/
|
|
uint8_t nvm_read_onboarding_flag(onboarding_type_t flag_key)
|
|
{
|
|
uint8_t onBoarding;
|
|
|
|
/*Storing the on-boarding value in the NVS so that to indicate that each time power on/off the value would be the same*/
|
|
//ESP_LOGI(TAG,"Opening Non-Volatile Storage (NVS) handle... ");
|
|
esp_err_t err = nvs_open("storage", NVS_READWRITE, &my_handle);
|
|
|
|
/* Make sure that NVS is initialized */
|
|
if(ESP_ERR_NVS_NOT_INITIALIZED == err)
|
|
{
|
|
/* initialized it if not */
|
|
err = nvs_flash_init();
|
|
|
|
/* Check if the response is OK then OPEN it */
|
|
if(err == ESP_OK)
|
|
{
|
|
/* Retry to open the NVS */
|
|
err = nvs_open("storage", NVS_READWRITE, &my_handle);
|
|
}
|
|
else
|
|
{
|
|
/* Print this LOG if failed to initialize it */
|
|
ESP_LOGI(TAG,"Failed to reinitialized The NVS partition");
|
|
}
|
|
}
|
|
|
|
if (err != ESP_OK)
|
|
{
|
|
ESP_LOGI(TAG,"Error (%s) opening NVS handle!\n", esp_err_to_name(err));
|
|
}
|
|
else
|
|
{
|
|
//ESP_LOGI(TAG,"Done\nReading on-boarding value from NVS ... ");
|
|
|
|
if(WIFI_ONBOARDING_KEY == flag_key)
|
|
{
|
|
err = nvs_get_u8(my_handle, NVM_WIFI_ONBOARDING_KEY, &onBoarding);
|
|
}
|
|
else
|
|
{
|
|
err = nvs_get_u8(my_handle, NVM_CELL_ONBOARDING_KEY, &onBoarding);
|
|
}
|
|
|
|
switch (err)
|
|
{
|
|
case ESP_OK:
|
|
|
|
ESP_LOGI(TAG,"On-Boarding = %d\n",onBoarding);
|
|
|
|
// Close the opened NVS
|
|
nvs_close(my_handle);
|
|
|
|
return onBoarding;
|
|
|
|
break;
|
|
|
|
case ESP_ERR_NVS_NOT_FOUND:
|
|
ESP_LOGI(TAG,"The on-boarding value is not initialized yet!\n");
|
|
break;
|
|
|
|
default:
|
|
ESP_LOGI(TAG,"Error (%s) reading!\n", esp_err_to_name(err));
|
|
}
|
|
}
|
|
|
|
// Close the opened NVS
|
|
nvs_close(my_handle);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
/**/
|
|
void nvm_write_onboarding_flag(onboarding_type_t flag_key, uint8_t flag_value)
|
|
{
|
|
esp_err_t err;
|
|
|
|
/*Storing the on-boarding value in the NVS so that to indicate that each time power on/off the value would be the same*/
|
|
//ESP_LOGI(TAG,"Opening Non-Volatile Storage (NVS) handle... ");
|
|
err = nvs_open("storage", NVS_READWRITE, &my_handle);
|
|
|
|
/* Make sure that NVS is initialized */
|
|
if(ESP_ERR_NVS_NOT_INITIALIZED == err)
|
|
{
|
|
/* initialized it if not */
|
|
err = nvs_flash_init();
|
|
|
|
/* Check if the response is OK then OPEN it */
|
|
if(err == ESP_OK)
|
|
{
|
|
/* Retry to open the NVS */
|
|
err = nvs_open("storage", NVS_READWRITE, &my_handle);
|
|
}
|
|
else
|
|
{
|
|
/* Print this LOG if failed to initialize it */
|
|
ESP_LOGI(TAG,"Failed to reinitialized The NVS partition");
|
|
}
|
|
}
|
|
|
|
if (err != ESP_OK)
|
|
{
|
|
ESP_LOGI(TAG,"Error (%s) opening NVS handle!\n", esp_err_to_name(err));
|
|
}
|
|
else
|
|
{
|
|
//ESP_LOGI(TAG,"Done\nUpdating on-boarding value in NVS ... ");
|
|
|
|
if(WIFI_ONBOARDING_KEY == flag_key)
|
|
{
|
|
err = nvs_set_u8(my_handle, NVM_WIFI_ONBOARDING_KEY, flag_value);
|
|
}
|
|
else
|
|
{
|
|
err = nvs_set_u8(my_handle, NVM_CELL_ONBOARDING_KEY, flag_value);
|
|
}
|
|
|
|
if (err != ESP_OK)
|
|
{
|
|
ESP_LOGI(TAG,"Failed");
|
|
}
|
|
else
|
|
{
|
|
//ESP_LOGI(TAG,"Done");
|
|
}
|
|
|
|
// Commit written value.
|
|
// After setting any values, nvs_commit() must be called to ensure changes are written
|
|
// to flash storage. Implementations may write to storage at other times,
|
|
// but this is not guaranteed.
|
|
hmi_stop_red_flashing();
|
|
|
|
//ESP_LOGI(TAG,"Committing updates in NVS ... ");
|
|
|
|
err = nvs_commit(my_handle);
|
|
|
|
if (err != ESP_OK)
|
|
{
|
|
ESP_LOGI(TAG,"Failed Updating on-boarding value in NVS");
|
|
}
|
|
else
|
|
{
|
|
ESP_LOGI(TAG,"Done Updating on-boarding value in NVS");
|
|
}
|
|
}
|
|
|
|
// Close the opened NVS
|
|
nvs_close(my_handle);
|
|
}
|
|
|
|
|
|
|
|
/**/
|
|
uint8_t nvm_read_comms_mode(void)
|
|
{
|
|
uint8_t commsMode;
|
|
esp_err_t err;
|
|
|
|
/*Storing the on-boarding value in the NVS so that to indicate that each time power on/off the value would be the same*/
|
|
//ESP_LOGI(TAG,"Opening Non-Volatile Storage (NVS) handle... ");
|
|
err = nvs_open("storage", NVS_READWRITE, &my_handle);
|
|
|
|
/* Make sure that NVS is initialized */
|
|
if(ESP_ERR_NVS_NOT_INITIALIZED == err)
|
|
{
|
|
/* initialized it if not */
|
|
err = nvs_flash_init();
|
|
|
|
/* Check if the response is OK then OPEN it */
|
|
if(err == ESP_OK)
|
|
{
|
|
/* Retry to open the NVS */
|
|
err = nvs_open("storage", NVS_READWRITE, &my_handle);
|
|
}
|
|
else
|
|
{
|
|
/* Print this LOG if failed to initialize it */
|
|
ESP_LOGI(TAG,"Failed to reinitialized The NVS partition");
|
|
}
|
|
}
|
|
|
|
if (err != ESP_OK)
|
|
{
|
|
ESP_LOGI(TAG,"Error (%s) opening NVS handle!\n", esp_err_to_name(err));
|
|
}
|
|
else
|
|
{
|
|
//ESP_LOGI(TAG,"Done\nReading Communication-Mode value from NVS ... ");
|
|
|
|
err = nvs_get_u8(my_handle, NVM_COMMS_MODE_KEY, &commsMode);
|
|
|
|
switch (err)
|
|
{
|
|
case ESP_OK:
|
|
|
|
ESP_LOGI(TAG,"Communication Mode = %d\n",commsMode);
|
|
|
|
// Close the opened NVS
|
|
nvs_close(my_handle);
|
|
|
|
return commsMode;
|
|
|
|
break;
|
|
|
|
case ESP_ERR_NVS_NOT_FOUND:
|
|
ESP_LOGI(TAG,"The Communication-Mode value is not initialized yet!\n");
|
|
break;
|
|
|
|
default:
|
|
ESP_LOGI(TAG,"Error (%s) reading!\n", esp_err_to_name(err));
|
|
}
|
|
}
|
|
|
|
// Close the opened NVS
|
|
nvs_close(my_handle);
|
|
|
|
return DEFAULT_COMMS_MODE;
|
|
|
|
}
|
|
|
|
/**/
|
|
void nvm_write_comms_mode(uint8_t commsMode)
|
|
{
|
|
esp_err_t err;
|
|
|
|
/*Storing the on-boarding value in the NVS so that to indicate that each time power on/off the value would be the same*/
|
|
//ESP_LOGI(TAG,"Opening Non-Volatile Storage (NVS) handle... ");
|
|
err = nvs_open("storage", NVS_READWRITE, &my_handle);
|
|
|
|
/* Make sure that NVS is initialized */
|
|
if(ESP_ERR_NVS_NOT_INITIALIZED == err)
|
|
{
|
|
/* initialized it if not */
|
|
err = nvs_flash_init();
|
|
|
|
/* Check if the response is OK then OPEN it */
|
|
if(err == ESP_OK)
|
|
{
|
|
/* Retry to open the NVS */
|
|
err = nvs_open("storage", NVS_READWRITE, &my_handle);
|
|
}
|
|
else
|
|
{
|
|
/* Print this LOG if failed to initialize it */
|
|
ESP_LOGI(TAG,"Failed to reinitialized The NVS partition");
|
|
}
|
|
}
|
|
|
|
if (err != ESP_OK)
|
|
{
|
|
ESP_LOGI(TAG,"Error (%s) opening NVS handle!\n", esp_err_to_name(err));
|
|
}
|
|
else
|
|
{
|
|
//ESP_LOGI(TAG,"Done\nUpdating Communication-Mode value in NVS ... ");
|
|
|
|
err = nvs_set_u8(my_handle, NVM_COMMS_MODE_KEY, commsMode);
|
|
|
|
if (err != ESP_OK)
|
|
{
|
|
ESP_LOGI(TAG,"Failed");
|
|
}
|
|
else
|
|
{
|
|
//ESP_LOGI(TAG,"Done");
|
|
}
|
|
|
|
//ESP_LOGI(TAG,"Committing updates in NVS ... ");
|
|
|
|
err = nvs_commit(my_handle);
|
|
|
|
if (err != ESP_OK)
|
|
{
|
|
ESP_LOGI(TAG,"Failed Updating Communication-Mode value in NVS");
|
|
}
|
|
else
|
|
{
|
|
ESP_LOGI(TAG,"Done Updating Communication-Mode value in NVS");
|
|
}
|
|
}
|
|
|
|
// Close the opened NVS
|
|
nvs_close(my_handle);
|
|
}
|
|
|
|
|
|
|
|
/**/
|
|
esp_err_t nvm_read_wifi_credentials(char* ssid, char* pswd)
|
|
{
|
|
esp_err_t err;
|
|
size_t ssid_len;
|
|
size_t pswd_len;
|
|
|
|
/*Storing the on-boarding value in the NVS so that to indicate that each time power on/off the value would be the same*/
|
|
//ESP_LOGI(TAG,"Opening Non-Volatile Storage (NVS) handle... ");
|
|
err = nvs_open("storage", NVS_READWRITE, &my_handle);
|
|
|
|
/* Make sure that NVS is initialized */
|
|
if(ESP_ERR_NVS_NOT_INITIALIZED == err)
|
|
{
|
|
/* initialized it if not */
|
|
err = nvs_flash_init();
|
|
|
|
/* Check if the response is OK then OPEN it */
|
|
if(err == ESP_OK)
|
|
{
|
|
/* Retry to open the NVS */
|
|
err = nvs_open("storage", NVS_READWRITE, &my_handle);
|
|
}
|
|
else
|
|
{
|
|
/* Print this LOG if failed to initialize it */
|
|
ESP_LOGI(TAG,"Failed to reinitialized The NVS partition");
|
|
}
|
|
}
|
|
|
|
/* Make sure that NVS storage has been opened successfully */
|
|
if (err != ESP_OK)
|
|
{
|
|
ESP_LOGI(TAG,"Error (%s) opening NVS handle!\n", esp_err_to_name(err));
|
|
}
|
|
else
|
|
{
|
|
/* Get the length of the WIFI-SSID */
|
|
nvs_get_str(my_handle, NVM_WIFI_SSID_KEY, NULL, (size_t*)&ssid_len);
|
|
|
|
/* Get the length of the WIFI-PSWD */
|
|
nvs_get_str(my_handle, NVM_WIFI_PSWD_KEY, NULL, (size_t*)&pswd_len);
|
|
|
|
//ESP_LOGI(TAG,"NVM-SSID len = %d, and NVM-PWD len = %d",ssid_len,pswd_len);
|
|
|
|
//char* sid = malloc(ssid_len);
|
|
//char* pwd = malloc(pswd_len);
|
|
|
|
/* Retrieve the WIFI-SSID */
|
|
if(ESP_OK == err)
|
|
err = nvs_get_str(my_handle, (const char*)NVM_WIFI_SSID_KEY, ssid, (size_t*)&ssid_len);
|
|
|
|
/* Retrieve the WIFI-PSWD */
|
|
if(ESP_OK == err)
|
|
err = nvs_get_str(my_handle, (const char*)NVM_WIFI_PSWD_KEY, pswd, (size_t*)&pswd_len);
|
|
|
|
/* Check the result of the NVS reading */
|
|
switch (err)
|
|
{
|
|
case ESP_OK:
|
|
|
|
//strcpy(ssid,sid);
|
|
//strcpy(pswd,pwd);
|
|
ESP_LOGI(TAG,"WIFI_SSID is: %s and WIFI_PSWD is: %s",ssid,pswd);
|
|
break;
|
|
|
|
case ESP_ERR_NVS_NOT_FOUND:
|
|
ESP_LOGI(TAG,"The WIFI_Credentials not initialized yet!\n");
|
|
break;
|
|
|
|
default:
|
|
ESP_LOGI(TAG,"Error (%s) reading!\n", esp_err_to_name(err));
|
|
}
|
|
|
|
//free(sid);
|
|
//free(pwd);
|
|
}
|
|
|
|
// Close the opened NVS
|
|
nvs_close(my_handle);
|
|
|
|
return err;
|
|
}
|
|
|
|
/**/
|
|
void nvm_write_wifi_credentials(char* ssid, uint8_t ssid_len, char* pswd, uint8_t pswd_len)
|
|
{
|
|
esp_err_t err;
|
|
|
|
/*Storing the on-boarding value in the NVS so that to indicate that each time power on/off the value would be the same*/
|
|
//ESP_LOGI(TAG,"Opening Non-Volatile Storage (NVS) handle... ");
|
|
err = nvs_open("storage", NVS_READWRITE, &my_handle);
|
|
|
|
/* Make sure that NVS is initialized */
|
|
if(ESP_ERR_NVS_NOT_INITIALIZED == err)
|
|
{
|
|
/* initialized it if not */
|
|
err = nvs_flash_init();
|
|
|
|
/* Check if the response is OK then OPEN it */
|
|
if(err == ESP_OK)
|
|
{
|
|
/* Retry to open the NVS */
|
|
err = nvs_open("storage", NVS_READWRITE, &my_handle);
|
|
}
|
|
else
|
|
{
|
|
/* Print this LOG if failed to initialize it */
|
|
ESP_LOGE(TAG,"Failed to reinitialized The NVS partition");
|
|
}
|
|
}
|
|
|
|
/* Make sure that NVS storage has been opened successfully */
|
|
if (err != ESP_OK)
|
|
{
|
|
ESP_LOGE(TAG,"Error (%s) opening NVS handle!\n", esp_err_to_name(err));
|
|
}
|
|
else
|
|
{
|
|
//ESP_LOGI(TAG,"Done\nUpdating WIFI-Credentials in NVS ... ");
|
|
|
|
/* Store the WIFI-SSID string in NVS */
|
|
err = nvs_set_str(my_handle, (const char*)NVM_WIFI_SSID_KEY, (const char*)ssid);
|
|
|
|
/* If WIFI-SSID stored successfully in NVS then ---> Store the WIFI-PSWD string in NVS */
|
|
if(ESP_OK == err)
|
|
err = nvs_set_str(my_handle, (const char*)NVM_WIFI_PSWD_KEY, (const char*)pswd);
|
|
|
|
/* Inform the user with one of these logs to indicate failing or succeeding to store wifi-credentials */
|
|
if (err != ESP_OK)
|
|
{
|
|
ESP_LOGE(TAG,"Failed");
|
|
}
|
|
else
|
|
{
|
|
//ESP_LOGI(TAG,"Done");
|
|
}
|
|
|
|
// Commit written value.
|
|
// After setting any values, nvs_commit() must be called to ensure changes are written
|
|
// to flash storage. Implementations may write to storage at other times,
|
|
// but this is not guaranteed.
|
|
|
|
//ESP_LOGI(TAG,"Committing updates in NVS ... ");
|
|
|
|
err = nvs_commit(my_handle);
|
|
|
|
if (err != ESP_OK)
|
|
{
|
|
ESP_LOGE(TAG,"Failed Updating WIFI-Credentials in NVS");
|
|
}
|
|
else
|
|
{
|
|
ESP_LOGI(TAG,"Done Updating WIFI-Credentials in NVS");
|
|
}
|
|
}
|
|
|
|
// Close the opened NVS
|
|
nvs_close(my_handle);
|
|
}
|
|
|
|
|
|
#if 0
|
|
/**/
|
|
void nvm_read_wifi_backup_credentials(char* ssid, char* pswd, char* key1, char* key2)
|
|
{
|
|
esp_err_t err;
|
|
size_t ssid_len;
|
|
size_t pswd_len;
|
|
|
|
/*Storing the on-boarding value in the NVS so that to indicate that each time power on/off the value would be the same*/
|
|
ESP_LOGI(TAG,"Opening Non-Volatile Storage (NVS) handle... ");
|
|
err = nvs_open("storage", NVS_READWRITE, &my_handle);
|
|
|
|
/* Make sure that NVS is initialized */
|
|
if(ESP_ERR_NVS_NOT_INITIALIZED == err)
|
|
{
|
|
/* initialized it if not */
|
|
err = nvs_flash_init();
|
|
|
|
/* Check if the response is OK then OPEN it */
|
|
if(err == ESP_OK)
|
|
{
|
|
/* Retry to open the NVS */
|
|
err = nvs_open("storage", NVS_READWRITE, &my_handle);
|
|
}
|
|
else
|
|
{
|
|
/* Print this LOG if failed to initialize it */
|
|
ESP_LOGI(TAG,"Failed to reinitialized The NVS partition");
|
|
}
|
|
}
|
|
|
|
/* Make sure that NVS storage has been opened successfully */
|
|
if (err != ESP_OK)
|
|
{
|
|
ESP_LOGI(TAG,"Error (%s) opening NVS handle!\n", esp_err_to_name(err));
|
|
}
|
|
else
|
|
{
|
|
/* Get the length of the WIFI-SSID */
|
|
nvs_get_str(my_handle, key1, NULL, (size_t*)&ssid_len);
|
|
|
|
/* Get the length of the WIFI-PSWD */
|
|
nvs_get_str(my_handle, key2, NULL, (size_t*)&pswd_len);
|
|
|
|
ESP_LOGI(TAG,"NVM-SSID len = %d, and NVM-PWD len = %d",ssid_len,pswd_len);
|
|
|
|
//char* sid = malloc(ssid_len);
|
|
//char* pwd = malloc(pswd_len);
|
|
|
|
/* Retrieve the WIFI-SSID */
|
|
if(ESP_OK == err)
|
|
err = nvs_get_str(my_handle, (const char*)key1, ssid, (size_t*)&ssid_len);
|
|
|
|
/* Retrieve the WIFI-PSWD */
|
|
if(ESP_OK == err)
|
|
err = nvs_get_str(my_handle, (const char*)key2, pswd, (size_t*)&pswd_len);
|
|
|
|
/* Check the result of the NVS reading */
|
|
switch (err)
|
|
{
|
|
case ESP_OK:
|
|
|
|
//strcpy(ssid,sid);
|
|
//strcpy(pswd,pwd);
|
|
ESP_LOGI(TAG,"WIFI_SSID is: %s and WIFI_PSWD is: %s",ssid,pswd);
|
|
break;
|
|
|
|
case ESP_ERR_NVS_NOT_FOUND:
|
|
ESP_LOGI(TAG,"The WIFI_Credentials not initialized yet!\n");
|
|
break;
|
|
|
|
default:
|
|
ESP_LOGI(TAG,"Error (%s) reading!\n", esp_err_to_name(err));
|
|
}
|
|
|
|
//free(sid);
|
|
//free(pwd);
|
|
}
|
|
|
|
// Close the opened NVS
|
|
nvs_close(my_handle);
|
|
}
|
|
|
|
/**/
|
|
void nvm_write_wifi_backup_credentials(char* ssid1, char* pswd1, char* ssid2, char* pswd2)
|
|
{
|
|
esp_err_t err;
|
|
|
|
/*Storing the on-boarding value in the NVS so that to indicate that each time power on/off the value would be the same*/
|
|
ESP_LOGI(TAG,"Opening Non-Volatile Storage (NVS) handle... ");
|
|
err = nvs_open("storage", NVS_READWRITE, &my_handle);
|
|
|
|
/* Make sure that NVS is initialized */
|
|
if(ESP_ERR_NVS_NOT_INITIALIZED == err)
|
|
{
|
|
/* initialized it if not */
|
|
err = nvs_flash_init();
|
|
|
|
/* Check if the response is OK then OPEN it */
|
|
if(err == ESP_OK)
|
|
{
|
|
/* Retry to open the NVS */
|
|
err = nvs_open("storage", NVS_READWRITE, &my_handle);
|
|
}
|
|
else
|
|
{
|
|
/* Print this LOG if failed to initialize it */
|
|
ESP_LOGE(TAG,"Failed to reinitialized The NVS partition");
|
|
}
|
|
}
|
|
|
|
/* Make sure that NVS storage has been opened successfully */
|
|
if (err != ESP_OK)
|
|
{
|
|
ESP_LOGE(TAG,"Error (%s) opening NVS handle!\n", esp_err_to_name(err));
|
|
}
|
|
else
|
|
{
|
|
ESP_LOGI(TAG,"Done\nUpdating WIFI-Credentials in NVS ... ");
|
|
|
|
/* Store the WIFI-SSID string in NVS */
|
|
err = nvs_set_str(my_handle, (const char*)NVM_WIFI_SSID_KEY, (const char*)ssid);
|
|
|
|
/* If WIFI-SSID stored successfully in NVS then ---> Store the WIFI-PSWD string in NVS */
|
|
if(ESP_OK == err)
|
|
err = nvs_set_str(my_handle, (const char*)NVM_WIFI_PSWD_KEY, (const char*)pswd);
|
|
|
|
/* Inform the user with one of these logs to indicate failing or succeeding to store wifi-credentials */
|
|
if (err != ESP_OK)
|
|
{
|
|
ESP_LOGE(TAG,"Failed");
|
|
}
|
|
else
|
|
{
|
|
ESP_LOGI(TAG,"Done");
|
|
}
|
|
|
|
// Commit written value.
|
|
// After setting any values, nvs_commit() must be called to ensure changes are written
|
|
// to flash storage. Implementations may write to storage at other times,
|
|
// but this is not guaranteed.
|
|
|
|
ESP_LOGI(TAG,"Committing updates in NVS ... ");
|
|
|
|
err = nvs_commit(my_handle);
|
|
|
|
if (err != ESP_OK)
|
|
{
|
|
ESP_LOGE(TAG,"Failed");
|
|
}
|
|
else
|
|
{
|
|
ESP_LOGI(TAG,"Done");
|
|
}
|
|
}
|
|
|
|
// Close the opened NVS
|
|
nvs_close(my_handle);
|
|
}
|
|
#endif
|
|
|
|
|
|
/**/
|
|
void nvm_write_history_data(historyLog_t* history_data)
|
|
{
|
|
esp_err_t err;
|
|
size_t required_size = 0; // value will default to 0, if not set yet in NVS
|
|
|
|
char key_str[18];
|
|
uint8_t sector_counter = 1;
|
|
|
|
/*Storing the on-boarding value in the NVS so that to indicate that each time power on/off the value would be the same*/
|
|
//ESP_LOGI(TAG,"Opening Non-Volatile Storage (NVS) handle... ");
|
|
err = nvs_open("storage", NVS_READWRITE, &my_handle);
|
|
|
|
/* Make sure that NVS is initialized */
|
|
if(ESP_ERR_NVS_NOT_INITIALIZED == err)
|
|
{
|
|
/* initialized it if not */
|
|
err = nvs_flash_init();
|
|
|
|
/* Check if the response is OK then OPEN it */
|
|
if(err == ESP_OK)
|
|
{
|
|
/* Retry to open the NVS */
|
|
err = nvs_open("storage", NVS_READWRITE, &my_handle);
|
|
}
|
|
else
|
|
{
|
|
/* Print this LOG if failed to initialize it */
|
|
ESP_LOGE(TAG,"Failed to reinitialized The NVS partition");
|
|
}
|
|
}
|
|
|
|
/* Make sure that NVS storage has been opened successfully */
|
|
if (err != ESP_OK)
|
|
{
|
|
ESP_LOGE(TAG,"Error (%s) opening NVS handle!\n", esp_err_to_name(err));
|
|
}
|
|
else
|
|
{
|
|
do
|
|
{
|
|
/* Setup the NVS sector to write to */
|
|
sprintf(key_str,NVM_HISTORY_DATA_KEY,sector_counter);
|
|
|
|
/* get the size of the history space */
|
|
err = nvs_get_blob(my_handle, key_str, NULL, &required_size);
|
|
|
|
/* Check if we can store data at that sector or not*/
|
|
if(required_size >= (NVM_MAX_NUMBER_OF_IN_ONE_SECTOR*sizeof(historyLog_t)))
|
|
{
|
|
/* Reset the required_size again to 0 */
|
|
required_size = 0;
|
|
|
|
/* if not then check the next sector */
|
|
sector_counter++;
|
|
}
|
|
else
|
|
{
|
|
/* if yes then increase the size of data to be stored by one element */
|
|
required_size += sizeof(historyLog_t);
|
|
break;
|
|
}
|
|
}while(sector_counter <= NVM_NUMBER_OF_SECTORS);
|
|
|
|
/* Make sure that there are some free sectors to store data in */
|
|
if(sector_counter <= NVM_NUMBER_OF_SECTORS)
|
|
{
|
|
/* set the new values for the history data */
|
|
err = nvs_set_blob(my_handle, key_str, history_data, required_size);
|
|
|
|
if (err != ESP_OK && err != ESP_ERR_NVS_NOT_FOUND)
|
|
ESP_LOGI(TAG," ---> History space not there");
|
|
|
|
if (required_size == 0)
|
|
{
|
|
ESP_LOGI(TAG," ---> Nothing saved yet");
|
|
}
|
|
else
|
|
{
|
|
// Commit
|
|
err = nvs_commit(my_handle);
|
|
if (err == ESP_OK)
|
|
ESP_LOGI(TAG," ---> the new history data has been committed successfully to nvm-sector %d\nand its size now is %d (max allowed size is %d)",sector_counter,required_size,(NVM_MAX_NUMBER_OF_IN_ONE_SECTOR*sizeof(historyLog_t)));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ESP_LOGE(TAG," ----> All the NVM sectors are full. can't store additional data");
|
|
}
|
|
}
|
|
|
|
// Close
|
|
nvs_close(my_handle);
|
|
}
|
|
|
|
/**/
|
|
size_t nvm_read_history_data(historyLog_t* history_data, uint8_t sector_number)
|
|
{
|
|
esp_err_t err;
|
|
size_t required_size = 0; // value will default to 0, if not set yet in NVS
|
|
|
|
char key_str[18];
|
|
|
|
/*Storing the on-boarding value in the NVS so that to indicate that each time power on/off the value would be the same*/
|
|
//ESP_LOGI(TAG,"Opening Non-Volatile Storage (NVS) handle... ");
|
|
err = nvs_open("storage", NVS_READWRITE, &my_handle);
|
|
|
|
/* Make sure that NVS is initialized */
|
|
if(ESP_ERR_NVS_NOT_INITIALIZED == err)
|
|
{
|
|
/* initialized it if not */
|
|
err = nvs_flash_init();
|
|
|
|
/* Check if the response is OK then OPEN it */
|
|
if(err == ESP_OK)
|
|
{
|
|
/* Retry to open the NVS */
|
|
err = nvs_open("storage", NVS_READWRITE, &my_handle);
|
|
}
|
|
else
|
|
{
|
|
/* Print this LOG if failed to initialize it */
|
|
ESP_LOGI(TAG,"Failed to reinitialized The NVS partition");
|
|
}
|
|
}
|
|
|
|
if (err != ESP_OK)
|
|
{
|
|
ESP_LOGI(TAG,"Error (%s) opening NVS handle!\n", esp_err_to_name(err));
|
|
}
|
|
else
|
|
{
|
|
/* Setup the NVS sector to write to */
|
|
sprintf(key_str,NVM_HISTORY_DATA_KEY,sector_number);
|
|
|
|
// obtain required memory space to store blob being read from NVS
|
|
err = nvs_get_blob(my_handle, key_str, NULL, &required_size);
|
|
|
|
if (err != ESP_OK && err != ESP_ERR_NVS_NOT_FOUND)
|
|
ESP_LOGI(TAG," ---> History not found yet");
|
|
|
|
//ESP_LOGI(TAG,"History data are:");
|
|
|
|
if (required_size == 0)
|
|
{
|
|
ESP_LOGI(TAG," ---> Nothing saved yet!\n");
|
|
}
|
|
else
|
|
{
|
|
err = nvs_get_blob(my_handle, key_str, history_data, &required_size);
|
|
if (err != ESP_OK)
|
|
{
|
|
ESP_LOGI(TAG," ---> ERROR in retrieving history data for NVM sector %d",sector_number);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Close
|
|
nvs_close(my_handle);
|
|
|
|
return required_size;
|
|
}
|
|
|
|
/**/
|
|
void nvm_clear_history_sector(uint8_t sector_num)
|
|
{
|
|
esp_err_t wifi_err;
|
|
uint8_t wifi_onboarding;
|
|
uint8_t cell_onboarding;
|
|
uint8_t comms_mode;
|
|
char ssid[32] = {0};
|
|
char pswd[64] = {0};
|
|
|
|
ESP_LOGI(TAG,"Clearing NVM History Sectors After successful POST process");
|
|
|
|
/* If there are some written data in the first sector ---> then this means that you should clear it. otherwise no (just to save read-write cycles for nvs) */
|
|
if(nvm_read_history_data(NULL,1))
|
|
{
|
|
/* 1- Firstly retrieve stored data in NVS */
|
|
wifi_onboarding = nvm_read_onboarding_flag(WIFI_ONBOARDING_KEY);
|
|
cell_onboarding = nvm_read_onboarding_flag(CELL_ONBOARDING_KEY);
|
|
comms_mode = nvm_read_comms_mode();
|
|
wifi_err = nvm_read_wifi_credentials(ssid,pswd);
|
|
|
|
/* Reload the WDT */
|
|
vTaskDelay(10/portTICK_PERIOD_MS);
|
|
|
|
/* 2- Clear NVS partition */
|
|
nvm_clear();
|
|
|
|
/* Reload the WDT */
|
|
vTaskDelay(10/portTICK_PERIOD_MS);
|
|
|
|
/* 3- Store the retrieved data again in NVS */
|
|
nvm_write_onboarding_flag(WIFI_ONBOARDING_KEY,wifi_onboarding);
|
|
nvm_write_onboarding_flag(CELL_ONBOARDING_KEY,cell_onboarding);
|
|
nvm_write_comms_mode(comms_mode);
|
|
if(wifi_err == ESP_OK)
|
|
nvm_write_wifi_credentials(ssid,32,pswd,64);
|
|
}
|
|
|
|
|
|
#if 0
|
|
esp_err_t err;
|
|
char key_str[18];
|
|
|
|
/*Storing the on-boarding value in the NVS so that to indicate that each time power on/off the value would be the same*/
|
|
ESP_LOGI(TAG,"Opening Non-Volatile Storage (NVS) handle... ");
|
|
err = nvs_open("storage", NVS_READWRITE, &my_handle);
|
|
|
|
/* Make sure that NVS is initialized */
|
|
if(ESP_ERR_NVS_NOT_INITIALIZED == err)
|
|
{
|
|
/* initialized it if not */
|
|
err = nvs_flash_init();
|
|
|
|
/* Check if the response is OK then OPEN it */
|
|
if(err == ESP_OK)
|
|
{
|
|
/* Retry to open the NVS */
|
|
err = nvs_open("storage", NVS_READWRITE, &my_handle);
|
|
}
|
|
else
|
|
{
|
|
/* Print this LOG if failed to initialize it */
|
|
ESP_LOGI(TAG,"Failed to reinitialized The NVS partition");
|
|
}
|
|
}
|
|
|
|
if (err != ESP_OK)
|
|
{
|
|
ESP_LOGI(TAG,"Error (%s) opening NVS handle!\n", esp_err_to_name(err));
|
|
}
|
|
else
|
|
{
|
|
for(int sector_counter=1; sector_counter<=NVM_NUMBER_OF_SECTORS; sector_counter++)
|
|
{
|
|
/* Setup the NVS sector to clear */
|
|
sprintf(key_str,NVM_HISTORY_DATA_KEY,sector_counter);
|
|
|
|
/* Check which sector number need to be cleared */
|
|
if((sector_num == sector_counter) || ((sector_num == NVM_HISTORY_ALL_SECTORS)))
|
|
{
|
|
/* set the new values for the history data */
|
|
err = nvs_set_blob(my_handle, key_str, NULL, 0);
|
|
if(err != ESP_OK)
|
|
{
|
|
ESP_LOGI(TAG,"Failed to clear sector %d",sector_counter);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
/* Check if the sector_num isn't equal to the NVM_HISTORY_ALL_SECTORS then break the loop after first successful clear process */
|
|
if(sector_num != NVM_HISTORY_ALL_SECTORS)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
#if 0
|
|
if((sector_num == NVM_HISTORY_SECTOR_1) || ((sector_num == NVM_HISTORY_ALL_SECTORS)))
|
|
{
|
|
/* set the new values for the history data */
|
|
err = nvs_set_blob(my_handle, NVM_HISTORY_SECTOR1, NULL, 0);
|
|
if(err != ESP_OK)
|
|
{
|
|
ESP_LOGI(TAG,"Failed to clear sector 1");
|
|
}
|
|
}
|
|
|
|
if((err == ESP_OK) && ((sector_num == NVM_HISTORY_SECTOR_2) || (sector_num == NVM_HISTORY_ALL_SECTORS)))
|
|
{
|
|
/* set the new values for the history data */
|
|
err = nvs_set_blob(my_handle, NVM_HISTORY_SECTOR2, NULL, 0);
|
|
if(err != ESP_OK)
|
|
{
|
|
ESP_LOGI(TAG,"Failed to clear sector 2");
|
|
}
|
|
}
|
|
|
|
if((err == ESP_OK) && ((sector_num == NVM_HISTORY_SECTOR_3) || (sector_num == NVM_HISTORY_ALL_SECTORS)))
|
|
{
|
|
/* set the new values for the history data */
|
|
err = nvs_set_blob(my_handle, NVM_HISTORY_SECTOR3, NULL, 0);
|
|
if(err != ESP_OK)
|
|
{
|
|
ESP_LOGI(TAG,"Failed to clear sector 3");
|
|
}
|
|
}
|
|
|
|
if((err == ESP_OK) && ((sector_num == NVM_HISTORY_SECTOR_4) || (sector_num == NVM_HISTORY_ALL_SECTORS)))
|
|
{
|
|
/* set the new values for the history data */
|
|
err = nvs_set_blob(my_handle, NVM_HISTORY_SECTOR4, NULL, 0);
|
|
if(err != ESP_OK)
|
|
{
|
|
ESP_LOGI(TAG,"Failed to clear sector 4");
|
|
}
|
|
}
|
|
|
|
if((err == ESP_OK) && ((sector_num == NVM_HISTORY_SECTOR_5) || (sector_num == NVM_HISTORY_ALL_SECTORS)))
|
|
{
|
|
/* set the new values for the history data */
|
|
err = nvs_set_blob(my_handle, NVM_HISTORY_SECTOR5, NULL, 0);
|
|
if(err != ESP_OK)
|
|
{
|
|
ESP_LOGI(TAG,"Failed to clear sector 5");
|
|
}
|
|
}
|
|
|
|
if((err == ESP_OK) && ((sector_num == NVM_HISTORY_SECTOR_6) || (sector_num == NVM_HISTORY_ALL_SECTORS)))
|
|
{
|
|
/* set the new values for the history data */
|
|
err = nvs_set_blob(my_handle, NVM_HISTORY_SECTOR6, NULL, 0);
|
|
if(err != ESP_OK)
|
|
{
|
|
ESP_LOGI(TAG,"Failed to clear sector 6");
|
|
}
|
|
}
|
|
|
|
if((err == ESP_OK) && ((sector_num == NVM_HISTORY_SECTOR_7) || (sector_num == NVM_HISTORY_ALL_SECTORS)))
|
|
{
|
|
/* set the new values for the history data */
|
|
err = nvs_set_blob(my_handle, NVM_HISTORY_SECTOR7, NULL, 0);
|
|
if(err != ESP_OK)
|
|
{
|
|
ESP_LOGI(TAG,"Failed to clear sector 7");
|
|
}
|
|
}
|
|
|
|
if((err == ESP_OK) && ((sector_num == NVM_HISTORY_SECTOR_8) || (sector_num == NVM_HISTORY_ALL_SECTORS)))
|
|
{
|
|
/* set the new values for the history data */
|
|
err = nvs_set_blob(my_handle, NVM_HISTORY_SECTOR8, NULL, 0);
|
|
if(err != ESP_OK)
|
|
{
|
|
ESP_LOGI(TAG,"Failed to clear sector 8");
|
|
}
|
|
}
|
|
#endif
|
|
// err = nvs_commit(my_handle);
|
|
// }
|
|
|
|
// Close
|
|
// nvs_close(my_handle);
|
|
}
|
|
|
|
/**/
|
|
uint8_t nvm_get_last_written_history_sector(void)
|
|
{
|
|
esp_err_t err;
|
|
size_t required_size = 0; // value will default to 0, if not set yet in NVS
|
|
|
|
char key_str[18];
|
|
uint8_t sector_counter = 1;
|
|
|
|
/*Storing the on-boarding value in the NVS so that to indicate that each time power on/off the value would be the same*/
|
|
//ESP_LOGI(TAG,"Opening Non-Volatile Storage (NVS) handle... ");
|
|
err = nvs_open("storage", NVS_READWRITE, &my_handle);
|
|
|
|
/* Make sure that NVS is initialized */
|
|
if(ESP_ERR_NVS_NOT_INITIALIZED == err)
|
|
{
|
|
/* initialized it if not */
|
|
err = nvs_flash_init();
|
|
|
|
/* Check if the response is OK then OPEN it */
|
|
if(err == ESP_OK)
|
|
{
|
|
/* Retry to open the NVS */
|
|
err = nvs_open("storage", NVS_READWRITE, &my_handle);
|
|
}
|
|
else
|
|
{
|
|
/* Print this LOG if failed to initialize it */
|
|
ESP_LOGI(TAG,"Failed to reinitialized The NVS partition");
|
|
}
|
|
}
|
|
|
|
if (err != ESP_OK)
|
|
{
|
|
ESP_LOGI(TAG,"Error (%s) opening NVS handle!\n", esp_err_to_name(err));
|
|
}
|
|
else
|
|
{
|
|
do
|
|
{
|
|
/* Setup the key of NVS sector to read the size of it's written data */
|
|
sprintf(key_str,NVM_HISTORY_DATA_KEY,sector_counter);
|
|
|
|
/* get the size of the history space */
|
|
err = nvs_get_blob(my_handle, key_str, NULL, &required_size);
|
|
|
|
/* Check if that sector is not full */
|
|
if(required_size >= (NVM_MAX_NUMBER_OF_IN_ONE_SECTOR*sizeof(historyLog_t)))
|
|
{
|
|
/* Reset the required_size again to 0 */
|
|
required_size = 0;
|
|
|
|
/* if full then check the next sector */
|
|
sector_counter++;
|
|
}
|
|
else
|
|
{
|
|
/* if not full then return the sector_number */
|
|
break;
|
|
}
|
|
}while(sector_counter <= NVM_NUMBER_OF_SECTORS);
|
|
|
|
if(sector_counter > NVM_NUMBER_OF_SECTORS)
|
|
{
|
|
/* Setup the key of NVS sector to read it's written data */
|
|
sector_counter--;
|
|
}
|
|
}
|
|
|
|
// Close
|
|
nvs_close(my_handle);
|
|
|
|
return sector_counter;
|
|
}
|
|
|
|
|
|
|
|
/**/
|
|
void nvm_set_last_posted_history_sector(uint8_t sector_num)
|
|
{
|
|
if(sector_num <= NVM_NUMBER_OF_SECTORS)
|
|
last_posted_sector = sector_num;
|
|
else
|
|
last_posted_sector = 0;
|
|
}
|
|
|
|
/**/
|
|
uint8_t nvm_get_last_posted_history_sector(void)
|
|
{
|
|
return last_posted_sector;
|
|
}
|
|
|
|
|
|
|
|
|