Control predictivo distribuido mediante redes de sensores: Aplicación al control distribuido de temperaturas en una habitación 8. PROVIEW Primero, vamos a ver paso a paso como se crea un proyecto en Proview y después profundizaremos en cómo se introduce un programa en C para leer de los sensores y, en su caso, actuar sobre el elemento a controlar (que se verá en apartados posteriores). Tras instalar el programa en un entorno Linux, se crea un icono en el escritorio de acceso directo. Cliqueando dos veces sobre este icono se abrirá la lista de proyectos (ProjectList) en una nueva ventana. Para crear un proyecto nuevo tenemos que activas el modo editor (Edit/Edit mode) y nos aparece una paleta a la izquierda de la ventana. Con esto ya podemos crear nuestro nuevo proyecto. Tenemos que crear un proyecto jerárquico para ir pudiendo añadirle objetos (al principio la lista de proyectos sólo contiene en la jerarquía la carpeta ‘bases’). Para ello seleccionamos Hier en la paleta y pulsamos con el botón intermedio del ratón sobre la carpeta Bases. Así insertaremos un nuevo objeto Hier en la lista de proyectos. El objeto jerárquico es un contenedor de objetos y tiene dos atributos: el nombre del objeto y la descripción del mismo. A continuación, añadimos un objeto ProjectReg al objeto jerárquico creado anteriormente. Para ello lo seleccionamos en la paleta izquierda y pulsamos en la hoja del objeto jerárquico con el botón intermedio del ratón. Figura 15: Arranque Proview Ahora procedemos a configurar nuestro proyecto. Enlazamos nuestro proyecto a un Directory Volume pulsando el botón derecho del ratón sobre el objeto ProjectReg creado y eligiendo Open Project. 29 Control predictivo distribuido mediante redes de sensores: Aplicación al control distribuido de temperaturas en una habitación La primera vez que se haga esto, se abrirá un proceso para configurar los nodos y volúmenes del proyecto. Para crear un proyecto sencillo como el nuestro, bastará con ir pulsando el botón Next. Los distintos pasos son los siguientes: En el primer paso se define el grupo de usuarios que puede acceder al sistema (será el grupo común predefinido). También definiremos los buses que vamos a usar para comunicar varios nodos si los hay. A continuación pulsamos Next. Figura 16 A continuación registraremos el volumen en la lista de volúmenes donde después configuraremos nuestra estación de proceso. 30 Control predictivo distribuido mediante redes de sensores: Aplicación al control distribuido de temperaturas en una habitación Figura 17 Se registrará un volumen por cada nodo. En nuestro caso sólo tendremos uno. El nombre estándar del root volumen viene precedido por el prefijo ‘Vol’. También podemos crear ClassVolumes con el prefijo ‘CVol’ aunque esto, que lo tendremos que usar para introducir nuestro programa en C, lo podemos crear más tarde. Pulsamos NO. 31 Control predictivo distribuido mediante redes de sensores: Aplicación al control distribuido de temperaturas en una habitación Figura 18 En la siguiente ventana especificamos el registro de volúmenes. Siempre habrá un volumen por defecto que será el root volume, que es un volumen que normalmente contiene todos los objetos de un nodo y es cargado en el nodo cuando se ejecuta el entorno de ejecución. Pulsamos Next para continuar. 32 Control predictivo distribuido mediante redes de sensores: Aplicación al control distribuido de temperaturas en una habitación Figura 19 En este paso configuramos la estación de proceso. Como no tenemos un nodo físico, no tenemos que inicializarlo. Sólo correremos una simulación, por lo que pasamos al siguiente paso. Figura 20 33 Control predictivo distribuido mediante redes de sensores: Aplicación al control distribuido de temperaturas en una habitación Procedemos a la configuración del nodo. En el cual ejecutaremos el entorno. La IP señalada es la que se usa cuando no hay comunicación con otros nodos. Figura 21 En la siguiente ventana pulsamos Next para guardar la configuración. Figura 22 34 Control predictivo distribuido mediante redes de sensores: Aplicación al control distribuido de temperaturas en una habitación Hemos creado Objetos para nodos y volúmenes y lo hemos almacenados. El resultado se ve en la siguiente figura: Figura 23: PwR Directory Vemos que la ventana está separada en dos partes, la izquierda con el volumen y la parte derecha con los nodos configurados. Si queremos añadir más volúmenes y nodos, entramos en modo editor y creamos nodos y volúmenes adicionales. Proseguimos con el proceso de configuración y edición de nodos y volúmenes. Abriremos ahora el root volumen creado donde haremos la configuración de nuestra estación de proceso. Pulsamos Yes. 35 Control predictivo distribuido mediante redes de sensores: Aplicación al control distribuido de temperaturas en una habitación Figura 24 Se configurará la estación de proceso para poder después ejecutar el entorno. Pulsamos Next. Figura 25 36 Control predictivo distribuido mediante redes de sensores: Aplicación al control distribuido de temperaturas en una habitación Volvemos a pulsar Next. Figura 26 Por último, pulsamos Next para guardar la configuración. Figura 27 37 Control predictivo distribuido mediante redes de sensores: Aplicación al control distribuido de temperaturas en una habitación Si entramos en el root volumen nos encontramos con la siguiente ventana: Figura 28: PwR VolGettingstarted En la parte izquierda de la ventana vemos la jerarquía de la planta y a la derecha la jerarquía del nodo. Esto es cuando estamos en el modo editor. La jerarquía del nodo contiene objetos configurados para el HW y para los procesos del sistema. La planta sin embargo está vacía. Nosotros añadiremos señales, sensores y componentes de la planta. Podemos añadir código de un programa PLC o de un código en C o de ambos también para la planta. La ventana que aparece en nuestro proyecto es la siguiente. Figura 29: PwR Directory 38 Control predictivo distribuido mediante redes de sensores: Aplicación al control distribuido de temperaturas en una habitación Como se puede observar, además del RootVolume creado durante todo el proceso anterior, se ha creado un ClassVolume donde se hará la llamada a nuestro código en C. Para crear este ClassVolume seguimos los siguientes pasos: • En la primera ventana que aparece al abrir el SCADA, abro GlobalVolumeList y creamos un VolumeReg dentro de la carpeta ClassVolumes. El rango es 0.0.2246.1-254 y hay que señalar el proyecto al que pertenece. Figura 30 • En Navigator directory (donde está el root) creo un ClassVolumeConfig con el mismo nombre del que he creado antes. Pulsamos el botón derecho del ratón y pulsamos OpenClassEditor. Figura 31 • Creo $ClassHier • Creo hijo $ClassDef y selecciono Configure-CCodeFo y se crea: rtbody, devbody, graphplcnode. 39 Control predictivo distribuido mediante redes de sensores: Aplicación al control distribuido de temperaturas en una habitación • En RtBody creo inputs, interns y outputs en ese orden. Al guardar se crea Template que es donde se guardan los valores por defecto. En GraphPlcNode, señalamos Default_mark[i]=1. En nuestro caso crearemos tres salidas: Humedad, Gráfica y medida, que después explicaremos. Figura 32 • Pulsamos ClassVolume Build y se genera .h con la estructura en C. Lo meto en el .c y en el .h y compilamos con el Makefile tal y como indicaremos más tarde. /* Proview V4.7.0 pwr_cvolserialportclasses.h */ /* /* Generated by co_convert. */ Do not edit this file. */ #ifndef pwr_cvolserialportclasses_h #define pwr_cvolserialportclasses_h #ifndef pwr_class_h #include "pwr_class.h" #endif #ifndef pwr_cClass_port #define pwr_cClass_port 33816584UL /*_* Class: port Body: RtBody @Aref port pwr_sClass_port */ typedef struct { 40 Control predictivo distribuido mediante redes de sensores: Aplicación al control distribuido de temperaturas en una habitación pwr_tFloat32 pwr_tFloat32 pwr_tString80 } pwr_sClass_port; Humedad pwr_dAlignW; grafica pwr_dAlignW; Medida pwr_dAlignW; /*_* Class: port Body: DevBody @Aref port pwr_sdClass_port */ typedef struct { pwr_sPlcNode } pwr_sdClass_port; PlcNode pwr_dAlignLW; #endif #endif • Cuando tengamos el ClassVolume y el RootVolume hechos (éste último falta por hacer) hago UpDateClasses en el RootVolume y así añadimos el bloque creado al configurador de PLC’s que tenemos que incluir en el root. Antes de ver cómo meter un programa en C en el SCADA, veremos como se configura el Root, donde hay que meter el PLC. Los pasos para configurarlo son los siguientes: • Entrar en el modo editor. • Seleccionar $PlantHier y crearlo en la ventana de en medio pulsando el botón intermedio del ratón. Lo llamaremos portS. • A continuación, creamos un objeto PlcPgm para meter nuestro PLC. Lo creamos como hijo del anterior (pulsando sobre la hoja) y lo llamamos plc. • En nuestro caso crearemos dentro de este objeto dos variables: una analógica llamada Salidagrafica y otra tipo string llamada Almacenamiento. Más tarde (cuando expliquemos como meter un programa en C en el SCADA) explicaremos la utilidad de estas dos variables. El resultado es: 41 Control predictivo distribuido mediante redes de sensores: Aplicación al control distribuido de temperaturas en una habitación Figura 33 El objeto WindowPlc se irá creando a medida que vamos creando el PLC gráficamente, tal y como iremos viendo a continuación. Para diseñarlo gráficamente pulsamos sobre PlcPgm con el botón derecho del ratón y seleccionamos OpenProgram. En la paleta derecha de la ventana que nos aparece se nos muestran todas las opciones que podemos crear. Al final de todas ellas, debe aparecer el componente que nosotros hemos creado anteriormente (con la estructura del apartado anterior) llamado en nuestro caso CVolSerialport. Seleccionando el componente y pulsando después sobre la paleta en blanco lo creamos. Este componente tiene tres salidas que han sido creadas antes: Humedad, gráfica y medida. Creamos tres salidas: en la carpeta signals/Analog creamos dos salida analógicas StoAp y una tipo String StoSp. Ahora debemos conectarlas con las salidas de nuestra estructura. Para ello, en la barra de herramientas activamos View/Palette/Plant para visualizar la planta que nosotros hemos creado. Dentro de ella buscamos las variables salidas de nuestra estructura para conectarlas con las salidas creadas. Para ello, en la paleta derecha entramos en: portS/plc/W/port6 tal y como muestra en la siguiente figura. Para conectarlas a nuestro plc, seleccionamos por ejemplo Humedad, nos vamos a la salida que queremos conectarle y pulsamos Connect. Hacemos lo mismo para las tres salidas. 42 Control predictivo distribuido mediante redes de sensores: Aplicación al control distribuido de temperaturas en una habitación Figura 34 Tras estos pasos, guardamos y cerramos el PLC. El siguiente paso es crear una pantalla para monitorizar los datos recogidos de los sensores. Esto lo podemos realizar gracias al editor gráfico de Proview. Para ello seguimos los siguientes pasos: • En el modo editor y en la ventana de configuración de RootVolume creamos un objeto XttGraph en la jerarquía del nodo en la carpeta Nodes/Serialport/Op. Este objeto lo podemos encontrar en la paleta izquierda en Node/Operator. Para crear un objeto hijo pulsamos sobre la hoja del objeto Op. Lo llamamos Grafica. • Para poder abrir la ventana cuando ejecutemos el SCADA necesitamos habilitar esta opción. Para ello, primero seleccionamos el objeto Grafica creado y después pulsamos el botón derecho del ratón sobre el objeto Op y activamos ConnectFastAvail/Row1/Column1. • Ahora podemos proceder a realizar el diseño gráfico. En el objeto creado pulsamos OpenGe... • Dibujaremos la pantalla de monitorización tal y como deseemos ayudándonos de la paleta de la derecha donde tenemos todos los elementos que podemos usar. En nuestro caso necesitaremos dos gráficas para medir temperatura y humedad. Además usaremos dos indicadores que nos muestren los valores de temperatura y humedad con displays. El resultado es el siguiente: 43 Control predictivo distribuido mediante redes de sensores: Aplicación al control distribuido de temperaturas en una habitación Figura 35 Ahora tenemos que indicarle las variables que serán mostradas en esa pantalla. Para ello, en la barra de herramientas entramos en View/ViewPlant. En la paleta derecha nos aparece la planta creada tal y como aparecía cuando configuramos el PLC. Entramos en portS/plc/W/port6. Seleccionamos la variable y el icono gráfico a la que la queremos asignar y pulsamos Function/Connect y ya está conectada. Esto lo hacemos con todos los iconos gráficos. Una vez hecho esto, ya tenemos nuestra pantalla de monitorización activada. A continuación se explicará cómo se introduce un programa en C en el SCADA y cómo se relaciona con las variables de salida creadas. En el programa en C se procederá a la lectura del puerto USB. Los sensores de temperatura y humedad se conectan al PC por puerto USB y desde éste lo lee el SCADA. En la primera parte del código leemos del puerto USB. Sin embargo, Proview no es capaz de leer directamente del puerto USB. Hay que usar variables intermedias. A la hora de leer del puerto USB, tengo que guardar la información de los sensores en una base de datos (si fueran variables internas no haría falta realizar este paso) y después leemos de ella. Para ello usamos las funciones escribir en la base de datos y leer de la base de datos: graf = atoi(ver); // ver es una cadena. printf ("%f", graf); sts = gdh_SetObjectInfo( "portS-plc-Salidagrafica.ActualValue", sizeof(graf)); if(sts%2==0){ printf("Fallo en gdh Set: %d", sts); exit(0); } &graf, 44 Control predictivo distribuido mediante redes de sensores: Aplicación al control distribuido de temperaturas en una habitación En la variable ver guardo el dato recibido por el puerto USB. Este dato es un string por lo que lo paso a entero. Con gdh_SetObjectInfo guardo el entero en una variable Av en la base de datos creada en el ClassEditor. portS-plc-Salidagrafica.ActualValue indica que nuestra variable Av ha sido llamada Salidagrafica (en el path indicado) y lo metemos en el atributo del valor actual. Para leer de la base de datos utilizamos lo siguiente: sts = gdh_GetObjectInfo( "portS-plc-Salidagrafica.ActualValue", &graf, sizeof(graf)); if (sts%2==1) { o-> Humedad = graf; } Guardamos el valor de la base de datos en graf y de ahí la pasamos a la variable Humedad de Proview creada antes en la estructura. Para ver el tipo de variables aceptada por el SCADA, para trabajar con la base de datos, se hace referencia al manual. Por poner un ejemplo, una variable String en Proview se expresaría como: pwr_tString80 y una flota: pwr_tFloat32. Una vez que tenemos escrito el programa sólo nos falta compilarlo. Para compilar se seguirán los siguientes pasos: • Guardar el fichero .c en la carpeta: /usr/local/pwrp/serialport/src/ • En ra_plc_user.h (creado cuando configuramos el RootVolume y por consiguiente el plc) hay que insertar la declaración de la función y meterla también en el .c. Este fichero debe estar guardado en $pwrp_src y en $pwrp_inc. • Redactamos el fichero Makefile que en nuestro caso será como sigue: puertoserie_top : puertoserie include $(pwr_exe)/pwrp_rules.mk puertoserie : $(pwrp_inc)/ra_plc_user.h $(pwrp_obj)/puertoserie.o echo "puertoserie built" $(pwrp_inc)/ra_plc_user.h : $(pwrp_appl)/ra_plc_user.h cp $(source) $(target) $(pwrp_obj)puertoserie.o : $(pwrp_appl)/puertoserie.c 45 Control predictivo distribuido mediante redes de sensores: Aplicación al control distribuido de temperaturas en una habitación • Se crea $pwrp_obj/puertoserie.o • Creamos el fichero $pwrp_exe/plc_migue-desktop_0999.opt y meto en él la siguiente línea: $pwrp_obj/rt_io_user.o $pwrp_obj/ra_myfunction.o -lpwr_rt -lpwr_usbio_dummy • Compilamos el nodo. Para ello, en la ventana de configuración del RootVolume. • También habremos de incluir el fichero pwr.h en el .h y en el .c. Con esto ya estaríamos preparados para ejecutar nuestro sistema. Antes de nada, vamos a destacar algunos detalles importantes a tener en cuenta y que no se han señalado anteriormente: • Para compilar, en el terminal consola de Linux tecleamos >sdf serialport y hacemos make (buscamos la carpeta en la que se encuentra). Para compilar, macemos make, Build en ClassEditor, abro Root y Update y Build node. Todo esto forzando Build en Options/Settings en todas las ventanas. • Recordar que los includes que hay que meter en fichero ra_plc_user.h son: rt_plc.h y pwr_cvolserialportclasses.h. • Para leer del puerto serie hay que dar permisos con el siguiente comando: >sudo chmod 777 /dev/ttyUSB0 (o el puerto que sea). • Para que en la caja del plc salgan todas las salidas que pongamos tenemos que indicárselo. Para ello, en GraphPlcNode, me voy a Mask_Default. El primero se refiere a las entradas y el segundo a las salidas. En nuestro caso, por ejemplo, tenemos 2 salidas: la temperatura y la humedad. Como hay dos salidas, tenemos que poner dos bits a uno (11). Pero este número hay que ponerlo en decimal en el programa, por lo que habría que poner un 3 (si fueran 3 salida, 111, un 7, y así sucesivamente). Ya estamos listos para la ejecución del sistema. Para ello seguimos las siguientes recomendaciones: • En el navegador y configurador del RootVolume seleccionamos Tools/Runtime Monitor. Apareciéndonos la siguiente ventana: 46 Control predictivo distribuido mediante redes de sensores: Aplicación al control distribuido de temperaturas en una habitación Figura 36 • Pulsamos Start Runtime. Figura 37 Para que aparezca la pantalla diseñada hacemos lo siguiente. • • • En File seleccionamos Start Operator Environment En la ventana que nos aparece Nodes/Serialport/Op Y ya nos aparece nuestra pantalla del SCADA. Encendemos los sensores e iremos monitorizando la información y guardándola en una fichero para hacer un histórico. En la siguiente figura se muestra la pantalla del Proview. 47 Control predictivo distribuido mediante redes de sensores: Aplicación al control distribuido de temperaturas en una habitación Figura 38 48