Versuchsanleitung - ias.uni-stuttgart.de

Universität Stuttgart
Institut für Automatisierungs- und Softwaretechnik
Prof. Dr.-Ing. Dr. h. c. P. Göhner
Grundlagenpraktikum: Versuch Nr. 27
Einführung in die SPS-Programmierung
Durchführungsort: 2.145
Weitere Infos und Unterlagen unter
www.ias.uni-stuttgart.de/glp
IAS – Universität Stuttgart
Pfaffenwaldring 47
D-70550 Stuttgart
Telefon (0711) 685-67301
Telefax (0711) 685-67302
[email protected]
www.ias.uni-stuttgart.de
Teilnehmerunterlagen
Institut für Automatisierungs- und Softwaretechnik
2
0 Inhaltsverzeichnis
0
INHALTSVERZEICHNIS .............................................................................................. 2
1
EINFÜHRUNG................................................................................................................. 3
1.1
Speicherprogrammierbare Steuerungen (SPS) ........................................................... 3
1.2
Die SPS Siemens SIMATIC S7 ................................................................................. 4
1.3
Programmieransätze nach Norm DIN EN 61131 ....................................................... 5
1.3.1
Anweisungsliste (AWL) ..................................................................................... 5
1.3.2
Kontaktplan (KOP) ............................................................................................ 5
1.3.3
Funktionsplan (FUP) .......................................................................................... 5
1.3.4
Strukturierter Text (ST) ...................................................................................... 6
1.3.5
Ablaufsprache (AS) ............................................................................................ 6
1.4
Die Entwicklungsumgebung STEP7 .......................................................................... 7
1.5
Die Umsetzung der Programmieransätze in STEP7 .................................................. 8
1.5.1
Der Editor für AWL, KOP und FUP .................................................................. 8
1.5.2
S7-GRAPH ......................................................................................................... 8
2
VERSUCHSTERMIN ....................................................................................................... 9
2.1
2.2
2.3
2.4
3
Ansteuerung eines Lichts ........................................................................................... 9
Erweiterung auf die ganze Ampel ............................................................................ 13
Einsatz von Schaltzeiten........................................................................................... 13
Außer-Betrieb-Setzen der Ampel ............................................................................. 15
ANHANG ........................................................................................................................ 20
3.1
Definition der Steuerung .......................................................................................... 20
3.2
Programmiersprachen in STEP7 - Befehle und Syntax ........................................... 20
3.2.1
AWL ................................................................................................................. 20
3.2.2
S7-GRAPH ....................................................................................................... 21
3.3
Abbildungsverzeichnis ............................................................................................. 22
3.4
Literaturhinweise ...................................................................................................... 22
Versuch Nr. 27
Speicherprogrammierbare Steuerungen
Versuchsanleitung
Institut für Automatisierungs- und Softwaretechnik
3
1 Einführung
Dieser Umdruck sollte vor dem Versuchsbeginn durchgearbeitet werden. Er enthält
Informationen, Beispiele, Anleitungen und begleitende Aufgaben für die Versuchsdurchführung.
Die VORBEREITUNGSFRAGEN müssen vor dem Versuchstermin beantwortet bzw. bearbeitet
werden.
Die AUFGABEN sind während der Versuchsdurchführung zu bearbeiten.
Ziel des Versuchs ist die Realisierung der Steuerung einer Lichtzeichenanlage, die den
Verkehr auf einer Straßenkreuzung regeln soll.
1.1 Speicherprogrammierbare Steuerungen (SPS)
Das Einsatzgebiet speicherprogrammierbarer Steuerungen (SPS) reicht von der einfachen
Steuerung eines automatischen Tores mit wenigen Signalein- und -ausgängen bis zu
komplexen Fertigungsanlagen mit einer großen Anzahl von Ein- und Ausgängen. Gegenüber
einer Kontaktsteuerung mit fest verdrahteter Ablauflogik beschränkt sich der Verdrahtungsaufwand bei einer SPS auf den Anschluß der Sensoren und Aktoren. Die
Verdrahtung der logischen Funktionen entfällt und wird durch das Programm der SPS ersetzt.
Durch Verändern des Programms lässt sich eine SPS leicht an geänderte Betriebsbedingungen
anpassen.
In Abbildung 1-1 ist der prinzipielle Aufbau einer SPS dargestellt. Eine SPS besteht
mindestens aus der Stromversorgung, einer Kerneinheit mit CPU und Speicher, und einem
Ein- und / oder Ausgangsmodul. Dieser minimale Aufbau zusammen mit der
Programmierperipherie und den Lichtsignalanlagen bilden den Aufbau in diesem Versuch.
Abbildung 1-1: Prinzipieller Aufbau einer SPS
Versuch Nr. 27
Speicherprogrammierbare Steuerungen
Versuchsanleitung
Institut für Automatisierungs- und Softwaretechnik
4
1.2 Die SPS Siemens SIMATIC S7
Die im Versuch verwendete Siemens SIMATIC S7-300 ist eine Kompakt-SPS, in die ein
Modul mit 24 digitalen Eingängen, 16 digitalen Ausgängen und verschiedenen analogen Einund Ausgängen integriert ist. Sie wird über einen PC programmiert. Das fertige Programm
wird auf die SPS kopiert und dort ausgeführt.
Zur komfortablen Programmierung der SPS dient die im späteren Verlauf beschriebene
Entwicklungsumgebung STEP7. Mit ihr ist eine Programmierung in den
Programmiersprachen AWL, KOP, FUP, SCL und einer Ablaufsprache (AS) namens S7GRAPH möglich. Die einzelnen Programmiersprachen und STEP7 werden in den folgenden
Kapiteln kurz vorgestellt. Die Zustände der digitalen Ein- und Ausgänge der S7 sind in einem
Speicherabschnitt abgebildet. Die Einteilung der Ein- und Ausgänge erfolgt deshalb
Byteweise, das heißt immer 8 Ein- oder 8 Ausgänge bilden jeweils einen Block, der dann sehr
einfach binär auf dem Speicher abgebildet werden kann. Jeder Ein- beziehungsweise Ausgang
wird durch ein Bit repräsentiert, wobei eine „0“ für die Abstinenz und eine „1“ für die
Existenz eines Signals steht. Die Adressierung der Ein- und Ausgänge in einem Programm
besteht aus einem „E“ für Eingang beziehungsweise „A“ für Ausgang mit nachgestellter
Byte- und einer durch einen Punkt getrennten Bitnummer innerhalb des Bytes. Byte- und
Bitnummerierung beginnen bei 0.
Beispiel:
Der dritte Ausgang im zweiten Byte würde mit A1.2 adressiert
Der erste Eingang im ersten Byte würde mit E0.0 adressiert.
Auf der SPS sind alle Angaben auf Englisch, das heißt „E“ ist „DI“ („Digital input“) und „A“
ist „DO“ („Digital output“). Abbildung 1-2 zeigt die Draufsicht auf die Kerneinheit der SPS.
Rechts sieht man die integrierten Steckereinschübe, an die die Ein- und Ausgangsleitungen
angeschlossen sind. Man erkennt auch die byteweise Gruppierung der Ein- und Ausgänge.
Die seitlich integrierten LEDs zeigen den aktuellen Schaltzustand an.
Abbildung 1-2: Draufsicht auf die SPS-Kerneinheit mit integrierten Modulen
Versuch Nr. 27
Speicherprogrammierbare Steuerungen
Versuchsanleitung
Institut für Automatisierungs- und Softwaretechnik
5
1.3 Programmieransätze nach Norm DIN EN 61131
In diesem Kapitel sollen die einzelnen genormten Programmieransätze anhand eines kleinen
Beispiels einer UND-Verknüpfung kurz vorgestellt werden.
1.3.1
Anweisungsliste (AWL)
Die Anweisungsliste kann als Assemblersprache der SPS-Programmierung angesehen
werden. Sie wirkt recht kryptisch und unübersichtlich. Eine Programmierung größerer
Anwendungen in AWL ist daher nicht empfehlenswert. In Abbildung 1-3 ist die Realisierung
des Beispiels in AWL zu sehen. Ein vorgestelltes „U“ markiert die UND-verknüpften
Adressen, „= „ bedeutet eine Zuweisung des Ergebnisses der vorangehenden Anweisung(en)
an die nachgestellte Adresse.
Abbildung 1-3: UND-Verknüpfung in AWL
1.3.2
Kontaktplan (KOP)
Im Kontaktplan werden die Ein- und Ausgänge durch Schalter und Schütze symbolisiert. Man
sieht auf der linken und rechten Seite jeweils eine Stromlaufschiene, zwischen die die
Schaltelemente platziert werden. Wird nun ein Eingang (Schalter) geschlossen fließt durch
selbigen Strom, der je nach Schaltung einen Ausgang (Schütz) durchsteuert oder andere
Prozesse in Gang setzt. In den Abbildungen 1-4 ist das Beispiel in KOP umgesetzt.
Abbildung 1-4: UND in KOP
1.3.3
Funktionsplan (FUP)
Ein Funktionsplan besteht aus verschiedenen Funktionsblöcken mit Eingängen und
Ausgängen. Im Funktionsplan wird anhand von logischen Schaltungen (im binären Fall), wie
in der Technischen Informatik programmiert. In den Abbildungen 1-5 sind die Beispiele in
einem Funktionsplan realisiert.
Abbildung 1-5: UND als Funktionsplan
Versuch Nr. 27
Speicherprogrammierbare Steuerungen
Versuchsanleitung
Institut für Automatisierungs- und Softwaretechnik
1.3.4
6
Strukturierter Text (ST)
Strukturierter Text ist wie AWL eine textuelle Programmiersprache. ST ähnelt aber eher den
frühen Hochsprachen wie BASIC oder PASCAL. Es gibt komplexere Sprachelemente wie
zum Beispiel Schleifen oder Bedingungen um den Programmfluss zu steuern. Abbildung 1-6
zeigen die kurzen Codefragmente für die Beispiele.
Abbildung 1-6: UND in Strukturiertem Text
1.3.5
Ablaufsprache (AS)
Ablaufsprachen beruhen auf dem Modell der Petri-Netze. Sie sind aufgebaut aus sogenannten
STELLEN, TRANSITIONEN und KANTEN. Eine Stelle im Modell ist vergleichbar mit einem
Zustand in der Realität. Transitionen hingegen kennzeichnen Ereignisse, die zum
Zustandsübergang führen, sind also Weiterschaltbedingungen. Stellen und Transitionen sind
über Kanten miteinander verbunden, und zwar so, dass eine Kante immer genau eine Stelle
mit einer Transition verbindet (siehe Abbildungen 1-7).
KANTE
STELLE
TRANSITION
Abbildung 1-7: Einfachstes Petri Netz
Ist eine Stelle aktiviert, so erhält sie im Modell ein Token (Markierung, hier durch einen
Punkt gekennzeichnet). Sind alle zum Weiterschalten erforderlichen Bedingungen erfüllt, so
schaltet die Transition. Dabei werden alle unmittelbar vor der Transition liegenden Stellen
deaktiviert und alle unmittelbar nachfolgenden Stellen aktiviert.
Ein Beispiel:
vorher
nachher
Abbildung 1-8: Zustand des Petri Netzes vor und nach Durchschalten der Transition
Versuch Nr. 27
Speicherprogrammierbare Steuerungen
Versuchsanleitung
Institut für Automatisierungs- und Softwaretechnik
1.4
7
Die Entwicklungsumgebung STEP7
Die Entwicklungsumgebung STEP7 wird zur Erstellung der SPS-Programme verwendet.
Sobald das Programm gestartet wurde erscheint ein Assistent um ein neues Projekt anzulegen.
Der Assistent hilft die erforderlichen Grundeinstellungen festzulegen. So muss zum Beispiel
der richtige CPU, in unserem Fall der „CPU314C-2 DP“, eingestellt werden und dem Projekt
muss einen Namen gegeben werden.
Nach Fertigstellung des Assistenten erscheint der Projektexplorer, welcher das zentrale
Element der Entwicklungsumgebung ist. Er funktioniert wie die meisten Datei-Explorer.
Abbildung 1-9: Der Projektexplorer
Wenn man den Baum einmal komplett expandiert kann man die Grundstruktur eines Projekts
in STEP7 erkennen. Der Wurzelknoten ist immer das Projekt selbst. Innerhalb des Projekts
kann es mehrere verschiedene Stationen geben (In unserem Fall gibt es nur eine Station).
Jeder Station ist eine CPU zugeordnet. Innerhalb der CPU befindet sich die Anwendung
beziehungsweise ein Programm. Ein Programm wiederum besteht aus Quellen und
Bausteinen.
In den Menüs gibt es eine Vielzahl an verschiedenen Optionen und Konfigurationsmöglichkeiten, deren genauere Beschreibung im Rahmen dieses Grundlagenpraktikums nicht
vorgenommen werden kann.
Bevor man mit der Programmierung loslegen kann muss man noch einige Einstellungen
durchführen. Diese Konfigurationen müssen jedes Mal, wenn ein neues Projekt erstellt wird
an die verwendete Hardware angepasst werden.
Nachdem alles korrekt eingestellt ist speichert man die Konfiguration und schließt die
Konfigurationsanwendung. Die Konfiguration muss jetzt nur noch auf die SPS geladen
werden. Zuerst muss die CPU urgelöscht werden, das heißt alle Daten und Konfigurationen
bis auf die systemeigenen Daten werden zurückgesetzt. Dazu wird der
Betriebszustandsschalter an der eingeschalteten SPS auf „STOP“ gestellt. Man markiert den
Stationsknoten im Projektexplorer und wählt aus dem Menu > Zielsystem > Urlöschen.
Danach muss man die Konfiguration laden. Man markiert wieder den Stationsknoten und
wählt dieses Mal aus dem Menu > Zielsystem > Laden aus.
Jetzt kann mit der Programmierung begonnen werden.
Versuch Nr. 27
Speicherprogrammierbare Steuerungen
Versuchsanleitung
Institut für Automatisierungs- und Softwaretechnik
8
1.5 Die Umsetzung der Programmieransätze in STEP7
Die Programmierung einer SPS basiert in STEP7 ausschließlich auf Bausteinen
beziehungsweise Quellen. Es gibt verschiedene Typen von Bausteinen, je nachdem was für
eine Funktion sie erfüllen. Man erkennt den Typ an ihrem Namen, der mit der eindeutigen
Abkürzung für den Bausteintyp beginnt. Für das Praktikum wichtige Bausteintypen sind
Organisationsbausteine (OB), Funktionsbausteine (FB), Funktionen (FC) und Datenbausteine
(DB). Manche Bausteine können nur in bestimmten Programmiersprachen erstellt werden.
Andere Bausteine hängen von einem mit ihnen assoziierten Baustein eines bestimmten Typs
ab. Diese Fälle werden in den folgenden Kapiteln und wenn sie für das Praktikum relevant
sind an entsprechender Stelle erklärt. Die im Namen auf die Typbezeichnung folgende
Nummer dient der genauen Identifizierung der Bausteine. Sie wird bei der Erstellung neuer
Bausteine einfach inkrementiert. Der „Urbaustein“ in dem die Programmabarbeitung beginnt
ist immer der Baustein OB1. Man kann das Programm direkt in diesem Baustein
implementieren oder erstellt eigene Bausteine, die aus OB1 heraus aufgerufen werden. In
OB1 kann nur in AWL, KOP und FUP programmiert werden. Im Anhang befindet sich ein
Überblick zur Syntax und zu den Befehlen der einzelnen, hier beschriebenen
Programmiersprachen in STEP7.
1.5.1
Der Editor für AWL, KOP und FUP
Wenn man im Projektexplorer im Knoten Bausteine auf einen Baustein doppelt klickt, der in
AWL, KOP oder FUP erstellt wurde, öffnet sich der Editor in Abbildung 1-10.
Abbildung 1-10: Der Editor für AWL, KOP und FUP
Im Menü > Ansicht kann zwischen den drei Programmiersprachen hin- und hergeschaltet
werden. Im Hauptfenster in der Mitte des Anwendungsbereiches wird das Programm erstellt.
In AWL werden die Anweisungen einfach zeilenweise in den Bereich unter dem
Kommentarfeld des Netzwerks eingegeben. In KOP werden die Programmelemente eingefügt
indem man die Stelle markiert an der das Element eingefügt werden soll und in der
Funktionsleiste auf der linken Seite oder im Menü > Einfügen das entsprechende Elemente
auswählt. Gleiches gilt für die Programmiersprache FUP.
1.5.2
S7-GRAPH
S7-GRAPH setzt das Prinzip einer Ablaufsprache um. Man programmiert mit Schritten und
Transitionen. Zu jedem Schritt gehört ein Aktionsblock, der die Aktionen enthält, die
während des Schrittes abgearbeitet werden. Die Programmierung der Aktionen erfolgt in einer
Versuch Nr. 27
Speicherprogrammierbare Steuerungen
Versuchsanleitung
Institut für Automatisierungs- und Softwaretechnik
9
textuellen Sprache nach festen Regeln, deren Einzelheiten im Anhang und den
entsprechenden Stellen näher beschrieben sind.
Abbildung 1-11: Der Editor für S7-GRAPH-Bausteine
Die Bedingungen für die Transitionen können nur in KOP oder FUP programmiert werden.
Zwischen den beiden Programmiersprachen kann im Menü > Ansicht umgeschaltet werden.
In der Funktionsleiste am linken Rand sind, je nachdem welchen Typ das gerade ausgewählte
Element hat, unterschiedliche Schaltflächen aktiv, über die man zusätzliche Elemente
einfügen kann. Wenn man ein fertig gestelltes Programm speichert, wird es sofort übersetzt.
2 Versuchstermin
Dieser Abschnitt befasst sich mit der Einführung in die Bedienung und Programmierung der
SPS. Zunächst wird die Steuerung einer einzelnen Ampel programmiert. Dabei werden die
nötigen Schritte nacheinander beschrieben und die Möglichkeiten erläutert, die die
Programmierung mit STEP7 zur Umsetzung der Forderungen bietet.
2.1 Ansteuerung eines Lichts
Nachdem mit dem Assistenten ein neues Projekt angelegt wurde mit dem Namen
„Gruppe<Gruppennummer>Termin<Terminnummer>“, alle Einstellungen vorgenommen
wurden und der Programmknoten noch in „Ampelprogramm“ umbenannt wurde kann mit
dem programmieren angefangen werden.
In einem ersten Schritt wird die Ampel so programmiert, dass lediglich das rote Licht dauernd
leuchtet. Der mit diesem Licht verbundene Ausgang hat die Nummer 0.0. Um das Programm
von vornherein gut lesbar zu gestalten, wird zunächst ein Name, in STEP7 auch Symbol
genannt, für diesen Ausgang definiert. Dazu dient die Symboltabelle im Programmknoten des
Projektbaums.
Versuch Nr. 27
Speicherprogrammierbare Steuerungen
Versuchsanleitung
Institut für Automatisierungs- und Softwaretechnik
10
Bei einem Doppelklick auf das Icon „Symbole“ erscheint ein Editor.
Die Symbole müssen eindeutig sein. Jeder Adresse darf nur ein Symbol zugewiesen werden.
In unserem Fall heißt das Symbol „RotLicht“. Im Adressfeld muss „A0.0“ eingetragen
werden (A steht für Ausgang, 0.0 für „erstes Bit im ersten Byte“ im Ausgangsadressbereich).
Der Datentyp wird automatisch ausgefüllt. Die Tabelle sollte dann wie Abbildung 2-1
aussehen.
Abbildung 2-1: Die Symboltabelle
Nachdem man die Symboltabelle gespeichert und den Editor geschlossen hat geht es an die
Programmierung des ersten Programms.
Zuerst muss man einen
Baustein in das Projekt
einfügen. Dies macht man
allgemein indem man im
Projekt-explorer
den
Baustein- knoten auswählt
und diesen mit der rechten
Maustaste anklickt um das
Kontextmenü zu öffnen.
Abbildung 2-2: Das Kontextmenü zum Bausteinknoten
In GRAPH ist es nur möglich Funktionsbausteine zu schreiben. Eine genauere Erklärung
hierzu erfolgt später.
Man wählt also im Kontextmenü Neues Objekt einfügen > Funktionsbaustein. Es öffnet sich
ein Dialog in dem man die Bausteineigenschaften einstellen kann.
Der Name des Bausteins wird, wie in Kapitel
1.4 beschrieben, automatisch vergeben. Er
muss hier auch nicht verändert werden. Im
Feld
„Symbolischer
Name“
wird
„Ampelsteuerung“ eingetragen. In der
Auswahlliste
„Erstellsprache“
wird
„GRAPH“ eingestellt. Die restlichen
Einstellungen können beibehalten werden.
Der Dialog wird mit „OK“ bestätigt.
Abbildung 2-3: Die Bausteineigenschaften von Funktionsbausteinen
Versuch Nr. 27
Speicherprogrammierbare Steuerungen
Versuchsanleitung
Institut für Automatisierungs- und Softwaretechnik
11
Da die Erstellsprache auf „GRAPH“ eingestellt ist, öffnet sich bei einem Doppelklick auf
„FB1“ automatisch der S7-GRAPH-Editor. Mit seiner Hilfe wird der Baustein erstellt.
Die Ampel nimmt während der gesamten Laufzeit nur einen einzigen Zustand an. Prinzipiell
sind also alle Elemente, die für dieses Beispiel benötigt werden, beim Starten des Editors
schon vorhanden. Es gibt einen Initialschritt (der Schritt mit einem doppelten Rand), der den
Startpunkt für den Programmablauf innerhalb eines GRAPH-Bausteins darstellt, mit
zugehörigem Aktionsblock und einer Transition mit einer leeren Bedingung. Die Elemente
müssen nur noch richtig benannt und mit Leben gefüllt werden. Der Schritt wird „ZeigeRot“
genannt, die Transition „WechselZuRot“. Um einen zyklischen Verlauf zu bekommen muss
am Ende der Schrittkette, an die Transition „WechselZuRot“, noch ein Sprung auf den
Startknoten eingefügt werden. Dazu muss man die Transition auswählen. Im oberen Bereich
der Funktionsleiste auf der linken Seite sollten dann die Symbole für das Einfügen von
„Schritt und Transition“, „Sprung“ und „Kettenende“ aktiviert sein. Man klickt auf die
Schaltflache für „Sprung“ und wählt als Sprungziel den Initialschritt „ZeigeRot“ durch einen
einfachen Klick mit der Maus auf den Schritt.
Jetzt fehlt nur noch die Aktion, die während „ZeigeRot“ ausgeführt werden soll. Um eine
Aktion in den Aktionsblock einzufügen, macht man einen Rechtsklick auf den Aktionsblock.
Im ersten Eingabefeld wird die Aktion, die ausgeführt werden soll, genauer spezifiziert. Jeder
Aktionstyp hat ein Abkürzungssymbol, das im ersten Feld eingetragen wird. Je nachdem was
für ein Aktionstyp gewählt wurde, muss in dem zweiten Feld ein entsprechender Operand
eingegeben werden auf den die Operation angewendet wird. Die wichtigsten dieses
Aktionstypen sind im Anhang näher beschrieben.
Wir müssen in unserem Programm eine der grundlegendsten Operationen durchführen – der
Ausgang soll solange aktiv sein, wie das Programm im Schritt „ZeigeRot“ ist. Die Abkürzung
für diesen Befehl ist ein „N“, das man in das erste Feld einträgt. Man kann mit dieser Aktion
beliebige boolesche Variablen setzten, solange der zugehörige Schritt aktiv ist auf „true“
beziehungsweise ein Bit auf „1“. In unserem Fall ist diese boolesche Variable der Ausgang
A0.0, also das erste Bit im ersten Byte des Ausgangsspeicherabbildes, den wir oben mit
„RotLicht“ bezeichnet hatten. Man kann in das zweite Feld nun die absolute Adresse „A0.0“
oder, einfach aus Gründen der Übersichtlichkeit und Verständlichkeit, den symbolischen
Namen „RotLicht“ eintragen. Das „N“ steht für „nicht speichernd“, das heißt sobald der
Schritt nicht mehr aktiv ist, wird auch die Variable zurückgesetzt.
Der fertige Ablauf sollte dann etwa so aussehen, wie in Abbildung 2-4 dargestellt. Da die
Transition immer durchschaltet, wechselt das Programm während des Ablaufs immer vom
Schritt „ZeigeRot“ in den Schritt selbst, weshalb die Ampel folglich immer Rot zeigt.
im S7-GRAPH-Editor
als Petri-Netz
Schritt
„ZeigeRot“
Transition
„WechselZuRot“
Abbildung 2-4: Das erste Programm
Versuch Nr. 27
Speicherprogrammierbare Steuerungen
Versuchsanleitung
Institut für Automatisierungs- und Softwaretechnik
12
Der Baustein muss nun nur noch gespeichert werden. Wenn man einen GRAPH-Baustein
speichert wird er direkt übersetzt.
Wenn man sich die Ansicht des Knotens „Bausteine“ jetzt einmal näher ansieht bemerkt man,
dass einige Bausteine automatisch hinzugefügt wurden. Dazu gehören einige Systembausteine
und ein Datenbaustein „DB1“. Zu jedem Funktionsbaustein in GRAPH gehört ein
Datenbaustein ohne den er nicht lauffähig wäre. Im Datenbaustein sind alle wichtigen
Informationen über den Funktionsbaustein gespeichert. Dieser Datenbaustein ist auch für den
nächsten Schritt wichtig.
Da der Programmablauf immer im Organisationsbaustein OB1 beginnt muss man aus diesem
Baustein heraus den Funktionsbaustein mit unserem gerade erstellten Programm aufrufen. Mit
einem Doppelklick auf OB1 öffnet sich der Editor. In den Programmierbereich des Editors
schreibt man die Zeile „CALL FB1, DB1“ und drückt die Eingabetaste. Daraufhin wird
„FB1“ durch den symbolischen Namen „Ampelsteuerung“ ersetzt und es erscheint eine Reihe
von Eingabeparametern (die übrigens auch im Datenbaustein DB1 gespeichert sind). Für uns
sind diese Parameter momentan noch nicht von Bedeutung. Man kann den OB1, wenn er wie
in Abbildung 2-5 aussieht abspeichern und den Editor schließen.
Abbildung 2-5: Der Aufruf des Funktionsbausteins aus OB1 heraus
Die Konfiguration und das Programm, also die Bausteine, müssen jetzt nur noch auf die SPS
geladen werden. Dazu stellt man zuerst den Betriebszustandsschalter der eingeschalteten SPS
(siehe Abbildung 1-2) auf „STOP“. Dann wählt man im Projektexplorer den Knoten
„Bausteine“ aus und öffnet mit einem Rechtsklick auf den Knoten das Kontextmenü. In
diesem Menü wählt man Zielsystem > Laden.
Vorbereitungsfrage 1: Erstellen sie für die für die Programmieransätze AWL, FUP, KOP
und ST jeweils eine ODER-Verknüpfung mit zwei Eingängen.
Aufgabe 1:
Versuch Nr. 27
Erstellen Sie das Projekt und die Ressourcen wie oben beschrieben. Laden
Sie das Programm auf die SPS. Stellen Sie den Betriebszustandsschalter auf
„RUN“ und beobachten und diskutieren Sie das Ergebnis.
Speicherprogrammierbare Steuerungen
Versuchsanleitung
Institut für Automatisierungs- und Softwaretechnik
13
2.2 Erweiterung auf die ganze Ampel
In einem zweiten Schritt wird nun die Steuerung auf die ganze Ampel ausgedehnt. Das
Vorgehen soll völlig analog zur vorigen Aufgabe sein. Anstatt ein neues Projekt anzulegen,
wird das bestehende Projekt aber nur erweitert.
Vorbereitungsfrage 2: Bitte erstellen Sie auf einem getrennten Blatt die zu dieser
Aufgabenstellung passende Schrittkette mit vier Schritten (wie die
Ampelphasen einer realen Ampel). Benutzen Sie analoge
Bezeichnungen (Gelblicht, GruenLicht).
(Hinweis Petri-Netz)
Bemerkung:
In einem Aktionsblock können mehrere Aktionen stehen (zum
Beispiel zwei Lichter, die gleichzeitig leuchten sollen). Weitere
Aktionen werden einem Aktionsblock durch gleiches Vorgehen, wie
bei der ersten Aktion hinzugefügt. Die Aktionen werden dann in
einer einfachen Liste unter dem Aktionsblock angezeigt.
Vorbereitungsfrage 3: Was wird die Ampel vermutlich anzeigen, wenn sie mit diesem
Programm in Betrieb genommen wird? Woran liegt das?
Aufgabe 2:
Ergänzen Sie die Symboltabelle mit den Einträgen für die neuen
Ausgänge. Das gelbe Licht ist an Ausgang A0.1, das grüne Licht an
Ausgang A0.2 angeschlossen.
Erstellen Sie die von Ihnen im Vorfeld erarbeitete Schrittkette im
GRAPH-Editor, indem Sie den vorhandenen Baustein „FB1“ um die
neuen Schritte und Transitionen ergänzen. Nehmen Sie das
Programm in Betrieb und diskutieren Sie auch hier das Ergebnis.
(Vergessen sie das Urlöschen nicht!)
2.3 Einsatz von Schaltzeiten
Um einen Zustand für eine bestimmte Zeitdauer zu halten, bevor die Transition schalten kann,
muss zuerst die Zeitdauer festgelegt werden. Um allgemein Daten zu speichern benötigt man
einen Datenbaustein. Jeder Funktionsbaustein hat einen solchen Datenbaustein um seinen
inneren Zustand zu speichern. Wir stellen die Variablen einfach in einem separaten globalen
DB zur Verfügung. Dazu muss man zunächst einen Datenbaustein erstellen.
Es erscheint ein Konfigurationsdialog. In diesem
Dialog müssen nur zwei Änderungen gemacht
werden. Zum einen wird der Name des Bausteins in
„DB4“ geändert, zum anderen vergeben wir den
symbolischen Namen „GLOBALS“ um zu
kennzeichnen, dass der Datenbaustein globale
Variablen enthält. Die restlichen Eigenschaften
können unverändert bleiben
Abbildung 2-6: Der Dialog Eigenschaften von Datenbausteinen
Versuch Nr. 27
Speicherprogrammierbare Steuerungen
Versuchsanleitung
Institut für Automatisierungs- und Softwaretechnik
14
Ein Doppelklick auf den Datenbaustein öffnet den Editor. Hier müssen einfache Variablen
vom Typ TIME, denen wir einen konstanten Anfangswert zuweisen, eingetragen werden. Ein
Wert beginnt mit einem „T#“ gefolgt vom einer Zeitangabe im Format „yMzS“. y und z sind
aus der Menge der natürlichen Zahlen von 0 bis 59, wobei man eine „0“ nicht angeben muss
(siehe Abbildung 2-7). M und S bedeuten Minuten und Sekunden.
Beispiel: T#2M44S ist eine Zeitspanne von 2 Minuten und 44 Sekunden
Abbildung 2-7: Die Tabelle eines Datenbausteins
Wenn die Eintragungen gemacht wurden kann der Baustein gespeichert und der Editor
geschlossen werden.
Als nächstes öffnen wir wieder den Baustein „FB1“. Um die Schaltzeiten zum Einsatz zu
bringen sollte man als Aktionstyp den nicht-speichernden Typ wählen, da man mit der
Schaltzeit die Zeitdauer angibt, für die der Schritt aktiv ist.
Abbildung 2-8: Schritt und Transition mit Schaltzeit als Bedingung
Wie in Abbildung 2-8 zu sehen ist, muss man außerdem die Transitionen der einzelnen
Schritte mit Leben füllen.
Die Bedingungen für die Transitionen lassen sich in der Programmiersprache KOP sehr
anschaulich realisieren. Man verwendet Schließer, Öffner und Vergleicher. Anschaulich kann
man sagen, sobald „Strom fließen“ kann schaltet die Transition. Wenn also an einem
Schließer der Wert 1 beziehungsweise „true“ an einem Öffner der Wert 0 beziehungsweise
„false“ liegt oder der Vergleich das Ergebnis 1 beziehungsweise „true“ liefert, schaltet die
daran angeschlossene Transition. Prinzipiell ist ein Öffner die Negation, ein Schließer eine
einfache Weiterleitung des daran anliegenden logischen Signals und ein Vergleicher, wie der
Name schon sagt, der Vergleich zweier boolescher Werte.
In Abbildung 2-8 wird das KOP-Element Vergleicher („Cmp“) benutzt um die vorgegebene
Zeit „GLOBALS“.RotZeit mit der seit Aktivierung des Schritts vergangenen Zeit zu
vergleichen. Die Transition soll schalten sobald der Schritt mindestens die vorgegebene Zeit
aktiv war.
Versuch Nr. 27
Speicherprogrammierbare Steuerungen
Versuchsanleitung
Institut für Automatisierungs- und Softwaretechnik
15
Um die Programmierung der Bedingungen in KOP vorzunehmen wechselt man mit
Menü > Ansicht > KOP in die Programmiersprache KOP. Das Einfügen der Öffner,
Schließer und Vergleicher geschieht über die Schaltflächen in der Funktionsleiste ganz
unten. Man markiert die Stromlaufschiene an der Bedingung auf der linken Seite und
betätigt dann die gewünschte Schaltfläche.
Die Verknüpfungen sehen in GRAPH wie in den folgenden Abbildungen aus:
Abbildung 2-9: UND- und ODER-Verknüpfung in GRAPH
Wie man in Abbildung 2-9 sieht kann man mehrere Bedingungen auf die oben beschriebene
Weise einfügen. Man kann die UND- und ODER-Verknüpfungen bei entsprechender
Vorgehensweise auch kombinieren.
Aufgabe 3:
Bitte ändern Sie die Aktionsblöcke im Funktionsbaustein FB1, so dass die
einzelnen Phasen mit den entsprechend benannten Schaltzeiten geschaltet
werden. Die Phase „ZeigeRotGelb“ soll dabei die Dauer „GelbZeit“ haben.
Ändern Sie die Transitionen wie oben besprochen und nehmen Sie das
Programm erneut in Betrieb.
Hinweis:
Um die Schreibarbeit etwas zu reduzieren kann man die automatische
Korrektur in STEP7 nutzen. Man kann zum Beispiel anstatt
„GLOBALS“.RotZeit auch globals.rotzeit schreiben. STEP7 korrigiert den
Ausdruck nach Betätigen der Returntaste automatisch. In Schrittketten kann
man mit gleicher Vorgehensweise auch die Schrittbezeichner anstatt die
Schrittnamen zur Formulierung der Bedingungen verwenden, d.h. man
schreibt zum Beispiel S1.T anstatt ZeigeRot.T (siehe Abbildung 2-8).
STEP7 ergänzt auch diesen Ausdruck automatisch.
2.4 Außer-Betrieb-Setzen der Ampel
Als letzte Entwicklungsstufe soll die Ampel per Schalter außer Betrieb gesetzt werden
können. Nach dem Einschalten und nach dem Ausschalten durch einen Schalter soll das gelbe
Licht der Ampel jeweils dreimal blinken, bevor die normale Funktion der Ampel beginnt,
bzw. sie außer Betrieb geht. Dazu verwenden wir zwei zusätzliche Funktionsbausteine und
zwei Funktionen (Eine Funktion ist ebenfalls ein Bausteintyp).
Wir haben ab diesem Punkt also mehrere verschiedene Abläufe / Schrittketten, die zu
verschiedenen Zeitpunkten ablaufen sollen. Man könnte dies bestimmt durch irgendwelche
zusätzlichen Bedingungen, Sprünge oder andere Verzweigungen in GRAPH realisieren. Dies
wäre aber eine sehr unübersichtliche und unsaubere Sache. Anschaulicher und sinnvoller ist
es die Steuerung des Wechsels zwischen den verschiedenen Modi, also die Organisation der
Funktionsbausteine, in einem Organisationsbaustein zu lösen.
Versuch Nr. 27
Speicherprogrammierbare Steuerungen
Versuchsanleitung
Institut für Automatisierungs- und Softwaretechnik
16
Um das Prinzip des Ablaufs eines SPS-Programms auf der S7 näher zu verstehen ist es
essentiell wichtig die unterschiedlichen Bausteintypen und ihre Eigenschaften zu kennen.
Organisationsbausteine dienen der Organisation der anderen Bausteine wie zum Beispiel
Funktionen.
Funktionen sind im Prinzip die Arbeiter des Programms. Sie erledigen bei jedem Aufruf die
gleiche Arbeit. Man kann zum Beispiel eine bestimmte Menge von Ausgängen setzen,
Berechnungen durchführen oder Bedingungen prüfen um die Organisation modularer zu
gestalten. Die Funktionen besitzen im Gegensatz zu Funktionsbausteinen kein Gedächtnis,
das heißt sie merken sich keine Ergebnisse oder bestimmte Rechenschritte, sie führen immer
die gleichen Operationen durch.
Funktionsbausteine haben ein Gedächtnis in Form eines Datenbausteins, der bei ihrem
Aufruf immer mit angegeben werden muss. Im Datenbaustein stehen alle Übergabewerte, der
innere Zustand des Bausteins und die Position die gerade bearbeitet wird. Bei GRAPHFunktionsbausteinen heißt das anschaulich, dass im Datenbaustein der aktuelle Schritt, aktive
und deaktivierte Schritte und der Zustand von Transitionen gespeichert sind. Durch dieses
Gedächtnis ergibt sich aber ein Problem. Wir können an verschiedenen Stellen nicht den
selben Funktionsbaustein verwenden, da er sich an seinen Zustand „erinnert“ und bei seinem
zweiten Aufruf nicht von vorne beginnt, sondern an der Stelle weiter macht, an der er bei
seinem
letzten Aufruf unterbrochen wurde. Man benötigt also zwei separate
Funktionsbausteine oder zumindest separate Datenbausteine.
Datenbausteine sind einfach eine Möglichkeit Daten in Variablen zu speichern. Sie besitzen
keine operative Funktionalität.
Innerhalb der Bausteine gibt es die Möglichkeit so genannte „Netzwerke“ anzulegen. Jedes
Netzwerk repräsentiert dabei ein unabhängig ablaufendes Programm. Diese Programme
werden quasi-parallel abgearbeitet.
In Abbildung 2-10 ist der prinzipielle Ablauf des zu erstellenden Programms dargestellt und
soll jetzt Schritt für Schritt beginnend mit einer kurzen Einführung in das allgemeine
Ablaufverhalten von SPS-Programmen erklärt werden.
Abbildung 2-10: Prinzipielle Struktur des Programms
Versuch Nr. 27
Speicherprogrammierbare Steuerungen
Versuchsanleitung
Institut für Automatisierungs- und Softwaretechnik
17
Das SPS-Betriebssystem beginnt mit dem Aufruf des benötigten Einsprungpunktes, in
unserem Fall der OB1.
Im OB1 werden andere Bausteine aufgerufen oder Anweisungen ausgeführt. Sobald alle
Zeilen im OB1 durchlaufen wurden wird wieder an das Betriebsystem zurückgegeben, das
jetzt die Ausgänge und Eingänge mit dem Speicherabbild abgleicht, verschiedene
Systemfunktionen bearbeitet, die Flankenmerker der Variablen setzt und dann wieder den
OB1 aufruft. OB1 wird also immer zyklisch aufgerufen.
Der zyklische Aufruf ist sehr wichtig, denn nur so kann das Programm mehrere tausend Map
pro Sekunde aufgerufen werden, und sichert so eine hohe Reaktionsfähigkeit des Systems auf
veränderte, äußere und innere Bedingungen.
Das gleiche gilt auch für den Aufruf von Bausteinen. Jede Bedingung, also auch eine
Transition in einer Schrittkette, wird mehrere tausend Mal pro Sekunde überprüft. Sollte eine
Bedingung wahr sein wird die bedingte Aktion, bei Schrittketten das Weiterschalten in den
nächsten Schritt ausgeführt. Wenn eine Bedingung also wahr ist wird, die daraus resultierende
Aktion nicht nur ein einziges Mal, sondern bei jedem Zyklusdurchlauf erneut ausgeführt.
Man kann jetzt also nicht mehr einfach nur eine Bedingung formulieren und eine bestimmte
Reaktion auf diese Bedingung, da eine Bedingung auch zu einem Zeitpunkt erfüllt sein kann
zu dem die Reaktion nicht wünschenswert ist oder sogar fatale Folgen haben kann. Um ein
System richtig organisieren zu können muss man immer den gesamten Systemzustand im
Auge behalten und Bedingungen eindeutig definieren.
Wenden wir uns nun also unserem Problem zu. Zuerst folgt ein kurzer Überblick über das
Programm und die fehlenden Komponenten. Danach wird Schritt für Schritt durch die
Erstellung des Programms geführt. Dort werden die einzelnen Bausteine dann näher erläutert.
Wie in Abbildung 2-10 dargestellt benötigen wir zwei zusätzliche Funktionsbausteine, einen
um das Blinken vor dem Normalbetrieb der Ampel und einen um das Blinken nach dem
Normalbetrieb zu realisieren. Im ersten Schritt dieser Bausteine werden alle Lichter durch den
Aufruf der Funktion „AlleAus“ ausgeschalten. Diese Funktion muss auch noch erstellt
werden. Die Steuerung des Ampelsystems übernimmt die noch zu erstellende Funktion
„Systemsteuerung“. Außerdem müssen noch einige Änderungen am OB1 vorgenommen
werden.
Wir fangen am besten damit an alle benötigten Variablen und Symbole anzulegen. In unserem
Fall sind das:
-
-
-
-
Alle Symbole für Lichter, also die Ausgänge der SPS. (Diese Symbole müssten in den
vorherigen Aufgaben schon erstellt worden sein)
Die Symbole „Schalter“ und „Taster“, also die Eingänge der SPS. (Es müsste
eigentlich nur noch das Symbol für den Schalter fehlen. Der Schalter ist an Eingang
E0.1 angeschlossen.)
Die Variablen für die Schaltzeiten. (Müssten auch schon vorhanden sein)
Die Variablen zur Steuerung des Ablaufs. Man benötigt für jeden Funktionsbaustein
zwei Kontrollvariablen über deren Flankenmerker die Schrittketten gesteuert werden.
Man nennt die Variablen zum Beispiel „Start<Bausteinname>“ und
„Stop<Bausteinname>“. (In unserem Fall sind es 6 Kontrollvariablen)
Eine Variable „Init“, um zu überprüfen, ob das System schon initialisiert wurde. Die
Initialisierung sind alle Einstellungen, die beim ersten Start des Systems
vorgenommen werden müssen.
Eine Variable „Weiter“, um zu überprüfen, ob der Baustein „BlinkenAn“ schon
dreimal geblinkt hat, bevor man den Baustein „Normalbetrieb“ startet.
Versuch Nr. 27
Speicherprogrammierbare Steuerungen
Versuchsanleitung
Institut für Automatisierungs- und Softwaretechnik
18
Die Erstellung der Bausteine beginnt man am besten in der Aufrufhierarchie ganz unten. Bei
uns wäre das die Funktion „AlleAus“. Funktionen fügt man, wie alle Bausteine, über das
Kontextmenü des Bausteinknotens im Projektexplorer hinzu. Ein Doppelklick öffnet den
Editor. Man muss in dieser Funktion einfach für jedes Licht eine Zeile in folgender Form
eintragen, wobei noch der Name des Lichts (z.B. RotLicht) ergänzt werden muss:
R
NameDesLichts
Wenn man fertig ist speichert man und schließt den Editor.
Als nächstes müssen die Schrittketten für die Funktionsbausteine, die für das Blinken
zuständig sind erstellt werden. Die Bausteine bestehen aus sieben beziehungsweise acht
Schritten. Im ersten Schritt wird die Funktion „AlleAus“ mit der Aktion CALL aufgerufen.
Auf diesen ersten Schritt folgen sechs Schritte, die das gelbe Licht abwechselnd an und aus
Schalten. In den Schritten, während denen das gelbe Licht aus ist, wird einfach keine Aktion
eingetragen. Der Vergleicher der darauf folgenden Transition darf aber trotzdem nicht fehlen,
da sonst direkt zum nächsten Schritt, in dem das gelbe Licht leuchtet geschalten wird.
Jetzt kommt der einzige Unterschied der beiden Schrittketten. In der Schrittkette, die vor dem
Normalbetrieb kommt, muss ein zusätzlicher Schritt eingefügt werden, in dem die Variable
Weiter gesetzt wird, um dem Steuerprogramm zu signalisieren, dass mit dem Normalbetrieb
begonnen werden kann.
Abschließend fügt man beiden Ketten ein „Kettenende“ hinzu, da beide Bausteine nicht
zyklisch verlaufen, sondern nach dem dritten Blinken beendet werden sollen.
Anschließend implementiert man die Funktion „Systemsteuerung“. Um die Übersichtlichkeit
zu verbessern legt man am besten für jede Steueraufgabe ein eigenes Netzwerk an. Also
jeweils ein Netzwerk für „BlinkenAn“, für „Ampelsteuerung“ und für „BlinkenAus“. Ein
neues Netzwerk legt man an, indem man im Menü > Einfügen > neues Netzwerk auswählt. In
den einzelnen Netzwerken der „Systemsteuerung“ sollten die folgenden Bedingungen und die
daraus resultierenden Anweisungen wie folgt umgesetzt werden.
Im Netzwerk „Steuerung BlinkenAn“:
-
Die Variable „GLOBALS“.StartBlinkenAn hat immer den gleichen Zustand, wie der
Schalter
Die Variable „GLOBALS“.StopBlinkenAn hat immer den umgekehrten Zustand, wie
der Schalter
Wenn der Schalter ausgeschaltet ist muss die Variable „GLOBALS“.Weiter
zurückgesetzt werden.
Im Netzwerk „Steuerung Ampelsteuerung“:
-
Die Variable „GLOBALS“.StartAmpelsteuerung hat immer den gleichen Zustand, wie
der Schalter, sobald die Variable „GLOBALS“.Weiter in „BlinkenAn“ gesetzt wurde.
Die Variable „GLOBALS“.StopAmpelsteuerung hat immer den umgekehrten
Zustand, wie der Schalter
Im Netzwerk „Steuerung BlinkenAus“:
Versuch Nr. 27
Speicherprogrammierbare Steuerungen
Versuchsanleitung
Institut für Automatisierungs- und Softwaretechnik
-
-
19
Die Variable „GLOBALS“.StartBlinkenAus hat immer den umgekehrten Zustand, wie
der Schalter, aber erst, wenn die Initialisierung durchgeführt, also „GLOBALS“.Init
gesetzt wurde. (siehe hierzu auch die Beschreibung zu OB1 auf der nächsten Seite)
Die Variable „GLOBALS“.StopBlinkenAus hat immer den gleichen Zustand, wie der
Schalter
Die benötigten Anweisungen in AWL können dem Kapitel 3.2.1 im Anhang entnommen
werden.
Bemerkung: Es werden die Bitverknüpfungen „U“ und „UN“ benötigt, um die Bedingungen
zu formulieren. Für die resultierenden Anweisungen werden „S“, „R“, und „=“
verwendet. (siehe Kapitel 3.2.1 im Anhang)
In Abbildung 2-11 sieht man die Umsetzung in AWL am Beispiel des Netzwerks „Steuerung
BlinkenAus“. („BlinkenAus“ entspricht hier „Blinken2“)
Abbildung 2-11: Netzwerk „Steuerung Blinken2“ in der Funktion „Systemsteuerung“
Man kann erkennen, dass die vorher in Klartext formulierten Bedingungen umgesetzt wurden.
Als nächstes ergänzt man den OB1. Zuerst wird im OB1 die „Systemsteuerung“ mit dem
CALL-Befehl aufgerufen. Darauf folgen die Initialisierungsanweisungen. Beim ersten Start
des Programms sind alle Bausteine initialisiert. Wenn der Schalter aus ist, sollen aber beim
ersten Start alle Bausteine deaktiviert sein. Die Bausteine „BlinkenAn“ und
„Ampelsteuerung“ werden dadurch deaktiviert, dass der Schalter aus ist (wie in den zuvor
festgelegten Bedingungen beschrieben). Der Baustein „BlinkenAus“ muss separat deaktiviert
werden, da er, da der Schalter aus ist, ausgeführt würde.
Die Initialisierung in OB1 besteht also darin, den Baustein „BlinkenAus“ zu deaktivieren und
der „Systemsteuerung“ mitzuteilen, wann das System durch umlegen des Schalters das erste
mal aktiviert wurde. Man kann folgende Bedingungen formulieren, die dann in den ersten
Zeilen des OB1 in AWL umgesetzt werden müssen:
-
Wenn noch nicht initialisiert wurde muss „BlinkenAus“ gestoppt werden, also die
Variable „GLOBALS“.StopBlinkenAus gesetzt werden.
Wenn der Schalter eingeschaltet ist wird die Variable „GLOBALS“.Init gesetzt.
Zuletzt müssen in OB1 nur noch alle restlichen Bausteinaufrufe einfach untereinander
eingetragen werden. Bei den Funktionsbausteinen muss der zugehörige Datenbaustein immer
mit angegeben werden. Außerdem muss man die Kontrollvariablen in die entsprechenden
Parameterfelder eintragen (also die Startvariablen bei INIT_SQ und die Stopvariablen bei
OFF_SQ).
Versuch Nr. 27
Speicherprogrammierbare Steuerungen
Versuchsanleitung
Institut für Automatisierungs- und Softwaretechnik
20
Vorbereitungsfrage 4: Entwickeln Sie auf einem getrennten Blatt die Schrittkette für die
Bausteine „BlinkenAnfang“ ,„BlinkenEnde und die Anweisungsliste
für die Bausteine „AlleAus“, „Systemsteuerung“ und „OB1“ (Bei
Bausteinaufrufen müssen nur die benutzten Parameter angegeben
werden)
Aufgabe 4:
Führen Sie alle beschriebenen Implementierungen und Änderungen
durch. Testen Sie, ob die Ampel erwartungsgemäß funktioniert.
3 Anhang
3.1 Definition der Steuerung
Nach DIN 19226 ist eine Steuerung durch einen offenen Wirkungsweg gekennzeichnet. Eine
Steuerung kann daher nur solchen Störgrößen entgegenwirken, für die sie ausgelegt wurde.
Der Wirkungsweg besteht aus einer Steuereinrichtung (Automatisierungsgerät) und einer
Steuerstrecke (Technischer Prozess).
Bei elektrischen Steuerungen unterscheidet man Kontaktsteuerungen, kontaktlose
Steuerungen und frei programmierbare Steuerungen. Das Unterscheidungsmerkmal ist dabei
die technische Realisierung der Steuereinrichtungen. Kontaktsteuerungen sind mittels Relaisund Schütztechnik aufgebaut. Bei der kontaktlosen Steuerung kommen Halbleiterschaltungen
in integrierter und diskreter Form zum Einsatz. Bei der speicherprogrammierbaren Steuerung
wird die Steuerlogik durch ein in einem Mikrorechner ablaufendes Programm realisiert.
3.2 Programmiersprachen in STEP7 - Befehle und Syntax
In den nächsten Kapiteln soll kurz auf die wichtigsten Befehle und Sprachelemente der
verwendeten Programmiersprachen aus STEP7 und deren Syntax eingegangen werden.
3.2.1 AWL
In AWL gibt es viele verschiedene Befehle. Hier sollen aber nur die grundlegensten Befehle
kurz erläutert werden.
Bitverknüpfüngen sind einfache boolesche Operationen auf Bits beziehungsweise
Wahrheitswerten (Werte aus dem Wertebereich [TRUE, FALSE]).
U
UN
O
ON
X
XN
– und
– und nicht
– oder
– oder nicht
– exklusives oder
– exklusives oder nicht
Anweisungen zur Formulierung
von Bedingungen
=
S
R
– Zuweisung
– Setzen (auf TRUE, also 1)
– Rücksetzen (auf FALSE, also 0)
Beenden einen Bedingungsblock
Syntax:
Versuch Nr. 27
Speicherprogrammierbare Steuerungen
Versuchsanleitung
Institut für Automatisierungs- und Softwaretechnik
Beispiel 1:
O
ON
R
21
DB10.Var1
E0.4
DB10.Var2
Die Variable Var2 im Datenbaustein DB10 wird zurückgesetzt (DB10.Var2 =
„FALSE“), wenn entweder DB10.Var1 „FALSE“ ist oder E0.4 ausgeschaltet
ist.
Der Befehl CALL ruft einen Baustein auf. Es können Funktionen, Organisationsbausteine
und Funktionsbausteine aufgerufen werden. Bei Funktionsbausteinen ist
darauf zu
achten, dass der Instanzdatenbaustein mit angegeben wird.
Syntax:
CALL <Baustein>, [<Instanzdatenbaustein>(bei FBs)]
Beispiel:
CALL FB1, DB1
3.2.2 S7-GRAPH
Die Programmiersprache GRAPH besteht im Wesentlichen aus Schritten und Transitionen.
Die Transitionen werden vorzugsweise in KOP geschrieben. Die Aktionen, die in den
Schritten durchgeführt werden sind in einer AWL-ähnlichen Sprache geschrieben. Die
Befehle setzen sich aus einem Befehlszeichen und einem oder mehreren Operanden
zusammen. Für das Befehlszeichen, sowie jeden einzelnen Operanden steht ein Eingabefeld
zur Verfügung. Hier werden kurz die wichtigsten Befehlszeichen und ihre Operanden
beschrieben.
N
– Nicht speicherndes Setzen. Der Operand wird nur während der Schritt aktiv
ist gesetzt. Nach Deaktivieren des Schritts wird der Operand zurückgesetzt.
S
– Setzen. Der Operand wird auf TRUE gesetzt.
R
– Rücksetzen. Der Operand wird auf FALSE gesetzt
D
– Verzögertes Setzen (Delayed). Nach Ablauf einer bestimmten Zeit, nach
Aktivierung des Schritts wird der Operand gesetzt.
L
– Limitiertes Setzen. Der Operand wird für eine bestimmte Zeit gesetzt und
dann wieder zurückgesetzt.
CALL – Aufruf eines Bausteins. Man sollte in GRAPH aber keine anderen
Funktionsbausteine aufrufen, da dann kein zuverlässiger Ablauf sichergestellt
werden kann.
Versuch Nr. 27
Speicherprogrammierbare Steuerungen
Versuchsanleitung
Institut für Automatisierungs- und Softwaretechnik
22
3.3 Abbildungsverzeichnis
Abbildung 1-1: Prinzipieller Aufbau einer SPS ......................................................................... 3
Abbildung 1-2: Draufsicht auf die SPS-Kerneinheit mit integrierten Modulen ........................ 4
Abbildung 1-3: UND-Verknüpfung in AWL ............................................................................. 5
Abbildung 1-4: UND in KOP..................................................................................................... 5
Abbildung 1-5: UND als Funktionsplan .................................................................................... 5
Abbildung 1-6: UND in Strukturiertem Text ............................................................................. 6
Abbildung 1-7: Einfachstes Petri Netz ....................................................................................... 6
Abbildung 1-8: Zustand des Petri Netzes vor und nach Durchschalten der Transition ............. 6
Abbildung 1-9: Der Projektexplorer .......................................................................................... 7
Abbildung 1-10: Der Editor für AWL, KOP und FUP .............................................................. 8
Abbildung 1-11: Der Editor für S7-GRAPH-Bausteine ............................................................ 9
Abbildung 2-1: Die Symboltabelle .......................................................................................... 10
Abbildung 2-2: Das Kontextmenü zum Bausteinknoten.......................................................... 10
Abbildung 2-3: Die Bausteineigenschaften von Funktionsbausteinen .................................... 10
Abbildung 2-4: Das erste Programm ........................................................................................ 11
Abbildung 2-5: Der Aufruf des Funktionsbausteins aus OB1 heraus ...................................... 12
Abbildung 2-6: Der Dialog Eigenschaften von Datenbausteinen ............................................ 13
Abbildung 2-7: Die Tabelle eines Datenbausteins ................................................................... 14
Abbildung 2-8: Schritt und Transition mit Schaltzeit als Bedingung ...................................... 14
Abbildung 2-9: UND- und ODER-Verknüpfung in GRAPH .................................................. 15
Abbildung 2-10: Prinzipielle Struktur des Programms ............................................................ 16
Abbildung 2-11: Netzwerk „Steuerung Blinken2“ in der Funktion „Systemsteuerung“ ......... 19
3.4 Literaturhinweise
Göhner, Peter:
Skript zur Vorlesung Prozessautomatisierung I. Stuttgart: Universität Stuttgart, IAS, 2002.
Petry, Jochen:
Speicherprogrammierbare Steuerungen. Heidelberg: Hüthig Verlag, 1988.
Lauber, Rudolf; Göhner, Peter:
Prozessautomatisierung 1, 3. neubearbeiteteAuflage-1999. Berlin-Heidelberg-New York:
Springer-Verlag, 1999.
Lauber, Rudolf; Göhner, Peter:
Prozessautomatisierung 2. Berlin-Heidelberg-NewYork: Springer-Verlag, 1999.
Mit dem Thema SPS-Programmierung befassen sich auch die Vorlesungen und Übungen des
IAS Prozessautomatisierung I und II.
Versuch Nr. 27
Speicherprogrammierbare Steuerungen
Versuchsanleitung