Ce tutoriel vous montrera comment démarrer avec le HUSKYLENS 2. Le HUSKYLENS 2 de DFRobot est un capteur de vision AI avec une caméra 2MP remplaçable, un écran tactile IPS de 2,4 pouces, un microphone, un haut-parleur et des voyants indicateurs.
Dès la sortie de la boîte, le HUSKYLENS 2 prend en charge plus de 20 modèles AI intégrés, allant de la reconnaissance d’objets et du suivi de visage à l’estimation de pose et à la segmentation d’instance. De plus, vous pouvez déployer des modèles personnalisés entraînés via un flux de travail de type YOLO sur l’appareil.
Vous apprendrez comment connecter le HUSKYLENS à un Arduino ou ESP32 via I2C et comment récupérer programmatiquement les résultats de détection pour différents algorithmes AI. Cela vous permet de contrôler des dispositifs externes depuis votre Arduino ou ESP32 en fonction des détections.
Par exemple, dans ce tutoriel, nous allons construire un Emotion Traffic Light qui allume une LED (rouge, jaune, verte), selon l’émotion détectée sur un visage (Colère, Neutre, Heureux).
Commençons !
Pièces requises
Vous pouvez obtenir le HUSKYLENS 2 de DFRobot via le lien ci-dessous. De plus, vous aurez besoin d’un microcontrôleur. J’utilise un Arduino UNO et un Lolin ESP32 lite, mais la plupart des autres cartes Arduino ou ESP32 fonctionneront également. La seule exigence est la prise en charge d’une interface I2C (ou UART).
HUSKYLENS 2
Arduino Uno
Câble USB pour Arduino UNO
ESP32 lite
Câble USB de données
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.
HUSKYLENS versus nouveau HUSKYLENS 2
Pour éviter toute confusion, commençons par une rapide comparaison entre l’original HUSKYLENS (Version 1) et le nouveau HUSKYLENS 2 que nous utilisons dans ce tutoriel. Les deux appareils sont des capteurs de vision AI conçus par DFRobot pour simplifier les applications de vision par ordinateur dans les systèmes embarqués. Les deux offrent un traitement de vision embarqué et des interfaces série, mais le HUSKYLENS 2 dispose de capacités matérielles et logicielles améliorées.
HUSKYLENS
Le HUSKYLENS de première génération est basé sur le processeur AI Kendryte K210 et fournit des algorithmes AI intégrés pour des tâches telles que la reconnaissance faciale, le suivi d’objets, la détection de couleur, le suivi de ligne et la reconnaissance de tags. Il inclut un écran IPS de 2,0 pouces pour un retour en temps réel et supporte les interfaces UART, I²C et USB pour la communication.
HUSKYLENS 2
Le HUSKYLENS 2, quant à lui, est équipé d’un processeur double cœur 1,6 GHz (K230) avec un accélérateur AI de 6 TOPS, 1 Go de RAM LPDDR4 et 8 Go de stockage embarqué. Cette capacité de traitement améliorée lui permet d’exécuter localement des tâches AI plus complexes.
Il est livré avec plus de vingt modèles de vision intégrés, incluant la détection d’objets, l’estimation de pose et la segmentation d’instance, et permet aux utilisateurs de déployer leurs propres modèles personnalisés via un flux de travail basé sur YOLO.
La nouvelle version dispose également d’un écran IPS 2,4 pouces à plus haute résolution, d’un système de caméra modulaire avec objectifs interchangeables, d’un port USB-C pour les données et l’alimentation, ainsi que d’un module de connectivité sans fil optionnel.
Tableau comparatif
| Caractéristique | HUSKYLENS (Original) | HUSKYLENS 2 |
|---|---|---|
| Processeur | Puce AI Kendryte K210 double cœur | Processeur double cœur 1,6 GHz avec accélérateur AI 6 TOPS |
| Mémoire / Stockage | Non spécifié | 1 Go LPDDR4 RAM + 8 Go eMMC |
| Modèles intégrés | 7 algorithmes prédéfinis (reconnaissance faciale, objet, ligne, couleur, tag) | Plus de 20 modèles intégrés avec support pour modèles YOLO personnalisés |
| Écran | IPS 2,0″ (320×240 px) | IPS 2,4″ (640×480 px) |
| Caméra | Fixe 2 MP (OV2640) | 2 MP (GC2093) avec objectifs interchangeables |
| Interfaces | UART, I²C, USB | USB-C, I²C, UART, module Wi-Fi optionnel |
| Consommation électrique | 230mA @ 5.0V (Reconnaissance faciale) | 340mA @ 5V (Reconnaissance faciale) |
Comme mentionné, dans ce tutoriel nous allons utiliser le HUSKYLENS 2 et dans la section suivante, nous examinerons plus en détail ses caractéristiques techniques.
Matériel du HUSKYLENS 2
Le HUSKYLENS 2 est construit autour d’un module de vision AI embarqué haute performance conçu pour exécuter l’inférence de réseaux neuronaux entièrement sur l’appareil, réduisant ainsi le besoin d’un processeur hôte séparé ou d’un calcul basé sur le cloud. Au cœur se trouve un CPU double cœur 1,6 GHz (K230) associé à un accélérateur AI capable d’environ 6 TOPS (téra-opérations par seconde) de performance de calcul AI.
L’image ci-dessous montre l’arrière du HUSKYLENS 2 avec la caméra, deux LEDs pour l’illumination, une LED RGB à côté d’un microphone et enfin un petit bouton poussoir pour la programmation/apprentissage :
Mémoire
Complétant le processeur, un sous-système mémoire composé de 1 Go de RAM LPDDR4 pour les tâches d’exécution des réseaux neuronaux et applications, et d’un stockage flash eMMC de 8 Go pour le firmware système, le stockage des modèles et les données utilisateur.
Caméra
La chaîne d’acquisition d’image utilise un capteur 2 mégapixels (modèle GC2093, format 1/2.9″) capable de capturer des vidéos jusqu’à 60 images par seconde (fps). Le module caméra est conçu pour être modulaire/interchangeable, permettant de changer les objectifs ou configurations optiques (par exemple macro, vision nocturne, longue portée) selon le cas d’usage.
Écran tactile
Pour l’interaction homme-machine et l’interface utilisateur locale, le HUSKYLENS 2 intègre un écran tactile IPS de 2,4″ (résolution 640×480). Un bouton fonction, une LED indicatrice RGB et un petit haut-parleur à l’arrière fournissent un retour audio/visuel supplémentaire.
Interfaces
Le HUSKYLENS 2 offre un port USB-C (pour alimentation et mises à jour du firmware), un connecteur “Gravity” 4 broches exposant UART et I²C (et alimentation/GND) pour la communication hôte, ainsi qu’un emplacement pour un module Wi-Fi 6 2,4 GHz optionnel pour la connectivité sans fil. L’extensibilité est aussi supportée via un slot TF (micro-SD) sur le côté pour un stockage additionnel ou la capture de jeux de données.
Le sous-système de vision fournit des données de coordonnées, des boîtes englobantes, des IDs et des métadonnées spécifiques au modèle via UART/I²C pour que les microcontrôleurs externes puissent les lire et agir en conséquence.
Alimentation
L’entrée d’alimentation est nominalement de 3,3V à 5,0V (régulée à bord) et la consommation typique est d’environ 1,5W à 3W selon la charge et l’utilisation du modèle actif. Le tableau ci-dessous montre les courants mesurés pour certains modèles, avec un courant allant jusqu’à 420mA pour l’OCR (reconnaissance optique de caractères) et un courant au repos (seulement l’interface utilisateur active) de 250mA :
| Tâche | Courant |
|---|---|
| Interface utilisateur | 250mA |
| Reconnaissance faciale | 340mA |
| Reconnaissance d’objets | 380mA |
| Suivi d’objets | 370mA |
| Reconnaissance de couleur | 330mA |
| Classification d’objets | 350mA |
| Segmentation d’instance | 390mA |
| Reconnaissance de main | 370mA |
| Reconnaissance de code QR | 410mA |
| OCR | 420mA |
Modèles AI intégrés
Le firmware du HUSKYLENS 2 gère à la fois le système RTOS et l’environnement de déploiement des modèles AI. L’appareil est préchargé avec 20+ built-in AI models (comme la détection d’objets, la reconnaissance faciale, l’estimation de pose, la segmentation d’instance) qui peuvent être sélectionnés via l’interface utilisateur embarquée ou programmatiquement :
Les mises à jour du firmware sont déployées via le port USB-C (ou via l’interface hôte) et le système supporte plusieurs modèles fonctionnant en série ou en parallèle (selon l’utilisation des ressources) grâce à l’accélérateur 6 TOPS.
Modèles personnalisés
En plus des modèles intégrés, le HUSKYLENS 2 supporte le déploiement de custom-trained models, spécifiquement via un flux de travail de type YOLO : les utilisateurs peuvent annoter des jeux de données, entraîner des modèles en externe, les convertir au format cible, les charger dans le stockage eMMC de l’appareil et les exécuter localement.
Protocole de contexte de modèle
Une caractéristique distinctive est le “Model Context Protocol” intégré (MCP) service, qui permet au module caméra de sortir des données sémantiques structurées (par exemple : “personne A soulève objet B”) vers un modèle de langage large (LLM) connecté ou une application hôte, faisant ainsi le lien entre le traitement de vision embarqué et le raisonnement de haut niveau.
Spécifications techniques
Le tableau suivant résume les spécifications techniques du HUSKYLENS 2 :
| Paramètre | Spécification |
|---|---|
| Cœur processeur | CPU double cœur @1,6 GHz (Kendryte K230) |
| Accélérateur AI | ~6 TOPS de calcul AI embarqué |
| RAM | 1 Go LPDDR4 |
| Stockage | 8 Go eMMC |
| Capteur d’image | GC2093, 2 MP, 1/2.9″, jusqu’à 60 fps |
| Écran embarqué | Écran tactile IPS 2,4″, résolution 640×480 |
| Interfaces | USB-C (alimentation/données), Gravity 4 broches (UART/I²C/Alim/GND), module WiFi optionnel |
| Stockage extensible | Slot carte TF (micro-SD) |
| Entrées/sorties audio | Microphone intégré, haut-parleur 1 W |
| Indicateurs / UI | 1 bouton fonction, 2 LEDs pour illumination, 1 LED RGB |
| Support caméra modulaire | Modules d’objectifs interchangeables (macro, vision nocturne, etc.) |
| Tension d’entrée | 3,3 V à 5,0 V |
| Consommation typique | ~1,5 W à 3 W |
| Dimensions | ~70 × 58 × 19 mm |
| Poids | ~90 g |
| Modèles préchargés | Plus de 20 modèles AI intégrés |
| Support modèles personnalisés | via flux de travail de type YOLO |
| Fonctionnalités spéciales | Service MCP reliant la vision aux LLMs |
Connexion du HUSKYLENS 2 à Arduino UNO
Vous pouvez communiquer avec le HUSKYLENS via le protocole UART ou I2C. I2C est plus rapide et permet de connecter plusieurs appareils sur le même bus. Nous allons donc utiliser I2C. Le connecteur Gravity du HUSKYLENS expose l’interface I2C (SDA, SCL) et les broches d’alimentation (VCC, GND). Voir la photo ci-dessous :
Vous pourriez connecter le HUSKYLENS 2 directement à un Arduino et l’alimenter via la broche 5V de l’Arduino, mais vous ne devriez PAS faire cela !
Le courant maximal que la broche 5V de l’Arduino peut fournir est de 500mA et le HUSKYLENS 2 consomme jusqu’à 420mA (modèle OCR). C’est inférieur au courant maximal, mais pour des durées prolongées, le régulateur de tension de l’Arduino ou ESP32 va beaucoup chauffer et peut griller.
L’option sûre est d’utiliser la petite carte d’alimentation fournie avec le HUSKYLENS. Elle vous permet d’alimenter le HUSKYLENS depuis une alimentation séparée.
Alternativement, vous pouvez connecter le HUSKYLENS à un port USB et l’Arduino à un autre port USB comme montré dans le Wiki DFRobot :
Cependant, je préfère utiliser la carte d’alimentation et la section suivante vous montre comment la câbler.
Schéma de câblage
Le schéma de câblage ci-dessous montre comment connecter le HUSKYLENS via la carte d’alimentation à un Arduino UNO :
Commencez par connecter la carte adaptatrice au HUSKYLENS. Utilisez le câble silicone blanc Dual-Plug PH2.0-4P (fils gris sur le schéma) fourni avec le HUSKYLENS et assurez-vous d’utiliser le connecteur marqué « Huskylens » et « I2C/UART » :
Ensuite, connectez le câble coloré Gravity-4P Sensor Connector à la carte d’alimentation et à l’Arduino :
Le fil rouge doit être connecté à la broche 5V de l’Arduino, le fil noir à la masse (GND). Le fil vert est SDA et doit être connecté à A4, et le fil bleu (SCL) doit être connecté à A5 de l’Arduino.
Connectez une batterie externe ou une autre alimentation 5V via un câble USB à la carte adaptatrice. Cela fournira l’alimentation au HUSKYLENS. Le HUSKYLENS devrait fonctionner une fois l’alimentation USB fournie.
Enfin, nous devons connecter notre Arduino via son câble USB à un PC exécutant l’IDE Arduino pour pouvoir le programmer :
Installation de la bibliothèque HuskylensV2
Avant de pouvoir exécuter les exemples de code suivants sur l’Arduino ou ESP32, vous devez d’abord installer la bibliothèque DFRobot_HuskylensV2. Rendez-vous sur la bibliothèque Github repo for the DFRobot_HuskylensV2, cliquez sur le bouton vert Code puis « Download ZIP » pour télécharger la bibliothèque au format ZIP :
Ensuite, ouvrez votre IDE Arduino, cliquez sur « Sketch » -> « Include Library » -> « Add .ZIP Library … » pour ajouter la bibliothèque DFRobot_HuskylensV2 que vous venez de télécharger à l’IDE Arduino :
Nous sommes maintenant prêts à écrire du code.
Exemple de code : Communication I2C avec les modèles
Dans ce premier exemple, nous allons tester la communication I2C entre certains des modèles AI sur le HUSKYLENS et l’Arduino UNO.
Connectez votre Arduino UNO à un PC exécutant l’IDE Arduino. Assurez-vous que l’Arduino est reconnu sur un port COM et que Arduino UNO est sélectionné comme carte :
Créez ensuite un nouveau Sketch et copiez-collez le code suivant. Ce code établit une communication I2C entre l’Arduino et le HUSKYLENS, et affiche les résultats de détection du modèle AI actuellement actif sur le HUSKYLENS :
// (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);
}
Bibliothèques et objets
Le code inclut d’abord la bibliothèque DFRobot_HuskylensV2 et crée l’objet HuskylensV2.
#include "DFRobot_HuskylensV2.h" HuskylensV2 huskylens;
Configuration
Ensuite, dans la fonction setup, nous initialisons d’abord la communication série (Serial.begin()) et l’interface I2C (Wire.begin()). Puis nous essayons d’établir une communication I2C avec le HUSKYLENS via huskylens.begin(Wire) :
void setup() {
Serial.begin(115200);
Wire.begin();
while (!huskylens.begin(Wire)) {
Serial.println(F("Can't init HUSKYLENS!"));
delay(100);
}
Serial.println("running...");
}
Si cela échoue et que vous voyez « Can’t init HUSKYLENS! » affiché sur votre moniteur série, vérifiez le câblage et assurez-vous que le protocole de communication du HUSKYLENS 2 est réglé sur I2C. Pour cela, allez dans « System Settings » -> « Protocol Type » et vérifiez que I2C est sélectionné comme montré ci-dessous :
Boucle
Dans la fonction loop, nous attendons d’abord si un des algorithmes AI du HUSKYLENS a des résultats prêts. Si c’est le cas, nous parcourons tous les résultats disponibles et affichons le nom et l’ID du résultat :
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);
}
Sélection de l’algorithme AI
Avant de voir des résultats affichés sur le moniteur série, vous devez d’abord sélectionner un algorithme AI (modèle) sur le HUSKYLENS (plus tard, nous ferons cela automatiquement depuis le code). Par exemple, vous pouvez sélectionner l’algorithme de reconnaissance d’objets :
Le HUSKYLENS commencera alors à détecter des objets et rapportera les résultats à l’Arduino, s’il y a des objets détectés. Vous devriez voir une sortie similaire à celle-ci sur votre moniteur série :
Notez que vous pouvez avoir plusieurs détections sous un même RESULT, car il peut y avoir plusieurs objets dans l’image.
Vous pouvez essayer d’autres algorithmes AI mais à part un ID, la plupart ne fourniront pas beaucoup d’informations utiles avec cet exemple de code. Les résultats dépendent de l’algorithme AI spécifique et nécessitent un code spécifique pour être affichés. Dans les sections suivantes, vous apprendrez à récupérer des résultats plus détaillés.
Algorithmes AI
Le HUSKYLENS 2 dispose de nombreux algorithmes AI intégrés. Si vous ouvrez le fichier Result.h de la bibliothèque DFRobot_HuskylensV2, vous trouverez la liste suivante de constantes pour les modèles intégrés :
// 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;
Dans la suite, nous utiliserons les algorithmes de reconnaissance d’objets, de reconnaissance faciale et de reconnaissance d’émotions. Une fois que vous aurez un peu d’expérience avec ceux-ci, écrire du code pour les autres sera facile.
Exemple de code : Reconnaissance d’objets
Dans cette section, nous allons récupérer les résultats de détection de l’algorithme Object Recognition. Nous avons déjà utilisé la reconnaissance d’objets lors du test de l’interface I2C, mais nous n’avions récupéré que le nom et l’ID de l’objet détecté. Le code suivant récupère le nom de l’objet, son ID, son point central et la boîte englobante :
// (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);
}
Le code est très similaire au précédent, avec trois différences importantes. D’abord, nous définissons une constante TASK qui spécifie l’algorithme AI pour lequel nous voulons récupérer les résultats.
#define TASK ALGORITHM_OBJECT_RECOGNITION
Ensuite, dans la fonction setup, nous appelons huskylens.switchAlgorithm(TASK) pour lancer automatiquement l’algorithme AI que nous voulons utiliser :
huskylens.switchAlgorithm(TASK);
Enfin, dans la fonction loop, nous ne convertissons plus le type de retour de huskylens.popCachedResult() mais prenons simplement le type Result tel quel.
Result *r = huskylens.popCachedResult(TASK);
Selon l’algorithme AI, l’objet Result est rempli avec différentes données de détection. Dans le cas de ALGORITHM_OBJECT_RECOGNITION, nous pouvons récupérer le name, classID, le point central (xCenter, yCenter) et les dimensions de la boîte englobante (width, height) :
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);
Si vous téléversez et exécutez le code sur votre Arduino, le HUSKYLENS devrait automatiquement activer l’algorithme de reconnaissance d’objets :
et vous devriez voir les noms et autres informations des objets détectés affichés sur le moniteur série :
Résultats et microprocesseur
Notez que certains résultats dépendent non seulement de l’algorithme AI mais aussi du microprocesseur connecté au HUSKYLENS.
Pour les microprocesseurs avec plus de mémoire que l’Arduino, par exemple l’ESP32, vous obtiendrez des résultats plus détaillés pour certains algorithmes (voir Differences in Data Acquisition). Vous pouvez voir cela dans le fichier Result.h de la bibliothèque DFRobot_HuskylensV2, qui contient la définition suivante :
#if defined(ESP32) || defined(NRF5) || defined(ESP8266) #define LARGE_MEMORY 1 #endif
Cela signifie que ESP32, ESP8266 et NRF5 sont reconnus comme ayant une grande mémoire et que des objets Result, tels que FaceResult avec plus d’informations, sont alors définis et retournés :
#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;
};
Dans la section suivante, nous connecterons un ESP32 au HUSKYLENS et récupérerons les résultats plus riches pour l’algorithme de reconnaissance faciale.
Connexion du HUSKYLENS 2 à ESP32
L’ESP32 lite que j’utilise ici a la même limitation de courant maximal de sortie de 500mA à cause du régulateur de tension ME6211 intégré. Nous connectons donc à nouveau l’ESP32 et le HUSKYLENS via la carte d’alimentation pour éviter de surcharger le régulateur.
Voici le schéma de câblage complet. Il est essentiellement le même que celui pour l’Arduino. Cependant, VCC est connecté à la sortie 3,3V de l’ESP32 et SCL et SDA sont connectés respectivement aux broches 23 et 19 :
Les broches matérielles I2C dépendront de votre carte ESP32. Consultez la fiche technique de votre carte ESP32 ou regardez notre tutoriel Find I2C and SPI default pins pour identifier les broches I2C d’une autre carte.
Exemple de code : Reconnaissance faciale
Dans cet exemple de code, nous allons récupérer les résultats de détection de l’algorithme Face Recognition. Il retourne les coordonnées des yeux gauche et droit, du nez et des coins gauche et droit de la bouche. Voir les points blancs sur l’image suivante qui montrent ces repères :
Notez que le code suivant ne compilera que pour un microprocesseur ESP32, ESP8266 ou NRF5, mais pas pour un Arduino, c’est pourquoi nous avons connecté un ESP32 au HUSKYLENS dans la section précédente.
// (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);
}
Constantes et objets
Nous commençons par définir une constante TASK pour l’algorithme AI, le ALGORITHM_FACE_RECOGNITION. Puis nous créons l’objet HuskylensV2 comme d’habitude :
#define TASK ALGORITHM_FACE_RECOGNITION HuskylensV2 huskylens;
Configuration
La fonction setup reste également classique. Nous initialisons la communication série, puis essayons de connecter le HUSKYLENS. Si cela échoue et que vous voyez « Can’t init HUSKYLENS! » sur votre moniteur série, vérifiez le câblage !
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...");
}
Sinon, l’algorithme AI ALGORITHM_FACE_RECOGNITION sur le HUSKYLENS est activé via huskylens.switchAlgorithm(TASK) et nous sommes prêts à détecter des visages.
Boucle
Il y a cependant un changement important dans la fonction loop. Nous convertissons le résultat retourné par la fonction huskylens.popCachedResult() en type FaceResult. Ce type contient les coordonnées des yeux, du nez et de la bouche pour le visage détecté, que nous affichons ensuite :
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);
Si vous téléversez ce code sur votre ESP32, vous devriez voir la sortie suivante sur votre moniteur série, si des visages sont détectés :
Notez que vous pouvez exécuter un code similaire sur l’Arduino UNO, mais vous n’obtiendrez que le point central et la boîte englobante, en raison de la mémoire plus limitée de l’Arduino, par exemple vous pourriez modifier la fonction loop comme suit :
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);
Exemple de code : Feu tricolore émotionnel
Dans ce dernier exemple, nous allons construire un feu tricolore émotionnel. Il utilise l’algorithme Face Emotion Recognition du HUSKYLENS pour détecter des émotions comme « Colère », « Neutre » ou « Joie » sur des visages et nous utilisons cette information pour allumer une LED rouge, jaune ou verte.
J’utilise un Arduino ici, mais un ESP32 fonctionnerait aussi. D’abord, nous devons connecter les LEDs. Le schéma suivant montre comment les connecter à l’Arduino UNO :
J’ai connecté la LED rouge à la broche 11, la LED jaune à la broche 10 et la LED verte à la broche 9. N’oubliez pas la résistance de 220 Ohms ou similaire pour limiter le courant dans les LEDs. La photo ci-dessous montre le câblage sur la breadboard :
Nous sommes maintenant prêts à écrire le code pour notre feu tricolore émotionnel. Il ajoute des fonctions pour contrôler les LEDs et étend la fonction loop pour allumer les LEDs selon le résultat (émotion) retourné par l’algorithme de reconnaissance d’émotions faciales :
// (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);
}
Définitions
Nous commençons par définir les broches des LEDs et le TASK comme ALGORITHM_EMOTION_RECOGNITION :
#define RED_LED 11 #define YELLOW_LED 10 #define GREEN_LED 9 #define TASK ALGORITHM_EMOTION_RECOGNITION
Fonctions LED
Ensuite, nous implémentons quelques fonctions pour initialiser et contrôler les trois 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);
}
Configuration
Dans la fonction setup, nous initialisons la communication série et I2C ainsi que les LEDs. Puis nous connectons le HUSKYLENS via huskylens.begin(Wire) et lançons l’algorithme AI comme d’habitude 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...");
}
Boucle
Enfin, nous avons la fonction loop, où nous récupérons le résultat de détection d’émotion et selon l’émotion détectée, allumons la LED rouge, jaune ou verte :
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);
}
}
Notez qu’au-delà de « Joie », « Colère » et « Neutre », il existe d’autres émotions comme « Peur », « Dégoût », « Tristesse » et « Surprise », auxquelles le code actuel ne réagit pas. Mais vous pouvez facilement l’étendre à ces émotions aussi.
Si vous exécutez le code sur votre Arduino, le HUSKYLENS devrait activer l’algorithme de reconnaissance d’émotions faciales :
et sur le moniteur série, vous devriez voir une sortie similaire à celle-ci. Les LEDs correspondantes aux émotions détectées devraient également s’allumer :
Et voilà ! Les exemples de code et les schémas de câblage ci-dessus devraient vous permettre de bien démarrer avec le HUSKYLENS 2.
Conclusions
Ce tutoriel vous a montré comment démarrer avec le capteur de vision AI HUSKYLENS 2. Vous avez appris à le connecter à un Arduino ou ESP32 et à récupérer les résultats de détection pour les différents algorithmes AI intégrés au HUSKYLENS 2. Je vous recommande également de lire le Tutorial for HUSKYLENS 2 and Arduino Code Programming de DFRobot.
Le HUSKYLENS 2 facilite grandement la prise en main de diverses applications AI telles que la reconnaissance d’objets et de visages, la reconnaissance de gestes de la main et de pose, l’OCR et bien d’autres. Vous pouvez facilement entraîner/ajuster certains algorithmes AI et même télécharger vos propres modèles AI personnalisés. Pour plus de détails, consultez DFRobot’s Wiki for the HUSKYLENS 2.
Le plus grand avantage d’un capteur AI comme le HUSKYLENS 2 est que vous pouvez exécuter les modèles AI localement sur l’appareil. Pas besoin de connexion Wi-Fi à un service cloud avec des latences potentielles élevées ou des problèmes de connexion.
Les inconvénients sont une consommation d’énergie potentiellement plus élevée et une précision moindre des modèles. J’ai mesuré un courant allant jusqu’à 420mA pour le modèle OCR (reconnaissance optique de caractères), qui semble être le modèle avec la consommation la plus élevée.
La précision des modèles varie. J’ai trouvé que la reconnaissance d’émotions faciales fonctionne très bien, tandis que le modèle de reconnaissance d’objets produisait beaucoup de classifications erronées. Vous voudrez probablement utiliser votre propre modèle personnalisé avec un nombre réduit de classes pour les tâches de reconnaissance d’objets ou essayer la fonction Self-Learning Classifier.
Si vous avez des questions, n’hésitez pas à les laisser dans la section commentaires.
Bon bricolage 😉
