Tudo sobre o Bluetooth no Raspberry Pi Pico W

A Fundação Raspberry Pi anunciou recentemente Suporte Bluetooth com o lançamento da versão 1.5.1 do SDK C/C++ com uma nova versão do SDK C/C++ e do Micropython no Pico W.

E adivinhe! Se já tem um Pico W, não precisa de comprar um novo.

E se ainda não tiver um Pico W, pode comprar um aqui.

Já temos um artigo sobre tudo o que precisa de saber sobre o Pico W. Além disso, se for um principiante com o Pico W, pode ver este artigo.

Mas aqui, vamos cobrir tudo o que precisa de saber sobre Bluetooth no Raspberry Pi Pico W.

Pico W Fundo

Vejamos primeiro algumas das especificações do Pico W.

O Pico W tem capacidades sem fios graças ao chip sem fios CYW43439.

No coração de cada Pico W está o RP2040, que é o primeiro chip de silício do Raspberry Pi.

O Infineon CYW43439 suporta IEEE 802.11 b/g/n WLAN (Wi-Fi) e Bluetooth 5.2. No lançamento, apenas o Wi-Fi era suportado pelo firmware e pelo software.

O CYW43439 suporta BLE e uma única antena partilhada entre Wi-Fi e Bluetooth.

Se olhar mais de perto para o Pico W, notará a antena PCB em forma de triângulo semelhante à Raspberry Pi 4. Raspberry Pi utiliza uma antena de bordo licenciada pela ABRACON.

Isso significa que não é necessária antena adicional. A interface sem fios é ligada via SPI ao RP2040.

O ficha de dados oficial também sugere que, para obter o melhor desempenho sem fios, não se deve colocar qualquer metal por baixo ou perto da antena. No entanto, adicionar metal ligado à terra aos lados da antena pode melhorar a largura de banda da antena.

O LED a bordo é controlado através do pino WL_GPIO0 do chip Infineon 43439. No Pico, o LED foi ligado ao Pino 25 da GPIO.

Além disso, os pinos debug SWD foram movidos para o centro da placa, para criar espaço para a antena PCB. Pode encontrá-los entre o RP2040 e o CYW43439 e a ordem da esquerda para a direita ainda é SWCLK, GND, SWDIO.

Com o Pico W, pode programar em C/C++ e MicroPython.

Bluetooth Clássico e BLE

O Pico W funciona tanto com Bluetooth Classic como com Bluetooth Low Energy. O Bluetooth Classic e o Bluetooth Low Energy (BLE) são duas formas diferentes de os dispositivos comunicarem no âmbito da especificação Bluetooth.

O Bluetooth Classic, também conhecido como Bluetooth Basic Rate/Enhanced Data Rate (BR/EDR), é a versão original do Bluetooth. Foi concebida para transmissão de dados a alta velocidade, streaming de áudio e emparelhamento de dispositivos. O Bluetooth Classic é normalmente utilizado para aplicações como colunas de áudio sem fios, teclados, ratos e transferência de ficheiros entre dispositivos.

O Bluetooth Low Energy (BLE), também conhecido como Bluetooth Smart, é uma variante do Bluetooth com baixo consumo de energia. O BLE foi introduzido como parte da especificação Bluetooth 4.0 e está optimizado para dispositivos de baixo consumo de energia que requerem uma longa duração da bateria, tais como rastreadores de fitness, smartwatches, dispositivos de automação doméstica e sensores sem fios.

O Pico W pode funcionar como um dispositivo central e como um dispositivo periférico.

Começar a utilizar o Bluetooth no Pico W

Vamos começar com um projeto rápido para garantir que o Bluetooth está a funcionar corretamente.

Vamos executar um programa clássico para fazer com que o LED integrado no Pico W se ligue, mas com Bluetooth.

Para isso, vai precisar de um Pico W, um cabo micro-USB e uma placa de ensaio.

PRIMEIRO PASSO

A primeira coisa que precisa é de descarregar Thonny IDEse ainda não o tiveres.

Thonny é uma maneira super fácil de programar MicroPython no Pico W.

Também é necessário descarregar este ficheiro UF2que tem suporte para Wi-Fi e BLE. Depois de o ter descarregado, mantenha premido o botão BOOTSEL no Pico W e ligue-o ao computador através de USB. Solte o botão BOOTSEL após cerca de 3 segundos.

Aparecerá uma unidade remota chamada "RPI-RP2". Mova o ficheiro UF2 para esta unidade.

Em seguida, a unidade desaparecerá.

PASSO DOIS

Pode agora desligar e voltar a ligar o seu Pico W (desta vez, não mantenha premido o botão BOOTSEL).

Abrir o Thonny.

Depois de ter o Thonny aberto, vá a Tools > Options > Interpreter e certifique-se de que o interpretador está definido para Micropython e que a porta é o seu Pico W. Aqui está um exemplo:

O seu Pico W pode aparecer com um nome diferente.

Depois de o ter feito, clique em OK e está pronto a utilizar.

Agora, copie o seguinte código e cole-o na secção :

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

Guarde esse ficheiro no Raspberry Pi Pico W como "ble_advertising.py". Este ficheiro foi concebido para que o Pico W possa ler e ser lido por outros dispositivos.

Em seguida, abra um novo ficheiro no Thonny e cole nele o seguinte código:

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

Agora, tal como antes, guarde o ficheiro no Pico W e, desta vez, pode chamar-lhe "led_peripheral.py". Enquanto o ficheiro de publicidade permite que o Pico W comunique com outros dispositivos, o ficheiro de periféricos permite-lhe função como um dispositivo periférico. Neste caso, essa função será a de acender o LED.

Agora, prima "Executar o script atual" na barra de ferramentas do Thonny.

Como pode ver na imagem, a consola emitirá a mensagem "Starting advertising" (Iniciar publicidade). Nesta altura, pode ligar-se a um dispositivo Bluetooth, como o seu telemóvel. Localize e emparelhe com o "mpy-uart".

Depois de emparelhar os dois, o LED do Pico W acende-se e a consola Thonny começa a contar o tempo que os dois estão contados:

Parabéns! Confirmou que o Bluetooth do seu Pico W está a funcionar e pode agora começar a concentrar-se no seu próximo projeto!

Projectos Pico W Bluetooth

Ao iniciar o seu próximo projeto para o Pico W, pode recorrer a alguns dos projectos que outros já realizaram. Uma vez que o Pico W acabou de receber suporte oficial para Bluetooth, estão a começar a surgir novos projectos.

Aqui está uma lista (crescente) de alguns dos projectos que apareceram até agora:

1. Pico W Bluetooth Controlo remoto
2. Pico W Bluetooth Robô
3. Pico W Bluetooth Rato
4. Pico W Bluetooth Luzes
5. Pico W USB para Bluetooth Adaptador de áudio
6. Pico W Bluetooth PicoDRO (leitura digital)

FAQ

Posso utilizar o Bluetooth Classic com o Pico W?

Sem dúvida, o Pico W suporta Bluetooth Classic e BLE!

Posso ligar vários dispositivos ao Pico W em simultâneo?

Sim, o Pico W pode atuar como um dispositivo central e ligar-se a vários periféricos Bluetooth em simultâneo. Também pode utilizar o Bluetooth Classic e o BLE em simultâneo. Assim, é possível criar sistemas ultra-complexos em que o Pico W comunica com vários sensores ou controla vários dispositivos ao mesmo tempo.

Qual é o alcance do Bluetooth no Pico W?

Normalmente, até 30 metros (98 pés) em espaço aberto. No entanto, o alcance pode variar dependendo de factores ambientais, como obstáculos, interferências e intensidade do sinal.

Posso utilizar o Pico W como um dispositivo periférico Bluetooth?

O Pico W pode funcionar como um dispositivo central ou periférico. Assim, permite que outros dispositivos centrais Bluetooth (como smartphones, tablets ou computadores) se liguem a ele. Tudo isto funciona muito bem com PiCockpitA propósito!

Como é que programo a funcionalidade Bluetooth no Pico W?

Pode programar a funcionalidade Bluetooth no Pico W utilizando o Raspberry Pi Pico SDK versão 1.5.1. O SDK fornece bibliotecas e exemplos especificamente para o desenvolvimento do Bluetooth. Permite-lhe implementar serviços Bluetooth, características e lidar com protocolos de comunicação.

Quais são os requisitos de energia para o Bluetooth no Pico W?

O Bluetooth foi concebido para ser eficiente em termos de consumo de energia. Assim, o Pico W consome o mínimo de energia durante os períodos de inatividade e pode otimizar ainda mais o seu código utilizando técnicas como os modos de suspensão e os estados de baixo consumo. Os requisitos específicos de energia dependem, obviamente, da aplicação e do cenário de utilização.