Tout sur le Bluetooth sur le Raspberry Pi Pico W

La Fondation Raspberry Pi a récemment annoncé Prise en charge de Bluetooth avec la sortie de la version 1.5.1 du SDK C/C++ avec une nouvelle version du SDK C/C++ et de Micropython sur le Pico W.

Et devinez quoi ! Si vous avez un Pico W, vous n'avez pas besoin d'en acheter un nouveau.

Et si vous n'avez pas encore de Pico W, vous pouvez en acheter un ici.

Nous disposons déjà d'un article couvrant tout ce que vous devez savoir sur le Pico W. De plus, si vous êtes un débutant avec le Pico W, vous pouvez lire cet article.

Mais ici, nous couvrons tout ce que vous devez savoir sur Bluetooth sur le Raspberry Pi Pico W.

Pico W Background

Voyons tout d'abord les caractéristiques du Pico W.

Le Pico W dispose de capacités sans fil grâce à la puce sans fil CYW43439.

Au cœur de chaque Pico W se trouve le RP2040, qui est la première puce en silicium du Raspberry Pi.

Le CYW43439 d'Infineon prend en charge le WLAN (Wi-Fi) IEEE 802.11 b/g/n et Bluetooth 5.2. Au lancement, seul le Wi-Fi était pris en charge par le micrologiciel et le logiciel.

Le CYW43439 prend en charge le BLE et une antenne unique partagée entre le Wi-Fi et le Bluetooth.

Si vous regardez de plus près le Pico W, vous remarquerez l'antenne PCB en forme de triangle, similaire à celle du Raspberry Pi 4. Le Raspberry Pi utilise une antenne embarquée sous licence ABRACON.

Cela signifie qu'aucune antenne supplémentaire n'est nécessaire. L'interface sans fil est connectée via SPI au RP2040.

Le site fiche technique officielle suggère également que pour obtenir les meilleures performances sans fil, il ne faut pas placer de métal sous ou à proximité de l'antenne. Toutefois, l'ajout de métal mis à la terre sur les côtés de l'antenne peut améliorer la bande passante de l'antenne.

La LED embarquée est contrôlée par la broche WL_GPIO0 de la puce Infineon 43439. Sur le Pico, la LED était connectée à la broche GPIO 25.

De plus, les broches de débogage SWD ont été déplacées vers le centre de la carte, afin de créer de l'espace pour l'antenne du PCB. Vous pouvez les trouver entre le RP2040 et le CYW43439 et l'ordre de gauche à droite est toujours SWCLK, GND, SWDIO.

Avec le Pico W, vous pouvez programmer en C/C++ et MicroPython.

Bluetooth Classic & BLE

Le Pico W fonctionne à la fois avec Bluetooth Classic et Bluetooth Low Energy. Bluetooth Classic et Bluetooth Low Energy (BLE) sont deux façons différentes pour les appareils de communiquer dans le cadre de la spécification Bluetooth.

Bluetooth Classic, également connu sous le nom de Bluetooth Basic Rate/Enhanced Data Rate (BR/EDR), est la version originale de Bluetooth. Elle a été conçue pour la transmission de données à haut débit, le streaming audio et le couplage d'appareils. Bluetooth Classic est couramment utilisé pour des applications telles que les haut-parleurs audio sans fil, les claviers, les souris et le transfert de fichiers entre appareils.

Bluetooth Low Energy (BLE), également connu sous le nom de Bluetooth Smart, est une variante économe en énergie de Bluetooth. BLE a été introduit dans le cadre de la spécification Bluetooth 4.0 et est optimisé pour les appareils à faible consommation d'énergie qui nécessitent une longue durée de vie de la batterie, tels que les trackers de fitness, les smartwatches, les appareils de domotique et les capteurs sans fil.

Le Pico W peut fonctionner à la fois comme un dispositif central et comme un dispositif périphérique.

Démarrer avec Bluetooth sur le Pico W

Commençons par un projet rapide pour nous assurer que Bluetooth fonctionne correctement.

Nous allons exécuter un programme classique pour allumer la LED embarquée sur le Pico W, mais avec Bluetooth.

Pour cela, vous aurez besoin d'un Pico W, d'un câble micro-USB et d'une planche à pain.

PREMIÈRE ÉTAPE

La première chose dont vous aurez besoin est de télécharger Thonny IDEsi vous ne l'avez pas déjà.

Thonny est un moyen très simple de programmer MicroPython sur le Pico W.

Vous devez également télécharger ce fichier UF2qui prend en charge à la fois le Wi-Fi et le BLE. Une fois que vous l'avez téléchargé, maintenez enfoncé le bouton BOOTSEL du Pico W et connectez-le à votre ordinateur via USB. Relâchez le bouton BOOTSEL après environ 3 secondes.

Un lecteur distant appelé "RPI-RP2" apparaît. Déplacez le fichier UF2 sur ce lecteur.

Le lecteur disparaît alors.

DEUXIÈME ÉTAPE

Vous pouvez maintenant déconnecter et reconnecter votre Pico W (cette fois, ne maintenez pas le bouton BOOTSEL enfoncé).

Ouvrez Thonny.

Une fois Thonny ouvert, allez dans Tools > Options > Interpreter et assurez-vous que l'interpréteur est défini sur Micropython et que le Port est votre Pico W. Voici un exemple :

Votre Pico W peut apparaître sous un nom différent.

Une fois que vous avez fait cela, cliquez sur OK et vous êtes prêt à partir.

Maintenant, copiez le code suivant et collez-le dans la section :

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

Enregistrez ce fichier sur le Raspberry Pi Pico W sous le nom de "ble_advertising.py". Ce fichier est conçu pour permettre au Pico W de lire et d'être lu par d'autres appareils.

Ensuite, ouvrez un nouveau fichier dans Thonny et collez-y le code suivant :

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

Maintenant, comme précédemment, sauvegardez le fichier sur le Pico W et cette fois, vous pouvez l'appeler "led_peripheral.py". Alors que le fichier publicitaire permet à la Pico W de communiquer avec d'autres appareils, le fichier périphérique lui permet de fonction en tant que périphérique. Dans ce cas, cette fonction consistera à allumer la LED.

Cliquez ensuite sur "Run current script" dans la barre d'outils de Thonny.

Comme vous pouvez le voir sur l'image, la console affichera "Starting advertising". À ce stade, vous pouvez vous connecter à un appareil Bluetooth tel que votre téléphone. Trouvez et appairez avec "mpy-uart".

Une fois les deux jumelés, la DEL du Pico W s'allume et la console Thonny commence à compter la durée pendant laquelle les deux sont comptés :

Félicitations ! Vous avez maintenant confirmé que le Bluetooth de votre Pico W fonctionne et vous pouvez maintenant vous concentrer sur votre prochain projet !

Projets Pico W Bluetooth

Lorsque vous commencerez votre prochain projet Pico W, vous pourrez vous tourner vers certains des projets réalisés par d'autres. Depuis que le Pico W vient de recevoir la prise en charge officielle de Bluetooth, de nouveaux projets commencent à voir le jour.

Voici une liste (croissante) de quelques-uns des projets qui sont apparus jusqu'à présent :

1. Pico W Bluetooth Télécommande
2. Pico W Bluetooth Robot
3. Pico W Bluetooth Souris
4. Pico W Bluetooth Lumières
5. Pico W USB vers Bluetooth Adaptateur audio
6. Pico W Bluetooth PicoDRO (lecture numérique)

FAQ

Puis-je utiliser Bluetooth Classic avec le Pico W ?

Absolument, le Pico W prend en charge Bluetooth Classic et BLE !

Puis-je connecter simultanément plusieurs appareils au Pico W ?

Oui, le Pico W peut agir en tant que dispositif central et se connecter à plusieurs périphériques Bluetooth simultanément. Vous pouvez également utiliser simultanément Bluetooth Classic et BLE. Vous pouvez donc créer des systèmes ultra-complexes dans lesquels le Pico W communique avec un grand nombre de capteurs ou contrôle plusieurs appareils à la fois.

Quelle est la portée du Bluetooth sur le Pico W ?

Généralement jusqu'à 30 mètres (98 pieds) dans un espace ouvert. Toutefois, la portée peut varier en fonction de facteurs environnementaux tels que les obstacles, les interférences et la force du signal.

Puis-je utiliser le Pico W comme périphérique Bluetooth ?

Le Pico W peut fonctionner comme un appareil central ou périphérique. Il permet donc à d'autres appareils centraux Bluetooth (tels que les smartphones, les tablettes ou les ordinateurs) de s'y connecter. Tout cela fonctionne parfaitement avec PiCockpitd'ailleurs !

Comment programmer la fonctionnalité Bluetooth sur le Pico W ?

Vous pouvez programmer la fonctionnalité Bluetooth sur le Pico W en utilisant le Raspberry Pi Pico SDK version 1.5.1. Le SDK fournit des bibliothèques et des exemples spécifiques au développement Bluetooth. Il vous permet de mettre en œuvre les services et les caractéristiques Bluetooth et de gérer les protocoles de communication.

Quelles sont les exigences en matière d'alimentation pour le Bluetooth sur le Pico W ?

Bluetooth est conçu pour être économe en énergie. Le Pico W consomme donc peu d'énergie pendant les périodes d'inactivité et vous pouvez optimiser davantage votre code en utilisant des techniques telles que les modes de veille et les états de faible consommation. Les exigences spécifiques en matière de consommation d'énergie dépendent évidemment de l'application et du scénario d'utilisation.