Vollständiger STF-Umdruck

Transcription

Hochschule Bremerhaven
Unterlagen zur Lehrveranstaltung
Steuerungs- und Feldbustechnik
[ STF ]
Teil 1:
Steuerungstechnik
--- SPS (Siemens Step 7)
--- IEC1131-3
--- Logische Funktionen
--- Ablaufsteuerungen
--- Signalverarbeitung
Teil 2:
Bussysteme in der Automatisierungstechnik
--- Ethernet
--- Profibus
Revision:
V0.2f (minor)
Datum:
Dezember 2014
K. Müller, HS Bremerhaven
Prof. Dr.-Ing. Kai Müller
Hochschule Bremerhaven
Institut für Automatisierungs- und Elektrotechnik
An der Karlstadt 8
D---27568 Bremerhaven
Tel:
FAX:
+49 471 48 23 --- 415
+49 471 48 23 --- 418
E---Mail:
[email protected]
1
Hochschule Bremerhaven --- IAE
I
Einleitung
I.I
Umdruck zur Vorlesung
Über die Homepage der Vorlesung <http://www1.hs---bremerhaven.de/kmueller/>
werden aktualisierte oder korrigierte Unterlagen im Verlauf der Vorlesung zur Verfügung
gestellt.
I.II Steuerungs- und Feldbustechnik
Industrielle Anlagen werden heute überwiegend mit elektronischen Steuerungen
versehen, um steigende Anforderungen an Genauigkeit und Geschwindigkeit erfüllen zu
können. Durch ihre Programmierbarkeit sind diese Steuerungen sehr flexibel und
universell einsetzbar. Sehr verbreitet ist die Speicherprogrammierbare Steuerung (SPS
oder PLC), die im Rahmen dieser Veranstaltung ausführlich behandelt wird.
Im Bereich der Vernetzung laufen ähnliche Entwicklungen ab wie in der Informationstechnik. Die unterschiedlichen Busse, die ursprünglich im Bereich der Steuerungstechnik
eingesetzt wurden (sogenannte Feldbusse), haben sich mittlerweile im Wesentlichen auf
das Ethernet reduziert, das bei geringen Kosten die höchste Übertragungsrate bietet.
Daneben spielen CAN (Car Area Network) und Profibus noch ein geringe, aber nicht zu
vernachlässigende Rolle.
Ich wünsche allen Hörern der Veranstaltung “Steuerungs- und Feldbustechnik” viel Freude
an dem faszinierenden Fachgebiet.
Bremerhaven, April 2010
Kai Müller
<kmueller@hs ---bremerhaven.de>
Tel: (0471) 4823 --- 415
I
II Inhalt
1
Steuerung von Anlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1
2
SPS (PLC) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2
2.1
Programmierung von Steuerungen nach IEC 61131-3 . . . . . . . . . . . . . .
3
2.2
Aufbau einer SPS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4
3
Organisation eines SPS-Programms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6
4
Logische Funktionen und Automaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7
4.1
Logische Signale und Funktionen (Gatter) . . . . . . . . . . . . . . . . . . . . . . .
7
4.2
Elementare Gatter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8
4.2.1
Inverter (Negation) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9
4.2.2
Konjunktion (AND) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9
4.2.3
Disjunktion (OR) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9
4.2.4
NAND . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10
4.2.5
NOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10
4.2.6
Antivalenz (exklusiv ODER, XOR) . . . . . . . . . . . . . . . . . . . . . . .
10
4.2.7
Äquivalenz (XNOR) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11
4.3
Vorrangregeln für boolsche Algebra . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11
4.4
Funktionen für eine Variable (UNARY OPERATORS) . . . . . . . . . . . .
12
4.5
Funktionen für zwei Variablen (BINARY OPERATORS) . . . . . . . . . . .
12
4.6
Übung: Aufstellen einer Wahrheitstabelle . . . . . . . . . . . . . . . . . . . . . . . .
12
4.7
Rechenregeln für eine Variable und eine Konstante . . . . . . . . . . . . . . . .
14
4.8
Verwirklichung einfacher Gatterfunktionen durch mechanische
Schalter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14
Programmierung einer Steuerung mit SPS . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
16
5.1
Operationen zur Signalverarbeitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
16
5.2
Operanden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
17
5.3
Programmorganisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
18
5.4
Kontrollstrukturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
18
6
Übung 1: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
19
7
Verknüpfungsoperationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
19
8
Schützschaltung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
20
8.1
21
5
Übung 2: Umsetzung einer Schützschaltung mit symbolischen Namen
II
9
Speicher . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.1
22
Übung 3: Programmieren ein RS-Flip-Flop mit Setz- und
Rücksetzdominanz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
23
10 Ablaufsteuerungen (Automaten) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
23
10.1
Beispiel: Ampelsteuerung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
25
10.1.1 Next-State-Logic (Eingangslogik) F(u, x) . . . . . . . . . . . . . . . . . .
26
10.1.2 Output-Logic (Ausgangslogik) G(x) (Moore-Maschine) . . . . .
26
10.1.3 State-Memory (Zustandsspeicher) . . . . . . . . . . . . . . . . . . . . . . . .
26
Zustandsdiagramm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
26
11 Verwirklichung mit SPS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
27
10.2
11.1
Übung: Erweiterung der Ampelsteuerung um die Funktion
“Blinken des gelben Lichts” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
31
12 Zeiten und Zähler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
31
12.1
Zeiten (Timer) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
31
12.2
Beispiel für den Einsatz von Timern: Rechteckgenerator . . . . . . . . . . .
33
12.3
Zähler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
34
12.4
Übung: Vorwärts-/Rückwärtszähler mit Anzeige . . . . . . . . . . . . . . . . . . .
34
13 Steuerung einer Ofenanlage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
35
14 CPU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
36
15 Prozesse in einer SPS-Applikation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
39
16 Fehlersuche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
41
17 Logische Operationen auf Wortebene . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
42
18 Algebraische Berechnungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
43
18.1
Auswertung algebraischer Operationen . . . . . . . . . . . . . . . . . . . . . . . . . .
46
18.2
Konversion zwischen Zahlensystemen . . . . . . . . . . . . . . . . . . . . . . . . . . .
47
19 Beispiel: Einlesen von Temperaturdaten und Darstellung auf
Siebensegmentanzeige . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
47
20 Beispiel: Berechnung von Scheinleistung und Blindleistung aus gemessenen
Werten von Strom und Wirkleistung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
49
21 Regelungen mit SPS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
51
21.1
Schaltende Regler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
51
III
21.1.1 Übung: Temperaturregelung (schaltender Regler) . . . . . . . . . .
52
22 Dynamische Regler-Übertragungsfunktionen . . . . . . . . . . . . . . . . . . . . . . . . . . .
53
22.1
Integrator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
56
22.2
PI-Regler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
58
23 PID-Regler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
62
23.1
Beispiel: D-Glied mit kd = 1, t* = 0.333333 und der Abtastperiode
T = 0.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
65
24 Berechnung des D-Glieds mit der SPS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
66
25 The Real Thing --- Konfiguration und Programmierung einer „echten” SPS . .
68
26 Vernetzung von SPS-Geräten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
70
26.1
RS-485 (MPI/Profibus) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
71
26.2
CSMA/CD und Token-Passing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
72
26.2.1 CSMA/CD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
72
26.2.2 Token-Passing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
73
27 Konfigurieren einer Siemenst-SPS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
75
28 Automatisierung einer Tankfüllanlage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
75
28.1
Übung: Verwirklichung der Steuerung . . . . . . . . . . . . . . . . . . . . . . . . . . .
80
29 Ampelsteuerung mit Belegungserkennung . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
80
29.1
Strategien zur Kodierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
83
29.2
Übung: Kodierung der Ampelsteuerung . . . . . . . . . . . . . . . . . . . . . . . . .
84
30 Diskrete Regelung (PI-Regler) mit einer SPS . . . . . . . . . . . . . . . . . . . . . . . . . . .
85
30.1
Übung: Umsetzung als SPS-Programm . . . . . . . . . . . . . . . . . . . . . . . . . .
87
31 Vergleich der Algorithmen des SIEMENSt-PI-Reglers (FB41) und der
bilinearen Transformation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
90
32 Einsatz des PID-Moduls der SPS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
93
32.1
Verwendung des PID-Moduls der Siemens-SPS (FB41) . . . . . . . . . . . . .
97
32.2
Übung: PID-Regelung mit FB41 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
103
33 Structured Text (ST) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
104
33.1
ST Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
105
33.1.1 Ausdrücke (Expressions) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
106
IV
33.1.2 Kontrollstrukturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
106
33.1.3 Schlüsselworte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
109
33.1.4 Unterprogramme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
109
34 Vergleich zwischen ST und IL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
111
35 Labor #01: AWL, FUP und KOP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
112
36 Labor #02: Elementare Logikfunktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
113
37 Labor #03: Zustandsdiagramme für Automaten und für eine
Ablaufsteuerung der SPS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
114
38 Labor #04: Ampelsteuerung (Verwirklichung mit AWL und FUP) . . . . . . . .
116
39 Labor #05: Industrie-Spülmaschine
(Ablaufsteuerung durch Kodierung der Zustände und durch Kodierung
der Übergänge) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
117
40 Labor #06: Berechnung numerischer Ausdrücke mit der SPS . . . . . . . . . . . . .
118
41 Labor #07: Numerische Lösung einer Gleichung durch Iteration mit der SPS
119
42 Labor #08: Digitales Filter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
120
43 Labor #09: Digitales Filter 2. Ordnung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
121
44 Labor #10: PID-Regler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
122
45 Labor #11: Füllstandsregelung
(solide & einfach) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
124
46 Labor #12: Füllstandsregelung
(vollständig) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
125
47 Labor #13: Graphische Bedienung der Füllstandsregelung mit WinCCt
(HMI) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
126
48 Labor #14: PI-Regelung einer Tiefpassstrecke mit SPS . . . . . . . . . . . . . . . . . .
127
49 Labor #15: Zweipunkt- und PI-Regelung einer Tiefpassstrecke mit SPS . . . .
129
60 Literatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
145
1
1
Steuerung von Anlagen
Einfache Anlagen mit wenigen Steuereingriffen lassen sich “von Hand” bedienen. Wenn
jedoch viele Signale zu beachten sind und eine Anlage über viele Steuereingriffe verfügt,
bietet sich eine Automatisierung an. Gleichzeitig kann damit auch eine Fehlbedienung
vermieden werden, so dass automatisierte Anlagen eine größere Betriebssicherheit
aufweisen.
Elektronische Steuerungen reagieren im Bereich von Mikrosekunden oder Millisekunden,
so dass die Produktivität automatisierter Anlagen gewöhnlich höher ist, als dies mit einer
manuellen Bedienung möglich ist.
Man unterscheidet folgende Strukturen zur Automatisierung von Anlagen:
Offene Steuerung:
Eine Steuerungsgerät erzeugt eine festgelegten Satz von Signalen an einen Prozess (z.B.
Ampelsteuerung).
Geschlossene Steuerung:
Aus dem Prozess werden zusätzlich Signale zurückgeführt, die die Steuersignale
beeinflussen. Ein Beispiel wäre eine Positioniereinrichtung mit Endschaltern. Sobald
ein Endschalter betätigt wird, muss der Positioniervorgang beendet werden.
Regelung:
Durch ständige Messung von Prozessgrößen werden die Ansteuersignale (in den
Prozess) verändert.
Sowohl bei der geschlossenen Steuerung als auch bei der Regelung spricht man von
rückgekoppelten Systemen.
Steuergerät
Bild 1.1:
Offene Steuerung
Steuergerät
Bild 1.2:
Prozess
Prozess
Geschlossene Steuerung und Regelung
Der Unterschied zwischen geschlossenen Steuerungen und Regelung besteht in der Natur
der Signale. Bei Regelungen handelt es sich um kontinuierliche Signale (Messwerte von
2
Temperatur, Druck, Geschwindigkeit, Strom usw., während es sich bei Steuerungen im
diskrete Signale handelt. In den meisten Fallen handelt es dabei im boolsche Signale, d.h.
das Signal nimmt nur zwei Zustände an. Die logischen Zustände werde mit “0” und “1”
bezeichnet. Damit lassen sich verschiede physikalische Sachverhalte beschreiben.
Beispiele:
“0”:
“1”:
Prozesstemperatur im gewünschten Bereich
Prozesstemperatur zu hoch
“0”:
“1”:
Motor steht
Motor läuft
“0”:
“1”:
Spannung aus
Spannung an
Zu Zuordnung von logischen Werten zu physikalischen Sachverhalten erfolgt rein
willkürlich.
Man könnte also auch den Wert “0” dem Sachverhalt “Motor läuft” zuordnen, was aber
die Lesbarkeit von Programmcode für eine Prozesssteuerung nicht gerade erhöht.
Wir werden uns im Rahmen dieser Veranstaltung nur mit Steuerungen befassen (der
Großteil der Anwendungen). Regelung werden in einer späteren Vorlesung behandelt.
2
SPS (PLC)
Die verbreitetste Form von Anlagensteuerungen ist die SPS (Speicherprogrammierbare
Steuerung oder PLC = programmable logic controller). Die SPS hat inzwischen viele
Entwicklungsstufen durchlaufen, da sich die Anforderungen bei komplexer werdenden
Anlagen ständig erhöhen.
Um eine herstellerunabhängige Programmierung zu ermöglicht, wurde der Standard
IEC1131-3 (IEC = Internationl Electrotechnical Commission) ins Leben gerufen, der
jedoch von den meisten Herstellern nicht besonders gepflegt wird. Dadurch bleibt die
Bindung von Kunden an einen bestimmten Hersteller erhalten. Im Rahmen der
Veranstaltung soll jedoch neben der SIEMENS Step 7-Programmierung auch auf den
herstellerunabhängigen IEC-Standard eingegangen werden. Die IEC-Norm ist im
wesentlichen aus der PLCopen Group hervorgegangen, ein Zusammenschluss von
SPS-Herstellern.
Unter einer SPS versteht man einen speziellen Computer mit mehreren (in der Regel)
digitalen Ein-/Ausgängen, der logische Verknüpfungen (programmierbar) zwischen
den Ein- und Ausgängen herstellt.
3
Im Prinzip können Steuerungsaufgaben auch von ganz normalen PCs erfolgen.
Entsprechende Software (Soft-SPS für PCs) ist für diesen Zweck auch verfügbar. Von
Standpunkt der Programmierung ist es unerheblich, auf welchem System die SPS-Funktion
umgesetzt wird. Dennoch werden Steuerungen überwiegend auf speziellen SPS-Computern verwirklicht. Folgende Gründe sprechen für den Einsatz spezieller SPS-Geräte:
Zuverlässigkeit:
Ein spezielles Steuergerät mit wenigen Komponenten ist zuverlässiger als ein
universeller Computer mit vielen Komponenten mit beschränkter Lebensdauer (z.B.
Festplatten in rauher Industrieumgebung).
“Absturzfreudige” PC-Betriebssysteme sind i.a. für Anlagen mit Personengefährdung
(z.B. Medizintechnik, Aufzüge) nicht geeignet.
Echtzeitfähigkeit:
Eine SPS gewährleistet definierte Reaktionszeiten. SPS besitzen eine “Firmware”, die
Echtzeit gewährleistet. Sofern man Computer zur Steuerung einsetzt, müssen diese
über ein Echtzeit-Betriebssystem verfügen.
2.1
Programmierung von Steuerungen nach IEC 61131-3
Die IEC (International Electrotechnical Commission) sieht folgende Programmiersprachen bzw. grafische Entwurfswerkzeuge vor (die Siemens-Bezeichnungen, die natürlich
nicht mit den IEC-Bezeichnungen übereinstimmen, werden in Klammern angegeben):
LD = Ladder Diagram
(KOP = Kontaktplan)
IL = Instruction List
(AWL = Anweisungsliste)
ST = Structured Text
(SCL = Structured Command Language)
FBD = Function Block Diagram
(FUP = Funktionsplan)
SFC = Sequential Function Chart
(AS = Ablaufsprache)
CFC = Continous Function Chart
(CFC) nicht Teil von IEC 61131-3
Keine diese Entwicklungsstandards können als dem Stand der Informationstechnik
entsprechendes Werkzeug aufgefasst werden (z.B. C++ / Java, embedded Java).
4
2.2
Aufbau einer SPS
digitale
Eingänge
digitale
Ausgänge
VerarbeitungsEinheit
.
.
.
Umsetzung
physikalisch
---> logisch
Mikrocomputer
mit
Umsetzung
logisch --->
physikalisch
SPS-Firmware
.
.
.
Porgrammierschnittstelle
(meist seriell)
licensed
Software
Bild 1.3:
Aufbau einer SPS (EVA-Prinzip)
Wir wollen uns zunächst nur auf digitale Ein-/Ausgänge beschränken. Eine SPS kann häufig
durch andere Schnittstellen (analog und digital) erweitert werden.
SPS-Systeme können mit nahezu beliebig vielen Ein- und Ausgängen bestellt werden.
Physikalisch wird eine Signal in Normalfall durch eine Spannung von 24V bzw. 0V
dargestellt (hohe Störsicherheit). Die Nennspannung von 24V hat historische Ursachen, da
mit diesem Spannungspegel Relais und Schütze angesteuert werden. Umsetzer an den Einund Ausgängen erzeugen das intern verwendete Format. Die Signale werden innerhalb der
SPS als logische “0”/“1”-Signale behandelt.
Die Verarbeitungseinheit besteht aus einer CPU mit einem speziellen Programm
(=Firmware), so dass der Entwickler meint, eine spezielle --- für Steuerungsaufgaben
geeignete --- Hardware zur Verfügung zu haben (=Programmiermodell). Wir können zur
Programmierung der SPS tatsächlich annehmen, dass eine Hardware gemäß Bild 1.4
vorhanden ist.
5
Verarbeitungseinheit
Speicher
Steuerwerk
Merker
Prozessabbild
Akku
Bild 1.4:
Speicher:
Zeitglieder
Zähler
Datenbus
Programmiermodell der Verarbeitungseinheit
Der Speicher enthält das SPS-Programm und besteht aus FLASH oder
EPROM (nichtflüchtig) sowie RAM (zur Speicherung von Variablen und
veränderlichen Daten).
Steuerwerk: Das Steuerwerk übernimmt die Initialisierung (Nullsetzen aller Zähler,
Zeitglieder und Merker sowie Akku). Die Hauptaufgabe besteht in der
sequentiellen Abarbeitung der Anweisungen, die im Speicher abgelegt sind.
Merker:
Dienen zur Speicherung von Signalzuständen = Gedächtnis der SPS.
Prozessabbild: Eine SPS rechnet nicht direkt mit den digitalen Ein- und Ausgängen,
sondern mit dem sogenannten Prozessabbild. Das Prozessabbild ist der
konsistente Satz von Ein- und Ausgangsgrößen zu einem bestimmten
Zeitpunkt. Falls sich Eingangsgrößen während eines Berechnungszyklusses
ändern, so hat dies keinen Einfluss auf des Berechnungsergebnis. Es wird
also stets mit den Signalwerten gerechnet, die zu Beginn eines
Berechnungszyklusses eingelesen wurden. In gleicher Weise ändern sich
auch nur die Ausgänge am Ende des Berechnungszyklusses, da erst dann das
Prozessabbild an die Ausgänge transferiert wird.
Akku:
Der Akku ist der Zwischenspeicher, in dem Berechnungen ausgeführt
werden. Der Akku ist vergleichbar mit der Anzeige eines einfachen
Taschenrechners ohne Klammerebenen.
Zeitglieder: Mit Hilfe von Zeitgliedern lasen sich Ergebnisse zu bestimmten Zeitpunkten
auslösen. Viele Anlagen erfordern nicht nur bestimmte Schalthandlungen,
6
sondern es müssen zusätzlich Zeitbedingungen eingehalten werden (z.B.
Ampel).
Zähler:
Zähler ermöglichen ein Zählen von Ereignissen.
Datenbus:
Der Datenbus verbindet alle Elemente der SPS und ermöglicht den
Datenaustausch zwischen allen Komponenten.
3
Organisation eines SPS-Programms
Die Programmierung einer SPS hat viele Entwicklungsstufen hinter sich. Dennoch merkt
man der SPS-Programmierung die Ursprünge (Schütz- und Relaistechnik) an. Erst in
letzter Zeit (PLCopen, IEC-1131) dringen Erkenntnisse der Informatik in die SPS vor.
Zurzeit (exklusive IEC-1131) bestehen drei Möglichkeiten, ein SPS-Programm zu
schreiben:
Anweisungsliste (AWL):
Diese Darstellung entspricht am ehesten eine Programmiersprache, da die Anweisungen sequentiell von der SPS abgearbeitet werden.
Die AWL kann aus mehreren ASCII-Dateien bestehen.
U
U
=
E
E
A
0.1
0.2
0.0
Funktionsplan (FUP):
Die
logischen
Funktionen werden
grafisch mit
DIN40900-Symbolen dargestellt. Diese Art der Programmierung erscheint
sehr einfach. Bei komplexen Steuerungen wird die grafische Darstellung
jedoch sehr unübersichtlich. Beispielsweise ist man bei modernen
Hardwarebeschreibungssprachen (VHDL oder Verilog) von der grafischen
Darstellung vollkommen abgekommen.
Kontaktplan (KOP):
Die Programmierung als Kontaktplan eignet sich für
Personen, die bereits Erfahrung mit Schützsteuerungen haben. Ansonsten
gelten die gleichen Einschränkungen wie beim FUP.
7
In dieser Veranstaltung wird zur Programmierung die AWL-Form verwendet. Die
IEC-1131-Norm sieht die Texteingabe als einzige Eingabeform vor. Der Übergang auf die
neue Norm ist also über die AWL-Form am einfachsten.
4
Logische Funktionen und Automaten
Mit einer SPS lassen sich Schaltnetze (logische Funktionen) und Automaten
programmieren.
Automaten (Ablaufsteuerungen) enthalten interne Zustände.
Jeder Automat enthält auch Schaltnetze, so dass es sinnvoll ist, mit den logischen
Funktionen zu beginnen.
4.1
Logische Signale und Funktionen (Gatter)
Unabhängig von der physikalischen Verwirklichung entwirft man oft ein digitales System
als logisches System mit logischen Signalen, d.h. “0”-“1”-Signalen. Wir ignorieren also das
elektrische Verhalten (bei CMOS- oder TTL-Schaltungen) und beschränken uns auf die
diskreten Signale 0 und 1. Bevor man also eine Schaltung aufbaut, wird zunächst das logische
Verhalten entworfen.
x
y
z
Bild 1.5:
f
logische
Schaltung
g
Logische Schaltung mit drei Eingängen und zwei Ausgängen
Die Funktion der Schaltung wird durch die sogenannte Wahrheitstabelle vollständig
beschrieben.
Die Wahrheitstabelle beschreibt vollständig eine kombinatorische logische Schaltung.
8
Unter
kombinatorischer
Schaltung versteht man eine Schaltung, bei der die
Ausgangsgrößen ausschließlich von den Eingangsgrößen abhängen.
Schaltungen mit internen Speicherelementen heißen sequentielle Schaltungen.
Die sequentiellen Schaltungen sind wesentlich leistungsfähiger. Jeder Computer ist eine
sequentielle Schaltung. Eine sequentielle Schaltung enthält aber immer kombinatorische
Logik. Es ist deshalb sinnvoll, sich zunächst mit kombinatorischer Logik zu befassen.
Die Schaltung in Bild 1.5 könnte z.B. die einstellige Addition aus Abschnitt NO TAG sein.
Wahrheitstabelle für eine einstellige duale Addition
Eingänge
Ausgänge
x = carryin
y = xk
z = yk
0
0
0
0
1
1
1
1
0
0
1
1
0
0
1
1
0
1
0
1
0
1
0
1
f = xk +yk
0
1
1
0
1
0
0
1
g = carryout
0
0
0
1
0
1
1
1
Beliebig komplexe Schaltungen lassen sich aus wenigen elementaren Logikfunktionen
(=Gatter) aufbauen.
4.2
Elementare Gatter
Es werden jeweils die gültigen IEC-Symbole aufgelistet als auch die veralteten
amerikanischen Schaltzeichen. Alte deutsche Symbole werden weggelassen. Die alten
amerikanischen Symbole sind auch heute weit verbreitet, insbesondere bei ECAD-Software (Electronic Computer Aided Design).
Variablen mit den Zuständen 0 und 1 bezeichnet man als boolsche Variablen.
Die Rechenreglen mit boolschen Variablen heißen boolsche Algebra.
Die folgenden Gatter werden nur mit der minimalen Anzahl von Eingangsgrößen
gezeichnet. Der Erweiterung auf mehrere Eingangsgrößen ist jedoch einfach.
Übung: Zeichnen Sie Gatter mit jeweils drei Eingangsgrößen und geben Sie die
entsprechende Wahrheitstabelle an.
9
4.2.1
Inverter (Negation)
Symbol
a
amerik. Symbol
1
x
a
Wahrheitstabelle
a
x
x
0
1
1
0
Boolsche Funktion
4.2.2
DIN-Schreibweise:
x=y
(x = nicht a)
amerik. Schreibweise:
x=a
(x = not a)
Konjunktion (AND)
Symbol
a
b
&
amerik. Symbol
x
a
b
x
Boolsche Funktion
4.2.3
Wahrheitstabelle
b
a
x
0
0
0
0
1
0
1
0
0
1
1
1
DIN-Schreibweise:
x =a∧b
(x = a und b)
x =a⋅b
(x = a and b)
Disjunktion (OR)
Symbol
a
b
≥1
amerik. Symbol
x
a
b
x
Boolsche Funktion
Wahrheitstabelle
b
a
x
0
0
0
0
1
1
1
0
1
1
1
1
DIN-Schreibweise:
x =a∨b
(x = a oder b)
x =a+b
(x = a or b)
10
4.2.4
NAND
Symbol
&
a
b
amerik. Symbol
x
a
b
x
Boolsche Funktion
DIN-Schreibweise:
x =a∧b
x = (a ⋅ b )
Wahrheitstabelle
a
x
b
0
0
1
0
1
1
1
0
1
1
1
0
(x = a nand b)
Mit NAND-Gattern lassen sich beliebige logische Funktionen realisieren.
4.2.5
NOR
Symbol
a
b
≥1
amerik. Symbol
x
a
b
x
Boolsche Funktion
Wahrheitstabelle
b
a
x
0
0
1
0
1
0
1
0
0
1
1
0
DIN-Schreibweise:
x =a∨b
x = (a + b ) (x = a nor b)
Mit NOR-Gattern lassen sich beliebige logische Funktionen realisieren.
4.2.6
Antivalenz (exklusiv ODER, XOR)
Symbol
a
b
=1
amerik. Symbol
x
a
b
x
Boolsche Funktion
DIN-Schreibweise:
x=a
amerk. Schreibweise:
x = (a
Wahrheitstabelle
a
b
x
0
0
0
0
1
1
1
0
1
1
1
0
b = (a ∧ b ) ∨ a ∧ b
b ) (x = a xor b)
11
4.2.7
Äquivalenz (XNOR)
Symbol
=1
a
b
amerik. Symbol
x
a
b
x
Boolsche Funktion
4.3
Wahrheitstabelle
b
a
x
0
0
1
0
1
0
1
0
0
1
1
1
b = a ∧ b ∨ (a ∧ b )
DIN-Schreibweise:
x=a
x = (a
b ) (x = a xnor b)
Vorrangregeln für boolsche Algebra
Leider sind die Vorrangregeln für Operationen international nicht einheitlich (die
amerikanischen Regeln unterscheidet sich von von DIN 66000). Dies folgt aus der
amerikanischen Schreibweise für UND ( ) und ODER (+), die der UND-Verknüpfung
eine höhere Priorität (Multiplikationszeichen) als der ODER-Verknüpfung (Summenzeichen) einräumt. Die deutsche DIN 66000 sieht UND und ODER als gleichwertig an. In der
DIN 660000 müssen also Klammern gesetzt werden, die im Amerikanischen entfallen
können.
Wir wollen uns in diesem Skript der amerikanischen Schreibweise anschließen, um bei den
späteren Software-Übungen nicht umlernen zu müssen.
Prioritätsregeln
1.
2.
3.
Negation
Konjunktion (UND)
Adjunktion (ODER)
a
a∧b
a∨b
4.
5.
6.
7.
NAND
NOR
Äquivalenz
Antivalenz (XOR)
a∧b
a∨b
a≡b
a b
Im Zweifel kann durch Klammernsetzung immer eine eindeutige Funktion angegeben
werden.
12
4.4
Funktionen für eine Variable (UNARY OPERATORS)
Eingang
a=1 0
Ausgang x
Symbol
Bezeichnung
0
1
0
1
x=0
x=a
x=a
x=1
Konstante 0
Identität
Negation
Konstante 1
Bild 1.6:
4.5
0
0
1
1
Unary Operators
Funktionen für zwei Variablen (BINARY
OPERATORS)
Eingänge
a= 1010
b= 1100
Ausgang x
Symbol
Bezeichnung
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111
x=0
x = a∨b
x = a∧b
x=b
x = a∧b
x=a
x=a b
x = a∧b
x = a∧b
x=a≡b
x=a
x = a∨b
x=b
x = a∨b
x = a∨b
x=1
Konstante 0
NOR
Inhibition
Negation (b)
Inhibition
Negation (a)
XOR (Antivalenz)
NAND
UND (Konjunktion
Äquivalenz
Identität (a)
Implikation
Identität (b)
Implikation
ODER (Disjunktion)
Konstante 1
Bild 1.7:
4.6
in SPS vorhanden
Binary Operators
Übung: Aufstellen einer Wahrheitstabelle
Geben Sie für folgende Schaltung die Wahrheitstabelle an.
13
a
&
a∧b
b
≥1
1
c
d
1
c
a∧b ∨ c∧d∧e
&
c∧d∧e
d
e
Bild 1.8:
Schaltung aus einzelnen Gattern
a
b
c
d
e
a∧b
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
1
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
1
0
0
0
0
1
1
1
1
0
0
0
0
1
1
1
1
0
0
0
0
1
1
1
1
0
0
0
0
1
1
1
1
0
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
1
c∧d∧e
0
1
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
1
0
0
0
0
0
0
a∧b ∨ c∧d∧e
0
1
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
1
0
0
0
0
0
0
1
1
1
1
1
1
1
1
14
4.7
Rechenregeln für eine Variable und eine Konstante
Die folgenden Rechenregeln ermöglichen oft eine erhebliche Vereinfachung von logischen
Schaltungen.
4.8
x∨0=x
(2.1)
x∨1=1
(2.2)
x∧0=0
(2.3)
x∧1=x
(2.4)
x∨x=1
(2.5)
x∧x=x
(2.6)
x∨x=x
(2.7)
x∧x=x
(2.8)
x=x
(2.9)
Verwirklichung einfacher Gatterfunktionen durch
mechanische Schalter
Zum Verständnis von Logikschaltungen ist es hilfreich, sich eine mechanische Realisierung
vorzustellen. In vielen Industrieanwendungen werden auch einfache logische Funktionen
durch Schalter (Öffner und Schließer) verwirklicht.
Schließer
Bild 1.9:
Öffner und Schließer
Schließer
Bild 1.10:
Öffner
Öffner
Öffner und Schließer in SPS-Darstellung
Durch Drücken des Tasters wird der Schließer geschlossen (Kontakt hergestellt); durch
Drücken des Tasters auf dem Öffner wird der Kontakt geöffnet.
Eingänge:
Taster nicht gedrückt = 0
Taster gedrückt = 1
15
Ausgänge: Lampe aus = 0
Lampe leuchtet = 1
a
b
Batterie
Bild 1.11:
Glühlampe
x
Glühlampe
x
Glühlampe
x
UND-Gatter
a
b
Batterie
Bild 1.12:
ODER-Gatter
a
b
Batterie
Bild 1.13:
NAND-Gatter
a
Batterie
Bild 1.14:
NOR-Gatter
b
Glühlampe
x
16
a
Batterie
x
Glühlampe
XOR-Gatter
Bild 1.15:
5
b
Programmierung einer Steuerung mit SPS
Die nachfolgende Programmierung basiert auf der DIN19239 sowie den firmenspezifischen Erweiterungen von Step 7 Der SIEMENS AG. Wie wollen uns auf die
Beschreibung der Steuerung auf die wichtige Ebene der AWL (Anweisungsliste)
beschränken.
5.1
Operationen zur Signalverarbeitung
Funktion
Symbol
Bemerkungen
UND
U
ODER
O
XOR
X
nur Step 7
NICHT
N
nur für Eingang!
Zuweisung
=
Setzen
S
Rücksetzen
R
Zählen +
ZV
Zählen ---
VR
17
Funktion
Symbol
Bemerkungen
Laden
L
Laden von Konstanten für
Zeitwerte oder Zähler
Nulloperation
NOP
= no ooperation
SPS-Programme sind “aktionsorientiert”, d.h. am Anfang jeder Anweisung steht eine
Operation. Es folgt ein
Operand.
Im Gegensatz zur SPS sind moderne
Programmiersprachen (z.B. Java, Python, C++) nicht “aktionsorientiert” sondern
“objektorientiert”.
Operand = Datum (Kennzeichen/Ergänzung/Parameter) oder eine Marke
(Sprungadresse in Verbindung mit Sprüngen).
5.2
Operanden
Funktion
Symbol
Beispiel
Konstante
K
Eingang
(aus Prozessabbild)
E
E0.0
EB10
EW4
ED2
Ausgang
(aus Prozessabbild)
A
A4.2
Eingang physikalisch
(Peripherie-Eingang)
PE
PE0.0
PEW2 (WORD)
Ausgang physikalisch
(Peripherie-Ausgang)
PA
PA0.2
PAD12 (DWORD)
Lokale Variable
L
L6.2
LD8
Daten
(im SPS-Programm)
D
DBW3
Zeiten
(T = Timer)
T
T1
Zähler
Z
Z13
(BIT)
(BYTE)
(WORD)
(DWORD
(DWORD)
Die Adressierung ist grundsätzlich Byte-orientiert.
Die Adressangabe hinter dem Operanden gibt somit die Byte-Adresse an. Bei
Bit-Operationen wird die Bitstelle durch einen Punkt abgetrennt. Z.B. bedeutet A4.2
Bit-Adresse 2 (das 3. Bit, die Zählung beginnt bei 0) der Byte-Adresse 4 (=5. Byte).
18
Wenn WORDs (2 Byte) oder DWORDs (4 Byte) adressiert werden, kann es zu
“Überlappungen” kommen
EB10
EB11
EB12
EB13
EB14
EB15
EW10
EW11
ED10
Adressraum bei der SPS
Bild 1.16:
Wie man sieht, überlagert sich der Speicherbereich der Werte EB10, EW10 und ED10. Im
Beispiel ist EB11 ist das obere Byte von EW10. Zu beachten ist, dass in der Byte mit der
höheren Adresse das niederwertige Byte eines WORDs gespeichert wird. Beispiel: Gilt
EW10 = 45AC hex, so ist EB10 = 45 hex und EB11 = AC hex.
Das Speicherformat bei der SPS ist “big endian” (das niederwertigste Byte =LSByte
steht an der höchsten Adresse (im Gegensatz zu “little endian” bei Intel).
5.3
Programmorganisation
Funktion
Symbol
Beispiel
Organisationsblock
OB
OB1
(OB1 ist die Wurzel allen
Übels!)
Unterprogramm
(FunCtion)
FC
UC FC1
FB
DB
Bausteinende
5.4
BE
Kontrollstrukturen
Hier sind den Entwicklern der SPS-Syntax bunt gemischt deutsch-englische Symbole
eingefallen.
Funktion
Symbol
unbedingter Sprung
SP
bedingter Sprung
SPB
Bemerkungen
19
Funktion
Symbol
Bemerkungen
unbedingter Unterprogrammaufruf
UC
UC FB 1
bedingter Unterprogrammaufruf
(Conditional Call)
CC
CC FB 5
Unterprogrammaufruf
mit Parameterübergabe
CALL
CALL FB 2 IN1:=M1.0
6
Übung 1:
Schreiben Sie ein SPS-Programm, dass folgende Logikfunktion realisiert
A0.1 := (E0.0 ∧ E0.1) ∨ E0.2 .
(1.1)
Testen Sie das Programm im Simulator durch Setzen und Löschen der entsprechenden
Eingänge.
7
Verknüpfungsoperationen
Den Entwicklern der SPS-Syntax ist der Unterschied zwischen Operanden (Signalen) und
Operationen (Verknüpfungen) entgangen. Die führt dazu, dass die Bedeutung von
Anweisungen teilweise von vorangegangenen Anweisungen abhängt. Das ist natürlich
ausgesprochen schwer verständlich und fehleranfällig. Aufgrund der unsauberen Syntax
gibt es natürlich nur unsaubere Lösungen für das Problem, dass mit der Struktur der SPS
für Bit-Operationen erklärt werden kann.
Für Bit-Operationen steht ein spezieller “Akku” (nicht zu verwechseln mit den Akkus für
BYTE-, WORD- und DWORD-Operationen) zur Verfügung.
Der “Akku” für Bit-Operationen ist das VKE (Verknüpfungsergebnis).
Eine syntaktisch “saubere” UND-Verknüpfung hätte folgendes Aussehen:
Speichere letztes Ergebnis
(STORE)
Lade Bit E0.0
(LOAD Signal)
Lade Bit E0.1
(LOAD Signal)
UND-Verknüpfung
(OPERATION)
Speichere A0.0
(STORE Signal)
20
Da Laden & Verknüpfen leider in der SPS syntaktisch untrennbar verbunden sind, sieht das
Programmfragment ist der SPS folgendermaßen aus
=
A0.5
(STORE)
U
E0.0
(LOAD + UND?)
U
E0.1
(LOAD + UND = OPERATION)
=
A0.0
(STORE)
Die Lösung der SPS besteht darin, dass die erste Operation nach einer Speicherung nicht
als UND-Operation interpretiert wird, sondern als LOAD-Operation. Das UND in der
Anweisung “U E0.0” wird also gar nicht ausgewertet. In der SPS-Sprache spricht man von
VKE-Begrenzung durch einer Speicher-Operation. Das hat zur Folge, dass folgender
Programmteil exakt die gleiche Wirkung hat:
=
A0.5
(STORE)
O
E0.0
(LOAD)
U
E0.1
(LOAD + UND = OPERATION)
=
A0.0
(STORE)
Dies ist natürlich noch schlechter lesbar als das erste Beispiel. Die folgende Tabelle listet
die VKE-begrenzenden Operationen auf. Danach wird eine Verknüpfungsoperation
lediglich als “LOAD” interpretiert.
Funktion
Symbol
Beispiel
Zuweisung
=
= M0.0
Klammer auf
U(, O(, X(, UN(, ...
ON( E1.4
Set und Reset
S, R
S A0.2
Zeitoperationen
SE, SA, SV, ...
SI T1
Zähloperationen
ZV, ZR
ZV Z6
Sprungbefehle
SPA, SPB, ...
SPA M002
Rücksprungbefehle
(Returns)
BE, BEB, BEA
BE
8
Schützschaltung
Die SPS hat ihre Wurzeln in der elektronischen Umsetzung von Schützschaltungen. Es ist
deshalb hilfreich für das Verständnis der Elemente einer SPS Schützschaltungen
nachzubilden. Für eine bessere Lesbarkeit der Programme ist es empfehlenswert, mit
symbolischen Namen anstelle der physikalischen Anschlüsse der Ein- und Ausgangsbaugruppen zu arbeiten.
Die symbolischen Bezeichnungen werden in einer Symbolik-Datei verwaltet.
21
In der Symbolik-Datei erfolgt die Zuordnung zwischen dem Namen eines Signals und dem
physikalischen Anschluss.
Symbol
Operand
Typ
Not_Aus
Anlage_Ein
Motor_An
E0.0
E0.2
A0.4
BOOL
BOOL
BOOL
Symbolik-Datei
Bild 1.17:
Der Datentyp “BOOL” kennzeichnet ein einzelnes Bit (andere Datentypen sind BYTE,
WORD, DWORD, INT, REAL etc.). Zusätzlich besteht die Möglichkeit, erläuternde
Kommentare zu den Symbolen anzugeben. Wenn sich physikalische Anschlüsse ändern,
muss dies nur noch an einer Stelle in der Symbolik-Datei beschrieben zu werden. In dem
SPS-Programm können die Symbole anstelle der physikalischen Anschlüsse benutzt
werden. Zur Sicherheit fügt die SPS-Software aber auch die Anschlussnamen ein.
Beispiel:
UN
U
=
“Not_Aus”
“Anlage_Ein”
“Motor_An”
Das Programm wird aus diese Weise (auch ohne ausladenden Kommentar) lesbar.
8.1
Übung 2: Umsetzung einer Schützschaltung mit
symbolischen Namen
Die folgende Schaltung soll als SPS-Programm symbolisch programmiert werden.
Überprüfen Sie die Funktion mit dem Simulator.
22
+
Not_Aus
TR1
k1
TR2
K1
Bild 1.18:
Schützschaltung
Die Zuordnung der physikalischen Ein- und Ausgänge zu den Schaltern und der
Schützansteuerung ist beliebig.
9
Speicher
Bisher wurden nur logische Schaltnetze betrachtet, deren Ausgänge eine logische Funktion
aller Eingänge sind. Bei komplexen Steuerungen hängt der Ausgang nicht nur von den
Eingängen ab, sondern auch von sogenannten internen Zuständen (Automat). Diese
Begriffe aus der Digitaltechnik finden sich jedoch leider nicht in den Beschreibungen zur
SPS wieder, so dass auf viele Erkenntnisse aus der Automatentheorie bei der SPS verzichtet
werden muss.
Ein Ein-Bit-Speicher wird in der SPS als RS-Flip-Flop behandelt (dieser Begriff wird in der
SPS-Sprache auch nicht verwendet). Ein RS-Flip-Flop lässt sich asynchron setzen (S) oder
rücksetzen bzw. löschen (R).
S
Q
R
Bild 1.19:
RS-Flip-Flop (Speicher)
R
S
Q
23
Ein “1”-Signal am S-Eingang setzt den Ausgang auf “1”. Durch ein “1”-Signal am
“R”-Eingang löscht den Ausgang. Der Ausgang bleibt auch erhalten, wenn beide
Eingangssignale “0” sind. Das Flip-Flop speichert damit eine Information von einem Bit.
Die linke und rechte Version unterscheiden sich durch den Zustand R = S = “1”. Das
Flip-Flop links wird durch diesen Zustand gelöscht (= “Rücksetzdominanz”), das Rechte
gesetzt (= “Setzdominanz”). Der Typ Flip-Flops wird durch implizit durch die Reihenfolge
bei der Programmierung bestimmt.
U
E0.1
S
A0.2
U
E0.2
R
A.02
// Rücksetzdominanz
U
R
U
S
E0.2
A0.2
E0.1
A.02
// Setzdominanz
Die letzte Anweisung (R) oder (S) bestimmt den Typ des Speichers. Schaltungstechnisch
kann das RS-Flip-Flop als “Selbsthalteschütz” aufgefasst werden.
9.1
Übung 3: Programmieren ein RS-Flip-Flop mit Setzund Rücksetzdominanz
Programmieren Sie eine AWL für beide Versionen und überprüfen Sie das Ergebnis.
10
Ablaufsteuerungen (Automaten)
In den meisten Fällen besteht eine Steuerung nicht nur aus logischen Funktionen, sondern
auch aus internen Zuständen. Das entstehende System nennt man auch Automat oder
sequenzielle Schaltung.
Es bestehen grundsätzlich zwei verschiedene Architekturen für Zustandsautomaten, die
sich in der Verwendung der Eingangssignale unterscheiden.
Zustandsautomat = Erzeugung von Ausgangssignalen als Folge von Eingangssignalen
und Zustandsgrößen. Zustandsgrößen sind die Inhalte von Speichern (Flip-Flops).
In der SPS wird jeder Zustand durch einen eigenen Speicher (Merker) kodiert
(One-Hot-Encoding). Für einen Automaten verwendet man dagegen häufig eine minimale
Anzahl an Speichern, d.h. mit n Speichern werden 2 n Zustände kodiert.
24
Die Zustandsgrößen werden jeweils synchron durch ein Clock-Signal neu gesetzt. Dieses
Clock-Signal nennt man auch Taktsignal. Man nennt diese Systeme deshalb auch getaktete
Systeme.
Komplexe digitale Systeme wie Mikroprozessoren oder Anlagensteuerungen sind
immer getaktete Systeme
Man unterscheidet sogenannte Moore- und Mealy-Maschinen.
neuer
Zustand
Eingänge
u
Next-State
Logic
Zustand
State
Memory
F(u,x)
x
Ausgänge
Output
Logic
y
G(x)
Clock Input
Clock
Bild 8.1:
Moore-Maschine
Ausgänge
neuer
Zustand
Zustand
Output
Logic
u
Eingänge
Next-State
Logic
F(u,x)
State
Memory
x
y
G(u,x)
Clock Input
Clock
Bild 8.2:
Mealy-Maschine
Der offensichtliche Unterschied zwischen beiden Maschinen besteht darin, dass bei der
Mealy-Maschine die Eingangssignale sich unmittelbar auf die Ausgänge auswirken. Bei der
Moore-Maschine hängen die Ausgänge ausschließlich von den Zustandsgrößen ab.
25
Die logischen Funktionen
F(u, x) ,
G(x)
(8.1)
der Moore-Maschine bzw.
F(u, x) ,
G(u, x)
(8.2)
der Mealy-Maschine sind dabei die bekannten logischen Funktionen der vorangegangenen
Kapitel. Das State-Memory besteht aus einer Reihe von Flip-Flops ohne jegliche weitere
Logik.
Diese formale Darstellung eignet sich gut zum Entwurf von komplexen Schaltungen.
Einfache Automaten kann man natürlich auch intuitiv entwerfen.
Bei praktischen Anwendungen können einzelnen Teile der Zustandsautomaten auch
entfallen (bis auf die Speicher und die Clock-Leitung natürlich). Beispielsweise können die
Ausgangsgrößen y identisch mit den Zustandsgrößen x sein. Dann entfällt die
Funktion F(x).
10.1
Beispiel: Ampelsteuerung
Eine einfache Ampelsteuerung für eine Fahrtrichtung muss mindestens die Zustände in
Bild 8.3 beherrschen.
Zustand
Bild 8.3:
0
1
2
3
Minimaler Satz von Zuständen für eine Ampel
Natürlich existieren bei einer realen Ampelanlage wesentlich mehr Zustände (Ampel der
Kreuzungsfahrbahn, Fußgängerampel, Blinken des gelben Lichtes bei Störungen oder im
Nachtbetrieb usw.). Wir wollen aber zunächst nur die Ampelphase gemäß Bild 8.3
verwirklichen, die sich zyklisch wiederholen soll.
Zu Beginn müssen wir die Eingangs-, Ausgangs- und Zustandsgrößen definieren, mit denen
wir die Aufgabe lösen können.
EINGANGSGRÖSSE u: Reset-Signal, mit dem die Ampel auf “rot” geschaltet wird
(soll Active-Low sein, d.h. ’0’ bedeutet “Reset”).
ZUSTANDSGRÖSSEN x: Es existieren 4 Zustände. Dafür benötige wir 2 Bits, d.h. wir
benötigen 2 Flip-Flops (z.B. D-Flip-Flops).
26
AUSGANGSGRÖSSEN y: rot, gelb, grün (Ansteuersignale für die einzelnen Lampen).
Für dies Aufgabe ist eine Moore-Maschine geeignet, da sich die Ausgangsgrößen
unmittelbar aus den Zustandsgrößen ableiten lassen.
10.1.1
Next-State-Logic (Eingangslogik) F(u, x)
Wenn u = ’0’, dann soll immer der Zustand 0 generiert werden, anderenfalls der jeweilige
Folgezustand. Wir können hier nicht die aus der Digitaltechnik bekannte Wahrheitstabelle
benutzen, da in einer SPS die Zustände i.a. durch einzelne Bits kodiert wird und nicht als
binäre Kodierung.
10.1.2
Output-Logic (Ausgangslogik) G(x) (Moore-Maschine)
Hier muss die Zuordnung der Zustände zu den Ansteuersignalen für die einzelnen Lampen
generiert werden.
10.1.3
State-Memory (Zustandsspeicher)
Wie bereits erwähnt setzt man bei der SPS keine binäre Kodierung der Zustände an,
sondern ordnet jedem Zustand ein einzelnes Flip-Flop zu. Von diesen Flip-Flops darf nur
jeweils ein einziges gesetzt sein. Folgt ein Übergang von einem Zustand zu einem
Folgezustand, so ist das Flip-Flop für den alten Zustand zu löschen; das jeweils neue
Flip-Flop wird gesetzt (One-Hot-Encoding).
10.2
Zustandsdiagramm
Das Verhalten eines Zustandsautomaten lässt sich im Zustandsdiagramm verdeutlichen.
Jeder Zustand wird durch einen Kreis symbolisiert; Pfeile kennzeichnen die möglichen
Übergänge. An den Pfeilen sind wird die Bedingung notiert, unter der der Übergang
erfolgt. Steht an einem Pfeil kein Bezeichnung, so erfolgt der Übergang im nächsten Takt.
27
u = ’0’
u = ’0’
“0”
rot
u = ’1’ & T0
“1”
rot/gelb
u = ’0’
u = ’1’ & T1
u = ’1’ & T3
“3”
gelb
Bild 8.4:
11
u = ’1’ & T2
“2”
grün
Zustandsdiagramm für die Ampelsteuerung
Verwirklichung mit SPS
Eine SPS kennt kein “Clock”-Signal. Anstelle des “Clock”-Signals steht bei der SPS
ein Zyklus (meist des OB1).
Viele Elemente der SPS sind für ganz bestimmte Funktionen entwickelt worden. Die im
folgenden beschriebene Verwirklichung setzt diese Elemente in einer typischen Art und
Weise ein. Elegantere aber weniger konventionelle Lösungen sind natürlich ebenfalls
denkbar. In SPS-Kreisen verwendet man eine spezielle Form der Zustandsgrafen, die mehr
an ein Flussdiagramm erinnert.
28
vorhergehender Schritt
WeiterschaltBedingungen
Zustands-Nummer
Rücksetzen
Ausgänge
Merker-Nummer
nachfolgender Schritt
Bild 1.20:
Schritt (Zustand) einer Ablaufsteuerung (in Anlehnung an DIN40719)
Jedem Zustand ist ein Merker zugeordnet, der als RS-Flip-Flip geschaltet wird. Die
Ampelsteuerung bekommt dann folgende Struktur.
29
Start
0
rot (A0.0)
M0.0
T3 ∨ Start
1
Start
rot (A0.0)
M0.1
T0
2
Start
M0.2
rot (A0.0)
gelb (A0.1)
T1
3
Start
gruen (A0.2)
M0.3
T2
4
Start
M0.4
1
Bild 1.21:
gelb (A0.1)
(= Sprung auf Zustand 1)
Ablaufsteuerung für die Ampel in einer Richtung
Das folgende Programm zeigt die Umsetzung der einzelnen Zustände. Es werden für jeden
Zustand jeweils die Setz- und Rücksetzbedingungen aufgeführt.
Es muss sichergestellt werden, dass nur ein Merkerbit, d.h. ein Zustand aktiv ist.
Dieser Vorgang entspricht der Aufstellung der Ausgangslogik F(x).
Es folgt die Ausgangslogik G(x), in der die Zuordnung zwischen den Ausgangsgrößen
(Lampen der Ampel) und den Zustandsgrößen (Merkern) erfolgt.
ORGANIZATION_BLOCK OB1
TITLE= ”Zyklisches Hauptprogramm”
NETWORK
//Ablaufsteuerung Ampel
30
// Zustand 0 (initial)
UN
E0.0
S
M
0.0
U
M
0.1
R
M
0.0
// Zustand 1 (rot)
U
E0.0
U
M
O
U
M
U
T
S
M
ON
E0.0
O
M
R
M
0.0
0.4
3
0.1
0.2
0.1
// Zustand 2 (rot/gelb)
U
M
0.1
U
T
0
S
M
0.2
ON
E0.0
O
M
0.3
R
M
0.2
// Zustand 3 (gruen)
U
M
U
T
S
M
ON
E0.0
O
M
R
M
// Zustand 4 (gelb)
U
M
U
T
S
M
ON
E0.0
O
M
R
M
// ------- outputs
O
M
O
M
O
M
=
A0.0
0.2
1
0.3
0.4
0.3
0.3
2
0.4
0.1
0.4
0.0
0.1
0.2
O
O
=
M
M
A0.1
0.2
0.4
U
=
M
A0.2
0.3
// -------U
L
SE
timer
M
S5T#2S
T
0.1
0
// Rot-Phase
31
U
L
SE
M
0.2
S5T#750MS
T
1
// Rot-gelb-Phase
U
L
SE
M
S5T#2S
T
// Gruen-Phase
0.3
2
U
M
0.4
L
S5T#1S
SE
T
3
END_ORGANIZATION_BLOCK
11.1
// Gelb-Phase
Übung: Erweiterung der Ampelsteuerung um die
Funktion “Blinken des gelben Lichts”
Ist eine Ampelanlage außer Betrieb, so muss dies durch Blinken des gelben Lichts
angezeigt werden. Verwenden Sie dazu den Eingang u. Ist u = ’0’, so soll das gelbe Licht
blinken. Für u = ’1’ soll der normale Ampelzyklus ablaufen.
a)
Definieren Sie alle benötigten Zustände. Wieviele Flip-Flops werden benötigt?
b)
Zeichnen Sie ein Zustandsdiagramm für diese Zustände mit den Übergangsbedingungen.
c)
Schreiben sie eine Anweisungsliste und überprüfen Sie die Funktion.
12
Zeiten und Zähler
Zeitbedingungen und Zählaufgaben treten in Steuerungen häufig auf. Eine SPS stellt eine
Anzahl von verschieden Timern und einen Zähler zur Verfügung.
12.1
Zeiten (Timer)
Es stehen 4 verschiedene Timer zur Verfügung. Auf diese Weise kann durch Auswahl des
geeigneten Timers zusätzliche Logik eingespart werden.
Die Timer-Versionen SI und SE werden am häufigsten eingesetzt.
Timer sind wie RS-Flip-Flops mit einen zusätzlichen Zeitbedingung, d.h. ein
Timer-Ausgang kann gesetzt (S) und rückgesetzt (R) werden. Von der
Rücksetzbedingung macht man jedoch wenig gebrauch, da nach Ablauf der Zeit
automatisch die Rücksetzbedingung greift.
32
Eine Spezialität der SPS sind natürlich wieder Ausnahmen, die eine intuitives Verständnis
der Funktionen unmöglich machen. Beispielsweise führt bei den Funktion SI und SE der
Übergang 1 → 0 ebenfalls zum Rücksetzen des Ausgangs. Dieses “Feature” ist natürlich
gut gemeint, aber höchstgradig inkonsistent.
In den folgenden Diagrammen wird auf Beispiele für den Rücksetzeingang verzichtet, da
die Aufgabe des (R)-Eingangs ohne Ausnahmen klar ist.
SI
U
L
SI
Bild 1.22:
E0.0
E0.0
S5T#3s
T0
T0
Ablauf des Timers
SI (Impuls)
Mit SV lässt sich ein Impuls maximaler Breite erzeugen. Wenn der S-Eingang auf “0” geht,
wird auch der Ausgang “0”.
SV
U
L
SV
Bild 1.23:
E0.0
E0.0
S5T#3s
T0
T0
Ablauf des Timers
SV (verlängerter Impuls)
Die Breite des Impulses kann die den S-Eingang nicht verkürzt werden. Ein Wiedertriggern
des Timers ist möglich (0→1-Übergang des Eingangs). Der Timer startet dann erneut.
Dieser Fall ist im Diagramm nicht dargestellt.
SE
U
L
SE
Bild 1.24:
E0.0
E0.0
S5T#3s
T0
T0
Ablauf des Timers
SE (Einschaltverzögerung)
Nach Ablauf des Timers wird der Ausgang gesetzt, vorausgesetzt, der Eingang ist noch
aktiv. Diese Funktion wird gewöhnlich gewählt, wenn Zeitbedingungen einzuhalten sind.
33
SA
U
L
SA
Bild 1.25:
E0.0
E0.0
S5T#3s
T0
T0
Ablauf des Timers
SA (Ausschaltverzögerung)
Dies ist die einzige Timerfunktion, bei der die negative Flanke des Eingangssignals
ausgewertet wird, d.h. wenn im aktuellen Zyklus der Wert E0.0==”0” ist und im
vorangegangenen Zyklus E0.0==”1” war. Nach Ablauf des Timers wird der Ausgang
auf “0” gesetzt. Der Eingang muss dazu aber “0” sein (s. Diagramm 1.25).
12.2
Beispiel für den Einsatz von Timern:
Rechteckgenerator
Mit einem Eingangssignal soll ein Rechteckgenerator eingeschaltet und ausgeschaltet
werden, der das in Bild 1.26 dargestellte Signal abgibt.
A0.0
1s
Bild 1.26:
Ausgang des Funktionsgenerators
Man benötigt zwei Timer, die mit den Zeiten 333ms sowie 667ms geladen werden. Eine
exakte Realisierung ist aufgrund von Zykluszeiten im Bereich einiger Millisekunden
ohnehin nicht möglich. Die Entwicklungssoftware wird evtl. die Zeiten je nach Möglichkeit
der SPS ändern, falls eine ms-Auflösung nicht gegeben ist.
Da die Timer auch als RS-Flip-Flop aufgefasst werden können, sind für die Zustände keine
weiteren Flip-Flops (als Merker) notwendig. Die Timer selbst sind die Zustandsgrößen der
Ablaufsteuerung.
TITLE= ”Zyklisches Hauptprogramm”
//Rechteckgenerator mit 1Hz und 1:2 Pulsverhaeltnis
// Timer 0
U
E
0.0
UN
T
1
L
S5T#330MS
SV
T
0
// Timer 1
U
E
0.0
UN
T
0
L
S5T#660MS
34
SV
T
1
// Ausgang
U
T
0
=
A
0.0
12.3
Zähler
Es existiert nur ein Zählertyp, der als Baustein in einem Funktionsplan (FUP) folgende
Form aufweist. Aus dieser Darstellung werden leicht alle Funktionen ersichtlich.
Z5
Bild 1.27:
vorwärts
rückwärts
ZV
ZR
Setzen
Zählerstand
BCD
Rücksetzen
S
ZW
R
DU
DE
O
Zahlerstand dual
Zählerstand BCD
Ausgang binär
Zählerbaustein
Mit ZV und ZR werden die positiven Flanken der betreffenden Signale gezählt. Der
Zähler kann jederzeit auf einen bestimmten Zählerstand gesetzt werden. Der Zählerstand
muss 16 Bit BCD-kodiert vorliegen. Das Auslesen des Zählerstands (mit L) kann dual oder
BCD erfolgen. Der logische Ausgang liefert ein “0”-Signal, wenn der Zählerstand null ist.
Anderenfalls ist der Ausgang “1”.
Beispiele für den Umgang mit einem Zähler (angenommen Zähler 5).
12.4
u
ZV
E0.0
Z5
// Vorwärtszählen mit E0.0
u
ZR
E0.1
Z5
// Rückwärtszählen mit E0.1
u
L
S
E0.3
C#100
Z5
L
LC
Z5
Z5
// Laden der Zahl 100 BCD-kodiert -> Akku
// mit positiver Flanke an E0.3 wird
// Z5 geladen (mit 100)
// Zählerstand dual
// Zählerstand BCD
Übung: Vorwärts-/Rückwärtszähler mit Anzeige
Es soll ein ladbarer Vorwärts-/Rückwärtszähler programmiert werden, der den aktuellen
Zählerstand auf einer BCD-Anzeigebaugruppe ausgibt. Eingänge:
35
E0.0
E0.1
E0.2
13
Zähler laden mit 12
Zählen vorwärts
Zählen rückwärts
Steuerung einer Ofenanlage
Nachdem alle Elemente einer SPS behandelt wurden, können wir nun eine in der Industrie
vorkommende vollständige Steuerung entwerfen. Es handelt sich um die Steuerung einer
Ofentür, wie sie bei sogenannten Glühöfen für die Wärmebehandlung von Stahl oder
Aluminium benötigt wird.
S1
S2
Tür
Ofen
y2
Öffnen
Bild 1.28:
Li
y1
Schließen
Halt
Ofentüranlage
Die Ein- und Ausgänge des Prozesses sind:
Eingänge:
Öffnen
E0.0, “1” = Taster betätigt
Schließen
Halt
S1
E0.3, “1” = Endschalter Tür offen betätigt
S2
E0.4, “1” = Endschalter Tür geschlossen betätigt
Li
E0.4, “1” = Objekt im Türbereich
Ausgänge:
y1
“1” = Tür schließt
y2
“1” = Tür öffnet
Die Signale werden zur besseren Lesbarkeit in Steurungsprogrammen oft symbolisch
deklariert. Es existiert dann eine Datei, in der den physikalischen Signalen symbolische
36
Namen gegeben werden. Besser (flexibler) wäre eine umgekehrte Zuordnung, wie es
beispielsweise VHDL vorsieht.
Randbedingungen:
1. y1 und y2 dürfen nicht gleichzeitig betätigt werden.
2. Nach 5 Sekunden muss die Tür automatisch schließen, damit der Ofen nicht
auskühlt.
3. Wenn die Lichtschranke anspricht, muss ein Schließvorgang unterbrochen
werden.
4. Ist der Ofenbereich wieder frei, so soll der Schließvorgang wieder fortgesetzt
werden.
Es ist erstrebenswert, eine Steuerung mit einer minimalen Anzahl von Zuständen zu
verwirklichen. Natürlich ist es immer möglich, zuviele Zustände aufzustellen, z.B. “Tür
offen”, “Tür schließt”, “Tür geöffnet” und “Tür öffnet”. Dies verkompliziert jedoch den
Entwurf und ist folglich auch fehleranfälliger als eine minimale Realisierung.
Wir benötigen hier nur zwei Zustände “Tür öffnet” sowie “Tür schließt”, wenn wir die Fälle
“Tür offen” und “Tür geschlossen” als in den Schaltern S1 und S2 gespeichert auffassen.
Weiterhin wird noch ein Timer benötigt, um das Schließen der Tür einzuleiten, falls nicht
der Taster “Schließen” gedrückt wird.
“Öffnen”
Öffnen
0
M0.1 v S1 v “Halt”
M0.0
“Schließen” v T0
Schließen
1
M0.0 v S2 v “Halt”
Bild 1.29:
y1 := M0.0
y2 := M0.1 & Li
M0.1
Logik für Ofentürsteuerung
Die Zustände sind gegenseitig verriegelt. Da der Ausgang y1 identisch mit dem
Zustand M0.0 ist, könnte auch der Ausgang als Zustand geführt werden.
Schreiben Sie eine SPS-Anweisungsliste, in der Sie die Steuerung nach Bild 1.29 umsetzen.
14
CPU
Die S7 -CPU kann als virtuelles Rechenwerk verstanden werden, d.h. eine CPU, die jede
Zeile der Anweisungsliste (AWL) in Hardware abarbeiten kann. In der SPS befindet sich
37
ein Mikroprozessor, der die virtuelle CPU emuliert. Die Hersteller legen i.a. nicht offen,
woraus ihre tatsächliche Hardware besteht. Für den Anwender ist dies jedoch auch von
untergeordneter Bedeutung. Bei einer Soft-SPS, d.h. einer Emulation der SPS auf einem
PC, führt dann die CPU des PCs (Intel, AMD, Sun, etc.) dann alle Berechnungen aus.
Für das Verständnis der Befehle und vor allem der Einschränkungen der SPS ist eine
Kenntnis der internen Abläufe innerhalb der SPS-CPU hilfreich. Bei der Fehlersuche
(Debugging) werden die internen Register und Statusbits benötigt. Eine Teil der
Entwicklungssoftware, der sogenannte Debugger liefert den Zustand aller internen
Register und Statusbits nach jeder Anweisung, wodurch sich alle Berechnungen detailliert
nachvollziehen lassen.
Akkumulatoren
Adressregister
Stack
Akku 1
AR 1
BIE
OR
VKE
FK
1
Akku 2
AR 2
BIE
OR
VKE
FK
2
BIE
.
.
.
BIE
OR
.
.
.
OR
VKE
.
.
.
VKE
FK
.
.
.
FK
3
Akku 3
Nur S7-400
Akku 4
DB-Register
DB1 (DB)
Stack-Pionter
DB2 (DI)
Status-Word
KLSP
8
BIE
Bild 1.30:
7
7
6
5
4
3
2
1
0
A1 A0 OV OS OR STA VKE ER
Register der virtuellen SPS-CPU
Der Registersatz der SPS-CPU ist primitiv und durch die gelegentliche Nummerierung von
1..n (anstelle von 0..n-1) auch etwas inkonsistent. Für die Automatisierungstechnik hat die
Struktur jedoch den Vorteil, dass sicherheitskritische Programmteile detailliert
nachvollziehbar sind. Bei Kenntnis des internen Aufbaus und der squenziellen
Abarbeitung des Programms werden auch scheinbar komplexe Phänomene wie Speicher
mit “Rücksetzdominanz” verständlich. Diese Eigenschaft erklärt sich aus der Tatsache,
dass einfach alle Befehle sequenziell abgearbeitet werden. Wenn also ein Rücksetzbefehl
nach dem Setzbefehl für ein RS-Flip-Flop steht, wird halt das Flip-Flop zuerst gesetzt und
dann zurückgesetzt. Die letztere Anweisung hat also Priorität über das erste Auftreten
eines entsprechenden Befehls.
38
Zum Vergleich sei an dieser Stelle die ARM7-CPU gezeigt (Bild 1.31). Bei dieser CPU
kann der Ablauf von Programmen aufgrund der RISC-Struktur (reduced instruction set
computer) nicht einfach nachvollzogen werden.
Bild 1.31:
ARM7 Core ( Advanced Risc Maschines)
Die vier bzw. zwei Akkus der SPS-CPU werden für logische und arithmetische Operationen
verwendet. Die Akkus arbeiten dabei wie ein Stack, d.h. bei Lade-Operationen wird der
Akku 1 beschrieben und der Inhalt das Akkus 1 wird zuvor nach Akku 2 kopiert.
Anschließend gibt man die Operation zwischen beiden Akkus an (z.B. Addition = “+I”).
Die Adressregister verwendet man für die indirekte Adressierung, d.h. Operationen
beziehen sich auf die Adresse, die sich in den ARi-Registern befindet.
Die DB-Register enthalten die Nummer des verwendeten Datenbausteins. Das
DI-Register enthält die Nummer des sogenannten Instanzbausteins bei Verwendung von
FBs (Funktionsblöcken). Diese Register werden in der Regel nicht explizit gesetzt. Durch
Angabe des Datenbausteins beim Zugriff (“L DB10.variablex”) erfolgt die richtige
Belegung der DB-Register automatisch.
Der Stack wird nur für Bit-Operationen benötigt. Die Verwaltung des Stacks wird ebenfalls
von der Entwicklungssoftware übernommen. Im Debugger ist eine Kenntnis über den
Aufbau des Stacks zur Überprüfung von Zwischenergebnissen jedoch hilfreich. Jede
Klammerebene benötigt eine weitere Stufe im Stack. Somit dürfen auch nicht mehr als 7
Klammerebenen benutzt werden. Allerdings wird dann das Programm auch unübersicht-
39
lich. Man arbeitet deshalb besser mit Zwischenergebnissen, d.h. mit Merkern. Die Bits im
Stack haben die gleiche Bedeutung wie im Statuswort mit Ausnahme von “FK”. Die
Funktionskennung (FK) gibt die Operation bei Öffnen einer Klammer an (also “U”, “O”,
“X” etc.).
Die einzelnen Bits des Statuswortes können direkt ausgewertet werden (über “L STW”
bzw. “T STW”). In der Praxis erweist es sich allerdings selten als notwendig, auf das
Statuswort direkt zuzugreifen. Die Bedeutung der einzelnen Bits des Statuswortes ist im
folgenden aufgeführt.
Bit
Name
Bedeutung
0
ER
“Erstverknüpfung”
Dies ist das “Reparaturbit” für die unsaubere
Step 7-Syntax, bei der die erste Operation unabhängig
vom Befehl als Lade-Befehl zu interpretieren ist.
Nach Zuweisungen wird ER = 0 gesetzt, d.h. U E0.4 ist
dann ein Lade-Befehl.
1
VKE
“Verknüpfungsergebnis”
Dies ist das aktuelle Ergebnis einer logischen
Bit-Operation (Akku für Bit-Operationen).
2
STA
“Status-Bit”
Wert des letzten Operanden, der VKE beeinflusst hat.
3
OR
“ODER-Flag”
Wird mit dem Befehl “O” (ODER) gesetzt.
4
OS
“Overflow-speichernd”
Dieses Bit speichert einen aufgetretenen Überlauf
(Overflow) aus arithmetischen Operationen. Bei dem
bedingten Sprung SPS (Verzweigung bei Overflow) wird
dieses Bit wieder zurückgesetzt.
5
OV
“Overflow”
Überlauf bei arithmetischer Operation.
6
A0
7
A1
Diese Bits speichern das Ergebnis einer
Vergleichsoperation. Der Wert dieser Bits wird für
bedingte Sprünge ausgewertet.
8
BIE
15
“Binärergebnis”
Verwendung intern als Zwischenspeicher für VKE.
Prozesse in einer SPS-Applikation
In einer SPS-Anwendung können mehrere Prozesse existieren, die mit unterschiedlichen
Prioritäten ablaufen. Die Prozesse werden OBs (Organisationsblöcke) genannt. Die
Prozessnummern sind dabei fest vergeben. Falls ein OB mit einer bestimmten Nummer
40
existiert, kann er ausgeführt werden, wenn die entsprechenden Bindungen für seine
Ausführung erfüllt sind.
Die möglichen Prozesse sind in Bild 1.32 aufgeführt.
Neustart
OB100
Start
Zyklusbetrieb
Ereignisgesteuerter Betrieb
(Interrupts)
OB10---17
Zeit
Uhrzeit
Asynchron
Hintergrund
Bild 1.32:
Wiederanlauf
OB101
Kaltstart
OB102
OB1
OB20---23
Verzögerung
OB30---38
Weckalarm
OB40---47
Prozess
OB70,72,80
Fehler
OB90
SPS-Prozesse (Organisationsblöcke)
Die Startprozesse werden genau einmal durchlaufen und lassen sich für die Initialisierung
der Steuerung benutzen. Die SPS setzt alle Variablen und Flip-Flops auf null. Für viele
Anwendungen ist dies ausreichend. Falls Variablen bzw Speicher auf bestimmte Werte zu
Beginn gesetzt werden müssen, bietet sich eine der Initialisierungsprozesse OB100, OB101
oder OB102 an (auch mehrere können eingesetzt werden).
Anschließend wird er OB1 zyklisch durchlaufen (s. Bild 1.33). Eine Vielzahl von
Anwendungen benutzt lediglich den OB1. Der OB1 muss in jeder Anwendung existieren.
Er darf auch leer sein (OB1 enthält keine Anwendungszeilen). Der OB1 enthält allerdings
nicht nur die programmierten Anweisungen, sondern besitzt eine Überwachung und stellt
die Verbindung zwischen den physikalischen Ein-/Ausgängen und dem Prozessabbild her.
Der OB1 besitzt eine Zykluszeitüberwachung. Sollte die Zykluszeit überschritten werden,
so ist die ordnungsgemäße Funktion nicht mehr gegeben. Es wird dann der
Fehlerbehandlungsblock OB80 aufgerufen, der die Anlage in einen sicheren Zustand
überführen kann (i.a. wird die Anlage dann abgeschaltet). Es folgt die Übertragung der
physikalischen Ein-/Ausgänge in das Prozessabbild. Abschließend werden alle
Anweisungen abgearbeitet und der OB1 beginnt erneut.
41
Zyklusüberwachungszeit
starten
PAs schreiben
(ins Prozessabbild)
PEs lesen
(aus Prozessabbild)
OB1-Anweisungen
abarbeiten
Bild 1.33:
Struktur des OB1
Die SPS-Firmware verwaltet eine Reihe asynchroner Ereignisse, welche über System
Functions (SFCs) verwaltet werden. Die freigegebenen asynchronen OBs müssen natürlich
existieren. Eine sehr häufig benutzte asynchrone Funktion ist der OB35, der periodisch in
einem bestimmten zeitlichen Raster aufgerufen wird. Damit lassen sich z.B. Regler mit
einer konstanten Abtastzeit verwirklichen.
16
Fehlersuche
Die SPS-Entwicklungssoftware überprüft lediglich, ob die Anweisungen syntaktisch richtig
sind. Es können leicht fehlerhafte Programme eingegeben werden, die einen Übergang der
SPS in den Zustand “Stop” übergeht.
Programmfehler, die erst bei Ablauf des Programms erkannt werden, nennt man
Laufzeitfehler.
Der Abschnitt befasst sich mit Gründen für Laufzeitfehler und mit der systematischen
Suche nach Laufzeitfehlern.
Als Beispiel dient folgendes Programm bestehen aus OB1, FC1 und FC2.
OB1:
UC
FC
1
42
FC1:
UC
FC
2
U
U
=
L
UN
L
=
M
E
A
W#16#55AA
E
DBW
A
0.0
0.0
0.1
FC2:
0.1
2
0.0
Dieses Programm lässt sich fehlerfrei in die SPS laden. Die SPS lässt sich jedoch nicht
permanent in den Zustand “Run” schalten, da die SPS sofort in den Zustand “Stop”
übergeht. Der Grund liegt ein einer Anweisung, die die SPS nicht ausführen kann.
Diese Stelle lässt sich über den sogenannten Diagnosepuffer auffinden. Unter
AG--->Baugruppenzustand, Unterpunkt “Diagnose” sind Ereignisse wie Start, Stop oder
Fehler aufgelistet. Hier findet sich die Fehlermeldung
“Fehler beim Zugriff auf einen Datenbaustein über das DB-Register, FC2”.
Betätigt man dann den Button “Baustein öffnen” gelangt man in den betreffenden
Funktionsblock. Die Zeile, die den Fehler ausgelöst hat, ist farblich markiert. In unserem
Beispiel ist dies die Zeile
L
DBW
2 .
Es wird versucht, auf einen Datenbaustein zuzugreifen, der nicht existiert. In einem solchen
Fall geht die SPS-CPU automatisch in den Zustand “Stop”.
Nicht alle Fehler lassen sich über den Diagnosepuffer auffinden. Hier hilft die
Untersuchung des “Stacks” weiter, indem detailliert der Zustand der CPU vor dem Fehler
protokolliert ist. Ebenfalls kann zurückverfolgt werden, welchen Weg das Programm zu der
fehlerhaften Stelle genommen hat. Unter AG--->Baugruppenzustand, Unterpunkt
“BStack/UStack/LStack” kann auf diese Informationen zugegriffen werden. Man erkennt
zunächst, welche Blöcke aufgerufen wurden. Da die Liste mit FC2 endet, ist dort also der
Fehler aufgetreten.
Wählt man diesen Baustein aus und betätigt den “UStack”-Button, so erhält man alle
Registerinhalte zum Zeitpunkt des Abbruchs, sowie die Information, an welcher Adresse
innerhalb des betreffenden Blockes der Fehler aufgetreten ist. Der Button “Baustein
öffnen” führt dann an die fehlerhafte Stelle des betreffenden Funktionsblocks.
Bei komplexeren Fehlern (z.B. Feldgrenzenüberschreitungen bei Arrays) ist die Weg über
den Stack die einzige Möglichkeit, Fehler aufzufinden.
17
Logische Operationen auf Wortebene
Häufig sind logische Funktionen, die mehrere Bits umfassen, wesentlich effizienter als
logische Bitoperationen. In einer SPS lassen sich logische Funktionen auch auf WORDs
43
(16 Bit) und DWORDs (32 Bit) anwenden. Mn kann auf diese Weise einfach ganze
Gruppen von Signalen (z.B. Schaltern) mit einem Befehl verarbeiten. Eine Verarbeitung
auf Byte-Ebene ist nicht möglich; es stehen nur WORD- (16 Bit) und DWORD-Operationen (32 Bit) zur Verfügung. Die Berechnungen erfolgen im Akku 1, der auch das Ergebnis
hält. Der zweite Operand befindet sich entweder im Akku 2 oder wird als Konstante auf
der Befehlszeile mit angegegeben.
Auch hier zeigt sich ein Hang zur Inkonsistenz, da nicht alle Operationen auf Bit-Ebene
auch auf WORD- bzw. DWORD-Ebene möglich sind.
Logische Operationen für WORDs (16 Bit):
Operator
Bedeutung
UW
UND
OW
ODER
XOW
XOR (Antivalenz)
Logische Operationen für DWORDs (32 Bit):
Operator
Bedeutung
UD
UND
OD
ODER
XOD
XOR (Antivalenz)
Die Operationen werden bitweise, jeweils für die Bits gleicher Wertigkeit zweier Worte
durchgeführt. Befehle wie z.B. UN existieren für WORD- und DWORD-Operationen
nicht.
Beispiel: Es soll festgestellt werden, ob mindestens ein Signal aus einer Gruppe von 8
Signalen ungleich null ist.
L
UW
L
<>I
=
EB
0
W#16#00FF
0
A
0.0
Hier wurde allerdings bereits die Vergleichsoperation auf null verwendet, die erst in
Abschnitt 18.1 beschrieben wird. Man kann leicht erkennen, dass sich das Programm leicht
auf 16 oder auch 32 Signale anpassen lässt.
18
Algebraische Berechnungen
In einer SPS lassen sich algebraische Berechnungen durchführen, wie sie z.B. bei der
Messwertverarbeitung oder auch bei digitalen Reglern und Filtern anfallen. Die
44
SPS-Syntax für algebraische Berechnungen ist ist an die übrige Syntax für logische
Funktionen angelehnt. Als Konsequenz steht man vor einer Programmieraufgabe, die man
als “Strafe für sündige Mönche” missverstehen könnte. Im Vergleich zu allen anderen
Programmiersprachen wird hier auf jeden lästigen Komfort verzichtet, der einem die
Arbeit erleichtern könnte.
Die folgenden elementaren Datentypen setzt man für algebraische Berechnungen ein.
Bezeichnung
Datentyp
Wortbreite
BYTE
Character
8 Bit (wird selten für
Berechnungen verwendet)
INT
Integer (signed)
16 Bit
DINT
Integer (signed)
32 Bit
WORD
Integer (unsigned)
16 Bit
DWORD
Integer (unsigned)
32 Bit
REAL
Real (single precision)
32 Bit
Selbstverständlich existieren keine intrinsischen Operationen ( außer MOD), die auf alle
Datentypen anwendbar sind. Zu jedem Datentyp existiert somit ein Satz von zulässigen
Operatoren.
Operatoren für 8 Bit Festkommazahlen (BYTE):
Operator
Bedeutung
INC <n>
Addition der Zahl n zum Akku 1
(0 ≤ n ≤ 255)
Akku 1 := Akku 1 + n
DEC <n>
Subtraktion der Zahl n vom Akku 1
(0 ≤ n ≤ 255)
Akku 1 := Akku 1 --- n
Operatoren für 16 Bit Festkommazahlen (INT und WORD):
Operator
Bedeutung
+I
Addition: Akku 2 + Akku 1
---I
Subtraktion: Akku 2 --- Akku 1
*I
Multiplikation: Akku 2 * Akku 1
/I
Division: Akku 2 / Akku 1
SLW
Akku 1 Schieben nach links,
MSB ---> A1, 0 ---> LSB
SRW
Akku 1 Schieben nach rechts,
0 ---> MSB, LSB ---> A1
45
Operator
Bedeutung
SSI
Akku 1 Schieben nach rechts mit Kopie des Vorzeichens
VZ ---> MSB, LSB ---> A1
MOD
Modulo-Operation (Rest der Division Akku 2 / Akku 1)
INVI
Inversion aller Bits (Einerkomplementbildung)
NEGI
Negation (Zweierkomplementbildung)
Operatoren für 32 Bit Festkommazahlen (DINT und DWORD):
Operator
Bedeutung
+D
---D
*D
/D
SLD
Akku 1 Schieben nach links,
MSB ---> A1, 0 ---> LSB
SRD
Akku 1 Schieben nach rechts,
0 ---> MSB, LSB ---> A1
SSD
Akku 1 Schieben nach rechts mit Kopie des Vorzeichens
VZ ---> MSB, LSB ---> A1
RLD <n>
Akku 1 Rotieren nach links um n Bits
b31 ---> A1 (Bit 31 wird jeweils in Statusbit A1
kopiert)
RRD <n>
Akku 1 Rotieren nach rechts um n Bits
b0 ---> A1 (Bit 0 wird jeweils in Statusbit A1 kopiert)
RLDA
Akku 1 Rotieren nach links durch das Statusbit A1
(33 Bit Rotation)
RRDA
Akku 1 Rotieren nach rechts durch das Statusbit A1
(33 Bit Rotation)
MOD
Modulo-Operation (Rest der Division Akku 2 / Akku 1)
INVD
Inversion aller Bits (Einerkomplementbildung)
NEGD
Negation (Zweierkomplementbildung)
Operatoren für 32 Bit Fließkommazahlen (REAL):
Operator
Bedeutung
+R
---R
46
Operator
Bedeutung
*R
/R
SIN / COS / TAN
trigonometrische Funktionen
z.B. Akku 1 := sin(Akku 1)
ASIN / ACOS / ATAN
inverse trigonometrische Funktionen
z.B. Akku 1 := asin(Akku 1)
LN / EXP
transzendente Funktionen: natürlicher Logarithmus und
Exponentialfunktion
SQR / SQRT
Quadrat- und Quadratwurzel-Funktion
NEGR
Negation (Multiplikation mit ---1.0)
ABS
Absolutwertbildung
18.1
Auswertung algebraischer Operationen
Neben der eigentlichen Berechnung von Zahlenwerten müssen die Ergebnisse oft mit
Zahlenwerten verglichen werden, um beispielsweise Grenzwerte überprüfen zu können.
Grundsätzlich werden bei Vergleichsoperationen die beiden Akkus (Akku 1 und Akku 2)
miteinander verglichen und als boolsches Ergebnis das VKE-Bit gesetzt bzw. gelöscht.
Die SPS kennt weder generische Vergleichsoperationen, noch erfolgt einer Überprüfung,
ob der Vergleich mit den richtigen Datentypen durchgeführt wird. Bei sicherheitskritischen
Anwendungen, sollten Vergleiche deshalb besonders untersucht werden.
Alternativ bietet sich der Einsatz modernerer Programmiersprachen wie ST (Structured
Text), C++ oder Java an. Die Siemens SPS erlaubt die Verwendung von ST, Ge-Fanuc
gestattet ST sowie ANSI-C.
Jeder Vergleich besteht aus dem Vergleichsoperator und einem Postfix, das den Typ angibt.
Beispiel:
<=D
Hier ist “<=” der Vergleichsoperator “kleiner gleich” und D das Postfix für den Datentyp
DWORD (32 Bit Integer).
Postfix-Kennung für Datentypen (Vergleiche):
Postfix
Bedeutung
I
16 Bit Integer
D
32 Bit Integer
R
Real
47
Kennungen der Vergleichsoperatoren:
Operator
Bedeutung
==
Akku 2 = Akku 1 (gleich)
<>
Akku 2 ≠ Akku 1 (ungleich)
<
Akku 2 < Akku 1 (kleiner)
<=
Akku 2 ≤ Akku 1 (kleiner gleich)
>
Akku 2 > Akku 1 (größer)
>=
Akku 2 ≥ Akku 1 (größer gleich)
18.2
Konversion zwischen Zahlensystemen
Die Daten für Ein-/Ausgaben (Anzeigen oder Sensoren) unterscheiden sich häufig von
Rechengrößen in der Zahlendarstellung. Deshalb werden gelegentlich Umwandlungen in
andere Zahlenformate erforderlich. Die Standard-Operationen zur Datentypwandlung
sind im folgenden zusammengefasst (INT = 16 Bit Integer, DINT = 32 Bit Integer).
Operator
Bedeutung
ITD
Umwandlung INT ---> DINT
ITB
Umwandlung INT ---> BCD
DTB
Umwandlung DINT ---> BCD
DTR
Umwandlung DINT ---> REAL
BTI
Umwandlung BCD ---> INT
BTD
Umwandlung BCD ---> DINT
RND+
Umwandlung REAL ---> DINT mit Rundung auf
nächstgrößere ganze Zahl (ceil)
RND---
nächstkleinere ganze Zahl (floor)
RND
nächstliegende ganze Zahl (round)
TRUNC
Umwandlung REAL ---> DINT (ganzzahliger Teil
einer Fließkommazahl, entspricht RND--- für positive
Zahlen)
19
Beispiel: Einlesen von Temperaturdaten und
Darstellung auf Siebensegmentanzeige
Es werde angenommen, dass die Temperatur als 32 Bit Integer in Vielfachen von
Milli-Fahrenheit vorliegt. Die Anzeige soll BCD-kodiert in Grad Celsius mit zwei
48
Vorkomma- und zwei Nachkommastellen erfolgen. Die Umrechnungsformel zwischen
Fahrenheit und Grad Celsius lautet
˚C = 5 (Fahrenheit − 32) = 0.55555555 (Fahrenheit − 32) .
9
(1.2)
Nachfolgend ist eine Beispiellösung (ohne Kommentar) angegeben. Versuchen Sie, die
einzelnen Programmschritte nachzuvollziehen.
L
L
ITD
-D
DTR
L
*R
L
/R
L
*R
RND
DTB
T
L#60000
32000
// 60 Fahrenheit
5.000000e+00
9.000000e+00
1.000000e-01
AW
0
Man kann erkennen, dass sich die Entwickler der SPS alle erdenkliche Mühe gegeben
haben, jegliche Eleganz und jeglichen Komfort bei der Programmierung zu vermeiden.
Die Lösung ist noch unvollständig, da die Über- bzw. Unterschreitung des darstellbaren
Temperaturbereichs nicht abgefangen wird. Die Anzeige würde bei negativen
Temperaturen oder Temperaturen größer als 99,99 ˚C nur Unsinniges darstellen. Das
Programm ist so zu erweitern, dass Unter- und Überlauf anzeigt werden sollen und dass die
Anzeige auf zulässige Werte beschränkt bleibt.
// 1.: 60F,
L
//
L
//
L
2.: 600F, 3.: -1F
L#60000
L#600000
L#-1
L
-D
DTR
L
*R
L
/R
L
*R
RND
T
L#32000
L
<I
0
5.000000e+00
9.000000e+00
1.000000e-01
#Temperature
49
Z000
Z001
=
SPBN
L
T
A
2.0
Z000
L#0
#Temperature
:NOP
L
L
>I
=
SPBN
L
T
1
#Temperature
9999
:NOP
L
DTB
T
1
#Temperature
A
2.1
Z001
L#9999
#Temperature
AW
0
Die gleiche Funktion mit ANSI-C könnte zum Vergleich viel kürzer und lesbarer ausfallen:
Fahrenheit = 60000;
// = 600000; = -1;
Deg_Celsius = 5.0 / 9.0 * (Fahrenheit - 32000);
Temperature = floor(Deg_Celsius + 0.5);
sys$clrBit(2, 0);
sys$clrBit(2, 1);
if (Temperature < 0)
{
Temperature = 0;
sys$setBit(2, 0);
}
else if (Temperature > 9999)
{
Temperature = 9999; sys$setBit(2, 1);
}
sys$displayW(0, Temperature);
Leider ist die Programmierung von SPS-Geräten nur bei wenigen Herstellern in höheren
Programmiersprachen möglich (z.B. GE-FANUC). Höhere Programmiersprachen sind
deutlich weniger fehleranfällig und sparen Entwicklungszeit.
20
Beispiel: Berechnung von Scheinleistung und
Blindleistung aus gemessenen Werten von
Strom und Wirkleistung
Wir nehmen an, dass Strom I (in mA) und Wirkleistung P (in W) gemessen werden. Daraus
lassen sich bei symmetrischer Drehstromlast Scheinleistung S und Blindleistung Q
berechnen (U beträgt 400V)
S = 3 UI ,
(1.3)
50
Q = S2 − P2 .
(1.4)
Die Berechnung soll in einer Funktion mit Parameterübergabe erfolgen. Das Programm
wird dadurch modular aufgebaut. der Funktionsblock FC kann dann auch in anderen
Projekten verwendet werden.
Der OB1 versorgt die Funktion FC1 mit den Daten
I = 1000 mA,
P = 500 W
und gibt die Rechenergebnisse auf Siebensegmentanzeigen aus (AW0 = S, Scheinleistung
und AW2 = Q, Blindleistung).
OB1:
CALL FC1
Phase_Curr:=L#1000
Act_Power:=L#500
Tot_Power:=MD0
React_Power:=MD4
L
MD
0
DTB
T
AW
0
L
MD
4
DTB
T
AW
2
FC1:
7
L
DTR
L
*R
T
RND
T
L
DTR
T
L
*R
T
L
L
*R
L
-R
SQRT
RND
T
#Phase_Curr
6.928200e-01
// 0.001*400*sqrt(3)
#tpwrx[1]
// S
#Tot_Power
#Act_Power
#tpwrx[2]
#tpwrx[2]
#tpwrx[2]
#tpwrx[1]
#tpwrx[1]
// P^2
// S^2
#tpwrx[2]
#React_Power
Hinweis: Die Variable tpwrx ist ein lokales Array mit zwei REAL-Elementen. Die
Deklaration erfolgt im Kopf des FC1:
tpwrx ARRAY [1..2] OF REAL;
51
21
Regelungen mit SPS
Eine SPS kann auch Regelaufgaben übernehmen, d.h. es werden Größen aus dem Prozess
gemessen (Regelgrößen) und Signale erzeugt, die den Prozess wieder beeinflussen. Es
entsteht ein geschlossener (Regel-) Kreis.
SPS
u
D
Regler
A
y
Prozess
A
D
Bild 1.34:
Regelung mit analoger Regelgröße y und analoger Stellgröße u
Häufig sind die Ein- und Ausgangsgrößen eines Prozesses analoger Natur, d.h. es handelt
sich um kontinuierliche Größen. Beispielsweise bei einer Drehzahlregelung eines
Gleichstrommotors liefert eine Tachomaschine eine Spannung, die der Drehzahl
proportional ist, während der Regler ein analoges Signal für den Strom des
Servoverstärkers erzeugen muss.
21.1
Schaltende Regler
Bei vielen Anwendungen --- insbesondere bei Temperaturregelungen --- ist das
Eingangssignal u für den Prozess nicht analog sondern digital. Der Regler erzeugt dann
keine analoges Signal, sondern ein digitales Signal.
SPS
Regler
u
Prozess
y
A
D
Bild 1.35:
Regelung mit analoger Regelgröße y und digitaler Stellgröße u
Bei einer Temperaturregelung wird die Temperatur in eine analoge Spannung oder einen
analogen Strom umgesetzt (Regelgröße y). Die Stellgröße u ist digital, d.h. der Prozess
52
wird beispielsweise mit dem digitalen Signal
angesteuert.
21.1.1
“Heizung aus”
und
“Heizung ein”
Übung: Temperaturregelung (schaltender Regler)
Schreiben Sie eine SPS-Anweisungsliste für eine Temperaturregelung. Die Heizung soll
eingeschaltet werden, wenn die Temperatur unter 240˚C fällt. Beträgt die Temperatur
mehr als 300˚C, so soll die Heizung wieder ausgeschaltet werden. Als Blockschaltbild lässt
sich die Regelaufgabe wie folgt darstellen.
SPS
±30˚
u
w = 270˚
Prozess
y
--A
D
Bild 1.36:
Regelung mit analoger Regelgröße y und digitaler Stellgröße u
Der Sollwert beträgt w = 270˚C. Wird der Sollwert um 30˚C überschritten, so ist die
Heizung auszuschalten. Bei Unterschreitung um 30˚C soll die Heizung wieder
eingeschaltet werden. Die Temperatur pendelt dann periodisch zwischen diesen Werten.
Man nennt dies einen periodischen Grenzzyklus. Die Konfiguration der SPS kann gemäß
Bild 1.37 gewählt werden. In diesem Fall wird die Temperatur als WORD mit einer
Auflösung 0,1˚C gemessen. Ein Messwert von 3226 entspricht somit einer Temperatur von
T = 322,6˚C.
53
Bild 1.37:
Konfiguration der SPS für Temperaturregelung
Auf den Messwert muss mit “PEW” (Peripheriewort) zugegriffen werden, da die SPS nur
Ein-/Ausgangsbits als Prozessabbild zur Verfügung stellt. Der Zugriff mit “L EW 256” ist
syntaktisch zwar richtig, würde aber immer den Wert 0 liefern.
Eine Lösung mit A0.0 als Ansteuersignal für die Heizung ist im folgenden gezeigt.
22
L
L
<I
S
PEW
2400
L
L
>I
R
PEW
3000
A
A
256
0.0
256
0.0
// Temperatur in C
// T zu klein
// Temperatur in C
// T zu gross
Dynamische Regler-Übertragungsfunktionen
Da mit einer SPS beliebige Rechenoperationen durchgeführt werden können, lassen sich
auch Reglerfunktionen mit einer SPS verwirklichen. Bei einem PI-Regler (bzw. bei einem
PID-Regler) handelt es sich um eine dynamische Übertragungsfunktion, deren
Berechnung die numerische Integration einer oder mehrerer Differentialgleichungen
erfordert.
Ein Digitalrechner --- wie die SPS --- kann nicht kontinuierlich neue Werte berechnen. Die
Berechnung erfolgt jeweils in einem festen Zeitraster.
54
Systeme, bei denen die Werte nur noch zu den Abtastzeitpunkten bestimmt werden,
nennet man diskrete Systeme.
Der zeitliche Abstand zwischen den Berechnungen sowie der Ein- und Ausgaben
nennt man Abtastperiode T.
Der Kehrwert der Abtastperiode ist die Abtastfrequenz fS .
Da nun nur noch die Werte zu den sogenannten Abtastzeitpunkten benötigt werden, kann
man von Differentialgleichungen zu den sogenannten Differenzengleichungen übergehen.
Die Differenzengleichungen liefern nur noch die Werte zu den jeweiligen Abtastzeitpunkten und erfordern keine numerische Integration mehr.
Differenzengleichungen erfordern zur Berechnung lediglich eine Addition (anstelle
der Integration bei den Differentialgleichungen).
Die Lösung von Differenzengleichungen ist somit wesentlich einfacher als die Integration
von Differentialgleichungen.
kontinuierliche Funktion
diskrete Funktion
1
Bild 1.38:
2
3
4
5
t
T
Kontinuierliche und diskrete Funktion
Strenggenommen werden nur die Werte der diskreten Funktion zu den Abtastzeitpunkten
bestimmt. Man verbindet die Abtastzeitpunkte aber zu einer sogenannten Stufenfunktion.
Dies entspricht auch genau der Arbeitsweise von D/A-Umsetzern, die einen einmal
eingeschriebenen Wert bis zum nächsten Abtastzeitpunkt konstant halten.
Kontinuierliche System beschreibt man als Übertragungsfunktion mit der unabhängigen
Variablen s. Den Faktor 1/s kann man auch als Integrationsoperator auffassen
t
y(s) = 1s u(s)
⇒
u(τ)dτ + y(0) .
y(t) =
0
(1.5)
55
Zur Beschreibung diskreter Funktionen verwendet man Übertragungsfunktionen mit der
unabhängigen Variablen z. Diese Variable kann über den sogenannten Verschiebeoperator 1/z definiert werden. Der Operator bedeutet eine Verschiebung um einen Abtastschritt
y(z) = 1z u(z)
⇒
y(kT) = u((k − 1)T) .
(1.6)
Das Ausgangssignal y(t) ist also identisch mit dem Signal u(t), nur ist y gegenüber u um
die Abtastzeit T verzögert. Diese Übertragungsfunktion entspricht einer Laufzeit, d.h.
man kann in s schreiben
y(s) = e −Ts u(s) .
(1.7)
Der Zusammenhang zwischen z und s folgt aus dem Vergleich von (1.6) mit (1.7)
1 = e −Ts .
z
(1.8)
z = e Ts .
(1.9)
bzw.
Löst man (1.9) nach s auf, so folgt
s = 1 ln z .
T
(1.10)
Würde man s in einer kontinuierlichen Übertragungsfunktion K(s) oder G(s) ersetzen,
so erhält man eine diskrete Übertragungsfunktion in z. Allerdings enthält die
Übertragungsfunktion dann Ausdrücke der Form ln(z) (transzendente Funktionen) und
wäre damit für weitere Berechnungen wertlos.
Gebrochen rationale Übertragungsfunktionen in z sind wesentlich günstiger zu
handhaben. Wenn man die Exponentialfunktion durch eine gebrochen rationale Funktion
nähert (Padé-Approximation), so kann jede kontinuierliche Übertragungsfunktion in s in
eine gebrochen rationale Übertragungsfunktion in z transformiert werden. Die
Padé-Approximation für die Exponentialfunktion lautet
z=e
Ts
≈
T
s+1
2
− T2 s + 1
.
(1.11)
56
1
0.8
0.6
0.4
0.2
0
---0.2
---0.4
---0.6
---0.8
---1
0
Bild 1.39:
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1
t
Sprungantworten des Laufzeitgliedes und der Padé-Approximation
In Bild 1.39 erkennt man die Approximation des Laufzeitgliedes durch eine gebrochen
rationale Funktion 1. Ordnung (Padé-Approximation). Die Approximation ist umso besser,
je kleiner das Produkt Ts ist. Beispiel: Mit Ts = 0,1 folgt
e 0.1 = 1.10517 ,
0.1
s+1
2
− 0.1
s+1
2
= 1.10526 .
(1.12)
Die Padé-Approximation ist genau für kleine Werte der Abtastzeit T.
Überprüfen Sie (1.11) auch mit dem Wert Ts = ---0,1.
Löst man nun (1.11) nach s auf, so erhält man die Tustin-Transformation
s = 2 z−1
T z+1
22.1
(1.13)
Integrator
Als Beispiel soll der Integrator in die diskrete Form gebracht werden. Aus der
Übertragungsfunktion
K(s) = 1
Ti s
(1.14)
folgt die diskrete Form mit Hilfe der Tustin-Transformation
K(z) = T z + 1 .
2T i z − 1
(1.15)
Die diskrete Übertragungsfunktion ist das Verhältnis von Ausgang y(z) zu Eingang u(z)
57
y(z)
K(z) = T z + 1 =
.
2T i z − 1
u(z)
(1.16)
Multiplizieren wir (1.16) mit u(z) und z-1 so folgt
(z − 1)y(z) = T (z + 1)u(z) .
2T i
(1.17)
Division durch z auf beiden Seiten führt auf
y(z) − 1z y(z) = T u(z) + 1z u(z) .
2T i
(1.18)
Diese Gleichung lässt sich auch einfach im Zeitbereich angeben, da der Operator 1/z
lediglich eine Verschiebung um eine Abtastzeit beschreibt.
y(kT) − y((k − 1)T) = T u(kT) + u((k − 1)T) .
2T i
(1.19)
Löst man (1.19) nach y(kT) auf, so erhält man eine rekursive Berechnungsvorschrift für
den Ausgang
y(kT) = y((k − 1)T) + T u(kT) + u((k − 1)T) .
2T i
(1.20)
Den Vergleich der Sprungantwort (u = 1) des diskreten Systems (1.20) mit der
Sprungantwort des kontinuierlichen Systems
y(t) = t
Ti
(1.21)
zeigt Bild 1.40. Mit der Abtastzeit T = 1s und Ti = 2s folgen für das kontinuierliche
System
y(t) = t
2s
(1.22)
und für das diskrete System
(1.23)
y(kT) = y((k − 1)T) + 0.25 u(kT) + u((k − 1)T) .
kontinuierliche Funktion
3
2
1
diskrete Funktion
1
Bild 1.40:
2
3
4
5
t
T
Sprungantworten von kontinuierlichem und diskretem System
58
Man erkennt, dass das diskrete System eine sinnvolle Approximation des kontinuierlichen
Systems ist.
22.2
PI-Regler
Der kontinuierliche PI-Regler
K(s) = V R
T ns + 1
Tns
(1.24)
lässt sich mit Hilfe der Tustin-Transformation (1.13) ebenfalls in ein diskretes System
überführen, indem die Variable s in (1.24) entsprechend ersetzt wird. Hierzu ist es
günstiger, den PI-Regler in die Form
K = VR 1 + 1
T ns
(1.25)
zu bringen, da hier nur einmal die Variable s auftritt. Damit folgt
K(z) = V R 1 + T z + 1 .
2T n z − 1
(1.26)
Ersetzt man
z+1
z−1
(1.27)
z−1+2=1+ 2 ,
z−1
z−1
(1.28)
durch
so entsteht ein besonders vorteilhafte Darstellung des diskreten PI-Reglers
K(z) = V R
2T n + T
1 = k + ki .
+ VR T
p
2Tn
Tn z − 1
z−1
(1.29)
Die Parameter des diskreten PI-Reglers sind dann
kp = V R
2T n + T
,
2T n
ki = V R T .
Tn
(1.30)
Mit dem Verschiebe-Operator 1/z lässt sich der diskrete PI-Regler als Blockschaltbild
zeichnen.
59
kp
Limit
u(k)
ki
xki (k+1)
1
z
y(k)
xki (k)
Begrenzungen
Bild 1.41:
Blockschaltbild des diskreten PI-Reglers
Zusätzlich eingezeichnet sind Begrenzungen des Ausgangs, da der Ausgang y häufig
bestimmte Werte nach unten oder oben nicht überschreiten darf. Theoretisch würde die
rechte Begrenzung genügen; jedoch könnte dann xki (kT) beliebig große Werte annehmen.
Kehrt u(k) dann das Vorzeichen um, würde es sehr lange dauern, bis xki wieder kleine
Werte annimmt (es handelt sich ja um einen Summationsvorgang). Die Begrenzung des
Signals xki nennt man auch “Anti-Windup”. Man verhindert damit eine “Sättigung” des
Reglers.
Der PI-Regler erfordert gemäß Blockschaltbild 1.41 somit die Berechnungen
y(k) = k pu(k) + x ki(k) ,
x ki(k + 1) = x ki(k) + k iu(k) .
(1.31)
Anschließend ist dann zu prüfen, ob sich y außerhalb des zulässigen Bereichs befindet.
Falls dies der Fall ist, muss y begrenzt werden. Entsprechend ist dann auch xki auf sinnvolle
Werte zu begrenzen. Im folgenden wird gezeigt, wie der PI-Regler auf einer SPS
verwirklicht werden kann.
60
Bild 1.42:
Konfiguration der SPS für einen Regler mit analogen Ein- und Ausgängen
OB1: <keine Anweisungen>
OB101: (Initialisierung)
L
0
T
DB1.xki
L
4.000000e-02
T
DB1.TSample
L
1.500000e+00
T
DB1.Vr
L
9.000000e-01
T
DB1.Limit
L
2.000000e+00
T
DB1.Tn
// Brerechnung kp und ki
L
DB1.TSample
L
2.000000e+00
/R
L
DB1.Tn
/R
L
1.000000e+00
+R
L
DB1.Vr
*R
T
DB1.kp
L
DB1.TSample
61
L
/R
L
*R
T
DB1.Tn
DB1.Vr
DB1.ki
OB35: (zyklischer Interrupt = “Weckalarm”)
L
PEW
256
ITD
DTR
L
3.618982e-05
*R
T
DB1.sig_u
L
DB1.kp
*R
L
DB1.xki
+R
T
DB1.sig_y
L
DB1.Limit
>R
SPBN Z000
// y > Limit
T
DB1.sig_y
L
DB1.sig_u
L
DB1.Vr
*R
L
DB1.sig_y
-R
NEGR
T
DB1.xki
L
0
<R
SPBN Z004
T
DB1.xki
SPA Z004
Z000
:NOP 1
L
DB1.sig_y
L
DB1.Limit
NEGR
<R
SPBN Z003
// y < -Limit
T
DB1.sig_y
L
DB1.sig_u
L
DB1.Vr
*R
L
DB1.sig_y
-R
NEGR
T
DB1.xki
L
0
>R
// 1/27648
// output
62
SPBN Z004
T
DB1.xki
SPA Z004
Z003 :NOP 1
// no limit: integrate
L
DB1.sig_u
L
DB1.ki
*R
L
DB1.xki
+R
T
DB1.xki
Z004 :NOP 1
// convert to DA format
L
DB1.sig_y
L
2.764800e+04
*R
RND
U
E
0.0
SPB Z005
L
0
Z005 :NOP 1
T
PAW
256
23
PID-Regler
Der PID-Regler unterscheidet sich vom PI-Regler durch den sogenannten D-Anteil. In der
Parallelform (s. Bild 1.43) wird der Unterschied zum PI-Regler deutlich.
kp
u
y
ki
s
kd
Bild 1.43:
P
t *s
s
+1
I
D
PID-Regler in Parallelform
Die Übertragungsfunktion des PID-Reglers lautet somit
k
.
K(s) = k p + si + k d * s
t s+1
(1.32)
63
Fasst man die drei Terme zusammen, so entsteht die Serienform des PID-Reglers
k d + k pt * s 2 + k p + k it * s + k i
K(s) =
s t *s + 1
.
(1.33)
Eine Umrechnung der Parameter der Standardform
K(s) = V R
(T ns + 1) T Ds + 1
(1.34)
T ns t *s + 1
in die Parameter kp , ki und kd der Parallelform kann durch Vergleich der
Polynomkoeffizienten des Zählers erfolgen, wenn (1.34) in die Form
K(s) =
V R T Ds 2 + V R
Tn+T D
Tn s
V
+ TRn
s t *s + 1
(1.35)
gebracht wird. Man erhält
ki =
VR
,
Tn
kp = V R
(1.36)
Tn + TD − t*
,
Tn
(1.37)
T nT D − T n + T D t * + t * 2
kd = V R
.
Tn
(1.38)
Die Umrechnung ist etwas verwickelt, kann aber leicht durch ein Programm erfolgen. Aus
der Parallelform ist die Bestimmung der Serienform sehr viel schwieriger, da hier eine
Berechnung der Nullstellen des Zählerpolynoms erforderlich wird. Es sind außerdem
Parameter kp , ki und kd möglich, die nicht in die Standardform (1.34) gebracht werden
können (es können komplexe Nullstellen entstehen).
Der diskrete PI-Regler wurde bereits behandelt. Der Unterschied zum diskreten
PID-Regler besteht nun nur noch in dem D-Anteil. Der D-Anteil
G d(s) = k d
t *s
s
+1
(1.39)
lautet in diskreter Form
G d(z) =
2 z−1
T z+1
k d 2 z−1
t * T z+1 + 1
=2
=2
kd
z−1
*
t
T 2 (z − 1) + z + 1
T
kd
z−1
.
T 2 t* + 1 z − 2 t * − 1
T
T
(1.40)
64
Eine weitere Umformung von (1.40) führt auf die Form
G d(z) =
2k d
2t *
z−1 ,
+ T z − 2t **−T
2t +T
(1.41)
die für die Berechnung der Differenzengleichung günstiger ist. Eine weitere Vereinfachung
ergibt sich aufgrund von
*
*
*
2t −T
2t −T
2t −T
z − 1 = z − 2t*+T + 2t*+T − 1 = 1 − 1 − 2t*+T
*−T
*−T
*−T
z − 2t
z − 2t
z − 2t
2t *+T
2t *+T
2t *+T
=1−
z
2T
2t *+T
*−T
− 2t
2t *+T
(1.42)
.
Daraus folgt die endgültige Schreibweise
G d(z) =
2k d
2t *
+T
−
4k dT
2t *
+T
1
2
*
−T
z − 2t
2t*+T
(1.43)
.
Wir können die Schreibweise abkürzen, indem wir die Konstanten k1, k2 und z1
verwenden
k
y(z)
G d(z) = k 1 − z −2 z =
u(z)
1
(1.44)
mit
k 1 :=
2k d
2t * + T
,
k 2 :=
4k dT
2t *
+T
2
,
*
z 1 := 2t * − T .
2t + T
(1.45)
Es bietet sich an, die beiden Terme in (1.44) getrennt zu rechnen. Während der erste Term
nur einen Faktor darstellt, erfordert der zweite Term eine zusätzliche Variable
k2
x(z)
z − z 1 = u(z) .
(1.46)
Durch “Hochmultiplizieren” erhält man
zx(z) − z 1x(z) = k 2u(z)
⇒
x(z) − 1z z 1x(z) = 1z k 2u(z) .
(1.47)
Der Operator 1/z (Verschiebeoperator) bewirkt eine Verschiebung um einen Abtastschritt
im Zeitbereich. Die Gleichung (1.47) entspricht somit der Differenzengleichung
x(k) = z 1x(k − 1) + k 2u(k − 1)
oder auch
(1.48)
65
(1.49)
x(k + 1) = z 1x(k) + k 2u(k) .
Der gesamte Algorithmus ist im Blockschaltbild 1.44 dargestellt.
k1
u(k)
y(k)
k2
x(k+1)
1
z
x(k)
---
z1
Bild 1.44:
Algorithmus für D-Glied
Anzumerken ist, dass bei der Berechnung eines vollständigen PID-Reglers der
(proportionale) Faktor k1 der P-Kanal zugerechnet werden kann.
23.1
Beispiel: D-Glied mit kd = 1, t* = 0.333333 und der
Abtastperiode T = 0.1
Mit diesen Daten lauten
k 1 = 2.6087 ,
k 2 = 0.6805 ,
z 1 = 0.7391 .
(1.50)
Die Berechnung von y(k) aus u(k) kann nun leicht durch iterative Lösung der
Differenzengleichung erfolgen. Die Sprungantwort der Übertragungsfunktion
G(s) kont = k p
s
t *s + 1
(1.51)
sowie die diskrete Sprungantwort (u(k) = 1 für alle k ≥ 0) ist im folgenden Bild
gezeichnet.
66
y(t)
y(k)
3.5
3
2.5
2
1.5
1
0.5
0
---0.5
0
Bild 1.45:
0.5
1
1.5
2
2.5
3
t
Sprungantworten des kontinuierlichen und des diskreten Systems
Man erkennt die gute Approximation des kontinuierliche Signals durch die diskrete
Sprungantwort.
24
Berechnung des D-Glieds mit der SPS
Man muss sich zunächst fragen, warum eine detaillierte Behandlung der Berechnung eines
PID-Reglers sinnvoll ist, wo doch ein PID-Algorithmus oft schon Bestandteil einer SPS ist.
Dafür lassen sich zwei Gründe angeben:
Mit Hilfe der beschriebene Tustin-Transformation lassen sich beliebige Übertragungsfunktionen als diskrete Systeme in Form von Differenzengleichungen rechnen. Man ist
somit nicht in der Struktur auf die in der SPS vorhandenen Übertragungsfunktionen
beschränkt.
Die in der SPS vorhandenen Regler sind oft nicht optimal programmiert. Die Regler
können vereinfacht verwirklicht sein oder der Algorithmus für die Begrenzung des
Reglerausgangs ist sehr ungünstig umgesetzt worden. Da die Hersteller ihren
Algorithmus nicht offenlegen, kann der Regler nicht optimal genutzt werden, da
unbekannt ist, wie der kontinuierliche Regler durch einen diskreten Regler approximiert wird.
Das hier vorgestellte Verfahren der “Tustin-Transformation” ist natürlich nicht das einzige
Verfahren zur Verwirklichung diskreter Regler. Die “Tustin-Transformation” ist aber eines
der leistungsfähigsten und besten Verfahren, gleichzeitig aber auch nicht das Einfachste.
67
Das SPS-Programm besteht auch hier --- wie beim PI-Regler --- aus zwei
Organisationsblöcken: dem OB101 für die Initialisierung und dem OB35 für die zyklische
Berechnung der eigentlichen Differenzengleichung. Der OB1 muss existieren, er enthält
aber keinen Programmtext. Üblicherweise würde im OB1 die sogenannte Betriebslogik
behandelt werden (Ein-/Ausschalten, Sicherheitsüberwachung etc.).
OB101: Initialisierung
// Abtastzeit
L
1.000000e-01
T
DB1.T_Samp
// Parameter des D-Glieds
L
1.000000e+00
T
DB1.kd
L
3.333333e-01
T
DB1.t_st
// Koeffizienten fuer Differenzengleichung
L
DB1.t_st
L
2.000000e+00
*R
L
DB1.T_Samp
+R
T
DB1.xtmp
// 2*t*+T
L
DB1.kd
L
2.000000e+00
*R
L
DB1.xtmp
/R
T
DB1.k1
L
2.000000e+00
*R
L
DB1.T_Samp
*R
L
DB1.xtmp
/R
T
DB1.k2
L
DB1.t_st
L
2.000000e+00
*R
L
DB1.T_Samp
-R
L
DB1.xtmp
/R
T
DB1.z1
OB35: zyklischer Interrupt
L
ITD
DTR
L
*R
T
PEW
256
3.616898e-05
DB1.u_real
68
// Ausgang
L
DB1.k1
*R
L
DB1.x1
-R
L
2.764800e+04
*R
RND
T
PAW
256
// Zustandsgroesse x1
L
DB1.k2
L
DB1.u_real
*R
T
DB1.xtmp
L
DB1.z1
L
DB1.x1
*R
L
DB1.xtmp
+R
T
DB1.x1
Die Faktoren 3.616898e-05 bzw. 2.764800e+04 bewirken eine Normierung der
Eingangsspannung bzw. eine Denomierung der Ausgangsspannung auf Werte zwischen -1
und +1. Versuchen Sie, den Algorithmus gemäß Bild 1.44 in OB35 nachzuvollziehen.
25
The Real Thing -- Konfiguration und
Programmierung einer „echten” SPS
Im Prinzip die gleichen Schritte wie im Simulator müssen auch durchlaufen werden, wenn
eine “reale” SPS eingesetzt werden soll. Dies soll am Beispiel der verbreiteten SIEMENS
Simatic S7 -300 erläutert werden. Die Baureihe -300 ist die mittlere SPS-Klasse. Die
S7-200 ist eine sogenannte Kompakt-SPS, die über einen bestimmten Satz an digitalen und
analogen Ein-/Ausgängen verfügt und nur sehr eingeschränkt erweiterbar ist. Die Baureihe
S7-300 ist eine modular aufgebaute SPS, die durch viele unterschiedliche Schnittstellen
erweiterbar ist. Das obere Ende bildet die S7-400 für sehr große Anlagen und
Anwendungen. Auch die S7-400 ist modular aufgebaut.
Als modulares System kann man sich eine SPS aus einzelnen Komponenten
zusammenstellen, so dass sich eine SPS sehr genau auf die speziellen Anforderungen für
eine bestimmte Aufgabe anpassen lässt.
Modulare Systeme bestehen entweder aus einen Gehäuse und Netzteil mit sogenannter
Backplane (Bus, der alle Komponenten mit Strom und Daten-/Adresssignalen versorgt), in
das Baugruppen gesteckt werden können. Ein typischer Vertreter dieser Technik in der
Industrie ist der VME-Bus. Auch PCs mit dem PCI-Bus funktionieren auf diese Weise. Eine
69
Siemens-SPS besitzt ein anderes Konzept, bei der die einzelnen Komponenten ein
geschlossenes Gehäuse besitzen und diese auf einen Blechwinkel (genannt Profilschiene)
gefummelt werden. Die einzelnen Komponenten werden durch sogenannte Busverbinder
miteinander verbunden. Das Siemens-Konzept ist etwas umständlich, aber auch etwas
flexibler als z.B. ein VME-Bus-Gehäuse.
Bei der Konfiguration der SPS müssen eine Reihe von Regeln beachtet werden. Das
folgende Bild zeigt den Maximalausbau einer S7 -300. Es sind maximal 4
Baugruppenträger zugelassen. Der 1. Baugruppenträger darf maximal 11 Komponenten
enthalten (1..11), in allen folgenden Baugruppenträgern dürfen nur Plätze 3..11
(9 Komponenten) benutzt werden. Die maximale Anzahl von Komponenten beträgt damit
11+3x9 = 38 Komponenten. Die einzelnen Baugruppenträger dürfen maximal 10m
auseinander sein.
EXT
4
Link
EXT
EXT
PS
CPU
1
2
Bild 1.46:
EXT
3
6
7
8
9
10
5
6
7
8
9
10
Baugruppenträger 2
11
BaugruppenB8 träger 1
5
6
7
8
9
10
B1
4
11
B8
B1
4
Link
5
B1
4
Link
BaugruppenB8 träger 3
B1
11
B8 Baugruppenträger 0
5
6
7
8
9
10
11
Maximalausbau einer S7 -300
Man beachte die inkonsistente Zählweise der “Steckplätze” (beginnen mit 1) und die der
Baugruppenträger (beginnen mit 0). Die Stromversorgung (PS) sowie die CPU dürfen nur
einmal im gesamten System verwendet werden. Bei der Auswahl der Stromversorgung
70
muss darauf geachtet werden, dass die Leistung für die Versorgung aller Baugruppen sowie
der CPU ausreicht. Man erkennt, dass die ersten 3 Steckplätze für bestimmte Funktionen
reserviert sind.
Steckplatz 1: Stromversorgung (PS = Power Supply)
Steckplatz 2: CPU (312 IFM, 313, 314, 315, 316, 318)
Steckplatz 3: Schnittstelle zur Erweiterung der SPS auf andere Baugruppenträger
Die folgenden Steckplätze können mit Schnittstellen zum oder vom zu steuernden/regelnden Prozess belegt werden.
Obwohl es technisch leicht möglich wäre, dass die CPU im System alle angeschlossenen
Komponenten automatisch erkennt, muss dies recht mühsam vom Betreiber “von Hand”
erfolgen. Die Konfiguration kann dann aber permanent in der CPU gespeichert werden,
so dass die Konfiguration nur bei Änderung der Baugruppen erforderlich ist.
26
Vernetzung von SPS-Geräten
Die Vernetzung von Geräten der Automatisierungstechnik (einschließlich der
Messtechnik) ist erforderlich, wenn großen Anlagen automatisiert werden sollen und eine
Kommunikation zwischen Anlagenteilen erforderlich ist. Man verwendet dazu sogenannte
Busse.
Bus: mehrere Teilnehmer teilen sich gemeinsame Leitungen zur Kommunikation.
Mit dem Bestreben, die Automatisierung in der Fertigung immer weiter voranzutreiben,
entstanden eine Vielzahl einfacher Bussysteme, die inzwischen mit der gleichen
Geschwindigkeit wieder verschwinden, mit der sie aufgekommen waren. Die einfachen
Busse der Automatisierungstechnik halten einem Vergleich mit den Bussystemen der
“gewöhnlichen” Computertechnik nicht Stand. So wird inzwischen in vielen Bereichen der
Automatisierungstechnik gewöhnliches TCP/IP-Protokoll über Ethernet eingesetzt. Dies
verringert Kosten und ist um den Faktor 10..100 schneller als typische “Automatisierungsbusse”.
Auf unterer Ebene (Verbindung zwischen Automatisierungsgeräten, Verbindung zu
Sensoren und Aktuatoren) werden sogenannte Feldbusse eingesetzt.
Feldbusse: einfache Busse für die Automatisierungstechnik.
Man unterscheidet grundsätzlich parallele Busse (z.B. GPIB) und serielle Busse. Bei
seriellen Bussen erfolgt die Datenübertragung über eine Leitung bzw. über zwei Leitungen
bei zwei Datenrichtungen (Duplex-Betrieb). Moderne Busse sind ausschließlich seriell.
71
Typische Vertreter der Feldbusse sind CAN (Car Area Network), ProfiBus, ASI
(Aktuator-Sensor-Interface), EIB (European Installation Bus). Aufgrund unterschiedlicher Eigenschaften dieser Busse, werden sie in bestimmten Bereichen bevorzugt eingesetzt
(z.B. EIB in der Gebäudeautomation). Ein wesentliches Merkmal der Busse sind ihre
maximalen Leitungslängen.
26.1
RS-485 (MPI/Profibus)
Jede SPS-CPU muss über eine Schnittstelle verfügen, um das Programm und die
Konfiguration in die CPU vom Entwicklungssystem übertragen zu können. Diese
Schnittstelle ist der serielle Bus nach der RS-485-Norm. Bei Siemens wird diese
Schnittstelle MPI (Multi-Point-Interface) genannt und mit einer Übertragungsrate von
187,5 kBit/s betrieben. Zum Vergleich: Ethernet ist um mehr als 500-fach schneller.
Die Leitungslänge darf 50 m nicht überschreiten (Ethernet/UTP-Kabel: 200 m). Werden
größere Entfernungen benötigt, so können “Repeater” eingesetzt werden, die eine
Leitungslänge zwischen den Repeatern von bis zu 1000 m ermöglicht.
Eine Vernetzung nach RS-485 ist in Bild 1.47 dargestellt.
max. 50 m
Leitung A
Rt
Rt
Leitung B
RxD
TxD
Teilnehmer 0
Bild 1.47:
RxD
TxD
Teilnehmer n
RS-485 (Halbduplex-Betrieb
Maximal 32 Teilnehmer können an den Bus angeschlossen werden. Jedem Teilnehmer wird
ein Nummer zugewiesen (0..31), die man als Adresse bezeichnet. Beim RS-485 verwendet
man eine Differenzübertragung, d.h. für den Wert auf dem Bus ist nicht der Pegel der
Leitungen A und B entscheidend, sondern die Differenz zwischen den Leitungen. Es
gelten folgende Zuordnungen
72
0:
u A − u B ≤ − 200mV ,
1:
uA − uB ≥ 200mV .
(1.52)
Die absoluten Pegel auf den Leitungen bewegen sich im Bereich von ca. 0..5V. Die
Leitungen müssen an den Enden (insbesondere bei Ausnutzung der maximalen Länge mit
dem sogenannten Wellenwiderstand der Leitung (folgt aus dem induktiven und kapazitiven
Leitungsbelag)
RW =
L
C
(1.53)
abgeschlossen werden. Der Wellenwiderstand beträgt etwa RW = 120Ω. Man schließt die
Leitung an den Enden mit einem ohmschen Widerstand Rt = 120Ω ab, um Reflexionen
an den Enden zu verhindern. Es bleibt anzumerken, dass bei einer abgeschlossenen
Leitung (mit Widerständen) und der relativ niedrigen Übertragungsrate von 187,5 kBit/s
problemlos wesentlich größere Leitungslängen möglich sind.
Bisher wurde die physikalische Ebene des Busses beschrieben. Die Software bestimmt das
Protokoll des RS-485-Busses. Die Deluxe-Version ist der sogenannte
Profibus
(12,5 MBit/s). Diese Version ist für die SPS als Option verfügbar. Meist erfolgt dies mit
einer eigenen CPU, da die Übertragungsrate von 12,5 MBit/s die SPS-CPU zu stark
belastet kann.
Bestandteil jeder Siemens -SPS ist eine RS-485-Schnittstelle mit 187,5 kBit/s, über die die
Programmierung und Konfiguration erfolgt. Gleichzeitig dient die Schnittstelle zur
Kommunikation unter verteilten SPS-Geräten. Es besteht die Möglichkeit, sogenannte
Globaldaten auf alle SPS-Geräte, die über den RS-485-Bus verbunden sind, zu kopieren.
Die Schnittstelle wird in der Siemens -Welt MPI (Multipoint-Interface) genannt.
Da das Entwicklungssystem (ein Windows-PC, in der Siemens -Welt “PG” = Programmiergerät genannt) nicht über eine RS-485-Schnittstelle verfügt, wird ein Umsetzer von
PC-Schnittstellen auf RS-485 benötigt. Angeschlossen wird der Umsetzer heute
überwiegend an die serielle Schnittstelle (= COM1, COM2, COM3 oder COM4).
Zukünftig dürfte jedoch USB (Universal Serial Bus) zum Einsatz kommen. Die Original
Siemens-Adapter für die serielle Schnittstelle sind in der Geschwindigkeit jedoch auf
38,4 kBit/s beschränkt.
26.2
CSMA/CD und Token-Passing
CSMA/CD und Token-Passing sind Zugriffsverfahren für eine fehlerfreien Betrieb eines
Busses. Bei einem Bus muss ein Zugriffsprotokoll festgelegt werden, da ja nur eine Leitung
für die Übertragung zur Verfügung steht.
26.2.1
CSMA/CD
Man wählt i.a. ein Verfahren, dass einen größtmöglichen Datendurchsatz gewährleistet. Es
hat sich bei der Vernetzung von Computern das CSMA/CD-Protokoll für Ethernet
etabliert.
73
CSMA/CD = Carrier Sense Multiple Access / Collision Detect
Bei diesem Zugriffsverfahren wartet ein Teilnehmer, bis keine Daten mehr übertragen
werden (Carrier Sense) und beginnt sofort mit dem Senden, ohne dass eine Freigabe
erforderlich wäre. Dabei kann es natürlich vorkommen, dass ein weiterer Teilnehmer
ebenfalls sendet. Dies wird durch “Mithören” aber erkannt (Collision Detect). In diesem
Fall brechen beide (oder mehrere Sender) den Sendevorgang ab und warten eine
unterschiedliche (zufällige) Zeit ab, bis ein erneuter Sendeversuch gestartet wird.
Natürlich darf ein Sender nicht beliebig lange senden. Ein “Frame” (Sendepaket) ist auf
eine bestimmte Länge beschränkt (MTU = Maximum Transfer Unit). Da die Wartezeit für
einen bestimmten Sender zufällig ist, kann nur mit statistischen Methoden der Durchsatz
bestimmt werden.
Der große Vorteil bei CSMA/CD ist, dass ein Transfer immer sofort beginnen kann. Es
vergeht also im Idealfall keine Wartezeit, bis Daten übertragen werden können. Die
Kollisionen steigen jedoch an, wenn viele Teilnehmer an einem Segment angeschlossen
sind und viele verschiedene Teilnehmer Daten übertragen müssen.
CSMA/CD ist sehr schnell aber nicht deterministisch.
26.2.2
Token-Passing
Das Token-Passing-Verfahren ist ein deterministischerer Ansatz als CSMA/CD. Allerdings
erfordert das Token-Passing einen “Overhead”, d.h. es wird eine Datenübertragung zur
Verwaltung des Zugriffsverfahren notwendig. Ein Datenpaket (das Token) wird von
Teilnehmer zu Teilnehmer gesandt. Der Teilnehmer, der das Token besitzt, darf den Bus
benutzen und beginnt mit der Übertragung von Daten. Anschließend wird das Token
weiterversandt. Ein Teilnehmer, der keine Daten zu versenden hat, sendet das Token
einfach weiter.
Natürlich ist auch hier die maximal erlaubte Datenmenge beschränkt, die ein Sender
übertragen darf, wenn er das Token “besitzt”. Mit dieser Information und der Anzahl der
Teilnehmer kann man ausrechnen, wie lange es dauert, bis ein Sender spätestens “an der
Reihe” ist. Nachteilig ist, dass alle Teilnehmer ständig mit Datentransfer beschäftigt sind,
auch wenn gar keine Nutzdaten zu übertragen sind.
Die Zugriffssteuerung für RS-485 bei der SPS erfolgt auf der Basis von Token-Passing.
Auch der Profibus basiert auf Token-Passing, jedoch beträgt hier die Übertragungsrate
maximal 12,5 MBit/s. Im folgenden soll der Betrieb der sogenannte MPI-Schnittstelle
(eingebaute RS-485-Schnittstelle in jeder SPS) erläutert werden. Vieles davon lässt sich auf
den Profibus übertragen.
74
EntwicklungsSystem
SPS 1
SPS 2
SPS n
OP
PG
0
Adressen
Bild 1.48:
Anzeige und
Bedienung
1
2
3
n+1
RS-485-Netzwerk (MPI)
Die Enden der Leitung (in diesem Fall das Entwicklungssystem mit der Adresse 0 und die
SPS n) müssen mit Abschlusswiderständen beschaltet werden. Üblicherweise befinden sich
in jedem Anschlussstecker Abschlusswiderstände, die über Schalter aktiviert werden
können.
Jeder Teilnehmer benötigt eine eindeutige Adresse im Bereich von 0..255. Die Adressen
können im Prinzip frei vergeben werden. Es besteht jedoch die sinnvolle Konvention, die
Adressen 0..2 nicht zu verwenden, um für den Servicefall gerüstet zu sein.
Die Adresse 0 sollte für ein Service-Entwicklungssystem (PG = Programmiergerät)
reserviert werden, dass dann einfach zugeschaltet werden kann. Das Gleiche gilt für ein
Service-Bedien- und Anzeigegerät (OP = Operator Panel). Wenn die Adresse 2
freigehalten wird, kann stets eine SPS in Werkseinstellung an das Netz angeschlossen
werden (Adresse 2 = Werkseinstellung).
Von Herstellerseite wird empfohlen, die Leitungslängen zwischen den Geräten auf
maximal 50m zu beschränken. Am Beginn und Ende der Leitung muss ein
Abschlusswiderstand von ca. 120Ω geschaltet werden, um Reflexionen zu verhindern. Wird
dies vergessen, so funktioniert i.a. die Übertragung auch noch, jedoch nehmen
Übertragungsfehler (erkannt durch Parity Errors) zu.
75
27
Konfigurieren einer Siemens -SPS
Ein modulares System --- wie die Siemens S7-300 --- muss konfiguriert werden, d.h. sowohl
der CPU sowie auch dem Entwicklungssystem müssen alle installierten Komponenten
bekannt sein. Die Konfiguration muss außerordentlich umständlich (damit auch
fehleranfällig) “von Hand” eingetragen werden, obwohl sich das System theoretisch auch
selbst konfigurieren und überprüfen könnte. Auf diese Weise soll der Programmierer
vielleicht gezwungen werden, sich “mit dem System vertraut zu machen”.
Die SPS-Software bestimmt dann die Adressen, unter denen auf die Schnittstellen (digital
I/O oder analog I/O) zugegriffen werden kann.
Die Konfiguration umfasst auch die eindeutige Vergabe der RS-485-Adressen, die nach
den vorstehenden Empfehlungen vergeben werden sollten. Wird nur eine SPS mit einem
Entwicklungs-PC verbunden, so werden oft die Adressen 0 (PC) und 2 (SPS) vergeben oder
sind bereits vom Werk auf diese Adressen eingestellt.
28
Automatisierung einer Tankfüllanlage
Der folgende Prozess soll mit einer realen SPS automatisiert werden.
Y1
Bild 1.49:
Y2
S1
S3
S2
S4
Tankfüllanlage mit 2 Tanks
Über die beiden Schaltventile sollen aus einer Sammelleitung (oben) zwei Tanks gefüllt
werden. Dabei ist zu beachten, dass nur jeweils ein Einlassventil betätigt werden darf. Der
Füllstand kann mit zwei Sensoren pro Tank gemessen werden. Wenn die Sensoren S2 und
S4 das Signal ’0’ liefern, ist der jeweilige Tank leer oder fast leer. In diesem Fall muss der
76
betreffende Tank sofort gefüllt werden. Wird der durch die Sensoren S1 bzw. S2 bestimmte
Füllstand erreicht, so sind die Ventile (durch Y1 bzw. Y2 gesteuert) abzuschalten.
Aufgrund der Anordnung der Füllstandssensoren dürfen bestimmte Messwertkombinationen nicht auftreten (z.B. S1 = ’1’ und S2 = ’0’). Wird ein solcher Fall gemessen, so muss
mindestens ein Sensor defekt sein. In diesem Fall müssen beide Ventile geschlossen werden
und die Anlage soll diesen Fehlerzustand anzeigen. Auch wenn der Fehler wieder
verschwindet, dürfen die Ventile erst wieder nach einem Quittungssignal wieder
eingeschaltet werden.
Was mit Worten beschrieben wurde, lässt sich natürlich viel eindeutiger in Form eines
Zustandsgrafen darstellen, da die Steuerung einen sogenannten “endlichen Zustandsautomaten” bildet.
Steuerungen (Automaten) sollten mit einer minimalen Anzahl von Zuständen
verwirklicht werden.
Wird mehr als die notwendige Anzahl von Zuständen einer Anlage verwendet, wird die
Steuerungsaufgabe komplexer und damit auch fehleranfälliger. Die minimale Anzahl an
Zuständen folgt aus den “Freiheitsgraden” eines digitalen Systems, d.h. den
unterschiedlichen Zuständen, die von Eingangsgrößen abhängen bzw. die die
Ausgangsgrößen beeinflussen.
Ein Zustand ist beispielsweise die Temperatur einer Flüssigkeit im Tank (Temperatur hoch,
Temperatur niedrig). Da bei der Tankfüllanlage die Temperatur weder beeinflusst noch
gemessen werden kann, braucht sie auch nicht für die Steuerung berücksichtigt zu werden.
“0”
Tanks
voll
F1(u)
“1”
Tank 1
füllen
Bild 1.50:
F3(u)
F0(u)
F4(u)
F5(u)
F2(u)
“2”
Tank 2
füllen
Zustandsgraf für die Steuerung der Tankfüllanlage (fehlerfreier Betrieb)
Die Qualität einer Steuerung hängt unter anderem davon ab, wie bzw. ob auf Fehler
reagiert wird. Man müsste Bild 1.50 um Fehlerzustände erweitern. Den Fehlerzustand
zeichnet man besser in ein separates Diagramm (Bild 1.51), da der Übergang in die
Fehlerzustände von jedem Zustand aus gleich erfolgt.
77
Fehler
250ms
“3”
Error 0
Reset
(zum Zustand “0”)
“4”
Error 1
250ms
Bild 1.51:
Zustandsgraf Fehlerzustände
Man erkennt, dass ein einmal aufgetretener Fehlerzustand ausschließlich durch das
“Reset”-Signal wieder verlassen werden kann.
Die nachfolgende Tabelle zeigt die Zuordnung zwischen Zuständen und Ausgängen.
Zustand
Ausgang
0
1
2
3
4
--- (alles aus)
Y1
Y2
Error LED 0
Error LED 1
Der Fehlerzustand soll somit durch ein abwechselndes Blinken zweier LEDs angezeigt
werden. Da zwei unterschiedliche Ausgänge auftreten, müssen auch zwei Zustände
verwendet werden. Ein Fehler in der Sensorik kann erkannt werden, wenn der obere Sensor
einen Füllstand anzeigt, während der untere Sensor das Signal “0” liefert.
S4
S3
S2
S1
Fehler
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
1
0
0
0
0
1
1
1
1
0
0
0
0
1
1
1
1
0
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
0
1
1
1
1
0
1
0
0
0
1
0
0
Im Interesses eines sicheren Betriebs (insbesondere bei Anlagen mit Personengefährdung)
sollten vorrangig Fehler behandelt werden. Es muss folglich die folgende Tabelle
ausgewertet werden. Die boolsche Gleichung lautet
78
(1.54)
Fehler = S 4 ∧ S 3 ∨ S 2 ∧ S 1 .
Wenn der Fehler abgefangen wird, können die entsprechenden Zeilen (Minterme) als
Don’t Care (X) angenommen werden, da diese Fälle dann nicht mehr auftreten können.
Die Tabelle bekommt damit folgende Gestalt (Begründung?):
S4
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
1
S3
0
0
0
0
1
1
1
1
0
0
0
0
1
1
1
1
S2
0
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1
S1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
Zustand
0
1
1
1
X
X
2
2
2
2
X
X
X
X
X
X
X
X
1
1
X
X
1
1
2
2
1
1
X
X
1
1
0
0
2
2
X
2
2
X
X
X
X
1
X
2
2
1
X
1
0
Folgezustände
Auf der rechten Seite stehen keine boolschen Werte sondern jeweils die Folgezustände aus
einem bestimmten Zustand in Abhängigkeit von den Sensorsignalen. Nehmen wir z.B. an,
dass wir uns im Zustand “0” (Tanks voll) befinden. Dann kann von diesem Zustand in die
Zustände “1” oder “2” verzweigt werden. Die entsprechenden Wahrheitstabellen lauten
79
S4
S3
S2
S1
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
1
0
0
0
0
1
1
1
1
0
0
0
0
1
1
1
1
0
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
Folgezustand 1 aus Zustand 0
1
X
0
0
X
X
X
X
1
X
1
0
1
X
1
0
S4 S3
S2 S1
00
01
00
01
11
10
1
X
1
1
X
X
X
X
S1 = 1
11
X
10
X
S2 = 1
1
1
S3 = 1
S4 = 1
Man erhält aus dem Karnaugh-Diagramm eine minimale Form für die Funktion zur
Bestimmung des Folgezustands 1 aus dem Zustand 0 (Funktion F0 aus Bild 1.50)
(1.55)
F0 = S2 ∨ S4 ∧ S1 .
S4
S3
S2
S1
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
1
0
0
0
0
1
1
1
1
0
0
0
0
1
1
1
1
0
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
Folgezustand 2 aus Zustand 0
0
X
1
1
X
X
X
X
0
X
0
1
0
X
0
0
S4 S3
S2 S1
00
00
01
11
10
X
X
X
01
X
X
11
1
X
10
1
1
S1 = 1
S2 = 1
X
S3 = 1
S4 = 1
Es folgt für die Funktion zur Bestimmung des Folgezustands 2 aus dem Zustand 0
(Funktion F2 aus Bild 1.50)
F2 = S4 ∧ S2 ∨ S3 ∧ S1 .
(1.56)
Auf die gleiche Weise lassen sich alle übrigen Bedingungen für die Übergänge zwischen den
Zuständen herleiten (in minimaler Form).
80
28.1
Übung: Verwirklichung der Steuerung
Entwickeln Sie eine Steuerung für die Tankfüllanlage mit einer Siemens -S7. Die
Fehlerbedingungen sollen ausgewertet werden. Bestimmen Sie zunächst alle logischen
Funktionen für die Übergangsbedingungen zwischen den Zuständen in minimaler Form
(Funktionen F0-F5 aus Bild 1.50).
Sie können die Zustände mit Merker-Bits (verbreitete Methode) kodieren. Vermeiden Sie
dabei die Überschneidung von Zuständen, d.h. es dürfen niemals zwei Zustände
“gleichzeitig aktiv” sein. Eine alternative Form ist die Kodierung der Zustände als
Integer-Wert. In diesem Fall können Überschneidungen nicht auftreten.
Die Funktionsfähigkeit (einschließlich Fehlerbehandlung) der Steuerung ist mit einem
Modell der Tankfüllanlage mit einer realen SPS nachzuweisen.
29
Ampelsteuerung mit Belegungserkennung
Eine besondere Schwierigkeit stellen Systeme dar, deren Ablauf nicht durch externe
Signale (z.B. Endschalter, Grenzwerte) bestimmt ist, sondern deren Ablauf weitgehend
“autonom” erfolgt. Dies ist bei einer Ampelsteuerung der Fall. Ein sogenannter Umlauf ist
ein vollständiger Ampelzyklus, der zeitgesteuert erfolgt und nur bedingt durch äußere
Signale (Anforderung durch Fußgänger, Belegung der Fläche vor der Ampel durch
Fahrzeuge) beeinflusst wird.
81
= Belegeungserkennung
rot_2
gelb_2
grün_2
Fahrtrichtung 2
rot_1
gelb_1
grün_1
Fahrtrichtung 1
Bild 1.52:
Kreuzung mit Ampeln und Belegungserkennung
Wir wollen lediglich die Fahrtrichtungen für Fahrzeuge betrachten (keine Fußgängerampeln). In jeder Richtung befinden sich Belegungssensoren, die angeben, ob sich ein
Fahrzeug über dem Sensor befindet. Diese Information soll genutzt werden, um im
Interesse eines möglichst hohen Verkehrsflusses den Ampelzyklus zu beeinflussen.
Es sind zwei grundsätzliche Betriebsarten zu unterscheiden: Normalbetrieb und inaktiver
Betrieb. Bei inaktiv geschalteter Ampel blinken jeweils die gelben Leuchten (Bild 1.53).
Die Zeiten für “Gelb an” und “aus” sind gleich (Tbl ).
82
10
rot_1
11
gelb_1
grün_1
rot_2
gelb_2
grün_2
Tbl
Bild 1.53:
Inaktive Ampelanlage
Die Zustände der Anlage sind sind von 0..11 durchnummeriert. Zu jedem Zustand gehört
eine Zeitbedingung. Die Grünphasen sind jeweils in zwei Abschnitte unterteilt (2-3 sowie
7-8). Nach Ablauf des ersten Abschnitts (2 bzw. 7) kann die Grünphase abgekürzt werden,
wenn die Belegungssensoren ein Fahrzeug in der jeweiligen Gegenrichtung anzeigen. Es
erfolgt dann ein Übergang von 3 → 4 oder 8 → 9 auch vor Ablauf der entsprechenden
Zeit. In den Zuständen 3 und 8 sind also die Belegungssensoren auszuwerten.
0 1 2
3
4 5 6
7
8
9 0
rot_1
gelb_1
grün_1
rot_2
gelb_2
grün_2
TU
Bild 1.54:
Umlauf der Ampelanlage
Das Eingangssignal
Umlaufbetrieb (
soll.
gibt an, ob die Ampelanlage im normalen
= 1) oder im inaktiven Betrieb (
= 0) arbeiten
83
29.1
Strategien zur Kodierung
Von mehreren Autoren über SPS-Programmierung [1], [2] oder [3] wird übereinstimmend
vorgeschlagen, Merker zur Kodierung der Zustände einzusetzen. Ein typisches Fragment
der Anweisungsliste lautet damit:
// Setz- und Ruecksetzbedingung für M0.3 --------------U
M0.2
// alter Zustand
U
E0.0
// zusätzliche Bedingung
S
M0.3
// dies wird der Folgezustand
O
M0.4
// mit dem (Folge-) Zustand M0.4
R
M0.3
// wird der Zustand M0.3 zurückgesetzt
// Setz- und Ruecksetzbedingung für M0.4 --------------U
M0.3
// alter Zustand
U
T 3
S
M0.4
O
M0.5
// mit dem Zustand M0.5
R
M0.4
// wird der Zustand M0.4 zurückgesetzt
Aus der Sicht der Automatentheorie ist diese Vorgehensweise höchst bedenklich, denn es
bestehen eine Reihe gravierender Nachteile:
Es findet keine geschlossene Kodierung von Zuständen statt. Die Setz- und Rücksetzbedingungen gehören zu unterschiedlichen Zuständen.
Es sind für einen Zyklus immer zwei oder mehr Merker (=Zustände) aktiv. Im obigen
Beispiel sind dies die Merker M0.3 und M0.4. Damit ist der Zustand einer Anlagen nicht
mehr eindeutig kodiert. Gewöhnlich hängen von den Zuständen Ausgangsgrößen ab.
Die Art der Programmierung ist fehleranfällig, da für n Zustände n Merker benutzt
werden. Mit den n Merkern lassen sich aber 2 n Zustände beschreiben.
Das System muss initialisiert werden, da immer ein Merker gesetzt sein muss.
Eine Alternative Kodierung von Zuständen kann mit Hilfe einer Integer-Variablen
erfolgen. Alle genannten Nachteile bestehen dann nicht mehr.
Sollen dennoch Merker verwendet werden --- was übliche Praxis ist ---, so wird folgende
Vorgehensweise nahegelegt:
// Kodierung von M0.2 --------------U
M0.2
// gegenwärtiger Zustand
U
E0.0
S
M0.3
R
M0.2
// alten Zustand loeschen
// Kodierung von M0.3 --------------U
M0.3
// gegenwärtiger Zustand
U
T 3
S
M0.4
R
M0.3
// alten Zustand loeschen
84
Die Anweisungsliste ist kürzer, besser lesbar und es treten keine Zustands-Merker doppelt
auf. Allerdings kann dieses Programm nicht als Funktionsplan dargestellt werden, was bei
größeren Anlagen ohnehin keine Rolle spielt.
29.2
Übung: Kodierung der Ampelsteuerung
Die Ampelsteuerung gemäß Bild 1.53 bzw. Bild 1.54 soll programmiert werden. Die
Zustände sind --- wie in der Praxis üblich --- in Merker-Bits zu kodieren. Das
Zustandsdiagramm zeigt Bild 1.55. An den Übergängen zwischen den Zuständen stehen
entweder Zeiten oder externe Signale.
NormBetrieb
rot_1
rot_2
0
Tgelb
NormBetrieb
Trr
gelb_2
9
Anf_1
Tg 22
grün_2
8
2
3
Anf_2
Trg
rot_2
gelb_2
grün_1
Tg 11
7
6
10
Trg
Tg 21
grün_2
rot_1
gelb_1
1
Tbl
gelb_1
gelb_2
Tbl
11
[AUS]
grün_1
Tg 12
4
gelb_1
Trr
Tgelb
5
rot_1
rot_2
Bild 1.55:
Zustandsdiagramm für Ampelsteuerung
1)
Kodieren Sie alle Zustände mit Merkern.
2)
Programmieren Sie die benötigten Timer.
3)
Programmieren Sie die Bedingungen für den Übergang zwischen den einzelnen
Zuständen.
85
4)
Überprüfen Sie die Funktion der Schaltung anhand eines Kreuzungsmodells, das
an die SPS angeschlossen werden kann.
30
Diskrete Regelung (PI-Regler) mit einer SPS
Ein kontinuierlicher Prozess soll mit Hilfe einer SPS mit A/D- und D/A-Schnittstellen
geregelt werden. Dieser Prozess wird durch eine Schaltung mit Operationsverstärkern
nachgebildet.
Bild 1.56:
Operationsverstärker-Schaltung für den kontinuierlichen Prozess
Der erste Operationsverstärker bestimmt die Verstärkung des Prozesses. Die folgenden
OPs sind Verzögerungen 1. Ordnung mit der Verstärkung 1 und den gleichen
Zeitkonstanten
T 1 = RC = 10kΩ 47 F = 0.47s .
(2.10)
Die gesamte Übertragungsfunktion lautet damit
VS
G a(s) =
T1 s + 1
3
.
(2.11)
Mit VS = 1 erhält man
G a(s) =
0.1038s 3
1
.
+ 0.6627s 2 + 1.41s + 1
(2.12)
Der Regler arbeitet mit einer Abtastperiode TS = 100ms. Der Vorgang des “Abtastens”
eines kontinuierlichen Prozesses lässt sich näherungsweise durch die Übertragungsfunktion
G des(s) =
0.0001s 3 + 0.0011s 2 − 0.0947s + 1
0.0053s 4 + 0.1384s 3 + 0.7385s 2 + 1.4653s + 1
(2.13)
beschreiben (Diskretisierung und inverse Tustin-Transformation, soll an dieser Stelle nicht
weiter vertieft werden). Für dieses Problem existiert keine einfache Lösungsvorschrift. Es
86
bietet sich deshalb an, die zwei Parameter des PI-Regler durch Simulation zu ermitteln.
Das folgende MATLAB -Fragment ermöglicht einen iterativen Entwurf der Parameter
VR (Verstärkung) sowie Tn (Nachstellzeit) des PI-Reglers.
function Kc = pidesign(Vr, Tn)
% format: Kc = pidesign(Vr, Tn)
global Gdes uu tt
% inputs:
w, d,
outputs: y, u
Kc = tf(Vr * [Tn 1], [Tn 0]);
T11
T12
T21
T22
=
=
=
=
feedback(Kc * Gdes, 1);
feedback(Gdes, Kc);
feedback(Kc, Gdes);
-feedback(Kc * Gdes, 1);
y11
y12
y21
y22
=
=
=
=
lsim(T11,
lsim(T12,
lsim(T21,
lsim(T22,
uu(:,1),
uu(:,2),
uu(:,1),
uu(:,2),
tt);
tt);
tt);
tt);
plot(tt, [uu y11+y12 y21+y22]);
title(’Continuous PI controller’);
Continuous PI controller
1.6
1.4
Stellgröße
1.2
1
0.8
Regelgröße
0.6
0.4
0.2
Sollwert
Störgröße
0
---0.2
0
Bild 1.57:
5
10
15
20
25
30
Geschlossener Kreis mit schlecht eingestellten Reglerparametern
87
Continuous PI controller
1
Sollwert
0.8
Regelgröße
0.6
Stellgröße
0.4
0.2
Störgröße
0
---0.2
Bild 1.58:
0
5
10
15
20
25
30
Geschlossener Kreis mit brauchbaren Reglerparametern
Sind die Reglerparameter bestimmt (beispielsweise die Parameter, die zur Simulation in
Bild 1.58 gehören), so kann der PI-Regler nach Abschnitt 22.2 programmiert werden.
Sollwert und Störgröße lassen sich ebenfalls programmgesteuert erzeugen.
Die Parameter des diskreten PI-Reglers folgen aus VR , Tn und T gemäß
kp = V R
2T n + T
,
2T n
ki = V R T .
Tn
(2.14)
Mit dem Verschiebe-Operator 1/z lässt sich der diskrete PI-Regler als Blockschaltbild
zeichnen.
kp
Limit
u(k)
ki
xki (k+1)
1
z
y(k)
xki (k)
Begrenzungen
Bild 1.59:
30.1
Blockschaltbild des diskreten PI-Reglers
Übung: Umsetzung als SPS-Programm
a)
Entwerfen Sie geeignete Parameter VR und Tn für den Prozess (2.13).
b)
Bestimmen Sie die Parameter (2.14) des diskreten PI-Reglers.
c)
Schreiben Sie ein SPS-Programm zur Regelung des Prozesses unter
Verwendung von analogen Schnittstellen.
88
d)
Die Anregungen für den Regelkreis (Sollwert und Störgröße) sollen zu
Testzwecken ebenfalls von der SPS erzeugt werden. Verwenden Sie dabei
zyklische Verläufe wie in den Bildern 1.57 und 1.58.
e)
Überprüfen Sie die Übereinstimmung von Berechnung und realer SPS mit dem
Oszilloskop.
Die folgende Lösung dient nur zum Vergleich. Sie sollten Ihr Programm unabhängig von
diesem Programm entwickeln. Das Programm ist natürlich nicht vollständig: gelistet ist
lediglich der OB35; DB1, OB1 und OB101 fehlen.
// setzen von Sollwert ww und Stoergroesse dd
L
DB1.cnt
L
0
==I
SPBN Z101
L
7.500000e-01
T
DB1.ww
Z101 :NOP 1
Z102
L
L
==I
SPBN
L
T
:NOP
Z103
L
L
==I
SPBN
L
T
:NOP
Z104
L
L
==I
SPBN
L
T
:NOP
DB1.cnt
50
Z102
2.500000e-01
DB1.dd
1
DB1.cnt
100
Z103
2.500000e-01
DB1.ww
1
DB1.cnt
150
Z104
-2.500000e-01
DB1.dd
1
// PI-Regler
L
PEW
256
ITD
DTR
L
3.618982e-05
*R
T
DB1.sig_u
L
DB1.ww
// 1/27648
89
L
DB1.sig_u
-R
T
DB1.sig_u
L
DB1.kp
*R
L
DB1.xki
+R
T
DB1.sig_y
L
DB1.Limit
>R
SPBN Z000
// y > Limit
T
DB1.sig_y
L
DB1.sig_u
L
DB1.Vr
*R
L
DB1.sig_y
-R
NEGR
T
DB1.xki
L
0
<R
SPBN Z004
T
DB1.xki
SPA Z004
Z000
:NOP 1
L
DB1.sig_y
L
DB1.Limit
NEGR
<R
SPBN Z003
// y < -Limit
T
L
L
*R
L
-R
NEGR
T
L
>R
SPBN
T
SPA
DB1.sig_y
DB1.sig_u
DB1.Vr
DB1.sig_y
DB1.xki
0
Z004
DB1.xki
Z004
Z003 :NOP 1
// no limit: integrate
L
DB1.sig_u
L
DB1.ki
*R
// output
90
L
+R
T
DB1.xki
DB1.xki
Z004 :NOP 1
// convert to DA format
L
DB1.sig_y
L
DB1.dd
+R
L
2.764800e+04
*R
RND
U
E
0.0
SPB Z005
L
0
Z005 :NOP 1
T
PAW
256
// inkrementieren von cnt (Begrenzung auf 0..199)
L
DB1.cnt
L
1
+I
T
DB1.cnt
L
200
>=I
SPBN Z100
L
0
T
DB1.cnt
Z100 :NOP 1
31
Vergleich der Algorithmen des
SIEMENS -PI-Reglers (FB41) und der
bilinearen Transformation
Der PI- bzw. PID-Regelalgorithmus ist in der SIEMENS-SPS bereits enthalten in Form
einen Funktionsbausteins (FB41) mit zugeordnetem Datenbaustein (DB) zur Parametrierung des kontinuierlichen Reglers
K(s) = V R
T ns + 1
.
Tns
(2.15)
Allerdings verwendet Siemens eine einfachere Diskretisierung, als die in dieser
Veranstaltung behandelte Tustin-Transformation. Die Diskretisierung von Siemens lautet
x i(k) = x i(k − 1) + T u(k) ,
Tn
y(k) = V R u(k) + x i(k) .
(2.16)
91
Dies entspricht der Übertragungsfunktion
K SIEMENS(z) = V R
1 + TTn z − 1
z−1
(2.17)
.
Die Übertragungsfunktion des PI-Reglers der Vorlesung hingegen lautet
K STF(z) = V R
T
T
1 + 2T
z − 1 − 2T
n
n
z−1
(2.18)
.
Die unterschiedlichen Eigenschaften der Regler zeigen sich in den Sprungantworten
(Bild 1.60) und --- wesentlich deutlicher --- im Bode-Diagramm (Bild 1.61). Da der Verlauf
im Bode-Diagramm maßgäblich für die Stabilität einer Regelung ist, kann die
Siemens-Version durch die größeren Abweichungen im Bode-Diagramm zu Problemen
führen.
5
4.5
Siemens
Amplitude
4
3.5
3
2.5
2
STF
1.5
kontinuierlilch
1
0.5
0
0
0.05 0.1
0.15 0.2
0.25 0.3
0.35 0.4
0.45 0.5
Time (sec)
Bild 1.60:
Sprungantworten PI-Regler (VR = 2, Tn = 0.4s, TS = 0.1s)
Man erkennt die gute Approximation der STF-Version im Gegensatz zur Siemens-Diskretisierung.
92
Magnitude (dB)
35
30
25
Siemens
20
15
Phase (deg)
10
5
0
---45
---90
---1
0
10
10
2
1
10
Frequency (rad/sec)
10
Bode-Diagramme PI-Regler (VR = 2, Tn = 0.4s, TS = 0.1s)
Bild 1.61:
Die Beträge im Bode-Diagramm von STF-Diskretisierung und kontinuierlichem Regler
unterscheiden sich nicht.
Diese Unterschiede zeigen zeigen sich natürlich auch im geschlossenen Kreis. Das folgende
Beispiel zeigt das Störverhalten des Reglers mit dem Prozess
G(s) =
1
.
0.128s 2 + 0.72s + 1
(2.19)
Amplitude
0.35
0.3
0.25
0.2
0.15
0.1
0.05
0
---0.05
---0.1
Bild 1.62:
STF
SIEMENS
0
0.5
1
1.5
2
2.5
Time (sec)
3
3.5
Störverhalten der Regler KSTF und KSIEMENS
Der Regelfehler der Siemens-Version ist größer als der des STF-Reglers.
4
93
32
Einsatz des PID-Moduls der SPS
Bestandteil der Siemens -Step7-SPS ist bereits ein PID-Regler als sogenannten
System-Funktionsblock (SFB). Der Funktionsblock ist weitgehend parametrierbar, d.h. die
Betriebsart kann durch viele Parameter festgelegt werden. Dabei ist zu berücksichtigen,
dass der Regler nicht exakt verwirklicht wird, sondern durch Diskretisierung des
kontinuierlichen Reglers und Verzögerungen durch die A/D-Umsetzung beeinflusst wird.
Im folgenden Bild ist Ein- und Ausgangssignal gezeigt, dass von der SPS über einen
A/D-Umsetzer eingelesen und sofort wieder über D/A-Umsetzer ausgegeben wird.
2.5
2
1.5
1
0.5
0
---0.5
---1
---1.5
---2
---2.5
0
Bild 1.63:
0.2
0.4
0.6
0.8
1
1.2
1.4
1.6
1.8
2
Verzögerungen bei der SPS-Signalverarbeitung (Wandelzeit 20ms)
Man erkennt, dass von theoretisch idealen Verlauf Abweichungen um bis 40ms auftreten,
die in der Wandelzeit und der Anzahl der zu wandelnden Kanäle begründet sind. Durch
Konfiguration der entsprechenden A/D-Baugruppe kann die maximal auftretende
Verzögerung auf ca. 5-10ms begrenzt werden.
Insbesondere durch die Art der Diskretisierung unterscheidet sich der diskrete Regler sehr
stark von der kontinuierlichen Variante. Im Abschnitt 23 haben wir die Tustin-Diskretisierung (bilineare Transformation) kennengelernt. Siemens verwendet ein einfacheres
Verfahren, das zu größeren Unterschieden zwischen kontinuierlichem und diskretem
Regler führt. Die Differentialquotient
du(t)
dt
(2.20)
wird durch den “Differenzenquotient”
du(t)
u(k) − u(k − 1)
≈
T
dt
(2.21)
ersetzt, der für T → 0 (Abtastperiode) gegen (2.20) konvergiert. Diese Näherung ist
graphisch in Bild 1.64 gezeigt.
94
u(t)
u(k) − u(k − 1)
T
dt
dt
u(t)
(k-1)T
Bild 1.64:
kT
(k+1)T
t
Näherung der Ableitung durch Differenzenquotient
Am Beispiel in Bild 1.64 wird deutlich, dass die Diskretisierungsfehler mit steigender
Abtastzeit immer größer werden. Bei besseren Diskretisierungsverfahren gilt dies jedoch
nicht generell.
Siemens geht von der Parallelform des PID-Reglers
T s
K SIEMENS = V R 1 + 1 + * V
Tn s T s + 1
(2.22)
aus, um mit dem Modul sowohl P-, I-, PI- sowie PID-Regler realisieren zu können. Am
Beispiel des I-Anteils
1 = y(s) ⇒ T s y(s) = u(s)
n
Tn s
u(s)
(2.23)
sei die von Siemens verwendete Diskretisierung gezeigt werden. Dies entspricht der DGL
Tn
dy(t)
y(k) − y(k − 1)
= u(t) ≈ T n
= u(k)
T
dt
(2.24)
Löst man (2.24) nach y(k) auf, so folgt
y(k) = y(k − 1) + T u(k) .
Tn
(2.25)
Die Sprungantwort des diskreten Integrators liegt immer über der des kontinuierlichen
Integrators. Zum Vergleich ist noch einmal der mit der bilinearen Transformation
berechnete Integrator eingezeichnet.
95
0.7
0.6
kontinuierlich
0.5
0.4
0.3
SIEMENS
0.2
Tustin
0.1
0
0
Bild 1.65:
0.05
0.1
0.15
0.2
0.25
0.3
0.35
0.4
0.45
0.5
Diskretisierung des kontinuierlichen Integrators
Die Unterschiede werden besonders deutlich, wenn die Bode-Diagramme der PID-Regler
verglichen werden (Bild 1.66).
10
Tustin
Betrag [dB]
5
0
---5
---10
SIEMENS
kontinuierlich
---15
---20
---25
---30
90
Phase [Grad]
Tustin
45
SIEMENS
0
---45
kontinuierlich
---90
10 0
Bild 1.66:
Frequenz [rad/s]
Bode-Diagramme der Regler
101
96
Man erkennt, dass der Siemens-Regler deutliche Unterschiede im Betrags- und
Phasenverlauf gegenüber dem kontinuierlichen Regler aufweisen. Die für die Stabilität
wesentliche Phasenanhebung fällt beim Siemens-Regler deutlich geringer aus. Die
Übereinstimmung von Tustin-Transformation und kontinuierlichem Regler ist dagegen
sehr hoch.
Die folgenden Rechnungen zeigen die Regelung des jeweils selben Prozesses mit den
Reglern: kontinuierlich (Bild 1.67), Tustin (Bild 1.68) sowie der “Siemens-diskretisierte”
Regler (Bild 1.69).
2
1.8
1.6
1.4
1.2
1
0.8
0.6
0.4
0.2
0
0
Bild 1.67:
5
10
15
20
25
30
Regelung mit kontinuierlichem PID-Regler
2
1.8
1.6
1.4
1.2
1
0.8
0.6
0.4
0.2
0
0
Bild 1.68:
5
10
15
20
25
Regelung mit dem diskreten Regler (Tustin-Transformation)
30
97
2
1.8
1.6
1.4
1.2
1
0.8
0.6
0.4
0.2
0
0
Bild 1.69:
5
10
15
20
25
30
Regelung mit dem diskreten Regler (SIEMENS-Diskretisierung)
Die Regelungen mit dem diskreten Reglern besitzen schlechtere Eigenschaften als mit dem
kontinuierlichen Regler. Besonders ungünstig schneidet die Siemens-Variante ab.
Es wäre aber vollkommen abwegig, daraus zu schließen, dass diskrete Regelungen
grundsätzlich schlechter als kontinuierliche Regelungen sein müssen. Um wirklich gute
Ergebnisse mit diskreten Reglern zu erhalten, muss nur der Entwurfsprozess auf die
diskrete Regelung abgestimmt werden. Der Entwurf einer diskreten Regelung ist jedoch
nicht Bestandteil dieser Lehrveranstaltung.
32.1
Verwendung des PID-Moduls der Siemens-SPS
(FB41)
Wenn eine PID-Regler-Funktion benötigt wird, kann der System-Funktionsblock SFB41
eingesetzt werden. Dieser Funktionsblock steht in der Standardbibliothek zur Verfügung
und ist eine schnelle Methode einen fehlerfreien PID-Regler zu verwirklichen. Man ist
dann allerdings auf die Einschränkungen des programmierten Reglers angewiesen, da der
Programmcode (geschrieben in ST / Structured Text) nicht einsehbar und damit nicht
veränderbar ist. Mit dem PID-Regler aus der Bibliothek ist allerdings auch ein Overhead
verbunden, da einige Funktionen aus dem Regler nicht in jeder Anwendung benötigt
werden.
Das Blockschaltbild 2.1 zeigt die Struktur sowie die Parameter des Funktionsblocks bzw.
des PID-Reglers.
98
Bild 2.1:
Blockschaltbild des SIEMENS -PID-Reglers in der SPS
Dem Funktionsblock ist ein sogenannter Instanzdatenbaustein zugeordnet, der die
Parameter enthält. Der Instanzdatenbaustein mit seinen Anfangswerten zeigt das folgende
Diagramm 2.2.
99
Bild 2.2:
Parameter des Instanzdatenbausteins und Anfangswerte
Der Instanzdatenbaustein zeigt eine bunte Mischung aus deutschen und englischen
Bezeichnungen, vermutlich ein Relikt aus dem Aufkauf der Texas Instruments PLC
Division durch Siemens.
Die Bedeutung der einzelnen Parameter ist der Siemens-Dokumentation entnommen.
100
101
102
103
Bei dem Parameter TI ist die Bezeichnung “reset time” falsch oder zumindest
missverständlich, da es sich um die Nachstellzeit oder Integrationszeitkonstante des
I-Anteils handelt.
Zu beachten ist, dass das alle internen Zahlenwerte auf 1% (0,01) bezogen sind, d.h. die
Stellgröße hat intern den Wert 100.0 (REAL). Dieses Siemens-Format sollte man nicht
ändern, denn einige Zusatzwerkzeuge wie z.B. “PID Control” erwarten dieses Format.
Sofern man die Regelgröße selbst normiert (über den Eingang PV_IN, Schalter
PVP_ON = FALSE) muss dies also so erfolgen, dass sich die Größe im Zahlenbereich
---100.0...+100.0 bewegt.
32.2
Übung: PID-Regelung mit FB41
Mit dem PID-Baustein FB41/DB41 soll der analoge Prozess
G a(s) =
VS
T1 s + 1
3
.
(2.26)
104
aus Abschnitt 30 geregelt werden.
1.
Parametrieren Sie den Instanzdatenbaustein. Verbinden Sie dabei die A/D- und
D/A-Umsetzer mit den entsprechenden Schnittstellen des Instanzdatenbausteins.
Beachten Sie das erforderliche Datenformat und die Skalierung.
2.
Untersuchen Sie die Möglichkeit des Handbetriebs und des “stoßfreien”
Umschaltens zwischen Handbetrieb und Reglerbetrieb. Als Signal für das
Umschalten dient ein beliebiger digitaler Eingang.
3.
Stellen Sie P-, I-, PI- und PID-Regler ein und untersuchen Sie ihre Eignung für die
Regelung des analogen Prozesses.
33
Structured Text (ST)
Structured Text ist die Programmiersprache der “nächsten Generation”, die wesentliche
Vorteile gegenüber den anderen Programmierformen nach IEC-61131
SFC (Sequential Function Chart)
FBD (Function Block Diagram)
LD (Ladder Diagram)
IL (Instruction List)
aufweist. Siemens hat natürlich eigene Bezeichnungen. So firmiert ST bei Siemens unter
SCL (structured control language). Zum großen Teil hält sich Siemens aber damit an die
Vorgaben der PLCopen bzw. IEC-61131.
Programme in ST sind portabel, d.h. sie können mit geringem Aufwand auf Anlagen
eines anderen Herstellers portiert werden.
Mit ST lässt sich Software für Automatisierungsanlagen endlich in einer Hochsprache
entwickeln. Der Einsatz von ST bietet ausschließlich Vorteile gegenüber IL bei der
Entwicklung neuer Programme. Die Vorteile im einzelnen sind:
Bessere Lesbarkeit und damit bessere Wartbarkeit der Programme
ST-Programme sind wesentlich kürzer und damit wesentlich weniger fehleranfällig und
lassen sich schneller entwickeln
Ermöglicht strukturiertes Programmieren im Gegensatz zu “Spaghetti”-IL-Programmen durch einen vollständigen Satz von Kontrollstrukturen (Vergleiche, Verzeigungen,
Schleifen usw.)
Eigene Definition komplexer Datentypen (damit kann man fast “objektorientiert”
programmieren)
105
In Anbetracht der Vorteile von ST gegenüber IL ist es unverständlich, warum ST so wenig
eingesetzt wird. Als Beispiel dient das Programm für einen PID-Regler, das man auch ohne
Detailkenntnisse von ST fast verstehen kann.
FUNCTION_BLOCK PID
VAR_INPUT
AUTO : BOOL ;
PV : REAL ;
SP : REAL ;
X0 : REAL ;
(*
(*
(*
(*
(*
(*
(*
(*
(*
0 - manual , 1 - automatic *)
Process variable *)
Set point *)
Manual output adjustment - *)
Typically from transfer station *)
Proportionality constant *)
Reset time *)
Derivative time constant *)
Sampling period *)
KP : REAL ;
TR : REAL ;
TD : REAL ;
CYCLE : TIME ;
END_VAR
VAR_OUTPUT XOUT : REAL; END_VAR
VAR ERROR : REAL ;
(* PV - SP *)
ITERM : INTEGRAL ;
(* FB for integral term *)
DTERM : DERIVATIVE ; (* FB for derivative term *)
END_VAR
ERROR := PV - SP ; (* Adjust ITERM so XOUT := X0 when AUTO = 0 *)
ITERM (RUN := AUTO, R1 := NOT AUTO, XIN := ERROR,
X0 := TR * (X0 - ERROR), CYCLE := CYCLE) ;
DTERM (RUN := AUTO, XIN := ERROR, CYCLE := CYCLE) ;
XOUT := KP * (ERROR + ITERM.XOUT/TR + DTERM.XOUT*TD) ;
END_FUNCTION_BLOCK
33.1
ST Syntax
ST ist eine Hochsprache, die Elemente von PASCAL und Ada übernommen hat. Man hätte
sich auch auch auf jede andere (existierende) Hochsprache einigen können, da ST kaum
SPS-spezifisch ist (damit ist ST eigentlich recht überflüssig). Ein Bestreben der
SPS-Produzenten in der PLCopen (www.plcopen.org) war sicherlich, die Kunden an die SPS
mit einer spezifischen Sprache zu binden. ST ist aber leicht erlernbar. Kenntnisse von
Programmiersprachen wie Java, C, oder natürlich PASCAL, Ada, Modula sind hilfreich für
das Erlernen von ST.
ST ist --- wie moderne Programmiersprachen --- nicht mehr zeilenorientiert, sondern die
Sprachelemente werden jeweils durch ein Semikolon “;” abgegrenzt. Beispielsweise sind
A := pi;
B := SIN(2.0 * pi * 50 * x);
und
A := pi;
B := SIN(2.0 * pi * 50 * x);
vollkommen identisch in ihrer Auswirkung auf den Programmkode. Man kann diese
Freiheit nutzen, um die Struktur eines Programms durch “Einrücken” zu verdeutlichen.
106
33.1.1
Ausdrücke (Expressions)
Mathematische und logische Ausdrücke unterscheiden sich nicht von anderen
Hochsprachen. Zu beachten ist, dass die Zuweisung durch das Symbol “:=” erfolgt (das
Symbol “=” ist der Vergleichsoperator auf “Gleichheit”). Alle Ausdrücke sind in folgender
Tabelle aufgelistet (von www.plcopen.org).
33.1.2
Kontrollstrukturen
ST besitzt alle notwendigen Kontrollstrukturen für eine strukturierte Programmierung.
Damit lassen sich Algorithmen leicht umsetzen und das Programm wird sehr viel
107
übersichtlicher und verständlicher. Jeder, der schon einmal eine längere IL
(Anweisungsliste) analysieren musste, die von einen anderen Programmierer stammt, ist
für dir Kontrollstrukuren von ST dankbar. Die Kontrollstrukturen sind in folgende Liste
zusammengestellt (von www.plcopen.org).
108
Es existiert eine Ausnahme zu den Kontrollstrukturen, die eine strukturierte
Programmierung naheliegen: der EXIT-Befehl. Mit “EXIT” kann eine Schleife verlassen
werden, auch wenn die Ende-Bedingung der Schleife noch nicht erreicht ist. Bei “sauberer”
Programmierung lässt sich “EXIT” immer vermeiden. Ais Effizienzgründen kann eine
Konstruktion mit EXIT dennoch günstig sein.
sum := 0;
FOR i := 1 TO 3 DO
FOR j := 1 TO 2 DO
IF flag THEN EXIT;
END_IF
sum := sum + j;
END_FOR;
sum := sum + i;
END_FOR;
Das “Einrücken” der Programmzeilen ist nicht erforderlich. Die folgende Fassung hätte
somit die gleiche Funktion:
SUM := 0;
FOR I := 1 TO 3 DO
FOR J := 1 TO 2 DO
IF FLAG THEN EXIT; END_IF
SUM := SUM + J;
END_FOR;
SUM := SUM + I;
END_FOR;
Es existieren unterschiedliche Empfehlungen, wie dies erfolgen sollte. Das erste Beispiel
folgt der Empfehlung von Jensen und Wirth, den Entwicklern der Programmiersprache
109
PASCAL. Beachten Sie, dass die Schlüsselworte (FOR, EXIT usw.) groß geschrieben
wurden. Auch dies ist keine Vorschrift, sondern eine Empfehlung zur Erhöhung der
Lesbarkeit des Programms.
33.1.3
Schlüsselworte
Schlüsselworte sind Bezeichnungen, die innerhalb eine ST-Programms bereits eine feste
Bedeutung haben und nicht für Variablennamen zur Verfügung stehen. Dies sind alle
Bezeichnungen von Kontrollstrukturen und Datentypen (z.B. REAL, BOOL usw.) sowie
folgende Namen:
START, DATA, PROJECT, SFC, SFC2, LADDER, I/O, ASCII, CAR, FORCE,
PLC2, CONFIG, INC, ALL, YES, NO, STRUCTURED TEXT
Variablennamen müssen mit einem Buchstaben beginnen. Ansonsten dürfen Variablennamen frei gewählt werden.
33.1.4
Unterprogramme
Anstelle der FBs und FCs treten gewöhnliche Unterprogramme, an die Werte übergeben
werden können. Die Variablen bekommen zusätzlich zum Typ auch noch ein Attribut, das
den Zugriff auf die Variable angibt.
Declaration
Description
VAR
VAR_INPUT
VAR_OUTPUT
VAR_IN_OUT
the general variable declaration
defines a variable list for a function
defines output variables from a function
defines variable that are both inputs and
outputs from a function
VAR_EXTERNAL
VAR_GLOBAL
VAR_ACCESS
RETAIN
CONSTANT
AT
END_VAR
Beispiele:
a global variable
a value will be retained when the power is cycled
a value that cannot be changed
can tie a variable to a specific location in memory
(without this variable locations are chosen by the
compiler)
marks the end of a variable declaration
110
Durch die Definition und Deklaration geeigneter Variablen wird eine Programmieraufgabe deutlich vereinfacht.
111
34
Vergleich zwischen ST und IL
Entwicklungszeit --- Lesbarkeit --- Fehleranfälligkeit --- Wartbarkeit?
Siemens
%
4#'
2
2 "
%
"
"
%
*"
%
-"
/4
6
/4$
!4
%
%
0"
/4
6
, )
5
* 5
1
2
)
2
)
1
6
2
6
2
1
6
2
2
"
" 2
4$'
ST
! "#$% & '
)
)
)
1
)
!4
%
%
Modicon
5
2
+
%
IL
)
5
* 5
)
#%/ , )
)
# 2 ,(
&3'
)
-
*
+
(
(
.#
(
0 1
.#
(
1
"#$%
!
)
(
35
112
Labor #01: AWL, FUP und KOP
Erstellen Sie ein SPS-Programm in Step-7, das die XOR Funktion in AWL, FUP und KOP
(Kopplungsplan) umsetzt. Verwenden Sie eine Symbolik-Datei mit den Vereinbarungen
x0
⇔
E0.0
x1
⇔
E0.1
y
⇔
A1.0
x0
x1
Bild L1.:
=1
y0
Schaltung für Labor #01
Verwirklichen Sie die Schaltung als AWL (Anweisungsliste).
Verwirklichen Sie die Schaltung als FUP (Funktionsplan).
Verwirklichen Sie die Schaltung als KOP (Kontaktplan).
Simulieren Sie die Funktion.
36
113
Labor #02: Elementare Logikfunktionen
Erstellen Sie ein SPS-Programm in Step-7, das folgende Logikschaltung umsetzt.
Verwenden Sie eine Symbolik-Datei mit den Vereinbarungen
x0
⇔
E0.0
x1
⇔
E0.1
x2
⇔
E0.2
x3
⇔
E0.3
y0
⇔
A1.0
y1
⇔
A1.1
=1
x3
≥1
a
x2
=1
S
R
Q
y0
y1
x1
&
x0
Bild L2.:
Schaltung für Labor #02
Verwirklichen Sie die Schaltung als AWL (Anweisungsliste).
Verwirklichen Sie die Schaltung als FUP (Funktionsplan).
Da sich die XOR-Funktion mit KOP (Kontaktplan) nur sehr umständlich umsetzen lässt,
soll auf eine Realisierung als KOP verzichtet werden.
Stellen Sie die Wahrheitstabellen für die Schaltung auf.
Simulieren Sie die Funktion.
Was passiert, wenn die Eingangssignale die Werte x3 = ’0’, x2 = ’0’, x1 = ’0’ sowie
x0 = ’0’ annehmen? Begründen Sie Ihre Aussagen.
37
114
Labor #03: Zustandsdiagramme für
Automaten und für eine Ablaufsteuerung
der SPS
Aufgabe des Ingenieurs ist es häufig, die abstrakte Struktur (Architektur) einer Lösung zu
erzeugen. Die Umsetzung in ein entsprechendes Steuerungsprogramm muss auch
beherrscht werden, kann aber auch von Programmierern erledigt werden. Bei eine
Ablaufsteuerung erfordert dieser Schritt die Abbildung eines praktischen Problems auf ein
Zustandsdiagramm.
Um die Zahl der schweren Eisenbahnunfälle zu verringern, soll der Betrieb auf einer
einspurigen Eisenbahnstrecke automatisiert werden.
B0
B1
S0
W0
y0
y1
B2
y2
Weichen
y3
W1
S1
B3
B4
Richtlinien für den Betrieb des einspurigen Streckenteils:
1. Der Zugbetrieb ist in Blöcke (B0 - B4) eingeteilt.
Befindet sich ein Zug in einem Block, so ist die Variable Bx = ’1’.
2. Die Stellung der Weiche wird durch die Signale W0 und W1 angezeigt.
3. Die Signale S0 und S1 regeln die Einfahrt eines Zuges in den nächsten Block.
4. Die Signale S0 und S1 stehen grundsätzlich auf Halt (Sx = ’0’).
Nur wenn ein Zug gefahrlos die einspurige Strecke befahren darf, geht das Signal
kurzfristig auf Freigabe (Sx = ’1’).
115
5. Mit den Signalen y0 - y2 können die Weichen umgesteuert werden (Abfrage der
Weichenstellung mit den Signalen W0 und W1).
6. Wenn die Anlage in Betrieb genommen wird, ist die Strecke frei und beide
Weichen befinden sich in “Linksstellung”.
Eingänge
Bedeutung
B0
’1’
Block 0 belegt
B1
’1’
Block 1 belegt
B2
’1’
Block 2 belegt
B3
’1’
Block 3 belegt
B4
’1’
Block 4 belegt
W0
’0’
Weiche links, ’1’
Weiche rechts
W1
’0’
Weiche links, ’1’
Weiche rechts
Ausgänge
Bedeutung
y0
’1’
obere Weiche nach links steuern
y1
’1’
obere Weiche nach rechts steuern
y2
’1’
untere Weiche nach links steuern
y3
’1’
untere Weiche nach rechts steuern
S0
’1’
Signal S0 Freigabe
S1
’1’
Signal S1 Freigabe
Sie können annehmen, dass die einzelnen Größen bereits in einer Symbolik-Datei
vereinbart wurden, d.h. Sie können z.B.
7
8 9
programmieren.
Zeichnen Sie ein Zustandsdiagramm (Zustände = Kreise, Bedingungen jeweils an den
Pfeilen angeben).
Zeichnen Sie das Zustandsdiagramm in der für SPS gebräuchlichen Form (Rechtecke
mit Bedingungen, Merkern und Ausgängen).
38
116
Labor #04: Ampelsteuerung (Verwirklichung
mit AWL und FUP)
Im folgenden ist das Zustandsdiagramm eines Umlaufs für eine einfache Ampelsteuerung
dargestellt (ohne Querrichtung bzw. Fußgängerampel).
Start
0
rot (A1.0)
M0.0
Start
1
Start
rot (A1.0)
M0.1
T0
2
Start
M0.2
rot (A1.0)
gelb (A1.1)
T1
3
Start
gruen (A1.2)
M0.3
T2
4
Start
gelb (A1.1)
M0.4
T3
1
Bild L3.:
Zustandsdiagramm für die Ampelsteuerung
Erzeugen Sie eine Symboldatei für die Ein- und Ausgänge der Steuerung.
Setzen Sie das Zustandsdiagramm in der Darstellung Funktionsplan (FUP) um. Für die
einzelnen Zustände können separate “Netzwerke” verwendet werden.
Setzen Sie das Zustandsdiagramm mit einer Anweisungsliste (AWL) um.
Die Funktionsfähigkeit Ihrer Programme ist jeweils durch Simulation nachzuweisen.
39
117
Labor #05: Industrie-Spülmaschine
(Ablaufsteuerung durch Kodierung der
Zustände und durch Kodierung der
Übergänge)
Die Ablaufsteuerung einer Industrie-Spülmaschine ist durch eine SPS zu automatisieren.
Eingänge
Bedeutung
Start
’1’
Start-Signal betätigt
Deckel_zu
’1’
Deckel geschlossen
Oeko
’1’
Ökobetrieb, d.h. verkürzter Spülbetrieb --- 1 Minute
(ansonsten 2 Minuten)
Ausgänge
Bedeutung
Verriegelung
’1’
Deckel verriegelt
Wasser_ein
’1’
Wasser einfüllen
Spuelung_ein
’1’
Spülbetrieb eingeschaltet (Umwälzpumpe)
Pumpe
’1’
Laugenpumpe ein
Der Ablauf soll wie folgt durchgeführt werden:
1.
Mit dem “Start”-Signal wird der Vorgang begonnen. Hierzu muss der Deckel
geschlossen sein.
2.
Deckel verriegeln.
3.
Wasser einfüllen (30s).
4.
Spülbetrieb ein: [Oeko = ’1’ ⇒ 1 Minute, Oeko = ’0’ ⇒ 2 Minuten]
5.
Wasser abpumpen (30s).
6.
Trocknen (Ruhephase = 30s).
7.
Deckelöffner freigeben (Deckel entriegeln).
Zeichnen Sie das Zustandsdiagramm.
Schreiben Sie ein SPS-Programm durch “Kodierung der Zustände” (klassische Lösung)
Schreiben Sie ein SPS-Programm durch “Kodierung der Übergänge” (Lösung aus der
Automatentheorie)
Die Funktionsfähigkeit Ihrer Programme ist jeweils durch Simulation nachzuweisen.
40
118
Labor #06: Berechnung numerischer
Ausdrücke mit der SPS
Schreiben Sie eine Funktion (FC = Function), die die ganzzahlige Fakultät berechnet. Die
Berechnungen sollen mit 32 Bit Integer (DW = Double Word) ausgeführt werden, um
einen Überlauf bei der Berechnung vermieden wird.
Die Fakultät ist definiert als
x
(1.57)
k.
x! =
k=1
Man beachte, dass
(1.58)
0! = 1
gilt.
Die 32 Bit Integer-Konstante 123456 wird beispielsweise mit
L #123456
geladen.
Der Aufruf der Funktion im Block OB1 könnte dann wie folgt aussehen:
L
T
L#5
MD
0
CALL FC
x:=MD0
x_fak:=MD4
1
L
4
MD
Der Ergebnis sollte dann 5! sein, was im Debugger zu überprüfen ist.
41
119
Labor #07: Numerische Lösung einer
Gleichung durch Iteration mit der SPS
Die Gleichung
cos(x) = ax 3 + x
(1.59)
lässt sich nicht analytisch, d.h. durch Auflösung nach x lösen.
Mit Hilfe einer Newton-Raphson-Iteration
x k+1 = x k −
f (x)
f (x)
(1.60)
kann die Lösung jedoch mit beliebiger Genauigkeit bestimmt werden.
Mit
!
∆
f (x) == cos(x) − ax 3 − x = 0
(1.61)
sowie der Ableitung
df
= f = − sin(x) − 3ax2 − 1
dx
(1.62)
lautet die Berechnungsvorschrift
x k+1 = x k +
cos(x) − ax 3 − x
.
sin(x) + 3ax 2 + 1
(1.63)
Der Anfangswert x0 kann null gewählt werden.
Eingänge
Bedeutung
a
aus AD-Umsetzer
Der Parameter a kann aus einem AD-Umsetzer mit folgender Programmsequenz
ausgelesen werden:
L
IDT
DTR
L
PEW
256
3.61689814e-04
//
//
//
//
//
AD-Umsetzer
Integer -> Doppelwort (32 Bit)
Real
Siemens Magic Number
= Normierung auf 0..10.0
*R
Schreiben Sie den Funktionsblock FB1, der diese Iteration durchführt.
Vereinbaren Sie sinnvolle Variablen im Datenbaustein DB1 (Zuordnung zu FB1).
Überprüfen Sie die Lösung mit dem Debugger.
42
120
Labor #08: Digitales Filter
Die kontinuierliche Übertragungsfunktion (Geschwindigkeitsmessung)
G(s) = 10s
s+1
(1.64)
soll durch die bilineare Transformation
s = 2 z−1
T z+1
(1.65)
in eine diskrete Übertragungsfunktion G(z) überführt werden. Die Abtastzeit betrage
T = 0.1s.
Berechnen Sie die diskrete Übertragungsfunktion G(z).
Bestimmen Sie die Differenzengleichung.
Programmieren Sie das digitale Filter mit dem Funktionsblock FB1 mit dem
Datenbaustein DB1. Der Aufruf von FB1 muss aus dem OB35 gemäß folgender
Programmsequenz erfolgen:
L
ITD
DTR
L
*R
T
PEW 256
// aus ADC (16 Bit)
3.616898e-05
// Normieren auf +-1.0
CALL
FB1,DB1
// DIGITALES FILTER
L
L
*R
RND
T
DB1.y
2.764800e+04
// Denormieren
PAW
// Integer (ganzzahlig)
// an DAC (16 Bit)
DB1.uk
258
Es erfolgt keine Parameterübergabe; die Daten werden direkt in den
Datenbaustein DB1 geschrieben.
43
121
Labor #09: Digitales Filter 2. Ordnung
Das diskrete Filter
G(z) =
0.1833z + 0.1757
z 2 − 1.523z + 0.8819
(1.66)
soll mit einer SPS verwirklicht werden. Die Abtastzeit beträgt T = 0.1s.
Bestimmen Sie die Differenzengleichung.
Beachten Sie, dass bei dem Filter 2. Ordnung sowohl u also auch y zeitlich verschoben
werden muss. Dies erfolgt üblicherweise am Ende der Berechnung des digitalen Filters.
Datenbaustein DB1. Der Aufruf von FB1 muss aus dem OB35 gemäß folgender
Programmsequenz erfolgen:
L
ITD
DTR
L
*R
T
PEW 256
// aus ADC (16 Bit)
3.616898e-05
// Normieren auf +-1.0
CALL
FB1,DB1
// DIGITALES FILTER
L
L
*R
RND
T
DB1.y
2.764800e+04
// Denormieren
PAW
// Integer (ganzzahlig)
// an DAC (16 Bit)
DB1.uk
258
Es erfolgt keine Parameterübergabe; die Daten werden direkt in den
Datenbaustein DB1 geschrieben.
Was für ein dynamisches Verhalten zeigt das Filter?
44
122
Labor #10: PID-Regler
Der kontinuierliche PID-Regler
kp
u
P
y
ki
s
kd
t *s
s
+1
I
D
soll als diskreter PID-Regler mit der SPS verwirklicht werden:
K(z) = k dp +
k di
k
− z −ddz
z−1
1
Begrenzungen
kdp
u(k)
xi [k+1]
kdi
1
z
xi [k]
y(k)
---
kdd
xd [k+1]
1
z
Limit
xd [k]
z1
Die Parameter des diskreten PID-Reglers lauten gemäß Vorlesungsumdruck nach
Zusammenfassung:
k dp = k p +
2k d
ki T
+
,
2
2t * + T
(1.68)
k di = k i T ,
k dd =
4k d T
(2t * + T)
z 1 = 2t * − T .
2t * + T
(1.67)
2
,
(1.69)
(1.70)
123
Die Daten des kontinuierliche Reglers seinen:
kp = 2.4 ,
ki = 0.2 ,
kd = 1.4 ,
t* = 0.5 .
Die Abtastperiode soll T = 0.1 betragen.
Bestimmen Sie die alle Differenzengleichungen.
Definieren Sie alle benötigten Variablen und temporären Variablen.
Datenbaustein DB1.
Verwirklichen Sie die Begrenzungen auf ±0.8 an den im Blockschaltbild gezeigten
Stellen.
45
124
Labor #11: Füllstandsregelung
(solide & einfach)
Ziel ist die Konfiguration des Siemens S7-300 mit der Software Step-7 sowie die
Programmierung einer Füllstandsregelung für die folgende Tankanlage.
Y1
Y2
S1
S3
S2
S4
Eine einfache Lösung, die weit hinter einer optimalen Lösung (einschließlich
Fehlererkennung) zurückbleibt, zeigt folgende Struktur (die Tanks sollen nicht gleichzeitig
gefüllt werden):
S2
0
S1 ∨ M0.1
Y1
(Tank 1)
M0.0
S4
1
S3 ∨ M0.0
Y2
M0.1
Konfigurieren Sie die SPS mit Step-7 .
Schreiben Sie eine SPS-Programm gemäß obiger Struktur.
Überprüfen Sie die Funktion mit der Tankanlage.
(Tank 2)
46
125
Labor #12: Füllstandsregelung
(vollständig)
Die Tankfüllanlage aus Labor #10 soll nun unter vollständiger Ausnutzung der Information
aus der Sensorik optimal gesteuert werden. Hierzu soll auch zwischen den Tanks
umgeschaltet werden, wenn der jeweils nicht befüllte Tank leerzulaufen droht (Schalter S2
bzw. S4).
Weiterhin ist in einen Fehlerzustand zu verzweigen (Anzeige durch Blinken von Y1 und
Y2), falls ein Fehler in der Anlage detektiert wird (z.B. durch S1 ∧ S2). Die Fehlerzustände
können nur durch ein “Reset”-Signal wieder verlassen werden.
“0”
Tanks
voll
F1(u)
F3(u)
F0(u)
F4(u)
“1”
Tank 1
füllen
F2(u)
“2”
Tank 2
füllen
F5(u)
Reset
(zum Zustand “0”)
Fehler
250ms
“3”
Error 0
“4”
Error 1
250ms
Verwenden Sie die erfolgte Konfiguration SPS mit Step-7 .
Schreiben Sie eine SPS-Programm gemäß der obiger Zustandsgraphen. Die Übergänge
sollen durch minimierte boolsche Gleichungen (durch KV-Diagramm) erfolgen.
Überprüfen Sie die Funktion mit der Tankanlage.
47
126
Labor #13: Graphische Bedienung der
Füllstandsregelung mit WinCC (HMI)
Für die Tankfüllanlage aus Labor #11 ist eine graphische Bedienoberfläche (WinCC =
Windows Control Center) entwickelt werden. Diese Art der Anlagenbedienung ermöglicht
es dem Operator eine Vielzahl von Anlagenkomponenten zu steuern und zu überwachen,
die sich nicht im unmittelbaren Umfeld des Bedieners befinden müssen.
Das nachfolgende Bild enthält einen Vorschlag zur Verwirklichung der Tankbedienung
zeigt das nachfolgende Bild.
Erzeugen Sie eine graphische Bedienoberfläche mit dem Graphics Designer von
WinCC .
Modifizieren Sie Ihr Step7-Programm auf der SPS, so dass Sie geeignete Variablen für
die Prozessanbindung zur Verfügung stellen.
Überprüfen Sie die Funktion mit dem Modell der Tankanlage.
48
127
Labor #14: PI-Regelung einer Tiefpassstrecke
mit SPS
Für die folgende Regelstrecke mit Operationsverstärkern soll ein diskreter PI-Regler mit
der SPS verwirklicht werden.
Zunächst sollen die Reglerparameter VR (Verstärkung) sowie TN (Nachstellzeit) durch
Simulation des Prozesses mit Matlab ermittelt werden.
Erzeugen Sie ein Modell mit der Matlab-Funktion :
;
.
Entwerfen Sie einen “guten” diskreten PI-Regler mit der Matlab-Funktion
: < ; = >
. Die Parameter VR und TN verstellen Sie iterativ, bis ein gutes
Verhalten in Bezug auf Störungs- und Führungsverhalten erzielt wird.
Erstellen Sie ein SPS-Programm, dass die folgenden Verläufe von Sollwert w und
Störgröße d erzeugt. Die Abtastperiode (=Zykluszeit des OB35) sei T = 100ms.
Sollwert w
Störgröße d
128
Berechnen Sie die Parameter des diskreten PI-Reglers gemäß
kp = V R
2T n + T
,
2T n
ki = V R T .
Tn
(1.71)
Erstellen Sie das vollständige SPS-Programm mit dem PID-Regler. Ein- und
Ausgangsgrößen sind über A/D- bzw. D/A-Umsetzer zu führen.
Überprüfung Sie die Funktion der Regelung mit dem Oszilloskop.
49
129
Labor #15: Zweipunkt- und PI-Regelung einer
Tiefpassstrecke mit SPS
Für die folgende Regelstrecke mit Operationsverstärkern sollen ein Zweipunktregler mit
Hysterese sowie ein diskreter PI-Regler (optional) mit der SPS verwirklicht werden.
Der Sollwert gemäß Diagramm soll durch die SPS erzeugt werden (periodisches Signal, 150
Abtastschritte 0.5 dann 150 Abtastschritte 0.0, T = 100ms). Ein- und Ausgang der Strecke
sind über A/D-Umsetzer anzuschließen.
Sollwert w
Programmieren Sie einen Zweipunktregler mit den Ausgängen 0.0 und 1.0 und einer
Hysterese ε = 0.04 .
Programmieren Sie den diskreten PI-Regler K(z) = 0.478125 + 0.05625 und vergleichen
z−1
Sie die Ergebnisse mit denen des Zweipunktreglers.
Überprüfung Sie die Funktion der Regelung mit dem Oszilloskop.
130
131
Teil L
50
Lösung Labor #03: Zustandsdiagramme für
Automaten und für eine Ablaufsteuerung
der SPS
Wenn die Anlage in Betrieb geht, stehen die Weichen “links” und die Strecke ist frei. Der
nachfolgende Ablauf ist ausschließlich durch die Belegung der Blöcke bzw. der
Weichenstellung abhängig.
Bild 2.3:
Zustandsdiagramm der Eisenbahnsteuerung
132
Das Programm ist nicht vollständig. Die Kodierung aller Übergänge (Transitionen) ist bei
einen vorhandenen Zustandsdiagramm jedoch leicht möglich.
L
L
==I
S
MW0
0
U
U
S
R
M0.0
“B0”
M0.1
M0.0
U
U
S
R
.
.
.
M0.1
“B2”
M0.2
M0.1
M0.0
// Ausgaenge
O
M0.1
O
M1.5
=
“S0”
.
.
.
// die ersten 16 Merker laden
// sind alle Merker 0?
// ersten Zustand markieren
51
133
Lösung Labor #04: Ampelsteuerung
(Verwirklichung mit AWL und FUP)
Ersetzt man s in der Übertragungsfunktion durch
52
134
Lösung Labor #05: Industrie-Spülmaschine
(Ablaufsteuerung durch Kodierung der
Zustände und durch Kodierung der
Übergänge)
53
135
Lösung Labor #06: Numerische Lösung einer
Gleichung durch Iteration mit der SPS
54
136
Lösung Labor #08: Digitales Filter
s = 2z−1 ,
Tz + 1
(2.27)
so folgt
y(z)
= G(z) =
u(z)
k1 =
20 ,
2+T
20 z−1
T z+1
2 z−1
+1
T z+1
=
20
z−1 =k z−1 ,
1 z−a
2 + T z − 2−T
2+T
a=2−T .
2+T
(2.28)
(2.29)
Dies entspricht der Differenzengleichung (soll in FB1, DB1 programmiert werden)
y[k] = k 1 u[k] − u[k − 1] + a y[k − 1] .
(2.30)
Mit dem Zahlenwert T = 0.1 erhält man
k1 =
Bild 2.4:
20 = 9.5238 ,
2 + 0.1
a = 2 − 0.1 = 0.9048 .
2 + 0.1
Sprungantwort kontinuierlichem (blau) und diskretem (grün) System
(2.31)
55
137
Lösung Labor #09: Digitales Filter 2. Ordnung
56
138
Lösung Labor #10: PID-Regler
Die Differenzengleichungen folgen unmittelbar aus dem Blockschaltbild.
y[k] = k dp u[k] + x i[k] − x d[k] ,
(2.32)
x i[k + 1] = k di u[k] + x i[k] ,
(2.33)
x d[k + 1] = k dd u[k] + z 1 x i[k] .
(2.34)
Für xi [k+1] und xd [k+1] werden keine eigenen Variablen benötigt, da die Variablen xi [k]
und xd [k] im Algorithmus einfach überschreiben werden können.
FB1:
FUNCTION_BLOCK FB1
VAR_INPUT
uk:real:=0.000000e+00
END_VAR
VAR_OUTPUT
yk:REAL:=0.000000e+00
END_VAR
VAR_IN_OUT
END_VAR
VAR
kdp:REAL:=4.955450e+00
kdi:real:=2.000000e-02
kdd:REAL:=4.628100e-01
z1:REAL:=8.181800e-01
limit:REAL:=8.000000e-01
xik:REAL:=0.000000e+00
xdk:REAL:=0.000000e+00
END_VAR
VAR_TEMP
tmp:REAL
END_VAR
BEGIN
// Ausgang
L
DB1.kdp
L
#uk
*R
L
DB1.xik
+R
L
DB1.xdk
-R
T
#tmp
// Begrenzung Ausgang
L
DB1.limit
z000
z001
>R
SPBN
T
:NOP
L
L
NEGR
<R
SPBN
T
:NOP
L
T
z000
#tmp
1
#tmp
DB1.limit
z001
#tmp
1
#tmp
#yk
// Zustaende
L
DB1.kdi
L
#uk
*R
L
DB1.xik
+R
L
#tmp
// Begrenzung Integrator
L
DB1.limit
>R
SPBN z002
T
#tmp
z002 :NOP 1
L
#tmp
L
DB1.limit
NEGR
<R
SPBN z003
T
#tmp
z003 :NOP 1
L
#tmp
T
DB1.xik
L
DB1.kdd
L
#uk
*R
T
#tmp
L
DB1.z1
L
DB1.xdk
*R
L
#tmp
+R
T
DB1.xdk
END_FUNCTION_BLOCK
139
140
OB35:
BEGIN
L
PEW
256
ITD
DTR
L
2.764800e+04
/R
T
MD
0
// PID-Regler
CALL FB
uk:=MD0
yk:=MD4
1,DB1
L
MD
4
L
2.764800e+04
*R
RND
T
PAW
258
57
141
Lösung Labor #11: Füllstandsregelung
(solide & einfach)
58
142
Lösung Labor #12: Füllstandsregelung
(vollständig)
59
143
Lösung Labor #13: PI-Regelung einer
Tiefpassstrecke mit SPS
144
145
60
Literatur
[1]
Gießler, W.: SIMATIC S7, SPS-Einsatzprojektireung und -Programmierung.
VDE-Verlag, 2003
[2]
Habermann, M. und T. Weiß: STEP7---Crashkurs.
VDE-Verlag, 2002
[3]
Wellenreuther, G. und D. Zastrow: Steuerungstechnik mit SPS.
Vieweg, 1998
[4]
Schnell, G.: Busssysteme und der Automatisierungstechnik.
Vieweg, 1999
[5]
Kriesel, W., T. Heimbold und D. Telschow: Bustechnologien für die Automation.
Hüthig, 1998
[6]
Pritschow, G.: Einführung in die Steuerungstechnik.
Hanser, 2006

Vollständiger STF-Umdruck

Transcription

Similar documents

Teil 1 - U. Ohm

Geschäftsinnovationen durch BPM-Technologien und SOA

1 Grundlagen - RISC

Standardregler Typ a...i

Bastelzeit Magazin März / April 2014

Masterarbeit Fischer - Jean

Erste Schritte PROFIsafe Module Fa. WAGO Anwendungshinweis

Kap6_Programmiersprachen

- Journal - embedded projects

COSINA Super 8 Professional

Wechselstrom – Alternating Current (mit Drehstrom)

theoretische Ansätze zur Erklärung individueller Radikalisierung

Schweigen, schauen und staunen auf dem Jakobsweg

Ampelschaltung mit dem Raspberry Pi