UNIVERSIDAD AUTÓNOMA DE ZACATECAS

UNIDAD ACADÉMICA DE INGENIERÍA ELÉCTRICA

Ingeniería en Robótica y Mecatrónica

SENSORES INTELIGENTES

Alumnos:

Dalia Nohemí Escamilla García

Yehoshua Juárez Elías

Víctor Hugo Tiscareño Flores

Efrén Ordóñez Rico

“Proyecto”

Docente: M. en T.A Gilberto Jiménez Díaz

Grado: 7° Grupo: “B”

Zacatecas. A 10 de noviembre del 2022

Contenido

• Introducción. ................................................................................................ 1
• Planteamiento. ............................................................................................ 2
¿QUÉ ES DETECCIÓN FACIAL? ................................................................... 2
MÉTODOS DE RECONOCIMIENTO FACIAL ................................................. 2
Investigaciones: .............................................................................................. 3
ANTECEDENTES: .......................................................................................... 5
Los inicios del reconocimiento facial ................................................................... 5
• Objetivos del proyecto: General y específico. .............................................. 6
Objetivo general: ............................................................................................. 6
Objetivo específico: ............................................................................................ 6
• Marco teórico. .............................................................................................. 7
• Cálculos ...................................................................................................... 8
• Cronograma de Actividades ........................................................................ 9
• Organigrama ............................................................................................. 11
• Evaluación de Costos ................................................................................ 12
• Especificación de los componentes ........................................................... 13
• Metodología V ........................................................................................... 15
Diseño funcional del sistema ............................................................................ 15
• Códigos: .................................................................................................... 16
• Pruebas Unitarias. ..................................................................................... 23
• Pruebas de Componente. .......................................................................... 25
• Pruebas de Sistema. ................................................................................. 32
• Pruebas de Aceptación ............................................................................. 38
• Resultados ................................................................................................ 39
• Conclusiones ............................................................................................. 40
• Referencias ............................................................................................... 41
Introducción.

Con el avance de los años, el reconocimiento facial se ha categorizado como una

de las aplicaciones más estudiadas en áreas como la biometría, reconocimiento
de patrones y procesamiento de imágenes.

El proyecto que se presenta a continuación corresponde a la materia de Sensores

Inteligentes, el cual específicamente consiste en realizar un Sensor Inteligente,
aplicando los conocimientos que han sido proporcionados a lo largo del curso.

Para este proyecto se decidió realizar como prototipo un sistema de

reconocimiento facial, el cual será desarrollado con la ayuda de un sensor de
cámara, mismo que proporcionará la lectura de imágenes para la misma
detección.

Se desea que la cámara logre capturar el rostro de la persona a la que se le dará

acceso, todo aquello que sea capturado por la cámara será emitido en la
computadora, para lograr observar lo que sucede en la misma. Una vez capturada
la información (el rostro), se hará la comparación, si el rostro que se muestra en la
cámara es el mismo que se grabó anteriormente, la pantalla arrojará un mensaje
de bienvenida (el cual podrá ser visible en color verde), de lo contrario, la pantalla
indicará que la persona que se encuentra en la cámara es un intruso (esto será
mostrado en color rojo), para hacerlo más funcional, se desea que el sistema
pueda grabar más de un rostro, de forma que pueda reconocer a más de una
persona simultáneamente.

A nivel global se han desarrollado proyectos relacionados con sistemas de visión

por computadora, para ser utilizados en diversos lugares como, por ejemplo:
aeropuertos, terminales terrestres, centros comerciales, etc. Permitiendo asistir en
la mejora de la seguridad, brindando alertas de seguridad y no permitir el acceso a
dicho lugar[1]

1
Planteamiento.

¿QUÉ ES DETECCIÓN FACIAL?

La detección de rostros es una técnica que permite encontrar en una imagen,

el rostro o cara de una o varias personas, mientras que ignora el fondo de la
imagen u otros objetos que estén presentes dentro de ella.
El procedimiento de reconocimiento facial a través de biometría facial tan
sólo necesita de un dispositivo de reconocimiento facial (también comúnmente
llamado detector facial o lector de cara), cualquiera que disponga de tecnología
facial digital (una cámara para generar y obtener las imágenes y datos necesarios
para crear y registrar el patrón biométrico facial de la persona a identificar). La
identificación biométrica facial utiliza patrones matemáticos únicos y dinámicos de
la persona que convierten este sistema en uno de los más seguros y eficaces.
El objetivo del reconocimiento facial es, desde la imagen entrante, encontrar
una serie de datos del mismo rostro en un conjunto de imágenes de entrenamiento
en una base de datos. La gran dificultad reside en lograr que este proceso se
realice en tiempo real, algo que no está al alcance de todos los proveedores de
software de verificación de identidad.[2]

MÉTODOS DE RECONOCIMIENTO FACIAL

Existen dos métodos de reconocimiento facial que dependen de la tecnología

facial de la que se disponga para llevarlos a cabo. El primer método y, hasta hace
poco, el más extendido, es el detector facial mediante fotografía. Este método de
reconocimiento facial era el más extendido antes de que empezase a tomar
protagonismo los avances de inteligencia artificial y machine learning aplicados a
la tecnología facial.
Actualmente, el método de reconocimiento facial más seguro y fiable es la
tecnología basada en vídeo. Los sistemas de reconocimiento facial basados en
video generalmente constan de tres módulos:
• uno para detectar el rostro

2
 • uno para rastrearlo
• uno para reconocerlo
La mayoría de estos sistemas eligen un número de buenos fotogramas
en los que aplican una de las técnicas de reconocimiento facial para
identificar al individuo.
El sistema de reconocimiento biométrico facial por vídeo es actualmente
el más utilizado por empresas financieras para identificar y autenticar a sus
clientes por tres razones principales:
1. Proporciona más información, ya que aporta más frames para
elegir en cual realizar la clasificación.
2. Proporciona continuidad temporal y permite reutilizar la
información de clasificación obtenida de los frames de alta calidad para
procesar los frames de baja calidad.
3. Permite hacer un seguimiento de las caras, de los cambios de
pose y de las expresiones faciales, por lo que la información se puede
compensar.[1]

Ilustración 1: Ejemplo en el proceso de datos biométricos.

Investigaciones:

Método OpenCV
Para realizar la función de reconocimiento de rostros, primero se realiza
la detección de rostros para determinar la posición del rostro en la imagen. El
método OpenCV es un método común en la detección de rostros. En primer
lugar, extrae las imágenes de características en un gran conjunto de

3
muestras extrayendo las características de Haar del rostro en la imagen y luego
utiliza el algoritmo AdaBoost como detector de rostros. En la detección de rostros,
el algoritmo puede adaptarse de manera efectiva a entornos complejos, como
iluminación insuficiente y desenfoque de fondo, lo que mejora en gran medida la
precisión de la detección. Para un conjunto de conjuntos de entrenamiento, se
obtienen diferentes conjuntos de entrenamiento para trabajos posteriores
cambiando las probabilidades de distribución de cada una de las muestras, y cada
conjunto de entrenamiento se entrena para obtener un clasificador débil, y luego
se ponderan estos varios clasificadores.
Por ejemplo, cada muestra se distribuye con una clase de entrenamiento y se
obtiene un nuevo conjunto de entrenamiento cambiando la probabilidad de
distribución de acuerdo con la corrección de la clasificación del conjunto de
entrenamiento. Cuanto mayor sea la tasa de precisión de la clasificación, menor
será la probabilidad de distribución. El nuevo conjunto de entrenamiento se
entrena para obtener el clasificador, y se repite, y se obtienen varios
clasificadores, de modo que el peso de cada clasificador aumenta por la precisión
de la clasificación.
La figura muestra la estructura del modelo de detección de rostros. La
extracción de las características rectangulares de Haar y el clasificador fuerte
basado en AdaBoost son una parte importante de la detección de rostros. La
función de Haar se compone de varios rectángulos idénticos, que se distinguen
por la diferencia de colores en blanco y negro, y los valores de las funciones de
Haar están definidos por los valores de píxel del rectángulo. [1].

Ilustración 2: Estructura del modelo de detección de rostros humanos.

4
ANTECEDENTES:
Los inicios del reconocimiento facial
Puede considerarse a Woodrow Wilson Bledsoe como el pionero de
esta tecnología, ya que en 1960 trabajó en un sistema para clasificar los
rasgos del rostro humano a través de la tabla RAND. Este sistema utilizaba
un lápiz óptico y unas coordenadas para situar los ojos, la nariz o la boca de
las personas de forma precisa, pero era un procedimiento todavía muy
manual.
“La tabla RAND utiliza simulación electrónica de una ruleta conectada a un
ordenador. Los resultados fueron cuidadosamente filtrados y probados antes
de ser utilizados para generar la tabla. La tabla RAND fue un avance
importante en la obtención de números al azar porque una tabla tan grande y
preparada cuidadosamente nunca había estado antes disponible (la tabla
más grande publicada anteriormente era diez veces más pequeña), y
también estaba disponible en tarjetas perforadas de IBM, lo que permitió su
uso en computadoras.”

Poco a poco, el reconocimiento facial se fue haciendo un hueco en

las aplicaciones de seguridad, en particular aquellas concernientes al Estado.
En 2001, nace el Viola-Jones Object Detection Framework, que propone
algoritmos para detectar objetos dentro de imágenes, y que enseguida fue
utilizado para la detección de rostros de forma exitosa. En la década actual,
aparecen los Convolutional Neural Networks, que hasta hoy suponen el
mejor modo de detectar rostros, haciendo uso de sistemas muy potentes
capaces de almacenar información en la nube.
No es hasta 2010 cuando esta tecnología llega al gran público a través
de Facebook. Conforme el público general ha conocido esta tecnología, se
ha convertido en una cuestión controvertida, pues muchos ciudadanos y
medios de comunicación cuestionan la privacidad de sistemas de este tipo.
Intentando rebajar esta polémica, Facebook anunció en septiembre de 2019
que elimina la utilización de reconocimiento facial por defecto, permitiendo a
sus usuarios decidir si desean utilizarla o no.[3]

5
 Objetivos del proyecto: General y específico.

Objetivo general:
Desarrollar un sistema de seguridad que permita el acceso a una persona
mediante el reconocimiento facial mediante Eigenfaces, Fisherfaces, entre otros
programas.

Objetivo específico:
Desarrollar un programa para el uso correcto de un módulo y cámara para de este
modo acondicionar el dispositivo en un procesador.

Diseñar un sistema de control para la apertura de puerta.

6
Marco teórico.
Dentro de las aplicaciones de procesamiento digital de imágenes, se puede
encontrar un tipo de problemas que involucra la medición de características del
cuerpo humano, especialmente aquellas que se puedan utilizar como métodos de
identificación de personas. El reconocimiento de rostros es uno de mayor interés
en el área de biometría, debido a su aplicabilidad en cuestiones ligadas a la
seguridad o a sistemas de acceso.

Las características del rostro se estudian desde hace mucho tiempo con diversos
objetivos. Dentro del rostro de una persona se ubican un conjunto de elementos
(boca, ojos, cejas, nariz, orejas, contorno, pómulos), cuyas características pueden
ser medidas y de esta manera asociar estas mediciones a la persona.

En el área de reconocimiento de rostro uno de los problemas principales es la

determinación de la ubicación del rostro dentro de la imagen. En este proyecto
supondremos que el sistema de captura se diseña para facilitar la obtención del
rostro desde un algoritmo automático. De esta manera, es posible, a partir de una
imagen digital, aplicar un conjunto de técnicas para obtener los valores que
identifiquen a una persona perteneciente.

El conjunto de características posibles es variado, así como los algoritmos

utilizados para su obtención. En este proyecto se utilizará un subconjunto de ellas
de modo de asegurar la identificación de una persona.

A continuación, se detallan las características a considerar:

• Ojos: Determinación de distancias relativas al ojo contrario y a los demás

elementos del rostro.
• Nariz: Longitud relativa respecto de otros elementos del rostro.
• Boca: Distancia entre los extremos de abertura de los labios.
• Cejas: Distancia máxima, mínima y promedio al ojo.[4]

7
Cálculos

• Cobertura de la cámara
Campo de visión Horizontal:
Rango del objeto= 75 m 75 𝑐𝑚
= 1.25
60 𝑐𝑚
Ancho del Área =60 cm

Ilustración 3:Imagen representativa de los

ángulos de cobertura de la cámara
Campo de visión Vertical: 75 𝑐𝑚
= 1.5
Rango del objeto= 75cm 50 𝑐𝑚

Largo del Área= 50cm

• Ángulo de la visión:

𝑑
𝛼 = 2 arctan
2𝑓

d= longitud de la diagonal del sensor

66°
f= distancia focal del objetivo

Ilustración 4: representación de los ángulos de visión

8
Cronograma de Actividades

Tabla 1: Cronograma de actividades primera parte

9
Tabla 2: cronograma de actividades segunda parte

10
 Proyecto
Presentación de propuestas de Proyecto,
deliberación y eleccion de la mejor opción
Marco
Introducción Planteamiento Objetivos Planeación y Grestión
teorico

Definicion y Definición de Organización y

Identificación calendarización de de
especificaciones estructura y
Investigacion de del enfoque actividades a realizar
del mismo funcionamiento
antecedentes, que llevará el
del proyecto
herramientas y proyecto
Investigación y evaluación de
Reseña del funcionamiento
Diagramas costos de los materiales
proyecto
Propuestas y de apoyo
planteamiento
de los objetivos Justificación del
esperados funcionamiento y
cálculos

Identificación de
materiales a necesitar

Organigrama
11
Evaluación de Costos
Costo
Precio Total
ESP 32-CAM
Producto ESP 32-CAM $262
Envío Mercado Libre $99
Software a utilizar Ide de Arduino $0
Conexión y complementos Módulo de Arduino $0
Total $361
Arducam
Producto Arducam $614
Envío Amazon $76
Software a utilizar Ide de Arduino $0
Conexión y complementos Arduino Mega $470
Total $1,160
CMOS 2511C002
Producto CMOS 2511C002 $9,326
Envío Digi-Key $0
Software a utilizar Aplicación Canon $0
Conexión y complementos
Total $9,326
Pixy2
Producto Pixy2 $1636
Envío Amazon $70
Software a utilizar Ide de Arduino $0
Conexión y complementos Arduino $0
Total $1,712

12
Especificación de los componentes
En este proyecto solo se usó el módulo ESP32_CAM, así como una computadora
mediante la cual se puede correr el programa y observar el funcionamiento de la
cámara.

ESP32_CAM ESPECIFICACIONES

Paquete DIP-16

Talla 27*40.5*4.5˄±0.2˅mm

SPI Flash Default 32Mbit

RAM 520KB SRAM +4M PSRAM

Bluetooth Bluetooth 4.2 BR/EDR and BLE standards

Wi-Fi 802.11 b/g/n/

Interfaz de soporte UARTǃSPIǃI2CǃPWM

Soporte de tarjeta TF Maximo soporte 4G

Puerto I0 9

Tasa de baudios del puerto serie Default 115200 bps

formato de salida de imagen JPEG( OV2640 support

only),BMP,GRAYSCALE

Rango de espectro 2412 ~2484MHz

Antenna Antena PCB integrada, ganancia 2dBi

Potencia de Transmisión 802.11b: 17±2 dBm (@11Mbps) 802.11g:

14±2 dBm (@54Mbps) 802.11n: 13±2 dBm
(@MCS7)

Sensibilidad de resepcion CCK, 1 Mbps : -90dBm CCK, 11 Mbps: -

85dBm 6 Mbps (1/2 BPSK): -88dBm 54
Mbps (3/4 64-QAM): -70dBm MCS7 (65
Mbps, 72.2 Mbps): -67dBm

Turn off the flash lamp:180mA@5V Turn

on the flash lamp and turn on the
brightness to the maximum:310mA@5V
Disipación de poder Deep-sleep: Minimum power consumption
can be achieved 6mA@5V Moderm-sleep:

13
 Minimum up to 20mA@5V Light-sleep:
Minimum up to 6.7mA@5V

Seguridad WPA/WPA2/WPA2-Enterprise/WPS

Rango de Fuente de alimentación 5V

Temperatura de funcionamiento -20 ć ~ 85 ć

Entorno de almacenamiento -40 ć ~ 90 ć , < 90%RH

14
Metodología V
Diseño funcional del sistema

Como se mencionó en los objetivos, se espera lograr el desarrollo de un sistema

de reconocimiento facial, el cual formará parte de un sistema de seguridad.

Para esto es necesario comenzar con la parte más

importante, el cual corresponde al módulo de
reconocimiento, según lo investigado, (costos,
implementación, funcionamiento, etc.), la mejor opción fue
el ESP32-CAM.

El Ide de Arduino, es una gran opción para la

programación del módulo ya que es cuestión de agregar la
tarjeta para tener acceso a su configuración. Ilustración 5:Visualizacion de
modulo ESP32 CAM
El ESP32-CAM según lo indica su hoja de datos, gracias a
la múltiple cantidad de componentes que ya integra permite el poder llevar a cabo
lo que se propuso como objetivo.

Para la conexión del módulo, al ser bastante

pequeño y no contener el puerto USB se tenía
pensado realizar una conexión del módulo a un
adaptador FTDI, para que se lograra tener una
comunicación.

Ilustración 6: Conexión de modulos

ESP32 CAM
Otra de las opciones que se querían llevar a cabo,
fue la de realizar la conexión en una Protoboard, añadiendo un módulo de relé, e
implementando el módulo desde un celular, pero, el grado de complicación era
bastante elevado, por lo que se optó por un cambio de diseño, desde el módulo y
el adaptador, hasta la conexión del mismo.

Con respecto al software, para que logre funcionar, una parte esencial es la
conexión a la red, por lo que habrá que realizar los cambios pertinentes en la parte
de la codificación.

15
El programa de cierta forma es bastante intuitivo, lo que permitirá el realizar los
cambios necesarios para la mejora en la detección del rostro, así como también el
lograr inscribir las caras que sean necesarias, para que logre el reconocer cuando
haya algún un intruso.

Códigos:
El siguiente código en su mayoría fue tomado de previos documentos
antecedentes relacionados tanto con el esp32 como con su modulo CAM,
realizado de esta forma para implementar por nuestra parte el acondicionamiento
para la detección de rostros y el reconocimiento facial respectivo a nuestro
principal objetivo.

Este el código principal refiriéndonos a la inicialización de nuestro modulo cam:

__________________________________________________________________
______________

#include "esp_camera.h"
//Añadimos la librería Wifi para crear he inicializar la interfaz de la cámara de tal forma que
nos direccione hacia
//una página de internet y poder interactuar con nuestro elemento físico.
#include <WiFi.h>
// usamos el siguiente elemento ya que contamos con el módulo ESP-31 CAM de manera
física.
#define CAMERA_MODEL_AI_THINKER // Has PSRAM

#include "camera_pins.h"

const char* ssid = "HOME-4BF1"; // Nombre de la red internet Wi-Fi

const char* password = "A27D8F38EF1B27F2"; // Contraseña

void startCameraServer();

void setup() {
Serial.begin(115200);
Serial.setDebugOutput(true);
Serial.println();

camera_config_t config;
config.ledc_channel = LEDC_CHANNEL_0;
config.ledc_timer = LEDC_TIMER_0;
config.pin_d0 = Y2_GPIO_NUM;

16
 config.pin_d1 = Y3_GPIO_NUM;
config.pin_d2 = Y4_GPIO_NUM;
config.pin_d3 = Y5_GPIO_NUM;
config.pin_d4 = Y6_GPIO_NUM;
config.pin_d5 = Y7_GPIO_NUM;
config.pin_d6 = Y8_GPIO_NUM;
config.pin_d7 = Y9_GPIO_NUM;
config.pin_xclk = XCLK_GPIO_NUM;
config.pin_pclk = PCLK_GPIO_NUM;
config.pin_vsync = VSYNC_GPIO_NUM;
config.pin_href = HREF_GPIO_NUM;
config.pin_sscb_sda = SIOD_GPIO_NUM;
config.pin_sscb_scl = SIOC_GPIO_NUM;
config.pin_pwdn = PWDN_GPIO_NUM;
config.pin_reset = RESET_GPIO_NUM;
config.xclk_freq_hz = 20000000;
config.pixel_format = PIXFORMAT_JPEG;

// Si el elemento PSRAM IC se encuentra presente, inicio con resolución UXGA y mayor

calidad JPEG de imagen
//para un búfer de trama preasignado más grande.
if(psramFound()){
config.frame_size = FRAMESIZE_UXGA;
config.jpeg_quality = 10;
config.fb_count = 2;
} else {
config.frame_size = FRAMESIZE_SVGA;
config.jpeg_quality = 12;
config.fb_count = 1;
}

#if defined(CAMERA_MODEL_ESP_EYE)
pinMode(13, INPUT_PULLUP);
pinMode(14, INPUT_PULLUP);
#endif

// Encendido de la cámara
esp_err_t err = esp_camera_init(&config);
if (err != ESP_OK) {
Serial.printf("Cámara con error en la entrada:0x%x", err);
return;
}

sensor_t * s = esp_camera_sensor_get();
// Los sensores iniciales se voltean verticalmente y saturamos un poco los colores

17
 if (s->id.PID == OV3660_PID) {
s->set_vflip(s, 1); // Voltearlo hacia atrás
s->set_brightness(s, 1); // subimos un poco el brillo
s->set_saturation(s, -2); // bajamos la saturación
}
// Tamaño de fotograma desplegado para obtener mayor velocidad de fotogramas inicial
s->set_framesize(s, FRAMESIZE_QVGA);

#if defined(CAMERA_MODEL_M5STACK_WIDE) ||
defined(CAMERA_MODEL_M5STACK_ESP32CAM)
s->set_vflip(s, 1);
s->set_hmirror(s, 1);
#endif

WiFi.begin(ssid, password);

while (WiFi.status() != WL_CONNECTED) {

delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi conectado");

startCameraServer();

Serial.print("La cámara esta lista para usarse! Use 'http://");

Serial.print(WiFi.localIP());
Serial.println("' para conectarse y usar.”);
}

void loop() {

delay(10000);
}

El siguiente es un documento tomado de Apache software que implementa tanto detección

de rostro como reconocimiento facial, en este código se acondiciono un apartado del
desarrollo previamente disponible e igualmente se personalizo la interfaz creada para
nuestro uso específico. Por su extensión solo se adjuntan las partes acondicionadas.
(Código que va de la línea 225 hasta 284)

size_t out_len, out_width, out_height;

uint8_t * out_buf;

18
bool s;
bool detected = false;
int face_id = 0;
if(!detection_enabled || fb->width > 400){
size_t fb_len = 0;
if(fb->format == PIXFORMAT_JPEG){
fb_len = fb->len;
res = httpd_resp_send(req, (const char *)fb->buf, fb->len);
} else {
jpg_chunking_t jchunk = {req, 0};
res = frame2jpg_cb(fb, 80, jpg_encode_stream, &jchunk)?ESP_OK:ESP_FAIL;
httpd_resp_send_chunk(req, NULL, 0);
fb_len = jchunk.len;
}
esp_camera_fb_return(fb);
int64_t fr_end = esp_timer_get_time();
Serial.printf("JPG: %uB %ums\n", (uint32_t)(fb_len), (uint32_t)((fr_end - fr_start)/1000));
return res;
}

dl_matrix3du_t *image_matrix = dl_matrix3du_alloc(1, fb->width, fb->height, 3);

if (!image_matrix) {
esp_camera_fb_return(fb);
Serial.println("dl_matrix3du_alloc failed");
httpd_resp_send_500(req);
return ESP_FAIL;
}

out_buf = image_matrix->item;
out_len = fb->width * fb->height * 3;
out_width = fb->width;
out_height = fb->height;

s = fmt2rgb888(fb->buf, fb->len, fb->format, out_buf);

esp_camera_fb_return(fb);
if(!s){
dl_matrix3du_free(image_matrix);
Serial.println("to rgb888 failed");
httpd_resp_send_500(req);
return ESP_FAIL;
}

box_array_t *net_boxes = face_detect(image_matrix, &mtmn_config);

if (net_boxes){

19
 detected = true;
if(recognition_enabled){
face_id = run_face_recognition(image_matrix, net_boxes);
}
draw_face_boxes(image_matrix, net_boxes, face_id);

/////////////////////////////////////////////////////////
dl_lib_free(net_boxes->score);
dl_lib_free(net_boxes->box);
dl_lib_free(net_boxes->landmark);
dl_lib_free(net_boxes);
////////////////////////////////////////////////////////
}…
…
(Código que va de la línea 339 hasta 284)

if(!detection_enabled || fb->width > 400){

if(fb->format != PIXFORMAT_JPEG){
bool jpeg_converted = frame2jpg(fb, 80, &_jpg_buf, &_jpg_buf_len);
esp_camera_fb_return(fb);
fb = NULL;
if(!jpeg_converted){
Serial.println("JPEG compression failed");
res = ESP_FAIL;
}
} else {
_jpg_buf_len = fb->len;
_jpg_buf = fb->buf;
}
} else {

image_matrix = dl_matrix3du_alloc(1, fb->width, fb->height, 3);

if (!image_matrix) {
Serial.println("dl_matrix3du_alloc failed");
res = ESP_FAIL;
} else {
if(!fmt2rgb888(fb->buf, fb->len, fb->format, image_matrix->item)){
Serial.println("fmt2rgb888 failed");
res = ESP_FAIL;
} else {
fr_ready = esp_timer_get_time();
box_array_t *net_boxes = NULL;
if(detection_enabled){
net_boxes = face_detect(image_matrix, &mtmn_config);

20
 }
fr_face = esp_timer_get_time();
fr_recognize = fr_face;
if (net_boxes || fb->format != PIXFORMAT_JPEG){
if(net_boxes){
detected = true;
if(recognition_enabled){
face_id = run_face_recognition(image_matrix, net_boxes);
}
fr_recognize = esp_timer_get_time();
draw_face_boxes(image_matrix, net_boxes, face_id);
//////////////////////////////////////////////////////////////////////////

dl_lib_free(net_boxes->score);
dl_lib_free(net_boxes->box);
dl_lib_free(net_boxes->landmark);
dl_lib_free(net_boxes);
////////////////////////////////////////////////////////////////////////
}

También se tiene un código de identificación de la cámara el cuál en general tiene la función

de encontrar y darnos la dirección a nuestro modulo CAM, por su extensión también solo se
agregan algunas líneas de el.

//File: index_ov2640.html.gz, Size: 4316

#define index_ov2640_html_gz_len 4316
const uint8_t index_ov2640_html_gz[] = {
0x1F, 0x8B, 0x08, 0x08, 0x50, 0x5C, 0xAE, 0x5C, 0x00, 0x03, 0x69, 0x6E, 0x64, 0x65, 0x78,
0x5F,
0x6F, 0x76, 0x32, 0x36, 0x34, 0x30, 0x2E, 0x68, 0x74, 0x6D, 0x6C, 0x00, 0xE5, 0x5D, 0x7B,
0x73,
0xD3, 0xC6, 0x16, 0xFF, 0x9F, 0x4F, 0x21, 0x04, 0x25, 0xF6, 0x34, 0x76, 0x6C, 0xC7, 0x84,
0xE0,
0xDA, 0xE2, 0x42, 0x08, 0xD0, 0x19, 0x5E, 0x25, 0x2D, 0x74, 0xA6, 0xD3, 0x81, 0xB5, 0xB4,
0xB2,
0x55, 0x64, 0xC9, 0x95, 0x56, 0x76, 0x52, 0x26, 0x9F, 0xE3, 0x7E, 0xA0, 0xFB, 0xC5, 0xEE,
0xD9,
0x87, 0xA4, 0x95, 0xBC, 0x7A, 0xD8, 0x26, 0x36, 0x97, 0xEB, 0xCC, 0x14, 0xD9, 0xDA, 0x73,
0xF6,
0x9C, 0xF3, 0x3B, 0xAF, 0x5D, 0x3D, 0x3A, 0xBC, 0x6D, 0xF9, 0x26, 0xB9, 0x9A, 0x63, 0x6D,
0x4A,
0x66, 0xAE, 0x71, 0x6B, 0xC8, 0xFF, 0xD1, 0xE0, 0x33, 0x9C, 0x62, 0x64, 0xF1, 0x43, 0xF6,
0x75,

21
0x86, 0x09, 0xD2, 0xCC, 0x29, 0x0A, 0x42, 0x4C, 0x46, 0x7A, 0x44, 0xEC, 0xD6, 0xA9, 0x9E,
0x3F,
0xED, 0xA1, 0x19, 0x1E, 0xE9, 0x0B, 0x07, 0x2F, 0xE7, 0x7E, 0x40, 0x74, 0xCD, 0xF4, 0x3D,
0x82,
0x3D, 0x18, 0xBE, 0x74, 0x2C, 0x32, 0x1D, 0x59, 0x78, 0xE1, 0x98, 0xB8, 0xC5, 0xBE, 0x1C,
0x3A,
0x9E, 0x43, 0x1C, 0xE4, 0xB6, 0x42, 0x13, 0xB9, 0x78, 0xD4, 0x95, 0x79, 0x11, 0x87, 0xB8,
0xD8,
0x38, 0xBF, 0x78, 0x7B, 0xDC, 0xD3, 0xDE, 0xBC, 0xEF, 0xF5, 0x4F, 0x3A, 0xC3, 0x23, 0xFE,
0x5B,
0x3A, 0x26, 0x24, 0x57, 0xF2, 0x77, 0xFA, 0x19, 0xFB, 0xD6, 0x95, 0xF6, 0x25, 0xF3, 0x13,
0xFD, …

Por último, se muestra el desarrollo del elemento de conexión a los pines que se añadió en
el código principal (elemento define CAMERA_MODEL_AI_THINKER)

#if defined(CAMERA_MODEL_AI_THINKER)
#define PWDN_GPIO_NUM 32
#define RESET_GPIO_NUM -1
#define XCLK_GPIO_NUM 0
#define SIOD_GPIO_NUM 26
#define SIOC_GPIO_NUM 27

#define Y9_GPIO_NUM 35
#define Y8_GPIO_NUM 34
#define Y7_GPIO_NUM 39
#define Y6_GPIO_NUM 36
#define Y5_GPIO_NUM 21
#define Y4_GPIO_NUM 19
#define Y3_GPIO_NUM 18
#define Y2_GPIO_NUM 5
#define VSYNC_GPIO_NUM 25
#define HREF_GPIO_NUM 23
#define PCLK_GPIO_NUM 22

#else
#error "Modelo de cámara no seleccionado"
#endif[5]

22
Pruebas Unitarias.
Las pruebas realizadas en el ide de Arduino fueron de la obtención de la dirección
IP y la comunicación al módulo CAM.

El primer error que tuvimos fue en la conexión del módulo y el puerto USB, el cual
se corrigió seleccionando la placa de programación como el puerto donde se
conectó nuestro dispositivo.

23
Subido el código ahora testeamos el módulo hasta que se obtuvieran los datos
pertinentes:

En primera instancia en el monitor serial no se obtuvo respuesta, como si no se

hubiera subido el programa de identificación y direccionamiento, pero esto se debe
a que hay que reiniciar el módulo haciendo uso de su push button para que ahora
si se genere información.

En varios intentos se obtenía la información cifrada o más bien no se leía

correctamente en el monitor serial esto porque el número de baudios seleccionado
era el incorrecto y la velocidad de adquisición de los símbolos de la información
digital no se procesaba correctamente. Después de los puntos suspensivos
notamos que ahora si se obtienen los datos y son legibles, llegando así a
corroborar que la compilación del programa es el esperado.

24
Pruebas de Componente.
En este apartado lo que realizamos fue configurar y probar el módulo:

Instalación del complemento ESP32 en el IDE de Arduino

Para instalar la placa ESP32 en su IDE Arduino, siga estas siguientes

instrucciones:

1. En el IDE Arduino, abrimos Archivo>Preferencias

2. Ingresamos lo siguiente en el campo "URL adicionales del gerente de la

junta":
1. https://raw.githubusercontent.com/espressif/arduino-esp32/gh-
pages/package_esp32_index.json

25
3. Abrimos el Administrador de tableros e ingresamos en
Herramientas>Board>Boards Manager...

26
4. Buscamos ESP32 y damos a la instalación para el "ESP32 de
Espressif Systems":

27
Prueba de la instalación

Conectada la placa ESP32 al equipo:

1. Seleccionamos la placa en el menú Herramientas> Tablero (en este caso es el

DOIT ESP32 DEVKIT V1)

28
2. Seleccionamos el puerto (como no se reconocía el esp32 tuvimos que instalar
los controladores CP210x USB a UART Bridge VCP):

29
3. Abrimos el siguiente ejemplo en Archivo>Ejemplos>WiFi (ESP32)>WiFiScan

4. Se abre el código en el IDE de Arduino:

30
 5. Presionamos el botón Cargar en el IDE de Arduino. Después de unos
segundos el código se compila y se carga en la placa.

6. Al terminar la compilación si es correcta obtuvimos “Terminado de cargar".

31
7. Abrimos el Arduino IDE monitor serial a una velocidad en baudios de 115200:

8. Tras pulsar el botón del ESP32 integrado vimos las redes disponibles cerca del
módulo:

Con esto terminamos las pruebas en el componente y pasamos a las pruebas del
sistema.

Pruebas de Sistema.
En este apartado se realizó la prueba funcional del sistema desarrollado:

32
Primero se ingreso la IP obtenida y corroboramos que se nos direccione a la
interfaz desarrollada.

Corroboramos que se realice la transmisión de video.

(La siguiente captura son respectivamente de algunos elementos integrados en la

interfaz para ver su funcionamiento.)

33
Como observamos en la barra menú izq. se han activado y cambiado parámetros
con respecto a la captura anterior comprobando que estos nuevos parámetros se
vean reflejados y en general asi fue.

Ahora testeamos primeramente la detección de rostros:

Como vemos no se obtuvo como se esperaba la detección de rostro, más sin

embargo este problema más adelante se solucióno.

34
Aquí testeamos el reconocimiento facial y en primera instancia al no tener el rostro
reconocido se nos mostro una leyenda de Intruder Alert!

Al guardar el rostro ahora la interfaz recoce a la persona y guarda el rostro, por lo

que se tiene una recopilación de la información en una base de datos.

Ahora vemos que si otra persona aparece ante la cámara esta no la reconoce y
comprobamos asi que el reconocimiento facial no sufre inconvenientes para
detectar a las personas.

En las siguientes capturas se muestra la personalización de algunos elementos de

la interfaz.
35
(activar la localización facial).

36
Como vemos en esta captura se está generando la identificación facial de un
usuario para que así sea reconocida y no se nos muestre la leyenda de alerta.

37
Por último, de nuevo se muestra la leyenda de bienvenida hola usuario más la
identificación (en este caso 0 pues es el primer rostro cargado).

Pruebas de Aceptación

Con respecto a los resultados obtenidos tomando en cuenta que los objetivos
fueron cumplidos y el módulo funcionó de la manera que se esperaba, se tiene la
idea de que un sistema de seguridad inteligente es bastante útil en la actualidad,
ya que con él tiempo todo se está desarrollando de sobremanera, lo que da paso
al desarrollo de nuevos sistemas inteligentes. Este sistema en particular es
bastante funcional ya que es posible grabar cualquier rostro que se desee, de
igual forma es bastante acertado en cuestión de detectar un rostro que no ha sido
grabado, básicamente un intruso, ya que en el tiempo que se puso a prueba en
ninguna ocasión erro en la detección.

A pesar de los buenos resultados que se obtuvieron del sistema, se tiene un

problema de gran importancia, el cual es qué la imagen en la computadora en la
parte de detección de rostros y reconocimiento facial está bastante trabada, se
cree que este es un problema algo grave ya que se puede tomar como ventaja
para dañar o hacer que el sistema falle, se deduce que el problema es provocado
hasta cierto punto por a la calidad del producto, ya que como se sabe cuenta con
algunas funciones algo limitadas, (como la resolución la cual es de tan solo de
2MGp), se cree que si fuera algún producto de más calidad podría ser que todo
funcionará de forma ideal, el problema que se encuentra en este tipo de productos
es que los costos son bastante elevados y la instalación o configuración algo
compleja, por lo que se cree qué no sería una de las mejores propuestas para la
introducción de este tipo de sistemas al mercado.

De igual manera se tomaron diferentes opiniones en cuenta, ya que, para ser un

producto bastante económico, tiene mucho que ofrecer, de no ser por el
inconveniente antes mencionado. El sistema en general sería una de las mejores
opciones del mercado. También es importante tener en cuenta, que la calidad que
se quiere obtener, en la mayoría de los casos es proporcional al costo que se está
dispuesto a pagar.

38
Resultados
Los resultados no fueron los más óptimos, esto debido a que el sensor que fue
requerido en la práctica fue de bajo costo, esto para ahorrar presupuesto ya que
los demás sensores que proporcionaban servicios parecidos excedían el valor de
nuestro presupuesto, por lo tanto, existían algunos fallos con respecto a la
conexión de internet y en la transmisión había perdidas de señal por lo tanto se
dificultaba la selección del reconocimiento fácil y no se obtenía un vídeo de
manera fluida. Al momento de no contar con la luz suficiente la cámara
comenzaba a mostrar todos estos pequeños defectos, esto debido a la poca
resolución que esta misma nos proporcionaba.

39
Conclusiones
Se concluyó este proyecto cuando realizamos la implementación esperada del
módulo esp32, aplicando el desarrollo de una interfase para el reconocimiento y
detección fácil de rostros básico en el que por medio de la cámara se detectaba
primeramente el rostro de una persona, pero si el rostro no es reconocido nos
muestra” Intruder Alert”. El reconocimiento es capaz de señalar cuando una
persona no es reconocida para determinar la identidad de un sujeto de entre una
base de rostros conocidos, y cuando el rostro es reconocido nos va mostrar una
bienvenida “Hola usuario (0)” de color verde, pero esto depende de los usuarios
que hemos registrado en el sistema de reconocimiento facial, no se nos olvide que
debemos guardar los datos biométricos del usuario para que posteriormente se
detectará automáticamente.

El sistema mostro ser fallido a trabajar con imágenes de rostros sin control de
iluminación, lo cual es una situación normal porque es un módulo de poco valor y
con solo 2 Megapíxeles de resolución de imagen.

40
 Referencias
[1] Electronic Identification, “¿Cómo funciona el reconocimiento facial?
Tecnología facial”, jul. 28, 2022.
https://www.electronicid.eu/es/blog/post/como-funciona-reconocimiento-
facial/es (consultado nov. 21, 2022).

[2] GABRIELA SOLANO, “DETECCIÓN DE ROSTROS ? con Haar Cascades

Python – OpenCV”, ene. 21, 2021. https://omes-va.com/deteccion-de-
rostros-con-haar-cascades-python-opencv/ (consultado nov. 21, 2022).

[3] Equipo BeeDIGITAL, “Historia y evolución del reconocimiento facial”, oct. 29,
2019. https://www.beedigital.es/tendencias-digitales/historia-y-evolucion-del-
reconocimiento-facial/#:~:text=para%20las%20empresas.-
,Los%20inicios%20del%20reconocimiento%20facial,través%20de%20la%20
tabla%20RAND. (consultado nov. 21, 2022).

[4] M. Teórico, “Proyecto 1”.

[5] PilnyTomas, “espressif / arduino-esp32”, dic. 19, 2018.

https://github.com/espressif/arduino-
esp32/blob/master/libraries/ESP32/examples/Camera/CameraWebServer/ap
p_httpd.cpp (consultado nov. 21, 2022).

41