Der Gravity Offline Edge AI Gesture & Face Detection Sensor ist ein kompaktes Vision-Modul, das Gesten- und Gesichtserkennung in Echtzeit direkt auf dem Gerät durchführt. Es integriert eine kleine Kamera und einen eingebetteten KI-Prozessor, der fünf vordefinierte Handgesten erkennen und bis zu 10 Gesichter oder Oberkörperziele in Entfernungen von mehreren Metern erfassen kann. Da alle Inferenz lokal abläuft, bietet der Sensor eine geringe Latenz und ist unabhängig von Cloud- oder Netzwerkverbindungen.
Der Sensor unterstützt sowohl I2C- als auch UART-Schnittstellen und arbeitet mit einer Versorgungsspannung von 3,3 V bis 5 V, was ihn kompatibel mit Plattformen wie Arduino, ESP32 und Raspberry Pi macht. Dadurch eignet sich das Modul für berührungslose Steuerung, Anwesenheitserkennung und andere datenschutzfreundliche Edge-AI-Anwendungen.
Im Folgenden erfahren Sie, wie Sie das Sensormodul an ein Arduino UNO oder einen ESP32 anschließen, wie Sie es für Gesten- und Gesichtserkennung programmieren und wie Sie damit einen Raumbelegungszähler bauen.
Benötigte Teile
Für dieses Tutorial benötigen Sie den Gravity Gesture & Face Detection Sensor von DFRobot. Außerdem brauchen Sie einen Mikrocontroller. Ich verwende ein Arduino UNO und ein ESP32-C3 SuperMini, aber auch andere Arduino- oder ESP32-Boards funktionieren gut. Die einzige Voraussetzung ist die Unterstützung einer I2C- (oder UART-) Schnittstelle.
Gravity Gesture & Face Detection Sensor
Arduino Uno
USB-Kabel für Arduino UNO
ESP32-C3 SuperMini
OLED-Display
USB-C-Kabel
Dupont-Kabelsatz
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 des Gravity Gesture & Face Detection Sensors
Der Gravity-Sensor integriert eine kompakte Kamera und einen eingebetteten KI-Prozessor, der alle Gestenerkennung und Anwesenheitserkennung lokal verarbeitet. Das bedeutet, dass kein externer Computer oder Cloud-Anschluss erforderlich ist: Der Sensor führt die Inferenz in Echtzeit direkt auf dem Modul durch. Das Bild unten zeigt Vorder- und Rückseite des Sensormoduls:
Gestenerkennungsfähigkeiten
Das Modul kann fünf vordefinierte Handgesten in einem Erkennungsbereich von etwa 0,5 bis 3 Metern erkennen. Unterstützte Gesten sind Daumen hoch 👍, das „OK“-Zeichen 👌, eine offene Handfläche als „Stopp“-Geste ✋, das „Victory“-Zeichen ✌️ und die „Call-me“-Geste 🤙.
Nach erfolgreicher Gestenerkennung liefert der Sensor sowohl einen digitalen Ausgang (über Interrupt) als auch eine visuelle Anzeige: Eine RGB-LED ändert ihre Farbe je nach erkannter Geste. Die Gesten und die zugehörigen Farben sind auf der Platine aufgedruckt:
Gesichts- und Oberkörper-/Anwesenheitserkennung
Neben Handgesten unterstützt der Sensor die Erkennung von menschlichen Gesichtern oder Oberkörpern (Kopf und Schultern). Er kann bis zu 10 verschiedene Gesichter oder Körper gleichzeitig erkennen und verfolgen. Für jede erkannte Person kann das Modul Positionskoordinaten (X/Y im Kamerabild) und einen Vertrauenswert ausgeben, was fortgeschrittene Anwendungen wie Personenzählung, anwesenheitsbasierte Automatisierung oder ortsabhängige Interaktionen ermöglicht.
Sichtfeld, Optik und Erkennungsreichweite
Die integrierte Kamera hat ein diagonales Sichtfeld (FOV) von etwa 85°, was eine relativ breite Abdeckung bietet, die sich eignet, um Personen oder Gesten im Raum und nicht nur in einem engen zentralen Bereich zu erkennen. Die angegebene effektive Erkennungsreichweite für Gesten und Gesichts-/Anwesenheitserkennung liegt ungefähr zwischen 0,5 m und 3 m. Die Brennweite der Kamera beträgt 1,56 mm und ist für diesen kurzen bis mittleren Erkennungsbereich mit Weitwinkel optimiert.
Elektrische und Kommunikationsschnittstellen
Der Sensor ist für breite Kompatibilität mit typischen Embedded-Plattformen ausgelegt. Er arbeitet mit einer Versorgungsspannung zwischen 3,3 V und 5 V bei einem Logikpegel von 3,3 V. Der typische Betriebsstrom liegt bei etwa 100 mA, was ihn auch für stromsparende oder batteriebetriebene Systeme geeignet macht.
Für die Datenübertragung und Integration unterstützt das Modul zwei Kommunikationsschnittstellen: I2C und UART. Der Benutzer kann die Schnittstelle über einen Modusschalter auf der Platine wählen. Die Standard-I2C-Adresse ist 0x72. Bei Verwendung von UART beträgt die Standard-Baudrate 9600 bps mit Modbus-RTU-Protokoll.
Beachten Sie, dass ein Schalter auf der Platine auf die gewählte Kommunikation (I2C oder UART) eingestellt werden muss:
Zusätzlich bietet das Modul einen Interrupt-INT-Ausgangspin (an einem 2,54 mm Header), der bei Gestenerkennung auf LOW geht. Dies ist nützlich, um externe Logik oder Mikrocontroller-Aktionen ohne ständiges Abfragen auszulösen.
Physikalische Abmessungen und Formfaktor
Die Sensorplatine misst 42 mm × 32 mm und ist damit kompakt genug, um in kleine Projekte oder Gehäuse eingebaut zu werden. Befestigungslöcher sind vorhanden: Der Abstand der Befestigungslöcher beträgt 25 mm × 35 mm, und die Löcher haben einen Durchmesser von 3,1 mm. Die Platine verwendet einen PH2.0-4P-Stecker (oder optional Standard-2,54-mm-Pin-Header-Löcher) für Strom- und Datenleitungen.
Technische Spezifikation
Die folgende Tabelle fasst die technischen Merkmale des Gravity Offline Edge AI Gesture & Face Detection Sensors zusammen
| Parameter | Beschreibung |
|---|---|
| Modell | Gravity Offline Edge AI Gesture & Face Detection Sensor (V1.0) |
| Verarbeitungsmethode | On-Device KI-Inferenz für Gesten-, Gesichts- und Oberkörpererkennung |
| Kamera-Sichtfeld | Ca. 85° diagonal |
| Brennweite | 1,56 mm |
| Erkennungsreichweite | 0,5 m bis 3 m für Gesten- und Gesichts-/Anwesenheitserkennung |
| Gestenerkennung | Fünf vordefinierte Gesten (OK, Daumen hoch, Victory, Stopp, Hang-loose) |
| Gesichts- / Anwesenheitserkennung | Bis zu 10 Gesichter oder Oberkörper gleichzeitig mit Positions- und Vertrauenswert-Ausgabe |
| Schnittstellen | I2C (Standardadresse 0x72) und UART (9600 bps, Modbus-RTU) |
| Interrupt-Ausgang | Aktiv-niedriger Interrupt-Pin, der bei Gestenerkennung ausgelöst wird |
| Betriebsspannung | 3,3 V bis 5 V (3,3 V Logikpegel) |
| Betriebsstrom | ~100 mA typisch |
| Statusanzeige | RGB-LED mit gestenabhängiger Farb-Rückmeldung |
| Anschluss | PH2.0-4P oder 2,54 mm Header-Pads |
| Platinengröße | 42 mm × 32 mm |
| Montage | 3,1 mm Löcher mit 25 mm × 35 mm Abstand |
| Softwareunterstützung | Arduino / ESP32 Bibliothek, MakeCode, Mind+ |
Anschluss des Gravity Gesture & Face Detection Sensors an Arduino
Sie können den Gravity Gesture & Face Detection Sensor über I2C oder UART anschließen. Wir verwenden die I2C-Schnittstelle, da sie schneller ist und es ermöglicht, mehrere Geräte am selben Bus zu betreiben. Das folgende Schaltbild zeigt, wie Sie den Sensor an ein Arduino UNO anschließen:
Verbinden Sie zuerst GND des Arduino mit GND des Sensors. Dann verbinden Sie den 5V-Ausgang (oder den 3,3V-Ausgang) mit dem VCC-Pin des Sensors. Schließlich verbinden wir SDA/A4 mit D/T und SCL/A5 mit C/R.
Stellen Sie sicher, dass der Kommunikationsschalter auf der Sensorplatine auf I2C und nicht auf UART steht!
Bibliotheken installieren
Bevor Sie den Gravity Gesture & Face Detection Sensor verwenden können, müssen Sie die DFRobot_GestureFaceDetection Bibliothek installieren. Öffnen Sie den LIBRARY MANAGER, geben Sie „DFRobot_GestureFaceDetection“ in die Suchleiste ein und drücken Sie INSTALL, um die Bibliothek wie unten gezeigt zu installieren:
Wahrscheinlich erscheint ein Dialog, der Sie auffordert, Bibliotheksabhängigkeiten zu installieren. Drücken Sie einfach INSTALL ALL:
Jetzt sind Sie bereit, einige Codebeispiele auszuprobieren.
Codebeispiel: Gestenerkennung
Dieses erste Codebeispiel zeigt, wie die Gestenerkennung funktioniert:
#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
Wir beginnen mit dem Einbinden der DFRobot_GestureFaceDetection Bibliothek, die die Gesten- und Gesichtserkennungsfunktionalität bereitstellt.
Objekte
Als Nächstes erstellen wir eine Instanz der Gesten- und Gesichtserkennungsklasse. Dieses Objekt wird später verwendet, um die Kommunikation zu initialisieren, Schwellenwerte zu konfigurieren und Erkennungsergebnisse abzurufen.
DFRobot_GestureFaceDetection_I2C gfd(0x72);
Der Konstruktor erhält die I2C-Adresse des DFRobot-Sensors. Die Standardadresse ist 0x72, aber Sie können die I2C-Adresse im Bereich 0x01 – 0xF6 durch Aufruf der setDeviceAddr(addr) Funktion konfigurieren.
Setup-Funktion
Der Setup-Block initialisiert die serielle Schnittstelle, startet die Kommunikation mit dem Gestensensor und konfiguriert dessen Erkennungsschwelle. Alles innerhalb von setup läuft einmalig beim Einschalten oder Reset des Boards.
void setup() {
Serial.begin(115200);
gfd.begin(&Wire);
gfd.setGestureDetectThres(60);
Serial.println("running...");
}
Die Gestenerkennungsschwelle liegt im Bereich von 0..100 und bestimmt die Empfindlichkeit zur Erkennung von Gesten. Ein niedriger Wert erhöht die Empfindlichkeit, kann aber zu mehr Fehlalarmen führen, während ein höherer Wert klarere Gesten erfordert, aber die Anzahl der Fehlalarme reduziert.
Loop-Funktion
Die Loop-Funktion läuft kontinuierlich, fragt den Sensor nach neuen Gesteninformationen ab und gibt Ergebnisse aus, wenn etwas erkannt wird.
Das Programm fordert den aktuellen Gestentyp vom Sensor an.
uint16_t gestureType = gfd.getGestureType();
Der zurückgegebene Wert identifiziert, welche Geste der Sensor erkannt hat, falls eine. Ein Wert von Null bedeutet, dass keine Geste erkannt wurde. Die folgende Tabelle zeigt die IDs der verschiedenen Gestentypen, die von der getGestureType() Funktion zurückgegeben werden, sowie die entsprechende Farbe der Onboard-LED:
| ID | Geste | Symbol | LED-Farbe |
|---|---|---|---|
| 1 | Daumen hoch | 👍 | Blau |
| 2 | OK | 👌 | Grün |
| 3 | Stopp | 🤚 | Rot |
| 4 | Victory | ✌️ | Gelb |
| 5 | Call-me | 🤙 | Lila |
Für jede Geste rufen wir dann den Gesten-Score ab mit:
uint16_t gestureScore = gfd.getGestureScore();
Dieser Score gibt an, wie sicher sich der Sensor bei der erkannten Geste ist. Höhere Werte bedeuten eine sicherere Erkennung. Der Vertrauenswert liegt im Bereich von 0…100.
Wenn eine Geste erkannt wurde, formatiert das Sketch eine Textnachricht und gibt sie im Serial Monitor aus.
if (gestureType > 0) {
sprintf(text, "Gesture: %d, score: %d\n", gestureType, gestureScore);
Serial.print(text);
delay(1000);
}
Die Bedingung prüft, ob gestureType größer als null ist. Die sprintf-Funktion schreibt die Gesteninformation in einen Zeichenpuffer, der dann ausgegeben wird. Eine Sekunde Verzögerung gibt dem Nutzer Zeit, die Ausgabe zu lesen und verhindert zu häufige Wiederholungen.
Ausgabe im Serial Monitor
Wenn Sie das Programm ausführen und Gesten vor der Kamera machen, sollten Sie Erkennungsergebnisse im Serial Monitor sehen:
Codebeispiel: Gesichtserkennung
Das folgende Codebeispiel zeigt, wie man Gesichtserkennung durchführt:
#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 und Objekte
Wie zuvor binden wir die DFRobot_GestureFaceDetection-Bibliothek ein und erstellen das Gesten- & Gesichtserkennungsobjekt gfd:
#include "DFRobot_GestureFaceDetection.h" DFRobot_GestureFaceDetection_I2C gfd(0x72);
Setup-Funktion
Der Setup-Block initialisiert die serielle Schnittstelle, startet die Kommunikation mit dem Sensor und konfiguriert die Erkennungsschwelle für Gesichter:
void setup() {
Serial.begin(115200);
gfd.begin(&Wire);
gfd.setFaceDetectThres(60);
}
Die Erkennungsschwelle liegt zwischen 0..100; niedrigere Werte erleichtern die Gesichtserkennung, führen aber zu mehr Fehlalarmen.
Loop-Funktion
Die Loop-Funktion läuft kontinuierlich und prüft auf Gesichtserkennung. Wenn mehr als null Gesichter erkannt werden, rufen wir den Vertrauenswert und die x,y-Position des erkannten Gesichts ab:
if (gfd.getFaceNumber() > 0) {
uint16_t faceScore = gfd.getFaceScore();
uint16_t faceX = gfd.getFaceLocationX();
uint16_t faceY = gfd.getFaceLocationY();
Anschließend geben wir diese Informationen im Serial Monitor aus:
sprintf(text, "Face:(x=%d, y=%d, score=%d)\n", faceX, faceY, faceScore);
Serial.print(text);
Wenn Sie die Kamera des Sensors auf Ihr Gesicht richten, sollten Sie Erkennungsergebnisse sehen:
Codebeispiel: Raumbelegungszähler
Im letzten Beispiel bauen wir einen Raumbelegungssensor, der die Anzahl der Personen im Raum zählt und den Zähler auf einem OLED anzeigt. Sie könnten das auch mit einem Arduino bauen, aber ich verwende zur Abwechslung ein ESP32-C3 SuperMini.
Das folgende Schaltbild zeigt, wie Sie den Gesichtserkennungssensor und das OLED an den ESP32 anschließen:
Sowohl der Gesichtserkennungssensor als auch das OLED sind an den I2C-Bus angeschlossen, der an den Pins 8 (SDA) und 9 (SCL) des ESP32 SuperMini liegt. Ebenso sind VCC und GND von Sensor und OLED mit 3,3 V und GND des SuperMini verbunden. Das Bild unten zeigt diese Verdrahtung auf einem Breadboard:
Und hier ist der Code zum Zählen der Personen im Raum:
#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
Der Code beginnt mit dem Einbinden der Bibliotheken für den Gesichtserkennungssensor und das OLED. Falls Sie die Adafruit_SSD1306 Bibliothek noch nicht verwendet haben, müssen Sie sie über den LIBRARY MANAGER installieren:
Objekte
Als Nächstes erstellen wir die Objekte für den Sensor und das OLED:
DFRobot_GestureFaceDetection_I2C gfd(0x72); Adafruit_SSD1306 oled(128, 64, &Wire, -1);
Da beide Geräte am I2C-Bus hängen, müssen sie unterschiedliche I2C-Adressen haben. Der Sensor hat die Adresse 0x72 und das OLED typischerweise 0x3C, daher gibt es keinen Konflikt. Falls jedoch nichts auf dem Display erscheint oder der Sensor nicht funktioniert, überprüfen Sie die I2C-Adressen und stellen Sie sicher, dass sie unterschiedlich sind.
Setup-Funktion
In der Setup-Funktion initialisieren wir den Sensor und das OLED: Beachten Sie, dass die I2C-Adresse für das OLED hier gesetzt wird und nicht im Konstruktor:
void setup() {
Wire.begin();
gfd.begin(&Wire);
gfd.setFaceDetectThres(60);
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
oled.setRotation(3);
oled.setTextSize(6);
oled.setTextColor(WHITE);
}
Loop-Funktion
Der Gravity Gesture & Face Detection Sensor macht das Zählen von Personen sehr einfach. Wir rufen einfach die getFaceNumber() Funktion auf, um die Anzahl der erkannten Gesichter/Personen zu erhalten. Beachten Sie, dass die Gesichtserkennung auf 10 Gesichter begrenzt ist. Sobald wir die Anzahl der Gesichter (nFaces) haben, zeigen wir sie einfach auf dem OLED an.
void loop() {
uint16_t nFaces = gfd.getFaceNumber();
oled.clearDisplay();
oled.setCursor(10, 20);
oled.printf("%d", nFaces);
oled.display();
delay(100);
}
Die kleine Größe des OLED, des ESP32 SuperMini und des Gesichtserkennungssensors ermöglicht den Bau eines sehr kompakten Raumbelegungszählers. Und da der ESP32 Wi-Fi unterstützt, könnten Sie den Personen-Zähler auch einfach an einen Server senden, zum Beispiel zur Steuerung der Raumtemperatur.
Fazit
In diesem Tutorial haben Sie gelernt, wie Sie den Gravity Gesture & Face Detection Sensor an ein Arduino UNO oder einen ESP32 anschließen. Sie haben außerdem erfahren, wie man Gesten erkennt, Gesichter detektiert und einen Raumbelegungssensor baut.
Ich empfehle, das DFRobot Wiki für weitere Informationen zum Gravity Gesture & Face Detection Sensor zu lesen. Schauen Sie auch in deren github-Repo für weitere Codebeispiele.
Die Gestenerkennung des Sensors ist ziemlich zuverlässig und schnell. Im Gegensatz zu einfacheren Gestensensoren, die einfache Gesten wie Wischen nach oben oder unten erkennen, erkennt der Gravity Gesture Sensor komplexere Gesten, ist aber auch etwas größer und hat eine Kamera mit höherem Stromverbrauch.
Für Informationen zu kleineren, einfacheren Gestensensoren sehen Sie sich unsere PAJ7620U2 Gesture Sensor with Arduino und APDS-9960 Gesture and Color Sensor with Arduino Tutorials an.
Wenn Sie statt Gesichtern Objekte erkennen möchten, schauen Sie sich die Train an Object Detection Model with Edge Impulse for ESP32-CAM, Object Detection with ESP32-CAM and YOLO und Getting Started with HUSKYLENS 2 and Arduino/ESP32 Tutorials an.
Für eine weitere Lösung für einen Belegungssensor empfehle ich das Edge AI Room Occupancy Sensor with ESP32 and Person Detection Tutorial.
Wenn Sie Fragen oder Anregungen haben, hinterlassen Sie diese gerne im Kommentarbereich.
Viel Spaß beim Tüfteln ; )
