Sensor de Gestos PAJ7620U2 com Arduino

Neste tutorial vais aprender a usar o Sensor de Gestos PAJ7620U2 com Arduino ou outros microcontroladores comuns como o ESP32 ou ESP8266.

Vamos utilizar três bibliotecas diferentes do Arduino para reconhecer gestos com o sensor PAJ7620U2. E vamos usar a deteção de gestos do PAJ7620U2 para controlar a posição de um servo.

Para outros sensores de gestos, consulta os nossos tutoriais para o APDS-9930 e o APDS-9960 Sensor de Gestos.

Componentes Necessários

Para este projeto vais precisar de um sensor PAJ7620U2 e de um microcontrolador. Usei um Arduino Uno, mas qualquer outro Arduino ou ESP32/ESP8266 também serve, desde que forneça uma saída de 3.3V. Um dos exemplos também usa um servo, mas este não é um componente essencial para este projeto.

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 do Sensor de Gestos PAJ7620U2

O PAJ7620U2 é um sensor de deteção de gestos muito pequeno (5.2x3x1.88 mm). Consegue reconhecer 13
gestos de mão humanos, como mover para cima, baixo, esquerda, direita, para a frente, para trás, círculo no sentido dos ponteiros do relógio, círculo no sentido contrário, acenar e combinações de alguns gestos, por exemplo, cima-baixo.

Nota que também existe um sensor PAJ7620, muito semelhante ao PAJ7620U2, mas que só reconhece 9 gestos.

O PAJ7620U2 tem dois modos de deteção: rápido e lento. A velocidade dos gestos vai de 60°/s a 600°/s no modo lento (normal) e de 60°/s a 1200°/s no modo rápido (gaming).

O chip foi desenhado para funcionar entre 2.8V e 3.6V, com um consumo de corrente de apenas 2.82 mA, e comunica via interface I2C até 400 kbit/s.

Para mais informações detalhadas consulta a folha de dados do PAJ7620U2 no link abaixo:

Placa breakout para PAJ7620U2

O chip PAJ7620U2 é demasiado pequeno para o ligares diretamente a um Arduino. Normalmente, vais precisar de uma placa breakout como a mostrada abaixo:

A maioria das placas breakout para o PAJ7620U2 tem os seguintes cinco pinos:

• VIN : Alimentação (2.8 – 3.6V)
• GND : Terra
• SDA : Sinal de dados I2C
• SCL : Sinal de clock I2C
• INT : Pino de interrupção

Na próxima secção mostro-te como ligar uma placa breakout PAJ7620U2 a um Arduino.

Ligar o PAJ7620U2 ao Arduino

Graças à interface I2C do PAJ7620U2, ligá-lo ao Arduino é fácil. Primeiro, liga o pino SCL da placa breakout do PAJ7620U2 ao A5 do Arduino. De forma semelhante, liga o SDA ao A4 do Arduino. Depois, liga o GND ao GND e 3.3V ao VCC do PAJ7620U2.

Certifica-te de que usas 3.3V como alimentação. O sensor PAJ7620U2 não suporta 5V e as placas breakout para o PAJ7620U2 normalmente não têm regulador de tensão.

Código para detetar gestos com o PAJ7620U2

Antes de podermos escrever qualquer código para detetar gestos com o PAJ7620U2, precisamos de instalar uma biblioteca. Optei pela PAJ7620U2 Library da Seeed-Studio. Para instalar esta biblioteca, abre o Library Manager , procura por “PAJ7620”, encontra a biblioteca “Gesture PAJ7620” da Seeed-Studio e clica em INSTALL

Com a biblioteca instalada, vamos escrever algum código de teste para experimentar o sensor. Carrega o código seguinte, abre o Serial Monitor e passa a tua mão em frente ao sensor a cerca de 5cm de distância.

#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);
}

Deves ver a seguinte saída no teu Serial Monitor depois de passares a mão pelo sensor em todas as quatro direções:

A imagem abaixo mostra a orientação do sensor e as direções em que deves mover a mão sobre o sensor para obter as leituras de gestos correspondentes:

Instalar biblioteca PAJ7620U2 atualizada

Em outubro de 2024, a PAJ7620U2 Library da Seeed-Studio disponível no Library Manager está limitada à versão 1.0.0. Embora a Seeed-Studio já tenha lançado a versão 2.0.0, esta não pode ser instalada via Library Manager. Nesta secção mostro-te como instalar e usar a biblioteca atualizada.

Antes de instalares a versão 2.0.0, certifica-te de que desinstalas primeiro a versão 1.0.0! Podes fazer isto abrindo o Library Manager, procurando por “PAJ7620” e carregando em “UNINSTALL” na PAJ7620U2 Library da Seeed-Studio.

Depois vai ao Grove_Gesture repo , clica no botão verde “Code” e depois em “Download ZIP”, o que vai descarregar um ficheiro chamado “Grove_Gesture-master.zip” para o teu computador.

Depois podes instalar esta biblioteca ZIP via Sketch -> Include Library -> Add .ZIP Library ...

Abaixo encontras um exemplo simples que usa a biblioteca PAJ7620U2 atualizada para reconhecer quatro gestos (Cima, Baixo, Esquerda, Direita):

#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);
}

É basicamente o mesmo exemplo mostrado para a biblioteca antiga, versão 1.0.0. Mas podes ver que o novo código é um pouco mais elegante, já que agora existe um Gesture e um result objeto.

O Grove_Gesture repo tem outros exemplos que demonstram como reconhecer 9 gestures ou 15 gestures . No entanto, se olhares para o código, é bastante complexo e, honestamente, pouco prático. Por isso, na próxima secção mostro-te outra biblioteca, muito mais fácil de usar, caso queiras detetar gestos mais complexos.

Instalar biblioteca RevEng_PAJ7620

Neste exemplo vamos usar a RevEng_PAJ7620 Library para detetar 9 gestos. Para instalar esta biblioteca, abre o Library Manager , procura por “RevEng PAJ7620”, encontra a biblioteca “RevEng PAJ7620” de Aaron S. Crandall e clica em INSTALL:

E aqui está o exemplo de código que usa a biblioteca RevEng PAJ7620 para reconhecer 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 podes ver, é muito simples. Primeiro, incluímos a biblioteca e criamos o objeto do sensor. Na função setup inicializamos a comunicação série e o sensor. E na função loop lê-se um gesto e usa-se um switch para imprimir qual o gesto detetado.

Achei que os gestos cima, baixo, esquerda, direita, frente e trás são detetados de forma fiável. No entanto, o sensor teve dificuldades em detetar os gestos de círculo no sentido dos ponteiros do relógio, no sentido contrário e acenar. Pode ser preciso alguma prática para os conseguir detetar.

Na próxima secção vamos usar o PAJ7620U2 para controlar um servo com gestos.

Controlar servo com o Sensor de Gestos PAJ7620U2

Primeiro precisamos de ligar o servo ao Arduino. Se tiveres um daqueles pequenos SG90 Micro Servos então podes ligá-los diretamente ao Arduino (não precisas de uma fonte de alimentação separada). Basta ligar o fio vermelho (pino do meio) do servo ao 5V, o fio castanho ao GND e o fio laranja/amarelo ao pino 13, como mostrado abaixo.

Se precisares de mais informações sobre como ligar e usar estes servos, consulta o How to control servo motors with Arduino tutorial.

O código seguinte usa a PAJ7620U2 Library by Seeed-Studio (V2.0.0) atualizada. Deteta quatro gestos e posiciona o servo em conformidade.

#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);
  }
}

Primeiro, incluímos a Servo library padrão (não é preciso instalar biblioteca). Depois criamos o objeto servo e definimos o pino ao qual o servo está ligado ( servoPin ).

Na função setup anexamos o servo ao pino e orientamos inicialmente o servo a 90°. Na função loop substituímos as chamadas à função print por comandos write para o servo. Para um gesto de cima ou baixo, movemos o servo para a posição de 90°. Um gesto para a esquerda move o servo para 10° e um gesto para a direita move-o para 170°. O pequeno vídeo abaixo mostra o código em ação:

E aqui está o mesmo código usando a RevEng_PAJ7620 Library . Funciona da mesma forma, mas achei-o um pouco menos responsivo, embora possa ser só impressão.

#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);
}

Com isto, já tens um controlo de gestos simples para um pequeno servo, que podes usar, por exemplo, para abrir ou fechar uma caixa sem tocar.

Conclusão

Neste tutorial aprendeste a usar o Sensor de Gestos PAJ7620U2 com um Arduino para detetar gestos usando diferentes bibliotecas.

Em comparação com o APDS-9930 ou o APDS-9960 Sensor de Gestos, o PAJ7620U2 consegue detetar muitos mais gestos (até 15) em comparação com os quatro gestos do APDS-9960 ou o único gesto do APDS-9930 .

O alcance dos Sensores de Gestos é normalmente limitado a cerca de 10 cm. Se quiseres medir distâncias a objetos distantes com precisão, por exemplo para aplicações de robótica, deves usar sensores de distância por infravermelhos como o GP2Y0A710K0F que usam triangulação para determinar a distância ao objeto. Ainda melhores são os sensores de distância Time-of-Flight (ToF) como o TOF10120 ou o VL53L1X library , que conseguem medir distâncias até vários metros.

Se tiveres alguma dúvida, deixa-a na secção de comentários.

Boas experiências ; )