Objekt Schnittstelle

Objekt Schnittstelle anlegen

Dialog Schnittstelle hinzufügen

Vererbung

Anwendungsfälle einer Schnittstelle

1. Prüfung der Schnittstellenvereinbarung mittels Compiler

• In einer Schnittstelle (z. B. I_Sample) deklarieren Sie die gewünschten Methoden und Eigenschaften (einschließlich Rückgabetyp, Eingänge etc.), die zu dieser Schnittstelle gehören sollen.
• In den Funktionsbausteinen, die dieser Schnittstelle entsprechen sollen und somit die zugehörigen Methoden und Eigenschaften bereitstellen sollen, implementieren Sie die Schnittstelle I_Sample.
• Der Funktionsbaustein enthält die Schnittstelle dabei in seiner IMPLEMENTS-Liste innerhalb seines Deklarationsteils (z. B. FB_Sample IMPLEMENTS I_Sample).
• Ein Funktionsbaustein kann eine oder mehrere Schnittstellen implementieren (z. B. FB_Sample IMPLEMENTS I_Sample1, I_Sample2).
• Ein Funktionsbaustein, der eine Schnittstelle implementiert, muss alle Methoden und Eigenschaften enthalten, die in dieser Schnittstelle definiert sind (Schnittstellenmethoden und -eigenschaften). Dabei muss die Deklaration der Methoden und Eigenschaften exakt der Deklaration in der Schnittstelle entsprechen (Name, Rückgabetype, Eingänge, Ausgänge).
• Die Funktionsbausteine fügen den Schnittstellenmethoden und Schnittstelleneigenschaften Funktionsbaustein-spezifischen Code hinzu. Wenn eine Schnittstelle von mehreren Funktionsbausteinen implementiert wird, können Sie die gleiche Methode mit identischen Parametern, aber unterschiedlichem Implementierungscode in verschiedenen Funktionsbausteinen verwenden.
• Für die Funktionsbausteine, die eine oder mehrere Schnittstellen implementieren, überprüft der Compiler, ob sich die Funktionsbausteine an die jeweiligen Schnittstellenvereinbarungen halten. Wenn sich die Deklaration der Elemente in der Schnittstelle und in dem Funktionsbaustein unterscheiden oder wenn die Schnittstelle über weitere Elemente verfügt, die der Funktionsbaustein nicht enthält, meldet der Compiler einen Fehler.

2. Aufruf von Methoden und Eigenschaften einer Funktionsbausteininstanz über eine Schnittstellenvariable

Neben der automatischen Prüfung der Schnittstellenvereinbarung mittels Compiler können Sie Schnittstellen verwenden, um über eine Schnittstellenvariable eine Schnittstellenmethode oder Schnittstelleneigenschaft einer Funktionsbausteininstanz aufzurufen.

• Sie instanziieren zunächst sowohl die Schnittstelle (z. B. iSample : I_Sample;) als auch den bzw. die Funktionsbausteine, die die Schnittstelle ordnungsgemäß implementieren (siehe Anwendungsfall 1: Prüfung der Schnittstellenvereinbarung mittels Compiler).
• Anschließend können Sie der Schnittstellenvariablen jede Instanz eines Funktionsbausteins zuweisen, der die Schnittstelle ordnungsgemäß implementiert. Wenn für eine Schnittstellenvariable noch keine Zuweisung erfolgt ist, enthält die Variable im Onlinebetrieb den Wert 0.
• Im letzten Schritt können Sie über die Schnittstellenvariable eine Schnittstellenmethode oder -eigenschaft aufrufen, wobei die Methode bzw. Eigenschaft für die Funktionsbausteininstanz aufgerufen wird, auf die die Schnittstelle verweist.
• Über eine solche Umsetzung können Sie verschiedene, aber gleichartige Funktionsbausteine über die Schnittstellenvariable einheitlich verwenden. Abhängig vom Projektzustand können Sie der Schnittstellenvariablen beispielsweise eine bestimmte Funktionsbausteininstanz zuweisen, sodass der Aufruf der Schnittstellenmethoden und -eigenschaften identisch ist, aber je nach Projektzustand eine andere Funktionsbausteininstanz verwendet wird.

Einer Variablen vom Typ einer Schnittstelle müssen Sie die Instanz eines Funktionsbausteins zuweisen, bevor eine Methode oder Eigenschaft über die Schnittstellenvariable aufgerufen werden kann.

Hinweise

• Sie dürfen keine Variablen innerhalb einer Schnittstelle deklarieren. Eine Schnittstelle hat keinen Implementierungsteil und keine Aktionen. Es wird nur eine Sammlung von Methoden und Eigenschaften definiert, welche Deklarationscode, aber keinen Implementierungscode enthalten.
• Eine Variable vom Typ einer Schnittstelle ist eine Referenz auf Instanzen von Funktionsbausteinen. TwinCAT behandelt Variablen, die mit dem Typ einer Schnittstelle deklariert sind, immer als Referenzen.

Schnittstellenreferenzen und Online-Change

• Ab TwinCAT 3.0 Build 3100 werden Schnittstellenreferenzen automatisch umadressiert, sodass in jedem Fall, also auch bei einem Online-Change, die korrekte Schnittstelle referenziert wird. Zusätzlicher Code und mehr Zeit werden dafür benötigt und somit muss abhängig von der Anzahl der betroffenen Objekte mit zeitlichen Problemen gerechnet werden. Daher wird dem Programmierer vor Ausführung des Online-Change die Anzahl der betroffenen Variablen und Schnittstellenreferenzen angezeigt, und er muss dann entschieden, ob der Online-Change durchgeführt oder abgebrochen werden soll.

Prüfen von Schnittstellenvariablen

• Den Operator __ISVALIDREF können Sie nur für Operanden vom Typ REFERENCE TO verwenden. Die Prüfung von Schnittstellenvariablen ist mit diesem Operator nicht möglich. Um zu überprüfen, ob einer Schnittstellenvariable bereits eine Funktionsbausteininstanz zugewiesen wurde, können Sie die Schnittstellenvariable auf ungleich 0 prüfen (IF iSample <> 0 THEN …).

Erweitertes Monitoring einer Schnittstellenvariablen

• Ab TwinCAT 3.1 Build 4024 stehen erweiterte Möglichkeiten zum Monitoring/Debugging einer Schnittstellenvariablen zur Verfügung. Dabei kann eine Schnittstellenvariable im Monitoring-Bereich (Deklarationseditor, Überwachungsliste) aufgeklappt werden. Unterhalb der Schnittstellenvariablen werden dann der Symbolpfad und die Onlinedaten der aktuell zugewiesenen FB-Instanz angezeigt.

Beispiel 1

Deklaration der Schnittstelle:

• Sie haben die Schnittstelle I_Sample zu Ihrem Projekt hinzugefügt. Der Schnittstelle fügen Sie die Methode GetType mit dem Rückgabetyp STRING hinzu.
• I_Sample und GetType enthalten keinen Implementierungscode. Die Methode GetType enthält lediglich die benötigten (Variablen-) Deklarationen (z. B. Rückgabetyp). Die Methode GetType können Sie später im Funktionsbaustein ausprogrammieren, der die Schnittstelle I_Sample implementiert.

INTERFACE I_Sample

Methode I_Sample.GetType:

METHOD GetType : STRING

Implementierung der Schnittstelle:

• Wenn Sie anschließend einen Funktionsbaustein zum Projekt hinzufügen und in dem Dialog Hinzufügen in dem Feld Implementiert die Schnittstelle I_Sample angeben, fügt TwinCAT diesem Funktionsbaustein auch automatisch die Methode GetType hinzu. Hier können Sie in den Methoden funktionsbaustein-spezifischen Code implementieren.
• Die Funktionsbausteine FB_A und FB_B implementieren jeweils die Schnittstelle I_Sample:

FUNCTION_BLOCK FB_A IMPLEMENTS I_Sample

FUNCTION_BLOCK FB_B IMPLEMENTS I_Sample

• Beide Funktionsbausteine müssen daher eine Methode mit dem Namen GetType und dem Rückgabetyp STRING enthalten. Ansonsten meldet der Compiler einen Fehler (siehe Anwendungsfall 1 im Abschnitt Anwendungsfälle einer Schnittstelle).

Methode FB_A.GetType:

METHOD GetType : STRING

GetType := 'FB_A';

Methode FB_B.GetType:

METHOD GetType : STRING

GetType := 'FB_B';

Verwendung der Schnittstelle:

• Eine Funktion F_DeliverType enthält die Deklaration einer Eingangsvariablen vom Typ der Schnittstelle I_Sample. Innerhalb der Funktion wird die Schnittstellenmethode GetType über die Schnittstellenvariable iSample aufgerufen. In diesem Fall hängt es vom übergebenen Funktionsbausteintyp ab, ob FB_A.GetType oder FB_B.GetType aufgerufen wird (siehe Anwendungsfall 2 im Abschnitt Anwendungsfälle einer Schnittstelle).

FUNCTION F_DeliverType : STRING
VAR_INPUT
    iSample : I_Sample;
END_VAR

F_DeliverType := iSample.GetType();

• Instanzen von Funktionsbausteinen, die die Schnittstelle I_Sample implementieren (z. B. FB_A und FB_B), können der Eingangsvariablen der Funktion F_DeliverType zugewiesen werden.
• Beispiele für Funktionsaufrufe:
• Wenn der Funktion F_DeliverType die Funktionsbausteininstanz fbA übergeben wird, wird innerhalb der Funktion die Methode fbA.GetType aufgerufen, da die Schnittstellenvariable iSample auf die Funktionsbausteininstanz fbA zeigt. Dieser Methodenaufruf liefert den Rückgabewert 'FB_A', welcher wiederum von der Funktion F_DeliverType zurückgegeben wird und im Hauptprogramm der Variablen sResultA zugewiesen wird.
• Entsprechend erhält sResultB den Wert 'FB_B', da innerhalb der Funktion F_DeliverType die Methode fbB.GetType aufgerufen wird.

PROGRAM MAIN
VAR
    fbA       : FB_A;
    fbB       : FB_B;
    sResultA  : STRING;
    sResultB  : STRING;
END_VAR

sResultA := F_DeliverType(iSample := fbA); // call with instance of type FB_A
sResultB := F_DeliverType(iSample := fbB); // call with instance of type FB_B

Beispiel 2

Deklaration der Schnittstelle:

• Sie haben die Schnittstelle I_Name zu Ihrem Projekt hinzugefügt. Der Schnittstelle fügen Sie die Eigenschaft Name mit dem Rückgabetyp STRING hinzu. Die Eigenschaft besitzt die Accessor-Methoden Get und Set. Der Get-Accessor soll dazu dienen, den Namen irgendeines Objekts aus einem Funktionsbaustein auszulesen, der die Schnittstelle implementiert. Den Set-Accessor verwenden Sie dazu, den Namen in diesen Funktionsbaustein zu schreiben.
• I_Name und Name enthalten keinen Implementierungscode. Die Eigenschaft Name enthält lediglich die benötigte Deklaration (Rückgabetyp). Die Get- und Set-Methoden können Sie innerhalb der Schnittstellendefinition somit nicht bearbeiten, jedoch später im Funktionsbaustein, der die Schnittstelle I_Name implementiert.

INTERFACE I_Name

Eigenschaft I_Name.Name:

PROPERTY Name : STRING

Implementierung der Schnittstelle:

• Die Funktionsbausteine FB_SampleA und FB_SampleB implementieren die Schnittstelle I_Name.
• Wenn die Schnittstelle beispielsweise beim Anlegen der Funktionsbausteine im Dialog Hinzufügen angegeben wird, fügt TwinCAT die Eigenschaft Name mit den Get- und Set-Methoden automatisch unterhalb der Funktionsbausteine FB_SampleA und FB_SampleB ein.
• Unterhalb der Funktionsbausteine können Sie die Accessor-Methoden editieren, beispielsweise so, dass die Variable sVar1 gelesen wird und Sie somit den Namen eines Objekts erhalten. In FB_SampleB, der dieselbe Schnittstelle I_Name implementiert, können Sie in der Get-Methode Code implementieren, der dann den Namen eines anderen Objekts liefert. Die Set-Methode verwenden Sie, um den Namen, den das Programm MAIN liefert ('abc'), in den Funktionsbaustein FB_SampleB zu schreiben.
• Die Funktionsbausteine FB_SampleA und FB_SampleB implementieren jeweils die Schnittstelle I_Name:

FUNCTION_BLOCK FB_SampleA IMPLEMENTS I_Name
VAR
    sVar1 : STRING := 'My name is A.';
END_VAR

FUNCTION_BLOCK FB_SampleB IMPLEMENTS I_Name
VAR
    sVar2 : STRING := 'My name is B.'; 
END_VAR

• Beide Funktionsbausteine müssen daher eine Eigenschaft mit dem Namen Name und dem Rückgabetyp STRING enthalten. Die Eigenschaft muss über eine Get- und eine Set-Methode verfügen. Ansonsten meldet der Compiler einen Fehler (siehe Anwendungsfall 1 im Abschnitt Anwendungsfälle einer Schnittstelle).

FB_SampleA.Name.Get:

Name := sVar1;

FB_SampleA.Name.Set:

sVar1 := Name;

FB_SampleB.Name.Get:

Name := sVar2;

FB_SampleB.Name.Set:

sVar2 := Name;

Verwendung der Schnittstelle:

• Auf die Eigenschaften der Funktionsbausteine kann sowohl über die entsprechenden Funktionsbausteininstanzen als auch über eine Schnittstellenvariable vom Typ I_Name zugegriffen werden. Voraussetzung für den Zugriff über eine Schnittstellenvariable ist, dass dieser Variablen zuvor eine konkrete Funktionsbausteininstanz zugewiesen wurde, die die Schnittstelle I_Name implementiert.

PROGRAM MAIN
VAR
    iName     : I_Name;

    fbSampleA : FB_SampleA; 
    sNameA    : STRING;       // will be 'My name is A.'

    fbSampleB : FB_SampleB;
    sNameB    : STRING;       // will be 'My name is B.' after first cycle
                              // and will be 'New name' afterwards
END_VAR

// assign FB instance fbSample1 to interface variable
iName := fbSampleA;
 
// access to name property of fbSample1 via interface variable (Get)
sNameA := iName.Name;
 
// access to name property of fbSample2 via FB instance (Get and Set)
sNameB := fbSampleB.Name;
fbSampleB.Name := 'New name';