Skip to main content

Type de données : ANY, ANY_<type>

Les types de données ANY ou ANY_<type> sont utilisées dans les interfaces de fonctions, de blocs fonction ou de méthodes afin de saisir des paramètres d'entrée dont le type est inconnu ou non spécifié : Les variables d'entrée (VAR_INPUT) ont un type de données générique.

Le compilateur remplace le type de variable d'entrée en interne par la structure de données décrite ci-dessous, la valeur n'étant pas transmise directement. Au lieu de cela, un pointeur est passé vers la valeur réelle afin que seule une variable puisse être transmise. Par conséquent, le type de données n’est spécifié que lors de son appel. En conséquence, les appels de ces POU peuvent être effectués à l'aide d'arguments ayant chacun des types de données différents.

Astuce

Littéraux, constantes remplacées et résultats d'appels de fonction ou d'expressions ne peut pas être transmis aux variables d'entrée (VAR_IN_OUT).

Structure de données interne pour ANY et ANY_<type>

Lorsque le code est compilé, les variables d'entrée sont saisies intérieurement avec ANY type de données par la structure suivante. Lorsque le POU est appelé (au moment de l'exécution), l'argument est passé à un paramètre de référence.

TYPE AnyType :
STRUCT
    // Type of the current parameter
    typeclass : __SYSTEM.TYPE_CLASS ;
    // Pointer to the current parameter
    pvalue : POINTER TO BYTE;
    // Size of the data to which the pointer points
    diSize : DINT;
END_STRUCT
END_TYPE

Astuce

Vous pouvez accéder à la variable d'entrée au sein du POU via cette structure au moyen de cette structure, et par exemple interroger la valeur transmise.

Exemple 210. Exemple

Ceci compare si deux variables d'entrée ont ou non le même type et la même valeur.

FUNCTION funGenericCompare : BOOL
// Declaration
VAR_INPUT
        any1 : ANY;
        any2 : ANY;
END_VAR
VAR
        pTest : POINTER TO ARRAY [0..100] OF POINTER TO DWORD;
        diCount: DINT;
END_VAR

// Implementation
pTest := ADR(any1);
Generic_Compare := FALSE;
IF any1.typeclass <> any2.typeclass THEN
        RETURN;
END_IF
IF any1.diSize <> any2.diSize THEN
        RETURN;
END_IF
// Byte comparison
FOR iCount := 0 TO any1.diSize-1 DO
        IF any1.pvalue[iCount] <> any2.pvalue[iCount] THEN
                RETURN;
        END_IF
END_FOR
Generic_Compare := TRUE;
RETURN;


Déclaration

Les descriptions syntaxiques font référence à un POU avec exactement un paramètre (une variable d'entrée).

Syntaxe

<portée> <Nom du POU> : <type de données de la valeur de retour>
VAR_INPUT
    <nom de la variable> : <type de données générique>; END_VAR

<portée>

Portées possibles :

  • FUNCTION

  • FUNCTION_BLOCK

  • METHOD

<Nom du POU>

Nom du POU

: <type de données de la valeur de retour>

Facultatif

<nom de la variable>

Nom de la variable d'entrée

<type de données générique>

ANY, ANY_BIT, ANY_DATE, ANY_NUM, ANY_REAL, ANY_INT, ou ANY_STRING

Exemple 211. Exemple
FUNCTION funComputeAny : BOOL
VAR_INPUT
    anyInput1 : ANY; // For valid data type see table
END_VAR

FUNCTION_BLOCK FB_ComputeAny
VAR_INPUT
    anyInput1 : ANY;
END_VAR

FUNCTION_BLOCK FB_ComputeMethod
METHOD methComputeAnny : BOOL
VAR_INPUT
    anyInput1 : ANY_INT; // Valid data types are SINT, INT, DINT, LINT, USINT, UINT, UDINT, ULINT
END_VAR


Astuce

Avec les versions du compilateur > 3.5.1.0, les types de données CEI génériques du tableau sont pris en charge.

Le tableau représente la hiérarchie des types de données génériques et fournit des informations sur quel type de données génériques du paramètre formel (déclaration) autorise quels types de données élémentaires de l'argument (appel).

Type de données générique dans le cas d'un paramètre formel

Type de données élémentaire autorisé dans le cas d'un paramètre réel (argument)

ANY

ANY_BIT

  • BYTE

  • WORD

  • DWORD

  • LWORD

ANY_DATE

  • DATE

  • DATE_AND_TIME, DT

  • TIME_OF_DAY, TOD

  • LDATE

  • LDATE_AND_TIME, LDT

  • LTIME_OF_DAY, LTOD

ANY_NUM

ANY_REAL

REAL, LREAL

ANY_INT

USINT, UINT, UDINT, ULINT

SINT, INT, DINT, LINT

ANY_STRING

STRING, WSTRING

Appeler

Les descriptions syntaxiques font référence à un POU avec exactement un paramètre, auquel un argument est passé. Par conséquent, le type de données de l'argument spécifie le type de données générique de la variable d'entrée. Par exemple, des arguments du type BYTE, WORD, DWORD, LWORD peut être passé à un type ANY_BIT variable d'entrée.

Syntaxe de l'appel de fonction :

<nom de la fonction> (<argument>)

Syntaxe de l'appel du bloc fonction

<nom de l'instance du bloc fonction> (<nom de la variable d'entrée> := <argument>)

Syntaxe de l'appel de méthode

<nom de l'instance du bloc fonction> . <nom de la méthode> (<nom de la variable d'entrée> := <argument>)

<argument>

Variable de transfert

Exemple 212. Exemple
PROGRAM PLC_PRG
VAR
    byValue : BYTE := 16#AB;
    iValue : INT := -1234;
    xResultByte : BOOL;
    xResultInt : BOOL;

    fbComputeAnyByte : FB_ComputeAny;
    fbComputeAnyInt : FB_ComputeAny;

    fbComputeM1 : FB_ComputeMethod;
    fbComputeM2 : FB_ComputeMethod;

    byN : BYTE := 1;
    wBitField1 : WORD := 16#FFFF;
    wBitField2 : WORD := 16#0001;
    xInit : BOOL;
    xResult : BOOL;
END_VAR

//Implementation
xResultByte := funComputeAny(byValue);
xResultInt := funComputeAny(iValue);

xResult := funGenericCompare(wBitField1, wBitField2);

fbComputeAnyByte(anyInput1 := byValue);
fbComputeAnyInt(anyInput1 := iValue);

fbComputeM1.methComputeAnny(anyInput1 := byValue);
fbComputeM2.methComputeAnny(anyInput1 := iValue);


Dans cette section​: