 Referencia de lenguajes

Arquitectura del proyecto

Objetos comunes

Lenguaje SFC

Lenguaje FC

Lenguaje FBD

Lenguaje LD

Lenguaje ST

Lenguaje IL

Operadores, bloques de función y funciones estándares


 Arquitectura del proyecto

El proyecto ISaGRAF está dividido en varias unidades de programación denominadas programas. Los programas del proyecto están vinculados entre sí por medio de una estructura de árbol. Para describir los programas, puede utilizarse cualquiera de los lenguajes gráficos o literales SFC, FC (Diagrama de flujo),FBD, LD, ST o IL.

Programas

Operaciones cíclicas y secuenciales

Programas SFC y FC hijo

Funciones y subprogramas

Bloques de función

Lenguaje de descripción

Reglas de ejecución


Programas

Un programa es una unidad de programación lógica, que describe las operaciones que tienen lugar entre las variables del proceso. Los programas describen operaciones bien secuenciales o bien cíclicas. Los programas cíclicos se ejecutan en cada ciclo del sistema objeto. La ejecución de programas secuenciales sigue las reglas dinámicas del lenguaje SFC o del lenguaje FC

Los programas están vinculados entre sí en un árbol jerárquico. Los programas situados en la parte superior de la jerarquía los activa el sistema. Los subprogramas (nivel inferior de la jerarquía) son activados por su padre. Se puede describir un programa mediante cualquiera de los siguientes lenguajes gráficos o literales:

Diagrama de Funciones Secuenciales (SFC) para la programación de alto nivel

Diagrama de flujo (FC) para la programación de alto nivel

Diagrama de Bloques de función (FBD) para operaciones cíclicas complejas

Diagrama de Escalera (Contactos) (LD), sólo para operaciones booleanas

Texto Estructurado (ST) para cualquier operación cíclica

Lista de Instrucciones (IL) para operaciones de bajo nivel

El mismo programa no puede mezclar varios lenguajes. Como excepción, LD y FBD pueden combinarse en un único diagrama.


Operaciones cíclicas y secuenciales

La jerarquía de programas se divide en cuatro secciones o grupos principales:

Comienzo	programas ejecutados al inicio de cada ciclo objeto

Secuencial	programas que siguen las reglas dinámicas del lenguaje SFC o FC

Fin	programas ejecutados al final de cada ciclo objeto

Funciones	conjunto de subprogramas no dedicados

Los programas pertenecientes a las secciones 'Comienzo' o 'Fin' describen las operaciones cíclicas y no son dependientes del tiempo. Los programas pertenecientes a la sección 'Secuencial' describen las operaciones secuenciales, donde la variable de tiempo sincroniza las operaciones básicas de forma explícita. Los programas principales de la sección 'Comienzo' se ejecutan sistemáticamente al inicio de cada ciclo de proceso. Los programas principales de la sección 'Fin' se ejecutan sistemáticamente al término de cada ciclo de proceso. Los programas principales de la sección 'Secuencial' se ejecutan de acuerdo con las reglas dinámicas del lenguaje SFC o del FC.

Los programas de la sección 'Funciones' son subprogramas que pueden ser invocados por cualquier otro programa perteneciente al proyecto. Un programa de la sección 'Funciones' puede invocar a otro programa perteneciente a la misma sección.

Los programas pertenecientes a la sección 'Bloques de función' son programas que pueden ser invocados por cualquier otro programa del proyecto. Un programa de la sección 'Bloques de función' puede invocar a programas pertenecientes a la sección Funciones, pero no a otros bloques de función.

Los programas principales e hijos de la sección secuencial deben ser descritos con el lenguaje SFC o el FC Los programas pertenecientes a las secciones cíclicas (Comienzo y Fin) no pueden ser descritos con el lenguaje SFC o el FC. Cualquier programa de cualquiera de las secciones puede poseer uno o más subprogramas. Cualquier programa de la sección secuencial puede poseer uno o más programas SFC o FC hijo. Los subprogramas no pueden ser descritos con el lenguaje SFC o el FC.

Una aplicación típica de los programas pertenecientes a la sección de Comienzo es la de describir operaciones preliminares sobre dispositivos de entrada para elaborar variables filtradas de alto nivel. Los programas de la sección Secuencial utilizan este tipo de variables con frecuencia. Los programas pertenecientes a la sección Final suelen utilizarse para describir operaciones de seguridad que afectan a las variables sobre las que actúa la sección Secuencial, antes de lanzar valores a los dispositivos de salida.


Programas SFC hijo
Programas SFC y FC hijo

Cualquier programa SFC de la sección secuencial tiene la capacidad de controlar a otros programas SFC. Dichos programas de bajo nivel se denominan programas SFC hijo. Un programa SFC hijo es un programa en paralelo que puede ser iniciado, finalizado, congelado o reiniciado por su programa padre. Tanto el programa padre como los programas hijo deben estar descritos en el lenguaje SFC. Un programa SFC hijo puede poseer variables locales y palabras definidas.

Cuando un programa padre arranca un programa SFC hijo, coloca una marca SFC en el paso inicial del programa hijo. Se describe este comando con la sentencia GSTART. Cuando un programa padre finaliza un programa SFC hijo, elimina todas las marcas que pudieran existir en los pasos del hijo. Este tipo de comando se describe con la sentencia GKILL.

Cuando un programa padre congela un programa SFC hijo, elimina todas las marcas que pudieran existir en el programa hijo y mantiene sus posiciones en memoria. Este tipo de comando se describe en la sentencia GFREEZE. Cuando un programa padre reinicia un programa SFC hijo que ha sido previamente congelado, restaura todas las marcas que eliminara en el momento de congelar el programa hijo. Este tipo de comando se describe con la sentencia GRST.

Cualquier programa FC de la sección secuencial tiene la capacidad de controlar a otros programas FC. Un programa FC padre se bloquea durante la ejecución  de un subprograma FC. No es posible que se hagan operaciones simultaneas en el programa FC padre y en uno de sus subprogramas FC.


Funciones y subprogramas

Los subprogramas y la ejecución de funciones están dirigidos por el correspondiente programa padre. La ejecución del programa padre se suspende hasta que finalice el subprograma o la función en cuestión:

program. pral.             subprogramas

Cualquier programa perteneciente a cualquier sección puede poseer uno o más subprogramas. Un subprograma pertenece a un único programa padre. Un subprograma puede tener variables y definiciones locales. Puede utilizarse cualquier lenguaje, con la excepción de SFC o FC para describir un subprograma. Los programas pertenecientes a la sección 'Funciones' son subprogramas que pueden ser invocados por cualquier otro programa del proyecto. A diferencia de otros subprogramas, no están dedicados a un único programa padre. Los programas de la sección 'Funciones' pueden invocar a otros programas pertenecientes a la sección. Una función puede ser colocada en la Librería.

Advertencia: El sistema ISaGRAF no soporta la recursividad durante la invocación de funciones. Se producirá un error de tiempo de proceso si uno de los programas de la sección 'Funciones' se invoca a sí mismo o si es invocado por uno de sus subprogramas.

Advertencia: Una función o subprograma no "almacena" el valor local de sus variables locales. Una función o subprograma no se instancia y por tanto no puede llamar a bloques de función.

La interfaz de un subprograma tiene que definirse de forma explícita, indicándose un tipo y un nombre único para cada uno de sus parámetros de llamada o retorno. Con vistas a sostener las convenciones del lenguaje ST, el parámetro de retorno debe tener el mismo nombre que el subprograma.

La siguiente tabla muestra la forma de especificar el valor del parámetro de retorno en el texto de un subprograma, en los diferentes lenguajes:

ST:	asignar el parámetro de retorno utilizando su nombre

(el mismo nombre que el subprograma):

nombre_subprograma := <expresión>;

IL:	el valor del resultado actual (registro IL)

al final de la secuencia se almacena en el parámetro de retorno:

LD      10

   ADD   20   (* valor de parámetro de retorno = 30 *)

FBD:	fijar el parámetro de retorno utilizando su nombre:

 nombre_subprograma

LD:	utilizar un símbolo de bucle con el nombre del parámetro de retorno:

nombre_subprograma


Bloques de función

Los bloques de función pueden utilizar los lenguajes LD, FBD, ST o IL. Los bloques de función son del tipo instanciado, lo que significa que se copian las variables locales de un bloque de función para cada instancia. Cuando se invoca un bloque desde un programa, en realidad se invoca la instancia del bloque: aunque se invoca el mismo código, los datos que se utilizan son aquellos que hayan sido asignados a la instancia. Los valores de las variables de la instancia se almacenan de un ciclo a otro.

Advertencias:

- Los bloques de función escritos con uno de los lenguajes IEC no pueden invocar a otros bloques de función: el mecanismo de instanciación solo gestiona las variables locales del propio bloque. A continuación se indica una lista de los bloques de función estándares que no pueden utilizarse dentro de un bloque de función IEC:

SR, RS, R_Trig, F_Trig, SEMA, CTU, CTD, CTUD, TON, TOF, TP, CMP, StackInt, AVERAGE, HYSTER, LIM_ALRM, INTEGRAL, DERIVATE, BLINK, SIG_GEN

- Por la misma razón, no se pueden utilizar contactos o bobinas (salidas) Positivos o Negativos, o bobinas (salidas) de Establecer (Set) y Restablecer (Reset).

- Las funciones de TSTART y TSTOP para iniciar y parar temporizadores no pueden utilizarse en bloques de función para objetos o targets 3.0x. Sölo pueden utilizarse a partir del target 3.20.

- Cuando se tenga la necesidad de incorporar un bucle en el bloque de función, se deberá usar una variable local antes de hacer el bucle. Véase el siguiente ejemplo:

Esto no funcionará:	Esto sí funcionará:


Lenguaje de descripción

Se puede describir un programa con cualquiera de los siguientes lenguajes gráficos o literales:

Tabla de Funciones Secuenciales (SFC) para operaciones de alto nivel

Diagrama de flujo (FC) para operaciones de alto nivel

Diagrama de Bloques de función (FBD) para operaciones cíclicas complejas

Diagrama de Escalera (Contactos) (LD), para operaciones booleanas solamente

Texto Estructurado (ST) para cualquier operación cíclica

Lista de Instrucciones (IL) para operaciones de bajo nivel

No se pueden mezclar varios lenguajes en un mismo programa. Se elige el lenguaje utilizado para describir un programa a la hora de crear el programa, y no se puede cambiar posteriormente. Como excepción, es posible combinar FBD y LD en un mismo programa.


Reglas de ejecución

ISaGRAF es un sistema síncrono. Se activan todas las operaciones por medio de un reloj. La duración básica del reloj se denomina el tiempo de ciclo:

Las operaciones básicas que se llevan a cabo durante un ciclo objeto son:

Este sistema permite:

- garantizar que una variable de entrada mantendrá el mismo valor durante un ciclo,

- garantizar que un dispositivo de salida no se actualizará más de una vez durante un ciclo,

- trabajar de manera segura con la misma variable global, desde diferentes programas,

-cuantificar y controlar los tiempos de respuesta de la aplicación en su conjunto.


 Objetos comunes

Estas son las principales características y los objetos comunes de la base de datos de programación ISaGRAF. Estos objetos pueden ser utilizados en cualquier programa que haya sido escrito con alguno de los lenguajes SFC, FBD, FC LD, ST o IL.

Tipos básicos

Expresiones constantes

Variables

Comentarios

Palabras definidas


Tipos básicos

Cualquier constante, expresión o variable que se utilice en un programa (escrito en cualquier lenguaje) debe estar caracterizada por un tipo. La coherencia de tipos deberá mantenerse en las operaciones gráficas y sentencias literales. Estos son los tipos básicos disponibles para objetos de programación:

BOOLEANO:	valor lógico (verdadero -true- o falso -false-)

ANALÓGICO:	valor contínuo entero o real (flotante)

TEMPORIZADOR:	valor en tiempo

MENSAJE:	cadena de caracteres

Nota: Los temporizadores contienen valores inferiores a un día y no pueden utilizarse para almacenar fechas.


Expresiones constantes

Una expresión constante está asociada a un único tipo. No se puede utilizar la misma notación para representar expresiones constantes de diferentes tipos.

Expresiones constantes booleanas

Expresiones constantes analógicas enteras

Expresiones constantes analógicas reales

Expresiones constantes temporizadores

Expresiones constantes de cadenas de mensajes


Expresiones constantes booleanas

Sólo existen dos expresiones constantes booleanas:

TRUE    	Verdadero, equivale al valor entero 1

FALSE	Falso, equivale al valor entero 0

Las palabras clave "True" y "False" son insensibles al uso de mayúsculas o minúsculas.


Expresiones constantes analógicas enteras

Las expresiones constantes analógicas representan valores enteros largos (32 bit) y con signo:

entre -2147483647 y +2147483647

Se pueden expresar las constantes analógicas enteras con una de las siguientes bases. Las constantes enteras deben empezar por un prefijo que identifique las bases utilizadas:

Base	Prefijo	Ejemplo
DECIMAL	(ninguno)	-908
HEXADECIMAL	"16#"	16#1A2B3C4D
OCTAL	"8#"	8#1756402
BINARIO	"2#"	2#1101_0001_0101_1101

Se puede emplear el carácter de subrayado ('_') para separar grupos de dígitos. No posee ningún significado particular, y se utiliza para aumentar la legibilidad de las expresiones constantes.


Expresiones constantes analógicas reales

Las expresiones constantes analógicas reales se pueden escribir con representación decimal o científica. El punto decimal ('.') separa las partes enteras de las decimales. Se debe utilizar el punto decimal para diferenciar entre las expresiones constantes reales y las enteras. La representación científica emplea las letras 'E' o 'F' para separar la mantisa del exponente. El exponente de una expresión científica real tiene que ser un valor entero con signo de entre 37 y +37. A continuación se dan ejemplos de expresiones constantes analógicas reales:

3.14159	-1.0E+12

+1.0	1.0F-15

-789.56	+1.0E-37

La expresión "123" no representa una expresión constante real. Su representación real correcta es "123.0".


Expresiones constantes temporizadores

Las expresiones constantes temporizadores representan valores de tiempo entre 0 segundos y 23h59m59s999ms. El valor más pequeño que se permite es un milisegundo. Las unidades de tiempo estándares que se utilizan en las expresiones constantes son:

Hora	Debe indicarse la letra "h" después del número de horas

Minuto	Debe indicarse la letra "m" después del número de minutos

Segundo	Debe indicarse la letra "s" después del número de segundos

Milisegundo	Deben indicarse las letras "ms" después del número de milisegundos

La expresión constante temporizador debe empezar por el prefijo "T#" o "TIME#". Los prefijos y las letras de las unidades pueden indicarse en mayúsculas o minúsculas, indistintamente. Es posible que algunas unidades no aparezcan. Estos son ejemplos de expresiones constantes temporizadores:

T#1H450MS	1 hora, 450 milisegundos

time#1H3M	1 hora, 3 minutos

La expresión "0" no representa un valor de tiempo, sino una constante analógica.


Expresiones constantes de cadenas de mensajes

Las expresiones constantes con cadenas o mensajes representan cadenas de caracteres. Los caracteres deben estar flanqueados por apóstrofes. Por ejemplo:

'ESTO ES UN MENSAJE'

Advertencia: No se puede utilizar el carácter de apóstrofe ''' en las expresiones constantes con cadenas. Una expresión constante con cadenas debe ser expresada en una única línea del código fuente del programa. Su longitud no puede superar los 255 caracteres, incluyendo espacios.

Las expresiones constantes de cadenas vacías se representan con dos apóstrofes, sin caracteres de espacio o tabulación entre ellos:

''   (* esta es una cadena vacía *)

En una expresión constante con cadenas, se puede utilizar el carácter especial de dólar ('$'), seguido por otros caracteres especiales, para representar un carácter no imprimible:

Secuencia	Significado	ASCII (hexa)	Ejemplo
$$	Carácter '$'	16#24	'pagué $$5 por esto'
$'	Apóstrofe	16#27	'introd. $'Y$' para SÍ'
$L	Cambio línea	16#0a	'siguiente línea $L'
$R	Retorno carro	16#0d	'   llo $R He'
$N	Nueva linea	16#0d0a	'esta es una línea$N'
$P	Nueva página	16#0c	'última línea $P primera linea
$T	Tabulación	16#09	'nombre$Ttamaño$Tfecha'
$hh   (*)	Cualquier carácter	16#hh	'ABCD = $41$42$43$44'

(*) "hh" es el valor hexadecimal del código ASCII correspondiente al carácter expresado.


Variables

Las variables pueden ser LOCALES a un programa, o GLOBALES. Las variables locales sólo pueden ser utilizadas por un programa. Las variables globales pueden ser utilizadas en cualquier programa del proyecto.

Palabras clave reservadas

Variables de representación directa

Variables booleanas

Variables analógicas

Variables de temporizador

Variables de cadenas de mensajes

Los nombres de las variables deben cumplir con las siguientes normas:

- el nombre no puede superar los 16 caracteres

- el primer carácter debe ser una letra

- los restantes caracteres pueden ser letras, dígitos o el carácter de subrayado (_)


Palabras clave reservadas

A continuación se muestra una relación de palabras clave reservadas. Tales identificadores no pueden ser empleados para nombrar programas, variables o funciones o bloques de función "C":

A	ANA, ABS, ACOS, ADD, ANA, AND, AND_MASK, ANDN, ARRAY, ASIN, AT, ATAN,

B	BCD_TO_BOOL, BCD_TO_INT, BCD_TO_REAL, BCD_TO_STRING, BCD_TO_TIME, BOO, BOOL, BOOL_TO_BCD, BOOL_TO_INT, BOOL_TO_REAL, BOOL_TO_STRING, BOOL_TO_TIME, BY, BYTE,

C	CAL, CALC, CALCN, CALN, CALNC, CASE, CONCAT, CONSTANT, COS,

D	DATE, DATE_AND_TIME, DELETE, DINT, DIV, DO, DT, DWORD,

E	ELSE, ELSIF, EN, END_CASE, END_FOR, END_FUNCTION, END_IF, END_PROGRAM, END_REPEAT, END_RESSOURCE, END_STRUCT, END_TYPE, END_VAR, END_WHILE, ENO, EQ, EXIT, EXP, EXPT,

F	FALSE, FEDGE, FIND, FOR, FUNCTION,

G	GE, GFREEZE, GKILL, GRST, GSTART, GSTATUS, GT,

I	IF, INSERT, INT, INT_TO_BCD, INT_TO_BOOL, INT_TO_REAL, INT_TO_STRING, INT_TO_TIME,

J	JMP, JMPC, JMPCN, JMPN, JMPNC,

L	LD, LDN, LE, LEFT, LEN, LIMIT, LINT, LN, LOG, LREAL, LT, LWORD,

M	MAX, MID, MIN, MOD, MOVE, MSG, MUL, MUX,

N	NE, NOT,

O	OF, ON, OPERATE, OR, OR_MASK, ORN,

P	PROGRAM

R	R, REDGE, READ_ONLY, READ_WRITE, REAL, REAL_TO_BCD, REAL_TO_BOOL, REAL_TO_INT, REAL_TO_STRING, REAL_TO_TIME, REDGE, REPEAT, REPLACE, RESSOURCE, RET, RETAIN, RETC, RETCN, RETN, RETNC, RETURN, RIGHT, ROL, ROR,

S	S, SEL, SHL, SHR, SIN, SINT, SQRT, ST, STN, STRING, STRING_TO_BCD, STRING_TO_BOOL, STRING_TO_INT, STRING_TO_REAL, STRING_TO_TIME, STRUCT, SUB, SYS_ERR_READ, SYS_ERR_TEST, SYS_INITALL, SYS_INITANA, SYS_INITBOO, SYS_INITTMR, SYS_RESTALL, SYS_RESTANA, SYS_RESTBOO, SYS_RESTTMR, SYS_SAVALL, SYS_SAVANA, SYS_SAVBOO, SYS_SAVTMR, SYS_TALLOWED, SYS_TCURRENT, SYS_TMAXIMUM, SYS_TOVERFLOW, SYS_TRESET, SYS_TWRITE, SYSTEM,

T	TAN, TASK, THEN, TIME, TIME_OF_DAY, TIME_TO_BCD, TIME_TO_BOOL, TIME_TO_INT, TIME_TO_REAL, TIME_TO_STRING, TMR, TO, TOD, TRUE, TSTART, TSTOP, TYPE,

U	UDINT, UINT, ULINT, UNTIL, USINT,

V	VAR, VAR_ACCESS, VAR_EXTERNAL, VAR_GLOBAL, VAR_IN_OUT, VAR_INPUT, ,VAR_OUTPUT,

W	WHILE, WITH, WORD,

X 	XOR, XOR_MASK, XORN

Todas las palabras clave que empiecen por un carácter de subrayado ('_') son palabras clave internas y no deben utilizarse en las instrucciones textuales.


Variables de representación directa

ISaGRAF permite el uso de variables de representación directa en la fuente de los programas para representar un canal libre. Los canales libres son aquellos que no están vinculados a una variable declarada de E/S. El identificador de una variable de representación directa siempre empieza por un carácter "%".

A continuación se muestran las convenciones de nombrado de variables de representación directa para un canal de una tarjeta simple. "s" es el número de la ranura de la tarjeta. "c" es el número del canal.

%IXs.c	canal libre de una tarjeta de entrada booleana

%IDs.c	canal libre de una tarjeta de entrada de valores enteros

%ISs.c	canal libre de una tarjeta de entrada de mensajes

%QXs.c	canal libre de una tarjeta de salida booleana

%QDs.c	canal libre de una tarjeta de salida de valores enteros

%QSs.c	canal libre de una tarjeta de salida de mensajes

A continuación se indican las convenciones de nombrado de variables de representación directa para un canal de un equipo complejo. "s" es el número de la ranura del equipo. "b" es el identificador de la tarjeta individual dentro del equipo complejo. "c" es el número del canal.

%IXs.b.c	canal libre de una tarjeta de entrada booleana

%IDs.b.c	canal libre de una tarjeta de entrada de valores enteros

%ISs.b.c	canal libre de una tarjeta de entrada de mensajes

%QXs.b.c	canal libre de una tarjeta de salida booleana

%QDs.b.c	canal libre de una tarjeta de salida de valores enteros

%QSs.b.c	canal libre de una tarjeta de salida de mensajes

Algunos ejemplos:

%QX1.6	6º canal de la tarjeta nº 1 (salida booleana)

%ID2.1.7	7º canal de la tarjeta nº 1 del equipo nº 2 (entrada valores enteros)

Una variable de representación directa no puede tener el tipo de datos "reales".


Variables booleanas

Booleano significa lógico. Tales variables pueden tomar uno de los dos valores booleanos: TRUE o FALSE. La aplicación típica de las variables booleanas se encuentra en las expresiones booleanas. Las variables booleanas pueden tener uno de los siguientes atributos:

Interna:	variable de memoria actualizada por el programa

Constante:	variable de memoria, de solo lectura, con un valor inicial

Entrada:	variable conectada a un dispositivo de entrada (refrescada por el sistema)

Salida:	variable conectada a un dispositivo de salida

Advertencia: Cuando se declara una variable booleana, pueden definirse cadenas para reemplazar los valores de "True" y "False" durante el proceso de depuración. Estas cadenas no pueden ser empleadas en los programas si no se han incorporado como 'palabras definidas' para el lenguaje.


Variables analógicas

Analógico significa continuo. Este tipo de variable posee valores enteros con signo o reales (flotantes). Los formatos disponibles para variables analógicas son:

Entero	valor entero con signo de 32 bits: de -2147483647 a +2147483647

Real	valor flotante de 32 bits, según el estándar IEEE (precisión simple)

1 bit signo + 23 bits mantisa + 8 bits exponente

El valor REAL del exponente analógico no puede ser inferior a -37 o superior a +37. Las variables analógicas pueden tener uno de los siguientes atributos:

Interna:	variable de memoria actualizada por el programa

Constante:	variable de memoria, solo lectura, con un valor inicial

Entrada:	variable conectada a un dispositivo de entrada (refrescada por el sistema)

Salida:	variable conectada a un dispositivo de salida

Nota: Cuando se conecta una variable real a un dispositivo de E/S, el correspondiente controlador de E/S opera con el valor entero equivalente.

Advertencia: No pueden mezclarse las variables o expresiones constantes analógicas enteras y reales en una misma expresión analógica.


Variables de temporizador

Temporizador significa reloj o contador. Las variables de este tipo se emplean típicamente en expresiones de tiempo. Un valor de temporizador no puede superar 23h59m59s99 y no puede ser negativo. Las variables de temporizador se almacenan en palabras de 32 bits. La representación interna es un número positivo expresado en milisegundos.

Las variables de temporizador pueden tener uno de los siguientes atributos:

Interno:	variable de memoria gestionada por el programa y refrescada por el sistema ISaGRAF

Constante:	variable de memoria, de solo lectura, con un valor inicial

Advertencia: Las variables de temporizador no pueden tener atributos de ENTRADA o SALIDA.

Las variables de temporizador puede ser refrescadas automáticamente por el sistema ISaGRAF. Cuando un temporizador se encuentra activo, su valor se incrementa automáticamente de acuerdo con el reloj en tiempo real del sistema objeto. Pueden utilizarse las siguientes instrucciones en lenguaje ST para controlar un temporizador:

TSTART	inicia el refresco automático de un temporizador

TSTOP	termina el refresco automático de un temporizador


Variables de cadenas de mensajes

Las variables de mensajes o cadenas contienen cadenas de caracteres. La longitud de la cadena puede variar en el transcurso de una operación de proceso. La longitud de una variable de mensaje no puede superar la capacidad (longitud máxima) especificada a la hora de declarar la variable. La capacidad de mensaje está limitada a 255 caracteres. Las variables de mensaje pueden tener uno de los siguientes atributos:

Interna:	variable de memoria actualizada por el programa

Constante:	variable de memoria, de solo lectura, con un valor inicial

Entrada:	variable conectada a un dispositivo de entrada (refrescada por el sistema)

Salida:	variable conectada a un dispositivo de salida

Las variables de cadena pueden contener cualquier carácter del juego estándar de caracteres ASCII (códigos ASCII del 0 al 255). Se permiten caracteres nulos en una cadena de caracteres. Algunas de las funciones "C" de la librería estándar de ISaGRAF no funcionarán correctamente con mensajes que contengan caracteres nulos (0).


Comentarios

En los lenguajes literales como ST e IL se pueden insertar comentarios libremente. Los comentarios deberán empezar por los caracteres especiales "(*" y terminar por los caracteres "*)". Se pueden insertar comentarios en cualquier punto de un programa ST, y pueden ocupar más de una línea.

Estos son ejemplos de comentarios:

counter := ivalue; (* asigna el contador principal *)

(* este es un comentario expresado

en dos líneas *)

c := counter (* se puede colocar comentarios en cualquier lugar *) + base_value + 1;

No se pueden utilizar comentarios intercalados. Es decir, no se pueden emplear los caracteres "(*" dentro de un comentario.

Advertencia: El lenguaje IL sólo acepta comentarios como el último componente de una línea de instrucciones.


Palabras definidas

El sistema ISaGRAF permite la redefinición de expresiones constantes, expresiones booleanas verdaderas y falsas, palabras clave y expresiones ST complejas. Para ello, se debe asignar un identificador a la expresión correspondiente. Por ejemplo:

SÍ	es	TRUE

PI	es	3.14159

OK	es	(auto_mode AND NOT (alarm))

Cuando se define una equivalencia de este tipo, se puede utilizar su identificador en cualquier punto de un programa ST para reemplazar la expresión asociada. A continuación aparece un ejemplo de programación en ST utilizando definiciones:

If OK Then

   angle := PI / 2.0;

   isdone := SI;

End_if;

Las palabras definidas pueden ser LOCALES para un programa, GLOBALES o COMUNES.

Las palabras definidas locales sólo pueden ser utilizadas por un único programa.

Las palabras definidas globales pueden ser utilizadas en cualquier programa del proyecto.

Las palabras definidas comunes pueden ser utilizadas en cualquier programa de cualquier proyecto.

Nota: Las palabras definidas comunes pueden almacenarse de forma independiente en el Gestor de Archivos.

Advertencia: Cuando se define el mismo identificador dos veces, con diferentes equivalencias ST, se utiliza la última expresión que haya sido definida. Por ejemplo:

La definición:	ABIERTO	es	FALSE

ABIERTO	es	TRUE

significa:	ABIERTO	es	TRUE

La denominación de palabras definidas debe cumplir con las siguientes normas:

- el nombre no puede superar los 16 caracteres

- el primer carácter debe ser una letra

- los restantes caracteres pueden ser letras, dígitos o el carácter de subrayado ('_')

Nota: ISaGRAF no admite dos caracteres de subrayado seguidos.

Advertencia: Una palabra definida no puede emplear otra palabra definida en su definición. Por ejemplo, no se puede escribir:

PI	es	3,14159

PI2 	es	PI*2

Debe escribirse la equivalencia completa, empleando constantes o variables y operaciones:

PI2 	es	6,28318


 Lenguaje IL

Lista de Instrucciones, o IL, es un lenguaje de bajo nivel. Las instrucciones siempre están relacionadas con el resultado actual (o registro IL). El operador indica la operación que debe llevarse a cabo entre el valor actual y el operando. El resultado de la operación se almacena de nuevo en el resultado actual.

Sintaxis principal IL

Operadores IL


Sintaxis principal IL

Un programa IL es una lista de instrucciones. Cada instrucción tiene que comenzar en una línea nueva y contener un operador, complementado con modificadores opcionales. Adicionalmente, y si fuera necesario para la operación específica, tiene que contener uno o más operandos, separados por comas (','). Una etiqueta seguida por dos puntos (':') puede preceder a la instrucción. Si se añade un comentario a la instrucción, debe ser el último componente de la línea. Los comentarios siempre comienzan por '(*' y concluyen por '*)'. Se pueden introducir líneas vacías entre instrucciones. Pueden colocarse los comentarios en líneas vacías.

Etiquetas

Modificadores de operadores

Operaciones demoradas

A continuación se muestran algunos ejemplos de líneas de instrucciones:

Etiqueta	Operador	Operando	Comentarios

Inicio:	LD	IX1	(* pulsar interruptor *)

ANDN	MX5	(* comando no prohibido *)

ST	QX2	(* arrancar motor *)


Etiquetas

Una etiqueta seguida por dos puntos (':') puede preceder a la instrucción. Puede situarse una etiqueta en una línea vacía. Las etiquetas se utilizan como operandos para algunas operaciones tales como saltos. La denominación de etiquetas debe cumplir con las siguientes normas:

- el nombre no puede superar los 16 caracteres

- el primer carácter tiene que ser una letra

- los siguientes caracteres tiene que ser letras, dígitos o el carácter '_'

No se puede utilizar el mismo nombre para más de una etiqueta en el mismo programa IL. Una etiqueta puede tener el mismo nombre que una variable.


Modificadores de operadores

Se dispone de los modificadores de operadores que aparecen a continuación. El carácter modificador tiene que completar el nombre del operador, sin dejar espacios en blanco entre ellos:

N	negación booleana del operando

(	operación demorada

C	operación condicional

El modificador 'N' indica la negación booleana del operando. Por ejemplo, la instrucción ORN IX12 se interpreta como: resultado := resultado OR NOT (IX12).

El modificador de paréntesis '(' indica que la evaluación de la instrucción debe demorarse hasta que se llegue al operador de paréntesis ')' de cierre.

El modificador 'C' indica que la instrucción asociada sólo debe ejecutarse si el resultado actual muestra el valor booleano VERDADERO (diferente a 0, en el caso de valores no booleanos). El modificador 'C' puede combinarse con el modificador 'N' para indicar que la instrucción sólo debe ejecutarse si el resultado actual muestra el valor booleano FALSO (o 0, en el caso de valores no booleanos).


Operaciones demoradas

Al existir un solo registro IL (resultado actual), algunas operaciones tienen que ser demoradas para que la orden de ejecución o las instrucciones puedan ser cambiadas. Se emplean paréntesis para indicar las operaciones demoradas:

'('	es un modificador	Indica la operación que va a ser demorada
')'	es un operador	Ejecuta la operación demorada

El modificador de paréntesis de apertura '(' indica que se tiene que demorar la evaluación de la instrucción hasta que se llegue al operador de paréntesis ')' de cierre. Por ejemplo, la siguiente secuencia:

AND(	IX12

OR	IX35

)

se interpreta como:

result := result AND ( IX12 OR IX35 )


Operadores IL

La siguiente tabla resume los operadores estándares del lenguaje IL:

Operador	Modificadores	Operando	Descripción
LD	N	Variable, constante	Carga operando
ST	N	Variable	Almacena resultado actual
S R		variable BOO variable BOO	Pone a VERDADERO Repone a FALSO
AND & OR XOR	N   ( N   ( N   ( N   (	BOO BOO BOO BOO	'Y' booleana 'Y' booleana 'O' booleana 'O' exclusiva
ADD SUB MUL DIV	( ( ( (	Variable, constante Variable, constante Variable, constante Variable, constante	Suma Resta Multiplicación División
GT GE EQ LE LT NE	( ( ( ( ( (	Variable, constante Variable, constante Variable, constante Variable, constante Variable, constante Variable, constante	Prueba: > Prueba: >= Prueba: = Prueba: <= Prueba: < Prueba: <>
CAL JMP RET	C   N  C   N C   N	Nombre instancia bloque función Etiqueta	Invoca bloque de función Salta a etiqueta  Retorna de subprograma
)   Function			Ejecuta operación demorada Invoca a función o subprograma

En la siguiente sección, sólo se describen operadores que son específicos del lenguaje IL. Pueden encontrarse otros operadores estándares en la sección titulada, "operadores, bloques de función y funciones estándares".


Operador LD

Operación	carga un valor en el resultado actual

Modificadores

permitidos	N

Operando	expresión constante

Variable interna, de entrada o de salida

Ejemplo:

(* EJEMPLOS DE OPERACIONES LD *)

LDex:	LD	FALSO	(* resultado := FALSO constante booleana *)

LD	VERDADERO	(* resultado := VERDADERO constante booleana *)

LD	123	(*resultado:= constante entero *)

LD	123.1	(*resultado:= constante real *)

LD	t#3ms	(*resultado:= constante de tiempo *)

LD	boo_var1	(*resultado:= variable booleana *)

LD	ana_var1	(*resultado:= variable analógica *)

LD	tmr_var1	(*resultado:= variable de reloj *)

LDN	boo_var2	(*resultado:= NOT ( variable booleana ) *)


Operador ST

Operación	almacena el resultado actual en una variable

Esta operación no modifica el resultado actual

Modificadores

permitidos	N

Operando	variable interna o de salida

Ejemplo:

(* EJEMPLOS DE OPERACIONES ST *)

STboo:	LD	FALSO

ST	boo_var1	(* boo_var1 := FALSO*)

STN	boo_var2	(* boo_var2 := VERDADERO*)

STana:	LD	123

ST	ana_var1	(* ana_var1 := 123 *)

STtmr:	LD	t#12s

ST	tmr_var1	(* tmr_var1 := t#12s *)


Operador S

Operación:	almacena el valor booleano VERDADERO en una variable booleana, si el resultado actual tiene el valor booleano VERDADERO. No se procesan operaciones si el resultado actual es FALSO. Esta operación no modifica el resultado actual.

Modificadores

permitidos:	(ninguno)

Operando:	variable booleana interna o de salida

Ejemplo:

(* EJEMPLOS DE OPERACIONES S *)

SETex:	LD	VERDADERO	(* resultado actual := VERDADERO *)

S	var_boo1	(*var_boo1 := VERDADERO *)

(* resultado actual no está modificado *)

LD	FALSO	(*resultado actual := FALSO *)

S	var_boo1	(* sin acciones  var_boo1 sin cambios *)


Operador R

Operación 	almacena el valor booleano FALSO en una variable booleana, si el resultado actual muestra el valor booleano VERDADERO. No se procesan operaciones si el resultado actual es FALSO. Esta operación no modifica el resultado actual.

Modificadores

permitidos	(ninguno)

Operando	variable booleana interna o de salida

Ejemplo:

(* EJEMPLOS DE OPERACIONES R *)

RESETex:	LD	VERDADERO	(* resultado actual := VERDADERO *)

R	boo_var1	(* boo_var1 := FALSO *)

(* resultado actual no se modifica *)

ST	boo_var2	(* boo_var2 := VERDADERO *)

LD	FALSO	(* resultado actual := FALSO *)

R	boo_var1	(* no se hace nada - boo_var1 no cambiado *)


Operador JMP

Operación	salta a la etiqueta especificada

Modificadores

permitidos	C   N

Operando	etiqueta definida en el mismo programa IL

Ejemplo:

(* el siguiente ejemplo verifica el valor de un selector analógico (0 ó 1 ó 2) *)	*)

(* para fijar una de 3 salidas booleanas. Verificación "es igual a 0" se realiza con *)	*)

(* el operador JMPC *)

JMPex:	LD	selector	(* selector es 0 ó 1 ó 2 *)

BOO	(* conversión a booleano *)

JMPC	test1	(* si selector = 0 entonces *)

LD	VERDADERO

ST	bo0	(* bo0 := VERDADERO *)

JMP	JMPend	(* fin de programa *)

test1:	LD 	selector

SUB	1	(* decrementar selector: ahora es 0 ó 1 *)

BOO	(* conversión a booleano *)

JMPC	test2	(* si selector = 0 entonces *)

LD	VERDADERO

ST	bo1	(* bo1 := VERDADERO *)

JMP	JMPend	(* fin de programa *)

test2:	LD	VERDADERO	(* última posibilidad *)

ST	bo2	(* bo2 := VERDADERO *)

JMPend:	(* fin de programa IL *)


Operador RET

Operación	finaliza la lista actual de instrucciones. Si la secuencia IL es un subprograma, se devuelve el resultado actual al programa invocante

Modificadores

permitidos	C   N

Operando	(ninguno)

Ejemplo:

(* el siguiente ejemplo verifica el valor de un selector analógico (0 ó 1 ó 2) *)	*)

(* para fijar una de 3 salidas booleanas. Verificación "es igual a 0" se realiza con *)	*)

(* el operador JMPC *)

JMPex:	LD	selector	(* selector es 0 ó 1 ó 2 *)

BOO	(* conversión a booleano *)

JMPC	test1	(* si selector = 0 entonces *)

LD	VERDADERO

ST	bo0	(* bo0 := VERDADERO *)

RET	(* fin - retorno 0 *)

(* decrementar selector *)

test1:	LD 	selector

SUB	1	(* selector es ahora 0 ó 1 *)

BOO	(* conversión a booleano *)

JMPC	test2	(* si selector = 0 entonces *)

LD	VERDADERO

ST	bo1	(* bo1 := VERDADERO *)

LD	1	(* cargar valor selector real *)

RET	(* fin - retorno 1 *)

(* última posibilidad *)

test2:	RETNC	(* retornar si el selector tiene *)

(* un valor inválido *)

LD	VERDADERO

ST	bo2	(* bo2 := VERDADERO *)

LD	2	(* cargar valor selector real *)

 	(* fin - retorno 2 *)


Operador ")"

Operación	ejecuta una operación demorada. La operación demorada fue notificada por un '('

Modificadores

permitidos	(ninguno)

Operando	(ninguno)

Ejemplo:

(* El siguiente programa intercala operaciones demoradas: *)

(* res := a1 + (a2 * (a3 - a4) * a5) + a6; *)

Delayed:	LD	a1	(* resultado := a1; *)

ADD(	a2	(* ADD retardado - resultado := a2; *)

MUL(	a3	(* MUL retardado - resultado := a3; *)

SUB	a4	(* resultado := a3 - a4; *)

)	(* ejecutar MUL retardado - resultado := a2 * (a3-a4); *)

MUL	a5	(* resultado := a2 * (a3 - a4) * a5; *)

)	(* ejecutar ADD retardado *)

(* resultado := a1 + (a2 * (a3 - a4) * a5); *)

ADD	a6	(* resultado := a1 + (a2 * (a3 - a4) * a5) + a6; *)

ST	res	(* almacenar resultado actual en variable res *)


Invocación de subprogramas o funciones

Un subprograma o una función (escritos en cualquiera de los lenguajes IL, ST, LD, FBD o "C") se invoca desde el lenguaje IL, utilizando su nombre como operador.

Operación	ejecuta un subprograma o una función  el valor devuelto por el subprograma o la función se almacena en el resultado actual IL.

Modificadores

permitidos	(ninguno)

Operando	El primer parámetro de invocación debe estar almacenado en el resultado actual antes de producirse la llamada. Los siguientes se expresan en el campo del operando, separados por comas.

Ejemplo:

(* Programa de invocación : convierte un valor analógico en un valor de tiempo *)

Main:	LD	bi0

SUBPRO	bi1,bi2	(* invoca subprograma para conseguir valor analógico *)

ST	resultado	(* resultado := valor retornado por subprograma *)

GT	vmax	(* test de rebasamiento de valor *)

RETC	(* retorno si hay rebasamiento *)

LD	resultado

MUL	1000	(* convierte segundos en milisegundos *)

TMR	(* convierte a temporizador *)

ST	tmval	(* almacena valor convertido en un temporizador *)

(* Invocado subprograma llamado 'SUBPRO' : evalúa el valor analógico *)

(* dado como valor binario en tres entradas booleanas: in0, in1, in2 son los tres parámetros booleanos de entrada del subprograma *)

LD	in2

ANA	(* resultado = ana (in2); *)

MUL	2	(* resultado := 2*ana (in2); *)

ST	temporary	(* temporary := resultado *)

LD	in1

ANA

ADD 	temporary	(* resultado := 2*ana (in2) + ana (in1); *)

MUL	2	(* resultado := 4*ana (in2) + 2*ana (in1); *)

ST	temporary	(* temporary := resultado *)

LD	in0

ANA

ADD	temporary	(* resultado := 4*ana (in2) + 2*ana (in1)+ana (in0); *)

ST	SUBPRO	(* retorna resultado actual a programa invocante *)


Invocación de bloques de función: operador CAL

Operación	invoca un bloque de función

Modificadores

permitidos	C   N

Operando	Nombre del bloque de función específico.

Tienen que asignarse los parámetros de entrada de los bloques antes de la invocación, utilizando la secuencia de operaciones LD/ST.

Se utilizan parámetros de salida si se conocen.

Ejemplo 1:

(* Invocación de bloque de función SR : SR1 es una instancia de SR *)

LD	auto_mode

Y	start_cmd

ST	SR1.set1

LD	stop_cmd

ST	SR1.reset

CAL	SR1

LD	SR1.Q1

ST	command

(* FBD equivalente : *)

Ejemplo 2

(* Se supone que R_TRIG1 es una instancia del bloque R_TRIG y CTU1 es una instancia del bloque CTU *)

LD	command

ST	R_TRIG1.clk

CAL	R_TRIG1

LD	R_TRIG1.Q

ST	CTU1.cu

LDN	auto_mode

ST	CTU1.reset

LD	100

ST	CTU1.pv

CAL	CTU1

LD	CTU1.Q

ST	overflow

LD	CTU1.cv

ST	result

(* FBD equivalente: *)


 Lenguaje ST

ST (Texto Estructurado) es un lenguaje estructurado de alto nivel diseñado para procesos de automatización. Este lenguaje se usa principalmente para implementar procesos complejos que no pueden expresarse fácilmente con lenguajes gráficos. ST es el lenguaje por defecto para la descripción de las acciones contenidas en los pasos y condiciones asociados a las transiciones del lenguaje SFC.

Sintaxis principal de ST

Expresiones y paréntesis

Invocación de funciones o bloques de función

Operadores booleanos específicos de ST

Sentencias básicas ST

Extensiones ST


Sintaxis principal de ST

Un programa ST es una lista de sentencias ST. Cada sentencia acaba con un separador constituido por un punto y coma (";"). Los nombres utilizados en el código fuente (identificadores de variables, constantes, palabras clave del lenguaje...) se espacian con separadores inactivos (carácter de espacio, fin de línea o pasos de tabulador) o con separadores activos, que poseen un significado bien definido (por ejemplo, el separador ">" indica la comparación "mayor que"). Se pueden insertar comentarios en el texto libremente. Un comentario tiene que empezar por "(*" y finalizar por "*)". Cada sentencia termina con un separador en forma de punto y coma (";"). Estos son los tipos básicos de sentencias ST:

- sentencia de asignación (variable := expresión;)

- invocación de subprogramas o funciones

- invocación de bloques de función

- sentencias de selección (IF, THEN, ELSE, CASE...)

- sentencias de iteración (FOR, WHILE, REPEAT...)

- sentencias de control (RETURN, EXIT...)

- sentencias especiales para enlaces con otros lenguajes tales como SFC

Se puede introducir separadores inactivos libremente entre los separadores activos, expresiones constantes e identificadores. Los separadores inactivos en ST son: Espacios o caracteres en blanco, Tabulaciones y caracteres de Fin de línea. A diferencia de los lenguajes con formato de líneas, como IL, pueden introducirse fines de línea en cualquier parte del programa. Se deberá tener en cuenta las siguientes normas a la hora de utilizar separadores inactivos, para aumentar la legibilidad del programa ST.

- No escribir más de una sentencia por línea

- Utilizar pasos de tabulador para identar sentencias complejas

- Insertar comentarios para aumentar la legibilidad de líneas o párrafos

Legibilidad de fuente - ejemplos:

Baja legibilidad	Alta legibilidad
imax := max_ite; cond := X12; if not(cond (* alarm *) then return; end_if; for i (* index *) := 1 to max_ite do if i <> 2 then Spcall(); end_if; end_for; (* no effect if alarm *)	(* imax : number of iterations *) (* i: FOR statement index *) (* cond: process validity *) imax := max_ite; cond := X12; if not (cond) then     return; end_if; (* process loop *) for i := 1 to max_ite do     if i <> 2 then         Spcall ();     end_if; end_for;


Expresiones y paréntesis

Las expresiones ST combinan operadores ST y operandos variables o constantes. Para cada expresión individual (que combine operandos con un operador ST), los operandos deben ser del mismo tipo. Dicha expresión tiene el mismo tipo que sus operandos, y se puede utilizar en una expresión más compleja. Por ejemplo:

(boo_var1 AND boo_var2)	posee tipo BOO

not (boo_var1)	posee tipo BOO

(sin (3.14) + 0.72)	posee tipo ANALÓGICO REAL

(t#1s23 + 1.78)	no es una expresión válida

Se utilizan los paréntesis para aislar las subpartes de la expresión y para estructurar explícitamente la prioridad de las operaciones. Cuando no aparecen paréntesis en una expresión compleja, la secuencia de operaciones viene indicada implícitamente por la prioridad por defecto que exista entre los operadores ST. Por ejemplo:

2 + 3 * 6 	es igual a 2+18=20	ya que el operador de multiplicación tiene una prioridad mayor

(2+3) * 6	es igual a 5*6=30	la prioridad viene dada por los paréntesis

Advertencia: Se puede incluir un número máximo de 8 niveles de paréntesis dentro de una expresión.


Invocación de funciones o bloques de función

Puede utilizarse la invocación estándar de funciones ST para cada uno de los siguientes objetos:

- Subprogramas

- Librerías de funciones y bloques de función escritos en lenguajes IEC

- Funciones y bloques de función "C"

- Funciones de conversión de tipos

Invocación de subprogramas o funciones

Invocación de bloques de función


Invocación de subprogramas o funciones

Nombre:	nombre del subprograma o función de librería invocado, escrito en un lenguaje IEC o en "C".

Significado:	invoca un subprograma o función ST, IL, LD o FBD o una función "C" y obtiene su valor de retorno.

Sintaxis:	<variable> := <subprog> (<par1>, ... <parN> );

Operandos:	El tipo de valor de retorno y los parámetros de invocación deben estar conformes con la interfaz definida para el subprograma.

Valor de retorno:	valor devuelto por el subprograma.

Se puede utilizar la invocación de subprogramas en cualquier expresión. Puede utilizarse igualmente en una transición SFC.

Ejemplo1: Invocación de subprograma

(* Programa ST principal *)

(* consigue un valor analógico y lo convierte a un valor de tiempo limitado*)

ana_timeprog := SPlimit ( tprog_cmd );

appl_timer := tmr (ana_timeprog * 100);

(* Programa FBD invocado de nombre 'SPlimit' *)

Ejemplo2: Invocación de función

(* las funciones usadas en expresiones complejas: min, max, right, mlen, y left son funciones "C" estandar *)

limited_value := min (16, max (0, input_value) );

rol_msg := right (message, mlen (message) - 1) + left (message, 1);


Invocación de bloques de función

Nombre:	nombre de la instancia de bloque de función.

Significado:	invoca un bloque de función de la librería ISaGRAF o de la librería del usuario y accede a sus parámetros de retorno

Sintaxis:	(* llamada del bloque de función *)

<nombre_bloque> ( <p1>, <p2> ... );

(* consigue sus parámetros de retorno *)

<resultado> := <nombre_bloque>. <ret_param1>;

...

<resultado> := <nombre_bloque>. <ret_paramN>;

Operandos:	los parámetros son expresiones que concuerdan con el tipo de los parámetros especificados para ese bloque de función

Valor de retorno:	Véase Sintaxis para obtener los parámetros de retorno.

Debe consultarse la librería ISaGRAF para hallar el significado y tipo de cada parámetro de bloque de función. Se tiene que declarar la instancia del bloque de función (nombre de la copia) en el diccionario.

Ejemplo :

(* Programa ST invocando un bloque de función *)

(* declarar la instancia del bloque en el diccionario: *)

(* trigb1 : bloque R_TRIG - detección flanco positivo *)

(* activación de bloque de función desde lenguaje ST *)

trigb1 (b1);

(* acceso a parámetros de retorno *)

If (trigb1.Q) Then nb_edge := nb_edge + 1; End_if;


Operadores booleanos específicos de ST

Los siguientes operadores booleanos son específicos del lenguaje ST:

REDGE	detección de flanco de subida

FEDGE	detección de flanco de bajada

También pueden utilizarse otros operadores booleanos estándares como:

- NOT	negación booleana

- AND (&)	'Y' lógica

- OR	'O' lógica

- XOR	'O' exclusiva lógica

Su descripción se encuentra en la sección 'Operadores, bloques de función y funciones estándares'.


Operador "REDGE"

Nombre:	REDGE

Significado:	evalúa el flanco de subida de una expresión booleana completa

Sintaxis:	<flanco> := REDGE ( <expresión_booleana>,<variable_memoria> );

Operandos:	el primer operando es cualquier variable booleana o expresión compleja

el segundo operando es una variable booleana interna que se utiliza para almacenar el último estado de la expresión

Valor de retorno:	VERDADERO cuando la expresión cambia de FALSO a VERDADERO

FALSO en todos los demás casos

No se puede detectar el flanco de subida de una expresión en más de una ocasión durante el mismo ciclo de ejecución, utilizando el operador REDGE. Este operador se puede utilizar para describir la condición asociada a una transición SFC.

Advertencia: La variable booleana de "memoria" utilizada para almacenar el último estado de la expresión no puede ser utilizada como activador de los flancos de diferentes expresiones.

Cuando la expresión es una variable booleana denominada "xxx", se debe declarar una variable interna única llamada "EDGE_xxx" y utilizarla en las expresiones REDGE asociadas a esta variable. Este método asegura que la variable de memoria no quede sobrescrita durante otras evaluaciones REDGE.

Ejemplo:

(* Programa ST utilizando el operador REDGE *)

(* este programa cuenta los flancos positivos de una entrada booleana *)

(* Bi120 es una variable booleana de entrada *)

(* Edge_Bi120 es la memoria de variable de estado Bi120 *)

If REDGE (Bi120, Edge_Bi120) Then

Counter := Counter + 1;

End_if;

Nota: Este operador no figura en la norma IEC1131-3. Existe la opción de utilizar el bloque estándar R_TRIG. Se ha mantenido por razones de compatibilidad.


Operador "FEDGE"

Nombre:	FEDGE

Significado:	evalúa el flanco de bajada de una expresión booleana

Sintaxis:	<flanco> := FEDGE ( <expresión_booleana>, <variable_memoria> );

Operandos:	el primer operando es cualquier variable booleana o expresión compleja

el segundo operando es una variable booleana interna que se utiliza para almacenar el último estado de la expresión

Valor de retorno:	VERDADERO cuando la expresión cambia de VERDADERO a FALSO

FALSO en todos los otros casos.

No se puede detectar el flanco de bajada de una expresión en más de una ocasión durante el mismo ciclo de ejecución, utilizando el operador FEDGE. Este operador se puede utilizar para describir la condición asociada a una transición SFC.

Advertencia: La variable booleana de "memoria" utilizada para almacenar el último estado de la expresión no puede ser utilizada como activador de los flancos de diferentes expresiones.

Cuando la expresión es una variable booleana denominada "xxx", se debe declarar una variable interna única llamada "EDGE_xxx" y utilizarla en las expresiones FEDGE asociadas a esta variable. Este método asegura que la variable de memoria no quede sobrescrita durante otras evaluaciones FEDGE.

Ejemplo:

(* Programa ST utilizando el operador FEDGE *)

(* este programa cuenta los flancos negativos de una entrada booleana *)

(* Bi120 es una variable de entrada booleana *)

(* Edge_Bi120 es la memoria de variable de estado Bi120 *)

If FEDGE (Bi120, Edge_Bi120) Then

Counter := Counter + 1;

End_if;

Nota: Este operador no figura en la norma IEC1131-3. Existe la opción de utilizar el bloque estándar F_TRIG. Se ha mantenido por razones de compatibilidad.


Sentencias básicas ST

Las sentencias básicas del lenguaje ST son:

Asignación

Sentencia RETURN

Estructura IF-THEN-ELSIF-ELSE

Sentencia CASE

Sentencia de iteración WHILE

Sentencia de iteración REPEAT

Sentencia de iteración FOR

Sentencia EXIT


Asignación

Nombre:	:=

Significado:	asigna una variable a una expresión

Sintaxis:	<variable> := <cualquier_expresión> ;

Operandos:	la variable debe ser interna o de salida

La variable y la expresión deben tener el mismo tipo

La expresión puede ser la invocación de un subprograma o una función de la librería ISaGRAF.

Ejemplo:

(* Programa ST con asignaciones *)

(* variable <<= variable *)

bo23 := bo10;

(* variable <<= expresión *)

bo56 := bx34 OR alrm100 & (level >= over_value);

result := (100 * input_value) / scale;

(* asignación con retorno de subprograma *)

rc := PSelect ( );

(* asignación con invocación de función *)

limited_value := min (16, max (0, input_value) );


Sentencia RETURN

Nombre:	RETURN

Significado:	termina la ejecución del programa actual

Sintaxis:	RETURN ;

Operandos:	(ninguno)

En un bloque de acciones SFC, la sentencia RETURN indica el final de la ejecución de ese bloque exclusivamente.

Ejemplo:

(* Especificación FBD del programa: contador programable *)

(* Implementación ST del programa, utilizando la sentencia RETURN *)

If not (CU) then

Q := FALSO;

CV := 0;

RETURN;   (* termina el programa *)

end_if;

if R then

CV := 0;

else

if (CV < PV) then

CV := CV + 1;

end_if;

end_if;

Q := (CV >= PV);


Sentencia IF-THEN-ELSIF-ELSE

Nombre:	IF ... THEN ... ELSIF ... THEN ... ELSE ... END_IF

Significado:	ejecuta una de varias listas de sentencias ST

La selección se realiza en base al valor de una expresión booleana

Sintaxis:	IF <expresión_booleana> THEN

   <sentencia> ;

   <sentencia> ;

   ...

ELSIF <expresión_ booleana> THEN

   <sentencia> ;

   <sentencia> ;

   ...

ELSE

   <sentencia> ;

   <sentencia> ;

   ...

END_IF;

Las sentencias ELSE y ELSIF son opcionales. Si no se incluye la sentencia ELSE, no se ejecutan instrucciones cuando la condición es FALSO.

Ejemplo:

(* Programa ST utilizando la sentencia IF *)

IF manual AND not (alarm) THEN

level := manual_level;

bx126 := bi12 OR bi45;

ELSIF over_mode THEN

level := max_level;

ELSE

level := (lv16 * 100) / scale;

END_IF;

(* Estructura IF sin ELSE *)

If overflow THEN

alarm_level := VERDADERO;

END_IF;


Sentencia CASE

Nombre:	CASE ... OF ... ELSE ... END_CASE

Significado:	ejecuta una de varias listas de sentencias ST

La selección se realiza en base a una expresión entera

Sintaxis:	CASE <expresión_entera> OF

   <valor> : <sentencias> ;

   <valor> , <valor> : <sentencias> ;

   ...

ELSE

   <sentencias> ;

END_CASE;

Los valores CASE tienen que ser expresiones constantes enteras. Varios valores, separados por comas, pueden conducir a la misma lista de sentencias. La sentencia ELSE es opcional.

Ejemplo:

(* Programa ST utilizando la sentencia CASE *)

CASE error_code OF

255:	err_msg := 'División por cero';

fatal_error := VERDADERO;

1:	err_msg := 'Rebasamiento';

2, 3:	err_msg := 'Signo erróneo';

ELSE

err_msg := 'Error desconocido';

END_CASE;


Sentencia WHILE

Nombre:	WHILE ... DO ... END_WHILE

Significado:	estructura de iteración para un grupo de sentencias ST

La condición de "continuar" se evalúa ANTES que cualquier iteración

Sintaxis:	WHILE <expresión_booleana> DO

   <sentencia> ;

   <sentencia> ;

   ...

END_WHILE ;

Advertencia: Teniendo en cuenta que ISaGRAF es un sistema síncrono, las variables de entrada no se refrescan durante las iteraciones WHILE. No se puede utilizar el cambio de estado de una variable de entrada para describir la condición de una sentencia WHILE.

Ejemplo:

(* Programa ST utilizando la sentencia WHILE *)

(* este programa usa funciones "C" específicas para leer caracteres en un puerto serie *)

string := ''; (* cadena vacía *)

nbchar := 0;

WHILE ((nbchar < 16) & ComIsReady ( )) DO

string := string + ComGetChar ( );

nbchar := nbchar + 1;

END_WHILE;


Sentencia REPEAT

Nombre:	REPEAT ... UNTIL ... END_REPEAT

Significado:	estructura de iteración para un grupo de sentencias ST

La condición de "continuar" se evalúa DESPUÉS de cualquier iteración

Sintaxis:	REPEAT

   <sentencia> ;

   <sentencia> ;

  ...

UNTIL <condición_booleana>

END_REPEAT ;

Advertencia: Teniendo en cuenta que ISaGRAF es un sistema síncrono, las variables de entrada no se refrescan durante las iteraciones REPEAT. No se puede utilizar el cambio de estado de una variable de entrada para describir la condición de finalización de una sentencia REPEAT.

Ejemplo:

(* Programa ST utilizando la sentencia REPEAT *)

(* este programa utiliza funciones "C" específicas para leer caracteres en un puerto serie *)

string := ''; (* cadena vacía *)

nbchar := 0;

SI ComIsReady ( ) THEN

REPEAT

string := string + ComGetChar ( );

nbchar := nbchar + 1;

UNTIL ( (nbchar >= 16) OR NOT (ComIsReady ( )) )

END_REPEAT;

END_IF


Sentencia FOR

Nombre:	FOR ... TO ... BY ... DO ... END_FOR

Significado:	ejecuta un número limitado de iteraciones,

utilizando una variable analógica entera de índice

Sintaxis:	FOR <index> := <mini> TO <maxi> BY <step> DO

   <sentencia> ;

   <sentencia> ;

END_FOR;

Operandos:	index:	variable analógica interna incrementada en cualquier bucle

mini:	valor inicial de referencia (antes del primer bucle)

maxi:	valor máximo permitido para la referencia

step:	incremento de la referencia en cada bucle

La sentencia [ BY step ] es opcional. Si no se especifica lo contrario, el paso incremental es 1.

Advertencia: Teniendo en cuenta que ISaGRAF es un sistema síncrono, las variables de entrada no se refrescan durante las iteraciones FOR.

Este es el equivalente "while" de una sentencia FOR:

index := mini;

while (index <= maxi) do

   <sentencia> ;

   <sentencia> ;

   index := index + step;

end_while;

Ejemplo:

(* Programa ST utilizando la sentencia FOR *)

(* este programa extrae los caracteres numéricos de una cadena *)

length := mlen (message);

target := ''; (* cadena vacía *)

FOR index := 1 TO length BY 1 DO

code := ascii (message, index);

IF (code >= 48) & (code <= 57) THEN

target := target + char (code);

END_IF;

END_FOR;


Sentencia EXIT

Nombre:	EXIT

Significado:	salir de una sentencia de iteración FOR, WHILE o REPEAT

Sintaxis:	EXIT;

Operandos:	(ninguno)

EXIT se suele usar en una sentencia IF, dentro de un bloque FOR, WHILE o REPEAT.

Ejemplo:

(* Programa ST utilizando la sentencia EXIT *)

(* este programa busca un carácter en una cadena *)

length := mlen (message);

found := NO;

FOR index := 1 TO length BY 1 DO

code := ascii (message, index);

IF (code  = searched_char) THEN

found := YES;

EXIT;

END_IF;

END_FOR;


Extensiones ST

Las siguientes funciones son extensiones del lenguaje ST::

TSTART - TSTOP: control de temporizador

Se dispone de las siguientes sentencias y funciones para controlar la ejecución de programas hijos SFC. Pueden utilizarse dentro de bloques ACTION(): ... END_ACTION; en pasos SFC.

GSTART	inicia un programa SFC

GKILL	finaliza un programa SFC

GFREEZE	congela un programa SFC

GRST	reinicia un programa SFC congelado

GSTATUS	obtiene el estado actual de un programa SFC

Advertencia: Estas funciones no aparecen en la norma IEC 1131-3.

GSTART y GKILL tienen una sencilla equivalencia en la siguiente sintaxis para un paso SFC:

child_name(S); (* equivalente a GSTART(child_name); *)

child_name(R); (* equivalente a GKILL(child_name); *)

Se puede emplear los siguientes campos para acceder al estado de un paso SFC:

GSnnn.x	valor booleano que representa la actividad del paso

GSnnn.t	tiempo transcurrido desde la última activación del paso

("nnn" es el número de referencia del paso SFC)

También es posible verificar la actividad de un paso que haya sido declarado en otro programa SFC, utilizando la siguiente sintaxis:

GSnnn(progname).x

Advertencia: Esta manera de referenciar un paso de otro programa, utilizando la expresada sintaxis, no aparece en la norma IEC 1131-3. Una forma sencilla de lograr el mismo objetivo, pero respetando las normas IEC, es la de declarar en el diccionario una variable booleana global que represente la actividad del paso que va a ser verificada (por ejemplo, ref_paso_X)., Después, se inserta en el paso la variable con el calificador N (ref_paso_X(N);). Posteriormente, se utiliza la variable en el programa en el cual se desea verificar la actividad del paso.

Programa Prog	el otro programa que necesita conocer la actividad del paso del programa Prog


Sentencia TSTART

Nombre:	TSTART

Significado:	inicia el conteo de una variable temporizador.

el comando TSTART no modifica el valor del temporizador; es decir, el conteo comienza a partir del valor actual del temporizador.

Sintaxis:	TSTART ( <variable_temporizador> );

Operandos:	cualquier variable temporizador inactiva

Valor de retorno:	(ninguno)

Ejemplo:

(* Programa SFC utilizando las sentencias TSTART y TSTOP *)

Si bi100, el diagrama de tiempo es siempre FALSO:

El reloj mantiene el mismo valor durante un ciclo.


Sentencia TSTOP

Nombre:	TSTOP

Significado:	finaliza la actualización de una variable de temporizador

El comando TSTOP no modifica el valor de temporizador

Sintaxis:	TSTOP ( <variable_temporizador> );

Operandos:	cualquier variable temporizador activa

Valor de retorno:	(ninguno)

Ejemplo: Véase TSTART (la función se describe en el apartado anterior)


Sentencia GSTART

Nombre:	GSTART

Significado:	inicia un programa hijo SFC mediante la colocación de una marca en cada uno de sus pasos iniciales

Sintaxis:	GSTART ( <programa_hijo> );

Operandos:	el programa SFC especificado tiene que ser un hijo de aquel que contiene la sentencia

Valor de retorno:	(ninguno)

La sentencia GSTART no arranca los hijos del programa hijo de forma automática.

Nota: Dado que GSTART no está incluida en la norma IEC 1131-3, existe la alternativa de usar el calificador S con la siguiente sintaxis para arrancar un programa hijo SFC:

Nombre_hijo(S);

Ejemplo: Uso de GSTART y GKILL

(* Secuencia 'Sfather' *)	(* Secuencia 'Schild' *)


Sentencia GKILL

Nombre:	GKILL

Significado:	finaliza un programa hijo SFC mediante la eliminación de las marcas que en ese momento se encuentren en sus pasos

Sintaxis:	GKILL ( <programa_hijo> );

Operandos:	el programa SFC especificado tiene que ser un hijo de aquel que contiene la sentencia

Valor de retorno:	(ninguno)

Se finalizan los hijos del programa hijo de forma automática con el programa especificado.

Nota: Dado que GKILL no está incluida en la norma IEC 1131-3, existe la alternativa de usar el calificador R con la siguiente sintaxis para finalizar un programa hijo SFC:

Nombre_hijo(R);

Ejemplo: Véase GSTART (la función se describe en el apartado anterior)


Sentencia GFREEZE

Nombre:	GFREEZE

Significado:	Suspende la ejecución de un programa hijo SFC. El programa congelado se puede reiniciar con la sentencia GRST.

Sintaxis:	GFREEZE ( <programa_hijo> );

Operandos:	el programa SFC especificado tiene que ser un hijo de aquel que contiene la sentencia

Valor de retorno:	(ninguno)

Se congelan los hijos del programa hijo de forma automática junto con el programa especificado.

Nota: GFREEZE no se encuentra en la norma IEC 1131-3.

Ejemplo:


Sentencia GRST

Nombre:	GRST

Significado:	reinicia un programa hijo SFC que ha sido congelado por la sentencia GFREEZE.

Sintaxis:	GRST ( <programa_hijo> );

Operandos:	el programa SFC especificado tiene que ser un hijo de aquel que contiene la sentencia

Valor de retorno:	(ninguno)

Se reinician los hijos del programa hijo de forma automática con la sentencia GRST.

Nota: GRST no se encuentra en la norma IEC 1131-3.

Ejemplo: Véase GFREEZE (la función se describe en el apartado anterior)


Sentencia GSTATUS

Nombre:	GSTATUS

Significado:	obtiene el estado actual de un programa SFC

Sintaxis:	<variable_analógica> := GSTATUS ( <programa_hijo> );

Operandos:	el programa SFC especificado tiene que ser un hijo de aquel que contiene la sentencia

Valor de retorno:	0 = el programa está inactivo (finalizado)

1 = el programa está activo (iniciado)

2 = el programa está congelado

Nota: GSTATUS no se encuentra en la norma IEC 1131-3.

Ejemplo:


 Lenguaje FBD

El Diagrama de Bloques de función (FBD) es un lenguaje gráfico. Permite al programador la construcción de procedimientos complejos, tomando funciones existentes de la librería ISaGRAF y enlazándolas en la zona del diagrama gráfico.

Formato principal del diagrama FBD

Sentencia RETURN

Saltos y etiquetas

Negación booleana

Invocación de funciones o bloques de función desde FBD


Formato principal del diagrama FBD

El diagrama FBD describe una función entre variables de entrada y variables de salida. Una función se describe como un conjunto de bloques de función elementales. Las variables de entrada y salida están vinculadas a los bloques por medio de líneas de conexión. Una salida de un bloque de función también puede conectarse a la entrada de otro bloque.

Una función completa manejada por un programa FBD está construida con bloques de función elementales y estándares procedentes de la librería ISaGRAF. Cada bloque de función tiene un número fijo de puntos de conexión de entradas y un número fijo de puntos de conexión de salidas. Un bloque de función está representado por un único rectángulo. Las entradas se conectan a su borde izquierdo. Las salidas se conectan a su borde derecho. Un bloque de función elementales lleva a cabo una única función entre sus entradas y salidas. El nombre de la función que tiene que desempeñar el bloque está escrito en su símbolo rectangular. Cada entrada o salida de un bloque posee un tipo bien definido.

Las variables de entrada de un programa FBD tienen que estar conectadas a los puntos de conexión de entradas de los bloques de función. El tipo de cada variable tiene que ser el mismo que se espera para la entrada asociada. Una entrada de un diagrama FBD puede ser una expresión constante, cualquier variable interna o de entrada, o una variable de salida.

Las variables de salida de un programa FBD tienen que estar conectadas a los puntos de conexión de salidas de los bloques de función. El tipo de cada variable tiene que ser el mismo que se espera para la salida de bloque asociada. Una salida de un diagrama FBD puede ser cualquier variable interna o de salida, o el nombre del programa (sólo en el caso de subprogramas). Cuando una salida es el nombre del subprograma que se está editando en ese momento, representa la asignación del valor de retorno del subprograma (retorno al programa invocante).

Las variables de entrada y salida y las entradas y salidas de los bloques de función están unidas por medio de líneas de conexión. Pueden utilizarse líneas simples para conectar dos puntos lógicos del diagrama:

- Una variable de entrada y una entrada de un bloque de función

- Una salida de un bloque de función y una entrada de otro bloque

- Una salida de un bloque de función y una variable de salida

La conexión está orientada, lo que significa que la línea lleva datos asociados desde la extremidad izquierda hasta la extremidad derecha. Las extremidades izquierda y derecha de la línea de conexión deben ser del mismo tipo.

Puede utilizarse una conexión múltiple en la extremidad derecha para difundir una información desde la extremidad izquierda hacia cada una de las extremidades derechas. Todas las extremidades de la conexión deben ser del mismo tipo.


Sentencia RETURN

La palabra clave "<RETURN>", o RETORNO, puede aparecer como una salida del diagrama. Tiene que estar conectada a un punto de conexión de salida booleana de un bloque de función. La sentencia RETURN representa una terminación condicional del programa: si la salida de la caja que está conectada a la sentencia tiene el valor booleano VERDADERO, el final (la parte restante) del diagrama no se ejecuta.

(* Ejemplo de un programa FBD que utiliza la sentencia RETURN *)

(* equivalencia ST: *)

If auto_mode OR alarm Then

Return;

End_if;

bo67 := (bi10 AND bi23) OR x_cmd;


Saltos y etiquetas

Se utilizan los saltos y las etiquetas para controlar la ejecución del diagrama. No pueden conectarse otros objetos a la derecha de un símbolo de salto o etiqueta. Se emplean las siguientes notaciones:

>>LAB	salto a una etiqueta (el nombre de la etiqueta es "LAB")

LAB:	definición de una etiqueta (el nombre de la etiqueta es "LAB")

Si la línea de conexión situada a la izquierda del símbolo de salto muestra el estado booleano VERDADERO, la ejecución del programa salta directamente después del símbolo de etiqueta correspondiente.

(* Ejemplo de un programa FBD que utiliza etiquetas y saltos *)

(* Equivalencia IL: *)

ld	manual

and	b1

jmpc	NOMODIF

ld	input1

or	input2

st	result

NOMODIF:	ld	result

or	valid

st	cmd10


Negación booleana

Una línea de conexión simple, con su extremidad derecha conectada a una entrada de un bloque de función, puede terminar con una negación booleana. La negación está representada por un círculo pequeño. Cuando se utiliza una negación booleana, las extremidades izquierda y derecha de la línea de conexión deben ser del tipo BOOLEANO.

(* Ejemplo de un programa FBD utilizando etiquetas y saltos *)

(* Equivalencia ST: *)

output1 := input1 AND NOT (input2);


Invocación de funciones o bloques de función desde FBD

El lenguaje FBD permite la invocación de subprogramas, funciones o bloques de función. Un subprograma, función o bloque de función está representado por una caja de función. El nombre que aparece en la caja es el nombre del subprograma, de la función o del bloque de función.

En el caso de un subprograma o una función, el valor de retorno es la única salida de la caja de función. Los bloques de función pueden tener más de una salida.

(* Ejemplo de un programa FBD utilizando el bloque de SUBPROGRAMA *)

(* Equivalencia ST *)

net_weight := Weighing (mode, delta); (* llamar a sub-programa *)

If (net_weight = 0) Then Return; End_if;

weight := net_weight + tare_weight;


 Lenguaje SFC

El Diagrama de Funciones Secuenciales (SFC) es un lenguaje gráfico que se utiliza para describir operaciones secuenciales. El proceso se representa como un conjunto de pasos bien definidos, vinculados por medio de transiciones. Se asocia una condición booleana a cada transición. Las acciones dentro de cada paso se detallan por medio de otros lenguajes (ST, IL, LD y FDB).

Principal formato de diagramas SFC

Componentes básicos SFC

Divergencias y convergencias

Macropaso

Acciones dentro de los pasos

Condiciones vinculadas a transiciones

Reglas dinámicas SFC

Jerarquía de programas SFC


Principal formato de diagramas SFC

Un programa SFC es un conjunto gráfico de pasos y transiciones, unidos por vínculos orientados. Se emplean múltiples vínculos de conexión para representar divergencias y convergencias. Se puede separar una parte determinada del programa completo, quedando representada en el esquema de conjunto por un único símbolo denominado macropaso. Las reglas gráficas básicas de SFC son las siguientes:

- A un paso no le puede seguir otro paso

- A una transición no le puede seguir otra transición


Componentes básicos SFC

Los componentes básicos (símbolos gráficos) del lenguaje SFC son: pasos y pasos iniciales, transiciones, vínculos orientados, y saltos a un paso.

Pasos y pasos iniciales

Transiciones

Vínculos orientados

Saltar a un paso


Pasos y pasos iniciales

Se representa un paso con un único cuadrado. Cada paso está referenciado con un número, escrito dentro del símbolo cuadrado del paso. Se incluye la descripción principal del paso en un rectángulo vinculado al símbolo del paso. Esta descripción es un comentario libre (es decir, no es parte del lenguaje de programación). La información arriba indicada se denomina el Nivel 1 del paso:

En el tiempo de ejecución, una marca indica que el paso se encuentra activo:

Paso activo:	Paso inactivo:

La situación inicial de un programa SFC se expresa mediante pasos iniciales. Un paso inicial posee un símbolo gráfico con un marco doble. Se coloca una marca automáticamente en cada paso inicial cuando se arranca el programa.

Paso inicial:

Un programa SFC debe contener al menos un paso inicial.

Estos son los atributos de un paso. Se puede utilizar este tipo de campo en cualquiera de los otros lenguajes:

GSnnn.x	actividad del paso (valor booleano)

GSnnn.t	duración de la activación del paso (valor en tiempo)

(donde nnn es el número de referencia del paso)


Transiciones

Las transiciones se representan por medio de unas barras horizontales pequeñas que atraviesan el vínculo de conexión. Cada transición está referenciada con un número escrito al lado del símbolo de transición. Se incluye la descripción principal del paso a la derecha del símbolo de transición. Esta descripción es un comentario libre (no es parte del lenguaje de programación). La información arriba indicada se denomina el Nivel 1 del paso:


Vínculos orientados

Se utilizan líneas simples para vincular pasos y transiciones. Estos son vínculos orientados. Cuando no se indica explícitamente la orientación, el vínculo se orienta de arriba abajo.


Saltar a un paso

Pueden emplearse símbolos de salto para indicar un vínculo de conexión entre una transición y un paso, sin necesidad de dibujar la línea de conexión. El símbolo de salto debe estar referenciado con el número del paso destino:

No se puede utilizar un símbolo de salto para representar un vínculo entre un paso y una transición. Ejemplo de saltos  los siguientes diagramas son equivalentes:


Divergencias y convergencias

Las divergencias son vínculos de conexión múltiples desde un símbolo SFC (paso o transición) a muchos otros símbolos SFC. Las convergencias son vínculos de conexión múltiples desde más de un símbolo SFC a otro símbolo SFC. Tanto las divergencias como las convergencias pueden ser simples o dobles.

Divergencias simples

Divergencias dobles


Divergencias simples

Una divergencia simple es un enlace múltiple entre un paso y muchas transiciones. Permite que la marca activa pase a una de un número de ramas. Una convergencia simple es un enlace múltiple desde muchas transiciones a un mismo paso. Se suelen utilizar las convergencias simples para agrupar a los ramales SFC que fueron iniciados en una divergencia simple. Las divergencias y convergencias simples se representan con líneas horizontales simples.

Advertencia: Las condiciones asociadas a las diferentes transiciones al inicio de una divergencia simple no son implícitamente exclusivas. Las condiciones de las transiciones deben incluir un detalle explícito de la exclusividad para asegurar que sólo una marca pueda progresar en un ramal de la divergencia durante el tiempo de ejecución. A continuación se muestra un ejemplo de divergencias y convergencias simples:

(* Programa SFC con divergencia y convergencia simple *)


Divergencias dobles

Una divergencia doble es un enlace múltiple desde una transición a muchos  pasos. Corresponde a operaciones en paralelo del proceso. Una convergencia doble es un enlace múltiple desde numerosos pasos a una única transición. Las convergencias dobles se utilizan generalmente para agrupar a los ramales SFC iniciados en una divergencia doble. Las divergencias y convergencias dobles se representan con líneas horizontales dobles.

Ejemplo de divergencia y convergencia doble:

(* Programa SFC con divergencia y convergencia doble *)


Macropaso

Un macropaso es una representación única de un grupo único de pasos y transiciones. El cuerpo de la macro se describe por separado, en otro lugar del mismo programa SFC. Aparece como un único símbolo en el esquema general SFC. Este es el símbolo que se emplea para representar un macropaso:

El número de referencia que se indica en el símbolo de la macro es el número de referencia del primer paso que figura en el cuerpo de la macro. El macropaso debe comenzar con un paso inicial y finalizar con un paso final. El diagrama debe ser autocontenido. El paso inicial no debe poseer enlaces ascendentes (ninguna transición hacia atrás) y el paso final no debe poseer enlaces descendentes (ninguna transición hacia delante). Se puede colocar un símbolo de macropaso en el cuerpo de otro macropaso.

Advertencia: Teniendo en cuenta que un macropaso es un conjunto único de pasos y transiciones, la misma macro no puede utilizarse más de una vez en un programa SFC.

Ejemplo de macropaso:

(* Programa SFC con macropaso *)

(* Diagrama principal *)	(* Cuerpo de la macropaso *)


Acciones dentro de los pasos

El Nivel 2 de un paso SFC es la descripción detallada de las acciones que se ejecutan durante la actividad del paso. Esta descripción se realiza utilizando las características literales SFC, y otros lenguajes como Texto Estructurado (ST). Los tipos básicos de acciones son:

Acciones booleanas

Acciones pulsantes

Acciones no almacenadas

Acciones SFC

Pueden describirse varias acciones (de tipos iguales o diferentes) en el mismo paso. Las características especiales que permiten el uso de otros lenguajes son:

Invocación de funciones y bloques de función desde una acción

Convecciones IL


Acciones booleanas

Las acciones booleanas asignan una variable booleana con la actividad del paso. Esta variable puede ser bien de salida o bien interna. Se asigna cada vez que empieza o finaliza la actividad del paso. La sintaxis de las acciones booleanas básicas es:

<variable_ booleana> (N) ;	asigna la señal de actividad del paso a la variable

<variable_ booleana> ;	mismo efecto (el atributo N es opcional)

/ <variable_ booleana> ;	asigna a la variable la negación de la señal de actividad del paso

Se dispone de otras funciones para establecer o restablecer una variable booleana, una vez que el paso esté activo. La sintaxis es:

<variable_ booleana> (S) ;	fija la variable en VERDADERO cuando la señal de actividad del paso se convierte en VERDADERO

<variable_ booleana> (R) ;	restablece la variable en FALSO cuando la señal de actividad del paso se convierte en VERDADERO

La variable booleana tiene que ser de SALIDA o INTERNA. La programación SFC que aparece a continuación conduce al siguiente comportamiento:

Ejemplo de acciones booleanas:

(* Programa SFC utilizando acciones BOOLEANAS *)


Acciones pulsantes

Una acción pulsante es una lista de instrucciones ST o IL, que se ejecutan sólo una vez al producirse la activación del paso. Las instrucciones se escriben de acuerdo con la siguiente sintaxis SFC:

ACCION (P) :

(* sentencias ST *)

FIN_ACCION ;

La siguiente ilustración muestra los resultados de una acción pulsante:

Ejemplo de acción pulsante:


Acciones no almacenadas

Una acción no almacenada (normal) es una lista de instrucciones ST o IL que se ejecutan en cada ciclo durante todo el periodo activo del paso. Las instrucciones se escriben de acuerdo con la siguiente sintaxis SFC:

ACCION (N) :

(* instrucciones ST *)

FIN_ACCION ;

La siguiente ilustración muestra los resultados de una acción no almacenada:

Ejemplo de acción no almacenada:


Acciones SFC

Una acción SFC es una secuencia SFC hija, iniciada o finalizada de acuerdo con los cambios que se producen en la señal de actividad de paso. Una acción SFC puede tener un calificador N (No almacenado), S (Establecer) o R (Restablecer). La sintaxis de las acciones SFC básicas es:

<prog_hijo> (N);	inicia la secuencia hija cuando el paso se activa y la finaliza cuando el paso se inactiva

<prog_hijo> ;	mismo efecto (el atributo N es opcional)

<prog_hijo> (S);	inicia la secuencia hija cuando el paso se activa; no se hace nada cuando el paso se inactiva

<prog_hijo> (R);	finaliza la secuencia hija cuando el paso se activa; no hace nada cuando el paso se inactiva

La secuencia SFC que se haya especificado como una acción tiene que ser un programa SFC hijo del programa que se esté editando en ese momento. Obsérvese que el uso de los calificadores S (Establecer) o R (Restablecer) para una acción SFC tiene exactamente el mismo efecto que las instrucciones GSTART y GKILL, que se programan en ST para una acción pulsante.

A continuación se muestra un ejemplo de una acción SFC. El principal programa SFC se denomina padre. Tiene dos hijos SFC, llamados SeqMlx y SeqPump. La programación SFC del programa SFC padre es:

 (* Programa SFC utilizando acciones SFC *)


Invocación de funciones y bloques de función desde una acción

Se pueden invocar subprogramas, funciones o bloques de función (escritos en los lenguajes ST, IL, LD o FBD) o funciones "C" y bloques de función "C" directamente desde un bloque de acciones SFC, con base en la siguiente sintaxis:

Para subprogramas, funciones y funciones "C":

ACTION (P) :

result := sub_program ( ) ;

END_ACTION;

o

ACTION (N) :

result := sub_program ( ) ;

END_ACTION;

Para bloques de función en "C" o en ST, IL, LD, FBD:

ACTION (P) :

Fbinst(in1, in2);

result1 := Fbinst.out1;

result2 := Fbinst.out2;

END_ACTION;

o

ACTION (N) :

Fbinst(in1, in2);

result1 := Fbinst.out1;

result2 := Fbinst.out2;

END_ACTION;

Para una sintaxis detallada, véase la sección dedicada al lenguaje ST.

Ejemplo de invocación de un subprograma en un bloque de acciones:

(* Programa SFC con invocación de subprograma en un bloque de acciones *)


Convenciones IL

Se puede incorporar la programación IL (Lista de Instrucciones) directamente en un bloque de acciones SFC, con base en la siguiente sintaxis:

ACTION (P) :	(* or N *)

#info=IL

     <sentencia>

     <sentencia>

     ....

#endinfo

END_ACTION;

Las palabras claves especiales "#info=IL" y "#endinfo" deben ser introducidas exactamente como se indica, y son sensibles al caso (mayúsculas o minúsculas). No se puede insertar caracteres de espacio o tabulación dentro, después o antes de palabras clave. A continuación se muestra un ejemplo de un programa IL dentro de un bloque de acciones:

(* Programa SFC con secuencia IL en un bloque de acciones *)


Condiciones vinculadas a transiciones

En cada transición, se asocia una expresión booleana que condiciona el franqueo de la transición. Esta condición suele expresarse con el lenguaje ST, o bien utilizando el lenguaje LD (editor Quick LD). Este es el Nivel 2 de la transición. Sin embargo, también se pueden utilizar otras estructuras:

Convenciones del lenguaje ST

Convenciones del lenguaje LD

Convenciones del lenguaje IL

Invocación de funciones desde una transición

Advertencia: Cuando no se añade una expresión a la transición, la condición por defecto es VERDADERO.


Convenciones ST

Se puede utilizar el lenguaje de Texto Estructurado (ST) puede utilizarse para describir la condición que se asocia a una transición. La expresión completa debe ser del tipo booleano y finalizar con punto y coma, de acuerdo con la siguiente sintaxis:

<expresión_booleana> ;

La expresión puede ser una expresión constante VERDADERA o FALSA, una entrada simple o una variable booleana interna, o una combinación de variables que conduce a un valor booleano. A continuación se muestra un ejemplo de programación ST para transiciones:

(* Programa SFC con programación ST para transiciones *)


Convenciones LD

El lenguaje de Diagrama de Escalera (Contactos) (LD) puede utilizarse para describir la condición que se asocia a una transición. El diagrama se compone de un único escalón (línea) con una bobina. El valor de la bobina (salida) representa el valor de la transición.

A continuación se muestra un ejemplo de programación LD para transiciones:


Convenciones IL

La programación de Lista de Instrucciones (IL) puede utilizarse directamente para describir una transición SFC, de acuerdo con la siguiente sintaxis:

#info=IL

<sentencia>

<sentencia>

....

#endinfo

El valor que contiene el resultado actual (registro IL) al final de la secuencia IL provoca la asociación del resultado de la condición a la transición:

Resultado actual = 0 	 	condición es FALSA

Resultado actual <> 0	condición es VERDADERA

Las palabras claves especiales "#info=IL" y "#endinfo" deben ser introducidas exactamente como se indica, y son sensibles al caso (mayúsculas o minúsculas). No se puede insertar caracteres de espacio o tabulación dentro, después o antes de palabras clave. A continuación se muestra un ejemplo de programación IL para transiciones:

(* Programa SFC con programa IL para transiciones *)


Invocación de funciones desde una transición

Puede invocarse cualquier subprograma o función (escritos en los lenguajes FBD, LD, ST o IL), o función "C", para evaluar la condición asociada a una transición, de acuerdo con la siguiente sintaxis:

< sub_program > ( ) ;

El valor de retorno del subprograma o de la función deberá ser booleano y producirá la condición correspondiente:

valor de retorno = FALSO	condición es FALSA

valor de retorno = VERDADERO	condición es VERDADERO

Ejemplo de un subprograma invocado durante una transición:

(* Programa SFC con invocación de subprograma para transiciones *)


Reglas dinámicas SFC

Las cinco reglas dinámicas del lenguaje SFC son:

 Situación inicial

La situación inicial está caracterizada por los pasos iniciales que están, por definición, en el estado activo al principio de la operación. Al menos un paso inicial tiene que estar presente en cada programa SFC.

 Franqueo de una transición

Una transición puede estar habilitada o inhabilitada. Se considera habilitada cuando todos los pasos inmediatamente anteriores y asociados al símbolo de transición correspondiente se encuentran activos. En caso contrario, se considera inhabilitada. Una transición no puede ser franqueada a no ser que:

- esté habilitada, y

- la condición de transición asociada sea verdadera.

 Cambio de estado de pasos activos

El franqueo de una transición conduce simultáneamente al estado activo de los pasos inmediatamente posteriores y al estado inactivo de los pasos inmediatamente anteriores.

 Franqueo simultáneo de transiciones

Se pueden utilizar líneas dobles para indicar aquellas transiciones que tienen que ser franqueadas simultáneamente. Si las transiciones de este tipo se muestran por separado, puede emplearse el estado de actividad de los pasos anteriores (GSnnn.x) para expresar su condición.

 Activación y desactivación simultánea de un paso

Si durante el tiempo de operación se activa y desactiva un paso simultáneamente, se dará prioridad a la activación.


Jerarquía de programas SFC

El sistema ISaGRAF permite la descripción de la estructura vertical de los programas SFC. Los programas SFC se organizan en un árbol jerárquico. Cada programa SFC puede controlar (iniciar, finalizar...) a otros programas SFC. Los programas de este tipo se conocen como hijos del programa SFC que los controla. Los programas SFC están unidos entre sí en un árbol jerárquico principal, valiéndose de una relación "padre-hijo".

Las reglas básicas implícitas en la estructura jerárquica son:

- Los programas SFC que carecen de padre se denominan programas SFC "principales"

- El sistema activa los programas SFC principales cuando se inicia la aplicación

- Un programa puede tener varios programas hijo

- El hijo de un programa no puede tener más de un padre

- Un programa hijo sólo puede ser controlado por su padre

- Un programa no puede controlar a los hijos de uno de sus propios hijos

Las acciones básicas que puede llevar a cabo un programa SFC padre para controlar a su programa hijo son:

Iniciar	(GSTART) Arranca el programa hijo: activa cada uno de sus pasos iniciales. Los hijos de este programa hijo no se inician automáticamente.

Terminar	(GKILL) Termina el programa hijo mediante la desactivación de cada uno de sus  pasos activos. También se finalizan todos los hijos del programa hijo.

Congelar	(GFREEZE) Suspende la ejecución del programa (desactiva acciones de cada paso activo y suspende el cálculo de transiciones) y memoriza el estado de los pasos del programa para que pueda reiniciarse.

Reiniciar	(GRST) Reinicia un programa SFC congelado mediante la reactivación de todos los pasos suspendidos. Los hijos del programa no se reinician automáticamente.

Obtener estado	(GSTATUS) Obtiene el estado actual (activo, desactivo o congelado) de un programa hijo.


 Lenguaje LD

El Diagrama de Escalera (Contactos) (LD) es una representación gráfica de ecuaciones booleanas que combina contactos (argumentos de entrada) con bobinas (resultados de salida). El lenguaje LD permite la descripción de pruebas y modificaciones de datos booleanos mediante la colocación de símbolos gráficos en el diagrama del programa. Los símbolos gráficos LD se organizan dentro del diagrama del mismo modo que en un diagrama de contactos eléctricos. Un diagrama LD está conectado en sus laterales izquierdo y derecho con carriles de potencia verticales.

Carriles de potencia y líneas de conexión

Conexiones múltiples

Contactos y bobinas básicos del lenguaje LD

Sentencia RETURN

Saltos y etiquetas

Bloques en LD

Estos son los componentes gráficos básicos de un diagrama LD:

Carril de potencia vertical izquierdo

Carril de potencia vertical derecho

Línea de conexión horizontal

Línea de conexión vertical

Líneas de conexión múltiples (todas interconectadas)

Contacto asociado a una variable

Bobina asociada a una salida o a una variable interna


Carriles de potencia y líneas de conexión

Un diagrama LD está delimitado en sus laterales izquierdo y derecho por unas líneas verticales, denominadas carril de potencia izquierdo y carril de potencia derecho, respectivamente.

Los símbolos gráficos de los diagramas LD están conectados a carriles de potencia o a otros símbolos por medio de líneas de conexión. Las líneas de conexión pueden ser horizontales o verticales.

Cada segmento de línea tiene un estado booleano FALSO o VERDADERO. El estado booleano es el mismo para todos los segmentos que estén conectados directamente entre sí. Cualquier línea horizontal que esté conectada al carril de potencia izquierdo tiene el estado VERDADERO.


Conexiones múltiples

El estado booleano que se atribuye a una única línea de conexión horizontal es el mismo que en las extremidades izquierda y derecha de la línea. La combinación de líneas de conexión horizontales y verticales permite la construcción de conexiones múltiples. El estado booleano de las extremidades de una conexión múltiple obedece una reglas lógicas.

Una conexión múltiple a la izquierda combina más de una línea horizontal conectada en el lateral izquierdo de una línea vertical, y una línea conectada en su lateral derecho. El estado booleano de la extremidad derecha es la 'O' (OR) LÓGICA entre todas las extremidades de la izquierda.

(* Ejemplo de conexión múltiple a la IZQUIERDA *)

(* estado de extremidad derecha es (v1 OR v2 OR v3) *)

Una conexión múltiple a la derecha combina una línea horizontal conectada al lateral izquierdo de una línea vertical, con más de una línea conectada a su lateral derecho. El estado booleano de la extremidad izquierda se propaga a cada una de las extremidades derechas.

(* Ejemplo de una conexión múltiple a la DERECHA *)

(* Equivalencia ST: *)

output1 := input1;

output2 := input1;

Una conexión múltiple a la derecha y a la izquierda combina más de una línea horizontal conectada al lateral izquierdo de una línea vertical, y más de una línea conectada a su lateral derecho. El estado booleano de cada una de sus extremidades de la derecha es el 'OR' LÓGICO del conjunto de extremidades de la izquierda.

(* Ejemplo de conexión múltiple IZQUIERDA y DERECHA *)

(* Equivalencia ST: *)

output1 := input1 OR input2;

output2 := input1 OR input2;

output3 := input1 OR input2;


Contactos y bobinas básicos del lenguaje LD

Se dispone de diversos símbolos para los contactos de entrada :

Contacto directo

Contacto invertido

Contactos con detección de flancos de subida

Contactos con detección de flancos de bajada

Se dispone de diversos símbolos para las bobinas de salida :

Bobina directa

Bobina invertida

Bobina SET

Bobina RESET

Bobinas con detección de flancos de subida

Bobinas con detección de flancos de bajada

El nombre de la variable se escribe por encima de cualquiera de estos símbolos gráficos:


Contacto directo

A Un contacto directo permite llevar a cabo una operación booleana entre un estado de línea de conexión y una variable booleana.

El estado de la línea de conexión situada a la derecha del contacto es el 'Y' (AND) LÓGICO entre el estado de la línea de conexión izquierda y el valor de la variable asociada al contacto.

(* Ejemplo utilizando contactos DIRECTOS *)

(* Equivalencia ST: *)

output1 := input1 AND input2;


Contacto invertido

Un contacto invertido permite llevar a cabo una operación booleana entre un estado de línea de conexión y la negación booleana de una variable booleana.

El estado de la línea de conexión situada a la derecha del contacto es la 'Y' (AND) LÓGICO entre el estado de la línea de conexión izquierda y la negación booleana del valor de la variable asociada al contacto.

(* Ejemplo utilizando contactos INVERTIDOS *)

(* Equivalencia ST: *)

output1 := NOT (input1) AND NOT (input2);


Contacto con detección de flancos de subida

Este contacto (positivo) permite llevar a cabo una operación booleana entre el estado de una línea de conexión y el flanco de subida de una variable booleana.

El estado de la línea de conexión situada a la derecha del contacto pasa a VERDADERO cuando el estado de la línea de conexión de la izquierda es VERDADERO, y el estado de la variable asociada se eleva de FALSO a VERDADERO. Se repone en FALSO en cualquier otro caso.

(* Ejemplo utilizando contactos de FLANCO DE SUBIDA *)

(* Equivalencia ST: *)

output1 := input1 AND (input2 AND NOT (input2prev));

(* input2prev es el valor de input2 del ciclo anterior *)


Contacto con detección de flanco de bajada

Este contacto (negativo) permite llevar a cabo una operación booleana entre un estado de línea de conexión y el flanco de bajada de una variable booleana.

El estado de la línea de conexión situada a la derecha del contacto pasa a VERDADERO cuando el estado de la línea de conexión de la izquierda es VERDADERO, y el estado de la variable asociada desciende de VERDADERO a FALSO. Se repone a FALSO en cualquier otro caso.

(* Ejemplo utilizando contactos de FLANCO DE BAJADA *)

(* Equivalencia ST: *)

output1 := input1 AND (NOT (input2) AND input2prev);

(*input2prev es el valor de iniput2 del ciclo anterior *)


Bobina directa

Las bobinas directas permiten la salida booleana del estado booleano de una línea de conexión.

La variable asociada se asigna al estado booleano de la conexión izquierda. El estado de la conexión izquierda se propaga hacia la conexión derecha. La conexión derecha puede conectarse al carril de potencia vertical de la derecha.

La variable booleana asociada tiene que ser de SALIDA o INTERNA.

El nombre asociado puede ser el nombre del programa (sólo en el caso de subprogramas). Esto corresponde a la asignación del valor de retorno del subprograma.

(* Ejemplo utilizando bobinas DIRECTAS *)

(* Equivalencia ST: *)

output1 := input1;

output2 := input1;


Bobina invertida

Las bobinas invertidas permiten una salida booleana de acuerdo con la negación booleana de un estado de línea de conexión.

La variable asociada se asigna a la negación booleana del estado de la conexión izquierda. El estado de la conexión izquierda se propaga hacia la conexión derecha. La conexión derecha puede conectarse al carril de potencia vertical de la derecha.

La variable booleana asociada tiene que ser de SALIDA o INTERNA.

El nombre asociado puede ser el nombre del programa (sólo en el caso de subprogramas). Esto corresponde a la asignación del valor de retorno del subprograma.

(* Ejemplo utilizando bobinas INVERTIDAS *)

(* Equivalencia ST: *)

output1 := NOT (input1);

output2 := input1;


Bobina SET (Establecer)

Las bobinas SET permiten la salida booleana del estado booleano de una línea de conexión.

La variable asociada PASA A VERDADERO cuando el estado booleano de la conexión izquierda se convierte en VERDADERO. La variable de salida mantiene este valor hasta que una bobina de "RESET" emite una orden inversa. El estado de la conexión izquierda se propaga hacia la conexión derecha. La conexión derecha puede conectarse al carril de potencia vertical de la derecha.

La variable booleana asociada tiene que ser de SALIDA o INTERNA.

(* Ejemplo utilizando bobinas de "SET" y "RESET" *)

(* Equivalencia ST: *)

IF input1 THEN

   output1 := VERDADERO;

END_IF;

IF input2 THEN

   output1 := FALSO;

END_IF


Bobinas RESET (Restablecer)

Las bobinas RESET permiten la salida booleana del estado booleano de una línea de conexión.

La variable asociada PASA A FALSO cuando el estado booleano de la conexión izquierda se convierte en VERDADERO. La variable de salida mantiene este valor hasta que una bobina de SET emite una orden inversa. El estado de la conexión izquierda se propaga hacia la conexión derecha. La conexión derecha puede conectarse al carril de potencia vertical de la derecha.

La variable booleana asociada tiene que ser de SALIDA o INTERNA.

(* Ejemplo utilizando bobinas de "SET" y "RESET" *)

(* Equivalencia ST: *)

IF input1 THEN

   output1 := VERDADERO;

END_IF;

IF input2 THEN

   output1 := FALSO;

END_IF;


Bobina con detección de flancos de subida

Las bobinas "Positivas" permiten la salida booleana del estado booleano de una línea de conexión. Este tipo de bucle sólo está disponible cuando se utiliza el editor Quick Ladder.

La variable asociada PASA A VERDADERO cuando el estado booleano de la conexión izquierda se eleva de FALSO a VERDADERO. La variable de salida se reinicia en FALSO en cualquier otro caso. El estado de la conexión izquierda se propaga hacia la conexión derecha. La conexión derecha puede conectarse al carril de potencia vertical de la derecha.

La variable booleana asociada tiene que ser de SALIDA o INTERNA.

(* Ejemplo utilizando una bobina "Positiva" *)

IF (input1 and NOT(input1prev)) THEN

   output1 := VERDADERO;

ELSE

   output1 := FALSO;

END_IF;

(* input1prev es el valor de input1 en el ciclo anterior *)


Bobina con detección de flanco de bajada

Las bobinas "Negativas" permiten la salida booleana del estado booleano de una línea de conexión. Este tipo de bucle sólo está disponible cuando se utiliza el editor Quick Ladder.

La variable asociada PASA A VERDADERO cuando el estado booleano de la conexión izquierda desciende de VERDADERO a FALSO. La variable de salida se reinicia en FALSO en cualquier otro caso. El estado de la conexión izquierda se propaga hacia la conexión derecha. La conexión derecha puede conectarse al carril de potencia vertical de la derecha.

La variable booleana asociada tiene que ser de SALIDA o INTERNA.

(* Ejemplo utilizando una bobina "Negativa" *)

(* Equivalencia ST: *)

IF (NOT(input1) and input1prev) THEN

   output1 := VERDADERO;

ELSE

   output1 := FALSO;

END_IF;

(* input1prev es el valor de input1 en el ciclo anterior *)


Sentencia RETURN

Se puede utilizar la etiqueta RETURN, como salida para representar un final condicional del programa. No se puede colocar conexión alguna a la derecha de un símbolo de RETURN.

Si la línea de conexión izquierda muestra un estado booleano VERDADERO, el programa finaliza sin ejecutar las ecuaciones que aparecen en las siguientes líneas del diagrama.

Nota: Cuando el programa LD es un subprograma, su nombre tiene que estar asociado con una bobina de salida para poder establecer el valor de retorno (retorno al programa invocante).

(* Ejemplo utilizando el símbolo de RETURN *)

(* Equivalencia ST: *)

If Not (manual_mode) Then RETURN; End_if;

result := (input1 OR input3) AND input2;


Saltos y etiquetas

Pueden emplearse etiquetas y símbolos de SALTOS condicionales e incondicionales para controlar la ejecución del diagrama. No se puede colocar conexión alguna a la derecha del símbolo de etiqueta y salto. Se utilizan las siguientes notaciones:

>>LAB	saltar a la etiqueta llamada "LAB"

LAB:	definición de la etiqueta llamada "LAB"

Si la conexión situada a la izquierda del símbolo de salto tiene el estado booleano VERDADERO, se lanzará la ejecución del programa después del símbolo de etiqueta.

(* Ejemplo utilizando los símbolos de SALTO y ETIQUETA *)

(* Equivalencia IL: *)

ldn	manual_mode

jmpc	other

ld	input1

st	result

jmp	END

OTHER:	ld	input2

st	result

END:	(* fin del programa *)


Bloques en LD

Utilizando el editor Quick LD, se pueden conectar cajas de funciones a líneas booleanas. Una función puede ser en realidad un operador, un bloque de función o una función. Ya que todos los bloques no siempre tienen una entrada booleana y/o una salida booleana, la inserción de bloques en un diagrama LD conduce a la incorporación de nuevos parámetros EN, ENO a la interfaz del bloque. No se añaden los parámetros EN, ENO si se utiliza el editor FBD/LD, ya que se puede conectar la variable con el tipo necesario.

La entrada "EN"

La salida "ENO"

Los parámetros "EN" y "ENO"


La entrada "EN"

En algunos operadores, funciones o bloques de función, la primera entrada no incluye datos de tipo booleano. Dado que la primera entrada tiene que estar siempre conectada al escalón (línea), se inserta otra entrada, denominada "EN", en la primera posición de forma automática. El bloque sólo se ejecuta si la entrada EN es VERDADERA. A continuación se muestra el ejemplo de un operador de comparación, junto con el código equivalente expresado en ST:

	IF rung_state THEN    q := (value1 > value 2); ELSE    q := FALSO; END_IF; (* continúa el escalón con el estado q *)


La salida "ENO"

En algunos operadores, funciones o bloques de función, la primera entrada no incluye datos del tipo booleano. Dado que la primera salida tiene que estar conectada siempre al escalón (línea), se inserta otra salida, denominada "ENO", en la primera posición de forma automática. La salida ENO siempre asume el mismo estado que la primera entrada del bloque. A continuación se muestra un ejemplo con el bloque de función AVERAGE, o PROMEDIO, con el código equivalente expresado en ST:

	AVERAGE(rung_state, Signal, 100); OutSignal := AVERAGE.XOUT; eno := rung_state; (* continúa el escalón con estado eno *)


Los parámetros "EN" y "ENO"

En algunos casos, se necesitan tanto EN como ENO. A continuación se muestra un ejemplo que incluye un operador aritmético, con el código equivalente expresado en ST:

	IF rung_state THEN    result := (value1 + value2); END_IF; eno := rung_state; (* continue rung with eno state *)


 Lenguaje FC

El Diagrama de flujo (FC) es un lenguaje gráfico que se utiliza para describir operaciones secuenciales. Un diagrama de flujo FC está compuesto por acciones y decisiones. Entre las acciones y decisiones hay vínculos orientados representando flujo de datos. Los vínculos de conexión múltiple se usan para representar divergencias y convergencias. Se pueden describir Acciones y decisiones con los lenguajes ST, LD o IL. Se pueden llamar a funciones y a bloques de función de cualquier lenguaje (excepto SFC) desde acciones y decisiones. Un programa diagrama de flujo puede llamar a otro programa diagrama de flujo, El programa FC llamado es un subprograma del programa FC que lo llama.

Componentes básicos FC

Ejemplos de estructuras complejas

Comportamiento FC dinámico

Comprobación FC


Componentes FC

A continuación están los componentes gráficos del lenguaje de diagrama de flujo

Inicio del diagrama FC

Fin del diagrama FC

Enlaces de flujo FC

Acciones FC

Condiciones FC

Subprograma FC

Especificación E/S FC

Conectores FC

Ramas paralelas FC

Comentarios FC


Inicio del diagrama FC

Un símbolo de "Inicio"  debe aparecer al comienzo del programa de diagrama de flujo. Es único y no se puede omitir, representa el estado inicial del diagrama cuando está activado. A continuación está el dibujo de un símbolo de "Inicio":

El símbolo de "Inicio" siempre tiene una conexión (por debajo) con los otros objetos del diagrama. Un diagrama de flujo no es valido si no hay ninguna conexión dibujada de "Inicio" a otro objeto.


Fin del diagrama FC

Un símbolo de "Fin"  debe aparecer al final del programa en diagrama de flujo. Es único y no se puede omitir, Es posible que no haya ninguna conexión dibujada al símbolo de fin (diagrama de bucle infinito), pero el símbolo de "Fin" debe aparecer en cualquier caso dibujado en la parte inferior del diagrama. Representa el estado final del diagrama cuando su ejecución se ha completado. A continuación está el símbolo de "Fin":

El símbolo de "Fin" tiene normalmente una conexión por arriba a otros objetos del diagrama. Un diagrama de flujo puede no tener conexión a un objeto "Fin" (diagrama de bucle infinito). El símbolo de "Fin" debe ser aún visible en la parte inferior del diagrama en este caso.


Enlaces de flujo FC

Un enlace de flujo es una línea que representa un flujo entre dos puntos del diagrama. Un enlace siempre termina en una flecha. A continuación está el dibujo de un enlace de flujo:

Dos enlaces no pueden estar conectados al mismo punto fuente de conexión.


Acciones FC

Un símbolo de acción FC representa las acciones a realizar. Una acción está identificada por un número y un nombre. Debajo está el dibujo de un símbolo de "acción":

Dos objetos diferentes del mismo diagrama no pueden tener el mismo nombre o número lógico. El lenguaje de programación para una acción puede ser ST, LD o IL. Una acción está siempre conectada con enlaces, uno llegando a ella, otro saliendo de ella.


Condiciones FC

Una Condición representa una decisión booleana . Una condición está identificada por un número y un nombre.

Según la evaluación de la correspondiente expresión en ST, LD o IL, el flujo se dirige por el camino de "SÍ" o "NO". Debajo están los posible dibujos para un símbolo de condición:

Dos objetos diferentes del mismo diagrama no pueden tener el mismo nombre o número lógico. La programación de una decisión es bien

- una expresión en ST, o

- un único contacto en LD, sin ningún símbolo para su única bobina, o

- diversas instrucciones en IL. El registro IL (o resultado actual) se usa para evaluar la condición.

Cuando se programa en texto ST la expresión puede ser opcionalmente seguida por un punto y coma. Cuando se programa en LD, la bobina única representa el estado de la condición. Una condición es igual:

- 0 o FALSO dirige el flujo hacia NO

- 1 o VERDADERO dirige el flujo hacia SÍ

Una condición está siempre conectada con un enlace de llegada y deben definirse las dos condiciones de salida.


Subprograma FC

El sistema permite la descripción de la estructura vertical de los programas FC. Los programas FC están organizados según un árbol jerárquico. Cada programa FC puede llamar a otros programas FC. Este programa se llama programa hijo del programa FC que lo llama. Los programas FC que llaman a subprogramas FC se llaman programas padre. Los programas FC se unen juntos a un árbol jerárquico principal usando una relación padre-hijo.

Un símbolo de subprograma  en un diagrama de flujo representa una llamada a un subprograma diagrama de flujo. La ejecución del programa padre está suspendida hasta que el subprograma termine de ejecutarse. Un subprograma diagrama de flujo se identifica con un numero y un nombre, como otros programas, funciones o bloques de función. Debajo está el dibujo de un símbolo de "llamada a subprograma":

Dos objetos diferentes del mismo diagrama no pueden tener el mismo nombre o mismo número lógico. Las reglas básicas que implica la estructura jerárquica FC son:

- Programas FC que no tienen padre se llaman programas FC principales.

- Programas FC principales se activan por el sistema cuando empieza la aplicación

- Un programa puede tener varios programas hijos

- Un programa hijo no puede tener más que un padre

- Un programa hijo sólo puede ser llamado por su padre

- Un programa no puede llamar al hijo de uno de sus hijos

El mismo programa puede aparecer varias veces en diagrama del padre. No puede aparecer en ramas diferentes de las misma divergencia paralela. Una llamada a un subprograma en diagrama de flujo representa la ejecución completa del subdiagrama. La ejecución del padre está suspendida durante la actuación del subdiagrama. Los bloques de llamada del subprograma deben seguir las mismas reglas de conexión como los definidos para Acciones.


Acción específica de E/S FC

Un símbolo de una acción específica de E/S FC  representa las acciones a ser realizadas. Como otras acciones, una acción de E/S específica se identifica por un número y un nombre. La misma semántica se utiliza en las acciones standard y especificaciones de E/S. El objetivo de una acción específica de E/S es sólo hacer el diagrama más legible y centrarse en las partes no portables del diagrama. Usar las acciones especificas es una característica opcional. Debajo está el diagrama de un símbolo de "acción específica de E/S:

Los bloques específicos de E/S tienen el mismo comportamiento que las acciones standard. Esto afecta a sus propiedades, a la programación ST, LD o IL, y a las reglas de conexión.


Conectores FC

Los conectores se utilizan para representar un enlace entre dos puntos del diagrama sin dibujarlo. Un conector se representa por un círculo y se conecta a la fuente de flujo. El dibujo del conector se completa, en el lado apropiado (dependiendo de la dirección del flujo de datos), por la identificación del punto de destino (generalmente el nombre del  símbolo objeto). Debajo está el dibujo standard de un conector:

Un conector siempre se dirige a un símbolo definido del diagrama de flujo. El símbolo de destino se identifica por un número lógico. El objetivo de un conector puede ser también el número lógico (etiqueta) de una divergencia paralela.


Ramas paralelas FC

Las ramas paralelas representan ejecución simultánea de subdiagramas. El sistema de "divergencia / convergencia" se identifica por un número lógico((etiqueta). Cada subprograma tiene un único "inicio" de flujo y un único "Fin" de flujo. Las ramas paralelas comienzan en un símbolo de "divergencia", y terminan en un símbolo de "convergencia". Las líneas horizontales dobles se utilizan para representar convergencias y divergencias:

El número lógico (etiqueta) de una rama paralela puede ser utilizado como objetivo de un conector. El número lógico es el mismo para la divergencia y la convergencia del mismo sistema paralelo. No puede utilizarse para otros símbolos en el diagrama.


Comentarios FC

Un bloque de comentario contiene texto que no tiene sentido para la semántica del diagrama. Se puede insertar en cualquier lugar del espacio no usado de la ventana documento del diagrama de flujo y se utiliza para documentar el programa. Debajo está el dibujo del símbolo de "comentario" :


Ejemplos de estructuras complejas FC

Esta sección muestra ejemplos de estructuras complejas  que pueden definirse en un diagrama de flujo. Dichas estructuras son combinaciones de objetos básicos enlazados.

	IF / THEN / ELSE (1) lugar para  acciones "THEN" que se inserten (2) lugar para acciones "ELSE" que se inserten
	REPEAT / UNTIL (3) lugar para acciones repetidas a ser insertadas
	WHILE / DO (4) lugar para acciones repetidas a ser insertadas


Comportamiento dinámico FC

La ejecución de un programa en diagrama de flujo se puede explicar como sigue:

- El símbolo de Inicio lleva un ciclo del sistema

- El símbolo de Fin lleva un ciclo del sistema y termina la ejecución del programa. Después de que se alcanza este símbolo no se ejecuta ninguna acción más sobre el diagrama.

- El flujo se rompe cada vez que se encuentra un ítem (acción, decisión) que ya ha sido alcanzado en el mismo ciclo del sistema. En este caso, el flujo continuará en el próximo ciclo.

Nota: Contrariamente a SFC, una acción no es un estado estable. No hay repetición de instrucciones mientras el símbolo de acción está destacado.


Verificación FC

Aparte de la programación unida a ST, LD o IL, otras reglas sintácticas  se aplican al propio diagrama de flujo. Debajo está la lista de las reglas principales:

- Todos los puntos de "conexión" deben de estar unidos. (la conexión al símbolo de "Fin" puede omitirse)

- Todos los símbolos deben de estar unidos (no debe aparecer ninguna parte aislada)

- Todos los conectores deben tener un destino valido

- Un símbolo en una rama paralela no puede estar unido a otros símbolos fuera de la rama (cada rama debe de estar conectada)

- El mismo subprograma no puede ser llamado desde diferentes ramas paralelas en la misma divergencia

Se presentan otros errores sintácticos menores:

- Se ignoran las ramas vacías en una divergencia

- Una divergencia con sólo una rama llena no es una divergencia

- Las acciones vacías (sin programación) se consideran como pasos durante el tiempo programado de ejecución

- las decisiones vacías (sin programación) se consideran como "siempre verdad"


 Operadores, bloques de función y funciones estándares

Operadores estándares

Bloques de función estándares

Funciones estándares

Indice alfabético


Operadores estándares

A continuación se exponen los operadores estándares de los lenguajes IEC.

Manejo de datos:

1 gain	Asignación

Neg	Negación analógica

Operaciones booleanas:

& (AND)	AND booleana

>=1 (OR)	OR booleana

=1 (XOR)	OR exclusiva booleana

Operaciones aritméticas:

 + 	Suma

 - 	Resta

 * 	Multiplicación

 / 	División

Operaciones lógicas:

AND_MASK	Máscara analógica bit-a-bit AND

OR_MASK	Máscara analógica bit-a-bit OR

XOR_MASK	Máscara analógica bit-a-bit OR exclusiva

NOT_MASK	Negación bit-a-bit

Pruebas comparativas:

 < 	Menor que

 <= 	Menor o igual que

 > 	Mayor que

 >= 	Mayor o igual que

 = 	Es igual a

 <> 	No es igual a

Conversión de datos:

BOO	Convertir a Booleano

ANA	Convertir a Analógico Entero

REAL	Convertir a Analógico Real

TMR	Convertir a Temporizador

MSG	Convertir a Mensaje

Otros:

CAT	Concatenación de mensajes

SYSTEM	Acceso al sistema

OPERATE	Operar canal E/S


1 gain

Argumentos:

IN	cualquier tipo

Q	cualquier tipo

Descripción:

Asignación de una variable a otra

Este bloque resulta muy útil para crear un vínculo directo entre una entrada de diagrama y una salida de diagrama. También se puede utilizar (con una línea de negación booleana) para invertir el estado de una línea que esté conectada a una salida de diagrama.

(* Ejemplo FBD con Bloques de Asignación *)

(* Equivalencia ST: *)

ao23 := ai10;

bo100 := NOT (bi1 Y bi2);

(* Equivalencia IL: *)

LD	ai10

ST 	ao23

LD	bi1

Y	bi2

STN	bo100


NEG

Argumentos:

IN	INT-REAL	entrada y salida tienen que tener el mismo formato

Q	INT-REAL

Descripción:

Asignación de la negación de una variable.

(* Ejemplo FBD con Bloques de Negación *)

(* Equivalencia ST: *)

ao23 := - (ai10);

ro100 := - (ri1 + ri2);

(* Equivalencia IL: *)

LD	ai10

MUL	-1

ST 	ao23

LD	ri1

ADD	ri2

MUL	-1.0

ST	ro100


& AND

Nota: Para este operador, el número de entradas puede extenderse a más de dos.

Argumentos:

(entradas)	BOOLEANO

salida	BOOLEANO	AND booleana de los términos de entrada

Descripción:

AND booleana entre dos o más términos.

(* Ejemplo FBD con Bloques “AND” *)

(* Equivalencia ST: *)

bo10 := bi101 AND NOT (bi102);

bo5 := (bi51 AND bi52) Y bi53;

(* Equivalencia IL *)

LD	bi101	(* resultado actual := bi101 *)

ANDN	bi102	(* resultado actual := bi101 AND not(bi102) *)

ST	bo10	(* bo10 := resultado actual *)

LD	bi51	(* resultado actual := bi51;

&	bi52	(* resultado actual := bi51 AND bi52 *)

&	bi53	(* resultado actual := (bi51 AND bi52) AND bi53 *)

ST	bo5	(* bo5 := resultado actual *)

>=1 OR

Nota: Para este operador, el número de entradas puede extenderse a más de dos.

Argumentos:

(entradas)	BOOLEANO

salida	BOOLEANO	OR booleana de los términos de entrada

Descripción:

OR booleana de dos o más términos.

(* Ejemplo FBD con Bloques “OR” *)

(* Equivalencia ST: *)

bo10 := bi101 OR NOT (bi102);

bo5 := (bi51 OR bi52) OR bi53;

(* Equivalencia IL: *)

LD	bi101

ORN	bi102

ST	bo10

LD	bi51

OR	bi52

OR	bi53

ST	bo5


=1 XOR

Argumentos:

IN1	BOOLEANO

IN2	BOOLEANO

Q	BOOLEANO	OR exclusiva booleana de los 2 términos de entrada

Descripción:

OR exclusiva booleana entre dos términos.

(* Ejemplo FBD con Bloques “XOR” *)

(* Equivalencia ST: *)

bo10 := bi101 XOR NOT (bi102);

bo5 := (bi51 XOR bi52) XOR bi53;

(* Equivalencia IL: *)

LD	bi101

XORN	bi102

ST	bo10

LD	bi51

XOR	bi52

XOR	bi53

ST	bo5


+
+ (Suma)

Nota: Para este operador, el número de entradas puede extenderse a más de dos.

Argumentos:

(entradas)	INT-REAL	puede ser ENTERO o REAL

(todas las entradas tienen que tener el mismo formato)

salida	INT-REAL	suma con signo de los términos de entrada

Descripción:

Adición de dos o más variables analógicas.

(* Ejemplo FBD con Bloques de Suma *)

(* Equivalencia ST: *)

ao10 := ai101 + ai102;

ao5 := (ai51 + ai52) + ai53;

(* Equivalencia IL: *)

LD	ai101

ADD	ai102

ST	ao10

LD	ai51

ADD	ai52

ADD	ai53

ST	ao5


-
- (Resta)

Argumentos:

IN1	INT-REAL	puede ser ENTERO o REAL

IN2	INT-REAL	(IN1 y IN2 tienen que tener el mismo formato)

Q	INT-REAL	resta (primera - segunda)

Descripción:

Resta de dos variables analógicas (primera - segunda).

(* Ejemplo FBD con Bloques de Resta *)

(* Equivalencia ST: *)

ao10 := ai101 - ai102;

ao5 := (ai51 - 1) - ai53;

(* Equivalencia IL: *)

LD	ai101

SUB	ai102

ST	ao10

LD	ai51

SUB	1

SUB	ai53

ST	ao5


*
* (Multiplicación)

Nota: Para este operador, el número de entradas puede extenderse a más de dos.

Argumentos:

(entradas)	INT-REAL	puede ser ENTERO o REAL

(todas las entradas tienen que tener el mismo formato)

salida	INT-REAL	multiplicación con signo de los términos de entrada

Descripción:

Multiplicación de dos o más variables analógicas.

(* Ejemplo FBD con Bloques de Multiplicación *)

(* Equivalencia ST *)

ao10 := ai101 * ai102;

ao5 := (ai51 * ai52) * ai53;

(* Equivalencia IL: *)

LD	ai101

MUL	ai102

ST	ao10

LD	ai51

MUL	ai52

MUL	ai53

ST	ao5


/
/ (División)

Argumentos:

IN1	INT-REAL	puede ser ENTERO o REAL (operando)

IN2	INT-REAL	valor analógico distinto de cero (divisor)

(IN1 y IN2 tienen que tener el mismo formato)

Q	INT-REAL	valor entero con signo o división real de IN1 por IN2

Descripción:

División de dos variables analógicas (la primera dividida por la segunda).

(* Ejemplo FBD con Bloques de División *)

(* Equivalencia ST: *)

ao10 := ai101 / ai102;

ao5 := (ai5 / 2) / ai53;

(* Equivalencia IL: *)

LD	ai101

DIV	ai102

ST	ao10

LD	ai51

DIV	2

DIV	ai53

ST	ao5


AND_MASK

Argumentos:

IN	INT	tiene que tener formato entero

MSK	INT	tiene que tener formato entero

Q	INT	AND lógico bit-a-bit entre IN y MSK

Descripción:

 Analógico entero AND máscara bit a bit.

(* Ejemplo FBD con Bloques Analógicos AND_MASK *)

(* Equivalencia ST: *)

parity := AND_MASK (xvalue, 1); (* 1 si xvalue es impar *)

result := AND_MASK (16#abc, 16#f0f); (* igual a 16#a0c *)

(* Equivalencia IL: *)

LD	xvalue

AND_MASK	1

ST	parity

LD	16#abc

AND_MASK	16#f0f

ST	result


OR_MASK

Argumentos:

IN	INT	tiene que tener formato entero

MSK	INT	tiene que tener formato entero

Q	INT	OR lógico de bit a bit entre 'IN' y 'MSK'

Descripción:

Analógico entero OR máscara bit a bit.

(* Ejemplo FBD con Bloques Analógicos OR_MASK *)

(* Equivalencia ST: *)

is_odd := OR_MASK (xvalue, 1); (* hace el valor siempre impar *)

result := OR_MASK (16#abc, 16#f0f); (* igual a 16#fbf *)

(* Equivalencia IL: *)

LD	xvalue

OR_MASK	1

ST	is_odd

LD	16#abc

OR_MASK	16#f0f

ST	result


XOR_MASK

Argumentos:

IN	INT	tiene que tener formato entero

MSK	INT	tiene que tener formato entero

Q	INT	OR exclusivo lógico de bit a bit entre 'IN' y 'MSK'

Descripción:

Analógico entero XOR máscara bit a bit.

(* Ejemplo FBD con Bloques XOR_MASK *)

(* Equivalencia ST: *)

crc32 := XOR_MASK (prevcrc, nextc);

resultado := XOR_MASK (16#012, 16#011); (* igual a 16#003 *)

(* Equivalencia IL: *)

LD	prevcrc

XOR_MASK	nextc

ST	crc32

LD	16#012

XOR_MASK	16#011

ST	resultado


NOT_MASK

Argumentos :

IN	INT	tiene que tener formato entero

Q	INT	negación de bit a bit en 32 bits de 'IN'

Descripción:

Máscara de negación bit a bit de analógico entero.

(* Ejemplo FBD con Bloques NOT_MASK *)

(* Equivalencia ST: *)

result := NOT_MASK (16#1234);

(* el resultado es 16#FFFF_EDCB *)

(* Equivalencia IL: *)

LD	16#1234

NOT_MASK

ST	result


<
< (Menor que)

Argumentos:

IN1	INT-REAL-

TMR-MSG

IN2	INT-REAL-

TMR-MSG	ambas entradas tienen que tener el mismo tipo

Q	BOOLEANO	VERDADERO si IN1 < IN2

Descripción:

Comprueba si un valor es MENOR QUE otro valor (para analógicos, temporizadores o mensajes)

(* Ejemplo FBD con Bloques de “Menor que” *)

(* Equivalencia ST: *)

aresult := (10 < 25); (* aresult es VERDADERO *)

mresult := ('z' < 'B'); (* mresult es FALSO*)

(* Equivalencia IL: *)

LD	10

LT	25

ST	aresult

LD	'z'

LT	'B'

ST	mresult


<=
<= (Menor o igual que)

Argumentos:

IN1	INT-REAL-MSG

IN2	INT-REAL-MSG	ambas entradas tienen que tener el mismo tipo

Q	BOOLEANO	VERDADERO si IN1 <= IN2

Descripción:

Comprueba si un valor es MENOR O IGUAL A otro valor (para analógicos, o mensajes)

(* Ejemplo FBD con Bloques de “Menor o igual a” *)

(* Equivalencia ST: *)

aresult := (10 <= 25); (* aresult es VERDADERO *)

mresult := ('ab' <= 'ab'); (* mresult es VERDADERO *)

(* Equivalencia IL: *)

LD	10

LE	25

ST	aresult

LD	'ab'

LE	'ab'

ST	mresult


>
> (Mayor que)

Argumentos:

IN1	INT-REAL-

TMR-MSG

IN2	INT-REAL-

TMR-MSG 	ambas entradas tienen que tener el mismo tipo

Q	BOOLEANO	VERDADERO si IN1 > IN2

Descripción:

Comprueba si un valor es MAYOR QUE otro valor (para analógicos, temporizadores o mensajes)

(* Ejemplo FBD con Bloques de “Mayor que” *)

(* Equivalencia ST: *)

aresult := (10 > 25); (* aresult es FALSO *)

mresult := ('ab' > 'a'); (* mresult es VERDADERO *)

(* Equivalencia IL: *)

LD	10

GT	25

ST	aresult

LD	'ab'

GT	'a'

ST	mresult


>=
>= (Mayor o igual que)

Argumentos:

IN1	INT-REAL-MSG

IN2	INT-REAL-MSG 	ambas entradas tienen que tener el mismo tipo

Q	BOOLEANO	VERDADERO si IN1 >= IN2

Descripción:

Comprueba si un valor es SUPERIOR O IGUAL A otro valor (para analógicos o mensajes)

(* Ejemplo FBD con bloques de “Mayor o igual que” *)

(* Equivalencia ST: *)

aresult := (10 >= 25); (* aresult es FALSO *)

mresult := ('ab' >= 'ab'); (* mresult es VERDADERO *)

(* Equivalencia IL: *)

LD	10

GE	25

ST	aresult

LD	'ab'

GE	'ab'

ST	mresult


=
= (Igual a)

Argumentos:

IN1	INT-REAL-MSG

IN2	INT-REAL-MSG 	ambas entradas tienen que tener el mismo tipo

Q	BOOLEANO	VERDADERO si IN1 = IN2

Descripción:

Comprueba si un valor es IGUAL A otro valor (para analógicos o mensajes)

(* Ejemplo FBD con Bloques “Igual a” *)

(* Equivalencia ST: *)

aresult := (10 = 25); (* aresult es FALSO *)

mresult := ('ab' = 'ab'); (* mresult es VERDADERO *)

(* Equivalencia IL: *)

LD	10

EQ	25

ST	aresult

LD	'ab'

EQ	'ab'

ST	mresult


<>
<> (No es igual a)

Argumentos:

IN1	INT-REAL-MSG

IN2	INT-REAL-MSG 	ambas entradas tienen que tener el mismo tipo

Q	BOOLEANO	VERDADERO si primera <> segunda

Descripción:

Comprueba si un valor NO ES IGUAL A otro valor (para analógicos o mensajes)

(* Ejemplo FBD con Bloques de “No es Igual a” *)

(* Equivalencia ST: *)

aresult := (10 <> 25); (* aresult es VERDADERO *)

mresult := ('ab' <> 'ab'); (* mresult es FALSO *)

(* Equivalencia IL: *)

LD	10

NE	25

ST	aresult

LD	'ab'

NE	'ab'

ST	mresult


BOO

Argumentos:

IN	ANY	cualquier valor no booleano

Q	BOO	VERDADERO para valores numéricos distintos a cero

FALSO para valores numéricos cero

VERDADERO para mensaje 'VERDADERO'

FALSO para mensaje 'FALSO'

Descripción:

Convierte cualquier variable a una variable booleana

(* Ejemplo FBD con Bloques de “Convertir a Booleana” *)

(* Equivalencia ST: *)

ares := BOO (10);	(* ares es VERDADERO *)

tres := BOO (t#0s);	(* tres es FALSO *)

mres := BOO ('FALSO');	(* mres es FALSO *)

(* Equivalencia IL: *)

LD	10

BOO

ST	ares

LD	t#0s

BOO

ST	tres

LD	'FALSO'

BOO

ST	mres


ANA

Argumentos:

IN	ANY	cualquier valor analógico no entero

Q	INT	0 si IN es FALSO / 1 si IN es VERDADERO

número de milisegundos para un temporizador

parte entera para analógico real

número decimal representado por una cadena

Descripción:

Convierte cualquier variable a una entera

(* Ejemplo FBD con Bloques de “Convertir a Analógico” *)

(* Equivalencia ST: *)

bres := ANA (VERDADERO);	(* bres es 1 *)

tres := ANA (t#1s46ms);	(* tres es 1046 *)

mres := ANA ('0198');	(* mres es 198 *)

(* Equivalencia IL: *)

LD	VERDADERO

ANA

ST	bres

LD	t#1s46ms

ANA

ST	tres

LD	'0198'

ANA

ST	mres


REAL

Argumentos:

IN	BOO-INT-

TMR	cualquier valor analógico no real (excepto mensaje)

Q	REAL	0.0 si IN es FALSO / 1.0 si IN es VERDADERO

número de milisegundos para un temporizador

número equivalente para analógico entero

Descripción:

Convierte cualquier variable a una real

(* Ejemplo FBD con Bloques de “Convertir a Real” *)

(* Equivalencia ST: *)

bres := REAL (VERDADERO);	(* bres es 1.0 *)

tres := REAL (t#1s46ms);	(* tres es 1046.0 *)

ares := REAL (198);	(* ares es 198.0 *)

(* Equivalencia IL: *)

LD	VERDADERO

REAL

ST	bres

LD	t#1s46ms

REAL

ST	tres

LD	198

REAL

ST	ares


TMR

Argumentos:

IN	INT-REAL	cualquier valor excepto temporizador

IN (o parte entera de IN si es real)

es el número de milisegundos

Q	TIMER	valor en tiempo, representado por IN

Descripción:

Convierte cualquier variable analógica en una variable de temporizador

(* Ejemplo FBD con Bloques de “Convertir a Temporizador” *)

(* Equivalencia ST: *)

ares := TMR (1256);	(* ares := t#1s256ms *)

rres := TMR (1256.3);	(* rres := t#1s256ms *)

(* Equivalencia IL: *)

LD	1256

TMR

ST	ares

LD	1256.3

TMR

ST	rres


MSG

Argumentos:

IN	BOO-

INT-REA	cualquier valor excepto mensaje

Q	MSG	'falso' o 'verdadero' si IN es booleano

representación decimal si IN es analógico

Descripción:

Convierte cualquier variable en una de mensaje

(* Ejemplo FBD con Bloques de “Convertir a Mensaje” *)

(* Equivalencia ST: *)

bres := MSG (VERDADERO); (* bres es 'VERDADERO' (VERDADERO) *)

ares := MSG (125); (* ares es '125' *)

(* Equivalencia IL: *)

LD	VERDADERO

MSG

ST	bres

LD	125

MSG

ST	ares


CAT

Nota: Para este operador, el número de entradas puede extenderse a más de dos.

Argumentos:

(entradas)	MSG	(la suma de todas la longitudes de mensajes no debe superar la capacidad del mensaje de salida)

salida	MSG	concatenación de los mensajes de entrada

Descripción:

Concatena varios mensajes en uno solo

(* Ejemplo FBD con Bloques de “Concatenación de Mensajes” *)

(* Equivalencia ST: usar el operador + *)

myname := ('Mr' + ' ') + 'Jones';

(* significa: myname := 'Mr Jones' *)

(* Equivalencia IL: *)

LD	'Mr'

ADD	' '

ADD	'Jones'

ST	myname


SYSTEM

Argumentos:

Mode	INT	identifica el parámetro de sistema y el modo de acceso

Arg	INT-TMR	valor nuevo para un acceso de “escritura”

Param	INT	valor del parámetro al cual se ha accedido

Descripción:

Acceso a los parámetros del sistema

A continuación se expone una relación de los comandos (palabras clave predefinidas) disponibles para la función de SISTEMA:

Comando	Significado
SYS_TALLOWED	leer tiempo de ciclo permitido
SYS_TCURRENT	leer tiempo de ciclo actual
SYS_TMAXIMUM	leer tiempo de ciclo máximo
SYS_TOVERFLOW	leer desbordamientos de tiempo de ciclo
SYS_TRESET	restaurar contadores de tiempo
SYS_TWRITE	cambiar tiempos de ciclo
SYS_ERR_TEST	comprobar errores de tiempo de proceso
SYS_ERR_READ	leer error de tiempo de proceso más antiguo

A continuación se indican los argumentos esperados para las funciones predefinidas de la función de SISTEMA:

Comando	Argumento	Valor de retorno
SYS_TALLOWED	0	tiempo de ciclo permitido
SYS_TCURRENT	0	tiempo de ciclo actual
SYS_TMAXIMUM	0	tiempo máximo detectado
SYS_TOVERFLOW	0	número de desbordamientos de tiempo
SYS_TRESET	0	0
SYS_TWRITE	Nuevo tiempo de ciclo permitido	tiempo escrito
SYS_ERR_TEST	0	0 si no se detectan errores
SYS_ERR_READ	0	código de error más antiguo

(* Ejemplo FBD con Bloques de “Sistema” *)

(* Equivalencia ST: *)

alarm := (SYSTEM (SYS_TOVERFLOW, 0) <> 0);

If (alarm) Then

nb_err := nb_err + 1;

rc := SYSTEM (SYS_TRESET, 0);

End_If


OPERATE

Argumentos:

IO	ANY	variable de entrada o salida

Funct	INT	acción a operar

Arg	INT	argumento para acción de E/S

Q	INT	comprobación retorno

Descripción:

Acceso a un canal de E/S

El significado de los argumentos OPERATE depende de la implementación de la interfaz de E/S. Para conocer en mayor detalle las capacidades OPERATE, véanse el manual del hardware o las correspondientes notas técnicas de la tarjeta de E/S..


Bloques de función estándares

Estos son bloques de función estándares soportados por el sistema ISaGRAF. Dichos bloques están predefinidos y no tienen que ser declarados en la librería.

Booleanos:

SR	Establecer biestable dominante

RS	Restablecer biestable dominante

R_TRIG	Detección de flanco de subida

F_TRIG	Detección de flanco de bajada

SEMA	Semáforo

Contaje:

CTU	Contador ascendente

CTD	Contador descendente

CTUD	Contador ascendente-descendente

Temporizadores:

TON	Temporización con retardo en conexión

TOF	Temporización con retardo en desconexión

TP	Temporización de impulsos

Analógicos enteros:

CMP	Bloque de función de comparación total

STACKINT	Grupo de valores analógicos enteros

Analógicos reales:

AVERAGE	Promedio dinámico basado en N muestras

HYSTER	Histéresis booleana por diferencias entre  reales

LIM_ALRM	Límites superior/inferior de alarma con histéresis

INTEGRAL	Integración a lo largo del tiempo

DERIVATE	Diferenciación según tiempos

Generación de señales:

BLINK	Señal booleana parpadeante

SIG_GEN	Generador de señales

Nota: Cuando se crean nuevos bloques “C”, pueden ser invocados desde el lenguaje FBD.


SR

Argumentos:

SET1	BOO	si VERDADERO, fija Q1 en VERDADERO (dominante)

RESET	BOO	si VERDADERO, restablece Q1 en FALSO

Q1	BOO	estado booleano de memoria

Descripción:

Establece biestable dominante: Véase Tabla de VERDAD a continuación:

SET1	RESET	Q1	resultado Q1
0	0	0	0
0	0	1	1
0	1	0	0
0	1	1	0
1	0	0	1
1	0	1	1
1	1	0	1
1	1	1	1
(* Programa FBD utilizando el Bloque “SR” *)

(* Equivalencia ST: se supone que SR1 es una instancia del bloque SR *)

SR1((auto_mode & start_cmd), stop_cmd);

command := SR1.Q1;

(* Equivalencia IL: *)

LD	auto_mode

Y	start_cmd

ST	SR1.set1

LD	stop_cmd

ST	SR1.reset

CAL	SR1

LD	SR1.Q1

ST	command


RS

Argumentos:

SET	BOO	si VERDADERO, fija Q1 en VERDADERO (dominante)

RESET	BOO	si VERDADERO, restablece Q1 en FALSO (dominante)

Q1	BOO	estado booleano de memoria

Descripción:

Restablecer biestable dominante: Véase Tabla de VERDAD a continuación:

SET	RESET	Q1	resultado Q1
0	0	0	0
0	0	1	1
0	1	0	0
0	1	1	0
1	0	0	1
1	0	1	1
1	1	0	0
1	1	1	0
(* Programa FBD utilizando el Bloque "RS" *)

(* Equivalencia ST: se supone que SR1 es una instancia del bloque RS *)

RS1(start_cmd, (stop_cmd OR alarm));

command := RS1.Q1;

(* Equivalencia IL: *)

LD	start_cmd

ST	RS1.set

LD	stop_cmd

OR	alarm

ST	RS1.reset1

CAL	RS1

LD	RS1.Q1

ST	command


R_TRIG

Argumentos:

CLK	BOO	cualquier variable booleana

Q	BOO	VERDADERO cuando CLK pasa de FALSO a VERDADERO

FALSO en todos los demás casos

Descripción:

Detecta el flanco de subida de una variable booleana

(* Programa FBD utilizando el Bloque "R_TRIG" *)

(* Equivalencia ST: se supone que R_TRIG1 es una instancia del bloque R_TRIG *)

R_TRIG1(cmd);

nb_edge := ANA(R_TRIG1.Q) + nb_edge;

(* Equivalencia IL: *)

LD	cmd

ST	R_TRIG1.clk

CAL	R_TRIG1

LD	R_TRIG1.Q

ANA

ADD	nb_edge

ST	nb_edge


F_TRIG

Argumentos:

CLK	BOO	cualquier variable booleana

Q	BOO	VERDADERO cuando CLK pasa de VERDADERO a FALSO

FALSO en todos los demás casos

Descripción:

Detecta el flanco de bajada de una variable booleana

(* Programa FBD utilizando el Bloque "F_TRIG" *)

(* Equivalencia ST: se supone que F_TRIG1 es una instancia del bloque FR_TRIG *)

F_TRIG1(cmd);

nb_edge := ANA(F_TRIG1.Q) + nb_edge;

(* Equivalencia IL: *)

LD	cmd

ST	F_TRIG1.clk

CAL	F_TRIG1

LD	F_TRIG1.Q

ANA

ADD	nb_edge

ST	nb_edge


SEMA

Argumentos:

CLAIM	BOOLEANO	comando de “comprobar y establecer”

RELEASE	BOOLEANO	libera el semáforo

BUSY	BOOLEANO	estado del semáforo

Descripción:

(* "x" es una variable booleana inicializada en FALSO *)

busy := x;

If claim Then

x := VERDADERO;

Else

If release Then

busy := FALSO;

x := FALSO;

End_If;

End_If;


CTU

Argumentos:

CU	BOO	entrada de contaje

(contaje creciente cuando CU es VERDADERO)

RESET	BOO	comando de restablecer (dominante)

PV	INT	valor máximo programado

Q	BOO	desbordamiento: VERDADERO cuando CV = PV

CV	INT	resultado del contaje

Advertencia: El bloque CTU no detecta los flancos de subida o bajada de la entrada de contaje (CU). Tiene que estar asociado a bloques "R_TRIG" o "F_TRIG" para crear un contador de impulsos.

Descripción:

Cuenta (números enteros) desde 0 hasta un valor determinado en pasos de 1

(* Programa FBD utilizando el Bloque "CTU" *)

(* Equivalencia ST: se supone que R_TRIG1 es una instancia del bloque R_TRIG y que CTU1 es una instancia del bloque CTU *)

CTU1(R_TRIG1(command),NOT(auto_mode),100);

overflow := CTU1.Q;

result := CTU1.CV;

(* Equivalencia IL: *)

LD	command

ST	R_TRIG1.clk

CAL	R_TRIG1

LD	R_TRIG1.Q

ST	CTU1.cu

LDN	auto_mode

ST	CTU1.reset

LD	100

ST	CTU1.pv

CAL	CTU1

LD	CTU1.Q

ST	overflow

LD	CTU1.cv

ST	result


CTD

Argumentos:

CD	BOO	entrada de contaje

(cuenta decreciente cuando CD es VERDADERO)

LOAD	BOO	comando de cargar (dominante)

(CV = PV cuando LOAD es VERDADERO)

PV	INT	valor inicial programado

Q	BOO	subdesbordamiento: VERDADERO cuando CV = 0

CV	INT	resultado del contaje

Advertencia: El bloque CTD no detecta los flancos de subida o bajada de la entrada de contaje (CD). Tiene que estar asociado a bloques "R_TRIG" o "F_TRIG" para crear un contador de impulsos.

Descripción:

Cuenta (números enteros) desde un valor determinado hasta 0 en pasos de 1

(* Programa FBD utilizando el Bloque "CTD" *)

 (* Equivalencia ST: se supone que F_TRIG1 es una instancia del bloque F_TRIG y que CTD1 es una instancia del bloque CTD *)

CTD1(F_TRIG1(command),load_cmd,100);

underflow := CTD1.Q;

result := CTD1.CV;

(* Equivalencia IL: *)

LD	command

ST	F_TRIG1.clk

CAL	F_TRIG1

LD	F_TRIG1.Q

ST	CTD1.cd

LD	load_cmd

ST	CTD1.load

LD	100

ST	CTD1.pv

CAL	CTD1

LD	CTD1.Q

ST	underflow

LD	CTD1.cv

ST	result


CTUD

Argumentos:

CU	BOO	contaje creciente (cuando CU es VERDADERO)

CD	BOO	contaje decreciente (cuando CD es VERDADERO)

RESET	BOO	comando de restablecer (dominante)

(CV = 0 cuando RESET es VERDADERO)

LOAD	BOO	comando de cargar (CV = PV cuando LOAD es VERDADERO)

PV	INT	valor inicial programado

QU	BOO	desbordamiento: VERDADERO cuando CV = PV

QD	BOO	subdesbordamiento: VERDADERO cuando CV = 0

CV	INT	resultado del contaje

Advertencia: El bloque CTUD no detecta los flancos de subida o bajada de las entradas de contaje (CU y CD). Tiene que estar asociado a bloques "R_TRIG" o "F_TRIG" para crear un contador de impulsos.

Descripción:

Cuenta (números enteros) desde 0 hasta un valor determinado, en pasos de 1

o desde un valor determinado hasta 0, en pasos de 1

(* Programa FBD utilizando el Bloque "CTUD" *)

(* Equivalencia ST: se supone que R_TRIG1 y R_TRIG2 son dos instancias del bloque R_TRIG y que CTUD1 es una instancia del bloque CTUD *)

CTUD1(R_TRIG1(add_elt), R_TRIG2(sub_elt), reset_cmd, load_cmd,100);

full := CTUD1.QU;

empty := CTUD1.QD;

nb_elt := CTUD1.CV;

(* Equivalencia IL: *)

LD	add_elt

ST	R_TRIG1.clk

CAL	R_TRIG1

LD	R_TRIG1.Q

ST	CTUD1.cu

LD	sub_elt

ST	R_TRIG2.clk

CAL	R_TRIG2

LD	R_TRIG2.Q

ST	CTUD1.cd

LD	reset_cmd

ST	CTUD1.reset

LD	load_cmd

ST	CTUD1.load

LD	100

ST	CTUD1.pv

CAL	CTUD1

LD	CTUD1.QU

ST	full

LD	CTUD1.QD

ST	empty

LD	CTUD1.CV

ST	nb_elt


TON

Argumentos:

IN	BOO	Con flanco de subida, comienza a aumentar el temporizador interno

Con flanco de bajada, para y reinicia el temporizador interno

PT	TMR	tiempo máximo programado

Q	BOO	Si estado VERDADERO:ha transcurrido el tiempo programado

ET	TMR	tiempo transcurrido actual

Descripción:

Incrementa un temporizador interno hasta un valor determinado.

Diagrama de tiempo:


TOF

Argumentos:

IN	BOO	Con flanco de bajada, comienza a aumentar el temporizador interno

Con flanco de subida, para y reinicia el temporizador interno

PT	TMR	tiempo máximo programado

Q	BOO	Si estado VERDADERO: no ha transcurrido el tiempo programado

ET	TMR	tiempo transcurrido actual

Descripción:

Incrementa un temporizador interno hasta un valor determinado.

Diagrama de tiempo:


TP

Argumentos:

IN	BOO	Con flanco de subida, comienza a aumentar el temporizador interno (si no se encuentra ya en aumento)

Con estado FALSO y sólo si ha transcurrido el temporizador, reinicia el temporizador interno

Cualquier cambio en IN durante el contaje queda sin efecto

PT	TMR	tiempo máximo programado

Q	BOO	Si estado VERDADERO: el temporizador está contando

ET	TMR	tiempo transcurrido actual

Descripción:

Incrementa un temporizador interno hasta un valor determinado.

Diagrama de tiempo:


CMP

Argumentos:

VAL1	INT	cualquier valor analógico entero con su correspondiente signo

VAL2	INT	cualquier valor analógico entero con su correspondiente signo

LT	BOO	VERDADERO si val1 es inferior a val2

EQ	BOO	VERDADERO si val1 es igual a val2

GT	BOO	VERDADERO si val1 es mayor que val2

Descripción:

Comparar dos valores, determinando si son iguales o si el primero es inferior o mayor que el segundo.

(* Programa FBD utilizando el Bloque "CMP" *)

(* Equivalencia ST: se supone que CMP1 es una instancia del bloque CMP *)

CMP1(level, max_level);

pump_cmd := CMP1.LT OR CMP1.EQ;

alarm := CMP1.GT Y NOT(manual_mode);

(* Equivalencia IL: *)

LD	level

ST	CMP1.val1

LD	max_level

ST	CMP1.val2

CAL	CMP1

LD	CMP1.LT

OR	CMP1.EQ

ST	pump_cmd

LD	CMP1.GT

ANDN	manual_mode

ST	alarm


STACKINT

Argumentos:

PUSH	BOO	comando push (introducir) (sólo flanco de subida)

añade el valor IN a la cabeza de la pila

POP	BOO	comando pop (sacar) (sólo flanco de subida)

elimina de la pila el último valor 'introducido' (cabeza de la pila)

R1	BOO	restablece la pila a su estado vacío

IN	INT	valor 'introducido'

N	INT	tamaño del pila definido por la aplicación

EMPTY	BOO	VERDADERO si la pila está vacía

OFLO	BOO	desbordamiento: VERDADERO si la pila está completa

OUT	INT	valor situado a la cabeza de la pila

Descripción:

Gestionar una pila de valores enteros.

El bloque de función "STACKINT" incluye la detección de flanco de subida para los comandos PUSH y POP. El tamaño máximo del grupo es de 128. El tamaño de pila definido por la aplicación, N, no puede ser inferior a 1 o superior a 128.

Observe que el valor OFLO sólo es válido después de un restablecimiento (R1 se sitúa en VERDADERO al menos en una ocasión, volviendo posteriormente a FALSO).

(* Programa FBD utilizando el Bloque "STACKINT": gestión de errores *)

(* Equivalencia ST: se supone que STACKINT1 es una instancia del bloque STACKINT *)

STACKINT1(err_detect, acknoledge, manual_mode, err_code, max_err);

appli_alarm := auto_mode Y NOT(STACKINT1.EMPTY);

err_alarm := STACKINT1.OFLO;

last_error := STACKINT1.OUT;

(* Equivalencia IL: *)

LD	err_detect

ST	STACKINT1.push

LD	acknoledge

ST	STACKINT1.pop

LD	manual_mode

ST	STACKINT1.r1

LD	err_code

ST	STACKINT1.IN

LD	max_err

ST	STACKINT1.N

CAL	STACKINT1

LD	auto_mode

ANDN	STACKINT1.empty

ST	appli_alarm

LD	STACKINT1.OFLO

ST	err_alarm

LD	STACKINT1.OUT

ST	last_error


AVERAGE

Argumentos:

RUN	BOO	VERDADERO=promediar / FALSO=restablecer

XIN	REAL	cualquier variable analógica real

N	INT	número de muestreos definido por la aplicación

XOUT	REAL	media dinámica del valor XIN

Descripción:

Almacena un valor en cada ciclo y calcula el valor medio de todos los valores ya almacenados. Sólo se almacenan los ultimos valores N.

El número de muestreos N no puede superar 128.

Si el comando "RUN" es FALSO (modo restablecer), el valor de salida es igual al valor de entrada.

Cuando se alcanza el número máximo de valores almacenados N, el primer valor almacenado queda reemplazado por el último.

(* Programa FBD utilizando el Bloque "AVERAGE": *)

(* Equivalencia ST: AVERAGE1 es instancia del bloque AVERAGE *)

AVERAGE1((auto_mode & store_cmd), sensor_value, 100);

ave_value := AVERAGE1.XOUT;

(* Equivalencia IL: *)

LD	auto_mode

Y	store_cmd

ST	AVERAGE1.run

LD	sensor_value

ST	AVERAGE1.xin

LD	100

ST	AVERAGE1.N

CAL	AVERAGE1

LD	AVERAGE1.XOUT

ST	ave_value


HYSTER

Argumentos:

XIN1	REAL	cualquier valor analógico real

XIN2	REAL	para comprobar si XIN1 ha sobrepasado XIN2+EPS

EPS	REAL	valor de histéresis (debe ser superior a cero)

Q	BOO	VERDADERO si XIN1 ha sobrepasado XIN2+EPS y todavía no está por debajo de XIN2-EPS

Descripción:

Histéresis de valor real para un límite superior.

Ejemplo de diagrama de tiempo:


LIM_ALRM

Argumentos:

H	REAL	valor de límite superior

X	REAL	entrada: cualquier valor analógico real

L	REAL	valor de límite inferior

EPS	REAL	valor de histéresis (debe ser superior a cero)

QH	BOO	alarma “superior”: VERDADERO si X está por encima de límite superior H

Q	BOO	salida de alarma: VERDADERO si X está fuera de límites

QL	BOO	alarma “inferior”: VERDADERO si X está por debajo del límite inferior L

Descripción:

Histéresis de valor real para límites superior e inferior.

Se aplica una histéresis a los límites superior e inferior. El delta de histéresis que se utiliza para cualquiera de los dos límites es la mitad del parámetro EPS. A continuación se muestra un ejemplo de un diagrama de tiempo:


INTEGRAL

Argumentos:

RUN	BOO	modo: VERDADERO=integrar / FALSO=mantener

R1	BOO	restablecimiento prioritario

XIN	REAL	entrada: cualquier valor analógico real

X0	REAL	valor inicial

CYCLE	TMR	periodo de muestreo

Q	BOO	R1 negado

XOUT	REAL	salida integrada

Descripción:

Integración de un valor real.

Si el valor del parámetro "CYCLE" es inferior al tiempo de ciclo de la aplicación, el periodo de muestreo equivale al tiempo de ciclo de la aplicación.

(* Programa FBD utilizando el Bloque "INTEGRAL": *)

(* Equivalencia ST: INTEGRAL1 es una instancia del bloque INTEGRAL *)

INTEGRAL1(manual_mode, NOT(manual_mode), sensor_value, init_value, t#100ms);

controlled_value := INTEGRAL1.XOUT;

(* Equivalencia IL: *)

LD	manual_mode

ST	INTEGRAL1.run

STN	INTEGRAL1.R1

LD	sensor_value

ST	INTEGRAL1.XIN

LD	init_value

ST	INTEGRAL1.X0

LD	t#100ms

ST	INTEGRAL1.CYCLE

CAL	INTEGRAL1

LD	INTEGRAL1.XOUT

ST	controlled_value


DERIVATE

Argumentos:

RUN	BOO	modo: VERDADERO=normal / FALSO=restablecer

XIN	REAL	entrada: cualquier valor analógico real

CYCLE	TMR	periodo de muestreo

XOUT	REAL	salidas diferenciadas

Descripción:

Diferenciación de un valor real.

Si el valor del parámetro "CYCLE" es inferior al tiempo de ciclo de la aplicación ISaGRAF, el periodo de muestreo equivale al tiempo de ciclo de la aplicación.

(* Programa FBD utilizando el Bloque "DERIVATE": *)

(* Equivalencia ST: DERIVATE1 es una instancia del bloque DERIVATE *)

DERIVATE1(manual_mode, sensor_value, t#100ms);

derivated_value := DERIVATE1.XOUT;

(* Equivalencia IL: *)

LD	manual_mode

ST	DERIVATE1.run

LD	sensor_value

ST	DERIVATE1.XIN

LD	t#100ms

ST	DERIVATE1.CYCLE

CAL	DERIVATE1

LD	DERIVATE1.XOUT

ST	derivated_value


BLINK

Argumentos:

RUN	BOO	modo: VERDADERO=parpadeante / FALSO=restablecer la salida en estado falso

CYCLE	TMR	periodo de parpadeo

Q	BOO	señal de salida parpadeante

Descripción:

Genera una señal parpadeante.

Diagrama de tiempo:


SIG_GEN

Argumentos:

RUN	BOO	modo: VERDADERO=en operación / FALSO=restablecer en estado falso

PERIOD	TMR	duración de una muestra

MAXIMUM	INT	valor máximo de contaje

PULSE	BOO	invertido después de cada muestra

UP	INT	contador creciente, incrementado con cada muestra

END	BOO	VERDADERO cuando finaliza la cuenta creciente

SENO	REAL	señal senoidal (periodo = duración de contaje)

Descripción:

Genera varias señales: parpadeo para booleanos, cuenta creciente de valores enteros y ondas senoidales reales.

Cuando el proceso de contaje alcanza su valor máximo, se reinicia desde 0 (cero). Por tanto, END sólo mantiene el valor VERDADERO durante un PERIOD.

Diagrama de tiempo:


Funciones estándares

Estas son funciones estándares soportadas por el sistema ISaGRAF. Dichas funciones están predefinidas y no tienen que ser declaradas en la librería.

Matemática:

ABS	Valor absoluto

EXPT	Cálculo de Exponente

LOG	Logaritmos

POW	Potencia

SQRT	Raíz cuadrada

TRUNC	Truncar parte decimal

Trigonometría:

ACOS	Arco coseno

ASIN	Arco seno

ATAN	Arco tangente

COS	Coseno

SIN	Seno

TAN	Tangente

Control de registros:

ROL	Rotar a la izquierda

ROR	Rotar a la derecha

SHL	Desplazar a la izquierda

SHR	Desplazar a la derecha

Tratamiento de datos:

MIN	Mínimo

MAX	Máximo

LIMIT	Límite

MOD	Módulo

MUX4	Multiplexor (4 entradas)

MUX8	Multiplexor (8 entradas)

ODD	Paridad impar

RAND	Valor aleatorio

SEL	Selector binario

Conversión de datos:

ASCII	Carácter  Código ASCII

CHAR	Código ASCII  Carácter

Gestión de cadenas:

DELETE	Borrar subcadena

INSERT	Insertar cadena

FIND	Encontrar subcadena

MLEN	Obtener longitud de cadena

LEFT	Extraer parte izquierda

MID	Extraer parte central

REPLACE	Sustituir subcadena

RIGHT	o derecha de una cadena

DAY_TIME	Hora del día

Tratamiento de grupos:

ARCREATE	Crear vector de valores enteros

ARREAD	Leer elementos de vector

ARWRITE	Escribir elementos de vector

Gestión de ficheros binarios:

F_ROPEN	Abrir un fichero binario en modo Lectura

F_WOPEN	Abrir un fichero binario en modo Escritura

F_CLOSE	Cerrar un fichero binario

F_EOF	Comprobar el final de un fichero binario

FA_READ	Leer un valor analógico en un fichero binario

FA_WRITE	Escribir un valor analógico en un fichero binario

FM_READ	Leer una cadena de mensajes en un fichero binario

FM_WRITE	Escribir una cadena de mensajes en un fichero binario


ABS

Argumentos:

IN	REAL	cualquier valor analógico real con signo

Q	REAL	valor absoluto (siempre positivo)

Descripción:

Proporciona el valor absoluto (positivo) de un valor real.

(* Programa FBD utilizando el Bloque "ABS" *)

(* Equivalencia ST: *)

over := (ABS (delta) > range);

(* Equivalencia IL: *)

LD	delta

ABS

GT 	range

ST	over


EXPT

Argumentos:

IN	REAL	cualquier valor analógico real con signo

EXP	INT	exponente analógico entero

Q	REAL	(IN EXP)

Descripción:

Proporciona el resultado real de la operación: (base exponente), siendo 'base' el primer argumento y 'exponente' el segundo.

(* Programa FBD utilizando el Bloque "EXPT" *)

(* Equivalencia ST: *)

tb_size := ANA (EXPT (2.0, range) );

(* Equivalencia IL: *)

LD	2.0

EXPT	range

ANA

ST	tb_size


LOG

Argumentos:

IN	REAL	debe ser superior a cero

Q	REAL	logaritmo (base 10) del valor de entrada

Descripción:

Calcula el logaritmo (base 10) de un valor real.

(* Programa FBD utilizando el Bloque "LOG" *)

(* Equivalencia ST: *)

xpos := ABS (xval);

xlog := LOG (xpos);

(* Equivalencia IL: *)

LD	xval

ABS

ST	xpos

LOG

ST	xlog


POW

Argumentos:

IN	REAL	número analógico real a elevar

EXP	REAL	potencia (exponente)

Q	REAL	(IN EXP)

1.0 si IN no es 0.0 y EXP es 0.0

0.0 si IN es 0.0 y EXP es negativo

0.0 si tanto IN como EXP son 0.0

0.0 si IN es negativo e Y no corresponde a un número entero

Descripción:

Proporciona el resultado real de la operación: (base exponente), siendo 'base' el primer argumento y 'exponente' el segundo. El exponente es un valor real.

(* Programa FBD utilizando el Bloque "POW" *)

(* Equivalencia ST: *)

resultado := POW (xval, power);

(* Equivalencia IL: *)

LD	xval

POW	power

ST	resultado


SQRT

Argumentos:

IN	REAL	debe ser superior o igual a cero

Q	REAL	raíz cuadrada del valor de entrada

Descripción:

Calcula la raiz cuadrada de un valor real.

(* Programa FBD utilizando el Bloque "SQRT" *)

(* Equivalencia ST: *)

xpos := ABS (xval);

xroot := SQRT (xpos);

(* Equivalencia IL: *)

LD	xval

ABS

ST	xpos

SQRT

ST	xrout


TRUNC

Argumentos:

IN	REAL	cualquier valor analógico REAL

Q	REAL	si IN>0, mayor número entero inferior o igual a la entrada

si IN<0, menor número entero mayor o igual a la entrada

Descripción:

Trunca un valor real para que tenga sólo la parte entera

(* Programa FBD utilizando el Bloque  "TRUNC" *)

(* Equivalencia ST: *)

resultado := TRUNC (+2.67) + TRUNC (-2.0891);

(* significa : resultado := 2.0 + (-2.0) := 0.0; *)

(* Equivalencia IL: *)

LD	2.67

TRUNC

ST	temporary	(* resultado temporal del primer TRUNC *)

LD	-2.0891

TRUNC

ADD	temporary

ST	result


ACOS

Argumentos:

IN	REAL	debe estar en el conjunto [-1.0 .. +1.0]

Q	REAL	arco coseno del valor de entrada (en el conjunto [0.0 .. PI])

= 0.0 para entradas no válidas

Descripción:

Calcula el Arco coseno de un valor real.

(* Programa FBD utilizando los Bloques "COS" y "ACOS" *)

(* Equivalencia ST: *)

cosine := COS (angle);

result := ACOS (cosine); (* resultado es igual a un ángulo *)

(* Equivalencia IL: *)

LD	angle

COS

ST	cosine

ACOS

ST	result


ASIN

Argumentos:

IN	REAL	debe estar en el conjunto [-1.0 .. +1.0]

Q	REAL	arco coseno del valor de entrada (en el conjunto [-PI/2 .. +PI/2])

= 0.0 para entradas no válidas

Descripción:

Calcula el Arco seno de un valor real.

(* Programa FBD utilizando los Bloques "SIN" y "ASIN" *)

(* Equivalencia ST: *)

sine := SIN (angle);

result := ASIN (sine); (* resultado es igual a un ángulo *)

(* Equivalencia IL: *)

LD	angle

SIN

ST	sine

ASIN

ST	result


ATAN

Argumentos:

IN	REAL	cualquier valor analógico REAL

Q	REAL	arco tangente del valor de entrada (en el conjunto [-PI/2 .. +PI/2])

= 0.0 para entradas no válidas

Descripción:

Calcula el Arco tangente de un valor real.

(* Programa FBD utilizando los Bloques "TAN" y "ATAN" *)

(* Equivalencia ST: *)

tangent := TAN (angle);

result := ATAN (tangent); (* resultado es igual a un ángulo *)

(* Equivalencia IL: *)

LD	angle

TAN

ST	tangent

ATAN

ST	result


COS

Argumentos:

IN	REAL	cualquier valor analógico REAL

Q	REAL	coseno del valor de entrada (en el conjunto [-1.0 .. +1.0])

Descripción:

Calcula el Coseno de un valor real.

(* Programa FBD utilizando los Bloques "COS" y "ACOS" *)

(* Equivalencia ST: *)

cosine := COS (angle);

result := ACOS (cosine); (* resultado es igual a ángulo *)

(* Equivalencia IL: *)

LD	angle

COS

ST	cosine

ACOS

ST	result


SIN

Argumentos:

IN	REAL	cualquier valor analógico REAL

Q	REAL	seno del valor de entrada (en el conjunto [-1.0 .. +1.0])

Descripción:

Calcula el Seno de un valor real.

(* Programa FBD utilizando los Bloques "SIN" y "ASIN" *)

(* Equivalencia ST: *)

sine := SIN (angle);

result := ASIN (sine); (* resultado es igual a ángulo *)

(* Equivalencia IL: *)

LD	angle

SIN

ST	sine

ASIN

ST	result


TAN

Argumentos:

IN	REAL	no puede ser igual a PI/2 módulo PI

Q	REAL	tangente del valor de entrada

= 1E+38 para entradas no válidas

Descripción:

Calcula la Tangente de un valor real.

(* Programa FBD utilizando los Bloques "TAN" y "ATAN" *)

(* Equivalencia ST: *)

tangent := TAN (angle);

result := ATAN (tangent); (* resultado es igual a ángulo *)

(* Equivalencia IL: *)

LD	angle

TAN

ST	tangent

ATAN

ST	result


ROL

Argumentos:

IN	INT	cualquier valor analógico entero

NbR	INT	número de rotaciones de 1 bit (en el conjunto [1..31])

Q	INT	valor rotado a la izquierda

Sin efecto si NbR <= 0

Descripción:

Provoca la rotación a la izquierda de los bits de un valor entero. La rotación se realiza sobre 32 bits:

(* Programa FBD utilizando el Bloque  "ROL" *)

(* Equivalencia ST: *)

result := ROL (register, 1);

(* register = 2#0100_1101_0011_0101*)

(* result = 2#1001_1010_0110_1010*)

(* Equivalencia IL: *)

LD	register

ROL	1

ST	result


ROR

Argumentos:

IN	INT	cualquier valor analógico entero

NbR	INT	número de rotaciones de 1 bit (en el conjunto [1..31])

Q	INT	valor rotado a la derecha

Sin efecto si NbR <= 0

Descripción:

Provoca la rotación a la derecha de los bits de un valor entero. La rotación se realiza sobre 32 bits:

(* Programa FBD utilizando el Bloque  "ROR" *)

(* Equivalencia ST: *)

result := ROR (register, 1);

(* register = 2#0100_1101_0011_0101 *)

(* result = 2#1010_0110_1001_1010 *)

(* Equivalencia IL: *)

LD	register

ROR	1

ST	result


SHL

Argumentos:

IN	INT	cualquier valor analógico entero

NbS	INT	número de desplazamientos de 1 bit (en el conjunto [1..31])

Q	INT	valor desplazado a la izquierda

Sin efecto si NbS <= 0

Se emplea 0 para sustituir al bit inferior

Descripción:

Provoca el desplazamiento a la izquierda de los bits de un valor entero. El desplazamiento se realiza sobre 32 bits:

(* Programa FBD utilizando el Bloque  "SHL" *)

(* Equivalencia ST: *)

result := SHL (register,1);

(* register = 2#0100_1101_0011_0101 *)

(* result = 2#1001_1010_0110_1010 *)

(* Equivalencia IL: *)

LD	register

SHL	1

ST	result


SHR

Argumentos:

IN	INT	cualquier valor analógico entero

NbS	INT	número de desplazamientos de 1 bit (en el conjunto [1..31])

Q	INT	valor desplazado a la derecha

Sin efecto si NbS <= 0

Se copia el bit superior en cada desplazamiento

Descripción:

Provoca el desplazamiento a la derecha de los bits de un valor entero. El desplazamiento se realiza sobre 32 bits:

(* Programa FBD utilizando el Bloque  "SHR" *)

(* Equivalencia ST: *)

result := SHR (register,1);

(* register = 2#1100_1101_0011_0101 *)

(* result = 2#1110_0110_1001_1010 *)

(* Equivalencia IL: *)

LD	register

SHR	1

ST	result


MIN

Argumentos:

IN1	INT	cualquier valor analógico entero con  signo

IN2	INT	(no puede ser REAL)

Q	INT	mínimo de ambos valores de entrada

Descripción:

Proporciona el mínimo de dos valores enteros.

(* Programa FBD utilizando los Bloques "MIN" y "MAX" *)

(* Equivalencia ST: *)

new_value := MAX (MIN (max_value, value), min_value);

(* limita el valor al conjunto [min_value..max_value] *)

(* Equivalencia IL: *)

LD	max_value

MIN	value

MAX	min_value

ST	new_value


MAX

Argumentos:

IN1	INT	cualquier valor analógico entero con  signo

IN2	INT	(no puede ser REAL)

Q	INT	máximo de ambos valores de entrada

Descripción:

Proporciona el máximo de dos valores enteros.

(* Programa FBD utilizando los Bloques "MIN" y "MAX" *)

(* Equivalencia ST: *)

new_value := MAX (MIN (max_value, value), min_value);

(* limita el valor al conjunto [min_value..max_value] *)

(* Equivalencia IL: *)

LD	max_value

MIN	value

MAX	min_value

ST	new_value


LIMIT

Argumentos:

MIN	INT	valor mínimo permitido

IN	INT	cualquier valor analógico entero con  signo

MAX	INT	valor máximo permitido

Q	INT	valor de entrada limitado al rango permitido

Descripción:

Limita un valor entero a un intervalo determinado. Mantiene su valor si se encuentra entre el mínimo y el máximo, cambia a máximo si se encuentra por encima o cambia a mínimo si se encuentra por debajo.

(* Programa FBD utilizando el Bloque "LIMIT" *)

(* Equivalencia ST: *)

new_value := LIMIT (min_value, value, max_value);

(* limita el valor al conjunto [min_value..max_value] *)

(* Equivalencia IL: *)

LD	min_value

LIMIT	value, max_value

ST	new_value


MOD

Argumentos:

IN	INT	cualquier valor analógico entero con  signo

Base	INT	debe ser superior a cero

Q	INT	cálculo de módulo (entrada MOD base)

retorna -1 si Base <= 0

Descripción:

Calcula el módulo de un valor entero.

(* Programa FBD utilizando el Bloque  "MOD" *)

(* Equivalencia ST: *)

division_result := (value / divider); (* división entera *)

rest_of_division := MOD (value, divider); (* resto de la división *)

(* Equivalencia IL: *)

LD	value

DIV	divider

ST	division_result

LD	value

MOD	divider

ST	rest_of_division


MUX4

Argumentos:

SEL	INT	valor entero del selector (tiene que estar en el conjunto [0..3])

IN1..IN4	INT	cualquier valor analógico entero

Q	INT	= valor1 si SEL = 0

= valor2 si SEL = 1

= valor3 si SEL = 2

= valor4 si SEL = 3

= 0 para los restantes valores del selector

Descripción:

Multiplexor con 4 entradas: selecciona un valor entre 4 valores enteros.

(* Programa FBD utilizando el Bloque  "MUX4" *)

(* Equivalencia ST: *)

range := MUX4 (choice, 1, 10, 100, 1000);

(* selecciona entre 4 rangos predefinidos, por ejemplo, si la elección es 1, el rango será 10 *)

(* Equivalencia IL: *)

LD	choice

MUX4	1,10,100,1000

ST	range


MUX8

Argumentos:

SEL	INT	valor entero del selector (tiene que estar en el conjunto [0..7])

IN1..IN8	INT	cualquier valor analógico entero

Q	INT	= valor1 si selector = 0

= valor2 si selector = 1

...

= valor8 si selector = 7

= 0 para los restantes valores del selector

Descripción:

Multiplexor con 8 entradas: selecciona un valor entre 8 valores enteros.

(* Programa FBD utilizando el Bloque  "MUX8" *)

(* Equivalencia ST: *)

range := MUX8 (choice, 1, 5, 10, 50, 100, 500, 1000, 5000);

(* selecciona entre 8 rangos predefinidos, por ejemplo, si la elección es 3, el rango será 50 *)

(* Equivalencia IL: *)

LD	choice

MUX8	1,5,10,50,100,500,1000,5000

ST	range


ODD

Argumentos:

IN	INT	cualquier valor analógico entero con  signo

Q	BOO	VERDADERO si el valor de entrada es impar

FALSO si el valor de entrada es par

Descripción:

Comprueba la paridad de un valor entero: el resultado es impar o par.

(* Programa FBD utilizando el Bloque "ODD" *)

(* Equivalencia ST: *)

If Not (ODD (value)) Then Return; End_If;

value := value + 1;

(* hace el valor siempre par *)

(* Equivalencia IL: *)

LD	value

ODD

RETNC

LD	value

ADD	1

ST	value


RAND

Argumentos:

base	INT	define el conjunto de números permitido

Q	INT	valor aleatorio en el conjunto [0..base-1]

Descripción:

Asigna un valor entero aleatorio a un rango determinado.

(* Programa FBD utilizando el Bloque "RAND" block *)

(* Equivalencia ST: *)

selected := MUX4 ( RAND (4), 1, 4, 8, 16 );

(*

selección aleatoria de uno entre 4 valores predefinidos

el valor proporcionado por la llamada RAND pertence al conjunto [0..3], por ello el valor 'seleccionado' por MUX4, tomará 'aleatoriamente' el valor:

1 si RAND genera 0

ó 4 si RAND genera 1

ó 8 si RAND genera 2

ó 16 si RAND genera 3

*)

(* Equivalencia IL: *)

LD	4

RAND

MUX4	1,4,8,16

ST	selected


SEL

Argumentos:

SEL	BOO	indica el valor seleccionado

IN1, IN2	INT	cualquier valor analógico entero

Q	INT	= valor1 si SEL es FALSO

= valor2 si SEL es VERDADERO

Descripción:

Selector binario: selecciona uno entre 2 valores enteros.

(* Programa FBD utilizando el Bloque "SEL" *)

(* Equivalencia ST: *)

ProCmd := SEL (AutoMode, ManuCmd, InpCmd);

(* procesa la selección de comando *)

(* Equivalencia IL: *)

LD	AutoMode

SEL	ManuCmd,InpCmd

ST	ProCmd


ASCII

Argumentos:

IN	MSG	cualquier cadena no vacía

Pos	INT	posición del carácter seleccionado

En el conjunto [1.. len] (len es la longitud del mensaje IN)

Code	INT	código del carácter seleccionado

(en el conjunto [0 .. 255])

retorna 0 si Pos está fuera de la cadena

Descripción:

Proporciona el código ASCII de un carácter perteneciente a una cadena de mensaje.

(* Programa FBD utilizando el Bloque "ASCII" *)

(* Equivalencia ST: *)

FirstChr := ASCII (message, 1);

(* FirstChr es el código Ascii del primer carácter de la cadena *)

(* Equivalencia IL: *)

LD	message

ASCII	1

ST	FirstChr


CHAR

Argumentos:

Code	INT	código en el conjunto [0 .. 255]

Q	MSG	una cadena de caracteres

El carácter tiene el código ASCII especificado en el Código de entrada

(el código ASCII utilizado es módulo 256)

Descripción:

Proporciona una cadena de mensaje de un carácter a partir de un código ASCII determinado.

(* Programa FBD utilizando el Bloque "CHAR" *)

(* Equivalencia ST: *)

Display := CHAR ( value + 48 );

(* valor en el conjunto [0..9] *)

(* 48 es el código ascii de '0' *)

(* resultado es un cadena de un carácter de '0' a '9' *)

(* Equivalencia IL: *)

LD	value

ADD	48

CHAR

ST	Display


DELETE

Argumentos:

IN	MSG	cualquier mensaje no vacío

NbC	INT	número de caracteres a borrar

Pos	INT	posición del primer carácter borrado

(el primer carácter de la cadena tiene la posición 1)

Q	MSG	cadena modificada

cadena vacía si Pos < 1

cadena inicial si Pos > IN longitud de cadena

cadena inicial si NbC <= 0

Descripción:

Borra parte de una cadena de mensaje.

(* Programa FBD utilizando el Bloque "DELETE" *)

(* Equivalencia ST: *)

complete_string := 'ABCD' + 'EFGH'; (* complete_string es 'ABCDEFGH' *)

sub_string := DELETE (complete_string, 4, 3); (* sub_string es 'ABGH' *)

(* Equivalencia IL: *)

LD	'ABCD'

ADD	'EFGH'

ST	complete_string

DELETE	4,3

ST 	sub_string


INSERT

Argumentos:

IN	MSG	cadena inicial

Str	MSG	cadena a insertar

Pos	INT	posición de la inserción

la inserción se realiza delante de la posición

(primera posición válida es 1)

Q	MSG	cadena modificada

cadena vacía si Pos <= 0

concatenación de ambas cadenas si Pos es mayor que la longitud de la cadena IN

Descripción:

Inserta una subcadena en una posición determinada de una cadena de mensaje.

(* Programa FBD utilizando el Bloque "INSERT" *)

(* Equivalencia ST: *)

MyName := INSERT ('Mr JONES', 'Frank ', 4);

(* MyName es 'Mr Frank JONES' *)

(* Equivalencia IL: *)

LD	'Mr JONES'

INSERT	'Frank ',4

ST 	MyName


FIND

Argumentos:

In	MSG	cualquier cadena de mensajes

Pat	MSG	cualquier cadena no vacía (patrón)

Pos	INT	= 0 si no se encuentra la subcadena Pat

= posición del primer carácter de la primera ocurrencia de la subcadena Pat

(primera posición es 1)

esta función es sensible al uso de mayúsculas o minúsculas

Descripción:

Localiza una subcadena en una cadena de mensajes. Indica la posición de la subcadena en la cadena.

(* Programa FBD utilizando el Bloque "FIND" *)

(* Equivalencia ST: *)

complete_string := 'ABCD' + 'EFGH'; (* complete_string es 'ABCDEFGH' *)

found := FIND (complete_string, 'CDEF'); (* found es 3 *)

(* Equivalencia IL: *)

LD	'ABCD'

ADD	'EFGH'

ST	complete_string

FIND	'CDEF'

ST 	found


MLEN

Argumentos:

IN	MSG	cualquier cadena de mensaje

NbC	INT	número de caracteres en la cadena IN

Descripción:

Calcula la longitud de una cadena de mensaje.

(* Programa FBD utilizando el Bloque "MLEN" *)

(* Equivalencia ST: *)

nbchar := MLEN (complete_string);

If (nbchar < 3) Then Return; End_if;

prefix := LEFT (complete_string, 3);

(* este programa extrae los 3 caracteres situados en la parte izquierda de la cadena y coloca el resultado en la variable del prefijo de mensaje

no se hace nada si la longitud de cadena es inferior a 3 caracteres *)

(* Equivalencia IL: *)

LD	complete_string

MLEN

ST	nbchar

LT	3

RETC

LD	complete_string

LEFT	3

ST	prefix


LEFT

Argumentos:

IN	MSG	cualquier cadena no vacía

NbC	INT	el número de caracteres a extraer

no puede ser superior a la longitud de la cadena IN

Q	MSG	parte izquierda de la cadena IN (su longitud = NbC)

cadena vacía si NbC <= 0

cadena IN completa si NbC >= longitud de cadena IN

Descripción:

Extrae la parte izquierda de una cadena de mensajes. Se indica el número de caracteres a extraer.

(* Programa FBD utilizando los Bloques "LEFT" y "RIGHT" *)

(* Equivalencia ST: *)

complete_string := RIGHT ('12345678', 4) + LEFT ('12345678', 4);

(* complete_string es '56781234'

el valor proporcionado por la llamada a RIGHT es '5678'

el valor proporcionado por la llamada a LEFT es '1234'

*)

(* Equivalencia IL: Primero se llama a LEFT *)

LD	'12345678'

LEFT	4

ST	sub_string 	(* resultado intermedio *)

LD	'12345678'

RIGHT	4

ADD	sub_string

ST 	complete_string


MID

Argumentos:

IN	MSG	cualquier cadena no vacía

NbC	INT	el número de caracteres a extraer

no puede ser superior a la longitud de la cadena IN

Pos	INT	posición de la subcadena

el primer carácter de la subcadena será el señalado por Pos

(la primera posición válida es 1)

Q	MSG	parte central de la cadena (su longitud = NbC)

cadena vacía si los parámetros no son válidos

Descripción:

Extrae una parte de una cadena de mensaje. Se indica el número de caracteres a extraer y la posición del primer carácter.

(* Programa FBD utilizando el Bloque "MID" *)

(* Equivalencia ST: *)

sub_string := MID ('abcdefgh', 2, 4);

(* sub_string es 'de' *)

(* Equivalencia IL: *)

LD	'abcdefgh'

MID	2,4

ST	sub_string


REPLACE

Argumentos:

IN	MSG	cualquier cadena

Str	MSG	cadena a insertar (para reemplazar NbC caracteres)

NbC	INT	número de caracteres a borrar

Pos	INT	posición del primer carácter modificado

(la primera posición válida es 1)

Q	MSG	cadena modificada:

- se borran los NbC caracteres en la posición Pos

- después, se inserta la subcadena Str en esa misma posición

se devuelve una cadena vacía si Pos <= 0

se devuelve una concatenación de cadenas (IN+Str) si Pos es mayor que la longitud de la cadena IN

se devuelve la cadena inicial IN si NbC <= 0

Descripción:

Sustituye una parte de una cadena de mensaje con un nuevo conjunto de caracteres.

(* Programa FBD utilizando el Bloque "REPLACE" *)

(* Equivalencia ST: *)

MyName := REPLACE ('Mr X JONES, 'Frank', 1, 4);

(* MyName es 'Mr Frank JONES' *)

(* Equivalencia IL: *)

LD	'Mr X JONES'

REPLACE	'Frank',1,4

ST	MyName


RIGHT

Argumentos:

IN	MSG	cualquier cadena no vacía

NbC	INT	no puede ser mayor que la longitud de la cadena IN

Q	MSG	parte derecha de la cadena (longitud = NbC)

cadena vacía si NbC <= 0

cadena completa si NbC >= longitud de cadena

Descripción:

Extrae la parte derecha de una cadena de mensaje. Se indica el número de caracteres a extraer.

(* Programa FBD utilizando los Bloques "LEFT" y "RIGHT" *)

(* Equivalencia ST: *)

complete_string := RIGHT ('12345678', 4) + LEFT ('12345678', 4);

(* complete_string es '56781234'

el valor proporcionado por la llamada a RIGHT es '5678'

el valor proporcionado por la llamada a LEFT es '1234'

*)

(* Equivalencia IL: Primero se llama a LEFT *)

LD	'12345678'

LEFT	4

ST	sub_string 	(* resultado intermedio *)

LD	'12345678'

RIGHT	4

ADD	sub_string

ST 	complete_string


DAY_TIME

Argumentos:

SEL	INT	selección de salida

0= obtener fecha actual

1= obtener hora actual

2= obtener día de la semana

Q	MSG	hora/fecha expresadas en una cadena de caracteres:

'AAAA/MM/DD' si SEL = 0

'HH:MM:SS' si SEL = 1

nombre día si SEL = 2 (p.ej.: 'Lunes')

Descripción:

Proporciona la fecha o la hora del día como una cadena de mensaje.

(* Programa FBD utilizando el Bloque "DAY_TIME" *)

(* Equivalencia ST: *)

Display := Day_Time (0) + ' ; ' + Day_Time (1);

(* El formato del texto a visualizar es: 'YYYY/MM/DD ; HH:MM:SS' *)

(* Equivalencia IL: Primero se llama a day_time(1) *)

LD	1

DAY_TIME

ST	hour_str 	(* resultado intermedio *)

LD	0

DAY_TIME

ADD	' ; '

ADD	hour_str

ST 	Display


ARCREATE

Argumentos:

ID	INT	identificador del vector (tiene que estar en el conjunto [0..15])

Size	INT	número de elementos en el vector

ok	INT	estado de ejecución :

1 = si el vector ha sido creado con éxito

2 = identificador de vector no válido o vector ya creado

3 = tamaño no válido

4 = memoria insuficiente

Descripción:

Creación de una vector de enteros.

Advertencia: Existe un máximo de 16 vectores en una aplicación. Los vectores contienen valores analógicos enteros. Al llevarse a cabo la asignación dinámica de memoria, esta función puede provocar un error de sistema si el tamaño del vector es demasiado próximo al tamaño de la memoria disponible.

(* Programa FBD creando un vector de enteros *)

(* Equivalencia ST: *)

array_error := (ARCREATE (ident, 16) <> 1));

(* Equivalencia IL: *)

LD	ident

ARCREATE	16

NE 	1

ST	array_error


ARREAD

Argumentos:

ID	INT	identificador del vector (tiene que estar en el conjunto [0..15])

Pos	INT	la posición del elemento en el vector

tiene que estar en el conjunto [0 .. size-1]

value	INT	valor del elemento leído

0 si los argumentos no son válidos

Descripción:

Lee un elemento en el vector de enteros.

(* Programa FBD utilizando los Bloques de Gestión de Vectores*)

(* Equivalencia ST: *)

If (array_error) Then Return; End_If;

read_value := ARREAD (ident, index);

(* array_error procede de la llamada a ARCREATE *)

(* Equivalencia IL: *)

LD	array_error

RETC

LD	ident

ARREAD	index

ST	read_value


ARWRITE

Argumentos:

ID	INT	identificador del vector (tiene que estar en el conjunto [0..15])

Pos	INT	la posición del elemento en el vector

tiene que estar en el conjunto [0 .. size-1]

IN	INT	nuevo valor del elemento

ok	INT	estado de ejecución

1 = éxito en el intento de escritura

2 = identificador de vector no válido

3 = índice no válido

Descripción:

Almacena (escribe) un valor en la vector de enteros.

(* Programa FBD utilizando los Bloques de Gestión de Vectores*)

(* Equivalencia ST: *)

If (array_error) Then Return; End_If;

write_status := ARWRITE (Ident, Index, value);

(* array_error proviene de la llamada a ARCREATE *)

(* Equivalencia IL: *)

LD	array_error

RETC

LD	ident

ARWRITE	index,value

ST	write_status


F_ROPEN

Argumentos:

Path	MSG	nombre de fichero

puede incluirse la ruta de acceso al fichero por medio de los símbolos \ o / para especificar un directorio. Para facilitar la portabilidad de las aplicaciones ambos símbolos son equivalentes.

ID	INT	número de fichero

0 si se produce un error: fichero no existe.

Descripción:

Abre un fichero binario en modo lectura. Para ser utilizado con FX_READ y F_CLOSE.

Esta función no se incluye en el simulador ISaGRAF.

(* Programa FBD utilizando los Bloques de Gestión de Ficheros *)

(* Equivalencia ST: *)

file_id := F_ROPEN('c:\data \data.bin');

error := (file_id=0);

(* Equivalencia IL: *)

LD	'c:\data\data.bin'

F_ROPEN

ST	file_id

EQ	0

ST	error


F_WOPEN

Argumentos:

Path	MSG	nombre de fichero

puede incluirse la ruta de acceso al fichero por medio de los símbolos \ o / para especificar un directorio. Para facilitar la portabilidad de las aplicaciones ambos símbolos son equivalentes.

ID	INT	número de fichero

0 si se produce un error. Si el fichero ya existe, se sobreescribe.

Descripción:

Abre un fichero binario en modo escritura. Para ser utilizado con FX_WRITE y F_CLOSE.

Esta función no se incluye en el simulador ISaGRAF.

(* Programa FBD utilizando los Bloques de Gestión de Ficheros *)

(* Equivalencia ST: *)

file_id := F_WOPEN('c:\data \data.bin');

error := (file_id=0);

(* Equivalencia IL: *)

LD	'c:\data\data.bin'

F_WOPEN

ST	file_id

EQ	0

ST	error


F_CLOSE

Argumentos:

ID	INT	número de fichero: devuelto por F_ROPEN o F_WOPEN.

ok	BOO	estado de retorno

VERDADERO si el cierre de fichero es OK

FALSO si se produjo un error

Descripción:

Cierra un fichero binario que previamente se ha abierto con las funciones F_ROPEN o F_WOPEN.

Esta función no se incluye en el simulador ISaGRAF.

(* Programa FBD utilizando los Bloques de Gestión de Ficheros *)

(* Equivalencia ST: *)

file_id := F_ROPEN('data.bin');

ok := F_CLOSE(file_id);

(* Equivalencia IL: *)

LD	'data.bin'

F_ROPEN

ST	file_id

F_CLOSE	(* file_id ya está en el resultado IL actual *)

ST 	ok


F_EOF

Argumentos:

ID	INT	número de fichero: devuelto por F_ROPEN o F_WOPEN.

ok	BOO	indicador de final de fichero

VERDADERO si se llegó al final del fichero en la última invocación del procedimiento de lectura o escritura.

Con FM_READ, el último mensaje que se ha leido de un fichero pudiera ser incorrecto, si el último carácter no es un terminador de cadenas.

Descripción:

Comprueba si se ha llegado al final del fichero.

Esta función no se incluye en el simulador ISaGRAF.

(* Programa FBD utilizando los Bloques de Gestión de Ficheros *)

(* Equivalencia ST: *)

file_id := F_ROPEN('data.bin');

WHILE not(F_EOF(file_id))

VAL := FA_READ(file_id);

END_WHILE;

MESSAGE := 'last val = ' + msg(VAL);

ok := F_CLOSE(file_id);

(* Equivalencia IL: *)

LD	'data.bin'

F_ROPEN

ST	file_id

LD 	file_id

F_EOF

JMPC	END_OF_FILE

NOT_EOF:	LD 	file_id

FA_READ

ST	VAL

LD 	file_id

F_EOF

JMPNC	NOT_EOF 	(* si no final de fichero, se continúa leyendo *)

END_OF_FILE:	LD	VAL

MSG

ST	val_msg	(* conversión de VAL en un mensaje *)

LD	'last val = '

ADD	val_msg

ST	MESSAGE

LD 	file_id

F_CLOSE

ST	ok


FA_READ

Argumentos:

ID	INT	número de fichero: devuelto por F_ROPEN.

Q	INT	valor analógico entero leido del fichero

Descripción:

Lee variables ANALÓGICAS de ficheros binarios. Para ser utilizado con F_ROPEN y F_CLOSE.

Este procedimiento lleva a cabo un acceso secuencial al fichero desde la posición previa.

La primera llamada después de F_ROPEN lee los primeros 4 bytes del fichero, y cada llamada avanza el puntero de lectura.

Para comprobar si se ha llegado al final del fichero, debe utilizarse F_EOF.

Esta función no se incluye en el simulador ISaGRAF.

(* Programa FBD utilizando los Bloques de Gestión de Ficheros *)

(* Equivalencia ST: *)

file_id := F_ROPEN('voltramp.bin');

vstart := FA_READ(file_id);

vend := FA_READ(file_id);

vinc := FA_READ(file_id);

delta_tim := tmr(FA_READ(file_id));

ok := F_CLOSE(file_id);

(* Equivalencia IL: *)

LD	'voltramp.bin'

F_ROPEN

ST	file_id

FA_READ	(* leer vstart *)

ST	vstart

LD 	file_id

FA_READ	(* leer vend *)

ST	vend

LD 	file_id

FA_READ	(* leer vinc *)

ST	vinc

LD 	file_id

FA_READ	(* leer delta_tim *)

TMR	(* conversión a un temporizador *)

ST	delta_tim

LD 	file_id

F_CLOSE

ST	ok


FA_WRITE

Argumentos:

ID	INT	número de fichero: devuelto por F_WOPEN.

IN	INT	valor analógico entero.  Para escribirse en el fichero

OK	BOO	estado de ejecución: VERDADERO si OK

Descripción:

Escribe variables ANALÓGICAS a un fichero binario.

Con este procedimiento, se realiza un acceso secuencial al fichero desde la posición anterior.

La primera llamada después de F_WOPEN escribe los primeros 4 bytes del fichero, y cada llamada avanza el puntero de escritura.

Esta función no se incluye en el simulador ISaGRAF.

(* Programa FBD *)

(* Equivalencia ST: *)

file_id := F_WOPEN('voltramp.bin');

nb_written  := 0;

nb_written := nb_written + ana(FA_WRITE(file_id,vstart));

nb_written := nb_written + ana(FA_WRITE(file_id,vend));

nb_written := nb_written + ana(FA_WRITE(file_id,vinc));

nb_written := nb_written + ana(FA_WRITE(file_id,ana(delta_tim)));

ok := F_CLOSE(file_id);

SI ( nb_written <> 4) THEN

ERROR := ERR_FILE;

END_SI;

(* Equivalencia IL: *)

LD	'voltramp.bin'

F_ROPEN

ST	file_id

LD	0

ST	nb_written

LD 	file_id	(* escribir vstart *)

FA_WRITE	vstart

ANA

ADD	nb_written

ST	nb_written

LD 	file_id	(* escribir vend *)

FA_WRITE	vend

ANA

ADD	nb_written

ST	nb_written

LD 	file_id	(* escribir vinc *)

FA_WRITE	vinc

ANA

ADD	nb_written

LD	(* escribir delta_tim *)

ANA	(* convertirlo en un entero *)

ST	ana_delta_tim

LD 	file_id

FA_WRITE	ana_delta_tim

ANA

ADD	nb_written

ST	nb_written

F_CLOSE

ST	ok

LD	nb_written

EQ	4

RETC	(* retorno si igual a 4 *)

LD	ERR_FILE	(* en otro caso error *)

ST	ERROR


FM_READ

Argumentos:

ID	INT	número de fichero: devuelto por F_ROPEN.

Q	MSG	valor de mensaje leido del fichero

Descripción:

Lee variables de MENSAJE de un fichero binario.

Para ser utilizado con F_ROPEN y F_CLOSE.

Con este procedimiento, se realiza un acceso secuencial al fichero desde la posición anterior.

La primera llamada después de F_ROPEN lee la primera cadena del fichero, y cada llamada avanza el puntero de lectura.

Las cadenas finalizan con cero (0), fin de renglón ('\n') o retorno ('\r');

Para comprobar si se ha alcanzado el final del fichero, se utiliza F_EOF.

Esta función no se incluye en el simulador ISaGRAF.

(* Programa FBD utilizando los Bloques de Gestión Ficheros *)

(* Equivalencia ST: *)

file_id := F_ROPEN('voltramp.bin');

status1 := FM_READ(file_id);

status2 := FM_READ(file_id);

IF (F_EOF(file_id)) THEN

ERROR := ERR_FILE;

unused_eof_mes := FM_READ(file_id);

END_IF;

ok := F_CLOSE(file_id);

(* Equivalencia IL: *)

LD	'voltramp.bin'

F_ROPEN

ST	file_id

FM_READ	(* leer status1 *)

ST	status1

LD 	file_id

FM_READ	(* leer status2 *)

ST	status2

LD 	file_id

F_EOF

JMPNC	CLOSE_FILE 	(* si final de fichero no saltar *)

LD	ERR_FILE

ST	ERROR

LD 	file_id

FM_READ	(* leer unused_eof_mes *)

ST	unused_eof_mes

CLOSE_FILE	LD 	file_id

F_CLOSE

ST	ok


FM_WRITE

Argumentos:

ID	INT	número de fichero: devuelto por F_WOPEN.

IN	MSG	valor de mensaje a escribir en el fichero

ok	BOO	estado de ejecución

VERDADERO si tiene éxito

Descripción:

Escribe variables de MENSAJE a un fichero binario.

Para ser utilizado con F_WOPEN y F_CLOSE.

Se escribe un mensaje en el fichero como una cadena terminada en nulo.

Con este procedimiento, se realiza un acceso secuencial al fichero desde la posición anterior.

La primera llamada después de F_WOPEN escribe la primera cadena del fichero, y cada llamada avanza el puntero de escritura.

Esta función no se incluye en el simulador ISaGRAF.

(* Programa FBD utilizando los Bloques de Gestión de Ficheros *)

(* Equivalencia ST: *)

file_id := F_WOPEN('trace.txt');

ok := FM_WRITE(file_id,'Primer mensaje');

ok := FM_WRITE(file_id,'Ultimo mensaje');

ok := F_CLOSE(file_id);

(* Equivalencia IL: *)

LD	'trace.txt'

F_WOPEN

ST	file_id

FM_WRITE	'Primer mensaje'	(* escribe el primer msg *)

ST	ok

LD 	file_id

FM_WRITE	'Ultimo mensaje'	(* escribe el segundo msg *)

ST	ok

LD 	file_id

F_CLOSE

ST	ok


Indice alfabético

-	ARWRITE	F_ROPEN	MSG	SHR
& (AND)	ASCII	F_TRIG	MUX4	SIG_GEN
*	ASIN	F_WOPEN	MUX8	SIN
/	ATAN	FA_READ	Neg	SQRT
+	AVERAGE	FA_WRITE	NOT_MASK	SR
<	BLINK	FIND	ODD	STACKINT
<=	BOO	FM_READ	OPERATE	SYSTEM
<>	CAT	FM_WRITE	OR_MASK	TAN
=	CHAR	HYSTER	POW	TMR
=1 (XOR)	CMP	INSERT	R_TRIG	TOF
>	COS	INTEGRAL	RAND	TON
>=	CTD	LEFT	REAL	TP
>=1 (OR)	CTU	LIM_ALRM	REPLACE	TRUNC
1 gain	CTUD	LIMIT	RIGHT	XOR_MASK
ABS	DAY_TIME	LOG	ROL
ACOS	DELETE	MAX	ROR
ANA	DERIVATE	MID	RS
AND_MASK	EXPT	MIN	SEL
ARCREATE	F_CLOSE	MLEN	SEMA
ARREAD	F_EOF	MOD	SHL