RTUQM 28 - Módulo Lógicas V2 - 0 PDF

Sistema RTUQM
Módulo Lógicas
Versión 2.0
1 IDENTIFICACIÓN ................................................................................................................................................. 5
2 DESCRIPCIÓN GENERAL................................................................................................................................... 5
3 DESCRIPCIÓN DEL FUNCIONAMIENTO ....................................................................................................... 6

3.1 CICLO DE TRABAJO ............................................................................................................................................. 6
4 VARIABLES............................................................................................................................................................ 7
4.1 PERSISTENCIA DE VARIABLES ........................................................................................................................... 10
4.2 REPRESENTACIÓN GRÁFICA .............................................................................................................................. 10
4.2.1 Variables externas de valor ..................................................................................................................... 12
4.2.2 Variables externas de comando............................................................................................................... 13
4.2.3 Variables internas y constantes ............................................................................................................... 14
4.3 VARIABLES EXTERNAS ..................................................................................................................................... 15
4.3.1 Tipos de punto de la base de datos.......................................................................................................... 15
4.3.2 Variables de entrada ............................................................................................................................... 15
4.3.2.1 Buffer de puntos de entrada .................................................................................................................................. 16
4.3.2.2 Campos de las estructuras externas de entrada de valor de BD ............................................................................ 17
4.3.2.3 Campos de las estructuras externas de entrada de comando de BD ...................................................................... 17
4.3.3 Variables de salida .................................................................................................................................. 18
4.3.3.1 Campos de las estructuras externas de salida de valor de BD ............................................................................... 18
4.3.3.2 Campos de las estructuras externas de salida de comando de BD......................................................................... 19
4.3.4 Flujo de información ............................................................................................................................... 19
4.4 VARIABLES DEL SISTEMA ................................................................................................................................. 20
4.4.1 Variable $SysInfo .................................................................................................................................... 20
4.4.2 Variable $Time ........................................................................................................................................ 21
5 FUNCIONAMIENTO ........................................................................................................................................... 22
5.1 PROGRAMAS..................................................................................................................................................... 22
5.1.1 Restricciones para los programas diagramables .................................................................................... 24
5.1.1.1 Restricciones en la utilización de funciones ......................................................................................................... 25
5.1.1.2 Restricciones en la utilización de bloques funcionales ......................................................................................... 25
5.1.1.3 Restricciones en la utilización de sentencias......................................................................................................... 26
5.2 FUNCIONES....................................................................................................................................................... 27
5.2.1 Funciones del usuario ............................................................................................................................. 28
RTUQM, Módulo Lógicas

RTUQM 28 - Módulo Lógicas V2_0.doc 1/109 08/01/a
CONTROLES S. A. AVENIDA RIVERA 3314

11300 MONTEVIDEO, URUGUAY
TEL (+598) 2622 0651
ELECTRÓNICA INDUSTRIAL Y TELECOMUNICACIONES
FAX (+598) 2622 2048
E-MAIL info@controles.com
5.2.1.1 Ejemplo SUMA .................................................................................................................................................... 29
5.3 BLOQUES FUNCIONALES ................................................................................................................................... 30
5.3.1 Bloques funcionales del usuario .............................................................................................................. 31
5.3.1.1 Ejemplo BLINK .................................................................................................................................................... 32
5.4 OPERANDOS DE ENTRADA ................................................................................................................................ 34
5.5 OPERANDOS DE SALIDA .................................................................................................................................... 34
5.6 TRATAMIENTO DE ERRORES ............................................................................................................................. 34
5.6.1 Errores de ejecución................................................................................................................................ 34
5.7 MODOS DE FUNCIONAMIENTO .......................................................................................................................... 35
5.7.1 Modo DEBUG-CICLO-A-CICLO ........................................................................................................... 36
5.7.2 Comandos del PLC .................................................................................................................................. 36
6 LENGUAJE DE PROGRAMACIÓN.................................................................................................................. 38
6.1 IDENTIFICADORES............................................................................................................................................. 38
6.2 COMENTARIOS ................................................................................................................................................. 38
6.3 REPRESENTACIÓN LITERAL DE DATOS .............................................................................................................. 39
6.3.1 Literales numéricos ................................................................................................................................. 39
6.3.2 Literales booleanos ................................................................................................................................. 40
6.3.3 Literales de string .................................................................................................................................... 40
6.3.4 Literales de duración............................................................................................................................... 41
6.3.5 Literales de fecha y hora (o marca de tiempo) ........................................................................................ 41
6.4 TIPOS DE DATOS ELEMENTALES ........................................................................................................................ 41
6.5 TIPOS DE DATOS DERIVADOS ............................................................................................................................ 43
6.5.1 Arrays ...................................................................................................................................................... 44
6.6 TIPOS DE DATOS GENÉRICOS ............................................................................................................................. 46
6.7 FUNCIONES DEL SISTEMA ................................................................................................................................. 46
6.7.1 Funciones de conversión de tipo ............................................................................................................. 46
6.7.2 Funciones numéricas ............................................................................................................................... 48
6.7.3 Funciones de selección ............................................................................................................................ 48
6.7.4 Funciones de strings ................................................................................................................................ 49
6.7.5 Funciones de tiempo ................................................................................................................................ 50
6.7.6 Funciones auxiliares ............................................................................................................................... 51
6.8 EXPRESIONES ................................................................................................................................................... 52
6.8.1 Operador LABEL .................................................................................................................................... 53
6.9 SENTENCIAS ..................................................................................................................................................... 53
6.9.1 Sentencia vacía ........................................................................................................................................ 53
6.9.2 Sentencia de asignación .......................................................................................................................... 54
6.9.3 Sentencia HEADER ................................................................................................................................. 55
6.9.4 Sentencia IF............................................................................................................................................. 57
6.9.5 Sentencia CASE ....................................................................................................................................... 58
6.9.6 Sentencia RETURN ................................................................................................................................. 59
6.9.7 Sentencias de iteración ............................................................................................................................ 60
6.9.7.1 Sentencia FOR ...................................................................................................................................................... 60
6.9.7.2 Sentencia WHILE ................................................................................................................................................. 61
6.9.7.3 Sentencia REPEAT ............................................................................................................................................... 62
6.9.7.4 Sentencia EXIT ..................................................................................................................................................... 62
6.9.8 Sentencia de evaluación de un bloque funcional .................................................................................... 63
6.9.9 Sentencia TRACE .................................................................................................................................... 64
7 BLOQUES FUNCIONALES DEL SISTEMA .................................................................................................... 67


TEL (+598) 2622 0651
FAX (+598) 2622 2048
7.1 BLINK – PARPADEO ........................................................................................................................................ 67
7.2 TP – TEMPORIZADOR DE PULSO ....................................................................................................................... 69
7.3 TON – TEMPORIZADOR DE RETARDO AL ENCENDIDO ....................................................................................... 72
7.4 TOF – TEMPORIZADOR DE RETARDO AL APAGADO........................................................................................... 74
7.5 R_TRIG – DETECTOR DE FLANCO ASCENDENTE .............................................................................................. 76
7.6 F_TRIG – DETECTOR DE FLANCO DESCENDENTE............................................................................................. 78
7.7 RF_TRIG – DETECTOR DE FLANCOS ................................................................................................................ 79
7.8 CTU – CONTADOR ASCENDENTE...................................................................................................................... 80
7.9 CTD – CONTADOR DESCENDENTE.................................................................................................................... 82
7.10 CTUD – CONTADOR ASCENDENTE-DESCENDENTE ........................................................................................... 83
7.11 SR – BIESTABLE CON ENTRADA DOMINANTE SET ............................................................................................. 85
7.12 RS – BIESTABLE CON ENTRADA DOMINANTE RESET ......................................................................................... 87
7.13 GET_DATE_AND_TIME .............................................................................................................................. 88
8 VISUALIZADOR DE LÓGICAS ........................................................................................................................ 92
8.1 PARÁMETROS DE LA LÍNEA DE COMANDOS ....................................................................................................... 92
9 PARÁMETROS DE LA LÍNEA DE COMANDOS ........................................................................................... 93
10 CONFIGURACIÓN .......................................................................................................................................... 93
10.1 PARÁMETROS DE CONFIGURACIÓN ................................................................................................................... 93
10.1.1 Carpeta General ...................................................................................................................................... 93
10.1.2 Estructuras .............................................................................................................................................. 94
10.1.3 Arrays ...................................................................................................................................................... 94
10.1.4 Variables Globales .................................................................................................................................. 94
10.1.5 Programas ............................................................................................................................................... 94
10.1.6 Bloques Funcionales ............................................................................................................................... 94
10.1.7 Funciones ................................................................................................................................................ 94
10.1.8 Carpeta Archivo INI ................................................................................................................................ 94
10.2 IMPORTACIÓN/EXPORTACIÓN ........................................................................................................................... 94
11 PUNTOS DE SUPERVISIÓN .......................................................................................................................... 95
12 OPCIONES DE ADMINISTRACIÓN DEL PROGRAMA DE TERMINAL ............................................. 96

12.1 CARPETA INFORMACIÓN GENERAL ................................................................................................................... 96
12.2 CARPETA VARIABLES ....................................................................................................................................... 96
12.3 CARPETA TRACE .............................................................................................................................................. 96
12.4 CARPETA DEBUG.............................................................................................................................................. 96
12.5 COMANDOS DEL PLC ....................................................................................................................................... 96
13 COMANDOS DE TERMINAL ........................................................................................................................ 96
13.1 COMANDOS COMUNES A TODOS LOS MÓDULOS ................................................................................................ 96
13.2 COMANDOS PARTICULARES DEL MÓDULO LÓGICAS .......................................................................................... 96
14 ANEXO A – EJEMPLOS DE BLOQUES FUNCIONALES ......................................................................... 98
14.1 BLINK_USR – PARPADEO .............................................................................................................................. 98
14.2 TP_USR – TEMPORIZADOR DE PULSO .............................................................................................................. 99
14.3 TON_USR – TEMPORIZADOR DE RETARDO AL ENCENDIDO ........................................................................... 101
14.4 TOF_USR – TEMPORIZADOR DE RETARDO AL APAGADO ............................................................................... 102


TEL (+598) 2622 0651
FAX (+598) 2622 2048
14.5 R_TRIG_USR – DETECTOR DE FLANCO ASCENDENTE .................................................................................. 104
14.6 F_TRIG_USR – DETECTOR DE FLANCO DESCENDENTE ................................................................................. 104
14.7 RF_TRIG_USR – DETECTOR DE FLANCOS .................................................................................................... 105
14.8 CTU_USR – CONTADOR ASCENDENTE .......................................................................................................... 106
14.9 CTD_USR – CONTADOR DESCENDENTE ........................................................................................................ 106
14.10 CTUD_USR – CONTADOR ASCENDENTE-DESCENDENTE ........................................................................... 107
14.11 SR_USR – BIESTABLE CON ENTRADA DOMINANTE SET.............................................................................. 108
14.12 RS_USR – BIESTABLE CON ENTRADA DOMINANTE RESET ......................................................................... 109


TEL (+598) 2622 0651
FAX (+598) 2622 2048
1 Identificación
Nombre del módulo: Módulo Lógicas
Tipo: MODULO_LOGICAS
Ejecutable: logicas
Versión: 3.0
Fecha: 08/01/2015
Versión del documento: 2.0

Fecha 08/01/2015
2 Descripción General
El módulo logicas es un módulo del sistema RTUQM que implementa la funcionalidad de lógica local dentro
de la RTU utilizando el lenguaje ST (Structured Text) de la norma IEC 61131-3 second edition 2003-01.
El módulo lógicas interactúa directamente con el módulo base de datos según se describe más adelante.
Se dispone además de un visualizador grafico que permite mostrar el estado interno del módulo en tiempo
real, dicho visualizador se ejecuta sobre la plataforma Windows.
El sistema RTUQM permite la ejecución de varias instancias del módulo lógicas concurrentemente pero el
sistema limita que exista una única instancia del módulo por archivo de configuración. A estos efectos se
agrega una entrada por archivo de configuración en el directorio “rtuqm/locks”. Si el módulo al arrancar
detecta que ya existe otra instancia ejecutándose con la misma configuración, termina en forma inmediata.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
3 Descripción del funcionamiento
3.1 Ciclo de trabajo

El módulo lee desde la base de datos un conjunto de puntos llamados variables de entrada, realiza cálculos
sobre los mismos y escribe en la base de datos un conjunto de puntos resultados llamados variables de
salida. Además de las variables de entrada y de salida pueden definirse un conjunto de variables internas al
módulo. Estas se utilizan para almacenar cálculos intermedios.
Un subconjunto configurable por el usuario de las variables internas puede definirse como persistente. Esto
implica que los valores almacenados son salvados a memoria no volátil y son recordados aunque la RTU
sea apagada.
El ciclo de trabajo del módulo se detalla en el siguiente diagrama:
Puntos de Entrada Variables

Internas
Máquina de
Cálculo
Puntos de Salida
Este ciclo se realiza periódicamente. El período puede ser configurado por el usuario o puede hacerse tan
rápidamente como la capacidad de la CPU lo permita.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
4 Variables
El módulo realiza sus cálculos con variables. Las mismas pueden obtenerse desde puntos de base de
datos de la RTU o ser internas al módulo. A continuación se resumen todos los tipos de datos soportados
por el PLC para la definición de variables.
• Tipos de datos externos: Corresponde a las estructuras predefinidas por el sistema para manejar
variables de entrada o de salida del PLC que estén asociadas a puntos de BD.
o Tipos externos de entrada del PLC

Tipos de entrada de valor: Corresponden a valores recibidos desde puntos de entrada
de BD.
• Entrada Valor DINT desde BD:EI: Variable DINT cuyo valor se obtiene desde
un punto de Entrada Int de BD
• Entrada Valor LREAL desde BD:EF: Variable LREAL cuyo valor se obtiene
desde un punto de Entrada Float de BD
• Entrada Valor BOOL desde BD:EB: Variable BOOL cuyo valor se obtiene
desde un punto de Entrada Bool de BD
• Entrada Valor STRING desde BD:ES: Variable STRING cuyo valor se obtiene
desde un punto de Entrada String de BD
Tipos de entrada de comando: Corresponden a comandos recibidos desde puntos de

salida de BD.
• Entrada Comando DINT desde BD:SI: Comando DINT recibido desde un

punto de Salida Int de BD
• Entrada Comando LREAL desde BD:SF: Comando LREAL recibido desde un
punto de Salida Float de BD
• Entrada Comando BOOL desde BD:SB: Comando BOOL recibido desde un
punto de Salida Bool de BD
• Entrada Comando STRING desde BD:SS: Comando STRING recibido desde
un punto de Salida String de BD
o Tipos externos de salida del PLC

Tipos de salida de valor: Corresponden a valores exportados hacia puntos de entrada
de BD.
• Salida Valor DINT hacia BD:EI: Variable DINT cuyo valor se exporta hacia un
punto de Entrada Int de BD
• Salida Valor LREAL hacia BD:EF: Variable LREAL cuyo valor se exporta
hacia un punto de Entrada Float de BD
• Salida Valor BOOL hacia BD:EB: Variable BOOL cuyo valor se exporta hacia
un punto de Entrada Bool de BD
• Salida Valor STRING hacia BD:ES: Variable STRING cuyo valor se exporta
hacia un punto de Entrada String de BD


TEL (+598) 2622 0651
FAX (+598) 2622 2048
Tipos de salida de comando: Corresponden a comandos realizados sobre puntos de
salida de BD.
• Salida Comando DINT hacia BD:SI: Comando DINT realizado sobre un punto
de Salida Int de BD
• Salida Comando LREAL hacia BD:SF: Comando LREAL realizado sobre un
punto de Salida Float de BD
• Salida Comando BOOL hacia BD:SB: Comando BOOL realizado sobre un
punto de Salida Bool de BD
• Salida Comando STRING hacia BD:SS: Comando STRING realizado sobre
un punto de Salida String de BD
• Tipos simples: Corresponden a valores de tipos de datos simples o elementales.

o DINT
o LREAL
o BOOL
o STRING
o TIME
o DATE_AND_TIME
• Constantes: Permiten utilizar valores constantes mediante nombres.

o Constante DINT
o Constante LREAL
o Constante BOOL
o Constante STRING
o Constante TIME
o Constante DATE_AND_TIME
• Bloques funcionales del sistema: Corresponden a todos los bloques funcionales predefinidos por el
sistema.
o CTU - Contador ascendente
o CTD - Contador descendente
o CTUD - Contador ascendente/descendente
o TP - Temporizador de pulso
o TON - Temporizador de cierre
o TOF - Temporizador de apertura
o BLINK - Temporizador de pulsos repetitivos
o R_TRIG - Detector de flanco ascendente
o F_TRIG - Detector de flanco descendente
o RF_TRIG - Detector de flancos
o SR - Biestable set dominante
o RS - Biestable reset dominante
o GET_DATE_AND_TIME
• Bloques funcionales del usuario: Corresponden a todos los bloques funcionales definidos por el usuario.
• Estructuras del usuario: Corresponden a las estructuras definidas por el usuario.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
• Arrays del usuario: Corresponden a los tipos de datos arrays definidos por el usuario.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
4.1 Persistencia de variables
Las variables internas, es decir no asociadas a puntos de base de datos, pueden definirse como
persistentes. Las variables persistentes mantienen su valor entre ejecuciones del PLC. Sólo las variables
globales y las variables internas de los programas pueden definirse como persistentes. Las variables
persistentes pueden ser de cualquiera de los tipos de datos soportados, tanto elementales como derivados,
pero no pueden ser constantes.
El estado de las variables persistentes se mantiene en disco en el archivo XML

“/rtuqm/state/<config>_variables.xml”, donde “<config>” indica el nombre del archivo de configuración
del módulo. Por ejemplo, si el archivo de configuración del módulo es “logicas.ini” entonces el archivo de
variables persistentes será “/rtuqm/state/logicas_variables.xml”.
Cada vez que el estado de alguna de las variables persistentes cambia se actualiza el archivo de variables
persistentes. Pero por razones de eficiencia, esta actualización no se realiza inmediatamente sino que
periódicamente cada cinco minutos se verifica si hay cambios pendientes y de ser así se actualiza el
archivo completo con el estado de todas las variables persistentes. El archivo también se actualiza, de ser
necesario, cada vez que se detiene el PLC.
NOTAS
1. El nuevo archivo XML de persistencia se empezó a utilizar a partir de la versión 3.0 del módulo. Las
versiones anteriores utilizaban un archivo de persistencia tipo INI de nombre
“/rtuqm/state/<config>_variables.ini”, el cual sólo soportaba variables persistentes de tipos de
datos simples o elementales.
2. Para las versiones de QNX anteriores a la 6.5.0, la librería de XML no está soportada, por lo cual se
sigue utilizando el viejo archivo de persistencia tipo INI y por lo tanto sólo se soportan variables
persistentes de tipos de datos simples o elementales. En el caso de que la configuración contenga
alguna variable persistente de tipo de dato derivado, se genera un error indicando la situación y no
se permite arrancar el PLC.
4.2 Representación gráfica

Los distintos tipos de variables se representan gráficamente en los diagramas teniendo en cuenta dos
parámetros: la forma y el color del elemento gráfico.
Las formas utilizadas dependiendo del tipo de variable son las siguientes:


TEL (+598) 2622 0651
FAX (+598) 2622 2048
Variable Externa de Valor
Variable Externa de Comando
Constante
Variable del Sistema
Variable Interna
Campo de Bloque Funcional
Los colores utilizados dependiendo del tipo de valor de las variables son los siguientes:
DATE_AND_
DINT LREAL BOOL STRING TIME
TIME


TEL (+598) 2622 0651
FAX (+598) 2622 2048
4.2.1 Variables externas de valor


TEL (+598) 2622 0651
FAX (+598) 2622 2048
4.2.2 Variables externas de comando


TEL (+598) 2622 0651
FAX (+598) 2622 2048
4.2.3 Variables internas y constantes


TEL (+598) 2622 0651
FAX (+598) 2622 2048
4.3 Variables Externas
4.3.1 Tipos de punto de la base de datos
La base de datos maneja dos tipos básicos de puntos en función de la dirección del flujo de información.
Un punto de estado (en rojo en el diagrama) es un punto adquirido por el hardware mediante un driver que
se envía hacia un centro de control mediante un módulo de protocolo.
Un punto de comando (en verde en el diagrama) es un punto obtenido desde un centro de control mediante
un módulo de protocolo que se envía al hardware mediante un módulo driver.
Centro de control
Hardware
Driver Módulo Protocolo

Base de
Datos
Además la base de datos maneja cuatro categorías de puntos para cada tipo en función del tipo de los
datos intercambiados, las mismas son booleanos, enteros, reales y string.
4.3.2 Variables de entrada

Las variables de entrada son leídas desde la BD al comienzo de cada ciclo del PLC. El módulo puede
obtener variables de entrada de la base de datos comportándose como un driver o como un protocolo. Esto
se detalla en el siguiente diagrama:


TEL (+598) 2622 0651
FAX (+598) 2622 2048
En tra das
Sali das
Módulo
Logicas
Centro de control
Hardware

Base de
Datos
Las variables de entrada del módulo pueden ser puntos de estado o de comando desde el punto de vista de
la base de datos. Esto permite elegir el origen de las variables de entrada al módulo.
Si una variable de entrada debe ser obtenida desde el hardware, la misma se debe configurar como punto
de estado desde la base de datos (en rojo en el diagrama).
Si el punto de entrada debe ser obtenido desde el centro de control, la misma se debe configurar como
punto de comando desde la base de datos (en verde en el diagrama).
Además de lo anterior el PLC maneja cuatro categorías de puntos de entrada según el tipo de datos. Los
mismos son booleanos, enteros, reales y string.
4.3.2.1 Buffer de puntos de entrada

Un punto de base de datos puede cambiar de valor varias veces en un ciclo de PLC, esto lleva a que haya
una incertidumbre sobre cuál es el valor que se copia sobre la variable de entrada, cuál es el valor que se
copia, el primero, el último, otro?
Para resolver esa incertidumbre el módulo dispone del parámetro global Buffer de puntos.
Si dicho parámetro esta en false (valor por defecto) el módulo copia el último valor recibido antes del
comienzo del ciclo y deshecha todos los anteriores.
Si el parámetro Buffer de puntos esta en true entonces se crea una cola de estados para cada variable de
entrada al módulo. Cada vez que se recibe un nuevo valor, el mismo se agrega al final de la cola.
Al inicio de cada ciclo de trabajo del PLC se verifica si hay cambios de estado almacenados en la cola, si
los hay se saca el más antiguo y se copia sobre la variable de entrada.
De esta forma todos los cambios de estados son procesados. Las colas tienen una capacidad máxima de
30 estados por lo cual si se reciben más de 30 estados durante la ejecución de un ciclo de trabajo del PLC,
los estados más antiguos son desechados.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
4.3.2.2 Campos de las estructuras externas de entrada de valor de BD
Variables de entrada tipo estado de BD

Campo Tipo Aplica a Descripción
VALUE (Nota 1) Todas Valor de entrada
VALID BOOL Todas Valor válido (actualizado)
MANUAL BOOL Todas Punto en manual (manual override)
TIME DATE_AND_TIME Todas Marca de tiempo del cambio de estado (en UTC)
VALIDTIME BOOL Todas Marca de tiempo válida
El valor TRUE indica que fue detectado un flanco
RTRIG BOOL booleanas
ascendente del campo VALUE
El valor TRUE indica que fue detectado un flanco
FTRIG BOOL booleanas
descendente del campo VALUE
NOTAS
1. El tipo de dato del campo VALUE dependerá del tipo de variable, los posibles valores son: DINT,
LREAL, BOOL y STRING.
2. Los campos RTRIG y FTRIG son actualizados automáticamente por el PLC al inicio de cada ciclo
de trabajo, pero sólo para las variables externas, es decir para las variables asociadas a puntos de
BD. Cuando la estructura es utilizada en la definición de variables internas, dichos campos no son
actualizados por el PLC.
4.3.2.3 Campos de las estructuras externas de entrada de comando de BD
Variables de entrada tipo comando de BD

Valor comandado desde la base de datos (solo es válido cuando
VALUE (Nota 1) Todas
TRIGGER es TRUE)
Tiempo de pulso comandado desde la base de datos (solo es
válido cuando TRIGGER es TRUE). El tiempo de pulso recibido
PULSETIME TIME booleanas desde la BD está dado en décimas de segundos, pero el PLC lo
convierte automáticamente al tipo TIME el cual representa una
medida de tiempo en nanosegundos.
Comando recibido. El valor TRUE indica que se recibió un nuevo
TRIGGER BOOL Todas
comando desde la base de datos.
NOTAS
4. El campo TRIGGER es actualizado automáticamente por el PLC al inicio de cada ciclo de trabajo, y
luego es reseteado a FALSE al final de cada ciclo, pero sólo para las variables externas, es decir
para las variables asociadas a puntos de BD. Cuando la estructura es utilizada en la definición de
variables internas, el campo no es actualizado por el PLC.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
4.3.3 Variables de salida
Las variables de salida son escritas en la base de datos al finalizar cada ciclo del PLC. El módulo puede
escribir puntos de salida en la base de datos comportándose como un driver o como un protocolo. Esto se
detalla en el siguiente diagrama
En tra das
Sali das
Módulo
Logicas
Centro de control
Hardware

Base de
Datos
Las variables de salida del módulo pueden ser puntos de estado o de comando desde el punto de vista de
la base de datos. Esto permite elegir el destino de los puntos de salida del PLC.
Si la variable de salida del módulo debe ser enviada al hardware la misma se debe configurar como punto
de comando hacia la base de datos (en verde en el diagrama).
Si la variable de salida del PLC debe ser enviada al centro de control la misma se debe configurar como
punto de estado hacia la base de datos (en rojo en el diagrama).
Además de lo anterior el PLC maneja cuatro categorías de puntos de salida según el tipo de datos. Los
mismos son booleanos, enteros, reales y string.
4.3.3.1 Campos de las estructuras externas de salida de valor de BD
Variables de salida tipo estado de BD

VALUE (Nota 1) Todas Valor del estado
VALID BOOL Todas Valor válido (actualizado)
MANUAL BOOL Todas Punto en manual (manual override)


TEL (+598) 2622 0651
FAX (+598) 2622 2048
TIME DATE_AND_TIME Todas Marca de tiempo del cambio de estado (en UTC)
NOTAS
4.3.3.2 Campos de las estructuras externas de salida de comando de BD
Variables de salida tipo comando de BD

VALUE (Nota 1) Todas Valor de salida a comandar (ver el parámetro TRIGGER)
Tiempo de pulso a comandar (para drivers de salidas pulsadas
que acepten dicho parámetro). El tipo TIME representa una
PULSETIME TIME booleanas
medida de tiempo en nanosegundos, pero el valor enviado a la
BD es convertido automáticamente a décimas de segundos.
Enviar el comando. El valor TRUE indica que se debe enviar el
comando del punto a la base de datos. Además los comandos
TRIGGER BOOL Todas
solamente se envían en esta situación, es decir
independientemente de lo valores de los otros campos.
NOTAS
2. El campo TRIGGER es reseteado a FALSE automáticamente por el PLC al final de cada ciclo de
trabajo, pero sólo para las variables externas, es decir para las variables asociadas a puntos de BD.
Cuando la estructura es utilizada en la definición de variables internas, el campo no es actualizado
por el PLC.
4.3.4 Flujo de información
Se muestra a continuación un diagrama general del flujo de información en la RTU con el módulo de lógicas
en funcionamiento.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
En tra das
Sali das
Módulo
Logicas
Centro de control
Hardware

Base de
Datos
En verde se detallan los puntos de comando de base de datos y en rojo los puntos de estado de la misma.
4.4 Variables del sistema

Además de las variables definidas por el usuario, existen un conjunto de variables predefinidas por el
sistema.
4.4.1 Variable $SysInfo

Proporciona información general del sistema.
Campo Tipo Descripción

ConfigCycleTime LREAL Tiempo configurado para la ejecución de los ciclos de trabajo del PLC
(en milisegundos)
CycleCounter LREAL Contador de ciclos ejecutados
CycleOverflow LREAL Contador de ciclos que excedieron el tiempo configurado
MaxCycleTime LREAL Tiempo máximo de ejecución de un ciclo (en milisegundos)
AverageCycleTime LREAL Tiempo promedio de ejecución de un ciclo (en milisegundos)


TEL (+598) 2622 0651
FAX (+598) 2622 2048
4.4.2 Variable $Time
Indica la hora local de inicio del ciclo de trabajo actual del PLC. Todos los campos están dados en UTC.
Campo Tipo Descripción

Year DINT Año, valor en el rango [1970, 2106]
Month DINT Mes, valor en el rango [1, 12]
Day DINT Día, valor en el rango [1, 31]
Hour DINT Hora, valor en el rango [0, 23]
Minute DINT Minuto, valor en el rango [0, 59]
Second DINT Segundo, valor en el rango [0, 59]
Nanosecond DINT Nanosegundo, valor en el rango [0, 999999999]
Value DATE_AND_TIME Marca de tiempo (en UTC)


TEL (+598) 2622 0651
FAX (+598) 2622 2048
5 Funcionamiento
Existen tres unidades de organización de programas (Program Organization Unit o POU) disponibles para el
usuario para la programación del PLC, estas unidades son las funciones, los bloques funcionales y los
programas.
Todas los POUs se configuran o programan utilizando el lenguaje ST (Structured Text) de la norma IEC
61131-3 second edition 2003-01.
El funcionamiento del módulo consiste en ejecutar la lista de programas configurados por el usuario.
El proceso de ejecución se puede resumir como:
• Se leen desde la base de datos el estado de las variables de entrada

• Para cada programa de la lista de programas
o Se ejecuta la lógica programada
• Se escriben a la base de datos el estado de las variables de salida
• Se espera el comienzo de un nuevo ciclo y se vuelve al paso inicial.
NOTAS
1. Los programas se ejecutan en el orden configurado por el usuario.
5.1 Programas
Un programa es la unidad de organización de código de más alto nivel del módulo. En función de los
elementos del lenguaje utilizados, un programa puede ser diagramable (representable gráficamente en el
módulo de visualización) o no. Además para los programas diagramables se permite ocultar partes de los
mismos en función del nivel de acceso del usuario.
Se muestra a continuación un ejemplo de un programa y el diagrama generado automáticamente a partir

del mismo.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
1
2 label("Interruptor abierto y abmos seccionadores cerrados o ambos
seccionadores abiertos")
3 header(true, "Interruptor - Habilitación mando cierre", true)
4 // El mando de apertura local se habilita si el interruptor esta cerrado
5 // y no esta en falla SF6
6 INT_HAB_CIERRE :=
7 ESTADO_VALIDO
8 and
9 INT_52_X_OFF.Value
10 and
11 (
12 label("Sec. cerrados")
13 (SEC_89_X_1_ON.Value and SEC_89_X_2_ON.Value)
14 or
15 label("Sec. abiertos")
16 (SEC_89_X_1_OFF.Value and SEC_89_X_2_OFF.Value)
17 );
18 end_header;
19
20 label("Interruptor cerrado y SF6 OK")
21 header(true, "Interruptor - Habilitación mando apertura", true)
22 // El mando de apertura local se habilita si el interruptor esta cerrado
23 // y no esta en falla SF6
24 INT_HAB_APERTURA :=
25 ESTADO_VALIDO
26 and
27 INT_52_X_ON.Value
28 and
29 not FALLA_SF6.Value;
30 end_header;
31


TEL (+598) 2622 0651
FAX (+598) 2622 2048
5.1.1 Restricciones para los programas diagramables
Para los programas diagramables se aplican un conjunto de restricciones en la utilización de los elementos
del lenguaje. Estas restricciones son necesarias para la generación automática de los diagramas.
NOTAS
1. Estas restricciones sólo se aplican a los programas diagramables. Dentro de las funciones, bloques
funcionales y programas no diagramables, no se aplica ninguna restricción pudiéndose utilizar toda
la potencialidad del lenguaje.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
5.1.1.1 Restricciones en la utilización de funciones
Cuando las funciones se utilizan dentro de programas diagramables se imponen un conjunto de
restricciones en la utilización de las mismas.
1. Las funciones con parámetros de entrada/salida no son diagramables.
2. Las funciones con resultado o parámetros de tipos de datos derivados (estructuras y arrays) no
son diagramables.
3. La cantidad de parámetros de entrada de la función debe estar comprendido en el rango 1 a 16.
En caso de que no se cumplan las restricciones anteriores, dichas funciones sólo podrán ser utilizadas
dentro de headers no diagramables.
5.1.1.2 Restricciones en la utilización de bloques funcionales

Cuando los bloques funcionales se utilizan dentro de programas diagramables se imponen un conjunto de
restricciones en la utilización de los mismos.
1. Los bloques funcionales con parámetros de tipos de datos derivados (estructuras y arrays) no son
diagramables.
2. La cantidad de parámetros de entrada del bloque funcional debe estar comprendido en el rango 1
a 16.
3. La cantidad de parámetros de salida del bloque funcional debe estar comprendido en el rango 1 a
16.
4. Dentro de headers diagramables, un bloque funcional sólo puede ser inicializado una única vez.
5. Un bloque funcional inicializado dentro de un header diagramable, debe ser utilizado al menos una
vez después de su inicialización dentro del mismo header diagramable, y además entre la
sentencia de inicialización y la primer utilización del bloque funcional sólo se permiten sentencias
de inicialización de otros bloques funcionales.
6. Si la primer utilización de un bloque funcional “A” corresponde a la utilización como parámetro de

inicialización de otro bloque funcional “B”, entonces no se permite la utilización de “A” antes de la
primer utilización de “B”. Esta restricción es necesaria para asegurar que el orden en que se
dibujan los elementos en el diagrama corresponda con el orden real del programa.
En caso de que no se cumplan las restricciones anteriores, las sentencias de inicialización de los bloques
funcionales sólo podrán ser utilizadas dentro de headers no diagramables.
Para aclarar la restricción (6) veamos el siguiente ejemplo. Sean dos bloques funcionales B1 y B2 y sus
respectivas instancias fb1 y fb2. Ambos bloques funcionales tienen una entrada IN1 y una salida OUT1,
ambos parámetros de tipo DINT.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
Ejemplo 1 (correcto):
fb1(1);
fb2(fb1.out1);
v1 := fb2.out1 + fb1.out1;
Este ejemplo cumple con la restricción (6), y observamos como se muestra correctamente en el diagrama
la utilización del campo “fb1.out” del bloque funcional después de la inicialización del mismo, lo cual
corresponde con el orden real del programa.
Ejemplo 2 (incorrecto):
fb1(1);
fb2(fb1.out1);
v1 := fb1.out1 + fb2.out1;
En este ejemplo el orden de los operandos de la suma está invertido con respecto al ejemplo anterior, y por
lo tanto no cumple con la restricción (6) y no compila. Pero si esta restricción no estuviese entonces el
diagrama generado sería como el mostrado, y por lo tanto se mostraría incorrectamente el campo “fb1.out”
del bloque funcional antes de la inicialización del mismo, lo cual no correspondería con el orden real del
programa.
5.1.1.3 Restricciones en la utilización de sentencias

Conjunto de restricciones en cuanto a la utilización de sentencias dentro de programas diagramables.
1. No se permite la utilización de la sentencia RETURN.
2. Las sentencias IF, CASE, WHILE, REPEAT y FOR no son diagramables, es decir que sólo se
permiten dentro de headers no diagramables.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
3. Las sentencias de asignación de valores de tipos de datos derivados (estructuras y arrays) no son
diagramables, es decir que sólo se permiten dentro de headers no diagramables.
5.2 Funciones
Desde el punto de vista de un diagrama, una función es un operador que puede tener varias entradas y una
sola salida. Desde el punto de vista del lenguaje de programación, una función es una unidad de
organización de programa (POU) que al ser ejecutada devuelve exactamente un solo valor, el cual
corresponde al resultado de la función, y opcionalmente varios valores de salida (parámetros de
entrada/salida).
El resultado de las funciones así también como sus parámetros pueden ser de cualquier tipo elemental o
derivado, pero no pueden ser bloques funcionales. Además las funciones no tienen estado interno
persistente entre ejecuciones, esto significa que ejecuciones distintas de una misma función con los
mismos argumentos (parámetros de entrada, parámetros de entrada/salida, y variables globales utilizadas
por la función) devuelven siempre el mismo resultado.
La invocación de una función se realiza como un operando dentro de una expresión del lenguaje. A
continuación se muestra un ejemplo de un programa que invoca a la función del sistema TRUNC para
redondear un valor real a un valor entero.
Las funciones se clasifican en dos tipos:
• Funciones del sistema: Son todas las funciones predefinidas por el sistema.
• Funciones del usuario: Son todas las funciones programadas por el usuario.
Independientemente del tipo de función la forma de utilización es la misma.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
5.2.1 Funciones del usuario
Parámetros de configuración de una función de usuario:
• Nombre: Campo obligatorio. Nombre identificador de la función.
• Nombre corto: Campo opcional. Nombre corto de la función para mostrar en los diagramas. Si este
campo está vacío se muestra directamente el nombre de la función.
• Descripción: Campo opcional. Descripción de la función.
• Resultado de la función: Campo obligatorio. Corresponde a una variable especial creada

automáticamente de igual nombre que la función que determina el valor devuelto por la función. Puede
ser de cualquier tipo elemental o derivado, pero no puede ser ni una constante ni un bloque funcional.
Dentro del código de la función corresponde a una variable de sólo escritura.
• Parámetros de Entrada: Campo opcional. Conjunto de variables donde cada variable representa un
parámetro de entrada de la función. Al momento de ejecución de la función cada una de estas variables
se inicializa con el valor del argumento correspondiente especificado en la invocación a la función. Los
argumentos son pasados a la función mediante el mecanismo conocido como “pasaje por valor”, es
decir que lo que se pasa a la función no son los argumentos en sí mismos, sino una copia de sus
valores. Estos argumentos pueden ser valores literales, expresiones, variables o constantes. Dentro del
código de la función los parámetros de entrada se comportan como variables de sólo lectura, es decir
no se permite modificar sus valores. Los parámetros de entrada pueden ser de cualquier tipo elemental
o derivado, pero no pueden ser ni constantes ni bloques funcionales.
• Parámetros de Entrada/Salida: Campo opcional. Conjunto de variables donde cada variable

representa un parámetro de entrada/salida de la función. Al momento de ejecución de la función cada
una de estas variables se inicializa con el puntero al argumento correspondiente especificado en la
invocación a la función. Los argumentos son pasados a la función mediante el mecanismo conocido
como “pasaje por referencia”, es decir que lo que se pasa a la función son los argumentos en sí
mismos, y no una copia de sus valores como en los parámetros de entrada. Estos argumentos sólo
pueden ser variables. Dentro del código de la función los parámetros de entrada/salida se comportan
como variables de lectura y escritura. Los parámetros pueden ser de cualquier tipo elemental o
derivado, pero no pueden ser ni constantes ni bloques funcionales.
• Variables locales: Campo opcional. Conjunto de variables auxiliares utilizadas para los cálculos
internos de la función. Al momento de ejecución de la función estas variables se inicializan con los
valores por defecto. Estas variables son de lectura y escritura. Estas variables pueden ser de cualquier
tipo elemental o derivado, pero no pueden ser bloques funcionales.
• Código de la función: Campo obligatorio. Implementa la lógica de la función. Toda función debe
devolver siempre un resultado. Para ello en tiempo de compilación se controla que todos los caminos
posibles de ejecución de la función devuelvan un resultado. El resultado devuelto por la función se fija
asignando un valor a la variable especial de resultado de la función.
Dentro del código de una función se pueden invocar a otras funciones, ya sean del sistema o del usuario,
pero dichas invocaciones no pueden ser recursivas. Existen dos formas de recursividad, recursividad


TEL (+598) 2622 0651
FAX (+598) 2622 2048
directa y recursividad indirecta. En tiempo de compilación se controla que no se genere ningún tipo de
recursividad. Una recursividad directa sería que una función se invocase a sí misma. Un ejemplo de
recursividad indirecta sería que una función A invocase a otra B y que a su vez la función B invocase a la
función A.
Dentro del código de la función, además de poder utilizarse las variables internas de la función, es decir las
variables de entrada, las variables de entrada/salida, las variables locales y la variable especial de resultado
de la función, también se pueden utilizar las variables globales.
Si se utilizan estructuras o arrays complejos, es muy recomendable utilizarlos como variables globales o
pasarlos como parámetros de entrada/salida para evitar generar una copia de sus valores en cada
invocación, y así lograr genera programas más eficientes.
NOTAS
1. Es posible pasar como parámetro de entrada/salida de una función, una variable de sólo lectura o
una constante, en este caso el sistema en tiempo de compilación comprueba que dicho parámetro
no sea modificado por la función, de lo contrario se genera un error de compilación. Pero esta
validación no se puede realizar al momento de compilación de un POU particular, sino que hay que
esperar a compilar la configuración completa.
5.2.1.1 Ejemplo SUMA

A continuación se muestra como ejemplo una función de usuario de nombre SUMA que implementa la
suma de dos enteros.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
La invocación a la función de usuario desde un programa es igual que la invocación de una función
estándar. A continuación se muestra un programa de ejemplo que utiliza la función SUMA definida más
arriba para sumar el valor de dos variables enteras val1 y val2.
5.3 Bloques funcionales

Desde el punto de vista de un diagrama, un bloque funcional es un operador que puede tener varias
entradas y varias salidas. Desde el punto de vista del lenguaje de programación, un bloque funcional es una
unidad de organización de programa (POU) que al ser ejecutada devuelve uno o más valores. Además a


TEL (+598) 2622 0651
FAX (+598) 2622 2048
diferencia de las funciones, los bloques funcionales tienen estado interno persistente entre invocaciones y
para ser utilizados deben ser instanciados mediante variables.
Los bloques funcionales se clasifican en dos tipos:
• Bloques funcionales del sistema: Son todos los bloques funcionales predefinidos por el
sistema.
• Bloques funcionales del usuario: Son todos los bloques funcionales programados por el
usuario.
Independientemente del tipo de bloque funcional la forma de utilización es la misma.
5.3.1 Bloques funcionales del usuario
Parámetros de configuración de un bloque funcional de usuario:
• Nombre: Campo obligatorio. Nombre identificador del bloque funcional.
• Nombre corto: Campo opcional. Nombre corto del bloque funcional para mostrar en los diagramas. Si
este campo está vacío se muestra directamente el nombre del bloque funcional.
• Descripción: Campo opcional. Descripción del bloque funcional.
• Parámetros de entrada: Campo opcional. Conjunto de variables donde cada variable representa un
parámetro de entrada del bloque funcional. Al momento de ejecución del bloque funcional cada una de
estas variables se inicializa con el valor del argumento correspondiente especificado en la invocación al
bloque funcional. Los argumentos son pasados al bloque funcional mediante el mecanismo conocido
como “pasaje por valor”, es decir que lo que se pasa al bloque funcional no son los argumentos en sí
mismos, sino una copia de sus valores. Estos argumentos pueden ser valores literales, expresiones,
variables o constantes. Dentro del código del bloque funcional los parámetros de entrada se comportan
como variables de sólo lectura, es decir no se permite modificar sus valores, y además el valor de las
mismas se persiste entre ejecuciones del bloque funcional. Los parámetros de entrada pueden ser de
cualquier tipo elemental o derivado, pero no pueden ser ni constantes ni bloques funcionales.
• Parámetros de salida: Campo opcional. Conjunto de variables donde cada variable representa un
parámetro de salida del bloque funcional. Dentro del código del bloque funcional estas variables son de
lectura y escritura y además el valor de las mismas se persiste entre ejecuciones del bloque funcional.
Los parámetros de salida pueden ser de cualquier tipo elemental o derivado, pero no pueden ser ni
constantes ni bloques funcionales.
• Variables locales: Campo opcional. Conjunto de variables auxiliares utilizadas para los cálculos
internos del bloque funcional. Estas variables son de lectura y escritura y además el valor de las
mismas se persiste entre ejecuciones del bloque funcional. Estas variables pueden ser de cualquier tipo
elemental o derivado, y pueden ser también bloques funcionales.
• Código del bloque funcional: Campo opcional. Implementa la lógica del bloque funcional.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
En la definición de un bloque funcional se pueden utilizar otros bloques funcionales, ya sean del sistema o
del usuario, pero no se permiten definiciones recursivas. Existen dos formas de recursividad, recursividad
directa y recursividad indirecta. En tiempo de compilación se controla que no se genere ningún tipo de
recursividad. Una recursividad directa sería que un bloque funcional A utilizase una variable local de tipo
bloque funcional A. Un ejemplo de recursividad indirecta sería que un bloque funcional A utilizase una
variable local de tipo bloque funcional B y que a su vez el bloque funcional B utilizase una variable local de
tipo bloque funcional A.
Dentro del código del bloque funcional, además de poder utilizarse las variables internas del bloque
funcional, es decir las variables de entrada, las variables de salida y las variables locales, también se
pueden utilizar las variables globales.
5.3.1.1 Ejemplo BLINK

En el Anexo A se muestran a modo de ejemplo las implementaciones de los bloques funcionales del
sistema como bloques funcionales del usuario.
Los bloques funcionales de usuario se utilizan de igual forma que los bloques funcionales del sistema. A
continuación se muestra un ejemplo de programa que utiliza el bloque funcional estándar BLINK y el bloque
de usuario BLINK_USR para generar dos pulsos independientes de igual período.


TEL (+598) 2622 0651
FAX (+598) 2622 2048

TEL (+598) 2622 0651
FAX (+598) 2622 2048
5.4 Operandos de entrada
Desde el punto de vista de un diagrama, un operando de entrada se usa para cálculos, pueden ser
variables de entrada, constantes, variables del sistema o campos de bloques funcionales.
5.5 Operandos de salida
Desde el punto de vista de un diagrama, un operando de salida recibe los resultados de los cálculos,
pueden ser variables de salida.
5.6 Tratamiento de errores
Ante cualquier error de ejecución del PLC se ejecuta la acción preestablecida para el manejo de errores.
Esta acción se configura en el parámetro “Manejo de errores” de la configuración y sólo existen dos
opciones:
• Detener el PLC: Se detiene inmediatamente la ejecución del PLC. Corresponde a la opción por
defecto.
• Reiniciar el PLC: Se detiene inmediatamente la ejecución del PLC y luego de 10 segundos se

arranca nuevamente en forma automática. En modo de ejecución DEBUG-CICLO-A-CICLO esta
opción es equivalente a la anterior ya que el PLC se detiene pero no se arranca automáticamente.
La detención del PLC significa que se detiene la ejecución del ciclo de trabajo del PLC y por lo tanto se
detiene la ejecución de los programas, pero el módulo lógicas continúa funcionando y comunicándose
normalmente con el resto de los módulos de la RTUQM.
5.6.1 Errores de ejecución

A continuación se enumeran los posibles errores de ejecución manejados por el PLC.
• Timeout de watchdog: Este error se produce cuando el ciclo actual del PLC supera un tiempo
máximo preestablecido. Este tiempo es configurable por el usuario en el parámetro de
configuración “Timeout del watchdog” del módulo, y donde el valor cero significa que no se utiliza el
watchdog.
• División por cero: Este error se produce cuando se intenta realizar una operación matemática de
división o módulo y el divisor es cero.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
• Desbordamiento de operación: Este error se produce cuando el resultado de una operación
matemática produce un valor no representable dentro del dominio de definición del tipo de dato del
resultado de la operación.
• Tipo de dato no válido: Este error se produce cuando el tipo de dato de un elemento (por ejemplo
una variable, o el resultado de una operación) no corresponde con el tipo de dato esperado. Si bien
este error se detecta en tiempo de compilación, por completitud y por seguridad igual se verifica en
tiempo de ejecución.
• Valor no válido: Este error se produce cuando se detecta un valor no válido. Por ejemplo en la
función ANY_TO_DINT al convertir un STRING a DINT si el valor de texto a convertir no
corresponde a la representación literal de un entero.
• Número de parámetros no válido: Este error se produce cuando se detecta que el número de
operandos de una expresión, o el número de argumentos de una función o bloque funcional no son
válidos. Si bien este error se detecta en tiempo de compilación, por completitud y por seguridad
igual se verifica en tiempo de ejecución.
• Stack no válido: Este error se produce cuando se detecta que el stack de memoria de ejecución
de los POUs no es válido. Corresponde a un error de ejecución interno que podría suceder por
ejemplo debido a falta de memoria.
• Indice no válido: Este error se produce cuando se intenta acceder a un elemento de un array con
un índice de elemento fuera del rango. También se produce cuando el selector de la función del
sistema MUX está fuera de rango.
• Otros errores: Cualquier otro error interno del módulo, como ser por ejemplo falta de memoria.
5.7 Modos de funcionamiento

El PLC tiene tres posibles estados de funcionamiento:
• DETENIDO: El PLC está detenido. Si bien esto significa que no se está ejecutando ningún programa,
el módulo lógicas continúa funcionando y comunicándose normalmente con el resto de los módulos de
la RTUQM. Este estado se asume automáticamente si al arrancar o reiniciar el módulo se detecta que
no hay una configuración válida o bien no hay ningún programa configurado. También se pasa a este
estado mediante el comando de administración “Detener PLC”.
• NORMAL: Corresponde al modo de funcionamiento normal donde el ciclo de trabajo del PLC se
ejecuta en forma periódica según los parámetros de ejecución configurados. Este estado se asume
automáticamente si al arrancar o reiniciar el módulo se detecta que hay una configuración válida y por
lo menos un programa configurado. También se pasa a este estado mediante el comando de
administración “Ejecutar PLC en modo NORMAL”.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
• DEBUG-CICLO-A-CICLO: Corresponde a un modo de ejecución para la depuración de los POUs
programados por el usuario. En este modo de funcionamiento el PLC se encuentra normalmente
pausado y los ciclos de trabajo se ejecutan de uno a la vez y sólo por solicitud del administrador. Se
pasa a este modo sólo mediante el comando de administración “Ejecutar PLC en modo DEBUG-
CICLO-A-CICLO”.
NOTAS
1. Si el módulo lógicas no tiene una configuración válida o bien no hay ningún programa configurado,
entonces el PLC estará siempre en estado DETENIDO no pudiendo conmutar de estado.
2. Cada vez que el PLC cambia su modo de funcionamiento se actualiza automáticamente el estado
del punto de supervisión “PLC_OK”.
5.7.1 Modo DEBUG-CICLO-A-CICLO

En este modo de funcionamiento el PLC se encuentra pausado en espera de un comando desde el
administrador para la ejecución de un ciclo de trabajo. Una vez ejecutado el ciclo, el PLC queda
nuevamente pausado automáticamente en espera de un nuevo comando desde el administrador para la
ejecución del próximo ciclo. De esta forma el administrador tiene la posibilidad de ejecutar ciclo a ciclo el
PLC analizando los estados de las variables en cada ciclo.
Además en este modo de funcionamiento se habilita la ejecución de la sentencia TRACE, la cual permite
generar mensajes de texto con información adicional para la depuración de los POUs. Todos los mensajes
de trace generados pueden verse desde la ventana de terminal del módulo en el Administrador RTUQM.
5.7.2 Comandos del PLC

Los siguientes comandos del PLC están disponibles desde la ventana de terminal del módulo en el
Administrador RTUQM, pero sólo para el nivel de acceso “Administración”.
• Ejecutar PLC en modo NORMAL: Si el PLC estaba detenido, este comando lo arranca y lo ejecuta
en modo NORMAL. Si estaba ejecutándose en modo DEBUG-CICLO-A-CICLO entonces lo pasa a
modo NORMAL continuando la ejecución a partir del estado actual.
• Detener PLC: Detiene la ejecución del PLC.
• Ejecutar PLC en modo DEBUG-CICLO-A-CICLO: Si el PLC estaba detenido, este comando lo

arranca y lo ejecuta en modo DEBUG-CICLO-A-CICLO. Si estaba ejecutándose en modo NORMAL
entonces lo pasa a modo DEBUG-CICLO-A-CICLO continuando la ejecución a partir del estado
actual. Cuando el PLC pasa a modo DEBUG-CICLO-A-CICLO queda pausado automáticamente
esperando por el comando de ejecución del próximo ciclo.
• Ejecutar un ciclo del PLC: Este comando sólo está disponible para el funcionamiento DEBUG-
CICLO-A-CICLO y permite ejecutar un ciclo de trabajo del PLC. Una vez ejecutado el ciclo, el PLC
queda pausado automáticamente en espera de un nuevo comando para la ejecución del próximo
ciclo.


TEL (+598) 2622 0651
FAX (+598) 2622 2048

TEL (+598) 2622 0651
FAX (+598) 2622 2048
6 Lenguaje de programación
El lenguaje de programación utilizado por el módulo constituye un subconjunto del lenguaje ST (Structured
Text) de la norma IEC 61131-3 second edition 2003-01, con algunas restricciones y también algunas
extensiones.
6.1 Identificadores
Un identificador es una cadena de letras, dígitos y caracteres de subrayado, que debe comenzar por una
letra. Los identificadores son insensibles a mayúsculas y minúsculas. Los identificadores no pueden
contener caracteres de espacio ni subrayados múltiples.
Ejemplos:
Los siguientes identificadores son equivalentes, es decir representan el mismo identificador
valor_12
VALOR_12
Valor_12
Los siguientes identificadores representan identificadores diferentes
valor_12
valor12
valor_1_2
Los siguientes valores no son identificadores válidos
_valor (empieza con subrayado)

1valor (empieza con un dígito)
valor__1 (tiene subrayado múltiple)
6.2 Comentarios
Todo texto delimitado por ciertos caracteres especiales se considera comentarios del usuario dentro del
código de un programa y no son tomados en cuenta para la compilación. Se soportan tres tipos distintos de
comentarios.
1. Comentarios delimitados por los caracteres de inicio “(*” y final “*)”

2. Comentarios delimitados por los caracteres de inicio “/*” y final “*/”
3. Comentarios delimitados por los caracteres de inicio “//” y el final de la línea.
NOTAS
1. Los comentarios 2 y 3 son extensiones a la norma. Se agregaron por compatibilidad con los
comentarios utilizados en las expresiones del MIRAGE.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
No se permiten comentarios anidados del mismo tipo. Por ejemplo el siguiente comentario no es válido
(*
...
(* COMENTARIO NO VALIDO *)
...
*)
Para ello es necesario utilizar tipos distintos, por ejemplo el siguiente comentario sí es válido
/*
...
(* COMENTARIO VALIDO *)
...
*/
6.3 Representación literal de datos
6.3.1 Literales numéricos

Hay dos clases de literales numéricos: literales enteros y literales reales.
Se permite la utilización de los caracteres de subrayado simple “_” intercalados entre los dígitos de un literal
numérico. Dichos caracteres no son significativos en cuanto al valor numérico, simplemente proporcionan
un mecanismo para facilitar la visualización de los datos.
Por ejemplo, los siguientes literales representan el mismo valor numérico
12345
12_345
Los literales enteros pueden estar representados en base decimal o en base 2, 8 o 16. La base se
especifica mediante el número de base y el carácter especial “#”. Los literales decimales pueden estar
precedidos de un signo “+” o “-“, pero los números en base no.
Ejemplos de literales enteros en base decimal:
0
-12
12_346
+10
Ejemplos de literales enteros en base 2:
2#1111_1111 // corresponde al 255 decimal

2#11 // corresponde al 3 decimal


TEL (+598) 2622 0651
FAX (+598) 2622 2048

16#FF // corresponde al 255 decimal

Los literales reales se distinguen por la presencia de un punto decimal obligatorio. Los literales reales sólo
se representan en base decimal. La letra “e” o “E” se utiliza para representar el exponente el cual indica la
potencia entera de 10 por la que se ha de multiplicar el número precedente para obtener el valor
representado. Los literales decimales y sus exponentes pueden estar precedidos de un signo “+” o “-“.
Ejemplos de literales reales:
-1.34e-12
1.0E+5
3.0
+1_234.0
6.3.2 Literales booleanos

Los literales booleanos se representan por las palabras claves FALSE y TRUE (en forma insensible a
mayúsculas y minúsculas).
6.3.3 Literales de string

Un literal de string es una secuencia de cero o más caracteres precedidos y terminados por el carácter
especial ’ (comilla simple) o ” (comillas dobles).
Ejemplos:
’’ // cadena vacía
”” // cadena vacía
’Hola’
”Hola”
NOTAS
1. En la norma las comillas simples se utilizan para cadenas de caracteres de un byte y las comillas
dobles para cadenas de caracteres de dos bytes. Nosotros sólo soportamos cadenas de caracteres
de un byte y por compatibilidad con las expresiones del MIRAGE permitimos utilizar indistintamente
ambos delimitadores de strings.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
6.3.4 Literales de duración
Representan una medida de duración de tiempo. Se representan mediante el prefijo “T#” o “TIME#” (en
forma insensible a mayúsculas y minúsculas) seguido de los campos de duración en unidades de días (d),
horas (h), minutos (m), segundos (s) y milisegundos (ms). Los campos pueden estar separados por
caracteres de subrayados y los identificadores de los campos también son insensibles a mayúsculas y
minúsculas.
Se permite el desbordamiento del campo más significativo, por ejemplo se permite la notación T#30h_15m,
y además el campo más significativo puede estar precedido de un signo “+” o “-“. El campo menos
significativo puede escribirse en notación real sin exponente.
Ejemplos de literales de tiempo válidos:
T#100d_12h_5m_3s_10.5ms
TIME#100.7h
Time#-0.01ms
t#-1M_40S_3ms
time#+3.3h
Ejemplos de literales de tiempo no válidos:
T#1d_28h // sólo se permite desbordamiento en el campo más significativo

T#1.3d_8h // sólo se permite notación real en el campo menos significativo
T#1e3ms // la notación real del campo menos significativo no puede
// utilizar exponente
T#1d_8m // no se pueden saltearse campos intermedios, en esta caso falta
// el campo hora
6.3.5 Literales de fecha y hora (o marca de tiempo)

Representan una fecha y hora del día (o marca de tiempo) con precisión de nanosegundos. Se representan
mediante el prefijo “DT#” o “DATE_AND_TIME#” (en forma insensible a mayúsculas y minúsculas) seguido
de los campos año, mes, día, hora, minuto y segundo. El campo segundo puede escribirse en notación real
sin exponente, lo cual permite especificar los nanosegundos dentro del segundo. Se debe utilizar el carácter
“-“ (menos) como separador entre los campos año, mes, día y hora, y el carácter “:” (dos puntos) como
separador entre los campos hora, minuto y segundo. Todos los valores deben expresarse en UTC.
Ejemplos de literales de fecha y hora válidos:
DT#2013-12-31-23:59:59
DATE_AND_TIME#2013-12-31-23:59:59.123456789
date_and_time#1984-06-25-15:36:55.36
Dt#1984-06-25-15:36:55.36
6.4 Tipos de datos elementales

En la tabla 1 se resumen los tipos de datos simples o elementales soportados por el lenguaje.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
Tabla 1 – Tipos de datos elementales
Tipo Descripción
BOOL Valor booleano de 1 bit. Los posibles valores son FALSE y TRUE.
DINT Número entero con signo de 32 bits. El rango de valores va desde –(2**31) a
(2**31)-1, lo que equivale al rango -2147483648 a 2147483647
LREAL Número real de punto flotante de doble precisión de 64 bits de acuerdo a la
norma IEC 559 (IEEE 754). Consiste en 1 bit de signo, 11 bits de exponente y
52 bits de mantisa.
STRING Cadena de texto de longitud variable con un largo máximo de 255 caracteres,
donde cada carácter se representa con un byte.
TIME Representa una duración de tiempo con precisión de nanosegundos. Es un
valor entero con signo de 64 bits. El rango de valores va desde
T#-106751d_23h_47m_16s_854.775808ms a
T#106751d_23h_47m_16s_854.775807ms
DATE_AND_TIME Fecha y hora del día o marca de tiempo. Es un valor entero con signo de 64 bits
y representa los nanosegundos desde el primero de enero de 1970 UTC. El
rango de valores va desde DT#1970-01-01-00:00:00 a 2106-02-07-06:28:14
UTC.
El valor literal “DT#1970-01-01-00:00:00” corresponde internamente al valor

numérico 0 y se utiliza como valor especial para representar una marca de
tiempo inválida. Corresponde al valor devuelto por la función
ANY_TO_DATE_AND_TIME(0).
Dado un valor del tipo DATE_AND_TIME, el bloque funcional del sistema

GET_DATE_AND_TIME devuelve los campos componentes de la marca de
tiempo y la función del sistema SET_DATE_AND_TIME realiza la operación
inversa, es decir a partir de los campos de una marca de tiempo devuelve un
valor del tipo DATE_AND_TIME.
Tanto los valores internos del tipo DATE_AND_TIME como los valores literales
y los campos componentes de una marca de tiempo se representan siempre
en UTC.
Si VALTIME es una variable del tipo DATE_AND_TIME y su valor corresponde

al valor especial ANY_TO_DATE_AND_TIME(0), es decir una marca de tiempo
inválida, entonces la función ANY_TO_STRING(VALTIME) devuelve el string
vacío. En forma análoga si VALSTRING corresponde al string vacío entonces el
resultado de la función ANY_TO_DATE_AND_TIME(VALSTRING) es igual al
valor especial ANY_TO_DATE_AND_TIME(0).
Si la ejecución del bloque funcional GET_DATE_AND_TIME, la función del

sistema SET_DATE_AND_TIME, la función de conversión
ANY_TO_DATE_AND_TIME o la actualización de la variable del sistema
$Time, producen un error de conversión o un valor fuera de rango de una
marca de tiempo, la ejecución del PLC no se detiene sino que simplemente se
toma la marca de tiempo inválida y se continua con el procesamiento normal


TEL (+598) 2622 0651
FAX (+598) 2622 2048
del PLC.
Tabla 2 – Valores iniciales por defecto
Tipo Valor por defecto

BOOL FALSE
Corresponde al valor ANY_TO_BOOL(0)
DINT 0
LREAL 0.0
STRING “”
Corresponde a la cadena vacía
TIME ANY_TO_TIME(0)
Corresponde al valor literal “T#0s”
DATE_AND_TIME ANY_TO_DATE_AND_TIME(0)
Corresponde al valor literal “DT#1970-01-01-00:00:00” UTC, el cual se utiliza
como valor especial para representar una marca de tiempo inválida.
Tabla 3 – Tamaño de los tipos elementales
Tipo Tamaño (en bytes)

BOOL 1
DINT 4
LREAL 8
STRING 255 (Nota 1)
TIME 8
DATE_AND_TIME 8
NOTAS
1. Si bien el tipo STRING es de largo variable, para el cálculo del tamaño ocupado por el tipo de dato
siempre se toma el tamaño máximo soportado, el cual corresponde a 255 bytes.
6.5 Tipos de datos derivados

Se soportan los tipos de datos derivados STRUCT y ARRAY definidos en la norma. Estos tipos de datos
derivados se pueden utilizar junto con los tipos elementales para la definición de variables.
Las estructuras consisten en una agrupación de elementos identificados por sus nombres, donde los
elementos pueden ser de tipos elementales o derivados.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
Los arrays consisten en un vector de elementos, donde todos los elementos del array deben ser del mismo
tipo de dato, el cual puede ser de tipo elemental o derivado. Se soportan arrays multidimensionales con un
máximo de hasta 3 dimensiones. Se limita también la cantidad máxima de elementos que puede contener
un array a 1000 elementos (considerando todas sus dimensiones).
Si bien en la definición de los tipos de datos derivados, además de los tipos elementales se pueden utilizar
a su vez tipos derivados, el lenguaje no permite definiciones recursivas.
Los valores iniciales de los tipos de datos derivados corresponderán a los valores iniciales de sus
componentes de tipos de datos elementales.
El sistema limita el tamaño máximo que puede ocupar una variable a 5KB (5120 bytes). El tamaño de una
variable se calcula a partir de los tamaños de los tipos de datos elementales. Por ejemplo, como el tamaño
del tipo DINT es 4 bytes, entonces una estructura con dos campos de tipo DINT tendrá un tamaño de 8
bytes, y un array de 100 elementos de tipo DINT tendrá un tamaño de 400 bytes. Otro ejemplo, un array de
100 elementos de tipo “Entrada Valor LREAL desde BD:EF” tendrá un tamaño de 1900 bytes.
6.5.1 Arrays
Existen dos formas para la definición de variables de tipo arrays. La forma indirecta es definir el array como
un tipo de dato independiente y luego crear variables de dicho tipo de dato. Y la forma directa, es definir el
array directamente dentro de la definición de la variable.
Dado dos variables de tipo array, independientemente de la forma de definición directa o indirecta, e
independientemente de los nombres de los tipos de datos de los arrays para el caso indirecto, si las
dimensiones de los dos arrays son iguales y el tipo de dato de los elementos de los dos arrays es el mismo,
entonces los dos arrays son equivalentes, es decir puedo asignar el valor completo de un array al otro.
Las dimensiones de un array se especifican como subrangos de enteros, utilizando la secuencia de

caracteres “..” (dos puntos consecutivos) como separador de los límites inferior y superior del rango, y
utilizando el carácter “,” (coma) como separados de dimensiones.
En el siguiente programa de ejemplo se definen cuatro arrays A1, A2, B1 y C1. Donde A1 se define en
forma indirecta mediante el tipo de dato ArrayInt, y el resto se definen en forma directa definiendo el array
directamente en la definición de las variables. Además los arrays A1 y A2 son equivalentes, pero B1 y C1 no
son equivalentes con ninguno. Los tres arrays A1, A2 y B1 son arrays de una única dimensión y tienen 3
elementos cada uno y son de tamaño 12 bytes, mientras que el array C1 es un array de 2 dimensiones con
un total de 20 elementos y un tamaño de 80 bytes.


TEL (+598) 2622 0651
FAX (+598) 2622 2048

TEL (+598) 2622 0651
FAX (+598) 2622 2048
6.6 Tipos de datos genéricos
Jerarquía de tipos de datos genéricos utilizados en la especificación de las entradas y salidas de las
funciones y bloques funcionales estándar. Estos tipos de datos genéricos no pueden utilizarse en los POUs
definidos por el usuario. Los tipos de datos genéricos están identificados por el prefijo “ANY”.
ANY
ANY_DERIVED
ANY_ELEMENTARY
ANY_NUM
LREAL
DINT
BOOL
STRING
DATE_AND_TIME
TIME
Por ejemplo, el tipo ANY_NUM significa cualquier tipo de dato numérico real o entero, esto significa que si
en una función se indica que un parámetro de entrada es del tipo ANY_NUM, en realidad acepta los tipos
LREAL y DINT.
El tipo ANY_DERIVED representa cualquier tipo de dato derivado, es decir estructuras y arrays, tanto
definidos por el sistema como definidos por el usuario.
6.7 Funciones del sistema

A continuación se detallan el conjunto de funciones predefinidas por el sistema. A excepción de las
funciones de string STRCMP, STRICMP, STRMATCH y STRIMATCH y las funciones auxiliares, el resto
corresponden a funciones estándar definidas en la norma.
6.7.1 Funciones de conversión de tipo
Tabla 3 – Funciones de conversión de tipo
Función Entrada Salida Descripción

ANY_TO_BOOL ANY_E BOOL Convierte cualquier valor de tipo elemental
a BOOL
ANY_TO_DINT ANY_E DINT Convierte cualquier valor de tipo elemental
a DINT (Nota 2)
ANY_TO_LREAL ANY_E LREAL Convierte cualquier valor de tipo elemental
a LREAL
ANY_TO_STRING ANY_E STRING Convierte cualquier valor de tipo elemental
a STRING
ANY_TO_TIME ANY_E TIME Convierte cualquier valor de tipo elemental
a TIME (Nota 2)
ANY_TO_DATE_AND_TIME ANY_E DATE_AND_TIME Convierte cualquier valor de tipo elemental
a DATE_AND_TIME (Notas 2 y 5)
TRUNC LREAL DINT Devuelve la parte entera de un valor real
(Nota 3)


TEL (+598) 2622 0651
FAX (+598) 2622 2048
NOTAS
1. ANY_E es la abreviación de ANY_ELEMENTARY.
2. En las funciones ANY_TO_DINT, ANY_TO_TIME y ANY_TO_DATE_AND_TIME, las conversiones

de LREAL a DINT, LREAL a TIME y LREAL a DATE_AND_TIME respectivamente, redondean el
valor real según las convenciones de la IEC 559. Es decir redondea el valor real al entero más
cercano, y en el caso de que el valor real se encuentre exactamente en el medio de los dos enteros
más cercanos, se queda con el entero par.
Ejemplos:
ANY_TO_DINT(1.6) = 2
ANY_TO_DINT(-1.6) = -2
ANY_TO_DINT (1.5) = 2
ANY_TO_DINT (-1.5) = -2
ANY_TO_DINT (-1.4) = -1
ANY_TO_DINT (-2.5) = –2
3. La función TRUNC trunca hacia cero un valor real.
Ejemplos:
TRUNC(1.6) = 1
TRUNC(-1.6) = -1
TRUNC(1.4) = 1
TRUNC(-1.4) = -1
4. Cuando una entrada o una salida de una función de conversión es del tipo STRING, la cadena de
caracteres representa el literal del dato correspondiente. Ver sección Representación literal de
datos.
Ejemplos:
ANY_TO_DINT(“2#11”) = 3
ANY_TO_DINT(“blabla”) genera un error de ejecución (y la detención del PLC), ya que el texto
“blabla” no corresponde con un literal entero válido.
5. A diferencia del resto de las funciones de conversión, si la función ANY_TO_DATE_AND_TIME no

puede convertir su entrada a una marca de tiempo o el valor convertido esta fuera de rango, no se
genera un error de ejecución y por lo tanto la ejecución del PLC no se detiene, sino que
simplemente se devuelve la marca de tiempo inválida y se continúa con el procesamiento normal
del PLC.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
6.7.2 Funciones numéricas
Tabla 4 – Funciones numéricas

Funciones generales
ABS ANY_NUM ANY_NUM Valor absoluto
SQRT LREAL LREAL Raíz cuadrada
Funciones logarítmicas
LN LREAL LREAL Logaritmo natural
LOG LREAL LREAL Logaritmo en base 10
EXP LREAL LREAL Exponencial natural
Funciones trigonométricas
SIN LREAL LREAL Seno
COS LREAL LREAL Coseno
TAN LREAL LREAL Tangente
ASIN LREAL LREAL Arcoseno
ACOS LREAL LREAL Arcocoseno
ATAN LREAL LREAL Arcotangente
Funciones aritméticas
+ ANY_NUM, ANY_NUM ANY_NUM Suma
* ANY_NUM, ANY_NUM ANY_NUM Multiplicación
- ANY_NUM, ANY_NUM ANY_NUM Resta
/ ANY_NUM, ANY_NUM ANY_NUM División
MOD DINT, DINT DINT Módulo
** (Nota 2) LREAL Exponenciación
NOTAS
1. Las funciones aritméticas utilizan los operadores aritméticos estándar.
2. Salvo en la exponenciación, los parámetros de los operadores aritméticos deben ser del mismo
tipo. En la exponenciación A**B el tipo de dato de A es LREAL mientras que el de B es ANY_NUM y
el resultado es del tipo LREAL.
6.7.3 Funciones de selección
Tabla 5 – Funciones de selección

SEL G: BOOL ANY Selección binaria. Si G es TRUE devuelve IN0 de lo contrario
IN0: ANY devuelve IN1
IN1: ANY
MAX IN1: ANY_E ANY_E Devuelve el mayor de los valores de entrada. Es una función
IN2: ANY_E de parámetros variables. La cantidad de parámetros debe
X estar entre 2 y 16
INn: ANY_E


TEL (+598) 2622 0651
FAX (+598) 2622 2048
MIN IN1: ANY_E ANY_E Devuelve el menor de los valores de entrada. Es una función
IN2: ANY_E de parámetros variables. La cantidad de parámetros debe
X estar entre 2 y 16
INn: ANY_E
LIMIT MN: ANY_E ANY_E Limita el valor de IN entre los límites MN (mínimo) y MX
IN: ANY_E (máximo)
MX: ANY_E
MUX K: DINT ANY Multiplexor. Selecciona una de las N entradas según el
IN0: ANY selector K. El rango de valores de K es [0, N-1]. Es una
IN1: ANY función de parámetros variables. La cantidad de parámetros
X debe estar entre 3 y 16. Si el valor de K esta fuera del rango
IN(n-1): ANY se genera un error de ejecución.
NOTAS
1. ANY_E es la abreviación de ANY_ELEMENTARY.
2. Los parámetros de tipo ANY o ANY_E de una función deben ser del mismo tipo, es decir por
ejemplo si el parámetro IN0 de la función SEL es del tipo DINT, entonces el parámetro IN1 también
debe ser del tipo DINT.
6.7.4 Funciones de strings
Tabla 6 – Funciones de strings

LEN IN: STRING DINT Devuelve el largo de la cadena IN.
Ejemplo: LEN(“ABCDEF”) = 6
LEFT IN: STRING STRING Devuelve L caracteres situados más a la izquierda de IN.
L: DINT Ejemplo: LEFT(“ABCDEF”, 3) = “ABC”
RIGHT IN: STRING STRING Devuelve L caracteres situados más a la derecha de IN.
L: DINT Ejemplo: RIGHT(“ABCDEF”, 3) = “DEF”
MID IN: STRING STRING Devuelve L caracteres de IN a partir de la posición P (la
L: DINT posición se cuenta partir del valor 1).
P: DINT Ejemplo: MID(“ABCDEF”, 3, 2) = “BCD”
CONCAT IN1: STRING STRING Concatena todas las entradas. Es una función de parámetros
IN2: STRING variables. La cantidad de parámetros debe estar entre 2 y 16.
X Ejemplo: CONCAT(“ABC”, “_”, “DEF”) = “ABC_DEF”
INn: STRING
INSERT IN1: STRING STRING Intercala IN2 en IN1 después de la posición P (la posición se
IN2: STRING cuenta partir del valor 1).
P: DINT Ejemplo: INSERT(“ABCDEF”, “XYZ”, 2) = “ABXYZCDEF”
DELETE IN: STRING STRING Borra L caracteres de IN comenzando en la posición P (la
L: DINT posición se cuenta partir del valor 1).
P: DINT Ejemplo: DELETE(“ABCDEF”, 3, 2) = “AEF”
REPLACE IN1: STRING STRING Sustituye L caracteres de IN1 por IN2 comenzando en la
IN2: STRING posición P (la posición se cuenta partir del valor 1).
L: DINT Ejemplo: REPLACE(“ABCDEF”, “XY”, 3, 2) = “AXYEF”
P: DINT


TEL (+598) 2622 0651
FAX (+598) 2622 2048
FIND IN1: STRING DINT Devuelve la posición de comienzo de la primer aparición de
IN2: STRING IN2 en IN1 (la posición se cuenta partir del valor 1). Si no se
encuentra IN2 devuelve 0.
Ejemplo: FIND(“ABCDEF”, “DE”) = 4
STRCMP IN1: STRING DINT Devuelve el resultado N de la comparación de IN1 e IN2,
IN2: STRING siendo (N < 0 si IN1 < IN2), (N = 0 si IN1 = IN2) y (N > 0 si IN1
> IN2)
STRICMP IN1: STRING DINT Realiza la misma operación que la función STRCMP pero en
IN2: STRING forma insensible a mayúsculas y minúsculas
STRMATCH IN1: STRING BOOL Indica si la cadena IN1 cumple con la máscara IN2. En la
IN2: STRING máscara IN2 se pueden utilizar los caracteres comodines
usuales '?' y '*'
Ejemplo: STRMATCH(“ABCDEF”, “*C?E”) = TRUE
STRIMATCH IN1: STRING BOOL Realiza la misma operación que la función STRMATCH pero
IN2: STRING en forma insensible a mayúsculas y minúsculas
NOTAS
1. El operador aritmético estándar “+” se extiende para aplicarse a datos del tipo STRING. La
expresión A + B, siendo A y B del tipo STRING es equivalente a CONCAT(A, B). Esta extensión no
es parte de la norma, pero la soportamos por compatibilidad con las expresiones del MIRAGE.
6.7.5 Funciones de tiempo
Tabla 7 – Funciones de tiempo

+ IN1: TIME TIME Suma
IN2: TIME
+ IN1: DATE_AND_TIME DATE_AND_TIME Suma
IN2: TIME
- IN1: TIME TIME Resta
IN2: TIME
- IN1: DATE_AND_TIME DATE_AND_TIME Resta
IN2: TIME
- IN1: DATE_AND_TIME TIME Resta
IN2: DATE_AND_TIME
* IN1: TIME TIME Multiplicación
IN2: ANY_NUM
/ IN1: TIME TIME División
IN2: ANY_NUM
NOTAS
1. Las funciones de tiempo utilizan los operadores aritméticos estándar.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
6.7.6 Funciones auxiliares
Tabla 8 – Funciones auxiliares

SET_DATE_AND_ YEAR: DINT DATE_AND_TIME Devuelve una marca de tiempo
TIME MONTH: DINT generada a partir de sus componentes.
DAY: DINT Esta función realiza la operación
HOUR: DINT inversa a la del bloque funcional
MINUTE: DINT GET_DATE_AND_TIME (Nota 4)
SECOND: DINT
NANOSECOND: DINT
CLOCK_CYCLES TIME Devuelve el valor actual del contador de
ciclos interno de la CPU (Notas 1 y 2)
CLOCK_CYCLES_ BEGIN: TIME TIME Devuelve el tiempo transcurrido (en
ELAPSED_TIME END: TIME nanosegundos) entre dos marcas de
tiempo correspondientes a valores del
contador de ciclos de la CPU (Notas 2
y 3)
NOTAS
1. Si bien el valor devuelto por la función CLOCK_CYCLES se maneja como un tipo de dato TIME, en
realidad no es un valor de duración TIME real sino que representa un contador de los ciclos de la
CPU y constituye un entero de 64 bits sin signo. Como no soportamos este tipo de dato utilizamos
el tipo TIME que también es un entero de 64 bits pero con signo.
2. Las marcas BEGIN y END no son valores de duración TIME reales, sino que corresponden a
valores devueltos por la función CLOCK_CYCLES, y además la marca END debe ser posterior en
el tiempo a la marca BEGIN. El valor devuelto por la función CLOCK_CYCLES_ELAPSED_TIME sí
es un valor TIME real.
3. Las funciones CLOCK_CYLES y CLOCK_CYCLES_ELAPSED_TIME permiten contabilizar con muy

alta precisión intervalos de tiempos, y lo que es más importante aún, que es independiente de la
hora real de la máquina y por lo tanto insensible a cambios en la misma. Si bien este contador
interno de la CPU puede representar valores de tiempo muy grandes, de todas formas la función
CLOCK_CYCLES_ELAPSED_TIME tiene en cuenta un posible rollover del contador. Por ejemplo
en una RTU típica con una CPU de 500MHz, el contador se incrementa unas 500 millones de veces
por segundo por lo cual recién realizaría el rollover a cero en aproximadamente 1170 años de
funcionamiento continuo. Estas funciones son las mismas utilizadas en los bloques funcionales
estándar BLINK, TP, TON y TOFF para implementar sus temporizadores. Un ejemplo de utilización
de estas funciones puede verse en el ejemplo del bloque funcional de usuario BLINK_USER.
4. Si la función SET_DATE_AND_TIME no puede convertir su entrada a una marca de tiempo o el

valor convertido esta fuera de rango, no se genera un error de ejecución y por lo tanto la ejecución
del PLC no se detiene, sino que simplemente se devuelve la marca de tiempo inválida y se continua
con el procesamiento normal del PLC.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
6.8 Expresiones
Las expresiones están compuestas por operadores y operandos. Un operando puede ser una constante,
una variable, una invocación de función u otra expresión. Los operadores del lenguaje se resumen en la
tabla 7. La evaluación de una expresión consiste en aplicar los operadores a los operandos según el orden
de prioridad de cada operador, empezando por el operador de mayor prioridad y terminando con el de
menor prioridad. Los operadores de igual prioridad se aplicarán tal como vienen escritos en la expresión de
izquierda a derecha.
Por ejemplo, si A, B, C y D son variables del tipo DINT y tienen respectivamente los valores 1, 2, 3 y 4
entonces la expresión
A + B – C * ABS(D)
deberá dar como resultado el valor –9, y la expresión
(A + B – C) * ABS(D)
deberá dar como resultado el valor 0.
Si un operador tiene dos operandos, se evaluará primero el operando de más a la izquierda. Por ejemplo en
la expresión
SIN(A) * COS(B)
se evalúa primero la expresión SIN(A), seguida de la expresión COS(B) y por último se evalúa el producto.
Tabla 9 – Operadores del lenguaje
Operador Símbolo Prioridad

Paréntesis (expresión) MAXIMA
Evaluación de función Identificador(lista de argumentos)
Elemento gráfico de comentario LABEL(“texto”)
Exponenciación **
Negación aritmética -
Negación Booleana NOT
Multiplicación *
División /
Módulo MOD
Suma +
Resta -
Comparación < , > , <= , >=
Igualdad =
Desigualdad <>
AND Booleano AND
XOR Booleano XOR
OR Booleano OR MINIMO


TEL (+598) 2622 0651
FAX (+598) 2622 2048
6.8.1 Operador LABEL
El operador LABEL es una extensión al lenguaje ST de la norma. Se utiliza para introducir comentarios en
el diagrama gráfico asociado a un programa. Este operador se aplica a la expresión o a la sentencia que se
encuentra inmediatamente a la derecha del operador.
El operador tiene la forma:
LABEL(”Texto descriptivo”)
Ejemplo:
6.9 Sentencias
Todas las sentencias deben terminarse siempre mediante el carácter “;” (punto y coma).
6.9.1 Sentencia vacía

La sentencia vacía es una sentencia que no hace nada. El compilador asume que existe una sentencia
vacía cuando escribimos en el programa un separador de sentencias “;” en forma innecesaria.
Normalmente esta sentencia se incluye en los lenguajes de programación simplemente para evitar errores
de compilación cuando el programador introduce separadores de sentencia innecesarios inadvertidamente.
Ejemplo:
A := 1.0;; (* El segundo “;” constituye una sentencia vacía *)


TEL (+598) 2622 0651
FAX (+598) 2622 2048
6.9.2 Sentencia de asignación
La sentencia de asignación tiene la forma:
A := <expresion>;
El resultado de la evaluación de la expresión de la derecha se asigna a la variable A de la izquierda. La

variable A debe corresponder a una variable de escritura y además el tipo de dato devuelto por la expresión
debe corresponder con el tipo de dato de la variable, de lo contrario la sentencia no compila.
NOTAS
1. Las sentencias de asignación de valores de tipos de datos derivados (estructuras y arrays) no son
diagramables, es decir que para los programas diagramables sólo se permiten dentro de headers
no diagramables.
Ejemplo:


TEL (+598) 2622 0651
FAX (+598) 2622 2048
6.9.3 Sentencia HEADER
La sentencia header o de encabezado es una extensión al lenguaje ST de la norma. Esta sentencia permite
describir, en el diagrama gráfico asociado a un programa, un conjunto de sentencias y controlar su
visibilidad.
La sentencia de encabezado tiene la forma:
HEADER(<diagramable>, <descripción>, <visibilidad>)

…
<conjunto de sentencias>
…
END_HEADER;
Donde los parámetros de la sentencia tienen el siguiente significado:
• <diagramable>: Parámetro de tipo BOOL. Indica si el header y el conjunto de sentencias contenidas es

diagramable o no. El valor FALSE indica que el header no es diagramable, y el valor TRUE indica que sí
es diagramable.
• <descripción>: Parámetro de tipo STRING. Texto descriptivo del conjunto de sentencias contenidas en
el header.
• <visibilidad>: Parámetro de tipo BOOL. Indica si el header y el conjunto de sentencias contenidas es

visible para el operador o no. El valor FALSE indica que el header no es visible para el operador, y el
valor TRUE indica que sí es visible para el operador. Observar que el header es siempre visible para el
administrador independientemente del valor de este parámetro.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
NOTAS
1. Los parámetros <descripción> y <visibilidad> sólo se aplican si el parámetro <diagramable> es
TRUE.
2. Las sentencias headers no pueden anidarse, es decir no se puede incluir una sentencia header
dentro de otra.
3. La sentencia header no está permitida dentro de las funciones y bloques funcionales.
4. Para un programa no diagramable, si bien la sentencia header está permitida, la misma no tiene
ningún resultado gráfico, es decir sólo se ejecutan las sentencias contenidas dentro de la misma.
Esto permite pasar un programa diagramable a no diagramable sin que haya un error de
compilación.
Ejemplo:


TEL (+598) 2622 0651
FAX (+598) 2622 2048
6.9.4 Sentencia IF
La sentencia IF permite realizar control de flujo en el programa. Esta sentencia no es diagramable, lo cual
significa que para un programa diagramable sólo se puede utilizar dentro de un header no diagramable.
La sentencia IF tiene la forma:
IF <expresión boolana> THEN

ELSIF <expresión booleana> THEN
ELSE
END_IF;
NOTAS
1. El elemento ELSIF es opcional y pueden haber varias ocurrencias del mismo.
2. El elemento ELSE es opcional y sólo puede haber una única ocurrencia del mismo.
Ejemplo:


TEL (+598) 2622 0651
FAX (+598) 2622 2048
6.9.5 Sentencia CASE
La sentencia case permite realizar control de flujo en el programa. Esta sentencia no es diagramable, lo
cual significa que para un programa diagramable sólo se puede utilizar dentro de un header no
diagramable.
La sentencia CASE tiene la forma:
CASE <expresión entera> OF

<elem>:
<elem>:
ELSE
END_CASE;


TEL (+598) 2622 0651
FAX (+598) 2622 2048
Los elementos <elem> son constantes enteras que pueden ser de la forma:
• N: Un único valor entero

• N1..N2: Un rango cerrado de valores enteros
• N1, N2..N3, N4, N5..N6: La combinación de las dos opciones anteriores, es decir valores enteros y
rangos de valores enteros, separados por el carácter “,” (coma).
NOTAS
1. El sistema controla que no haya intersección entre los distinos elementos <elem> de una sentencia
CASE, de lo contrario no compila.
2. El sistema controla que el rango de valores de un elemento <elem> sea válido, es decir que el
primer elemento del rango sea menor o igual que el último, de lo contrario no compila.
3. El elemento ELSE es opcional y sólo puede haber una única ocurrencia del mismo.
Ejemplo:
6.9.6 Sentencia RETURN

La sentencia RETURN termina inmediatamente la ejecución de un programa, función o bloque funcional.
Dentro de los programas solo puede ser usada en programas no diagramables.
La sentencia RETURN tiene la forma:
RETURN;


TEL (+598) 2622 0651
FAX (+598) 2622 2048
6.9.7 Sentencias de iteración
La sentencias FOR, WHILE y REPEAT son sentencias de iteración que permiten ejecutar repetidamente un
grupo se sentencias. Estas sentencias no son diagramables, lo cual significa que para un programa
diagramable sólo pueden utilizarse dentro de un header no diagramable.
6.9.7.1 Sentencia FOR

La sentencia FOR tiene la forma:
FOR <elem> := <valor_inicial> TO <valor_final> BY <valor_incremento> DO

END_FOR;
Donde:
• El elemento <elem> es la variable de control del FOR y corresponde a una variable de tipo DINT.
• Los elementos <valor_inicial>, <valor_final> y <valor_incremento> corresponden a

expresiones de tipo DINT. Estas tres expresiones son evaluadas una única vez al inicio de la
sentencia, lo que significa que sus valores permanecen constantes durante toda la ejecución del
FOR.
• La parte “BY <valor_incremento>” de la sentencia es opcional y en su defecto significa que la

variable de control se incrementa en uno en cada iteración del FOR.
• Si la expresión <valor_incremento> corresponde al valor cero se produce un error de ejecución

del PLC.
La sentencia FOR ejecuta repetidamente una secuencia de sentencias mientras una progresión de valores
se asigna a la variable de control <elem> de la sentencia. Inicialmente la variable de control toma el valor
inicial <valor_inicial> y luego en cada iteración su valor aumenta o disminuye en una magnitud igual a
<valor_incremento> hasta exceder el valor final <valor_final>.
Si <valor_incremento> corresponde a un valor positivo, significa que la variable de control aumenta en

cada iteración hasta superar el valor final, y si <valor_incremento> corresponde a un valor negativo,
significa que la variable de control disminuye en cada iteración hasta ser menor que el valor final.
El chequeo de la condición de parada se realiza al inicio de cada iteración, por lo cual si inicialmente el valor
de la variable de control excede el valor final, la secuencia de iteraciones nunca se ejecuta.
Ejemplo
El siguiente programa inicializa los elementos de un array A1 con los valores de sus índices. La
inicialización se hace de tres formas distintas pero equivalentes utilizando las sentencias FOR, WHILE y
REPEAT.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
6.9.7.2 Sentencia WHILE
La sentencia WHILE tiene la forma:
WHILE <condición> DO
END_WHILE;
Donde:
• El elemento <condición> corresponde a una expresión tipo BOOL.
La sentencia WHILE ejecuta repetidamente una secuencia de sentencias mientras que la expresión
booleana <condición> sea TRUE.
El chequeo de la condición de parada se realiza al inicio de cada iteración, por lo cual si inicialmente el valor
de la expresión <condición> es FALSE, la secuencia de iteraciones nunca se ejecuta.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
6.9.7.3 Sentencia REPEAT
La sentencia REPEAT tiene la forma:
REPEAT
UNTIL <condición> END_REPEAT;
Donde:
• El elemento <condición> corresponde a una expresión tipo BOOL.
La sentencia REPEAT ejecuta repetidamente una secuencia de sentencias hasta que la expresión booleana
<condición> sea TRUE.
El chequeo de la condición de parada se realiza al final de cada iteración, por lo cual siempre se ejecutará
al menos una iteración.
6.9.7.4 Sentencia EXIT

Esta sentencia sólo se permite dentro de una sentencia de iteración FOR, WHILE o REPEAT, y lo que hace
es provocar la salida inmediata del bucle de iteración donde está contenida.
Cuando la sentencia EXIT se utiliza dentro de sentencias de iteración anidadas, el EXIT se aplica sólo al
bucle de iteración más interno en el cual está contenida la sentencia EXIT.
Ejemplo
En el siguiente programa si la variable booleana FLAG es FALSE el resultado de la variable SUMA será 8,
mientras que si FLAG es TRUE entonces SUMA será 2.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
6.9.8 Sentencia de evaluación de un bloque funcional
Para poder utilizar un bloque funcional primero hay que instanciarlo mediante una variable. Esta variable es
la que mantiene el estado interno del bloque funcional durante toda la ejecución del PLC. La sentencia de
evaluación de un bloque funcional asigna los parámetros de entrada y calcula el nuevo estado interno del
bloque funcional.
La sentencia de evaluación de un bloque funcional consiste en utilizar la variable correspondiente a la

instancia del bloque funcional como si fuera una función pasándole la lista de parámetros necesarios.
Las salidas de un bloque funcional instanciado pueden ser usadas en cualquier parte de un programa
referenciándolas como un campo de la variable del bloque funcional.
Por ejemplo, supongamos un bloque funcional con dos parámetros de entrada booleanos y dos parámetros
de salida enteros llamados SAL1 y SAL2 instanciado en la variable de nombre BLOQ1.
Para usarlo lo que hay que hacer es:
BLOQ1(<expreson boolana>, <expresión booleana>); // Sentencia de evaluación

VAR := BLOQ1.SAL1; // Primer uso
…
…
VAR := BLOQ1.SAL2; // Siguientes usos
La primera utilización del bloque funcional después de su evaluación se toma como un caso especial. En el
diagrama gráfico asociado al programa, la primera utilización corresponde a la salida por defecto conectada
al bloque funcional y puede ser usada en ese contexto como parte de una expresión.
El resto de las asignaciones se dibujan como operadores de entrada.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
6.9.9 Sentencia TRACE
La sentencia TRACE es una extensión al lenguaje ST de la norma. Permite generar mensajes de texto
utilizados para la depuración de los POUs. Esta sentencia sólo se ejecuta cuando el PLC está corriendo en
modo DEBUG-CICLO-A-CICLO. Cuando el PLC está corriendo en modo NORMAL, esta sentencia no hace
nada y no consume ciclos de CPU. Los mensajes de texto generados por esta sentencia se pueden ver
desde la terminal del módulo en el Administrador RTUQM.
La sentencia TRACE tiene la forma:
TRACE(<mensaje>, <lista_parámetros>);
Donde los parámetros de la sentencia tienen el siguiente significado:
• <mensaje>: Parámetro de tipo STRING. Indica el mensaje de texto a generar. Dentro del texto se
puede utilizar el formato especial “{X}” para referenciar al parámetro “X” de la lista de parámetros
<lista_parámetros>, siendo “X” el índice del parámetro dentro de la lista. Los índices se cuentan a
partir de cero, es decir que el primer parámetro de la lista corresponde al índice cero, el segundo al
índice uno, y así sucesivamente.
• <lista_parámetros>: Lista de parámetros donde cada parámetro corresponde a una expresión de un

tipo de dato elemental. La lista de parámetros puede estar vacía, lo cual significa que no se utilizan
parámetros dentro del texto del mensaje.
NOTAS
1. La sentencia TRACE se comporta como una función con número de parámetros variables, siendo
el primer parámetro de tipo STRING el único obligatorio, y el resto de los parámetros pueden ser de
cualquiera de los tipos de datos elementales soportados.
2. La sintaxis utilizada en la generación del texto del mensaje es similar a la utilizada por la función
String.Format() del C#.
3. La sentencia TRACE se puede utilizar en todos los POUs, y a pesar de no ser una sentencia
diagramable, igual puede utilizarse dentro de un programa diagramable.
Ejemplo:


TEL (+598) 2622 0651
FAX (+598) 2622 2048
Mensajes de trace generados:
26/12/2014 14:32:07.549 (UTC) - Programa (Ejemplo_TRACE) Línea (10) - Int 4

Real 2.3 Bool FALSE String Hola y adiós Time T#1h5s DateTime DT#2015-01-01-
00:00:00
26/12/2014 14:32:07.549 (UTC) - Programa (Ejemplo_TRACE) Línea (20) - Param1:

Hola Param0: Chau Param1: Hola


TEL (+598) 2622 0651
FAX (+598) 2622 2048
Observar como en los mensajes de trace generados se agrega automáticamente como
prefijo al texto del usuario, la marca de tiempo de ejecución de la sentencia,
el nombre del POU que contiene la sentencia y el número de línea de la
sentencia dentro del POU.
Toda sentencia trace mal formada simplemente se decarta generando un mensaje de

error. En el ejemplo anterior la sentencia trace de la línea 16 se descarta
generando el siguiente error:
(1:Error ) (1) 26/12/2014 14:32:07.549 (UTC) LGR_ExpStmtTrace::Calculate - POU

(Ejemplo_TRACE) Línea (16) - Trace no válido - Indice (4) no válido


TEL (+598) 2622 0651
FAX (+598) 2622 2048
7 Bloques funcionales del sistema
A continuación se detalla el conjunto de bloques funcionales predefinidos por el sistema. A excepción de los
bloques funcionales BLINK, RF_TRIG y GET_DATE_AND_TIME, el resto corresponden a bloques
funcionales estándar definidos en la norma.
7.1 BLINK – Parpadeo

El bloque BLINK implementa la función de temporizador de parpadeo o tren de pulsos.
BLINK
BOOL RUN
TIME CYCLE Q BOOL
Diagrama de tiempos
RUN
CYCLE
Parámetros de entrada
Nombre Tipo Descripción
RUN BOOL Habilitación
CYCLE TIME Período del temporizador
Parámetros de salida
Q BOOL Señal de salida


TEL (+598) 2622 0651
FAX (+598) 2622 2048
Evaluación
BLINK (RUN, CYCLE);
Funcionamiento
Si la entrada RUN es TRUE entonces la salida Q cambia entre TRUE y FALSE con un ciclo de trabajo del
50% y con un período dado por el valor de la entrada CYCLE, si es OFF la salida queda en FALSE
Ejemplo de uso
Se usa un bloque funcional BLINK instanciado con el nombre BLK1 para cambiar el estado de la variable
interna de tipo BOOL MEM1, con un ciclo de 1 segundo;


TEL (+598) 2622 0651
FAX (+598) 2622 2048
7.2 TP – Temporizador de pulso
El bloque TP implementa la función de temporizador de pulsos.
TP
BOOL IN Q BOOL
TIME PT ET TIME
Diagrama de tiempos
IN
PT PT PT
PT
ET
Tiempo
IN BOOL Señal de entrada.
PT TIME Período de temporización
Q BOOL Salida temporizada
ET TIME Tiempo transcurrido


TEL (+598) 2622 0651
FAX (+598) 2622 2048
Evaluación
TP (IN, PT);
Funcionamiento
Genera en Q un pulso de tiempo constante igual a PT cada vez que detecta un flanco ascendente en la
entrada IN.
Normalmente la salida Q está en FALSE. Si se detecta un flanco ascendente en la entrada IN entonces la

salida Q pasa a TRUE durante un tiempo determinado por la entrada PT. La salida ET muestra el tiempo
transcurrido del pulso. Una vez terminado el pulso si IN ya esta en cero pasa inmediatamente ET a cero, de
lo contrario espera por el próximo flanco descendente de IN para pasar ET a cero. Si durante la generación
del pulso se detecta otro flanco ascendente de IN, el pulso continúa normalmente pero cuando termina se
resetea inmediatamente el tiempo ET a cero sin esperar por el flanco descendente de la entrada IN.
Ejemplo de uso
Se usa un bloque funcional TP instanciado con el nombre TP1. Se configura el tiempo de pulso en 500ms.
La entrada a temporizar está dada por la variable interna de tipo BOOL MEM1 y la salida temporizada se
asigna a la variable interna de tipo BOOL MEM2.


TEL (+598) 2622 0651
FAX (+598) 2622 2048

TEL (+598) 2622 0651
FAX (+598) 2622 2048
7.3 TON – Temporizador de retardo al encendido
El bloque TON implementa la función de temporizador de retardo al encendido
TON
BOOL IN Q BOOL
TIME PT ET TIME
Diagrama de tiempos
IN
PT PT PT
PT
ET
Tiempo
IN BOOL Señal de entrada.
Evaluación


TEL (+598) 2622 0651
FAX (+598) 2622 2048
TON (IN, PT);
Funcionamiento
Copia la entrada IN en la salida Q retardando el flanco ascendente en un tiempo PT.
Normalmente la salida Q está en FALSE. Si se detecta un flanco ascendente en la entrada IN entonces se

dispara un contador (ET) ascendente. Cuando este contador llega al valor dado por la entrada PT la salida
pasa a TRUE y se mantiene en tal estado hasta que la entrada IN pasa a FALSE. Si la entada cambia a
FALSE antes que transcurra el tiempo PT, la salida no cambia de estado y el temporizador se resetea a 0.
La salida ET muestra el tiempo transcurrido del temporizador.
Ejemplo de uso
Ver el caso del temporizador de pulso.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
7.4 TOF – Temporizador de retardo al apagado
El bloque TOF implementa la función de temporizador de retardo al apagado
TOF
BOOL IN Q BOOL
TIME PT ET TIME
Diagrama de tiempos
IN
PT PT PT
PT
ET
Tiempo
IN BOOL Señal de entrada


TEL (+598) 2622 0651
FAX (+598) 2622 2048
Evaluación
TOFF (IN, PT);
Funcionamiento
Copia la entrada IN en la salida Q retardando el flanco descendente en un tiempo PT.
Normalmente la salida Q está en FALSE. Si se detecta un flanco ascendente en la entrada IN entonces la

salida Q pasa a TRUE inmediatamente. Cuando se detecta un flanco descendente en la entrada IN se
dispara un temporizador ET y cuando este llega al valor dado por la entrada PT la salida pasa a FALSE. Si
la entada cambia a TRUE antes que transcurra el tiempo PT, la salida Q no cambia de estado y el
temporizador se resetea a cero.
La salida ET muestra el tiempo transcurrido del temporizador.
Ejemplo de uso
Ver el caso del temporizador de pulso.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
7.5 R_TRIG – Detector de flanco ascendente
El bloque R_TRIG implementa la función de detección de flancos ascendentes.
R_TRIG
BOOL CLK Q BOOL
CLK BOOL Señal de entrada
Evaluación
R_TRIG (CLK);
Funcionamiento
Normalmente la salida Q está en FALSE. Si se detecta un flanco ascendente (transición FALSE a TRUE)
en la entrada CLK entonces la salida pasa a TRUE durante un ciclo de PLC.
Ejemplo de uso
Se usa un bloque funcional R_TRIG instanciado con el nombre RT1 para detectar flancos ascendentes en
la variable interna de tipo BOOL MEM1. El flanco detectado se asigna a la variable interna de tipo BOOL
MEM2.


TEL (+598) 2622 0651
FAX (+598) 2622 2048

TEL (+598) 2622 0651
FAX (+598) 2622 2048
7.6 F_TRIG – Detector de flanco descendente
El bloque F_TRIG implementa la función de detección de flancos descendentes.
F_TRIG
BOOL CLK Q BOOL
Evaluación
F_TRIG (CLK);
Funcionamiento
Normalmente la salida Q está en FALSE. Si se detecta un flanco descendente (transición TRUE a FALSE)
en la entrada CLK entonces la salida pasa a TRUE durante un ciclo de PLC.
Ejemplo de uso
Ver el caso del detector de flancos de subida.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
7.7 RF_TRIG – Detector de flancos
El bloque RF_FTRIG implementa la función de detección de flancos ascendentes y descendentes.
RF_TRIG
BOOL CLK Q BOOL
Evaluación
RF_TRIG (CLK);
Funcionamiento
Normalmente la salida Q está en FALSE. Si se detecta un flanco ascendente o descendente (cualquier
transición entre TRUE y FALSE) en la entrada CLK entonces la salida pasa a TRUE durante un ciclo de
PLC.
Ejemplo de uso
Ver el caso del detector de flancos de subida.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
7.8 CTU – Contador ascendente
El bloque CTU implementa la función de contador ascendente.
CTU
BOOL CU Q BOOL
BOOL R
DINT PV CV DINT
Señal a ser contada. Este campo tiene un detector de flanco
CU BOOL
ascendente
R BOOL Señal de reset de contador
PV DINT Valor máximo
Q BOOL Señal de valor máximo alcanzado
CV DINT Valor actual de la cuenta
Evaluación
CTU (CU, R, PV);
Funcionamiento
Normalmente la salida Q está en FALSE. El valor de CV se va incrementando a cada flanco de subida de
CU. Cuando CV alcanza PV la salida Q pasa a TRUE y CV deja de incrementarse. Un valor TRUE en la
entrada R vuelve CV a cero.
Ejemplo de uso
Se usa un bloque funcional CTU instanciado en una variable de nombre CT1 para contar cambios en la
variable interna de tipo BOOL MEM1 hasta el valor 100. Cuando se alcanza el máximo se pasa a TRUE la
variable interna de tipo BOOL MEM2.


TEL (+598) 2622 0651
FAX (+598) 2622 2048

TEL (+598) 2622 0651
FAX (+598) 2622 2048
7.9 CTD – Contador descendente
El bloque CTD implementa la función de contador descendente.
CTD
BOOL CD Q BOOL
BOOL LD
DINT PV CV DINT
Señal a ser contada. Este campo tiene un detector de flanco
CD BOOL
ascendente
LD BOOL Señal de preseteo al valor inicial
PV DINT Valor inicial
Q BOOL Señal de valor cero alcanzado
Evaluación
CTD (CD, LD, PV);
Funcionamiento
Normalmente la salida Q está en FALSE. El valor de CV se va decrementando a cada flanco de subida de
CD. Cuando CV alcanza 0 la salida Q pasa a TRUE y CV deja de decrementarse. Un valor TRUE en la
entrada LD carga el valor de PV en CV.
Ejemplo de uso
Ver el caso del contador ascendente.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
7.10 CTUD – Contador ascendente-descendente
El bloque CTUD implementa la función de contador ascendente/descendente.
CTUD
BOOL CU Q BOOL
BOOL CD
BOOL R
BOOL LD
DINT PV CV DINT
Señal de conteo ascendente. Este campo tiene un
CU BOOL
detector de flanco ascendente
Señal de conteo descendente. Este campo tiene un
CD BOOL
detector de flanco ascendente
R BOOL Señal de reset de contador
LD BOOL Señal de preseteo al valor inicial
PV DINT Valor máximo
QU BOOL Salida de conteo ascendente
QD BOOL Salida de conteo descendente
Evaluación
CTUD (CU, CD, R, LD, PV);
Funcionamiento
Cada flanco ascendente de la señal CU incrementa el contador CV y cada flanco ascendente de la señal
CD la decrementa. CV se incrementa hasta PV y se decrementa hasta 0.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
Normalmente las salidas QU y QD se encuentran en FALSE. Cuando CV vale PV la salida QU se pone en
TRUE, cuando CV vale 0 la salida QD se pone en TRUE.
Un valor TRUE en la entrada R pone CV en 0 y un valor TRUE en la entrada LD lo pone en PV. La entrada
R tiene prioridad sobre la entrada LD, esto significa que si ambas entradas están en TRUE, la entrada R es
la que gana y por lo tanto CV pasa a 0.
Ejemplo de uso
Ver el caso del contador ascendente.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
7.11 SR – Biestable con entrada dominante set
El bloque SR implementa la función de elemento biestable con entrada dominante SET.
SR
BOOL S1
BOOL R Q1 BOOL
S1 BOOL Entrada SET (dominante)
R BOOL Entrada RESET
Q BOOL Salida del elemento biestable
Evaluación
SR (S1, R);
Funcionamiento
La salida Q pasa a TRUE cuando S1 pasa a TRUE y a FALSE cuando R pasa a FALSE. Si S1 y R están en
TRUE la salida está en TRUE, si S1 y R están en FALSE la salida no cambia de estado.
S1 R Q
TRUE FALSE TRUE
FALSE TRUE FALSE
TRUE TRUE TRUE
FALSE FALSE <no varía>
Ejemplo de uso


TEL (+598) 2622 0651
FAX (+598) 2622 2048
Se usa un bloque funcional SR instanciado con el nombre SR1 para memorizar el estado dado por las
variables internas de tipo BOOL MEM1 y MEM2. El estado memorizado se copia sobre la variable interna
de tipo BOOL MEM3.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
7.12 RS – Biestable con entrada dominante reset
El bloque RS implementa la función de elemento biestable con entrada dominante RESET.
RS
BOOL S
BOOL R1 Q1 BOOL
S BOOL Entrada SET
R1 BOOL Entrada RESET (dominante)
Q BOOL Salida del elemento biestable
Evaluación
RS (S, R1)
Funcionamiento
La salida Q pasa a TRUE cuando S pasa a TRUE y a FALSE cuando R1 pasa a FALSE. Si S y R1 están en
TRUE la salida está en FALSE, si S y R1 están en FALSE la salida no cambia de estado.
S1 R Q
TRUE FALSE TRUE
FALSE TRUE FALSE
TRUE TRUE FALSE
FALSE FALSE <no varía>
Ejemplo de uso
Ver el caso del biestable SR.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
7.13 GET_DATE_AND_TIME
Devuelve los campos componentes de una marca de tiempo del tipo DATE_AND_TIME. Tanto el parámetro
de entrada como los parámetros de salida se manejan en UTC. Este bloque funcional realiza la operación
inversa a la función del sistema SET_DATE_AND_TIME.
Si el bloque funcional no puede realizar la conversión o el parámetro de entrada esta fuera de rango, la
ejecución del PLC no se detiene sino que simplemente se inicializan todos los parámetros de salida al valor
cero y se continúa con el procesamiento normal del PLC.
GET_DATE_AND_TIME
DATE_AND_TIME IN YEAR DINT
MON DINT
DAY DINT
HOUR DINT
MIN DINT
SEC DINT
NSEC DINT
IN DATE_AND_TIME Marca de tiempo (en UTC)
Parámetros de salida (en UTC)

YEAR DINT Año
MON DINT Mes
DAY DINT Día
HOUR DINT Hora
MIN DINT Minuto


TEL (+598) 2622 0651
FAX (+598) 2622 2048
SEC DINT Segundo
NSEC DINT Nanosegundo
Evaluación
GET_DATE_AND_TIME (IN);
Ejemplo de uso
La variable fbDT corresponde a una instancia del bloque funcional GET_DATE_AND_TIME. El programa
separa la marca de tiempo dada por la variable del sistema $Time en sus componentes y luego los vuelve a
unir en la variable auxiliar dt1 mediante la función del sistema SET_DATE_AND_TIME.


TEL (+598) 2622 0651
FAX (+598) 2622 2048

TEL (+598) 2622 0651
FAX (+598) 2622 2048

TEL (+598) 2622 0651
FAX (+598) 2622 2048
8 Visualizador de lógicas
Se suministra un programa independiente que permite visualizar en tiempo real el estado de las lógicas.
Se presenta el diagrama lógico con los valores superpuestos. Los valores analógicos se muestran en un
cuadro de texto, los valores digitales se muestran resaltando en color el borde de los objetos, rojo es TRUE
y azul es FALSE
8.1 Parámetros de la línea de comandos

El visualizador permite el uso de una serie de parámetros de línea de comandos para permitir su ejecución
automática. Los mismos son:
-h str : Conectar automaticamente con el host de direccion IP str

-po n : Usar para la conexión automática el puerto TCP n
-u str : Usar para la conexión automática el nombre de usuario str
-p str : Usar para la conexión automática la contraseña str
-pr str : Mostrar programa str
-f : Arrancar en fullscreen


TEL (+598) 2622 0651
FAX (+598) 2622 2048
9 Parámetros de la línea de comandos
El módulo lógicas es usualmente ejecutado por la consola, aunque puede ser ejecutado desde la línea de
comandos si así se desea.
La sintaxis para ejecutar el módulo desde la línea de comandos es la siguiente:
logicas [-d level] [-h] -f file
Opciones:
-d Debug. El programa se ejecuta en modalidad de debug y level indica el nivel de debug para los
mensajes.
-h Despliega información de uso y termina.
-i Despliega información de la versión y termina.
-f file Archivo de configuración. file es el nombre del archivo de configuración del programa, por defecto
se toma el archivo plc.ini. Si no se especifica la ruta del archivo se toma por defecto el directorio
/rtu/config.
10 Configuración
10.1 Parámetros de configuración

Se detallan a continuación los parámetros de funcionamiento configurables mediante el administrador de
RTU.
10.1.1 Carpeta General

- Descripción: Texto libre que describe la configuración del módulo.
- Puerto TCP de atención de clientes: Puerto TCP para la atención de los clientes visualizadores de las
lógicas. El valor cero significa que no se atienden clientes. El valor por defecto es 2013.
- Duración (en milisegundos) del ciclo de trabajo del PLC: El valor cero significa que se ejecuta lo más
rápido posible. El valor por defecto es 50 ms.
- Dirección de supervisión: Corresponde al comienzo de la tabla de puntos de supervisión del módulo. El

valor cero significa que no se exportan puntos de supervisión hacia la BD. El valor por defecto es 0.
- Buffer de puntos: Indica si está habilitado el buffer de puntos para los puntos de entrada al PLC. El valor
por defecto es No.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
- Manejo de errores: Indica la acción automática que se realiza cuando se produce un error de ejecución
del PLC, ver sección Tratamiento de errores.
- Timeout del watchdog (en milisegundos): Si el ciclo actual del PLC supera este tiempo se produce un
error de ejecución y se ejecuta la acción preestablecida para el manejo de errores. El valor cero
significa que no se utiliza el watchdog. El valor por defecto es 5000 ms.
10.1.2 Estructuras
Permite configurar las estructuras definidas por el usuario.
10.1.3 Arrays
Permite configurar los tipos de datos array definidos por el usuario.
10.1.4 Variables Globales

Permite configurar la lista de las variables globales a todos los POUs.
10.1.5 Programas
Permite configurar los programas del usuario.
10.1.6 Bloques Funcionales

Permite configurar los bloques funcionales del usuario.
10.1.7 Funciones
Permite configurar las funciones del usuario.
10.1.8 Carpeta Archivo INI

La configuración se salva como archivo de texto ASCII. Esta opción permite editar el archivo directamente
con un editor. Los parámetros configurables son los mismos que a través de la interfaz gráfica pero para
cambios repetitivos puede resultar más conveniente.
10.2 Importación/exportación
El Administrador RTUQM permite realizar operaciones de “drag-and-drop” entre configuraciones del módulo
lógicas, de forma de poder importar o exportar elementos de una configuración a otra.
Los elementos configurables a los cuales se pueden aplicar las operaciones de “drag-and-drop” son los
siguientes:
• Variables globales: Se permite importar una variable global desde otra configuración. Al importar la
variable si el tipo de dato de la misma no existe en la configuración destino, también se importa
automáticamente.
• Programas: Se permite importar un programa completo desde otra configuración. Al importar el

programa se importan automáticamente todas las variables internas del programa, y también los
tipos de datos de las mismas si es que no existen en la configuración destino.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
• Funciones: Se permite importar una función completa desde otra configuración. Al importar la
función se importan automáticamente todas las variables internas de la función, y también los tipos
de datos de las mismas si es que no existen en la configuración destino. Además si la función utiliza
otras funciones y las mismas no existen en la configuración destino, también se importan
automáticamente.
• Bloques Funcionales: Se permite importar un bloque funcional completo desde otra configuración.
Al importar el bloque funcional se importan automáticamente todas las variables internas del bloque
funcional, y también los tipos de datos de las mismas si es que no existen en la configuración
destino. Además si el bloque funcional utiliza funciones u otros bloques funcionales y los mismos no
existen en la configuración destino, también se importan automáticamente.
• Arrays: Se permite importar un tipo de dato array desde otra configuración. Al importar el array si el
tipo de dato de los elementos del mismo no existe en la configuración destino, también se importa
automáticamente.
• Estructuras: Se permite importar una estructura completa desde otra configuración. Al importar la
estructura si los tipos de datos de sus campos no existen en la configuración destino, también se
importan automáticamente.
11 Puntos de supervisión
El módulo registra un conjunto de puntos hacia la base de datos que permiten supervisar su estado de
funcionamiento. Estos puntos se registran a partir de la dirección dada por el parámetro “Dirección de
Supervision” que se encuentra en la carpeta “General” de la configuración.
La tabla de puntos de supervisión es la siguiente:
Dirección
a partir de Tipo Nombre Descripción
DirSupervisión
TRUE si el PLC está ejecutándose en modo
Entrada
0 PLC_OK NORMAL, de lo contrario esta en FALSE. Ver sección
Bool
Modos de funcionamiento.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
12 Opciones de administración del programa de terminal
El módulo se administra mediante el administrador de RTU. A continuación se describen las distintas
opciones de la terminal de administración.
12.1 Carpeta Información general

Muestra información general como ser por ejemplo la versión y fecha del módulo. La información mostrada
se actualiza cada cinco segundos.
12.2 Carpeta Variables

Muestra en tiempo real el estado de todas las variables del PLC. Las variables mostradas se pueden filtrar
por varios criterios como ser por ejemplo, el tipo de dato de la variable, el ámbito de definición, el nombre,
etc.
12.3 Carpeta Trace

Muestra todos los mensajes de debug generados por la sentencia especial TRACE cuando el PLC se
ejecuta en modo DEBUG-CICLO-A-CICLO. Cuando el PLC se ejecuta en modo NORMAL, dicha sentencia
no hace nada y por lo tanto no genera ningún mensaje de debug.
12.4 Carpeta Debug

Muestra una ventana de terminal del módulo donde es posible dar comandos sobre el mismo. La lista de
comandos disponibles se detalla en la sección siguiente. Esta carpeta sólo se muestra para el nivel de
acceso “Adminstración”.
12.5 Comandos del PLC

Comandos disponibles sólo para el nivel de acceso “Administración”. Ver sección Modos de
funcionamiento.
13 Comandos de terminal
A continuación se describen, en orden alfabético, la sintaxis y la semántica de cada uno de los comandos
de terminal soportados por el módulo. Los mismos pueden ser enviados mediante la carpeta consola de
debug del administrador de RTU o, con el módulo ejecutado desde línea de comandos, directamente desde
el teclado.
13.1 Comandos comunes a todos los módulos
Se detallan en la documentación general del software RTUQM.
13.2 Comandos particulares del módulo lógicas


TEL (+598) 2622 0651
FAX (+598) 2622 2048
- sysinfo: Muestra el estado de la variable del sistema $SysInfo
- resetsysinfo: Resetea los contadores de la variable del sistema $SysInfo
- showclients: Muestra información sobre los clientes visualizadores conectados.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
14 Anexo A – Ejemplos de bloques funcionales
En esta sección se presentan a modo de ejemplo las implementaciones de todos los bloques funcionales
del sistema (con excepción de GET_DATE_AND_TIME) mediante bloques funcionales del usuario. Cada
bloque de usuario aquí implementado es totalmente equivalente al bloque del sistema correspondiente. La
diferencia esencial radica en que los bloques del sistema son más eficientes dado que están
implementados en C++ y embebidos en el código del PLC, mientras que los bloques del usuario son
programados en el lenguaje ST (Structured Text) de la norma y son interpretados por el PLC.
14.1 BLINK_USR – Parpadeo

Este bloque funcional del usuario es equivalente al bloque funcional del sistema BLINK.
RUN BOOL Habilitación
CYCLE TIME Período del temporizador
Variables Locales
tBegin TIME Marca de tiempo de inicio del temporizador
tElapsedTime TIME Tiempo transcurrido desde el inicio del temporizador
1
2 if RUN and CYCLE > T#0s then
3 if tBegin = T#0s then
4 // Inicio el temporizador.
5 tBegin := CLOCK_CYCLES();
6 Q := false;
7 else
8 // Calculo el tiempo transcurrido (en nanosegundos)
9 // desde el inicio del temporizador.
10 tElapsedTime := CLOCK_CYCLES_ELAPSED_TIME(tBegin, CLOCK_CYCLES());
11 if tElapsedTime >= (CYCLE / 2) then
12 // Expiró el temporizador entonces conmuto la salida Q
13 // y reincio el temporizador.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
14 Q := not Q;
16 end_if;
17 end_if;
18 else
19 // Detengo el temporizador.
20 tBegin := T#0s;
21 Q := false;
22 end_if;
23
14.2 TP_USR – Temporizador de pulso

Este bloque funcional del usuario es equivalente al bloque funcional del sistema TP.
Variables Locales
R_TRIG_IN R_TRIG Detector de flanco ascendente en la entrada IN
Indica si se produjo un flanco ascendente durante el pulso actual
bRisingEdge BOOL
del timer
F_TRIG_IN F_TRIG Detector de flanco descendente en la entrada IN
1
2 // Determino si hubo algún flanco ascendente o descendente en la entrada IN
3 R_TRIG_IN(IN);
4 F_TRIG_IN(IN);
5


TEL (+598) 2622 0651
FAX (+598) 2622 2048
6
7 if PT <= T#0s then
8 // Termino el temporizador.
9 tBegin := T#0s;
10 bRisingEdge := false;
11 Q := false;
12 ET := T#0s;
13 return;
14 end_if;
15
16
17 if Q then
18 if R_TRIG_IN.Q then
19 // Memorizo que se produjo un flanco ascendente durante
20 // el procesamiento del pulso actual.
21 bRisingEdge := true;
22 end_if;
23
27 if tElapsedTime >= PT then
28 // Expiró el temporizador entonces termino el pulso.
29 tBegin := T#0s;
30 Q := false;
31 if (bRisingEdge or not IN) then
32 ET := T#0s;
33 else
34 ET := PT;
35 end_if;
36 else
37 // El temporizador todavía no terminó entonces actualizo
38 // el tiempo transcurrido.
39 ET := tElapsedTime;
40 end_if;
41
42 elsif R_TRIG_IN.Q then
43 // Inicio el pulso
45 bRisingEdge := false;
46 Q := true;
47 ET := T#0s;
48 elsif F_TRIG_IN.Q then
49 ET := T#0s;
50 end_if;
51


TEL (+598) 2622 0651
FAX (+598) 2622 2048
14.3 TON_USR – Temporizador de retardo al encendido
Este bloque funcional del usuario es equivalente al bloque funcional del sistema TON.
Variables Locales
R_TRIG_IN R_TRIG Detector de flanco ascendente en la entrada IN
1
2 // Determino si hubo un flanco ascendente en la entrada IN.
3 R_TRIG_IN(IN);
4
5
8 tBegin := T#0s;
9 Q := IN;
10 ET := T#0s;
11 return;
12 end_if;
13
14
15 if R_TRIG_IN.Q then
16 // Inicio el temporizador de retardo.
18 Q := false;
19 ET := T#0s;
20 elsif IN = true then
21


TEL (+598) 2622 0651
FAX (+598) 2622 2048
22 if tBegin <> T#0s then
27 // Expiró el temporizador entonces lo detengo
28 // y copio la entrada IN en la salida Q.
29 tBegin := T#0s;
30 Q := IN;
31 ET := PT;
32 else
33 // El temporizador todavía no terminó entonces
34 // actualizo el tiempo transcurrido.
36 end_if;
37 else
38 // El temporizador ya terminó entonces copio la entrada
39 // IN en la salida Q.
40 Q := IN;
41 ET := PT;
42 end_if;
43
44 else // (IN = false)
45 // Detengo el temporizador y copio la entrada IN en la salida Q.
46 tBegin := T#0s;
47 Q := IN;
48 ET := T#0s;
49 end_if;
50
14.4 TOF_USR – Temporizador de retardo al apagado

Este bloque funcional del usuario es equivalente al bloque funcional del sistema TOF.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
Variables Locales
F_TRIG_IN F_TRIG Detector de flanco descendente en la entrada IN
1
2 // Determino si hubo un flanco descendente en la entrada IN.
3 F_TRIG_IN(IN);
4
5
8 tBegin := T#0s;
9 Q := IN;
10 ET := T#0s;
11 return;
12 end_if;
13
14
15 if F_TRIG_IN.Q then
16 // Inicio el temporizador de retardo.
18 Q := true;
19 ET := T#0s;
20 elsif IN = false then
21
22 if tBegin <> T#0s then
27 // Expiró el temporizador entonces lo detengo
28 // y copio la entrada IN en la salida Q.
29 tBegin := T#0s;
30 Q := IN;
31 ET := PT;
32 else
33 // El temporizador todavía no terminó entonces
34 // actualizo el tiempo transcurrido.
36 end_if;
37 else
38 // El temporizador ya terminó entonces copio la entrada


TEL (+598) 2622 0651
FAX (+598) 2622 2048
39 // IN en la salida Q.
40 Q := IN;
41 ET := PT;
42 end_if;
43
44 else // (IN = true)
45 // Detengo el temporizador y copio la entrada IN en la salida Q.
46 tBegin := T#0s;
47 Q := IN;
48 ET := T#0s;
49 end_if;
50
14.5 R_TRIG_USR – Detector de flanco ascendente

Este bloque funcional del usuario es equivalente al bloque funcional del sistema R_TRIG.
Nombre Nombre corto Tipo Descripción
IN_CLK CLK BOOL Señal de entrada
OUT_Q Q BOOL Señal de salida
Variables locales
MEM BOOL Memoriza el valor de IN_CLK
1
2 OUT_Q := IN_CLK and not MEM;
3 MEM := IN_CLK;
4
14.6 F_TRIG_USR – Detector de flanco descendente

Este bloque funcional del usuario es equivalente al bloque funcional del sistema F_TRIG.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
Variables locales
1
2 OUT_Q := not IN_CLK and MEM;
3 MEM := IN_CLK;
4
14.7 RF_TRIG_USR – Detector de flancos

Este bloque funcional del usuario es equivalente al bloque funcional del sistema RF_TRIG.
Variables locales


TEL (+598) 2622 0651
FAX (+598) 2622 2048
1
2 OUT_Q := (IN_CLK and not MEM) or (not IN_CLK and MEM);
3 MEM := IN_CLK;
4
14.8 CTU_USR – Contador ascendente

Este bloque funcional del usuario es equivalente al bloque funcional del sistema CTU.
IN_CU CU BOOL Señal a ser contada
IN_R R BOOL Señal de reset de contador
IN_PV PV DINT Valor máximo
OUT_Q Q BOOL Señal de valor máximo alcanzado
OUT_CV CV DINT Valor actual de la cuenta
Variables locales
R_TRIG_IN_CU R_TRIG_USR Detector de flanco ascendente en la entrada IN_CU
1
2 R_TRIG_IN_CU(IN_CU);
3
4 if IN_R then
5 OUT_CV := 0;
6 elsif R_TRIG_IN_CU.OUT_Q and (OUT_CV < IN_PV) then
7 OUT_CV := OUT_CV + 1;
8 end_if;
9
10 OUT_Q := (OUT_CV >= IN_PV);
11
14.9 CTD_USR – Contador descendente

Este bloque funcional del usuario es equivalente al bloque funcional del sistema CTD.


TEL (+598) 2622 0651
FAX (+598) 2622 2048
IN_CD CD BOOL Señal a ser contada
IN_LD LD BOOL Señal de preseteo al valor inicial
IN_PV PV DINT Valor inicial
OUT_Q Q BOOL Señal de valor cero alcanzado
Variables locales
R_TRIG_IN_CD R_TRIG_USR Detector de flanco ascendente en la entrada IN_CD
1
2 R_TRIG_IN_CD(IN_CD);
3
4 if IN_LD then
5 OUT_CV := IN_PV;
6 elsif R_TRIG_IN_CD.OUT_Q and (OUT_CV > 0) then
7 OUT_CV := OUT_CV - 1;
8 end_if;
9
10 OUT_Q := (OUT_CV <= 0);
11
14.10 CTUD_USR – Contador ascendente-descendente

Este bloque funcional del usuario es equivalente al bloque funcional del sistema CTUD.
IN_CU CU BOOL Señal de conteo ascendente
IN_CD CD BOOL Señal de conteo descendente
IN_R R BOOL Señal de reset de contador
IN_LD LD BOOL Señal de preseteo al valor inicial
IN_PV PV DINT Valor máximo


TEL (+598) 2622 0651
FAX (+598) 2622 2048
OUT_QU QU BOOL Señal de valor máximo alcanzado
OUT_QD QD BOOL Señal de valor cero alcanzado
Variables locales
R_TRIG_IN_CU R_TRIG_USR Detector de flanco ascendente en la entrada IN_CU
R_TRIG_IN_CD R_TRIG_USR Detector de flanco ascendente en la entrada IN_CD
1
2 R_TRIG_IN_CU(IN_CU);
3 R_TRIG_IN_CD(IN_CD);
4
5 if IN_R then
6 OUT_CV := 0;
7 elsif IN_LD then
8 OUT_CV := IN_PV;
9 elsif not (R_TRIG_IN_CU.OUT_Q and R_TRIG_IN_CD.OUT_Q) then
10 if R_TRIG_IN_CU.OUT_Q and (OUT_CV < IN_PV) then
11 OUT_CV := OUT_CV + 1;
12 elsif R_TRIG_IN_CD.OUT_Q and (OUT_CV > 0) then
13 OUT_CV := OUT_CV - 1;
14 end_if;
15 end_if;
16
17 OUT_QU := (OUT_CV >= IN_PV);
18 OUT_QD := (OUT_CV <= 0);
19
14.11 SR_USR – Biestable con entrada dominante set

Este bloque funcional del usuario es equivalente al bloque funcional del sistema SR.
IN_S S1 BOOL Entrada SET (dominante)
IN_R R BOOL Entrada RESET


TEL (+598) 2622 0651
FAX (+598) 2622 2048
OUT_Q Q1 BOOL Salida del elemento biestable
1
2 OUT_Q := IN_S or (not IN_R and OUT_Q);
3
14.12 RS_USR – Biestable con entrada dominante reset

Este bloque funcional del usuario es equivalente al bloque funcional del sistema RS.
IN_S S BOOL Entrada SET
IN_R R1 BOOL Entrada RESET (dominante)
OUT_Q Q1 BOOL Salida del elemento biestable
1
2 OUT_Q := not IN_R and (IN_S or OUT_Q);
3


TEL (+598) 2622 0651
FAX (+598) 2622 2048

RTUQM 28 - Módulo Lógicas V2 - 0 PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

RTUQM 28 - Módulo Lógicas V2 - 0 PDF

Cargado por

Copyright:

Formatos disponibles

Sistema RTUQM

3 DESCRIPCIÓN DEL FUNCIONAMIENTO ....................................................................................................... 6

RTUQM, Módulo Lógicas

CONTROLES S. A. AVENIDA RIVERA 3314

RTUQM, Módulo Lógicas

CONTROLES S. A. AVENIDA RIVERA 3314

12 OPCIONES DE ADMINISTRACIÓN DEL PROGRAMA DE TERMINAL ............................................. 96

RTUQM, Módulo Lógicas

CONTROLES S. A. AVENIDA RIVERA 3314

RTUQM, Módulo Lógicas

CONTROLES S. A. AVENIDA RIVERA 3314

Versión del documento: 2.0

RTUQM, Módulo Lógicas

CONTROLES S. A. AVENIDA RIVERA 3314

3.1 Ciclo de trabajo

El ciclo de trabajo del módulo se detalla en el siguiente diagrama:

Puntos de Entrada Variables

RTUQM, Módulo Lógicas

CONTROLES S. A. AVENIDA RIVERA 3314

o Tipos externos de entrada del PLC

Tipos de entrada de comando: Corresponden a comandos recibidos desde puntos de

• Entrada Comando DINT desde BD:SI: Comando DINT recibido desde un

o Tipos externos de salida del PLC

RTUQM, Módulo Lógicas

CONTROLES S. A. AVENIDA RIVERA 3314

• Tipos simples: Corresponden a valores de tipos de datos simples o elementales.

• Constantes: Permiten utilizar valores constantes mediante nombres.

• Estructuras del usuario: Corresponden a las estructuras definidas por el usuario.

RTUQM, Módulo Lógicas

CONTROLES S. A. AVENIDA RIVERA 3314

RTUQM, Módulo Lógicas

CONTROLES S. A. AVENIDA RIVERA 3314

El estado de las variables persistentes se mantiene en disco en el archivo XML

4.2 Representación gráfica

RTUQM, Módulo Lógicas

CONTROLES S. A. AVENIDA RIVERA 3314

Variable Externa de Comando

Variable del Sistema

Campo de Bloque Funcional

RTUQM, Módulo Lógicas

CONTROLES S. A. AVENIDA RIVERA 3314

RTUQM, Módulo Lógicas

CONTROLES S. A. AVENIDA RIVERA 3314

RTUQM, Módulo Lógicas

CONTROLES S. A. AVENIDA RIVERA 3314

RTUQM, Módulo Lógicas

CONTROLES S. A. AVENIDA RIVERA 3314

4.3.1 Tipos de punto de la base de datos

Driver Módulo Protocolo

4.3.2 Variables de entrada

RTUQM, Módulo Lógicas

CONTROLES S. A. AVENIDA RIVERA 3314

Driver Módulo Protocolo

4.3.2.1 Buffer de puntos de entrada

RTUQM, Módulo Lógicas

CONTROLES S. A. AVENIDA RIVERA 3314

Variables de entrada tipo estado de BD

4.3.2.3 Campos de las estructuras externas de entrada de comando de BD

Variables de entrada tipo comando de BD

RTUQM, Módulo Lógicas

CONTROLES S. A. AVENIDA RIVERA 3314

Driver Módulo Protocolo

4.3.3.1 Campos de las estructuras externas de salida de valor de BD