T09117
T09117
T09117
Director
WILLIAM GUTIERREZ MARROQUIN
Magister en Ingeniería
Jimmy Tombe
4
CONTENIDO
pág.
RESUMEN 12
INTRODUCCIÓN 14
2. JUSTIFICACIÓN 17
3. OBJETIVOS 19
4. ANTECEDENTES 20
5. MARCO DE REFERENCIA 27
5.3.2 VNC 30
5
5.3.3 Python 31
5.3.5 Arduino 31
5.3.6 PLC 32
5.3.7 Raspberry pi 33
6. METODOLOGÍA 35
6.1.1 Planeación 35
6.1.2 Diseño 35
6.1.3 Verificación 35
6
8.1.4 Especificaciones Arduino mega 2560 47
9. SISTEMA DE SUPERVISION 53
13. CONCLUSIONES 80
14. RECOMENDACIONES 81
BIBLIOGRAFÍA 82
ANEXOS 85
7
LISTA DE FIGURAS
Figura 5. Raspberry pi 3 34
8
Figura 23. Plano de alimentación 69
9
LISTA DE TABLAS
pág.
Tabla 1. Misión del Proyecto 37
10
LISTA DE ANEXOS
pág.
Anexo A. Métricas vs. Necesidades 85
Anexo B. QFD 86
11
RESUMEN
La pasantía institucional realizada en el Sena Astin se dio con el fin de resolver una
problemática encontrada en el Compresor CAMPBELL HAUSFELD. Su tarjeta de
control, al estar dañada y no poderla conseguir en el país, requería el desarrollo de
un nuevo sistema de control con el fin de lograr la puesta en marcha del compresor.
A partir de una matriz de selección (QFD) se definió la métrica de mayor peso para
el proyecto y con la matriz para evaluar conceptos se optó por el Arduino en conjunto
con la raspberry. El Arduino como maestro, el cual obtendrá los datos de las
variables sensadas (presión y temperatura), además de controlar las salidas y
entradas del compresor; la raspberry trabajará como esclavo, esta tomará los datos
de las variables y por medio de una interfaz brindará una visualización en tiempo
real de los datos, además de avisar cuando se encuentre una falla en el compresor.
12
ABSTRACT
The institutional internship conducted at Sena Astin was given in order to solve a
problem found in the CAMPBELL HAUSFELD Compressor. Your control card, being
damaged and unable to obtain in the country, request the development of a new
control system in order to achieve the start-up of the compressor.
The control system and the implementation for the start-up of the compressor, select
a couple of stages that can be observed throughout the document, these stages are
made up of a planning, design, verification and finally a start-up, this with the in order
to have a correct methodology for the development of the project.
In order to determine the most optimal development of the system, they studied
microcontrollers with which they achieve the correct functioning of the compressor,
in addition to complying with the requirements established by the Seine, among
which is the economy of the same. The microcontrollers studied were: PLC, Arduino,
Raspberry and Pic.
Based on a selection matrix (QFD), the most important metric for the project is
defined and with the matrix to evaluate concepts, the Arduino was chosen in
conjunction with the raspberry. The Arduino as master, which controls the data of
the sensed variables (pressure and temperature), in addition to controlling the
outputs and inputs of the compressor; The raspberry will work as a slave, will take
the data of the variables and through an interface will provide a real-time display of
the data, in addition to warning when it finds a fault in the compressor.
Finally, the wiring is implemented in the control and power board, in order to perform
tests with the compressor, this in order to identify possible failures, once the failures
are identified and verification tests are carried out, the compressor is left in line with
plants that require compressed air.
13
INTRODUCCIÓN
Los compresores son máquinas cuya finalidad es aportar una energía a los fluidos
compresibles (gases y vapores) sobre los que operan, para hacerlos fluir
aumentando al mismo tiempo su presión.1
En los últimos años estos compresores han tenido impactos muy positivos en la
industria, teniendo como fin brindar aire comprimido a los diferentes procesos que
lo requieran, “los compresores se emplean para aumentar la presión de una gran
variedad de gases y vapores para un gran número de aplicaciones, un caso común
es el compresor de aire, que suministra aire a elevada presión para transporte,
pintura a pistola, inflamiento de neumáticos, limpieza, herramientas neumáticas y
perforadoras, otras aplicaciones abarcan procesos químicos, conducción de gases,
turbinas de gas y construcción”2
Los compresores han tenido grandes avances tecnológicos en los últimos años, uno
de ellos es el control neumático mediante lógica digital, la tecnología los ha
posibilitado a que tengan aplicaciones en el maquinado y la construcción,
1 GIMENO, Alberto Alfaro. "Modelado y simulación de compresores", [En linea]. Ingeniería técnica
industrial: mecánica. Madrid España. Universidad Carlos III de Madrid. Facultad de Ingenieria.
Departamento de mecanica, 2009. [Consultado: 11, julio, 2019 ]. Disponible en internet: https://e-
archivo.uc3m.es/bitstream/handle/10016/7714/PFC_Alberto_Alfaro_Gimeno.pdf?sequence=1&isAll
owed=y
14
actualmente las industrias requieren compresores programables y automáticos que
brinden un total control del proceso, obligando a que estos sean más eficientes.
El centro de formación Astin del SENA requiere disponer de aire comprimido para
el funcionamiento de las máquinas y equipos utilizados en la formación de técnicos
y tecnólogos, por lo cual se hace indispensable colocar en funcionamiento el
compresor CAMPELL HAUSFELD.
Este proyecto de grado tiene como fin rediseñar sistema de control del compresor
con precios económicos en el mercado, este es uno de los mayores requerimientos,
además de añadirle parámetros que mejoren el rendimiento del mismo y con ayuda
de un microprocesador realizar una interfaz amigable con el usuario.
15
1. PLANTEAMIENTO DEL PROBLEMA
¿Qué sistema de control sería el más eficiente para el rendimiento óptimo del
compresor de aire CAMPBELL HAUSFELD?
16
2. JUSTIFICACIÓN
Servicios Tecnológicos
Autoconsumo
Formación
Para el año 2019 el centro cuenta con una población de 534 aprendices activos
distribuidos en 39 fichas que se encuentran asociadas a la formación en tecnologías
duras del centro.
3 SENA, Astin. “Portafolio laboratorios Sena Astin” [En línea], Sena 2016. [Consultado: 29, julio, 2019
]. Disponible en internet: https://drive.google.com/file/d/0BwyuZeRCqmtiRmcwWlZNX0Rtelk/view
17
Según el documento “Control de sistema de posicionamiento neumático” de Arias
Osorio los sistemas de adquisición de datos basados en computadora aprovechan
la potencia del procesamiento, la productividad, la visualización y las habilidades de
conectividad de las computadoras estándares en la industria, esto proporciona una
solución de medidas más potente, flexible y rentable”4.
4ARIAS OSORIO, Oscar Eduardo. “Control de sistema de posicionamiento neumático”. [En línea].
Tecnología eléctrica. Pereira Colombia. Universidad Tecnológica de Pereira. Facultad de
Tecnología. Departamento de eléctrica, 2016. [Consultado: 29, julio, 2019 ]. Disponible en internet:
https://core.ac.uk/download/pdf/84108387.pdf
18
3. OBJETIVOS
19
4. ANTECEDENTES
Se dice que el primer “compresor de aire” en realidad es el pulmón del ser humano.
Como el cuerpo humano puede exhalar, nuestros antepasados utilizaron su aliento
para avivar fogatas desde los tiempos más remotos.
Unos pulmones saludables pueden producir solamente de 0.02 a 0.08 bar (1 bar
equivale a 14.5 psi) de presión, por lo que no era suficiente para ayudar a
incrementar la temperatura, además de que el dióxido de carbono que contiene el
aliento humano no ayudaba. La demanda por generar aire a mayor presión comenzó
a incrementar conforme el tiempo pasaba.
En el año 1500 D.C. se inventó el primer compresor de aire que consistía en una
bolsa flexible que al aplastarse producía aire a presión y ayudaba a mantener las
altas temperaturas que necesitaban.
A pesar de que el invento de Smeaton era eficiente para aquel entonces, fue
reemplazado por una maquina inventada por Johm Wilkinson en 1776. Esa máquina
se convertiría en el llamado “borrador” para los compresores mecánicos posteriores,
utilizando una máquina de vapor en una bomba de aire.
20
Los compresores de aire tenían muchas funcionalidades para aquella época, se
empezaron a utilizarse para distintas actividades, como la minería y ventilación de
áreas subterráneas.
Durante el año 1800, la población empezó a utilizar los compresores de aire para
transmitir energía, el aire al estar comprimido genera de cierta manera energía
cinética por el calor de las moléculas al ser espuertas a estar en un menor espacio
o volumen.
21
La figura 1 nos muestra los planes de acción para soluciones óptimas en los
compresores por la empresa Burckhardt Compression, se enfocan en diferentes
alternativas, una es la renovación, se realizan cambios tecnológicos en el compresor
modificando sus capacidades, implementan ingeniería inversa para crear nuevas
soluciones de mejora, también se enfocan en la sustitución del compresor,
reemplazando en su totalidad sus partes, finalmente proceden a realizar una
modernización, optimización, legalización y modificación según lo presente.
22
En la etapa de revisión del estado del arte se encontró un proyecto el cual con la
“implementación del controlador prototipo basado en un microcontrolador, con la
tarjeta se realiza la adquisición de variables para hacer la lectura de datos de los
transductores del sistema del compresor, con la tarjeta de interfaz de potencia se
envía señales de control a los preactuadores para controlar el funcionamiento del
compresor y se programaron los modos de compresión de encendido “dentro y fuera
de línea” y de “modulación” en la compresión”6
6 VARGAS JIMÉNEZ, Mario Alberto. “Diseño e implementación del prototipo de un sistema de control
que simule las funciones de la tarjeta Intellisys en un compresor estacionario Ingersoll Rand”. [En
linea]. Ingenieria Electronica. Costa Rica. Instituto Tegnologica de Costa Rica. Facultad de
Ingenieria. Departamento de electronica, 2007. [Consultado: 20 ,julio, 2019]. Disponible en internet:
https://repositoriotec.tec.ac.cr/bitstream/handle/2238/534/Vargas%20Jimenez%20Mario%20Alberto
.pdf?sequence=1&isAllowed=y
23
disminuir el esfuerzo del compresor, al no estar funcionando en la carga máxima
que puede producir.
Por tal motivo se debe controlar la capacidad del compresor, de manera que
coincida con la carga térmica real que estos producen. Existen varias maneras
comunes de controlar la capacidad (bar o psi) generada del compresor:
24
actualidad o el arranque o la parada de algunos compresores en un sistema de
varios compresores los cuales tienen diferentes formas de procesar.
25
4.3.1.4 Bypass de gas caliente
8 DANFOSS. “Aplicaciones de refrigeración industrial con amoníaco y CO2 ”. [En línea]. Manual de
aplicaciones. 3 de mayo del 2016. [Consultado 03, enero, 2020]. Disponible en internet:
https://assets.danfoss.com/documents/DOC263641649990/DOC263641649990.pdf
26
5. MARCO DE REFERENCIA
Teniendo claro los temas a abordar para entender cada uno de los conceptos
utilizados en el proyecto se toma el concepto de compresor como punto de partida
y a partir de ahí se desglosarán cada uno de los conceptos necesarios para
comprender el desarrollo del proyecto9.
27
entrelazados que rotan paralelamente con un juego o luz mínima, sellado por la
mezcla de aire y aceite.
El aire entra por la válvula de admisión con el aceite y el espacio entre los labios es
progresivamente reducido al correr por el compresor, comprimiendo el aire atrapado
hasta salir por la válvula de salida.
En los compresores a tornillo húmedos los engranajes y tornillos son lubricados por
el aceite que actúa también como sello. Típicamente tienen filtros coalescentes
para eliminar el aceite del aire o gas comprimido.
Los compresores lubricados con inyección de aceite utilizan aceites R&O (resistente
a oxidación por lo que trabaja entre 80° C y 120°C y con aditivos contra la corrosión)
y aceites hidráulicos AW (anti-desgaste). Los engranajes son lubricados por
salpicadura con aceite R&O. Típicamente utilizan viscosidades entre ISO 32 e ISO
68 de acuerdo a la temperatura del ambiente, la velocidad de giro y el tamaño de
sus tornillos y luz10.
28
característica especial es la de mantener al controlador central informado del estado
de las variables para generar acciones correctivas cuando así sea necesario11.
Misión
11 ABARCA, Patricio. “El ABC de la automatización | Sistemas de control automático”. [En línea]. aie
Abril, 2019, p.1. [Consultado 30, julio, 2019 ]. Disponible en internet:
http://www.aie.cl/files/file/comites/ca/abc/sistemas-de-control-automatico.pdf
29
La contribución a la efectiva generación de empleo y la superación de la pobreza.
5.3.2 VNC
12 SENA, Astin, Sub título "Misión y Visión”. [En línea]. Nosotros. 2002. [Consultado 29, julio, 2019].
basado en condición de los compresores reciprocantes y de tornillo”. [En linea]. Ingenieria Mecanica.
Riobamba Ecuador. Escuela Superior Pilitécnica de Chimborazo. Facultad de mecanica.
Departamento de mecanica, 2009. [Consultado: 29, julio, 2019]. Disponible en internet:
http://dspace.espoch.edu.ec/bitstream/123456789/260/3/15T00437.pdf
30
Virtual Network Computing (VNC) es un programa de escritorio remoto de software
libre basado en una estructura cliente-servidor que permite tomar el control del
ordenador servidor remotamente a través de un ordenador cliente.
5.3.3 Python
5.3.5 Arduino
14 VELOSO, Cristian. “Arduino mega 2560 características”. [En línea]. Arduino Mega 2560. 19 de
junio del 2018. [Consultado 03, enero, 2020]. Disponible en internet:
https://www.electrontools.com/Home/WP/2018/06/19/arduino-mega-2560-caracteristicas/
31
Figura 3. Arduino Mega 2560
Fuente: VELOSO, Cristian. “Arduino mega 2560 características”. [En línea]. Arduino
Mega 2560. 19 de junio del 2018. [Consultado 03, enero, 2020]. Disponible en
internet: https://www.electrontools.com/Home/WP/2018/06/19/arduino-mega-2560-
caracteristicas/
5.3.6 PLC
Controlador lógico programable (figura 4), más conocido por sus siglas en inglés
PLC (Programmable Logic Controller), el cual es un instrumento electrónico, que
utiliza memoria programable para guardar instrucciones sobre la implementación de
determinadas funciones, como operaciones lógicas, secuencias de acciones,
especificaciones temporales, contadores y cálculos para el control mediante
módulos de E/S analógicos o digitales sobre diferentes tipos de máquinas y de
procesos15.
32
Figura 4. PLC Festo FC660, Siemens Logo y Simatic S7-200
5.3.7 Raspberry pi
33
Figura 5. Raspberry pi 3
Fuente: MOCQ, François. “La raspberry pi 3”. [En línea]. Raspberry Pi 3 o Pi Zero.
Junio de 2017. [Consultado 04, enero, 2020]. Disponible en internet:
https://www.ediciones-
eni.com/open/mediabook.aspx?idR=9727568be97f6cfbb8f45569b5f90c56
34
6. METODOLOGÍA
6.1.1 Planeación
En esta fase inicial se realiza una revisión de los sistemas de control actualmente
utilizados en los compresores, con las características del compresor Campbell.
Además, la instrumentación utilizada para la medición de las variables físicas
comprometidas en el funcionamiento del compresor. Posteriormente en esta fase
se seleccionan los equipos de medición y control más adecuados y se determinan
los proveedores nacionales de estos equipos.
6.1.2 Diseño
Durante esta etapa una vez adquiridos los elementos y seleccionada la alternativa
de solución, se realizan las simulaciones del control. Se crea la interfaz de usuario
programada, se procede con el diseño, construcción y cableado del tablero de
potencia, tablero de interfaz de usuario y del tablero de control.
6.1.3 Verificación
Con esta etapa se prueba el compresor, con el fin de detectar posibles fallas que
pueda presentar y se comprueba el correcto funcionamiento de los sensores. Una
vez verificado se procede a la elaboración de planos finales y la construcción de
manuales e instructivos.
35
6.1.4 Puesta en marcha
36
7. PLANTEAMIENTO DE LA MISIÓN, IDENTIFICACIÓN DE NECESIDADES Y
ESPECIFICACIONES TECNICAS
37
CRITERIOS DE DISEÑO
MERCADO PRIMARIO
PREMISAS Y RESTRICCIONES
Open source.
38
7.2 IDENTIFICACIÓN DE NECESIDADES
Importancia Peso
Media (importante) 3
N° Necesidad Importancia
1 Es de fácil 1
mantenimiento
2 Seguro para el usuario 3
3 Open source 9
4 Bajo costo de 3
mantenimiento
5 Fácil instalación 1
6 Es de bajo costo 9
39
7 Fácil configuración 1
8 Interfaz de usuario de 9
fácil visualización
9 Robusto para procesos 3
industriales
10 Dispositivo con entradas 9
análogas y digitales en
un mismo equipo
A partir de la tabla se puede observar que las necesidades más importantes para el
Sena-Astin son que la programación sea Open source (código abierto), que sea un
dispositivo de bajo costo, que pueda tener una interfaz de usuario y que contenga
tanto entradas digitales como análogas en un mismo equipo.
1 Costo $ 4,6
17 OLSINA, Luis. “Métricas e Indicadores: Dos Conceptos Claves para Dos Conceptos Claves para
Medición y Evaluación”. [En línea]. Grupo de Investigación y Desarrollo en Ingeniería de Software.
Argentina. Universidad Nacional de La Pampa Universidad Nacional de La Pampa. Facultad de
ingeniería. Departamento de informática, 2003. [Consultado 05, enero, 2020]. Disponible en internet:
http://www.ciw.cl/recursos/Charla_Metricas_Indicadores.pdf
40
3 Nivel de seguridad Norma IEC 2
61508, EN
671518
4 Pasos para # 1
mantenimiento
5 Durabilidad de los Años 4,9
componentes
6 Peso Kg 5
7 Tiempo de Min 7
configuración
8 Cantidad de entradas # 10
análogas y digitales
9 Capacidad de trabajo Min 9,4
continuo
10 Cantidad de pasos # 8
para visualización
41
un producto muy económico se puede presentar un problema con la capacidad de
trabajo para largas jornadas, así mismo el tiempo de configuración depende de la
cantidad de entradas y salida del dispositivo la selección tiene que tener los
requisitos de activación necesarios para el control sin necesidad de adicionar más
módulos.
Su bajo costo y fácil manejo para proyectos, además de sus múltiples entradas y
salidas análogas y digitales, permitieron seguir con la implementación del sistema
de control, el Arduino será el maestro, al tener todo el código de control del
compresor, será el que lea las entradas del compresor, entre las cuales están
presión y temperatura, estas lecturas de los sensores se enviaran vía serial a la
Raspberry la cual procesara los datos por medio de Python, en ella se realizara la
interfaz de supervisión.
42
8. DESARROLLO DEL SISTEMA DEL CONTROL
Para el desarrollo del sistema de control del compresor de la figura 6, fue de total
importancia realizar ingeniería inversa de la tarjeta de control figura 7, en la que se
leyeron los manuales e instructivos, para así identificar cada parte que la componía,
tanto de software como de hardware.
43
Inicialmente se realiza el Grafcet para el proceso principal, anexo E, el cual es un
diagrama de control por etapas y transiciones, en él se identifica el proceso que se
tiene que llevar acabo para realizar el control del compresor, inicialmente se realiza
una verificación de los sensores de temperatura y presión, en donde se identifica 7
posibles estados, tabla 5.
En el Grafcet del anexo F se pueden observar las fallas del sistema. El interruptor
de PARO DE EMERGENCIA, al activarse apaga de inmediato la válvula de
admisión y el motor en el estado que se encuentre, para iniciar de nuevo el proceso
se tiene que presionar el pulsador de RESET.
44
Tabla 5. Estados de verificación
Para poder manejar estos datos de corriente dentro del Arduino se realizó un
circuito, figura 8, una vez adecuada la entrada de datos al Arduino, se realizó una
45
adquisición de datos entrada vs salida de temperatura, esto con el fin de realizar
una ecuación característica. El anexo I nos muestra las tablas que se realizaron
para obtener la ecuación lineal y la gráfica correspondiente a dicha caracterización.
El Arduino Mega 2560 es una tarjeta de desarrollo de Hardware libre construida con
el microcontrolador Atmega 2560, el cual le da sentido a su nombre. Este
microcontrolador forma parte del proyecto Arduino que involucra una comunidad
internacional dedicada al diseño y manufactura de placas de desarrollo de Hardware
Open source.
46
El Arduino es un de los primeros que logro su objetivo de facilitar y relacionar de
manera simple y didáctica la programación de microcontroladores y electrónica, dos
áreas que en la ingeniería son muy complejas.
Existen varios diseños de tarjetas diferentes dependiendo su uso, entre ellas se
encuentra el Arduino Mega 2560 que cuenta con una serie de características que
en función del proyecto que necesitemos realizar pueden ser una ventaja.
Microcontrolador: ATmega2560.
47
Pines análogos de entrada: 16.
SRAM: 8KB.
EEPROM: 4KB.
Es Open source.
Cada canal es controlado por una entrada TTL, la cual puede ser fácilmente
controlada por un microcontrolador o Arduino. Esta placa requiere de una
alimentación de 5V, para ello se adecuo una fuente externa que generaba a partir
de una entrada de 220v Ac una salida de 12v DC y 5v DC.
48
8.2.1 Características relé de 8 canales
Led indicador para cada canal (enciende cuando la bobina del relé esta activa).
Para el accionamiento del motor se hizo uso contactores de relé a 24v 3 polos 150A,
que permitieron el arranque del motor trifásico de manera óptima, se hizo uso en
total de 3 contactores, uno para el arranque de línea, otra para el cambio a estrella
y finalmente para el cambio a delta, esto con el fin de disminuir su corriente nominal
en el arranque del motor.
49
Tabla 6. Elementos empleados para el sistema de control
Elementos de control
Descripción Fotografía
CONTROLADOR ARDUINO
MEGA 2560: es una tarjeta
electrónica programable que
permite la creación rápida de
prototipos. Su diseño es de código
abierto. Es el controlador del
proceso, el cual recibe las señales
de los sensores, las procesa a
través de un programa realizado
previamente, y posteriormente
envía la señal a los actuadores,
quienes realizan los movimientos
respectivos.
TARJETA DE RELEVOS–8
CANALES: recibe las señales de
baja potencia de salida del arduino,
y a través del relé, permite manejar
cargas de mayor corriente, como la
electroválvula y los contactores.
SENSORES DE TEMPERATURA
– TERMOCUPLA TIPO K: Detecta
la temperatura del aceite, el
transmisor, convierte la señal de la
termocupla en una señal
proporcional de 4 a 20 mA.
50
Tabla 6. (continuación)
SENSOR DE PRESION
ANALOGO (4 – 20mA): Es el
encargado de detectar la presión
de carga del compresor, lee una
señal entre 0 y 16 bar, escalada
entre 4 a 20 mA, la cual es
convertida a través de una
resistencia de 250 Ohm, en una
señal de 0 -5v, leida por el arduino.
ELECTROVALVULA DE
ADMISION MONOESTABLE:
Permite a través de una señal
eléctrica, dar apertura a la entrada
de aire para la carga del
compresor.
CONTACTORES: Son
accionamientos eléctricos,
empleados para energizar el motor
principal, realizando el arranque
estrella – delta.
51
Tabla 6. (continuación)
INTERRUCTOR DE PARA DE
EMERGENCIA: Se maneja con
dos interruptores, uno normamente
cerrado y otro normalmente
abierto.
52
9. SISTEMA DE SUPERVISION
53
El anexo K, muestra el código implementado en código Python, la interfaz gráfica
se realizó por medio de la librería Tkinter que cuenta con una serie de componentes
gráficos llamados Widgets, con los cuales podemos diseñar nuestras interfaces.
Los widgets deben seguir una jerarquía a la hora de añadirse a la interfaz. Por
ejemplo, un Marco (frame) forma parte del objeto raíz Tk. Y a su vez, un botón
(button) puede formar parte de un contenedor como la raíz o un marco.
Tk: Contenedor base o raíz de todos los widgets que forman la interfaz. No tiene
tamaño propio, sino que se adapta a los widgets que contiene.
Frame: Marco contenedor de otros widgets. Puede tener tamaño propio y
posicionarse en distintos lugares de otro contenedor (ya sea la raíz u otro marco).
Label: Etiqueta dónde podemos mostrar algún texto estático.
Entry:
Campo de texto sencillo para escribir texto corto. Nombres, apellidos,
números.
Text: Campo de texto multilínea para escribir texto largo. Descripciones,
comentarios.
Button: Botón con un texto sobre el cual el usuario puede hacer clic.
Radiobutton: Botón radial que se usa en conjunto donde es posible marcar una
opción.
Checkbutton: Botón cuadrado que se puede marcar con un tic.
Menu: Estructura de botones centrados en la composición de menús superiores.
Dialogs: Ventanas emergentes que permiten desde mostrar información al usuario
(típico mensaje de alerta o de confirmación) hasta ofrecer una forma gráfica de
interactuar con el sistema operativo (seleccionar un fichero de un directorio para
abrirlo).
54
Hay otros widgets, pero estos son los más importantes19.
Paso 1:
• hdmi_mode=1 VGA
19 HEKTOR, PROFE, “Interfaz gráfica con Tkinter”. [En línea]. Interfaz con tkinter. 4 de octubre del
2018. [Consultado 12, enero, 2020]. Disponible en internet:
https://docs.hektorprofe.net/python/interfaces-graficas-con-tkinter/
55
• hdmi_mode=14 480p 60Hz.
$sudo reboot
Paso 1:
56
sudo apt-get update
sudo apt-get install realvnc-vnc-server
sudo apt-get install realvnc-vnc-viewer
Paso 2:
Sudo raspi-config
Una vez escrito el comando se muestra una pantalla figura 10, se presiona opciones
de interfaz y nos sale lo siguiente figura 11, se debe habilitar VCN y presionar
finalizar, una vez finalizado se conecta se puede acceder a la raspberry vía remota
con los pasos a continuación.
57
Figura 11. Habilitación VCN
Nombre: compresor
Clave: compresor
Por defecto la Raspberry ya estará conectada a dicha red, de no ser así, se debe
encender el modo Wifi, dando click en el icono de red, ubicado en la esquina
superior derecha de la pantalla. TURN ON WIFI.
58
Tabla 7. Pasos para acceso remoto Raspberry pi
Abrir vcn viewer en la pantalla touch, del tablero de control y anotar la dirección de
red que aparece en pantalla.
59
Tabla 7. (continuación)
Al ingresar la
Raspberry te pide
una clave de
acceso, la cual
es:
Usuario: pi
Clave:
compresor
60
Tabla 7. (continuación)
Deberías tener
acceso a la
raspberry,
observaras que
desde el
computador
podras acceder a
todos los
comandos de
esta.
Una vez
ingresado se
puede cerrar el
vnc viewer.
61
10. SISTEMA DE CONTROL Y POTENCIA
62
Figura 13. Cableado tablero de control
63
Figura 14. Descripción general tablero de control
64
Figura 16. Componentes de seguridad tablero de control
65
Figura 18. Descripción general tablero de potencia
66
Figura 21. Conexión sensores compresor
67
11. PLANOS FINALES Y PUESTA EN MARCHA DEL COMPRESOR
68
Figura 23. Plano de alimentación
En la figura 24 se observa las entradas que serán dirigidas al Arduino entras las
cuales encontramos el pulsador de Start, Stop, Reset, el interruptor de emergencia
y el contactor NA del relé térmico, también se tiene los transmisores de corriente,
temperatura y presión.
69
Figura 24. Plano de entradas del Arduino
La figura 25 nos muestra el plano de salidas del Arduino, las salidas son 8 y van
conectadas al relé de 8 canales para así poder manejar potencia, las salidas se
dividen en 3 indicadores led (Estado OK, Estado pre alarma y Estado de
emergencia), contactor de línea, contactor de estrella, contactor de delta, secadora
y válvula de admisión.
70
Figura 25. Plano salidas de control
71
Figura 26. Plano relevos y potencia
72
Figura 27. Plano conexiones Raspberry
73
Figura 28. Plano borneras del tablero de control
74
Figura 29. Plano borneras del tablero de potencia
Pasos Fotografía
75
Tabla 8. (continuación)
3. Desactivar el paro de
emergencia, si esta
pulsado.
4. Pulsar RESET
5. Pulsar START
6. El script de Python
ejecutado quedó
guardado en el escritorio
con el nombre de:
Interfazsenavdefinitiva.p
y, al darle doble clic al
archivo se ejecutar el
scrip.
76
Tabla 8. (continuación)
7. Posteriormente se le
debe dar en play para
ejecutarlo.
8. Se observará en la
pantalla los estados
iniciales de los sensores,
que estarán entre los
siguientes rangos:
Presión: -2 a 0.5 bar
Temperatura: 25 a 35
ºC.
Tiempos de carga: 0
Tiempo total: 0
Estado alarma:
ESTADO OK
Estado compresor:
PULSE START
77
12. RELACIÓN COSTO BENEFICIO SENA-ASTIN
Del total de la maquinaria del Sena-Astin, el 60% requiere aire comprimido para sus
procesos, por lo tanto, del total de ingresos que se generan se le debita el 40%.
En la tabla 10 se puede observar el gasto que tuvo el proyecto, detallando cada uno
de los materiales comprados.
Costo total
Nº Material cantidad costo unidad
materiales
78
Tabla 10. (continuación)
Termocupla
6 tipo K 2 $ 35.000 $ 70.000
7 Raspberry pi 3 1 $ 170.000 $ 170.000
9 Pantalla LCD 1 $ 100.000 $ 100.000
10 Fuente dual 1 $ 150.000 $ 150.000
Tablero De
11 control 1 $ 950.000 $ 950.000
12 Breaker 10A 2 $ 40.000 $ 80.000
13 Borneras 100 $ 300 $ 30.000
Cable
14 instrumentación 50 $ 2.000 $ 100.000
15 Pulsadores NA 3 $ 25.000 $ 75.000
Interruptor de
16 emergencia 1 $ 50.000 $ 50.000
TOTAL
COSTOS $ 2.099.000
79
13. CONCLUSIONES
80
14. RECOMENDACIONES
81
BIBLIOGRAFÍA
82
Madrid. Facultad de Ingenieria. Departamento de mecanica, 2009. [Consultado: 11,
julio, 2019 ]. Disponible en internet: https://e-
archivo.uc3m.es/bitstream/handle/10016/7714/PFC_Alberto_Alfaro_Gimeno.pdf?s
equence=1&isAllowed=y
HEKTOR, PROFE, “Interfaz gráfica con Tkinter”. [En línea]. Interfaz con tkinter. 4 de
octubre del 2018. [Consultado 12, enero, 2020]. Disponible en internet:
https://docs.hektorprofe.net/python/interfaces-graficas-con-tkinter/
MOCQ, François. “La raspberry pi 3”. [En línea]. Raspberry Pi 3 o Pi Zero. Junio de
2017. [Consultado 04, enero, 2020]. Disponible en internet: https://www.ediciones-
eni.com/open/mediabook.aspx?idR=9727568be97f6cfbb8f45569b5f90c56
OLSINA, Luis. “Métricas e Indicadores: Dos Conceptos Claves para Dos Conceptos
Claves para Medición y Evaluación”. [En línea]. Grupo de Investigación y Desarrollo
en Ingeniería de Software. Argentina. Universidad Nacional de La Pampa
Universidad Nacional de La Pampa. Facultad de ingeniería. Departamento de
informática, 2003. [Consultado 05, enero, 2020]. Disponible en internet:
http://www.ciw.cl/recursos/Charla_Metricas_Indicadores.pdf
SENA, Astin. “Portafolio laboratorios Sena Astin” [En línea],Sena 2016. [Consultado:
29, julio, 2019 ]. Disponible en internet:
https://drive.google.com/file/d/0BwyuZeRCqmtiRmcwWlZNX0Rtelk/view
83
TOAPANTA CUNALATA, Oscar Gabriel. “Implementación de un an}alisis de
mantenimiento basado en condición de los compresores reciprocantes y de tornillo”.
[En linea]. Ingenieria Mecanica. Riobamba Ecuador. Escuela Superior Pilitécnica de
Chimborazo. Facultad de mecanica. Departamento de mecanica, 2009.
[Consultado: 29, julio, 2019]. Disponible en internet:
http://dspace.espoch.edu.ec/bitstream/123456789/260/3/15T00437.pdf
VELOSO, Cristian. “Arduino mega 2560 características”. [En línea]. Arduino Mega
2560. 19 de junio del 2018. [Consultado 03, enero, 2020]. Disponible en internet:
https://www.electrontools.com/Home/WP/2018/06/19/arduino-mega-2560-
caracteristicas/
84
ANEXOS
85
Anexo B. QFD
86
Anexo E. Grafcet proceso principal del compresor
87
Anexo F. Grafcet de fallos del sistema
88
Anexo H. Código de control Arduino
89
float voltaje_sensor_I = 0.0;
float corriente_flotante = 0.0;
float I = 0.0;
float corriente_flotante_visual = 0.0;
float sensibilidad_corriente = 0.185;
float potencia_flotante = 0.0;
//-------- declaracion de variables de envio de datos
char cadena1[7]; // cadena para envio de datos temperatura
char cadena2[7]; // cadena para envio de datos presion.
char cadena3[7]; // cadena para envio de datos presion.
int i = 0; // iterador ciclo for de lectura de sensores
float x[] = {0.0, 0.0}; // arreglo para el envio de datos de temperatura
float y[] = {0.0, 0.0}; // arreglo para el envio de datos de presion.
float z[] = {0.0, 0.0}; // arreglo para el envio de datos de corriente.
// declaracion vaiables de tiempo
unsigned long t = 0;
unsigned long duracion = 0;
unsigned long Ttotal = 0;
//-----------------------------------------------
// declaración de nombres a los pines de entrada digital
const int START = 53; // Inicia secuencia encendido, entrada digital arduino
const int STOP = 49; // Detiene secuencia, entrada digital arduino
const int RESET = 45; // Resetea alarmas
const int PARO = 41; // 1 contacto NO : Entrada digital para el arduino
const int TERMICO = 37; // 1 contacto NO : Entrada digital para el arduino
// declaración de nombres a los pines de salida
const int CONTACT_LINEA = 13; // Contactor linea - Motor
const int CONTACT_ESTRELLA = 12; // Contactor Estrella - Motor
const int CONTACT_DELTA = 11; // Contactor Delta - Motor
const int VALVU_ADMISION = 10; // Valvula de admision
const int SECADORA = 9; // SECADORA
const int PILOTO_OK = 8; // PILOTO_OK
90
const int PILOTO_PREALARMA = 7; // Piloto indicador de estado PRE ALARMA -
No detiene el ciclo
const int PILOTO_ALARMA = 6; // Piloto indicador de estado ALARMA - Detiene
el ciclo
//decalaracion variable volátiles – estado de entradas
bool estado_START = true; //estado START.
bool estado_STOP = true; //estado STOP - Interrupciones
bool estado_RESET = true; //estado RESET.
bool estado_PARO = true; //estado PARO - Interrupciones
bool estado_TERMICO = true; //estado TERMICO. - Interrupciones
// declaración de otros estados booleanos
// variables de temperatura
bool TEMP_OK = false;
bool TEMP_PREALARMA = false;
bool TEMP_ALARMA = false;
bool HABILITAR_TEMP = false;
// variables de presion:
bool PRESION_BAJA = false;
bool PRESION_NOMINAL = false;
bool PRESION_PREALARMA = false;
bool TIEMPO_DELTA = false;
bool TIEMPO_PREARRANQUE = false;
// variables habilitacion condiciones:
bool SENSORES_OK = false;
bool PROTECCIONES_OK = true;
bool PRESION_ALARMA = false;
bool HABILITAR_PRESIONES = false;
// variables de Tiempos:
bool TIEMPO_ESTRELLA = false;
// variables indicadores de estados pilotos:
bool ESTADO_OK = false;
bool ESTADO_PREALARMA = false;
bool ESTADO_ALARMA = false;
91
//banderas de inicio
bool INICIO = false;
bool INI_CICLO = false;
bool FUNCIONAR = false;
// declaración de etapas booleanas
bool ETP0 = false;
bool ETP1 = false;
bool ETP2 = false;
bool ETP3 = false;
bool ETP4 = false;
bool ETP5 = false;
bool ETP6 = false;
bool ETP7 = false;
bool ETP8 = false;
bool ETP_STOP = false;
bool ETP_FALLA = false;
// variables de condicion para cambio de etapas:
bool CARGA_CONTINUA = false;
bool PRESION_CARGA = false;
bool HABILITAR_ARRANQUE = false;
bool PREARRANQUE = false;
//-------------------------------------------------------------------------
void setup() {
// Abre puerto serial
Serial.begin(9600);
Serial.print("0.0");
Serial.print(",");
Serial.print("0.0");
Serial.print(",");
Serial.print("0.0");
Serial.print(",");
Serial.print("0");
Serial.print(",");
92
Serial.print("0");
Serial.print(",");
Serial.print("0");
Serial.print(",");
Serial.print("0");
Serial.println(",");
// declaracion de pines como entradas
pinMode(START, INPUT_PULLUP);
pinMode(STOP, INPUT_PULLUP);
pinMode(RESET, INPUT_PULLUP);
pinMode(PARO, INPUT_PULLUP);
pinMode(TERMICO, INPUT_PULLUP);
// declaracion de pines como salida
pinMode(CONTACT_LINEA, OUTPUT);
pinMode(CONTACT_ESTRELLA, OUTPUT);
pinMode(CONTACT_DELTA, OUTPUT);
pinMode(VALVU_ADMISION, OUTPUT);
pinMode(PILOTO_OK, OUTPUT);
pinMode(PILOTO_PREALARMA, OUTPUT);
pinMode(PILOTO_ALARMA, OUTPUT);
pinMode(SECADORA, OUTPUT);
// declaracion interrupciones en pines STOP y PARO.
//attachInterrupt(digitalPinToInterrupt(STOP), parada,LOW);
//attachInterrupt(digitalPinToInterrupt(PARO),emergencia,LOW);
//attachInterrupt(digitalPinToInterrupt(TERMICO),termico,FALLING);
//Ejecuto condiciones iniciales
// Deshabilito todas las banderas booleanas
//variable volátiles – estado de entradas
estado_START = true; //estado START.
estado_STOP = true; //estado STOP - interrupciones
estado_RESET = true; //estado RESET.
estado_PARO = true; //estado PARO - interrupciones
estado_TERMICO = true; //estado TERMICO - interrupciones
93
// variables de temperatura
TEMP_OK = false;
TEMP_PREALARMA = false;
TEMP_ALARMA = false;
HABILITAR_TEMP = false;
// variables de presion:
PRESION_BAJA = false;
PRESION_NOMINAL = false;
PRESION_PREALARMA = false;
PRESION_ALARMA = false;
HABILITAR_PRESIONES = false;
// variables de Tiempos:
TIEMPO_ESTRELLA = false;
TIEMPO_DELTA = false;
TIEMPO_PREARRANQUE = false;
// variables habilitacion condiciones:
SENSORES_OK = false;
PROTECCIONES_OK = true;
// variables indicadores de estados pilotos:
ESTADO_OK = false;
ESTADO_PREALARMA = false;
ESTADO_ALARMA = false;
//banderas de inicio
INICIO = false;
INI_CICLO = false;
FUNCIONAR = false;
// declaración de estado compresor
fallo="ESTADO OK";
proceso = "PULSE START";
// declaración de etapas booleanas
ETP0 = false;
ETP1 = false;
ETP2 = false;
94
ETP3 = false;
ETP4 = false;
ETP5 = false;
ETP6 = false;
ETP7 = false;
ETP8 = false;
ETP_STOP = false;
ETP_FALLA = false;
// variables de condicion para cambio de etapas:
CARGA_CONTINUA = false;
PRESION_CARGA = false;
HABILITAR_ARRANQUE = false;
PREARRANQUE = false;
// apago todas las salidas
digitalWrite(CONTACT_LINEA, HIGH); // Apaga contactor linea
digitalWrite(CONTACT_ESTRELLA, HIGH); // Apaga contactor estrella
digitalWrite(CONTACT_DELTA, HIGH); // Apaga contactor delta
digitalWrite(VALVU_ADMISION, HIGH); // Apaga valvula admision
digitalWrite(SECADORA, HIGH); // Apaga SECADORA
digitalWrite(PILOTO_OK, HIGH); // Apaga piloto OK
digitalWrite(PILOTO_PREALARMA, HIGH); // Apaga piloto PREALARMA
digitalWrite(PILOTO_ALARMA, HIGH); // Apaga piloto ALARMA
delay(50); // espera 50 milisegundos
}
//---------------------------------------------------------------
void loop() {
INICIO:
// Comienza conteo de segundos:
Ttotal = millis();
// llamado a subrutina de lectura de entradas de sensores:
Lecturaentradas();
delay(10);
// Envio a subrutina de impresiones
95
impresiones();
// Verificacion de condiciones:
HABILITAR_TEMP = (TEMP_OK || TEMP_PREALARMA); // Variable que
habilita la continuacion del proceso por temperaturas
delay(10); // espera 10 milisegundos
HABILITAR_PRESIONES = (PRESION_BAJA || PRESION_NOMINAL); // Variable
que habilita la continuacion del proceso por presion
delay(10); // espera 10 milisegundos
SENSORES_OK = (HABILITAR_PRESIONES && HABILITAR_TEMP); // Bandera
que habilita el inicio de ciclo, cuando las presiones y las temperaturas estan OK.
delay(10); // espera 10 milisegundos
// verificacion estados:
ESTADO_OK = (TEMP_OK && HABILITAR_PRESIONES); // Variable de
todo OK
delay(10); // espera 10 milisegundos
ESTADO_PREALARMA = (TEMP_PREALARMA || PRESION_PREALARMA); //
Variable de prealarma
delay(10); // espera 10 milisegundos
ESTADO_ALARMA = (TEMP_ALARMA || PRESION_ALARMA); // Variable de
alarma
delay(10); // espera 10 milisegundos
// lee entradas digitales:
estado_START = digitalRead(START); //lea estado Pulsador START
estado_STOP = digitalRead(STOP); //lea estado Pulsador STOP
estado_RESET = digitalRead(RESET); //lea estado Pulsador RESET
estado_PARO = digitalRead(PARO); //lea estado Pulsador PARO
estado_TERMICO = digitalRead(TERMICO); //lea estado TERMICO
delay(50); // espera 50 milisegundos
if (estado_STOP == false) {
ETP_STOP = true;
fallo="STOP";
goto STOP;
}
else if (estado_PARO == false) {
96
ETP_FALLA = true;
fallo="PARO";
//Serial.println("PARO");
goto FALLA;
}
else if (estado_TERMICO == false ) {
ETP_FALLA = true;
fallo="TERMICO";
//Serial.println("TERMICO");
goto FALLA;
}
else {
//////
}
INI_CICLO = (!estado_START || PREARRANQUE);
PROTECCIONES_OK = (estado_PARO && estado_TERMICO); // Nunguna de las
protecciones pueden estar activadas. termico o paro
FUNCIONAR = (INI_CICLO && SENSORES_OK); // Bandera que habilita
el inicio de ciclo.
97
else if (ESTADO_PREALARMA == true) { // prealarma por temperatura
digitalWrite(PILOTO_OK, HIGH); // apaga piloto OK
digitalWrite(PILOTO_PREALARMA, LOW); // Enciende piloto de prealarma
digitalWrite(PILOTO_ALARMA, HIGH); // Apaga piloto de alarma
delay(50); // espera 50 milisegundos
}
else if (ESTADO_ALARMA == true || PROTECCIONES_OK == false ) { //
PROTECCIONES es false, por que ni el termico (97-98), ni el paro de emergencia(3-
4), pueden estar en false, o sea accionados
digitalWrite(PILOTO_OK, HIGH); // apaga piloto OK
digitalWrite(PILOTO_PREALARMA, HIGH); // Apaga piloto de prealarma
digitalWrite(PILOTO_ALARMA, LOW); // enciende piloto de alarma
ETP_FALLA = true; //activa la etapa de falla
ETP1 = false; //desactiva la etapa 1
ETP2 = false; //desactiva la etapa 2
ETP3 = false;
ETP4 = false;
ETP5 = false;
ETP6 = false;
ETP7 = false;
ETP8 = false;
ETP_STOP = false;
PREARRANQUE = false; // deshabilita el prearranque
CARGA_CONTINUA = false;
delay(50); // espera 50 milisegundos
}
else {
///
}
// inicia ciclo
if (INICIO == true && HABILITAR_ARRANQUE == true) {
98
proceso="INICIADO"; // INICIADO
//-----------------------
// ciclo for para reemplazar delay de 20 seg - Tiempo entre el encendido de la
secadora y el compresor
for (int i = 0; i < 180; i++) { // 180 x 10 ms x 10ms(lecturas) = 18000ms = 9seg +
tiempos de maquina = 20 seg
Ttotal = millis();
Lecturaentradas();
impresiones();
estado_STOP = digitalRead(STOP); //lea estado Pulsador STOP
estado_PARO = digitalRead(PARO); //lea estado Pulsador PARO
estado_TERMICO = digitalRead(TERMICO); //lea estado TERMICO
delay(70); // espera 70 milisegundos
if (estado_STOP == false) {
ETP_STOP = true;
fallo="STOP";
goto STOP;
}
else if (estado_PARO == false) {
ETP_FALLA = true;
fallo="PARO";
//Serial.println("PARO");
goto FALLA;
}
99
}
Ttotal = millis();
Lecturaentradas();
impresiones();
estado_STOP = digitalRead(STOP); //lea estado Pulsador STOP
estado_PARO = digitalRead(PARO); //lea estado Pulsador PARO
estado_TERMICO = digitalRead(TERMICO); //lea estado TERMICO
delay(70); // espera 70 milisegundos
if (estado_STOP == false) {
ETP_STOP = true;
fallo="STOP";
goto STOP;
100
}
}
//delay(4000); // espera 4 segundos - Transicion estrella - delta
TIEMPO_ESTRELLA = true; // Tiempo estrella - Delta.
//Serial.println("etapa2");
ETP1 = false; //desactiva la etapa 1
delay(20); // espera 20 milisegundos
101
delay(2000); // espera 2 segundos antes de encender valvula
de admision
102
for (int i = 0; i < 30; i++) { // reemplaza el delay de 5 seg
proceso="EN VACIO"; // visualice EN VACIO
Ttotal = millis();
Lecturaentradas();
delay(50);
impresiones();
estado_STOP = digitalRead(STOP); //lea estado Pulsador STOP
estado_PARO = digitalRead(PARO); //lea estado Pulsador PARO
estado_TERMICO = digitalRead(TERMICO); //lea estado TERMICO
delay(70); // espera 70 milisegundos
if (estado_STOP == false) {
ETP_STOP = true;
fallo="STOP";
goto STOP;
}
103
//delay(5000); // espera 5 segundos, con la valvula de admision
apagada - en descarga
//-----------------DECISION--------------
//Serial.println("etapa6");
if (estado_STOP == false) {
ETP_STOP = true;
fallo="STOP";
104
goto STOP;
}
}
//delay(180000); // espera 180 segundos
TIEMPO_PREARRANQUE = true; // activa bandera de tiempo prearranque
105
else if (ETP5 == true && PRESION_BAJA == true) {
//-------------------------------------------------
else {
// no hace nada
}
106
//////////
STOP:
if (ETP_STOP == true) {
//Serial.println("STOP");
fallo="STOP";
Ttotal = millis();
Lecturaentradas();
delay(50); // retardo para mitiar ruido de motor en vacio
impresiones();
estado_PARO = digitalRead(PARO); //lea estado Pulsador PARO
estado_TERMICO = digitalRead(TERMICO); //lea estado TERMICO
delay(70); // espera 70 milisegundos
if (estado_PARO == false) {
ETP_FALLA = true;
fallo="PARO";
//Serial.println("PARO");
goto FALLA;
}
107
ETP_FALLA = true;
fallo="TERMICO";
//Serial.println("TERMICO");
goto FALLA;
}
}
digitalWrite(CONTACT_LINEA, HIGH); // Apaga contactor linea
digitalWrite(CONTACT_ESTRELLA, HIGH); // Apaga contactor estrella
digitalWrite(CONTACT_DELTA, HIGH); // Apaga contactor delta
digitalWrite(SECADORA, HIGH); // Apaga Secadora
delay(50); // espera 50 milisegundos
// variables de Tiempos:
TIEMPO_ESTRELLA = false;
TIEMPO_DELTA = false;
TIEMPO_PREARRANQUE = false;
108
ETP7 = false;
ETP8 = false;
ETP_STOP = false;
ETP_FALLA = false;
// variables de condicion para cambio de etapas:
CARGA_CONTINUA = false;
PRESION_CARGA = false;
HABILITAR_ARRANQUE = false;
PREARRANQUE = false;
fallo="ESTADO OK";
proceso="PULSE START"; // Visualizacion: PULSE START
}
else {
// no hace nada
}
//////////
FALLA:
if (ETP_FALLA == true) {
while (true) {
//Serial.print("etapa falla");
Ttotal = millis();
Lecturaentradas();
delay(10);
impresiones();
delay(50);
// apago todas las salidas
digitalWrite(CONTACT_LINEA, HIGH); // Apaga contactor linea
digitalWrite(CONTACT_ESTRELLA, HIGH); // Apaga contactor estrella
digitalWrite(CONTACT_DELTA, HIGH); // Apaga contactor delta
digitalWrite(VALVU_ADMISION, HIGH); // Apaga valvula admision
digitalWrite(SECADORA, HIGH); // Apaga Secadora
digitalWrite(PILOTO_OK, HIGH); // apaga piloto OK
digitalWrite(PILOTO_PREALARMA, HIGH); // Apaga piloto de prealarma
109
digitalWrite(PILOTO_ALARMA, LOW); // enciende piloto de alarma
// variables de Tiempos:
TIEMPO_ESTRELLA = false;
TIEMPO_DELTA = false;
TIEMPO_PREARRANQUE = false;
110
estado_RESET = digitalRead(RESET); //lea estado Pulsador RESET
delay(10);// espera 10 milisegundos
if (estado_RESET == false) {
fallo="ESTADO OK";
proceso="PULSE START"; // Visualizacion: PULSE START
ETP_FALLA = false; //desactiva la etapa FALLA
delay(50); // espera 50 milisegundos
break;
}
}
}
else {
// no hace nada
}
void Lecturaentradas() {
i = 0;
for (i = 0; i <= 1; i++) {
// leo temperatura
temperatura = get_temperatura(20);
//temperatura_entera = int(temperatura_flotante);
//x[i] = temperatura_entera; // asigna la temperatura al arreglo x
x[i]=temperatura;
// leo PRESIONES
presion = get_presion(20);
//presion_entera = int(presion);
111
//y[i] = presion_entera; // asigna la presion al arreglo en entero.
y[i]=presion;
// Leo corriente
I = get_corriente(20); //obtenemos la corriente promedio de 500 muestras
//corriente_entera = int(I);
// organizo en cadenas
////////////////////
//// COMPARACION////
112
}
else if ((temperatura > 85.0) && (temperatura <= 105.0)) { // MODO PRE ALARMA
= No detiene el ciclo
TEMP_OK = false;
TEMP_PREALARMA = true;
TEMP_ALARMA = false;
delay(10); // espera 10 milisegundos
}
else if (presion_flotante > 7.0 && presion_flotante < 10.0 ) { // MODO PRESION
NOMINAL - Presion nominal entre 7 y 9.5 bar
PRESION_BAJA = false;
PRESION_NOMINAL = true;
PRESION_PREALARMA = false;
113
PRESION_ALARMA = false;
delay(10); // espera 10 milisegundos
}
PRESION_BAJA = false;
PRESION_NOMINAL = false;
PRESION_PREALARMA = true;
PRESION_ALARMA = false;
delay(10); // espera 10 milisegundos
}
PRESION_BAJA = false;
PRESION_NOMINAL = false;
PRESION_PREALARMA = false;
PRESION_ALARMA = true;
delay(10); // espera 10 milisegundos
fallo="SOBRE PRESION";
}
else {
////
}
//////////////////////////////////
void impresiones() {
114
Serial.print(cadena1);
Serial.print(",");
Serial.print(cadena2);
Serial.print(",");
Serial.print(cadena3);
Serial.print(",");
Serial.print((duracion / 1000) / 60);
Serial.print(",");
Serial.print((Ttotal / 1000) / 60);
Serial.print(",");
Serial.print(fallo);
Serial.print(",");
Serial.print(proceso);
Serial.println(",");
//Serial.println(presion_flotante);
//Serial.print(",");
//Serial.println(I);
115
corriente = corriente / n_muestras;
return (corriente);
}
}
presion_flotante = presion_flotante / n_muestras;
return (presion_flotante);
}
//ajuste promedio de temperaturas
116
}
////}
117
Anexo K. Código sistema de supervisión
'''
Jean Breitner Mora Galvis
Universidad Autonoma de Occidente
SENA-ASTIN
2150913
'''
#!/usr/bin/env python3
#Se importan las librerias
import serial #Libreria para la transmision de datos
from tkinter import messagebox # Libreria para interfaz grafica
from tkinter import* # Libreria para interfaz grafica
import tkinter as tk # Libreria para interfaz grafica
from PIL import Image # se importa una imagen en tkinter
from time import sleep # Libreria para fijar tiempos de espera
import numpy as np # Libreria para crear vectores y matrices
import time
import subprocess
#-------------------------------------------------------------------------------------
''' Se crea un funcion para salir de la interfaz grafica, con el metodo destroy() '''
def quit():
root.destroy()
subprocess.call(['shutdown', '-h', 'now'], shell=False)
#------------------------------------------------------------------------------------------------------------
----------------------------------
#Funcion principal
def update():
#Se definin una variables iniciales para cada valor que llega desde arduino
temp=0.0
118
presion=0.0
corriente=0.0
tcarga=0
ttotal=0
falloc=0
procesoc=0
# Ciclo infinito
while 1:
#Se realiza una excepcion inicial para cualquier tipo de falla en el ingreso de
datos
try:
''' Se Selecciona el puerto que va a transmitir la comunicacion serial y la
velocidad de transmision, esta debe ser igual a la de arduino
'''
#Se realiza una excepcion secundaria para cualquier tipo de falla en el
ingreso de datos en la comunicacion
try:
ser = serial.Serial('/dev/ttyACM0',baudrate=9600,timeout=None)
#ser = serial.Serial('/dev/ttyACM0',baudrate=9600, stopbits =
STOPBITS_ONE, timeout=None)
#ser=serial.Serial('/dev/cu.usbmodem14201',baudrate=9600,timeout=None)
except:#Si presenta fallas en la lectura del puerto este manda un mensaje
de error en la comunicacion
print("ESPERANDO LA CONEXION SERIAL")
119
#El metodo split pertenete a la libreria numpy,
#esta divide en vectores por cada coma que llegue,
#esto queda guardado en datos
datos = val.split(",")
#Se realiza una ultima excepcion en la funcion para cualquier tipo de falla en
el ingreso de datos ya sea por tamaño o valores erroneos
try:
120
#Toma de datos lo que este en la posicion 3 y lo asigna
#a la variable tiempocarga
timepocarga=datos[3]
121
tcarga = timepocarga
ttotal = tiempototal
falloc = fallo
procesoc = proceso
122
#------------------------------------------------------------------------------------------------------------
----------------------------------
'''
Se realiza la interfaz grafica mediante la libreria Tkinter
'''
root=tk.Tk() # Asignacion del maestro denominado root este tendra todos los
contenidos de Tkinter
#root.overrideredirect(True) # Inhabilita el cierre de la interfaz de manera normal
'''
Se crea la geometria de la interfaz se le asigna el tamaño de
pantalla completa
'''
#root.geometry("{0}x{1}+0+0".format(root.winfo_screenwidth(),root.winfo_screenhe
ight()))
root.geometry("{0}x{0}+0+0".format(root.winfo_screenwidth(),root.winfo_screenhei
ght()))
#root.geometry("1500x1000+0+0")
photo2 = PhotoImage(file='fondo1.png')# Se carga una imgagen tipo png y se le
asigna a una variable
photo = Label(root,image=photo2, bg='snow') #Muestra la imagen en la pantalla
photo.pack() # Deja la imagen con el tamaño predefinido de la pantalla
root.title("Datos de variables COMPRESOR CAMPBELL HAUSFELD") # Se le
asigna un titulo
'''
Se crean diferentes cuadros de texto los cuales se les asignan
variables que se posicionan dentro de la interfaz, asignandoles
tamaño, fondo, tipo de letra y color de letra.
'''
lblhvar=Label(text="COMPRESOR CAMPBELL HAUSFELD ",
bg="snow",fg="black",font=("Times new Roman",25)).place(x=500,y=20)
lbltemp=Label(text="PRESION---------------------------->",bg="snow",
fg="black",font=("Times new Roman",25)).place(x=400,y=80)
123
lblpres=Label(text="Temperatura------------------------->", bg="snow",
fg="black",font=("Times new Roman",25)).place(x=400,y=160)
lblcorriente=Label(text="Corriente----------------------------->", bg="snow",
fg="black",font=("Times new Roman",25)).place(x=400,y=240)
lbltcarga=Label(text="Tiempo carga------------------------>",bg="snow", fg="black",
font=("Times new Roman",25)).place(x=400,y=340)
lblttotal=Label(text="Tiempo total------------------------->", bg="snow",
fg="black",font=("Times new Roman",25)).place(x=400,y=430)
lblalarma=Label(text="ESTADO ALARMA---------------
>",bg="snow",fg="black",font=("Times new Roman",25)).place(x=400,y=520)
lblestado_comp=Label(text="ESTADO COMPRESOR---------
>",bg="snow",fg="black",font=("Times new Roman",25)).place(x=400,y=610)
'''
Otros cuadros de texto en este caso las unidades a sensar
'''
lblcentigrados=Label(text="BAR ", bg="snow", fg="black",font=("Times new
Roman",25)).place(x=1100,y=80)
lblbar=Label(text="C. ", bg="snow", fg="black", font=("Times new
Roman",25)).place(x=1100,y=150)
lblbar=Label(text="A", bg="snow", fg="black", font=("Times new
Roman",25)).place(x=1100,y=250)
lbltiempocarga=Label(text="Min ", bg="snow", fg="black",font=("Times new
Roman",25)).place(x=1100,y=340)
lbltiempototal=Label(text="Min ", bg="snow", fg="black",font=("Times new
Roman",25)).place(x=1100,y=430)
'''
Las varibles que anteriormente se setearon se convierten en tipo
cadena, esto con el fin de meterlas en los cuadros de texto
'''
readingt=StringVar()
readingp=StringVar()
readingc=StringVar()
readingtc=StringVar()
readingtt=StringVar()
124
readingfc=StringVar()
readingpc=StringVar()
'''
Se crean nuevos cuadros de textos, mediante el metodo textvariable
se les asigna las variables anteriormente mencionados de tipo cadena,
se posicion dentro de la pantalla, asignandoles igualmente un
tamaño, fondo, tipo de letra y color de letra.
'''
lbltemp=Label(root,textvariable=readingp,font=("Times New
Roman",25),fg="blue",bg="snow").place(x=900,y=80)
lblpres=Label(root,textvariable=readingt,font=("Times New
Roman",25),fg="blue",bg="snow").place(x=900,y=150)
lblcorriente=Label(root,textvariable=readingc,font=("Times New
Roman",25),fg="blue",bg="snow").place(x=900,y=250)
lbltcarga=Label(root,textvariable=readingtc,font=("Times New
Roman",25),fg="blue",bg="snow").place(x=900,y=340)
lblttotal=Label(root,textvariable=readingtt,font=("Times New
Roman",25),fg="blue",bg="snow").place(x=900,y=430)
lblalarma=Label(root,textvariable=readingfc,font=("Times New
Roman",25),fg="blue",bg="snow").place(x=870,y=520)
lblestado_comp=Label(root,textvariable=readingpc,font=("Times New
Roman",25),fg="blue",bg="snow").place(x=870,y=610)
'''
Mediante el metodo after se esta actualizando y llamando constantemente
a la funcion update para que esta actualiza el valor de las variables
'''
root.after(1,update)
'''Se crea un boton llamado salir, mediante command llama la funcion quit
y se sale de la interfaz, igualmente se posiciona en un lugar dentrode la interfaz
'''
b1=Button(root,text='APAGAR',command=quit,fg="blue2", bg='white',font=("Times
new Roman",25)).place(x=50,y=600)
#Se mantiene en un ciclo infinito con el fin que se mantenga la interfaz
root.mainloop()
125
Anexo L. Diseño 3d tablero de control
126
Anexo M. Cotización empresa DISH Ingeniería
e $ -
f $ -
g $ -
h $ -
i $ -
j $ -
k $ -
TOTAL: $ 993.650,00
INSTALACIONES ELECTRICAS COMERCIALES E INDUSTRIALES BAJO NORMATIVA
RETIE Y NTC2050, AUTOMATIZACION INDUSTRIAL, INSTRUMENTACION.
127