Capteur de Gestes Gravity & Détection de Visage

Le capteur Gravity Offline Edge AI Gesture & Face Detection est un module de vision compact qui réalise la détection de gestes et de visages en temps réel directement sur l’appareil. Il intègre une petite caméra et un processeur AI embarqué capable de reconnaître cinq gestes de la main prédéfinis et de détecter jusqu’à 10 visages ou cibles de la partie supérieure du corps à plusieurs mètres de distance. Comme toute l’inférence s’exécute localement, le capteur offre une faible latence et évite toute dépendance au cloud ou au réseau.

Le capteur supporte les interfaces I2C et UART et fonctionne sous une alimentation de 3,3 V à 5 V, ce qui le rend compatible avec des plateformes telles qu’Arduino, ESP32 et Raspberry Pi. Cela rend le module utile pour le contrôle sans contact, la détection de présence et d’autres applications edge-AI respectueuses de la vie privée.

Dans ce qui suit, vous apprendrez comment connecter le module capteur à un Arduino UNO ou un ESP32, comment le programmer pour la détection de gestes et de visages, et comment construire un compteur d’occupation de pièce avec celui-ci.

Pièces requises

Pour ce tutoriel, vous aurez besoin du capteur Gravity Gesture & Face Detection de DFRobot. De plus, vous aurez besoin d’un microcontrôleur. J’utilise un Arduino UNO et un ESP32-C3 SuperMini, mais d’autres cartes Arduino ou ESP32 fonctionneront également très bien. La seule exigence est la prise en charge d’une interface I2C (ou UART).

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.

Matériel du capteur Gravity Gesture & Face Detection

Le capteur Gravity intègre une caméra compacte et un processeur AI embarqué qui gère localement toute la reconnaissance de gestes et la détection de présence humaine. Cela signifie qu’aucun ordinateur externe ni connexion cloud n’est nécessaire : le capteur effectue l’inférence en temps réel, directement sur le module lui-même. L’image ci-dessous montre le devant et le dos du module capteur :

Capacités de reconnaissance de gestes

Le module est capable de reconnaître cinq gestes de la main prédéfinis dans une plage de détection d’environ 0,5 à 3 mètres. Les gestes supportés incluent un pouce levé 👍, un signe « OK » 👌, un geste « stop » avec la paume ouverte ✋, un signe « victoire » ✌️, et un geste « appelle-moi » 🤙.

Lorsqu’un geste est reconnu avec succès, le capteur fournit à la fois une sortie numérique (via interruption) et une indication visuelle : une LED RGB change de couleur selon le geste reconnu. Vous pouvez voir les gestes et les couleurs correspondantes imprimés sur la carte :

Détection de visages et de la partie supérieure du corps / détection de présence

Au-delà des gestes de la main, le capteur supporte la détection de visages humains ou de la présence de la partie supérieure du corps (tête et épaules). Il peut détecter et suivre jusqu’à 10 visages ou corps distincts simultanément. Pour chaque personne détectée, le module peut fournir des coordonnées positionnelles (X/Y dans le cadre de la caméra) et un score de confiance, permettant des applications plus avancées telles que le comptage de personnes, l’automatisation basée sur la présence ou les interactions sensibles à la localisation.

Champ de vision, optique et portée de détection

La caméra embarquée a un champ de vision diagonal (FOV) d’environ 85°, ce qui offre une couverture de scène relativement large adaptée à la détection de personnes ou de gestes dans une pièce plutôt que seulement dans un point central étroit. La portée de détection effective spécifiée pour les gestes et la détection de présence/visages s’étend d’environ 0,5 m à 3 m. La focale de la caméra est de 1,56 mm, optimisée pour une détection grand-angle à courte et moyenne distance.

Interfaces électriques et de communication

Le capteur est conçu pour une large compatibilité avec les plateformes embarquées typiques. Il fonctionne sous une tension d’alimentation entre 3,3 V et 5 V, avec un niveau logique 3,3 V. Son courant de fonctionnement typique est d’environ 100 mA, ce qui le rend adapté même aux systèmes basse consommation ou alimentés par batterie.

Pour la sortie des données et l’intégration, le module supporte deux interfaces de communication : I2C et UART. L’utilisateur peut sélectionner l’interface via un interrupteur de mode sur la carte. L’adresse I2C par défaut est 0x72. En mode UART, le débit par défaut est de 9600 bps utilisant le protocole Modbus-RTU.

Notez qu’il y a un interrupteur sur la carte qui doit être positionné sur la communication choisie (I2C ou UART) :

De plus, le module offre une broche de sortie d’interruption INT (sur un connecteur 2,54 mm) qui passe à l’état bas lorsqu’un geste est reconnu. Cela est utile pour déclencher des actions logiques externes ou microcontrôleur sans interrogation continue.

Dimensions physiques et format

La carte du capteur mesure 42 mm × 32 mm, ce qui la rend assez compacte pour être intégrée dans de petits projets ou boîtiers. Des trous de fixation sont prévus : l’espacement pour le montage est de 25 mm × 35 mm, et les trous ont un diamètre de 3,1 mm. La carte utilise un connecteur PH2.0-4P (ou en option des trous pour connecteur standard 2,54 mm) pour l’alimentation et les lignes de données.

Spécifications techniques

Le tableau suivant résume les caractéristiques techniques du capteur Gravity Offline Edge AI Gesture & Face Detection

Paramètre	Description
Modèle	Gravity Offline Edge AI Gesture & Face Detection Sensor (V1.0)
Méthode de traitement	Inférence AI embarquée pour la détection de gestes, visages et partie supérieure du corps
Champ de vision de la caméra	Environ 85° en diagonale
Longueur focale	1,56 mm
Portée de détection	0,5 m à 3 m pour les gestes et la détection de visages/présence
Reconnaissance de gestes	Cinq gestes prédéfinis (OK, pouce levé, victoire, stop, hang-loose)
Détection de visages / présence	Jusqu’à 10 visages ou cibles de la partie supérieure du corps simultanément avec position et score de confiance
Interfaces	I2C (adresse par défaut 0x72) et UART (9600 bps, Modbus-RTU)
Sortie d’interruption	Broche d’interruption active à l’état bas déclenchée lors de la reconnaissance d’un geste
Tension d’alimentation	3,3 V à 5 V (niveau logique 3,3 V)
Courant de fonctionnement	~100 mA typique
Indication d’état	LED RGB avec retour couleur dépendant du geste
Connecteur	PH2.0-4P ou pastilles pour connecteur 2,54 mm
Dimensions de la carte	42 mm × 32 mm
Fixation	Trous de 3,1 mm avec espacement 25 mm × 35 mm
Support logiciel	Bibliothèque Arduino / ESP32, MakeCode, Mind+

Connexion du capteur Gravity Gesture & Face Detection à Arduino

Vous pouvez connecter le capteur Gravity Gesture & Face Detection via I2C ou UART. Nous allons utiliser l’interface I2C, car elle est plus rapide et permet de connecter plusieurs appareils sur le même bus. Le schéma de câblage suivant montre comment connecter le capteur à un Arduino UNO :

Commencez par connecter la masse (GND) de l’Arduino à la masse du capteur. Ensuite, connectez la sortie 5V (ou la sortie 3,3V) au pin VCC du capteur. Enfin, connectez SDA/A4 à D/T et SCL/A5 à C/R.

Assurez-vous que l’interrupteur de communication sur la carte du capteur est bien positionné sur I2C et non UART !

Installation des bibliothèques

Avant de pouvoir utiliser le capteur Gravity Gesture & Face Detection, vous devez installer la DFRobot_GestureFaceDetection bibliothèque. Ouvrez le LIBRARY MANAGER, entrez « DFRobot_GestureFaceDetection » dans la barre de recherche et appuyez sur INSTALL pour installer la bibliothèque comme montré ci-dessous :

Vous verrez probablement une boîte de dialogue vous demandant d’installer les dépendances de la bibliothèque. Appuyez simplement sur INSTALL ALL :

Vous êtes maintenant prêt à essayer quelques exemples de code.

Exemple de code : reconnaissance de gestes

Ce premier exemple de code montre comment fonctionne la reconnaissance de gestes :

#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

Nous commençons par inclure la bibliothèque DFRobot_GestureFaceDetection qui fournit la fonctionnalité de détection de gestes et de visages.

Objets

Ensuite, nous créons une instance de la classe de détection de gestes et de visages. Cet objet sera utilisé plus tard pour initialiser la communication, configurer les seuils et récupérer les résultats de détection.

DFRobot_GestureFaceDetection_I2C gfd(0x72);

Le constructeur reçoit l’adresse I2C du capteur DFRobot. L’adresse par défaut est 0x72, mais vous pouvez configurer l’adresse I2C dans la plage 0x01 – 0xF6 en appelant la fonction setDeviceAddr(addr).

Fonction setup

Le bloc setup initialise le port série, démarre la communication avec le capteur de gestes et configure son seuil de détection. Tout ce qui est dans setup s’exécute une fois au démarrage ou au reset de la carte.

void setup() {
  Serial.begin(115200);
  gfd.begin(&Wire);
  gfd.setGestureDetectThres(60);
  Serial.println("running...");
}

Le seuil de détection des gestes varie entre 0 et 100 et détermine la sensibilité à la détection des gestes. Une valeur plus basse augmente la sensibilité mais peut entraîner plus de fausses détections, tandis qu’une valeur plus élevée nécessite des gestes plus clairs mais réduit le nombre de fausses détections.

Fonction loop

La fonction loop s’exécute en continu, interrogeant le capteur pour obtenir de nouvelles informations sur les gestes et affichant les résultats lorsqu’un geste est détecté.

Le programme demande au capteur le type de geste actuel.

uint16_t gestureType = gfd.getGestureType();

La valeur retournée identifie quel geste, le cas échéant, le capteur a détecté. Une valeur zéro signifie qu’aucun geste n’a été reconnu. Le tableau suivant montre les IDs des différents types de gestes retournés par la fonction getGestureType() et la couleur correspondante de la LED embarquée :

ID	Geste	Icône	Couleur LED
1	Pouce levé	👍	Bleu
2	OK	👌	Vert
3	Stop	🤚	Rouge
4	Victoire	✌️	Jaune
5	Appelle-moi	🤙	Violet

Pour chaque geste, nous récupérons ensuite le score du geste en appelant :

uint16_t gestureScore = gfd.getGestureScore();

Ce score indique la confiance du capteur dans le geste détecté. Des scores plus élevés représentent une détection plus sûre. Le score de confiance est dans la plage 0…100.

Si un geste a été détecté, le sketch formate un message texte et l’affiche dans le moniteur série.

if (gestureType > 0) {
  sprintf(text, "Gesture: %d, score: %d\n", gestureType, gestureScore);
  Serial.print(text);
  delay(1000);
}

La condition vérifie que gestureType est supérieur à zéro. La fonction sprintf écrit l’information du geste dans un tampon de caractères, qui est ensuite affiché. Un délai d’une seconde donne le temps à l’utilisateur de lire la sortie et évite les répétitions excessives.

Sortie sur le moniteur série

Si vous lancez le programme et faites des gestes devant la caméra, vous devriez voir les résultats de détection s’afficher dans le moniteur série :

Exemple de code : détection de visages

Le code suivant montre comment effectuer la détection de visages :

#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 et objets

Comme précédemment, nous commençons par inclure la bibliothèque DFRobot_GestureFaceDetection et créer l’objet de détection de gestes et visages gfd :

#include "DFRobot_GestureFaceDetection.h"

DFRobot_GestureFaceDetection_I2C gfd(0x72);

Fonction setup

Le bloc setup initialise le port série, démarre la communication avec le capteur et configure le seuil de détection pour les visages :

void setup() {
  Serial.begin(115200);
  gfd.begin(&Wire);  
  gfd.setFaceDetectThres(60);
}

Le seuil de détection varie entre 0 et 100 et des valeurs plus basses facilitent la détection des visages mais au prix de plus de fausses détections.

Fonction loop

La fonction loop s’exécute en continu et vérifie la détection de visages. Si le nombre de visages détectés est supérieur à zéro, nous récupérons le score de confiance et la position x,y du visage détecté :

  if (gfd.getFaceNumber() > 0) {
    uint16_t faceScore = gfd.getFaceScore();
    uint16_t faceX = gfd.getFaceLocationX();
    uint16_t faceY = gfd.getFaceLocationY();

Ensuite, nous affichons ces informations dans le moniteur série :

    sprintf(text, "Face:(x=%d, y=%d, score=%d)\n", faceX, faceY, faceScore);
    Serial.print(text);

Si vous pointez la caméra du capteur vers votre visage, vous devriez voir les résultats de détection s’afficher :

Exemple de code : compteur d’occupation de pièce

Dans ce dernier exemple, nous allons construire un capteur d’occupation de pièce qui compte les personnes dans une pièce et affiche le compteur sur un écran OLED. Vous pourriez le faire avec un Arduino aussi, mais je vais utiliser un ESP32-C3 SuperMini pour changer.

Le schéma de câblage suivant montre comment connecter le capteur de détection de visages et l’OLED à l’ESP32 :

Le capteur de détection de visages et l’OLED sont tous deux connectés au bus I2C, qui se trouve sur les broches 8 (SDA) et 9 (SCL) de l’ESP32 SuperMini. De même, VCC et GND du capteur et de l’OLED sont connectés au 3,3 V et à la masse du SuperMini. L’image ci-dessous montre ce câblage sur une breadboard :

Et voici le code pour compter le nombre de personnes dans une pièce :

#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

Le code commence par inclure les bibliothèques pour le capteur de détection de visages et l’OLED. Si vous n’avez pas encore utilisé la bibliothèque Adafruit_SSD1306, vous devrez l’installer via le LIBRARY MANAGER :

Objets

Ensuite, nous créons les objets pour le capteur et l’OLED :

DFRobot_GestureFaceDetection_I2C gfd(0x72);
Adafruit_SSD1306 oled(128, 64, &Wire, -1);

Comme les deux appareils sont connectés au bus I2C, ils doivent avoir des adresses I2C différentes. Le capteur a l’adresse 0x72 et l’OLED a typiquement l’adresse 0x3C, donc il n’y a pas de conflit. Mais si rien n’apparaît à l’écran ou si le capteur ne fonctionne pas, vérifiez les adresses I2C et assurez-vous qu’elles ne sont pas identiques.

Fonction setup

Dans la fonction setup, nous initialisons le capteur et l’OLED : notez que l’adresse I2C pour l’OLED est définie ici et non dans le constructeur :

void setup() {
  Wire.begin();
  gfd.begin(&Wire);
  gfd.setFaceDetectThres(60);

  oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  oled.setRotation(3);
  oled.setTextSize(6);
  oled.setTextColor(WHITE);
}

Fonction loop

Le capteur Gravity Gesture & Face Detection facilite grandement le comptage des personnes. Nous appelons simplement la fonction getFaceNumber() pour obtenir le nombre de visages/personnes détectés. Notez cependant que la reconnaissance faciale est limitée à 10 visages. Une fois que nous avons le nombre de visages (nFaces), nous l’affichons simplement sur l’OLED.

void loop() {
  uint16_t nFaces = gfd.getFaceNumber();
  oled.clearDisplay();
  oled.setCursor(10, 20);
  oled.printf("%d", nFaces);
  oled.display();
  delay(100);
}

La petite taille de l’OLED, de l’ESP32 SuperMini et du capteur de détection de visages vous permet de construire un compteur d’occupation de pièce très compact. Et comme l’ESP32 supporte le Wi-Fi, vous pourriez facilement envoyer le compteur de personnes à un serveur, par exemple pour contrôler la température d’une pièce.

Conclusions

Dans ce tutoriel, vous avez appris comment connecter le capteur Gravity Gesture & Face Detection à un Arduino UNO ou un ESP32. Vous avez également appris à reconnaître des gestes, à détecter des visages et à construire un capteur d’occupation de pièce.

Je vous recommande de lire la documentation DFRobot Wiki pour plus d’informations concernant le capteur Gravity Gesture & Face Detection. Jetez aussi un œil à leur dépôt github pour plus d’exemples de code.

La détection de gestes du capteur est assez fiable et rapide. Contrairement à des capteurs de gestes plus simples qui détectent des gestes basiques comme un balayage vers le haut ou le bas, le capteur Gravity Gesture détecte des gestes plus complexes mais est aussi un peu plus grand et possède une caméra avec une consommation d’énergie plus élevée.

Pour des informations sur des capteurs de gestes plus petits et plus simples, consultez nos tutoriels PAJ7620U2 Gesture Sensor with Arduino et APDS-9960 Gesture and Color Sensor with Arduino.

Si vous souhaitez détecter des objets au lieu de visages, regardez les tutoriels Train an Object Detection Model with Edge Impulse for ESP32-CAM, Object Detection with ESP32-CAM and YOLO et Getting Started with HUSKYLENS 2 and Arduino/ESP32 .

Enfin, pour une autre solution de capteur d’occupation, je vous suggère le tutoriel Edge AI Room Occupancy Sensor with ESP32 and Person Detection.

Si vous avez des questions ou des suggestions, n’hésitez pas à les laisser dans la section des commentaires.

Bon bricolage ; )