A família Pi Pico da Raspberry possui uma linha voltada à conectividade que é a linha "W", tanto na primeira versão que temos a Pi Pico W como na versão 2 onde temos a Pi Pico 2W. Elas possuem tanto conexão WiFi como Bluetooth Low Energy (BLE). Neste artigo temos um passo a passo de como fazer a conexão via Bluetooth entre uma placa Pi Pico 2W e um aparelho de celular.
O LightBlue
Para que possamos localizar e fazer a comunicação com a placa Pi Pico 2W , precisamos instalar o LightBlue no telefone celular. Esta aplicativo irá localizar, capturar todas as informações da placa e abrir um canal de comunicação com a mesa.
O app LightBlue é uma ferramenta muito utilizada pelos desenvolvedores que utilizam o Bluetooth em suas aplicações. Este aplicativo foi desenvolvido pela Punchthrough com o intuito de sempre melhorar as ferramentas como a segurança da comunicação Bluetooth. [1]
Para instalar: https://punchthrough.com/lightblue/
Enviando texto para o Celular
Agora utilizaremos a própria placa Pi Pico 2W para enviar um texto que digitamos no "Shell" do Thonny para ser recebido e mostrado no aplicativo LightBlue no aparelho celular. Para isso precisaremos de 2 código instalado na Pi Pico 2W: O arquivo "ble.py" e o arquivo "ble_advertising" [2] , onde o código é apresentado abaixo:
Código ble.py
import bluetooth
import struct
import time
import machine
import ubinascii
from ble_advertising import advertising_payload
from micropython import const
from machine import Pin
_IRQ_CENTRAL_CONNECT = const(1)
_IRQ_CENTRAL_DISCONNECT = const(2)
_IRQ_GATTS_INDICATE_DONE = const(20)
_FLAG_READ = const(0x0002)
_FLAG_NOTIFY = const(0x0010)
# UUIDs de serviço e características personalizados
# Modifique-os conforme necessário.
_SERVICE_UUID = bluetooth.UUID("3ec837af-b0c6-4e7e-a8c5-4b31311d98cf")
_CHAR_UUID = (
bluetooth.UUID("945c4d90-825d-452f-820a-0d8b0cc74a12"),
_FLAG_READ | _FLAG_NOTIFY,
)
_SERVICE = (
_SERVICE_UUID,
(_CHAR_UUID,),
)
led = Pin("LED", Pin.OUT)
class BLEText:
def __init__(self, ble, name=""):
# Inicialize a interface BLE e registre o serviço personalizado
self._ble = ble
self._ble.active(True)
self._ble.irq(self._irq)
((self._handle,),) = self._ble.gatts_register_services((_SERVICE,))
self._connections = set()
# Se nenhum nome for fornecido, gere um com base no endereço MAC.
if len(name) == 0:
name = 'Pico %s' % ubinascii.hexlify(self._ble.config('mac')[1], ':').decode().upper()
print('Nome do dispositivo: %s' % name)
# Cria um payload do anúncio com o serviço personalizado
self._payload = advertising_payload(
name=name, services=[_SERVICE_UUID]
)
self._advertise()
def _irq(self, event, data):
# Handle Eventos BLE
if event == _IRQ_CENTRAL_CONNECT:
# A central has connected
conn_handle, _, _ = data
self._connections.add(conn_handle)
print("New connection", conn_handle)
led.value(1)
elif event == _IRQ_CENTRAL_DISCONNECT:
# A central desconectou
conn_handle, _, _ = data
self._connections.remove(conn_handle)
print("Desconectou", conn_handle)
led.value(0)
# Começando o anúncio novamente para permitir nova conexão
self._advertise()
elif event == _IRQ_GATTS_INDICATE_DONE:
# Confirmação de indicação recebida (não utilizada aqui)
conn_handle, value_handle, status = data
def send_text(self, text):
# Escreva o texto fornecido com o valor característico.
self._ble.gatts_write(self._handle, text.encode('utf-8'))
# Notifique todos os nós centrais conectados sobre o novo valor
for conn_handle in self._connections:
self._ble.gatts_notify(conn_handle, self._handle)
def _advertise(self, interval_us=500000):
print("Começando advertising")
# Inicie a transmissão de dados BLE no intervalo especificado
self._ble.gap_advertise(interval_us, adv_data=self._payload)
def is_connected(self):
return len(self._connections) > 0
def demo():
# Crie uma instância BLE e um periférico BLEText.
ble = bluetooth.BLE()
ble_text = BLEText(ble,"Mooca")
# Continuously read input from the terminal and send it via BLE
while True:
if ble_text.is_connected():
line = input("Digite o texto e tecle Enter para enviar o texto via BLE (Ctrl+C encerra): ")
ble_text.send_text(line)
if __name__ == "__main__":
demo()
Código ble_advertising.py
# Helpers for generating BLE advertising payloads.
# A more fully-featured (and easier to use) version of this is implemented in
# aioble. This code is provided just as a basic example. See
# https://github.com/micropython/micropython-lib/tree/master/micropython/bluetooth/aioble
from micropython import const
import struct
import bluetooth
# Advertising payloads are repeated packets of the following form:
# 1 byte data length (N + 1)
# 1 byte type (see constants below)
# N bytes type-specific data
_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)
_ADV_MAX_PAYLOAD = const(31)
# Generate a payload to be passed to gap_advertise(adv_data=...).
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)
# See org.bluetooth.characteristic.gap.appearance.xml
if appearance:
_append(_ADV_TYPE_APPEARANCE, struct.pack("<h", appearance))
if len(payload) > _ADV_MAX_PAYLOAD:
raise ValueError("Aviso payload muito grande")
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 code in (_ADV_TYPE_UUID16_COMPLETE, _ADV_TYPE_UUID32_COMPLETE, _ADV_TYPE_UUID128_COMPLETE):
for u in decode_field(payload, code):
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()
Ao executar o arquivo "ble.py", uma mensagem irá aparecer no Shell do Thonny, onde aparecerá o Nome do dispositivo e o aviso que o "anúncio" do dispositivo está sendo enviado e que está pronto para a conexão. Uma vez conectado, aparecerá no Shell o aviso de uma nova conexão e uma frase pedindo para que você entre com um texto para ser enviado para o aparelho celular (figura 1).
Depois que a placa estabelece a comunicação com o aparelho celular, precisamos configurar como iremos ler os dados enviados pela placa. Para isto é só seguir o passo a passo da figura 2, onde alteramos as configurações de recebimento de dados no padrão hexadecimal para o padrão “ascii” UTF-8. O número que o dispositivo está mostrando na tela, que é o canal de comunicação estabelecido, você encontrará no código fonte.
Para enviar os dados, faça como na figura 3, onde digitamos uma frase que será enviada pela Pi Pico 2W para o aparelho celular, mas ele será exibido na tela se pressionarmos o botão "Read".
Enviando dados para a Pi Pico 2W
É possível enviar dados para a Pi Pico 2W, para que possamos também enviar comandos de ações a serem executadas pela mesma. Neste exemplo iremos acionar 3 LEDs de cores diferentes via aparelho celular como demostração de envios de comando. Continuaremos a utilizar o padrão UTF-8, mas dependendo da aplicação, outro formato poderá ser adotado. Para este exemplo montamos um circuito simples usando as GPIOs 11,12 e 13, conforme mostra a figura 4.
Vamos utilizar neste exemplo dois códigos, sendo que o código "ble_simple_peripheral.py" tem a função "BLESimplePeripheral" que é responsável pela coleta dos dados. No código "ble_trafficlight.py" temo o código principal que deve ser rodado. Caso queira executar esta aplicações sem estar conectado ao computador, lembre-se de renomear este código para "main.py" ou chamá-lo no próprio "main.py".
Código ble_simple_peripheral.py
# This example demonstrates a UART periperhal.
# This example demonstrates the low-level bluetooth module. For most
# applications, we recommend using the higher-level aioble library which takes
# care of all IRQ handling and connection management. See
# https://github.com/micropython/micropython-lib/tree/master/micropython/bluetooth/aioble
import bluetooth
import random
import struct
import time
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):
# Track connections so we can send notifications.
if event == _IRQ_CENTRAL_CONNECT:
conn_handle, _, _ = data
print("Nova Conexão", conn_handle)
self._connections.add(conn_handle)
elif event == _IRQ_CENTRAL_DISCONNECT:
conn_handle, _, _ = data
print("Desconectado", conn_handle)
self._connections.remove(conn_handle)
# Start advertising again to allow a new connection.
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("Começando advertising")
self._ble.gap_advertise(interval_us, adv_data=self._payload)
def on_write(self, callback):
self._write_callback = callback
def demo():
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():
# Short burst of queued notifications.
for _ in range(3):
data = str(i) + "_"
print("TX", data)
p.send(data)
i += 1
time.sleep_ms(100)
if __name__ == "__main__":
demo()
Cógido ble_trafficlight.py
# Importando os módulos necessários
from machine import Pin
import bluetooth
from ble_simple_peripheral import BLESimplePeripheral
# Criando um objeto Bluetooth Low Energy (BLE)
ble = bluetooth.BLE()
# Criando uma instancia com a classe BLESimplePeripheral
sp = BLESimplePeripheral(ble,"Mooca")
led = Pin("LED", Pin.OUT)
red = machine.Pin(13, machine.Pin.OUT)
yellow = machine.Pin(12, machine.Pin.OUT)
green = machine.Pin(11, machine.Pin.OUT)
def update_traffic(data):
decoded_data = data.decode('utf-8').rstrip('\r\n')
red.off()
green.off()
yellow.off()
if decoded_data == "R" or decoded_data == "r":
red.on()
elif decoded_data == "G" or decoded_data == "g":
green.on()
elif decoded_data == "Y" or decoded_data == "y":
yellow.on()
# Define a callback function to handle received data
def on_rx(data):
print("Dado recebido: ", data) # Exibe o dado recebido
update_traffic(data)
# Start an infinite loop
while True:
if sp.is_connected(): # Analisa se a comunicação BLE foi estabelecida
sp.on_write(on_rx) # Seta a função callback para a recepção do dado
Para testar o código você precisará conectar o LightBlue com a Pi Pico 2W, usando o nome que você deu ao dispositivo, e seguir os passos de configuração para estabelecer o formato de envio e recebimento dos dados, em nosso caso o UTF-8. Uma coisa importante agora a notar é que diferente da aplicação anterior, temos agora dois canais de comunicações , e na figura 5 podemos ver que aparecem duas linhas com os números de envio e recebimento que aparecem no código acima.
Com o programa em execução, clique no botão "Write" e envie as letras "R", "G" e "Y" para acender os LEDs conectadas na Pi Pico 2W, envie outras letras e note que o LED que está acesso se apagará e nenhuma outra acende.
Conclusão
Este artigo é uma pincelada no que podemos fazer com a conexão da Pi Pico 2W ou Pi Pico W via Bluetooth, existe uma quantidade de configurações a serem feitas para cada tipo de aplicação. Criar aplicativos próprios também é interessante para facilitar a usabilidade de um sistema como este, mas espero ter ajudado a entender como fazemos a primeira conexão via Bluetooth de uma Raspberry Pi Pico 2W.
Referências
[1] - Punchthrough - https://punchthrough.com/
[2] – Biblioteca Micropython BLE - https://github.com/micropython/micropython-lib/tree/master/micropython/bluetooth/aioble
