Le enseñas una cara a tu cámara con IA… y ahora vas a conseguir que se detenga a mirarla

Hay una cámara que aprende a reconocer una cara, un objeto o un color con solo pulsar un botón, y luego lo busca sola en todo lo que tiene delante: es la HuskyLens, y es, literalmente, un pequeño agente inteligente. El problema es que, tal y como viene programada de fábrica, en cuanto reconoce algo lo dice y sigue mirando sin pausa, tan rápido que apenas te da tiempo a leerlo. Aquí tienes el proceso completo, paso a paso, para conseguir que se quede 2 segundos “congelada” mostrando el resultado antes de seguir buscando — y para que lo repitas tú mismo con tu propio Arduino.

El problema que resuelve

Cuando conectas una HuskyLens a un Arduino y la dejas funcionando con su programa básico, el mensaje de “objeto reconocido” aparece y desaparece del Monitor Serie en una fracción de segundo, al mismo ritmo constante con el que la cámara sondea todo el rato. Para alguien que se está iniciando en programación, o para un grupo de alumnos viendo el resultado proyectado en la pizarra, ese ritmo no da tiempo a leer ni a entender qué ha pasado. La solución no es hardware nuevo: es enseñarle al programa a comportarse de forma distinta según lo que acaba de ocurrir.

Lo que necesitas antes de empezar

• Un Arduino Mega (sirve cualquier placa con un puerto serie por hardware libre, como el Serial1 del Mega).
• Una cámara HuskyLens, ya conectada por UART a esos pines y con el sketch básico de arranque funcionando (el que solo imprime lo que ve, sin pausas).
• El IDE de Arduino y la librería HUSKYLENS.h instalada.
• Haber “enseñado” ya al menos un objeto o una cara a la cámara con su botón de aprendizaje.

Paso 1 — Localiza dónde se decide el ritmo del programa

Abre tu sketch de arranque y busca la línea delay(150); al final de la función loop(). Ese es el único temporizador que tiene el programa ahora mismo: hace una pausa corta y constante en cada vuelta, reconozca algo o no. Ese único número es lo que vas a sustituir por una decisión.

Paso 2 — Añade una variable que recuerde lo que ha pasado en esta vuelta

Al principio de loop(), antes de que el programa pregunte nada a la cámara, declara una variable nueva:

cpp

bool reconocido = false;

Una variable booleana solo puede valer verdadero o falso, y aquí va a servir de “memoria” de una sola vuelta del bucle: por defecto asumimos que no se ha reconocido nada, y solo la cambiamos si ocurre.

Paso 3 — Marca el momento exacto en que la cámara reconoce algo

Dentro del bloque que ya imprime los datos del objeto (if (result.command == COMMAND_RETURN_BLOCK) { ... }), justo después de las líneas que muestran el ID, la posición y el tamaño, añade:

cpp

reconocido = true; // hemos identificado un objeto/cara ya aprendido

Con esto, en el instante en que la HuskyLens confirma un reconocimiento, el programa lo anota en esa variable para poder usarlo más abajo.

Paso 4 — Cambia el temporizador final por una decisión

Ahora sí, sustituye el delay(150); único por esto:

cpp

if (reconocido) {
    delay(2000);   // hemos reconocido algo: nos quedamos 2 s viéndolo
} else {
    delay(150);    // seguimos buscando a ritmo normal
}

Esta es la pieza clave de todo el ejercicio: el mismo programa ahora se comporta de dos formas distintas según lo que acaba de percibir, que es exactamente lo que hace que hablemos de un “agente” y no de una simple secuencia de instrucciones fijas.

Paso 5 — Verifica, sube y compruébalo con tus propios ojos

Compila el programa, súbelo a la placa y abre el Monitor Serie a 115200 baudios (recuerda que la comunicación con la HuskyLens va aparte, a 9600 baudios). Enseña de nuevo el objeto o la cara que ya tenías aprendidos y observa el resultado: en cuanto los reconoce, el mensaje se queda quieto 2 segundos en pantalla antes de que la cámara vuelva a sondear a su ritmo normal.

Avisos antes de manipular el cableado

No conectes ni desconectes el cable de la HuskyLens con la placa encendida: apaga o desconecta el USB antes de tocar el cableado. Comprueba también la orientación del conector antes de encajarlo, sin forzarlo. Y, aunque con luz ambiente normal no hay ningún riesgo para el sensor, evita apuntar la cámara de forma prolongada hacia fuentes de luz muy intensas.

La idea para llevarse a casa

El cambio real en este ejercicio no está en el delay() en sí, sino en la idea de fondo: un programa puede reaccionar de forma distinta según lo que un sistema de inteligencia artificial acaba de percibir, en vez de repetir siempre la misma acción. Esa misma lógica —una variable que recuerda lo ocurrido y un if/else que decide qué hacer con ello— es la base de cualquier proyecto donde una IA ya entrenada tenga que comunicarse con un programa de control, muchísimo más allá de una simple pausa de 2 segundos.