O editor

Bluetooth simulado

Pareie um telefone com seu ESP32 ou HC-05 e converse com ele. O telefone é o painel Bluetooth do Mokxi, não um rádio de verdade.

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() recebe ESP_SPP_INIT_EVT e ESP_SPP_START_EVT de begin(), ESP_SPP_SRV_OPEN_EVT quando o celular conecta (com o endereço dele), ESP_SPP_DATA_IND_EVT para cada linha enviada e ESP_SPP_CLOSE_EVT quando desconecta;
  • hasClient() e connected() acompanham o link, e write() retorna 0 sem ninguém conectado;
  • available(), read(), peek(), readString() e o resto de Stream leem o que o celular enviou, e onData() 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() e SerialBT.setPin("1234"), o painel pede o PIN e um errado falha, chamando onAuthComplete(false).
  • Comparação numérica: com SerialBT.enableSSP() e onConfirmRequest(), 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 o confirmReply(true) do sketch. Aí onAuthComplete(true) roda.
  • Com enableSSP(true, false) a placa digita o código que o painel mostra (onKeyRequest() e depois respondPasskey()); com enableSSP(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 irq recebe _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, cada gatts_notify() aparece.
  • aioble também funciona: adicione a pasta aioble da 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, e SerialBT.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.