Questo tutorial ti mostrerà come iniziare con il HUSKYLENS 2. L’HUSKYLENS 2 di DFRobot è un sensore di visione AI con una fotocamera 2MP sostituibile, un touchscreen IPS da 2,4 pollici, microfono, altoparlante e spie luminose.
Appena uscita dalla scatola, la HUSKYLENS 2 supporta oltre 20 modelli AI integrati, che vanno dal riconoscimento oggetti e tracciamento volti alla stima della posa e instance segmentation. Inoltre, è possibile distribuire modelli personalizzati addestrati tramite un flusso di lavoro in stile YOLO direttamente sul dispositivo.
Imparerai come collegare la HUSKYLENS a un Arduino o a un ESP32 tramite I2C e come recuperare programmaticamente i risultati di rilevamento per diversi algoritmi AI. Questo ti permette di controllare dispositivi esterni dall’Arduino o dall’ESP32 in base alle rilevazioni.
Ad esempio, in questo tutorial costruiremo un Emotion Traffic Light che accende un LED (rosso, giallo, verde) a seconda dell’emozione rilevata sul volto (Rabbia, Neutrale, Felice).
Iniziamo!
Componenti necessari
Puoi ottenere la HUSKYLENS 2 da DFRobot tramite il link sottostante. Inoltre avrai bisogno di un microcontrollore. Io uso un Arduino UNO e un Lolin ESP32 lite, ma la maggior parte delle altre schede Arduino o ESP32 funzioneranno comunque. L’unico requisito è il supporto per un’interfaccia I2C (o UART).
HUSKYLENS 2
Arduino Uno
Cavo USB per Arduino UNO
ESP32 lite
Cavo dati USB
Dupont Wire Set
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 new HUSKYLENS 2
Per evitare confusione, iniziamo con un rapido confronto tra l’originale HUSKYLENS (Versione 1) e il nuovo HUSKYLENS 2che stiamo usando in questo tutorial. Entrambi i dispositivi sono sensori di visione AI progettati da DFRobot per semplificare le applicazioni di computer vision nei sistemi embedded. Offrono elaborazione visiva a bordo e interfacce seriali, ma l’HUSKYLENS 2 presenta miglioramenti hardware e software.
HUSKYLENS
La prima generazione HUSKYLENS si basa sul processore AI Kendryte K210 e fornisce algoritmi AI integrati per compiti come riconoscimento facciale, tracciamento oggetti, rilevamento colori, tracciamento linee e riconoscimento tag. Include un display IPS da 2,0 pollici per il feedback in tempo reale e supporta interfacce UART, I²C e USB per la comunicazione.
HUSKYLENS 2
L’HUSKYLENS 2, invece, è alimentato da un processore dual-core a 1,6 GHz (K230) con un acceleratore AI da 6 TOPS, 1 GB di LPDDR4 RAM e 8 GB di memoria onboard. Questa maggiore capacità di elaborazione gli permette di eseguire compiti AI più complessi localmente.
Include oltre venti modelli di visione integrati, tra cui object detection, pose estimation e instance segmentation, e permette agli utenti di distribuire i propri modelli personalizzati usando un flusso di lavoro basato su YOLO.
La nuova versione dispone inoltre di un display IPS a risoluzione maggiore da 2,4″, di un sistema fotocamera modulare con lenti intercambiabili, di una porta USB-C per dati e alimentazione e di un modulo di connettività wireless opzionale.
Tabella di confronto
| Caratteristica | HUSKYLENS (Original) | HUSKYLENS 2 |
|---|---|---|
| Processore | Kendryte K210 dual-core AI chip | Processore dual-core 1.6 GHz con acceleratore AI da 6 TOPS |
| Memoria / Storage | Non specificato | 1 GB LPDDR4 RAM + 8 GB eMMC |
| Modelli integrati | 7 algoritmi predefiniti (face, object, line, color, tag recognition) | 20+ built-in models with support for custom YOLO models |
| Display | 2.0″ IPS (320×240 px) | 2.4″ IPS (640×480 px) |
| Camera | Fixed 2 MP (OV2640) | 2 MP (GC2093) with interchangeable lenses |
| Interfacce | UART, I²C, USB | USB-C, I²C, UART, modulo Wi‑Fi opzionale |
| Consumo energetico | 230mA @ 5.0V (Face Recognition) | 340mA @ 5V (Face Recognition) |
Come accennato, in questo tutorial useremo il HUSKYLENS 2 e nella sezione successiva esamineremo più in dettaglio le sue caratteristiche tecniche.
Hardware dell’HUSKYLENS 2
L’HUSKYLENS 2 è costruito attorno a un modulo di visione AI embedded ad alte prestazioni progettato per eseguire l’inferenza delle reti neurali interamente on-device, riducendo la necessità di un host processor separato o di elaborazione cloud. Al centro c’è una CPU dual-core a 1,6 GHz (K230) abbinata a un acceleratore AI in grado di ≈ 6 TOPS di capacità di calcolo AI.
L’immagine qui sotto mostra il retro dell’HUSKYLENS 2 con la fotocamera, due LED per l’illuminazione, un LED RGB, accanto un microfono e infine un piccolo pulsante per programmazione/apprendimento:
Memoria
A complemento del processore c’è un sottosistema di memoria composto da 1 GB di LPDDR4 RAM per le reti neurali e l’esecuzione delle applicazioni, e una memoria flash eMMC da 8 GB per firmware di sistema, archiviazione dei modelli e dati utente.
Camera
La catena di acquisizione immagine utilizza un sensore da 2 megapixel (modello GC2093, formato 1/2.9″) in grado di catturare video fino a 60 fps. Il modulo fotocamera è progettato per essere modulare/intercambiabile, permettendo di montare diverse ottiche o configurazioni (per esempio macro, visione notturna, lungo raggio) a seconda del caso d’uso.
Touchscreen
Per l’interazione uomo-macchina e l’interfaccia locale, l’HUSKYLENS 2 integra un touchscreen IPS da 2,4″ (risoluzione 640×480). Un pulsante di funzione, un LED RGB e un piccolo speaker sul retro forniscono feedback audio/visivi aggiuntivi.
Interfacce
L’HUSKYLENS 2 offre una porta USB-C (per alimentazione e aggiornamenti firmware), un connettore “Gravity” a 4 pin che espone UART e I²C (e Power/GND) per la comunicazione con l’host, e la predisposizione per un modulo Wi‑Fi 2.4 GHz (Wi-Fi 6) a innesto opzionale per abilitare la connettività wireless. L’espandibilità è supportata anche tramite uno slot TF-card (micro-SD) laterale per ulteriore storage o acquisizione dataset.
Il sottosistema di visione fornisce dati di coordinate, bounding-box, ID e metadata specifici del modello via UART/I²C per permettere ai microcontrollori esterni di leggerli e agire di conseguenza.
Alimentazione
L’ingresso di alimentazione è nominalmente 3.3V fino a 5.0V (regolati a bordo) e il consumo tipico è intorno a 1.5W–3W a seconda del carico e dei modelli attivi. La tabella sotto mostra le correnti che ho misurato per alcuni modelli, con un picco fino a 420mA per OCR (Optical Character Recognition) e una corrente a riposo (solo UI attiva) di 250mA:
| Task | Current |
|---|---|
| UI | 250mA |
| Face Recognition | 340mA |
| Object Recognition | 380mA |
| Object Tracking | 370mA |
| Color Recognition | 330mA |
| Object Classification | 350mA |
| Instance Segmentation | 390mA |
| Hand Recognition | 370mA |
| QR Code Recognition | 410mA |
| OCR | 420mA |
Modelli AI integrati
Il firmware dell’HUSKYLENS 2 gestisce sia l’RTOS di sistema sia l’ambiente di deployment dei modelli AI. Il dispositivo arriva preinstallato con 20+ built-in AI models (come object detection, face recognition, pose estimation, instance segmentation) che possono essere selezionati tramite l’interfaccia onboard o programmaticamente:
Gli aggiornamenti firmware vengono effettuati tramite la porta USB-C (o tramite l’interfaccia host) e il sistema supporta l’esecuzione di più modelli in serie o in parallelo (a seconda dell’uso delle risorse) grazie all’acceleratore da 6 TOPS.
Modelli addestrati personalizzati
Oltre ai modelli integrati, l’HUSKYLENS 2 supporta la distribuzione di custom-trained models, nello specifico tramite un flusso di lavoro in stile YOLO: gli utenti possono annotare dataset, addestrare i modelli esternamente, convertirli nel formato target e caricarli nella memoria eMMC del dispositivo per eseguirli on-device.
Model Context Protocol
Una caratteristica distintiva è il “Model Context Protocol” integrato (MCP) service, che permette al modulo camera di emettere dati semantici strutturati (per esempio: “person A lifting object B”) verso un large-language-model (LLM) o un’applicazione host, collegando così l’elaborazione visiva on-device con ragionamenti di livello superiore.
Specifiche tecniche
La tabella seguente riassume le specifiche tecniche dell’HUSKYLENS 2:
| Parametro | Specifiche |
|---|---|
| Processor core | CPU dual-core @1.6 GHz (Kendryte K230) |
| AI accelerator | ~6 TOPS di calcolo AI on-device |
| RAM | 1 GB LPDDR4 |
| Storage | 8 GB eMMC |
| Image sensor | GC2093, 2 MP, 1/2.9″, fino a 60 fps |
| On-board display | Touchscreen IPS 2.4″, risoluzione 640×480 |
| Interfacce | USB-C (power/data), Gravity a 4 pin (UART/I²C/Power/GND), modulo WiFi opzionale |
| Storage espandibile | Slot TF (micro-SD) |
| Audio I/O | Microfono integrato, altoparlante 1 W |
| Indicator / UI | 1 pulsante funzione, 2 LED per illuminazione, 1 LED RGB |
| Supporto fotocamera modulare | Moduli con lenti intercambiabili (macro, visione notturna, ecc.) |
| Tensione d’ingresso | 3.3 V a 5.0 V |
| Consumo tipico | ~1.5 W a 3 W |
| Dimensioni | ~70 × 58 × 19 mm |
| Peso | ~90 g |
| Modelli preinstallati | 20+ built-in AI models |
| Supporto modelli personalizzati | tramite workflow in stile YOLO |
| Funzionalità speciali | Servizio MCP che collega la visione agli LLMs |
Collegare HUSKYLENS 2 ad Arduino UNO
Puoi comunicare con l’HUSKYLENS usando il protocollo UART o I2C. I2C è più veloce e permette di collegare più dispositivi sullo stesso bus. Useremo quindi I2C. Il connettore Gravity dell’HUSKYLENS espone l’interfaccia I2C (SDA, SCL) e i pin di alimentazione (VCC, GND). Vedi la foto sotto:
Potresti collegare l’HUSKYLENS 2 direttamente a un Arduino e alimentarlo dal pin 5V dell’Arduino, ma NON dovresti farlo!
Il massimo corrente che il pin 5V dell’Arduino può fornire è 500mA e l’HUSKYLENS 2 consuma fino a 420mA (modello OCR). Questo è inferiore al massimo, ma per periodi prolungati il regolatore di tensione sull’Arduino o sull’ESP32 si riscalderà molto e potrebbe bruciarsi.
L’opzione sicura è usare la piccola scheda adattatrice di alimentazione fornita con l’HUSKYLENS. Permette di alimentare l’HUSKYLENS da una fonte di alimentazione separata.
In alternativa, puoi collegare l’HUSKYLENS a una porta USB e l’Arduino a un’altra porta USB come mostrato sul DFRobot Wiki:
Tuttavia, preferisco usare la scheda adattatrice di alimentazione e la sezione seguente ti mostra come cablarla.
Schema di collegamento
Lo schema elettrico sottostante mostra come collegare l’HUSKYLENS tramite la scheda adattatrice di alimentazione a un Arduino UNO:
Inizia collegando la scheda adattatrice all’HUSKYLENS. Usa il cavo bianco Dual-Plug PH2.0-4P Silicone Cable (fili grigi nello schema) fornito con l’HUSKYLENS e assicurati di usare il connettore etichettato “Huskylens” e “I2C/UART“:
Successivamente collega il cavo colorato Gravity-4P Sensor Connector Cable alla scheda adattatrice e all’Arduino:
Il filo rosso deve essere collegato al pin 5V dell’Arduino, e il filo nero al GND. Il filo verde è SDA e dovrebbe essere collegato ad A4 e il filo blu (SCL) dovrebbe essere collegato ad A5 dell’Arduino.
Collega una power bank o un’altra fonte 5V tramite un cavo USB alla scheda adattatrice. Questo fornirà alimentazione all’HUSKYLENS. L’HUSKYLENS dovrebbe avviarsi una volta fornita la tensione USB.
Infine, dobbiamo collegare il nostro Arduino tramite il suo cavo USB a un PC che esegue l’Arduino IDE per poterlo programmare:
Installazione della libreria HuskylensV2
Prima di poter eseguire uno qualsiasi degli esempi di codice seguenti su Arduino o ESP32, dovrai prima installare la DFRobot_HuskylensV2 library. Vai alla Github repo for the DFRobot_HuskylensV2 library, clicca sul pulsante verde Code e poi su “Download ZIP” per scaricare la libreria come file ZIP:
Apri poi il tuo Arduino IDE, clicca su “Sketch” -> “Include Library” -> “Add .ZIP Library …” per aggiungere la libreria DFRobot_HuskylensV2 appena scaricata all’Arduino IDE:
Ora siamo pronti a scrivere del codice.
Esempio di codice: comunicazione I2C con i modelli
In questo primo esempio testeremo la comunicazione I2C tra alcuni dei modelli AI sul dispositivo HUSKYLENS e l’Arduino UNO.
Collega il tuo Arduino UNO a un PC che esegue l’Arduino IDE. Assicurati che l’Arduino sia riconosciuto su una porta COM e che Arduino UNO sia selezionato come scheda:
Crea un nuovo Sketch e copia&incolla il codice seguente al suo interno. Questo codice stabilisce una comunicazione I2C tra l’Arduino e l’HUSKYLENS e stampa i risultati di rilevamento del modello AI attualmente in esecuzione sull’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);
}
Librerie e oggetti
Il codice include prima la DFRobot_HuskylensV2 library e crea il HuskylensV2 oggetto.
#include "DFRobot_HuskylensV2.h" HuskylensV2 huskylens;
Setup
Poi, nella funzione setup inizializziamo prima la comunicazione Serial (Serial.begin()) e l’interfaccia I2C (Wire.begin()) . Quindi proviamo a stabilire una comunicazione I2C con l’HUSKYLENS tramite 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...");
}
Se ciò fallisce e vedi “Can’t init HUSKYLENS!” stampato sul tuo Serial Monitor, controlla il cablaggio e assicurati che il protocollo di comunicazione dell’HUSKYLENS 2 sia impostato su I2C. Per quest’ultimo vai su “System Settings” -> “Protocol Type” e verifica che I2C sia selezionato come mostrato sotto:
Loop
Nella funzione loop aspettiamo prima se uno qualsiasi degli algoritmi AI sull’HUSKYLENS ha risultati pronti. Se è così, iteriamo su tutti i risultati disponibili e stampiamo il nome e l’ID del risultato:
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);
}
Seleziona algoritmo AI
Prima di poter vedere risultati stampati sul Serial Monitor, devi prima selezionare un algoritmo AI (modello) sull’HUSKYLENS (più avanti lo faremo automaticamente dal codice). Per esempio, puoi selezionare l’algoritmo Object Recognition:
L’HUSKYLENS inizierà quindi a rilevare oggetti e riporterà i risultati all’Arduino, se vengono rilevati oggetti. Dovresti vedere un output simile al seguente sul tuo Serial Monitor:
Nota che puoi avere più rilevazioni sotto un singolo RESULT, poiché possono esserci più oggetti nell’immagine.
Puoi provare altri algoritmi AI ma a parte un ID la maggior parte non fornirà molte informazioni utili con questo esempio di codice. I risultati dipendono dall’algoritmo AI specifico e richiedono codice dedicato per essere visualizzati. Nelle sezioni successive imparerai come recuperare risultati più dettagliati.
Algoritmi AI
L’HUSKYLENS 2 dispone di molti algoritmi AI integrati. Se apri il Result.h file della DFRobot_HuskylensV2 library, troverai la seguente lista di costanti per i modelli integrati:
// 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;
Nelle sezioni successive useremo gli algoritmi Object Recognition, Face Recognition e Emotion Recognition. Una volta che avrai preso confidenza con questi, scrivere codice per gli altri sarà semplice.
Esempio di codice: Object Recognition
In questa sezione recupereremo i risultati di rilevamento dall’algoritmo Object Recognition. Abbiamo già usato Object Recognition quando abbiamo testato l’interfaccia I2C ma abbiamo recuperato solo il nome e l’ID dell’oggetto rilevato. Il codice seguente recupera il nome dell’oggetto, il suo ID, il punto centrale e la bounding box:
// (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);
}
Il codice è molto simile al precedente, con tre differenze importanti. Prima, definiamo una costante TASK che specifica l’AI Algorithm per cui vogliamo recuperare i risultati.
#define TASK ALGORITHM_OBJECT_RECOGNITION
Secondo, nella funzione setup chiamiamo huskylens.switchAlgorithm(TASK) per eseguire automaticamente l’algoritmo AI che vogliamo usare:
huskylens.switchAlgorithm(TASK);
Infine, nella funzione loop non castiamo più il tipo di ritorno di huskylens.popCachedResult() ma prendiamo semplicemente il tipo Result così com’è.
Result *r = huskylens.popCachedResult(TASK);
A seconda dell’AI Algorithm, l’oggetto Result viene riempito con diversi dati di rilevamento. Nel caso di ALGORITHM_OBJECT_RECOGNITION possiamo recuperare il name, classID, il punto centrale (xCenter, yCenter) e le dimensioni della bounding box (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);
Se carichi ed esegui il codice sul tuo Arduino, l’HUSKYLENS dovrebbe attivare automaticamente l’algoritmo Object Recognition:
e dovresti vedere i nomi e le altre informazioni degli oggetti rilevati stampati sul Serial Monitor:
Risultati e microprocessore
Nota che alcuni risultati non dipendono solo dall’AI Algorithm ma anche dal microprocessore collegato all’HUSKYLENS.
Per microprocessori con più memoria rispetto all’Arduino, per esempio l’ESP32, riceverai risultati più dettagliati per alcuni algoritmi (vedi Differences in Data Acquisition). Puoi vedere questo nel file Result.h della libreria DFRobot_HuskylensV2, che contiene la seguente definizione:
#if defined(ESP32) || defined(NRF5) || defined(ESP8266) #define LARGE_MEMORY 1 #endif
Questo significa che ESP32, ESP8266 e NRF5 sono riconosciuti come dispositivi con memoria ampia e Result oggetti, come FaceResult con più informazioni sono allora definiti e ritornati:
#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;
};
Nella sezione successiva collegheremo un ESP32 all’HUSKYLENS e recupereremo i risultati più ricchi per l’algoritmo Face Recognition.
Collegare HUSKYLENS 2 all’ESP32
L’ESP32 lite che uso qui ha la stessa limitazione di corrente massima in uscita di 500mA a causa del regolatore di tensione integrato. Collegheremo quindi di nuovo l’ESP32 e l’HUSKYLENS tramite la scheda adattatrice di alimentazione per evitare di sovraccaricare il regolatore di tensione.
Di seguito trovi lo schema completo di cablaggio. È essenzialmente lo stesso di quello per l’Arduino. Tuttavia, VCC è collegato all’uscita 3.3V dell’ESP32 e SCL e SDA sono collegati rispettivamente ai pin 23 e 19:
I pin I2C hardware dipenderanno dalla tua scheda ESP32. Consulta il datasheet della tua scheda ESP32 o dai un’occhiata al nostro Find I2C and SPI default pins tutorial per identificare i pin I2C per una scheda diversa.
Esempio di codice: Face Recognition
In questo esempio di codice andremo a recuperare i risultati di rilevamento dall’algoritmo Face Recognition. Restituisce le coordinate per occhio sinistro e destro, il naso e gli angoli sinistro e destro della bocca. Vedi i puntini bianchi nella foto seguente che mostrano questi landmark:
Nota che il codice seguente compilerà solo per un microprocessore ESP32, ESP8266 o NRF5 ma non per un Arduino, motivo per cui abbiamo collegato un ESP32 all’HUSKYLENS nella sezione precedente.
// (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);
}
Costanti e oggetti
Iniziamo definendo una costante TASK per l’AI Algorithm, il ALGORITHM_FACE_RECOGNITION. Poi creiamo l’oggetto HuskylensV2 come al solito:
#define TASK ALGORITHM_FACE_RECOGNITION HuskylensV2 huskylens;
Setup
La funzione setup rimane anch’essa standard. Inizializziamo la comunicazione Serial, e poi proviamo a collegarci all’HUSKYLENS. Se ciò fallisce e vedi “Can’t init HUSKYLENS!” stampato sul Serial Monitor controlla il cablaggio!
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...");
}
Altrimenti, l’AI algorithm ALGORITHM_FACE_RECOGNITION sull’HUSKYLENS viene attivato tramite huskylens.switchAlgorithm(TASK) e siamo pronti a rilevare volti.
Loop
C’è però un cambiamento importante nella funzione loop. Stiamo effettuando il cast del risultato restituito dalla funzione huskylens.popCachedResult() al tipo FaceResult. Questo tipo contiene le coordinate di occhi, naso e bocca per il volto rilevato, che poi stampiamo:
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);
Se carichi questo codice sul tuo ESP32 dovresti vedere il seguente output sul Serial Monitor, se vengono rilevati volti:
Nota che puoi eseguire codice simile anche su Arduino UNO ma otterrai solo il punto centrale e la bounding box, a causa della memoria ridotta dell’Arduino; per esempio potresti modificare la funzione loop come segue:
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);
Esempio di codice: Semaforo emotivo
In questo ultimo esempio costruiremo un Semaforo emotivo. Usa l’algoritmo Face Emotion Recognition dell’HUSKYLENS per rilevare emozioni come “Anger”, “Neutral” o “Happiness” nei volti e utilizziamo queste informazioni per accendere un LED rosso, giallo o verde.
Userò un Arduino qui, ma anche un ESP32 andrà bene. Per prima cosa dobbiamo collegare i LED. Il diagramma seguente mostra come collegarli all’Arduino UNO:
Ho collegato il LED rosso al pin 11, il LED giallo al pin 10 e il LED verde al pin 9. Non dimenticare la resistenza da 220 Ohm o simile per limitare la corrente attraverso i LED. La foto sotto mostra il cablaggio sulla breadboard:
Ora siamo pronti a scrivere il codice per il nostro Semaforo emotivo. Aggiunge funzioni per controllare i LED ed estende la funzione loop per accendere i LED in base al risultato (emozione) restituito dall’algoritmo Face Emotion Recognition:
// (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);
}
Definizioni
Iniziamo definendo i pin per i LED e il TASK come ALGORITHM_EMOTION_RECOGNITION :
#define RED_LED 11 #define YELLOW_LED 10 #define GREEN_LED 9 #define TASK ALGORITHM_EMOTION_RECOGNITION
Funzioni LED
Poi implementiamo alcune funzioni per inizializzare e controllare i tre LED:
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
Nella funzione setup inizializziamo serial e la comunicazione I2C e i LED. Poi ci connettiamo all’HUSKYLENS tramite huskylens.begin(Wire) e avviamo l’algoritmo AI come di consueto tramite 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
Infine, abbiamo la funzione loop, dove recuperiamo il risultato del rilevamento delle emozioni e a seconda dell’emozione rilevata accendiamo il LED rosso, giallo o verde:
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);
}
}
Nota che oltre a “Happiness”, “Anger” e “Neutral” ci sono altre emozioni come “Fear”, “Disgust”, “Sad” e “Surprised”, a cui il codice attuale non reagisce. Ma potresti facilmente estenderlo anche a quelle emozioni.
Se esegui il codice sul tuo Arduino, l’HUSKYLENS dovrebbe attivare l’algoritmo Face Emotion Recognition:
e sul Serial Monitor dovresti vedere un output simile al seguente. Anche i LED corrispondenti alle emozioni rilevate dovrebbero accendersi:
Ed è tutto! Gli esempi di codice e gli schemi di collegamento sopra dovrebbero renderti più semplice iniziare con l’HUSKYLENS 2.
Conclusioni
Questo tutorial ti ha mostrato come iniziare con il sensore AI Vision HUSKYLENS 2. Hai imparato come collegarlo a un Arduino o a un ESP32 e come recuperare i risultati di rilevamento per i vari algoritmi AI integrati nell’HUSKYLENS 2. Ti consiglio anche di leggere il Tutorial for HUSKYLENS 2 and Arduino Code Programming di DFRobot.
L’HUSKYLENS 2 rende estremamente semplice prendere confidenza con varie applicazioni AI come riconoscimento oggetti e volti, riconoscimento gesti della mano e pose, OCR e molte altre. Puoi facilmente addestrare/aggiustare alcuni degli algoritmi AI e persino caricare i tuoi modelli AI personalizzati. Per maggiori dettagli dai un’occhiata a DFRobot’s Wiki for the HUSKYLENS 2.
Il vantaggio principale di un sensore AI come l’HUSKYLENS 2 è che puoi eseguire i modelli AI localmente sul dispositivo. Non è necessario una connessione Wi‑Fi a un servizio cloud con potenziali latenze elevate o problemi di connessione.
Gli svantaggi sono un consumo energetico potenzialmente maggiore e una minore accuratezza dei modelli. Ho misurato una corrente fino a 420mA per il modello OCR (Optical Character Recognition), che sembrava essere il modello con il consumo più alto.
L’accuratezza dei modelli varia. Ho trovato che il Face Emotion recognition funziona molto bene, mentre l’Object Recognition ha prodotto molte misclassificazioni. Probabilmente vorrai usare un tuo modello personalizzato con un numero ridotto di classi per i compiti di object recognition o provare la funzione Self-Learning Classifier.
Se hai domande, sentiti libero di lasciarle nella sezione commenti.
Buon tinkering 😉
