Deklaration eines Funktionsbausteins in ST

Syntax
FUNCTION_BLOCK (* optional_begin *) FINAL|ABSTRACT (* optional_end *) FB_name_2

(* optional_begin *) USING Namespace_1;
USING Namespace_2; (* optional_end *)

(* optional_begin *) EXTENDS FB_name_1 (* optional_end *)

(* optional_begin *) IMPLEMENTS interface_1, interface_2, ... interface_n (* optional_end *)

(* optional: declaration of variables/instances *)

(* optional: declaration of methods *)

(* optional: body of function block *)

END_FUNCTION_BLOCK
Bedeutung

Deklaration eines →Funktionsbausteins, wobei FB_name_2 ein →IEC-Bezeichner sein muss
Die Deklaration ist in einem ST-Objekt und in einer ST-Schnittstelle eines C-/C++-Bausteins möglich darin erfolgt die Deklaration entweder im globalen →Namespace oder in einem deklarierten Namespace. FUNCTION_BLOCK und END_FUNCTION_BLOCK sind die →Schlüsselwörter für die Deklaration des Funktionsbausteins. 

logi.CAD 3 unterstützt die folgenden Varianten an Funktionsbausteinen:

  1. Der Funktionsbaustein enthält nur einen Satz an Operationen (den sogenannten Body).
    In diesem Fall enthält der Funktionsbaustein keine Methoden.
  2. Der Funktionsbaustein enthält den Body und →Methoden.
    Eine Methode ist ähnlich zu einer →Funktion; Eine Methode kann nur im →Gültigkeitsbereich eines →Funktionsbaustein-Typ definiert werden und hat impliziten Zugang zu den →statischen Variablen der →Funktionsbaustein-Instanz. Eine Methode wird nach dem Abschnitt der deklarierten →Variablen/→Instanzen, aber vor dem Body des Funktionsbausteins deklariert.
  3. Der Funktionsbaustein enthält nur Methoden.
    In diesem Fall enthält der Funktionsbaustein einen leeren Body.

Die Schlüsselwörter FINAL und ABSTRACT (Features der →objektorientierte Programmierung) sind optional. Siehe "Deklaration einer Methode" für ein Beispiel mit einem abstrakten/finalen Funktionsbaustein.

  • Verwenden Sie das Schlüsselwort FINAL, falls der aktuelle Funktionsbaustein nicht als Basis-Funktionsbaustein verwendet werden soll und von dem in Folge nicht abgeleitet werden kann. Siehe Schlüsselwort EXTENDS für Details über Basis-Funktionsbaustein und abgeleiteten Funktionsbaustein.
  • Verwenden Sie das Schlüsselwort ABSTRACT, falls der aktuelle Funktionsbaustein ein Basis-Funktionsbaustein sein soll, von dem abgeleitet wird. Es gelten diese Einschränkungen/Folgen:
    • Ein abstrakter Funktionsbaustein darf nicht instanziiert werden.
    • Ein abstrakter Funktionsbaustein muss zumindest eine abstrakte Methode enthalten. 
    • Als Folge muss ein nicht-abstrakter Funktionsbaustein, der von einem abstrakten Funktionsbaustein abgeleitet wird, alle abstrakten Methoden des abstrakten Funktionsbausteins implementieren. 

Die USING-Namespace-Anweisung nach dem Namen des Funktionsbaustein ist ebenfalls optional. Siehe "Namespaces in ST: Verwendung" für Details für diese Anweisung.

Das Schlüsselwort EXTENDS (ein Feature der →objektorientierte Programmierung) ist ebenfalls optional. Geben Sie EXTENDS an, falls der Funktionsbaustein von einem anderen Funktionsbaustein (dem Basis-Funktionsbaustein) abgeleitet werden soll. Den Namen des Basis-Funktionsbausteins FB_name_1 geben Sie hinter EXTENDS an.
Die Auswirkungen des Schlüsselwort EXTENDS sind:

  • Der abgeleitete Funktionsbaustein FB_name_2 erbt alle Variablen und Methoden vom Basis-Funktionsbaustein FB_name_1. Sie können natürlich eigene Variablen und Methoden im abgeleiteten Funktionsbaustein deklarieren. In Folge kann der abgeleitete Funktionsbaustein die vererbten Variablen und Methoden als auch die eigenen Variablen und Methoden verwenden.
    Ausnahme von dieser Vererbung sind jene Methoden, die mit dem Schlüsselwort PRIVATE oder INTERNAL im Basis-Funktionsbaustein deklariert sind.
  • Sie müssen eindeutige Namen für alle Variablen und Methoden im abgeleiteten Funktionsbaustein und im jeweiligen Basis-Funktionsbausteinen verwenden.

  • Der Basis-Funktionsbaustein selbst kann jedoch ein abgeleiteter Funktionsbaustein sein. So können Variablen und Methoden über mehrere Ebenen von Funktionsbaustein zu Funktionsbaustein weiter vererbt werden. Eine Rekursion wird laut der →IEC-Norm nicht unterstützt.
  • Wird der Basis-Funktionsbaustein geändert, erben die abgeleiteten Funktionsbausteine diese Änderungen über die entsprechenden Ebenen hinweg.
  • Weitere Einschränkungen:

    • Ein Funktionsbaustein darf nur von einem Basis-Funktionsbaustein abgeleitet werden. Dieser Basis-Funktionsbaustein muss ein anderer Funktionsbaustein sein. Ein abgeleiteter Funktionsbaustein darf nicht von mehreren Basis-Funktionsbausteinen gleichzeitig erben – dies wird von der IEC-Norm nicht unterstützt. 
    • Ein Funktionsbaustein darf nur von einem Basis-Funktionsbaustein abgeleitet werden, wenn dieser Basis-Funktionsbaustein Methoden enthält. Die Methoden können auch über mehrere Ebenen hinweg enthalten sein, sofern der Basis-Funktionsbaustein wiederum ein abgeleiteter Funktionsbaustein ist usw.
    • Der abgeleitete Funktionsbaustein erbt nicht automatisch den Body des Basis-Funktionsbausteins. Damit beim Aufruf eines abgeleiteten Funktionsbausteins auch der Body des abgeleiteten Funktionsbausteins ausgeführt wird, müssen Sie die Anweisung SUPER(); im Body des abgeleiteten Funktionsbausteins einfügen. Siehe das folgende Beispiel 3.
      Einschränkungen für SUPER();
      • SUPER();  ist nur in einem abgeleiteten Funktionsbaustein zulässig, also nur falls das Schlüsselwort EXTENDS beim Funktionsbaustein angegeben ist.
      • SUPER();  darf nur einmal im Body des abgeleiteten Funktionsbausteins angegeben werden. In Folge ist SUPER();  auch nicht in Wiederholungsanweisungen zulässig.
      • SUPER();  darf in Methoden zum Aufruf einer Methode nicht verwendet werden. Verwenden Sie stattdessen einen der Aufrufe einer Methode.
    • Alternative zu SUPER();: Verlagern Sie den Body des Basis-Funktionsbausteins in eine deklarierte Methode dieses Basis-Funktionsbausteins und rufen Sie diese Methode im abgeleiteten Funktionsbaustein auf. Siehe das folgende Beispiel 4.

Das Schlüsselwort IMPLEMENTS (ein Feature der →objektorientierte Programmierungist ebenfalls optional. Geben Sie IMPLEMENTS an, falls der Funktionsbaustein ein oder mehrere →Interfaces implementieren soll. Die Namen der Interfaces geben Sie hinter IMPLEMENTS an (durch einen Beistrich voneinander getrennt).
Beachten Sie, dass der
Funktionsbaustein in Folge alle Methoden der Interfaces enthalten muss. Ist dies nicht der Fall, weist eine Meldung auf die fehlenden Methoden hin. Verwenden Sie am besten die Schnellkorrektur von logi.CAD 3, um die nicht-implementierten Methoden im Funktionsbaustein hinzuzufügen.  Die konkreten Methoden, die im Funktionsbaustein deklariert sind, werden nur aufgrund des Namens der Methode mit den abstrakten Methoden abgeglichen, die in den Interfaces deklariert sind. Die Methoden mit dem gleichen Namen müssen in den folgenden Aspekte übereinstimmen:

  • Falls ein Datentyp erforderlich ist, muss der Datentyp in der abstrakten Methode und in der konkreten Methode angegeben sein. Der Datentyp muss vom gleichen Typ sein.
    Ist kein Datentyp erforderlich, darf der Datentyp weder in der abstrakten noch in der abstrakten Methode angegeben sein.
  • Alle Variablen, die in der abstrakten Methode deklariert sind, müssen mit den Variablen übereinstimmen, die in der konkrete Methode deklariert sind.
Beispiel 1: Funktionsbaustein ohne Body und ohne Methoden
FUNCTION_BLOCK Control
END_FUNCTION_BLOCK
Beispiel 2: Funktionsbaustein, der Interfaces implementiert
INTERFACE ISwitch     (* Deklaration des 1. Interfaces *)
  METHOD SwitchState
    VAR_INPUT
      STATE : BOOL;
    END_VAR
  END_METHOD
END_INTERFACE
 
INTERFACE IValve      (* Deklaration des 2. Interfaces *)
  METHOD Open
  END_METHOD 
END_INTERFACE
 
FUNCTION_BLOCK MySwitch IMPLEMENTS ISwitch, IValve
  VAR
    switchState : BOOL;
    valveOpen : BOOL;
  END_VAR
  METHOD PUBLIC SwitchState
    VAR_INPUT
    STATE : BOOL;
  END_VAR
    switchState := STATE;
  END_METHOD
  METHOD PUBLIC Open
    valveOpen := TRUE;
  END_METHOD 
END_FUNCTION_BLOCK
Beispiel 3: Abgeleiteter Funktionsbaustein und Basis-Funktionsbaustein
FUNCTION_BLOCK LightRoom (* der Basis-Funktionsbaustein "LightRoom" *)
	VAR
		Light : BOOL;
	END_VAR
	VAR_INPUT
		Daytime : BOOL;
	END_VAR

	METHOD PUBLIC M1 : INT
		m1:=2;
	END_METHOD

	Light := NOT(Daytime);
END_FUNCTION_BLOCK

FUNCTION_BLOCK FB_A
	METHOD PUBLIC m1 : INT
		m1 := 1;
	END_METHOD
END_FUNCTION_BLOCK

FUNCTION_BLOCK Light2Room
	EXTENDS LightRoom (* der abgeleitete Funktionsbaustein "Light2Room" *)
	VAR
		Light2 : BOOL; // 2. Licht
		Inst1 : FB_A;
		v1, v2, v3 : INT;
	END_VAR

	METHOD PUBLIC OVERRIDE M1 : INT
		m1 := 3;
	END_METHOD

	METHOD PUBLIC M2
	END_METHOD

	SUPER(); // Der Body des Basis-Funktionsbaustein "LightRoom" wird hier aufgerufen.
	Light2:= NOT(Daytime);

	v1 := SUPER.M1(); // Die Methode "M1" des Basis-Funktionsbausteins "LightRoom" wird hier aufgerufen.
	v2 := THIS.M1();  // Die Methode "M1" des aktuellen Funktionsbausteins "Light2Room " wird hier aufgerufen.
	v3 := Inst1.M1(); // Die Methode "M1" der Funktionsbaustein-Instanz 'Inst1' (= Funktionsbaustein 'FB_A') wird hier aufgerufen.
END_FUNCTION_BLOCK
Beispiel 4: Abgeleiteter Funktionsbaustein und Basis-Funktionsbaustein
FUNCTION_BLOCK FB1  (* der Basis-Funktionsbaustein "FB1" *)
	VAR
		Var1 : INT;
	END_VAR

	METHOD PUBLIC InitFB1
		Var1 := 5;
	END_METHOD

	InitFB1();      (* Aufruf der Methode "InitFB1" *)
END_FUNCTION_BLOCK

FUNCTION_BLOCK FB2 EXTENDS FB1 (* der abgeleitete Funktionsbaustein "FB2" *)
	VAR
		Var2 : INT;
	END_VAR

	METHOD PUBLIC InitFB2
		Var2 := 5;
		InitFB1();  (* Aufruf der Methode "InitFB1" des Basis-Funktionsbaustein "FB1" - identisch zum Aufruf der Methode im Basis-Funktionsbaustein selbst  *)
	END_METHOD

	InitFB2();      (* Aufruf der Methode "InitFB2" des abgeleiteten Funktionsbaustein "FB2" *)
END_FUNCTION_BLOCK

FUNCTION_BLOCK FB3 
	VAR
		iFB2 : FB2;
	END_VAR

	iFB2();         (* Aufruf des Instanz für den abgeleiteten Funktionsbaustein-Typ "FB2" *)
END_FUNCTION_BLOCK

In einem Funktionsbaustein dürfen Sie die folgenden Sprachelemente für ST verwenden:

Die Verwendung dieser Sprachelemente ermöglicht wiederum eine Verwendung von weiteren Elementen (z.B. Deklaration von STRING-Variablen im Abschnitt VAR ... END_VAR ). Dieses Elemente sind in der obigen Liste nicht angeführt.