Skip to main content

Datentyp: ANY, ANY_<type>

Die Datentypen ANY oder ANY_<type> werden in Schnittstellen von Funktionen, Funktionsbausteinen oder Methoden verwendet, um Eingangsparameter, deren Typ unbekannt oder beliebig ist, formal zu typisieren: Die Eingangsvariablen (VAR_INPUT) haben einen generischen Datentyp.

Der Compiler ersetzt den Typ der Eingangsvariable intern mit der unten beschriebenen Datenstruktur, wobei der Wert wird nicht direkt übergeben wird. Stattdessen wird ein Zeiger auf den eigentlichen Wert übergeben, weswegen nur eine Variablen übergeben werden kann. Erst beim Aufruf wird also der Datentyp konkretisiert. Aufrufe solcher Programmierbausteine können daher mit Argumenten, die jeweils unterschiedliche Datentypen haben, erfolgen.

Tipp

Literale, ersetzte Konstanten und Ergebnisse von Funktionsaufrufen oder Ausdrücken können nicht an Eingangsvariablen (VAR_IN_OUT) übergeben werden.

Interne Datenstruktur bei ANY und ANY_<type>

Beim Übersetzen des Codes werden die Eingangsvariablen mit ANY-Datentyp intern durch die folgende Struktur typisiert. Bei Aufruf des Programmierbausteins (zur Laufzeit) wird das Argument an einen Referenzparameter übergeben.

TYPE AnyType :
STRUCT
    // the type of the actual parameter
    typeclass : __SYSTEM.TYPE_CLASS ;
    // the pointer to the actual parameter
    pvalue : POINTER TO BYTE;
    // the size of the data, to which the pointer points
    diSize : DINT;
END_STRUCT
END_TYPE

Tipp

Über diese Struktur können Sie innerhalb des Programmierbausteins auf die Eingangsvariable zugreifen und beispielsweise den übergebenen Wert abfragen.

Beispiel 201. Beispiel

Die Funktion vergleicht, ob zwei Eingangsvariablen den gleichen Typ und den gleichen Wert haben.

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

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;
// END_FUNCTION


Deklaration

Die Syntaxbeschreibungen beziehen sich auf einen Programmierbaustein mit genau einem Parameter (eine Eingangsvariable).

Syntax

FUNCTION | FUNCTION_BLOCK | METHOD <POU name> ( : <return data type> )?
VAR_INPUT
    <input variable name> : <generic data type>;
END_VAR

<generic data type> = ANY | ANY_BIT | ANY_DATE | ANY_NUM | ANY_REAL | ANY_INT | ANY_STRING
Beispiel 202. Beispiel
FUNCTION funComputeAny : BOOL
VAR_INPUT
            anyInput1 : ANY; // valid data type see table
END_VAR
// END_FUNCTION

FUNCTION_BLOCK FB_ComputeAny
VAR_INPUT
    anyInput1 : ANY;
END_VAR
// END_FUNCTION_BLOCK

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
//END_METHOD


Tipp

Ab Compilerversion >= 3.5.1.0 werden die in der Tabelle dargestellten generischen IEC-Datentypen unterstützt.

Die Tabelle stellt die Hierarchie der generischen Datentypen dar und gibt Auskunft, welcher generische Datentyp des formalen Parameters (Deklaration) welche elementaren Datentypen des Arguments (Aufruf) erlaubt.

Generischer Datentyp beim formalen Parameter

Erlaubter elementarer Datentyp beim tatsächlichen Parametrer (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

Aufruf

Die Syntaxbeschreibungen beziehen sich auf einen Programmierbaustein mit genau einem Parameter, dem ein Argument übergeben wird. Der Datentyp des Arguments konkretisiert dabei den generischen Datentyp der Eingangsvariable. Beispielsweise können Argumente des Typs BYTE, WORD, DWORD, LWORD an eine ANY_BIT-Eingangsvariable übergeben werden.

Syntax Funktionsaufruf

<variable name> := <function name> ( <argument name> );
<argument name> : variable with valid data type

Syntax Funktionsbausteinaufruf

<function block name> ( <input variable name> := <argument name> );

Syntax Methodenaufruf

<function block name> . <method name> ( <input variable name> := <argument name> );
Beispiel 203. Beispiel
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

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

xResult := funGenericCompare(wBitField1, wBitField2);

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

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