pbio/drv/bluetooth: Maintain advertising state.

We used to maintain an advertising state in pbsys/bluetooth and now in pbsys/hmi, handling things such as _not_ advertising if it was already in the connected state. This works, but becomes even more cumbersome when we add a USB state in the next commits.

It is simpler for the higher level code to be able to just say stop_advertising, and letting the Bluetooth driver treat it as a no-op if it not advertising to begin with.

Author: laurensvalk

lib/pbio/drv/bluetooth/bluetooth.c

@@ -317,8 +317,18 @@ void pbdrv_bluetooth_cancel_operation_request(void) {
 static pbio_os_process_func_t advertising_or_scan_func;
 static pbio_error_t advertising_or_scan_err;
 
+pbdrv_bluetooth_advertising_state_t pbdrv_bluetooth_advertising_state;
+
 pbio_error_t pbdrv_bluetooth_start_advertising(bool start) {
 
+    bool is_advertising = pbdrv_bluetooth_advertising_state == PBDRV_BLUETOOTH_ADVERTISING_STATE_ADVERTISING_PYBRICKS;
+
+    // Already in requested state. This makes it safe to call stop advertising
+    // even if it already stopped on becoming connected;
+    if (start == is_advertising) {
+        return PBIO_SUCCESS;
+    }
+
     if (advertising_or_scan_func) {
         return PBIO_ERROR_BUSY;
     }
@@ -349,9 +359,13 @@ pbio_error_t pbdrv_bluetooth_start_broadcasting(const uint8_t *data, size_t size
         return PBIO_ERROR_INVALID_ARG;
     }
 
+    bool is_broadcasting = pbdrv_bluetooth_advertising_state == PBDRV_BLUETOOTH_ADVERTISING_STATE_BROADCASTING;
+
     // This means stop broadcasting.
     if (!data || !size) {
-        if (!pbdrv_bluetooth_is_broadcasting) {
+
+        if (!is_broadcasting) {
+            // Already stopped.
             return PBIO_SUCCESS;
         }
         advertising_or_scan_err = PBIO_ERROR_AGAIN;
@@ -362,7 +376,7 @@ pbio_error_t pbdrv_bluetooth_start_broadcasting(const uint8_t *data, size_t size
 
     // Avoid I/O operations if the user tries to broadcast the same data
     // over and over in a tight loop.
-    if (pbdrv_bluetooth_is_broadcasting && pbdrv_bluetooth_broadcast_data_size == size && !memcmp(pbdrv_bluetooth_broadcast_data, data, size)) {
+    if (is_broadcasting && pbdrv_bluetooth_broadcast_data_size == size && !memcmp(pbdrv_bluetooth_broadcast_data, data, size)) {
         return PBIO_SUCCESS;
     }
     pbdrv_bluetooth_broadcast_data_size = size;
@@ -376,7 +390,6 @@ pbio_error_t pbdrv_bluetooth_start_broadcasting(const uint8_t *data, size_t size
     return PBIO_SUCCESS;
 }
 
-bool pbdrv_bluetooth_is_broadcasting;
 bool pbdrv_bluetooth_is_observing;
 pbdrv_bluetooth_start_observing_callback_t pbdrv_bluetooth_observe_callback;
 
@@ -441,7 +454,7 @@ pbio_error_t pbdrv_bluetooth_process_thread(pbio_os_state_t *state, void *contex
 
         DEBUG_PRINT("Bluetooth disable requested.\n");
 
-        pbdrv_bluetooth_is_broadcasting = false;
+        pbdrv_bluetooth_advertising_state = PBDRV_BLUETOOTH_ADVERTISING_STATE_NONE;
         pbdrv_bluetooth_is_observing = false;
         observe_restart_requested = false;
 

lib/pbio/drv/bluetooth/bluetooth.h

@@ -52,7 +52,14 @@ extern size_t pbdrv_bluetooth_char_write_size;
 extern uint8_t pbdrv_bluetooth_broadcast_data[PBDRV_BLUETOOTH_MAX_ADV_SIZE];
 extern uint8_t pbdrv_bluetooth_broadcast_data_size;
 
-extern bool pbdrv_bluetooth_is_broadcasting;
+typedef enum {
+    PBDRV_BLUETOOTH_ADVERTISING_STATE_NONE,
+    PBDRV_BLUETOOTH_ADVERTISING_STATE_ADVERTISING_PYBRICKS,
+    PBDRV_BLUETOOTH_ADVERTISING_STATE_BROADCASTING,
+} pbdrv_bluetooth_advertising_state_t;
+
+extern pbdrv_bluetooth_advertising_state_t pbdrv_bluetooth_advertising_state;
+
 extern bool pbdrv_bluetooth_is_observing;
 extern pbdrv_bluetooth_start_observing_callback_t pbdrv_bluetooth_observe_callback;
 

lib/pbio/drv/bluetooth/bluetooth_btstack.c

@@ -281,6 +281,7 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
 
                 // don't start advertising again on disconnect
                 gap_advertisements_enable(false);
+                pbdrv_bluetooth_advertising_state = PBDRV_BLUETOOTH_ADVERTISING_STATE_NONE;
             } else {
                 // If we aren't waiting for a peripheral connection, this must be a different connection.
                 if (handset.con_state != CON_STATE_WAIT_CONNECT) {
@@ -548,6 +549,8 @@ pbio_error_t pbdrv_bluetooth_start_advertising_func(pbio_os_state_t *state, void
 
     PBIO_OS_AWAIT_UNTIL(state, event_packet && HCI_EVENT_IS_COMMAND_COMPLETE(event_packet, hci_le_set_advertising_data));
 
+    pbdrv_bluetooth_advertising_state = PBDRV_BLUETOOTH_ADVERTISING_STATE_ADVERTISING_PYBRICKS;
+
     PBIO_OS_ASYNC_END(PBIO_SUCCESS);
 }
 
@@ -556,9 +559,11 @@ pbio_error_t pbdrv_bluetooth_stop_advertising_func(pbio_os_state_t *state, void
     PBIO_OS_ASYNC_BEGIN(state);
 
     gap_advertisements_enable(false);
-    pbdrv_bluetooth_is_broadcasting = false;
+
     // REVISIT: use callback to await operation
 
+    pbdrv_bluetooth_advertising_state = PBDRV_BLUETOOTH_ADVERTISING_STATE_NONE;
+
     PBIO_OS_ASYNC_END(PBIO_SUCCESS);
 }
 
@@ -797,18 +802,19 @@ pbio_error_t pbdrv_bluetooth_start_broadcasting_func(pbio_os_state_t *state, voi
     gap_advertisements_set_data(pbdrv_bluetooth_broadcast_data_size, pbdrv_bluetooth_broadcast_data);
 
     // If already broadcasting, await set data and return.
-    if (pbdrv_bluetooth_is_broadcasting) {
+    if (pbdrv_bluetooth_advertising_state == PBDRV_BLUETOOTH_ADVERTISING_STATE_BROADCASTING) {
         PBIO_OS_AWAIT_UNTIL(state, event_packet && HCI_EVENT_IS_COMMAND_COMPLETE(event_packet, hci_le_set_advertising_data));
         return PBIO_SUCCESS;
     }
 
-    pbdrv_bluetooth_is_broadcasting = true;
     bd_addr_t null_addr = { };
     gap_advertisements_set_params(0xA0, 0xA0, PBDRV_BLUETOOTH_AD_TYPE_ADV_NONCONN_IND, 0, null_addr, 0x7, 0);
     gap_advertisements_enable(true);
 
     PBIO_OS_AWAIT_UNTIL(state, event_packet && HCI_EVENT_IS_COMMAND_COMPLETE(event_packet, hci_le_set_advertise_enable));
 
+    pbdrv_bluetooth_advertising_state = PBDRV_BLUETOOTH_ADVERTISING_STATE_BROADCASTING;
+
     PBIO_OS_ASYNC_END(PBIO_SUCCESS);
 }
 

lib/pbio/drv/bluetooth/bluetooth_stm32_bluenrg.c

@@ -265,6 +265,8 @@ pbio_error_t pbdrv_bluetooth_start_advertising_func(pbio_os_state_t *state, void
     PBIO_OS_AWAIT_UNTIL(state, hci_command_complete);
     // aci_gap_set_discoverable_end();
 
+    pbdrv_bluetooth_advertising_state = PBDRV_BLUETOOTH_ADVERTISING_STATE_ADVERTISING_PYBRICKS;
+
     PBIO_OS_ASYNC_END(PBIO_SUCCESS);
 }
 
@@ -281,10 +283,9 @@ pbio_error_t pbdrv_bluetooth_stop_advertising_func(pbio_os_state_t *state, void
     // This protothread is also shared with stop broadcasting. Either way,
     // nothing is advertising or broadcasting after this, so reset that state.
     // even if it wasn't active.
-    pbdrv_bluetooth_is_broadcasting = false;
+    pbdrv_bluetooth_advertising_state = PBDRV_BLUETOOTH_ADVERTISING_STATE_NONE;
 
     PBIO_OS_ASYNC_END(PBIO_SUCCESS);
-    ;
 }
 
 
@@ -588,7 +589,7 @@ pbio_error_t pbdrv_bluetooth_start_broadcasting_func(pbio_os_state_t *state, voi
 
     PBIO_OS_ASYNC_BEGIN(state);
 
-    if (!pbdrv_bluetooth_is_broadcasting) {
+    if (pbdrv_bluetooth_advertising_state != PBDRV_BLUETOOTH_ADVERTISING_STATE_BROADCASTING) {
         PBIO_OS_AWAIT_WHILE(state, write_xfer_size);
         aci_gap_set_non_connectable_begin(ADV_NONCONN_IND, STATIC_RANDOM_ADDR);
         PBIO_OS_AWAIT_UNTIL(state, hci_command_complete);
@@ -620,7 +621,7 @@ pbio_error_t pbdrv_bluetooth_start_broadcasting_func(pbio_os_state_t *state, voi
         // Errors from deleting are ignored since we should only get an error
         // if the AD does not exist, which is OK.
 
-        pbdrv_bluetooth_is_broadcasting = true;
+        pbdrv_bluetooth_advertising_state = PBDRV_BLUETOOTH_ADVERTISING_STATE_BROADCASTING;
     }
 
     // This has to be done _after_ other data is delete to make sure it fits.
@@ -898,6 +899,7 @@ static void handle_event(hci_event_pckt *event) {
                     evt_le_connection_complete *subevt = (evt_le_connection_complete *)evt->data;
                     if (subevt->role == GAP_PERIPHERAL_ROLE) {
                         conn_handle = subevt->handle;
+                        pbdrv_bluetooth_advertising_state = PBDRV_BLUETOOTH_ADVERTISING_STATE_NONE;
                     } else {
                         peri->con_handle = subevt->handle;
                     }

lib/pbio/drv/bluetooth/bluetooth_stm32_cc2640.c

@@ -296,6 +296,8 @@ pbio_error_t pbdrv_bluetooth_start_advertising_func(pbio_os_state_t *state, void
     PBIO_OS_AWAIT_UNTIL(state, hci_command_complete);
     // ignoring response data
 
+    pbdrv_bluetooth_advertising_state = PBDRV_BLUETOOTH_ADVERTISING_STATE_ADVERTISING_PYBRICKS;
+
     PBIO_OS_ASYNC_END(PBIO_SUCCESS);
 }
 
@@ -315,10 +317,8 @@ pbio_error_t pbdrv_bluetooth_stop_advertising_func(pbio_os_state_t *state, void
     // Status could also be bleIncorrectMode which means "Not advertising".
     // This is not expected, but should be safe to ignore.
 
-    // This protothread is also shared with stop broadcasting. Either way,
-    // nothing is advertising or broadcasting after this, so reset that state.
-    // even if it wasn't active.
-    pbdrv_bluetooth_is_broadcasting = false;
+    // This protothread is also shared with stop broadcasting.
+    pbdrv_bluetooth_advertising_state = PBDRV_BLUETOOTH_ADVERTISING_STATE_NONE;
 
     PBIO_OS_ASYNC_END(PBIO_SUCCESS);
 }
@@ -804,7 +804,7 @@ pbio_error_t pbdrv_bluetooth_start_broadcasting_func(pbio_os_state_t *state, voi
     HCI_LE_setAdvertisingData(pbdrv_bluetooth_broadcast_data_size, pbdrv_bluetooth_broadcast_data);
     PBIO_OS_AWAIT_UNTIL(state, hci_command_complete);
 
-    if (pbdrv_bluetooth_is_broadcasting) {
+    if (pbdrv_bluetooth_advertising_state == PBDRV_BLUETOOTH_ADVERTISING_STATE_BROADCASTING) {
         // Already broadcasting, so just updating the data as above is enough.
         return PBIO_SUCCESS;
     }
@@ -823,7 +823,7 @@ pbio_error_t pbdrv_bluetooth_start_broadcasting_func(pbio_os_state_t *state, voi
     // wait for make discoverable done event
     PBIO_OS_AWAIT_UNTIL(state, hci_command_complete);
 
-    pbdrv_bluetooth_is_broadcasting = true;
+    pbdrv_bluetooth_advertising_state = PBDRV_BLUETOOTH_ADVERTISING_STATE_BROADCASTING;
 
     PBIO_OS_ASYNC_END(PBIO_SUCCESS);
 }
@@ -1319,6 +1319,9 @@ static void handle_event(uint8_t *packet) {
                         // assume minimum MTU until we get an exchange MTU request
                         conn_mtu = ATT_MTU_SIZE;
 
+                        // Establishing the link implicitly stops advertising.
+                        pbdrv_bluetooth_advertising_state = PBDRV_BLUETOOTH_ADVERTISING_STATE_NONE;
+
                         // On 2019 and newer MacBooks, the default interval was
                         // measured to be 15 ms. This caused advertisement to
                         // not be received by the local Bluetooth chip when

lib/pbio/sys/hmi_pup.c

@@ -203,19 +203,14 @@ static pbio_error_t run_ui(pbio_os_state_t *state, pbio_os_timer_t *timer) {
             PBIO_OS_AWAIT(state, &sub, pbdrv_bluetooth_power_on(&sub, pbsys_storage_settings_bluetooth_enabled_get()));
 
             // Update advertising state.
-            if (pbsys_storage_settings_bluetooth_enabled_get()) {
-                // Start advertising if we aren't already.
-                if (!pbsys_status_test(PBIO_PYBRICKS_STATUS_BLE_ADVERTISING)) {
-                    pbsys_status_set(PBIO_PYBRICKS_STATUS_BLE_ADVERTISING);
-                    DEBUG_PRINT("Start advertising.\n");
-                    pbdrv_bluetooth_start_advertising(true);
-                    PBIO_OS_AWAIT(state, &sub, pbdrv_bluetooth_await_advertise_or_scan_command(&sub, NULL));
-                }
+            bool do_advertise = pbsys_storage_settings_bluetooth_enabled_get();
+            if (do_advertise) {
+                pbsys_status_set(PBIO_PYBRICKS_STATUS_BLE_ADVERTISING);
             } else {
-                // Not advertising if Bluetooth is disabled. The physical state
-                // is already off, but we need the blinking to stop too.
                 pbsys_status_clear(PBIO_PYBRICKS_STATUS_BLE_ADVERTISING);
             }
+            pbdrv_bluetooth_start_advertising(do_advertise);
+            PBIO_OS_AWAIT(state, &sub, pbdrv_bluetooth_await_advertise_or_scan_command(&sub, NULL));
         }
 
         // Buttons could be pressed at the end of the user program, so wait for