Skip to main content

Variable: VAR_GENERIC CONSTANT

Konstante generische Variable

Überblick

Die Erweiterung VAR_GENERIC bietet Unterstützung für generische Konstanten zur Kompilierungszeit in Funktionsbausteinen. Dadurch können flexible und wiederverwendbare Funktionsbausteine erstellt werden, die sich an verschiedene Konfigurationen anpassen lassen, beispielsweise Puffergrößen oder feste Bereiche, ohne auf dynamische Speicherzuweisung angewiesen zu sein.

Dieses Feature ist besonders nützlich für Funktionsbausteine, die Arrays oder andere Speicherstrukturen verwalten. Zudem ermöglicht es leistungsoptimierte Designs, die typsicher sind und vollständig zur Kompilierungszeit aufgelöst werden.

Eine generische Konstante ist eine Variable im Gültigkeitsbereich VAR_GENERIC CONSTANT eines Funktionsbausteins. Die Variable wird erst bei der Deklaration der Funktionsbaustein-Instanz definiert.

Es ist erlaubt in Methoden generische Konstanten zu verwenden. Insbesondere in VAR_IN_OUT oder VAR_IN_OUT CONSTANT-Bereichen kann das hilfreich sein.

Syntax

Deklaration

Generische Variablen werden zwischen den Schlüsselwörtern VAR_GENERIC CONSTANT und END_VAR im Deklarationsteil von Funktionsbausteinen deklariert. Alle Variablen müssen von einem Integer-Datentyp sein, beispielsweise INT, UINT, DINT. 

FUNCTION_BLOCK <function block name>
VAR_GENERIC CONSTANT
    <generic constant name> : <integer data type> := <initial value> ; //Initial value will be overwritten
END_VAR

<function block name>

Name des Funktionsbausteins

VAR_GENERIC CONSTANT

END_VAR

Gültigkeitsbereich für generische Konstanten

Sie können im VAR_GENERIC CONSTANT-Bereich beliebig viele generische Konstanten deklarieren.

<generic constant name>

Variablenname der generischen Konstanten

: <integer data type>

Konstrukt, das die generische Konstante typisiert.

Erlaubt ist ein ganzzahliger Datentyp oder der Teilbereich eines ganzzahligen Datentyps.

Beispiel:

maxlen1 : INT := 4;

maxlen2 : INT(5..10) := 5;

:= <initial value>

Optional

Initialisierung

Wichtig

Der Initialwert wird nur für Compile-Prüfungen benötigt. Zur Laufzeit wird der Wert überschrieben.

Beispiel:

FUNCTION BLOCK FB
VAR_GENERIC CONSTANT
    size : INT;
END_VAR
VAR
    buffer : ARRAY[0..size] OF BYTE;
END_VAR

Instanziierung

Die Instanziierung eines Funktionsbausteins mit generischen Konstanten kann über eine Parameterübergabe explizit als Ausdruck oder implizit mittels Literal erfolgen.

Dabei gilt:

  • Der Teil der Parameterübergabe, der den VAR_GENERIC CONSTANT-Bereich betrifft, wird in spitze Klammern gesetzt.

  • Generische Funktionsbausteine müssen mit Parametern für alle generischen Variablen instanziiert werden. Die Parameterübergabe muss vollständig sein. Eine teilweise Angabe ist nicht zulässig und führt zu einem Fehler.

  • Entweder werden die Parameter alle explizit angegeben oder alle implizit. Eine Mischung aus expliziter oder impliziter Angabe ist nicht zulässig.

    • Implizit

      Werden Parameter für mehrere generische Variablen übergeben, müssen die gewünschten Werte als Literal in der Reihenfolge, in der sie im VAR_GENERIC CONSTANT-Bereich deklariert wurden, durch Kommas getrennt aneinandergereiht werden.

      <5,10>

    • Explizit mit Name

      Werden Parameter für mehrere generische Variablen übergeben, müssen die gewünschten Parameter jeweils als geklammerter Ausdruck in freier Reihenfolge durch Kommas getrennt aneinandergereiht werden. Ein Ausdruck wird wie üblich von runden Klammern umfasst.

      Der Ausdruck weist der namentlich genannten generischen Konstanten nach dem Zuweisungsoperator := ein Literal, eine Variable oder einen Ausdruck zu. Wichtig ist, diese explizite Parameterübergabe in runde Klammern zu setzen.

      <(Array2Size := 10), (Array1Size := 5)>

      Der Vorteil ist, dass die Parameterübergabe gut lesbar, somit nachvollziehbar und nach Änderungen gut wartbar ist.

  • Wurden weitere Variablen deklariert, müssen dafür weitere Parameter übergeben werden. Diese werden nach dem Zuweisungsoperator := von runden Klammern umfasst aneinandergereiht.

Beispiel 91. Beispiel

Funktionsbaustein FB mit generischen Konstanten

FUNCTION_BLOCK FB
VAR_GENERIC CONSTANT
    Array1Size : INT := 0;
    Array2Size : INT := 0;
END_VAR
VAR_INPUT
    MyArray1 : ARRAY[0..Array1Size-1] OF REAL;
    MyArray2 : ARRAY[0..Array2Size-1] OF REAL;
END_VAR
VAR
    SomeOtherParameter : INT;
END_VAR


Beispiel 92. Beispiel

Instanziierung des Funktionsbausteins FB mit einfacher Parameterübergabe. 

PROGRAM PLC_PRG
VAR
    MyFB1 : FB<5,10> := (SomeOtherParameter:=20);
END_VAR

VAR
    liArray1Size: LINT;
END_VAR
liArray1Size := UPPER_BOUND(MyFB1.MyArray1,1) + 1;


Beispiel 93. Beispiel

Funktionsbaustein-Instanz MyFB2 mit expliziter Parameterübergabe 

PROGRAM PLC_PRG
VAR
    MyFB1 : FB<5,10> := (SomeOtherParameter:=20);
    MyFB2 : FB<(Array2Size:=10), (Array1Size:=5)> := (SomeOtherParameter := 10);
END_VAR

VAR
    Array1Size, Array2Size : LINT;
END_VAR
Array1Size := UPPER_BOUND(MyFB1.MyArray1,1) + 1;
Array2Size := UPPER_BOUND(MyFB1.MyArray2,1) + 1;


Vererbung mit generischen Konstanten

Generische Konstanten können auch durch Vererbung an Basis-Funktionsbausteine übergeben werden.

Verwendung der Konstanten in einem Funktionsbaustein

Die Konstante kann wie jede andere Konstante in einem Funktionsbaustein verwendet werden, beispielsweise in Arrays oder in String-Deklarationen. Sie kann in Methoden, Propertys oder Aktionen des Funktionsbausteins verwendet werden, jedoch kann von Außen nicht auf sie zugegriffen werden. Das heißt, sie verhält sich wie eine private Variable.

Precompile-Überprüfungen

Da der finale Wert von generischen Konstanten im Funktionsbaustein nicht zur Verfügung steht, sind die Precompile-Überprüfungen begrenzt. Es ist möglich einen Initialisierungswert wie folgt zu definieren:

FUNCTION_BLOCK FB
VAR_GENERIC CONSTANT  
    size : INT := 1;
END_VAR
VAR 
   buffer : ARRAY[0..size] OF BYTE;
END_VAR

Dieser Initialisierungswert (im Beispiel der Wert 1) wird für Precompile-Überprüfungen innerhalb des Funktionsbausteins verwendet, er hat jedoch keinen weiteren Effekt.

Beispiele

Beispiel 94. Beispiel für die Verwendung mehrerer generischer Konstanten
FUNCTION_BLOCK FB_Pou
VAR_GENERIC CONSTANT
    lnstring : DINT := 10;
    numstring : DINT := 100;
END_VAR
VAR
    arraystring : ARRAY[0..numstring-1] OF STRING(lnstring);
END_VAR
PROGRAM PLC_PRG
VAR
    fbPou : FB_Pou<100, 1000>;
END_VAR


Beispiel 95. Beispiel: Generische Konstante eines Subrange-Typs

Ein Subrange-Typ kann als generischer Parameter verwendet werden, um einen erlaubten Wertebereich festzulegen, der vom Compiler überprüft wird.

FUNCTION_BLOCK FB_SrString 
VAR_GENERIC CONSTANT
    maxlen2 : INT(5..10) := 5;    //subrange data type
END_VAR
VAR
    arrTest : ARRAY[0..maxlen-1] OF BYTE;
END_VAR
;
PROGRAM SrMain
VAR CONSTANT
    cconst: INT(5..10) := 5;
END_VAR
VAR    
    fbMyString1 : FB_SrString<5>;
    fbMyString2 : FB_SrString<(2 * cconst)>;
    fbMyString3 : FB_SrcString<123>;
    // ERROR: An error is reported here because 123 is not within the value range 5..10.
    arrMyString : ARRAY [0..5] OF FB_SrString<6>;
END_VAR


Beispiel 96. Beispiel: Generischer Funktionsbaustein mit parametrierbarer Arrayvariable

Der folgende Code zeigt, wie ein Funktionsbaustein zu definieren ist, der Arrays beliebiger Länge verarbeiten kann. Der Funktionsbaustein verfügt über ein Array mit einer generischen, aber konstanten Länge. Mit "konstant" ist gemeint, dass, obwohl jede Funktionsbaustein-Instanz in ihrer Arraylänge variiert, diese während der Lebensdauer des Objekts konstant ist.

Ein solches Konstrukt ist beispielsweise für einen Bibliotheksprogrammierer von Vorteil, der einen generischen Bibliotheksbaustein implementieren möchte.

FUNCTION_BLOCK FB_MyString 
VAR_GENERIC CONSTANT
    maxlen : UDINT := 1;
END_VAR
VAR
    test : ARRAY[0..maxlen-1] OF BYTE;
END_VAR
PROGRAM PLC_PRG
VAR CONSTANT
    cconst: DINT := 1000;
END_VAR
VAR    
    fbMyString1 : FB_MyString<100>;
    fbMyString2 : FB_MyString<(2 * cconst)>;   
    arrMyString : ARRAY[0..5] OF FB_MyString<6>;    
END_VAR


Vererbung

Ein Funktionsbaustein kann von einem Basis-Funktionsbaustein mit generischer Konstante (EXTENDS) erben. Der erbende Funktionsbaustein benötigt eine eigene generische Konstante. Von außen kann dann ein spezifischer Wert übergeben werden.

Syntax:

FUNCTION_BLOCK <function block name> 
VAR_GENERIC CONSTANT        
    <generic constant name> : <integer data type> ; 
END_VAR 
EXTENDS <function block base> < <generic constant name> >

Ein Funktionsbaustein mit generischer Konstante kann eine Schnittstelle implementieren (IMPLEMENTS). Die Schnittstelle deklariert eine Eigenschaft (PROPERTY) mit der von außen auf den spezifizierten Wert zugegriffen werden kann. Die Schnittstelle selbst darf keine generischen Konstanten oder lokale Variablen deklarieren. Schnittstellen haben keine Implementierung.

Syntax:

FUNCTION_BLOCK <function block name>
VAR_GENERIC CONSTANT
    <generic constant name> : <integer data type> ;
END_VAR
IMPLEMENTS <interface name>

Wichtig

Achten Sie beim Kodieren darauf, dass erst die Deklaration der generischen Konstanten eingefügt wird und dann EXTENDS und IMPLEMENTS nachfolgen. Das ist gewöhnungsbedürftig, hat aber den Grund, dass generische Konstanten auch bei Basisklassen verwendet werden können.

Beispiel 97. Beispiel

Definition der Schnittstelle IString für einen generischen Funktionsbaustein.

Es wird dringend empfohlen für generische Funktionsbausteine eine Schnittstelle zu definieren. Die Schnittstelle soll die Verwendung der generischen Funktionsbaustein-Instanz ohne Kenntnis der generischen Konstanten ermöglichen.

Die Eigenschaft Length ermöglicht den Zugriff auf die generische Konstante.

INTERFACE IString 
METHOD Append : BOOL 
VAR_INPUT     
    strAppend : IString; 
END_VAR 

METHOD Assign : BOOL
VAR_INPUT     
    stringIn : STRING; 
END_VAR 

METHOD ToString : STRING
VAR_INPUT 
END_VAR 

PROPERTY Length : DINT

Deklaration des Funktionsbausteins FB_MyString mit der generischen Konstanten maxlen

FUNCTION_BLOCK FB_MyString 
VAR_GENERIC CONSTANT        
    maxlen : UDINT; 
END_VAR 
IMPLEMENTS IString

Der Funktionsbaustein FB_LongString ist eine Erweiterung des spezifizierten Funktionsbausteins FB_MyString.

FUNCTION_BLOCK FB_LongString EXTENDS FB_MyString<1000>

Deklaration des Funktionsbausteins FB_MySpecialString mit der generischen Konstanten maxlen2 als Erweiterung des spezifizierten Funktionsbausteins FB_MyString. Der Funktionsbaustein ist erweitert um die Methode METH_ToLatin.

FUNCTION_BLOCK FB_MySpecialString 
VAR_GENERIC CONSTANT        
    maxlen2 : UDINT:= 1; 
END_VAR 
EXTENDS FB_MyString<maxlen2>

METHOD METH_ToLatin : STRING
VAR_INPUT
END_VAR

Instanziierung der Funktionsbausteine mit spezifischen Konstanten

PROGRAM PLC_PRG 
VAR CONSTANT     
    cconst: DINT := 1000; 
END_VAR
VAR     
    string1 : FB_MyString<100>;
    string2 : FB_MyString<(2 * cconst)>;
    derived1 : FB_LongString;
    derived2 : FB_MySpecialString<100>;
END_VAR

Aufrufe

string1.METH_Assign ('Welt'); 
string2.METH_Assign ('Hallo '); 
string2.METH_Append(string1); 
derived2.METH_ToLatin('Hello World');


In diesem Abschnitt: