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()recibeESP_SPP_INIT_EVTyESP_SPP_START_EVTdebegin(),ESP_SPP_SRV_OPEN_EVTcuando el celular se conecta (con la dirección del celular),ESP_SPP_DATA_IND_EVTpor cada línea que envía, yESP_SPP_CLOSE_EVTcuando se desconecta;hasClient()yconnected()siguen el estado del enlace, ywrite()devuelve 0 si nadie está conectado;available(),read(),peek(),readString()y el resto deStreamleen lo que el celular envió, yonData()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()ySerialBT.setPin("1234"), el panel pide el PIN y uno incorrecto falla, llamando aonAuthComplete(false). - Comparación numérica: con
SerialBT.enableSSP()yonConfirmRequest(), 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 elconfirmReply(true)del sketch. EntoncesonAuthComplete(true)se ejecuta. - Con
enableSSP(true, false)la placa escribe el código que muestra el panel (onKeyRequest(), luegorespondPasskey()); conenableSSP(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
irqrecibe_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, cadagatts_notify()aparece. aiobletambién funciona: agrega la carpetaaioblede 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, ySerialBT.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.