Guida di riferimento ai linguaggi di programmazione

Architettura del progetto

Oggetti comuni

Linguaggio SFC

Linguaggio FC

Linguaggio FBD

Linguaggio LD

Linguaggio ST

Linguaggio IL

Operatori standard, funzioni e blocchi funzione


Architettura del progetto

Un progetto ISaGRAF è composto da più unità di programmazione chiamate programmi. I programmi di un progetto sono legati assieme con un'architettura di tipo ad albero. I programmi possono essere scritti con i linguaggi SFC, FC (Flow Chart), FBD, LD, ST o IL sia in modo grafico che testuale.

Programmi

Operazioni  di tipo ciclico e sequenziale

Programmi SFC ed FC, programmi figli SFC

Funzioni e sottoprogrammi

Blocchi funzione

Descrizione del linguaggio

Regole di esecuzione


Programmi

Un programma è costituito da un'unità logica di programmazione, che descrive le operazioni tra le variabili di un processo. Possono essere rappresentate sia operazioni sequenziali che cicliche. I programmi di tipo ciclico sono eseguiti ad ogni ciclo del sistema. L'esecuzione di programmi di tipo sequenziale si attengono alle regole del linguaggio SFC o del linguaggio FC.

I programmi sono legati assieme in una struttura del tipo ad albero gerarchico. I programmi principali sono posti in cima all'albero gerarchico e sono attivati dal sistema. I sottoprogrammi e i programmi figli (i livelli inferiori della struttura ad albero) vengono attivati dai rispettivi programmi padre. Un programma può essere scritto usando i seguenti linguaggi:

Sequential Function Chart (SFC) 	per operazioni di livello alto

Flow Chart (FC)                            	per operazioni di livello alto

Function Block Diagram (FBD)    	per operazioni cicliche complesse

Ladder Diagram (LD)                    	solamente per operazioni di tipo booleano

Structured Text (ST)                    	per qualsiasi operazione di tipo ciclico

Instruction List (IL)                      	per operazioni di livello basso

In uno stesso programma non possono coesistere linguaggi diversi, ad eccezione dei linguaggi LD e FBD che possono essere combinati assieme su uno stesso diagramma.


Operazioni di tipo ciclico e sequenziale

La gerarchia dei programmi consta di quattro principali sezioni di gruppi:

Iniziale	programmi che vengono eseguiti all'inizio di ciascun ciclo

Sequenziale	programmi che rispettano le regole della dinamica SFC

Finale	programmi eseguiti al termine di ogni ciclo

Funzioni	insieme di sottoprogrammi non dedicati

I programmi della sezione Iniziale o Finale servono a rappresentare operazioni di tipo ciclico e non dipendono dal tempo. I programmi della sezione Sequenziale rappresentano operazioni di tipo sequenziale in cui la variabile tempo sincronizza esplicitamente le operazioni di base.

I programmi principali della sezione Iniziale vengono eseguiti sistematicamente all'inizio di ogni ciclo di esecuzione. I programmi principali della sezione Finale vengono eseguiti sistematicamente al termine di ciascun ciclo di esecuzione. I programmi principali della sezione Sequenziale vengono eseguiti secondo le regole della dinamica SFC o FC.

I programmi delle sezioni di tipo ciclico (Iniziale ed Finale) non possono venire scritti in linguaggio SFC o FC.

I programmi principali della sezione Sequenziale sono obbligatoriamente scritti in linguaggio SFC o FC, così come i loro programmi figli sono obbligatoriamente scritti rispettivamente in linguaggio SFC e FC (da non confondere con i sottoprogrammi che invece non possono essere scritti in linguaggio SFC o FC).

I programmi della sezione Funzioni sono chiamati sottoprogrammi e possono essere chiamati da un qualsiasi altro programma (sia un padre, che un figlio) del progetto. Un programma della sezione Funzioni può chiamare un altro programma della medesima sezione Funzioni.

I sottoprogrammi non possono venire scritti in linguaggio SFC o FC.

Qualsiasi programma di qualsiasi sezione può avere uno o più sottoprogrammi, che obbligatoriamente non devono essere scritti in linguaggio SFC o FC.

I programmi della sezione Iniziale vengono tipicamente usati per descrivere operazioni preliminari su dispositivi di ingresso per costruire variabili filtrate ad alto livello. Queste variabili vengono usate frequentemente dai programmi della sezione Sequenziale. I programmi della sezione Finale, normalmente, eseguono controlli di sicurezza sulle variabili elaborate dalla sezione Sequenziale, prima dell'invio dei loro valori ai dispositivi di output.


Programmi SFC ed FC, programmi figli SFC

Ogni programma SFC della sezione Sequenziale può controllare altri programmi SFC. Tali programmi di livello inferiore vengono chiamati programmi figli SFC. Un programma figlio SFC è un programma parallelo (entrambi padre e figlio vengono eseguiti in parallelo), che può essere avviato, terminato, sospeso o riavviato dal proprio programma padre. Sia il programma padre che il figlio devono essere entrambi scritti in linguaggio SFC. Un programma SFC figlio può contenere variabili e nomi definiti con campo di validità LOCALE (cioè sono utilizzabili solo localmente al programma in cui sono dichiarati).

Un programma genitore che avvia un programma SFC figlio, inserisce un token SFC in ciascun passo iniziale del programma figlio. Un programma genitore che termina un programma SFC figlio, rimuove tutti i token esistenti nei passi del programma figlio.

L'avvio di un programma figlio avviene con l'istruzione GSTART, la terminazione di un programma figlio avviene con l'istruzione GKILL.

Quando un programma genitore sospende un programma figlio SFC, rimuove da esso tutti i token esistenti, memorizzandone la posizione. Quando un programma genitore riavvia un programma figlio SFC sospeso, ripristina tutti i token rimossi al momento della sospensione del programma figlio.

La sospensione di un programma figlio avviene con l'istruzione GFREEZE, il riavvio di un programma figlio avviene con l'istruzione GRST.

Per quanto riguarda la gestione dei sottoprogrammi il linguaggio FC (Flow Chart) si differenzia dal linguaggio SFC (Sequential Function Chart).

Ogni programma FC della sezione Sequenziale può controllare un altro sottoprogramma FC. Durante l'esecuzione di un sottoprogramma FC, il programma FC padre viene bloccato (in stato di attesa). Non è possibile eseguire operazioni simultanee in un programma FC padre ed in uno dei suoi sottoprogrammi FC.


Funzioni e sottoprogrammi

L'esecuzione di un sottoprogramma o di una funzione viene guidata dal relativo programma padre.

A differenza del caso di un programma figlio attivato da un programma padre, nel caso di chiamata a un sottoprogramma o ad una funzione, l'esecuzione del programma padre viene sospesa fino al termine del sottoprogramma o della funzione:

Ogni programma di ogni sezione può avere uno o più sottoprogrammi. Un sottoprogramma è una funzione dedicata ad un solo programma padre. Un sottoprogramma può avere variabili e definizioni locali. Un sottoprogramma può essere scritto con qualunque linguaggio, ad eccezione del linguaggio SFC (tale linguaggio può essere usato per descrivere un programma figlio).

I programmi della sezione Funzioni sono sottoprogrammi che possono essere richiamati da qualunque altro programma del progetto. A differenza dei sottoprogrammi delle altre sezioni, non sono dedicati ad un unico programma padre. Un programma della sezione Funzioni può chiamare un altro programma della stessa sezione (ma non se stesso). Una funzione può risiedere nella libreria.

Avvertenza: Il sistema ISaGRAF non supporta la ricorsività delle chiamate a funzioni. Si verificherà un errore in esecuzione nel caso in cui un programma della sezione Funzioni venga chiamato da se stesso o da uno dei sottoprogrammi da esso chiamati.

Avvertenza: Una funzione o un sottoprogramma (funzione dedicata ad un padre) non "memorizza" i valori delle proprie variabili locali. Una funzione o un sottoprogramma non viene istanziato e non può, quindi, richiamare blocchi funzione.

L'interfaccia di una funzione o di un sottoprogramma deve essere definita esplicitamente usando un unico nome e un unico tipo di dato per ogni parametro di ingresso o per il parametro di ritorno.

Una funzione può avere un unico parametro di ritorno e complessivamente 32 parametri di chiamata o ritorno. Per compatibilità con il linguaggio ST, il parametro di ritorno, deve avere lo stesso nome del sottoprogramma.

La tavola seguente mostra come impostare il valore del parametro di ritorno all'interno di una funzione o di un sottoprogramma, con i differenti linguaggi:

ST:	al parametro di ritorno viene assegnato il proprio nome

(lo stesso nome del sotto programma):

   nome_sottoprogramma := <espressione>;

IL:	il valore del risultato corrente (registro IL)

è contenuto, al termine della sequenza, nel parametro di ritorno:

   LD      10

   ADD   20   (* valore del parametro di ritorno = 30 *)

FBD:	imposta il parametro di ritorno usando il proprio nome:

 nome_sottoprogramma

LD:	usa il simbolo di bobina con il nome del parametro di ritorno:

nome_sottoprogramma


Blocchi funzione

Un blocco funzione può essere scritto in linguaggio: LD, FBD, ST o IL. Un blocco funzione può avere più parametri di ritorno e complessivamente 32 parametri di chiamata e ritorno.

Un blocco funzione viene istanziato. Ciò significa che viene eseguita una copia delle variabili locali di un blocco funzione per ogni istanza: viene richiamato lo stesso codice, ma i dati usati sono quelli allocati per l'istanza. I valori delle variabili dell'istanza vengono memorizzati tra un ciclo e l'altro.

Avvertenza:

- Un blocco funzione scritto in uno dei linguaggi IEC non può chiamare altri blocchi funzione: il meccanismo che regola le istanze gestisce solamente le variabili locali del blocco stesso. Di seguito viene riportata una lista di blocchi funzione standard che non possono essere richiamate da un blocco funzione 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

- Per la stessa ragione, non è possibile usare contatti o bobine di tipo Positivo o Negativo, o bobine di tipo set o reset.

- Le funzioni TSTART e TSTOP, che provvedono ad avviare e fermare i timer, non possono essere usate in un blocco funzione di un target versione 3.0x. Funzionano a partire dalla versione 3.20.

- Volendo usare un loop In un blocco funzione, è necessario dichiarare la variabile locale prima. Si veda il seguente esempio:

Questo non funziona:	Questo va bene:


Descrizione del linguaggio

Un programma può essere scritto usando uno qualsiasi dei seguenti linguaggi grafici o testuali:

Sequential Function Chart (SFC) 	per operazioni di livello alto

Flow Chart (FC)                            	per operazioni di livello alto

Function Block Diagram (FBD)    	per operazioni cicliche complesse

Ladder Diagram (LD)                    	solamente per operazioni di tipo booleano

Structured Text (ST)                    	per qualsiasi operazione di tipo ciclico

Instruction List (IL)                      	per operazioni di livello basso

In uno stesso programma non possono coesistere linguaggi diversi. Il linguaggio viene scelto alla creazione del programma e non può più essere cambiato. Fanno eccezione i linguaggi LD e FBD, che possono essere combinati assieme in uno stesso programma.


Regole di esecuzione

Il sistema ISaGRAF è sincrono. Tutte le operazioni eseguite sul PLC target sono comandate da un impulso di clock. La durata base del clock, viene chiamata Tempo di ciclo:

Le operazioni di base eseguite durante un ciclo destinazione sono:

Il sistema provvede a:

- garantire che una variabile di ingresso mantenga lo stesso valore all'interno di un ciclo,

- garantire che un dispositivo di uscita non venga aggiornato più di una volta per ciclo,

- operare in modo sicuro sulla stessa variabile globale usata in programmi diversi,

- stimare e controllare il tempo di ciclo utilizzato da un'applicazione completa.


Oggetti comuni

Vengono qui illustrate le caratteristiche principali e gli oggetti comuni del data base di programmazione ISaGRAF. Tali oggetti possono essere usati in uno qualsiasi dei linguaggi SFC, FC FBD, LD, ST o IL.

Tipi base

Espressioni costanti

Variabili

Commenti

Nomi definiti


Tipi base

Qualsiasi costante, espressione o variabile usata in un programma (qualunque sia il linguaggio) deve essere caratterizzata da un tipo. È importante rispettare la coerenza tra tipi sia in operazioni con grafico che in istruzioni testuali. Di seguito sono elencati i tipi base disponibili per gli oggetti di programmazione:

BOOLEANO:	valore logico (true o false)

ANALOGICO:	valore continuo intero o real (floating)

TIMER:	valore temporale

MESSAGGIO:	stringa di caratteri

Nota: I timers contengono valori inferiori ad un giorno e non possono essere usati per memorizzare date.


Espressioni costanti

Le espressioni costanti si riferiscono ad un solo tipo. La stessa notazione non può essere usata per rappresentare espressioni costanti di tipo differente.

Espressioni costanti di tipo booleano

Espressioni costanti di tipo analogico intero

Espressioni costanti di tipo analogico reale

Espressioni costanti di tipo timer

Espressioni costanti di tipo stringa messaggio


Espressioni costanti di tipo booleano

Esistono solo due espressioni costanti booleane:

TRUE	equivalente al valore intero 1

FALSE	equivalente al valore intero 0

Nelle parole chiave "True" e "False" non viene fatta distinzione tra maiuscole e minuscole.


Espressioni costanti di tipo analogico intero

Le espressioni costanti intere rappresentano valori interi lunghi con segno (32 bit):

da -2147483647 a +2147483647

Le costanti intere di tipo analogico possono essere espresse con uno dei seguenti tipi base. Le costanti intere devono iniziare con un prefisso che identifica il tipo base usato:

Base	Prefisso	Esempio

DECIMALE	(nessuno)	-908

ESADECIMALE	"16#"	16#1A2B3C4D

OTTALE	"8#"	8#1756402

BINARIO	"2#"	2#1101_0001_0101_1101

Il carattere underscore ('_') permette di separare gruppi di cifre. Non ha alcun significato particolare, ma migliora la leggibilità delle espressioni costanti.


Espressioni costanti di tipo analogico Real
Espressioni costanti di tipo analogico Reale

Le espressioni costanti di tipo Reale analogico possono essere scritte usando la rappresentazione decimale o scientifica. Il punto decimale ('.') separa la parte intera dalla parte decimale. Nella rappresentazione scientifica la mantissa e l'esponente sono separate dalle lettere 'E' o 'F'. L'esponente di un'espressione in notazione scientifica deve essere un valore di tipo intero con segno compreso tra -37 e +37. Di seguito sono riportati alcuni esempi di espressioni costanti di tipo analogico reale:

3.14159	-1.0E+12

+1.0	1.0F-15

-789.56	+1.0E-37

L'espressione "123" non è di tipo reale. La corretta rappresentazione di tipo reale è "123.0".


Espressioni costanti di tipo Timer

Le espressioni costanti di tipo Timer rappresentano valori temporali compresi tra 0 secondi e 23h59m59s999ms. La più piccola entità rappresentabile è il millisecondo. Alcune unità temporali standard  usate in espressioni costanti sono:

Hour	Lettera "h" posta dopo il numero di ore

Minute	Lettera "m" posta dopo il numero di minuti

Second	Lettera "s" posta dopo il numero di secondi

Millisecond	Lettere "ms" poste dopo il numero di millisecondi

Le espressioni costanti di tipo timer hanno il prefisso "T#" o "TIME#". Non viene fatta distinzione tra maiuscole e minuscole nei prefissi e nelle lettere. Seguono alcuni esempi di espressioni costanti di tipo timer:

T#1H450MS	1 ora, 450 millisecondi

time#1H3M	1 ora, 3 minuti

L'espressione "0" non rappresenta un valore temporale, ma una costante di tipo analogico.


Espressioni costanti di tipo stringa messaggio

Le espressioni costanti di tipo stringa  o messaggio rappresentano stringhe di caratteri. I caratteri devono essere preceduti da un apice e seguiti da un apostrofo. Ad esempio:

'ECCO UN MESSAGGIO'

Avvertenza: Non è possibile usare il carattere apostrofo ''' all'interno di una espressione costante di tipo stringa. Un'espressione costante di tipo stringa deve essere contenuta in una sola riga del codice sorgente del programma. La lunghezza complessiva non deve eccedere i 255 caratteri, spazi compresi.

L'espressione costante stringa vuota viene rappresentata da due apostrofi che non contengono il carattere spazio o tabulazione.:

''   (* questa è una stringa vuota *)

Il carattere speciale dollaro  ('$'), seguito da altri caratteri speciali, si usa all'interno di una stringa per rappresentare i caratteri non stampabili:

Sequenze	Significato	ASCII (hexa)	Esempio

$$	carattere '$'	16#24	'Mi è costato $$5'

$'	apostrofo	16#27	'Inserire $'Y$' per YES'

$L	line feed	16#0a	'riga $L seguente'

$R	ritorno carrello	16#0d	'   ao $R Ci'

$N	nuova riga	16#0d0a	'Questa è una riga $N'

$P	nuova pagina	16#0c	'ultima riga $P prima riga'

$T	tabulazione	16#09	'nome$Tdim$Tdata'

$hh   (*)	qualsiasi carattere	16#hh	'ABCD = $41$42$43$44'

(*) "hh" rappresenta il valore esadecimale del codice ASCII del carattere da esprimere.


Variabili

Le variabili possono essere LOCALI ad un programma o GLOBALI. le variabili locali possono essere usate da un solo programma. Le variabili globali vengono viste da ogni programma del progetto.

Parole chiave riservate

Variabili rappresentate direttamente

Variabili di tipo booleano

Variabili di tipo analogico

Variabili di tipo timer

Variabili di tipo stringa messaggio

I nomi delle variabili devono rispettare le seguenti regole:

Il nome non può eccedere i 16 caratteri

il primo carattere deve essere una lettera

i caratteri seguenti possono essere lettere, cifre o il carattere underscore


Parole chiave riservate

Viene riportato sotto l'elenco delle parole chiave . Tali identificatori non possono essere usati come nome di programma, variabile, funzione "C" o blocchi funzione:

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

Tutte le parole chiave che iniziano con il carattere underscore ('_') sono ad uso interno e non devono essere usate in istruzioni testuali.


Variabili rappresentate direttamente

ISaGRAF consente l'uso nel codice del programma di variabili rappresentate direttamente per identificare un canale libero. Per canali liberi si intendono quelli che non sono associati ad una variabile I/O. L'identificatore di una variabile rappresentata direttamente inizia sempre con il carattere "%"

Seguono le convenzioni per assegnare il nome ad una variabile rappresentata direttamente per un canale di una apparecchiatura complessa. "s" è il numero di connessione (slot) della scheda. "c" il numero del canale.

%Ixs.c	canale libero di una scheda di input booleana

%IDs.c	canale libero di una scheda di input intera

%ISs.c	canale libero di una scheda di input di tipo messaggio

%QXs.c	canale libero di una scheda di output booleana

%QDs.c	canale libero di una scheda di output intera

%QSs.c	canale libero di una scheda di output di tipo messaggio

Seguono le convenzioni per assegnare il nome ad una variabile rappresentata direttamente per un canale di una apparecchiatura complessa. "s" è il numero di connessione (slot) della scheda. "b" è l'indice della singola scheda all'interno dell'apparecchiatura. "c" il numero del canale.

%IXs.b.c	canale libero di una scheda di input booleana

%IDs.b.c	canale libero di una scheda di input intera

%ISs.b.c	canale libero di una scheda di input di tipo messaggio

%QXs.b.c	canale libero di una scheda di output booleana

%QDs.b.c	canale libero di una scheda di output intera

%QSs.b.c	canale libero di una scheda di output di tipo messaggio

Seguono degli esempi:

%QX1.6	6° canale della scheda #1 (output booleano)

%ID2.1.7	7° canale della scheda #1 nell'apparecchiatura #2 (input intero)

Una variabile rappresentata direttamente non può essere di tipo "reale".


Variabili di tipo booleano

Booleano significa logico. Variabili di questo tipo possono assumere valori booleani: TRUE o FALSE. Le variabili booleane vengono tipicamente usate in espressioni booleane. Le variabili booleane possono avere uno dei seguenti attributi:

Interna:	variabile gestita dal programma

Ingresso:	variabile riferita ad un dispositivo di ingresso (aggiornata dal sistema)

Uscita:	variabile riferita ad un dispositivo di uscita

Avvertenza: Dichiarando una variabile booleana, si possono definire delle stringhe sostitutive dei valori 'true' e 'false' in fase di debug. Tali stringhe possono essere usate dai programmi solo se dichiarate come 'nomi definiti' del linguaggio.


Variabili di tipo analogico

Analogico significa continuo. Tali variabili sono di tipo intero con segno o reale (floating). I formati disponibili per una variabile di tipo analogico:

Intero	intero con segno a 32 bit da -2147483647 a +2147483647

Reale	valore IEEE standard  32 bit in virgola mobile (precisione singola)

1 bit di segno + 23 bit mantissa + 8 bit di esponente

Il valore dell'esponente reale analogico deve essere compreso tra -37 e +37. Le variabili di tipo analogico  possono avere uno dei seguenti attributi:

Interna:	variabile gestita dal programma

Costante:	variabile di sola lettura con un valore iniziale

Ingresso:	variabile riferita ad un dispositivo di ingresso (aggiornata dal sistema)

Uscita:	variabile riferita ad un dispositivo di uscita

Nota: Quando una variabile di tipo reale è connessa ad un dispositivo I/O, il driver I/O agisce sul relativo valore intero.

Avvertenza: Variabili analogiche di tipo intero o reale non possono coesistere nella stessa espressione analogica con espressioni costanti.


Variabili di tipo Timer

Timer equivale ad orologio o contatore. Tali variabili contengono valori temporali e vengono tipicamente usate in espressioni di tipo temporale. Un valore temporale non può eccedere 23h59m59s99 e non può essere negativo. Le variabili di tipo timer vengono memorizzate in words a 32 bit. La rappresentazione interna consiste in un numero positivo di millisecondi.

Avvertenza: Le variabili di tipo Timer non hanno gli attributi INPUT o OUTPUT

Le variabili di tipo Timer vengono aggiornate automaticamente dal sistema ISaGRAF. Quando un timer è attivo, il suo valore viene automaticamente incrementato seguendo l'orologio in tempo reale del sistema target. Per controllare un timer si usano le seguenti istruzioni ST:

TSTART	avvia l'aggiornamento automatico di un timer

TSTOP	ferma l'aggiornamento automatico di un timer


Variabili di tipo stringa messaggio

Le variabili di tipo messaggio o stringa contengono stringhe di caratteri. La lunghezza della stringa può cambiare in fase di esecuzione. La lunghezza di una variabile messaggio non può eccedere la capacità (la lunghezza massima) specificata al momento della dichiarazione della variabile. La capacità di un messaggio è limitata a 255 caratteri. Le variabili di tipo messaggio possono avere uno dei seguenti attributi:

Interna:	variabile gestita dal programma

Ingresso:	variabile riferita ad un dispositivo di ingresso (aggiornata dal sistema)

Uscita:	variabile riferita ad un dispositivo di uscita

Le variabili di tipo stringa possono contenere qualsiasi carattere della tabella standard ASCII. (codici ASCII compresi tra 0 e 255). Una stringa di caratteri può contenere Il carattere null. Alcune funzioni "C" della libreria standard ISaGRAF, tuttavia, non tratteranno correttamente i messaggi contenenti caratteri null (0).


Commenti

Nei linguaggi testuali come ST o IL si possono liberamente inserire dei commenti. Un commento deve iniziare con i caratteri speciali "(*" e terminare con i caratteri "*)". I commenti possono essere inseriti dovunque in un programma ST, e possono essere scritti su più di una riga.

Alcuni esempi di commenti:

counter := ivalue;   (* assegna il contatore principale *)

(* questo commento occupa

due righe *)

c := counter (* i commenti possono essere inseriti ovunque *) + base_value + 1;

Non sono possibili commenti annidati. In pratica i caratteri "(*" non possono comparire all'interno di un commento.

Avvertenza: Il linguaggio IL accetta commenti solamente se inseriti al termine di una riga di istruzione.


Nomi definiti

Il sistema ISaGRAF permette di ridefinire espressioni costanti, espressioni booleane true e false, parole chiave o espressioni ST articolate. Per far questo, si deve assegnare il nome di un identificatore all'espressione. Ad esempio:

YES	equivale a	TRUE

PI	equivale a	3.14159

OK	equivale a	(auto_mode AND NOT (alarm))

Una volta definita questa equivalenza, il relativo identificatore può essere usato in qualsiasi punto del programma ST per sostituire l'espressione abbinata. Segue un esempio di programmazione in linguaggio ST con l'uso delle definizioni:

If OK Then

   angolo := PI / 2.0;

   fatto := YES;

End_if;

I nomi definiti possono essere LOCALI ad un  programma, GLOBALI o COMUNI. I nomi definiti Locali possono essere usati da un solo programma. I nomi definiti Globali possono essere usate da qualsiasi programma di un progetto. I nomi definiti Comuni possono essere usati da qualsiasi programma di qualsiasi progetto.

Da notare che le definizioni COMUNI possono essere archiviate separatamente usando la gestione di archivio (comando "Strumenti / Archivio / Dati comuni" dalla finestra Gestione progetti)..

Avvertenza: Se lo stesso identificatore viene definito due volte con differenti equivalenze ST, viene usata l'ultima espressione definita. Ad esempio:

Definendo:	OPEN	equivalente a	FALSE

OPEN	equivalente a	TRUE

si avrà:	OPEN	equivalente a	TRUE

L'assegnamento del nome ai nomi definiti deve rispettare le seguenti direttive:

il nome non può eccedere i 16 caratteri

il primo carattere deve essere una lettera

i successivi caratteri possono essere lettere, cifre o il carattere underscore ('_')

Avvertenza: Un Nome definito non può far uso a sua volta di un altro Nome definito, ad esempio, non è possibile:

PI	equivale a	3.14159

PI2 	equivale a	PI*2

bisogna scrivere l'equivalenza completa usando costanti, variabili ed operatori:

PI2 	equivale a	6.28318


Linguaggio IL

Instruction List, o ILè un linguaggio di basso livello, molto efficace per piccole applicazioni o per ottimizzare parti di un'applicazione. Le istruzioni sono sempre relative al risultato corrente (o registro IL). L'operatore indica l'operazione che deve essere svolta tra il valore corrente e l'operando. Il risultato dell'operazione viene, nuovamente, memorizzato nel risultato corrente.

Sintassi IL

Operatori IL


Sintassi IL

Un programma IL consiste in un elenco di istruzioni. Ogni istruzione deve iniziare su una nuova riga e deve contenere un operatore completato, facoltativamente, da modificatori e, se necessario, per un'operazione specifica, da uno o più operandi separati da virgole (','). L'istruzione può essere preceduta da una etichetta seguita dal carattere "due punti" (':'). Un eventuale commento, abbinato all'istruzione, deve essere posto come ultima parte della riga. I commenti iniziano sempre con '(*' e terminano con '*)'. Possono esserci righe vuote tra un'istruzione e l'altra. I commenti possono essere messi anche su righe vuote.

Etichette

Modificatori di operatori

Operazioni rinviate

Di seguito viene riportato un esempio di righe di istruzione:

Etichetta	Operatore	Operando	Commenti

Start:	LD	IX1	(* pressione del pulsante *)

ANDN	MX5	(* il comando è permesso *)

ST	QX2	(* avvio motore *)


Etichette

Un etichetta seguita dai due punti (':') può precedere l'istruzione. Una etichetta può trovar posto anche su una riga vuota. Le etichette vengono usate come operandi per alcune operazioni come i salti. Il nome delle etichette deve rispettare le seguenti regole:

-	il nome non deve eccedere i 16 caratteri

-	il primo carattere deve essere una lettera

-	i successivi caratteri devono essere lettere, cifre o il carattere '_'

Lo stesso nome non può essere usato per più di una etichetta nello stesso programma IL. Una etichetta può avere lo stesso nome di una variabile.


Modificatori di operatori

Di seguito vengono riportati i modificatori di operatori disponibili. Il carattere modificatore deve completare il nome dell'operatore, senza che vi sia alcun carattere "vuoto" tra essi:

N	negazione booleana dell'operando

(	operazione rinviata

C	operazione condizionata

Il modificatore 'N' indica una negazione booleana dell'operando. Ad esempio, l'istruzione ORN IX12 viene interpretata come: result := result OR NOT (IX12).

Il modificatore parentesi '(' indica che la valutazione dell'istruzione deve essere rinviata fino a quando non venga incontrato il modificatore parentesi chiusa ')'.

Il modificatore 'C' indica che l'istruzione abbinata deve essere eseguita solamente se il risultato corrente ha valore booleano TRUE (diverso da 0 nel caso di operatori non booleani). Il modificatore 'C' può essere usato in combinazione con il modificatore 'N' per indicare che l'istruzione deve essere eseguita solamente nel caso il risultato corrente abbia valore booleano FALSE (o 0 per valori non booleani).


Operazioni rinviate

Poiché esiste un solo registro IL (il risultato corrente ), alcune operazioni devono essere rinviate , così da permettere di cambiare l'ordine di esecuzione delle istruzioni.

Le parentesi permettono di indicare le operazioni rinviate:

'('	è un modificatore	indica che l'operazione deve essere rinviata

')'	è un operatore	esegue l'operazione rinviata

Il modificatore parentesi aperta  '(' indica che la valutazione dell'istruzione deve essere rinviata fino a quando non venga incontrato l'operatore parentesi chiusa ')'. Ad esempio, la seguente sequenza:

AND(	IX12

OR	IX35

)

viene interpretata come:

result := result AND ( IX12 OR IX35 )


IL operators
Operatori IL

  La seguente tavola riassume gli operatori standard del linguaggio IL:

Operatore	Modificatori	Operandi	Descrizione

LD	N	Variabile, costante	Carica (load) operando

ST	N	Variabile	memorizza (store) il risultato corrente

S	variabile BOOLEANA	imposta a TRUE

R	variabile BOOLEANA	imposta a FALSE

CAL	C   N	Nome istanza di FB	Chiamata a blocco funzione

JMP	C   N	Etichetta	Salto a etichetta

RET	C   N	Ritorna da sottoprogramma

 ) 	Esegue operazioni "rinviate"

Funzione	Chiamata a blocco funzione o sottoprogramma

AND	N   (	BOO	AND booleano

&	N   (	BOO	AND booleano

OR	N   (	BOO	OR booleano

XOR	N   (	BOO	OR booleano

ADD	(	variabile, costante	Addizione

SUB	(	variabile, costante	Sottrazione

MUL	(	variabile, costante	Moltiplicazione

DIV	(	variabile, costante	Divisione

GT	(	variabile, costante	Controllo: >

GE	(	variabile, costante	Controllo: >=

EQ	(	variabile, costante	Controllo: =

LE	(	variabile, costante	Controllo: <=

LT	(	variabile, costante	Controllo: <

NE	(	variabile, costante	Controllo: <>

Nella seguente sezione, sono descritti solo gli operatori specifici del linguaggio. Per gli altri operatori standard, si rimanda alla sezione "Operatori, blocchi funzione e funzioni standard".


Operatore LD

Operazione	carica un valore nel risultato corrente

Modificatori permessi	N

Operando	espressione costante

variabile interna, di input o output

Esempio:

(* ESEMPI DI OPERAZIONI LD *)

LDex:	LD	false	(* risultato := costante booleana FALSE *)

LD	true	(* risultato := costante booleana TRUE *)

LD	123	(* risultato := costante intera *)

LD	123.1	(* risultato := costante reale *)

LD	t#3ms	(* risultato := costante temporale *)

LD	boo_var1	(* risultato := variabile booleana *)

LD	ana_var1	(* risultato := variabile analogica *)

LD	tmr_var1	(* risultato := variabile temporale *)

LDN	boo_var2	(* risultato := NOT ( variabile booleana ) *)


Operatore ST

Operazione	memorizza in una variabile il risultato corrente

questo operatore non modifica il risultato corrente

Modificatori permessi	N

Operando	una variabile interna o di output

Esempio:

(* ESEMPI DI OPERAZIONI 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 *)


Operatore S

Operazione:	assegna il valore booleano TRUE ad una variabile booleana se il risultato corrente ha valore booleano TRUE. Non viene eseguita alcuna operazione se il risultato corrente vale FALSE. Questa operazione non modifica il risultato corrente.

Modificatori permessi:	(nessuno)

Operando:	variabile booleana di output o interna

Esempio:

(* ESEMPI DI OPERAZIONI S *)

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

S	boo_var1	(* boo_var1 := TRUE *)

(* il risultato corrente non viene modificato *)

LD	false	(* risultato corrente:= FALSE *)

S	boo_var1	(* niente di fatto - boo_var1 invariata *)


Operatore R

Operazione	assegna il valore booleano FALSE ad una variabile booleana, se il risultato corrente ha il valore booleano TRUE. Non viene eseguita alcuna operazione se il risultato corrente vale FALSE. Questa operazione non modifica il risultato corrente.

Modificatori permessi	(nessuno)

Operando	variabile booleana di output o interna

Esempio:

(* ESEMPI DI OPERAZIONI R *)

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

R	boo_var1	(* boo_var1 := FALSE *)

(*il risultato corrente non viene modificato *)

ST	boo_var2	(* boo_var2 := TRUE *)

LD	false	(*risultato corrente := FALSE *)

R	boo_var1	(*niente di fatto - boo_var1 invariata *)


Operatore JMP

Operazione	salta all'etichetta specificata

Modificatori permessi	C   N

Operando	una etichetta definita nello stesso programma IL

Esempio:

(* il seguente esempio controlla il valore di un selettore analogico (0 o 1 o 2) *)

(* per impostare uno di tre output booleani. Il controllo "è uguale a 0" viene eseguito*)

(* tramite l'operatore JMPC	*)

JMPex:	LD	selector	(* selector vale 0 o 1 o 2 *)

BOO	(* conversione a booleano *)

JMPC	test1	(* se selector = 0 allora *)

LD	true

ST	bo0	(* bo0 := true *)

JMP	JMPend	(* fine del programma *)

test1:	LD 	selector

SUB	1	(* decrementa selector: adesso vale 0 o 1 *)

BOO	(*conversione a booleano *)

JMPC	test2	(* se selector = 0 allora *)

LD	true

ST	bo1	(* bo1 := true *)

JMP	JMPend	(* fine del programma *)

test2:	LD	true	(* ultimo caso *)

ST	bo2	(* bo2 := true *)

JMPend:	(* fine del programma IL *)


operatore RET

Operazione	termina 'esecuzione della lista corrente di istruzioni. Qualora la sequenza IL sia un sottoprogramma, il risultato corrente viene restituito al programma chiamante

Modificatori permessi	C   N

Operando	(nessuno)

Esempio:

(* il seguente esempio controlla il valore di un selettore analogico (0 o 1 o 2) *)

(* per impostare uno di tre output booleani. Il controllo "è uguale a 0" viene eseguito*)

(* tramite l'operatore JMPC	*)

JMPex:	LD	selector	(* selector vale 0 o 1 o 2 *)

BOO	(*conversione a booleano *)

JMPC	test1	(* if selector = 0 then *)

LD	true

ST	bo0	(* bo0 := true *)

RET	(* fine - ritorna 0 *)

(* decrementa selector *)

test1:	LD 	selector

SUB	1	(* selector vale ora 0 o 1 *)

BOO	(*conversione a booleano *)

JMPC	test2	(* se selector = 0 allora *)

LD	true

ST	bo1	(* bo1 := true *)

LD	1	(*carica il valore reale del selettore *)

RET	(* fine - ritorna 1 *)

(* utlimo caso *)

test2:	RETNC	(* ritorna se selector *)

(* ha valore non valido *)

LD	true

ST	bo2	(* bo2 := true *)

LD	2	(* carica il valore reale del selettore *)

(*fine- ritorna 2 *)


Operatore ")"

Operazione	esegue un'operazione rinviata. L'operazione rinviata è stata notificata da '('

Modificatori permessi	(nessuno)

Operando	(nessuno)

Esempio:

(* Il seguente programma alterna operazioni rinviate: *)

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

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

ADD(	a2	(* rinviata ADD - result := a2; *)

MUL(	a3	(*rinviata MUL - result := a3; *)

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

)	(* esegue MUL rinviata - risultato := a2 * (a3-a4); *)

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

)	(* esegue ADD rinviata*)

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

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

ST	res	(* assegna alla variabile res il risultato corrente *)


Chiamare sottoprogrammi o funzioni

Un sottoprogramma o una funzione (scritta in un qualunque linguaggio IL, ST, LD, FBD o "C") può essere richiamata dal linguaggio IL usando il nome come operatore.

Operazione	esegue un sottoprogramma o una funzione  il valore restituito dal sottoprogramma o funzione è assegnato al risultato corrente IL

Modificatori permessi	(nessuno)

Operando	Il primo parametro di chiamata deve essere assegnato al risultato corrente prima della chiamata. I seguenti vengono espressi nel campo dell'operando, separati da virgole.

Esempio:

(* Programma chiamante: converte un valore analogico in valore temporale *)

Main:	LD	bi0

SUBPRO	bi1,bi2	(* chiama sotto-prog. per avere valore analogico *)

ST	result	(* risultato := valore restituito dal sotto-prog. *)

GT	vmax	(* controllo overflow valore*)

RETC	(* ritorno se overflow *)

LD	result

MUL	1000	(* converte secondi in millisecondi *)

TMR	(* converte a timer *)

ST	tmval	(* assegna valore convertito ad un timer *)

(* 'SUBPRO': valuta il valore analogico *)

(* passato come valore binario su tre input booleani: in0, in1, in2 sono i tre parametri di input del sottoprogramma *)

LD	in2

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

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

ST	temporary	(* temporary := risultato *)

LD	in1

ANA

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

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

ST	temporary	(* temporary := risultato *)

LD	in0

ANA

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

ST	SUBPRO	(* ritorna al programma chiamante il risultato corrente *)


Chiamare blocchi funzione: operatore CAL

Operazione	chiama un blocco funzione

Modificatori permessi	C   N

Operando	Nome dell'istanza del blocco funzione.

i parametri di input dei blocchi devono essere assegnati prima della chiamata, usando una sequenza di operazioni LD/ST.

I parametri di output sono accessibili se usati.

Esempio1:

(* Chiamata al blocco funzione SR : SR1 è un'istanza di SR *)

LD	auto_mode

AND	start_cmd

ST	SR1.set1

LD	stop_cmd

ST	SR1.reset

CAL	SR1

LD	SR1.Q1

ST	command

(* equivalente FBD: *)

Esempio 2

(*Si suppone R_TRIG1 istanza del blocco R_TRIG e CTU1 istanza del blocco 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 FBD: *)


Linguaggio ST

ST (Structured Text) è un linguaggio strutturato di alto livello pensato per l'automazione di processi. Questo linguaggio viene principalmente usato per implementare procedure complesse che non possono essere facilmente espresse con i linguaggi di tipo grafico. ST è il linguaggio predefinito per le azioni all'interno di passi e condizioni abbinate alle transizioni del linguaggio SFC.

Sintassi ST

Espressioni e parentesi

Chiamate a funzioni o blocchi funzione

Operatori booleani ST specifici

Istruzioni base ST

Estensioni ST


Sintassi ST

Un programma ST consiste in un elenco di istruzioni ST. Ogni istruzione termina con il separatore "punto e virgola" (";"). I nomi usati nel codice sorgente (variabili, identificatori, costanti, parole chiave del linguaggio …) sono separati da separatori inattivi (carattere spazio, fine riga, tabulazione) o da separatori attivi, con significato ben definito (ad esempio il separatore ">" indica "più grande di". Nel testo possono essere liberamente inseriti commenti. Un commento inizia con "(*" e termina con "*)". Ogni istruzione termina con il separatore "punto e virgola" (";"). Vengono qui riportati i tipi base di istruzione ST:

-	istruzione di assegnamento (variabile := espressione;)

-	chiamata a sottoprogramma o funzione

-	chiamata a blocco funzione

-	istruzioni di selezione (IF, THEN, ELSE, CASE...)

-	istruzioni di iterazione (FOR, WHILE, REPEAT...)

-	istruzioni di controllo (RETURN, EXIT...)

-	istruzioni speciali per il collegamento con altri linguaggi, come ad esempio SFC

I separatori inattivi possono essere inseriti liberamente tra separatori attivi, espressioni costanti ed identificatori. I separatori inattivi ST sono: il carattere Spazio (blank), Tabulazione ed il carattere Fine riga (End of line). Diversamente dai linguaggi con formattazione a riga, come ad esempio IL, la fine riga può essere inserita in qualunque punto del programma. È bene, tuttavia, rispettare alcune regole per migliorare la leggibilità di un programma ST:

-	Non scrivere più di una istruzione per riga

-	Inserire dei rientri (indentazione) con le tabulazioni nel caso di sequenze di istruzioni complesse

-	Inserire commenti per migliorare la leggibilità di righe e paragrafi

Leggibilità dei sorgenti - esempi:

Scarsa leggibilità	Ottima leggibilità
imax := max_ite; cond := X12; if not(cond (* allarme *) then return; end_if; for i (* indice *) := 1 to max_ite do if i <> 2 then Spcall(); end_if; end_for; (* nessun effetto se allarme *)	(* imax : numero di iterazioni *) (* i: indice ciclo FOR *) (* cond: validità del processo *) imax := max_ite; cond := X12; if not (cond) then     return; end_if; (* ciclo del processo *) for i := 1 to max_ite do     if i <> 2 then         Spcall ();     end_if; end_for;


Espressioni e parentesi

Le espressioni ST combinano assieme operatori ST ed operandi variabili o costanti. Nel caso di espressione singola (un operatore ST assieme ad operandi), gli operandi devono essere dello stesso tipo. L'espressione singola risulta essere dello stesso tipo dei suoi operandi e può, a sua volta, essere usata in espressioni più complesse. Ad esempio:

(boo_var1 AND boo_var2)	è di tipo BOOLEANO

not (boo_var1)	è di tipo BOOLEANO

(sin (3.14) + 0.72)	è DI TIPO REALE ANALOG

(t#1s23 + 1.78)	non è un'espressione valida

Le parentesi servono ad isolare parti di un'espressione e a definire esplicitamente la priorità delle operazioni. In un'espressione complessa priva di parentesi, la sequenza delle operazioni è implicitamente data dalla priorità predefinita tra operatori ST. Ad esempio:

2 + 3 * 6 	equivale a 2+18=20	poiché l'operatore moltiplicazione ha priorità più alta

(2+3) * 6	equivale a 5*6=30   	la priorità è data dalle parentesi

Avvertenza: In un'espressione si possono annidare fino ad un massimo di 8 livelli di parentesi.


Chiamate a funzioni o blocchi funzione

Funzioni ST standard possono essere usate negli oggetti seguenti:

-	Sottoprogrammi

-	Funzioni e blocchi funzione di libreria scritte con linguaggi IEC

-	Funzioni e blocchi funzione "C"

-	Funzioni di conversione di tipo

Chiamate a sottoprogrammi o funzioni

Chiamate a blocchi funzione


Chiamate a sottoprogrammi o funzioni

Nome:	nome del sottoprogramma chiamato

o della funzione di libreria  scritta in linguaggio IEC o "C"

Descrizione:	chiama un sottoprogramma o una funzione ST, IL, LD o FBD o una funzione "C"

ed ottiene il valore di ritorno

Sintassi:	<variabile> := <sottoprog> (<par1>, ... <parN> );

Operandi:	Il tipo del valore di ritorno e dei parametri di chiamata deve essere lo stesso di quello

definito per il sottoprogramma.

Valore di ritorno:	valore restituito dal sottoprogramma.

Qualsiasi espressione può contenere chiamate a sottoprogrammi, anche transizioni SFC.

Esempio1: Chiamata a sottoprogramma

(* Programma principale ST *)

(* ottiene un valore analog e lo converte in valore temporale *)

ana_timeprog := SPlimit ( tprog_cmd );

appl_timer := tmr (ana_timeprog * 100);

(* Il programma FBD chiamato è 'SPlimit' *)

Esempio2: Chiamata a funzione

(* le funzioni usate in espressioni complesse: min, max, right, mlen e left sono funzioni standard "C" *)

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

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


Chiamate a blocchi funzione

Nome:	nome dell'istanza di blocco funzione

Descrizione:	chiama un blocco funzione dalla libreria ISaGRAF o dalla libreria utente ed accede ai parametri di ritorno

Sintassi:	(* chiamata a blocco funzione *)

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

(ottiene i parametri di ritorno *)

<result> := <blockname>. <ret_param1>;

...

<result> := <blockname>. <ret_paramN>;

Operandi:	i parametri sono costituiti da espressioni il cui tipo coincide con quello dei parametri dello specifico blocco funzione

Valore di ritorno:	i parametri di ritorno si leggono come specificato nella Sintassi.

Consultare la libreria ISaGRAF per la descrizione ed il tipo di ciascun parametro di blocco funzione. L'istanza (il nome della copia) di blocco funzione deve essere dichiarata nel dizionario

Esempio :

(* Programma ST che chiama un blocco funzione *)

(* dichiarazione dell'istanza del blocco nel dizionario: *)

(* trigb1 : blocco R_TRIG  riconoscimento di fronte di salita *)

(* attivazione del blocco funzione da linguaggio ST *)

trigb1 (b1);

(* accesso ai parametri di ritorno *)

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


Operatori booleani ST specifici

I seguenti operatori booleani sono specifici del linguaggio ST::

REDGE	riconoscimento di fronte di salita

FEDGE	riconoscimento di fronte di discesa

Altri operatori booleani standard:

NOT	negazione booleana

AND (&)	AND logico

OR	OR logico

XOR	OR logico esclusivo

possono essere usati. Per la descrizione, si veda la sezione "Operatori, blocchi funzione e funzioni standard".


L'operatore "REDGE"

Nome:	REDGE

Descrizione:	valuta il fronte di salita di un'espressione booleana completa

Sintassi:	<edge> := REDGE ( <espressione_booleana>,<variabile_memo> );

Operandi:	il primo operando è costituito da una qualsiasi variabile booleana o espressione complessa

il secondo operando è una variabile booleana interna usata per mantenere il precedente stato dell'espressione

Valore di ritorno:	TRUE quando l'espressione passa da FALSE a TRUE

FALSE negli altri casi

Non è possibile, con l'operatore REDGE, interrogare il fronte di salita di un'espressione più di una volta nello stesso ciclo di esecuzione. Questo operatore può essere usato per descrivere la condizione associata ad una transizione SFC.

Avvertenza: La variabile booleana "variabile_memo", usata per mantenere il precedente stato dell'espressione, non può essere usata per fronti di espressioni differenti.

Nel caso l'espressione sia una variabile booleana chiamata "xxx", è consigliabile dichiarare una variabile interna unica chiamata "EDGE_xxx" da usarsi nelle espressioni REDGE per la variabile "xxx". In questo modo si evita che la variabile memo venga sovrascritta da altre valutazioni REDGE.

Esempio:

(* Programma ST che fa uso dell'operatore REDGE *)

(* questo programma conta i fronti di salita di un input booleano *)

(* Bi120 è una variabile booleana di input *)

(* Edge_Bi120 è la memoria dello stato della variabile Bi120 *)

If REDGE (Bi120, Edge_Bi120) Then

Counter := Counter + 1;

End_if;

Nota: questo operatore non è conforme alle norme IEC1131-3. È possibile usare il blocco standard R_TRIG. Viene mantenuto per ragioni di compatibilità.


L'operatore "FEDGE"

Nome:	FEDGE

Descrizione:	valuta il fronte di discesa di un'espressione booleana

Sintassi:	<edge> := FEDGE ( <espressione_booleana>, <variabile_memo> );

Operandi:	il primo operando è costituito da una qualsiasi variabile booleana o espressione complessa

il secondo operando è una variabile booleana interna usata per mantenere il precedente stato dell'espressione

Valore di ritorno:	TRUE quando l'espressione passa da TRUE a FALSE

FALSE negli altri casi.

Non è possibile, con l'operatore FEDGE, interrogare il fronte di salita di un'espressione più di una volta nello stesso ciclo di esecuzione. Questo operatore può essere usato per descrivere la condizione abbinata ad una transizione SFC.

Avvertenza: La variabile booleana "variabile_memo", usata per mantenere il precedente stato dell'espressione, non può essere usata per fronti di espressioni differenti.

Nel caso l'espressione sia una variabile booleana chiamata "xxx", è consigliabile dichiarare una variabile interna unica chiamata "EDGE_xxx" da usarsi nelle espressioni FEDGE per la variabile "xxx". In questo modo si evita che la variabile memo venga sovrascritta da altre valutazioni FEDGE.

Esempio:

(*Programma ST che fa uso dell'operatore FEDGE*)

(*questo programma conta i fronti di caduta di un input booleano *)

(* Bi120 è una variabile booleana di input *)

(* Edge_Bi120 è la memoria dello stato della variabile Bi120*)

If FEDGE (Bi120, Edge_Bi120) Then

Counter := Counter + 1;

End_if;

Nota: questo operatore non è conforme alle norme IEC1131-3. È possibile usare il blocco standard F_TRIG. Viene mantenuto per ragioni di compatibilità.


Istruzioni base ST

Le istruzioni base del linguaggio ST sono:

Assegnazione

Istruzione RETURN

Istruzione IF-THEN-ELSIF-ELSE

Istruzione CASE

Istruzione WHILE

Istruzione REPEAT

Istruzione FOR

Istruzione EXIT


Assegnazione

Nome:	:=

Descrizione:	assegna un'espressione ad una variabile

Sintassi:	<variable> := <any_expression> ;

Operandi:	la variabile deve avere attributo di variabile di USCITA o INTERNA

variabile ed espressione devono essere dello stesso tipo

L'espressione può essere una chiamata a sottoprogramma o una funzione della libreria ISaGRAF

Esempio:

(* Programma ST con assegnazioni *)

(* variabile <<= variabile *)

bo23 := bo10;

(* variabile <<= espressione *)

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

result := (100 * input_value) / scale;

(* assegnazione con valore di ritorno da sottoprogramma *)

rc := PSelect ( );

(* asseganzione con chiamata a funzione *)

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


Istruzione RETURN

Nome:	RETURN

Descrizione:	termina l'esecuzione del programma corrente

Sintassi:	RETURN ;

Operandi:	(nessuno)

In un Blocco Azione SFC, l'istruzione RETURN indica la fine dell'esecuzione solamente del tal blocco.

Esempio:

(* Specifica FBD del programma: contatore programmabile *)

(* Implementazione ST del programma, con l'uso dell'istruzione RETURN *)

If not (CU) then

Q := false;

CV := 0;

RETURN;   (* termina il programma *)

end_if;

if R then

CV := 0;

else

if (CV < PV) then

CV := CV + 1;

end_if;

end_if;

Q := (CV >= PV);


Istruzione IF-THEN-ELSIF-ELSE

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

Descrizione:	esegue uno di due elenchi di istruzioni ST

la scelta avviene in base al valore di

un'espressione booleana

Sintassi:	IF <espressione_booleana> THEN

   <istruzione> ;

   <istruzione> ;

   ...

ELSIF <espressione_booleana> THEN

   <istruzione> ;

   <istruzione> ;

   ...

ELSE

   <istruzione> ;

   <istruzione> ;

   ...

END_IF;

Le istruzioni ELSE ed ELSIF sono facoltative. Se non viene specificata l'istruzione ELSE, non viene eseguita alcuna istruzione quando la condizione vale FALSE.

Esempio:

(* Programma ST che fa uso dell'istruzione 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;

(* La struttura IF usata senza ELSE *)

If overflow THEN

alarm_level := true;

END_IF;


Istruzione CASE

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

Descrizione:	esegue uno di più elenchi di istruzioni ST

la scelta avviene in base ad un'espressione intera

Sintassi:	CASE <espressione_intera> OF

   <valore> : <istruzioni> ;

   <valore> , <valore> : <istruzioni> ;

   ...

ELSE

   <istruzioni> ;

END_CASE;

I valori valutati dall'istruzione CASE, devono essere espressioni costanti intere. Valori diversi, separati da virgole, portano allo stesso elenco di istruzioni. L'istruzione ELSE è facoltativa.

Esempio:

(* Programma ST che fa uso dell'istruzione CASE*)

CASE codice_errore OF

255:	err_msg := 'Divisione per zero;

fatal_error := TRUE;

1:	err_msg := 'Overflow';

2, 3:	err_msg := 'Segno errato;

ELSE

err_msg := 'Errore sconosciuto;

END_CASE;


Istruzione WHILE

Nome:	WHILE ... DO ... END_WHILE

Descrizione:	struttura iterativa per un gruppo di istruzioni ST

la condizione che permette di continuare, viene valutata PRIMA di ogni iterazione

Sintassi:	WHILE <espressione_booleana> DO

   <istruzione> ;

   <istruzione> ;

   ...

END_WHILE ;

Avvertenza: Poiché il sistema ISaGRAF è sincrono, le variabili di input, non vengono aggiornate durante le iterazioni WHILE. Il cambiamento di stato di una variabile di input non può essere usato come condizione per un'istruzione WHILE.

Esempio:

(* Programma ST che fa uso dell'istruzione WHILE *)

(* questo programma utilizza funzioni specifiche "C" per leggere caratteri *)

(* da una porta seriale *)

string := ''; (*stringa vuota *)

nbchar := 0;

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

string := string + ComGetChar ( );

nbchar := nbchar + 1;

END_WHILE;


istruzione REPEAT

Nome:	REPEAT ... UNTIL ... END_REPEAT

Descrizione:	struttura iterativa per un gruppo di istruzioni ST

la condizione che permette di continuare, viene valutata DOPO ogni iterazione

Sintassi:	REPEAT

   <istruzione> ;

   <istruzione> ;

  ...

UNTIL <espressione_booleana>

END_REPEAT ;

Avvertenza: Poiché il sistema ISaGRAF è sincrono, le variabili di input, non vengono aggiornate durante le iterazioni REPEAT. Il cambiamento di stato di una variabile di input non può essere usato come condizione per un'istruzione REPEAT.

Esempio:

(* Programma ST che fa uso dell'istruzione REPEAT *)

(* questo programma utilizza funzioni specifiche "C" per leggere caratteri *)

(* da una porta seriale *)

string := ''; (*stringa vuota *)

nbchar := 0;

IF ComIsReady ( ) THEN

REPEAT

string := string + ComGetChar ( );

nbchar := nbchar + 1;

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

END_REPEAT;

END_IF;


Istruzione FOR

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

Descrizione:	esegue un numero limitato di iterazioni,

usando come indice una variabile intera di tipo analogico

Sintassi:	FOR <indice> := <mini> TO <maxi> BY <passo> DO

   <istruzione> ;

   <istruzione> ;

END_FOR;

Operandi:	index:	variabile analogica interna incrementata ad ogni ciclo

mini:	valore iniziale (prima del primo ciclo) dell'indice

maxi:	valore massimo che può assumere l'indice

step:	incremento dell'indice ad ogni ciclo

La direttiva [ BY passo ] è facoltativa. Se non diversamente specificato, l'incremento è di passo 1.

Avvertenza: Poiché il sistema ISaGRAF è sincrono, le variabili di input, non vengono aggiornate durante le iterazioni FOR.

Questo è l'equivalente ciclo "while" per l'istruzione FOR:

index := mini;

while (index <= maxi) do

   <istruzione> ;

   <istruzione> ;

   index := index + step;

end_while;

Esempio:

(* Programma ST che fa uso dell'istruzione FOR *)

(* questo programma estrae i caratteri corrispondenti a cifre da una stringa *)

length := mlen (message);

target := ''; (*stringa vuota *)

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;


Istruzione EXIT

Nome:	EXIT

Descrizione:	uscita da un'istruzione iterativa FOR, WHILE o REPEAT

Sintassi:	EXIT;

Operandi:	(nessuno)

EXIT viene comunemente usata in un'istruzione IF all'interno di un blocco FOR, WHILE o REPEAT.

Esempio:

(* Programma ST che fa uso dell'istruzione EXIT *)

(* questo programma esegue la ricerca di un carattere in una stringa *)

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;


Estensioni ST

Le seguenti funzioni estendono il linguaggio ST:

TSTART - TSTOP: controllo timer

Le seguenti istruzioni sono disponibili per controllare l'esecuzione di programmi figli SFC. Possono essere usate nei passi SFC, all'interno di blocchi ACTION(): ... END_ACTION;.

GSTART	avvia un programma SFC

GKILL	termina un programma SFC

GFREEZE	sospende un programma SFC

GRST	riavvia un programma SFC sospeso

GSTATUS	ottiene lo stato corrente di un programma SFC

Avvertenza: Queste funzioni non fanno parte della normativa IEC 1131-3.

Equivalgono, in un passo SFC, a GSTART e GKILL:

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

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

I seguenti campi permettono di conoscere lo stato di un passo SFC:

GSnnn.x	valore booleano che rappresenta lo stato di l'attività del passo

GSnnn.t	tempo trascorso dall'ultima attivazione del passo

("nnn" rappresenta il numero di riferimento del passo SFC)

È possibile, anche, controllare lo stato di l'attività di un passo dichiarato in un diverso programma SFC, usando la sintassi riportata di seguito:

GSnnn(progname).x

Avvertenza: il riferimento ad un passo di un diverso programma, con questa sintassi, non fa parte delle norme IEC 1131-3. Un modo semplice per ottenere lo stesso risultato, ottemperando alle regole IEC, consiste nel dichiarare nel dizionario una variabile booleana globale che rappresenta l'attività del passo da controllare (ad esempio ref_step_X). Inserire, poi, nel passo, la variabile qualificata da N (ref_step_X(N)). Usare poi la variabile, nel programma da cui si vuole controllare l'attività del passo.

Programma Prog	l'altro programma che necessita dello stato di attività

del programma Prog


Istruzione TSTART

Nome:	TSTART

Descrizione:	avvia il conteggio di una variabile di tipo timer

il valore del timer non viene modificato dal comando TSTART, ovvero, il conteggio viene avviato a partire dall'attuale valore del timer.

Sintassi:	TSTART ( <variabile_timer> );

Operandi:	qualsiasi timer non attivo

Valore di ritorno:	(nessuno)

Esempio:

(* Programma SFC che fa uso delle istruzioni TSTART e TSTOP *)

Il diagramma Tempo se bi100 vale sempre FALSE:

Il timer mantiene lo stesso valore per la durata di un ciclo.


Istruzione TSTOP

Nome:	TSTOP

Descrizione:	ferma l'aggiornamento di una variabile di tipo timer

Il valore del timer non viene modificato dal comando TSTOP

Sintassi:	TSTOP ( <variabile_timer> );

Operandi:	qualsiasi variabile timer attiva

Valore di ritorno:	(nessuno)

Esempio: Si veda TSTART (la funzione descritta precedentemente)


Istruzione GSTART

Nome:	GSTART

Descrizione:	Avvia un programma figlio SFC inserendovi un token in

ciascuno dei passi iniziali

Sintassi:	GSTART ( <child_program> );

Operandi:	il programma SFC specificato deve essere figlio di quello

in cui è scritta l'istruzione

Valore di ritorno:	(nessuno)

I figli del programma figlio, non vengono avviati automaticamente dall'istruzione GSTART.

Nota: Poiché GSTART non fa parte delle norme IEC 1131-3, è preferibile avviare un programma figlio SFC, usando il qualificatore S, con la seguente sintassi:

Child_name(S);

Esempio: Uso di GSTART e GKILL

(* Sequenza 'Spadre' *)	(* Sequenza 'Sfiglio' *)


Istruzione GKILL

Nome:	GKILL

Descrizione:	termina un programma figlio SFC eliminandovi i token

presenti nei passi

Sintassi:	GKILL ( <programma_figlio> );

Operandi:	il programma SFC specificato deve essere figlio di quello

in cui è scritta l'istruzione

Valore di ritorno:	(nessuno)

I figli del programma figlio vengono, assieme ad esso, automaticamente terminati.

Nota: Poichè GKILL non fa parte delle norme IEC 1131-3, è preferibile terminare un programma figlio SFC, usando il qualificatore R, con la seguente sintassi:

Child_name(R);

Esempio: Si veda GSTART (la funzione descritta precedentemente)


Istruzione GFREEZE

Nome:	GFREEZE

Descrizione:	Sospende l'esecuzione di un programma figlio SFC.

Il programma sospeso può essere riavviato con l'istruzione GRST.

Sintassi:	GFREEZE ( <programma_figlio> );

Operandi:	il programma SFC specificato deve essere figlio di quello

in cui è scritta l'istruzione

Valore di ritorno:	(nessuno)

I figli del programma figlio vengono automaticamente sospesi assieme al programma specificato.

Nota: GFREEZE non è compreso nelle norme IEC 1131-3.

Esempio:


Istruzione GRST

Nome:	GRST

Descrizione:	riavvia un programma figlio SFC, precedentemente sospeso dall'istruzione GFREEZE.

Sintassi:	GRST ( <programma_figlio> );

Operandi:	il programma SFC specificato deve essere figlio di quello

in cui è scritta l'istruzione

Valore di ritorno:	(nessuno)

L'istruzione GRST provvede automaticamente, a riavviare i figli del programma figlio.

Nota: GRST non è compreso nelle norme IEC 1131-3.

Esempio: Si veda GFREEZE (la funzione descritta precedentemente)


Istruzione GSTATUS

Nome:	GSTATUS

Descrizione:	restituisce l'attuale stato di un programma SFC

Sintassi:	<ana_var> := GSTATUS ( <programma_figlio> );

Operandi:	il programma SFC specificato deve essere figlio di quello

in cui è scritta l'istruzione

Valore di ritorno:	0 = programma non attivo (terminato)

1 = programma attivo (avviato)

2 = programma sospeso

Nota: GSTATUS non è compreso nelle norme IEC 1131-3.

Esempio:


 Linguaggio FBD

Il linguaggio Functional Block Diagram (FBD) è di tipo grafico. Consente al programmatore la generazione di procedure complesse attingendo alle funzioni della libreria ISaGRAF ed assemblandole assieme nell'area del diagramma grafico.

Formato del diagramma FBD

Istruzione RETURN

Salti e etichette

Negazione (inversione) booleana

Chiamate a funzioni o blocchi funzione dal diagramma FBD


Formato del diagramma FBD

Un diagramma FBD descrive una funzione tra variabili di input e variabili di output. Una funzione viene descritta come insieme di blocchi funzione elementari. Le variabili di input ed output sono collegate ai blocchi tramite linee di connessione. L'output di un blocco funzione può essere connesso all'input di un altro blocco.

Un'intera funzione gestita con un programma FBD è costituita da blocchi funzione standard elementari presi dalla libreria ISaGRAF. Ogni blocco funzione possiede un numero fisso di punti di connessione di input ed un numero fisso di punti di connessione di output. Un blocco funzione è rappresentato da un singolo rettangolo. Gli input collegati sul lato sinistro. Gli output collegati sul lato destro. Un blocco funzione elementare esegue una singola funzione tra i suoi input ed output. Il nome della funzione che deve essere eseguita dal blocco è scritto all'interno del simbolo rettangolare. Ciascun input o output di un blocco ha un ben definito tipo.

Le variabili di input di un programma FBD devono essere connesse ai punti di connessione di input di un blocco funzione. Il tipo di ciascuna variabile deve essere lo stesso dell'input associato. Un input di un diagramma FBD può essere costituito da un'espressione costante, una qualsiasi variabile interna o di input, o una variabile di output.

Le variabili di output di un programma FBD devono essere connesse ai punti di connessione di output dei blocchi funzione. Il tipo di ciascuna variabile deve essere lo stesso dell'output associato. L'output di un programma FBD può essere costituito da una qualunque variabile interna, di output, o dal nome del programma (solo per i sottoprogrammi). Quando l'output è costituito dal nome del sottoprogramma corrente, rappresenta il valore di ritorno del sottoprogramma (restituito al programma chiamante).

Le variabili di input ed output, gli input e gli output dei blocchi funzione, sono connessi tra loro mediante linee di connessione. Si possono usare delle linee singole per collegare due punti logici del diagramma:

-	Una variabile di ingresso con l'input di un blocco funzione

-	L'output di un blocco funzione e l'input di un altro blocco

-	L'output di un blocco funzione ed una variabile di uscita

La connessione è orientata, ovvero, la linea trasporta i dati dall'estremità sinistra verso l'estremità destra. Le estremità sinistra e destra della connessione devono essere dello stesso tipo.

Connessioni multiple a destra permettono di trasmettere un'informazione dall'estremità sinistra a ciascuna delle estremità a destra. Tutte le estremità della connessione devono essere dello stesso tipo.


Istruzione RETURN

L'output di un diagramma può essere costituito dalla parola chiave "<RETURN>". Tale parola chiave deve essere connessa ad un punto di connessione di output, di tipo booleano, di un blocco funzione. L'istruzione RETURN rappresenta la fine condizionata del programma: se l'output della casella collegata all'istruzione ha il valore booleano TRUE, la fine (la parte restante) del diagramma non viene eseguita.

(* Esempio di un programma FBD che fa uso dell'istruzione RETURN *)

(* Equivalente ST: *)

If auto_mode OR alarm Then

Return;

End_if;

bo67 := (bi10 AND bi23) OR x_cmd;


Salti ed etichette

Etichette e salti permettono di controllare l'esecuzione del diagramma. Non si possono collegare oggetti alla destra di un salto o di una etichetta. Si usa la seguente notazione:

>>LAB	salto ad una etichetta (il nome dell'etichetta è "LAB")

LAB:	definizione di una etichetta (il nome dell'etichetta è "LAB")

Quando la linea di connessione alla sinistra del salto ha stato booleano TRUE, l'esecuzione del programma salta direttamente al simbolo successivo l'etichetta corrispondente.

(* Esempio di un programma FBD che fa uso di etichette e salti *)

(* Equivalente IL: *)

ld	manual

and	b1

jmpc	NOMODIF

ld	input1

or	input2

st	result

NOMODIF:	ld	result

or	valid

st	cmd10


Negazione (Inversione) booleana

Una singola linea di connessione con l'estremità destra connessa all'input di un blocco funzione, può terminare con una negazione booleana . La negazione viene rappresentata da un piccolo cerchietto. Per usare una negazione booleana, le estremità sinistra e destra della connessione devono essere di tipo BOOLEANO.

(*Esempio di un programma FBD che fa uso di una negazione booleana *)

(* Equivalente ST: *)

output1 := input1 AND NOT (input2);


Chiamate a funzioni o blocchi funzione dal diagramma FBD

Il linguaggio FBD permette di richiamare sottoprogrammi, funzioni o blocchi funzione. Un sottoprogramma, una funzione o un blocco funzione, vengono rappresentati da caselle funzione. Il nome scritto nella casella è il nome del sottoprogramma, della funzione o del blocco funzione.

Nel caso di un sottoprogramma o di una funzione, il valore di ritorno è il solo output della casella funzione. Un blocco funzione può avere più output.

(* Esempio di un programma FBD che fa uso di un sottoprogramma *)

(* Equivalente ST *)

net_weight := Weighing (mode, delta); (* chiamata a sottoprogramma *)

If (net_weight = 0) Then Return; End_if;

weight := net_weight + tare_weight;


Linguaggio SFC

Il linguaggio grafico Sequential Function Chart (SFC) permette di rappresentare operazioni sequenziali. Il processo viene rappresentato come insieme di ben definiti passi, collegati tra loro da transizioni. Ad ogni transizione è abbinata una condizione booleana. Le azioni che costituiscono i passi vengono inserite con altri linguaggi. (ST, IL, LD e FDB).

Formato di un diagramma SFC

Componenti di base SFC

Divergenze e convergenze

Macro passi

Azioni all'interno di un passo

Condizioni abbinate alle transizioni

Regole dinamiche SFC

Gerarchia dei programmi SFC


Formato di un diagramma SFC

Un programma SFC è un insieme grafico di passi e transizioni, connesse tra loro da collegamenti orientati. Divergenze e convergenze vengono rappresentate da collegamenti multipli. Alcune porzioni del programma completo possono essere separate e rappresentate sul diagramma principale da singoli simboli, chiamati macro passi. Le direttive base SFC sono:

-	Un passo non può essere seguito da un altro passo

-	Una transizione non può essere seguita da un'altra transizione


Componenti di base SFC

I componenti di base (simboli grafici) del linguaggio SFC sono passi, passi iniziali, transizioni, collegamenti orientati e salti ad un passo.

Passi e passi iniziali

Transizioni

Collegamenti orientati

Salto ad un passo


Passi e passi iniziali

Un passo  è rappresentato da un singolo riquadro. Per ogni passo esiste un numero di riferimento  rappresentato all'interno di un simbolo quadrato. La descrizione del passo appare invece in una casella collegata al simbolo di passo. Questa descrizione consiste in un commento libero (che non fa parte del linguaggio di programmazione). L'informazione di cui sopra, viene chiamata Livello 1 del passo:

In fase di esecuzione, un token (segnale) indica che il passo è attivo :

Passo attivo:	Passo non attivo:

La situazione iniziale  di un programma SFC viene introdotta con un passo iniziale. Un passo iniziale è rappresentato da un simbolo grafico dotato di doppio bordo. All'avvio del programma, in ciascun passo iniziale, viene automaticamente visualizzato un token.

Passo iniziale:

Un programma SFC deve contenere almeno un passo iniziale.

GSnnn.x	stato di attività del passo (valore booleano)

GSnnn.t	durata dell'attività del passo (valore temporale)

(con nnn che rappresenta il numero di riferimento  del passo)


Transizioni

Le transizioni sono rappresentate da piccole barre orizzontali che attraversano i collegamenti. Ad ogni transizione è associato un numero di riferimento , visibile in prossimità del simbolo di transizione. La descrizione della transizione è posta alla destra del simbolo di transizione. Questa descrizione consiste in un commento libero (che non fa parte del linguaggio di programmazione). L'informazione di cui sopra viene chiamata Livello 1 della transizione:


Collegamenti orientati

Passi e transizioni sono collegati da singole linee . Si tratta di collegamenti orientati. Se l'orientamento non viene esplicitamente specificato, il collegamento viene orientato dall'alto verso il basso.


Salto ad un passo

I simboli di salto possono essere usati per indicare un collegamento da una transizione ad un passo, senza dover tracciare la linea di connessione. Al simbolo di salto deve far riferimento  il numero del passo destinazione.

Un simbolo di salto non può essere usato per rappresentare il collegamento da un passo ad una transizione. Esempio di salti  i seguenti diagrammi sono equivalenti:


Divergenze e convergenze

Le divergenze  vengono rappresentate con collegamenti multipli da un simbolo SFC (passo o transizione) verso molti altri simboli SFC. Le convergenze  vengono rappresentate con collegamenti multipli da più simboli SFC verso un altro singolo simbolo. Divergenze e convergenze possono essere sia singole che doppie.

Divergenze singole

Divergenze doppie


Divergenze singole

Una singola divergenza è un collegamento multiplo tra un solo passo e molte transizioni. Permette al segnale attivo di passare in una di un certo numero di diramazioni. Una convergenza singola è un collegamento multiplo da molte transizioni ad uno stesso passo. Una convergenza singola viene generalmente usata per raggruppare le diramazioni SFC che si dipartono da una divergenza singola. Divergenze e convergenze singole vengono rappresentate da linee orizzontali semplici.

Avvertenza: le condizioni abbinate a differenti transizioni all'inizio di una divergenza singola non sono implicitamente esclusive. La condizione di esclusività deve essere esplicitamente indicata nelle condizioni delle transizioni per assicurare che, in fase di esecuzione, un solo segnale avanzi in una diramazione della divergenza. Sotto viene riportato un esempio di una divergenza e convergenza singola:

(* programma SFC con divergenza e convergenza singola *)


Divergenze doppie

Una divergenza doppia è costituita da un collegamento multiplo da una transizione a molti passi. Rappresenta le operazioni in parallelo del processo. Una convergenza doppia è costituita da un collegamento multiplo da molteplici passi ad una stessa transizione. La convergenza doppia si usa, normalmente, per raggruppare le diramazioni SFC che si dipartono da una divergenza doppia. Divergenze e convergenze doppie vengono rappresentate da linee orizzontali doppie.

Esempio di una divergenza e convergenza doppie:

(* programma SFC con divergenza e convergenza doppie *)


Macro passi

Un macro passo  è la rappresentazione unica di un gruppo unico di passi e transizioni. Il corpo di un macro passo viene descritto in un punto diverso dello stesso programma SFC. Nel diagramma SFC principale appare come un singolo simbolo. Questo è la rappresentazione di un macro passo:

Il numero di riferimento visibile nel simbolo del macro passo è il numero di riferimento del primo passo nel corpo del macro passo.  Il corpo di un macro passo deve aver inizio con un passo iniziale di macro e deve terminare con un passo finale di macro. Il diagramma non deve avere riferimenti esterni. Un passo iniziale non ha collegamenti superiori (nessuna transizione precedente). Un passo finale non ha collegamenti inferiori (nessuna transizione successiva). Il simbolo di un macro passo può essere inserito nel corpo di un altro macro passo.

Avvertenza: Poiché un macro passo costituisce un unico insieme di passi e transizioni, lo stesso macro passo non può essere usato più di una volta in un programma SFC.

Esempio di macro passo:

(* Programma SFC con un macro passo *)

(* Diagramma principale *)	(* Corpo di un macro passo *)


Azioni all'interno di un passo

Il livello 2 di un passo SFC è l'elenco dettagliato delle azioni eseguite quando il passo è attivo, che viene inserito in modalità SFC testuale, con la possibilità di usare anche altri linguaggi come ad esempio Structured Text (ST). I tipi base delle azioni sono:

Azioni booleane

Azioni di tipo impulsivo

Azioni di tipo non-memorizzato

Azioni SFC

Uno stesso passo può contenere più azioni (di tipo uguale o differente). Le situazioni particolari che permettono l'uso di altri linguaggi sono:

Richiamare funzioni e blocchi funzione da un'azione

Convenzione IL


Azioni booleane

Le azioni booleane  assegnano ad una variabile booleana lo stato di attività del passo. La variabile booleana può essere interna o un output. Viene valorizzata ogni volta che viene avviata o fermata l'attività del passo. Questa è la sintassi delle azioni booleane di base:

<variabile_booleana> (N);    	assegna alla variabile lo stato di attività del passo

<variabile_booleana>;          	stesso effetto (l'attributo N è facoltativo)

/ <variabile_booleana>;        	assegna alla variabile l'inverso dello stato di attività del passo

Esistono altre possibilità di modificare il valore della variabile booleana all'attivazione del passo. Questa è la sintassi delle azioni booleane di tipo set e reset:

<variabile_booleana> (S);      	imposta la variabile booleana a TRUE quando lo stato di attività del passo diventa TRUE

<variabile_booleana> (R);      	imposta la variabile a FALSE quando lo stato di attività del passo diventa TRUE

La variabile booleana deve avere attributo di variabile di USCITA o INTERNA. Nell'esempio, il risultato della programmazione SFC:

Esempio di azioni booleane:

(* Programma SFC che usa azioni BOOLEANE *)


Azioni di tipo impulsivo

Un'azione di tipo impulsivo è costituita da un elenco di istruzioni ST o IL, che vengono eseguite solamente una volta al momento dell'attivazione del passo. Le istruzioni rispettano la seguente sintassi SFC:

ACTION (P) :

(* istruzioni ST *)

END_ACTION ;

Di seguito vengono illustrati i risultati di  un'azione di tipo impulsivo

Esempio di un'azione di tipo impulsivo:


Azioni di tipo non-memorizzato

Un'azione di tipo non-memorizzato (normale) è costituita da un elenco di istruzioni ST o IL, che vengono eseguite ad ogni ciclo durante l'intero periodo di attivazione del passo. Le istruzioni rispettano la seguente sintassi SFC:

ACTION (N) :

(* istruzioni ST*)

END_ACTION ;

Nota: non confondere ACTION(N) con un azione booleana Normale.

Di seguito vengono illustrati i risultati di un'azione di tipo non-memorizzata:

Esempio di un'azione di tipo non-memorizzato:


Azioni SFC

Un'azione SFC è costituita da una sequenza figlia SFC, avviata o terminata in seguito al mutare dello stato di attività del passo. Un'azione SFC può venire qualificata come N (Non-memorizzata), S (Set), o R (Reset). Questa è la sintassi delle azioni SFC di base:

<prog_figlio> (N);	avvia la sequenza figlia al momento dell'attivazione del passo, e termina la sequenza figlia quando il passo diventa inattivo

<prog_figlio> ;	stesso effetto (l'attributo N è facoltativo)

<prog_figlio> (S);	avvia la sequenza figlia al momento dell'attivazione del passo.  nessuna azione viene intrapresa quando il passo torna inattivo

<prog_figlio> (R);	termina la sequenza figlia quando il passo diventa inattivo

La sequenza SFC specificata come azione deve essere un programma SFC figlio del programma attualmente in fase di modifica. L'uso dei qualificatori S (Set) o R (Reset) in un'azione SFC, produce lo stesso effetto delle istruzioni programmate in un'azione ST di tipo pulse.

Segue sotto un esempio di azione SFC. Il programma principale SFC viene chiamato padre. Ha due figli SFC, chiamati SeqMlx e SeqPump. La programmazione SFC per il programma SFC padre è la seguente:

(* Programma SFC che usa un'azione SFC *)


Richiamare funzioni e blocchi funzione da un'azione

Sottoprogrammi, funzioni o blocchi funzione (scritti in linguaggio ST, IL, LD o FBD) o funzioni "C" e blocchi funzione "C", possono essere chiamati direttamente dall'interno di un'azione SFC, attenendosi alla seguente sintassi:

Per sottoprogrammi, funzioni e funzioni "C":

ACTION (P) :

result := sub_program ( ) ;

END_ACTION;

o

ACTION (N) :

result := sub_program ( ) ;

END_ACTION;

Per blocchi funzione in "C" o in ST, IL, LD, FBD:

ACTION (P) :

Fbinst(in1, in2);

result1 := Fbinst.out1;

result2 := Fbinst.out2;

END_ACTION;

o

ACTION (N) :

Fbinst(in1, in2);

result1 := Fbinst.out1;

result2 := Fbinst.out2;

END_ACTION;

La sintassi dettagliata è disponibile nella sezione dedicata al linguaggio ST.

Esempio di una chiamata ad un sottoprogramma dall'interno di un'azione:

(* Programma SFC con sottoprogramma chiamato dall'interno di un'azione *)


Convenzione IL

La programmazione di tipo Instruction List (IL) può essere introdotta direttamente in un'azione SFC rispettando la seguente sintassi:

ACTION (P) :	(* o N *)

#info=IL

     <istruzione>

     <istruzione>

     ....

#endinfo

END_ACTION;

Le parole chiave speciali "#info=IL" e "#endinfo" devono essere introdotte esattamente nel modo esposto, viene fatta distinzione tra lettere maiuscole e minuscole. I caratteri spazio o tabulazione non possono essere inseriti all'interno, prima o dopo le parole chiave. Segue un esempio di programma IL all'interno di in un'azione:

(* Programma SFC con una sequenza IL in un blocco azione *)


Condizioni abbinate alle transizioni

Ad ogni transizione è abbinata un'espressione booleana  che regola l'attivazione della transizione. La condizione viene generalmente espressa con il linguaggio ST o con il linguaggio LD (editor Quick LD). Corrisponde al Livello 2 della transizione. È, comunque, possibile usare altre strutture:

-	Convenzioni del linguaggio ST

-	Convenzioni del linguaggio LD

-	Convenzioni del linguaggio IL

-	Funzione chiamata da una transizione

Avvertenza: Qualora non ci siano espressioni abbinate alla transizione, la condizione predefinita è TRUE.


Convenzione ST

La condizione abbinata ad una transizione può essere scritta usando il linguaggio Structured Text (ST) L'espressione completa deve essere di tipo booleano e deve terminare con punto e virgola, rispettando la seguente sintassi:

< espressione_booleana > ;

L'espressione può essere costituita da un'espressione costante TRUE o FALSE, un singolo input, una variabile interna booleana, o una combinazione di variabili che diano come risultato un valore booleano. Di seguito, viene proposto un esempio di programmazione ST per le transizioni:

(* Programma SFC con programmazione ST per le transizioni *)


Convenzione LD

Il linguaggio Ladder Diagram (LD) permette di descrivere la condizione abbinata ad una transizione. Il diagramma è composto di un solo ramo con una sola bobina. La bobina rappresenta il valore della transizione. Di seguito, viene proposto un esempio di programmazione LD per le transizioni:


IL convention

Con la programmazione Instruction List (IL) , è possibile descrivere direttamente una transizione SFC rispettando la seguente sintassi:

#info=IL

<istruzione>

<istruzione>

....

#endinfo

Il valore contenuto nel risultato corrente (registro IL) al termine della sequenza IL, viene abbinato alla condizione della transizione:

current result = 0 	 	la condizione vale FALSE

current result <> 0	la condizione vale TRUE

Le parole chiave speciali "#info=IL" e "#endinfo" devono essere inserite esattamente nel modo descritto, viene fatta distinzione tra lettere maiuscole e minuscole. I caratteri spazio o tabulazione non possono essere inseriti all'interno, prima o dopo le parole chiave. Segue sotto un esempio di programma IL in una transizione:

(* Programma SFC con un programma IL per transizioni *)


Richiamare funzioni da una transizione

La condizione abbinata ad una transizione può essere valutata richiamando qualsiasi sottoprogramma, funzione (scritta in linguaggio FBD, LD, ST o IL) o funzione "C", rispettando la seguente sintassi:

< sub_program > ( ) ;

Il valore restituito dal sottoprogramma o dalla funzione deve essere di tipo booleano e determina il risultato della condizione:

return value = FALSE	la condizione vale FALSE

return value = TRUE	la condizione vale TRUE

Esempio di un sottoprogramma chiamato in una transizione:

(* Programma SFC con una chiamata a sottoprogramma per transizioni *)


Regole dinamiche SFC

Le cinque regole dinamiche del linguaggio SFC sono:

 Situazione iniziale

La situazione iniziale è caratterizzata dai passi iniziali che sono, per definizione, in stato attivo all'inizio dell'operazione. In ogni programma SFC deve essere presente almeno un passo iniziale.

 Attivazione di una transizione

Una transizione può essere sia abilitata che disabilitata. Viene detta abilitata quando tutti i passi precedenti connessi al corrispondente simbolo di transizione sono attivi, altrimenti è disabilitata. Una transizione non può essere attivata senza che:

   - sia abilitata e

   - la condizione associata alla transizione valga TRUE.

 Modifica dello stato di passi attivi

L'attivazione di una transizione, simultaneamente, porta allo stato attivo i passi immediatamente successivi ed allo stato inattivo i passi immediatamente precedenti.

 Attivazione simultanea di transizioni

La sincronizzazione delle transizioni di due rami paralleli può essere fatta in due modi diversi:

1)	Dando una regola di sincronizzazione esplicita nelle condizioni associate alle transizioni (usando l'istruzione GSnnn.X).

2)	Disegnando una doppia divergenza che indica una sincronizzazione ed utilizza una sola transizione.

 Attivazione e disattivazione simultanea di un passo

Se, durante un'operazione, un passo viene contemporaneamente attivato e disattivato, la priorità viene data all'attivazione.


Gerarchia dei programmi SFC

Il sistema ISaGRAF permette  di descrivere la struttura verticale dei programmi SFC. I programmi SFC sono organizzati ad albero gerarchico. Ogni programma SFC può controllare (avviare, terminare …) altri programmi SFC. Questi programmi vengono chiamati figli del programma SFC che li controlla. I programmi SFC sono collegati tra loro tramite un albero gerarchico rappresentato dalla relazione padre-figlio.

Le regole basilari che la struttura gerarchica implica sono:

I programmi SFC che non hanno padre, vengono chiamati programmi SFC "principali"

I programmi principali SFC vengono attivati dal sistema all'avvio dell'applicazione

Un programma può avere molteplici programmi figli

Un programma figlio non può avere più di un padre

Un programma figlio può essere controllato solamente dal proprio padre

Un programma non può controllare il figlio di uno dei suoi propri figli

Le azioni basilari che permettono ad un programma padre SFC di controllare i propri programmi figli sono:

- Avviare    	(GSTART) Avvia il programma figlio: attiva ognuno dei suoi passi iniziali. I figli del programma figlio non vengono avviati automaticamente.

- Terminare	(GKILL) Termina il programma figlio disattivando ognuno dei suoi passi attivi. I figli del programma figlio vengono a loro volta terminati.

- Sospendere	(GFREEZE) Sospende l'esecuzione del programma (disattiva le azioni di ognuno dei passi attivi e sospende il calcolo delle transizioni), e memorizza lo stato dei passi del programma di modo che il programma possa essere fatto ripartire. I figli del programma figlio vengono a loro volta sospesi.

- Riavviare	(GRST) Riavvia un programma figlio SFC sospeso, riattivando tutti i passi sospesi. I figli del programma figlio vengono a loro volta riavviati.

- Stato	(GSTATUS) Permette di conoscere l'attuale stato (attivo, inattivo o sospeso) del programma figlio.


Linguaggio LD

Il linguaggio Ladder Diagram (LD) è la rappresentazione grafica di formule booleane che combinano contatti (argomenti in ingresso) con bobine (risultati in uscita). Il linguaggio LD permette di descrivere interrogazioni e modifiche di dati di tipo booleano inserendo simboli grafici sul diagramma del programma. I simboli grafici LD sono organizzati sul diagramma esattamente come per un diagramma di contatti elettrici. I diagrammi LD sono connessi sul lato sinistro e sul lato destro a barre di alimentazione verticali.

Barre di alimentazione e linee di connessione

Connessioni multiple

Contatti e bobine LD

Istruzione di RETURN

Salti ed etichette

Blocchi in LD

Questi sono i componenti grafici di base di un diagramma LD:

Barra verticale sinistra di alimentazione

Barra verticale destra di alimentazione

Linea di connessione orizzontale

Linea di connessione verticale

Linee di connessione multiple (tutte connesse tra loro))

Contatto associato ad una variabile

Bobina associata ad un output o ad una variabile interna


Barre di alimentazione e linee di connessione

Un diagramma LD è delimitato sul lato sinistro e destro da linee verticali chiamate, rispettivamente, barra di alimentazione sinistra e barra di alimentazione destra.

I simboli grafici di un diagramma LD sono connessi alle barre di alimentazione o agli altri simboli mediante linee di connessione . Le linee di connessione possono essere orizzontali o verticali.

Ogni segmento può assumere uno stato booleano FALSE o TRUE. Lo stato booleano è il medesimo per tutti i segmenti collegati tra loro direttamente. Ogni linea orizzontale connessa ad una barra verticale sinistra di alimentazione ha stato TRUE.


Connessioni multiple

Lo stato booleano assunto da una singola connessione orizzontale, è lo stesso alle estremità sinistra e destra della linea stessa. Si possono creare connessioni multiple combinando assieme linee verticali ed orizzontali. Lo stato booleano delle estremità di una connessione multipla viene determinato dalle seguenti regole

Una connessione multipla a sinistra è costituita da molteplici linee orizzontali collegate al lato sinistro di una linea verticale e da una linea connessa al lato destro. Lo stato booleano dell'estremità destra è costituito dall'OR LOGICO di tutte le estremità a sinistra.

(* Esempio di connessione multipla a SINISTRA *)

(* Lo stato dell'estremità destra vale (v1 OR v2 OR v3) *)

Una connessione multipla a destra è costituita da una linea orizzontale collegata al lato sinistro di una linea verticale, al cui lato destro, sono collegate molteplici linee. Lo stato booleano dell'estremità sinistra viene propagato a ciascuna estremità destra.

(* Esempio di connessione multipla a DESTRA *)

(* Equivalente ST: *)

output1 := input1;

output2 := input1;

Una connessione multipla a sinistra e destra è costituita da molteplici linee orizzontali collegate a sinistra di una linea verticale, al cui lato destro sono collegate molteplici linee. Lo stato booleano di ciascuna delle estremità a destra è costituito dall'OR LOGICO di tutte le estremità a sinistra.

(* Esempio di connessione multipla a SINISTRA e DESTRA *)

(* Equivalente ST: *)

output1 := input1 OR input2;

output2 := input1 OR input2;

output3 := input1 OR input2;


Contatti e bobine LD

Svariati simboli sono disponibili per rappresentare i contatti in input :

Contatto diretto

Contatto inverso

Contatto con riconoscimento del fronte di salita

Contatto con riconoscimento del fronte di discesa

Svariati simboli sono disponibili per rappresentare le bobine in output :

Bobina diretta

Bobina inversa

Bobina di tipo SET

Bobina di tipo RESET

Bobina con riconoscimento del fronte di salita

Bobina con riconoscimento del fronte di discesa

Il nome della variabile è scritto sopra ogni simbolo grafico::


Contatto diretto

Un contatto diretto  corrisponde ad un'operazione booleana tra lo stato di una linea di connessione ed una variabile booleana.

Lo stato della linea di connessione destra del contatto è l'AND LOGICO tra lo stato della linea di connessione sinistra ed il valore della variabile associata al contatto.

(* Esempio che fa uso di contatti DIRETTI *)

(* Equivalente ST: *)

output1 := input1 AND input2;


Contatto inverso

Un contatto inverso  corrisponde ad un'operazione booleana tra lo stato di una linea di connessione e la negazione booleana di una variabile booleana.

Lo stato della linea di connessione destra del contatto è l'AND LOGICO tra lo stato della linea di connessione sinistra e la negazione booleana del valore della variabile associata al contatto.

(* Esempio che fa uso di contatti INVERSI *)

(*Equivalente ST: *)

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


Contatto con riconoscimento di fronte di salita

Questo contatto (positivo) corrisponde ad un'operazione booleana tra lo stato di una linea di connessione ed il fronte di salita di una variabile booleana.

Lo stato della linea di connessione destra del contatto viene impostato a TRUE quando lo stato della linea di connessione a sinistra vale TRUE e lo stato della variabile associata sale da FALSE a TRUE. In tutti gli altri casi viene impostato a FALSE.

(* Esempio che fa uso di contatti con FRONTE DI SALITA *)

(* Equivalente ST: *)

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

(* input2prev è il valore di input2 nel ciclo precedente *)


Contatto con riconoscimento di fronte di discesa

 Questo contatto (negativo) corrisponde ad un'operazione booleana tra lo stato di una linea di connessione ed il fronte di discesa di una variabile booleana.

Lo stato della linea di connessione destra del contatto viene impostato a TRUE quando lo stato della linea di connessione a sinistra vale TRUE e lo stato della variabile associata cade da TRUE a. FALSE In tutti gli altri casi viene impostato a FALSE.

(*Esempio che fa uso di contatti con FRONTE DI DISCESA*)

(*Equivalente ST: *)

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

(*input2prev è il valore di input2 nel ciclo precedente*)


Bobina diretta

Le bobine dirette  corrispondono all'output booleano di una linea di connessione.

Alla variabile associata viene assegnato lo stato booleano della connessione sinistra. Lo stato della connessione sinistra viene propagato alla connessione destra. La connessione destra può essere collegata alla barra verticale destra di alimentazione.

La variabile booleana associata deve avere attributo di variabile di USCITA o INTERNA. Il nome associato può essere il nome del programma (solamente per sottoprogrammi). In questo modo viene assegnato il valore di ritorno del sottoprogramma.

(* Esempio che fa uso di bobine DIRETTE *)

(* Equivalente ST: *)

output1 := input1;

output2 := input1;


Bobina inversa

Le bobine inverse corrispondono ad un output booleano dato dalla negazione booleana dello stato di una linea di connessione.

Alla variabile associata viene assegnata la negazione dello stato booleano della connessione sinistra. Lo stato della connessione sinistra viene propagato alla connessione destra. La connessione destra può essere collegata alla barra verticale destra di alimentazione.

La variabile booleana associata deve avere attributo di variabile di USCITA o INTERNA. Il nome associato può essere il nome del programma (solamente per sottoprogrammi). In questo modo viene assegnato il valore di ritorno del sottoprogramma.

(*Esempio che fa uso di bobine INVERSE*)

(* Equivalente ST: *)

output1 := NOT (input1);

output2 := input1;


Bobina di tipo SET

Le bobine di tipo "Set"  corrispondono ad un output booleano dato dallo stato di una linea di connessione.

La variabile associata viene IMPOSTATA A TRUE quando lo stato booleano della connessione di sinistra diventa TRUE. La variabile di output mantiene tale valore fino a quando viene attuata un'inversione da parte di una bobina di tipo "RESET". Lo stato della connessione sinistra viene propagato alla connessione destra. La connessione destra può essere collegata alla barra verticale destra di alimentazione.

La variabile booleana associata deve avere attributo di variabile di USCITA o INTERNA.

(* Esempio che fa uso di bobine di tipo "SET" e "RESET" *)

(* Equivalente ST: *)

IF input1 THEN

   output1 := TRUE;

END_IF;

IF input2 THEN

   output1 := FALSE;

END_IF;


Bobina di tipo RESET

Le bobine di tipo "Reset"  corrispondono ad un output booleano dato dallo stato di una linea di connessione.

La variabile associata viene IMPOSTATA A FALSE quando lo stato booleano della connessione di sinistra diventa TRUE. La variabile di output mantiene tale valore fino a quando viene attuata un'inversione da parte di una bobina di tipo "SET". Lo stato della connessione sinistra viene propagato alla connessione destra. La connessione destra può essere collegata alla barra verticale destra di alimentazione.

La variabile booleana associata deve avere attributo di variabile di USCITA o INTERNA.

 (*Esempio che fa uso di bobine di tipo "SET" e "RESET" *)

(*Equivalente ST: *)

IF input1 THEN

   output1 := TRUE;

END_IF;

IF input2 THEN

   output1 := FALSE;

END_IF;


Bobina con riconoscimento di fronte di salita

Le bobine "positive" corrispondono ad un output booleano dato dallo stato di una linea di connessione. Questo tipo di bobine è disponibile solo usando l'editor Quick Ladder.

La variabile associata viene impostata a TRUE quando lo stato booleano della connessione di sinistra sale da FALSE a TRUE. In tutti gli altri casi, il valore della variabile di output, viene impostato a FALSE. Lo stato della connessione sinistra viene propagato alla connessione destra. La connessione destra può essere collegata alla barra verticale destra di alimentazione.

La variabile booleana associata deve avere attributo di variabile di USCITA o INTERNA.

(* Esempio che fa uso di una bobina "Positiva" *)

(* Equivalente ST: *)

IF (input1 and NOT(input1prev)) THEN

   output1 := TRUE;

ELSE

   output1 := FALSE;

END_IF;

(*input1prev è il valore di input1 nel ciclo precedente*)


Bobina con riconoscimento di fronte di discesa

Le bobine "negative" corrispondono ad un output booleano dato dallo stato di una linea di connessione. . Questo tipo di bobine è disponibile solo usando l'editor Quick Ladder.

La variabile associata viene impostata a TRUE quando lo stato booleano della connessione di sinistra cade da TRUE a FALSE. In tutti gli altri casi, il valore della variabile di output, viene impostato a FALSE. Lo stato della connessione sinistra viene propagato alla connessione destra. La connessione destra può essere collegata alla barra verticale destra di alimentazione.

La variabile booleana associata deve avere attributo di variabile di USCITA o INTERNA.

(* Esempio che fa uso di una bobina "Negativa" *)

(*Equivalente ST: *)

IF (NOT(input1) and input1prev) THEN

   output1 := TRUE;

ELSE

   output1 := FALSE;

END_IF;

(*input1prev è il valore di input1 nel ciclo precedente*)


Istruzione RETURN

L'etichetta RETURN può essere usata come output per rappresentare la fine condizionata del programma. Nessun'altra connessione è possibile alla destra del simbolo di RETURN.

Quando la linea di connessione sinistra ha stato booleano TRUE, il programma termina senza che vengano eseguite le formule inserite nelle successive linee del diagramma.

Nota: Nel caso il programma LD sia un sottoprogramma, il suo nome deve essere associato ad una bobina di output per assegnare il valore di ritorno (restituito al programma chiamante).

(* Esempio che fa uso del simbolo RETURN *)

(* Equivalente ST: *)

If Not (manual_mode) Then RETURN; End_if;

result := (input1 OR input3) AND input2;


Salti ed etichette

Simboli etichetta, SALTI condizionati o incondizionati, si usano per controllare l'esecuzione del diagramma. Non è possibile alcuna connessione alla destra del simbolo di etichetta o di salto. Si usano le seguenti notazioni:

>>LAB	salto ad una etichetta chiamata "LAB"

LAB:	definizione di una etichetta chiamata "LAB"

Quando la connessione sinistra del simbolo di salto vale TRUE, l'esecuzione del programma viene indirizzata dopo il simbolo dell'etichetta.

(* Esempio che fa uso dei simboli di  SALTO e ETICHETTA *)

(* Equivalente IL: *)

ldn	manual_mode

jmpc	other

ld	input1

st	result

jmp	END

OTHER:	ld	input2

st	result

END:	(* fine del programma *)


Blocchi in LD

L'editor Quick LD permette di collegare caselle funzione a linee booleane. Per funzione si intende un operatore, un blocco funzione o una funzione. Poiché non tutti i blocchi hanno sempre un input booleano e/o un output booleano, per inserire blocchi in un diagramma LD, è necessario introdurre i nuovi parametri EN, ENO all'interfaccia del blocco. I parametri EN, ENO non vengono aggiunti nell'editor FBD/LD, poiché è possibile collegare variabili del tipo necessario.

L'input "EN"

L'output "ENO"

I parametri "EN" e "ENO"


L'input "EN"

Alcuni operatori, funzioni o blocchi funzione, non hanno il primo input di tipo booleano. Poiché il primo input deve essere sempre collegato al ramo, un altro input, chiamato "EN" viene automaticamente inserito in prima posizione. Il blocco viene eseguito solamente se l'input EN vale TRUE. Segue un esempio che riporta un operatore di confronto ed il codice equivalente espresso in codice ST:

	IF rung_state THEN    q := (value1 > value 2); ELSE    q := FALSE; END_IF; (* continue rung with q state *)


L'output "ENO"

Alcuni operatori, funzioni o blocchi funzione, non hanno il primo output di tipo booleano. Poiché il primo output deve essere sempre collegato al ramo, un altro output, chiamato "ENO" viene automaticamente inserito in prima posizione. L'output ENO, assume sempre lo stesso stato del primo input del blocco. Segue un esempio che riporta un blocco funzione AVERAGE (MEDIA) ed il codice equivalente espresso in codice ST:

	AVERAGE(rung_state, Signal, 100); OutSignal := AVERAGE.XOUT; eno := rung_state; (* continue rung with eno state *)


I parametri "EN" ed "ENO"

In alcuni casi sono necessari entrambi EN ed ENO. Segue un esempio che riporta operatore aritmetico ed il codice equivalente espresso in codice:

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


Operatori standard, blocchi funzione e funzioni

Operatori standard

Blocchi funzione standard

Funzioni standard

Indice alfabetico


Operatori standard

I seguenti sono operatori standard dei linguaggi IEC.

Manipolazione dei dati

1 gain	Assegnazione

Neg	Negazione analogica

Operazioni booleane

& (AND)	AND booleano

>=1 (OR)	OR booleano

=1 (XOR)	OR esclusivo booleano

Operazioni aritmetiche

 + 	Addizione

 - 	Sottrazione

 * 	Moltiplicazione

 / 	Divisione

Operazioni logiche

AND_MASK	Mascheramento analogico AND bit a bit

OR_MASK	Mascheramento analogico OR bit a bit

XOR_MASK	Mascheramento analogico OR esclusivo bit a bit

NOT_MASK	Negazione bit a bit

Test di comparazione

 < 	Minore di

 <= 	Minore o uguale a

 > 	Maggiore di

 >= 	Maggiore o uguale a

 = 	Uguale a

 <> 	Non uguale a

Conversione dati

BOO	Conversione a Booleano

ANA	Conversione ad Intero Analogico

REAL	Conversione a Reale Analogico

TMR	Conversione a Timer

MSG	Conversione a Messaggio

Altri

CAT	Concatenazione di messaggi

SYSTEM	Accesso al sistema

OPERATE	Operazioni su canali I/O


1 gain

Argomenti:

IN	qualsiasi tipo

Q	qualsiasi tipo

Descrizione:

assegnazione di una variabile ad un'altra

Questo blocco risulta molto utile per collegare direttamente l'input di un diagramma all'output di un altro diagramma. Può anche essere usato (con una linea di negazione booleana) per invertire lo stato di una linea connessa all'output di un diagramma.

(*Esempio FBD con Blocchi di tipo assegnazione *)

(* equivalente ST: *)

ao23 := ai10;

bo100 := NOT (bi1 AND bi2);

(*equivalente IL: *)

LD	ai10

ST 	ao23

LD	bi1

AND	bi2

STN	bo100


NEG

Argomenti:

IN	INT-REALE	input ed output devono avere lo stesso formato

Q	INT-REALE

Descrizione:

Assegnazione della negazione di una variabile.

(*Esempio FBD con Blocchi di tipo negazione *)

(* equivalente ST: *)

ao23 := - (ai10);

ro100 := - (ri1 + ri2);

(* equivalente IL: *)

LD	ai10

MUL	-1

ST 	ao23

LD	ri1

ADD	ri2

MUL	-1.0

ST	ro100


& AND

Nota: Per questo operatore, il numero degli input può essere esteso a più di due.

Argomenti:

input	BOOLEAN

output	BOOLEAN	AND booleano dei termini in input

Descrizione:

AND booleano tra due o più termini.

(*Esempio FBD con Blocchi "AND" *)

(* equivalente ST: *)

bo10 := bi101 AND NOT (bi102);

bo5 := (bi51 AND bi52) AND bi53;

(*equivalente IL *)

LD	bi101	(* risultato corrente := bi101 *)

ANDN	bi102	(* risultato corrente := bi101 AND not (bi102) *)

ST	bo10	(* bo10 := risultato corrente *)

LD	bi51	(* risultato corrente := bi51;

&	bi52	(* risultato corrente := bi51 AND bi52 *)

&	bi53	(* risultato corrente := (bi51 AND bi52) AND bi53 *)

ST	bo5	(* bo5 := risultato corrente *)


>=1 OR

Nota: Per questo operatore, il numero degli input può essere esteso a più di due.

Argomenti:

input	BOOLEAN

output	BOOLEAN	OR booleano dei termini di input

Descrizione:

OR booleano di due o più termini.

(*Esempio FBD con Blocchi "OR" *)

(* Equivalente ST: *)

bo10 := bi101 OR NOT (bi102);

bo5 := (bi51 OR bi52) OR bi53;

(*Equivalente IL: *)

LD	bi101

ORN	bi102

ST	bo10

LD	bi51

OR	bi52

OR	bi53

ST	bo5


=1 XOR

Argomenti:

IN1	BOOLEAN

IN2	BOOLEAN

Q	BOOLEAN	OR esclusivo booleano dei due termini di input

Descrizione:

OR esclusivo booleano tra due termini.

(* Esempio FBD con Blocchi "XOR" *)

(* Equivalente ST: *)

bo10 := bi101 XOR NOT (bi102);

bo5 := (bi51 XOR bi52) XOR bi53;

(* Equivalente IL: *)

LD	bi101

XORN	bi102

ST	bo10

LD	bi51

XOR	bi52

XOR	bi53

ST	bo5


+

Nota: Per questo operatore, il numero degli input può essere esteso a più di due.

Argomenti:

input	INT-REALE	può essere di tipo INTERO o REALE

(tutti gli input devono avere lo stesso formato)

output	INT-REALE	addizione con segno dei termini di input

Descrizione:

Addizione di due o più variabili analogiche.

(*Esempio FBD Blocchi di Addizione *)

(*equivalente ST: *)

ao10 := ai101 + ai102;

ao5 := (ai51 + ai52) + ai53;

(*equivalente IL: *)

LD	ai101

ADD	ai102

ST	ao10

LD	ai51

ADD	ai52

ADD	ai53

ST	ao5


-

Argomenti:

IN1	INT-REALE	può essere INTERO o REALE

IN2	INT-REALE	(IN1 e IN2 devono avere lo stesso formato)

Q	INT-REALE	sottrazione (primo - secondo)

Descrizione:

Sottrazione tra due variabili analogiche (primo - secondo).

(*Esempio FBD con Blocchi di tipo Sottrazione *)

(* Equivalente ST: *)

ao10 := ai101 - ai102;

ao5 := (ai51 - 1) - ai53;

(* Equivalente IL: *)

LD	ai101

SUB	ai102

ST	ao10

LD	ai51

SUB	1

SUB	ai53

ST	ao5


*

Nota: Per questo operatore, il numero degli input può essere esteso a più di due.

Argomenti:

input	INT-REALE	può essere di tipo INTERO o REALE

(tutti gli input devono avere lo stesso formato)

output	INT-REALE	moltiplicazione con segno dei termini di input

Descrizione:

Moltiplicazione di due o più variabili analogiche.

(* Esempio FBD con Blocchi di tipo Moltiplicazione *)

(* Equivalente ST *)

ao10 := ai101 * ai102;

ao5 := (ai51 * ai52) * ai53;

(* Equivalente IL: *)

LD	ai101

MUL	ai102

ST	ao10

LD	ai51

MUL	ai52

MUL	ai53

ST	ao5


/

Argomenti:

IN1	INT-REALE	può essere di tipo INTERO o REALE (operando)

IN2	INT-REALE	valore analogico diverso da 0 (divisore)

(IN1 e IN2 devono avere lo stesso formato)

Q	INT-REALE	divisione con segno intera o reale tra IN1 e IN2

Descrizione:

Divisione di due variabili analogiche (la prima diviso la seconda).

(*Esempio FBD con Blocchi di tipo Divisione *)

(* Equivalente ST: *)

ao10 := ai101 / ai102;

ao5 := (ai51 / 2) / ai53;

(* Equivalente IL: *)

LD	ai101

DIV	ai102

ST	ao10

LD	ai51

DIV	2

DIV	ai53

ST	ao5


AND_MASK

Argomenti:

IN	INT	deve avere formato intero

MSK	INT	deve avere formato intero

Q	INT	AND logico bit a bit tra IN e MSK

Descrizione:

Mascheramento intero analogico AND bit a bit.

(* Esempio FBD con Blocchi di tipo AND_MASK analogico*)

(* Equivalente ST: *)

parity := AND_MASK (xvalue, 1); (* 1 se xvalue è dispari *)

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

(* Equivalente IL: *)

LD	xvalue

AND_MASK	1

ST	parity

LD	16#abc

AND_MASK	16#f0f

ST	result


OR_MASK

Argomenti:

IN	INT	deve avere formato intero

MSK	INT	deve avere formato intero

Q	INT	OR logico bit a bit tra IN e MSK

Descrizione:

Mascheramento intero analogico OR bit a bit.

(* Esempio FBD con Blocchi di tipo OR_MASK analogico*)

(* Equivalente ST: *)

is_odd := OR_MASK (xvalue, 1); (* rende sempre dispari il valore *)

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

(* Equivalente IL: *)

LD	xvalue

OR_MASK	1

ST	is_odd

LD	16#abc

OR_MASK	16#f0f

ST	result


XOR_MASK

Argomenti:

IN	INT	deve avere formato intero

MSK	INT	deve avere formato intero

Q	INT	OR esclusivo logico bit a bit tra IN e MSK

Descrizione:

Mascheramento intero analogico OR esclusivo bit a bit

(* Esempio FBD con Blocchi di tipo XOR_MASK *)

(* Equivalente ST: *)

crc32 := XOR_MASK (prevcrc, nextc);

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

(* Equivalente IL: *)

LD	prevcrc

XOR_MASK	nextc

ST	crc32

LD	16#012

XOR_MASK	16#011

ST	result


NOT_MASK

Argomenti :

IN	INT	deve avere formato intero

Q	INT	negazione bit a bit a 32 bit di IN

Descrizione:

Mascheramento negato intero analogico bit a bit.

(* Esempio FBD con Blocchi di tipo NOT_MASK *)

(*Equivalente ST: *)

result := NOT_MASK (16#1234);

(* result is 16#FFFF_EDCB *)

(* Equivalente IL: *)

LD	16#1234

NOT_MASK

ST	result


<

Argomenti:

IN1	INT-REALE-

TMR-MSG

IN2	INT-REALE-

TMR-MSG	entrambi gli input devono essere dello stesso tipo

Q	BOOLEAN	TRUE se IN1 < IN2

Descrizione:

Controlla se un valore sia MINORE DI un altro (per tipo analogico, timer o messaggio)

(* Esempio FBD con Blocchi di tipo "Minore di" *)

(* Equivalente ST: *)

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

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

(* Equivalente IL: *)

LD	10

LT	25

ST	aresult

LD	'z'

LT	'B'

ST	mresult


<=

Argomenti:

IN1	INT-REALE-MSG

IN2	INT-REALE-MSG	entrambi gli input devono essere dello stesso tipo

Q	BOOLEAN	TRUE se IN1 <= IN2

Descrizione:

Controlla se un valore sia MINORE DI o UGUALE A un altro (per tipo analogico o messaggio)

(* Esempio FBD con Blocchi di tipo "Minore o uguale a" *)

(* Equivalente ST: *)

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

mresult := ('ab' <= 'ab'); (* mresult vale TRUE *)

(* Equivalente IL: *)

LD	10

LE	25

ST	aresult

LD	'ab'

LE	'ab'

ST	mresult


>

Argomenti:

IN1	INT-REALE-

TMR-MSG

IN2	INT-REALE-

TMR-MSG 	entrambi gli input devono essere dello stesso tipo

Q	BOOLEAN	TRUE se IN1 > IN2

Descrizione:

Controlla se un valore sia MAGGIORE DI un altro (per tipo analogico, timer o messaggio)

(* Esempio FBD con Blocchi di tipo "Maggiore di" *)

(* Equivalente ST: *)

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

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

(* Equivalente IL: *)

LD	10

GT	25

ST	aresult

LD	'ab'

GT	'a'

ST	mresult


>=

Argomenti:

IN1	INT-REALE-MSG

IN2	INT-REALE-MSG 	entrambi gli input devono essere dello stesso tipo

Q	BOOLEAN	TRUE se IN1 >= IN2

Descrizione:

Controlla se un valore sia MAGGIORE DI o UGUALE A un altro (per tipo analogico o messaggio)

(* Esempio FBD con Blocchi di tipo "Maggiore o uguale a " *)

(* Equivalente ST: *)

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

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

(* Equivalente IL: *)

LD	10

GE	25

ST	aresult

LD	'ab'

GE	'ab'

ST	mresult


=

Argomenti:

IN1	INT-REALE-MSG

IN2	INT-REALE-MSG 	entrambi gli input devono essere dello stesso tipo

Q	BOOLEAN	TRUE se IN1 = IN2

Descrizione:

Controlla se un valore sia UGUALE A un altro (per tipo analogico o messaggio)

(* Esempio FBD con Blocchi di tipo "Uguale a" *)

(* Equivalente ST: *)

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

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

(* Equivalente IL: *)

LD	10

EQ	25

ST	aresult

LD	'ab'

EQ	'ab'

ST	mresult


<>

Argomenti:

IN1	INT-REALE-MSG

IN2	INT-REALE-MSG 	entrambi gli input devono essere dello stesso tipo

Q	BOOLEAN	TRUE se primo <> secondo

Descrizione:

Controlla se un valore sia DIVERSO DA un altro (per tipo analogico o messaggio)

(* Esempio FBD con Blocchi di tipo "Diverso da" *)

(* Equivalente ST: *)

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

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

(* Equivalente IL: *)

LD	10

NE	25

ST	aresult

LD	'ab'

NE	'ab'

ST	mresult


BOO

Argomenti:

IN	ANY	qualsiasi valore non booleano

Q	BOO	TRUE per valori numerici diversi da zero

FALSE per valori numerici uguali a zero

TRUE per il messaggio 'TRUE'

FALSE per il messaggio 'FALSE'

Descrizione:

Converte una variabile da un qualsiasi tipo a tipo booleano

(* Esempio FBD con Blocchi di tipo "Conversione a booleano " *)

(* Equivalente ST: *)

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

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

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

(* Equivalente IL: *)

LD	10

BOO

ST	ares

LD	t#0s

BOO

ST	tres

LD	'false'

BOO

ST	mres


ANA

Argomenti:

IN	ANY	qualsiasi valore analogico non intero

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

numero di millisecondi nel caso di un timer

parte intera nel caso di reale analogico

numero decimale rappresentato da una stringa

Descrizione:

Converte una variabile da un qualsiasi tipo a tipo intero

(* Esempio FBD con Blocchi di tipo "Conversione ad Analogico" *)

(* Equivalente ST: *)

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

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

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

(* Equivalente IL: *)

LD	true

ANA

ST	bres

LD	t#1s46ms

ANA

ST	tres

LD	'0198'

ANA

ST	mres


REAL

rgomenti:

IN	BOO-INT-

TMR	qualsiasi valore di tipo diverso da reale analogico o messaggio

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

numero di millisecondi nel caso di un timer

il numero equivalente nel caso di intero analogico

Descrizione:

Converte una variabile da un qualsiasi tipo a tipo reale

(* Esempio FBD con Blocchi di tipo "Conversione a Reale" *)

(* Equivalente ST: *)

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

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

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

(* Equivalente IL: *)

LD	true

REAL

ST	bres

LD	t#1s46ms

REAL

ST	tres

LD	198

REAL

ST	ares


TMR

Argomenti:

IN	INT-REALE	qualsiasi valore non temporale

IN (o la parte intera di IN nel caso sia di tipo reale) rappresenta il numero di millisecondi

Q	TIMER	valore temporale rappresentato da IN

Descrizione:

Converte una variabile di tipo analogico a tipo timer

(* Esempio FBD con Blocchi di tipo "Conversione a Timer" *)

(* Equivalente ST: *)

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

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

(* Equivalente IL: *)

LD	1256

TMR

ST	ares

LD	1256.3

TMR

ST	rres


MSG

Argomenti:

IN	BOO-

INT-REA	qualsiasi valore che non sia un messaggio

Q	MSG	'false' o 'true' se IN è di tipo booleano

rappresentazione decimale se IN è di tipo analogico

Descrizione:

Converte una variabile in messaggio

(* Esempio FBD con Blocchi di tipo "Conversione a Messaggio" *)

(* Equivalente ST: *)

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

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

(* Equivalente IL: *)

LD	true

MSG

ST	bres

LD	125

MSG

ST	ares


CAT

Nota: Per questo operatore, il numero degli input può essere esteso a più di due.

Argomenti:

input	MSG	(la lunghezza complessiva dei messaggi non deve eccedere la capacità del messaggio in output)

output	MSG	concatenazione dei messaggi in input

Descrizione:

Concatena più messaggi in uno

(* Esempio FBD con Blocchi di tipo "Concatenazione di Messaggi" *)

(* Equivalente ST: si usa l'operatore + *)

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

(*equivale a: myname := 'Mr Jones' *)

(* Equivalente IL: *)

LD	'Mr'

ADD	' '

ADD	'Jones'

ST	myname


SYSTEM

Argomenti:

Mode	INT	rappresenta il parametro di sistema ed il modo di accesso

Arg	INT-TMR	nuovo valore per un accesso "in scrittura"

Param	INT	valore del parametro cui si accede

Descrizione:

Accesso ai parametri di sistema

La seguente lista elenca i comandi disponibili (parole chiave predefinite) per la funzione SYSTEM:

Comando	Descrizione

SYS_TALLOWED	lettura del tempo ciclo consentito

SYS_TCURRENT	lettura del tempo ciclo corrente

SYS_TMAXIMUM	lettura del tempo ciclo massimo

SYS_TOVERFLOW	lettura overflow tempo ciclo

SYS_TRESET	azzeramento contatori temporali

SYS_TWRITE	modifica tempo ciclo

SYS_ERR_TEST	controllo errori in esecuzione

SYS_ERR_READ	lettura errore iniziale in esecuzione

Argomenti richiesti per le funzioni predefinite della funzione SYSTEM:

comando	argomento	Valore di ritorno

SYS_TALLOWED	0	tempo ciclo consentito

SYS_TCURRENT	0	tempo ciclo corrente

SYS_TMAXIMUM	0	timing massimo rilevato

SYS_TOVERFLOW	0	numero di overflow timing

SYS_TRESET	0	0

SYS_TWRITE	nuovo tempo	valore accettato

ciclo consentito

SYS_ERR_TEST	0	0 nel caso non sia stato rilevato alcun errore

SYS_ERR_READ	0	codice di errore iniziale

(* Esempio FBD con Blocchi di tipo "System" *)

(* Equivalente ST: *)

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

If (alarm) Then

nb_err := nb_err + 1;

rc := SYSTEM (SYS_TRESET, 0);

End_If;


OPERATE

Argomenti:

IO	ANY	variabile di input o output

Funct	INT	azione da intraprendere

Arg	INT	argomento per l'azione di I/O

Q	INT	controllo di ritorno

Descrizione:

Accesso ad un canale di I/O

Il significato degli argomenti di OPERATE dipende dall'implementazione dell'interfaccia I/O. Per maggiori ragguagli sulle possibilità di OPERATE, si veda il manuale relativo alla parte hardware o le note tecniche della scheda I/O.


Blocchi funzione standard

Questi sono i blocchi funzione standard supportati dal sistema ISaGRAF. Sono predefiniti e non devono essere dichiarati nella libreria.

Booleani:

SR	Bistabile con set dominante

RS	Bistabile con reset dominante

R_TRIG	Riconoscimento di fronte di salita

F_TRIG	Riconoscimento di fronte di discesa

SEMA	Semaforo

Contatore:

CTU	Contatore ad incremento

CTD	Contatore a decremento

CTUD	Contatore ad incremento - decremento

Temporizzatori:

TON	Temporizzatore con ritardo di attivazione

TOF	Temporizzatore con ritardo di disattivazione

TP	Temporizzatore di impulsi

Interi analogici:

CMP	Blocco funzione di comparazione completa

STACKINT	Stack di interi analogici

Analogici di tipo reale:

AVERAGE	Media mobile su N campioni

HYSTER	Isteresi booleana su differenza di dati di tipo reale

LIM_ALRM	Allarme di limite superiore/inferiore con isteresi

INTEGRAL	Integrazione rispetto al tempo

DERIVATE	Derivazione rispetto al tempo

Generatore di segnali:

BLINK	Segnale booleano intermittente

SIG_GEN	Generatore di segnale

Nota: Nuovi blocchi funzione creati in "C", possono essere richiamati dal linguaggio FBD.


SR

Argomenti:

SET1	BOO	se TRUE, imposta Q1 a TRUE (dominante)

RESET	BOO	se TRUE, imposta Q1 a FALSE

Q1	BOO	memoria di stato booleano

Descrizione:

Bistabile con set dominante: Si veda la seguente "tavola di verità":

Set1 	Reset	Q1	risultato 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

(* Programma FBD che fa uso di un blocco di tipo "SR" *)

(* Equivalente ST: Si assuma SR1 istanza del blocco SR *)

SR1((auto_mode & start_cmd), stop_cmd);

command := SR1.Q1;

(* Equivalente IL: *)

LD	auto_mode

AND	start_cmd

ST	SR1.set1

LD	stop_cmd

ST	SR1.reset

CAL	SR1

LD	SR1.Q1

ST	command


RS

Argomenti:

SET	BOO	se TRUE, imposta Q1 a TRUE

RESET1	BOO	se TRUE, imposta Q1 a FALSE (dominante)

Q1	BOO	memoria di stato booleano

Descrizione:

Bistabile con reset dominante: Si veda la seguente "tavola di verità":

Set 	Reset1	Q1	risultato 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

(* Programma FBD che fa uso di un blocco di tipo "RS" block *)

(* Equivalente ST: Si assuma RS1 istanza del blocco RS*)

RS1(start_cmd, (stop_cmd OR alarm));

command := RS1.Q1;

(* Equivalente IL: *)

LD	start_cmd

ST	RS1.set

LD	stop_cmd

OR	alarm

ST	RS1.reset1

CAL	RS1

LD	RS1.Q1

ST	command


R_TRIG

Argomenti:

CLK	BOO	qualsiasi variabile booleana

Q	BOO	TRUE quando CLK sale da FALSE a TRUE

FALSE in tutti gli altri casi

Descrizione:

Rileva un fronte di salita di una variabile booleana

(* Programma FBD che fa uso di un blocco "R_TRIG" *)

(* Equivalente ST: Si assuma R_TRIG1 istanza del blocco R_TRIG *)

R_TRIG1(cmd);

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

(* Equivalente IL: *)

LD	cmd

ST	R_TRIG1.clk

CAL	R_TRIG1

LD	R_TRIG1.Q

ANA

ADD	nb_edge

ST	nb_edge


F_TRIG

Argomenti:

CLK	BOO	qualsiasi variabile booleana

Q	BOO	TRUE quando CLK cambia da TRUE a FALSE

FALSE in tutti gli altri casi

Descrizione:

Rileva un fronte di discesa di una variabile booleana

(* Programma FBD che fa uso di un blocco di tipo "F_TRIG" *)

(* Equivalente ST: Si assuma F_TRIG1 istanza del blocco F_TRIG *)

F_TRIG1(cmd);

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

(* Equivalente IL: *)

LD	cmd

ST	F_TRIG1.clk

CAL	F_TRIG1

LD	F_TRIG1.Q

ANA

ADD	nb_edge

ST	nb_edge


SEMA

Argomenti:

CLAIM	BOOLEAN	comando di "controllo ed impostazione"

RELEASE	BOOLEAN	rilascia il semaforo

BUSY	BOOLEAN	stato del semaforo

Descrizione:

(* "x" è una variabile booleana inizializzata a FALSE *)

busy := x;

If claim Then

x := True;

Else

If release Then

busy := False;

x := False;

End_if;

End_if;


CTU

Argomenti:

CU	BOO	input del contatore (il conteggio avviene quando CU vale TRUE)

RESET	BOO	comando di reset (dominante)

PV	INT	valore massimo programmato

Q	BOO	overflow: TRUE quando CV = PV

CV	INT	valore del contatore

Avvertenza: Il blocco CTU non rileva fronti di salita o di caduta dell'input del contatore (CU). Per ottenere un contatore ad impulso, si deve associare un blocco di tipo "R_TRIG" o "F_TRIG".

Descrizione:

Conteggio (intero) da 0 fino ad un dato valore ad incrementi di uno

(* Programma FBD che fa uso di un blocco di tipo "CTU" block *)

(* Equivalente ST: Si assuma R_TRIG1 istanza del blocco R_TRIG e CTU1 istanza del CTU *)

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

overflow := CTU1.Q;

result := CTU1.CV;

(* Equivalente IL: *)

LD	command

ST	R_TRIG1.clk

CAL	R_TRIG1

LD	R_TRIG1.Q

ST	CTU1.cu

LDN	auto_mode

ST	CTU1.reset

LD	100

ST	CTU1.pv

CAL	CTU1

LD	CTU1.Q

ST	overflow

LD	CTU1.cv

ST	result


CTD

Argomenti:

CD	BOO	input del contatore

(il conteggio a ritroso avviene quando CD vale TRUE)

LOAD	BOO	comando di caricamento  (dominante)

(CV = PV quando LOAD vale TRUE)

PV	INT	valore iniziale programmato

Q	BOO	underflow: TRUE quando CV = 0

CV	INT	valore del contatore

Avvertenza: Il blocco CTD non rileva fronti di salita o di caduta dell'input del contatore (CD). Per ottenere un contatore ad impulso, si deve associare un blocco di tipo "R_TRIG" o "F_TRIG".

Descrizione:

Conteggio (intero) da un dato valore fino a zero a decrementi di 1

(* Programma FBD che fa uso di un blocco di tipo "CTD" *)

(* Equivalente ST: Si assuma F_TRIG1 istanza del blocco F_TRIG e CTD1 istanza del blocco CTD *)

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

underflow := CTD1.Q;

result := CTD1.CV;

(* Equivalente IL: *)

LD	command

ST	F_TRIG1.clk

CAL	F_TRIG1

LD	F_TRIG1.Q

ST	CTD1.cd

LD	load_cmd

ST	CTD1.load

LD	100

ST	CTD1.pv

CAL	CTD1

LD	CTD1.Q

ST	underflow

LD	CTD1.cv

ST	result


CTUD

Argomenti:

CU	BOO	contatore a salire (quando CU vale TRUE)

CD	BOO	contatore a scendere (quando CD vale TRUE)

RESET	BOO	comando di reset (dominante)

(CV = 0 quando RESET vale TRUE)

LOAD	BOO	comando di caricamento (CV = PV quando LOAD vale TRUE)

PV	INT	valore massimo programmato

QU	BOO	overflow: TRUE quando CV = PV

QD	BOO	underflow: TRUE quando CV = 0

CV	INT	valore del contatore

Avvertenza: Il blocco CTUD non rileva fronti di salita o di caduta degli input del contatore (CU e CD). Per ottenere un contatore ad impulso, si deve associare un blocco di tipo "R_TRIG" o "F_TRIG".

Descrizione:

Conteggio (intero) da 0 fino ad un dato valore ad incrementi di 1

o da un dato valore fino a 0 a decrementi di 1

(* Programma FBD che fa uso di un blocco di tipo "CTUD" *)

(* Equivalente ST: Si assumano R_TRIG1 e R_TRIG2 due istanze del blocco R_TRIG e CTUD1 istanza del blocco 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;

(* Equivalente IL: *)

LD	add_elt

ST	R_TRIG1.clk

CAL	R_TRIG1

LD	R_TRIG1.Q

ST	CTUD1.cu

LD	sub_elt

ST	R_TRIG2.clk

CAL	R_TRIG2

LD	R_TRIG2.Q

ST	CTUD1.cd

LD	reset_cmd

ST	CTUD1.reset

LD	load_cmd

ST	CTUD1.load

LD	100

ST	CTUD1.pv

CAL	CTUD1

LD	CTUD1.QU

ST	full

LD	CTUD1.QD

ST	empty

LD	CTUD1.CV

ST	nb_elt


TON

Argomenti:

IN	BOO	Se fronte di salita, inizia ad incrementare un timer interno

Se fronte di discesa, ferma ed azzera il timer interno

PT	TMR	massimo tempo programmato

Q	BOO	Se TRUE, il tempo programmato è trascorso

ET	TMR	tempo attualmente trascorso

Descrizione:

Incrementa un timer interno fino ad un dato valore.

Diagramma del tempo:


TOF

Argomenti:

IN	BOO	Se fronte di discesa, inizia ad incrementare un timer interno

Se fronte di salita ferma ed azzera il timer interno

PT	TMR	massimo tempo programmato

Q	BOO	Se TRUE, il tempo programmato non è trascorso

ET	TMR	tempo attualmente trascorso

Descrizione:

Incrementa un timer interno fino ad un dato valore.

Diagramma del tempo:


TP

Argomenti:

IN	BOO	Se fronte di salita, inizia l'incremento di un timer interno (se non viene già attualmente incrementato)

Se FALSE e solamente se il tempo è trascorso, azzera il timer interno

I cambiamenti di IN durante il conteggio, non producono alcun effetto.

PT	TMR	massimo tempo programmato

Q	BOO	Se TRUE: il timer è attivo (sta contando)

ET	TMR	tempo attualmente trascorso

Descrizione:

Incrementa un timer interno fino ad un dato valore.

Diagramma del tempo:


CMP

Argomenti:

VAL1	INT	qualsiasi valore analogico intero con segno

VAL2	INT	qualsiasi valore analogico intero con segno

LT	BOO	TRUE se val1 è Minore di val2

EQ	BOO	TRUE se val1 è Uguale a val2

GT	BOO	TRUE se val1 è Maggiore di val2

Descrizione:

Confronta due valori: riporta se sono uguali, o se il primo è minore o maggiore del secondo.

(* Programma FBD che fa uso di un blocco di tipo "CMP" *)

(* Equivalente ST: Si assuma CMP1 istanza del blocco CMP *)

CMP1(level, max_level);

pump_cmd := CMP1.LT OR CMP1.EQ;

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

(* Equivalente IL: *)

LD	level

ST	CMP1.val1

LD	max_level

ST	CMP1.val2

CAL	CMP1

LD	CMP1.LT

OR	CMP1.EQ

ST	pump_cmd

LD	CMP1.GT

ANDN	manual_mode

ST	alarm


STACKINT

Argomenti:

PUSH	BOO	comando push (solamente per fronti in salita)

aggiunge il valore IN sullo stack

POP	BOO	comando pop (solamente per fronti in salita)

elimina dallo stack l'ultimo valore inserito (in cima allo stack)

R1	BOO	svuota lo stack

IN	INT	valore inserito

N	INT	dimensione dello stack definita dall'applicazione

EMPTY	BOO	TRUE se lo stack è vuoto

OFLO	BOO	overflow: TRUE se lo stack è pieno

OUT	INT	valore in cima allo stack

Descrizione:

Gestione di uno stack di valori interi.

Il blocco funzione "STACKINT" comprende la rilevazione di un fronte di salita per entrambi i comandi PUSH e POP. La dimensione massima dello stack è 128. La dimensione N dello stack definita dall'applicazione non può essere inferiore ad 1 o superiore a 128.

Si noti che il valore OFLO è valido solamente dopo un reset (R1 è stato impostato a TRUE almeno una volta e poi di nuovo a FALSE).

(* Programma FBD che fa uso di un blocco di tipo "STACKINT": gestione dell'errore *)

(* Equivalente ST: Si assuma STACKINT1 istanza del blocco 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;

(* Equivalente IL: *)

LD	err_detect

ST	STACKINT1.push

LD	acknoledge

ST	STACKINT1.pop

LD	manual_mode

ST	STACKINT1.r1

LD	err_code

ST	STACKINT1.IN

LD	max_err

ST	STACKINT1.N

CAL	STACKINT1

LD	auto_mode

ANDN	STACKINT1.empty

ST	appli_alarm

LD	STACKINT1.OFLO

ST	err_alarm

LD	STACKINT1.OUT

ST	last_error


AVERAGE

Argomenti:

RUN	BOO	TRUE=esecuzione / FALSE=reset

XIN	REALE	qualsiasi variabile reale analogica

N	INT	Numero di campioni definito dall'applicazione

XOUT	REALE	Media mobile del valore XIN

Descrizione:

Memorizza un valore ad ogni ciclo e calcola il valore tra tutti i valori precedentemente memorizzati. Vengono memorizzati solamente gli ultimi N valori.

Il numero N di campioni non può eccedere 128.

Quando il comando "RUN" vale FALSE (modo reset), il valore in output è uguale al valore in input.

Quando viene raggiunto il massimo N di valori memorizzati, il primo di questi viene sovrascritto dall'ultimo entrato.

(* Programma FBD che fa uso di un blocco di tipo "AVERAGE": *)

(* Equivalente ST: AVERAGE1 istanza del blocco AVERAGE*)

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

ave_value := AVERAGE1.XOUT;

(* Equivalente IL: *)

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

Argomenti:

XIN1	REALE	qualsiasi valore reale analogico

XIN2	REALE	per controllare se XIN1 abbia oltrepassato XIN2+EPS

EPS	REALE	valore di isteresi (deve essere maggiore di zero)

Q	BOO	TRUE se XIN1 ha oltrepassato XIN2+EPS e non è ancora inferiore a XIN2-EPS

Descrizione:

Isteresi con limite superiore su un valore reale.

Esempio del diagramma del tempo:


LIM_ALRM

Argomenti:

H	REALE	limite alto

X	REALE	input: qualsiasi valore reale analogico

L	REALE	limite basso

EPS	REALE	valore di isteresi (deve essere maggiore di zero)

QH	BOO	allarme "alto": TRUE se X sopra il limite alto H

Q	BOO	allarme output: TRUE se X fuori dai limiti

QL	BOO	allarme "basso": TRUE se X sotto il limite basso L

Descrizione:

Isteresi con limite superiore/inferiore su un valore reale.

Isteresi applicata su limiti inferiore/superiore. Il valore delta usato sia per il limite superiore che inferiore vale la metà del parametro EPS. Segue un esempio del diagramma del tempo:


INTEGRAL

Argomenti:

RUN	BOO	modo: TRUE=integrate / FALSE=hold

R1	BOO	reset dominante

XIN	REALE	ingresso: qualsiasi valore analogico reale

X0	REALE	valore iniziale

CYCLE	TMR	periodo di campionamento

Q	BOO	Not R1

XOUT	REALE	uscita dell'integrale

Descrizione:

Integrazione di un valore reale.

Se il valore del parametro "CYCLE" è inferiore al tempo ciclo dell'applicazione ISaGRAF, il periodo di campionamento equivale al tempo ciclo dell'applicazione.

(* Programma FBD che fa uso di un blocco di tipo "INTEGRAL" *)

(* Equivalente ST: INTEGRAL1 istanza del blocco INTEGRAL *)

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

controlled_value := INTEGRAL1.XOUT;

(* Equivalente IL: *)

LD	manual_mode

ST	INTEGRAL1.run

STN	INTEGRAL1.R1

LD	sensor_value

ST	INTEGRAL1.XIN

LD	init_value

ST	INTEGRAL1.X0

LD	t#100ms

ST	INTEGRAL1.CYCLE

CAL	INTEGRAL1

LD	INTEGRAL1.XOUT

ST	controlled_value


DERIVATE

Argomenti:

RUN	BOO	modo: TRUE=normale / FALSE=reset

XIN	REALE	ingresso: qualsiasi valore analogico reale

CYCLE	TMR	periodo di campionamento

XOUT	REALE	uscita della derivata

Descrizione:

Derivazione di un valore reale.

Se il valore del parametro "CYCLE" è inferiore al tempo ciclo dell'applicazione ISaGRAF, il periodo di campionamento equivale al tempo ciclo dell'applicazione.

(* Programma FBD che fa uso di un blocco di tipo "DERIVATE" *)

(* Equivalente ST: DERIVATE1 istanza del blocco DERIVATE *)

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

derivated_value := DERIVATE1.XOUT;

(* Equivalente IL: *)

LD	manual_mode

ST	DERIVATE1.run

LD	sensor_value

ST	DERIVATE1.XIN

LD	t#100ms

ST	DERIVATE1.CYCLE

CAL	DERIVATE1

LD	DERIVATE1.XOUT

ST	derivated_value


BLINK

Argomenti:

RUN	BOO	modo: TRUE=intermittenza / FALSE=imposta output a false

CYCLE	TMR	periodo intermittenza

Q	BOO	output segnale intermittente

Descrizione:

Genera un segnale intermittente.

Diagramma del tempo:


SIG_GEN

Argomenti:

RUN	BOO	modo: TRUE=attivo / FALSE=reset a false

PERIOD	TMR	durata di un campione

MAXIMUM	INT	valore massimo del contatore

PULSE	BOO	inversione dopo ogni campione

UP	INT	contatore ad incremento, incrementato dopo ogni campione

END	BOO	TRUE al termine del conteggio incrementale

SINE	REALE	segnale sinusoidale (periodo = durata conteggio)

Descrizione:

Genera l'intermittenza di vari segnali su un valore booleano, un contatore intero ad incremento, un'onda sinusoidale reale.

Quando il contatore raggiunge il valore massimo, riparte da 0 (zero). Così END assume il valore TRUE solamente per la durata di 1 PERIOD.

Diagramma del tempo:


Funzioni standard

Queste sono le funzioni standard incorporate dal sistema ISaGRAF. Queste funzioni sono predefinite e non devono essere dichiarate nella libreria.

Matematiche:

ABS	Valore assoluto

EXPT	Calcolo di esponente

LOG	Logaritmo

POW	Elevazione a potenza

SQRT	Radice quadrata

TRUNC	Troncamento della parte decimale

Trigonometriche:

ACOS	Arco coseno

ASIN	Arco seno

ATAN	Arco tangente

COS	Coseno

SIN	Seno

TAN	Tangente

Controllo registri:

ROL	Rotazione a sinistra

ROR	Rotazione a destra

SHL	Shift a sinistra

SHR	Shift a destra

Manipolazione dati:

MIN	Minimo

MAX	Massimo

LIMIT	Limite

MOD	Modulo

MUX4	Multiplexer (4 ingressi)

MUX8	Multiplexer (8 ingressi)

ODD	Odd parity (parità dispari)

RAND	Valore random (casuale)

SEL	Selettore binario

Conversione dati:

ASCII	Carattere  Codice ASCII

CHAR	Codice ASCII  Carattere

Gestione stringhe:

DELETE	Cancellazione sottostringa

INSERT	Inserimento stringa

FIND	Ricerca sottostringa

MLEN	Lunghezza stringa

LEFT	Estrazione della parte sinistra

MID	Estrazione della parte centrale

REPLACE	Sostituzione sottostringa

RIGHT	Estrazione della parte destra

DAY_TIME	Tempo del giorno

Operazioni su Array:

ARCREATE	Creazione di array (matrici) di valori interi

ARREAD	Lettura elemento di array

ARWRITE	Scrittura elemento di array

Gestione file di tipo binario:

F_ROPEN	Apertura file binario in modo Lettura

F_WOPEN	Apertura file binario in modo Scrittura

F_CLOSE	Chiusura file binario

F_EOF	Controllo raggiungimento fine file binario

FA_READ	Lettura di un valore analogico da file binario

FA_WRITE	Scrittura di un valore analogico in un file binario

FM_READ	Lettura di un messaggio stringa da file binario

FM_WRITE	Scrittura di un messaggio stringa in file binario


ABS

Argomenti:

IN	REALE	qualsiasi valore analogico reale con segno

Q	REALE	valore assoluto (sempre positivo)

Descrizione:

Restituisce il valore assoluto (positivo) di un valore reale.

(* Programma FBD che fa uso di un blocco di tipo "ABS" *)

(* Equivalente ST: *)

over := (ABS (delta) > range);

(* Equivalente IL: *)

LD	delta

ABS

GT 	range

ST	over


EXPT

Argomenti:

IN	REALE	qualsiasi valore analogico reale con segno

EXP	INT	esponente intero analogico

Q	REALE	(IN EXP)

Descrizione:

Restituisce il risultato reale dell'operazione: (Base Esponente) con base 'Base' corrispondente al primo argomento ed 'Esponente' al secondo.

(* Programma FBD che fa uso di un blocco di tipo "EXPT" *)

(* Equivalente ST: *)

tb_size := ANA (EXPT (2.0, range) );

(* Equivalente IL: *)

LD	2.0

EXPT	range

ANA

ST	tb_size


LOG

Argomenti:

IN	REALE	deve essere maggiore di zero

Q	REALE	logaritmo (in base 10) del valore di input

Descrizione:

Calcola il logaritmo (in base 10) di un valore reale.

(* Programma FBD che fa uso di un blocco di tipo "LOG" *)

(* Equivalente ST: *)

xpos := ABS (xval);

xlog := LOG (xpos);

(* Equivalente IL: *)

LD	xval

ABS

ST	xpos

LOG

ST	xlog


POW

Argomenti:

IN	REALE	numero reale analogico da elevare

EXP	REALE	potenza (esponente)

Q	REALE	(IN EXP)

1.0 se IN è non 0.0 ed EXP è 0.0

0.0 se IN è 0.0 ed EXP è negativo

0.0 se entrambi IN e EXP sono 0.0

0.0 se IN è negativo e Y non corrisponde ad un intero

Descrizione:

Restituisce il risultato reale dell'operazione: (Base Esponente) con 'Base' corrispondente al primo argomento ed 'Esponente' al secondo.

(* Programma FBD che fa uso di un blocco di tipo "POW" *)

(* Equivalente ST: *)

result := POW (xval, power);

(* Equivalente IL: *)

LD	xval

POW	power

ST	result


SQRT

Argomenti:

IN	REALE	deve essere maggiore od uguale a zero

Q	REALE	radice quadrata del valore in input

Descrizione:

Calcola la radice quadrata di un valore reale.

(* Programma FBD che fa uso di un blocco di tipo "SQRT" *)

(* Equivalente ST: *)

xpos := ABS (xval);

xroot := SQRT (xpos);

(* Equivalente IL: *)

LD	xval

ABS

ST	xpos

SQRT

ST	xrout


TRUNC

Argomenti:

IN	REALE	qualsiasi valore analogico reale

Q	REALE	se IN>0, il più grande intero minore o uguale dell'input

se IN<0, il più piccolo intero maggiore o uguale dell'input

Descrizione:

Tronca un valore reale restituendo la sola parte intera

(* Programma FBD che fa uso di un blocco di tipo "TRUNC" *)

(* Equivalente ST: *)

result := TRUNC (+2.67) + TRUNC (-2.0891);

(* significa: result := 2.0 + (-2.0) := 0.0; *)

(* Equivalente IL: *)

LD	2.67

TRUNC

ST	temporary	(* risultato temporaneo del primo TRUNC *)

LD	-2.0891

TRUNC

ADD	temporary

ST	result


ACOS

Argomenti:

IN	REALE	deve essere compreso tra [-1.0 .. +1.0]

Q	REALE	arco coseno del valore in input (compreso tra [0.0 .. PI])

= 0.0 per input non valido

Descrizione:

Calcola l'arco coseno di un valore reale.

(* Programma FBD che fa uso di un blocco di tipo "COS" e "ACOS" *)

(* Equivalente ST: *)

cosine := COS (angle);

result := ACOS (cosine); (* result equivale all'angolo *)

(* Equivalente IL: *)

LD	angle

COS

ST	cosine

ACOS

ST	result


ASIN

Argomenti:

IN	REALE	deve essere compreso tra [-1.0 .. +1.0]

Q	REALE	arco seno del valore in input (compreso tra [-PI/2 .. +PI/2])

= 0.0 per input non valido

Descrizione:

Calcola l'arco seno di un valore reale.

(* Programma FBD che fa uso di un blocco di tipo "SIN" e "ASIN" *)

(* Equivalente ST: *)

sine := SIN (angle);

result := ASIN (sine); (* result equivale all'angolo *)

(* Equivalente IL: *)

LD	angle

SIN

ST	sine

ASIN

ST	result


ATAN

Argomenti:

IN	REALE	qualsiasi valore analogico reale

Q	REALE	arco tangente del valore in input (compreso tra [-PI/2 .. +PI/2])

= 0.0 per input non valido

Descrizione:

Calcola l'arco tangente di un valore reale.

(* Programma FBD che fa uso di un blocco di tipo "TAN" e "ATAN" *)

(* Equivalente ST: *)

tangent := TAN (angle);

result := ATAN (tangent); (* result equivale all'angolo *)

(* Equivalente IL: *)

LD	angle

TAN

ST	tangent

ATAN

ST	result


COS

Argomenti:

IN	REALE	qualsiasi valore analogico reale

Q	REALE	coseno del valore in input (compreso tra [-1.0 .. +1.0])

Descrizione:

Calcola il Coseno di un valore reale.

(* Programma FBD che fa uso di un blocco di tipo "COS" e "ACOS" *)

(* Equivalente ST: *)

cosine := COS (angle);

result := ACOS (cosine); (* result equivale all'angolo *)

(* Equivalente IL: *)

LD	angle

COS

ST	cosine

ACOS

ST	result


SIN

Argomenti:

IN	REALE	qualsiasi valore analogico reale

Q	REALE	seno del valore in input (compreso tra [-1.0 .. +1.0])

Descrizione:

Calcola il Seno di un valore reale.

(* Programma FBD che fa uso di un blocco di tipo "SIN" e "ASIN" *)

(* Equivalente ST: *)

sine := SIN (angle);

result := ASIN (sine); (* result equivale all'angolo *)

(* Equivalente IL: *)

LD	angle

SIN

ST	sine

ASIN

ST	result


TAN

Argomenti:

IN	REALE	non può essere uguale a PI/2 modulo PI

Q	REALE	tangente del valore in input

= 1E+38 per input non valido

Descrizione:

Calcola la Tangente di un valore reale.

(* Programma FBD che fa uso di un blocco di tipo "TAN" e "ATAN" *)

(* Equivalente ST: *)

tangent := TAN (angle);

result := ATAN (tangent); (* result equivale all'angolo*)

(* Equivalente IL: *)

LD	angle

TAN

ST	tangent

ATAN

ST	result


ROL

Argomenti:

IN	INT	qualsiasi valore analogico intero

NbR	INT	numero di rotazioni di 1 bit (compreso tra [1..31])

Q	INT	valore dopo la rotazione a sinistra

nessun effetto se NbR <= 0

Descrizione:

Esegue la rotazione a sinistra dei bit di un intero. La rotazione viene eseguita su 32 bit:

(* Programma FBD che fa uso di un blocco di tipo "ROL" *)

(* Equivalente ST: *)

result := ROL (register, 1);

(* register = 2#0100_1101_0011_0101*)

(* result    = 2#1001_1010_0110_1010*)

(* Equivalente IL: *)

LD	register

ROL	1

ST	result


ROR

Argomenti:

IN	INT	qualsiasi valore analogico intero

NbR	INT	numero di rotazioni di 1 bit (compreso tra [1..31])

Q	INT	valore dopo la rotazione a destra

nessun effetto se NbR <= 0

Descrizione:

Esegue la rotazione a destra dei bit di un intero. La rotazione viene eseguita su 32 bit:

(* Programma FBD che fa uso di un blocco di tipo "ROR" *)

(* Equivalente ST: *)

result := ROR (register, 1);

(* register = 2#0100_1101_0011_0101 *)

(* result    = 2#1010_0110_1001_1010 *)

(* Equivalente IL: *)

LD	register

ROR	1

ST	result


SHL

Argomenti:

IN	INT	qualsiasi valore analogico intero

NbS	INT	numero di spostamenti di 1 bit (compreso tra [1..31])

Q	INT	valore dopo lo shift a sinistra

nessun effetto se NbS <= 0

il bit più basso viene sostituito da 0

Descrizione:

Esegue lo shift (spostamento) a sinistra dei bit di un intero. Lo shift viene eseguito su 32 bit:

(* Programma FBD che fa uso di un blocco di tipo "SHL" *)

(* Equivalente ST: *)

result := SHL (register,1);

(* register = 2#0100_1101_0011_0101 *)

(* result    = 2#1001_1010_0110_1010 *)

(* Equivalente IL: *)

LD	register

SHL	1

ST	result


SHR

Argomenti:

IN	INT	qualsiasi valore analogico intero

NbS	INT	numero di spostamenti di 1 bit (compreso tra [1..31])

Q	INT	valore dopo lo shift a destra

nessun effetto se NbS <= 0

il bit più alto viene copiato ad ogni shift

Descrizione:

Esegue lo shift (spostamento) a destra dei bit di un intero. Lo shift viene eseguito su 32 bit:

(* Programma FBD che fa uso di un blocco di tipo "SHR" *)

(* Equivalente ST: *)

result := SHR (register,1);

(* register = 2#1100_1101_0011_0101 *)

(* result    = 2#1110_0110_1001_1010 *)

(* Equivalente IL: *)

LD	register

SHR	1

ST	result


MIN

Argomenti:

IN1	INT	qualsiasi valore analogico intero con segno

IN2	INT	(non può essere REALE)

Q	INT	il minimo di entrambi i valori di input

Descrizione:

Restituisce il minimo di due valori interi.

(* Programma FBD che fa uso di un blocco di tipo "MIN" e "MAX" *)

(* Equivalente ST: *)

new_value := MAX (MIN (max_value, value), min_value);

(* arrotonda il valore all'insieme [min_value..max_value] *)

(* Equivalente IL: *)

LD	max_value

MIN	value

MAX	min_value

ST	new_value


MAX

Argomenti:

IN1	INT	qualsiasi valore analogico intero con segno

IN2	INT	(non può essere REALE)

Q	INT	il massimo di entrambi i valori di input

Descrizione:

Restituisce il massimo di due valori interi.

(* Programma FBD che fa uso di un blocco di tipo "MIN" e "MAX" *)

(* Equivalente ST: *)

new_value := MAX (MIN (max_value, value), min_value);

(* arrotonda il valore all'insieme [min_value..max_value] *)

(* Equivalente IL: *)

LD	max_value

MIN	value

MAX	min_value

ST	new_value


LIMIT

Argomenti:

MIN	INT	valore minimo consentito

IN	INT	qualsiasi valore analogico intero con segno

MAX	INT	valore massimo consentito

Q	INT	il valore di input arrotondato all'intervallo consentito

Descrizione:

Limita un valore intero all'interno di un dato intervallo. Mantiene lo stesso valore se è compreso tra massimo e minimo, assume il valore massimo se è superiore, assume il minimo se inferiore.

(* Programma FBD che fa uso di un blocco di tipo "LIMIT" *)

(* Equivalente ST: *)

new_value := LIMIT (min_value, value, max_value);

(* arrotonda il valore all'insieme [min_value..max_value] *)

(* Equivalente IL: *)

LD	min_value

LIMIT	value, max_value

ST	new_value


MOD

Argomenti:

IN	INT	qualsiasi valore analogico INTERO

Base	INT	deve essere maggiore di zero

Q	INT	calcolo del modulo (input MOD base)

restituisce -1 se Base <= 0

Descrizione:

Calcola il modulo di un valore intero.

(* Programma FBD che fa uso di un blocco di tipo "MOD" *)

(* Equivalente ST: *)

division_result := (value / divider); (* divisione intera *)

rest_of_division := MOD (value, divider); (* resto della divisione *)

(* Equivalente IL: *)

LD	value

DIV	divider

ST	division_result

LD	value

MOD	divider

ST	rest_of_division


MUX4

Argomenti:

SEL	INT	valore intero del selettore (deve essere compreso tra [0..3])

IN1..IN4	INT	qualsiasi valore analogico intero

Q	INT	= valore1 se SEL = 0

= valore2 se SEL = 1

= valore3 se SEL = 2

= valore4 se SEL = 3

= 0 per tutti gli altri valori del selettore

Descrizione:

Multiplexer a 4 entrate: seleziona un valore tra 4 valori interi.

(* Programma FBD che fa uso di un blocco di tipo "MUX4" *)

(* Equivalente ST: *)

range := MUX4 (choice, 1, 10, 100, 1000);

(* seleziona a partire da 4 intervalli predefiniti, ad esempio se la scelta è 1, l'intervallo sarà 10 *)

(* Equivalente IL: *)

LD	choice

MUX4	1,10,100,1000

ST	range


MUX8

Argomenti:

SEL	INT	valore intero del selettore (deve essere compreso tra [0..7])

IN1..IN8	INT	qualsiasi valore analogico intero

Q	INT	= valore1 se SEL = 0

= valore2 se SEL = 1

...

= valore8 se SEL = 7

= 0 per tutti gli altri valori del selettore

Descrizione:

Multiplexer a 8 entrate: seleziona un valore tra 8 valori interi.

(* Programma FBD che fa uso di un blocco di tipo "MUX8" *)

(* Equivalente ST: *)

range := MUX8 (choice, 1, 5, 10, 50, 100, 500, 1000, 5000);

(* seleziona a partire da 8 intervalli predefiniti, ad esempio se la scelta è 3, l'intervallo sarà 50 *)

(* Equivalente IL: *)

LD	choice

MUX8	1,5,10,50,100,500,1000,5000

ST	range


ODD

Argomenti:

IN	INT	qualsiasi valore analogico intero con segno

Q	BOO	TRUE se il valore di input è dispari

FALSE se il valore di input è pari

Descrizione:

Valuta la parità di un intero: il risultato è dispari o pari.

(* Programma FBD che fa uso di un blocco di tipo "ODD" *)

(* Equivalente ST: *)

If Not (ODD (value)) Then Return; End_if;

value := value + 1;

(* forza il valore ad essere sempre pari *)

(* Equivalente IL: *)

LD	value

ODD

RETNC

LD	value

ADD	1

ST	value


RAND

Argomenti:

base	INT	definisce un insieme di numeri permessi

Q	INT	valore casuale (random) compreso nell'insieme [0..base-1]

Descrizione:

Restituisce un valore intero casuale (random) compreso nell'intervallo dato.

(* Programma FBD che fa uso di un blocco di tipo "RAND" *)

(* Equivalente ST: *)

selected := MUX4 ( RAND (4), 1, 4, 8, 16 );

(*

selezione casuale di 1 di 4 valori predefiniti

il valore uscente dalla chiamata a RAND è compreso nell'insieme [0..3],

così 'selected' restituito da MUX4, avrà valore 'casuale'

1 se 0 viene restituito da RAND,

o 4 se 1 viene restituito da RAND,

o 8 se 2 viene restituito da RAND,

o 16 se 3 viene restituito da RAND,

*)

(* Equivalente IL: *)

LD	4

RAND

MUX4	1,4,8,16

ST	selected


SEL

Argomenti:

SEL	BOO	indica il valore scelto

IN1, IN2	INT	qualsiasi valore intero analogico

Q	INT	= valore1 se SEL vale FALSE

= valore2 se SEL vale TRUE

Descrizione:

Selettore binario: seleziona un valore tra due valori interi.

(* Programma FBD che fa uso di un blocco di tipo "SEL" *)

(* Equivalente ST: *)

ProCmd := SEL (AutoMode, ManuCmd, InpCmd);

(* processa il comando di selezione *)

(* Equivalente IL: *)

LD	AutoMode

SEL	ManuCmd,InpCmd

ST	ProCmd


ASCII

Argomenti:

IN	MSG	qualsiasi stinga non nulla

Pos	INT	posizione del carattere voluto

compresa tra [1.. len] (dove len corrisponde alla lunghezza del messaggio IN)

Code	INT	codice del carattere voluto

(compreso tra [0 .. 255])

restituisce 0 se Pos è esterna alla stringa

Descrizione:

Restituisce il codice ASCII di un carattere di una stringa messaggio.

(* Programma FBD che fa uso di un blocco di tipo "ASCII" *)

(* Equivalente ST: *)

FirstChr := ASCII (message, 1);

(* FirstChr è il codice Ascii del primo carattere della stringa *)

(* Equivalente IL: *)

LD	message

ASCII	1

ST	FirstChr


CHAR

Argomenti:

Code	INT	codice compreso nell'insieme [0 .. 255]

Q	MSG	stringa di un carattere

il carattere ha il codice ASCII equivalente al codice di input

(il codice ASCII viene usato modulo 256)

Descrizione:

Restituisce un stringa messaggio composta da un carattere a partire da un dato codice ASCII.

(* Programma FBD che fa uso di un blocco di tipo "CHAR" *)

(* Equivalente ST: *)

Display := CHAR ( value + 48 );

(* il valore appartiene all'insieme [0..9] *)

(* 48 è il codice ascii per '0' *)

(* il risultato è costituito da una stringa di un carattere da '0' a '9' *)

(* Equivalente IL: *)

LD	value

ADD	48

CHAR

ST	Display


DELETE

Argomenti:

IN	MSG	qualsiasi messaggio non vuoto

NbC	INT	numero di caratteri da cancellare

Pos	INT	posizione del primo carattere da cancellare

(il primo carattere della stringa ha posizione 1)

Q	MSG	stringa modificata

stringa vuota se Pos < 1

stringa iniziale se Pos > lunghezza della stringaIN

stringa iniziale se NbC <= 0

Descrizione:

Cancella una parte di una stringa messaggio.

(* Programma FBD che fa uso di un blocco di tipo "DELETE" *)

(* Equivalente ST: *)

complete_string := 'ABCD' + 'EFGH'; (* complete_string vale 'ABCDEFGH' *)

sub_string := DELETE (complete_string, 4, 3); (* sub_string vale 'ABGH' *)

(* Equivalente IL: *)

LD	'ABCD'

ADD	'EFGH'

ST	complete_string

DELETE	4,3

ST 	sub_string


INSERT

Argomenti:

IN	MSG	stringa iniziale

Str	MSG	stringa da inserire

Pos	INT	posizione per l'inserimento

l'inserimento avviene prima della posizione

(la prima posizione valida è 1)

Q	MSG	stringa modificata

stringa vuota se Pos <= 0

concatenazione delle due stringhe se Pos è maggiore della lunghezza della stringa IN

Descrizione:

Inserimento in una data posizione, di una sottostringa in una stringa messaggio.

(* Programma FBD che fa uso di un blocco di tipo "INSERT" *)

(* Equivalente ST: *)

MyName := INSERT ('Mr JONES', 'Frank ', 4);

(* la variabile MyName contiene 'Mr Frank JONES' *)

(* Equivalente IL: *)

LD	'Mr JONES'

INSERT	'Frank ',4

ST 	MyName


FIND

Argomenti:

In	MSG	qualsiasi stringa messaggio

Pat	MSG	qualsiasi stringa non vuota (Pattern)

Pos	INT	= 0 se sottostringa Pat non trovata

= posizione del primo carattere della prima occorrenza della sottostringa Pat

(la prima posizione equivale ad 1)

questa funzione è case sensitive (distingue tra maiuscole e minuscole)

Descrizione:

Cerca una sottostringa in una stringa messaggio. Restituisce la posizione della sottostringa nella stringa.

(* Programma FBD che fa uso di un blocco di tipo "FIND" *)

(* Equivalente ST: *)

complete_string := 'ABCD' + 'EFGH'; (* complete_string vale 'ABCDEFGH' *)

found := FIND (complete_string, 'CDEF'); (* la variabile found vale  3 *)

(* Equivalente IL: *)

LD	'ABCD'

ADD	'EFGH'

ST	complete_string

FIND	'CDEF'

ST 	found


MLEN

Argomenti:

IN	MSG	qualsiasi stringa messaggio

NbC	INT	numero di caratteri della stringa IN

Descrizione:

Calcola la lunghezza di una stringa messaggio.

(* Programma FBD che fa uso di un blocco di tipo "MLEN" *)

(* Equivalente ST: *)

nbchar := MLEN (complete_string);

If (nbchar < 3) Then Return; End_if;

prefix := LEFT (complete_string, 3);

(* questo programma estrae i 3 caratteri alla sinistra della stringa ed assegna risultato alla variabile messaggio prefix

non viene compiuta alcuna operazione se la lunghezza della stringa è inferiore ai 3 caratteri *)

(* Equivalente IL: *)

LD	complete_string

MLEN

ST	nbchar

LT	3

RETC

LD	complete_string

LEFT	3

ST	prefix


LEFT

Argomenti:

IN	MSG	Qualsiasi stringa non vuota

NbC	INT	Numero di caratteri da estrarre

non può essere superiore alla lunghezza della stringa IN

Q	MSG	la parte a sinistra della stringa IN (con lunghezza = NbC)

stringa vuota se NbC <= 0

la stringa IN completa nel caso NbC >= lunghezza stringa IN

Descrizione:

Estrazione della parte sinistra di una stringa messaggio, dato il numero di caratteri da estrarre.

(* Programma FBD che fa uso di un blocco di tipo "LEFT" e "RIGHT" *)

(* Equivalente ST: *)

complete_string := RIGHT ('12345678', 4) + LEFT ('12345678', 4);

(* complete_string vale '56781234'

il valore risultante dalla chiamata a RIGHT è '5678'

il valore risultante dalla chiamata a LEFT è '1234'*)

(* Equivalente IL: viene chiamato per primo LEFT *)

LD	'12345678'

LEFT	4

ST	sub_string 	(* risultato intermedio *)

LD	'12345678'

RIGHT	4

ADD	sub_string

ST 	complete_string


MID

Argomenti:

IN	MSG	qualsiasi stringa non vuota

NbC	INT	Numero di caratteri da estrarre

non può essere superiore alla lunghezza della stringa IN

Pos	INT	posizione della sottostringa

il primo carattere della sottostringa è quello cui si riferisce Pos (la prima posizione valida è 1)

Q	MSG	una parte contenuta nella stringa (con lunghezza = NbC)

stringa vuota se parametri non corretti

Descrizione:

Estrazione di una parte di una stringa messaggio, dati il numero di caratteri da estrarre e la posizione del primo carattere.

(* Programma FBD che fa uso di un blocco di tipo "MID" *)

(* Equivalente ST: *)

sub_string := MID ('abcdefgh', 2, 4);

(* sub_string vale 'de' *)

(* Equivalente IL: *)

LD	'abcdefgh'

MID	2,4

ST	sub_string


REPLACE

Argomenti:

IN	MSG	qualsiasi stringa

Str	MSG	stringa da inserire (per sostituire NbC caratteri)

NbC	INT	numero di caratteri da cancellare

Pos	INT	posizione del primo carattere modificato

(la prima posizione valida è 1)

Q	MSG	stringa modificata:

- NbC caratteri vengono cancellati dalla posizione Pos

- la sottostringa Str viene inserita in questa posizione

restituisce una stringa vuota se Pos <= 0

restituisce la concatenazione delle stringhe (IN+Str) se Pos è maggiore della lunghezza della stringa IN

restituisce la stringa iniziale IN se NbC <= 0

Descrizione:

Sostituisce una parte di un messaggio con un nuovo insieme di caratteri.

(* Programma FBD che fa uso di un blocco di tipo "REPLACE" *)

(* Equivalente ST: *)

MyName := REPLACE ('Mr X JONES, 'Frank', 1, 4);

(* MyName vale 'Mr Frank JONES' *)

(* Equivalente IL: *)

LD	'Mr X JONES'

REPLACE	'Frank',1,4

ST	MyName


RIGHT

Argomenti:

IN	MSG	Qualsiasi stringa non vuota

NbC	INT	non può essere superiore alla lunghezza della stringa IN

Q	MSG	la parte a destra della stringa IN (con lunghezza = NbC))

stringa vuota se NbC <= 0

la stringa IN completa nel caso NbC >= lunghezza stringa IN

Descrizione:

Estrazione della parte destra di una stringa messaggio, dato il numero di caratteri da estrarre.

(* Programma FBD che fa uso di un blocco di tipo "LEFT" e "RIGHT" *)

(* Equivalente ST: *)

complete_string := RIGHT ('12345678', 4) + LEFT ('12345678', 4);

(* complete_string vale '56781234'

the value issued from RIGHT call is '5678'

the value issued from LEFT call is '1234'*)

(* IL Equivalence: First done is call to LEFT *)

LD	'12345678'

LEFT	4

ST	sub_string 	(* risultato intermedio *)

LD	'12345678'

RIGHT	4

ADD	sub_string

ST 	complete_string


DAY_TIME

Argomenti:

SEL	INT	selezione output

0 = data corrente

1 = orario corrente

2 = giorno della settimana

Q	MSG	orario/data espresso da una stringa di caratteri

'YYYY/MM/DD' se SEL = 0

'HH:MM:SS' se SEL = 1

nome del giorno se SEL = 2 (es: 'Lunedì')

Descrizione:

Restituisce la data o l'orario del giorno in formato stringa messaggio.

(* Programma FBD che fa uso di un blocco di tipo "DAY_TIME" *

(* Equivalente ST: *)

Display := Day_Time (0) + ' ; ' + Day_Time (1);

(* Il formato di visualizzazione del messaggio è: 'YYYY/MM/DD ; HH:MM:SS' *)

(* IL Equivalence: La prima chiamata è day_time(1) *)

LD	1

DAY_TIME

ST	hour_str 	(* risultato intermedio *)

LD	0

DAY_TIME

ADD	' ; '

ADD	hour_str

ST 	Display


ARCREATE

Argomenti:

ID	INT	Identificativo dell'array (deve essere compreso tra [0..15])

Size	INT	numero di elementi dell'array

ok	INT	resoconto dell'operazione:

1 = se l'array è stato creato

2 = identificativo dell'array errato o array già creato

3 = dimensione (size) dell'array non corretta

4 = memoria non sufficiente

Descrizione:

Creazione di un array di interi.

Avvertenza: In un'applicazione, sono disponibili al più 16 array. Gli array contengono valori interi analogici. Poiché l'allocazione della memoria avviene in modo dinamico, questa funzione può causare un errore di sistema qualora la dimensione dell'array sia prossima alla dimensione della memoria disponibile.

(* Programma FBD che crea un array di interi *)

(* Equivalente ST: *)

array_error := (ARCREATE (ident, 16) <> 1));

(* Equivalente IL: *)

LD	ident

ARCREATE	16

NE 	1

ST	array_error


ARREAD

Argomenti:

ID	INT	Identificativo dell'array (deve essere compreso tra [0..15])

Pos	INT	posizione dell'elemento nell'array

deve essere compreso tra [0 .. dimensione-1]

value	INT	valore dell'elemento letto

0 se gli argomenti non sono corretti

Descrizione:

Lettura di un elemento di un array di interi.

(* Programma FBD che fa uso della gestione di array *)

(* Equivalente ST: *)

If (array_error) Then Return; End_if;

read_value := ARREAD (ident, index);

(* array_error deriva da una chiamata a ARCREATE *)

(* Equivalente IL: *)

LD	array_error

RETC

LD	ident

ARREAD	index

ST	read_value


ARWRITE

Argomenti:

ID	INT	Identificativo dell'array (deve essere compreso tra [0..15])

Pos	INT	posizione dell'elemento nell'array

deve essere compreso tra [0 .. dimensione-1]

IN	INT	nuovo valore per l'elemento

ok	INT	resoconto dell'operazione

1 = scrittura avvenuta

2 = identificativo dell'array errato

3 = indice errato

Descrizione:

memorizza (scrive) un valore in un array di interi.

(* Programma FBD che fa uso della gestione di array *)

(* Equivalente ST: *)

If (array_error) Then Return; End_if;

write_status := ARWRITE (Ident, Index, value);

(*array_error deriva da una chiamata a ARCREATE *)

(* Equivalente IL: *)

LD	array_error

RETC

LD	ident

ARWRITE	index,value

ST	write_statu


F_ROPEN

Argomenti:

Path	MSG	nome file

Può includere il percorso (path) di accesso al file con i simboli \ o / per specificare una directory. Per facilitare la portabilità dell'applicazione, / o \ sono equivalenti.

ID	INT	numero file

0 se si è verificato un errore: il file non esiste.

Descrizione:

Apre in file binario in modo lettura, per l'uso con FX_READ e F_CLOSE.

Questa funzione non è inclusa nel simulatore ISaGRAF.

(* Programma FBD che fa uso della gestione file *)

(* Equivalente ST: *)

file_id := F_ROPEN('c:\data \data.bin');

error := (file_id=0);

(* Equivalente IL: *)

LD	'c:\data\data.bin'

F_ROPEN

ST	file_id

EQ	0

ST	error


F_WOPEN

Argomenti:

Path	MSG	nome file

Può includere il path (percorso) di accesso al file con i simboli \ o / per specificare una directory. Per facilitare la portabilità dell'applicazione, / o \ sono equivalenti.

ID	INT	numero file

0 se si è verificato un errore. Un eventuale file già esistente viene sovrascritto.

Descrizione:

Apre un file binario in modo scrittura, per l'uso con FX_WRITE e F_CLOSE.

Questa funzione non è inclusa nel simulatore ISaGRAF.

(* Programma FBD che fa uso della gestione file *)

(* Equivalente ST: *)

file_id := F_WOPEN('c:\data\data.bin');

error := (file_id=0);

(* Equivalente IL: *)

LD	'c:\data\data.bin'

F_WOPEN

ST	file_id

EQ	0

ST	error


F_CLOSE

Argomenti:

ID	INT	numero file: restituito da F_ROPEN o F_WOPEN.

ok	BOO	stato

TRUE se la chiusura del file è OK

FALSE se si è verificato un errore

Descrizione:

Chiude un file binario aperto con le funzioni F_ROPEN o F_WOPEN.

Questa funzione non è inclusa nel simulatore ISaGRAF.

(* Programma FBD che fa uso della gestione file *)

(* Equivalente ST: *)

file_id := F_ROPEN('data.bin');

ok := F_CLOSE(file_id);

(* Equivalente IL: *)

LD	'data.bin'

F_ROPEN

ST	file_id

F_CLOSE	(* file_id è già nel risultato corrente IL *)

ST 	ok


F_EOF

Argomenti:

ID	INT	numero file restituito da F_ROPEN o F_WOPEN.

ok	BOO	indicatore di fine file (end of file)

TRUE  se è stata raggiunta la fine del file nella precedente operazione di lettura o scrittura.

Con FM_READ, l'ultimo messaggio letto da un file potrebbe non essere corretto, qualora l'ultimo carattere non sia il terminatore di stringa.

Descrizione:

Controlla se sia stata raggiunta la fine del file.

Questa funzione non è inclusa nel simulatore ISaGRAF.

(* Programma FBD che fa uso della gestione file *)

(* Equivalente ST: *)

file_id := F_ROPEN('data.bin');

WHILE not(F_EOF(file_id))

VAL := FA_READ(file_id);

END_WHILE;

MESSAGE := 'last val = ' + msg(VAL);

ok := F_CLOSE(file_id);

(* Equivalente IL: *)

LD	'data.bin'

F_ROPEN

ST	file_id

LD 	file_id

F_EOF

JMPC	END_OF_FILE

NOT_EOF:	LD 	file_id

FA_READ

ST	VAL

LD 	file_id

F_EOF

JMPNC	NOT_EOF 	(* se non eof, continua la lettura *)

END_OF_FILE:	LD	VAL

MSG

ST	val_msg	(* conversione di VAL in messaggio *)

LD	'last val = '

ADD	val_msg

ST	MESSAGE

LD 	file_id

F_CLOSE

ST	ok


FA_READ

Argomenti:

ID	INT	numero file: restituito da F_ROPEN.

Q	INT	valore intero analogico letto dal file

Descrizione:

Lettura di una variabile ANALOGICA da un file binario. Da usarsi assieme in concomitanza con F_ROPEN e F_CLOSE.

Questa procedura effettua un accesso sequenziale al file, dalla precedente posizione.

La prima chiamata successiva a F_ROPEN legge i primi 4 byte del file,

ogni chiamata sposta il puntatore di lettura.

Usare F_EOF per controllare se sia stata raggiunta la fine del file.

Questa funzione non è inclusa nel simulatore ISaGRAF.

(* Programma FBD che fa uso della gestione file *)

(* Equivalente ST: *)

file_id := F_ROPEN('voltramp.bin');

vstart := FA_READ(file_id);

vend := FA_READ(file_id);

vinc := FA_READ(file_id);

delta_tim := tmr(FA_READ(file_id));

ok := F_CLOSE(file_id);

(* Equivalente IL: *)

LD	'voltramp.bin'

F_ROPEN

ST	file_id

FA_READ	(* lettura vstart *)

ST	vstart

LD 	file_id

FA_READ	(*lettura vend *)

ST	vend

LD 	file_id

FA_READ	(*lettura vinc *)

ST	vinc

LD 	file_id

FA_READ	(*lettura delta_tim *)

TMR	(* conversione a timer *)

ST	delta_tim

LD 	file_id

F_CLOSE

ST	ok


FA_WRITE

Argomenti:

ID	INT	numero file: restituito da F_WOPEN.

IN	INT	valore intero analogico che deve essere scritto nel file.

OK	BOO	stato: TRUE se ok

Descrizione:

Scrittura di una variabile ANALOGICA in un file binario.

Questa procedura effettua un accesso sequenziale al file, dalla precedente posizione.

La prima chiamata successiva a F_WOPEN scrive i primi 4 byte del file,

ogni chiamata sposta il puntatore di lettura.

Questa funzione non è inclusa nel simulatore ISaGRAF.

(* Programma FBD *)

(* Equivalente IL: *)

LD	'voltramp.bin'

F_ROPEN

ST	file_id

LD	0

ST	nb_written

LD 	file_id	(* scrittura vstart *)

FA_WRITE	vstart

ANA

ADD	nb_written

ST	nb_written

LD 	file_id	(*scrittura vend *)

FA_WRITE	vend

ANA

ADD	nb_written

ST	nb_written

LD 	file_id	(*scrittura vinc *)

FA_WRITE	vinc

ANA

ADD	nb_written

ST	nb_written

LD	delta_tim	(*scrittura delta_tim *)

ANA	(* conversione ad intero *)

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	(* ritorno se uguale a 4 *)

LD	ERR_FILE	(* altrimenti errore *)

ST	ERROR


FM_READ

Argomenti:

ID	INT	numero file: restituito da F_ROPEN.

Q	MSG	messaggio letto dal file

Descrizione:

Lettura di variabili MESSAGGIO da file binario.

Da usarsi in concomitanza con F_ROPEN e F_CLOSE.

Questa procedura effettua un accesso sequenziale al file, dalla precedente posizione.

La prima chiamata successiva a F_ROPEN legge la prima stringa del file,

ogni chiamata sposta il puntatore di lettura.

Una stringa viene conclusa da null (0), end of line ('\n') o return ('\r');

Usare F_EOF per controllare se sia stata raggiunta la fine del file.

Questa funzione non è inclusa nel simulatore ISaGRAF.

(* Programma FBD che fa uso della gestione file *)

(* Equivalente ST: *)

file_id := F_ROPEN('voltramp.bin');

status1 := FM_READ(file_id);

status2 := FM_READ(file_id);

IF (F_EOF(file_id)) THEN

ERROR := ERR_FILE;

unused_eof_mes := FM_READ(file_id);

END_IF;

ok := F_CLOSE(file_id);

(* Equivalente IL: *)

LD	'voltramp.bin'

F_ROPEN

ST	file_id

FM_READ	(* lettura status1 *)

ST	status1

LD 	file_id

FM_READ	(* lettura status2 *)

ST	status2

LD 	file_id

F_EOF

JMPNC	CLOSE_FILE (* se non end of file salta sotto *)

LD	ERR_FILE

ST	ERROR

LD 	file_id

FM_READ	(* lettura unused_eof_mes *)

ST	unused_eof_mes

CLOSE_FILE	LD 	file_id

F_CLOSE

ST	ok


FM_WRITE

Argomenti:

ID	INT	numero file: restituito da F_WOPEN.

IN	MSG	messaggio che deve essere scritto nel file

ok	BOO	stato

TRUE se operazione riuscita

Descrizione:

Scrittura di variabili MESSAGGIO su file binario.

Da usarsi in concomitanza con F_WOPEN e F_CLOSE.

Un messaggio scritto su file ha formato stringa terminata da null.

Questa procedura effettua un accesso sequenziale al file, dalla precedente posizione.

La prima chiamata successiva a F_WOPEN scrive la prima stringa sul file,

ogni chiamata sposta il puntatore di scrittura.

Questa funzione non è inclusa nel simulatore ISaGRAF.

(* Programma FBD che fa uso della gestione file *)

(* Equivalente ST: *)

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);

(* Equivalente IL: *)

LD	'trace.txt'

F_WOPEN

ST	file_id

FM_WRITE	'First message'	(* scrittura primo msg *)

ST	ok

LD 	file_id

FM_WRITE	'Last message'	(* scrittura secondo msg *)

ST	ok

LD 	file_id

F_CLOSE

ST	ok


Indice alfabetico

-	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


Linguaggio FC

Flow Chart (FC) è un linguaggio grafico usato per descrivere operazioni sequenziali. Un diagramma Flow Chart è composto di azioni e test. Tra le azioni ed i test sono interposti dei collegamenti orientati  che rappresentano il flusso dei dati. Le azioni ed i test possono essere descritti con i linguaggi ST, LD o IL. Funzioni e blocchi funzione di ogni linguaggio (eccetto SFC e FC) possono essere chiamati da azioni e test. Un programma Flow Chart può chiamare un altro programma Flow Chart. Il programma FC richiamato è un sottoprogramma FC del programma FC chiamante.

Componenti base FC

Esempi di strutture complesse FC

Comportamento dinamico FC

Controlli FC


Componenti FC

Segue una lista dei componenti grafici del linguaggio Flow Chart:

Inizio di un diagramma FC

Fine di un diagramma FC

Flusso dei collegamenti FC

Azioni FC

Test FC

Sottoprogramma FC

Azione FC specifica per I/O

Connettori FC

Commenti FC


Inizio di un diagramma FC

Un simbolo "Start" deve apparire all'inizio di un programma Flow Chart. Il simbolo è unico e non può essere omesso. Esso rappresenta lo stato iniziale quando il diagramma viene attivato . Segue il disegno del simbolo "Start":

Il simbolo "Start" ha sempre una connessione (nella parte inferiore) verso un altro oggetto del diagramma. Un diagramma Flow Chart non è valido se non esiste una connessione da "Start" ad un altro oggetto.


Fine di un diagramma FC

Un simbolo "Stop" deve apparire alla fine di un programma Flow Chart. Il simbolo è unico e non può essere omesso. Esso rappresenta lo stato finale del diagramma, quando la sua esecuzione è stata terminata. Segue il disegno del simbolo "Stop":

Il simbolo "Stop" generalmente ha una connessione (nella parte superiore) proveniente da altri oggetti del diagramma. E' possibile che nessuna connessione sia tracciata verso il simbolo "Stop" (ad esempio in un diagramma che itera sempre), ma il simbolo "Stop" viene in ogni caso disegnato alla fine del diagramma.


Flusso dei collegamenti FC

Un collegamento è una linea che rappresenta un flusso tra due punti del diagramma. Un collegamento è sempre terminato da una freccia. Segue il disegno del simbolo collegamento:

Due collegamenti non possono essere connessi allo stesso punto sorgente della connessione.


Azioni FC

Un simbolo di Azione rappresenta azioni da eseguire. Un'azione è identificata da un numero e da un nome. Segue il disegno del simbolo "Azione":

Due differenti oggetti dello stesso diagramma non possono avere lo stesso nome o lo stesso numero logico. Il linguaggio di programmazione per un'azione può essere ST, LD o IL. Un'azione è sempre connessa con dei collegamenti, uno che arriva su di essa, uno che parte da essa.


Condizioni FC
Test FC

Un test rappresenta una condizione booleana. Un test è identificato da un nome e da un numero logico. In accordo con la valutazione dell'espressione ST, LD o IL associata, il flusso viene diretto verso il percorso "SI" o "NO". Seguono i disegni possibili per un simbolo di test:

Due differenti oggetti test dello stesso diagramma non possono avere lo stesso nome o lo stesso numero logico. Il programma di un oggetto test può essere

-  un espressione in linguaggio ST,

-  un singolo ramo in linguaggio LD, con nessun simbolo collegato all'unica bobina,

-  una sequenza di istruzioni in linguaggio IL. Il registro IL (o il risultato corrente) è utilizzato per valutare il test.

Quando si programma in linguaggio ST, l'espressione può essere opzionalmente seguita da un simbolo di punto-e-virgola. Quando si programma in linguaggio LD, l'unica bobina presente rappresenta il risultato del test. Un test uguale a:

-  0 o FALSO 	dirige il flusso verso il NO

-  1 o VERO 	dirige il flusso verso il SI

Un oggetto test è sempre connesso con un collegamento di arrivo, ed entrambe le due connessioni di partenza devono essere definite.


Sottoprogramma FC

Il sistema permette la descrizione di strutture verticali nei programmi FC. I programmi FC sono organizzati con una gerarchia ad albero. Ogni programma FC può chiamare altri programmi FC. Tali programmi sono chiamati sottoprogrammi FC del programma che li ha chiamati. I programmi FC che chiamano sottoprogrammi FC sono chiamati programmi padre FC. I programmi FC sono collegati assieme in gerarchia ad albero, usando una relazione "padre-figlio":

Nota: Non si confondano tra di loro i seguenti 3 oggetti:

-	Sottoprogramma

-	Programma figlio SFC

-	Sottoprogramma FC

Nota: Non si confondano tra di loro i seguenti 2 oggetti:

-	Programma padre SFC

-	Programma padre FC

Un simbolo di sottoprogramma FC in un Flow Chart rappresenta una chiamata ad un sottoprogramma del Flow Chart. L'esecuzione del programma padre FC viene sospesa fino a quando l'esecuzione del sottoprogramma FC è completata. Un sottoprogramma FC è identificato da un nome e da un numero logico, come per gli altri programmi, funzioni o blocchi funzione. Segue il disegno del simbolo di "sottoprogramma FC":

Due oggetti differenti dello stesso diagramma non possono avere lo stesso numero logico. Le regole base della struttura gerarchica FC sono le seguenti:

-	I programmi FC che non hanno padre sono chiamati programmi FC principali.

-	I programmi FC principali sono attivati dal sistema quando l'applicazione inizia

-	Un programma può avere più sottoprogrammi FC

-	Un sottoprogramma FC non può avere più di un programma padre FC

-	Un sottoprogramma FC può essere chiamato solo dal suo programma padre FC

-	Un programma non può chiamare i sottoprogrammi FC di un suo sottoprogramma FC

Lo stesso sottoprogramma FC può comparire più volte nel diagramma padre FC. Una chiamata del sottoprogramma FC rappresenta una esecuzione completa del sotto diagramma. L'esecuzione del diagramma padre FC viene sospesa durante l'esecuzione del sottodiagramma FC. I blocchi di chiamata a sottoprogrammi FC devono seguire le stesse regole di connessione definite per le azioni.


Azione FC specifica per I/O

Un simbolo di  azione specifica I/O rappresenta azioni che devono essere eseguite. Come per altre azioni, un azione specifica I/O è definita da un nome e da un numero logico. La stessa semantica viene utilizzata per azioni standard e azioni specifiche I/O. Lo scopo delle azioni specifiche I/O è quello di rendere il diagramma più leggibile e di focalizzare alle parti del diagramma non-portabili. L'utilizzo delle azioni specifiche I/O è opzionale. Segue il disegno del simbolo "azione specifica I/O":

I blocchi specifici I/O hanno esattamente lo stesso comportamento delle azioni standard. Questo si riferisce alle loro proprietà, alla programmazione ST, LD o IL, e alle regole di connessione.


Connettori FC

I Connettori sono usati per rappresentare collegamenti tra due punti del diagramma senza doverli disegnare. Un connettore è rappresentato con un cerchio ed è connesso alla sorgente del flusso. Il disegno del connettore viene completato, sul lato appropriato (dipendente dalla direzione del flusso di dati), con l'identificazione del punto destinazione (generalmente il nome del simbolo destinazione). Segue il disegno del simbolo connettore:

Un connettore riporta il flusso sempre ad un simbolo definito sul diagramma Flow Chart. Il simbolo destinazione è identificato con il suo numero logico.


Commenti FC

Un blocco commento contiene del testo che non influenza la semantica del diagramma. Un commento può essere inserito ovunque in un qualsiasi spazio inutilizzato della finestra documento Flow Chart, e viene utilizzato per documentare il programma. Segue il disegno del simbolo "commento":


Esempi di strutture complesse FC

Questa sezione mostra esempi di strutture complesse che possono essere definite in un diagramma Flow Chart. Tali strutture sono combinazioni di oggetti base collegati insieme.

	IF / THEN / ELSE (1) posizione di inserimento di un azione "THEN" (2) posizione di inserimento di un azione "ELSE"
	REPEAT / UNTIL (3) posizione di inserimento di un azione ripetitiva
	WHILE / DO (3) posizione di inserimento di un azione ripetitiva


Comportamento dinamico FC

L'esecuzione di un diagramma può essere spiegata nel modo seguente:

-	Il simbolo Start utilizza un ciclo del target

-	Il simbolo Stop utilizza un ciclo del target e termina l'esecuzione del diagramma. Dopo che questo simbolo è stato raggiunto, non viene più eseguita nessuna azione del diagramma.

-	L'esecuzione di un azione utilizza un ciclo del target.

Nota: Contrariamente ad un diagramma SFC, un azione non è uno stato stabile. Mentre il simbolo di azione è attivo, non avviene nessuna ripetizione di istruzioni.


Controlli FC

A parte la programmazione ST, LD o IL allegata, altre regole sintattiche si applicano al Flow Chart. Sotto è riportata la lista delle regole principali:

-	Tutti i punti di "connessione" di tutti i simboli devono essere collegati. (la connessione al simbolo "Stop" può essere omessa)

-	Tutti i simboli devono essere collegati assieme (non devono apparire parti isolate)

-	Tutte le connessioni devono avere una destinazione valida

Altri errori di sintassi di minore importanza sono qui riportati:

-	Le azioni vuote (senza programma) sono considerate come passi durante lo scheduling

-	I test vuoti (senza programma) sono considerati come "sempre veri"