Detección de gestos con acelerómetro y control de LEDs

Introducción a Detección de Gestos con Acelerómetro

La detección de gestos con acelerómetros representa una de las fronteras más emocionantes en la interfaz hombre-máquina (HMI). Esta tecnología permite crear sistemas que responden intuitivamente a los movimientos naturales del usuario, abriendo nuevas posibilidades en mecatrónica, robótica y sistemas embebidos.

Los acelerómetros MEMS (Micro-Electro-Mechanical Systems) son sensores microscópicos que miden la aceleración en múltiples ejes. En combinación con algoritmos de procesamiento de señales digitales y técnicas básicas de aprendizaje automático, estos sensores pueden interpretar gestos complejos y traducirlos en comandos específicos para el control de actuadores como LEDs, motores o sistemas completos.

Principios Fundamentales

Aceleración Tri-axial: Medición en ejes X, Y, Z
Procesamiento DSP: Filtrado y análisis de señales
Reconocimiento de Patrones: Algoritmos de clasificación
Respuesta en Tiempo Real: Latencia mínima crítica

Aplicaciones Industriales

Robótica Colaborativa: Control gestual de cobots
Realidad Aumentada: Interfaces inmersivas
Dispositivos Médicos: Control sin contacto
Automatización: Comandos gestuales en líneas de producción

Arquitectura Técnica del Sistema

Tecnología MEMS y Sensores

Los sensores MEMS utilizan estructuras microscópicas de silicio que se deforman bajo aceleración. El MPU6050 y MPU9250 son los sensores más utilizados, integrando acelerómetro, giroscopio y magnetómetro en un solo chip con comunicación I2C.

Protocolo I2C y Comunicación

El protocolo I2C (Inter-Integrated Circuit) permite la comunicación serial síncrona entre el ESP32 y el sensor. Utilizando solo dos líneas (SDA y SCL), se pueden leer múltiples registros del sensor a velocidades de hasta 400 kHz.

Arduino C++ - Inicialización MPU6050

#include <Wire.h>
#include <MPU6050.h>

// Configuración del sensor MPU6050
MPU6050 mpu;

// Variables para almacenar lecturas del acelerómetro
int16_t ax, ay, az;
int16_t gx, gy, gz;

// Parámetros de calibración
float ax_offset = 0, ay_offset = 0, az_offset = 0;

// Configuración inicial del sistema
void setup() {
    Serial.begin(115200);
    
    // Inicializar comunicación I2C
    Wire.begin();
    Wire.setClock(400000); // Frecuencia I2C a 400kHz
    
    // Inicializar MPU6050
    Serial.println("Inicializando MPU6050...");
    mpu.initialize();
    
    // Verificar conexión
    if (mpu.testConnection()) {
        Serial.println("MPU6050 conectado correctamente");
        
        // Configurar rangos del sensor
        mpu.setFullScaleAccelRange(MPU6050_ACCEL_FS_4); // ±4g
        mpu.setFullScaleGyroRange(MPU6050_GYRO_FS_500);  // ±500°/s
        
        // Configurar filtro paso bajo digital
        mpu.setDLPFMode(MPU6050_DLPF_BW_42); // 42Hz
        
        // Calibrar el sensor
        calibrarSensor();
    } else {
        Serial.println("Error: No se puede conectar al MPU6050");
        while(1);
    }
    
    // Configurar LEDs de salida
    configurarLEDs();
}

// Función de calibración del sensor
void calibrarSensor() {
    Serial.println("Calibrando sensor... Mantener inmóvil");
    
    long sum_ax = 0, sum_ay = 0, sum_az = 0;
    const int num_lecturas = 1000;
    
    for(int i = 0; i < num_lecturas; i++) {
        mpu.getAcceleration(&ax, &ay, &az);
        sum_ax += ax;
        sum_ay += ay;
        sum_az += az;
        delay(2);
    }
    
    // Calcular offsets (el eje Z debería leer ~16384 para 1g)
    ax_offset = sum_ax / num_lecturas;
    ay_offset = sum_ay / num_lecturas;
    az_offset = (sum_az / num_lecturas) - 16384;
    
    Serial.println("Calibración completada");
}

Arduino C++ - Algoritmo de Detección de Gestos

// Estructura para almacenar datos del gesto
struct GestureData {
    float magnitude;
    float direction_x;
    float direction_y;
    float direction_z;
    unsigned long timestamp;
};

// Buffer circular para análisis temporal
const int BUFFER_SIZE = 50;
GestureData gesture_buffer[BUFFER_SIZE];
int buffer_index = 0;

// Umbrales para detección de gestos
const float SHAKE_THRESHOLD = 2.0;      // Umbral para detectar sacudida
const float TILT_THRESHOLD = 0.7;       // Umbral para detectar inclinación
const float TAP_THRESHOLD = 3.0;        // Umbral para detectar golpe

// Estados de los gestos detectados
enum GestureType {
    NO_GESTURE,
    SHAKE_LEFT_RIGHT,
    SHAKE_UP_DOWN,
    TILT_LEFT,
    TILT_RIGHT,
    TILT_FORWARD,
    TILT_BACKWARD,
    DOUBLE_TAP
};

GestureType current_gesture = NO_GESTURE;

void loop() {
    // Leer datos del acelerómetro
    mpu.getAcceleration(&ax, &ay, &az);
    
    // Aplicar calibración
    float ax_cal = (ax - ax_offset) / 16384.0; // Convertir a 'g'
    float ay_cal = (ay - ay_offset) / 16384.0;
    float az_cal = (az - az_offset) / 16384.0;
    
    // Almacenar en buffer circular
    gesture_buffer[buffer_index].magnitude = sqrt(ax_cal*ax_cal + ay_cal*ay_cal + az_cal*az_cal);
    gesture_buffer[buffer_index].direction_x = ax_cal;
    gesture_buffer[buffer_index].direction_y = ay_cal;
    gesture_buffer[buffer_index].direction_z = az_cal;
    gesture_buffer[buffer_index].timestamp = millis();
    
    buffer_index = (buffer_index + 1) % BUFFER_SIZE;
    
    // Analizar gestos cada 10 muestras
    if (buffer_index % 10 == 0) {
        current_gesture = analizarGesto();
        
        // Ejecutar acción según el gesto detectado
        ejecutarAccionGesto(current_gesture);
    }
    
    delay(20); // 50Hz de muestreo
}

// Función principal de análisis de gestos
GestureType analizarGesto() {
    // Análisis de varianza para detectar sacudidas
    float variance_x = calcularVarianza('x');
    float variance_y = calcularVarianza('y');
    float variance_z = calcularVarianza('z');
    
    // Detectar sacudida horizontal
    if (variance_x > SHAKE_THRESHOLD && variance_y < SHAKE_THRESHOLD/2) {
        return SHAKE_LEFT_RIGHT;
    }
    
    // Detectar sacudida vertical
    if (variance_y > SHAKE_THRESHOLD && variance_x < SHAKE_THRESHOLD/2) {
        return SHAKE_UP_DOWN;
    }
    
    // Análisis de inclinación basado en promedio de últimas lecturas
    float avg_x = calcularPromedio('x', 20);
    float avg_y = calcularPromedio('y', 20);
    
    if (avg_x > TILT_THRESHOLD) return TILT_RIGHT;
    if (avg_x < -TILT_THRESHOLD) return TILT_LEFT;
    if (avg_y > TILT_THRESHOLD) return TILT_FORWARD;
    if (avg_y < -TILT_THRESHOLD) return TILT_BACKWARD;
    
    // Detectar doble golpe
    if (detectarDobleGolpe()) {
        return DOUBLE_TAP;
    }
    
    return NO_GESTURE;
}

// Función para calcular varianza en un eje específico
float calcularVarianza(char eje) {
    float sum = 0, sum_sq = 0;
    int count = min(BUFFER_SIZE, 20); // Analizar últimas 20 muestras
    
    for (int i = 0; i < count; i++) {
        int idx = (buffer_index - 1 - i + BUFFER_SIZE) % BUFFER_SIZE;
        float value;
        
        switch(eje) {
            case 'x': value = gesture_buffer[idx].direction_x; break;
            case 'y': value = gesture_buffer[idx].direction_y; break;
            case 'z': value = gesture_buffer[idx].direction_z; break;
            default: return 0;
        }
        
        sum += value;
        sum_sq += value * value;
    }
    
    float mean = sum / count;
    return (sum_sq / count) - (mean * mean);
}

Ejercicios Prácticos de Implementación

1

Lectura Básica del Acelerómetro

Básico 30 min I2C

Objetivo: Implementar la lectura básica de datos del acelerómetro MPU6050 y visualizar los valores en el monitor serie.

Materiales necesarios:

ESP32 DevKit V1
Sensor MPU6050
Jumpers y protoboard
Multímetro (opcional)

Conexiones I2C:

VCC → 3.3V (ESP32)
GND → GND
SDA → GPIO 21
SCL → GPIO 22

2

Detección de Inclinación

Intermedio 45 min LEDs

Objetivo: Crear un sistema que encienda LEDs específicos según la dirección de inclinación del sensor.

Funcionalidades:

LED Norte: Inclinación hacia adelante
LED Sur: Inclinación hacia atrás
LED Este: Inclinación hacia la derecha
LED Oeste: Inclinación hacia la izquierda

3

Reconocimiento de Gestos Complejos

Avanzado 60 min ML

Objetivo: Implementar algoritmos para reconocer gestos complejos como sacudidas, golpes y movimientos circulares.

Gestos a detectar:

Sacudida horizontal/vertical
Doble golpe (double-tap)
Movimiento circular
Gesto de "dibujar" en el aire

4

Sistema LED Reactivo

Experto 90 min RGB

Objetivo: Crear un sistema de LEDs RGB que responda con patrones dinámicos a diferentes gestos detectados.

Características avanzadas:

Transiciones suaves de color
Patrones de animación
Ajuste de intensidad por inclinación
Modos de operación múltiples

Implementación del Control de LEDs

Arduino C++ - Sistema de Control LED

// Definición de pines para LEDs direccionales
#define LED_NORTH  2   // LED Norte (Adelante)
#define LED_SOUTH  4   // LED Sur (Atrás)
#define LED_EAST   16  // LED Este (Derecha)
#define LED_WEST   17  // LED Oeste (Izquierda)

// LEDs RGB para gestos especiales
#define LED_R      25  // Pin Rojo
#define LED_G      26  // Pin Verde
#define LED_B      27  // Pin Azul

// Variables para control de animaciones
unsigned long last_animation_time = 0;
int animation_step = 0;

// Configuración inicial de LEDs
void configurarLEDs() {
    // LEDs direccionales
    pinMode(LED_NORTH, OUTPUT);
    pinMode(LED_SOUTH, OUTPUT);
    pinMode(LED_EAST, OUTPUT);
    pinMode(LED_WEST, OUTPUT);
    
    // LEDs RGB - configurar como PWM
    pinMode(LED_R, OUTPUT);
    pinMode(LED_G, OUTPUT);
    pinMode(LED_B, OUTPUT);
    
    // Configurar canales PWM para LEDs RGB
    ledcSetup(0, 5000, 8); // Canal 0, 5kHz, 8-bit
    ledcSetup(1, 5000, 8); // Canal 1
    ledcSetup(2, 5000, 8); // Canal 2
    
    ledcAttachPin(LED_R, 0);
    ledcAttachPin(LED_G, 1);
    ledcAttachPin(LED_B, 2);
    
    // Test inicial de LEDs
    testLEDs();
}

// Función de prueba de LEDs
void testLEDs() {
    Serial.println("Probando LEDs...");
    
    // Encender LEDs direccionales uno por uno
    digitalWrite(LED_NORTH, HIGH); delay(300);
    digitalWrite(LED_NORTH, LOW);
    digitalWrite(LED_EAST, HIGH); delay(300);
    digitalWrite(LED_EAST, LOW);
    digitalWrite(LED_SOUTH, HIGH); delay(300);
    digitalWrite(LED_SOUTH, LOW);
    digitalWrite(LED_WEST, HIGH); delay(300);
    digitalWrite(LED_WEST, LOW);
    
    // Probar LEDs RGB con colores primarios
    setRGBColor(255, 0, 0); delay(300); // Rojo
    setRGBColor(0, 255, 0); delay(300); // Verde
    setRGBColor(0, 0, 255); delay(300); // Azul
    setRGBColor(0, 0, 0);               // Apagar
    
    Serial.println("Test de LEDs completado");
}

// Función para controlar LEDs RGB con PWM
void setRGBColor(int red, int green, int blue) {
    ledcWrite(0, red);
    ledcWrite(1, green);
    ledcWrite(2, blue);
}

// Función principal para ejecutar acciones según gestos
void ejecutarAccionGesto(GestureType gesto) {
    // Apagar todos los LEDs direccionales
    apagarLEDsDireccionales();
    
    switch(gesto) {
        case TILT_FORWARD:
            digitalWrite(LED_NORTH, HIGH);
            setRGBColor(0, 100, 0); // Verde tenue
            Serial.println("Gesto: Inclinación hacia adelante");
            break;
            
        case TILT_BACKWARD:
            digitalWrite(LED_SOUTH, HIGH);
            setRGBColor(100, 100, 0); // Amarillo
            Serial.println("Gesto: Inclinación hacia atrás");
            break;
            
        case TILT_RIGHT:
            digitalWrite(LED_EAST, HIGH);
            setRGBColor(0, 0, 100); // Azul tenue
            Serial.println("Gesto: Inclinación hacia la derecha");
            break;
            
        case TILT_LEFT:
            digitalWrite(LED_WEST, HIGH);
            setRGBColor(100, 0, 100); // Magenta
            Serial.println("Gesto: Inclinación hacia la izquierda");
            break;
            
        case SHAKE_LEFT_RIGHT:
            animacionSacudidaHorizontal();
            Serial.println("Gesto: Sacudida horizontal");
            break;
            
        case SHAKE_UP_DOWN:
            animacionSacudidaVertical();
            Serial.println("Gesto: Sacudida vertical");
            break;
            
        case DOUBLE_TAP:
            animacionDobleGolpe();
            Serial.println("Gesto: Doble golpe detectado");
            break;
            
        case NO_GESTURE:
        default:
            // Modo ambiente - respiración suave
            animacionAmbiente();
            break;
    }
}

// Animación para sacudida horizontal
void animacionSacudidaHorizontal() {
    for(int i = 0; i < 3; i++) {
        digitalWrite(LED_EAST, HIGH);
        digitalWrite(LED_WEST, LOW);
        setRGBColor(255, 0, 0);
        delay(100);
        
        digitalWrite(LED_EAST, LOW);
        digitalWrite(LED_WEST, HIGH);
        setRGBColor(0, 0, 255);
        delay(100);
    }
    apagarTodosLEDs();
}

// Animación para sacudida vertical
void animacionSacudidaVertical() {
    for(int i = 0; i < 3; i++) {
        digitalWrite(LED_NORTH, HIGH);
        digitalWrite(LED_SOUTH, LOW);
        setRGBColor(0, 255, 0);
        delay(100);
        
        digitalWrite(LED_NORTH, LOW);
        digitalWrite(LED_SOUTH, HIGH);
        setRGBColor(255, 255, 0);
        delay(100);
    }
    apagarTodosLEDs();
}

// Animación para doble golpe
void animacionDobleGolpe() {
    // Efecto de destello blanco
    setRGBColor(255, 255, 255);
    encenderTodosLEDsDireccionales();
    delay(100);
    
    apagarTodosLEDs();
    delay(50);
    
    // Segundo destello más tenue
    setRGBColor(150, 150, 150);
    encenderTodosLEDsDireccionales();
    delay(100);
    
    apagarTodosLEDs();
}

// Animación ambiente (respiración)
void animacionAmbiente() {
    unsigned long current_time = millis();
    
    if (current_time - last_animation_time > 50) {
        // Efecto respiración con seno
        float brightness = (sin(animation_step * 0.1) + 1) * 20; // 0-40
        setRGBColor(brightness, brightness/2, brightness*1.5);
        
        animation_step++;
        last_animation_time = current_time;
    }
}

Proyecto Aplicado: Sistema de Control Gestual Completo

Descripción: Implementación de un sistema completo de reconocimiento gestual que controla un array de LEDs RGB para crear patrones visuales interactivos. Este proyecto integra técnicas avanzadas de procesamiento de señales digitales con interfaces hombre-máquina intuitivas.

Lista de Materiales

Componentes Principales:

ESP32 DevKit V1
Sensor MPU6050 (acelerómetro + giroscopio)
8x LEDs RGB WS2812B (Neopixels)
Resistencia pull-up 4.7kΩ (2 unidades)
Capacitor 1000µF (filtro de alimentación)

Materiales de Construcción:

Protoboard 830 puntos
Jumpers macho-macho (20 unidades)
Fuente de alimentación 5V/2A
Cable USB-C para programación
Carcasa impresa en 3D (opcional)

Arduino C++ - Proyecto Completo

/*
 * Sistema de Control Gestual Completo con ESP32
 * Curso de Mecatrónica UNAM - Módulo 11
 * 
 * Características:
 * - Reconocimiento de 7 tipos de gestos
 * - Control de 8 LEDs RGB (WS2812B)
 * - Algoritmos de filtrado digital
 * - Interfaz serial para debugging
 */

#include <Wire.h>
#include <MPU6050.h>
#include <FastLED.h>

// Configuración de LEDs RGB
#define NUM_LEDS 8
#define DATA_PIN 5
#define LED_TYPE WS2812B
#define COLOR_ORDER GRB

CRGB leds[NUM_LEDS];

// Configuración del sensor
MPU6050 mpu;

// Variables globales del sistema
struct SensorData {
    float ax, ay, az;          // Aceleración calibrada
    float gx, gy, gz;          // Giroscopio
    float magnitude;           // Magnitud total
    unsigned long timestamp;
};

// Buffer circular para análisis temporal
const int BUFFER_SIZE = 100;
SensorData sensor_buffer[BUFFER_SIZE];
int buffer_index = 0;

// Sistema de filtrado digital
class DigitalFilter {
private:
    float alpha;  // Factor de suavizado
    float prev_value;
    
public:
    DigitalFilter(float smoothing = 0.8) : alpha(smoothing), prev_value(0) {}
    
    float filter(float new_value) {
        prev_value = alpha * prev_value + (1 - alpha) * new_value;
        return prev_value;
    }
    
    void reset() { prev_value = 0; }
};

// Filtros para cada eje
DigitalFilter filter_x(0.85);
DigitalFilter filter_y(0.85);
DigitalFilter filter_z(0.85);

// Detector de gestos avanzado
class GestureDetector {
private:
    // Umbrales adaptativos
    float shake_threshold = 1.5;
    float tilt_threshold = 0.4;
    float tap_threshold = 2.5;
    
    // Estados internos
    bool shake_in_progress = false;
    unsigned long last_gesture_time = 0;
    unsigned long gesture_cooldown = 500; // ms
    
public:
    enum GestureType {
        NONE, SHAKE_X, SHAKE_Y, SHAKE_Z,
        TILT_LEFT, TILT_RIGHT, TILT_FORWARD, TILT_BACK,
        DOUBLE_TAP, CIRCLE_CW, CIRCLE_CCW
    };
    
    GestureType detectGesture() {
        if (millis() - last_gesture_time < gesture_cooldown) {
            return NONE;
        }
        
        // Análisis de ventana deslizante (últimas 30 muestras)
        float variance_x = calculateVariance('x', 30);
        float variance_y = calculateVariance('y', 30);
        float variance_z = calculateVariance('z', 30);
        
        float avg_x = calculateAverage('x', 20);
        float avg_y = calculateAverage('y', 20);
        float avg_z = calculateAverage('z', 20);
        
        GestureType detected = NONE;
        
        // Detección de sacudidas
        if (variance_x > shake_threshold && variance_y < shake_threshold/2 && variance_z < shake_threshold/2) {
            detected = SHAKE_X;
        } else if (variance_y > shake_threshold && variance_x < shake_threshold/2 && variance_z < shake_threshold/2) {
            detected = SHAKE_Y;
        } else if (variance_z > shake_threshold && variance_x < shake_threshold/2 && variance_y < shake_threshold/2) {
            detected = SHAKE_Z;
        }
        
        // Detección de inclinaciones
        else if (avg_x > tilt_threshold) detected = TILT_RIGHT;
        else if (avg_x < -tilt_threshold) detected = TILT_LEFT;
        else if (avg_y > tilt_threshold) detected = TILT_FORWARD;
        else if (avg_y < -tilt_threshold) detected = TILT_BACK;
        
        // Detección de doble golpe
        else if (detectDoubleTap()) detected = DOUBLE_TAP;
        
        // Detección de movimiento circular
        else if (detectCircularMotion()) detected = CIRCLE_CW;
        
        if (detected != NONE) {
            last_gesture_time = millis();
        }
        
        return detected;
    }
    
private:
    float calculateVariance(char axis, int samples) {
        float sum = 0, sum_sq = 0;
        int count = min(samples, BUFFER_SIZE);
        
        for (int i = 0; i < count; i++) {
            int idx = (buffer_index - 1 - i + BUFFER_SIZE) % BUFFER_SIZE;
            float value = getAxisValue(sensor_buffer[idx], axis);
            sum += value;
            sum_sq += value * value;
        }
        
        float mean = sum / count;
        return (sum_sq / count) - (mean * mean);
    }
    
    float calculateAverage(char axis, int samples) {
        float sum = 0;
        int count = min(samples, BUFFER_SIZE);
        
        for (int i = 0; i < count; i++) {
            int idx = (buffer_index - 1 - i + BUFFER_SIZE) % BUFFER_SIZE;
            sum += getAxisValue(sensor_buffer[idx], axis);
        }
        
        return sum / count;
    }
    
    float getAxisValue(const SensorData& data, char axis) {
        switch(axis) {
            case 'x': return data.ax;
            case 'y': return data.ay;
            case 'z': return data.az;
            default: return 0;
        }
    }
    
    bool detectDoubleTap() {
        // Implementar detección de doble golpe
        // Buscar dos picos de aceleración separados por ~200ms
        return false; // Simplificado
    }
    
    bool detectCircularMotion() {
        // Implementar detección de movimiento circular
        // Análisis de frecuencia en componentes X e Y
        return false; // Simplificado
    }
};

GestureDetector detector;

// Sistema de efectos LED
class LEDEffects {
public:
    void rainbow(uint8_t speed = 5) {
        static uint8_t hue = 0;
        for(int i = 0; i < NUM_LEDS; i++) {
            leds[i] = CHSV(hue + i * 255/NUM_LEDS, 255, 255);
        }
        hue += speed;
        FastLED.show();
    }
    
    void wave(CRGB color, uint8_t speed = 10) {
        static uint8_t pos = 0;
        fadeToBlackBy(leds, NUM_LEDS, 50);
        
        leds[pos % NUM_LEDS] = color;
        leds[(pos + 1) % NUM_LEDS] = color;
        
        pos += speed;
        FastLED.show();
    }
    
    void sparkle(CRGB color) {
        fadeToBlackBy(leds, NUM_LEDS, 30);
        leds[random(NUM_LEDS)] = color;
        FastLED.show();
    }
    
    void solid(CRGB color) {
        fill_solid(leds, NUM_LEDS, color);
        FastLED.show();
    }
    
    void clear() {
        fill_solid(leds, NUM_LEDS, CRGB::Black);
        FastLED.show();
    }
};

LEDEffects effects;

void setup() {
    Serial.begin(115200);
    
    // Inicializar comunicación I2C
    Wire.begin();
    Wire.setClock(400000);
    
    // Inicializar MPU6050
    Serial.println("Inicializando sistema gestual...");
    mpu.initialize();
    
    if (!mpu.testConnection()) {
        Serial.println("Error: MPU6050 no conectado");
        while(1);
    }
    
    // Configurar sensor
    mpu.setFullScaleAccelRange(MPU6050_ACCEL_FS_4);
    mpu.setFullScaleGyroRange(MPU6050_GYRO_FS_500);
    mpu.setDLPFMode(MPU6050_DLPF_BW_42);
    
    // Inicializar LEDs
    FastLED.addLeds<LED_TYPE, DATA_PIN, COLOR_ORDER>(leds, NUM_LEDS);
    FastLED.setBrightness(120);
    
    // Test de inicio
    effects.rainbow(20);
    delay(2000);
    effects.clear();
    
    Serial.println("Sistema listo. Detectando gestos...");
}

void loop() {
    // Leer sensores
    int16_t ax_raw, ay_raw, az_raw;
    int16_t gx_raw, gy_raw, gz_raw;
    
    mpu.getMotion6(&ax_raw, &ay_raw, &az_raw, &gx_raw, &gy_raw, &gz_raw);
    
    // Convertir a unidades físicas y filtrar
    float ax = filter_x.filter(ax_raw / 16384.0);
    float ay = filter_y.filter(ay_raw / 16384.0);
    float az = filter_z.filter((az_raw / 16384.0) - 1.0); // Restar gravedad
    
    // Almacenar en buffer
    sensor_buffer[buffer_index] = {
        ax, ay, az,
        gx_raw / 131.0, gy_raw / 131.0, gz_raw / 131.0,
        sqrt(ax*ax + ay*ay + az*az),
        millis()
    };
    
    buffer_index = (buffer_index + 1) % BUFFER_SIZE;
    
    // Detectar y procesar gestos cada 20ms
    static unsigned long last_detection = 0;
    if (millis() - last_detection > 20) {
        GestureDetector::GestureType gesture = detector.detectGesture();
        processGesture(gesture);
        last_detection = millis();
    }
    
    delay(10); // 100Hz de muestreo
}

void processGesture(GestureDetector::GestureType gesture) {
    switch(gesture) {
        case GestureDetector::SHAKE_X:
            effects.wave(CRGB::Red, 15);
            Serial.println("Sacudida en X");
            break;
            
        case GestureDetector::SHAKE_Y:
            effects.wave(CRGB::Green, 15);
            Serial.println("Sacudida en Y");
            break;
            
        case GestureDetector::SHAKE_Z:
            effects.wave(CRGB::Blue, 15);
            Serial.println("Sacudida en Z");
            break;
            
        case GestureDetector::TILT_LEFT:
            effects.solid(CRGB::Purple);
            Serial.println("Inclinación izquierda");
            break;
            
        case GestureDetector::TILT_RIGHT:
            effects.solid(CRGB::Orange);
            Serial.println("Inclinación derecha");
            break;
            
        case GestureDetector::TILT_FORWARD:
            effects.solid(CRGB::Cyan);
            Serial.println("Inclinación adelante");
            break;
            
        case GestureDetector::TILT_BACK:
            effects.solid(CRGB::Yellow);
            Serial.println("Inclinación atrás");
            break;
            
        case GestureDetector::DOUBLE_TAP:
            effects.sparkle(CRGB::White);
            Serial.println("Doble golpe");
            break;
            
        case GestureDetector::CIRCLE_CW:
            effects.rainbow(30);
            Serial.println("Movimiento circular");
            break;
            
        default:
            // Modo ambiente
            effects.rainbow(2);
            break;
    }
}

Troubleshooting y Optimización

Problemas Comunes

Lecturas Erráticas: Verificar conexiones I2C y alimentación estable
Gestos No Detectados: Ajustar umbrales según la aplicación
Falsos Positivos: Implementar filtros digitales más agresivos
Latencia Alta: Optimizar frecuencia de muestreo y algoritmos

Criterios de Evaluación

Precisión: >95% de gestos correctamente detectados
Tiempo de Respuesta: <100ms desde gesto a LED
Robustez: Funcionamiento estable por >2 horas
Eficiencia Energética: <200mA consumo promedio

Optimizaciones Avanzadas

Para aplicaciones críticas, considere implementar algoritmos adaptativos que ajusten automáticamente los umbrales según las condiciones ambientales. La fusión de sensores combinando acelerómetro y giroscopio puede mejorar significativamente la precisión del reconocimiento gestual.

La implementación de redes neuronales embebidas utilizando TensorFlow Lite para microcontroladores puede proporcionar capacidades de reconocimiento de patrones mucho más sofisticadas, permitiendo el reconocimiento de gestos complejos específicos del usuario.