Alles über Bluetooth auf dem Raspberry Pi Pico W

Die Raspberry Pi Foundation hat kürzlich angekündigt Bluetooth-Unterstützung mit der Veröffentlichung des C/C++ SDK Version 1.5.1 mit einer neuen Version des C/C++ SDK und von Micropython auf dem Pico W.

Und wissen Sie was? Wenn Sie einen Pico W haben, brauchen Sie keinen neuen zu kaufen.

Und wenn Sie noch keinen Pico W haben, können Sie einen kaufen hier.

Wir haben bereits einen Artikel über alles, was Sie über den Pico W wissen müssen. Wenn Sie mit dem Pico W noch nicht vertraut sind, können Sie Lesen Sie diesen Artikel.

Aber hier erfahren Sie alles, was Sie wissen müssen über Bluetooth auf dem Raspberry Pi Pico W.

Pico W Hintergrund

Kommen wir zunächst zu den technischen Daten des Pico W.

Der Pico W ist dank des CYW43439 Wireless-Chips kabellos.

Das Herzstück eines jeden Pico W ist der RP2040, der erste Siliziumchip des Raspberry Pi.

Der Infineon CYW43439 unterstützt IEEE 802.11 b/g/n WLAN (Wi-Fi) und Bluetooth 5.2. Bei der Markteinführung wurde nur Wi-Fi von der Firmware und Software unterstützt.

Der CYW43439 unterstützt BLE und eine einzige Antenne, die von Wi-Fi und Bluetooth gemeinsam genutzt wird.

Wenn Sie sich den Pico W genauer ansehen, werden Sie die dreieckige PCB-Antenne bemerken, die der des Raspberry Pi 4 ähnelt. Der Raspberry Pi verwendet eine von ABRACON lizenzierte Onboard-Antenne.

Das bedeutet, dass keine zusätzliche Antenne benötigt wird. Die Funkschnittstelle ist über SPI mit dem RP2040 verbunden.

Die offizielles Datenblatt empfiehlt außerdem, dass Sie für eine optimale Funkleistung kein Metall unter oder in der Nähe der Antenne anbringen sollten. Das Hinzufügen von geerdetem Metall an den Seiten der Antenne kann jedoch die Bandbreite der Antenne verbessern.

Die Onboard-LED wird über den WL_GPIO0 Pin des Infineon 43439 Chips gesteuert. Auf dem Pico wurde die LED an GPIO Pin 25 angeschlossen.

Außerdem wurden die SWD-Debug-Pins in die Mitte des Boards verlegt, um Platz für die PCB-Antenne zu schaffen. Sie sind zwischen dem RP2040 und dem CYW43439 zu finden und die Reihenfolge von links nach rechts ist immer noch SWCLK, GND, SWDIO.

Mit dem Pico W können Sie in C/C++ und MicroPython programmieren.

Bluetooth Klassisch & BLE

Der Pico W funktioniert sowohl mit Bluetooth Classic als auch mit Bluetooth Low Energy. Bluetooth Classic und Bluetooth Low Energy (BLE) sind zwei verschiedene Möglichkeiten für Geräte, innerhalb der Bluetooth-Spezifikation zu kommunizieren.

Bluetooth Classic, auch bekannt als Bluetooth Basic Rate/Enhanced Data Rate (BR/EDR), ist die ursprüngliche Version von Bluetooth. Sie wurde für Hochgeschwindigkeits-Datenübertragung, Audio-Streaming und Gerätekopplung entwickelt. Bluetooth Classic wird häufig für Anwendungen wie kabellose Audio-Lautsprecher, Tastaturen, Mäuse und die Dateiübertragung zwischen Geräten verwendet.

Bluetooth Low Energy (BLE), auch bekannt als Bluetooth Smart, ist eine energiesparende Variante von Bluetooth. BLE wurde als Teil der Bluetooth 4.0-Spezifikation eingeführt und ist für Geräte mit geringem Stromverbrauch optimiert, die eine lange Akkulaufzeit benötigen, wie z. B. Fitness-Tracker, Smartwatches, Hausautomatisierungsgeräte und drahtlose Sensoren.

Der Pico W kann sowohl als zentrales Gerät als auch als Peripheriegerät fungieren.

Erste Schritte mit Bluetooth auf dem Pico W

Beginnen wir mit einem kurzen Projekt, um sicherzustellen, dass Bluetooth richtig funktioniert.

Wir werden ein klassisches Programm ausführen, um die integrierte LED auf dem Pico W zum Leuchten zu bringen, allerdings mit Bluetooth.

Hierfür benötigen Sie einen Pico W, ein Micro-USB-Kabel und ein Breadboard.

SCHRITT 1

Als Erstes müssen Sie Folgendes herunterladen Thonny IDEfalls Sie es noch nicht haben.

Thonny ist eine super einfache Möglichkeit, MicroPython auf dem Pico W zu programmieren.

Sie müssen auch Folgendes herunterladen diese UF2-Dateidie sowohl Wi-Fi- als auch BLE-Unterstützung bietet. Sobald du es heruntergeladen hast, halte die BOOTSEL-Taste am Pico W gedrückt und verbinde es über USB mit deinem Computer. Lassen Sie die BOOTSEL-Taste nach etwa 3 Sekunden los.

Es erscheint ein entferntes Laufwerk namens "RPI-RP2". Verschieben Sie die UF2-Datei auf dieses Laufwerk.

Dann wird das Laufwerk verschwinden.

SCHRITT ZWEI

Sie können nun Ihren Pico W ab- und wieder anstecken (halten Sie diesmal die BOOTSEL-Taste nicht gedrückt).

Öffnen Sie Thonny.

Nachdem Sie Thonny geöffnet haben, gehen Sie zu Extras > Optionen > Interpreter und stellen Sie sicher, dass der Interpreter auf Micropython eingestellt ist und der Port Ihr Pico W ist:

Ihr Pico W erscheint möglicherweise unter einem anderen Namen.

Klicken Sie anschließend auf OK, und schon können Sie loslegen.

Kopieren Sie nun den folgenden Code und fügen Sie ihn in den Abschnitt ein:

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()

Speichern Sie diese Datei auf dem Raspberry Pi Pico W als "ble_advertising.py". Diese Datei soll es dem Pico W ermöglichen, andere Geräte zu lesen und von ihnen gelesen zu werden.

Öffnen Sie dann eine neue Datei in Thonny und fügen Sie den folgenden Code ein:

# 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()

Speichern Sie die Datei wie zuvor auf dem Pico W. Diesmal können Sie sie "led_peripheral.py" nennen. Während die Werbedatei es dem Pico W ermöglicht, mit anderen Geräten zu kommunizieren, ermöglicht die Peripheriedatei ihm Funktion als ein Peripheriegerät. In diesem Fall besteht die Funktion darin, die LED einzuschalten.

Klicken Sie nun auf "Aktuelles Skript ausführen" in der Thonny-Symbolleiste.

Wie Sie auf dem Bild sehen können, meldet die Konsole "Starting advertising". Jetzt können Sie eine Verbindung mit einem Bluetooth-Gerät, z. B. Ihrem Telefon, herstellen. Suchen und koppeln Sie mit "mpy-uart".

Sobald Sie die beiden gekoppelt haben, leuchtet die LED des Pico W auf und die Thonny-Konsole beginnt zu zählen, wie lange die beiden gezählt werden:

Herzlichen Glückwunsch! Sie haben nun bestätigt, dass die Bluetooth-Funktion Ihres Pico W funktioniert und Sie können sich nun auf Ihr nächstes Projekt konzentrieren!

Pico W Bluetooth Projekte

Wenn Sie Ihr nächstes Pico W-Projekt beginnen, können Sie sich an einigen Projekten orientieren, die andere bereits durchgeführt haben. Da der Pico W gerade erst offizielle Bluetooth-Unterstützung erhalten hat, tauchen gerade neue Projekte auf.

Hier ist eine (wachsende) Liste einiger der bisher erschienenen Projekte:

1. Pico W Bluetooth Fernsteuerung
2. Pico W Bluetooth Roboter
3. Pico W Bluetooth Maus
4. Pico W Bluetooth Lichter
5. Pico W USB zu Bluetooth Audio-Adapter
6. Pico W Bluetooth PicoDRO (digitale Auslesung)

FAQ

Kann ich Bluetooth Classic mit dem Pico W verwenden?

Ja, der Pico W unterstützt Bluetooth Classic und BLE!

Kann ich mehrere Geräte gleichzeitig an den Pico W anschließen?

Ja, der Pico W kann als zentrales Gerät fungieren und sich mit mehreren Bluetooth-Peripheriegeräten gleichzeitig verbinden. Sie können auch Bluetooth Classic und BLE gleichzeitig verwenden. So können Sie ultrakomplexe Systeme erstellen, bei denen der Pico W mit einer Reihe von Sensoren kommuniziert oder mehrere Geräte gleichzeitig steuert.

Wie groß ist die Bluetooth-Reichweite des Pico W?

In der Regel bis zu 30 Meter (98 Fuß) im freien Raum. Die Reichweite kann jedoch je nach Umgebungsfaktoren wie Hindernissen, Störungen und Signalstärke variieren.

Kann ich den Pico W als Bluetooth-Peripheriegerät verwenden?

Der Pico W kann als zentrales oder als peripheres Gerät fungieren. So können andere Bluetooth-Zentralgeräte (wie Smartphones, Tablets oder Computer) mit ihm verbunden werden. All dies funktioniert wunderbar mit PiCockpitÜbrigens!

Wie programmiere ich die Bluetooth-Funktion auf dem Pico W?

Sie können Bluetooth-Funktionen auf dem Pico W mit dem Raspberry Pi Pico SDK Version 1.5.1 programmieren. Das SDK bietet Bibliotheken und Beispiele speziell für die Bluetooth-Entwicklung. Es ermöglicht Ihnen die Implementierung von Bluetooth-Diensten und -Eigenschaften sowie die Handhabung von Kommunikationsprotokollen.

Wie hoch ist der Strombedarf für Bluetooth auf dem Pico W?

Bluetooth ist so konzipiert, dass es stromsparend ist. Daher verbraucht der Pico W im Leerlauf nur wenig Strom, und Sie können Ihren Code weiter optimieren, indem Sie Techniken wie Ruhemodi und Stromsparzustände verwenden. Die spezifischen Leistungsanforderungen hängen natürlich von der Anwendung und dem Nutzungsszenario ab.