Cámara Seguidora de Rostros con IA

InicioTarjetas de DesarrolloArduinoCámara Seguidora de Rostros con IA

Cámara Seguidora de Rostros con IA

En esta publicación abordamos el tema de IA con la aplicación de una cámara seguidora de rostros, se verá el desarrollo de la programación en PyCharm usando librerías de tratado de imágenes, como es Mediapipe, y la clásica de VA OpenCV, así como el envío de datos a través de puerto serial para la toma de decisiones en un Arduino uno.

Introducción

La inteligencia artificial (IA) es una rama de la informática que desarrolla sistemas capaces de realizar tareas que normalmente requieren inteligencia humana, como percibir el entorno, aprender, razonar, resolver problemas y comunicarse.

¿Que és OpenCV?

OpenCV es una biblioteca de software de código abierto que proporciona herramientas para visión por computadora, procesamiento de imágenes y aprendizaje automático en tiempo real.

¿Qué es Mediapipe?

MediaPipe es un conjunto de herramientas de código abierto diseñado para facilitar el desarrollo de soluciones de visión artificial en tiempo real. Ofrece una colección de soluciones listas para usar para tareas como el reconocimiento facial, el seguimiento de gestos, la detección de objetos y el seguimiento del cuerpo humano.

Materiales

Arduino UNO SMD Tipo C.
Cables Dupont Largos.
Servomotor SG90 RC 9g.
Cable USB Tipo C.
WebCam.
Piezas de Estructura.
PC / Ordenador.
IDE PyCharm.
IDE Arduino.

Diagrama de Conexión

A continuación, se puede ver el diagrama para conectar el Servomotor y el Arduino.

Requerimientos Previos

Instalación de PyCharm

Para la programación en lenguaje Python se usará el IDE conocido como PyCharm, su instalación es muy sencilla, como primer paso lo que se debe de realizar es ingresar a la página de JetBrains, nos abrirá la siguiente pantalla:

Le daremos en el botón de “Descarga”, y posteriormente en el botón “Descargar”, de forma automática empezará, al finalizar tendremos un archivo ejecutable .exe, posteriormente lo ejecutaremos como administrador:

Empezará la instalación con la ventana emergente, se dará en “Next”.

Ilustración 4. Dirección de Instalación.

Se abrirá la ventana en donde veremos la dirección del lugar donde se instalará el programa, se dará “Next”. En la siguiente ventana seleccionaremos las primeras 3 opciones, quedando de la siguiente manera:

Ilustración 5. Configuración de PyCharm.

Aquí solo le daremos en “Install”:

Ilustración 6. Aceptación de Instalación.

Una vez que termine la instalación, tendremos el mensaje de termino:

Con estos sencillos pasos terminamos de instalar PyCharm, ahora lo que haremos es la configuración del Proyecto.

Configuración de Proyecto en PyCharm.

Si terminamos con la instalación de PyCharm, este se abrirá de forma automática, teniendo la siguiente ventana:

Le daremos click a “New Project”, y tendremos que hacer la siguiente configuración, como se ve en la siguiente imagen:

En la sección “Environment:” nos iremos a Custom environmente, y ahí pondremos en “Type:” Virtualenv; algo sumamente importante es cambiar la “Base Python:” a Python 3.8.10, en caso contrario tendremos problemas en la ejecución del código por la librería Mediapipe.

Ahora bien, el nombre del proyecto lo da de forma automática Python, se puede cambiar o dejarlo así, sin embargo, si se cambia no debe contener espacios ni tampoco caracteres especiales, ya que, esto afecta a la ejecución del código. Teniendo el proyecto creado, procederemos a la instalación de librerías necesarias.

Instalación de Librerías

Teniendo abierto el proyecto en la esquina superior izquierda se tendrá 3 rayas, daremos click ahí (Main Menu):

Posteriormente, iremos a “File” y de ahí a Settings:

Ahora en “Python Interpreter”:

Nos dirigiremos en “Install”, que es un símbolo “+”:

Se abrirá el siguiente recuadro, en el cual buscaremos opencv-python y le daremos en “Install Package”:

Esperaremos hasta que termine de instalar, posteriormente haremos el mismo procedimiento con las librerías:

Mediapipe.
Pyserial.

ATENCIÓN: A cada una, se le tiene que dar el tiempo para instalarse, ya que, si queremos instalar las dos al mismo tiempo, no funcionará. De esta forma tendremos las librerías ya listas para usar.

Instalar Arduino IDE

Para la instalación de Arduino IDE se puede hacer desde su página oficial, dando solo click en “Descargar”, verificando que sea su sistema operativo el seleccionado, se ejecuta como administrador, y le daremos en siguiente a todas las ventanas.

La otra opción más sencilla es abrir la “Microsoft Store” y buscar Arduino IDE, tendremos la siguiente imagen:

Le daremos en “Obtener” y listo lo tendremos instalado, cualquiera de las dos formas nos funcionará.

Códigos

Código de PyCharm

'''''
========================================================================================================================
Nombre del archivo:     Deteccion_Rostros.py
Proyecto:               UNIT Electronics Blog - Cámara Seguidora de Rostros con IA UNIT Electronics Blog
Área:                   Desarrollo
Autor:                  Gonzalo González
Fecha:                  21/08/2025
========================================================================================================================
Descripción:

Este programa permite abrir la interfaz de la cámara de la laptop o de una WebCAM (es lo ideal) para que detecte rostros humanos, y así enviar datos a través del puerto serial para un Arduino UNO, los cuales serán interpretados para un Servomotor que estará unido a la cámara, se usan librerías de IA como cv2, mediapipe (detección de rostro), y serial para la comunicación.
========================================================================================================================
Desarrollado para UNIT Electronics / Desarrollo / Blog UNIT Electronics
========================================================================================================================
'''''

# Importación de Librerías

import cv2
import mediapipe as mp
import serial

# Puerto Serial Configuración

com = serial.Serial("COM16", 9600, write_timeout=10) # Se configura el puerto serial para el arduino
d = 'd'
i = 'i'
p = 'p'

# Declaración del Dectetor de Rostros

detector = mp.solutions.face_detection
dibujo = mp.solutions.drawing_utils

# Video Captura del Rostro en Tiempo Real

cap = cv2.VideoCapture(0, cv2.CAP_DSHOW) # Si usamos una WEBCAM, que es lo ideal sebe poner un valor alto (0), pero si vamos a usar la cam de la lap debe ser un valor bajo (1)

# Detección del Rostro Fidelidad

with detector.FaceDetection(min_detection_confidence=0.75,) as rostros: # Declaramos que tan certero será nuestro detector
    while True:
        ret, frame = cap.read()

        # Aplicación Espejo en los frames, se hace ya que cv2 hace la captura de lado opuesto, provocando irregularidades
        frame = cv2.flip(frame, 1)

        # Corrección de Color, como mediapipe no acept aformato BGR se debe convertir a RGB
        rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

        # Detección de los Rostros
        resultado = rostros.process(rgb)

        # ¿Qué sucede si tenemos muchos rostros en el campo?
        if resultado.detections is not None:
            for rostro in resultado.detections:
                dibujo.draw_detection(frame, rostro, dibujo.DrawingSpec(color=(0,255,0),))

                for id, puntos in enumerate(resultado.detections):
                    # print("Puntos: ", resultado.detections)

                    al, an, c = frame.shape # Extraemos las dimensiones de la captura
                    centro = int(an/2) # Se saca el centro de la imagen

                    x = puntos.location_data.relative_bounding_box.xmin
                    y = puntos.location_data.relative_bounding_box.ymin # Se extraen las coordenadas X,Y

                    ancho = puntos.location_data.relative_bounding_box.width
                    alto = puntos.location_data.relative_bounding_box.height # Se extrean el ancho y alto

                    x, y = int(x * an), int(y * al)
                    # print("X, Y: ", x, y) # Pasamos los datos de X, Y a coordenadas en pixeles

                    x1, y1 = int(ancho * an), int(alto * al) # Pasamos el ancho y el alto a pixeles

                    cx = (x + (x + x1)) // 2
                    cy = (y + (y + y1)) // 2 # Se calcula el punto central
                    # print("Centro: ", cx, cy)

                    cv2.circle(frame, (cx, cy), 3, (0, 0, 255), cv2.FILLED)
                    cv2.line(frame, (cx, 0), (cx, 480), (0, 0, 255), 2) # Mostraremos un punto en el centro, y la linea roja

                    if cx < centro - 50: # Control del Servo a través del puerto COM
                        print("Izquierda") # Movimiento hacia la izquierda, se envía la letra i en asccii al arduino
                        com.write(i.encode('ascii'))

                    elif cx > centro + 50:
                        print("Derecha") # Movimiento hacia la derecha, se envía la letra d en asccii al arduino
                        com.write(d.encode('ascii'))

                    elif cx == centro: # Se para el servo, se envía la letra p en asccii al arduino
                        print("Parar")
                        com.write(p.encode('ascii'))

        cv2.imshow("Camara", frame) # Mostramos el video en tiempo real
        if cv2.waitKey(1) & 0xFF == ord('s'): # Se puede cerrar el código a través de la letra s del teclado
            com.close()
            break
cap.release()
cv2.destroyAllWindows() # Destruimos todas las ventanas y cerramos el código

Código de Arduino

/*
========================================================================================================================
Nombre del archivo:     SERVO_ROSTRO.ino
Proyecto:               UNIT Electronics Blog - Cámara Seguidora de Rostros con IA UNIT Electronics Blog
Área:                   Desarrollo
Autor:                  Gonzalo González
Fecha:                  21/08/2025
========================================================================================================================
Descripción:

Este código recibe datos a través del puerto serial por parte de PyCharm, para el movimiento de un servomotor, en este caso el modelo SG90 RC 9g que maneja UNIT, este se moverá dependiendo de la dirección recibida (izquierda, derecha, parar).
========================================================================================================================
Conexión de Hardware

Servomotor SG90.
 GND - Tierra Arduino.
 VIN - 5V Arduino.
 SEÑ - PIN 2 Arduino.

WEBCAM.
USB - Computador.
========================================================================================================================
Desarrollado para UNIT Electronics / Desarrollo / Blog UNIT Electronics
========================================================================================================================
*/

// Librerías Usadas
#include <SoftwareSerial.h>
#include <Servo.h>

Servo servo; // Se declara al servo.

// Se declaran las variables que se usarán
char dato;
int angulo = 90;

void setup(){
  Serial.begin(9600);
  Serial.setTimeout(10);
  servo.attach(2); // Se declara el PIN a usar
  servo.write(angulo);
}

void loop(){
  while(Serial.available()){ // Se reciben los datos del puerto serial, sependiendo de la letra recibida se mueve el servo para la detección de rostro
    dato = Serial.read();
    delay(10);
    Serial.println(dato);
    switch(dato){

      case 'd': // El servo se moverá a la derecha
      angulo = angulo + 2;
      servo.write(angulo);
      break;

      case 'i': // El servo se moverá a la izquierda
      angulo = angulo - 2;
      servo.write(angulo);
      break;

      case 'p': // El servo se detendrá ya que el rostro se encuentra centrado
      angulo = angulo;
      servo.write(angulo);
      break;
    }
  }
}

Funcionamiento

Armado de Estructura

El primer paso para hacer funcionar nuestro proyecto será armar nuestra estructura, para ello necesitaremos nuestras piezas impresas; recuerda que tenemos servicios de impresión, nosotros nos encargaremos de todos los ajustes necesarios, solo debes enviarnos los archivos STL (Base, Cámara).

El archivo con el nombre “Base” corresponde a la pieza para colocar el servomotor y nuestro Arduino, viéndose de la siguiente manera:

El servomotor tiene un sentido para colocarlo, ya que existe una ranura para el cable, este entra a presión. El segundo archivo titulado “Cámara”, es solo una base para la WebCam, esta se debe personalizar de acuerdo a la que estén manejando, sin embargo, también se encuentra adjunta en el blog; una vez colocada y atornillado todo quedará así:

Colocando nuestro Arduino y nuestra WebCam, debería quedar así:

Prueba Final

Con todo listo podemos proceder a la prueba de fuego, tendremos que hacer los siguientes pasos:

Primero deberás cargar el código de para el Arduino, para ello abrirás el IDE, y seleccionarás tu placa – puerto (memoriza en que puerto está en el paso 3 lo usarás).

Abre el código de Arduino y súbelo a la tarjeta, notarás que se pondrá el servomotor en una posición de 90°, así debes de colocar la cámara ya que será céntrica.

Abre ahora PyCharm, junto con el código que realizamos, aquí tendrás que modificar el valor del puerto serial que se encuentra en la línea 28, donde dice port, tendrás que poner entre comillas el COM que tengas asignado (paso 1)

Ilustración 19. Línea 28.

En la línea 40, tenemos declarada la WebCam, con el valor 0, que es lo ideal, sin embargo, si usas la cámara de tu laptop, debes cambiar a 1, pero esto depende mucho de tu sistema, yo te recomiendo que pruebes como lo asigna tu sistema.

Ilustración 20. Línea 40.

Por último, corre el código de PyCharm con el botón “Play”, que aparece en la parte superior del programa:

Como resultado el programa abrirá la interfaz de la WebCam viendo tu entorno, y detectando tu rostro, esto hará que el servomotor se mueva de acuerdo a la posición de tu cara, siguiéndote de forma continua.

Para cerrar el programa tendrás que teclear la letra s, ya que de esa forma se programó en la parte final del código de PyCharm.

Conclusiones

En este proyecto se demostró cómo la inteligencia artificial y la visión por computadora pueden integrarse con plataformas de desarrollo como Arduino para crear un sistema capaz de detectar y seguir rostros en tiempo real. A través del uso de librerías como OpenCV y Mediapipe, se logró procesar imágenes de manera eficiente, mientras que la comunicación serial permitió controlar un servomotor que orienta la cámara según la posición del rostro detectado.

La implementación evidenció la importancia de la correcta instalación de entornos y librerías, así como la integración entre hardware y software para obtener un resultado funcional. Este tipo de desarrollos abre la puerta a aplicaciones en robótica, seguridad, domótica y sistemas interactivos, mostrando el potencial de la IA aplicada a proyectos accesibles y prácticos.

Glosario

IA: Inteligencia Artificial.
VA: Visión Artificial.