Language reference
Referência das linguagens

Arquitetura do projeto

Objetos comuns

Linguagem SFC

Linguagem FC

Linguagem FBD

Linguagem LD

Linguagem ST

Linguagem IL

Operadores padrão, blocos de função e funções


 Arquitetura do projeto

Um projeto ISaGRAF é dividido em várias unidades chamadas programas. Os programas do projeto estão ligados entre si em uma arquitetura semelhante a uma árvore. Programas podem ser descritos utilizando-se qualquer das seguintes linguagens gráficas ou literais: SFC, FC (Fluxograma), FBD, LD, ST ou IL.

Programas

Operações cíclicas e seqüenciais

Programas SFC secundário e FC

Funções e subprogramas

Blocos de função

Linguagens

Regras de execução


Programas

Um programa é uma unidade lógica de programação, que descreve operações entre varáveis do processo. Programas descrevem tanto operações cíclicas como seqüenciais. Programas cíclicos são executados a cada ciclo do sistema destino. A execução de programas seqüenciais segue as regras dinâmicas da linguagem SFC ou FC.

Programas estão ligados entre si em uma árvore hierárquica. Programas posicionados no topo da hierarquia são ativados pelo sistema. Subprogramas (nível mais baixo da hierarquia) são ativados pelo seu programa superior. Um programa pode ser descrito com qualquer das linguagens gráficas ou literais que seguem:

Sequential Function Chart (SFC), Diagrama SFC, para programação de alto nível

Flow Chart (FC), Fluxograma,  para programação de alto nível

Function Block Diagram (FBD), Diagrama de Blocos de Função,  para operações cíclicas complexas

Ladder Diagram (LD), Diagrama Ladder, apenas para operações booleanas

Structured Text (ST), Texto Estruturado,  para quaisquer operações cíclicas

Instruction List (IL), Lista de Instruções, para operações de nível mais baixo

O mesmo programa não pode misturar várias linguagens, exceto LD e FBD, que podem ser combinados eum um diagrama.


Operações cíclicas e seqüenciais

a hierarquia de programas está dividida em quatro seções ou grupos principais:

Início	programas executados ao início de cada ciclo do destino

Sequencial	programas seguindo regras dinâmicas de SFC ou FC

Fim	programas executados ao final de cada ciclo do destino

Functions	conjunto de subprogramas não-dedicados

Programas das seções 'Início' ou 'Fim' descrevem operações cíclicas, e não são dependentes do tempo. Programas da seção 'Sequencial' descrevem operações seqüenciais, onde o a variável tempo sincroniza explicitamente operações básicas. Programas principais da seção 'Início' são sistematicamente executados ao início de cada ciclo de execução. Programas principais da seção 'Fim' são sistematicamente executados ao final de cada ciclo de execução. Programas principais da seção 'Sequencial' são executados de acordo com regras dinâmicas de SFC ou FC.

Programas da seção 'Funções' são subprogramas que podem ser chamados por algum outro programa no projeto. Um programa da seção 'Funções' pode chamar outro programa desta seção.

Programas principais e secundários da seção sequencial devem ser descritos com linguagem SFC ou FC. Programas das seções cíclicas (Início e Fim) não podem ser descritos com linguagem SFC ou FC. Qualquer programa de qualquer seção pode possuir um ou mais subprogramas. Qualquer programa da seção sequencial pode possuir um ou mais programas secundários de linguagem SFC ou FC (de acordo com sua própria linguagem). Subprogramas não podem ser descritos com linguagem SFC ou FC.

Programas da seção Início são tipicamente utilizados para descrever operações preliminares em dispositivos de entrada para construir variáveis de alto nível filtradas. Estas variáveis são freqüentemente utilizadas pelos programas da seção Sequencial. Programas da seção Fim são tipicamente utilizados para descrever operações de segurança nas variáveis em que se operou na seção Sequencial, antes de se enviar valores aos dispositivos de saída.


Programas SFC Secundário e FC

Qualquer programa SFC da seção sequencial pode controlar outros programas SFC. Estes programas de nível mais baixo são chamados programas SFC secundários. Um programa SFC secundário é um programa paralelo que pode ser acionado, terminado, congelado ou reiniciado por seu programa principal. O programa principal e o programa secundário devem ser descritos com a linguagem SFC. Um programa SFC secundário pode ter variáveis locais e definições.

Quando um programa principal aciona um programa SFC secundário, ele coloca uma marca SFC em cada passo inicial do programa secundário. Este comando é descrito pela declaração GSTART. Quando um programa principal termina um programa SFC secundário, ele limpa todas as marcas existentes em passos do secundário. Um comando assim é descrito pela declaração GKILL.

Quando um programa principal congela um programa SFC secundário, ele limpa todas as marcas existentes no programa secundário e mantém suas posições em memória. Um comando assim é descrito pela declaração GFREEZE. Quando um programa principal reinicia um programa secundário SFC congelado, ele restaura todas as marcas limpas quando o programa secundário foi congelado. Um comando assim é descrito pela declaração GRST.

Qualquer programa FC da seção seqüencial pode controlar outros programas FC. Um programa FC principal é bloqueado (espera) durante a execução de um subprograma FC. Não é possível que operações simultâneas sejam realizadas no programa principal FC e em um de seus subprogramas FC.


Funções e subprogramas

Um subprograma ou uma execução de função é comandada pelo seu programa principal. A execução do programa principal é suspensa até que o subprograma ou a função termine.

principal	subprogramas

Qualquer programa de qualquer seção pode ter um ou mais subprogramas. Um subprograma é possuído por apenas um programa principal. Um subprograma pode ter variáveis locais e definições. Qualquer linguagem exceto SFC ou FC pode ser utilizada para descrever um subprograma. Programas da seção "Funções" são subprogramas que podem ser chamados por qualquer outro programa do projeto. Diferente de outros subprogramas, eles não são dedicados a um programa principal. Um programa da seção "Funções" pode chamar outro programa desta seção. Uma função pode ser armazenada na Biblioteca.

Advertência: O ISaGRAF não suporta recursão durante chamada de funções. Um erro de tempo de execução ocorrerá se um programa da seção "Funções" for chamado por si mesmo ou por um de seus subprogramas chamados.

Advertência: Uma função ou subprograma não "armazena" o valor local de suas variáveis locais. Uma função ou subprograma não é instanciado e portanto não pode chamar blocos de função

A interface de um subprograma deve ser definida explicitamente, com um tipo e um nome único para cada um dos parâmetros de chamada ou retorno. Para que seja suportada a convenção da linguagem ST, o parâmetro de retorno deve ter o mesmo nome do subprograma.

A tabela seguinte mostra como determinar o valor do parâmetro de retorno no corpo de um subprograma, em diferentes linguagens:

ST:	atribua o parâmetro de retorno usando o seu nome

(o mesmo nome do subprograma):

   nome_do_subprograma := <expressão>;

IL:	o valor do resultado corrente (registrador IL)

ao final da seqüência é armazenado no parâmetro de retorno:

   LD      10

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

FBD:	atribua o parâmetro de retorno utilizando seu nome:

nome_do_subprograma

LD:	use um símbolo de bobina com o nome do parâmetro de retorno:

nome_subprog


Blocos de função

Blocos de função podem usar as linguagens: LD, FBD, ST or IL. Blocos de função são instanciados. Isto significa que variáveis locais de um bloco de função são copiadas para cada instância. Quando se chama um bloco em um programa, você na verdade chama a instância do bloco: o mesmo código é chamado mas os dados utilizados são os que foram alocados para aquela instância. Valores das variáveis da instância são armazenados de um ciclo para o outro.

Advertências:

- Um bloco de função escrito em uma das linguagens IEC não pode chamar outros blocos de função: o mecanismo de instanciamento somente gerencia as variáveis locais do bloco em si. Esta é a lista de blocos de função padrão que você não pode utilizar dentro de um bloco de função 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

- Pela mesma razão, você não pode utilizar contatos normalmente abertos ou normalmente fechados, ou bobinas Liga e Desliga.

- Funções TSTART e TSTOP para disparar e parar temporizadores não podem ser utilizadas em um bloco de função para destinos 3.0x. Isto é possível para destinos desde a versão 3.20.

- Quando for necessário um laço no seu bloco de função, você deve utilizar uma variável local antes de fechar o "loop". Veja o exemplo a seguir:

Isto não irá funcionar:	Isto está correto:


Linguagens

Um programa pode ser descrito em qualquer das linguagens literais e gráficas a seguir:

Sequential Function Chart (SFC), Diagrama SFC, para programação de alto nível

Flow Chart (FC), Fluxograma,  para programação de alto nível

Function Block Diagram (FBD), Diagrama de Blocos de Função,  para operações cíclicas complexas

Ladder Diagram (LD), Diagrama Ladder, apenas para operações booleanas

Structured Text (ST), Texto Estruturado,  para quaisquer operações cíclicas

Instruction List (IL), Lista de Instruções, para operações de nível mais baixo

O mesmo programa não pode misturar várias linguagens. A linguagem utilizada para descrever um programa é escolhida quando o programa é criado, e não pode ser alterada mais tarde. A exceção é a possibilidade de combinar FBD e LD em um programa.


Regras de execução

O ISaGRAF é um sistema síncrono. Todas as operações são acionadas por um relógio. A duração de um ciclo do relógio é chamada de tempo de ciclo:

As operações básicas processadas durante um ciclo do destino são:

Este sistema torna possível:

- garantir que uma variável de entrada mantenha o mesmo valor durante um ciclo,

- garantir que um dispositivo de saída não é atualizado mais de uma vez em um ciclo,

- trabalhar com segurança na mesma variável global a partir de programas diferentes,

- estimar e controlar o tempo de resposta do aplicativo completo.


 Objetos comuns

Estas são as características principais e objetos comuns do banco de dados de programação ISaGRAF. Tais objetos podem ser utilizados em qualquer programa escrito com qualquer das linguagens: SFC, FC, FBD, LD, ST ou IL.

Tipos básicos

Expressões constantes

Variáveis

Comentários

Definições


Tipos básicos

Qualquer constante, expressão ou variável utilizada em um programa (escrito em qualquer linguagem) deve ser caracterizada por um tipo . Deve-se manter uma coerência de tipos em operações gráficas e declarações literais. Estes são os tipos básicos disponíveis para programação:

BOOLEANO:	valor lógico (true ou false)

ANALÓGICO:	valor contínuo inteiro ou real (flutuante)

TEMPORIZADOR:	valor de tempo

MENSAGEM:	cadeia de caracteres

Observação: Temporizadores podem conter valores menores que um dia e não podem ser utilizados para armazenar datas.


Expressões constantes

Expressões constantes  são relativas a um tipo. A mesma notação não pode ser utilizada para representar expressões constantes de tipos diferentes.

Expressões constantes booleanas

Expressões constantes analógicas inteiras

Expressões constantes analógicas reais

Expressões constantes do tipo temporizador

Expressões constantes do tipo mensagem


Expressões constantes booleanas

Existem apenas duas expressões constantes booleanas:

TRUE	é equivalente ao valor inteiro 1

FALSE	é equivalente ao valor inteiro 0

"As palavras-chave "True" e "False" não são sensíveis a maiúsculas e minúsculas.


Expressões constantes analógicas inteiras

Expressões constantes inteiras representam valores inteiros longos com sinal (32 bit):

de -2147483647 a +2147483647

Constantes analógicas inteiras podem ser expressas em uma das bases a seguir, e devem começar com um prefixo que identifica a base utilizada:

Base	Prefixo	Exemplo

DECIMAL	(nenhum)	-908

HEXADECIMAL	"16#"	16#1A2B3C4D

OCTAL	"8#"	8#1756402

BINÁRIA	"2#"	2#1101_0001_0101_1101

O caractere sublinhado ('_') pode ser utilizado para separar grupos de algarismos. Ele não tem nenhum significado especial, e é utilizado apenas para facilitar a visualização do valor da expressão.


Expressões constantes analógicas reais

Expressões constantes analógicas reais podem ser escritas tanto em notação decimal como em notação científica. O ponto decimal ('.') separa as partes inteira e decimal. O ponto decimal deve ser utilizado para diferenciar uma constante real de uma inteira. A notação científica utiliza a letra 'E' ou 'F' para separar a mantissa do expoente. O expoente de uma expressão real em notação científica deve ser um valor inteiro com sinal de -37 a +37. A seguir estão exemplos de expressões constantes analógicas reais:

3.14159	-1.0E+12

+1.0	1.0F-15

-789.56	+1.0E-37

A expressão "123" não representa uma expressão constante real. Sua representação correta é "123.0".


Expressões constantes do tipo temporizador

Expressões constantes do tipo temporizador representam valores de tempo de 0 segundos a 23h59m59s999ms. A menor unidade permitida é o milisegundo. As unidades padrão de tempo utilizadas em expressões constantes são:

Hora	A letra "h" deve vir após o número de horas

Minuto	A letra "m" deve vir após o número de minutos

Segundo	A letra "s" deve vir após o número de segundos

Milisegundo	As letras "ms" devem vir após o número de milisegundos

A expressão constante do tipo temporizador deve começar com o prefixo "T#" ou "TIME#". Prefixos e letras que denotam unidades não são sensíveis a maiúsculas e minúsculas. Pode-se omitir unidades. Estes são exemplos de expressões constantes do tipo temporizador:

T#1H450MS	1 hora, 450 millisegundos

time#1H3M	1 hora, 3 minutos

A expressão "0" não representa um valor de tempo, e sim uma constante analógica.


Expressões constantes do tipo mensagem

Expressões constantes do tipo mensagem representam cadeias de caracteres. Os caracteres devem ser precedidos de um sinal "`" e seguidos por um apóstrofo. Por exemplo::

'ISTO É UMA MENSAGEM'

Advertência: O caractere apóstrofo ''' não pode ser utilizado dentro de uma expressão constante de cadeia de caracteres. Uma cadeia de caracteres deve estar contida em uma linha do código fonte do programa. Seu tamanho não pode exceder 255 caracteres, incluindo espaços.

Cadeias vazias são representadas por dois apóstrofos, sem nenhum espaço ou caractere de tabulação entre eles:

''   (* isto é uma cadeia vazia *)

O caractere especial cifrão ('$'), seguido por outros caracteres especiais, pode ser utilizado em uma cadeia para representar um caractere não imprimível:

Seqüência	Significado	ASCII (hexa)	Exemplo

$$	caractere '$'	16#24	'Eu paguei  $$5 por isto'

$'	apóstrofo	16#27	'Digite $'S$' fpara SIM'

$L	line feed	16#0a	'próxima $L linha'

$R	carriage return	16#0d	'   llo $R He'

$N	nova linha	16#0d0a	'Isto é uma linha$N'

$P	nova página	16#0c	'última linha $P primeira linha'

$T	tabulação	16#09	'nome$Ttamanho$Tdata'

$hh   (*)	qualquer caractere	16#hh	'ABCD = $41$42$43$44'

(*) "hh" é o valor hexadecimal do código ASCII para o caractere.


Variáveis

Variáveis podem ser LOCAIS a um programa, ou GLOBAIS. Variáveis locais podem ser utilizadas por apenas um programa. Variáveis globais podes ser utilizadas em qualquer programa do projeto.

Palavras reservadas

Variáveis diretamente representadas

Variáveis booleanas

Variáveis analógicas

Variáveis do tipo temporizador

Variáveis do tipo mensagem

Os nomes de variáveis  devem seguir as seguintes regras:

- O nome não pode exceder 16 caracteres

- O primeiro caractere deve ser uma letra

- Os caracteres seguintes podem ser letras, números ou o caractere sublinhado


Palavras reservadas

Uma lista das palavras reservadas é mostrada a seguir. Tais identificadores não podem ser utilizados para dar nome a um programa, variável, função "C" ou bloco de função.

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 as palavras-chave iniciadas por um caractere sublinhado ('_') são palavras-chave internas e não podem ser utilizadas em instruções textuais.


Variáveis representadas diretamente

O ISaGRAF permite o uso de variáveis representadas diretamente no código fonte dos programa para representar um canal livre. Canais livres são aqueles que não estão ligados a uma variável de E/S declarada. O identificador de uma variável representada diretamente sempre começa com o caractere "%".

A seguir estão as convenções de nome de uma variável diretamente representada para um canal ou uma placa. "s" é o número do slot da placa. "c" é o número do canal.

%IXs.c	canal livre de uma placa de entrada booleana

%IDs.c	canal livre de uma placa de entrada inteira

%ISs.c	canal livre de uma placa de entrada do tipo mensagem

%QXs.c	canal livre de uma placa de saída booleana

%QDs.c	canal livre de uma placa de saída inteira

%QSs.c	canal livre de uma placa de saída do tipo mensagem

A seguir estão as convenções de nome de um uma variável representada diretamente para um canal de um equipamento complexo. "s" é o número do slot do equipamento. "b" é o índice da placa dentro do equipamento complexo. "c" é o número do canal.

%IXs.b.c	canal livre de uma placa de entrada booleana

%IDs.b.c	canal livre de uma placa de entrada inteira

%ISs.b.c	canal livre de uma placa de entrada do tipo mensagem

%QXs.b.c	canal livre de uma placa de saída booleana

%QDs.b.c	canal livre de uma placa de saída inteira

%QSs.b.c	canal livre de uma placa de saída do tipo mensagem

Exemplos:

%QX1.6	Sexto canal da placa número 1 (saída booleana)

%ID2.1.7	Sétimo canal da placa número 1 no equipamento número 2 (entrada inteira)

Uma variável representada diretamente não pode ser do tipo real.


Variáveis booleanas

Booleano significa lógico. Tais variáveis podem ter um dos dois valores booleanos: TRUE ou FALSE. Variáveis booleanas são tipicamente utilizadas em expressões booleanas. Variáveis booleanas podem ter um dos seguintes atributos:

Interna:	variável de memória atualizada pelo programa

Entrada:	variável conectada a um dispositivo de entrada (atualizada pelo sistema)

Saída:	variável conectada a um dispositivo de saída

Advertência: Quando se declara uma variável booleana, cadeias de caracteres podem ser definidas para substituir os valores 'true' e 'false' durante a depuração. Estas cadeias não podem ser utilizadas em programas a menos que tenham sido inseridas como 'definições' para a linguagem.


Variáveis analógicas

Analógico significa contínuo. Tais variáveis possuem valores inteiros ou reais (flutuantes) com sinal. Os formatos disponíveis para uma variável analógica são:

Inteiro	Inteiro de 32 bits com sinal: de -2147483647 a +2147483647

Real    	valor de ponto flutuante padrão IEEE 32 (precisão simples)

1 bit de sinal + 23 bits de mantissa + 8 bits de expoente

O valor do expoente deve ser um inteiro entre -37 e +37, inclusive. Variáveis analógicas podem ter um dos seguintes atributos:

Interna:	variável de memória atualizada pelo programa

Entrada:	variável conectada a um dispositivo de entrada (atualizada pelo sistema)

Saída:	variável conectada a um dispositivo de saída

Observação: Quando uma variável real é conectada a um dispositivo de E/S, o driver de E/S correspondente opera com o valor inteiro equivalente.

Advertência: Variáveis analógicas ou expressões constantes inteiras e reais não podem ser misturadas na mesma expressão analógica.


Variáveis do tipo temporizador

Variáveis temporizador contém valores de tempo e são utilizadas em expressões de tempo. Um valor de temporizador não pode exceder 23h59m59s99 e não pode ser negativo. Variáveis temporizador são armazenadas em palavras de 32 bits. A representação interna é um número positivo de milisegundos.

Advertência: Variáveis temporizador não podem ter atributos ENTRADA ou SAÍDA.

Variáveis temporizador podem ser automaticamente atualizadas pelo sistema ISaGRAF. Quando um temporizador está ativo, seu valor é automaticamente incrementado de acordo com o relógio de tempo real do sistema destino. As seguintes declarações da linguagem ST podem ser utilizadas para controlar um temporizador:

TSTART	inicia a atualização automática de um temporizador

TSTOP	pára a atualização automática de um temporizador


Variáveis do tipo mensagem

Variáveis do tipo mensagem contém cadeias de caracteres. O tamanho da cadeia pode mudar durante as operações de processamento. O tamanho de uma variável do tipo mensagem não pode exceder a capacidade (tamanho máximo) especificada quando a variável é declarada. A capacidade de uma mensagem é limitada a 255 caracteres. Variáveis do tipo mensagem podem ter um dos seguintes atributos:

Interna:	variável de memória atualizada pelo programa

Entrada:	variável conectada a um dispositivo de entrada (atualizada pelo sistema)

Saída:	variável conectada a um dispositivo de saída

Variáveis do tipo mensagem podem conter qualquer caractere da tabela ASCII padrão (código ASCII de 0 a 255). O caractere nulo pode existir em uma cadeia de caracteres. Algumas funções "C" da biblioteca padrão ISaGRAF não operam corretamente com cadeias que contém caracteres nulos (0).


Comentários

Comentários podem ser inseridos livremente em linguagens literais como ST e IL. Um comentário deve iniciar com os caracteres especiais "(*" e terminar com os caracteres "*)". Comentários podem ser inseridos em qualquer lugar dentro de um programa ST, e podem ser escritos em mais de uma linha.

Exemplos de comentários:

contador := ivalue;   (* atribui ao contador principal *)

(* isto é um comentário

em duas linhas *)

c := contador (* você pode colocar comentários em qualquer lugar *) + base_value + 1;

Comentários intercalados não podem ser utilizados. Isto significa que a seqüência de caracteres "(*" não pode ocorrer dentro de um comentário.

Advertência: A linguagem IL somente aceita comentários como o último componente de uma linha de instrução.


Definições

O ISaGRAF permite a redefinição de expressões constantes, expressões booleanas true e false, palavras-chave ou expressões complexas em ST. Para isto, um nome identificador deve ser dado para a expressão correspondente. Por exemplo:

YES	é	TRUE

PI	é	3.14159

OK	é	(auto_mode AND NOT (alarm))

Quando uma equivalência como esta é definida, seu identificador pode ser utilizado em qualquer lugar em um programa ST, em substituição à expressão representada. Este é um exemplo de programação ST utilizando definições:

If OK Then

   angle := PI / 2;

   isdone := YES;

End_if;

Definições podem ser LOCAIS a um programa, GLOBAIS, ou COMUNS.

Definições locais podem ser utilizadas por apenas um programa.

Definições globais podem ser utilizadas por qualquer programa em um projeto.

Definições comuns podem ser utilizadas em qualquer programa de qualquer projeto.

Note que definições comuns podem ser armazenadas separadamente com o Gerenciador de Diretório.

Advertência: Quando o mesmo identificador é definido duas vezes com diferentes equivalências em ST, a última expressão definida é utilizada. Por exemplo:

Definição:	OPEN	é	FALSE

OPEN	é	TRUE

significa:	OPEN	é	TRUE

Nomes de definições devem seguir as seguintes regras:

- O nome não pode exceder 16 caracteres

- O primeiro caractere deve ser uma letra

- Os caracteres seguintes podem ser letras, números ou o caractere sublinhado

Advertência: Uma definição não pode utilizar uma outra definição dentro de seu significado. Por exemplo, não é possível fazer:

PI	é	3.14159

PI2 	é	PI*2

escreva a definição completa utilizado constantes ou variáveis e operações:

PI2 	é	6.28318


IL language
 Linguagem IL

Lista de Instruções (Instruction List), ou IL, é uma linguagem de baixo nível. Ela é altamente eficiente para aplicações menores ou para otimização de partes de uma aplicação. As suas instruções sempre se relacionam ao resultado corrente (ou registrador IL). O operador indica que a operação deve ser realizada entre o valor corrente e o operando. O resultado da operação é armazenado novamente no resultado corrente.

Sintaxe geral IL

Operadores IL


IL main syntax
Sintaxe geral IL

Um programa IL é uma lista de instruções. Cada instrução deve iniciar em uma nova linha, e deve conter um operador, completado com modificadores opcionais e, se necessário para a operação específica, um ou mais operandos, separados por vírgulas (','). Um rótulo seguido por um sinal de dois pontos (':') pode preceder a instrução. Se um comentário é associado à instrução, ele deve ser o último componente da linha. Comentários sempre começam com '(*' e terminam com '*)'. Linhas vazias podem ser inseridas entre instruções. Comentários podem ser inseridos em linhas vazias.

Rótulos

Modificadores de operadores

Operações em espera

Abaixo estão exemplos de linhas de instrução:

Rótulo	Operador	Operando	Comentários

Start:	LD	IX1	(* botão *)

ANDN	MX5	(* comando *)

ST	QX2	(* liga motor *)


Labels
Rótulos

Um rótulo  seguido por um sinal de dois pontos (':') pode preceder a instrução. Um rótulo pode ser colocado em uma linha vazia. Rótulos são utilizados como operandos em algumas instruções como desvios. Os nomes de rótulos devem seguir as seguintes regras:

- o nome não pode exceder 16 caracteres

- o primeiro caractere deve ser uma letra

- os seguintes caracteres devem ser letras, números ou o caractere "_"

O mesmo nome não pode ser utilizado para mais de um rótulo no mesmo programa IL. Um rótulo pode ter o mesmo nome que uma variável.


Operator modifiers
Modificadores de operadores

Os modificadores disponíveis são mostrados a seguir. . O caractere modificador deve completar o nome do operador, sem caracteres em branco entre eles:

N	inversão booleana do operando

(	operação em espera

C	operação condicional

O modificador 'N' indica uma inversão booleana do operando. Por exemplo, a instrução ORN IX12 é interpretada como: resultado := resultado OR NOT (IX12).

O modificador "abre parênteses"  '(' indica que a execução da instrução deve ser adiada até que o operador "fecha parênteses" ')' seja encontrado.

O modificador 'C' indica que a instrução associada deve ser executada somente se o resultado corrente tiver o valor booleano TRUE (diferente de 0 para valores não booleanos). O modificador 'C' pode ser combinado com o modificador 'N' para indicar que a instrução deve ser executada somente se o resultado corrente tiver o valor booleano FALSE (ou 0 para valores não booleanos).


Delayed operations
Operações em espera

Como existe apenas um registrador IL (resultado corrente), pode ser necessário colocar "em espera"  algumas operações, de modo que a ordem de execução das instruções possa ser alterada. Parênteses são utilizados para indicar operações em espera:

'('	é um modificador	indica que a operação deve entrar em espera

')'	é um operador	executa a operação em espera

O sinal modificador "abre parênteses"  '(' indica que a execução da instrução deve ser adiada até que o operador "fecha parênteses" ')' seja encontrado. Por exemplo, a seguinte seqüência:

AND(	IX12

OR	IX35

)

é interpretada como:

resultado := resultado AND ( IX12 OR IX35 )


IL operators
Operadores IL

  A seguinte tabela resume os operadores padrão da linguagem IL:

Operador	Modificadores	Operando	Descrição

LD	N	Variável, constante	Carrega operando

ST	N	Variável	Armazena o resultado corrente

S	variável BOO	Atribui TRUE

R	variável BOO	Atribui FALSE

CAL	C   N	Nome da instância FB	Chama um bloco de função

JMP	C   N	Rótulo	Desvia para o rótulo

RET	C   N	Retorna de subprograma

 ) 	Executa operação em espera

Function	Chama função ou subprograma

AND	N   (	BOO	E booleano

&	N   (	BOO	E booleano

OR	N   (	BOO	OU booleano

XOR	N   (	BOO	OU exclusivo

ADD	(	variável, constante	Adição

SUB	(	variável, constante	Subtração

MUL	(	variável, constante	Multiplicação

DIV	(	variável, constante	Divisão

GT	(	variável, constante	Comparação: >

GE	(	variável, constante	Comparação: >=

EQ	(	variável, constante	Comparação: =

LE	(	variável, constante	Comparação: <=

LT	(	variável, constante	Comparação: <

NE	(	variável, constante	Comparação: <>

Outros operadores podem ser encontrados na seção "operadores padrão, blocos de função e funções".


LD operator
Operador LD

Operação	carrega um valor no resultado corrente

Modificadores permitidos	N

Operando	expressão constante

variável interna, de entrada ou de saída

Exemplo:

(* EXEMPLOS DE OPERAÇÕES LD *)

LDex:	LD	false	(* resultado := FALSE constante booleana *)

LD	true	(* resultado := TRUE constante booleana *)

LD	123	(* resultado := constante inteira *)

LD	123.1	(* resultado := constante real *)

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

LD	boo_var1	(* resultado := variável booleana *)

LD	ana_var1	(* resultado := variável analógica *)

LD	tmr_var1	(* resultado := variável temporizador *)

LDN	boo_var2	(* resultado := NOT ( variável booleana ) *)


ST operator
Operador ST

Operação	armazena o resultado corrente em uma variável

o resultado corrente não é modificado por esta operação

Modificadores permitidos	N

Operando	variável interna ou de saída

Exemplo:

(* EXEMPLOS DE OPERAÇÕES ST*)

STboo:	LD	false

ST	boo_var1	(* boo_var1 := FALSE *)

STN	boo_var2	(* boo_var2 := TRUE *)

STana:	LD	123

ST	ana_var1	(* ana_var1 := 123 *)

STtmr:	LD	t#12s

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


S operator
Operador S

Operação:	armazena o valor booleano TRUE em uma variável booleana, se o resultado corrente tiver o valor booleano TRUE. Nenhuma operação é processada se o resultado corrente é FALSE. O resultado corrente não é modificado por esta operação

Modificadores permitidos:	(nenhum)

Operando:	variável booleana de saída ou interna

Exemplo:

(* EXEMPLOS DE OPERAÇÕES S *)

SETex:	LD	true	(* resultado corrente := TRUE *)

S	boo_var1	(* boo_var1 := TRUE *)

(* resultado corrente não é modificado *)

LD	false	(* resultado corrente := FALSE *)

S	boo_var1	(* nada é feito - boo_var1 inalterada *)


R operator
Operador R

Operação	armazena o valor booleano FALSE em uma variável booleana, se o resultado corrente tem o valor booleano TRUE. Nenhuma operação é processada se o resultado corrente é FALSE. O resultado corrente não é modificado por esta operação

Modificadores permitidos	(nenhum)

Operando	variável booleana de saída ou interna

Exemplo:

(* EXEMPLOS DE OPERAÇÕES R *)

RESETex:	LD	true	(* resultado corrente := TRUE *)

R	boo_var1	(* boo_var1 := FALSE *)

(* resultado corrente não é modificado *)

ST	boo_var2	(* boo_var2 := TRUE *)

LD	false	(* resultado corrente := FALSE *)

R	boo_var1	(* nada é feito - boo_var1 inalterada *)


JMP operator
Operador JMP

Operação	desvia para o rótulo especificado

Modificadores permitidos	C   N

Operando	rótulo definido no mesmo programa IL

Exemplo:

(* o seguinte exemplo testa o valor de um seletor analógico (0 or 1 or 2) 	*)

(* para ligar uma dentre 2 sa;idas booleanas. O teste "é igual a zero 0" é feito com	*)

(* o operador JMPC 	*)

JMPex:	LD	selector	(* selector é 0 ou 1 ou 2 *)

BOO	(* conversão para booleana *)

JMPC	test1	(* se selector = 0 então *)

LD	true

ST	bo0	(* bo0 := true *)

JMP	JMPend	(* fim do programa *)

test1:	LD 	selector

SUB	1	(* decrementa selector:  agora é 0 ou 1 *)

BOO	(* conversão para booleana *)

JMPC	test2	(* se selector = 0 então *)

LD	true

ST	bo1	(* bo1 := true *)

JMP	JMPend	(* fim do programa *)

test2:	LD	true	(* última possibilidade *)

ST	bo2	(* bo2 := true *)

JMPend:	(* fim do programa IL *)


RET operator
Operador RET

Operação	termina a lista de instruções corrente. Se a IL é um subprograma, o resultado corrente é retornado ao programa que o chamou.

Modificadores permitidos	C   N

Operando	(nenhum)

Exemplo:

(* o seguinte exemplo testa o valor de um seletor analógico (0 ou 1 ou 2) 	*)

(* para ligar uma dentre 2 saídas booleanas. O teste "é igual a zero 0" é feito com	*)

(* o operador JMPC 	*)

JMPex:	LD	selector	(* selector é 0 ou 1 ou 2 *)

BOO	(* conversão para booleana *)

JMPC	test1	(* se selector = 0 então *)

LD	true

ST	bo0	(* bo0 := true *)

RET	(* end - return 0 *)

(* decrementa selector *)

test1:	LD 	selector

SUB	1	(* selector agora é 0 ou 1 *)

BOO	(* conversão para booleana *)

JMPC	test2	(* se selector = 0 então *)

LD	true

ST	bo1	(* bo1 := true *)

LD	1	(* carrega valor real de selector *)

RET	(* end - return 1 *)

(* última possibilidade *)

test2:	RETNC	(* retorna se selector tiver *)

(* um valor inválido *)

LD	true

ST	bo2	(* bo2 := true *)

LD	2	(* carrega valor real de selector *)

 	(* end - return 2 *)


")" operator
Operador ")"

Operação	executa uma operação em espera. A operação em espera  foi marcada por um '('

Modificadores permitidos	(nenhum)

Operando	(nenhum)

Exemplo:

(* O seguinte programa intercala operações em espera*)

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

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

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

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

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

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

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

)	(* execute ADD atrasado*)

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

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

ST	res	(* armazena resultado corrente na variável res *)


Calling sub-programs or functions
Chamando subprogramas ou funções

Um subprograma ou função (escrito em linguagem IL, ST, LD, FBD ou "C") é chamado a partir da linguagem IL com o uso de seu nome como operador.

Operação	executa um subprograma ou função  - o valor retornado pelo subprograma ou função é armazenado no resultado corrente da IL

Modificadores permitidos	(nenhum)

Operando	O primeiro parâmetro de chamada deve estar armazenado no resultado corrente antes da chamada. Os seguintes são expressos no campo "operando", separados por vírgulas.

Exemplo:

(* Programa que chama : converte um valor analógico em um valor de tempo *)

Main:	LD	bi0

SUBPRO	bi1,bi2	(* chama subprograma para obter um valor analógico *)

ST	result	(* result := valor devolvido pelo subprograma *)

GT	vmax	(* testa valor máximo *)

RETC	(* retorna se extrapolou *)

LD	result

MUL	1000	(* converte segundos em milisegundos *)

TMR	(* converte para um temporizador *)

ST	tmval	(* armazena valor convertido em um temporizador *)

(* Subprograma chamado, 'SUBPRO' , processa o valor analógico *)

(* dados como valores binários em três variáveis booleanas: in0, in1, in2 são três parâmetros de entrada booleanos do 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 o valor corrente para chamada do programa *)


Calling function blocks: CAL operator
Chamando blocos de função: o operador CAL

Operação	chama um bloco de função

Modificadores permitidos	C   N

Operando	Nome da instância do bloco de função.

Os parâmetros de entrada dos blocos devem ser atribuídos antes da chamada, com o uso sequencial de operações LD/ST.

Parâmetros de saída são conhecidos se utilizados.

Exemplo1:

(* Chamando bloco de função SR: SR1 é uma instância de SR *)

LD	auto_mode

AND	start_cmd

ST	SR1.set1

LD	stop_cmd

ST	SR1.reset

CAL	SR1

LD	SR1.Q1

ST	command

(* Equivalente em FBD: *)

Exemplo 2

(* Supomos que R_TRIG1 seja uma instância do bloco R_TRIG e CTU1 seja uma instância do bloco 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

(* Equivalente em FBD: *)


ST language
 Linguagem ST

O ST (Texto Estruturado) é uma linguagem estruturada de alto nível projetada para processos de automação. Esta linguagem é utilizada principalmente para implementar procedimentos complexos que não podem ser facilmente expressos com linguagens gráficas. ST é a linguagem padrão para a descrição das ações dentro das etapas e condições associadas a transições da linguagem SFC.

Sintaxe geral ST

Expressões e parênteses

Chamadas de funções e blocos de função

Operações booleanas específicas em ST

Comandos básicos ST

Extensões ST


ST main syntax
Sintaxe geral ST

Um programa ST é uma lista de comandos ST. Cada comando termina com um separador ponto-e-vírgula (";"). Nomes utilizados no código fonte (identificadores de variáveis, constantes, palavras-chave da linguagem...) são separados por separadores inativos (espaço, fim de linha, caracteres de tabulação...) ou por separadores ativos, que têm um significado bem definido (por exemplo, o separador ">" indica uma comparação "maior que"). Comentários  podem ser livremente inseridos no texto. Um comentário deve iniciar com "(*" e terminar com "*)". Cada comando  termina com um separador ponto-e-vírgula (";"). Estes são os tipos básicos de comandos ST:

- atribuição (variável := expressão;)

- chamada de subprograma ou função

- chamada de bloco de função

- seleção (IF, THEN, ELSE, CASE...)

- iteração (FOR, WHILE, REPEAT...)

- controle (RETURN, EXIT...)

- comandos especiais para ligação com outras linguagens como SFC.

Separadores inativos  podem ser inseridos livremente entre separadores ativos, expressões constantes e identificadores. Os separadores inativos ST são os caracteres Espaço, Tab e Fim de linha. De maneira diferente de outras linguagens formatadas por linha como IL, finais de linha podem ser inseridos em qualquer lugar no programa. As regras a seguir devem ser seguidas quando se usa separadores inativos para melhorar a clareza do programa ST.:

- Não escreva mais de um comando em uma linha

- Use Tabs para indentar comandos complexos

- Insira comentários para aumentar a clareza de linhas ou parágrafos

Clareza de código fonte - exemplos:

Pouca clareza	Bastante clareza
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 : número de interações *) (* i: índice da sintaxe FOR *) (* cond: condição do processo *) imax := max_ite; cond := X12; if not (cond) then     return; end_if; (* loop do processo *) for i := 1 to max_ite do     if i <> 2 then         Spcall ();     end_if; end_for;


Expressão and parentheses
Expressões e parênteses

Expressões ST combinam operadores ST e operandos variáveis ou constantes. Para cada uma das expressões (combinando operandos com um operador ST), o tipo dos operandos deve ser o mesmo. Esta expressão terá o mesmo tipo dos seus operandos, e pode ser utilizada em uma expressão mais complexa. Pro exemplo:

(boo_var1 AND boo_var2)	Tem tipo BOO

not (boo_var1)	Tem tipo BOO

(sin (3.14) + 0.72)	Tem tipo REAL ANALOG

(t#1s23 + 1.78)	é uma expressão inválida

Parênteses são utilizados para isolar sub partes da expressão, e para determinar explicitamente a ordem da operações. Quando não há parênteses em uma expressão complexa, a seqüência de operação é dada implicitamente pela precedência padrão entre operadores ST. Por exemplo:

2 + 3 * 6 	igual a 2+18=20	operador de multiplicação tem precedência

(2+3) * 6	igual a 5*6=30	precedência é dada pelos parênteses

Advertência: Um número máximo de 8 níveis de parênteses podem ser encadeados dentro de uma expressão.


Function or function block calls
Chamadas de função ou blocos de função

Chamadas de função padrão ST podem ser utilizadas para cada um dos seguintes objetos:

- Subprogramas

- Funções da biblioteca e blocos de função escritos em linguagens IEC

- Funções "C" e blocos de função

- Funções de conversão de tipo

Chamando subprogramas ou funções

Chamando blocos de função


Calling subprogramas or functions
Chamando subprogramas ou funções

Nome:	nome do subprograma chamado

ou função da biblioteca  escrita em linguagem IEC ou em "C"

Significado:	chama um subprograma ST, IL, LD ou FBD ou função ou um função "C"

e obtém seu valor de retorno

Sintaxe:	<variável> := <subprog> (<par1>, ... <parN> );

Operandos:	O tipo do valor de retorno e parâmetros da chamada deve seguir a

interface definida para o subprograma.

Valor de retorno:	valor retornado pelo subprograma

Chamadas a subprogramas podem ser utilizadas em qualquer expressão. Elas também podem ser utilizadas em transições SFC.

Exemplo1: Chamada de subprograma

(* Programa principal ST *)

(* obtém um varo analógico e converte para um valor de tempo limitado *)

ana_timeprog := SPlimit ( tprog_cmd );

appl_timer := tmr (ana_timeprog * 100);

(* Chamou programa FBD chamado 'SPlimit' *)

Exemplo2: Chamada de função

(* funções utilizadas em expressões complexas: min, max, right, mlen e left são funções "C" padrão *)

limited_valor := min (16, max (0, input_valor) );

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


Calling function blocks
Chamando blocos de função

Nome:	nome da instância do bloco de função

Significado:	chama um bloco de função da biblioteca ISaGRAF ou da biblioteca do usuário e acessa seus parâmetros de retorno

Sintaxe:	(* chamada do bloco de função *)

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

(* obtém seus parâmetros de retorno *)

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

...

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

Operandos:	Parâmetros são expressões de tipos iguais aos tipos dos parâmetros

especificados para o bloco de função

Valor de retorno:	Veja Sintaxe para obter os parâmetros de retorno.

Consulte a biblioteca ISaGRAF para obter o significado e tipo de cada parâmetros do bloco. A instância do bloco de função (nome da cópia) deve ser declarada no dicionário.

Exemplo :

(* Programa ST chamando um bloco de função *)

(* declare a instância do bloco no dicionário: *)

(* trigb1 : bloco R_TRIG - detecção de borda de subida*)

(* ativação de bloco de função da linguagem ST *)

trigb1 (b1);

(* acesso aos parâmetros de retorno*)

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


ST specific boolean operators
Operações booleanas específicas ST

Os seguintes operadores booleanos são específicos à linguagem ST:

REDGE	detecção de borda de subida

FEDGE	detecção de borda de descida

Outros operadores booleanos padrão como:

NOT	inversão booleana

AND (&)	E lógico

OR	OU lógico

XOR	OU exclusivo lógico

podem ser utilizados. A descrição deles pode ser encontrada na seção 'Operadores padrão, blocos de função e funções'.


"REDGE" operator
Operador "REDGE"

Nome:	REDGE

Significado:	avalia a borda de subida de uma expressão booleana completa

Sintaxe:	<borda> := REDGE ( <expressão_boo >,< variável_memo> );

Operandos:	primeiro operando é qualquer variável booleana ou expressão complexa

segundo operando é uma variável booleana interna utilizada para armazenar o último estado da expressão

Valor de retorno:	TRUE quando a expressão muda de FALSE para TRUE

FALSE para todos os outros casos

A borda de subida não pode ser detectada mais do que uma vez durante o mesmo ciclo de execução, utilizando-se o operador REDGE. Este operador pode ser utilizado para descrever a condição associada a uma transição SFC.

Advertência: A variável booleana "memo" utilizada para armazenar o último estado da expressão não pode ser utilizada como acionador de bordas para diferentes expressões.

Quando a expressão é uma variável booleana de nome "xxx", uma variável interna única de nome  "EDGE_xxx" deve ser declarada e usada em expressões REDGE para esta variável. Este método assegura que a variável de memória não será sobrescrita durante outras operações REDGE.

Exemplo:

(* Programa ST utilizando operador REDGE *)

(* este programa conta as bordas de subida de uma entrada booleana *)

(* Bi120 é uma variável booleana de entrada *)

(* Edge_Bi120 é a memória do estado da variável Bi120 *)

If REDGE (Bi120, Edge_Bi120) Then

Counter := Counter + 1;

End_if;

Obs: este operador não está na norma IEC1131-3. Você pode preferir o uso do bloco padrão R_TRIG. Este operador foi mantido por razões de compatibilidade.


"FEDGE" operator
Operador "FEDGE"

Nome:	FEDGE

Significado:	avalia a borda de descida de uma expressão booleana completa

Sintaxe:	<borda> := FEDGE ( <expressão_boo >,< variável_memo> );

Operandos:	primeiro operando é qualquer variável booleana ou expressão complexa

segundo operando é uma variável booleana interna utilizada para armazenar o último estado da expressão

Valor de retorno:	TRUE quando a expressão muda de TRUE para FALSE

FALSE para todos os outros casos

A borda de descida não pode ser detectada mais do que uma vez durante o mesmo ciclo de execução, utilizando-se o operador FEDGE. Este operador pode ser utilizado para descrever a condição associada a uma transição SFC.

Advertência: A variável booleana "memo" utilizada para armazenar o último estado da expressão não pode ser utilizada como acionador de bordas para diferentes expressões.

Quando a expressão é uma variável booleana de nome "xxx", uma variável interna única de nome  "EDGE_xxx" deve ser declarada e usada em expressões FEDGE para esta variável. Este método assegura que a variável de memória não será sobrescrita durante outras operações FEDGE.

Exemplo:

(* Programa ST utilizando operador FEDGE *)

(* este programa conta as bordas de descida de uma entrada booleana *)

(* Bi120 é uma variável booleana de entrada *)

(* Edge_Bi120 é a memória do estado da variável Bi120 *)

If FEDGE (Bi120, Edge_Bi120) Then

Counter := Counter + 1;

End_if;

Obs: este operador não está na norma IEC1131-3. Você pode preferir o uso do bloco padrão F_TRIG. Este operador foi mantido por razões de compatibilidade.


ST basic statements
Comandos básicos ST

Os comando básicos da linguagem ST são:

Atribuição

Comando RETURN

Estrutura IF-THEN-ELSIF-ELSE

Comando CASE

Comando de iteração WHILE

Comando de iteração REPEAT

Comando de iteração FOR

Comando EXIT


Assignment
Atribuição

Nome:	:=

Significado:	atribui uma variável a uma expressão

Sintaxe:	<variável> := < expressão> ;

Operandos:	variável deve ser interna ou de saída

variável e expressão devem ter o mesmo tipo

A expressão pode ser uma chamada a um subprograma ou uma função da biblioteca ISaGRAF.

Exemplo:

(* Programa ST com atribuições *)

(* variável <<= variável *)

bo23 := bo10;

(* variável <<= expressão *)

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

result := (100 * input_valor) / scale;

(* atribuição de valor de retorno de subprograma *)

rc := PSelect ( );

(* atribuição de chamada de função *)

limited_valor := min (16, max (0, input_valor) );


RETURN statement
Comando RETURN

Nome:	RETURN

Significado:	termina a execução do programa corrente

Sintaxe:	RETURN ;

Operandos:	(nenhum)

Em um bloco SFC, o comando return indica o final da execução de apenas aquele bloco.

Exemplo:

(* Especificação FBD do programa: contador programável *)

(* Implementação ST do programa, utilizando comando RETURN  *)

If not (CU) then

Q := false;

CV := 0;

RETURN;   (* termina o programa *)

end_if;

if R then

CV := 0;

else

if (CV < PV) then

CV := CV + 1;

end_if;

end_if;

Q := (CV >= PV);


IF-THEN-ELSIF-ELSE statement
Comando IF-THEN-ELSIF-ELSE

Nome:	IF ... THEN ... ELSIF ... THEN ... ELSE ... END_IF

Significado:	executa uma de duas listas de comandos ST

seleção é feita de acordo com o valor de uma expressão booleana

Sintaxe:	IF <expressão_booleana> THEN

   <comando> ;

   <comando> ;

   ...

ELSIF <expressão_booleana> THEN

   <comando> ;

   <comando> ;

   ...

ELSE

   <comando> ;

   <comando> ;

   ...

END_IF;

Os comandos ELSE e ELSIF são opcionais. Se o comando ELSE não é utilizado, nenhuma instrução é executada quando a condição é FALSE.

Exemplo:

(* Programa ST utilizando comando 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;

(* Estrutura If sem ELSE *)

If overflow THEN

alarm_level := true;

END_IF;


CASE statement
Comando CASE

Nome:	CASE ... OF ... ELSE ... END_CASE

Significado:	executa uma entre várias listas de comandos ST

a seleção é feita de acordo com uma expressão inteira

Sintaxe:	CASE <expressão_inteira> OF

   <valor> : <comandos> ;

   <valor> , <valor> : <comandos> ;

   ...

ELSE

   <comandos> ;

END_CASE;

Os valores do Case deves ser expressões constantes inteiras. Város valores, separados por vírgulas, podem levar a uma mesma lista de comandos. O comando ELSE é opcional.

Exemplo:

(* Programa ST utilizando comando CASE *)

CASE error_code OF

255:	err_msg := 'Division by zero';

fatal_error := TRUE;

1:	err_msg := 'Overflow';

2, 3:	err_msg := 'Bad sign';

ELSE

err_msg := 'Unknown error';

END_CASE;


WHILE statement
Comando WHILE

Nome:	WHILE ... DO ... END_WHILE

Significado:	estrutura de iteração para um grupo de comandos ST

a condição de "continuação" é avaliada ANTES de cada iteração

Sintaxe:	WHILE <expressão_booleana> DO

   <comando> ;

   <comando> ;

   ...

END_WHILE ;

Advertência: Como o ISaGRAF é um sistema síncrono, variáveis de entrada não são atualizadas durante iterações WHILE. A mudança de estado de uma variável de entrada não pode ser utilizada para descrever a condição de um comando WHILE.

Exemplo:

(* Programa ST utilizando comando WHILE *)

(* este programa utiliza funções "C" específicas para ler caracteres *)

(* em uma porta serial *)

string := ''; (* "string" vazia *)

nbchar := 0;

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

string := string + ComGetChar ( );

nbchar := nbchar + 1;

END_WHILE;


REPEAT statement
Comando REPEAT

Nome:	REPEAT ... UNTIL ... END_REPEAT

Significado:	estrutura de iteração para um grupo de comandos ST

a condição de "continuação" é avaliada DEPOIS de cada iteração

Sintaxe:	REPEAT

   <comando> ;

   <comando> ;

  ...

UNTIL <condição_booleana>

END_REPEAT ;

Advertência: Como o ISaGRAF é um sistema síncrono, variáveis de entrada não são atualizadas durante iterações REPEAT. A mudança de estado de uma variável de entrada não pode ser utilizada para descrever a condição de um comando REPEAT.

Exemplo:

(* Programa ST utilizando comando REPEAT *)

(* este programa utiliza funções "C" específicas para ler caracteres *)

(* em uma porta serial *)

string := ''; (* "string" vazia *)

nbchar := 0;

IF ComIsReady ( ) THEN

REPEAT

string := string + ComGetChar ( );

nbchar := nbchar + 1;

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

END_REPEAT;

END_IF;


FOR statement
Comando FOR

Nome:	FOR ... TO ... BY ... DO ... END_FOR

Significado:	executa um número limitado de iterações

utilizando uma variável analógica inteira como índice

Sintaxe:	FOR <índice> := <mini> TO <maxi> BY <passo> DO

   <comando> ;

   <comando> ;

END_FOR;

Operandos:	índice:	variável interna analógica incrementada a cada iteração

mini:	valor inicial para o índice (antes da primeira iteração)

maxi:	valor máximo permitido para o índice

passo:	incremento do índice a cada iteração

A declaração [ BY passo ] é opcional. Se não especificado, o incremento padrão é 1.

Advertência: Como o ISaGRAF é um sistema síncrono, variáveis de entrada não são atualizadas durante iterações FOR.

Este é o equivalente "while" de um comando FOR:

indice := mini;

while (indice <= maxi) do

   <comando> ;

   <comando> ;

   indice := indice + passo;

end_while;

Exemplo:

(* Programa ST utilizando comando FOR *)

(* este programa extrai os caracteres numéricos de uma cadeia *)

length := mlen (message);

target := ''; (* "string" vazia *)

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;


EXIT statement
Comando EXIT

Nome:	EXIT

Significado:	sai de um laço FOR, WHILE ou REPEAT

Sintaxe:	EXIT;

Operandos:	(nenhum)

O comando EXIT é comumente utilizado em comandos IF, dentro de um laço FOR, WHILE ou REPEAT.

Exemplo:

(* Programa ST utilizando comando EXIT *)

(* este programa procura por um caractere em uma "string" *)

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;


ST extensions
Extensões ST

A seguintes funções são extensões da linguagem ST:

TSTART - TSTOP: controle de temporização

Os seguintes comandos estão disponíveis para controlar a execução de programas secundários SFC. Eles podem ser utilizados dentro de blocos ACTION(): ... END_ACTION; em etapas SFC.

GSTART	inicia um programa SFC

GKILL	termina um programa SFC

GFREEZE	congela um programa SFC

GRST	reinicia um programa SFC congelado

GSTATUS	obtém o status corrente de um programa SFC

Advertência: Estas funções não estão na norma IEC 1131-3.

Equivalentes simples podem ser encontrados para GSTART e GKILL utilizando-se a seguinte sintaxe na etapa SFC:

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

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

Os seguintes campos podem ser utilizados para acessar o status de um passo SFC:

GSnnn.x	valor booleano que representa o estado de ativação de uma etapa

GSnnn.t	tempo decorrido desde a última ativação da etapa

("nnn" é o número de referência da etapa)

Também é possível testar o estado de ativação de uma etapa declarada em outro programa SFC, utilizando-se a seguinte sintaxe:

GSnnn(nomeprog).x

Advertência: a referência a etapas em outro programa através desta sintaxe não faz parte da norma IEC 1131-3. Uma maneira fácil de fazer o mesmo respeitando as regras IEC é declarar uma variável booleana global no dicionário, que irá representar o estado de ativação da etapa que se quer testar (por exemplo ref_step_X). Depois se insere a variável na etapa, com o qualificador N (ref_step_X(N);). Após isso, quando se desejar testar o estado de ativação da etapa, pode-se utilizar esta variável.

Programa Prog	o outro programa que deseja testar o estado de ativação de Prog


TSTART statement
TSTART sintaxe

Nome:	TSTART

Significado:	inicia a contagem de uma variável temporizador

o valor do temporizador não é modificado pelo comando TSTART, i.e. a contagem inicia a partir do valor corrente do temporizador.

Sintaxe:	TSTART ( <variável_temporizador> );

Operandos:	qualquer variável temporizador inativa

Valor de retorno:	(nenhum)

Exemplo:

(* Programa SFC utilizando comandos TSTART e TSTOP *)

Diagrama de temp se bi100 for sempre FALSE:

O temporizador mantém o mesmo valor durante um ciclo.


TSTOP statement
TSTOP sintaxe

Nome:	TSTOP

Significado:	pára de atualizar uma variável temporizador

o valor do temporizador não é modificado pelo comando TSTOP

Sintaxe:	TSTOP ( <variável_temporizador> );

Operandos:	qualquer variável temporizador ativa

Valor de retorno:	(nenhum)

Exemplo: veja TSTART


GSTART statement
Comando GSTART

Nome:	GSTART

Significado:	inicia um programa SFC secundário colocando marcas de ativação em cada um

de seus estados iniciais.

Sintaxe:	GSTART ( <programa_secundário> );

Operandos:	o programa especificado deve ser secundário em relação ao programa onde

está o comando

Valor de retorno:	(nenhum)

Programas secundários ao programa sendo disparado não são automaticamente iniciados pelo comando GSTART.

Obs: Como GSTART não faz parte da norma IEC 1131-3, dê preferência o uso do qualificador S, com a seguinte sintaxe, para iniciar um programa SFC secundário:

Nome_do_filho_de(S);

Exemplo: Uso de GSTART e GKILL

(* Sequência 'SPrinc' *)	(* Sequência 'SSecund' *)


GKILL statement
Comando GKILL

Nome:	GKILL

Significado:	termina um programa SFC, removendo as marcas de ativação existentes em

suas etapas no momento

Sintaxe:	GKILL ( <programa_secundário> );

Operandos:	o programa especificado deve ser secundário em relação ao programa onde

está o comando

Valor de retorno:	(nenhum)

Programas secundários ao programa sendo terminado são automaticamente terminados pelo comando GKILL.

Obs: Como GKILL não faz parte da norma IEC 1131-3, dê preferência o uso do qualificador R, com a seguinte sintaxe, para terminar um programa SFC secundário:

Nome_do_filho_de(R);

Exemplo: Veja GSTART


GFREEZE statement
Comando GFREEZE

Nome:	GFREEZE

Significado:	Suspende a execução de um programa SFC secundário

O programa suspenso pode ser reiniciado pelo comando GRST.

Sintaxe:	GFREEZE ( <programa_secundário> );

Operandos:	o programa especificado deve ser secundário em relação ao programa onde

está o comando

Valor de retorno:	(nenhum)

Programas secundários ao programa sendo suspenso são automaticamente suspensos também.

Obs: GFREEZE não faz parte da norma IEC 1131-3.

Exemplo:


GRST statement
Comando GRST

Nome:	GRST

Significado:	reinicia um programa SFc secundário suspenso pelo comando GFREEZE

Sintaxe:	GRST ( <programa_secundário> );

Operandos:	o programa especificado deve ser secundário em relação ao programa onde

está o comando

Valor de retorno:	(nenhum)

Programas secundários ao programa sendo suspenso são automaticamente reiniciados também.

Obs: GRST não faz parte da norma IEC 1131-3.

Exemplo: Veja GFREEZE


GSTATUS statement
Comando GSTATUS

Nome:	GSTATUS

Significado:	retorna o estado de execução corrente de um programa sFC

Sintaxe:	<var_ana> := GSTATUS ( <programa_secundário> );

Operandos:	o programa especificado deve ser secundário em relação ao programa onde

está o comando

Valor de retorno:	0 = programa está inativo (terminado)

1 = programa está ativo (iniciado)

2 = programa está suspenso

Note: GFREEZE não faz parte da norma IEC 1131-3.

Exemplo:


FBD language
 Linguagem FBD

O Diagrama de Blocos Funcionais (FBD) é uma linguagem gráfica. Ele permite ao programador construir procedimentos complexos tomando funções existentes na biblioteca do ISaGRAF e as conectando na área do diagrama..

Formato geral do diagrama FBD

Declaração RETURN

Desvios e rótulos

Inversão booleana

Chamando funções ou blocos de função do FBD


FBD diagram main format
Formato geral do diagrama FBD

Um diagrama FBD descreve uma função entre variáveis de entrada e variáveis de saída. Uma função é descrita como um conjunto de blocos de função básicos. Variáveis de entrada e saída estão conectadas aos blocos por linhas de conexão. Uma saída de um bloco de função também pode ser conectada a uma entrada de um outro bloco.

Uma função inteira realizada por um programa FBD é construída com blocos de função básicos padrão. Cada bloco de função tem um número fixo de pontos de conexão de entrada e um número fixo de pontos de conexão de saída. Um bloco de função é representado por um retângulo simples. As entradas são conectadas em seu lado esquerdo. As saídas são conectadas em seu lado direito. Um bloco de função básico realiza uma função entre suas entradas e saídas. O nome da função a ser realizada pelo bloco aparece dentro de seu símbolo retangular. Cada entrada ou saída do bloco tem um tipo bem definido.

Variáveis de entrada de um FBD devem ser conectadas a pontos de conexão de entrada de blocos de função. O tipo de cada variável deve ser o mesmo tipo esperado para a entrada associada. Uma Entrada para um diagrama FBD pode ser um expressão constante, qualquer variável interna ou de entrada, ou uma variável de saída.

Variáveis de saída de um programa FBD devem ser conectadas em pontos de conexão de saída de blocos de função. O tipo de cada variável deve ser o mesmo tipo esperado para a saída associada do bloco. Uma Saída para um diagrama FBD pode ser qualquer variável interna ou de saída, ou o nome do programa (apenas para subprogramas). Quando uma saída é o nome do subprograma sendo editado no momento, ela representa a atribuição do valor de retorno do subprograma (retornado ao programa que o chamou).

Variáveis de entrada e saída, entradas e saídas dos blocos de função são ligados entre si através de linhas de conexão. Linhas simples podem ser utilizadas para conectar dois pontos do diagrama.:

- Uma variável de entrada e uma entrada de um bloco de função

- Uma saída de um bloco de função e uma entrada de outro bloco

- Uma saída de um bloco de função e uma variável de saída

A conexão é orientada, de modo que a linha transporta dados associados da extremidade esquerda para a extremidade direita. Extremidades esquerda e direita da linha de conexão devem ser do mesmo tipo.

Conexões múltiplas à direita  podem ser utilizadas para transmitir uma informação de sua extremidade esquerda para cada uma das suas extremidades direitas. Todas as extremidades da conexão devem ser do mesmo tipo.


RETURN statement
Declaração RETURN

A palavra-chave "<RETURN>" pode ocorrer como uma saída do diagrama. Ela deve ser conectada a um conto de conexão cooleano de saída de um bloco de função. A declaração RETURN representa um fim condicional do programa: se a saída do bloco de função conectada à declaração tem valor TRUE, o resto do diagrama não é executado..

(* Exemplo de um programa FBD utilizando uma declaração RETURN *)

(* Equivalência ST: *)

If auto_mode OR alarm Then

Return;

End_if;

bo67 := (bi10 AND bi23) OR x_cmd;


Jumps and labels
Desvios e rótulos

Desvios e rótulos são utilizados para controlar a execução do diagrama. Nenhum outro objeto pode ser conectado á direita de um símbolo de desvio ou de rótulo. As seguintes notações são utilizadas:

>>ROT	desviar para um rótulo (nome do rótulo é "ROT")

ROT:	definição de um rótulo (nome do rótulo é "ROT")

Se a linha de conexão à esquerda do símbolo de desvio tem o estado booleano TRUE, a execução do programa desvia diretamente para o símbolo do rótulo correspondente.

(* Exemplo de um programa FBD utilizando rótulos e desvios *)

(* Equivalência IL: *)

ld	manual

and	b1

jmpc	NOMODIF

ld	input1

or	input2

st	result

NOMODIF:	ld	result

and	valid

st	cmd10


Boolean negation
Inversão booleana

Uma linha de conexão simples com sua extremidade direita conectada à entrada de um bloco de função pode ser terminada por um símbolo de inversão booleana. A inversão é representada por um pequeno círculo. Quando uma inversão booleana é utilizada, as extremidades esquerda e direita da linha de conexão devem ser do tipo BOOLEANO.

(* Exemplo de um programa FBD utilizando inversão booleana *)

(* Equivalência ST: *)

output1 := input1 AND NOT (input2);


Calling function or function blocks from the FBD
Chamando funções ou blocos de função do FBD

A linguagem FBD permite a chamada de subprogramas, funções ou blocos de função. I, subprograma, função ou bloco de função é representado por uma caixa de função. O nome que aparece na caixa é o nome do subprograma, função ou bloco de função.

No caso de um subprograma ou função, o valor de retorno é a única saída do bloco de função.

Um bloco de função pode ter mais de uma saída.

(* Exemplo de um programa FBD utilizando um bloco de SUBPROGRAMA *)

(* Equivalência ST *)

net_weight := Weighing (mode, delta); (* chama subprograma *)

If (net_weight = 0) Then Return; End_if;

weight := net_weight + tare_weight;


SFC language
 Linguagem SFC

Sequential Function Chart (SFC), Fluxograma de Funções Sequenciais,  é uma linguagem gráfica usada para descrever operações seqüenciais . O processo é representado como um conjunto de etapas bem definidas, ligadas por transições. Uma condição booleana é associada a cada transição. Ações  dentro de cada etapa são detalhadas com o uso de outras linguagens (ST, IL, LD and FDB).

Formato principal de um gráfico SFC

Componentes básicos SFC

Divergências e convergências

Macro etapas

Ações dentro das etapas

Condições associadas a transições

Regras dinâmicas SFC

Hierarquia de programas SFC


SFC chart main format
Formato principal de um gráfico SFC

Um programa SFC é um conjunto gráfico de etapas e transições, conectadas por ligações orientadas. Ligações de conexões múltipla são utilizadas para representar divergências e convergências. Algumas partes do programa completo podem ser separadas e representadas no gráfico principal por apenas um símbolo, chamado de macro etapa. As regras gráficas básicas de um SFC são:

- Uma etapa não pode ser seguida por outra etapa

- Uma transição não pode ser seguida por outra transição


SFC basic components
Componentes básicos SFC

Os componentes básicos (símbolos gráficos) da linguagem SFC são: etapas e etapas iniciais, transições, ligações orientadas e desvios para uma etapa.

Etapas e etapas iniciais

Transições

Ligações orientadas

Desvio para uma etapa


Steps and initial steps
Etapas e etapas iniciais

Uma etapa é representada por um quadrado. Cada etapa é referenciada por um número, escrito no quadrado símbolo da etapa. Uma descrição geral da etapa é mostrada em um retângulo ligado ao símbolo da etapa. Esta descrição é um comentário livre (não é parte da linguagem de programação). A informação acima é chamada de Nível 1 da etapa:

Em tempo de execução, uma marca indica que a etapa está ativa:

Etapa ativa:	Etapa inativa:

A situação inicial de um programa SFC é denotada pelas etapas iniciais. Uma etapa inicial tem um símbolo gráfico com borda dupla. Uma marca ;e automaticamente colocada em cada etapa inicial quando o programa é iniciado.

Etapa inicial:

Um programa SFC deve conter pelo menos uma etapa inicial. Estes são os atributos de uma etapa. Tais campos podem ser usados em qualquer das outras linguagens:

GSnnn.x	Estado de atividade de uma etapa (valor booleano)

GSnnn.t	Duração da atividade da etapa (valor de tempo)

(onde nnn é o número de referência  do passo)


Transitions
Transições

Transições são representadas por uma pequena barra horizontal que cruza a conexão entre etapas. Cada transição é referenciada  por um número que aparece ao lado do símbolo da transição. Uma descrição geral da transição aparece ao lado direito do símbolo da transição. Esta descrição é um comentário livre  (não é parte da linguagem de programação. A informação acima é chamada de Nível 1 da transição:


Oriented links
Ligações orientadas

Linhas simples são utilizadas para ligar  etapas e transições. Estas são ligações orientadas. Quando a orientação não é dada explicitamente, a ligação é orientada de cima para baixo.

s


Jump to a step
Desvio para uma etapa

Símbolos de desvio podem ser utilizados para indicar uma ligação de conexão de uma transição para uma etapa, sem ter que desenhar a linha de conexão. O símbolo de desvio deve ser referenciado com o número da etapa de destino:

Um símbolo de desvio não pode ser utilizado para representar uma ligação de um passo para uma transição. Exemplo de desvios - os seguintes gráficos são equivalentes:


Divergences and convergences
Divergências e convergências

Divergências são ligações de conexão múltipla de um símbolo SFC (etapa ou transição) para muitos outros símbolos SFC. Convergências são ligações de conexão múltipla de mais de um símbolo SFC para um outro símbolo individual. Divergências e convergências podem ser simples ou duplas.

Divergências simples

Divergências duplas


Single divergences
Divergências simples

Uma divergência simples é uma ligação múltipla de uma etapa para muitas transições. Ela permite que a marca de atividade passe por uma ramificação entre um número delas. Uma convergência simples geralmente é usada para agrupar ramificações SFC que foram iniciadas em uma divergência simples. Divergências e convergências simples são representadas por linhas horizontais simples.

Advertência: As condições associadas a diferentes transições no início de uma divergência simples não são  implicitamente exclusivas. A exclusividade deve ser detalhada explicitamente nas condições das transições  para assegurar que somente uma marca de atividade prossiga em uma ramificação da divergência durante a execução. A seguir está um exemplo de divergência e convergência simples:

(* Programa SFC com divergência e convergência simples *)


Double divergences
Divergências duplas

Uma divergência dupla é uma ligação múltipla de uma transição para muitas etapas. Ela corresponde a operações paralelas do processo. Uma convergência dupla é uma ligação múltipla de muitas etapas para uma mesma transição. Convergências duplas geralmente são utilizadas para agrupas ramificações SFC iniciadas em uma divergência dupla. Divergências e convergências duplas são representadas por linhas horizontais duplas.

Exemplo de divergência e convergência duplas:

(* Programa SFC com divergência e convergência duplas *)


Macro steps
Macro etapas

Uma macro etapa  é uma representação individual de um grupo definido de etapas e transições. O corpo da macro etapa é descrito separadamente, em algum outro lugar no mesmo programa SFC. Ele aparece como um símbolo individual no gráfico SFC principal. Este é o símbolo utilizado pela macro etapa:

O número de referência exibido no símbolo da macro etapa é o número de referência da primeira etapa no corpo da macro etapa. O corpo da macro etapa deve começar com uma etapa inicial e terminar com uma etapa final . O gráfico deve estar contido em si próprio. Uma etapa inicial pode ter ligação para cima (sem transição para trás). Uma etapa final não pode ter ligação para baixo (sem transição para frente). Um símbolo de macro etapa pode ser inserido no corpo de outra macro etapa.

Advertência: Como uma macro etapa é um conjunto único de etapas e transições, a mesma macro etapa não pode ser utilizada mais de uma vez em um programa SFC.

Exemplo de macro etapa:

(* Gráfico principal *)	(* Corpo da macro etapa *)


Actions within the steps
Ações dentro das etapas

O nível 2 de uma etapa SFC é a descrição detalhada das ações  executadas enquanto a etapa está ativa. Esta descrição é feita utilizando-se das características literais SFC, e outras linguagens como Texto Estruturado (ST). Os tipos básicos de ações são:

Ações booleanas

Ações de pulso

Ações Não-armazenadas

Ações SFC

Várias ações (de tipos iguais ou diferentes) podem ser descritas na mesma etapa. As características especiais que possibilitam o uso de quaisquer das outras linguagens são:

Chamando funções e blocos de função de uma ação

Convenção IL


Boolean actions
Ações booleanas

Ações booleanas  atribuem a uma variável booleana o estado de atividade da etapa. A variável booleana pode ser uma variável de saída ou uma interna. Ela é atribuída cada vez que a etapa entra ou sai de atividad. Esta é a sintaxa de ações booleanas básicas:

<variável_booleana> (N) ;	atribui o estado de atividade da etapa para a variável

<variável_booleana > ;	mesmo efeito (atributo N é opcional)

/ <variável_booleana> ;	atribui a negação do estado de atividade da etapa à variável

Outras caracteríticas estão disponíveis para ligar ou desligar uma variável booleana, quando a etapa se torna ativa. Esta é a sintaxe:

<variável_booleana> (S) ;	Atribui TRUE à variável quando o sinal de atividade da etapa se torna TRUE.

<variável_booleana> (R) ;	Atribui FALSE à variável quando o sinal de atividade da etapa se torna FALSE

A variável booleana deve ser de SAÏDA ou INTERNA. O seguinte programa SFC tem este comportamento:

Exemplo de ações booleanas:

(* Programa SFC usando ações BOOLEANAS *)


Pulse actions
Ações de pulso

Uma ação de pulso  é uma lista de instruções ST ou IL, que são executadas apenas uma vez quando da ativação da etapa. As instruções são escritas de acordo com a seguinte sintaxe SFC:

ACTION (P) :

(* declarações ST*)

END_ACTION ;

Os resultados de uma ação de pulso são mostrados a seguir:

Exemplo de ação de pulso:


Non-stored actions
Ações não-armazenadas

Uma ação não-armazenada  (normal)  é uma lista de instruções ST ou IL que são executadas a cada ciclo durante todo o período em que a etapa está ativa. As instruções são escritas de acordo com a seguinte sintaxe SFC:

ACTION (N) :

(* sintaxe ST *)

END_ACTION ;

Os resultados de uma ação não-armazenada são mostrados a seguir:

Exemplo de ação não-armazenada:


SFC actions
Ações SFC

Uma ação SFC é uma seqüência SFC secundária, iniciada ou terminada de acordo com a mudança do estado de ativação da etapa. Uma ação SFC pode ter os qualificadores N (Não-armazenada), S (Liga), ou R (Desliga). Esta é a sintaxe das ações SFC básicas:

<prog_secund> (N);	inicia a seqüência secundária quando a etapa se torna ativa, e termina a seqüência secundária quando a etapa se torna inativa

<prog_secund> ;	mesmo efeito (atributo N é opcional)

<prog_secund> (S);	inicia a seqüência secundária quando a etapa se torna ativa, nada é feito quando a etapa se torna inativa

<prog_secund> (R);	termina a seqüência secundária quando a etapa se torna ativa, nada é feito quando a etapa se torna inativa

A seqüência SFC especificada como uma ação deve ser um programa SFC secundário do programa sendo editado no momento. Note que usar os qualificadores S (Liga) ou R (Desliga) para uma ação SFC tem exatamente o mesmo efeito que as declarações GSTART e GKILL programadas em uma ação de pulso ST.

Abaixo está um exemplo de uma ação SFC. O programa principal SFC é chamado de Father. Ele tem dois SFC secundários, chamados SeqMlx e SeqPump. A programação SFC do programa principal é:

(* SFC program using SFC actions *)


Calling function and function blocks from an action
Chamando funções e blocos de função de uma ação

Subprogramas, funções ou blocos de função (escritos em ST, IL, LD ou FBD) ou funções "C" ou blocos de função "C" podem ser chamados diretamente de um bloco de ação SFC, baseando-se na seguinte sintaxe:

Para subprogramas, funções e funções "C":

ACTION (P) :

result := sub_program ( ) ;

END_ACTION;

ou

ACTION (N) :

result := sub_program ( ) ;

END_ACTION;

Para blocos de função em "C" ou em ST, IL, LD, FBD:

ACTION (P) :

Fbinst(in1, in2);

result1 := Fbinst.out1;

result2 := Fbinst.out2;

END_ACTION;

ou

ACTION (N) :

Fbinst(in1, in2);

result1 := Fbinst.out1;

result2 := Fbinst.out2;

END_ACTION;

A sintaxe detalhada pode ser encontrada na seção sobre a linguagem ST.

Exemplo da chamada de um subprograma em blocos de ação:

(* programa SFC com um subprograma chamado em um bloco de ação *)


IL convention
Convenção IL

Programação em Instruction List (IL), Lista de Instruções, pode ser realizada diretamente em um bloco de ação SFC , baseando-se na seguinte sintaxe:

ACTION (P) :	(* ou N *)

#info=IL

     <instrução>

     <instrução>

     ....

#endinfo

END_ACTION;

As palavras-chave especiais "#info=IL" e "#endinfo" devem ser inseridas exatamente deste jeito, e são dependentes de maiúsculas e minúsculas. Caracteres de tabulação ou espaços não podem ser inseridos antes, no meio ou depois das palavras-chave. Abaixo encontra-se um exemplo de um programa IL em um bloco de ação:

(* programa SFC com uma sequencia IL em um bloco de ação *)


Conditions attached to transitions
Condições associadas a transições

A cada transição, uma expressão que condiciona a transposição da transição é associada . A condição é normalmente escrita em linguagem ST ou usando-se linguagem LD (editor Quick LD). Este é o Nível 2 da transição. Outras estruturas podem, no entanto, ser utilizadas:

Convenção ST

Convenção LD

Convenção IL

Chamando funções de uma transição

Advertência: Quando nenhuma expressão é associada à transição, a condição padrão é TRUE.


ST convention
Convenção ST

A linguagem Structured Text (ST), Texto Estruturado,  pode ser utilizada para descrever a condição associada a uma transição. A expressão completa deve ser do tipo booleano e deve ser terminada por um ponto-e-vírgula, de acordo com a seguinte sintaxe::

< expressão_booleana > ;

A expressão pode ser uma constante TRUE ou FALSE, uma entrada simples ou uma variável booleana interna, ou uma combinação de variáveis que levem a um valor booleano. Abaixo está um exemplo de programação ST para transições:

(* Programa SFC com programação ST para transições *)


LD convention
Convenção LD

A linguagem Ladder Diagram (LD), Diagrama Ladder, pode ser utilizada para descrever uma condição associada a uma transição. O diagrama é composto de apenas uma lógica com uma bobina. O valor da bobina representa o valor da transição.

Abaixo está um exemplo de programação LD para transições:


IL convention
Convenção IL

Programação em Instruction List (IL), Lista de Instruções, pode ser utilizada diretamente para descrever uma transição SFC , de acordo com a seguinte sintaxe:

#info=IL

<instrução>

<instrução>

....

#endinfo

O valor do resultado corrente (registrador IL) ao final da seqüência IL é associado à transição pela seguinte regra:

resultado corrente = 0 	 	condição é FALSE

resultado corrente <> 0	condição é TRUE

As palavras-chave especiais "#info=IL" e "#endinfo" devem ser inseridas exatamente deste jeito, e são dependentes de maiúsculas e minúsculas. Caracteres de tabulação ou espaços não podem ser inseridos antes, no meio ou depois das palavras-chave. Abaixo encontra-se um exemplo de programação IL para transições:

:

(* Programa SFC com um programa IL para transições *)


Calling functions from a transition
Chamando funções de uma transição

Qualquer subprograma ou função (escrita em FBD, LD, ST ou IL) ou uma função "C" pode ser chamada para avaliar a condição associada a uma transição, de acordo com a seguinte sintaxe:

< subprograma > ( ) ;

O valor retornado pelo subprograma ou pela função deve ser booleano e dele decorre a condição resultante:

valor de retorno = 0	condição é FALSE

valor de retorno <> 0	condição é TRUE

Abaixo está um exemplo de um subprograma chamado em uma transição:

(* Programa SFC com chamada de subprograma para transições *)


SFC dynamic rules
Regras dinâmicas SFC

As cinco regras dinâmicas  da linguagem SFC são:

 Situação inicial

A situação inicial é caracterizada pelas etapas iniciais que estão, por definição, ativas no início da operação. Pelo menos uma etapa inicial deve estar presente em cada programa SFC.

 Transposição de uma transição

Uma transição está sempre habilitada ou desabilitada. Ela é dita habilitada quando todos as etapas imediatamente precedentes ligadas ao seu símbolo de transição correspondente estão ativas, senão ela é dita desabilitada. Uma transição não pode ser transposta a menos que:

   - ela esteja habilitada, e

   - a condição associada à transição seja verdadeira

 Alterando o estado das etapas ativas

A transposição de uma transição simultaneamente leva ao estado ativo as etapas imediatamente seguintes, e ao estado inativo as etapas imediatamente precedentes.

 Transposição simultânea de transições

Linhas duplas podem ser utilizadas para indicar transições que devem ser transpostas simultaneamente. Se estas transições são mostradas separadamente, o estado de ativação das etapas precedentes (GSnnn.x) pode ser utilizado para expressar suas condições

 Ativação e desativação simultânea de uma etapa

Se, durante a operação, uma etapa é simultaneamente ativada e desativada, a prioridade é dada à ativação.


SFC program hierarchy
Hierarquia de programas SFC

O ISaGRAF permite a descrição da estrutura vertical de programas SFC. Programas SFC são organizados em uma árvore hierárquica. Cada programa SFC  pode controlar (iniciar, terminar) outros programas SFC. Tais programas são chamados secundários do programa SFC que os controla. Programas SFC são ligados entre si através de uma árvore hierárquica principal, utilizando uma relação principal - secundário.

As regras básicas impostas pela estrutura hierárquica são:

- Programas SFC que não têm programa principal são chamados programas "principais" SFC

- Programas principais SFC são ativados pelo sistema quando o aplicativo inicia

- Um programa pode ter vários programas secundários

- Um programa secundário não pode ter mais de um programa principal

- Um programa secundário pode ser controlado apenas pelo seu programa principal

- Um programa não pode controlar os programas secundários de um de seus programas secundários

As ações básicas que um programa principal SFC pode tomar para controlar seus programas secundários são:

Iniciar	(GSTART) Inicia o programa secundário: ativa cada uma das suas etapas iniciais. Secundários deste programa secundário não são iniciados automaticamente.

Terminar	(GKILL) Termina o programa secundário, desativando todas as suas etapas ativas. Todos os programas secundários deste programa também são terminados.

Congelar	(GFREEZE) Suspende a execução do programa (desativa ações de cada uma das etapas ativas e suspende o cálculo de transições), e memoriza o estado das etapas do programa de modo que o programa possa ser reiniciado. Todos os secundários deste programa também são congelados.

Reiniciar	(GRST) Reinicia um programa SFC congelado, reativando todas as etapas suspensas. Secundários deste programa não são automaticamente reiniciados.

Obter estado	(GSTATUS) Obtém o estado corrente (ativo, inativo ou congelado) de um programa secundário.


LD language
 Linguagem LD

Um Diagrama Ladder (LD)é uma representação gráfica de equações booleanas, combinando contatos (argumentos de entrada com bobinas (resultados de saída). A linguagem LD permite a descrição de testes e modificações de dados booleanos pela disposição de símbolos gráficos no gráfico do programa. Diagramas LD são conectados à esquerda e à direita a barras de energia verticais.

Barras de energia e linhas de conexão

Conexão múltipla

Contatos e bobinas LD básicos

Declaração RETURN

Desvios e rótulos

Blocos em LD

Estes são os componentes básicos de um diagrama LD:

Barra de energia vertical à esquerda

Barra de energia vertical à direita

Linha de conexão horizontal.

Linha de conexão vertical

Linhas de conexão múltiplas (todas conectadas entre si)

Contato associado a uma variável

Bobina associada a uma saída ou a uma variável interna


Power rails and connection lines
Barras de energia e linhas de conexão

Um diagrama LD é limitado à esquerda e à direita por linhas verticais, chamadas barra de energia esquerda  e barra de energia direita, respectivamente.

Os símbolos gráficos de um diagrama LD são conectados às barras de energia ou a outros símbolos por linha de conexão. Linhas de conexão são horizontais ou verticais.

Cada segmento de linha tem um estado booleano FALSE ou TRUE. O estado booleano é o mesmo para todos os segmentos ligados diretamente. Qualquer linha horizontal conectada à barra de energia esquerda tem o estado TRUE.


Multiple connection
Conexão múltipla

O estado booleano dado a uma conexão horizontal simples é o mesmo nas extremidades esquerda e direita da linha. A combinação de linhas horizontais e verticais permite a construção de conexões múltiplas. O estado booleano das extremidades de uma conexão múltipla segue as regras a seguir.

Uma conexão múltipla à esquerda combina mais de uma linha horizontal conectadas ao lado esquerdo de uma linha vertical, e uma linha conectada ao seu lado direito. O estado booleano da extremidade direita é o OU LÓGICO entre todas as extremidades esquerdas.

(* Exemplo de uma conexão múltipla à ESQUERDA *)

(* estado da extremidade direita é (v1 OR v2 OR v3) *)

Uma conexão múltipla à direita combina uma linha horizontal conectada à esquerda de uma linha vertical e mais de uma linha conectadas à sua direita. O estado booleano da extremidade esquerda é propagado a cada uma das extremidades direitas.

(* Exemplo de conexão múltipla à DIREITA *)

(* Equivalência ST: *)

output1 := input1;

output2 := input1;

Uma conexão múltipla à esquerda e à direita combina mais de uma linha horizontal conectadas à esquerda de uma linha vertical, e mais de uma linha horizontal conectadas à sua direita. O estado booleano de cada uma das extremidades direitas é o OU LÓGICO entre todas as extremidades esquerdas.

(* Exemplo de conexão múltipla à ESQUERDA e à DIREITA *)

(* Equivalência ST: *)

output1 := input1 OR input2;

output2 := input1 OR input2;

output3 := input1 OR input2;


Basic LD contacts and coils
Contatos e bobinas LD básicos

Existem vários símbolos disponíveis para contatos de entrada:

Contato normalmente aberto

Contato normalmente fechado

Contato com detecção de borda de subida

Contato com detecção de borda de descida

Existem vários símbolos disponíveis para bobinas de saída:

Bobina simples

Bobina invertida

Bobina Liga

Bobina Desliga

Bobinas com detecção de borda de subida

Bobinas com detecção de borda de descida

O nome da variável aparece acima de qualquer destes símbolos gráficos:


Direct contact
Contato normalmente aberto

Um contato normalmente aberto  permite uma operação booleana  entre o estado de uma linha de conexão e uma variável booleana.

O estado da linha de conexão à direita do contato é o "E" LÓGICO entre o estado da conexão à esquerda e o valor da variável associada ao contato.

(* Exemplo utilizando contatos normalmente abertos *)

(* Equivalência ST: *)

output1 := input1 AND input2;


Inverted contact
Contato normalmente fechado

Um contato normalmente fechado  permite uma operação booleana  entre o estado de uma linha de conexão e a inversão booleana de uma variável booleana

O estado da linha de conexão à direita do contato é o "E" LÓGICO entre o estado da conexão à esquerda e a inversão booleana do valor da variável associada ao contato.

(* Exemplo utilizando contatos normalmente fechados *)

(* Equivalência ST: *)

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


Contact with rising edge detection
Contato com detecção de borda de subida

Este contato permite uma operação booleana entre o estado da linha de conexão e a borda de subida de uma variável booleana.

O estado da linha de conexão à direita do contato é determinado TRUE quando o estado da linha de conexão à esquerda do contato é TRUE, e o estado da variável associada sobe de FALSE para TRUE. Ela é determinada FALSE em todos os outros casos.

(* Exemplo utilizando contato com detecção de borda de subida *)

(* Equivalência ST: *)

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

(* input2prev é o valor de input2 no ciclo anterior *)


Contact with falling edge detection
Contato com detecção de borda de descida

Este contato permite uma operação booleana entre o estado da linha de conexão e a borda de descida de uma variável booleana.

O estado da linha de conexão à direita do contato é determinado TRUE quando o estado da linha de conexão à esquerda do contato é TRUE, e o estado da variável associada desce de TRUE para FALSE. Ela é determinada FALSE em todos os outros casos.

(* Exemplo utilizando contato com detecção de borda de descida *)

(* Equivalência ST: *)

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

(*input2prev é o valor de input2 no ciclo anterior *)


Direct coil
Bobina simples

Bobinas simples  permitem uma saída booleana do estado de uma linha de conexão.

A variável associada é atribuída com o estado booleano da conexão à esquerda. O estado da conexão à esquerda é propagado à conexão à direita. A conexão à direita pode estar conectada à barra de energia vertical da direita.

A variável booleana associada deve ser de SAÍDA ou  INTERNA.

O nome associado pode ser o nome do programa (apenas para  subprogramas). Isto corresponde à atribuição do valor de retorno do subprograma.

(* Exemplo utilizando bobinas simples *)

(* Equivalência ST: *)

output1 := input1;

output2 := input1;


Inverted coil
Bobina invertida

Bobinas invertidas  permitem uma saída booleana da inversão do estado de uma linha de conexão.

A variável associada é atribuída com a inversão do estado booleano da conexão à esquerda. O estado da conexão à esquerda é propagado à conexão à direita. A conexão à direita pode estar conectada à barra de energia vertical da direita.

A variável booleana associada deve ser de SAÍDA ou  INTERNA.

O nome associado pode ser o nome do programa (apenas para  subprogramas). Isto corresponde à atribuição do valor de retorno do subprograma.

(* Exemplo utilizando bobinas invertidas *)

(* Equivalência ST: *)

output1 := NOT (input1);

output2 := input1;


SET coil
Bobina Liga

Bobinas "liga" permitem uma saída booleana do estado de uma linha de conexão.

A variável associada é ATRIBUÍDA COM TRUE quando o estado booleano da conexão à esquerda se torna TRUE. A variável de saída mantém este valor até que uma ordem inversa é dada por uma Bobina "Desliga". O estado da conexão à esquerda é propagado à conexão à direita. A conexão à direita pode estar conectada à barra de energia vertical da direita.

A variável booleana associada deve ser de SAÍDA ou  INTERNA.

(* Exemplo utilizando bobinas "liga" ("set")e "desliga" ("reset") *)

(* Equivalência ST: *)

IF input1 THEN

   output1 := TRUE;

END_IF;

IF input2 THEN

   output1 := FALSE;

END_IF;


RESET coil
Bobina Desliga

Bobinas "desliga" permitem uma saída booleana do estado de uma linha de conexão.

A variável associada é ATRIBUÍDA COM FALSE quando o estado booleano da conexão à esquerda se torna TRUE. A variável de saída mantém este valor até que uma ordem inversa é dada por uma Bobina "Liga". O estado da conexão à esquerda é propagado à conexão à direita. A conexão à direita pode estar conectada à barra de energia vertical da direita.

A variável booleana associada deve ser de SAÍDA ou  INTERNA.

(* Exemplo utilizando bobinas "liga" ("set") e "desliga" ("reset") *)

(* Equivalência ST: *)

IF input1 THEN

   output1 := TRUE;

END_IF;

IF input2 THEN

   output1 := FALSE;

END_IF;


Coil with rising edge detection
Bobina com detecção de borda de subida

Bobinas com detecção de borda de subida  permitem uma saída booleana do estado de uma linha de conexão. Este tipo de bobina só está disponível na utilização do editor Quick ladder.

A variável associada é ATRIBUÍDA COM TRUE quando o estado booleano da conexão à esquerda sobe de FALSE para TRUE. A variável de saída será atribuída com FALSE em todos os outros casos. O estado da conexão à esquerda é propagado à conexão à direita. A conexão à direita pode estar conectada à barra de energia vertical da direita.

A variável booleana associada deve ser de SAÍDA ou  INTERNA.

(* Exemplo utilizando uma bobina com detecção de borda de subida *)

(* Equivalência ST: *)

IF (input1 and NOT(input1prev)) THEN

   output1 := TRUE;

ELSE

   output1 := FALSE;

END_IF;

(*input1prev é o valor de input1 no ciclo anterior *)


Coil with falling edge detection
Bobina com detecção de borda de descida

Bobinas com detecção de borda de descida  permitem uma saída booleana do estado de uma linha de conexão. Este tipo de bobina só está disponível na utilização do editor Quick ladder.

A variável associada é ATRIBUÍDA COM TRUE quando o estado booleano da conexão à esquerda desce de TRUE para FALSE. A variável de saída será atribuída com FALSE em todos os outros casos. O estado da conexão à esquerda é propagado à conexão à direita. A conexão à direita pode estar conectada à barra de energia vertical da direita.

A variável booleana associada deve ser de SAÍDA ou  INTERNA.

(* Exemplo utilizando uma bobina com detecção de borda de descida *)

(* Equivalência ST: *)

IF (NOT(input1) and input1prev) THEN

   output1 := TRUE;

ELSE

   output1 := FALSE;

END_IF;

(*input1prev é o valor de input1 no ciclo anterior *)


RETURN statement
Declaração RETURN

O rótulo RETURN pode ser utilizado como uma saída para representar um fim condicional do programa. Nenhuma conexão pode ser ligada à direita de um símbolo de RETURN.

Se a saída do bloco de função conectada à declaração tem valor TRUE, o programa termina sem executar as equações inseridas nas linhas seguintes do programa.

Observação: Quando o programa LD é um subprograma, seu nome tem que ser associado com uma bobina de saída para atribuição do valor de retorno (retornado ao programa que o chamou).

(* Exemplo utilizando o símbolo RETURN *)

(* Equivalência ST: *)

If Not (manual_mode) Then RETURN; End_if;

result := (input1 OR input3) AND input2;


Jumps and labels
Desvios e rótulos

Rótulos e desvios condicionais e incondicionais podem ser utilizados para controlar a execução do diagrama. Nenhum outro objeto pode ser conectado à direita de um símbolo de desvio ou de rótulo. As seguintes notações são utilizadas:

>>ROT	desviar para um rótulo (nome do rótulo é "ROT")

ROT:	definição de um rótulo (nome do rótulo é "ROT")

Se a linha de conexão à esquerda do símbolo de desvio tem o estado booleano TRUE, a execução do programa desvia diretamente para o símbolo do rótulo correspondente.

(* Exemplo de um programa LD utilizando rótulos e desvios *)

(* Equivalência IL: *)

ldn	manual_mode

jmpc	other

ld	input1

st	result

jmp	END

OTHER:	ld	input2

st	result

END:	(* end of program *)


Blocks in LD
Blocos em LD

Utilizando o Editor Quick LD, você conecta blocos de função a linha booleanas. Uma função pode na verdade ser um operador, um bloco de função ou uma função. Como nem todos os blocos têm sempre uma entrada booleana e/ou uma saída booleana, a inserção de blocos em um diagrama LD leva à adição de novos parâmetros, EN e ENO, à interface do bloco. Os parâmetros EN e ENO não são adicionados no uso do editor FBD/LD, porque você pode conectar a variável com o tipo necessário.

A entrada "EN"

A saída "ENO"

Utilizando ambos: "EN" e "ENO"


The "EN" input
A entrada "EN"

Em alguns operadores, funções ou blocos de função, a primeira entrada não é do tipo booleano. Como a primeira entrada deve sempre estar conectada à lógica, outra entrada é automaticamente inserida na primeira posição, chamada "EN". O bloco é executado somente se a entrada EN é TRUE. Abaixo está um exemplo de um operador de comparação, e o código equivalente expresso em ST:

	IF estado_logica THEN    q := (value1 > value 2); ELSE    q := FALSE; END_IF; (* continua logica com estado q *)


The "ENO" output
A saída "ENO"

Em alguns operadores, funções ou blocos de função, a primeira saída não é do tipo booleano. Como a primeira saída deve sempre estar conectada à lógica, outra saída é automaticamente inserida na primeira posição, chamada "ENO". A saída ENO sempre recebe o mesmo estado da primeira entrada do bloco. Abaixo está um exemplo com o bloco de função AVERAGE, e o código equivalente expresso em ST:

	AVERAGE(estado_logica, Signal, 100); OutSignal := AVERAGE.XOUT; eno := estado_logica; (* continua logica com estado eno *)


Using both "EN" and "ENO"
Usando ambos "EN" e "ENO"

Em alguns casos, tanto EN quanto ENO são necessários. Abaixo está um exemplo com um operador aritmético, e o código equivalente expresso em ST:

	IF estado_logica THEN    result := (value1 + value2); END_IF; eno := estado_logica; (* continua logica com estado eno *)


FC language
 Linguagem FC

O Fluxograma (Flow Chart - FC) é uma linguagem gráfica utilizada para descrever operações seqüenciais. Um Fluxograma é composto de Ações  e Testes. Entre ações e teste existem ligações orientadas representando o fluxo de dados. Ações e testes podem ser descritos com as linguagens ST, LD ou IL. Funções e blocos de função de qualquer linguagem (exceto SFC) podem ser chamados a partir de ações e testes. Um Fluxograma pode chamar outro Fluxograma. O Fluxograma chamado é um subprograma do programa FC que o está chamado.

Componentes básicos FC

Exemplos de estruturas complexas FC

Comportamento dinâmico do FC

Checagem do FC


FC components
Componentes FC

A seguir estão os componentes gráficos da linguagem de Fluxograma:

Início do gráfico FC

Fim do gráfico FC

Linhas de fluxo FC

Ações FC

Condições FC

Subprograma FC

Ação específica de E/S FC

Conectores FC

Comentários FC


Beginning of FC chart
Início do Gráfico FC

Um símbolo "Início" deve aparecer no início de um programa FC. Ele deve ser único e não pode ser omitido. Ele representa o estado inicial do gráfico quando é ativado. Abaixo está o desenho de um símbolo "Início":

O símbolo "Início" sempre tem uma conexão (na parte de baixo) para outros objetos do gráfico. Um Fluxograma não é válido se nenhuma conexão é feita do "Início" para outro objeto.


Ending of FC chart
Fim do Gráfico FC

Um símbolo "Fim" deve aparecer no final de um programa FC. Ele deve ser único e não pode ser omitido. É possível que nenhuma conexão seja feita para o símbolo "Fim" (gráfico com laço eterno), mas o símbolo "Fim" ainda é mostrado na parte inferior do gráfico. Ele representa o estado final do gráfico, quando sua execução foi completada. Abaixo está o desenho de um símbolo "Fim":

O símbolo "Fim" geralmente tem uma conexão (na parte de cima) para outros objetos do gráfico. Um Fluxograma pode não ter conexão com o objeto "Fim" (gráfico com laço eterno). O objeto "Fim" ainda é visível na parte inferior do gráfico neste caso.


FC flow links
Linhas de fluxo FC

Uma linha de fluxo é uma linha que representa um fluxo entre dois pontos do diagrama. Uma linha é sempre terminada por uma flecha na extremidade. Abaixo segue o desenho de uma linha de fluxo:

Duas linhas de fluxo não podem ser conectadas ao mesmo ponto de origem.


FC actions
Ações FC

Um símbolo de ação representa ações a serem realizadas. Uma ação é identificada por um número e um nome. Abaixo está o desenho de um símbolo de "ação":

Dois objetos diferentes do mesmo gráfico não podem ter o mesmo nome ou número lógico. A linguagem de programação para uma ação pode ser ST, LD ou IL. Uma ação está sempre conectada por linhas de fluxo, uma chegando até ela, e uma partindo dela.


FC conditions
FC condições

Uma condição representa um teste booleano. Uma condição é identificada por um número e um nome. De acordo com o resultado da expressão ST, LD ou IL associada, o fluxo é dirigido para o caminho "SIM" ou para o "NÃO". A seguir estão os possíveis aspectos de um símbolo de condição:

Dois objetos diferentes de um mesmo gráfico não podem ter o mesmo nome ou número lógico. A programação de um teste pode ser

- uma expressão em ST, ou

- uma única lógica em LD, sem nenhum símbolo associado a um única bobina, ou

- várias instruções em IL. O registrador IL (ou resultado corrente) é utilizado para avaliar a condição.

Quando programada em texto ST, a expressão pode opcionalmente ser seguida por um ponto-e-vírgula. Quando programada em LD, a lógica única representa o valor da condição. Uma condição igual a :

- 0 ou FALSO direciona o fluxo para NÃO

- 1 ou VERDADEIRO direciona o fluxo para SIM

Um teste é sempre conectado por uma linha de fluxo de chegada, e as duas conexões à frente devem ser definidas.


FC sub-program
Subprograma FC

O ISaGRAF permite a descrição da estrutura vertical de programas FC. Programas FC são organizados em uma árvore hierárquica. Cada programa FC  pode chamar outros programas FC. Tais programas são chamados secundários do programa FC que os controla. Programas que chamam  subprogramas são chamados programas principais. Programas FC são ligados entre si através de uma árvore hierárquica principal, utilizando uma relação principal - secundário.

Um símbolo de subprograma em um Fluxograma representa uma chamada a um programa secundário FC. A execução do programa que chama é suspensa até que a execução do subprograma seja completada. Um subprograma FC é identificado por um número e um nome, como outros programas, funções e blocos de função. Abaixo está o símbolo de uma "chamada a subprograma":

Dois objetos diferentes do mesmo gráfico não podem ter o mesmo número lógico. As regras básicas impostas pela estrutura hierárquica FC são:

- Programas FC que não têm programa principal são chamados programas "principais" FC

- Programas principais FC são ativados pelo sistema quando o aplicativo inicia

- Um programa pode ter vários programas secundários

- Um programa secundário não pode ter mais de um programa principal

- Um programa secundário pode ser chamado apenas pelo seu programa principal

- Um programa não pode chamar os programas secundários de um de seus programas secundários

O mesmo subprograma pode aparecer várias vezes no Fluxograma do programa principal. Uma chamada a um subprograma FC representa a execução completa do sub Fluxograma. A execução do programa principal é suspensa enquanto a execução do subprograma ocorre. Os blocos de chamada de subprograma devem seguir as mesmas regras de conexão dos blocos definidos para ações.


FC I/O specific action
Ação específica de E/S FC

Um símbolo de ação específica de E/S representa ações a serem executadas. Como outras ações, uma ação específica de E/S é identificada por um número e um nome. A mesma semântica é utilizada em ações padrão e ações de E/S específicas. A intenção das ações específicas de E/S é apenas tornar o Fluxograma mais legível e voltar o foco a partes não portáveis do gráfico. A utilização de ações específicas de E/S é uma característica opcional. A seguir é mostrado o símbolo de uma "ação específica de E/S":

Blocos específicos de E/S tê exatamente o mesmo comportamento de ações padrão. Isto cobre suas propriedades, programação ST, LD ou IL, e regras de conexão.


FC connectors
Conectores FC

Conectores são utilizados para representar uma ligação entre dois pontos de um diagrama sem desenhá-la. Um conector é representado por um círculo e é conectado à origem do fluxo. O desenho do conector é completado, do lado apropriado (dependendo da direção do fluxo de dados), pela identificação do ponto de destino (geralmente o nome do símbolo de destino). A seguir está o símbolo de um conector:

Um conector sempre tem como destino um símbolo definido do Fluxograma. O símbolo de destino é identificado pelo seu número lógico.


FC comments
Comentários FC

Um bloco de comentário contém texto que não tem sentido semântico para o Fluxograma. Ele pode ser inserido em qualquer espaço não utilizado da janela do Fluxograma, e é utilizado para documenta o programa. Abaixo está o símbolo de um comentário:


FC complex structures examples
Exemplos de estruturas complexas FC

Esta seção mostra exemplos de estruturas complexas que podem ser definidas em um Fluxograma. Tais estruturas são combinações de objetos básicos ligados entre si.

	IF / THEN / ELSE (1) lugar para inserção de ações "THEN" (2) lugar para inserção de ações "ELSE"
	REPEAT / UNTIL (3) lugar para inserção de ações repetidas
	WHILE / DO (4) lugar para inserção de ações repetidas


FC dynamic behavior
Comportamento dinâmico FC

A execução de um Fluxograma pode ser explicada como segue:

- O símbolo Início toma um ciclo do destino

- O símbolo Fim toma um ciclo do destino e termina a execução do Fluxograma. Após esse símbolo ser alcançado, nenhuma ação do Fluxograma é executada.

- O fluxo é quebrado cada vez que um item (ação, decisão) seja encontrado e que já tenha sido alcançado no mesmo ciclo do destino. Neste caso o fluxo continuará no próximo ciclo.

Obs: Ao contrário de SFC, uma ação não é um estado estável. Não há repetição de instruções enquanto o símbolo da ação é destacado.


FC checking
Checagem do FC

Além da programação ST, LD ou IL associada, algumas outras regras de sintaxe se aplicam ao Fluxograma em si. Abaixo está a lista das principais regras:

- Todos os pontos de conexão de todos os símbolo devem estar conectados. (a conexão ao símbolo "Fim" pode ser omitida)

- Todos os símbolos devem estar ligados entre si (nenhuma parte isolada deve existir)

- Todos os conectores devem ter um destino válido

Outros erros menores de sintaxe podem ser reportados:

- Ações vazias (sem programação) são consideradas como etapas durante escalonamento de execução

- Testes vazios (sem programação) são considerados como "sempre VERDADEIRO"


 Operadores padrão, blocos de função e funções

Operadores padrão

Blocos de Função padrão

Funções padrão

Índice alfabético


Operadores padrão

Os operadores padrão das linguagens IEC são:

Manipulação de dados:

1 gain	Atribuição

Neg	Negação Analógica

Operações booleanas:

& (AND)	Lógica Booleana E

>=1 (OR)	Lógica Booleana OU

=1 (XOR)	Lógica Booleana OU EXCLUSIVO

Operações Aritméticas:

 + 	Adição

 - 	Subtração

 * 	Multiplicação

 / 	Divisão

Operações Lógicas:

AND_MASK	Máscara analógica da lógica E bit a bit

OR_MASK	Máscara analógica da lógica OU bit a bit

XOR_MASK	Máscara analógica da lógica OU EXCLUSIVO bit a bit

NOT_MASK	Negação analógica bit a bit

Testes de Comparação:

 < 	Menor que

 <= 	Menor ou igual a

 > 	Maior que

 >= 	Maior ou igual a

 = 	Igual a

 <> 	Diferente de

Conversão de Dados:

BOO	Converte para Booleana

ANA	Converte para Analógico Inteiro

REAL	Converte para Analógico Real

TMR	Converte para Horário

MSG	Converte para Mensagem

Outros:

CAT	Concatenação de mensagens

SYSTEM	Acesso ao Sistema

OPERATE	Operação com canal de E/S


1 gain

Argumentos:

IN	qualquer tipo

Q	qualquer tipo

Descrição:

Atribuição do valor de uma variável para outra

Este bloco é muito útil para interligar diretamente uma entrada do diagrama a uma saída do diagrama. Ele também pode ser usado (com Negação Booleana) para inverter o estado de uma linha conectada à uma saída do diagrama.

(* FBD exemplo com bloco de atribuição *)

(* Programa ST equivalente: *)

ao23 := ai10;

bo100 := NOT (bi1 AND bi2);

(* Programa IL equivalente: *)

LD	ai10

ST 	ao23

LD	bi1

AND	bi2

STN	bo100


NEG

Argumentos:

IN	INT-REAL	entrada e saída devem ter o mesmo formato

Q	INT-REAL

Descrição:

Negação de uma variável

(* FBD exemplo com blocos "NEG" *)

(* Programa ST equivalente: *)

ao23 := - (ai10);

ro100 := - (ri1 + ri2);

(* Programa IL equivalente: *)

LD	ai10

MUL	-1

ST 	ao23

LD	ri1

ADD	ri2

MUL	-1.0

ST	ro100


& AND

Nota: Para este operador, o número de entradas pode ser estendido para mais de dois.

Argumentos:

(entradas)	BOOLEAN

saída	BOOLEAN	Resultado da lógica booleana E dos termos de entrada

Descrição:

Lógica booleana E de dois ou mais termos

(* FBD exemplo com blocos "AND" *)

(* Programa ST equivalente: *)

bo10 := bi101 AND NOT (bi102);

bo5 := (bi51 AND bi52) AND bi53;

(* Programa IL equivalente *)

LD	bi101	(* resultado atual := bi101 *)

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

ST	bo10	(* bo10 := resultado atual *)

LD	bi51	(*resultado atual := bi51;

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

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

ST	bo5	(* bo5 := resultado atual *)


>=1 OR

Nota: Para este operador, o número de entradas pode ser estendido para mais de dois.

Argumentos:

(entradas)	BOOLEAN

saída	BOOLEAN	Resultado da lógica booleana OU dos termos de entrada

Descrição:

Lógica booleana OU de dois ou mais termos

(* FBD exemplo com blocos "OR" *)

(* Programa ST equivalente: *)

bo10 := bi101 OR NOT (bi102);

bo5 := (bi51 OR bi52) OR bi53;

(* Programa IL equivalente: *)

LD	bi101

ORN	bi102

ST	bo10

LD	bi51

OR	bi52

OR	bi53

ST	bo5


=1 XOR

Argumentos:

IN1	BOOLEAN

IN2	BOOLEAN

Q	BOOLEAN	resultado da lógica booleana OU EXCLUSIVO dos termos de entrada

Descrição:

Lógica booleana OU EXLCUSIVO entre dois termos

(* FBD exemplo com blocos "XOR" *)

(* Programa ST equivalente: *)

bo10 := bi101 XOR NOT (bi102);

bo5 := (bi51 XOR bi52) XOR bi53;

(* Programa IL equivalente: *)

LD	bi101

XORN	bi102

ST	bo10

LD	bi51

XOR	bi52

XOR	bi53

ST	bo5


+

Nota: Para este operador, o número de entradas pode ser estendido para mais de dois.

Argumentos:

(entradas)	INT-REAL	pode ser INTEIRO ou REAL

(todas entradas devem ter o mesmo formato)

saída	INT-REAL	resultado da adição dos termos de entrada

Descrição:

Adição de duas ou mais variáveis de entrada

(* FBD exemplo com  blocos de adição*)

(* Programa ST equivalente: *)

ao10 := ai101 + ai102;

ao5 := (ai51 + ai52) + ai53;

(* Programa IL equivalente: *)

LD	ai101

ADD	ai102

ST	ao10

LD	ai51

ADD	ai52

ADD	ai53

ST	ao5


-

Argumentos:

IN1	INT-REAL	pode ser "INTEIRO" ou "REAL"

IN2	INT-REAL	(IN1 e IN2 devem ter o mesmo formato)

Q	INT-REAL	resultado da subtração  do primeiro pelo segundo termo de entrada

Descrição:

Subtração de duas variáveis analógicas (primeiro termo pelo segundo termo)

(* FBD exemplo com blocos de subtração *)

 (* Programa ST equivalente: *)

ao10 := ai101 - ai102;

ao5 := (ai51 - 1) - ai53;

(* Programa IL equivalente: *)

LD	ai101

SUB	ai102

ST	ao10

LD	ai51

SUB	1

SUB	ai53

ST	ao5


*

Nota: Para este operador, o número de entradas pode ser estendido para mais de dois.

Argumentos:

(entradas)	INT-REAL	pode ser INTEIRO ou REAL

(todas entradas devem ter o mesmo formato)

saída	INT-REAL	resultado da multiplicação dos termos de entrada

Descrição:

Multiplicação de duas ou mais variáveis analógicas.

(* FBD exemplo com blocos de multiplicação *)

(* Programa ST equivalente *)

ao10 := ai101 * ai102;

ao5 := (ai51 * ai52) * ai53;

(* Programa IL equivalente: *)

LD	ai101

MUL	ai102

ST	ao10

LD	ai51

MUL	ai52

MUL	ai53

ST	ao5


/

Argumentos:

IN1	INT-REAL	pode ser INTEIRO ou REAL (dividendo)

IN2	INT-REAL	valor analógico diferente de zero (divisor)

(IN1 e IN2 devem ter o mesmo formato)

Q	INT-REAL	resultado INTEIRO ou REAL da divisão de IN1 por IN2

Descrição:

Divisão de duas variáveis analógicas (a primeira dividida pela segunda).

(* FBD exemplo com blocos de divisão *)

(* Programa ST equivalente: *)

ao10 := ai101 / ai102;

ao5 := (ai5 / 2) / ai53;

(* Programa IL equivalente: *)

LD	ai101

DIV	ai102

ST	ao10

LD	ai51

DIV	2

DIV	ai53

ST	ao5


AND_MASK

Argumentos:

IN	INT	deve ter formato INTEIRO

MSK	INT	deve ter formato INTEIRO

Q	INT	lógica E bit a bit entre IN e MSK

Descrição:

Máscara analógica da lógica E bit a bit.

(* FBD exemplo com o bloco analógico AND_MASK *)

(* Programa ST equivalente: *)

parity := AND_MASK (xvalue, 1); (* 1 if xvalue é ímpar *)

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

(* Programa IL equivalente: *)

LD	xvalue

AND_MASK	1

ST	parity

LD	16#abc

AND_MASK	16#f0f

ST	result


OR_MASK

Argumentos:

IN	INT	deve ter formato INTEIRO

MSK	INT	deve ter formato INTEIRO

Q	INT	Lógica OU bit a bit entre IN e MSK

Descrição:

Máscara analógica da lógica OU bit a bit.

(* FBD exemplo com bloco analógico OR_MASK *)

(* Programa ST equivalente: *)

is_odd := OR_MASK (xvalue, 1); (* valor sempre ímpar *)

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

(* Programa IL equivalente: *)

LD	xvalue

OR_MASK	1

ST	is_odd

LD	16#abc

OR_MASK	16#f0f

ST	result


XOR_MASK

Argumentos:

IN	INT	deve ter formato INTEIRO

MSK	INT	deve ter formato INTEIRO

Q	INT	Lógica OU Exclusivo bit a bit entre IN e MSK

Descrição:

Máscara analógica da lógica OU EXCLUSIVO bit a bit.

(* FBD exemplo com o bloco XOR_MASK *)

(* Programa ST equivalente: *)

crc32 := XOR_MASK (prevcrc, nextc);

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

(* Programa IL equivalente: *)

LD	prevcrc

XOR_MASK	nextc

ST	crc32

LD	16#012

XOR_MASK	16#011

ST	result


NOT_MASK

Argumentos :

IN	INT	deve ter formato INTEIRO

Q	INT	negação bit a bit dos 32 bits do IN

Descrição:

Máscara da negação analógica bit a bit

(* FBD exemplo com bloco NOT_MASK *)

(*Programa ST equivalente: *)

result := NOT_MASK (16#1234);

(* resultado é 16#FFFF_EDCB *)

(* Programa IL equivalente: *)

LD	16#1234

NOT_MASK

ST	result


<

Argumentos:

IN1	INT-REAL-

TMR-MSG

IN2	INT-REAL-

TMR-MSG	ambas entradas devem ter o mesmo valor

Q	BOOLEAN	TRUE se IN1 < IN2

Descrição:

Testa se um valor é MENOR QUE o outro (analógico, horário ou mensagens)

(* FBD teste com bloco "MENOR QUE" *)

(* Programa ST equivalente: *)

aresult := (10 < 25); (* aresult é TRUE *)

mresult := ('z' < 'B'); (* mresult é FALSE *)

(* Programa IL equivalente: *)

LD	10

LT	25

ST	aresult

LD	'z'

LT	'B'

ST	mresult


<=

Argumentos:

IN1	INT-REAL-MSG

IN2	INT-REAL-MSG	ambas entradas devem ser do mesmo tipo

Q	BOOLEAN	TRUE se IN1 <= IN2

Descrição:

Testa se um valor é MENOR OU IGUAL A outro (analógico ou mensagens)

(* FBD exemplo com bloco "MENOR OU IGUAL A" *)

(* Programa ST equivalente: *)

aresult := (10 <= 25); (* aresult é TRUE *)

mresult := ('ab' <= 'ab'); (* mresult é FALSE *)

(* Programa IL equivalente: *)

LD	10

LE	25

ST	aresult

LD	'ab'

LE	'ab'

ST	mresult


>

Argumentos:

IN1	INT-REAL-

TMR-MSG

IN2	INT-REAL-

TMR-MSG 	ambas entradas devem ser do mesmo tipo

Q	BOOLEAN	TRUE se IN1 > IN2

Descrição:

Testa se um valor é MAIOR QUE outro (analógico, horário ou mensagens)

(* FBD exemplo com bloco "MAIOR QUE" *)

(* Programa ST equivalente: *)

aresult := (10 > 25); (* aresult é FALSE *)

mresult := ('ab' > 'a'); (* mresult é TRUE *)

(* Programa IL equivalente: *)

LD	10

GT	25

ST	aresult

LD	'ab'

GT	'a'

ST	mresult


>=

Argumentos:

IN1	INT-REAL-MSG

IN2	INT-REAL-MSG 	ambas entradas devem ser do mesmo tipo

Q	BOOLEAN	TRUE se IN1 >= IN2

Descrição:

Testa se um valor é MAIOR OU IGUAL A outro (analógico ou mensagens)

(* FBD exemplo com bloco "MAIRO OU IGUAL A" *)

(* Programa ST equivalente: *)

aresult := (10 >= 25); (* aresult é FALSE *)

mresult := ('ab' >= 'ab'); (* mresult é TRUE *)

(* Programa IL equivalente: *)

LD	10

GE	25

ST	aresult

LD	'ab'

GE	'ab'

ST	mresult


=

Argumentos:

IN1	INT-REAL-MSG

IN2	INT-REAL-MSG 	ambas entradas devem ser do mesmo tipo

Q	BOOLEAN	TRUE se IN1 = IN2

Descrição:

Testa se um valor é IGUAL A outro (analógico ou mensagens)

(* FBD exemplo com bloco "IGUAL A" *)

(* Programa ST equivalente: *)

aresult := (10 = 25); (* aresult é FALSE *)

mresult := ('ab' = 'ab'); (* mresult é TRUE *)

(* Programa IL equivalente: *)

LD	10

EQ	25

ST	aresult

LD	'ab'

EQ	'ab'

ST	mresult


<>

Argumentos:

IN1	INT-REAL-MSG

IN2	INT-REAL-MSG 	ambas entradas devem ser do mesmo tipo

Q	BOOLEAN	TRUE se IN1<> IN2

Descrição:

Testa se um valor é DIFERENTE DE outro (analógico ou mensagens)

(* FBD exemplo com blocos "DIFERENTE DE" *)

(* Programa ST equivalente: *)

aresult := (10 <> 25); (* aresult é TRUE *)

mresult := ('ab' <> 'ab'); (* mresult é FALSE *)

(* Programa IL equivalente: *)

LD	10

NE	25

ST	aresult

LD	'ab'

NE	'ab'

ST	mresult


BOO

Argumentos:

IN	ANY	qualquer valor não-booleano

Q	BOO	TRUE para valor numérico diferente de zero

FALSE para valor numérico igual a zero

TRUE para mensagem 'TRUE'

FALSE para mensagem 'FALSE'

Descrição:

Converte qualquer variável para tipo Booleano

(* FBD exemplo com bloco "Converte para booleano" *)

(* Programa ST equivalente: *)

ares := BOO (10);	(* ares é TRUE *)

tres := BOO (t#0s);	(* tres é FALSE *)

mres := BOO ('false');	(* mres é FALSE *)

(* Programa IL equivalente: *)

LD	10

BOO

ST	ares

LD	t#0s

BOO

ST	tres

LD	'false'

BOO

ST	mres


ANA

Argumentos:

IN	ANY	qualquer valor analógico não-inteiro

Q	INT	0 se IN é FALSE / 1 se IN é TRUE

número de milisegundos para um temporizador

parte inteira de uma variável analógica real

número decimal representado por uma "string"

Descrição:

Converte qualquer variável para formato INTEIRO

(* FBD exemplo com blocos "Converte para Analógico" *)

(* Programa ST equivalente: *)

bres := ANA (true);	(* bres é 1 *)

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

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

(* Programa IL equivalente: *)

LD	true

ANA

ST	bres

LD	t#1s46ms

ANA

ST	tres

LD	'0198'

ANA

ST	mres


REAL

Argumentos:

IN	BOO-INT-

TMR	qualquer valor analógico não-real (exceto mensagem)

Q	REAL	0.0 se IN é FALSE / 1.0 se IN é TRUE

número de milisegundos para um temporizador

número equivalente para um valor analógico inteiro

Descrição:

Converte qualquer variável para formato REAL

(* FBD exemplo com bloco "Converte para Real" *)

(* Programa ST equivalente: *)

bres := REAL (true);	(* bres é 1.0 *)

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

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

(* Programa IL equivalente: *)

LD	true

REAL

ST	bres

LD	t#1s46ms

REAL

ST	tres

LD	198

REAL

ST	ares


TMR

Argumentos:

IN	INT-REAL	qualquer valor diferente do formato horário

IN (ou parte inteira de IN se ele for real)

é o número de milisegundos

Q	TIMER	valor de tempo representado por IN

Descrição:

Converte qualquer variável analógica para formato de horário

(* FBD exemplo com bloco "Converte para horário" *)

 (* Programa ST equivalente: *)

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

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

(* Programa IL equivalente: *)

LD	1256

TMR

ST	ares

LD	1256.3

TMR

ST	rres


MSG

Argumentos:

IN	BOO-

INT-REA	qualquer valor diferente do formato de mensagem

Q	MSG	'false' ou ' true ' se IN é booleano

Representação decimal se IN é analógico

Descrição:

Converte qualquer variável para mensagem

(* FBD exemplo com bloco "Converte para mensagem" *)

(* Programa ST equivalente: *)

bres := MSG (true); (* bres é 'TRUE' *)

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

(* Programa IL equivalente: *)

LD	true

MSG

ST	bres

LD	125

MSG

ST	ares


CAT

Nota: Para este operador, o número de entradas pode ser estendido para mais de dois.

Argumentos:

(entradas)	MSG	(tamanho da adição de todas mensagens não deve exceder a capacidade da mensagem de saída)

saída	MSG	concatenação das mensagens de saída

Descrição:

Concatena várias mensagens em uma só.

(* FBD exemplo do bloco "Concatenação de mensagens" *)

(* Programa ST equivalente: use o operador + *)

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

(* o mesmo que: myname := 'Mr Jones' *)

(* Programa IL equivalente: *)

LD	'Mr'

ADD	' '

ADD	'Jones'

ST	myname


SYSTEM

Argumentos:

Mode	INT	identifica o parâmetro de sistema e o modo de acesso

Arg	INT-TMR	novo valor para acesso de "escrita"

Param	INT	valor do parâmetro acessado

Descrição:

Acesso aos parâmetros de sistema

Abaixo segue a lista dos comandos disponíveis (palavras-chaves pré-definidas) para a função SYSTEM:

comando	significado

SYS_TALLOWED	lê  tempo de ciclo permitido

SYS_TCURRENT	lê  tempo de ciclo atual

SYS_TMAXIMUM	lê  máximo tempo de ciclo

SYS_TOVERFLOW	lê tempo de ciclo excedido ("overflow")

SYS_TRESET	zera contadores de tempo ("reset")

SYS_TWRITE	muda o tempo de ciclo

SYS_ERR_TEST	verificação de erros em execução ("runtime error")

SYS_ERR_READ	lê o último erro em execução ("runtime error")

Estes são os argumentos disponíveis para tarefas pré-definidas da função SYSTEM:

comando	argument0	valor de retorno

SYS_TALLOWED	0	tempo de ciclo permitido

SYS_TCURRENT	0	tempo de ciclo atual

SYS_TMAXIMUM	0	máximo tempo detectado

SYS_TOVERFLOW	0	número de tempos excedidos (overflow)

SYS_TRESET	0	0

SYS_TWRITE	new allowed	tempo escrito

cycle timing

SYS_ERR_TEST	0	0 se não houveram erros detectados

SYS_ERR_READ	0	código de erro mais antigo

(* FBD exemplo com blocos "SYSTEM" *)

(* Programa ST equivalente: *)

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	variável de entrada ou saída

Funct	INT	ação para ser executada

Arg	INT	argumento para ação de E/S

Q	INT	retorno da verificação

Descrição:

Acesso para um canal de E/S

O significado dos argumentos do OPERATE dependem da implementação da interface de E/S. Consulte o manual de seu "hardware" ou manual técnico da correspondente placa de E/S para aprender mais sobre as possíveis utilizações do OPERATE.


Blocos de Função padrão

São Blocos de Função padrão suportados pelo sistema ISaGRAF. Desta forma, os Blocos de Função são pré-definidos e não precisam ser declarados na biblioteca.

Booleanos:

SR	Biestável  "SET" dominante

RS	Biestável  "RESET" dominante

R_TRIG	Detecção de borda de subida

F_TRIG	Detecção de borda de descida

SEMA	Semáforo

Contadores:

CTU	Contador crescente

CTD	Contador decrescente

CTUD	Contador bidirecional (crescente e decrescente)

Temporizadores:

TON	Temporizador na energização

TOF	Temporizador na desenergização

TP	Pulso temporizado

Analógicas Inteiras:

CMP	Comparação completa de bloco de função

STACKINT	Pilha de analógicas inteiras

Analógicas Reais:

AVERAGE	Calcula a média de N termos

HYSTER	Histerese referente à diferença de reais

LIM_ALRM	Limite de alarme Alto/Baixo com histerese

INTEGRAL	Integral no tempo

DERIVATE	Derivada no tempo

Geração de sinal:

BLINK	Pisca (alterna entre TRUE e FALSE) sinal booleano

SIG_GEN	Gerador de sinal

Nota: Quando novos  blocos de função "C" são criados, eles podem ser chamados a partir da linguagem FBD.


SR

Argumentos:

SET1	BOO	se TRUE, atribui a Q1 o valor TRUE (dominante)

RESET	BOO	se TRUE, atribui a Q1 o valor FALSE

Q1	BOO	estado booleano memorizado

Descrição:

Biestável  "SET" dominante. Veja tabela da verdade abaixo:

Set1 	Reset	Q1	resultado de 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 SFB usando bloco SR *)

(* Programa ST equivalente: Nós consideramos SR1 como sendo um exemplo do bloco SR *)

SR1((auto_mode & start_cmd), stop_cmd);

command := SR1.Q1;

(* Programa IL equivalente: *)

LD	auto_mode

AND	start_cmd

ST	SR1.set1

LD	stop_cmd

ST	SR1.reset

CAL	SR1

LD	SR1.Q1

ST	command


RS

Argumentos:

SET	BOO	se TRUE, atribui a Q1 o valor TRUE

RESET1	BOO	se TRUE, atribui a Q1 o valor FALSE (dominante)

Q1	BOO	estado booleano memorizado

Descrição:

Biestável  "RESET" dominante. Veja tabela da verdade abaixo:

Set 	Reset1	Q1	resultado de 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 usando bloco "RS" *)

(* Programa ST equivalente: Nós consideramos SR1 como sendo um exemplo do bloco SR *)

RS1(start_cmd, (stop_cmd OR alarm));

command := RS1.Q1;

(* Programa IL equivalente: *)

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	qualquer variável booleana

Q	BOO	TRUE quando CLK varia do estado FALSE para o estado TRUE (borda de subida)

FALSE em todos outros casos

Descrição:

Detecta borda de subida de uma variável booleana

(* Programa FBD usando bloco "R_TRIG" *)

(* Programa ST equivalente: Nós consideramos R_TRIG1 como sendo um exemplo do bloco R_TRIG *)

R_TRIG1(cmd);

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

(* Programa IL equivalente: *)

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	qualquer variável booleana

Q	BOO	TRUE quando CLK varia do estado TRUE para o estado FALSE (borda de descida)

FALSE em todos outros casos

Descrição:

Detecta borda de descida de uma variável booleana

(* programa FBD usando bloco "F_TRIG" *)

(* Programa ST equivalente: Nós consideramos F_TRIG1 como sendo um exemplo do bloco F_TRIG *)

F_TRIG1(cmd);

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

(* Programa IL equivalente: *)

LD	cmd

ST	F_TRIG1.clk

CAL	F_TRIG1

LD	F_TRIG1.Q

ANA

ADD	nb_edge

ST	nb_edge


SEMA

Argumentos:

CLAIM	BOOLEAN	comando de teste e "set"

 RELEASE	BOOLEAN	libera o semáforo

BUSY	BOOLEAN	estado do semáforo

Descrição:

(* "x" é uma variável booleana inicializada em FALSE *)

busy := x;

If claim Then

x := True;

Else

If release Then

busy := False;

x := False;

End_if;

End_if;


CTU

Argumentos:

CU	BOO	entrada de contagem (conta quando CU é TRUE)

 RESET	BOO	comando de "reset" (dominante)

PV	INT	máximo valor programado

Q	BOO	overflow: TRUE quando CV = PV

CV	INT	resultado da contagem

Atenção: O bloco CTU não detecta a borda de subida ou de descida da entrada de contagem (CU). Ele deve ser associado com um bloco "R_TRIG" ou "F_TRIG" para criar um pulso de contagem.

Descrição:

Conta (inteiro) desde 0 até um valor superior pré-definido, 1 por 1.

(* Programa FBD usando bloco "CTU" *)

(* Programa ST equivalente: Nós consideramos R_TRIG1 como sendo um exemplo do bloco R_TRIG e CTU1 como sendo um exemplo do bloco CTU *)

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

overflow := CTU1.Q;

result := CTU1.CV;

(* Programa IL equivalente: *)

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 contagem

(contagem decrescente quando CD é TRUE)

LOAD	BOO	comando de carregamento (dominante)

(CV = PV quando LOAD é TRUE)

PV	INT	valor inicial programado

Q	BOO	limite inferior: TRUE quando CV = 0

CV	INT	resultado da contagem decrescente

Atenção: O bloco CTD não detecta a borda de subida ou de descida da entrada de contagem (CD). Ele deve ser associado com um bloco "R_TRIG" ou "F_TRIG" para criar um pulso de contagem.

Descrição:

Conta (inteiro) de forma decrescente desde um valor dado até 0, 1 por 1.

(* Programa FBD usando bloco "CTD" *)

(* Programa ST equivalente: Nós consideramos F_TRIG1 como sendo um exemplo do bloco F_TRIG e CTD1 como sendo um exemplo do bloco CTD *)

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

underflow := CTD1.Q;

result := CTD1.CV;

(* Programa IL equivalente: *)

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	contagem crescente (quando CU é TRUE)

CD	BOO	contagem decrescente (quando CD é TRUE)

RESET	BOO	comando de "reset" (dominante)

(CV = 0 quando RESET é TRUE)

LOAD	BOO	comando de carregamento (CV = PV quando LOAD é TRUE)

PV	INT	máximo valor programado

QU	BOO	limite superior: TRUE quando CV = PV

QD	BOO	limite inferior: TRUE quando CV = 0

CV	INT	resultado da contagem

Atenção: O bloco CTUD não detecta a borda de subida ou de descida das entradas de contagem (CU e CD). Ele deve ser associado com um bloco "R_TRIG" ou "F_TRIG" para criar um pulso de contagem.

Descrição:

Conta (inteiro) desde 0 até um valor superior pré-definido, 1 por 1,

ou conta (inteiro) de forma decrescente desde um valor dado até 0, 1 por 1.

(* Programa FBD usando bloco "CTUD" *)

(* Programa ST equivalente: Nós consideramos R_TRIG1 e R_TRIG2 como sendo exemplo do bloco R_TRIG e CTUD1 como sendo um exemplo do bloco 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;

(* Programa IL equivalente: *)

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	Na borda de subida, inicia o incremento do acumulador de tempo interno

Na borda de descida, interrompe a contagem e zera o acumulador de tempo interno

PT	TMR	tempo máximo programado

Q	BOO	Se TRUE, o tempo programado foi expirado

ET	TMR	valor de tempo decorrido atual

Descrição:

Incrementa um acumulador de tempo interno até um valor pré-determinado.

Diagrama de tempo:


TOF

Argumentos:

IN	BOO	Na borda de descida inicia o incremento do acumulador de tempo interno

Na borda de subida, interrompe a contagem e zera o acumulador de tempo interno

PT	TMR	tempo máximo programado

Q	BOO	Se TRUE: o tempo total ainda não foi expirado

ET	TMR	valor atual de tempo decorrido

Descrição:

Incrementa um acumulador de tempo interno até um valor pré-determinado.

Diagrama de tempo:


TP

Argumentos:

IN	BOO	Na borda de subida, inicia o incremento do acumulador de tempo interno (caso já não estivesse incrementando)

Se FALSE, e apenas se o tempo acumulado tenha expirado o limite, zera o acumulador de tempo interno

Qualquer mudança na entrada IN durante a contagem de tempo, não tem efeito

PT	TMR	tempo máximo programado

Q	BOO	Se TRUE: acumulador de tempo está sendo incrementado

ET	TMR	valor atual de tempo decorrido

Descrição:

Incrementa um acumulador de tempo interno até um valor pré-determinado.

Diagrama de tempo:


CMP

Argumentos:

VAL1	INT	qualquer valor analógico inteiro

VAL2	INT	qualquer valor analógico inteiro

LT	BOO	TRUE se val1 for menor que val2

EQ	BOO	TRUE se val1 for igual a val2

GT	BOO	TRUE se val1 for maior que val2

Descrição:

Compara dois valores: informa se eles são iguais, ou se o primeiro é menor ou maior que o segundo.

(* Programa FBD usando bloco "CMP" *)

(* Programa ST equivalente: Nós consideramos CMP1 como sendo um exemplo do bloco CMP *)

CMP1(level, max_level);

pump_cmd := CMP1.LT OR CMP1.EQ;

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

(* Programa IL equivalente: *)

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 insere (apenas na borda de subida)

Adiciona o valor de IN para o topo da pilha

POP	BOO	comando retira (apenas na borda de subida)

apaga da pilha o último valor inserido (topo da pilha)

R1	BOO	leva a pilha ao seu estado vazio ("reset")

IN	INT	valor inserido

N	INT	tamanho da pilha definido na aplicação

EMPTY	BOO	TRUE se a pilha está vazia

OFLO	BOO	limite excedido ("overflow"): TRUE se a pilha está cheia

OUT	INT	valor do topo da pilha

Descrição:

Gerencia uma pilha de valores inteiros.

O bloco de função "STACKINT" detecta a borda de subida dos comandos PUSH e POP. O tamanho máximo da pilha é 128. O tamanho N da pilha, definido na aplicação, não pode ser menor que 1 nem maior que 128.

Note que o valor de OFLO somente é válido após um "reset". (R1 tenha sido levado ao estado TRUE pelo menos uma vez e voltado para o estado FALSE).

(* FBD progama usando o bloco "STACKINT": erro de gerenciamento *)

(* Programa ST equivalente: Nós consideramos STACKINT1 como sendo um exemplo do bloco STACKINT *)

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

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

err_alarm := STACKINT1.OFLO;

last_error := STACKINT1.OUT;

(* Programa IL equivalente: *)

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	TRUE=executa / FALSE=zera ("reset")

XIN	REAL	qualquer variável analógica real

N	INT	número de termos definido na aplicação

XOUT	REAL	calcula a média do valor de XIN

Descrição:

Armazena um valor a cada ciclo e calcula o valor médio de todos valores já armazenados. Aponas dos N últimos valores armazenados.

O número de termos N não pode exceder 128.

Se o comando "RUN" é FALSE (mode de "reset"). O valor da saída é igual ao valor da entrada.

Quando o número máximo N de valores é ultrapassado, o primeiro valor armazenado é substituído pelo último.

(* Programa FBD usando o bloco "AVERAGE" *)

(* Programa ST equivalente: Nós consideramos AVERAGE1 como sendo um exemplo do bloco AVERAGE *)

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

ave_value := AVERAGE1.XOUT;

(* Programa IL equivalente: *)

LD	auto_mode

AND	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	qualquer valor analógico real

XIN2	REAL	referência para testar se XIN1 ultrapassou XIN2+EPS

EPS	REAL	valor da histerese (deve ser maior que zero)

Q	BOO	TRUE se XIN1 ultrapassou XIN2+EPS ainda não é inferior a XIN2-EPS

Descrição:

Realiza a histerese de um valor real para limite alto.

Exemplo de diagrama de tempo:


LIM_ALRM

Argumentos:

H	REAL	valor de limite alto

X	REAL	entrada: qualquer valor analógico real

L	REAL	valor de limite baixo

EPS	REAL	valor da histerese (deve ser maior que zero)

QH	BOO	alarme "alto": TRUE se X for superior ao limite alto H

Q	BOO	saída de alarme: TRUE se X estiver fora dos limites

QL	BOO	alarme "baixo": TRUE se X for inferior ao limite baixo L

Descrição:

Histerese de um valor real, para limites alto e baixo.

É aplicada histerese para os limites alto e baixo. O valor da histerese (delta) para cada um dos limites (alto ou baixo), é a metade do parâmetro EPS. Abaixo segue um exemplo do diagrama de tempo:


INTEGRAL

Argumentos:

RUN	BOO	modo: TRUE=integra / FALSE=aguarda

R1	BOO	"reset" da operação

XIN	REAL	entrada: qualquer valor analógico real

X0	REAL	valor inicial

CYCLE	TMR	período de integração

Q	BOO	Inverso de R1

XOUT	REAL	saída da integração

Descrição:

Integração de um valor real.

Caso o valor do parâmetro "CYCLE" seja menor que o tempo de ciclo da aplicação ISaGRAF, o período de integração será o tempo de ciclo da aplicação.

(* Programa FBD usando o bloco "INTEGRAL": *)

(* Programa ST equivalente: Nós consideramos INTEGRAL1 como sendo um exemplo do bloco INTEGRAL *)

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

controlled_value := INTEGRAL1.XOUT;

(* Programa IL equivalente: *)

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: TRUE=normal / FALSE=zera ("reset")

XIN	REAL	entrada: qualquer valor analógico real

CYCLE	TMR	período de derivação

XOUT	REAL	saída da diferenciação

Descrição:

Realiza a diferenciação de um valor real.

Caso o valor do parâmetro "CYCLE" seja menor que o tempo de ciclo da aplicação ISaGRAF, o período de diferenciação será o tempo de ciclo da aplicação.

(* Programa FBD usando o bloco "DERIVATE": *)

(* Programa ST equivalente: Nós consideramos DERIVATE1 como sendo um exemplo do bloco DERIVATE *)

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

derivated_value := DERIVATE1.XOUT;

(* Programa IL equivalente: *)

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: TRUE=piscando / FALSE=leva a saída para FALSE ("reset")

CYCLE	TMR	período do astável

Q	BOO	sinal de saída alternada (piscante)

Descrição:

Gera um sinal alternado (astável).

Diagrama de tempo:


SIG_GEN

Argumentos:

RUN	BOO	modo: TRUE=executa / FALSE=desabilita ("reset")

PERIOD	TMR	tempo de referência

MAXIMUM	INT	valor máximo de contagem

PULSE	BOO	invertido a cada tempo de referência

UP	INT	contador, incrementa a cada tempo de referência

END	BOO	TRUE quando contador atinge o limite máximo

SINE	REAL	sinal senoidal (periodo = duração da contagem)

Descrição:

Gera vários sinais: alterna (pisca) uma variável booleana, um contador inteiro e uma senóide real.

Quando a contagem alcança o valor máximo, ela é reiniciada do valor 0 (zero). Portanto, END mantém o valor TRUE apenas durante 1 PERIOD.

Timing diagram:


Funções padrão

Estas são as funções padrão suportadas pelo sistema ISaGRAF. Tais funções são pré-definidas e não precisam ser declaradas na biblioteca.

Matemática:

ABS	Valor absoluto

EXPT	Exponencial

LOG	Logarítmica

POW	Potenciação

SQRT	Raíz quadrada

TRUNC	Trunca a parte decimal

Trigonometria:

ACOS	Arco cosseno

ASIN	Arco seno

ATAN	Arco tangente

COS	Coseno

SIN	Seno

TAN	Tangente

Controle de registro:

ROL	Rotaciona à esquerda

ROR	Rotaciona à direita

SHL	Descola para esquerda

SHR	Desloca para direita

Manipulação de dados:

MIN	Mínimo

MAX	Máximo

LIMIT	Limite

MOD	Resto da divisão

MUX4	Multiplexador (4 entradas)

MUX8	Multiplexador (8 entradas)

ODD	Paridade ímpar

RAND	Valor randômico

SEL	Seletor binário

Conversão de dados:

ASCII	Caracter · código ASCII

CHAR	código ASCII · Caracter

Manipulação de mensagens ("strings")

DELETE	Apaga "sub-string"

INSERT	Insere "string"

FIND	Encontra "sub-string"

MLEN	Obtém tamanho da "string"

LEFT	Extrai à esquerda

MID	Extrai no meio

REPLACE	Substitui "sub-string"

RIGHT	Direita de uma "string"

DAY_TIME	Hora do dia

Manipulação de matrizes ("array"):

ARCREATE	Cria matriz de valores inteiros

ARREAD	Lê elemento da matriz

ARWRITE	Escreve elemento na matriz

Manipulação de arquivo binário:

F_ROPEN	Abre um arquivo binário no mode de leitura

F_WOPEN	Abre um arquivo binário no mode de escrita

F_CLOSE	Fecha um arquivo binário

F_EOF	Verifica o fim de um arquivo binário

FA_READ	Lê um valor analógico em um arquivo binário

FA_WRITE	Escreve um valor analógico em um arquivo binário

FM_READ	Lê uma mensagem ("string") em um arquivo binário

FM_WRITE	Escreve uma mensagem ("string") em um arquivo binário


ABS

Argumentos:

IN	REAL	qualquer sinal analógico real

Q	REAL	valor absoluto (sempre positivo)

Descrição:

Fornece o valor absoluto (positivo) de um valor real.

(* Programa FBD usando bloco "ABS" *)

(* Programa ST equivalente: *)

over := (ABS (delta) > range);

(* Programa IL equivalente: *)

LD	delta

ABS

GT 	range

ST	over


EXPT

Argumentos:

IN	REAL	qualquer sinal analógico real

EXP	INT	expoente analógico inteiro

Q	REAL	(IN EXP)

Descrição:

Fornece o resultado da operação: (base exponente), onde 'base' é o primeiro argumento e 'expoente' é o segundo.

(* Programa FBD usando bloco "EXPT" *)

(* Programa ST equivalente: *)

tb_size := ANA (EXPT (2.0, range) );

(* Programa IL equivalente: *)

LD	2.0

EXPT	range

ANA

ST	tb_size


LOG

Argumentos:

IN	REAL	deve ser maior que zero

Q	REAL	logaritmo (base 10) do valor de entrada

Descrição:

Calcula o logaritmo (base 10) de uma valor real.

(* Programa FBD usando bloco "LOG" *)

(* Programa ST equivalente: *)

xpos := ABS (xval);

xlog := LOG (xpos);

(* Programa IL equivalente: *)

LD	xval

ABS

ST	xpos

LOG

ST	xlog


POW

Argumentos:

IN	REAL	número analógico real que sofrerá potenciação

EXP	REAL	exponente

Q	REAL	(IN EXP)

1.0 se IN não for 0.0 e EXP for 0.0

0.0 se IN for 0.0 e EXP for negativo

0.0 se ambos IN e EXP forem 0.0

0.0 se IN for negativo e Y não corresponder a um valor inteiro

Descrição:

Fornece o resultado da operação: (base exponente), onde 'base' é o primeiro argumento e 'expoente' é o segundo. O expoente é um valor real.

(* Programa FBD usando bloco "POW" *)

(* Programa ST equivalente: *)

result := POW (xval, power);

(* Programa IL equivalente: *)

LD	xval

POW	power

ST	result


SQRT

Argumentos:

IN	REAL	deve ser maior ou igual a zero

Q	REAL	raíz quadrada do valor de entrada

Descrição:

Calcula a raíz quadrada de um valor real.

(* Programa FBD usando bloco "SQRT" *)

(* Programa ST equivalente: *)

xpos := ABS (xval);

xroot := SQRT (xpos);

(* Programa IL equivalente: *)

LD	xval

ABS

ST	xpos

SQRT

ST	xrout


TRUNC

Argumentos:

IN	REAL	qualquer valor analógico REAL

Q	REAL	se IN>0, maior inteiro menor ou igual ao valor da entrada

se IN<0, menor inteiro maior ou igual ao valor da entrada

Descrição:

Trunca um valor real para obter apenas a parte inteira.

(* Programa FBD usando bloco "TRUNC" *)

(* Programa ST equivalente: *)

result := TRUNC (+2.67) + TRUNC (-2.0891);

(* means: result := 2.0 + (-2.0) := 0.0; *)

(* Programa IL equivalente: *)

LD	2.67

TRUNC

ST	temporary	(* temporary armazena resultado do primeiro TRUNC *)

LD	-2.0891

TRUNC

ADD	temporary

ST	result


ACOS

Argumentos:

IN	REAL	deve ser definido [-1.0 .. +1.0]

Q	REAL	arco cosseno do valor de entrada (na faixa [0.0 .. PI])

= 0.0 para entrada inválida

Descrição:

Calcula o arco coseno de um valor real

(* Programa FBD usando blocos "COS" e "ACOS" *)

(* Programa ST equivalente: *)

cosine := COS (angle);

result := ACOS (cosine); (* result é igual ao ângulo *)

(* Programa IL equivalente: *)

LD	angle

COS

ST	cosine

ACOS

ST	result


ASIN

Argumentos:

IN	REAL	deve ser definido [-1.0 .. +1.0]

Q	REAL	arco seno do valor de entrada (na faixa [-PI/2 .. +PI/2])

= 0.0 para entrada inválida

Descrição:

Caulcula o arco seno de um valor real.

(* Programa FBD usando blocos "SIN" e "ASIN" *)

(* Programa ST equivalente: *)

sine := SIN (angle);

result := ASIN (sine); (* result é igual ao ângulo *)

(* Programa IL equivalente: *)

LD	angle

SIN

ST	sine

ASIN

ST	result


ATAN

Argumentos:

IN	REAL	qualquer valor analógico real

Q	REAL	arco tangente do valor de entrada (na faixa [-PI/2 .. +PI/2])

= 0.0 para entrada inválida

Descrição:

Calcula o arco tangente de um valor real.

(* Programa FBD usando blocos "TAN" e "ATAN" *)

(* Programa ST equivalente: *)

tangent := TAN (angle);

result := ATAN (tangent); (* result é igual ao ângulo *)

(* Programa IL equivalente: *)

LD	angle

TAN

ST	tangent

ATAN

ST	result


COS

Argumentos:

IN	REAL	qualquer valor analógico REAL

Q	REAL	cosseno do valor de entrada (na faixa [-1.0 .. +1.0])

Descrição:

Calcula o coseno de um valor real.

(* Programa FBD usando blocos "COS" e "ACOS" *)

(* Programa ST equivalente: *)

cosine := COS (ângulo);

result := ACOS (cosine); (* result é igual ao ângulo *)

(* Programa IL equivalente: *)

LD	angle

COS

ST	cosine

ACOS

ST	result


SIN

Argumentos:

IN	REAL	qualquer valor analógico REAL

Q	REAL	seno do valor de entrada (na faixa [-1.0 .. +1.0])

Descrição:

Calcula o seno de um valor real.

(* Programa FBD usando blocos "SIN" e "ASIN" *)

(* Programa ST equivalente: *)

sine := SIN (ângulo);

result := ASIN (sine); (* result é igual ao ângulo *)

(* Programa IL equivalente: *)

LD	angle

SIN

ST	sine

ASIN

ST	result


TAN

Argumentos:

IN	REAL	o módulo deste valor não pode ser igual à PI/2

Q	REAL	tangente do valor de entrada

= 1E+38 para entrada inválida

Descrição:

Caulcula a tangente de um valor real.

(* Programa FBD usando blocos "TAN" e "ATAN" *)

(* Programa ST equivalente: *)

tangent := TAN (ângulo);

result := ATAN (tangent); (* result é igual ao ângulo *)

(* Programa IL equivalente: *)

LD	angle

TAN

ST	tangent

ATAN

ST	result


ROL

Argumentos:

IN	INT	qualquer valor analógico inteiro

NbR	INT	número de rotações de cada bit (na faixa [1..31])

Q	INT	valor da rotação à esquerda

sem efeito se NbR <= 0

Descrição:

Faz os bits de um inteiro rotacionarem para a esquerda. A Rotação é realizado nos 32 bits.

(* Programa FBD usando bloco "ROL" *)

(* Programa ST equivalente: *)

result := ROL (register, 1);

(* register = 2#0100_1101_0011_0101*)

(* result    = 2#1001_1010_0110_1010*)

(* Programa IL equivalente: *)

LD	register

ROL	1

ST	result


ROR

Argumentos:

IN	INT	qualquer valor analógico inteiro

NbR	INT	número de rotações de cada bit (na faixa [1..31])

Q	INT	valor da rotação à direita

sem efeito se NbR <= 0

Descrição:

Faz os bits de um inteiro rotacionarem para a direita. A Rotação é realizado nos 32 bits.

(* programa FBD usando bloco "ROR" *)

(* Programa ST equivalente: *)

result := ROR (register, 1);

(* register = 2#0100_1101_0011_0101 *)

(* result    = 2#1010_0110_1001_1010 *)

(* Programa IL equivalente: *)

LD	register

ROR	1

ST	result


SHL

Argumentos:

IN	INT	qualquer valor analógico inteiro

NbS	INT	número de deslocamento de cada bit (na faixa [1..31])

Q	INT	valor deslocado para a esquerda

Sem efeito se NbS <= 0

0 é usado para substituir o bit menos significativo

Descrição:

Faz o deslocamento dos  bits de um inteiro para a esquerda. O deslocamento é realizado nos 32 bits.

(* Programa FBD usando bloco "SHL" *)

(* Programa ST equivalente: *)

result := SHL (register,1);

(* register = 2#0100_1101_0011_0101 *)

(* result    = 2#1001_1010_0110_1010 *)

(* Programa IL equivalente: *)

LD	register

SHL	1

ST	result


SHR

Argumentos:

IN	INT	qualquer valor analógico inteiro

NbS	INT	número de deslocamento de cada bit (na faixa [1..31])

Q	INT	valor deslocado para a direita

Sem efeito se NbS <= 0

Bit mais significativo é copiado a cada deslocamento

Descrição:

Faz o deslocamento dos  bits de um inteiro para a direita. O deslocamento é realizado nos 32 bits.

(* Programa FBD usando bloco "SHR" *)

(* Programa ST equivalente: *)

result := SHR (register,1);

(* register = 2#1100_1101_0011_0101 *)

(* result    = 2#1110_0110_1001_1010 *)

(* Programa IL equivalente: *)

LD	register

SHR	1

ST	result


MIN

Argumentos:

IN1	INT	qualquer sinal com valor analógico inteiro

IN2	INT	(não pode ser REAL)

Q	INT	menor valor das duas entradas

Descrição:

Fornece o menor valor de dois valores inteiros.

(* Programa FBD usando blocos "MIN" e "MAX" *)

(* Programa ST equivalente: *)

new_value := MAX (MIN (max_value, value), min_value);

(* bounds the value to the [min_value..max_value] set *)

(* Programa IL equivalente: *)

LD	max_value

MIN	value

MAX	min_value

ST	new_value


MAX

Argumentos:

IN1	INT	qualquer sinal com valor analógico inteiro

IN2	INT	(não pode ser REAL)

Q	INT	maior valor das duas entradas

Descrição:

Fornece o maior valor de dois valores inteiros.

(* Programa FBD usando blocos "MIN" e "MAX" *)

(* Programa ST equivalente: *)

new_value := MAX (MIN (max_value, value), min_value);

(* bounds the value to the [min_value..max_value] set *)

(* Programa IL equivalente: *)

LD	max_value

MIN	value

MAX	min_value

ST	new_value


LIMIT

Argumentos:

MIN	INT	mínimo valor permitido

IN	INT	qualquer sinal com valor analógico inteiro

MAX	INT	máximo valor permitido

Q	INT	valor de entrada limitado à faixa permitida

Descrição:

Limita um valor inteiro em um intervalo dado. O valor é mantido se estiver entre os limites de mínimo e máximo, ou é congelado no limite máximo se estiver acima, ou é congelado no limite mínimo se estiver abaixo.

(* Programa FBD usando bloco "LIMIT" *)

(* Programa ST equivalente: *)

new_value := LIMIT (min_value, value, max_value);

(* limita o valor na faixa [min_value..max_value] *)

(* Programa IL equivalente: *)

LD	min_value

LIMIT	value, max_value

ST	new_value


MOD

Argumentos:

IN	INT	qualquer sinal com valor analógico inteiro

Base	INT	deve ser maior que zero

Q	INT	cálculo do resto

retorna -1 se Base <= 0

Descrição:

Calcula o resto da divisão de um valor inteiro.

(* Programa FBD usando bloco "MOD" *)

(* Programa ST equivalente: *)

division_result := (value / divider); (* divisão do valor inteiro *)

rest_of_division := MOD (value, divider); (* resto da divisão *)

(* Programa IL equivalente: *)

LD	value

DIV	divider

ST	division_result

LD	value

MOD	divider

ST	rest_of_division


MUX4

Argumentos:

SEL	INT	valor inteiro de seleção (deve estar na faixa [0..3])

IN1..IN4	INT	qualquer sinal com valor analógico inteiro

Q	INT	= valor1 se SEL = 0

= valor2 se SEL = 1

= valor3 se SEL = 2

= valor4 se SEL = 3

= 0 para todos outros valores de seleção

Descrição:

Multiplexador com 4 entradas: seleciona um valor entre 4 valores inteiros.

(* Programa FBD usando bloco "MUX4" *)

(* Programa ST equivalente: *)

range := MUX4 (choice, 1, 10, 100, 1000);

(* seleção entre os 4 valores pré-definidos, por exemplo, se choice for igual a 1, range será 10 *)

(* Programa IL equivalente: *)

LD	choice

MUX4	1,10,100,1000

ST	range


MUX8

Argumentos:

SEL	INT	valor inteiro de seleção (deve estar na faixa [0..7])

IN1..IN8	INT	qualquer sinal com valor analógico inteiro

Q	INT	= valor1 se SEL = 0

= valor2 se SEL = 1

...

= valor8 se SEL = 7

= 0 para todos outros valores de seleção

Descrição:

Multiplexador com 8 entradas: seleciona um valor entre 8 valores inteiros.

(* Programa FBD usando bloco "MUX8" *)

(* Programa ST equivalente: *)

range := MUX8 (choice, 1, 5, 10, 50, 100, 500, 1000, 5000);

(* seleção entre os 8 valores pré-definidos, por exemplo, se choice for igual a 3, range será 50 *)

(* Programa IL equivalente: *)

LD	choice

MUX8	1,5,10,50,100,500,1000,5000

ST	range


ODD

Argumentos:

IN	INT	qualquer sinal com valor analógico inteiro

Q	BOO	TRUE se o valor de entrada for ímpar

FALSE se o valor de entrada for par

Descrição:

Verifica a paridade de um inteiro: resultado é ímpar ou par

(* Programa FBD usando bloco "ODD" *)

(* Programa ST equivalente: *)

If Not (ODD (value)) Then Return; End_if;

value := value + 1;

(* faz value ser sempre par *)

(* Programa IL equivalente: *)

LD	value

ODD

RETNC

LD	value

ADD	1

ST	value


RAND

Argumentos:

base	INT	define a faixa de valores permitida

Q	INT	valor randômico na faixa [0..base-1]

Descrição:

Fornece um valor inteiro randômico dentro de uma faixa dada.

(* Programa FBD usando bloco "RAND" *)

(* Programa ST equivalente: *)

selected := MUX4 ( RAND (4), 1, 4, 8, 16 );

(*

seleção randômica entre os valores pré-definidos de 1 a 4.

O valor fornecido por RAND está na faixa [0..3],

portanto, 'selected' fornecido pelo MUX4, receberá valores randomicamente:

1 se 0 for fornecido por RAND,

ou 4 se 1 for fornecido por RAND,

ou 8 se 2 for fornecido por RAND,

ou 16 se 3 for fornecido por RAND,

*)

(* Programa IL equivalente: *)

LD	4

RAND

MUX4	1,4,8,16

ST	selected


SEL

Argumentos:

SEL	BOO	indica o valor de escolha

IN1, IN2	INT	qualquer valor analógico inteiro

Q	INT	= valor1 se SEL for FALSE

= valor2 se SEL for TRUE

Descrição:

Seletor binário:: seleciona um valor entre 2 valores inteiros.

(* Programa FBD usando bloco "SEL" *)

(* Programa ST equivalente: *)

ProCmd := SEL (AutoMode, ManuCmd, InpCmd);

(* seleção de comando do processo *)

(* Programa IL equivalente: *)

LD	AutoMode

SEL	ManuCmd,InpCmd

ST	ProCmd


ASCII

Argumentos:

IN	MSG	qualquer "string" não vazia

Pos	INT	posição do caracter selecionado

Na faixa [1.. len] (len é o tamanho da mensagem IN)

Code	INT	código do caracter selecionado

(na faixa [0 .. 255])

retorna 0 se Pos estiver for a da "string"

Descrição:

Fornece o código ASCII de um caracter na mensagem "string".

(* Programa FBD usando bloco "ASCII" *)

(* Programa ST equivalente: *)

FirstChr := ASCII (message, 1);

(* FirstChr será o código Ascii do primeiro caracter da "string" *)

(* Programa IL equivalente: *)

LD	message

ASCII	1

ST	FirstChr


CHAR

Argumentos:

Code	INT	código na faixa [0 .. 255]

Q	MSG	um caracter ("string")

o caractere tem o código ASCII fornecido na entrada Code

Descrição:

Fornece um caracter de mensagem ("string") referente ao código ASCII fornecido.

(* Programa FBD usando bloco "CHAR" *)

(* Programa ST equivalente: *)

Display := CHAR ( value + 48 );

(* value está na faixa [0..9] *)

(* 48 é o código ASCII de '0' *)

(* result é um caracter ("string") de '0' to '9' *)

(* Programa IL equivalente: *)

LD	value

ADD	48

CHAR

ST	Display


DELETE

Argumentos:

IN	MSG	qualquer mensagem não vazia

NbC	INT	número de caracteres a serem apagados

Pos	INT	posição do primeiro caracter apagado

(o primeiro caracter da mensagem tem posição 1)

Q	MSG	mensagem ("string") modificada

mensagem vazia se Pos < 1

mensagem original se Pos > IN tamanho da mensagem

mensagem original se NbC <= 0

Descrição:

Apaga parte de uma mensagem ("string")

(* Programa FBD usando bloco "DELETE" *)

(* Programa ST equivalente: *)

complete_string := 'ABCD' + 'EFGH'; (* complete_string é 'ABCDEFGH' *)

sub_string := DELETE (complete_string, 4, 3); (*  sub_string é 'ABGH' *)

(* Programa IL equivalente: *)

LD	'ABCD'

ADD	'EFGH'

ST	complete_string

DELETE	4,3

ST 	sub_string


INSERT

Argumentos:

IN	MSG	mensagem ("string") original

Str	MSG	mensagem ("string") a ser inserida

Pos	INT	posição da inserção

A inserção é feita antes da posição

(a primeira posição válida é 1)

Q	MSG	mensagem ("string") modificada

mensagem ("string") vazia se Pos <= 0

concatenação de ambas mensagens ("strings") se  Pos for maior que o tamanha da mensagem ("string") IN

Descrição:

Insere uma "sub"-string" em uma mensagem ("string") em uma dada posição

(* Programa FBD usando bloco "INSERT" *)

(* Programa ST equivalente: *)

MyName := INSERT ('Mr JONES', 'Frank ', 4);

(* MyName is 'Mr Frank JONES' *)

(* Programa IL equivalente: *)

LD	'Mr JONES'

INSERT	'Frank ',4

ST 	MyName


FIND

Argumentos:

In	MSG	qualquer mensagem ("string")

Pat	MSG	qualquer mensagem ("string") não vazia (modelo)

Pos	INT	= 0 se "sub-string" Pat não foi encontrada

= posição do primeiro caracter da primeira ocorrência da "sub-string" Pat

(a primeira posição é 1)

essa função diferencia letras maiúsculas de minúsculas ("case sensitive")

Descrição:

Encontra uma "sub-string" em uma mensagem ("string"). Fornece a posição da "sub-sting" na mensagem ("string").

(* Programa FBD usando bloco "FIND" *)

(* Programa ST equivalente: *)

complete_string := 'ABCD' + 'EFGH'; (* complete_string é 'ABCDEFGH' *)

found := FIND (complete_string, 'CDEF'); (* found é 3 *)

(* Programa IL equivalente: *)

LD	'ABCD'

ADD	'EFGH'

ST	complete_string

FIND	'CDEF'

ST 	found


MLEN

Argumentos:

IN	MSG	qualquer mensagem ("string")

NbC	INT	número de caracteres na mensage ("string") IN

Descrição:

Calcula o tamanho da mensagem ("string").

(* Programa FBD usando bloco "MLEN" *)

(* Programa ST equivalente: *)

nbchar := MLEN (complete_string);

If (nbchar < 3) Then Return; End_if;

prefix := LEFT (complete_string, 3);

(* este programa  extrai os 3 caracteres à esquerda da mensagem ("string") e coloca o resultado na variável prefix)

Nada é feito se o tamanho da "string" for menor que 3 caracteres *)

(* Programa IL equivalente: *)

LD	complete_string

MLEN

ST	nbchar

LT	3

RETC

LD	complete_string

LEFT	3

ST	prefix


LEFT

Argumentos:

IN	MSG	qualquer mensagem ("string") não vazia

NbC	INT	Número de caracteres a serem extraídos

Não pode ser superior ao tamanho da "string" IN

Q	MSG	parte esquerda da "string" IN (seu tamanho = NbC)

"string" vazia se NbC <= 0

"string" IN completa se NbC >= IN tamanho da "string"

Descrição:

Extrai a parte esquerda de uma mensagem "sting". O número de caracteres a serem extraídos é dado.

(* Programa FBD usando blocos "LEFT" e "RIGHT" *)

(* Programa ST equivalente: *)

complete_string := RIGHT ('12345678', 4) + LEFT ('12345678', 4);

(* complete_string é '56781234'

o valor fornecido por RIGHT é '5678'

o valor fornecido por LEFT é '1234'

*)

(* Programa IL equivalente: primeira função chamada é LEFT *)

LD	'12345678'

LEFT	4

ST	sub_string 	(* resultado intermediário *)

LD	'12345678'

RIGHT	4

ADD	sub_string

ST 	complete_string


MID

Argumentos:

IN	MSG	qualquer "string" não vazia

NbC	INT	número de caracteres a serem extraídos

Não pode ser maior que o tamanho da "sting" IN

Pos	INT	posição da "sub-string"

o primeiro caracter da "sub-sting" será aquele apontado por Pos

(a primeira posição válida é 1)

Q	MSG	parte do meio da "string" (seu tamanho é = NbC)

"string" vazia se os parâmetros não forem válidos

Descrição:

Extrai uma parte da mensagem "string". O número de caracteres a serem extraídos e a posição do primeiro caracter são dados.

(* Programa FBD usando bloco "MID" *)

(* Programa ST equivalente: *)

sub_string := MID ('abcdefgh', 2, 4);

(* sub_string é 'de' *)

(* Programa IL equivalente: *)

LD	'abcdefgh'

MID	2,4

ST	sub_string


REPLACE

Argumentos:

IN	MSG	qualquer "string"

Str	MSG	"string" a ser inserida (substituir NbC caracteres)

NbC	INT	número de caracteres a serem apagados

Pos	INT	posição do primeiro caracter modificado

(a primeira posição válida é 1)

Q	MSG	"string" modificada:

- NbC caracteres são apagados na posições Pos

- então a "substring" Str é inserida nesta posição

retorna "string" vazia se  Pos <= 0

retorna a concatenação de "stings" (IN+Str) se Pos for maior que o tamanho da "sting" IN

retorna a "string" original IN se NbC <= 0

Descrição:

Substitui uma parte de uma "sting" por uma nova sequência de caracteres.

(* Programa FBD usando bloco "REPLACE" *)

(* Programa ST equivalente: *)

MyName := REPLACE ('Mr X JONES, 'Frank', 1, 4);

(* MyName é 'Mr Frank JONES' *)

(* Programa IL equivalente: *)

LD	'Mr X JONES'

REPLACE	'Frank',1,4

ST	MyName


RIGHT

Argumentos:

IN	MSG	qualquer "string" não vazia

NbC	INT	não pode ser maior que o tamanho da "string" IN

Q	MSG	parte direita da "string" (tamanho = NbC)

"string" vazia se NbC <= 0

"string" completa se NbC >= tamanho da "string"

Descrição:

Extrai a parte direita de uma mensagem "string". O número de caracteres a serem extraídos é dado.

(* Programa FBD usando blocos "LEFT" e "RIGHT" *)

(* Programa ST equivalente: *)

complete_string := RIGHT ('12345678', 4) + LEFT ('12345678', 4);

(* complete_string é '56781234'

o valor fornecido por RIGHT é '5678'

o valor fornecido por LEFT é '1234'

*)

(* Programa IL equivalente: primeira função chamada é LEFT *)

LD	'12345678'

LEFT	4

ST	sub_string 	(* resultado intermediário *)

LD	'12345678'

RIGHT	4

ADD	sub_string

ST 	complete_string


DAY_TIME

Argumentos:

SEL	INT	seleção da saída

0= obtém a data atual

1= obtém a hora atual

2= obtém o dia da semana atual

Q	MSG	hora/data expressado em uma "string"

'YYYY/MM/DD' se SEL = 0

'HH:MM:SS' se SEL = 1

nome do dia se SEL = 2 (ex: 'Monday')

Descrição:

Fornece a data ou hora do dia com uma mensagem "string"

(* Programa FBD usando bloco "DAY_TIME" *)

(* Programa ST equivalente: *)

Display := Day_Time (0) + ' ; ' + Day_Time (1);

(* o formato de apresentação do texto é: 'YYYY/MM/DD ; HH:MM:SS' *)

(* Programa IL equivalente: primeira função executada é day_time(1) *)

LD	1

DAY_TIME

ST	hour_str 	(* resultado intermediário *)

LD	0

DAY_TIME

ADD	' ; '

ADD	hour_str

ST 	Display


ARCREATE

Argumentos:

ID	INT	identificador da matriz (deve estar na faixa [0..15])

Size	INT	número de elementos da matriz

ok	INT	estados de execução :

1 = se a matriz foi criada com sucesso

2 = identificador da matriz inválido ou matriz já criada

3 = tamanho inválido

4 = memória insuficiente

Descrição:

Criação de uma matriz de inteiros.

Aenção: Existem até 16 matrizes em uma aplicação. Matrizes contém valores analógicos inteiros. Da maneira que a memória dinâmica é tratada, esta função pode causar um erro de sistema se o tamanho da matriz for muito próximo da memória disponível.

(* Programa FBD criando uma matriz de inteiros *)

(* Programa ST equivalente: *)

array_error := (ARCREATE (ident, 16) <> 1));

(* Programa IL equivalente: *)

LD	ident

ARCREATE	16

NE 	1

ST	array_error


ARREAD

Argumentos:

ID	INT	identificador da matriz (deve estar na faixa [0..15])

Pos	INT	posição do elemento na matriz

deve estar na faixa [0 .. tamanho-1]

value	INT	valor do elemento lido

0 se os argumentos não forem válidos

Descrição:

Lê um elemento de uma matriz de inteiros.

(* Programa FBD usando blocos de manipulação de matrizes *)

(* Programa ST equivalente: *)

If (array_error) Then Return; End_if;

read_value := ARREAD (ident, index);

(* array_error vem da função ARCREATE chamada *)

(* Programa IL equivalente: *)

LD	array_error

RETC

LD	ident

ARREAD	index

ST	read_value


ARWRITE

Argumentos:

ID	INT	identificador da matriz (deve estar na faixa [0..15])

Pos	INT	posição do elemento na matriz

deve estar na faixa [0 .. tamanho-1]

IN	INT	novo valor para o elemento

ok	INT	estados de execução:

1 = escrita bem sucedida

2 = identificador da matriz inválido

3 = índice inválido

Descrição:

Armazena (escreve) um valor em uma matriz de inteiros.

(* Programa FBD usando blocos de manipulação de matrizes *)

(* Programa ST equivalente: *)

If (array_error) Then Return; End_if;

write_status := ARWRITE (Ident, Index, value);

(*array_error vem da função ARCREATE chamada *)

(* Programa IL equivalente: *)

LD	array_error

RETC

LD	ident

ARWRITE	index,value

ST	write_status


F_ROPEN

Argumentos:

Path	MSG	nome do arquivo

Pode incluir o caminho de acesso do arquivo usando os símbolos \ ou / para especificar o diretório.

Para facilitar a compatibilidade, / ou \ são equivalentes.

ID	INT	número do arquivo

0 se ocorrer um erro: arquivo não existe

Descrição:

Abre um arquivo binário em modo de leitura. Para ser usado com FX_READ e F_CLOSE.

Esta função não está incluída no simulador ISaGRAF.

(* Programa FBD usando blocos de manipulação de arquivos *)

(* Programa ST equivalente: *)

file_id := F_ROPEN('c:\data \data.bin');

error := (file_id=0);

(* Programa IL equivalente: *)

LD	'c:\data\data.bin'

F_ROPEN

ST	file_id

EQ	0

ST	error


F_WOPEN

Argumentos:

Path	MSG	nome do arquivo

Pode incluir o caminho de acesso do arquivo usando os símbolos \ ou / para especificar o diretório.

Para facilitar a compatibilidade, / ou \ são equivalentes.

ID	INT	número do arquivo

0 se ocorrer um erro: se o arquivo já existe, ele é escrito por cima

Descrição:

Abre um arquivo binário em modo de escrita. Para ser usado com FX_WRITE e F_CLOSE.

Esta função não está incluída no simulador ISaGRAF.

(* Programa FBD usando blocos de manipulação de arquivos *)

(* Programa ST equivalente: *)

file_id := F_WOPEN('c:\data \data.bin');

error := (file_id=0);

(* Programa IL equivalente: *)

LD	'c:\data\data.bin'

F_WOPEN

ST	file_id

EQ	0

ST	error


F_CLOSE

Argumentos:

ID	INT	número do arquivo: fornecido por F_ROPEN ou F_WOPEN.

ok	BOO	estado de retorno:

TRUE  se o fechamento do arquivo for Ok

FALSE se um erro ocorrer

Descrição:

Fecha um arquivo binário aberto com funções F_ROPEN ou F_WOPEN.

Esta função não está incluída no simulador ISaGRAF.

 (* Programa FBD usando blocos de manipulação de arquivos *)

(* Programa ST equivalente: *)

file_id := F_ROPEN('data.bin');

ok := F_CLOSE(file_id);

(* Programa IL equivalente: *)

LD	'data.bin'

F_ROPEN

ST	file_id

F_CLOSE	(* file_id já está no resultado IL atual *)

ST 	ok


F_EOF

Argumentos:

ID	INT	número do arquivo fornecido por F_ROPEN ou F_WOPEN.

ok	BOO	indicador do fim do arquivo

TRUE caso o fim do arquivo tenha sido alcançado no último procedimento de leitura ou escrita chamado.

Com FM_READ, a última mensagem lida do arquivo pode não ser correta, se o último caracter não for uma "string" de terminação.

Descrição:

Verifica se o fim do arquivo foi alcançado.

Está função não está incluída no simulador ISaGRAF.

(* Programa FBD usando blocos de manipulação de arquivos *)

(* Programa ST equivalente: *)

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);

(* Programa IL equivalente: *)

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 	(* se not eof, continua leitura *)

END_OF_FILE:	LD	VAL

MSG

ST	val_msg	(* conversão de  VAL para uma mensagem *)

LD	'last val = '

ADD	val_msg

ST	MESSAGE

LD 	file_id

F_CLOSE

ST	ok


FA_READ

Argumentos:

ID	INT	número do arquivo: fornecido por F_ROPEN.

Q	INT	valor analógico inteiro lido do arquivo

Descrição:

Lê variáveis ANALÓGICAS do arquivo binário. Para ser usada com F_ROPEN e F_CLOSE.

Este procedimentos realiza um acesso sequencial ao arquivo, a partir da posição anterior.

A primeira chamada após F_ROPEN lê os 4 bytes do arquivo,

cada chamada atualiza o ponteiro de leitura.

Para verificar se o fim do arquivo foi alcançado, use F-EOF.

Esta função não está incluída no simulador ISaGRAF.

 (* Programa FBD usando blocos de manipulação de arquivos *)

(* Programa ST equivalente: *)

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);

(* Programa IL equivalente: *)

LD	'voltramp.bin'

F_ROPEN

ST	file_id

FA_READ	(* lê vstart *)

ST	vstart

LD 	file_id

FA_READ	(* lê vend *)

ST	vend

LD 	file_id

FA_READ	(* lê vinc *)

ST	vinc

LD 	file_id

FA_READ	(* lê delta_tim *)

TMR	(* conversão para "timer" *)

ST	delta_tim

LD 	file_id

F_CLOSE

ST	ok


FA_WRITE

Argumentos:

ID	INT	número do arquivo: fornecido por F_WOPEN.

IN	INT	valor analógico inteiro a ser escrito no arquivo

OK	BOO	estado da execução: TRUE se ok

Descrição:

Escreve variáveis ANALÓGICAS para um arquivo binário.

Este procedimento realiza um acesso sequencial ao arquivo, a partir da posição anterior.

A primeira chamada após F_WOPEN escreve os 4 primeiros bytes do arquivo,

cada chamada atualiza o ponteiro de escrita.

Esta função não está incluída no simulador ISaGRAF.

(* Programa FBD *)

(* Programa ST equivalente: *)

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);

IF ( nb_written <> 4) THEN

ERROR := ERR_FILE;

END_IF;

(* Programa IL equivalente: *)

LD	'voltramp.bin'

F_ROPEN

ST	file_id

LD	0

ST	nb_written

LD 	file_id	(* write vstart *)

FA_WRITE	vstart

ANA

ADD	nb_written

ST	nb_written

LD 	file_id	(* write vend *)

FA_WRITE	vend

ANA

ADD	nb_written

ST	nb_written

LD 	file_id	(* write vinc *)

FA_WRITE	vinc

ANA

ADD	nb_written

LD	(* write delta_tim *)

ANA	(* convert it to an integer *)

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	(* return if equal 4 *)

LD	ERR_FILE	(* else error *)

ST	ERROR


FM_READ

Argumentos:

ID	INT	número do arquivo: fornecido por F_ROPEN.

Q	MSG	valor da mensagem lida do arquivo

Descrição:

Lê variáveis MESSAGE de um arquivo binário.

Para ser usada com F_ROPEN e F_CLOSE.

Este procedimento realiza um acesso sequencial ao arquivo, a partir da posição anterior.

A primeira chamada após F_ROPN lê a primeira "string" do arquivo,

cada chamada atualiza o ponteiro de escrita.

Uma "string" é finalizada por vazio null (0), en of file ('\n') ou return ('\r');

Para verificar se o fim do arquivo foi alcançado, use F_EOF.

Esta função não está incluída no simulador ISaGRAF.

(* Programa FBD usando blocos de manipulação de arquivos *)

(* Programa ST equivalente: *)

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);

(* Programa IL equivalente: *)

LD	'voltramp.bin'

F_ROPEN

ST	file_id

FM_READ	(* lê status1 *)

ST	status1

LD 	file_id

FM_READ	(* lê status2 *)

ST	status2

LD 	file_id

F_EOF

JMPNC	CLOSE_FILE (* se for fim do arquivo não pula *)

LD	ERR_FILE

ST	ERROR

LD 	file_id

FM_READ	(* lê unused_eof_mes *)

ST	unused_eof_mes

CLOSE_FILE	LD 	file_id

F_CLOSE

ST	ok


FM_WRITE

Argumentos:

ID	INT	número do arquivo: fornecido por F_WOPEN.

IN	MSG	valor da mensagem a ser escrita no arquivo

ok	BOO	estado da execução:

TRUE se for bem sucedida

Descrição:

Escreve variáveis MESSAGE em um arquivo binário.

Para ser usado com F_WOPEN e F_CLOSE.

Uma mensagem é escrita no arquivo como uma "string" nula de terminação.

Este procedimento realiza um acesso sequencial ao arquivo, a partir da posição anterior.

A primeira chamada após F_WOPEN escreve a primeira "string" para o arquivo,

cada chamada atualiza o ponteiro de escrita.

Esta função não está incluída no simulador ISaGRAF.

(* Programa FBD usando blocos de manipulação de arquivos *)

(* Programa ST equivalente: *)

file_id := F_WOPEN('trace.txt');

ok := FM_WRITE(file_id,'First message');

ok := FM_WRITE(file_id,'Last message');

ok := F_CLOSE(file_id);

(* Programa IL equivalente: *)

LD	'trace.txt'

F_WOPEN

ST	file_id

FM_WRITE	'First message'	(* escreve primeira mensagem *)

ST	ok

LD 	file_id

FM_WRITE	'Last message'	(* escreve segunda mensagem *)

ST	ok

LD 	file_id

F_CLOSE

ST	ok


Índice 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