Dieses Tutorial zeigt Ihnen, wie Sie mit dem HUSKYLENS 2 starten. Der HUSKYLENS 2 von DFRobot ist ein KI-Vision-Sensor mit einer austauschbaren 2MP-Kamera, einem 2,4-Zoll-IPS-Touchscreen, Mikrofon, Lautsprecher und Anzeigeleuchten.
Direkt unterstützt der HUSKYLENS 2 über 20 integrierte KI-Modelle, von Objekterkennung und Gesichtserkennung bis hin zu Pose-Schätzung und Instanzsegmentierung. Zusätzlich können Sie benutzerdefinierte Modelle über einen YOLO-ähnlichen Workflow auf das Gerät laden.
Sie lernen, wie Sie den HUSKYLENS über I2C mit einem Arduino oder ESP32 verbinden und wie Sie die Erkennungsergebnisse verschiedener KI-Algorithmen programmatisch abrufen. So können Sie externe Geräte basierend auf den Erkennungen steuern.
Zum Beispiel bauen wir in diesem Tutorial eine Emotion Traffic Light, die je nach erkannter Emotion im Gesicht (Wut, Neutral, Glücklich) eine LED (rot, gelb, grün) einschaltet.
Legen wir los!
Benötigte Teile
Den HUSKYLENS 2 von DFRobot können Sie über den untenstehenden Link erwerben. Außerdem benötigen Sie einen Mikrocontroller. Ich verwende einen Arduino UNO und einen Lolin ESP32 lite, aber die meisten anderen Arduino- oder ESP32-Boards funktionieren ebenfalls. Die einzige Voraussetzung ist die Unterstützung einer I2C- (oder UART-) Schnittstelle.
HUSKYLENS 2
Arduino Uno
USB-Kabel für Arduino UNO
ESP32 lite
USB-Datenkabel
Dupont-Drahtset
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.
HUSKYLENS versus neuer HUSKYLENS 2
Um Verwirrung zu vermeiden, beginnen wir mit einem kurzen Vergleich des ursprünglichen HUSKYLENS (Version 1) und des neuen HUSKYLENS 2, den wir in diesem Tutorial verwenden. Beide Geräte sind KI-Vision-Sensoren von DFRobot, die Computer-Vision-Anwendungen in eingebetteten Systemen vereinfachen. Beide bieten Onboard-Vision-Verarbeitung und serielle Schnittstellen, aber der HUSKYLENS 2 verfügt über verbesserte Hardware- und Softwarefähigkeiten.
HUSKYLENS
Die erste Generation des HUSKYLENS basiert auf dem Kendryte K210 KI-Prozessor und bietet integrierte KI-Algorithmen für Aufgaben wie Gesichtserkennung, Objektverfolgung, Farberkennung, Linienverfolgung und Tag-Erkennung. Es verfügt über ein 2,0-Zoll-IPS-Display für Echtzeit-Feedback und unterstützt UART-, I²C- und USB-Schnittstellen für die Kommunikation.
HUSKYLENS 2
Der HUSKYLENS 2 hingegen wird von einem 1,6 GHz Dual-Core-Prozessor (K230) mit einem 6 TOPS KI-Beschleuniger, 1 GB LPDDR4 RAM und 8 GB Onboard-Speicher angetrieben. Diese verbesserte Rechenleistung ermöglicht komplexere KI-Aufgaben lokal.
Er bietet über zwanzig integrierte Vision-Modelle, darunter Objekterkennung, Pose-Schätzung und Instanzsegmentierung, und erlaubt Nutzern, eigene Modelle über einen YOLO-basierten Workflow zu deployen.
Die neue Version verfügt außerdem über ein hochauflösendes 2,4-Zoll-IPS-Display, ein modulares Kamerasystem mit austauschbaren Objektiven, einen USB-C-Anschluss für Daten und Strom sowie ein optionales drahtloses Verbindungsmodule.
Vergleichstabelle
| Merkmal | HUSKYLENS (Original) | HUSKYLENS 2 |
|---|---|---|
| Prozessor | Kendryte K210 Dual-Core KI-Chip | Dual-Core 1,6 GHz Prozessor mit 6 TOPS KI-Beschleuniger |
| Speicher / Speicherplatz | Nicht spezifiziert | 1 GB LPDDR4 RAM + 8 GB eMMC |
| Integrierte Modelle | 7 vordefinierte Algorithmen (Gesicht, Objekt, Linie, Farbe, Tag-Erkennung) | 20+ integrierte Modelle mit Unterstützung für benutzerdefinierte YOLO-Modelle |
| Display | 2,0″ IPS (320×240 px) | 2,4″ IPS (640×480 px) |
| Kamera | Fest 2 MP (OV2640) | 2 MP (GC2093) mit austauschbaren Objektiven |
| Schnittstellen | UART, I²C, USB | USB-C, I²C, UART, optionales Wi-Fi-Modul |
| Stromverbrauch | 230mA @ 5,0V (Gesichtserkennung) | 340mA @ 5V (Gesichtserkennung) |
Wie erwähnt, verwenden wir in diesem Tutorial den HUSKYLENS 2 und im nächsten Abschnitt werfen wir einen genaueren Blick auf seine technischen Merkmale.
Hardware des HUSKYLENS 2
Der HUSKYLENS 2 basiert auf einem leistungsstarken eingebetteten KI-Vision-Modul, das neuronale Netzwerkinferenz vollständig auf dem Gerät ausführt und so die Notwendigkeit eines separaten Host-Prozessors oder Cloud-Computings reduziert. Im Kern arbeitet eine Dual-Core-CPU mit 1,6 GHz (K230) zusammen mit einem KI-Beschleuniger mit etwa 6 TOPS (Tera-Operationen pro Sekunde) KI-Rechenleistung.
Das Bild unten zeigt die Rückseite des HUSKYLENS 2 mit der Kamera, zwei LEDs zur Beleuchtung, einer RGB-LED, daneben ein Mikrofon und schließlich einen kleinen Taster für Programmierung/Lernen:
Speicher
Ergänzend zum Prozessor gibt es ein Speichersystem mit 1 GB LPDDR4 RAM für neuronale Netzwerke und Anwendungs-Tasks sowie 8 GB eMMC Flash-Speicher für System-Firmware, Modell-Speicherung und Nutzerdaten.
Kamera
Die Bildaufnahme erfolgt über einen 2-Megapixel-Sensor (Modell GC2093, 1/2,9″ Format), der Videos mit bis zu 60 Bildern pro Sekunde (fps) aufnehmen kann. Das Kameramodul ist modular/austauschbar und ermöglicht den Wechsel verschiedener Objektive oder optischer Konfigurationen (z. B. Makro, Nachtsicht, Langstrecke) je nach Anwendungsfall.
Touchscreen
Für die Mensch-Maschine-Interaktion und lokale Benutzeroberfläche integriert der HUSKYLENS 2 einen 2,4″ IPS-Touchscreen (Auflösung 640×480). Eine Funktionstaste, eine RGB-Anzeige-LED und ein kleiner Lautsprecher auf der Rückseite bieten zusätzliches Audio-/visuelles Feedback.
Schnittstellen
Der HUSKYLENS 2 bietet einen USB-C-Anschluss (für Strom und Firmware-Updates), einen 4-poligen „Gravity“-Anschluss mit UART und I²C (sowie Strom/GND) für die Host-Kommunikation und einen Steckplatz für ein optionales 2,4 GHz Wi-Fi 6 Modul zur drahtlosen Verbindung. Erweiterungen sind auch über einen TF-Karten (micro-SD) Slot an der Seite für zusätzlichen Speicher oder Datensatz-Erfassung möglich.
Das Vision-Subsystem liefert Koordinatendaten, Begrenzungsrahmen, IDs und modell-spezifische Metadaten über UART/I²C, die externe Mikrocontroller auslesen und darauf reagieren können.
Stromversorgung
Die Versorgungsspannung liegt nominal bei 3,3V bis 5,0V (an Bord geregelt) und der typische Stromverbrauch liegt je nach Last und aktivem Modell zwischen 1,5W und 3W. Die folgende Tabelle zeigt gemessene Ströme für einige Modelle, mit bis zu 420mA für OCR (Optische Zeichenerkennung) und einem Leerlaufstrom (nur UI läuft) von 250mA:
| Aufgabe | Strom |
|---|---|
| UI | 250mA |
| Gesichtserkennung | 340mA |
| Objekterkennung | 380mA |
| Objektverfolgung | 370mA |
| Farberkennung | 330mA |
| Objektklassifizierung | 350mA |
| Instanzsegmentierung | 390mA |
| Handerkennung | 370mA |
| QR-Code-Erkennung | 410mA |
| OCR | 420mA |
Integrierte KI-Modelle
Die Firmware des HUSKYLENS 2 verwaltet sowohl das System-RTOS als auch die KI-Modell-Umgebung. Das Gerät wird mit 20+ AI Modellen (wie Objekterkennung, Gesichtserkennung, Pose-Schätzung, Instanzsegmentierung) vorinstalliert geliefert, die über die Onboard-Benutzeroberfläche oder programmatisch ausgewählt werden können:
Firmware-Updates werden über den USB-C-Anschluss (oder über die Host-Schnittstelle) eingespielt, und das System unterstützt mehrere Modelle, die seriell oder parallel laufen (je nach Ressourcenverbrauch) dank des 6 TOPS Beschleunigers.
Benutzerdefinierte Modelle
Neben den integrierten Modellen unterstützt der HUSKYLENS 2 die Bereitstellung von custom-trained models, speziell über einen YOLO-ähnlichen Workflow: Nutzer können Datensätze annotieren, Modelle extern trainieren, in das Zielformat konvertieren und in den eMMC-Speicher des Geräts laden und dort ausführen.
Model Context Protocol
Ein besonderes Merkmal ist das integrierte „Model Context Protocol“ (MCP) Service, das es dem Kameramodul ermöglicht, strukturierte semantische Daten (z. B. „Person A hebt Objekt B“) an ein verbundenes Large-Language-Model (LLM) oder Host-Anwendung auszugeben und so die On-Device-Vision-Verarbeitung mit höherstufigem Reasoning verbindet.
Technische Spezifikation
Die folgende Tabelle fasst die technischen Spezifikationen des HUSKYLENS 2 zusammen:
| Parameter | Spezifikation |
|---|---|
| Prozessorkern | Dual-Core CPU @1,6 GHz (Kendryte K230) |
| KI-Beschleuniger | ~6 TOPS On-Device KI-Rechenleistung |
| RAM | 1 GB LPDDR4 |
| Speicher | 8 GB eMMC |
| Bildsensor | GC2093, 2 MP, 1/2,9″, bis zu 60 fps |
| Onboard-Display | 2,4″ IPS-Touchscreen, 640×480 Auflösung |
| Schnittstellen | USB-C (Strom/Daten), 4-poliger Gravity (UART/I²C/Strom/GND), optionales WiFi-Modul |
| Erweiterbarer Speicher | TF (micro-SD) Karten-Slot |
| Audio I/O | Integriertes Mikrofon, 1 W Lautsprecher |
| Anzeige / UI | 1 Funktionstaste, 2 LEDs zur Beleuchtung, 1 RGB-LED |
| Modulare Kamerauunterstützung | Austauschbare Objektivmodule (Makro, Nachtsicht, etc.) |
| Eingangsspannung | 3,3 V bis 5,0 V |
| Typischer Stromverbrauch | ~1,5 W bis 3 W |
| Abmessungen | ~70 × 58 × 19 mm |
| Gewicht | ~90 g |
| Vorinstallierte Modelle | 20+ integrierte KI-Modelle |
| Unterstützung für benutzerdefinierte Modelle | über YOLO-ähnlichen Workflow |
| Besondere Merkmale | MCP-Service zur Verknüpfung von Vision mit LLMs |
HUSKYLENS 2 mit Arduino UNO verbinden
Sie können mit dem HUSKYLENS über UART oder das I2C-Protokoll kommunizieren. I2C ist schneller und erlaubt den Anschluss mehrerer Geräte am selben Bus. Wir verwenden daher I2C. Der Gravity-Anschluss des HUSKYLENS stellt die I2C-Schnittstelle (SDA, SCL) und Stromversorgungspins (VCC, GND) bereit. Siehe Foto unten:
Sie könnten den HUSKYLENS 2 direkt an einen Arduino anschließen und über den 5V-Ausgang des Arduino mit Strom versorgen, aber Sie sollten DAS NICHT tun!
Der maximale Strom, den der 5V-Pin des Arduino liefern kann, beträgt 500mA, und der HUSKYLENS 2 verbraucht bis zu 420mA (OCR-Modell). Das ist zwar unter dem Maximum, aber bei längerer Laufzeit wird der Spannungsregler auf dem Arduino oder ESP32 sehr heiß und kann durchbrennen.
Die sichere Option ist die Verwendung des kleinen Netzteil-Adapterboards, das mit dem HUSKYLENS geliefert wird. Damit können Sie den HUSKYLENS von einer separaten Stromquelle versorgen.
Alternativ können Sie den HUSKYLENS an einen USB-Port und den Arduino an einen anderen USB-Port anschließen, wie im DFRobot Wiki gezeigt:
Ich bevorzuge jedoch das Netzteil-Adapterboard, und der folgende Abschnitt zeigt, wie man es anschließt.
Schaltplan
Der folgende Schaltplan zeigt, wie Sie den HUSKYLENS über das Netzteil-Adapterboard mit einem Arduino UNO verbinden:
Beginnen Sie damit, das Adapterboard mit dem HUSKYLENS zu verbinden. Verwenden Sie das weiße Dual-Plug PH2.0-4P Silikonkabel (graue Drähte im Diagramm), das mit dem HUSKYLENS geliefert wird, und achten Sie darauf, den Anschluss mit der Beschriftung „Huskylens“ und „I2C/UART“ zu verwenden:
Verbinden Sie als Nächstes das farbige Gravity-4P Sensor-Kabel mit dem Netzteil-Adapter und dem Arduino:
Der rote Draht muss mit dem 5V-Pin des Arduino verbunden werden, der schwarze Draht mit GND. Der grüne Draht ist SDA und sollte mit A4 verbunden werden, der blaue Draht (SCL) mit A5 des Arduino.
Schließen Sie eine Powerbank oder eine andere 5V-Stromquelle über ein USB-Kabel an das Adapterboard an. Dies versorgt den HUSKYLENS mit Strom. Der HUSKYLENS sollte laufen, sobald USB-Strom anliegt.
Schließlich verbinden wir unseren Arduino über sein USB-Kabel mit einem PC, auf dem die Arduino IDE läuft, um ihn programmieren zu können:
Installation der HuskylensV2 Bibliothek
Bevor Sie eines der folgenden Codebeispiele auf Arduino oder ESP32 ausführen können, müssen Sie zuerst die DFRobot_HuskylensV2 Bibliothek installieren. Gehen Sie zur Github repo for the DFRobot_HuskylensV2 Bibliothek, klicken Sie auf den grünen Code-Button und dann auf „Download ZIP“, um die Bibliothek als ZIP-Datei herunterzuladen:
Öffnen Sie anschließend Ihre Arduino IDE, klicken Sie auf „Sketch“ -> „Include Library“ -> „Add .ZIP Library …“ und fügen Sie die gerade heruntergeladene DFRobot_HuskylensV2 Bibliothek hinzu:
Codebeispiel: I2C-Kommunikation mit Modellen
In diesem ersten Beispiel testen wir die I2C-Kommunikation zwischen einigen der KI-Modelle auf dem HUSKYLENS-Gerät und dem Arduino UNO.
Verbinden Sie Ihren Arduino UNO mit einem PC, auf dem die Arduino IDE läuft. Stellen Sie sicher, dass der Arduino an einem COM-Port erkannt wird und dass Arduino UNO als Board ausgewählt ist:
Erstellen Sie als Nächstes einen neuen Sketch und kopieren Sie den folgenden Code hinein. Dieser Code stellt eine I2C-Kommunikation zwischen Arduino und HUSKYLENS her und gibt die Erkennungsergebnisse des aktuell auf dem HUSKYLENS laufenden KI-Modells aus:
// (c) www.makerguides.com
#include "DFRobot_HuskylensV2.h"
HuskylensV2 huskylens;
void setup() {
Serial.begin(115200);
Wire.begin();
while (!huskylens.begin(Wire)) {
Serial.println(F("Can't init HUSKYLENS!"));
delay(100);
}
Serial.println("running...");
}
void loop() {
while (!huskylens.getResult(ALGORITHM_ANY)) {
delay(100);
}
Serial.println("\nRESULTS:");
while (huskylens.available(ALGORITHM_ANY)) {
Result *r= static_cast<Result *>(huskylens.popCachedResult(ALGORITHM_ANY));
Serial.print("Name=");
Serial.print(r->name);
Serial.print(" ID=");
Serial.println(r->ID);
}
delay(1000);
}
Bibliotheken und Objekte
Der Code bindet zuerst die DFRobot_HuskylensV2 Bibliothek ein und erstellt das HuskylensV2 Objekt.
#include "DFRobot_HuskylensV2.h" HuskylensV2 huskylens;
Setup
Im Setup() initialisieren wir zuerst die serielle Kommunikation (Serial.begin()) und die I2C-Schnittstelle (Wire.begin()). Dann versuchen wir, eine I2C-Verbindung mit dem HUSKYLENS über huskylens.begin(Wire) herzustellen:
void setup() {
Serial.begin(115200);
Wire.begin();
while (!huskylens.begin(Wire)) {
Serial.println(F("Can't init HUSKYLENS!"));
delay(100);
}
Serial.println("running...");
}
Falls dies fehlschlägt und Sie „Can’t init HUSKYLENS!“ im Serial Monitor sehen, überprüfen Sie die Verkabelung und stellen Sie sicher, dass das Kommunikationsprotokoll des HUSKYLENS 2 auf I2C eingestellt ist. Gehen Sie dazu in „System Settings“ -> „Protocol Type“ und vergewissern Sie sich, dass I2C ausgewählt ist, wie unten gezeigt:
Loop
In der loop()-Funktion warten wir zunächst, ob eines der KI-Algorithmen auf dem HUSKYLENS Ergebnisse bereitstellt. Falls ja, iterieren wir über alle verfügbaren Ergebnisse und geben Name und ID des Ergebnisses aus:
void loop() {
while (!huskylens.getResult(ALGORITHM_ANY)) {
delay(100);
}
Serial.println("\nRESULTS:");
while (huskylens.available(ALGORITHM_ANY)) {
Result *r= static_cast<Result *>(huskylens.popCachedResult(ALGORITHM_ANY));
Serial.print("Name=");
Serial.print(r->name);
Serial.print(" ID=");
Serial.println(r->ID);
}
delay(1000);
}
KI-Algorithmus auswählen
Bevor Sie Ergebnisse im Serial Monitor sehen, müssen Sie zuerst einen KI-Algorithmus (Modell) auf dem HUSKYLENS auswählen (später machen wir das automatisch per Code). Zum Beispiel können Sie den Algorithmus für Objekterkennung auswählen:
Der HUSKYLENS beginnt dann mit der Objekterkennung und meldet die Ergebnisse an den Arduino, falls Objekte erkannt werden. Sie sollten eine Ausgabe ähnlich der folgenden im Serial Monitor sehen:
Beachten Sie, dass unter einem ERGEBNIS mehrere Erkennungen sein können, da sich mehrere Objekte im Bild befinden können.
Sie können andere KI-Algorithmen ausprobieren, aber abgesehen von einer ID liefern die meisten mit diesem Codebeispiel keine nützlichen Informationen. Die Ergebnisse hängen vom jeweiligen KI-Algorithmus ab und erfordern spezifischen Code zur Ausgabe. In den nächsten Abschnitten lernen Sie, wie Sie detailliertere Ergebnisse abrufen.
KI-Algorithmen
Der HUSKYLENS 2 verfügt über viele integrierte KI-Algorithmen. Wenn Sie die Result.h Datei der DFRobot_HuskylensV2 Bibliothek öffnen, finden Sie folgende Liste von Konstanten für die integrierten Modelle:
// https://github.com/DFRobot/DFRobot_HuskylensV2/blob/master/Result.h
typedef enum {
ALGORITHM_ANY = 0, // 0
ALGORITHM_FACE_RECOGNITION = 1, // 1
ALGORITHM_OBJECT_TRACKING, // 2
ALGORITHM_OBJECT_RECOGNITION, // 3
ALGORITHM_LINE_TRACKING, // 6
ALGORITHM_COLOR_RECOGNITION, // 5
ALGORITHM_TAG_RECOGNITION, // 6
ALGORITHM_SELF_LEARNING_CLASSIFICATION, // 7
ALGORITHM_OCR_RECOGNITION, // 8
ALGORITHM_LICENSE_RECOGNITION, // 9
ALGORITHM_QRCODE_RECOGNITION, // 10
ALGORITHM_BARCODE_RECOGNITION, // 11
ALGORITHM_EMOTION_RECOGNITION, // 12
ALGORITHM_POSE_RECOGNITION, // 13
ALGORITHM_HAND_RECOGNITION, // 14
ALGORITHM_OBJECT_CLASSIFICATION, // 15
ALGORITHM_BLINK_RECOGNITION, // 16
ALGORITHM_GAZE_RECOGNITION, // 17
ALGORITHM_FACE_ORIENTATION, // 18
ALGORITHM_FALLDOWN_RECOGNITION, // 19
ALGORITHM_SEGMENT, // 20
ALGORITHM_FACE_ACTION_RECOGNITION, // 21
ALGORITHM_CUSTOM0, // 22
ALGORITHM_CUSTOM1, // 23
ALGORITHM_CUSTOM2, // 24
ALGORITHM_BUILTIN_COUNT, // 25
ALGORITHM_CUSTOM_BEGIN = 128, // 128
} eAlgorithm_t;
Im Folgenden verwenden wir die Algorithmen Objekterkennung, Gesichtserkennung und Emotionserkennung. Sobald Sie mit diesen vertraut sind, ist das Schreiben von Code für die anderen einfach.
Codebeispiel: Objekterkennung
In diesem Abschnitt rufen wir die Erkennungsergebnisse des Object Recognition Algorithmus ab. Wir haben die Objekterkennung bereits beim Testen der I2C-Schnittstelle verwendet, aber nur Name und ID des erkannten Objekts abgerufen. Der folgende Code holt den Namen, die ID, den Mittelpunkt und den Begrenzungsrahmen ab:
// (c) www.makerguides.com
#include "DFRobot_HuskylensV2.h"
#define TASK ALGORITHM_OBJECT_RECOGNITION
HuskylensV2 huskylens;
void setup() {
Serial.begin(115200);
Wire.begin();
while (!huskylens.begin(Wire)) {
Serial.println(F("Can't init HUSKYLENS!"));
delay(100);
}
huskylens.switchAlgorithm(TASK);
Serial.println("running...");
}
void loop() {
static char text[128];
while (!huskylens.getResult(TASK)) {
delay(100);
}
while (huskylens.available(TASK)) {
Result *r = huskylens.popCachedResult(TASK);
sprintf(text, "%10s (%d) x=%3d y=%3d w=%3d h=%3d",
r->name.c_str(),
r->classID,
r->xCenter,
r->yCenter,
r->width,
r->height);
Serial.println(text);
}
delay(1000);
}
Der Code ähnelt dem vorherigen, mit drei wichtigen Unterschieden. Erstens definieren wir eine Konstante TASK, die den KI-Algorithmus angibt, für den wir Ergebnisse abrufen wollen.
#define TASK ALGORITHM_OBJECT_RECOGNITION
Zweitens rufen wir im Setup() huskylens.switchAlgorithm(TASK) auf, um den gewünschten KI-Algorithmus automatisch zu starten:
huskylens.switchAlgorithm(TASK);
Schließlich casten wir in der loop()-Funktion den Rückgabewert von huskylens.popCachedResult() nicht mehr, sondern nehmen den Result Typ unverändert.
Result *r = huskylens.popCachedResult(TASK);
Je nach KI-Algorithmus wird das Result Objekt mit unterschiedlichen Erkennungsdaten gefüllt. Im Fall von ALGORITHM_OBJECT_RECOGNITION können wir den name, classID, Mittelpunkt (xCenter, yCenter) und die Dimensionen des Begrenzungsrahmens (width, height) abrufen:
Result *r = huskylens.popCachedResult(TASK);
sprintf(text, "%10s (%d) x=%3d y=%3d w=%3d h=%3d",
r->name.c_str(),
r->classID,
r->xCenter,
r->yCenter,
r->width,
r->height);
Serial.println(text);
Wenn Sie den Code auf Ihren Arduino hochladen und ausführen, sollte der HUSKYLENS automatisch den Objekterkennungs-Algorithmus aktivieren:
und Sie sollten die Namen und weitere Informationen der erkannten Objekte im Serial Monitor sehen:
Ergebnisse und Mikroprozessor
Beachten Sie, dass einige Ergebnisse nicht nur vom KI-Algorithmus, sondern auch vom an den HUSKYLENS angeschlossenen Mikroprozessor abhängen.
Für Mikroprozessoren mit mehr Speicher als der Arduino, z. B. den ESP32, erhalten Sie für einige Algorithmen detailliertere Ergebnisse (siehe Differences in Data Acquisition). Dies ist in der Result.h Datei der DFRobot_HuskylensV2 Bibliothek definiert, mit folgender Definition:
#if defined(ESP32) || defined(NRF5) || defined(ESP8266) #define LARGE_MEMORY 1 #endif
Das bedeutet, dass ESP32, ESP8266 und NRF5 als speicherstark erkannt werden und Result Objekte, wie FaceResult mit mehr Informationen, dann definiert und zurückgegeben werden:
#ifdef LARGE_MEMORY
class FaceResult : public Result {
public:
FaceResult(const void *buf);
public:
int16_t leye_x;
int16_t leye_y;
int16_t reye_x;
int16_t reye_y;
int16_t nose_x;
int16_t nose_y;
int16_t lmouth_x;
int16_t lmouth_y;
int16_t rmouth_x;
int16_t rmouth_y;
};
Im nächsten Abschnitt verbinden wir einen ESP32 mit dem HUSKYLENS und rufen die umfangreicheren Ergebnisse für den Gesichtserkennungs-Algorithmus ab.
HUSKYLENS 2 mit ESP32 verbinden
Der hier verwendete ESP32 lite hat dieselbe maximale Ausgangsstrombegrenzung von 500mA wegen des eingebauten ME6211 Spannungsreglers. Wir verbinden daher erneut ESP32 und HUSKYLENS über das Netzteil-Adapterboard, um eine Überlastung des Spannungsreglers zu vermeiden.
Unten sehen Sie den vollständigen Schaltplan. Er ist im Wesentlichen derselbe wie für den Arduino. Allerdings ist VCC mit dem 3,3V-Ausgang des ESP32 verbunden und SCL sowie SDA sind an die Pins 23 bzw. 19 angeschlossen:
Die Hardware-I2C-Pins hängen von Ihrem ESP32-Board ab. Schauen Sie entweder ins Datenblatt Ihres ESP32-Boards oder sehen Sie sich unser Find I2C and SPI default pins Tutorial an, um die I2C-Pins für ein anderes Board zu identifizieren.
Codebeispiel: Gesichtserkennung
In diesem Codebeispiel rufen wir Erkennungsergebnisse des Face Recognition Algorithmus ab. Er liefert die Koordinaten für linkes und rechtes Auge, die Nase sowie die linken und rechten Mundwinkel. Die weißen Punkte im folgenden Bild zeigen diese Landmarken:
Beachten Sie, dass der folgende Code nur für ESP32, ESP8266 oder NRF5 Mikroprozessoren kompiliert, nicht für Arduino, weshalb wir im vorherigen Abschnitt einen ESP32 mit dem HUSKYLENS verbunden haben.
// (c) www.makerguides.com
#include "DFRobot_HuskylensV2.h"
#define TASK ALGORITHM_FACE_RECOGNITION
HuskylensV2 huskylens;
void setup() {
Serial.begin(115200);
Wire.begin();
while (!huskylens.begin(Wire)) {
Serial.println(F("Can't init HUSKYLENS!"));
delay(100);
}
huskylens.switchAlgorithm(TASK);
Serial.println("running...");
}
void loop() {
static char text[128];
while (!huskylens.getResult(TASK)) {
delay(100);
}
while (huskylens.available(TASK)) {
FaceResult *r = static_cast<FaceResult *>(huskylens.popCachedResult(TASK));
sprintf(text, "%3d [%3d %3d %3d %3d %3d %3d %3d %3d %3d %3d]",
r->classID,
r->leye_x,
r->leye_y,
r->reye_x,
r->reye_y,
r->nose_x,
r->nose_y,
r->lmouth_x,
r->lmouth_y,
r->rmouth_x,
r->rmouth_y);
Serial.println(text);
}
delay(1000);
}
Konstanten und Objekte
Wir beginnen mit der Definition einer Konstante TASK für den KI-Algorithmus, den ALGORITHM_FACE_RECOGNITION. Dann erstellen wir wie gewohnt das HuskylensV2-Objekt:
#define TASK ALGORITHM_FACE_RECOGNITION HuskylensV2 huskylens;
Setup
Die Setup-Funktion bleibt ebenfalls unverändert. Wir initialisieren die serielle Kommunikation und versuchen dann, eine Verbindung zum HUSKYLENS herzustellen. Falls dies fehlschlägt und Sie „Can’t init HUSKYLENS!“ im Serial Monitor sehen, überprüfen Sie die Verkabelung!
void setup() {
Serial.begin(115200);
Wire.begin();
while (!huskylens.begin(Wire)) {
Serial.println(F("Can't init HUSKYLENS!"));
delay(100);
}
huskylens.switchAlgorithm(TASK);
Serial.println("running...");
}
Anschließend wird der KI-Algorithmus ALGORITHM_FACE_RECOGNITION auf dem HUSKYLENS via huskylens.switchAlgorithm(TASK) aktiviert und wir sind bereit, Gesichter zu erkennen.
Loop
In der loop()-Funktion gibt es eine wichtige Änderung: Wir casten das von der huskylens.popCachedResult() Funktion zurückgegebene Ergebnis in den FaceResult Typ. Dieser Typ enthält die Koordinaten von Augen, Nase und Mund für das erkannte Gesicht, die wir dann ausgeben:
FaceResult *r = static_cast<FaceResult *>(huskylens.popCachedResult(TASK));
sprintf(text, "%3d [%3d %3d %3d %3d %3d %3d %3d %3d %3d %3d]",
r->classID,
r->leye_x,
r->leye_y,
r->reye_x,
r->reye_y,
r->nose_x,
r->nose_y,
r->lmouth_x,
r->lmouth_y,
r->rmouth_x,
r->rmouth_y);
Serial.println(text);
Wenn Sie diesen Code auf Ihren ESP32 hochladen, sollten Sie folgende Ausgabe im Serial Monitor sehen, wenn Gesichter erkannt werden:
Beachten Sie, dass Sie ähnlichen Code auf dem Arduino UNO ausführen können, aber nur Mittelpunkt und Begrenzungsrahmen zurückbekommen, wegen des geringeren Speichers des Arduino. Sie könnten z. B. die loop()-Funktion wie folgt ändern:
Result *r = static_cast<Result *>(huskylens.popCachedResult(TASK));
sprintf(text, "%3d [%3d %3d %3d %3d]",
r->classID,
r->xCenter,
r->yCenter,
r->width,
r->height);
Serial.println(text);
Codebeispiel: Emotionen-Ampel
Im letzten Beispiel bauen wir eine Emotionen-Ampel. Sie verwendet den Face Emotion Recognition Algorithmus des HUSKYLENS, um Emotionen wie „Wut“, „Neutral“ oder „Glück“ in Gesichtern zu erkennen, und schaltet basierend darauf eine rote, gelbe oder grüne LED ein.
Ich verwende hier einen Arduino, aber ein ESP32 würde ebenfalls funktionieren. Zuerst müssen wir die LEDs anschließen. Das folgende Diagramm zeigt, wie sie an den Arduino UNO angeschlossen werden:
Ich habe die rote LED an Pin 11, die gelbe LED an Pin 10 und die grüne LED an Pin 9 angeschlossen. Vergessen Sie nicht den 220-Ohm-Widerstand oder einen ähnlichen, um den Strom durch die LEDs zu begrenzen. Das Foto unten zeigt die Verdrahtung auf dem Breadboard:
Jetzt sind wir bereit, den Code für unsere Emotionen-Ampel zu schreiben. Er fügt Funktionen zur Steuerung der LEDs hinzu und erweitert die loop()-Funktion, um LEDs je nach Ergebnis (Emotion) des Gesichtsemotions-Erkennungsalgorithmus einzuschalten:
// (c) www.makerguides.com
#include "DFRobot_HuskylensV2.h"
#define RED_LED 11
#define YELLOW_LED 10
#define GREEN_LED 9
#define TASK ALGORITHM_EMOTION_RECOGNITION
HuskylensV2 huskylens;
void initLEDs() {
pinMode(RED_LED, OUTPUT);
pinMode(YELLOW_LED, OUTPUT);
pinMode(GREEN_LED, OUTPUT);
switchOffLEDs();
}
void switchOffLEDs() {
digitalWrite(RED_LED, LOW);
digitalWrite(YELLOW_LED, LOW);
digitalWrite(GREEN_LED, LOW);
}
void switchOnLED(int led) {
digitalWrite(led, HIGH);
}
void setup() {
Serial.begin(115200);
initLEDs();
Wire.begin();
while (!huskylens.begin(Wire)) {
Serial.println(F("Can't init HUSKYLENS!"));
delay(100);
}
huskylens.switchAlgorithm(TASK);
Serial.println("running...");
}
void loop() {
while (!huskylens.getResult(TASK)) {
delay(100);
}
while (huskylens.available(TASK)) {
Result *r = static_cast<Result *>(huskylens.popCachedResult(TASK));
Serial.println(r->name);
switchOffLEDs();
if (r->name == "Happiness") {
switchOnLED(GREEN_LED);
}
if (r->name == "Neutral") {
switchOnLED(YELLOW_LED);
}
if (r->name == "Anger") {
switchOnLED(RED_LED);
}
}
delay(1000);
}
Definitionen
Wir beginnen mit der Definition der Pins für die LEDs und des TASK als ALGORITHM_EMOTION_RECOGNITION :
#define RED_LED 11 #define YELLOW_LED 10 #define GREEN_LED 9 #define TASK ALGORITHM_EMOTION_RECOGNITION
LED-Funktionen
Als Nächstes implementieren wir Funktionen zur Initialisierung und Steuerung der drei LEDs:
void initLEDs() {
pinMode(RED_LED, OUTPUT);
pinMode(YELLOW_LED, OUTPUT);
pinMode(GREEN_LED, OUTPUT);
switchOffLEDs();
}
void switchOffLEDs() {
digitalWrite(RED_LED, LOW);
digitalWrite(YELLOW_LED, LOW);
digitalWrite(GREEN_LED, LOW);
}
void switchOnLED(int led) {
digitalWrite(led, HIGH);
}
Setup
Im Setup initialisieren wir die serielle und I2C-Kommunikation sowie die LEDs. Dann verbinden wir uns mit dem HUSKYLENS via huskylens.begin(Wire) und starten den KI-Algorithmus wie gewohnt via huskylens.switchAlgorithm(TASK):
void setup() {
Serial.begin(115200);
initLEDs();
Wire.begin();
while (!huskylens.begin(Wire)) {
Serial.println(F("Can't init HUSKYLENS!"));
delay(100);
}
huskylens.switchAlgorithm(TASK);
Serial.println("running...");
}
Loop
Schließlich haben wir die loop()-Funktion, in der wir das Emotionserkennungsergebnis abrufen und je nach erkannter Emotion die rote, gelbe oder grüne LED einschalten:
Result *r = static_cast<Result *>(huskylens.popCachedResult(TASK));
Serial.println(r->name);
switchOffLEDs();
if (r->name == "Happiness") {
switchOnLED(GREEN_LED);
}
if (r->name == "Neutral") {
switchOnLED(YELLOW_LED);
}
if (r->name == "Anger") {
switchOnLED(RED_LED);
}
}
Beachten Sie, dass es neben „Glück“, „Wut“ und „Neutral“ noch weitere Emotionen wie „Angst“, „Ekel“, „Traurig“ und „Überrascht“ gibt, auf die der aktuelle Code nicht reagiert. Sie könnten ihn aber leicht auf diese Emotionen erweitern.
Wenn Sie den Code auf Ihrem Arduino ausführen, sollte der HUSKYLENS den Gesichtsemotions-Erkennungsalgorithmus aktivieren:
und im Serial Monitor sollten Sie eine Ausgabe ähnlich der folgenden sehen. Auch die entsprechenden LEDs für die erkannten Emotionen sollten leuchten:
Und das war’s! Die Codebeispiele und Schaltpläne oben sollten Ihnen den Einstieg in den HUSKYLENS 2 erleichtern.
Fazit
Dieses Tutorial zeigte Ihnen, wie Sie mit dem HUSKYLENS 2 KI-Vision-Sensor starten. Sie haben gelernt, wie man ihn mit Arduino oder ESP32 verbindet und wie man Erkennungsergebnisse der verschiedenen integrierten KI-Algorithmen abruft. Ich empfehle Ihnen auch, das Tutorial for HUSKYLENS 2 and Arduino Code Programming von DFRobot zu lesen.
Der HUSKYLENS 2 macht es extrem einfach, sich mit verschiedenen KI-Anwendungen wie Objekt- und Gesichtserkennung, Handgesten- und Pose-Erkennung, OCR und vielen anderen vertraut zu machen. Sie können einige der KI-Algorithmen einfach trainieren/anpassen und sogar eigene benutzerdefinierte KI-Modelle herunterladen. Für mehr Details schauen Sie sich DFRobot’s Wiki for the HUSKYLENS 2 an.
Der größte Vorteil eines KI-Sensors wie dem HUSKYLENS 2 ist, dass Sie KI-Modelle lokal auf dem Gerät ausführen können. Es ist keine WLAN-Verbindung zu einem Cloud-Service mit potenziell hoher Latenz oder Verbindungsproblemen nötig.
Die Nachteile sind ein potenziell höherer Stromverbrauch und eine geringere Genauigkeit der Modelle. Ich habe einen Strom von bis zu 420mA für das OCR-Modell gemessen, das den höchsten Verbrauch zu haben scheint.
Die Genauigkeit der Modelle variiert. Ich fand die Gesichtsemotions-Erkennung sehr gut, während das Objekterkennungsmodell viele Fehlklassifikationen lieferte. Wahrscheinlich möchten Sie für Objekterkennungsaufgaben ein eigenes Modell mit weniger Klassen verwenden oder die Self-Learning Classifier Funktion ausprobieren.
Wenn Sie Fragen haben, können Sie diese gerne im Kommentarbereich stellen.
Viel Spaß beim Tüfteln 😉
