El editor

Bluetooth, simulado

Vincula un celular con tu ESP32 o HC-05 y habla con él. El celular es el panel de Bluetooth en Mokxi, no una radio real.

Bluetooth simulado: un celular dentro de Mokxi, no una radio real. Nada en Mokxi transmite nada, y ningún celular real puede ver una placa aquí. Lo que sí es fiel es el código de Arduino que escribes: los ejemplos de Bluetooth del núcleo del ESP32 corren sin cambios, y el panel hace lo que hacen las apps de celular que usan esos tutoriales.

Dónde está el celular

Presiona Ejecutar y luego abre la pestaña Bluetooth junto a Serie (en un celular está bajo Más). El panel lista todos los dispositivos que el celular puede ver:

  • un ESP32 ejecutando BluetoothSerial (Bluetooth Classic, solo el ESP32 clásico),
  • un ESP32 anunciándose por Bluetooth LE (el ESP32, ESP32-S3, C3 y C6 con un sketch de Arduino, y el ESP32-C3 y C6 con MicroPython),
  • cada módulo HC-05 y HC-06 del circuito, en cualquier placa.

Elige uno, vincúlalo, conéctalo, y el lado derecho del panel se convierte en la app.

Bluetooth serie: el SerialBT del ESP32

El sketch del tutorial corre tal 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 en el panel. Presiona Vincular, luego Conectar, y el panel es una terminal como la app "Serial Bluetooth Terminal": escribe una línea y envíala (con CR+LF, LF, CR o nada al final), y lo que el sketch escriba en SerialBT aparece debajo.

Lo que el sketch ve es lo que vería en una placa real:

  • register_callback() recibe ESP_SPP_INIT_EVT y ESP_SPP_START_EVT de begin(), ESP_SPP_SRV_OPEN_EVT cuando el celular se conecta (con la dirección del celular), ESP_SPP_DATA_IND_EVT por cada línea que envía, y ESP_SPP_CLOSE_EVT cuando se desconecta;
  • hasClient() y connected() siguen el estado del enlace, y write() devuelve 0 si nadie está conectado;
  • available(), read(), peek(), readString() y el resto de Stream leen lo que el celular envió, y onData() lo recibe en su lugar cuando está definido.

Vincular como lo pide tu sketch

  • Just works es lo predeterminado: Vincular tiene éxito de inmediato.
  • Un PIN: tras SerialBT.disableSSP() y SerialBT.setPin("1234"), el panel pide el PIN y uno incorrecto falla, llamando a onAuthComplete(false).
  • Comparación numérica: con SerialBT.enableSSP() y onConfirmRequest(), el panel muestra un código de seis dígitos y el callback del sketch recibe el mismo número. Ambos lados deben decir que sí: el botón Vincular del panel y el confirmReply(true) del sketch. Entonces onAuthComplete(true) se ejecuta.
  • Con enableSSP(true, false) la placa escribe el código que muestra el panel (onKeyRequest(), luego respondPasskey()); con enableSSP(false, true) la placa lo muestra y tú lo escribes en el panel.

Olvidar desvincula, como lo hacen los ajustes de un celular.

Bluetooth LE: el servidor BLE del ESP32

Los ejemplos BLE_server, BLE_notify y BLE_uart del núcleo del ESP32 funcionan sin cambios. BLEDevice::startAdvertising() hace visible la placa; el panel es entonces un escáner como nRF Connect:

  • Conectar, y los servicios y características que creó el sketch se listan con sus UUID, sus nombres donde un celular los conoce (el Nordic UART Service, Battery Level y demás) y sus propiedades;
  • Leer ejecuta primero el onRead() de la característica y muestra el valor como texto y como hexadecimal;
  • Escribir envía texto o hexadecimal, y el onWrite() del sketch se ejecuta con ello;
  • Notificar se suscribe, y cada notify() a partir de entonces aparece con su valor. Antes de suscribirte, notify() no llega a nadie, como en un celular real.

onConnect() y onDisconnect() se ejecutan cuando el panel se conecta y desconecta. La placa deja de anunciar su presencia una vez conectada, así que desaparece de la lista tras una desconexión hasta que el sketch llama de nuevo a startAdvertising(). Por eso los ejemplos lo hacen en loop().

Bluetooth LE en MicroPython: el ESP32-C3 y C6

En un ESP32-C3 o un ESP32-C6 con MicroPython, el módulo bluetooth funciona como en la placa, porque corre el propio software de Bluetooth de la placa: solo se sustituye la parte del chip de radio. Un servidor GATT como este aparece en el panel:

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')
  • El panel lista la placa por el nombre de sus datos de anuncio.
  • Conectar, y tu manejador de irq recibe _IRQ_CENTRAL_CONNECT (1). El panel luego encuentra los servicios como lo haría una app de celular, así que lista los servicios Generic Access y Generic Attribute de la placa antes que los tuyos.
  • Leer muestra lo que guardó gatts_write(), Escribir dispara _IRQ_GATTS_WRITE (3), y tras Notificar, cada gatts_notify() aparece.
  • aioble también funciona: agrega la carpeta aioble de micropython-lib a tu proyecto, como la copiarías en una placa real.
  • gap_scan() termina sin encontrar nada, porque el celular no se anuncia, y la placa no puede conectarse al celular como central.

HC-05 y HC-06 en cualquier placa

Los módulos son puentes serie: lo que el celular envía sale por TXD, a la velocidad en baudios del módulo, bit por bit, y lo que la placa envía a RXD va al celular. En el panel cada uno se lista por su nombre. Vincúlalo con su PIN (1234 hasta que AT+PSWD o AT+PIN lo cambie), conéctalo y usa la misma terminal. Hacer clic en el módulo del lienzo también conecta o cuelga.

Un HC-05 empieza conectado, así que la casilla del monitor serie para él funciona de inmediato. Un HC-06 empieza con nada conectado, como uno recién sacado de la bolsa, y mientras no haya nada conectado responde comandos AT. La guía de serie inalámbrico tiene los comandos AT de ambos módulos.

Qué es real y qué no

Real, en el sentido de que se comporta como lo hará tu placa: las llamadas y sus firmas, el orden en que llegan los callbacks, la vinculación que debe tener éxito antes de conectar nada, un PIN o código que debe coincidir, los bytes en cada dirección, la tabla GATT y una notificación solo después de que el celular se suscribe.

No real, y nunca se pretendió que lo fuera:

  • sin radio. Sin 2.4 GHz, sin RFCOMM, sin canales de anuncio, sin alcance, sin claves de enlace, sin cifrado. Un PIN se compara como cadena.
  • sin retraso propio. Una línea llega completa, de una vez; un enlace real tarda decenas de milisegundos y fluctúa. Los callbacks se ejecutan cada 10 ms de tiempo simulado mientras el sketch está en delay(), que es aproximadamente donde alcanza a entrar la tarea de Bluetooth de una placa real.
  • sin otros dispositivos. El celular es el único. Una placa que escanea (BLEScan) o que se conecta como cliente no encuentra nada, y SerialBT.connect() no encuentra a nadie a quien conectarse.
  • sin intercambio de MTU para un sketch de Arduino: un valor de hasta 512 bytes llega completo. Con MicroPython el celular intercambia el MTU con el propio software de Bluetooth de la placa, como lo hace un celular real.
  • sin vinculación por LE con MicroPython: el celular dice que la vinculación no es compatible.
  • NimBLE-Arduino y el Bluetooth del Pico W no están simulados.