Instructions

Présentation

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

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

Instruction

Exemple

affectation 

A:=B; CV := CV + 1; C:=SIN(X);

Appel d'un bloc fonction et utilisation de la sortie correspondante 

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

RETURN

RETURN;

IF 

D:=B*B;
IF D<0.0 THEN
C:=A;
ELSIF D=0.0 THEN
C:=B;
ELSE
C:=D;
END_IF;

CASE 

CASE INT1 OF
1: BOOL1 := TRUE;
2: BOOL2 := TRUE;
ELSE
 BOOL1 := FALSE;
 BOOL2 := FALSE;
END_CASE;

FOR 

J:=101;
FOR I:=1 TO 100 BY 2 DO
IF ARR[I] = 70 THEN
J:=I;
'EXIT;
END_IF;
END_FOR;

WHILE 

J:=1;
WHILE J<= 100 AND ARR[J] <> 70 DO
J:=J+2;
END_WHILE;

REPEAT 

J:=-1;
REPEAT
J:=J+2;
UNTIL J= 101 OR ARR[J] = 70
END_REPEAT;

EXIT

EXIT;

CONTINUE

CONTINUE;

JMP 

label1: i:=i+1;
IF i=10 THEN
    JMP label2;
END_IF
JMP label1;
label2:

Instruction vide

;

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 

<variable name> REF= <variablename> ;

Exemple 

refA : 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_boolé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 :

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

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

  • Si 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 une virgule, afin de conditionner l'exécution courante.

  • Si 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 dans l'exemple ci-dessus), on obtient une boucle infinie. 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.
 AVERTISSEMENT
BOUCLE INFINIE
Assurez-vous que le type de variable utilisé dans les instructions FOR est suffisamment élevé pour prendre en charge l'opération <VALEUR_FIN> + 1.
Le non-respect de ces instructions peut provoquer la mort, des blessures graves ou des dommages matériels.

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 WHILE constitue une alternative à la boucle FOR, car 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.

 AVERTISSEMENT
BOUCLE INFINIE
Assurez-vous que la boucle WHILE se termine lors de l'exécution des instructions en créant une condition FALSE de l'expression booléenne contrôlant la boucle WHILE.
Le non-respect de ces instructions peut provoquer la mort, des blessures graves ou des dommages matériels.

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

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

Boucle REPEAT

La boucle REPEAT constitue une alternative à la boucle FOR, à l'instar de la boucle WHILE. La boucle REPEAT est différente de la boucle WHILE dans la mesure où la condition de sortie est évaluée uniquement après que la boucle a été exécutée au moins une fois, à la fin de la boucle.

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.

 AVERTISSEMENT
BOUCLE INFINIE
Assurez-vous que la boucle REPEAT se termine lors de l'exécution des instructions en créant une condition TRUE de l'expression booléenne.
Le non-respect de ces instructions peut provoquer la mort, des blessures graves ou des dommages matériels.

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.

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.

 AVERTISSEMENT
BOUCLE INFINIE
Vérifiez que l'utilisation de l'instruction JMP est conditionnelle.
Le non-respect de ces instructions peut provoquer la mort, des blessures graves ou des dommages matériels.

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 :

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

  • Commentaire 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.