espressif/common-hal/_bleio/Adapter.c: use busy-waiting, to allow background tasks to run

Author: dhalbert

locale/circuitpython.pot

@@ -2219,8 +2219,9 @@ msgstr ""
 msgid "Unsupported hash algorithm"
 msgstr ""
 
+#: ports/espressif/common-hal/_bleio/Adapter.c
 #: ports/espressif/common-hal/dualbank/__init__.c
-msgid "Update Failed"
+msgid "Update failed"
 msgstr ""
 
 #: ports/espressif/common-hal/_bleio/Characteristic.c

ports/espressif/common-hal/_bleio/Adapter.c

@@ -24,6 +24,7 @@
 #include "shared-bindings/_bleio/Connection.h"
 #include "shared-bindings/_bleio/ScanEntry.h"
 #include "shared-bindings/time/__init__.h"
+#include "shared/runtime/interrupt_char.h"
 
 #include "controller/ble_ll_adv.h"
 #include "nimble/hci_common.h"
@@ -47,22 +48,23 @@
 #include "shared-module/os/__init__.h"
 #endif
 
-bleio_connection_internal_t bleio_connections[BLEIO_TOTAL_CONNECTION_COUNT];
+// Status variables used while busy-waiting for events.
+static volatile bool _nimble_sync;
+static volatile int _connection_status;
 
-bool ble_active = false;
+bleio_connection_internal_t bleio_connections[BLEIO_TOTAL_CONNECTION_COUNT];
 
 static void nimble_host_task(void *param) {
     nimble_port_run();
     nimble_port_freertos_deinit();
 }
 
-static TaskHandle_t cp_task = NULL;
 
 static void _on_sync(void) {
     int rc = ble_hs_util_ensure_addr(false);
     assert(rc == 0);
 
-    xTaskNotifyGive(cp_task);
+    _nimble_sync = true;
 }
 
 // All examples have this. It'd make sense in a header.
@@ -133,15 +135,26 @@ void common_hal_bleio_adapter_set_enabled(bleio_adapter_obj_t *self, bool enable
 
         ble_store_config_init();
 
-        cp_task = xTaskGetCurrentTaskHandle();
-
+        _nimble_sync = false;
         nimble_port_freertos_init(nimble_host_task);
-        // Wait for sync.
-        ulTaskNotifyTake(pdTRUE, pdMS_TO_TICKS(200));
+        // Wait for sync from nimble task.
+        const uint64_t timeout_time_ms = common_hal_time_monotonic_ms() + 200;
+        while (!_nimble_sync && (common_hal_time_monotonic_ms() < timeout_time_ms)) {
+            RUN_BACKGROUND_TASKS;
+            if (mp_hal_is_interrupted()) {
+                // Return prematurely. Then the interrupt will be raised.
+                return;
+            }
+        }
+
+        if (!_nimble_sync) {
+            mp_raise_RuntimeError(MP_ERROR_TEXT("Update failed"));
+        }
     } else {
         int ret = nimble_port_stop();
-        while (xTaskGetHandle("nimble_host") != NULL) {
-            vTaskDelay(pdMS_TO_TICKS(2));
+        while (xTaskGetHandle("nimble_host") != NULL && !mp_hal_is_interrupted()) {
+            RUN_BACKGROUND_TASKS;
+            common_hal_time_delay_ms(2);
         }
         if (ret == 0) {
             nimble_port_deinit();
@@ -309,15 +322,16 @@ static int _mtu_reply(uint16_t conn_handle,
     if (error->status == 0) {
         connection->mtu = mtu;
     }
-    xTaskNotify(cp_task, conn_handle, eSetValueWithOverwrite);
+    // Set status var to connection handle to report that connection is now established.
+    // Another routine is waiting for this.
+    _connection_status = conn_handle;
     return 0;
 }
 
 static void _new_connection(uint16_t conn_handle) {
     // Set the tx_power for the connection higher than the advertisement.
     esp_ble_tx_power_set(conn_handle, ESP_PWR_LVL_N0);
 
-
     // Find an empty connection. One should always be available because the SD has the same
     // total connection limit.
     bleio_connection_internal_t *connection = NULL;
@@ -353,13 +367,14 @@ static int _connect_event(struct ble_gap_event *event, void *self_in) {
     switch (event->type) {
         case BLE_GAP_EVENT_CONNECT:
             if (event->connect.status == 0) {
-                // This triggers an MTU exchange. Its reply will unblock CP.
+                // This triggers an MTU exchange. Its reply will exit the loop waiting for a connection.
                 _new_connection(event->connect.conn_handle);
                 // Set connections objs back to NULL since we have a new
                 // connection and need a new tuple.
                 self->connection_objs = NULL;
             } else {
-                xTaskNotify(cp_task, -event->connect.status, eSetValueWithOverwrite);
+                // The loop waiting for the connection to be comnpleted will stop when _connection_status changes.
+                _connection_status = -event->connect.status;
             }
             break;
 
@@ -397,24 +412,31 @@ mp_obj_t common_hal_bleio_adapter_connect(bleio_adapter_obj_t *self, bleio_addre
     ble_addr_t addr;
     _convert_address(address, &addr);
 
-    cp_task = xTaskGetCurrentTaskHandle();
-    // Make sure we don't have a pending notification from a previous time. This
-    // can happen if a previous wait timed out before the notification was given.
-    xTaskNotifyStateClear(cp_task);
+    const int timeout_ms = SEC_TO_UNITS(timeout, UNIT_1_MS) + 0.5f;
     CHECK_NIMBLE_ERROR(
         ble_gap_connect(own_addr_type, &addr,
-            SEC_TO_UNITS(timeout, UNIT_1_MS) + 0.5f,
+            timeout_ms,
             &conn_params,
             _connect_event, self));
 
-    int error_code;
     // Wait an extra 50 ms to give the connect method the opportunity to time out.
-    CHECK_NOTIFY(xTaskNotifyWait(0, 0, (uint32_t *)&error_code, pdMS_TO_TICKS(timeout * 1000 + 50)));
+
+    const uint64_t timeout_time_ms = common_hal_time_monotonic_ms() + timeout_ms;
+    // _connection_status gets set to either a positive connection handle or a negative error code.
+    _connection_status = BLEIO_HANDLE_INVALID;
+    while (_connection_status == BLEIO_HANDLE_INVALID && (common_hal_time_monotonic_ms() < timeout_time_ms)) {
+        RUN_BACKGROUND_TASKS;
+        if (mp_hal_is_interrupted()) {
+            // Return prematurely. Then the interrupt exception  will be raised.
+            return mp_const_none;
+        }
+    }
+
     // Negative values are error codes, connection handle otherwise.
-    if (error_code < 0) {
-        CHECK_BLE_ERROR(-error_code);
+    if (_connection_status < 0) {
+        CHECK_BLE_ERROR(-_connection_status);
     }
-    uint16_t conn_handle = error_code;
+    const uint16_t conn_handle = _connection_status;
 
     // TODO: If we have keys, then try and encrypt the connection.
 

ports/espressif/common-hal/_bleio/Connection.c

@@ -191,8 +191,8 @@ static void _start_discovery_timeout(void) {
 }
 
 static int _wait_for_discovery_step_done(void) {
-    while ((_last_discovery_status == 0) &&
-           (common_hal_time_monotonic_ms() < _discovery_start_time + DISCOVERY_TIMEOUT_MS)) {
+    const uint64_t timeout_time_ms = _discovery_start_time + DISCOVERY_TIMEOUT_MS;
+    while ((_last_discovery_status == 0) && (common_hal_time_monotonic_ms() < timeout_time_ms)) {
         RUN_BACKGROUND_TASKS;
         if (mp_hal_is_interrupted()) {
             // Return prematurely. Then the interrupt will be raised.

ports/espressif/common-hal/dualbank/__init__.c

@@ -27,7 +27,7 @@ void dualbank_reset(void) {
 
 static void __attribute__((noreturn)) task_fatal_error(void) {
     ESP_LOGE(TAG, "Exiting task due to fatal error...");
-    mp_raise_RuntimeError(MP_ERROR_TEXT("Update Failed"));
+    mp_raise_RuntimeError(MP_ERROR_TEXT("Update failed"));
 }
 
 void common_hal_dualbank_flash(const void *buf, const size_t len, const size_t offset) {