Abstract

In this report the importance of automation in the industry, as well as the control of processes and automatic control systems will be exposed; In the same way, the development of the project will be explained, the implementations that were used, the type of components that were used, the technologies used, among others...

Resumen

En el presente informe se expondrá la importancia de la automatización en la industria, así como el control de procesos y sistemas de control automáticos; de igual manera, se explicará el desarrollo del proyecto, las implementaciones que se hicieron, el tipo de componentes que se utilizaron, las tecnologías empleadas, entre otras...

Video 1. Explicando la implementacion realizada. Video 2. Planta o proceso controlado

Introducción

A partir de la inventiva, experiencia y demás virtudes que el hombre posee a podido generar miles de soluciones a sus problemas cotidianos, si unimos parte de estas virtudes con la necesidad de mejorar, ser más competitivo, reducir al máximo su participación en los trabajos pesados y generar para sí mismo mayores beneficios, encontramos soluciones tan creativas y a la vez tan avanzadas que nos permiten eliminar por un instante los limites que el hombre como ser racional posee.

En medio de su afán por mejorar sus producciones, conseguir mayores beneficios, y ser mejor cada día, el hombre de la mano de la tecnología, grandes investigaciones y una infinidad de posibilidades ha logrado crear sistemas automáticos, que de una u otra manera han hecho más fácil y a la vez más productiva la vida del hombre.

Dentro de las grandes posibilidades que se tiene a partir de lo existente, cualquier aparato, mecanismo o sistema es apto para sufrir modificaciones de este tipo, basta únicamente con aplicar conceptos de las ciencias básicas, con conceptos más nuevos, tecnológicos y de gran alcance.

Sistemas de cualquier tipo como mecánico, eléctrico, neumático, etc. son aquellos que sitúan dentro de la escala de evolución tecnológica al humano en cada espacio de tiempo, siendo cada uno de estos sistemas en la vida cotidiana del hombre indispensables para su funcionamiento normal dentro de cualquier ámbito.

La Automatización Industrial es la aplicación de diferentes tecnologías para controlar y monitorear un proceso, maquina, aparato o dispositivo que por lo regular cumple funciones o tareas repetitivas, haciendo que opere automáticamente, reduciendo al mínimo la intervención humana.

Lo que se busca con la Automatización industrial es generar la mayor cantidad de producto, en el menor tiempo posible, con el fin de reducir los costos y garantizar una uniformidad en la calidad.

La Automatización Industrial es posible gracias a la unión de distintas tecnologías, por ejemplo la instrumentación nos permite medir las variables de la materia en sus diferentes estados, gases, sólidos y líquidos, (eso quiere decir que medimos cosas como el volumen, el peso, la presión etc.), la olehidraulica, la neumática, los servos y los motores son los encargados del movimiento, nos ayudan a realizar esfuerzos físicos (mover una bomba, prensar o desplazar un objeto), los sensores nos indican lo que está sucediendo con el proceso, donde se encuentra en un momento determinado y dar la señal para que siga el siguiente paso, los sistemas de comunicación enlazan todas las partes y los Controladores Lógicos Programables o por sus siglas PLC se encargan de controlar que todo tenga una secuencia, toma decisiones de acuerdo a una programación pre establecida, se encarga de que el proceso cumpla con una repetición, a esto debemos añadir otras tecnologías como el vacío, la robótica, telemetría y otras más.

figura1 controldeprocesos
Figura 1. Control de procesos

La Automatización Industrial la encontramos en muchos sectores de la economía, como en la Fabricación de Alimentos, Productos Farmacéuticos, Productos Químicos, en la Industria Gráfica, Petrolera, Automotriz, Plásticos, Telecomunicaciones entre otros, sectores en los cuales generan grandes beneficios. No solo se aplica a maquinas o fabricación de productos, también se aplica la gestión de procesos, de servicios, a manejo de la información, a mejorar cualquier proceso que conlleven a un desempeño más eficiente, desde la instalación, mantenimiento, diseño, contratación e incluso la comercialización.

Es por ello que la importancia de la automatización industrial, es reconocida hoy en día, en los ámbitos gerenciales y operativos dentro de la industria manufacturera moderna, sobre todo en la Comunidad Europea, como un elemento clave en el crecimiento y desarrollo de las naciones.

Bajo costo

A pesar de que el costo de implementación de máquinas y software, pude resultar en primera instancia, el retorno de la inversión es rápido y seguro. Una vez la compañía ha recuperado la inversión realizada en automatización, los Empresarios percibe que los costes de producción se reducen en forma drástica, si se tiene en cuenta que un robot puede llegar a realizar la labor de varios trabajadores, sin afectar rubros de presupuesto tales como, seguridad social, vacaciones, bonificaciones, prestaciones sociales etc.

Seguridad operativa

Una de las mayores preocupaciones de las grandes empresas, y que a la vez nos ayuda a entender la importancia de la automatización industrial, es la necesidad de mantener la excelencia en los procesos de producción, para asegurar productos certificados, sin incurrir en riesgos de accidentalidad laboral, que, todos los sabemos, son uno de los mayores costes que tienen las industrias del siglo XXI que no han sido objeto de procesos de automatización.

Figura2SistemadeAutomatizacionIndustrial
Figura 2. Sistema de automatizacion Industrial.

Como proceso, la automatización se compone de tres fases, el ingreso de datos, el procesamiento de dichos datos, la salida y ejecución de los mismos.

En el ingreso de datos se encuentra que pueden ser operados por pulsadores, perillas, accionadores, así como las variables de entrada pueden ser de tipo físico como temperaturas, presión, humedad, etc. El manejo de estas variables permiten al operador o programador, generar una serie de características a un programa para que cumpla luego de ser analizadas las funciones requeridas por programador. Así por ejemplo a partir del ingreso a un sistema de un nivel de temperatura, el programador puede usar esta variable física como señal de inicio para efectuar un proceso automático, como lo es la calefacción.

De acuerdo a lo anterior observamos como a partir de fenómenos naturales se puede llegar a dar solución a un problema dentro de la cotidianidad del hombre, es por ello que desde que existan dichas variables y la inventiva del hombre cualquier tipo de sistema, proceso o equipo puede ser fácilmente automatizado.

Durante el procesamiento de las entradas, y mediante el uso de tecnologías como la computación, los procesadores, etc., el hombre decodifica dichas entradas en lenguajes entendibles para la màquina, esto hace que haya un cambio de datos sin perder el fin al que se quiere llegar, así por ejemplo al recibir del exterior una temperatura x el sistema determina mediante programaciones anteriores que tipo de procedimiento debe seguir para ejecutar una acción.

Así pues si el procesador tiene como variable definida una temperatura de 20 grados como nivel de referencia, al ingresar una variable exterior, como por ejemplo 30° grados el procesador realizara a nivel interno una serie de acciones como comparar, ajustar, verificar ambas señales, una vez realizadas estas acciones determinara cual es la mejor solución, a partir de las necesidades del hombre. De esta manera el sistema de calefacción puede determinar que es momento de activar un sistema aparte que genere una similitud entre las variables.

Sin duda este momento es de vital importancia en cualquier sistema automatizado, pues de la preparación previa de la programación dependen en gran medida los resultados esperados.

Por último encontramos la salida de datos o ejecución de órdenes, después de haber realizado los procesos propios del análisis de datos de entrada y luego de encontrar una respuesta y solución al problema, el sistema mediante algún tipo de comunicación transmite sus conclusiones a sistemas generalmente de tipo mecánico, como lo son actuadores, motores, etc. A partir de este momento se evidencia en el espacio un cambio favorable a las condiciones iniciales de estado en el ambiente propuesto.

Sin duda dichos sistemas mecánicos que no son más que parte de la inventiva antigua del hombre, hacen posible después de una serie de pasos el poder contar con resultados eficientes a problemas cotidianos.

Figura3SistemaDeControlAutomatico
Figura 3. Sistema de Control Automático.

Este es en sí el principio y razón de ser de los sistemas automatizados, son sin lugar a dudas una de las grandes invenciones del hombre, pues generan en todo sentido mayores beneficios, menos pérdidas de tiempo y grandes contribuciones hacia el desarrollo futurista de la humanidad.

Sistemas de control Escalables

La planta o proceso “Sistema elevador clasificador para paquetes” es un sistema de control que hemos adaptado para que sea escalable y flexible con respecto a las implementaciones y aplicaciones utilizadas.

Cuando la ISA (Sociedad para los Sistemas de Instrumentación y la Automatización, por sus iniciales en inglés) definió la norma ANSI/ISA-S88-01-1995 hace más de diez años, creó un lenguaje y unos modelos comunes para el diseño y la especificación de los sistemas de control para el procesamiento por lotes. Para los fabricantes de maquinaria, ya sometidos a las presiones habituales para que suministren máquinas más flexibles, más rápidamente y con menores costes, la norma presagiaba una notable reducción de la complejidad en el diseño de sistemas.

Conocida hoy en día simplemente como S88, la norma ANSI/ISA-S88.01-1995, su equivalente en la Comisión Internacional de Electrotécnica (IEC 61512-01) y las posteriores ampliaciones de la norma han allanado el camino para que los fabricantes de maquinaria puedan hacer un uso óptimo de los sistemas modulares con el fin de reducir los costes. Además, han eliminado la necesidad de escribir código personalizado para cada aplicación, reduciendo así los plazos de desarrollo, y han permitido la reutilización del código escrito para un sistema en sistemas posteriores, con independencia de la escala y la complejidad.

Por lo tanto, los fabricantes de maquinaria se benefician de una reducción de los plazos de comercialización gracias a los equipos estandarizados, las reutilizaciones eficaces del código, los controles escalables y las plataformas de información procedentes de redes de distribución de primera fila.

Creada en 1995, la norma trazó el camino a seguir en el desarrollo de sistemas de control por lotes (batch), definiendo modelos y terminología para la planta física, procedimientos y fórmulas de un proceso por lotes. La norma ha evolucionado con los años: En 2001 se publicó ANSI/ISA-88.00.02-2001, que trata sobre la estructura de los datos y las directrices para los lenguajes, y en 2004 vio la luz ANSI/ISA-88.00.03-2004, que trata de los modelos y representaciones de fórmulas generales y de plantas.

Además, de la norma S88 derivó la S95 para la integración de sistemas de control empresarial, que definía una terminología común para la descripción y comprensión de la información sobre fabricación en una empresa. También define el intercambio de información entre las funciones de control de fabricación y otras funciones de la empresa, incluidos los modelos de datos y las funciones de intercambio.

Entonces, ¿qué implica exactamente para los fabricantes de maquinaria trabajar para las industrias de transformación? El objetivo de los equipos de control por lotes para la industria de transformación es ser capaz de fabricar muchos productos con el mismo equipo, o llevar a cabo diferentes operaciones en el mismo producto, sin necesidad de realizar grandes reconfiguraciones manuales del equipo de producción y sin tener que reescribir el software de control por lotes, una tarea potencialmente costosa y que lleva tiempo.

El modelo S88 de planta física define el equipo en función de celdas de proceso. Cada una de ellas contiene el equipo necesario para la producción de uno o más lotes.

Una celda de proceso se compone de todas las unidades: conjuntos de equipos de proceso, equipos de control y la lógica de control asociada que realiza las actividades de procesamiento.

Las capacidades básicas de procesamiento de la unidad pueden definirse mediante «módulos de equipo» y estos definen qué puede hacer una fórmula a la unidad, generalmente acciones como incorporaciones de material, transferencias de material, calentar o enfriar un recipiente, presurizar un recipiente y mezclar materiales en un recipiente. La norma S88 desglosa aún más los módulos de equipo en módulos de control, que son una combinación de la lógica básica de control y los diversos sensores y accionadores dentro de la unidad.

El efecto de todo ello es definir la gestión de las fórmulas jerárquicas y los marcos de segmentación de procesos que materializan el objetivo de separar los productos en fabricación de los equipos que los fabrican, y así permitir a los fabricantes disfrutar de importantes mejoras de la productividad.

Se puede usar el mismo equipo para fabricar múltiples productos o para realizar diferentes operaciones en un producto dado, con un desarrollo y despliegue sencillo de la fórmula y sin necesidad de contar con ingenieros especializados en sistemas de control.

Esto reduce de forma efectiva el coste total del diseño, desarrollo y suministro a través de una menor intervención de la ingeniería de proyectos (diseño, programación, cableado, ensayos, instalación, asistencia técnica), un ahorro de energía escalable y modular y sistemas abiertos de control e información de automatización.

El resultado es que los fabricantes de maquinaria pueden reducir espectacularmente los plazos de diseño de sistemas y suministrar soluciones de mayor capacidad y flexibilidad a los clientes con mayor rapidez. Al no tener que confiar en software y hardware personalizado, los costes del proceso de desarrollo se reducen drásticamente y las aplicaciones posteriores son más fáciles y rápidas de implantar.

En resumen, la S88 redefinió la forma en que se podían construir sistemas de control por lotes haciendo posible un enfoque modular del diseño de sistemas. Sin embargo, lo que de verdad ha hecho posible la materialización de los objetivos de la S88 es la llegada de herramientas informáticas estándar combinadas con equipos estándar, escalables y «llave en mano». Los fabricantes de maquinaria tienen por fin las herramientas que necesitan para construir sistemas de control por lotes de cualquier tamaño y nivel de complejidad para cualquier sector, de forma rápida y rentable.

Figura4SistemasDeCOntrolEscalables
Figura 4. Sistema de Control Escalable ó Sistema de Control Distribuido SCS/DSC.

Al diseñar un sistema de control automático, nuestra mayor satisfacción es el saber que funciona de manera adecuada y sin percances sobre su ejecución, a raíz de mejorar la estabilidad en el funcionamiento de los sistemas de control automático, nace la necesidad de un constante monitoreo del sistema, este monitoreo consiste en darse cuenta si el proceso se está ejecutando de manera correcta, ya sea confirmando el estado del sistema personalmente o analizando su estatus por medio de un panel que permita su control ante algún evento, por esto vemos la necesidad de implementar un SCS “Scalable Control System o Sistema de Control Escalable” que permite amoldarse a cualquier entorno de control automático en producción y analizar en RT su funcionamiento utilizando tecnologias OpenSource tanto en Hardware como en Software.

Planta o Proceso a controlar:

Sistema Elevador clasificador para paquetes

El proceso se inicia con el transporte de uno de los paquetes a la báscula; una vez clasificado el paquete en la báscula, se encenderá una luz indicadora del tipo de paquete (luz 1 será paquete grande y luz 2 será paquete pequeño). A continuación, el paquete es transportado por la cinta 1 hasta el plano elevador. El cilindro C eleva los paquetes. Acto seguido los paquetes son clasificados; los paquetes pequeños son colocados en la cinta 2 por el cilindro A, y los paquetes grandes son colocados en la cinta 3 por el cilindro B. el cilindro elevador C se recupera sólo cuando los cilindros A y B llegan a la posición final. El sistema contará con botones locales de stop, start y reinicio; los cuales también aparecerán en la HMI, en donde se mostrará las fases del proceso y llevará la cuenta de los paquetes grandes y pequeños.

planta
Figura 5. Sistema Elevador Clasificador de paquetes.

Objetivo.

Implementar un Sistema de Control Escalable con tecnologías Open Source basado en la arquitectura de los DCS, que permita interactuar en tiempo real con el sistema controlado.

rex_rexcontrolpi_diagram
Figura 6. DSC basado en Raspberry, implementacion hecha para el proyecto

Objetivos Generales.

  • Simular un entorno o proceso de control automático el cual estará monitoreado y controlado. Este entorno estará adaptado a pruebas de error en la ejecución del sistema para probar el funcionamiento del SCS.
  • Entender los diferentes tipos de protocolos permitidos para controlar dispositivos “IoT” y sensores.
  • Aplicar las técnicas necesarias para linealizar los datos de los sensores a monitorear.
  • Analizar las herramientas disponibles para diseñar el Dashboard.
  • Interfazar todos los dispositivos que componen el SCS.
  • Diseñar el Frontend o Panel de control.
  • Publicar el SCS en la nube monitoreando el sistema.

Componentes del sistema:

Componentes de software del SCS

Parte 1: Construcción del Hardware del sistema

A continuación, se empezará a dar solución al Proyecto “Sistema elevador clasificador para paquetes”.

En primer lugar, se hizó el planeamiento de cómo serìa construida la planta (arquitectura) del sistema. Luego de esto, se empezó a diseñar la idea teniendo en cuenta madera Triplex como el principal material de la maqueta del proyecto.

En segundo lugar, debido a que después de que las cajas pasan de la banda 0 hacia la báscula de pesaje, nos dimos cuenta de que debíamos diseñar las bandas transportadoras con alturas diferentes para que las cajas cayeran de la primer banda hacia el sensor de peso. Entonces, se decidió que la prmera banda debería ser levemente más alta que la segunda, esto debido a que necesitabamos que se creara un cambio de sectores, es decir, era necesario que el objeto transportado pasara de la cinta 0 al sensor de peso. Seguidamente, y después de tener la idea del material, era hora de empezar a construir, primeramente, las bandas transportadoras ya que estas nos podían determinar las dimensiones que tendría todo el sistema.

Figura7Mediciondelsisde-odelasbandastransportadoras
Figura 7. Medicion y diseño de las bandas transportadoras.

Acto seguido, depués de que se hicieron las dimensiones de la primer banda, se decidió hacer todas las bandas con las mismas dimensiones, para hacerlas más uniformes.

Figura8Construcciondelasdiferentesbandastranspotadorasdelsistema
Figura 8. Construcción de las diferentes bandas transportadoras del sistema.

Llegado a este punto, y después de haber hecho el esqueleto de todas las bandas, ya era hora de decidir la altura que llevaran cada una de éstas, adicionar el soporte de la cinta, agregar el hule que es el que servirá para que el objeto sea transportado a través de toda la planta.

Con respecto al diseño de las cintas, se hizo la cinta 0 relativamente más alta que la báscula y la cinta 1, esto para que halla una transicion de ésta al sensor. Luego, el sensor; después de sensar y determinar si el peso corresponde a una caja grande o pequeña; por medio de un servo-motor, envía una señal que hace que gire la plataforma en la que se encuentra en objeto a pesar para que éste pase a la siguiente banda.

Figura9Adicciondelsoporte
Figura 9. Adicion del soporte para las bandas.

Figura10AdiciondelHulealascintastransportadoras
Figura 10. Adicion del Hule para las bandas.

Figura11Dise-oFinaldelaBanda
Figura 11. Diseño final de la banda transportadora.

Luego de adicionar el soporte y el hule, se procedió a colocar el motor que servirá para que la banda gire (esto se hizo nuevamente a cada una de las cintas restantes).

Llegado a este punto, se empezó a diseñar el elevador que servirá para elevar los objetos a las demás bandas, las cuales será las correspondieste a las cajas pequeñas y grandes.

figura12DiseoyContruccionfinaldelelevadordepaquetes
Figura 12. Diseño y construccion final del elevador.

Por otra parte, luego de haber construido el elevador de paquetes era necesario la Implementación de lo que serán los cilindros que son los que clasificarán los paquetes, ya sean grandes o pequeños.

figura13Acoplamientodetodoslossectoresquecomponenelsistema
Figura 13. Acoplamiento de todos los sectores que componen el sistema.

Para terminar esta primer parte de la contrucción de la maqueta del sistema era importante la Implementación del sistema de clasficación de paquetes. Para ello, se hizo uso de servomotes con acoples que permites que al generar un PWM, éstos harán que un brazo actue sobre las cajas hacienda que éstas se dirijan hacia la cinta A o la cinta B.

figura14sistemaclasificadorparapaquetesimplementadopormediodeservomotoresyacoplamientodelosbrazosclasificadores
Figura 14. Acoplamiento de los brazos clasificadores.

Parte 2: Implementacion electronica y logica de control para el proceso

Luego de concluir con la contrucción de la parte del hardware del sistema de elevación clasificación para paquetes, era hora de empezar a diseñar, programar e implementar la parte de la electrónica y el software que controlarán todos los procesos que se requieran en el proyecto.

Primeramente, se decidió usar la Raspberry Pi v3, como servidor de aplicacion WEB sobre el cual se enviarán todos los datos correspondientes al monitoreo y control del proceso que se llevará a cabo en el sistema.

Luego de ésto, se implemento un modulo WIFI ESP8266 el cual se comunica con la Raspberry inalámbricamente por medio del servidor de aplicación MQTT, enviando los datos acerca del pesaje, clasificación, control manual de inicio, parada y reinicio del sistema y visualización de la planta en tiempo real.

Instalando Raspbian en Raspberrypi3.

Raspbian es un sistema operativo basado en GNU/Linux el cual ha sido compilado para arquitecturas ARM es mantenido por una de las comunidades mas fuertes "Debian el Sistema Operativo Universal".

desde la página principal, podemos ver las versiones actuales disponibles
Raspbian escoger la versión mas reciente del sistema.

Para nuestro ambiente de trabajo, tenemos Deepin GNU/Linux Basado en Debian instalado sobre la Laptop 13Z940.
Descargamos el Sistema Operativo

# wget https://downloads.raspberrypi.org/raspbian_lite_latest

Descomprimimos el archivo que ha sido descargado previamente como zip.

# unzip 2017-04-10-raspbian-jessie.zip</code>

Confirmamos que se ha desempaquetado correctamente el archivo de imagen sobre el directorio actual

# ls -lh | grep raspbian
-rw-r--r-- 1 heberth heberth 1,3G abr 10 10:58 2017-04-10-raspbian-jessie-lite.img

Montando el Sistema Operativo

Asumimos que tenemos una MicroSD que ha sido formateada con anterioridad en el formato FAT32, si no se tiene es necesario hacerlo para poder continuar

Conectamos la MicroSD físicamente a nuestro Computador
Confirmamos que la MicroSD ha sido reconocida como dispositivo y ha sido montada sobre el Sistema Operativo

# dmesg
[19074.892402] mmc0: new high speed SDHC card at address 0001
[19074.892787] mmcblk0: mmc0:0001  7.50 GiB 
[19074.894089]  mmcblk0: p1

Confirmamos el dispositivo sobre el cual se ha montado la MicroSD sobre el Sistema Operativo

# df -h
/dev/mmcblk0p1   7,5G   4,0K  7,5G   1% /media/heberth/MEM

El dispositivo ha sido montado sobre la unidad /dev/mmcblk0p1 el cual no es la primera partición del dispositivo, es una partición que se crea como secundaria al instante en el que se ha formateado la MicroSD, cuando se monta la memoria y se corre el comando dmesg este me indica cual es la primera partición que hace referencia al dispositivo, el cual sera la partición sobre la cual montaremos el Sistema Operativo.
confirmamos la existencia de la partición primaria.

$ ls -l /dev/mmcblk0
brw-rw---- 1 root disk 179, 0 abr 26 12:19 /dev/mmcblk0

Desmontamos la partición que ha sido montada sobre el sistema operativo

$ sudo umount /dev/mmcblk0p1

Accedemos al directorio sobre el cual descargamos y descomprimimos la Imagen del Sistema Operativo.

$ cd Descargas/

Montamos La imagen descargada con anterioridad sobre la partición principal de la memoria

$ sudo dd bs=4M if=2017-04-10-raspbian-jessie-lite.img of=/dev/mmcblk0 && sync
309+1 registros leídos
309+1 registros escritos
1297862656 bytes (1,3 GB, 1,2 GiB) copied, 249,949 s, 5,2 MB/s
real	4m9.958s
user	0m0.008s
sys	0m1.516s

Extraemos la MicroSD de nuestro Computador, la conectamos a la raspberry a un monitor vía HDMI y confirmamos que el Sistema Operativo arranca adecuadamente.


Figura 15. Arranque de Raspberry pi.

Configurando la distribución de teclado

Al momento de ingresar al sistema, normalmente la distribución de teclado no es la adecuada, en nuestro caso la distribución que debemos de configurar es español "es"

editamos el archivo de configuración /etc/default/keyboard y agregamos el tipo de teclado

$ sudo nano /etc/default/keyboard 

buscamos la linea XKBLAYOUT="gb" y cambiamos lo que esta dentro de "" por nuestra distribución de teclado "es", guardamos y reiniciamos el sistema.

Conectando la Pi a una red Wi-Fi

Como el Sistema Operativo que hemos seleccionado para la raspberry no tiene administración gráfica, todas las configuraciones que realicemos sobre esta, serán en modo CLI, es necesario tener unos conocimientos básicos de Sistemas Operativos Basados en Kernels Linux y tener un poco de manejo de BASH para profundizar en nuestro Sistema.

Accedemos al sistema vía Clic, Buscamos las redes Inalámbricas disponibles cercanas al dispositivo

$ sudo iwlist wlan0 scan

Identificamos la red inalámbrica a la cual nos vamos a conectar, para esta prueba nos conectaremos a la siguiente red:
ESSID: "MiWifi"

Password: "MiPass"

Seguridad: WPA2 Version

editamos el archivo de configuración el cual se encarga de asociar el sistema a una red Wi-Fi conocida cuando este se inicia.

$ sudo nano /etc/wpa_supplicant/wpa_supplicant.conf

agregamos las lineas de configuración para la red que vamos a asociar a nuestra raspberry y guardamos el archivo.

network={
    ssid="MiWifi"
    psk="MiPass"
    priority=1
    id_str="Home"
}

reiniciamos la raspberry, una vez reiniciada confirmamos que se haya conectado a la red Wi-Fi y que el servidor DHCP de la red haya asignado una dirección IP valida para el rango de la red LAN

$ sudo ifconfig

Direc. inet:192.168.2.124  Difus.:192.168.2.255  Másc:255.255.255.0

Actualizando Raspbian...

una vez realizada la configuración de la red Wi-Fi podremos actualizar la cache de repositorios y confirmar si existen actualizaciones disponibles sobre el dispositivo.

Actualizamos cache de repositorios

$ sudo apt-get update

Actualizamos el Sistema Operativo Completo

$ sudo apt-get dist-upgrade

Habilitando conexiones Remotas Via SSH.

El protocolo SSH, es utilizado para comunicaciones remotas seguras, este software puede instalarse fácilmente con un comando, pero en este caso no lo vamos a instalar, ya que viene instalado por defecto sobre la versión de Raspbian que hemos instalado con anterioridad.

Subimos el servicio ssh al inicio del sistema.

$ sudo systemctl enable ssh.service

Reiniciamos la raspberry pi, confirmamos que el servicio ssh se haya levantado al inicio del sistema

$ sudo systemctl status ssh.service 
● ssh.service - OpenBSD Secure Shell server
   Loaded: loaded (/lib/systemd/system/ssh.service; enabled)
   Active: active (running) since Wed 2017-04-26 22:35:54 UTC; 1min 42s ago
 Main PID: 696 (sshd)
   CGroup: /system.slice/ssh.service
           ├─696 /usr/sbin/sshd -D
           ├─792 sshd: pi [priv]
           ├─798 sshd: pi@pts/0
           ├─800 -bash
           ├─837 sudo systemctl status ssh.service
           └─841 systemctl status ssh.service

Confirmamos el puerto que se ha abierto con la conexión sobre el dispositivo y validamos que en realidad sea el puerto de nuestro servicio ssh.

$ netstat -nta

tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN
tcp6       0      0 :::22                   :::*                    LISTEN

nos conectamos a la IP remota sobre el servicio de ssh desde nuestro computador de pruebas via SSH.

$ ssh pi@192.168.2.124

Instalando Node-RED en Raspberry Pi

Node-RED es una herramienta de programacion basada en Flows, editor de flujos con tecnologias basadas en APIs para conectar dispositivos de Hardware del Internet de las Cosas "IoT" https://nodered.org/, Documentacion https://nodered.org/docs/
Cuando realizamos la instalacion de Raspbian en una version Full o completa, Node-RED ya viene preinstalado sobre esta, pero si estamos es utilizando la version Lite de Raspbian, tendremos que realizar la instalacion de Node-RED por medio del siguiente Script, si queremos revisar la guia detallada de la instalacion sobre Raspberry Pi podemos visitar la siguiente URL

bash <(curl -sL https://raw.githubusercontent.com/node-red/raspbian-deb-package/master/resources/update-nodejs-and-nodered)

Una vez instalado Node-RED, podemos hacer que el servicio arranque al inicio del Sistema Operativo por medio de la siguiente instruccion

$ sudo systemctl enable nodered.service

Reiniciamos la Raspberry y confirmamos que el servicio se ha alzado al inicio del sistema

$ sudo systemctl status nodered

statusnodered
Figura 16. Status de Node-RED en Raspberry Pi V3.

Accedemos por medio de un PC conectado a la misma red LAN a la direccion IP de la raspberry, en este caso hemos agregado el nombre del host al servidor DNS local para darle resolucion al dispositivo
http://scspi:1880/
Node-RED-GUI
Figura 17. Panel de programacion Node-RED.

para el proyecto, hemos instalado algunos nodos adicionales, los cuales fueron utilizados para la creacion del DashBoard

  • node-red-contrib-os
  • node-red-contrib-usbcamera
  • node-red-dashboard

Node-REd-Instalacion-nodosAdicionales
Figura 18. Instalacion de paletas adicionales en Node-RED.

Adicional, para que la camara web que se conecte al sistema la cual monitorea la planta en tiempo real, es necesario instalar unas libreria la cual controlara las fotos que tomara la camara.

sobre la raspberry ejecutar:

sudo apt-get install fswebcam

Node-red interactua con los ficheros que el usuario configura creando un directorio estatico para todo el contenido http que se utiiza sobre el flow.

Es necesario configurar el archivo settings.js hubicado en la ruta
"/home/pi/.node-red"

sudo nano /home/pi/.node-red/settings.js

buscar la linea httpStatic: '/home/pi/Pictures/',y reemplazarla por la ruta de la foto
httpStaticNode-Red

Codigo Fuente del FLow

Sobre la siguiente URL se encuentra el Flow escrito y utilizado para la implementacion que se ha realizado.
https://github.com/UavLabsColombia/ScsPi/tree/master/Sources/Flow-NodeRed

Instalando el servidor MQTT (mosquitto) en Rasbperry Pi

Mosquitto es un servidor de aplicacion el cual actua como intermediario entre los mensajes recibidos o enviados por medio del protocolo MQTT, estos mensajes publicados sobre el servidor toman el nombre de "Topics" estos topics pueden ser leidos o escritos desde un cliente MQTT.

para proceder con la instalacion del servidor MQTT sobre Raspberry Pi, ejecutamos la siguiente instruccion

sudo apt-get install mosquitto mosquitto-clients

una vez instalado el servidor, podemos validar el estado del mismo gracias a systemctl

sudo systemctl status mosquitto.service

statusmosquitto
Figura 19. Status del servidot MQTT "Mosquitto".

para analizar el funcionamiento del servidor MQTT realizamos una prueba sobre el mismo creando un topic y realizando una piblicacion sobre el topic creado.

Creamos un topic llamado topic_prueba sobre el servidor con la siguiente instruccion

mosquitto_sub -d -t topic_prueba

esta instruccion pondra el servidor Mosquitto a la escucha sobre ese topic y estara pendiente a recibir una publicacion

realizamos la publicacion de un mensaje sobre el servidor en el topic creado con el siguiente comando.

mosquitto_pub -d -t topic_prueba -m "Hola Mundo"

Eso, publicara sobre el servidor Mosquitto sobre el topic "topic_prueba" el mensaje Hola Mundo
publicinmosquitto-1
Figura 20. Publicando sobre el servidor MQTT un Hola Mundo.

Programando el modulo Wi-fi ESP8266 con Arduino

La idea de utilizar el modulo WiFi para comunicar nuestra planta con el servidor MQTT, se debe a la arquitectura del Chip y la compatibilidad con el IDE de programacion Arduino, se debe aclarar que el modulo trabaja por medio de comandos AT en su Firmware nativo, los comandos AT son instrucciones codificadas que conforman un lenguaje de comunicación entre el hombre y un terminal modem. Ahora que se sabe qué es un comando AT, se debe decir que no se trabajó con este Firmware, así que se decidió cambiar este para poder hacer uso de un lenguajes mucho más coplejos como lo es C bajo Arduino.

Para subir el codigo escrito en Arduino al Chip Wi-Fi, utilizamos un modulo USB to TTL el cual fue conectado al puerto serial del modulo inalambrico por medio del siguiente diagrama de conexion.
esp8266-esp-01-flashing-diagram-laquearmeprimeravez
Figura 21. Conexion del modulo Wi-Fi con el programador USB to TTL.

Instalamos la plataforma de programacion Arduino IDE sobre Ubuntu 16.04 descargando la ultima version disponible de la plataforma "1.8.5" desde la siguiente URL https://www.arduino.cc/en/Main/Software
para descargar el software directo sobre el sistema Linux, ejecutamos la siguiente instruccion.

$ wget https://downloads.arduino.cc/arduino-1.8.5-linux64.tar.xz

descargarArduino
Figura 22. Descarga de Arduino IDE V1.8.5.

Una vez descargado Arduino IDE, es necesario descomprimirlo sobre el directorio actual de trabajo.

tar -xJf arduino-1.8.5-linux64.tar.xz 

arduinoextraido
Figura 23. Extraccion de Arduino IDE V1.8.5.

Accedemos al directorio y listamos el contenido dentro del mismo

$ cd arduino-1.8.5/ && ls -lh

instalandoarduino
Figura 24. Listando el contenido del directorio.

optamos por ejecutar arduino desde el mismo directorio y no realizar la instalacion del mismo, ejecutamos el IDE con la siguiente instruccion.

./arduino

arduinoejecutado
Figura 25. Ejecutando arduino desde el directorio de trabajo.

Una vez instalado Arduino, es necesario realizar la instalacion de las librerias necesarias para poder programar los Chip referentes al modulo ESP8266, por medio de este repositorio en GitHub podremos realizar la instalacion de las librerias https://github.com/esp8266/Arduino

  • Abrimos arduino y accedemos a la ventana de "Preferencias"
  • Agregamos el Json correspondiente al Chip http://arduino.esp8266.com/stable/package_esp8266com_index.json en "Gestor de URLs Adicionales de Tarjetas"instalandolibreriaswifi
    Figura 26. Instalando el Json de la placa ESP8266.
  • Abrimos el "Gestor de Tarjetas" desde "Placa" sobre el menu "Herramientas", buscamos el paquete referente al modulo ESP8266 y lo instalamos
    instalandomoduloesp8266
    Figura 27. Instalando la libreria para la Board ESP8266.

Instalada correctamente la libreria, sera posible seleccionar el Chip sobre la lista de tarjetas en el IDE Arduino
seleccionandoelchipenarduino
Figura 28. Seleccionando el modulo ESP8266 en Arduino IDE.

Para que el Chip ESP8266 pueda realizar la conexion con el servidor MQTT, es necesario instalar sobre Arduino IDE, la libreria de publicacion "PubSubClient"
Para proceder con la instalacion, abrimos el menu "Gestionar Librerias" sobre "Incluir libreria" en "Programa"
InstalandoPubSublientEnArduino
Figura 29. Gestor de librerias Arduino.
instalandolibreriapubsubclient
Figura 30. Instalando libreria PubSubClient.

Descargamos del repositorio UavLabsColombia en GitHub el codigo correspondiente al modulo ESP8266 que comunicara este con el servidor MQTT hubicado en la Raspberry Pi
https://github.com/UavLabsColombia/ScsPi/blob/master/Sources/ESP8266/ESP8266MQTTSerialIO.ino
Este codigo se debe de descargar, compilar y subir con el IDE Arduino.


/*
Conexion de modulo Wi-Fi ESP8266 Con servidor Mosquitto bajo el  protocolo MQTT (M2M)
Creado por: Heberth Alexander Ardila  / heberthardila@gmail.com
UAVLabs.org
Licencia: GNU General Public License v3.0


Este codigo, es una modificacion al ejemplo de conexion con el servidor MQTT  de arduino 
el cual utiliza la librerias ESP8266Wifi y PubSubclient, fue modificado y adaptado para el control de nuestro proceso, se conecta a un servidor de MQTT el cual se encuentra en
una red alcanzable via TCP/IP

Funcionamiento: 
- AL conectarse con el servidor MQTT, imprime el mensaje "Hola mundo" indicando que se ha conectado correctamente, esto lo realiza con el topic
"outopic", este hola mundo es utilizado sobre Node-Red para detectar que la planta se ha conectado con el servidor de aplicacion
- Se suscribe a un topic "inTopic" por el cual recibe los eventos de desde el mismo servidor MQTT y son enviados por serial al pic18f2550
- Si el primer caracter del topic de entrada es un 1, enciende el led integrado sobre el mismo ESP8266
- Este se reconecta al servidor si en algun momento falla la comunicacion

Envia y recibe datos por el puerto serial el cual van y vienen del microcontrolador PIC18f4550

Para instalar la board ESP8266 sobre arduino 1.6.4 o mayor agregue el siguiente al administrador de Boards de arduino sobre
Archivo, Preferencias, Administrador de boards adicionales 
http://arduino.esp8266.com/stable/package_esp8266com_index.json
Despues habra "Herramientas > Board > Administrador de Boards", busque e instale el paquete ESP8266
Para seleecionar el modulo, clic en Tool > Board
*/

//Librerias:
#include <ESP8266WiFi.h> 
#include <PubSubClient.h>

// ACtualizar estos valores con los datos de la red Wifi y el servidor de aplicacion MQTT

const char* ssid = "SSIDDeLaRed";
const char* password = "ClaveDeLaRedWifi";
const char* mqtt_server = "DireccionIPoNombredeDominiodelServidor";

WiFiClient espClient;
PubSubClient client(espClient);
long lastMsg = 0;
char msg[50];
int value = 0;

//Inicia el serial, el wifi y la conexion con el servidor mqtt por el puerto 1883
void setup() {
  pinMode(BUILTIN_LED, OUTPUT);     // Inicializa el BUILTIN_LED pin Como una salida
  Serial.begin(9600);
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);
}

// FUncion que realiza la conexion a la red Wifi.
//Imprime por el serial un . mientras intenta ralizar la conexion con la red Wifi
// Una vez conectado imprime por serial los datos de la conexion realizada y la ip asignada. 
void setup_wifi() {

  delay(10);
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);

  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}

//Funcion que recoge el evento de llegada recogido por el servidor mqtt, lo almacena en buffer y lo imprime por serial
void callback(char* topic, byte* payload, unsigned int length) {
  for (int i = 0; i < length; i++) {
    Serial.print((char)payload[i]);
  }

  // Enciende el BUILTIN_LED si se recibe un 1 sobre el primer espacio del buffer de datos recibido
  if ((char)payload[0] == '1') {
    digitalWrite(BUILTIN_LED, LOW);   // Enciende el led con logica 0
    // 
  } else {
    digitalWrite(BUILTIN_LED, HIGH);  // Apaga el led con logica 1
  }

}

void reconnect() {
  // Loop de reconexoin con el servidor MQTT
  while (!client.connected()) {
    Serial.print("Attempting MQTT connection...");
    // Intento de conexion
    if (client.connect("ESP8266Client")) {
      Serial.println("connected");
      // Una vez conectado, realiza una publicacion
      client.publish("outTopic", "hello world");
      // Se suscribe a un topic de entrada
      client.subscribe("inTopic");
    } else {
      Serial.print("failed, rc=");
      Serial.print(client.state());
      Serial.println(" try again in 5 seconds");
      // Espera 5 segundos antes de intentar reconectar de nuevo 
      delay(5000);
    }
  }
}

void loop() {

  if (!client.connected()) {
    reconnect();
  }
  client.loop();

  long now = millis();
  if (now - lastMsg > 500) {
    lastMsg = now;
    ++value;
    // Buffer que recoge los datos leidos por el puerto serial y lo publica sobre el topic de salida. 
    char myArray[5];
    Serial.readBytes(myArray,6);
    client.publish("outTopic", myArray);
  }
// no dejar linea en blanco al final del codigo 
}

Si al flashear el codigo de arduino, no inicia el CHIP, es necesario subir el binario que ha compilado arduino desde la herramienta "esptool.py" el binario lo almacena sobre el directorio /tmp/arduino_build una vez compilado sobre el IDE.

para subir el binario, se utiliza el siguiente comando

esptool.py -c esp8266 --port /dev/ttyUSB0 -b 115200 write_flash --flash_freq 40m --flash_size 1MB 0x00000 /tmp/arduino_build_827523/ESP8266MQTTSerialIO.ino.bin

Funcionamiento del codigo.

Este codigo, es una modificacion al ejemplo de conexion con el servidor MQTT de arduino el cual utiliza la librerias ESP8266Wifi y PubSubclient, fue modificado y adaptado para el control de nuestro proceso, se conecta a un servidor de MQTT el cual se encuentra en una red alcanzable via TCP/IP

  • AL conectarse con el servidor MQTT, imprime el mensaje "Hola mundo" indicando que se ha conectado correctamente, esto lo realiza con el topic
    "outopic", este hola mundo es utilizado sobre Node-Red para detectar que la planta se ha conectado con el servidor de aplicacion
  • Se suscribe a un topic "inTopic" por el cual recibe los eventos de desde el mismo servidor MQTT y son enviados por serial al pic18f2550
  • Si el primer caracter del topic de entrada es un 1, enciende el led integrado sobre el mismo ESP8266
  • Si se reciben datos de estado que van hacia la planta, el modulo los recibe via Wi-Fi por medio del servidor MQTT y los pasa a la planta por conexion Serial.
  • Este se reconecta al servidor si en algun momento falla la comunicacion

esp8266compilado
Figura 30. Compilando y subiendo el codigo al ESP8266.

Programando el MicroControlador PIC18F2550 con PiCKit2 y CCS C Compiler

Para esta implementacion, utilizamos el PIC18F2550 diseñado por MicroChip ya que era requerimiento del diseño trabajar con este fabricante, a raiz de esto las aplicaciones implementadas para programar este dispositivo fueron implementadas sobre un computador con Sistema Operativo de la familia de Microsoft, en este caso Windows 8.1.

El MicroControlador implementado en este caso, se utiliza para controlar todo el proceso industrial; manteniendo el estatus y la ejuccion de la planta y actualizando estos estados sobre el servidor MQTT.

Como el software utilizado para Flashear este MicroControlador es totalmente cerrado por el fabricante, no vamos a documentar la instalacion ni configuracion de las mismas.
Asumimos que ya se encuentra instalado el Compilador "CCS C Compiler" con su debida licencia y el programador PICkit 2.

El codigo fuente que se ha grabado sobre este MicroControlador, se encuentra disponible sobre UAVlabsColombia en Github a travez del repositorio SCSPi sobre la siguiente URL.
https://github.com/UavLabsColombia/ScsPi/blob/master/Sources/pic18f2550/scsPic.c

/* 
    Created on : 01/12/2017
    Author     :
                  script-cat@outlook.com
                  uavlabs.org
    
    Programa para un micro controlador 18F2550 el cual se encarga del control de una
    planta clasificadora de paquetes.
*/

#include <18F2550.h>
#fuses xt, nowdt, noprotect, put, CPUDIV1

// Numero de bits a utilizar en el convertidor analogo a digital
#device adc = 10
// se define el uso del reloj interno a 8Mhz
#use delay(internal = 8000000)

// se define la comunicacion serial a 9600 baudios, sin paridad y un bit de stop
#use rs232(baud = 9600, bits = 8, parity = N, xmit = PIN_C6, RCV = PIN_C7, stop=1, ERRORS)

#use fast_io(b)
#use fast_io(a)
#use fast_io(c)


// ****************  Variables Globales  *******************

// calculo de la resulucion para una salida maxima de 5
float resolucion = (float) 5 / (float) 1023;

// se guarda el ultimo caracter que se recibe por serial
char dato_recibido = '0';

// se usa en los bucles
int i;

// se calcula el promedio del peso
float promedio = 0.0f;

// bandera que avisa si la caja paso la primera banda
boolean primera_etapa = false;

// se define una simulacion de un puerto pwm de 50 hz
void duty_50(int puerto, int16 time_on, int ciclos){
    for (i = 0; i < ciclos; i++) {
        output_high(puerto);
        delay_us(time_on);
        output_low(puerto);
        delay_us(20000 - time_on);
    }
}

void define_puertos() {
       
    /* Define el pin 7 y 0 como entrada y el resto del puerto como salidas
    3 y 4 leds indicadores de caja
    0  entrada finales de carrera
    2 banda 1
    bin: 1110 0001
    */
       
    set_tris_b(0xE1);
    output_low(PIN_B1);
       
    // define la entrada 0 del puerto a como entrada
    //bin: 0000 0001
    set_tris_a(0x01);
    output_high(PIN_A5);
    output_low(PIN_A3);
       
    // se define el puerto c como salida
    set_tris_c(0x00);
    output_c(0x00);
       
    // Define como entradas analoga el puerto AN0
    SETUP_ADC_PORTS(AN0);
       
    // Define el relog interno para el uso del ADC
    SETUP_ADC(ADC_CLOCK_INTERNAL);
    
    // se configura el canal del adc
    SET_ADC_CHANNEL(0);
}

void correr_bandas_finales(){
    // corre las 3 bandas del rele por 3.5 seg
    output_low(PIN_A5);
    delay_ms(3500);
    output_high(PIN_A5);
}

void parar_planta(){
    // se enciende el led indicador de paro
    output_high(PIN_B1);
    
    // se detiene la banda 1
    output_low(PIN_B2);
    // se detiene las bandas finales
    output_high(PIN_A5);
    
    // se mantiene en el bucle hasta que se presione el boton de start
    while(!input(PIN_B5)){
        delay_ms(100);
    }
    
    if(primera_etapa){
        // se reanuda la primera banda
        output_high(PIN_B2);
    }else{
        // se encomprueba los finales de carrera del elevador
        if(input(PIN_B0)){
            // esta en las bandas finles, activamos el rele de las badas
            correr_bandas_finales();
        }
    }
    
    // apagado del led indicador de paro
    output_low(PIN_B1);
}

// ************************* interupciones ************************

// iterupcion de cambio en el puerto b
#int_rb
void int_rb_pulsadores(){
    //boton de rest b7
    if(input(PIN_B7)){
        printf("7.0000");
    }
    // stop b6
    if(input(PIN_B6)){
        parar_planta();
    }
}

//interrupcion de llegada de datos
#int_rda
void rb_isr() {
    // comprueba si hay llegada de datos
    if (kbhit()) {
        dato_recibido = getc();
        delay_ms(4);
        
        if(dato_recibido == '1'){
            parar_planta();
        }
        
        dato_recibido = '0';
    }
}

// retorna un valor de 0 a 5 con respecto al valor medido en el pin A0
float leerADC() {
    return resolucion * (float) (READ_ADC());
}

void subir_ascensor() {
    //ENABLE RA3,  datos: A1, A2
    output_high(PIN_A1);
    output_low(PIN_A2);
    
    //inicio de la subida con fuerza
    for (i = 0; i < 40; i++) {
        output_high(PIN_A3);
        delay_ms(9);
        output_low(PIN_A3);
        delay_ms(11);
    }
    
    if (promedio >= 3.5) {
        //cajas pesadas
        while (!input(PIN_B0)) {
                output_high(PIN_A3);
                delay_ms(8);
                output_low(PIN_A3);
                delay_ms(12);
            }
    } else {
        //cajas livianas
        while (!input(PIN_B0)) {
            output_high(PIN_A3);
            delay_ms(6);
            output_low(PIN_A3);
            delay_ms(14);
        }
    }
}

void bajar_ascensor() {
    //ENABLE RA3,  datos: A1, A2
    
    output_low(PIN_A1);
    output_high(PIN_A2);
    
    for (i = 0; i < 40; i++) {
        output_high(PIN_A3);
        delay_ms(12);
        output_low(PIN_A3);
        delay_ms(8);
    }
    
    for (i = 0; i < 80; i++) {
        output_high(PIN_A3);
        delay_ms(5);
        output_low(PIN_A3);
        delay_ms(15);
    }
    
    while (!input(PIN_B0)) {
        output_high(PIN_A3);
        delay_ms(3);
        output_low(PIN_A3);
        delay_ms(17);
    }
}

void main() {
    
    //habilita las interrupciones por serial
    enable_interrupts(int_rda);
    //habilita las interrupciones puerto b
    enable_interrupts(int_rb);
    //habilita las interrupciones glovales
    enable_interrupts(global);
    
    //intrerrupcion por flanco de subida
    ext_int_edge(L_TO_H);
    
    // configura los puertos
    define_puertos();
    
    
    while (true) {
        primera_etapa = true;
        
        // se apagan los led indicadores de caja
        output_low(PIN_B3);
        output_low(PIN_B4);
        
        // inicia la banda 1
        output_high(PIN_B2);
    
        // esta en este metodo hasta que pese algo
        while (true) {
            delay_ms(200);
            if (leerADC() > 1.0f) {
                break;
            }
        }
    
        // se detiene la banda 1
        output_low(PIN_B2);
    
        // espera 3s mientras cuadra la caja
        delay_ms(3000);
    
        // ******************* peso de la caja ************   
        for (i = 0; i < 7; i++) {
            delay_ms(300);
            promedio += leerADC();
        }
        promedio /= 7;
 
        // se envia el peso por r232
        printf("%1.4f", promedio);
       
    
        // enciende los led indicadores 
        if (promedio >= 3.5) {
            output_high(PIN_B3);
        }else{
            output_high(PIN_B4);
        }
        
        delay_ms(500);
        
        //**************** servo 1 (pasa a la otra banda) ***************
        // brazo 90 grados
        duty_50(PIN_C2, 1500, 15);
        duty_50(PIN_C2, 500, 15);

        // ************** Finaliza la primera etapa  *******************
        primera_etapa = false;

        correr_bandas_finales();
   
        subir_ascensor();
        delay_ms(500);
    
        // condicional para pesar las cajas 
        if (promedio >= 3.5) {
            // bazo cajas pesadas
            duty_50(PIN_C1, 500, 60);
            duty_50(PIN_C1, 2500, 60);
        } else {
            // bazo cajas livianas
            duty_50(PIN_C0, 500, 60);
            duty_50(PIN_C0, 2500, 60);
        }
    
        correr_bandas_finales();
        bajar_ascensor();
    }
}

Funcionamiento.

  • Inicia la planta o el proceso
  • Valida con el peso de las cajas si esta es pesada o liviana
  • Clasifica las cajas y las direcciona hacia el lado correcto dependiendo del peso
  • Envia y actualiza el estado de la planta y el conteo de las cajas por medio del puerto serial sobre el modulo ESP8266

Fuentes:

Para acceder a todo el codigo fuente implementado sobre este proyecto se puede descargar deracta y libremente desde nuestro GitHub
https://github.com/UavLabsColombia/ScsPi

Conclusion:

Al implementar sistemas de monitoreo como interfaces "HMI" y "KVM" para el control de procesos industriales, vemos una alta usabilidada en las herramientas de Opensource basados en Software y en Hardware de bajo costo, logramos evidenciar un alto potencial de implementaciones que se pueden realizar para el control de cuaquier proceso, esto debido a la inmensa documentacion que podemos encontrar en internet gracias a las comunidades que documentan estos proyectos, comprendimos lo modular y escalable que puede llegar a ser un proceso y lo facil que puede llegar a ser la implementacion con estas tecnologias.

Agradecimientos:

En especial, agradecimientos a mi padre, Julio Heberth Ardila Gonzalez que hizo posible la construccion y diseño de nuestra planta combinando un poco de ingenieria mecanica y de movimiento.