Refactor: storage in separate component ausgelagert
This commit is contained in:
@@ -0,0 +1,9 @@
|
||||
idf_component_register(
|
||||
SRCS
|
||||
"src/storage.c"
|
||||
INCLUDE_DIRS
|
||||
"include"
|
||||
REQUIRES
|
||||
nvs_flash
|
||||
)
|
||||
|
||||
@@ -0,0 +1,57 @@
|
||||
#ifndef STORAGE_H
|
||||
#define STORAGE_H
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stddef.h>
|
||||
#include "esp_err.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/** Initialisiert NVS (mit Auto-Recovery bei Versionswechsel) */
|
||||
esp_err_t storage_init(void);
|
||||
|
||||
/**
|
||||
* Lädt gespeicherte STA-Credentials aus NVS.
|
||||
* - Allokiert *out_ssid / *out_pass via malloc; Caller muss free() aufrufen.
|
||||
* - Gibt true zurück, wenn beide Strings erfolgreich gelesen wurden.
|
||||
*/
|
||||
bool storage_load_wifi_creds(char **out_ssid, char **out_pass);
|
||||
|
||||
/**
|
||||
* Speichert STA-Credentials idempotent in NVS.
|
||||
* - Schreibt nur, wenn sich Werte geändert haben.
|
||||
* - Gibt ESP_OK bei Erfolg zurück (auch wenn nichts zu schreiben war).
|
||||
*/
|
||||
esp_err_t storage_save_wifi_creds(const char *ssid, const char *pass);
|
||||
bool storage_get_effective_device_name(char **out_devname);
|
||||
|
||||
/**
|
||||
* Speichert Geräte-Infos (Name, Influx-Token, Bucket, Org) in NVS.
|
||||
* - Leere/NULL-Strings löschen den jeweiligen Key.
|
||||
*/
|
||||
|
||||
bool storage_get_effective_influx(char **out_org, char **out_bucket, char **out_token);
|
||||
esp_err_t storage_save_influx_softap(const char *org, const char *bucket, const char *token);
|
||||
void storage_factory_reset_influx(void);
|
||||
void storage_debug_dump(void);
|
||||
esp_err_t storage_save_device_name(const char *devicename); // NULL=kein Update, ""=löschen
|
||||
esp_err_t storage_factory_reset_all(void);
|
||||
|
||||
esp_err_t storage_save_service_url(const char *url); // url=="" löscht
|
||||
bool storage_load_service_url(char **out_url); // malloc'd, caller free
|
||||
void storage_erase_service_url(void);
|
||||
|
||||
bool storage_load_device_name(char **out_devname);
|
||||
|
||||
esp_err_t storage_save_device_info(const char *devicename,
|
||||
const char *token,
|
||||
const char *bucket,
|
||||
const char *org);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // STORAGE_H
|
||||
@@ -0,0 +1,450 @@
|
||||
// File: src/storage.c
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#include "esp_log.h"
|
||||
#include "nvs_flash.h"
|
||||
#include "nvs.h"
|
||||
|
||||
#include "storage.h"
|
||||
|
||||
#include "esp_system.h"
|
||||
|
||||
static const char *TAG = "storage";
|
||||
|
||||
// Namespace & Keys (intern)
|
||||
#define NVS_NAMESPACE "wifi"
|
||||
#define NVS_KEY_SSID "sta_ssid"
|
||||
#define NVS_KEY_PASS "sta_pass"
|
||||
#define NVS_KEY_DEVNAME "dev_name"
|
||||
#define NVS_KEY_INFLUX_TOKEN "influx_token"
|
||||
#define NVS_KEY_BUCKET "influx_bucket"
|
||||
#define NVS_KEY_ORG "org_id"
|
||||
#define NVS_KEY_SERVICE_URL "service_url"
|
||||
|
||||
// Werkseinstellungen
|
||||
#define DEFAULT_ORG_ID "myorg"
|
||||
#define DEFAULT_BUCKET "nanoPSX"
|
||||
#define DEFAULT_INFLUX_TOKEN "0946c41441a85088b38d39da6ed06d75a"
|
||||
#define DEFAULT_DEVNAME "Sensor"
|
||||
|
||||
static char* get_nvs_str(nvs_handle_t h, const char *key);
|
||||
|
||||
|
||||
bool storage_load_device_name(char **out_devname) {
|
||||
if (!out_devname) return false;
|
||||
*out_devname = NULL;
|
||||
|
||||
nvs_handle_t h;
|
||||
if (nvs_open(NVS_NAMESPACE, NVS_READONLY, &h) != ESP_OK) return false;
|
||||
|
||||
char *name = get_nvs_str(h, NVS_KEY_DEVNAME);
|
||||
nvs_close(h);
|
||||
if (!name) return false;
|
||||
|
||||
*out_devname = name;
|
||||
return true;
|
||||
}
|
||||
|
||||
esp_err_t storage_save_service_url(const char *url) {
|
||||
nvs_handle_t h;
|
||||
esp_err_t err = nvs_open(NVS_NAMESPACE, NVS_READWRITE, &h);
|
||||
if (err != ESP_OK) return err;
|
||||
|
||||
// Semantik wie bei anderen Feldern: "" => löschen
|
||||
if (url && url[0] != '\0') {
|
||||
err = nvs_set_str(h, NVS_KEY_SERVICE_URL, url);
|
||||
} else {
|
||||
esp_err_t e = nvs_erase_key(h, NVS_KEY_SERVICE_URL);
|
||||
err = (e == ESP_ERR_NVS_NOT_FOUND) ? ESP_OK : e;
|
||||
}
|
||||
if (err == ESP_OK) err = nvs_commit(h);
|
||||
nvs_close(h);
|
||||
|
||||
if (err == ESP_OK) {
|
||||
ESP_LOGI(TAG, "Service-URL %s", (url && url[0]) ? "gespeichert" : "gelöscht");
|
||||
} else {
|
||||
ESP_LOGE(TAG, "Speichern Service-URL fehlgeschlagen: %s", esp_err_to_name(err));
|
||||
}
|
||||
return err;
|
||||
}
|
||||
|
||||
bool storage_load_service_url(char **out_url) {
|
||||
if (!out_url) return false;
|
||||
*out_url = NULL;
|
||||
|
||||
nvs_handle_t h;
|
||||
if (nvs_open(NVS_NAMESPACE, NVS_READONLY, &h) != ESP_OK) return false;
|
||||
|
||||
char *url = get_nvs_str(h, NVS_KEY_SERVICE_URL);
|
||||
nvs_close(h);
|
||||
if (!url) return false;
|
||||
*out_url = url;
|
||||
return true;
|
||||
}
|
||||
|
||||
void storage_erase_service_url(void) {
|
||||
(void)storage_save_service_url("");
|
||||
}
|
||||
|
||||
// ---------- NVS Init ----------
|
||||
esp_err_t storage_init(void) {
|
||||
esp_err_t ret = nvs_flash_init();
|
||||
if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
|
||||
ESP_ERROR_CHECK(nvs_flash_erase());
|
||||
ret = nvs_flash_init();
|
||||
}
|
||||
if (ret == ESP_OK) {
|
||||
ESP_LOGI(TAG, "NVS init OK");
|
||||
} else {
|
||||
ESP_LOGE(TAG, "NVS init failed: %s", esp_err_to_name(ret));
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
// ---------- interne Helfer ----------
|
||||
static esp_err_t nvs_set_str_or_erase(nvs_handle_t h, const char *key, const char *val) {
|
||||
if (val && val[0] != '\0') {
|
||||
return nvs_set_str(h, key, val);
|
||||
} else {
|
||||
esp_err_t e = nvs_erase_key(h, key);
|
||||
return (e == ESP_ERR_NVS_NOT_FOUND) ? ESP_OK : e;
|
||||
}
|
||||
}
|
||||
|
||||
static char* get_nvs_str(nvs_handle_t h, const char *key) {
|
||||
size_t need = 0;
|
||||
if (nvs_get_str(h, key, NULL, &need) != ESP_OK || need == 0) return NULL;
|
||||
char *buf = (char*)malloc(need);
|
||||
if (!buf) return NULL;
|
||||
if (nvs_get_str(h, key, buf, &need) != ESP_OK) {
|
||||
free(buf);
|
||||
return NULL;
|
||||
}
|
||||
return buf; // inkl. Nullterminator
|
||||
}
|
||||
|
||||
static esp_err_t set_keep_or_erase(nvs_handle_t h, const char *key, const char *val) {
|
||||
if (val == NULL) return ESP_OK; // nicht geändert
|
||||
if (val[0] == '\0') { // explizit löschen -> fällt auf Default zurück
|
||||
esp_err_t e = nvs_erase_key(h, key);
|
||||
return (e == ESP_ERR_NVS_NOT_FOUND) ? ESP_OK : e;
|
||||
}
|
||||
return nvs_set_str(h, key, val); // neuen Wert setzen
|
||||
}
|
||||
|
||||
// ---------- WLAN-Creds ----------
|
||||
bool storage_load_wifi_creds(char **out_ssid, char **out_pass) {
|
||||
if (!out_ssid || !out_pass) return false;
|
||||
*out_ssid = *out_pass = NULL;
|
||||
|
||||
nvs_handle_t h;
|
||||
if (nvs_open(NVS_NAMESPACE, NVS_READONLY, &h) != ESP_OK) return false;
|
||||
|
||||
size_t need = 0;
|
||||
|
||||
// SSID
|
||||
if (nvs_get_str(h, NVS_KEY_SSID, NULL, &need) != ESP_OK || need == 0) {
|
||||
nvs_close(h);
|
||||
return false;
|
||||
}
|
||||
char *ssid = (char*)malloc(need);
|
||||
if (!ssid) { nvs_close(h); return false; }
|
||||
if (nvs_get_str(h, NVS_KEY_SSID, ssid, &need) != ESP_OK) {
|
||||
free(ssid); nvs_close(h); return false;
|
||||
}
|
||||
|
||||
// PASS
|
||||
need = 0;
|
||||
if (nvs_get_str(h, NVS_KEY_PASS, NULL, &need) != ESP_OK || need == 0) {
|
||||
free(ssid); nvs_close(h); return false;
|
||||
}
|
||||
char *pass = (char*)malloc(need);
|
||||
if (!pass) { free(ssid); nvs_close(h); return false; }
|
||||
if (nvs_get_str(h, NVS_KEY_PASS, pass, &need) != ESP_OK) {
|
||||
free(ssid); free(pass); nvs_close(h); return false;
|
||||
}
|
||||
|
||||
nvs_close(h);
|
||||
*out_ssid = ssid;
|
||||
*out_pass = pass;
|
||||
return true;
|
||||
}
|
||||
|
||||
esp_err_t storage_save_wifi_creds(const char *ssid, const char *pass) {
|
||||
if (!ssid || !pass) return ESP_ERR_INVALID_ARG;
|
||||
|
||||
// idempotent schreiben
|
||||
char *cur_s = NULL, *cur_p = NULL;
|
||||
bool have = storage_load_wifi_creds(&cur_s, &cur_p);
|
||||
bool same = have && strcmp(cur_s, ssid) == 0 && strcmp(cur_p, pass) == 0;
|
||||
if (cur_s) free(cur_s);
|
||||
if (cur_p) free(cur_p);
|
||||
|
||||
if (same) {
|
||||
ESP_LOGI(TAG, "Creds identisch, kein erneutes Speichern.");
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
nvs_handle_t h;
|
||||
esp_err_t err = nvs_open(NVS_NAMESPACE, NVS_READWRITE, &h);
|
||||
if (err != ESP_OK) return err;
|
||||
|
||||
ESP_ERROR_CHECK_WITHOUT_ABORT(nvs_set_str(h, NVS_KEY_SSID, ssid));
|
||||
ESP_ERROR_CHECK_WITHOUT_ABORT(nvs_set_str(h, NVS_KEY_PASS, pass));
|
||||
|
||||
err = nvs_commit(h);
|
||||
nvs_close(h);
|
||||
|
||||
if (err == ESP_OK) {
|
||||
ESP_LOGI(TAG, "Creds gespeichert: SSID='%s' (Passwort %zu Zeichen)", ssid, strlen(pass));
|
||||
} else {
|
||||
ESP_LOGE(TAG, "nvs_commit failed: %s", esp_err_to_name(err));
|
||||
}
|
||||
return err;
|
||||
}
|
||||
|
||||
// ---------- Device/Influx-Infos (generisch speichern) ----------
|
||||
esp_err_t storage_save_device_info(const char *devicename,
|
||||
const char *token,
|
||||
const char *bucket,
|
||||
const char *org) {
|
||||
nvs_handle_t h;
|
||||
esp_err_t err = nvs_open(NVS_NAMESPACE, NVS_READWRITE, &h);
|
||||
if (err != ESP_OK) return err;
|
||||
|
||||
ESP_ERROR_CHECK_WITHOUT_ABORT(nvs_set_str_or_erase(h, NVS_KEY_DEVNAME, devicename));
|
||||
ESP_ERROR_CHECK_WITHOUT_ABORT(nvs_set_str_or_erase(h, NVS_KEY_INFLUX_TOKEN, token));
|
||||
ESP_ERROR_CHECK_WITHOUT_ABORT(nvs_set_str_or_erase(h, NVS_KEY_BUCKET, bucket));
|
||||
ESP_ERROR_CHECK_WITHOUT_ABORT(nvs_set_str_or_erase(h, NVS_KEY_ORG, org));
|
||||
|
||||
err = nvs_commit(h);
|
||||
nvs_close(h);
|
||||
|
||||
if (err == ESP_OK) {
|
||||
ESP_LOGI(TAG, "Deviceinfo gespeichert: name='%s', token_len=%d",
|
||||
devicename ? devicename : "",
|
||||
token ? (int)strlen(token) : 0);
|
||||
} else {
|
||||
ESP_LOGE(TAG, "nvs_commit failed: %s", esp_err_to_name(err));
|
||||
}
|
||||
return err;
|
||||
}
|
||||
|
||||
// ---------- Werkseinstellung + effektive Influx-Konfig ----------
|
||||
bool storage_get_effective_influx(char **out_org, char **out_bucket, char **out_token) {
|
||||
if (!out_org || !out_bucket || !out_token) return false;
|
||||
*out_org = *out_bucket = *out_token = NULL;
|
||||
|
||||
nvs_handle_t h;
|
||||
bool have_nvs = (nvs_open(NVS_NAMESPACE, NVS_READONLY, &h) == ESP_OK);
|
||||
|
||||
char *org = NULL, *bucket = NULL, *token = NULL;
|
||||
if (have_nvs) {
|
||||
org = get_nvs_str(h, NVS_KEY_ORG);
|
||||
bucket = get_nvs_str(h, NVS_KEY_BUCKET);
|
||||
token = get_nvs_str(h, NVS_KEY_INFLUX_TOKEN);
|
||||
nvs_close(h);
|
||||
}
|
||||
|
||||
if (!org) org = strdup(DEFAULT_ORG_ID);
|
||||
if (!bucket) bucket = strdup(DEFAULT_BUCKET);
|
||||
if (!token) token = strdup(DEFAULT_INFLUX_TOKEN);
|
||||
|
||||
if (!org || !bucket || !token) {
|
||||
free(org); free(bucket); free(token);
|
||||
return false;
|
||||
}
|
||||
|
||||
*out_org = org; *out_bucket = bucket; *out_token = token;
|
||||
return true;
|
||||
}
|
||||
|
||||
// Speichert nur, wenn sich mind. ein übergebenes Feld ändert
|
||||
// NULL = Feld nicht angefasst (behalten)
|
||||
// "" = löschen (fällt auf Werkseinstellung zurück)
|
||||
esp_err_t storage_save_influx_softap(const char *org, const char *bucket, const char *token) {
|
||||
char *cur_org = NULL, *cur_bucket = NULL, *cur_token = NULL;
|
||||
if (!storage_get_effective_influx(&cur_org, &cur_bucket, &cur_token)) {
|
||||
ESP_LOGE(TAG, "cannot get effective influx config");
|
||||
return ESP_FAIL;
|
||||
}
|
||||
|
||||
// Wenn nichts übergeben wurde, ist nichts zu tun
|
||||
if (!org && !bucket && !token) {
|
||||
free(cur_org); free(cur_bucket); free(cur_token);
|
||||
ESP_LOGI(TAG, "SoftAP: keine geänderten Felder.");
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
bool changed = false;
|
||||
if (org != NULL && strcmp(org, cur_org) != 0) changed = true;
|
||||
if (bucket != NULL && strcmp(bucket, cur_bucket) != 0) changed = true;
|
||||
if (token != NULL && strcmp(token, cur_token) != 0) changed = true;
|
||||
|
||||
free(cur_org); free(cur_bucket); free(cur_token);
|
||||
|
||||
if (!changed) {
|
||||
ESP_LOGI(TAG, "SoftAP: keine Änderungen – nichts zu speichern.");
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
nvs_handle_t h;
|
||||
esp_err_t err = nvs_open(NVS_NAMESPACE, NVS_READWRITE, &h);
|
||||
if (err != ESP_OK) return err;
|
||||
|
||||
ESP_ERROR_CHECK_WITHOUT_ABORT(set_keep_or_erase(h, NVS_KEY_ORG, org));
|
||||
ESP_ERROR_CHECK_WITHOUT_ABORT(set_keep_or_erase(h, NVS_KEY_BUCKET, bucket));
|
||||
ESP_ERROR_CHECK_WITHOUT_ABORT(set_keep_or_erase(h, NVS_KEY_INFLUX_TOKEN, token));
|
||||
|
||||
err = nvs_commit(h);
|
||||
nvs_close(h);
|
||||
|
||||
if (err == ESP_OK) {
|
||||
ESP_LOGI(TAG, "SoftAP: Influx-Konfig gespeichert.");
|
||||
} else {
|
||||
ESP_LOGE(TAG, "nvs_commit failed: %s", esp_err_to_name(err));
|
||||
}
|
||||
return err;
|
||||
}
|
||||
|
||||
void storage_factory_reset_influx(void) {
|
||||
nvs_handle_t h;
|
||||
if (nvs_open(NVS_NAMESPACE, NVS_READWRITE, &h) != ESP_OK) return;
|
||||
nvs_erase_key(h, NVS_KEY_ORG);
|
||||
nvs_erase_key(h, NVS_KEY_BUCKET);
|
||||
nvs_erase_key(h, NVS_KEY_INFLUX_TOKEN);
|
||||
nvs_commit(h);
|
||||
nvs_close(h);
|
||||
ESP_LOGI(TAG, "Influx-Keys gelöscht – Werkseinstellungen aktiv beim nächsten Use.");
|
||||
}
|
||||
|
||||
void storage_debug_dump(void) {
|
||||
// WLAN
|
||||
char *ssid = NULL, *pass = NULL;
|
||||
if (storage_load_wifi_creds(&ssid, &pass)) {
|
||||
ESP_LOGI(TAG, "DUMP WLAN: SSID='%s', PASS_LEN=%d",
|
||||
ssid ? ssid : "<null>", pass ? (int)strlen(pass) : -1);
|
||||
free(ssid); free(pass);
|
||||
} else {
|
||||
ESP_LOGI(TAG, "DUMP WLAN: keine STA-Credentials gespeichert.");
|
||||
}
|
||||
|
||||
// Influx (effektiv = NVS oder Defaults)
|
||||
char *org = NULL, *bucket = NULL, *token = NULL;
|
||||
if (storage_get_effective_influx(&org, &bucket, &token)) {
|
||||
// Token maskieren
|
||||
const char *t = token ? token : "";
|
||||
int n = (int)strlen(t);
|
||||
char masked[80] = {0};
|
||||
if (n <= 8) {
|
||||
snprintf(masked, sizeof(masked), "%s", t);
|
||||
} else {
|
||||
int head = 4, tail = 4;
|
||||
int stars = n - head - tail;
|
||||
if (stars < 0) stars = 0;
|
||||
snprintf(masked, sizeof(masked), "%.*s%.*s%.*s",
|
||||
head, t,
|
||||
stars, "****************************************",
|
||||
tail, t + n - tail);
|
||||
}
|
||||
ESP_LOGI(TAG, "DUMP Influx: org='%s', bucket='%s', token='%s' (len=%d)",
|
||||
org ? org : "", bucket ? bucket : "", masked, n);
|
||||
free(org); free(bucket); free(token);
|
||||
} else {
|
||||
ESP_LOGW(TAG, "DUMP Influx: konnte effektive Konfiguration nicht lesen.");
|
||||
}
|
||||
|
||||
// Device-Name + Service-URL in einem NVS-Handle lesen
|
||||
nvs_handle_t h;
|
||||
if (nvs_open(NVS_NAMESPACE, NVS_READONLY, &h) == ESP_OK) {
|
||||
// Device-Name
|
||||
size_t need = 0;
|
||||
if (nvs_get_str(h, NVS_KEY_DEVNAME, NULL, &need) == ESP_OK && need > 0) {
|
||||
char *dev = (char*)malloc(need);
|
||||
if (dev && nvs_get_str(h, NVS_KEY_DEVNAME, dev, &need) == ESP_OK) {
|
||||
ESP_LOGI(TAG, "DUMP Device: name='%s'", dev);
|
||||
} else {
|
||||
ESP_LOGI(TAG, "DUMP Device: name=<read error>");
|
||||
}
|
||||
if (dev) free(dev);
|
||||
} else {
|
||||
ESP_LOGI(TAG, "DUMP Device: name=<nicht gesetzt>");
|
||||
}
|
||||
|
||||
// Service-URL
|
||||
need = 0;
|
||||
if (nvs_get_str(h, NVS_KEY_SERVICE_URL, NULL, &need) == ESP_OK && need > 0) {
|
||||
char *url = (char*)malloc(need);
|
||||
if (url && nvs_get_str(h, NVS_KEY_SERVICE_URL, url, &need) == ESP_OK) {
|
||||
ESP_LOGI(TAG, "DUMP Service: url='%s'", url);
|
||||
} else {
|
||||
ESP_LOGI(TAG, "DUMP Service: url=<read error>");
|
||||
}
|
||||
if (url) free(url);
|
||||
} else {
|
||||
ESP_LOGI(TAG, "DUMP Service: url=<nicht gesetzt>");
|
||||
}
|
||||
|
||||
nvs_close(h);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
esp_err_t storage_save_device_name(const char *devicename) {
|
||||
nvs_handle_t h;
|
||||
esp_err_t err = nvs_open(NVS_NAMESPACE, NVS_READWRITE, &h);
|
||||
if (err != ESP_OK) return err;
|
||||
|
||||
// Semantik: NULL = nicht ändern, "" = löschen, sonst setzen
|
||||
if (devicename != NULL) {
|
||||
if (devicename[0] == '\0') {
|
||||
esp_err_t e = nvs_erase_key(h, NVS_KEY_DEVNAME);
|
||||
if (e != ESP_OK && e != ESP_ERR_NVS_NOT_FOUND) { nvs_close(h); return e; }
|
||||
} else {
|
||||
err = nvs_set_str(h, NVS_KEY_DEVNAME, devicename);
|
||||
if (err != ESP_OK) { nvs_close(h); return err; }
|
||||
}
|
||||
err = nvs_commit(h);
|
||||
} else {
|
||||
err = ESP_OK; // nichts geändert
|
||||
}
|
||||
nvs_close(h);
|
||||
|
||||
if (err == ESP_OK) {
|
||||
ESP_LOGI(TAG, "Device-Name %s",
|
||||
(devicename == NULL) ? "unverändert"
|
||||
: (devicename[0] == '\0') ? "gelöscht"
|
||||
: "gesetzt");
|
||||
}
|
||||
return err;
|
||||
}
|
||||
|
||||
// ---------- Device-Name (effektiv mit Default) ----------
|
||||
bool storage_get_effective_device_name(char **out_devname) {
|
||||
if (!out_devname) return false;
|
||||
*out_devname = NULL;
|
||||
|
||||
char *name = NULL;
|
||||
if (!storage_load_device_name(&name)) {
|
||||
// kein Name im NVS -> Werkseinstellung nehmen
|
||||
name = strdup(DEFAULT_DEVNAME);
|
||||
if (!name) return false;
|
||||
}
|
||||
|
||||
*out_devname = name; // malloc-String zurückgeben
|
||||
return true;
|
||||
}
|
||||
|
||||
esp_err_t storage_factory_reset_all(void) {
|
||||
// Löscht die komplette NVS-Partition (alle Namespaces und Keys)
|
||||
esp_err_t err = nvs_flash_erase();
|
||||
if (err == ESP_OK) {
|
||||
// Direkt danach kann bei Bedarf wieder initialisiert werden – wir rebooten aber ohnehin
|
||||
ESP_LOGW(TAG, "FACTORY RESET: gesamte NVS-Partition gelöscht.");
|
||||
} else {
|
||||
ESP_LOGE(TAG, "FACTORY RESET: nvs_flash_erase() fehlgeschlagen: %s", esp_err_to_name(err));
|
||||
}
|
||||
return err;
|
||||
}
|
||||
Reference in New Issue
Block a user