Merge branch 'master' into master

Author: ladyada

BLE_Crickit_Light_Switch/ble_crickit_light_switch.py

@@ -1,6 +1,6 @@
 # BLE Crickit Light Switch
 # Use with the Adafruit BlueFruit LE Connect app
-# Works with CircuitPython 4.0.0-beta.1 and later
+# Works with CircuitPython 5.0.0-beta.0 and later
 # running on an nRF52840 Feather board and Crickit FeatherWing
 # micro servo, 3D printed switch actuator
 
@@ -10,7 +10,10 @@
 import digitalio
 
 from adafruit_crickit import crickit
-from adafruit_ble.uart import UARTServer
+
+from adafruit_ble import BLERadio
+from adafruit_ble.advertising.standard import ProvideServicesAdvertisement
+from adafruit_ble.services.nordic import UARTService
 
 from adafruit_bluefruit_connect.packet import Packet
 # Only the packet classes that are imported will be known to Packet.
@@ -22,7 +25,9 @@
 blue_led.direction = digitalio.Direction.OUTPUT
 red_led.direction = digitalio.Direction.OUTPUT
 
-uart_server = UARTServer()
+ble = BLERadio()
+uart_service = UARTService()
+advertisement = ProvideServicesAdvertisement(uart_service)
 
 UP_ANGLE = 180
 NEUTRAL_ANGLE = 120
@@ -35,17 +40,17 @@
 print("Use Adafruit Bluefruit app to connect")
 while True:
     blue_led.value = False
-    uart_server.start_advertising()
+    ble.start_advertising(advertisement)
 
-    while not uart_server.connected:
+    while not ble.connected:
         # Wait for a connection.
         pass
     blue_led.value = True  # turn on blue LED when connected
-    while uart_server.connected:
-        if uart_server.in_waiting:
+    while ble.connected:
+        if uart_service.in_waiting:
             # Packet is arriving.
             red_led.value = False  # turn off red LED
-            packet = Packet.from_stream(uart_server)
+            packet = Packet.from_stream(uart_service)
             if isinstance(packet, ButtonPacket) and packet.pressed:
                 red_led.value = True  # blink to show a packet has been received
                 if packet.button == ButtonPacket.UP and angle != UP_ANGLE:  # UP button pressed

Bluetooth_Luminaries/code.py

@@ -5,13 +5,17 @@
 import neopixel
 import touchio
 import adafruit_fancyled.adafruit_fancyled as fancy
-# from adafruit_ble.uart import UARTServer
-# for >= CPy 5.0.0
-from adafruit_ble.uart_server import UARTServer
 from adafruit_bluefruit_connect.packet import Packet
 from adafruit_bluefruit_connect.button_packet import ButtonPacket
 from adafruit_bluefruit_connect.color_packet import ColorPacket
 
+
+from adafruit_ble import BLERadio
+from adafruit_ble.advertising.standard import ProvideServicesAdvertisement
+from adafruit_ble.services.nordic import UARTService
+
+
+
 NUM_LEDS = 24             # change to reflect your total number of ring LEDs
 RING_PIN = board.A1       # change to reflect your wiring
 CPX_PIN = board.D8        # CPX Neopixels live on pin D8
@@ -66,7 +70,11 @@
 offset_increment = 6
 OFFSET_MAX = 1000000
 
-uart_server = UARTServer()
+# Setup BLE
+ble = BLERadio()
+uart = UARTService()
+advertisement = ProvideServicesAdvertisement(uart)
+
 
 def set_palette(palette):
     for i in range(NUM_LEDS):
@@ -101,17 +109,17 @@ def set_palette(palette):
         set_palette(palette_choice)
         offset = (offset + offset_increment) % OFFSET_MAX
 
-    if not uart_server.connected and not advertising:
-        uart_server.start_advertising()
+    if not ble.connected and not advertising:
+        ble.start_advertising(advertisement)
         advertising = True
 
     # Are we connected via Bluetooth now?
-    if uart_server.connected:
+    if ble.connected:
         # Once we're connected, we're not advertising any more.
         advertising = False
         # Have we started to receive a packet?
-        if uart_server.in_waiting:
-            packet = Packet.from_stream(uart_server)
+        if uart.in_waiting:
+            packet = Packet.from_stream(uart)
             if isinstance(packet, ColorPacket):
                 cycling = False
                 # Set all the pixels to one color and stay there.

CPB_Ornament_Proximity/cpb_ornament_proximity.py

@@ -0,0 +1,86 @@
+"""
+Circuit Playground Bluefruit Ornament Proximity
+This demo uses advertising to set the color of scanning devices depending on the strongest broadcast
+signal received. Circuit Playgrounds can be switched between advertising and scanning using the
+slide switch. The buttons change the color when advertising.
+"""
+
+import time
+from adafruit_circuitplayground.bluefruit import cpb
+
+from adafruit_ble import BLERadio
+from adafruit_ble.advertising.adafruit import AdafruitColor
+
+# The color pickers will cycle through this list with buttons A and B.
+color_options = [0x110000,
+                 0x111100,
+                 0x001100,
+                 0x001111,
+                 0x000011,
+                 0x110011,
+                 0x111111,
+                 0x221111,
+                 0x112211,
+                 0x111122]
+
+ble = BLERadio()
+
+i = 0
+advertisement = AdafruitColor()
+advertisement.color = color_options[i]
+cpb.pixels.auto_write = False
+cpb.pixels.fill(color_options[i])
+while True:
+    # The first mode is the color selector which broadcasts it's current color to other devices.
+    if cpb.switch:
+        print("Broadcasting color")
+        ble.start_advertising(advertisement)
+        while cpb.switch:
+            last_i = i
+            if cpb.button_a:
+                i += 1
+            if cpb.button_b:
+                i -= 1
+            i %= len(color_options)
+            if last_i != i:
+                color = color_options[i]
+                cpb.pixels.fill(color)
+                cpb.pixels.show()
+                print("New color {:06x}".format(color))
+                advertisement.color = color
+                ble.stop_advertising()
+                ble.start_advertising(advertisement)
+                time.sleep(0.5)
+        ble.stop_advertising()
+    # The second mode listens for color broadcasts and shows the color of the strongest signal.
+    else:
+        closest = None
+        closest_rssi = -80
+        closest_last_time = 0
+        print("Scanning for colors")
+        while not cpb.switch:
+            for entry in ble.start_scan(AdafruitColor, minimum_rssi=-100, timeout=1):
+                if cpb.switch:
+                    break
+                now = time.monotonic()
+                new = False
+                if entry.address == closest:
+                    pass
+                elif entry.rssi > closest_rssi or now - closest_last_time > 0.4:
+                    closest = entry.address
+                else:
+                    continue
+                closest_rssi = entry.rssi
+                closest_last_time = now
+                discrete_strength = min((100 + entry.rssi) // 5, 10)
+                cpb.pixels.fill(0x000000)
+                for i in range(0, discrete_strength):
+                    cpb.pixels[i] = entry.color
+                cpb.pixels.show()
+
+            # Clear the pixels if we haven't heard from anything recently.
+            now = time.monotonic()
+            if now - closest_last_time > 1:
+                cpb.pixels.fill(0x000000)
+                cpb.pixels.show()
+        ble.stop_scan()

CircuitPython_BLE_Rover/circuitpython_ble_rover.py

@@ -9,7 +9,10 @@
 import digitalio
 
 from adafruit_crickit import crickit
-from adafruit_ble.uart import UARTServer
+
+from adafruit_ble import BLERadio
+from adafruit_ble.advertising.standard import ProvideServicesAdvertisement
+from adafruit_ble.services.nordic import UARTService
 
 from adafruit_bluefruit_connect.packet import Packet
 # Only the packet classes that are imported will be known to Packet.
@@ -22,7 +25,9 @@
 blue_led.direction = digitalio.Direction.OUTPUT
 red_led.direction = digitalio.Direction.OUTPUT
 
-uart_server = UARTServer()
+ble = BLERadio()
+uart_service = UARTService()
+advertisement = ProvideServicesAdvertisement(uart_service)
 
 # motor setup
 motor_1 = crickit.dc_motor_1
@@ -46,16 +51,16 @@
 print("Use Adafruit Bluefruit app to connect")
 while True:
     blue_led.value = False
-    uart_server.start_advertising()
-    while not uart_server.connected:
+    ble.start_advertising(advertisement)
+    while not ble.connected:
         # Wait for a connection.
         pass
     blue_led.value = True  # turn on blue LED when connected
-    while uart_server.connected:
-        if uart_server.in_waiting:
+    while ble.connected:
+        if uart_service.in_waiting:
             # Packet is arriving.
             red_led.value = False  # turn off red LED
-            packet = Packet.from_stream(uart_server)
+            packet = Packet.from_stream(uart_service)
             if isinstance(packet, ColorPacket):
                 # Change the color.
                 color = packet.color

CircuitPython_PyPaint/code.py

@@ -146,9 +146,9 @@ def set_cursor_bitmap(self, bmp):
         self.poke()
 
 ################################################################################
-
 class Paint(object):
 
+    #pylint:disable=too-many-statements
     def __init__(self, display=board.DISPLAY):
         self._logger = logging.getLogger("Paint")
         self._logger.setLevel(logging.DEBUG)
@@ -196,9 +196,13 @@ def __init__(self, display=board.DISPLAY):
         self._splash.append(self._palette)
 
         self._display.show(self._splash)
-        self._display.refresh_soon()
-        gc.collect()
-        self._display.wait_for_frame()
+        try:
+            gc.collect()
+            self._display.refresh(target_frames_per_second=60)
+        except AttributeError:
+            self._display.refresh_soon()
+            gc.collect()
+            self._display.wait_for_frame()
 
         self._brush = 0
         self._cursor_bitmaps = [self._cursor_bitmap_1(), self._cursor_bitmap_3()]
@@ -215,6 +219,7 @@ def __init__(self, display=board.DISPLAY):
         self._last_location = None
 
         self._pencolor = 7
+    #pylint:enable=too-many-statements
 
     def _make_palette(self):
         self._palette_bitmap = displayio.Bitmap(self._w // 10, self._h, 5)

CircuitPython_displayio/displayio_display_driver.py

@@ -37,4 +37,3 @@
 group = displayio.Group()
 group.append(tile_grid)
 display.show(group)
-display.refresh_soon()

CircuitPython_displayio/displayio_display_manual.py

@@ -64,4 +64,3 @@
 group = displayio.Group()
 group.append(tile_grid)
 display.show(group)
-display.refresh_soon()

CircuitPython_displayio/displayio_parallelbus.py

@@ -62,4 +62,3 @@
 group = displayio.Group()
 group.append(tile_grid)
 display.show(group)
-display.refresh_soon()

Circuit_Playground_Bluefruit_Color_Remote/cpb_remote_color_client.py

@@ -12,37 +12,48 @@
 # Only the packet classes that are imported will be known to Packet.
 from adafruit_bluefruit_connect.color_packet import ColorPacket
 
-from adafruit_ble.scanner import Scanner
-from adafruit_ble.uart_client import UARTClient
+from adafruit_ble import BLERadio
+from adafruit_ble.advertising.standard import ProvideServicesAdvertisement
+from adafruit_ble.services.nordic import UARTService
 
 def scale(value):
     """Scale an value from 0-65535 (AnalogIn range) to 0-255 (RGB range)"""
     return int(value / 65535 * 255)
 
-scanner = Scanner()
-uart_client = UARTClient()
+ble = BLERadio()
 
-a3 = AnalogIn(board.A4)
-a4 = AnalogIn(board.A5)
-a5 = AnalogIn(board.A6)
+a4 = AnalogIn(board.A4)
+a5 = AnalogIn(board.A5)
+a6 = AnalogIn(board.A6)
 
-while True:
-    uart_addresses = []
-    # Keep trying to find a UART peripheral
-    while not uart_addresses:
-        uart_addresses = uart_client.scan(scanner)
-    uart_client.connect(uart_addresses[0], 5)
+uart_connection = None
+
+# See if any existing connections are providing UARTService.
+if ble.connected:
+    for connection in ble.connections:
+        if UARTService in connection:
+            uart_connection = connection
+        break
 
-    while uart_client.connected:
-        r = scale(a3.value)
-        g = scale(a4.value)
-        b = scale(a5.value)
+while True:
+    if not uart_connection:
+        for adv in ble.start_scan(ProvideServicesAdvertisement, timeout=5):
+            if UARTService in adv.services:
+                uart_connection = ble.connect(adv)
+                break
+        # Stop scanning whether or not we are connected.
+        ble.stop_scan()
+
+    while uart_connection and uart_connection.connected:
+        r = scale(a4.value)
+        g = scale(a5.value)
+        b = scale(a6.value)
 
         color = (r, g, b)
         print(color)
         color_packet = ColorPacket(color)
         try:
-            uart_client.write(color_packet.to_bytes())
+            uart_connection[UARTService].write(color_packet.to_bytes())
         except OSError:
             pass
         time.sleep(0.3)

Circuit_Playground_Bluefruit_Color_Remote/cpb_remote_color_periph.py

@@ -6,12 +6,17 @@
 import board
 import neopixel
 
-from adafruit_ble.uart_server import UARTServer
+from adafruit_ble import BLERadio
+from adafruit_ble.advertising.standard import ProvideServicesAdvertisement
+from adafruit_ble.services.nordic import UARTService
+
 from adafruit_bluefruit_connect.packet import Packet
 # Only the packet classes that are imported will be known to Packet.
 from adafruit_bluefruit_connect.color_packet import ColorPacket
 
-uart_server = UARTServer()
+ble = BLERadio()
+uart = UARTService()
+advertisement = ProvideServicesAdvertisement(uart)
 
 NUM_PIXELS = 10
 np = neopixel.NeoPixel(board.NEOPIXEL, NUM_PIXELS, brightness=0.1)
@@ -23,12 +28,12 @@ def mod(i):
 
 while True:
     # Advertise when not connected.
-    uart_server.start_advertising()
-    while not uart_server.connected:
+    ble.start_advertising(advertisement)
+    while not ble.connected:
         pass
 
-    while uart_server.connected:
-        packet = Packet.from_stream(uart_server)
+    while ble.connected:
+        packet = Packet.from_stream(uart)
         if isinstance(packet, ColorPacket):
             print(packet.color)
             np[next_pixel] = packet.color