Restart BLE controller

2025-06-15 21:13:45 +02:00
parent b60bbf032f
commit f8b68ff2fa
14 changed files with 384 additions and 114 deletions
--- a/boards/nuki-esp32-c5dbg.json
+++ b/boards/nuki-esp32-c5dbg.json
@@ -0,0 +1,31 @@
+{
+  "build": {
+    "core": "esp32",
+    "f_cpu": "240000000L",
+    "f_flash": "80000000L",
+    "flash_mode": "qio",
+    "mcu": "esp32c5",
+    "variant": "esp32c5"
+  },
+  "connectivity": [
+    "bluetooth",
+    "wifi"
+  ],
+  "debug": {
+    "openocd_target": "esp32c5.cfg"
+  },
+  "frameworks": [
+    "arduino",
+    "espidf"
+  ],
+  "name": "ESP32-C5 (>=8MB QD, QUAD OR NO PSRAM)",
+  "upload": {
+    "flash_size": "8MB",
+    "maximum_ram_size": 327680,
+    "maximum_size": 8388608,
+    "require_upload_port": true,
+    "speed": 460800
+  },
+  "url": "https://docs.espressif.com/projects/esp-dev-kits/en/latest/esp32c5/esp32-c5-devkitc-1/user_guide.html",
+  "vendor": "Espressif"
+}
--- a/lib/BleScanner/src/BleScanner.cpp
+++ b/lib/BleScanner/src/BleScanner.cpp
@@ -20,6 +20,16 @@ Scanner::Scanner(int reservedSubscribers) {
  subscribers.reserve(reservedSubscribers);
 }

+Scanner::~Scanner() {
+  Serial.println("Destroying scanner");
+  bleScan->stop();
+  Serial.println("bleScan stopped");
+  bleScan->clearResults();
+  Serial.println("bleScan results cleared");
+  bleScan = nullptr;
+  Serial.println("bleScan nulled");
+}
+
 void Scanner::initialize(const std::string& deviceName, const bool wantDuplicates, const uint16_t interval, const uint16_t window) {
  if (!BLEDevice::isInitialized()) {
    if (wantDuplicates) {
--- a/lib/BleScanner/src/BleScanner.h
+++ b/lib/BleScanner/src/BleScanner.h
@@ -25,7 +25,7 @@ namespace BleScanner {
 class Scanner : public Publisher, BLEAdvertisedDeviceCallbacks {
  public:
    Scanner(int reservedSubscribers = 10);
-    ~Scanner() = default;
+    ~Scanner();

    static Scanner& instance() {
      static Scanner* scanner = new Scanner(); // only initialized once on first call
--- a/partitions_c5dbg.csv
+++ b/partitions_c5dbg.csv
@@ -0,0 +1 @@
+# Espressif ESP32 Partition Table
--- a/platformio.ini
+++ b/platformio.ini
@@ -179,9 +179,11 @@ build_flags =

 [env:esp32-c5_dbg]
 extends = env:esp32-c5
+board_build.partitions = partitions_c5dbg.csv
+board = nuki-esp32-c5dbg
 custom_build = debug
 board_build.cmake_extra_args =
-    -DSDKCONFIG_DEFAULTS="sdkconfig.defaults;sdkconfig.debug.defaults;sdkconfig.defaults.esp32-c5;sdkconfig.singlecore.defaults"
+    -DSDKCONFIG_DEFAULTS="sdkconfig.defaults;sdkconfig.debug.defaults;sdkconfig.defaults.esp32-c5;sdkconfig.defaults.esp32-c5dbg;sdkconfig.singlecore.defaults"
 build_flags =
    ${env.build_flags}
    -DCORE_DEBUG_LEVEL=ARDUHAL_LOG_LEVEL_DEBUG
--- a/sdkconfig.defaults.esp32-c5
+++ b/sdkconfig.defaults.esp32-c5
@@ -2,4 +2,5 @@ CONFIG_SPIRAM=y
 CONFIG_SPIRAM_IGNORE_NOTFOUND=y
 CONFIG_MBEDTLS_DEFAULT_MEM_ALLOC=y
 CONFIG_BT_NIMBLE_MEM_ALLOC_MODE_DEFAULT=y
+CONFIG_ESPTOOLPY_NO_STUB=n
 CONFIG_SPIRAM_MALLOC_RESERVE_INTERNAL=50768
--- a/sdkconfig.defaults.esp32-c5dbg
+++ b/sdkconfig.defaults.esp32-c5dbg
@@ -0,0 +1,4 @@
+CONFIG_ESPTOOLPY_FLASHSIZE_8MB=y
+CONFIG_BT_NIMBLE_LOG_LEVEL_DEBUG=y
+CONFIG_BT_NIMBLE_LOG_LEVEL=4
+CONFIG_NIMBLE_CPP_LOG_LEVEL=4
--- a/src/Config.h
+++ b/src/Config.h
@@ -5,7 +5,7 @@
 #define NUKI_HUB_VERSION "9.11"
 #define NUKI_HUB_VERSION_INT (uint32_t)911
 #define NUKI_HUB_BUILD "unknownbuildnr"
-#define NUKI_HUB_DATE "2025-06-10"
+#define NUKI_HUB_DATE "2025-06-15"

 #define GITHUB_LATEST_RELEASE_URL (char*)"https://github.com/technyon/nuki_hub/releases/latest"
 #define GITHUB_OTA_MANIFEST_URL (char*)"https://raw.githubusercontent.com/technyon/nuki_hub/binary/ota/manifest.json"
--- a/src/NukiNetwork.cpp
+++ b/src/NukiNetwork.cpp
@@ -1142,7 +1142,9 @@ void NukiNetwork::onMqttDataReceived(const char* topic, byte* payload, const uns
                            {
                                duoResult = _importExport->checkDuoApprove();
                                delay(2000);
+                                #if !defined(CONFIG_IDF_TARGET_ESP32C5)
                                esp_task_wdt_reset();
+                                #endif
                            }
                        }

--- a/src/NukiOpenerWrapper.cpp
+++ b/src/NukiOpenerWrapper.cpp
@@ -214,6 +214,16 @@ void NukiOpenerWrapper::readSettings()
    }
 }

+uint8_t NukiOpenerWrapper::restartController()
+{
+    return _restartController;
+}
+
+bool NukiOpenerWrapper::hasConnected()
+{
+    return _hasConnected;
+}
+
 void NukiOpenerWrapper::update()
 {
    wdt_hal_context_t rtc_wdt_ctx = RWDT_HAL_CONTEXT_DEFAULT();
@@ -254,9 +264,9 @@ void NukiOpenerWrapper::update()
    {
        Log->print("No BLE beacon received from the opener for ");
        Log->print((ts - lastReceivedBeaconTs) / 1000);
-        Log->println(" seconds, restarting device.");
+        Log->println(" seconds, signalling to restart BLE controller.");
        delay(200);
-        restartEsp(RestartReason::BLEBeaconWatchdog);
+        _restartController = 2;
    }

    _nukiOpener.updateConnectionState();
@@ -501,6 +511,11 @@ bool NukiOpenerWrapper::updateKeyTurnerState()
        _network->publishKeyTurnerState(_keyTurnerState, _lastKeyTurnerState);
        return false;
    }
+    else if (!_hasConnected)
+    {
+        _hasConnected = true;
+    }
+
    _retryLockstateCount = 0;

    const NukiOpener::LockState& lockState = _keyTurnerState.lockState;
@@ -4067,8 +4082,8 @@ void NukiOpenerWrapper::notify(Nuki::EventType eventType)
    }
    else if(eventType == Nuki::EventType::BLE_ERROR_ON_DISCONNECT)
    {
-        Log->println("Error in disconnecting BLE client, rebooting");
-        restartEsp(RestartReason::BLEError);
+        Log->println("Error in disconnecting BLE client, signalling to restart BLE controller");
+        _restartController = 1;
    }
 }

--- a/src/NukiOpenerWrapper.h
+++ b/src/NukiOpenerWrapper.h
@@ -25,6 +25,7 @@ public:
    void deactivateRTO();
    void deactivateCM();

+    bool hasConnected();
    bool isPinValid();
    void setPin(const uint16_t pin);
    uint16_t getPin();
@@ -36,6 +37,7 @@ public:
    const bool isPaired() const;
    const bool hasKeypad() const;
    const BLEAddress getBleAddress() const;
+    uint8_t restartController();

    std::string firmwareVersion() const;
    std::string hardwareVersion() const;
@@ -135,9 +137,11 @@ private:
    bool _forceKeypad = false;
    bool _keypadEnabled = false;
    bool _forceId = false;
+    bool _hasConnected = false;
    uint _maxKeypadCodeCount = 0;
    uint _maxTimeControlEntryCount = 0;
    uint _maxAuthEntryCount = 0;
+    uint8_t _restartController = 0;
    int _rssiPublishInterval = 0;
    int64_t _statusUpdatedTs = 0;
    int64_t _nextLockStateUpdateTs = 0;
--- a/src/NukiWrapper.cpp
+++ b/src/NukiWrapper.cpp
@@ -229,6 +229,16 @@ void NukiWrapper::readSettings()
    }
 }

+uint8_t NukiWrapper::restartController()
+{
+    return _restartController;
+}
+
+bool NukiWrapper::hasConnected()
+{
+    return _hasConnected;
+}
+
 void NukiWrapper::update(bool reboot)
 {
    wdt_hal_context_t rtc_wdt_ctx = RWDT_HAL_CONTEXT_DEFAULT();
@@ -270,9 +280,9 @@ void NukiWrapper::update(bool reboot)
    {
        Log->print("No BLE beacon received from the lock for ");
        Log->print((ts - lastReceivedBeaconTs) / 1000);
-        Log->println(" seconds, restarting device.");
+        Log->println(" seconds, signalling to restart BLE controller.");
        delay(200);
-        restartEsp(RestartReason::BLEBeaconWatchdog);
+        _restartController = 2;
    }

    _nukiLock.updateConnectionState();
@@ -535,6 +545,10 @@ bool NukiWrapper::updateKeyTurnerState()
        _network->publishKeyTurnerState(_keyTurnerState, _lastKeyTurnerState);
        return false;
    }
+    else if (!_hasConnected)
+    {
+        _hasConnected = true;
+    }

    _retryLockstateCount = 0;

@@ -4320,8 +4334,8 @@ void NukiWrapper::notify(Nuki::EventType eventType)
            }
            else if(eventType == Nuki::EventType::BLE_ERROR_ON_DISCONNECT)
            {
-                Log->println("Error in disconnecting BLE client, rebooting");
-                restartEsp(RestartReason::BLEError);
+                Log->println("Error in disconnecting BLE client, signalling to restart BLE controller");
+                _restartController = 1;
            }
        }
    }
--- a/src/NukiWrapper.h
+++ b/src/NukiWrapper.h
@@ -27,6 +27,7 @@ public:
    void lockngo();
    void lockngounlatch();

+    bool hasConnected();
    bool isPinValid();
    void setPin(const uint16_t pin);
    void setUltraPin(const uint32_t pin);
@@ -42,6 +43,7 @@ public:
    bool hasDoorSensor() const;
    bool offConnected();
    const BLEAddress getBleAddress() const;
+    uint8_t restartController();

    std::string firmwareVersion() const;
    std::string hardwareVersion() const;
@@ -142,9 +144,11 @@ private:
    bool _forceId = false;
    bool _isUltra = false;
    bool _isDebugging = false;
+    bool _hasConnected = false;
    uint _maxKeypadCodeCount = 0;
    uint _maxTimeControlEntryCount = 0;
    uint _maxAuthEntryCount = 0;
+    uint8_t _restartController = 0;    
    int _nrOfRetries = 0;
    int _retryDelay = 0;
    int _retryConfigCount = 0;
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -53,10 +53,14 @@ NukiDeviceId* deviceIdOpener = nullptr;
 Gpio* gpio = nullptr;
 SerialReader* serialReader = nullptr;

+bool bleDone = false;
 bool lockEnabled = false;
 bool openerEnabled = false;
 bool wifiConnected = false;
 bool rebootLock = false;
+uint8_t lockRestartControllerCount = 0;
+uint8_t openerRestartControllerCount = 0;
+char16_t buffer_size = CHAR_BUFFER_SIZE;

 TaskHandle_t nukiTaskHandle = nullptr;

@@ -78,6 +82,7 @@ int64_t restartTs = 10 * 60 * 1000;
 char log_print_buffer[1024];

 PsychicHttpServer* psychicServer = nullptr;
+PsychicHttpServer* psychicServerRedirect = nullptr;
 PsychicHttpsServer* psychicSSLServer = nullptr;
 NukiNetwork* network = nullptr;
 WebCfgServer* webCfgServer = nullptr;
@@ -95,10 +100,12 @@ RTC_NOINIT_ATTR bool forceEnableWebServer;
 RTC_NOINIT_ATTR bool disableNetwork;
 RTC_NOINIT_ATTR bool wifiFallback;
 RTC_NOINIT_ATTR bool ethCriticalFailure;
+
 bool coredumpPrinted = true;
 bool timeSynced = false;
 bool webStarted = false;
 bool webSSLStarted = false;
+uint8_t partitionType = -1;

 int lastHTTPeventId = -1;
 bool doOta = false;
@@ -176,11 +183,15 @@ uint8_t checkPartition()
    Log->print("Partition subtype: ");
    Log->println(running_partition->subtype);

+
+    #if !defined(CONFIG_IDF_TARGET_ESP32C5) && !defined(CONFIG_IDF_TARGET_ESP32P4)
    if(running_partition->size == 1966080)
    {
        return 0;    //OLD PARTITION TABLE
    }
-    else if(running_partition->subtype == ESP_PARTITION_SUBTYPE_APP_OTA_0)
+    #endif
+
+    if(running_partition->subtype == ESP_PARTITION_SUBTYPE_APP_OTA_0)
    {
        return 1;    //NEW PARTITION TABLE, RUNNING MAIN APP
    }
@@ -307,7 +318,7 @@ void networkTask(void *pvParameters)

        if(espMillis() > restartTs)
        {
-            uint8_t partitionType = checkPartition();
+            partitionType = checkPartition();

            if(partitionType!=1)
            {
@@ -316,11 +327,202 @@ void networkTask(void *pvParameters)

            restartEsp(RestartReason::RestartTimer);
        }
+        #if !defined(CONFIG_IDF_TARGET_ESP32C5)
        esp_task_wdt_reset();
+        #endif
    }
 }

 #ifndef NUKI_HUB_UPDATER
+void startWebServer()
+{
+    #ifdef CONFIG_SOC_SPIRAM_SUPPORTED
+    bool failed = false;
+
+    if (esp_psram_get_size() <= 0) {
+        Log->println("Not running on PSRAM enabled device");
+        failed = true;
+    }
+    else
+    {
+        if (!SPIFFS.begin(true)) {
+            Log->println("SPIFFS Mount Failed");
+            failed = true;
+        }
+        else
+        {
+            File file = SPIFFS.open("/http_ssl.crt");
+            if (!file || file.isDirectory()) {
+                failed = true;
+                Log->println("http_ssl.crt not found");
+            }
+            else
+            {
+                Log->println("Reading http_ssl.crt");
+                size_t filesize = file.size();
+                char cert[filesize + 1];
+
+                file.read((uint8_t *)cert, sizeof(cert));
+                file.close();
+                cert[filesize] = '\0';
+
+                File file2 = SPIFFS.open("/http_ssl.key");
+                if (!file2 || file2.isDirectory()) {
+                    failed = true;
+                    Log->println("http_ssl.key not found");
+                }
+                else
+                {
+                    Log->println("Reading http_ssl.key");
+                    size_t filesize2 = file2.size();
+                    char key[filesize2 + 1];
+
+                    file2.read((uint8_t *)key, sizeof(key));
+                    file2.close();
+                    key[filesize2] = '\0';
+
+                    psychicServerRedirect = new PsychicHttpServer();
+                    psychicServerRedirect->config.ctrl_port = 20424;
+                    psychicServerRedirect->onNotFound([](PsychicRequest* request, PsychicResponse* response) {
+                        String url = "https://" + request->host() + request->url();
+                        if (preferences->getString(preference_https_fqdn, "") != "")
+                        {
+                            url = "https://" + preferences->getString(preference_https_fqdn) + request->url();
+                        }
+
+                        response->setCode(301);
+                        response->addHeader("Cache-Control", "no-cache");
+                        return response->redirect(url.c_str());
+                    });
+                    psychicServerRedirect->begin();
+                    psychicSSLServer = new PsychicHttpsServer;
+                    psychicSSLServer->ssl_config.httpd.max_open_sockets = 8;
+                    psychicSSLServer->setCertificate(cert, key);
+                    psychicSSLServer->config.stack_size = HTTPD_TASK_SIZE;
+                    webCfgServerSSL = new WebCfgServer(nuki, nukiOpener, network, gpio, preferences, network->networkDeviceType() == NetworkDeviceType::WiFi, partitionType, psychicSSLServer, importExport);
+                    webCfgServerSSL->initialize();
+                    psychicSSLServer->onNotFound([](PsychicRequest* request, PsychicResponse* response) {
+                        return response->redirect("/");
+                    });
+                    psychicSSLServer->begin();
+                    webSSLStarted = true;
+                }
+            }
+        }
+    }
+
+    if (failed)
+    {
+    #endif
+        psychicServer = new PsychicHttpServer;
+        psychicServer->config.stack_size = HTTPD_TASK_SIZE;
+        webCfgServer = new WebCfgServer(nuki, nukiOpener, network, gpio, preferences, network->networkDeviceType() == NetworkDeviceType::WiFi, partitionType, psychicServer, importExport);
+        webCfgServer->initialize();
+        psychicServer->onNotFound([](PsychicRequest* request, PsychicResponse* response) {
+            return response->redirect("/");
+        });
+        psychicServer->begin();
+        webStarted = true;
+    #ifdef CONFIG_SOC_SPIRAM_SUPPORTED
+    }
+    #endif
+}
+
+void restartBle()
+{
+    bleDone = false;
+
+    if(webSSLStarted)
+    {
+        Log->println("Reset Psychic SSL server");
+        psychicSSLServer->reset();
+        Log->println("Reset Psychic SSL server done");
+        Log->println("Deleting Psychic SSL server");
+        delete psychicSSLServer;
+        psychicSSLServer = nullptr;
+        Log->println("Deleting Psychic SSL server done");
+    }
+
+    if(webStarted)
+    {
+        Log->println("Reset Psychic server");
+        psychicServer->reset();
+        Log->println("Reset Psychic server done");
+        Log->println("Deleting Psychic server");
+        delete psychicServer;
+        psychicServer = nullptr;
+        Log->println("Deleting Psychic server done");
+    }
+
+    if(webStarted || webSSLStarted)
+    {
+        Log->println("Deleting webCfgServer");
+        delete webCfgServer;
+        webCfgServer = nullptr;
+        Log->println("Deleting webCfgServer done");
+    }
+
+    if(lockEnabled)
+    {
+        Log->println("Deleting nuki");
+        delete nuki;
+        nuki = nullptr;
+        Log->println("Deleting nuki done");
+    }
+
+    if(openerEnabled)
+    {
+        Log->println("Deleting nukiOpener");
+        delete nukiOpener;
+        nukiOpener = nullptr;
+        Log->println("Deleting nukiOpener done");
+    }
+
+    Log->println("Destroying scanner from main");
+    delete bleScanner;
+    Log->println("Scanner deleted");
+    bleScanner = nullptr;
+    Log->println("Scanner nulled from main");
+
+    if (BLEDevice::isInitialized()) {
+        Log->println("Deinit BLE device");
+        BLEDevice::deinit(false);
+        Log->println("Deinit BLE device done");
+    }
+
+    delay(2000);
+    Log->println("Restarting BLE Scanner");
+    bleScanner = new BleScanner::Scanner();
+    bleScanner->initialize("NukiHub", true, 40, 40);
+    bleScanner->setScanDuration(0);
+    Log->println("Restarting BLE Scanner done");
+
+    if(lockEnabled)
+    {
+        Log->println("Restarting Nuki lock");
+        nuki = new NukiWrapper("NukiHub", deviceIdLock, bleScanner, networkLock, nukiOfficial, gpio, preferences, CharBuffer::get(), buffer_size);
+        nuki->initialize();
+        Log->println("Restarting Nuki lock done");
+    }
+
+    if(openerEnabled)
+    {
+        Log->println("Restarting Nuki opener");
+        nukiOpener = new NukiOpenerWrapper("NukiHub", deviceIdOpener, bleScanner, networkOpener, gpio, preferences, CharBuffer::get(), buffer_size);
+        nukiOpener->initialize();
+        Log->println("Restarting Nuki opener done");
+    }
+
+    bleDone = true;
+
+    if(webStarted || webSSLStarted)
+    {
+        Log->println("Restarting web server");
+        startWebServer();
+        Log->println("Restarting web server done");
+    }
+}
+
 void nukiTask(void *pvParameters)
 {
    if (preferences->getBool(preference_mqtt_ssl_enabled, false))
@@ -340,7 +542,7 @@ void nukiTask(void *pvParameters)
    bool whiteListed = false;
    while(true)
    {
-        if(disableNetwork || wifiConnected)
+        if((disableNetwork || wifiConnected) && bleDone)
        {
            bleScanner->update();
            delay(20);
@@ -366,22 +568,79 @@ void nukiTask(void *pvParameters)

            if(lockEnabled)
            {
+                if (nuki->restartController() > 0)
+                {
+                    if (lockRestartControllerCount > 3)
+                    {
+                        if (nuki->restartController() == 1)
+                        {
+                            restartEsp(RestartReason::BLEError);
+                        }
+                        else if (nuki->restartController() == 2)
+                        {
+                            restartEsp(RestartReason::BLEBeaconWatchdog);
+                        }
+                    }
+                    else
+                    {
+                        lockRestartControllerCount += 1;
+                        restartBle();
+                        continue;
+                    }
+                }
+                else
+                {
+                    if (lockRestartControllerCount > 0 && nuki->hasConnected())
+                    {
+                        lockRestartControllerCount = 0;
+                    }
+                    
                    nuki->update(rebootLock);
                    rebootLock = false;
                }
+            }
            if(openerEnabled)
            {
+                if (nukiOpener->restartController() > 0)
+                {
+                    if (openerRestartControllerCount > 3)
+                    {
+                        if (nukiOpener->restartController() == 1)
+                        {
+                            restartEsp(RestartReason::BLEError);
+                        }
+                        else if (nukiOpener->restartController() == 2)
+                        {
+                            restartEsp(RestartReason::BLEBeaconWatchdog);
+                        }
+                    }
+                    else
+                    {
+                        openerRestartControllerCount += 1;
+                        restartBle();
+                        continue;
+                    }
+                }
+                else
+                {
+                    if (openerRestartControllerCount > 0 && nukiOpener->hasConnected())
+                    {
+                        openerRestartControllerCount = 0;
+                    }
+                    
                    nukiOpener->update();
                }
            }
+        }

        if(espMillis() - nukiLoopTs > 120000)
        {
            Log->println("nukiTask is running");
            nukiLoopTs = espMillis();
        }
-
+        #if !defined(CONFIG_IDF_TARGET_ESP32C5)
        esp_task_wdt_reset();
+        #endif
    }
 }

@@ -472,7 +731,7 @@ esp_err_t _http_event_handler(esp_http_client_event_t *evt)

 void otaTask(void *pvParameter)
 {
-    uint8_t partitionType = checkPartition();
+    partitionType = checkPartition();
    String updateUrl;

    if(partitionType==1)
@@ -525,7 +784,9 @@ void otaTask(void *pvParameter)
        {
            Log->println("Firmware upgrade failed, retrying in 5 seconds");
            retryCount++;
+            #if !defined(CONFIG_IDF_TARGET_ESP32C5)
            esp_task_wdt_reset();
+            #endif
            delay(5000);
            continue;
        }
@@ -542,6 +803,7 @@ void otaTask(void *pvParameter)
 void setupTasks(bool ota)
 {
    // configMAX_PRIORITIES is 25
+    #if !defined(CONFIG_IDF_TARGET_ESP32C5)
    esp_task_wdt_config_t twdt_config =
    {
        .timeout_ms = 300000,
@@ -549,6 +811,7 @@ void setupTasks(bool ota)
        .trigger_panic = true,
    };
    esp_task_wdt_reconfigure(&twdt_config);
+    #endif

    esp_chip_info_t info;
    esp_chip_info(&info);
@@ -559,20 +822,26 @@ void setupTasks(bool ota)
    if(ota)
    {
        xTaskCreatePinnedToCore(otaTask, "ota", 8192, NULL, 2, &otaTaskHandle, (espCores > 1) ? 1 : 0);
+        #if !defined(CONFIG_IDF_TARGET_ESP32C5)
        esp_task_wdt_add(otaTaskHandle);
+        #endif
    }
    else
    {
        if(!disableNetwork)
        {
            xTaskCreatePinnedToCore(networkTask, "ntw", preferences->getInt(preference_task_size_network, NETWORK_TASK_SIZE), NULL, 3, &networkTaskHandle, (espCores > 1) ? 1 : 0);
+            #if !defined(CONFIG_IDF_TARGET_ESP32C5)
            esp_task_wdt_add(networkTaskHandle);
+            #endif
        }
 #ifndef NUKI_HUB_UPDATER
        if(!network->isApOpen() && (lockEnabled || openerEnabled))
        {
            xTaskCreatePinnedToCore(nukiTask, "nuki", preferences->getInt(preference_task_size_nuki, NUKI_TASK_SIZE), NULL, 2, &nukiTaskHandle, 0);
+            #if !defined(CONFIG_IDF_TARGET_ESP32C5)
            esp_task_wdt_add(nukiTaskHandle);
+            #endif
        }
 #endif
    }
@@ -678,7 +947,7 @@ void setup()
    Serial.begin(115200);
    Log = &Serial;

-#ifndef NUKI_HUB_UPDATER
+#if !defined(NUKI_HUB_UPDATER) && !defined(CONFIG_IDF_TARGET_ESP32C5)
    //
    stdout = funopen(NULL, NULL, &write_fn, NULL, NULL);
    static char linebuf[1024];
@@ -705,7 +974,7 @@ void setup()
        listDir(SPIFFS, "/", 1);
    }

-    uint8_t partitionType = checkPartition();
+    partitionType = checkPartition();

    //default disableNetwork RTC_ATTR to false on power-on
    if(espRunning != 1)
@@ -861,7 +1130,7 @@ void setup()
        deviceIdOpener->assignId(deviceIdLock->get());
    }

-    char16_t buffer_size = preferences->getInt(preference_buffer_size, CHAR_BUFFER_SIZE);
+    buffer_size = preferences->getInt(preference_buffer_size, CHAR_BUFFER_SIZE);
    CharBuffer::initialize(buffer_size);

    gpio = new Gpio(preferences);
@@ -928,100 +1197,13 @@ void setup()
        nukiOpener->initialize();
    }

+    bleDone = true;
+
    if(!doOta && !disableNetwork && (forceEnableWebServer || preferences->getBool(preference_webserver_enabled, true) || preferences->getBool(preference_webserial_enabled, false)))
    {
        if(forceEnableWebServer || preferences->getBool(preference_webserver_enabled, true))
        {
-            #ifdef CONFIG_SOC_SPIRAM_SUPPORTED
-            bool failed = false;
-
-            if (esp_psram_get_size() <= 0) {
-                Log->println("Not running on PSRAM enabled device");
-                failed = true;
-            }
-            else
-            {
-                if (!SPIFFS.begin(true)) {
-                    Log->println("SPIFFS Mount Failed");
-                    failed = true;
-                }
-                else
-                {
-                    File file = SPIFFS.open("/http_ssl.crt");
-                    if (!file || file.isDirectory()) {
-                        failed = true;
-                        Log->println("http_ssl.crt not found");
-                    }
-                    else
-                    {
-                        Log->println("Reading http_ssl.crt");
-                        size_t filesize = file.size();
-                        char cert[filesize + 1];
-
-                        file.read((uint8_t *)cert, sizeof(cert));
-                        file.close();
-                        cert[filesize] = '\0';
-
-                        File file2 = SPIFFS.open("/http_ssl.key");
-                        if (!file2 || file2.isDirectory()) {
-                            failed = true;
-                            Log->println("http_ssl.key not found");
-                        }
-                        else
-                        {
-                            Log->println("Reading http_ssl.key");
-                            size_t filesize2 = file2.size();
-                            char key[filesize2 + 1];
-
-                            file2.read((uint8_t *)key, sizeof(key));
-                            file2.close();
-                            key[filesize2] = '\0';
-
-                            psychicServer = new PsychicHttpServer();
-                            psychicServer->config.ctrl_port = 20424;
-                            psychicServer->onNotFound([](PsychicRequest* request, PsychicResponse* response) {
-                                String url = "https://" + request->host() + request->url();
-                                if (preferences->getString(preference_https_fqdn, "") != "")
-                                {
-                                    url = "https://" + preferences->getString(preference_https_fqdn) + request->url();
-                                }
-
-                                response->setCode(301);
-                                response->addHeader("Cache-Control", "no-cache");
-                                return response->redirect(url.c_str());
-                            });
-                            psychicServer->begin();
-                            psychicSSLServer = new PsychicHttpsServer;
-                            psychicSSLServer->ssl_config.httpd.max_open_sockets = 8;
-                            psychicSSLServer->setCertificate(cert, key);
-                            psychicSSLServer->config.stack_size = HTTPD_TASK_SIZE;
-                            webCfgServerSSL = new WebCfgServer(nuki, nukiOpener, network, gpio, preferences, network->networkDeviceType() == NetworkDeviceType::WiFi, partitionType, psychicSSLServer, importExport);
-                            webCfgServerSSL->initialize();
-                            psychicSSLServer->onNotFound([](PsychicRequest* request, PsychicResponse* response) {
-                                return response->redirect("/");
-                            });
-                            psychicSSLServer->begin();
-                            webSSLStarted = true;
-                        }
-                    }
-                }
-            }
-
-            if (failed)
-            {
-            #endif
-                psychicServer = new PsychicHttpServer;
-                psychicServer->config.stack_size = HTTPD_TASK_SIZE;
-                webCfgServer = new WebCfgServer(nuki, nukiOpener, network, gpio, preferences, network->networkDeviceType() == NetworkDeviceType::WiFi, partitionType, psychicServer, importExport);
-                webCfgServer->initialize();
-                psychicServer->onNotFound([](PsychicRequest* request, PsychicResponse* response) {
-                    return response->redirect("/");
-                });
-                psychicServer->begin();
-                webStarted = true;
-            #ifdef CONFIG_SOC_SPIRAM_SUPPORTED
-            }
-            #endif
+            startWebServer();
        }
        /*
 #ifdef DEBUG_NUKIHUB