Práctica 1

Módulo IoT como sistema

de percepción

Edna Priscila Montfort Flores 1638681

Brigada y hora: 416 V6
Equipo 3

Dr. Luis Martín Torres Treviño

INDICE

Laboratorio de Percepción
Definición del sistema de percepción.................................................................................................3
Definición y diagramas de los actuadores y sensores utilizados.........................................................3
Servomotor.................................................................................................................................3
LED RGB......................................................................................................................................5
Buzzer..........................................................................................................................................6
Sensor ultrasónico....................................................................................................................7
Sensor LM35...............................................................................................................................8
Sensor fotorresistencia LDR................................................................................................10
Capturas del Monitor serial haciendo lectura del funcionamiento de los componentes....................12
Código fuente en Arduino IDE para ESP32.....................................................................................15
Captura del Servidor Web................................................................................................................22
Circuito Armado..............................................................................................................................23
CONCLUSION................................................................................................................................24
Definición del sistema de percepción

El objetivo de esta práctica fue realizar un sistema IoT de percepción para la

activación de 3 actuadores y la lectura de 3 sensores por medio de la
programación en la plataforma Arduino IDE y el microcontrolador ESP32.
Se establecieron 3 actuadores fijos: servomotor, semáforo de 5 leds y un buzzer.
Los 3 sensores fueron de libre elección en tanto no fueran de respuesta binaria,
para ellos seleccionamos, una fotorresistencia, un sensor ultrasónico y un LM35.
A demás del funcionamiento de los actuadores y el sensado de los valores
detectados por cada sensor, se implementó un código para la realización de un
web server que nos permitiría controlar cada actuador y cada sensor por medio de
un navegador web, ya fuera desde la computadora o un celular.

Definición y diagramas de los actuadores y sensores utilizados

Servomotor
Un servomotor (o servo) es un tipo especial de motor con características
especiales de control de posición. Al hablar de un servomotor se hace referencia a
un sistema compuesto por componentes electromecánicos y electrónicos.

Figura 1. Partes de un servomotor.

El motor en el interior de un servomotor es un motor DC común y corriente. El eje

del motor se acopla a una caja de engranajes similar a una transmisión. Esto se
hace para potenciar el torque del motor y permitir mantener una posición fija
cuando se requiera. De forma similar a un automóvil, a mayor velocidad, menor
torque. El circuito electrónico es el encargado de manejar el movimiento y la
posición del motor.
 Figura 2. Servomotor utilizado y sus conexiones.

Figura 3. Diagrama electrónico del servomotor.

Figura 4. Diagrama de conexión del

LED RGB
El LED RGB es un tipo especial de diodo LED que se compone por varias
matrices LEDs simples como las que se encuentran en otros LEDs monocolor. De
esa forma, pueden emitir en estos tres colores primarios, generando así todo tipo
de efectos y colores diferentes (incluso el blanco combinando el rojo, verde y azul
a la vez) tan solo controlando una de las patillas de estos componentes.
Los 3 diodos LED empaquetados en un mismo encapsulado es capaz de producir
toda esta gama de colores. Tiene un pinout algo diferente a los LEDs
convencionales, ya que incluyen 3 pines, uno por cada color (cátodos o +) y otro
más adicional común a todos, el ánodo (-).

Figura 4. Conexión LED RGB

Figura 5. Diagrama de conexión del LED RGB al ESP32.

Buzzer
Un zumbador o mejor conocido como buzzer es un pequeño transductor capaz de
convertir la energía eléctrica en sonido. Para hacerlos funcionar solo basta
conectar el positivo con el + y la tierra o negativo con el – de una batería o
cualquier fuente de corriente directa.

Figura 6. Buzzer utilizado.

El funcionamiento se basa en el efecto piezoeléctrico de los materiales, Este

efecto funciona de tal manera que cuando aplicamos un voltaje el volumen del
material cambia ligeramente. Los zumbadores están construidos con dos
pequeñas placas una metálica y una cerámica, las cuales aprovechan este efecto,
pero solo generan un click ya que los materiales cambiaron de forma, pero no
regresan a su estado natural hasta que se les quita el voltaje.
Para que se pueda emitir un sonido continuo las placas necesitan vibrar
constantemente, para eso se instala un oscilador que hace que los materiales
cambien de estado una y otra vez, y así puedan cambiar miles de veces para
poder alcanzar un audio perceptible.
 Figura 8. Diagrama de conexión del buzzer al ESP32.

Sensor ultrasónico
Como su nombre lo indica, los sensores ultrasónicos miden la distancia mediante
el uso de ondas ultrasónicas. El cabezal emite una onda ultrasónica y recibe la
onda reflejada que retorna desde el objeto. Los sensores ultrasónicos miden la
distancia al objeto contando el tiempo entre la emisión y la recepción.

Figura 9. Representación del funcionamiento del sensor ultrasónico.

Un sensor óptico tiene un transmisor y receptor, mientras que un sensor

ultrasónico utiliza un elemento ultrasónico único, tanto para la emisión como la
recepción. En un sensor ultrasónico de modelo reflectivo, un solo oscilador emite y
recibe las ondas ultrasónicas, alternativamente. Esto permite la miniaturización del
cabezal del sensor.
La tecnología ultrasónica funciona basándose en principios acústicos. El sensor
emite pulsaciones acústicas cortas a través del aire, y de esta forma detecta
objetos que después reflejará. Lo que mide le sensor es el tiempo entre emitir el
pulso y la recepción del este.
Esta es la razón por la que el sensor ultrasónico es de los instrumentos más
confiables en medición. Casi todo tipo de material es capaz de reflejar ondas
acústicas o sonido, haciendo que las mediciones sean limpias.

Las inclemencias de ambientes hostiles como el polvo no afectan a los sensores

ultrasónicos, por lo que sus mediciones son más estables y precisas. El sensor
puede incluso hacer mediciones tan breves como 0,025 mm.

Figura 10. Diagrama de conexión del sensor ultrasónico al ESP32.

Sensor LM35
El LM35 es un sensor de temperatura lineal de tres terminales de National
semiconductors que puede medir temperaturas desde los -55 hasta los +150
grados centígrados, por lo que cuenta con aplicabilidad para distintos ambientes, y
gracias a sus dimensiones puede ser instalado en casi cualquier lugar. El ajuste
de salida de voltaje del LM35 es proporcional al de su entrada, y por cada valor de
temperatura este aumenta o disminuye 10 mV. El LM35 puede funcionar con una
fuente de alimentación continua de 5 V hasta 20 V, y la corriente de reserva es
inferior a 60 uA.
Este componente posee grades ventajas frente a los circuitos integrados
calibrados en grados kelvin, y la más destacable es que no se necesita sustraer
una tensión constante elevada de su salida para ajustarla a una escala en grados
centígrados. Por otra parte, no requieren de circuitos adicionales para calibrarlo
externamente, y su baja impedancia de salida, salida lineal y precisa calibración
hace posible que pueda ser instalado fácilmente en cualquier circuito de control.
 Figura 11. Foto del sensor LM35.

Por si solo el LM35 no tiene mucho que ofrecer, no obstante, este circuito
integrado es de los que requiere de menor cantidad de conexiones externas para
medir la temperatura de un lugar. Una de las formas más eficientes de aprovechar
sus funcionamientos es a través de un Arduino, estos dispositivos (aparte de ser
compatibles con cualquiera de los sensores de temperatura comerciales
disponibles en el mercado), son fáciles de configurar, tienen bajo costo y admiten
salidas analógicas en circuitos integrados.
Es difícil describir el comportamiento del circuito integrado de este componente,
especialmente porque su salida es analógica, pero por medio de simples ajustes
en un Arduino es posible interpretar las variaciones de voltaje de salida en una
pantalla digital con mucha precisión y poca cantidad de dinero. Algunos
encapsulados admiten la instalación de accesorios metálicos que permiten
determinar la temperatura con mayor facilidad y aseguran que el componente
responderá a la prontitud.

Figura 12. Diagrama de las conexiones del LM35.

 Figura 13. Diagrama de conexión del LM35 al ESP32.

Sensor fotorresistencia LDR

Una fotorresistencia es un componente eléctrico, el cual posee una resistencia
capaz de variar su magnitud al estar en contacto con distintas magnitudes de
intensidad lumínica.
Está conformado por una célula fotorreceptora y dos pastillas; cuando dicha célula
no percibe más cierto nivel de luz (es decir cuando baja del mínimo de lúmenes
predefinido), entonces hace contacto y se encienden las luces.

Figura 14. Fotorresistencia y su símbolo.

La base del funcionamiento de una fotorresistencia radica en su componente

principal, el sulfuro de cadmio (CdS). Este componente químico es un
semiconductor que tiene la capacidad de variar su resistencia según la cantidad
de luz que en él incida.

Cuanto mayor intensidad es la luz que incide sobre el sulfuro de cadmio, más baja
es la resistencia, es decir mayor facilidad de los electrones para moverse. Vale
saber que la variación de la resistencia cuando hay cambios de luminosidad
repentinos no sigue la misma velocidad, sino que tiene retardo.
 Figura 14. Diagrama de fotorresistencia LDR.

Figura 15. Diagrama de conexión de una

Capturas del Monitor serial haciendo lectura del funcionamiento de los componentes
 Captura 1. Se mueve el servomotor a 80°.

Captura 2. Se enciende el led Rojo conectado al GPIO 25.

 Captura 3. Se enciende el led Verde conectado al GPIO 26.

Captura 4. Se enciende el led Azul conectado al GPIO 27.

NOTA: Se emplearon 3 botones para el led RGB, al encender dos de ellos a la vez
podemos apreciar colores diferentes, por lo cual se logran obtener los 5 colores en total.
 Captura 5. Enciende el buzzer conectado al GPIO 33.

Captura 6. Se detecta la distancia con el sensor Ultrasónico y la temperatura con el LM35.

Código fuente en Arduino IDE para ESP32

#include <WiFi.h>
#include <Servo.h>

Servo myservo;

const char* ssid = "moto";

const char* password = "10esperfecto";

WiFiServer server(80);

String header;

String output33State = "off";

const int output33 = 33;
static const int servoPin = 13;
String valueString = String(5);
int pos1 = 0;
int pos2 = 0;

unsigned long currentTime = millis();

unsigned long previousTime = 0;
const long timeoutTime = 2000;

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
float worst;
float better = 0;
int el;

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

void setup() {
Serial.begin(115200);

Serial.print("Connecting to ");
Serial.println(ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}

Serial.println("");
Serial.println("WiFi connected.");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
server.begin();
pinMode(output33, OUTPUT);
digitalWrite(output33, LOW);

myservo.attach(servoPin);

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
}

void loop(){
WiFiClient client = server.available();
if (client) {
currentTime = millis();
previousTime = currentTime;
Serial.println("New Client.");
String currentLine = "";
while (client.connected() && currentTime - previousTime <= timeoutTime) {
currentTime = millis();
if (client.available()) { // if there's bytes to read from the client,
char c = client.read(); // read a byte, then
Serial.write(c); // print it out the serial monitor
header += c;
if (c == '\n') { // if the byte is a newline character
// if the current line is blank, you got two newline characters in a row.
// that's the end of the client HTTP request, so send a response:
if (currentLine.length() == 0) {
// HTTP headers always start with a response code (e.g. HTTP/1.1 200 OK)
// and a content-type so the client knows what's coming, then a blank line:
client.println("HTTP/1.1 200 OK");
client.println("Content-type:text/html");
client.println("Connection: close");
client.println();
// Display the HTML web page
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("<h1>Equipo No. 2</h1>");

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: 25px; margin: 2px; cursor: pointer;}");
client.println(".button2 {background-color: #e51a4c;}</style></head>");
client.println("</body></html>");

client.println("<style>body { text-align: center; font-family: \"Trebuchet MS\", Arial; margin-

left:auto; margin-right:auto;}");
client.println(".slider { width: 300px; }</style>");
client.println("<script
src=\"https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js\"></script>");

client.println("</head><body><h2>Servidor WEB</h2>");
client.println("<p>Servomotor - Position: <span id=\"servoPos\"></span></p>");
client.println("<input type=\"range\" min=\"0\" max=\"180\" class=\"slider\" id=\"servoSlider\"
onchange=\"servo(this.value)\" value=\""+valueString+"\"/>");

client.println("<script>var slider = document.getElementById(\"servoSlider\");");

client.println("var servoP = document.getElementById(\"servoPos\"); servoP.innerHTML =
slider.value;");
client.println("slider.oninput = function() { slider.value = this.value; servoP.innerHTML =
this.value; }");
client.println("$.ajaxSetup({timeout:1000}); function servo(pos) { ");
client.println("$.get(\"/?value=\" + pos + \"&\"); {Connection: close};}</script>");

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");

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

//Luz //Sonido
weird = analogRead(pin34);
worst = analogRead(pin32);
porcentaje = weird/40.95;
better = ((worst*3.3*1000)/4095)/10;
Serial.println(porcentaje);
Serial.println(better);
Serial.println(worst);

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

// turns the GPIOs on and off

if (header.indexOf("GET /33/on") >= 0) {
Serial.println("GPIO 33 on");
output33State = "on";
digitalWrite(output33, HIGH);
} else if (header.indexOf("GET /33/off") >= 0) {
Serial.println("GPIO 33 off");
output33State = "off";
digitalWrite(output33, LOW);
}

// Muestra el estado actual y los botones ON / OFF para GPIO 34

client.println("<p>Buzzer - State " + output33State + "</p>");
// Si output2State está apagado, muestra el botón ON
if (output33State=="off") {
client.println("<p><a href=\"/33/on\"><button class=\"button\">ON</button></a></p>");
} else {
client.println("<p><a href=\"/33/off\"><button class=\"button button2\">OFF</button></a></p>");
}

//GET /?value=180& HTTP/1.1

if(header.indexOf("GET /?value=")>=0) {
pos1 = header.indexOf('=');
pos2 = header.indexOf('&');
valueString = header.substring(pos1+1, pos2);
//Rotate the servo
myservo.write(valueString.toInt());
Serial.println(valueString);
}

// turns the GPIOs of leds on and off

if (header.indexOf("GET /25/on") >= 0) {
Serial.println("GPIO 25 on");
output25State = "on";
digitalWrite(output25, HIGH);
} else if (header.indexOf("GET /25/off") >= 0) {
Serial.println("GPIO 25 off");
output25State = "off";
digitalWrite(output25, LOW);
}

// Muestra el estado actual y los botones ON / OFF para GPIO 25

client.println("<p>Led Rojo - State " + output25State + "</p>");
// Si output2State está apagado, muestra el botón ON
if (output25State=="off") {
client.println("<p><a href=\"/25/on\"><button class=\"button\">ON</button></a></p>");
} else {
client.println("<p><a href=\"/25/off\"><button class=\"button button2\">OFF</button></a></p>");
}

// turns the GPIOs of leds on and off

if (header.indexOf("GET /26/on") >= 0) {
Serial.println("GPIO 26 on");
output26State = "on";
digitalWrite(output26, HIGH);
} else if (header.indexOf("GET /26/off") >= 0) {
Serial.println("GPIO 26 off");
output26State = "off";
digitalWrite(output26, LOW);
}

// Muestra el estado actual y los botones ON / OFF para GPIO 26

client.println("<p>Led Verde - State " + output26State + "</p>");
// Si output26State está apagado, muestra el botón ON
if (output26State=="off") {
client.println("<p><a href=\"/26/on\"><button class=\"button\">ON</button></a></p>");
} else {
client.println("<p><a href=\"/26/off\"><button class=\"button button2\">OFF</button></a></p>");
}

// turns the GPIOs of leds on and off

if (header.indexOf("GET /27/on") >= 0) {
Serial.println("GPIO 27 on");
output27State = "on";
digitalWrite(output27, HIGH);
} else if (header.indexOf("GET /27/off") >= 0) {
Serial.println("GPIO 27 off");
output27State = "off";
digitalWrite(output27, LOW);
}

// Muestra el estado actual y los botones ON / OFF para GPIO 27

client.println("<p>Led Azul - State " + output27State + "</p>");
// Si output27State está apagado, muestra el botón ON
if (output27State=="off") {
client.println("<p><a href=\"/27/on\"><button class=\"button\">ON</button></a></p>");
} else {
client.println("<p><a href=\"/27/off\"><button class=\"button button2\">OFF</button></a></p>");
}

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

// The HTTP response ends with another blank line

client.println();
// Break out of the while loop
break;
} else { // if you got a newline, then clear currentLine
currentLine = "";
}
} else if (c != '\r') { // if you got anything else but a carriage return character,
currentLine += c; // add it to the end of the currentLine
}
}
}
// Clear the header variable
header = "";
// Close the connection
client.stop();
Serial.println("Client disconnected.");
Serial.println("");
}
}
Captura del Servidor Web
Circuito Armado
CONCLUSION

En el presente trabajo hemos tenido la oportunidad de experimentar algo nuevo

para nosotros, el enlace de código para la representación en un servidor web, en
pocas ocasiones antes de esta hemos tenido la necesidad de armar circuitos de
manera física, con las amplias tecnologías muchas de las veces incluso han sido
circuitos virtuales los que hemos realizado, sin necesidad de ningún componente
físico, pero en esta ocasión además de poder recordar fundamentos para armar
circuitos electrónicos básicos también pudimos refrescar la memoria y adquirir
nuevos conocimientos al armar un circuito físico de percepción y obtener la lectura
de datos de los sensores por medio de códigos y para la visualización de un
prospecto cliente, puesto en una pantalla web, se requirió de la investigación del
uso y funcionamiento de códigos básicos en HTML lo cual represento algo muy
nuevo para nosotros, al dedicarnos más que nada a la mecatrónica no son
muchas las ocasiones en que necesitamos de una interfaz gráfica para concluir un
trabajo o como objetivo mismo, asi que fue un gran y nuevo conocimiento a un
área nueva y probablemente que no muchos mecatrónicos conocen.