botchain/firmware
1
0
Fork 0
mirror of https://github.com/BotChain-Robots/firmware.git synced 2026-07-08 17:47:21 +02:00
Code Issues Packages Projects Releases Wiki Activity

Config manager fixes

Browse Source
This commit is contained in:
Johnathon Slightham
2025-09-30 15:30:10 -04:00
parent 792f4a530a
commit 1ca488b7b9
17 changed files with 328 additions and 205 deletions
Download Patch File Download Diff File Expand all files Collapse all files

215
components/config/ConfigManager.cpp
View File

@@ -2,101 +2,182 @@
// Created by Johnathon Slightham on 2025-06-12.
//
#include <mutex>
#include <esp_log.h>
#include "nvs_flash.h"
#include "constants/config.h"
#include "ConfigManager.h"
static auto TAG = "ConfigManager";
void ConfigManager::init_config() {
nvs_flash_init();
std::unique_lock lock(rw_lock);
if (this->initialized)
return;
this->initialized = true;
lock.unlock();
nvs_handle config_handle;
nvs_open(NVS_FLASH_NAMESPACE, NVS_READWRITE, &config_handle);
uint16_t id;
if (ESP_ERR_NVS_NOT_FOUND == nvs_get_u16(config_handle, MODULE_ID_KEY, &id)) {
nvs_set_u16(config_handle, MODULE_ID_KEY, DEFAULT_MODULE_ID);
esp_err_t ret = nvs_flash_init();
if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
// NVS partition was truncated and needs to be erased, retry nvs_flash_init after erasing
ESP_ERROR_CHECK(nvs_flash_erase());
ret = nvs_flash_init();
}
uint16_t type;
if (ESP_ERR_NVS_NOT_FOUND == nvs_get_u16(config_handle, MODULE_TYPE_KEY, &type)) {
nvs_set_u16(config_handle, MODULE_TYPE_KEY, DEFAULT_MODULE_TYPE);
}
nvs_close(config_handle);
ESP_ERROR_CHECK(ret);
}
// todo: we should probably cache some of these things
uint16_t ConfigManager::get_module_id() {
nvs_handle config_handle;
nvs_open(NVS_FLASH_NAMESPACE, NVS_READONLY, &config_handle);
uint16_t id;
nvs_get_u16(config_handle, MODULE_ID_KEY, &id);
nvs_close(config_handle);
return id;
uint16_t ConfigManager::get_module_id() const {
uint16_t i = DEFAULT_MODULE_ID;
get_uint16(MODULE_ID_KEY, &i);
return i;
}
ModuleType ConfigManager::get_module_type() {
nvs_handle config_handle;
nvs_open(NVS_FLASH_NAMESPACE, NVS_READONLY, &config_handle);
uint16_t type;
nvs_get_u16(config_handle, MODULE_TYPE_KEY, &type);
nvs_close(config_handle);
ModuleType ConfigManager::get_module_type() const {
uint16_t type = DEFAULT_MODULE_TYPE;
get_uint16(MODULE_TYPE_KEY, &type);
return static_cast<ModuleType>(type);
}
std::string ConfigManager::get_wifi_ssid() {
return get_string(WIFI_SSID_KEY);
}
std::string ConfigManager::get_wifi_password() {
return get_string(WIFI_PASSWORD_KEY);
}
std::string ConfigManager::get_string(const char *key) {
nvs_handle config_handle;
nvs_open(NVS_FLASH_NAMESPACE, NVS_READONLY, &config_handle);
size_t required_size; // get size of the string
if (ESP_ERR_NVS_NOT_FOUND == nvs_get_str(config_handle, key, nullptr, &required_size)) {
return "";
}
std::string ConfigManager::get_wifi_ssid() const {
std::string str;
str.resize(required_size);
if (ESP_ERR_NVS_NOT_FOUND == nvs_get_str(config_handle, key, str.data(), &required_size)) {
return "";
}
nvs_close(config_handle);
get_string(WIFI_SSID_KEY, str);
return str;
}
void ConfigManager::set_module_id(const uint16_t id) {
std::string ConfigManager::get_wifi_password() const {
std::string str;
get_string(WIFI_PASSWORD_KEY, str);
return str;
}
esp_err_t ConfigManager::get_string(const char *key, std::string& out) const {
std::shared_lock lock(rw_lock);
esp_err_t ret = ESP_OK;
if (const auto str = get_config_from_cache<std::string>(key)) {
out = *str;
return ret;
}
ESP_LOGD(TAG, "get_string cache miss");
nvs_handle config_handle;
nvs_open(NVS_FLASH_NAMESPACE, NVS_READWRITE, &config_handle);
nvs_set_u16(config_handle, MODULE_ID_KEY, id);
if (ret = nvs_open(NVS_FLASH_NAMESPACE, NVS_READONLY, &config_handle); ret != ESP_OK) {
ESP_LOGE(TAG, "get_string Failed to open NVS");
return ret;
}
size_t required_size; // get size of the string
if (ret = nvs_get_str(config_handle, key, nullptr, &required_size); ret != ESP_OK) {
ESP_LOGE(TAG, "get_string failed to get string size");
return ret;
}
out.resize(required_size);
if (ret = nvs_get_str(config_handle, key, out.data(), &required_size); ret != ESP_OK) {
ESP_LOGE(TAG, "get_string failed to get string");
return ret;
}
nvs_close(config_handle);
return ret;
}
esp_err_t ConfigManager::get_uint16(const char *key, uint16_t *out) const {
esp_err_t ret = ESP_OK;
std::shared_lock lock(rw_lock);
if (const auto i = get_config_from_cache<uint16_t>(key)) {
*out = i.value();
return ret;
}
ESP_LOGD(TAG, "get_uint16 cache miss");
nvs_handle config_handle;
if (ret = nvs_open(NVS_FLASH_NAMESPACE, NVS_READONLY, &config_handle); ret != ESP_OK) {
return ret;
}
if (ret = nvs_get_u16(config_handle, key, out); ret != ESP_OK) {
return ret;
}
nvs_close(config_handle);
return ret;
}
template<typename T>
std::optional<T> ConfigManager::get_config_from_cache(const std::string& key) const {
// Not thread safe
if (const auto it = cache.find(key); it != cache.end()) {
if (auto val = std::get_if<T>(&it->second))
return *val;
}
return std::nullopt;
}
void ConfigManager::set_module_id(const uint16_t id) {
set<nvs_set_u16, uint16_t>(MODULE_ID_KEY, id);
}
void ConfigManager::set_module_type(const ModuleType type) {
nvs_handle config_handle;
nvs_open(NVS_FLASH_NAMESPACE, NVS_READWRITE, &config_handle);
nvs_set_u16(config_handle, MODULE_TYPE_KEY, type);
nvs_close(config_handle);
set<nvs_set_u16, uint16_t>(MODULE_TYPE_KEY, type);
}
void ConfigManager::set_wifi_ssid(const char* ssid) {
nvs_handle config_handle;
nvs_open(NVS_FLASH_NAMESPACE, NVS_READWRITE, &config_handle);
nvs_set_str(config_handle, WIFI_SSID_KEY, ssid);
nvs_close(config_handle);
set<nvs_set_cpp_str, std::string>(WIFI_SSID_KEY, ssid);
}
void ConfigManager::set_wifi_password(const char* password) {
nvs_handle config_handle;
nvs_open(NVS_FLASH_NAMESPACE, NVS_READWRITE, &config_handle);
nvs_set_str(config_handle, WIFI_PASSWORD_KEY, password);
nvs_close(config_handle);
set<nvs_set_cpp_str, std::string>(WIFI_PASSWORD_KEY, password);
}
// Func - the esp write function to call (ie. nvs_set_u16)
// T - the type of the value in the key value pair
template<auto Func, typename T>
esp_err_t ConfigManager::set(const char* key, const T value) {
std::unique_lock lock(rw_lock);
if (write_to_cache(key, value)) {
return ESP_OK;
}
esp_err_t ret = ESP_OK;
nvs_handle config_handle;
ret = nvs_open(NVS_FLASH_NAMESPACE, NVS_READWRITE, &config_handle);
if (ESP_OK != ret) {
ESP_LOGE(TAG, "set error opening NVS handle");
return ret;
}
ret = Func(config_handle, key, value);
if (ESP_OK != ret) {
ESP_LOGE(TAG, "set error writing to NVS key %s", key);
}
nvs_close(config_handle);
return ret;
}
// Returns true when we don't need to write through the cache
template<typename T>
bool ConfigManager::write_to_cache(const std::string& key, const T value) {
const auto it = cache.find(key);
if (it != cache.end()) {
if (const auto existing = std::get_if<T>(&it->second)) {
if (*existing == value)
return true;
}
}
cache[key] = value;
return false;
}
esp_err_t ConfigManager::nvs_set_cpp_str(const nvs_handle_t handle, const std::string& key, const std::string& str) {
return nvs_set_str(handle, key.c_str(), str.c_str());
}
esp_err_t ConfigManager::nvs_get_cpp_str(const nvs_handle_t handle, const std::string& key, std::string& out_str, size_t *length) {
return nvs_get_str(handle, key.c_str(), out_str.data(), length);
}