Alles over Bluetooth op de Raspberry Pi Pico W

De Raspberry Pi Foundation heeft onlangs het volgende aangekondigd Bluetooth-ondersteuning met de release van de C/C++ SDK versie 1.5.1 met een nieuwe uitgave van de C/C++ SDK en van Micropython op de Pico W.

En raad eens! Als je een Pico W hebt, hoef je geen nieuwe te kopen.

En als je nog geen Pico W hebt, kun je er een kopen hier.

We hebben al een artikel over alles wat je moet weten over de Pico W. Bovendien kun je als beginner met de Pico W bekijk dit artikel.

Maar hier behandelen we alles wat je moet weten over Bluetooth op de Raspberry Pi Pico W.

Pico W Achtergrond

Laten we eerst eens kijken naar de specificaties van de Pico W.

De Pico W heeft draadloze mogelijkheden dankzij de CYW43439 draadloze chip.

Het hart van elke Pico W is de RP2040, de eerste siliciumchip van Raspberry Pi.

De Infineon CYW43439 ondersteunt IEEE 802.11 b/g/n WLAN (Wi-Fi) en Bluetooth 5.2. Bij de introductie werd alleen Wi-Fi ondersteund door de firmware en software.

De CYW43439 ondersteunt BLE en een enkele antenne die gedeeld wordt tussen Wi-Fi en Bluetooth.

Als u de Pico W van dichtbij bekijkt, zult u de driehoekige PCB-antenne opmerken die vergelijkbaar is met die van de Raspberry Pi 4. De Raspberry Pi gebruikt een ingebouwde antenne onder licentie van ABRACON.

Dat betekent dat er geen extra antenne nodig is. De draadloze interface is via SPI verbonden met de RP2040.

De officieel gegevensblad suggereert ook dat je voor de beste draadloze prestaties geen metaal onder of dichtbij de antenne moet plaatsen. Het toevoegen van geaard metaal aan de zijkanten van de antenne kan echter de bandbreedte van de antenne verbeteren.

De LED aan boord wordt aangestuurd via de WL_GPIO0 Pin van de Infineon 43439 chip. Op de Pico was de LED verbonden met GPIO Pin 25.

Verder zijn de SWD debug-pennen naar het midden van de printplaat verplaatst, om ruimte te maken voor de PCB-antenne. U kunt ze vinden tussen de RP2040 en de CYW43439 en de volgorde van links naar rechts is nog steeds SWCLK, GND, SWDIO.

Met de Pico W kun je programmeren in C/C++ en MicroPython.

Bluetooth Klassiek & BLE

De Pico W werkt met zowel Bluetooth Classic als Bluetooth Low Energy. Bluetooth Classic en Bluetooth Low Energy (BLE) zijn twee verschillende manieren voor apparaten om te communiceren binnen de Bluetooth-specificatie.

Bluetooth Classic, ook bekend als Bluetooth Basic Rate/Enhanced Data Rate (BR/EDR), is de originele versie van Bluetooth. Het is ontworpen voor datatransmissie met hoge snelheid, audiostreaming en het koppelen van apparaten. Bluetooth Classic wordt vaak gebruikt voor toepassingen zoals draadloze audioluidsprekers, toetsenborden, muizen en bestandsoverdracht tussen apparaten.

Bluetooth Low Energy (BLE), ook bekend als Bluetooth Smart, is een energiezuinige variant van Bluetooth. BLE werd geïntroduceerd als onderdeel van de Bluetooth 4.0-specificatie en is geoptimaliseerd voor apparaten met een laag stroomverbruik die een lange batterijlevensduur vereisen, zoals fitnesstrackers, smartwatches, domotica-apparaten en draadloze sensoren.

De Pico W kan zowel als centraal apparaat als randapparaat functioneren.

Aan de slag met Bluetooth op de Pico W

Laten we beginnen met een snel project om ervoor te zorgen dat Bluetooth goed werkt.

We zullen een klassiek programma uitvoeren om de LED op de Pico W aan te laten gaan, maar dan met Bluetooth.

Hiervoor heb je een Pico W, een micro-USB-kabel en een breadboard nodig.

STAP EEN

Als eerste moet je het volgende downloaden Thonny IDEals je die nog niet hebt.

Thonny is een super eenvoudige manier om MicroPython op de Pico W te programmeren.

U moet ook het volgende downloaden dit UF2-bestanddie zowel Wi-Fi als BLE ondersteunt. Zodra je het hebt gedownload, houd je de BOOTSEL-knop op de Pico W ingedrukt en sluit je hem via USB aan op je computer. Laat de BOOTSEL-knop na ongeveer 3 seconden los.

Er verschijnt een extern station met de naam "RPI-RP2". Verplaats het UF2-bestand naar dit station.

Dan verdwijnt de schijf.

STAP TWEE

U kunt nu uw Pico W loskoppelen en opnieuw aansluiten (houd deze keer de BOOTSEL-knop niet ingedrukt).

Maak Thonny open.

Nadat je Thonny hebt geopend, ga je naar Extra > Opties > Interpreter en zorg je ervoor dat de interpreter is ingesteld op Micropython en dat de poort je Pico W is:

Je Pico W kan onder een andere naam verschijnen.

Als je dat gedaan hebt, klik je op OK en kun je aan de slag.

Kopieer nu de volgende code en plak deze in de sectie :

from micropython import const
import struct
import bluetooth

_ADV_TYPE_FLAGS = const(0x01)
_ADV_TYPE_NAME = const(0x09)
_ADV_TYPE_UUID16_COMPLETE = const(0x3)
_ADV_TYPE_UUID32_COMPLETE = const(0x5)
_ADV_TYPE_UUID128_COMPLETE = const(0x7)
_ADV_TYPE_UUID16_MORE = const(0x2)
_ADV_TYPE_UUID32_MORE = const(0x4)
_ADV_TYPE_UUID128_MORE = const(0x6)
_ADV_TYPE_APPEARANCE = const(0x19)

def advertising_payload(limited_disc=False, br_edr=False, name=None, services=None, appearance=0):
    payload = bytearray()

    def _append(adv_type, value):
        nonlocal payload
        payload += struct.pack("BB", len(value) + 1, adv_type) + value

    _append(
        _ADV_TYPE_FLAGS,
        struct.pack("B", (0x01 if limited_disc else 0x02) + (0x18 if br_edr else 0x04)),
    )

    if name:
        _append(_ADV_TYPE_NAME, name)

    if services:
        for uuid in services:
            b = bytes(uuid)
            if len(b) == 2:
                _append(_ADV_TYPE_UUID16_COMPLETE, b)
            elif len(b) == 4:
                _append(_ADV_TYPE_UUID32_COMPLETE, b)
            elif len(b) == 16:
                _append(_ADV_TYPE_UUID128_COMPLETE, b)

    if appearance:
        _append(_ADV_TYPE_APPEARANCE, struct.pack("<h", appearance))

    return payload


def decode_field(payload, adv_type):
    i = 0
    result = []
    while i + 1 < len(payload):
        if payload[i + 1] == adv_type:
            result.append(payload[i + 2 : i + payload[i] + 1])
        i += 1 + payload[i]
    return result


def decode_name(payload):
    n = decode_field(payload, _ADV_TYPE_NAME)
    return str(n[0], "utf-8") if n else ""


def decode_services(payload):
    services = []
    for u in decode_field(payload, _ADV_TYPE_UUID16_COMPLETE):
        services.append(bluetooth.UUID(struct.unpack("<h", u)[0]))
    for u in decode_field(payload, _ADV_TYPE_UUID32_COMPLETE):
        services.append(bluetooth.UUID(struct.unpack("<d", u)[0]))
    for u in decode_field(payload, _ADV_TYPE_UUID128_COMPLETE):
        services.append(bluetooth.UUID(u))
    return services


def demo():
    payload = advertising_payload(
        name="micropython",
        services=[bluetooth.UUID(0x181A), bluetooth.UUID("6E400001-B5A3-F393-E0A9-E50E24DCCA9E")],
    )
    print(payload)
    print(decode_name(payload))
    print(decode_services(payload))


if __name__ == "__main__":
    demo()

Sla dat bestand op de Raspberry Pi Pico W op als "ble_advertising.py". Dit bestand is ontworpen om het voor de Pico W mogelijk te maken om andere apparaten te lezen en gelezen te worden.

Open vervolgens een nieuw bestand in Thonny en plak de volgende code erin:

# PiCockpit.com

import bluetooth
import random
import struct
import time
from machine import Pin
from ble_advertising import advertising_payload

from micropython import const

_IRQ_CENTRAL_CONNECT = const(1)
_IRQ_CENTRAL_DISCONNECT = const(2)
_IRQ_GATTS_WRITE = const(3)

_FLAG_READ = const(0x0002)
_FLAG_WRITE_NO_RESPONSE = const(0x0004)
_FLAG_WRITE = const(0x0008)
_FLAG_NOTIFY = const(0x0010)

_UART_UUID = bluetooth.UUID("6E400001-B5A3-F393-E0A9-E50E24DCCA9E")
_UART_TX = (
    bluetooth.UUID("6E400003-B5A3-F393-E0A9-E50E24DCCA9E"),
    _FLAG_READ | _FLAG_NOTIFY,
)
_UART_RX = (
    bluetooth.UUID("6E400002-B5A3-F393-E0A9-E50E24DCCA9E"),
    _FLAG_WRITE | _FLAG_WRITE_NO_RESPONSE,
)
_UART_SERVICE = (
    _UART_UUID,
    (_UART_TX, _UART_RX),
)


class BLESimplePeripheral:
    def __init__(self, ble, name="mpy-uart"):
        self._ble = ble
        self._ble.active(True)
        self._ble.irq(self._irq)
        ((self._handle_tx, self._handle_rx),) = self._ble.gatts_register_services((_UART_SERVICE,))
        self._connections = set()
        self._write_callback = None
        self._payload = advertising_payload(name=name, services=[_UART_UUID])
        self._advertise()

    def _irq(self, event, data):
        if event == _IRQ_CENTRAL_CONNECT:
            conn_handle, _, _ = data
            print("New connection", conn_handle)
            self._connections.add(conn_handle)
        elif event == _IRQ_CENTRAL_DISCONNECT:
            conn_handle, _, _ = data
            print("Disconnected", conn_handle)
            self._connections.remove(conn_handle)
            self._advertise()
        elif event == _IRQ_GATTS_WRITE:
            conn_handle, value_handle = data
            value = self._ble.gatts_read(value_handle)
            if value_handle == self._handle_rx and self._write_callback:
                self._write_callback(value)

    def send(self, data):
        for conn_handle in self._connections:
            self._ble.gatts_notify(conn_handle, self._handle_tx, data)

    def is_connected(self):
        return len(self._connections) > 0

    def _advertise(self, interval_us=500000):
        print("Starting advertising")
        self._ble.gap_advertise(interval_us, adv_data=self._payload)

    def on_write(self, callback):
        self._write_callback = callback


def demo():
    led_onboard = Pin("LED", Pin.OUT)
    ble = bluetooth.BLE()
    p = BLESimplePeripheral(ble)

    def on_rx(v):
        print("RX", v)

    p.on_write(on_rx)

    i = 0
    while True:
        if p.is_connected():
            led_onboard.on()
            for _ in range(3):
                data = str(i) + "_"
                print("TX", data)
                p.send(data)
                i += 1
        time.sleep_ms(100)


if __name__ == "__main__":
    demo()

Sla nu, net als eerder, het bestand op de Pico W op en noem het deze keer "led_peripheral.py". Terwijl het advertising-bestand de Pico W in staat stelt om met andere apparaten te communiceren, stelt het peripheral-bestand hem in staat om functie als een randapparaat. In dit geval is die functie het inschakelen van de LED.

Druk nu op "Voer huidig script uit" in de Thonny werkbalk.

Zoals je in de afbeelding kunt zien, geeft de console "Starting advertising" (reclame starten) weer. Op dit punt kun je verbinding maken met een Bluetooth-apparaat zoals je telefoon. Zoek en koppel met "mpy-uart".

Zodra je de twee koppelt, gaat de LED van de Pico W aan en begint de Thonny console te tellen hoe lang de twee geteld zijn:

Gefeliciteerd! Je hebt nu bevestigd dat de Bluetooth van je Pico W werkt en je kunt je nu gaan richten op je volgende project!

Pico W Bluetooth-projecten

Wanneer je aan je volgende Pico W project begint, kun je gebruik maken van enkele projecten die anderen al gedaan hebben. Aangezien de Pico W net officiële Bluetooth-ondersteuning heeft gekregen, beginnen er net nieuwe projecten te verschijnen.

Hier is een (groeiende) lijst van enkele projecten die tot nu toe zijn verschenen:

1. Pico W Bluetooth Afstandsbediening
2. Pico W Bluetooth Robot
3. Pico W Bluetooth Muis
4. Pico W Bluetooth Lichten
5. Pico W USB naar Bluetooth Audio-adapter
6. Pico W Bluetooth PicoDRO (digitale uitlezing)

FAQ

Kan ik Bluetooth Classic gebruiken met de Pico W?

Absoluut, de Pico W ondersteunt Bluetooth Classic en BLE!

Kan ik meerdere apparaten tegelijk aansluiten op de Pico W?

Ja, de Pico W kan fungeren als centraal apparaat en tegelijkertijd verbinding maken met meerdere Bluetooth-randapparaten. Je kunt ook Bluetooth Classic en BLE tegelijkertijd gebruiken. Je kunt dus ultra-complexe systemen maken waarbij de Pico W communiceert met een heleboel sensoren of meerdere apparaten tegelijk aanstuurt.

Wat is het Bluetooth-bereik van de Pico W?

Gewoonlijk tot 30 meter in een open ruimte. Het bereik kan echter variëren afhankelijk van omgevingsfactoren zoals obstakels, interferentie en signaalsterkte.

Kan ik de Pico W gebruiken als een randapparaat met Bluetooth?

De Pico W kan functioneren als centraal apparaat of als randapparaat. Andere centrale Bluetooth-apparaten (zoals smartphones, tablets of computers) kunnen er dus verbinding mee maken. Dit alles werkt prachtig met PiCockpittrouwens!

Hoe programmeer ik Bluetooth-functionaliteit op de Pico W?

Je kunt Bluetooth-functionaliteit programmeren op de Pico W met behulp van de Raspberry Pi Pico SDK versie 1.5.1. De SDK biedt bibliotheken en voorbeelden speciaal voor Bluetooth-ontwikkeling. Hiermee kun je Bluetooth-diensten en -kenmerken implementeren en communicatieprotocollen afhandelen.

Wat zijn de stroomvereisten voor Bluetooth op de Pico W?

Bluetooth is ontworpen om energiezuinig te zijn. De Pico W verbruikt dus minimale energie tijdens inactieve periodes en je kunt je code verder optimaliseren door technieken als slaapstanden en spaarstanden te gebruiken. De specifieke stroomvereisten zijn uiteraard afhankelijk van de toepassing en het gebruiksscenario.