Siemens Manual WinCC PDF

Siemens Productos y
Sistemas
Manual WinCC V4.02 Indice General
Indice:
1 INTRODUCCIÓN ............................................................................................................ 10
INSTALACION ....................................................................................................................... 13
2.1 Instalación de WinCC V4.02..................................................................................... 13
2.2 Primeros pasos de instalación .................................................................................. 14
2.2.1 Pestaña Seleccionar opción instalación:................................................................ 15
2.2.2 Botón Instalar aplicaciones: .................................................................................. 15
2.2.3 Botón Notas de instalación:................................................................................... 15
2.2.4 Botón Diapositivas Powerpoint.............................................................................. 15
2.2.5 Botón Guía de iniciación rápida............................................................................. 16
2.2.6 Botón Instalar Simulador de Variables................................................................... 16
2.2.7 Botón Cambio de idioma:...................................................................................... 16
2.2.8 Botón Salir de la instalación: ................................................................................. 16
2.3 Desinstalación de WinCC ......................................................................................... 23
2.4 Instalación de la Demo de WinCC. ........................................................................... 24
2.5 Instalación del simulador de WinCC. ........................................................................ 25
2.5.1 ¿Cómo asignar variables al simulador?................................................................. 32
3 Estructura de WinCC....................................................................................................... 35
3.1 Estructura del programa ........................................................................................... 35
3.2 Estructura del proyecto............................................................................................. 42
4 CONTROL CENTER ....................................................................................................... 46
4.1 Introducción. ............................................................................................................ 46
4.2 Crear un nuevo proyecto. ......................................................................................... 48
4.2.1 ¿Cómo inicializar la base de datos de runtime?..................................................... 50
4.3 Base de datos SQL AnyWhere ................................................................................. 52
4.4 Opciones del menú del Control Center ..................................................................... 53
4.4.1 Print FeedBack Doc.. ............................................................................................ 53
4.4.2 Shut Down ............................................................................................................ 53
4.4.3 Idioma del Control Center ..................................................................................... 54
4.4.4 Status de conexión ............................................................................................... 55
4.5 Datos del Proyecto ................................................................................................... 57
4.5.1 Introducción .......................................................................................................... 57
4.5.2 General Information. ............................................................................................. 57
4.5.3 Update cycles. ...................................................................................................... 58
4.5.4 Hotkeys: ............................................................................................................... 59
4.6 Computer: ................................................................................................................ 60
4.7 Computer Properties ................................................................................................ 61
4.7.1 General Information. ............................................................................................. 61
4.7.2 Startup:................................................................................................................. 63
 Siemens P.S. 1999 Página: 1/457

4.7.3 Parameter:............................................................................................................ 65
4.7.4 Graphics-Runtime................................................................................................. 66
4.8 Tag Management ..................................................................................................... 69
4.8.1 Introducción. ......................................................................................................... 69
4.8.2 ¿Qué es un driver o canal de comunicaciones? .................................................... 69
4.8.3 Adición de un driver de comunicaciones................................................................ 69
4.8.4 Adición de una nueva conexión............................................................................. 71
4.8.5 ¿Qué es un group? ............................................................................................... 73
4.8.6 ¿Qué es un tag? ................................................................................................... 74
4.8.7 Control de límites en variables de comunicaciones................................................ 76
4.8.8 Escalado de variables por software ....................................................................... 77
4.8.9 Tamaño de las variables o tags............................................................................. 78
4.8.10 Adaptar una variable de WinCC con respecto al valor del PLC .......................... 78
4.8.11 Generación de variables internas (internal tags) ................................................ 78
4.9 Data Types............................................................................................................... 80
4.9.1 Introducción .......................................................................................................... 80
4.10 Barra de estado de Control Center ........................................................................... 82
GRAPHICS DESIGNER ......................................................................................................... 85
5.1 Introducción ............................................................................................................. 85
5.2 Características ......................................................................................................... 85
5.2.1 Tips&Tricks........................................................................................................... 85
5.2.2 Propiedades de los objetos ................................................................................... 86
5.2.3 Propiedades del objeto Picture.............................................................................. 86
5.2.4 Iconos de la ventana propiedades......................................................................... 91
5.2.5 Barra de herramientas del Graphic Designer......................................................... 92
5.2.6 Biblioteca de objetos ............................................................................................. 94
5.3 Opciones del menú .................................................................................................. 99
5.3.1 Settings ................................................................................................................ 99
5.3.2 Idioma de la pantalla:...........................................................................................102
5.4 Barras de herramientas ...........................................................................................103
5.4.1 Barra de colores ..................................................................................................103
5.4.2 Barra de zoom .....................................................................................................103
5.4.3 Barra de objetos ..................................................................................................103
5.4.4 Barra de layers: ...................................................................................................105
5.4.5 Barra de alineación. .............................................................................................105
5.4.6 Barra de fuentes ..................................................................................................106
5.4.7 Barra de estilos....................................................................................................106
5.5 Smart Objects .........................................................................................................107
5.5.1 Introducción .........................................................................................................107
Página: 2/457  Siemens P.S. 1999

5.5.2 I/O Field...............................................................................................................107

5.5.3 Bar.......................................................................................................................115
5.5.4 Graphic Object.....................................................................................................124
5.5.5 Status display. .....................................................................................................126
5.5.6 Text list. ...............................................................................................................128
5.5.7 Buttons. ...............................................................................................................129
5.5.8 Check box............................................................................................................132
5.5.9 Option button. ......................................................................................................134
5.5.10 Slider................................................................................................................135
5.5.11 Round. .............................................................................................................137
5.6 Asistentes ...............................................................................................................138
Dinamic Dialogs System Functions:................................................................................138
5.6.2 Standard Dinamics...............................................................................................140
5.7 Dinamización de propiedades..................................................................................145
5.7.1 Dinamización a través de una variable .................................................................145
5.7.2 Dinamización a través de dinamic dialog..............................................................145
5.7.3 Dinamización mediante código C .........................................................................145
5.7.4 Dinamización indirecta de una propiedad .............................................................146
5.7.5 Programación de eventos ....................................................................................146
5.7.6 Programación en C de eventos ............................................................................147
6 ALARM LOGGING .........................................................................................................151
6.1 Introducción ............................................................................................................151
6.2 El editor de alarmas ................................................................................................151
6.3 El Wizard del Alarm Logging....................................................................................153
6.3.1 Estructura de un mensaje de alarmas ..................................................................153
6.3.2 Pasos del asistente de alarmas............................................................................154
6.4 Opciones del menú de Alarm Logging .....................................................................158
6.4.1 Importar mensajes ...............................................................................................158
6.4.2 Exportar mensajes de alarmas.............................................................................158
6.4.3 Tipo de introducción de texto ...............................................................................159
6.4.4 Edición de Múltiples mensajes de alarma.............................................................160
6.4.5 Conexión de varios texto a una variable de comunicaciones ................................160
6.4.6 Idioma de los mensajes de alarma .......................................................................161
6.4.7 Mensajes de sistema ...........................................................................................162
6.5 Configuración de Alarm Logging sin el Asistente .....................................................163
6.5.1 Message blocks ...................................................................................................163
6.5.2 Fecha de alarma..................................................................................................164
6.5.3 Hora de alarma ....................................................................................................165
6.5.4 Duración de la alarma..........................................................................................165
6.5.5 Estado de la alarma .............................................................................................166

6.5.6 Número de la alarma ...........................................................................................167

6.5.7 Daylight Saving....................................................................................................167
6.5.8 Estado de reconocimiento de alarma ...................................................................168
6.5.9 Clase de alarma...................................................................................................168
6.5.10 Número de CPU...............................................................................................169
6.5.11 Nombre de la variable que genera la alarma.....................................................169
6.5.12 Violación de límites en alarmas ........................................................................170
6.5.13 Identificación del archivo de la alarma ..............................................................170
6.5.14 Identificación de report de alarma.....................................................................171
6.5.15 Comentarios de alarma ....................................................................................171
6.5.16 Texto de información de la alarma....................................................................172
6.5.17 Saltar a ventanas a partir de una alarma ..........................................................172
6.5.18 Texto de la alarma............................................................................................173
6.5.19 Lugar donde se produce la alarma ...................................................................173
6.5.20 Bloques de proceso..........................................................................................174
6.6 Línea de mensajes de alarmas................................................................................175
6.7 Ventanas de alarmas...............................................................................................176
6.8 Message Classes ....................................................................................................186
6.8.1 Introducción .........................................................................................................186
6.8.2 Clases .................................................................................................................186
6.9 Alarmas analógicas .................................................................................................190
6.9.1 Introducción .........................................................................................................190
6.9.2 Generación de una alarma analógica ...................................................................190
6.9.3 Generación de límites de alarma software............................................................191
6.10 Archivar alarmas .....................................................................................................193
6.11 Imprimir alarmas......................................................................................................195
6.12 Generación de alarmas ...........................................................................................197
6.13 Colocar la ventana de alarmas ................................................................................201
7 TAG LOGGING ..............................................................................................................205
7.1 Introducción ............................................................................................................205
7.2 Propiedades del proyecto ........................................................................................206
7.2.1 Exportar variables en formato Dbase III ...............................................................206
7.3 Tiempos de adquisición de valores ..........................................................................208
7.4 Crear archivos de valores en el disco duro ..............................................................210
7.4.1 Archive Wizard.....................................................................................................210
7.4.2 Propiedades de los archivos de valores ...............................................................211
7.5 Adquirir variables de archivo ...................................................................................215
7.5.1 Propiedades de variables de archivo....................................................................215
7.5.2 Presettings de variables de archivo......................................................................221

7.6 Curvas de valores ...................................................................................................224

7.6.1 Introducción .........................................................................................................224
7.6.2 Propiedades de la ventana de tendencias ............................................................224
7.6.3 Adición y borrado de curvas.................................................................................235
7.6.4 Barra de herramientas .........................................................................................236
7.7 Tablas de valores ....................................................................................................240
7.7.1 introducción .........................................................................................................240
7.7.2 Crear una tabla de valores ...................................................................................240
8 Text Library ....................................................................................................................247
8.1 Introducción ............................................................................................................247
8.2 Idiomas ...................................................................................................................248
8.2.1 ¿Cómo crear un nuevo idioma? ...........................................................................248
8.2.2 ¿Cómo borrar un idioma? ....................................................................................248
8.2.3 ¿Cómo cambiar de idioma desde el Graphic Designer? .......................................249
8.2.4 ¿Cómo cambiar de idioma desde el runtime?.......................................................249
9 User Administrator..........................................................................................................253
9.1.1 Introducción .........................................................................................................253
9.1.2 ¿Cómo crear un nuevo grupo de usuarios?..........................................................254
9.1.3 ¿Cómo asignar una capacidad a un nuevo usuario? ............................................255
9.1.4 ¿Cómo crear una nueva capacidad?....................................................................255
9.1.5 ¿Cómo borrar una nueva capacidad? ..................................................................255
9.1.6 ¿Cómo cambiar el password de un usuario?........................................................256
9.1.7 ¿Cómo cambiar el login de un usuario? ...............................................................256
9.1.8 Desactivación automática de un usuario ..............................................................256
9.1.9 ¿Cómo asignar un nivel de password a una acción? ............................................257
10 Global Script ..................................................................................................................261
10.1 Introducción ............................................................................................................261
10.2 Tipos de funciones en Global Scripts.......................................................................261
10.2.1 Project Functions..............................................................................................262
10.2.2 Standard Functions ..........................................................................................265
10.2.3 Internal functions ..............................................................................................265
10.2.4 Actions .............................................................................................................265
10.3 Disparo de acciones ................................................................................................266
10.3.1 Compilación de funciones externas a través de DLL’s.......................................270
10.3.2 Definición de variables globales y variables locales ..........................................270
11 REPORT DESIGNER.....................................................................................................275
11.1 Introducción ............................................................................................................275
11.2 Partes del report designer .......................................................................................275
11.3 Layout .....................................................................................................................277
11.3.1 Características generales .................................................................................277

11.3.2 Propiedades del layout .....................................................................................278

11.3.3 Barra de herramientas del layout ......................................................................280
11.3.4 Objetos del layout.............................................................................................280
11.4 Line printer layout....................................................................................................286
11.5 Jobs ........................................................................................................................288
12 EJEMPLO BÁSICO ........................................................................................................295
12.1 Introducción ............................................................................................................295
12.2 Salto entre pantallas................................................................................................296
12.3 Consulta de bits ......................................................................................................298
12.3.1 Consulta con dynamic dialog ............................................................................298
12.3.2 Consulta con smart objects...............................................................................300
12.3.3 Representación mediante imágenes .................................................................302
12.3.4 Representación textual del estado de un bit......................................................304
12.4 Consulta analógica..................................................................................................305
12.4.1 Consulta con dynamic dialog ............................................................................305
12.4.2 Representación mediante barras ......................................................................308
12.4.3 Representación mediante indicadores ..............................................................311
12.5 Activación de bits ....................................................................................................315
12.5.1 Activación de bits mediante Wizard ..................................................................315
12.5.2 Activar un bit durante la pulsación de una tecla. ...............................................318
12.5.3 Activación de varios bits ...................................................................................319
12.5.4 Activar bits mediante telerruptores....................................................................320
12.5.5 Activación de bits a través de texto...................................................................322
12.6 Asignar valores analógicos......................................................................................323
12.6.1 Asignación directa de valores analógicos..........................................................323
12.6.2 Asignación mediante barra de desplazamiento. ................................................325
12.6.3 Asignación mediante el objeto Slider de WinCC ...............................................325
12.7 Rellenado de superficies .........................................................................................327
12.7.1 Rellenado mediante Smart Objets ....................................................................327
12.7.2 Rellenado directo de objetos ............................................................................328
12.7.3 Rellenado de polígonos. ...................................................................................328
13 Ejemplo avanzado..........................................................................................................331
13.1 Comunicación DDE .................................................................................................331
13.2 Comunicación OLE 2.0............................................................................................335
13.2.1 Lectura de valores desde Excel ........................................................................336
13.2.2 Escritura de valores desde Excel......................................................................337
13.3 Exportación de datos...............................................................................................339
13.3.1 Exportación de datos a ficheros TXT o CSV. ....................................................339
13.3.2 Exportación desde ISQL...................................................................................343

13.4 Ayuda en sus aplicaciones ......................................................................................345

13.4.1 Ayuda Online....................................................................................................345
13.4.2 Ayuda temporal ................................................................................................347
13.5 Datos de una picture ...............................................................................................349
13.5.1 Nombre de la ventana actual ............................................................................349
13.6 Introducción de valores múltiples.............................................................................350
13.6.1 Cajas sin verificación........................................................................................350
13.6.2 Cajas de introducción con verificación de límites. .............................................353
13.6.3 Incrementar/decrementar valores .....................................................................355
13.7 Animación ...............................................................................................................356
13.8 Controles OLE.........................................................................................................359
13.8.1 Introducción .....................................................................................................359
13.8.2 Utilización de OCX ...........................................................................................359
13.8.3 Controles OCX de WinCC ................................................................................361
13.9 Multimedia...............................................................................................................366
13.9.1 Sonidos en WinCC ...........................................................................................366
13.9.2 Video en WinCC...............................................................................................367
13.10 Instancias ............................................................................................................368
13.10.1 Introducción .....................................................................................................368
13.10.2 Generación de una instancia ............................................................................368
13.11 Vinculación ODBC ...............................................................................................373
13.12 Animación de tuberías .........................................................................................376
13.13 Manejo de ficheros...............................................................................................379
13.13.1 Introducción .....................................................................................................379
13.13.2 Almacenamiento de valores en el disco duro. ...................................................379
13.13.3 Lectura de valores desde un fichero .................................................................380
13.13.4 Añadir valores a un fichero. ..............................................................................382
13.13.5 Borrado de ficheros. .........................................................................................383
13.14 Gráficas no temporal............................................................................................384
13.15 Horarios en WinCC ..............................................................................................388
13.15.1 Modificación de la fecha y hora del WinCC. ......................................................388
13.15.2 Lectura de la fecha y la hora del WinCC. ..........................................................388
13.15.3 Franjas horarias de activación. .........................................................................389
13.16 Teleservicio con WinCC.......................................................................................392
14 Instalación Demo............................................................................................................395
14.1 Introducción. ...........................................................................................................395
14.1.1 Control de alarmas. ..........................................................................................397
14.1.2 Control de eventos de alarma...........................................................................399
14.1.3 Utilización de la opción horn .............................................................................400
14.1.4 Impresión de ventanas de alarmas. ..................................................................400

14.2 Control de usuarios .................................................................................................401

14.2.1 Activación y desactivación de usuarios. ............................................................401
14.2.2 Control del usuario actual. ................................................................................401
14.3 Control del proceso .................................................................................................403
14.3.1 Ejemplo sin instancias. .....................................................................................403
14.3.2 Ejemplo con instancias. ....................................................................................405
14.4 Recetas de productos..............................................................................................412
14.5 Gráficos en la instalación.........................................................................................415
14.5.1 Curvas de datos. ..............................................................................................415
14.5.2 Reports de gráficos y de tablas de valores........................................................416
15 APENDICE A CONFIGURACIONES DE WINCC............................................................419
16 APENDICE B CANALES DE COMUNICACIONES ........................................................444
17 APENDICE C INDICE TEMATICO: ................................................................................... 1


Manual WinCC V4.02 Introducción
1 INTRODUCCIÓN
El paquete de software WinCC constituye el entorno de desarrollo de Siemens en el marco de
los scadas1 para visualización y control de procesos industriales. Sus características más
importantes se pueden resumir en:
ü Arquitectura de desarrollo abierta (programación en C)

ü Soporte de tecnologías ActiveX
ü Comunicación con otras aplicaciones vía ODBC, OLE 2.0 y DDE.
ü Comunicación sencilla mediante drivers2 implementados.
ü Programación Online: no es necesaria detener la runtime del desarrollo para poder
actualizar las modificaciones en el mismo.
El presente manual tiene como objeto explicar de la manera más práctica posible todas las
posibilidades que dicho scada dispone, comenzando con una descripción de todas las
opciones del paquete para posteriormente adentrarse en los capítulos sobre comunicaciones,
finalizando con la realización de un proyecto que utiliza las más importantes características
descritas.
Siemens Productos y Sistemas.
1 Scada: Sistema de visualización y control para procesos industriales desde PC.
2 Driver: Código que implementa el protocolo de comunicaciones con un determinado equipo inteligente.

Manual WinCC V4.02 Instalación WinCC
INSTALACION
DE WINCC V4.02


2 INSTALACION
2.1 Instalación de WinCC V4.02

El WinCC se suministra en formato de CD-ROM, además de un disco de protección de
color amarillo, en el que se encuentra la llave de autorización, ya sea para el paquete de
desarrollo o para la runtime.
Los sistemas operativos que soporta son Windows 95, Windows 98 y Windows NT4.0.
No puede instalar el WinCC en Windows 3.x

2.2 Primeros pasos de instalación

Introduzca el CD en el ordenador. Si tiene activada la opción autorun en su PC
aparecerá la siguiente pantalla de instalación:
Seleccionar
opción
Instalar
selección
Notas de
instalación
Diapositivas
Powepoint
Guía
iniciación
Simulador de
variables
Cambio
de idioma
Salir de la
instalación
Si no dispone del autorun activado, ejecute el fichero setup.exe del raíz de su CD.
A continuación veremos las diferentes opciones posibles.

2.2.1 Pestaña Seleccionar opción instalación:
Nos permite seleccionar la aplicación a instalar, desplegando la solapa como muestra

la figura. Las diferentes posibilidades son:
• Cyberlogic Chanel Driver: canal específico de comunicaciones (versión demo).

• WinCC Control Center: El software completo del WinCC.
• WinCC Demostration Sample Demo V4.02: Proyecto de ejemplo en el que se muestran
algunas posibilidades del WinCC.
2.2.2 Botón Instalar aplicaciones:
Este botón nos permite instalar el software seleccionado anteriormente.
2.2.3 Botón Notas de instalación:
Fichero en Word sobre las peculiaridades de la instalación.
2.2.4 Botón Diapositivas Powerpoint
Algunas imágenes en las que se explica las características técnicas y de

comunicaciones de WinCC. Para poder visualizarlas es necesario tener instalado el
PowerView, utilidad de visualización para transparencias de powerpoit.

2.2.5 Botón Guía de iniciación rápida
Esta guía en formato Word le permite adentrarse en el mundo del WinCC mediante la
explicación de un ejemplo claro y sencillo. Es muy recomendable que se imprima dicha guía en
papel y realice el ejercicio descrito antes de comenzar a desarrollar un proyecto en WinCC, ya
que se describen los casos más usuales de manejo del paquete.
2.2.6 Botón Instalar Simulador de Variables
Este software nos permite simular un valor periódico (seno, coseno, etc..) en unas
variables internas de WinCC. Esto es útil cuando necesitamos dinamizar algún proceso (p. Ej.
Para visualizar gráficas de curvas o animar una barra analógica) y, o no disponemos de ningún
PLC con el que poder animar la propiedad, o el PLC no dispone de ningún valor que se
encuentre variando de manera constante.
2.2.7 Botón Cambio de idioma:
Podemos cambiar el idioma del software de la instalación de WinCC, pero sólo entre
inglés, alemán y francés. Este cambio de idioma corresponde a los textos del menú del
programa de desarrollo, no confundir con los textos de la aplicación que vamos a desarrollar
con WinCC.
2.2.8 Botón Salir de la instalación:
Con este botón se sale de la instalación de WinCC
Suponemos que ya tenemos instalado Internet Explorer en nuestro ordenador, por lo

que seleccionamos la opción WinCC Windows Control Center y presionamos el botón
de instalación (esquina superior derecha).
Se inicia el asistente de instalación del paquete de software que nos va guiando paso a
paso en la instalación.
Lo primero que nos solicita es el número de identificación de nuestro disco llave. Este
número aparece en la etiqueta del disco amarillo de protección, y en la primera página del
contrato de software que aparece dentro de la caja de WinCC.
Tenga presente que este número que se le solicita es para la licencia de desarrollo, por
lo que si usted dispone sólo de la licencia de runtime, no debe introducir el número de licencia
de runtime.

Figura 1: Número de identificación del software de desarrollo.
En la pantalla de registro, si no se dispone de autorización para desarrollar aplicaciones

(paquete de desarrollo CS), puede introducir cualquier texto en el campo ID_No, permitiéndole
seguir instalando el software (por ejemplo x).
La única limitación que se producirá si no dispone de llave de desarrollo, será que:
• Cada vez que arranque el WinCC en runtime, le aparecerá un cartel indicándole que no
dispone de licencia.
• Si no tiene activado el runtime de WinCC, una vez transcurrida media hora, el programa
automáticamente se saldrá a Windows (previamente le consulta al respecto de si desea
guardar las últimas modificaciones).
Si deja siempre activado el runtime, aparece el mensaje
indicándole que se va a desactivar el WinCC, pero en realidad
no lo hace, por lo que puede seguir desarrollando y
comunicando de manera ilimitada, siempre y cuando cada
media hora presione el mensaje de aviso que aparece en
pantalla.
Cuando el tiempo de desarrollo expire, si tiene activada la
runtime del WinCC, las aplicaciones auxiliares del WinCC
(tales como el graphic designer) serán cerradas.

A continuación se nos pide el path donde deseamos guardar el software (por defecto
C:\Siemens\WinCC), así como si deseamos instalar el software en otro idioma además de en
inglés.
Figura 2 : Idioma del software y ruta de instalación.
A continuación se nos permite elegir entre los tres tipos de instalación que podemos
realizar:
• Típica: Se instalan los componentes habituales de WinCC.

• Definida por el usuario: Permite seleccionar todas las opciones posibles.
• Mínima: Se instalan los componentes mínimos de WinCC.

Figura 3 : Tipos de instalación.
Seleccionamos la opción User defined y las opciones disponibles son:

1 . WinCC y archivos de ayuda: Programa completo (116 Mb).
2 . Samples: Ejemplo de comunicación OLE (43 K).
3 . Options: Instala los paquetes opcionales del WinCC (13 Mb).
4 . Comunication: Instala los drivers de S7 para poder comunicarse con equipos S7 a través
de MPI (9 Mb). Si dispone ya de Step 7 instalado en su ordenador, no le es necesaria esta
opción para comunicarse con S7 300/400, ya que instala el software que se encarga de ajustar
la interface MPI.
Seleccionamos las opciones WinCC, Help, Options y Comunication (compruebe

anteriormente que dispone de un mínimo de 130 Mb libres para esta selección en el disco
duro).

Figura 4: Instalación personalizada del WinCC.
A continuación se nos consulta sobre el modo de optimizar la base de datos que

genere el WinCC.
Figura 5: Optimización de la base de datos Sybase SQL.

Los datos del WinCC se almacenan en un fichero de extensión DB, que posee un
formato SQL Server, y puede optimizarse para velocidad en acceso a los datos, con lo cual la
base de datos generada ocupará 4 Mb, o optimizarlo para espacio en el disco duro, con lo cual
la base de datos se reduce a la mitad de tamaño pero el tiempo de acceso a la misma
aumenta. Seleccionamos optimizada para velocidad en acceso a datos (4 Mb.)
Figura 6: Llaves de autorización.
Lo siguiente que se nos pide es la introducción de la correspondiente autorización de

software de desarrollo. Si no disponemos de la misma, podemos saltar este paso
seleccionando la opción No, authorization will be carried out later.
Nos aparece por ultimo una ventana resumen de todas nuestras opciones
seleccionadas y comienza el proceso de instalación, que puede durar una media hora
aproximadamente.

Figura 7: Finalización de la instalación de WinCC.
Si la instalación ha sido satisfactoria, deberá aparecer una pantalla como la siguiente

indicándonos que debemos reinicializar el ordenador para que el WinCC pueda arrancar
correctamente.
Con esto se concluye la instalación del WinCC.

2.3 Desinstalación de WinCC

Para poder desinstalar alguna parte del WinCC, instalar alguna opción a posteriori o
desinstalar completamente el paquete del PC es necesario repetir los pasos anterior como si se
estuviese instalando el software de nuevo. El sofware de instalación detecta que ya existe una
copia del programa en el disco duro y nos permite elegir entre las siguientes opciones:
Figura 8: Desinstalación de WinCC.
Podemos:
• Quitar/poner partes del programa.
• Quitar/poner un lenguaje del programa.
• Desinstalar completamente el software del disco duro.

2.4 Instalación de la Demo de WinCC.

Seleccione en la pestaña superior Demo V4 y presione el botón de instalación.
El Asistente le indica que un total de 78 Mb son necesarios en el disco duro para poder
instalar la demo. Curiosamente, no existe posibilidad de cambiar de unidad de instalación ni
seleccionar el subdirectorio en el que se va a instalar (que por defecto es c:\demoV4), por lo
que debe anteriormente comprobar que dispone de 80 Mb en C: antes de instalar la demo.
Figura 9: Demostración de WinCC.
Para que pueda ejecutar la demo en su ordenador, deberá cambiar el nombre de

Computer al de su PC.

2.5 Instalación del simulador de WinCC.

Si no disponemos de un PLC para conectarnos, en ocasiones puede ser de utilidad un
simulador de variables que nos genere valores variables en el tiempo, para que sin disponer de
comunicación podamos observar una gráfica evolucionando, por ejemplo.
Figura 10: Instalación del simulador de WinCC.
El software que se encarga de realizar esto se debe instalar a parte del WinCC,
seleccionando la opción del menú principal de la instalación de WinCC. El asistente nos
permite modificar el subdirectorio en el que se va a instalar la aplicación.
Si no se modifica, el programa instala en el subdirectorio C:\Siemens\Sim, los
archivos Simeng.exe y Simdeu.exe. Ambos son el mismo programa, pero en versiones inglesa
y alemana del simulador de variables. Para arrancar el simulador desde el menú inicio vamos
a:
Inicio->Simatic->WinCC->WinCC Simulator
El simulador sólo puede arrancarse si ya se está ejecutando la runtime de un proyecto

de WinCC, debido a que necesita conocer las variables de proceso actualmente vigentes para
poder simular (variables internas). Si intentamos ejecutar el simulador sin tener arrancado
dicha runtime en la versión 4.01, no realiza aparentemente ninguna acción, pero en realidad

carga una instancia en memoria del programa, que posteriormente al arrancar la runtime de
WinCC bloquea el PC. Para comprobarlo, ejecute el simulador sin tener el WinCC arrancado y
posteriormente presione Ctrl+Alt+Supr. Verá como aparece una instancia de Simulation que
anteriormente no existía.
Este fallo se encuentra corregido en la versión 4.02. En cualquier caso, si intenta
ejecutar el simulador sin tener activado el runtime de WinCC aparecerá el siguiente mensaje:
Figura 11: Fallo del simulador.
Suponiendo que ya hemos arrancado WinCC y ejecutado un runtime de proyecto,

podemos a continuación arrancar el simulador, apareciéndonos la imagen inferior.
Figura 12: Variables del simulador de WinCC.

Si en el menú principal accedemos a Edit->New Tag nos aparecerán el administrador

de variables de nuestro proyecto en WinCC actual, pudiendo desde aquí tanto definir nuevas
variables internas como elegir una de las ya existentes. Una vez seleccionadas las variables
que deseamos simular, en la pestaña de propiedades se puede asociar un tipo de señal
predeterminada a cada una, para que el simulador se encargue de animar dichos valores. Es
necesaria para que la asignación sea efectiva la selección de la casilla active. Las diferentes
posibilidades en cuanto a señales pre-configuradas son:
• Función seno:
Figura 13: Función seno del simulador.

• Oscilación: valor senoidal sobre un valor de continua o estacionario.
Figura 14: Función oscilación del simulador.

• Random: valor aleatorio entre unos límites máximo y mínimo. El ideal para simulación de
gráficas y valores dinámicos.
Figura 15: Función aleatoria del simulador.

• Inc: Rampa incremental que al llegar a un valor comienza formando dientes de sierra.
Figura 16: Función rampa ascendente del simulador.

• Dec: Rampa decremental que va disminuyendo hasta un valor cero, formando dientes de
sierra invertidos.
Figura 17: Función rampa descendente del simulador.

• Slider: en función de nuestros desplazamientos por la barra que nos habilita el simulador
podremos definir el valor de la variable. Ideal para simular valores estáticos.
Figura 18: Función slider de WinCC.
2.5.1 ¿Cómo asignar variables al simulador?
Para poder simular variables, primero tenemos que asignárselas al programa de

simulación. En el menú Edit->New Tag podemos seleccionar la variable del proyecto activo
actualmente. Después deberemos de seleccionar la casilla active. En la solapa list of tags
podemos visualizar el valor actual de la variable simulada.
En la opción Edit->Delete Tag podemos borrar una variable creada.
Si deseamos cambiar de forma de onda una variable ya seleccionada, deberemos de
volver a marcar la casilla active aunque ya aparezca seleccionada.

Manual WinCC V4.02 Estructura WinCC
ESTRUCTURA
DEL WINCC


3 Estructura de WinCC
3.1 Estructura del programa

Una vez instalado WinCC se nos genera en el disco duro la siguiente estructura de
directorios:
Veamos los archivos más importantes y su utilidad:

• Diagnose: en este subdirectorio se encuentran archivos de texto generador por WinCC
para poder analizar los problemas que puedan surgir en la ejecución del programa.
License.log: licencias de los paquetes instalados y violaciones cometidas
(rebasamiento de límite de variables, etc..).
License.bak: el archivo license.log del anterior arranque de WinCC.
WinCC_Op_01.log: mensajes de operador generados por WinCC durante el runtime.
WinCC_Sstart_01.log: mensajes de error generador por WinCC en el arranque de la
runtime.
WinCC_Sys_01.log: mensajes de error generador por WinCC durante la runtime.
S7chn01.log: mensajes de error generados por el canal de comunicaciones S7.
• Bin:
Apdiag.exe: programa de diagnosis del funcionamiento de la aplicación runtime, en el
que podemos estudiar los procesos internos que se van realizando en el código de la
runtime. Si activa la runtime de un proyecto, puede arrancar a su vez este programa,
que permite observar los mensajes del sistema, la ejecución de eventos y exportar esta
información a un fichero de texto. Incluso es posible que muestre mensajes
automáticamente en la pantalla cuando detecte un error interno en la ejecución del
WinCC.

Figura 19: Ventana output de Apdiag.exe
Apitest.exe: este programa nos permite manejar todos los objetos de un

proyecto desde una sola ventana, modificando sus propiedades y enlaces.
Para poder visualizar los objetos tendremos que introducir el path de nuestro
proyecto y el mcp del mismo.

Figura 20: Ventana de ApiTest.exe.
CCAuthorInformation.EXE: Este programa nos permite conocer las
Figura 21:Programa CCAuthorInformation.EXE
autorizaciones que poseemos actualmente instaladas y la cantidad de variables

que se utilizan en el proyecto que actualmente se está desarrollando.

CCConvert.exe: programa de conversión de la base de datos de un proyecto

realizado con una versión anterior a la 4.0 de WinCC. Anteriormente la base de
datos runtime y de desarrollo se encontraban unificadas. Este programa separa
dicha información para poder ser tratada en esta nueva versión.
Figura 22: Programa de conversión CCConvert.exe
CcMetaViewRt.exe: Este programa nos permite visualizar la documentación a

imprimir desde WinCC en modo runtime.
Figura 23: CCMetaviewRt.exe
CCProjectDuplicator.exe: Duplicación de proyectos. En sistemas

redundantes, es necesario disponer de una copia del proyecto en el ordenador

que va a trabajare en stand-by. Mediante esta utilidad podemos disponer

automáticamente del proyecto duplicado.
Figura 24: Duplicador de proyectos.
DynWizEdit.exe: Editor de Wizards. Mediante este programa podemos no solo

editar los wizards que acompañan al graphic designer, sino generar nuestros
propios asistentes.
Los asistentes generados se guardan como ficheros wnf en el
subdirectorio wincc\wscripts\wscripts.enu (los del idioma inglés). Podemos
basándonos en los mismos, editarlos y generar los scripts en español.

Figura 25: Editor de scripts para WinCC.
Wunload.exe: programa de compactación de la base de datos del proyecto. A

medida que se van generando estructuras en WinCC (objetos, curvas, etc..) y
se van borrando del proyecto, quedan páginas en blanco dentro de la base de
datos. Estas zonas de memoria vacías pueden ser eliminadas con lo que se
reduce el tamaño de la base de datos db.
La nueva base de datos generada se almacena en un subdirectorio que genera
el programa automáticamente denominado Wunload. Deberemos
posteriormente copiar esta base de datos compactada en el subdirectorio de
nuestro proyecto, realizando previamente una copia de seguridad de la misma.

Figura 26: Utilidad de compactación de bases de datos.

3.2 Estructura del proyecto

Vamos a estudiar la estructura que nos genera WinCC en el disco duro al crear un nuevo
proyecto.
Archivos del sistema:

Directorio raíz:
Db -> la base de datos con los parámetros de configuración del proyecto.
Rtdb -> la base de datos con los valores de runtime, tendencias y mensajes.
Mcp -> fichero principal del proyecto. Este archivo es el que abre el proyecto.
Directorio GraCS:
Pdl -> las imágenes del proyecto.
Sav -> ficheros backup de las imágenes. Si se realiza una modificación errónea en una
picture y se salva se puede recuperar renombrando el fichero sav como pdl.
Bmp, wmf, emf: ficheros de imágenes.
Act -> acciones C. Un código C se puede almacenar en uno de estos ficheros para
luego ser importado desde otro proyecto sin disponer del proyecto original en donde
residía el código.
Pdd -> parámetros por defecto del graphic designer.
Directorio Library:
H -> declaración de funciones C.
Pxl -> librería de símbolos.
Fct -> project functions (funciones de proyecto definidas por nosotros).

Directorio Pas:
Pas -> acciones de proyecto que son disparadas por un trigger y corren en
background con respecto al runtime del proyecto.
Directorio Prt:
rpl -> layouts para realizar reports a impresora. Los definidos por el sistema comienzan
con el carácter @.
Rp1 -> line layouts. Definiciones de líneas a impresora para impresión de eventos en
tiempo real.
Archivos opcionales:
Directorio raíz:
Ini -> archivo de inicialización del simulador de variables.
Sim -> variables internas a simular por el simulador de variables.
Csv -> textos exportados separados por comas.
Txt -> mensajes exportados separados por comas.
Emf -> report a impresora exportado a un fichero.
Log -> ficheros de diagnosis de la ejecución del WinCC.

Manual WinCC V4.02 Control Center
CONTROL CENTER


4 CONTROL CENTER
4.1 Introducción.
Control Center representa el acceso a todas las opciones del WinCC como sistema de
desarrollo para visualización de procesos industriales. Desde el Control Center podemos disponer
de todos los módulos software para la creación de ventanas gráficas, archivos de procesos,
ventanas de alarmas, y generación de documentos a impresora.
Además de esto, la filosofía abierta del WinCC posibilita la interconexión desde aquí del
sistema con otras aplicaciones, ya sea a través de OLE, DDE o ODBC.
Al arrancar el WinCC, existen tres posibilidades:
a) Que anteriormente no hubiera ningún proyecto abierto, con lo que se nos abre
automáticamente una caja de diálogo en la que se nos permite crear un nuevo proyecto o abrir
uno existente.
b) Que ya hubiera un proyecto abierto anteriormente, con lo que no nos aparece esta caja de
diálogo, sino el proyecto en cuestión.
c) Que el proyecto ya estuviera abierto y en runtime cuando lo abandonamos la última vez, con lo
que arranca automáticamente la runtime del WinCC.

Figura 27: Crear o abrir un proyecto de WinCC.
Si deseamos un nuevo proyecto, como podemos ver se permite la generación de

proyectos Single-User System (proyectos monopuesto), y Multi-User System (proyectos
multipuesto).
El presente manual se centra en los proyectos monopuesto. Vea el apéndice de
configuraciones al final del libro para más información al respecto de las configuraciones
multipuesto.
Si no desea que arranque la runtime automáticamente al

entrar a un proyecto, cuando esté arrancando el mismo
mantenga presionadas las teclas control + mayúsculas.

4.2 Crear un nuevo proyecto.

Seleccionamos Single-User System (Crear un nuevo proyecto monopuesto), y se nos
solicita a continuación un nombre para el mismo. En el siguiente cuadro de diálogo se puede
decidir tanto el nombre del proyecto, como el nombre del subdirectorio en el cual lo vamos a
guardar, así como el path hasta el mismo.
Figura 28: Nuevo proyecto
Al crear el nuevo proyecto se nos genera por defecto un subdirectorio en el path

c:\siemens\wincc\winccproyects\dunker en el cual se almacenarán todos los archivos que
nosotros generemos en la realización de nuestro proyecto, por lo que si deseamos mover nuestro
proyecto a otro ordenador distinto, deberemos de copiar íntegramente todo este subdirectorio en el
otro ordenador.

Figura 29: Ventana del Control Center.
La estructura que nos genera en el disco duro es la que se muestra en la figura superior.
De toda esta estructura, el único subdirectorio que ya contiene inicialmente archivos es el
de Prt, en el cual se encuentran los reports a impresora pre-configurados.
Figura 30: Estructura de un proyecto.
Los demás archivos son:

a) Dunker.db: base de datos del proyecto.
b) Dunker.log: fichero donde se guardan los datos de los objetos que componen el
proyecto.

c) Dunker.mcp: fichero de proyecto. Es el que debe de invocarse desde el control center

para ejecutar el proyecto.
d) DunkerRT.db: base de datos del proyecto en modo runtime.
Como se puede observar desde el Control Center, todo proyecto de WinCC se divide en una
serie de partes bien definidas y siempre iguales, lo que nos permite afrontar cualquier tipo de
proyecto siguiendo siempre las mismas pautas de trabajo.
Un proyecto está compuesto por:
• El nombre del proyecto, en este caso Dunker,
• Computer: Todos los parámetros relacionados con el entorno de trabajo de la aplicación en
general.
• Tag Management: Administrador de comunicaciones (tener en cuenta a partir de ahora que
tag equivale en el proyecto a una variable, sea de comunicaciones con el PLC o interna del
proyecto).
• Data Types: Agrupación de las variables del WinCC por tamaño, sin distinción de origen de
los datos (comunicaciones o internos).
• Editors: Editores de las diferentes partes en que se subdivide el runtime del WinCC. Dentro
de este apartado nos encontramos con:
Graphics Designer: Editor gráfico que nos permite dibujar las pantallas que componen el
WinCC.
Alarm Logging: Editor de alarmas que nos permite configurar las ventanas y tratamiento
de alarmas del proceso.
Tag Logging: Editor de archivos y gráficas que e encarga de configurar el
almacenamiento de datos y su posterior visualización en forma de curvas o de tablas.
Report Designer: Editor de informes a impresora. Se encarga de configurar todo lo
referente al envío a impresora de informes.
Global Script: Compilador en C que nos permite programar nuestras propias acciones y
ejecutarlas de manera periódica o mediante eventos de cambio de variables.
Text Library: Editor de texto que nos permite asignar diferentes configuraciones de textos
según el idioma seleccionado en el WinCC.
User Administrator: Administrador de usuarios que nos permite activar o desactivar
usuarios mediante activación de passwords.
4.2.1 ¿Cómo inicializar la base de datos de runtime?
Los datos del proceso son almacenados en la base de datos PROYECTORT.DB siendo
PROYECTO el nombre de nuestro proyecto. A medida que se trabaja en modo runtime el tamaño
de dicha base va aumentando (histórico de alarmas, archivos, etc..). Si en un momento dado es

necesario inicializar dicho archivo, realice una copia de seguridad del mismo y siga los siguientes
pasos:
• borre el archivo PROYECTORT.DB
• copie el archivo WINRT.DB del subdirectorio WinCC\bin en su proyecto.
• Renómbrelo como PROYECTORT.DB.

4.3 Base de datos SQL AnyWhere

Trabajando en background se encuentra la base de datos Sybase SQL AnyWhere, que se
encarga de almacenar la información proveniente del proceso, para posteriormente suministrársela
a la aplicación runtime cuando esta así lo solicite.
Los datos que podemos obtener de la ventana de Sybase son:
• El fichero de transacción con el que está trabajando (dunker.log)
• La fecha y hora en que arrancamos el runtime y,
• El estado actual de la base de datos (arrancada, parada, con error).
Es muy importante que no cerremos la aplicación y siempre la mantengamos minimizada,

ya que si cerramos esta ventana, nuestro proyecto perderá el enlace con su propia base de datos,
y la aplicación se bloqueará.

4.4 Opciones del menú del Control Center

Vamos a comentar las opciones del menú del Control Center que no son directamente
autoexplicativas, y poseen un especial interés.
4.4.1 Print FeedBack Doc..
Esta opción nos permite generar un report para documentar nuestro proyecto. Si
deseamos modificar el formato que nos aparece por defecto, tenemos que ir al report designer y
modificar el report @Documentation Control Center.
Figura 31: Documentación de un proyecto de WinCC.
4.4.2 Shut Down
Esta opción del menú nos permite seleccionar la forma en la que deseamos salir del
WinCC.
Las opciones disponibles son:
• Salir de Windows, cerrando todas las aplicaciones que estuvieran abiertas (apagar el
ordenador en una instalación).

• Salir de Windows y rearrancar, reinicializa el Windows, pero no entra automáticamente al

WinCC, salvo que se coloque el exe del WinCC en la opción Inicio de Windows. Esta opción
es interesante cuando se desea reinicializar el WinCC debido a que alguna aplicación no está
funcionando correctamente.
• Dar de baja al usuario actual y solicitar la entrada de uno nuevo. Esta opción es interesante
cuando deseamos desactivar nuestro password en un cambio de turno, y el operario va a ser
sustituido por otro compañero que se va a hacer cargo del sistema.
Figura 32: Salida de Control Center.
4.4.3 Idioma del Control Center
Si hemos seleccionado algún idioma además del inglés en la instalación del WinCC,
disponemos en Tools->Languaje de la posibilidad de cambiar de idioma el Control Center.
Figura 33: Idiomas de Control Center.

Es importante recordar que estos idiomas son para el Control Center, no para la runtime.
Por esta razón no aparece la opción en español, ya que el software sólo está disponible en
francés, inglés y alemán. Sin embargo, esto no impide que en la runtime podamos seleccionar los
textos directamente por la referencia Español.
4.4.4 Status de conexión
Si tenemos la runtime activada de un proyecto de WinCC, desde el menú Tools->Status

of driver Connection... podemos acceder a una pantalla en la que se nos muestra el estado de
las comunicaciones del WinCC con los diferentes drivers que hemos configurado.
Figura 34: Status de comunicaciones con el proceso.
La información suministrada se divide en:

• Name: Nombre de la conexión lógica
• Status: Estado actual de la conexión (connected = con comunicación / disconnected = sin
comunicación).
• Error: Código de error de las comunicaciones
• Tags Read: Variables leídas desde que se arrancó la runtime.
• Tags Writted: Variables escritas en la conexión lógica desde que se arrancó la runtime.
• Read Requests: Lectura de variables solicitadas por el WinCC a la conexión lógica.
• Write Requests: Escritura de variables solicitada por el WinCC a la conexión lógica.

Para actualizar los campos, se puede seleccionar la casilla Cyclic Update, que actualiza cada
segundo el estado de las comunicaciones en la ventana, así como las variables leídas y escritas.

4.5 Datos del Proyecto
4.5.1 Introducción
Vamos a repasar todas las opciones que nos ofrece el proyecto recién generado, visto
desde la ventana del Control Center.
4.5.2 General Information.
Si nos posicionamos sobre el nombre del proyecto (DUNKER) y presionamos el botón

derecho del ratón, aparece un menú contextual indicándonos las opciones buscar y propiedades.
Seleccionamos esta última teniendo acceso al cuadro de diálogo inferior. Su significado es:
• El tipo de CPU nos permite seleccionar un proyecto para un sistema monopuesto o
multipuesto. Evidentemente es importante tener cuidado en no cambiar este parámetro si
deseamos trabajar en monopuesto.
• Podemos también introducir la versión de nuestro proyecto y un comentario.
• El campo GUID sirve como información para conocer el número ID que se le asigna al
proyecto generado. WinCC asigna un número propio para cada proyecto generado. Este dato nos
será útil a la hora de conocer la base de datos con la que debemos conectarnos a través de ODBC
de manera externa a WinCC, ya que nos permitirá dirigirnos a la base de datos que corresponda
según este indicador.

Figura 35: Información general de un proyecto.
4.5.3 Update cycles.
En la solapa de ciclos de actualización podemos observar los períodos de actualización

predefinidos, permitiéndonos modificar los 5 últimos ciclos (denominados de usuario), e introducir
un ciclo personalizado basándose en los ya definidos. En posteriores apartados se nos brindará la
posibilidad de realizar diversos eventos en función del ciclo definido en esta solapa por nosotros.
Ejemplo:
Si deseamos leer un valor de proceso cada 6 segundos, definiremos aquí este tiempo en base
a milisegundos (6000) y posteriormente utilizaremos como ciclo de lectura el user cycle 1.

Figura 36: Ciclos de actualización/adquisición.
4.5.4 Hotkeys:
En la solapa hotkeys podemos definir:

• La combinación de teclas para activar la ventana de activación de usuarios. Para ello se
selecciona log on, se pincha en la ventana de asignación previa, se presiona la combinación de
teclas y por último se realiza click sobre el botón Assign.
• La combinación de teclas para ocultar dicha ventana.
• La combinación de teclas para realizar un hardcopy de la pantalla actual del ordenador por
impresora.
Hay que tener en cuenta que para poder realizar un hardcopy con el botón asignado, no
basta con la simple asignación, sino que debemos de arrancar el programa PrtScr.exe que se
encuentra en el subdirectorio C:\Siemens\WinCC\bin, para poder realizar hardcopys de pantalla.
Posteriormente veremos como poder arrancar una aplicación automáticamente al arrancar
el runtime del WinCC.

Figura 37: Asignación de hotkeys.
4.6 Computer:
Si presionamos el botón derecho sobre la opción computer de Control Center podemos

seleccionar properties de nuestro ordenador. Aquí se encuentran todas las características
globales de nuestra aplicación runtime.

Figura 38: Lista de ordenadores de nuestro proyecto.
4.7 Computer Properties
4.7.1 General Information.
Esta opción nos permite seleccionar el nombre de nuestro ordenador. Hay que tener en
cuenta que dicho nombre ha de corresponder al asignado en Windows 95, 98 o NT, ya que de otro
modo al ejecutar la runtime WinCC nos indicará que no encuentra dicho nombre en su lista de
servidores.
En los ejemplos que vienen con WinCC, los nombres de los

ordenadores no corresponden lógicamente con el asignado a nuestro
ordenador, por lo que no se pueden ejecutar. Para solucionar el problema, sólo
debe de cambiar en esta solapa el nombre del ordenador especificado por el
de su PC.
Introduzca el nombre que le indica en el mensaje de aviso como nombre de
unidad.
Cuando usted realice sus propios proyectos, le aparece
automáticamente el indicador de su estación local, por lo que para saber cual
es el nombre de su estación solo debe de realizar un nuevo proyecto.

El mensaje que aparece si no tenemos correcto el nombre de nuestra estación es el

siguiente:
Figura 39: Nombre de ordenador erróneo.
Figura 40: Lista de servidores del proyecto.

4.7.2 Startup:
Figura 41: Partes del runtime del WinCC.
En esta solapa podemos seleccionar la parte del runtime que deseamos activar en WinCC.
El runtime del WinCC está dividido en varias partes para poder optimizar el tiempo de respuesta
en el procesamiento de las comunicaciones. Esto es así, ya que si por ejemplo no se dispone de
impresora en la instalación, no es necesario activar la parte de runtime que corresponde a la
impresora, con lo que no pierde tiempo el programa, encargándose de realizar esa parte de
código.
Hay que tener en cuenta que con respecto a la runtime del Global Script, su ámbito de
activación no es exclusivamente el de programar funciones en C. Si asignamos un script a un
botón deberemos de tener activado el runtime de Global Script, ya que de facto esto es una acción
en C. Esto no es siempre obligatorio para todas las acciones en C, pero es conveniente ya que
algunas no se ejecutarán si no tiene instalada la parte de Global Script.
A su vez, en Additional Tasks podemos asociar aquellas aplicaciones que deseamos que
se ejecuten cada vez que arranque la runtime del WinCC.

Hay que tener en cuenta que al parar el WinCC no desactiva

aquellas tareas que hubiera arrancado, por lo que si
asociamos Excel al arranque del mismo, y lo arrancamos y
paramos varias veces, el resultado será que tendremos
varias instancias o copias en memoria del programa, ya que
nos lo arrancará cada vez sin chequear si ya estaba
arrancada la aplicación.
Figura 42: Parametrización de la aplicación a arrancar.
Si presionamos el botón Add.. podemos configurar un caja de diálogo en la que

introducimos el nombre de la aplicación a arrancar, podemos pasarle comandos o definir si se
debe ejecutar minimizada, normal, o maximizada. En la imagen se muestra como llamar a una
hoja de Excel automáticamente al arrancar WinCC.

4.7.3 Parameter:
Figura 43: Idioma del runtime y inhabilitación de teclas.
En esta pestaña podemos seleccionar el lenguaje del runtime del WinCC (por defecto
viene en inglés). No confundir con el lenguaje del entorno de desarrollo, que sólo puede ser en
inglés, francés y alemán, seleccionándose en el menú, y no en esta opción.
Por defecto sólo aparece un idioma (inglés) para comenzar la aplicación, pero podemos
disponer prácticamente de cualquier idioma en esta solapa, siempre y cuando en el Text Library
añadamos este idioma a la tabla (para más información ver Text Library).
A su vez, también podemos seleccionar la prioridad de acceso al microprocesador de la
cpu de nuestra aplicación. Si seleccionamos prioridad alta, nuestra tarea será la única que podrá
acceder de una manera ágil al micro, por lo que cualquier tarea que se desee realizar en paralelo
se verá ralentizada al máximo.
También podemos deshabilitar algunas combinaciones de teclas. Las diferentes
posibilidades son:
• Ctrl+Alt+Del: Impide cerrar el WinCC realizando un reset por software.

• Alt+Tab: Impide que podamos cambiar de aplicación activa.

• Ctrl+Esc: Impide que aparezca el menú inicio, que permitiría al usuario cambiar de aplicación.
• Alt+ Esc: Impide cambiar de aplicación a la siguiente activa en memoria.
4.7.4 Graphics-Runtime
Figura 44: Pantalla inicial y características de las pantallas.
En esta ventana podemos:

• Consultar el nombre y el path de nuestro proyecto.
• Asignar la picture inicial con la que debe de arrancar nuestro runtime.
• Definir los atributos de todas las ventanas
• Deshabilitar algunas propiedades de las ventanas, como pueden ser minimizarse o
maximizarse.
• Asignar la combinación de teclas que permite a un usuario controlar el desplazamiento a
través de los controles del WinCC con el teclado.

Las posibilidades a la hora de configurar la apariencia de las ventanas son:

• Title: Añade un título a todas las ventanas.
• Border: Añade un borde a todas las ventanas
• Maximize: Activa el botón maximizar de todas las ventanas, por lo que pueden ser
maximizadas.
• Minimize: Lo mismo pero para minimizar las ventanas.
• Full Screen: La ventana ocupa todo el tamaño de la pantalla, por lo que queda oculta la barra
de Windows y cualquier otra aplicación. Ideal para desarrollos que solo vayan a gastar el
WinCC en la instalación.
• Scroll Bar: Activa la barra de desplazamiento cuando el tamaño de la ventana diseñado en el
runtime oculta objetos diseñados en el desarrollo.
• Status Bar: Coloca una barra de estado en la parte inferior de la ventana.
• Adapt Picture: Adapta el tamaño de los objetos al tamaño actual diseñado de la ventana.
Con respecto a los atributos de ventana que se pueden bloquear, las posibilidades son:
• Alt+F4: Impide que se pueda cerrar la ventana de runtime con la combinación Alt+F4.
• Change Size: Impide que se pueda modificar el tamaño de la ventana de runtime desde el
propio runtime.
• Move: Impide que se pueda mover la ventana de runtime.
• Minimize: Impide que se pueda minimizar la ventana de runtime.
• Maximize: Impide que se pueda maximizar la ventana de runtime.
• Close: Impide que se pueda cerrar la ventana de runtime desde la X de la esquina superior
derecha de la ventana.
• Optimized View: Deshabilita la optimización del redibujado de los objetos en pantalla. Por
defecto, los objetos de la pantalla no se redibujan de manera individual, sino todos a la vez en
el denominado Windows Cycle. Si deseamos que cada objeto se redibuje de manera
independiente seleccionaremos esta opción, teniendo en cuenta que esto nos puede producir
parpadeos en la pantalla y retardos en el redibujado de la misma.
La combinación de teclas para el control desde el teclado del WinCC es la siguiente:

• Window on top: con esta combinación la ventana de WinCC se coloca en primer plano si
estaba tapada.
• Tab Order/Alpha cursor: El orden en el desplazamiento con el tabulador entre los diferentes
objetos puede ser:
• Tab Order: Orden e tabulación que se asigna desde el graphic editor a los objetos.
• Alpha cursor: Desplazarse sólo por los campos alfanuméricos, en lugar de por todos los
objetos que puedan activarse.
• Runtime Cursor On/Off: Se puede asignar una combinación de teclas para que aparezca un
cursor resaltando el objeto activo actual. Si se desea que siempre esté activa esta opción
(ideal en controles por teclado) hay que seleccionar Turn On during activation.

Figura 45: Runtime cursor on.
Además de la asignación de teclas para subir y bajar con el teclado, podemos configurar el
funcionamiento del cursor a la hora de desplazarse, eligiendo entre las siguientes opciones:
• Normal: El cursor al llegar al extremo de una fila de controles si nos desplazamos en
horizontal, comienza de nuevo por la izquierda (pasa de 3 al 1).En vertical exactamente igual
(pasa del 4 al 1).
• Normal Whitout Rollback: El cursor al llegar a un extremo de la fila o columna de controles
no continúa desplazándose (al llegar a 3 se queda en el 3 aunque sigamos intentando
desplazarnos hacia la derecha).
• Expanded: El cursor al llegar a un extremo de una fila o columna, continúa por el principio de
la siguiente fila o columna (al llegar a 3 pasa a 4, al llegar al 6 pasa al 1).

4.8 Tag Management
4.8.1 Introducción.
El administrador de variables se encarga de las comunicaciones entre las diversas redes

de PLC’s, acoplamientos punto a punto, y enlace con otras aplicaciones
Se divide en dos tipos de variables determinadas por su origen:
1. Variables de comunicaciones: son aquellas cuyo valor se obtiene de la comunicación
entre el WinCC y cualquier red de PLC’s u aplicación.
2. Variables internas: son aquellas cuyo valor no se obtiene de la comunicación con otras
aplicaciones, aunque pueden almacenar el resultado de una operación matemática
obtenida a partir de variables de comunicaciones.
Las variables internas se almacenan en la rama del árbol internal tags.
Las variables de comunicaciones para ser almacenadas requieren primeramente que se

añada el driver correspondiente de comunicaciones que posibilite la obtención de dichos valores.
4.8.2 ¿Qué es un driver o canal de comunicaciones?
Un driver de comunicaciones es una dll, con la extensión *.CHN que posibilita al WinCC
comunicarse con un determinado protocolo con un tipo determinado de PLC industrial o aplicación
software. Un canal de comunicaciones puede soportar varios enlaces de comunicaciones a la vez
o no, dependiendo del tipo de canal. Existen canales de comunicaciones que, pese a encontrarse
entro del CD de WinCC, necesitan para funcionar una licencia aparte. Para más información
acerca de cuales son, ver apéndice.
Es posible generar un nuevo canal de comunicaciones si se dispone de la herramienta
CDK, paquete de desarrollo de WinCC para canales de comunicaciones.
4.8.3 Adición de un driver de comunicaciones
Supongamos que deseamos conectar el WinCC a un autómata S7 300 o 400 para obtener
información de él. Primeramente necesitaremos añadir el driver de comunicaciones adecuado.
Para ello, seleccionando con el botón derecho tag management, aparece un menú contextual
cuya primera opción es añadir nuevo driver. Seleccionando esta opción nos aparecen todos
aquellos drivers de que dispone el WinCC.

Figura 46: Canales de comunicaciones de WinCC.
Seleccionamos el driver Simatic S7 protocol suite.
El driver indicado nos permite conectarnos a:

1. Una red MPI
2. Una red Profibús en FMS o funciones S7
3. Una red Ethernet
4. Una conexión a través de Slot PLC
5. Conexión en Ethernet mediante TCP/IP
Seleccionamos la opción MPI y presionando el botón derecho aparece un menú contextual en

el que podemos seleccionar system parameters. Esta opción definirá cual va a ser el acceso al
PLC desde el driver.
Seleccionamos PC Adapter si vamos a trabajar a través del cable PC/MPI, y MPI si vamos
a trabajar a partir de una tarjeta interna MPI.

Figura 47: Parametrización dispositivo MPI.
4.8.4 Adición de una nueva conexión
Si volvemos a colocarnos sobre el driver MPI y presionamos el botón derecho, una de las
opciones es new driver connection. Seleccionándola podemos configurar la dirección MPI y el
nombre simbólico que le queremos dar a nuestro enlace MPI (en nuestro caso AUTOMATA_314).
En la solapa connection podemos definir la dirección MPI del equipo al que vamos a
conectarnos. Los autómatas S7 disponen de un número identificativo comprendido entre 2 y 126
que les identifica dentro de una red MPI. También podemos activar la opción de envío y recepción
de raw datas. Como veremos más adelante, los raw datas son bloques de datos que no reciben
tratamiento a nivel de protocolo ni por parte del PLC ni por parte de WinCC. Es el sistema ideal
para el envío de estructuras de información o telegramas completos, en lugar de variables sueltas
de comunicaciones.

Figura 48: Nombre de la conexión lógica.
Figura 49: Dirección MPI de la conexión lógica.

Con esto se ha definido el enlace con un PLC S7 300/400 en la dirección MPI 2. Todas las
variables que se definan a partir de este enlace obtendrán su valor de las comunicaciones con
dicho PLC de manera automática. Para conocer otros tipos de enlaces a parte del S7 ver apéndice
al final del libro.
4.8.5 ¿Qué es un group?
Todas las variables, tanto las internas como las externas pueden agruparse en groups o
grupos de variables, lo que permite cuando el proyecto crece en tamaño acceder a las variables
de una manera más intuitiva.
Ejemplo:
Supongamos que deseamos realizar un proyecto de una máquina de lavado de coches,
que se compone de cuatro partes bien diferenciadas, entrada al lavadero, enjabonado, lavado y
secado
Definimos cuatro grupos de variables dentro de los cuales crearemos los tags que
correspondan a cada una de las partes de la máquina.

Para ello nos colocamos sobre AUTOMATA_314 y presionando el botón derecho

seleccionamos new group. Asignamos un nombre como muestra la figura para cada uno de los
grupos de variables.
4.8.6 ¿Qué es un tag?
Un tag es el elemento de enlace entre la base de datos del WinCC, las variables del PLC y
los objetos del runtime de nuestra aplicación. Los valores de los tag son almacenados en nuestra
base de datos del proyecto. Cuando arranca el WinCC, carga estos valores de la base de datos. A
partir de ese momento se pueden modificar dichos valores, pero hay que tener en cuenta que
dichas dinamizaciones no se almacenan en la base de datos, por lo que si utilizamos variables
internas para realizar una receta de valores, y nos salimos de WinCC, cargará al arrancar de
nuevo los valores de las variables internas que tenga asignados en propiedades estáticas, y no el
último valor que hubiésemos introducido.
Para crear una variable de comunicaciones o tag, nos colocamos sobre cualquiera de los
grupos creados y seleccionamos con el botón derecho new tag.
Figura 50: Propiedades de una variable de comunicaciones.

La solapa general information nos permite introducir un nombre simbólico para nuestra
variable de comunicaciones.
Recomendamos asignar el nombre de la dirección absoluta de la variable, seguido de una

indicación al equipo MPI del cual se está leyendo la variable, ya que si se intenta leer esa
misma variable de otro equipo MPI distinto, es necesario identificar las dos etiquetas de alguna
manera de tal forma que cuando vayamos a acceder a dichas variables sepamos de qué equipo
las estamos leyendo.
Presionando en el botón select podemos acceder a un cuadro de diálogo que nos permite
definir la dirección del mapa de memoria del PLC de la que queremos obtener el valor o donde lo
deseamos almacenar.
Figura 51: Direccionamiento de la variable de

comunicaciones.
Las zonas de memoria a las que podemos acceder son:

• Entradas digitales
• Salidas digitales
• Marcas
• DB’s

El poder seleccionar estos mapas de memoria nos permite realizar controles de instalaciones
que ya estuvieran funcionando con su programa de PLC siempre y cuando las zonas a las que
accedamos para escribir no estén a su vez siendo escritas desde programa de PLC. Con respecto
a la lectura no existe evidentemente ninguna limitación, accediendo a todas ellas libremente.
4.8.7 Control de límites en variables de comunicaciones
Figura 52: Límites de variables de comunicaciones.
En la solapa limits/reporting podemos definir:

• Los límites máximo y mínimo que WinCC debe chequear y como debe comportarse cuando se
alcancen, permitiendo sustituir el valor de comunicaciones por uno substitutivo.
• El valor que la variable de comunicaciones debe de tener al arrancar el WinCC.
• Si el valor substitutivo debe sustituir al valor de comunicaciones frente a un error en las
mismas.

4.8.8 Escalado de variables por software
Figura 53: Escalado de variables de comunicaciones.
También se pueden realizar escalados lineales de valores analógicos directamente en el

WinCC, tratando las señales según nuestra propia escala.
Ejemplo
Se desea leer un valor analógico que viene de una sonda 0-20 mA que dentro del PLC se
almacena tras la conversión analógica digital en un valor de 32 bits. La sonda aporta 0 mA para –
10 ºC y 20 mA para 60ºC. Leemos el valor directamente de la entrada del PLC y escalamos al
rango de la sonda, con lo que podemos obtener en el WinCC la representación en ºC del valor de
la sonda sin necesidad de más transformaciones dentro del PLC.

4.8.9 Tamaño de las variables o tags
En data type podemos seleccionar el tamaño de la variable que vamos a utilizar.

Las posibilidades a la hora de seleccionar el tamaño son:
• Binary tag: Un bit
• Signed 8 bit value: Un byte con signo (-128 a 127)
• Unsigned 8 bit value: un byte sin signo (0 a 255).
• Signed 16 bit value: Una palabra con signo (-32768 a 32767)
• Unsigned 16 bit value: Una palabra sin signo (0 a 65535)
• Signed 32 bit value: Una doble palabra con signo (-2147483647 a 2147483647)
• Unsigned 32 bit value: Una doble palabra sin signo (0 a 4294967295)
• Floating Point 32 bits: Una doble palabra en coma flotante de 32 bits de resolución
• Floating Point 64 bits: Una doble palabra en coma flotante de 64 bits de resolución
• Text tag 8 bit Character Set: Una cadena de texto de la longitud que deseemos de caracteres
de 8 bits (caracteres ASCII).
• Text tag 16 bit Character Set: Una cadena de texto de la longitud que deseemos de
caracteres de 16 bits (caracteres Unicode).
• Raw data type: Una telegrama de datos que no es tratado por el procesador del PLC
utilizando el protocolo propio de comunicaciones.
• Text Reference: Un puntero a una cadena de texto que se encuentra en el Text Library.
Asociándole a la variable el numero identificador del Text library, soporta el valor de la cadena
de texto que definamos allí.
• Structure Types: Una estructura es un conjunto de variables de igual o diferentes tamaño
agrupadas debido a una determinada propiedad que las relaciona. Para poder seleccionar una
propiedad en esta pestaña es necesario anteriormente haber generado la estructura en Data
Types.
4.8.10 Adaptar una variable de WinCC con respecto al valor del PLC
En la solapa Adapt format podemos adaptar las variables de comunicaciones al formato

de WinCC y viceversa (p. Ej. para convertir un valor del PLC entero en real dentro de WinCC o
viceversa). Cada tamaño de variable tiene sus propias conversiones.
4.8.11 Generación de variables internas (internal tags)
Las variables internas solo difieren de las de comunicaciones en tres aspectos:

a) No poseen la funcionalidad del botón select para asociar dicha variable al mapa de memoria
del PLC

b) Poseen una funcionalidad añadida, que es la opción de poder elegir si dicha variable debe ser
local para el ordenador en el que se genera o debe ser compartida por todos los ordenadores
cuando se trabaja en una red multipuesto.
c) A diferencia de las de comunicaciones, son gratuitas e ilimitadas, en función de la memoria
RAM de que disponga el PC.
Figura 54: Parámetros de variables internas.

4.9 Data Types
4.9.1 Introducción
Data types, agrupa las variables en lugar de por origen de los valores de las mismas, por
tamaño. Así las agrupaciones posibles son:
Desde esta opción podemos generar estructuras de variables que luego pueden ser
utilizadas en el Tag Management. Para generar una nueva estructura, sobre Structure Tag,
pulsamos el botón derecho y seleccionamos New...
Generamos una estructura de PID como la de la figura de abajo. Esto nos permite ir al Tag
Management, y cuando generemos una nueva variable, podemos asociarle esta estructura, con lo
que en lugar de estar definiendo una sola variable, definimos un grupo de variables, direccionando
de una sola vez todas dentro del PLC..

Figura 55: Definición de una estructura de variables.
Una estructura puede contener tanto variables internas como de comunicaciones. Al crear
una variable en el Tag Management de tipo Struct se puede asignar el tipo definido en este punto,
con lo que se generan tantas variables nuevas como tenga la estructura, siguiendo la siguiente
regla:
Variable_nueva.dato_estructura

4.10 Barra de estado de Control Center

En la parte inferior de la ventana principal del control center disponemos de una barra de
estado que nos informa de:
• Variables externas que estamos utilizando en nuestro proyecto. Esto nos permite
dimensionar la runtime que debemos adquirir para la comunicación una vez finalizado el
desarrollo.
• El modo de desarrollo que se está utilizando. En modo demo (sin licencia) se cumple lo
anteriormente mencionado al respecto de los 30 minutos de control.
• CAPS: tecla mayúsculas presionada.
• NUM: teclado numérico activado.
• SCRL: la tecla bloq despl del teclado está activada.

Manual WinCC V4.02 Graphics Designer
GRAPHIC DESIGNER

Manual WinCC V4.02 Graphic Designer

5 GRAPHICS DESIGNER
5.1 Introducción
El editor Graphics designer se encarga de la confección de las pantallas del WinCC.
Básicamente es un entorno de dibujo con la característica de que los objeto poseen la
capacidad de asociar sus propiedades a variables de comunicaciones que son proporcionadas
por el Tag Management.
5.2 Características
5.2.1 Tips&Tricks
El editor Graphics designer posee una opción de Tips&Tricks o ideas que nos
proporciona algunas sugerencias cada vez que entramos al mismo al respecto de alguna
funcionalidad del mismo.

5.2.2 Propiedades de los objetos
Todos los objetos poseen dentro del graphics designer varias características comunes,
incluyendo a la propia superficie en la que vamos a colocar los objetos (picture). Estos son:
• Todo objeto posee una serie de propiedades, cuyo número depende del tipo de objeto en
cuestión. Para acceder a estas propiedades es necesario colocarse sobre el objeto y
presionar el botón derecho del ratón, emergiendo un menú contextual como el de la figura.
Estas propiedades del objeto son visibles de dos modos distintos:

Mediante:
• Customize object: podemos asociar una nueva propiedad a un grupo de objetos para
generar nuevas funcionalidades a las agrupaciones de los mismos. Ejemplos de ello son
los smart objects de la biblioteca de objetos.
• Group objects: cuando se selecciona más de un objeto se pueden agrupar, de manera
que conforman uno nuevo que posee las características de los dos pero tiene un nuevo
nombre. La mayoría de los objetos de la biblioteca son agrupaciones de objetos más
simples. Las agrupaciones se pueden desagrupar en cualquier momento.
• Configuration Dialog: se accede a un resumen de las propiedades del objeto más
importantes.
• Properties: se accede a una caja de diálogo en la que disponemos por un lado de todas
las propiedades del objeto y por otro de los eventos frente a los cuales reacciona. Dentro
de estos eventos podremos colocar nuestro código programado para que ejecute el
programa ciertas acciones cuando se generen estos eventos del objeto.
5.2.3 Propiedades del objeto Picture
La propia pantalla en la que trabajamos posee propiedades y eventos. Presione el

botón derecho sobre ella y elija properties. Las propiedades son:
• Geometry:
Picture Width: Ancho de la pantalla (en pixels).
Picture Height: Alto de la pantalla (en pixels).

Grid On: Activar la rejilla de puntos

Grid Width: Ancho de la rejilla de puntos
Grid Height: Alto de la rejilla de puntos
Figura 56: Geometría de una picture.
• Colors:
Background Color: Color del fondo de la picture
Fill Pattern Color: Color de la máscara de dibujado sobre el fondo de la picture.
Grid color: Color de los puntos de la rejilla

• Miscelaneous:
Operator-Control Enabled: la picture se encuentra habilitada.
User Level: Nivel de usuario al que le está permitido entrar en esta ventana. Para
conocer como realizar la asignación de niveles de usuario, vea capítulo User Administrator.
Display: Mostrar la picture.
Update cycle: Ciclo de actualización de la picture.
Date of the last change: fecha de la última modificación que se hizo a la picture.
Cursor Mode: Tipo de modo de desplazamiento con el cursor (alpha o tab).
Figura 57: Propiedades miscelaneous de una picture.

Con respecto a los eventos, las posibilidades para una picture son:
Figura 58: Eventos mouse de una picture.
• Eventos Mouse:
Mouse Action: Se ejecuta al presionar cualquier botón del ratón.
Figura 59: Eventos del teclado de una picture.

Press Left: Se ejecuta al bajar el botón izquierdo del ratón.

Release Left: Se ejecuta al levantar el botón izquierdo del ratón.
Press Rigth: Se ejecuta al bajar el botón derecho del ratón.
Release Rigth: Se ejecuta al levantar el botón derecho del ratón.
• Eventos Keyboard:
Press: Se ejecuta al presionar una tecla, siempre y cuando el foco activo sea dicho
objeto.
Release: Se ejecuta al levantar la tecla presionada anteriormente.
Figura 60: Eventos miscelaneous de la picture.
• Eventos Miscelaneous:
Objetc Change: Se ejecuta cada vez que cambia alguna propiedad del objeto.
Open Picture: Se ejecuta al entrar al picture.
• Property topics:
Se ejecutan cuando la propiedad seleccionada cambia en el objeto.

Figura 61: Eventos property topics de una picture.
5.2.4 Iconos de la ventana propiedades
Todas las ventanas de propiedades poseen tres iconos en su esquina derecha. El

significado de los mismos es:
Clip: Al presionarse impide que la ventana desaparezca, por lo que podemos
movernos por varios objetos de la pantalla observando sus propiedades sin que
desaparezca cada vez la ventana de la pantalla.
Copiar Propiedades: Copia las propiedades del objeto activo en ese momento
en el portapapeles.
Pegar propiedades: Pega las propiedades copiadas en el portapapeles al

objeto que esté activo en ese momento.

5.2.5 Barra de herramientas del Graphic Designer
La barra de herramientas del graphics designer posee los siguientes iconos:
Nueva picture (PLD)
Abrir picture (PLD)
Guardar imagen (PLD)
Arrancar el runtime desde la picture actualmente abierta en el Graphics

designer.
Traer objeto al frente. Util cuando existen varios objetos que se solapan.
Enviar objeto al fondo. Util cuando el objeto está tapando a otros.
Visualizar rejilla
Forzar objetos a rejilla
Aumentar zoom de la ventana
Disminuir zoom de la ventana
Realizar zoom a la selección. Realiza un zoom a una selección que hagamos.
Copiar las propiedades del objeto en el portapapeles
Pegar las propiedades en el portapapeles
Biblioteca de objetos.

La ventana del graphics designer con sus barras de herramientas activadas se

presenta así:
Figura 62: Ventana del graphic designer de WinCC.

5.2.6 Biblioteca de objetos
La biblioteca de objetos es el lugar donde disponemos de imágenes pre-configuradas

que podemos utilizar en nuestras picture. Algunos de estos objetos en realidad son
agrupaciones de varios de ellos y llevan ya asociado código C de tal manera que están
preparados para realizar una tarea determinada (smart objects).

La biblioteca se compone de dos partes:

• Global library: biblioteca general accesible desde cualquier proyecto.
• Project library: librería exclusiva del proyecto.
Para pasar un objeto a nuestra picture basta con arrastrarlo y soltarlo sobre la misma.
En las siguientes imágenes se verán los objetos más importantes contenidos.
Veamos
Figura 63: Botones 3D de la librería de WinCC.
Figura 64: Teclados virtuales de WinCC.

Figura 65: Motores 3D de la librería de WinCC.
Figura 66: Botones incrementales de la librería de WinCC.

Figura 67: Medidores analógicos de WinCC.
Figura 68: Slider Panels de la librería de WinCC.
Figura 69: Tanques de la librería de WinCC.

Figura 70: Botones de activación y pulsadores.
Figura 71: Válvulas de la librería de WinCC.

5.3 Opciones del menú
5.3.1 Settings
En el menú Tools ->Settings disponemos de las siguientes opciones para configurar el

graphic designer:
En la opción grid podemos seleccionar:

• Display grid: El visualizar o no la rejilla al crear o abrir un picture.
• Width in pixels: El tamaño que debe tener la rejilla.
• Snap to grid: El ajustar o no los objetos a la rejilla.
Figura 72: Opciones de la configuración de la

rejilla de WinCC.

Figura 73: Opciones de configuración.
En la pestaña options podemos seleccionar:

• Grabar los cambios cuando se sale del graphic designer o no.
• El tipo de selección de los objetos:
Surrounding: Los objetos se seleccionan si se encuentran completamente dentro de la
selección realizada.
Touching: Los objetos se seleccionan aunque solo una parte de los mismos se
encuentre incluida en la selección.
• Object Tree: mostrar siempre igual el árbol de objetos, independientemente de cómo se
quedó la última vez al salir.
• Configuration Dialog: usar el dialog box para configurar los objetos al insertarlos en la
picture o no.

Figura 74: Capas visibles.
En esta opción podemos seleccionar las capas que deben estar activas por defecto en
una picture y las que no.
Figura 75: Objetos del árbol de objetos.

Por último, podemos seleccionar la configuración por defecto de objetos que deseamos
y donde guardarla.
5.3.2 Idioma de la pantalla:
Podemos seleccionar diferentes idiomas para los textos asociados a todos los objetos
que coloquemos en las pantallas del WinCC, de tal manera que simplemente cambiando de
página de idioma podamos modificar completamente el lenguaje del runtime en la aplicación.
Para conseguir esto, primeramente deberemos definir el lenguaje de la pantalla en la
que estamos.
¿Cómo saber el idioma actual de la pantalla que estamos editando?
Aparece en la barra de status, en la parte de debajo de la pantalla
¿Cómo poder modificar el idioma actual de la pantalla activa?

En el menú del graphic designer, en la opción View->Language aparece una ventana
como la de la figura y podemos seleccionar nuestro idioma.
¿Cómo hacer una misma pantalla en Inglés y en Español?

Seleccione al principio el idioma Español (tradicional), coloque todos los objetos que
desee que aparezcan, escriba todos los textos, y grabe la pantalla. Ahora cambie de idioma al
inglés y verá como todos los textos aparecen en interrogantes. Vuelva a escribirlos, esta vez en
inglés.
Figura 76: Selección del idioma actual del

graphic designer.

5.4 Barras de herramientas
5.4.1 Barra de colores
Disponemos de una barra de colores para asignar a las propiedades estáticas de los
objetos. Dichos colores pueden personalizarse gracias al último de los iconos de la barra.
5.4.2 Barra de zoom
Gracias al zoom podemos hacer escalados a la picture hasta de 8 aumentos y

reducciones hasta 1/4 parte.
5.4.3 Barra de objetos
Los objetos de la barra de objetos se dividen en tres categorías:

• Standard Objects: Objetos estándar de dibujo, tales como líneas, polígonos, etc..

Figura 77: Standard Objects.
• Smart Objects: Objetos inteligentes, cada uno con unas propiedades especiales.
Figura 78: Smart Objects.
• Windows Objects: Objetos comunes de Windows, tales como botones, cajas de selección,
barras de desplazamiento, etc..

Figura 79: Windows Objects.
5.4.4 Barra de layers:
La barra de layers nos indica las capas que actualmente están activas en nuestra
ventana. Todos los objetos poseen una propiedad layer que indica a qué capa pertenecen.
Disponemos de un total de 16 capas, apareciendo por defecto todas activas.
Es conveniente, cuando necesitemos poner objetos que se superponen (p. Ej. Un

efecto de sobra bajo un texto, o un mensaje de ayuda que aparece sobre un botón) que
asignemos diferentes capas, para que podamos desactivarlas pinchando sobre ellas y trabajar
de una manera más cómoda en el editor de dibujo.
5.4.5 Barra de alineación.
Esta barra se utiliza para poder alinear varios objetos y también para igualarlos en
tamaño tanto en altura como en anchura.
Para que aparezca activa lógicamente deberemos de tener seleccionados por lo menos
dos objetos.

5.4.6 Barra de fuentes
La mayoría de los objetos poseen algún texto asociado. Mediante la barra de fuentes
podemos configurar el tamaño y fuente de los mismos sin tener que entrar en sus propiedades.
5.4.7 Barra de estilos
Al igual que el anterior, poseemos también una barra de herramientas solo para las
líneas de los objetos, en las que podemos modificar el estilo de la línea, su grosor, su final y el
relleno que deben tener (si poseen un grosor mayor de una simple línea).

5.5 Smart Objects
5.5.1 Introducción
Los smart objects son la base de construcción de los proyectos de WinCC. Los cuatro
primeros los estudiaremos más adelante, ya que su estudio es más amplio y complicado. Nos
centraremos ahora en los siguientes objetos.
5.5.2 I/O Field
Caja de entrada/Salida para visualizar el valor de una variable y poderlo modificar

Las propiedades estáticas del I/O Field son:
Figura 80: Geometría de cajas I/O.

Figura 81: Estilos Cajas I/O
Figura 82: Fuente Cajas I/O
Destacar en estas propiedades:

• Bold -> La fuente de la caja en negrita
• Underline -> La fuente de la caja subrayada
• Text orientation -> orientación del texto de la caja (horizontal o vertical)
• X Alignement -> alineación con respecto al eje x (izquierda, centrado o derecha)
• Y Alignement -> Alineación con respecto al eje y (arriba, centrado o derecha)

Figura 83: Flashing de caja I/O
El flashing es una agrupación de propiedades no vista hasta ahora. Básicamente se

utiliza para señalizar un cierto estado de algún elemento de la instalación que esté
representado por dicho objeto. Si la presente caja de I/O está representando un valor de
presión de agua, podemos representar aquí dicho valor con el fondo parpadeando cuando se
exceda un determinado límite de seguridad.
• Flashing border active: Que parpadee el borde de la caja.
• Flashing border color off: Color del parpadeo del borde en estado off.
• Flashing border color on: Color del parpadeo del borde en estado on.
• Border Flashing frequency: Frecuencia del parpadeo. Disonemos de tres velocidades:
lenta, media y rápida.
• Flashing Background active: Que parpadee el fondo de la caja.
• Flashing background color off: Color del parpadeo del fondo en estado off.
• Flashing background color on: Color del parpadeo del fondo en estado on.
• Background Flashing frequency: Frecuencia del parpadeo del fondo. Disonemos de tres
velocidades: lenta, media y rápida.
• Flashing Text active: Que parpadee el texto de la caja.
• Flashing Text color off: Color del parpadeo del texto en estado off.
• Flashing Text color on: Color del parpadeo del texto en estado on.

• Text Flashing frequency: Frecuencia del parpadeo del texto. Disonemos de tres
velocidades: lenta, media y rápida.
Figura 84: Miscelaneous de cajas I/O
Opciones Miscelaneous:
• Operator Control Enable: Indica si el usuario puede tener acceso a la caja para introducir
valores. Esta propiedad es independiente de que tenga o no nivel para poder introducir
valores. Equivale al Locked de los controles de programación de objetos.
• User level: Nivel que debe disponer el usuario para poder introducir datos en esta caja.
• Display: Si debe ser visible o no la caja.
• Tooltip Text: Texto que debe aparecer en el cursor al posicionarse con el mismo sobre la
caja. Los tooltip dependen también del código de página de idiomas seleccionado en el
runtime.
• Operator activites report: Cuando se activa esta opción, cada vez que se introduzca un
valor en la caja, aparecerá una caja de texto solicitando que introduzcamos una explicación
al respecto de la modificación realizada en el valor del proceso. Este mensaje queda
almacenado en el sistema como seguridad antes posibles fallos debidos a los cambios
realizados, o como nota aclaratoria de porqué se toma dicha decisión.
• Operator Input Message:
• Adapt Border: Ajusta automáticamente el tamaño de la caja al texto o número que
contenga en cada momento.

• Cursor Control: Determina si después de realizar una entrada en la caja se debe saltar al
siguiente objeto en el orden de Alpha-cursor seleccionado o se debe de continuar en el
campo en el que se acaba de introducir el valor.
• Inmediate input: Indica si la caja al recibir el foco debe ponerse automáticamente en modo
de edición para introducir un valor, o no.
Figura 85: Límites de cajas I/O.
Límites:
• Low Limit Value: Valor menor que se puede aceptar como válido a la hora de introducir un
valor en proceso.
• High Limit Value: Valor mayor que se puede aceptar como válido a la hora de introducir un
valor en proceso.
Si se sobrepasa cualquiera de estos valores, automáticamente aparece una caja
indicándonos dicho suceso.
Output/Input:
• Field Type: Tipo de valor del campo a representar o introducir. Las diferentes posibilidades
son:
Output: Solo leer el valor en el PLC, sin poder escribir.
Input: Solo escribir el valor en el PLC sin poder leer.
I/O field: leer el valor en el PLC y poder modificarlo también.

Figura 86: Propiedades de entrada/salida de I/O.
• Output value: Variable de proceso que contiene la caja.

• Data format: Formato de los datos a representar.
• Output Format: formato de salida del valor a introducir. Cada carácter 9 corresponde a un
dígito. Los dígitos que se coloquen después del punto corresponderán a los decimales a
los que se ajuste el valor a representar.

Las diferentes posibilidades en formatos de entrada son:

• Formato binario: debe estar compuesto por unos y ceros.
• Formato decimal: debe estar compuesto por:
s -> proporcionar signo (+ o -)
e ->representación exponencial.
9 -> numero entre 0 y 9.
0 -> ceros de relleno a la izquierda que deben aparecer.
. -> punto decimal.
Ejemplo:
9.9 -> 1.0
s9.9 -> +1.0
s9.9e -> +1.0E+00
09.99 -> 01.00
• Formato string: compuesto por:

* -> cualquier cadena
? -> un carácter.
a -> cualquier carácter o número
A -> cualquier carácter en mayúsculas o número.
b -> cualquier carácter en mayúsculas o minúsculas.
B -> cualquier carácter en mayúsculas.
d -> signo + o -, punto decimal, espacio en blanco o número.
t -> separador (:,;) o espacio en blanco.
1 -> número 0 o 1
2 -> número 0, 1 o 2.
Etc…
h -> carácter hexadecimal.
• Formato hexadecimal:
f -> carácter hexadecimal.
0 -> cero de relleno a la izquierda de caracteres hexadecimales.

• Apply on full: Determina si el valor introducido se da por validado cuando se han

completado todos los dígitos del campo de manera automática, o es necesario presionar
enter o cambiar de campo activo con tab para que se considere validado el campo.
• Apply on exit: Fuerza al sistema a dar como validado el campo inmediatamente después
de que sea realizada la validación por el usuario (mediante enter o el tabulador).
• Clear on new Input: Indica si cuando se va a introducir valores en el campo, debe de
borrarse el valor que existiera anteriormente, o se conserva y editamos el nuevo valor
sobre el anteriormente existente.
• Clear on invalid input: Indica si al introducir un valor no válido en la caja, debe de borrarse
de esta el valor erróneo para que sigamos introduciendo uno correcto, o nos permite editar
el valor erróneo para modificarlo y que sea válido para el sistema.
• Hidden Input: Oculta el valor que se está introduciendo mediante caracteres de *. Esta
opción es útil para la solicitud de passwords al usuario.
Además de las propiedades, todo objeto (incluyendo el objeto I/O que estamos tratando
ahora) posee un Configuration Dialog, perteneciente a su menú contextual, en el cual se
representan las propiedades más importantes del objeto en cuestión, es decir, un resumen de
lo visto en las páginas anteriores. El Configuration dialog de la caja I/O es:
Figura 87: Configuration dialog de I/O.

5.5.3 Bar.
La barra es un objeto que nos permite representar un valor analógico y compararlo con
unos límites establecidos para saber en que estado se encuentra el proceso con respecto al
valor deseado.
• Bar direction: dirección en la que debe de crecer la barra (hacia arriba, hacia abajo...)
Figura 88: Colores de la barra.
Colors:

• Border Color: Color del borde de la barra.

• Border Background Color: Color del fondo del borde de la barra. Solo es visible si el
estilo del borde de la barra no es sólido.
• Background color: Color del fondo de la ventana de la barra.
• Fill Pattern color: Color de rellenado de la ventana de la barra. Solo es visible si el estilo
del fondo de la ventana no es sólido.
• Bar color: Color de la barra.
• Scale color: Color de la escala.
• Bar Background color: Color del fondo de la barra.
• Trend color: Color de la tendencia. La tendencia es un indicador que aparece en la
esquina inferior de la barra indicándonos el sentido del proceso (creciente o decreciente).
Figura 89: Estilos de las líneas de la barra.
Styles:
• Border Weight: Anchura del borde de la ventana de la barra.
• Border Style: Estilo del borde de la ventana.
• Fill Pattern: Estilo de rellenado del fondo de la ventana de la barra.
• Bar Pattern: Estilo de rellenado de la barra.

Figura 90: Fuentes de la barra.
Font:
• Font: Fuente de la escala e la barra.
• Font Size: Escala de la fuente de la escala de la barra.
• Bold: Si dicha fuente debe aparecer en negrita.
Figura 91: Flashing de la barra.

Figura 92: Miscelaneous de la barra.
Miscelaneous:
• Change color: Cambia el color de la barra al superar un límite superior o inferior de
manera total, o solo el trozo que sobrepase dicho límite.
• Maximum value: Valor máximo de la escala de la barra.
• Zero point value: Valor del punto cero de la escala.
• Minimun value: Valor mínimo de la escala de la barra.
• Histeresys: Indica si el valor debe de comportarse según una histéresis al alcanzar el
límite superior o inferior. Si alcanzamos un límite de 100, teniendo activado este parámetro,
y seleccionando un rango de histéresis de 20, hasta que el valor no baja de 80 no volverá
la barra a representar modificaciones en su valor. Esto permite evitar las oscilaciones
propias de los fluidos una vez alcanzados los límites precisos.
• Histeresys Range: Valor a tener en cuenta en la histéresis.
• Trend: Indicador del sentido de la barra. Nos indica si el proceso está aumentando o
disminuyendo, realizando una comparación del valor actual con el anterior.
• Average Value: Seleccionando esta opción se muestra la media de los últimos 15 valores
leídos en el proceso, no el instantáneo. Ideal para procesos muy fluctuantes.
• Process Drive Connection: Valor del proceso a mostrar.

Figura 93: Ejes de la barra.
Axis:
• Scale: Mostrar o no la escala de referencia de la barra.
• Alignment: Lugar en el que colocar la escala (derecha o izquierda).
• Long Axis Section: La escala se compone de barras largas y cortas. Esta opción dibuja
las barras largas de la escala en negrita.
• Label Each: Indica cada cuantas barras largas de la escala hay que colocar un valor
numérico.
• Only long axis sections: Mostrar solo las barras largas de la escala, no las intermedias
cortas.
• Lenght of axis section: Longitud en pixels de las barras divisoras de la escala de la barra.
• Exponent display: Mostrar la escala en valor exponencial o lineal.
• Bar Scaling: Tipo de escala de la barra.

LINEAL LOGARIT. NEG. LOGARIT. AUTOMATIC TANGENT QUADRATIC
CUBIC
• Zero point: Lugar donde se encuentra el punto cero en la escala.
• Axis Section: Cada cuantas unidades queremos poner un indicador numérico de escala.
Por ejemplo, cada 20 unidades, con lo que la cantidad de marcadores numéricos en la
escala será de 100/20=6.
• Scale marcs: La distancia en las divisiones de la escala.
• Digits to the left of the decimal: Dígitos del valor entero de la escala.
• Digits to the rigth of the decimal: Cantidad de decimales del valor del a escala.


Figura 94: Límites de barra.
Limits:
• Limit Marker: Marca de límite que aparece a la izquierda de la barra indicándonos donde
se encuentran los límites de control de la barra.
• Monitoring AL: Controlar alarma 1de mínimo.
• Limit AL: Valor del límite de alarma 1.
• Bar color AL: Color que debe adoptar la barra cuando el valor del proceso esté por debajo
de lo especificado en Limit AL.
• Type AL: El valor de Limit AL puede ser expresado en valor absoluto, con lo cual es
necesario conocer a priori el valor máximo de la escala, o en porcentual (mucho más
flexible, ya que ante cualquier modificación de límites continúa manteniendo la
proporcionalidad).

Las demás opciones son idénticas pero para los cuatro siguientes limites de alarma
mínima (La L de AL indica que es un límite de mínimo). Los límites de máximo comienzan con
AH, siendo su funcionamiento y propiedades idéntico al descrito, salvo que la barra cambia de
color cuando el valor del proceso está por encima del valor estipulado como límite de alarma.
Como ya dijimos, todo objeto tiene su Configuration dialog, o resumen de propiedades.

En el caso de la barra son:
Figura 95: Configuration dialog de

barra.

5.5.4 Graphic Object.
El objeto gráfico representa una imagen en pantalla. Su asignación suele ser dinámica,
utilizándose el status display para realizar animaciones de imágenes, aunque puede
dinamizarse la imagen que representa.
Figura 96: Propiedades picture de un graphic object.
Picture:
• Picture: Imagen actual a representar.
• Picture referenced: Indica si se debe almacenar en el objeto la imagen o solo la referencia
a la misma, para que al cambiar esta en el disco duro, cambie también en el objeto.
• Picture transparent color: Color que se considera transparente en la imagen.
• Picture transparent color on: Activar el color transparente, con lo que todos los pixels de
dicho color serán reemplazados por la imagen que se encuentre por debajo del objeto.
Los formatos que soporta el objeto son:

• Bmp
• Emf
• Wmf
• Dib.

Cuando se selecciona una imagen, esta se copia automáticamente en el subdirectorio

GraCS de nuestro proyecto, por lo que una vez la seleccionemos en algún objeto estará
disponible para todos los demás que realicemos.
El Configuration Dialog del Graphic Object es el que se muestra en la imagen siguiente.
Figura 97: Configuration Dialog de un graphic object.

5.5.5 Status display.
El status display es el objeto a utilizar para mostrar animaciones en pantalla. Estas

animaciones se componen de hasta un máximo de 31 imágenes que se van mostrando en
función del valor que adopte una variable asignada.
El Configuration Dialog del status display es el siguiente:
Figura 98: Configuration display de un status display por número.
Existen dos posibilidades a la hora de realizar la animación:

• que exista un valor que se va incrementando desde 0 hasta x. Esta opción suele ser una
variable interna, y se incrementa mediante una función en C desde WinCC.
• Que exista un valor de comunicaciones que nos indica en que posición se encuentra la
máquina. Cada bit de la palabra muestra un estado de la máquina. En este caso hay que
utilizar el botón Add que nos irá incrementando el valor a chequear para el cambio de
imagen en potencias de 2.

Figura 99: Configuration display de un status display por bit .
Algunas propiedades interesantes de este objeto son también:
Figura 100: Propiedades state de status display.

5.5.6 Text list.
El objeto textlist es útil a la hora de realizar un control sobre valores numéricos que se
encuentran claramente definidos mediante textos. Suelen ser estadios del proceso de 3 o
cuatro pasos máximo. Por ejemplo, un motor puede estar parado, arrancado en automático, o
arrancado en manual. En estas situaciones el asociar textos a valores numéricos dentro del
PLC permite gobernar variables del proceso simplemente seleccionando un texto de una lista,
o que un texto nos describa el estado de un determinado elemento de la instalación.
Figura 101: Configuration dialog de text list.
Output/Input:
• Field Type: Campo de salida (solo leer el valor), de entradas (solo modificar el valor en el
PLC) o de ambos (leer y escribir en el PLC).
• Output Value: Valor del proceso relacionado con los textos.
• List Type: Tipo de lista de texto.
• Asignement: Asignación de los textos a los diferentes valores numéricos.

• Bit number:
• Apply on exit:
• Number of visibles lines: Líneas de texto visibles al desplegar la ventana de selección de
valor.

5.5.7 Buttons.
El objeto button es el encargado de la asignación de las funciones típicas de manejo

por el programa de la aplicación (cambio de pantalla) y realización de funciones predefinidas
(activar una determinada bomba, etc...).
La ventana de configuration dialog de button es la siguiente:
Figura 102: Configuration dialog del objeto

button.
• El campo text es el texto que aparece sobre el botón.

• Hotkey es la función del teclado que se asigna a ese botón, de tal manera que presionando
dicha tecla se ejecuta la función que se haya asociado al mismo.
Destacar que la asignación del teclado no se limita a las teclas de función pudiéndose
asignar hasta la tecla de ESC o la de ENTER para salirse de las pantallas o entrar a elllas
como si se estuviese en una OP.

Figura 103: Hotkey de un botón.
• Password es el campo en el que indicamos el nivel de autorización requerido para poder

ejecutar la acción del botón.
• El campo inferior de la ventana está reservado por si deseamos darle al botón la
funcionalidad típica de cambiar de pantalla. Podemos asignar con el icono que aparece a la
derecha una de las pictures ya definidas
Figura 104: Propiedades miscelaneous de un botón.

Dos opciones no vistas del botón es que podemos definir dos imágenes (picture on y
picture off) para representar los dos estados del botón (presionado o no).

5.5.8 Check box.
El control checkbox es la manera de seleccionar opciones no excluyentes entre sí

dentro de una selección requerida al usuario.
• Number of boxes: Cantidad de cajas de selección a introducir en el control.
Figura 105: Fuente del objeto checkbox.

• Index: Indice actual dentro del array de cajas de control.

• Text: Texto asignado para este idioma y este índice de caja. Para cambiar los textos de
otras cajas, cambie el número de Index.
• X Alignement: Alineación en el eje X de los textos.
• Y Alignement: Alineación en el eje Y de los textos.
Figura 106: Output/Input de una checkbox.
• Selected Boxes: Cajas que están activas por defecto según el array generado (en el
ejemplo solo la primera de las tres).
La visualización del control tal como lo hemos configurado es la siguiente:

5.5.9 Option button.
El objeto option button se utiliza para realizar una entrada en el proceso de un valor
que solo puede adoptarse de entre una serie definida de posibilidades excluyentes entre sí.
La única diferencia entre él y checkbox, visto anteriormente es precisamente esta
característica de exclusión, lo que hace que seleccionando cualquiera de las opciones del
objeto option automáticamente dejan de estar seleccionadas todas las demás.
Todas las propiedades vistas en checkbox sirven para option button.

5.5.10 Slider.
La barra slider sirve para poder introducir valores analógicos en el proceso de una
manera gráfica.
Figura 108: Configuration dialog de un

slider object.
Figura 107: Miscelaneous de slider object.

De las propiedades de slider solo destacar por no haber sido vista aún:
• Extended operation:
• Operation steps: incrementos en que aumenta o disminuye la variable de proceso cada
vez que nos desplazamos por la barra.
Figura 109: Colores del slider object.
Podemos asignar también colores a la barra y a los botones de máximo y mínimo de

manera individualizada, así como al fondo con respecto a lo que lleva y lo que queda hasta el
máximo.

5.5.11 Round.
El objeto round está ideado como pulsador con enclavamiento o como visualizador de
estado (presionado o no presionado).
Figura 110: Estilos del botón round.
Las opciones más interesantes son:

• Latch Down: Mantiene el botón enclavado en función set/reset pese a no estar
presionándolo.
• Pressed: Valor actual del botón (0 = no presionado / 1 = presionado).
Figura 111: Imágenes del objeto round.

5.6 Asistentes
Los asistentes de programación son pequeños scripts o trozos de código de programa
que se añaden de manera automática al objeto sobre el que se aplican, para realizar una
determinada tarea de programación.
Cuando se aplica un Dinamic Wizard a un objeto aparece un asistente que nos permite
seleccionar el evento con el cual deseamos ejecutar el script.
5.6.1 Dinamic Dialogs System Functions:
• Exit WinCC:
Sale del runtime de WinCC y del propio WinCC.
Código añadido: ExitWinCC();
• Exit WinCC or Windows:
Nos permite seleccionar la forma de salir de WinCC. Las opciones posibles son:

• Exit WinCC Runtime:

Sale de runtime del WinCC, pero no del propio WinCC. Es el método para desactivar la
runtime desde la propia runtime.
Código: DeactivateRTProject ();
• HardCopy:
Imprime la pantalla actual por la impresora predeterminada de Windows.
Código: WinExec("PRTSCR.EXE -hardcopy",SW_SHOWNORMAL);
• Language switch:
Cambia de idioma los textos de la aplicación runtime.
Código: SetLanguage(0x040A); /* SPANISH */
Un asistente nos permite seleccionar el código de área del lenguaje deseado.
Figura 112: Idiomas de la runtime.
• Start another aplication:

Arranca otra aplicación que deseemos ejecutar.
Código: ProgramExecute("C:\\Archivos de programa\\Microsoft
Office\\Office\\EXCEL.EXE");

5.6.2 Standard Dinamics
• Add dinamics to the prototype: permite dinamizar una propiedad del objeto seleccionado
a través de un Wizard en lugar de hacerlo directamente en propiedades del objeto.
• Copy tag value: incluye el código que copia una variable en otra.
Figura 113: Copiar una variable en otra.
• Fill object: rellena los objetos que permitan dinamic filling, pero con la ventaja de que a
través del wizard podemos establecer un rango de llenado diferente de 0 a 100 que sería
mediante una conexión directa de la variable de llenado con la propiedad de llenado.

Figura 114: Rellenado automático de superficies escalado.
• Make a property dinamic: dinamizar una propiedad.

• Move object: dinamiza las coordenadas de un objeto seleccionado de acuerdo a dos
variables definidas de tal manera que en función de las variables se moverá la posición del
objeto.
Figura 115: Mover un objeto de acuerdo a unas variables.

Figura 116: Ventanas de mensajes.
• Display error: muestra una ventana de error en pantalla. Este Wizard es muy útil para
sacar mensajes al operario frente a error de manejo.

Figura 117: Wizard de mensajes de aviso.
El resultado es el siguiente:
• Display WinCC dialog: mostrar una ventana de diálogo ya configurada anteriormente. Nos
crea el código necesario para que al presionar sobre el objeto, aparezca la ventana
indicada.

Figura 118: Saltos entre ventanas.
• Single picture change: abrir una ventana. Equivale a Openpicture();

5.7 Dinamización de propiedades
5.7.1 Dinamización a través de una variable
Las dinamización de las propiedades de un objeto se puede realizar de diferentes

maneras. La más sencilla de todas reside en conectar la propiedad a una variable de manera
directa, de tal forma que el valor que posea la variable será el que tenga la propiedad, y
viceversa.
La representación de una asignación directa a una variable se realiza con una bombilla
verde.
5.7.2 Dinamización a través de dinamic dialog
La segunda forma sencilla de dinamizar una propiedad es a través del dinamic dialog,
una caja de diálogo que nos permite configurar cual debe ser el valor que controla la propiedad
dependiendo de una fórmula que puede ser el resultado del valor de una variable o de una
operación matemática.
El dinamic dialog lo veremos más adelante en los ejemplos de programación, pero es
conveniente saber que se representa su asignación a una propiedad mediante un rayo rojo.
5.7.3 Dinamización mediante código C
La última forma de poder dinamizar una propiedad es directamente programar en C

una operación que nos debe de devolver el valor que controlará la propiedad. Solo es
necesaria esta solución en casos de cálculos matemáticos muy complejos.
La representación de su asignación se realiza por un rayo verde.

5.7.4 Dinamización indirecta de una propiedad
Además de poder dinamizar una propiedad asignándole un valor, ya sea a través de

una variable o del resultado de operaciones matemáticas, podemos realizar una asignación
indirecta del valor de la propiedad.
Supongamos que tenemos una caja de I/O y queremos mostrar la temperatura de la
sala. Dependiendo de una serie de botones, podremos seleccionar una sala u otra. La caja de
I/O deberá cada vez estar asociada a una variable distinta. Para conseguir esto, se asocia una
variable de tipo texto a la propiedad en cuestión (en nuestro caso Output Value). Todas las
propiedades tienen una caja de asignación a la derecha llamada indirect. Seleccionándola, el
valor de la cadena VAR_TEXTO indica el nombre de la variable que debe de conectarse a la
salida de la caja. Por lo tanto, cambiando VAR_TEXTO cambiamos la variable conectada en
dicha propiedad.
5.7.5 Programación de eventos
Los eventos de un objeto deben de programarse en C. Sin embargo, existe un pequeño

asistente que nos puede evitar en algunas circunstancias tener que recurrir a la programación
para realizar nuestras acciones en los eventos.
En WinCC este asistente se denomina Direct connection y tiene el aspecto inferior:

Cuando se realiza un irect connection a un evento queda indicado mediante un rayo

azul:
5.7.6 Programación en C de eventos
Pero casi siempre hay que recurrir al C para realizar las acciones que deseamos.
Cuando asignamos nuestro código de programación a un evento, se nos indica mediante una
bombilla verde:
Sin embargo, no siempre la programación en C que realicemos será correcta. Cuando

el código asociado contenga errores y no pueda ser compilado por WinCC, se nos indicará
mediante un rayo amarillo. Tenemos que tener en cuenta que en esta circunstancia no se
ejecutará el código aunque se produzca el evento.

Manual WinCC V4.02 Alarm Logging

ALARM LOGGING


6 ALARM LOGGING
6.1 Introducción
Alarm Logging es la parte del WinCC que de se encarga del tratamiento de los
mensajes de alarma de la instalación, así como del tratamiento del histórico de alarmas y la
generación de alarmas a partir de comparaciones con valores de comunicaciones.
El tratamiento de alarmas de WinCC proporciona:
• Información sobre el error que se ha producido en la instalación.
• Detecta situaciones críticas del sistema.
• Reduce los tiempos de parada de la instalación.
El editor se ejecuta presionando con el botón derecho sobre Alarm Logging del
Control Center y seleccionando Open
6.2 El editor de alarmas

El editor de alarmas nos permite configurar los mensajes de alarmas, así como la
estructura de la ventana en la que representaremos dichos mensajes.
Lo primero que sorprende al entrar al editor es la ventana de mensaje que aparece
denominada Add Ins. Un Add Ins es una opción que podemos incorporar o no a nuestro editor.
En el caso de las alarmas solo hay uno, y es las alarmas software, denominadas Analog Alarm.
Una alarma software es la generación de una alarma a partir de una comparación de un valor
de comunicaciones con una consigna o límite que nosotros determinemos. Generalmente este
tipo de alarmas se creaban realizando la comparación en el PLC, activando si era el caso un bit

que era el responsable del ulterior mensaje de alarmas. Mediante esta opción esto no es
necesario, siempre y cuando la alarma no tenga ninguna repercusión en el proceso (activar p.
Ej. una sirena), descargando de esta tarea al PLC y permitiendo realizar modificaciones de este
estilo sin modificar el PLC.
Figura 119: Adición de alarmas analógicas al proyecto.
La apariencia del Alarm Logging es la que presenta la ventana siguiente:.
Figura 120: Ventana de alarm logging.

Como se puede observar, esta dividida entres partes. La primera es un árbol en que se
representan las diferentes partes en que se divide la construcción de una ventana de alarmas.
La segunda, son los objetos que contiene la parte seleccionada a la izquierda. Por último, la
ventana inferior, es donde se representan todas los mensajes de alarma que pueden existir en
nuestro proyecto, con su bit de comunicaciones asignado.
6.3 El Wizard del Alarm Logging
6.3.1 Estructura de un mensaje de alarmas
Un mensaje de alarmas puede componerse de hasta tres tipos de bloques:

• System Blocks: Bloques de sistema, que contienen datos que son asignados por el
sistema, tales como hora de aparición de la alarma, fecha, etc...
• Process value blocks: Bloques que contienen información acerca el valor actual del
proceso (p. Ej. una alarma de temperatura puede tener un bloque de proceso en el que
aparezca el valor de dicha temperatura).
• User text blocks: Bloques de usuario son los que nos dan la información sobre que es esa
alarma (el texto de la alarma), donde se produjo (lugar), etc...
Estos bloques se organizan en una línea, y esta línea ya configurada con los bloques se
coloca como base de una ventana de alarmas. Una vez configurada la ventana de alarmas, su
emplazamiento en una o varias pantallas del runtime no se realiza desde este editor, sino
desde el graphic designer.

6.3.2 Pasos del asistente de alarmas
Para poder realizar todos estos bloques y configurar las líneas y ventanas de alarmas
disponemos de un Wizard de alarmas que nos guía paso a paso en su realización. Para
arrancarlo, vaya al menú File->Start Message Wizard.
Figura 121: Wizard alarmas paso 1.
Figura 122: Wizard de alarmas paso 2.

En system blocks definimos Si los bloques de sistema que deseamos son la fecha, la
hora, el número de alarma...o + el status de la alarma y la duración de la misma...o + la clase
de alarma y el tipo de mensaje.
En User text blocks definimos si no queremos ninguno, si queremos el teto de la
alarma y el lugar donde se produjo, o todos los posibles.
En process value blocks definimos si no queremos bloques de proceso, si queremos
solo 2 o todos.
A continuación definimos la línea de alarmas, eligiendo entre una línea con solo los
bloques de hora, fecha y número de alarma, o todos los configurados anteriormente.

A continuación definimos la ventana de alarmas, eligiendo si queremos o no barra de

herramientas y línea de status en la misma.
A continuación se definen las clases de mensajes. Los mensajes pueden agruparse por
clases, de tal manera que WinCC puede determinar un color y funcionamiento diferente ante
mensajes de diferentes clases. Aquí se puede elegir entre crear la clase error, que contiene los
tipos de mensajes alarma, fallo, warning, o además crear la clase operación, con los tipos
Check-Back y tipo de operación.

A continuación se elige el tipo de ventana que necesitamos. Existen tres tipos de

ventanas de alarmas:
• No archives: No guarda un histórico de alarmas en el disco duro.
• Short Term archive: Guarda un histórico de alarmas de las 250 últimas mediante
funcionamiento de tambor. El número del tambor de alarmas puede ser configurado a
posteriori.
• Long Term Archive: Archiva las alarmas en el disco duro sin límite.
Con esto finaliza el Wizard de configuración. Todos estos pasos también se pueden
realizar de manera manual.

6.4 Opciones del menú de Alarm Logging
6.4.1 Importar mensajes
En el menú messages disponemos de Import messages. Esta utilidad nos permite

importar los textos de los mensajes de las alarmas desde un fichero de texto
Figura 127: Importar mensajes de alarmas.
El formato que debe poseer el fichero de texto viene especificado en el Manual del
WinCC.
Esta opción se encuentra en Messages->Import single messages.
6.4.2 Exportar mensajes de alarmas
Al igual que podemos importar los mensajes, también podemos desde el menú
exportarlos a un fichero de texto. Incluso podemos seleccionar cuales deseamos exportar y
cuales no.
Esta opción se encuentra en Messages->Export single messages.

Figura 128: Exportación de mensajes de alarmas.
6.4.3 Tipo de introducción de texto
A la hora de realizar modificaciones en los textos de las alarmas, podemos determinar

mediante esta ventana si las modificaciones que realizamos deben aplicarse a todas las líneas
de alarmas con idéntico texto, o solo a la que estamos editando en ese momento. Para que
esta opción seleccionada se mantenga hasta que deseemos cambiarla, debemos activar Keep
Settings. Si no, cada vez que editemos un texto de alarma nos preguntará lo mismo, lo cual es
bastante engorroso.
Figura 129: Tipo de introducción de texto en alarmas.
Esta opción se encuentra en Messages->Change Text input mode.

6.4.4 Edición de Múltiples mensajes de alarma
Si necesitamos realizar una acción sobre varios mensajes de alarma a la vez

(borrarlos, copiarlos, borrar sus textos), esta opción nos permite trabajar con todos ellos.
Figura 130: Múltiples mensajes de alarma

y su asignación o borrado.
Las opciones son:

• Borrar varios mensajes
• Añadir los mensajes seleccionados copiados al final de la lista de alarmas.
• Borrar la variable de comunicaciones asociada a dichos mensajes.
• Borrar el texto de alarma asociado a dichos mensajes.
Esta opción se encuentra en Messages->Text for multiple messages.
6.4.5 Conexión de varios texto a una variable de comunicaciones
Si necesitamos conectar varios textos de alarma a una variable de comunicaciones,

desde esta ventana podemos seleccionarlos y automáticamente realizará la conexión con dicha
variable.
Esta opción se encuentra en Messages->Start interconnection Wizard.

Figura 131: Asignación de varios textos a una variable.
6.4.6 Idioma de los mensajes de alarma
Los mensajes de alarmas pueden almacenarse en diferentes idiomas, y mediante una

opción de la ventana de alarmas poder cambiar de idioma. Para saber en que idioma estamos
configurando los mensajes, o cambiar de idioma para configurar otros existe esta opción en el
menú
Figura 132: Idioma de las alarmas.
Esta opción se encuentra en Options->Language.

6.4.7 Mensajes de sistema
Podemos importar los mensajes pre-configurados de sistema del WinCC a nuestro

editor de alarmas, para que cuando ocurra un error en el WinCC podamos mostrar un mensaje
en el runtime.
Figura 133: Mensajes del sistema importados.

La importación de los mensajes la realiza a partir de la alarma 100000, pudiendo

decidir a posteriori si nos interesan todos o solo los que son más posibles de aparecer en
nuestro runtime.
6.5 Configuración de Alarm Logging sin el Asistente
6.5.1 Message blocks
Vamos a configurar los diferentes apartados del alarm logging sin utilizar ahora el asistente. Lo
primero que vamos a parametrizar serán los bloques de mensajes que necesitemos. Nos
colocamos sobre Message Blocks, y con el botón derecho seleccionamos la opción del menú
Message Blocks.
Figura 134: Configuración de los bloques de mensajes.
Si presionamos en esta ventana Add aparecerán todos los bloques de sistema

disponibles, pudiendo añadir o retirar de nuestra configuración aquellos que deseemos. Vamos
a ver la aplicación y características de cada uno de ellos. Los bloques de sistema disponibles
son:

6.5.2 Fecha de alarma
La fecha de la alarma, ya sea en la aparición, en el acuse o en la desaparición.

Podemos cambiar el texto de date a fecha, en castellano.

• Flashing On: si se activa, el bloque parpadeará en la pantalla.

• Podemos seleccionar la fecha con dos dígitos en el año, o con los cuatro correspondientes.
• El formato de la fecha puede aparecer en inglés (mes, día, año) o europeo (día, mes, año).
6.5.3 Hora de alarma
La hora del día en que aparece/desaparece/se acusa la alarma.
• Se puede seleccionar hasta milisegundos de resolución, y formato de hora de 12 horas o

de 24 horas.
6.5.4 Duración de la alarma
La duración de la alarma es un bloque muy útil, que nos indica:

Cuando aparece la alarma: aparece vacío.
Cuando desaparece la alarma: el tiempo que ha tardado en solucionarse la alarma.
Cuando es acusada: el tiempo que el controlador del proceso ha tardado en enterarse del
problema.

6.5.5 Estado de la alarma
El estado de la alarma es un carácter o texto que nos identifica el estado actual de la

misma (aparece, desaparece, es acusada). Por defecto, en el WinCC la simbología es la
siguiente:
• Aparece: +
• Desaparece: -
• Es acusada: +/-

En cualquier caso, estos textos pueden modificarse desde el text library a posteriori para
que sean más descriptivos.
6.5.6 Número de la alarma
El número de la alarma identifica a la alarma dentro de todas las posibles, y es unívoco.
La opción With leading zeros rellena de ceros los campos definidos en number of que
no queden rellenos por número de alarma, comenzando por la izquierda.
6.5.7 Daylight Saving

6.5.8 Estado de reconocimiento de alarma
Este bloque muestra cuando una alarma ha sido reconocida.
6.5.9 Clase de alarma
Este bloque nuestra la clase de mensaje a la que pertenece la alarma. Se pueden

generar diferentes clases de mensajes, cada uno con unas características determinadas (con
reconocimiento o sin él, etc..). Aquí podemos mostrar el texto identificativo de dicha clase (p.
Ej: Error grave, Advertencia, Información...).

6.5.10 Número de CPU
El número de cpu indica el equipo del cual proviene la alarma generada.
6.5.11 Nombre de la variable que genera la alarma
Este bloque contiene el nombre de la variable que genera la alarma en el PLC.

6.5.12 Violación de límites en alarmas
Este bloque indica cuando hemos superado un límite definido en la variable de

alarmas, tanto el superior como el inferior.
6.5.13 Identificación del archivo de la alarma
Identifica si el mensaje de alarmas se va a archivar o no en el histórico de alarmas.

Existe la posibilidad de que las alarmas puedan ser archivadas o no, y puede ser interesante
conocer al aparecer una alarma en pantalla si quedará constancia de la misma en el sistema.

6.5.14 Identificación de report de alarma
Indica si el mensaje de alarma va a salir por impresora o no. Se puede seleccionar para
cada línea de alarma la posibilidad de salir por impresora. Este campo nos indica que esto va a
ser efectivo o no.
6.5.15 Comentarios de alarma
Este bloque contiene los comentarios que se han realizado sobre las alarmas. Los
comentarios pueden ser introducidos por el operario a posteriori de que se genere la alarma, y
se pueden asociar a la próxima aparición de la alarma mediante este bloque.
La funcionalidad de los comentarios se centra en la búsqueda de una solución al

problema de manera empírica: “salta la alarma cuando hemos abierto el rastrillo de entrada...”

6.5.16 Texto de información de la alarma
6.5.17 Saltar a ventanas a partir de una alarma
El bloque loop in alarma indica que la alarma presente posee la funcionalidad de saltar
a una ventana si se presiona el botón loop in alarm.

6.5.18 Texto de la alarma
El primero de los bloques de usuario.

Este bloque es el más importante, ya que define el texto que identifica a la alarma (p.
Ej: Fallo compresor 35).
Podemos definir la cantidad de caracteres máxima que tendrá nuestro mensaje de
alarmas. Por defecto son 10, pero es demasiado escaso para los mensajes corrientes.
Recomendamos de 25 a 30 caracteres.
6.5.19 Lugar donde se produce la alarma
Otro bloque de usuario que nos indica donde se ha producido la alarma (p. Ej: Sector
de entrada).

6.5.20 Bloques de proceso
Un bloque de proceso es un campo en el que vamos a representar no un texto, sino un

valor del proceso que tiene que ver o está relacionado con la aparición de la alarma.
Podemos definir varios valores de proceso, pero normalmente con uno basta. La
asignación del valor que debe configurarse en este campo es individual para cada una de las
alarmas, lógicamente.

6.6 Línea de mensajes de alarmas

Desde message line format podemos definir los tipos de líneas de alarmas que
deseemos.
En una línea de alarmas podemos definir:

• El texto que la identifica (p. Ej: Línea para mensaje principal, línea para histórico de
alarmas, etc...).
• Los bloques que la componen y en qué orden deben encontrarse.
Figura 135: Línea de mensaje de alarmas.

6.7 Ventanas de alarmas

En la ventana de alarmas podemos definir como debe de configurarse para representar
las alarmas en pantalla
Disponemos aquí también de un pequeño Wizard.
Figura 136: Ventana de alarmas.
Las opciones a configurar en general information de la ventana de alarmas son:

• Window: Nombre de la ventana identificativo. Por este nombre se llamará después desde
el Graphics designer a la misma.
• Window Title: Título que puede aparecer arriba de la ventana.
• Font: Fuente de los textos de la ventana de alarmas.
• Window Type: Tipo de ventana de alarmas. Existen tres tipos:
Message Window: se utiliza para mostrar la última alarma que se ha producido en la
instalación. Suele colocarse una pequeña ventana en la pantalla principal que nos

indica que alarma acaba de saltar, con un botón que accede a la ventana en la que ya
se encuentra la ventana de alarmas con el histórico de alarmas.
Short Term Archive Window: Ventana que almacena las alarmas en un histórico para
que posteriormente podamos observarlas. El tambor de alarmas puede ser
configurado.
Sequence Archive Window: Archivo secuencial de alarmas. Las alarmas se van
almacenando en él sin límite de almacenamiento.
• El botón selection nos permite seleccionar que bloques son los que se deben almacenar
en el histórico, independientemente de los que estemos representando en pantalla al
aparecer la alarma.
Figura 137: Selección de la línea a mostrar en la ventana de

alarmas.
Message Line: En esta ventana seleccionamos la línea de alarmas que debe aparecer
en esta ventana de alarmas.

Parameters:
• Líneas de separación: horizontales y/o verticales.
Title line: Título de la línea.
• Selection: Tipo de selección de la alarma dentro de la ventana. Podemos decidir si la
selección es por celda, o por línea.
• Column title: Coloca encima de cada columna un título descriptivo de la misma.
• Change column Width: Poder cambiar el ancho de las columnas desde el runtime. Si se
realiza click sobre la línea de separación de una columna en el runtime, la columna se
autoajusta al ancho de la misma.
• Shortem Title: Si el título de la columna no se puede representar entero en la columna
debido a que no cabe, seleccionando esta opción se añaden unos puntos suspensivos,
para indicarnos que existe texto oculto.
• Shortem cell content: Si el texto de una celda de un bloque de la línea de alarmas no se
puede representar entero debido a que no cabe, seleccionando esta opción se añaden
unos puntos suspensivos, para indicarnos que existe texto oculto.
• Auto Scrolling: Cuando esta opción está activada, al entrar a la ventana de alarmas, si la
cantidad de alarmas es superior a la que cabe en la ventana de alarmas, salta
automáticamente al final de la pila de alarmas. En caso contrario (opción no seleccionada),
nos muestra desde la primera alarma en pantalla.

Status bar:
• Display status bar: Muestra en la parte inferior de la ventana de alarmas una línea de
status que podemos configurar en la ventana Elements of the status bar.
Las opciones a configurar en la línea de status son:
Date: muestra la fecha actual.
Time: muestra la hora actual.
Number of the messages in the list: muestra el número de alarmas DIFERENTES
actuales en la ventana.
Number of messages in the window: muestra el número de alarmas actuales en la
ventana, independientemente de que se repitan.
Number of messages not yet acknowledged: cantidad de alarmas no acusadas aún,
y que deben serlo.
Lock: Algún tipo de alarmas está siendo bloqueado actualmente, por lo que puede
producirse y no ser representado en la pantalla.
Selection: Se está aplicando una selección o filtrado al histórico de alarmas, de tal
manera que las que se están representando actualmente no son todas las que hay.
Figura 138: Barra de estado de la ventana de alarmas.
• Alignement: Donde deseamos la línea de status (arriba de la ventana o abajo).
Toolbar:
• Display toolbar: muestra la barra de herramientas en la ventana de alarmas.
• Alignement: posición de la barra de herramientas (izquierda, derecha, arriba, abajo).

Keyboard: botones de la barra de herramientas. Las opciones posibles son:

Display process message window: Muestra la ventana en la que se representan las
alarmas actuales (la ventana de alarmas propiamente dicha).
Display short term archive: Muestra la ventana en la que se representa el histórico de
alarmas de tipo shot term o de tambor.
Display sequence archive: Muestra la ventana en la que se representa el histórico de
alarmas de tipo secuencial.
Figura 139: Barra de herramientas ventana de alarmas.
Horn acknowledgement: acuse del aviso horn.

Single acknowledgement: Acuse de la alarma actualmente seleccionada.
Group acknowledgement: Acuse del grupo de alarmas al que pertenece la alarma
actualmente seleccionada.
Auto-Scroll On/Off: Activa el auto-scroll en la pantalla, para poder desplazarnos por la
ventana de alarmas cuando la cantidad de alarmas es superior a las que se pueden
representar en pantalla.
Selection: Especifica un filtrado de alarmas, de tal forma que nos presenta no todas,
sino un extracto de acuerdo al criterio especificado por nosotros. Las posibilidades de filtrado
son:
Number: Mostrar un determinado rango de alarmas (p. Ej: de la alarma 1 a la
alarma 1 solo muestra el histórico de la alarma 1).

Message classes: muestra solo las clases de mensaje que seleccionemos (p.
Ej: crear una clase que sea alarmas zona 1 y luego filtrar por este tipo de clase).
Text blocks: filtrar por un determinado bloque (p. Ej: todas las alarmas que
tengan texto en el campo point of error).
Process Value: filtrar por valor de proceso (p. Ej: todas las alarmas que tengan
un valor de proceso asignado).
Figura 140: Filtrado de alarmas.
Con la opción store settings permanently el filtrado queda activado permanentemente

aunque nos salgamos de la pantalla de alarmas. Si se selecciona esta opción, hay que tener
cuidado en dejar en la barra de status activada la visualización de select para que sepamos
que se está aplicando un filtrado.
Continuando con los botones de que disponemos en toolbar de alarmas tenemos:

Set lock: Este botón bloque un determinado tipo de clase de alarma o grupo
definido por el usuario, de tal manera que si se producen las alarmas que pertenecen a este
grupo, no son mostradas ni en la ventana de alarmas, ni archivadas en el histórico de alarmas.
Esta opción es útil cuando se conoce una alarma que puede producirse, pero que no es
actualmente importante para el proceso, y va a estar apareciendo de manera repetitiva hasta
que podamos solucionar el fallo.
En la imagen podemos ver el tipo alarmas bloqueado, por lo que aunque salte alguna
de sus alarmas, no se visualizará.

Figura 141: Bloqueo de tipos de alarmas.
Otra posibilidad es bloquear alarmas de manera individual y no por grupo (p. Ej: un
nivel de depósito se ha roto y da siempre fallo de desbordamiento). Para ello, deberemos de
generar un grupo, User defined, y añadir las alarmas que deseemos que formen parte de dicho
grupo. Posteriormente lo bloquearemos.

Report functions: realizar un report a impresora de la ventana de alarmas.

Reset: La opción reset en realidad es el botón Emergency Action. Este botón
nos permite enviar al PLC un mensaje de sistema para realizar una acción de emergencia.
Figura 142: Envío de mensajes al PLC frente a una

alarma.
Beginning of the list: Ponerse al principio de la lista de alarmas.

End of the list: ponerse al final de la lista.
Next Message: Pasar a la siguiente alarma.
Previous message: pasar a la alarma anterior.
Infotext: Visualizar el texto de información de una determinada alarma.
Figura 143: Ventana de infotext .
Comments: Comentarios del usuario al respecto de una determinada alarma,

que posteriormente pueden servir para la resolución del problema a posteriori.

Figura 144: Comentarios de alarma.
Loop in alarm: permite saltar a una pantalla relacionada con la alarma que
actualmente se está seleccionando (p. Ej: Alarma compresor enfriadora 1 temperatura alta, y
un loop a la ventana en la que se encuentra el compresor, para poder arrancar el motor de
reserva y reducir la temperatura).
Todos los botones de la barra de herramientas poseen una serie de opciones a las que
se accede seleccionando el texto del botón y posteriormente el botón que hay sobre la ventana,
denominado properties.
Figura 145: Acceso a un botón del

toolbar de alarmas.

Las únicas importantes son:

• Operator Authorization: No todos los usuarios pueden p. Ej. acusar una alarma. Aquí
podemos definir que usuarios tiene acceso a presionar el botón correspondiente.
• Key: Podemos asignar una combinación de teclas, para acceder al botón desde el teclado
sin ratón.
La última característica que nos queda por ver de la ventana de alarmas es que podemos
visualizar como va a quedar nuestra ventana si pulsamos sobre el icono de la ventana que
aparece en la ventana principal del alarm logging. La primera de las opciones es Window
Preview. La representación se puede apreciar en la imagen inferior.
Figura 146: Ventana previa de alarmas.

6.8 Message Classes
6.8.1 Introducción
Una clase de mensaje es una agrupación de alarmas que poseen una determinada
característica. Generalmente se utiliza para disponer de un grupo de alarmas que necesitan ser
acusadas porque son muy graves, y otro grupo de avisos, que no requieren acuse y son solo
de información.
Disponemos de hasta 16 clases de mensajes, que podemos configurar como

deseemos. Cada una de estas clases puede contener a su vez tipos de mensajes.
Un tipo de mensaje es un subgrupo de una clase que comparten todas las
características, salvo el color de representación a la hora de aparecer, desaparecer y ser
acusadas. Los tipos de mensajes se gastan para, dentro de una clase de aviso, p. Ej. poder
determinar mediante un código de colores de que parte de la máquina proviene el aviso, o a
que parte del proceso pertenece (creación de pieza, soldadura, acabado de pieza...).
6.8.2 Clases
Las clases que nos genera el wizard por efecto son:

• Error.
• Sistema, con requerimiento de reconocimiento
• Sistema, sin requerimiento de reconocimiento.
Si entramos dentro de la clase error, tenemos tres tipos definidos:

• Alarma
• Fallo
• Aviso
Todos los textos pueden cambiarse por el que nosotros deseemos.

Figura 147: Clases de mensajes de alarmas.
Dentro de reconocimiento de clase podemos definir para la misma:

• Acknowledgement came in: que deba ser acusada una ves aparezca la alarma
perteneciente a dicha clase.
Figura 148: Reconocimiento de clases.

• Acknowledgement Went out: que deba ser acusada la alarma una vez desaparezca.
• Flashing On: que parpadeen las alarma de esta clase cuando estén activas.
• Only initial value: que parpadee solo el primer valor de esta clase que se encuentre
activo.
• Message without status Went Out: Anula el acuse de alarmas al desaparecer.
• Central signal devices:
Separate Ack. Key: asignar una segunda opción de acuse, independiente de la de
hacer desaparecer de la pantalla de alarmas la actual alarma. Las alarmas del grupo
seleccionado, al aparecer habilitan el botón Horn de la barra de herramientas. Se
puede asignar una variable de proceso como alarmas no acusadas, de tal manera que
hasta que no presionemos el botón horn, aunque la alarma se haya acusado,
continuaremos teniendo constancia de que se ha producido alguna alarma en la
instalación. Como el botón horn puede tener una prioridad distinta que el de acuse, se
puede dejar esta opción para que un responsable de control sepa que se ha producido
una alarma pese a que se hayan acusado todas y no haya histórico.
Status text:
Podemos definir los caracteres que aparecen el bloque status display a la hora de
mostrar los mensajes al aparecer, al desaparecer y al ser acusados.
Figura 149: Texto de status de clase de alarmas.

A su vez, todos los tipos que se definan dentro de una clase de alarmas pueden tener
diferentes colores con respecto a los otros tipos, tanto para:
• El color de texto y fondo cuando aparece la alarma
• El color de texto y fondo cuando desaparece la alarma
• El color de texto y fondo cuando es acusada la alarma.
Figura 150: Colores de la clase de alarmas.
Dentro de cada tipo perteneciente a una clase podemos definir la cantidad de líneas de
alarma que queremos crear para este tipo. Posteriormente deberemos de rellenar los textos
que lleven asociados.
Figura 151. Crear mensajes de la clase de alarmas.

6.9 Alarmas analógicas
6.9.1 Introducción
Las alarmas analógicas nos permiten generar alarmas a partir de una comparación que
se realiza en el WinCC entre un valor de proceso y un límite generado por nosotros. Esto
descarga al PLC de realizar este tipo de cálculos, pero solo si dicha alarma no tiene ninguna
repercusión posterior sobre el proceso, como tener que arrancar un motor, o hacer sonar una
sirena.
6.9.2 Generación de una alarma analógica
Si nos situamos sobre analog alarm, con el botón derecho podemos seleccionar New.
Figura 152: Definición de alarma analógica.
Los datos a rellenar para generar una nueva alarma analógica son:
• La variable a monitorizar.

• Podemos elegir seleccionar un único mensaje de alarma para todos los límites que
definamos en una alarma analógica, en cuyo caso debemos indicarle el número de alarma
deseado. Si no elegimos esta opción cada límite posterior que generemos generará un
mensaje de alarma diferente. Por ejemplo , si estamos controlando el nivel de un pozo, nos
interesa dejar desactivada esta casilla, ya que deseamos tener un límite de pozo vacío y
otro de pozo lleno. Sin embargo si vamos a monitorizar la temperatura de un motor, puede
ser interesante seleccionar esta opción, ya que solo tendremos un límite de motor
sobrecalentado, no generamos alarma por motor frío.
• Delay Time: Tiempo que debe de estar superado el límite que definamos para que haga
saltar la alarma. Esta opción es interesante en valores analógicos que suelen tener una
cierta oscilación permanente, y no nos interesa que dispare hasta que efectivamente no
haya llegado a sobrepasar el límite establecido (los temas de aguas suelen generar este
rizado sobre un valor continuo, al producir pequeñas olas que falsean la señal de nivel).
6.9.3 Generación de límites de alarma software
Una vez generada la variable analógica, podemos comenzar a crear límites asociados a la
misma. Colocándonos sobre ella y con el botón derecho, seleccionamos new..
Figura 153: Crear un límite de alarma analógica.


• Tipo de límite:
Upper limit hace saltar la alarma si el valor de proceso es superior al valor de límite
definido.
Lower limit hace saltar la alarma si el valor de proceso es inferior al valor de límite
definido.
• Limit value or tag: podemos crear un límite estático (introduciendo un valor) o un límite
dinámico (introduciendo el nombre de una variable). Si el límite lo hacemos dinámico,
posteriormente podremos cambiarlo al modificar el valor de la variable.
• Indirect: Esta casilla indica que el valor que pasamos en tag es una variable de tipo texto
que contiene el nombre de la variable que deseamos que sea el límite software.
• Deadband: La banda muerta es un rango de valores en los cuales no se genera alarma
bajo unas ciertas circunstancias. Supongamos que estamos controlando el nivel de un
pozo para que no rebose. Deseamos que salte una alarma cuando el valor del nivel sea
superior a 100. Cuando el nivel del pozo es 101, y transcurrido el tiempo definido en delay
time, salta la alarma. Si inmediatamente después el nivel baja un par de centímetros y
vuelve a subir, se nos volverá a disparar la alarma pese a que la hayamos acusado.
Mediante la banda muerta, nos aseguramos que una vez disparada la alarma, hasta que el
valor del pozo no baje por debajo de la banda y vuelva a llegar al límite, no se disparará de
nueva dicha alarma de límite. Las posibilidades son:
Absolute o percent: el valor de la banda es absoluto o en porcentaje sobre el máximo
de la variable de límite seleccionada.
Histeresis: Valor de la histéresis.
Efective if message is triggered: La banda cuenta a partir de que el mensaje se ha
disparado (cuando sobrepasa el límite del pozo).
Efective if message is tacken back: La banda cuenta a partir de que el valor del pozo
baja por debajo del límite, una vez lo hubiera superado.
Efective for both: la banda de histéresis cuenta tanto una vez se supere el límite,
como cuando se baje por debajo del límite.
• Message: Número de mensaje de alarma que se asigna a este límite software.

6.10 Archivar alarmas
Si deseamos archivar en el disco duro las alarmas que se vayan generando, tenemos
que seleccionar en archives cuando seamos guardarlas. Las opciones posibles son:
• Guardar las alarmas en un archivo rotatorio o de tambor (short term archive) y/o
• Guardarlas en un archivo secuencial (sequencer archive).
Si seleccionamos en un archivo de tambor, podemos definir si dichos valores se

almacenan en la memoria del ordenador o en el disco duro: Si los almacenamos en la memoria
del ordenador cada vez que salgamos de WinCC perderemos el histórico de alarmas.
También se puede definir la cantidad de alarmas que integran el tambor.
Con el botón selection podemos indicar que bloques de la alarma deben ser
almacenados, y bajo que circunstancias (solo las alarmas que aparecen, las que desaparecen,
etc..)

Figura 154: Archivar las alarmas en el disco duro.
Figura 155: Filtrado de bloques a archivar en el disco duro.

6.11 Imprimir alarmas
Desde la propia ventana de alarmas tenemos la opción de enviar reports a impresora

para disponer en papel tanto del histórico de alarmas, como de las última alarmas que existen
en la instalación.
Para poder imprimir desde la barra de herramientas de la ventana de alarmas,
necesitamos activar en reports la impresión en:
• Message sequence report: poder imprimir un report de las alarmas actuales.

• Archive report active: poder imprimir un report del histórico de alarmas.
Desde el icono de archive report podemos acceder a una ventana de selección en la que
podemos definir los bloques que queremos que aparezcan en nuestro report a impresora. Si no
indicamos nada, realizará el report predefinido en el apartado reports para archive reports.

Figura 156: Ventana de impresión de report secuenciales.
Figura 157: Filtrado de bloques de alarma a impresora.

6.12 Generación de alarmas
En la parte inferior del alarm logging podemos definir las alarmas que deseamos que
existan en nuestro proyecto.
Figura 158: Ventana del alarm logging.
Las alarmas las podemos copiar, pegar, y ver sus propiedades.

La primera agrupación de propiedades es parameters. La descripción de cada una de ellas
es la siguiente:
• Number: número de alarma, de solo lectura, que identifica la alarma dentro del array de
alarmas.

• Class: Clase a la que pertenece la alarma. De esta clase le derivarán una serie de
propiedades ya descritas anteriormente.
• Type: Tipo de la clase a la que pertenece la alarma. De esta propiedad le derivará su color
de fondo y texto.
• Group: Grupo al que pertenece la alarma. Al agrupar las alarmas en grupos podemos
posteriormente realizar acuses de grupos (acusar varias alarmas a la vez), filtrados (ver
solo las alarmas de un grupo) o reports a impresora (imprimir solo las alarmas de un
determinado grupo).
• Propiedades del mensaje:
Is single acknowledged: la alarma debe ser reconocida de manera individual y no en
un grupo de alarmas.
Trigger horn: Dispara la variable asignada en trigger horn. Recordemos que mediante
la activación de trigger horn, se nos activa un bit de una variable que deseemos una
vez se dispare alguna alarma. El bit continúa activo independientemente de que
nosotros acusemos las alarmas, hasta que se pulsa el botón horn de la barra de
herramientas de la ventana de alarmas. Estos nos puede servir para poner en marcha
un indicador luminoso que permanecerá activo hasta que lo apaguemos con dicho
botón.
• Will be archived: la alarma se guardará en el histórico de alarmas.
• Will be reported: la alarma se imprimirá por impresora con el report de alarmas.
Create with a negative edge: la alarma aparece con un flanco negativo, no cuando aparece la
señal, sino cuando desaparece.
• Triggers an action: la alarma dispara una acción en C que debe ser asignada.
• Event tag: Variable y bit de la variable que activa la alarma.
Acknowledge tag: variable y bit de la variable donde se guarda automáticamente si la alarma
ha sido ya acusada o no.
• Status bit: variable y bit de la variable en el que se encuentra el valor actual de la señal de
proceso (si aún existe la alarma o no).
• Format DLL:
La segunda agrupación de propiedades es text:

• Infotext: texto de información que va asociado a la alarma.
• Message text: El texto descriptivo de la alarma
• Point of error: el lugar donde se ha producido la alarma.
Los demás bloques de usuario se activan si han sido seleccionados a la hora de configurar
la línea de alarmas.

Figura 159: Asignación de variables al mensaje de alarma.
En la ventana tag/action podemos definir:

La variable de proceso que va asignada a cada bloque de proceso que hayamos determinado
ea la hora de confeccionar la línea de alarmas.
• La picture a la que hay que saltar si se presiona el botón loop in alarm.
• La función que llama a la ventana. Si queremos que además de saltar a la picture, ejecute
una acción en C, en lugar de seleccionar como function name openpicture,
seleccionaremos una que hayamos generado nosotros, y que acabe con una llamada a
openpicture pero desde C.

Figura 160: Asignación de los mensajes de texto a la alarma.
Las líneas que definamos de esta forma serán de dos tipos:

• Las que van asociadas a una variable de comunicaciones
• Las que no llevan variable de comunicaciones, y son invocadas por una alarma software,
antes descrita.

6.13 Colocar la ventana de alarmas

Una vez hayamos terminado de definir nuestras alarmas, guardamos nuestra
configuración y nos salimos del alarm logging. Nos resta definir en que ventana o ventanas
queremos colocar nuestras ventanas de alarmas.
Esto por supuesto lo realizaremos desde el graphic designer. Estando en él insertamos
un objeto de tipo aplication window.
Seleccionamos alarm logging en el diálogo, y posteriormente nuestra ventana de

alarmas ya configurada.
Por último, sólo nos queda recordar activar el runtime de alarmas desde computer del
control center. El arranque de una parte de runtime del WinCC solo es efectivo si se para la
runtime y se vuelve a arrancar, por lo que si ya estuviera activado el runtime del WinCC, en
este punto sería necesario pararlo y rearrancarlo.

Manual WinCC V4.02 Tag Logging

TAG LOGGING


7 TAG LOGGING
7.1 Introducción
El tag logging es la parte del WinCC que se encarga del almacenamiento de los valores
de proceso en el disco duro, así como de mostrarlos tanto en formato de gráfica como de tabla
de valores. Así mismo, permite editar dichos valores a posteriori desde la base de datos.
La presentación del tag logging en pantalla es la siguiente:
Figura 161: Ventana del tag logging.

7.2 Propiedades del proyecto
Si pulsamos sobre el nombre de nuestro proyecto con el botón derecho, podemos

seleccionar sus propiedades.
Figura 162: Propiedades de los archivos del tag

logging.
7.2.1 Exportar variables en formato Dbase III
La opción más interesante es que podemos seleccionar el almacenar las variables de

un archivo Short-term que generemos en formato Dbase III. Esta opción es especialmente
aconsejable cuando queramos disponer de un archivo de tambor que deba disponer de un gran
número de variables, ya que el acceso en formato Dbase III es más rápido. También es una
elección aconsejable cuando necesitemos exportar nuestros valores a otra base de datos que
no sea la del propio WinCC.

Si activamos esta casilla, todas las variables que definamos en los archivos de nuestro
proyecto generarán en el subdirectorio Pde\archivo_de_valores un archivo en el que
almacenan su valor de proceso, componiéndose dicho archivo del nombre de la variable, con la
extensión DBF. El formato Dbase III es exportable por la mayoría de las aplicaciones. El
archivo que genera posee 3 columnas:
• T: Fecha y hora de la adquisición del valor. Este campo es de texto y no separa la fecha de
la hora, por lo que su tratamiento es relativamente difícil, requiriendo de una macro que nos
descomponga los campos en celdas separadas si deseamos posteriormente realizar
consultas por fechas o intervalos de tiempo.
• V: valor del proceso. Este es el valor del proceso que almacena en el archivo.
• F: Código de error de lectura del valor del proceso. Si el valor es correcto, este campo está
a cero.
En la imagen se puede apreciar un archivo exportado automáticamente a Dbase III y

abierto con Excel.
Observar que el campo fecha, en realidad es 1999-01-02 y 19:40:34:990, es decir, el 2

de enero de 1999 a las 19:40:34 y 990 milisegundos. Esta descomposición es necesaria
realizarla a mano, ya que no almacena cada valor en un campo de la base de datos. Sin
embargo, es posible su tratamiento debido a que siempre se encuentran los datos de fecha,
hora, etc.. en las mismas posiciones de la cadena de texto. Nota: Hay que observar que la
notación de la fecha es estilo americano (año, mes, día), no europeo.

7.3 Tiempos de adquisición de valores

Podemos definir timers, es decir, temporizadores de proceso, que posteriormente
podremos utilizar para la adquisición o el almacenamiento de valores de proceso a intervalos
propios.
Figura 163: Temporizadores de lectura y adquisición de datos.
Los predefinidos aparecen en la figura, pero si deseamos uno nuevo, solo necesitamos
rellenar la pantalla de nuevo timer, o modificar un o existente.

Figura 164: Definición de un nuevo ciclo de adquisición

de datos.
En la imagen se puede ver un nuevo temporizador que actuará cada 3 segundos. Las
opciones son:
• Que se dispare el temporizador solo entrar al WinCC, pese a que no le corresponda aún.
• Que se dispare el temporizador al salir del WinCC, pese a que aún no le corresponda.
• Poder seleccionar la fecha exacta de comienzo del ciclo de disparo. A partir de ese minuto
y ese segundo, comenzará cada 3 segundos a dispararse.

7.4 Crear archivos de valores en el disco duro
La opción archives de la ventana del tag logging es la que se encarga de la

configuración de los archivos de almacenamiento de valores en el disco duro. Para realizar la
configuración de los mismos disponemos de un Wizard que aparece en el menú contextual
presionando sobre archives con el botón derecho.
7.4.1 Archive Wizard
Lo primero que se nos pide en el Wizard es el nombre de nuestro archivo. Dicho

nombre debe de ser una única palabra, por lo que si queremos hacerla significativa deberemos
generalmente de separar varias palabras con subrayados, como muestra la figura.
Figura 165: Creación de un archivo de valores. Paso 1.
También se nos permite elegir entre los tres tipos de archivos posibles. Los archivos de
WinCC pueden ser:

• Archivos de proceso: archivo que almacena los valores de una o varias variables en el
disco duro.
• Compressed Archives: archivos de valores comprimidos. Se realiza una compresión de
los datos antes de almacenarlos, y una descompresión a la hora de sacarlos de nuevo de
la base de datos. Este tipo de archivos es ideal para el almacenamiento de grandes
cantidades de datos que no requieran un almacenamiento inferior al minuto.
• User Archives: Archivos de usuario.
Figura 166: Creación de un archivo de valores. Paso 2.
En el paso 2 del Wizard podemos seleccionar aquellas variables que van a ser
almacenadas en el archivo. Con el botón select podemos ir añadiéndolas a la lista. Estas
variables sólo comparten el lugar de almacenamiento, pero no necesariamente el tiempo de
lectura ni el de almacenamiento, como posteriormente veremos.
7.4.2 Propiedades de los archivos de valores
Si presionamos con el botón derecho sobre el nuevo archivo de valores que se nos ha
generado en el Tag Logging podemos editar sus propiedades.
Las opciones que podemos modificar son:
• Archive name: podemos cambiar su nombre a posteriori.
• Comment: podemos añadir un comentario sobre dicho archivo.
• Archiving at system starts: Indica si el almacenamiento en el disco duro debe de
comenzar solo entrar en la runtime de WinCC, o cuando nosotros se lo indiquemos con una
función. La opción enabled comienza a almacenar nada más entrar en la runtime, la opción
locked no.

• Archive type: Esta función de solo lectura nos indica de que tipo es nuestro archivo. Esto
quiere decir que una vez generado un tipo de archivo no podrá ser modificado
posteriormente, por lo que tendremos que generar otro y borrar el actual si deseamos
cambiar de tipo de archivo nuestros valores.
Figura 167: Propiedades del archivo de valores.
• Authorization level: Nivel de autorización requerido para poder leer los valores del
archivo, y para poder editarlos. Hay que tener en cuenta que estos datos son variables
dependiendo del archivo en cuestión, luego se puede hacer archivos protegidos (nivel
elevado de protección) y otros desprotegidos. También se puede dejar desprotegida la
lectura, y proteger la escritura para que solo el responsable pueda modificar los datos en el
archivo.

Hay que tener en cuenta que si no se ha creado por lo menos un usuario en el

user administrator, lógicamente no aparecerá la ventana de niveles de usuario al
presionar el botón select. Para poder seleccionar los niveles de lectura, o
escritura en archivos de proceso, primeramente deberá ir al capítulo dedicado a
user administrator y generar por lo menos un usuario nuevo, asignándole unos
niveles que sean de leer archivos y otro de escribir en archivos. Al volver a esta
pantalla, ya podrá seleccionar el nivel deseado en la misma.
• Action during start/enabled: podemos definir una acción en C que se ejecutará cada vez
que se habilite la lectura y almacenamiento en el archivo.
Figura 168: Tamaño del tambor de valores a archivar.
En la solapa archive parameters, podemos definir:

• si el archivo seleccionado es short-term el tambor de valores deseado.

• Memory location: donde guardar los valores leídos. Se pueden guardar en la memoria
RAM del ordenador o en el disco duro. Si se selecciona en la memoria del ordenador, el
cálculo para saber cuanta RAM estamos consumiendo es:
Memoria RAM consumida=Numero de valores de proceso * 28 bytes
Si no se dispone de un SAI en la instalación no es recomendable almacenar en la memoria

del ordenador, ya que si se desconecta la alimentación los datos almacenados se pierden. Solo
sería interesante esta opción cuando necesitamos leer muchos valores rápidamente y o no los
vamos a almacenar de manera permanente, o solo deseamos obtener en pantalla una
representación p. Ej,. de una curva de temperaturas en los últimos 20 segundos con una
lectura cada medio segundo. En estos casos, el almacenamiento en el disco duro produciría un
acceso constante al mismo, por lo que el WinCC sería ingobernable si no se accede a
memoria.
• Action for exporting the short-term archive: Acción en C que se tiene que ejecutar para
exportar el archivo short-term. Cuando se llega al final del tambor, se ejecutará
automáticamente esta acción en C, en la cual debemos de incluir nuestra programación
para el almacenamiento de dichos valores en otro archivo. Si no incluimos en este punto
dicha acción, el tambor da la vuelta y comienza a machacar el primer valor que almacenó
con el nuevo adquirido, y así sucesivamente.
• Archive type: Los archivos pueden ser una vez definido su tipo (de proceso, comprimido o
de usuario) de dos tipos:
Short-term: archivos de tambor.
Sequence: archivos lineales.

7.5 Adquirir variables de archivo
7.5.1 Propiedades de variables de archivo
Las variables que hemos definido en nuestro archivo, aparecen en la ventana inferior
en forma de tabla. Si presionamos el botón derecho sobre cada una de ellas podemos editar
sus propiedades particulares.
Figura 169: Propiedades de la variable a almacenar.

Las propiedades de una variable almacenada dentro de un archivo son:

• Name of the archive tag: podemos dar un nombre distinto a la variable almacenada que el
respectivo de la variable de proceso.
• Name of the process tag: Valor de proceso que se está almacenando en dicha variable de
archivo. Desde esta ventana también podemos cambiar de variable de proceso a
almacenar a posteriori.
• Comments: Un comentario individualizado para cada variable de archivo.
• Supplying tags: Se puede seleccionar la adquisición de datos desde el administrador de
variables hasta el archivo de manera:
Automatic: los valores se transfieren de uno a otro de manera automática.
Manual: Los valores requieren de una orden para ser transferidos desde el
administrador hasta el archivo.
• Archiving at system starts: Comenzar a guardar valores en esta variable de archivo
automáticamente al arrancar la runtime de WinCC o no.
• Archiving type: Existen tres tipo de almacenamiento para una variable de proceso:
Acyclic: Se almacenan valores de proceso cuando arranca la habilitación del mismo y
cuando se deshabilita.
Cyclic-Continous: Se almacenan valores de proceso desde que se habilita el mismo,
con una frecuencia marcada por el ciclo de almacenamiento, hasta que se deshabilita.
Cyclic Selective: Igual que el ciclo continuo, con la diferencia de que además se
puede gobernar cuando debe durante el tiempo de habilitación de almacenamiento
mediante una función que determina el comienzo de lectura y la finalización de la
misma.
Este apartado es el más importante de una variable de archivo, ya que determina su

funcionamiento. ¿Cuándo gastar cada uno de ellos?, depende del uso que deseemos darle a la
variable, claro está.
Variables Acyclic: Valores que solo deseamos guardar en el disco duro cuando un bit
se active en el PLC (p. Ej. guardar los valores de presión cuando una pieza pase por el horno).
El problema con este tipo de variables es que almacenan dicho valor cuando aparece
el bit y cuando desaparece (por flanco positivo y por flanco negativo), por lo que nos duplica el
valor deseado, con el agravante de que el valor al aparecer el bit no necesariamente debe ser
igual al que almacena cuando desaparece el bit. La solución esta en almacenar la media de los
valores leídos durante el tiempo que el bit está activo. En cualquier caso, no solventa este tipo
de variable de archivo el problema, ya que el duplicar las variables hace prácticamente
ingobernable el posterior estudio del archivo en el disco duro.
Variables Cyclic-Continous: Valores que deseamos guardar siempre en el WinCC
cada x tiempo.

Variables Cyclic Selective: Valores que deseamos guardar en el WinCC solo durante
determinados períodos de tiempo (p. Ej: cada vez que pase un ladrillo por el horno, y mientras
esté dentro, almacenar los valores de presión en el WinCC).
• Also put archived value in tag: determina que variables deben también almacenarse en
esta variable de archivo además de la que se indicó al principio.
Figura 170: Tiempos de adquisición y archivo de variables.
En la solapa parameters podemos definir:

• Cycle acquisition: Este tiempo indica cada cuanto debe ser leído el valor de proceso del
administrador de variables para pasar a la variable de archivo.
• Cycle Archiving: Este tiempo indica cada cuanto debe ser almacenada la variable de
archivo en el disco duro (o en la memoria del WinCC, si así se decidió). El valor que se
almacena depende del método que se utilice para su procesamiento (véase Processing).
• Processing: Método de cálculo para el almacenamiento de la variable de archivo. Las
opciones posibles son:
Actual Value: Almacena el último valor adquirido, despreciando si los hubiera otros
valores que se hubieran adquirido pero aún no se hubieran almacenado.

Sum: Suma todos los valores adquiridos y los almacena.

Maximum value: Almacena el valor mayor de todos los adquiridos durante el período
de tiempo entre el último almacenamiento y éste.
Mean Value: Calcula la media de todos los valores adquiridos y almacena dicho valor.
Es el ideal para la mayoría de los procesos.
Action: Realiza una acción en C cada vez que deba almacenar el valor de archivo en
el disco duro. Esta opción es ideal para cálculos complejos de estadística que no sean
la suma, el máximo o la media, que ya son contemplados por el propio WinCC. El botón
select permite seleccionar que acción es la que se realizará.
Minimum value: Almacena el valor menor de todos los adquiridos durante el período
de tiempo entre el último almacenamiento y éste.
• Unit:
• Save on error: permite determinar que valor almacenar ante la aparición de un error en la
lectura de la variable desde el proceso. Las opciones posibles son:
Last value: Almacena el último valor leído desde el administrador de variables.
Substitute value: toda variable dispone de un valor de substitución. Podemos
determinar el almacenar dicho valor frente a un error de comunicaciones.
• Archive upon change: Esta opción permite almacenar el valor exclusivamente si cambia
dicho valor en el proceso. Es muy interesante, ya que permite substituir las carencias del
tag logging en la adquisición de datos realizando programación en el PLC. Por ejemplo,
ante el fallo del acyclic, que nos archiva valores en el flanco de subida y el de bajada,
podemos programar en el PLC una subrutina que cada vez que un bit esté activo, nos
transfiera un valor del plc a otra variable de comunicaciones. Si el valor es el mismo que
poseía se le aumenta o disminuye en una cantidad insignificante para su posterior análisis
desde WinCC. Así, solo adquiere el valor el WinCC cuando se modifica, que en realidad es
cuando existe un bit en el PLC.
• Hysteresis: % que debe de variar la variable de proceso con respecto al último valor
almacenado para que se vuelva a considerar su almacenamiento como necesario. Esta
opción es interesante en valores que está variando ligeramente en el PLC, pero sólo nos
interesa almacenarlos cuando su variación sea significativa, ya que en caso contrario se
convertiría en un almacenamiento continuo de la variable.

Figura 171: Límites de almacenamiento de variable.
En display podemos definir:

• No display limitation: almacena en la variable de archivo cualquier valor que provenga de
la variable de proceso asignada.
• Configured directly:. Si la variable de proceso ha alcanzado un límite máximo o mínimo,
permite configurar el valor a almacenar en la variable de archivo de manera independiente
al valor que proviene del proceso. Esta opción es interesante cuando deseamos ante un
valor que se ha salido de escala presentar en la gráfica un valor 0.

Figura 172: Acciones de arranque de gráfica, de parada y de lectura.
La ventana events nos permite configurar:

• Start Events: La función en C que permite habilitar el almacenamiento de variables de
archivo en el disco duro.
• Stop Events: La función en C que deshabilita el almacenamiento de variables de archivo
en el disco duro.
• Dynamic: La función que se ejecuta cada vez que un valor de archivo es almacenado en el
disco duro.
Para que una de estas funciones realicen la acción deseada, deben devolver un 1. Así, si
deseamos arrancar el almacenamiento de valores en la gráfica con un bit, lo que haremos será
consultarlo dentro de una función. Supongamos que deseamos arrancar la gráfica cuando un
bit de proceso esté a uno y pararlo con ese mismo bit cuando esté a cero.
Tenemos que generar dos funciones, una para el arranque y otra para la parada.
Seleccionamos como tipo Cycle-selective. El código de las funciones se encuentra abajo
indicado.

int Arrancar_Grafica()
{
if (GetTagBit("NewTag")==TRUE)
{
return(1);
}
else
{
return(0);
}
}
La función para parar el almacenamiento en el archivo es el siguiente:
Int Parar_Grafica()
{
if (GetTagBit("NewTag")==FALSE)
{
return(1);
}
else
{
return(0);
}
}
7.5.2 Presettings de variables de archivo
Todas estas propiedades que hemos definido para cada variable de archivo podemos
preconfigurarlas, para que cada vez que definamos una nueva variable no tengamos que
asignárselas de nuevo. Las posibles preconfiguraciones son:

• Process Archive.
• User archive.
• Compressed archive
• Analog tag: Preconfiguración de una variable analógica (mayor que un bit).:
• Binary tag: Preconfiguración de una variable digital (0 o 1).:
Con respecto a las variables digitales, destacar que se puede seleccionar que se
almacenen siempre, frente a un flanco positivo o uno negativo. Lógicamente aquí sólo
existe el ciclo de almacenamiento, ya que no se pueden hacer medias de valores, ni
sumas. Podemos as su vez asignar un texto a el estado 0 y otro al 1 (p. Ej 0=parado y
1=arrancado) para una mayor claridad en la gráfica.
Figura 173: Archivos de valores binarios.
• Compressed tag: Preconfiguración para los valores comprimidos dentro de archivos

comprimidos. Las características de los mismos difieren ligeramente de los archivos
normales (ver imagen inferior).

Figura 174: Variables de archivos comprimidos.

7.6 Curvas de valores
7.6.1 Introducción
Las tendencias de valores son utilizadas para mostrar la evolución de una variable de
proceso en el tiempo de manera gráfica. La limitación más importante es que el eje X siempre
obligatoriamente debe ser de tiempo, por lo que no podemos utilizar las curvas o tendencias
(trends) para realizar una gráfica en la que comparemos la presión con respecto a la humedad,
por ejemplo.
7.6.2 Propiedades de la ventana de tendencias
Dentro de una ventana de tendencias podemos tener una o más curvas, cada una con
un color identificativo, y que asociaremos a variables de archivo que formarán parte de un
archivo generado anteriormente, como ya vimos.

Las propiedades de general information son:

• Name of the trend: nombre descriptivo de la curva (p. Ej: presión zona 1).
• Display:
Display Trend: Muestra o no la curva o tendencia definida.
Share X axis: Si en la primera de las tendencias se selecciona esta casilla, todos los
ejes X de las tendencias serán comunes. Es decir todos los valores representados en
un punto del eje X fueron o están siendo generados en el mismo instante de tiempo. Si
no se selecciona, cada tendencia muestra su propio eje de tiempos, por lo que no se
tiene que producir necesariamente una correspondencia temporal entre dos curvas
mostradas en la pantalla a una misma altura del eje X.
Shared Y Axis: Ejecuta la misma acción que antes, pero para el eje Y. Esto es
interesante cuando los valores del proceso a mostrar no presentan una
correspondencia en unidades (una es presión y otra es temperatura), pero sí en
temporalidad (las dos variables es interesante mostrarlas a la vez en la misma pantalla
para compararlas en el tiempo).
Figura 175: Ventana sin share en X ni en Y.
Figura 176: Ventana con share en Y.

Figura 177: Ventana con share en X.
Figura 178: Ventana con share en X e Y.
Ruler visible while opening the picture: La opción regla visible al abrir la ventana nos
presenta en pantalla automáticamente una ventana auxiliar en la que se van visualizando los
valores instantáneos de las tendencias sobre las que se encuentra la regla que aparece en la
ventana de curvas. Esta regla la podemos desplazar para observar los valores de las curvas en
un determinado instante de tiempo.
Display trends staggered: Muestra las tendencias en gráficas separadas. Esta opción
es interesante en ciertas situaciones en las que los valores de dos o más tendencias van
parejos en el tiempo, por lo que se están solapando, y deseamos observarlos o plasmarlos de
manera individual.

Figura 179: Mostrar cada tendencia en una subventana.
Display trends vertically: Muestra la gráfica de manera vertical en lugar de horizontal,

como lo haría un registrador de líneas. Se puede elegir si los valores son añadidos a la gráfica
por arriba o por abajo.
Figura 180: Gráfica con tendencias verticales.
Color: podemos definir el color de la tendencia para poder identificarla con respecto a
las demás curvas.
Con respecto a la solapa tag, aquí se puede definir la variable de proceso con la cual
estamos conectados o almacenando dicho valor. Observar que en tiempo de ejecución
podemos desde esta ventana modificar dicha variable, con lo cual es posible realizar la
operación de cambiar de señal de proceso a representar sin modificar el desarrollo de

visualización, siempre y cuando se haya tenido la precaución de almacenar el valor reserva de

proceso en un archivo de valores.
Figura 181: Asignación de la variable de archivo a la tendencia de la gráfica.
En la solapa X Axis podemos definir todas las propiedades que tiene que ver con dicho
eje. Para que estas propiedades sean modificables deberemos encontrarnos en la primera de
las tendencias de nuestra ventana, si hubiera más de una.
• Label: etiqueta de texto que identifica el eje X (generalmente la unidad de tiempo).
• Update: Actualizar o no la ventana de curvas.
• Autorange: Realiza un escalado del eje x, mostrando los último n valores en dicho eje. El
número n es el valor que estipulemos nosotros en el apartado measured.
• Si no seleccionamos autorange, entonces se nos pide una fecha a partir de la cual se
quiere presentar los datos almacenados. Si no seleccionamos la casilla time period,
entonces tenemos que introducir una fecha final, y nos muestra todos los datos en ese
intervalo de tiempo.
• Si por el contrario seleccionamos la casilla time period, se nos pide el tamaño del periodo
de tiempo. Las opciones posibles son:
500 ms.
1 segundo.

1 minuto.
1 hora.
1 día.
Figura 182: Eje X de la gráfica.
Resumiendo, tenemos tres formas de presentar los datos:

• De la fecha x a la fecha y.
• Los últimos n valores
• Desde la fecha x, presentar un día o una hora, o un minuto.

Figura 183: Parámetros eje Y de la gráfica.
En la solapa Y definimos las propiedades de dicho eje.

• Label: Etiqueta de texto que identifica a este eje (p. Ej: presiones en mbar.)
• Display:
Coarse Grid: muestra una línea de división en el eje y cada x valores del eje. El valor
de x se puede introducir por el campo que aparece a la derecha de dicha opción.
Fine grid: muestra una línea de subdivisión al igual que la línea coarse, pero con la
diferencia de que esta es más estrecha, y no presenta número de escala.
Display grid lines: Muestra unas líneas de referencia en pantalla quye parten de las
líneas de división coarse. Estas líneas sirven como rejilla de referencia.
Precision: Cantidad de decimales que deben poseer los número de la escala Y. El
valor 0 indica sin decimales.
• Selection: Selección del rango del eje Y a mostrar en pantalla. Existen dos posibilidades:
Intervalo: Muestra un intervalo del eje Y, comenzando en Begin y acabando en End.
Esta opción es la interesante si se conoce cual va a ser el fondo de escala de nuestro
valor de proceso.
Autorange: Muestra un escalado cuyo fondo de escala está en función del valor
máximo a representar. Esta opción es interesante cuando los valores de proceso varía
de un valor muy bajo a uno muy alto, ya que si dejamos la escala en fondo de escala,

cuando estemos intentando representar sólo los valores de bajo rango nos aparecerá
una línea superpuesta al eje X, como si estuvieran todos a cero.
• Trend display: La unión de los puntos de la variable de archivo se puede realizar de varias
maneras en la pantalla:
Stepped trend: mediante escalones cuadrados que unen nuestros puntos.
Figura 184: Unión de valores de archivo mediante escalones.
Show only dots: une los puntos con líneas discontinuas.
Figura 185: Unión de valores de archivo mediante líneas punteadas.

Connect dots linearly: Conecta los puntos mediante líneas.
Figura 186: Unión de los valores mediante líneas.
Fill area interpolated trend: muestra los puntos como un área que rellena del color de
la tendencia. Este tipo impide que otras tendencias se puedan apreciar. En la figura se observa
como la tendencia 2 queda oculta tras la tendencia 1 debido a que ésta última se presenta bajo
el tipo área rellena. Sólo es aconsejable este tipo para una sola curva, o cuando la curva a la
que se le aplica este estilo ocupa la última posición.
Figura 187: Rellenado de áreas.

Fill area stepped trend: Igual que el anterior pero la unión se realiza mediante
cuadrados y no de manera lineal.
Figura 188: Rellenado de cuadrados.
Propiedades de color y límites: en esta ventana podemos definir el color que debe
adoptar la tendencia cuando baje o sobrepase unos límites que nosotros estipulemos.
Figura 189: Colores de límites en gráfica.

• Límite inferior: Cuando el valor de la tendencia baje de 30, el color de la misma cambiará
a rojo.
• Límite superior: Cuando el valor de la curva sobrepase 900 cambiará a amarillo.
El ejemplo de abajo muestra esto mismo, con límite inferior de 200 y superior de 800.
Figura 190: Ejemplo de cambio de color en límites.
• Overlamp: cambio de color de la curva cuando se produce un solapamiento de tiempos (se

vuelve a repetir el mismo tiempo en el Sistema que ya hubo.
• Jump: Salto del tiempo del sistema. Se ha realizado un salto temporal, adelantando el
tiempo del sistema.
• Remplacement Values: Cuando uno de los límites que se ha marcado como máximo o
mínimo para la adquisición de datos por parte del archivo se activa, los valores
substitutivos, que no provienen del proceso propiamente quedan marcados con otro color.

7.6.3 Adición y borrado de curvas
En la ventana choose object podemos añadir y restar las curvas que van a componer
nuestra ventana de tendencias. A su vez podemos seleccionándolas editar mediante el botón
Template las características de la ventana. Estas son:
Figura 191: Propiedades de la ventana

de curvas.
• Name of the template: Nombre identificativo de la ventana de curvas.

• Title bar: Muestra sobre la ventana un título con el nombre de la ventana.

• Status bar: Barra de estado en la que se indica el proceso que está teniendo lugar
actualmente.
• Toolbar: Barra de herramientas con opciones accesibles desde botones ya
preconfigurados.
• Read data from archive inmediately: Leer los datos del archivo al entrar en la ventana.
Cuando existe en el archivo una gran cantidad de datos, puede ser interesante desactivar
esta opción y que no pierda tiempo leyéndolos. Unicamente cuando rebobinemos marcha
atrás en el histórico, leerá los datos del disco duro.
• Font: Fuente de los textos de la escala.
• Color: Color del fondo de la gráfica.
7.6.4 Barra de herramientas
Mediante la opción configure podemos configurar la barra de herramientas que nos

aparece en la ventana de curvas.
Figura 192: Barra de herramientas gráfica de curvas.
Las opciones posibles son:

Online help system: ayuda en pantalla sobre las opciones más importantes para
poder configurar la ventana de curvas.

Set parameters: Esta ventana posibilita que un usuario de WinCC parametrice sus
ventana de curvas a su gusto, después de haber configurado el programador la
instalación. Las modificaciones que se realicen, pueden ser de tres tipos:
• Volátiles, que se pierden en cuanto se sale de la ventana actual. Esta situación se
produce si en la ventana Persistence no se selecciona nada.
• Persistentes en el runtime: seleccionando esta opción las modificaciones que

realice el usuario se mantendrán siempre que no desactive el WinCC. Cuando
desactive la runtime del WinCC, o apague el ordenador y lo encienda de nuevo,
restablecerá la configuración original.
• Persistentes en el Runtime y el CS: seleccionando esta opción las
modificaciones que realice el usuario serán permanentes.
Primer dato: si la gráfica está detenida, se desplaza al primer elemento del archivo.
Dato anterior: muestra el dato anterior del archivo, hasta llegar al primero.
Dato siguiente: muestra el dato siguiente del archivo hasta llegar al último.
Ultimo dato: se posiciona en el último dato del archivo.
Regla: muestra la regla de referencia y la ventana de valores.
Lupa: realiza una ampliación de una zona que determinemos de la gráfica.
Restablecer tamaño: restablece el tamaño de la gráfica después de haber hecho un

zoom.
Modificación de la variable de archivo seleccionada: mediante esta opción

podemos modificar en el runtime la variable de archivo que asignamos a una
determinada curva. La ventana de diálogo es la siguiente:

Figura 193: Asignación de variable de archivo a curva.
Mostrar curvas: mediante esta opción podemos seleccionar que curvas deseamos
observar en la ventana La ventana de diálogo aparece abajo indicada..
Figura 194: Visualización de curvas.

Seleccionar el rango de tiempos: con esta opción se puede seleccionar el rango de

tiempos para cada una de las curvas de la ventana.
Figura 195: Selección de tiempos gráfica.
Curva previa al frente: esta opción trae la curva que tengamos en segundo plano al
primero y viceversa.
Deshacer Curva previa al frente: Esta opción deshace la acción anterior.
Start/Stop: arranque/parada de la actualización de los datos en la ventana. Destacar

que la parada no significa que se deje de guardar los valores en la base de datos.
Estos continúan siendo almacenados de igual manera.

7.7 Tablas de valores
7.7.1 introducción
Las tablas de valores permiten representar los datos de los archivos en forma de
tablas, para poder comparar los valores numéricos, además de poder editar dichos valores
directamente desde las mismas, lo que posibilita la modificación de los datos de proceso con
posterioridad al desarrollo de los mismos.
7.7.2 Crear una tabla de valores
Desde table window template del Tag logging podemos crear una tabla de valores.
Dicha tabla podrá contener una o más columnas, cada una de ellas asociada a un valor de un
archivo que hayamos previamente generado.
Figura 196: Tabla de valores.

Propiedades General Information:

• Column heading: Título de la columna que estamos editando
• Display:
Hide column: oculta la columna actual en la tabla de datos.
Column can be edited: La columna puede ser editada, es decir, se permite modificar
los datos de esta columna en el archivo de proceso.
Share column: Compartir una misma base de tiempos. Los datos de las columnas
pueden haber sido adquiridos en un mismo instante de tiempo o no. Mediante esta
opción se separan o comparten los tiempos de las columnas que componen la tabla.
Figura 197: Ejemplo de tablas sin share activado.
Figura 198:Ejemplo de tablas con

share activado.

• Selection: disponemos de dos formas de visualizar los datos del archivo:

A partir de una fecha cada x tiempo actualizándose o
Desde una fecha hasta una fecha, mostrar ese intervalo de tiempo.
Figura 199: Asignación de variable de archivo a columna de tabla.
En la solapa tag podemos definir la variable de archivo asociada a cada columna.

En la opción Operator authorization podemos definir que niveles de autorización son
requeridos para leer los datos y para modificarlos. Esto es especialmente importante, ya que
desde las tablas podemos modificar la base de datos, y solo personal autorizado debería
acceder a estas tablas con nivel suficiente como para modificarlas.
Con respecto a la barra de herramientas, sus posibilidades y parametrización son

similares a las de las curvas, salvo por las siguientes nuevas opciones:
Editar una columna: Presionando este botón y seleccionando una celda de una
columna, si dicha columna tiene activada la opción Can be edited, será posible
modificarla.
Enviar la columna previa a la primera posición.
Invierte la acción del anterior icono.

Nivel de password: permite introducir un nivel de password.
Insertar fila: en los archivos de usuario, es posible insertar una fila.
Borrar fila: en los archivos de usuario, es posible borrar una fila.

Manual WinCC V4.02 Text Library

TEXT LIBRARY


8 Text Library
8.1 Introducción
Text Library es la parte el WinCC que se encarga de gestionar los mensajes de textos.
Cuando necesitamos realizar una aplicación que deba cambiar sus textos según el idioma
seleccionado, necesariamente deberemos realizar una asignación de dichos textos en un
idioma u otro.
Mediante text library se consigue enlazar a través de un número identificativo cadenas
de texto de diferentes idiomas. Dicho número se asigna automáticamente a los controles que
utilizamos en el Graphic Designer. De esta manera, cuando dentro del WinCC en modo runtime
cambiamos de código de idioma, automáticamente sustituye los textos asignados a un número
en un idioma por el correspondiente.
Figura 200: Ventana de text library.

8.2 Idiomas
8.2.1 ¿Cómo crear un nuevo idioma?
Lo primero que necesitamos en el Text Library es generar un nuevo idioma, ya que por
defecto solo nos genera la columna en Inglés. Evidentemente, el hecho de que el idioma sea el
Inglés no implica que podemos poner los textos en castellano, y no tener que cambiar de
página de idioma.
Sin embargo, si deseamos disponer de dos idiomas, lo correcto sería generar nuestros
mensajes en el idioma correspondiente (español o los diferentes dialectos, si así
correspondiera en la provincia).
Vamos a generar dos nuevos idiomas, Español y Catalán. Para ello, en el menú
Options->Add language podemos añadir los idiomas que soporta el WinCC.
Figura 201: Idiomas del text library.
Nos parecen dos nuevas columnas, cada una con el idioma correspondiente. Ahora,
debemos de rellenar todos los mensajes que aparecen en la columna inglés, traduciéndolos
nosotros mismos al idioma correspondiente.
8.2.2 ¿Cómo borrar un idioma?
Para borrar un idioma, en el menú Options->Delete language podemos deshacernos

de un idioma no deseado. Hay que tener en cuenta que se pierden todos los mensajes
configurados bajo ese idioma de manera irrevocable.

Figura 202: Idiomas instalados en la runtime.
8.2.3 ¿Cómo cambiar de idioma desde el Graphic Designer?
En el menú View->Language podemos seleccionar el código de idioma activo

actualmente para los objetos de nuestra picture. Podemos escribir los textos modificando su
propiedad de texto objeto a objeto, aunque es más cómodo insertar todos los objetos en un
determinado idioma, y una vez finalizada la picture, ir al Text Library, rellenando allí la columna
correspondiente al nuevo idioma. Si posteriormente aparece un nuevo objeto, se puede utilizar
el método visto en este punto para configurarle los dos idiomas, sin necesidad de recurrir esta
vez al text library.
8.2.4 ¿Cómo cambiar de idioma desde el runtime?
Vamos a realizar un ejemplo de cómo cambiar de idioma el texto de un botón desde el

runtime.
Figura 203: Ejemplo de cambio de

idioma en inglés.

El botón de la figura está configurado en inglés, español y valenciano. Para modificar el

idioma actual del runtime disponemos de tres botones, que a su vez cambiarán también su
lenguaje según estemos en un idioma u otro.

idioma en Español.

idioma en Valenciano.
El código asociado a los botones de cambio de idioma es:

• Inglés: SetLanguage(0x0409);
• Español: SetLanguage(0x040A);
• Catalán: SetLanguage(0x0403);
Para otros idiomas, se puede utilizar el Dinamic Wizard de cambio de idioma.

Manual WinCC V4.02 User Administrator
U SE R
ADMINISTRATOR


9 User Administrator
9.1.1 Introducción
El apartado de WinCC denominado User Administrator se encarga de la administración

de los usuarios que van a trabajar en el runtime del sistema WinCC.
La principal diferencia que hay que observar en la filosofía de usuarios del WinCC con
respecto al típico control de privilegios por niveles es que en el WinCC el disponer de privilegio
o nivel para realizar algo que los demás no estén autorizados no implica que se permita
acceder a todo lo que los demás usuarios son capaces de realizar.
Figura 206. Ventana de user administrator.
En los sistemas de privilegios por nivel, si un usuario dispone de nivel 3, podrá realizar
todo lo que pueden realizar los de nivel 2, más aquello que se permite solo a los de nivel 3.
Cuando se bloquea una acción para nivel de password 3, significa que todos los que dispongan
de nivel igual o superior a 3 podrán realizarla.
En WinCC esto no es así, definiéndose en lugar de niveles, capacidades de realizar
cosas (cambiar valores en archivos, entrar a determinadas pantallas, resetear alarmas, etc..).
Dichas capacidades pueden ser o no compartidas por usuarios. Estos usuarios se

pueden agrupar en grupos, sólo para una más fácil identificación, ya que no es imprescindible
que compartan las mismas capacidades dos usuarios de un mismo grupo.
9.1.2 ¿Cómo crear un nuevo grupo de usuarios?
Vamos a crear un grupo de usuarios que se llame operadores. Para ello, presionando
sobre el grupo de administración el botón derecho, seleccionaremos add group. Introducimos
el nombre del grupo y presionando de nuevo sobre el grupo creado, le añadimos dos usuarios.
Figura 207: Crear nuevo usuario.
La caja de diálogo que configura un nuevo usuario nos pide:

• Login: Nombre identificativo del usuario en cuestión (sólo puede ser una palabra, p. Ej.
Juan_Perez).
• Password: Cadena de texto de un mínimo de 6 caracteres, que puede incluir espacios y
números y letras indistintamente.
• Verify password: La misma cadena del password debemos de repetirla para confirmar que
no hemos introducido ninguna letra por equivocación.
• Copy group settings also: Se puede preestablecer una configuración para todos los
nuevos usuarios que se generen dentro de un grupo. Con esta casilla se activa el hecho de
que un nuevo usuario copia las características predefinidas de su grupo.

9.1.3 ¿Cómo asignar una capacidad a un nuevo usuario?
Las capacidades que dispone un usuario aparecen con un piloto rojo indicativo
seleccionadas.
Para añadir una capacidad a un usuario, simplemente hay que hacer doble click en el
lugar donde debe aparecer el piloto rojo de la capacidad.
Para deshacer dicha operación es necesario realizar de nuevo doble click en el mismo
lugar.
9.1.4 ¿Cómo crear una nueva capacidad?
Lógicamente, lo primero que debemos realizar, será estudiar los diferentes bloqueos o
límites que requerimos en nuestro desarrollo para posteriormente asignárselos a los usuarios
creados.
Un bloqueo es una acción cuya capacidad de realización diferencia a unos usuarios de
otros. Normalmente se suele bloquear el acceso a determinadas pantallas, la impresión de
determinadas gráficas, la activación de determinados elementos de campo (p. Ej. pasarlos a
manual y que no realicen su actividad en automático) y sobretodo la modificación de los valores
de proceso, ya sea en producción (bloqueo de cajas), como a de manera posterior
(modificación de archivos de proceso).
Para crear un nuevo bloqueo o límite que permita definir una capacidad a un usuario,
debemos seleccionar en el menú Table-> Add New Authorization Level.
Nos indica un número de nivel de autorización, que debemos aceptar como bueno, ya
que no podemos duplicar dicho número indicado. Esta acción nos lleva a disponer de una línea
nueva con el número de orden indicado, pero que no dispone de ningún texto descriptivo, por lo
que será de difícil asignación dicho nivel si posteriormente olvidamos a que correspondía este
bloqueo.
Para añadir un texto descriptivo debemos realizar doble click en la casilla del texto, e
introducir un comentario que nos resulte intuitivo para el bloqueo que realiza dicho nivel. La
asignación del privilegio del bloqueo a los usuarios se realiza como vimos anteriormente.
9.1.5 ¿Cómo borrar una nueva capacidad?
Para borrar una capacidad o bloqueo ya existente simplemente seleccione primeramente el

nivel de bloqueo que desea borrar realizando un click sobre él. Seleccione del menú Table-
>Delete Authorization Level, y confirme el borrado del mismo.
Los niveles de autorización son comunes para todos los usuarios y grupos, por lo que
el borrar un nivel en un grupo lo borra de los demás.

9.1.6 ¿Cómo cambiar el password de un usuario?
Si un determinado usuario desea cambiar el password que ya dispone, no es necesario

borrarlo y volver a generarlo. Presionando el botón derecho sobre el usuario, y seleccionando
del menú Change password podemos cambiar su password, siempre uy cuando
conociésemos de antemano el password a cambiar.
Figura 208: Cambio de password.
Si no conocemos su password, deberemos necesariamente darlo de baja.
9.1.7 ¿Cómo cambiar el login de un usuario?
Para cambiar el login o nombre identificativo solo es necesario realizar un solo click
sobre dicho nombre y se podrá curiosamente cambiar, sin necesidad de ningún tipo de clave,
por lo que un superusuario puede modificarlo a su entera voluntad sin ninguna autorización por
parte de los mismos usuarios.
9.1.8 Desactivación automática de un usuario
Una vez se ha activado un usuario, el sistema dispone de los privilegios derivados del
nivel de dicho usuario. Hasta que dicho usuario no se da de baja en el sistema, los privilegios
continúan activos, por lo que si un usuario deja el sistema activado con su login, un par de
horas después puede utilizar el sistema WinCC cualquier usuario sin necesidad de darse de
alta en el mismo y utilizando todos los accesos habilitados en función del nivel del anterior
usuario aún en activo.
Como el olvido de dejar activado el password es muy frecuente con el tiempo, resulta
inservible un sistema de passwords que siempre se encuentra habilitado. Para evitar este
punto, todo usuario dispone de una casilla de desconexión automática en base de minutos.

Figura 209: Tiempo para

logout automático.
Si la casilla es distinta de cero, pasados dichos minutos automáticamente el sistema

desconecta al usuario, por lo que si quiere utilizar de nuevo el sistema WinCC con sus
privilegios deberá de volver a darse de alta en el mismo.
9.1.9 ¿Cómo asignar un nivel de password a una acción?
Las acciones a realizar que requieren un password determinado siempre van asociadas a un
objeto. Todos los objetos disponen de una propiedad en miscelaneous que se llama User
Level. Si realizamos doble click sobre ella, nos aparece una ventana en la que se muestran los
diferentes niveles generados anteriormente con el user administrator. Podemos seleccionar
uno, en cuyo caso todos los usuarios que deseen realizar las acciones asociadas a dicho
objeto, deberán disponer previamente del nivel requerido.
Figura 210: Niveles de password.

Manual WinCC V4.02 Global Script

GLOBAL SCRIPT


10 Global Script
10.1 Introducción
El global script es un compilador de C incorporado con el WinCC, que nos permite
realizar compilaciones de código objeto (con un formato un tanto especial, ya que no lo deja en
obj) sin necesidad de salir del propio entorno.
Este código generado puede ser añadido directamente al propio runtime y generarse
cada cierto tiempo, o posteriormente asociarse a un evento de un objeto. Si desde el editor del
Graphic Designer seleccionamos realizar una acción en C, automáticamente se nos activa el
global script para permitirnos editar dicha acción en el compilador de C.
10.2 Tipos de funciones en Global Scripts

Dentro del compilador de Global Scripts podemos observar que existen cuatro tipos de
clases o categorías de funciones:
• Project functions: funciones de proyecto. Son aquellas funciones que deben ser
llamadas desde otras partes del programa para devolver valores después de realizar
alguna operación en C. Anteriormente vimos como arrancábamos una gráfica y la
parábamos con dos funciones de proyecto. Las funciones de proyecto quedan
almacenadas automáticamente en el subdirectorio Library de nuestro proyecto, con
la extensión fct. Para traerse una función de proyecto de un proyecto a otro

deberemos de copiar dicho archivo en dicho subdirectorio del proyecto fuente al

destino.
• Standard Functions: Son las funciones standard del propio WinCC, que no residen
en nuestro proyecto, sino en el subdirectorio aplib de WinCC. Estas funciones
estándar se pueden modificar, pero dicha modificación es permanente hasta que no
se reinstale el WinCC, ya que como se dijo los archivos fct de standard functions son
comunes para todos nuestros proyectos. Si deseamos generar subrutinas que sean
utilizadas por todos los proyectos en que trabajemos, solo tenemos que copiarlas en
el subdirectorio aplib. Cuando volvamos al global script no nos aparece en el árbol la
función hasta que no seleccionamos en el menú Options-> Regenerate Header.
• Internal Functions: Funciones que realizan acciones predeterminadas, como son
proporcionar un valor de una variable, o asignar un valor a una variable. Estas
funciones son por supuesto comunes, y no pueden ser modificadas.
• Actions: Una acción es una subrutina que no se ejecuta cuando sea llamada por un
evento, sino cuando un trigger o disparo, ya sea por tiempo o por cambio de variable
ocurra. Las actions no se pueden cambiar de nombre (siempre se llaman
gscaction), y generan un fichero de extensión pas que se guarda en el subdirectorio
pas, ya sea del ordenador en cuestión (monopuesto) o de manera global para todos
los ordenadores (multipuesto). El fichero pas por defecto se llama gsccs1.pas, pero
se puede renombrar a posteriori.
10.2.1 Project Functions
Vamos a realizar una función de proyecto, que mediante código C nos suma dos
valores enteros y nos devuelve el resultado. El código es el siguiente:
int Suma_Dos_Valores(int Valor_1, int Valor_2)
int Temporal;
Temporal=Valor_1+Valor_2;
return(Temporal);

A continuación asociaremos en el evento action mouse de un botón el código

siguiente, el cual realiza la llamada a la Project Function generada por nosotros, tomando dos
parámetros de entrada y devolviendo un resultado.
#include "apdefap.h"
void OnClick(char* lpszPictureName, char* lpszObjectName, char* lpszPropertyName)
int Temporal;
int temp1,temp2;
temp1=GetTagSWord("CANTIDAD_1"); //Return-Type :short int
temp2=GetTagSWord("CANTIDAD_2"); //Return-Type :short int
Temporal=Suma_Dos_Valores(temp1,temp2); //Return-Type :long int
SetTagSWord("VAR_1",Temporal); //Return-Type :BOOL
Cualquier Project function que definamos en nuestro proyecto se almacenará en un

fichero de extensión fct en el subdirectorio Library de nuestro proyecto. Esto es interesante a la
hora de reutilizar funciones ya generadas anteriormente.
Para utilizar una función generada en otro proyecto, sólo tendremos que copiar el
fichero fct en el subdirectorio indicado, y posteriormente desde el global script seleccionar en el
menú Options->Regenerate Header, que nos actualiza el árbol de funciones de la ventana del
global script.
Resumiendo, las funciones de proyecto son las típicas subrutinas de cualquier lenguaje
de programación, dentro de las cuales podemos programar en C y utilizar las funciones
incorporadas en el propio WinCC. Este código se almacena en un fichero de texto de extensión
fct y puede ser llamada la función desde un evento de un objeto, o desde una acción.

10.2.2 Standard Functions
Las funciones standard son funciones de proyecto (subrutinas de programación en C)

también de extensión fct, pero con la particularidad de que vienen generadas por el propio
sistema, y no se encuentran en nuestro proyecto, sino en el subdirectorio aplib de WinCC.
La estructura del árbol que cuelga de standard function se basa en los subdirectorios
que cuelgan del directorio aplib, pudiendo nosotros modificarlo a nuestro gusto, e incluir project
functions que sean accesibles a todos los proyectos.
Es decir, por un lado podemos acceder al código de las funciones por defecto o
standard simplemente realizando click sobre ellas, modificándolas o borrándolas si no nos
interesan (la modificación será para todos los proyectos, ya que son funciones comunes a los
mismos).
Por otro lado, podemos incluir en un directorio nuestro archivo fct y será accesible a
todos los proyectos a partir de ese momento. Se debe recordar que para que se actualice el
árbol del global script hay que realizar la acción compile header, como se vio anteriormente.
Resumiendo, una función standard es como una función de proyecto, con la diferencia
de que es accesible a todos los proyectos, ya que existe en un subdirectorio fuera del propio
del proyecto actual.
10.2.3 Internal functions
Las funciones internas son las básicas con las que se puede trabajar a la hora de
realizar funciones o acciones en C. Son propiamente las instrucciones de programación de que
dispone el WinCC para poder realizar las subrutinas por código.
Dichas funciones también son comunes y se encuentran en el subdirectorio aplib, pero
se diferencian de las anteriores en la extensión, que en este caso es icf.
Además, no pueden ser editadas las funciones internas, y por lo tanto no se pueden
modificar por parte del usuario.
10.2.4 Actions
Las actions son funciones que son llamadas o disparadas generalmente de manera
independiente a los objetos de las pictures. Se utilizan para realizar disparos de acciones por
tiempo (cada 10 segundos hacer x), para realizar acciones frente a cambios de variables
(cuando cambie la variable x o la y, realizar su suma), y para ser llamadas cuando acontecen
ciertos eventos (cuando finalice la gráfica, cuando el valor ha sido superado, etc..).

Existen dos tipos de acciones, las comunes a todos los ordenadores de nuestro
proyecto, que se agrupan bajo el epígrafe de Global Actions, y las que pertenecen
exclusivamente a nuestro ordenador, que se agrupan bajo el nombre dado a nuestra estación.
En sistemas monopuesto la diferencia es inexistente, dando igual en qué apartado se
genere la acción para luego poder ser llamada.
Una acción se almacena siempre en un fichero de extensión pas, que suele guardarse
en el subdirectorio pas de nuestro proyecto. Si la generamos como acción local (de nuestra
estación), se almacenará en el pas que cuelga del subdirectorio generado con el nombre de
nuestra estación. Si por el contrario la generamos global, se almacena en el subdirectorio pas
de nuestro proyecto.
Una acción no es una función, por lo que no podemos:
• Ni definir el valor de retorno (siempre será un int). Por lo tanto, deberemos terminar con un
return que indique si ha finalizado adecuadamente la acción.
• Ni cambiarle el nombre, que por defecto es gscAction.
• Ni pasarle parámetros de entrada, ya que siempre es de tipo void.
Por lo tanto, el nombre por el que luego la identificaremos no será el de la acción (que es
gcsAction), sino el del archivo en el que la almacenamos, que finaliza en extensión pas.
10.3 Disparo de acciones
Figura 211: Información de la acción.

El disparo de acciones se realiza seleccionando la acción y en el menú Edit->Info.

En la solapa info podemos indicar:
• Quién y cuando realizó la acción (la programó o la modificó).
• Podemos proteger nuestra acción para que solo nosotros podamos visualizar su contenido.
Esto permite proteger el know-how del desarrollador y poder ser utilizada por el usuario.
• Podemos indicar un número de versión y un comentario.
Figura 212: Disparo de acciones.
Curiosamente, si no se aprieta el botón de aplicar antes de salir, aunque se acepte, las

modificaciones realizadas se pierden. Atención con este error de programación que puede
hacer perder el trabajo introducido.
En la solapa trigger definimos el disparo de la acción, disponiendo de tres tipos
posibles de disparo (que no son excluyentes los unos de los otros):
• Acíclico: El disparo de la acción se realiza sólo una vez un día y a una hora determinada.
Pulsando sobre Add podemos definir la fecha y hora, así como el nombre del disparo.

Figura 213: Disparo acíclico.
• Cíclico: La acción se realizará cada x tiempo de manera automática en el PC a partir de

que arranque la runtime y hasta que pare.
Figura 214: Disparo cíclico de acciones.

En event podemos seleccionar por ciclo standard, con lo cual podemos asignar la
llamada a un ciclo de usuario personalizado, o por hora, día, semana, mes o año. En este
segundo caso, nos permite indicar a partir e que fecha u hora debe empezar a realizar dicha
acción.
Figura 215: Disparo cíclico prefijado.
• Tag: Podemos disparar una acción cuando alguna o varias variables cambien de valor.
Figura 216: Disparo por cambio de variable.

10.3.1 Compilación de funciones externas a través de DLL’s.
Si deseamos utilizar funciones ya realizadas por nosotros en alguna de nuestras

subrutinas desde WinCC, deberemos primeramente compilarlas en formato DLL desde nuestro
compilador original (Visual C, Visual Basic, Delphi).
Una vez dispongamos de dichas funciones a utilizar dentro de una DLL de 32 bits
compilada, deberemos de declarar las funciones en nuestro código C de WinCC para poderlas
utilizar.
Al principio de la subrutina donde vayamos a realizar la llamada a la función externa,
deberemos de escribir la siguiente declaración:
#pragma code(“NOMBRE_DE_LA_DLL.DLL”)
#include “NOMBRE_DE_LA_CABECERA.h”
#pragma code()
Esta declaración indica al precompilador de C que añada a su biblioteca de funciones

las incluidas en NOMBRE_DE_CABECERA.h, que se encuentran en
NOMBRE_DE_LA_DLL.DLL.
10.3.2 Definición de variables globales y variables locales
Una variable local es toda aquella cuyo ámbito de acción se circunscribe a la subrutina
en que es definida, mientras que una variable global es accesible desde cualquier subrutina
generada en WinCC.
En numerosas ocasiones se utilizan en WinCC variables internas para realizar tareas
que con variables globales quedan fácilmente solventadas.
Para definir una variable local, simplemente hay que declararla dentro de una función o
evento. Sin embargo para definir una variable global:
• si estamos declarándola en una acción de C, se debe declarar antes de la
declaración de la función:
int variable=0;
void subrutina()
{
• si estamos declarándola en una propiedad o evento, deberemos de antecederla de
la instrucción extern:
void OnProertyChange(…)
{
extern int variable;
a=0;

Nota: Si declaramos una variable externa sobre una función standard, esta
función existirá en todos los proyectos que generemos.

Manual WinCC V4.02 Report Designer

REPORT DESIGNER


11 REPORT DESIGNER
11.1 Introducción
El módulo report designer se encarga de todas las tareas relacionadas con la impresión
de datos y documentos desde WinCC a una impresora o a un archivo de texto. Un report es un
documento diseñado previamente que posee una serie de campos, en el momento de enviarse
el documento a impresora o fichero, toman el valor de los datos con los que están relacionados
en la propia base del WinCC.
La finalidad lógica de dicho reports a impresora es permitir al usuario tener constancia
en papel de un resumen organizado de los valores del proceso, alarmas, o estado de la
instalación en un momento determinado.
11.2 Partes del report designer
Dentro del apartado report designer existen tres subdivisiones, cada una con una
finalidad distinta.

• Layout: Un layout es el propio documento que queremos imprimir. En layout podemos

generar dicho documento, diseñarlo como deseemos y asociar los campos a la base de
datos.
• Line printer layout: a veces no deseamos enviar todo un informe a la impresora, sino más
bien ir imprimiendo un determinado estado en tiempo real (cada vez que se imprima una
alarma, sacarla por impresora). En este caso, en lugar de enviar un layout, deberemos
configurar un line printer layout, que se encarga de configurar el diseño de la línea que
debe de salir por la impresora.
• Print Job: Un layout como tal no puede imprimirse, sólo ser asignado a un job o tarea, que
reúne los datos del layout o documento a imprimir, la impresora por la que deseamos
realizarlo, y cada cuanto tiempo queremos hacerlo. Es por tanto el job el verdadero report,
pero previamente debe necesariamente haberse generado un layout o un line printer layout
para poder ejecutarse.

11.3 Layout
11.3.1 Características generales
El WinCC, en el momento de generar el proyecto por primera vez, copia en el

subdirectorio prt una serie de layouts de sistema. Estos layouts pueden ser modificados por el
usuario, pero no deben ser borrados, ya que el WinCC los utiliza a la hora de imprimir la
documentación en sus diversas partes de desarrollo (curiosamente el nombre puede cambiarse
sin problemas, el sistema lo identifica internamente y no por el nombre del layout).
Figura 217: Ventana del report designer.

Todos los layouts poseen la extensión rpl y se encuentran en el subdirectorio prt de

nuestro proyecto, por lo que pasar layouts de un proyecto a otro es copiar dicho fichero.
El editor de layouts tiene el aspecto que muestra la figura. Si generamos un nuevo
layout, podemos observar que nuestro documento se divide en dos partes, una de color gris y
otra central de blanco. La parte gris corresponde a la cabecera y pie de página del documento,
que puede contener campos de la base de datos, pero que será común a todas las hojas que
compongan el layout. La parte central será donde se almacenen los datos del report.
11.3.2 Propiedades del layout
Si presionamos con el botón derecho sobre el layout, podemos ver sus propiedades.
Repasemos las más importantes:
Layout:
• Name: nombre del objeto layout.
• Context: a que contexto debe relacionarse este layout. Desde el graphic designer existen
asignaciones a layouts de sistema a la hora de imprimir determinadas acciones (p. Ej., el
botón de impresión de alarmas desde la ventana de alarmas está asignado a un contexto.)
Figura 218: Propiedades del layout.
Geometry:
• Width: ancho de la página.
• Height: alto de la página.
• Paper size: formato de tamaño del papel en que se imprime el layout (carta, A4,etc..)
• Orientación: Vertical o apaisado.

• Left print margin: margen izquierdo a partir del que se empieza a imprimir.
• Top dinamic margin: margen entre la parte superior de la página y el comienzo de la parte
dinámica del documento. Estas distancias determinan la anchura de la parte gris del layout
(cabecera y pie de página).
Figura 219: Geometría del layout.
Miscelaneous:
• Cover sheet: Todo layout puede tener una página inicial, en la que se puede introducir los
textos informativos al respecto del tipo de layout, la instalación en la que se genera,
etc…Aquí se determina si esta página inicial debe de aparecer o no en el documento final.
• Final page: lo mismo, pero con una página de finalización de documento.

11.3.3 Barra de herramientas del layout
La barra de herramientas, además de varias funciones ya comentadas anteriormente,

posee una serie de botones específicos, que son:
Visualizar parte estática del documento. Solo puede modificar la parte cabecera y
pierde del documento.
Visualizar parte dinámica del documento. Solo se puede modificar la parte central, no la
cabecera ni el pie de página.
Visualizar portada del documento.
Visualiza parte central del documento.
Visualiza contraportada del documento.
11.3.4 Objetos del layout
Como en el graphic designer, lo más importante del layout serán los objetos que
insertemos en el mismo. Disponemos de una ventana en el que se nos muestran los mismos
por categorías.

Objetos estáticos: su valor es el mismo independientemente del momento en que se

imprima el layout (p. Ej. El nombre de nuestra empresa, la persona que lo diseña, la
instalación, etc…).
Objetos dinámicos: su valor está en función del momento en que se imprima el

documento, ya que es entonces cuando toman el valor de la base de datos.
• Dynamic metafile: realiza una impresión gráfica o de una determinada pantalla que
hayamos diseñado con el graphic designer, o de una gráfica.
Los objetos dinámicos requieren una conexión, que es el vínculo con el sistema que
determina que valores del mismo deben plasmarse en el objeto a la hora de la impresión. En
este caso, si queremos imprimir:
• las pictures de WinCC: deberemos seleccionar General Display de picture. Nos
mostrará todas las imágenes diseñadas, con el tamaño que le demos a dicho objeto.

• Una gráfica: deberemos seleccionar Variable-Curve.
Figura 220: Reports de gráficas.
Las propiedades de la curva a mostrar que podemos parametrizar son:

• Time selection: rango de tiempo que debe aparecer en la gráfica.
Figura 221: Intervalo de gráfica a imprimir.

• Archive data selection: archivo del que hay que sacar los datos y tendencias a mostrar en
la gráfica.
Figura 222: Datos a representar en el report de la gráfica.
• Format: fuente de los textos que componen la gráfica.
Figura 223: Fuente del report de la gráfica.
Dynamic Table: tabla de datos cuyas celdas se rellenan de los datos indicados
mediante connect. Se utiliza para mostrar todo tipo de datos numéricos y de texto, en oposición
a la anterior que mostraba dibujos y gráficas. Las posibilidades dentro de connect son muy
amplias, por lo que ejemplificaremos creando una lista de valores de proceso en impresora.

Figura 224: Report de tabla de datos.
Dentro de tag logging runtime, tag table se encarga de mostrar una tabla con los
valores de variables de proceso durante un periodo de tiempo determinado. Asignamos esta
conexión a la tabla creada.
Figura 225: Selección de valores del archivo para report de tabla.
En las propiedades de la conexión podemos determinar la selección de los datos a

mostrar en la tabla, seleccionando el archivo origen de dichos datos.

De esta manera se pueden realizar tablas de datos por impresora, listados de alarmas,
y en general cualquier representación de datos durante el tiempo o listas almacenadas en la
base de datos, ya sea del desarrollo CS o de runtime RT.
Continuando con los objetos que podemos utilizar tenemos:

• Dynamic text: Si disponemos un texto que puede cambiar de manera dinámica en
cualquier picture mediante este objeto podemos imprimir el valor actual en un report.
• Embedded layout: mostrar otro layout ya configurado dentro de una ventana.
• Tag: Mostrar el valor de un tag dentro de una celda. Se puede aplicar desde las
propiedades el formato deseado y el tipo de representación (decimal, texto, hexadecimal,
etc…). Este objeto es el ideal para realizar reports a impresora de un grupo de valores de
proceso en un instante determinado.
System Objects: Son campos que rellenará el WinCC de su propio sistema, no de la

base de datos del proyecto. Estos objetos sólo pueden introducirse en la parte estática del
documento, no en la dinámica.
• Date/Time: Permite introducir la fecha y la hora dentro de un report.
• Page Number: número de página.
• Project name: nombre del proyecto.
• Layout name: nombre del layout que se está imprimiendo.

11.4 Line printer layout
La impresión por líneas se utiliza para mostrar generalmente las alarmas o eventos de la
instalación en tiempo real por impresora.
Figura 226: Ventana de line printer layout.
Podemos definir la cantidad de líneas que queremos que ocupe una hoja, los
márgenes, y los textos de cabecera y pie de página. Todas estas opciones evidentemente
están ideadas para una impresora matricial que solo utilizaremos para caracteres de texto.
Definidos estos parámetros, no queda determinar el formato del mensaje que vamos a
sacar en la línea de layout. Para ello, si seleccionamos el botón Selection de esta ventana,
podemos acceder a los bloques que hayamos creado en la parte de Alarm logging. Mediante
estos bloques confeccionamos nuestra línea.
Los archivos de line printer poseen la extensión rp1 y se almacenan en el subdirectorio
Prt de nuestro proyecto.

Figura 227: Selección de bloques para la línea de

impresora.

11.5 Jobs
Un job o trabajo es un fichero que vincula nuestro layout o documento con la impresora y
el momento en que se debe imprimir dicho documento.
En la ventana podemos observar el nombre del trabajo o job, y el layout al que está
asociado. La P o F que aparecen después del nombre del layout significan respectivamente
Printer y File, indicando si el trabajo está configurado para salir por impresora, a un fichero o a
ambos.
Al igual que en los layouts, ya existen jobs configurados por le sistema, que nosotros
podemos modificar, pero no debemos borrar, ya que son los que utiliza WinCC.
Si realizamos un nuevo job, podemos acceder a sus propiedades que son:
Figura 228: Propiedades de un job.

• Name: nombre del trabajo.

• Project: proyecto en el que se encuentra el trabajo (solo lectura).
• Layout: Layout al que está asociado el trabajo.
• Last printout: última impresión realizada en este trabajo (solo lectura en tiempo de
runtime).
• Next printout: próxima impresión realizada en este trabajo (solo lectura en tiempo de
runtime).
• Start time: hora de comienzo de las impresiones si se desean cíclicas.
• Cycle: Cada cuanto tiempo debe imprimirse el layout.
Figura 229: Hojas y fechas a imprimir en el job.
• Page range: rango de páginas a imprimir del trabajo.

• Time range: el rango de tiempo que debe mostrar en datos que dependan del tiempo
(gráficas, tablas de valores). Puede ser:
• Relative: relativo al inicio del arranque de la runtime.
• Absolute: indica el comienzo y la finalización del periodo de tiempo a mostrar en los
datos del job.

Printer setup nos permite seleccionar la impresora de todas las que posea el sistema
por la que deseamos imprimir. Podemos indicar hasta 3 impresoras si existen en el sistema,
para que si una de ellas actualmente está desconectada o no responde (falta de papel, etc..),
poder imprimir por la siguiente que esté en la lista asignada.
También podemos exportar el documento o report a un fichero emf en el disco duro. En
este caso, se genera en nuestro proyecto un subdirectorio llamado Prt_Out, dentro del cual se
genera otro directorio con el nombre del job más la fecha y la hora en que se imprime, donde
se almacena cada página de nuestro documento en formato EMF (gráfico).
Los iconos de un job indican si está configurado para disparase a través de un evento
de tiempo de manera automática o no. En la imagen se aprecia que el primero arrancará por
tiempo, mientras que el segundo deberá de ser llamado desde el graphic designer mediante la
función en C de ejecución de reports.
Existe la posibilidad de poder realizar una visualización previa del report sin necesidad
de esperarse al evento de tiempo ni tener que llamarlo desde C. Si presionamos sobre el job
con el botón derecho estando el runtime activado, podemos seleccionar Job Preview, con lo
que podremos observar como nos quedaría la impresión en el momento actual, e incluso
imprimir desde esta ventana el report.


Manual WinCC V4.02 Ejemplo Básico

Manual WinCC V4.02 Ejemplo básico
EJEMPLO BÁSICO


12 EJEMPLO BÁSICO
12.1 Introducción
Para ejemplificar todo lo visto hasta ahora vamos a realizar un ejemplo de las diferentes
posibilidades a la hora de configurar las pantallas del WinCC. Comenzaremos por las
características básicas a la hora de realizar una instalación de control, para posteriormente
introducirnos en el posibilidades más particulares.
Comenzaremos creando un nuevo proyecto de nombre DUNKER. Lo primero que
necesita nuestro proyecto es un botón para desactivar la runtime desde la propia runtime de
WinCC.
Creamos una picture desde el graphic designer que se llame MAIN.PDL. Colocamos
un botón como muestra la figura, y tenemos dos opciones:
• utilizar el asistente de Exit WinCC Runtime
• o colocar la instrucción DeactivateRTProject (); en el evento Mouse action.
Asignamos como hotkey ctrl+s.

Guardamos la picture y en Control Center->Computer->Graphics-Runtime
indicamos que la picture inicial va a ser MAIN.
Activamos en Window Atributes las opciones Border y Full Screen.
Activamos el runtime. Con el botón salir podremos salir de la runtime.

12.2 Salto entre pantallas.

Lo primero que se necesita en un proyecto es poder saltar entre varias pictures para
poder desplazarse por las imágenes.
Cree una picture llamada CONSULTA_BIT.PDL, con un botón como la figura.
Existen dos formas de asignar el salto de pantalla a un botón:

• a través de su dinamic dialog, que ya vimos anteriormente. Esto crea un Direct connection
del tipo:

• mediante C, asignando el código:

OpenPicture("Main");
Que se encuentra dentro de Standard Functions->Graphics. El código debe
introducirse en el evento Action Mouse, ya que en caso contrario la hotkey no funcionará. La
hotkey que asignaremos será ESC, para que al presionar escape volvamos a la pantalla
principal.
Guardamos la pantalla y ahora necesitamos llamar a dicha picture desde la principal.
Abrimos MAIN.PDL y creamos un botón, asignándole la llamada a la picture
CONSULTA_BIT.PDL. La hotkey asignada será F1. Guardamos los cambios.
Si ahora cambiamos con Alt+Tab a nuestra runtime aún abierta, observaremos que las
modificaciones no se han actualizado en la pantalla. Para poder actualizar dichos cambios,
podemos parar el runtime y volver a arrancarlo, o presionar el botón de play que aparece en la
barra de herramientas del graphic designer. Con esto el resultado es el siguiente:
Figura 230: Salto entre ventana MAIN y CONSULTA_BIT.
Comprobamos que podemos saltar de una a otra con el teclado o con el ratón.

12.3 Consulta de bits
12.3.1 Consulta con dynamic dialog
Vamos a ver como podemos activar un piloto en pantalla que cambie al color verde
cuando se active un bit en el PLC. Para ello, crearemos una caja I/O, con una variable interna
de nombre CONFIRMACION_MARCHA de 32 bits unsigned. Creamos también un círculo
quedando la imagen siguiente:
En la propiedad del círculo Colors->Background Color presionamos el botón derecho

y seleccionamos Dynamic dialog. Mediante el diálogo dinámico definimos dos colores, uno
para la posición de reposo y otro para la de activación asignando el cambio de color a la
variable anteriormente citada.
Seleccionamos el bit 0 de la variable interna, según la figura.

La actualización de los cambios del bit de la variable está en función de la selección

que realicemos en el botón event name de dicha ventana.
En este caso nos interesa que cambie de color cuando cambie dicha variable
únicamente, aunque no siempre será así.
Este tipo de configuración nos permite chequear el estado de un bit de una variable de
comunicaciones. Por lo tanto, lo más interesante será agrupar todas las variables binarias
(confirmaciones de marcha, estados manual/automático, etc..) en variables lo más grandes
posibles. En el caso de S7 el tamaño será de 32 bits, mientras que en el caso de S5 de 16 bits.
Si seleccionamos evaluate status of tag podemos indicar un color especial frente a
errores de comunicaciones, fallo en la conversión de datos y demás errores que indican que el
valor a representar no corresponde al estado real de la variable asociada.

Esta opción está pensada para las variables de comunicaciones. Con esto cuando el bit
0 de la variable.
12.3.2 Consulta con smart objects
Como sabemos WinCC tiene una biblioteca de imágenes y botones. Existen algunos
ellos que ya vienen preconfigurados para representar un estado binario (pilotos de aviso).
Seleccionamos la biblioteca y en Global Library->Smart Objects->Toggle Buttons
elegimos el botón de la figura.
En las propiedades del piloto, asignamos a tag assignement la variable igual que hicimos
anteriormente.

Con esto, cuando el bit valga uno aparece un piloto amarillo, y cuando valga cero es
rojo.
Puede ser que la imagen de un piloto amarillo no sea la ideal para representar el
estado del motor en marcha y deseemos modificarla para introducir nuestra propia imagen.
Para ello, en el menú contextual del objeto seleccionamos Customize Object->Edit. Ahora
seleccionamos Configuration Dialog, y nos aparece la asignación de imágenes que realiza el
objeto. Simplemente tenemos que asignar la que nosotros deseemos. Una vez funcione el
objeto según nuestros deseos, debemos volver a la opción Customize Object->Finish
Editing.
En realidad, WinCC crea un nuevo objeto al que asigna dos wmf y el siguiente código:
void OnClick(char* lpszPictureName, char* lpszObjectName, char* lpszPropertyName)
{
BOOL value;
LINKINFO plink;
PDLRTGetPropEx(0,lpszPictureName,lpszObjectName,"Toggle",VT_BOOL,&value,NULL,
NULL,0,NULL,NULL);
if(value) value =FALSE;
else value = TRUE;
PDLRTGetLink(0,lpszPictureName,lpszObjectName,"Toggle",&plink,NULL,NULL,NULL);
//Rückgabe-Typ :BOOL
if (plink.LinkType >2) return;

else SetTagBit (plink.szLinkName,(short int) value);
}

12.3.3 Representación mediante imágenes
A veces nos interesa representar imágenes dependiendo del estado del bit de una
variable (compuerta abierta o cerrada).
Para ello, lo primero que necesitamos son dos imágenes. En la biblioteca disponemos
dentro de global library->Valve 3D de una válvula de paso. La añadimos a nuestra picture y la
desagrupamos.
Los objetos de la biblioteca generalmente son un grupo de otros objetos. Para
desagrupar el objeto seleccionamos del menú group object->Ungroup. Ahora modificamos el
color de la tubería para que adquiera el color azul (paso de agua).
Por último volvemos a agrupar el objeto disponiendo del de la biblioteca y el
modificado.
El siguiente paso es exportar dichos objetos. Seleccionamos uno de ellos, y en el menú

general vamos a File->Export. Le damos el nombre valvula_on.emf a la azul y
valvula_off.emf a la de tubería blanca. Esta exportación genera un archivo en el subdirectorio
GraCS de nuestro proyecto por cada objeto.
Ahora creamos en la picture un objeto Status display, realizando la siguiente
asignación:

El resultado es el siguiente en nuestra imagen:
Mediante este sistema podemos animar imágenes en relación a un bit de una variable.

12.3.4 Representación textual del estado de un bit
Otra posibilidad es que se nos indique representar mediante texto el estado de un

elemento de la instalación (p. Ej: motor parado o motor arrancado).
Para ello introducimos un objeto Text List y rellenamos el configuration dialog con la
asignación a nuestra variable del ejemplo.
A continuación en Properties->Output/Input->List Type seleccionamos Bit, y en
Assignements rellenamos la ventana de textos.
Ya tenemos configurado el text list para que cuando cambie el bit nos represente dicho
estado con un texto.

12.4 Consulta analógica
12.4.1 Consulta con dynamic dialog
La representación analógica de valores puede ser de manera numérica, lo cual

consiste simplemente en utilizar un objeto I/O para visualizar el valor, o gráfica. Dentro del
apartado de gráfica, podemos utilizar objetos para representar dicho valor, o modificar las
propiedades de un objeto en función del valor a representar.
Empecemos por esta última opción. Deseamos visualizar en una caja I/O un valor de
presión de una máquina. El indicador debe:
• Si la presión está por debajo de un valor mínimo, el texto debe aparecer en amarillo.
• Si la presión rebasa un valor máximo, ponerse en rojo.
• Si la presión pasa un valor de seguridad máximo, deberá parpadear el texto.
Vamos a crear una nueva picture llamada CONSULTA_ANALOGICA.PDL. Para ello,
abrimos CONSULTA_BIT.PDL y la renombramos. Luego borramos todos los objetos, menos
el botón de VOLVER. Colocamos ahora una caja de I/O y guardamos la picture, y en Main.PDL
copiamos el botón anterior de salto, y lo pegamos modificando su texto como F2: CONSULTA
ANAL.. Modificamos su salto para que nos lleve a la nueva ventana creada y su hotkey, para
que sea F2. La picture generada tendrá el siguiente aspecto:
Los valores analógicos en S7 ya pueden ser tratados mediante números reales, por lo
que vamos a elegir esta opción en el ejemplo para obtener mayor resolución. Creamos una
variable interna denominada VALOR_ANALOGICO de tipo Floating point 32. Seleccionamos la
caja I/O y realizamos la siguiente parametrización:

Con esto definimos que el valor va a tener 1 decimal de resolución y no va a superar

nunca un valor de 99. La presión en la máquina sabemos por el elemento de campo que nunca
superará 30 unidades.
En la propiedad colors->Font color realizamos el siguiente dynamic dialog. Con él

cuando el valor esté por debajo de 5.3 el texto de la caja será amarillo, cuando estemos entre
5.3 y 14.7 será verde y cuando superemos los 14.7 será rojo.
Nos queda por último que parpadee cuando superamos un límite de seguridad. Para
ello en la propiedad Flashing->Flashing text active introducimos el siguiente dynamic dialog:

También podemos definir la frecuencia de flashing como fast y el color de flashing off
igual al del fondo de la caja. Esto dará sensación de desaparecer de la pantalla y volver a
aparecer.
Ahora ya puede guardar los cambios y comprobar el resultado introduciendo valores
entre 0 y 21 dentro de la caja I/O en el runtime.

12.4.2 Representación mediante barras
Representar valores analógicos mediante barras es muy sencillo. Basta con asignar el
valor a representar (que en nuestro caso continúa siendo el de la caja I/O) y parametrizar unos
máximo y mínimo de barra.
Nosotros realizaremos un ejercicio en que estos valores máximos sean a su vez
parametrizables.
En la picture CONSULTA_ANALOGICA, introducimos una barra, Y tres cajas de I/O
para controlar los valores de mínimo, máximo y fondo de escala, como muestra la figura.
Creamos tres variables nuevas, todas de coma flotante e internas, denominadas

VALOR_MINIMO, VALOR_MAXIMO y FONDO_ESCALA. Asignamos a la barra la siguiente
configuración:

En la propiedad limits, activamos el limit Marker, Monitoring AL (alarm Low),

asignamos la variable VALOR_MINIMO y el color. En type AL definimos que el valor de
mínimo será porcentual en relación con el valor de fondo de escala de la barra. Realizamos la
misma operación con los parámetros concernientes a AH (límite superior) pero esta vez con
VALOR_MAXIMO y color en rojo.
En miscelaneous definimos como maximum value de la barra la variable

FONDO_ESCALA. Activamos trend y asignamos a Process Drive el valor a representar.

Con esto podemos modificar la escala y observar la tendencia del valor (crece o
disminuye). Seleccionamos change color en segment, para que cambie de color por segmentos
la barra.

12.4.3 Representación mediante indicadores
Además de las barras, podemos representar los valores analógicos mediante un control
que existe en WinCC llamado gauge control. En realidad el gauge control es un control OCX
suministrado por WinCC, por lo que para poder crear un objeto gauge debemos insertar un
OLE Control. De la lista que se nos suministra elegimos WinCC gauge control. La apariencia
del control es la siguiente.
Vamos a repasar las propiedades de dicho control, ya que algunas de ellas son muy
interesantes a la hora de representar los valores analógicos en un proceso.
En OLE control properties tenemos:
• backcolor: color de fondo del circulo indicador.
• Background picture: podemos indicar un bitmap como fondo del indicador.
• BevelInner: Tamaño del borde del cuadro que rodea al indicador por su cara interior.
• BevelOuter: Tamaño del borde del cuadro que rodea al indicador por su cara exterior.
• BevelWidth: Tamaño del propio cuadro que rodea al indicador.
• Center Color: color del círculo central de la aguja del indicador.
• NeedleColor: color de la aguja del indicador.
• Show danger: mostrar el trozo de la escala que indica zona peligrosa superior (color rojo
escala).
• Show warning: mostrar el trozo de la escala que indica zona peligrosa inferior (color
amarillo escala).
• Tic color: color de las divisiones de la escala.

• Border Width: Ancho del borde que rodea al gauge.

• Caption color: color del texto del indicador (en el ejemplo texto PRESION).
• Center scale: diámetro de la circunferencia negra donde está la aguja del gauge.
• Danger: Donde empieza la zona de peligro (escala roja).
• Delta: Distancia entre divisiones de la escala. Si el valora representar es alto (32000) y
tenemos en delta un valor de 10, aparecerán 3200 divisiones en el indicador. Hay que tener
en cuenta el fondo de escala para que delta esté en función de ValueMax. Una solución
sería que delta=valuemax/10.
• Frame Scale: distancia desde la escala hasta el borde de la circunferencia del gauge.
• Value: valor de proceso.
• Value Max: fondo de escala.
• Value Min: menor valor de la escala.

• Warning: comienzo de la zona amarilla de la escala.

• TicFont: fuente de la escala.
• Frame Picture: Imagen de la escala.
• Angle Min: ángulo en que comienza la escala por la izquierda.
• Angle Max: ángulo en que termina la escala por la derecha.
• Caption Font: fuente de los indicadores centrales de texto.
• TicTextcolor: color de los números de la escala.
• Captionoffset: posición del texto de indicador (en el ejemplo PRESION).
• Tictext offset: distancia de los números de la escala a la escala.

• Tic Offset: posición de la escala.
• Tic Width: ancho de la escala.
• Caption: texto indicador.
• Unitfont: fuente del texto indicador de las unidades (en el ejemplo DUNKER).
• Unitoffset: distancia del texto de las unidades.
• Unittext: texto indicador de unidades de medida.
• UnitColor: color del texto de unidades de medida.
• Warning Color: color de la escala de alarma inferior (parte de la escala amarilla).
• DangerColor: color de la escala roja.

• ShowNormal: Mostrar la parte de la escala que esta entre los límites máximo y mínimo
(parte verde).
• Show DecimalPoint: Mostrar los números de la escala con un decimal o no.
• ShowPeak: Muestra una línea indicando el límite que ha alcanzado el valor por arriba o por
debajo (el pico máximo o mínimo que alcanzó el proceso).

12.5 Activación de bits
12.5.1 Activación de bits mediante Wizard
El control sobre los bits de una variable del PLC es una de las facetas fundamentales
en la configuración de un sistema scada. La mayoría de las acciones que implican dicho control
se basan en activar o resetear bits que conforman una palabra dentro de la memoria del PLC.
La variable de comunicaciones a controlar puede ser directamente una salida de PLC,
aunque lo más común es utilizar un estado de manual para el control por ordenador y un
estado de automático para el control a través del programa de PLC.
Nuestra intención es activar un bit en una variable interna a través de un botón. Para
ello, creamos una picture llamada ACTIVACION_BIT.PDL, que posee el siguiente aspecto:
La variable que asignaremos a I/O será CONFIRMACION_MARCHA, ya utilizada

anteriormente y de 32 bits. La propiedad Output/Input->Data Format debe estar seleccionada
en binario, y Output format debe tener 32 bits para permitirnos ver e introducir todos los bits
en el campo que estamos configurando.
Una vez tengamos definidos los botones y el campo de I/O, y de haber realizado un
botón de salto desde la ventana Main a esta picture (utilizar como hotkey F3 y como texto
Activación Bit), nos resta que los botones al presionar F1 activen el bit 3 de la palabra y con
Shift+F1 desactiven dicho bit.

Seleccionamos el primer botón, y en el Dynamic Wizard, en la pestaña Standard

Dynamics existe el Wizard Setting/Reseting a bit. El Wizard es el siguiente:
En esta pantalla se nos solicita el evento con el que debe de activarse/desactivarse el

bit: con cualquier acción del ratón, al presionar el botón derecho o izquierdo, o al levantar el
botón una vez presionado. Si no se asocia el código a any mouse key, luego la hotkey no
funciona, ya que sólo actúa cuando el código a realizar se encuentra en el evento Mouse
Action.

A continuación se nos solicita la variable y si debe de setearse o resetearse el bit.
Por último debemos indicar el bit sobre el que se debe realizar la acción. Estos pasos
son idénticos para el segundo botón, salvo que en lugar de elegir setear el bit se elige resetear
el bit. Sólo queda guardar las modificaciones realizadas y probar el runtime.

12.5.2 Activar un bit durante la pulsación de una tecla.
Movimiento en manual de motores, la confirmación de seguridad para habilitar el paso

por barreras de seguridad, son todos estas situaciones en las que se hace imprescindible la
pulsación continuada del operario de una o varias teclas para que se realice la acción.
Para que se realice de una manera satisfactoria, en el PLC debe de estar activo el bit
exclusivamente mientras se pulse la tecla, por lo que al levantar el dedo de la misma el bit debe
de resetearse.
En WinCC este se consigue utilizando el código que nos genera el Wizard anterior de
seteo de bit en el evento keyboard ->press. Suponemos que deseamos activar el bit 12 de la
doble palabra MOTORES. En este caso el código asociado a dicho evento es el siguiente:
DWORD dwHelp1,dwHelp2;
dwHelp1=GetTagDWordWait("MOTORES");
dwHelp2=dwHelp1|4096;
SetTagDWordWait("MOTORES",dwHelp2);
Para que al levantar la presión sobre la tecla desaparezca el bit el código debe de
asignarse en el evento keyboard->release y es el siguiente:
DWORD dwHelp1,dwHelp2;
dwHelp1=GetTagDWordWait("MOTORES");
dwHelp2=dwHelp1&(0xFFFFFFFF^4096);
SetTagDWordWait("MOTORES", dwHelp2);
Nota:
Si vamos a trabajar sólo con el teclado, debemos
recordar siempre que:
• se debe asignar una hotkey al objeto.
• En el evento mouse action del mismo se debe
realizar una llamada setfocus, ya que es el único
evento que realiza la tecla hotkey , por lo que si en
el mismo no tomamos el foco a nuestro objeto, no
se realizarán los eventos de teclado anteriormente
descritos.

12.5.3 Activación de varios bits
Otra posibilidad es activar o desactivar varios bits de una misma palabra a la vez. Los
pasos a seguir son similares al primer caso, salvo que el Wizard será distinto. Creamos dos
nuevos botones según la figura:
Seleccionamos el primer nuevo botón, y en el Dynamic Wizard, en la pestaña Standard

Dynamics existe el Wizard Setting/Reseting bits. El Wizard es similar al anterior, salvo que
ahora podemos seleccionar varios bits.

12.5.4 Activar bits mediante telerruptores.
Además de poder activar bits mediante botones estándar de Windows, en los sistemas
de control se utiliza la superposición de dos imágenes que simulan interruptores de parado y
arrancado. Mediante la pulsación sobre esta imagen se activa el elemento y se visualiza su
estado. Con una nueva pulsación se desactiva el bit y se vuelve al estado inicial.
En WinCC, esta posibilidad ya esta contemplada en la biblioteca dentro de Smart
Objects. Todos los Toggle Buttons poseen dos imágenes, y lo único que tenemos que hacer
es asignar a la propiedad Tag Assignement la variable que se debe controlar desde estos
botones.
El inconveniente de este método es que la variable a seleccionar no puede ser un bit

de una palabra, sino que debe de ser una variable exclusiva para este botón, por lo que debe
de asignarse una variable para cada botón, no puede ser activado un bit exclusivamente de
una variable.
Sin embargo, podemos modificar esta situación y utilizar una variable interna de tipo
BOOL para el objeto telerruptor, e introducir un poco de código en C que solvente esta
situación, y enlace la variable del telerruptor con la variable de proceso a la que le deseamos
activar o desactivar el bit.
El código que es necesario introducir en Action Mouse es el siguiente (además del que
ya tiene asignado el telerruptor para realizar la acción de cambiar la variable BOOL:
if (GetTagBit("VARIABLE_BOOL")==TRUE)
{
dwHelp1=GetTagDWord("CONFIRMACION_MARCHA"); //Return-Type :DWORD
dwHelp2=dwHelp1|8;

SetTagDWordWait("CONFIRMACION_MARCHA",dwHelp2);
}
else
{
dwHelp1=GetTagDWord("CONFIRMACION_MARCHA"); //Return-Type :DWORD
dwHelp2=dwHelp1&(0xFFFFFFFF^8);
SetTagDWordWait("CONFIRMACION_MARCHA",dwHelp2);
}
VARIABLE_BOOL es la variable asignada al telerruptor, CONFIRMACION_MARCHA

es la variable de proceso de 32 bits, y el bit a alternar es el bit 3 (de ahí que se realice la and y
la or lógica con el número 8). Para otros bits diferentes del 3 deberá sustituirse este código por
2 elevado al número de bit.

12.5.5 Activación de bits a través de texto.
También podemos activar bits de una palabra a través de un menú de textos

configurables por nosotros, una solución técnica que en los sistemas de control está
infrautilizada y sin embargo es muy útil y descriptiva en muchas situaciones.
Introduciremos un objeto text list en nuestra picture como muestra la figura:
La configuración del text list se basa en seleccionar el campo como entrada/salida,

asignar la variable CONFIRMACION_MARCHA, en list type asignar el tipo bit, y parametrizar
Assignements. El bit a activar en la palabra lo define la propiedad Bit Number.

12.6 Asignar valores analógicos
12.6.1 Asignación directa de valores analógicos
La asignación de valores analógicos se suele realizar mediante barras de deslizamiento,

aunque a veces es necesario inicializar un valor, o restaurarlo a unos valores por defecto.
Vamos a crear una nueva picture ACTIVACION_ANALOGICA.PDL según la figura:
Disponemos de un Wizard en Standard Dynamics->Set Tag Value que nos permite

asignar el código C necesario para realizar esta acción.

Esta misma acción se puede realizar en C directamente asociando el siguiente código

a un evento cualquiera:
SetTagWord("CONFIRMACION_MARCHA",30);

12.6.2 Asignación mediante barra de desplazamiento.
WinCC dispone de una barra de desplazamiento estándar de Windows, que se puede

utilizar para introducir valores analógicos.
Su funcionamiento y manejo se puede definir directamente desde el Configuration

Dialog sin problemas.
12.6.3 Asignación mediante el objeto Slider de WinCC
WinCC dispone de un objeto propio además del ya visto de Windows para poder
introducir y visualizar a la vez valores analógicos en el proceso. Este objeto se encuentra en
Ole Control->Slider Control. La imagen es la siguiente:

El problema que tiene este objeto es que al asignar la propiedad position, solo es de
lectura, pero no modifica el valor de proceso al que se asigna al modificar la posición del slider
el usuario.
Esto se solventa añadiendo el siguiente código C en el evento Miscelaneous del
objeto slider.
void Change(char* lpszPictureName, char* lpszObjectName , long Position)
{
SetTagDWord("CONFIRMACION_MARCHA",Position); //Return-Type :BOOL
}
Las propiedades del objeto slider aparecen a continuación:

12.7 Rellenado de superficies
12.7.1 Rellenado mediante Smart Objets
Para rellenar superficies en función de un valor analógico, la forma más sencilla es

utilizar cualquiera de los contenedores que se incluyen en el apartado Smart Objects de la
biblioteca de WinCC.
Introducimos un tanque y unas variables como muestra la figura:
El tanque posee ya preconfiguradas las funciones de rellenado automático en función

de un valor máximo y mínimo.

12.7.2 Rellenado directo de objetos
Algunos objetos, como un cuadrado, poseen la propiedad Dynamic Filling, que les
permite rellenar su fondo en función de un valor de proceso. El único inconveniente es que el
valor es escalado entre 0 y 100, de tal manera que si el valor de proceso pasa de 100, el objeto
queda completamente rellenado, sin mostrar nuevos incrementos.
Para solucionar esto, se puede utilizar el escalado de variables que permite el Tag
Management, pasando del valor de proceso a un valor entre 0 a 100.
12.7.3 Rellenado de polígonos.
En aquellas situaciones en que los valores de llenado sean irregulares deberemos de

utilizar el objeto polígono, que nos permite adoptar todo tipo de formas, p.ej tanques de agua
irregulares.

Manual WinCC V4.02 Ejemplo avanzado
EJEMPLO AVANZADO


13 Ejemplo avanzado
13.1 Comunicación DDE

Existen principalmente dos formas de enlazar las aplicaciones dentro de Windows a nivel
de comunicaciones: DDE y OLE 2.0.
Vamos a centrarnos primeramente en la comunicación entre WinCC y Excel, desde el
punto de vista DDE.
El enlace DDE se considera un canal de comunicaciones, por lo que las variables
asignadas deben de comprarse. La característica principal que lo diferencia de OLE es que las
aplicaciones que comunican lo hacen de manera constante, es decir, cualquier modificación de
la variable en una de las aplicaciones repercute inmediatamente en la otra aplicación.
Para realizar un enlace DDE, desde el tag management agregamos el driver Windows
DDE. A dicho driver podemos asociarle diversos enlaces. En nuestro caso vamos a
comunicarnos con las hojas 1 y 2 de un libro de Excel 97 que se llama Ejemplo.xls y que se
encuentra en el subdirectorio del proyecto de WinCC.
Nota: todas las variables del canal DDE se consideran variables de comunicaciones,
por que es necesario tenerlas en cuenta a la hora de comprar una runtime de un determinado
número de tags.
Si deseamos acceder a variables que se encuentren en la hoja 1 de un libro de excel,
basta con realizar la parametrización del enlace que aparece en la imagen siguiente.

Las características de la conexión DDE son:

• Computer Name: Ordenador en el que se va a realizar la comunicación DDE (solo es
necesario cuando se trabaja en proyectos multipuesto).
• Application: Aplicación con la que se va a realizar la comunicación DDE.
• Topic: Nombre del fichero con el que debe de comunicarse entre la aplicación anterior y el
WinCC. Si el archivo no se encuentra en el subdirectorio del proyecto WinCC, será
necesario añadir antes del nombre el path completo.
• Metod for reading tag:
Always fetch: Comunicar constantemente las aplicaciones, independientemente de
que se modifiquen los valores en las mismas.
Fetch only after change: Comunicar solo despues de que se modifique la variable de
comunicaciones.
Fetch automatically upon change: Comunicar automáticamente en el momento del
cambio.
• Response Time: Tiempo que debe esperar la aplicación que manda la comunicación DDE
para que conteste la otra como mensaje recibido.
• Abort after timeout: Posibilidad de abortar las comunicaciones cuando se sobrepasa el
timeout sin respuesta por parte de la otra aplicación.

• Setup attemps: veces que se debe de permitir realizar la comunicación DDE entre las
aplicaciones:
Infinite: se permitirá comunicar mientras esté activo el canal DDE entre las
aplicaciones (ninguna de las dos se cierre).
Quantity: se permitirá comunicar un número determinado de veces entre las
aplicaciones.
Sin embargo, para asignar un enlace a otra hoja que no sea la primera, en el apartado
Topic es necesario indicar el siguiente acceso:
[ejemplo.xls]Hoja2
Con respecto a las variables que se asignan al enlace de comunicaciones, la única

particularidad es el acceso que se debe de parametrizar. Para acceder a una celda de excel, es
necesario introducir la letra L (de línea), el número de línea, la letra C (de columna), y el
número de columna.
También es necesario introducir el tamaño de la variable que va a contener la celda de
excel.
En la siguiente imagen se puede apreciar un canal DDE entre la ventana de WinCC y

un libro de Excel en su hoja 2.


13.2 Comunicación OLE 2.0

No siempre las aplicaciones deben de intercambiar datos de manera constante. De
hecho, y en contra de lo que en principio se suele pensar, la mayoría de los procesos deben de
renunciar al canal DDE ya que necesitan de una orden de validación para enviar sus datos a
WinCC, ya que generalmente esto suele significar enviarlos al proceso.
Un método más práctico de comunicar aplicaciones lo representa la conexión OLE 2.0,
que solo se realiza mediante una orden expresa de envío o de recepción, y exclusivamente de
las variables que se soliciten.
Dentro de la demo de WinCC, en el subdirectorio DemoV4\db existe un archivo
llamado Olesetget.xls. Esta hoja de excel contiene unas macros para realizar la comunicación
OLE entre la demo y Excel.
Nosotros hemos modificado ligeramente la hoja para nuestro ejemplo particularizándola
como muestra la figura:
Los botones Leer() y Ecribir() poseen asociadas dos macros (que en el ejemplo se
llaman setvalue() y getvalue(), pero que podemos denominar como deseemos.

En realidad dichas macros son unas pequeñas instrucciones en visual basic, que
vamos a explicar de manera personalizada (simplificando el ejemplo suministrado por
DemoV4).
13.2.1 Lectura de valores desde Excel
La macro modificada para lectura de variables desde Excel es la siguiente:
Sub GetValue()
Rem----------------------------------------------------------------------
Rem Leer valores de WinCC desde Excel
Rem----------------------------------------------------------------------
Dim mcp As Object

Dim value As Variant
Set mcp = CreateObject("WinCC-Runtime-Project")
' LEER VAR_1_BOOL EN LA CELDA D6

value = mcp.GetValue("VAR_1_BOOL")
Range("D6").Select
ActiveCell.FormulaR1C1 = Str(value)
' LEER VAR_2_BYTE EN LA CELDA D7

value = mcp.GetValue("VAR_2_BYTE")
Range("D7").Select

ActiveCell.FormulaR1C1 = Str(value)
End Sub
Rem///// end /////////////////////////////////////////////////////
13.2.2 Escritura de valores desde Excel
La macro setvalue para activar las dos primeras variables del ejemplo puede ser la
siguiente:
Sub SetValue()
Rem----------------------------------------------------------------------
Rem ESCRITURA DE VALORES DESDE EXCEL A WINCC
Rem----------------------------------------------------------------------
Dim mcp As Object

Dim value As Variant
Dim bRet As Integer
Set mcp = CreateObject("WinCC-Runtime-Project")
' ESCRITURA DE E6 EN WINCC

value = Range("E6")
bRet = mcp.SetValue("VAR_1_BOOL", value)

' ESCRITURA DE E7 EN WINCC

value = Range("E7")
bRet = mcp.SetValue("VAR_2_BYTE", value)
End Sub
Una de las grandes ventajas de utilizar la comunicación OLE entre aplicaciones es que
no consume variables de comunicaciones, a diferencia de DDE, por lo que son gratuítas,
mientras que las segundas deben de comprarse.

13.3 Exportación de datos
13.3.1 Exportación de datos a ficheros TXT o CSV.
La exportación de datos es uno de los procesos más frecuentes para poder tratar la
información almacenada por WinCC del proceso. Estos datos se pueden tratar a través de
Excel y Access como aplicaciones ofimáticas más comunes. En realidad, el formato CSV, que
se suele utilizar para importar datos a Excel, es este mismo tipo de exportación (a fichero de
texto, separando los diferentes campos por un operador (en este caso una coma).
Por consiguiente, la exportación a ficheros txt es una manera sencilla de poder obtener
datos de la base sql anywhere en la que almacena WinCC la información y poder plasmarla
mediante cualquier procesador de textos para combinar dicha información con un documento
(p. Ej. Un informe realizado con Word).
Vamos a realizar un nuevo proyecto que se denomine Exportar, y que cuelgue del subdirectorio
raíz C:\.
Nos vamos al tag logging y creamos un archivo de nombre ARCHIVO, en el que
almacenaremos el valor de VARIABLE cada segundo. Creamos una tabla que contenga en la
columna 1 el valor de VARIABLE del archivo ARCHIVO.
Nos creamos una picture main.pdl como la figura:
La variable interna que aparece en la esquina derecha la creamos con el nombre de

VARIABLE.
Vamos al evento del botón EXPORTAR TXT y en action mouse asociamos el siguiente
código C:

void OnLButtonDown(char* lpszPictureName, char* lpszObjectName, char*
lpszPropertyName, UINT nFlags, int x, int y)
{
ProgramExecute("ISQL.EXE -q -b -c
UID=DBA;PWD=SQL;DBF=C:\\exportar\\exportarRT.DB;DBN=CC_Exportar_99-01-
29_21:17:03R; read C:\\exportar\\DB\\CONSULTA.SQL");
Estudiemos que significa dicha sentencia:

• ProgramExecute: ejecutar una aplicación externa a WinCC. En realidad la exportación no
la realiza WinCC directamente sino que recurre a una aplicación llamada ISQL.EXE para
que realice una consulta SQL a nuestra base de datos.
• ISQL.EXE: ejecutable que hace la consulta.
• DBF=: path y nombre de la base de datos runtime de nuestro proyecto, en la cual se
encuentra almacenada la tendencia que queremos exportar.
• DBN=: identificador DSN de ODBC. Como sabemos, las bases de datos para poder
realizar transacciones ODBC necesitan un DSN (data source name) que identifique a dicha
base de datos en la consulta o exportación de los mismos). Este identificador, se asigna
tanto a la base de datos del proyecto como a la de runtime.

Para conocer el DSN de nuestra base de datos del proyecto EXPORTAR,

acudimos a una aplicación que se denomina 32 Bits ODBC y que se encuentra en el
panel de control de Windows.
En dicha ventana aparecen todas las bases de datos de nuestro PC que soportan
ODBC. El nombre identificador de la base de datos se compone de:
CC_ + Nombre del proyecto + fecha/hora creación + R
La R final identifica si la base de datos es la del proyecto (donde se guardan los
parámetros del proyecto) o de runtime (donde se guardan los valores que se almacenan
del proceso).
El primer campo nos identifica el DSN de nuestra base de datos.
Continuando con la explicación de la línea en C que realiza la exportación tenemos:

• Read archivo_consulta.sql: La palabra read va seguida del path y el nombre del archivo
de texto con extensión sql en el que vamos a realizar la consulta sql. Dentro de este
archivo no estarán los datos, sino nuestra expresión SQL que permitirá extraerlos y
dejarlos en otro archivo que aquí definiremos.

Compilamos este código, y desde el Explorer de Windows creamos el subdirectorio Db y

dentro creamos mediante el block de notas un archivo de texto de nombre
CONSULTA.SQL que contenga las siguientes líneas de texto:
select t,v from pde#hd#archivo#variable;

output to C:\exportar\db\consulta.txt format ascii
El crear las consultas en el subdirectorio DB no es obligatorio, pero recomendamos

esta práctica para que se produzca una estandarización en las aplicaciones a la hora de poder
conocer donde se realizan las exportaciones en WinCC.
Estudiemos la consulta SQL:
• Select t,v: Selecciona las columnas T y V. Todo archivo de variables dentro de SQL
Anywhere posee dos columnas, T y V, que corresponden:
T: fecha y hora de almacenamiento del valor de proceso.
V: Valor de proceso almacenado.
• From pde#hd#archivo#variable: la variable VARIABLE almacenada en ARCHIVO se
encuentra en esta dirección dentro de la base de datos.
• Output to: sacar dicha consulta por el fichero consulta.txt que se encuentra en
C:\exportar\db.
• Format ascii: la exportación se debe de realizar en formato ascii.
Volvemos al WinCC y activamos en COMPUTER la parte del runtime del tag logging, y
definimos como imagen inicial esta picture creada (en nuestro ejemplo como siempre la hemos
denominado MAIN.PDL).

Si ejecutamos el runtime y realizamos la exportación, desde el explorador de Windows

podremos abrir un nuevo archivo creado dentro del subdirectorio DB, como mostraba la figura
anterior.
13.3.2 Exportación desde ISQL
En realidad lo que hemos hecho antes ha sido llamar a una utilidad de SQL Anywhere
llamada ISQL que se ha encargado de realizar la exportación.
También podemos llamar directamente desde Windows al ejecutable isql.exe. En la
conexión deberemos de pasar los parámetros DBA y como password SQL:
Podemos desde la ventana del interactive SQL realizar las consultas que deseemos
cargando nuestro fichero *.sql en que realizamos la consulta.
Destacar que en las propiedades de este programa podemos configurar el tipo de

archivo que deseamos en la salida, pudiendo elegir desde formato txt hasta dbase III.


13.4 Ayuda en sus aplicaciones
13.4.1 Ayuda Online
Cuanto mayor es un proyecto de visualización, mayor también es la complejidad y

cantidad de elementos diferentes a representar y monitorizar. No es sencillo en la mayoría de
los casos describir suficientemente la funcionalidad de los elementos representados en las
pictures o de los objetos de control que gobiernan el proceso.
La ayuda online, entendiendo por ella la ayuda que depende del objeto del cual
requerimos la misma, se convierte en vital en instalaciones de visualización de tipo medio-alto.
Para realizar la activación de ventanas de ayuda online, aconsejamos utilizar el evento
del botón derecho del ratón, de tal manera que con el botón izquierdo se activa el elemento, y
con el botón derecho emerge la ayuda sobre el mismo.
Volvemos a nuestro proyecto dunker, y creamos una picture de nombre AYUDAS.PDL
con la siguiente presentación:
Creamos otra picture denominada AYUDA_1.PDL que estará compuesta por un static
text y un botón como se aprecia en la figura inferior. Es importante recordar que en el static text
el poder introducir diferentes líneas de texto se consigue presionando la tecla ENTER + SHIFT.
Asignamos a la picture Window que hemos creado la picture AYUDA_1.PDL con las
siguientes propiedades (además de DISPLAY=NO):

La picture AYUDA_1.PDL es la siguiente:
Queremos que presionando con el botón derecho del ratón sobre el botón AYUDA
CON EL BOTON OK aparezca esta ventana de ayuda, y que desaparezca al presionar el
botón ACEPTAR. El código en el botón AYUDA CON EL BOTON OK en el evento Press
Rigth es el siguiente:
SetVisible("AYUDAS.PDL","Picture Window1",1);
El código a programar en el botón ACEPTAR es el siguiente:

13.4.2 Ayuda temporal
Otra posibilidad a la hora de plasmar ayudas contextuales es que con el botón derecho
pinchado sobre el objeto seleccionado aparezca una ventana de ayuda que desaparece
automáticamente después de un tiempo predeterminado.
Para realizar esto, utilizaremos la picture AYUDA_1.PDL pero borrándole el botón
ACEPTAR, con lo que para que desaparezca tendremos que programar una acción en C.
En el evento press rigth del botón AYUDA TEMPORAL programamos:
La idea es activar una variable interna de tipo bit al mostrar la ventana de ayuda. Esta
variable interna, activará una acción en C que irá contando automáticamente hasta llegar a 5
segundos, tiempo en que ocultará la ventana de ayuda.
En la picture AYUDA_1.PDL, en el evento Open picture programamos:
SetTagBit("TRIGGER_AYUDA_1",TRUE);
TRIGGER_AYUDA_1 es una variable interna que nos hemos definido de tipo BOOL y
que debe de disparar una acción en C. Nos vamos al Global Script y creamos una nueva
acción de tipo global que contenga el siguiente código:

int gscAction( void )

{
BOOL visible;
static int contador;
visible=GetVisible("AYUDAS.PDL","Picture Window1"); //Return-Type :BOOL

if (visible)
{
if (contador>=5)
{
contador=0;
SetVisible("AYUDAS.PDL","Picture Window1",0); //Return-Type :BOOL
}
else
{
contador++;
SetTagBit("TRIGGER_AYUDA_1",FALSE); //Return - Type :BOOL
}
}
return(0);
}
Por último nos queda asignar el trigger de esta acción a la variable

TRIGGER_AYUDA_1 y al evento cíclico 1 segundo, de tal manera que mientras esté la
variable a TRUE y cada 1 segundo se ejecutará la acción, que irá contando hasta 5 (segundos)
y reseteará el contador (observar que es una variable static para poder memorizar el valor
anterior) y la variable de disparo.

13.5 Datos de una picture
13.5.1 Nombre de la ventana actual
Podemos mostrar el nombre de la ventana actual en un campo de texto de una manera

muy sencilla. Solo tenemos que realizar la siguiente asignación a una caja de I/O:
En output value escribimos el siguiente código C:
return(lpszPictureName);
Esta función nos devuelve el nombre de la ventana desde la que ha sido llamada.

13.6 Introducción de valores múltiples

En ciertos momentos del control del proceso es necesario introducir valores de control
dentro del mismo pero de una manera coordinada, es decir, al mismo tiempo. Además se
requiere la posibilidad de que si antes de enviar los datos modificados se considera que son
erróneos, se contemple la posibilidad de poder deshacer la operación de envío.
Para estos menesteres se utiliza normalmente una caja de validación. Consiste en una
picture generalmente de un tamaño más reducido que la ventana en la que están nos datos a
modificar, y que contiene los campos de introducción de las variables, mas un botón de
cancelar y otro de aceptar. Sólo si el botón de aceptar es pulsado las modificaciones en el
proceso son efectivas.
13.6.1 Cajas sin verificación
Para ejemplificar esto último vamos a crear una nueva picture llamada
INTRODUCCIÓN.PDL que posee el siguiente aspecto:
Las variables asociadas a los campos de I/O van a ser las conocidas
VARIABLE_ANALOGICA, VALOR_MINIMO y VALOR_MAXIMO.
Ahora creamos otra nueva picture llamada CAJA_INTRODUCCION.PDL con un tamaño de
300*400 y el siguiente aspecto:

Creamos tres variables temporales denominadas TEMP_VARIABLE_ANALOGICA,

TEMP_VALOR_MINIMO y TEMP_VALOR_MAXIMO y las asignamos a las cajas de I/O.
Por último en la picture window de la ventana anterior asignamos a la propiedad picture
name el valor CAJA_INTRODUCCION.PDL.
Solo nos queda asignar el código C pertinente para que la aplicación se comporte
como deseamos. En el botón CAJAS SIN VERIFICACION, en el evento action mouse
deberemos introducir lo siguiente:
SetTagFloat("TEMP_VARIABLE_ANALOGICA",GetTagFloat("VARIABLE_ANALOGICA"));
SetTagFloat("TEMP_VALOR_MINIMO",GetTagFloat("VALOR_MINIMO"));
SetTagFloat("TEMP_VALOR_MAXIMO",GetTagFloat("VALOR_MAXIMO"));
SetVisible("INTRODUCCION.pdl","Ventana Introduccion 1",1); //Return-Type :BOOL
En la picture CAJA_INTRODUCCION, en el evento Open picture deberemos escribir
Set_Focus("CAJA_INTRODUCCION.PDL","I/O ANALOGICA"); //Return-Type :BOOL
Esto es necesario ya que si no activamos el foco en la ventana que ha emergido, no

podremos introducir datos sin ayuda del ratón.
Por último nos queda el código de los botones aceptar y cancelar. El de cancelar es el
siguiente:
Y el de aceptar:
SetTagFloat("VARIABLE_ANALOGICA",GetTagFloat("TEMP_VARIABLE_ANALOGICA"));
SetTagFloat("VALOR_MINIMO",GetTagFloat("TEMP_VALOR_MINIMO"));

SetTagFloat("VALOR_MAXIMO",GetTagFloat("TEMP_VALOR_MAXIMO"));
Con esto ya tenemos nuestra caja de entradas de valores.

13.6.2 Cajas de introducción con verificación de límites.
La introducción de datos al proceso siguiendo el método anterior permite deshacer la

operación de envío, pero no comprueba que los datos introducidos sean correctos.
Vamos a modificar el ejemplo anterior para que solo si el valor analógico se encuentra
comprendido entre los límites mínimo y máximo podamos introducirlo en el proceso. Para ello
en el objeto I/O ANALOGICA de la picture CAJA_INTRODUCCION, en el evento Property
Topic->Output-Input->Input Value escribimos el siguiente código C:
float valor,minimo,maximo;
valor=GetTagFloat("TEMP_VARIABLE_ANALOGICA"); //Return-Type :float

minimo=GetTagFloat("TEMP_VALOR_MINIMO"); //Return-Type :float
maximo=GetTagFloat("TEMP_VALOR_MAXIMO"); //Return-Type :float
if (valor<minimo)
{
valor=minimo;
MessageBox(NULL,"El valor analógico debe ser mayor que el valor minimo.","Error de
introducción",MB_OK|MB_ICONEXCLAMATION|MB_SETFOREGROUND|MB_SYSTEMMO
DAL);
}
if (valor>maximo)
{
valor=maximo;
MessageBox(NULL,"El valor analógico debe ser menor que el valor maximo.","Error de
introducción",MB_OK|MB_ICONEXCLAMATION|MB_SETFOREGROUND|MB_SYSTEMMO
DAL);
}
SetTagFloat("TEMP_VARIABLE_ANALOGICA",valor); //Return-Type :BOOL

Si observamos el código, realiza una comparación entre el valor temporal analógico y el

temporal de mínimo y el de máximo. Si no se encuentra comprendido lo iguala al límite y
muestra un mensaje de aviso al operario.

13.6.3 Incrementar/decrementar valores
Otra posibilidad a la hora de modificar los valores de proceso es utilizar botones de

incrementar/decrementar con límites de máximo y mínimo.
Vamos a controlar la variable VARIABLE_ANALOGICA con botones de subir/bajar
entre los límites de VALOR_MINIMO y VALOR_MAXIMO.
En la biblioteca de objetos, en Global Library->Smart Objets->Incr-Decr Button
tenemos preconfigurados unos botones que colocamos en nuestra picture:
En las propiedades de los botones podemos asignar tanto el incremento que van a
realizar, como la variable a incrementar/decrementar, como el límite que no se puede rebasar.

13.7 Animación
La animación de los procesos a través de la lectura de un bit es la forma más visual de
mostrar el funcionamiento del proceso. En WinCC es el status display el que se encarga de
realizar esta acción, ya que es un objeto que contiene hasta un máximo de 31 imágenes, y que
en función de un índice irá mostrándolas.
El principal problema reside en el hecho de que en los procesos, el movimiento debe de
producirse cuando el bit de una variable está activado. Por lo tanto, deberemos de mediante
una función en C, animar una variable interna mientras dicho bit se encuentre activo.
Creamos una picture llamada ANIMACION.PDL. Vamos a utilizar unas imágenes que se
encuentran en la demo de WinCC, en el subdirectorio GraCS y que son 29 imágenes BMP
llamadas DMP00000 a DMP00029.
Asignamos a un objeto status display las 29 imágenes como muestra la figura:
Hay que observar que a partir de la imagen 14 desde esta ventana no permite
introducir los valores, por lo que deberemos ir a properties->state->Current status y asignar a
mano el número y la imagen en Basis Picture.
La pantalla resultante, con un botón para parar la animación y otro para arrancarla
debe quedar aproximadamente así:

El código en el botón de arrancar será el siguiente:
SetTagBit("BIT_ANIMACION",1); //Return-Type :BOOL
Esta variable booleana es la que va a controlar la marcha de la animación. El botón

parar es igual pero con el parámetro a cero en lugar de a uno.
Nos queda la parte compleja, que consiste en realizar una acción que será disparada
cada medio segundo cuando el bit BIT_ANIMACION sea true, y que irá incrementando la
variable INDICE_ANIMACION hasta 29, volviendo a cero y así sucesivamente.
Nos vamos al global script y creamos una acción llamada ANIMACION que posee el
siguiente código:

{
int indice;
indice=GetTagByte("INDICE_ANIMACION"); //Return - Type :BYTE
if (indice>28)
{
indice=0;
}
else

{
indice++;
}
SetTagByte("INDICE_ANIMACION",indice); //Return - Type :BOOL
return(0);
}
Por último el trigger de esta acción será el siguiente:
Solo queda comprobar que la animación funciona. Recordar que es necesario poner un
botón que acceda a la ventana ANIMACION.PDL.

13.8 Controles OLE
13.8.1 Introducción
Una de las posibilidades más interesantes de que dispone el WinCC a nivel de

conectividad es la inserción de objetos OLE 2.0 (OCX). Un control OLE es un código (WinCC
solo soporta OCX, es decir, compilado a 32 bits) que ha sido desarrollado por un tercero y que
nos permite realizar una determinada función. Dicho código tiene una serie de parámetros de
entrada que desde nuestra aplicación podemos introducir, y de salida, que podemos consultar.
De esta manera, no es necesario para un programador desarrollar todo el código de
una aplicación, sino que puede “reutilizar” código realizado anteriormente por otros.
La mayoría de las aplicaciones suministran varios controles OCX para que podamos
realizar ciertas funcionalidades. En especial Visual Basic, que si está instalado en el PC nos
ofrece multitud de objetos.
13.8.2 Utilización de OCX
Vamos a crear una nueva picture llamada OLE, con un campo I/O asignado a la
variable VARIABLE_ANALOGICA. Introducimos desde Smart Objects->Ole Control el objeto
ProgressBar que es la barra de progresión que aparece cuando arranca el runtime de WinCC.
Observar que en la parte inferior nos indica a que OCX pertenece el control OLE.

El insertar un objeto nos permite acceder a sus propiedades, que irán en función de lo
que realice el mismo. En este caso nos interesa dinamizar el valor que debe representar.
El resultado es que tenemos una barra de progresión para mostrar valores analógicos
que WinCC no poseía anteriormente. El único inconveniente de utilizar OCX externos es que
no basta con instalar el WinCC en otro ordenador y copiar el subdirectorio de nuestro proyecto
para que la aplicación funcione. Es necesario registrar en el sistema el control. En caso
contrario donde aparecía el control mostrará una imagen en blanco.

13.8.3 Controles OCX de WinCC
El propio WinCC incorpora varios OCX, que curiosamente no están disponibles

directamente desde el árbol de objetos. Estos OCX se pueden utilizar por otras aplicaciones
ajenas a WinCC, en sentido inverso a lo que hicimos anteriormente con un objeto de Visual
Basic.
Vamos a repasar estos objetos de WinCC.
Digital/Analog Clock
Creamos dos objetos iguales de OLE control, asignándole el objeto reloj en nuestra
picture OLE, y repasamos los parámetros de que dispone dicho objeto.

• Backcolor: color de fondo del reloj.

• Font: fuente para el reloj digital.
• Forecolor: color de la fuente para el reloj digital.
• Picture: se puede asociar un bitmap al fondo del reloj.
• HourNeedleWidth: Ancho de la aguja de las horas.
• MinuteNeedleWidth: Ancho de la aguja de los minutos.
• HourNeedleHeigth: Largo de la aguja de las horas.
• MinuteNeedleHeigth: Largo de la aguja de los minutos.
• SecodNeedleWidth: Ancho de la aguja de los segundos.
• SecodNeedleHeigth: Largo de la aguja de los segundos.
• Analog: tipo de representación de la hora. En la figura inferior se muestra una
representación analógica y otra digital.
• Ticks: mostrar en la representación analógica los círculos de las horas.
• TicksColor: Color de los indicadores de las horas.
GLOBAL SCRIPT DIAGNOSE CONTROL
El control de diagnosis de global script es muy útil a la hora de depurar programas

complejos que incluyan código C. Cuando se ejecuta la aplicación que soporta el código,
descubrir cual es el error que se está produciendo es relativamente sencillo con este objeto, ya
que WinCC automáticamente envía un mensaje a dicha ventana para informarnos del mismo.
El control es básicamente una caja de texto en la que van apareciendo los mensajes
tanto de error del sistema como aquellos que nosotros enviemos a la ventana (mediante la
instrucción en C printf). En la barra de herramientas disponemos de un icono para parar el

diagnosis, y poder retroceder en los mensajes para estudiarlos con calma, a la vez que poder
imprimirlos en papel.
Para poder enviar mensajes de aviso a la pantalla de diagnosis desde nuestra propia
aplicación, creamos un botón y en el evento action mouse escribimos:
printf("Valor analógico actual:%f",GetTagFloat("VARIABLE_ANALOGICA"));
Cuando presionamos sobre él el resultado en la runtime será el siguiente:

Diagnose Control
El objeto diagnose control nos indica que aplicación de qué ordenador está enviando
un mensaje de error. En instalaciones en las cuales disponemos de varios ordenadores esta
ventana se vuelve bastante útil a la hora de informar si uno de los ordenadores de la red está
teniendo problemas.
WinCC Webbrowser
WinCC dispone de un control para poder navegar a través de internet sin necesidad de
salir del mismo ni utilizar el Explorer ni Netscape. Dicho objeto se denomina Webbrowser, y lo
único que requiere es habilitar la dirección home en la que debe de arrancar.


13.9 Multimedia
13.9.1 Sonidos en WinCC
La inserción de sonidos en WinCC se realiza a través de una llamada a la API de

Windows. La función API se denomina PlaySoundA, que requiere como parámetro el fichero
WAV que debe sonar.
Como ejemplo crearemos cualquier botón, y asociaremos el siguiente código a action
mouse:
#pragma code ("Winmm.dll")

VOID WINAPI PlaySoundA ( char* pszSound,char* hmode, DWORD dwFlag );
#pragma code()
PlaySoundA("C:\\FRTRAIN.WAV", NULL, 1);
Hay que observar que para que suene, deberemos de tener el fichero FRTRAIN.WAV
que está disponible en la Demo de WinCC copiado en el raíz. También destacar que como la
función pertenece a la API del sistema primeramente deberemos de declararla, incluyendo la
dll a la que pertenece, lo cual realizamos en las primeras tres líneas de código.

13.9.2 Video en WinCC
La presentación de ficheros AVI, mezcla de vídeo y sonido también es posible en

WinCC gracias al programa externo mplayer.exe
Al invocar mediante una función en C a dicho programa, pasándole como parámetro el
nombre del fichero avi podemos disponer de una manera vistosa de animar los estados de
reposo del sistema o realizar explicaciones espectaculares de información mediante imágenes
y voz.
En cualquier botón, asociemos el código siguiente:
ProgramExecute("C:\\mplayer.exe /play /play /close C:\\coravif.avi");
Debemos de disponer del programa mplayer.exe en el raíz de nuestro disco duro, así
como de un archivo avi llamado coravif.avi (se encuentra en el subdirectorio video de
DemoV4).
Los parámetros play y close indican al programa que debe de arrancar
automáticamente, y que al acabar la presentación del avi debe cerrarse automáticamente.
Una grabación con cámara de vídeo de las partes de la instalación podría servir como
ayuda a un operario, que podría estar viendo y oyendo lo que debe hacer ante una
determinada situación.

13.10 Instancias
La asignación dinámica de las variables a una ventana es uno de los procesos más
interesantes a la hora de configurar una aplicación que posee determinados elementos con una
estructura similar.
Supongamos el funcionamiento de un motor. Sus estados de control son
manual/automático, marcha/paro, parado/funcionando/con error. Podría realizar una ventana,
asignando estas tres variables para un determinado motor, y con un botón visualizar o no la
misma.
Esta solución cuando existen una gran cantidad de elementos idénticos (200 motores)
se vuelve tediosa y repetitiva. Para solventar esta situación existen la asignación de estructuras
de datos a ventanas y la generación de instancias de prototipos de ventanas.
13.10.2 Generación de una instancia
Vamos a seguir los pasos necesarios para generar una instancia de un prototipo de
ventana mediante la pulsación de un botón.
Creamos una nueva picture llamada INSTANCIA.PDL, y que posee el siguiente
aspecto:
Las cajas I/O no poseen de momento ninguna variable asignada, así que vamos a
generarlas. Primeramente vamos a generar una estructura prototipo. En data types, en la
opción structure tag, creamos una nueva según la siguiente imagen:

Creamos tres nuevas variables (PID_1, PID_2 y PID_3) en Tag management una
nueva variable interna, del tipo que acabamos de definir (PID), con lo que veremos que se nos
generan tantas variables como elementos posee la estructura.
Volvemos a la picture anterior, y asignamos las variables creadas a cada una de las
cajas de I/O.
Ahora vamos a crear una nueva picture llamada VENTANA.PDL, con un tamaño de
300x400 y el siguiente aspecto:

Teniendo creada esta ventana, el siguiente paso es asignar a cada propiedad de esta
ventana una variable de la estructura tipo (PID). Para ello podemos utilizar el Wizard llamado
Picture Modul Template del Wizard Picture Moduls.
Indicamos la estructura que deseamos enlazar a la ventana actual.

Asignamos como muestra la imagen las propiedades de la ventana a los elementos de

la estructura. El Wizard nos generará al finalizar una nueva picture, cuyo nombre se compone
del nombre de la picture antecedido por @TYPE_.
Guardamos esta nueva ventana, y lo siguiente que debemos hacer es llamar a la nueva
ventana ya enlazada a la estructura desde la anterior (INSTANCIAS.PDL), pasándole como
parámetro en cada llamada las variables que debe de sustituir por las de la estructura.
Teniendo activa la picture INSTANCIAS.PDL seleccionamos el Wizard Picture-Module
Instances.
Se nos solicita la picture de la cual se deben generar instancias (creada con el wizard
anterior.
Además disponemos de cuatro tipos de generación de instancias:
• Crear una ventana para cada instancia.
• Crear una sola ventana y con varios botones seleccionar la instancia que se carga en dicha
ventana.
• Igual que la anterior, pero el botón no solo muestra la instancia, sino que con una segunda
pulsación la oculta.
• Una sola ventana que puede modificar su instancia cambiando el nombre que posee en la
parte superior, y que corresponde con la estructura a cargar.

En esta ventana podemos elegir la cantidad de instancias que deseamos generar (en
nuestro caso 3, una para cada estructura generada).
Además, podemos asignar ya una posición para la instancia de manera absoluta, o con
respecto a la posición del botón que hará visible la instancia.
En la esquina superior se nos generará una window picture y tres botones amarillos.
Cada uno de estos botones cargará una instancia diferente en la picture window generada. El
resultado es el siguiente:

13.11 Vinculación ODBC

La base de datos de WinCC soporta comunicación ODBC con otras bases de datos
externas. Esta característica es interesante a la hora de vincular dinámicamente los datos
almacenados por WinCC con una base de datos (p. Ej. Access) para poder analizar los mismos
mediante un programa que maneje los mismos.
Vamos a crear una nueva picture llamada ODBC.PDL, en la que introducimos 3
campos I/O asociados a tres variables nuevas llamadas VARIABLE_1, VARIABLE_2 y
VARIABLE_3 internas de tipo unsigned 16 bits.
En el tag logging creamos un archivo llamado ARCHIVO que contenga estas tres
variables, con un ciclo de adquisición de 1 segundo.
Arrancamos la runtime, y en el simulador de variables simularemos los valores de las
mismas:
Con esto, estaremos archivando en la base de datos de WinCC valores dentro del
archivo donde se almacenan dichas variables.
Arrancamos Access 97, y creamos una nueva base de datos en blanco. Con el botón
derecho, seleccionamos Importar. La ventana de Access nos muestra por defecto solo las
bases de datos de tipo mdb. Seleccionamos desplegando la solapa de tipos de archivo la
opción bases de datos ODBC.

En la ventana siguiente seleccionaremos la base de datos de runtime de nuestro

proyecto.
A continuación se nos permite seleccionar de la base de datos aquellos valores que

deseamos importar a nuestra base en Access.
Con estos pasos hemos conseguido importar no solo los datos de la base con su fecha
y hora de adquisición, sino también en la tercera columna el código de error (si lo hubiera) que
se pueda producir en la adquisición del valor.
Hay que tener en cuenta que la columna T es un campo de la base de datos en formato
fecha/hora, que habrá que descomponer para su posterior tratamiento.

La vinculación es un proceso todavía más interesante que la importación, ya que al ser

dinámico, permite actualizar constantemente y de manera automática los datos entre WinCC y
Access, por lo que lo que estamos manejando en Access es lo que se está almacenando en
WinCC. El inconveniente es que por este mismo motivo, cuando se desee modificar la base de
datos desde Access será necesario utilizar la importación.

13.12 Animación de tuberías

El movimiento de fluidos por tuberías es una de las primeras acciones a la hora de
conseguir la representación de la dirección de un proceso. Normalmente las instalaciones
industriales se basan en el movimiento de objetos o fluidos. En el caso de los fluidos (aire,
agua, grasa, etc..), la dirección del movimiento del fluido es importantísima para poder seguir el
funcionamiento del mismo en una pantalla.
Para animar una tubería en función de la activación de un bit de una variable de
proceso seguiremos los pasos que describiremos a continuación.
Primeramente crearemos un pequeño rectángulo, que posea la siguiente configuración
en la propiedad background color y en la propiedad line color
Copiamos dicho cuadrado varias veces, realizando en cada una de las copias un
desplazamiento de los colores que se muestran en el dinamic dialog superior.
La variable VALOR_1 es una variable interna de tipo unsigned int que utilizaremos para
desplazar los colores, de tal manera que se genere el efecto de desplazamiento de líquido.
Solo queda realizar una acción en C que varíe el valor de VALOR_1 de 0 a 3
dependiendo de si se encuentra activado un bit.
En global script crearemos la siguiente acción:

{

static int temporal;
if (GetTagBit("bit")==1)
{
if(temporal>2)
{
temporal=0;
}
else
{
temporal++;
}
SetTagWord("VALOR_1",temporal); //Return - Type :BOOL
}
return(0);
}
El trigger de dicha acción será el siguiente:

Con esto, la animación deberá quedar como muestra la figura inferior. Es importante
destacar que se debe de tener en cuenta el sentido que se da al corrimiento de los colores de
los rectángulos ya que en función del mismo será el efecto de desplazamiento del fluido.
Por último se debe de rodear con varias líneas negras el borde de los rectángulos para
que se dé el efecto de tubería.

13.13 Manejo de ficheros
El manejo de recetas supone uno de los inconvenientes del paquete básico WinCC. Tal
como está diseñado el scada, el almacenamiento de valores importantes para el proceso que
no sean históricos debe de realizarse en el PLC.
Cualquier sistema que se base en variables internas, depende de conseguir que no se
pare nunca la runtime, ya que al volver a arrancar carga los valores que se hayan definido en el
apartado valor inicial para cada variable interna (por defecto 0).
La única manera de conseguir utilizar el WinCC como un sistema de almacenamiento y
manejo de recetas pasa por la utilización de ficheros en el disco duro programados en C y que
nos permitan guardar los valores internos, y posteriormente ser cargados para su envío al
proceso.
Este apartado se ocupa de la programación en C necesaria para poder llevar a cabo el
manejo de ficheros.
13.13.2 Almacenamiento de valores en el disco duro.
Vamos a guardar en el disco duro 3 variables internas diferentes:

• VALOR_1 de tipo long.
• VALOR_2 de tipo entero.
• VALOR_3 de tipo real o float.
Creamos una nueva picture llamada FICHEROS.PDL con el siguiente aspecto y botones:

La ventana en blanco que aparece en la parte inferior es el control OLE Global Script
Diagnose Control ya visto anteriormente.
Definimos las variables anteriormente citadas y las asignamos a las cajas I/O.
Vamos a asociar el siguiente código C al botón ESCRIBIR VALORES A FICHERO
DUNKER.DAT:
FILE *DATOS;
long L;
float FP;
int I;
DATOS=fopen("C:\\DUNKER.DAT","w+");
if(DATOS!=NULL)
{
L=GetTagDWord("VALOR_1"); //DWORD
FP=GetTagFloat("VALOR_3"); //float
I=GetTagWord("VALOR_2"); //WORD
fprintf(DATOS,"%ld\r\n%d\r\n%f\r\n",L,I,FP);
fclose(DATOS);
printf("DATOS GUARDADOS EN C:\\DUNKER.DAT\r\n");

}
else
{
printf("ERROR ESCRIBIENDO DATOS EN DUNKER.DAT");
}
Con esto guardaremos los valores anteriormente indicados en un fichero llamado

DUNKER.DAT que cuelga del raíz de C:.
13.13.3 Lectura de valores desde un fichero
Ahora realizaremos la acción contraria, la lectura de dichos valores de un fichero para

cargar los mismos en las variables internas.
El código asociado al botón LEER VALORES DE FICHERO DUNKER.DAT es el
siguiente:
FILE *DATOS;

long L;
float FP;
int I;
int a;
char CADENA[20];
char* z;
DATOS=fopen("C:\\DUNKER.DAT","r");
if(DATOS!=NULL)
{
z=fgets(CADENA,20,DATOS);
printf("CADENA 1:%s\r\n",CADENA);
L=atol(CADENA); //Return-Type :long int
FP=atof(CADENA); //Return-Type :double
I=atoi(CADENA); //Return-Type :long int
SetTagDWord("VALOR_1",L); //Return-Type :BOOL

SetTagWord("VALOR_2",I); //Return-Type :BOOL
SetTagFloat("VALOR_3",FP); //Return-Type :BOOL
fclose(DATOS);
printf("VALORES LEIDOS:%ld %f %d\r\n",L,FP,I);
printf("DATOS LEIDOS DE C:\\DUNKER.DAT\r\n");
}
else
{
printf("ERROR LEYENDO DATOS EN DUNKER.DAT");
}
Para poder apreciar que ha cargado los valores, lógicamente deberemos de modificar
anteriormente los que ya poseen las cajas de I/O, y presionar el botón, con lo que cargará los
valores que hubiéramos introducido anteriormente.

13.13.4 Añadir valores a un fichero.
Menos frecuente puede ser la siguiente posibilidad, pero tal vez pueda resultar
interesante al lector: disponer de un fichero ya creado, y añadirle un valor de una variable
interna que anteriormente no se hubiese almacenado, sin tener que generarlo de nuevo.
El código que asociaremos al botón AÑADIR VALORES AL FICHERO DUNKER.DAT
es el siguiente:
FILE *DATOS;
float FP;
DATOS=fopen("C:\\DUNKER.DAT","a");
if(DATOS!=NULL)
{
fprintf(DATOS,"%f",FP);
fclose(DATOS);
printf("DATO VALOR_3 AÑADIDO A C:\\DUNKER.DAT\r\n");
}
else
{
printf("ERROR AÑADIENDO DATOS A DUNKER.DAT");
}
En este código hemos vuelto a grabar el valor VALOR_3 de nuevo en el fichero ya

creado al principio de estos ejemplos.

13.13.5 Borrado de ficheros.
Por último, solo nos queda explicar como se borra un fichero de datos desde WinCC. El
código asociado al botón BORRAR EL FICHERO DUNKER.DAT es el siguiente:
remove("C:\\DUNKER.DAT");
printf("FICHERO C:\\DUNKER.DAT BORRADO.\r\n");

13.14 Gráficas no temporal.

WinCC proporciona todo tipo de herramientas a la hora de configurar la presentación
de gráficas temporales en pantalla. Sin embargo, no existe de una manera directa una manera
de parametrizar una gráfica de acuerdo a un eje x que no esté basado en el tiempo.
Así, si deseamos p. Ej. Mostrar la intensidad consumida por un variador en nuestra
instalación con respecto a la frecuencia la tarea se convierte relativamente compleja.
En este ejemplo vamos a mostrar una función en C que solventa este inconveniente
supliendo en parte esta ausencia de gráfica no-temporal. Esta solución es solo parcial debido a
que la cantidad de parámetros a presentar tanto en el eje X como en el Y debe ser fija, ya que
deberemos de programar en C las variables que confirmarán la gráfica de acuerdo a los
mismos.
Creamos una nueva picture llamada GRAFICA_NO_TEMPORAL.PDL que presente el
siguiente aspecto:
Creamos 10 variables internas unsigned de 16 bits denominadas desde VAL_X_1 a

VAL_X_5 y desde VAL_Y_1 a VAL_Y_5.
Estas variables corresponden a los valores de intensidad (eje Y) con respecto a la
frecuencia (eje X) y las asignaremos a las cajas de I/O.
La línea de la gráfica que las va a representar es una polilínea de 5 segmentos llamada
Línea. Nos queda ahora la parte complicada, que es asignar a los parámetros Top y Left de
cada uno de los segmentos de la polilínea los valores de proceso (variables internas definidas

anteriormente). El problema reside en que hay que realizar un cambio de escala, ya que los
valores del eje X en el proceso representar la frecuencia entre 0 y 140 Hz, mientras que en la
gráfica son píxels desde el 60 al 560.
Con respecto al eje Y, los valores del proceso son Intensidades que van desde 0
amperios a 120, mientras que la gráfica va desde 480 píxels a 340.
En el global script creamos una nueva acción denominada GRAFICA_NO_TEMPORAL
que posee el siguiente código C:

{
int TEMP_X;
int TEMP_Y;
TEMP_X=60 + ((GetTagWord("VAL_X_1")*560)/140);
TEMP_Y=480- ((GetTagWord("VAL_Y_1")*250)/120);
SetIndex("grafica_no_temporal","Línea",1); //Rückgabe-Typ :BOOL

SetActualPointLeft("grafica_no_temporal","Línea",TEMP_X); //Rückgabe-Typ
:BOOL
SetActualPointTop("grafica_no_temporal","Línea",TEMP_Y); //Rückgabe-Typ
:BOOL

:BOOL
:BOOL

:BOOL
:BOOL

:BOOL
:BOOL

:BOOL
:BOOL
return(0);
}
Destacar el cambio de escala (una simple regla de tres) para ajustar la posición de la
polilínea, y como vamos cambiando el índice para cada vez asignar la posición de un vértice
diferente.
Por último, esta acción deberá realizarse siempre que cambie alguna variable del
proceso que tenga que ver con la gráfica. La asignación se realiza en el trigger de la siguiente
manera:

Es importante recordar que para que se ejecute el código de la acción la parte del
runtime global script runtime debe estar asignada antes de arrancar la runtime.
Con esto dispondremos de una gráfica de 5 puntos que muestra la función x=f(y).

13.15 Horarios en WinCC
13.15.1 Modificación de la fecha y hora del WinCC.
La manera más sencilla de cambiar la hora del WinCC sin necesidad de programar
excesivamente en C consiste en llamar a una utilidad del panel de control de Windows 95
denominada timedate.cpl, y en la cual modificamos a nuestro antojo el calendario del reloj del
sistema.
La instrucción a asociar a cualquier botón de cambio de hora será la siguiente:
ProgramExecute("C:\\windows\\control.exe timedate.cpl"); //Return-Type :unsigned long

int
13.15.2 Lectura de la fecha y la hora del WinCC.
En WinCC disponemos de un objeto OLE que nos muestra automáticamente la fecha y

hora del sistema. Sin embargo, puede ser necesario controlar a través de variables en qué
fecha y hora nos encontramos dentro del sistema.
Para realizar esta operación llamaremos a una función del sistema operativo que nos
devolverá una estructura con esta información. Deberemos crear variables de tipo unsigned 16
bits para cada uno de los datos. El código a asignar a una tarea que se ejecute cada cierto
tiempo será el siguiente:
#pragma code("kernel32.dll");
void GetLocalTime(SYSTEMTIME * lpst);
#pragma code();
SYSTEMTIME datos;
GetLocalTime(&datos);
SetTagWord("año",datos.wYear); //Return-Type :BOOL
SetTagWord("mes",datos.wMonth); //Return-Type :BOOL
SetTagWord("día_de_la_semana",datos.wDayOfWeek); //Return-Type :BOOL
SetTagWord("día",datos.wDay); //Return-Type :BOOL
SetTagWord("Horas",datos.wHour); //Return-Type :BOOL
SetTagWord("minutos",datos.wMinute); //Return-Type :BOOL
SetTagWord("segundos",datos.wSecond); //Return-Type :BOOL
SetTagWord("Milisegundos",datos.wMilliseconds); //Return-Type :BOOL

13.15.3 Franjas horarias de activación.
Muchos procesos deben de realizarse en una determinada franja de tiempo que debe
de ser parametrizable. La lubricación de motores, el arranque y parada del alumbrado, etc.. son
tareas que requieren de la comparación de la hora actual del PLC con una hora de arranque, y
posteriormente con una de parada.
En estos casos, no es posible realizar la comparación en WinCC (que sería mucha más
sencillo), debido a que si el ordenador se desconectara no arrancaría o pararía el proceso
temporal.
Vamos a realizar un ejemplo en el que queremos arrancar una salida del PLC de
acuerdo a una franja horaria. Creamos una picture en WinCC llamada HORARIO.PDL y que
presenta el siguiente aspecto:
Las variables asignadas a las cajas I/O son una estructura definida por nosotros en
data types->struct como HORARIO y que presenta el siguiente aspecto de la imagen inferior.
Destacar que es necesaria en la solapa de conversión realizar una conversión de byte a BCD,
ya que en los PLC’s S7 300/400 el horario se almacena en un formato denominado
date_and_time.
Este formato se describe en la ayuda de Step 7, pero básicamente cada valor de año,
mes, etc.. se encuentra en un byte en formato BCD.

En el tag management, creamos un enlace con un equipo S7 por MPI (si no

disponemos de él actualmente en nuestro proyecto), y generamos dos variables basadas en la
estructura anterior.

Por último solo queda crear una comparación dentro del PLC de dichas variables con la
hora del mismo. El programa de S7 en AWL a programar dentro de una FC es el siguiente:
CALL SFC 1
RET_VAL:=#ERROR
CDT :="HORARIOS".FECHA_HORA_ACTUAL
CALL FC 14
DT1 :="HORARIOS".FECHA_HORA_ACTUAL
DT2 :="HORARIOS".INICIO
RET_VAL:=M0.0
CALL FC 23
DT1 :="HORARIOS".FECHA_HORA_ACTUAL
DT2 :="HORARIOS".FIN
RET_VAL:=M0.1
U M 0.0
U M 0.1
= A 124.0
La SCF1 lee la hora actual del PLC. La FC14 realiza la comparación de arranque,
mientras que la FC23 la de finalización. Estas FC’s se encuentran en la librería stdlib de Step
7.

13.16 Teleservicio con WinCC

Mediante el paquete adicional teleservice es posible realizar una conexión con WinCC a
través de línea telefónica. Esta opción es muy interesante cuando se desea visualizar e incluso
controlar la instalación sin necesidad de encontrarse “in situ” (p. Ej. diagnosis de averías del
jefe de mantenimiento a distancia).
Para poder realizar teleservicio con WinCC es necesario disponer de:
• software teleservice.
• Adaptador TS, que convierte la salida del módem (RS232) en señal MPI (RS485).
Uno de los inconvenientes del teleservicio es que para poder instalar dicho software se
necesita tener instalado el software de Step 7 en dicho ordenador. Sin embargo, si se dispone
de dicho software, la desventaja se convierte en ventaja ya que no solo es posible visualizar y
controlar con WinCC, sino que además podremos acceder a todos los PLC’s que se
encuentren conectados en MPI y pogramarlos como si nos encontráramos en la misma
instalación.
La velocidad de transferencia se reduce lógicamente de 187000 baudios a 19200
debido a la línea telefónica.
Una gran cualidad de la conexión en teleservicio desde WinCC es que no son
necesarias grandes modificaciones de nuestro proyecto inicial con respecto al que existirá en el
ordenador remoto. Basta con seleccionar en el enlace MPI, en lugar de por PC Adapter o
Tarjeta MPI por TS Adapter. El resto del proyecto nos sirve sin realizar ninguna modificación.

Manual WinCC V4.02 Instalación Demo
INSTALACION DEMO


14 Instalación Demo.
14.1 Introducción.
Vamos a realizar una instalación de demostración en la que trataremos de utilizar la
mayor cantidad posible de técnicas de programación para que sirvan como base de ejemplos a
otras aplicaciones.
Comenzaremos creando un nuevo proyecto llamado INSTALACION.
Lo primero que haremos será crear nuestra estructura de usuarios del sistema. Tendremos:
• 2 operarios (OPERARIO_1 y OPERARIO_2) que podrán manejar el sistema.
• 1 responsable (RESPONSABLE_1) que tendrá el mismo acceso que nosotros a todas las
posibilidades del scada.
Los operarios de momento solo podrán salirse de WinCC para apagar el ordenador. Los
passwords de cada uno de ellos serán igual a su nombre pero sin el guión inferior (ej.
RESPONSABLE_1 es RESPONSABLE1).
A continuación creamos una pantalla MAIN.PDL con un botón de la biblioteca para salir de
la aplicación. Seleccionamos en el graphic designer como idioma el Español. En el text
library, añadimos el Español como idioma, y en Computer, seleccionamos el Español como
idioma del runtime.
Figura 231: Usuarios del sistema ejemplo.

Al botón de salida anterior le asignamos el nivel de password SALIR DEL SISTEMA. El

botón va a llamar a una ventana de confirmación denominada VENTANA_SALIR.PDL como
muestra la figura:
Creamos una picture Window asignada a PREGUNTAR_SALIR.PDL. Al botón de

salida inferior le asignamos el siguiente código:
SetVisible(lpszPictureName,"Ventana Salir",1); //Return-Type :BOOL
Nos queda asignar el código a los botones aceptar y cancelar. Para el botón aceptar el
código será:
DeactivateRTProject ();
Y para el botón cancelar:
SetVisible("MAIN.PDL","Ventana Salir",0); //Return-Type :BOOL
Por último nos queda en Computer asignar las hotkeys control+q para activar
usuarios y control+a para desactivar usuarios.

14.1.1 Control de alarmas.
Vamos a crearnos una variable interna de 32 bits denominada ALARMAS. Cada uno de
los bits de la misma activará un mensaje de alarma.
En el alarm logging configuramos una ventana de alarmas, y 10 mensajes de alarmas
para los 10 primeros bits de la palabra de alarmas. En propiedades de Error activamos la
opción horn.
Creamos una nueva picture que se denomine ALARMAS.PDL y que posea el siguiente
aspecto:
Deberemos crear dos tipos de ventanas, la anterior del tipo short-term y otra del estilo
message windows que colocaremos en la pantalla main, y que nos avisará del último evento
acaecido en la instalación.

El botón superior forma parte de una serie de botones que van a ser comunes a la
mayoría de las pantallas, y que nos van a permitir acceder y controlar el proceso
independientemente de donde nos encontremos. El botón ALARMAS, además de saltar a la
ventana del histórico de alarmas, cambia el color de fondo de gris a rojo cuando existe alguna
alarma en la instalación, y el texto parpadea.
Para conseguir esto creamos una variable de tipo BOOL llamada ALARMA_ACTIVA, y
vamos a generar una acción en C llamada alarma.pas y que tiene el siguiente código:

{
if(GetTagSDWord("ALARMAS")!=0)
{
SetTagBit("ALARMA_ACTIVA",1); //Return - Type :BOOL
}
else
{
SetTagBit("ALARMA_ACTIVA",0); //Return - Type :BOOL
}

return(0);
}
El trigger de la acción lógicamente será la variable ALARMAS para que cuando

aparezca o desaparezca alguna alarma se ejecute la subrutina que nos activa/desactiva la
variable booleana.
Por último, en las propiedades del botón asociamos a flashing text active la variable
ALARMA_ACTIVA y a background color el siguiente dinamic dialog:
14.1.2 Control de eventos de alarma.
Supongamos que deseamos que cuando aparezca una alarma podamos sacarle al
operario una ventana de aviso indicando qué alarma ha disparado, la fecha o la hora de su
aparición o desaparición.
Para ello, toda alarma dispone de una propiedad denominada Trigger an action que
permite asociar una subrutina de C a los eventos de aparición de una alarma. Esta función se
llama GMSGFUNC.FCT y se encuentra dentro del global script en standard functions\alarm.
Podemos editarla y modificar su código a nuestra voluntad. Si no realizamos ningún
cambio en la misma, lo que ejecuta es una salida por la ventana de diagnosis de C en la que se
refleja la alarma, fecha, hora y estado de la misma. Podemos leer los valores de la estructura
que nos devuelve la función para asociarlos a una ventana de mensajes personalizada, o
asignar un sonido particularizado para cada alarma, etc…
En concreto añadimos el código de activar un fichero wav al principio de esta función
standard, de tal manera que cuando aparece una alarma, suena por los altavoces de nuestra
instalación.

14.1.3 Utilización de la opción horn
Creamos un nuevo nivel de password denominado RECONOCIMIENTO HORN y al

que sólo tiene acceso RESPONSABLE_1. Activamos la opción trigger horn de nuestras
alarmas, y asignamos el nivel de password creado al botón horn. De esta manera, aunque
cualquiera de los usuarios acuse las alarmas que aparezcan, el botón de horn continuará
activado, indicando al responsable que en la instalación ha ocurrido una alarma que el no había
supervisado.
14.1.4 Impresión de ventanas de alarmas.
Además de poder activar en el alarm logging la opción de activar el botón de impresión

de la barra de herramientas de la ventana de alarmas, también podemos configurar nuestro
propio botón de impresión de alarmas.
Colocamos un botón en la picture de alarmas, y asociamos el siguiente código C al
botón:
RPTJobPreview("Report Alarm Logging RT Revolving archive");
Disponemos de tres reports preconfigurados:

• Report Alarm Logging RT Message sequence: alarmas actuales.
• Report Alarm Logging RT Sequence archive: archivo secuencial de alarmas.
• Report Alarm Logging RT Revolving archive: archivo short-term de alarmas.
Podemos imprimir directamente el report mediante otra función denominada

RPTJobPrint() o utilizar la función anterior que realiza una visualización del report además de
permitirnos imprimirlo.

14.2 Control de usuarios
14.2.1 Activación y desactivación de usuarios.
Llegados a este punto se vuelve interesante el control de los usuarios de nuestro sistema
desde la runtime. Para ello tomamos dos botones de la biblioteca, como muestra la figura:
El código de activación de usuarios mediante un botón es el siguiente:

#pragma code ("useadmin.dll")
#include "PWRT_api.h"
#pragma code()
PWRTLogin('c');
Y el de desactivación de usuarios, con una ventana de aviso indicando que

desactivamos nuestro nivel de autorización el siguiente:
#pragma code()
PWRTLogout();
MessageBox(NULL,"Desactivación de usuario","Desactivar
usuario",MB_OK|MB_ICONSTOP|MB_SETFOREGROUND);
14.2.2 Control del usuario actual.
Podemos mostrar en una cadena de texto el usuario actual que está activo en el
sistema. Para conocer quién esta activo y su login seguimos los siguientes pasos:
• creamos una variable de tipo text 8 bits con 40 caracteres llamada
USUARIO_ACTUAL.
• Creamos una caja de I/O de sólo lectura y de tipo string y le asociamos la variable
anterior.
• Insertamos el siguiente código en un evento temporal:


#pragma code()
char cadena[100];
PWRTGetCurrentUser(cadena, 20);
SetTagChar("USUARIO_ACTUAL",cadena); //Return-Type :BOOL

14.3 Control del proceso
14.3.1 Ejemplo sin instancias.
Vamos a controlar en nuestro proyecto demo unos tanques de llenado utilizando tres
válvulas proporcionales y tres electroválvulas. Disponemos de dos depósitos de llenado que
confluyen en un tercero en el que se realiza una mezcla de dos líquidos.
Creamos una nueva picture llamada ZONA_1.PDL en la que utilizando los objetos de la
librería del graphic designer dibujamos lo siguiente:
Los contenedores de líquido los asignaremos a tres variables float (se recomienda
utilizar el asistente para dynamic filling, ya que permite escalar la variable de proceso
automáticamente, no restringiéndonos a un valor entre 0 y 100).
El siguiente paso es mover las electroválvulas de acuerdo a bits de una variable interna
llamada CONFIRMACION_MARCHA de 32 bits. Tomamos de la biblioteca el dibujo de la
electroválvula horizontal y vertical, las superponemos (por comodidad, cada una en una capa
distinta) y a la horizontal le asignamos en la propiedad display el siguiente dinamic dialog:

A la electroválvula vertical evidentemente le asignaremos un dynamic dialog igual pero

con las propiedades de display al revés (Set=No y not set=Yes).
De esta manera, cuando el bit 0 de CONFIRMACION_MARCHA esté activo aparecerá
la electroválvula horizontal y desaparecerá la vertical y al contrario.
Por supuesto, podemos utilizar otros métodos para dinamizar el posicionado de objetos
de acuerdo a bit (recordar lo visto en los ejemplos de status display), pero esta es una nueva
forma de poder realizar estas acciones.
El rellenado del color de las tuberías de acuerdo a un bit de una palabra se realiza de
una manera muy sencilla utilizando el dynamic dialog. Unicamente es necesario tener en
cuenta que hay que desagrupar los objetos de la librería si queremos obtener el rellenado
exclusivo del fondo de la tubería, para luego volver a agrupar los objetos.

14.3.2 Ejemplo con instancias.
Nos queda ahora asignar tres PID’s, una a cada electoválvula proporcional que van a
regular la dosificación del producto.
Podríamos hacer tantas ventanas como PID’s y asignarle a cada botón amarillo
(PID_X) la opción de displya de la ventana. En este ejemplo, esto es posible. Sin embargo, si
queremos realizar el control de 20 motores con manual/automático y marcha/paro,
necesitaremos recurrir a la generación de instancias, ya vistas anteriormente, y que ahora
trataremos en algo más de profundidad.
Comencemos por crearnos una estructura que contenga los parámetros de un PID:
Si deseamos actuar sobre un PID continuo de un S7 (SFB41 ó FB41, dependiendo de

si el PLC es IFM o no), la parametrización podría ser similar a la figura. Repasemos las
variables que estamos generando:
• COM_RST: rearranque completo del PID.
• MAN_ON: conectar modo manual del PID o automático.
• SP_INT: consigna del PID.
• PV_IN: valor del proceso a controlar.
• MAN: consigna para valor en manual.
• GAIN: ganancia de la parte proporcional del PID.
• TI: tiempo para la acción integral del PID.
• TD: tiempo para la parte derivativa del PID.
• LMN_HLM: límite máximo de salida del PID.
• LMN_LLM: límite mínimo de salida del PID.
• LMN: valor de salida del PID.

Teniendo construida correctamente nuestra estructura de acuerdo a la de la DB de

instancia asociada a la FB41 del PLC, en el tag logging crearemos tres variables según la
estructura PID denominadas PID_1, PID_2, y PID_3. Automáticamente e nos generan tantas
variables como disponga la estructura anterior:
En el graphic designer, creamos una nueva picture denominada PID.PDL, que posee el
siguiente aspecto:
Las cajas I/O de este prototipo no las asignamos a ninguna variable de momento, tan
solo les asignamos nombres que nos permitan identificarlas claramente, al igual que las barras
y los botones.

Teniendo en el graphic designer la ventana PID.PDL seleccionamos el Wizard Picture

Modul Template.
Lo primero que se nos solicita es la estructura de variables que se va a lincar al
prototipo, en nuestro caso PID.
Si es la primera vez que se realiza una asignación de una estructura a un prototipo la

siguiente ventana aparecerá vacía, indicándonos las propiedades a lincar con las variables de
la estructura anteriormente seleccionada.
A las barras les asignaremos la propiedad proccess, a las cajas I/O la propiedad
OutputValue. El único punto algo complicado reside en crear un piloto que nos indique si el PID
se encuentra actualmente en manual o en automático.
Para realizar esto lincamos la variable MAN_ON a la propiedad visible de
CIRCULO_AUTOMATICO, que es un círculo de color verde. Por lo tanto cuando se active
dicho bit de la estructura el círculo será visible. Una vez realizados todos los lincados,
aceptamos el Wizard.
En la ventana de PID.PDL que ahora está lincada con la estructura, creamos otro
círculo igual que CIRCULO_AUTOMATICO pero e color rojo y que quede por debajo del verde.
De esta manera, cuando desaparezca CIRCULO_AUTOMATICO, aparecerá el rojo, dándonos
la impresión de que ha cambiado de color, cuando en realidad está desapareciendo.

Guardamos esta ventana y volvemos a la picture ZONA_1.PDL. Utilizando el Wizard

Picture Module Instances realizamos tres instancias de PID_1, PID_2 y PID_3 en base a
PID.PDL com muestra la figura:

Seleccionamos la aparición de la ventana relativa a la posición de los botones de

llamada (hay que introducir el valor adecuado en la posición relativa de X e Y, ya que en caso
contrario la ventana tapará al botón que la llama, por lo que no podremos cerrarla).
Terminado el Wizard se nos genera un picture window object y tres botones. Estos
botones al ser presionados, hacen visible el objeto picture window que muestra la ventana
PID.PDL, pero en cada llamada se lincan las variables asignadas a cada estructura del PID.
El código que se genera en los botones de llamada es el siguiente:
#include "PicBlck.h"
CalledTypePicture "Pid";
Position_x xPositionOfButton + (100);
Position_y yPositionOfButton + (-200);
LinkPrototypeInstance;
Para conocer las funciones CalledTypePicture y LinkPrototypeInstance puede editar

con cualquier procesador de texto el fichero Piclck.h del subdirectorio WinCC\aplib donde
están las declaraciones de las funciones.
Puede ser interesante en el objeto picture window en el que va a aparecer la picture
activar las propiedades border=yes border=yes y moveable=yes para poder mover la
ventana del PID si se superpone con algún valor que deseamos visualizar mientras
introducimos valores en el mismo.
Continuando con el estudio del código que nos asigna el wizard de generación de
instancias, en la picture PID.PDL en el evento Open Picture se nos asigna el código de
generación de instancia:
char* TemplateTypePicture = lpszPictureName ;

char* InstanceName = GetParentPictureWindow(lpszPictureName);
int TemplateHeight = 250;

EnableTemplateInstance(TemplateTypePicture,InstanceName,TemplateHeight);
En cualquier caso, lo más importante a recordar en la generación de instancias, es lo

siguiente: el botón que realiza la llamada a la instancia debe de denominarse como la
estructura de la que debe de cargar los valores.
En nuestro ejemplo, el botón PID_1 se llama PID_1 y llama a la estructura PID_1.
Con esto hemos visto la asignación de un lincado o enlace entre los valores de la
estructura que es relativamente sencillo utilizando los wizard existentes. Pero si lo que
deseamos es modificar un valor de la variable enlazada mediante código, es necesario
comprender detenidamente el código que vamos a asociar a los botones M y A de la picture
PID.PDL.
Deseamos con el botón M poner el PID en manual y con el A en automático, o lo que
es lo mismo, modificar el bit MAN_ON de la estructura del PID. El código a asociar al botón M
es el siguiente:
// crea una estructura de tipo LINKINFO en la variable par4

LINKINFO par4;
// recibe la información de la propiedad visible del

// objeto CIRCULO_AUTOMATICO y almacena en la estructura par4
// según el siguiente orden:
// par4.LinkType lincado directo/indirecto
// par4.dwCycle tiempo de actualización
// par4.szLinkName nombre de la variable lincada
GetLink(lpszPictureName,"CIRCULO_AUTOMATICO","Visible",&par4);
// cambia el valor de la variable asignada a la propiedad visible de

CIRCULO_AUTOMATICO a cero.
SetTagBit(par4.szLinkName,0);
Para el botón de automático sería lo mismo salvo la instrucción settagbit con parámetro
final a 1.
Si deseáramos cambiar el valor de un bit de una estructura con un solo botón, de
manera que cada vez que pulsamos una vez el PID se pone en manual y con otra pulsación en
automático, la última línea debería de sustituirse por la siguiente:
SetTagBit(par4.szLinkName,1-GetTagBit(par4.szLinkName));
Este código realiza la alternancia entre 0 y 1 cada vez que se pulsa el botón.

Por último, terminada la instancia, nos quedan los indicadores analógicos, a los que le
asignamos directamente la variable PV_IN de su correspondiente estructura de PID.

14.4 Recetas de productos.

En la anterior pantalla hemos realizado la mezcla de dos líquidos creando un tercero.
Supongamos que podemos asignar una composición a cada uno de ellos, y cuyas cantidades
de componentes se encuentran en un conjunto de variables definidas por nosotros.
A estas variables las denominaremos receta. Vamos a crear una picture llamada
RECETA.PDL y que posea el siguiente aspecto:
Creamos cinco variables internas de 16 bits denominadas desde RECETA_1 a

RECETA_5, todas ellas asignadas a las cajas I/O de la derecha.
Veamos el código del botón GRABAR RECETA 1:
FILE *DATOS;
int L[5];
DATOS=fopen("C:\\RECETA_1.DAT","w+");
if(DATOS!=NULL)
{
L[0]=GetTagWord("RECETA_1");

fprintf(DATOS,"%d\r\n%d\r\n%d\r\n%d\r\n%d\r\n",L[0],L[1],L[2],L[3],L[4]);
fclose(DATOS);
printf("DATOS GUARDADOS EN C:\\RECETA_1.DAT\r\n");

}
else
{
printf("ERROR ESCRIBIENDO DATOS EN RECETA_1.DAT");
}
Para los demás botones de grabar valdrá el mismo código, simplemente modificando el
nombre del fichero RECETA_1.DAT por RECETA_2.DAT y así sucesivamente.
Para la lectura de recetas el código asignado al botón CARGAR RECETA 1 será el

siguiente:
FILE *DATOS;
int L[5];
char CADENA[20];
char* z;
DATOS=fopen("C:\\RECETA_1.DAT","r");
if(DATOS!=NULL)
{
L[0]=atoi(CADENA); //Return-Type :long int
SetTagWord("RECETA_1",L[0]); //Return-Type :BOOL


fclose(DATOS);
printf("DATOS LEIDOS DE C:\\RECETA_1.DAT\r\n");
}
else
{
printf("ERROR LEYENDO DATOS EN RECETA_1.DAT");
}
Por último esta carga de valores debe ser enviada mediante el botón ENVIAR RECETA
A PLC que copia los valores internos a los de proceso. Lo contrario realiza el botón LEER
RECETA DEL PLC.

14.5 Gráficos en la instalación.
14.5.1 Curvas de datos.
Las anteriores recetas, cuyos valores de comunicaciones van evolucionando en el PLC

pueden ser objeto de nuestro estudio mediante gráfica para saber como evoluciona la cantidad
de producto restante.
En el tag logging creamos un archivo que contenga las cinco recetas anteriores:
Antes de crear una nueva trend y una nueva table, acudimos al user administrator,
donde definimos un nuevo nivel de password al que solo puede acceder el RESPONSABLE_1.
Volviendo al tag logging creamos una nueva trend y una nueva tabla. En las
propiedades del archivo de lectura le asignamos el nivel creado anteriormente. De esta
manera, a la hora de editar los datos de la tabla, solo podrá realizar dicha acción el
RESPONSABLE_1, quedando inhabilitada para los demás usuarios.
Creamos una nueva picture llamada GRAFICA.PDL y que posea una aplication window
de trend y una aplication window de table.

Observar como al haber bloqueado el acceso a escritura del archivo, solo el

responsable_1 puede acceder a modificar los datos.
14.5.2 Reports de gráficos y de tablas de valores.
Para finalizar una instalación, se suelen realizar los reports que deben de plasmar los
resultados anteriores del proceso en el formato deseado por el cliente. Se suele añadir un
logotipo, nombre de instalación, etc… Lo que será común en todas las instalaciones es la
necesidad de mostrar las gráficas de la instalación en hojas separadas, al igual que las tablas
de datos.
Nuestro ejemplo modificará (para simplificar los pasos a seguir) el report ya existente en el
WinCC por defecto, pero recomendamos crear un nuevo report (basándonos en este que nos
genera WinCC) y lo personalicemos completamente.
Necesitaremos un report y un layout asignado por cada gráfica o tabla diferente que
deseemos imprimir.

El report para imprimir una gráfica se denomina Report Tag Logging RT Curves y el
layout asignado a dicho report tlrtkur.rpl. Sin embargo, necesitaremos asignar a dicho layout la
gráfica que debe de mostrar, por lo que entramos en el mismo y sobre el objeto central tag-
logging runtime curve editando su conexión, modificamos:
• time selection: seleccionamos el intervalo de tiempo que debe de imprimirse.
• Archive data selection: seleccionamos el archivo y del mismo las curvas que deben
de imprimirse.
Guardamos los cambios, y en la picture GRAFICA.PDL incluimos un nuevo botón

IMPRIMIR al que asociamos el siguiente código:
RPTJobPreview("Report Tag Logging RT Curves"); //Return-Type :BOOL
Desde la ventana de previsualización se puede visualizar la gráfica antes de imprimirla

como muestra la figura:
Para las tablas de valores, utilizaremos el report Report Tag Logging RT Tables
asociado al layout tlrttab.rpl que deberemos también que asignar a un archivo, e indicar el
periodo de tiempo que deseamos que imprima. Asignamos el siguiente código a otro botón en
la ventana GRAFICA.PDL:

RPTJobPreview("Report Tag Logging RT Tables"); //Return-Type :BOOL
Con esto damos por concluida nuestra instalación demo, confiando en que junto con
los ejemplos básicos y avanzados vistos en los diferentes capítulos de este libro sirvan como
cimientos para la construcción de desarrollos de auténticas instalaciones que intenten
aprovechar al máximo las múltiples cualidades de este sistema de visualización.

15 APENDICE A
CONFIGURACIONES
DE WINCC

Ejemplo de aplicación Nº 1
WinCC Monopuesto Windows 95
Comunicación serie a PG-SS (Protocolo AS511)
Manual de WinCC en Ingles

6AV6392-1XA04-0AB0
Manual de ejemplos de WinCC en Ingles
6AV6392-1CA04-0AB0
Max. 1000m
SIMATIC S5-95/100/115/135/155U
WINCC - Ejemplos de configuraciones Edicion 01/02/99
 José Martínez Torres 1999 Página: 420/457

WinCC Monopuesto/ Windows 95
Serie 3964R (Protocolo RK512)

6AV6392-1XA04-0AB0
6AV6392-1CA04-0AB0
max. 1000m
• Procesador de comunicación CP 524 • Procesador de comunicación CP 544

6ES5524-3UA15 6ES5544-3UA11
• Modulo de interfase 752 / 20mA O • Modulo de interfase 752 / 20mA
6ES5752-0AA12 6ES5752-0AA12
• Memoria EPROM • Memoria Flash-EPROM
• 6ES5373-1AA61 6ES5374-2FH21
SIMATIC S5-115/135/155U

WinCC Monopuesto con Windows 95
con Protocolo MPI

6AV6392-1XA04-0AB0
• Tarjeta MPI CP5611 6AV6392-1CA04-0AB0
6GK1561-1AA00
SIMATIC MPI
SIMATIC S7-300
SIMATIC S7-400

SIMATIC NET PROFIBUS con protocolo S7

6AV6392-1XA04-0AB0
6AV6392-1CA04-0AB0
PROFIBUS SIMATIC NET
• CP 5412 (A2)
6GK1541-2BA00
• Software para S7-5412 (Windows95)
6GK1702-5CH41-3AA0
(a partir V 2.30)
SIMATIC NET PROFIBUS
SIMATIC NET, CP 443-5 • SIMATIC NET, CP 343-5 FMS/Funciones S7

• CP443-5 Básica 6GK7343-5FA00-0XE0
6GK7443-5FX00-0XE0 • NCM para PROFIBUS
• NCM para PROFIBUS 6GK7830-5BC03-0YA0
6GK7830-5BC03-0YA0
SIMATIC S7-300
SIMATIC S7-400

SIMATIC NET PROFIBUS FMS

• CP 5412 (A2) Manual de WinCC en Ingles
6GK1541-2BA00 6AV6392-1XA04-0AB0
• Software para FMS-5412/Win95
(a partir V2.50) Manual de ejemplos de WinCC en Ingles
6GK1702-5FH41-3AA0 6AV6392-1CA04-0AB0
• WinCC/FMS (Canal-DLL)
6AV6371-1CD03-1CX0
SIMATIC NET, CP 443-5 • SIMATIC NET, CP 5431 FMS/DP

• CP443-5 Básica 6GK1543-1AA01
6GK7443-5FX00-0XE0
NCM para PROFIBUS • COM 5431 FMS/DP
6GK7830-5BC03-0YA0 6GK1745-1AD01-0EA0
SIMATIC S7-400 SIMATIC S5-115/135/155U

SIMATIC NET PROFIBUS DP

• CP 5412 (A2)
6GK1541-2BA00
• Software para DP-5412/Windows 95 6AV6392-1XA04-0AB0
6GK1702 -5DH41-3AA0 Manual de ejemplos de WinCC en Ingles
6AV6392-1CA04-0AB0

Ethernet Industrial Nivel 4 (HTB) y TF
Ethernet (SINEC H1)
• S7-NET 1413/Windows 95 (a partir V 2.0)
6GK1141-3CH11 Manual de WinCC en Ingles
Comprende : 6AV6392-1XA04-0AB0
* Procesador de comunicaciones CP 1413
* Software para S5/TI505 Nivel 4 Manual de ejemplos de WinCC en Ingles
o 6AV6392-1CA04-0AB0
• TF-NET 1413/Windows 95 (a partir V 2.0)
- Solamente necesario para
comunicación S5TF
6GK1141-3TH11
Comprende:
* Software para funciones TF y S5/TI505 Nivel 4
Industrial Ethernet (SINEC H1)
SIMATIC NET, CP 1430 TF (Versión-básica)

Interfase SEND/RECEIVE
y Interfase TF
6GK1143-0TA02
SIMATIC S5-115/135/155U SIMATIC S5-115/135/155U

Ethernet Industrial con Protocolo S7

6AV6392-1XA04-0AB0
Industrial Ethernet (SINEC H1) Manual de ejemplos de WinCC en Ingles
• S7-NET 1413/Windows 95 (a partir V 2.0) 6AV6392-1CA04-0AB0
6GK1141-3CH11
comprende:
* Software para Funciones S7
Ethernet Industrial (SINEC H1)
SIMATIC NET, CP 443-1

SIMATIC NET, CP 343-1 con Funciones S7
Para Interfase SEND/RECEIVE
• 6GK7343-1BA00-0XE0
y Funciones S7
• NCM S7 para Ethernet Industrial
• 6GK7443-1BX00-0XE0
6GK7830-1BA01-0YA0
6GK7830-1BA01-0YA0 SIMATIC S7-300
SIMATIC S7-400

Ethernet Industrial con Protocolo TCP/IP
• CP 1411
•6GK1141-1AA00 Manual de WinCC en Ingles
•SOFT NET 8 Conexiones 6GK17041CW22-3AA0
•SOFTNET 64 Conexiones 6GK1704-1CX22-3AA0 6AV6392-1XA04-0AB0
6AV6392-1CA04-0AB0

SIMATIC NET, CP 343-1 con Funciones S7
Para Interfase SEND/RECEIVE
• 6GK7343-1BA00-0XE0
y Funciones S7
• 6GK7443-1BX00-0XE0 DM 2.900,-
6GK7830-1BA01-0YA0
6GK7830-1BA01-0YA0 DM 420,- SIMATIC S7-300
SIMATIC S7-400

SIMATIC NET Ethernet Industrial

• SR-NET 1413/Windows 95 (a partir V 2.0)
6GK1141-3RH01
comprende : Manual de WinCC en Ingles
* Procesador de Comunicaciones CP 1413 6AV6392-1XA04-0AB0
* Software para S5/TI505 nivel 4 Manual de ejemplos de WinCC en Ingles
o
• TF-NET 1413/Windows 95 (a partir V 2.0) 6AV6392-1CA04-0AB0
- solamente para comunicación S5TF
6GK1141-3TH11
Comprende:
* Software para Funciones TF y S5/TI505 Nivel 4
Ethernet Industrial(SINEC H1)
SIMATIC NET, CP 1434 L4 SIMATIC NET, CP 1430 TF(Versión Básica

para Interfase SEND/RECEIVE para Interfase SEND/RECEIVE
PPX:505-CP 1434TF y Interfase TF
6GK1143-0TA02
SIMATIC TI 505 SIMATIC S5-115/135/155U

WinCC Monopuesto Windows NT
Comunicación serie a PG-SS (Protocolo AS511)

6AV6392-1XA04-0AB0
6AV6392-1CA04-0AB0
Max. 1000m
SIMATIC S5-95/100/115/135/155U

WinCC Monopuesto/ Windows NT
Serie 3964R (Protocolo RK512)

6AV6392-1XA04-0AB0
6AV6392-1CA04-0AB0
max. 1000m
• Procesador de comunicación CP 524 • Procesador de comunicación CP 544

6ES5524-3UA15 6ES5544-3UA11
• Modulo de interfase 752 / 20mA O • Modulo de interfase 752 / 20mA
6ES5752-0AA12 6ES5752-0AA12
• Memoria EPROM • Memoria Flash-EPROM
• 6ES5373-1AA61 6ES5374-2FH21
SIMATIC S5-115/135/155U

WinCC Monopuesto con Windows 95/NT
con Protocolo MPI

6AV6392-1XA04-0AB0
• Tarjeta MPI CP5611 6AV6392-1CA04-0AB0
6GK1561-1AA00
Adaptador 6ES7901-2BF00-0AA0
SIMATIC MPI
SIMATIC S7-300
SIMATIC S7-400

WinCC Monopuesto con Windows NT
SIMATIC NET PROFIBUS con Protocolo S7

6AV6392-1XA04-0AB0
6AV6392-1CA04-0AB0
• CP 5412 (A2)
6GK1541-2BA00
Software para S7-5412 (Windows NT4.0)

6GK1702-5CB41-3AA0

6GK7830-5BC03-0YA0
SIMATIC S7-300
SIMATIC S7-400

SIMATIC NET PROFIBUS FMS

• CP 5412 (A2)
6GK1541-2BA00
• Software para FMS-5412/Windows 6AV6392-1XA04-0AB0
NT 4.0 (a partir V2.50) Manual de ejemplos de WinCC en Ingles
6GK1702-5FB41-3AA0
6AV6392-1CA04-0AB0
WinCC/FMS (Canal-DLL)
6AV6371-1CD03-1CX0

• CP 443-5 Básica 6GK1543-1AA01
6GK7443-5FX00-0XE0
6GK7830-5BC03-0YA0 6GK1745-1AD01-0EA0

SIMATIC NET PROFIBUS DP

• CP 5412 (A2)
6GK1541-2BA00
• Software para DP Windows NT 6AV6392-1XA04-0AB0
6GK1702-5DB41-3AA0 Manual de ejemplos de WinCC en Ingles
6AV6392-1CA04-0AB0

WinCC Monopuesto / Windows NT
Ethernet Industrial Nivel 4 (HTB) & TF
Ethernet (SINEC H1)
• S7-NET 1413/Windows NT4.0 (a partir V 3.30)
6GK1141-3CB11
Comprende: Manual de WinCC en Ingles
*Procesador de comunicación CP 1413
* Software para S5/TI505 Nivel 4 6AV6392-1XA04-0AB0
o Manual de ejemplos de WinCC en Ingles
• TF-NET 1413/Windows NT4.0 (a partir V 3.10)
- solamente necesario para comunicación S5 TF 6AV6392-1CA04-0AB0
6GK1141-3TB11
Comprende:
* Procesador de comunicación CP 1413
* Software para Funciones TF y S5/TI505 Nivel 4
SIMATIC NET, CP 1430 TF( Versión Básica)

Para interfase SEND/RECEIVE y TF
6GK1143-0TA02
SIMATIC S5-115/135/155U SIMATIC S5-115/135/155U

Ethernet Industrial con Protocolo S7

6AV6392-1XA04-0AB0
• S7-NET 1413/Windows NT 4.0 (a partir V 3.30) Manual de ejemplos de WinCC en Ingles
6GK1141-3CB11 6AV6392-1CA04-0AB0
Comprende:
* procesador de comunicaciones CP 1413
* Software para Funciones S7

para Interfase SEND/RECEIVE SIMATIC NET, CP 343-1 con Funciones S7
y Funciones S7 • 6GK7343-1BA00-0XE0
• 6GK7443-1BX00-0XE0 • NCM S7 para Ethernet Industrial
• NCM S7 para Ethernet Industrial 6GK7830-1BA01-0YA0
SIMATIC S7-400


Ethernet Industrial con Protocolo TCP/IP
• CP 1411
•6GK1141-1AA00 Manual de WinCC en Ingles
•SOFT NET 8 Conexiones 6GK17041CW22-3AA0
•SOFTNET 64 Conexiones 6GK1704-1CX22-3AA0 6AV6392-1XA04-0AB0
6AV6392-1CA04-0AB0

para Interfase SEND/RECEIVE SIMATIC NET, CP 343-1 con Funciones S7
y Funciones S7 • 6GK7343-1BA00-0XE0
• 6GK7443-1BX00-0XE0 • NCM S7 para Ethernet Industrial
• NCM S7 para Ethernet Industrial 6GK7830-1BA01-0YA0
SIMATIC S7-400

SIMATIC NET Ethernet Industrial
• SR-NET 1413/Windows NT 4.0 (a partir V 3.30)
6GK1141-3CB11
comprende: Manual de WinCC en Ingles
* Procesador de comunicaciones CP 1413 6AV6392-1XA04-0AB0
* Software para S5/TI505 nivel 4 Manual de ejemplos de WinCC en Ingles
o
• TF-NET 1413/Windows NT 4.0 (ab V 3.10) 6AV6392-1CA04-0AB0
- Solamente necesario para comunicación S5TF
6GK1141-3TB11
Comprende:
* Software para Funciones TF S5/TI505
SIMATIC NET, CP 1434 L4 SIMATIC NET, CP 1430 TF(Versión Básica)

para Interfase SEND/RECEIVE Para Interfase SEND/RECEIVE
y interfase TF
PPX:505-CP 1434TF
6GK1143-0TA02

SIMATIC HMI
WinCC Multipuesto, Server con Visualización
y Ethernet Industrial (SINEC H1) protocolo S7
Estación de operador WinCC Server max. 4
C WinCC C
S
+ Windows NT4.0
+ 64 MB- Cliente
+WinCC RC o RT
+Opción Server
6AV6371-1CA03-0AX0
+Conexión a TCP/IP TCP/IP
NetBEUI
Bus de Terminales
Estación de Operador WinCC Cliente
con (como mínimo) licencia Run timel RT 128 Variables
•Windows95 o Windows NT
+Conexión a TCP/IP
• S7-NET 1413/Windows NT V 4.0 (a partir V3.30)
6GK1141-3CB11
Comprende:
+ Procesador de comunicaciones CP 1413
* Software para Funciones S7 (6GK1701-1CB41-3AA0)
SIMATIC NET, CP 443-1 SIMATIC NET, CP 343-1 con Funciones S7

para Interfase SEND/RECEIVE • 6GK7343-1BA00-0XE0
y Funciones S7 • NCM S7 para Ethernet Industrial
• 6GK7443-1BX00-0XE0 6GK7830-1BA01-0YA0
SIMATIC S7-400 6GK7830-1BA01-0YA0 SIMATIC S7-300

SIMATIC HMI
y Ethernet Industrial (SINEC H1) Nivel 4 y Nivel 7 (S5)
Estación de operador WinCC Server
C WinCC C
S
+ Windows NT4.0
+ 64 MB- Cliente
+WinCC RC o RT
+Opción Server
6AV6371-1CA03-0AX0
NetBEUI
Bus de Terminales
TF
• TF-NET 1413/Windows NT 4.0 (ab V 3.10)
- Solamente necesario para comunicación S5TF
o S/R
•Windows95 o Windows NT
+Conexión a TCP/IP
• SR-NET 1413/Windows NT 4.0 (a partir V 3.30)
6GK1141-3TB01
Comprende: 6GK1141-3CB11
comprende:
* Software para Funciones TF S5/TI505 Nivel 4 * Procesador de comunicaciones CP 1413
* Software para S5/TI505 nivel 7
SIMATIC NET, CP 1434 L4 SIMATIC NET, CP 1430 TF(Versión Básica)

para Interfase SEND/RECEIVE Para Interfase SEND/RECEIVE
y interfase TF
PPX:505-CP 1434TF
6GK1143-0TA02

SIMATIC HMI
y Profibus (SINEC L2) protocolo S7
C WinCC C
S
+ Windows NT4.0
+ 64 MB- Cliente
+WinCC RC o RT
+Opción Server
6AV6371-1CA03-0AX0
NetBEUI
Bus de Terminales
Estación de Operador Wincc Cliente
PROFIBUS SIMATIC NET con (como mínimo) licencia Run timel RT 128 Variables
• CP 5412 (A2) •Windows95 o Windows NT
6GK1541-2BA00 +Conexión a TCP/IP
Software para S7-5412 (Windows NT4.0)
6GK1702-5CB41-3AA0
(a partir V 2.01)

6GK7830-5BC03-0YA0
SIMATIC S7-300
SIMATIC S7-400

SIMATIC HMI
y Profibus (SINEC L2) protocolo FMS (S5 y S7)
C WinCC C
S
+ Windows NT4.0
+ 64 MB- Client
+WinCC RC o RT
+Opción Server
6AV6371-1CA03-0AX0
WinCC/FMS (Canal-DLL)
NetBEUI
6AV6371-1CD03-1CX0 Bus de Terminales
PROFIBUS SIMATIC NET •Windows95 o Windows NT
• CP 5412 (A2) +Conexión a TCP/IP
GK1541-2BA00
• Software para FMS-5412/Windows
NT 4.0 (a partir V2.50)
GK1702-5FB41-3AA0

• CP 443-5 Básica 6GK1543-1AA01
6GK7443-5FX00-0XE0
6GK7830-5BC03-0YA0 6GK1745-1AD01-0EA0

Manual WinCC V4.02 Apéndice B: Canales
16 APENDICE B
CANALES DE
COMUNICACIONES

CANAL AS 511
El canal AS 511 implementa el protocolo de comunicaciones que poseen los PLC’s de
la serie S5 en el puerto de programación de las CPU’s.
• Podemos definir diferentes puertos para cada uno de los enlaces S5 que deseemos
realizar.
• La velocidad de transferencia vendrá limitada a 9600 baudios.
• El cable de comunicaciones de S5 nos servirá para realizar el enlace entre el PLC y el
WinCC.
Una particularidad de este canal de comunicaciones, debida a que viene implementada en

el protocolo AS 511, es que al definir la variable de comunicaciones podemos:
• Asignarla a una variable de tipo PLC: en este caso, la variable deberá ser de tipo texto de
al menos 23 caracteres, y almacenará el tipo de CPU con la que nos estamos conectando
(p. Ej. S5 95U).
• Asignarla a una variable de tipo Status: en este caso la variable deberá ser de tipo BOOL, y
valdrá 0 cuando el PLC esté en stop y 1 cuando el PLC esté en run.
• Asignarla a una variable de datos: como normalmente asignamos las variables a la
memoria del PLC (marcas, entradas, etc..)

SIMATIC S5 Serial 3964R.

Mediante el 3964R podemos comunicar con cualquier CPU de S5 a través de su
correspondiente tarjeta de comunicaciones, dejando libre el puerto de comunicaciones de la
CPU. Esta solución es necesaria cuando ya existe una OP conectada al puerto de la CPU, o
cuando no es viable desconectar el sistema Scada cada vez que se deba realizar una
modificación en el programa del PLC.
Al igual que con AS 511 podemos definir el puerto por el que vamos a comunicarnos,
sin embargo al poder elegir comunicación RS232 podemos aumentar la velocidad de
comunicaciones.
También podemos configurar el tiempo de espera antes de generar error de
comunicaciones y el tipo de protocolo entre 3964 y 3964R.

SIMATIC S7 PROFIBUS.
Para realizar una conexión en Profibús, necesitamos disponer de una tarjeta de
comunicaciones para Profibús y de su correspondiente driver de comunicaciones
implementado.
En la ventana de Device deberemos de seleccionar el dispositivo lógico que debe de
haber sido definido al parametrizar el driver de la tarjeta.

SIPART DR.
Podemos definir una red de reguladores Sipart que dispongan de la tarjeta serie, para
que WinCC a través de uno de sus puertos pueda leer los valores de los mismos, y modificar
cualquier valor a través de dicho puerto.
Tan solo deberemos de parametrizar el puerto de comunicaciones de acuerdo a

nuestra conexión serie.

Cuando generemos una nueva conexión deberemos de definir el tipo de regulador al

que nos vamos a conectar y el número de estación dentro de la red del regulador (que deberá
coincidir con el programado dentro de la estructura del regulador).
Una vez creado el enlace, podemos generar variables de comunicaciones, con la

particularidad de que en lugar de acceder a la memoria del PLC, estaremos definiendo enlaces
con estructuras del regulador, como muestra la figura inferior:
PROFIBUS FMS.
A la hora de realizar una red de PLC’s la opción más frecuente es la utilización de
Profibús FMS, que integra tanto S5 como S7 en la misma red.
Para poder conectar el WinCC, deberemos tener primeramente la tarjeta de
comunicaciones con su driver correspondiente integrado.
Dicho driver nos genera un nombre de conexión. Los enlaces de dicha conexión
podremos definirlos en esta pantalla, de tal manera que estaremos a través del driver
accediendo al PLC en cuestión.

OMRON SERIE C.
Además de los propios autómatas de Siemens, WinCC dispone de drivers opcionales
para comunicarse con otros PLC’s del mercado. El driver para los autómatas de Omron
(CQM1, CPM1 y C200H) se encuentra en WinCC en forma de add-on.
Las únicas particularidades del driver se basan en definir el puerto de comunicaciones
por el que vamos a enlazar con el PLC.
En la solapa HostLink Options definiremos si deseamos realizar un enlace punto a
punto o en formato HostLink (en red) en cuyo caso seleccionaremos el participante al que
estamos accediendo por este enlace que configuramos.


GE FANUC.
Otro autómata del mercado son los Fanuc de General Electric. Mediante este driver se
pueden realizar hasta 4 enlaces diferentes (uno por cada puerto del PC) en acoplamiento punto
a punto.
En la ventana system parameters podemos definir las características del enlace.

A partir de ese momento, las variables que realicemos en el mismo accederán a la
memoria del PLC de Fanuc.

Manual WinCC V4.02 Indice temático
17 APENDICE C INDICE TEMATICO:
A D
Actions, 262 Data Types, 80

Alarm Logging, 151 Dbase III, 206
Alarmas analógicas, 190 Diagnose, 35
alineación, 105 Dinamización, 145
Apdiag.exe, 35 driver, 69
Apitest.exe, 36 DynWizEdit.exe, 39
Archivar alarmas, 193
Archive Wizard, 210 E
archives, 210
asistente de alarmas, 154 Escalado de variables, 77
Asistentes, 138 estilos, 106
estructura, 81
B Exportar mensajes, 158
Bar, 115 F
Barra de estado, 82
Barras de herramientas, 103 fuentes, 106
Biblioteca de objetos, 94 Full Screen, 67
Bin, 35
Buttons, 129 G
C global script, 261

GraCS, 42
CCAuthorInformation.EXE, 37 Graphic Object, 124
CCConvert.exe, 38 Graphics designer, 85
CcMetaViewRt.exe, 38 group, 73
CCProjectDuplicator.exe, 38 Group objects, 86
Check box, 132 Guía de iniciación rápida, 16
Clases, 186 GUID, 57
computer, 60
conexión, 71 H
Configuration Dialog, 86
Control Center, 46 Hotkeys, 59
Customize object, 86
Cyberlogic Chanel Driver, 15

PC Adapter, 70
I
Presettings, 221
I/O Field, 107 Print FeedBack Doc.., 53
Idioma, 102 Project functions, 261
Idioma del Control Center, 54 Properties, 86
Idiomas, 248 Prt, 43

Importar mensajes, 158
Instalación de WinCC: subentrada, 13 R
Internal Functions, 262
internal tags, 78 registro, 17
report designer, 274
Round, 137
J
Job, 275 S
Settings, 99
L
Shut Down, 53
layers, 105 simulador, 25
Layout, 275 Slider, 135

Library, 42 Smart Objects, 104
límites en variables, 76 SQL AnyWhere, 52
Line printer layout, 275 Standard Functions, 262

Login, 254 Startup, 63
Status, 55
Status display, 126
M
Message blocks, 163 T

Message Classes, 186
message line format, 175 table window, 240
Message Window, 176 tag, 74

tag logging, 205
Tag Management, 69
N
Tamaño de las variables, 78
Notas de instalación, 15 Text Library, 247
nuevo proyecto, 47 Text list, 128
Tips&Tricks, 85
trends, 224
O
trigger, 266
Option button, 134
U
P
Update cycles, 58
Pas, 43 User Administrator, 253
Password, 254

Windows Objects, 104

W
Wunload.exe, 40

Siemens Manual WinCC PDF

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Siemens Manual WinCC PDF

Hochgeladen von

Copyright:

Verfügbare Formate

Siemens Productos y

 Siemens P.S. 1999 Página: 1/457

Página: 2/457  Siemens P.S. 1999

5.5.2 I/O Field...............................................................................................................107

 Siemens P.S. 1999 Página: 3/457

6.5.6 Número de la alarma ...........................................................................................167

Página: 4/457  Siemens P.S. 1999

7.6 Curvas de valores ...................................................................................................224

 Siemens P.S. 1999 Página: 5/457

11.3.2 Propiedades del layout .....................................................................................278

Página: 6/457  Siemens P.S. 1999

13.4 Ayuda en sus aplicaciones ......................................................................................345

 Siemens P.S. 1999 Página: 7/457

14.2 Control de usuarios .................................................................................................401

Página: 8/457  Siemens P.S. 1999

 Siemens P.S. 1999 Página: 9/457

ü Arquitectura de desarrollo abierta (programación en C)

Siemens Productos y Sistemas.

1 Scada: Sistema de visualización y control para procesos industriales desde PC.

Página: 10/457  Siemens P.S. 1999

 Siemens P.S. 1999 Página: 11/457

Página: 12/457  Siemens P.S. 1999

2.1 Instalación de WinCC V4.02

No puede instalar el WinCC en Windows 3.x

 Siemens P.S. 1999 Página: 13/457

2.2 Primeros pasos de instalación

Página: 14/457  Siemens P.S. 1999

2.2.1 Pestaña Seleccionar opción instalación:

Nos permite seleccionar la aplicación a instalar, desplegando la solapa como muestra

• Cyberlogic Chanel Driver: canal específico de comunicaciones (versión demo).

2.2.2 Botón Instalar aplicaciones:

Este botón nos permite instalar el software seleccionado anteriormente.

2.2.3 Botón Notas de instalación:

Fichero en Word sobre las peculiaridades de la instalación.

2.2.4 Botón Diapositivas Powerpoint

Algunas imágenes en las que se explica las características técnicas y de

 Siemens P.S. 1999 Página: 15/457

2.2.5 Botón Guía de iniciación rápida

2.2.6 Botón Instalar Simulador de Variables

2.2.7 Botón Cambio de idioma:

2.2.8 Botón Salir de la instalación:

Con este botón se sale de la instalación de WinCC

Suponemos que ya tenemos instalado Internet Explorer en nuestro ordenador, por lo

Página: 16/457  Siemens P.S. 1999

Figura 1: Número de identificación del software de desarrollo.

En la pantalla de registro, si no se dispone de autorización para desarrollar aplicaciones

 Siemens P.S. 1999 Página: 17/457

Figura 2 : Idioma del software y ruta de instalación.

• Típica: Se instalan los componentes habituales de WinCC.

Página: 18/457  Siemens P.S. 1999

Figura 3 : Tipos de instalación.

Seleccionamos la opción User defined y las opciones disponibles son:

Seleccionamos las opciones WinCC, Help, Options y Comunication (compruebe

 Siemens P.S. 1999 Página: 19/457

Figura 4: Instalación personalizada del WinCC.

A continuación se nos consulta sobre el modo de optimizar la base de datos que

Figura 5: Optimización de la base de datos Sybase SQL.

Página: 20/457  Siemens P.S. 1999

Figura 6: Llaves de autorización.

Lo siguiente que se nos pide es la introducción de la correspondiente autorización de

 Siemens P.S. 1999 Página: 21/457

Figura 7: Finalización de la instalación de WinCC.

Si la instalación ha sido satisfactoria, deberá aparecer una pantalla como la siguiente