Pragma condizionale

L'operatore fa in modo che all'espressione venga assegnato il valore TRUE quando la variabile <variable name> è dichiarato nell'ambito di applicazione attuale. Altrimenti FALSE viene restituito.

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

L'operatore fa in modo che all'espressione venga assegnato il valore TRUE. Il requisito è che l'identificatore <identifier> è stato definito mediante a {define} enunciato e non indefinito successivamente con an {undefine} dichiarazione. Altrimenti FALSE viene restituito.

{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'operatore fa in modo che all'espressione venga assegnato il valore TRUE quando un tipo di dati viene dichiarato con l'identificatore <identifier>. Altrimenti FALSE viene restituito.

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

L'operatore fa in modo che all'espressione venga assegnato il valore TRUE quando uno dei seguenti oggetti con nome <pou-name> esiste:

Altrimenti FALSE viene restituito.

{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'operatore fa in modo che all'espressione venga assegnato il valore TRUE se un oggetto risorsa denominato <identifier> esiste per l'applicazione; altrimenti FALSE viene restituito.

{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'operatore fa in modo che all'espressione venga assegnato il valore TRUE quando un'attività è definita con il nome <task name>. Altrimenti FALSE viene restituito.

Sintassi

{ 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'operatore fa in modo che all'espressione venga assegnato il valore FALSE quando la memoria della CPU è organizzata in Big Endian (ordine dei byte di Motorola).

L'operatore fa in modo che all'espressione venga assegnato il valore TRUE quando l'applicazione viene eseguita su un dispositivo simulato (in modalità simulazione).

Per ulteriori informazioni, vedere: Test in modalità simulazione

Se l'espressione restituisce il valore TRUE, quindi il generatore di codice produce un codice FPU (per l'unità di elaborazione a virgola mobile) durante il calcolo con REAL i valori. In caso contrario, le operazioni FPU vengono emulate, il che è molto più lento.

L'operatore fa in modo che all'espressione venga assegnato il valore TRUE quando l'attributo <attribute> è specificato nella prima riga della parte di dichiarazione del blocco funzione <pou name>. Altrimenti FALSE viene restituito.

{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'operatore fa in modo che all'espressione venga assegnato il valore TRUE quando il pragma {attribute '<attribute>'} viene assegnato alla variabile nella riga prima della dichiarazione della variabile. Altrimenti FALSE viene restituito.

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'operatore verifica o meno la costante con cui si identifica <constant name>, È stato sostituito. Il secondo parametro (valore booleano) controlla ciò che viene verificato:

Quando si verifica il rispettivo caso, l'operatore ritorna TRUE.

Sintassi

{ 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'operatore confronta il valore della costante identificata con <constant name>, con il valore del secondo parametro. Il secondo parametro può essere specificato sia come valore letterale <literal> o come variabile <variable name>.

Sintassi

{ 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'operatore fa in modo che all'espressione venga assegnato il valore TRUE quando la variabile <variable> è del tipo di dati <type-spec>. Altrimenti FALSE viene restituito.

Possibili tipi di dati:

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}

La modalità pacchetto selezionato dipende dalla descrizione del dispositivo, non dal pragma che può essere specificato per i singoli DUT.

<register size>: Dimensione di un registro della CPU (in bit)

L'operatore fa in modo che l'espressione restituisca il valore TRUE quando la dimensione di un registro della CPU è uguale a <register size>.

L'operatore fa in modo che all'espressione venga assegnato il valore TRUE quando una variabile è definita con l'identificatore <define-ident> e ha il valore <char-string>. Altrimenti FALSE viene restituito.

{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}

All'espressione viene assegnato il valore TRUE quando il valore inverso di <operator> restituisce il valore TRUE. <operator> può essere uno degli operatori descritti in questo capitolo.

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

All'espressione viene assegnato il valore TRUE quando i due operatori specificati ritornano TRUE. <operator> può essere uno degli operatori descritti in questo capitolo.

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

L'espressione ritorna TRUE quando uno dei due operatori specificati ritorna TRUE. <operator> può essere uno degli operatori qui descritti.

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

() tra parentesi gli operatori.