Wszystko o Bluetooth na Raspberry Pi Pico W

Fundacja Raspberry Pi ogłosiła niedawno Obsługa Bluetooth wraz z wydaniem pakietu C/C++ SDK w wersji 1.5.1 z nową wersją C/C++ SDK i Micropython na Pico W.

I zgadnij co! Jeśli masz Pico W, nie musisz kupować nowego.

A jeśli nie masz jeszcze Pico W, możesz go kupić tutaj.

Mamy już artykuł na ten temat Wszystko, co musisz wiedzieć o Pico W. Ponadto, jeśli jesteś początkującym użytkownikiem Pico W, możesz Sprawdź ten artykuł.

Ale tutaj omawiamy wszystko, co musisz wiedzieć o Bluetooth na Raspberry Pi Pico W.

Tło Pico W

Przejdźmy najpierw do niektórych specyfikacji Pico W.

Pico W ma możliwości bezprzewodowe dzięki układowi bezprzewodowemu CYW43439.

Sercem każdego Pico W jest RP2040, który jest pierwszym układem krzemowym Raspberry Pi.

Infineon CYW43439 obsługuje IEEE 802.11 b/g/n WLAN (Wi-Fi) i Bluetooth 5.2. W momencie premiery tylko Wi-Fi było obsługiwane przez oprogramowanie układowe i oprogramowanie.

CYW43439 obsługuje BLE i pojedynczą antenę współdzieloną między Wi-Fi i Bluetooth.

Jeśli przyjrzeć się bliżej Pico W, można zauważyć trójkątny kształt anteny PCB, podobny do tego, jaki zastosowano w Raspberry Pi 4. Raspberry Pi używa anteny pokładowej na licencji firmy ABRACON.

Oznacza to, że nie jest potrzebna dodatkowa antena. Interfejs bezprzewodowy jest podłączony przez SPI do RP2040.

Strona oficjalny arkusz danych sugeruje również, że aby uzyskać najlepszą wydajność bezprzewodową, nie należy umieszczać metalu pod anteną lub w jej pobliżu. Jednak dodanie uziemionego metalu po bokach anteny może poprawić jej przepustowość.

Wbudowana dioda LED jest sterowana przez pin WL_GPIO0 układu 43439 firmy Infineon. W modelu Pico dioda LED była podłączona do pinu GPIO 25.

Ponadto piny debug SWD zostały przesunięte na środek płytki, aby zrobić miejsce na antenę PCB. Można je znaleźć pomiędzy RP2040 a CYW43439, a kolejność od lewej do prawej to nadal SWCLK, GND, SWDIO.

Pico W umożliwia programowanie w językach C/C++ i MicroPython.

Bluetooth Classic i BLE

Pico W działa zarówno z Bluetooth Classic, jak i Bluetooth Low Energy. Bluetooth Classic i Bluetooth Low Energy (BLE) to dwa różne sposoby komunikacji urządzeń w ramach specyfikacji Bluetooth.

Bluetooth Classic, znany również jako Bluetooth Basic Rate/Enhanced Data Rate (BR/EDR), to oryginalna wersja Bluetooth. Został zaprojektowany do szybkiej transmisji danych, strumieniowego przesyłania dźwięku i parowania urządzeń. Bluetooth Classic jest powszechnie używany do takich zastosowań, jak bezprzewodowe głośniki audio, klawiatury, myszy i przesyłanie plików między urządzeniami.

Bluetooth Low Energy (BLE), znany również jako Bluetooth Smart, to energooszczędny wariant Bluetooth. BLE został wprowadzony jako część specyfikacji Bluetooth 4.0 i jest zoptymalizowany pod kątem urządzeń o niskim poborze mocy, które wymagają długiej żywotności baterii, takich jak monitory fitness, smartwatche, urządzenia automatyki domowej i czujniki bezprzewodowe.

Pico W może działać zarówno jako urządzenie centralne, jak i urządzenie peryferyjne.

Rozpoczęcie pracy z Bluetooth na Pico W

Zacznijmy od szybkiego projektu, aby upewnić się, że Bluetooth działa poprawnie.

Uruchomimy klasyczny program, aby włączyć wbudowaną diodę LED na Pico W, ale z Bluetooth.

W tym celu potrzebny będzie Pico W, kabel micro-USB i płytka prototypowa.

KROK PIERWSZY

Pierwszą rzeczą, której będziesz potrzebować, jest pobranie Thonny IDEjeśli jeszcze go nie masz.

Thonny to bardzo prosty sposób na zaprogramowanie MicroPythona na Pico W.

Należy również pobrać ten plik UF2który obsługuje zarówno Wi-Fi, jak i BLE. Po pobraniu aplikacji przytrzymaj przycisk BOOTSEL na urządzeniu Pico W i podłącz je do komputera przez USB. Puść przycisk BOOTSEL po około 3 sekundach.

Pojawi się dysk zdalny o nazwie "RPI-RP2". Przenieś plik UF2 na ten dysk.

Następnie dysk zniknie.

KROK DRUGI

Możesz teraz odłączyć i ponownie podłączyć Pico W (tym razem nie przytrzymuj przycisku BOOTSEL).

Otwórz Thonny.

Po otwarciu Thonny przejdź do Narzędzia > Opcje > Interpreter, a następnie upewnij się, że interpreter jest ustawiony na Micropython, a port to Pico W. Oto przykład:

Pico W może występować pod inną nazwą.

Gdy to zrobisz, kliknij OK i jesteś gotowy do pracy.

Teraz skopiuj poniższy kod i wklej go do sekcji :

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

Zapisz ten plik na Raspberry Pi Pico W jako "ble_advertising.py". Plik ten ma na celu umożliwienie Pico W odczytywania i bycia odczytywanym przez inne urządzenia.

Następnie otwórz nowy plik w Thonny i wklej do niego następujący kod:

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

Teraz, tak jak poprzednio, zapisz plik na Pico W i tym razem możesz nazwać go "led_peripheral.py". Podczas gdy plik reklamowy umożliwia Pico W komunikację z innymi urządzeniami, plik peryferyjny umożliwia mu funkcja jako urządzenie peryferyjne. W tym przypadku funkcją tą będzie włączenie diody LED.

Teraz naciśnij "Uruchom bieżący skrypt" na pasku narzędzi Thonny.

Jak widać na obrazku, konsola wyświetli komunikat "Starting advertising". W tym momencie można połączyć się z urządzeniem Bluetooth, takim jak telefon. Znajdź i sparuj z "mpy-uart".

Po sparowaniu obu urządzeń dioda LED Pico W zaświeci się, a konsola Thonny zacznie liczyć, jak długo oba urządzenia są ze sobą połączone:

Gratulacje! Potwierdziłeś, że Bluetooth w Pico W działa i możesz teraz skupić się na kolejnym projekcie!

Projekty Pico W Bluetooth

Rozpoczynając kolejny projekt Pico W, możesz skorzystać z niektórych projektów, które wykonali inni. Odkąd Pico W otrzymał oficjalne wsparcie Bluetooth, nowe projekty dopiero zaczynają się pojawiać.

Oto (rosnąca) lista niektórych projektów, które pojawiły się do tej pory:

1. Pico W Bluetooth Pilot zdalnego sterowania
2. Pico W Bluetooth Robot
3. Pico W Bluetooth Mysz
4. Pico W Bluetooth Światła
5. Pico W USB do Bluetooth Adapter audio
6. Pico W Bluetooth PicoDRO (odczyt cyfrowy)

FAQ

Czy mogę używać Bluetooth Classic z Pico W?

Oczywiście, Pico W obsługuje Bluetooth Classic i BLE!

Czy mogę podłączyć wiele urządzeń do Pico W jednocześnie?

Tak, Pico W może działać jako urządzenie centralne i łączyć się z wieloma urządzeniami peryferyjnymi Bluetooth jednocześnie. Można również jednocześnie korzystać z Bluetooth Classic i BLE. Można więc tworzyć bardzo złożone systemy, w których Pico W komunikuje się z wieloma czujnikami lub steruje wieloma urządzeniami jednocześnie.

Jaki jest zasięg Bluetooth w Pico W?

Zazwyczaj do 30 metrów (98 stóp) na otwartej przestrzeni. Zasięg może się jednak różnić w zależności od czynników środowiskowych, takich jak przeszkody, zakłócenia i siła sygnału.

Czy mogę używać Pico W jako urządzenia peryferyjnego Bluetooth?

Pico W może działać jako urządzenie centralne lub peryferyjne. Umożliwia więc łączenie się z innymi centralnymi urządzeniami Bluetooth (takimi jak smartfony, tablety lub komputery). Wszystko to doskonale współpracuje z PiCockpittak przy okazji!

Jak zaprogramować funkcję Bluetooth w Pico W?

Funkcjonalność Bluetooth na Pico W można zaprogramować przy użyciu Raspberry Pi Pico SDK w wersji 1.5.1. SDK zapewnia biblioteki i przykłady specjalnie dla rozwoju Bluetooth. Umożliwia implementację usług Bluetooth, charakterystyki i obsługę protokołów komunikacyjnych.

Jakie są wymagania dotyczące zasilania dla Bluetooth w Pico W?

Bluetooth został zaprojektowany tak, aby był energooszczędny. Tak więc Pico W zużywa minimalną ilość energii w okresach bezczynności, a kod można dodatkowo zoptymalizować za pomocą technik takich jak tryby uśpienia i stany niskiego poboru mocy. Konkretne wymagania dotyczące zasilania zależą oczywiście od aplikacji i scenariusza użytkowania.