UNIVERSIDAD POLITÉCNICA DE ATLACOMULCO

Ingeniería en Robótica

PROYECTO DE ESTADIA
“DISEÑO DE GUI EN PYTHON
PARA CONTROL DE
SISTEMAS EN LA NUBE”

Presentado por:
Enrique Reyes Morales

Profesor Asesor:
Dr. Erick Axel Padilla García

Atlacomulco, México. Septiembre 2021

1
ÍNDICE DE CONTENIDO

ÍNDICE DE CONTENIDO ...............................................................................................................1

ÍNDICE DE FIGURAS ...........................................................................................................................4
Antecedentes.....................................................................................................................................5
Definición del problema ..................................................................................................................12
Justificación .....................................................................................................................................13
Objetivo ...........................................................................................................................................14
Objetivos específicos ...................................................................................................................14
Meta de ingeniería ..........................................................................................................................15
Marco teórico ..................................................................................................................................15
Sistemas embebidos ....................................................................................................................15
Módulo ESP8266 NODEMCU .......................................................................................................16
Características: ............................................................................................................................17
Módulo ESP32..............................................................................................................................17
Características principales: ......................................................................................................18
Encoder rotativo ky-404 ..............................................................................................................19
Driver TB6612FNG .......................................................................................................................20
Arduino ........................................................................................................................................21
Entorno IDE de Arduino ...............................................................................................................22
Python..........................................................................................................................................22
Librería Tkinter ........................................................................................................................22
Interfaz Gráfica de Usuario......................................................................................................23
Internet de las cosas (IOT) ...........................................................................................................24
Plataforma Blynk .........................................................................................................................24
MÉTODOS Y/O PROCEDIMIENTOS ..................................................................................................25
Pseudocódigo Maestro: ...............................................................................................................26
Diagrama de flujo: Maestro ........................................................................................................27
Pseudocódigo: Esclavo.................................................................................................................28
Diagrama de flujo esclavo ...........................................................................................................30
Pseudocódigo interfaz .................................................................................................................32

2
 Diagrama de flujo: interfaz ..........................................................................................................34
Validación de plataforma experimental .........................................................................................40
Prueba del sistema: .....................................................................................................................40
Conclusiones ....................................................................................................................................45

3
ÍNDICE DE FIGURAS

Figura 1. Robot Danchex v.2.0 ............................................................................................................5

Figura 2. Estructura de sistema electrónico .......................................................................................6
Figura 3. Interfaz gráfica de usuario ...................................................................................................7
Figura 4. Diagrama de red genérico del proyecto ..............................................................................8
Figura 5. Interfaz gráfica de usuario versión Beta ..............................................................................9
Figura 6. Interfaz Gráfica creada en Visual Studio Web...................................................................10
Figura 7. Diagrama de conexión para el sistema de monitoreo .......................................................11
Figura 8. Datasheet ESP8266 nodemc ..............................................................................................17
Figura 9. Datasheet ESP32 ................................................................................................................19
Figura 10. Ilustración interna del encoder rotativo ..........................................................................20
Figura 11. Driver TB6612FNG ...........................................................................................................21
Figura 12. Interfaz gráfica .................................................................................................................37
Figura 13. Circuito esclavo utilizando ESP32 ....................................................................................38
Figura 14. Módulo ESP8266 nodemcu..............................................................................................39
Figura 15. Conexión de módulos wifi ...............................................................................................40
Figura 16. Estado inicial de interfaz gráfica ......................................................................................41
Figura 17. Iniciar y detener animación .............................................................................................41
Figura 18. Pausar y continuar animación .........................................................................................42
Figura 19. Encender led ....................................................................................................................42
Figura 20. Apagar Led .......................................................................................................................43
Figura 21. Activar botón en la interfaz .............................................................................................43
Figura 22. Accionar y graficar motor1 ..............................................................................................44
Figura 23. Accionar y graficar motor2 ..............................................................................................44
Figura 24. Control de rpm directamente ..........................................................................................44

4
Antecedentes
Las investigaciones realizadas actualmente sobre el control de sistemas embebidos
en una interfaz mediante la nube son pocas pero existen algunas al respecto que
son de gran importancia y fundamentales para el desarrollo de este proyecto. Una
de ellas es la siguiente:

DISEÑO DE UNA INTERFAZ HOMBRE-MÁQUINA PARA LA ADQUISICIÓN DE

DATOS EN ROBOTS MÓVILES. Describe la implementación de una interfaz
Hombre-Máquina desarrollada para la visualización e interpretación de datos
adquiridos mediante la tarjeta Sense HAT que se nuestra en la siguiente Figura 1, la
cual cuenta con sensores que permiten interactuar como: Temperatura, Humedad
y Presión. Esto con la finalidad de que el robot Danchex v.2.0 pueda comunicarse
con el usuario de una manera más amigable. Es importante destacar que
actualmente se cuenta con varias plataformas para el desarrollo de interfaces
gráficas, por lo que se eligió trabajar con una plataforma gratuita que permitirá seguir
creciendo en el área de software y hardware abiertos.

Figura 1. Robot Danchex v.2.0

5
En la siguiente Figura 2 se puede observar la estructura del sistema electrónico que
se empleó en este proyecto, se utiliza una tarjeta Raspberry Pi, Arduino y un Sense
HAT para medir la temperatura.

Figura 2. Estructura de sistema electrónico

En conclusión el robot Danchex v. 2.0 cuenta con una interfaz gráfica desarrollada
con Tkinter y Python, como se muestra en la Figura 3, en conjunto con la tarjeta Sense
Hat, las cuales son tecnologías Open Software y Open Hardware. Se destaca que
el empleo de software libre reduce los costos en comparación con otros programas
comerciales como LabView, MATLAB y Qt Creator dentro de la visión computadora
y desarrollo de interfaces gráficas (Fausto, 2018).

6
 Figura 3. Interfaz gráfica de usuario

Otra investigación relacionado al tema es: DISEÑO DE UN SISTEMA DE

ADQUISICIÓN Y VISUALIZACIÓN DE DATOS BASADO EN LA PLATAFORMA DE
SISTEMAS EMBEBIDOS RASPBERRY PY. Este proyecto busca fomentar e
incentivar el uso de software libre y aplicaciones de IoT, con el objetivo de aportar
nuevos métodos de implementación e integración en sistemas embebidos para el
internet de las cosas, permitiendo la creación de nuevas estrategias de bajo costo
y fomentar procesos óptimos y portables para el tratamiento y adquisición de datos
a partir de sensores por medio de software libre. Por lo tanto, se planteó realizar un
aplicativo que permita a partir de estudios de ergonomía ambiental determinar el
confort térmico de un lugar determinado, donde se plantea utilizar métodos de
estudio en los que señalan zonas de bienestar a partir de humedad relativa y
temperatura del aire.

7
En la siguiente Figura 4 se observa el diagrama de red genérico que se utilizó para
este proyecto, aquí también se utiliza la placa Raspberry conectado a la nube y por
medio de sensores (DHT11) poder obtener la temperatura y humedad en tiempo
real.

Figura 4. Diagrama de red genérico del proyecto

Este proyecto Utiliza el lenguaje de Python mediante la librería Tkinter para el

desarrollo de la interfaz gráfica de usuario que se muestra en la siguiente Figura 5
para la adquisición de variables de humedad y temperatura (Guaqueta, 2018).

8
 Figura 5. Interfaz gráfica de usuario versión Beta

Una tercera investigación al respecto es: SISTEMA DE MONITOREO REMOTO

CON RESGUARDO EN LA NUBE PARA UN REACTOR ANAEROBIO HIBRIDO DE
LECHO FIJO Y LECHO FLUIZADO INVERSO, se trata de un sistema de monitoreo
y control de un biorreactor anaerobio hibrido de lecho fijo y lecho fluidizante,
adecuándolo a los requerimientos del mismo, este sistema tendrá una funcionalidad
digital analógico ya que los datos serán enviados en un tren digital de pulsos por un
micro controlador y recibidos analógicamente por separado, para posteriormente
agruparse en un tren de pulsos digitales el cual será codificado por el micro
controlador, que será enviado a un entorno de desarrollo integrado (IDE) para
sistemas operativos de Windows el cual tiene la capacidad de soportar diferentes
lenguajes de programación.

La interfaz se creó en Visual Studio Web, en un lenguaje de c++ y conocimiento de

HTML, como se muestra en la Figura 6 , para la creación de páginas web, así como
el uso de tarjetas en las cuales serán montados los sistemas así como sus
características. Por otra parte el sistema embebido utilizado para este proyecto fue
la tarjeta UDOO (Perez, 2021).

9
 Figura 6. Interfaz Gráfica creada en Visual Studio Web

En la siguiente Figura 7 se observa el diagrama de conexión utilizada en este

proyecto, aquí se utiliza la placa UDOO en conjunto con Raspberry conectados a la
nube para monitorear un reactor utilizando sensores y actuadores.

10
Figura 7. Diagrama de conexión para el sistema de monitoreo

11
Definición del problema

Tradicionalmente el control de sistemas embebidos (microcontroladores) se realiza

de forma manual, es decir en el caso de estudiantes cuando realizan sus prototipos
tienen que estar programando todas y cada una de las funciones entre ellas;
avanzar, detener, izquierda, derecha, encendido y apagado establecer una
velocidad fija para los motores, entre otros, esto resulta en ocasiones incierto porque
no se sabe si cada componente se está desempeñando correctamente durante su
funcionamiento como son los motores, sensores, batería entre otros. Otro problema
es que se tiene que encender y apagar directamente resultando el apagado más
complicado porque el robot se encuentra en movimiento y se tiene que estar
siguiendo para poder desenergizarlo, por ello la importancia de poder ser
controlados mediante una interfaz por medio de internet.

Por otra parte en el área de la industria el control sobre las máquinas se realiza de
forma directa es decir, debe estar al pendiente del buen funcionamiento de todo el
sistema, por lo cual resulta invertir tiempo en ello. Si se trabajan con muchas
máquinas al mismo tiempo se requiere mucho personal para la monitorización de
cada una de ellas resultando que se invierta más capital en los procesos de
producción.

La mayoría de los proyectos sobre el control de sistemas embebidos mediante la

nube que actualmente existe siempre se utiliza la tarjeta RaspBerry Pi, por lo que
existen otros microcontroladores con la misma capacidad para ejecutar funciones,
enviando y recibiendo datos a través internet como lo son los módulos ESP8266 y
el ESP32

12
Justificación
Hoy en día con la aparición del IOT, la mayoría de los sistemas embebidos están
siendo controlados a larga distancia por medio de la nube teniendo un gran impacto
en el área de domótica, automatización, proyectos de estudiantes, entre otros,
reduciendo el tiempo de chequeo de lo que es controlado. En este caso el módulo
ESP8266 NODEMCU tiene una gran potencia en el envío y recepción de datos al
igual que el ESP32, solo que este último cuenta con más puertos GPIO pero ambos
pueden ejecutar las misma funciones y el valor que se les da a estos
microcontroladores es que cuentan con un módulo Wifi que los hace llevar la
delantera en cuanto a los microcontroladores normales que no cuentan con este
módulo wifi.

Los microcontroladores ESP8266 y ESP32, han llegado a dejar atrás los

microcontroladores tradicionales como Arduino uno, nano, mega, etc. ya que cuenta
con puertos GPIO para el envío y recepción de datos a través de su módulo Wifi y
una ventaja que tiene es que en dimensión es más pequeño que la tarjeta Raspberry
que es la más usada para este tipo de proyectos de control por la nube.

Por otra parte la interfaz gráfica de usuario es una herramienta importante porque
por medio de ella se pude monitorear y controlar alguna actividad que se esté
realizando con algún microcontrolador conectado a la nube, como lo es la velocidad
y aceleración de los motores, encendido y apagado del sistema electrónico entre
otros, ya que esta creada y programada de acuerdo a los estándares requeridos
para su aplicación y función.

13
Objetivo general
 Presentar una propuesta de interfaz gráfica de usuario, usando herramientas
de Python y Arduino, para poder controlar y monitorear sistemas embebidos
en la nube y aplicar esta propuesta en robots móviles.

Objetivos específicos
 Realizar la programación referente a la interfaz mediante el programa de
Python.
 Utilizar la librería de Python (Tkinter) para la creación del GUI.
 Con los módulos ESP8266 y ESP32 realizar el circuito y trabajar como
maestro-esclavo.
 Utilizar el Software Arduino para la programación de los módulos.
 Ocupar la plataforma Blynk para realizar la comunicación de los módulos.

14
Meta de ingeniería
Desarrollar sistemas integrados mecatrónicos eficientes con la finalidad de que
lleven un enfoque guiado hacia control en la nube por medio de una interfaz gráficas
de usuario (GUI) para poder controlar y monitorear sistemas embebidos orientados
a la industria 4.0.

Marco teórico
Sistemas embebidos
Un sistema embebido es un sistema electrónico diseñado específicamente para
realizar unas determinadas funciones, habitualmente formando parte de un sistema
de mayor entidad. La característica principal es que emplea para ello uno o varios
procesadores digitales (CPUs) en formato microprocesador o DSP lo que permite
aportar inteligencia al sistema anfitrión al que ayuda a gobernar y de que forma
parte (Miñarro, 2009).

En un sistema embebido la mayoría de los componentes se encuentran incluidos

en la placa base (la tarjeta de video, audio, modem) y muchas veces los dispositivos
resultantes no tienen el aspecto de lo que se suele asociar a una computadora.
Tienen una computadora con características especiales conocida como
microcontrolador que viene a ser el cerebro del sistema. Este no es más que un
microprocesador que incluye interfaces de entrada/salida en el mismo chip.
Normalmente estos sistemas poseen una interfaz externa para efectuar un
monitoreo del estado y hacer un diagnóstico del sistema (SemanticWeb, 2020).

15
Módulo ESP8266 NODEMCU
ESP8266 es el nombre de un microcontrolador diseñado por una compañía china
llamada Espressif Systems en su sede en Shangai. Pero su producción en masa
inicio hasta principios del año 2014, donde se anunció que este chip sería una
excelente solución autónoma de redes Wi-Fi que se ofrece como puente entre los
microcontroladores que hasta ahora existen o que tienen la capacidad de ejecutar
aplicaciones independientes.

Está basado en la compactación de un chip SMT (Tecnología de Montaje

Superficial) en lo cual viene en un solo paquete de tan solo 5 milímetros cuadrados.
Se han adecuado y están listos para su uso. Esto permite trabajar con este
dispositivo único acoplado a un microcontrolador para desarrollar proyectos o como
sistema autónomo para ciertas aplicaciones (ECORFAN, 2017).

El ESP8266 tiene potentes capacidades a bordo de procesamiento y

almacenamiento que le permite integrarse con sensores y dispositivos específicos
de aplicación a través de sus GPIOs con un desarrollo mínimo y carga mínima
durante el tiempo de ejecución. Su alto grado de integración en el chip permite una
circuitería externa mínima, y la totalidad de la solución, incluyendo el módulo está
diseñado para ocupar el área mínima en un PCB (Anon., 2021).

En la siguiente Figura 8 se observa el datasheet del esp8266 nodemcu, todos y

cada uno de los pines GPIO (Sistema de entrada y salida de propósito general).

16
 Figura 8. Datasheet ESP8266 nodemc

Características:
 Código abierto
 Programable
 Bajo costo
 Compatible con Arduino
 10 GPIO cada GPIO puede ser PWM, 12C, 1-wir
 FCC CERTIDIED WI-FI module
 USB-TTL included, plug&play

Módulo ESP32
Creado por Espressif system, ESP32 es un sistema de bajo consumo y bajo costo
en un chips SoC (System On Chip) con Wi-Fi y módulo dual con Bluetooth. En el
fondo tiene un microprocesador Tensilica Xtensa LX6 de doble núcleo o de un solo
núcleo, con una frecuencia de hasta 240MHz.

17
ESP32 está altamente integrado con switch de antena, balun para RF, amplificador
de potencia, amplificador de recepción con bajo nivel de ruido, filtros y módulos de
administración de energía, totalmente integrados dentro del mismo chip.

Diseñada para dispositivos móviles; tanto en las aplicaciones de electrónica y las

de IOT (Internet de las cosas). ESP32 logra un consumo de energía ultra bajo a
través de funciones de ahorro de energía. Incluye sintonización de reloj con una
resolución fina, modos de potencia múltiple y escalado de potencia dinámica
(Saravia, 2019).

Características principales:
 Procesador principal: Tensilica Xtensa LX6 de 32 bits.
 Wi-Fi: 802.11, 2.4GHz hasta 150Mbit/s.
 Bluetooth: v4.2BR y Bluetooth Low Energy (BLE).
 Frecuencia de Clock: Programable, hasta 240 MHz.
 Rendimiento: hasta 600DMIPSD.
 ROM: 448KB para arranque y funciones básicas.
 SRAM: 520KB, para datos e instrucciones.

18
 Figura 9. Datasheet ESP32

Encoder rotativo ky-404

Un encoder permite indicar la posición y sentido de giro mediante una perilla que
posee en uno de sus lados, se utiliza a menudo para controlar servomotores y
motores paso a paso, otra aplicación en la que se emplea este modelo es para hacer
la función de potenciómetro digital.

El funcionamiento de este dispositivo se calcula mediante 30 posiciones que posee

en su interior que se puede medir fácilmente mediante “click” que existe al rotar la
perilla. El encoder posee 3 pines A, B y C respectivamente, en su interior existe dos
interruptores uno que conecta A con C y otro que conecta B con C; en la Figura 10
se puede observar la representación de cómo se construye el interruptor.

19
 Figura 10. Ilustración interna del encoder rotativo

Mediante la gráfica anterior se afirma que los dos interruptores se encuentran en

estado OFF, es decir de modo cerrado, esto lleva a cabo dos posibles opciones que
son:

 Si el interruptor gira hacia la derecha, el pin A y C cambian de estado cerrado

a abierto y el interruptor que contiene a B y C se mantienen en cerrado.
 Si el interruptor gira hacia la izquierda, el pin B y C son los que cambian de
estado cerrado a abierto y el interruptor A y C se mantienen (BOLAÑOS,
2019)

Driver TB6612FNG
El TB6612FNG que se observa en la Figura 11 es un controlador (driver) de motores
que nos permite manejar dos motores de corriente continua desde Arduino, variando
tanto la velocidad como el sentido de giro. Puede ser considerado una versión
mejorada del L298N, al igual que este, internamente está formado por dos puentes-
H, junto con la electrónica necesaria para simplificar su uso, y eliminar posibles
cortocircuitos por errores de uso.

20
Sin embargo, en el caso del TB6612FNG los puentes-H están formados por
transistores MOSFET, en lugar de transistores BJT como el L298N. Esto permite
que el TB6612FNG tenga mejor eficiencia y mejores dimensiones que el L298N.

El TB6612FNG también permite controlar intensidades de corriente superiores,

siendo capaz de suministrar 1.2A por canal de forma continua, y 3.2A de pico. La
siguiente Figura 11 muestra el datasheet indicando el uso de cada uno de los puertos
para su uso que tiene este driver (David, 2020).

Figura 11. Driver TB6612FNG

Arduino
Arduino es una plataforma de prototipos electrónica de código abierto (open-source)
basada en hardware y software flexibles y fáciles de usar. Está pensado para
artistas, diseñadores, como hobby y para cualquier interesado en crear objetos o
entornos interactivos.

Arduino pude “sentir” el entorno mediante la recepción de entradas desde una

variable de sensores y puede afectar a su alrededor mediante el control de luces,
motores, y otros artefactos. El software se puede descargar gratuitamente, los
diseños de referencia del hardware (archivos CAD) están disponibles bajo licencia
open-source, por lo que es libre de a adaptarla a nuestras necesidades (Herrador,
2009).

21
Entorno IDE de Arduino
El IDE de Arduino es una versión reducida del lenguaje C/C++, que no es lo más
indicado para iniciarse en la programación de instrucciones de código. Gracias a los
colores que utiliza en sus palabras reservadas se puede saber si una palabra no
está escrita correctamente. Las características que ofrece este entorno son:

 Tiene un lenguaje simple, basado en C/C++

 Permite desde el primer momento estar programando directamente el
hardware.
 Es un proyecto open-source se pude experimentar sobre la misma tarjeta.
 Tiene una comunidad de desarrollo alrededor que permite un acceso a
referencias, ejemplos y proyectos de gran ayuda (Vega, 2016).

Python
Básicamente Python es un lenguaje de programación de alto nivel, interpretado y
multipropósito. En los últimos años su utilización ha ido constantemente creciendo
y en la actualidad es uno de los lenguajes de programación más empleados para el
desarrollo de software.

Python puede ser utilizado en diversas plataformas y sistemas operativos, entre los
que podemos destacar los más populares, como Windows, Mac OS y Linux. Pero,
además, Python también puede funcionar en Smartphone, Nokia desarrollo un
intérprete de este lenguaje para su sistema operativo Symbian. Con este lenguaje
podemos desarrollar software para aplicaciones científicas, para comunicaciones
de red, para aplicaciones de escritorio con interfaz gráfica de usuario (GUI), para
crear juegos, para Smartphone y por supuesto, para aplicaciones web (Montoro,
2012).

Librería Tkinter
Tkinter es un binding de la biblioteca gráfica Tcl/Tk para el lenguaje de programación
Python, con estos queremos decir que Tk se encuentra disponible para varios
lenguajes de programación entre los cuales se encuentra Python con el nombre de

22
Tkinter. Este no es más que una capa de esta librería para el lenguaje Python con
lo cual usar Tk en otro lenguaje no nos supondrá un inconveniente.

Se considera un estándar para la interfaz gráfica de usuario (GUI) para Python y es

el que viene por defecto con la instalación para Microsoft Windows y preinstalado
en la mayoría de las distribuciones de GNU/Linux. Con Tkinter podemos conseguir
resultados casi tan buenos como con otras librerías gráficas siempre teniendo en
cuenta que quizás con otras herramientas podamos realizar trabajos más complejos
donde necesitemos una plataforma más robusta, pero como herramienta didáctica
e interfaces sencillas nos sobrara, dándonos una perspectiva de lo que se trata el
desarrollo de una parte muy importante de una aplicación si deseamos distribuirla
(Álvarez, 2016).

Interfaz Gráfica de Usuario

El concepto de interfaz es un concepto muy amplio según el ámbito de
conocimientos, si vamos a la etimología de la palabra interfaz encontramos una
palabra compuesta por dos vocablos: Inter proviene del latín inter, y significa entre
o en medio, y Faz proviene del latín facies y significa superficie, vista o lado de una
cosa. Por lo tanto una traducción literal del concepto de interfaz atendido a su
etimología, podría ser “superficie, vista, a lado mediador”.

En el contexto de la interacción persona-ordenador, hablamos de una interfaz de

usuario, para referirnos de forma genérica al espacio que media la relación de un
sujeto y un ordenador o sistema interactivo. El interfaz de usuario, es una ventana
mágica de un sistema informático, que posibilita a una persona interactuar con él.

Cuando hablamos de interfaz gráfica de usuario, el concepto es aún más específico

en cuanto que interfaz gráfico de usuario al contrario que el concepto de interfaz,
tiene una localización determinada y definida: Si el interfaz etimológicamente
supone la cara o superficie mediadora, el interfaz gráfico de usuario supone un tipo
específico de interfaz que usa metáforas visuales y signos gráficos como paradigma

23
interactivo entre la persona y el ordenador. “Es un método de interacción con un
ordenador a través del paradigma de manipulación directa de imágenes gráficas
controles y texto (Marreo, 2006).

Internet de las cosas (IOT)

Internet de las cosas, revolución tecnológica que posibilita que internet alcance el
mundo real de los objetos físicos, convirtiendo objetos comunes en “cosas
inteligentes” conectadas a internet. Se está convirtiendo en una realidad capaz de
generar gran cantidad de datos del mundo físico, los que, luego de ser analizados
con herramientas informáticas, pueden ser útiles en nuestra toma de decisiones al
contar con información valiosa en tiempo real y así mejorar nuestras actividades
cotidianas de manera inmediata (Pérez, 2017).

El concepto de combinar computadoras, sensores, y redes para monitorear y

controlar diferentes dispositivos ha existido durante décadas. Sin embargo, la
reciente confluencia de diferentes tendencias del mercado tecnológico está
permitiendo que la internet de las cosas este cada vez más cerca de ser una realidad
generalizada. Esta tendencia incluye la conectividad omnipresente, la adopción
generalizada de redes basadas en el protocolo IP, la economía en la capacidad de
cómputo, la miniaturización, los avances en el análisis de datos y el seguimiento de
la computación en la nube (Rose, 2015).

Plataforma Blynk
Blynk es una plataforma de internet de las cosas para Android y iOS de control de
sistemas desarrollados con Arduino y Raspberry Pi. Con esta herramienta de trabajo
se pude diseñar interfaces gráficas para proyectos dibujando y poniendo controles
en la misma. El sistema no está limitado a ningún hardware específico. Solo se
requiere que tu proyecto con Arduino o RaspBerry Pi este linkeado a internet por

24
medio de Wifi, Ethernet o un ESP8266. De esta manera podrá conectarse con el
servidor Blynk y controlar tus sistemas.

Blynk es un proyecto realizado por personas de Nueva York, Kiev y Barsovia. Los
costos en el modo de desarrollo son nulos, permitiendo esto tener un prototipo a un
costo reducido. Luego de ello, se ofrecen diferentes planes de servicio dependiendo
de las exigencias del mismo.

El servidor Blynk server responsable de todas las comunicaciones entre el teléfono

celular y el hardware. Podrás utilizar el servidor online de Blynk o instalar tu propio
servidor Blynk local. El servidor Blynk es una aplicación de código abierto.

Las librerías de Blynk se encuentran disponibles para diferentes plataformas de

desarrollo permitiendo la comunicación entre el servidor y los recursos del hardware.
Por ejemplo cada vez que presione el botón en la aplicación Blynk, se generara un
mensaje que viajara por la nube Blynk encontrando su camino hacia tu hardware o
viceversa.

La aplicación podrá controlar múltiples controladores remotos al mismo tiempo.

Podrás controlar pines analógicos o digitales del hardware en forma directa, sin
escribir código (Tecnologia_humanizada, 2018).

MÉTODOS Y/O PROCEDIMIENTOS

Para realizar la presente investigación de estadía que tiene como principal objetivo
diseñar una interfaz gráfica de usuario en Python, para controlar sistemas
embebidos en las nube utilizando módulos ESP8266 nodemcu 12 y ESP32
programados en Arduino y realizando la conexión entre ellos mediante la plataforma
Blynk, se realizó el pseudocódigo del programa así como el diagrama de flujo
especificando todo el proceso que se llevó a cabo.

25
Pseudocódigo Maestro:
1. Algoritmo Proceso iterativo del programa (maestro)
2. Incluir librerías ESP y Blynk
3. Declarar variables (int, char, string, unsigned long)
4. Declarar código de blynk, red y contraseña
5. Leer dato de puerto virtual “0” correspondiente al potenciómetro, convertirlo
a valor hexadecimal y guardarlo en variable datos [0,1]
6. Leer dato de puerto virtual “5” correspondiente al motor 1, convertido en valor
hexadecimal y guardarlo en variable datos[2,3]
7. Leer dato de puerto virtual “6” correspondiente al motor 2, convertirlo en valor
hexadecimal y guardarlo en variable datos[4,5]
8. Leer dato de puerto virtual “2” correspondiente al botón 1, convertirlo en valor
hexadecimal y guardarlo en variable datos[6]
9. Leer dato de puerto virtual “3” correspondiente al botón 2, convertirlo en valor
hexadecimal y guardarlo en variable datos[7]
10. Leer dato de puerto virtual “4” correspondiente a botón 3, convertirlo en valor
hexadecimal y guardarlo en variable datos[8]
11. Conectarse con el dispositivo que enviara la información
12. Habilitar el puerto serial
13. Si dato recibido por el puerto referente a la interfaz es igual a “m”
14. Encender Led
15. Si dato recibido por el puerto referente a la interfaz es igual a “n”
16. Accionar motores
17. Si tiempo transcurrido >= 500 milisegundos (para evitar publicaciones
rápidas)
18. Publicar (datos,9)
19. Fin

26
Diagrama de flujo: Maestro

Inicio

Incluir librerías ESP y Habilitar puerto serial

Blynk

Declarar variables (int, char,

String, unsigned long)

Si recibe dato de
interfaz &
Declarar código (Blynk), tiempo
red y contraseña transcurrido Si
>=500
milisegundos

Leer puerto virtual 0,

convertirlo a
hexadecimal y guardarlo
No Ejecutar función específica
en el pin correspondiente:
Encender led, accionar
motores, activar botones.
Leer puerto virtual 5,
convertirlo a
hexadecimal y guardarlo

Fin
Leer puerto virtual 6,
convertirlo a
hexadecimal y guardarlo

Leer puerto virtual 2,

convertirlo a
hexadecimal y guardarlo

Leer puerto virtual 3,

convertirlo a
hexadecimal y guardarlo

Leer puerto virtual 4,

convertirlo a
hexadecimal y guardarlo

Conectarse con esclavo

27
Pseudocódigo: Esclavo
1. Algoritmo Proceso iterativo del programa (esclavo)
2. Incluir librerías ESP, Blynk, WiFi.
3. Asignar una tarea (0) en el micro
4. Definir variables:
 Const int e int para asignar número de pin y valor de inicio
 Unsigned long para tiempo
 Double para rpm
 Char para configurad la red a la que se conecta y auth token de la
plataforma

5. Declarar función “avanzar” para la señal pwm de los motores

6. Leer puerto virtual 8
7. Si rpm2 >125 & rpm2<=250
8. Velocidad motor1 avanza y velocidad motor 2 disminuye
9. Si rpm2<125 & rpm2>=0
10. Velocidad motor1 disminuye y velocidad motor 2 aumenta
11. Si rpm2>=251
12. Velocidad motor1 y motor2 = 0
13. Si no
14. Velocidad motor1 y 2 =125
15. Configurar a que dispositivo envía la información
16. Declarar pines pwm y motores como salida
17. Definir canal, frecuencia y resolución para pwm motor1 y pwm motor2
18. Definir tarea del encoder
19. Inicializar puerto serial
20. Conectarse a la red
21. Declarar pines de botones (1,2,3) como entradas
22. Función encoder: rmp, motor1 y rpm motor2 = pulsos/60*150.
23. Lectura de botones

28
24. Si botón (1,2,3) presionado una vez
25. Botón (1,2,3) encendido
26. Si botón (1,2,3) presionado segunda vez
27. Botón (1,2,3) apagado
28. Evitar publicaciones rápidas entre envió de datos
29. Si tiempo <= ultimo_tiempo
30. Entonces tiempo = millis()
31. Si tiempo – ultimo_tiempo >=300 & aux4 = 0
32. aux4 = 1, envía por el puerto virtual 5 rpm motor1
33. Si tiempo – ultimo_tiempo >=600 & aux5 = 0
34. aux5 = 1, envía por el puerto virtual 6 rmp motor2
35. Si tiempo – ultimo_tiempo >=900
36. Reinicia tiempo, aux4 y aux5 a 0

29
Diagrama de flujo esclavo

Inicio

Incluir librerías ESP,

Blynk, Wifi

Si rpm2 <125 Si
Asignar tarea en micro & >= 0
ESP32

Motor1 disminuye
velocidad, motor2
No aumenta
Definir variables: const,
int, char, unsigned long,
double

Si rpm2 >= Si
251
Declarar función
“avanzar” para señal
rpm de los motores Velocidad motor1 y
motor 2 = 0
No

Declarar función
Velocidad motor1 y
“avanzar” para señal
motor 2 = 125 rpm
rpm de los motores

Leer puerto virtual 8 Configurar a que

dispositivo envía la
información

Declarar pines pwm y

motores como
Si rpm2 >125 Si
“OUTPUT”
& <= 250

Motor1 aumenta
velocidad, motor2 Definir Canal, frecuencia
disminuye y resolución para pwm1
No y pwm2

30
 Evitando publicaciones
rápidas:

“tiempo <= último tiempo

tiempo = millis ()
Definir tarea en el
encoder

Iniciar puerto serial Si t – u_t >= 300 Si

& aux4 = 0

Envía rpm a motor1 y

Conectarse a la red aux = 1
No

Declarar botones (1, 2, 3) Si t – u_t >=

Si
como entrada 600 & aux5 = 0

Declarar función encoder: Envía rpm a motor2 y

rpm motor1 y rpm aux5 = 1
No
motor2 = pulsos / 60*150

Si t – u_t >= Si
Lectura de los botones 900
(1, 2, 3)

Reinicia tiempo

No aux4 = 0 y aux5 = 0

Si botón (1,
Si
2, 3) es
pulsado

Fin
Botón (1, 2, 3) activado

No

Si botón (1,
2, 3) otra vez
pulsado
No

Si

Botón (1, 2, 3) apagado

31
Pseudocódigo interfaz

1. Algoritmo proceso iterativo Interfaz

2. Importar librerías tkinter, matplotlib, serial
3. Inicializar puerto serial
4. Definir características de las gráficas (potenciómetro, motor1 y motor2)
5. Definir función iniciar animación
6. Definir el rango de animación para cada gráfica (0 - 100)
7. Leer datos recibidos del micro ESP8266 por el puerto serial
8. Separar datos y contarlos
9. Si datos = 9
10. Publicarlos en forma ordenada
11. Si botón (1,2,3) es presionado
12. Envía señal y botón cambia de color
13. Si no
14. Conserva su mismo color
15. Si botón “Iniciar” es pulsado
16. Cambia nombre de botón a “Detener” e inicia la animación de cada gráfica y
se activa el botón pausar
17. Si no
18. Gráficas (1,2,3) = None
19. Definir función enviar dato led
20. Si botón “LED OFF” es pulsado
21. Enviar dato por el puerto y cambia a estado “LED ON”
22. Si no conserva su estado “LED OFF”
23. Definir función enviar rpm motor1 para enviar por el serial la velocidad
24. Definir función pausar animación
25. Si botón “Pausar” es pulsado
26. Detener animación y estado de botón cambia a “Continuar”
27. Si no continua con la animación y conserva su estado “Pausar”

32
28. Crear interfaz: Geometría, titulo, color, estilo
29. Agregar cada una de las gráficas
30. Colocar en diferentes columnas
31. Posicionar cada gráfica
32. Definir variables: long, aux
33. Definir función Leer datos para graficar
34. Agregar etiquetas donde muestra el valor recibido del potenciómetro y rmp
motor 1 y 2
35. Configurar color, posición, texto, fuente y función (leer datos) de cada
etiqueta
36. Agregar widget Slaider para controlar rpm
37. Configurar color, posición, texto, fuente y función “enviar rpm”
38. Agregar botón iniciar
39. Configurar color, posición, y asignar función “iniciar animación”
40. Agregar botones (1,2,3)
41. Configurar posición, color, texto y fuente
42. Agregar botón pausar
43. Configurar posición, color, texto, fuente y función "pausar animación”
44. Agregar botón “LED OFF”
45. Configurar posición, color, texto y función “enviar dato led”
46. Agregar botón “Enviar rpm”
47. Configurar posición, color, texto y función “enviar rpm”

33
Diagrama de flujo: interfaz

Inicio

Importar librerías: tkinter,

matplotlolib, serial Si datos Si

recibidos=9

No

Iniciar puerto serial Publicarlos de forma

ordenada

Definir características de las

Si botón (1, Si
gráficas
2,3)
presionado

Definir función “iniciar

Envía señal y cambia de color
animación”
No

Conserva el mismo color

Animación 1, 2, 3

Definir rango de animación

para gráficas (0-100) Si botón Si
“iniciar” es
presionado

Leer dato recibido del ESP826

Cambia de estado a “Detener”
por puerto serial
e inicia la animación
No

Graficas (1,2,3) = None

Separar los datos y contarlos

Definir función “enviar dato

led”

34
 Definir variables: long, aux

Si botón Si
“LED OFF”
presionado
Definir función leer datos para
Envía dato y cambia a estado gráficar
No “LED ON”

Conserva su estado “LED OFF” Agregar etiquetas donde

muestra el valor recibido de
potenciómetro y rpm motor 1
y2
Definir función “pausar
animación”
Configurar color, posición,
texto y asignar función “leer
dato” de cada etiqueta

Si botón Si
“Pausar”
Agregar Slaider para controlar
+ presionado
rpm, configurar posición,
color, texto y asignar función
Detener animación y cambia a
“iniciar animacion”
No estado “Continuar”

Continúa con la animación y

Agregar botón “iniciar”,
conserva su estado “Pausar”
configurar color, posición y
asignar función “iniciar
animación”
Crear interfaz: geometría,
posición, color, estilo
Asignar botones (1, 2, 3)
configurar posición, color,
texto y fuente
Agregar cada gráfica (3),
posicionarlas y colocarlas en
diferentes columnas

35
 Agregar botón “pausar”
configurar posición, color,
texto, fuente y asignar función
“pausar animación”

Agregar botón “LED OFF”

configurar posición, color,
texto, fuente y asignar función
“enviar dato led”

Agregar botón “enviar rpm”

configurar posición, color,
texto y asignar función “enviar
rpm”

Fin

36
La siguiente Figura 12 muestra la interfaz gráfica de usuario final donde se puede
apreciar cada widget como los botones Slaider etc. Cada componente está ubicado
de acuerdo a posiciones en x y y, las gráficas reciben la señal del esclavo y los
botones envían datos por el puerto serial al maestro.

Botón Gráficas donde Etiqueta donde Botones

encender y se muestra las se muestra los (1, 2, 3)
apagar LED señales recibidas valores recibidos
del esclavo (rpm y
potenciómetro)

Botón iniciar Slaider para Entrada de

animación controlar las texto (rpm)
rpm

Botón pausar
Figura 12. Interfaz gráfica Botón
animación
Enviar rpm

37
En siguiente Figura 13 se muestra el circuito que se realizó para el proyecto, para
esto se utilizó el módulo wifi ESP32 que en la actualidad es un microcontrolador
de gran potencia para este tipo de trabajos. Los Encoders envían los pulsos para
ser graficados en la interfaz así como las señales del potenciómetro, los botones
al ser presionados envían la señal al maestro que muestra en la interfaz el cambio
de color de estos.

Motores Encoder Led

rotativo
Driver
TB6612FNG

Potenciómetro Botones ESP32

(1, 2, 3)

Figura 13. Circuito esclavo utilizando ESP32

38
La siguiente Figura 14 se aprecia el módulo ESP8266 NODEMCU que se utilizó como
maestro en el proyecto, su función es enviar datos recibidos de la interfaz por el
puerto serial y así mismo recibir datos o señales del esclavo y enviarlas a la interfaz.

Figura 14. Módulo ESP8266 nodemcu

39
Validación de plataforma experimental

Prueba del sistema:

1. Para dar comienzo al funcionamiento de la interfaz, primero se debe conectar
el módulo wifi maestro (ESP8266) al puerto de la computadora y especificar en
la programación de Python el # puerto que se utilizara, así mismo el esclavo
(ESP32) conectado a una alimentación externa a la computadora o en algún
otro lugar donde se quiera controlar. Para poder controlar a distancia solo se
necesita configurar la red y contraseña a la cual se conectara en la
programación de Arduino.

Figura 15. Conexión de módulos wifi

2. Se corre el programa en Python para ejecutar la interfaz (Figura 16), y

automáticamente los motores se accionaran girando a una misma velocidad
(125 rpm), pero aun no iniciara la animación en las gráficas.

40
 Figura 16. Estado inicial de interfaz gráfica

3. Presionar el botón “iniciar” (Figura 17a), que cambiara a estado “Detener”

(Figura 17b), para iniciar la animación de cada una de las gráficas. La primera

representa la señal obtenida del potenciómetro, la segunda al motor1 y la

tercera al motor2.

a) b)
Figura 17. Iniciar y detener animación

41
4. Presionar el botón “Pausa” (Figura 18a), que cambiara a estado “Continuar”
(Figura 18b), y cada una de las gráficas detendrá la animación y continuaran
hasta que se presione continuar.

a) b)
Figura 18. Pausar y continuar animación

5. Al presionar el botón “LEDOFF” (Figura 19a), cambiara a estado “LEDON” (Figura

20b), y este activara el encendido del led que se encuentra ubicado en el circuito
esclavo. Y volverá a su estado original presionando nuevamente apagando el
led que estaba encendido.

a)

Figura 19. Encender led

42
 b)

Figura 20. Apagar Led

6. Presionar cualquiera de los botones 1, 2, 3 (Figura 21), del circuito esclavo se

activara y cambiara el color del botón de la interfaz en señal de que ha recibido
la instrucción correspondiente. Presionar nuevamente cualquier botón y
regresara a su estado original en la interfaz.

Figura 21. Activar botón en la interfaz

7. En la parte de los motores hay dos formas de controlar la rpm de cada uno de
ellos; la primera es utilizando el Slaider (Figura 22a), deslizando de un lado hacia
otro para ajustar la velocidad deseada. Como ya se mencionó, al ejecutar la
interfaz los motores siempre tendrán una velocidad de 125 en ambos, pero con
el Slaider si se desliza todo hacia la derecha, conforme se valla deslizando el
motor1 va a girar más que el otro hasta llegar a 250 que es el máximo,
graficando la señal rpm (Figura 22b), quedando el motor2 parado.

43
 a) Figura 22. Accionar y graficar motor1 b)

Por el contrario si se desliza hasta llegar a 0 (Figura 23a), entonces el motor2

estará girando y el motor1 quedara parado y la gráfica se cumple en el motor2
(Figura 23b).

a) b)

Figura 23. Accionar y graficar motor2

8. El botón “Enviar rpm” (Figura 24) cumple la misma función que el Slaider solo

que aquí se ingresa de forma numérica la velocidad que se desea, cualquier

número que se le ingrese menor a 250 y mayor a 0 accionara las rpm de los
motores, por el contrario si se ingresa un digito mayor a 250 entonces se
detendrán ambos motores.

Figura 24. Control de rpm directamente

44
Conclusiones

Por medio de la interfaz gráfica de usuario se logró controlar y monitorear sistemas

embebidos en este caso el módulo wifi ESP32 que cuenta con dos núcleos para
ejecutar funciones y recibir las señales rpm de los motores y del potenciómetro y
ser graficadas en la interfaz, aunque el tiempo de tráfico de datos fue de 100
milisegundos la velocidad de envío y recepción de datos fue rápida. Se pudo realizar
la conexión de los módulos (ESP32 y ESP8266) por medio de la plataforma Blynk
con facilidad ya que es muy práctica y se pueden conectar varios
microcontroladores al mismo tiempo además de que proporciona un código de
seguridad para evitar ser controlado por alguien más.

45
Referencias bibliográficas

Álvarez, A., 2016. [Link]. [En línea]

Available at: [Link]
[Último acceso: 2021].

Anon., 2021. Electronibal. [En línea]

[Último acceso: 09 2021].

BOLAÑOS, K. M. R., 2019. Google Scholar. [En línea]

Available at:
[Link]
[Link]
[Último acceso: 06 2021].

David, A. C. B., 2020. Google Scholar. [En línea]

Available at: [Link]
[Link]
[Último acceso: 06 2021].

ECORFAN, 2017. [Link]. [En línea]

[Último acceso: 05 2021].

Fausto, M. S. R., 2018. [Link]. [En línea]

Available at: [Link]
[Último acceso: Mayo 2021].

Guaqueta, J. E. L., 2018. [Link]. [En línea]

Available at:
[Link]
&isAllowed=y
[Último acceso: 05 2021].

Herrador, R. E., 2009. [Link] [En línea]

Available at: [Link]
[Último acceso: 06 2021].

Marreo, C., 2006. [Link]. [En línea]

Available at: [Link]
[Último acceso: 2021].

Miñarro, B. Ú., 2009. [Link]. [En línea]

Available at: [Link]
4c3f-acbe-e7699e490f4e
[Último acceso: 05 2021].

46
Montoro, A. F., 2012. Google Scholar. [En línea]
Available at: [Link]
[Último acceso: 06 2021].

Perez, E. P., 2021. [Link]. [En línea]

Available at:
[Link]
MANUEL%20PE%c3%91A%20P%c3%[Link]?sequence=1&isAllowed=y
[Último acceso: 05 2021].

Pérez, F. A. F., 2017. [Link] [En línea]

Available at: [Link]
[Último acceso: 2021].

Rose, K., 2015. [Link]. [En línea]

Available at: [Link]
[Link]
[Último acceso: 2021].

Saravia, A. R. B., 2019. [Link]. [En línea]

Available at: [Link]
[Último acceso: 05 2021].

SemanticWeb, 2020. [Link]. [En línea]

Available at:
[Link]
Sistemas_Inteligentes_
[Último acceso: 05 2021].

Tecnologia_humanizada, 2018. [Link]. [En línea]

Available at: [Link]
en-la-red/revista/2018/volumen-4-2018/11/2018/
[Último acceso: 2021].

Vega, J., 2016. Google Scholar. [En línea]

Available at: [Link]
[Link]
[Último acceso: 06 2021].

47
48