Queremos implementar un programa en Arduino que permita la gestión de gestos mediante…
- User
Queremos implementar un programa en Arduino que permita la gestión de gestos mediante entradas táctiles en un ESP32. El programa debe incluir las siguientes especificaciones:
Configuración de Pines y Umbrales: Definir un conjunto de pines como entradas táctiles (GPIOs específicos del ESP32). Establecer umbrales para detectar toques en estos pines. Gestión de Gestos: Crear una estructura de datos para almacenar gestos definidos por el usuario. Cada gesto debe estar compuesto por una secuencia de pines táctiles y una serie de acciones a realizar. Las acciones, en este caso, son presionar teclas específicas (códigos HID específicos para teclados). Implementar la capacidad de añadir, eliminar y listar gestos almacenados. Persistencia: Utilizar Preferences para guardar y cargar gestos desde la memoria no volátil del ESP32 al inicio. Funcionalidad de HID BLE (Bluetooth de bajo consumo): Configurar el dispositivo como un teclado HID BLE que se pueda emparejar con otros dispositivos. Enviar teclas específicas cuando se detecta un gesto táctil conocido. Manejo de Entrada Táctil: Implementar un mecanismo de debounce para garantizar la estabilidad en la detección de toques. Utilizar un buffer para mantener un historial de las entradas táctiles más recientes. Verificar y ejecutar gestos reconocidos si los toques coinciden con las secuencias predefinidas. Soporte para Comandos Seriales: Implementar la capacidad de recibir y procesar comandos a través de la interfaz Serial, permitiendo añadir, eliminar y listar gestos, así como probar el sistema. Debugging: Proveer un mecanismo de registro (logging) a través del puerto serial para diagnosticar problemas durante el desarrollo. Conserva el diseño modular de clases para la gestión de gestos (GestureManager) y el manejo de HID (HIDManager), asegurando un código limpio y fácil de mantener.
- Assistant
¡Claro! A continuación, se presenta un programa completo para el ESP32 utilizando el entorno de Arduino que cumple con todas las especificaciones mencionadas. El diseño se mantiene modular mediante las clases
GestureManageryHIDManager, lo que facilita el mantenimiento y la ampliación del sistema.1. Bibliotecas Necesarias
Asegúrate de tener instaladas las siguientes bibliotecas en tu entorno de Arduino:
- Preferences: Para manejar la memoria no volátil.
- NimBLE (o BLE HID): Para implementar HID sobre BLE.
- BLE HID: Para la funcionalidad de teclado HID BLE.
- ArduinoJson: Para manejar comandos y almacenamiento estructurado.
2. Estructura del Código
El programa se divide en las siguientes partes:
- Definiciones y Configuraciones Iniciales
- Clases Principales
GestureGestureManagerHIDManager
- Implementación de Funcionalidades
- Gestión de Gestos
- HID BLE
- Manejo de Entradas Táctiles
- Comandos Seriales
- Función
setup()yloop()
3. Código Completo
#include <Arduino.h> #include <Preferences.h> #include <BLEDevice.h> #include <BLEHIDDevice.h> #include <HIDTypes.h> #include <HIDKeyboardTypes.h> #include <BLEServer.h> #include <BLEUtils.h> #include <ArduinoJson.h> // Definiciones y Configuraciones Iniciales #define NUM_TOUCH_PINS 6 const uint8_t touchPins[NUM_TOUCH_PINS] = {4, 0, 2, 15, 13, 12}; // GPIOs táctiles del ESP32 const uint16_t touchThreshold = 40; // Umbral para detectar toques const unsigned long debounceDelay = 50; // Debounce en ms const size_t gestureBufferSize = 10; // Tamaño del buffer de gestos // Preferencias para almacenamiento Preferences preferences; // Estructura para un Gestos struct Gesture { String name; uint8_t sequence[gestureBufferSize]; size_t sequenceLength; String action; // Código HID o acción asociada }; // Clase para gestionar Gestos class GestureManager { public: GestureManager() { loadGestures(); } bool addGesture(const Gesture& gesture) { if (gestures.size() >= maxGestures) return false; gestures.push_back(gesture); saveGestures(); return true; } bool removeGesture(const String& name) { for (auto it = gestures.begin(); it != gestures.end(); ++it) { if (it->name == name) { gestures.erase(it); saveGestures(); return true; } } return false; } void listGestures() { Serial.println("Gestos almacenados:"); for (const auto& gesture : gestures) { Serial.print("Nombre: "); Serial.println(gesture.name); Serial.print("Secuencia: "); for (size_t i = 0; i < gesture.sequenceLength; i++) { Serial.print(gesture.sequence[i]); if (i < gesture.sequenceLength - 1) Serial.print(" -> "); } Serial.println(); Serial.print("Acción: "); Serial.println(gesture.action); Serial.println("-----"); } } Gesture* matchGesture(const uint8_t* buffer, size_t length) { for (auto& gesture : gestures) { if (length >= gesture.sequenceLength) { bool match = true; for (size_t i = 0; i < gesture.sequenceLength; i++) { if (buffer[length - gesture.sequenceLength + i] != gesture.sequence[i]) { match = false; break; } } if (match) return &gesture; } } return nullptr; } private: std::vector<Gesture> gestures; const size_t maxGestures = 20; void saveGestures() { DynamicJsonDocument doc(2048); JsonArray arr = doc.createNestedArray("gestures"); for (const auto& gesture : gestures) { JsonObject obj = arr.createNestedObject(); obj["name"] = gesture.name; JsonArray seq = obj.createNestedArray("sequence"); for (size_t i = 0; i < gesture.sequenceLength; i++) { seq.add(gesture.sequence[i]); } obj["action"] = gesture.action; } String json; serializeJson(doc, json); preferences.putString("gestures", json); Serial.println("Gestos guardados en Preferences."); } void loadGestures() { gestures.clear(); if (!preferences.begin("gestures-nvs", false)) { Serial.println("Error al acceder a Preferences."); return; } String json = preferences.getString("gestures", ""); if (json.length() == 0) { Serial.println("No se encontraron gestos en Preferences."); return; } DynamicJsonDocument doc(2048); DeserializationError error = deserializeJson(doc, json); if (error) { Serial.print("Error al parsear JSON: "); Serial.println(error.c_str()); return; } JsonArray arr = doc["gestures"].as<JsonArray>(); for (auto& obj : arr) { Gesture gesture; gesture.name = obj["name"].as<String>(); JsonArray seq = obj["sequence"].as<JsonArray>(); gesture.sequenceLength = seq.size(); for (size_t i = 0; i < seq.size() && i < gestureBufferSize; i++) { gesture.sequence[i] = seq[i].as<uint8_t>(); } gesture.action = obj["action"].as<String>(); gestures.push_back(gesture); } Serial.println("Gestos cargados desde Preferences."); } }; // Clase para gestionar HID BLE class HIDManager { public: HIDManager() : hid(nullptr), keyboard(nullptr), connected(false) {} void begin() { BLEDevice::init("ESP32 HID Keyboard"); pServer = BLEDevice::createServer(); pServer->setCallbacks(this); hid = new BLEHIDDevice(pServer); keyboard = hid->createKeyboardImpl(); hid->startServices(); BLEAdvertising* pAdvertising = pServer->getAdvertising(); pAdvertising->setAppearance(HID_KEYBOARD); pAdvertising->addServiceUUID(hid->hidService()->getUUID()); pAdvertising->start(); Serial.println("Esperando a que un dispositivo se empareje..."); } bool isConnected() const { return connected; } void sendKey(const String& keyCode) { if (!connected) return; // Aquí se debe mapear el keyCode a códigos HID específicos // Por simplicidad, asumiremos que keyCode es un carácter ASCII uint8_t k = keyCode.c_str()[0]; keyboard->press(k); delay(100); keyboard->release(k); Serial.print("Enviar tecla: "); Serial.println((char)k); } // Callbacks BLE void onConnect(BLEServer* pServer) { connected = true; Serial.println("Dispositivo conectado."); } void onDisconnect(BLEServer* pServer) { connected = false; Serial.println("Dispositivo desconectado."); } private: BLEHIDDevice* hid; BLECharacteristic* input; BLEServer* pServer; BLEHIDDevice::Keyboard* keyboard; bool connected; }; // Instancias Globales GestureManager gestureManager; HIDManager hidManager; // Gestión de Entradas Táctiles uint8_t touchBuffer[gestureBufferSize]; size_t touchIndex = 0; unsigned long lastTouchTime = 0; // Función para manejar táctiles void handleTouchInputs(GestureManager& gm, HIDManager& hm) { for (size_t i = 0; i < NUM_TOUCH_PINS; i++) { uint16_t touchValue = touchRead(touchPins[i]); bool touched = touchValue < touchThreshold; static bool touchState[NUM_TOUCH_PINS] = {false}; static unsigned long lastDebounceTime[NUM_TOUCH_PINS] = {0}; if (touched != touchState[i]) { unsigned long currentTime = millis(); if (currentTime - lastDebounceTime[i] > debounceDelay) { touchState[i] = touched; lastDebounceTime[i] = currentTime; if (touched) { Serial.print("Toque detectado en pin: "); Serial.println(touchPins[i]); touchBuffer[touchIndex] = i; touchIndex = (touchIndex + 1) % gestureBufferSize; // Verificar gestos Gesture* matchedGesture = gm.matchGesture(touchBuffer, gestureBufferSize); if (matchedGesture) { Serial.print("Gestor detectado: "); Serial.println(matchedGesture->name); hm.sendKey(matchedGesture->action); } } } } } } // Manejador de Comandos Seriales void handleSerialCommands(GestureManager& gm) { if (Serial.available()) { String command = Serial.readStringUntil('\n'); command.trim(); if (command.startsWith("ADD")) { // Formato: ADD nombre accion pin1 pin2 ... // Ejemplo: ADD saludo A 0 1 2 DynamicJsonDocument doc(256); DeserializationError error = deserializeJson(doc, command.substring(4)); if (error) { Serial.println("Error al parsear comando ADD."); return; } Gesture gesture; gesture.name = doc["name"].as<String>(); gesture.action = doc["action"].as<String>(); JsonArray seq = doc["sequence"].as<JsonArray>(); gesture.sequenceLength = seq.size(); for (size_t i = 0; i < seq.size() && i < gestureBufferSize; i++) { gesture.sequence[i] = seq[i].as<uint8_t>(); } if (gm.addGesture(gesture)) { Serial.println("Gestor añadido exitosamente."); } else { Serial.println("Error al añadir gestor."); } } else if (command.startsWith("REMOVE")) { // Formato: REMOVE nombre String name = command.substring(7); name.trim(); if (gm.removeGesture(name)) { Serial.println("Gestor eliminado exitosamente."); } else { Serial.println("Gestor no encontrado."); } } else if (command.startsWith("LIST")) { gm.listGestures(); } else if (command.startsWith("TEST")) { // Prueba de conexión HID Serial.println("Enviando tecla de prueba: 'A'"); hidManager.sendKey("A"); } else { Serial.println("Comando desconocido."); } } } // Función de Configuración void setup() { Serial.begin(115200); while (!Serial) { delay(10); } // Inicializar Preferences if (!preferences.begin("gestures-nvs", false)) { Serial.println("No se pudo inicializar Preferences."); } // Inicializar HID hidManager.begin(); // Configurar pines táctiles for (size_t i = 0; i < NUM_TOUCH_PINS; i++) { pinMode(touchPins[i], INPUT); } Serial.println("Sistema inicializado."); Serial.println("Comandos disponibles:"); Serial.println("ADD {\"name\":\"nombre\",\"action\":\"A\",\"sequence\":[0,1,2]}"); Serial.println("REMOVE nombre"); Serial.println("LIST"); Serial.println("TEST"); } // Bucle Principal void loop() { handleTouchInputs(gestureManager, hidManager); handleSerialCommands(gestureManager); delay(10); // Pequeño retardo }4. Explicación Detallada
4.1. Definiciones y Configuraciones Iniciales
- Pines Táctiles: Se definen los GPIOs táctiles que se utilizarán para detectar toques.
- Umbral de Toque:
touchThresholddetermina si un pin ha sido tocado. - Debounce: Se utiliza para evitar lecturas erróneas debido al ruido.
4.2. Clase
GestureManager- Agregar Gestos: Permite añadir nuevos gestos a la lista y guardarlos en la memoria no volátil.
- Eliminar Gestos: Permite eliminar gestos existentes por su nombre.
- Listar Gestos: Imprime en el Serial todos los gestos almacenados.
- Match Gestures: Verifica si la secuencia actual de toques coincide con algún gesto definido.
4.3. Clase
HIDManager- Inicialización: Configura el ESP32 como un dispositivo HID BLE con un perfil de teclado.
- Enviar Teclas: Envía una tecla específica al dispositivo conectado. Aquí se puede mejorar mapeando acciones más complejas o múltiples teclas.
- Callbacks de BLE: Gestiona las conexiones y desconexiones de dispositivos BLE.
4.4. Gestión de Entradas Táctiles
- Debounce: Asegura que solo se reconozca un toque efectivo.
- Buffer de Gestos: Almacena la secuencia reciente de toques para comparar con gestos almacenados.
- Detección de Gestos: Cuando se detecta un toque, se actualiza el buffer y se verifica si coincide con algún gesto definido.
4.5. Manejo de Comandos Seriales
- ADD: Permite añadir un nuevo gesto. Se espera un JSON con estructura:
{ "name":"nombre_del_gesto", "action":"A", "sequence":[0,1,2] } - REMOVE: Elimina un gesto por su nombre.
- LIST: Lista todos los gestos almacenados.
- TEST: Envía una tecla de prueba para verificar la funcionalidad HID.
4.6. Funciones
setup()yloop()setup(): Inicializa el Serial, las preferencias, HID, y configura los pines táctiles. También imprime los comandos disponibles.loop(): Maneja continuamente las entradas táctiles y los comandos seriales.
5. Formato de Comandos Seriales
-
Agregar un Gestor:
ADD {"name":"saludo","action":"A","sequence":[0,1,2]}name: Nombre único para el gesto.action: La tecla HID a enviar (en este caso, "A").sequence: Secuencia de índices de pines táctiles que componen el gesto.
-
Eliminar un Gestor:
REMOVE saludo -
Listar Gestores:
LIST -
Probar HID:
TEST
6. Mejoras y Consideraciones Futuras
- Mapeo de Teclas Más Complejo: Actualmente, la acción asume un carácter. Se puede expandir para soportar combinaciones o secuencias de teclas.
- Gestión de Secuencias de Diferente Longitud: El buffer actual tiene una longitud fija. Podría ser mejorado para manejar gestos de diversas longitudes.
- Interfaz de Usuario para Comandos: Implementar una interfaz más amigable o incluso utilizar una aplicación móvil para gestionar gestos.
- Optimización del Uso de Memoria: Dependiendo de la cantidad de gestos, ajustar el tamaño del JSON o el buffer para optimizar el uso de memoria.
7. Conclusión
Este programa proporciona una base sólida para gestionar gestos táctiles en un ESP32 con funcionalidad HID BLE. Gracias al diseño modular, es fácil de mantener y ampliar según las necesidades específicas de tu proyecto. Asegúrate de ajustar los pines táctiles y los umbrales según tu configuración de hardware particular para obtener el mejor rendimiento.