El hardware sobre la mesa
La tarjeta es una ESP32-S31 Function-CoreBoard-1 de Espressif. Una tarjeta de desarrollo es una pequeña tarjeta que vende el fabricante de un microcontrolador: lleva el chip, su alimentación, sus puertos USB y un conector que da acceso a sus pines, para escribir y probar un programa antes de que exista la tarjeta definitiva. Esta lleva un módulo ESP32-S31-WROOM-3: dos núcleos RISC-V a 320 MHz, 16 MB de memoria flash, 16 MB de memoria RAM externa, Wi-Fi 6, Bluetooth 5.4 e incluso un puerto Ethernet. Sus pines salen a un conector de 40 pines, identificado como J2 en la tarjeta.

Tiene dos puertos USB-C. El marcado USB-DBG es el USB nativo del chip: sirve para cargar el programa y leer la consola sin presionar ningún botón. Ese es el que conectamos. La tarjeta también tiene dos botones: RST, que reinicia el chip, y BOOT, conectado al pin IO61, que usaremos más adelante.
El ESP32-S31 es un chip reciente. ESP-IDF, el entorno de desarrollo oficial de Espressif (las bibliotecas, el compilador y las herramientas), todavía lo clasifica en su versión 6.1 entre los chips «en vista previa»: cada comando debe reconocerlo mediante la opción --preview; de lo contrario, se niega a compilar para él.
Para ver qué está haciendo la tarjeta sin mantener un computador conectado, agregamos una pantalla ST7789 de 1,9 pulgadas, de 170 × 320 píxeles, controlada por un bus SPI (una conexión serial con reloj, en la que la tarjeta envía órdenes y píxeles por dos líneas). El robot tendrá la misma.
Falta el control. Es un BSP-G6, vendido para jugar en el celular. Se perdió su manual; por eso, todo lo que sigue se aprendió interrogándolo.


En la parte posterior del control, debajo de la etiqueta, un selector de cinco posiciones elige el modo: V3, M, X, S y 2.4G. A cada lado, dos palancas traseras marcadas M1 y M2 quedan al alcance de los dedos. Al final de la tercera prueba sabremos para qué sirven.

El programa está escrito en C++ con ESP-IDF 6.1. El Bluetooth lo maneja Bluedroid, la pila Bluetooth que proporciona ESP-IDF (la pila es el conjunto de capas de software entre la radio y el programa).
Prueba 01: una pantalla para ver qué está haciendo la tarjeta
Antes de escuchar al control, necesitábamos algo que mostrara lo recibido. Ocho cables hembra-hembra conectan la pantalla al conector J2, con la tarjeta desconectada del USB mientras se hace el cableado:
| Pantalla | Pin de J2 (serigrafía) | Pin del chip | Función |
|---|---|---|---|
| GND | 34 (G) | — | tierra |
| VCC | 36 (3V3) | — | alimentación de 3,3 V |
| SCL | 20 (42) | IO42 | reloj del bus SPI |
| SDA | 17 (43) | IO43 | datos del bus SPI |
| RES | 14 (48) | IO48 | reinicio de la pantalla |
| DC | 16 (46) | IO46 | comando o dato |
| CS | 11 (49) | IO49 | selección de la pantalla |
| BLK | 23 (37) | IO37 | retroiluminación |
Hay dos trampas en esta tabla. VCC va a 3,3 V, no a 5 V: las señales del ESP32 son de 3,3 V, y una pantalla alimentada al mismo nivel nunca recibe en una entrada una tensión superior a su propia alimentación. Y SCL y SDA no forman un bus I²C, a pesar de los nombres que les dan los vendedores de módulos: son el reloj y los datos del bus SPI. Guíese por la serigrafía impresa junto a cada pin de J2 en lugar de contarlos: lo que cuenta es lo impreso en la tarjeta que tiene en la mano.
En el programa, este cableado se resume en unas pocas constantes:
constexpr gpio_num_t BROCHE_SCLK = GPIO_NUM_42; // horloge SPI J2 broche 20
constexpr gpio_num_t BROCHE_MOSI = GPIO_NUM_43; // données SPI J2 broche 17
constexpr ecran::Broches BROCHES_ECRAN = {
.cs = GPIO_NUM_49, // sélection J2 broche 11
.dc = GPIO_NUM_46, // cmd. / donnée J2 broche 16
.rst = GPIO_NUM_48, // remise à zéro J2 broche 14
.blk = GPIO_NUM_37, // rétroéclairage J2 broche 23
};
constexpr spi_host_device_t BUS_SPI = SPI3_HOST;
constexpr unsigned FREQUENCE_SPI_HZ = 20 * 1000 * 1000;
El chip ST7789 puede manejar paneles de distintos tamaños, cada uno con sus propios ajustes. Para encontrarlos, el primer programa dibujaba un patrón de prueba: un marco blanco de un píxel en los cuatro bordes, un cuadrado amarillo en una esquina y cuatro franjas roja, verde, azul y blanca. Cada defecto posible deja una huella distinta: un marco recortado a la izquierda indica un desplazamiento horizontal, los colores en negativo indican que hay que activar la inversión, y el rojo y el azul intercambiados indican el orden de los colores. El patrón salió bien al primer intento con estos ajustes:
// La dalle de 1,9 pouce, 170 × 320 : la puce a 240 colonnes de mémoire, la dalle
// n'en montre que les 170 du milieu, d'où le décalage de (240 − 170) / 2 = 35.
constexpr Dalle DALLE_1_9_POUCE = {170, 320, 35, 0, true, LCD_RGB_ELEMENT_ORDER_RGB};
El true solicita la inversión de colores: los paneles IPS, como este, muestran la imagen en negativo sin ella.
Sin embargo, más adelante apareció un defecto que vale la pena contar. El patrón, que estaba bien, se convirtió de repente en su negativo exacto después de mover la tarjeta: fondo blanco, el rojo convertido en cian y el verde en magenta. No había nada dañado. Al arrancar, el programa envía a la pantalla una secuencia de órdenes, entre ellas CASET (código 0x2A, en binario 00101010), que selecciona las columnas en las que se va a escribir. La explicación más probable es que un cable hizo falso contacto en el momento equivocado y dos de esos bits se leyeron como cero. Queda 00100000, es decir, 0x20, que es la orden INVOFF: «deje de invertir los colores». Un falso contacto no necesariamente corrompe una orden: puede crear otra perfectamente válida. La solución: ajustar bien los cables y presionar RST. El programa vuelve a enviar toda la configuración cada vez que arranca.
La pantalla funciona a 20 MHz con cables sueltos de unos diez centímetros, sin errores de transferencia. Podemos pasar al control.
El programa completo de esta prueba, con su patrón de prueba y sus cuatro ajustes, se descarga al final del artículo, en los programas completos.
Prueba 02: el control se cree una pantalla táctil
ESP-IDF proporciona un ejemplo listo para leer un dispositivo Bluetooth de entrada: esp_hid_host, en la carpeta examples/bluetooth. Busca durante unos segundos los dispositivos HID cercanos (Human Interface Device, la familia normalizada de teclados, ratones y controles), se conecta y escribe en la consola cada reporte recibido, es decir, el pequeño paquete de bytes que envía el dispositivo cuando cambia un botón.
El ejemplo no encontró el control tal como venía. Fueron necesarias tres correcciones:
- Detectaba el control y luego lo descartaba. El ejemplo solo acepta un dispositivo si el servicio HID aparece en la lista completa de servicios que anuncia. El BSP-G6 lo incluye en la lista incompleta, que el ejemplo no leía.
- Nunca intentaba conectarse. Cuando está activo el Bluetooth clásico, el ejemplo solo se conecta a un dispositivo llamado «HID Mouse Example», su propio ratón de demostración. Ahora se conecta al último dispositivo HID encontrado.
- La búsqueda a veces terminaba sin decir nada. Sus dos esperas ahora tienen un límite de tiempo y anuncian su final en la consola.
Con el selector en V3 y HOME presionado durante tres segundos (la luz roja parpadea rápido: es el modo de emparejamiento), el control se conectó. La consola mostró su identidad: nombre «BSP-G6», fabricante «ShanWan BM-835», identificadores de fabricante y producto 1949:0402.
Después llegaron los reportes, y eran extraños. Un único reporte de 17 bytes: cuatro grupos de cuatro bytes y uno final que cuenta los dedos. El control se describía como una pantalla táctil de cuatro dedos. En cada grupo, el primer byte contiene el número del dedo y su estado, y los tres siguientes, su posición. El grupo 13 3d 44 ad, por ejemplo, se lee así:
13: dedo n.º 1 (el dígito hexadecimal de la izquierda), apoyado (el3de la derecha; un2indicaría levantado);3d 44 ad: dos números de 12 bits entrelazados, X =0x43D= 1085 y Y =0xAD4= 2772.
Es el «modo de mapeo» de los controles para celulares, pensado para juegos que solo entienden la pantalla táctil: una palanca desliza un dedo virtual y un botón apoya otro en un punto fijo de la pantalla. Esos puntos se configuran en la aplicación del fabricante. Para un robot, es inutilizable: la posición de un «botón» dependería de un ajuste hecho en un celular.
El programa de esta prueba, el ejemplo de ESP-IDF con sus tres correcciones, se descarga al final del artículo, en los programas completos.
Cinco posiciones, tres identidades
El selector de cinco posiciones cambia, por tanto, la naturaleza misma del control. Se examinaron tres posiciones con la tarjeta, un celular y un PC con Windows:
| Posición | Radio | Se presenta como | Dirección de radio |
|---|---|---|---|
| V3 | Bluetooth de bajo consumo (BLE) | una pantalla táctil de cuatro dedos, «BSP-G6» | 01:26:05:15:BE:A2 |
| X | Bluetooth clásico | un control Xbox One S, «Xbox Wireless Controller» | 83:26:05:15:BE:A2 |
| 2.4G | Bluetooth de bajo consumo (BLE) | un control de videojuegos, «BM769 24G»: seis ejes, dieciséis botones y una cruceta | 04:26:05:15:BE:A2 |
Las tres direcciones solo difieren en su primer byte: una sola radio, tres identidades. En X, el control imita un control Xbox mediante Bluetooth clásico, un formato conocido; pero en Windows solo funcionaba con el cable conectado. La posición 2.4G tenía una sorpresa: uno esperaría una conexión propietaria a 2,4 GHz con un receptor USB incluido; en realidad es BLE (Bluetooth de bajo consumo, que también transmite a 2,4 GHz). Y su descripción es la de un verdadero control de videojuegos. Windows lo registró como un «control de juego HID»… y no se movió nada en su panel de prueba, sin importar qué botones se presionaran.
Seguía siendo la posición más prometedora. Había que ver qué enviaba realmente, sin suponer nada sobre su formato.
Prueba 03: mostrarlo todo, bit por bit
El tercer programa no decodifica nada. Muestra cada byte recibido en una fila de la pantalla, con sus ocho bits en ocho casillas: un bit en 1 aparece en azul claro y uno en 0, en azul grisáceo oscuro. Un bit que acaba de cambiar conserva otro color durante medio segundo: amarillo pálido si pasa a 1 y caqui si vuelve a 0. Así, un botón se identifica por la casilla que se enciende en amarillo pálido al presionarlo; una palanca hace parpadear varias casillas de uno o dos bytes a la vez. En el video, el amarillo pálido se ve hacia el cuarto segundo; el caqui apenas dura un instante, hacia el noveno.
Antes de llegar ahí, tres líneas de la consola detuvieron el control, cada una a su turno.
La conexión se caía de inmediato, con el código 0x3d: «fallo en la comprobación del cifrado». La tarjeta había iniciado el cifrado de la conexión con una clave guardada de un emparejamiento anterior que el control ya no reconocía; en la prueba 04 veremos por qué. Ahora el programa borra todas las claves al arrancar.
Los siguientes intentos eran rechazados por la radio, con Cmd Disallowed. En cuanto se utiliza una función de BLE 5.0, la pila pasa a las conexiones «extendidas» de BLE 5.0, que la radio rechaza después de una búsqueda hecha al estilo de BLE 4.2. Un control no necesita BLE 5.0: se desactiva en la configuración del proyecto.
Luego la consola empezó a llenarse, doscientas veces por segundo: drop notif, handle 0x002e not registered. La pila recibía paquetes del control y los descartaba porque nadie se había suscrito a su origen.
Para entender este mensaje, hay que saber cómo organiza sus datos un dispositivo BLE. Los presenta en un catálogo, el GATT (el catálogo de datos de un dispositivo BLE), compuesto por servicios (familias de datos), a su vez compuestos por características (un dato que se puede leer, escribir o recibir automáticamente). Cada elemento del catálogo tiene un número de dirección, su handle. Una característica puede enviar su valor por iniciativa propia cada vez que cambia: eso es una notificación, y hay que suscribirse para recibirla. Este es el catálogo del control en la posición 2.4G, tal como lo leyó la tarjeta:
| Handles | Servicio | Qué contiene |
|---|---|---|
0x01 a 0x07 | 0x1800, acceso genérico | el nombre «BSP-G6-HID», la apariencia |
0x08 a 0x0B | 0x1801, atributos genéricos | — |
0x0C a 0x12 | 0x180A, información | fabricante «ShanWan BM-835» |
0x13 a 0x23 | 0x1812, HID | la descripción de un control de 10 bytes. No pasa ningún paquete por ahí |
0x24 a 0x29 | 0xFFFF, del fabricante | silencioso |
0x2A a 0x2F | 91680001-…, del fabricante | la característica 91680003, handle 0x2E: todo pasa por ella |
0x30 a 0x35 | 95990001-…, del fabricante | silencioso |
Ahí está la explicación de lo ocurrido en Windows. El servicio HID, el único que escuchan Windows y el lector HID de ESP-IDF, sí describe un control, pero no transmite nada. Los botones pasan por un servicio del fabricante, identificado por un UUID (un identificador de 128 bits) que nada relaciona con un control: 91680001-1111-6666-8888-0123456789AB. Bastaba con suscribirse al handle correcto (el número de dirección de un dato dentro del control) para que la cuadrícula cobrara vida.
Suscribirse: lo que la tarjeta no había hecho
«Nadie se había suscrito a su origen»: la frase es corta, pero esconde el mecanismo más útil de todo BLE. Merece que nos detengamos.
Dos formas de obtener un dato. Un central (el dispositivo que elige a quién conectarse, aquí la tarjeta) puede obtener el valor de una característica de dos maneras. Puede leerlo: envía una solicitud por radio y el periférico responde. Es una llamada para preguntar el marcador de un partido. O puede suscribirse: el periférico le envía el valor por iniciativa propia cada vez que cambia, mediante una notificación. Es el mensaje que llega con cada gol, sin haberlo pedido. En un control, la diferencia es grande. Leer sus botones cien veces por segundo implicaría cien solicitudes y cien respuestas, y una pulsación llegaría, en promedio, con medio período de retraso. Con una suscripción, el control solo habla cuando cambia un botón y el paquete sale en el siguiente encuentro de radio.
Una suscripción requiere dos registros. La palabra «suscripción» está bien escogida: como con un periódico, el editor debe saber que tiene que enviarlo y, en la casa, alguien debe recoger el correo. De la misma manera, una notificación BLE pasa por dos registros, uno en cada dispositivo.
El registro de la tarjeta (① en la figura). Varios programas de la tarjeta pueden compartir una conexión de radio: en la prueba 03, el lector HID de ESP-IDF y el nuestro escuchaban al mismo control. Por eso, todas las notificaciones de la conexión llegan primero a la pila Bluetooth de la tarjeta, que debe decidir a qué programa entregar cada una. Para ello mantiene un registro: tal handle, tal programa. Un programa se inscribe mediante la función esp_ble_gattc_register_for_notify, indicando el handle que espera. Si el handle de una notificación no aparece en ninguna entrada, nadie la está esperando: la pila la descarta y lo escribe en la consola. Es exactamente el mensaje de la prueba 03. El lector HID se había inscrito para los handles de su servicio, 0x1B y 0x17; nadie lo había hecho para 0x2E, y doscientos paquetes por segundo terminaban en la basura.
El registro del control (② en la figura). Cada característica capaz de notificar lleva un pequeño dato de dos bytes: su descriptor de suscripción (en inglés, Client Characteristic Configuration Descriptor, con UUID 0x2902). El central escribe ahí lo que desea recibir:
| Valor escrito | Qué hace el periférico |
|---|---|
00 00 | permanece en silencio: es el valor inicial |
01 00 | notifica: envía el valor cada vez que cambia, sin esperar respuesta |
02 00 | indica: envía el valor y espera que el central confirme la recepción antes de enviar el siguiente |
Los dos bytes se leen con el menos significativo primero: 01 00 representa el número 1. Una indicación ofrece más garantías porque cada envío se confirma, pero cuesta un viaje de ida y vuelta por radio por cada valor. Para un control, conviene más la notificación: si se pierde un paquete, el siguiente llega en el próximo encuentro de radio y contiene el estado completo del control, no solo lo que cambió.
Los dos registros no sirven para lo mismo. El registro del control decide si este envía. El registro de la tarjeta decide si lo que llega se entrega al programa correcto. Sin el segundo, la tarjeta descarta lo que recibe. Sin el primero, un control que cumple la norma permanece en silencio. El BSP-G6, en cambio, ya enviaba por su canal sin que nadie hubiera escrito en su descriptor: en la prueba 03 solo faltaba el registro de la tarjeta.
Dos ejemplos distintos de nuestro control.
- Una banda de frecuencia cardíaca deportiva anuncia un servicio normalizado,
0x180D, cuya característica0x2A37contiene la frecuencia cardíaca. Solo la envía cuando el celular escribe01 00en su descriptor de suscripción. Una aplicación que lo olvide verá una banda conectada y silenciosa: es el caso opuesto al nuestro. - El nivel de batería de un dispositivo (servicio
0x180F, característica0x2A19) permite ambas opciones. Un celular puede leerlo al mostrar la pantalla de dispositivos o suscribirse para recibir un aviso cada vez que disminuya.
En el programa, la suscripción sigue este orden. Una vez leído el catálogo, la tarjeta busca el canal del control por su UUID, conserva su handle y se inscribe en el registro de su pila (①):
esp_gattc_char_elem_t canal = {};
uint16_t nombre = 1;
esp_bt_uuid_t uuid = {};
uuid.len = ESP_UUID_LEN_128;
std::memcpy(uuid.uuid.uuid128, UUID_DU_CANAL, 16);
if (esp_ble_gattc_get_char_by_uuid(interface_, session_, debut_du_service_, fin_du_service_, uuid, &canal,
&nombre) != ESP_GATT_OK ||
nombre == 0) {
refuser(-6, "canal du fabricant introuvable dans son service");
break;
}
handle_du_canal = canal.char_handle;
esp_ble_gattc_register_for_notify(interface_, adresse_liee_, canal.char_handle);
La pila confirma la inscripción mediante un evento (ESP_GATTC_REG_FOR_NOTIFY_EVT). La tarjeta escribe entonces 01 00 en el descriptor de suscripción del control (②), después de buscarlo entre los descriptores de la característica:
void Liaison::ecrire_l_abonnement(uint16_t handle_de_caracteristique)
{
esp_gattc_descr_elem_t descripteur = {};
uint16_t nombre = 1;
esp_bt_uuid_t uuid = {};
uuid.len = ESP_UUID_LEN_16;
uuid.uuid.uuid16 = UUID_DU_DESCRIPTEUR_D_ABONNEMENT;
if (esp_ble_gattc_get_descr_by_char_handle(interface_, session_, handle_de_caracteristique, uuid, &descripteur,
&nombre) == ESP_GATT_OK &&
nombre > 0) {
uint8_t valeur[2] = {0x01, 0x00};
esp_ble_gattc_write_char_descr(interface_, session_, descripteur.handle, sizeof valeur, valeur,
ESP_GATT_WRITE_TYPE_RSP, ESP_GATT_AUTH_REQ_NONE);
}
}
ESP_GATT_WRITE_TYPE_RSP solicita una escritura con respuesta: el control confirma que registró la suscripción. A partir de ahí, cada notificación del handle 0x2E llega a la función recevoir_un_paquet del programa, que se detalla más adelante en la prueba 04.
Una suscripción no sobrevive a la conexión. Con cada desconexión, la pila de la tarjeta borra las entradas de su registro correspondientes a esa conexión. Y la norma exige que el periférico restablezca su descriptor a 00 00 en cada conexión nueva, salvo para un central con el que se haya emparejado y cuyos ajustes conserva. Como veremos, nuestra tarjeta prescinde del emparejamiento: por tanto, ambos registros están vacíos en cada reconexión. Por eso el programa repite las dos inscripciones cada vez que se conecta, no una sola vez al arrancar. Un programa que solo se suscribe al arrancar funciona hasta la primera desconexión; después queda conectado y silencioso.
Solo nos suscribimos a lo que leemos. Durante una investigación, resulta tentador suscribirse a todas las características de un dispositivo «para ver», pero cada suscripción genera tráfico de radio. El programa final solo se inscribe para el handle 0x2E. La pila descarta las notificaciones de los demás handles antes de que le lleguen; si aun así recibiera un paquete de otro handle, lo contaría en pantalla como «ajeno» y lo ignoraría.
Para hacer el mismo análisis con otro control, hay que inscribirse para cada característica capaz de notificar. Después bastan unas pocas líneas, en la función que recibe los eventos del cliente GATT de ESP-IDF, para escribir en la consola cada notificación con su handle y sus bytes:
case ESP_GATTC_NOTIFY_EVT:
ESP_LOGI(TAG, "handle 0x%04X, %d octets", p->notify.handle, p->notify.value_len);
ESP_LOG_BUFFER_HEX(TAG, p->notify.value, p->notify.value_len);
break;
El registro, botón por botón
Cada paquete del canal 0x2E tiene 20 bytes y siempre empieza por 20 0F. Para asignar cada casilla a su botón, una primera pasada siguió un orden acordado. La segunda fue más ingeniosa: cada botón se presionó un número distinto de veces, de una a cuatro, en dos grupos. Así, el número de parpadeos de una casilla identifica su botón, sin importar el orden en que se presionaron, y equivocarse de orden ya no puede falsear el registro. Este fue el resultado:
| Byte | Contenido | Valores |
|---|---|---|
| 0 y 1 | encabezado | siempre 0x20, 0x0F |
| 3 y 4 | palanca izquierda, X y luego Y | 0x80 en el centro; X = 0xFF hacia la derecha; Y = 0x00 hacia arriba |
| 5 y 6 | palanca derecha, X y luego Y | lo mismo |
| 7 | A, B, X, Y y la cruceta | A 0x10 · B 0x20 · X 0x40 · Y 0x80 · arriba 0x01 · abajo 0x02 · izquierda 0x04 · derecha 0x08 |
| 8 | botones superiores digitales, clics de las palancas, botones centrales | LB 0x01 · RB 0x02 · clic izquierdo 0x04 · clic derecho 0x08 · «doble pantalla» 0x10 · «lista» 0x20 · HOME 0x40 |
| 10 | gatillo analógico izquierdo | de 0x00 en reposo a 0xFF completamente presionado |
| 11 | gatillo analógico derecho | lo mismo |
| 13 a 16 | una segunda copia de la posición de las palancas | significado no establecido |
Los demás bytes no cambiaron, o no lo hicieron de una manera que pudiéramos relacionar con un movimiento. Al presionar varios botones a la vez, sus bits se combinan: 0x03 en el byte 8 son los dos botones superiores digitales. El botón T, en el centro, no envía nada: es el botón «turbo», que hace repetir otro botón mientras se mantiene presionado.
En el programa final, este registro se convierte en una tabla y la decodificación, en un bucle:
struct Bouton {
const char *mot;
uint8_t octet;
uint8_t masque;
int rang; // ligne de l'écran (à partir de Y_BOUTONS)
int x;
};
constexpr Bouton BOUTONS[] = {
{"A", 7, 0x10, 0, 2}, {"B", 7, 0x20, 0, 26}, {"X", 7, 0x40, 0, 50}, {"Y", 7, 0x80, 0, 74},
{"LB", 8, 0x01, 0, 106}, {"RB", 8, 0x02, 0, 138}, {"HAUT", 7, 0x01, 1, 2}, {"BAS", 7, 0x02, 1, 42},
{"GAU", 7, 0x04, 1, 74}, {"DRO", 7, 0x08, 1, 106}, {"L3", 8, 0x04, 2, 2}, {"R3", 8, 0x08, 2, 26},
{"SEL", 8, 0x10, 2, 50}, {"START", 8, 0x20, 2, 82}, {"HOME", 8, 0x40, 2, 130},
};
Commandes decoder(const uint8_t p[TAILLE_DU_PAQUET])
{
Commandes c = {};
for (int i = 0; i < NOMBRE_DE_BOUTONS; ++i) {
if (p[BOUTONS[i].octet] & BOUTONS[i].masque) {
c.boutons |= 1u << i;
}
}
// 0x80 au milieu ; X = 0xFF à droite ; Y = 0x00 en haut, d'où l'inversion.
c.stick_g_x = p[3] - 128;
c.stick_g_y = 128 - p[4];
c.stick_d_x = p[5] - 128;
c.stick_d_y = 128 - p[6];
c.gachette_g = p[10];
c.gachette_d = p[11];
return c;
}
Cada fila de BOUTONS indica dónde leer un botón: en qué byte y con qué máscara (el número que conserva únicamente el bit deseado). La operación p[octet] & masque vale cero si el bit está en 0 y un valor distinto de cero si está en 1. Los dos últimos números ubican la palabra en la pantalla. Agregar un botón consiste en agregar una fila a la tabla, sin tocar el bucle. Las palancas se recentran alrededor de cero, de −128 a +127, y el eje vertical se invierte para que «hacia arriba» sea positivo, como en una gráfica.
Las dos palancas traseras
Faltaban M1 y M2. Al presionarlas no se encendía ninguna casilla. Son teclas de macro, vacías de fábrica: el control puede guardar una secuencia de botones y reproducirla con una sola pulsación. El procedimiento viene del manual de un control G6 de la misma familia, que también cubre el BSP-G6:
- Mantenga presionado el botón «doble pantalla» (dos rectángulos superpuestos, en el centro) y presione M1; después de un segundo, la luz parpadea rápido.
- Presione los botones deseados, en orden, hasta un máximo de doce.
- Vuelva a presionar M1: la luz queda fija de nuevo.
Con la secuencia B, Y, X, A grabada, la palanca M1 hace pasar el byte 7 por 0x20, 0x80, 0x40 y luego 0x10, aproximadamente un botón cada 50 ms. La tarjeta recibe los botones reproducidos, sin nada que identifique la palanca trasera. Para el robot, la consecuencia es sencilla: una palanca trasera nunca es una orden adicional, sino un atajo hacia botones que ya existen. Además, los gatillos analógicos se reproducen a fondo, sin conservar el recorrido del dedo.
El defecto que muestra el video
Observe de nuevo la franja del video: indica RECHERCHE («búsqueda») aunque llegan paquetes y la cuadrícula se mueve. La radio no tenía la culpa. En la tarjeta, dos programas escuchaban la misma conexión: el lector HID de ESP-IDF, que la había abierto, y el nuestro, suscrito al canal 0x2E. La franja seguía al primero. El lector HID había cerrado su sesión por una razón que la consola no mostró; la nuestra seguía abierta y, con ella, la conexión.
Para un robot, este tipo de discrepancia es grave: dice «no hay control» cuando sí lo hay, y podría decir lo contrario. El estado mostrado debe ser el de la conexión misma, y solo debe haber un programa escuchándola. Esa será la primera regla de la cuarta prueba.
El programa de esta prueba, el de la cuadrícula, se descarga al final del artículo, en los programas completos. Basta para registrar los bytes de otro control.
Prueba 04: una conexión que solo habla con su control
En una competencia, decenas de controles idénticos pueden anunciarse en el mismo recinto. De ahí salen dos requisitos: el control de otra persona nunca debe poder conectarse al robot, y nuestra conexión no debe poder verse interrumpida sin que el robot lo sepa. El cuarto programa se escribió para eso: es el programa final, que se descarga al final del artículo junto con los de las tres primeras pruebas, en los programas completos. Ya no pasa por el lector HID de ESP-IDF: en la posición 2.4G no tenía nada que leer.
En BLE, el central es quien elige
Una conexión BLE reúne dos roles. El periférico, aquí el control, se anuncia: emite a intervalos regulares un anuncio (un mensaje corto de radio que dice «estoy aquí», con su dirección). El central, aquí la tarjeta, escucha esos anuncios y elige a quién conectarse. Por tanto, un control no puede imponerse a un central que no lo llama.
Toda la protección se apoya en ese punto. Una vez conocido el control, la tarjeta guarda su dirección y solo lo llama a él. ESP-IDF llama a esto una conexión directa:
void Liaison::ouvrir(const uint8_t adresse[6], esp_ble_addr_type_t type)
{
if (ouverture_en_cours_ || liaison_ouverte_ || interface_ == ESP_GATT_IF_NONE) {
return;
}
// « is_direct » : la radio guette les annonces de CETTE adresse, et d'elle
// seule, jusqu'à 30 s (CONFIG_BT_BLE_ESTAB_LINK_CONN_TOUT). C'est ce qui
// garantit qu'aucune autre manette ne peut être prise.
esp_ble_gatt_creat_conn_params_t parametres = {};
std::memcpy(parametres.remote_bda, adresse, 6);
parametres.remote_addr_type = type;
parametres.own_addr_type = BLE_ADDR_TYPE_PUBLIC;
parametres.is_direct = true;
parametres.is_aux = false; // connexion BLE 4.2 : le 5.0 est coupé (sdkconfig.defaults)
parametres.phy_mask = 0;
if (esp_ble_gattc_enh_open(interface_, ¶metres) == ESP_OK) {
ouverture_en_cours_ = true;
} else {
ESP_LOGE(TAG, "connexion refusée par la pile ; nouvel essai dans 1 s");
programmer(AFaire::Ouvrir, 1000 * 1000);
}
}
Durante treinta segundos, la radio solo escucha los anuncios de esa dirección. Si el control no se anuncia, el intento falla y el programa inicia otro de inmediato, indefinidamente. Por eso la tarjeta nunca necesita «buscar» el control: está permanentemente lista para recuperarlo en cuanto se anuncie. is_aux = false solicita una conexión al estilo de BLE 4.2, por la razón descubierta en la prueba 03.
Vincularlo solo mediante una acción deliberada
Falta aprender su dirección, una sola vez, sin correr el riesgo de guardar la del vecino. Deben cumplirse dos condiciones. Primero, una acción deliberada: mantener presionado el botón BOOT de la tarjeta durante tres segundos. Después, un control muy cerca: la tarjeta conserva el dispositivo HID con mejor señal detectado durante una búsqueda de tres segundos y solo lo acepta si su señal alcanza −60 dBm. Este valor es el RSSI (la intensidad de la señal recibida, en decibelios referidos a un milivatio): −60 dBm corresponde a unas pocas decenas de centímetros. Un control al otro extremo del recinto no corre el riesgo de ser elegido por error.
case Quoi::FinDeRecherche:
recherche_en_cours_ = false;
if (!appairage_) {
break;
}
if (candidat_ && signal_du_candidat_ >= SEUIL_D_APPAIRAGE_DBM) {
ESP_LOGI(TAG, "appairage avec " ESP_BD_ADDR_STR " (%d dBm)", ESP_BD_ADDR_HEX(adresse_du_candidat_),
signal_du_candidat_);
ouvrir(adresse_du_candidat_, type_du_candidat_);
} else {
rechercher(); // personne d'assez proche : on recommence
}
break;
El botón BOOT tiene una particularidad: el chip lee su nivel al arrancar, para elegir entre ejecutar el programa o esperar una carga de firmware. Mantenerlo presionado durante un reinicio haría que la tarjeta arrancara en modo de descarga. El programa solo lo lee una vez que ya está ejecutándose, cada 10 ms, en una tarea aparte:
// Le bouton BOOT : 3 s tenu, une seule fois par appui.
if (gpio_get_level(BROCHE_BOOT) == 0) {
if (boot_presse_depuis == 0) {
boot_presse_depuis = maintenant;
}
const int64_t tenu = maintenant - boot_presse_depuis;
boot_tenu_ms = static_cast<int32_t>(tenu / 1000);
if (tenu >= DUREE_POUR_APPAIRER_US && !boot_signale) {
boot_signale = true;
poster(evenement(Quoi::Boot));
}
} else {
boot_presse_depuis = 0;
boot_signale = false;
boot_tenu_ms = 0;
}
La dirección elegida se guarda en la memoria de configuración del ESP32 (una zona de la memoria flash llamada NVS, que sobrevive a los cortes de energía). Reiniciar la tarjeta no la borra; solo una nueva pulsación de tres segundos en BOOT permite cambiar de control.
El silencio no es una falla
La primera versión vigilaba la conexión de la forma más evidente: si no llega ningún paquete de datos durante 200 ms, se detienen los motores. Al dejar el control sobre la mesa, quedó de inmediato en «silencio», con los motores detenidos. Solo envía un paquete de datos cuando cambia un botón o una palanca. Una palanca sostenida inmóvil a fondo también habría detenido los motores en plena carrera.
¿Acaso no hay un diálogo permanente para mantener la conexión? Sí lo hay, pero en otra capa: la de la radio. Una vez conectados, el central y el periférico se encuentran a intervalos fijos y, en cada encuentro, intercambian un paquete, vacío si no tienen nada que decir. Ese ritmo es el intervalo de conexión. Si esos intercambios cesan durante un tiempo determinado, el tiempo de supervisión, la radio declara perdida la conexión. El latido ya existe; solo había que escucharlo en el lugar correcto.
Al conectarse, el control proponía un intervalo de 25 ms y un tiempo de supervisión de 6 segundos. Seis segundos con el robot avanzando a ciegas antes de saber que se perdió el control: es demasiado. Pero quien fija estos parámetros es el central. Por eso la tarjeta solicita algo mejor desde que se conecta:
constexpr uint16_t INTERVALLE_MIN = 6; // 7,5 ms
constexpr uint16_t INTERVALLE_MAX = 12; // 15 ms
constexpr uint16_t DELAI_DE_SUPERVISION = 30; // 300 ms
void Liaison::demander_les_parametres()
{
esp_ble_conn_update_params_t parametres = {};
std::memcpy(parametres.bda, adresse_liee_, 6);
parametres.min_int = INTERVALLE_MIN;
parametres.max_int = INTERVALLE_MAX;
parametres.latency = 0; // la manette répond à CHAQUE rendez-vous radio
parametres.timeout = DELAI_DE_SUPERVISION;
if (esp_ble_gap_update_conn_params(¶metres) != ESP_OK) {
ESP_LOGW(TAG, "demande de paramètres de liaison refusée par la pile");
}
}
Las unidades son las de la norma Bluetooth: el intervalo se cuenta en pasos de 1,25 ms (6 pasos son 7,5 ms y 12 pasos son 15 ms), y el tiempo de supervisión, en pasos de 10 ms (30 pasos son 300 ms). La latencia es el número de encuentros que el periférico puede saltarse para ahorrar batería; en cero, responde a todos.
La norma exige una condición entre estos valores para que la conexión no se declare perdida antes de haber podido faltar siquiera a un intercambio:
Con un intervalo de 15 ms y latencia nula, se necesitan más de 30 ms: nuestros 300 ms permiten perder unos veinte encuentros antes de concluir. ¿Por qué no menos? La norma prohíbe bajar de 100 ms, y un tiempo demasiado corto haría que cualquier interferencia pasajera cortara la conexión, cuando recuperarla después toma cerca de un segundo. Si es demasiado largo, el robot seguiría avanzando a ciegas. Los 300 ms son un punto de partida que habrá que ajustar con pruebas en condiciones de competencia. El control aceptó estos parámetros: 15 ms y 300 ms. En el robot, los motores se detendrán en el instante en que la radio declare perdida la conexión.
La clave que el control olvida
El primer programa de la cuarta prueba cifraba la conexión. Durante el emparejamiento (el primer encuentro de dos dispositivos, en el que generan una clave compartida que conservan), la tarjeta y el control acordaban una clave que la tarjeta reutilizaba en cada reconexión. Mientras el control permanecía encendido, todo iba bien. Después de apagarlo y volverlo a encender, rechazaba su propia clave: la conexión se caía con el código 0x3d, «fallo en la comprobación del cifrado», en cada intento. No era una clave ausente, que daría otro código (0x06); todo ocurre como si el control generara una clave nueva en cada encendido.

La siguiente solución fue volver a emparejar automáticamente el control elegido, y solo ese, cada vez que su clave dejara de servir. El control no respondió. Solo acepta un emparejamiento en su propio modo de emparejamiento, con HOME presionado durante tres segundos, y la conexión se terminaba después de seis segundos por falta de respuesta.
Quedaba una pregunta: ¿el control realmente exige cifrado? No lo exige. En su canal 0x2E, envía sus paquetes sin cifrar, desde que se conecta y sin esperar ninguna clave. Por eso el programa prescinde de la clave mediante un solo ajuste:
constexpr bool CHIFFRER = false;
Hay que ser honestos con lo que sigue protegido. La tarjeta solo llama a la dirección guardada y únicamente BOOT permite cambiarla: ningún otro control puede ser elegido por error ni imponerse. Lo que deja de estar protegido es la suplantación por un dispositivo construido expresamente para hacerse pasar por nuestro control, copiando su dirección. En una competencia, el riesgo habitual es el control del vecino, y ese queda descartado; un ataque deliberado es de otra naturaleza, pero había que mencionarlo. La ruta cifrada permanece en el programa: poner CHIFFRER en true la restablece para otro control que sí conserve su clave.
Sin clave, la conexión se resume en tres acciones: verificar que el dispositivo conectado sea el control elegido, solicitar los parámetros de conexión y leer el catálogo para encontrar el canal:
if (!CHIFFRER) {
// Sans clé : on fixe les paramètres de liaison, puis on lit le
// canal. Hors appairage, l'adresse est forcément la retenue (la
// carte n'en appelle pas d'autre) ; on le vérifie quand même.
if (!appairage_ && std::memcmp(adresse_liee_, manette_.adresse, 6) != 0) {
refuser(-3, "appareil autre que la manette retenue");
break;
}
demander_les_parametres();
lire_le_plan();
break;
}
Un detalle importa: al arrancar en modo sin clave, el programa borra todas las claves que la pila Bluetooth pudiera haber guardado. De lo contrario, la pila las usaría por su cuenta si el control llegara a solicitar cifrado, y la clave anterior fallaría con el mismo 0x3d.
El catálogo del control, en cambio, se conserva en la memoria de configuración gracias a CONFIG_BT_GATTC_CACHE_NVS_FLASH: al reconectarse, la tarjeta no se lo vuelve a pedir al control, lo que acorta la recuperación. Una vez encontrado el canal, la tarjeta se suscribe por ambos lados, como vimos en la prueba 03: primero en su propia pila y luego en el descriptor de suscripción del control. Como las dos suscripciones se borran con cada desconexión, se repiten en cada conexión; su confirmación es lo que hace que la pantalla pase a EN LIGNE («en línea»).
Una sola tarea decide
El programa está dividido en cuatro tareas (partes del programa que funcionan como si estuvieran solas y que el pequeño sistema operativo FreeRTOS alterna según su prioridad):
- La pila Bluetooth llama a dos funciones del programa con cada evento de radio. Un paquete del control se procesa ahí mismo, en unos pocos microsegundos; todo lo demás se envía a una cola de mensajes (un buzón entre dos tareas).
- La tarea «liaison» («conexión») vacía esa cola. Solo ella decide qué hace la conexión: conectarse, desconectarse, emparejar, rechazar. Dos partes del programa que decidieran por separado terminarían contradiciéndose, como en la prueba 03.
- La tarea «guet» («vigilancia») revisa el botón BOOT cada 10 ms.
- La tarea «affichage» («visualización») vuelve a dibujar diez veces por segundo únicamente las líneas de la pantalla que cambiaron.
La ruta más frecuente del programa es la de un paquete del control. Solo verifica, copia y cuenta:
void recevoir_un_paquet(uint16_t handle, const uint8_t *octets, uint16_t longueur)
{
// Un paquet qui n'a pas la forme attendue (20 octets, commençant par 0x20
// 0x0F, relevé de l'essai 03) n'est pas pris : il ne nourrit pas le guet.
if (handle != handle_du_canal || longueur != TAILLE_DU_PAQUET || octets[0] != 0x20 || octets[1] != 0x0F) {
paquets_etrangers++;
return;
}
instant_du_dernier_paquet = esp_timer_get_time();
portENTER_CRITICAL(&verrou_du_paquet);
std::memcpy(dernier_paquet, octets, TAILLE_DU_PAQUET);
portEXIT_CRITICAL(&verrou_du_paquet);
paquets_recus++;
}
El programa conserva el último paquete, no una cola de paquetes: el robot necesita el estado actual del control, no su historial. La copia se hace en una sección crítica (un tramo tan corto que se impide que otras tareas se intercalen mientras se ejecuta), para que la visualización nunca lea un paquete a medio copiar. Los contadores son variables atómicas (std::atomic, variables que dos tareas pueden leer y escribir al mismo tiempo sin leer jamás un valor a medio escribir).
El arranque prepara todo en un orden preciso:
file_de_la_liaison = xQueueCreate(48, sizeof(Evenement));
if (file_de_la_liaison == nullptr) {
ESP_LOGE(TAG, "pas de mémoire pour la file de la liaison");
return;
}
xTaskCreate(liaison, "liaison", 6 * 1024, nullptr, 4, nullptr);
xTaskCreate(guetter, "guet", 3 * 1024, nullptr, 6, nullptr);
xTaskCreate(afficher, "affichage", 6 * 1024, nullptr, 3, nullptr);
// 5. Le Bluetooth, en dernier : ses événements trouvent la file prête.
ESP_ERROR_CHECK(demarrer_le_bluetooth());
El Bluetooth arranca de último: así, sus primeros eventos encuentran listas la cola y la tarea que la vacía. La vigilancia tiene la prioridad más alta (6), porque debe ejecutarse cada 10 ms pase lo que pase; la visualización, la más baja (3), porque una imagen atrasada no cuesta nada.
Un último detalle de escritura costó una compilación. La macro de ESP-IDF que prepara la configuración de la radio, BT_CONTROLLER_INIT_CONFIG_DEFAULT, no asigna un valor a todos los campos de la estructura para el ESP32-S31. C pone los campos omitidos en cero sin decir nada; C++ lo advierte, y ESP-IDF convierte cualquier advertencia en error. Se silencia esa advertencia, solo en esta línea:
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
esp_bt_controller_config_t config_radio = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
#pragma GCC diagnostic pop
Por último, los ajustes del proyecto están en el archivo sdkconfig.defaults. Este es su núcleo: solo Bluetooth BLE, sin Bluetooth clásico, que no haría más que ocupar la radio, y sin BLE 5.0:
CONFIG_BT_ENABLED=y
CONFIG_BT_BLUEDROID_ENABLED=y
CONFIG_BTDM_CTRL_MODE_BLE_ONLY=y
# CONFIG_BT_CLASSIC_ENABLED is not set
CONFIG_BT_BLE_ENABLED=y
CONFIG_BT_GATTC_ENABLE=y
CONFIG_BT_BLE_SMP_ENABLE=y
CONFIG_BT_BLE_42_FEATURES_SUPPORTED=y
# CONFIG_BT_BLE_50_FEATURES_SUPPORTED is not set
CONFIG_BT_GATTC_CACHE_NVS_FLASH=y
Lo que muestra la pantalla y lo que midió
La pantalla de la cuarta prueba ya no muestra bits, sino el estado de la conexión. La franja indica la etapa:
| Franja | Qué está pasando |
|---|---|
| SANS MANETTE (gris, «sin control») | no hay ningún control guardado: hay que vincularlo manteniendo BOOT presionado 3 s |
| APPAIRAGE (cian, «emparejamiento») | la tarjeta busca un control en modo de emparejamiento, muy cerca de ella |
| ATTENTE (naranja, «espera») | la tarjeta espera que se anuncie el control guardado |
| LECTURE (amarillo, «lectura») | conectada: lectura del catálogo y suscripción al canal |
| EN LIGNE (verde, «en línea») | la conexión está establecida y llegan las órdenes |
Bajo la franja aparece la dirección del control guardado y luego las mediciones: la tasa de paquetes, el tiempo transcurrido desde el último paquete de datos, el número de desconexiones con el código de su causa, el tiempo de recuperación después de la última desconexión, los rechazos y los dos parámetros de la conexión. La línea MOTEURS AUTORISES (verde, «motores habilitados») o MOTEURS COUPES (roja, «motores detenidos») indica qué haría el robot. Más abajo, cada botón presionado se enciende en amarillo, y los gatillos y las palancas aparecen como números.
La foto de apertura resume todo el capítulo sobre el silencio: DERNIER PAQUET 277.8 S («último paquete: 277,8 s»), ningún paquete de datos desde hace más de cuatro minutos y medio, y aun así EN LIGNE, MOTEURS AUTORISES. Nadie tocaba el control y la radio seguía latiendo cada 15 ms.
Las mediciones, tomadas el 20 de noviembre de 2026:
- Reinicio de la tarjeta, con el control todavía encendido: la tarjeta lo recupera sola, sin ninguna acción, y vuelve a estar en línea en menos de un segundo y medio desde el arranque.
- Control apagado y encendido de nuevo (pulsación larga de HOME para apagarlo y corta para encenderlo): la tarjeta lo recupera en cuanto se anuncia, unos veinte milisegundos después de establecer la conexión de radio, al volver a leer el catálogo desde la memoria de configuración.
- Control dejado en reposo: terminó la conexión por su cuenta 5 min 11 s después de quedar en línea, incluso con la conexión abierta. Es su suspensión automática. La tarjeta lo detectó al instante (desconexión, causa
0x13: el dispositivo remoto terminó la conexión), y una pulsación de HOME lo devuelve a línea.

En el robot, esta suspensión tendrá una consecuencia práctica: un control dejado cinco minutos durante una pausa debe despertarse con HOME antes de retomar el manejo. No hay peligro, ya que los motores se detienen en el instante en que termina la conexión.
Repetir el montaje
Qué necesita
- Una tarjeta ESP32-S31 Function-CoreBoard-1 de Espressif y un cable USB-C.
- Una pantalla ST7789 de 1,9 pulgadas, de 170 × 320 píxeles, en un módulo de ocho pines (GND, VCC, SCL, SDA, RES, DC, CS, BLK).
- Ocho cables hembra-hembra de unos diez centímetros.
- Un control BSP-G6 (ShanWan BM-835). Otro control requerirá su propio análisis con el método de la prueba 03: es muy probable que su canal y la ubicación de sus botones sean distintos.
- ESP-IDF 6.1, instalado según la documentación de Espressif (en Windows, mediante su instalador, que deja listo un terminal ESP-IDF con toda la configuración).
- El proyecto completo, disponible para descargar al final del artículo.
Cablear
Siga la tabla de la prueba 01 con la tarjeta desconectada. El único cable que debe revisar dos veces es VCC: al 3V3 (pin 36 de J2), nunca al 5V.
Compilar y cargar el programa
Descomprima el proyecto en una carpeta cuya ruta no contenga espacios ni tildes, por ejemplo C:\esp\manette-ble-esp32-s31 en Windows. Algunas herramientas de ESP-IDF 6.1 fallan con los espacios, los caracteres acentuados y las rayas largas en una ruta, y sus mensajes de error no lo explican claramente. Conecte la tarjeta por su puerto USB-DBG, abra el terminal ESP-IDF, ubíquese en la carpeta del proyecto y ejecute:
idf.py --preview set-target esp32s31
idf.py --preview build
idf.py --preview -p COM3 flash monitor
El primer comando elige el chip; el segundo compila (varios minutos la primera vez y unos segundos después); el tercero carga el programa y muestra la consola. Reemplace COM3 por el puerto de su tarjeta: Windows la muestra como un «dispositivo serie USB» en el Administrador de dispositivos y Linux, como /dev/ttyACM0. No hay que presionar ningún botón: la carga pone por sí sola el chip en modo de descarga y luego lo reinicia. Para salir de la consola, use Ctrl+].
Vincular el control
- Si el control ya estuvo conectado a un celular o a un PC, haga que lo olvide en su configuración Bluetooth: un control conectado a otro dispositivo deja de anunciarse.
- La pantalla indica SANS MANETTE. Mantenga BOOT presionado durante tres segundos: la pantalla cuenta los segundos y luego pasa a APPAIRAGE.
- Ponga el selector del control en 2.4G, mantenga HOME presionado durante tres segundos (la luz parpadea rápido) y colóquelo junto a la tarjeta. La pantalla muestra el nombre del dispositivo detectado y su señal: en verde si está lo suficientemente cerca y en naranja si está demasiado lejos.
- Espere a que aparezca EN LIGNE y presione cada botón: su nombre se enciende en amarillo.
- Verifique la recuperación: presione RST en la tarjeta y esta debe volver a estar en línea sola; apague el control (manteniendo HOME presionado), enciéndalo con una pulsación corta y la tarjeta debe recuperarlo sin ninguna otra acción.
Cuando no funciona
| Lo que ve | Qué significa | Qué puede hacer |
|---|---|---|
| La pantalla se ilumina, pero queda uniforme, sin texto | la pantalla no recibe sus órdenes | revisar SCL, SDA, DC, CS y RES uno por uno; después bajar FREQUENCE_SPI_HZ a 10 MHz |
| Toda la pantalla pasa a negativo después de mover un cable | un falso contacto cambió una orden durante la transmisión | ajustar bien los cables y presionar RST |
| APPAIRAGE sin fin, nombre en naranja | el control está demasiado lejos (señal por debajo de −60 dBm) | acercarlo a la tarjeta |
| APPAIRAGE sin fin, sin ningún nombre | el control no está en modo de emparejamiento o está conectado a otro dispositivo | mantener HOME presionado 3 s; hacer que el celular o el PC lo olvide |
| REFUS MOTIF 6 | no se encuentra el canal del fabricante | el control no está en la posición 2.4G |
| REFUS MOTIF 2 | la conexión no estaba en línea 10 s después de conectarse | volver a intentarlo; si se repite, leer la consola |
| COUPURES, CAUSE 13 | el control terminó la conexión: apagado o en suspensión | pulsación corta de HOME |
| COUPURES, CAUSE 08 | no hubo ningún intercambio de radio durante 300 ms | el control está demasiado lejos o hay un obstáculo metálico entre él y la tarjeta |
| ATTENTE prolongada | el control guardado no se anuncia | despertarlo con HOME; para cambiarlo, mantener BOOT presionado 3 s |
La consola dice más que la pantalla: allí se escriben de forma explícita cada cambio de estado, cada desconexión con su causa, cada rechazo, los parámetros de la conexión y el tiempo de recuperación.
Lo que falta poner a prueba
Todo lo anterior se midió sobre un escritorio, a unas pocas decenas de centímetros. Un recinto de competencia será más exigente, y quedan cinco pruebas antes de confiar en esta conexión:
- La distancia: ¿hasta dónde se mantiene la conexión y vuelve sola cuando nos acercamos?
- La pérdida total de señal: encerrar el control en una caja metálica debe hacer que los motores se detengan en unos 300 ms, con la causa
0x08. - El Wi-Fi con mucho tráfico: ¿un celular como punto de acceso, descargando datos y colocado contra la tarjeta, hace caer la conexión? Si es así, 300 ms es demasiado corto.
- Otro dispositivo: un celular que intente conectarse a la tarjeta u otro control en modo de emparejamiento a su lado no debe cambiar nada en la pantalla.
- El control conectado por otro dispositivo: con la tarjeta apagada, ¿un celular puede ver nuestro control y conectarse a él? Es decir, ¿el control se anuncia a todos o únicamente al último dispositivo que conoció?
El último punto importa tanto como los demás. La tarjeta no se deja desviar hacia otro control, pero todavía no sabemos si alguien puede llevarse la conexión del control mientras el robot duerme.
Con qué quedarse
El control se hacía pasar por una pantalla táctil y luego por un control HID que no enviaba nada. Sus botones viajaban por un canal del fabricante, sin cifrar, y es ese canal el que la tarjeta lee ahora: quince botones, las dos palancas y los dos gatillos analógicos, a más de 150 paquetes por segundo en cuanto se mueve el control.
En un recinto de competencia lleno de controles idénticos, la tarjeta solo llama al suyo, y únicamente mantener presionado BOOT tres segundos la hace cambiar de control. Lo recupera sola, sin ninguna acción: en menos de un segundo y medio después de reiniciar la tarjeta, y en cuanto el control se anuncia al volver a encenderlo. Incluso después de casi veintisiete minutos en suspensión, bastó una sola pulsación de HOME, sin búsqueda y sin pedir nada.

La fracción de segundo, en cambio, está configurada pero todavía no se ha puesto a prueba. El control aceptó 300 ms de supervisión en lugar de los seis segundos que proponía, y la tarjeta detecta al instante un control que termina la conexión; falta cortarla de golpe, dentro de una caja metálica, para medir cuánto tardaría realmente el robot en detenerse.
Tres ideas hicieron posible el recorrido y sirven mucho más allá de este control.
La descripción de un dispositivo no es lo que hace. El control se describía como un control HID, pero hablaba por otro lado. Mostrar los bytes sin procesar, sin suponer nada sobre su formato, resolvió en unos minutos lo que horas leyendo descripciones no habrían resuelto.
En BLE, el central es quien elige. Guardar una dirección y llamar únicamente a esa basta para cerrarles la puerta a los demás controles, sin ninguna clave.
Una conexión silenciosa no es una conexión muerta. Vigilar los datos era confundir un control en reposo con uno perdido. La radio intercambia un paquete en cada encuentro, aunque esté vacío: ahí era donde había que mirar, y es el central quien ajusta cuánto tiempo tolera el silencio.
Queda la pregunta que solo un recinto de competencia real podrá resolver: ¿300 ms de supervisión, entre decenas de conexiones Wi-Fi y Bluetooth, es lo bastante corto para la seguridad y lo bastante largo para no detener el robot con cada interferencia?
Los programas completos
Cada prueba tiene su programa, completo y listo para compilar. Los archivos contienen solo el código fuente: no hay que descargar nada más que ESP-IDF, y cada uno se compila con los tres comandos de la sección «Compilar y cargar el programa». Siguen la historia: cada uno conserva lo que la prueba aprendió, y los defectos que todavía no había visto.
Prueba 01, la pantalla: essai-01-ecran-st7789.zip. El programa dibuja el patrón de prueba y luego mueve un pequeño cuadrado de un lado a otro. Solo necesita la pantalla, cableada como en la tabla de la prueba 01. Los cuatro ajustes del panel, marcados «À RÉGLER», están al principio de main/essai_ecran.cpp.
Prueba 02, el control por Bluetooth: essai-02-manette-ble.zip. Es el ejemplo esp_hid_host de ESP-IDF, con sus tres correcciones, marcadas [essai 02] en el código; su licencia, Unlicense o CC0-1.0, está al inicio de cada archivo. No muestra nada en la pantalla: todo se lee en la consola. Su búsqueda dura solo cinco segundos, una sola vez, al arrancar: ponga el control en modo de emparejamiento (selector en V3, HOME presionado tres segundos) antes de arrancar la tarjeta, o presione RST justo después.
Prueba 03, mostrarlo todo, bit por bit: essai-03-manette-et-ecran.zip. Es el programa de la cuadrícula del video 1, con el controlador de la pantalla y la búsqueda de la prueba 02 guardados en components/. Su búsqueda se reinicia sola mientras no haya ningún control conectado. Borra todos los emparejamientos en cada arranque: después de un RST, vuelva a poner el control en modo de emparejamiento. Conserva el defecto de la franja descrito más arriba.
Prueba 04, la conexión blindada, el programa final: manette-ble-esp32-s31.zip. Es el que describen la sección «Repetir el montaje» y la mayoría de los fragmentos de código. El archivo contiene:
CMakeLists.txt,sdkconfig.defaultsypartitions.csv: el proyecto, sus ajustes y la distribución de la memoria flash.main/essai_liaison.cpp: el programa, en nueve secciones comentadas (los ajustes, los estados de la conexión, el último paquete, los eventos Bluetooth, la memoria de configuración, la tarea «liaison», la vigilancia del botón BOOT, la visualización y el arranque del Bluetooth).components/ecran_st7789/: el controlador de la pantalla, con su fuente de 3 × 5 píxeles.
Todos los ajustes que podría querer cambiar están agrupados al principio de main/essai_liaison.cpp, en la sección «0. Les réglages»: los pines de la pantalla, la duración de la pulsación de BOOT, los parámetros de conexión, el umbral de señal para vincular el control y CHIFFRER.
El código fuente, sus comentarios y los mensajes de la pantalla y la consola se conservan en francés, tal como aparecen en los ejemplos y las fotografías.
Fuentes y antecedentes
- Espressif, ESP32-S31 Function-CoreBoard-1, User Guide: distribución de pines del conector J2, puertos USB y botones; y el esquema de la tarjeta, versión 1.0 del 13 de mayo de 2026.
- Espressif, documentación de ESP-IDF: API del cliente GATT y de seguridad BLE de Bluedroid; ejemplo
examples/bluetooth/esp_hid_host, punto de partida de la prueba 02. - Bluetooth SIG, Bluetooth Core Specification, volumen 6, parte B (capa de enlace): intervalo de conexión, latencia y tiempo de supervisión, y la condición que los relaciona.
- Sitronix, hoja de datos del ST7789V: códigos de las órdenes
CASET(0x2A) eINVOFF(0x20). - Manual del control G6, en manuals.plus, consultado el 20 de noviembre de 2026: grabación y borrado de macros en M1 y M2, botón turbo.
Fotografías y video: Sébastien Debucquoi.
Los programas de los archivos se publican bajo la licencia PolyForm Noncommercial 1.0.0: puede usarlos, modificarlos y compartirlos para un uso personal, educativo, de investigación o sin ánimo de lucro; cualquier uso comercial requiere la autorización escrita del autor. Los archivos de Espressif que contienen conservan su propia licencia.
