8. PROVIEW

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