Sensore di gesti PAJ7620U2 con Arduino

In questo tutorial imparerai a usare il sensore di gesti PAJ7620U2 con Arduino o altri microcontrollori comuni come ESP32 o ESP8266.

Useremo tre diverse librerie Arduino per riconoscere i gesti con il sensore PAJ7620U2. Inoltre, sfrutteremo il rilevamento dei gesti del PAJ7620U2 per controllare la posizione di un servo.

Per altri sensori di gesti dai un’occhiata ai nostri tutorial per il APDS-9930 e il APDS-9960 Sensore di Gesti.

Componenti necessari

Per questo progetto ti serviranno un sensore PAJ7620U2 e un microcontrollore. Io ho usato un Arduino Uno, ma va bene qualsiasi altro Arduino o anche un ESP32/ESP8266, purché fornisca un’uscita a 3.3V. Uno degli esempi utilizza anche un servo, ma non è indispensabile per il progetto.

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.

Caratteristiche del sensore di gesti PAJ7620U2

Il PAJ7620U2 è un sensore di rilevamento gesti molto piccolo (5.2x3x1.88 mm). Può riconoscere 13 gesti umani
della mano come movimento su, giù, sinistra, destra, avanti, indietro, cerchio orario, cerchio antiorario, orario, ondeggiamento e combinazioni di alcuni gesti, ad esempio su-giù.

Nota che esiste anche un sensore PAJ7620 molto simile al PAJ7620U2, ma che riconosce solo 9 gesti.

Il PAJ7620U2 ha due modalità di rilevamento: veloce e lenta. La velocità dei gesti va da 60°/s a 600°/s in modalità lenta (normale) e da 60°/s a 1200°/s in modalità veloce (gaming).

Il chip è progettato per funzionare da 2.8V a 3.6V, con un consumo di corrente di soli 2.82 mA, e comunica tramite interfaccia I2C fino a 400 kbit/s.

Per informazioni più dettagliate dai un’occhiata al datasheet del PAJ7620U2 linkato qui sotto:

Breakout board per PAJ7620U2

Il chip PAJ7620U2 è troppo piccolo per collegarlo direttamente ad Arduino. Di solito serve una breakout board come quella mostrata qui sotto:

La maggior parte delle breakout board per PAJ7620U2 ha i seguenti cinque pin:

• VIN : Alimentazione (2.8 – 3.6V)
• GND : Massa
• SDA : Segnale dati I2C
• SCL : Segnale clock I2C
• INT : Pin di interrupt

Nella prossima sezione ti mostro come collegare una breakout board PAJ7620U2 ad Arduino.

Collegare il PAJ7620U2 ad Arduino

Grazie all’interfaccia I2C del PAJ7620U2, collegarlo ad Arduino è semplice. Prima collega il pin SCL della breakout board PAJ7620U2 ad A5 di Arduino. Allo stesso modo, collega SDA ad A4 di Arduino. Poi collega GND a GND e 3.3V a VCC del PAJ7620U2.

Assicurati di usare 3.3V come alimentazione. Il sensore PAJ7620U2 non è compatibile con 5V e le breakout board per PAJ7620U2 di solito non hanno un regolatore di tensione.

Codice per rilevare i gesti con PAJ7620U2

Prima di poter scrivere qualsiasi codice per rilevare i gesti con il PAJ7620U2 dobbiamo installare una libreria. Ho scelto la PAJ7620U2 Library di Seeed-Studio. Per installarla, apri il Library Manager , cerca “PAJ7620”, trova la libreria “Gesture PAJ7620” di Seeed-Studio e clicca su INSTALL

Con la libreria installata, scriviamo un po’ di codice di test per provare il sensore. Carica il seguente codice, apri il Serial Monitor e muovi la mano davanti al sensore a circa 5cm di distanza.

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

Dovresti vedere il seguente output sul Serial Monitor dopo aver passato la mano davanti al sensore in tutte e quattro le direzioni:

L’immagine qui sotto mostra l’orientamento del sensore e le direzioni in cui muovere la mano sopra il sensore per ottenere la lettura del gesto corrispondente:

Installa la versione aggiornata della libreria PAJ7620U2

A ottobre 2024 la PAJ7620U2 Library di Seeed-Studio installabile tramite Library Manager è limitata alla versione 1.0.0. Anche se Seeed-Studio ha rilasciato una versione aggiornata 2.0.0, questa non può essere installata tramite Library Manager. In questa sezione ti mostro come installare e usare la libreria aggiornata.

Prima di installare la versione 2.0.0 assicurati di disinstallare prima la versione 1.0.0! Puoi farlo aprendo il Library Manager, cercando “PAJ7620” e premendo “UNINSTALL” sulla PAJ7620U2 Library di Seeed-Studio.

Poi vai al Grove_Gesture repo , clicca il pulsante verde “Code” e poi premi “Download ZIP”, che scaricherà un file chiamato “Grove_Gesture-master.zip” sul tuo computer.

Puoi poi installare questa libreria ZIP tramite Sketch -> Include Library -> Add .ZIP Library ...

Qui sotto trovi un esempio semplice che usa la versione aggiornata della libreria PAJ7620U2 per riconoscere quattro gesti (Su, Giù, Sinistra, Destra):

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

È praticamente lo stesso esempio mostrato per la vecchia libreria versione 1.0.0. Ma puoi notare che il nuovo codice è un po’ più elegante, dato che ora c’è un Gesture e un result oggetto.

La Grove_Gesture repo contiene altri esempi che mostrano come riconoscere 9 gestures o 15 gestures . Tuttavia, se guardi il codice, è piuttosto complesso e onestamente poco leggibile. Nella prossima sezione ti mostro quindi un’altra libreria, molto più comoda da usare se vuoi rilevare gesti più complessi.

Installa la libreria RevEng_PAJ7620

In questo esempio useremo la RevEng_PAJ7620 Library per rilevare 9 gesti. Per installare questa libreria, apri il Library Manager , cerca “RevEng PAJ7620”, trova la libreria “RevEng PAJ7620” di Aaron S. Crandall e clicca su INSTALL:

Ecco il codice di esempio che usa la libreria RevEng PAJ7620 per riconoscere 9 gesti diversi:

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

Come vedi, è molto semplice. Prima includiamo la libreria e creiamo l’oggetto sensore. Nella funzione setup inizializziamo la comunicazione seriale e il sensore. E nella funzione loop leggiamo un gesto e usiamo uno switch per stampare quale gesto è stato rilevato.

Ho notato che i gesti su, giù, sinistra, destra, avanti e indietro vengono rilevati in modo affidabile. Tuttavia, il sensore ha qualche difficoltà a rilevare i gesti orario, antiorario e wave. Potrebbe volerci un po’ di pratica per farli funzionare.

Nella prossima sezione useremo il PAJ7620U2 per controllare un servo tramite i gesti.

Controllare un servo con il sensore di gesti PAJ7620U2

Per prima cosa dobbiamo collegare il servo ad Arduino. Se hai uno di quei piccoli  SG90 Micro Servos  puoi collegarli direttamente ad Arduino (non serve un’alimentazione separata). Collega semplicemente il filo rosso (pin centrale) del servo a 5V, il filo marrone a massa (GND) e il filo arancione/giallo al pin 13, come mostrato qui sotto.

Se ti serve più info su come collegare e usare questi servi dai un’occhiata al  How to control servo motors with Arduino  tutorial.

Il codice seguente usa la versione aggiornata della PAJ7620U2 Library by Seeed-Studio (V2.0.0). Rileva quattro gesti e posiziona il servo di conseguenza.

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

Per prima cosa includiamo la libreria standard  Servo library , (non serve installare una libreria). Poi creiamo l’oggetto  servo  e definiamo il pin a cui è collegato il servo ( servoPin ).

Nella funzione  setup  agganciamo il servo al pin e lo posizioniamo inizialmente a 90°. Nel loop sostituiamo le chiamate alla funzione  print  con i comandi  write  al servo. Per un gesto su o giù, muoviamo il servo a 90°. Un gesto a sinistra lo porta a 10° e uno a destra a 170°. Il breve video qui sotto mostra il codice in azione:

Ed ecco lo stesso codice usando la RevEng_PAJ7620 Library . Funziona allo stesso modo ma mi è sembrato un po’ meno reattivo, anche se potrebbe essere solo una sensazione.

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

Ora hai un semplice controllo a gesti per un piccolo servo, che puoi usare ad esempio per aprire o chiudere una scatola senza toccarla.

Conclusioni

In questo tutorial hai imparato a usare il sensore di gesti PAJ7620U2 con Arduino per rilevare gesti usando diverse librerie.

Rispetto al APDS-9930 o al APDS-9960 Sensore di Gesti, il PAJ7620U2 può rilevare molti più gesti (fino a 15) rispetto ai quattro gesti del APDS-9960 o al singolo gesto del APDS-9930 .

La portata dei sensori di gesti è di solito limitata a circa 10 cm. Se vuoi misurare con precisione la distanza di oggetti lontani, ad esempio per applicazioni di robotica, dovresti usare sensori di distanza a infrarossi come il GP2Y0A710K0F che usano la triangolazione per determinare la distanza da un oggetto. Ancora meglio sono i sensori di distanza Time-of-Flight (ToF) come il TOF10120 o il VL53L1X library , che possono misurare distanze fino a diversi metri.

Se hai domande sentiti libero di lasciarle nei commenti.

Buon divertimento con i tuoi progetti ; )