11.1 Komplexe Bausteine

11.1.1 Formelbausteine

Bei den Formelbausteinen wird zwischen analogen und digitalen Bausteinen unterschieden. Diese Bausteine verknüpfen die Werte ihrer Eingänge nach einer parametrierbaren Berechnungsvorschrift (Formel) und geben das Ergebnis am Bausteinausgang aus. Jede Berechnungsvorschrift wird von links nach rechts abgearbeitet. Formeln können Klammern mit beliebiger Schachtelungstiefe enthalten.

Analoge Formeln:

Erlaubte Operatoren in analogen Formeln sind: + - * / sin cos tan cot sqr sqrt abs pw(+ Winkel) mw(- Winkel)

Erlaubte Werte in analogen Formeln sind die Namen der Eingänge(x1, x2..) und konstante Festpunktwerte (z.B. 0.32 ..0.77). Wenn mit Konstanten multipliziert wird, dann darf der Wert dieser Konstanten auch größer als 1 sein (z.B. x1*3.7). Konstanten >1 dürfen nicht am Anfang einer Multiplikation stehen, da der Festpunktakku dann mit einem Wert >1.0 geladen werden müsste: also nicht (2.5*x1) sondern (x1*2.5).

Beispiel einer analogen Formel: y=x1+x2-0.11+(sin(x3 pw 0.5)*3.1415926)

Bei der Benutzung von Formeln muss beachtet werden, daß die verwendete Festpunktarithmetik einen Wertebereich von +/-1 hat. Auch Zwischenergebnisse werden auf +/-1 begrenzt. Bei der Winkel-addition(pw) bzw. -subtraktion(mw) gibt es keine Begrenzung, stattdessen werden die als Winkel interpretierten Argumente (+/-1 entspricht +/-pi) „mit Übertrag” addiert (z.B. 0.9+0.6 = -0.5).

Digitale Formeln:

Erlaubte Operatoren in digitalen Formeln sind: AND & OR | NOT /

Erlaubte Werte in digitalen Formeln sind nur die Namen der Eingänge(i1, i2..)

Beispiel einer digitalen Formel: o=(i1 or i2) and not(i1 & /i3)

11.1.2 Strukturierter Text

Mit „Strukturiertem-Text” können die Funktionen von SPS-Bausteinen in einer Programmiersprache mit Pascal ähnlichen Syntax programmiert werden.

Erlaubte VariablenNamen für Ein- und Ausgangs-variable sind dabei die parametrierbaren Namen der Ein- und Ausgänge des Bausteins. Außerdem können Lokale- und Temporäre-Variable deklariert werden. Lesender Zugriff ist für alle Variable erlaubt. Schreibender Zugriff auf Eingangs-variable ist verboten (nicht möglich).

Neben den Datentypen FRACT(Festpunkt) und BOOL(Logisch/Digital) wird beim Strukturierten-Text auch der Datentyp INTEGER(ganzeZahl) unterstützt. INTEGER Variable werden z.B. benötigt wenn indizierten auf Register zugegriffen werden soll, oder wenn Schleifen mit Lauf-variablen programmiert werden sollen.

Lokale Variable (VAR_LOCAL) haben Initial (nach Programmstart) den Wert „0”. Wenn das nicht passt, dann können lokale Variable im Deklarationsteil auch initialisiert werden (...var1: FRACT := 0.32; ). Lokale Variable behalten ihren Wert bis zum nächsten Zyklus/Programm-Aufruf. Sie haben ein „Gedächtnis”.

Temporäre Variable (VAR_TEMP) haben kein „Gedächtnis”. Ihr Wert ist bei jedem Programm-Aufruf undefiniert, weil sich alle St-Text Bausteine den selben Satz von temporären Variablen teilen.

Am Anfang des Deklarationsteils können Konstanten vereinbart werden. Enthält der Zahlenwert einer Konstante einen Punkt, dann wird dieser Konstanten der Datentyp FRACT(Festpunkt) zugeordnet. Enthält eine Zahl keinen Punkt, dann wird der zugehörigen Konstante der Datentyp INTEGER zugeordnet.

Als Programmieranweisung gibt es die „Zuweisung (var := Ausdruck)” , die ”IF THEN ELSE” Fallunterscheidung, die „WHILE” Schleife, die „REPEAT” Schleife und die „FOR” Schleife.

Bei der Auswertung von Ausdrücken wird die Regel „Punktrechnung geht vor Strichrechnung” beachtet. Außerdem können Ausdrücke durch Klammern beliebig geschachtelt werden.

Beispiel1: 4+2*3=10

Beispiel2:(4+2)*3=18

Kommentare können folgendermaßen geschrieben werden:

  1. (* Kommentar *)
  2. /* Kommentar */
  3. // Kommentar bis Zeilenende

Ein vollständiges „ST-Text” Programm kann z.B. so aussehen:

 
 
PROGRAM ProgrammName; (* ProgrammName = BausteinName *) 
CONST 
    c1=21; Cons2=-0.73; 
VAR_TEMP // Variable ohne Gedächtnis 
    i, k :INTEGER; 
VAR_LOCAL // Variable mit Gedächtnis 
    var1 : INTEGER; 
    var2 : FRACT := 0.99; //..initialisierte Variable 
BEGIN_PROGRAM 
    da1 := NOT(de1 & de2);  // Zuweisung 
    IF ae1<Cons2 THEN // if then else... 
       ia1:= ie1 DIV 5; 
    ELSIF ae1<0.23 THEN 
       aa1 := 10.41 * ae1 + SIN(ae2 - 0.33); 
    ELSE 
       da3 := da2 OR da3; 
    END_IF; 
    k :=27; 
    FOR i:=1 TO k+3 BY 2 DO // For-Schleife 
       ok := fillBit(800,900,i); // Reg. 800, bit i auf TRUE setzen 
    END_FOR; 
END_PROGRAM /* Ende St-Text */

11.1.2.1 Zugriff auf Register

Für den Zugriff auf Register steht folgender Satz von Funktionen zur Verfügung:

  1. ok := getBit(RegAnf,RegEnd,BitNr,BoolVar); Der Wert des Bits „BitNr” des Registers „RegAnf” wird in die Variable BoolVar geschrieben.
  2. ok := setBit(RegAnf,RegEnd,BitNr,BoolVar); Der Wert der Variablen „BoolVar” wird in das Bit „BitNr” des Registers „RegAnf” geschrieben.
  3. ok := fillBit(RegAnf,RegEnd,BitNr); Das Bit „BitNr” des Registers „RegAnf” wird auf TRUE gesetzt.
  4. ok := clrBit(RegAnf,RegEnd,BitNr); Das Bit „BitNr” des Registers „RegAnf” wird auf FALSE gesetzt.
  5. ok := setHiVal(RegAnf,RegEnd,Offset,Var); Das höherwertige Wort der Variablen „Var” wird in das Register „RegAnf+Offset” geschrieben.
  6. ok := setLoVal(RegAnf,RegEnd,Offset,Var); Das niederwertige Wort der Variablen „Var” wird in das Register „RegAnf+Offset” geschrieben.
  7. ok := setVal(RegAnf,RegEnd,Offset,Var); Der Wert der Variablen „Var” wird in das Register „RegAnf+Offset” und „RegAnf+Offset+1” geschrieben.
  8. ok := getHiVal(RegAnf,RegEnd,Offset,Var); Das höherwertige Wort der Variablen „Var” wird mit dem Inhalt des Registers „RegAnf+Offset” beschrieben.
  9. ok := getLoVal(RegAnf,RegEnd,Offset,Var); Das niederwertige Wort der Variablen „Var” wird mit dem Inhalt des Registers „RegAnf+Offset” beschrieben.
  10. ok := getVal(RegAnf,RegEnd,Offset,Var); Die Variable „Var” wird mit dem Inhalt der Registers „RegAnf+Offset” und „RegAnf+Offset+1” beschrieben.

Die Parameter „RegAnf” und „RegEnd” sind die (zur Laufzeit) überwachte untere- und obere Grenze für Registerzugriffe.

Das Funktionsergebnis(ok) wird dann auf „FALSE” gesetzt, wenn versucht wird auf Register außerhalb des erlaubten Bereiches(RegAnf..RegEnd-1) zuzugreifen.

Für lesende Register-Zugriffe (bei der ZKG512) ist der maximal erlaubte Registerbereich: 0..2600.

Für schreibende Register-Zugriffe (bei der ZKG512) ist der maximal erlaubte Registerbereich: 600..2600.

Der Parameter „BitNr” darf auch größer als 15 sein. Es wird dann auf Bits der folgenden Register zugegriffen. Dadurch können Bitfelder (beginnend mit RegAnf) bearbeitet werden.

11.1.2.2 Integer Funktionen

Für Integer Variable stehen zusätzlich zur Arithmetik (+, -, * und DIV) folgende Funktionen zur Verfügung:

  1. INC(Var,val); Die Variable „Var” wird um den Wert „val” erhöht. Wenn val nicht angegeben ist, dann wird um „1” erhöht.
  2. DEC(Var,val); Die Variable „Var” wird um den Wert „val” vermindert. Wenn val nicht angegeben ist, dann wird um „1” vermindert.
  3. MOD oder % : Es wird der (ganzzahlige) Rest einer Integerdivision berechnet. Beispiel: 13 MOD 10 = 3

Integer Multiplikation und Division ist hier nur (...für Adress-Berechnungen) als Unsigned_16Bit implementiert.

11.1.2.3 Festpunkt Funktionen

Neben den Grundrechenarten (+ , - , * , / ) werden folgende Festpunkt-funktionen unterstützt:

  1. Addiere Winkel: +< ; Beispiel: aa1:=aa1 +< 0.9; // Addition ohne Begrenzung, wie z.B ..180°+90°= -90°
  2. Subtrahiere Winkel: -< ; Beispiel: aa1:=aa1 -< 0.9; // Subtraktion ohne Begrenzung, wie z.B ..-160°- 30°= +170°
  3. Absolutwert: ABS; Beispiel: aa1:=ABS(-0.84); // Ergebnis ist +0,84
  4. Quadratwurzel: SQRT; Beispiel: aa1:=SQRT(0.25); // Ergebnis ist +0,50;
    Achtung: SQRT(-x) => -SQRT(x)
  5. Winkelfunktionen: SIN, COS, TAN, COT, ARCSIN; Beispiel: aa1 := SIN(ae1);

Es werden folgende Relationen unterstützt:

  1. Gleich: =; Beispiel: IF ae1=0.71 THEN ...
  2. Ungleich: <>, #; Beispiel: IF (ae1#ae2) OR (ae1<>ae3) THEN ...
  3. Größer: >; Beispiel: IF ae1 > ae1 THEN ...
  4. Größer oder gleich: >=; Beispiel: IF ae1 >= ae1 THEN ...
  5. Kleiner: <; Beispiel: IF ae1 < ae1 THEN ...
  6. Kleiner oder gleich: <=; Beispiel: IF ae1 <= ae1 THEN ...

11.1.2.4 Boolsche Funktionen

Es werden folgende Boolsche bzw. Digitale Funktionen unterstützt:

  1. Und Verknüpfung: AND bzw. &; Beispiel: da1:= de1 & de2 AND de3;
  2. Oder Verknüpfung: OR bzw. | ; Beispiel: da1:= de1 | de2 OR de3;
  3. Negierung: NOT bzw. ! oder ~ ; Beispiel: da1:= NOT ( ~ ( ! de1)); // 3-fache Negierung

Es werden folgende Boolsche bzw. Digitale Relationen unterstützt:

  1. Gleich: = ; Beispiel: „IF de1=TRUE THEN ...
  2. Ungleich: <>, # ; Beispiel: IF de1#de2 THEN...

11.1.2.5 Strukturierter-Text Klone-Bausteine

Über den Baustein-Menüpunkt „klonen” können Strukturierter-Text Klone-Bausteine erzeugt werden. Änderungen an einem Klon werden (automatisch) auf alle Klone gleichen Namens übertragen.

11.1.3 Makros

Makros sind selbst-definierte SPS-Bausteine und können beliebige SPS-Strukturen enthalten. Makros verbergen komplexe Strukturen und erhöhen so die Übersichtlichkeit eines Programms.

Makros können, wie andere Bausteine auch, kopiert werden. Änderungen am Original wirken sich nicht auf Kopien aus. Um das Projekt wartbar zu halten, wird aber (beim Übersetzen und beim Schließen von Makros) geprüft, ob es Makros gleichen Namens aber mit verschiedenen Inhalten gibt. Makros die sich nur durch die Parameter ihrer Bausteine unterscheiden gelten als gleich.

Über den Baustein-Menüpunkt „Öffnen” gelangt man in die innere Struktur eines Makros und kann hier (im Edit-mode) auch Änderungen vornehmen.

Über den Baustein-Menüpunkt(..Kontexmenü) „sichern” kann man Makros abspeichern, und sich so eine „Makrobibliothek” anlegen. Über das Menü „Datei/Makro-Laden” können abgespeicherte Makros wieder geladen werden.

Neue Makros erzeugen: Aus dem Menü „Bausteine” wählt man „Makro” und platziert dieses Makro auf dem Arbeitsblatt. Über den Baustein-Menüpunkt „öffnen” gelangt man ins Innere des noch leeren Makros. Hier kann man über das „Bausteine” Menü analoge oder digitale Makroanschlüsse (..PortIn, PortOut) erzeugen. Diese Makroanschlüsse müssen mit Anschluss-Name(3 Zeichen) und Anschluss-Nr. parametriert werden. Die Anschluss-Nr. bestimmt die Position des Anschlusses an der Makro-Hülle (Nr.1 ist immer ganz oben).

Damit diese Anschlüsse auch auf der äußeren Makro-Hülle sichtbar werden, muss jeder Anschluss über den Baustein-Menüpunkt „einschalten” aktiviert werden. Beim „einschalten” wird geprüft, ob Anschluss-Name und Nr. gültige Werte enthalten bzw. ob diese Namen und Nummern schon in anderen (aktivierten) Anschlüssen des Makros benutzt wurden. In solch einem Fall wird eine Fehlermeldung erzeugt, und der Anschluss wird nicht aktiviert. Wenn kein Fehler vorhanden ist, dann wird der Anschluss auch auf der äußeren Makro-Hülle sichtbar, und kann benutzt werden.

Abschließend erzeugt man im Makro SPS-Strukturen, welche mit den Anschlüssen des Makros beliebig verbunden werden können. Es ist auch erlaubt Makros in Makros zu benutzen (Rekursionen sind nicht möglich).

Makros aktualisieren: Mit dem Baustein-Menüpunkt updateMacros kann erreicht werden, dass Änderungen an einem Makro auf alle andere Makros gleichen Namens übertragen werden.

Makros verriegeln: Makros können durch Passwörter1 gegen Änderungen durch Unbefugte geschützt werden. Das ist z.B. dann sinnvoll, wenn weitergegebene Makros sicherheitsrelevante Schutzfunktionen enthalten, die nicht verändert werden dürfen. Zum Verriegeln wählt man das Kontexmenü Verriegeln und muß dann ein Passwort (zweimal) eingeben. Zum Öffnen des Makros muss dann immer dieses Passwort eingegeben werden. Zum Entriegeln eines Makros muß das gleiche Passwort eingegeben werden. Wenn man das Passwort vergessen hat, dann kann mit Hilfe des Makro-Namens ein Freischaltcode2 berechnet werden, mit dem das Makro entriegelt werden kann.

Zum entriegeln eines Makros mittels Freischaltcode geht man folgendermaßen vor:

11.1.4 Digitale Filter

Mit Hilfe von SPS-Bausteinen können auch „Digitale Filter” realisiert werden.

Die Koeffizienten der Übertragungsfunktion H(z) Digitaler-filter können mit Hilfe von Filterentwurfs-programmen ermittelt werden.

Zum Beispiel mit dem freien Filterentwurfs-programm DFCGEN
Siehe: http://home.arcor.de/dfcgen/

Oder mit Hilfe der „Signal-processing” Funktionen des Programmes OCTAVE3.
Dokumentation siehe: http://octave.sourceforge.net/signal

Im folgenden Beispiel soll ein Tiefpass 8.Ordnung (Tschebyscheff II) mit einer Grenzfrequenz von 49 Hz und einer Dämpfung von 60 dB im Sprerrbereich berechnet werden. Die Abtastfrequenz Fs sei 1000 Hz.

Mit dem OCTAV Aufruf: [b,a]=cheby2(n,Rs,Wn,) werden die Zähler(b) und Nenner(a) Koeffizienten der Übertragungsfunktion H(z) ermittelt. Dabei ist:

Die Grenzfrequenz Wn liegen im Bereich 0..1 und bezieht sich auf die halbe Abtastfrequenz (Fs/2=1.0).

also: Rs=60; Wn=49/500;   [b,a]=cheby2(8,Rs,Wn)

Durch Aufruf der OCTAVE-Funktion freqz(b,a) kann der Frequenzgang des Filters grafisch dargestellt werden.

Da Filter höherer Ordnung eine hohe Koeffizientengenauigkeit erfordern und zu numerischen Instabilitäten neigen, ist es besser solche Filter durch eine Reihenschaltung aus Filtern 2. Ordnung zu realisieren.

Die Berechnung der Koeffizienten für Filterblöcke 2. Ordnung, aus einem Filter höherer Ordnung, erfolgt mit dem OCTAVE-Kommando: [sos,g]=tf2sos(b,a). Sos steht für „second order system”, g(gain) ist die benötigte Gesamtverstärkung über alle Blöcke.

Ausgabeformat der Ergebnisses von tf2sos:

 b01 b11 b21 1 a11 a21     1.0 -0.45010 1.0 1 -1.52324 0.58321 
 b02 b12 b22 1 a12 a22     1.0 -1.71056 1.0 1 -1.63642 0.68917 
 b03 b13 b23 1 a13 a23     1.0 -1.86539 1.0 1 -1.77510 0.82065 
 b04 b14 b24 1 a14 a24     1.0 -1.90233 1.0 1 -1.89855 0.94113 
    g = verstärkung(gain)        0.0010401

Die Zähler(b) und Nenner(a) Koeffizienten werden als Parameter(KP) in die PROPortional Bausteine der Filterblöcke eingetragen.

Filterblock 2.Ordnung realisiert durch SPS-Bausteine:



Abbildung 11.1: Filterblock 2.Ordnung

PIC


Proportional-bausteine mit einer Verstärkung von 1 (KP=1.0) können auch weggelassen und durch eine Verbindungslinie ersetzt werden.

Wenn es beim Testen zu Überläufen kommt (Begrenzung der Ausgangswerte auf +/-1.0), dann müssen die Verstärkungsfaktoren der jeweiligen Blöcke herunter-gesetzt werden. Nach dem letzten Filterblock muss dann ein weiterer Proportional-baustein eingefügt werden, damit die Gesamtverstärkung (g) den geforderten Wert hat.

11.1.5 Funktionsblöcke

Funktionsblöcke (FBLO’s) sind SPS-Programme die nur dann ausgeführt werden, wenn an ihren Eingängen der Wert TRUE anliegt. Der Parameter „Name” eines Funktionsblockbausteins gibt den Namen eines zuvor erzeugten Funktionsblock-Programms an. Ein Funktionsblock kann auch mehrfach innerhalb eines Programms/Prozesses eingefügt werden. Der Programm-Code dieses Blockes wird dann in jedem SPS-Zyklus ggf. auch mehrfach durchlaufen. Die Anzahl unterschiedlicher Funktionsblöcke ist z.Z. auf „32” begrenzt.

Am Ausgang eines Funktionsblockes liegt immer der Wert des Eingangs an (der Eingangswert wird auf den Ausgang übertragen).

Wenn ein Funktionsblock mehrfach in einem Programm benutzt wird, dann muss man beachten, daß dieser Fkt-Block jedes mal mit dem selben Variablensatz arbeitet.

Zeitabhängige Bausteine (z.B. Anzugsverzögerungen) in Funktionsblöcken sind problematisch, weil die Zeit in Funtionsblöcken stehen bleibt, wenn sie nicht enabled sind, d.h. wenn sie nicht ausgeführt werden. Wird ein Funktionsblock mehrfach in einem Programm ausgeführt, dann vergeht die Zeit in diesem Funktionsblock sogar schneller.

11.1.6 Sub-Prozesse

Sub-Prozesse sind eigenständige SPS-Prozessdateien, welche durch Sub-Prozess Bausteine repräsentiert werden.

Der einzige Parameter dieser Bausteine ist der Name der zugeordneten SPS-Programmdatei. Wenn diese SPS-Programmdatei beim Öffnen des Sub-Prozesses noch nicht existieren, dann wird sie (beim Öffnen) erzeugt.

Sub-Prozesse besitzen „dummy-Anschlüsse”. Über diese Anschlüsse werden keine Daten übertragen. Sie können aber zur Festlegung der Baustein-Abarbeitungsreihenfolge genutzt werden.

Beim Übersetzen wird der Code der Sub-Prozesse mittels „include” Mechanismus in übergeordnete SPS-Prozesse eingebunden. Der Datenaustausch zwischen Prozess und Sub-Prozess erfolgt (falls erforderlich) über selbst-definierte SPS-Variable oder über Register.

11.1.7 Zustandsautomaten

Mit Zustandsautomaten können komplexe logische zusammenhänge übersichtlich programmiert und dargestellt werden. Ähnlich wie Makros können auch selbstdefinierte Zustandsautomat-Bausteine erstellt werden. Nach außen ist nur die Hülle des Automaten mit logischen Ein- und Ausgängen sichtbar. Der Zustand der logischen Ausgänge eines Automaten ist abhängig vom Zustand der logischen Eingänge und vom internen Zustand des Automaten. Der Wert des State-Nr-Ausgangs(Integer) eines Automaten ist nur vom internen Zustand des Automaten abhängig.

Zustandsautomaten werden aus folgenden Bausteinen zusammengesetzt:

Hat ein Zustand(State) mehrere Ausgänge mit Zustandsübergängen, dann werden diese Übergänge von oben nach unten abgearbeitet, bis eine Übergangsbedingung gefunden wird welche den wert true liefert. Liefert kein Zustandsübergang den Wert true, dann findet auch kein Zustandsübergang statt. Der alte „aktive Zustand” ist der neue „aktive Zustand”.

Beim Erstellen eines Zustandsautomaten sollte man besondere Sorgfalt auf das Verlegen der Verbindungslinien (möglichst wenig Kreuzungen) legen, da das Zustandsdiagramm ansonsten schnell unübersichtlich wird.

Beispiel: Zustandsdiagramm mit übergeordnetem Zustandsautomat-Baustein.

PICPIC

1Passwörter werden nach dem MD5-Algorithmus verschlüsselt.

2Der Freischaltcode kann bei der Fachabteilung unter Angabe des Makro-Namens erfragt werden.

3ein freies Programm für numerische Berechnungen (ähnlich wie MATLAB)