Instructions

Présentation

Les instructions définissent le traitement à appliquer aux expressions .

Les instructions suivantes peuvent être utilisées dans ST :

Opérateurs d'affectation

Affectation par défaut

A gauche d'une affectation figure un opérande (variable, adresse) auquel l'opérateur d'affectation := affecte la valeur de l'expression située à droite.

Consultez également la description de l'opérateur MOVE dont la fonction est la même.

Pour obtenir un exemple avec affectation, consultez le paragraphe Exemple d'appel avec affectations du chapitre Appel d'un bloc fonction.

Exemple

a:= b;

a prend la valeur de b.

Opérateur de définition S=

La valeur est définie ; si elle est définie une fois sur TRUE, elle le reste.

Exemple

a S= b;

a est défini sur TRUE si b est TRUE lors du traitement de l'affectation.

Si b est FALSE lors du traitement de l'affectation, la valeur a ne change pas.

Opérateur de réinitialisation R=

La valeur est réinitialisée ; si elle est définie une fois sur FALSE, elle le reste.

Exemple

a R= b;

a prend la valeur FALSE dès que b est TRUE.

NOTE : En cas d'affectations multiples, les affectations définies et réinitialisées font référence au dernier membre de l'affectation.

Exemple

a S= b R= fun1(par1,par2)

Dans ce cas, b correspond à la valeur de sortie réinitialisée de fun1. Toutefois, a ne prend pas la valeur définie de b, mais la valeur de sortie définie de fun1.

Notez qu'une affectation peut être utilisée en tant qu'expression. Cette fonction correspond à une extension de la norme IEC 61131-3.

Opérateur d'affectation REF

Cet opérateur génère une référence à une valeur.

Syntaxe

REF= <variable>

Exemple

A : REFERENCE TO DUT;
B : DUT;
C : DUT;
A REF= B; // corresponds to A := ADR(B);
A := C; // corresponds to A^ := C;

Appel de blocs fonction dans ST

Un bloc fonction (FB) est appelé dans le texte structuré selon la syntaxe suivante :

<nom de l'instance de FB>(variable d'entrée de FB:=<valeur ou adresse>|, <autre variable d'entrée de FB:=<valeur ou adresse>|…autres variables d'entrée de FB);

Exemple

Dans l'exemple ci-dessous, un bloc fonction de temporisateur (TON) est appelé avec des affectations pour les paramètres IN et PT. Puis la variable de résultat Q est affectée à la variable A. Le bloc fonction de temporisateur est instancié par TMR:TON;. Comme dans le langage IL, la variable de résultat est adressée selon la syntaxe <nom de l'instance de FB>.<variable de FB>:

TMR(IN := %IX5, PT := 300);
A:=TMR.Q;

Une autre syntaxe est disponible pour les sorties :

fb(in1:=myvar, out1=>myvar2);

Instruction RETURN

Vous pouvez utiliser l'instruction RETURN pour quitter un POU.

Syntaxe

RETURN;

Exemple

IF b=TRUE THEN
RETURN;
END_IF;
a:=a+1;

Si b a la valeur TRUE, l'instruction a:=a+1; n'est pas exécutée. Par conséquent, le POU est fermé immédiatement.

Instruction IF

L'instruction IF permet de tester une condition et, suivant celle-ci, d'exécuter des instructions.

Syntaxe

IF <expression_booléenne1> THEN

<instructions_IF>

{ELSIF <expression_booléenne2> THEN

<instructions_ELSIF1>

..

..

ELSIF <expression_booléenne n> THEN

<instructions_ELSIF-1>

ELSE

<instructions_ELSE>}

END_IF;

La partie entre accolades {} est facultative.

Si <expression_booléenne1> renvoie la valeur TRUE, seules les <instructions_IF> sont exécutées. Dans le cas contraire, les expressions booléennes à partir de <expression_boo­léenne2> sont évaluées l'une après l'autre jusqu'à ce que l'une d'elles renvoie la valeur TRUE. Ensuite, seules les instructions qui suivent cette expression booléenne et qui précèdent l'instruction ELSE ou ELSIF suivante, sont évaluées. Si aucune expression booléenne ne renvoie TRUE, seules les <instructions_ELSE> sont évaluées.

Exemple

IF temp<17
THEN heating_on := TRUE;
ELSE heating_on := FALSE;
END_IF;

Dans cet exemple, le chauffage s'allume lorsque la température est inférieure à 17 degrés. Sinon, il reste éteint.

Instruction CASE

L'instruction CASE permet de combiner dans une structure plusieurs instructions conditionnelles ayant la même variable de condition.

Syntaxe

CASE <Var1> OF

<valeur1>: <instruction 1>

<valeur2>: <instruction 2>

<valeur3, valeur4, valeur5>: <instruction 3>

<valeur6…valeur10>: <instruction4>

..

..

<valeur n>: <instruction n>

ELSE <instruction ELSE>

END_CASE;

Une instruction CASE est traitée selon le modèle suivant :

oSi la variable <Var1> a la valeur <valeur 1>, l'instruction <instruction 1> est exécutée.

oSi <Var 1> n'est défini sur aucune des valeurs indiquées, l'instruction <instruction ELSE> est exécutée.

oSi la même instruction doit être exécutée pour plusieurs valeurs des variables, vous pouvez les écrire l'une après l'autre en les séparant par des virgules, afin de conditionner l'exécution courante.

oSi la même instruction doit être exécutée pour une plage de valeurs d'une variable, vous pouvez écrire la valeur initiale et la valeur de fin séparées par deux points. Ainsi, vous pouvez conditionner l'exécution courante.

Exemple

CASE INT1 OF
1, 5: BOOL1 := TRUE;
      BOOL3 := FALSE;
2: BOOL2 := FALSE;
      BOOL3 := TRUE;
10..20: BOOL1 := TRUE;
      BOOL3:= TRUE;
ELSE
    BOOL1 := NOT BOOL1;
    BOOL2 := BOOL1 OR BOOL2;
END_CASE;

Boucle FOR

La boucle FOR permet de programmer des processus de manière répétée.

Syntaxe

INT_Var:INT;

FOR <INT_Var> := <VALEUR_INIT> TO <VALEUR_FIN> {BY <intervalle>} DO

<instructions>

END_FOR;

La partie entre accolades {} est facultative.

Les <instructions> sont exécutées tant que le compteur <INT_Var> ne dépasse pas <VALEUR_FIN>. La vérification a lieu avant l'exécution des <instructions>, pour éviter que celles-ci soient exécutées si <VALEUR_INIT> est supérieur à <VALEUR_FIN>.

Lorsque les <instructions> sont exécutées, <INT_Var> est incrémenté de <intervalle>. L'intervalle peut être une valeur entière quelconque. Si cette valeur n'est pas indiquée, elle est définie sur 1. La boucle s'arrête dès lors que <INT_Var> dépasse <VALEUR_FIN>.

Exemple

FOR Counter:=1 TO 5 BY 1 DO
Var1:=Var1*2;
END_FOR;
Erg:=Var1;

Supposons que la valeur par défaut de Var1 soit 1. Elle aura la valeur 32 après l'exécution de la boucle FOR.

NOTE : si <VALEUR_FIN> équivaut à la valeur limite du type de données de <INT_Var> (le compteur de l'exemple ci-dessus), vous obtenez une boucle infinie (sans fin). Avec un compteur de type SINT, par exemple, et une <VALEUR_FIN> égale à 127 (valeur positive maximale pour une variable SINT), la boucle ne se termine jamais. En effet, si vous ajoutez 1 à cette valeur maximale, la variable devient négative et ne dépasse jamais les limites imposées par l'instruction FOR.

Vous pouvez utiliser l'instruction CONTINUE dans une boucle FOR. Cette fonction correspond à une extension de la norme IEC 61131-3.

Boucle WHILE

La boucle FOR constitue une alternative à la boucle WHILE ; elle exécute la boucle si une condition booléenne est TRUE et tant qu'elle le reste. Si la valeur initiale de la condition n'est pas TRUE, la boucle n'est pas exécutée. Si la condition dont la valeur initiale était TRUE devient FALSE, la boucle prend fin.

Syntaxe

WHILE <expression booléenne> DO

<instructions>

END_WHILE;

Naturellement, l'expression booléenne initiale et en cours doit avoir la valeur FALSE à un moment donné lors de l'exécution des instructions de la boucle. Sinon, la boucle ne prend jamais fin, ce qui crée une condition de boucle infinie (sans fin).

L'exemple suivant présente des instructions entraînant la fin de la boucle :

WHILE Counter>0 DO
 Var1 := Var1*2;
 Counter := Counter-1;
END_WHILE

L'instruction REPEAT n'est pas encore mise en œuvre. Le paragraphe (avec la modification) est donc déplacé plus bas.

Vous pouvez utiliser l'instruction CONTINUE dans une boucle WHILE.

Boucle REPEAT

La boucle REPEAT constitue une seconde alternative à la boucle FOR, à l'instar de la boucle WHILE. La boucle REPEAT est différente de la boucle WHILE, car la condition de sortie n'est évaluée qu'à la fin de la boucle, après une exécution au moins de celle-ci.

Syntaxe

REPEAT

<instructions>

UNTIL <expression booléenne>

END_REPEAT;

Les <instructions> sont exécutées de façon répétée jusqu'à ce que l'<expression booléenne> renvoie TRUE. Si c'est le cas dès la première évaluation UNTIL, les <instructions> sont exécutées une fois seulement. L'<expression booléenne> doit prendre la valeur TRUE à un moment donné lors de l'exécution des instructions de la boucle. Sinon, la boucle ne prend jamais fin, ce qui crée une condition de boucle infinie (sans fin).

L'exemple suivant présente des instructions entraînant la fin de la boucle :

REPEAT
 Var1 := Var1*2;
 Counter := Counter-1;
UNTIL
 Counter=0
END_REPEAT;

Vous pouvez utiliser l'instruction CONTINUE dans une boucle REPEAT. Cette fonction correspond à une extension de la norme IEC 61131-3.

D'une certaine manière, les boucles WHILE et REPEAT sont plus puissantes que la boucle FOR, car il n'est pas nécessaire de connaître le nombre de cycles pour les exécuter. Dans certains cas, vous pourrez donc n'utiliser que ces deux types de boucle. Toutefois, si le nombre de cycles est défini, une boucle FOR est préférable. En effet, dans la plupart des cas, elle exclut automatiquement les boucles sans fin (consultez l'avertissement dans le FORparagraphe relatif à la boucle ).

Instruction CONTINUE

Extension de la norme IEC 61131-3, l'instruction CONTINUE est prise en charge dans les boucles FOR, WHILE et REPEAT. CONTINUE permet d'exécuter le cycle de boucle suivant.

Exemple

FOR Counter:=1 TO 5 BY 1 DO
INT1:=INT1/2;
IF INT1=0 THEN
CONTINUE; (* to avoid division by zero *)
END_IF
Var1:=Var1/INT1; (* only executed, if INT1 is not "0" *)
END_FOR;
Erg:=Var1;

Instruction EXIT

L'instruction EXIT met fin à la boucle FOR, WHILE ou REPEAT à laquelle elle appartient, de façon non conditionnelle.

Instruction JMP

Vous pouvez utiliser l'instruction JMP pour accéder de manière non conditionnelle à une ligne de code identifiée par une étiquette de saut.

Syntaxe

JMP <étiquette>;

L'<étiquette> est un identifiant unique arbitraire ajouté au début d'une ligne de programme. L'instruction JMP doit être suivie par l'indication de la destination qui doit correspondre à une étiquette prédéfinie.

L'exemple suivant présente des instructions qui créent des conditions logiques permettant d'éviter qu'une boucle infinie entre le saut et sa destination :

aaa:=0;
_label1: aaa:=aaa+1;
(*instructions*)
IF (aaa < 10) THEN
JMP _label1;
END_IF;

Tant que la variable i, initialisée à 0, a une valeur inférieure à 10, l'instruction de saut dans l'exemple ci-dessus entraîne un retour répété à la ligne du programme identifiée par _label1. Par conséquent, les instructions comprises entre l'étiquette et l'instruction JMP sont traitées indéfiniment. Étant donné que ces instructions incluent également l'incrémentation de la variable i, la condition de saut est transgressée (lors de la neuvième vérification) et l'exécution du programme se poursuit.

Vous pouvez également obtenir ce résultat en utilisant une boucle WHILE ou REPEAT dans l'exemple. En général, les instructions de saut nuisent à la lisibilité du code.

Commentaires dans ST

Pour écrire des commentaires dans un objet de texte structuré, deux possibilités sont offertes :

oDémarrez le commentaire par (* et fermez-le par *). Vous pouvez ainsi insérer des commentaires occupant plusieurs lignes. Exemple : (*Ceci est un commentaire.*)

oCommentaire d'une ligne (extension de la norme IEC 61131-3) : // indique le début d'un commentaire qui se termine à la fin de la ligne. Exemple  : // Ceci est un commentaire.

Vous pouvez placer des commentaires à l'endroit de votre choix dans la partie déclaration ou implémentation de l'éditeur ST.

Commentaires imbriqués : vous pouvez insérer des commentaires à l'intérieur de commentaires.

Exemple

(*
a:=inst.out; (* to be checked *)
b:=b+1;
*)

Dans cet exemple, le commentaire qui commence à la première parenthèse n'est pas fermé par celle qui suit checked, mais par la dernière parenthèse.