Instructions

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

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

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

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

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

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

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

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

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

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

Affectation par défaut

A gauche d'une affectation figure un opérande (variable, adresse) auquel l'opérateur d'affectation := attribue 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, reportez-vous au paragraphe Exemple d'appel avec affectations du chapitre Appel d'un bloc fonction.

Exemple

a:= b;

a obtient 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 a la valeur TRUE lors du traitement de l'affectation.

Si b est FALSE lors du traitement de l'affectation, la valeur de 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 est défini sur FALSE dès que b est TRUE.

Exemple

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

Dans ce cas, b sera la valeur de sortie réinitialisée de fun1. Toutefois, a n'obtient 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. Il s'agit d'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;

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 suivant, un bloc fonction de temporisateur (TON) est appelé avec des affectations pour les paramètres IN et PT. La variable de résultat Q est ensuite affectée à la variable A. Le bloc fonction de temporisateur est instancié par TMR:TON;. La variable de résultat, comme dans le langage IL, est adressée selon la syntaxe <nom d'instance FB>.<variable FB> :

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

Une autre syntaxe est disponible pour les sorties :

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

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 quitté immédiatement.

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

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.

Avec l'instruction CASE permet de combiner dans une structures plusieurs instructions conditionnelles partageant 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 <valeuri>, l'instruction <instruction i> est exécutée.

• Si <Var 1> n'a 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 écrire ces valeurs l'une après l'autre en les séparant par une virgule afin de conditionner l'exécution commune.

• 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;

La boucle FOR permet de programmer des processus répétitifs.

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 se termine lorsque <INT_Var> dépasse <VALEUR_FIN>.

Exemple

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

En supposant que la valeur par défaut de Var1 est 1. Sa valeur sera 32 après l'exécution de la boucle FOR.

Vous pouvez utiliser l'instruction CONTINUE au sein d'une boucle FOR. Il s'agit d'une extension de la norme IEC 61131-3.

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

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 au sein d'une boucle WHILE.

Comme la boucle WHILE, la boucle REPEAT constitue une alternative à la boucle FOR. La boucle REPEAT diffère de la boucle WHILE en ce que la condition de sortie n'est évaluée qu'après au moins une exécution de la boucle, à 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.

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 au sein d'une boucle REPEAT. Il s'agit d'une extension de la norme IEC 61131-3.

En tant qu'extension de la norme IEC 61131-3, l'instruction CONTINUE est prise en charge dans les boucles FOR, WHILE et REPEAT. CONTINUE permet de passer au 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;

Vous pouvez utiliser l'instruction JMP pour accéder de manière inconditionnelle à 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 de l'indication de la destination du saut, laquelle doit correspondre à une étiquette prédéfinie.

L'exemple suivant présente des instructions qui créent des conditions logiques permettant d'éviter 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é à 0, a une valeur inférieure à 10, l'instruction de saut de l'exemple ci-dessus entraîne un retour répété à la ligne de programme définie par l'étiquette _label1. Il s'ensuit que les instructions comprises entre l'étiquette et l'instruction JMP vont être traitées de manière répétitive. Comme 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 le flux 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.

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

Il existe deux possibilités pour écrire des commentaires dans un objet de texte structuré :

• Commencer le commentaire par (* et le fermer avec *). Vous pouvez ainsi insérer des commentaires occupant plusieurs lignes.

  Exemple : (*This is a comment.*)

• Utiliser des commentaires d'une seule ligne, par extension de la norme IEC 61131-3, qui sont marqués de deux manières différentes :

  • // indique le début d'un commentaire qui se termine à la fin de la ligne.

    Exemple : // This is a comment.

  • /// indique le début d'un commentaire qui se termine à la fin de la ligne.

    Exemple : /// This is a comment.

  Exemple de commentaires pour les info-bulles et la documentation des POU :

  A tooltip in the header of a POU is defined by the following comment:
      // tooltip text – line 1
      // tooltip text – line 2
      // tooltip text – line 3
  
      Afterwards the documentation is defined as follows:
      /// reStructuredText

  Pour plus d'informations sur la gestion des deux types de commentaires lors de la création de documentation de bibliothèque à l'aide de l'outil CODESYS LibDoc Scripting Collection avec la propriété LibDocContent, consultez Propriétés de bibliothèque.

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 la parenthèse qui suit checked, mais uniquement par la dernière parenthèse.