Skip to main content

Pragmas Condicionales

Importante

Se utilizan pragmas condicionales en las implementaciones de ST POU. CODESYS no evalúa los pragmas condicionales cuando los usas en la parte de declaración.

La excepción es el pragma condicional con el {project_define (<global define>)} operador, que se puede utilizar en la parte de implementación y en la parte de declaración de las POU (consulte project_defined (<global define>)).

El propósito de los pragmas condicionales es influir en cómo se genera el código en el proceso de precompilación o compilación. El lenguaje de implementación ST admite estos pragmas.

Con los pragmas condicionales, influye si el código de implementación se tiene en cuenta o no para la compilación. Por ejemplo, puede hacer que esto dependa de si se declara una variable específica, si existe una POU específica, etc.

Pragma

Descripción

{define <identifier> <string>}

El valor se puede consultar y comparar con hasvalue mas tarde.

{undefine <identifier>}

El {define} declaración del identificador <identifier> se elimina, y el identificador vuelve a ser "indefinido" a partir de ahora. El pragma se ignora cuando el identificador especificado no está definido en absoluto.

{IF <expr>}...

{ELSIF <expr>}...

{ELSE}...

END_IF}

Estos son pragmas para la compilación condicional.

Las expresiones especificadas <expr> tiene que ser constante en tiempo de compilación. Se evalúan en el orden en que aparecen aquí hasta que una de las expresiones tenga un valor distinto de cero. Se compila el texto vinculado a la declaración. Las otras líneas se ignoran. El orden de los segmentos es fijo. El ELSIF y ELSE los segmentos son opcionales. El ELSIF los segmentos pueden ocurrir cualquier número de veces. Puede usar múltiples operadores de compilación condicionales dentro de las constantes <expr>.

<expr>

Puedes usar uno o más operadores dentro de la expresión constante <expr> dentro del pragma de compilación condicional {IF} o {ELSIF} .

Sugerencia

Puede especificar expresiones y define definiciones como definiciones del compilador sobre el Construir pestaña en el cuadro de diálogo Propiedades de las POU. si especificas define definiciones en el cuadro de diálogo de propiedades, entonces debe omitir el término {define}, en contraste con la definición en el código de implementación. Además, puede especificar varios valores separados por comas define definiciones en el diálogo de propiedades.

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.

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.

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.

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 293. Ejemplo

{IF defined (task: Task_D)}



ejemplo 294. 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 295. 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 296. 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 297. 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 298. 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 299. Ejemplo

{IF hasconstantvalue(PLC_PRG.aConst, 99, >)}

{ELSIF hasconstantvalue(PLC_PRG.aConst, GVL.intconst99, =)}



ejemplo 300. 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 301. 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.

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 302. 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.

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 303. 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.

En esta sección: