HUSKYLENS è un sensore di visione AI compatto per edge computing. Alimentato da un chip AI Kendryte K210 e dotato di un piccolo display IPS da 2,0 pollici, il dispositivo supporta funzioni integrate di riconoscimento e tracciamento come riconoscimento facciale, riconoscimento e tracciamento di oggetti, rilevamento di colori e linee, riconoscimento di tag e classificazione degli oggetti.
Nuovi oggetti o modelli possono essere facilmente appresi e le informazioni sugli oggetti rilevati possono essere trasferite tramite interfacce UART o I2C a microcontrollori comuni come Arduino, ESP32 o Raspberry Pi.
In questo tutorial imparerai come collegare HUSKYLENS a un Arduino UNO e recuperare i risultati di rilevamento per il tracciamento di linee e la classificazione degli oggetti.
Componenti necessari
Puoi acquistare HUSKYLENS da DFRobot o Amazon usando i link sottostanti. Inoltre, ti servirà un microcontrollore. Io uso un Arduino UNO, ma anche altre schede Arduino funzioneranno bene. L’unico requisito è il supporto per un’interfaccia I2C (o UART).
HUSKYLENS
Arduino Uno
Cavo USB per Arduino UNO
Set di fili Dupont
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 di HUSKYLENS
Al centro del modulo HUSKYLENS c’è un system-on-chip Kendryte K210, che integra una CPU dual-core RISC-V a 64 bit con acceleratori hardware dedicati per reti neurali convoluzionali e elaborazione del segnale.
Questa architettura permette al dispositivo di eseguire molteplici algoritmi di visione classici e basati su deep learning interamente in edge, senza dipendere da un host esterno per l’inferenza. Il K210 include diversi megabyte di SRAM on-chip usati come buffer per i frame e per l’archiviazione intermedia delle mappe di caratteristiche, consentendo l’elaborazione in tempo reale e mantenendo bassa la larghezza di banda e la latenza della memoria esterna.
Modelli AI
Il firmware che gira sul K210 offre sette funzioni principali di visione artificiale: riconoscimento facciale, tracciamento oggetti, riconoscimento oggetti, tracciamento linee, riconoscimento colori, riconoscimento tag e classificazione oggetti.
Queste funzioni condividono una pipeline di inferenza comune ma si differenziano per pre-elaborazione, topologia del modello e fasi di post-elaborazione. Il risultato è un set di modelli ottimizzati e pre-tarati che possono essere cambiati a runtime tramite l’interfaccia utente integrata o comandi seriali, senza che l’utente debba gestire o distribuire manualmente i modelli.
Sensore d’immagine e sottosistema display
HUSKYLENS utilizza un sensore d’immagine digitale collegato al K210 tramite un’interfaccia camera di tipo DVP. A seconda del lotto di produzione, il modulo camera si basa su un sensore OV2640 o GC0328, entrambi con output RGB a rolling shutter adatto per compiti di visione embedded. La variante OV2640 offre una risoluzione nativa fino a 2 megapixel, mentre la GC0328 è un’opzione a risoluzione inferiore e ottimizzata per costi.
Il modulo integra un display LCD IPS da 2,0 pollici con risoluzione 320 × 240 pixel. Questo display è strettamente integrato con la pipeline di visione ed è usato per mostrare il feed live della camera, sovrapporre riquadri di rilevamento, ID e indicatori di confidenza, oltre a visualizzare nomi delle funzioni e menu di configurazione.
L’interfaccia del display è pilotata direttamente dal K210, permettendo al dispositivo di fornire una spiegazione visiva immediata di ciò che gli algoritmi di visione stanno rilevando, senza alcuna interazione con l’host.
Alimentazione e caratteristiche elettriche
Elettricamente, HUSKYLENS è progettato per funzionare con alimentazioni tipiche da 3,3 volt e 5 volt per sistemi embedded. La tensione di alimentazione specificata va da 3,3 V a 5,0 V, e sia il connettore Gravity a 4 pin che il connettore micro-USB possono essere usati come ingressi di alimentazione. Un circuito onboard di selezione automatica della fonte di alimentazione dà priorità all’ingresso USB quando entrambi sono collegati.
In un’operazione tipica di riconoscimento facciale con la retroilluminazione LCD al 80% di luminosità e la luce di riempimento disabilitata, il modulo assorbe circa 320 mA a 3,3 V o 230 mA a 5,0 V. Questo consumo è dovuto al funzionamento continuo dell’acceleratore di rete neurale del K210 e al display attivo.
Interfacce di comunicazione
HUSKYLENS offre due interfacce di comunicazione per l’integrazione con microcontrollori: UART e I2C. Queste interfacce sono collegate al connettore standard DFRobot Gravity a 4 pin.
In modalità UART, i quattro pin corrispondono a TX, RX, massa e VCC, mentre in modalità I2C corrispondono a SDA, SCL, massa e VCC. Le due tabelle seguenti mostrano la configurazione dei pin per le modalità UART e I2C:
| Num | Etichetta | Funzione Pin | Descrizione |
|---|---|---|---|
| 1 | T | TX | Pin TX di HuskyLens |
| 2 | R | RX | Pin RX di HuskyLens |
| 3 | – | GND | Negativo (0V) |
| 4 | + | VCC | Positivo (3,3~5,0V) |
| Num | Etichetta | Funzione Pin | Descrizione |
|---|---|---|---|
| 1 | T | SDA | Linea dati seriale |
| 2 | R | SCL | Linea clock seriale |
| 3 | – | GND | Negativo (0V) |
| 4 | + | VCC | Positivo (3,3~5,0V) |
Entrambe le modalità di interfaccia supportano il protocollo completo di comandi per configurare gli algoritmi, attivare operazioni di apprendimento e leggere i risultati di rilevamento come coordinate dei bounding box e ID.
Interfaccia utente e controlli onboard
Il modulo include un’interfaccia utente locale implementata con due pulsanti hardware e il display integrato. Il pulsante “function” agisce principalmente come selettore di modalità e controllo di configurazione. Ruotando o “girando” questo pulsante a sinistra o destra, il firmware cicla tra le funzioni di visione disponibili, aggiornando lo schermo per indicare l’algoritmo corrente.
Una pressione prolungata sul pulsante function apre un menu di parametri di secondo livello per la funzione attiva. Qui puoi regolare parametri come sensibilità, soglie di riconoscimento, impostazioni LED e opzioni di apprendimento multi-oggetto senza alcun controller esterno.
Il pulsante “learning” è strettamente legato alle routine interne di addestramento di ogni algoritmo. Una pressione breve istruisce il dispositivo ad apprendere l’oggetto o il colore attualmente centrato sotto il mirino sullo schermo.
Una pressione lunga abilita l’apprendimento continuo su più frame. Questo permette al sistema di costruire un modello più robusto rispetto a variazioni di distanza, angolo o illuminazione. Se è presente un target già appreso, un’altra pressione breve può essere usata per cancellare i dati del modello associato.
Collegare HUSKYLENS ad Arduino UNO
Puoi comunicare con HUSKYLENS usando il protocollo UART o I2C. I2C è più veloce e permette di collegare più dispositivi sullo stesso bus. Perciò useremo I2C.
Il connettore Gravity di HUSKYLENS espone l’interfaccia I2C (SDA(T), SCL(R)) e i pin di alimentazione (VCC(+), GND(-)). La foto sottostante mostra come collegare HUSKYLENS a un Arduino UNO:
Il filo rosso va collegato al pin 5V dell’Arduino, e il filo nero a GND. Il filo verde è SDA e va collegato ad A4. Il filo blu è SCL e va collegato ad A5 dell’Arduino.
Nota che devi impostare il protocollo di comunicazione su I2C nelle impostazioni di HUSKYLENS. Vai su “General Settings”, poi “Protocol Type”, seleziona “I2C” e salva le impostazioni come mostrato di seguito:
Se ti servono istruzioni più dettagliate, leggi il manuale di HUSKYLENS Wiki.
Installare la libreria HUSKYLENS
Per poter recuperare i risultati di rilevamento da HUSKYLENS dobbiamo installare la HUSKYLENS Library. Clicca su link per scaricare la libreria come file “HUSKYLENSArduino-master.zip” sul tuo computer. Poi estrai il contenuto del file ZIP. Dovresti vedere i seguenti file nella cartella estratta:
Successivamente dobbiamo copiare la cartella “HUSKYLENS” nella cartella “libraries” dell’IDE Arduino. Su Windows la cartella “libraries” si trova tipicamente in:
C:\Users\<username>\OneDrive\Documents\Arduino\libraries
Poiché questa cartella contiene già librerie installate, ti consiglio di rinominarla temporaneamente, ad esempio in “_libraries”, e creare una nuova cartella chiamata “libraries”. In questo modo eviti conflitti con le librerie già installate e non le perdi. Potrai facilmente tornare indietro in seguito. L’immagine sottostante mostra come dovrebbe apparire la tua cartella “Arduino” con le librerie:
Ora possiamo copiare la cartella “HUSKYLENS” nella nuova cartella “libraries” come mostrato di seguito:
La cartella “libraries” può contenere altre librerie, ma per questo progetto non ne servono altre.
Esempio di codice: Tracciamento linee
Nel primo esempio di codice proveremo l’algoritmo Line Tracking. Ha il vantaggio che non devi addestrare HUSKYLENS a rilevare linee, poiché questa funzione funziona senza alcun apprendimento.
Il codice seguente collega Arduino a HUSKYLENS via I2C e stampa i punti iniziali e finali dei segmenti di linea rilevati. Dai un’occhiata veloce al codice e poi ne discutiamo i dettagli.
#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);
}
}
Importazioni
Iniziamo includendo la libreria HUSKYLENS con la direttiva #include "HUSKYLENS.h". Questa importazione rende disponibili allo sketch tutte le definizioni di classi, costanti e routine di comunicazione necessarie per interfacciarsi con la camera AI HUSKYLENS.
#include "HUSKYLENS.h"
Nota che questa libreria attualmente (dic 2025) non compila per il core ESP32.
Istanziazione oggetto
Dopo la direttiva include, creiamo un’istanza globale della classe HUSKYLENS. L’oggetto chiamato huskylens mantiene lo stato interno dell’interfaccia del dispositivo ed espone l’API usata nel programma.
HUSKYLENS huskylens;
Setup
La funzione setup() inizializza l’interfaccia seriale della scheda, il bus I2C e il dispositivo HUSKYLENS.
Il programma chiama Serial.begin(115200) per configurare l’output seriale a 115200 baud. Poi attiva la comunicazione I2C tramite Wire.begin(). Successivamente avvia la comunicazione con il dispositivo chiamando huskylens.begin(Wire). Questo metodo configura il driver interno, imposta l’indirizzo I2C e verifica che il modulo risponda. Se l’inizializzazione fallisce, il programma stampa un messaggio di errore sulla console seriale.
Dopo l’inizializzazione, selezioniamo quale algoritmo di visione integrato il dispositivo deve eseguire. In questo esempio attiviamo l’algoritmo di tracciamento linee usando 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);
}
Le costanti per gli altri algoritmi AI si trovano nel file header della libreria e sono le seguenti:
ALGORITHM_FACE_RECOGNITION ALGORITHM_OBJECT_TRACKING ALGORITHM_OBJECT_RECOGNITION ALGORITHM_LINE_TRACKING ALGORITHM_COLOR_RECOGNITION ALGORITHM_TAG_RECOGNITION ALGORITHM_OBJECT_CLASSIFICATION
Loop
Nella funzione loop() eseguiamo l’acquisizione continua dei dati dal sensore. Viene dichiarato un buffer statico di caratteri chiamato text per contenere i messaggi di output formattati. Dichiararlo statico assicura che la memoria venga allocata una sola volta.
Lo sketch invia una richiesta di dati al dispositivo HUSKYLENS chiamando huskylens.request(). Questo metodo invita la camera a inviare l’ultimo set di risultati di riconoscimento o tracciamento.
Dopo la richiesta, entriamo in un ciclo che continua finché il dispositivo segnala risultati disponibili. Ogni iterazione recupera un oggetto risultato usando huskylens.read(). La struttura HUSKYLENSResult restituita contiene informazioni geometriche sull’elemento rilevato. In modalità tracciamento linee, questi valori corrispondono all’origine centrale (xOrigin, yOrigin) e al punto finale o coordinata target (xTarget, yTarget) del segmento di linea rilevato.
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);
}
}
Formattiamo questi quattro valori interi in un messaggio leggibile usando sprintf e poi lo stampiamo sul monitor seriale. Sul Serial Monitor vedrai dati simili allo screenshot sottostante:
Nota che il rilevamento linee di default è piuttosto fragile e anche per una linea chiaramente visibile non funziona sempre in modo affidabile. Puoi migliorare la precisione addestrando l’algoritmo line tracking.
Angolo della linea
Spesso vogliamo conoscere l’angolo della linea, per esempio per controllare la direzione di guida di un robot. Ecco una funzione che ti permette di calcolare quell’angolo:
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;
}
Se la linea è dritta davanti, la funzione restituisce un angolo di 0 gradi. Se la linea punta a sinistra l’angolo sarà negativo, altrimenti positivo. Puoi recuperare e stampare l’angolo con il seguente codice.
float angle = calcAngle(r); Serial.println(angle);
Nella sezione successiva eseguiremo la classificazione degli oggetti.
Esempio di codice: Classificazione oggetti
Per questo esempio devi prima far apprendere a HUSKYLENS due oggetti. Consulta le istruzioni nel Wiki DFRobot per Object Classification per i dettagli. Io ho usato una piccola figura di Babbo Natale e una macchinina giocattolo per addestrare il mio HUSKYLENS:
Una volta appresi due oggetti, puoi usare il codice seguente per eseguire il rilevamento degli oggetti e stampare i nomi degli oggetti rilevati sul Serial Monitor:
// (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);
}
}
Importazioni
Come prima, iniziamo includendo la libreria HUSKYLENS:
#include "HUSKYLENS.h"
Costanti
Poi definiamo un array costante chiamato names. Questo array contiene etichette leggibili dall’uomo che corrispondono agli ID di classificazione generati dal dispositivo HUSKYLENS. La prima voce è una stringa vuota perché gli ID di classificazione di HUSKYLENS partono da uno. L’indice uno corrisponde alla stringa “Santa” e l’indice due a “Car”.
const char* names[] = {"", "Santa", "Car"};
Istanziazione oggetto
Quindi creiamo l’oggetto HUSKYLENS chiamato huskylens.
HUSKYLENS huskylens;
Setup
Nella funzione setup() inizializziamo la comunicazione seriale, l’interfaccia I2C e il sensore HUSKYLENS.
La riga successiva inizializza il sottosistema I2C usando Wire.begin(). La chiamata a huskylens.begin(Wire) configura il driver del dispositivo e verifica se il sensore risponde sul bus. Se questa inizializzazione fallisce, il programma stampa un messaggio di errore.
Dopo aver stabilito la comunicazione, il programma seleziona l’algoritmo di classificazione oggetti chiamando huskylens.writeAlgorithm(ALGORITHM_OBJECT_CLASSIFICATION). Altrimenti dovresti selezionare manualmente l’algoritmo di classificazione oggetti su 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);
}
Le due righe successive assegnano nomi personalizzati agli ID. La funzione huskylens.setCustomName(names[1], 1) associa la stringa “Santa” all’ID di classificazione 1. La riga successiva fa lo stesso per l’ID 2, assegnando il nome “Car”. Queste etichette personalizzate vengono visualizzate sullo schermo di HUSKYLENS quando un oggetto viene riconosciuto. Vedi gli screenshot sottostanti:
Loop
La funzione loop() gestisce il recupero dati dal motore di classificazione. Ogni iterazione inizia richiedendo i risultati più recenti dal sensore con la chiamata huskylens.request().
Il successivo ciclo while elabora tutti i risultati attualmente disponibili. Il metodo huskylens.available() indica se almeno una struttura risultato è pronta per essere letta. Se è presente un risultato, lo sketch lo recupera usando huskylens.read(), che restituisce un oggetto HUSKYLENSResult.
Il campo r.ID contiene l’ID di classificazione assegnato dal modulo. Il programma usa questo ID come indice nell’array names e stampa l’etichetta associata sul monitor seriale. Segue un ritardo di un secondo per rallentare l’output, rendendo i risultati stampati più facili da osservare.
void loop() {
huskylens.request();
while (huskylens.available()) {
HUSKYLENSResult r = huskylens.read();
Serial.println(names[r.ID]);
delay(1000);
}
}
Il classificatore di oggetti non restituisce un punteggio di confidenza, quindi non puoi filtrare le rilevazioni a bassa confidenza. Anche se non c’è alcun oggetto davanti a HUSKYLENS, viene restituito l’ID della prima classe. Di conseguenza, lo sfondo viene rilevato come “Santa” nel mio caso. Dovrai addestrare una classe “sfondo” separata per ovviare a questo.
Nota anche che il classificatore di oggetti non restituisce informazioni sulla posizione dell’oggetto (x, y, w, h), a differenza degli algoritmi face detection o object tracking, per esempio.
Conclusioni
Questo tutorial ti ha mostrato come iniziare con il sensore di visione AI HUSKYLENS. Hai imparato come collegarlo a un Arduino e come recuperare i risultati di rilevamento dagli algoritmi AI integrati. Ti consiglio anche di leggere il HUSKYLENS Wiki di DFRobot per altri esempi di codice e istruzioni.
HUSKYLENS rende facile provare vari algoritmi AI come riconoscimento facciale, classificazione oggetti, tracciamento oggetti, tracciamento linee e altri. Non è richiesto codice complesso per l’addestramento, tuttavia la precisione del rilevamento e il numero di oggetti rilevabili sono limitati.
Se ti servono algoritmi AI più potenti e la possibilità di distribuire i tuoi modelli AI sul dispositivo, dai un’occhiata al successore di HUSKYLENS, il HUSKYLENS 2. È più costoso e consuma più energia, ma offre una selezione più ampia di algoritmi AI con migliori precisioni.
Inoltre, la libreria per comunicare con HUSKYLENS 2 funziona su piattaforme Arduino ed ESP32, mentre la libreria HUSKYLENS funziona solo su Arduino.
Sia HUSKYLENS che HUSKYLENS 2 hanno il vantaggio di poter eseguire modelli AI localmente sul dispositivo. Non serve una connessione Wi-Fi a un servizio cloud con potenziali latenze elevate o problemi di connessione.
Se hai domande, sentiti libero di lasciarle nella sezione commenti.
Buon divertimento con il tinkering 😉
