CÓDIGO: SGC.DI.

505
GUÍA PARA LAS PRÁCTICAS DE VERSIÓN: 2.0
FECHA ÚLTIMA REVISIÓN:
LABORATORIO, TALLER O CAMPO. 12/04/2017

DEPARTAMENT DEPARTAMENTO DE CIENCIAS

CARRERA: INGENIERÍA MECATRÓNICA
O: DE LA ENERGÍA MECÁNICA
PERIODO MARZO 2020 –
ASIGNATURA: TECNOLOGÍAS DE SOFTWARE NIVEL:
LECTIVO: JULIO 2020
ING. LUIS ESCOBAR PRÁCTICA
DOCENTE: NRC: 2.4
ING. PAUL MEJÍA N°:
LABORATORIO DONDE SE DESARROLLARÁ LA
INSTRUMENTACIÓN MECATRÓNICA
PRÁCTICA
TEMA DE LA MICROCONTROLADOR ESP32 – PINES DE INTERRUPCIÓN Y ENCODER - COMUNICACIÓN
PRÁCTICA: SERIAL
INTRODUCCIÓN:
INTERRUPCIONES

Las interrupciones son útiles para hacer que las cosas sucedan automáticamente en los programas de
microcontroladores y pueden ayudar a resolver problemas de tiempo. Con las interrupciones, no necesita verificar
constantemente el valor actual del pin. Cuando se detecta un cambio, se activa un evento (se llama a una función).

Cuando ocurre una interrupción, el procesador detiene la ejecución del programa principal para ejecutar una tarea y
luego vuelve al programa principal. Esto es especialmente útil para desencadenar una acción cada vez que se detecta
movimiento o cuando se presiona un botón sin la necesidad de verificar constantemente su estado. Los pines de
interrupción en la ESP32 son todos los GPIO, excepto, GPIO 6 al GPIO 11.

ENCODER

Encoder es un dispositivo de detección que proporciona una respuesta. Los Encoders convierten el movimiento en una
señal eléctrica que puede ser leída por algún tipo de dispositivo de control en un sistema de control de movimiento, tal
como un mostrador o PLC. El encoder envía una señal de respuesta que puede ser utilizada para determinar la
posición, contar, velocidad o dirección. Un dispositivo de control puede usar esta información para enviar un comando
para una función particular.

ESP32-CAM

Tarjeta de desarrollo ESP32 incluido cámara de 2 MPx. y dotado de un lector de tarjeta micro sd. Para su
funcionamiento independiente se debe utilizar un convertidor USB a TTL,
OBJETIVOS:
● Conocer las capacidades de ESP32.
● Pines de interrupción.
● Resolución de ejercicios propuestos.
MATERIALES:
REACTIVOS: INSUMOS:
Dejar en blanco / No aplica Dejar en blanco / No aplica
EQUIPOS:
● PC portátil
● Microcontrolador ESP32
● Microcontrolador ESPCam
● Conversor Interfaz Ft232rl Usb Ftdi Arduino Serial
● Protoboard (1)
 CÓDIGO: SGC.DI.505
GUÍA PARA LAS PRÁCTICAS DE VERSIÓN: 2.0
FECHA ÚLTIMA REVISIÓN:
LABORATORIO, TALLER O CAMPO. 12/04/2017

● Cables
● Un motor DC
● Módulo encoder
● Rueda encoder
● Driver L298N, 2 motores
● ESP32-CAM
● Módulo USB to TTL (Cualquier modelo)

MUESTRA:
Dejar en blanco / No aplica
INSTRUCCIONES:

NOTA: La siguiente práctica se realiza por medio de un módulo encoder infrarrojo con el uso de una rueda para
encoder conjunto a un motor. Se puede utilizar un encoder de efecto Hall incorporado al motor sin necesidad de
cambiar el código, pero teniendo en consideración la conexión física de la misma.

Figura 1 Encoder y rueda encoder utilizados en la práctica

1. Lectura de encoder.

1.1. Implementar el circuito de la figura 1

Figura2 Funcionamiento de encoder.

Pines de encoder D0 en GPIO19, 5V a 3.3V de ESP32 o a 5V externos. GND común entre todos. ESP32 con
 CÓDIGO: SGC.DI.505
GUÍA PARA LAS PRÁCTICAS DE VERSIÓN: 2.0
FECHA ÚLTIMA REVISIÓN:
LABORATORIO, TALLER O CAMPO. 12/04/2017

alimentación por cable USB o fuente externa no mayor a 5V.

1.2. Implementar el siguiente código en micropython y para probar use un pedazo de cartón para interrumpir el sensor
infrarrojo.

from machine import Pin #Importamos librerias para pines

from time import sleep #Importamos librerias para tiempo

contador=0 #Definimos un cotador de pulsos

led=Pin(2,Pin.OUT) # colocamos un indicador de cambio de posicion
pir=Pin(19,Pin.IN) # definimos el pin de interrupcion como salida

def handle_interrupt(pin): #definimos la funcion que realizara al detectar la interrupcion

global contador #Llamamos a la variable global contador
led.value(not led.value()) #Realizamos el cambio de valor del led auxiliar
contador=contador+1 #Aumentamo en 1 la cuenta que mide el encoder por cada interrupcion

#Se define a pir como pin de interrupcion Se usa Pin.IRQ_RISING para detectar en alto
#y se pone handle_interrupt como funcion de accin en la interrupcion
pir.irq(trigger=Pin.IRQ_RISING, handler=handle_interrupt)

#Programa principal
while True:
print(contador) #Imprimimos el valor del contador
sleep(0.5) #Colocamos un tiempo de espera

1.3. Preguntas

- ¿Cómo actúa una interrupción?

- ¿Cómo actúa un encoder?

2. Detección de velocidad

2.1. Implementar el circuito de la figura 3

 CÓDIGO: SGC.DI.505
GUÍA PARA LAS PRÁCTICAS DE VERSIÓN: 2.0
FECHA ÚLTIMA REVISIÓN:
LABORATORIO, TALLER O CAMPO. 12/04/2017

Figura 3 Funcionamiento de motor y encoder

Figura 4 Acoplamiento de módulo, acople de motor con encoder

Pines de encoder: D0 a GPIO19, 5V a 3.3v de ESP32 o fuente externa no mayor a 5V, GND común.

Pines L298N: ENA a GPIO25, pin1 a GPIO33, pin2 a GPIO32

2.2. Implementar el siguiente código en micropython

from machine import Pin,PWM #Importamos librerias para pines

import utime #Importamos librerias para tiempo

contador=0 #Definimos un cotador de pulsos

dt=1000 #Definimos el tiempo de muestra en ms
ppr=8 #Definimos las divisiones de la rueda encoder o ppr del otor con encoder
 CÓDIGO: SGC.DI.505
GUÍA PARA LAS PRÁCTICAS DE VERSIÓN: 2.0
FECHA ÚLTIMA REVISIÓN:
LABORATORIO, TALLER O CAMPO. 12/04/2017

led=Pin(2,Pin.OUT) # colocamos un indicador de cambio de posicion

pir=Pin(19,Pin.IN) # definimos el pin de interrupcion como salida

#Pines de control de motor

pin1=Pin(33,Pin.OUT)
pin2=Pin(32,Pin.OUT)
frecuency=5000
motor=PWM(Pin(25),frecuency)
potenciaMotor¿1023 #Valores entre 0-1023

def handle_interrupt(pin): #definimos la función que realizara al detectar la interrupción

global contador #Llamamos a la variable global contador
led.value(not led.value()) #Realizamos el cambio de valor del led auxiliar
contador=contador+1 #Aumenta en 1 la cuenta que mide el encoder por cada interrupción

tiempo_inicial=utime.ticks_ms() #Tomamos el tiempo inicial de ESP32

#Se define a pir como pin de interrupción Se usa Pin.IRQ_RISING para detectar en alto
#y se pone handle_interrupt como función de accin en la interrupción
pir.irq(trigger=Pin.IRQ_RISING, handler=handle_interrupt)

#Programa principal
while True:
#Configuración de dirección de motor
pin1.value(0);
pin2.value(1);
#Control de potencia de motor
motor.duty(potenciaMotor)
tiempo_actual=utime.ticks_ms() #Tomamos el tiempo actual de la ESP32
if (tiempo_actual-tiempo_inicial>=dt): #Verificamos si ha pasado dt
print((contador*60)/(dt*ppr)) #Imprimimos el valor de velocidad en RPMS con formula
tiempo_inicial=tiempo_actual #Reseteamos el tiempo inicial
contador=0

2.3. Preguntas

- ¿Qué diferencia existe entre sleep() y utime.ticks_ms() ?

- ¿Explique el proceso de obtención de la velocidad de un motor en RPMs?

- ¿Si el motor posee una reducción de engranes cómo afectaría a la fórmula?

- Varíe la variable <potenciaMotor> 10 veces y observe como varía la velocidad. Haga una tabla y exprese un
modelo matemático simple de relación entre la velocidad y pwm de <potenciaMotor>.
 CÓDIGO: SGC.DI.505
GUÍA PARA LAS PRÁCTICAS DE VERSIÓN: 2.0
FECHA ÚLTIMA REVISIÓN:
LABORATORIO, TALLER O CAMPO. 12/04/2017

3. Lectura de imagen con ESP32-CAM

3.1. Implementar el circuito de la figura 5

Figura 5 Conexión Entre USB to TTL y ESP32.

Tenga en cuenta el modelo de su convertidor a la hora de realizar la conexión
3.2 Implementación de código

El siguiente código ha sido compilado con el uso de platformio IDE y arduino IDE pero se puede utilizar otro de su
agrado. Para conocer el uso de estos programas puede revisar:

https://docs.platformio.org/en/latest/integration/ide/vscode.html#ide-vscode

https://www.prometec.net/instalando-esp32/

Para poder usar el siguiente código es necesario la implementación de la librería esp32cam del repositorio
https://github.com/yoursunny/esp32cam.git. Si se usa platformio colocar la carpeta descomprimida dentro de la carpeta
lib de su WORKSPACE y si se usa arduino descargarlo e instalar libreria .zip. Para arduino puede consultar el url:
https://www.geekfactory.mx/tutoriales/tutoriales-arduino/como-instalar-una-libreria-de-arduino/ .

#include <WebServer.h>
#include <WiFi.h>
#include <esp32cam.h>
const char* WIFI_SSID = "<Colocar nombre de su router>"; //Usar su SSID del router
const char* WIFI_PASS = "Colocar contraseña de router"; //Usar su contraseña del router
WebServer server(80);
static auto loRes = esp32cam::Resolution::find(320, 240);
static auto hiRes = esp32cam::Resolution::find(800, 600);
void
handleBmp()
{
if (!esp32cam::Camera.changeResolution(loRes)) {
Serial.println("SET-LO-RES FAIL");
}
 CÓDIGO: SGC.DI.505
GUÍA PARA LAS PRÁCTICAS DE VERSIÓN: 2.0
FECHA ÚLTIMA REVISIÓN:
LABORATORIO, TALLER O CAMPO. 12/04/2017

auto frame = esp32cam::capture();

if (frame == nullptr) {
Serial.println("CAPTURE FAIL");
server.send(503, "", "");
return;
}
Serial.printf("CAPTURE OK %dx%d %db\n", frame->getWidth(), frame->getHeight(),
static_cast<int>(frame->size()));
if (!frame->toBmp()) {
Serial.println("CONVERT FAIL");
server.send(503, "", "");
return;
}
Serial.printf("CONVERT OK %dx%d %db\n", frame->getWidth(), frame->getHeight(),
static_cast<int>(frame->size()));

server.setContentLength(frame->size());
server.send(200, "image/bmp");
WiFiClient client = server.client();
frame->writeTo(client);
}
void
serveJpg()
{
auto frame = esp32cam::capture();
if (frame == nullptr) {
Serial.println("CAPTURE FAIL");
server.send(503, "", "");
return;
}
Serial.printf("CAPTURE OK %dx%d %db\n", frame->getWidth(), frame->getHeight(),
static_cast<int>(frame->size()));

server.setContentLength(frame->size());
server.send(200, "image/jpeg");
WiFiClient client = server.client();
frame->writeTo(client);
}
void
handleJpgLo()
{
if (!esp32cam::Camera.changeResolution(loRes)) {
Serial.println("SET-LO-RES FAIL");
}
serveJpg();
}

void
handleJpgHi()
 CÓDIGO: SGC.DI.505
GUÍA PARA LAS PRÁCTICAS DE VERSIÓN: 2.0
FECHA ÚLTIMA REVISIÓN:
LABORATORIO, TALLER O CAMPO. 12/04/2017

{
if (!esp32cam::Camera.changeResolution(hiRes)) {
Serial.println("SET-HI-RES FAIL");
}
serveJpg();
}
void
handleJpg()
{
server.sendHeader("Location", "/cam-hi.jpg");
server.send(302, "", "");
}
void
handleMjpeg()
{
if (!esp32cam::Camera.changeResolution(hiRes)) {
Serial.println("SET-HI-RES FAIL");
}
Serial.println("STREAM BEGIN");
WiFiClient client = server.client();
auto startTime = millis();
int res = esp32cam::Camera.streamMjpeg(client);
if (res <= 0) {
Serial.printf("STREAM ERROR %d\n", res);
return;
}
auto duration = millis() - startTime;
Serial.printf("STREAM END %dfrm %0.2ffps\n", res, 1000.0 * res / duration);
}
void
setup()
{
Serial.begin(115200);
Serial.println();

{
using namespace esp32cam;
Config cfg;
cfg.setPins(pins::AiThinker);
cfg.setResolution(hiRes);
cfg.setBufferCount(2);
cfg.setJpeg(80);

bool ok = Camera.begin(cfg);
Serial.println(ok ? "CAMERA OK" : "CAMERA FAIL");
}

WiFi.persistent(false);
WiFi.mode(WIFI_STA);
 CÓDIGO: SGC.DI.505
GUÍA PARA LAS PRÁCTICAS DE VERSIÓN: 2.0
FECHA ÚLTIMA REVISIÓN:
LABORATORIO, TALLER O CAMPO. 12/04/2017

WiFi.begin(WIFI_SSID, WIFI_PASS);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
}

Serial.print("http://");
Serial.println(WiFi.localIP());
Serial.println(" /cam.bmp");
Serial.println(" /cam-lo.jpg");
Serial.println(" /cam-hi.jpg");
Serial.println(" /cam.mjpeg");

server.on("/cam.bmp", handleBmp);
server.on("/cam-lo.jpg", handleJpgLo);
server.on("/cam-hi.jpg", handleJpgHi);
server.on("/cam.jpg", handleJpg);
server.on("/cam.mjpeg", handleMjpeg);

server.begin();
}

void
loop()
{
server.handleClient();
}
Nota:

- Colocar el nombre y contraseña de su router. No utilizaremos una red global, sino local.
- Para cargar el programa debe estar conectado GPI0 y GND. Una vez cargado desconecte estos pines abra el
serial.

3.2 Observación de imagen

- Abra un puerto serial con banda 115200 y reinicie la ESP32-CAM y obtenga la dirección ip del dispositivo y
opciones de visualización.
 CÓDIGO: SGC.DI.505
GUÍA PARA LAS PRÁCTICAS DE VERSIÓN: 2.0
FECHA ÚLTIMA REVISIÓN:
LABORATORIO, TALLER O CAMPO. 12/04/2017

- Abra un navegador web y escriba la dirección seguido de las opciones de visualización.

- Prueba las demás opciones.

Nota 1: Una vez cargado y obtenido el IP, es recomendable desconectar el Rx y Tx, dejando solo la alimentación de 5v.
 CÓDIGO: SGC.DI.505
GUÍA PARA LAS PRÁCTICAS DE VERSIÓN: 2.0
FECHA ÚLTIMA REVISIÓN:
LABORATORIO, TALLER O CAMPO. 12/04/2017

Nota 2: En ocasiones debido a la conexión de cables o la misma cámara, la conexión se reiniciará constantemente y se
deberá reiniciar manualmente algunas veces para obtener la ip y opciones. Esto se corrige en gran parte al desconectar
Tx y Rx, luego de obtener IP. La ip se puede obtener por medio de CMD o terminal si lo desea.

3.3.. Preguntas

- ¿Analizando el código fuente, en qué se ha convertido nuestra ESP32-CAM?

- Explique la diferencia de cada opción de visualización de la imagen.
- Explique la diferencia de ocupar platformio IDE o arduino IDE en comparación con Micropython

4. Ejercicio para desarrollo del estudiante

4.1. Generar un control PID para regular la velocidad del motor. Ingresando en código la velocidad a regular y
mostrando su velocidad. Puede utilizar librerías preestablecidas de esp32 para controladores PID. Regule las
constantes Kp, Ki, Kd de forma empírica.

4.2. Preguntas

- ¿Cuáles son los valores de las constantes kp, kd y ki utilizadas?

- ¿Cuál fue el error obtenido?

- ¿Qué otro tipo de controlador se puede implementar?

5. Ejercicio para desarrollo del estudiante

5.1. Usando la ESP32-CAM configurada anteriormente, elabore un programa en Python utilizando openCV que obtenga
la imagen de esta, la muestre y detecte el contorno de los objetos captados.

Puede guiarse de las siguientes fuentes:

https://www.gsampallo.com/2019/09/24/esp32-cam-primeros-pasos-y-algo-de-python/
https://www.youtube.com/watch?v=oCA7XZl8ztk
http://acodigo.blogspot.com/2017/08/deteccion-de-contornos-con-opencv-python.html#:~:text=Un%20contorno%20es
%20un%20conjunto,el%20objeto%20que%20hemos%20detectado%2C

5.2. Preguntas

- Explique las librerías de openCV utilizadas para obtener el contorno de un objeto.

- Ejemplifique el uso de este ejercicio en un proyecto práctico.
ACTIVIDADES POR DESARROLLAR EN EL LABORATORIO:
Implementación y modificación de ejercicios.
RESULTADOS OBTENIDOS:
Sistema embebido programado para el control de entradas y salidas analógicas.
CONCLUSIONES:
Los estudiantes presentan las conclusiones de la práctica de laboratorio en el informe técnico.
RECOMENDACIONES:
Consultar el fabricante para poder saber el pinout de las diferentes placas .
 CÓDIGO: SGC.DI.505
GUÍA PARA LAS PRÁCTICAS DE VERSIÓN: 2.0
FECHA ÚLTIMA REVISIÓN:
LABORATORIO, TALLER O CAMPO. 12/04/2017

Los estudiantes presentan las recomendaciones de la práctica de laboratorio en el informe técnico.

FIRMAS

F: ……………………………………………
F: ……………………………………
F: …………………………………… Ing. Johanna Tobar
Ing. Francisco Terneus COORDINADOR/JEFE DE
COORDINADOR DE ÁREA DE LABORATORIO
DOCENTE CONOCIMIENTO