Embed Size (px)
Citation preview
TRABAJO FINAL DE ESTUDIOS
ESTUDIO DE LAS ETAPAS DE DISEÑO Y DESARROLLO DE UNA ARQUITECTURA CIBERFÍSICA COMO SOPORTE A LA AUTOMATIZACIÓN INDUSTRIAL
ANNEXOS
Titulación: Grado en Ingeniería en Tecnologías Industriales Nombre y apellidos alumno: Ivan Pretel Rodríguez Nombre y apellidos del director: Miguel Delgado Prieto Nombre y apellidos del co-director: Ángel Fernández Sobrino Fecha de entrega: 13/01/2021
Estudio de las etapas de diseño y desarrollo de una arquitectura ciberfísica como
soporte a la automatización industrial
Tabla de contenido
ANEXO A ................................................................................................................... 1
ANEXO B .................................................................................................................. 20
ANEXO C .................................................................................................................. 28
ANEXO D ................................................................................................................. 35
1
ANEXO A: Creación de una máquina virtual en Plataforma en Nube (Azure) Ángel Fernández Sobrino Miguel Delgado Prieto Luis Romeral Martínez
La finalidad de la práctica es adentrarse en el uso de herramientas de computación en nube e IIoT para la adquisición de datos en sistemas industriales. El objetivo será crear un dashboard que permita visualizar datos adquiridos y calculados, mediante gráficas en diferentes paneles.
Para esto será necesario aprender a utilizar varias herramientas: crear máquinas virtuales, instalar software mediante línea de comandos en una máquina Linux ubicada en cualquier parte del mundo, aprender cómo se utilizan y en qué se basan los entornos softwares de gestión de flujos de información, y como se pueden transmitir datos o visualizarlos en nube.
En todo caso, enfatizar que la parte más importante de este proyecto es que sepáis crear dichas máquinas virtuales, que instaléis los programas y seáis capaces de poner en marcha la arquitectura IIoT propuesta. Durante este proceso, afrontareis las dificultades propias de la implementación y puesta en marcha, y desarrolléis habilidades de resolución de problemas relacionados con la operación de la arquitectura concreta a implementar.
Los pasos para el desarrollo del proyecto son:
1- Crear una máquina virtual Linux Server Ubuntu alojada en un servidor de la plataforma Azure de Microsoft.
2- Instalar los programas Node.js, NodeRed, InfluxDB y Grafana. 3- Ejecutar los programas como un servicio de la máquina virtual. 4- Abrir los puertos en la interfaz de red de Azure de la máquina virtual para poder acceder a
la configuración de los diferentes programas. 5- Acceder a NodeRed y programar el flow que genere los datos que se almacenaran en la
base de datos InfluxDB. 6- Configurar un dashboard Grafana para que acceda a los datos almacenados en InfluxDB y
generar visualizadores. 7- Implementar una script en Matlab para lectura y escritura de datos en la base de datos 8- Implementar una script en Matlab que realice un servicio de procesado sobre los datos
disponibles en base de datos
Además, indicar que se trata de un proyecto en el que debéis ser capaces de solucionar los problemas que os encontréis. No tengáis miedo en borrar una máquina virtual y crear una nueva si veis que habéis cometido errores, es parte del proceso.
2
1. Crear máquina virtual
Para ello crearéis una cuenta personal a la que, posteriormente, le asignaréis vuestro email @estudiant.upc.edu. Una vez hecho esto deberéis activar una subscripción de Azure para estudiantes, con lo que tendréis acceso a algunos servicios de la plataforma, en los que podréis gastar 100 dólares que la plataforma os asignará gratuitamente. No es necesario que deis información de tarjetas bancarias ni realizar ningún gasto real para dar de alta el servicio en ningún momento del proceso.
A continuación, tenéis las páginas web donde poder daros de alta en los servicios.
• Web UPC Azure. Para dar de alta la cuenta, debe ser con un email personal, después podréis poner el email de la UPC. Deberéis autenticar la cuenta varias veces y poner vuestro número de teléfono para recibir los códigos de verificación.
https://serveistic.upc.edu/ca/distsoft/faq/microsoft-imagine/acord-upc-microsoft-imagine
• Web de Azure donde activar el servicio gratuito para estudiantes. Existen dos promociones gratuitas, la común de 170€ durante un mes, y la versión de estudiantes, que proporciona 100€ durante 12 meses. Esta última es la que deberéis activar desde la siguiente página web.
https://azure.microsoft.com/es-es/free/students/
Una vez realizado este proceso podréis acceder al portal de Azure en el botón Portal de la web de Microsoft Azure indicada primeramente o accediendo directamente a portal.azure.com, como se ve en las siguientes capturas de pantalla.
Una vez en el portal deberíais ver al siguiente web:
3
Una vez en dentro del portal debéis conocer cómo acceder al ver vuestra subscripción. Para ellos entrareis en todos los recursos y buscaréis “Education”, donde podréis ver si tenéis disponibles los 100USD y cuántos os quedan disponibles.
Una vez hecho esto ya podéis poner en marcha vuestra máquina virtual, que será el principal elemento evaluable de vuestro proyecto, que será tutorizado pero no resuelto por el profesor. En caso de que tengáis dudas de operación con la plataforma deberéis primero buscar soluciones e información mediante los manuales profesionales de Azure.
Para empezar a trabajar, deberéis entrar la página de inicio de Azure y buscar el botón Máquinas Virtuales.
Una vez allí podréis acceder al creador de máquinas virtuales. Más abajo tenéis las capturas de las características de la máquina que debéis generar. Como podréis comprobar, se trata de la máquina más económica posible, con un coste de 3,40€ al mes estando 24 horas activa. Vosotros las tendréis conectada mucho menos tiempo, por tanto, podríais optar por una máquina virtual con más prestaciones (cuidado!, gastar los 100 USD de la cuenta implica el fin del acceso gratuito a los servicios, con impacto en la ejecución del proyecto!). Dado que la gestión económica y temporal es importante en cualquier implementación real, se os ruega que seáis cuidadosos.
Las capturas de pantalla que muestran los pasos a realizar se indican a continuación.
4
En este punto debéis poner el usuario y contraseña para la conexión SSH. Las credenciales propuestas para que los profesores podamos acceder son:
ApellidoNombre y la contraseña 123456789Upc
5
6
Finalmente, en la ventada recursos, deberíais ver los siguientes elementos.
Si accedéis al recurso máquina virtual veréis que podéis iniciarla y detenerla. Además, para evitar sustos, en la configuración veréis que os he indicado que activaseis el apagado automático de la máquina cada día a las 24:00:00, para que no que os olvide dejarla encendida.
Podréis acceder a la siguiente página web para poder ver el saldo que os queda y el consumo que realizáis:
https://www.microsoftazuresponsorships.com
7
Manejo y uso de la máquina virtual
Una vez arranquéis la maquina deberéis conectaros a ella para poder utilizarla. Esta conexión se logra mediante SSH, un protocolo de línea de comandos que permite hacer algo parecido a programas de conexión remota de escritorios como TeamViewer. La máquina creada no tiene por qué tener una interfaz gráfica, es solo un ordenador con línea de comando. En la ventana de la máquina podréis darle al botón “conectar” y os dará las instrucciones para conectaros por SSH, usuario, contraseña y puerto, solo deberéis copiarlo y usarlo desde vuestro cliente en el ordenador. Linux y Mac OSX traen un cliente SSH instalado de fábrica, SSH en terminal, pero en Windows se debe instalar aparte, como por ejemplo PuTTY, Command Promt o la interfaz de línea de comandos de Azure. De este último, se adjunta imagen para saber donde encontrala en Azure:
Aquí tenéis un tutorial sencillo.
https://www.profesionalreview.com/2018/11/30/ssh-windows-10/
Otra opción para poder trabajar con los comandos SSH en Windows es mediante
Una vez introducido el comando “ssh ApellidoNombreusuario@direcciónIP”, nos pedirá que aceptemos el certificado y escribimos la contraseña (123456789Upc), que no se verá mientras la escribáis. Finalmente, deberíais llegar a algo como lo que se puede observar en la siguiente imagen:
8
Esto es vuestro control sobre vuestra máquina virtual.
Para que esta conexión funcione a la hora de crear la máquina virtual debéis haber definido los puertos de entrada públicos en la interfaz de red, de esa manera Azure permite que la máquina virtual este “escuchando” en uno de los puertos de la IP publica que se le asigne automáticamente al arrancar, y al intentar conectaros des del exterior la interfaz de red permite acceder a la máquina. Si no se configura de esa manera la interfaz de red no transmitirá nuestra petición SSH por el puerto 22 a la máquina virtual y no tendremos acceso a esta.
De cara al uso general del terminal Bash de Linux, podéis utilizar la siguiente web que os explicará los comandos básicos del terminal:
https://es.wikibooks.org/wiki/Manual_de_consola_Bash_de_Linux
Resaltar el uso del comando “ps –A”, el cual permite ver los procesos (programas) que está ejecutando el sistema operativo, muy útil para comprobar si los software que necesitareis están en ejecución.
9
2. Instalación de software
Una vez controlada la máquina virtual, es ahora tiempo de instalar los recursos que haremos correr sobre ella. Estos recursos serán:
- NodeRed, un gestor de comunicaciones con la planta y otras aplicaciones en nube, que permite además ejecutar programas (en la primera parte del proyecto, para comprobar su funcionamiento, NodeRed contendrá un generador de señales sinusoidales a cierta frecuencia y amplitud que emulará la señal capturada)
- Grafana, un interfaz gráfico de baja complejidad - InfluxDB, un servidor de base de datos, que contendrá datos en general.
Se pasa a continuación a explicar los procesos de instalación del software comentado.
Node.js – versión 10.x https://github.com/nodesource/distributions/blob/master/README.md
En este GitHub aparecen los comandos para poder instalar dicho programa en Linux Ubuntu.
Una vez terminado el proceso debéis comprobar que está instalado correctamente mediante el comando correspondiente para ver a la versión instalada, mediante el comando
- node -v o: - node –version
Node-Red El siguiente programa a instalar será node-red, un software que permite enviar y recibir información vía diferentes tipos de comunicaciones. Más información, comandos, etc en la siguiente web:
https://nodered.org/docs/getting-started/local
Ahora deberéis instalar influxdb, un software que permite almacenar datos en bases de datos transmitidos por puertos de internet (en este caso enviaremos datos des de node-red a influxdb, aun estando en el mismo PC, utilizando la IP 127.0.0.1, que corresponde a la IP del propio ordenador, por tanto, el mensaje reentra por la misma interfaz de internet al ordenador, por tanto, a influxDB).
InfluxDB https://portal.influxdata.com/downloads/
En la web anterior debéis seguir las instrucciones (comandos de bash -Linux terminal-), para poder instalar la versión 1.8.3 del software influxDB. Al presionar en el cuadrado os aparecerán los comandos para instalarlo en diversas plataformas, debéis buscar las instrucciones para Ubuntu. Concretamente son las que se pueden ver a continuación:
10
Grafana Por último, utilizaremos Grafana, un programa que permite presentar datos en una web en forma de gráficos, mapas, etc. Es fácilmente configurable para trabajar con influxDB. Al igual que en el caso anterior, este programa podría estar alojado en otro ordenador distinto, incluso en el vuestro personal, y conectarse a la base de datos por internet, pero lo instalaremos en la misma máquina virtual y localizaremos la base de datos en la IP 127.0.0.1 o en localhost (son equivalentes).
https://grafana.com/grafana/download
En esta web tenéis las instrucciones para instalarlo en Ubuntu, muy semejante a los programas anteriores.
En este último debéis estar muy atentos al proceso de instalación, puesto que el programa requiere de un paquete para poder funcionar que no viene por defecto en la distribución Linux que ofrece Azure. Deberéis ver, en la respuesta que os da Grafana al ser instalado, que es lo que necesita y buscar en internet la manera de instalar dichos paquetes.
Para instalar los paquetes necesarios, seguir las instrucciones que se detallan en el siguiente enlace:
https://grafana.com/docs/grafana/latest/installation/debian/#install-from-apt-repository
11
3. Arranque del software como servicios
Primero, deberéis poner en marcha los programas como servicios dentro del sistema operativo. Estos servicios se deben ejecutar cada vez que se arranca la máquina virtual para no tener que ponerlos en marcha cada vez que se inicia.
Para ejecutar los programas deberéis abrir un terminal, Shell o CMD (según vuestro sistema operativo) acceder mediante SSH y ejecutar el comando correspondiente a los 3 programas. Los podéis encontrar en las siguientes páginas web. También os pueden servir para obtener más instrucciones de instalación.
https://nodered.org/docs/faq/starting-node-red-on-boot#using-pm2
https://docs.influxdata.com/influxdb/v1.7/introduction/installation/
https://grafana.com/docs/installation/debian/
En el caso de Grafana e Influx, estos se utilizan como servicios, que, por defecto, una vez iniciados por el usuario se mantendrán siempre activos y se ejecutaran en el arranque de la máquina si esta se reinicia, por tanto, solo es necesario comprobar si al ejecutar el servicio y reiniciar la máquina este vuelve a iniciarse correctamente.
¡Advertencia!! Grafana puede que no se inicie automáticamente al bootear el sistema una vez ejecutando mediante “sudo services grafana-server start”, destacar que ‘sudo’ indica que el comando se ejecute como administrador. Como veréis, hay dos maneras de iniciar el servidor, mediante los scripts init.d service, o mediante systemd. En caso de que mediante el primer método no arranque automáticamente al iniciar la máquina virtual, deberéis utilizar el segundo. Leed atentamente lo que os indique la respuesta de cada uno de los comandos para actuar en consecuencia.
En el caso de NodeRed no es así, si ejecutáis el comando node-red en vuestro terminal SSH veréis que ese terminal se convierte en el propio NodeRed, como si fuese cualquier otro programa de escritorio. Si cerráis el terminal el programa se termina. Para solucionar esto deberéis seguir las instrucciones que veréis en la web anterior. El objetivo será instalar un programa que se llama PM2 que permite ejecutar otros softwares como servicio de manera sencilla. Además, veréis que permite configurarse para ser ejecutado al arrancar la máquina, utilizando varios comandos como se os indica en la web.
12
4. Configuración de los puertos
En el caso de influx, al ser este una base de datos a la que no vamos a tener que acceder desde el exterior, sino únicamente accederán NodeRed y Grafana, que se encuentra en la misma máquina, ya estaría lista para funcionar.
En el caso de NodeRed y Grafana es distinto, porque se tratan de programas que deberemos poder configurar, programar y visualizar. Para ello estos incorporan un servidor web, que al acceder des del navegador podremos configurar las comunicaciones en el caso de NodeRed, o visualizar datos en el caso de Grafana.
1880 – Node-Red
3000 – Grafana
Estos son los puertos por defecto de los programas a los que debéis acceder de manera remota para configurarlos. Debéis abrir los puertos en el gestor de la interfaz de red que habéis generado en el propio Azure.
La configuración de los puertos a los que se tiene acceso se debe configurar en la interfaz de red asociada a la máquina o directamente en el apartado red del recurso máquina virtual, como veis a continuación.
Aquí debéis definir las reglas de entrada para que podáis acceder a la máquina des del exterior, la seguridad de hacer esto si tener definidas contraseñas de acceso ni un canal de comunicación seguro encriptado es rozando nula, pero al tratarse de una tarea didáctica no es necesario que sea seguro.
A continuación, tenéis unas capturas de cómo se debe configurar el puerto para que permita el acceso desde cualquier IP externa y desde cualquier puerto externo a la IP local al puerto indicado.
13
14
Nota: También podéis acceder a la base de datos de manera directa, utilizando el protocolo http siguiendo las referencias del programa. Para ello deberéis configurar también el puerto de influx, el 8086. Una vez hecho esto, mediante vuestro navegador, podréis acceder a la base de datos de la máquina virtual. Aquí tenéis un ejemplo para pedirle a la máquina las bases de datos que tiene creadas.
http://”laIPpublicaDeVuestraMaquina”:8086/query?q=show databases&pretty=true
En este caso, si utilizamos la barra del navegador de internet (Chrome, firefox, ...), realizaremos una petición GET (es la petición que hace el navegador siempre des de la barra de direcciones), al “endpoint” query, con los parámetros “q” y “pretty”. El parámetro “q” contiene el comando que deseamos ejecutar, en este caso “SHOW DATABASES”, y el parámetro “pretty” que la respuesta sea con saltos de línea fáciles de visualizar, con el valor en “true”. La respuesta podría ser del siguiente estilo:
Para acceder a NodeRed y a Grafana utilizareis el puerto de cada uno de ellos de la siguiente manera:
http://”laIPpublicaDeVuestraMaquina”:1880 -> NodeRed
http://”laIPpublicaDeVuestraMaquina”:3000 -> Grafana
Una vez hecho esto podréis acceder a la programación de Nodered y a la visualización de Grafana. En Nodered deberéis programar un generador de datos aleatorios y que se almacenen en Influx, para lo que deberéis instalar la librería Influxdb. En Grafana deberéis configurar la base de datos Influx para que puede localizar los datos y visualizarlos en una gráfica. Más adelante se detallará esta parte del proyecto.
15
5. Flows de NodeRed
Como veréis al empezar a trabajar con NodeRed, este os permite definir muchos programas, que denomina “flows”, que realizaran acciones enfocadas a realizar flujos de datos entre distintos sistemas de comunicaciones. NodeRed se programa a partir de bloques funcionales que realizan operaciones con datos. Cada bloque dispone de una o varias entradas, por donde entraran datos a ser procesados, y una o varias salidas, por donde devuelve los datos una vez procesados. Existen bloques que son solo de entrada o salida, puesto que se dedican a realizar alguna acción con un cierto dato, o a emitir cierto dato que el bloque será capaz de obtener.
Los bloques que generan datos, ya sea de manera manual o que son capaces de captar datos de alguna fuente externa, son los que permiten la entrada de datos al flow. Los bloques entre ellos se unen por líneas en el programa y los datos se transmiten entre los bloques en un objeto, una “cosa”, que contiene la información con la estructura que deseemos. Este es el objeto msg, mensaje. Vamos con un ejemplo.
Existe un bloque que permite la generación de mensajes en el flow de manera manual, mediante un botón en el que podremos hacer clic, o de manera periódica. Este es el bloque inject, que será el inicio del flow que tendréis que realizar, puesto que inicialmente no tendréis ninguna fuente de datos de la que extraer información, pero ese bloque se podría substituir por otro conjunto de bloques que fuese capaz de tomar datos de algún sensor, de una base de datos, una estación meteorológica, o un PLC como está previsto en la segunda parte de la puesta en marcha.
Este bloque se encargará de emitir por su puerto de salida un objeto msg con cierta información. Dentro de msg podemos tener mucha información almacenada, que guardaremos dentro de su subestructura. Normalmente todos los msg tendrá un elemento llamado payload, al que podremos acceder utilizando msg.payload, donde se acostumbra a almacenar la información importante de ese msg. En el bloque inject podréis decidir qué queréis que se incluya en el payload del objeto emitido. Por defecto se configura a timestamp, es decir, la marca de tiempo del momento en el que se ha ejecutado ese bloque inject. Se pueden incluir gran cantidad de datos distintos, en vuestro caso seguramente ya os vendrá bien que sea así.
Como veis, en la esquina superior izquierda hay un botón que se llama deploy, este sirve para cargar los cambios que hagáis en el flow. Además, los flows se puede activar y desactivar haciendo doble clic sobre la pestaña, activando y desactivando el enable.
16
El siguiente bloque importante con el que tendréis que trabajar es el bloque function. Este bloque os permitirá manipular los msg según vuestras necesidades.
Este bloque se programa en lenguaje JavaScript, encontrareis información sobre las capacidades operativas que ofreces en el siguiente link:
https://nodered.org/docs/user-guide/writing-functions
En vuestro proyecto tenéis que conseguir, mediante un bloque de función, que se generen datos variables a lo largo del tiempo, ya sean aleatorios, dependiente del tiempo teniendo en cuenta que disponéis del timestamp, lo que seáis capaces de obtener. Para empezar deberíais definir un valor contante para comprobar el correcto funcionamiento del sistema, trabajando de forma manual.
El siguiente paso será instalar una librería que incorpora unos bloques que incluyen el software necesario para poder almacenar estos datos en la base de datos influx. Para ello deberéis ir al desplegable superior a la derecha, ir a la sección Manage Palette y entrar en la pestaña Install. Dentro de ella podréis instalar librerías que incorporan nuevos bloques, en este caso instalaremos la librería que incorpora los bloques para cargar los datos en InfluxDB. Deberéis buscar Influx en el buscador, localizar la librería node-red-contrib-influxdb y hacer clic en Install. A continuación, disponéis de la web donde indica cómo utilizar la librería.
https://flows.nodered.org/node/node-red-contrib-influxdb
En esta página encontrareis ejemplos de cómo cargar datos en una base de datos. En el desplegable de NodeRed hay una sección llamada import, en la que podéis pegar el código que os indican y os generará el flow de ejemplo.
Para entender mejor que sucede, copiamos el primer código de ejemplo, tal y como se muestra en la siguiente imagen:
17
Al hacer clic en Import, podremos ver que en el espacio de trabajo nos aparece lo siguiente:
Vuestro objetivo será crear la señal que deseéis ver el grafana y adaptar la estructura y los datos del msg para que los entienda el bloque de la librería Influx.
De cara a trabajar con influx, veréis que dispone de una cierta estructura de datos. Dentro del programa podréis generar diferentes bases de datos, databases. De manera análoga, si quisiésemos utilizar Excel para almacenar datos, las bases de datos serian como archivos de Excel distintos. En Excel podemos generar varias hojas en el mismo archivo, de manera análoga, en influx podemos generar varias series de datos dentro de la misma base de datos, cada serie independiente, estas series se llaman measurements.
18
Dentro de los measurements podemos almacenar datos. Cada dato que se almacena se le asigna una hora de entrada, puesto que influx es un tipo de base de datos enfocada al tiempo en el que se toman esos datos, por eso la utilizamos para almacenar datos a lo largo del tiempo de sistemas y sensores. Eso indica que cada medida que cargamos está asociada a una hora de medida, a un timestamp. La hora que se le asigna al dato puede ser la hora a la que este ha entrado en la base de datos o le podemos definir la hora en la que se debe almacenar al enviar el dato.
Como habéis visto tenemos dos nodos de salida para enviar datos a influx, output y output batch. El segundo nos permite almacenar distintos datos en varios measurements. En el primero, todos los conjuntos de datos que queramos cargar se almacenaran en el mismo measurement, definido en el propio bloque.
Lo siguiente que vamos a hacer es ir al nodo function creado anteriormente y hacer doble clic para poder escribir un código de ejemplo como el que vemos en la siguiente imagen:
A partir del código de ejemplo anterior, se preparará el msg para introducirlo en Influx Output. Como veis, por cada medida (fila de la tabla), podemos incluir valores, que corresponden a los datos que queremos almacenar, y tags, que son indicadores que nos permitirán filtrar los datos a posteriori. Por ejemplo, en un measurement donde almacenásemos datos de varios sensores de temperatura, tendríamos una sola columna de temperatura y una columna donde indicase de que sensor se trata. La columna de temperatura, que es el dato a almacenar, es una columna tipo field, y el nombre del sensor al que corresponde esa temperatura sería una columna de tipo tag.
19
6. Configuración de Grafana
Una vez tengáis Grafana ejecutándose y en escucha en el puerto 3000 podréis acceder mediante la URL antes indicada con vuestra IP pública asignada por Azure. Para iniciar sesión por primera vez utilizareis admin (usuario) y admin (contraseña). Una vez hecho esto deberéis cambiar la contraseña, pondréis la misma que para acceder a la máquina virtual (123456789Upc).
Ahora, es necesario conectar Grafana con la base de datos de InfluxDB. Para hacerlo, se deberá llegar a la pantalla que se puede ver en la siguiente imagen y configularlo según se indica.
NOTA: Puede ser que al clicar el botón “Save&Test” os aparezca un error diciendo que no encuentra la base de datos. Eso es porque es necesario poner el nombre de la base de datos de Influx. Realizar los siguientes pasos hasta la imagen.
Para saber el nombre de la base de datos, se ha de escribir los siguientes comandos en ssh: influx show databases
Si aún no tenemos ninguna base de datos creada en influx, no nos aparecerá ninguna. Para crearla se ha de escribir a continuación de los comandos anteriores, lo siguiente: create database “nombre que queramos que tenga nuestra base de datos”
Una vez creada, ya podemos escribir su nombre donde pone InfluxDB Details, Database. Al hacerlo y volver a clicar “Save&Test”, ya se debería conectar correctamente.
Una vez dentro, lo primero que tendréis que hacer es configurar una base de datos, en nuestro caso, de tipo Influx, y tenemos que indicarle a Grafana que debe obtener información de la base de datos que hemos generado, por tanto, debéis configurar Grafana utilizando el cuadro de diálogo anterior. Pensad que Grafana accederá a la base de datos que se encuentra en el mismo ordenador, por tanto, deberéis utilizar el localhost, o 127.0.0.1, para que en vez de ir a buscar la base de datos por internet la vaya a buscar a la misma máquina virtual.
Ahora sí, si todo lo que habéis hecho está bien configurado, deberíais poder acceder a la base de datos de Influx que habéis creado al almacenar datos desde NodeRed y visualizar los datos en Grafana.
20
ANEXO B: Procesado de datos en Matlab Adquisición, tratamiento y visualización de datos
Ángel Fernández Sobrino Miguel Delgado Prieto
1. INTRODUCCIÓN
La razón por la que interesa almacenar datos es poder procesarlos y analizarlos posteriormente para obtener información útil (e.g. alarmas, costes, toma de decisiones en logística, etc.). En esta segunda parte utilizaremos el entorno Matlab para leer datos de una base de datos creada en InfluxDB. Luego, se procesarán dichos datos en Matlab, obteniendo una información que emula la información de valor añadido obtenida, y a continuación, subiremos de nuevo esa información resultante del procesado a una base de datos en InfluxDB. Por último, se visualizarán los datos (i.e. los existentes originalmente en la base de datos y los nuevos calculados), en un panel de visualización basado en Grafana, finalizando el flujo de información completo de la arquitectura IIoT desarrollada.
Para entender mejor cómo se estructura una base de datos en InfluxDB, es recomendable leer antes la siguiente introducción
https://docs.influxdata.com/influxdb/v1.7/concepts/key_concepts/.
21
2. OBJETIVO
El objetivo de este bloque de trabajo es mostrar la comunicación de datos provenientes de una planta (i.e. a través de sus PLCs por ejemplo), con aplicaciones software mediante protocolos TCP/IP, ejecutar módulos y funciones de procesado de señal (i.e. data analytics), y generar un panel de visualización gráfico en Grafana que permita hacer un seguimiento de los resultados.
El objetivo es, en concreto, y partiendo de los desarrollos realizados en la primera parte, analizar los datos que se registren provenientes de un sensor de vibración ubicado en una máquina. Este sensor devuelve cuatro parámetros estadísticos calculados sobre la señal de vibración de la máquina: RMS, Skewness, Kurtosis and Mean. Estos parámetros son capturados y registrados en unas posiciones de memoria de un PLC, el cual dispone de un puerto de comunicaciones Ethernet, disponiendo de protocolo Modbus TCP/IP.
El primer paso de esta sesión es implementar un sistema de registro de los datos obtenidos por el PLC, que tienen una frecuencia de refresco de 5 segundos. Para ello se implementa un bloque de acceso a un dispositivo mediante Modbus TCP/IP, con una frecuencia de adquisición de, por ejemplo, 1 segundo.
Posteriormente, mediante un bloque de función, se debe estructurar los datos provenientes del bloque modbus, que se presentaran en forma de vector, para poder almacenarlos en las columnas correspondientes de la base de datos InfluxDB que se utilice.
Con los datos almacenados se realizará un dashboard sobre Grafana de visualización, que permita ver los datos en tiempo real.
Posteriormente se debe implementar una aplicación sobre Matlab que permita procesar estos datos, que debe ser capaz de analizar la información y caracterizar la operación y funcionamiento del equipo sensorizado:
22
3. DESARROLLO
Lectura de datos del equipo de medida Se debe acceder al equipo de medida situado en el laboratorio de automatización, encargado de registrar los cuatro valores provenientes de un sensor de vibración situados en una máquina.
Instalar las librerías Modbus TCP básicas para poder utilizar los bloques “modbustcp-server”,
“modbustcp-write” y “modbustcp-read” como se indica en el siguiente enlace:
https://flows.nodered.org/node/node-red-contrib-modbustcp
Instalar también estas otras librerías que nos ofrecen otros bloques con más funciones y
posibilidades:
https://flows.nodered.org/node/node-red-contrib-modbus
Una vez instaladas, las hemos de habilitar en Node-Red. Para ello, ir al desplegable de la esquina derecha y buscar “Manage palette”. Aquí hay que buscarlas e instalarlas para poder usarlas.
Los datos se encuentran almacenados en el siguiente mapa de memoria:
FC Dirección Dato 3 0 RMS 3 1 Skewness 3 2 Kurtosis 3 3 Mean
A continuación, se deberá crear el siguiente Flow en Node-Red:
Bloque Inject:
Dejarlo tal cual por defecto al principio para hacer pruebas de que el Flow funciona correctamente. Una vez verificado, configurarlo para que se repita durante un intervalo de tiempo de 2-3 segundos.
Bloque Function “Lectura datos Modbus”:
Configurarlo como se puede ver en la imagen, ya que los datos de los indicadores se encuentran almancenados en el PLC según la tabla anterior:
23
El campo ‘fc’ debe ser 3 tal y como se indica en la tabla anterior, el ‘unitid’ debe tener un valor pero da igual cual, el ‘address’ deber ser 0 y el ‘quantity’ deber ser 4 porque es el número total de indicadores de los que se quiere leer sus datos.
Bloque Modbus Flex Getter:
Utilizar el protocolo Modbus TCP con la siguiente configuración:
IP: 147.83.83.29 Puerto TCP: 20000
Bloque Function “Procesado datos”:
Los datos recibidos deben ser preprocesados en el entorno Node-Red generando un quinto indicador correspondiente a:
Indicator5 = RMS 2
Para ello se utiliza nuevamente una Function para preparar los datos procesados y gracias a este bloque, se pueden almacenar en la base de datos InfluxDB. Si queremos conseguir guardar los datos de los cuatro indicadores y que el quinto tenga la relación indicada anteriormente, se ha de configurar dicho bloque como se muestra en la siguiente imagen:
Le podemos dar el nombre que queramos al measurement. Con el nombre escogido, lo podremos ver en la base de datos.
De este modo, podremos ver en la base de datos los fields clasificados por columnas. Al utilizar este método del bloque function, se deben enviar los datos a un bloque de Influx llamado “Influx Batch”.
Bloques Influx Batch:
Se debe crear un nuevo servidor y poner la IP 127.0.0.1, que corresponde a la dirección IP donde InfluxDB está instalado, con el puerto 8086 que es por defecto el de esta base de datos. Además, se debe definir la base de datos en la que se quiere escribir los datos, que dependerá del nombre que se le haya dado a la base de datos al crearla. En la siguiente imagen se detalla toda esta información que se ha explicado y todos estos bloques deben estar configurados de la misma manera.
Configurar el bloque tal y como se puede ver en la siguiente imagen:
24
En database, escribir el nombre que tenga la base de datos creada en InfluxDB.
Una montado el flow en Node-Red, podemos comprobar si funciona correctamente, obervando si se están leyendo los datos y escribiéndolos en Influx. Para ello, escribir los siguientes comandos en ssh: influx show databases use “nombre de la base de datos que le hayamos dado” show measurements select*from “nombre que le hayamos dado al measurement”
Podremos observar algo parecido a la siguiente imagen:
25
Preprocesado y almacenamiento
Dichos datos deben ser almacenados posteriormente en la base de datos Influx (tanto los datos obtenidos como el indicador generado posteriormente).
Previamente a este cálculo, se deberá comprobar si los datos leídos son los mismos que en la lectura anterior, puesto que leeréis varias veces el mismo dato antes de que este se modifique en el PLC (período de refresco 5sg, período de lectura 1seg). Para ello almacenareis los datos recibidos en una variable de nodeRED, la cual consultareis en la siguiente lectura para comprobar si los datos han variado.
En caso de haberse modificado enviareis el nuevo dato a Influx, de lo contrario, deberéis descartar el envío.
var datosAnterior = flow.get("datoAnterior"); // Comparais los datos anteriores con los datos actuales y en caso de ser // diferentes almacenais los nuevos datos y enviais los datos a influx mediante flow.set("datosAnterior", msg.payload); return msg;
26
Lectura de datos en InfluxDB
Para poder trabajar con InfluxDB desde Matlab, se utilizará la siguiente librería:
https://github.com/EnricSala/influxdb-matlab
Para poder acceder a la base de datos con la que queremos trabajar, es necesario definir las credenciales de la siguiente manera en el script de Matlab:
Comprobamos si la conexión con la base de datos ha funcionado a través de siguiente código:
Para adquirir los datos de la base de datos de InfluxDB desde Matlab, se usará el siguiente código, modificando la parte en negrita según la señal que queramos utilizar:
% Add the InfluxDB library addpath(genpath('./influxdb-client')); % Init client URL = 'IPDEVUESTRAMAQUINA:PUERTODEINFLUX'; USER = ''; PASS = ''; DATABASE = 'NOMBREDEVUESTRABASEDEDATOS';
% Test the connection [ok, millis] = influxdb.ping(); assert(ok, 'InfluxDB is DOWN!'); fprintf('InfluxDB is OK (%.2fms)\n\n', millis);
% Data reading str = 'SELECT * FROM nombreDelMeasureme WHERE <ConfigParaCogerUnMinutoDeDatos'; result_query = influxdb.runQuery(str); query = result_query.series('nombreDelMeasurement'); TSP = query.time; data = query.table(); signal = [data.<nombreDeLaColumna1>]; signal = [data.<nombreDeLaColumna2>];
27
Procesado de datos en Matlab
En Matlab se realizará un script que calcule la media de cada uno de los cinco parámetros recibidos en el último minuto de información registrada y disponible en la base de datos.
Escritura de datos en InfluxDB
Posteriormente deberéis almacenar los datos obtenidos del procesado en un nuevo measurement “Resultados”:
Preparamos los valores obtenidos para poder enviarlos a la base de datos. Estos serán almacenados a la misma fecha que el último valor obtenido de Influx para realizar el cálculo.
Es posible obtener una vista previa del contenido que se escribirá en InfluxDB usando el siguiente código:
Si es el resultado que queremos escribir en InfluxDB, hacemos un post:
Visualización en Grafana Se debe implementar un dashboard de Grafana que permita visualizar el registro temporal de los datos almacenados en la base de datos en uno o varios gráficos.
Se deberá poder consultar, además, los valores obtenidos tanto por el preprocesado realizado en NodeRED (quinto indicador), como el resultado del procesado de datos en Matlab (las cinco medias de los cinco indicadores).
% Prepare the data result_post = Series('Resultados')...
. fields('nombreColumnaResutlado1', variableResultado1) ...
. fields('nombreColumnaResutlado', variableResultado2) ... …………….
. fields('nombreColumnaResutladon', variableResultadoN);
% Build preview influxdb.writer() ...
.append(result_post)...
.build()
% Post influxdb.writer() ...
.append(result_post)...
.execute();
28
ANEXO C: Procesado de datos en Matlab Script de diagnóstico
Ángel Fernández Sobrino Miguel Delgado Prieto
1. INTRODUCCIÓN
La carpeta Scripts_Diagnosis_Novelty cuenta en su interior con una carpeta Database, dos scripts y cuatro scripts de funciones relacionados con los dos anteriores.
En este documento nos centraremos en el script de Diagnosis y las funciones que utiliza, dejando de lado el script Novelty, ya que, por falta de tiempo, no ha dado tiempo de desarrollarlo y ponerlo en práctica.
En el laboratorio 001 de automatización del TR2 hay implantada una infraestructura ciberfísica para uso académica. En ella, hay una serie de motores que se encargan de accionar las cintas transportadoras para transportar a lo largo de ellas un conjunto de bandejas metálicas. Este estudio, se centrará en adquirir una serie de datos de un equipo instalado en uno de estos motores, provenientes de un sensor de vibración, que devuelve los cuatro indicadores estadísticos vistos en la parte anterior (RMS, Skewness, Kurtosis and Mean).
En el proceso de esta tercera parte, se distinguen dos fases diferentes: La fase de entrenamiento y la de validación.
Para ello, se parte de una base de datos obtenida a partir de poner en marcha la estructura IIoT vista en los anexos A y B, obteniendo un total de 7200 muestras de los cuatro indicadores. Cada muestra es un vector de cuatro componentes (los cuatro indicadores estadísticos).
De estas 7200 muestras, se pueden distinguir dos estados diferentes, el sano y el de fallo1. De cada estado, se tiene 3600 muestras. De estas 3600 muestras de cada estado, hay tres condiciones de operación diferentes según la velocidad a la que gira el motor, donde cada condición de operación tiene 1200 muestras. Los datos están concatenados de la siguiente manera: Saludable condición 1, Saludable condición 2, Saludable condición 3, Fallo condición 1, Fallo condición 2 y Fallo condición 3. Todas las muestras se encuentran normalizadas respecto a las tres condiciones del estado saludable.
En resumen, para tenerlo más claro, la base de datos con la que se trabaja, tiene el siguiente esquema:
29
Para que el proceso sea más rápido, se consideran solo 100 muestras de las 1200 de cada condición de operación de ambos estados para la parte de entrenamiento y del mismo modo para la parte de validación. Es decir, un total de 300 muestras del estado sano y 300 del estado fallo1 para cada una de las partes.
A parte de la base de datos, se tiene un algoritmo matemático que en función de la entrada que tenga (una muestra del vector con los cuatro parámetros de los indicadores), determinará su estado (si es sano o fallo1). En la fase de entrenamiento, este algoritmo, en un principio está “desentrenado” y, por lo tanto, no es capaz de distinguir que muestras son de estado sano o fallo1.
Para ello, se debe desarrollar una instrucción en el script para que realice periódicamente el “entrenamiento” del algoritmo hasta que ya esté “entrenado” y pueda determinar por si solo y con certeza, en base a la experiencia que tiene durante su “entrenamiento” al prácticar con 7200 muestras diferentes, el estado que tiene cada muestra. Una vez se consiga esto, en la base de datos de InfluxDB deberá añadirse dos columnas más a continuación de los indicadores, donde se mostrará el estado de la muestra.
La parte donde tengamos ya el algoritmo “entrenado” y listo para probar si funciona dada una muestra la llamaremos fase de validación.
Estas dos columnas que indican el estado, las llamaremos clase (sana o fallo1) y será un numero binario que expresará si se trata de la clase sana o fallo1. Por ejemplo, la clase sana puede ser el número binario 10 (1 en la primera columna de clase y 0 en la segunda) y la clase fallo1 puede ser el número binario 01 (0 en la primera columna de clase y 1 en la segunda).
7200 muestras
3600 muestras clase sana
1200 muestras condición de operación 1
Se consideran 100 para fase
entrenamiento
Se consideran 100 para fase validación
1200 muestras condición de operación 2
No se consideran
1200 muestras condición de operación 3
No se consideran
3600 muestras clase fallo1
1200 muestras condición de operación 1
Se consideran 100 para fase
entrenamiento
Se consideran 100 para fase validación
1200 muestras condición de operación 2
No se consideran
1200 muestras condición de operación 3
No se consideran
30
2. OBJETIVO
El objetivo de este bloque de trabajo es poner en marcha el script Diagnosis en Matlab, para ver cómo funciona, qué hace y para qué sirve. Se debe conseguir que, con este script, se realice la reducción de cuatro a dos dimensiones mediante una técnica matemática llamada “PCA vibración”, y con ella realizar su respectiva clasificación entre las dos clases distintas (sana y fallo1). Además, generar 2 archivos llamados “Train_samples” y “Test_samples” correspondientes a la reducción a dos dimensiones de los archivos llamados “TRAIN_DATA” y “TEST DATA”. La idea es que gracias a las muestras de los estados sano y fallo1, a partir de un proceso iterativo, se entrene al algoritmo hasta el punto en que haya aprendido como debe funcionar y, una vez que tenga una muestra de datos como entrada, pueda dar una respuesta con certeza del tipo de muestra que es (sana o fallo1) y poder determinar si el motor está funcionando correctamente o no. Si se continuara con el proyecto, después de almacenar los datos a InfluxDB, se podría ver el resultado de como está funcionado el motor en el Dashboard de Grafana. La idea es que, si se siguiera desarrollando, se pudiese aplicar este proyecto, implementándolo en diferentes departamentos de una empresa como, por ejemplo, en logística; producción mantenimiento; entre otros. De este modo, se podría detectar a partir de una estructura con sensores y otros dispositivos a nivel de campo, poder detectar a distancia con el flujo de comunicaciones creado en Node-Red, almacenar todos estos datos en InfluxDB, realizar el procesado de datos con Matlab y poder visualizar un Dashboard en Grafana, donde se pueda observar visualmente con un botón verde (estado sano y funcionando correctamente) o con un botón rojo (estado fallo1 y funcionando incorrectamente). En el caso de que esté funcionando incorrectamente, configurar para que, con una opción de alerta, el sistema pueda avisar al usuario, para que pueda solucionar el problema en el menor tiempo posible. Si todo este proceso explicado se iniciara automáticamente cada vez que se pulsara un botón pulsador, el diagrama de flujo para que se entienda más fácilmente, podría ser el siguiente:
Botón Node-Red InfluxDB Matlab Grafana
31
3. DESARROLLO Cargar de los ficheros a Matlab Para que funcione el script Diagnosis es necesario, en primer lugar, cargar los scripts y los ficheros llamados TRAIN_DATA y TEST_DATA, que se encuentran en la carpeta Database, en Matlab, tal y como se encuentran en la carpeta genérica de esta tercera parte del proyecto. Es decir, una vez cargados en Matlab, los deberíamos poder visualizar de la siguiente manera:
Los ficheros TRAIN_DATA y TEST_DATA son los asociados al script Diagnosis, que cada uno de ellos, son datos que corresponden a matrices de 4x7200 (las 7200 muestras para los 4 indicadores estadísticos que se leen en el sensor de vibración).
Una vez cargados dichos ficheros a Matlab, debemos indicar en las dos instrucciones “Load” del principio del script, donde se encuentran respectivamente, estos ficheros. En este caso, dichas instrucciones se ven de la siguiente manera:
Ejecutar el script Una vez hecho esto, ya se puede ejecutar el script Diagnosis. Para hacerlo, basta con darle al botón “Run” de la pestaña “Editor” de Matlab.
Al hacerlo, no debería haber ningún problema y, automáticamente, se deberían abrir los siguientes paneles correspondientes al panel de entrenamiento de la red neuronal (Neural Network Training); la matriz de confusión (Confusion Matrix); la gráfica de componentes principales (Principal Components) y la gráfica del estado del entrenamiento de diagnóstico (Status Diagnosis Training). Se detallan estos paneles a continuación:
32
Una vez hemos podido comprobar que el script funciona correctamente, se debe hacer una pequeña modificación del script, para que solo se considere una única condición de operación de las muestras de ambos estados de la base de datos, e implementar una instrucción en Matlab que permita que se realice periódicamente (con un bucle) el entrenamiento hasta que el algoritmo de la red neuronal esté entrenado.
Modificación base de datos Para poder observar mejor los gráficos 2D que hemos visto antes evitando un solape entre los dos tipos de estados (muestras azules y rojas), se ha de modificar la base de datos para considerar solo una condición de operación. Es decir, para solo tener en cuenta las primeras 1200 muestras del estado sano, que hacen referencia a las muestras llamadas “Saludable condición 1”, y las 1200 muestras del estado fallo1, que hacen referencia a las muestras llamadas “Fallo condición 1”. Esta modificación, se debe aplicar a la parte de entrenamiento y a la de validación.
33
Para ello, se deben realizar las siguientes modificaciones (se adjunto foto de como debe quedar el código):
• Cambiar el valor de la variable “nsamples” de 300 a 100:
• Borrar las muestras que correspondan a la segunda y a la tercera condición de operación de la clase sana y fallo1 de la fase de entrenamiento:
• Borrar las muestras que correspondan a la segunda y a la tercera condición de operación de la clase sana y fallo1 de la fase de validación:
• Cambiar el valor de la variable “Test_samples” de 300 a 100:
Al realizar este conjunto de modificaciones, se deberían ver las gráficas de representación 2D anteriores, respectivamente de la siguiente manera:
Bucle de entrenamiento En este caso, se ha decidido realizar el bucle de entrenamiento de la red neuronal con la instrucción “while”. Dicha instrucción realiza el entrenamiento de la red hasta que se consigue tenerla entrenada. Por lo tanto, como se puede ver en la siguiente imagen, la instrucción es la siguiente y se debe iniciar después de la parte llamada “Model for classification” y debe finalizar al final del script Diagnosis:
34
Al ejecutar ahora la instrucción, se realizará de periódicamente el entrenamiento, abriéndose automáticamente y de forma periódica los paneles anteriores, hasta que se haya finalizado el proceso de entrenamiento.
Con esto, finalizaría la parte 3 del proyecto, trasformando las matrices de 4x7200 de los archivos de datos TRAIN_DATA y TEST_DATA a los datos llamados “Train_samples y “Test_samples, respectivamente, que corresponden a datos de 2x7200 (las 7200 muestras con los 2 tipos de clase, la sana y la fallo1).
El siguiente paso sería subir está información en dos columnas adicionales a InfluxDB, tal y como se ha comentado anteriormente.
35
ANEXO D: Explicación del Script de diagnóstico Ivan Pretel Rodríguez
1. SCRIPT DIAGNOSIS
36
2. FUNCIONES DEL SCRIPT
37
