Le HUSKYLENS est un capteur de vision compact doté d’une IA embarquée. Alimenté par une puce AI Kendryte K210 et équipé d’un petit écran IPS de 2,0 pouces, l’appareil prend en charge des fonctions intégrées de reconnaissance et de suivi telles que la reconnaissance faciale, la reconnaissance et le suivi d’objets, la détection de couleurs et de lignes, la reconnaissance de tags et la classification d’objets.
De nouveaux objets ou motifs peuvent être facilement appris et les informations sur les objets détectés peuvent être transférées via les interfaces UART ou I2C vers des microcontrôleurs courants comme Arduino, ESP32 ou Raspberry Pi.
Dans ce tutoriel, vous apprendrez comment connecter le HUSKYLENS à un Arduino UNO et récupérer les résultats de détection pour le suivi de ligne et la classification d’objets.
Pièces requises
Vous pouvez obtenir le HUSKYLENS chez DFRobot ou Amazon via les liens ci-dessous. De plus, vous aurez besoin d’un microcontrôleur. J’utilise un Arduino UNO, mais d’autres cartes Arduino fonctionneront également. La seule exigence est la prise en charge d’une interface I2C (ou UART).
HUSKYLENS
Arduino Uno
Câble USB pour Arduino UNO
Jeu de fils Dupont
Plaque d’essai (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.
Matériel du HUSKYLENS
Au cœur du module HUSKYLENS se trouve un système sur puce Kendryte K210, qui intègre un processeur RISC-V 64 bits double cœur avec des accélérateurs matériels dédiés aux réseaux neuronaux convolutifs et au traitement du signal.
Cette architecture permet à l’appareil d’exécuter plusieurs algorithmes de vision classiques et basés sur l’apprentissage profond entièrement en périphérie, sans dépendre d’un hôte externe pour l’inférence. Le K210 inclut plusieurs mégaoctets de SRAM intégrée utilisés comme tampons d’image et pour le stockage intermédiaire des cartes de caractéristiques, ce qui permet un traitement en temps réel tout en maintenant faible la bande passante et la latence de la mémoire externe.
Modèles d’IA
Le firmware tournant sur le K210 offre sept fonctions principales de vision machine : reconnaissance faciale, suivi d’objet, reconnaissance d’objet, suivi de ligne, reconnaissance de couleur, reconnaissance de tag et classification d’objet.
Ces fonctions partagent une chaîne d’inférence commune mais se différencient par leur prétraitement, la topologie du modèle et les étapes de post-traitement. Le résultat est un ensemble de modèles optimisés et pré-réglés pouvant être changés à la volée via l’interface utilisateur embarquée ou par commandes série, sans que l’utilisateur ait à gérer ou déployer les modèles manuellement.
Capteur d’image et sous-système d’affichage
Le HUSKYLENS utilise un capteur d’image numérique connecté au K210 via une interface caméra de type DVP. Selon le lot de production, le module caméra est basé soit sur un capteur OV2640, soit sur un GC0328, tous deux fournissant une sortie RGB à obturateur roulant adaptée aux tâches de vision embarquée. La variante OV2640 offre une résolution native allant jusqu’à 2 mégapixels, tandis que le GC0328 est une option à résolution plus faible et optimisée pour le coût.
Le module intègre un écran LCD IPS de 2,0 pouces avec une résolution de 320 × 240 pixels. Cet écran est étroitement lié à la chaîne de vision et sert à afficher le flux vidéo en direct, superposer les cadres de détection, les identifiants et les indicateurs de confiance, ainsi qu’à afficher les noms des fonctions et les menus de configuration.
L’interface d’affichage est pilotée directement par le K210, ce qui permet à l’appareil de fournir une explication visuelle immédiate de ce que les algorithmes de vision détectent, sans interaction avec un hôte.
Alimentation et caractéristiques électriques
Électriquement, le HUSKYLENS est conçu pour fonctionner avec des tensions d’alimentation embarquées typiques de 3,3 volts et 5 volts. La plage de tension d’alimentation spécifiée est de 3,3 V à 5,0 V, et le connecteur Gravity 4 broches ainsi que le connecteur micro-USB peuvent être utilisés comme entrées d’alimentation. Un circuit de sélection automatique de la source d’alimentation à bord privilégie l’entrée USB lorsque les deux sont connectés.
En fonctionnement typique de reconnaissance faciale avec le rétroéclairage LCD réglé à 80 % de luminosité et la lumière de remplissage désactivée, le module consomme environ 320 mA à 3,3 V ou 230 mA à 5,0 V. Cette consommation est due au fonctionnement continu de l’accélérateur de réseau neuronal du K210 et à l’affichage actif.
Interfaces de communication
Le HUSKYLENS propose deux interfaces de communication pour l’intégration avec des microcontrôleurs : UART et I2C. Ces interfaces sont acheminées vers le connecteur standard DFRobot Gravity 4 broches.
En mode UART, les quatre broches correspondent à TX, RX, masse et VCC, tandis qu’en mode I2C elles correspondent à SDA, SCL, masse et VCC. Les deux tableaux suivants montrent la configuration des broches pour les modes UART et I2C :
| Num | Label | Fonction de la broche | Description |
|---|---|---|---|
| 1 | T | TX | Broche TX du HuskyLens |
| 2 | R | RX | Broche RX du HuskyLens |
| 3 | – | GND | Masse (0V) |
| 4 | + | VCC | Alimentation positive (3,3~5,0V) |
| Num | Label | Fonction de la broche | Description |
|---|---|---|---|
| 1 | T | SDA | Ligne de données série |
| 2 | R | SCL | Ligne d’horloge série |
| 3 | – | GND | Masse (0V) |
| 4 | + | VCC | Alimentation positive (3,3~5,0V) |
Les deux modes d’interface supportent le protocole complet de commande pour configurer les algorithmes, déclencher les opérations d’apprentissage et lire les résultats de détection tels que les coordonnées des cadres et les identifiants.
Interface utilisateur et contrôles embarqués
Le module inclut une interface utilisateur locale composée de deux boutons matériels et de l’écran intégré. Le bouton « fonction » sert principalement de sélecteur de mode et de contrôle de configuration. Lorsque l’utilisateur tourne ce bouton vers la gauche ou la droite, le firmware fait défiler les fonctions de vision disponibles, mettant à jour l’écran pour indiquer l’algorithme actif.
Une pression longue sur le bouton fonction ouvre un menu de paramètres de second niveau pour la fonction active. Vous pouvez y ajuster des paramètres tels que la sensibilité, les seuils de reconnaissance, les réglages des LED et les options d’apprentissage multi-objets sans contrôleur externe.
Le bouton « apprentissage » est étroitement lié aux routines internes d’entraînement de chaque algorithme. Une pression courte demande à l’appareil d’apprendre l’objet ou la couleur actuellement centrée sous la croix à l’écran.
Une pression longue active un apprentissage continu sur plusieurs images. Cela permet au système de construire un modèle plus robuste face aux variations de distance, d’angle ou d’éclairage. Lorsqu’une cible déjà apprise est présente, une autre pression courte peut être utilisée pour effacer ses données de modèle associées.
Connexion du HUSKYLENS à l’Arduino UNO
Vous pouvez communiquer avec le HUSKYLENS via les protocoles UART ou I2C. L’I2C est plus rapide et permet de connecter plusieurs appareils sur le même bus. Nous allons donc utiliser l’I2C.
Le connecteur Gravity du HUSKYLENS expose l’interface I2C (SDA(T), SCL(R)) et les broches d’alimentation (VCC(+), GND(-)). La photo ci-dessous montre comment câbler le HUSKYLENS avec un Arduino UNO :
Le fil rouge doit être connecté à la broche 5V de l’Arduino, et le fil noir à la masse (GND). Le fil vert est SDA et doit être connecté à A4. Le fil bleu est SCL et doit être connecté à A5 de l’Arduino.
Notez que vous devez régler le protocole de communication sur I2C dans les paramètres du HUSKYLENS. Allez dans « General Settings », puis « Protocol Type », sélectionnez « I2C » et sauvegardez les paramètres comme montré ci-dessous :
Si vous avez besoin d’instructions plus détaillées, lisez le HUSKYLENS Wiki.
Installation de la bibliothèque HUSKYLENS
Pour pouvoir récupérer les résultats de détection du HUSKYLENS, nous devons installer la HUSKYLENS Library. Cliquez sur le link pour télécharger la bibliothèque sous forme de fichier « HUSKYLENSArduino-master.zip » sur votre ordinateur. Ensuite, décompressez le fichier ZIP pour en extraire le contenu. Vous devriez voir les fichiers suivants dans le dossier décompressé :
Ensuite, nous devons copier le dossier « HUSKYLENS » dans le dossier « libraries » de l’IDE Arduino. Sous Windows, le dossier « libraries » se trouve généralement sous :
C:\Users\<username>\OneDrive\Documents\Arduino\libraries
Comme ce dossier contient déjà des bibliothèques installées, je vous recommande de le renommer temporairement, par exemple en « _libraries », et de créer un nouveau dossier nommé « libraries ». Ainsi, vous évitez les conflits avec vos bibliothèques déjà installées sans les perdre. Vous pourrez facilement revenir en arrière plus tard. L’image ci-dessous montre à quoi devrait ressembler votre dossier « Arduino » avec les bibliothèques :
Maintenant, nous pouvons copier le dossier « HUSKYLENS » dans le nouveau dossier « libraries » comme montré ci-dessous :
Le dossier « libraries » peut contenir d’autres bibliothèques, mais nous n’en avons pas besoin pour ce projet.
Exemple de code : Suivi de ligne
Dans le premier exemple de code, nous allons tester l’algorithme Line Tracking. Il a l’avantage de ne pas nécessiter d’entraînement du HUSKYLENS pour détecter les lignes, car cette fonction fonctionne sans apprentissage.
Le code suivant connecte l’Arduino au HUSKYLENS via I2C et affiche les points de départ et d’arrivée des segments de ligne détectés. Jetez un coup d’œil rapide au code, puis nous en discuterons en détail.
#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
Nous commençons par inclure la bibliothèque HUSKYLENS avec la directive #include "HUSKYLENS.h". Cette importation rend disponibles toutes les définitions de classes, constantes et routines de communication nécessaires pour interfacer la caméra AI HUSKYLENS dans le sketch.
#include "HUSKYLENS.h"
Notez que cette bibliothèque ne compile actuellement (décembre 2025) pas pour le core ESP32.
Instantiation de l’objet
Après la directive include, nous créons une instance globale de la classe HUSKYLENS. L’objet nommé huskylens contient l’état interne de l’interface du dispositif et expose l’API utilisée dans tout le programme.
HUSKYLENS huskylens;
Setup
La fonction setup() initialise l’interface série de la carte, le bus I2C et le dispositif HUSKYLENS lui-même.
Le programme appelle Serial.begin(115200) pour configurer la sortie série à 115200 bauds. Ensuite, la communication I2C est activée via Wire.begin(). Puis nous démarrons la communication avec le dispositif en appelant huskylens.begin(Wire). Cette méthode configure le pilote interne, définit l’adresse I2C et vérifie que le module répond. En cas d’échec, le programme affiche un message d’erreur sur la console série.
Après l’initialisation, nous sélectionnons l’algorithme de vision intégré que l’appareil doit exécuter. Dans cet exemple, nous activons l’algorithme de suivi de ligne avec 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);
}
Les constantes pour les autres algorithmes AI se trouvent dans le fichier d’en-tête de la bibliothèque et sont les suivantes :
ALGORITHM_FACE_RECOGNITION ALGORITHM_OBJECT_TRACKING ALGORITHM_OBJECT_RECOGNITION ALGORITHM_LINE_TRACKING ALGORITHM_COLOR_RECOGNITION ALGORITHM_TAG_RECOGNITION ALGORITHM_OBJECT_CLASSIFICATION
Loop
Dans la fonction loop(), nous effectuons une acquisition continue des données du capteur. Un tampon de caractères statique nommé text est déclaré pour contenir les messages formatés. Le déclarer statique garantit que la mémoire est allouée une seule fois.
Le sketch envoie une requête de données au dispositif HUSKYLENS en appelant huskylens.request(). Cette méthode invite la caméra à envoyer le dernier ensemble de résultats de reconnaissance ou de suivi.
Après la requête, nous entrons dans une boucle qui continue tant que le dispositif signale des résultats disponibles. Chaque itération récupère un objet résultat avec huskylens.read(). La structure retournée HUSKYLENSResult contient des informations géométriques sur l’élément détecté. En mode suivi de ligne, ces valeurs correspondent à l’origine centrale (xOrigin, yOrigin) et au point final ou coordonnée cible (xTarget, yTarget) du segment de ligne détecté.
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);
}
}
Nous formatons ces quatre valeurs entières dans un message lisible avec sprintf puis l’affichons sur le moniteur série. Vous devriez voir des données similaires à la capture d’écran ci-dessous :
Notez que la détection de ligne par défaut est assez fragile et ne fonctionne pas toujours de manière fiable, même pour une ligne clairement visible. Vous pouvez améliorer la précision en entraînant l’algorithme line tracking.
Angle de la ligne
Souvent, on souhaite connaître l’angle de la ligne, par exemple pour contrôler la direction de déplacement d’un robot. Voici une fonction qui permet de calculer cet angle :
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;
}
Si la ligne est droite devant, la fonction renvoie un angle de 0 degré. Si la ligne pointe vers la gauche, l’angle sera négatif, sinon positif. Vous pouvez récupérer et afficher l’angle avec le code suivant.
float angle = calcAngle(r); Serial.println(angle);
Dans la section suivante, nous réalisons la classification d’objets.
Exemple de code : Classification d’objets
Pour cet exemple, vous devez d’abord faire apprendre deux objets au HUSKYLENS. Consultez les instructions dans le Wiki DFRobot pour Object Classification pour plus de détails. J’ai utilisé une petite figurine de Père Noël et une voiture jouet pour entraîner mon HUSKYLENS :
Une fois que vous avez appris deux objets, vous pouvez utiliser le code suivant pour lancer la détection d’objets et afficher les noms des objets détectés sur le moniteur série :
// (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
Comme précédemment, nous commençons par inclure la bibliothèque HUSKYLENS :
#include "HUSKYLENS.h"
Constantes
Ensuite, nous définissons un tableau constant nommé names. Ce tableau contient des étiquettes lisibles par l’humain correspondant aux IDs de classification générés par le dispositif HUSKYLENS. La première entrée est une chaîne vide car les IDs de classification HUSKYLENS commencent à un. L’index un correspond à la chaîne « Santa » et l’index deux à « Car ».
const char* names[] = {"", "Santa", "Car"};
Instantiation de l’objet
Puis nous créons l’objet HUSKYLENS nommé huskylens.
HUSKYLENS huskylens;
Setup
Dans la fonction setup(), nous initialisons la communication série, l’interface I2C et le capteur HUSKYLENS.
La ligne suivante initialise le sous-système I2C avec Wire.begin(). L’appel à huskylens.begin(Wire) configure le pilote du dispositif et vérifie si le capteur répond sur le bus. En cas d’échec, un message d’erreur est affiché.
Après avoir établi la communication, le programme sélectionne l’algorithme de classification d’objets en appelant huskylens.writeAlgorithm(ALGORITHM_OBJECT_CLASSIFICATION). Sinon, vous devriez sélectionner manuellement cet algorithme sur le 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);
}
Les deux lignes suivantes assignent des noms personnalisés aux IDs. La fonction huskylens.setCustomName(names[1], 1) associe la chaîne « Santa » à l’ID de classification 1. La ligne suivante fait de même pour l’ID 2, en assignant le nom « Car ». Ces étiquettes personnalisées s’affichent à l’écran du HUSKYLENS lorsqu’un objet est reconnu. Voir les captures d’écran ci-dessous :
Loop
La fonction loop() gère la récupération des données du moteur de classification. Chaque itération commence par une requête des résultats les plus récents du capteur avec l’appel huskylens.request().
La boucle while suivante traite tous les résultats disponibles. La méthode huskylens.available() indique si au moins une structure résultat est prête à être lue. Si un résultat est présent, le sketch le récupère avec huskylens.read(), qui retourne un objet HUSKYLENSResult.
Le champ r.ID contient l’ID de classification attribué par le module. Le programme utilise cet ID comme index dans le tableau names et affiche l’étiquette associée sur le moniteur série. Un délai d’une seconde suit pour ralentir la sortie, ce qui facilite l’observation des résultats imprimés.
void loop() {
huskylens.request();
while (huskylens.available()) {
HUSKYLENSResult r = huskylens.read();
Serial.println(names[r.ID]);
delay(1000);
}
}
Le classificateur d’objets ne retourne pas de score de confiance, ce qui signifie que vous ne pouvez pas filtrer les détections à faible confiance. Même si aucun objet n’est devant le HUSKYLENS, l’ID de la première classe est renvoyé. Par conséquent, le fond est détecté comme « Santa » dans mon cas. Vous devrez entraîner une classe « fond » séparée pour contourner ce problème.
Notez aussi que le classificateur d’objets ne retourne pas d’informations de localisation (x, y, w, h), contrairement aux algorithmes face detection ou object tracking par exemple.
Conclusions
Ce tutoriel vous a montré comment démarrer avec le capteur de vision AI HUSKYLENS. Vous avez appris à le connecter à un Arduino et à récupérer les résultats de détection des algorithmes AI intégrés. Je vous recommande également de lire le HUSKYLENS Wiki de DFRobot pour plus d’exemples de code et d’instructions.
Le HUSKYLENS facilite l’expérimentation avec divers algorithmes AI tels que la reconnaissance faciale, la classification d’objets, le suivi d’objets, le suivi de ligne et d’autres. Aucun code complexe d’entraînement n’est requis, cependant, la précision de détection et le nombre d’objets détectables restent limités.
Si vous avez besoin d’algorithmes AI plus puissants et de la possibilité de déployer vos propres modèles AI sur l’appareil, jetez un œil au successeur du HUSKYLENS, le HUSKYLENS 2. Il est plus cher et consomme plus d’énergie, mais offre une plus large sélection d’algorithmes AI avec de meilleures précisions.
De plus, la bibliothèque pour communiquer avec le HUSKYLENS 2 fonctionne sur les plateformes Arduino et ESP32, tandis que la bibliothèque HUSKYLENS fonctionne uniquement sur Arduino.
Le HUSKYLENS et le HUSKYLENS 2 ont l’avantage de pouvoir exécuter des modèles AI localement sur l’appareil. Pas besoin de connexion Wi-Fi à un service cloud avec des latences potentielles ou des problèmes de connexion.
Si vous avez des questions, n’hésitez pas à les laisser dans la section des commentaires.
Bon bricolage 😉
