El HUSKYLENS es un sensor de visión compacto con inteligencia artificial en el borde. Impulsado por un chip AI Kendryte K210 y equipado con una pequeña pantalla IPS de 2,0 pulgadas, el dispositivo soporta funciones integradas de reconocimiento y seguimiento como reconocimiento facial, reconocimiento y seguimiento de objetos, detección de color y líneas, reconocimiento de etiquetas y clasificación de objetos.
Nuevos objetos o patrones pueden aprenderse fácilmente y la información sobre los objetos detectados puede transferirse mediante las interfaces UART o I2C a microcontroladores comunes como Arduino, ESP32 o Raspberry Pi.
En este tutorial aprenderás cómo conectar el HUSKYLENS a un Arduino UNO y obtener resultados de detección para seguimiento de líneas y clasificación de objetos.
Partes necesarias
Puedes conseguir el HUSKYLENS en DFRobot o Amazon usando los enlaces a continuación. Además, necesitarás un microcontrolador. Yo uso un Arduino UNO, pero otras placas Arduino también funcionarán bien. El único requisito es que soporte una interfaz I2C (o UART).
HUSKYLENS
Arduino Uno
Cable USB para Arduino UNO
Juego de cables Dupont
Protoboard
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 del HUSKYLENS
En el núcleo del módulo HUSKYLENS está un sistema en chip Kendryte K210, que integra un complejo CPU RISC-V de doble núcleo de 64 bits con aceleradores hardware dedicados para redes neuronales convolucionales y procesamiento de señales.
Esta arquitectura permite que el dispositivo ejecute múltiples algoritmos de visión clásicos y basados en aprendizaje profundo completamente en el borde, sin depender de un host externo para la inferencia. El K210 incluye varios megabytes de SRAM en chip usados como búferes de cuadros y almacenamiento intermedio de mapas de características, lo que permite procesamiento en tiempo real y mantiene baja la latencia y el ancho de banda de la memoria externa.
Modelos de IA
El firmware que corre en el K210 expone siete funciones principales de visión por máquina: reconocimiento facial, seguimiento de objetos, reconocimiento de objetos, seguimiento de líneas, reconocimiento de color, reconocimiento de etiquetas y clasificación de objetos.
Estas funciones comparten una canalización común de inferencia pero se diferencian en sus etapas de preprocesamiento, topología del modelo y postprocesamiento. El resultado es un conjunto de modelos optimizados y preajustados que pueden cambiarse en tiempo de ejecución mediante la interfaz de usuario integrada o comandos seriales, sin que el usuario tenga que gestionar o desplegar modelos manualmente.
Subsistema de sensor de imagen y pantalla
HUSKYLENS usa un sensor de imagen digital conectado al K210 mediante una interfaz de cámara estilo DVP. Dependiendo del lote de producción, el módulo de cámara está basado en un sensor OV2640 o GC0328, ambos con salida RGB de obturador rodante adecuada para tareas de visión embebida. La variante OV2640 ofrece una resolución nativa de hasta 2 megapíxeles, mientras que el GC0328 es una opción de menor resolución y costo optimizado.
El módulo integra una pantalla LCD IPS de 2,0 pulgadas con resolución de 320 × 240 píxeles. Esta pantalla está estrechamente ligada a la canalización de visión y se usa para mostrar la imagen en vivo de la cámara, superponer cuadros delimitadores de detección, IDs e indicadores de confianza, así como para mostrar nombres de funciones y menús de configuración.
La interfaz de la pantalla es manejada directamente por el K210, lo que permite que el dispositivo presente una explicación visual inmediata de lo que los algoritmos de visión están detectando, sin interacción con un host.
Fuente de alimentación y características eléctricas
El HUSKYLENS está diseñado para operar con fuentes de alimentación embebidas típicas de 3,3 voltios y 5 voltios. El rango de voltaje especificado es de 3,3 V a 5,0 V, y tanto el conector Gravity de 4 pines como el conector micro-USB pueden usarse como entradas de alimentación. Un circuito interno de selección automática de fuente de alimentación da prioridad a la entrada USB cuando ambas están conectadas.
En operación típica de reconocimiento facial con la retroiluminación LCD al 80% de brillo y la luz de relleno desactivada, el módulo consume aproximadamente 320 mA a 3,3 V o 230 mA a 5,0 V. Este consumo está impulsado por la operación continua del acelerador de redes neuronales del K210 y la pantalla activa.
Interfaces de comunicación
El HUSKYLENS ofrece dos interfaces de comunicación para integración con microcontroladores: UART e I2C. Estas interfaces están conectadas al conector estándar DFRobot Gravity de 4 pines.
En modo UART, los cuatro pines corresponden a TX, RX, tierra y VCC, mientras que en modo I2C corresponden a SDA, SCL, tierra y VCC. Las siguientes dos tablas muestran la configuración de pines para los modos UART e I2C:
| Num | Etiqueta | Función del pin | Descripción |
|---|---|---|---|
| 1 | T | TX | Pin TX del HuskyLens |
| 2 | R | RX | Pin RX del HuskyLens |
| 3 | – | GND | Negativo (0V) |
| 4 | + | VCC | Positivo (3,3~5,0V) |
| Num | Etiqueta | Función del pin | Descripción |
|---|---|---|---|
| 1 | T | SDA | Línea de datos serial |
| 2 | R | SCL | Línea de reloj serial |
| 3 | – | GND | Negativo (0V) |
| 4 | + | VCC | Positivo (3,3~5,0V) |
Ambos modos de interfaz soportan el protocolo completo de comandos para configurar algoritmos, activar operaciones de aprendizaje y leer resultados de detección como coordenadas de cuadros delimitadores e IDs.
Interfaz de usuario y controles integrados
El módulo incluye una interfaz de usuario local implementada con dos botones físicos y la pantalla integrada. El botón “function” actúa principalmente como selector de modo y control de configuración. Cuando el usuario gira o “marca” este botón hacia la izquierda o derecha, el firmware recorre las funciones de visión disponibles, actualizando la pantalla para indicar el algoritmo actual.
Una pulsación larga en el botón de función abre un menú de parámetros de segundo nivel para la función activa. Allí puedes ajustar parámetros como sensibilidad, umbrales de reconocimiento, configuración de LED y opciones de aprendizaje multi-objeto sin necesidad de un controlador externo.
El botón “learning” está estrechamente ligado a las rutinas internas de entrenamiento de cada algoritmo. Una pulsación corta indica al dispositivo que aprenda el objeto o color actualmente centrado bajo la mira en pantalla.
Una pulsación larga habilita el aprendizaje continuo durante múltiples cuadros. Esto permite que el sistema construya un modelo más robusto ante variaciones de distancia, ángulo o iluminación. Cuando un objetivo ya aprendido está presente, otra pulsación corta puede usarse para borrar sus datos de modelo asociados.
Conectando HUSKYLENS a Arduino UNO
Puedes comunicarte con el HUSKYLENS usando el protocolo UART o I2C. I2C es más rápido y permite conectar múltiples dispositivos al mismo bus. Por eso usaremos I2C.
El conector Gravity del HUSKYLENS expone la interfaz I2C (SDA(T), SCL(R)) y los pines de alimentación (VCC(+), GND(-)). La foto a continuación muestra cómo cablear el HUSKYLENS con un Arduino UNO:
El cable rojo debe conectarse al pin de 5V del Arduino, y el cable negro a GND. El cable verde es SDA y debe conectarse a A4. Y el cable azul es SCL y debe conectarse a A5 del Arduino.
Ten en cuenta que debes configurar el protocolo de comunicaciones a I2C en los ajustes del HUSKYLENS. Ve a «General Settings», luego «Protocol Type», selecciona «I2C» y guarda la configuración como se muestra a continuación:
Si necesitas instrucciones más detalladas, lee el HUSKYLENS Wiki.
Instalando la librería HUSKYLENS
Para poder obtener resultados de detección del HUSKYLENS necesitamos instalar la HUSKYLENS Library. Haz clic en el link para descargar la librería como un archivo «HUSKYLENSArduino-master.zip» en tu ordenador. Luego descomprime el archivo ZIP para extraer su contenido. Deberías ver los siguientes archivos en la carpeta descomprimida:
A continuación, necesitamos copiar la carpeta «HUSKYLENS» dentro de la carpeta «libraries» del IDE de Arduino. En Windows, la carpeta «libraries» suele estar ubicada en:
C:\Users\<username>\OneDrive\Documents\Arduino\libraries
Como esta carpeta ya contiene librerías instaladas, te recomiendo renombrarla temporalmente, por ejemplo a «_libraries», y crear una nueva carpeta llamada «libraries». Así evitas conflictos con las librerías ya instaladas y no las pierdes. Más tarde puedes revertir fácilmente este cambio. La imagen a continuación muestra cómo debería verse tu carpeta «Arduino» con las librerías:
Ahora podemos copiar la carpeta «HUSKYLENS» dentro de la nueva carpeta «libraries» como se muestra a continuación:
La carpeta «libraries» puede contener otras librerías, pero no necesitamos ninguna para este proyecto.
Ejemplo de código: Seguimiento de líneas
En el primer ejemplo de código vamos a probar el algoritmo Line Tracking. Tiene la ventaja de que no necesitas entrenar el HUSKYLENS para detectar líneas, ya que esa función funciona sin aprendizaje.
El siguiente código conecta el Arduino al HUSKYLENS vía I2C e imprime los puntos de inicio y fin de los segmentos de línea detectados. Echa un vistazo rápido al código primero y luego discutimos los detalles.
#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);
}
}
Importaciones
Comenzamos incluyendo la librería HUSKYLENS con la directiva #include "HUSKYLENS.h". Esta importación pone a disposición del sketch todas las definiciones de clases, constantes y rutinas de comunicación necesarias para la interfaz con la cámara AI HUSKYLENS.
#include "HUSKYLENS.h"
Ten en cuenta que esta librería actualmente (dic 2025) no compila para el core ESP32.
Instanciación de objeto
Después de la directiva include, creamos una instancia global de la clase HUSKYLENS. El objeto llamado huskylens mantiene el estado interno de la interfaz del dispositivo y expone la API usada en todo el programa.
HUSKYLENS huskylens;
Setup
La función setup() inicializa la interfaz serial de la placa, el bus I2C y el dispositivo HUSKYLENS.
El programa llama a Serial.begin(115200) para configurar la salida serial a 115200 baudios. Luego se activa la comunicación I2C mediante Wire.begin(). Después iniciamos la comunicación con el dispositivo llamando a huskylens.begin(Wire). Este método configura el driver interno, establece la dirección I2C y verifica que el módulo responda. Si la inicialización falla, el programa imprime un mensaje de error en la consola serial.
Tras la inicialización, seleccionamos qué algoritmo de visión integrado debe ejecutar el dispositivo. En este ejemplo, activamos el algoritmo de seguimiento de líneas 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);
}
Las constantes para otros algoritmos de IA se encuentran en el archivo header de la librería y son las siguientes:
ALGORITHM_FACE_RECOGNITION ALGORITHM_OBJECT_TRACKING ALGORITHM_OBJECT_RECOGNITION ALGORITHM_LINE_TRACKING ALGORITHM_COLOR_RECOGNITION ALGORITHM_TAG_RECOGNITION ALGORITHM_OBJECT_CLASSIFICATION
Loop
En la función loop() realizamos adquisición continua de datos del sensor. Se declara un buffer estático de caracteres llamado text para contener mensajes de salida formateados. Declararlo como estático asegura que la memoria se asigne solo una vez.
El sketch envía una solicitud de datos al dispositivo HUSKYLENS llamando a huskylens.request(). Este método solicita a la cámara que envíe el conjunto más reciente de resultados de reconocimiento o seguimiento.
Tras emitir la solicitud, entramos en un bucle que continúa mientras el dispositivo reporte resultados disponibles. Cada iteración recupera un objeto resultado usando huskylens.read(). La estructura HUSKYLENSResult devuelta contiene información geométrica sobre el elemento detectado. En modo seguimiento de líneas, estos valores corresponden al origen central (xOrigin, yOrigin) y al punto final o coordenada objetivo (xTarget, yTarget) del segmento de línea detectado.
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);
}
}
Formateamos estos cuatro valores enteros en un mensaje legible usando sprintf y luego lo imprimimos en el monitor serial. En el Monitor Serial deberías ver datos impresos similares a la captura de pantalla a continuación:
Ten en cuenta que la detección de líneas por defecto es bastante frágil y, aun con una línea claramente visible, no funciona de forma fiable. Puedes mejorar la precisión entrenando el algoritmo line tracking.
Ángulo de línea
A menudo queremos conocer el ángulo de la línea, por ejemplo, para controlar la dirección de marcha de un robot. Aquí tienes una función que permite calcular ese ángulo:
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 línea está recta hacia adelante, la función devuelve un ángulo de 0 grados. Si la línea apunta a la izquierda, el ángulo será negativo y, de lo contrario, positivo. Puedes obtener e imprimir el ángulo con el siguiente código.
float angle = calcAngle(r); Serial.println(angle);
En la siguiente sección realizamos Clasificación de Objetos.
Ejemplo de código: Clasificación de objetos
Para este ejemplo primero necesitas que el HUSKYLENS aprenda dos objetos. Consulta las instrucciones en el Wiki de DFRobot para Object Classification para más detalles. Yo usé una pequeña figura de Santa y un coche de juguete para entrenar mi HUSKYLENS:
Una vez que hayas aprendido dos objetos, puedes usar el siguiente código para ejecutar la detección de objetos e imprimir los nombres de los objetos detectados en el Monitor Serial:
// (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);
}
}
Importaciones
Como antes, comenzamos incluyendo la librería HUSKYLENS:
#include "HUSKYLENS.h"
Constantes
Luego definimos un array constante llamado names. Este array contiene etiquetas legibles para humanos que corresponden a los IDs de clasificación generados por el dispositivo HUSKYLENS. La primera entrada es una cadena vacía porque los IDs de clasificación de HUSKYLENS comienzan en uno. El índice uno corresponde a la cadena «Santa» y el índice dos a «Car».
const char* names[] = {"", "Santa", "Car"};
Instanciación de objeto
Luego creamos el objeto HUSKYLENS llamado huskylens.
HUSKYLENS huskylens;
Setup
En la función setup() inicializamos la comunicación serial, la interfaz I2C y el sensor HUSKYLENS.
La siguiente línea inicializa el subsistema I2C usando Wire.begin(). La llamada a huskylens.begin(Wire) configura el driver del dispositivo y verifica si el sensor responde en el bus. Si esta inicialización falla, el programa imprime un mensaje de error.
Tras establecer la comunicación, el programa selecciona el algoritmo de clasificación de objetos llamando a huskylens.writeAlgorithm(ALGORITHM_OBJECT_CLASSIFICATION). De lo contrario, tendrías que seleccionar manualmente el algoritmo de clasificación de objetos en el 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);
}
Las siguientes dos líneas asignan nombres personalizados a los IDs. La función huskylens.setCustomName(names[1], 1) asocia la cadena «Santa» con el ID de clasificación 1. Y la siguiente línea realiza la misma operación para el ID 2, asignando el nombre «Car». Estas etiquetas personalizadas se muestran en la pantalla del HUSKYLENS cuando se reconoce un objeto. Consulta las capturas de pantalla a continuación:
Loop
La función loop() maneja la recuperación de datos del motor de clasificación. Cada iteración comienza solicitando los resultados más recientes del sensor con la llamada huskylens.request().
El bucle while procesa todos los resultados disponibles actualmente. El método huskylens.available() indica si al menos una estructura de resultado está lista para ser leída. Si hay un resultado, el sketch lo recupera usando huskylens.read(), que devuelve un objeto HUSKYLENSResult.
El campo r.ID contiene el ID de clasificación asignado por el módulo. El programa usa este ID como índice en el array names e imprime la etiqueta asociada en el monitor serial. A continuación, hay un retardo de un segundo para ralentizar la salida, lo que facilita observar los resultados impresos.
void loop() {
huskylens.request();
while (huskylens.available()) {
HUSKYLENSResult r = huskylens.read();
Serial.println(names[r.ID]);
delay(1000);
}
}
El clasificador de objetos no devuelve una puntuación de confianza, lo que significa que no puedes filtrar detecciones de baja confianza. Incluso si no hay ningún objeto frente al HUSKYLENS, se devuelve el ID de la primera clase. En consecuencia, el fondo se detecta como «Santa» en mi caso. Necesitarás entrenar una clase separada de «fondo» para evitar esto.
También ten en cuenta que el clasificador de objetos no devuelve información de ubicación del objeto (x, y, w, h), lo que es diferente de los algoritmos face detection o object tracking, por ejemplo.
Conclusiones
Este tutorial te mostró cómo empezar con el sensor de visión AI HUSKYLENS. Aprendiste cómo conectarlo a un Arduino y cómo obtener resultados de detección de los algoritmos AI integrados. Te recomiendo también leer el HUSKYLENS Wiki de DFRobot para más ejemplos de código e instrucciones.
El HUSKYLENS facilita probar varios algoritmos AI como reconocimiento facial, clasificación de objetos, seguimiento de objetos, seguimiento de líneas y otros. No se requiere código complejo para el entrenamiento, sin embargo, la precisión de detección y el número de objetos que pueden detectarse es limitado.
Si necesitas algoritmos AI más potentes y la opción de desplegar tus propios modelos AI en el dispositivo, echa un vistazo al sucesor del HUSKYLENS, el HUSKYLENS 2. Es más caro y tiene un mayor consumo de energía, pero ofrece una selección más amplia de algoritmos AI con mejores precisiones.
Además, la librería para comunicarse con el HUSKYLENS 2 funciona en plataformas Arduino y ESP32, mientras que la librería del HUSKYLENS solo funciona en Arduino.
Tanto el HUSKYLENS como el HUSKYLENS 2 tienen la ventaja de que puedes ejecutar modelos AI localmente en el dispositivo. No necesitas conexión Wi-Fi a un servicio en la nube con posibles latencias altas o problemas de conexión.
Si tienes alguna pregunta, no dudes en dejarlas en la sección de comentarios.
¡Feliz bricolaje! 😉
