Il Gravity Offline Edge AI Gesture & Face Detection Sensor è un modulo di visione compatto che esegue il riconoscimento in tempo reale di gesti e volti direttamente sul dispositivo. Integra una piccola fotocamera e un processore AI onboard in grado di riconoscere cinque gesti predefiniti della mano e rilevare fino a 10 volti o soggetti a mezzo busto a distanze fino a diversi metri. Poiché tutta l’inferenza avviene localmente, il sensore offre bassa latenza ed evita qualsiasi dipendenza da cloud o rete.
Il sensore supporta sia interfacce I2C che UART e funziona con alimentazione da 3,3 V a 5 V, rendendolo compatibile con piattaforme come Arduino, ESP32 e Raspberry Pi. Questo rende il modulo utile per il controllo senza contatto, il rilevamento di presenza e altre applicazioni edge-AI che preservano la privacy.
Nel seguito imparerai come collegare il modulo sensore a un Arduino UNO o a un ESP32, come programmarlo per il riconoscimento di gesti e volti e come costruire un contatore di occupazione di una stanza.
Parti Necessarie
Per questo tutorial ti servirà il Gravity Gesture & Face Detection Sensor di DFRobot. Inoltre, ti servirà un microcontrollore. Io uso un Arduino UNO e un ESP32-C3 SuperMini, ma anche altre schede Arduino o ESP32 andranno bene. L’unico requisito è il supporto per un’interfaccia I2C (o UART).
Gravity Gesture & Face Detection Sensor
Arduino Uno
Cavo USB per Arduino UNO
ESP32-C3 SuperMini
Display OLED
Cavo USB C
Set di fili Dupont
Breadboard
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
Il sensore Gravity integra una fotocamera compatta e un processore AI embedded che gestisce localmente tutto il riconoscimento dei gesti e il rilevamento della presenza umana. Questo significa che non è necessario un computer esterno o una connessione cloud: il sensore esegue l’inferenza in tempo reale, direttamente sul modulo stesso. L’immagine sotto mostra il fronte e il retro del modulo sensore:
Capacità di Riconoscimento dei Gesti
Il modulo è in grado di riconoscere cinque gesti predefiniti della mano entro un raggio di rilevamento di circa 0,5-3 metri. I gesti supportati includono il pollice in su 👍, il segno “OK” 👌, il gesto “stop” con palmo aperto ✋, il segno di “vittoria” ✌️ e il gesto “call-me” 🤙.
Al riconoscimento di un gesto, il sensore fornisce sia un’uscita digitale (tramite interrupt) sia un’indicazione visiva: un LED RGB cambia colore a seconda del gesto riconosciuto. Puoi vedere i gesti e i colori corrispondenti stampati sulla scheda:
Rilevamento di Volti e Presenza a Mezzo Busto
Oltre ai gesti della mano, il sensore supporta il rilevamento di volti umani o presenza a mezzo busto (testa e spalle). Può rilevare e tracciare fino a 10 volti o corpi distinti simultaneamente. Per ogni persona rilevata, il modulo può fornire coordinate posizionali (X/Y nel frame della fotocamera) e un punteggio di confidenza, permettendo applicazioni più avanzate come il conteggio delle persone, automazioni basate sulla presenza o interazioni basate sulla posizione.
Campo Visivo, Ottica e Raggio di Rilevamento
La fotocamera onboard ha un campo visivo diagonale (FOV) di circa 85°, che offre una copertura relativamente ampia della scena, adatta a rilevare persone o gesti in tutta una stanza piuttosto che solo in un punto centrale ristretto. Il raggio di rilevamento efficace specificato per gesti e rilevamento di presenza/volti va da circa 0,5 m fino a 3 m. La lunghezza focale della fotocamera è di 1,56 mm, ottimizzata per questo uso a corto-medio raggio e grandangolare.
Interfacce Elettriche e di Comunicazione
Il sensore è progettato per ampia compatibilità con piattaforme embedded tipiche. Funziona con una tensione di alimentazione tra 3,3 V e 5 V, con livello logico a 3,3 V. La corrente operativa tipica è di circa 100 mA, rendendolo adatto anche a sistemi a basso consumo o a batteria.
Per l’output dati e l’integrazione, il modulo supporta due interfacce di comunicazione: I2C e UART. L’utente può selezionare l’interfaccia tramite un interruttore sulla scheda. L’indirizzo I2C predefinito è 0x72. Se si usa UART, la velocità di trasmissione predefinita è 9600 bps con protocollo Modbus-RTU.
Nota che c’è un interruttore sulla scheda che deve essere impostato sulla comunicazione scelta (I2C o UART):
Inoltre, il modulo offre un pin di uscita interrupt INT (su header da 2,54 mm) che va a livello basso quando viene riconosciuto un gesto. Questo è utile per attivare logiche esterne o azioni del microcontrollore senza dover fare polling continuo.
Dimensioni Fisiche e Form Factor
La scheda sensore misura 42 mm × 32 mm, abbastanza compatta da poter essere integrata in piccoli progetti o contenitori. Sono presenti fori di montaggio: la distanza tra i fori è 25 mm × 35 mm, e i fori hanno un diametro di 3,1 mm. La scheda usa un connettore PH2.0-4P (o opzionalmente fori per header standard da 2,54 mm) per alimentazione e linee dati.
Specifiche Tecniche
La tabella seguente riassume le caratteristiche tecniche del Gravity Offline Edge AI Gesture & Face Detection Sensor
| Parametro | Descrizione |
|---|---|
| Modello | Gravity Offline Edge AI Gesture & Face Detection Sensor (V1.0) |
| Metodo di elaborazione | Inferenza AI on-device per riconoscimento di gesti, volti e mezzo busto |
| Campo visivo fotocamera | Circa 85° diagonale |
| Lunghezza focale | 1,56 mm |
| Raggio di rilevamento | 0,5 m a 3 m per gesti e rilevamento volti/presenza |
| Riconoscimento gesti | Cinque gesti predefiniti (OK, pollice in su, vittoria, stop, hang-loose) |
| Rilevamento volti / presenza | Fino a 10 volti o soggetti a mezzo busto simultaneamente con output di posizione e confidenza |
| Interfacce | I2C (indirizzo predefinito 0x72) e UART (9600 bps, Modbus-RTU) |
| Uscita interrupt | Pin interrupt attivo basso attivato al riconoscimento del gesto |
| Tensione di funzionamento | 3,3 V a 5 V (livello logico 3,3 V) |
| Corrente operativa | ~100 mA tipici |
| Indicazione di stato | LED RGB con feedback colore dipendente dal gesto |
| Connettore | PH2.0-4P o pad header da 2,54 mm |
| Dimensioni scheda | 42 mm × 32 mm |
| Montaggio | Fori da 3,1 mm con distanza 25 mm × 35 mm |
| Supporto software | Libreria Arduino / ESP32, MakeCode, Mind+ |
Collegare il Gravity Gesture & Face Detection Sensor ad Arduino
Puoi collegare il Gravity Gesture & Face Detection Sensor tramite I2C o UART. Useremo l’interfaccia I2C, poiché è più veloce e permette di collegare più dispositivi sullo stesso bus. Il diagramma di collegamento seguente mostra come collegare il sensore a un Arduino UNO:
Inizia collegando il GND di Arduino al GND del sensore. Poi collega l’uscita 5V (o 3,3V) al pin VCC del sensore. Infine, collega SDA/A4 a D/T e SCL/A5 a C/R.
Assicurati che l’interruttore di comunicazione sulla scheda del sensore sia impostato su I2C e non su UART!
Installare le Librerie
Prima di poter usare il Gravity Gesture & Face Detection Sensor devi installare la DFRobot_GestureFaceDetection libreria. Apri il LIBRARY MANAGER, digita “DFRobot_GestureFaceDetection” nella barra di ricerca e premi INSTALL per installare la libreria come mostrato sotto:
Probabilmente vedrai una finestra che ti chiede di installare le dipendenze della libreria. Premi semplicemente INSTALL ALL:
Ora sei pronto per provare qualche esempio di codice.
Esempio di Codice: Riconoscimento Gesti
Questo primo esempio di codice mostra come funziona il riconoscimento dei gesti:
#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);
}
Inclusioni
Iniziamo includendo la DFRobot_GestureFaceDetection libreria che fornisce la funzionalità di riconoscimento gesti e volti.
Oggetti
Successivamente creiamo un’istanza della classe per il riconoscimento gesti e volti. Questo oggetto sarà usato per inizializzare la comunicazione, configurare le soglie e recuperare i risultati del rilevamento.
DFRobot_GestureFaceDetection_I2C gfd(0x72);
Il costruttore riceve l’indirizzo I2C del sensore DFRobot. L’indirizzo predefinito è 0x72 ma puoi configurare l’indirizzo I2C nell’intervallo 0x01 – 0xF6 chiamando la funzione setDeviceAddr(addr).
Funzione Setup
Il blocco setup inizializza la porta seriale, avvia la comunicazione con il sensore gesti e configura la soglia di rilevamento. Tutto ciò che è dentro setup viene eseguito una volta all’accensione o al reset della scheda.
void setup() {
Serial.begin(115200);
gfd.begin(&Wire);
gfd.setGestureDetectThres(60);
Serial.println("running...");
}
La soglia di rilevamento dei gesti varia tra 0 e 100 e determina la sensibilità nel riconoscere i gesti. Un valore più basso aumenta la sensibilità ma può causare più falsi positivi, mentre un valore più alto richiede gesti più chiari ma riduce i falsi rilevamenti.
Funzione Loop
La funzione loop viene eseguita continuamente, interrogando il sensore per nuove informazioni sui gesti e stampando i risultati quando qualcosa viene rilevato.
Il programma richiede al sensore il tipo di gesto attuale.
uint16_t gestureType = gfd.getGestureType();
Il valore restituito identifica quale gesto, se presente, il sensore ha rilevato. Un valore zero significa che nessun gesto è stato riconosciuto. La tabella seguente mostra gli ID per i diversi tipi di gesto restituiti dalla funzione getGestureType() e il colore corrispondente del LED onboard:
| ID | Gesto | Icona | Colore LED |
|---|---|---|---|
| 1 | Pollice in su | 👍 | Blu |
| 2 | OK | 👌 | Verde |
| 3 | Stop | 🤚 | Rosso |
| 4 | Vittoria | ✌️ | Giallo |
| 5 | Call-me | 🤙 | Viola |
Per ogni gesto recuperiamo poi il punteggio di confidenza chiamando:
uint16_t gestureScore = gfd.getGestureScore();
Questo punteggio indica quanto il sensore è sicuro del gesto rilevato. Punteggi più alti rappresentano una rilevazione più affidabile. Il punteggio di confidenza è nell’intervallo 0…100.
Se un gesto è stato rilevato, lo sketch formatta un messaggio di testo e lo stampa sul Monitor Seriale.
if (gestureType > 0) {
sprintf(text, "Gesture: %d, score: %d\n", gestureType, gestureScore);
Serial.print(text);
delay(1000);
}
La condizione verifica che gestureType sia maggiore di zero. La funzione sprintf scrive le informazioni del gesto in un buffer di caratteri, che viene poi stampato. Un ritardo di un secondo dà tempo all’utente di leggere l’output e previene messaggi ripetuti eccessivi.
Output sul Monitor Seriale
Se esegui il programma e fai gesti davanti alla fotocamera dovresti vedere i risultati del rilevamento stampati sul Monitor Seriale:
Esempio di Codice: Rilevamento Volti
Il seguente esempio di codice dimostra come eseguire il rilevamento dei volti:
#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);
}
Inclusioni e Oggetti
Come prima, iniziamo includendo la libreria DFRobot_GestureFaceDetection e creando l’oggetto per il riconoscimento gesti e volti gfd:
#include "DFRobot_GestureFaceDetection.h" DFRobot_GestureFaceDetection_I2C gfd(0x72);
Funzione Setup
Il blocco setup inizializza la porta seriale, avvia la comunicazione con il sensore e configura la soglia di rilevamento per i volti:
void setup() {
Serial.begin(115200);
gfd.begin(&Wire);
gfd.setFaceDetectThres(60);
}
La soglia di rilevamento varia tra 0 e 100 e valori più bassi facilitano il rilevamento dei volti ma a costo di più falsi positivi.
Funzione Loop
La funzione loop gira continuamente e controlla la presenza di volti. Se il numero di volti rilevati è maggiore di zero, recuperiamo il punteggio di confidenza e la posizione x,y del volto rilevato:
if (gfd.getFaceNumber() > 0) {
uint16_t faceScore = gfd.getFaceScore();
uint16_t faceX = gfd.getFaceLocationX();
uint16_t faceY = gfd.getFaceLocationY();
Successivamente stampiamo queste informazioni sul Monitor Seriale:
sprintf(text, "Face:(x=%d, y=%d, score=%d)\n", faceX, faceY, faceScore);
Serial.print(text);
Se punti la fotocamera del sensore verso il tuo volto dovresti vedere i risultati del rilevamento stampati:
Esempio di Codice: Contatore di Occupazione Stanza
In questo ultimo esempio costruiremo un sensore di occupazione stanza che conta le persone presenti e mostra il contatore su un OLED. Potresti farlo anche con un Arduino, ma io userò un ESP32-C3 SuperMini per cambiare un po’.
Il diagramma di collegamento seguente mostra come collegare il sensore di rilevamento volti e l’OLED all’ESP32:
Sia il sensore di rilevamento volti che l’OLED sono collegati al bus I2C, che si trova sui pin 8 (SDA) e 9 (SCL) dell’ESP32 SuperMini. Analogamente, VCC e GND del sensore e dell’OLED sono collegati a 3,3V e GND del SuperMini. L’immagine sotto mostra questo cablaggio su una breadboard:
Ecco il codice per contare il numero di persone in una stanza:
#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);
}
Inclusioni
Il codice inizia includendo le librerie per il sensore di rilevamento volti e per l’OLED. Se non hai mai usato la libreria Adafruit_SSD1306, dovrai installarla tramite il LIBRARY MANAGER:
Oggetti
Successivamente creiamo gli oggetti per il sensore e per l’OLED:
DFRobot_GestureFaceDetection_I2C gfd(0x72); Adafruit_SSD1306 oled(128, 64, &Wire, -1);
Poiché entrambi i dispositivi sono collegati al bus I2C devono avere indirizzi I2C diversi. Il sensore ha l’indirizzo 0x72 e l’OLED tipicamente 0x3C, quindi non c’è conflitto. Se però non appare nulla sul display o il sensore non funziona, controlla gli indirizzi I2C e assicurati che non siano uguali.
Funzione Setup
Nella funzione setup inizializziamo il sensore e l’OLED: nota che l’indirizzo I2C per l’OLED viene impostato qui e non nel costruttore:
void setup() {
Wire.begin();
gfd.begin(&Wire);
gfd.setFaceDetectThres(60);
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
oled.setRotation(3);
oled.setTextSize(6);
oled.setTextColor(WHITE);
}
Funzione Loop
Il Gravity Gesture & Face Detection Sensor rende molto semplice contare le persone. Chiamiamo semplicemente la funzione getFaceNumber() per ottenere il numero di volti/persona rilevati. Nota però che il riconoscimento volti è limitato a 10 volti. Una volta ottenuto il numero di volti (nFaces), lo visualizziamo sull’OLED.
void loop() {
uint16_t nFaces = gfd.getFaceNumber();
oled.clearDisplay();
oled.setCursor(10, 20);
oled.printf("%d", nFaces);
oled.display();
delay(100);
}
La piccola dimensione dell’OLED, dell’ESP32 SuperMini e del sensore di rilevamento volti ti permette di costruire un contatore di occupazione stanza molto compatto. E dato che l’ESP32 supporta il Wi-Fi, potresti facilmente inviare il conteggio persone a un server, per esempio per controllare la temperatura in una stanza.
Conclusioni
In questo tutorial hai imparato come collegare il Gravity Gesture & Face Detection Sensor a un Arduino UNO o a un ESP32. Hai anche imparato a riconoscere gesti, rilevare volti e costruire un sensore di occupazione stanza.
Ti consiglio di leggere il documento DFRobot Wiki per maggiori informazioni riguardo al Gravity Gesture & Face Detection Sensor. Dai anche un’occhiata al loro repository github per altri esempi di codice.
Il rilevamento gesti del sensore è piuttosto affidabile e veloce. A differenza di sensori gestuali più semplici che rilevano gesti elementari come lo swipe verso l’alto o il basso, il Gravity Gesture Sensor riconosce gesti più complessi ma è anche un po’ più grande e ha una fotocamera con un consumo energetico superiore.
Per informazioni su sensori gestuali più piccoli e semplici, consulta i nostri tutorial PAJ7620U2 Gesture Sensor with Arduino e APDS-9960 Gesture and Color Sensor with Arduino.
Se vuoi rilevare oggetti invece di volti, dai un’occhiata ai tutorial Train an Object Detection Model with Edge Impulse for ESP32-CAM, Object Detection with ESP32-CAM and YOLO e Getting Started with HUSKYLENS 2 and Arduino/ESP32 .
Infine, per un’altra soluzione di sensore di occupazione, ti suggerisco il tutorial Edge AI Room Occupancy Sensor with ESP32 and Person Detection.
Se hai domande o suggerimenti, sentiti libero di lasciarli nella sezione commenti.
Buon divertimento con il tinkering ; )
