10 Programmiersprache Strukturierter Text ST (SCL)

350
10 Programmiersprache Strukturierter Text ST (SCL)
In der DIN EN 61131-3 ist die Programmiersprache Strukturierter Text ST neben der Anweisungsliste AWL als zweite Textsprache für SPSen definiert. Bei STEP 7 wird die entsprechende Programmiersprache SCL (Structured Control Language) genannt. ST (SCL) ist optimiert
für die Programmierung von Speicherprogrammierbaren Steuerungen und enthält sowohl
Sprachelemente aus der Programmiersprache PASCAL als auch typische SPS-Elemente, wie
z. B. Ein-/Ausgänge, Zeiten und Zähler.
Die Programmiersprache ST (SCL) ist besonders für folgende Aufgaben geeignet:
x
x
x
x
Programmierung komplexer Algorithmen für digitale Variablen
Programmierung mathematischer Funktionen
Daten- bzw. Rezepturverwaltung
Prozessoptimierung
10.1 Bausteine in ST (SCL)
Die Programmiersprache ST (SCL) kann in allen von der DIN EN 61131-3 definierten Programmorganisationseinheiten verwendet werden. Der Aufbau der Programmorganisationseinheiten besteht aus den Bereichen: Bausteinanfang, Deklarationsteil, Anweisungsteil und Bausteinende.
10.1.1 Bausteinanfang und -ende
Der Quelltext für einen einzelnen Baustein wird abhängig von der Bausteinart mit einem Standardbezeichner für den Anfang des Bausteins und der Bausteinbezeichnung eingeleitet. Abgeschlossen wird er bei STEP 7 mit einem Standardbezeichner für das Ende des Bausteins.
Die Syntax für die verschiedenen Bausteinarten zeigt folgende Tabelle:
Bausteinart
Name Syntax in STEP 7
Syntax in CoDeSys
Programm
PRG
PROGRAM xxxx
Organisationsbaustein
OB
ORGANIZATION_BLOCK OBxx
...
END_ORGANIZATION_BLOCK
Funktion
FC
FUNCTION FCxx : TYP
...
END_FUNCTION
FUNCTION FCxx : TYP
Funktionsbaustein
FB
FUNCTION_BLOCK FBxx
...
END_FUNCTION_Block
FUNCTION_BLOCK FBxx
Datenbaustein
DB
DATA_BLOCK DBxx
...
END_DATA_Block
UDT-Baustein
(Datenstruktur)
UDT TYPE UDTxx
...
END_TYPE
10.1 Bausteine in ST (SCL)
351
10.1.2 Deklarationsteil
Der Deklarationsteil dient zur Vereinbarung der lokalen Variablen, Eingangs-, Ausgangs- bzw.
Durchgangs-Parameter und Konstanten. Darüber hinaus bieten die beiden Programmiersysteme STEP 7 und CoDeSys noch weitere spezifische Daten zur Deklaration an.
Der Deklarationsteil gliedert sich in unterschiedliche Vereinbarungsblöcke, die jeweils durch
ein eigenes Schlüsselwortpaar gekennzeichnet sind. Jeder Block enthält eine Deklarationsliste
für gleichartige Daten. Die Reihenfolge dieser Blöcke ist beliebig.
In der nachfolgenden Tabelle zeigt die möglichen Vereinbarungsblöcke in einem Funktionsbaustein an Beispielen:
Daten
Syntax in STEP 7
Syntax in CoDeSYS
Eingangsparameter
(Eingangsvariable)
VAR_INPUT
IN1:BOOL:=FALSE;
END_VAR
VAR_INPUT
IN1:BOOL:=FALSE;
END_VAR
Ausgangsparameter
(Ausgangsvariable)
VAR_OUTPUT
OUT1:BOOL:=TRUE;
END_VAR
VAR_OUTPUT
OUT1:BOOL:=TRUE;
END_VAR
Durchgangsparameter
(Durchgangsvariable)
VAR_IN_OUT
INOUT1:INT:=123;
END_VAR
VAR_IN_OUT
INOUT1:INT;
END_VAR
Statische Variable
VAR
VAR1:REAL:=0.1;
END_VAR
VAR
VAR1:REAL:=0.1;
END_VAR
Konstanten
CONST
Wert:=16#FFFF;
END_CONST
VAR CONSTANT
Wert:WORD:=16#FFFF
END_VAR
Temporäre Variable
VAR_TEMP
VAR2:REAL;
END_VAR
Remanente Variable
Sprungmarken
VAR RETAIN
VAR3:INT:=123;
END_VAR
LABEL
Marke1, Make2;
END_LABEL
Hinweis: Die Initialisierung der Werte ist nur in Funktionsbausteinen und bei STEP 7 in Datenbausteinen möglich. In Funktionen oder Programmen können den Variablen keine Anfangswerte zugewiesen werden.
10.1.3 Anweisungsteil
Der Anweisungsteil beinhaltet Anweisungen, die nach dem Aufruf eines Codebausteins zur
Ausführung kommen sollen. Eine Anweisung ist dabei die kleinste selbstständige Einheit des
Anwenderprogramms. Sie stellt eine Arbeitsvorschrift für den Prozessor dar. ST (SCL) kennt
folgende Arten von Anweisungen:
Wertzuweisungen,
die dazu dienen, einer Variablen einen Wert, das Ergebnis eines Ausdrucks oder den Wert
einer anderen Variablen zuzuweisen.
352
10 Programmiersprache Strukturierter Text ST (SCL)
Kontrollanweisungen,
die dazu dienen, Anweisungen oder Gruppen von Anweisungen zu wiederholen oder innerhalb
eines Programms zu verzweigen.
Unterprogrammbearbeitungen,
die zum Aufrufen von Funktionen und Funktionsbausteinen dienen.
Regeln für den Anweisungsteil:
STEP 7
CoDeSys
Jede Anweisung endet mit einem Semikolon.
x
x
Alle verwendeten Bezeichner müssen vorher vereinbart sein.
x
x
Der Anweisungsteil wird mit dem Schlüsselwort BEGIN eingeleitet.
x
-
Der Anweisungsteil endet mit dem Schlüsselwort für das Bausteinende.
x
-
Vor jeder Anweisung können optional Sprungmarken stehen.
x
-
Regel
10.2 Ausdrücke, Operanden und Operatoren
10.2.1 Übersicht
Ein Ausdruck ist ein Konstrukt, das bei Auswertung einen Wert liefert, der zur Laufzeit des
Programms berechnet wird. Ausdrücke bestehen aus Operanden (z. B. Konstanten, Variablen
oder Funktionsaufrufe) und Operatoren (z. B. *, /, + oder –). Der Datentyp des Operanden und
der verwendete Operator bestimmen den Typ des Ausdrucks. ST (SCL) unterscheidet arithmetische Ausdrücke, Vergleichs-Ausdrücke und logische Ausdrücke
Die Auswertung eines Ausdrucks erfolgt durch Anwenden der Operatoren auf die Operanden
in bestimmter Reihenfolge. Diese ist festgelegt durch die Priorität der beteiligten Operatoren,
der links-rechts Reihenfolge oder durch die vorgenommene Klammerung.
Das Ergebnis eines Ausdrucks kann einer Variablen zugewiesen werden, als Bedingung für
eine Abfrage oder als Parameter für den Aufruf einer Funktion oder eines Funktionsbausteines
verwendet werden.
10.2.2 Operatoren
Die meisten Operatoren verknüpfen zwei Operanden und werden deshalb als binär bezeichnet.
Andere Operatoren arbeiten mit nur einem Operanden, daher bezeichnet man sie als unär.
Binäre Operatoren werden zwischen die Operanden geschrieben (z. B. A + B). Eine unäre
Operation steht immer unmittelbar vor seinem Operand (z. B. –B).
Wenn ein Ausdruck mehrere Operationen enthält, muss der linke Operand zuerst ausgewertet
werden. Zum Beispiel muss im Ausdruck SIN(X) * TAN(Y) die Operation SIN(X) zuerst
ausgewertet werden, gefolgt von TAN(Y) und danach wird die Multiplikation ausgeführt. Die
folgenden Bedingungen bei der Ausführung von Operatoren führen zu Fehlern:
x Division durch Null
x Operanden haben nicht den für die Operation erforderlichen Datentyp.
x Das Ergebnis überschreitet den Wertebereich des Datentyps.
10.2 Ausdrücke, Operanden und Operatoren
353
Zusammenstellung der Operatoren der Sprache ST (SCL):
Klasse
Zuweisungsoperation
Arithmetische
Operationen
Vergleichsoperationen
Logische Operationen
Klammerungszeichen
Funktionsbearbeitung
(Auswahl)
Operation
Zuweisung
Potenz
unäres Plus
unäres Minus
Multiplikation
Division
Modulo-Funktion
ganzzahlige Division
Addition
Subtraktion
Kleiner
Größer
Kleiner gleich
Größer gleich
Gleichheit
Ungleichheit
Negation
UND
ODER
EXCLUSIV-ODER
Klammer auf/zu
Exponent e hoch N
Exponent 10 hoch N
Exponent M hoch N
Natürlicher Logarithmus
Dekad. Logarithmus
Betrag
Quadrat
Quadratwurzel
Arcus-Cosinus
Arcus-Sinus
Arcus-Tangens
Cosinus
Sinus
Tangens
Symbol
:=
**
+
*
/
MOD
DIV
+
<
>
<=
>=
=
<>
NOT
AND od. &
OR
XOR
( )
EXP
EXPD
EXPT
LN
LOG
ABS
SQR
SQRT
ACOS
ASIN
ATAN
COS
SIN
TAN
Rang
11
2
3
3
4
4
4
4
5
5
6
6
6
6
7
7
3
8
10
9
1
Hinweis
Bei STEP 7
Bei CoDeSys
Bei STEP 7
Hinweis: In den Kapiteln 4, 5 und 7 ist die Syntax der Operationen in ST (SCL) bei der allgemeinen Darstellung der Operatoren in der Programmiersprache STEP 7 und CoDeSys bereits
beschrieben.
10.2.3 Operanden
Ein Operand kann eine Konstante, eine Variable, ein Funktionsaufruf oder ein Ausdruck sein.
Die Operandenkennzeichen sind in Kapitel 2 beschrieben und gelten für ST (SCL) gleichermaßen.
354
10 Programmiersprache Strukturierter Text ST (SCL)
10.2.4 Ausdrücke
Man unterscheidet arithmetische Ausdrücke, logische Ausdrücke und Vergleichsausdrücke.
Das Ergebnis eines logischen Ausdrucks und eines Vergleichsausdrucks ist ein boolescher
Wert.
Die Verarbeitung von Ausdrücken erfolgt nach den folgenden Regeln:
x Ein Operand zwischen zwei Operationen von unterschiedlicher Priorität ist immer an die
höherrangige gebunden.
x Die Operationen werden entsprechend der hierarchischen Rangfolge bearbeitet.
x Operationen gleicher Priorität werden von links nach rechts bearbeitet.
x Das Voranstellen eines Minuszeichens vor einen Bezeichner ist gleichbedeutend mit der
Multiplikation mit –1.
x Arithmetische Operationen dürfen nicht direkt aufeinander folgen. Deshalb ist der Ausdruck a * –b ungültig, aber a*(–b) erlaubt.
x Das Setzen von Klammerpaaren kann den Operationenvorrang außer Kraft setzen, d. h., die
Klammerung hat die höchste Priorität.
x Ausdrücke in Klammern werden als einzelner Operand betrachtet und immer als Erstes
ausgewertet.
x Die Anzahl von linken Klammern muss mit der von rechten Klammern übereinstimmen.
x Arithmetische Operationen können nicht in Verbindung mit Zeichen oder logischen Daten
angewendet werden. Deshalb sind Ausdrücke wie 'A' + 'B' und (n <= 0) + (m > 0) falsch.
10.3 Anweisungen
Anweisungen müssen durch ein Semikolon abgeschlossen werden. Die maximal erlaubte Länge von Anweisungen ist ein implementierungsabhängiger Parameter. Man unterscheidet drei
Arten von Anweisungen: Wertzuweisungen, Kontrollanweisungen und Bausteinaufrufe.
10.3.1 Wertzuweisungen
Wertzuweisungen ersetzen den momentanen Wert einer Variablen mit einem neuen Wert, der
über einen Ausdruck angegeben wird. Dieser Ausdruck kann auch Bezeichner von Funktionen
enthalten, die dadurch aktiviert werden und entsprechende Werte zurückliefern .
Beispiele:
Wertzuweisung einer Konstanten zu einer Variablen
SCHALTER_1
SOLLWERT_1
ABFRAGE_1
ZEIT_1
ZEIT_2
DATUM_1
:=
:=
:=
:=
:=
:=
-15 ;
40.5 ;
TRUE ;
T#1H_20M_10S_30MS ;
T#2D_1H_20M_10S_30MS ;
D#1996-01-10 ;
Wertzuweisung einer Variablen zu einer Variable
SOLLWERT_1 := SOLLWERT_2 ;
SCHALTER_2 := SCHALTER_1 ;
Wertzuweisung eines Ausdrucks zu einer Variablen
SCHALTER_2 := SCHALTER_1 * 3 ;
10.3 Anweisungen
355
Wertzuweisungen von Feldkomponenten
Feldname_1[ n ]
Feldname_1[ n ]
Bezeichner_1
Feldname_1
:=
:=
:=
:=
Feldname_2[ m ] ;
Ausdruck ;
Feldname_1[ n ] ;
Feldname_2
Wertzuweisungen mit Variablen vom Typ STRING
MELDUNG_1 := 'Fehler in Modul 3' ;
MELDUNG_2 := STRUKTUR1.MELDUNG_3 ;
Wertzuweisungen mit Variablen vom Typ DATE_AND_TIME
ZEIT_1 := DATE_AND_TIME#1995-01-01-12:12:12.2 ;
STRUKTUR1.ZEIT_3 := DT#1995-02-02-11:11:11 ;
ZEIT_1 := STRUKTUR1.ZEIT_2 ;
Der Zugriff auf SPS-Operanden wie Eingänge, Ausgänge, Merkern, sowie bei STEP 7 Datenbausteine und UDTs unterscheidet sich bei den beiden Programmiersystemen. Bei CoDeSys
können die Variablennamen durch die absolute SPS-Adresse ersetzt werden. Bei STEP 7 gibt
es die Möglichkeiten eines absoluten, indizierten und symbolische Zugriffs.
Beispiele für Wertzuweisungen mit SPS-Operanden bei STEP 7:
Absoluter Zugriff:
STATUSWORT1
A1.1
Wert1
Wert1_1[1]
:=
:=
:=
:=
EW4 ;
TRUE ;
DB11.DW1 ;
DB11.ZAHL
Indizierter Zugriff:
STATUSWORT3 := EB[ADRESSE] ;
A[1.ByteNR]:= Wert2;
Symbolischer Zugriff:
Messwert_1:= Sens_1 //In der Symboltabelle ist die absolute
//Adresse E 1.7 für Sens_1 festgelegt.
10.3.2 Kontrollanweisungen
Mit Kontrollanweisungen wird der Programmfluss in Abhängigkeit von Bedingungen beeinflusst, um in verschiedene Anweisungsfolgen zu verzweigen. Man unterscheidet Auswahlanweisungen, Wiederholungsanweisungen (Schleifenbearbeitung) und Programmsprünge.
10.3.2.1 Übersicht
Auswahlanweisungen: Eine Auswahlanweisung wählt aufgrund einer Bedingung oder mehrerer Bedingungen Anweisungen zur Bearbeitung aus. Damit ergibt sich die Möglichkeit, den
Programmfluss in verschiedene Anweisungsfolgen zu verzweigen.
Kontrollanweisung
Funktion
IF-Anweisung
Mit der IF-Anweisung kann der Programmfluss in Abhängigkeit von
einer Bedingung, die entweder TRUE oder FALSE ist, in eine von
zwei Alternativen verzweigen.
CASE-Anweisung
Mit einer CASE-Anweisung kann der Programmfluss im Sinne einer
1: n-Verzweigung gesteuert werden, indem eine Variable einen Wert
aus n möglichen annimmt.
356
10 Programmiersprache Strukturierter Text ST (SCL)
Wiederholungsanweisungen: Wiederholungsanweisungen legen fest, dass eine Gruppe von
zugehörigen Anweisungen wiederholt ausgeführt werden muss.
Kontrollanweisung
FOR-Anweisung
Funktion
Die FOR-Anweisung dient zur Wiederholung einer Anweisungsgruppe, solange die Laufvariable innerhalb des angegebenen Wertebereichs liegt.
WHILE-Anweisung
Die WHILE-Anweisung dient zur Wiederholung einer Anweisungsgruppe, solange eine Durchführungsbedingung erfüllt ist.
REPEAT-Anweisung
Die REPEAT-Anweisung dient zur Wiederholung einer Anweisungsgruppe, bis eine Abbruchbedingung erfüllt ist.
Programmsprünge: Ein Programmsprung bewirkt das sofortige Verlassen der Programmschleife, das sofortige Verlassen des Bausteins oder nur bei STEP 7 den sofortigen Sprung zu
einem angegebenen Sprungziel und damit zu einer anderen Anweisung innerhalb desselben
Bausteins.
Kontrollanweisung
EXIT-Anweisung
RETURN-Anweisung
Funktion
Die EXIT-Anweisung dient zum Verlassen einer FOR-, WHILE-,
oder REPEAT-Schleife, bevor deren Ende-Bedingung erfüllt ist.
Die RETURN-Anweisung bewirkt das Verlassen des aktuell bearbeiteten Bausteins.
Nur in STEP 7
CONTINUEAnweisung
Die CONTINUE-Anweisung kann die momentane Bearbeitung des
Schleifenrumpfes einer FOR-, WHILE- oder REPEAT-Schleife umgehen, ohne die Schleifendurchläufe zu beeinflussen.
GOTO-Anweisung
Mit einer GOTO-Anweisung kann ein Programmsprung realisiert
werden. Die Anweisung bewirkt den sofortigen Sprung zu einer
angegebenen Sprungmarke und damit zu einer anderen Anweisung
innerhalb desselben Bausteins.
10.3.2.2 IF-Anweisung
Die IF-Anweisung ist eine bedingte Anweisung. Sie bietet eine oder mehrere Optionen und
wählt eine (gegebenenfalls auch keine) ihrer Anweisungsteile zur Ausführung an. Die Ausführung der bedingten Anweisung bewirkt die Auswertung der angegebenen logischen Ausdrücke. Ist der Wert eines Ausdrucks TRUE, so gilt die Bedingung als erfüllt, bei FALSE als
nicht erfüllt.
Die IF-Anweisung wird nach den folgenden Regeln bearbeitet:
x Die erste Anweisungsfolge, deren logischer Ausdruck = TRUE ist, kommt zur Ausführung.
Die restlichen Anweisungsfolgen kommen nicht zur Ausführung.
x Falls kein boolescher Ausdruck = TRUE ist, wird die Anweisungsfolge bei ELSE ausgeführt (oder keine Anweisungsfolge, falls der ELSE-Zweig nicht vorhanden ist).
x Es dürfen beliebig viele ELSIF-Anweisungen vorhanden sein.
10.3 Anweisungen
357
Beispiel:
Anweisungen
Zugehöriges Struktogramm
IF S1 THEN
OUT1 := 10 ;
ELSIF S2 THEN
OUT1 := 20 ;
ELSE
OUT1 := 30 ;
END_IF ;
10.3.2.3 CASE-Anweisung
Die CASE-Anweisung dient der Auswahl unter 1–n alternativen Programmteilen. Diese Auswahl beruht auf dem laufenden Wert eines Auswahl-Ausdrucks.
Die CASE-Anweisung wird nach folgenden Regeln bearbeitet:
x Der Auswahl-Ausdruck muss einen Wert vom Typ INTEGER liefern.
x Bei der Abarbeitung der CASE-Anweisung wird überprüft, ob der Wert des AuswahlAusdrucks in einer angegebenen Werteliste enthalten ist. Bei Übereinstimmung wird der
der Liste zugeordnete Anweisungsteil ausgeführt.
x Ergibt der Vergleichsvorgang keine Übereinstimmung, so wird der Anweisungsteil nach
ELSE ausgeführt oder keine Anweisung, falls der ELSE-Zweig nicht vorhanden ist.
Beispiel:
Anweisungen
Zugehöriges Struktogramm
CASE A_W OF
0: OUT1:=0;
1: OUT1:=1;
2..5: OUT1:=2;
6,8,10:OUT1:=3;
ELSE:
OUT1:=10;
END_CASE;
10.3.2.4 FOR-Anweisung
Eine FOR-Anweisung dient zur Wiederholung einer Anweisungsfolge, solange eine Laufvariable innerhalb des angegebenen Wertebereichs liegt. Die Laufvariable muss der Bezeichner
einer lokalen Variablen vom Typ INT oder DINT sein. Die Definition einer Schleife mit FOR
schließt die Festlegung eines Start- und eines Endwertes mit ein. Beide Werte müssen typgleich mit der Laufvariablen sein.
Beim Start der Schleife wird die Laufvariable auf den Startwert (Anfangszuweisung) gesetzt
und nach jedem Schleifendurchlauf um die angegebene Schrittweite erhöht (positive Schrittweite) oder erniedrigt (negative Schrittweite), solange bis der Endwert erreicht ist. Nach jedem
Durchlauf wird überprüft, ob die Bedingung (Variable liegt innerhalb des Wertebereichs)
erfüllt ist. Bei JA wird die Anweisungsfolge ausgeführt, andernfalls wird die Schleife und
damit die Anweisungsfolge übersprungen.
Folgende Regeln sind bei der Formulierung von FOR-Anweisungen zu beachten:
x Die Laufvariable darf nur vom Datentyp INT oder DINT sein.
x Die Schrittweite muss nicht angegeben werden. Ist keine angegeben, beträgt sie +1.
358
10 Programmiersprache Strukturierter Text ST (SCL)
Beispiel:
Anweisungen
Zugehöriges Struktogramm
INDEX:=0;
OUT1:=0;
FOR INDEX:= ANFW TO ENDW BY 1 DO
OUT1:=OU1 + INDEX;
END_FOR;
10.3.2.5 WHILE-Anweisung
Die WHILE-Anweisung erlaubt die wiederholte Ausführung einer Anweisungsfolge unter der
Kontrolle einer Durchführungsbedingung. Die Durchführungsbedingung wird nach den Regeln eines logischen Ausdrucks gebildet.
Die WHILE-Anweisung wird nach folgenden Regeln bearbeitet:
x Vor jeder Ausführung des Anweisungsteils wird die Durchführungsbedingung ausgewertet
(abweisende Schleife oder kopfgesteuerte Schleife).
x Der auf DO folgende Anweisungsteil wird solange wiederholt bearbeitet, wie die Durchführungsbedingung den Wert TRUE liefert.
x Tritt der Wert FALSE auf, wird die Schleife übersprungen und die der Schleife folgende
Anweisung ausgeführt.
Beispiel:
Anweisungen
Zugehöriges Struktogramm
INDEX:=0;
OUT1:=0;
WHILE INDEX < ENDW DO
INDEX:=INDEX + 1;
OUT1:=OUT1+INDEX;
END_WHILE;
10.3.2.6 REPEAT-Anweisung
Eine REPEAT-Anweisung bewirkt die wiederholte Ausführung einer zwischen REPEAT und
UNTIL stehenden Anweisungsfolge bis zum Eintreten einer Abbruchbedingung. Die Abbruchbedingung wird nach den Regeln eines logischen Ausdrucks gebildet. Die Bedingung
wird jeweils nach der Ausführung des Rumpfes überprüft. Dies bedeutet, dass der Rumpf
mindestens einmal ausgeführt wird, auch wenn die Abbruchbedingung von Anfang an erfüllt
ist.
Beispiel:
Anweisungen
OUT1:=0;
INDEX:=0;
REPEAT
INDEX:=INDEX + 1;
OUT1:=OUT1 + INDEX;
UNTIL INDEX >= ENDW
END_REPEAT;
Zugehöriges Struktogramm
10.3 Anweisungen
359
10.3.2.7 EXIT-Anweisung
Eine EXIT-Anweisung dient zum Verlassen einer Schleife (FOR, WHILE oder REPEAT) an
beliebiger Stelle und unabhängig davon, ob die Abbruchbedingung erfüllt ist. Die Anweisung
ist im Struktogramm nicht darstellbar.
Die EXIT-Anweisung wird nach folgenden Regeln bearbeitet:
x Diese Anweisung bewirkt das sofortige Verlassen derjenigen Wiederholungsanweisung,
die die EXIT-Anweisung unmittelbar umgibt.
x Die Ausführung des Programms wird nach dem Ende der Wiederholungsschleife (z. B.
nach END_FOR) fortgesetzt.
Beispiel:
Anweisungen
Programmablaufplan
OUT1:=0;
INDEX:=0;
REPEAT
OUT1:=OUT1+INDEX;
IF OUT1 > ABRW THEN
EXIT;
END_IF;
INDEX:=INDEX+1;
UNTIL INDEX > ENDW
END_REPEAT;
10.3.2.8 RETURN-Anweisung
Eine RETURN-Anweisung bewirkt das Verlassen des aktuell bearbeiteten Bausteins und die
Rückkehr zum aufrufenden Baustein bzw. zum Betriebssystem.
Beispiel:
Anweisungen
Struktogramm
IF WERT > 100 THEN
RETURN
ELSE
... //Weitere Anweisungen
10.3.2.9 CONTINUE-Anweisung
Eine CONTINUE-Anweisung dient zum Abbruch der Ausführung des momentanen Schleifendurchlaufes einer Wiederholungsanweisung (FOR, WHILE oder REPEAT). Die Anweisung ist nur bei STEP 7 SCL vorhanden und mit einem Struktogramm nicht darstellbar.
Die CONTINUE-Anweisung wird nach folgenden Regeln bearbeitet:
x Diese Anweisung bewirkt die sofortige Umgehung des Schleifenrumpfes, ohne die Schleifenbearbeitung zu unterbrechen.
x Abhängig davon, ob die Bedingung für die Wiederholung der Schleife erfüllt ist oder nicht,
wird der Schleifenrumpf weiterhin bearbeitet oder die Schleife verlassen.
360
10 Programmiersprache Strukturierter Text ST (SCL)
x In einer FOR-Anweisung wird direkt nach einer CONTINUE-Anweisung die Laufvariable
um die angegebene Schrittweite erhöht.
Beispiel:
Anweisungen
Programmablaufplan
OUT1:=0;
INDEX:=0;
REPEAT
INDEX:=INDEX+1;
IF OUT1 >= OGR THEN
CONTINUE;
END_IF;
OUT1:=OUT1+10;
UNTIL INDEX > ENDW-1
END_REPEAT;
10.3.2.10 GOTO-Anweisung
Mit einer GOTO-Anweisung kann ein Programmsprung realisieren werden. Die Anweisung
bewirkt den sofortigen Sprung zu einer angegebenen Sprungmarke und damit zu einer anderen
Anweisung innerhalb desselben Bausteins.
Nach den Regeln der strukturierten Programmierung sollte die GOTO-Anweisung nicht verwendet werden. Die Anweisung ist nur bei STEP 7 SCL vorhanden und mit einem Struktogramm nicht darstellbar.
Bei der Verwendung der GOTO-Anweisung sind folgende Regeln zu beachten:
x Das Ziel einer Sprunganweisung muss innerhalb desselben Bausteins liegen.
x Das Sprungziel muss eindeutig sein.
x Einsprung in einen Schleifenblock ist nicht zulässig. Aussprung aus einem Schleifenblock
ist möglich.
Beispiel:
Anweisungen
..
IF Wert1 > Wert2 THEN
GOTO MARKE1 ;
ELSIF Wert1 > Wert3 THEN
GOTO MARKE2 ;
ELSE
GOTO MARKE3 ;
END_IF ;
MARKE1: INDEX := 1 ;
GOTO MARKE3 ;
MARKE2: INDEX := 2 ;
. . .
MARKE3: ..//Programmfortsetzung .
Programmablaufplan
10.3 Anweisungen
361
10.3.3 Steueranweisungen für Funktionen und Funktionsbausteinen
Beim Aufruf von Funktionen oder Funktionsbausteinen findet ein Datenaustausch zwischen
dem aufrufenden und dem aufgerufenen Baustein statt. In der Schnittstelle des aufgerufenen
Bausteins sind Parameter definiert, mit denen der Baustein arbeitet. Diese Parameter werden
als Formalparameter bezeichnet. Sie sind lediglich „Platzhalter“ für die Parameter, die dem
Baustein beim Aufruf übergeben werden. Die beim Aufruf übergebenen Parameter werden als
Aktualparameter bezeichnet.
Die Parameter, die übergeben werden sollen, müssen im Aufruf als Parameterliste angegeben
werden. Die Parameter werden in Klammern geschrieben. Mehrere Parameter werden durch
Kommas getrennt.
10.3.3.1 Aufruf von Funktionsbausteinen
Bei Funktionsbausteinaufruf hat die Beschaltung der Eingangs- und Durchgangsparameter die
Form einer Wertzuweisung. Durch diese Wertzuweisung wird den Parametern, die im Vereinbarungsteil des aufgerufenen Bausteins definiert sind (Formalparametern), ein Wert (Aktualparameter) zugewiesen.
Die Ausgangsparameter können nach der Bearbeitung des aufgerufenen Bausteins aus der
zugehörigen Instanz mit einer Wertzuweisung gelesen werden.
Aufruf in STEP 7
Beim Aufruf eines Funktionsbausteins können sowohl globale Instanz-Datenbausteine als auch
lokale Instanzbereiche (Multiinstanzen) des aktuellen Instanz-Datenbausteins benutzt werden.
Globale Instanz: Der Aufruf erfolgt in einer Aufrufanweisung unter Angabe des Namens des
Funktionsbausteins bzw. Systemfunktionsbausteins (FB oder SFB-Bezeichnung), des InstanzDatenbausteins (DB-Bezeichnung) sowie der Parameterversorgung (FB-Parameter). Ein Aufruf einer globalen Instanz kann absolut oder symbolisch definiert sein.
Beispiel:
FB10.DB20(IN1:=10,IN2:=5,... );
REGLER.DATEN (IN1:=10,IN2:=5,... );
Lokale Instanz: Der Aufruf erfolgt in einer Aufrufanweisung unter Angabe des lokalen Instanznamens und der Parameterversorgung. Ein Aufruf einer lokalen Instanz ist immer symbolisch. Der symbolische Namen muss im Vereinbarungsteil des aufrufenden Bausteins vereinbart werden.
Beispiel:
REGDATEN (IN1:=10, IN2:=VAR2, ... );
Ausgangswerte: Nach dem Bausteindurchlauf des aufgerufenen FBs sind die übergebenen
aktuellen Eingangsparameter unverändert und die übergebenen aber veränderten Werte der
Durchgangsparameter aktualisiert. Nun können die Ausgangsparameter vom aufrufenden Baustein aus dem globalen Instanz-Datenbaustein oder dem lokalen Instanzbereich gelesen werden.
Beispiel:
ERGEBNIS:=DB10.STELLWERT;
ERGEBNIS:=DATEN.OUT1;
Aufruf in CoDeSys
Bei CoDeSys wird der Funktionsblock mit dem Namen der Instanz des Bausteins aufgerufen.
Anschließend werden in Klammer die gewünschten Werte den Parametern zugewiesen. Die
362
10 Programmiersprache Strukturierter Text ST (SCL)
Ergebnisvariable kann mit der Konstruktion Instanzname.Variablenname angesprochen werden.
Beispiel:
FB10_INST1(IN1:=10, IN2:= VAR1, ... )
ERGEBNIS:= FB10_INST1.OUT1;
10.3.3.2 Aufruf von Funktionen
Eine Funktion ist ein Baustein, der als Ergebnis der Ausführung genau ein Wert (der auch ein
Feld oder eine Struktur sein kann) zurückliefert und nach DIN EN 61131-3 noch beliebig viele
zusätzliche Durchgangs- (VAR_IN_OUT) oder Ausgangselemente (VAR_OUTPUT) liefert.
Aufruf in STEP 7
Der Aufruf einer Funktion erfolgt unter Angabe des Funktionsnamens (FC.., SFC.. oder
BEZEICHNER), sowie der Parameterliste, welche die Eingangs-, Durchgangs-, und Ausgangsparameter enthält. Der Funktionsname, der den Rückgabewert bezeichnet, kann absolut
oder symbolisch angegeben werden.
Beispiele:
Aufruf ohne Rückgabewert: FC10 (LAE:=VAR1, BRE:= VAR2, FLA:= Ergebnis);
Aufruf mit Rückgabewert:
Ergebnis:= FC10 (LAE:=VAR1, BRE:= VAR2);
Aufruf in CoDeSys
Bei CoDeSys können derzeit bei Funktionen keine Ausgangsparameter deklariert werden. Das
Ergebnis der Funktion steht somit stets im Rückgabewert. In ST kann ein Funktionsaufruf als
Operand in Ausdrücken verwendet werden.
Beispiel:
Ergebnis: = FC10 (IN1: =10, 20, IN3: =VAR1)
Hinweis: Statt FC10 können beliebige Bezeichnungen verwendet werden.
10.3.3.3 Aufruf von Zählern und Zeiten
Werden die Standard-Funktionsbausteine für Zähler CTU, CTD und CTUD sowie für Zeiten
TP, TON und TOF verwendet, so gelten für deren Aufrufe die Regeln für den Aufruf von
Funktionsbausteinen.
Beispiel: STEP 7: SFB2.DB22(CU:=S1, CD:=S2, R:= RESET, LOAD:=S3,PV:=20);
ZAEST: = DB22.CV;
CoDeSys: ZAE(CU:=S1, CD:=S2, R:= RESET, LOAD:=S3,PV:=20);
ZAEST:= ZAE.CV;
Werden bei STEP 7 die Standard- Zählfunktionen S_CU, S_CD und S_CDU sowie die Standard-Zeitfunktionen S_PULSE (SI), S_PEXT (SV), S_ODT (SE) S_ODTS (SS) und
S_OFFDT (SA) verwendet, so gelten die im vorigen Abschnitt beschriebenen Regeln für den
Aufruf von Funktionen. Die Standardfunktionen für Zeiten und Zähler können im S7-SCLProgramm ohne vorherige Deklaration verwenden werden. Sie müssen lediglich mit den erforderlichen Parametern versorgt werden. Beispiel:
BCD_Wert:= S_ODT(T_NO:=ZEIT, S:=S1, TV:= ZW,R:=S2, BI:=BinWert, Q:=P);
Der Aufruf und die Parameter der Standard-Funktionsbausteine wie auch die Standard-Funktionen für Zähler und Zeiten sind im Kapitel 4 ausführlich beschrieben.
10.4 Beispiele
363
10.4 Beispiele
„ Beispiel 10.1: Pegelschalter (FC1001_HYS)
Abhängig von sich ständig ändernden Messwerten eines Sensors soll mit Hilfe einer Funktion FC 1001
ein Ausgang bei Überschreitung eines bestimmten vorgebbaren Schaltwertes ein- und bei Unterschreiten
ausgeschaltet werden. Um ein mögliches Hin- und Herschalten (Flattern) am Schaltwert zu verhindern,
wird an einem weiteren Funktionseingang eine Schalthysterese in % vom Schaltwert vorgegeben. Die
Messwerte haben durch eine Umwandlungsfunktion das Datenformat REAL.
Bild 10.1: Schalthysterese
Funktion FC 1001:
Übergabeparameter:
Beschreibung der Parameter:
MEW:
REAL Messwert
SP: REAL: Schaltpunkt
HYS:
REAL Hysterese
OUT:
BOOL Schaltausgang
Zuordnungstabelle der Merker und Ausgänge:
Merkervariable
Messwert
Schaltpunkt
Hysterese
Ausgangsvariable
Schaltaktor
Symbol
MD_1
MD_2
MD_3
Datentyp
REAL
REAL
REAL
Logische Zuordnung
Gleitpunktzahl
Gleitpunktzahl
Gleitpunktzahl
AKT
BOOL
Aktor eingeschaltet
Adresse
MD 10
MD 20
MD 30
AKT = 1
A 4.1
Lösung
Aus dem Prozentwert der Schalthysterese HYS und dem Schaltpunkt SP wird der obere und der untere
Schaltpunkt berechnet. Durch Vergleichen des aktuellen Messwertes mit den Schaltpunkten wird der
Signalzustand des Ausgangs OUT bestimmt. Liegt der Messwert weder oberhalb noch unterhalb des
Abschaltpunktes, behält der Ausgang OUT seinen bisherigen Wert.
Struktogramm der Funktion FC 1001:
Zur Berechnung der Schaltpunkte wird die lokale
Variable P_HYS eingeführt.
364
10 Programmiersprache Strukturierter Text ST (SCL)
STEP 7 Programm (SCL-Quelle):
FUNCTION FC1001 : VOID
VAR_INPUT
MEW:REAL;
SP:REAL;
HYS:REAL;
END_VAR
VAR_IN_OUT
OUT:BOOL;
END_VAR
VAR_TEMP
P_HYS:REAL;
END_VAR
CoDeSys Programm (ST):
FUNCTION FC1001 :BOOL
VAR_INPUT
MEW: REAL;
SP: REAL;
HYS: REAL;
END_VAR
VAR_IN_OUT
OUT:BOOL;
END_VAR
VAR
P_HYS: REAL;
END_VAR
P_HYS:=MEW*HYS/100;
IF MEW<(SP-P_HYS/2) THEN
OUT:=TRUE;
ELSIF
MEW>(SP+P_HYS/2) THEN
OUT:=FALSE;
ELSE
OUT:=OUT;
END_IF;
END_FUNCTION
P_HYS:=MEW*HYS/100;
IF MEW<(SP-P_HYS/2) THEN
OUT:=TRUE;
ELSIF
MEW>(SP+P_HYS/2) THEN
OUT:=FALSE;
ELSE
OUT:=OUT;
END_IF
„ Beispiel 10.2: Ultraschall-Überwachungssystem
Ein Ultraschall-Überwachungssystem erkennt in einem dreidimensionalen Schutzfeld alle Personen und
Gegenstände, die sich dem Gefahrenbereich nähern. Meldet der Ultraschallsensor eine Annäherung, gibt
die Hupe P_HU ein akustisches Warnsignal. Dauert die Wahrnehmung der Person oder des Gegenstandes
länger als 3 Sekunden, wird das Warnsignal P_HU ausgeschaltet und ein Alarm P_AL eingeschaltet. Mit
dem Schalter E_A wird das Überwachungssystem eingeschaltet und der eingeschaltete Zustand mit P1
angezeigt. Zum Abschalten des Alarms muss das Überwachungssystem mit dem Schalter E_A ausgeschaltet werden.
Technologieschema:
Bild 10.2: Ultraschall-Überwachung
Zuordnungstabelle der Eingänge und Ausgänge:
Eingangsvariable
Überwachung EIN-AUS
Ultraschallsensor
Ausgangsvariable
Überwachung EIN-AUS
Hupe
Alarmleuchte
Symbol
E_A
SENSOR
Datentyp
BOOL
BOOL
P1
P_HU
P_AL
BOOL
BOOL
BOOL
Logische Zuordnung
Betätigt
E_A = 1
Meldung
SENSOR = 0
Leuchtet
Warnsignal
Leuchtet
P1 = 1
P_HU = 1
P_AL = 1
Adresse
E 0.0
E 0.1
A 4.0
A 4.1
A 4.2
10.4 Beispiele
365
Struktogramm der Funktion FC 1002:
Mit der IF-Anweisung E_A = 0 wird abgefragt, ob
die Überwachung ausgeschaltet ist.
Wenn JA, werden alle Ausgänge zurückgesetzt.
Wenn NEIN, folgen zwei IF-Anweisungen.
Am Programmende muss noch die Zeit von 3 s gestartet werden, damit bei anhaltender Meldung des
Ultraschallsensors der Alarm eingeschaltet wird.
Die Realisierung der Zeit erfolgt bei STEP 7 SCL mit der Funktion S_ODT (SE) als IN-Variable und bei
CoDeSys mit dem Funktionsblock TON als IN_OUT_Variable.
STEP 7 Programm:
CoDeSys Programm:
Aufruf der Funktion FC 1002 im OB 1
Aufruf der Funktion FC 1002 im PLC_PRG
FC1002 SCL-Quelle
FUNCTION FC1002 : VOID
VAR_INPUT
E_A, SENSOR: BOOL;
ZEIT: TIMER;
ZEITW:S5TIME;
END_VAR
VAR_IN_OUT
P_HU, P_AL: BOOL;
END_VAR
VAR_OUTPUT
P1: BOOL;
END_VAR
VAR_TEMP
BCD_Zeitwert: S5TIME;
END_VAR
FC1002 ST
FUNCTION FC1002 :BOOL
VAR_INPUT
E_A, SENSOR: BOOL;
ZEITW: TIME;
END_VAR
IF NOT E_A THEN P1:=FALSE;
P_HU:=FALSE;
P_AL:=FALSE;
ELSE P1:=TRUE;
IF P_AL THEN P_HU:=FALSE;
ELSIF SENSOR THEN P_HU:=FALSE;
ELSE P_HU:= TRUE;
END_IF;
END_IF;
BCD_Zeitwert:=S_ODT(T_NO:=ZEIT,
S:=P_HU OR P_AL, TV:=ZEITW,
Q:=P_AL);
END_FUNCTION
VAR_IN_OUT
ZEIT:TON;
P_HU, P_AL: BOOL;
END_VAR
IF NOT E_A THEN FC1002:=FALSE;
P_HU:=FALSE;
P_AL:=FALSE;
ELSE
FC1002:=TRUE;
IF P_AL THEN P_HU:=FALSE;
ELSIF SENSOR THEN P_HU:=FALSE;
ELSE P_HU:=TRUE;
END_IF
END_IF
ZEIT(IN:=P_HU OR P_AL, PT:=ZEITW);
P_AL:=Zeit.Q;
366
10 Programmiersprache Strukturierter Text ST (SCL)
„ Beispiel 10.3: Lineare Bereichsabbildung (FC 1003 BABB)
Ein Temperatursensor liefert an einen SPS-Digitaleingang Werte von 0
bis 255. Diese Werte entsprechen beispielsweise einer Temperatur von
–20 °C bis 40 °C. In der Steuerung soll mit Temperaturwerten gearbeitet werden. Dazu ist eine Funktion FC 1003 zu entwerfen, welche die in
Gleitpunktzahlen gewandelten Digitaleingangswerte von 0 bis 255 in
den Temperaturbereich von –20 °C bis 40 °C umrechnet. Damit die
Bereichsabbildung für beliebige Zahlenbereiche verwendet werden
kann, soll der ursprüngliche Bereich durch wählbare Untergrenze
(IN_MIN) und Obergrenze (IN_MAX) definiert und der Bereich der
Ausgabe ebenfalls durch Angabe von Untergrenze (OUT_MIN) und
Obergrenze (OUT_MAX) bestimmten werden.
Bild 10.3: Thermoelement
Ein Funktionsausgang FEH soll anzeigen, wenn versehentlich die Ober- und Untergrenze mit gleichen
Werten versehen wurden, der Eingangs- oder Ausgangsbereich also null ist.
Übergabeparameter:
Beschreibung der Parameter:
IN_R:
IN_MAX:
IN_MIN:
OUT_MAX:
OUT_MIN:
OUT_R:
FEH:
REAL
REAL
REAL
REAL
REAL
REAL
BOOL
Abzubildender REAL-Wert
Obergrenze des Eingangsbereichs
Untergrenze des Eingangsbereichs
Obergrenze des Ausgangsbereichs
Untergrenze des Ausgangsbereichs
Abgebildeter REAL-Wert
Anzeige Bereichsangabe falsch
Zum Test der Funktion FC 1003 werden an den Funktionseingang IN_R und an den Funktionsausgang
OUT_R je ein Merkerdoppelwort gelegt. An die Eingangs und Ausgangsgrenzen können beliebige Zahlenwerte angelegt werden. Der Funktionsausgang FEH wird dem SPS-Ausgang A 4.1 zugewiesen. Über
„Variable beobachten/steuern“ kann dann ein Eingangswert vorgegeben und das Ergebnis beobachtet
werden.
Zuordnungstabelle der Ausgänge und Merker:
Ausgangsvariable
Bereichsangabenüberprüfung
Merkervariable
Eingangs-REAL-Zahl
Ausgangs-REAL-Zahl
Symbol
FEH
Datentyp
BOOL
MD_1
MD_2
REAL
REAL
Logische Zuordnung
Bereich = 0
FEH = 1
Gleitpunktzahl
Gleitpunktzahl
Adresse
A 4.1
MD 10
MD 20
Lösung
Die Berechnungsformel für die lineare Abbildung leitet sich aus den Geradengleichungen der beiden
Bereiche her.
IN _ MAX IN _ MIN
OUT _ MAX OUT _ MIN
IN _ R IN _ MIN
OUT _ R OUT _ MIN
Daraus ergibt sich:
OUT _ R
OUT _ MAX OUT _ MIN
IN _ MAX IN _ MIN
IN _ R IN _ MIN OUT _ MIN
Im Steuerungsprogramm wird zunächst überprüft, ob die Differenzen von IN_MAX – IN_MIN bzw.
OUT_MAX – OUT_MIN verschieden von null sind. Wenn JA, wird der Ausgangswert nach der vorge-
10.4 Beispiele
367
gebenen Formel berechnet und der Ausgang FEH erhält 0-Signal. Wenn NEIN, wird die Berechnung
nicht durchgeführt, der Ausgang FEH erhält 1-Signal und der Ausgangswert OUT_R wird auf 0.0 gesetzt.
STEP 7 Programm (SCL-Quelle):
FUNCTION FC1003 : VOID
CoDeSys Programm (ST):
TYPE FC_OUT :
STRUCT
OUT_R:REAL;
FEH:BOOL;
END_STRUCT
END_TYPE
VAR_INPUT
IN_R:REAL;
IN_MAX, IN_MIN:REAL;
OUT_MAX, OUT_MIN:REAL;
END_VAR
VAR_OUTPUT
OUT_R:REAL;
FEH:BOOL;
END_VAR
VAR_TEMP
DIFF1, DIFF2:REAL;
END_VAR
DIFF1:= IN_MAX-IN_MIN;
DIFF2:= OUT_MAX-OUT_MIN;
FEH := (DIFF1=0) OR (DIFF2=0);
IF NOT FEH THEN
OUT_R:= (OUT_MAX-OUT_MIN)
/DIFF1*(IN_R-IN_MIN)
+OUT_MIN;
ELSE OUT_R:=0.0;
END_IF;
END_FUNCTION
FUNCTION FC1003 :FC_OUT
VAR_INPUT
IN_R: REAL;
IN_MAX, IN_MIN:REAL;
OUT_MAX, OUT_MIN: REAL;
END_VAR
VAR
DIFF1, DIFF2: REAL;
END_VAR
DIFF1:= IN_MAX-IN_MIN;
DIFF2:= OUT_MAX-OUT_MIN;
FC1003.FEH := (DIFF1=0) OR (DIFF2=0);
IF NOT FC1003.FEH THEN
FC1003.OUT_R:= (OUT_MAX-OUT_MIN)
/DIFF1*(IN_R-IN_MIN)
+OUT_MIN;
ELSE FC1003.OUT_R:=0.0;
END_IF
„ Beispiel 10.4: Bitwert setzen in einer DWORD-Variablen (FC1004_PUT)
In einer Meldevariablen soll beim Kommen oder Gehen einer Fehlermeldung ein zum Fehler gehörendes
Bit gesetzt bzw. zurückgesetzt werden. Dies soll mit einer Funktion FC 1004 erfolgen, deren Eingangsparameter N_BIT und B_W mit der Nummer des zu verändernden Bits und einem booleschen Wert zu
versorgen sind. Am Durchgangsparameter X_DW der Funktion wird die Meldevariable angegeben.
Übergabeparameter:
Beschreibung der Parameter:
N_BIT: INT
Nummer (0 ... 31) des zu verändernden Bits
B_W: BOOL
Wert TRUE oder FALSE
X_DW: DWORD
Meldevariable, bei der ein Bit geändert werden soll
Hinweis: Der boolesche Rückgabewert der Funktion zeigt mit TRUE an,
ob die Angabe der Bit-Nummer an N_Bit innerhalb des Bereichs von
0 ... 31 liegt.
Zuordnungstabelle der Eingänge, Ausgänge und Merker:
Eingangsvariable
Vorgabe Bitnummer
Vorgabe boolescher Wert
Ausgangsvariable
Anzeige gültige Bitnummer
Merkervariable
Meldevariable
Symbol
EW
S
P1
MD_1
Datentyp Logische Zuordnung
INT
Integer Zahl
BOOL Betätigt
S=1
BOOL
Bitnummer gültig
DWORD Bit-Muster
P1 = 1
Adresse
EW 8
E 0.0
A 4.0
MD 10
368
10 Programmiersprache Strukturierter Text ST (SCL)
Lösung
Das Setzen eines bestimmten Bits der Meldevariablen erfolgt durch eine ODER-Verknüpfung der Meldevariablen mit einer Konstanten, bei der genau an der Stelle, an der das Bit der Meldevariablen auf
TRUE gesetzt werde soll, eine „1“ steht. Die Konstante wird durch Linksschieben von DWORD#16#1
um so viele Stellen, wie die Bit_Nr angibt, erzeugt.
Das Rücksetzen eines bestimmten Bits der Meldevariablen erfolgt durch eine UND-Verknüpfung
der Meldevariablen mit einer Konstanten, bei der genau an der Stelle, an der das Bit der Meldevariable
auf FALSE gesetzt werden soll, eine „0“ steht. Die Konstante wird durch Rotieren von
DWORD#16#FFFFFFFE um so viele Stellen, wie die Bit_Nr angibt, erzeugt.
STEP 7 Programm (SCL-Quelle):
FUNCTION FC1004 : BOOL
CoDeSys Programm (ST):
FUNCTION FC1004 :BOOL
VAR_INPUT
N_BIT:INT;
B_W:BOOL;
END_VAR
VAR_IN_OUT
X_DW:DWORD;
END_VAR
VAR_INPUT
N_BIT:INT;
B_W:BOOL;
END_VAR
VAR_IN_OUT
X_DW:DWORD;
END_VAR
IF N_BIT < 32 THEN
IF N_BIT < 32 THEN
FC1004:=TRUE;
FC1004:=TRUE;
IF B_W THEN
IF B_W THEN
X_DW:= X_DW OR
X_DW:= X_DW OR
SHL(IN:=DWORD#1,N:=N_BIT);
SHL(DWORD#1,N_BIT);
ELSE
ELSE
X_DW:= X_DW AND
X_DW:= X_DW AND
ROL(IN:=DWORD#
ROL(DWORD#16#FFFFFFFE,
16#FFFFFFFE,N:=N_BIT);
N_BIT);
END_IF;
END_IF;
ELSE
ELSE
FC1004:=FALSE;
FC1004:=TRUE;
END_IF;
END_IF;
„ Beispiel 10.5: Qualitätsprüfung von Keramikplatten (FC1005_QP)
Bei der Herstellung von keramischen Isolationsplatten muss nach dem Brennen überprüft werden, ob die
Dicke der Platte innerhalb eins vorgegebenen Toleranzbandes liegt. Dazu werden die Platten durch eine
aus zwei Laser bestehende Messstelle mit gleichmäßiger Geschwindigkeit geschoben. Aus der Differenz
der Messungen der beiden Laser wird die Dicke der Platten ermittelt. Bei jeder Messung wird der kleinste
und der größte Wert der Plattendicke festgehalten. Liegen diese außerhalb des Toleranzbandes, gilt die
Platte als Ausschuss.
Technologieschema:
Bild 10.4: Prüfeinrichtung
10.4 Beispiele
369
Es ist ein Funktionsbaustein FB 1005 zu entwerfen, der die Plattendicke überprüft, welche sich aus der
Differenz der beiden Laser-Messungen ergibt. Während und nach der Messung soll der Funktionsbaustein den größten (M_MAX) bzw. kleinsten Wert (M_MIN) der Plattendicke ausgeben. Liegen die beiden
Werte außerhalb des mit V_MAX und V_MIN vorgegebnen Bereichs, wird die Ausschussleuchte P1
eingeschaltet. Gestartet und beendet wird die Messung mit dem Sensor S1, der ein 1-Signal liefert, solange sich die Keramikplatte in der Messeinrichtung befindet. Zu Beginn einer neuen Messung werden die
Ausgabewerte des Funktionsbausteins mit den Werten des neuen Messzyklus überschrieben.
Übergabeparameter:
Beschreibung der Parameter:
START:
DICKE:
V_MAX:
V_MIN:
D_MAX:
D_MIN:
P1: BOOL
BOOL Starten der Prüfung mit Sensor S1
REAL Laufende Messwerte der Dicke
REAL Vorgabe der Obergrenze
REAL Vorgabe der Untergrenze
REAL Ausgabe der maximalen Dicke
REAL Ausgabe der minimalen Dicke
Anzeige Ausschuss
Zum Test des Funktionsbausteins FB 1005 wird an den Eingang START der Sensor S1 gelegt. Dem
Funktionseingang DICKE wird ein Merkerdoppelwort MD_1 zugewiesen. An V-MAX und V_MIN
können beliebige REAL-Zahlen geschrieben werden. An die Ausgangswerte D_MAX und D_MIN werden Merkerdoppelwörter geschrieben und der Ausgang FEH dem SPS-Ausgang A 4.1 zugewiesen. Über
„Variable beobachten/steuern“ kann dann ein Messwert vorgegeben und das Ergebnis beobachtet werden
Zuordnungstabelle der Eingänge, Ausgänge und Merker:
Eingangsvariable
Sensor Platte in der Messeinrichtung
Ausgangsvariable
Anzeige Ausschuss
Merkervariable
Messwert der Dicke
Ausgabe der maximalen Dicke
Ausgabe der minimalen Dicke
Symbol
S1
Datentyp Logische Zuordnung
BOOL Platte vorhanden
S1 = 1
Adresse
E 0.1
P1
BOOL
Platte ist Ausschuss P1 = 1
A 4.1
MD_1
MD_2
MD_3
REAL
REAL
REAL
Gleitpunktzahl
Gleitpunktzahl
Gleitpunktzahl
MD 10
MD 20
MD 30
Darstellung des Algorithmus im Struktogramm:
Hinweis: Bei STEP 7 wird die Flankenauswertung im Programm durch die Einführung einer statischen
Lokalvariablen als Flankenoperand FO programmiert (siehe Kapitel 4.6). Bei CoDeSys könnte für die
Flankenauswertung der Funktionsblock R_TRIG mit der lokalen Variablen FO als Instanz benutzt werden. Wird jedoch die Programmierung einer Flankenauswertung wie bei STEP 7 verwendet, sind die beiden Programme ST und SCL bis auf die Anweisung „END_FUNCTION_BLOCK“ bei STEP 7 identisch.
370
10 Programmiersprache Strukturierter Text ST (SCL)
STEP 7 Programm (SCL-Quelle) / CoDeSys Programm (ST):
FUNCTION_BLOCK FB1005
VAR_INPUT
START:BOOL; DICKE, V_MAX, V_MIN:REAL;
END_VAR
VAR_OUTPUT
D_MAX, D_MIN:REAL; P1:BOOL;
END_VAR
VAR
FO:BOOL;
END_VAR
IF NOT START THEN FO:=START; RETURN;
END_IF;
IF START=TRUE AND FO=FALSE THEN D_MAX:=DICKE; D_MIN:=DICKE; P1:=FALSE;
END_IF;
FO:=START;
IF DICKE < D_MIN THEN D_MIN:=DICKE; END_IF;
IF DICKE > D_MAX THEN D_MAX:=DICKE; END_IF;
IF D_MIN < V_MIN OR D_MAX > V_MAX THEN P1:=TRUE; END_IF;
END_FUNCTION_BLOCK
„ Beispiel 10.6: Funktionsgenerator (FB 1006_FGEN)
Für die Programmbibliothek ist ein Funktionsbaustein FB 1006 zu bestimmen, der die Aufgaben eines
Funktionsgenerators erfüllt. An den Eingängen des Funktionsbausteins können die gewünschte Kurvenform, die Amplitude und die Periodendauer vorgegeben werden.
Folgende Kurvenformen können ausgewählt werden:
0. Rechteck_Pos.
1. Rechteck
2. Dreieck_Pos.
3. Dreieck
4. Sägezahn_Pos.
5. Sägezahn
6. N_Sägezahn_P
7. N_Sägezahn
8. Sinus
9. Cosinus
Funktionsbaustein FB 1006:
Übergabeparameter:
Beschreibung der Parameter:
KFORM:
INT
PERIODE:
TIME Periodendauer
AMPLITUDE: INT
Nummer (0 ... 9) der Kurvenform
Amplitude A der Kurven
RESET
BOOL Rücksetzen und Ausschalten des Fkt.-Generators
OUT
INT
Ausgabe der Kurve
10.4 Beispiele
371
Zuordnungstabelle der Eingänge und Ausgänge:
Eingangsvariable
Auswahl Kurvenform
Amplitude
Rücksetz-Taster
Ausgangsvariable
Kurvenwerte
Symbol
EW_1
EW_2
RESET
Datentyp
INT
INT
BOOL
AW
INT
Logische Zuordnung
Integer Zahl (0..9)
Integer Zahl
Betätigt
RESET = 1
Adresse
EW 8
EW 10
E 0.0
Integer-Werte
AW10
Die Periodendauer wird mit einer Zeitkonstante (z. B. T#50s) am Funktionsbausteineingang vorgegeben.
Je nach gewählter Kurvenform müssen folgende Berechnungen durchgeführt werden:
0. Rechteck_P:
t < T/2
t > T/2
OUT:= 0
1. Rechteck:
t < T/2
OUT:= AMPLITUDE
t > T/2
OUT:= – AMPLITUDE
2. Dreieck_Pos:
3. Dreieck:
OUT:= AMPLITUDE
t < T/2
OUT:= AMPLITUDE * t / (T/2)
t > T/2
OUT:= – AMPLITUDE * (t – T/2) / (T/2) + AMPLITUDE
t < T/2
OUT:= 2 * AMPLITUDE * t / (T/2) – AMPLITUDE
t > T/2
OUT:= – 2 * AMPLITUDE * (t – T/2) / (T/2) + AMPLITUDE
4. Sägezahn_Pos:
OUT:= AMPLITUDE * t / T
5. Sägezahn:
OUT:= 2 * AMPLITUDE * t / T – AMPLITUDE
6. N_Sägezahn_P:
OUT:= – AMPLITUDE * t / T + AMPLITUDE
7. N_Sägezahn:
OUT:= – 2 * AMPLITUDE * t / T + AMPLITUDE
8. Sinus:
OUT:= AMPLITUDE * SIN(6,283176 * t/T)
7. Cosinus:
OUT:= AMPLITUDE * COS(6,283176 * t/T)
Das STEP 7 SCL Programm und das CoDeSys ST Programm unterscheiden sich nur durch die bei
STEP 7 erforderliche Anweisung „END_FUNCTION_BLOCK“ und einen Doppelpunkt, der bei STEP 7
bei der CASE-Anweisung hinter ELSE stehen muss und bei CoDeSys nicht.
STEP 7 Programm (SCL-Quelle) / CoDeSys Programm (ST):
VAR_INPUT KFORM:INT; PERIODE:TIME; AMPLITUDE:INT; RESET:BOOL; END_VAR
VAR_OUTPUT OUT:INT; END_VAR
VAR
ZAE:INT; ZEIT:TON; X_T,P_T:DINT; END_VAR
IF RESET THEN ZEIT(IN:=FALSE, PT:=t#0s); OUT:=0;
ELSE ZEIT(IN:=TRUE,PT:=PERIODE);
IF ZEIT.Q= TRUE THEN ZEIT(IN:=FALSE); ZEIT(IN:=TRUE); END_IF;
X_T:=TIME_TO_DINT(ZEIT.ET);
P_T:=TIME_TO_DINT(PERIODE);
CASE KFORM OF
0: IF X_T < P_T/2 THEN OUT:=AMPLITUDE; ELSE OUT:=0; END_IF;
1: IF X_T < P_T/2 THEN OUT:=-AMPLITUDE; ELSE OUT:=AMPLITUDE; END_IF;
2: IF X_T < P_T/2 THEN
OUT:=DINT_TO_INT(AMPLITUDE*X_T/(P_T/2));
ELSE
OUT:=DINT_TO_INT(-AMPLITUDE*(X_T-P_T/2)/(P_T/2)+ AMPLITUDE);
END_IF;
372
10 Programmiersprache Strukturierter Text ST (SCL)
3: IF X_T < P_T/2 THEN
OUT:=DINT_TO_INT(2*AMPLITUDE*X_T/(P_T/2) - AMPLITUDE);
ELSE
OUT:=DINT_TO_INT(-2*AMPLITUDE*(X_T-P_T/2)/(P_T/2) + AMPLITUDE);
END_IF;
4:
OUT:=DINT_TO_INT(AMPLITUDE*X_T/(P_T));
5:
OUT:=DINT_TO_INT(2*AMPLITUDE*X_T/(P_T)- AMPLITUDE);
6:
OUT:=DINT_TO_INT(-AMPLITUDE*X_T/(P_T) + AMPLITUDE);
7:
OUT:=DINT_TO_INT(-2*AMPLITUDE*X_T/(P_T)+ AMPLITUDE);
8:
OUT:=REAL_TO_INT(SIN(6.283176*X_T/P_T)*AMPLITUDE);
9:
OUT:=REAL_TO_INT(COS(6.283176*X_T/P_T)*AMPLITUDE);
ELSE: ZEIT(IN:=FALSE, PT:=t#0s); OUT:=0; END_CASE;
END_IF;
END_FUNCTION_BLOCK
„ Beispiel 10.7: Bestimmung von Minimum, Maximum und arithmetischer Mittelwert in einem
eindimensionalen Datenfeld (FC1007_F_MINMAX)
In einem eindimensionalen Datenfeld mit 100 Werten soll der größte, der kleinste und der arithmetischen
Mittelwert bestimmt werden. Die Werte liegen im Datenformat REAL vor. Der Bereich des Datenfeldes
für die Bestimmung des Maximums MAXW, Minimums MINW und arithmetischen Mittelwertes AMW
wird durch die Angabe der ersten Feld-Nummer F_NR und die Anzahl der Werte ANZ vorgegeben. Bei
einer fehlerhaften Vorgabe des Datenbereichs (z. B. F_Nr:= 50 und ANZ 60) hat der Ausgang FEH
1-Signal und den Ausgabewerten MAXW, MINW und AMW wird 0.0 zugewiesen.
Übergabeparameter:
Beschreibung der Parameter:
FELD
F_NR
ANZ
MINW
MAXW
AMW
FEH
ARRAY
INT
INT
REAL
REAL
REAL
BOOL
Datenfeld mit 100 REAL-Werten
Nummer des ersten Feldwertes für den Bereich
Anzahl der Feldwerte
Kleinster Wert im Datenfeld
Größter Wert im Datenfeld
Arithmetischer Mittelwert des Datenfeldes
Anzeige fehlerhafte Bereichsauswahl
Zum Test der Funktion FC 1007 wird ein Datenfeld mit 100 unterschiedlichen Gleitpunktzahlen angelegt.
Bei STEP 7 kann dies innerhalb eines Datenbausteins DB erfolgen. Die Feldanfangsnummer F_NR und
die Anzahl ANZ des zu untersuchenden Bereichs werden mit den Eingangsworten EW8 und EW10 vorgegeben. Mit der Taste S1 wird die Bearbeitung der Funktion FC 1007 über den EN-Eingang gesteuert.
Die Ergebnisse der Bearbeitung MINW, MAXW und AMW werden den Merkerdoppelwörtern MD10,
MD20 und MD30 zugewiesen. Die Funktionsweise des Bausteins FC 1007 kann mit „Variable beobachten/steuern“ überprüft werden.
Zuordnungstabelle der Eingänge, Ausgänge und Merker:
Eingangsvariable
Berechnung EIN
Vorgabe Feldanfangsnummer
Vorgabe Anzahl der Feldwerte
Ausgangsvariable
Fehlerhafte Bereichsvorgabe
Merkervariable
Kleinster Wert
Größter Wert
Arithmetischer Mittelwert
Symbol
S1
F_NR
ANZ
Datentyp
BOOL
INT
INT
Logische Zuordnung
Betätigt
S1 = 1
Integer Zahl
Integer Zahl
FEH
BOOL
Falsche Vorgabe
MINW
MAXW
AMW
REAL
REAL
REAL
Gleitpunktzahl
Gleitpunktzahl
Gleitpunktzahl
FEH = 1
Adresse
E 0.0
EW 8
EW 10
A 4.0
MD 10
MD 20
MD 30
10.4 Beispiele
373
Der Algorithmus für die Ermittlung des kleinsten und des größten Feldwertes basiert auf dem Vergleich
jedes Wertes mit dem aktuellen Minimalwert MINW bzw. dem aktuellen Maximalwert MAXW. Falls der
Vergleich erfüllt ist wird der jeweilige Feldwert dem aktuellen Minimalwert bzw. Maximalwert zugewiesen. Für die Berechnung des arithmetischen Mittelwertes wird jeder Feldwert zu der Variablen AMW
addiert.
Nachdem alle Werte addiert sind, wird die Summe durch die Anzahl der Werte dividiert. (Siehe auch
Beispiel 9.3 „Bestimmung von Minimum, Maximum und arithmetischer Mittelwert in einem Datenbaustein“.) Zu Beginn wird abgefragt, ob die Bereichswahl gültig ist.
Darstellung des Algorithmus im Struktogramm:
Lokale Variablen:
NR:
INT
ZAE: INT
Adressierung der
Feldvariablen
Zählvariable für die
Schleife
SUM: REAL Hilfsvariable zur
Berechnung des
arithmetischen Mittelwertes
Hinweis: Bei STEP 7 wird das zu untersuchende Feld in einem Datenbaustein DB 10 angelegt. Bei
CoDeSyS wird im PLC_PRG eine Feldvariable FELD deklariert und mit entsprechenden Startwerten versehen.
STEP 7 Programm:
CoDeSys Programm:
Aufruf der Funktion FC 1007 im OB 1
Aufruf der Funktion FC 1007 im PLC_PRG in CFC
374
10 Programmiersprache Strukturierter Text ST (SCL)
FC 1007 SCL-Quelle
FUNCTION FC1007: VOID
VAR_INPUT
FELD: ARRAY[0..99] OF REAL;
MNR, ANZ:INT;
END_VAR
VAR_OUTPUT
MINW, MAXW, AMW:REAL; FEH:BOOL;
END_VAR
VAR_TEMP
NR, ZAE:INT; SUM:REAL;
END_VAR
IF F_NR<=0 OR F_NR > 99 OR ANZ<=0
OR ANZ > 100 - F_NR THEN
FEH:=TRUE; MINW:=0.0;
MAXW:=0.0; AMW:=0.0;
Else
FEH:=False; NR:=F_NR+ANZ-1);
MINW:=FELD[NR]; MAXW:=FELD[NR];
SUM:=FELD[NR]; ZAE:=ANZ
WHILE ZAE>1 DO
ZAE:=ZAE-1; NR:=NR-4;
IF MAXW < FELD[NR]; THEN
MAXW:= FELD[NR];
END_IF;
IF MINW > FELD[NR] THEN
MINW:= FELD[NR];
END_IF;
SUM:=SUM + FELD[NR]
END_WHILE;
AMW:=SUM/INT_TO_REAL(ANZ);
END_IF;
END_FUNCTION
FC 1007 ST
TYPE FC_OUT :
STRUCT MINW:REAL; MAXW:REAL;
AMW:REAL; FEH:BOOL; END_STRUCT
END_TYPE
FUNCTION FC1007 :FC_OUT
VAR_INPUT
FELD: ARRAY [0..99] OF REAL;
F_NR: INT; ANZ: INT;
END_VAR
VAR ZAE: INT; NR: INT; SUM: REAL;
END_VAR
IF F_NR<0 OR F_NR > 99 OR ANZ<=0
OR ANZ > 100 – F_NR THEN
FC1007.FEH:=TRUE;
FC1007.MINW:=0.0;
FC1007.MAXW:=0.0;
FC1007.AMW:=0.0;
ELSE
FC1007.FEH:=FALSE;
NR:=(F_NR+ANZ-1);
FC1007.MINW:= FELD[NR];
FC1007.MAXW:=FELD[NR];
SUM:=FELD[NR]; ZAE:=ANZ;
WHILE ZAE>1 DO
ZAE:=ZAE-1; NR:=NR - 1;
IF FC1007.MAXW < FELD[NR] THEN
FC1007.MAXW:=FELD[NR]; END_IF;
IF FC1007.MINW > FELD[NR] THEN
FC1007.MINW:=FELD[NR]; END_IF;
SUM:=SUM+FELD[NR];
END_WHILE;
FC1007.AMW:=SUM/INT_TO_REAL(ANZ);
END_IF;
„ Beispiel 10.8: Betriebsstunden erfassen und auswerten
Bei einem Altglasrecyclingprozess wird der Schmelzofen durch mehrere Brenner beheizt, die je nach
Bedarf zu- und abgeschaltet werden. Zur vorbeugenden Instandhaltung und Wartung wird die Betriebszeit jedes Brenners ermittelt und ausgewertet. Nach jedem Einschalten wird die Laufzeit gemessen und
für jedes Einschaltintervall der Wert in einem zugehörigen Datenfeld hinterlegt. Ist eine vorgegebene
Betriebsstundendauer oder eine vorgegebenen Anzahl von Betriebsintervallen überschritten, muss der
Brenner gereinigt werden. Nach der Wartung des Brenners beginnt ein neues Wartungsintervall und alle
Aufzeichnungen über die Laufzeiten aus dem vorherigen Wartungsintervall werden im Datenfeld gelöscht.
Technologieschema:
Bild 10.5: Schmelzofen
10.4 Beispiele
375
Für die Überwachung der Betriebszeit ist ein Funktionsbaustein FB 1008 zu entwerfen, der zusammen
mit einem Datenfeld die Aufgabe der Betriebsstundenzählung und Auswertung für einen Brenner übernimmt. Nach jedem Betriebszyklus des Brenners wird die gemessene Betriebszeit, die Gesamtbetriebszeit
und die Anzahl der Betriebsintervallen in das zum Brenner gehörende Datenfeld hinterlegt. Bei STEP 7
befindet sich das Datenfeld in einem Datenbaustein DB. Bei CoDeSys wird das Datenfeld in einer Variablen realisiert. Über den Eingang TAKT erhält der Betriebsstundenzähler des Funktionsblocks Zählimpulse von einem Taktgenerator Die maximale Betriebsdauer und Anzahl der Betriebszyklen werden an
den Funktionsbaustein-Eingängen T_AMX und E_ZYK vorgegeben. Das Ende einer Wartung des Brenners wird dem Funktionsblock über den Eingang QUIT mitgeteilt.
Übergabeparameter bei STEP 7:
Beschreibung der Parameter:
BR_EIN
TAKT
DBNR
T_MAX
EZ_MAX
QUIT
T_AK
T_GE
P_WA
BOOL
BOOL
INT
DINT
INT
BOOL
DINT
DINT
BOOL
Brenner ist eingeschaltet
Zählimpulse für den Betriebsstundenzähler
Datenbausteinnummer für das Datenfeld
Maximale Betriebszeit
Maximale Anzahl der Betriebszyklen
Wartung durchgeführt
Ausgabe der aktuellen Betriebszeit
Ausgabe der gesamten Betriebszeit
Anzeige Wartung erforderlich
BR_EIN
TAKT
T_MAX
EZ_MAX
QUIT
DATEN
T_AK
T_GE
P_WA
BOOL
BOOL
DINT
INT
BOOL
FELD
DINT
DINT
BOOL
Brenner ist eingeschaltet
Zählimpulse für den Betriebsstundenzähler
Maximale Betriebszeit
Maximale Anzahl der Betriebszyklen
Wartung durchgeführt
Datenfeld zur Speicherung der Betriebszeiten
Ausgabe der aktuellen Betriebszeit
Ausgabe der gesamten Betriebszeit
Anzeige Wartung erforderlich
Übergabeparameter bei CoDeSys:
Zum Test des Funktionbausteins FB 1008 wird der Betrieb des Brenners durch einen Schalter S1 (S1 = 1,
Brenner EIN) simuliert. Die Taktfrequenz wird mit dem Bibliotheksbaustein FC 100/FB 100 (TAKT)
gebildet. Die Periodendauer des Takts, welche die Zeitbasis für die Betriebsstundenzählung vorgibt, wird
für den Test des Bausteins auf 100 ms eingestellt. An dem Eingang „Z_MAX“ wird die maximale Betriebszeit im Datenformat DINT vorgegeben. Wird dort der Wert 5000 angelegt, bedeutet dies, dass bei
einer Taktzeit von 0,1 s nach etwa 8,3 Minuten die maximale Betriebszeit erreicht ist. Für Testzwecke ist
dies ein akzeptabler Wert. Die maximale Anzahl der Einschaltzyklen wird mit 20 vorgegeben. Die Ausgänge T_AK (aktuelle die Betriebszeit) und T_GE (Betriebszeit seit der letzten Wartung) im Datenformat
DINT werden Merkerdoppelwörtern zugewiesen. Mit dem Taster S2 wird das Ende einer Wartung gemeldet und somit alle Aufzeichnungen gelöscht.
Zuordnungstabelle der Eingänge, Ausgänge und Merker:
Eingangsvariable
Brenner EIN
Wartung beendet
Ausgangsvariable
Wartungsanzeige
Merkervariable
Aktuelle Betriebszeit
Gesamte Betriebszeit
Symbol
S1
S2
Datentyp Logische Zuordnung
BOOL Betätigt
S1 = 1
BOOL l Betätigt
S2 = 1
P_WA
BOOL
Wartung nötig
MD_1
MD_2
DINT
DINT
Dualzahl
Dualzahl
P_WA = 1
Adresse
E 0.1
E 0.2
A 4.0
MD 10
MD 20
376
10 Programmiersprache Strukturierter Text ST (SCL)
Lösung in STEP 7
Der Datenbaustein DB 10, mit dem Inhalt: Anzahl der Einschatzyklen, Gesamtbetriebszeit und Betriebszeiten für die einzelnen Einschaltzyklen wird wie folgt angelegt:
Struktogramm für den Funktionsbaustein FB 1008:
Lokale Variablen:
Statische:
E_ZAE, ZAE :INT
FO1,FO2,FO3,FO5: BOOL
(Hilfsvariablen für die Flankenauswertungen)
Temporäre:
DBNR: WORD
(Hilfsvariable zur indirekten
Adressierung des Datenbausteins)
Hinweis: Für die indirekte Adressierung des Datenbausteins DB[DBNR], wie im Struktogramm angegeben, muss in SCL die Anweisung WORD_TO_BLOCK_DB(DBNR) verwendet werden.
FC 1008 SCL-Quelle
VAR_INPUT
BR_EIN, TAKT:BOOL; DB_NR :INT; T_MAX :DINT; EZ_MAX:INT; QUIT :BOOL;
END_VAR
VAR_OUTPUT T_AK, T_GE:DINT; P_WA:BOOL; END_VAR
VAR E_ZAE, ZAE:INT; FO1,FO2,FO3,FO4:BOOL; END_VAR
VAR_TEMP DBNR:WORD; END_VAR
// Anweisungsteil
DBNR:=INT_TO_WORD(DB_NR);
IF BR_EIN = 1 AND FO1 = 0 THEN
E_ZAE:=WORD_TO_INT(WORD_TO_BLOCK_DB(DBNR).DW0); E_ZAE:=E_ZAE + 1;
10.4 Beispiele
377
T_AK:=0;
END_IF; FO1:=BR_EIN;
IF BR_EIN = 1 THEN
IF TAKT = 1 AND FO2=0 THEN T_AK:=T_AK + 1; END_IF;
FO2:=TAKT; T_GE:= DWORD_TO_DINT(WORD_TO_BLOCK_DB(DBNR).DD2)+ T_AK;
END_IF;
IF T_GE > T_MAX OR E_ZAE >= EZ_MAX THEN P_WA:=1;END_IF;
IF BR_EIN = 0 AND FO3 = 1 THEN
WORD_TO_BLOCK_DB(DBNR).DW0:=INT_TO_WORD(E_ZAE);
WORD_TO_BLOCK_DB(DBNR).DD[(E_ZAE+1)*4-2]:= DINT_TO_DWORD(T_AK);
WORD_TO_BLOCK_DB(DBNR).DD2:= DINT_TO_DWORD(T_GE);
END_IF; FO3:=BR_EIN;
IF QUIT = 1 AND FO4=0 THEN P_WA:=0; T_GE:=0; T_AK:=0;
FOR ZAE:= 0 TO (E_ZAE+1)*4+2 DO
WORD_TO_BLOCK_DB(DBNR).DB[ZAE]:=0;
END_FOR;
END_IF; FO4:=QUIT;
END_FUNCTION_BLOCK
Lösung in CoDeSys
Der Unterschied zur Lösung in STEP 7 besteht in der Adressierung des Datenfeldes. Statt des Datenbausteins DB wird zunächst eine Datentyp FELD mit den erforderlichen Variablen angelegt.
TYPE FELD : STRUCT
E_ZAE:INT; G_ZEIT:DINT; A_ZEIT:ARRAY[1..100] OF DINT; END_STRUCT
END_TYPE
Im PLC_PRG wird als Datenfeld dann die Variable DATEN mit dem Datentyp FELD deklariert.
Aufruf des Funktionsbausteins FB 1008 im PLC-PRG (CFC):
ST-Programm FB 1008:
FUNCTION_BLOCK FB1008
VAR_INPUT BR_EIN, TAKT: BOOL; T_MAX, E_ZYKL: INT; QUIT: BOOL; END_VAR
VAR_OUTPUT T_AK, T_GE: DINT; P_WA: BOOL; END_VAR
VAR_IN_OUT Daten: FELD; END_VAR
VAR E_ZAE, ZAE:INT; FO1, FO2, FO3, FO4:BOOL; END_VAR
IF BR_EIN AND FO1 = 0 THEN
E_ZAE:= DATEN.E_ZAE; E_ZAE:= E_ZAE+1; T_AK:=0; END_IF; FO1:=BR_EIN;
IF BR_EIN = 1 THEN
IF TAKT = 1 AND FO2=0 THEN T_AK:=T_AK + 1; END_IF;
FO2:=TAKT; T_GE:= Daten.G_ZEIT+ T_AK; END_IF;
IF E_ZAE >= E_ZYKL OR T_GE > T_MAX THEN P_WA:=1; END_IF;
IF BR_EIN = 0 AND FO3 = 1 THEN Daten.E_ZAE:=E_ZAE;
Daten.A_ZEIT[E_ZAE]:=T_AK; Daten.G_ZEIT:=T_GE; END_IF; FO3:=BR_EIN;
IF QUIT = 1 AND FO4=0 THEN P_WA:=0; T_GE:=0; T_AK:=0; Daten.E_ZAE:=0;
Daten.G_ZEIT:=0;
FOR ZAE:= 1 TO (E_ZAE) DO Daten.A_ZEIT[ZAE]:=0; END_FOR;
END_IF; FO4:=QUIT;