Pragmes Conditionnels

L'opérateur donne à l'expression la valeur TRUE lorsque la variable <variable name> est déclaré dans le périmètre courant. Autrement FALSE est retourné.

{IF defined (variable: g_bTest)}
    (* the following code is only processed in App2*)
    g_bTest := x > 300;
{END_IF}

L'opérateur donne à l'expression la valeur TRUE. L'exigence est que l'identifiant <identifier> a été défini au moyen d'un {define} déclaration et non indéfini après avec un {undefine} déclaration. Autrement FALSE est retourné.

{IF defined (pdef1)}
(* This code is processed in App1 *)
{info 'pdef1 defined'}
    hugo := hugo + SINT#1;
{ELSE}
(* the following code is only processed in App2 *)
{info 'pdef1 not defined'}
    hugo := hugo - SINT#1;
{END_IF}

L'opérateur donne à l'expression la valeur TRUE lorsqu'un type de données est déclaré avec l'identifiant <identifier>. Autrement FALSE est retourné.

{IF defined (type: DUT)}
    (* the following code is only processed in App1*)
    bDutDefined := TRUE;
{END_IF}

L'opérateur donne à l'expression la valeur TRUE lorsque l'un des objets suivants avec le nom <pou-name> existe :

Autrement FALSE est retourné.

{IF defined (pou: CheckBounds)}
    (* the following code is only processed in App1 *)
    arrTest[CheckBounds(0,i,10)] := arrTest[CheckBounds(0,i,10)] + 1;
{ELSE}
    (* the following code is only processed in App2 *)
    arrTest[i] := arrTest[i]+1;
{END_IF}

L'opérateur donne à l'expression la valeur TRUE si un objet ressource nommé <identifier> existe pour l'application ; autrement FALSE est retourné.

{IF defined (resource:glob_var1)}
    (* the following code is only processed in App1 *)
    gvar_x := gvar_x + ivar;
{ELSE}
    (* the following code is only processed in App2 *)
    x := x + ivar;
{END_IF}

L'opérateur donne à l'expression la valeur TRUE lorsqu'une tâche est définie avec le nom <task name>. Autrement FALSE est retourné.

Syntaxe

{ IF defined (task: <task name> }
{ ELSIF defined (task: <task name> }

{IF defined (task: PLC_PRG_Task)}
    (* the following code is only processed in App1 *)
    erg := plc_prg.x;
{ELSE}
    (* the following code is only processed in App2 *)
    erg := prog.x;
{END_IF}

L'opérateur donne à l'expression la valeur FALSE lorsque la mémoire CPU est organisée en Big Endian (ordre des octets Motorola).

L'opérateur donne à l'expression la valeur TRUE lorsque l'application s'exécute sur un appareil simulé (en mode simulation).

Pour plus d'informations, consultez : Test en mode simulation

Si l'expression renvoie la valeur TRUE, alors le générateur de code produit un code FPU (pour le processeur d'unité à virgule flottante) lors du calcul avec REAL valeurs. Sinon, les opérations FPU sont émulées, ce qui est beaucoup plus lent.

L'opérateur donne à l'expression la valeur TRUE lorsque l'attribut <attribute> est spécifié dans la première ligne de la partie déclaration du bloc fonction <pou name>. Autrement FALSE est retourné.

{attribute 'vision'}
FUNCTION fun1 : INT
VAR_INPUT
    i : INT;
END_VAR
VAR
END_VAR

FUNCTION fun1 : INT
VAR_INPUT
    i : INT;
END_VAR
VAR
END_VAR

{IF hasattribute (pou: fun1, 'vision')}
    (* the following code is only processed in App1 *)
    ergvar := fun1(ivar);
{END_IF}

L'opérateur donne à l'expression la valeur TRUE quand le pragma {attribute '<attribute>'} est affecté à la variable dans la ligne avant la déclaration de la variable. Autrement FALSE est retourné.

VAR_GLOBAL
    {attribute 'DoCount'}
    g_globalInt : INT;
    g_multiType : STRING;
END_VAR

VAR_GLOBAL
    g_globalInt : INT;
    g_multiType : STRING;
END_VAR

{IF hasattribute (variable: g_globalInt, 'DoCount')}
    (* the following code is only processed in App1 *)
    g_globalInt := g_globalInt + 1;
{END_IF}

L'opérateur vérifie si la constante, qui est identifiée par <constant name>, a été remplacé. Le deuxième paramètre (valeur booléenne) contrôle ce qui est coché :

Lorsque le cas respectif se produit, l'opérateur retourne TRUE.

Syntaxe

{ IF hasconstanttype( <constant namne> , <boolean literal> ) }
{ ELSIF hasconstanttype( <constant namne> , <boolean literal> ) }

VAR
    iCntMAXIsReplaced: INT;
    xErrorOccured : BOOL;
END_VAR
VAR CONSTANT
    c_iMAX: INT := 99;
END_VAR

{IF hasconstanttype(c_iMAX, TRUE)}
    iCntMAXIsReplaced := iCntMAXIsReplaced + 1;
{ELSE}
    xErrorOccured := FALSE;
{END_IF}

L'opérateur compare la valeur de la constante, qui est identifiée par <constant name>, avec la valeur du deuxième paramètre. Le deuxième paramètre peut être spécifié soit comme un littéral <literal> ou comme variable <variable name>.

Syntaxe

{ IF hasconstantvalue( <constant name> , <variable name> , <comparison operator> )
{ IF hasconstantvalue( <constant name> , <literal> , <comparison operator> )
{ ELSIF hasconstantvalue( <constant name> , <variable name> , <comparison operator> )
{ ELSIF hasconstantvalue( <constant name> , <literal> , <comparison operator> )

PROGRAM PRG_ConditionConstantValue
VAR
    iCntMAX: INT;
    iCntGlobalMAX : INT;
    iCntABC: INT;
    iCntGlobalABC : INT;
    xErrorOccured : BOOL;
END_VAR
VAR CONSTANT
    c_iMAX: INT := 999;
    c_sABC: STRING := 'ABC';
    {attribute 'const_non_replaced'}
    c_iNonReplaceable: INT := 888;
END_VAR

{IF hasconstantvalue(c_iMAX, 999, =)}
    iCntMAX := iCntMAX + 1;
{ELSE}
    xErrorOccured := FALSE;
{END_IF}

{IF hasconstantvalue(c_iMAX, GVL.gc_iMAX, =)}
    iCntGlobalMAX := iCntGlobalMAX + 1;
{ELSE}
    xErrorOccured := FALSE;
{END_IF}

{IF hasconstantvalue(c_sABC, 'ABC', =)}
    iCntABC := iCntMAX + 1;
{ELSE}
    xErrorOccured := FALSE;
{END_IF}
{IF hasconstantvalue(c_sABC, GVL.gc_sABC, =)}
    iCntGlobalABC := iCntMAX + 1;
{ELSE}
    xErrorOccured := FALSE;
{END_IF}

L'opérateur donne à l'expression la valeur TRUE lorsque la variable <variable> est du type de données <type-spec>. Autrement FALSE est retourné.

Types de données possibles :

BOOL | BYTE | DATE | DATE_AND_TIME | DT | DINT | DWORD | INT | LDATE | LDATE_AND_TIME | LDT | LINT | LREAL | LTIME | LTIME_OF_DAY | LTOD | LWORD | REAL | SINT | STRING | TIME | TIME_OF_DAY | TOD | ULINT | UDINT | UINT | USINT | WORD | WSTRING

{IF (hastype (variable: g_multitype, LREAL))}
    (*  the following code is only processed in App1 *)
    g_multitype := (0.9 + g_multitype) * 1.1;
{ELSIF (hastype (variable: g_multitype, STRING))}
    (* the following code is only processed in App2 *)
    g_multitype := 'this is a multitalent';
{END_IF}

Le mode de pack vérifié dépend de la description de l'appareil, et non du pragma qui peut être spécifié pour les DUT individuels.

<register size>: Taille d'un registre CPU (en bits)

L'opérateur fait en sorte que l'expression renvoie la valeur TRUE lorsque la taille d'un registre CPU est égale à <register size>.

L'opérateur donne à l'expression la valeur TRUE lorsqu'une variable est définie avec l'identifiant <define-ident> et a la valeur <char-string>. Autrement FALSE est retourné.

{IF hasvalue(test,'1')}
    (*  the following code is only processed in App1 *)
    x := x + 1;
{ELSIF hasvalue(test,'2')}
    (*  the following code is only processed in App2 *)
        x := x + 2;
{END_IF}

L'expression prend la valeur TRUE lorsque la valeur inverse de <operator> renvoie la valeur TRUE. <operator> peut être l'un des opérateurs décrits dans ce chapitre.

{IF defined (pou: PLC_PRG1) AND NOT (defined (pou: CheckBounds))}
    (* the following code is only processed in App2 *)
    bANDNotTest := TRUE;
{END_IF}

L'expression prend la valeur TRUE lorsque les deux opérateurs spécifiés reviennent TRUE. <operator> peut être l'un des opérateurs décrits dans ce chapitre.

{IF defined (pou: PLC_PRG1) AND (defined (pou: CheckBounds))}
    (* the following code is only processed in App1 *)
    bANDTest := TRUE;
{END_IF}

L'expression retourne TRUE lorsque l'un des deux opérateurs spécifiés revient TRUE. <operator> peut être l'un des opérateurs décrits ici.

{IF defined (pou: PLC_PRG1) OR (defined (pou: CheckBounds))}
    (* the following code is only processed in App1 and in App2 *)
    bORTest := TRUE;
{END_IF}

() met entre parenthèses les opérateurs.