Sensor de gestos PAJ7620U2 con Arduino

En este tutorial aprenderás a usar el sensor de gestos PAJ7620U2 con Arduino u otros microcontroladores comunes como el ESP32 o ESP8266.

Vamos a utilizar tres librerías diferentes de Arduino para reconocer gestos con el sensor PAJ7620U2. Además, usaremos la detección de gestos del PAJ7620U2 para controlar la posición de un servo.

Si buscas otros sensores de gestos, echa un vistazo a nuestros tutoriales sobre el APDS-9930 y el APDS-9960 Sensor de Gestos.

Componentes necesarios

Para este proyecto necesitarás un sensor PAJ7620U2 y un microcontrolador. Yo utilicé un Arduino Uno, pero cualquier otro Arduino o un ESP32/ESP8266 funcionará igual de bien, siempre que tenga salida de 3.3V. Uno de los ejemplos también usa un servo, pero no es imprescindible para este proyecto.

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.

Características del sensor de gestos PAJ7620U2

El PAJ7620U2 es un sensor de detección de gestos muy pequeño (5.2x3x1.88 mm). Puede reconocer 13 gestos humanos
con la mano, como mover hacia arriba, abajo, izquierda, derecha, adelante, atrás, círculo en sentido horario, antihorario, movimiento en sentido horario, saludar y combinaciones de algunos gestos, por ejemplo, arriba-abajo.

Ten en cuenta que también existe un sensor PAJ7620 que es muy similar al PAJ7620U2, pero solo reconoce 9 gestos.

El PAJ7620U2 tiene dos modos de detección: rápido y lento. La velocidad de gesto es de 60°/s a 600°/s en modo lento (normal) y de 60°/s a 1200°/s en modo rápido (gaming).

El chip está diseñado para funcionar entre 2.8V y 3.6V, con un consumo de corriente de solo 2.82 mA, y se comunica mediante una interfaz I2C de hasta 400 kbit/s.

Para información más detallada, consulta la hoja de datos del PAJ7620U2 enlazada a continuación:

Placa adaptadora para PAJ7620U2

El chip PAJ7620U2 es demasiado pequeño para conectarlo directamente a un Arduino. Normalmente, necesitarás una placa adaptadora como la que se muestra a continuación:

La mayoría de las placas adaptadoras para el PAJ7620U2 tienen los siguientes cinco pines:

• VIN: Alimentación (2.8 – 3.6V)
• GND: Tierra
• SDA: Señal de datos I2C
• SCL: Señal de reloj I2C
• INT: Pin de interrupción

En la siguiente sección te muestro cómo conectar una placa adaptadora PAJ7620U2 a un Arduino.

Conexión del PAJ7620U2 a Arduino

Gracias a la interfaz I2C del PAJ7620U2, conectarlo a un Arduino es muy sencillo. Primero, conecta el pin SCL de la placa adaptadora del PAJ7620U2 al A5 del Arduino. De igual forma, conecta SDA al A4 del Arduino. Después, conecta GND a GND y 3.3V a VCC del PAJ7620U2.

Asegúrate de usar 3.3V como fuente de alimentación. El sensor PAJ7620U2 no está diseñado para 5V y las placas adaptadoras para el PAJ7620U2 normalmente no tienen regulador de voltaje.

Código para detectar gestos con el PAJ7620U2

Antes de poder escribir código para detectar gestos con el PAJ7620U2, necesitamos instalar una librería. Yo elegí la PAJ7620U2 Library de Seeed-Studio. Para instalar esta librería, abre el Library Manager, busca “PAJ7620”, encuentra la librería «Gesture PAJ7620» de Seeed-Studio y haz clic en INSTALL

Con la librería instalada, vamos a escribir un código de prueba para probar el sensor. Sube el siguiente código, abre el Serial Monitor y mueve tu mano frente al sensor a una distancia de unos 5 cm.

#include "Wire.h"
#include "paj7620.h"

void setup() {
  Serial.begin(9600);
  if (paj7620Init()) {
    Serial.println("Could not initalize Sensor!");
  }
}

void loop() {
  uint8_t data = 0;

  if (!paj7620ReadReg(0x43, 1, &data)) {
    if (data == GES_RIGHT_FLAG) Serial.println("Right");
    if (data == GES_LEFT_FLAG) Serial.println("Left");
    if (data == GES_UP_FLAG) Serial.println("Up");
    if (data == GES_DOWN_FLAG) Serial.println("Down");
  }
  delay(100);
}

Deberías ver la siguiente salida en tu Serial Monitor después de pasar la mano por el sensor en las cuatro direcciones:

La imagen de abajo muestra la orientación del sensor y las direcciones en las que debes mover la mano sobre el sensor para obtener las lecturas de gestos correspondientes:

Instalar la versión actualizada de la librería PAJ7620U2

A partir de octubre de 2024, la librería PAJ7620U2 de Seeed-Studio que se puede instalar desde el Library Manager está limitada a la versión 1.0.0. Aunque Seeed-Studio ha publicado una versión actualizada 2.0.0, no se puede instalar desde el Library Manager. En esta sección te muestro cómo instalar y usar la librería actualizada.

¡Antes de instalar la versión 2.0.0, asegúrate de desinstalar primero la versión 1.0.0! Puedes hacerlo abriendo el Library Manager, buscando «PAJ7620» y pulsando «UNINSTALL» en la librería PAJ7620U2 de Seeed-Studio.

Luego ve al Grove_Gesture repo, haz clic en el botón verde «Code» y luego pulsa «Download ZIP», lo que descargará un archivo llamado «Grove_Gesture-master.zip» en tu ordenador.

Después puedes instalar esta librería ZIP desde Sketch -> Include Library -> Add .ZIP Library ...

A continuación tienes un ejemplo sencillo que utiliza la versión actualizada de la librería PAJ7620U2 para reconocer cuatro gestos (Arriba, Abajo, Izquierda, Derecha):

#include "Gesture.h"

paj7620 Gesture;

void setup() {
  Serial.begin(9600);
  if (!Gesture.init()) {
    Serial.println("PAJ7620U2 initialization failed");
  }
}

void loop() {
  paj7620_gesture_t result;
  if (Gesture.getResult(result)) {
    if (result == UP) Serial.println("Up");
    if (result == DOWN) Serial.println("Down");
    if (result == LEFT) Serial.println("Left");
    if (result == RIGHT) Serial.println("Right");
  }
  delay(100);
}

Es básicamente el mismo ejemplo que el mostrado para la versión antigua 1.0.0 de la librería. Pero puedes ver que el nuevo código es un poco más elegante, ya que ahora hay un Gesture y un result objeto.

El Grove_Gesture repo tiene otros ejemplos que demuestran cómo reconocer 9 gestures o 15 gestures. Sin embargo, si miras el código, es bastante complejo y, sinceramente, poco claro. Por eso, en la siguiente sección te muestro otra librería, mucho más fácil de usar si quieres detectar gestos más complejos.

Instalar la librería RevEng_PAJ7620

En este ejemplo vamos a usar la RevEng_PAJ7620 Library para detectar 9 gestos. Para instalar esta librería, abre el Library Manager, busca “RevEng PAJ7620”, encuentra la librería «RevEng PAJ7620» de Aaron S. Crandall y haz clic en INSTALL:

Y aquí tienes el ejemplo de código que usa la librería RevEng PAJ7620 para reconocer 9 gestos diferentes:

#include "RevEng_PAJ7620.h"

RevEng_PAJ7620 sensor = RevEng_PAJ7620();

void setup() {
  Serial.begin(9600);
  if (!sensor.begin()) {
    Serial.print("PAJ7620U2 initialization failed");
  }
}

void loop() {
  Gesture gesture = sensor.readGesture();

  switch (gesture) {
    case GES_FORWARD:
      Serial.println("FORWARD");
      break;
    case GES_BACKWARD:
      Serial.println("BACKWARD");
      break;
    case GES_LEFT:
      Serial.println("LEFT");
      break;
    case GES_RIGHT:
      Serial.println("RIGHT");
      break;
    case GES_UP:
      Serial.println("UP");
      break;
    case GES_DOWN:
      Serial.println("DOWN");
      break;
    case GES_CLOCKWISE:
      Serial.println("CLOCKWISE");
      break;
    case GES_ANTICLOCKWISE:
      Serial.println("ANTICLOCKWISE");
      break;
    case GES_WAVE:
      Serial.println("WAVE");
      break;
  }
}

Como puedes ver, es muy sencillo. Primero, incluimos la librería y creamos el objeto del sensor. En la función setup inicializamos la comunicación serie y el sensor. Y en la función loop leemos un gesto y usamos un switch para mostrar qué gesto se ha detectado.

He comprobado que los gestos de arriba, abajo, izquierda, derecha, adelante y atrás se detectan de forma fiable. Sin embargo, el sensor tiene dificultades para detectar los gestos de giro horario, antihorario y saludo. Puede que necesites algo de práctica para que funcionen bien.

En la siguiente sección vamos a usar el PAJ7620U2 para controlar un servo mediante gestos.

Controlar un servo con el sensor de gestos PAJ7620U2

Primero necesitamos conectar el servo al Arduino. Si tienes uno de esos pequeños SG90 Micro Servos puedes conectarlos directamente al Arduino (no necesitas una fuente de alimentación aparte). Solo conecta el cable rojo (pin central) del servo a 5V, el cable marrón a tierra (GND) y el cable naranja/amarillo al pin 13, como se muestra abajo.

Si necesitas más información sobre cómo conectar y usar estos servos, consulta el tutorial How to control servo motors with Arduino correspondiente.

El siguiente código utiliza la versión actualizada de la PAJ7620U2 Library by Seeed-Studio (V2.0.0). Detecta cuatro gestos y posiciona el servo en consecuencia.

#include "Gesture.h"
#include "Servo.h"

paj7620 sensor;
Servo servo;

const int servoPin = 13;

void setup() {
  sensor.init();
  servo.attach(servoPin);
  servo.write(90);
}

void loop() {
  paj7620_gesture_t gesture;
  if (sensor.getResult(gesture)) {
    if (gesture == UP) servo.write(90);
    if (gesture == DOWN) servo.write(90);
    if (gesture == LEFT) servo.write(170);
    if (gesture == RIGHT) servo.write(10);
  }
}

Primero, incluimos la librería estándar Servo library (no es necesario instalar ninguna librería). Luego creamos el objeto servo y definimos el pin al que está conectado el servo (servoPin).

En la función setup adjuntamos el servo al pin correspondiente y lo orientamos inicialmente a 90°. En la función loop, reemplazamos las llamadas a print por comandos write al servo. Para un gesto de arriba o abajo, movemos el servo a la posición de 90°. Un gesto a la izquierda mueve el servo a 10° y un gesto a la derecha lo mueve a 170°. El siguiente vídeo corto muestra el código en acción:

Y aquí tienes el mismo código usando la RevEng_PAJ7620 Library. Funciona igual, aunque me ha parecido un poco menos sensible, aunque puede ser solo una impresión.

#include "RevEng_PAJ7620.h"
#include "Servo.h"

RevEng_PAJ7620 sensor = RevEng_PAJ7620();
Servo servo;

const int servoPin = 13;

void setup() {
  sensor.begin();
  servo.attach(servoPin);
  servo.write(90);
}

void loop() {
  Gesture gesture = sensor.readGesture();
  if (gesture == GES_UP) servo.write(90);
  if (gesture == GES_DOWN) servo.write(90);
  if (gesture == GES_LEFT) servo.write(170);
  if (gesture == GES_RIGHT) servo.write(10);
}

Con esto ya tienes un control de gestos sencillo para un pequeño servo, que podrías usar, por ejemplo, para abrir o cerrar una caja sin tocarla.

Conclusiones

En este tutorial has aprendido a usar el sensor de gestos PAJ7620U2 con Arduino para detectar gestos usando diferentes librerías.

En comparación con el APDS-9930 o el APDS-9960 Sensor de Gestos, el PAJ7620U2 puede detectar muchos más gestos (hasta 15) frente a los cuatro gestos del APDS-9960 o el único gesto del APDS-9930.

El alcance de los sensores de gestos suele estar limitado a unos 10 cm. Si quieres medir distancias a objetos lejanos con precisión, por ejemplo para aplicaciones de robótica, deberías usar sensores de distancia por infrarrojos como el GP2Y0A710K0F que utilizan triangulación para determinar la distancia al objeto. Aún mejores son los sensores de distancia Time-of-Flight (ToF) como el TOF10120 o el VL53L1X library, que pueden medir distancias de varios metros.

Si tienes cualquier duda, no dudes en dejarla en los comentarios.

¡Feliz cacharreo! ; )