Este tutorial te mostrará cómo empezar con el HUSKYLENS 2. El HUSKYLENS 2 de DFRobot es un sensor de visión AI con una cámara reemplazable de 2MP, una pantalla táctil IPS de 2.4 pulgadas, micrófono, altavoz y luces indicadoras.
Desde el primer momento, el HUSKYLENS 2 soporta más de 20 modelos AI integrados, que van desde reconocimiento de objetos y seguimiento facial hasta estimación de pose y segmentación de instancias. Además, puedes desplegar modelos personalizados entrenados mediante un flujo de trabajo estilo YOLO en el dispositivo.
Aprenderás cómo conectar el HUSKYLENS a un Arduino o ESP32 vía I2C y cómo recuperar programáticamente los resultados de detección para diferentes algoritmos AI. Esto te permite controlar dispositivos externos desde tu Arduino o ESP32 basándote en las detecciones.
Por ejemplo, en este tutorial construiremos un Emotion Traffic Light que enciende un LED (rojo, amarillo, verde), dependiendo de la emoción detectada en un rostro (Enojo, Neutral, Feliz).
¡Vamos a empezar!
Partes necesarias
Puedes conseguir el HUSKYLENS 2 de DFRobot usando el enlace abajo. Además, necesitarás un microcontrolador. Yo uso un Arduino UNO y un Lolin ESP32 lite, pero la mayoría de las placas Arduino o ESP32 funcionarán bien también. El único requisito es que soporten una interfaz I2C (o UART).
HUSKYLENS 2
Arduino Uno
Cable USB para Arduino UNO
ESP32 lite
Cable USB de datos
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.
HUSKYLENS versus nuevo HUSKYLENS 2
Para evitar confusiones, comencemos con una rápida comparación del original HUSKYLENS (Versión 1) y el nuevo HUSKYLENS 2 que usamos en este tutorial. Ambos dispositivos son sensores de visión AI diseñados por DFRobot para simplificar aplicaciones de visión por computadora en sistemas embebidos. Ambos ofrecen procesamiento de visión a bordo e interfaces seriales, pero el HUSKYLENS 2 tiene capacidades mejoradas de hardware y software.
HUSKYLENS
El HUSKYLENS de primera generación está basado en el procesador AI Kendryte K210 y ofrece algoritmos AI integrados para tareas como reconocimiento facial, seguimiento de objetos, detección de color, seguimiento de líneas y reconocimiento de etiquetas. Incluye una pantalla IPS de 2.0 pulgadas para retroalimentación en tiempo real y soporta interfaces UART, I²C y USB para comunicación.
HUSKYLENS 2
El HUSKYLENS 2, por otro lado, está potenciado por un procesador dual-core de 1.6 GHz (K230) con un acelerador AI de 6 TOPS, 1 GB de RAM LPDDR4 y 8 GB de almacenamiento a bordo. Esta capacidad de procesamiento mejorada le permite realizar tareas AI más complejas localmente.
Viene con más de veinte modelos de visión integrados, incluyendo detección de objetos, estimación de pose y segmentación de instancias, y permite a los usuarios desplegar sus propios modelos personalizados usando un flujo de trabajo basado en YOLO.
La nueva versión también cuenta con una pantalla IPS de mayor resolución de 2.4 pulgadas, un sistema modular de cámara que soporta lentes intercambiables, un puerto USB-C para datos y alimentación, y un módulo opcional de conectividad inalámbrica.
Tabla comparativa
| Característica | HUSKYLENS (Original) | HUSKYLENS 2 |
|---|---|---|
| Procesador | Chip AI dual-core Kendryte K210 | Procesador dual-core 1.6 GHz con acelerador AI de 6 TOPS |
| Memoria / Almacenamiento | No especificado | 1 GB RAM LPDDR4 + 8 GB eMMC |
| Modelos integrados | 7 algoritmos predefinidos (reconocimiento facial, objetos, líneas, color, etiquetas) | Más de 20 modelos integrados con soporte para modelos YOLO personalizados |
| Pantalla | IPS 2.0″ (320×240 px) | IPS 2.4″ (640×480 px) |
| Cámara | Fija 2 MP (OV2640) | 2 MP (GC2093) con lentes intercambiables |
| Interfaces | UART, I²C, USB | USB-C, I²C, UART, módulo Wi-Fi opcional |
| Consumo de energía | 230mA @ 5.0V (Reconocimiento facial) | 340mA @ 5V (Reconocimiento facial) |
Como se mencionó, en este tutorial usaremos el HUSKYLENS 2 y en la siguiente sección veremos con más detalle sus características técnicas.
Hardware del HUSKYLENS 2
El HUSKYLENS 2 está construido alrededor de un módulo de visión AI embebido de alto rendimiento diseñado para ejecutar inferencias de redes neuronales completamente en el dispositivo, reduciendo la necesidad de un procesador host separado o computación en la nube. En su núcleo tiene una CPU dual-core de 1.6 GHz (K230) junto con un acelerador AI capaz de ≈ 6 TOPS (tera-operaciones por segundo) de rendimiento de cómputo AI.
La imagen abajo muestra la parte trasera del HUSKYLENS 2 con la cámara, dos LEDs para iluminación, un LED RGB y junto a él un micrófono y finalmente un pequeño botón para programación/aprendizaje:
Memoria
Complementando el procesador hay un subsistema de memoria que consiste en 1 GB de RAM LPDDR4 para tareas de redes neuronales y ejecución de aplicaciones, y un almacenamiento flash eMMC de 8 GB para firmware del sistema, almacenamiento de modelos y datos de usuario.
Cámara
La cadena de adquisición de imagen usa un sensor de 2 megapíxeles (modelo GC2093, formato 1/2.9″) capaz de capturar video a hasta 60 cuadros por segundo (fps). El módulo de cámara está diseñado para ser modular/intercambiable, permitiendo cambiar lentes o configuraciones ópticas diferentes (por ejemplo macro, visión nocturna, largo alcance) según el caso de uso.
Pantalla táctil
Para la interacción humano-máquina y la interfaz local, el HUSKYLENS 2 integra una pantalla táctil IPS de 2.4″ (resolución 640×480). Un botón de función, un LED indicador RGB y un pequeño altavoz en la parte trasera proporcionan retroalimentación audiovisual adicional.
Interfaces
El HUSKYLENS 2 ofrece un puerto USB-C (para alimentación y actualizaciones de firmware), un conector “Gravity” de 4 pines que expone UART e I²C (y alimentación/GND) para comunicación con el host, y una ranura para un módulo Wi-Fi 6 de 2.4 GHz opcional para conectividad inalámbrica. También soporta expansión mediante una ranura para tarjeta TF (micro-SD) en el lateral para almacenamiento adicional o captura de datasets.
El subsistema de visión proporciona datos de coordenadas, cajas delimitadoras, IDs y metadatos específicos del modelo vía UART/I²C para que microcontroladores externos los lean y actúen en consecuencia.
Alimentación
La entrada de alimentación es nominalmente de 3.3V a 5.0V (regulada a bordo) y el consumo típico de energía está entre 1.5W y 3W dependiendo de la carga y el modelo activo. La tabla abajo muestra las corrientes que medí para algunos modelos, con un máximo de 420mA para OCR (Reconocimiento Óptico de Caracteres) y una corriente en reposo (solo UI activa) de 250mA:
| Tarea | Corriente |
|---|---|
| UI | 250mA |
| Reconocimiento facial | 340mA |
| Reconocimiento de objetos | 380mA |
| Seguimiento de objetos | 370mA |
| Reconocimiento de color | 330mA |
| Clasificación de objetos | 350mA |
| Segmentación de instancias | 390mA |
| Reconocimiento de manos | 370mA |
| Reconocimiento de código QR | 410mA |
| OCR | 420mA |
Modelos AI integrados
El firmware del HUSKYLENS 2 gestiona tanto el sistema RTOS como el entorno de despliegue de modelos AI. El dispositivo viene precargado con 20+ built-in AI models (como detección de objetos, reconocimiento facial, estimación de pose, segmentación de instancias) que pueden ser seleccionados por la UI a bordo o programáticamente:
Las actualizaciones de firmware se despliegan vía el puerto USB-C (o mediante la interfaz host) y el sistema soporta múltiples modelos corriendo en serie o en paralelo (dependiendo del uso de recursos) gracias al acelerador de 6 TOPS.
Modelos personalizados entrenados
Además de los modelos integrados, el HUSKYLENS 2 soporta el despliegue de custom-trained models, específicamente mediante un flujo de trabajo estilo YOLO: los usuarios pueden anotar datasets, entrenar modelos externamente, convertirlos al formato objetivo, cargarlos en el almacenamiento eMMC del dispositivo y ejecutarlos localmente.
Protocolo de contexto de modelo
Una característica distintiva es el “Protocolo de Contexto de Modelo” integrado (MCP) service, que permite al módulo de cámara emitir datos semánticos estructurados (por ejemplo: “persona A levantando objeto B”) a un modelo de lenguaje grande (LLM) conectado o aplicación host, conectando así el procesamiento de visión en el dispositivo con razonamiento de nivel superior.
Especificación técnica
La siguiente tabla resume la especificación técnica del HUSKYLENS 2:
| Parámetro | Especificación |
|---|---|
| Núcleo del procesador | CPU dual-core @1.6 GHz (Kendryte K230) |
| Acelerador AI | ~6 TOPS de cómputo AI en dispositivo |
| RAM | 1 GB LPDDR4 |
| Almacenamiento | 8 GB eMMC |
| Sensor de imagen | GC2093, 2 MP, 1/2.9″, hasta 60 fps |
| Pantalla a bordo | Pantalla táctil IPS 2.4″, resolución 640×480 |
| Interfaces | USB-C (alimentación/datos), Gravity de 4 pines (UART/I²C/Alim/GND), módulo WiFi opcional |
| Almacenamiento expandible | Ranura para tarjeta TF (micro-SD) |
| Audio I/O | Micrófono integrado, altavoz de 1 W |
| Indicadores / UI | 1 botón de función, 2 LEDs para iluminación, 1 LED RGB |
| Soporte de cámara modular | Módulos de lentes intercambiables (macro, visión nocturna, etc) |
| Voltaje de entrada | 3.3 V a 5.0 V |
| Consumo típico de energía | ~1.5 W a 3 W |
| Dimensiones | ~70 × 58 × 19 mm |
| Peso | ~90 g |
| Modelos precargados | Más de 20 modelos AI integrados |
| Soporte para modelos personalizados | mediante flujo de trabajo estilo YOLO |
| Características especiales | Servicio MCP que enlaza visión con LLMs |
Conectando HUSKYLENS 2 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, SCL) y pines de alimentación (VCC, GND). Mira la foto abajo:
Podrías conectar el HUSKYLENS 2 directamente a un Arduino y alimentarlo desde el pin de 5V del Arduino, pero ¡NO deberías hacerlo!
La corriente máxima que el pin de 5V del Arduino puede proporcionar es 500mA y el HUSKYLENS 2 consume hasta 420mA (modelo OCR). Esto es menor que la corriente máxima, pero para tiempos prolongados el regulador de voltaje del Arduino o ESP32 se calentará mucho y podría quemarse.
La opción segura es usar la pequeña placa adaptadora de alimentación que viene con el HUSKYLENS. Te permite alimentar el HUSKYLENS desde una fuente de alimentación separada.
Alternativamente, puedes conectar el HUSKYLENS a un puerto USB y el Arduino a otro puerto USB como se muestra en el Wiki de DFRobot:
Sin embargo, prefiero usar la placa adaptadora de alimentación y la siguiente sección te muestra cómo conectarla.
Diagrama de conexiones
El diagrama de conexiones abajo muestra cómo conectar el HUSKYLENS vía la placa adaptadora de alimentación a un Arduino UNO:
Comienza conectando la placa adaptadora al HUSKYLENS. Usa el cable blanco Dual-Plug PH2.0-4P de silicona (cables grises en el diagrama) que viene con el HUSKYLENS y asegúrate de usar el conector etiquetado «Huskylens» y «I2C/UART«:
Luego conecta el cable de conector sensor Gravity-4P de colores a la placa adaptadora y al Arduino:
El cable rojo debe conectarse al pin 5V del Arduino, el negro a GND. El verde es SDA y debe conectarse a A4, y el azul (SCL) a A5 del Arduino.
Conecta un power bank u otra fuente de alimentación de 5V mediante un cable USB a la placa adaptadora. Esto proveerá la energía para el HUSKYLENS. El HUSKYLENS debería funcionar una vez que se suministre energía USB.
Finalmente, necesitamos conectar nuestro Arduino mediante su cable USB a un PC que ejecute el Arduino IDE para poder programarlo:
Instalando la librería HuskylensV2
Antes de poder ejecutar cualquiera de los ejemplos de código siguientes en Arduino o ESP32, primero necesitas instalar la DFRobot_HuskylensV2 librería. Ve a la Github repo for the DFRobot_HuskylensV2 librería, haz clic en el botón verde Code y luego en «Download ZIP» para descargar la librería como un archivo ZIP:
Luego abre tu Arduino IDE, haz clic en «Sketch» -> «Include Library» -> «Add .ZIP Library …» para añadir la librería DFRobot_HuskylensV2 que acabas de descargar al Arduino IDE:
Ahora estamos listos para escribir algo de código.
Ejemplo de código: Comunicación I2C con modelos
En este primer ejemplo vamos a probar la comunicación I2C entre algunos de los modelos AI en el dispositivo HUSKYLENS y el Arduino UNO.
Conecta tu Arduino UNO a un PC con Arduino IDE. Asegúrate de que el Arduino sea reconocido en un puerto COM y que Arduino UNO esté seleccionado como placa:
Luego crea un nuevo Sketch y copia y pega el siguiente código. Este código establece una comunicación I2C entre el Arduino y el HUSKYLENS, e imprime los resultados de detección del modelo AI que esté corriendo en el 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);
}
Librerías y objetos
El código primero incluye la DFRobot_HuskylensV2 librería y crea el objeto HuskylensV2.
#include "DFRobot_HuskylensV2.h" HuskylensV2 huskylens;
Setup
Luego, en la función setup primero inicializamos la comunicación Serial (Serial.begin()) y la interfaz I2C (Wire.begin()). Después intentamos establecer comunicación I2C con el HUSKYLENS vía 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 esto falla y ves «Can’t init HUSKYLENS!» impreso en tu Monitor Serial, revisa las conexiones y asegúrate de que el protocolo de comunicación del HUSKYLENS 2 esté configurado en I2C. Para esto ve a «System Settings» -> «Protocol Type» y verifica que I2C esté seleccionado como se muestra abajo:
Loop
En la función loop primero esperamos si alguno de los algoritmos AI en el HUSKYLENS tiene resultados listos. Si es así, iteramos sobre todos los resultados disponibles e imprimimos el nombre y ID del resultado:
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);
}
Seleccionar algoritmo AI
Antes de que puedas ver resultados impresos en el Monitor Serial, debes primero seleccionar un algoritmo AI (modelo) en el HUSKYLENS (más adelante haremos esto automáticamente desde el código). Por ejemplo, puedes seleccionar el algoritmo de Reconocimiento de Objetos:
El HUSKYLENS entonces comenzará a detectar objetos y reportará los resultados al Arduino, si detecta alguno. Deberías ver una salida similar a la siguiente en tu Monitor Serial:
Ten en cuenta que puedes tener múltiples detecciones bajo un mismo RESULTADO, ya que puede haber varios objetos dentro de la imagen.
Puedes probar otros algoritmos AI pero aparte de un ID, la mayoría no proporcionará mucha información útil con este ejemplo de código. Los resultados dependen del algoritmo AI específico y requieren código específico para ser impresos. En las siguientes secciones aprenderás cómo obtener resultados más detallados.
Algoritmos AI
El HUSKYLENS 2 tiene muchos algoritmos AI integrados. Si abres el archivo Result.h de la librería DFRobot_HuskylensV2, encontrarás la siguiente lista de constantes para los modelos integrados:
// 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;
En lo siguiente usaremos los algoritmos de Reconocimiento de Objetos, Reconocimiento Facial y Reconocimiento de Emociones. Una vez que tengas experiencia con estos, escribir código para los demás es fácil.
Ejemplo de código: Reconocimiento de Objetos
En esta sección recuperaremos los resultados de detección del algoritmo Object Recognition. Ya usamos Reconocimiento de Objetos antes al probar la interfaz I2C pero solo recuperamos el nombre y ID del objeto detectado. El siguiente código recupera el nombre del objeto, su ID, su punto central y la caja delimitadora:
// (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);
}
El código es muy similar al anterior, con tres diferencias importantes. Primero, definimos una constante TASK que especifica el algoritmo AI para el que queremos obtener resultados.
#define TASK ALGORITHM_OBJECT_RECOGNITION
Segundo, en la función setup llamamos a huskylens.switchAlgorithm(TASK) para ejecutar automáticamente el algoritmo AI que queremos usar:
huskylens.switchAlgorithm(TASK);
Finalmente, en la función loop, ya no casteamos el tipo de retorno de huskylens.popCachedResult() sino que tomamos el tipo Result tal cual.
Result *r = huskylens.popCachedResult(TASK);
Dependiendo del algoritmo AI, el objeto Result se llena con diferentes datos de detección. En el caso de ALGORITHM_OBJECT_RECOGNITION, podemos obtener el name, classID, el punto central (xCenter, yCenter) y las dimensiones de la caja delimitadora (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 subes y ejecutas el código en tu Arduino, el HUSKYLENS debería activar automáticamente el algoritmo de Reconocimiento de Objetos:
y deberías ver los nombres y otra información de los objetos detectados impresos en el Monitor Serial:
Resultados y microprocesador
Ten en cuenta que algunos resultados no solo dependen del algoritmo AI sino también del microprocesador conectado al HUSKYLENS.
Para microprocesadores con más memoria que el Arduino, por ejemplo el ESP32, obtendrás resultados más detallados para algunos algoritmos (ver Differences in Data Acquisition). Puedes ver esto en el archivo Result.h de la librería DFRobot_HuskylensV2, que tiene la siguiente definición:
#if defined(ESP32) || defined(NRF5) || defined(ESP8266) #define LARGE_MEMORY 1 #endif
Esto significa que ESP32, ESP8266 y NRF5 son reconocidos como con memoria grande y se definen y retornan objetos Result, como FaceResult con más información:
#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;
};
En la siguiente sección conectaremos un ESP32 al HUSKYLENS y recuperaremos los resultados más completos para el algoritmo de Reconocimiento Facial.
Conectando HUSKYLENS 2 a ESP32
El ESP32 lite que uso aquí tiene la misma limitación máxima de corriente de salida de 500mA debido al regulador de voltaje ME6211 incorporado. Por eso conectamos nuevamente el ESP32 y el HUSKYLENS vía la placa adaptadora de alimentación para evitar sobrecargar el regulador de voltaje.
Abajo está el diagrama completo de conexiones. Es esencialmente el mismo que para el Arduino. Sin embargo, VCC está conectado a la salida de 3.3V del ESP32 y SCL y SDA están conectados a los pines 23 y 19, respectivamente:
Los pines hardware I2C dependerán de tu placa ESP32. Consulta la hoja de datos de tu placa ESP32 o mira nuestro tutorial Find I2C and SPI default pins para identificar los pines I2C para una placa diferente.
Ejemplo de código: Reconocimiento Facial
En este ejemplo de código vamos a recuperar resultados de detección del algoritmo Face Recognition. Devuelve las coordenadas del ojo izquierdo y derecho, la nariz y las esquinas izquierda y derecha de la boca. Mira los puntos blancos en la siguiente imagen que muestran esos puntos de referencia:
Ten en cuenta que el siguiente código solo compilará para un microprocesador ESP32, ESP8266 o NRF5, pero no para Arduino, por eso conectamos un ESP32 al HUSKYLENS en la sección anterior.
// (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 y objetos
Comenzamos definiendo una constante TASK para el algoritmo AI, el ALGORITHM_FACE_RECOGNITION. Luego creamos el objeto HuskylensV2 como de costumbre:
#define TASK ALGORITHM_FACE_RECOGNITION HuskylensV2 huskylens;
Setup
La función setup también permanece igual. Iniciamos la comunicación Serial y luego intentamos conectar con el HUSKYLENS. Si falla y ves «Can’t init HUSKYLENS!» en el Monitor Serial, ¡revisa las conexiones!
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...");
}
De lo contrario, el algoritmo AI ALGORITHM_FACE_RECOGNITION en el HUSKYLENS se activa vía huskylens.switchAlgorithm(TASK) y estamos listos para detectar rostros.
Loop
Sin embargo, hay un cambio importante en la función loop. Estamos casteando el resultado retornado por la función huskylens.popCachedResult() al tipo FaceResult. Este tipo contiene las coordenadas de ojos, nariz y boca para el rostro detectado, que luego imprimimos:
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 subes este código a tu ESP32 deberías ver la siguiente salida en tu Monitor Serial, si se detectan rostros:
Ten en cuenta que puedes ejecutar código similar en Arduino UNO pero solo obtendrás el punto central y la caja delimitadora debido a la menor memoria del Arduino, por ejemplo podrías cambiar la función loop así:
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);
Ejemplo de código: Semáforo de emociones
En este último ejemplo construiremos un Semáforo de Emociones. Usa el algoritmo Face Emotion Recognition del HUSKYLENS para detectar emociones como «Enojo», «Neutral» o «Felicidad» en rostros y usamos esta información para encender un LED rojo, amarillo o verde.
Voy a usar un Arduino aquí, pero un ESP32 también funcionaría. Primero, necesitamos conectar los LEDs. El siguiente diagrama muestra cómo conectarlos al Arduino UNO:
Conecté el LED rojo al pin 11, el amarillo al pin 10 y el verde al pin 9. No olvides la resistencia de 220 Ohm o similar para limitar la corriente a través de los LEDs. La foto abajo muestra el cableado en la protoboard:
Ahora estamos listos para escribir el código para nuestro Semáforo de Emociones. Añade funciones para controlar los LEDs y extiende la función loop para encender LEDs según el resultado (emoción) retornado por el algoritmo de Reconocimiento de Emociones 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);
}
Definiciones
Comenzamos definiendo los pines para los LEDs y el TASK como ALGORITHM_EMOTION_RECOGNITION :
#define RED_LED 11 #define YELLOW_LED 10 #define GREEN_LED 9 #define TASK ALGORITHM_EMOTION_RECOGNITION
Funciones para LEDs
Luego implementamos funciones para inicializar y controlar los tres 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);
}
Setup
En la función setup inicializamos la comunicación serial e I2C y los LEDs. Luego conectamos al HUSKYLENS vía huskylens.begin(Wire) y arrancamos el algoritmo AI como de costumbre vía 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
Finalmente, tenemos la función loop, donde recuperamos el resultado de detección de emociones y según la emoción detectada encendemos el LED rojo, amarillo 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);
}
}
Ten en cuenta que además de «Felicidad», «Enojo» y «Neutral» hay otras emociones como «Miedo», «Asco», «Triste» y «Sorpresa», a las que el código actual no reacciona. Pero podrías extenderlo fácilmente para esas emociones también.
Si ejecutas el código en tu Arduino, el HUSKYLENS debería activar el algoritmo de Reconocimiento de Emociones Faciales:
y en el Monitor Serial deberías ver una salida similar a la siguiente. También deberían encenderse los LEDs correspondientes a las emociones detectadas:
¡Y eso es todo! Los ejemplos de código y diagramas de conexión arriba deberían facilitarte empezar con el HUSKYLENS 2.
Conclusiones
Este tutorial te mostró cómo empezar con el sensor de visión AI HUSKYLENS 2. Aprendiste cómo conectarlo a un Arduino o ESP32 y cómo recuperar resultados de detección para los diversos algoritmos AI integrados en el HUSKYLENS 2. Te recomiendo también leer el Tutorial for HUSKYLENS 2 and Arduino Code Programming de DFRobot.
El HUSKYLENS 2 hace extremadamente fácil familiarizarse con varias aplicaciones AI como reconocimiento de objetos y rostros, reconocimiento de gestos de mano y pose, OCR y muchas otras. Puedes entrenar/ajustar fácilmente algunos de los algoritmos AI e incluso descargar tus propios modelos AI personalizados. Para más detalles, echa un vistazo a DFRobot’s Wiki for the HUSKYLENS 2.
La mayor ventaja de un sensor AI como el HUSKYLENS 2 es 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.
Las desventajas son un consumo de energía potencialmente mayor y una menor precisión de los modelos. Medí una corriente de hasta 420mA para el modelo de Reconocimiento Óptico de Caracteres (OCR), que parece ser el modelo con mayor consumo de energía.
La precisión de los modelos varía. Encontré que el reconocimiento de emociones faciales funciona muy bien, mientras que el modelo de reconocimiento de objetos produjo muchas clasificaciones erróneas. Probablemente querrás usar tu propio modelo personalizado con un número menor de clases para tareas de reconocimiento de objetos o probar la función Self-Learning Classifier.
Si tienes alguna pregunta, no dudes en dejarlas en la sección de comentarios.
¡Feliz bricolaje! 😉
