Référence des langages
Références des langages

Architecture du projet

Objets communs

Langage SFC (GRAFCET)

Langage FC  (Flow Chart)

Langage FBD

Langage LD

Langage ST

Langage IL

Opérateurs, fonctions et blocs fonctionnels standards


 Architecture du projet

Une application ISaGRAF est divisée en plusieurs unités de programmation appelés programmes. Les programmes d'une application sont organisés en une architecture hiérarchisée. Les programmes peuvent être décrits avec les langages graphiques ou textuels SFC, FC (Flow Chart), FBD, LD, ST ou IL.

Programmes

Opérations séquentielles et cycliques

Programmes fils SFC et sous-programmes FC

Fonctions et sous-programmes

Blocs fonctionnels

Langages de programmation

Règles d'exécution


Programmes

Un programme est une unité logique de programmation qui décrit des opérations entre les variables de l'application. Les programmes décrivent des opérations séquentielles ou cycliques. Les programmes cycliques sont exécutés systématiquement à chaque cycle ISaGRAF. L'exécution des programmes séquentiels respecte les règles d'évolution des langages SFC et FC.

Les programmes sont organisés dans un système hiérarchique arborescent. Les programmes placés au sommet, programmes principaux, de la hiérarchie sont activés par le système. Les sous-programmes (de niveau inférieur dans la hiérarchie) sont activés par leur programme père. La description d'un programme peut être réalisée à l'aide des langages graphiques ou textuels disponibles :

- Sequential Function Chart (SFC) ou GRAFCET pour les traitements séquentiels de haut niveau

- Flow Chart (FC) pour la structuration des opérations

- Function Block Diagram (FBD) ou Logigramme pour les traitements cycliques

- Ladder Diagram (LD) ou schéma à relais pour les traitements cycliques booléens

- Structured Text (ST) pour les traitements cycliques

- Intruction List (IL) pour les traitements cycliques de bas niveau

Plusieurs langages ne peuvent pas être mixés dans le même programme, à l'exception des langages LD et FBD qui peuvent être mêlés dans le même diagramme.


Opérations séquentielles et cycliques

La hiérarchie des programmes est organisée en quatre principales sections ou groupes :

DEBUT	programmes exécutés au début de chaque cycle

SEQUENTIEL	programmes exécutés en fonction des règles SFC ou FC

FIN	programmes exécutés à la fin de chaque cycle

FONCTIONS	ensemble de sous-programmes non dédiés

BLOCS FONCTIONNELS	ensemble de blocs fonctionnels

Les programmes des sections "Début" et "Fin" décrivent des opérations cycliques. Ils sont indépendants de l'état du procédé. Les programmes de la section "Sequentiel" décrivent des opérations séquentielles, où l'état du procédé est explicitement représenté dans la programmation, selon les conventions SFC ou FC.

Les programmes de la section "Fonctions" sont des sous-programmes qui peuvent être appelés par tous les autres programmes du projet. Un programme de la section "Fonction" peut appeler un programme de la même section.

Les programmes de la section Blocs fonctionnels peuvent être appelé par tous les autres programmes du projet. Un programme de la section Blocs fonctionnels peut appeler des programmes de la section fonction, mais pas d'autres blocs fonctionnels.

Les programmes principaux de la section "Début" sont exécutés systématiquement au début de chaque cycle. Les programmes principaux de la section "Fin" sont exécutés systématiquement à la fin de chaque cycle. Les programmes principaux de la section "Séquentiel" sont activés au lancement de l'application, et exécutés conformément aux règles d'évolution du SFC ou du FC.

Les programmes principaux et fils de la section séquentielle doivent être décrits avec le langage SFC ou le langage FC. Les programmes principaux des sections cycliques ne peuvent pas être décrits avec le langage SFC ni avec le langage FC. Chaque programme de chaque section peut avoir un ou plusieurs sous-programmes. Chaque programme SFC de la section séquentielle peut contrôler un ou plusieurs programmes SFC fils. Chaque programme FC de la section séquentielle peut contrôler un ou plusieurs sous-programmes FC.

Les sous-programmes (non FC) ne peuvent pas être décrits avec les langage SFC ou FC.

Les programmes de la section "Début" sont typiquement utilisés pour décrire les opérations préliminaires effectuées sur les variables d'entrée, pour construire des données de plus haut niveau, qui seront reprises dans la section "Séquentiel". Les programmes de la section "Fin" sont typiquement utilisés pour les opérations de contrôle et de mise en forme des données de haut niveau (ordres) fabriqués par la section "Séquentiel" avant la mise à jour des actionneurs.


Programmes fils SFC et sous-programmes FC

Chaque programme SFC de la section séquentielle peut contrôler d'autres programmes SFC, appelés ses programmes fils. Un programme SFC fils est un programme exécuté en parallèle, qui peut être lancé, tué, figé ou relancé par son programme père. Le programme père et le programme fils doivent tous deux être décrits avec le langage SFC. Un programme fils peut avoir des variables et définitions locales.

Quand un programme père lance un programme SFC fils, il place un jeton (activation) dans chacune de ses étapes initiales. Une telle commande peut être décrite par l'énoncé GSTART. Quand un programme père tue un programme SFC fils, il enlève tous les jetons existant dans ses étapes. Une telle commande peut être décrite par l'énoncé GKILL.

Quand un programme père fige un programme SFC fils, il suspend son exécution. Une telle commande peut être décrite par l'énoncé GFREEZE. Le programme fils peut ensuite être relancé par l'énoncé GRST.

Tout programme FC de la section séquentielle peut contrôler des sous-programmes FC. L'exécution d'un programme père FC est suspendue (le flux est bloqué) pendant toute l'exécution du sous-programme FC, c'est-à-dire jusqu'à ce que le flux dans le sous-programme rencontre le symbole END. Il ne peut en aucun cas y avoir d'exécution simultanée d'un programme FC et d'un de ses sous-programmes FC.


Fonctions et sous-programmes

L'exécution d'un sous-programme ou d'un fonction est demandée par son programme père. L'exécution du père est suspendue jusqu'à la fin du déroulement du sous-programme ou de la fonction:

progr.	sous-programmes

Chaque programme de chaque section peut avoir un ou plusieurs sous-programmes. Un sous-programme ne peut être activé que par un seul programme père. Un sous-programme peut avoir des variables et des définitions locales. Tous les langages à l'exception du SFC et du FC peuvent être utilisés pour décrire un sous-programme. Les programmes de la section "Fonctions" sont des sous-programmes qui peuvent être appelés par n'importe quel autre programme du projet. Contrairement aux autres sous-programmes, ils ne sont pas dédiés à un programme père unique. Un programme de la section "Fonction" peut appeler un autre sous-programme de cette section.

Attention : Le système ISaGRAF ne supporte pas la récursivité dans les appels de fonctions. Une erreur surviendra à l'exécution si un programme de la section "Fonctions" est appelé par lui-même ou un de ses descendants.

Attention : Une fonction ou un sous-programme ne "stocke" pas la valeur de ses variables locales. Une fonction ou un sous-programme n'est pas instancié et ne peut donc pas appelé de blocs fonctionnels.

L'interface d'un sous-programme doit être défini explicitement, avec un type et un nom pour chacun de ses paramètres d'appel et son paramètre de retour. Afin de respecter les conventions d'écriture du langage ST, le paramètre de retour d'un sous-programme doit porter le même nom que le sous-programme. La table ci-après montre comment forcer le paramètre de retour dans le corps d'un sous-programme, dans les différents langages:

ST:	assigner une valeur au paramètre de retour en utilisant son nom

(le même nom que le sous-programme):

   nom_sous_programme := <expression>;

IL:	la valeur du résultat courant (registre IL) à la fin de la séquence

est stocké dans le paramètre de retour:

   LD      10

   ADD   20   (* valeur du paramètre de retour = 30 *)

FBD:	affecter le paramètre de retour en utilisant son nom:

   nom_sous_programme

LD:	utiliser un relais ayant le nom du sous-programme:

nom_sous_programme


Blocs fonctionnels

Un bloc fonctionnel peut être programmé dans les langages: LD, FBD, ST ou IL. Les blocs fonctionnels sont instanciés. Ce qui signifie que les variables locales d'un bloc fonctionnel sont copiées pour chaque instance. Lorsqu'un programme appelle un bloc, il appelle en fait l'instance du bloc: le même code est appelé mais les données utilisées sont celles qui ont été allouées pour l'instance. Les valeurs des variables de l'instance sont conservées d'un cycle à l'autre.

Attention:

- Un bloc fonctionnel écrit dans l'un des langages de la CEI ne peuvent pas appeler d'autres blocs fonctionnels: le mécanisme d'instanciation gère uniquement les variables locales du bloc en question. Voici la liste des blocs fonctionnels standard que vous ne pouvez pas utiliser à l'intérieur d'un bloc fonctionnel écrit en langage CEI:

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

- Pour les mêmes raisons, vous ne pouvez pas utiliser des contacts ou des relais de type Positif ou Négatif, ou des relais de type Set ou Reset.

- Les fonctions TSTART et TSTOP qui gère le démarrage ou l'arrêt de temporisation ne peuvent pas être utilisées si les cibles de version 3.0x. Mais peuvent être utilisées avec les cibles dont la version est au moins 3.20.

- Lorsque vous écrivez des boucles dans votre bloc fonctionnel, vous devez utiliser une variable locale avant la boucle, comme dans l'exemple ci-dessous:

Ceci ne marche pas:	Ceci marche:


Langages de programmation

Un programme peut être décrit avec un des langages graphiques ou littéraux suivants :

- Sequential Function Chart (SFC) ou GRAFCET pour les traitements séquentiels de haut niveau

- Flow Chart (FC) pour la structuration des opérations

- Function Block Diagram (FBD) ou Logigramme pour les traitements cycliques

- Ladder Diagram (LD) ou schéma à relais pour les traitements cycliques booléens

- Structured Text (ST) pour les traitements cycliques

- Intruction List (IL) pour les traitements cycliques de bas niveau

Le même programme ne peut pas utiliser plusieurs langages. Le langage utilisé pour décrire un programme est choisi quand le programme est créé. Toutefois, les éléments graphiques des langages LD et FBD peuvent être mêlés dans le même diagramme.


Règles d'exécution
Execution rules

ISaGRAF est un système synchrone. Toutes les opérations sont échantillonnées. La durée d'un échantillon est appelée le temps de cycle:

Les opérations réalisées dans un cycle sont :

Ce système assure :

- qu'une variable d'entrée n'évolue pas pendant un cycle

- que les sorties ne sont mises à jour qu'une fois dans le cycle

- le partage fiable de variables globales entre les programmes

- l'estimation du temps de réponse de l'application complète


 Objets communs

Ce chapitre présente les objets de la base de données de programmation d'ISaGRAF. Ces objets sont manipulés par les programmes écrits en SFC, FC, FBD, LD, ST ou IL.

Types de données

Expressions constantes

Variables

Commentaires

Mots équivalents


Types de données

Toute expression, constante ou variable utilisée dans un programme doit être caractérisée par un type. La cohérence des types doit être respectée dans les réseaux graphiques et les énoncés textuels. Voici les types de base prédéfinis par ISaGRAF :

- BOOLEEN:	valeur logique (vrai ou faux)

- ANALOGIQUE:	valeur continue entière ou réelle

- TEMPORISATION:	valeur de temps

- MESSAGE:	chaîne de caractères

Note: les temporisations contiennent des valeurs inférieures à un jour, et ne peuvent pas être utilisées pour stocker des dates.


Expressions constantes

Une expression constante est toujours relative à un type. La même notation ne peut pas être utilisée pour représenter des expressions constantes de type différent.

Expressions constantes booléennes

Expressions constantes analogiques entières

Expressions constantes analogiques réelles

Expressions constantes temporelles

Expressions constantes messages


Expressions constantes booléennes

Il existe seulement deux expressions constantes de type booléen :

- TRUE	est équivalent à la valeur entière 1

- FALSE	est équivalent à la valeur entière 0

Les minuscules et les majuscules ne sont pas différenciées pour l'écriture des mots clé "True" et "False".


Expressions constantes analogiques entières

Une expression constante analogique entière représente un nombre signé entre -2147483647 et +2147483647. Les expressions constantes entières peuvent être exprimées dans l'une ou l'autre des bases présentées dans le tableau suivant. L'expression constante doit commencer par un préfixe qui identifie la base utilisée.

Base	Prefixe	Exemple

DECIMAL	(aucun)	-908

HEXADECIMAL	"16#"	16#1A2B3C4D

OCTAL	"8#"	8#1756402

BINARY	"2#"	2#1101_0001_0101_1101

Le caractère souligné ('_') peut être librement utilisé pour séparer des groupes de chiffres. Il n'a aucune signification sémantique, mais augmente la lisibilité des expressions longues.


Expressions constantes analogiques réelles

Les expressions analogiques réelles peuvent utiliser une représentation décimale ou scientifique. Le point décimal ('.') sépare la partie entière de la partie décimale. Il doit obligatoirement être présent car il permet la différenciation des expressions constantes entières et réelles. La représentation scientifique utilise la lettre 'E' ou 'F' pour séparer la mantisse de l'exposant. L'exposant d'une expression constante scientifique est un entier signé compris entre -37 et +37. Voici des exemples d'expressions constantes réelles :

3.14159	-1.0E+12

+1.0	1.0F-15

-789.56	+1.0E-37

L'expression "123" ne représente pas une valeur réelle. Sa notation correcte est "123.0".


Expressions constantes temporelles

Les expressions constantes temporelles représentent des valeurs de temps entre 0 seconde et 23h59m59s999ms. La plus petite unité autorisée est la milli-seconde. Voici les unités standard de temps utilisées dans les expressions constantes temporelles :

- Heure:	la lettre "h" doit suivre le nombre d'heures

- Minute:	la lettre "m" doit suivre le nombre de minutes

- Seconde:	la lettre "s" doit suivre le nombre de secondes

- Milli-seconde:	les lettres "ms" doivent suivre le nombre de milli-secondes

L'expression doit commencer par le préfixe "T#" ou "TIME#". Les préfixes et les lettres d'unité peuvent être écrits en minuscule ou en majuscule. Certaines unités peuvent ne pas apparaître. Voici des exemples d'expressions constantes temporelles :

T#1H451MS	1 heure et 451 milli-secondes

time#1H3M	1 heure et 3 minutes

L'expression "0" ne représente pas une expression constante temporelle, mais analogique.


Expressions constantes messages

Les expressions constantes de type message représentent des chaînes de caractères. Les caractères de la chaîne doivent être précédés et suivis par une apostrophe. Par exemple :

'CECI EST UN MESSAGE'

Attention: le caractère apostrophe ne peut pas être utilisé à l'intérieur de l'expression. Une expression constante de type message doit être exprimée sur une seule ligne de programme, et ne doit jamais excéder 255 caractères.

Une chaîne vide est représentée par deux apostrophes, sans espace ou caractère de tabulation entre elles :

''   (* ceci est une chaîne vide *)

Le caractère spécial dollar ('$'), suivi par d'autres caractères spéciaux, peut être utilisé pour insérer des caractères non imprimables dans une chaîne de caractères:

Séquence	signifie	ASCII (hexa)	Exemple

$$	caractère '$'	16#24	'I paid $$5 for this'

$'	apostrophe	16#27	'Enter $'Y$' for YES'

$L	ligne suivante	16#0a	'next $L line'

$R	retour chariot	16#0d	'   llo $R He'

$N	nouvelle ligne	16#0d0a	'This is a line$N'

$P	nouvelle page	16#0c	'lastline $P first line'

$T	tabulation	16#09	'name$Tsize$Tdate'

$hh   (*)	tout character	16#hh	'ABCD = $41$42$43$44'

(*) "hh" est le code ascii du caractère, exprimé sur deux chiffres en hexadécimal.


Variables

Les variables peuvent être LOCALES à un programme, ou GLOBALES. Les variables locales ne peuvent être utilisées que par un seul programme. Les variables globales peuvent être utilisées par tous les programmes de l'application.

Mots réservés

Variables représentées directement

Variables booléennes

Variables analogiques

Variables temporisations

Variables messages

Le nom d'une variable doit respecter les règles suivantes:

- la longueur du nom ne doit pas excéder 16 caractères

- le premier caractère doit être une lettre

- les caractères suivants doivent être des lettres, des chiffres ou '_'


Mots réservés

Voici la liste des mots clés réservés. Ces identificateurs ne doivent pas être utilisés en tant pour nommer un programme, une variable, une fonction ou un bloc fonctionnel.

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

Tous les mots clé commençant par le caractère souligné ('_') sont des mots clés internes et ne doivent pas être utilisés dans des instructions textuelles.


Variables représentées directement

ISaGRAF permet l'utilisation des 'variables représentées directement' dans le code des programmes pour accéder à une voie d'E/S libre. Les voies libres sont celles qui ne sont pas liées à une variable d'E/S déclarée. L'identificateur d'une variable représentée directement commence toujours pas le caractère "%" .

Voici la nomenclature à suivre pour accéder à une variable représentée directement pour une voie de carte simple. "s" est le numéro d'emplacement de la carte (slot). "c" est le numéro de la voie (channel).

%IXs.c	voie libre pour une carte d'entrée booléenne

%IDs.c	voie libre pour une carte d'entrée analogique entière

%ISs.c	voie libre pour une carte d'entrée de type message

%QXs.c	voie libre pour une carte de sortie booléenne

%QDs.c	voie libre pour une carte de sortie analogique entière

%QSs.c	voie libre pour une carte de sortie de type message

Voici la nomenclature à suivre pour accéder à d'une variable représentée directement pour une voie d'un équipement complexe. "s" est le numéro d'emplacement de l'équipement (slot). "b" est le numéro de la carte dans l'équipement (board). "c" est le numéro de la voie (channel).

%IXs.b.c	voie libre pour une carte d'entrée booléenne

%IDs.b.c	voie libre pour une carte d'entrée analogique entière

%ISs.b.c	voie libre pour une carte d'entrée de type message

%QXs.b.c	voie libre pour une carte de sortie booléenne

%QDs.b.c	voie libre pour une carte de sortie analogique entière

%QSs.b.c	voie libre pour une carte de sortie de type message

Exemples:

%QX1.6	6ième voie de la carte #1 (sortie booléenne)

%ID2.1.7	7ième voie de la carte #1 de l'équipement #2 (entrée entière)

Une variable représentée directement ne peut pas avoir le type "réel".


Variables booléennes

Booléen signifie logique. Ces variables ne peuvent prendre que les valeurs TRUE ou FALSE. Les variables booléennes sont typiquement utilisées dans les expressions de type booléen. Une variable booléenne peut avoir un des attributs suivants :

Interne:	variable mémoire mise à jour par le programme

Constant:	variable mémoire avec une valeur initiale, autorisée en lecture seulement

Entrée:	variable connectée à un capteur (rafraîchie par le système)

Sortie:	variable connectée à un actionneur

Attention: Lors de la déclaration d'une variable booléenne, les libellés définis pour remplacer les valeurs 'true' et 'false' sont destinés à la mise au point. Ils ne peuvent pas être utilisés dans la programmation, tant qu'ils ne font pas l'objet de définitions de mots équivalents.


Variables analogiques

Analogique signifie continu. Ces variables prennent des valeurs signées entières ou réelles (flottantes). Voici les formats disponibles pour une variable analogique :

Entier:	entier signé sur 32 bits : de -2147483647 à +2147483647

Réel:    	valeur flottante sur 32 bits - standard IEEE (simple précision)

1 bit de signe + 23 bits de mantisse + 8 bits d'exposant

L'exposant d'une variable analogique REELLE doit être compris entre -37 et +37. Une variable analogique peut avoir un des attributs suivants :

Interne:	variable mémoire mise à jour par le programme

Constant:	variable mémoire avec une valeur initiale, autorisée en lecture seulement

Entrée:	variable connectée à un capteur (rafraîchie par le système)

Sortie:	variable connectée à un actionneur

Note: Quand une variable réelle est connectée à un dispositif d'E/S, le pilote d'E/S correspondant traite l'équivalent entier de sa valeur.

Attention: Les variables entières et réelles ne peuvent pas être mélangées dans la même expression analogique.


Variables temporisations

Une temporisation est un chronomètre, (ou horloge ou compteur de temps). Ces variables prennent des valeurs temporelles, comprises entre 0s et 23h59m59s999ms, et ne peuvent jamais être négatives. Les variables temporisations sont stockées sur 32 bits. Leur représentation interne indique un nombre entier de milli-secondes.

Une variable temporisation peut avoir un des attributs suivants :

Interne:	variable mémoire mise à jour par le programme

Constant:	variable mémoire avec une valeur initiale, autorisée en lecture seulement

Attention: Les variables temporisations ne peuvent pas prendre les attributs ENTREE ou SORTIE.

Les variables temporisations peuvent être automatiquement rafraîchies par le système ISaGRAF. Quand une temporisation est active, sa valeur est automatiquement incrémentée en accord avec l'horloge du système. Les énoncés suivants peuvent être utilisés pour contrôler une temporisation:

TSTART:	lance le rafraîchissement automatique d'une temporisation

TSTOP:	arrête le rafraîchissement automatique d'une temporisation


Variables messages

Les variables messages contiennent des chaînes de caractères. La longueur de la chaîne peut changer en fonction des opérations réalisées. La longueur d'un message ne peut jamais excéder sa capacité (longueur maximale) spécifiée pendant sa déclaration. La capacité d'un message ne peut pas excéder 255 caractères. Une variable message peut avoir un des attributs suivants :

Interne:	variable mémoire mise à jour par le programme

Constant:	variable mémoire avec une valeur initiale, autorisée en lecture seulement

Entrée:	variable connectée à un capteur (rafraîchie par le système)

Sortie:	variable connectée à un actionneur

Les variables messages peuvent contenir tous les caractères de la table ascii (codes de 0 à 255). Le caractère nul (code 0) peut exister à l'intérieur d'une chaîne. Certaines procédures "C" de la librairie standard d'ISaGRAF ne peuvent pas traiter correctement des messages contenant des caractères nuls.


Commentaires

Des blocs de commentaires peuvent être librement insérés dans le code source des programmes textuels ST et IL. Un bloc de commentaire doit commencer par les caractères "(*" et se terminer par les caractères "*)". Les commentaires peuvent être insérés partout dans un programme ST, et peuvent être exprimés sur plusieurs lignes. Voici des exemples de commentaires :

counter := ivalue;   (* assignation compteur principal *)

(* voici un commentaire exprimé

sur deux lignes *)

c := counter (* compteur principal *) + base_value + 1;

Les blocs de commentaires ne peuvent pas être imbriqués. Les caractères "(*" sont interdits dans un bloc de commentaires.

Attention: Le langage IL n'accepte un bloc de commentaire que comme dernier composant d'une ligne d'instruction.


Mots équivalents

Le système ISaGRAF permet de redéfinir des expressions constantes, des libellés équivalents à "true" ou "false", des mots clé du langage ou des expressions ST complexes. Pour ceci, il faut affecter un identificateur à l'expression correspondante. Par exemple :

OUI	signifie	TRUE

PI	signifie	3.14159

OK	signifie	(mode_auto AND NOT (alarme))

Quand une équivalence est définie, son identificateur peut être utilisé pour remplacer l'expression dans le code source d'un programme. Voici un exemple de programme ST utilisant les équivalences définies ci-avant :

If OK Then

angle := PI / 2.0;

isdone := OUI;

End_if;

Les définitions peuvent être LOCALES à un programme, ou GLOBALES, ou COMMUNES.

Les définitions locales ne peuvent être utilisées que dans un seul programme.

Les définitions globales peuvent être utilisées dans tous les programmes de l'application.

Les définitions communes peuvent être utilisées dans tous les programmes de toutes les applications.

Notez que les définitions communes peuvent être stockées séparément en utilisant l'utilitaire d'archivage.

Attention:

Quand le même identificateur est utilisé pour plusieurs équivalences, il remplace seulement la dernière expression définie. Par exemple :

Définition:	OPEN	équivalent à	FALSE

OPEN	équivalent à	TRUE

signifie:	OPEN	équivalent à	TRUE

La nomenclature des définitions doit respecter les règles suivantes :

- la longueur du nom ne doit pas excéder 16 caractères

- le premier caractère doit être une lettre

- les caractères suivants doivent être des lettres, des chiffres, ou '_'

Attention :

Un mot équivalent ne peut pas utiliser un mot équivalent dans sa définition. Par exemple, vous ne pouvez pas avoir:

PI	équivalent à 	3.14159

PI2 	équivalent à	PI*2

Il faut écrire l'équivalence en utilisant uniquement des constantes des variables ou des opérations:

PI2 	équivalent à	6.28318


 Langage IL

Le langage IL (Instruction List), est un langage textuel de bas niveau. Il est particulièrement adapté aux applications de petite taille, ou à l'optimisation de portions réduites d'une application. Les instructions travaillent toujours sur un résultat courant (ou registre IL). L'opérateur indique le type d'opération à effectuer entre le résultat courant et l'opérande. Le résultat de l'opération est stocké à son tour dans le résultat courant.

Syntaxe du IL

Opérateurs du IL


Syntaxe du IL

Un programme IL est une liste d'instructions. Chaque instruction doit commencer par une ligne nouvelle, et doit contenir un opérateur, complété éventuellement par des modificateurs et, si c'est nécessaire pour l'opération, un ou plusieurs opérandes, séparés par des virgules (','). Une étiquette suivie de deux points (':') peut précéder l'instruction. Si un commentaire est attaché à l'instruction, il doit être le dernier élément de la ligne. Un commentaire commence toujours par les caractères '(*' et se termine par  '*)'. Des lignes vides peuvent être insérées entre des instructions. Un commentaire peut être posé sur une ligne sans instruction.

Etiquettes

Modificateurs d'instructions

Opérations différées

Exemples de ligne d'instruction :

Etiquette	Opérateur	Opérande	Commentaire

Debut:	LD	IX1	(* bouton poussoir *)

ANDN	MX5	(* commande valide *)

ST	QX2	(* lance moteur *)


Etiquettes

Une étiquette suivie du caractère ':' peut précéder une instruction. Une étiquette peut être posée sur une ligne sans instruction. Les étiquettes sont utilisées comme opérandes par certaines instructions telles que les sauts. La nomenclature des étiquettes doit respecter les règles suivantes:

- la longueur du nom ne doit pas excéder 16 caractères

- le premier caractère doit être une lettre

- les caractères suivants doivent être des lettres, des chiffres ou '_'

Deux étiquettes d'un même programme IL ne peuvent pas avoir le même nom. Une étiquette peut avoir le même nom qu'une variable.


Modificateurs d'instructions

Voici la liste des modificateurs autorisés pour les instructions du langage IL. Le caractère modificateur complète le nom de l'instruction, sans aucun caractère de séparation.

N	inversion booléenne de l'opérande

(	opération différée

C	opération conditionnelle

Le modificateur 'N' indique que l'opérande doit être inversé avant d'être utilisé par l'instruction. Par exemple, l'instruction ANDN IX12 est interprétée comme : resultat := resultat AND NOT ( IX12 )

Le modificateur parenthèse ouvrante '(' indique que l'évaluation de l'instruction doit être différée jusqu'à la prochaine instruction parenthèse fermante ')'.

Le modificateur 'C' indique que l'instruction ne doit être exécutée que si le résultat courant a la valeur booléenne TRUE (ou différent de 0 pour une valeur non booléenne). Le modificateur 'C' peut être combiné avec l'opérateur 'N' pour indiquer que l'instruction ne doit être exécutée que si le résultat courant vaut FALSE (ou 0 pour une instruction non booléenne).


Opérations différées

Parce que le langage IL ne traite qu'un seul registre (résultat courant), certaines opérations doivent être différées, pour changer l'ordre naturel d'exécution des instructions. Les parenthèses sont utilisées pour représenter les opérations différées.

'('	est un modificateur	indique que l'opération doit être différée

')'	est une instruction	exécute l'opération différée

Le modificateur parenthèse ouvrante '(' indique que l'évaluation de l'instruction doit être différée jusqu'à la prochaine instruction parenthèse fermante ')'. Par exemple, la séquence :

AND(	IX12

OR	IX35

)

est interprétée :

result := result AND ( IX12 OR IX35 )


Opérateurs du IL

La table suivante résume l'ensemble des opérateurs du langage IL:

Operateur	Modificateurs	Opérande	Description

LD	N	Variable, constante	Charge un opérande

ST	N	Variable	Stocke le résultat courant

S	variable BOO	Force à TRUE

R	variable BOO	Force à FALSE

CAL	C   N	instance de B.F.	Appel de bloc fonctionnel

JMP	C   N	Etiquette	Saut à une étiquette

RET	C   N	Retour de sous-programme

 ) 	Exécute une instruction différée

Fonction	Appel de fonction ou sous-programme

AND	N   (	BOO	ET logique

&	N   (	BOO	ET logique

OR	N   (	BOO	OU logique

XOR	N   (	BOO	OU exclusif

ADD	(	variable, constante	Addition

SUB	(	variable, constante	Soustraction

MUL	(	variable, constante	Multiplication

DIV	(	variable, constante	Division

GT	(	variable, constante	Test: >

GE	(	variable, constante	Test: >=

EQ	(	variable, constante	Test: =

LE	(	variable, constante	Test: <=

LT	(	variable, constante	Test: <

NE	(	variable, constante	Test: <>

Dans les sections qui suivent seuls les opérateurs spécifiques au IL sont décrits. Les autres opérateurs utilisables sont détaillés dans le chapitre "Opérateurs, blocs fonctionnels et fonctions standard".


Opérateur LD

Opération	Charge une valeur dans le résultat courant

Modificateurs	N

Opérande	Expression constante

Variable interne d'entrée ou de sortie

Exemple :

(* EXEMPLES D'OPERATIONS LD *)

LDex:	LD	false	(* resultat := constante booléenne FALSE *)

LD	true	(* resultat := constante booléenne TRUE *)

LD	123	(* resultat := constante analogique entière*)

LD	123.1	(* resultat := constante analogique réelle *)

LD	t#3s	(* resultat := constante tempo *)

LD	boo_var1	(* resultat := variable booléenne *)

LD	ana_var1	(* resultat := variable analogique *)

LD	tmr_var1	(* resultat := variable temporisation *)

LDN	boo_var2	(* resultat := NOT ( variable booléenne ) *)


Opérateur ST

Opération	Stocke le résultat courant dans une variable

Le résultat courant n'est pas modifié par cette instruction

Modificateurs	N

Opérande	Variable interne ou de sortie

Exemple :

(* EXEMPLES D'OPERATIONS 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 *)


Opérateur S

Opération	Force une variable booléenne à TRUE, si le résultat courant vaut TRUE. Aucune opération n'est effectuée si le résultat courant vaut FALSE. Le résultat courant n'est pas modifié par cette instruction.

Modificateurs	(aucun)

Opérande	Variable booléenne interne ou de sortie

Exemple :

(* EXEMPLES D'OPERATIONS S *)

SETex:	LD	true	(* résultat courant := TRUE *)

S	boo_var1	(* boo_var1 := TRUE *)

(* résultat courant inchangé *)

LD	false	(* résultat courant := FALSE *)

S	boo_var1	(* aucune action - boo_var1 inchangé *)


Opérateur R

Opération	Force une variable booléenne à FALSE, si le résultat courant vaut TRUE. Aucune opération n'est effectuée si le résultat courant vaut FALSE. Le résultat courant n'est pas modifié par cette instruction.

Modificateurs	(aucun)

Opérande	Variable booléenne interne ou de sortie

Exemple :

(* EXEMPLES D'OPERATIONS R *)

RESETex:	LD	true	(* résultat courant := TRUE *)

R	boo_var1	(* boo_var1 := FALSE *)

(* résultat courant inchangé *)

ST	boo_var2	(* boo_var2 := TRUE *)

LD	false	(* résultat courant := FALSE *)

R	boo_var1	(* aucune action - boo_var1 inchangé *)


Opérateur JMP

Opération	Saut à l'instruction repérée par une étiquette

Modificateurs	C   N

Opérande	Etiquette définie dans le même programme IL

Exemple :

(* l'exemple suivant teste la valeur d'un sélecteur analogique (0 ou 1 ou 2) *)

(* et force une parmi 3 variables booléennes. Le test "égal à 0" est réalisé *)

(* par l'instruction JMPC *)

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

BOO	(* conversion en booléen *)

JMPC	test1	(* si selector = 0 alors *)

LD	true

ST	bo0	(* bo0 := true *)

JMP	JMPend	(* fin du programme *)

test1:	LD 	selector	(* décrémente selector *)

SUB	1	(* selector vaut 0 ou 1 *)

BOO	(* conversion en booléen *)

JMPC	test2	(* si selector = 0 alors *)

LD	true

ST	bo1	(* bo1 := true *)

JMP	JMPend	(* fin du programme *)

(* dernière possibilité *)

test2:	LD	true

ST	bo2	(* bo2 := true *)

JMPend:	(* fin du programme *)


Opérateur RET

Opération	Termine l'exécution du programme. Si la séquence IL est un sous-programme, le résultat courant sera la valeur retournée au programme appelant.

Modificateurs	C   N

Opérande	(aucun)

Exemple :

(* l'exemple suivant teste la valeur d'un sélecteur analogique (0 ou 1 ou 2) *)

(* et force une parmi 3 variables booléennes. Le test "égal à 0" est réalisé *)

(* par l'instruction JMPC *)

RETex:	LD	selector	(* selector = 0 ou 1 ou 2 *)

BOO	(* conversion en booléen *)

JMPC	test1	(* si selector = 0 alors *)

LD	true

ST	bo0	(* bo0 := true *)

RET	(* fin - retourne 0 *)

test1:	LD	selector	(* décrémente selector *)

SUB	1	(* selector = 0 ou 1 *)

BOO	(* conversion en booléen *)

JMPC	test2	(* si selector = 0 alors *)

LD	true

ST	bo1	(* bo1 := true *)

LD	1	(* valeur de selector *)

RET	(* fin - retourne 1 *)

(* dernière possibilité *)

test2:	RETNC	(* retour si selector contient *)

(* une valeur invalide *)

LD	true

ST	bo2	(* bo2 := true *)

LD	2	(* valeur de selector *)

(* fin - retourne 2 *)


Opérateur ")"

Opération 	Exécute une opération différée

L'opération différée a été modifiée par "("

Modificateurs	(aucun)

Opérande	(aucun)

Exemple :

(* Exemple d'opérations différées imbriquées *)

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

Delayed:	LD	a1	(* résultat := a1; *)

ADD(	a2	(* ADD différé - résultat := a2; *)

MUL(	a3	(* MUL différé - résultat := a3; *)

SUB	a4	(* résultat := a3 - a4; *)

)	(* exécute MUL différé - résultat := a2 * (a3-a4); *)

MUL	a5	(* résultat := a2 * (a3 - a4) * a5; *)

)	(* exécute ADD différé *)

(* résultat := a1 + (a2 * (a3 - a4) * a5); *)

ADD	a6	(* résultat := a1 + (a2 * (a3 - a4) * a5) + a6; *)

ST	res	(* res := résultat courant *)


Appel de fonctions ou de sous-programmes

Pour appeler un sous-programme ou une fonction (écrit en langage IL, ST, LD ou FBD) depuis un programme IL, il suffit d'utiliser son nom comme une opération.

Opération	Exécute un sous-programme ou une fonction. La valeur retournée par le sous-programme ou la fonction est chargée dans le résultat courant.

Modificateurs	(aucun)

Opérande	Le premier paramètre d'appel doit être stocké dans le résultat courant. Les paramètres suivants sont exprimés dans le champ opérande, séparés par des virgules.

Exemple :

(* Appel de sous-programme : conversion analogique > temporisation *)

Main:	LD	bi0

SUBPRO	bi1,bi2	(* Appel sous-programme pour avoir la valeur ana *)

ST	result	(* resultat := valeur rendue par le sous-programme *)

GT	vmax	(* test de dépassement *)

RETC	(* retour si dépassement *)

LD	result

MUL	1000	(* conversion secondes > milli-secondes *)

TMR	(* conversion en temporisation *)

ST	tmval	(* stockage dans une variable temporisation *)

(* Sous-programme nommé 'SUBPRO' : évalue la valeur analogique *)

(* valeur binaire codée sur trois bits donnés par trois variables d'entrée : in0, in1, in2. Ce sont les paramètres d'entrée du sous-programme *)

LD	in2

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

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

ST	temporary	(* temporary := result *)

LD	in1

ANA

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

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

ST	temporary	(* temporary := result *)

LD	in0

ANA

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

ST	SUBPRO	(* retourne le résultat courant au programme appelant *)


Opérateur CAL: appel de bloc fonctionnel

Operation	appel un bloc fonctionnel

Modificateur	C   N

Opérande	Nom de l'instance du bloc fonctionnel

Vous devez assignez les paramètres d'entrée du bloc avant de l'appeler en utilisant les séquences d'opérations LD/ST.

Les paramètres de sortie seront connus s'ils sont utilisés.

Exemple1:

(* Appel du bloc fonctionnel SR : SR1 est une instance de SR *)

LD	auto_mode

AND	start_cmd

ST	SR1.set1

LD	stop_cmd

ST	SR1.reset

CAL	SR1

LD	SR1.Q1

ST	command

(* Equivalent FBD : *)

Exemple 2

(* R_TRIG1 est une instance du bloc R_TRIG et CTU1 est une instance du bloc 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

(* Equivalent FBD : *)


 Langage ST

Le langage ST (Structured Text) est un langage textuel de haut niveau dédié aux applications d'automatisation. Ce langage est principalement utilisé pour décrire les procédures complexes, difficilement modélisables avec les langages graphiques. Le ST est le langage par défaut pour la programmation des actions dans les étapes et des conditions associées aux transitions du SFC.

Syntaxe du ST

Expressions et parenthèses

Appels de fonctions et de blocs fonctionnels

Opérateurs booléens du ST

Enoncés du ST

Extensions au ST


Syntaxe du ST

Un programme ST est une suite d'énoncés. chaque énoncé est terminé par un point virgule (";").Les noms utilisés dans le code source (identificateurs de variables, constantes, mots clés du langage...) sont délimités par des séparateurs passifs (espace, fin de ligne ou tabulation) ou des séparateurs actifs, qui ont un rôle d'opérateur. Des commentaires peuvent être librement insérés dans la programmation. Un commentaire doit commencer par les caractères "(*" et se terminer par "*)". Chaque énoncé est terminé par un point virgule (";"). Voici les types d'énoncés standards du ST :

- assignation (variable := expression;)

- appel de sous-programme ou de fonction

- appel de blocs fonctionnel

- énoncés de sélection (IF, THEN, ELSE, CASE)

- énoncés d'itération (FOR, WHILE, REPEAT)

- énoncés de contrôle (RETURN, EXIT)

- énoncés spéciaux pour le lien avec le langage SFC

Des séparateurs passifs peuvent être librement insérés entre les séparateurs actifs, les expressions constantes et les identificateurs. Ces séparateurs sont l'espace (caractère blanc), les caractère de tabulation et de fin de ligne. Contrairement aux langages formatés en lignes tels que le IL, des caractères de fin de ligne peuvent être insérés partout dans le programme. Il est recommandé de respecter les règles suivantes quand vous utilisez les séparateurs passifs, pour assurer une bonne lisibilité du code source :

- Ne pas écrire plusieurs énoncés sur la même ligne

- Utiliser les tabulations pour indenter les structures de contrôle

- Insérer des commentaires

Lisibilité du code source - exemples:

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


Expressions et parenthèses

Les expressions ST combinent des opérateurs et des opérandes variables ou constants. Pour chaque expression simple (combinant des opérandes avec un opérateur ST), le typage des opérandes doit être cohérent. L'expression simple a un type donné par ses opérandes et l'opérateur mis en oeuvre, et pourra être utilisée dans une expression plus complexe. Par exemple :

(boo_var1 AND boo_var2)	a le type BOOLEEN

not (boo_var1)	a le type BOOLEEN

(sin (3.14) + 0.72)	a le type analogique REEL

(t#1s23 + 1.78)	est une expression invalide

Les parenthèses sont utilisées pour isoler des parties d'une expression, et donner explicitement un ordre d'évaluation des opérations. Quand aucune parenthèses n'est insérée, l'ordre d'évaluation est donné par la priorité entre les opérateurs du ST. Par exemple :

2 + 3 * 6 	égale 2+18=20	parce que la multiplication est plus prioritaire

(2+3) * 6	égale 5*6=30	priorité indiquée par les parenthèses

Attention: Vous ne pouvez pas imbriquer plus de 8 niveaux de parenthèses dans la même expression.


Appels de fonctions et de blocs fonctionnels

La convention d'appel du ST pour les fonctions concerne les objets suivants:

- Sous-programmes

- Fonctions ou blocs fonctionnels de la librairie écrits en langage IEC

- Fonctions et blocs fonctionnels en "C"

- Fonctions de conversion de type

Appel de sous-programmes et de fonctions

Appel de blocs fonctionnels


Appel de sous-programmes et de fonctions

Nom:	nom du sous-programme appelé

(ou fonction de librairie en langage IEC ou en "C")

Fonction:	appelle un sous-programme ou une fonction en ST, IL, LD ou FBD

et rend sa valeur de retour

Syntaxe:	<var_ana> := <ssprog> (<par1>, ... <parN> );

Opérandes:	la valeur de retour et les valeurs passées doivent respecter le typage des paramètres

Retour:	valeur retournée par le sous-programme

Un appel de sous-programme peut être inclus dans une expression complexe ou une condition SFC.

Exemple1 : appel de sous-programme

(* Programme appelant, écrit en ST *)

(* acquisition d'une valeur analogique et conversion en temporisation *)

ana_timeprog := SPlimit ( tprog_cmd );

appl_timer := tmr (ana_timeprog * 100);

(* Programme appelé, nommé 'SPlimit', écrit en FBD *)

Exemple2: appel de fonction

(* les fonctions utilisées dans les expressions complexes: min, max, right, mlen et left sont des fonctions "C" standard *)

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

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


Appel de blocs fonctionnels

Nom:	nom de l'instance du bloc fonctionnel

Fonction:	appelle un bloc fonctionnel de la librairie ISaGRAF ou de la librairie utilisateur et accède à ses paramètres de retour

Syntaxe:	(* appel du bloc *)

<nom_bloc> ( <pa1>, <pa2> ... );

(* récupère les paramètres de sortie *)

<result> := <nom_bloc>. <param_ret_1>;

...

<result> := <nom_bloc>. <nom_ret_N>;

Opérandes:	les paramètres d'appel et l'affectation des paramètres de retour doivent respecter les types définis dans l'interface du bloc fonctionnel.

Retour:	Voir la syntaxe pour récupérer les paramètres de sortie.

Consultez la librairie ISaGRAF pour connaître le rôle et l'interface précis de chaque bloc fonctionnel. L'instance du bloc fonctionnel (nom de la copie) doit être déclarée dans le dictionnaire.

Exemple :

(* Programme ST avec appel de bloc fonctionnel *)

(* déclaration de l'instance dans le dictionnaire: *)

(* trigb1 : bloc R_TRIG - détection de front montant *)

(* activation du bloc fonctionnel en ST  *)

trigb1 (b1);

(* accès aux paramètres de retour *)

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


Opérateurs booléens du ST

Les opérateurs suivants sont spécifiques au langage ST:

REDGE	détection de front montant

FEDGE	détection de front descendant

Les opérateurs booléens suivants:

- NOT	inversion booléenne

- AND (&)	ET logique

- OR	OU logique

- XOR	OU exclusif logique

peuvent être utilisés. Leur description est détaillée dans le chapitre "Opérateurs, blocs fonctionnels et fonctions standard".


Opérateur "REDGE"

Nom:	REDGE

Fonction:	évalue le front montant d'une expression booléenne

Syntaxe:	<front> := REDGE ( <expression_boo>, <variable_memo> );

Opérandes:	le premier opérande est une variable booléenne ou toute expression booléenne complexe

le second opérande est une variable booléenne interne utilisée pour mémoriser l'état précédent de l'expression

Retour:	TRUE quand l'expression passe de FALSE à TRUE

FALSE dans tous les autres cas

Le front montant d'une expression ne peut être détecté qu'une seule fois, avec la fonction REDGE, dans le même cycle d'exécution.

Attention: La variable "mémoire" utilisée pour stocker l'état précédent de l'expression ne doit pas être utilisée dans les calculs de front pour d'autres expressions.

Quand l'expression est une variable booléenne nommée "xxx", déclarez une variable interne nommée "EDGE_xxx" dédiée aux opérations REDGE et FEDGE pour cette variable. Cette méthode évite les conflits entre variables pendant les calculs de détection de fronts.

Exemple :

(* Programme ST avec opérateur REDGE *)

(* ce programme compte les fronts montants d'une entrée booléenne *)

(* Bi120 est le nom de la variable d'entrée *)

(* Edge_Bi120 est la variable utilisée pour mémoriser l'état de Bi120 *)

If REDGE (Bi120, Edge_Bi120) Then

Counter := Counter + 1;

End_if;

Remarque: cet opérateur ne fait pas partie de la norme CEI 1131-3. Préférez le bloc standard R_TRIG. Cet opérateur a été conservé pour des raisons de compatibilité.


Opérateur "FEDGE"

Nom:	FEDGE

Fonction:	évalue le front descendant d'une expression booléenne

Syntaxe:	<front> := FEDGE ( <expression_boo>, <variable_memo> );

Opérandes:	le premier opérande est une variable booléenne ou toute expression booléenne complexe

le second opérande est une variable booléenne interne utilisée pour mémoriser l'état précédent de l'expression

Retour:	TRUE quand l'expression passe de TRUE à FALSE

FALSE dans tous les autres cas

Le front descendant d'une expression ne peut être détecté qu'une seule fois, avec la fonction FEDGE, dans le même cycle d'exécution.

Attention: La variable "mémoire" utilisée pour stocker l'état précédent de l'expression ne doit pas être utilisée dans les calculs de front pour d'autres expressions.

Quand l'expression est une variable booléenne nommée "xxx", déclarez une variable interne nommée "EDGE_xxx" dédiée aux opérations REDGE et FEDGE pour cette variable. Cette méthode évite les conflits entre variables pendant les calculs de détection de fronts.

Exemple :

(* Programme ST avec opérateur FEDGE *)

(* ce programme compte les fronts descendants d'une entrée booléenne *)

(* Bi120 est le nom de la variable d'entrée *)

(* Edge_Bi120 est la variable utilisée pour mémoriser l'état de Bi120 *)

If FEDGE (Bi120, Edge_Bi120) Then

Counter := Counter + 1;

End_if;

Remarque: cet opérateur ne fait pas partie de la norme CEI 1131-3. Préférez le bloc standard F_TRIG. Cet opérateur a été conservé pour des raisons de compatibilité.


Enoncés du ST

Voici les types d'énoncés du langage ST :

Assignation

Enoncé RETURN

Structure IF-THEN-ELSIF-ELSE

Enoncé CASE

Enoncé d'itération WHILE

Enoncé d'itération REPEAT

Enoncé d'itération FOR

Enoncé EXIT


Assignation

Nom:	:=

Fonction:	assigne une variable avec une expression

Syntaxe:	<variable> := <expression> ;

Opérandes:	la variable doit être interne ou de sortie

la variable et l'expression doivent avoir le même type

L'expression peut être un appel à un sous-programme ou à une fonction de la librairie ISaGRAF

Exemple :

(* Programme ST - exemple d'assignations *)

(* variable <<= variable *)

bo23 := bo10;

(* variable <<= expression *)

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

result := (100 * input_value) / scale;

(* assignation avec retour de sous-programme *)

rc := PSelect ( );

(*assignation avec retour de fonction *)

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


Enoncé RETURN

Nom:	RETURN

Fonction:	Termine l'exécution du programme

Syntaxe:	RETURN ;

Opérandes:	(aucun)

Si l'énoncé RETURN apparaît dans un bloc d'action SFC, la terminaison ne concerne que ce bloc d'action.

Exemple :

(* Spécifications FBD du programme: compteur programmable *)

(* implémentation ST du programme, avec énoncé RETURN *)

If not (CU) then

Q := false;

CV := 0;

RETURN; (* fin du programme *)

end_if;

if R then

CV := 0;

else

if (CV < PV) then

CV := CV + 1;

end_if;

end_if;

Q := (CV >= PV);


Structure IF-THEN-ELSIF-ELSE

Nom:	IF ... THEN ... ELSIF ... THEN ... ELSE ... END_IF

Fonction:	Exécute une parmi deux listes d'énoncés ST.

La sélection est effectuée en fonction de l'état d'une expression booléenne

Syntaxe:	IF <expression_booleenne> THEN

   <enonce> ;

   <enonce> ;

   ...

ELSIF <expression_booleenne> THEN

   <enonce> ;

   <enonce> ;

   ...

ELSE

   <enonce> ;

   <enonce> ;

   ...

END_IF;

Les énoncés ELSE et ELSIF sont optionnels. Si ELSE est omis, aucune instruction n'est exécutée quand l'expression de sélection prend la valeur FALSE.

Exemple :

(* Programme ST avec énoncé 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;

(* Structure IF sans ELSE *)

If overflow THEN

alrm_level := true;

END_IF;


Enoncé CASE

Nom:	CASE ... OF ... ELSE ... END_CASE

Fonction:	exécute une parmi plusieurs liste d'énoncés ST

la sélection est faite en accord avec la valeur d'une expression analogique entière

Syntaxe:	CASE <expression_entiere> OF

   <valeur> : <enonces> ;

   <valeur> , <valeur> : <enonces> ;

   ...

ELSE

   <enonces> ;

END_CASE;

Les valeurs de sélection doivent être des expressions constantes entières. Plusieurs valeurs de sélection, séparées par des virgules, peuvent mener à la même liste d'énoncés. L'énoncé ELSE est optionnel.

Exemple:

(* Programme ST avec énoncé CASE *)

CASE error_code OF

255:	err_msg := 'Division by zero';

fatal_error := TRUE;

1:	err_msg := 'Overflow';

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

ELSE

err_msg := 'Unknown error';

END_CASE;


Enoncé d'itération WHILE

Nom:	WHILE ... DO ... END_WHILE

Fonction:	Enoncé d'itération avec test en début de boucle.

Syntaxe:	WHILE <expression_booleenne> DO

   <enonce> ;

   <enonce> ;

   ...

END_WHILE ;

Attention: ISaGRAF étant un système synchrone, les variables d'entrées ne sont pas rafraîchies pendant les itérations d'une boucle WHILE. Il ne faut jamais tester l'évolution d'une variable d'entrée dans la condition d'une structure WHILE.

Exemple :

(* Programme ST avec énoncé WHILE *)

(* ce programme utilise des procédures "C" spécifiques pour lire *)

(* des caractères sur un port de communication série *)

string := ''; (* chaîne vide *)

nbchar := 0;

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

string := string + ComGetChar ( );

nbchar := nbchar + 1;

END_WHILE;


Enoncé d'itération REPEAT

Nom:	REPEAT ... UNTIL ... END_REPEAT

Fonction:	Enoncé d'itération avec test d'itération en fin de boucle.

Syntaxe:	REPEAT

   <enonce> ;

   <enonce> ;

  ...

UNTIL <condition_booleenne>

END_REPEAT ;

Attention: ISaGRAF étant un système synchrone, les variables d'entrées ne sont pas rafraîchies pendant les itérations d'une boucle REPEAT. Il ne faut jamais tester l'évolution d'une variable d'entrée dans la condition d'une structure REPEAT.

Exemple :

(* Programme ST avec énoncé REPEAT *)

(* ce programme utilise des procédures "C" spécifiques pour lire	*)

(* des caractères sur un port de communication série	*)

string := ''; (* chaîne vide *)

nbchar := 0;

IF ComIsReady ( ) THEN

REPEAT

string := string + ComGetChar ( );

nbchar := nbchar + 1;

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

END_REPEAT;

END_IF;


Enoncé d'itération FOR

Nom:	FOR ... TO ... BY ... DO ... END_FOR

Fonction:	Structure d'itération utilisant une variable d'index de type analogique entier

Syntaxe:	FOR <index> := <mini> TO <maxi> BY <pas>

DO

   <enonce> ;

   <enonce> ;

END_FOR;

Opérandes:	index:	variable analogique interne incrémentée

à chaque itération

mini:	valeur initiale de la variable d'index

(valeur lors de la première itération)

maxi:	valeur maximum autorisée pour l'index

pas:	pas d'incrémentation de l'index

(à chaque itération)

La mention [ BY pas ] est optionnelle. Lorsqu'il n'est pas spécifié, le pas d'incrément par défaut est 1.

Attention: ISaGRAF étant un système synchrone, les variables d'entrées ne sont pas rafraîchies pendant les itérations d'une boucle FOR.

Voici l'équivalent "While" d'un énoncé FOR :

index := mini;

while (index <= maxi) do

   <enonce> ;

   <enonce> ;

   index := index + pas;

end_while;

Exemple :

(* Programme ST avec énoncé FOR *)

(* Ce programme extrait les caractères "chiffres" d'une chaîne *)

length := mlen (message);

target := ''; (* chaîne vide *)

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;


Enoncé EXIT

Nom:	EXIT

Fonction:	quitte une boucle d'itération FOR, WHILE ou REPEAT

Syntaxe:	EXIT;

L'énoncé EXIT est généralement utilisé dans un énoncé de sélection IF, à l'intérieur d'un bloc FOR, WHILE ou REPEAT.

Exemple:

(* Programme ST avec énoncé EXIT *)

(* ce programme recherche un caractère dans une chaîne *)

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;


Extensions au ST

Les énoncés et fonctions suivants sont des extensions du langage ST.

TSTART - TSTOP: contrôle des temporisations

Les énoncés suivants permettent à un programme SFC père, dans ses actions, de contrôler un programme SFC fils. Ils peuvent être utilisés dans les blocs ACTION(): ... END_ACTION; des étapes SFC.

GSTART	lance un programme SFC

GKILL	tue un programme SFC

GFREEZE	fige un programme SFC

GRST	relance un programme SFC

GSTATUS	donne l'état d'un programme SFC

Attention: Ces fonctions ne font pas partie de la norme CEI 1131-3.

Voici des équivalents simples pour les énoncés GSTART et GKILL dans les étapes SFC:

sfc_fils(S); (*équivalent à GSTART(sfc_fils); *)

sfc_fils(R); (*équivalent à GKILL(sfc_fils); *)

Les champs suivants d'une étape SFC peuvent être testés dans des expressions:

GSnnn.x	est une valeur booléenne qui représente l'activité de l'étape

GSnnn.t	est une valeur temporelle qui représente le temps écoulé depuis que l'étape est active: durée d'activation.

("nnn" est le numéro de référence de l'étape SFC)

Il est également possible de tester l'activité d'une étape déclarée dans un autre programme SFC, en utilisant la syntaxe suivante:

GSnnn(nomprog).x

Attention: référencer une étape d'un autre programme, en utilisant cette syntaxe de fait pas partie de la norme CEI 1131-3. Une façon simple d'obtenir le même résultat en respectant la norme, est de déclarer une variable booléenne globale dans le dictionnaire. Cette variable représentera l'activité de l'étape à tester (par exemple ref_step_X). Ensuite vous insérez cette variable dans l'étape avec le qualificatif N (ref_step_X(N);). Puis dans le programme qui a besoin de tester l'activité de l'étape, vous utilisez la variable.

programme Prog	programme qui a besoin de tester

l'activité de l'étape du programme Prog


Enoncé TSTART

Nom:	TSTART

Fonction:	Valide le rafraîchissement automatique d'une tempo.

La valeur courante de la temporisation n'est pas modifiée par l'énoncé TSTART, i.e. le comptage démarre à partir de la valeur courante.

Syntaxe:	TSTART ( <variable_tempo> );

Opérandes:	toute variable temporisation inactive

Retour:	(aucun)

Exemple :

(* Exemple d'utilisation des énoncés TSTART et TSTOP *)

Diagramme de temps si bi100 est toujours à FALSE:

La temporisation garde la même valeur pendant la durée du cycle.


Enoncé TSTOP

Nom:	TSTOP

Fonction:	Stoppe le rafraîchissement automatique d'une tempo.

La valeur de la variable n'est pas modifiée par la commande TSTOP.

Syntaxe:	TSTOP ( <variable_tempo> );

Opérandes:	toute variable temporisation activée par TSTART

Retour:	(aucun)

Exemple : Voir TSTART (fonction décrite ci-dessus)


Enoncé GSTART

Nom:	GSTART

Fonction:	Lance un programme SFC fils en plaçant un jeton dans chacune de ses étapes initiales

Syntaxe:	GSTART ( <programme_fils> );

Opérandes:	Le programme SFC spécifié doit être le fils du programme incluant l'énoncé GSTART.

Retour:	(aucun)

Les fils du programme lancé par GSTART ne sont pas automatiquement lancés avec lui.

Remarque: comme GSTART ne fait pas partie de la norme CEI 1131-3, préférez l'utilisation du qualificatif S et la syntaxe suivante pour lancer un programme SFC fils:

SFC_fils(S);

Exemple d'utilisation de GSTART et GKILL :

(* Séquence 'Sfather' *)	(* Séquence 'Schild' *)


Enoncé GKILL

Nom:	GKILL

Fonction:	Tue un programme SFC fils en supprimant tous les jetons existant dans ses étapes

Syntaxe:	GKILL ( <programme_fils> );

Opérandes:	Le programme SFC spécifié doit être le fils du programme incluant l'énoncé GKILL.

Retour:	(aucun)

Les fils du programme tué sont automatiquement tués avec lui.

Remarque: comme GKILL ne fait pas partie de la norme CEI 1131-3, préférez l'utilisation du qualificatif R et la syntaxe suivante;

SFC_fils(R);

Exemple d'utilisation de GSTART et GKILL :

(* Séquence 'Sfather' *)	(* Séquence 'Schild' *)


Enoncé GFREEZE

Nom:	GFREEZE

Fonction:	Suspend l'exécution d'un programme fils SFC. Le programme figé pourra être relancé en utilisant la commande GRST.

Syntaxe:	GFREEZE ( <programme_fils> );

Opérandes:	Le programme SFC spécifié doit être le fils du programme

incluant l'énoncé GFREEZE.

Retour:	(aucun)

Les fils du programme fils sont automatiquement "gelés" en même temps que le programme spécifié.

Remarque: GFREEZE ne fait pas partie de la norme CEI 1131-3.

Exemple :


Enoncé GRST

Nom:	GRST

Fonction:	Relance un programme SFC fils figé par une commande GFREEZE.

Syntaxe:	GRST ( <programme_fils> );

Opérandes:	Le programme SFC spécifié doit être le fils du programme incluant l'énoncé GRST.

Retour:	(aucun)

Les fils du programme fils sont automatiquement "relancés" en même temps que le programme spécifié.

Remarque: GRST ne fait pas partie de la norme CEI 1131-3.

Exemple :


Enoncé GSTATUS
GSTATUS statement

Nom:	GSTATUS

Fonction:	Rend l'état courant d'un programme SFC.

Syntaxe:	<var_ana> := GSTATUS ( <programme_fils> );

Opérandes:	Le programme SFC spécifié doit être le fils du programme incluant l'appel à GSTATUS.

Retour:	0 = le programme est inactif (tué)

1 = le programme est actif (lancé)

2 = le programme est figé

Remarque: GSTATUS ne fait pas partie de la norme CEI 1131-3.

Exemple :


 Langage FBD

Le FBD (Function Block Diagram) est un langage graphique. Il permet la construction d'équations complexes à partir des fonctions élémentaires des librairies ISaGRAF.

Format du diagramme

Symbole "Return"

Sauts et étiquettes

Inversion booléenne

Appel de fonctions et de blocs fonctionnels


Format du diagramme

Le diagramme FBD décrit une fonction entre des variables d'entrée et des variables de sortie. Une fonction est décrite comme un réseau de fonctions élémentaires. Les variables d'entrée et de sortie sont connectées aux boîtes fonctions par des arcs de liaison. Une sortie d'une boîte peut être connectée sur une entrée d'une autre boîte.

La fonction complète représentée par un programme FBD est construite à l'aide de boîtes fonctions élémentaires de la librairie ISaGRAF. Chaque boîte fonction élémentaire a une nombre prédéfini de points de connexion en entrée et en sortie. Une boîte fonction est représenté par un rectangle. Ses entrées sont connectées sur le bord gauche du rectangle. Ses sorties sont connectées sur le bord droit. Une boîte fonction élémentaire réalise une fonction élémentaire entre ses entrées et ses sorties. Le nom de la fonction réalisée est inscrite dans le rectangle de la boîte. Chaque entrée ou sortie de la boîte est caractérisée par un type.

Les variables d'entrée du diagramme FBD doivent être connectées aux entrées des boîtes fonctions. Le type de chaque variable doit être cohérent avec le type de l'entrée de la boîte correspondante. Une entrée pour le diagramme FBD peut être une expression constante, toute variable interne, d'entrée ou de sortie

Les variables de sortie du diagramme FBD doivent être connectées aux sorties des boîtes fonctions. Le type de chaque variable doit être cohérent avec le type de la sortie de la boîte correspondante. Une sortie pour le diagramme FBD peut être une variable interne ou de sortie, ou le nom du programme édité (pour les sous-programmes seulement) Quand le nom du sous-programme édité est utilisé comme sortie du diagramme, il représente une assignation de la valeur retournée par le sous-programme.

Les variables d'entrée et de sortie, les entrées et les sorties des boîtes fonctions sont reliées par des arcs de liaison. Des lignes sont utilisées pour représenter les liaisons entre deux points du diagramme :

- Une variable d'entrée et une entrée de boîte

- Une sortie d'une boîte et une entrée d'un autre boîte

- Une sortie de boîte et une variable de sortie

Les liaisons sont orientées : une liaison transporte une information depuis son extrémité gauche vers son extrémité droite. Les extrémités gauche et droite doivent être connectées à des éléments de même type.

Des liaisons multiples à droite sont utilisées pour transmettre une information depuis une extrémité à gauche vers plusieurs points à droite. Toutes les extrémités de la liaison doivent avoir le même type.


Symbole "Return"

Le mot clé "<RETURN>" peut apparaître comme une sortie du diagramme. Il doit être connecté à une sortie booléenne d'une boîte fonction. L'énoncé RETURN représente une terminaison conditionnelle de l'exécution du programme : si la liaison connectée prend l'état booléen TRUE, la fin du diagramme n'est pas interprétée. Voici un exemple d'énoncé RETURN :

(* Equivalence ST *)

If auto_mode OR alarm Then

Return;

End_if;

bo67 := (bi10 AND bi23) OR x_cmd;


Sauts et étiquettes

Les étiquettes et les sauts conditionnels, sont utilisés pour contrôler l'exécution du diagramme. Aucune connexion ne peut être réalisée à droite d'un symbole d'étiquette ou de saut.

>>LAB	saut à une étiquette (le nom de l'étiquette est "LAB")

LAB:	définition d'une étiquette (nommée "LAB")

Si la liaison à gauche du symbole de saut prend l'état booléen VRAI, l'exécution du programme est déroutée après l'étiquette correspondante. Voici un Exemple d'utilisation de sauts et étiquettes:

(* Equivalence IL: *)

ld	manual

and	b1

jmpc	NOMODIF

ld	input1

or	input2

st	result

NOMODIF:	ld	result

and	valid

st	cmd10


Inversion booléenne

Un arc de liaison simple, connecté à une entrée booléenne d'une boîte fonction, peut être terminé par un symbole d'inversion booléenne. L'inversion est représentée par un petit cercle. Quand une inversion booléenne est utilisée, les extrémités gauche et droite de l'arc concerné doivent être de type booléen. Voici un exemple d'utilisation d'une inversion booléenne:

(* Liaison avec inversion booléenne *)

(* Equivalence ST: *)

output1 := input1 AND NOT (input2);


Appel de fonctions et de blocs fonctionnels

Le langage FBD permet l'appel de sous-programmes, de fonctions ou de blocs fonctionnels. Un sous-programme, une fonction ou un bloc fonctionnel est représenté comme une boîte fonction. Le nom de la boîte est le nom du sous-programme, de la fonction ou du bloc fonctionnel.

Dans le case d'un sous-programme ou d'une fonction, la valeur rendue par le sous-programme est la seule sortie de la boîte. Un bloc fonctionnel peut avoir plusieurs sorties.

Voici un exemple d'appel de sous-programme:

(* Equivalence ST *)

net_weight := Weighing (mode, delta); (*appel d'un sous-programme *)

If (net_weight = 0) Then Return; End_if;

weight := net_weight + tare_weight;


 Langage SFC

Le langage SFC (Sequential Function Chart) ou GRAFCET est un langage graphique utilisé pour décrire les opérations séquentielles. Le procédé est représenté comme une suite connue d'étapes (états stables), reliées entre elles par des transitions. Une condition booléenne est attachée à chaque transition. Les actions dans les étapes sont décrites avec les langages ST, IL, LD ou FDB.

Format du graphe SFC

Composants du langage SFC

Divergences et convergences

Macro-étapes

Actions dans les étapes

Conditions attachées aux transitions

Règles dynamiques du SFC

Hiérarchie de programmes SFC


Format du graphe SFC

Un programme SFC est un réseau graphique d'étapes et de transitions, reliées par des liaisons orientées. Les liens de connexion multiples sont représentés par des divergences et des convergences. Certaines parties du graphe peuvent être isolées, et représentées dans le graphe principal par un seul symbole, nommé macro-étape. Les principales règles graphiques du langage SFC sont :

- une étape ne peut pas être suivie d'une autre étape

- une transition ne peut pas être suivie d'une autre transition


Composants du langage SFC

Voici les composants de base (symboles graphiques) du graphe SFC: étapes et étapes initiales, transitions, liaisons orientées et renvois à une étape.

Etapes et étapes initiales

Transitions

Liaisons orientées

Renvoi à une étape


Etapes et étapes initiales

Une étape est représentée par un carré. Chaque étape est référencée par un numéro. Ce numéro est inscrit dans le cadre de l'étape. Une description générale de l'étape est écrite dans un rectangle relié au symbole de l'étape. Cette description est un commentaire libre (pas de langage de programmation). Toutes ces informations constituent le niveau 1 de l'étape :

A l'exécution, un jeton indique si l'étape est active :

Etape active:	Etape inactive:

La situation initiale d'un programme SFC est représentée par ses étapes initiales. Le symbole d'une étape initiale a un cadre double. Un jeton est automatiquement posé dans chaque étape initiale quand le programme est lancé.

Etape initiale:

Un programme SFC doit contenir au moins une étape initiale. Voici les attributs d'une étape. Ces champs peuvent être testés depuis tous les langages :

GSnnn.x	activité de l'étape (valeur booléenne)

GSnnn.t	durée d'activité de l'étape (valeur temporelle)

(nnn est le numéro de référence de l'étape)


Transitions

Une transition est représentée par une barre horizontale qui croise un arc de liaison. Chaque transition est référencée par un numéro. Ce numéro est inscrit à côté du symbole de la transition. Une description générale de la transition est inscrite à la droite de son symbole. C'est un commentaire libre (pas de langage de programmation). Toutes ces informations constituent le niveau 1 de la transition :


Liaisons orientées

De simple lignes sont utilisées pour représenter les liaisons orientées entre les étapes et les transitions. Quand l'orientation n'est pas explicitement donnée, le lien est orienté du haut vers le bas.


Renvoi à une étape

Un symbole de renvoi peut être utilisé pour représenter un arc de liaison d'une transition vers une étape, sans tracer le lien. Le symbole du renvoi doit être référencé avec le numéro de référence de l'étape de destination :

Vous ne pouvez pas utiliser de symbole de renvoi vers une transition. Exemple de renvois - les graphes suivants sont équivalents :


Divergences et convergences

Les divergences sont des liaisons multiples depuis un symbole SFC (étape ou transition) vers plusieurs autres symboles SFC. Les convergences sont des liaisons multiples depuis plusieurs symboles SFC vers un même symbole. On distingue deux types de divergences et de convergences: simples ou doubles.

Divergences simples

Divergences doubles


Divergences simples

Une divergence simple est une liaison multiple depuis une étape vers plusieurs transitions. Elle représente plusieurs possibilités dans le séquencement du procédé. Une convergence simple est une liaison multiple depuis plusieurs transitions vers la même étape. Une convergence simple est généralement utilisée pour regrouper les branches ouvertes sur une divergence simple. Les divergences et convergences simples sont représentées par des lignes horizontales simples.

Attention: Les conditions attachées aux différentes transitions qui débutent les branches de la divergence ne sont pas implicitement exclusives. Il faut détailler l'exclusivité explicitement dans chacune de ces conditions pour s'assurer qu'un seul jeton SFC sera créé, dans l'une des branches de la divergence, quand celle-ci sera franchie. Voici un exemple de divergence et de convergence simples :

(* Programme SFC avec divergence et convergence simples *)


Divergences doubles

Une divergence double est une liaison multiple depuis une transition vers plusieurs étapes. Elle représente généralement des opérations parallèles dans le séquencement du procédé. Une convergence double est une liaison multiple depuis plusieurs étapes vers la même transition. Une convergence double est généralement utilisée pour regrouper les branches ouvertes sur une divergence double. Les divergences et convergences doubles sont représentées par des lignes horizontales doubles.

Voici un exemple de divergence et de convergence doubles:

(* Programme SFC avec divergence et convergence doubles *)


Macro-étapes

Une macro-étape est une représentation par un symbole unique d'un groupe unique d'étapes et de transitions. Le corps de la macro-étape est décrit séparément, ailleurs dans le même programme SFC. Elle apparaît comme un symbole unique dans le graphe principal. Voici le symbole utilisé pour représenter une macro-étape :

Le numéro de référence écrit dans le symbole de la macro-étape est le numéro de référence de la première étape du corps de la macro. Le corps d'une macro-étape doit commencer par une étape de début et se terminer par une étape de fin. Le graphe doit être connexe. Une étape de début n'a pas de liaison en amont (pas de transition précédente). Une étape de fin n'a pas de liaison en aval (pas de transition suivante). Un symbole de macro-étape peut apparaître dans le corps d'une autre macro-étape.

Attention: Puisqu'une macro-étape représente un groupe unique d'étapes et de transitions, la même macro-étape ne peut pas apparaître plusieurs fois dans le même programme SFC.

Voici un exemple de macro-étape :

(* Programme SFC incluant une macro-étape *)

(* Schéma principal *)	(* Corps de la macro-étape *)


Actions dans les étapes

Le niveau 2 d'une étape SFC est la description détaillée des actions exécutées quand l'étape est active. Cette description est réalisée à l'aide des structures littérales du SFC, et des autres langages, tels que le ST (Structured Text). Voici les différents types d'action :

Actions booléennes

Actions impulsionnelles

Actions non mémorisées

Actions SFC

Plusieurs actions (de même type ou de type différent) peuvent être décrites dans la même étape. Les structures suivantes permettent d'intégrer des traitements décrits dans d'autres langages :

Appel de fonction ou de bloc fonctionnel

Convention IL


Actions booléennes

Une action booléenne consiste à assigner à une variable booléenne le signal d'activité d'une étape (drapeau d'étape). La variable booléenne doit être interne ou de sortie. Elle est forcée à chaque fois que le signal d'activité de l'étape change d'état. Voici la syntaxe des actions booléennes non mémorisées:

<variable_bool> (N);	copie le signal d'activité de l'étape dans la variable

<variable_bool> ;	même effet (l'attribut N est optionnel)

/ <variable_bool> ;	copie l'inverse logique du signal d'activité de l'étape dans la variable

D'autres types d'actions consistent à forcer la variable (à faux ou à vrai) quand l'étape devient active. Voici la syntaxe de ces actions :

<variable_bool> (S) ;	force la variable à TRUE quand le signal d'activité de l'étape prend l'état TRUE

<variable_bool> (R) ;	force la variable à FALSE quand le signal d'activité de l'étape prend l'état TRUE

La variable booléenne doit être INTERNE ou de SORTIE. La programmation SFC suivante représente le comportement indiqué dans le chronogramme:

Exemple d'action booléenne :

(* Programme SFC avec actions booléennes *)


Actions impulsionnelles

Une action impulsionnelle est une liste d'instructions ST ou IL, exécutée une seule fois quand l'étape devient active. Les instructions sont écrites selon la syntaxe SFC suivante :

ACTION (P) :

(* Enoncés ST *)

END_ACTION ;

Voici le chronogramme d'une action de type P :

Exemple d'action impulsionnelle :

(* Programme SFC avec actions impulsionnelles *)


Actions non mémorisées

Une action normale (ou non mémorisée) est une liste d'instructions ST ou IL, exécutée à chaque cycle pendant toute la durée d'activité de l'étape. Les instructions sont écrites selon la syntaxe SFC suivante :

ACTION (N) :

(* Enoncés ST *)

END_ACTION ;

Voici le chronogramme d'une action de type N :

Exemple d'action normale :

(* Programme SFC avec actions normales *)


Actions SFC

Une action SFC est une séquence fille SFC, lancée ou tuée selon les évolutions du signal d'activité de l'étape. Une action SFC peut être décrite avec les qualificatifs d'action N (Non mémorisée), S (Set), ou R (Reset). Voici la syntaxe des actions SFC :

<progr_fils> (N) ;	lance la séquence fille quand l'étape devient active, et la tue lorsque l'étape redevient inactive

<progr_fils> ;	même effet (l'attribut N est optionnel)

<progr_fils> (S) ;	lance la séquence fille quand l'étape devient active.

rien n'est fait lorsque l'étape redevient inactive

<progr_fils> (R) ;	tue la séquence fille quand l'étape devient active.

rien n'est fait lorsque l'étape redevient inactive

La séquence SFC spécifiée dans l'action doit être un programme SFC fils du programme en cours d'édition. Notez que l'utilisation des qualificatifs S (Set) ou R (Reset) pour une action SFC a exactement le même effet que les énoncés GSTART et GKILL, programmés dans une action de type P (impulsionnelle) en ST.

Voici un exemple d'action SFC. Le programme SFC principal est nommé Princ. Il a deux programmes SFC fils, nommés SeqMlx et SeqPomp. Voici la programmation en SFC du programme principal :

(* Programme SFC avec actions SFC *)


Appel de fonction ou de bloc fonctionnel

Les sous-programmes, fonctions ou blocs fonctionnels (écrits en ST, IL, LD ou FBD), ou les fonctions ou blocs fonctionnels "C" peuvent être directement appelés depuis un bloc d'action, selon la syntaxe suivante :

Pour les sous-programmes, fonctions ou fonctions "C":

ACTION (P) :

<resultat> := <sous_programme> ( ) ;

END_ACTION;

ou

ACTION (N) :

<resultat> := <sous_programme> ( ) ;

END_ACTION;

Pour les blocs fonctionnels écrits en "C" ou en ST, IL, LD, FBD:

ACTION (P) :

Fbinst(in1, in2);

result1 := Fbinst.out1;

result2 := Fbinst.out2;

END_ACTION;

ou

ACTION (N) :

Fbinst(in1, in2);

result1 := Fbinst.out1;

result2 := Fbinst.out2;

END_ACTION;

Vous trouverez la syntaxe détaillées de ces appels dans le chapitre concernant le langage ST.

Exemple d'appel de sous-programme dans un bloc d'action :

(* Appel de sous-programme dans une action  SFC*)


Convention IL

La programmation en IL (Instruction List) peut être directement insérée dans un bloc d'action, selon la syntaxe suivante :

ACTION (P) :  (* ou N *)

#info=IL

<instruction>

<instruction>

....

#endinfo

END_ACTION;

Les mots clés "#info=IL" et "#endinfo" doivent être entrés exactement sous cette forme. Respectez les majuscules et les minuscules. N'insérez aucun caractère blanc ou tabulation avant ou après ces mots clés. Voici un exemple d'action programmée en IL :

(* Programme SFC avec action programmée en IL *)


Conditions attachées aux transitions

A chaque transition est attachée une expression booléenne, qui conditionne le franchissement de la transition. Les conditions sont généralement décrites en langage ST. C'est le niveau 2 de la transition. Mais d'autres conventions d'écriture sont autorisées :

Convention ST

Convention LD

Convention IL

Appel de fonction dans une transition

Attention: Quand aucune condition n'est attachée à une transition, sa réceptivité par défaut est TRUE (vraie).


Convention ST

Vous pouvez utiliser le langage ST (Structured Text) pour décrire la condition attachée à une transition. L'expression doit être du type booléen et doit être terminée par un point virgule, selon la syntaxe suivante :

< expression_booleenne > ;

L'expression peut être une valeur constante TRUE ou FALSE, une variable booléenne interne ou d'entrée, ou une combinaison de variables représentant une grandeur booléenne. Voici un exemple de transition programmée en ST :

(* Programme SFC avec conditions programmées en ST *)


Convention LD

Le langage LD (schéma à relais) peut être utilisé pour décrire une condition associée à une transition. Le schéma est alors composé d'un seul échelon contenant un seul relais. La valeur du relais représente la valeur de la transition. Voici un exemple de transition programmée en LD:


Convention IL

Le langage IL (Instruction List) peut directement être utilisé pour programmer la condition d'une transition, selon la syntaxe suivante :

#info=IL

<instruction>

<instruction>

....

#endinfo

La valeur contenue dans le résultat courant (registre IL) à la fin de la séquence programmée indique le résultat de la condition attachée à la transition :

résultat courant = 0 	 	condition = FALSE

résultat courant <> 0	condition = TRUE

Les mots clés "#info=IL" et "#endinfo" doivent être entrés exactement sous cette forme. Respectez les majuscules et les minuscules. N'insérez aucun caractère blanc ou tabulation avant ou après ces mots clés. Voici un exemple de condition programmée en IL :

(* Programme SFC avec transitions programmées en IL *)


Appel de fonction dans une transition

Un sous-programme ou une fonction (écrit en FBD, LD, ST ou IL) peut être appelé pour évaluer la condition attachée à une transition, selon la syntaxe suivante :

< sous_programme > ( ) ;

La valeur retournée par le sous-programme indique le résultat de la condition de franchissement de la transition :

valeur retournée = FALSE 	 	condition = FALSE

valeur retournée = TRUE	condition = TRUE

Voici un exemple d'appel de sous-programme dans une transition :

(* Programme SFC avec appel de sous-programme *)


Règles dynamiques du SFC

Voici les cinq règles d'évolution définies par le langage SFC :

 Situation initiale

La situation initiale est caractérisée par les étapes initiales qui définissent l'état du procédé au lancement de l'application. Il doit y avoir au moins une étape initiale dans un programme SFC.

 Franchissement d'une transition

Une transition est soit valide soit invalide. Elle est valide quand toutes les étapes immédiatement précédentes sont actives.

Une transition ne peut être franchie que si :

   - elle est valide, et

   - la condition associée est vraie.

 Evolution des étapes actives

Le franchissement d'une transition entraîne simultanément l'activation de toutes les étapes immédiatement suivantes et la désactivation de toutes les étapes immédiatement précédentes.

 Franchissement simultané de transitions

Les lignes doubles peuvent être utilisées pour représenter les transitions qui doivent être franchies simultanément. Si ces transitions sont représentées séparément, le test de l'activité des étapes précédentes (GSnnn.x) peut être inclus dans leur condition.

 Activation et désactivation simultanées

Si, durant le séquencement, une étape doit être simultanément activée et désactivée, la priorité est donnée à l'activation.


Hiérarchie de programmes SFC

Le système ISaGRAF permet la description d'une structure verticale des programmes SFC. Les programmes SFC sont organisés dans un système hiérarchique. Chaque programme peut contrôler (lancer, tuer...) d'autres programmes SFC. Chaque programme SFC peut contrôler d'autres programmes SFC appelés ses fils. Les programmes SFC sont reliés dans un arbre de hiérarchie, par des relations de type "père - fils".

Voici les règles de base imposées par la hiérarchie :

- Les programmes SFC qui n'ont pas de père sont appelés "principaux"

- Les programmes principaux sont activés au lancement de l'application

- Un programme père peut avoir plusieurs programmes fils

- Un programme fils ne peut avoir qu'un seul programme père

- Un programme fils ne peut être contrôlé que par son programme père

- Un programme ne peut pas contrôler les fils de ses programmes fils

Voici les actions qu'un programme SFC père peut effectuer pour contrôler un programme SFC fils :

- Lancer	(GSTART) Lance le programme fils : active chacune de ses étapes initiales. Les fils du programme lancé ne sont pas automatiquement lancés avec lui.

- Tuer	(GKILL) Tue le programme en désactivant chacune de ses étapes actives. Tous ses programmes fils sont tués avec lui.

- Figer	(GFREEZE) Suspend l'exécution du programme (désactive les actions des étapes actives et le calcul des transitions), et mémorise l'état des étapes actives pour le programme puisse être relancé ultérieurement. Les fils du programme figés sont également figés.

- Relancer	(GRST) Relance un programme SFC en réactivant toutes les étapes qui ont été désactivées quand le programme a été figé. Les fils du programme relancé ne sont pas relancés automatiquement.

- Tester	(GSTATUS) Rend l'état (figé, actif, inactif) du programme.


 Langage LD

Le langage LD (Ladder Diagram) est une représentation graphique d'équations booléennes combinant des contacts (en entrée) et des relais (en sortie). Le langage LD permet la manipulation de données booléennes, à l'aide de symboles graphiques organisés dans un diagramme. Les symboles du diagramme LD sont organisés comme les éléments d'un schéma électrique à contacts. Les diagrammes LD sont limités à gauche et à droite par des barres d'alimentation.

Barres d'alimentation et liaisons

Liaisons multiples

Contacts et relais

Symbole "Return"

Sauts et étiquettes

Blocs fonctionnels

Voici les composants graphiques élémentaires d'un diagramme LD:

Barre d'alimentation à gauche

Barre d'alimentation à droite

Arc de liaison horizontal

Arc de liaison vertical

Liaisons multiples verticales et horizontales

Contact associé à une variable

Relais associé à une variable de sortie ou interne


Barres d'alimentation et liaisons

Un diagramme LD est limité sur la gauche et la droite par des lignes verticales appelées respectivement barre d'alimentation à gauche et barre d'alimentation à droite.

Les symboles du diagramme LD sont reliés ensemble et aux barres d'alimentation par des arcs de liaison. Les liaisons doivent être verticales ou horizontales.

Chaque segment de liaison peut prendre l'état booléen FALSE ou TRUE. L'état d'une liaison est propagé dans toutes ses extrémités à droite. Toute liaison horizontale connectée à la barre d'alimentation à gauche a l'état booléen TRUE.


Liaisons multiples

L'état booléen d'un arc de liaison horizontal est le même à son extrémité gauche et à son extrémité droite. La combinaison de liaisons horizontales et verticales permet la construction de liaisons multiples. L'état aux extrémités d'une liaison multiple respecte des règles logiques.

Une liaison multiple à gauche combine plusieurs liaisons horizontales connectées à gauche d'une liaison verticale, et une seule liaison horizontale à droite. L'état de l'extrémité à droite est le résultat du OU LOGIQUE entre les états des extrémités à gauche.

(* Exemple de liaison multiple à gauche *)

(* Etat de l'extrémité droite: (v1 OR v2 OR v3) *)

Une liaison multiple à droite combine une seule liaison horizontale connectées à gauche d'une liaison verticale, et plusieurs liaisons horizontales à droite. L'état de l'extrémité à gauche est propagé dans toutes les extrémités à droite.

(* Exemple de liaison multiple à droite *)

(* Equivalence ST : *)

output1 := input1;

output2 := input1;

Une liaison multiple à gauche combine plusieurs liaisons horizontales connectées à gauche d'une liaison verticale, et plusieurs liaisons horizontales à droite. L'état de chacune des extrémités à droite est le résultat du OU LOGIQUE entre les états des extrémités à gauche.

(* Exemple de liaison multiple à gauche et à droite *)

(*Equivalence ST: *)

output1 := input1 OR input2;

output2 := input1 OR input2;

output3 := input1 OR input2;


Contacts et relais

Les types de contacts suivants peuvent être utilisés dans un diagramme:

Contact direct

Contact inversé

Contact avec détection de front montant

Contact avec détection de front descendant

Les types de relais suivants peuvent être utilisés dans un diagramme:

Relais direct

Relais inversé

Relais SET

Relais RESET

Relais avec détection de front montant

Relais avec détection de front descendant

Le nom de la variable associée est inscrit au dessus du symbole graphique:


Contact direct

Un contact direct représente une opération entre l'état d'un arc de liaison et une variable booléenne.

L'état de la liaison à droite est le résultat du ET LOGIQUE entre l'état de la liaison à gauche et la valeur de la variable associée au contact.

(* Exemple de contacts directs: *)

(*Equivalence ST: *)

output1 := input1 AND input2;


Contact inversé

Un contact inversé représente une opération entre l'état d'un arc de liaison et l'inverse logique d'une variable booléenne.

L'état de la liaison à droite est le résultat du ET LOGIQUE entre l'état de la liaison à gauche et l'INVERSE LOGIQUE de la valeur de la variable associée au contact.

(* Exemple de contacts inversés *)

(*Equivalence ST: *)

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


Contact avec détection de front montant

Un tel contact représente une opération entre l'état d'un arc de liaison et le passage à l'état VRAI d'une variable booléenne: front montant.

L'état de la liaison à droite prend l'état VRAI quand l'état de la liaison à gauche et à VRAI et que l'état de la variable associée passe de FAUX à VRAI. Il prend l'état FAUX dans tous les autres cas.

(* Exemple de contacts à détection de front positif *)

(*Equivalence ST: *)

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

(* input2prev is the value of input2 at the previous cycle *)


Contact avec détection de front descendant

Un tel contact représente une opération entre l'état d'un arc de liaison et le passage à l'état FAUX d'une variable booléenne : front descendant.

L'état de la liaison à droite prend l'état VRAI quand l'état de la liaison à gauche et à VRAI et que l'état de la variable associée passe de VRAI à FAUX. Il prend l'état FAUX dans tous les autres cas.

(* Exemple de contacts à détection de front négatif *)

(*Equivalence ST: *)

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

(* input2prev is the value of input2 at the previous cycle *)


Relais direct

Une relais direct permet le forçage d'une sortie booléenne avec l'état d'un arc de liaison.

La variable associée est forcée à l'état de la liaison à gauche. L'état de la liaison à gauche est propagé dans la liaison à droite. La liaison à droite peut être connectée à la barre d'alimentation à droite. La variable booléenne associée doit être de SORTIE ou INTERNE. Le nom de la variable associée peut être le nom du programme édité (pour les sous-programmes seulement). Dans ce cas le relais représente l'affectation de la valeur renvoyée par le sous-programme.

(* Exemple de relais directs *)

(*Equivalence ST: *)

output1 := input1;

output2 := input1;


Relais inversé

Une relais inversé permet le forçage d'une sortie booléenne avec l'inverse logique de l'état d'un arc de liaison.

La variable associée est forcée à l'inverse logique de l'état de la liaison à gauche. L'état de la liaison à gauche est propagé dans la liaison à droite. La liaison à droite peut être connectée à la barre d'alimentation à droite. La variable booléenne associée doit être de SORTIE ou INTERNE. Le nom de la variable associée peut être le nom du programme édité (pour les sous-programmes seulement). Dans ce cas le relais représente l'affectation de la valeur renvoyée par le sous-programme.

(* Exemple de relais inversés *)

(*Equivalence ST: *)

output1 := NOT (input1);

output2 := input1;


Relais SET

Un relais à action "Set" permet le forçage d'une sortie booléenne en fonction de l'état d'un arc de liaison.

La variable associée est FORCEE A TRUE quand la liaison à gauche prend l'état TRUE. La variable garde cette valeur jusqu'à un ordre inverse donné par un relais de type "RESET". L'état de la liaison à gauche est propagé dans la liaison à droite. La liaison à droite peut être connectée à la barre d'alimentation à droite. La variable booléenne associée doit être de SORTIE ou INTERNE.

(* Exemple de relais à action SET et RESET *)

(*Equivalence ST: *)

IF input1 THEN

   output1 := TRUE;

END_IF;

IF input2 THEN

   output1 := FALSE;

END_IF;


Relais RESET

Un relais à action "Reset" permet le forçage d'une sortie booléenne en fonction de l'état d'un arc de liaison.

La variable associée est FORCEE A FALSE quand la liaison à gauche prend l'état TRUE. La variable garde cette valeur jusqu'à un ordre inverse donné par un relais de type "SET". L'état de la liaison à gauche est propagé dans la liaison à droite. La liaison à droite peut être connectée à la barre d'alimentation à droite. La variable booléenne associée doit être de SORTIE ou INTERNE.

(* Exemple de relais à action SET et RESET *)

(*Equivalence ST: *)

IF input1 THEN

   output1 := TRUE;

END_IF;

IF input2 THEN

   output1 := FALSE;

END_IF;


Relais avec détection de front montant

Les relais "Positif"  permet le forçage d'une sortie booléenne en fonction de l'état d'un arc de liaison. Ce type de relais est disponible uniquement dans l'éditeur Quick LD.

La variable est FORCEE A TRUE quand la liaison à gauche passe de l'état FALSE à l'état TRUE: front montant. La variable est remise à FALSE dans tous les autres cas. L'état de la liaison à gauche est propagé dans la liaison à droite. La liaison à droite peut être connectée à la barre d'alimentation à droite. La variable booléenne associée doit être de SORTIE ou INTERNE.

(* Exemple d'utilisation d'un relais "Positif" *)

(*Equivalence ST: *)

IF (input1 and NOT(input1prev)) THEN

   output1 := TRUE;

ELSE

   output1 := FALSE;

END_IF;

(* input1prev est la valeur de input1 au cycle précédent *)


Relais avec détection de front descendant

Les relais "Négatifs"  permet le forçage d'une sortie booléenne en fonction de l'état d'un arc de liaison. Ce type de relais est disponible uniquement dans l'éditeur Quick LD.

La variable est FORCEE A TRUE quand la liaison à gauche passe de l'état TRUE à l'état FALSE: front descendant. La variable est remise à FALSE dans tous les autres cas. L'état de la liaison à gauche est propagé dans la liaison à droite. La liaison à droite peut être connectée à la barre d'alimentation à droite. La variable booléenne associée doit être de SORTIE ou INTERNE.

(* Exemple d'utilisation d'un relais "Négatif" *)

(*Equivalence ST: *)

IF (NOT(input1) and input1prev) THEN

   output1 := TRUE;

ELSE

   output1 := FALSE;

END_IF;

(* input1prev est la valeur de input1 au cycle précédent*)


Symbole "Return"

Le symbole RETURN peut être utilisé pour représenter une fin conditionnelle de l'exécution du programme. Aucune liaison ne doit être tracée à droite du symbole RETURN.

Si l'état de la liaison à gauche est TRUE, la suite du diagramme LD (lignes suivantes) n'est pas interprétée.

(* Exemple d'utilisation du symbole RETURN *)

(*Equivalence ST: *)

If Not (manual_mode) Then RETURN; End_if;

result := (input1 OR input3) AND input2;


Sauts et étiquettes

Les étiquettes, les sauts conditionnels ou inconditionnels, sont utilisés pour contrôler l'exécution du diagramme. Aucune connexion ne peut être réalisée à droite d'un symbole d'étiquette ou de saut.

>>LAB	saut à l'étiquette de nom "LAB"

LAB:	définition de l'étiquette "LAB"

Si la liaison à gauche du symbole de saut prend l'état TRUE, l'exécution du programme est déroutée après l'étiquette correspondante.

(* Exemple d'utilisation de sauts et étiquettes *)

(*Equivalence IL: *)

ldn	manual_mode

jmpc	other

ld	input1

st	result

jmp	END

OTHER:	ld	input2

st	result

END:	(* fin du programme *)


Blocs fonctionnels

Lorsque vous utilisez l'éditeur Quick LD, des boites fonctions peuvent être connectées aux lignes booléennes. Une fonction peut être un opérateur, un bloc fonctionnel ou une fonction. Comme un bloc n'a pas forcément une entrée ou une sortie booléenne, l'insertion d'un bloc dans un diagramme LD peut entraîner l'ajout automatique de nouveaux paramètres à l'interface de ce bloc : EN, ENO. Ces paramètres EN / ENO ne sont pas ajoutés si vous utilisez l'éditeur FBD / LD, car avec cet éditeur vous avez la possibilité de connecter les variables du type requis.

L'entrée "EN"

La sortie "ENO"

Utiliser "EN" et "ENO" ensemble


L'entrée "EN"

La première entrée de certains opérateurs, bloc fonctionnels ou fonctions, n'est pas du type booléen, et ne peut donc pas être connecté à une ligne LD booléenne. Donc, pour ces blocs, une entrée supplémentaire booléenne est ajoutée comme premier paramètre d'entrée. Cette entrée a le nom "EN". Dans ce cas, le bloc est exécuté uniquement si l'entrée EN reçoit un signal TRUE. Voici l'exemple du bloc comparateur et son équivalent en ST:

	IF rung_state THEN    q := (value1 > value 2); ELSE    q := FALSE; END_IF; (*la liaison à droite  prend l'état de q *)


La sortie "ENO"

La première sortie de certains opérateurs, bloc fonctionnel ou fonctions, n'est pas du type booléen, et ne peut donc pas être connectée à une ligne LD booléenne. Donc, pour ces blocs, une sortie supplémentaire booléenne est ajoutée comme premier paramètre de sortie. Cette sortie a le nom "ENO". La sortie ENO prend toujours l'état de la première entrée du bloc. Voici l'exemple du bloc AVERAGE et son équivalent en ST.

	AVERAGE(rung_state, Signal, 100); OutSignal := AVERAGE.XOUT; eno := rung_state; (*la liaison à droite prend  l'état de eno *)


Utiliser "EN" et "ENO" ensemble

Dans certains cas, les deux paramètres EN et ENO sont ajoutés. Voici l'exemple d'un opérateur arithmétique et son équivalent en ST.

	IF rung_state THEN    result := (value1 + value2); END_IF; eno := rung_state; (*la liaison à droite prend  l'état de eno *)


Opérateurs, blocs fonctionnels et fonctions standard

Opérateurs standard

Blocs fonctionnels standard

Fonctions standard

Index alphabétique


Opérateurs standard

Voici la liste des boîtes fonctions disponibles, correspondant aux opérateurs et fonctions définies en standard par le langage ST :

Manipulation de données:

1 Gain	Assignation

Neg	Négation analogique

Opérations booléennes:

& (AND)	ET logique

>=1 (OR)	OU logique

=1 (XOR)	OU exclusif logique

Opérations arithmétiques:

 + 	Addition

 - 	Soustraction

 * 	Multiplication

 / 	Division

Opérations de masquage:

AND_MASK	Masque ET analogique bit à bit

OR_MASK	Masque OU analogique bit à bit

XOR_MASK	Masque OU exclusif analogique bit à bit

NOT_MASK	Inversion bit à bit

Comparaisons:

 < 	Plus petit que

 <= 	Plus petit ou égal à

 > 	Plus grand que

 >= 	Plus grand ou égal à

 = 	Egal à

 <> 	Différent de

Conversion de données:

BOO	Conversion en booléen

ANA	Conversion en analogique entier

REAL	Conversion en analogique réel

TMR	Conversion en temporisation

MSG	Conversion en message

Autres:

CAT	Concaténation de messages

SYSTEM	Accès aux paramètres du système

OPERATE	Traitement des E/S

Les notations suivantes sont utilisés pour le type des paramètres:

BOO : booléen

ENT : analogique entier

REEL : analogique réel

TMP: temporisation

MSG : message


1 gain

Arguments:

IN	tout type

Q	tout type

Description:

assignation d'une variable dans une autre

Ce bloc est très utile pour relier directement une entrée et une sortie du diagramme. Il peut également être utilisé pour insérer une inversion booléenne avant la connexion d'un arc à une variable de sortie du diagramme.

(* Programme FBD avec blocs "assignation" *)

(* Equivalence ST: *)

ao23 := ai10;

bo100 := NOT (bi1 AND bi2);

(* Equivalence IL: *)

LD	ai10

ST 	ao23

LD	bi1

AND	bi2

STN	bo100


NEG

Arguments:

IN	ENT-REEL	L'entrée et la sortie doivent avoir le même format

Q	ENT-REEL

Description:

Assignation de la négation d'une variable.

(* Programme FBD avec blocs de négation *)

(* Equivalence ST: *)

ao23 := - (ai10);

ro100 := - (ri1 + ri2);

(* Equivalence IL: *)

LD	ai10

MUL	-1

ST 	ao23

LD	ri1

ADD	ri2

MUL	-1.0

ST	ro100


& AND

Remarque: Vous pouvez étendre le nombre d'entrées de cet opérateur à plus de deux.

Arguments:

(inputs)	BOO

output	BOO	ET logique entre les termes en entrée

Description:

ET logique entre deux ou plusieurs termes.

(* Programme FBD avec blocs "ET" *)

(* Equivalence ST: *)

bo10 := bi101 AND NOT (bi102);

bo5 := (bi51 AND bi52) AND bi53;

(* Equivalence IL: *)

LD	bi101	(* résultat courant := bi101 *)

ANDN	bi102	(* résultat courant:= bi101 AND not(bi102) *)

ST	bo10	(* bo10 := résultat courant *)

LD	bi51	(* résultat courant:= bi51;

&	bi52	(* résultat courant:= bi51 AND bi52 *)

&	bi53	(* résultat courant:= (bi51 AND bi52) AND bi53 *)

ST	bo5	(* bo5 := résultat courant *)


>=1 OR

Remarque: Vous pouvez étendre le nombre d'entrées de cet opérateur à plus de deux.

Arguments:

(inputs)	BOO

output	BOO	OU logique entre les termes en entrée

Description:

OU logique entre deux ou plusieurs termes.

(* Programme FBD avec blocs "OU" *)

(* Equivalence ST: *)

bo10 := bi101 OR NOT (bi102);

bo5 := (bi51 OR bi52) OR bi53;

(* Equivalence IL: *)

LD	bi101

ORN	bi102

ST	bo10

LD	bi51

OR	bi52

OR	bi53

ST	bo5


=1 XOR

Arguments:

IN1	BOO

IN2	BOO

Q	BOO	OU logique exclusif des deux termes en entrée

Description:

OU logique exclusif entre deux termes.

(* Programme FBD avec blocs "OU Exclusif" *)

(* Equivalence ST: *)

bo10 := bi101 XOR NOT (bi102);

bo5 := (bi51 XOR bi52) XOR bi53;

(* Equivalence IL: *)

LD	bi101

XORN	bi102

ST	bo10

LD	bi51

XOR	bi52

XOR	bi53

ST	bo5


+

Remarque: Vous pouvez étendre le nombre d'entrées de cet opérateur à plus de deux.

Arguments:

(entrées)	ENT-REEL	les entrées peuvent être entières ou réelles

(toutes les entrées doivent avoir le même format)

sortie	ENT-REEL	addition signée des termes en entrée

Description:

Addition de deux ou plusieurs termes analogiques.

(* Programme FBD avec blocs "addition" *)

(* Equivalence ST *)

ao10 := ai101 + ai102;

ao5 := (ai51 + ai52) + ai53;

(* Equivalence IL *)

LD	ai101

ADD	ai102

ST	ao10

LD	ai51

ADD	ai52

ADD	ai53

ST	ao5


-

Arguments:

IN1	ENT-REEL	peut être entier ou réel

IN2	ENT-REEL	(IN1 et IN2 doivent avoir le même format)

Q	ENT-REEL	soustraction (IN1 - IN2)

Description:

Soustraction de deux termes analogiques (premier - second).

(* Programme FBD avec blocs "soustraction" *)

(* Equivalence ST *)

ao10 := ai101 - ai102;

ao5 := (ai51 - 1) - ai53;

(* Equivalence IL *)

LD	ai101

SUB	ai102

ST	ao10

LD	ai51

SUB	1

SUB	ai53

ST	ao5


*

Remarque: Vous pouvez étendre le nombre d'entrées de cet opérateur à plus de deux.

Arguments:

(entrées)	ENT-REEL	les entrées peuvent être entières ou réelles

(toutes les entrées doivent avoir le même format)

sortie	ENT-REEL	multiplication signée des termes en entrée

Description:

Multiplication de deux ou plusieurs termes analogiques.

(* Programme FBD avec blocs "multiplication" *)

(* Equivalence ST *)

ao10 := ai101 * ai102;

ao5 := (ai51 * ai52) * ai53;

(* Equivalence IL *)

LD	ai101

MUL	ai102

ST	ao10

LD	ai51

MUL	ai52

MUL	ai53

ST	ao5


/

Arguments:

IN1	ENT-REEL	peut être entier ou réel (opérande)

IN2	ENT-REEL	valeur analogique non nulle (diviseur)

(IN1 et IN2 doivent avoir le même format)

Q	ENT-REEL	division signée, entière ou réelle, de IN1 par IN2.

Description:

Division de deux variables analogiques (la première divisé par la seconde).

(* Programme FBD avec blocs "division" *)

(* Equivalence ST *)

ao10 := ai101 / ai102;

ao5 := (ai5 / 2) / ai53;

(* Equivalence IL *)

LD	ai101

DIV	ai102

ST	ao10

LD	ai51

DIV	2

DIV	ai53

ST	ao5


AND_MASK

Arguments:

IN	ENT	doit avoir le format entier

MSK	ENT	doit avoir le format entier

Q	ENT	ET logique bit à bit entre IN et MSK

Description:

Masque ET bit à bit entre deux entiers analogiques.

(* Programme FBD avec bloc "Masque ET" *)

(* Equivalence ST: *)

parity := AND_MASK (xvalue, 1); (* 1 si xvalue est impair *)

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

(* Equivalence IL: *)

LD	xvalue

AND_MASK	1

ST	parity

LD	16#abc

AND_MASK	16#f0f

ST	result


OR_MASK

Arguments:

IN	ENT	doit avoir le format entier

MSK	ENT	doit avoir le format entier

Q	ENT	OU logique bit à bit entre IN et MSK

Description:

Masque OU bit à bit entre deux entiers analogiques.

(* Programme FBD avec bloc "Masque OU" *)

(* Equivalence ST: *)

is_odd := OR_MASK (xvalue, 1); (* toujours impair *)

result := OR_MASK (16#abc, 16#f0f); (* égal 16#fbf *)

(* Equivalence IL: *)

LD	xvalue

OR_MASK	1

ST	is_odd

LD	16#abc

OR_MASK	16#f0f

ST	result


XOR_MASK

Arguments:

IN	ENT	doit avoir le format entier

MSK	ENT	doit avoir le format entier

Q	ENT	OU exclusif logique bit à bit entre IN et MSK

Description:

Masque OU exclusif bit à bit entre deux entiers analogiques.

(* Programme FBD avec bloc "Masque OU Exclusif" *)

(* Equivalence ST: *)

crc32 := XOR_MASK (prevcrc, nextc);

result := XOR_MASK (16#012, 16#011); (* égal 16#003 *)

(* Equivalence IL: *)

LD	prevcrc

XOR_MASK	nextc

ST	crc32

LD	16#012

XOR_MASK	16#011

ST	result


NOT_MASK

Arguments :

IN	ENT	doit avoir le format entier

Q	ENT	inversion logique bit à bit de IN (sur 32 bits)

Description:

Masque inversion logique bit à bit d'un entier analogique.

(* Programme FBD avec bloc "NOT_MASK" *)

(* Equivalence ST: *)

result := NOT_MASK (16#1234);

(* result = 16#FFFF_EDCB *)

(* Equivalence IL: *)

LD	16#1234

NOT_MASK

ST	result


<

Arguments:

IN1	ENT-REEL-

TMP-MSG

IN2	ENT-REEL-

TMP-MSG	les deux entrées doivent être du même type

Q	BOO	TRUE si IN1 < IN2

Description:

Teste si une valeur est plus petite (Less Than) qu'une autre (sur les analogiques, les temporisations ou les messages)

(* Programme FBD avec bloc "Plus petit que" *)

(* Equivalence ST: *)

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

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

(* Equivalence IL: *)

LD	10

LT	25

ST	aresult

LD	'z'

LT	'B'

ST	mresult


<=

Arguments:

IN1	ENT-REEL-MSG

IN2	ENT-REEL-MSG	les deux entrées doivent avoir le même type

Q	BOO	TRUE si IN1 <= IN2

Description:

Teste si une valeur est plus petite ou égale (Less or Equal) à une autre (sur les analogiques, ou les messages)

(* Programme FBD avec bloc "Plus petit ou égal" *)

(* Equivalence ST: *)

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

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

(* Equivalence IL: *)

LD	10

LE	25

ST	aresult

LD	'ab'

LE	'ab'

ST	mresult


>

Arguments:

IN1	ENT-REEL-

TMP-MSG

IN2	ENT-REEL-

TMP-MSG 	les deux entrées doivent avoir le même type

Q	BOO	TRUE si IN1 > IN2

Description:

Teste si une valeur est plus grande (Greater Than) qu'une autre (sur les analogiques, les temporisations ou les messages)

(* Programme FBD avec bloc "Plus grand que" *)

(* Equivalence ST: *)

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

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

(* Equivalence IL: *)

LD	10

GT	25

ST	aresult

LD	'ab'

GT	'a'

ST	mresult


>=

Arguments:

IN1	ENT-REEL-MSG

IN2	ENT-REEL-MSG 	les deux entrées doivent avoir le même type

Q	BOO	TRUE si IN1 >= IN2

Description:

Teste si une valeur est plus grande ou égale (Greater or Equal) à une autre (sur les analogiques, ou les messages)

(* Programme FBD avec bloc "Plus grand ou égal" *)

(* Equivalence IL: *)

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

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

(* Equivalence IL: *)

LD	10

GE	25

ST	aresult

LD	'ab'

GE	'ab'

ST	mresult


=

Arguments:

IN1	ENT-REEL-MSG

IN2	ENT-REEL-MSG 	les deux entrées doivent avoir le même type

Q	BOO	TRUE si IN1 = IN2

Description:

Teste si une valeur est égale (EQual) à une autre (sur les analogiques, ou les messages)

(* Programme FBD avec bloc "Est égal à" *)

(* Equivalence ST: *)

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

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

(* Equivalence IL: *)

LD	10

EQ	25

ST	aresult

LD	'ab'

EQ	'ab'

ST	mresult


<>

Arguments:

IN1	ENT-REEL-MSG

IN2	ENT-REEL-MSG 	les deux entrées doivent avoir le même type

Q	BOO	TRUE si IN1 <> IN2

Description:

Teste si une valeur est différente (Not Equal) d'une autre (sur les analogiques, ou les messages)

(* Programme FBD avec bloc "Est différent de" *)

(* Equivalence ST: *)

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

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

(* Equivalence IL: *)

LD	10

NE	25

ST	aresult

LD	'ab'

NE	'ab'

ST	mresult


BOO

Arguments:

IN	Tout type	toute valeur non booléenne

Q	BOO	TRUE pour une valeur analogique non nulle

FALSE pour une valeur analogique nulle

TRUE pour un message 'TRUE'

FALSE pour un message 'FALSE'

Description:

Convertit une variable en une variable booléenne

(* Programme FBD avec conversion en booléen *)

(* Equivalence ST: *)

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

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

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

(* Equivalence IL: *)

LD	10

BOO

ST	ares

LD	t#0s

BOO

ST	tres

LD	'false'

BOO


ANA

Arguments:

IN	Tout type	toute valeur non analogique entière

Q	ENT	0 pour FALSE / 1 pour TRUE

nombre de milli-secondes pour une tempo

partie entière d'un analogique réel

valeur décimale représentée par un message

Description:

Convertit une variable en une variable analogique entière

(* Programme FBD avec conversion en entier *)

(* Equivalence ST: *)

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

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

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

(* Equivalence IL: *)

LD	true

ANA

ST	bres

LD	t#1s46ms

ANA

ST	tres

LD	'0198'

ANA

ST	mres


REAL

Arguments:

IN	BOO-ENT-

TMP	toute valeur non analogique réelle (pas de message)

Q	REEL	0.0 pour FALSE / 1.0 pour TRUE

nombre de milli-secondes pour une tempo

nombre équivalent à un analogique entier

Description:

Convertit une variable en une variable analogique réelle

(* Programme FBD avec bloc conversion en réel *)

(* Equivalence ST: *)

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

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

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

(* Equivalence IL: *)

LD	true

REAL

ST	bres

LD	t#1s46ms

REAL

ST	tres

LD	198

REAL

ST	ares


TMR

Arguments:

IN	ENT-REEL	toute valeur non temporelle

IN (ou la partie entière de IN, si elle est réelle)

représente le nombre de milli-secondes

Q	TMP	temps représenté par IN

Description:

Convertit une variable analogique en temporisation

(* Programme FBD avec conversion en temporisation *)

(* Equivalence ST: *)

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

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

(* Equivalence IL: *)

LD	1256

TMR

ST	ares

LD	1256.3

TMR

ST	rres


MSG

Arguments:

IN	BOO-

ENT-REEL	toute valeur non message

Q	MSG	'false' ou 'true' si IN est  un booléen

représentation décimale pour si IN est un entier

Description:

Convertit une variable en variable message

(* Programme FBD avec conversion en message *)

(* Equivalence ST: *)

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

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

(* Equivalence IL: *)

LD	true

MSG

ST	bres

LD	125

MSG

ST	ares


CAT

Remarque: Vous pouvez étendre le nombre d'entrées de cet opérateur à plus de deux.

Arguments:

(entrées)	MSG	(la somme des longueurs des messages d'entrée ne doit pas excéder la capacité du message de sortie)

sortie	MSG	concaténation des messages en entrée

Description:

Concatène plusieurs message en un seul

 (* Programme FBD avec bloc "Concaténation" *)

(* Equivalence ST : utilisation de l'opérateur + *)

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

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

(* Equivalence IL : *)

LD	'Mr'

ADD	' '

ADD	'Jones'

ST	myname


SYSTEM

Arguments:

Mode	ENT	identifie le paramètre système et le mode d'accès réalisé

Arg	ENT-TMP	nouvelle valeur dans le cas d'un accès en écriture

Param	ENT	valeur du paramètre accédé

Description:

Accès aux paramètres système

Voici la liste des ordres disponibles (mots clés prédéfinis) pour la fonction SYSTEM:

ordre	signification

SYS_TALLOWED	lecture du temps de cycle programmé

SYS_TCURRENT	lecture du temps de cycle courant

SYS_TMAXIMUM	lecture du temps de cycle maximum

SYS_TOVERFLOW	lecture des dépassements du temps de cycle

SYS_TRESET	remise à zéro des compteurs de temps

SYS_TWRITE	écriture du temps de cycle

SYS_ERR_TEST	test des erreurs d'exécution

SYS_ERR_READ	lecture de la dernière erreur d'exécution

Voici la liste des arguments requis pour les ordres prédéfinis de la fonction SYSTEM :

ordre	argument	valeur retournée

SYS_TALLOWED	0	temps de cycle autorisé

SYS_TCURRENT	0	temps de cycle courant

SYS_TMAXIMUM	0	temps de cycle max détecté

SYS_TOVERFLOW	0	nombre de dépassements

SYS_TRESET	0	0

SYS_TWRITE	nouveau temps	valeur écrite

de cycle autorisé

SYS_ERR_TEST	0	0 si aucune erreur détectée

SYS_ERR_READ	0	code de la dernière erreur

(* Programme FBD avec bloc "System" *)

(* ST Equivalence: *)

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

If (alarm) Then

nb_err := nb_err + 1;

rc := SYSTEM (SYS_TRESET, 0);

End_If;


OPERATE

Arguments:

IO	Tout type	variable d'entrée ou de sortie

Funct	ENT	action à effectuer

Arg	ENT	argument pour l'action d'E/S effectuée

Q	ENT	compte rendu d'exécution

Description:

Accès à une voie d'E/S

La signification des arguments de OPERATE dépend de l'implémentation de l'interface de l'E/S traitée. Référez-vous au manuel de votre automate ou à la fiche technique de la carte d'E/S correspondante pour plus d'informations sur les possibilités offertes par la fonction OPERATE.


Blocs fonctionnels standards

Voici les blocs fonctionnels standards supportés par le système ISaGRAF. Ces blocs fonctionnels sont prédéfinis et n'ont pas à être déclarés dans la librairie.

Booléen:

SR	Bistable - forçage à TRUE prioritaire

RS	Bistable - forçage à FALSE prioritaire

R_TRIG	Détection de front montant

F_TRIG	Détection de front descendant

SEMA	Sémaphore

Comptage:

CTU	Compteur

CTD	Décompteur

CTUD	Compteur / décompteur

Temporisations:

TON	Temporisateur à enclenchement

TOF	Temporisateur à déclenchement

TP	Temporisateur d'impulsions

Entiers:

CMP	Comparateur

STACKINT	Pile de valeurs analogiques entières

Réels:

AVERAGE	Moyenne courante sur N échantillons

HYSTER	Hystérésis sur la différence de 2 réels

LIM_ALRM	Alarme de limite avec d'hystérésis

INTEGRAL	Intégration en fonction du temps

DERIVATE	Dérivée par rapport au temps

Signaux:

BLINK	Clignotant

SIG_GEN	Base de temps

Note: Quand de nouveaux blocs fonctionnels en "C" sont développés, ils deviennent disponibles pour le langage FBD.


SR

Arguments:

SET1	BOO	si TRUE, force Q1 à TRUE (prioritaire)

RESET	BOO	si TRUE, force Q1 à FALSE

Q1	BOO	état de la bascule

Description:

bistable à mise à 1 prioritaire: Voici sa table de vérité :

Set1 	Reset	Q1	Q1 résultant

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

(* programme FBD avec bloc "SR" *)

(* Equivalence ST : SR1 est une instance du bloc SR *)

SR1((auto_mode & start_cmd), stop_cmd);

command := SR1.Q1;

(* Equivalence IL : *)

LD	auto_mode

AND	start_cmd

ST	SR1.set1

LD	stop_cmd

ST	SR1.reset

CAL	SR1

LD	SR1.Q1

ST	command


RS

Arguments:

SET	BOO	si TRUE, force Q1 à TRUE

RESET1	BOO	si TRUE, force Q1 à FALSE (prioritaire)

Q1	BOO	état de la bascule

Description:

Bistable à remise à 0 prioritaire : Voici sa table de vérité :

Set 	Reset1	Q1	Q1 résultant

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

(* programme FBD avec bloc "RS" *)

(* Equivalence: RS1 est une instance du bloc RS *)

RS1(start_cmd, (stop_cmd OR alarm));

command := RS1.Q1;

(* Equivalence IL : *)

LD	start_cmd

ST	RS1.set

LD	stop_cmd

OR	alarm

ST	RS1.reset1

CAL	RS1

LD	RS1.Q1

ST	command


R_TRIG

Arguments:

CLK	BOO	toute variable booléenne

Q	BOO	TRUE quand CLK passe de FALSE à TRUE

FALSE dans tous les autres cas

Description:

Détection du front montant d'une variable booléenne

(* Programme FBD avec bloc fonctionnel "R_TRIG" *)

(* Equivalence ST : R_TRIG1 est une instance du bloc R_TRIG *)

R_TRIG1(cmd);

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

(* Equivalence IL : *)

LD	cmd

ST	R_TRIG1.clk

CAL	R_TRIG1

LD	R_TRIG1.Q

ANA

ADD	nb_edge

ST	nb_edge


F_TRIG

Arguments:

CLK	BOO	toute variable booléenne

Q	BOO	TRUE quand CLK passe de TRUE à FALSE

FALSE dans tous les autres cas

Description:

Détection le front descendant d'une variable booléenne

(* Programme FBD avec bloc fonctionnel "F_TRIG" *)

(* Equivalence ST : F_TRIG1 est une instance du bloc F_TRIG *)

F_TRIG1(cmd);

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

(* Equivalence IL : *)

LD	cmd

ST	F_TRIG1.clk

CAL	F_TRIG1

LD	F_TRIG1.Q

ANA

ADD	nb_edge

ST	nb_edge


SEMA

Arguments:

CLAIM	BOO	commande "test and set"

RELEASE	BOO	commande de libération de la ressource (libère le sémaphore)

BUSY	BOO	état du sémaphore (TRUE = occupé)

Description:

(* "x" est une variable booléenne initialisée à FALSE *)

busy := x;

If claim Then

x := True;

Else

If release Then

busy := False;

x := False;

End_if;

End_if;


CTU

Arguments:

CU	BOO	entrée de comptage (compte si CU = TRUE)

RESET	BOO	remise à zéro (prioritaire)

PV	ENT	valeur maximum programmée

Q	BOO	signal "plein" : TRUE quand CV = PV (overflow)

CV	ENT	résultat courant du comptage

Attention: Le bloc CTU ne détecte pas les fronts montants ou descendants de l'entrée de comptage (CU). Il doit être associé à un bloc fonctionnel "R_TRIG" ou "F_TRIG" pour réaliser un compteur d'impulsions.

Description:

Compte (en entier) de 0 à une valeur donnée par pas de 1

(* Programme FBD avec bloc fonctionnel "CTU" *)

(* Equivalence ST : R_TRIG1 est une instance du bloc R_TRIG et CTU1 est une instance du bloc CTU *)

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

overflow := CTU1.Q;

result := CTU1.CV;

(* Equivalence 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

Arguments:

CD	BOO	entrée de comptage

(décompte si CD = TRUE)

LOAD	BOO	commande de chargement (prioritaire)

(CV = PV si LOAD = TRUE)

PV	ENT	valeur initiale programmée

Q	BOO	signal "vide" : TRUE quand CV = 0 (underflow)

CV	ENT	résultat courant du comptage

Attention: Le bloc CTD ne détecte pas les fronts montants ou descendants de l'entrée de comptage (CD). Il doit être associé à un bloc fonctionnel "R_TRIG" ou "F_TRIG" pour réaliser un compteur d'impulsions.

Description:

Compte (décompte) (en entier) d'une valeur donnée jusqu'à 0 par pas de 1

(* Programme FBD avec bloc fonctionnel "CTD" *)

(* Equivalence ST : F_TRIG1 est une instance du bloc F_TRIG bloc et CTD1 est une instance du bloc CTD *)

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

underflow := CTD1.Q;

result := CTD1.CV;

(* IL Equivalence: *)

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

Arguments:

CU	BOO	comptage (incrémentation quand CU = TRUE)

CD	BOO	décomptage (décrémentation quand CD = TRUE)

RESET	BOO	commande de remise à zéro (prioritaire)

(CV = 0 si RESET = TRUE)

LOAD	BOO	commande de chargement

(CV = PV si LOAD = TRUE)

PV	ENT	valeur maximum programmée

QU	BOO	signal "plein": TRUE quand CV = PV (overflow

QD	BOO	signal "vide": TRUE quand CV = 0 (underflow)

CV	ENT	résultat courant du comptage

Attention: Le bloc CTUD ne détecte pas les fronts montants ou descendants des entrées de comptage (CU et CD). Il doit être associé à un bloc fonctionnel "R_TRIG" ou "F_TRIG" pour réaliser un compteur d'impulsions.

Description:

Compte (en entier) de 0 à une valeur donnée par pas de 1

ou d'une valeur donnée jusqu'à 0 par pas de 1

(* Programme FBD avec bloc fonctionnel "CTUD" *)

(* Equivalence ST : R_TRIG1 et R_TRIG2 sont deux instances du bloc R_TRIG et CTUD1 est une instance du bloc 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;

(* Equivalence 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

Arguments:

IN	BOO	si front montant, démarre l'incrément d'une temporisation interne

si front descendant, arrête et remet à 0 la temporisation interne

PT	TMP	temps maximum programmé

Q	BOO	si TRUE, le temps programmé est écoulé

ET	TMP	temps écoulé depuis le démarrage

Description:

Incrémente une temporisation interne jusqu'à une valeur donnée (temporisateur à enclenchement)

Chronogramme :


TOF

Arguments:

IN	BOO	si front descendant, démarre l'incrément d'une temporisation

si front descendant, arrête et remet à 0 la temporisation interne

PT	TMP	temps maximum programmé

Q	BOO	si TRUE: le temps programmé n'est pas encore écoulé

ET	TMP	temps écoulé depuis le démarrage

Description:

Incrémente une temporisation interne jusqu'à une valeur donnée (temporisateur à déclenchement)

Chronogramme :


TP

Arguments:

IN	BOO	si front montant, démarre l'incrément d'une temporisation interne (si elle n'est pas déjà active)

si FALSE et seulement si le temps est écoulé, remet à 0 la temporisation interne

Tout changement sur IN pendant le comptage, est sans effet.

PT	TMP	temps maximum programmé

Q	BOO	si TRUE: la temporisation est en cours (comptage)

ET	TMP	temps écoulé depuis le démarrage

Description:

Incrémente une temporisation interne jusqu'à une valeur donnée (temporisateur à impulsion)

Chronogramme:


CMP

Arguments:

VAL1	ENT	toute valeur analogique entière signée

VAL2	ENT	toute valeur analogique entière signée

LT	BOO	TRUE si val1 est plus petit val2

EQ	BOO	TRUE si val1 est égal à val2

GT	BOO	TRUE si val1 si val1 est plus grand que val2

Description:

Compare deux valeurs : signale si elles sont égales, ou si la première est plus petite ou plus grande que la seconde.

 (* Programme FBD avec bloc fonctionnel "CMP" *)

(* Equivalence ST : CMP1 est une instance du bloc CMP *)

CMP1(level, max_level);

pump_cmd := CMP1.LT OR CMP1.EQ;

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

(* Equivalence 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

Arguments:

PUSH	BOO	commande "empiler" (sur front montant)

ajoute la valeur IN au somment de la pile

POP	BOO	commande "dépiler" (sur front montant)

détruit dans la pile la dernière valeur empilée (sommet de la pile)

R1	BOO	vide la pile

IN	INT	valeur à empiler

N	INT	taille de la pile définie par l'application

EMPTY	BOO	TRUE si la pile est vide

OFLO	BOO	TRUE si la pile est pleine (overflow)

OUT	INT	valeur au sommet de la pile

Description:

Gère une pile de valeurs entières.

Le bloc fonctionnel "STACKINT" inclut une détection de front montant pour les entrées PUSH et POP (commandes "empiler" et "dépiler"). La taille maximum absolue de la pile est de 128 éléments. La taille définie par l'application ne peut pas être inférieure à 1 ou supérieure à 128.

Remarque: la valeur de OFLO est géré seulement après au moins une remise à 0 (R1a été mis à TRUE au moins une fois et remis à FALSE).

(* Programme FBD avec bloc fonctionnel "STACKINT": gestion d'erreurs *)

(* Equivalence ST : STACKINT1 est une instance du bloc 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;

(* Equivalence 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

Arguments:

RUN	BOO	TRUE = marche / FALSE = ré-initialisation

XIN	REAL	toute valeur analogique réelle

N	INT	nombre d'échantillons (défini par l'application)

XOUT	REAL	moyenne courante de l'entrée XIN

Description:

Stocke une valeur à chaque cycle et calcule la valeur moyenne des valeurs déjà stockées. Seules les N dernières valeurs sont stockées.

Le nombre d'échantillons ne peut pas excéder 128.

Si l'entrée "RUN" vaut FALSE (ré-initialisation), la valeur de sortie est égale à la valeur d'entrée.

Quand N valeurs ont été stockées, la première valeur qui a été stockée est écrasée par la dernière.

(* Programme FBD avec bloc fonctionnel "AVERAGE" : *)

(* Equivalence ST : AVERAGE1 est une instance du bloc AVERAGE *)

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

ave_value := AVERAGE1.XOUT;

(* Equivalence 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

Arguments:

XIN1	REEL	toute valeur analogique réelle

XIN2	REEL	pour tester si XIN1 est au-delà de XIN2+EPS

EPS	REEL	REEL	valeur de l'hystérésis (doit être positif)

Q	BOO	TRUE si XIN1 est au-delà de XIN2+EPS et n'est pas encore en dessous de XIN2-EPS

Description:

Hysteresis sur limite haute sur une valeur analogique réelle.

Exemple de chronogramme :


LIM_ALRM

Arguments:

H	REEL	valeur de la limite haute

X	REEL	entrée: toute valeur analogique réelle

L	REEL	valeur de la limite basse

EPS	REEL	valeur de l'hysteresis (doit être positif)

QH	BOO	alarme haute : TRUE si X au dessus de la limite haute H

Q	BOO	alarme : TRUE si X hors limites

QL	BOO	alarme basse : TRUE si X en dessous de la limite basse L

Description:

Hysteresis sur limites haute et basse sur une valeur analogique réelle.

Un hystérésis est appliqué aux limites haute et basse. Le delta d'hystérésis utilisé pour la limite haute ou la limite basse est la moitié de la valeur du paramètre EPS.

Exemple de chronogramme :


INTEGRAL

Arguments:

RUN	BOO	mode: TRUE = intégration / FALSE = attente

R1	BOO	commande de remise à zéro

XIN	REEL	entrée: toute valeur analogique réelle

X0	REAL	valeur initiale

CYCLE	TMP	période d'échantillonnage

Q	BOO	Not R1

XOUT	REEL	valeur intégrée

Description:

Intégration d'une valeur analogique réelle.

Si la valeur du paramètre "CYCLE" est inférieure au temps de cycle de l'application ISaGRAF, la période d'échantillonnage est égale au temps de cycle de l'application.

(* Programme FBD avec bloc "INTEGRAL" : *)

(* Equivalence ST: INTEGRAL1 est une instance du bloc INTEGRAL *)

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

controlled_value := INTEGRAL1.XOUT;

(* Equivalence 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

Arguments:

RUN	BOO	mode: TRUE = normal / FALSE = remise à zéro

XIN	REEL	entrée: toute valeur analogique réelle

CYCLE	TMP	période d'échantillonnage

XOUT	REEL	sortie: dérivée du signal

Description:

Différentiation d'une valeur analogique réelle.

Si la valeur du paramètre "CYCLE" est inférieure au temps de cycle de l'application ISaGRAF, la période d'échantillonnage est égale au temps de cycle de l'application.

(* Programme FBD avec bloc "DERIVATE" : *)

(* Equivalence ST : DERIVATE1 est une instance du bloc DERIVATE *)

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

derivated_value := DERIVATE1.XOUT;

(* Equivalence 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

Arguments:

RUN	BOO	mode: TRUE = clignotant / FALSE = remise à false de la sortie

CYCLE	TMR	période du clignotant

Q	BOO	sortie : signal clignotant

Description:

Génère un signal clignotant.

Chronogramme:


SIG_GEN

Arguments:

RUN	BOO	mode: TRUE = marche / FALSE = remise à 0

PERIOD	TMP	période d'un échantillon

MAXIMUM	ENT	valeur maximum de comptage

PULSE	BOO	inversé à chaque échantillon

UP	ENT	compteur incrémenté à chaque échantillon

END	BOO	TRUE en fin de comptage

SINE	REEL	sinus (période = temps de comptage)

Description:

Génère plusieurs signaux : clignotant sur un booléen, comptage d'un entier, et signal sinusoïdal réel.

Quand le comptage atteint sa valeur maximum, il redémarre à 0. Donc END reste à TRUE seulement pendant un échantillon (PERIOD).

Chronogramme:


Fonctions standards

Voici les fonctions standards supportées par le système ISaGRAF. Ces fonctions sont prédéfinies et n'ont pas à être déclarées dans la librairie.

Fonctions mathématiques:

ABS	Valeur absolue

EXPT	Exponentiation

LOG	Logarithme

POW	Elévation à une puissance

SQRT	Racine carrée

TRUNC	Partie entière

Fonctions trigonométriques

ACOS	Arc cosinus

ASIN	Arc sinus

ATAN	Arc tangente

COS	Cosinus

SIN	Sinus

TAN	Tangente

Manipulation de registres

ROL	Rotation à gauche

ROR	Rotation à droite

SHL	Décalage à gauche

SHR	Décalage à droite

Manipulation de données

MIN	Minimum

MAX	Maximum

LIMIT	Limite

MOD	Modulo

MUX4	Multiplexeur (4 entrées)

MUX8	Multiplexeur (8 entrées)

ODD	Imparité

RAND	Nombre aléatoire

SEL	Sélecteur binaire

Conversion de données

ASCII	Caractère  Code Ascii

CHAR	Code Ascii  Caractère

Chaînes de caractères

DELETE	Suppression

FIND	Recherche

INSERT	Insertion de caractères

LEFT	Extraction à gauche,

MID	Extraction au milieu

MLEN	Longueur courante

REPLACE	Remplacement de caractères

RIGHT	Extraction à droite

DAY_TIME	Date et heure courantes

Gestion de tableaux

ARCREATE	Création de tableau

ARREAD	Lecture d'éléments

ARWRITE	Ecriture d'éléments

Gestion de fichiers binaires

F_ROPEN	Ouvre un fichier binaire en mode lecture

F_WOPEN	Ouvre un fichier binaire en mode écriture

F_CLOSE	Ferme un fichier binaire

F_EOF	Teste la fin d'un fichier binaire

FA_READ	Lit une valeur analogique dans un fichier binaire

FA_WRITE	Ecrit une valeur analogique dans un fichier binaire

FM_READ	Lit un message (chaîne de caractères) dans un fichier binaire

FM_WRITE	Ecrit un message (chaîne de caractères) dans un fichier binaire

Note: quand une nouvelle procédure "C" est créée, elle devient disponible sous forme d'une boîte fonction pour le langage FBD.


ABS

Arguments:

IN	REEL	toute valeur réelle signée

Q	REEL	valeur absolue (toujours positive)

Description:

Donne la valeur absolue (positive) d'une valeur analogique réelle.

(* Programme FBD avec bloc "ABS" *)

(* Equivalence ST: *)

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

(* Equivalence IL: *)

LD	delta

ABS

GT 	range

ST	over


EXPT

Arguments:

IN	REEL	toute valeur réelle signée

EXP	ENT	exposant entier

Q	REEL	(IN EXP) (Exponentiation)

Description:

Donne le résultat analogique réel de l'opération: (base exponent) 'base' étant le premier argument et 'exponent' le deuxième.

 (* Programme FBD avec bloc "EXT" *)

(* Equivalence ST: *)

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

(* Equivalence IL: *)

LD	2.0

EXPT	range

ANA

ST	tb_size


LOG

Arguments:

IN	REEL	doit être plus grand que zéro

Q	REEL	logarithme (base 10) de la valeur d'entrée

Description:

Calcule le logarithme (base 10) d'une valeur réelle.

(* Programme FBD avec bloc "LOG" *)

(* Equivalence ST: *)

xpos := ABS (xval);

xlog := LOG (xpos);

(* Equivalence IL: *)

LD	xval

ABS

ST	xpos

LOG

ST	xlog


POW

Arguments:

IN	REEL	nombre analogique réel à élever

EXP	REEL	puissance (exposant)

Q	REEL	(IN EXP) (élévation à une puissance)

1.0 si IN est différent de 0.0 et EXP est égal à 0.0

0.0 si IN est égal à 0.0 et EXP est négatif

0.0 si IN et EXP sont égaux à 0.0

0.0 si IN est négatif et Y ne correspond pas à un entier

Description:

Donne le résultat analogique réel de: (base exponent) 'base' étant le premier argument et 'exponent' le deuxième. 'exponent' est une valeur réelle.

(* Programme FBD avec bloc "POW" *)

(* Equivalence ST: *)

result := POW (xval, power);

(* Equivalence IL: *)

LD	xval

POW	power

ST	result


SQRT

Arguments:

IN	REEL	doit être plus grand ou égal à zéro

Q	REEL	racine carrée de la valeur d'entrée

Description:

Calcule la racine carrée d'une valeur réelle.

(* Programme FBD avec bloc "SQRT" *)

(* Equivalence ST: *)

xpos := ABS (xval);

xroot := SQRT (xpos);

(* Equivalence IL: *)

LD	xval

ABS

ST	xpos

SQRT

ST	xrout


TRUNC

Arguments:

IN	REEL	toute valeur réelle signée

Q	REEL	si IN>0, plus grand entier inférieur ou égal à IN

si IN<0, plus petit entier supérieur ou égal à IN

Description:

Tronque une valeur réelle de façon à obtenir sa partie entière.

(* Programme FBD avec bloc "TRUNC" *)

(* Equivalence ST: *)

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

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

(* Equivalence IL: *)

LD	2.67

TRUNC

ST	temporary	(* Résultat temporaire du premier TRUNC *)

LD	-2.0891

TRUNC

ADD	temporary

ST	result


ACOS

Arguments:

IN	REEL	doit être dans l'intervalle [-1.0 .. +1.0]

Q	REEL	arc-cosinus de la valeur d'entrée dans l'intervalle [0.0 .. PI]

= 0.0 pour une entrée invalide

Description:

Calcule l'Arc cosinus d'une valeur réelle.

(* Programme FBD avec blocs "COS" et "ACOS" *)

(* Equivalence ST: *)

cosine := COS (angle);

result := ACOS (cosine); (* result est égal à angle *)

(* Equivalence IL: *)

LD	angle

COS

ST	cosine

ACOS

ST	result


ASIN

Arguments:

IN	REEL	doit être dans l'intervalle [-1.0 .. +1.0]

Q	REEL	arc-sinus de la valeur d'entrée dans l'intervalle [-PI/2 .. +PI/2]

= 0.0 pour une entrée invalide

Description:

Calcule l'Arc sinus d'une valeur réelle.

(* Programme FBD avec blocs "SIN" et "ASIN" *)

(* Equivalence ST: *)

sine := SIN (angle);

result := ASIN (sine); (* result est égal à angle *)

(* Equivalence IL: *)

LD	angle

SIN

ST	sine

ASIN

ST	result


ATAN

Arguments:

IN	REEL	toute valeur analogique réelle

Q	REEL	arc-tangente de la valeur d'entrée dans l'intervalle [-PI/2 .. +PI/2]

= 0.0 pour une entrée invalide

Description:

Calcule l'Arc tangente d'une valeur réelle.

(* Programme FBD avec blocs "TAN" et "ATAN" *)

(* Equivalence ST: *)

tangent := TAN (angle);

result := ATAN (tangent); (* result est égal à angle*)

(* Equivalence IL: *)

LD	angle

TAN

ST	tangent

ATAN

ST	result


COS

Arguments:

IN	REEL	toute valeur analogique réelle

Q	REEL	cosinus de la valeur d'entrée dans l'intervalle [-1.0 .. +1.0]

Description:

Calcule le Cosinus d'une valeur réelle.

(* Programme FBD avec blocs "COS" et "ACOS" *)

(* Equivalence ST: *)

cosine := COS (angle);

result := ACOS (cosine); (* result est égal à angle *)

(* Equivalence IL: *)

LD	angle

COS

ST	cosine

ACOS

ST	result


SIN

Arguments:

IN	REEL	toute valeur analogique réelle

Q	REEL	sinus de la valeur d'entrée dans l'intervalle [-1.0 .. +1.0]

Description:

Calcule le Sinus d'une valeur réelle.

(* Programme FBD avec blocs "SIN" et "ASIN" *)

(* Equivalence ST: *)

sine := SIN (angle);

result := ASIN (sine); (* result est égal à angle *)

(* Equivalence IL: *)

LD	angle

SIN

ST	sine

ASIN

ST	result


TAN

Arguments:

IN	REEL	ne peut pas être égal à PI/2 modulo PI

Q	REEL	tangente de la valeur d'entrée

= 1E+38 pour une entrée invalide

Description:

Calcule la Tangente d'une valeur réelle.

(* Programme FBD avec blocs "TAN" et "ATAN" *)

(* Equivalence ST: *)

tangent := TAN (angle);

result := ATAN (tangent); (* result est égal à angle*)

(* Equivalence IL: *)

LD	angle

TAN

ST	tangent

ATAN

ST	result


ROL

Arguments:

IN	ENT	toute valeur analogique ENTIERE

NbR	ENT	nombre de rotations de 1 bit (dans l'intervalle [1..31])

Q	ENT	valeur décalée à gauche

sans effet si NbR <= 0

Description:

Rotation à gauche des bits d'un entier. La rotation est effectuée sur 32 bits:

(* Programme FBD avec bloc "ROL" *)

(* Equivalence ST: *)

result := ROL (register, 1);

(* register = 2#0100_1101_0011_0101*)

(* result    = 2#1001_1010_0110_1010*)

(* Equivalence IL: *)

LD	register

ROL	1

ST	result


ROR

Arguments:

IN	ENT	toute valeur analogique ENTIERE

NbR	ENT	nombre de rotations de 1 bit (dans l'intervalle [1..31])

Q	ENT	valeur décalée à droite

sans effet si NbR <= 0

Description:

Rotation à droite des bits d'un entier. La rotation est effectuée sur 32 bits:

(* Programme FBD avec bloc "ROR" *)

(* Equivalence ST: *)

result := ROR (register, 1);

(* register = 2#0100_1101_0011_0101 *)

(* result    = 2#1010_0110_1001_1010 *)

(* Equivalence IL: *)

LD	register

ROR	1

ST	result


SHL

Arguments:

IN	ENT	toute valeur analogique ENTIERE

NbS	ENT	nombre de décalages de 1 bit (dans l'intervalle [1..31])

Q	ENT	valeur décalée à gauche

sans effet si NbS <= 0

la valeur 0 remplace le bit de poids faible

Description:

Décalage à gauche des bits d'un entier. Le décalage est effectué sur 32 bits:

(* Programme FBD avec bloc "SHL" *)

(* Equivalence ST: *)

result := SHL (register,1);

(* register = 2#0100_1101_0011_0101 *)

(* result    = 2#1001_1010_0110_1010 *)

(* Equivalence IL: *)

LD	register

SHL	1

ST	result


SHR

Arguments:

IN	ENT	toute valeur analogique ENTIERE

NbS	ENT	nombre de décalages de 1 bit (dans l'intervalle [1..31])

Q	ENT	valeur décalée à droite

sans effet si NbS <= 0

le bit de poids fort est recopié à chaque décalage

Description:

Décalage à droite des bits d'un entier. Le décalage est effectué sur 32 bits:

(* Programme FBD avec bloc "SHR" *)

(* Equivalence ST: *)

result := SHR (register,1);

(* register = 2#1100_1101_0011_0101 *)

(* result    = 2#1110_0110_1001_1010 *)

(* Equivalence IL: *)

LD	register

SHR	1

ST	result


MIN

Arguments:

IN1	INT	toute valeur entière signée

IN2	INT	(ne peut pas être REEL)

Q	INT	minimum des deux entrées

Description:

Donne la valeur minimum entre deux entiers.

(* Programme FBD avec blocs "MIN" et "MAX" *)

(* Equivalence ST: *)

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

(* Limite la valeur à l'intervalle [min_value..max_value] *)

(* Equivalence IL: *)

LD	max_value

MIN	value

MAX	min_value

ST	new_value


MAX

Arguments:

IN1	ENT	toute valeur entière signée

IN2	ENT	(ne peut pas être REEL)

Q	ENT	maximum des deux entrées

Description:

Donne la valeur maximum entre deux entiers.

(* Programme FBD avec blocs "MIN" et "MAX" *)

(* Equivalence ST: *)

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

(* Limite la valeur à l'intervalle [min_value..max_value] *)

(* Equivalence IL: *)

LD	max_value

MIN	value

MAX	min_value

ST	new_value


LIMIT

Arguments:

MIN	ENT	valeur minimum autorisée

IN	ENT	toute valeur analogique entière signée

MAX	ENT	valeur maximum autorisée

Q	ENT	valeur limitée à la plage autorisée

Description:

Limite une valeur entière à un intervalle donné. Soit elle conserve sa valeur si elle est entre le minimum et le maximum, soit elle est forcée à la valeur maximum si elle est au dessus, soit elle est forcée au minimum si elle est en dessous.

(* Programme FBD avec bloc "LIMIT" *)

(* Equivalence ST: *)

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

(* Limite la valeur à l'intervalle [min_value..max_value] *)

(* Equivalence IL: *)

LD	min_value

LIMIT	value, max_value

ST	new_value


MOD

Arguments:

IN	ENT	toute valeur ENTIERE signée

Base	ENT	doit être plus grand que zéro

Q	ENT	résultat du modulo (input MOD base)

rend -1 si Base <= 0

Description:

Calcule le modulo d'une valeur entière.

(* Programme FBD avec bloc "MOD" *)

(* Equivalence ST: *)

division_result := (value / divider); (*division entière *)

rest_of_division := MOD (value, divider); (* reste de la division *)

(* Equivalence IL: *)

LD	value

DIV	divider

ST	division_result

LD	value

MOD	divider

ST	rest_of_division


MUX4

Arguments:

SEL	ENT	valeur entière de sélection dans l'intervalle [0..3]

IN1..IN4	ENT	valeurs entières signées

Q	ENT	= IN1 si SEL = 0

= IN2 si SEL = 1

= IN3 si SEL = 2

= IN4 si SEL = 3

= 0 pour toutes les autres valeurs de SEL

Description:

Multiplexeur 4 entrées: sélectionne une valeur parmi 4 valeurs entières.

(* Programme FBD avec bloc "MUX4" *)

(* Equivalence ST: *)

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

(* sélectionne une valeur parmi 4 échelles prédéfinies, par exemple, si choice = 1, range sera égal à 10 *)

(* Equivalence IL: *)

LD	choice

MUX4	1,10,100,1000

ST	range


MUX8

Arguments:

SEL	ENT	valeur entière de sélection dans l'intervalle [0..7]

IN1..IN8	ENT	valeurs entières signées

Q	ENT	= IN1 si SEL = 0

= IN2 si SEL = 1

...

= IN8 si SEL = 7

= 0 pour toutes les autres valeurs de SEL

Description:

Multiplexeur 8 entrées: sélectionne une valeur parmi 8 valeurs entières.

(* Programme FBD avec bloc "MUX8" *)

(* Equivalence ST: *)

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

(* sélectionne une valeur parmi 8 échelles prédéfinies, par exemple, si choice = 3, range sera égal à 50 *)

(* Equivalence IL: *)

LD	choice

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

ST	range


ODD

Arguments:

IN	ENT	toute valeur entière signée

Q	BOO	TRUE si la valeur est impaire

FALSE si la valeur est paire

Description:

Teste la parité d'un entier: le résultat est impair ou pair.

(* Programme FBD avec bloc "ODD" *)

(* Equivalence ST: *)

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

value := value + 1;

(* rend la valeur toujours paire *)

(* Equivalence IL: *)

LD	value

ODD

RETNC

LD	value

ADD	1

ST	value


RAND

Arguments:

base	ENT	définit l'intervalle de valeurs autorisées

Q	ENT	valeur aléatoire dans l'intervalle [0..base-1]

Description:

Retourne un nombre aléatoire (valeur entière) dans un intervalle donné.

(* Programme FBD avec bloc "RAND" *)

(* Equivalence ST: *)

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

(*

sélection aléatoire d'une valeur parmi 4 valeurs prédéfinies.

La valeur issue de l'appel à RAND est dans l'intervalle [0..3],

Donc 'selected' issue de MUX4, prendra aléatoirement la valeur

1 si 0 est issue de RAND,

ou 4 si 1 est issue de RAND,

ou 8 si 2 est issue de RAND,

ou 16 si 3 est issue de RAND,

*)

(* Equivalence IL: *)

LD	4

RAND

MUX4	1,4,8,16

ST	selected


SEL

Arguments:

SEL	BOO	indique la valeur choisie

IN1, IN2	ENT	valeurs analogiques entières

Q	ENT	= IN1 si SEL = FALSE

= IN2 si SEL = TRUE

Description:

Sélecteur binaire: sélectionne une valeur parmi deux valeurs entières.

(* Programme FBD avec bloc "SEL" *)

(* Equivalence ST: *)

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

(* sélection de commande pour le procédé *)

(* Equivalence IL: *)

LD	AutoMode

SEL	ManuCmd,InpCmd

ST	ProCmd


ASCII

Arguments:

IN	MSG	chaîne de caractères non vide

Pos	ENT	position du caractère sélectionné dans l'intervalle [1 .. long] (long est la longueur du message IN)

Code	ENT	code du caractère sélectionné

(dans l'intervalle[0 .. 255])

retourne 0 si Pos n'est pas dans la chaîne

Description:

Donne le code ASCII d'un caractère dans une chaîne de caractère (message).

(* Programme FBD avec bloc "ASCII" *)

(* Equivalence ST: *)

FirstChr := ASCII (message, 1);

(* FirstChr est le code Ascii du premier caractère de la chaîne *)

(* Equivalence IL: *)

LD	message

ASCII	1

ST	FirstChr


CHAR

Arguments:

Code	ENT	code ascii dans l'intervalle [0 .. 255]

Q	MSG	chaîne de un caractère

le caractère a le code ascii spécifié dans Code

(le code ascii est pris modulo 256)

Description:

Donne un message de un caractère à partir de son code ASCII.

(* Programme FBD avec bloc "CHAR" *)

(* Equivalence ST: *)

Display := CHAR ( value + 48 );

(* value est dans l'intervalle [0..9] *)

(* 48 est le code ASCII de '0' *)

(* le résultat est une chaîne de un caractère de '0' à '9' *)

(* Equivalence IL: *)

LD	value

ADD	48

CHAR

ST	Display


DELETE

Arguments:

IN	MSG	chaîne de caractères non vide

NbC	ENT	nombre de caractères à supprimer

Pos	ENT	position du premier caractère à supprimer

(le premier caractère de la chaîne a la position 1)

Q	MSG	chaîne modifiée

chaîne vide si position < 1

chaîne initiale si Pos > longueur de la chaîne IN

chaîne initiale si NbC <= 0

Description:

Détruit une partie(sous-chaîne) d'une chaîne de caractères.

(* Programme FBD avec bloc "DELETE" *)

(* Equivalence ST: *)

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

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

(* Equivalence IL: *)

LD	'ABCD'

ADD	'EFGH'

ST	complete_string

DELETE	4,3

ST 	sub_string


FIND

Arguments:

In	MSG	chaîne de caractères

Pat	MSG	toute chaîne non vide (Pattern)

Pos	ENT	= 0 si sous-chaîne Pat non trouvée

= position du premier caractère de la première occurrence de la sous-chaîne Pat

(la première position valide est 1)

Cette fonction différencie les majuscules et minuscules

Description:

Recherche une sous-chaîne dans une chaîne message. Donne la position dans la chaîne de la sous-chaîne.

(* Programme FBD avec bloc "FIND" *)

(* Equivalence ST: *)

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

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

(* Equivalence IL: *)

LD	'ABCD'

ADD	'EFGH'

ST	complete_string

FIND	'CDEF'

ST 	found


INSERT

Arguments:

IN	MSG	chaîne initiale

Str	MSG	chaîne de caractères à insérer

Pos	ENT	position d'insertion

l'insertion se fait avant la position donnée

(la première position valide est 1)

Q	MSG	chaîne modifiée

chaîne vide si Pos <= 0

concaténation des deux chaînes si Pos est plus grand que la longueur de la chaîne IN

Description:

Insertion d'une sous-chaîne dans une chaîne message à une position donnée.

(* Programme FBD avec bloc "INSERT" *)

(* Equivalence ST: *)

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

(* MyName = 'Mr Frank JONES' *)

(* Equivalence IL: *)

LD	'Mr JONES'

INSERT	'Frank ',4

ST 	MyName


LEFT

Arguments:

IN	MSG	chaîne de caractères non vide

NbC	INT	Nombre de caractères à extraire

ne peut pas être plus grand que la longueur de la chaîne IN

Q	MSG	partie gauche de la chaîne IN (sa longueur = NbC)

chaîne vide si NbC <= 0

chaîne IN initiale si NbC >= longueur de la chaîne IN

Description:

Extraction de la partie gauche d'une chaîne message. Le nombre de caractères à extraire est donné en paramètre.

(* Programme FBD avec blocs "LEFT" et "RIGHT" *)

(* Equivalence ST: *)

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

(* complete_string = '56781234'

la valeur issue de l'appel à RIGHT = '5678'

la valeur issue de l'appel à LEFT = '1234'

*)

(* Equivalence IL: on fait d'abord l'appel à LEFT *)

LD	'12345678'

LEFT	4

ST	sub_string 	(* résultat intermédiaire *)

LD	'12345678'

RIGHT	4

ADD	sub_string

ST 	complete_string


MID

Arguments:

IN	MSG	chaîne de caractères non vide

NbC	ENT	nombre de caractères à extraire

ne peut pas être plus grand que la longueur de la chaîne IN

Pos	ENT	position de la sous-chaîne

le premier caractère de la sous-chaîne sera celui pointé par Pos

(la première position valide est 1)

Q	MSG	partie du milieu de la chaîne (sa longueur = NbC)

chaîne vide si les paramètres sont invalides

Description:

Extraction d'une sous-chaîne au milieu d'une chaîne message. Le nombre de caractères à extraire et la position du premier caractère sont donnés en paramètre.

(* Programme FBD avec bloc "MID" *)

(* Equivalence ST: *)

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

(* sub_string = 'de' *)

(* Equivalence IL: *)

LD	'abcdefgh'

MID	2,4

ST	sub_string


MLEN

Arguments:

IN	MSG	chaîne de caractères

NbC	INT	nombre de caractères dans la chaîne IN

Description:

Calcule la longueur d'une chaîne message.

(* Programme FBD avec bloc "MLEN" *)

(* Equivalence ST: *)

nbchar := MLEN (complete_string);

If (nbchar < 3) Then Return; End_if;

prefix := LEFT (complete_string, 3);

(* ce programme extrait les 3 caractères à gauche de la chaîne et met le résultat dans la variable message 'prefix'.

Rien n'est fait si la longueur de la chaîne est inférieure à 3 *)

(* Equivalence IL: *)

LD	complete_string

MLEN

ST	nbchar

LT	3

RETC

LD	complete_string

LEFT	3

ST	prefix


REPLACE

Arguments:

IN	MSG	chaîne de caractères

Str	MSG	chaîne à insérer (pour remplacer NbC caractères)

NbC	ENT	nombre de caractères à détruire

Pos	ENT	position du premier caractère modifié

(la première position valide est 1)

Q	MSG	chaîne modifiée:

- NbC caractères sont détruits à partir de Pos

- ensuite la sous-chaîne Str est insérée à cette position

rend une chaîne vide si Pos <= 0

rend la concaténation des chaînes(IN+Str) si Pos est plus grand que la longueur de la chaîne IN

rend la chaîne initiale IN si NbC <= 0

Description:

Remplacement d'une partie d'une chaîne message par une nouvelle sous-chaîne.

(* Programme FBD avec bloc "REPLACE" *)

(* Equivalence ST: *)

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

(* MyName = 'Mr Frank JONES' *)

(* Equivalence IL: *)

LD	'Mr X JONES'

REPLACE	'Frank',1,4

ST	MyName


RIGHT

Arguments:

IN	MSG	chaîne de caractères non vide

NbC	ENT	Nombre de caractères à extraire

ne peut pas être plus grand que la longueur de la chaîne IN

Q	MSG	partie droite de la chaîne IN (sa longueur = NbC)

chaîne vide si NbC <= 0

chaîne IN initiale si NbC >= longueur de la chaîne IN

Description:

Extraction de la partie droite d'une chaîne message. Le nombre de caractères à extraire est donné en paramètre.

(* Programme FBD avec blocs "LEFT" et "RIGHT" *)

(* Equivalence ST: *)

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

(* complete_string = '56781234'

la valeur issue de l'appel à RIGHT = '5678'

la valeur issue de l'appel à LEFT = '1234'

*)

(* Equivalence IL: on fait d'abord l'appel à LEFT *)

LD	'12345678'

LEFT	4

ST	sub_string 	(* résultat intermédiaire *)

LD	'12345678'

RIGHT	4

ADD	sub_string

ST 	complete_string


DAY_TIME

Arguments:

SEL	ENT	sélection de l'information

0= date courante

1= heure courante

2= jour de la semaine

Q	MSG	date/heure sous forme de chaîne de caractère

'AAAA/MM/JJ' si SEL = 0

'HH:MM:SS' si SEL = 1

nom du jour SEL = 2 (ex: 'Monday')

(les noms de jour sont toujours en anglais)

Description:

Donne la date ou l'heure ou le jour courant sous forme de chaîne message.

(* Programme FBD avec bloc "DAY_TIME" *)

(* Equivalence ST: *)

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

(* Le format texte de Display est : 'YYYY/MM/DD ; HH:MM:SS' *)

(* Equivalence IL: on fait d'abord l'appel à day_time(1) *)

LD	1

DAY_TIME

ST	hour_str 	(* résultat intermédiaire *)

LD	0

DAY_TIME

ADD	' ; '

ADD	hour_str

ST 	Display


ARCREATE

Arguments:

ID	ENT	identificateur du tableau (doit être dans l'intervalle [0..15])

Size	ENT	nombre d'éléments du tableau à créer

ok	ENT	compte rendu d'exécution:

1 = si le tableau a été crée avec succès

2 = identificateur invalide ou tableau déjà créé

3 = taille invalide

4 = pas assez de mémoire

Description:

Création d'un tableau d'entiers.

Attention: Il ne peut pas y avoir plus de 16 tableaux dans une application. Les tableaux contiennent des valeurs analogiques entières. La mémoire étant allouée dynamiquement, cette procédure peut endommager le système et provoquer des erreurs fatales si la taille demandée est trop proche de la taille de la mémoire système disponible.

(* Programme FBD avec gestion de tableaux d'entiers *)

(* Equivalence ST: *)

array_error := (ARCREATE (ident, 16) <> 1));

(* Equivalence IL: *)

LD	ident

ARCREATE	16

NE 	1

ST	array_error


ARREAD

Arguments:

ID	ENT	identificateur du tableau (doit être dans l'intervalle [0..15])

Pos	ENT	position de l'élément dans le tableau

dans l'intervalle [0 .. size-1]

value	ENT	valeur de l'élément lu

0 si les arguments sont invalides

Description:

Lit un élément dans un tableau d'entiers.

(* Programme FBD avec gestion de tableaux *)

(* Equivalence ST: *)

If (array_error) Then Return; End_if;

read_value := ARREAD (ident, index);

(* array_error vient de l'appel à ARCREATE *)

(* Equivalence IL: *)

LD	array_error

RETC

LD	ident

ARREAD	index

ST	read_value


ARWRITE

Arguments:

ID	ENT	identificateur du tableau (doit être dans l'intervalle [0..15])

Pos	ENT	position de l'élément dans le tableau

dans l'intervalle [0 .. size-1]

IN	ENT	nouvelle valeur pour l'élément

ok	ENT	compte rendu d'exécution

1 = l'écriture a réussi

2 = identificateur de tableau invalide

3 = indice (Pos) invalide

Description:

Stocke (écrit) une valeur dans un tableau d'entiers.

(* Programme FBD avec gestion de tableaux *)

(* Equivalence ST: *)

If (array_error) Then Return; End_if;

write_status := ARWRITE (Ident, Index, value);

(* array_error vient de l'appel à ARCREATE *)

(* Equivalence IL: *)

LD	array_error

RETC

LD	ident

ARWRITE	index,value

ST	write_status


F_ROPEN

Arguments:

Path	MSG	nom de fichier

peut inclure le chemin d'accès au fichier avec les symboles \ ou / pour spécifier un répertoire. Pour améliorer la portabilité de l'application, / et \ sont équivalents.

ID	ENT	identificateur de fichier

0 en cas d'erreur : le fichier n'existe pas.

Description:

Ouvre un fichier binaire en mode lecture. Doit être utilisé avec FX_READ et F_CLOSE.

Cette fonction n'est pas incluse dans le simulateur ISaGRAF.

(* Programme FBD avec gestion de fichier *)

(* Equivalence ST : *)

file_id := F_ROPEN('c:\data \data.bin');

error := (file_id=0);

(* Equivalence IL : *)

LD	'c:\data\data.bin'

F_ROPEN

ST	file_id

EQ	0

ST	error


F_WOPEN

Arguments:

Path	MSG	nom de fichier

peut inclure le chemin d'accès au fichier avec les symboles \ ou / pour spécifier un répertoire. Pour améliorer la portabilité de l'application, / et \ sont équivalents.

ID	ENT	identificateur de fichier

0 en cas d'erreur. Si le fichier existe déjà il est écrasé.

Description:

Ouvre un fichier binaire en mode écriture. Doit être utilisé avec FX_WRITE et F_CLOSE.

Cette fonction n'est pas incluse dans le simulateur ISaGRAF.

(* Programme FBD avec gestion de fichier *)

(* Equivalence ST : *)

file_id := F_WOPEN('c:\data \data.bin');

error := (file_id=0);

(* Equivalence IL : *)

LD	'c:\data\data.bin'

F_WOPEN

ST	file_id

EQ	0

ST	error


F_CLOSE

Arguments:

ID	ENT	identificateur de fichier: retourné par F_ROPEN ou F_WOPEN.

ok	BOO	statut

TRUE  si la fermeture de fichier s'est bien passée

FALSE en cas d'erreur

Description:

Ferme un fichier binaire ouvert avec la fonction F_ROPEN ou F_WOPEN.

Cette fonction n'est pas incluse dans le simulateur ISaGRAF.

(* Programme FBD avec gestion de fichier *)

(* Equivalence ST : *)

file_id := F_ROPEN('data.bin');

ok := F_CLOSE(file_id);

(* Equivalence IL : *)

LD	'data.bin'

F_ROPEN

ST	file_id

F_CLOSE	(* file_id est déjà dans le résultat courant IL *)

ST 	ok


F_EOF

Arguments:

ID	ENT	identificateur de fichier: retourné par F_ROPEN ou F_WOPEN.

ok	BOO	indicateur de fin de fichier

TRUE  si la fin du fichier a été atteinte au moment du dernier appel aux procédures de lecture ou d'écriture.

Avec FM_READ, le dernier message lu dans un fichier peut ne pas être correcte, si le dernier caractère n'est pas un caractère de fin de chaîne.

Description:

Teste si la fin de fichier est atteinte.

Cette fonction n'est pas incluse dans le simulateur ISaGRAF.

Notez que EOF en anglais signifie End Of File.

(* Programme FBD avec gestion de fichier *)

(* Equivalence 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);

(* Equivalence IL : *)

LD	'data.bin'

F_ROPEN

ST	file_id

LD 	file_id

F_EOF

JMPC	END_OF_FILE

NOT_EOF:	LD 	file_id

FA_READ

ST	VAL

LD 	file_id

F_EOF

JMPNC	NOT_EOF 	(* si pas fin de fichier :eof, continuer la lecture *)

END_OF_FILE:	LD	VAL

MSG

ST	val_msg	(* conversion de VAL en message *)

LD	'last val = '

ADD	val_msg

ST	MESSAGE

LD 	file_id

F_CLOSE

ST	ok


FA_READ

Arguments:

ID	ENT	identificateur de fichier: retourné par F_ROPEN

Q	ENT	valeur analogique entière lue dans le fichier

Description:

Lit des valeurs analogiques dans un fichier binaire. Doit être utilisé avec F_ROPEN et F_CLOSE.

Cette procédure accède de façon séquentielle au fichier, à partir de la dernière position.

Le premier appel après F_ROPEN lit les 4 premiers octets dans le fichier,

chaque appel décale le pointeur de lecture.

Pour tester si la fin du fichier est atteinte, utilisez F_EOF.

Cette fonction n'est pas incluse dans le simulateur ISaGRAF.

(* Programme FBD avec gestion de fichier *)

(* Equivalence 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);

(* Equivalence IL : *)

LD	'voltramp.bin'

F_ROPEN

ST	file_id

FA_READ	(* lit vstart *)

ST	vstart

LD 	file_id

FA_READ	(* lit vend *)

ST	vend

LD 	file_id

FA_READ	(* lit vinc *)

ST	vinc

LD 	file_id

FA_READ	(* lit delta_tim *)

TMR	(* conversion en temporisation *)

ST	delta_tim

LD 	file_id

F_CLOSE

ST	ok


FA_WRITE

Arguments:

ID	ENT	identificateur de fichier: retourné par F_WOPEN

IN	ENT	valeur analogique entière à écrire dans le fichier

OK	BOO	compte rendu d'exécution: TRUE si ok

Description:

Ecrit des valeurs analogiques dans un fichier binaire.

Cette procédure accède de façon séquentielle au fichier, à partir de la dernière position.

Le premier appel après F_WOPEN écrit les 4 premiers octets dans le fichier,

chaque appel décale le pointeur d'écriture.

Cette fonction n'est pas incluse dans le simulateur ISaGRAF.

(* Programme FBD avec gestion de fichier *)

(* Equivalence ST : *)

file_id := F_WOPEN('voltramp.bin');

nb_written  := 0;

nb_written := nb_written + ana(FA_WRITE(file_id,vstart));

nb_written := nb_written + ana(FA_WRITE(file_id,vend));

nb_written := nb_written + ana(FA_WRITE(file_id,vinc));

nb_written := nb_written + ana(FA_WRITE(file_id,ana(delta_tim)));

ok := F_CLOSE(file_id);

IF ( nb_written <> 4) THEN

ERROR := ERR_FILE;

END_IF;

(* Equivalence IL : *)

LD	'voltramp.bin'

F_ROPEN

ST	file_id

LD	0

ST	nb_written

LD 	file_id	(* écrit vstart *)

FA_WRITE	vstart

ANA

ADD	nb_written

ST	nb_written

LD 	file_id	(* écrit vend *)

FA_WRITE	vend

ANA

ADD	nb_written

ST	nb_written

LD 	file_id	(* écrit vinc *)

FA_WRITE	vinc

ANA

ADD	nb_written

LD	(* écrit delta_tim *)

ANA	(* conversion en entier *)

ST	ana_delta_tim

LD 	file_id

FA_WRITE	ana_delta_tim

ANA

ADD	nb_written

ST	nb_written

F_CLOSE

ST	ok

LD	nb_written

EQ	4

RETC	(* return si égal 4 *)

LD	ERR_FILE	(* sinon erreur *)

ST	ERROR


FM_READ

Arguments:

ID	ENT	identificateur de fichier: retourné par F_ROPEN

Q	MSG	valeur du message lu dans le fichier

Description:

Lit des variables messages dans un fichier binaire.

Doit être utilisé avec F_ROPEN et F_CLOSE.

Cette procédure accède de façon séquentielle au fichier, à partir de la dernière position.

Le premier appel après F_ROPEN lit la première chaîne dans le fichier,

chaque appel décale le pointeur de lecture.

Une chaîne finit par nul (0), le caractère fin de ligne ('\n') ou retour ('\r');

Pour tester si la fin du fichier est atteinte, utilisez F_EOF.

Cette fonction n'est pas incluse dans le simulateur ISaGRAF.

(* Programme FBD avec gestion de fichier *)

(* Equivalence 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);

(* Equivalence IL : *)

LD	'voltramp.bin'

F_ROPEN

ST	file_id

FM_READ	(* lit status1 *)

ST	status1

LD 	file_id

FM_READ	(* lit status2 *)

ST	status2

LD 	file_id

F_EOF

JMPNC	CLOSE_FILE (* si fin de fichier, saut non effectué *)

LD	ERR_FILE

ST	ERROR

LD 	file_id

FM_READ	(* lecture unused_eof_mes *)

ST	unused_eof_mes

CLOSE_FILE	LD 	file_id

F_CLOSE

ST	ok


FM_WRITE

Arguments:

ID	ENT	identificateur de fichier: retourné par F_WOPEN

IN	MSG	valeur du message à écrire dans le fichier

ok	BOO	compte rendu d'exécution

TRUE en cas de succès

Description:

Ecrit des variables message dans un fichier binaire.

Doit être utilisé avec F_WOPEN et F_CLOSE.

Un message est écrit dans le fichier comme une chaîne terminée par le caractère nul.

Cette procédure accède de façon séquentielle au fichier, à partir de la dernière position.

Le premier appel après F_WOPEN écrit la première chaîne dans le fichier,

Cette fonction n'est pas incluse dans le simulateur ISaGRAF.

(* Programme FBD avec gestion de fichier *)

(* Equivalence 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);

(* Equivalence IL: *)

LD	'trace.txt'

F_WOPEN

ST	file_id

FM_WRITE	'First message'	(* écrit le premier message *)

ST	ok

LD 	file_id

FM_WRITE	'Last message'	(* écrit le deuxième message *)

ST	ok

LD 	file_id

F_CLOSE

ST	ok


Index alphabétique

-	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


 Langage FC

Le Flow Chart (FC) est un langage graphique qui décrit des opérations séquentielles et un flux de décision. Un diagramme Flow Chart est composé d' Actions et de Décisions. Les actions et décisions sont reliés par des liaisons orientées représentant le flux. Les actions et les décisions peuvent être décrits en langage ST, LD ou IL. Des fonctions et blocs fonctionnels écrits en tout langage (à l'exception du SFC et du FC) peuvent être appelés depuis les actions et les décisions. Un programme Flow Chart peut appeler un autre programme Flow Chart. Le programme FC appelé est appelé sous-programme FC du programme appelant.

Composants de base du FC

Exemples de structures complexes FC

Comportement dynamique du FC

Syntaxe du FC


Composants de base du FC

Voici les composants graphiques élémentaires du langage Flow Chart:

Début du diagramme FC

Fin du diagramme FC

Liaisons FC (flux)

Actions

Décisions

Sous-programmes FC

Actions spécifiques

Connecteurs

Commentaires


Début du diagramme FC

Un symbole "begin" doit apparaître au début du diagramme Flow Chart. Il est unique et ne peut mas être omis. Il représente l'état initial du diagramme lors de son activation. Voici le dessin du symbole "begin":

Le symbole "Begin" a toujours une connection (en aval) vers un autre objet du diagramme. Un diagramme flow chart est invalide si aucune liaison n'est tracée depuis le symbole "Begin" vers un autre élément.


Fin du diagramme FC

Un symbole "end" doit apparaître à la fin du diagramme Flow Chart program. Il est unique et ne peut pas être omis. Toutefois il est possible qu'aucune liaison ne mène au symbole "End" (diagramme bouclant indéfiniment), mais le symbole "End" est tout de même présent dans le diagramme. Il représente l'état final du diagramme, quand son exécution est terminées. Voici le dessin d'un symbole "End":

Le symbole "End" a généralement une connection (en amont) provenant d'un autre objet du diagramme.


Liaisons FC (flux)

Une liaison est une ligne orientée qui représente le flux de contrôle entre deux points du diagramme. Une liaison est toujours terminée par une flèche qui indique la direction du flux. Voici le dessin d'une liaison:

Deux liens ne peuvent pas être conectés à partir du même point.


Actions FC

Le symbole d'une action représente des actions à exécuter. Une action est identififiée par un numéro et un nom. Voici le dessin d'un symbole d'action:

Deux objets du diagramme ne peuvent pas avoir le même numéro. Le langage de programmation d'une action peut être le ST, le LD ou le IL. Une action doit toujours être connectée en amont et en aval aux autres objets du diagramme.


Décisions FC

Une décision représente un test booléen. Une décision est identifiée par un numéro et un nom. Selon l'expression de la condition, exprimée en ST, LD ou IL, le flux est dirigé soit vers la sortie "YES" soit vers la sortie "NO". Voici les différentes possibilités pour le dessin d'une décision:

Deux objets du diagramme ne peuvent pas avoir le même numéro. La programmation de la condition peut être réalisée avec:

- une expression booléenne en ST, ou

- une échelle unique en LD, sans symbole attaché à la bobine, ou

- plusieurs instructions en IL. Le résultat courant IL en fin de liste contient le résultat de la condition.

Quand la condition est programmée en ST, l'expression peut optionnellement être terminée par un point-virgule. Quand la condition est programmée en LD, la bobine unique représente la valeur de la condition. Une condition peut être égale à:

- FALSE qui représente la décision NO

- TRUE qui représente la décision YES

Un test doit toujours avoir une connection en amont et deux connections aval reliées à ses orties "Yes" et "No".


Sous-programmes FC

ISaGRAF permet la représentation d'une structure verticale de programmes FC. Les programmes FC sont organisés dans un arbre de hiérarchie. Chaque programme FC peut appeler un ou plusieurs sous-programmes FC. Les programmes FC sont reliés dans l'arbre de hiérarchie par une relation de type "père / fils" matérialisé par un lien terminé par une flèche:

Un symbole de sous-programme dans un diagramme Flow Chart représente un appel au sous programme. L'exécution du programme appelant est suspendue pendant toute l'exécution du sous-programme. Un sous-programme Flow Chart est identifié ar son nom et par un numéro. Voici le dessin d'un appel de sous-programme:

Deux objets du diagramme ne peuvent pas avoir le même numéro. Les règles suivantes doivent être respectées pour la mise en œuvre de la hiérarchie des programmes FC:

- Les programmes FC n'ayant pas de père sont appelés programmes principaux.

- Les programmes principaux FC sont activés au lancement de l'application.

- Un programme peut avoir un ou plusieurs sous-programmes.

- Un sous-programme ne peut pas avoir plusieurs programmes pères.

- Un sous-programme ne peut être appelé que par son programme père.

- Un programme ne peut pas appeler un fils d'un de ses fils

L'appel au même sous-programme peut apparaître plusieurs foid dans le même diagramme. Un appel de sous-programme FC représente l'exécution totale du sous-programme. Le programme père est suspendu pendant l'exécution du sous-programme. Un appel de sous-programme doit avoir des connections en amont et en aval vers les autres éléments du diagramme.


Actions spécifiques

Un symbole d'action spécifique représente une série d'actions à exécuter. Comme les autres symboles actions, il est identifié par un numéro et un nom. L'exécution d'une action spécifique n'a pas de différence avec celle d'une action normale. Le but des actions spécifiques est simplement de rendre le diagramme plus lisible en marquand les parties non portables du programme. L'utilisation des symboles d'action spécifique est optionnelle. Voici le dessin d'une action spécifique:

Les actions spécifiques ont rigoureusement le même comportement que les autres actions, qu'il s'agisse du mode de programmation, des règles de connection aux autres éléments du diagramme, ou du comportement dynamique.


Connecteurs

Les connecteurs permettent d'exprimer une liaison entre deux points du diagramme, sans que le trait de la liaison complète soit tracé. Un connecteur est représenté par un cercle, connecté par un trait de liaison à la source du lien à exprimer. Le dessin du connecteur est complété, à sa droite, par le nom de l'élément qui est la destination du lien. Voici le dessin d'un connecteur:

Un connecteur se réfère toujours à un élément défini dans le même diagramme. La destination de la liaison est exprimée par le numéro de l'élément de destination.


Commentaires

Les blocs de commentaires n'ont pas d'influence sur le comportement du diagramme. Ils peuvent être insérés partout dans le diagramme, et permettent de documenter le programme. Voici le dessin d'un bloc de commentaire:


Exemples de structures complexes FC

Cette section montre des exemples de structures complexes pouvant apparaître dans les diagrammes FC. Ces combinaisons de base permettent la construction de diagrammes structurés.

	IF / THEN / ELSE (1) les actions pour "THEN" sont insérées ici (2) les actions pour "ELSE" sont insérées ici
	REPEAT / UNTIL (3) les actions à répéter sont insérées ici
	WHILE / DO (4) les actions à répéter sont insérées ici


Comportement dynamique du FC

Voici les règles de base de l'exécution d'un diagramme Flow Chart:

- L'activation du symbole Begin nécesite un cycle sur la cible

- L'activation du symbole End nécessite un cycle sur la cible et engendre la fin de l'exécution du diagramme. Aucune action n'est plus exécutée après le symboel End.

- L'exécution est poursuivie, dans le même cycle, jusqu'à ce qu'un élément déjà rencontré soit rencontré à nouveau (boucle).

Note: Contrairement au SFC, une action n'est pas un état stable. Il n'y a jamais de répétition des instructions quand le symbole d'une action est rencontré.


Syntaxe du FC

En plus des règles syntaxiques des actions et conditions programmées en ST, LD ou IL, d'autres règles syntaxiques s'appliquent au diagramme lui-même:

- Tous les "points de connection" des symboles doivent être correctement reliés aux autres éléments du graphe. (seule la connection entrée du symbole "End" peut être omise)

- Tous les symboles doivent être reliés ensemble (pas de partie de graphe isolée)

- Tous les connecteurs doivent avoir une destination valide

Il est à noter que:

- Les actions vides (sans programmation) sont autorisées

- Les décisions vides (sans programmation) sont considérés comme toujours égales à TRUE.