Merge pull request #652 from doudar/UpdatesFix

Fixed BLE and WiFI (App) updates

Author: doudar

.actrc

@@ -9,10 +9,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+### Changed
+
+### Hardware
+
+
+## [25.7.29]
+
+### Added
+
 ### Changed
 - Removed unused file. 
 - Added license to test files.
 - Fixed unterminated comment.
+- Fixed BLE and WiFI updates.
 
 ### Hardware
 

CHANGELOG.md

@@ -118,7 +118,7 @@ void logCharacteristic(char* buffer, const size_t bufferCapacity, const byte* da
 void calculateInstPwrFromHR();
 
 // BLE FIRMWARE UPDATER
-void BLEFirmwareSetup();
+void BLEFirmwareSetup(NimBLEServer* pServer);
 
 // *****************************Client*****************************
 

include/BLE_Common.h

@@ -71,7 +71,8 @@ lib_deps =
     https://github.com/bblanchon/ArduinoJson/archive/refs/tags/v7.3.1.zip
     ;https://github.com/gin66/FastAccelStepper/archive/refs/tags/0.31.2.zip
     https://github.com/doudar/FastAccelStepper/
-    https://github.com/gilmaimon/ArduinoWebsockets/archive/refs/tags/0.5.4.zip
+    ;https://github.com/gilmaimon/ArduinoWebsockets/archive/refs/tags/0.5.4.zip
+    https://github.com/doudar/ArduinoWebsockets/
     ;https://github.com/Links2004/arduinoWebSockets
     ;https://github.com/doudar/NimBLE-Arduino/
 

platformio.ini

@@ -521,7 +521,8 @@ CONFIG_ARDUINO_SELECTIVE_HTTPClient=y
 CONFIG_ARDUINO_SELECTIVE_WebServer=y
 CONFIG_ARDUINO_SELECTIVE_WiFi=y
 CONFIG_ARDUINO_SELECTIVE_NetworkClientSecure=y
-CONFIG_ARDUINO_SELECTIVE_WiFiProv=y
+# default:
+# CONFIG_ARDUINO_SELECTIVE_WiFiProv is not set
 CONFIG_ARDUINO_SELECTIVE_BLE=y
 # default:
 # CONFIG_ARDUINO_SELECTIVE_BluetoothSerial is not set
@@ -539,8 +540,8 @@ CONFIG_ARDUINO_SELECTIVE_BLE=y
 # Compiler options
 #
 # CONFIG_COMPILER_OPTIMIZATION_DEBUG is not set
-CONFIG_COMPILER_OPTIMIZATION_SIZE=y
-# CONFIG_COMPILER_OPTIMIZATION_PERF is not set
+# CONFIG_COMPILER_OPTIMIZATION_SIZE is not set
+CONFIG_COMPILER_OPTIMIZATION_PERF=y
 # CONFIG_COMPILER_OPTIMIZATION_NONE is not set
 CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_ENABLE=y
 # CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_SILENT is not set

sdkconfig.release.old

@@ -146,6 +146,7 @@ void bleClientTask(void *pvParameters) {
 
     // disconnect all connected servers if we're updating via BLE
     if (ss2k->isUpdating) {
+      SS2K_LOG(BLE_CLIENT_LOG_TAG, "Disconnecting all connected servers due to update.");
       for (auto &_BLEd : spinBLEClient.myBLEDevices) {  // loop through discovered devices
         if (_BLEd.connectedClientID != BLE_HS_CONN_HANDLE_NONE) {
           if (_BLEd.advertisedDevice) {                                                                // is device registered?
@@ -160,15 +161,19 @@ void bleClientTask(void *pvParameters) {
       }
       while (ss2k->isUpdating) {  // wait until the update is done
         delay(100);
+        if(NimBLEDevice::getScan()->isScanning()) {  // if we're scanning, stop it
+          NimBLEDevice::getScan()->stop();  // stop scanning if we're updating
+        }
       }
+      SS2K_LOG(BLE_CLIENT_LOG_TAG, "Update complete, re-enabling BLE scanning.");
     }
 
     // Post connect previously connected clients. This needs to be before connect, as it takes a while to complete the connection (let it loop once.)
     spinBLEClient.postConnect();
 
     // Connect BLE Servers to this client
     for (int x = 0; x < NUM_BLE_DEVICES; x++) {
-      if (spinBLEClient.myBLEDevices[x].doConnect == true && !ss2k->isUpdating) {
+      if (spinBLEClient.myBLEDevices[x].doConnect == true) {
         // stop in process scans
         NimBLEScan *pBLEScan = NimBLEDevice::getScan();
         if (pBLEScan->isScanning()) {
@@ -186,9 +191,9 @@ void bleClientTask(void *pvParameters) {
 
     // Scan for BLE devices that we should connect to this client
     static unsigned long scanDelay = millis();
-    if ((millis() - scanDelay) > BLE_RECONNECT_SCAN_INTERVAL) {
+    if (((millis() - scanDelay) > BLE_RECONNECT_SCAN_INTERVAL)) {
       spinBLEClient.checkBLEReconnect();
-      if (spinBLEClient.doScan && (!ss2k->isUpdating)) {
+      if (spinBLEClient.doScan) {
         spinBLEClient.scanProcess(DEFAULT_SCAN_DURATION);
       }
       scanDelay = millis();

src/BLE_Client.cpp

@@ -15,6 +15,8 @@
 #include <NimBLEDevice.h>
 #include <BLE_Custom_Characteristic.h>
 
+#define BLE_OTA_LOG_TAG "BLE_OTA"
+
 /*------------------------------------------------------------------------------
   BLE instances & variables
   ----------------------------------------------------------------------------*/
@@ -40,7 +42,7 @@ bool downloadFlag = false;
   ----------------------------------------------------------------------------*/
 
 class otaCallback : public BLECharacteristicCallbacks {
-  void onWrite(BLECharacteristic *pCharacteristic, ble_gap_conn_desc *connDesc) {
+  void onWrite(NimBLECharacteristic *pCharacteristic, NimBLEConnInfo &connInfo) override {
     std::string rxData = pCharacteristic->getValue();
     bufferCount++;
 
@@ -52,33 +54,36 @@ class otaCallback : public BLECharacteristicCallbacks {
       // update the connection interval so that it provides enough time for the long writes
 
       Serial.printf("1. BeginOTA");
-      BLEDevice::getServer()->updateConnParams(connDesc->conn_handle, 12, 12, 0, 1000);
+      BLEDevice::getServer()->updateConnParams(connInfo.getConnHandle(), 12, 12, 0, 1000);
       const esp_partition_t *configured = esp_ota_get_boot_partition();
       const esp_partition_t *running    = esp_ota_get_running_partition();
 
       if (configured != running) {
-        Serial.printf("ERROR: Configured OTA boot partition at offset 0x%08x, but running from offset 0x%08x", configured->address, running->address);
-        Serial.printf("(This can happen if either the OTA boot data or preferred boot image become corrupted somehow.)");
+        SS2K_LOG(BLE_OTA_LOG_TAG, "ERROR: Configured OTA boot partition at offset 0x%08x, but running from offset 0x%08x", configured->address, running->address);
+        SS2K_LOG(BLE_OTA_LOG_TAG, "(This can happen if either the OTA boot data or preferred boot image become corrupted somehow.)");
         downloadFlag = false;
         esp_ota_end(otaHandler);
       } else {
-        Serial.printf("2. Running partition type %d subtype %d (offset 0x%08x) \n", running->type, running->subtype, running->address);
+        SS2K_LOG(BLE_OTA_LOG_TAG, "2. Running partition type %d subtype %d (offset 0x%08x) \n", running->type, running->subtype, running->address);
       }
 
       update_partition = esp_ota_get_next_update_partition(NULL);
-      assert(update_partition != NULL);
+      if (update_partition == NULL) {
+        SS2K_LOG(BLE_OTA_LOG_TAG, "ERROR: No valid partition found");
+        downloadFlag     = false;
+        ss2k->rebootFlag = true;
+        return;
+      }
 
-      Serial.printf("3. Writing to partition subtype %d at offset 0x%x \n", update_partition->subtype, update_partition->address);
+      SS2K_LOG(BLE_OTA_LOG_TAG, "3. Writing to partition subtype %d at offset 0x%x \n", update_partition->subtype, update_partition->address);
 
       //------------------------------------------------------------------------------------------
       // esp_ota_begin can take a while to complete as it erase the flash partition (3-5 seconds)
       // so make sure there's no timeout on the client side (iOS) that triggers before that.
       //------------------------------------------------------------------------------------------
-      esp_task_wdt_config_t wdt_config = {
-          .timeout_ms = 10000, // 10 seconds
-          .idle_core_mask = 0,
-          .trigger_panic = false
-      };
+      esp_task_wdt_config_t wdt_config = {.timeout_ms     = 20000,  // 20 seconds
+                                          .idle_core_mask = 0,
+                                          .trigger_panic  = false};
       esp_task_wdt_init(&wdt_config);
 
       // if (BLECommunicationTask != NULL) {
@@ -97,26 +102,27 @@ class otaCallback : public BLECharacteristicCallbacks {
       // vTaskDelay(5);
 
       if (esp_ota_begin(update_partition, OTA_SIZE_UNKNOWN, &otaHandler) != ESP_OK) {
-        downloadFlag = false;
-         ss2k->isUpdating = false;
+        downloadFlag     = false;
+        ss2k->isUpdating = false;
+        SS2K_LOG(BLE_OTA_LOG_TAG, "OTA begin failed");
         return;
       }
       downloadFlag = true;
     }
 
     if (bufferCount >= 1 || rxData.length() > 0) {
       if (esp_ota_write(otaHandler, (uint8_t *)rxData.c_str(), rxData.length()) != ESP_OK) {
-        Serial.printf("Error: write to flash failed");
+        SS2K_LOG(BLE_OTA_LOG_TAG, "Error: write to flash failed");
         downloadFlag = false;
         pTxCharacteristic->notify(0x04, 1);
+        ss2k->rebootFlag = true;
         return;
       } else {
         bufferCount = 1;
         // Serial.printf("%d bytes", rxData.length());
         //  Notify the iOS app so next batch can be sent
         Serial.printf(".");
-        // pTxCharacteristic->setValue(0x02, sizeof(uint8_t));
-        // pTxCharacteristic->notify();
+        pTxCharacteristic->notify(0x02, sizeof(uint8_t));
       }
 
       //-------------------------------------------------------------------
@@ -126,50 +132,54 @@ class otaCallback : public BLECharacteristicCallbacks {
       //-------------------------------------------------------------------
       if (rxData.length() < 512)  // TODO Asumes at least 511 data bytes (@BLE 4.2).
       {
-        Serial.printf("4. Final byte arrived");
+        SS2K_LOG(BLE_OTA_LOG_TAG, "4. Final byte arrived");
         //-----------------------------------------------------------------
         // Final chunk arrived. Now check that
         // the length of total file is correct
         //-----------------------------------------------------------------
         if (esp_ota_end(otaHandler) != ESP_OK) {
-          Serial.printf("OTA end failed ");
+          SS2K_LOG(BLE_OTA_LOG_TAG, "OTA end failed ");
           downloadFlag = false;
           pTxCharacteristic->notify(0x04, sizeof(uint8_t));
+          ss2k->rebootFlag = true;
           return;
         }
         pTxCharacteristic->notify(0x05, sizeof(uint8_t));
         //-----------------------------------------------------------------
         // Clear download flag and restart the ESP32 if the firmware
         // update was successful
         //-----------------------------------------------------------------
-        Serial.printf("Set Boot partion");
+        SS2K_LOG(BLE_OTA_LOG_TAG, "Set Boot partition");
         if (ESP_OK == esp_ota_set_boot_partition(update_partition)) {
           esp_ota_end(otaHandler);
           downloadFlag = false;
-          Serial.printf("Restarting...");
+          SS2K_LOG(BLE_OTA_LOG_TAG, "Restarting...");
           ss2k->rebootFlag = true;
           return;
         } else {
           //------------------------------------------------------------
           // Something went wrong, the upload was not successful
           //------------------------------------------------------------
-          Serial.printf("Upload Error");
+          SS2K_LOG(BLE_OTA_LOG_TAG, "Upload Error");
           pTxCharacteristic->notify(0x04, sizeof(uint8_t));
           downloadFlag = false;
           esp_ota_end(otaHandler);
+          ss2k->rebootFlag = true;
           return;
         }
       }
     } else {
-       ss2k->isUpdating = false;
-      downloadFlag = false;
+      SS2K_LOG(BLE_OTA_LOG_TAG, "Data Length < 1");
+      ss2k->isUpdating = false;
+      downloadFlag     = false;
+      ss2k->rebootFlag = true;
     }
   }
 };
 
-void BLEFirmwareSetup() {
+void BLEFirmwareSetup(NimBLEServer *pServer) {
   // 3. Create BLE Service
-  NimBLEService *pService = spinBLEServer.pServer->createService(FIRMWARE_SERVICE_UUID);
+  NimBLEService *pService = pServer->createService(FIRMWARE_SERVICE_UUID);
 
   // 4. Create BLE Characteristics inside the service(s)
   pTxCharacteristic = pService->createCharacteristic(FIRMWARE_CHARACTERISTIC_TX_UUID, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::NOTIFY);

src/BLE_Firmware_Update.cpp

@@ -51,7 +51,7 @@ void startBLEServer() {
   deviceInformationService.setupService(spinBLEServer.pServer);
   // wattbikeService.setupService(spinBLEServer.pServer);  // No callback needed
   // sb20Service.begin();
-  BLEFirmwareSetup();
+  BLEFirmwareSetup(spinBLEServer.pServer);
 
   // const std::string fitnessData = {0b00000001, 0b00100000, 0b00000000};
   // pAdvertising->setServiceData(FITNESSMACHINESERVICE_UUID, fitnessData);

src/BLE_Server.cpp

@@ -310,61 +310,75 @@ void HTTP_Server::start() {
     server.send(200, "text/html", OTAServerIndex);
   });
 
-  /*handling uploading firmware file */
   server.on(
       "/update", HTTP_POST,
+      // This is the onComplete callback. It is executed ONLY after the upload is fully finished.
+      // This is the correct and only place to send the final response to the client.
       []() {
         server.sendHeader("Connection", "close");
-        server.send(200, "text/plain", (Update.hasError()) ? "FAIL" : "OK");
+        // Check if the Update process reported an error and send the final status.
+        if (Update.hasError()) {
+          // You can get more specific error information if you want
+          // size_t len = Update.getErrorString(error_string_buffer, 128);
+          // server.send(500, "text/plain", error_string_buffer);
+          server.send(500, "text/plain", "FAIL");
+        } else {
+          server.send(200, "text/plain", "OK");
+          // It's better to trigger the reboot after successfully notifying the client.
+          ss2k->rebootFlag = true;
+        }
       },
+      // This is the onUpload callback. It handles the file data as it arrives.
+      // It should not send any response to the client.
       []() {
         HTTPUpload &upload = server.upload();
         if (upload.filename == String("firmware.bin").c_str()) {
-          ss2k->isUpdating = true;  // Set the updating flag to true
           if (upload.status == UPLOAD_FILE_START) {
-            SS2K_LOG(HTTP_SERVER_LOG_TAG, "Update: %s", upload.filename.c_str());
-            if (!Update.begin(UPDATE_SIZE_UNKNOWN, U_FLASH)) {  // start with max
-                                                                // available size
+            ss2k->isUpdating = true;  // Set the updating flag to true
+            SS2K_LOG(HTTP_SERVER_LOG_TAG, "Update Start: %s", upload.filename.c_str());
+            if (!Update.begin(UPDATE_SIZE_UNKNOWN, U_FLASH)) {
               Update.printError(Serial);
             }
           } else if (upload.status == UPLOAD_FILE_WRITE) {
             /* flashing firmware to ESP*/
+            Serial.printf(".");
             if (Update.write(upload.buf, upload.currentSize) != upload.currentSize) {
               Update.printError(Serial);
+              SS2K_LOG(HTTP_SERVER_LOG_TAG, "Upload Write Failed.");
             }
           } else if (upload.status == UPLOAD_FILE_END) {
-            if (Update.end(true)) {  // true to set the size to the
-                                     // current progress
-              server.send(200, "text/plain", "Firmware Uploaded Successfully. Rebooting...");
-              ESP.restart();
+            // Finalize the update. The true parameter tells it to flash the remaining buffer.
+            // DO NOT send a response here.
+            if (Update.end(true)) {
+              SS2K_LOG(HTTP_SERVER_LOG_TAG, "Firmware Upload Finished Successfully.");
             } else {
               Update.printError(Serial);
+              SS2K_LOG(HTTP_SERVER_LOG_TAG, "Unknown OTA issue on end.");
             }
+            // The reboot will be triggered in the onComplete handler after the response.
           }
-          ss2k->isUpdating = false;  // Reset the updating flag
         } else if (upload.filename == String("littlefs.bin").c_str()) {
           if (upload.status == UPLOAD_FILE_START) {
-            SS2K_LOG(HTTP_SERVER_LOG_TAG, "Update: %s", upload.filename.c_str());
-            if (!Update.begin(UPDATE_SIZE_UNKNOWN, U_SPIFFS)) {  // start with max
-                                                                 // available size
+            SS2K_LOG(HTTP_SERVER_LOG_TAG, "Update Start: %s", upload.filename.c_str());
+            if (!Update.begin(UPDATE_SIZE_UNKNOWN, U_SPIFFS)) {
               Update.printError(Serial);
             }
           } else if (upload.status == UPLOAD_FILE_WRITE) {
-            /* flashing firmware to ESP*/
+            Serial.printf(".");
             if (Update.write(upload.buf, upload.currentSize) != upload.currentSize) {
               Update.printError(Serial);
             }
           } else if (upload.status == UPLOAD_FILE_END) {
-            if (Update.end(true)) {  // true to set the size to the
-                                     // current progress
-              server.send(200, "text/plain", "Littlefs Uploaded Successfully. Rebooting...");
+            // Finalize the update.
+            // DO NOT send a response here.
+            if (Update.end(true)) {
+              SS2K_LOG(HTTP_SERVER_LOG_TAG, "Littlefs Upload Finished Successfully.");
               userConfig->saveToLittleFS();
-              ss2k->rebootFlag == true;
             } else {
               Update.printError(Serial);
             }
           }
-        } else {
+        } else {  // Handles other file uploads to LittleFS
           if (upload.status == UPLOAD_FILE_START) {
             String filename = upload.filename;
             if (!filename.startsWith("/")) {
@@ -382,7 +396,10 @@ void HTTP_Server::start() {
               fsUploadFile.close();
             }
             SS2K_LOG(HTTP_SERVER_LOG_TAG, "handleFileUpload Size: %zu", upload.totalSize);
-            server.send(200, "text/plain", String(upload.filename + " Uploaded Successfully."));
+            // For non-firmware files, it's okay to send a response here,
+            // but for consistency, it's better to let the onComplete handler do it.
+            // For this example, we assume the main onComplete handler is for firmware.
+            // A more robust solution would check which type of file was uploaded.
           }
         }
       });