read config from nvs

main/CMakeLists.txt

@@ -2,11 +2,13 @@ idf_build_get_property(project_dir PROJECT_DIR)
 message(STATUS "The project dir is: ${project_dir}")
 
 set(headers
+    configwrapper.h
     feature_bmp.h
     feature_dht.h
     feature_lamp.h
     feature_switch.h
     feature_tsl.h
+    futurecpp.h
     myconfig.h
     mymdns.h
     mymqtt.h
@@ -15,6 +17,7 @@ set(headers
 )
 
 set(sources
+    configwrapper.cpp
     feature_bmp.cpp
     feature_dht.cpp
     feature_lamp.cpp

main/configwrapper.cpp

@@ -0,0 +1,8 @@
+#include "configwrapper.h"
+
+// system includes
+
+// local includes
+
+namespace deckenlampe {
+} // namespace deckenlampe

main/configwrapper.h

@@ -0,0 +1,150 @@
+#pragma once
+
+// system includes
+#include <string>
+#include <cstdint>
+#include <utility>
+
+// esp-idf includes
+#include <nvs.h>
+#include <hal/gpio_types.h>
+
+// 3rdparty lib includes
+#include <tl/expected.hpp>
+#include <fmt/core.h>
+
+// local includes
+#include "espchrono.h"
+#include "futurecpp.h"
+
+namespace deckenlampe {
+extern nvs_handle_t nvsHandle;
+
+template<typename T> esp_err_t nvs_get(nvs_handle handle, const char* key, T* out_value) = delete;
+template<typename T> esp_err_t nvs_set(nvs_handle handle, const char* key, T value) = delete;
+
+template<typename T>
+class ConfigWrapper
+{
+public:
+    ConfigWrapper(const char *key, const T &value) : m_key{key}, m_value{value} {}
+
+    const char *key() const { return m_key; }
+    const T &value() const { return m_value; }
+    void setValue(const T &value) { m_value = value; }
+
+    tl::expected<T, std::string> readFromFlash() const;
+    tl::expected<void, std::string> writeToFlash(const T &value);
+
+private:
+    const char * const m_key;
+    T m_value;
+};
+
+template<typename T>
+tl::expected<T, std::string> ConfigWrapper<T>::readFromFlash() const
+{
+    T val;
+
+    const auto result = nvs_get(nvsHandle, m_key, &val);
+    //ESP_LOG_LEVEL_LOCAL((result == ESP_OK ? ESP_LOG_INFO : ESP_LOG_ERROR), TAG, "nvs_flash_init(): %s", esp_err_to_name(result));
+    if (result == ESP_OK)
+        return val;
+    else
+        return tl::make_unexpected(fmt::format("nvs_get() {} failed with {}", m_key, esp_err_to_name(result)));
+}
+
+template<typename T>
+tl::expected<void, std::string> ConfigWrapper<T>::writeToFlash(const T &value)
+{
+    return {};
+}
+
+template<> inline esp_err_t nvs_get(nvs_handle handle, const char* key, int8_t* out_value)  { return nvs_get_i8 (handle, key, out_value); }
+template<> inline esp_err_t nvs_get(nvs_handle handle, const char* key, uint8_t* out_value) { return nvs_get_u8 (handle, key, out_value); }
+template<> inline esp_err_t nvs_get(nvs_handle handle, const char* key, int16_t* out_value) { return nvs_get_i16(handle, key, out_value); }
+template<> inline esp_err_t nvs_get(nvs_handle handle, const char* key, uint16_t* out_value){ return nvs_get_u16(handle, key, out_value); }
+template<> inline esp_err_t nvs_get(nvs_handle handle, const char* key, int32_t* out_value) { return nvs_get_i32(handle, key, out_value); }
+template<> inline esp_err_t nvs_get(nvs_handle handle, const char* key, uint32_t* out_value){ return nvs_get_u32(handle, key, out_value); }
+template<> inline esp_err_t nvs_get(nvs_handle handle, const char* key, int64_t* out_value) { return nvs_get_i64(handle, key, out_value); }
+template<> inline esp_err_t nvs_get(nvs_handle handle, const char* key, uint64_t* out_value){ return nvs_get_u64(handle, key, out_value); }
+template<> inline esp_err_t nvs_get(nvs_handle handle, const char* key, bool* out_value)
+{
+    uint8_t temp;
+    const auto result = nvs_get(handle, key, &temp);
+    if (result == ESP_OK && out_value)
+        *out_value = temp;
+    return result;
+}
+template<> inline esp_err_t nvs_get(nvs_handle handle, const char* key, gpio_num_t* out_value)
+{
+    std::underlying_type_t<gpio_num_t> temp;
+    const auto result = nvs_get(handle, key, &temp);
+    if (result == ESP_OK && out_value)
+        *out_value = gpio_num_t(temp);
+    return result;
+}
+template<> inline esp_err_t nvs_get(nvs_handle handle, const char* key, float* out_value)
+{
+    uint32_t temp;
+    const auto result = nvs_get(handle, key, &temp);
+    if (result == ESP_OK)
+        *out_value = std::bit_cast<float>(temp);
+    return result;
+}
+template<> inline esp_err_t nvs_get(nvs_handle handle, const char* key, double* out_value)
+{
+    uint64_t temp;
+    const auto result = nvs_get(handle, key, &temp);
+    if (result == ESP_OK)
+        *out_value = std::bit_cast<double>(temp);
+    return result;
+}
+template<> inline esp_err_t nvs_get(nvs_handle handle, const char* key, std::string* out_value)
+{
+    size_t length;
+    if (const esp_err_t result = nvs_get_str(handle, key, nullptr, &length); result != ESP_OK)
+        return result;
+
+    char buf[length];
+    if (const esp_err_t result = nvs_get_str(handle, key, buf, &length); result != ESP_OK)
+        return result;
+
+    *out_value = buf;
+
+    return ESP_OK;
+}
+
+template<> inline esp_err_t nvs_set(nvs_handle handle, const char* key, int8_t value)                    { return nvs_set_i8 (handle, key, value); }
+template<> inline esp_err_t nvs_set(nvs_handle handle, const char* key, uint8_t value)                   { return nvs_set_u8 (handle, key, value); }
+template<> inline esp_err_t nvs_set(nvs_handle handle, const char* key, int16_t value)                   { return nvs_set_i16(handle, key, value); }
+template<> inline esp_err_t nvs_set(nvs_handle handle, const char* key, uint16_t value)                  { return nvs_set_u16(handle, key, value); }
+template<> inline esp_err_t nvs_set(nvs_handle handle, const char* key, int32_t value)                   { return nvs_set_i32(handle, key, value); }
+template<> inline esp_err_t nvs_set(nvs_handle handle, const char* key, uint32_t value)                  { return nvs_set_u32(handle, key, value); }
+template<> inline esp_err_t nvs_set(nvs_handle handle, const char* key, int64_t value)                   { return nvs_set_i64(handle, key, value); }
+template<> inline esp_err_t nvs_set(nvs_handle handle, const char* key, uint64_t value)                  { return nvs_set_u64(handle, key, value); }
+template<> inline esp_err_t nvs_set(nvs_handle handle, const char* key, bool value)                      { return nvs_set_u8 (handle, key, value); }
+template<> inline esp_err_t nvs_set(nvs_handle handle, const char* key, gpio_num_t value)                { return nvs_set    (handle, key, std::to_underlying(value)); }
+template<> inline esp_err_t nvs_set(nvs_handle handle, const char* key, float value)                     { return nvs_set(handle, key, std::bit_cast<uint32_t>(value)); }
+template<> inline esp_err_t nvs_set(nvs_handle handle, const char* key, double value)                    { return nvs_set(handle, key, std::bit_cast<uint64_t>(value)); }
+template<> inline esp_err_t nvs_set(nvs_handle handle, const char* key, const std::string &value)        { return nvs_set_str(handle, key, value.c_str()); }
+
+
+#define IMPLEMENT_NVS_GET_SET_CHRONO(Name) \
+    template<> inline esp_err_t nvs_get(nvs_handle handle, const char* key, Name* out_value) \
+    { \
+        Name::rep temp; \
+        const auto result = nvs_get(handle, key, &temp); \
+        if (result == ESP_OK && out_value) \
+            *out_value = Name{temp}; \
+        return result; \
+    } \
+    \
+    template<> inline esp_err_t nvs_set(nvs_handle handle, const char* key, Name value)                  { return nvs_set(handle, key, Name::rep(value.count())); }
+
+IMPLEMENT_NVS_GET_SET_CHRONO(espchrono::milliseconds32)
+IMPLEMENT_NVS_GET_SET_CHRONO(espchrono::seconds32)
+IMPLEMENT_NVS_GET_SET_CHRONO(espchrono::minutes32)
+IMPLEMENT_NVS_GET_SET_CHRONO(espchrono::hours32)
+#undef IMPLEMENT_NVS_GET_SET_CHRONO
+} // namespace deckenlampe

main/feature_bmp.cpp

@@ -30,7 +30,7 @@ espchrono::millis_clock::time_point last_bmp085_readout;
 
 void init_bmp()
 {
-    if (!config::enable_i2c || !config::enable_bmp)
+    if (!config::enable_i2c.value() || !config::enable_bmp.value())
         return;
 
     bmp.construct(10085);
@@ -55,7 +55,7 @@ void init_bmp()
 
 void update_bmp()
 {
-    if (!config::enable_i2c || !config::enable_bmp)
+    if (!config::enable_i2c.value() || !config::enable_bmp.value())
         return;
 
     if (bmpInitialized) {
@@ -81,17 +81,17 @@ void update_bmp()
 
                 if (mqttConnected) {
                     if (!lastBmpValue)
-                        mqttVerbosePub(config::topic_bmp085_availability, "online", 0, 1);
+                        mqttVerbosePub(config::topic_bmp085_availability.value(), "online", 0, 1);
-                    if (!lastBmpValue || espchrono::ago(last_bmp085_pressure_pub) >= config::valueUpdateInterval) {
+                    if (!lastBmpValue || espchrono::ago(last_bmp085_pressure_pub) >= config::valueUpdateInterval.value()) {
-                        if (mqttVerbosePub(config::topic_bmp085_pressure, fmt::format("{:.1f}", bmpValue.pressure), 0, 1) >= 0)
+                        if (mqttVerbosePub(config::topic_bmp085_pressure.value(), fmt::format("{:.1f}", bmpValue.pressure), 0, 1) >= 0)
                             last_bmp085_pressure_pub = espchrono::millis_clock::now();
                     }
-                    if (!lastBmpValue || espchrono::ago(last_bmp085_temperature_pub) >= config::valueUpdateInterval) {
+                    if (!lastBmpValue || espchrono::ago(last_bmp085_temperature_pub) >= config::valueUpdateInterval.value()) {
-                        if (mqttVerbosePub(config::topic_bmp085_temperature, fmt::format("{:.1f}", bmpValue.temperature), 0, 1) >= 0)
+                        if (mqttVerbosePub(config::topic_bmp085_temperature.value(), fmt::format("{:.1f}", bmpValue.temperature), 0, 1) >= 0)
                             last_bmp085_temperature_pub = espchrono::millis_clock::now();
                     }
-                    if (!lastBmpValue || espchrono::ago(last_bmp085_altitude_pub) >= config::valueUpdateInterval) {
+                    if (!lastBmpValue || espchrono::ago(last_bmp085_altitude_pub) >= config::valueUpdateInterval.value()) {
-                        if (mqttVerbosePub(config::topic_bmp085_altitude, fmt::format("{:.1f}", bmpValue.altitude), 0, 1) >= 0)
+                        if (mqttVerbosePub(config::topic_bmp085_altitude.value(), fmt::format("{:.1f}", bmpValue.altitude), 0, 1) >= 0)
                             last_bmp085_altitude_pub = espchrono::millis_clock::now();
                     }
                 }
@@ -107,10 +107,10 @@ void update_bmp()
         }
     } else {
     bmpOffline:
-        if (lastBmpValue && espchrono::ago(lastBmpValue->timestamp) >= config::availableTimeoutTime) {
+        if (lastBmpValue && espchrono::ago(lastBmpValue->timestamp) >= config::availableTimeoutTime.value()) {
             ESP_LOGW(TAG, "bmp timeouted");
             if (mqttConnected)
-                mqttVerbosePub(config::topic_bmp085_availability, "offline", 0, 1);
+                mqttVerbosePub(config::topic_bmp085_availability.value(), "offline", 0, 1);
             lastBmpValue = std::nullopt;
         }
     }

main/feature_dht.cpp

@@ -29,10 +29,10 @@ espchrono::millis_clock::time_point last_dht11_readout;
 
 void init_dht()
 {
-    if (!config::enable_dht)
+    if (!config::enable_dht.value())
         return;
 
-    dht.construct(config::pins_dht, DHT11);
+    dht.construct(config::pins_dht.value(), DHT11);
 
     ESP_LOGI(TAG, "calling dht.begin()...");
     dhtInitialized = dht->begin();
@@ -41,7 +41,7 @@ void init_dht()
 
 void update_dht()
 {
-    if (!config::enable_dht)
+    if (!config::enable_dht.value())
         return;
 
     if (dhtInitialized) {
@@ -62,13 +62,13 @@ void update_dht()
 
             if (mqttConnected) {
                 if (!lastDhtValue)
-                    mqttVerbosePub(config::topic_dht11_availability, "online", 0, 1);
+                    mqttVerbosePub(config::topic_dht11_availability.value(), "online", 0, 1);
-                if (!lastDhtValue || espchrono::ago(last_dht11_temperature_pub) >= config::valueUpdateInterval) {
+                if (!lastDhtValue || espchrono::ago(last_dht11_temperature_pub) >= config::valueUpdateInterval.value()) {
-                    if (mqttVerbosePub(config::topic_dht11_temperature, fmt::format("{:.1f}", dhtValue.temperature), 0, 1) >= 0)
+                    if (mqttVerbosePub(config::topic_dht11_temperature.value(), fmt::format("{:.1f}", dhtValue.temperature), 0, 1) >= 0)
                         last_dht11_temperature_pub = espchrono::millis_clock::now();
                 }
-                if (!lastDhtValue || espchrono::ago(last_dht11_humidity_pub) >= config::valueUpdateInterval) {
+                if (!lastDhtValue || espchrono::ago(last_dht11_humidity_pub) >= config::valueUpdateInterval.value()) {
-                    if (mqttVerbosePub(config::topic_dht11_humidity, fmt::format("{:.1f}", dhtValue.humidity), 0, 1) >= 0)
+                    if (mqttVerbosePub(config::topic_dht11_humidity.value(), fmt::format("{:.1f}", dhtValue.humidity), 0, 1) >= 0)
                         last_dht11_humidity_pub = espchrono::millis_clock::now();
                 }
             }
@@ -80,10 +80,10 @@ void update_dht()
         }
     } else {
     dhtOffline:
-        if (lastDhtValue && espchrono::ago(lastDhtValue->timestamp) >= config::availableTimeoutTime) {
+        if (lastDhtValue && espchrono::ago(lastDhtValue->timestamp) >= config::availableTimeoutTime.value()) {
             ESP_LOGW(TAG, "dht timeouted");
             if (mqttConnected)
-                mqttVerbosePub(config::topic_dht11_availability, "offline", 0, 1);
+                mqttVerbosePub(config::topic_dht11_availability.value(), "offline", 0, 1);
             lastDhtValue = std::nullopt;
         }
     }

main/feature_lamp.cpp

@@ -11,23 +11,23 @@ std::atomic<bool> lampState;
 
 void init_lamp()
 {
-    if (!config::enable_lamp)
+    if (!config::enable_lamp.value())
         return;
 
-    pinMode(config::pins_lamp, OUTPUT);
+    pinMode(config::pins_lamp.value(), OUTPUT);
     writeLamp(lampState);
 }
 
 void update_lamp()
 {
-    if (!config::enable_lamp)
+    if (!config::enable_lamp.value())
         return;
 }
 
 void writeLamp(bool state)
 {
-    if (config::invertLamp)
+    if (config::invertLamp.value())
         state = !state;
-    digitalWrite(config::pins_lamp, state ? HIGH : LOW);
+    digitalWrite(config::pins_lamp.value(), state ? HIGH : LOW);
 }
 } // namespace deckenlampe

main/feature_switch.cpp

@@ -23,15 +23,15 @@ bool readSwitch();
 
 void init_switch()
 {
-    if (!config::enable_switch)
+    if (!config::enable_switch.value())
         return;
 
-    pinMode(config::pins_switch, INPUT);
+    pinMode(config::pins_switch.value(), INPUT);
 }
 
 void update_switch()
 {
-    if (!config::enable_switch)
+    if (!config::enable_switch.value())
         return;
 
     if (espchrono::ago(last_switch_readout) < 20ms)
@@ -49,14 +49,14 @@ void update_switch()
             switchState = newState;
 
             if (mqttConnected)
-                mqttVerbosePub(config::topic_switch_status, switchState ? "ON" : "OFF", 0, 1);
+                mqttVerbosePub(config::topic_switch_status.value(), switchState ? "ON" : "OFF", 0, 1);
 
-            if (config::enable_lamp) {
+            if (config::enable_lamp.value()) {
                 lampState = !lampState;
                 writeLamp(lampState);
 
                 if (mqttConnected)
-                    mqttVerbosePub(config::topic_lamp_status, lampState ? "ON" : "OFF", 0, 1);
+                    mqttVerbosePub(config::topic_lamp_status.value(), lampState ? "ON" : "OFF", 0, 1);
             }
         }
     }
@@ -65,8 +65,8 @@ void update_switch()
 namespace {
 bool readSwitch()
 {
-    bool state = digitalRead(config::pins_switch) == HIGH;
+    bool state = digitalRead(config::pins_switch.value()) == HIGH;
-    if (config::invert_switch)
+    if (config::invert_switch.value())
         state = !state;
     return state;
 }

main/feature_tsl.cpp

@@ -28,7 +28,7 @@ espchrono::millis_clock::time_point last_tsl2561_readout;
 
 void init_tsl()
 {
-    if (!config::enable_i2c || !config::enable_tsl)
+    if (!config::enable_i2c.value() || !config::enable_tsl.value())
         return;
 
     tsl.construct(TSL2561_ADDR_FLOAT, 12345);
@@ -69,7 +69,7 @@ void init_tsl()
 
 void update_tsl()
 {
-    if (!config::enable_i2c || !config::enable_tsl)
+    if (!config::enable_i2c.value() || !config::enable_tsl.value())
         return;
 
     if (tslInitialized) {
@@ -89,9 +89,9 @@ void update_tsl()
 
                 if (mqttConnected) {
                     if (!lastTslValue)
-                        mqttVerbosePub(config::topic_tsl2561_availability, "online", 0, 1);
+                        mqttVerbosePub(config::topic_tsl2561_availability.value(), "online", 0, 1);
-                    if (!lastTslValue || espchrono::ago(last_tsl2561_lux_pub) >= config::valueUpdateInterval) {
+                    if (!lastTslValue || espchrono::ago(last_tsl2561_lux_pub) >= config::valueUpdateInterval.value()) {
-                        if (mqttVerbosePub(config::topic_tsl2561_lux, fmt::format("{:.1f}", tslValue.lux), 0, 1) >= 0)
+                        if (mqttVerbosePub(config::topic_tsl2561_lux.value(), fmt::format("{:.1f}", tslValue.lux), 0, 1) >= 0)
                             last_tsl2561_lux_pub = espchrono::millis_clock::now();
                     }
                 }
@@ -109,10 +109,10 @@ void update_tsl()
         }
     } else {
     tslOffline:
-        if (lastTslValue && espchrono::ago(lastTslValue->timestamp) >= config::availableTimeoutTime) {
+        if (lastTslValue && espchrono::ago(lastTslValue->timestamp) >= config::availableTimeoutTime.value()) {
             ESP_LOGW(TAG, "tsl timeouted");
             if (mqttConnected)
-                mqttVerbosePub(config::topic_tsl2561_availability, "offline", 0, 1);
+                mqttVerbosePub(config::topic_tsl2561_availability.value(), "offline", 0, 1);
             lastTslValue = std::nullopt;
         }
     }

main/futurecpp.h

@@ -0,0 +1,29 @@
+#pragma once
+
+// system includes
+#include <cstring>
+#include <limits>
+
+// C++20 backports (until espressif finally updates their aged compiler suite)
+
+namespace std {
+template <class To, class From>
+typename std::enable_if_t<
+    sizeof(To) == sizeof(From) && std::is_trivially_copyable_v<From> && std::is_trivially_copyable_v<To>,
+    To>
+// constexpr support needs compiler magic
+bit_cast(const From& src) noexcept
+{
+    static_assert(std::is_trivially_constructible_v<To>,
+                  "This implementation additionally requires destination type to be trivially constructible");
+
+    To dst;
+    std::memcpy(&dst, &src, sizeof(To));
+    return dst;
+}
+
+template <typename EnumT, typename = std::enable_if_t<std::is_enum<EnumT>{}>>
+constexpr std::underlying_type_t<EnumT> to_underlying(EnumT e) noexcept {
+    return static_cast<std::underlying_type_t<EnumT>>(e);
+}
+} // namespace std

main/main.cpp

@@ -81,10 +81,10 @@ extern "C" void app_main()
 
     init_switch();
 
-    if (config::enable_i2c)
+    if (config::enable_i2c.value())
     {
         ESP_LOGI(TAG, "calling Wire.begin()...");
-        const auto result = Wire.begin(config::pins_sda, config::pins_scl);
+        const auto result = Wire.begin(config::pins_sda.value(), config::pins_scl.value());
         ESP_LOGI(TAG, "finished with %s", result ? "true" : "false");
     }
 
@@ -104,31 +104,41 @@ extern "C" void app_main()
 
     while (true)
     {
-        update_config();
-
-        update_lamp();
-
-        update_wifi();
-
-        update_webserver();
-
-        update_mdns();
-
-        update_mqtt();
-
-        update_dht();
-
-        update_tsl();
-
-        update_bmp();
-
-        update_switch();
-
 #if defined(CONFIG_ESP_TASK_WDT_PANIC) || defined(CONFIG_ESP_TASK_WDT)
         if (const auto result = esp_task_wdt_reset(); result != ESP_OK)
             ESP_LOGE(TAG, "esp_task_wdt_reset() failed with %s", esp_err_to_name(result));
 #endif
 
+        update_config();
+        vPortYield();
+
+        update_lamp();
+        vPortYield();
+
+        update_wifi();
+        vPortYield();
+
+        update_webserver();
+        vPortYield();
+
+        update_mdns();
+        vPortYield();
+
+        update_mqtt();
+        vPortYield();
+
+        update_dht();
+        vPortYield();
+
+        update_tsl();
+        vPortYield();
+
+        update_bmp();
+        vPortYield();
+
+        update_switch();
+        vPortYield();
+
 #ifdef CONFIG_APP_ROLLBACK_ENABLE
         if (ota_state == ESP_OTA_IMG_PENDING_VERIFY)
         {
@@ -138,7 +148,7 @@ extern "C" void app_main()
         }
 #endif
 
-        vPortYield();
+        vTaskDelay(std::chrono::ceil<espcpputils::ticks>(20ms).count());
     }
 }
 

main/myconfig.cpp

@@ -4,11 +4,70 @@
 #include <nvs_flash.h>
 #include <esp_log.h>
 
+using namespace std::chrono_literals;
+
 namespace deckenlampe {
 nvs_handle_t nvsHandle;
 
+namespace config {
+ConfigWrapper<std::string> hostname{"hostname", "deckenlampe1"};
+
+ConfigWrapper<std::string> sta_ssid{"sta_ssid", "ScheissAP"};
+ConfigWrapper<std::string> sta_key{"sta_key", "Passwort_123"};
+
+ConfigWrapper<std::string> ap_ssid{"ap_ssid", "deckenlampe1"};
+ConfigWrapper<std::string> ap_key{"ap_key", "Passwort_123"};
+
+ConfigWrapper<bool> enable_webserver{"enable_webserver", true};
+
+ConfigWrapper<bool> enable_mdns{"enable_mdns", true};
+
+ConfigWrapper<bool> enable_mqtt{"enable_mqtt", true};
+ConfigWrapper<std::string> broker_url{"broker_url", "mqtt://192.168.0.2/"};
+
+ConfigWrapper<bool> enable_lamp{"enable_lamp", true};
+ConfigWrapper<gpio_num_t> pins_lamp{"pins_lamp", GPIO_NUM_4};
+ConfigWrapper<bool> invertLamp{"invertLamp", true};
+ConfigWrapper<std::string> topic_lamp_availability{"topic_lamp_availability", "dahoam/wohnzimmer/deckenlicht1/available"};
+ConfigWrapper<std::string> topic_lamp_status{"topic_lamp_status", "dahoam/wohnzimmer/deckenlicht1/status"};
+ConfigWrapper<std::string> topic_lamp_set{"topic_lamp_set", "dahoam/wohnzimmer/deckenlicht1/set"};
+
+
+ConfigWrapper<bool> enable_switch{"enable_switch", true};
+ConfigWrapper<gpio_num_t> pins_switch{"pins_switch", GPIO_NUM_35};
+ConfigWrapper<bool> invert_switch{"invert_switch", true};
+ConfigWrapper<std::string> topic_switch_availability{"topic_switch_availability", "dahoam/wohnzimmer/schalter1/available"};
+ConfigWrapper<std::string> topic_switch_status{"topic_switch_status", "dahoam/wohnzimmer/schalter1/status"};
+
+ConfigWrapper<bool> enable_dht{"enable_dht", true};
+ConfigWrapper<gpio_num_t> pins_dht{"pins_dht", GPIO_NUM_33};
+ConfigWrapper<std::string> topic_dht11_availability{"topic_dht11_availability", "dahoam/wohnzimmer/dht11_1/available"};
+ConfigWrapper<std::string> topic_dht11_temperature{"topic_dht11_temperature", "dahoam/wohnzimmer/dht11_1/temperature"};
+ConfigWrapper<std::string> topic_dht11_humidity{"topic_dht11_humidity", "dahoam/wohnzimmer/dht11_1/humidity"};
+
+ConfigWrapper<bool> enable_i2c{"enable_i2c", true};
+ConfigWrapper<gpio_num_t> pins_sda{"pins_sda", GPIO_NUM_16};
+ConfigWrapper<gpio_num_t> pins_scl{"pins_scl", GPIO_NUM_17};
+
+ConfigWrapper<bool> enable_tsl{"enable_tsl", true};
+ConfigWrapper<std::string> topic_tsl2561_availability{"topic_tsl2561_availability", "dahoam/wohnzimmer/tsl2561_1/available"};
+ConfigWrapper<std::string> topic_tsl2561_lux{"topic_tsl2561_lux", "dahoam/wohnzimmer/tsl2561_1/lux"};
+
+ConfigWrapper<bool> enable_bmp{"enable_bmp", true};
+ConfigWrapper<std::string> topic_bmp085_availability{"topic_bmp085_availability", "dahoam/wohnzimmer/bmp085_1/available"};
+ConfigWrapper<std::string> topic_bmp085_pressure{"topic_bmp085_pressure", "dahoam/wohnzimmer/bmp085_1/pressure"};
+ConfigWrapper<std::string> topic_bmp085_temperature{"topic_bmp085_temperature", "dahoam/wohnzimmer/bmp085_1/temperature"};
+ConfigWrapper<std::string> topic_bmp085_altitude{"topic_bmp085_altitude", "dahoam/wohnzimmer/bmp085_1/altitude"};
+
+ConfigWrapper<espchrono::seconds32> availableTimeoutTime{"availableTimeoutTime", 1min};
+ConfigWrapper<espchrono::seconds32> valueUpdateInterval{"valueUpdateInterval", 15s};
+} // namespace config
+
 namespace {
 constexpr const char * const TAG = "CONFIG";
+
+template<typename T>
+void loadParam(ConfigWrapper<T> &config);
 } // namespace
 
 void init_config()
@@ -16,21 +75,70 @@ void init_config()
     {
         const auto result = nvs_flash_init();
         ESP_LOG_LEVEL_LOCAL((result == ESP_OK ? ESP_LOG_INFO : ESP_LOG_ERROR), TAG, "nvs_flash_init(): %s", esp_err_to_name(result));
-        //if (result != ESP_OK)
+        if (result != ESP_OK)
-        //    return result;
+            return;
     }
 
     {
-        const auto result = nvs_open("deckenlampe", NVS_READWRITE, &nvsHandle);
+        constexpr const char* name = "deckenlampe";
-        ESP_LOG_LEVEL_LOCAL((result == ESP_OK ? ESP_LOG_INFO : ESP_LOG_ERROR), TAG, "nvs_open(): %s", esp_err_to_name(result));
+        const auto result = nvs_open(name, NVS_READWRITE, &nvsHandle);
-        //if (result != ESP_OK)
+        ESP_LOG_LEVEL_LOCAL((result == ESP_OK ? ESP_LOG_INFO : ESP_LOG_ERROR), TAG, "nvs_open() %s: %s", name, esp_err_to_name(result));
-        //    return result;
+        if (result != ESP_OK)
+            return;
     }
 
-    // TODO
+    loadParam(config::hostname);
+    loadParam(config::sta_ssid);
+    loadParam(config::sta_key);
+    loadParam(config::ap_ssid);
+    loadParam(config::ap_key);
+    loadParam(config::enable_webserver);
+    loadParam(config::enable_mdns);
+    loadParam(config::enable_mqtt);
+    loadParam(config::broker_url);
+    loadParam(config::enable_lamp);
+    loadParam(config::pins_lamp);
+    loadParam(config::invertLamp);
+    loadParam(config::topic_lamp_availability);
+    loadParam(config::topic_lamp_status);
+    loadParam(config::topic_lamp_set);
+    loadParam(config::enable_switch);
+    loadParam(config::pins_switch);
+    loadParam(config::invert_switch);
+    loadParam(config::topic_switch_availability);
+    loadParam(config::topic_switch_status);
+    loadParam(config::enable_dht);
+    loadParam(config::pins_dht);
+    loadParam(config::topic_dht11_availability);
+    loadParam(config::topic_dht11_temperature);
+    loadParam(config::topic_dht11_humidity);
+    loadParam(config::enable_i2c);
+    loadParam(config::pins_sda);
+    loadParam(config::pins_scl);
+    loadParam(config::enable_tsl);
+    loadParam(config::topic_tsl2561_availability);
+    loadParam(config::topic_tsl2561_lux);
+    loadParam(config::enable_bmp);
+    loadParam(config::topic_bmp085_availability);
+    loadParam(config::topic_bmp085_pressure);
+    loadParam(config::topic_bmp085_temperature);
+    loadParam(config::topic_bmp085_altitude);
+    loadParam(config::availableTimeoutTime);
+    loadParam(config::valueUpdateInterval);
 }
 
 void update_config()
 {
 }
+
+namespace {
+template<typename T>
+void loadParam(ConfigWrapper<T> &config)
+{
+    if (const auto value = config.readFromFlash())
+        config.setValue(*value);
+    else
+        ESP_LOGE(TAG, "error loading param %s: %.*s", config.key(), value.error().size(), value.error().data());
+}
+} // namespace
 } // namespace deckenlamp

main/myconfig.h

@@ -1,68 +1,71 @@
 #pragma once
 
 // system includes
-#include <string_view>
+#include <string>
-#include <chrono>
 
 // esp-idf includes
 #include <nvs.h>
 #include <hal/gpio_types.h>
 
+// local includes
+#include "espchrono.h"
+#include "configwrapper.h"
+
 namespace deckenlampe {
 extern nvs_handle_t nvsHandle;
 
 namespace config {
-constexpr const std::string_view hostname = "deckenlampe1";
+extern ConfigWrapper<std::string> hostname;
 
-constexpr const std::string_view sta_ssid = "ScheissAP";
+extern ConfigWrapper<std::string> sta_ssid;
-constexpr const std::string_view sta_key = "Passwort_123";
+extern ConfigWrapper<std::string> sta_key;
 
-constexpr const std::string_view ap_ssid = "deckenlampe1";
+extern ConfigWrapper<std::string> ap_ssid;
-constexpr const std::string_view ap_key = "Passwort_123";
+extern ConfigWrapper<std::string> ap_key;
 
-constexpr const bool enable_webserver = true;
+extern ConfigWrapper<bool> enable_webserver;
 
-constexpr const bool enable_mdns = true;
+extern ConfigWrapper<bool> enable_mdns;
 
-constexpr const bool enable_mqtt = true;
+extern ConfigWrapper<bool> enable_mqtt;
-constexpr const std::string_view broker_url = "mqtt://192.168.0.2/";
+extern ConfigWrapper<std::string> broker_url;
 
-constexpr const bool enable_lamp = true;
+extern ConfigWrapper<bool> enable_lamp;
-constexpr const gpio_num_t pins_lamp = GPIO_NUM_25;
+extern ConfigWrapper<gpio_num_t> pins_lamp;
-constexpr const bool invertLamp = true;
+extern ConfigWrapper<bool> invertLamp;
-constexpr const std::string_view topic_lamp_availability = "dahoam/wohnzimmer/deckenlicht1/available";
+extern ConfigWrapper<std::string> topic_lamp_availability;
-constexpr const std::string_view topic_lamp_status = "dahoam/wohnzimmer/deckenlicht1/status";
+extern ConfigWrapper<std::string> topic_lamp_status;
-constexpr const std::string_view topic_lamp_set = "dahoam/wohnzimmer/deckenlicht1/set";
+extern ConfigWrapper<std::string> topic_lamp_set;
 
 
-constexpr const bool enable_switch = true;
+extern ConfigWrapper<bool> enable_switch;
-constexpr const gpio_num_t pins_switch = GPIO_NUM_35;
+extern ConfigWrapper<gpio_num_t> pins_switch;
-constexpr const bool invert_switch = true;
+extern ConfigWrapper<bool> invert_switch;
-constexpr const std::string_view topic_switch_availability = "dahoam/wohnzimmer/schalter1/available";
+extern ConfigWrapper<std::string> topic_switch_availability;
-constexpr const std::string_view topic_switch_status = "dahoam/wohnzimmer/schalter1/status";
+extern ConfigWrapper<std::string> topic_switch_status;
 
-constexpr const bool enable_dht = true;
+extern ConfigWrapper<bool> enable_dht;
-constexpr const gpio_num_t pins_dht = GPIO_NUM_33;
+extern ConfigWrapper<gpio_num_t> pins_dht;
-constexpr const std::string_view topic_dht11_availability = "dahoam/wohnzimmer/dht11_1/available";
+extern ConfigWrapper<std::string> topic_dht11_availability;
-constexpr const std::string_view topic_dht11_temperature = "dahoam/wohnzimmer/dht11_1/temperature";
+extern ConfigWrapper<std::string> topic_dht11_temperature;
-constexpr const std::string_view topic_dht11_humidity = "dahoam/wohnzimmer/dht11_1/humidity";
+extern ConfigWrapper<std::string> topic_dht11_humidity;
 
-constexpr const bool enable_i2c = true;
+extern ConfigWrapper<bool> enable_i2c;
-constexpr const gpio_num_t pins_sda = GPIO_NUM_16;
+extern ConfigWrapper<gpio_num_t> pins_sda;
-constexpr const gpio_num_t pins_scl = GPIO_NUM_17;
+extern ConfigWrapper<gpio_num_t> pins_scl;
 
-constexpr const bool enable_tsl = true;
+extern ConfigWrapper<bool> enable_tsl;
-constexpr const std::string_view topic_tsl2561_availability = "dahoam/wohnzimmer/tsl2561_1/available";
+extern ConfigWrapper<std::string> topic_tsl2561_availability;
-constexpr const std::string_view topic_tsl2561_lux = "dahoam/wohnzimmer/tsl2561_1/lux";
+extern ConfigWrapper<std::string> topic_tsl2561_lux;
 
-constexpr const bool enable_bmp = true;
+extern ConfigWrapper<bool> enable_bmp;
-constexpr const std::string_view topic_bmp085_availability = "dahoam/wohnzimmer/bmp085_1/available";
+extern ConfigWrapper<std::string> topic_bmp085_availability;
-constexpr const std::string_view topic_bmp085_pressure = "dahoam/wohnzimmer/bmp085_1/pressure";
+extern ConfigWrapper<std::string> topic_bmp085_pressure;
-constexpr const std::string_view topic_bmp085_temperature = "dahoam/wohnzimmer/bmp085_1/temperature";
+extern ConfigWrapper<std::string> topic_bmp085_temperature;
-constexpr const std::string_view topic_bmp085_altitude = "dahoam/wohnzimmer/bmp085_1/altitude";
+extern ConfigWrapper<std::string> topic_bmp085_altitude;
 
-constexpr const std::chrono::minutes availableTimeoutTime{1};
+extern ConfigWrapper<espchrono::seconds32> availableTimeoutTime;
-constexpr const std::chrono::seconds valueUpdateInterval{15};
+extern ConfigWrapper<espchrono::seconds32> valueUpdateInterval;
 } // namespace configs
 
 void init_config();

main/mymdns.cpp

@@ -14,7 +14,7 @@ constexpr const char * const TAG = "MDNS";
 
 void init_mdns()
 {
-    if (!config::enable_mdns)
+    if (!config::enable_mdns.value())
         return;
 
     {
@@ -25,20 +25,20 @@ void init_mdns()
     }
 
     {
-        const auto result = mdns_hostname_set(config::hostname.data());
+        const auto result = mdns_hostname_set(config::hostname.value().c_str());
         ESP_LOG_LEVEL_LOCAL((result == ESP_OK ? ESP_LOG_INFO : ESP_LOG_ERROR), TAG, "mdns_hostname_set(): %s", esp_err_to_name(result));
         //if (result != ESP_OK)
         //    return result;
     }
 
     {
-        const auto result = mdns_instance_name_set(config::hostname.data());
+        const auto result = mdns_instance_name_set(config::hostname.value().c_str());
         ESP_LOG_LEVEL_LOCAL((result == ESP_OK ? ESP_LOG_INFO : ESP_LOG_ERROR), TAG, "mdns_instance_name_set(): %s", esp_err_to_name(result));
         //if (result != ESP_OK)
         //    return result;
     }
 
-    if (config::enable_webserver)
+    if (config::enable_webserver.value())
     {
         const auto result = mdns_service_add(NULL, "_http", "_tcp", 80, NULL, 0);
         ESP_LOG_LEVEL_LOCAL((result == ESP_OK ? ESP_LOG_INFO : ESP_LOG_ERROR), TAG, "mdns_service_add(): %s", esp_err_to_name(result));
@@ -49,7 +49,7 @@ void init_mdns()
 
 void update_mdns()
 {
-    if (!config::enable_mdns)
+    if (!config::enable_mdns.value())
         return;
 }
 } // namespace deckenlampe

main/mymqtt.cpp

@@ -28,11 +28,11 @@ void mqttEventHandler(void *event_handler_arg, esp_event_base_t event_base, int3
 
 void init_mqtt()
 {
-    if (!config::enable_mqtt)
+    if (!config::enable_mqtt.value())
         return;
 
     esp_mqtt_client_config_t mqtt_cfg = {
-        .uri = config::broker_url.data(),
+        .uri = config::broker_url.value().data(),
     };
 
     mqttClient = espcpputils::mqtt_client{&mqtt_cfg};
@@ -62,13 +62,19 @@ void init_mqtt()
 
 void update_mqtt()
 {
-    if (!config::enable_mqtt)
+    if (!config::enable_mqtt.value())
         return;
 }
 
 int mqttVerbosePub(std::string_view topic, std::string_view value, int qos, int retain)
 {
     ESP_LOGD(TAG, "topic=\"%.*s\" value=\"%.*s\"", topic.size(), topic.data(), value.size(), value.data());
+
+    if (!mqttClient) {
+        ESP_LOGE(TAG, "mqttClient not constructed!");
+        return -1;
+    }
+
     const auto pending_msg_id = mqttClient.publish(topic, value, qos, retain);
     if (pending_msg_id < 0)
         ESP_LOGE(TAG, "topic=\"%.*s\" value=\"%.*s\" failed pending_msg_id=%i", topic.size(), topic.data(), value.size(), value.data(), pending_msg_id);
@@ -104,43 +110,43 @@ void mqttEventHandler(void *event_handler_arg, esp_event_base_t event_base, int3
 
         mqttConnected = true;
 
-        if (config::enable_lamp) {
+        if (config::enable_lamp.value()) {
-            mqttVerbosePub(config::topic_lamp_availability, "online", 0, 1);
+            mqttVerbosePub(config::topic_lamp_availability.value(), "online", 0, 1);
-            mqttVerbosePub(config::topic_lamp_status, lampState.load() ? "ON" : "OFF", 0, 1);
+            mqttVerbosePub(config::topic_lamp_status.value(), lampState.load() ? "ON" : "OFF", 0, 1);
-            mqttClient.subscribe(config::topic_lamp_set, 0);
+            mqttClient.subscribe(config::topic_lamp_set.value(), 0);
         }
 
-        if (config::enable_switch) {
+        if (config::enable_switch.value()) {
-            mqttVerbosePub(config::topic_switch_availability, "online", 0, 1);
+            mqttVerbosePub(config::topic_switch_availability.value(), "online", 0, 1);
-            mqttVerbosePub(config::topic_switch_status, switchState.load() ? "ON" : "OFF", 0, 1);
+            mqttVerbosePub(config::topic_switch_status.value(), switchState.load() ? "ON" : "OFF", 0, 1);
         }
 
-        if (config::enable_dht) {
+        if (config::enable_dht.value()) {
-            mqttVerbosePub(config::topic_dht11_availability, lastDhtValue ? "online" : "offline", 0, 1);
+            mqttVerbosePub(config::topic_dht11_availability.value(), lastDhtValue ? "online" : "offline", 0, 1);
             if (lastDhtValue) {
-                if (mqttVerbosePub(config::topic_dht11_temperature, fmt::format("{:.1f}", lastDhtValue->temperature), 0, 1) >= 0)
+                if (mqttVerbosePub(config::topic_dht11_temperature.value(), fmt::format("{:.1f}", lastDhtValue->temperature), 0, 1) >= 0)
                     last_dht11_temperature_pub = espchrono::millis_clock::now();
-                if (mqttVerbosePub(config::topic_dht11_humidity, fmt::format("{:.1f}", lastDhtValue->humidity), 0, 1) >= 0)
+                if (mqttVerbosePub(config::topic_dht11_humidity.value(), fmt::format("{:.1f}", lastDhtValue->humidity), 0, 1) >= 0)
                     last_dht11_humidity_pub = espchrono::millis_clock::now();
             }
         }
 
-        if (config::enable_i2c && config::enable_tsl) {
+        if (config::enable_i2c.value() && config::enable_tsl.value()) {
-            mqttVerbosePub(config::topic_tsl2561_availability, lastTslValue ? "online" : "offline", 0, 1);
+            mqttVerbosePub(config::topic_tsl2561_availability.value(), lastTslValue ? "online" : "offline", 0, 1);
             if (lastTslValue) {
-                if (mqttVerbosePub(config::topic_tsl2561_lux, fmt::format("{:.1f}", lastTslValue->lux), 0, 1) >= 0)
+                if (mqttVerbosePub(config::topic_tsl2561_lux.value(), fmt::format("{:.1f}", lastTslValue->lux), 0, 1) >= 0)
                     last_tsl2561_lux_pub = espchrono::millis_clock::now();
             }
         }
 
-        if (config::enable_i2c && config::enable_bmp) {
+        if (config::enable_i2c.value() && config::enable_bmp.value()) {
-            mqttVerbosePub(config::topic_bmp085_availability, lastBmpValue ? "online" : "offline", 0, 1);
+            mqttVerbosePub(config::topic_bmp085_availability.value(), lastBmpValue ? "online" : "offline", 0, 1);
             if (lastBmpValue) {
-                if (mqttVerbosePub(config::topic_bmp085_pressure, fmt::format("{:.1f}", lastBmpValue->pressure), 0, 1) >= 0)
+                if (mqttVerbosePub(config::topic_bmp085_pressure.value(), fmt::format("{:.1f}", lastBmpValue->pressure), 0, 1) >= 0)
                     last_bmp085_pressure_pub = espchrono::millis_clock::now();
-                if (mqttVerbosePub(config::topic_bmp085_temperature, fmt::format("{:.1f}", lastBmpValue->temperature), 0, 1) >= 0)
+                if (mqttVerbosePub(config::topic_bmp085_temperature.value(), fmt::format("{:.1f}", lastBmpValue->temperature), 0, 1) >= 0)
                     last_bmp085_temperature_pub = espchrono::millis_clock::now();
-                if (mqttVerbosePub(config::topic_bmp085_altitude, fmt::format("{:.1f}", lastBmpValue->altitude), 0, 1) >= 0)
+                if (mqttVerbosePub(config::topic_bmp085_altitude.value(), fmt::format("{:.1f}", lastBmpValue->altitude), 0, 1) >= 0)
                     last_bmp085_altitude_pub = espchrono::millis_clock::now();
             }
         }
@@ -172,12 +178,12 @@ void mqttEventHandler(void *event_handler_arg, esp_event_base_t event_base, int3
 
         ESP_LOGI(TAG, "%s event_id=%s topic=%.*s data=%.*s", event_base, "MQTT_EVENT_DATA", topic.size(), topic.data(), value.size(), value.data());
 
-        if (topic == config::topic_lamp_set) {
+        if (topic == config::topic_lamp_set.value()) {
-            if (config::enable_lamp) {
+            if (config::enable_lamp.value()) {
                 bool newState = (lampState = (value == "ON"));
                 writeLamp(newState);
                 if (mqttConnected)
-                    mqttVerbosePub(config::topic_lamp_status, newState ? "ON" : "OFF", 0, 1);
+                    mqttVerbosePub(config::topic_lamp_status.value(), newState ? "ON" : "OFF", 0, 1);
             } else {
                 ESP_LOGW(TAG, "received lamp set without lamp support enabled!");
             }

main/mywifi.cpp

@@ -24,9 +24,9 @@ wifi_stack::config makeWifiConfig()
 {
     return wifi_stack::config {
         .wifiEnabled = true,
-        .hostname = std::string{config::hostname},
+        .hostname = config::hostname.value(),
         .wifis = std::array<wifi_stack::wifi_entry, 10> {
-            wifi_stack::wifi_entry { .ssid = std::string{config::sta_ssid}, .key = std::string{config::sta_key} },
+            wifi_stack::wifi_entry { .ssid = config::sta_ssid.value(), .key = config::sta_key.value() },
             wifi_stack::wifi_entry { .ssid = {}, .key = {} },
             wifi_stack::wifi_entry { .ssid = {}, .key = {} },
             wifi_stack::wifi_entry { .ssid = {}, .key = {} },
@@ -47,16 +47,16 @@ wifi_stack::config makeWifiConfig()
         },
         .ap = {
             {
-                .ssid = std::string{config::ap_ssid},
+                .ssid = config::ap_ssid.value(),
-                .key = std::string{config::ap_key}
+                .key = config::ap_key.value()
             },
             .channel = 1,
             .authmode = WIFI_AUTH_WPA2_PSK,
             .ssid_hidden = false,
             .max_connection = 4,
             .beacon_interval = 100,
-            .ip{192, 168, 4, 1},
+            .ip = ap_ip,
-            .subnet{255, 255, 255, 0}
+            .subnet = ap_subnet
         },
         .min_rssi = -90
     };

main/mywifi.h

@@ -1,6 +1,12 @@
 #pragma once
 
+// local includes
+#include "espwifiutils.h"
+
 namespace deckenlampe {
+constexpr const wifi_stack::ip_address_t ap_ip{192, 168, 4, 1};
+constexpr const wifi_stack::ip_address_t ap_subnet{255, 255, 255, 0};
+
 void init_wifi();
 void update_wifi();
 } // namespace deckenlampe

main/webserver.cpp

@@ -38,11 +38,12 @@ esp_err_t webserver_reboot_handler(httpd_req_t *req);
 
 void init_webserver()
 {
-    if (!config::enable_webserver)
+    if (!config::enable_webserver.value())
         return;
 
     {
         httpd_config_t httpConfig HTTPD_DEFAULT_CONFIG();
+        httpConfig.core_id = 1;
 
         const auto result = httpd_start(&httpdHandle, &httpConfig);
         ESP_LOG_LEVEL_LOCAL((result == ESP_OK ? ESP_LOG_INFO : ESP_LOG_ERROR), TAG, "httpd_start(): %s", esp_err_to_name(result));
@@ -67,7 +68,7 @@ void init_webserver()
 
 void update_webserver()
 {
-    if (!config::enable_webserver)
+    if (!config::enable_webserver.value())
         return;
 }
 
@@ -92,7 +93,7 @@ esp_err_t webserver_root_handler(httpd_req_t *req)
 {
     std::string body = "this is work in progress...<br/>\n";
 
-    if (config::enable_lamp) {
+    if (config::enable_lamp.value()) {
         body += "<a href=\"/on\">on</a><br/>\n"
                 "<a href=\"/off\">off</a><br/>\n"
                 "<a href=\"/toggle\">toggle</a><br/>\n";
@@ -101,13 +102,13 @@ esp_err_t webserver_root_handler(httpd_req_t *req)
     body += "<a href=\"/reboot\">reboot</a><br/>\n"
             "<br/>\n";
 
-    if (config::enable_lamp)
+    if (config::enable_lamp.value())
         body += fmt::format("Lamp: {}<br/>\n", lampState ? "ON" : "OFF");
 
-    if (config::enable_switch)
+    if (config::enable_switch.value())
         body += fmt::format("Switch: {}<br/>\n", switchState ? "ON" : "OFF");
 
-    if (config::enable_dht) {
+    if (config::enable_dht.value()) {
         if (lastDhtValue) {
             body += fmt::format("DHT11 Temperature: {:.1f} C<br/>\n", lastDhtValue->temperature);
             body += fmt::format("DHT11 Humidity: {:.1f} %<br/>\n", lastDhtValue->humidity);
@@ -115,14 +116,14 @@ esp_err_t webserver_root_handler(httpd_req_t *req)
             body += "DHT11 not available at the moment<br/>\n";
     }
 
-    if (config::enable_i2c && config::enable_tsl) {
+    if (config::enable_i2c.value() && config::enable_tsl.value()) {
         if (lastTslValue) {
             body += fmt::format("TSL2561 Brightness: {:.1f} lux<br/>\n", lastTslValue->lux);
         } else
             body += "TSL2561 not available at the moment<br/>\n";
     }
 
-    if (config::enable_i2c && config::enable_bmp) {
+    if (config::enable_i2c.value() && config::enable_bmp.value()) {
         if (lastBmpValue) {
             body += fmt::format("BMP085 Pressure: {:.1f} lux<br/>\n", lastBmpValue->pressure);
             body += fmt::format("BMP085 Temperature: {:.1f} C<br/>\n", lastBmpValue->temperature);
@@ -205,16 +206,18 @@ esp_err_t webserver_root_handler(httpd_req_t *req)
         body += "<span style=\"color: red;\">no wifi scan result at the moment!</span><br/>\n";
     }
 
+    if (config::enable_mqtt.value()) {
         body += "<br/>\n"
                 "<h2>MQTT</h2>\n"
                 "<table border=\"1\">\n";
-    body += fmt::format("<tr><th>client url</th><td>{}</td></tr>\n", htmlentities(config::broker_url));
+        body += fmt::format("<tr><th>client url</th><td>{}</td></tr>\n", htmlentities(config::broker_url.value()));
         body += fmt::format("<tr><th>client constructed</th><td>{}</td></tr>\n", mqttClient ? "true" : "false");
         if (mqttClient) {
             body += fmt::format("<tr><th>client started</th><td>{}</td></tr>\n", mqttStarted ? "true" : "false");
             body += fmt::format("<tr><th>client connected</th><td>{}</td></tr>\n", mqttConnected ? "true" : "false");
         }
         body += "</table>\n";
+    }
 
     CALL_AND_EXIT_ON_ERROR(httpd_resp_set_type, req, "text/html")
     CALL_AND_EXIT_ON_ERROR(httpd_resp_send, req, body.data(), body.size())
@@ -224,7 +227,7 @@ esp_err_t webserver_root_handler(httpd_req_t *req)
 
 esp_err_t webserver_on_handler(httpd_req_t *req)
 {
-    if (!config::enable_lamp) {
+    if (!config::enable_lamp.value()) {
         ESP_LOGW(TAG, "lamp support not enabled!");
         CALL_AND_EXIT_ON_ERROR(httpd_resp_send_err, req, HTTPD_400_BAD_REQUEST, "lamp support not enabled!")
     }
@@ -233,7 +236,7 @@ esp_err_t webserver_on_handler(httpd_req_t *req)
     writeLamp(state);
 
     if (mqttConnected)
-        mqttVerbosePub(config::topic_lamp_status, state ? "ON" : "OFF", 0, 1);
+        mqttVerbosePub(config::topic_lamp_status.value(), state ? "ON" : "OFF", 0, 1);
 
     std::string_view body{"ON called..."};
     CALL_AND_EXIT_ON_ERROR(httpd_resp_set_type, req, "text/html")
@@ -244,7 +247,7 @@ esp_err_t webserver_on_handler(httpd_req_t *req)
 
 esp_err_t webserver_off_handler(httpd_req_t *req)
 {
-    if (!config::enable_lamp) {
+    if (!config::enable_lamp.value()) {
         ESP_LOGW(TAG, "lamp support not enabled!");
         CALL_AND_EXIT_ON_ERROR(httpd_resp_send_err, req, HTTPD_400_BAD_REQUEST, "lamp support not enabled!")
     }
@@ -253,7 +256,7 @@ esp_err_t webserver_off_handler(httpd_req_t *req)
     writeLamp(state);
 
     if (mqttConnected)
-        mqttVerbosePub(config::topic_lamp_status, state ? "ON" : "OFF", 0, 1);
+        mqttVerbosePub(config::topic_lamp_status.value(), state ? "ON" : "OFF", 0, 1);
 
     std::string_view body{"OFF called..."};
     CALL_AND_EXIT_ON_ERROR(httpd_resp_set_type, req, "text/html")
@@ -264,7 +267,7 @@ esp_err_t webserver_off_handler(httpd_req_t *req)
 
 esp_err_t webserver_toggle_handler(httpd_req_t *req)
 {
-    if (!config::enable_lamp) {
+    if (!config::enable_lamp.value()) {
         ESP_LOGW(TAG, "lamp support not enabled!");
         CALL_AND_EXIT_ON_ERROR(httpd_resp_send_err, req, HTTPD_400_BAD_REQUEST, "lamp support not enabled!")
     }
@@ -273,7 +276,7 @@ esp_err_t webserver_toggle_handler(httpd_req_t *req)
     writeLamp(state);
 
     if (mqttConnected)
-        mqttVerbosePub(config::topic_lamp_status, state ? "ON" : "OFF", 0, 1);
+        mqttVerbosePub(config::topic_lamp_status.value(), state ? "ON" : "OFF", 0, 1);
 
     std::string_view body{"TOGGLE called..."};
     CALL_AND_EXIT_ON_ERROR(httpd_resp_set_type, req, "text/html")

sdkconfig

@@ -976,7 +976,9 @@ CONFIG_MDNS_TIMER_PERIOD_MS=100
 # CONFIG_MQTT_SKIP_PUBLISH_IF_DISCONNECTED is not set
 # CONFIG_MQTT_REPORT_DELETED_MESSAGES is not set
 # CONFIG_MQTT_USE_CUSTOM_CONFIG is not set
-# CONFIG_MQTT_TASK_CORE_SELECTION_ENABLED is not set
+CONFIG_MQTT_TASK_CORE_SELECTION_ENABLED=y
+# CONFIG_MQTT_USE_CORE_0 is not set
+CONFIG_MQTT_USE_CORE_1=y
 # CONFIG_MQTT_CUSTOM_OUTBOX is not set
 # end of ESP-MQTT Configurations