Objekt Eigenschaft

Objekt Eigenschaft anlegen

Dialog Eigenschaft hinzufügen

Zugriffsmodifizierer

Eine Eigenschaft kann zusätzliche lokale Variablen enthalten. Eine Eigenschaft kann aber keine zusätzlichen Eingänge enthalten und, im Gegensatz zu einer Funktion oder Methode, keine zusätzlichen Ausgänge.

Wenn Sie eine Eigenschaft von einer POU zu einer Schnittstelle kopieren oder verschieben, löscht TwinCAT die enthaltenen Implementierungen automatisch.

Get- und Set-Accessoren

Die Accessor-Methoden Get und Set fügt TwinCAT automatisch im SPS-Projektbaum unterhalb des Eigenschaftenobjekts ein. Mithilfe des Befehls Hinzufügen können Sie sie auch explizit hinzufügen.

TwinCAT ruft den Set-Accessor auf, wenn auf die Eigenschaft schreibend zugegriffen wird, das bedeutet, Sie verwenden den Namen der Eigenschaft als Eingabeparameter.

TwinCAT ruft den Get-Accessor auf, wenn auf die Eigenschaft lesend zugegriffen wird, das bedeutet, Sie verwenden den Namen der Eigenschaft als Ausgabeparameter.

Bitte beachten Sie, dass Sie die Accessor-Methoden implementieren müssen, um auf die Eigenschaft zuzugreifen.

Beispiel für die Implementierung

Deklaration des Funktionsbausteins FB_Sample

FUNCTION_BLOCK FB_Sample
VAR
    nVar : INT;
END_VAR

nVar := nVar + 1;

Deklaration der Eigenschaft nValue

PROPERTY PUBLIC nValue : INT

Implementierung der Accessormethode FB_Sample.nValue.Set

nVar := nValue;

Implementierung der Accessormethode FB_Sample.nValue.Get

nValue := nVar;

Aufruf der Eigenschaft nValue

PROGRAM MAIN
VAR
    fbSample : FB_Sample;
END_VAR

fbSample();
If fbSample.nValue > 500 THEN
    fbSample.nValue := 0;
END_IF;

Wenn Sie die Eigenschaft nur für den Lesezugriff oder nur für den Schreibzugriff verwenden wollen, können Sie den Accessor löschen, den Sie nicht verwenden.

Sie können den Accessor-Methoden an folgenden Stellen Zugriffsbezeichner hinzufügen: Im Deklarationsteil des Accessors durch manuelles Eintragen. Im Dialog 'get'-Accessor hinzufügen oder 'set'-Accessor hinzufügen, wenn Sie den Accessor explizit mit dem Befehl Hinzufügen einfügen.

Kompatibilitätswarnung bei Eigenschaften vom Typ REFERENCE Zu TC3.1 Build 4022 ändert sich das Aufrufverhalten von Eigenschaften, die mit dem Rückgabetyp 'REFERENCE TO <…>' definiert sind. Bei Schreibzugriffen mittels ':=' wird mit Versionen < 3.1.4022.0 der Set-Accessor aufgerufen, sodass die Referenz geschrieben wird. Mit Versionen >= 3.1.4022.0 wird hingegen der Get-Accessor aufgerufen, sodass der Wert geschrieben wird. Um mit Versionen >= 3.1.4022.0 die Referenz zuzuweisen, muss der Referenz-Zuweisungsoperator 'REF=' verwendet werden.

Monitoring für Eigenschaften im Onlinebetrieb

Für das Monitoring für Eigenschaften im Onlinebetrieb stehen folgende Pragmas zur Verfügung, die Sie an oberster Stelle in der Definition der Eigenschaft einfügen (Attribut 'monitoring'):

• {attribute 'monitoring':= 'variable'}: Bei jedem Zugriff auf die Eigenschaft speichert TwinCAT den Istwert in einer Variablen und stellt den Wert dieser Variablen dar. Dieser Wert kann unter Umständen veralten, wenn im Code kein Zugriff mehr auf die Eigenschaft erfolgt.
• {attribute 'monitoring' := 'call'}: Bei jeder Darstellung des Werts ruft TwinCAT den Code des Get-Accessors auf. Wenn dieser Code einen Seiteneffekt enthält, dann wird der Seiteneffekt durch das Monitoring ausgeführt.

Sie können eine Eigenschaft mithilfe folgender Funktionalitäten monitoren:

• Inline-Monitoring
  Voraussetzung: In den TwinCAT-Optionen in der Kategorie TwinCAT > SPS Programmierumgebung > Texteditor ist in der Registerkarte Monitoring die Option Inline-Monitoring aktivieren aktiviert.
• Überwachungsliste (Überwachungslisten verwenden)

Zugriff auf ein einzelnes Element eines strukturierten Rückgabetyps beim Methoden-/Funktions-/Eigenschaftenaufruf

Um direkt bei einem Methoden-, Funktions- oder Eigenschaftenaufruf auf ein einzelnes Element des strukturierten Datentyps, welcher von der Methode/Funktion/Eigenschaft zurückgeliefert wird, zugreifen zu können, kann folgende Umsetzung verwendet werden. Ein strukturierter Datentyp ist beispielsweise eine Struktur oder ein Funktionsbaustein.

1. Der Rückgabetyp der Methode/Funktion/Eigenschaft wird als „REFERENCE TO <structured type>“ definiert (anstelle von lediglich „<structured type>“).
2. Bei einem solchen Rückgabetyp ist zu beachten, dass – falls beispielsweise eine FB-lokale Instanz des strukturierten Datentyps zurückgeliefert werden soll – der Referenzoperator REF= anstatt des „normalen“ Zuweisungsoperators := verwendet werden muss.

Die Erklärungen und das Beispiel dieses Abschnitts beziehen sich auf den Aufruf einer Eigenschaft. Sie sind aber genauso auf andere Aufrufe übertragbar, die Rückgabewerte liefern (z. B. Methoden oder Funktionen).

Beispiel

Deklaration der Struktur ST_Sample (strukturierter Datentyp):

TYPE ST_Sample :
STRUCT
    bVar  : BOOL;
    nVar  : INT;
END_STRUCT
END_TYPE

Deklaration des Funktionsbausteins FB_Sample:

FUNCTION_BLOCK FB_Sample
VAR
    stLocal     : ST_Sample;
END_VAR

Deklaration der Eigenschaft FB_Sample.MyProp mit dem Rückgabetyp „REFERENCE TO ST_Sample“:

PROPERTY MyProp : REFERENCE TO ST_Sample

Implementierung der Get-Methode von der Eigenschaft FB_Sample.MyProp:

MyProp REF= stLocal;

Implementierung der Set-Methode von der Eigenschaft FB_Sample.MyProp:

stLocal := MyProp;

Aufruf der Get- und Set-Methoden im Hauptprogramm MAIN:

PROGRAM MAIN
VAR
    fbSample    : FB_Sample;
    nSingleGet  : INT;
    stGet       : ST_Sample;    
    bSet        : BOOL;
    stSet       : ST_Sample;
END_VAR

// Get - single member and complete structure possible
nSingleGet := fbSample.MyProp.nVar;
stGet      := fbSample.MyProp;
 
// Set - only complete structure possible 
IF bSet THEN
    fbSample.MyProp REF= stSet;
    bSet            := FALSE;
END_IF 

Durch die Deklaration des Rückgabetyps der Eigenschaft MyProp als „REFERENCE TO ST_Sample“ und durch die Verwendung des Referenzoperators REF= in der Get-Methode dieser Eigenschaft, kann direkt beim Aufruf der Eigenschaft auf ein einzelnes Element des zurückgelieferten strukturierten Datentyps zugegriffen werden.

VAR
    fbSample    : FB_Sample;
    nSingleGet  : INT;
END_VAR

nSingleGet := fbSample.MyProp.nVar;

Wenn der Rückgabetyp nur als „ST_Sample“ deklariert wäre, müsste die von der Eigenschaft zurückgelieferte Struktur zunächst einer lokalen Strukturinstanz zugewiesen werden. Die einzelnen Strukturelemente könnten dann anhand der lokalen Strukturinstanz abgefragt werden.

VAR
    fbSample    : FB_Sample; 
    stGet       : ST_Sample; 
    nSingleGet  : INT;
END_VAR

stGet      := fbSample.MyProp;
nSingleGet := stGet.nVar;

Zugriff auf VAR_IN_OUT-Variablen des Funktionsbausteins in einer Methode/Transition/Eigenschaft

Auf die VAR_IN_OUT-Variablen eines Funktionsbausteins kann in einer Methode, einer Transition oder einer Eigenschaft des Funktionsbausteins prinzipiell zugegriffen werden. Bei einem solchen Zugriff ist folgendes zu beachten:

• Wird der Rumpf oder eine Aktion des Funktionsbausteins von außerhalb des FBs aufgerufen, stellt der Compiler sicher, dass bei diesem Aufruf die VAR_IN_OUT-Variablen des Funktionsbausteins zugewiesen werden.
• Bei dem Aufruf einer Methode, Transition oder Eigenschaft des Funktionsbausteins ist dies nicht der Fall, da die VAR_IN_OUT-Variablen des FBs nicht innerhalb eines Methoden-, Transitions- oder Eigenschaftenaufrufs zugewiesen werden können. Es könnte daher gegebenenfalls ein Zugriff auf die VAR_IN_OUT-Variablen stattfinden, indem die Methode/Transition/Eigenschaft aufgerufen wird, bevor die VAR_IN_OUT-Variablen einer gültigen Referenz zugewiesen wurden. Da dies einem ungültigen Zugriff während der Laufzeit entsprechen würde, ist es potentiell riskant, auf die VAR_IN_OUT-Variablen des FBs in einer Methode, einer Transition oder einer Eigenschaft zuzugreifen.

Aus diesem Grund wird bei einem Zugriff auf die VAR_IN_OUT-Variablen des FBs in einer Methode, einer Transition oder einer Eigenschaft folgende Warnung mit der ID C0371 ausgegeben:

„Warning: Access to VAR_IN_OUT <Var> declared in <POU> from external context <Method/Transition/Property>”

Eine adäquate Reaktion auf diese Warnung ist beispielsweise die Überprüfung der VAR_IN_OUT-Variablen innerhalb der Methode/Transition/Eigenschaft, bevor auf sie zugegriffen wird. Diese Überprüfung ist mithilfe des Operators __ISVALIDREF möglich, mit dem geprüft werden kann, ob eine Referenz auf einen gültigen Wert verweist. Ist diese Prüfung vorhanden, kann zum einen davon ausgegangen werden, dass sich der Anwender des Risikos bewusst ist, das potentiell vorhanden ist, wenn auf die VAR_IN_OUT-Variablen des FBs in einer Methode/Transition/Eigenschaft zugegriffen wird. Zum anderen liegt durch die Überprüfung der Referenz ein angemessener Umgang mit diesem Risiko vor. Somit kann die Warnung für diesen überprüften Bereich mittels Attribut 'warning disable' unterdrückt werden.

Die dazugehörige Beispielimplementierung einer Methode ist im Folgenden dargestellt.

Funktionsbaustein FB_Sample:

FUNCTION_BLOCK FB_Sample
VAR_IN_OUT
    bInOut : BOOL;
END_Var

Methode FB_Sample.MyMethod:

METHOD MyMethod
VAR_INPUT
END_VAR

// The warning can be disabled here as the user is aware of the risk that the reference may not be valid by checking its validity
{warning disable C0371}

// Checking the VAR_IN_OUT reference, leave the current method in case of invalid reference
IF NOT __ISVALIDREF(bInOut) THEN
     RETURN;
END_IF

// Access to VAR_IN_OUT reference (only if the reference was confirmed as valid before)
bInOut := NOT bInOut;

// The warning may be restored at the end of the access area
{warning restore C0371}

Im folgenden Beispiel werden eine Eingangsvariable und eine Eigenschaft von einem Funktionsbaustein initialisiert, welcher über eine FB_init-Methode mit einem zusätzlichen Parameter verfügt.

Funktionsbaustein FB_Sample:

FUNCTION_BLOCK FB_Sample
VAR_INPUT
    nInput           : INT;
END_VAR
VAR
    nLocalInitParam  : INT;
    nLocalProp       : INT;
END_VAR

Methode FB_Sample.FB_init:

METHOD FB_init : BOOL
VAR_INPUT
    bInitRetains : BOOL;  // if TRUE, the retain variables are initialized (warm start / cold start)
    bInCopyCode  : BOOL;  // if TRUE, the instance afterwards gets moved into the copy code (online change)
    nInitParam   : INT;
END_VAR

nLocalInitParam := nInitParam;

Eigenschaft FB_Sample.nMyProperty und die zugehörige Set-Funktion:

PROPERTY nMyProperty : INT

nLocalProp := nMyProperty;

Programm MAIN:

PROGRAM MAIN
VAR
    fbSample  : FB_Sample(nInitParam := 1) := (nInput := 2, nMyProperty := 3);
    aSample   : ARRAY[1..2] OF FB_Sample[(nInitParam := 4), (nInitParam := 7)]
                            := [(nInput := 5, nMyProperty := 6), (nInput := 8, nMyProperty := 9)];
END_VAR

Initialisierungsergebnis:

• fbSample
• nInput = 2
• nLocalInitParam = 1
• nLocalProp = 3
• aSample[1]
• nInput = 5
• nLocalInitParam = 4
• nLocalProp = 6
• aSample[2]
• nInput = 8
• nLocalInitParam = 7
• nLocalProp = 9