UNIVERSIDAD AUTÓNOMA DE NUEVO LEÓN

Facultad de Ingeniería Mecánica y Eléctrica

PRACTICA #4:

ASIGNATURA: Laboratorio de Percepción

TUTOR: SUSANA VIRIDIANA GUTIERREZ MARTINEZ

ALUMNO: Omar Leopoldo Rodriguez Hernández

MATRÍCULA: 1832141

MONTERREY NUEVO LEÓN, 03 DE MAYO DEL 2022

Índice
Instrucciones ..................................................................................................................................... 3
Tabla de datos .................................................................................................................................. 3
Arquitectura de la red neuronal utilizada y parámetros de entrenamiento .............................. 6
Arquitectura ................................................................................................................................... 6
Datos de entrenamiento ............................................................................................................ 11
Componentes utilizados ................................................................................................................ 15
Circuito armado............................................................................................................................... 16
Resultado del entrenamiento (graficas de error) ....................................................................... 17
Casos con respuestas altas y bajas ............................................................................................ 18
1ra condición (alta) ..................................................................................................................... 18
2da condición (baja) ................................................................................................................... 19
Código fuente en Arduino IDE para ESP32 ............................................................................... 20
Link para video de funcionamiento .............................................................................................. 33
 Instrucciones
Usar al menos tres sensores; por ejemplo, de temperatura, humedad, calidad del
aire, iluminación, pulso cardiaco, temperatura corporal, oxigenación, etc.
Salida es un semáforo de 5 leds, un buzzer y un servomotor
Codificar red neuronal entrenada.
Utilizar código de Python (en carpeta de material de clase) para entrenar la red
neuronal considerando la tabla de datos y la respuesta propuesta.
Implementar el algoritmo de la red neuronal en el ESP32 por medio de la plataforma
de Arduino IDE.

Tabla de datos

Temperatura (°C) Luz (%) Distancia (cm) Condición para vacunación contra Covid
37 96 280 4
1 46 50 1
39 15 210 2
14 14 200 3
27 97 160 5
24 78 80 3
-9 5 270 2
-7 39 20 1
35 45 450 3
39 35 70 2
14 35 330 4
38 98 240 5
-8 11 230 2
46 80 20 1
43 50 130 1
-9 89 260 3
46 83 220 3
37 37 390 2
12 100 240 5
38 37 0 1
37 83 30 2
-3 17 60 1
20 82 120 4
34 35 130 3
29 54 190 4
 33 82 320 5
6 81 450 4
33 85 230 4
36 63 120 3
-1 98 390 3
26 44 320 3
-1 94 80 2
2 72 90 2
-8 84 40 2
-7 48 110 1
34 25 360 3
-7 36 160 2
13 51 100 3
2 63 140 4
26 62 80 4
50 56 110 2
-3 26 0 1
-10 8 380 1
13 59 120 3
42 73 90 2
-9 95 150 4
6 24 280 2
23 79 40 3
2 55 230 3
42 39 10 1
-5 99 300 3
19 97 430 5
49 64 430 2
22 80 10 2
-8 72 260 4
45 90 50 2
-8 83 250 4
35 33 370 2
30 41 220 3
27 1 220 3
46 57 20 2
-5 82 410 4
42 18 30 1
22 7 200 3
8 41 270 3
22 34 110 2
-5 97 440 4
31 84 110 4
29 52 80 3
20 31 400 3
49 13 80 1
3 90 100 3
27 29 420 3
5 14 220 2
21 90 410 5
17 27 450 3
42 42 30 2
-9 75 260 2
14 87 90 3
5 2 100 1
38 85 60 3
21 2 330 3
43 78 180 4
11 90 170 5
25 7 410 3
14 85 90 4
25 76 320 5
44 75 0 1
-7 87 10 1
-9 89 90 2
27 15 10 1
13 12 10 1
22 95 250 5
32 60 110 4
3 14 330 2
44 23 180 2
30 4 30 1
25 55 410 5
13 6 60 1
-3 98 10 2
 Arquitectura de la red neuronal utilizada y parámetros de
entrenamiento

Arquitectura
Datos de entrenamiento
Pesos

o= {-3.515552399752711,

-9.522862930667985,

-15.463516632968291,

0.9814077387658282,

-6.81912397321553,

8.09297180978903,

1.722585442091482};

m= {{-0.5730995520693748,

-3.1654220795065386,

-1.7075956896551787,

2.2197258487308678},

{14.740422252062558,

-8.288258044454496,

-2.7001326835853576,

-8.213349161992717},

{-8.925932378903589,

-11.30949618792544,

-15.477690781583822,

11.98711813530532},

{-3.3233904649274626,

-1.2657227343123119,

-2.043213774233675,

-1.2150898998219775},

{-10.49693645073214,

4.742488514398998,

0.690299388127907,

-4.904156132986425},
{-7.160306565258374,

-12.88036971120068,

-8.532787470117055,

12.31215555862011},

{1.0519543845662855,

0.8960074111511478,

0.49406694638849546,

-1.271220742437876}};
 Componentes utilizados

Componente Imagen
Sensor ultrasónico

LM35 sensor de humedad

LDR sensor de luz

Servomotor

Led RGB

Buzzer

ESP32

Protoborad
Resistencias

Circuito armado
Resultado del entrenamiento (graficas de error)
 Casos con respuestas altas y bajas

1ra condición (alta)

Simulación de condiciones para vacuna contra el COVID-19

Nos marca una condición muy buena, ya que la persona está a 2.14m, la iluminación
es de 63% y la temperatura es de 15 grados. El LED verde indica esta condición.
2da condición (baja)

Ahora vemos que las personas están a 27cm de distancia unas con otras, la
iluminación es de 37% y hay 16 grados, esta condición es muy mala para esperar
la vacuna. El LED pasó de verde a rojo, el servo paso de 0° a 180° y el buzzer
comenzó a emitir ruido.
 Código fuente en Arduino IDE para ESP32

// Cargar biblioteca de Wi-Fi

#include <WiFi.h>

// Reemplace con sus credenciales de red

//const char* ssid = "***";
//const char* password = "**";

const char* ssid = "M4_B3";

const char* password = "8d71088d8055";

//Servo libreria
#include <Servo.h>

// Establecer el número de puerto del servidor web en 80

WiFiServer server(80);
Servo myservo;

// Variable para almacenar la solicitud HTTP

String header;

//Variables auxiliares para almacenar el estado de salida actual

String output33State = "off";
const int output33 = 33;
String output25State = "off";
const int output25 = 25;
String output26State = "off";
const int output26 = 26;
String output27State = "off";
const int output27 = 27;

const int pin34 = A6;

const int pin32 = A4;

//Luz sensor
float weird;
int porcentaje = 0;
//temp sensor
int RawValue= 0;
float Voltage = 0;
float tempC = 0;

const int Trigger = 18; //Pin digital 2 para el Trigger del sensor
const int Echo = 19; //Pin digital 3 para el Echo del sensor

String output13State = "off";

String LECTURA1;
String LECTURA2;
String LECTURA3;
String LECTURA4;
//Pesos
float o[7]= {-3.515552399752711,
-9.522862930667985,
-15.463516632968291,
0.9814077387658282,
-6.81912397321553,
8.09297180978903,
1.722585442091482};

float m[7][4]= {{-0.5730995520693748,

-3.1654220795065386,
-1.7075956896551787,
2.2197258487308678},
{14.740422252062558,
-8.288258044454496,
-2.7001326835853576,
-8.213349161992717},
{-8.925932378903589,
-11.30949618792544,
-15.477690781583822,
11.98711813530532},
{-3.3233904649274626,
-1.2657227343123119,
-2.043213774233675,
-1.2150898998219775},
{-10.49693645073214,
 4.742488514398998,
0.690299388127907,
-4.904156132986425},
{-7.160306565258374,
-12.88036971120068,
-8.532787470117055,
12.31215555862011},
{1.0519543845662855,
0.8960074111511478,
0.49406694638849546,
-1.271220742437876}};

float Range[4][2]= {{-10, 50},

{1, 100},
{0.002906665171225453, 4.483522893541733},
{1, 5}};

float x[4]= {0, 0, 0, 1};

float SENSOR1 = 0;
float SENSOR2 = 0;
float SENSOR3 = 0;

float N[7]= {0, 0, 0, 0, 0, 0, 0};

float YN = 0;
void setup() {
Serial.begin(115200);
delay(1000);
myservo.attach(13);
// Inicializar las variables de salida como salidas
pinMode(output33, OUTPUT);
digitalWrite(output33, LOW);

pinMode(output25, OUTPUT);
digitalWrite(output25, LOW);
pinMode(output26, OUTPUT);
digitalWrite(output26, LOW);
pinMode(output27, OUTPUT);
digitalWrite(output27, LOW);

pinMode(Trigger, OUTPUT); //pin como salida

pinMode(Echo, INPUT); //pin como entrada
digitalWrite(Trigger, LOW);//Inicializamos el pin con 0
myservo.write(0);

// Conéctese a la red Wi-Fi con SSID y contraseña

Serial.print("Connecting to ");
Serial.println(ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
 Serial.print(".");
}
// Imprima la dirección IP local e inicie el servidor web
Serial.println("");
Serial.println("WiFi connected.");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
server.begin();
}

void loop(){
//Luz //Sonido
weird = analogRead(pin34);
RawValue = analogRead(pin32);
porcentaje = weird/40.95;
Voltage = (RawValue / 2048.0) * 3300; // 5000 to get millivots.
tempC = Voltage * 0.1;
Serial.println(porcentaje);
Serial.println(tempC);
LECTURA1= String(tempC);
SENSOR1= tempC;
LECTURA2= String(porcentaje);
SENSOR2= porcentaje;

//Sensor ultrasónico
long t; //timepo que demora en llegar el eco
long d; //distancia en centimetros
 digitalWrite(Trigger, HIGH);
delayMicroseconds(10); //Enviamos un pulso de 10us
digitalWrite(Trigger, LOW);

t = pulseIn(Echo, HIGH); //obtenemos el ancho del pulso

d = t/59; //escalamos el tiempo a una distancia en cm

Serial.print("Distancia: ");
Serial.print(d); //Enviamos serialmente el valor de la distancia
Serial.print("cm");
LECTURA3= String(d);
SENSOR3= d;

WiFiClient client = server.available(); // Escuche a los clientes entrantes

if (client) { // Si un nuevo cliente se conecta,
Serial.println("New Client."); // imprimir un mensaje en el puerto serie
String currentLine = ""; // hacer una cadena para contener los datos entrantes
del cliente
while (client.connected()) { // Bucle mientras el cliente está conectado
if (client.available()) { // Si hay bytes para leer del cliente,
char c = client.read(); // leer un byte, luego
Serial.write(c); // imprímalo en el monitor de serie
header += c;
if (c == '\n') { // si el byte es un carácter de nueva línea
// si la línea actual está en blanco, tiene dos caracteres de nueva línea seguidos.
// ese es el final de la solicitud HTTP del cliente, así que envíe una respuesta:
if (currentLine.length() == 0) {
 // Los encabezados HTTP siempre comienzan con un código de respuesta (por
ejemplo, HTTP / 1.1 200 OK)
// y un tipo de contenido para que el cliente sepa lo que viene, luego una línea en
blanco:
client.println("HTTP/1.1 200 OK");
client.println("Content-type:text/html");
client.println("Connection: close");
client.println();

x[0] = SENSOR1;
x[1] = SENSOR2;
x[2] = SENSOR3;

//Normalizar los sensores

x[0] = normalizar(x[0], Range[0][0], Range[0][1]);
x[1] = normalizar(x[1], Range[1][0], Range[1][1]);
x[2] = normalizar(x[2], Range[2][0], Range[2][1]);

//Ecuaciones de red
N[0] = fa(x[0] * m[0][0] + x[1] * m[0][1] + x[2] * m[0][2] + x[3] * m[0][3]);
N[1] = fa(x[0] * m[1][0] + x[1] * m[1][1] + x[2] * m[1][2] + x[3] * m[1][3]);
N[2] = fa(x[0] * m[2][0] + x[1] * m[2][1] + x[2] * m[2][2] + x[3] * m[2][3]);
N[3] = fa(x[0] * m[3][0] + x[1] * m[3][1] + x[2] * m[3][2] + x[3] * m[3][3]);
N[4] = fa(x[0] * m[4][0] + x[1] * m[4][1] + x[2] * m[4][2] + x[3] * m[4][3]);
N[5] = fa(x[0] * m[5][0] + x[1] * m[5][1] + x[2] * m[5][2] + x[3] * m[5][3]);
N[6] = fa(x[0] * m[6][0] + x[1] * m[6][1] + x[2] * m[6][2] + x[3] * m[6][3]);
//Ecuacion de salida
YN = fa(N[0] * o[0] + N[1] * o[1] + N[2] * o[2] + N[3] * o[3] + N[4] * o[4] + N[5] * o[5] + N[6]
* o[6]);
YN = desnormalizar(YN, Range[0][5], Range[4][0]);
LECTURA4 = String(YN);

//Adaptar los actuadores a la salida

if (YN >= 0 && YN <= 1) {
//MUY MALA
digitalWrite(output25, HIGH);
digitalWrite(output26, LOW);
digitalWrite(output27, LOW);
digitalWrite(output33, HIGH); ///ENCENDER BUZZER
myservo.write(180);
}

else {
if (YN > 1 && YN <= 2) {
//MALA
digitalWrite(output25, HIGH);
digitalWrite(output26, LOW);
digitalWrite(output27, HIGH);
digitalWrite(output33, LOW); ///ENCENDER BUZZER
myservo.write(180);
}

else {
if (YN > 2 && YN <= 3) {
//REGULAR
digitalWrite(output25, LOW);
digitalWrite(output26, HIGH);
digitalWrite(output27, HIGH);
digitalWrite(output33, LOW); ///ENCENDER BUZZER
myservo.write(90);
}

else {
if (YN > 3 && YN <= 4) {
//BUENA
digitalWrite(output25, LOW);
digitalWrite(output26, LOW);
digitalWrite(output27, HIGH);
digitalWrite(output33, LOW); ///ENCENDER BUZZER
myservo.write(0);
}

else {
if (YN > 4 && YN <= 5) {
///MUY BUENA
digitalWrite(output25, LOW);
digitalWrite(output26, HIGH);
digitalWrite(output27, LOW);
digitalWrite(output33, LOW); ///ENCENDER BUZZER
myservo.write(0);
}
else {
digitalWrite(output25, LOW);
digitalWrite(output26, LOW);
digitalWrite(output27, LOW);
digitalWrite(output33, LOW); ///ENCENDER BUZZER
myservo.write(0);
}
}
}
}
}

// Mostrar la página web HTML

client.println("<!DOCTYPE html><html>");
client.println("<head><meta name=\"viewport\" content=\"width=device-width,
initial-scale=1\">");
client.println("<link rel=\"icon\" href=\"data:,\">");

client.println("<style>html { font-family: Helvetica; display: inline-block; margin: 0px

auto; text-align: center;}");
client.println(".button { background-color: #4CAF50; border: none; color: white;
padding: 1px 25px;");
client.println("text-decoration: none; font-size: 30px; margin: 2px; cursor:
pointer;}");
client.println(".button2 {background-color: #e51a4c;}</style></head>");

// Encabezado de la página web

client.println("<body><h1>Servidor WEB</h1>");
client.println("<body><h2>Equipo No. 3</h2>");

//Muestra en la página web los valores de los sensores

client.println("<p>");
client.println("Distancia:");
client.println(LECTURA3);
client.println("cm");
client.println("<p>");

client.println("<p>");
client.println("Iluminacion:");
client.println(LECTURA2);
client.println("% de luz");
client.println("<p>");
client.println("Temperatura:");
client.println(LECTURA1);
client.println("grados centigrados");
client.println("<p>");

client.println("<p>");
client.print("La condicion para vacunacion es: ");
client.print(LECTURA4);
client.println("<p>");

client.println("</body></html>");

// La respuesta HTTP termina con otra línea en blanco

 client.println();
// Salir del bucle while
break;
} else { // si tiene una nueva línea, borre currentLine
currentLine = "";
}
} else if (c != '\r') { // si tiene algo más que un carácter de retorno de carro,
currentLine += c; // agréguelo al final de la línea actual
}
}
}
// Borrar la variable de encabezado
header = "";
// Cerrar la conexión
client.stop();
Serial.println("Client disconnected.");
Serial.println("");
}
}

//Funciones Auxiliares
float normalizar(float sensor, float minimo, float maximo) {
float normalizado;
normalizado = (sensor - minimo) / (maximo - minimo);
return normalizado;
}
float desnormalizar(float sensor, float minimo, float maximo) {
float desnormalizado;
desnormalizado = (sensor * (maximo - minimo)) + minimo;
return desnormalizado;
}

float fa(float z) {
float y;
y = 1 / (1 + exp(-1 * z));
return y;
}

Link para video de funcionamiento

https://youtu.be/V12IIoABygo