Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und...

38
Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 1 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 Marketing- strategien 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 Spracher- weiterungen, 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.

Transcript of Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und...

Page 1: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 1

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 Marketing-strategien 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 Spracher-weiterungen, 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.

Page 2: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 2

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

Page 3: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 3

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

Page 4: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 4

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

Page 5: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 5

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 S7-Stationen zur Programmierung und für Online Testfunktionen. Für wenige Teilnehmer mit geringen Datenmengen kann aber auch eine Kommunikation zwischen den S7-Stationen ermöglicht werden. Dies geschieht durch Projektierung von sogenannten Globaldaten, die inner-halb bestimmter Kommunikationskreise von den beteiligten CPU’s verschickt und empfangen werden. Mit den S7-Stationen 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.

Page 6: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 6

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 Transporteinrich-tungen, 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.

Page 7: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 7

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 Zyklus am Zyklusende und nach dem Anlauf (Ende von OB100)OB10 Uhrzeitalarm definierte Uhrzeit oder Datum OB35 Weckalarm "Zeit-Interrupt" periodisch jeweils nach einer definierten ZeitOB40 Prozessalarm "I/O-Interrupt" bei bestimmten Signalen der I/O-PeripherieOB80 Zykluszeitfehler OB1-Zyklus überschreitet eine definierte ZeitOB100 Anlauf beim Anlauf der SPS, d.h. bei Stop=>Run

höchste OB122 Baugruppenfehler wenn beim Baugruppenzugriff ein Fehler erkannt wird

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.

Page 8: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 8

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.

Programmablauf am Beispiel der Abfüllanlage

Page 9: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 9

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

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.

TypAnzahl

Bit Beschreibung Wertebereich

BOOL 1 Bit TRUE, FALSE BYTE 8 Byte 0 ... 255 WORD 16 Wort 0 ... 65535 (216-1) DWORD 32 Doppelwort 0 ... 232-1 CHAR 8 Zeichen druckbare Zeichen (ASCII-Code) INT 16 Ganzzahl 16 Bit -32768 ... +32767 (-215... +215-1) DINT 32 Ganzzahl 32 Bit -231 ... + 231-1 (ca. -2,1Mia...2,1Mia) REAL 32 IEEE Gleitpunktzahl -3,4E38 ... 3,4E38

TIME 32 IEC-Zeit in Intervallen von 1 ms -231 + 231-1 ms (ca. -24..24 Tage) DATE 16 IEC-Datum in Intervallen von 1 Tag 216-1 Tage ab 1990-1-1 TOD 32 Time Of Day. Uhrzeit in Intervallen v. 1ms Stunden(0..23) : Minuten(0..59) : Sekund.(0..59) : ms(0..999) S5TIME 16 Voreingestellte Zeitwerte: 0H_0M_0S_0MS ... 2H_46M_30S_0MS

Page 10: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 10

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.

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.

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“ (in Anführungszeichen „...“ !) oder nach wie vor mit M3.5

Page 11: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 11

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 in Eingangsparameter lesen FB, FC out Ausgangsparameter schreiben FB, FC in_out Ein- Ausgangsparameter lesen, schreiben FB, FC temp temporäre Variable, die im Lokaldaten-Stack gespeichert wird. Der Wert der lesen, schreiben FB, FC, OB Variablen ist ist nach der Bearbeitung des Bausteins (das bedeuted auch: im im nächsten Zyklus!) nicht mehr verfügbar. stat statische Variable, wird im Instanz-Datenbaustein gespeichert lesen, schreiben FB • 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.

Page 12: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 12

Beispiel für Parameterübergabe:

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] // Kommentarzeile, zweidimensionales Array Datentyp

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 STRUCT // Kommentarzeile zur Struktur Data1 Datentyp1 Data2 Datentyp2 ... ... Data i Datentyp i END_STRUCT Beispiel:

2.6.5.3 STRING Eine Zeichenkette (STRING) ist ein eindimensionales Feld aus CHAR-Datentypen. Die Feldgrösse ist maximal 254 Zeichen.

x

sin (x)

yMW2 MW4

Page 13: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 13

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.

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).

SpeicherbereichZugriff über Einheiten der

folgenden GrößeS7-

NotationBeschreibung Verfügbar bei CPU 312 IFM

PAE Eingang (Bit) E PAE ist ein Speicherbereich, der vom Betriebs- E0.0...31.7, E124.0...127.7Prozeßabbild EingangsByte EB system jeweils vor Beginn des OB1-Zyklus mit 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) A 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

AusgangsDoppelwort AD werden. AD0...28, AD124Merker Merker (Bit) M Anwender - Speicherbereich M0.0...M127.7

MerkerByte MB MB0... MB127MerkerWort MW MW0...MW126MerkerDoppelwort MD MD0... MD124

Zeiten Zeiten T Speicherbereich, in den vom Betriebssystem Z0... Z31Zeitwerte geschrieben werden

Zähler Zähler Z Speicherbereich für Zähler T0 ... T63

Datenbausteine,adressiert mit

Datenbaustein, geöffnet mitOperation "AUF DB"

DBDatenbausteine werden im Anwenderprogrammerstellt in Größe und Datenstruktur. Sie können

DB 1... DB 63

DB-Register DatenBit DBX entweder so definiert sein, daß alle Codebau- DBX 0.0 ... DBX 6143.7DatenByte DBB steine auf sie zugreifen können (Globale DB) DBB 0 ... DBB 6143DatenWort DBW oder sie sind einem bestimmten FB oder SFB DBW 0... DBW 6142DatenDoppelwort DBD zugeordnet (Instanz-DB). DBD 0 ... DBD 6140

Datenbausteine,adressiert mit

Datenbaustein, geöffnet mitOperation "AUF DI"

DIDurch zwei Register der CPU (DB-, DI-Register)können gleichzeitig zwei Datenbausteine

DI 0 ... DI 63

DI-Register DatenBit DIX adressiert werden. DIX 0.0 ... DIX 6143.7DatenByte DIB DIB 0 ... DIB 6143DatenWort DIW DIW 0 ... DIW 6142DatenDoppelwort DID DID 0 ... DID 6140

Lokaldaten LokaldatenBit L Speicherbereich für temporäre Daten eines L 0.0 ... L 255.7"Lokaldaten-Stack" LokaldatenByte LB Codebausteins. Der Aufbau des jeweiligen LB 0 ... LB 255

oder "L-Stack" LokaldatenWort LW Lokaldaten-Stacks ergibt sich aus der LW 0 ... LW 254LokaldatenDoppelwort LD zugehörigen Deklarationstabelle LD 0 ... LD 252

Peripheriebereich PeripherieEingangsByte PEB Speicherbereich, der direkt mit den Daten der PEB0..31, PEB124..127, PEB256..383Eingänge PeripherieEingangsWort PEW Ein-/Ausgabebaugruppen in Verbindung steht. PEW0..30, PEW124..126, PEW256..382

PeripherieEing.Doppelwort PED Durch Zugriff auf Daten des Peripheriebereichs PED0..28, PED124, PED256..380Peripheriebereich PeripherieAusgangsByte PAB können die Ein/Ausgabebaugruppen unabhängig PAB0..31, PAB124..127, PAB256..383

Ausgänge PeripherieAusgangsWort PAW vom OB1-Zyklus erreicht werden. PAW0..30, PW124..126, PAW256..382PeripherieAusgDoppelwort PAD PAD0..28, PAD124, PAD256..380

Page 14: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 14

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 U „Sensor1“ UND-Operation mit dem Eingangsbit E2.3 L EB1 L „Eingänge“ 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: p# Bereichskennung Anfangs-Byte.Bit Datentyp Wiederholfaktor Beispiele: p# M 50.0 Byte 10 // 10 Bytes im Speicherbereich Merker MB 50... MB 59 p# A 10.0 BOOl 4 // 4 Bit im Speicherbereich Ausgänge A 10.0.... A 10.3 p# DB 10. DBX5.0 S5TIME 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: M10.0 =1; M 10.1 =1; ... M 10.7 =0; ... usw ... M13.0 =1; M13.1 =0; ... M13.7 =0 BYTE: MB 10 = 17 Hex; MB 11 = 07 Hex; MB 12 = F0 Hex; MB 13 = 41 Hex WORD: MW 10 = 1707 Hex MW 11 = 07F0 Hex MW12 = F041 Hex DWORD: MD 10 = 1707F041 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!

Page 15: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 15

Vorsicht Programmierfehler! Die oben beschriebene Mehrfachnutzung von Speicherplatz für unterschiedliche Datentypen führt bei STEP7- Einsteigern 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 festgelegter Adreßraum Reihenfolge der Vergabe ... bis Merker-Bits: MB10 ... MB19 M10.0 M10.1 M10.2 ... M19.7 Merker-Bytes: MB20 ... MB39 MB20 MB21 MB22 ... MB39 Merker-Worte: MB40 ... MB59 MW40 MW42 MW44 ... MW58 Merker-Doppelworte MB60 ... MB99 MD60 MD64 MD68 ... MD96

2.9 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 Datentyp Beschreibung Beispiel (e) 2# WORD Binäre Schreibweise 2#0001_0000_0000_1101 DWORD Binäre Schreibweise 2#1000_1111_0101_1101_0010_0000_0000_1101 True/False BOOL TRUE oder FALSE TRUE, FALSE B#(...) WORD Wert der einzelnen Bytes dezimal B#(10,255) DWORD Wert der einzelnen Bytes dezimal B#(100,114,2,10) B#16# BYTE Byte hexadezimal B#16#4F W#16# WORD Wort hexadezimal W#16#FF1B DW#16# DWORD Doppelwort hexadezimal DW#16#09A2_FF13 Ganzzahl INT IEC-Ganzzahlformat mit Vorzeichen in Bit 15 -2270 32767 L# DINT 32Bit Ganzzahlformat, Vorzeichen in Bit 31 L#44520 L#-49245 Gleitpunktzahl REAL IEC-Gleitpunktzahlenformat 3.14 1.234567e+13 C# WORD 16Bit Zählerkonstante 0...999 C#500 T# TIME T#TageD_StundH_MinutM_SekundS_MillisekMS T#0D_1H_10M_22S_100MS D# DATE D#Jahr-Monat-Tag D#1997-3-15 TOD# TOD TOD#Stunden:Minuten:Sekunden:Millisekunden TOD#13:24:33:555 S5T# S5TIME S5T#TageD_StundH_MinutM_SekundS_MillisekMS S5T#12M_22S_100MS

Page 16: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 16

3 Beispiele in FUP/KOP und AWL

3.1 Logische Verknüpfung Die folgenden kleinen Programm-beispiele sind zum Vergleich jeweils in den 3 Sprachen dargestellt. FUP und KOP sind im Sprachumfang gleich. Insbesondere bei den etwas kom-plexeren 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 domi-nandem Rücksetzeingang. Flankenerkennungen benötigen einen freien binären Operanden zum Speichern des früheren Signal-zustands, hier M1.0. Gezeigt ist die Verwendung der Operation „P“ zur Erkennung einer positiven, d.h. ansteigenden Flanke.

3.3 Timer Der Zeitwert ist vom Datentyp S5Time! Neben dem verwendeten Impuls-timer gibt es noch Timer für Einschaltverzögerung, Ausschalt-verzögerung und speichernde Einschaltverzögerung.

Page 17: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 17

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 dargestellten Rückwärtszähler gibt es auch Vorwärts- und Vorwärts/Rück-wärtszähler.

3.5 Arithmetische Operation Addition zweier Integerzahlen.

3.6 Bausteinaufruf Gezeigt ist der bedingte Baustein-aufruf: FC2 wird nur dann bearbeitet, wenn die Variable „E3“ den Wert TRUE hat. Außerdem gibt es noch einen absoluten Bausteinaufruf (Bearbei-tung immer, ohne Bedingung). Unter FUP darf der Eingang EN dann einfach unbeschaltet bleiben (s.a. Abschnitt 3.5)

Page 18: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 18

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 Hardware- oder 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 ⇒ Betriebszustand ⇒ CPU auf „STOP“ Und dann: ⇒ Zielsystem ⇒ Urlöschen

4.4 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.

Page 19: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 19

• 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

Page 20: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 20

Statt „Öffnen“ können Sie hier entsprechend ein Projekt schließen, löschen, archivieren etc. Nutzen Sie die Online-Hilfe, 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äger-Symbol. 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 Hardware-Katalogs! Wie unter Windows üblich, können Sie Unter-Objekte öffnen durch anklicken des Symbols:

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 1: reserviert für die Stromversorgung PS (Power Supply) Steckplatz 2: reserviert für die CPU. Steckplatz 3: bleibt frei Steckplätze 4..11: Signalbaugruppen digital/analog 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 Laufzeit-Fehlern 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“.

Page 21: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 21

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 S7-Programm 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 E0.0 *) BOOL Zählerstand automatisch inkrementiert, wenn Zählen=1 Reset E0.1 *) BOOL Zählerstand auf 0 gesetzt, wenn Reset=1 Zeit1 MW0 WORD Zeitablauf Timer 1 Zeit2 MW2 WORD Zeitablauf Timer 2 Zähl_Dual AW4 *) WORD Zählerstand als Dualwert Zähl_BCD MW4 WORD Zählerstand als BCD-Wert Zähl_Q M1.1 BOOL 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: FUP Symbolische Darstellung: Ein Symbolinformation: Ein Baustein-Kommentare unterstützen: Ein Vergrößern, Verkleinern, Zoomfaktor 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!

Page 22: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 22

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 ⇒ S-Impuls (SIMATIC Timer, Impuls) ⇒ Bitverknüpfung ⇒ Negationspunkt (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 ⇒ Z_VORW (Vorwärtszähler) ⇒ Bitverknüpfung ⇒ -[=] (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 hinter „OB1“ Baustein-Kommentar unter der Bausteinüberschrift Netzwerk-Überschrift hinter „Netzwerk 1“ Netzwerk-Kommentar 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 ! Den Baustein abspeichern mit Datei → Speichern

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

Page 23: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 23

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 ⇒ Erreichbare Teilnehmer ⇒ MPI-Stationsadresse markieren (hier: MPI=2), dann ⇒ 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.

Page 24: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 24

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 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.

Operand Symbol Status-Format E0.0 Zählen Bin E0.1 Reset Bin MW0 Zeit1 Dez MW2 Zeit2 Dez AW4 Zähl_Dual Dez MW4 Zähl_Dez Dez M1.1 Zähl_Q Bin

Ende Ihrer Ersten Sitzung am Programmiergerät

Page 25: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 25

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 hintereinander-geschalteten 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 neben-stehende Beschreibung von MUL_DI zeigt.

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 entspricht dem Wert von BIE vor der Bearbeitung, ENO 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: BIE = 1 (ENO = 1) Fehler aufgetreten: BIE = 0 (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.

aus der Online-Hilfe zu MUL_DI

Page 26: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 26

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

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.

U M1.0 SAVE

Page 27: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 27

Anweisungsteil desselben Netzwerks in AWL: Folgende AWL-Operationen sind im Zusammenhang mit dem Binärergebnis-Flag BIE besonders interessant:

Operation Beschreibung SAVE Wert von VKE → BIE CLR setzt VKE → 0 SET setzt VKE → 1 NOT negiert das VKE

6.3 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.

Page 28: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 28

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 (kleinste CPU der Reihe S7-300) Größe eines DB: max. 6 kByte (6144 Byte) Anzahl Datenbausteine: 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)

Page 29: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 29

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 speichert die Nummer des (globalen) Datenbaustein DI - Register 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 (Symbol-Editor). Syntax: bei absoluter Adressierung: DB-Nummer . Adresse bei symbolischer Adressierung: „DB-Name“ . Daten-Name Beispiele Absolute Adressierung: DB1. DB X2.5 Erklärung der Adressbezeichner s. Abschnitt 7.3.2 DB10. DB W0 Symbolische Adressierung: „Geschwindigkeit“.x_alt Geschwindigkeit ist der symb. Name für den DB, z.B. DB10 x_alt ist Daten-Name in der DB-Deklaration von DB10 „Motor“.Leistung Motor ist der symbolische Name für den DB,, Leistung ist Daten-Name in der DB-Deklaration von DB3

Page 30: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 30

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 Datentyp Beispiel Erklärung DB X BOOL DB X2.5 Bit5 im Byte2 ... in dem DB, dessen Nummer im DB-Register steht DB B BYTE DB B2 Byte 2 ... in dem DB, dessen Nummer im DB-Register steht DB W WORD DB W2 Wort 2 (d.h. Byte 2,3) ... in dem DB, dessen Nummer im DB-Register steht DB D DWORD DB D4 Doppelwort 4 (d.h. Wort 4,6 ... in dem DB, dessen Nummer im DB-Register steht oder Byte 4,5,6,7) DI X BOOL DI X2.5 Bit5 im Byte2 ... in dem DB, dessen Nummer im DI-Register steht DI B BYTE DI B2 Byte 2 ... in dem DB, dessen Nummer im DI-Register steht DI W WORD DI W2 Wort 2 (d.h. Byte 2,3) ... in dem DB, dessen Nummer im DI-Register steht DI D DWORD DI D4 Doppelwort 4 (d.h. Wort 4,6 ... in dem DB, dessen Nummer im DI-Register steht oder Byte 4,5,6,7) Beispiele: AUF DB 10 DB10 öffnen: DB-Nummer → DB-Register L DB W0 Lade Datenwort 0 von dem Datenbaustein, dessen Nummer im DB-Register steht, in den Akku1 U DB X2.3 UND-Verknüpfung mit Bit 3 von Byte 2 in dem DB, dessen Nummer im DB-Register steht AUF DI 11 DB11 als Instanz-DB öffnen: DB-Nummer → DI-Register L DI B3 lade Byte 3 von dem Datenbaustein, dessen Nummer im DI-Register steht

7.4 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: L DBLG Lade Länge des DB in Akku1 bzw: L DILG Lade Länge des Instanz-DB in Akku1 Nummer des geöffneten DB: L DBNO Lade Nummer DB in Akku1 bzw: L DINO Lade Nummer Instanz-DB in Akku1 DB’s tauschen TDB tauscht Inhalt DB-Register mit Inhalt DI-Register

Page 31: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 31

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

Page 32: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 32

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“)

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: T DB10.DB W6 Transferiere Inhalt von Akku1 nach: Datenwort 6 von DB10 mit symbolischer Adressierung: T „GeschwDB“.x_alt Transferiere Inhalt von Akku 1 nach: x_alt im Datenbaustein „GeschwDB“

OB35: Aufruf des FB10

Page 33: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 33

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 OB1-Zyklus über konsistente, d.h. widerspruchsfreie Eingangsdaten verfügt. Nachteilig ist selbst-verstä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 (lade PEB 12 in Akku1) T PAW 2 (transferiere Inhalt von Akku1 nach PAW2

Page 34: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 34

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 Typ Deklaration Beschreibung OB100_STRTUP BYTE TEMP 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!

Page 35: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 35

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 Operand Datentyp Kommentar Manuell_Start A 4.0 BOOL A4.0=1, wenn Anlauf manuell war (Schlüsselschalter oder durch PG) Symbol Operand Datentyp Kommentar Stromversorrgung_Start A 4.1 BOOL A4.1=1, wenn Anlauf automatisch war (Netzwiederkehr)

Page 36: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 36

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:

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.

CPU verfügbare Weckalarm-OB'sCPU 312 IFM --- --- --- --- --- --- --- --- ---

CPU 313 --- --- --- --- --- OB35 --- --- ---CPU 314 --- --- --- --- --- OB35 --- --- ---

CPU 314 IFM --- --- --- --- --- OB35 --- --- ---CPU 315 --- --- --- --- --- OB35 --- --- ---CPU 614 --- --- --- --- --- OB35 --- --- ---

CPU 412-1 --- --- OB 32 --- --- OB35 --- --- ---CPU 413-1 --- --- OB 32 --- --- OB35 --- --- ---CPU 414-1 --- --- OB 32 OB 33 OB 34 OB35 --- --- ---CPU 416-1 OB 30 OB 31 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 7OB 31 2000 8OB 32 1000 9OB 33 500 10OB 34 200 11OB 35 100 12OB 36 50 13OB 37 20 14OB 38 10 15

verfügbare Weckalarm-OB’s, voreingestelltes Zeitraster und Priorität

Page 37: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 37

9.4 Prozeßalarm = I/O-Interrupt (OB40) Prozeßalarm ist ein Systemereignis, das von einer Peripherie-Eingangsbaugruppe ausgelöst wird. Neben der CPU-Fä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 Alarm-eingang1 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.

Page 38: Programmieren mit STEP7 - elektro-kompendium.dedie2e.square7.ch/Programmieren mit S7.pdf · und S7-400, das sind Steuerungen mit mittlerer und hoher Leistungsfähigkeit. Daneben ist

Dipl.Ing. Norbert Heinlein FH Frankfurt, Labor für Automatisierungstechnik

S7kurs_2000.doc 07.01.10 Programmieren mit STEP 7 Seite 38

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