Programmieren mit STEP7

Transcrição

Dipl.Ing. Norbert Heinlein
FH Frankfurt, Labor für Automatisierungstechnik
Programmieren mit STEP7
Einführung
Dieses Skript wendet sich an STEP7-Einsteiger, die bereits Grundkenntnisse in
Zusammenhang mit Speicherprogrammierbaren Steuerungen haben. Es soll die
Einarbeitung in STEP7 erleichtern und einen Überblick ermöglichen. Zu diesem
Zweck sind hier Informationen in komprimierter Form zusammengestellt, die sonst
auf mehrere Handbücher verteilt sind.
Über viele Jahre war Einsatz und Programmierung von Speicherprogrammierbaren
Steuerungen ein Thema, das mit EDV oder Informationstechnik nichts zu tun hatte.
Zunehmend verlangt aber der moderne Produktionsbetrieb eine Durchgängigkeit und
Verzahnung aller Steuerungs- und Informationssysteme. Dies hat zu einer
nachhaltigen Veränderung in der Automatisierungstechnik geführt. Moderne
Steuerungen sind heute Teil von vernetzten Rechnerstrukturen.
In der Automatisierungstechnik werden daher zunehmend Begriffe und Methoden
der Informationstechnik verwendet. Mit der Verbreitung der Norm IEC 61131 wird
sich die Entwicklung einer Informatik-Sicht auf die Steuerungsebene noch
beschleunigen. Im Skript soll versucht werden, die teils historisch gewachsenen
Begriffe von STEP7 auch vom Standpunkt des IEC-Programmierers aus zu
beleuchten.
STEP7 ?
Mit der Programmierumgebung STEP7 werden Siemens Automatisierungssysteme
SIMATIC S7 programmiert. Genauer gesagt, geht es um Geräte der Familien S7-300
und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit.
Daneben ist STEP7 auch für die Systeme SIMATIC M7 (Automatisierungsrechner)
und SIMATIC C7 (Steuerungen mit Operator Panel) verwendbar.
Wegen der Marktbedeutung des Herstellers ist STEP7 weltweit verbreitet. In der
Basis-Version von STEP7 sind die Programmiersprachen FUP, KOP und AWL zur
Programmierung von vernetzten Automatisierungs-Stationen vorhanden. Durch
optionale Programmpakete sind weitere Sprachen verfügbar (siehe unten).
Außerdem arbeitet STEP7 mit größeren Softwarepaketen für Visualisierung, SCADA
und Prozeßleittechnik zusammen.
Konform mit IEC 61131-3 ?
STEP7 ist an die Norm IEC 61131-3 angelehnt, enthält aber viele SIMATIC-Typische
Erweiterungen. Dadurch soll neben einer gewissen Kontinuität zu der früheren
Programmierumgebung STEP5 eine optimale Anpassung an das Siemens
Automatisierungskonzept erreicht werden. Aber sicher spielen auch Marketingstrategien eine Rolle für den eigenen Weg von Siemens.
Anwender mit IEC-Sprachkenntnissen müssen sich bei der Umstellung auf STEP7
vor allem erst an das spezielle Bausteinkonzept und an die Freiheiten und Gefahren
bei der Adressierung von Operanden gewöhnen. Danach dürften sie mit STEP7-FUP
und -KOP wenig Umstellungsschwierigkeiten haben. Beim Einstieg in STEP7-AWL
zeigt sich ein gegenüber der Norm wesentlich größerer Funktionsumfang.
Besonders interessant für IEC-Programmierer sind die optionalen Spracherweiterungen, die nach der Installation von der STEP7-Oberfläche aus verfügbar sind:
S7-SCL (Structured Control Language)
entspricht der Sprache ST (Strukturierter Text) nach IEC 61131-3, eine textuelle
Hochsprache mit Ähnlichkeiten zu Pascal. Die Konformität mit ST nach IEC 61131-3
ist nachgewiesen durch ein Base-Level Zertifikat der PLC-Open Organisation.
S7-GRAPH
hat große Gemeinsamkeiten mit der Sprache AS (Ablaufsprache) nach IEC 61131-3,
mit deren Hilfe Ablaufsteuerungen programmiert werden können. In der aktuellen
Version besitzt GRAPH noch keinen Konformitätsnachweis mit der IEC-Norm.
S7kurs_2000.doc 07.01.10
Programmieren mit STEP 7
Seite 1
Inhalt
1 PROGRAMMIERUMGEBUNG ..................................................................................5
1.1
Programmiergerät ........................................................................................................................................ 5
1.2
MPI-Bus......................................................................................................................................................... 5
1.3
STEP7 Projekt .............................................................................................................................................. 5
2 GRUNDWISSEN FÜR DAS PROGRAMMIEREN MIT STEP7 ..................................6
2.1
Programmstruktur ....................................................................................................................................... 6
2.2
Bausteine: OB, FC, DB, FB, SFC, SFB ...................................................................................................... 7
2.2.1
Organisationsbausteine (OB‘s) ................................................................................................................ 7
2.2.2
Funktion (Function, FC) .......................................................................................................................... 8
2.2.3
Datenbaustein (Data Block, DB) ............................................................................................................. 8
2.2.4
Funktionsbaustein (Function Block, FB)................................................................................................. 8
2.2.5
Systemfunktion (SFC) und Systemfunktionsbaustein (SFB)................................................................... 8
2.3
Bibliothek für Standardfunktionen............................................................................................................. 8
2.4
Netzwerke ...................................................................................................................................................... 9
2.5
Datentypen .................................................................................................................................................... 9
Elementare Datentypen ............................................................................................................................................. 9
2.5.2
Anwenderdefinierte Datentypen (UDT, =User defined Type) ................................................................ 9
2.5.3
Datentyp ANY......................................................................................................................................... 9
2.6
Variable ....................................................................................................................................................... 10
2.6.1
Variablennamen..................................................................................................................................... 10
2.6.2
Symboltabelle ........................................................................................................................................ 10
2.6.3
Globale Variable.................................................................................................................................... 11
2.6.4
Lokale Variable und deren Deklaration................................................................................................. 11
2.6.5
Variable mit zusammengesetzten Datentypen ....................................................................................... 12
2.7
Anwenderspeicher in der CPU .................................................................................................................. 13
2.7.1
Remanenz .............................................................................................................................................. 13
2.8
Adressierung ............................................................................................................................................... 14
2.8.1
Direkte Adressierung ............................................................................................................................. 14
2.8.2
Indirekte Adressierung .......................................................................................................................... 14
2.8.3
Adressierung mit Pointer ....................................................................................................................... 14
2.8.4
Adresszusammenhang Bit, Byte, Wort, Doppelwort........................................................................... 14
2.9
Schreibweise zum Eingeben von Werten .................................................................................................. 15
3 BEISPIELE IN FUP/KOP UND AWL .......................................................................16
3.1
Logische Verknüpfung ............................................................................................................................... 16
3.2
Flip Flop und Flankenerkennung.............................................................................................................. 16
3.3
Timer............................................................................................................................................................ 16
3.4
Zähler........................................................................................................................................................... 17
3.5
Arithmetische Operation............................................................................................................................ 17
3.6
Bausteinaufruf............................................................................................................................................. 17
4 HANDHABUNG DER CPU ......................................................................................18
S7kurs_2000.doc 07.01.10
Seite 2
4.1
Betriebszustände und Übergänge.............................................................................................................. 18
4.2
Laden des Anwenderprogramms .............................................................................................................. 18
4.3
Urlöschen der CPU ..................................................................................................................................... 18
4.4
Verhalten der CPU bei Netzausfall ........................................................................................................... 18
5 ERSTE ÜBUNG AM STEP7-ARBEITSPLATZ........................................................19
5.1
Ein STEP7 Programm erstellen ................................................................................................................ 19
5.1.1
STEP7 starten ........................................................................................................................................ 19
5.1.2
Ein neues Projekt erzeugen.................................................................................................................... 19
5.1.3
Umgang mit dem S7 Manager ............................................................................................................... 19
5.1.4
Die Hardware konfigurieren .................................................................................................................. 20
5.1.5
Die Baugruppen parametrieren.............................................................................................................. 20
5.1.6
Erstellen einer Symboltabelle ................................................................................................................ 21
5.1.7
Bausteine Editieren................................................................................................................................ 21
5.2
Das Programm in das Zielsystem laden.................................................................................................... 23
5.2.1
Verbindung zum Automatisierungsgerät ............................................................................................... 23
5.2.2
Urlöschen der CPU................................................................................................................................ 23
5.2.3
Programm übertragen ............................................................................................................................ 23
5.2.4
Das Automatisierungsgerät starten ........................................................................................................ 23
5.3
Das Programm testen ................................................................................................................................. 23
5.3.1
Onlinedarstellung im S7 Manager ......................................................................................................... 23
5.3.2
Bausteinorientierte Testhilfe.................................................................................................................. 23
5.3.3
Variablenorientierte Testhilfe:............................................................................................................... 24
6 FUNKTION (FC) ......................................................................................................25
6.1
Die Operanden EN (Enable) und ENO (Enable Out)............................................................................. 25
6.2
Erstellen einer Funktion............................................................................................................................. 26
6.2.1
Deklarationsteil...................................................................................................................................... 26
6.2.2
Anweisungsteil in FUP und AWL ......................................................................................................... 26
6.3
Aufrufen der Funktion ............................................................................................................................... 27
6.4
Fehlerbehandlung und Statusmeldungen ................................................................................................. 27
7 DATENBAUSTEIN (DB) ..........................................................................................28
7.1
Erzeugen eines Datenbausteins.................................................................................................................. 28
7.2
Festlegen der Datenstruktur ...................................................................................................................... 28
7.3
Adressierung der Daten.............................................................................................................................. 29
7.3.1
Vollständige Adressierung der Daten in einem Schritt.......................................................................... 29
7.3.2
Adressierung mit: DB ‘Öffnen’ bzw. DI ‘Öffnen’ ........................................................................... 30
7.4
Weitere Operationen mit Datenbausteinen .............................................................................................. 30
8 FUNKTIONSBAUSTEIN (FB)..................................................................................31
8.1
Unterschied zur Funktion .......................................................................................................................... 31
8.2
Anwendungsbeispiel: Zeitliche Ableitung eines Meßsignals................................................................... 31
8.2.1
FB Erstellen ........................................................................................................................................... 31
8.2.2
FB Aufrufen........................................................................................................................................... 32
8.2.3
Instanz-DB............................................................................................................................................. 32
9 EREIGNISGESTEUERTE PROGRAMMBEARBEITUNG .......................................33
S7kurs_2000.doc 07.01.10
Seite 3
9.1
Zyklische Programmbearbeitung (OB1) .................................................................................................. 33
9.2
Anlaufbearbeitung und Initialisierung (OB100)...................................................................................... 34
9.2.1
Lokale Variable des OB100................................................................................................................... 34
9.2.2
Anwendungsbeispiel.............................................................................................................................. 34
9.3
Weckalarm = Periodischer Zeitinterrupt (OB30..OB38) ........................................................................ 36
9.3.1
Einstellung des Aufrufintervalls ............................................................................................................ 36
9.3.2
Anwendungsbeispiel.............................................................................................................................. 36
9.4
Prozeßalarm = I/O-Interrupt (OB40) ....................................................................................................... 37
9.4.1
Alarm-Freischaltung in der CPU ........................................................................................................... 37
9.4.2
Alarmbearbeitung .................................................................................................................................. 37
Anhang:
Literaturverzeichnis
S7kurs_2000.doc 07.01.10
Seite 4
1 Programmierumgebung
1.1
Programmiergerät
Als Programmiergeräte (PG) werden meist PCs mit eingebauter MPI-Steckkarte oder spezielle Laptops verwendet.
Betriebssystem ist Windows NT oder 95/98, der PC sollte mindestens Pentium-Performance mit 64 MB RAM haben.
1.2
MPI-Bus
Jede S7-Station besitzt eine MPI-Schnittstelle (Multi Point Interface). Über diese Schnittstelle werden die am
Automatisierungsprojekt beteiligten S7-Stationen mit dem Programmiergerät vernetzt.
Bei MPI handelt es sich um Schnittstellen mit RS485-Physik, über die ein Siemens-internes Protokoll abgewickelt
wird. Es können bis zu 32 Teilnehmer über eine Zweidrahtleitung verbunden werden. Jeder Teilnehmer bekommt
eine MPI-Adresse zugewiesen, über die er ansprechbar ist. Baudrate am MPI-Bus ist 187,5 kBit/s.
Für Programmiergeräte sollen die Adressen MPI-0 oder MPI-1 verwendet werden, die erste S7-Station erhält die
Adresse MPI-2.
Normalerweise verläuft über den MPI
Bus nur der Datenaustausch zwischen
Programmiergerät und den S7Stationen zur Programmierung und für
Online Testfunktionen.
Für wenige Teilnehmer mit geringen
Datenmengen kann aber auch eine
Kommunikation zwischen den S7Stationen ermöglicht werden. Dies
geschieht durch Projektierung von
sogenannten Globaldaten, die innerhalb bestimmter Kommunikationskreise
von den beteiligten CPU’s verschickt
und empfangen werden. Mit den S7Stationen können über MPI auch
Operator Panels verbunden werden.
1.3
STEP7 Projekt
Ein STEP7-Projekt enthält Datenobjekte für eine oder mehrere zusammengehörige S7-Stationen. Im folgenden
Beispiel besteht das Projekt der Einfachheit halber nur aus einer Station der Reihe S7-300.
Das Projekt mit dem
Namen S7_Proj1 belegt ein eigenes Verzeichnis. Die Station selbst besteht aus Angaben zum Hardwareaufbau (sog.
„Stationskonfiguration“) und aus Systemeinstellungen für die CPU, hier eine CPU314.
Im Behälter „S7-Programm“ ist das Programm für die CPU abgelegt. Hierzu gehören Voreinstellungen der
Programmierumgebung, die Definition von Symbolischen Variablen und im Behälter „Bausteine“ die eigentlichen
Programmanweisungen in FUP/KOP und AWL. Diese sind in Programmbausteine gegliedert, die ohne weitere
Compilierung in die CPU geladen werden können.
S7kurs_2000.doc 07.01.10
Seite 5
Der Behälter „Quellen“ ist für Programm-Module im Quelltext bestimmt. Das sind beispielsweise Anweisungen in
AWL, die mit einem Texteditor erstellt werden. Vor der Übertragung zur S7-Station müssen die Quellen erst noch
compiliert werden, dadurch entstehen ebenfalls Bausteine.
Zu jeder Station werden also viele Informationen abgelegt: Allgemeine Dokumentation, Hardwareaufbau,
Voreinstellungen der Programmierumgebung, Symbolische Bezeichnungen von Variablen, Hilfen für Test und
Inbetriebnahme usw. und -last not least- die eigentlichen Programmanweisungen unter FUP, KOP, AWL oder
weiteren Hochsprachen.
Vom Programmiergerät aus betrachtet, gehören alle diese Informationen zum Programm für die CPU. Vom
Automatisierungsgerät aus betrachtet, besteht das CPU-Programm lediglich aus AWL-Anweisungen: das Programm
wird nämlich beim Laden in die CPU automatisch in AWL-Anweisungen umgesetzt.
2 Grundwissen für das Programmieren mit STEP7
2.1
Programmstruktur
STEP7-Programme bestehen im allgemeinen aus mehreren oder vielen Programmbausteinen. In jedem Baustein
wird dabei eine Teilaufgabe des Gesamtprogramms bearbeitet. Zur Vorbereitung der Programmierung wird zunächst
die Funktion der zu steuernden Anlage untersucht. Aus der Aufspaltung in Teilfunktionen entsteht schließlich die
Programmstruktur.
Am Beispiel einer Abfüllanlage soll dieser
Entwurfsvorgang gezeigt werden:
Die Anlage könnte beispielsweise grob
unterteilt werden in Transporteinrichtungen, die Füllung der Behälter und
irgendwelche Bedieneinrichtungen mit
Schaltern und Anzeigen.
Eine genauere Betrachtung der Füllung
könnte beispielsweise ergeben, daß nach
mehreren Reinigungsvorgängen und
dem Füllvorgang noch eine Etikettierung
der Behälter erfolgen soll.
Auf diese Weise erhält man eine
funktionale Gliederung der Anlage in
beliebig feiner Struktur.
Die Programmbausteine entsprechen
den so festgelegten Teilaufgaben.
Die
einzelnen Bausteine erhalten
Namen, die für die jeweilige Teilaufgabe
kennzeichnend sind. Außerdem erscheint
der Bausteintyp mit Nummer, z.B. FC20
Der Baustein „Füllung“ beispielsweise
veranlaßt später die Bearbeitung der
Bausteine für die Reinigungen, Kontrolle,
Füllung und Etikettierung.
S7kurs_2000.doc 07.01.10
Seite 6
Die Strukturierung des Programms in Bausteine hat wichtige Vorteile:
•
•
•
•
•
Gegliederte Lösung
Ein in funktionelle Einheiten unterteiltes Programm ist leichter zu entwickeln
Transparenz
Ein aus Bausteinen bestehendes Programm ist einfacher zu dokumentieren und ist besser verstehbar
Vorteile bei Test und Inbetriebnahme
Die Programmteile können einzeln getestet und korrigiert werden
Kürzeres Programm
Bausteine im Speicher können mehrfach verwendet werden
Fertige Lösungen verwenden
Wiederverwendung von Teillösungen, Einsatz von Standardfunktionen und Programmbibliotheken
2.2
Bausteine: OB, FC, DB, FB, SFC, SFB
STEP7 unterscheidet sich im Bausteinkonzept stark von den Festlegungen der Norm IEC 1131-3. Gleichzeitig ist das
Verständnis der Bausteine aber zentral wichtig für das Verständnis von STEP7! Grundsätzlich werden alle Bausteine
vom Anwender erstellt oder in das aktuelle Projekt importiert.
Hinsichtlich des Inhalts können Bausteine unterschieden werden in
• Codebausteine
diese enthalten Programmanweisungen (Code). Alle Bausteine außer DB‘s sind Codebausteine.
• Datenbausteine (DB‘s)
enthalten Speicherplatz für Daten. Auf die Daten von DB‘s kann man durch Anweisungen in Codebausteinen
zugreifen. DB‘s werden in ihrer Größe und Datenstruktur vom Anwender festgelegt. Sie werden verwendet
beispielsweise für die Speicherung von statischen Variablen, Messwerten, Rezepturen, Regelparametern.
Die Codebausteine können hinsichtlich des Programmablaufs in zwei Gruppen unterschieden werden.
• Organisationsbausteine (OB’s) werden bei bestimmten Ereignissen vom Betriebssystem gestartet.
• Alle anderen Codebausteine werden durch Anweisungen im Anwenderprogramm gestartet.
2.2.1 Organisationsbausteine (OB‘s)
OB‘s bilden die Schnittstelle zwischen dem Betriebssystem und dem Anwenderprogramm. Sie können nicht durch
Programmanweisungen gestartet werden! Stattdessen wird der Start von OB’s beim Eintreten von festgelegten
Ereignissen durch das SPS-Betriebssystem veranlasst. Die nachfolgende Tabelle zeigt eine Auswahl der wichtigsten
OB’s mit den betreffenden Ereignissen und der zugehörigen Priorität. Ein OB höherer Priorität unterbricht die
Bearbeitung des OB mit niedrigerer Priorität. Am Ende des höherprioren OB’s wird die Bearbeitung des
unterbrochenen OB’s fortgesetzt.
Priorität
OB-Nr
Name
Systemereignis
niedrigste
OB1
OB10
OB35
OB40
OB80
OB100
OB122
Zyklus
Uhrzeitalarm
Weckalarm
Prozessalarm
Zykluszeitfehler
Anlauf
Baugruppenfehler
am Zyklusende und nach dem Anlauf (Ende von OB100)
definierte Uhrzeit oder Datum
periodisch jeweils nach einer definierten Zeit
bei bestimmten Signalen der I/O-Peripherie
OB1-Zyklus überschreitet eine definierte Zeit
beim Anlauf der SPS, d.h. bei Stop=>Run
wenn beim Baugruppenzugriff ein Fehler erkannt wird
höchste
"Zeit-Interrupt"
"I/O-Interrupt"
Am häufigsten wird in Anwenderprogrammen der OB1 (Zyklus) eingesetzt. Viele STEP7-Programme verwenden den
OB1 sogar als einzigen OB. Wegen der niedrigen Priorität kann er durch alle Systemereignisse unterbrochen
werden. Die höchste Priorität hat der OB122, der bei der Erkennung von Baugruppenfehlern sofort bearbeitet wird.
Die Anzahl der verfügbaren OB’s hängt ab von den Leistungsdaten der verwendeten CPU. Beispielsweise kennt die
kleinste CPU (CPU312 IFM) nur OB1, OB40 und OB100.
Im vorigen Abschnitt wurde am Beispiel einer Abfüllanlage gezeigt, wie die Bausteine entsprechend der
Anlagenfunktion gegliedert werden können. Wenn die einzelnen Bausteine zyklisch bearbeitet werden sollen, sieht
der Programmablauf etwa so aus wie im folgenden Bild.
S7kurs_2000.doc 07.01.10
Seite 7
Programmablauf am Beispiel
der Abfüllanlage
Wenn ein bestimmtes Systemereignis eintritt, der Anwender aber den betreffenden OB nicht erstellt hat, dann
passiert folgendes: das System verzweigt auf die OB-Adresse, dort steht aber nichts, also wird der unterbrochene
OB sofort weiterbearbeitet.
Eine beliebte Fehlerquelle besteht darin, daß irgendein Baustein eigentlich zyklisch bearbeitet werden soll, aber im
OB1 die CALL-Programmanweisung fehlt. Dann passiert nichts und der Programmierer wundert sich.
2.2.2 Funktion (Function, FC)
Beim Aufruf können einer Funktion Parameter übergeben werden, am Ende kann die Funktion dem aufrufenden
Baustein Parameter zurückliefern. Anzahl und Typen der Parameter werden bei der Erstellung der Funktion
deklariert. Außerdem können temporäre Variable deklariert werden (z.B. für Zwischenergebnisse), deren Daten am
Ende des FC allerdings verloren gehen. FC’s haben keinen Speicher für statische Variablen. Einzelheiten zu FC’s
siehe Abschnitt 6.
2.2.3 Datenbaustein (Data Block, DB)
Datenbausteine sind strukturierte Datenspeicher, auf die durch Programmanweisungen in Codebausteinen
zugegriffen werden kann. Bei der Erstellung eines DB wird die Datenstruktur festgelegt. Einzelheiten zu DB’s siehe
Abschnitt 7.
2.2.4 Funktionsbaustein (Function Block, FB)
Besonderheit dieses Bausteintyps ist, daß beim Aufruf ein Datenbaustein angegeben werden muß, der der
aufgerufenen Instanz des FB als Speicher zur Verfügung steht. Daher können in FB’s statische Variablen deklariert
werden, d.h. Variable, deren Daten am Ende des FB erhalten bleiben. Ansonsten bestehen diesselben Möglichkeiten
wie bei FC’s. Einzelheiten zu FB’s siehe Abschnitt 8.
2.2.5 Systemfunktion (SFC) und Systemfunktionsbaustein (SFB)
Das sind spezielle Bausteine, die als Teil des Betriebssystems in die S7-CPU integriert sind. Man kann diese
Bausteine mit Programmanweisungen starten und wie ganz normale FC’s oder FB’s behandeln. Es hängt von der
jeweiligen CPU ab, welche Systembausteine zur Verfügung stehen. Beispielsweise hat die kleinste CPU insgesamt
27 SFC/SFB’s. Die Funktionen betreffen u.a. Uhrzeit, Betriebsstundenzähler, Blockbefehle zum Initialisieren oder
Kopieren von Variablen, Alarmbearbeitung, Diagnosefunktionen.
2.3
Bibliothek für Standardfunktionen
Bibliotheken unter STEP7 enthalten Bausteine, die zur Verwendung in das aktuelle Projekt kopiert werden können.
Zur STEP7-Programmumgebung gehört eine Standardbibliothek. Sie enthält u.a. die Systemfunktionen (SFC’s,
SFB’s), Standardfunktionen zum Umgang mit IEC-Datentypen und PID-Reglerfunktionen. Man kann aus
vorhandenen Bausteinen eigene Bibliotheken aufbauen.
S7kurs_2000.doc 07.01.10
Seite 8
2.4
Netzwerke
Die Codebausteine sind unterteilt in sogenannte „Netzwerke“ (NW). Unter FUP/KOP sind NW’s relativ kurz.
Automatisch wird nämlich mit der ersten Zuweisungoperation ein Netzwerkende veranlaßt. Der Begriff ‘Netzwerk’
kommt aus der Nachbildung eines elektrischen Stromkreises unter KOP.
Unter AWL können NW’s ziemlich lang sein (ca. 2000 Zeilen), so dass umfangreiche Algorithmen kompakt in ein NW
passen. Innerhalb eines Netzwerks kann die Programmiersprache nicht umgeschaltet werden! Ansonsten kann in
einem Baustein mit unterschiedlichen Sprachen gearbeitet werden.
2.5
Datentypen
2.5.1 Elementare Datentypen
Typ
BOOL
BYTE
WORD
DWORD
CHAR
INT
DINT
REAL
TIME
DATE
TOD
S5TIME
Anzahl
Beschreibung
Bit
1
8
16
32
8
16
32
32
32
16
32
16
Wertebereich
Bit
Byte
Wort
Doppelwort
Zeichen
Ganzzahl 16 Bit
Ganzzahl 32 Bit
IEEE Gleitpunktzahl
IEC-Zeit in Intervallen von 1 ms
IEC-Datum in Intervallen von 1 Tag
Time Of Day. Uhrzeit in Intervallen v. 1ms
Voreingestellte Zeitwerte:
TRUE, FALSE
0 ... 255
0 ... 65535 (216-1)
0 ... 232-1
druckbare Zeichen (ASCII-Code)
-32768 ... +32767 (-215... +215-1)
-231 ... + 231-1
(ca. -2,1Mia...2,1Mia)
-3,4E38 ... 3,4E38
(ca. -24..24 Tage)
-231 + 231-1 ms
216-1 Tage ab 1990-1-1
Stunden(0..23) : Minuten(0..59) : Sekund.(0..59) : ms(0..999)
0H_0M_0S_0MS ... 2H_46M_30S_0MS
Jeder elementare Datentyp verfügt über einen zugeordneten Speicherplatz mit fester Länge. Der Datentyp BOOL
zum Beispiel hat nur ein Bit, ein Byte (BYTE) besteht aus 8 Bits, ein Wort (WORD) sind 2 Bytes (bzw. 16 Bits), ein
Doppelwort (DWORD) hat 4 Bytes (bzw. 32 Bits). Die folgende Tabelle zeigt alle vorhandenen elementaren
Datentypen:
2.5.2 Anwenderdefinierte Datentypen (UDT, =User defined Type)
Es können auch eigene Datentypen, sogenannte „User defined Types“ (UDT‘s), definiert werden. Sie bestehen aus
Zusammensetzungen von Elementaren Datentypen.
Der Aufwand eigener Datentypen lohnt sich aber nur, wenn in einem STEP7-Projekt viele Variablen gleichen Typs
benötigt werden. Ansonsten wird man auch komplexere Variablen direkt deklarieren mit den Schlüsselwörtern:
ARRAY, STRUCT, STRING (s.a. Variablendeklaration im Abschnitt 2.6.5).
Ein Anwenderdefinierter Datentyp gilt für das gesamte S7-Programm. UDT’s werden erstellt im STEP7-Manager mit
dem Menü: Einfügen ⇒ S7-Baustein ⇒ Datentyp. Dort ist eine entsprechende Typdeklaration für den betreffenden
UDT nr (z.B. UDT10) zu erstellen.
Die Deklaration einer Variablen vom Typ ‘UDT nr’ erfolgt dann im Deklarationsteil des betreffenden Bausteins.
2.5.3 Datentyp ANY
ANY ist wird als unbestimmter Datentyp bei der Erstellung von Bausteinen benutzt. ANY kennzeichnet dann, dass
der Datentyp eines Übergabeparameters noch unbestimmt ist und erst beim Bausteinaufruf definiert wird. ANY wird
häufig bei der Verwendung von Systemfunktionen (SFC‘s) und Systembausteinen (SFB‘s) benutzt. Für die Übergabe
des eigentlichen Datentyps wird ein Zeigeroperator p (=pointer) verwendet, s.a. Abschnitt 2.8.3.
S7kurs_2000.doc 07.01.10
Seite 9
2.6
Variable
Der Umgang mit Variablen und Adressen bei STEP7 unterscheidet sich von den Festlegungen der IEC 61131-3.
Während den IEC-Programmierer im Allgemeinen nicht interessiert, an welcher Adresse eine Variable im Speicher
repräsentiert ist, hat sich der STEP7-Programmierer bereits vor der Variablendeklaration darüber seine Gedanken
gemacht und Entscheidungen getroffen. Erfahrene STEP7-Programmierer können einen Nutzen aus dem Wissen
über die Speicheraufteilung ziehen und manche Probleme elegant lösen. Allerdings haben es Einsteiger in STEP7
etwas schwerer.
Was sind eigentlich Variable?
Einige allgemein gültige Überlegungen sollen den Blick auf die Belange von STEP7 schärfen: Variable oder ganz
allgemein „Datenobjekte“ bezeichnen mit ihrem Namen eine bestimmte Menge von Speicherplatz. Unter dem
Variablennamen können die dort liegenden Daten benutzt werden. Im Gegensatz dazu stehen Konstante, die keinen
Speicherplatz haben und deren Wert im Programmcode festgelegt ist, weil er sich sowieso nie ändert.
Somit ist ein erstes wichtiges Kennzeichen für Variable der zugehörige Datentyp, der ja bereits die erforderliche
Menge an Speicherplatz festlegt. Außerdem ist es wichtig zu wissen, wie lange Daten im Speicher verbleiben und
wann eine Aktualisierung der Daten erfolgt. Dies hat viel zu tun mit dem Ereignisgesteuerten Programmablauf der
CPU und wird im Abschnitt 9 behandelt.
Wichtig ist auch der Gültigkeitsbereich, innerhalb dessen der Variablenname dem Programm bekannt ist. Hierzu sind
Aussagen in den Abschnitten über Globale und Lokale Variable gemacht.
Der Ort, an dem die Variable gespeichert ist, wird durch Speicheraufbau und Adressierung bestimmt. Dies ist Thema
der folgenden folgenden Abschnitte.
2.6.1 Variablennamen
Bei der Beschreibung irgendwelcher anderen Hochsprachen (und auch nach IEC61131-3) würden zum Thema
„Namen“ wahrscheinlich nur Fragen der Schreibweise von Variablenbezeichnern behandelt werden. Eine Variable
wäre dann etwa so deklariert:
Datentyp
Name
// Kommentar
Man wüßte nicht -und es wäre auch nicht wichtig-, unter welcher Adresse die Variable im Speicher liegt. Beim
Übersetzen des Programms würde automatisch eine Adresse festgelegt, die zur Laufzeit des Programms
selbstverständlich bekannt wäre.
Bei STEP7 ist das etwas anders, da es eigentlich gar keine Variablennamen gibt – zumindest nicht in der
adressunabhängigen Art, wie sie sonst in Hochsprachen verwendet werden. Mit dieser etwas provokativen
Behauptung soll darauf hingewiesen werden, dass bei STEP7 im „Namen“ bereits die Adressinformation steckt – und
zwar bereits im Quelltext (!) des Programms.
STEP7 Bausteine in FUP/KOP oder AWL brauchen nicht übersetzt werden!
Dieses Prinzip der festen Zuordnung von Variablennamen und Adressen hat den Vorteil, dass die Bausteine ohne
Übersetzung in die CPU geladen werden können! Auch beim Fehlersuchen in Programmen kann viel Zeit gespart
werden, weil Bausteine auch ohne Rückübersetzung aus der CPU ausgelesen und interpretiert werden können.
2.6.2 Symboltabelle
Damit man unter STEP7 trotzdem flüssig programmieren kann, ist der Anwenderspeicher in bestimmte Bereiche
aufgeteilt (E, A, M, Z, T, L, P, D siehe Abschnitt 3.7). Außerdem kann man mit einem Symboleditor eine symbolische
Bezeichnung für die feste Adresse festlegen und mit dieser programmieren.
Beispiel: M3.5
M3.5 ist eine Variable vom Typ BOOL, die im Merkerbereich (wegen der Bezeichnung
„M“) des Anwenderspeichers liegt und dort im Byte Nr.3 das Bit 5 belegt. In einer
Symboltabelle erstellt man Zuordnungen der Art
Symbol
Adresse
Datentyp
Kommentar
Name
M3.5
BOOL
Symbolname für M3.5
Auf die Variable kann man dann zugreifen mit „Name“
oder nach wie vor mit M3.5
(in Anführungszeichen „...“ !)
Solche Variablen wie M3.5 nennt man in STEP7 „Absolute Operanden“. Gemeint ist damit, dass die Adresse sich
niemals ändert und man mit ihnen operieren kann. Dieses kleine Beispiel ist bereits ein kleiner Vorgriff auf die
Adressierung unter STEP7, die im Abschnitt 2.8 ausführlich behandelt wird.
S7kurs_2000.doc 07.01.10
Seite 10
2.6.3 Globale Variable
Globale Variable können überall im Programm benutzt werden, man kann in jedem Codebaustein lesend oder
schreibend auf sie zugreifen. Es gibt 2 Arten von globalen Variablen
•
Absolute Operanden, z.B.: E2.0 AW10 M1.2 MB4 Z1 T2 OB1 FC3
Diese brauchen nirgends deklariert werden, da sie im Anwenderspeicher der CPU feste Adressen haben. Die
Namensbezeichnung verweist auf einen bestimmten Bereich des Anwenderspeichers (siehe Abschnitt 2.7).
•
Variablen in Datenbausteinen (DB‘s)
Die einzelnen Variablen eines DB‘s werden bei der Erstellung des DB deklariert. Eine Besonderheit bei DB’s ist,
daß der Gültigkeitsbereich der Variablen programmgesteuert ist: solange der DB ‘geöffnet’ ist, d.h. die Nummer
des DB steht im DB- oder DI-Register der CPU, kann von allen Codebausteinen auf seine Variablen zugegriffen
werden. Vorteil der Organisation von Daten in DB’s ist, dass die Datenmengen leicht ausgetauscht werden
können, auch zur Laufzeit. Die Erstellung und Verwendung von DB’s werden im Abschnitt 7 erklärt.
2.6.4 Lokale Variable und deren Deklaration
Lokale Variable gelten in dem Code-Baustein (OB,FC,FB), in dem sie deklariert sind. Nur innerhalb des Bausteins
sind Lese- und Schreibzugriffe auf die lokalen Variablen möglich.
Zu Beginn jedes Code-Bausteins (OBs, FCs, FBs) werden in der sogenannten Deklarationstabelle lokale Variable
deklariert, die der Baustein bei seiner Bearbeitung verwenden soll, zum Beispiel:
Man trägt Deklarationstyp, Variablenname, Datentyp und Kommentar ein. Die Adressen ermittelt STEP7
automatisch. Alle nicht temporären Variablen können mit einem Anfangswert initialisiert werden. Als Datentypen
kommen Elementare Datentypen, UDT’s, ANY und zusammengesetzte Datentypen mit ARRAY, STRUCT und
STRING vor. Zusammengesetzte Datentypen siehe Abschnitt 2.6.5.
Es gibt folgende Deklarationstypen:
Typ
Beschreibung
Zugriff
zulässig in
Eingangsparameter
Ausgangsparameter
Ein- Ausgangsparameter
lesen
schreiben
lesen, schreiben
FB, FC
FB, FC
FB, FC
temp
temporäre Variable, die im Lokaldaten-Stack gespeichert wird. Der Wert der
Variablen ist ist nach der Bearbeitung des Bausteins (das bedeuted auch: im
im nächsten Zyklus!) nicht mehr verfügbar.
lesen, schreiben
FB, FC, OB
stat
statische Variable, wird im Instanz-Datenbaustein gespeichert
lesen, schreiben
FB
in
out
in_out
• in, out, in_out (Formalparameter)
Formalparameter (sind für die Übergabe von Variablen oder Daten beim Bausteinaufruf gedacht. Diese werden beim
Aufruf durch „Aktualparameter“ ersetzt. Eingangsparameter erscheinen in der Blockdarstellung links,
Ausgangsparameter rechts.
S7kurs_2000.doc 07.01.10
Seite 11
Beispiel für Parameterübergabe:
sin (x)
MW2
x
y
MW4
Es sei ein Baustein vorhanden mit der Funktion y=sin(x). Der
Baustein hat als Eingang den Formaloperanden x, ausdem er
mit einem Sinusalgorithmus y bestimmt. Auch y ist ein
Formaloperand, allerdings vom Ausgangstyp.
Beim Aufruf des Bausteins werden die Aktualoperanden (für x:
MW2, für y: MW4) übergeben.
•
temp (temporäre Variable)
Temporäre Variable sind nur in dem Baustein gültig, in dem sie deklariert sind, d.h. beim Verlassen des Bausteins
wird der zugehörige Speicherplatz freigegeben für andere Zwecke. Der Speicherbereich für temporäre Variable ist
der sogenannte „Lokaldaten-Stack“; der Aufbau des Stacks ergibt sich jeweils aus den gerade aktuellen temporären
Variablen.
• stat (statische Variable)
Statische Variable können nur in Funktionsbausteinen deklariert werden. Der Wert wird im Instanz-Datenbaustein
gespeichert und ist daher im nächsten Zyklus wieder verfügbar. Im Abschnitt 8 ist die Erstellung und Verwendung
von FB’s erklärt.
2.6.5 Variable mit zusammengesetzten Datentypen
Mit den Schlüsselnamen ARRAY, STRUCT, STRING lassen sich Variable deklarieren, die aus elementaren
Datentypen zusammengesetzt sind.
2.6.5.1 ARRAY
Ein ARRAY verknüpft ein Feld gleicher Datentypen zu einer Einheit. Es sind auch mehrdimensionale Arrays möglich.
DerZugriff auf die Variable erfolgt in der Schreibweise: #ArrayName [i,k]
Syntax:
ArrayName
ARRAY [1..10, 1..2]
Datentyp
// Kommentarzeile, zweidimensionales Array
2.6.5.2 STRUCT
Eine Struktur (STRUCT) verknüpft verschiedene Datentypen zu einer Einheit. Der Zugriff auf die Elemente erfolgt in
der Schreibweise #Strukturname.Feldname (z.B. #Messwert.Temperatur).
Syntax:
StructName
Data1
Data2
...
Data i
STRUCT
Datentyp1
Datentyp2
...
Datentyp i
END_STRUCT
// Kommentarzeile zur Struktur
Beispiel:
2.6.5.3 STRING
Eine Zeichenkette (STRING) ist ein eindimensionales Feld aus CHAR-Datentypen. Die Feldgrösse ist maximal 254
Zeichen.
S7kurs_2000.doc 07.01.10
Seite 12
2.7
Anwenderspeicher in der CPU
Beim Laden in die CPU werden die Bausteine des S7-Programms in einen Ladespeicher transferiert. Das
Betriebssystem generiert daraus ein ausführbares Programm im Arbeitsspeicher (RAM) der CPU.
Daneben gibt es den Systemspeicher (RAM), der in bestimmte Bereiche unterteilt ist: Eingänge (E), Ausgänge (A),
Merker (M), Timer (T), Zähler (Z), Daten (D), Lokaldaten (L), Eingangsperipherie (PE) und Ausgangsperipherie (PA).
Auf alle Speicherbereiche kann durch Anweisungen im Anwenderprogramms lesend und schreibend zugegriffen
werden.
Speicherbereich
Zugriff über Einheiten der
folgenden Größe
S7Notation
Beschreibung
Verfügbar bei CPU 312 IFM
PAE
Prozeßabbild
Eingang (Bit)
EingangsByte
E
EB
PAE ist ein Speicherbereich, der vom Betriebssystem jeweils vor Beginn des OB1-Zyklus mit
E0.0...31.7, E124.0...127.7
EB0...31,
EB124...127
der Eingänge
EingangsWort
EW
den Daten der Eingabebaugruppen beschrieben
EW0...30,
EW124...126
EingangsDoppelwort
ED
wird.
ED0...28,
ED124
PAA
Ausgang (Bit)
PAA ist ein Speicherbereich, dessen Daten vom
A0.0...31.7, A124.0...127.7
Prozeßabbild
AusgangsByte
AB
Betriebssystem jeweils nach Ende des OB1-
AB0...31,
AB124...127
der Ausgänge
AusgangsWort
AW
Zyklus an die Ausgabebaugruppen geschrieben
AW0...30,
AW124...126
AD
M
MB
MW
MD
T
werden.
Anwender - Speicherbereich
Zeiten
AusgangsDoppelwort
Merker (Bit)
MerkerByte
MerkerWort
MerkerDoppelwort
Zeiten
AD0...28, AD124
M0.0...M127.7
MB0... MB127
MW0...MW126
MD0... MD124
Z0... Z31
Zähler
Zähler
Merker
Datenbausteine,
adressiert mit
A
Z
Datenbaustein, geöffnet mit
Operation "AUF DB"
DB-Register
DatenBit
DatenByte
DatenWort
DatenDoppelwort
Datenbausteine, Datenbaustein, geöffnet mit
adressiert mit
Operation "AUF DI"
DI-Register
DatenBit
DatenByte
DatenWort
DatenDoppelwort
Lokaldaten
LokaldatenBit
"Lokaldaten-Stack" LokaldatenByte
oder "L-Stack"
LokaldatenWort
LokaldatenDoppelwort
Peripheriebereich PeripherieEingangsByte
Eingänge
PeripherieEingangsW ort
PeripherieEing.Doppelwort
Peripheriebereich PeripherieAusgangsByte
Ausgänge
PeripherieAusgangsWort
PeripherieAusgDoppelwort
DB
DBX
DBB
DBW
DBD
DI
DIX
DIB
DIW
DID
L
LB
LW
LD
PEB
PEW
PED
PAB
PAW
PAD
Speicherbereich, in den vom Betriebssystem
Zeitwerte geschrieben werden
Speicherbereich für Zähler
Datenbausteine werden im Anwenderprogramm
erstellt in Größe und Datenstruktur. Sie können
entweder so definiert sein, daß alle Codebausteine auf sie zugreifen können (Globale DB)
oder sie sind einem bestimmten FB oder SFB
zugeordnet (Instanz-DB).
Durch zwei Register der CPU (DB-, DI-Register)
können gleichzeitig zwei Datenbausteine
adressiert werden.
Speicherbereich für temporäre Daten eines
Codebausteins. Der Aufbau des jeweiligen
Lokaldaten-Stacks ergibt sich aus der
zugehörigen Deklarationstabelle
Speicherbereich, der direkt mit den Daten der
Ein-/Ausgabebaugruppen in Verbindung steht.
Durch Zugriff auf Daten des Peripheriebereichs
können die Ein/Ausgabebaugruppen unabhängig
vom OB1-Zyklus erreicht werden.
*)
*)
T0 ... T63
DB 1... DB 63
DBX 0.0 ... DBX 6143.7
DBB 0 ... DBB 6143
DBW 0... DBW 6142
DBD 0 ... DBD 6140
DI 0 ... DI 63
DIX 0.0 ... DIX 6143.7
DIB 0 ... DIB 6143
DIW 0 ... DIW 6142
DID 0 ... DID 6140
L 0.0 ... L 255.7
LB 0 ... LB 255
LW 0 ... LW 254
LD 0 ... LD 252
PEB0..31, PEB124..127, PEB256..383
PEW0..30, PEW124..126, PEW256..382
PED0..28, PED124, PED256..380
PAB0..31, PAB124..127, PAB256..383
PAW0..30, PW124..126, PAW256..382
PAD0..28, PAD124, PAD256..380
Die folgende Tabelle zeigt die Speicheraufteilung. Die Menge der verfügbaren Operanden (d.h. die Größe des
Systemspeichers) ist abhängig von der jeweiligen CPU. Als Beispiel sind in der Tabelle die verfügbaren Operanden
für die kleinste CPU der Reihe S7-300 dargestellt.
*) die CPU312IFM besitzt Onboard-Peripherie, die EB124..127 und AB124..127 zugeordnet ist
2.7.1 Remanenz
Normalerweise gehen Daten im Speicherbereich Merker, Zeiten, Zähler bei Spannungsausfall der CPU verloren.
Außerdem werden beim Anlauf der CPU (Übergang STOP→RUN) diese Daten in einen definierten Zustand gesetzt.
Durch Parametrierung der CPU kann man aber einen kleinen Teil der Merker, Zeiten, Zähler als „remanent“
festlegen.
Remanente Daten bleiben erhalten bei Spannungsausfall und beim Anlauf der CPU (Übergang STOP → RUN).
S7kurs_2000.doc 07.01.10
Seite 13
2.8
Adressierung
2.8.1 Direkte Adressierung
Ist die überwiegend verwendete Adressierungsart. Man kann die Operanden entweder absolut adressieren durch
Angabe der Bezeichnung (z.B. E2.3) oder symbolisch adressieren durch eine symbolische Bezeichnung der Adresse
(z.B. „Sensor1“). Symbolische Bezeichnungen werden mit dem „Symboleditor“ erstellt und gelten für das gesamte
S7-Programm.
Beispiele für Direkte Adressierung:
Absolute Adressierung
Symbolische Adressierung
Beschreibung
U E2.3
L EB1
U „Sensor1“
L „Eingänge“
UND-Operation mit dem Eingangsbit E2.3
Lade-Operation: Lade EingangsByte EB1 in Akku1
2.8.2 Indirekte Adressierung
Bei speziellen Problemstellungen kann eine Indirekte Adressierung verwendet werden; allerdings ist diese nur unter
AWL verfügbar. Statt fester Adressen wird eine Speicherstelle bezeichnet, in der die eigentliche Adresse des
Operanden steht (Verwendung von pointern).
Beispiele für Indirekte Adressierung:
U A [MD 12] UND-Operation; die Adresse des Ausgangs steht im MerkerDoppelwort 12
SI T [LW8]
Starte Timer; die Timer-Nummer steht im LokaldatenWort 8
2.8.3 Adressierung mit Pointer
Variablen vom Datentyp ANY werden bei Bausteinaufrufen mit einem Zeigeroperator (p=pointer) übergeben, der auf
die Anfangsadresse der Variablen zeigt. Es kann auch ein Speicherbereich eingesetzt werden. Zusammen mit einer
Angabe über die Menge der nachfolgenden Daten ist der Speicherbereich definiert.
Syntax für Speicherbereich:
Beispiele: p# M 50.0
p# A 10.0
p# DB 10. DBX5.0
p# Bereichskennung Anfangs-Byte.Bit Datentyp
Byte
10
BOOl
4
S5TIME 3
Wiederholfaktor
// 10 Bytes im Speicherbereich Merker
MB 50... MB 59
// 4 Bit im Speicherbereich Ausgänge
A 10.0.... A 10.3
// 3 Daten vom Typ S5TIME, die in DB10 gespeichert sind
// und zwar in DB10 Byte 5 ... 10
2.8.4 Adresszusammenhang Bit, Byte, Wort, Doppelwort
Es ist wichtig zu wissen, wie Datentypen im Speicher angeordnet sind. Es gibt nämlich keine getrennten
Speicherbereiche für z.B. Bits oder Bytes! Die folgende Tabelle zeigt, wie die verschiedenen Datentypen
miteinander verzahnt sind:
Angenommen, es handelt sich um Operanden aus dem Merkerbereich. Dann lassen sich aus der Tabelle
beispielsweise folgende Werte für die Operanden ablesen:
BOOL:
BYTE:
WORD:
DWORD:
M10.0 =1; M 10.1 =1;
MB 10 = 17 Hex;
MW 10 = 1707 Hex
MD 10 = 1707F041 Hex
...
M 10.7 =0;
MB 11 = 07 Hex;
MW 11 = 07F0 Hex
... usw ...
MB 12 = F0 Hex;
MW12 = F041 Hex
M13.0 =1; M13.1 =0; ... M13.7 =0
MB 13 = 41 Hex
Der Anwenderspeicherspeicher ist also Byteweise organisiert: Binäre Operanden sind auf das jeweilige Byte
bezogen, in dem sie vorkommen und die Nummer von Wörtern und Doppelwörtern bezieht sich auf das
höchstwertige Byte!
S7kurs_2000.doc 07.01.10
Seite 14
Vorsicht Programmierfehler!
Die oben beschriebene Mehrfachnutzung von Speicherplatz für unterschiedliche Datentypen führt bei STEP7Einsteigern häufig zu Programmierfehlern! Da beispielsweise die Merker M10.0...M10.7 Untermengen von MB10
sind, verändert man durch Schreibzugriff auf MB10 auch automatisch diese Merker. Ebenso verändert man durch
Schreiben auf MW10 auch automatisch den Inhalt von MB11 usw.
Der beschriebene Speicheraufbau ermöglicht ein geschicktes Programmieren, z.B. kann man alle binären Eingänge
parallel mit einer Ladeoperation in das PAE einlesen - allerdings können bei Unachtsamkeit böse Programmierfehler
entstehen!
Tip: Zur Vermeidung solcher Fehler sollte man in einem STEP7-Projekt die Operanden getrennt nach Datentypen in
festgelegten Speicherbereichen ansiedeln! Am besten macht man hierfür ein Konzept vor der eigentlichen
Programmierarbeit und erspart sich so die Mühe des Fehlersuchens.
Beispiel:
Typ
Merker-Bits:
Merker-Bytes:
Merker-Worte:
Merker-Doppelworte
2.9
festgelegter Adreßraum
MB10 ... MB19
MB20 ... MB39
MB40 ... MB59
MB60 ... MB99
Reihenfolge der Vergabe
M10.0
M10.1
M10.2
MB20
MB21
MB22
MW40
MW42
MW44
MD60
MD64
MD68
...
...
...
...
...
bis
M19.7
MB39
MW58
MD96
Schreibweise zum Eingeben von Werten
STEP7 bietet Schreibweisen zum Eingeben oder Anzeigen von Daten in verschiedenen Formaten. Während die
meisten Schreibweisen einem bestimmten Datentyp entsprechen, können einige für mehrere Datentypen verwendet
werden. Folgende Schreibweisen sind zulässig:
Schreibweise
2#
True/False
B#(...)
B#16#
W#16#
DW#16#
Ganzzahl
L#
Gleitpunktzahl
C#
T#
D#
TOD#
S5T#
Datentyp
WORD
DWORD
BOOL
WORD
DWORD
BYTE
WORD
DWORD
INT
DINT
REAL
WORD
TIME
DATE
TOD
S5TIME
S7kurs_2000.doc 07.01.10
Beschreibung
Beispiel (e)
Binäre Schreibweise
2#0001_0000_0000_1101
Binäre Schreibweise
2#1000_1111_0101_1101_0010_0000_0000_1101
TRUE oder FALSE
TRUE, FALSE
Wert der einzelnen Bytes dezimal
B#(10,255)
Wert der einzelnen Bytes dezimal
B#(100,114,2,10)
Byte hexadezimal
B#16#4F
Wort hexadezimal
W#16#FF1B
Doppelwort hexadezimal
DW#16#09A2_FF13
IEC-Ganzzahlformat mit Vorzeichen in Bit 15
-2270
32767
32Bit Ganzzahlformat, Vorzeichen in Bit 31
L#44520
L#-49245
IEC-Gleitpunktzahlenformat
3.14
1.234567e+13
16Bit Zählerkonstante 0...999
C#500
T#TageD_StundH_MinutM_SekundS_MillisekMS
T#0D_1H_10M_22S_100MS
D#Jahr-Monat-Tag
D#1997-3-15
TOD#Stunden:Minuten:Sekunden:Millisekunden
TOD#13:24:33:555
S5T#TageD_StundH_MinutM_SekundS_MillisekMS
S5T#12M_22S_100MS
Seite 15
3 Beispiele in FUP/KOP und AWL
3.1
Logische Verknüpfung
Die folgenden kleinen Programmbeispiele sind zum Vergleich jeweils
in den 3 Sprachen dargestellt. FUP
und KOP sind im Sprachumfang
gleich.
Insbesondere bei den etwas komplexeren Funktionen sind sie sehr
ähnlich. Daher sollte man nicht mit
FUP
und
KOP
gleichermaßen
arbeiten, sondern sich für eine der
beiden entscheiden.
3.2
Flip Flop und Flankenerkennung
Gezeigt ist ein ein FlipFlop mit dominandem Rücksetzeingang.
Flankenerkennungen benötigen einen
freien binären Operanden zum
Speichern des früheren Signalzustands, hier M1.0.
Gezeigt ist die Verwendung der
Operation „P“ zur Erkennung einer
positiven, d.h. ansteigenden Flanke.
3.3
Timer
Der Zeitwert
S5Time!
ist
vom
Datentyp
Neben dem verwendeten Impulstimer gibt es noch Timer für
Einschaltverzögerung,
Ausschaltverzögerung
und
speichernde
Einschaltverzögerung.
S7kurs_2000.doc 07.01.10
Seite 16
3.4
Zähler
Mit positiver Flanke 0→1 an S wird
der Zähler auf den Wert ZW
eingestellt. ZW ist im Format
C#<Wert>
Wert = 0..999
Neben
dem
Rückwärtszähler
Vorwärtsund
wärtszähler.
3.5
dargestellten
gibt es auch
Vorwärts/Rück-
Arithmetische Operation
Addition zweier Integerzahlen.
3.6
Bausteinaufruf
Gezeigt ist der bedingte Bausteinaufruf:
FC2 wird nur dann
bearbeitet, wenn die Variable „E3“
den Wert TRUE hat.
Außerdem gibt es noch einen
absoluten Bausteinaufruf (Bearbeitung immer, ohne Bedingung).
Unter FUP darf der Eingang EN
dann einfach unbeschaltet bleiben
(s.a. Abschnitt 3.5)
S7kurs_2000.doc 07.01.10
Seite 17
4 Handhabung der CPU
4.1
Betriebszustände und Übergänge
Die Betriebszustände der CPU können mit dem Schlüssel-Schalter an der CPU (STOP - RUN - RUN-P) oder durch
Einstellungen am Programmiergerät (siehe unten) eingestellt werden. Der Schlüsselschalter hat dabei höhere
Priorität. Das Verhalten der CPU ist durch den jeweiligen Betriebszustand gekennzeichnet:
STOP: Das Anwenderprogramm wird nicht bearbeitet. Ausgänge sind auf 0 gesetzt. Die CPU prüft, ob Hardwareoder Systemfehler vorliegen. Das Urlöschen ist möglich.
ANLAUF: Bevor die CPU nach dem Einschalten mit der Bearbeitung des Anwenderprogramms beginnt, veranlaßt
das Betriebssystem den Aufruf des OB100 (Neustart). Im OB1 können Sie Voreinstellungen für den Start des
zyklischen OB1-Programms vornehmen.
RUN: Bearbeitung des zyklischen OB1-Anwenderprogramms
RUN-P: RUN-Zustand, in dem zusätzlich Bausteine vom Programmiergerät geladen werden können.
Vorsicht! Nach Ablauf des Ladens setzt die CPU mit den neuen Bausteinen die zyklische Bearbeitung fort!
HALT: Dies ist eine selten verwendete Betriebsart zu Testzwecken. Dabei werden die Grundtakte der Zeitsteuerung
angehalten und die Timer bleiben stehen.
4.2
Laden des Anwenderprogramms
Programm-Bausteine sind im Ladespeicher der CPU
abgelegt.
Für Testzwecke und im Labor genügt
normalerweise das Ablegen der Bausteine im RAM.
Dies geschieht vom SIMATIC-Manager aus mit:
Zielsystem ⇒ Laden ⇒ Objekt, z.B. S7-Programm
Das EPROM wird angesprochen mit
Zielsystem ⇒ RAM nach ROM kopieren
EPROM-Memory Cards im Slot der CPU werden
angesprochen mit
Zielsystem ⇒ Laden in Memory-Card ⇒ Objekt
4.3
Urlöschen der CPU
Beim sogenannten „Urlöschen“ wird der Arbeitsspeicher und RAM-Ladespeicher der CPU gelöscht. Außerdem
werden alle CPU- und Baugruppenparameter auf die Default-Einstellungen zurückgesetzt. Man sollte die CPU vor
dem Laden eines neuen Anwenderprogramms urlöschen. Die CPU muß dabei im Betriebszustand STOP sein. Zum
Urlöschen mit dem Programmiergerät sind vom SIMATIC Manager aus die folgenden Schritte erforderlich:
Erreichbare Teilnehmer ⇒ CPU auswählen ⇒ Zielsystem
Und dann:
⇒ Zielsystem
4.4
⇒ Betriebszustand ⇒ CPU auf „STOP“
⇒ Urlöschen
Verhalten der CPU bei Netzausfall
Um die CPU vor Datenverlust zu schützen, gibt es je nach CPU verschiedene Methoden:
•
Batteriepufferung
Die meisten CPU’s haben eine Batteriepufferung. Dadurch sind Codebausteine (OB,FC,FB) und Datenbausteine
(DB) geschützt. Ebenso die remanenten Merker, Zeiten und Zähler (siehe auch unter ‘Remanenz’). Nicht
remanente Operanden erhalten nach Netzausfall automatisch den Wert 0.
S7kurs_2000.doc 07.01.10
Seite 18
•
EPROM, Memory-Card
Verschiedene CPU’s haben einen Slot für Memory-Card oder einen eingebauten E(E)PROM-Bereich. Sofern das
Programm in den EPROM-Bereich geladen wurde, sind Code- und Datenbausteine vor Datenverlust bei Netzausfall
geschützt - auch ohne Batteriepufferung.
CPU’s ohne Batterie-Fach
Falls eine CPU keine Batterie hat (zB. CPU 312IFM), existiert ein E(E)PROM-Bereich zum Schutz der Daten bei
Stromausfall. Nach dem normalen Laden des S7-Programms in den RAM-Bereich der CPU sichert man die Daten
wie folgt:
SIMATIC Manager (Online) ⇒ die betreffende CPU markieren ⇒ rechte Maustaste
⇒ Zielsystem
⇒ RAM nach ROM kopieren
5 Erste Übung am STEP7-Arbeitsplatz
5.1
Ein STEP7 Programm erstellen
Für Ihr erstes Step7-Projekt soll die Aufgabe bewußt einfach sein, damit Sie sich auf die Programmierumgebung
konzentrieren können. Es soll nur eine S7- Station existieren.
Aufgabe: Ein selbst programmierter Zeittakt soll einen Zähler inkrementieren, solange der Eingang „Zählen“ =1 ist.
Außerdem soll möglich sein, den aktuellen Zählerstand am Ausgang dual anzuzeigen und den Zähler über einen
Eingang rückzusetzen.
5.1.1 STEP7 starten
Sie starten die Software aus Windows, indem Sie auf das Symbol für den SIMATIC Manager
doppelklicken. Der SIMATIC Manager ermöglicht eine Übersicht über vorhandene Projekte und
Bibliotheken auf dem Datenträger. Alle Objekte eines Projekts werden hierarchisch dargestellt. Über die
Objekte erhalten Sie einfachen Zugang zu allen Funktionen. Sie können neue Projekte erstellen,
kopieren, löschen, archivieren. Sie können Daten in angeschlossene Automatisierungsgeräte laden.
5.1.2 Ein neues Projekt erzeugen
Legen Sie fest, in welchem Verzeichnis Ihr Projekt abgelegt werden soll:
SIMATIC Manager ⇒ Extras ⇒ Einstellungen ⇒ SIMATIC Manager ⇒ Ablageort für Projekte u. Bibliotheken
Sie können die Voreinstellung ..\STEP7\S7proj aber auch so lassen. Zur Erstellung eines neuen Projekts nutzen
Sie die Hilfe des Projekt-Assistenten: SIMATIC-Manager ⇒ Datei ⇒ Assistent ‘Neues Projekt’
Geben Sie den CPU-Typ „Ihrer“ S7-Station an. Als MPI-Adresse können Sie die Defaulteinstellung (MPI=2) lassen,
wenn nur eine Station angeschlossen ist. Klicken Sie die „Vorschau“ an, um die entstehende Projektstruktur zu
kontrollieren.
Mit „Weiter“ kommen Sie in das nächste Fenster. Hier können Sie die benötigten OB’s auswählen. Verschaffen Sie
sich einen ersten Überblick über die vorhandenen OBs und deren Funktion.
Wählen Sie als Baustein den „OB1“ und als Voreinstellung für die Programmiersprache „FUP“ .
Mit „Weiter“ kommen Sie in das nächste Fenster. Tragen Sie einen aussagekräftigen Namen Ihres Projekts ein.
Sind Sie mit den Einstellungen zufrieden, schließen Sie den Projekt-Assistenten mit „Fertigstellen“.
Betrachten Sie im SIMATIC Manager Ihr neues Projekt. Klicken Sie mit der rechten Maustaste einzelne Objekte an,
z.B. „S7-Programm“. Es klappt jeweils ein Menü auf mit Möglichkeiten, was Sie mit dem Objekt machen können, z.B.
Kopieren, Löschen, Einfügen etc. Unter „Objekteigenschaften“ können Sie beispielsweise eine Kurzbeschreibung des
Objekts anfordern.
Löschen Sie im S7-Programm den Behälter „Quellen“. Da wir jetzt nur unter AWL,FUP,KOP programmieren wollen,
brauchen wir ihn nicht.
5.1.3
Umgang mit dem S7 Manager
Nach dem Verlassen von STEP7 würde bei Ihrer nächsten Arbeitssitzung automatisch das zuletzt bearbeitete Projekt
geladen werden. Ein beliebiges Projekt wählen Sie aus mit:
SIMATIC Manager ⇒ Datei ⇒ Öffnen ⇒ Projekt
S7kurs_2000.doc 07.01.10
Seite 19
Statt „Öffnen“ können Sie hier entsprechend ein Projekt schließen, löschen, archivieren etc. Nutzen Sie die OnlineHilfe, wenn Sie ein Vorgang besonders interessiert. Wichtig ist Projekt archivieren, da ein Speichern des Projekts
auf Diskette wegen der Datenmenge praktisch nur möglich ist mit einer komprimierten Archivdatei.
Im Fenster "Öffnen Projekt" können Sie sich mit „Durchsuchen“ eine Übersicht über die vorhandenen Projekte
verschaffen. Wenn Sie genug probiert haben, stellen Sie „Ihr“ Projekt wieder ein.
5.1.4 Die Hardware konfigurieren
Unter „Hardware konfigurieren“ versteht man die Festlegung, aus welchen Baugruppen die Station besteht.
Prinzipiell ist es egal, ob Sie erst das Programm erstellen und danach die Stations-Hardware konfigurieren oder
umgekehrt. Spätestens aber, ehe Sie Ihre Programmbausteine in das Automatisierungsgerät laden, muß die
vorhandene Hardware konfiguriert sein.
Öffnen Sie das Objekt „Hardware“: Klicken Sie mit der rechten Maustaste auf das Objekt „Hardware“ im Behälter
„SIMATIC 300-Station“ und wählen Sie „Objekt öffnen“, (Auch ein Doppelklick mit der linken Maustaste auf das
Objekt „Hardware“ führt zum Ziel). Es erscheint das Fenster „Hardware Konfigurieren“ mit einem BaugruppenträgerSymbol. Falls der „Hardware-Katalog“ auf der rechten Bildschirmseite noch nicht sichtbar ist, veranlassen Sie dies
mit: Einfügen ⇒ Hardware-Komponenten
Verschaffen Sie sich einen Überblick über die Komponenten des
können Sie Unter-Objekte öffnen durch anklicken des Symbols:
Hardware-Katalogs! Wie unter Windows üblich,
Nun können Sie den Baugruppenträger ‘bestücken’, indem Sie Komponenten im Hardware-Katalog anklicken und bei
gedrückter Maustaste auf den entsprechenden Bestückungsplatz ziehen. Orientieren Sie sich bei der Auswahl der
Komponenten an der Ihren zur Verfügung stehenden SIMATIC-Station.
Reservierung der Steckplätze:
Steckplatz
Steckplatz
Steckplatz
Steckplätze
1:
2:
3:
4..11:
reserviert für die Stromversorgung
reserviert für die CPU.
bleibt frei
Signalbaugruppen digital/analog
PS (Power Supply)
SM (Signal Modul)
Baugruppen-Adressen
Die Adressen der I/O-Signale einer bestimmten Baugruppe sind abhängig von den Eigenschaften der Baugruppe
(E/A und Anzahl der Byte) und von dem Steckplatz, aus dem sich die Anfangsadresse ergibt.
Tip: Neben den anderen Objekt-Eigenschaften können Sie sich auch die Baugruppen-Anfangsadressen direkt
ausgeben lassen: Rechter Maustklick auf die betreffende Baugruppe, dann: ⇒ Objekteigenschaften ⇒ Adressen
Beispiel:
Baugruppe für 16 digitale Ausgänge am Steckplatz 5
Wegen Steckplatz 5 gilt: Anfangsadresse = 4 (dezimal)
Die Baugruppe belegt 16 Bit, also 2 Byte im Peripheriebereich der Ausgänge ab der Anfangsadresse
Daher sind verfügbar: AB4 und AB5
oder:
A4.0 ... A4.7, A5.0 ... A5.7
Speichern Sie Ihre Hardwarekonfiguration mit: Station ⇒ Speichern
5.1.5 Die Baugruppen parametrieren
Die CPU und auch verschiedene andere Baugruppen können parametriert werden, d.h. per Software kann die
Funktionalität verändert werden. Gehen Sie dazu wie folgt vor:
Rechter Mausklick auf die die betreffende Baugruppe, z.B. CPU, dann: „Objekteigenschaften“
Verschaffen Sie sich jetzt nur einen ersten Einblick in die Parametriermöglichkeiten „Ihrer“ CPU.
Tip: Interessant ist z.B. der Parameter „Zyklusüberwachungszeit“ im Menü Zyklus/Taktmerker. Damit kann die
spätere Bearbeitung des OB1-Zyklus überwacht werden: Falls die Zyklus-Dauer des OB1-Bausteins wegen LaufzeitFehlern länger ist als der eingestellte Parameter, wird die CPU automatisch in den STOP-Modus geschaltet.
Interessant ist auch die Einstellung der remanenten Merker,Timer,Zähler im Menü „Remanenz“. Die als „remanent“
gekennzeichneten Operatoren werden später vor Datenverlust bei Spannungsausfall geschützt.
Lassen Sie alle eingestellten Parameter, wie sie in der Voreinstellung vorgesehen sind. Verlassen Sie das Fenster
„Hardware Konfigurieren“.
S7kurs_2000.doc 07.01.10
Seite 20
5.1.6 Erstellen einer Symboltabelle
Sinn der Symboltabelle ist, eine Zuordnung von absoluten Operanden (z.B. A4.0) zu aussagekräftigen symbolischen
Bezeichnungen (z.B. „Ventil 1“) zu schaffen. Dadurch wird das Programm übersichtlicher.
Wichtig: Die Symboltabelle gilt für das ganze S7-Programm, nicht nur für einen einzelnen Baustein!
Den Symboleditor zur Erstellung der Symboltabelle starten Sie vom SIMATIC Manager aus im Behälter S7Programm durch Doppelklicken auf „Symbole“:
Es erscheint das Fenster "Symbol Editor". Die Programmumgebung hat bereits für den absoluten Operanden „OB1“
ein Symbol vorgeschlagen. Das können Sie löschen oder auch so lassen - wie Sie möchten.
Erstellen Sie die folgende Symboltabelle. Achten Sie dabei in der Spalte ‘Symbol’ auf Groß/Kleinschreibung! Falls
Sie Probleme beim Editieren haben, nutzen Sie die die Online-Hilfe.
Symbol
Adresse
Datentyp
Kommentar
Zählen
Reset
Zeit1
Zeit2
Zähl_Dual
Zähl_BCD
Zähl_Q
E0.0 *)
E0.1 *)
MW0
MW2
AW4 *)
MW4
M1.1
BOOL
BOOL
WORD
WORD
WORD
WORD
BOOL
Zählerstand automatisch inkrementiert, wenn Zählen=1
Zählerstand auf 0 gesetzt, wenn Reset=1
Zeitablauf Timer 1
Zeitablauf Timer 2
Zählerstand als Dualwert
Zählerstand als BCD-Wert
Status des Zählers Zähl_Q=1 wenn Zählerstand > 0
*) überzeugen Sie sich, daß auch „Ihre“ Station mit den entsprechenden I/O-Baugruppen bestückt ist (oder fragen Sie Ihren
Betreuer) und ändern Sie gegebenenfalls die Adressen!
Probieren Sie die verschiedenen Sortiermöglichkeiten, um die Datensätze der Symboltabelle darzustellen, mit:
Symbol Editor ⇒ Ansicht ⇒ Sortieren ⇒ Sortierkriterium...
Speichern Sie Ihre Symboltabelle und schließen Sie den Symbol Editor.
5.1.7 Bausteine Editieren
Sie wissen, mit den SPS-Programmiersprachen können strukturierte Programme aufgebaut werden. Ein Programm
besteht im allgemeinen aus mehreren oder vielen Bausteinen, die im OB1 aufgerufen werden. Der OB1 ist dabei so
etwas wie ein Hauptprogramm, das ständig im Zyklus abläuft. Ihr erstes kleines Programm soll -der Einfachheit
halber- nur aus dem OB1 bestehen.
Öffnen Sie das bereits vorhandene Objekt „OB1“ im Behälter „Bausteine“ durch anklicken von OB1 mit der rechten
Maustaste und „Objekt Öffnen“ .
Tip: Sie können ein Objekt auch öffnen durch Doppelklicken auf das Objekt. Einen neuen Baustein können Sie
erzeugen im SIMATIC Manager mit: Anklicken des Objekts „Bausteine“ mit der rechten Maustaste, dann:
⇒ „Neues Objekt einfügen“ ⇒ Baustein-Typ wählen
Es erscheint das Fenster „KOP/AWL/FUP..Projektname..OB1“. In diesem Baustein-Editor können Sie den OB1 in der
gewünschten Sprache erstellen. Im oberen Teil ist die Deklarationstabelle, darunter können die Anweisungen für den
OB1 editiert werden.
Um die Deklarationstabelle brauchen Sie sich jetzt nicht zu kümmern, nur so viel: von STEP7 wurden per
Voreinstellung bereits lokale Variable deklariert, auf die im Bedarfsfall zugegriffen werden kann. Beispielsweise
übergibt das Betriebssystem einer Variablen „OB1_Date_Time“ den Startzeitpunkt des aktuellen Zyklus. Damit Sie
mehr Platz auf dem Bildschirm haben, können Sie die Deklarationstabelle am unteren Rand mit der Maus packen
und nach oben zusammenschieben.
Nun sind noch einige Einstellungen zu machen mit dem Menü Ansicht:
Programmiersprache einstellen:
Symbolische Darstellung:
Symbolinformation:
Baustein-Kommentare unterstützen:
Vergrößern, Verkleinern, Zoomfaktor
FUP
Ein
Ein
Ein
nach Bedarf...
Ein Baustein wird unterteilt in ein oder mehrere „Netzwerke“, die nacheinander bearbeitet werden. Unser kurzes
Programm paßt in zwei Netzwerke.
Editieren Sie die beiden Netzwerke.
Hinweis: Die fertigen Netzwerke finden Sie auf der nächsten Seite ausgedruckt!
S7kurs_2000.doc 07.01.10
Seite 21
Editieren Sie ein Netzwerk am besten von rechts nach links, d.h. beginnen Sie am Ausgang! Zuerst setzen Sie die
einzelnen Programmelemente und tragen schließlich die Operanden ein. Bei den Operanden können Sie absolute
und symbolische Bezeichnungen verwenden (soweit diese bereits im Symbol Editor definiert wurden).
Symbolische Bezeichnungen müssen gekennzeichnet werden durch Anführungszeichen, z.B. „Zählen“. Bei den
Symbolischen Bezeichnungen achten Sie auf auf richtige Groß/Kleinschreibung entsprechend Ihrer Definition!
Ihre Eingaben werden Schritt für Schritt von STEP7 auf Fehler untersucht. Falsche Eingaben werden rot
gekennzeichnet. Nutzen Sie bei Bedarf die Online-Hilfe.
Zeigen Sie die vorhandenen Programmelemente an mit ⇒ Einfügen ⇒ Programmelemente,
oder
durch
klicken
auf:
Falls Sie die Programmelemente am rechten Bildrand jetzt noch nicht sehen: Packen Sie im Fenster KOP/FUP/AWL
den rechten senkrechten Bildrand und ziehen ihn nach links. Damit schaffen Sie Platz für das Dialogfeld
„Programmelemente“. Verschaffen Sie sich einen Überblick über die vorhandenen Programmelemente!
Wählen Sie jeweils aus den Programmelementen das geeignete Objekt aus und ziehen Sie es bei gedrückter
Maustaste in den Anweisungsteil Ihes Netzwerks, also z.B.:
Programmelemente
⇒
⇒
Zeiten
Bitverknüpfung
⇒
⇒
S-Impuls
Negationspunkt
(SIMATIC Timer, Impuls)
(Binäre Negation)
die Operanden tragen Sie ein an den Stellen mit: ???
Ein neues Netzwerk erreichen Sie mit:
schließlich im 2. Netzwerk:
Programmelemente
⇒ Zähler
⇒ Bitverknüpfung
⇒
⇒
Z_VORW
-[=]
(Vorwärtszähler)
(Binäre Zuweisungsoperation, oder „Spule“)
Am besten tragen Sie jetzt zum kennenlernen die verschiedenen Kommentare ein. Sie haben folgende Stellen, an
denen Sie im Baustein Kommentar eintragen können:
Kommentare:
FUP/KOP/AWL
Baustein-Überschrift
Baustein-Kommentar
Netzwerk-Überschrift
Netzwerk-Kommentar
hinter „OB1“
unter der Bausteinüberschrift
hinter „Netzwerk 1“
unter Netzwerk-Überschrift
unter AWL haben Sie außerdem noch die Möglichkeit zu einem Zeilenkommentar hinter dem Trennzeichen: //
Beispiel:
U E2.3
// dies ist ein Zeilenkommentar
Es ist äußerst sinnvoll, den erklärenden Text gleich beim Editieren der Netzwerke bzw. des Baustein einzutragen,
dann müssen Sie ein Programm später nicht noch mal entwickeln...
So etwa sollte Ihr OB1 schließlich
aussehen !
So etwa sollte Ihr OB1 schließlich
aussehen!
Tip: Schalten Sie testhalber um in die
anderen Sprachen KOP und AWL, damit
Sie einen Eindruck bekommen, wie KOP
und AWL funktioniert.
Umschalten mit zB.: Ansicht ⇒ KOP
Den Baustein abspeichern mit Datei → Speichern
S7kurs_2000.doc 07.01.10
Seite 22
5.2
Das Programm in das Zielsystem laden
5.2.1 Verbindung zum Automatisierungsgerät
Überzeugen Sie sich, dass Ihre S7-Station am Programmiergerät angeschlossen und mit Strom versorgt ist.
5.2.2 Urlöschen der CPU
Bevor die Programme eines neuen Projekts zum ersten Mal in das Automatisierungsgerät (AG) geladen werden, ist
es sinnvoll, durch Urlöschen der CPU eine definierte Ausgangssituation zu schaffen: alte Bausteine und Daten
werden gelöscht, Systemeinstellungen erhalten Voreinstellungswerte.
Zum Urlöschen mit dem Programmiergerät muß der Schlüsselschalter auf STOP stehen (LEDs kontrollieren).
SIMATIC Manager
dann
⇒
⇒
Erreichbare Teilnehmer ⇒ MPI-Stationsadresse markieren (hier: MPI=2),
Zielsystem ⇒ Urlöschen
5.2.3 Programm übertragen
Im Allgemeinen besteht das CPU-Programm aus mehreren oder vielen Bausteinen. Sie können alle Bausteine in
einem Stück in das Automatisierungsgerät (AG) laden durch Verwendung des SIMATIC Managers.
SIMATIC Manager
⇒ Behälter „Bausteine“ des S7-Programms markieren, dann
⇒ Zielsystem
⇒ Laden
Wenn Sie nur einen Baustein haben oder aktuelle Änderungen nur einen Baustein des CPU-Programms betreffen
(alle anderen Bausteine also bereits im AG vorhanden sind), können Sie aus dem KOP/AWL/FUP-Editor heraus den
gerade geöffneten Baustein alleine übertragen mit:
KOP/AWL/FUP-Editor ⇒ Zielsystem ⇒
Laden
5.2.4 Das Automatisierungsgerät starten
Bringen Sie den Schalter am AG in die Stellung „RUN“. Nun können Sie auch vom Programmiergerät aus das AG
stoppen oder wieder erneut starten mit:
SIMATIC Manager
⇒ Erreichbare Teilnehmer
⇒ MPI-Stationsadresse markieren (hier: MPI=2), dann
⇒ Zielsystem
⇒ STOP bzw. Start
5.3
Das Programm testen
Natürlich gibt es triviale Möglichkeiten zum Testen des Programms: Einfach auf auf die LEDs der Ein/Ausgänge
schauen oder gar frech einfach die zu steuernde Anlage anschließen. Aus Sicherheitsgründen ist aber dringend
davon abzuraten!!!
Nutzen Sie die in STEP7 vorhandenen Testhilfen, um die Fehlerfreiheit Ihres Anwenderprogramms zu beweisen, ehe
eine Anlage angeschlossen wird.
Dazu müssen Sie eine Online-Verbindung zum AG herstellen:
5.3.1 Onlinedarstellung im S7 Manager
SIMATIC Manager ⇒ Ansicht ⇒ Online oder dieses Symbol anklicken:
Öffnen Sie aus dem Behälter „Bausteine“ Ihren OB1. Damit kommen Sie in Online-Darstellung in den
KOP/AWL/FUP-Editor.
Sie haben nun zwei grundsätzlich verschiede Testhilfen zur Verfügung:
5.3.2 Bausteinorientierte Testhilfe
Hierbei werden Variablenwerte in einem bestimmten Baustein -und dort in einem bestimmten Netzwerk- online
dargestellt. Die Testumgebung eignet sich vor allem zur Fehlersuche auf Bausteinebene und zur Untersuchung
einzelner Programmsequenzen.
S7kurs_2000.doc 07.01.10
Seite 23
Starten Sie den Test mit:
Test ⇒ Beobachten
Jetzt können Sie sie die Variablenwerte betrachten. Sie sehen, wie die Werte sich im jeweiligen Netzwerk verhalten.
Machen Sie sich vertraut mit der Testumgebung. Sie verlassen die Testhilfe durch erneutes anklicken von: Test ⇒
Beobachten.
5.3.3 Variablenorientierte Testhilfe:
Hierbei können Sie Variablenwerte an einem bestimmten Triggerpunkt im Programm (i.a. am OB1-Zyklusende)
online betrachten. Sie erstellen eine Tabelle der interessanten Variablen und legen die Triggerbedingung fest. Diese
Testhilfe eignet sich besonders gut, einen Überblick über die Funktion des gesamten CPU-Programms zu erhalten.
Auch bei der späteren Inbetriebnahme der Anlage ist sie gut einsetzbar. Die Variablen-Tabelle bekommt einen
Namen (z.B. VAT12) und wird als Bestandteil des CPU-Programms abgespeichert. Sinn ist, bereits bei der
Programmentwicklung eine brauchbare Testumgebung zu gestalten.
Starten Sie den Test aus dem Fenster KOP/AWL/FUP(Online) mit: Zielsystem ⇒ Variable beobachten/steuern
Es erscheint ein Fenster „Variable beobachten und steuern“. Tragen
Sie in die Tabelle „Ihre“ Operanden ein wie nebenstehend. Es
genügt, absolute Operanden einzutragen, der Rest wird von STEP7
automatisch eingetragen.
5.3.3.1 Variablen Beobachten
Operand
E0.0
E0.1
MW0
MW2
AW4
MW4
M1.1
Symbol
Zählen
Reset
Zeit1
Zeit2
Zähl_Dual
Zähl_Dez
Zähl_Q
Status-Format
Bin
Bin
Dez
Dez
Dez
Dez
Bin
Starten Sie „Variablen Beobachten“: Variable ⇒ Beobachten.
Jetzt können Sie betrachten, wie die Werte Ihre Variablen am festgelegten Triggerpunkt des Programms sich im Lauf
der Zeit verändern. Sie stoppen die Testhilfe durch erneutes anklicken von: Variable ⇒ Beobachten
5.3.3.2 Variablen Steuern
Sie können zu Testzwecken an einem bestimmten Triggerpunkt im Programm den Wert von Variablen gezielt
ändern! Tragen Sie die gewünschten Werte in die Spalte „Steuerwerte“ der Variablentabelle ein. Beim Start der
Testhilfe werden die Variablen in der CPU mit den Steuerwerten initialisiert. Anschließend ändern sie sich
entsprechend den Programmanweisungen.
Probieren Sie, den Zähler (Variable Z1) testhalber auf einen bestimmten Wert zu setzen.
Ende Ihrer Ersten Sitzung am Programmiergerät
S7kurs_2000.doc 07.01.10
Seite 24
6 Funktion (FC)
Im diesem Abschnitt werden die wesentlichen Aspekte bei der Erstellung und Verwendung von Funktionen
behandelt. Das geschieht am Beispiel eines speziellen Multiplizierers.
Beispiel-Funktion
Es soll eine Funktion erstellt werden, die das Ergebnis Y = A*B*C zurückliefert. Die Variablen sind alle vom Typ DINT
(Ganzzahl, 32 Bit). Wenn die Faktoren zu groß sind, wird der zulässige Zahlenbereich von Y überschritten und das
Ergebnis ist falsch! Deshalb sollte der Erfolg der Berechnung dem aufrufenden Baustein mitgeteilt werden.
Wegen Y= A*B*C= (A*B)*C kann die Berechnung
der
Multiplikation
aus
zwei
hintereinandergeschalteten Multiplizierern mit jeweils 2 Eingängen
zusammengesetzt werden.
STEP7 stellt fertige Multiplizierer mit zwei Eingängen
zur Verfügung. In der Liste der Programmelemente
ist die Operation MUL_DI (Multiplikation für Variable
vom Typ DINT) zu finden.
Die Operanden EN und ENO kommen in FUP/KOP
bei der Darstellung von FC‘s, FB‘s und aufwendigen
Programmelementen, vor, wie auch die nebenstehende Beschreibung von MUL_DI zeigt.
aus der Online-Hilfe zu MUL_DI
6.1
Die Operanden EN (Enable) und
ENO (Enable Out)
Wenn unter FUP/KOP eine Funktion aufgerufen wird, erscheint ein Block mit den Bausteinparametern, die von
außen entsprechend beschaltet werden. Eine Besonderheit sind dabei die Operanden EN auf der Eingangs- und
ENO auf der Ausgangsseite. Sie werden zur Programmsteuerung und zur Behandlung von Laufzeitfehlern während
der Bearbeitung verwendet.
Die Operanden EN und ENO sind dem Wert des Statusflags „BIE“ (Binärergebnis) der CPU fest zugeordnet und
brauchen deshalb im Baustein nicht deklariert zu werden.
EN
ENO
entspricht dem Wert von BIE vor der Bearbeitung,
entspricht dem Wert von BIE nach der Bearbeitung des jeweiligen Funktionsblocks.
Unter AWL treten diese Operanden nicht auf. Hier wird stattdessen direkt mit dem Statusflag „BIE“ gearbeitet
EN (Enable)
Der betreffende Funktionsblock wird nur dann bearbeitet, wenn EN = 1 ist. Im anderen Fall wird er übersprungen. Im
Zusammenhang mit einem Bausteinaufruf ist EN die Bedingung, ob der Baustein tatsächlich bearbeitet wird oder
übersprungen wird.
Bearbeitung des Funktionsblocks dann, wenn:
EN = 1
ENO (Enable Out)
Der Wert von ENO bzw. BIE wird durch Programmanweisungen im betreffenden Funktionsblock festgelegt. Es gilt
folgende Konvention zur Programmsteuerung:
Man setzt ENO in Abhängigkeit von evtl. Laufzeitfehlern durch einem Schreibzugriff auf das Statusflag „BIE“
(Binärergebnis) auf folgenden Wert:
Bearbeitung des Bausteins ohne Fehler:
Fehler aufgetreten:
BIE = 1
BIE = 0
(ENO = 1)
(ENO = 0)
Die letzte Operation vor dem Verlassen des Bausteins sollte also die Zuweisung eines entsprechenden Wertes auf
das BIE-Flag sein. Damit wird der ENO des gesamten Bausteins festgelegt.
Hierfür wird unter AWL die Operation „SAVE“ verwendet. BIE wird wird dieser Operation auf den Wert des
Statusflags VKE (Verknüpfungsergebnis) gesetzt.
S7kurs_2000.doc 07.01.10
Seite 25
Mit der Operation „SAVE“ wird der Inhalt des VKE (Verknüpfungsergebnis) dem BIE zugewiesen
Man erstellt also ein VKE entsprechend der Programmsteuerungs-Konvention und weist am Bausteinende durch
eine „SAVE“-Operation den Wert dem BIE-Flag zu.
Da von den vielen Operationsbefehlen unter STEP7 lediglich SAVE einen Einfluß auf das BIE-Flag besitzt, gilt
außerdem noch die folgende Regel:
Wenn keine Operation „SAVE“ vorkommt, ist:
ENO = EN
Beispiel: BIE soll mit dem Wert von Merker M1.0 belegt werden. In den verschiedenen Sprachen sieht die Operation
so aus:
FUP
KOP
AWL
U M1.0
SAVE
6.2
Erstellen einer Funktion
Selbstverständlich muß ein Baustein bereits existieren, ehe er aufgerufen werden kann! Ideshalb wird als erstes die
Funktion erstellt. Im Deklarationsteil wird die Schnittstelle der Funktion nach außen festgelegt:
6.2.1 Deklarationsteil
Die Deklarationstabelle enthält die Lokalen Variablen der Funktion.
Als Eingänge (Deklarationstyp „in“) vom
Datentyp DINT werden dem Baustein die
drei Faktoren A, B, C übergeben. Der
Ausgang Y (Deklarationstyp „out“) ist
ebenfalls vom Datentyp DINT. Alle
Formalparameter
werden
mit
dem
Anfangswert 0 initialisiert
Das Zwischenergebnis A*B kann nach
Verlassen des Bausteins ‘vergessen’ werden; deshalb wird es als temporäre Variable deklariert (Deklarationstyp
„temp“).
6.2.2 Anweisungsteil in FUP und AWL
Anweisungsteil in FUP
Wenn unter FUP der EN Eingang unbeschaltet ist, wird der Block bearbeitet!
Zur Ermittlung des Baustein-ENO kann man hier einfach den ENO des ersten Blocks auf den EN des zweiten
‘durchschleifen’ (dann den ENO auf den EN des nächsten ...usw.). Der ENO des letzten Funktionsblocks muß über
die Operation „SAVE“ nach außen weitergegeben werden. Würde oben die Save-Anweisung gelöscht werden, würde
ein Überlauf-Fehler des zweiten Funktionsblocks nicht weitergegeben werden!
Im letzten Netzwerk wird als letzte Anweisung über die Operation SAVE der Baustein-ENO gesetzt.
Meistens hat man es aber mit weniger komplexen Programmelementen zu tun, die selbst keine EN/ENO-Anschlüsse
haben (z.B Binäre Verknüpfungen, FlipFlops, Zähler etc). Dann muß man den Wert des Baustein-ENO’s eben selbst
programmieren. Dabei ist die bereits beschriebene Konvention zu beachten.
S7kurs_2000.doc 07.01.10
Seite 26
Anweisungsteil desselben Netzwerks in AWL:
Folgende
AWL-Operationen
sind
im
Zusammenhang mit dem Binärergebnis-Flag
BIE besonders interessant:
Operation
SAVE
CLR
SET
NOT
6.3
Beschreibung
Wert von VKE → BIE
setzt VKE → 0
setzt VKE → 1
negiert das VKE
Aufrufen der Funktion
Aufruf unter FUP:
Unter FUP erfolgt der Aufruf des FC mit dem
Programmelement „FC“. Dort ist der bereits
erstellte FC1 vorhanden und kann einfach
ins Netzwerk gezogen werden.Falls der
Aufruf von einer Bedingung abhängen soll,
wird
der EN-Eingang entsprechend
beschaltet (Bearbeitung erfolgt, wenn EN=1
oder wenn EN unbeschaltet ist).
Im Beispiel trägt der Merker 1.0 die
Information, ob das Ergebnis Y stimmt.
Aufruf unter AWL:
Unter AWL erfolgt der Aufruf mit der
Operation „CALL“. Falls der Aufruf von einer
Bedingung abhängig sein soll, muß durch
entsprechende Sprunganweisungen die
Zeile mit „CALL“ übersprungen werden.
6.4
Fehlerbehandlung und Statusmeldungen
Manchmal reicht die bereits beschriebene Verwendung von EN/ENO zur Fehlerbehandlung nicht aus, um im
aufrufenden Baustein ausreichende Informationen über den Bearbeitungsstatus zu bekommen.
In solchen Fällen ist es gebräuchlich, im FC einen zusätzlichen Ausgangsparameter für Statusinformationen zu
deklarieren. Den Datentyp wählt man je nach Anforderungen. Der ENO wird als Sammelmeldung benutzt: ‘irgend
etwas ist passiert’, wenn ENO=0.
Im aufrufenden Baustein hat man zunächst nur ENO zu überwachen. Erst wenn ENO=0 ist, wird die
Statusinformation ausgewertet.
S7kurs_2000.doc 07.01.10
Seite 27
7 Datenbaustein (DB)
In diesem Abschnitt werden die Erstellung, Adressierung der Daten und die Einsatzmöglichkeiten von DB’s
behandelt. Das spezielle Umgehen mit Instanz-DB’s wird im Abschnitt 8 zusammen mit Funktionsbausteinen erklärt.
Die Datenstruktur und Länge von DB’s wird vom Anwenderprogramm festgelegt. Die Adressierung in
Datenbausteinen ist auf Bytes bezogen, ebenso wie im Speicher der CPU. Die maximale Länge eines DB und die
Anzahl der Datenbausteine hängt ab von der jeweiligen CPU.
Beispiel:
CPU 312 IFM
Größe eines DB:
Anzahl Datenbausteine:
(kleinste CPU der Reihe S7-300)
max. 6 kByte (6144 Byte)
DB 1 ... DB 63
DB0 ist reserviert für Systemdaten
Grundsätzlich können zwei verschiedene DB-Typen unterschieden werden:
•
Instanz-DB
dient einem FB als „Gedächtnis“ und ist deshalb in seiner Datenstruktur festgelegt. Die Datenstruktur entspricht
der Deklarationstabelle des zugehörigen FB und kann nicht verändert werden.
•
Global-DB (oft auch nur als als ‚Datenbaustein‘ bezeichnet)
Anwender-Speicherbereich, der in seiner Datenstruktur frei vereinbart werden kann
Grundsätzlich kann man auf alle DB’s (auch auf Instanz-DB’s) lesend und schreibend zugreifen durch Anweisungen
in irgendwelchen Codebausteinen (OB, FC, FB).
7.1
Erzeugen eines Datenbausteins
Beim Erstellen eines neuen DB’s wird festgelegt, um welchen Typ es sich handeln soll. Ein neuer DB wird erstellt
vom SIMATIC Manager aus mit:
S7-Programm ⇒ Bausteine ⇒ Einfügen ⇒ S7-Baustein ⇒ Datenbaustein
Nach Eintragen der DB-Nr (zB. „DB2“) und öffnen des Objekts erscheint ein Fenster „Neuer Datenbaustein“. Hier
wird der Typ festgelegt:
Die erste Auswahlmöglichkeit betrifft einen
Datenbaustein, bei dem die Datenstruktur frei
festgelegt weden kann.
Mit der letzten Auswahlmöglichkeit kann ein
sogenannter Instanz-DB erzeugt werden. Bei
diesem liegt die Datenstruktur fest: sie wurde
bereits festgelegt in den Deklarationen des
zugeordneten Funktionsbausteins.
7.2
Festlegen der Datenstruktur
Nachdem ein neuer DB als „Datenbaustein“ definiert wurde (s. vorheriger Abschnitt) erscheint eine
Deklarationstabelle zum Festlegen der Datenstruktur. Eingetragen wird jeweils ein Name, Datentyp, Anfangswert und
Kommentar. Die lokale Adresse vergibt STEP7 automatisch.
Man beachte die unterschiedlichen
Datentypen. In der linken Spalte
„Adresse“ ergibt sich automatisch die
lokale Adresse.
Beispiel für einen DB: (Deklarationssicht)
S7kurs_2000.doc 07.01.10
Seite 28
Sobald die DB-Deklaration abgeschlossen und der DB abgespeichert ist, kann der Datenbaustein in der sogenannten
„Datensicht“ betrachtet werden mit: Ansicht ⇒ Datensicht
In der Spalte ‘Aktualwert’ ist
zu sehen, daß die Daten
bereits auf den Anfangswert
initialisiert wurden.
Derselbe DB in „Datensicht“
Tip: Man sollte für den DB einen symbolischen Namen festlegen (zB. „DB_Name“)! Dann kann man bequem auf die
einzelnen Datensätze zugreifen, z.B.mit „DB_Name“.Messwert[1]), s.a. nächster Abschnitt.
7.3
Adressierung der Daten
Der folgende Abschnitt betrifft den Zugriff auf Daten sowohl in Instanz- als auch in Global-Datenbausteinen.
Die CPU hat für die Adressierung der jeweiligen Datenbausteine 2 Register zur Verfügung, so daß gleichzeitig zwei
DB’s komfortabel adressiert werden können:
DB-Register
DI - Register
speichert die Nummer des (globalen) Datenbaustein
speichert die Nummer des Instanz-Datenbausteins
Grundsätzlich gibt es gibt zwei Möglichkeiten, auf Daten zuzugreifen:
7.3.1 Vollständige Adressierung der Daten in einem Schritt
Diese Adressierungsart ist nur in Zusammenhang mit dem DB-Register verfügbar. Für jeden Datenzugriff wird die
DB-Nummer mit angegeben. Die Methode ist bei etwas höherem Schreibaufwand sicherer in Projekten mit mehreren
Datenbausteinen (Programmierfehler).
Ein besonderer Vorteil besteht darin, daß die Namen der deklarierten Datentypen zur Adressierung direkt verwendet
werden können. Dazu muß allerdings vorher für den DB eine symbolische Bezeichnung definiert werden (SymbolEditor).
Syntax:
bei absoluter Adressierung:
bei symbolischer Adressierung:
DB-Nummer . Adresse
„DB-Name“ . Daten-Name
Beispiele
Absolute Adressierung:
DB1.
DB10.
DB X2.5
DB W0
Symbolische Adressierung:
„Geschwindigkeit“.x_alt
„Motor“.Leistung
S7kurs_2000.doc 07.01.10
Erklärung der Adressbezeichner s. Abschnitt 7.3.2
Geschwindigkeit ist der symb. Name für den DB, z.B. DB10
x_alt ist Daten-Name in der DB-Deklaration von DB10
Motor ist der symbolische Name für den DB,,
Leistung ist Daten-Name in der DB-Deklaration von DB3
Seite 29
7.3.2 Adressierung mit: DB ‘Öffnen’ bzw. DI ‘Öffnen’
Vorteil dieser Adressierung ist die kürzere Schreibweise. Wenn im Projekt nur höchstens 2 Datenbausteine existieren
(ein DB und ein Instanz-DB), ist die Methode auch übersichtlich. Allerdings müssen die einzelnen Daten absolut
adressiert werden! Die Namen der deklarierten Daten können leider nicht verwendet werden.
Den DB ‘öffnen’ ist nichts anderes, als dem DB- oder DI-Register die entsprechende DB-Nummer zuzuweisen. Dann
können die Daten dieses Datenbausteins in kürzerer Schreibweise adressiert werden, nämlich durch Angabe der
Adresse innerhalb des DB.
Die Zuweisung der DB-Nummer zum jeweiligen Register geschieht in AWL durch die Operation „AUF“ (öffnen,
aufschlagen):
AUF DB [DB-Nummer]
bzw.
AUF DI [DB-Nummer]
in FUP/KOP gibt es ein Programmelement ‘Datenbaustein Öffnen’
Beispiel:
FUP:
AWL:
AUF DB 10;
AUF DI 10
Die folgenden Bezeichnungen werden verwendet, um innerhalb eines DB die gewünschten Daten absolut zu
adressieren:
Wichtige Bezeichnungen:
Format
DB X
DB B
DB W
DB D
Datentyp
BOOL
BYTE
WORD
DWORD
Beispiel
DB X2.5
DB B2
DB W2
DB D4
Erklärung
Bit5 im Byte2 ...
Byte 2 ...
Wort 2 (d.h. Byte 2,3) ...
Doppelwort 4 (d.h. Wort 4,6 ...
oder Byte 4,5,6,7)
DI X
DI B
DI W
DI D
BOOL
BYTE
WORD
DWORD
DI X2.5
DI B2
DI W2
DI D4
Bit5 im Byte2 ...
Byte 2 ...
Wort 2 (d.h. Byte 2,3) ...
Doppelwort 4 (d.h. Wort 4,6 ...
oder Byte 4,5,6,7)
in dem
in dem
in dem
in dem
DB, dessen Nummer im
DB-Register steht
DB-Register steht
DB-Register steht
DB-Register steht
in dem
in dem
in dem
in dem
DI-Register steht
DI-Register steht
DI-Register steht
DI-Register steht
Beispiele:
AUF
DB 10
L
DB W0
U
DB X2.3
DB10 öffnen: DB-Nummer → DB-Register
Lade Datenwort 0 von dem Datenbaustein, dessen Nummer im DB-Register steht, in den Akku1
UND-Verknüpfung mit Bit 3 von Byte 2 in dem DB, dessen Nummer im DB-Register steht
AUF
L
DB11 als Instanz-DB öffnen: DB-Nummer → DI-Register
lade Byte 3 von dem Datenbaustein, dessen Nummer im DI-Register steht
7.4
DI 11
DI B3
Weitere Operationen mit Datenbausteinen
Unter AWL sind außerdem die folgenden Operationen bei der Verwendung von Datenbausteinen wichtig:
Weitere wichtige Operationen mit DB’s
Länge des geöffneten DB:
bzw:
L DBLG
L DILG
Lade Länge des DB in Akku1
Lade Länge des Instanz-DB in Akku1
Nummer des geöffneten DB:
bzw:
L DBNO
L DINO
Lade Nummer DB in Akku1
Lade Nummer Instanz-DB in Akku1
DB’s tauschen
TDB
tauscht Inhalt DB-Register mit Inhalt DI-Register
S7kurs_2000.doc 07.01.10
Seite 30
8 Funktionsbaustein (FB)
8.1
Unterschied zur Funktion
Beim Aufruf eines FB muß ein Instanz-DB angegeben werden, der für diese Instanz des FB als Speicher dient.
Wesentlicher Unterschied zu FC’s ist die Möglichkeit, statische Variable zu deklarieren, deren Wert beim Verlassen
des FB erhalten bleiben.
Im Instanz-DB werden neben den statischen Variablen auch die aktuellen Werte der übergebenen Parameter (in, out,
in_out) gespeichert. Ansonsten gelten diesselben Eigenschaften wie bei Funktionen.
8.2
Anwendungsbeispiel: Zeitliche Ableitung eines Meßsignals
Das folgende Beispiel zeigt, wie ein Funktionsbaustein und der Instanz-Datenbaustein zusammenarbeiten. Im FB10
wird der Differenzenquotient ∆x/∆T gebildet, z.B. zur Berechnung der Geschwindigkeit aus einem gemessenen Weg.
Durch erneuten Aufruf des FB10 mit einem anderen Instanz-DB könnte beispielsweise die Beschleunigung berechnet
werden.
Eingangsgröße ist der aktuelle Meßwert x. Der alte Meßwert x_alt wird als statische Variable (Deklarationstyp „stat“)
deklariert. Die Messung soll in gleichen Zeitabständen erfolgen, der Wert von ∆T kann daher als konstanter
Eingangsparameter beim Aufruf des FB10 übergeben werden.
8.2.1 FB Erstellen
FB10:
Deklaration der lokalen Variablen
FB10: Anweisungsteil
S7kurs_2000.doc 07.01.10
Seite 31
8.2.2 FB Aufrufen
Es muß dafür gesorgt werden, daß die
Bearbeitung des FB in gleichen Zeitabständen
erfolgt. Dies kann sehr einfach mit dem OB35,
ein periodischer Zeitinterrupt oder „Weckalarm“,
realisiert werden (s.a. Abschnitt 10.2,
Weckalarm)
Vom Betriebssystem wird dem OB35 beim
Aufruf die Abtastzeit übergeben (lokale Variable
„OB35_EXC_FREQ“). Mit „PEW288“ wird ein
direkter Peripheriezugriff auf eine analoge
Eingangsbaugruppe mit der Adresse 288
veranlaßt.
Beim Aufruf des FB10 (symbolischer Name
„d/dt“) muß der Name des Instanz-DB
angegeben
werden,
hier
DB10
(„GeschwDB“)
OB35: Aufruf des FB10
8.2.3 Instanz-DB
Beim Aufruf des FB wird der Instanz-DB (hier DB10) angegeben. Wenn STEP7 feststellt, daß es ihn noch nicht gibt,
wird er automatisch aus der FB-Deklarationsliste erstellt. Der Datenbausteins kann er in zwei Darstellungs-arten
angezeigt werden:
DB10 in „Deklarationssicht“
DB10 öffnen ⇒ Ansicht ⇒
Deklarationssicht
DB 10 in „Datensicht“
DB10 öffnen ⇒ Ansicht
⇒ Datensicht
In der Datensicht ist zusehen, daß die Daten bereits mit den deklarierten Anfangswert initialisiert sind.
Wenn der FB10 mehrmals im Programm verwendet wird (z.B. Berechnung von Geschwindigkeit und
Beschleunigung), muß für jede Instanz des FB10 ein eigener Instanz-DB angegeben werden.
Auch von anderen Codebausteinen kann lesend und schreibend auf einen Instanz-DB zugegriffen werden!
z.B. um Daten neu zu initialisieren (s.a. Abschnitt 7.3 Adressierung der Daten).
Beispiel:
mit absoluter Adressierung:
mit symbolischer Adressierung:
S7kurs_2000.doc 07.01.10
T DB10.DB W6
T „GeschwDB“.x_alt
Transferiere Inhalt von Akku1 nach: Datenwort 6 von DB10
Transferiere Inhalt von Akku 1 nach: x_alt im
Datenbaustein „GeschwDB“
Seite 32
9 Ereignisgesteuerte Programmbearbeitung
Im Abschnitt 2.2.1 (Organisationsbausteine) wurde bereits gezeigt, daß vom Betriebssystem die verschiedenen OB’s
gestartet werden und zwar in Abhängigkeit von bestimmten Systemereignissen. In diesem Kapitel werden die
Zusammenhänge bei den wichtigsten OB’s genauer beleuchtet. Besondere Aufmerksamkeit verdient dabei die
Frage, wann die Aktualisierung von Daten erfolgt.
9.1
Zyklische Programmbearbeitung (OB1)
Hinweis: Im nachfolgenden Text kommt häufig der CPU-Speicher vor. In diesem Zusammenhang ist die Tabelle im
Abschnitt 2.7 (Anwenderspeicher in der CPU) hilfreich für das Verständnis.
Vor Beginn des OB1 werden die Daten der Eingangsperipherie gelesen und in dem CPU-Speicherbereich PAE
(Prozeßabbild der Eingänge) abgelegt. Für die gesamte Dauer des OB1-Zyklus wird mit diesen Daten gearbeitet,
wenn in Operationen auf ‚Eingänge‘ zugegriffen wird (E,EB, EW, ED) . Erst zu Beginn des nächsten Zyklus wird das
PAE aktualisiert.
Die so „eingefrorenen“ Eingangsdaten haben den
Vorteil, daß das Programm trotz möglicher
Änderungen an der Peripherie während des OB1Zyklus über konsistente, d.h. widerspruchsfreie
Eingangsdaten verfügt.
Nachteilig ist selbstverständlich,
daß
Änderungen
an
der
Eingangsperipherie erst im nächsten Zyklus bemerkt
werden.
Entsprechend den PAE-Daten, Merkern, anderen
Daten und Anweisungen des Programms wird der
OB1 abgearbeitet. Anweisungen im OB1 hinsichtlich
der Ausgänge verändern den CPU-Speicherbereich
PAA (Prozeßabbild der Ausgänge). Sie betreffen
aber
nicht die eigentlichen, an der Peripherie
befindlichen Ausgänge!
Erst am Ende des OB1 wird der Wert des PAA auf
die Ausgänge transferiert.
Beim
Auftreten
von
irgendwelchen
Systemereignissen wird der OB1 entsprechend der
Priorität der zugehörigen OB’s unterbrochen und
nach deren Bearbeitung wieder fortgesetzt.
Falls es spezielle Problemstellungen erfordern, kann auch innerhalb des OB1-Zyklus direkt auf die Peripherie
zugegriffen werden. Dies geschieht durch Lese/Schreibzugriffe auf den CPU-Speicherbereich PE (Peripheriebereich
Eingänge) bzw. PA (Peripheriebereich Ausgänge) .
Beispiel:
L PEB 12
T PAW 2
S7kurs_2000.doc 07.01.10
(lade PEB 12 in Akku1)
(transferiere Inhalt von Akku1 nach PAW2
Seite 33
9.2
Anlaufbearbeitung und Initialisierung (OB100)
Mit dem OB100 (‘Neustart’) kann das Anlaufverhalten der CPU programmiert werden.
Der OB100 unterbricht mit sehr hoher Priorität andere OB’s, bevor der CPU-Betriebszustandswechsel STOP→RUN
passiert und der erste OB1-Zyklus beginnt.
Daher können im OB100 sehr gut Initialisierungs-Routinen programmiert werden. Weil der Baustein zur Laufzeit nur
ein einziges Mal aufgerufen wird, eignet sich der OB100 auch zum Aufruf von einmaligen zeitaufwendigen
Berechungen und für Dokumentationszwecke.
Sicherlich macht es bei der Steuerung einer Anlage durchaus Unterschiede, ob beispielsweise ein Anlauf
STOP→RUN erfolgt, weil eben eingeschaltet wird oder ob plötzlich eine eingebrochene Netzspannung wiederkehrt.
Deshalb wird vom Betriebssystem die Vorgeschichte in lokale Variable des OB100 eingetragen.
9.2.1 Lokale Variable des OB100
Bei der Programmierung des OB100 werden von STEP7 automatisch einige lokale Variable deklariert, die im
Anwenderprogramm verwendet werden können. Die zugehörigen Daten werden beim Aufruf des OB100 vom
Betriebssystem übergeben. Die Informationen betreffen u.a. die Anlaufmethode, Start-Datum und Uhrzeit, Ursache
des letzten Stops, Änderung der Systemkonfiguration.
Die folgende Tabelle der lokalen Variablen ist dem Siemens Handbuch ‘System- und Standardfunktionen,
Referenzhandbuch’ entnommen. Die Variable OB100_STRT_INFO ist dort im Abschnitt 1.17 genauer
aufgeschlüsselt.
9.2.2 Anwendungsbeispiel
Im folgenden Beispiel soll das Programm unterschiedlich reagieren, je nachdem ob der Anlauf manuell oder durch
Spannungswiederkehr erfolgt ist. Dazu werden die Informationen der lokalen Variablen OB100_STRTUP genutzt.
Über die Variable ist bekannt (siehe Tabelle):
Variable
OB100_STRTUP
Typ
BYTE
Deklaration
TEMP
Beschreibung
Anlaufmethode:
16#81
= Manueller Neustart
16#82
= Automatischer Neustart, z.B bei Spannungswiederkehr
Im OB100 wird daher der tatsächliche Wert von OB100_STRTUP abgefragt und die Anlaufmethode ermittelt.
Wichtig: die gefundene Information muß in einer statischen Variable abgelegt werden, damit auch außerhalb vom
OB100 darauf zugegriffen werden kann!
S7kurs_2000.doc 07.01.10
Seite 34
Beschreibung des Beispiel-Programms
Wenn die SPS manuell gestartet wurde, soll während des OB1-Zyklus ständig der Ausgang „Manuell_START“=1
sein, wenn die SPS AG automatisch (durch Netzwiederkehr) gestartet wurde, soll der Ausgang
„Stromversorgung_Start“=1 sein.
Im OB100 wird also die Variable OB100_STRTUP verglichen mit bestimmten Testdaten. Der 16Bit-Vergleicher
verlangt allerdings Variablen oder Zahlen vom Typ Integer, so daß die Variable OB100_STRTUP erst noch von Byte
nach Integer umgewandelt werden muß. Hierfür wird das Programmelement ‘MOVE’ verwendet (in AWL:
Laden...Transferieren). Damit kein statischer Speicher verbraucht wird, wird in der Deklarationstabelle eine
temporäre Variable Temp_Int vom Typ INT eingeführt.
Im OB1-Zyklus kann bei Bedarf auf die Informationen Manuell_Start und Stromversorgung_Start von Anfang an
zugegriffen werden. Die entsprechenden Ausgänge der I/O-Peripherie werden allerdings erst am Ende des ersten
OB1-Zyklus gesetzt.
Symboltabelle:
Symbol
Manuell_Start
Operand
A 4.0
Datentyp
BOOL
Kommentar
A4.0=1, wenn Anlauf manuell war
(Schlüsselschalter oder durch PG)
Symbol
Stromversorrgung_Start
Operand
A 4.1
Datentyp
BOOL
Kommentar
A4.1=1, wenn Anlauf automatisch war
(Netzwiederkehr)
S7kurs_2000.doc 07.01.10
Seite 35
9.3
Weckalarm = Periodischer Zeitinterrupt (OB30..OB38)
Eine periodische Unterbrechung der zyklischen OB1-Bearbeitung ist mit den Organisationsbausteinen OB30 bis
OB38 möglich. Allerdings ist die verfügbare Anzahl der Weckalarm-OB’s abhängig von der jeweiligen CPU, wie die
nachfolgende Tabelle zeigt:
CPU
CPU 312 IFM
CPU 313
CPU 314
CPU 314 IFM
CPU 315
CPU 614
CPU 412-1
CPU 413-1
CPU 414-1
CPU 416-1
------------------------------------OB 30 OB 31
verfügbare Weckalarm-OB's
--------------------OB35
------------OB35
------------OB35
------------OB35
------------OB35
------OB 32
----OB35
------OB 32
----OB35
------OB 32 OB 33 OB 34 OB35
------OB 32 OB 33 OB 34 OB 35 OB 36 OB 37 OB 38
Weckalarm-OB’s Zeittakt in ms Prioritätsklasse
OB 30
5000
7
OB 31
2000
8
OB 32
1000
9
OB 33
500
10
OB 34
200
11
OB 35
100
12
OB 36
50
13
OB 37
20
14
OB 38
10
15
verfügbare Weckalarm-OB’s, voreingestelltes Zeitraster und Priorität
Weckalarme unterbrechen den OB1-Zyklus periodisch, d.h. in gleichen Zeitabständen. Der Zeittakt startet mit dem
CPU-Zustandswechsel STOP→RUN. Das voreingestellte Zeitraster kann bei der Parametrierung der CPU verändert
werden (siehe unten). Weckalarme werden eingesetzt beispielsweise beim Aufruf von Regler-Algorithmen oder von
irgendwelchen anderen Operationen, die periodisch, d.h. in gleichen Zeitabständen durchgeführt werden sollen.
9.3.1 Einstellung des Aufrufintervalls
Die voreingestellten Werte für das Aufrufintervall (Zeit zwischen zwei Aufrufen) und die Priorität des Aufrufs können
bei der Parametrierung der CPU mit dem SIMATIC-Manager verändert werden:
Die betreffende SIMATIC-Station mit rechter Maustaste anklicken, dann ⇒ Objekteigenschaften.
es erscheint das Fenster ‘Hardware-Konfiguration’. Die ausgewählte CPU in der rechten Maustaste anklicken,
⇒ Objekteigenschaften ⇒ Weckalarm
Nun kann das Aufrufintervall eingetragen werden. Es sind ganzzahlige Vielfache von 1 ms möglich:
Zeittakt = n * Grundtakt 1 ms;
Die Zeitdauer zwischen zwei Aufrufen (Aufrufintervall) ist einstellbar von 1ms...1 Minute.
Das Aufrufintervall sollte an das Programm und die Notwendigkeiten angepaßt sein! Es muß mindestens so groß
sein, daß die Anweisungen des Weckalarms auch abgearbeitet werden können. Außerdem ist folgendes zu
berücksichtigen:
Wenn das Aufrufintervall zu klein gewählt wird, kommen OB’s der kleineren Prioritätsklassen wegen der häufigen
Unterbrechungen nicht zügig voran. Dies gilt insbesondere für das zyklische OB1-“Hauptprogramm“: Es droht ein
Programmabbruch wegen Zykluszeitüberschreitung.
9.3.2 Anwendungsbeispiel
Es sei verwiesen auf das Anwendungsbeispiel aus dem Abschnitt 8.2 (Zeitliche Ableitung eines Meßsignals) , in dem
ein Periodischer Zeitinterrupt benutzt wird.
S7kurs_2000.doc 07.01.10
Seite 36
9.4
Prozeßalarm = I/O-Interrupt (OB40)
Prozeßalarm ist ein Systemereignis, das von einer Peripherie-Eingangsbaugruppe ausgelöst wird. Neben der CPUFähigkeit zur Auswertung solcher Prozeßalarme ist allerdings auch eine spezielle Eingangsperipherie notwendig, um
den Interrupt auszulösen. Zu solchen Baugruppen gehören beispielsweise schnelle Zähler und Positioniermodule.
Normale I/O-Baugruppen sind nicht alarmfähig!
Im folgenden Beispiel wird am Beispiel einer CPU 312IFM, die bereits Onboard einige I/O’s, davon 4 Eingänge mit
Alarmfähigkeit besitzt, die wesentlichen Schritte gezeigt.
9.4.1 Alarm-Freischaltung in der CPU
Die CPU muß entsprechend parametriert werden, damit die entsprechenden Interruptanforderungen bearbeitet
werden. Dies geschieht mit dem SIMATIC Manager :
Die betreffende SIMATIC-Station mit rechter Maustaste anklicken, dann ⇒ Objekteigenschaften.
es erscheint das Fenster ‘Hardware-Konfiguration’. Die ausgewählte CPU in der rechten Maustaste anklicken,
⇒ Objekteigenschaften ⇒ Integrierte Funktion
Ausgewählt wird die Integrierte Funktion
‚Alarmeingang‘.
Mit ‚Parametrieren‘ wird das nächste
Fenster gewählt, in dem die Bedingungen
zur Freischaltung eines Prozeßalarms
definiert werden können.
Im diesem Beispiel soll der Alarm dann
auftreten, wenn entweder am Alarmeingang1 eine steigende Flanke oder am
Alarmeingang2 eine fallende Signalflanke
erscheint.
9.4.2 Alarmbearbeitung
Die CPU reagiert auf die Interruptanforderung der peripheren Baugruppe durch Start des OB40. Somit wird man im
OB40 die entsprechenden Anweisungen zur Alarmbearbeitung (Interruptroutine) eintragen.
S7kurs_2000.doc 07.01.10
Seite 37
Literaturangaben
Im Labor für Automatisierungstechnik sind die folgenden Handbücher im Zusammenhang mit STEP7. Sie werden
alle von der Firma Siemens AG herausgegeben:
1.
Elektronische Handbücher 02/2000 auf CD-ROM
enthalten die Gesamtdokumentation zu STEP7 und Softwareerweiterungen, Hardwaredokumentation zu S7,
SIMATIC NET, WinCC, PCS7, WinAC u.a.
(in deutsch, englisch, französisch, spanisch, italienisch)
2.
Dokumentationspaket: „STEP7-Grundwissen V5“ enthält die folgenden Handbücher
Getting Started: Erste Schritte und Übungen mit STEP7 V5.0 (1998)
Handbuch: Programmieren mit STEP7 V5.0 (1998)
Handbuch: Hardware konfigurieren und Verbindungen projektieren mit STEP7 V5.0 (1998)
Umsteigerhandbuch: Von S5 nach S7 (1997)
3.
Dokumentationspaket: „STEP7-Referenzhandbücher V5“ enthält die folgenden Handbücher
Referenzhandbuch: Systemsoftware für S7-300/400, System- und Standardfunktionen (1998)
Referenzhandbuch: Funktionsplan (FUP) für S7-300/400 (1998)
Referenzhandbuch: Kontaktplan (KOP) für S7-300/400 (1998)
Referenzhandbuch: Anweisungsliste (AWL) für S7-300/400 (1998)
4.
Handbuch: SCL für S7-300/400, Bausteine programmieren (1996)
5.
Handbuch: GRAPH für S7-300/400, Ablaufsteuerungen programmieren (1997)
6.
Handbuch: Automatisierungssystem S7-300, Integrierte Funktionen der CPU 312 IFM/ 314 IFM (1996)
7.
Handbuch: Automatisierungssystem S7-300, Aufbauen einer S7-300 (1995)
8.
Handbuch: Kommunikation mit SIMATIC (1997)
9.
Tabellenheft: Operationsliste (AWL) für S7-300, CPU312IFM, CPU313, CPU314
S7kurs_2000.doc 07.01.10
Seite 38

Programmieren mit STEP7

Transcrição

Documentos relacionados

Technische Beschreibung CB-Funkanlage AE

Karten personalisieren – Welche Technik steckt dahinter

XNotar-Datenschutzerklärung

Technische Beschreibung CB-Funkanlage AE 4900 FM (Europa

Freezer 64 Pro: Installationsanleitung / Installation Instructions

Noctua NH-L9i (DE)

VR-Bank Hunsrück-Mosel eG 54497 Morbach

PC Preisliste - Cyberworld Multimedia

pdf-Datei zum - Engels Elektrotechnik GmbH

6. Übung „Nebenläufige und verteilte Programmierung“