Skip to main content

Pragmas condicionales

Restricción en el caso de pragmas condicionales

Utilice pragmas para la compilación condicional solo en implementaciones de POU. En las declaraciones, estos pragmas se ignoran y no se evalúan.

Tenga en cuenta la siguiente excepción: el pragma IF con el project_defined El operador se puede insertar en las declaraciones. Para más información, consulte el pragma IF con project_defined (<global define>)

El compilador evalúa los pragmas durante la precompilación y la compilación. Esta operación se denomina compilación condicional. El lenguaje de implementación ST admite estos pragmas.

El {IF<expression> } pragmas junto con {ELSIF<expression> }, {ELSE}, y la conclusión {END_IF} Indica el código en las implementaciones que se conserva o se ignora según las condiciones especificadas. Las condiciones especificadas en <expression> son expresiones constantes enteras que pueden estar compuestas de diferentes operandos y operadores.

Al compilar, la primera expresión en el <{IF <expression>} se evalúa. Si su valor de retorno es FALSE, entonces la ramificación ocurrirá en el siguiente {ELSIF <expression>} segmento y la expresión evaluada allí hasta que un segmento devuelva una expresión con TRUE Las expresiones se evalúan sucesivamente hasta que una devuelve un valor distinto de 0. Solo se compilará este segmento de código asociado con una expresión positiva. Los demás se ignoran. Si todas las expresiones devuelven 0, la ramificación se produce después. {ELSE}. Si el {ELSE} Si falta pragma, es posible que no se compile ningún segmento de código.

Sintaxis

Ejemplo de fragmento de código

Descripción

{IF <expression> }

{IF defined (DEF0815)}
{info 'DEF0815 has been defined'}
Cnt0815 := iCnt0815 + 1;

Etiqueta el comienzo del segmento de código que se compila en el caso de una operación válida. <expression> condición.

{ELSIF <expression> }

{ELSIF defined (DEF0816)}
{info 'DEF0815 has been defined'}
iCnt0816 := iCnt0816 + 1;

Ninguno, uno o varios)

Rama que etiqueta el segmento de código alternativo si es válido <expression> condición

{ELSE}

{ELSE}
{info 'DEF0815 not defined'}
iCnt0 := iCnt0 - 1;

Opcional

Rama que etiqueta el segmento de código que se compila si no se cumplen las condiciones anteriores

{END_IF}

{END_IF}

Etiqueta el final del segmento de código condicional

<expression>

defined (DEF0815)

Condición

Expresión entera que es constante en tiempo de compilación y puede estar compuesta de operadores y operandos, como definiciones del compilador, variables o literales.

Definición del compilador

Las definiciones del compilador se utilizan como etiquetas para estados específicos del código. Una definición del compilador se puede establecer, eliminar o verificar mediante los operadores definidos.

Sintaxis

Ejemplo

Descripción

{define <name> }

{define DEF0815}

Define la definición del compilador. <name> con tipo BOOL

Nota

El compilador define <name> está sujeto a las reglas para identificadores válidos.

{define <name> <string> }

{define DEF0123 '123'}

Define la definición del compilador. <name> y asigna la cadena literal <string> como un valor

{undefine <name>}

{undefine DEF0815}

Elimina la definición del compilador <name>

Como resultado, el identificador no está definido. Se ignora un pragma con una definición de compilador indefinida.

Sugerencia

Como alternativa, también puede definir expresiones y definiciones del compilador localmente en las propiedades de una POU, o en toda la aplicación en las propiedades de la aplicación superordinada.

Para ello, seleccione la POU o la aplicación superior en el árbol de dispositivos. En el menú contextual, haga clic en Propiedades y luego seleccione el Construir pestaña. En el Define el compilador En el campo de entrada, puede definir un literal o una expresión (ejemplo: DEF0815). El campo de entrada no espera una sentencia pragmática como {define }, sino simplemente un nombre.

Puede especificar varias definiciones de compilador separadas por comas.

Operadores

defined (variable: <variable name> )

El operador hace que a la expresión se le dé el valor TRUE cuando la variable <variable name> se declara dentro del alcance actual. De lo contrario FALSE es regresado.

ejemplo 293. Ejemplo

Requisito: Las dos aplicaciones App1 y App2 existe. La variable g_bTest se declara en App1, pero no en App2.

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


defined (<identifier>)

El operador hace que a la expresión se le dé el valor TRUE. El requisito es que el identificador <identifier> ha sido definida por medio de un {define} declaración y no indefinida después con un {undefine} declaración. De lo contrario FALSE es regresado.

Requisito: Las aplicaciones App1 y App2 existe. El pdef1 variable está definida por una {define} declaración en App1, pero no en App2.

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

Esto también incluye un ejemplo de pragma de mensaje: Solo el mensaje pdef1 defined se muestra en la vista de mensajes cuando se compila la aplicación porque pdef1 está realmente definido. El mensaje pdef1 not defined se muestra cuando pdef1 no está definido.

defined (type: <identifier> )

El operador hace que a la expresión se le dé el valor TRUE cuando se declara un tipo de datos con el identificador <identifier>. De lo contrario FALSE es regresado.

ejemplo 294. Ejemplo

Requisito: Las dos aplicaciones App1 y App2 existe. el tipo de datos DUT se declara en App1, pero no en App2.

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


defined (pou: <pou name>)

El operador hace que a la expresión se le dé el valor TRUE cuando uno de los siguientes objetos con nombre <pou-name> existe:

  • Bloque de funciones

  • Función

  • Programa

  • Acción

  • Método

  • Interfaz

De lo contrario FALSE es regresado.

ejemplo 295. Ejemplo

Requisito: Las dos aplicaciones App1 y App2 existe. El POU CheckBounds existe en App1, pero no en App2.

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


defined (resource: <identifier>)

Importante

Aún sin implementar

El operador hace que a la expresión se le dé el valor TRUE si un objeto de recurso llamado <identifier> existe para la aplicación; de lo contrario FALSE es regresado.

Requisito: Las dos aplicaciones App1 y App2 existe. Un objeto de recurso glob_var1 de la lista de variables globales existe para App1, pero no para App2.

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

defined (task: <task name> )

El operador hace que a la expresión se le dé el valor TRUE cuando se define una tarea con el nombre <task name>. De lo contrario FALSE es regresado.

Sintaxis

{ IF defined (task: <task name> }
{ ELSIF defined (task: <task name> }
ejemplo 296. Ejemplo
{IF defined (task: Task_D)}


ejemplo 297. Ejemplo

Requisito: Las dos aplicaciones App1 y App2 existe. La tarea PLC_PRG_Task se define en App1, pero no en App2.

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


defined (IsLittleEndian)

El operador hace que a la expresión se le dé el valor FALSE cuando la memoria de la CPU está organizada en Big Endian (orden de bytes de Motorola).

defined (IsSimulationMode)

El operador hace que a la expresión se le dé el valor TRUE cuando la aplicación se ejecuta en un dispositivo simulado (en modo de simulación).

Para más información, ver: Pruebas en modo de simulación

defined (IsFPUSupported)

Si la expresión devuelve el valor TRUE, entonces el generador de código produce un código FPU (para el procesador de unidades de punto flotante) al calcular con REAL valores. De lo contrario, se emulan las operaciones de FPU, lo que es mucho más lento.

hasattribute (pou: <pou name>, ' <attribute name> ')

El operador hace que a la expresión se le dé el valor TRUE cuando el atributo <attribute> se especifica en la primera línea de la parte de declaración del bloque de función <pou name>. De lo contrario FALSE es regresado.

ejemplo 298. Ejemplo

Requisito: Las dos aplicaciones App1 y App2 existe. La función fun1 se declara en App1 y App2. Sin embargo, en App1 también se proporciona con el pragma {attribute 'vision'}.

En App1:

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

En App2:

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

Declaración pragmática:

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


hasattribute (variable: <variable name> , ' <attribute name> ')

El operador hace que a la expresión se le dé el valor TRUE cuando el pragma {attribute '<attribute>'} se asigna a la variable en la línea anterior a la declaración de la variable. De lo contrario FALSE es regresado.

ejemplo 299. Ejemplo

Requisito: Las dos aplicaciones App1 y App2 existe. La variable g_globalInt se usa en App1 y App2, pero en App1 el atributo 'DoCount' también se le asigna.

Declaración de g_GlobalInt en App1

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

Declaración g_GlobalInt en App2:

VAR_GLOBAL
    g_globalInt : INT;
    g_multiType : STRING;
END_VAR

Declaración pragmática:

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


hasconstanttype( <constant name> , <boolean literal> )

El operador comprueba si la constante, que se identifica con <constant name>, ha sido reemplazado. El segundo parámetro (valor booleano) controla lo que se comprueba:

  • TRUE: Comprueba si la constante ha sido reemplazada

  • FALSE: Comprueba si la constante no ha sido reemplazada

Cuando ocurre el caso respectivo, el operador regresa TRUE.

Sintaxis

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

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

ejemplo 300. Ejemplo
 {IF hasconstanttype(PLC_PRG.aConst, TRUE)}


. El reemplazo automático de constantes en principio depende de lo siguiente:
  • Opción de compilación Reemplazar constantes

  • Tipo constante (por ejemplo, STRING los tipos nunca se reemplazan.)

  • Uso del atributo {attribute 'const_non_replaced'}

  • Uso del atributo {attribute 'const_replaced'}

ejemplo 301. Ejemplo
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}


hasconstantvalue( <constant name> , <variable name> , <comparison operator> )

El operador compara el valor de la constante, que se identifica con <constant name>, con el valor del segundo parámetro. El segundo parámetro se puede especificar como un literal <literal> o como una variable <variable name>.

. Operadores de comparación <comparison operator>:
  • Mas grande que (>)

  • Mayor qué o igual a (>=)

  • Igual a (=)

  • No igual a (<>)

  • Menos que o igual a (<=)

  • Menos que (<)

Sintaxis

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

ejemplo 302. Ejemplo
{IF hasconstantvalue(PLC_PRG.aConst, 99, >)}
{ELSIF hasconstantvalue(PLC_PRG.aConst, GVL.intconst99, =)}


ejemplo 303. Ejemplo
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}


hastype (variable: <variable name>, <data type> )

El operador hace que a la expresión se le dé el valor TRUE cuando la variable <variable> es del tipo de dato <type-spec>. De lo contrario FALSE es regresado.

Posibles tipos de datos:

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

ejemplo 304. Ejemplo

Requisito: Las dos aplicaciones App1 y App2 existe. La variable g_multitype se declara en App1 con tipo de datos LREAL, en App2 con tipo de datos STRING.

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


hasvalue (PackMode, ' <pack mode value> ')

El modo de paquete marcado depende de la descripción del dispositivo, no del pragma que se puede especificar para DUT individuales.

hasvalue (RegisterSize, ' <register size> ')

<register size>: Tamaño de un registro de CPU (en bits)

El operador hace que la expresión devuelva el valor TRUE cuando el tamaño de un registro de la CPU es igual a <register size>.

Posibles valores para <register size>

  • 16 para C16x,

  • 64 para X86-64 bits

  • 32 para X86-32 bits

hasvalue (<define-ident>, ' <character string> ')

El operador hace que a la expresión se le dé el valor TRUE cuando una variable se define con el identificador <define-ident> y tiene el valor <char-string>. De lo contrario FALSE es regresado.

ejemplo 305. Ejemplo

Requisito: Las dos aplicaciones App1 y App2 existe. La variable test se utiliza en las aplicaciones App1 y App2. En App1, se le da el valor 1. En App2, se le da el valor 2.

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


project_defined (<global define>)

Este operador está disponible desde CODESYS V3.5 SP20.

El operador hace que la expresión reciba el valor. TRUE si el global define <global define> está incluido en la lista de definiciones globales en el Opciones de compilación de la configuración del proyecto.

El operador se especifica como una condición de un IF declaración y se puede utilizar tanto en la parte de implementación como en la parte de declaración de ST POU y bibliotecas. Se pueden combinar con otros define mediante el AND y OR operadores si estos están permitidos en la posición respectiva.

En la parte de declaración de las POU, IF declaraciones con el operador project_defined (<global define>) puede contener las siguientes construcciones:

  • Declaraciones de variables

    Ejemplo:

    {If project_defined(define1)}
        x : DINT;
    {END_IF}
  • Comentarios

  • Declaraciones de atributos

  • Declaraciones pragmáticas

Las siguientes construcciones son no posible:

  • Declaraciones de variables completas

    Ejemplo

    {If project_defined(define1)}
    VAR
        x : DINT;
    END_VAR
    {END_IF}
  • Declaraciones completas de las POU

    Ejemplo:

    {If project_defined(define1)}
    FUNCTION POU : BOOL
    VAR_INPUT
        x : INT;
    END_VAR
    {END_IF}
  • Alcances: VAR_INPUT, VAR_OUTPUT, VAR_IN_OUT

NOT <operator>

A la expresión se le da el valor TRUE cuando el valor inverso de <operator> devuelve el valor TRUE. <operator> puede ser uno de los operadores descritos en este capítulo.

ejemplo 306. Ejemplo

Requisito: Las dos aplicaciones App1 y App2 existe. PLC_PRG1 existe en App1 y App2, y la POU CheckBounds existe solo en App1.

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


<operator> AND <operator>

A la expresión se le da el valor TRUE cuando los dos operadores especificados regresan TRUE. <operator> puede ser uno de los operadores descritos en este capítulo.

ejemplo 307. Ejemplo

Requisito: Las aplicaciones App1 y App2 existe. PLC_PRG1 existe en App1 y App2, y la POU CheckBounds existe solo en App1.

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


<operator> OR <operator>

La expresión vuelve TRUE cuando uno de los dos operadores especificados regresa TRUE. <operator> puede ser uno de los operadores descritos aquí.

ejemplo 308. Ejemplo

Requisito: Las dos aplicaciones App1 y App2 existe. El POU PLC_PRG1 existe en App1 y App2, y la POU CheckBounds existe solo en App1.

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


(<operator>)

() entre paréntesis los operadores.