BLE fixed

Author: mcmchris

content/hardware/06.nicla/boards/nicla-vision/tutorials/user-manual/content.md

@@ -1629,99 +1629,54 @@ We are going to build a Bluetooth® LE temperature monitor that using the __nRF
 For this Bluetooth® LE application example, we are going to emulate the temperature sensor.  Below you will find the complete sketch.
 
 ```python
+from micropython import const
+import uasyncio as asyncio
+import aioble
 import bluetooth
 import random
 import struct
-import time
-from ble_advertising import advertising_payload
-from machine import LED
-from micropython import const
-
-_IRQ_CENTRAL_CONNECT = const(1)
-_IRQ_CENTRAL_DISCONNECT = const(2)
-_IRQ_GATTS_INDICATE_DONE = const(20)
-
-_FLAG_READ = const(0x0002)
-_FLAG_NOTIFY = const(0x0010)
-_FLAG_INDICATE = const(0x0020)
-
 # org.bluetooth.service.environmental_sensing
 _ENV_SENSE_UUID = bluetooth.UUID(0x181A)
 # org.bluetooth.characteristic.temperature
-_TEMP_CHAR = (
-    bluetooth.UUID(0x2A6E),
-    _FLAG_READ | _FLAG_NOTIFY | _FLAG_INDICATE,
-)
-_ENV_SENSE_SERVICE = (
-    _ENV_SENSE_UUID,
-    (_TEMP_CHAR,),
-)
-
+_ENV_SENSE_TEMP_UUID = bluetooth.UUID(0x2A6E)
 # org.bluetooth.characteristic.gap.appearance.xml
 _ADV_APPEARANCE_GENERIC_THERMOMETER = const(768)
-
-
-class BLETemperature:
-    def __init__(self, ble, name="Py Temp Sensor"):
-        self._ble = ble
-        self._ble.active(True)
-        self._ble.irq(self._irq)
-        ((self._handle,),) = self._ble.gatts_register_services((_ENV_SENSE_SERVICE,))
-        self._connections = set()
-        self._payload = advertising_payload(
-            name=name,
-            services=[_ENV_SENSE_UUID],
-            appearance=_ADV_APPEARANCE_GENERIC_THERMOMETER,
-        )
-        self._advertise()
-        self.led = LED("LED_BLUE")
-
-    def _irq(self, event, data):
-        # Track connections so we can send notifications.
-        if event == _IRQ_CENTRAL_CONNECT:
-            conn_handle, _, _ = data
-            self._connections.add(conn_handle)
-            self.led.on()
-        elif event == _IRQ_CENTRAL_DISCONNECT:
-            conn_handle, _, _ = data
-            self._connections.remove(conn_handle)
-            # Start advertising again to allow a new connection.
-            self._advertise()
-            self.led.off()
-        elif event == _IRQ_GATTS_INDICATE_DONE:
-            conn_handle, value_handle, status = data
-
-    def set_temperature(self, temp_deg_c, notify=False, indicate=False):
-        # Data is sint16 in degrees Celsius with a resolution of 0.01 degrees Celsius.
-        # Write the local value, ready for a central to read.
-        self._ble.gatts_write(self._handle, struct.pack("<h", int(temp_deg_c * 100)))
-        if notify or indicate:
-            for conn_handle in self._connections:
-                if notify:
-                    # Notify connected centrals.
-                    self._ble.gatts_notify(conn_handle, self._handle)
-                if indicate:
-                    # Indicate connected centrals.
-                    self._ble.gatts_indicate(conn_handle, self._handle)
-
-    def _advertise(self, interval_us=500000):
-        self._ble.gap_advertise(interval_us, adv_data=self._payload)
-
-
-if __name__ == "__main__":
-    ble = bluetooth.BLE()
-    temp = BLETemperature(ble)
-
-    t = 25
-    i = 0
-
+# How frequently to send advertising beacons.
+_ADV_INTERVAL_MS = 250_000
+# Register GATT server.
+temp_service = aioble.Service(_ENV_SENSE_UUID)
+temp_characteristic = aioble.Characteristic(
+    temp_service, _ENV_SENSE_TEMP_UUID, read=True, notify=True
+)
+aioble.register_services(temp_service)
+# Helper to encode the temperature characteristic encoding (sint16, hundredths of a degree).
+def _encode_temperature(temp_deg_c):
+    return struct.pack("<h", int(temp_deg_c * 100))
+# This would be periodically polling a hardware sensor.
+async def sensor_task():
+    t = 24.5
     while True:
-        # Write every second, notify every 10 seconds.
-        i = (i + 1) % 10
-        temp.set_temperature(t, notify=i == 0, indicate=False)
-        # Random walk the temperature.
+        temp_characteristic.write(_encode_temperature(t))
         t += random.uniform(-0.5, 0.5)
-        time.sleep_ms(1000)
+        await asyncio.sleep_ms(1000)
+# Serially wait for connections. Don't advertise while a central is
+# connected.
+async def peripheral_task():
+    while True:
+        async with await aioble.advertise(
+            _ADV_INTERVAL_MS,
+            name="mpy-temp",
+            services=[_ENV_SENSE_UUID],
+            appearance=_ADV_APPEARANCE_GENERIC_THERMOMETER,
+        ) as connection:
+            print("Connection from", connection.device)
+            await connection.disconnected()
+# Run both tasks.
+async def main():
+    t1 = asyncio.create_task(sensor_task())
+    t2 = asyncio.create_task(peripheral_task())
+    await asyncio.gather(t1, t2)
+asyncio.run(main())
 ```
 
 The example code shown above creates a Bluetooth® Low Energy service and characteristics according to the [Bluetooth® LE standard](https://btprodspecificationrefs.blob.core.windows.net/assigned-numbers/Assigned%20Number%20Types/Assigned_Numbers.pdf) for transmitting an emulated temperature value.