Der HUSKYLENS ist ein kompakter Edge-AI-Vision-Sensor. Angetrieben von einem Kendryte K210 AI-Chip und ausgestattet mit einem kleinen 2,0-Zoll-IPS-Display unterstützt das Gerät integrierte Erkennungs- und Verfolgungsfunktionen wie Gesichtserkennung, Objekterkennung und -verfolgung, Farb- und Linienerkennung, Tag-Erkennung sowie Objektklassifizierung.
Neue Objekte oder Muster können einfach erlernt werden, und Informationen über erkannte Objekte können über UART- oder I2C-Schnittstellen an gängige Mikrocontroller wie Arduino, ESP32 oder Raspberry Pi übertragen werden.
In diesem Tutorial lernst du, wie du den HUSKYLENS mit einem Arduino UNO verbindest und Erkennungsergebnisse für Linienverfolgung und Objektklassifizierung abrufst.
Benötigte Teile
Den HUSKYLENS kannst du über DFRobot oder Amazon über die untenstehenden Links beziehen. Außerdem benötigst du einen Mikrocontroller. Ich verwende einen Arduino UNO, aber auch andere Arduino-Boards funktionieren gut. Die einzige Voraussetzung ist die Unterstützung einer I2C- (oder UART-) Schnittstelle.
HUSKYLENS
Arduino Uno
USB-Kabel für Arduino UNO
Dupont-Kabelset
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 HUSKYLENS
Im Kern des HUSKYLENS-Moduls befindet sich ein Kendryte K210 System-on-Chip, der einen dualen 64-Bit RISC-V CPU-Komplex mit dedizierten Hardwarebeschleunigern für Convolutional Neural Networks und Signalverarbeitung integriert.
Diese Architektur ermöglicht es dem Gerät, mehrere klassische und Deep-Learning-basierte Vision-Algorithmen vollständig am Edge auszuführen, ohne auf einen externen Host für die Inferenz angewiesen zu sein. Der K210 verfügt über mehrere Megabyte On-Chip-SRAM, das als Frame-Buffer und Zwischenspeicher für Feature-Maps dient, was Echtzeitverarbeitung ermöglicht und die externe Speicherbandbreite sowie Latenz gering hält.
KI-Modelle
Die Firmware auf dem K210 bietet sieben Hauptfunktionen für maschinelles Sehen: Gesichtserkennung, Objektverfolgung, Objekterkennung, Linienverfolgung, Farberkennung, Tag-Erkennung und Objektklassifizierung.
Diese Funktionen teilen sich eine gemeinsame Inferenz-Pipeline, unterscheiden sich jedoch in Vorverarbeitung, Modell-Topologie und Nachverarbeitung. Das Ergebnis ist eine Reihe optimierter, vorab abgestimmter Modelle, die zur Laufzeit über die integrierte Benutzeroberfläche oder serielle Befehle gewechselt werden können, ohne dass der Nutzer Modelle manuell verwalten oder bereitstellen muss.
Bildsensor- und Display-Subsystem
HUSKYLENS verwendet einen digitalen Bildsensor, der über eine DVP-Kamera-Schnittstelle mit dem K210 verbunden ist. Je nach Produktionscharge basiert das Kameramodul entweder auf einem OV2640- oder einem GC0328-Sensor, die beide einen Rolling-Shutter-RGB-Ausgang bieten, der für eingebettete Vision-Aufgaben geeignet ist. Die OV2640-Variante bietet eine native Auflösung von bis zu 2 Megapixeln, während der GC0328 eine kostengünstigere, niedrigauflösende Option ist.
Das Modul integriert ein 2,0-Zoll-IPS-LCD mit einer Auflösung von 320 × 240 Pixeln. Dieses Display ist eng mit der Vision-Pipeline verbunden und wird verwendet, um den Live-Kamerafeed darzustellen, Erkennungsrahmen, IDs und Vertrauensindikatoren zu überlagern sowie Funktionsnamen und Konfigurationsmenüs anzuzeigen.
Die Display-Schnittstelle wird direkt vom K210 angesteuert, was es dem Gerät ermöglicht, eine sofortige visuelle Erklärung dessen zu liefern, was die Vision-Algorithmen erkennen, ohne dass eine Host-Interaktion erforderlich ist.
Stromversorgung und elektrische Eigenschaften
Elektrisch ist der HUSKYLENS für den Betrieb mit typischen 3,3-Volt- und 5-Volt-Eingangsspannungen ausgelegt. Der spezifizierte Spannungsbereich liegt zwischen 3,3 V und 5,0 V, und sowohl der Gravity 4-Pin-Anschluss als auch der Micro-USB-Anschluss können als Stromversorgung genutzt werden. Eine automatische Stromquellen-Auswahl auf dem Board priorisiert die USB-Eingabe, wenn beide angeschlossen sind.
Im typischen Betrieb mit Gesichtserkennung, bei einer LCD-Hintergrundbeleuchtung von 80 % Helligkeit und deaktiviertem Fülllicht, zieht das Modul etwa 320 mA bei 3,3 V oder 230 mA bei 5,0 V. Dieser Stromverbrauch wird durch den kontinuierlichen Betrieb des neuronalen Netzwerkbeschleunigers des K210 und das aktive Display verursacht.
Kommunikationsschnittstellen
Der HUSKYLENS bietet zwei Kommunikationsschnittstellen zur Integration mit Mikrocontrollern: UART und I2C. Diese Schnittstellen sind auf den standardmäßigen DFRobot Gravity 4-Pin-Anschluss geführt.
Im UART-Modus entsprechen die vier Pins TX, RX, Masse und VCC, während sie im I2C-Modus SDA, SCL, Masse und VCC sind. Die folgenden beiden Tabellen zeigen die Pinbelegung für UART- und I2C-Modus:
| Num | Label | Pin-Funktion | Beschreibung |
|---|---|---|---|
| 1 | T | TX | TX-Pin des HuskyLens |
| 2 | R | RX | RX-Pin des HuskyLens |
| 3 | – | GND | Masse (0V) |
| 4 | + | VCC | Plus (3,3~5,0V) |
| Num | Label | Pin-Funktion | Beschreibung |
|---|---|---|---|
| 1 | T | SDA | Serielle Datenleitung |
| 2 | R | SCL | Serielle Taktleitung |
| 3 | – | GND | Masse (0V) |
| 4 | + | VCC | Plus (3,3~5,0V) |
Beide Schnittstellenmodi unterstützen das vollständige Befehlsprotokoll zur Konfiguration von Algorithmen, zum Auslösen von Lernvorgängen und zum Auslesen von Erkennungsergebnissen wie Begrenzungsrahmen-Koordinaten und IDs.
Integrierte Benutzeroberfläche und Bedienelemente
Das Modul verfügt über eine lokale Benutzeroberfläche mit zwei Hardware-Tasten und dem integrierten Display. Die „Funktion“-Taste dient hauptsächlich als Modusauswahl und Konfigurationssteuerung. Wenn der Benutzer diese Taste nach links oder rechts dreht oder „wählt“, durchläuft die Firmware die verfügbaren Vision-Funktionen und aktualisiert den Bildschirm, um den aktuellen Algorithmus anzuzeigen.
Ein langer Druck auf die Funktionstaste öffnet ein Parameter-Menü der zweiten Ebene für die aktive Funktion. Dort kannst du Parameter wie Empfindlichkeit, Erkennungsschwellen, LED-Einstellungen und Optionen für das Lernen mehrerer Objekte anpassen – ganz ohne externen Controller.
Die „Lern“-Taste ist eng mit den internen Trainingsroutinen jedes Algorithmus verbunden. Ein kurzer Druck weist das Gerät an, das Objekt oder die Farbe zu lernen, die aktuell unter dem Fadenkreuz auf dem Bildschirm zentriert ist.
Ein langer Druck aktiviert das kontinuierliche Lernen über mehrere Frames. So kann das System ein robusteres Modell über Variationen in Entfernung, Winkel oder Beleuchtung aufbauen. Wenn ein bereits gelerntes Ziel vorhanden ist, kann ein weiterer kurzer Druck verwendet werden, um die zugehörigen Modelldaten zu löschen.
HUSKYLENS mit Arduino UNO verbinden
Du kannst mit dem HUSKYLENS über das UART- oder das I2C-Protokoll kommunizieren. I2C ist schneller und ermöglicht den Anschluss mehrerer Geräte am selben Bus. Deshalb verwenden wir hier I2C.
Der Gravity-Anschluss des HUSKYLENS stellt die I2C-Schnittstelle (SDA(T), SCL(R)) und die Stromversorgungs-Pins (VCC(+), GND(-)) bereit. Das folgende Foto zeigt, wie du den HUSKYLENS mit einem Arduino UNO verdrahtest:
Das rote Kabel muss mit dem 5V-Pin des Arduino verbunden werden, das schwarze Kabel mit GND. Das grüne Kabel ist SDA und sollte mit A4 verbunden werden. Das blaue Kabel ist SCL und sollte mit A5 des Arduino verbunden werden.
Beachte, dass du im HUSKYLENS die Kommunikation auf I2C einstellen musst. Gehe zu „General Settings“, dann „Protocol Type“, wähle „I2C“ und speichere die Einstellungen wie unten gezeigt:
Wenn du detailliertere Anweisungen benötigst, lies das HUSKYLENS Wiki.
Installation der HUSKYLENS-Bibliothek
Um Erkennungsergebnisse vom HUSKYLENS abzurufen, müssen wir die HUSKYLENS Library installieren. Klicke auf link, um die Bibliothek als „HUSKYLENSArduino-master.zip“ auf deinen Computer herunterzuladen. Entpacke dann die ZIP-Datei, um deren Inhalt zu extrahieren. Du solltest folgende Dateien im entpackten Ordner sehen:
Als Nächstes kopieren wir den Ordner „HUSKYLENS“ in den „libraries“-Ordner der Arduino IDE. Unter Windows befindet sich der „libraries“-Ordner typischerweise hier:
C:\Users\<username>\OneDrive\Documents\Arduino\libraries
Da dieser Ordner bereits installierte Bibliotheken enthält, empfehle ich, ihn vorübergehend umzubenennen, z. B. in „_libraries“, und einen neuen Ordner namens „libraries“ zu erstellen. So vermeidest du Konflikte mit bereits installierten Bibliotheken und verlierst sie nicht. Später kannst du diese Änderung leicht rückgängig machen. Das Bild unten zeigt, wie dein „Arduino“-Ordner mit den Bibliotheken aussehen sollte:
Jetzt können wir den Ordner „HUSKYLENS“ in den neuen „libraries“-Ordner kopieren, wie unten gezeigt:
Der „libraries“-Ordner kann weitere Bibliotheken enthalten, aber für dieses Projekt benötigen wir keine anderen.
Code-Beispiel: Linienverfolgung
Im ersten Code-Beispiel probieren wir den Line Tracking-Algorithmus aus. Der Vorteil ist, dass du den HUSKYLENS nicht trainieren musst, um Linien zu erkennen, da diese Funktion ohne Lernen funktioniert.
Der folgende Code verbindet den Arduino über I2C mit dem HUSKYLENS und gibt die Start- und Endpunkte erkannter Liniensegmente aus. Schau dir den Code zuerst kurz an, dann besprechen wir die Details.
#include "HUSKYLENS.h"
HUSKYLENS huskylens;
void setup() {
Serial.begin(115200);
Wire.begin();
if (!huskylens.begin(Wire)) {
Serial.println("Can't connect!");
}
huskylens.writeAlgorithm(ALGORITHM_LINE_TRACKING);
}
void loop() {
static char text[100];
huskylens.request();
while (huskylens.available()) {
HUSKYLENSResult r = huskylens.read();
sprintf(text, "x=%d, y=%d, w=%d, h=%d",
r.xOrigin, r.yOrigin, r.xTarget, r.yTarget);
Serial.println(text);
delay(1000);
}
}
Imports
Wir beginnen mit dem Einbinden der HUSKYLENS-Bibliothek mittels der Direktive #include "HUSKYLENS.h". Dieser Import stellt alle Klassendefinitionen, Konstanten und Kommunikationsroutinen bereit, die für die Schnittstelle mit der HUSKYLENS AI-Kamera benötigt werden.
#include "HUSKYLENS.h"
Beachte, dass diese Bibliothek derzeit (Dezember 2025) nicht für den ESP32-Core kompiliert.
Objektinstanziierung
Nach der Include-Direktive erstellen wir eine globale Instanz der HUSKYLENS-Klasse. Das Objekt mit dem Namen huskylens hält den internen Zustand der Geräte-Schnittstelle und stellt die API bereit, die im gesamten Programm verwendet wird.
HUSKYLENS huskylens;
Setup
Die setup()-Funktion initialisiert die serielle Schnittstelle des Boards, den I2C-Bus und das HUSKYLENS-Gerät selbst.
Das Programm ruft Serial.begin(115200) auf, um die serielle Ausgabe mit 115200 Baud zu konfigurieren. Danach wird die I2C-Kommunikation mit Wire.begin() aktiviert. Anschließend starten wir die Kommunikation mit dem Gerät durch Aufruf von huskylens.begin(Wire). Diese Methode konfiguriert den internen Treiber, setzt die I2C-Adresse und prüft, ob das Modul antwortet. Falls die Initialisierung fehlschlägt, gibt das Programm eine Fehlermeldung auf der seriellen Konsole aus.
Nach der Initialisierung wählen wir den eingebauten Vision-Algorithmus aus, den das Gerät ausführen soll. In diesem Beispiel aktivieren wir den Linienverfolgungs-Algorithmus mit huskylens.writeAlgorithm(ALGORITHM_LINE_TRACKING).
void setup() {
Serial.begin(115200);
Wire.begin();
if (!huskylens.begin(Wire)) {
Serial.println("Can't connect!");
}
huskylens.writeAlgorithm(ALGORITHM_LINE_TRACKING);
}
Die Konstanten für andere KI-Algorithmen findest du in der Header-Datei der Bibliothek, sie lauten wie folgt:
ALGORITHM_FACE_RECOGNITION ALGORITHM_OBJECT_TRACKING ALGORITHM_OBJECT_RECOGNITION ALGORITHM_LINE_TRACKING ALGORITHM_COLOR_RECOGNITION ALGORITHM_TAG_RECOGNITION ALGORITHM_OBJECT_CLASSIFICATION
Loop
In der loop()-Funktion führen wir eine kontinuierliche Datenerfassung vom Sensor durch. Ein statischer Zeichenpuffer namens text wird deklariert, um formatierte Ausgabemeldungen zu halten. Die Deklaration als static stellt sicher, dass der Speicher nur einmal zugewiesen wird.
Das Sketch sendet eine Datenanforderung an das HUSKYLENS-Gerät durch Aufruf von huskylens.request(). Diese Methode veranlasst die Kamera, den aktuellsten Satz von Erkennungs- oder Verfolgungsergebnissen zu senden.
Nach der Anforderung betreten wir eine Schleife, die so lange läuft, wie das Gerät verfügbare Ergebnisse meldet. Jede Iteration ruft ein Ergebnisobjekt mit huskylens.read() ab. Die zurückgegebene HUSKYLENSResult-Struktur enthält geometrische Informationen über das erkannte Element. Im Linienverfolgungsmodus entsprechen diese Werte dem Mittelpunktursprung (xOrigin, yOrigin) und dem Endpunkt oder Zielkoordinate (xTarget, yTarget) des erkannten Liniensegments.
void loop() {
static char text[100];
huskylens.request();
while (huskylens.available()) {
HUSKYLENSResult r = huskylens.read();
sprintf(text, "x=%d, y=%d, w=%d, h=%d",
r.xOrigin, r.yOrigin, r.xTarget, r.yTarget);
Serial.println(text);
delay(1000);
}
}
Wir formatieren diese vier Ganzzahlwerte in eine lesbare Nachricht mit sprintf und geben sie dann im seriellen Monitor aus. Im Serial Monitor solltest du Daten ähnlich dem folgenden Screenshot sehen:
Beachte, dass die Standard-Linienerkennung recht empfindlich ist und selbst bei klar sichtbaren Linien nicht zuverlässig funktioniert. Du kannst die Genauigkeit verbessern, indem du den line tracking-Algorithmus trainierst.
Linienwinkel
Oft möchte man den Winkel der Linie wissen, zum Beispiel zur Steuerung der Fahrtrichtung eines Roboters. Hier ist eine Funktion, mit der du diesen Winkel berechnen kannst:
float calcAngle(const HUSKYLENSResult &r) {
float dx = (float)r.xTarget - (float)r.xOrigin;
float dy = (float)r.yTarget - (float)r.yOrigin;
float angleRad = atan2(dy, dx);
float angleDeg = angleRad * 180.0 / PI + 90;
return angleDeg;
}
Wenn die Linie geradeaus zeigt, gibt die Funktion einen Winkel von 0 Grad zurück. Zeigt die Linie nach links, ist der Winkel negativ, sonst positiv. Du kannst den Winkel mit folgendem Code abrufen und ausgeben.
float angle = calcAngle(r); Serial.println(angle);
Im nächsten Abschnitt führen wir die Objektklassifizierung durch.
Code-Beispiel: Objektklassifizierung
Für dieses Beispiel musst du zuerst zwei Objekte vom HUSKYLENS lernen lassen. Siehe die Anweisungen im DFRobot Wiki für Object Classification für Details. Ich habe eine kleine Weihnachtsmannfigur und ein Spielzeugauto verwendet, um meinen HUSKYLENS zu trainieren:
Sobald du zwei Objekte gelernt hast, kannst du den folgenden Code verwenden, um die Objekterkennung auszuführen und die Namen der erkannten Objekte im Serial Monitor auszugeben:
// (c) www.makerguides.com
#include "HUSKYLENS.h"
const char* names[] = {"", "Santa", "Car"};
HUSKYLENS huskylens;
void setup() {
Serial.begin(115200);
Wire.begin();
if (!huskylens.begin(Wire)) {
Serial.println("Can't connect!");
}
huskylens.writeAlgorithm(ALGORITHM_OBJECT_CLASSIFICATION);
huskylens.setCustomName(names[1], 1);
huskylens.setCustomName(names[2], 2);
}
void loop() {
huskylens.request();
while (huskylens.available()) {
HUSKYLENSResult r = huskylens.read();
Serial.println(names[r.ID]);
delay(1000);
}
}
Imports
Wie zuvor beginnen wir mit dem Einbinden der HUSKYLENS-Bibliothek:
#include "HUSKYLENS.h"
Konstanten
Als Nächstes definieren wir ein konstantes Array namens names. Dieses Array enthält menschenlesbare Bezeichnungen, die den Klassifizierungs-IDs entsprechen, die vom HUSKYLENS-Gerät generiert werden. Der erste Eintrag ist ein leerer String, da die Klassifizierungs-IDs bei eins beginnen. Index eins entspricht dem String „Santa“ und Index zwei „Car“.
const char* names[] = {"", "Santa", "Car"};
Objektinstanziierung
Dann erstellen wir das HUSKYLENS-Objekt mit dem Namen huskylens.
HUSKYLENS huskylens;
Setup
In der setup()-Funktion initialisieren wir die serielle Kommunikation, die I2C-Schnittstelle und den HUSKYLENS-Sensor.
Die nächste Zeile initialisiert das I2C-Subsystem mit Wire.begin(). Der Aufruf von huskylens.begin(Wire) konfiguriert den Gerätetreiber und prüft, ob der Sensor auf dem Bus antwortet. Falls die Initialisierung fehlschlägt, gibt das Programm eine Fehlermeldung aus.
Nach der Kommunikation wählt das Programm den Objektklassifizierungs-Algorithmus durch Aufruf von huskylens.writeAlgorithm(ALGORITHM_OBJECT_CLASSIFICATION) aus. Andernfalls müsstest du den Algorithmus manuell am HUSKYLENS auswählen.
void setup() {
Serial.begin(115200);
Wire.begin();
if (!huskylens.begin(Wire)) {
Serial.println("Can't connect!");
}
huskylens.writeAlgorithm(ALGORITHM_OBJECT_CLASSIFICATION);
huskylens.setCustomName(names[1], 1);
huskylens.setCustomName(names[2], 2);
}
Die nächsten zwei Zeilen weisen den IDs benutzerdefinierte Namen zu. Die Funktion huskylens.setCustomName(names[1], 1) verknüpft den String „Santa“ mit der Klassifizierungs-ID 1. Die nächste Zeile macht dasselbe für ID 2 und weist den Namen „Car“ zu. Diese benutzerdefinierten Bezeichnungen werden auf dem Bildschirm des HUSKYLENS angezeigt, wenn ein Objekt erkannt wird. Siehe die Screenshots unten:
Loop
Die loop()-Funktion übernimmt das Abrufen der Daten von der Klassifizierungs-Engine. Jede Iteration beginnt mit der Anforderung der aktuellsten Ergebnisse vom Sensor durch den Aufruf huskylens.request().
Die anschließende while-Schleife verarbeitet alle derzeit verfügbaren Ergebnisse. Die Methode huskylens.available() zeigt an, ob mindestens eine Ergebnisstruktur zum Lesen bereitsteht. Wenn ein Ergebnis vorhanden ist, ruft das Sketch es mit huskylens.read() ab, das ein HUSKYLENSResult-Objekt zurückgibt.
Das Feld r.ID enthält die vom Modul zugewiesene Klassifizierungs-ID. Das Programm verwendet diese ID als Index in das names-Array und gibt die zugehörige Bezeichnung im seriellen Monitor aus. Anschließend folgt eine Sekunde Verzögerung, um die Ausgabe zu verlangsamen und die Ergebnisse besser beobachten zu können.
void loop() {
huskylens.request();
while (huskylens.available()) {
HUSKYLENSResult r = huskylens.read();
Serial.println(names[r.ID]);
delay(1000);
}
}
Der Objektklassifizierer gibt keinen Vertrauenswert zurück, daher kannst du keine Erkennungen mit niedriger Sicherheit filtern. Selbst wenn kein Objekt vor dem HUSKYLENS ist, wird die ID der ersten Klasse zurückgegeben. Folglich wird in meinem Fall der Hintergrund als „Santa“ erkannt. Du musst eine separate „Hintergrundklasse“ trainieren, um das zu umgehen.
Beachte auch, dass der Objektklassifizierer keine Objektpositionsinformationen (x, y, w, h) zurückgibt, was sich von den face detection– oder object tracking-Algorithmen unterscheidet.
Fazit
Dieses Tutorial hat dir gezeigt, wie du mit dem HUSKYLENS AI Vision Sensor startest. Du hast gelernt, wie du ihn an einen Arduino anschließt und wie du Erkennungsergebnisse der integrierten KI-Algorithmen abrufst. Ich empfehle dir auch, das HUSKYLENS Wiki von DFRobot für weitere Code-Beispiele und Anleitungen zu lesen.
Der HUSKYLENS macht es einfach, verschiedene KI-Algorithmen wie Gesichtserkennung, Objektklassifizierung, Objektverfolgung, Linienverfolgung und andere auszuprobieren. Es ist kein komplexer Trainingscode erforderlich, allerdings sind die Erkennungsgenauigkeit und die Anzahl der erkennbaren Objekte begrenzt.
Wenn du leistungsfähigere KI-Algorithmen und die Möglichkeit suchst, eigene KI-Modelle auf dem Gerät einzusetzen, schau dir den Nachfolger des HUSKYLENS, den HUSKYLENS 2 an. Er ist teurer und hat einen höheren Stromverbrauch, bietet aber eine größere Auswahl an KI-Algorithmen mit besseren Genauigkeiten.
Außerdem läuft die Bibliothek zur Kommunikation mit dem HUSKYLENS 2 sowohl auf Arduino- als auch auf ESP32-Plattformen, während die HUSKYLENS-Bibliothek nur auf Arduino läuft.
Sowohl der HUSKYLENS als auch der HUSKYLENS 2 haben den Vorteil, dass KI-Modelle lokal auf dem Gerät ausgeführt werden können. Es ist keine WLAN-Verbindung zu einem Cloud-Dienst mit potenziell hoher Latenz oder Verbindungsproblemen erforderlich.
Wenn du Fragen hast, kannst du sie gerne im Kommentarbereich stellen.
Viel Spaß beim Tüfteln 😉
