extmod/nimble: Make stm32 and unix NimBLE ports use synchronous events.

This changes stm32 from using PENDSV to run NimBLE to use the MicroPython
scheduler instead.  This allows Python BLE callbacks to be invoked directly
(and therefore synchronously) rather than via the ringbuffer.

The NimBLE UART HCI and event processing now happens in a scheduled task
every 128ms.  When RX IRQ idle events arrive, it will also schedule this
task to improve latency.

There is a similar change for the unix port where the background thread now
queues the scheduled task.

Signed-off-by: Jim Mussared <jim.mussared@gmail.com>

Author: jimmo

extmod/modbluetooth.h

@@ -50,6 +50,7 @@
 #endif
 
 // This is used to protect the ringbuffer.
+// A port may no-op this if MICROPY_PY_BLUETOOTH_USE_SYNC_EVENTS is enabled.
 #ifndef MICROPY_PY_BLUETOOTH_ENTER
 #define MICROPY_PY_BLUETOOTH_ENTER mp_uint_t atomic_state = MICROPY_BEGIN_ATOMIC_SECTION();
 #define MICROPY_PY_BLUETOOTH_EXIT MICROPY_END_ATOMIC_SECTION(atomic_state);

extmod/nimble/hal/hal_uart.c

@@ -28,10 +28,13 @@
 #include "py/mphal.h"
 #include "nimble/ble.h"
 #include "extmod/nimble/hal/hal_uart.h"
+#include "extmod/nimble/nimble/nimble_npl_os.h"
 #include "extmod/mpbthci.h"
 
 #if MICROPY_PY_BLUETOOTH && MICROPY_BLUETOOTH_NIMBLE
 
+#define HCI_TRACE (0)
+
 static hal_uart_tx_cb_t hal_uart_tx_cb;
 static void *hal_uart_tx_arg;
 static hal_uart_rx_cb_t hal_uart_rx_cb;
@@ -62,10 +65,10 @@ void hal_uart_start_tx(uint32_t port) {
         mp_bluetooth_hci_cmd_buf[len++] = data;
     }
 
-    #if 0
-    printf("[% 8d] BTUTX: %02x", mp_hal_ticks_ms(), hci_cmd_buf[0]);
-    for (int i = 1; i < len; ++i) {
-        printf(":%02x", hci_cmd_buf[i]);
+    #if HCI_TRACE
+    printf("< [% 8d] %02x", mp_hal_ticks_ms(), mp_bluetooth_hci_cmd_buf[0]);
+    for (size_t i = 1; i < len; ++i) {
+        printf(":%02x", mp_bluetooth_hci_cmd_buf[i]);
     }
     printf("\n");
     #endif
@@ -77,13 +80,21 @@ int hal_uart_close(uint32_t port) {
     return 0; // success
 }
 
-void mp_bluetooth_nimble_hci_uart_process(void) {
+void mp_bluetooth_nimble_hci_uart_process(bool run_events) {
     bool host_wake = mp_bluetooth_hci_controller_woken();
 
     int chr;
     while ((chr = mp_bluetooth_hci_uart_readchar()) >= 0) {
-        // printf("UART RX: %02x\n", data);
+        #if HCI_TRACE
+        printf("> %02x (%d)\n", chr);
+        #endif
         hal_uart_rx_cb(hal_uart_rx_arg, chr);
+
+        // Incoming data may result in events being enqueued. If we're in
+        // scheduler context then we can run those events immediately.
+        if (run_events) {
+            mp_bluetooth_nimble_os_eventq_run_all();
+        }
     }
 
     if (host_wake) {

extmod/nimble/hal/hal_uart.h

@@ -43,6 +43,6 @@ void hal_uart_start_tx(uint32_t port);
 int hal_uart_close(uint32_t port);
 
 // --- Called by the MicroPython port when UART data is available -------------
-void mp_bluetooth_nimble_hci_uart_process(void);
+void mp_bluetooth_nimble_hci_uart_process(bool run_events);
 
 #endif // MICROPY_INCLUDED_EXTMOD_NIMBLE_HAL_HAL_UART_H

extmod/nimble/modbluetooth_nimble.c

@@ -382,6 +382,7 @@ int mp_bluetooth_init(void) {
     mp_bluetooth_nimble_ble_state = MP_BLUETOOTH_NIMBLE_BLE_STATE_WAITING_FOR_SYNC;
 
     // Initialise NimBLE memory and data structures.
+    DEBUG_printf("mp_bluetooth_init: nimble_port_init\n");
     nimble_port_init();
 
     // Make sure that the HCI UART and event handling task is running.
@@ -402,6 +403,8 @@ int mp_bluetooth_init(void) {
         return MP_ETIMEDOUT;
     }
 
+    DEBUG_printf("mp_bluetooth_init: starting services\n");
+
     // By default, just register the default gap/gatt service.
     ble_svc_gap_init();
     ble_svc_gatt_init();
@@ -417,7 +420,7 @@ int mp_bluetooth_init(void) {
 }
 
 void mp_bluetooth_deinit(void) {
-    DEBUG_printf("mp_bluetooth_deinit\n");
+    DEBUG_printf("mp_bluetooth_deinit %d\n", mp_bluetooth_nimble_ble_state);
     if (mp_bluetooth_nimble_ble_state == MP_BLUETOOTH_NIMBLE_BLE_STATE_OFF) {
         return;
     }

extmod/nimble/nimble.mk

@@ -17,6 +17,13 @@ CFLAGS_MOD += -DMICROPY_BLUETOOTH_NIMBLE_BINDINGS_ONLY=$(MICROPY_BLUETOOTH_NIMBL
 
 ifeq ($(MICROPY_BLUETOOTH_NIMBLE_BINDINGS_ONLY),0)
 
+# On all ports where we provide the full implementation (i.e. not just
+# bindings like on ESP32), then we don't need to use the ringbuffer. In this
+# case, all NimBLE events are run by the MicroPython scheduler. On Unix, the
+# scheduler is also responsible for polling the UART, whereas on STM32 the
+# UART is also polled by the RX IRQ.
+CFLAGS_MOD += -DMICROPY_PY_BLUETOOTH_USE_SYNC_EVENTS=1
+
 NIMBLE_LIB_DIR = lib/mynewt-nimble
 
 LIB_SRC_C += $(addprefix $(NIMBLE_LIB_DIR)/, \