Bluetooth simulado: um celular dentro do Mokxi, não um rádio de verdade. Nada no Mokxi transmite nada, e nenhum celular real consegue ver uma placa aqui. O que é fiel é o código do Arduino que você escreve: os exemplos de Bluetooth do próprio core do ESP32 rodam sem mudanças, e o painel faz o que os aplicativos de celular usados nesses tutoriais fazem.
Onde está o celular
Aperte Rodar e abra a aba Bluetooth ao lado de Serial (no celular fica em Mais). O painel lista todos os dispositivos que o celular consegue ver:
- uma ESP32 rodando
BluetoothSerial(Bluetooth Classic, só na ESP32 clássica), - uma ESP32 fazendo anúncio por Bluetooth LE (a ESP32, ESP32-S3, C3 e C6 com um sketch do Arduino, e a ESP32-C3 e C6 com MicroPython),
- todo módulo HC-05 e HC-06 do circuito, em qualquer placa.
Escolha um, faça o pareamento, conecte, e o lado direito do painel vira o aplicativo.
Bluetooth serial: o SerialBT da ESP32
O sketch do tutorial roda como está escrito:
#include "BluetoothSerial.h"
BluetoothSerial SerialBT;
void setup() { Serial.begin(115200); SerialBT.begin("ESP32test"); }
void loop() {
if (Serial.available()) SerialBT.write(Serial.read());
if (SerialBT.available()) Serial.write(SerialBT.read());
}
ESP32test aparece no painel. Aperte Parear e depois Conectar, e o painel é um terminal como o app "Serial Bluetooth Terminal": digite uma linha e envie (com CR+LF, LF, CR ou nada no final), e o que o sketch escrever em SerialBT aparece embaixo.
O que o sketch vê é o que ele veria em uma placa de verdade:
register_callback()recebeESP_SPP_INIT_EVTeESP_SPP_START_EVTdebegin(),ESP_SPP_SRV_OPEN_EVTquando o celular conecta (com o endereço dele),ESP_SPP_DATA_IND_EVTpara cada linha enviada eESP_SPP_CLOSE_EVTquando desconecta;hasClient()econnected()acompanham o link, ewrite()retorna 0 sem ninguém conectado;available(),read(),peek(),readString()e o resto deStreamleem o que o celular enviou, eonData()recebe no lugar quando está definido.
Pareando do jeito que seu sketch pede
- Just works é o padrão: Parear funciona na hora.
- Um PIN: depois de
SerialBT.disableSSP()eSerialBT.setPin("1234"), o painel pede o PIN e um errado falha, chamandoonAuthComplete(false). - Comparação numérica: com
SerialBT.enableSSP()eonConfirmRequest(), o painel mostra um código de seis dígitos e o callback do sketch recebe o mesmo número. Os dois lados precisam dizer sim: o botão Parear do painel e oconfirmReply(true)do sketch. AíonAuthComplete(true)roda. - Com
enableSSP(true, false)a placa digita o código que o painel mostra (onKeyRequest()e depoisrespondPasskey()); comenableSSP(false, true)a placa mostra o código e você digita no painel.
Esquecer desfaz o pareamento, como as configurações de um celular fazem.
Bluetooth LE: o servidor BLE da ESP32
Os exemplos BLE_server, BLE_notify e BLE_uart do core da ESP32 rodam sem mudanças. BLEDevice::startAdvertising() torna a placa visível; o painel então é um scanner como o nRF Connect:
- Conectar, e os serviços e características criados pelo sketch são listados com seus UUIDs, seus nomes onde um celular os conhece (o Nordic UART Service, Battery Level e assim por diante) e suas propriedades;
- Ler executa primeiro o
onRead()da característica e mostra o valor como texto e como hexadecimal; - Escrever envia texto ou hexadecimal, e o
onWrite()do sketch roda com ele; - Notificar faz a inscrição, e cada
notify()a partir daí aparece com seu valor. Antes de você se inscrever,notify()não chega a ninguém, como em um celular de verdade.
onConnect() e onDisconnect() rodam quando o painel conecta e desconecta. A placa para de anunciar assim que conecta, então ela some da lista após uma desconexão até o sketch chamar startAdvertising() de novo. É por isso que os exemplos fazem isso no loop().
Bluetooth LE no MicroPython: ESP32-C3 e C6
Em uma ESP32-C3 ou ESP32-C6 rodando MicroPython, o módulo bluetooth funciona como na placa, porque o próprio software de Bluetooth da placa roda: só a parte do chip de rádio é simulada. Um servidor GATT como este aparece no painel:
import bluetooth
b = bluetooth.BLE()
b.active(True)
F = bluetooth.FLAG_READ | bluetooth.FLAG_WRITE | bluetooth.FLAG_NOTIFY
((h,),) = b.gatts_register_services(((bluetooth.UUID(0x180F), ((bluetooth.UUID(0x2A19), F),)),))
b.gatts_write(h, b'42')
b.gap_advertise(100000, bytes([2, 1, 6, 8, 9]) + b'mpy-ble')
- O painel lista a placa pelo nome nos dados de anúncio dela.
- Conectar, e seu handler de
irqrecebe_IRQ_CENTRAL_CONNECT(1). O painel então encontra os serviços do jeito que um aplicativo de celular faria, então lista os serviços Generic Access e Generic Attribute da placa antes dos seus. - Ler mostra o que
gatts_write()guardou, Escrever dispara_IRQ_GATTS_WRITE(3), e depois de Notificar, cadagatts_notify()aparece. aiobletambém funciona: adicione a pastaaiobleda micropython-lib ao seu projeto, como você copiaria para uma placa de verdade.gap_scan()termina sem encontrar nada, porque o celular não anuncia, e a placa não consegue conectar ao celular como central.
HC-05 e HC-06 em qualquer placa
Os módulos são pontes seriais: o que o celular envia sai por TXD, na taxa de baud do módulo, bit por bit, e o que a placa envia em RXD vai para o celular. No painel cada um é listado pelo seu nome. Pareie com o PIN dele (1234 até um AT+PSWD ou AT+PIN mudar), conecte e use o mesmo terminal. Clicar no módulo no canvas também conecta ou encerra a ligação.
Um HC-05 começa conectado, então a caixa dele no monitor serial funciona na hora. Um HC-06 começa sem nada conectado, como um recém-saído do saquinho, e enquanto nada está conectado ele responde a comandos AT. O guia de serial sem fio tem os comandos AT dos dois módulos.
O que é real e o que não é
Real, no sentido de que se comporta como sua placa vai se comportar: as chamadas e suas assinaturas, a ordem em que os callbacks chegam, um pareamento que precisa dar certo antes de qualquer coisa conectar, um PIN ou código que precisa corresponder, os bytes em cada direção, a tabela GATT, e uma notificação só depois que o celular se inscreve.
Não real, e nunca fez de conta que era:
- nenhum rádio. Sem 2,4 GHz, sem RFCOMM, sem canais de anúncio, sem alcance, sem chaves de link, sem criptografia. Um PIN é comparado como string.
- nenhum atraso próprio. Uma linha chega inteira, de uma vez; um link real leva dezenas de milissegundos e varia. Os callbacks rodam a cada 10 ms de tempo simulado enquanto o sketch está em
delay(), que é mais ou menos onde a tarefa de Bluetooth de uma placa real entra. - nenhum outro dispositivo. O celular é o único. Uma placa que escaneia (
BLEScan) ou conecta como cliente não encontra nada, eSerialBT.connect()não encontra com o que conectar. - nenhuma troca de MTU em um sketch do Arduino: um valor de até 512 bytes chega inteiro. Com MicroPython o celular troca o MTU com o próprio software de Bluetooth da placa, como um celular real faz.
- nenhum pareamento por LE com MicroPython: o celular diz que o pareamento não é suportado.
- NimBLE-Arduino e o Bluetooth do Pico W não são simulados.