El Gravity Offline Edge AI Gesture & Face Detection Sensor es un módulo de visión compacto que realiza detección de gestos y rostros en tiempo real directamente en el dispositivo. Integra una pequeña cámara y un procesador AI a bordo capaz de reconocer cinco gestos de mano predefinidos y detectar hasta 10 rostros o objetivos de torso superior a distancias de varios metros. Debido a que todo el procesamiento se realiza localmente, el sensor ofrece baja latencia y evita cualquier dependencia de la nube o red.
El sensor soporta interfaces I2C y UART y funciona con una alimentación de 3.3 V a 5 V, lo que lo hace compatible con plataformas como Arduino, ESP32 y Raspberry Pi. Esto hace que el módulo sea útil para control sin contacto, detección de presencia y otras aplicaciones de edge-AI que preservan la privacidad.
A continuación aprenderás cómo conectar el módulo sensor a un Arduino UNO o un ESP32, cómo programarlo para la detección de gestos y rostros, y cómo construir un contador de ocupación de habitaciones con él.
Piezas Requeridas
Para este tutorial necesitarás el Gravity Gesture & Face Detection Sensor de DFRobot. Además, necesitarás un microcontrolador. Yo estoy usando un Arduino UNO y un ESP32-C3 SuperMini, pero otras placas Arduino o ESP32 también funcionarán bien. El único requisito es que soporten una interfaz I2C (o UART).
Gravity Gesture & Face Detection Sensor
Arduino Uno
Cable USB para Arduino UNO
ESP32-C3 SuperMini
Pantalla OLED
Cable USB C
Juego de cables Dupont
Protoboard
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Hardware del Gravity Gesture & Face Detection Sensor
El sensor Gravity integra una cámara compacta y un procesador AI embebido que maneja todo el reconocimiento de gestos y detección de presencia humana localmente. Esto significa que no se requiere una computadora externa ni conexión a la nube: el sensor realiza inferencias en tiempo real, directamente en el módulo. La imagen a continuación muestra el frente y la parte trasera del módulo sensor:
Capacidades de Reconocimiento de Gestos
El módulo es capaz de reconocer cinco gestos de mano predefinidos dentro de un rango de detección de aproximadamente 0.5 a 3 metros. Los gestos soportados incluyen un pulgar hacia arriba 👍, un signo de «OK» 👌, un gesto de «alto» con palma abierta ✋, un signo de «victoria» ✌️ y un gesto de «llámame» 🤙.
Al reconocer un gesto con éxito, el sensor proporciona tanto una salida digital (a través de una interrupción) como una indicación visual: un LED RGB cambia de color según el gesto reconocido. Puedes ver los gestos y los colores correspondientes impresos en la placa:
Detección de Rostros y Torso Superior / Presencia
Más allá de los gestos de mano, el sensor soporta la detección de rostros humanos o presencia de torso superior (cabeza y hombros). Puede detectar y rastrear hasta 10 rostros o cuerpos distintos simultáneamente. Para cada persona detectada, el módulo puede entregar coordenadas posicionales (X/Y dentro del marco de la cámara) y un puntaje de confianza, permitiendo aplicaciones más avanzadas como conteo de personas, automatización basada en presencia o interacciones con conciencia de ubicación.
Campo de Visión, Óptica y Rango de Detección
La cámara integrada tiene un campo de visión diagonal (FOV) de aproximadamente 85°, lo que ofrece una cobertura de escena relativamente amplia adecuada para detectar personas o gestos en una habitación en lugar de solo en un punto central estrecho. El rango efectivo especificado para la detección tanto de gestos como de presencia/rostros abarca desde aproximadamente 0.5 m hasta 3 m. La distancia focal de la cámara es de 1.56 mm, optimizada para detección de ángulo amplio a corto y medio alcance.
Interfaces Eléctricas y de Comunicación
El sensor está diseñado para una amplia compatibilidad con plataformas embebidas típicas. Funciona con un voltaje de alimentación entre 3.3 V y 5 V, con nivel lógico de 3.3 V. Su corriente típica de operación es alrededor de 100 mA, haciéndolo adecuado incluso para sistemas de bajo consumo o basados en batería.
Para la salida de datos e integración, el módulo soporta dos interfaces de comunicación: I2C y UART. El usuario puede seleccionar la interfaz mediante un interruptor de modo en la placa. La dirección I2C por defecto es 0x72. Si se usa UART, la velocidad por defecto es 9600 bps usando protocolo Modbus-RTU.
Ten en cuenta que hay un interruptor en la placa que debe estar configurado en la comunicación elegida (I2C o UART):
Además, el módulo ofrece un pin de salida de interrupción INT (en un header de 2.54 mm) que se pone en bajo cuando se reconoce un gesto. Esto es útil para activar lógica externa o acciones del microcontrolador sin necesidad de sondeo continuo.
Dimensiones Físicas y Factor de Forma
La placa del sensor mide 42 mm × 32 mm, lo que la hace lo suficientemente compacta para integrarse en proyectos o carcasas pequeñas. Se proporcionan orificios de montaje: el espaciamiento para montaje es de 25 mm × 35 mm, y los orificios tienen un diámetro de 3.1 mm. La placa usa un conector PH2.0-4P (o opcionalmente pines estándar de 2.54 mm) para líneas de alimentación y datos.
Especificaciones Técnicas
La siguiente tabla resume las características técnicas del Gravity Offline Edge AI Gesture & Face Detection Sensor
| Parámetro | Descripción |
|---|---|
| Modelo | Gravity Offline Edge AI Gesture & Face Detection Sensor (V1.0) |
| Método de procesamiento | Inferencia AI en el dispositivo para detección de gestos, rostros y torso superior |
| Campo de visión de la cámara | Aproximadamente 85° diagonal |
| Distancia focal | 1.56 mm |
| Rango de detección | 0.5 m a 3 m para gestos y detección de rostro/presencia |
| Reconocimiento de gestos | Cinco gestos predefinidos (OK, pulgar arriba, victoria, stop, hang-loose) |
| Detección de rostro / presencia | Hasta 10 rostros o objetivos de torso superior simultáneamente con salida de posición y confianza |
| Interfaces | I2C (dirección por defecto 0x72) y UART (9600 bps, Modbus-RTU) |
| Salida de interrupción | Pin de interrupción activo en bajo activado al reconocer un gesto |
| Voltaje de operación | 3.3 V a 5 V (nivel lógico 3.3 V) |
| Corriente de operación | ~100 mA típico |
| Indicación de estado | LED RGB con retroalimentación de color según el gesto |
| Conector | PH2.0-4P o pads de header de 2.54 mm |
| Dimensiones de la placa | 42 mm × 32 mm |
| Montaje | Orificios de 3.1 mm con espaciamiento de 25 mm × 35 mm |
| Soporte de software | Librería Arduino / ESP32, MakeCode, Mind+ |
Conectando Gravity Gesture & Face Detection Sensor a Arduino
Puedes conectar el Gravity Gesture & Face Detection Sensor vía I2C o UART. Usaremos la interfaz I2C, ya que es más rápida y permite conectar múltiples dispositivos al mismo bus. El siguiente diagrama de conexiones muestra cómo conectar el sensor a un Arduino UNO:
Comienza conectando GND del Arduino a GND del sensor. Luego conecta la salida de 5V (o la de 3.3V) al pin VCC del sensor. Finalmente, conecta SDA/A4 a D/T y SCL/A5 a C/R.
¡Asegúrate de que el interruptor de comunicación en la placa del sensor esté en I2C y no en UART!
Instalar Librerías
Antes de poder usar el Gravity Gesture & Face Detection Sensor necesitas instalar la DFRobot_GestureFaceDetection librería. Abre el LIBRARY MANAGER, escribe «DFRobot_GestureFaceDetection» en la barra de búsqueda y presiona INSTALL para instalar la librería como se muestra a continuación:
Probablemente verás un diálogo pidiéndote instalar dependencias de la librería. Simplemente presiona INSTALL ALL:
Ahora estás listo para probar algunos ejemplos de código.
Ejemplo de Código: Reconocimiento de Gestos
Este primer ejemplo de código muestra cómo funciona el reconocimiento de gestos:
#include "DFRobot_GestureFaceDetection.h"
DFRobot_GestureFaceDetection_I2C gfd(0x72);
void setup() {
Serial.begin(115200);
gfd.begin(&Wire);
gfd.setGestureDetectThres(60);
gfd.setDetectThres(100);
Serial.println("running...");
}
void loop() {
static char text[100];
uint16_t gestureType = gfd.getGestureType();
uint16_t gestureScore = gfd.getGestureScore();
if (gestureType > 0) {
sprintf(text, "Gesture: %d, score: %d\n", gestureType, gestureScore);
Serial.print(text);
delay(1000);
}
delay(100);
}
Includes
Comenzamos incluyendo la DFRobot_GestureFaceDetection librería que provee la funcionalidad de detección de gestos y rostros.
Objetos
Luego creamos una instancia de la clase de detección de gestos y rostros. Este objeto se usará más adelante para inicializar la comunicación, configurar umbrales y obtener resultados de detección.
DFRobot_GestureFaceDetection_I2C gfd(0x72);
El constructor recibe la dirección I2C del sensor DFRobot. La dirección por defecto es 0x72, pero puedes configurar la dirección I2C en el rango 0x01 – 0xF6 llamando a la función setDeviceAddr(addr).
Función Setup
El bloque setup inicializa el puerto serial, comienza la comunicación con el sensor de gestos y configura su umbral de detección. Todo lo que está dentro de setup se ejecuta una vez cuando la placa se enciende o reinicia.
void setup() {
Serial.begin(115200);
gfd.begin(&Wire);
gfd.setGestureDetectThres(60);
Serial.println("running...");
}
El umbral de detección de gestos varía entre 0 y 100 y determina la sensibilidad para detectar gestos. Un valor más bajo aumenta la sensibilidad pero puede resultar en más falsas detecciones, mientras que un valor más alto requiere gestos más claros pero reduce las falsas detecciones.
Función Loop
La función loop se ejecuta continuamente, consultando el sensor para nueva información de gestos e imprimiendo resultados cuando se detecta algo.
El programa solicita el tipo de gesto actual al sensor.
uint16_t gestureType = gfd.getGestureType();
El valor devuelto identifica qué gesto, si alguno, detectó el sensor. Un valor cero significa que no se reconoció ningún gesto. La siguiente tabla muestra los IDs para los diferentes tipos de gestos devueltos por la función getGestureType() y el color correspondiente del LED a bordo:
| ID | Gesto | Icono | Color del LED |
|---|---|---|---|
| 1 | Pulgar arriba | 👍 | Azul |
| 2 | OK | 👌 | Verde |
| 3 | Stop | 🤚 | Rojo |
| 4 | Victoria | ✌️ | Amarillo |
| 5 | Llámame | 🤙 | Púrpura |
Para cada gesto luego recuperamos la puntuación del gesto llamando a:
uint16_t gestureScore = gfd.getGestureScore();
Esta puntuación indica cuán confiable está el sensor en el gesto detectado. Puntuaciones más altas representan detección más confiable. El puntaje de confianza está en el rango 0…100.
Si se detectó un gesto, el sketch formatea un mensaje de texto y lo imprime en el Monitor Serial.
if (gestureType > 0) {
sprintf(text, "Gesture: %d, score: %d\n", gestureType, gestureScore);
Serial.print(text);
delay(1000);
}
La sentencia condicional verifica que gestureType sea mayor que cero. La función sprintf escribe la información del gesto en un buffer de caracteres, que luego se imprime. Un retardo de un segundo da tiempo al usuario para leer la salida y evita mensajes repetidos excesivos.
Salida en el Monitor Serial
Si ejecutas el programa y haces gestos frente a la cámara deberías ver los resultados de detección impresos en el Monitor Serial:
Ejemplo de Código: Detección de Rostros
El siguiente ejemplo de código demuestra cómo realizar la detección de rostros:
#include "DFRobot_GestureFaceDetection.h"
DFRobot_GestureFaceDetection_I2C gfd(0x72);
void setup() {
Serial.begin(115200);
gfd.begin(&Wire);
gfd.setFaceDetectThres(60);
}
void loop() {
static char text[100];
if (gfd.getFaceNumber() > 0) {
uint16_t faceScore = gfd.getFaceScore();
uint16_t faceX = gfd.getFaceLocationX();
uint16_t faceY = gfd.getFaceLocationY();
sprintf(text, "Face:(x=%d, y=%d, score=%d)\n", faceX, faceY, faceScore);
Serial.print(text);
delay(1000);
}
delay(100);
}
Includes y Objetos
Como antes, comenzamos incluyendo la librería DFRobot_GestureFaceDetection y creando el objeto de detección de gestos y rostros gfd:
#include "DFRobot_GestureFaceDetection.h" DFRobot_GestureFaceDetection_I2C gfd(0x72);
Función Setup
El bloque setup inicializa el puerto serial, comienza la comunicación con el sensor y configura el umbral de detección para rostros:
void setup() {
Serial.begin(115200);
gfd.begin(&Wire);
gfd.setFaceDetectThres(60);
}
El umbral de detección varía entre 0 y 100 y valores más bajos facilitan la detección de rostros pero a costa de más falsas detecciones.
Función Loop
La función loop se ejecuta continuamente y verifica detecciones de rostros. Si el número de rostros detectados es mayor que cero, recuperamos el puntaje de confianza y la ubicación x,y del rostro detectado:
if (gfd.getFaceNumber() > 0) {
uint16_t faceScore = gfd.getFaceScore();
uint16_t faceX = gfd.getFaceLocationX();
uint16_t faceY = gfd.getFaceLocationY();
Luego imprimimos esta información en el Monitor Serial:
sprintf(text, "Face:(x=%d, y=%d, score=%d)\n", faceX, faceY, faceScore);
Serial.print(text);
Si apuntas la cámara del sensor a tu rostro deberías ver los resultados de detección impresos:
Ejemplo de Código: Contador de Ocupación de Habitación
En este último ejemplo construiremos un sensor de ocupación de habitación que cuenta las personas en una sala y muestra el contador en un OLED. Podrías construir esto con un Arduino también, pero voy a usar un ESP32-C3 SuperMini para variar.
El siguiente diagrama de conexiones muestra cómo conectar el sensor de detección de rostros y el OLED al ESP32:
Tanto el sensor de detección de rostros como el OLED están conectados al bus I2C, que está en los pines 8 (SDA) y 9 (SCL) del ESP32 SuperMini. De manera similar, VCC y GND del sensor y del OLED están conectados a 3.3V y GND del SuperMini. La imagen a continuación muestra esta conexión en una protoboard:
Y aquí está el código para contar el número de personas en una habitación:
#include "DFRobot_GestureFaceDetection.h"
#include "Adafruit_SSD1306.h"
DFRobot_GestureFaceDetection_I2C gfd(0x72);
Adafruit_SSD1306 oled(128, 64, &Wire, -1);
void setup() {
Wire.begin();
gfd.begin(&Wire);
gfd.setFaceDetectThres(60);
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
oled.setRotation(3);
oled.setTextSize(6);
oled.setTextColor(WHITE);
}
void loop() {
uint16_t nFaces = gfd.getFaceNumber();
oled.clearDisplay();
oled.setCursor(10, 20);
oled.printf("%d", nFaces);
oled.display();
delay(100);
}
Includes
El código comienza incluyendo las librerías para el sensor de detección de rostros y el OLED. Si no has usado la Adafruit_SSD1306 librería antes, necesitarás instalarla vía el LIBRARY MANAGER:
Objetos
Luego creamos los objetos para el sensor y el OLED:
DFRobot_GestureFaceDetection_I2C gfd(0x72); Adafruit_SSD1306 oled(128, 64, &Wire, -1);
Como ambos dispositivos están conectados al bus I2C, necesitan tener direcciones I2C diferentes. Pero el sensor tiene la dirección 0x72 y el OLED típicamente tiene la dirección 0x3C, así que no hay conflicto. Pero si no aparece nada en la pantalla o el sensor no funciona, revisa las direcciones I2C y asegúrate de que no sean iguales.
Función Setup
En la función setup inicializamos el sensor y el OLED: Ten en cuenta que la dirección I2C para el OLED se establece aquí y no en el constructor:
void setup() {
Wire.begin();
gfd.begin(&Wire);
gfd.setFaceDetectThres(60);
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
oled.setRotation(3);
oled.setTextSize(6);
oled.setTextColor(WHITE);
}
Función Loop
El Gravity Gesture & Face Detection Sensor hace muy simple contar personas. Simplemente llamamos a la función getFaceNumber() para obtener el número de rostros/personas detectadas. Ten en cuenta que el reconocimiento facial está limitado a 10 rostros. Una vez que tenemos el número de rostros (nFaces), simplemente lo mostramos en el OLED.
void loop() {
uint16_t nFaces = gfd.getFaceNumber();
oled.clearDisplay();
oled.setCursor(10, 20);
oled.printf("%d", nFaces);
oled.display();
delay(100);
}
El tamaño pequeño del OLED, el ESP32 SuperMini y el sensor de detección de rostros te permite construir un contador de ocupación de habitación muy compacto. Y dado que el ESP32 soporta Wi-Fi, podrías enviar fácilmente el contador de personas a un servidor, por ejemplo, para controlar la temperatura en una habitación.
Conclusiones
En este tutorial aprendiste cómo conectar el Gravity Gesture & Face Detection Sensor a un Arduino UNO o un ESP32. También aprendiste cómo reconocer gestos, cómo detectar rostros y cómo construir un sensor de ocupación de habitación.
Te recomiendo que leas el DFRobot Wiki para más información sobre el Gravity Gesture & Face Detection Sensor. También echa un vistazo a su repositorio github para más ejemplos de código.
La detección de gestos del sensor es bastante fiable y rápida. En contraste con sensores de gestos más simples que detectan gestos básicos como deslizar hacia arriba o abajo, el Gravity Gesture Sensor detecta gestos más complejos pero también es un poco más grande y tiene una cámara con mayor consumo de energía.
Para información sobre sensores de gestos más pequeños y simples, consulta nuestros tutoriales PAJ7620U2 Gesture Sensor with Arduino y APDS-9960 Gesture and Color Sensor with Arduino.
Si quieres detectar objetos en lugar de rostros, echa un vistazo a los tutoriales Train an Object Detection Model with Edge Impulse for ESP32-CAM, Object Detection with ESP32-CAM and YOLO y Getting Started with HUSKYLENS 2 and Arduino/ESP32 .
Finalmente, para otra solución de sensor de ocupación, te sugiero el tutorial Edge AI Room Occupancy Sensor with ESP32 and Person Detection.
Si tienes alguna pregunta o sugerencia, no dudes en dejarlas en la sección de comentarios.
¡Feliz bricolaje ; )
