En este tutorial aprenderás los primeros pasos para utilizar la HUSKYLENS 2, un sensor de visión con inteligencia artificial que permite agregar reconocimiento visual a proyectos de forma sencilla.
Comenzaremos explicando cómo alimentar correctamente el módulo, cómo interactuar con su pantalla táctil y cómo explorar los diferentes modelos de IA que vienen precargados.
También aprenderás cómo verificar y actualizar el firmware de la HUSKYLENS 2, ya que algunos módulos pueden venir con una versión anterior y es recomendable instalar la versión más reciente para acceder a nuevas funciones, mejoras de estabilidad y modelos actualizados.
Después, realizaremos una práctica paso a paso donde entrenaremos la HUSKYLENS 2 para detectar dos gestos: palma abierta y mano cerrada, los cuales se utilizarán para encender y apagar un LED mediante una placa UNIT Pulsar ESP32 C6 o compatible. Finalmente, encontrarás una sección de referencia con los principales métodos de visión que puedes implementar, junto con ideas de aplicación para futuros proyectos con inteligencia artificial.
INTRODUCCIÓN
La HUSKYLENS 2 es un sensor de visión con inteligencia artificial diseñado para facilitar la integración de reconocimiento visual en proyectos de electrónica, robótica, automatización y educación. A diferencia de una cámara convencional, este módulo no solo captura imágenes, sino que también puede analizarlas directamente desde el dispositivo gracias a su capacidad de procesamiento interno.
Esto permite detectar, reconocer y clasificar elementos visuales sin depender completamente de una computadora externa o de procesos complejos de programación.
Este sensor está pensado para que estudiantes, makers, docentes, desarrolladores y entusiastas de la electrónica puedan experimentar con visión artificial e inteligencia artificial de una forma más sencilla. Su pantalla táctil permite seleccionar funciones, visualizar detecciones en tiempo real, aprender nuevos objetivos y ajustar parámetros directamente desde el módulo.
Además, puede comunicarse con diferentes tarjetas de desarrollo mediante I2C o UART, lo que facilita su integración con plataformas como Arduino, ESP32, micro:bit, Raspberry Pi y UNIHIKER.
Una de las principales ventajas de la HUSKYLENS 2 es que incorpora más de 20 modelos de visión precargados, listos para utilizarse en diferentes tipos de proyectos. Entre ellos se encuentran:
Esto la convierte en una herramienta muy versátil para crear proyectos inteligentes sin tener que entrenar modelos desde cero.
En comparación con la primera generación de HUSKYLENS, basada en el procesador Kendryte K210, la HUSKYLENS 2 representa una mejora importante en capacidad, funciones y posibilidades de aplicación. Mientras que el modelo anterior integraba 7 algoritmos principales, como reconocimiento facial, seguimiento de objetos, reconocimiento de objetos, seguimiento de líneas, reconocimiento de color, reconocimiento de etiquetas y clasificación de objetos, la HUSKYLENS 2 amplía considerablemente el número de modelos disponibles e incorpora funciones más avanzadas como reconocimiento de gestos, posturas humanas, segmentación de instancias, OCR, detección de caídas y despliegue de modelos personalizados.
Otra diferencia importante es su hardware. La HUSKYLENS 2 cuenta con un procesador Kendryte K230 de doble núcleo a 1.6 GHz, capacidad de cómputo de 6 TOPS, memoria LPDDR4 de 1 GB, almacenamiento interno eMMC de 8 GB, pantalla IPS táctil de 2.4 pulgadas con resolución 640 × 480, cámara de 2 MP a 60 FPS, micrófono, bocina, luces de relleno, ranura para tarjeta TF, interfaz USB-C y conector Gravity de 4 pines. Estas características la hacen más robusta y preparada para proyectos que requieren mayor procesamiento visual.
Además de utilizar los modelos precargados, la HUSKYLENS 2 permite trabajar con modelos personalizados, lo que abre la posibilidad de enseñar al sensor a reconocer objetos específicos según las necesidades del proyecto. Por ejemplo, se puede entrenar para identificar componentes electrónicos, herramientas, piezas mecánicas, señales, empaques, colores específicos o elementos utilizados en líneas educativas y prototipos de automatización. Esta capacidad resulta especialmente útil cuando los modelos integrados no son suficientes para una aplicación particular.
Gracias a estas cualidades, la HUSKYLENS 2 puede utilizarse en una gran variedad de aplicaciones. En robótica, puede servir para crear robots seguidores de línea, robots que siguen objetos, sistemas de navegación visual o robots controlados por gestos. En automatización, puede emplearse para clasificar piezas por color, detectar códigos, reconocer etiquetas, identificar productos o activar acciones según lo que observe la cámara. En proyectos educativos, permite explicar conceptos de inteligencia artificial, visión por computadora, clasificación de imágenes y control interactivo de una manera visual y práctica.
También puede utilizarse en proyectos de interacción humano-máquina, como sistemas que responden a gestos de mano, detección de posturas, reconocimiento facial, interfaces sin contacto o prototipos de seguridad. Por ejemplo, se puede configurar para encender una luz al detectar una palma abierta, apagar un dispositivo al detectar un puño cerrado, abrir una puerta al reconocer un rostro autorizado o activar una función al leer un código QR. Todo esto convierte a la HUSKYLENS 2 en una herramienta ideal para llevar proyectos electrónicos tradicionales a un nuevo nivel con visión e inteligencia artificial.
MATERIALES
Para realizar este tutorial utilizaremos pocos materiales los cuales son los siguientes:
- HUSKYLENS 2 Sensor de Visión con IA 2-6 TOPS LLM MCP SEN0638
- Cable USB Tipo C 3A
- Arduino UNO o tarjeta compatible
- LED 5mm
- Resistencia de 220 Ω o 330 Ω
- Protoboard
- Cables Dupont
1. Primeros pasos con la HUSKYLENS 2
Identificación de los elementos que integra la HUSKYLENS 2
La HUSKYLENS 2 es un módulo muy completo, ya que además de integrar una cámara, también incorpora pantalla, iluminación, audio, conectividad y puertos de comunicación que facilitan su uso en distintos proyectos. En la siguiente imagen se muestran sus principales partes y referencias físicas.
- Botón A: permite ejecutar acciones rápidas dentro de algunos modos, como aprender o confirmar una detección o habilitar el modo Boot para actualización de firmware.
- Módulo de cámara reemplazable: es el encargado de capturar la imagen que será procesada por los modelos de inteligencia artificial.
- Luz RGB: sirve como indicador visual de estado o funcionamiento.
- Luces de relleno: ayudan a mejorar la iluminación de la escena para obtener una detección más estable.
- Altavoz interno: permite reproducir avisos o sonidos durante ciertas funciones.
- Micrófono: útil para funciones relacionadas con interacción o captura de audio, según el modo de uso.
- Cubierta de antena WiFi: protege el área de conectividad inalámbrica integrada.
- Pantalla táctil: muestra la imagen capturada por la cámara, las detecciones, los menús y la información del sistema.
- Orificio de montaje: facilita la fijación del módulo en soportes, estructuras o robots.
- Tornillo de fijación de la cámara: mantiene asegurado el módulo de cámara.
- Tornillo de fijación de la carcasa: mantiene ensamblado el cuerpo del dispositivo.
- Interfaz Gravity UART / I2C: permite conectar la HUSKYLENS 2 a placas como Arduino, ESP32, micro:bit o Raspberry Pi mediante comunicación serial o I2C.
- Interfaz USB-C: se utiliza principalmente para alimentación, conexión a computadora y procesos como actualización de firmware.
- Ranura para tarjeta TF: permite ampliar almacenamiento o utilizar archivos compatibles según la función requerida.
Alimentación y encendido
Una vez identificadas sus partes, el siguiente paso es encender correctamente la HUSKYLENS 2.
La forma más práctica y recomendada para comenzar es alimentar el módulo mediante su puerto USB-C. Solo necesitas conectar un cable USB-C a la HUSKYLENS 2 y el otro extremo a una computadora, cargador USB o fuente de alimentación estable.
Para las primeras pruebas, esta es la mejor opción porque:
- Es sencilla y rápida.
- Permite una alimentación más estable.
- Facilita la actualización de firmware.
- Evita problemas de energía al usarla junto con un microcontrolador
Recomendación: Si posteriormente la conectas a una placa como Arduino para comunicarte por I2C o UART, lo ideal es seguir alimentando la HUSKYLENS 2 por USB-C y compartir la tierra común (GND) entre ambos dispositivos.
Al conectar la alimentación por USB-C, la HUSKYLENS 2 iniciará automáticamente. En pocos segundos la pantalla mostrará la interfaz principal y el sistema quedará listo para usarse.
Interacción con la pantalla táctil
Uno de los puntos fuertes de la HUSKYLENS 2 es su pantalla táctil. Desde la pantalla táctil puedes:
- Navegar entre los diferentes modelos de IA.
- Ver en tiempo real la imagen capturada por la cámara.
- Observar recuadros, etiquetas o puntos de detección.
- Entrenar ciertos reconocimientos o gestos.
- Configurar parámetros del sistema.
- Consultar información del dispositivo.
- Acceder a opciones como idioma, brillo y versión del firmware.
La navegación es bastante sencilla:
- Desliza sobre la pantalla para cambiar entre modelos o apartados.
- Toca una opción para entrar a ella.
- Confirma acciones desde la interfaz o mediante el Botón A, según el modo seleccionado.
En general, la pantalla funciona como centro de control de la HUSKYLENS 2. Desde aquí podrás elegir el tipo de reconocimiento que deseas utilizar y ver si la detección está funcionando correctamente.
Ahora que ya sabes cómo interactuar con la pantalla de la HUSKYLENS 2, te recomendamos revisar las configuraciones básicas que puedes realizar desde el sistema. Para conocer más detalles sobre estas opciones, consulta la siguiente documentación: Configuración del sistema HUSKYLENS 2.
Modelos de IA precargados en la HUSKYLENS 2
Entre los principales modelos que integra se encuentran:
Qué observar en pantalla durante las pruebas
Cuando selecciones un modelo de IA, la pantalla mostrará la escena frente a la cámara junto con información visual generada por el sistema, por ejemplo:
- Recuadros de detección.
- IDs o etiquetas.
- Puntos clave en manos o cuerpo.
- Líneas de seguimiento.
- Códigos detectados.
- Indicadores de reconocimiento.
Esto es muy útil, ya que permite verificar rápidamente si el módulo está reconociendo correctamente el objetivo antes de conectarlo a un proyecto con Arduino o ESP32.
2. Actualización de firmware
Antes de comenzar con proyectos avanzados, es recomendable verificar la versión del sistema de la HUSKYLENS 2. Algunos módulos pueden venir con una versión anterior de firmware, por lo que actualizarlo permite acceder a nuevas funciones, mejoras de estabilidad, modelos adicionales y correcciones de funcionamiento.
De acuerdo con la documentación oficial, la versión más reciente indicada para HUSKYLENS 2 es 1.2.2. Para revisar la versión instalada, entra a:
System Settings > Device Information
Si tu HUSKYLENS 2 tiene una versión anterior, se recomienda actualizarla antes de continuar.
Recomendaciones antes de actualizar
Antes de actualizar el firmware toma en cuenta lo siguiente:
- Utiliza una computadora con Windows, macOS o Linux.
- Usa un cable USB-C de buena calidad.
- Respalda los archivos almacenados en la memoria de la HUSKYLENS 2.
- No la desconectes durante el proceso de actualización.
Importante: Durante la actualización, el contenido almacenado en la unidad USB de la HUSKYLENS puede borrarse, por lo que es recomendable hacer una copia de seguridad antes de continuar.
Pasos para actualizar el firmware
1. Instalación de drivers
El primer paso es instalar los drivers necesarios en tu computadora para que la HUSKYLENS 2 pueda ser reconocida correctamente y posteriormente sea posible cargar el firmware.
Para realizar este proceso utilizaremos el programa Zadig, una herramienta que permite instalar o reemplazar controladores USB de forma sencilla. Así que descárgalo y realizar el proceso de instalación.
Ya instalado el programa de Zadig sigue los siguientes pasos para instalar el driver:
- Mantén presionado el Button-A de HUSKYLENS 2 y después conecta a tu PC espera aproximadamente 2 segundos y suelta el botón.
- Después abre el administrador de dispositivos saldrá de la síguete forma:
- Ahora abre el programa Zadig y selecciona K230 USB Boot Device y después da clic en Install Driver:
- Espera el proceso de instalación, ya completado puedes desconectar la HUSKYLENS 2 de tu pc.
2. Descarga la ultima versión del firmware
Descarga la ultima versión firmware desde el repositorio de GitHub de DFROBOT
https://github.com/DFRobot/DFRobot_HuskylensV2/releases/
Descomprime el archivo .ZIP huskylensV2-v1.2.2.0204.img ya que en el siguiente paso se utilizara.
3. Descarga el programa K230 BurningTool
Ya que instalaste el driver, utilizaremos el programa de K230 BurningTool para cargar el firmware. Haz clic en el siguiente enlace para descargarlo:
El programa es portable solo descomprime el archivo .zip y abre K230 BurningTool.exe
4. Cargar el firmware
Una vez que hayas abierto el programa K230 BurningTool.exe, es necesario colocar la HUSKYLENS 2 en modo Boot antes de conectarla a la computadora. Este modo permite que la PC reconozca correctamente el dispositivo para iniciar el proceso de actualización del firmware.
Para activar el modo Boot, mantén presionado el Button-A de la HUSKYLENS 2. Sin soltarlo, conecta la placa a tu PC mediante el cable USB. Espera aproximadamente 2 segundos y después suelta el botón.
Cuando el dispositivo sea detectado por el programa, carga el archivo de firmware correspondiente:
huskylensV2-v1.2.2[0204].img
Después de seleccionar la imagen del firmware, da clic en el botón Start para iniciar la carga. Espera a que el proceso finalice por completo y evita desconectar la HUSKYLENS 2 durante la actualización.
3. Entrenamiento de gestos: palma abierta y mano cerrada
En esta práctica utilizaremos la función Hand Recognition de la HUSKYLENS 2 para entrenar dos gestos de la mano: palma abierta y mano cerrada. Después, la HUSKYLENS 2 enviará el resultado por comunicación I2C a la UNIT Pulsar ESP32-C6, la cual se encargará de encender o apagar un LED dependiendo del gesto detectado.
La lógica será muy sencilla:
| Gesto detectado | ID asignado | Acción |
|---|---|---|
| Palma abierta | ID 1 | Encender LED |
| Mano cerrada | ID 2 | Apagar LED |
| Gesto no aprendido | ID 0 | Sin acción |
La función Hand Recognition puede detectar la palma de la mano, identificar puntos clave y reconocer gestos previamente aprendidos. De acuerdo con la documentación de DFRobot, este modo puede visualizar 21 puntos clave de la mano y, después del aprendizaje, mostrar el nombre del gesto, su ID y el nivel de confianza de la detección.
Materiales
Para esta práctica utilizaremos:
- HUSKYLENS 2 Sensor de Visión con IA 2-6 TOPS LLM MCP SEN0638
- UNIT Pulsar ESP32 C6
- LED 5mm
- Resistencia de 220 Ω o 330 Ω
- Protoboard
- Cables Dupont
- Cable USB Tipo C 3A
Preparación de la HUSKYLENS 2
Antes de iniciar el entrenamiento de gestos, asegúrate de que la HUSKYLENS 2 esté encendida y actualizada. También es recomendable trabajar en un espacio con buena iluminación para que la cámara pueda distinguir correctamente la forma de la mano.
Desde la pantalla táctil de la HUSKYLENS 2, selecciona la función:
Hand Recognition
Al entrar en este modo, apunta la cámara hacia tu mano. Cuando el módulo detecte una palma, aparecerá un recuadro y puntos de referencia sobre la mano. Esto indica que la HUSKYLENS 2 está reconociendo correctamente la presencia de una mano en la imagen.
Si ya habías realizado pruebas anteriores, puedes borrar los gestos aprendidos desde la opción Forget IDs para comenzar desde cero. Esta opción elimina los IDs guardados y ayuda a evitar confusiones durante la práctica.
Entrenamiento del gesto: palma abierta
El primer gesto que entrenaremos será la palma abierta, ya que la usaremos como señal para encender el LED.
Coloca tu mano frente a la cámara de la HUSKYLENS 2 con la palma abierta. Trata de mantener la mano completa dentro del área visible de la pantalla, con los dedos separados y una distancia aproximada de 20 a 40 cm de la cámara.
Cuando la mano sea detectada correctamente, presiona el Botón A para aprender el gesto. La HUSKYLENS 2 asignará este primer gesto como ID1. Para mejorar la precisión, puedes mantener presionado el Botón A y mover ligeramente la mano, cambiando un poco el ángulo, la distancia y la posición. La documentación oficial recomienda este aprendizaje multiángulo para mejorar el reconocimiento del gesto.
Recomendación
Después de aprender el gesto, puedes cambiar el nombre del ID desde la opción Set Name y asignarle un nombre como: Palma
De esta forma será más fácil identificarlo en pantalla durante las pruebas.
Entrenamiento del gesto: mano cerrada
El segundo gesto será la mano cerrada o puño, y lo utilizaremos para apagar el LED.
Coloca nuevamente tu mano frente a la cámara, pero ahora con el puño cerrado. Asegúrate de que la mano se vea completa, bien iluminada y sin otros objetos cerca que puedan confundirse con la forma de la mano.
Presiona el Botón A para aprender este segundo gesto. Como será el segundo gesto aprendido, la HUSKYLENS 2 lo asignará como ID2.
También puedes realizar aprendizaje multiángulo manteniendo presionado el Botón A mientras mueves ligeramente la mano. Esto ayuda a que la HUSKYLENS 2 reconozca mejor el gesto aunque la posición de la mano cambie un poco.
Recomendación
Puedes nombrar este segundo ID como: Puño o Mano cerrada
Así podrás identificar más fácilmente cuándo la HUSKYLENS 2 reconoce cada gesto.
Verificación del entrenamiento
Después de entrenar ambos gestos, realiza una prueba rápida directamente desde la pantalla de la HUSKYLENS 2.
Muestra la palma abierta frente a la cámara. El módulo debería mostrar algo similar a:
Gesture: ID1
Después muestra la mano cerrada. Ahora debería mostrar:
Gesture: ID2
Si al mostrar un gesto aparece ID0, significa que la HUSKYLENS 2 detectó una mano, pero no logró asociarla con un gesto aprendido. En ese caso, vuelve a entrenar el gesto con mejor iluminación, mayor estabilidad y diferentes ángulos.
Conexión de la HUSKYLENS 2 con la UNIT Pulsar ESP32-C6
Para este tutorial, la HUSKYLENS 2 se conectará a la UNIT Pulsar ESP32-C6 mediante el adaptador Power Board V1, incluido con el sensor. Este adaptador facilita la conexión de alimentación y comunicación, evitando conectar directamente sobre el módulo principal.
La comunicación se realizará mediante I2C, utilizando las líneas SDA y SCL. La UNIT Pulsar ESP32-C6 será la encargada de recibir el ID del gesto detectado por la HUSKYLENS 2 y, con base en ese resultado, encender o apagar un LED.
Conexión I2C
Para esta conexión se utilizarán los pines tipo Arduino Nano de la UNIT Pulsar ESP32-C6:
| Power Board V1 / HUSKYLENS 2 | UNIT Pulsar ESP32-C6 | Función |
|---|---|---|
| VCC / 5V | 5V | Alimentación |
| GND | GND | Tierra común |
| SDA | A4 / GPIO22 | Datos I2C |
| SCL | A5 / GPIO23 | Reloj I2C |
Antes de energizar el circuito, verifica la serigrafía del Power Board V1 para confirmar correctamente los pines VCC, GND, SDA y SCL.
Alimentación del sistema
En este montaje se utiliza una fuente externa de 5V DC para alimentar correctamente la HUSKYLENS 2. La UNIT Pulsar ESP32-C6 también estará conectada a la computadora por USB-C para cargar el programa y visualizar información en el Monitor Serial.
Es importante que todos los elementos compartan la misma referencia de tierra, es decir, conectar GND de la fuente, GND de la Pulsar y GND del Power Board V1.
Conexión del LED
El LED será la salida visual de la práctica:
| Componente | UNIT Pulsar ESP32-C6 |
|---|---|
| Ánodo del LED | GPIO8 / D2 mediante resistencia |
| Cátodo del LED | GND |
La resistencia puede ser de 220 Ω o 330 Ω para limitar la corriente del LED.
Configuración en Arduino IDE
Antes de cargar el código, configura Arduino IDE de la siguiente manera:
Abre Arduino IDE. Instala las tarjetas ESP32 by Espressif Systems. Selecciona una tarjeta compatible con ESP32-C6, por ejemplo ESP32C6 Dev Module. Selecciona el puerto COM correspondiente. Instala la librería DFRobot_HuskylensV2. Carga el siguiente código.
Código para encender y apagar un LED con gestos
Este código lee el ID del gesto detectado por la HUSKYLENS 2. Si detecta ID1, enciende el LED. Si detecta ID2, lo apaga.
// Nota:
// Antes de cargar el programa, asegúrate de que la HUSKYLENS 2 ya tenga aprendidos
// los gestos correspondientes. En este ejemplo, el ID 1 corresponde a palma abierta
// y el ID 2 corresponde a mano cerrada.
#include <Wire.h> // Incluye la librería Wire para comunicación I2C
#include "DFRobot_HuskylensV2.h" // Incluye la librería para controlar la HUSKYLENS 2
// Objeto para HUSKYLENS 2
HuskylensV2 huskylens; // Crea un objeto llamado huskylens para comunicarse con la cámara
// Pines I2C usando A4/A5 de la UNIT Pulsar ESP32-C6
// A4 = GPIO22 = SDA
// A5 = GPIO23 = SCL
const int I2C_SDA = 22; // Define el pin GPIO22 como SDA para la comunicación I2C
const int I2C_SCL = 23; // Define el pin GPIO23 como SCL para la comunicación I2C
// LED externo conectado a D7 / GPIO21
const int LED_PIN = 8; // Define el pin donde está conectado el LED externo
// IDs aprendidos en la HUSKYLENS 2
const int ID_PALMA_ABIERTA = 1; // Define el ID 1 como el gesto de palma abierta
const int ID_MANO_CERRADA = 2; // Define el ID 2 como el gesto de mano cerrada
void setup() { // Función setup: se ejecuta una sola vez al iniciar la placa
Serial.begin(115200); // Inicia la comunicación serial a 115200 baudios
delay(1000); // Espera 1 segundo para estabilizar el inicio del sistema
pinMode(LED_PIN, OUTPUT); // Configura el pin del LED como salida
digitalWrite(LED_PIN, LOW); // Apaga el LED al iniciar el programa
Serial.println("Iniciando HUSKYLENS 2 con UNIT Pulsar ESP32-C6...");
// Muestra un mensaje en el monitor serial indicando el inicio del sistema
// Inicializa bus I2C en los pines definidos
Wire.begin(I2C_SDA, I2C_SCL); // Inicia la comunicación I2C usando los pines SDA y SCL definidos
Wire.setClock(100000); // Configura la velocidad del bus I2C a 100 kHz
// Verifica comunicación con HUSKYLENS 2
while (!huskylens.begin(Wire)) { // Mientras no se detecte la HUSKYLENS 2 por I2C, repite el bloque
Serial.println("No se detecta la HUSKYLENS 2. Revisa SDA, SCL, GND y alimentacion.");
// Muestra un mensaje de error si no hay comunicación con la HUSKYLENS 2
delay(500); // Espera 500 milisegundos antes de volver a intentar la conexión
}
// Selecciona el modelo de reconocimiento de mano
huskylens.switchAlgorithm(ALGORITHM_HAND_RECOGNITION);
// Cambia la HUSKYLENS 2 al modo de reconocimiento de manos
Serial.println("HUSKYLENS 2 lista en modo Hand Recognition.");
// Indica que la HUSKYLENS 2 ya está lista en modo reconocimiento de manos
Serial.println("ID1 = Palma abierta -> LED encendido");
// Muestra la acción asociada al ID 1 en el monitor serial
Serial.println("ID2 = Mano cerrada -> LED apagado");
// Muestra la acción asociada al ID 2 en el monitor serial
}
void loop() { // Función loop: se ejecuta continuamente después del setup
// Solicita resultados del modelo Hand Recognition
huskylens.getResult(ALGORITHM_HAND_RECOGNITION);
// Solicita a la HUSKYLENS 2 los resultados actuales del reconocimiento de manos
if (huskylens.available(ALGORITHM_HAND_RECOGNITION)) {
// Verifica si hay resultados disponibles del algoritmo de reconocimiento de manos
int gestureID = RET_ITEM_NUM( // Crea una variable para guardar el ID del gesto detectado cerca del centro
huskylens.getCachedCenterResult(ALGORITHM_HAND_RECOGNITION),
// Obtiene el resultado detectado más cercano al centro de la pantalla
Result, // Indica que se quiere acceder a los datos del resultado detectado
ID // Extrae el valor del ID aprendido por la HUSKYLENS 2
);
int totalGestos = huskylens.getCachedResultNum(ALGORITHM_HAND_RECOGNITION);
// Guarda la cantidad total de gestos detectados por la HUSKYLENS 2
Serial.print("Gestos detectados: ");
// Imprime el texto "Gestos detectados:" en el monitor serial
Serial.print(totalGestos); // Imprime la cantidad total de gestos detectados
Serial.print(" | ID cerca del centro: ");
// Imprime un separador y texto para mostrar el ID detectado
Serial.println(gestureID); // Imprime el ID del gesto detectado cerca del centro
if (gestureID == ID_PALMA_ABIERTA) {
// Verifica si el gesto detectado corresponde a la palma abierta
digitalWrite(LED_PIN, HIGH); // Enciende el LED externo
Serial.println("Palma abierta detectada -> LED ENCENDIDO");
// Muestra en el monitor serial que se detectó la palma abierta
}
else if (gestureID == ID_MANO_CERRADA) {
// Si no fue palma abierta, verifica si el gesto es mano cerrada
digitalWrite(LED_PIN, LOW); // Apaga el LED externo
Serial.println("Mano cerrada detectada -> LED APAGADO");
// Muestra en el monitor serial que se detectó la mano cerrada
}
else if (gestureID == 0) { // Verifica si se detectó un gesto, pero no está aprendido o registrado
Serial.println("Gesto detectado, pero no aprendido.");
// Muestra un mensaje indicando que el gesto no tiene ID aprendido
}
}
delay(100); // Espera 100 milisegundos antes de volver a leer la HUSKYLENS 2
}
¿Qué hace el código?
El programa inicializa la comunicación I2C entre la UNIT Pulsar ESP32-C6 y la HUSKYLENS 2. Después cambia el modo activo de la cámara a Hand Recognition, que es el modelo encargado de detectar y reconocer gestos de mano.
En cada ciclo, la Pulsar solicita a la HUSKYLENS 2 el resultado más reciente. Si existe un gesto detectado, el programa obtiene el ID del gesto más cercano al centro de la imagen. Esta lógica es útil porque evita tomar como referencia una mano que aparezca parcialmente en los bordes de la cámara.
Cuando el ID recibido es 1, el programa interpreta que se detectó la palma abierta y activa el pin del LED. Cuando el ID recibido es 2, interpreta que se detectó la mano cerrada y apaga el LED.
Cómo validar que funciona
Para comprobar el funcionamiento realiza las siguientes pruebas:
- Carga el código en la UNIT Pulsar ESP32-C6.
- Abre el Monitor Serial a 115200 baudios.
- En la HUSKYLENS 2, entra al modo Hand Recognition.
- Muestra la palma abierta frente a la cámara.
- El Monitor Serial debe mostrar ID1 y el LED debe encender.
- Muestra la mano cerrada.
- El Monitor Serial debe mostrar ID2 y el LED debe apagarse.
Si el LED no cambia de estado, revisa primero el Monitor Serial. Si no aparece ningún ID, el problema puede estar en la conexión I2C, la alimentación o el modo seleccionado en la HUSKYLENS 2.
CONCLUSIÓN
La HUSKYLENS 2 es una herramienta muy práctica para comenzar a integrar visión con inteligencia artificial en proyectos de electrónica, robótica, automatización y educación. Gracias a sus modelos precargados, pantalla táctil e interfaces de comunicación, permite experimentar con reconocimiento visual de una forma sencilla, sin necesidad de configurar sistemas complejos de visión artificial desde cero.
A lo largo del tutorial conociste sus elementos principales, la forma correcta de alimentación, el uso básico de su interfaz, la importancia de mantener actualizado el firmware y las posibilidades que ofrecen sus diferentes modelos de IA. Además, viste cómo es posible entrenar gestos personalizados y utilizarlos como señales de control para interactuar con una tarjeta de desarrollo, como la UNIT Pulsar ESP32-C6.
Aunque el ejemplo se enfoca en una práctica sencilla de control por gestos, la misma idea puede aplicarse a proyectos más completos, como robots inteligentes, sistemas de acceso, clasificación de objetos, seguimiento de líneas, lectura de códigos, automatización visual e interfaces sin contacto. Esto convierte a la HUSKYLENS 2 en una excelente opción para dar el siguiente paso en proyectos que requieren interacción visual, aprendizaje automático y control inteligente.
