Simatic S7 von Siemens - Portal Automatisierungstechnik der tsm

Dipl.Ing. Norbert Heinlein 

FH Frankfurt, Labor für Automatisierungstechnik 

Programmieren mit STEP7 

Einführung 

Dieses Skript wendet sich an STEP7-Einsteiger, die bereits Grundkenntnisse in Zusammenhang mit 

Speicherprogrammierbaren Steuerungen (SPS) haben. Es soll die Einarbeitung in STEP7 erleichtern und den 

Überblick fördern. Deshalb sind hier Informationen in kompakter Form zusammengestellt, die in der ausführlichen 

Hersteller-Dokumentation auf einige Handbücher verteilt sind. 

Wegen der zunehmenden Verbreitung der Norm IEC 61131-3 für die Programmierung von Steuerungen habe ich 

versucht, die teils historisch gewachsenen Begriffe von STEP7 auch vom Standpunkt des IEC-Programmierers aus 

darzustellen. Falls STEP7 von der Norm abweichende Begriffe verwendet, benutze ich die aktuellen STEP7- 

Bezeichnungen (z.B. FUP statt Funktionsbausteinsprache FBS). 

STEP7 ? 

Mit der Programmierumgebung STEP7 werden SIMATIC S7 - Steuerungen der Firma Siemens konfiguriert und 

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. Außerdem arbeitet 

STEP7 mit größeren Softwarepaketen für Visualisierung, SCADA und Prozessleittechnik zusammen. 

Hinweis: Kleinsteuerungen der Familie S7-200 werden nicht mit STEP7, sondern mit dem Produkt (STEP7-Micro) 

programmiert. 

Im Labor arbeiten wir dem Softwarepaket „STEP7 Professional V. 5.3 (Edition 

2004)“. Unter der Verwaltung von einem „SIMATIC Manager“ sind darin u.a. 

folgende Grundfunktionalitäten enthalten: 

• Konfiguration von Hardware, Systemeigenschaften und Kommunikationsbeziehungen 

der S7-Stationen, die in einem Projekt verwaltet werden 

• Programmiersprachen: FUP (Funktionsplan), KOP (Kontaktplan) und AWL 

(Anweisungsliste) 

• Programmiersprache: S7-SCL, entspricht der Sprache ST (Strukturierter Text) 

nach IEC 61131-3 

• Programmiersprache: S7-Graph, entspricht der Sprache AS (Ablaufsprache) 

nach IEC 61131-3 

• S7-PLCSIM, eine Simulation der konfigurierten S7-Station für Programmtests 

• Werkzeuge für Laden von Programmen in die Zielsysteme und für Online Tests 

• Werkzeuge zur Online-Diagnose von Baugruppen 

Konform zur Norm 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 zur 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. Für IEC-Programmierer sind die folgenden 

Sprachen besonders interessant, die aber in diesem Skript nicht weiter behandelt werden: 

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 

Entspricht der Sprache AS (Ablaufsprache) nach IEC 61131-3, mit deren Hilfe Ablaufsteuerungen programmiert 

werden können. Die Konformität mit AS nach IEC 61131-3 ist nachgewiesen durch ein Base-Level Zertifikat der PLC- 

Open Organisation. 

S7kurs_2004.doc 27.10.05 Programmieren mit STEP 7 Seite 1



Inhalt 

1 PROGRAMMIERUMGEBUNG.............................................................................................................. 4 

1.1 Programmiergerät..................................................................................................................................................................4 

1.2 MPI-Bus ................................................................................................................................................................................4 

1.3 STEP7 Projekt.......................................................................................................................................................................4 

2 GRUNDWISSEN FÜR DAS PROGRAMMIEREN MIT STEP7............................................................. 5 

2.1 Programme in Teilaufgaben strukturieren .............................................................................................................................5 

2.2 Programmbausteine: OB, FC, DB, FB, SFC, SFB ...............................................................................................................6 

2.2.1 Organisationsbausteine (OB‘s) ................................................................................................................................................................ 6 

2.2.2 Funktion (Function, FC) .......................................................................................................................................................................... 7 

2.2.3 Datenbaustein (Data Block, DB) ............................................................................................................................................................. 7 

2.2.4 Funktionsbaustein (Function Block, FB)................................................................................................................................................. 7 

2.2.5 Systemfunktion (SFC) und Systemfunktionsbaustein (SFB).................................................................................................................. 7 

2.3 Anwendungsbeispiel: Abfüllanlage.......................................................................................................................................7 

2.4 S7-Bibliotheken.....................................................................................................................................................................8 

2.5 Netzwerke .............................................................................................................................................................................8 

2.6 Datentypen ............................................................................................................................................................................9 

2.6.1 Elementare Datentypen............................................................................................................................................................................ 9 

2.6.2 Zusammengesetzte Datentypen ............................................................................................................................................................. 10 

2.6.3 Parametertypen....................................................................................................................................................................................... 11 

2.6.4 Anwenderdefinierter Datentyp (UDT) .................................................................................................................................................. 11 

2.7 Variable...............................................................................................................................................................................12 

2.7.1 Globale Variable .................................................................................................................................................................................... 12 

2.7.2 Lokale Variable...................................................................................................................................................................................... 14 

2.7.3 Anwendungsbeispiel: Wie verwende ich innerhalb einer Funktion einen Timer? ............................................................................... 16 

2.8 Systemspeicher in der CPU.................................................................................................................................................17 

2.8.1 Remanenz............................................................................................................................................................................................... 18 

2.9 Adressierung........................................................................................................................................................................18 

2.9.1 Direkte Adressierung ............................................................................................................................................................................. 18 

2.9.2 Indirekte Adressierung........................................................................................................................................................................... 19 

2.9.3 Adressierung mit Pointer ....................................................................................................................................................................... 19 

2.9.4 Adresszusammenhang Bit, Byte, Wort, Doppelwort .......................................................................................................................... 20 

3 BEISPIELE IN FUP/KOP UND AWL................................................................................................... 21 

3.1 Logische Verknüpfung ........................................................................................................................................................21 

3.2 Flip Flop und Flankenerkennung.........................................................................................................................................21 

3.3 Timer...................................................................................................................................................................................21 

3.4 Zähler ..................................................................................................................................................................................22 

3.5 Arithmetische Operation .....................................................................................................................................................22 

3.6 Bausteinaufruf .....................................................................................................................................................................22 

3.7 MOVE (Laden und Transferieren) ......................................................................................................................................23 

4 HANDHABUNG DER CPU.................................................................................................................. 23 

4.1 Betriebszustände und Übergänge ........................................................................................................................................23 

4.2 Laden des Anwenderprogramms .........................................................................................................................................23 

4.3 Urlöschen der CPU..............................................................................................................................................................24 

4.4 Verhalten der CPU bei Netzausfall......................................................................................................................................24 

5 FUNKTION (FC) .................................................................................................................................. 25 

5.1 Die Operanden EN (Enable) und ENO (Enable Out) .........................................................................................................25 

5.2 Erstellen einer Funktion ......................................................................................................................................................26 

5.2.1 Deklarationsteil ...................................................................................................................................................................................... 26 

5.2.2 Anweisungsteil in FUP und AWL......................................................................................................................................................... 26 

5.3 Aufrufen der Funktion.........................................................................................................................................................27 

5.4 Fehlerbehandlung und Statusmeldungen.............................................................................................................................27 

6 DATENBAUSTEIN (DB)...................................................................................................................... 28 




6.1 Erzeugen eines Datenbausteins ...........................................................................................................................................28 

6.2 Festlegen der Datenstruktur.................................................................................................................................................28 

6.3 Adressierung der Daten .......................................................................................................................................................29 

6.3.1 Vollständige Adressierung der Daten in einem Schritt ......................................................................................................................... 29 

6.3.2 Adressierung mit: DB ‘Öffnen’ bzw. DI ‘Öffnen’........................................................................................................................... 30 

6.4 Weitere Operationen mit Datenbausteinen..........................................................................................................................30 

7 FUNKTIONSBAUSTEIN (FB) ............................................................................................................. 31 

7.1 Unterschied zur Funktion ....................................................................................................................................................31 

7.2 Anwendungsbeispiel: Zeitliche Ableitung eines Meßsignals ..............................................................................................31 

7.2.1 FB Erstellen............................................................................................................................................................................................ 31 

7.2.2 FB Aufrufen ........................................................................................................................................................................................... 32 

7.2.3 Instanz-DB ............................................................................................................................................................................................. 32 

8 EREIGNISGESTEUERTE PROGRAMMBEARBEITUNG.................................................................. 33 

8.1 Zyklische Programmbearbeitung (OB1)..............................................................................................................................33 

8.2 Anlaufbearbeitung und Initialisierung (OB100)..................................................................................................................34 

8.2.1 Lokale Variable des OB100................................................................................................................................................................... 34 

8.2.2 Anwendungsbeispiel .............................................................................................................................................................................. 34 

8.3 Weckalarm = Periodischer Zeitinterrupt (OB30..OB38) .....................................................................................................36 

8.3.1 Einstellung des Aufrufintervalls ............................................................................................................................................................ 36 

8.3.2 Anwendungsbeispiel .............................................................................................................................................................................. 36 

8.4 Prozeßalarm = I/O-Interrupt (OB40)...................................................................................................................................37 

8.4.1 Alarm-Freischaltung in der CPU ........................................................................................................................................................... 37 

8.4.2 Alarmbearbeitung................................................................................................................................................................................... 37 

Anhang: 

Literaturverzeichnis 




1 Programmierumgebung 

1.1 Programmiergerät 

Als Programmiergeräte (PG) werden meist PCs mit eingebauter MPI-Steckkarte oder spezielle Notebooks 

verwendet. Betriebssystem ist Windows 2000 Professional oder Windows XP Professional. 

1.2 MPI-Bus 

Jede S7-Station hat in der CPU 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 und MPI-1 reserviert 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. In 

festgelegten Kommunikationskreisen werden die 

Globaldaten von den beteiligten CPU’s verschickt 

und empfangen. Mit den S7-Stationen können 

über MPI auch Operator Panels (OP) 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_Pro1 belegt ein eigenes Verzeichnis. Die Station selbst besteht aus Angaben zum 

Hardwareaufbau (sog. „Stationskonfiguration“) und aus Systemeinstellungen für die CPU, hier eine CPU312IFM. 

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 man ohne 

Compilierung in die CPU laden kann. 




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 viele Informationen abgelegt: Hardwareaufbau, Kommunikationsbeziehungen, Symbolische 

Bezeichnungen von Variablen, Hilfen für Test und Inbetriebnahme, Voreinstellung der Programmierumgebung, 

Dokumentation und -last not least- die eigentlichen Programmanweisungen unter FUP, KOP, AWL oder weiteren 

Hochsprachen. 

2 Grundwissen für das Programmieren mit STEP7 

2.1 Programme in Teilaufgaben strukturieren 

STEP7-Programme bestehen im allgemeinen aus mehreren oder vielen Programmbausteinen. In jedem Baustein 

wird dabei eine Teilaufgabe des Gesamtprogramms bearbeitet. Zur Vorbereitung der Programmierung wird zunächst 

die Funktion der zu steuernden Anlage untersucht. Aus der Aufspaltung in Teilfunktionen entsteht schließlich die 

Programmstruktur. 

Am Beispiel einer Abfüllanlage soll dieser 

Entwurfsvorgang gezeigt werden: 

Die Anlage könnte beispielsweise grob 

unterteilt werden in Transporteinrichtungen, 

die Füllung der Behälter und 

irgendwelche Bedieneinrichtungen mit 

Schaltern und Anzeigen. 

Eine genauere Betrachtung der Füllung 

könnte beispielsweise ergeben, daß nach 

mehreren Reinigungsvorgängen und 

dem Füllvorgang noch eine Etikettierung 

der Behälter erfolgen soll. 

Auf diese Weise erhält man eine 

funktionale Gliederung der Anlage in 

beliebig feiner Struktur. 

Die Programmbausteine entsprechen 

den so festgelegten Teilaufgaben. 

Der Baustein „Füllung“ beispielsweise 

veranlaßt später die Bearbeitung der 

Bausteine für die Reinigungen, Kontrolle, 

Füllung und Etikettierung. 




2.2 Programmbausteine: OB, FC, DB, FB, SFC, SFB 

Das Bausteinkonzept von STEP7 unterscheidet sich von den Festlegungen der Norm IEC 1131-3. Es ist für das 

Verständnis von STEP7 von zentraler Bedeutung! 

Eine Besonderheit sind die Systembausteine SFC und SFB. Sie sind bereits in der jeweiligen CPU vorhanden. Alle 

anderen erforderlichen Bausteine werden vom Programmierer erstellt oder in das S7-Programm importiert. 

Hinsichtlich des Inhalts können Bausteine unterschieden werden in 

• Codebausteine 

Diese enthalten Programmanweisungen (Code). Alle OB, FC, FB, SFC, SFB sind Codebausteine. 

• Datenbausteine (DB’s) 

enthalten Speicherplatz für Daten. Der Programmierer legt die Größe und Datenstruktur von DB’s fest. Auf die 

Daten kann man durch Anweisungen in Codebausteinen zugreifen. DB’s werden für die Speicherung von 

statischen Variablen (Messwerte, Rezepturen, Regelparameter etc.) verwendet. 

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 SPS-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 CPU-Betriebssystem veranlasst. 

OB’s werden durch Systemereignisse ausgelöst! 

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 Zeit 

OB40 Prozessalarm "I/O-Interrupt" bei bestimmten Signalen der I/O-Peripherie 

OB80 Zykluszeitfehler OB1-Zyklus überschreitet eine definierte Zeit 

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

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, dass irgendein Baustein eigentlich zyklisch bearbeitet werden soll, aber im 

OB1 der betreffende Bausteinaufruf 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 5. 

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

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

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 Anwendungsbeispiel: Abfüllanlage 

Im Abschnitt 2.1 wurde am Beispiel einer Abfüllanlage gezeigt, wie aus der Anlagenfunktion die erforderliche 

Steuerung in Teilaufgaben gegliedert werden kann. Nehmen wir an, die Bausteine werden zyklisch bearbeitet 

(Eingänge lesen, Verarbeitung, Ausgänge schreiben), könnte der Programmablauf etwa so aussehen wie im 

folgenden Bild. 

Programmablauf am Beispiel 

der Abfüllanlage 




Zusammenfassung: Vorteile durch geschickte Aufteilung des Programms in Bausteine 

• Gegliederte Lösung 

Ein in funktionelle Einheiten unterteiltes Programm ist leichter zu erstellen. 

Die Teillösungen können von mehreren Personen entwickelt werden (Teamarbeit). 

• Transparenz 

Ein aus Bausteinen bestehendes Programm ist einfacher zu dokumentieren und besser verstehbar 

• Variabler Ablauf 

Die Programmteile können übersichtlich durch Systemereignisse gestartet werden. Bearbeitungsreihenfolge läßt 

sich leicht ändern 

• Vorteile bei Test und Inbetriebnahme 

Die Bausteine können einzeln getestet und korrigiert werden 

• Kürzeres Programm 

Bausteine im Speicher können mehrfach verwendet werden 

• Fertige Lösungen verwendbar 

Wiederverwendung von Teillösungen, Einsatz von Standardfunktionen und Programmbibliotheken 

2.4 S7-Bibliotheken 

Bibliotheken unter STEP7 enthalten Bausteine, die zur Verwendung in das aktuelle Projekt kopiert werden können. 

Zur STEP7-Programmierumgebung gehören Standardbibliotheken. Diese enthalten u.a. Prototypen der 

Systemfunktionen (SFC) und Systemfunktionsbausteine (SFB), Standardfunktionen für den Umgang mit IEC- 

Datentypen, Arithmetischen Berechnungen, sowie PID-Reglerbausteine. Man kann aus vorhandenen Bausteinen 

auch eigene Bibliotheken aufbauen. 

2.5 Netzwerke 

Die Codebausteine sind unterteilt in sogenannte „Netzwerke“ (NW). Unter FUP/KOP sind NW’s relativ kurz. 

Automatisch wird nämlich mit der ersten Zuweisungsoperation ein Netzwerkende veranlasst. Der Begriff ‘Netzwerk’ 

kommt aus der Nachbildung eines elektrischen Stromkreises in der KOP-Darstellung. 

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

2.6.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 elementaren Datentypen: 

Typ 

Anzahl 

Bit 

Beschreibung Wertebereich 

BOOL 1 Bit TRUE, FALSE 

BYTE 8 Byte 0 ... 255 

WORD 16 Wort 0 ... 65535 (2 16 -1) 

DWORD 32 Doppelwort 0 ... 2 32 -1 

CHAR 8 Zeichen druckbare Zeichen (ASCII-Code) 

INT 16 Ganzzahl 16 Bit -32768 ... +32767 (-2 15 ... +2 15 -1) 

DINT 32 Ganzzahl 32 Bit -2 31 ... + 2 31 -1 (ca. -2,1Mia...2,1Mia) 

REAL 32 IEEE Gleitpunktzahl -3,4E 38 ... 3,4E 38 

TIME 32 IEC-Zeit in Intervallen von 1 ms -2 31 + 2 31 -1 ms (ca. -24..24 Tage) 

DATE 16 IEC-Datum in Intervallen von 1 Tag 2 16 -1 Tage ab 1990-1-1 

TIME_OF_DAY 32 Tageszeit in 1ms-Intervallen, Mitternacht=0 Stunden(0..23) : Minuten(0..59) : Sekund.(0..59) : ms(0..999) 

S5TIME 16 SIMATIC Zeitformat, Intervalle von 10ms 0H_0M_0S_0MS ... 2H_46M_30S_0MS 

Schreibweise zum Eingeben von Daten 

STEP7 bietet mehrere Schreibweisen zum Eingeben von Daten. Je nach Datentyp sind die folgenden Schreibweisen 

erlaubt: 

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 mit 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# TIME_OF_DAY TOD#Stunden:Minuten:Sekunden:Millisekunden TOD#13:24:33:555 

S5T# S5TIME S5T#TageD_StundH_MinutM_SekundS_MillisekMS S5T#12M_22S_100MS 

Beispiel: 

Es soll der Wert 137 dezimal für eine WORD-Variable eingegeben werden. Dann hat man folgende Möglichkeiten: 

W#16#89 

// Hexadezimale Schreibweise, wird am häufigsten verwendet 

2#0000_0000_1000_1001 

// Binäre Schreibweise 

B#(0,137) 

// Schreibweise mit aufeinanderfolgenden Bytes 

C#137 // wird nur im Zusammenhang mit Zählern verwendet 




2.6.2 Zusammengesetzte Datentypen 

Zusammengesetzte Datentypen bestehen aus 2 oder mehreren elementaren Datentypen. 

2.6.2.1 ARRAY 

Ein ARRAY (Feld) verknüpft mehrere gleiche Datentypen zu einer Einheit. Es sind auch mehrdimensionale Arrays 

möglich. 

Syntax: ArrayName ARRAY [1..10, 1..2] of Datentyp // Kommentareile, zweidimensionales Array 

Der Zugriff auf die Variable erfolgt in der Schreibweise: #ArrayName [i,k] 

Beispiel: ARRAY deklarieren und verwenden 

2.6.2.2 STRUCT 

Ein STRUCT (Struktur) verknüpft verschiedene Datentypen zu einer Einheit. 

Syntax: StructName STRUCT // Kommentarzeile zur Struktur 

Data1 Datentyp1 

Data i Datentyp i 

END_STRUCT 

Der Zugriff auf die Elemente erfolgt in der Schreibweise #Strukturname.Feldname (z.B. #Messwert.Temperatur). 

Beispiel: STRUCT deklarieren und verwenden 




STRING 

Eine Zeichenkette (STRING) ist ein eindimensionales ARRAY mit CHAR-Datentypen. Die Feldgrösse beträgt 

maximal 254 Zeichen. 

2.6.3 Parametertypen 

Mit den sogenannten ‚Parametertypen’ können beim Aufruf einer Funktion (FC) oder eines Funktionsbausteins (FB) 

bestimmte Timer, Zähler, Baustein-Nummern, Adressen oder sogar Datenbereiche des Systemspeichers übergeben 

werden. 

Parametertyp Größe Beschreibung Format (Beispiele) 

TIMER 2 Byte übergibt einen bestimmten Timer T10 

COUNTER 2 Byte übergibt einen bestimmten Zähler Z3 

BLOCK_FC 2 Byte übergibt eine bestimmte Funktion F10 

BLOCK_FB 2 Byte übergibt einen bestimmten FB FB3 

BLOCK_DB 2 Byte übergibt einen bestimmten DB DB10 

BLOCK_SDB 2 Byte übergibt einen bestimmten SDB SDB1 

POINTER 6 Byte übergibt einen Zeiger auf einen Absoluten Operanden des P#E3.1 P#A12.0 

Systemspeichers. Der Inhalt entspricht der Operanden- P#M100.3 

anfangsadresse 

ANY 10 Byte übergibt einen Datenbereich im Systemspeicher. ANY zeigt P#E 1.0 BYTE 10 

auf einen Absoluten Operanden des Systemspeichers und P#M 100.0 WORD 3 

gibt außerdem eine bestimmte darauf folgende Datenmenge an 

Die Parametertypen sind notwendig für die Kapselung von Funktionen oder Funktionsbausteinen! 

Auch STEP7-Einsteiger benötigen deshalb die Parametertypen TIMER, COUNTER und BLOCK_…, mit POINTER 

brauchen sie sich aber zunächst nicht herumschlagen. 

Im Abschnitt 2.7.3 wird an einem Beispiel die Verwendung eines Timers innerhalb einer Funktion gezeigt 

Ein Beispiel für ANY finden Sie im Abschnitt 2.9.3 

2.6.4 Anwenderdefinierter Datentyp (UDT) 

Es können auch eigene Datentypen, sogenannte „User Defined Types“ (UDT‘s), definiert werden. Sie bestehen aus 

Zusammensetzungen von Datentypen und gelten im gesamten S7-Programm. Der Aufwand eigener Datentypen 

lohnt sich aber nur, wenn in einem STEP7-Projekt viele Variablen gleichen Typs benötigt werden. 

Anwenderdefinierte Datentypen (UDT’s) gelten im gesamten S7-Programm! 

UDT’s werden im STEP7-Manager erstellt mit: Einfügen ⇒ S7-Baustein ⇒ Datentyp. 

Dort ist eine entsprechende Typdeklaration für den betreffenden UDT, z.B. UDT10, zu erstellen. 

Die Deklaration von Variablen dieses Typs ‚UDT10’ erfolgt dann im Deklarationsteil der betreffenden Bausteine. 




2.7 Variable 

Der Umgang mit Variablen und Adressen bei STEP7 unterscheidet sich von den Festlegungen der IEC 61131-3. 

Während IEC-Programmierer im Allgemeinen nicht daran interessiert sind, an welcher Adresse eine Variable im 

Speicher repräsentiert ist, kann der STEP7-Programmierer aus seinem Wissen über die Speicheraufteilung Nutzen 

ziehen und manche Probleme elegant lösen. Allerdings haben es STEP7-Einsteiger zunächst 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 Kennzeichen für Variable der zugehörige Datentyp, der die erforderliche Menge an Speicherplatz 

kennzeichnet. Ein anderes Kriterium ist die Aktualisierungsrate von Variablen, die sich aus dem Programmablauf 

ergibt und von Systemereignissen abhängig ist (siehe Abschnitt 8). 

Wichtig ist auch der Gültigkeitsbereich, innerhalb dessen eine Variable dem Programm bekannt ist. Dies führt zum 

Begriff einer Globalen bzw. Lokalen Variable. 

2.7.1 Globale Variable 

Globale Variable sind überall im Programm bekannt. Tatsächlich könnte man in jedem Codebaustein lesend oder 

schreibend auf sie zugreifen – aber man sollte es nicht tun! 

Globale Variable nur in Organisationsbausteinen (OB) verwenden! 

Dies fördert die Übersichtlichkeit von Programmen, vermeidet Programmfehler und unterstützt die 

Wiederverwertbarkeit von Bausteinen. 

Es gibt folgende Arten von Globalen Variablen: 

a) Absolute Operanden 

Diese haben einen festen Namen und werden nirgends deklariert, da sie im Systemspeicher der CPU eine feste 

Adresse haben. Die Anzahl der verfügbaren Absoluten Operanden ist daher abhängig von der Hardwarebestückung 

der betreffenden S7-Station (verwendete CPU, Ein- und Ausgabebaugruppen etc.). 

Die Absoluten Operanden verweisen mit ihrem Namen auf einen bestimmten Bereich des Systemspeichers. 

Beispielsweise haben sämtliche Namen, die mit ‚E’ beginnen, mit dem Prozessabbild der Eingänge zu tun, d.h. diese 

Operanden speichern die Zustände der Eingangsperipherie. 

Es gibt folgende Bereiche im Systemspeicher (s.a. Abschn. 2.8): 

Bereichskennung 

E 

A 

M 

Z 

T 

L 

P 

D 

Erklärung 

Prozessabbild der Eingänge (PAE) 

Prozessabbild der Ausgänge (PAA) 

Speicherbereich für Merker 

Speicherbereich für Zähler 

Speicherbereich für Timer 

Lokaldatenstack 

Peripheriedaten 

Daten von Datenbausteinen 

Namensaufbau für Operanden der Speicherbereiche E, A, M, L 

Der Name enthält Bereichskennung, Datentyp und die Startadresse (=Bytenummer, weil der Speicher Byteorientiert 

aufgebaut ist). 

Syntax allgemein: Bereichskennung Datentyp Bytenummer Beispiel: EB 10 

B = Byte 

W= Wort 

D= Doppelwort 

Ausnahme für Bitdaten: Bereichskennung Bytenummer.Bitnummer Beispiel: E 1.0 




Beispiele: 

Operand sprich Erklärung 

E 1.0 „E 1 punkt 0“ Bit 0 (niederwertigstes Bit) von Byte 1 im Prozessabbild der Eingänge 

E 3.7 „E 3 punkt 7“ Bit 7 (höchstwertigstes Bit) von Byte 3 im Prozessabbild der Eingänge 

EB 10 „Eingangsbyte 10“ Byte 10 im Prozessabbild der Eingänge 

EW 20 „Eingangswort 20“ Wort 20 im Prozessabbild der Eingänge 

ED 40 „Eingangsdoppelwort 40“ Doppelwort 40 im Prozessabbild der Eingänge 

Namensaufbau für Operanden der Speicherbereiche Z, T (Zähler und Timer) 

Der Name erhält Bereichskennung und eine Nummer 

Beispiele: Z10, T3 

Namensaufbau für Operanden des Speicherbereichs P (Peripheriedaten) 

Der Name beginnt mit PE ( Eingangsperipherie) bzw. PA (Ausgangsperipherie, gefolgt von Datentyp und der 

Startadresse (=Bytenummer, weil der Spoeicher Byteorientiert aufgebaut ist). 

Syntax Eingangsperipherie: PE Datentyp Bytenummer Beispiele: PEB 2, PEW10, PED 4 

Syntax Ausgangsperipherie: PA Datentyp Bytenummer Beispiele: PAB 2, PAW10, PAD 4 

B=Byte 

W=Wort 

D=Doppelwort 

Namen von Bausteinen und Anwenderdefinierten Datentypen (UDT’s) sind ebenfalls Absolute Operanden! 

Beispiele: OB1, FC10, FB1, DB3, SFC10, SFB3, UDT3 

b) Symbole 

Symbole erleichtern den Umgang mit absoluten Operanden, weil sie anwenderdefinierte Bezeichnungen haben. Sie 

sind sind aber nichts anderes als nur eine andere Schreibweise für Absolute Operanden! Man definiert in einer 

sogenannten „Symboltabelle“ eigene aussagekräftige Symbolnamen, z.B. 

Symbol Adresse Datentyp Kommentar 

Aus E1.3 BOOL Taster für Ausschalten der Maschine 

Nun kann auf den Absoluten Operanden mit der symbolischen Bezeichnung „Aus“ (in Anführungszeichen „...“ !!) oder 

nach wie vor mit E1.3 zugegriffen werden. 

Symboldefinitionen gelten für das gesamte S7-Programm! 

c) Datenbausteine (DB) 

Ein Datenbaustein (DB) ist ein vom Programmierer festgelegter Speicher. Bei der Erstellung eines DB deklariert man 

die enthaltenen Variablen. Daraus ergibt sich die Datenstruktur des DB. Formal kann man überall im S7-Programm 

auf alle Datenbausteine schreibend und lesend zugreifen. Man sollte dies aber aus Gründen besserer 

Übersichtlichkeit und zur Fehlervermeidung nicht tun! 

Selbstverständlich dürfen innerhalb eines Funktionsbausteins Zugriffe auf den Instanz-DB – der ja das eigene 

Gedächtnis bildet – jederzeit erfolgen. 

Ebenfalls erlaubt sind innerhalb einer Funktion oder eines Funktionsbausteins Zugriffe auf einen „Globalen 

Datenbaustein“. Voraussetzung ist aber, daß von Außen erkennbar ist, welcher Datenbaustein verwendet wird. 

In FC’s und FB’s keine „heimlichen“ Zugriffe auf Datenbausteine, die von Außen nicht erkennbar sind! 




2.7.2 Lokale Variable 

Lokale Variable gelten nur in dem Code-Baustein (OB,FC,FB), in dem sie deklariert sind. 

Sie sind ganz spezielle Freunde von IEC-Programmierern und ermöglichen die Erstellung von wiederverwendbaren 

Programmbausteinen. 

Funktionen (FB) und Funktionsbausteine (FB) können nach Außen hin gekapselt werden, so dass dem Benutzer nur 

die Schnittstelle sichtbar ist. 

Vorteil der Kapselung ist zunächst, dass der Baustein für sich alleine getestet werden kann. Sobald der betreffende 

Baustein fehlerfrei arbeitet, kann er ohne weiteres auch in anderen Programmen wiederverwendet werden. Es ist 

auch möglich, ihn in eine S7-Bibliothek einzustellen oder ihn an andere zu verkaufen. In diesem Fall ist eine 

Verschlüsselung des Innenlebens angebracht (Bausteineigenschaft ‚KnowHow-Schutz’ einstellen). 

Selbstverständlich ist neben einer sinnvollen Schnittstelle auch eine gute Dokumentation notwendig, damit der 

Baustein wiederverwendet werden kann. 

Es gilt als Zeichen von sehr schlechtem Programmierstil, innerhalb von FB’s oder FC’s auf globale Variable 

zuzugreifen. Dadurch können Programmfehler nur sehr schwer gefunden werden und eine Wiederverwendung des 

Bausteins ist ausgeschlossen! 

Regel: 

Niemals innerhalb von FB oder FC Absolute Operanden verwenden! 

Am Anfang jedes Code-Bausteins (OB, FC, FB) deklariert man in einem Variablenfenster Lokale Variable. Innerhalb 

des Bausteins kann man durch Programmanweisungen auf die Lokalen Variablen zugreifen. 

Beispiel: Deklaration von Lokalen Variablen 

Wie erkennbar ist, hat dieser Baustein die beiden Eingänge x1 vom Typ INT und x2 vom Typ BYTE. Beim 

Bausteinaufruf müssen Eingangsdaten vom entsprechenden Typ übergeben werden. Falls beim Bausteinaufruf die 

Eingänge nicht beschaltet werden, gelten die deklarierten Anfangswerte, also hier x1=0 und x2=0. 

Bei der Deklaration erhalten die Lokalen Variablen automatisch irgendwelche interne Adressen. Beim 

Programmieren innerhalb des Bausteins braucht man aber die Adressen nicht, sondern kann zum Zugriff direkt die 

Variablennamen verwenden. Dies finden IECProgrammierer ganz normal, alte STEP7-Programmierer hingegen 

freuen sich. 

Die nachfolgende Tabelle zeigt mögliche Variablentypen bei den verschiedenen Codebausteinen (OB, FC, FB). 

Typ Beschreibung kommt vor in: OB FC FB 

IN Eingang nein ja ja 

OUT Ausgang nein ja ja 

IN_OUT Durchgang nein ja ja 

STAT Statisch nein nein ja 

TEMP Temporär ja ja ja 




Ein OB besitzt nur TEMP- (temporäre) Variable! 

Auf den ersten Blick erscheint es seltsam, dass ein OB nur TEMP-Variable besitzt. Der Grund liegt darin, dass die 

einzige Schnittstelle eines OB diejenige zum Betriebssystem ist. Ein OB kann nicht durch Programmanweisungen 

aufgerufen werden, sondern wird automatisch durch ein Systemereignis gestartet (siehe 2.2.1). Das Betriebssystem 

übergibt dem OB beim Aufruf jeweils einige Daten (z.B. Startzeitpunkt). Hierfür benötigt der OB entsprechende 

TEMP- (temporäre) Variable, die beim Erstellen des OB automatisch vom Bausteineditor deklariert werden. 

STAT- (statische) Variable kommen nur in FB’s vor! 

Der Grund liegt darin, dass FB’s ein zugeordnetes „Gedächtnis“ in Form eines Instanzdatenbausteins (Instanz-DB) 

besitzen. Die anderen Codebausteine (OB, FC) besitzen keinen zugeordneten Speicher, können sich also auch 

nichts merken! 

Hinsichtlich der Zugriffsmöglichkeit auf lokale Variable gilt: 

Typ Beschreibung Zugriff 

IN Eingang nur Leseoperation möglich 

OUT Ausgang nur Schreiboperation möglich 

IN_OUT Durchgang Lese- und Schreiboperationen möglich 

STAT Statisch Lese- und Schreiboperationen möglich 

TEMP temporär Lese- und Schreiboperationen möglich 

Auf einen Eingang kann also nicht geschrieben werden. Sinnvoll, oder? 

Hinsichtlich der Lebensdauer von lokalen Variablen gilt: 

Typ Beschreibung Lebensdauer 

IN Eingang bei FB: wie statische Variable bei FC: wie temporäre Variable 

OUT Ausgang bei FB: wie statische Variable bei FC: wie temporäre Variable 

IN_OUT Durchgang bei FB: wie statische Variable bei FC: wie temporäre Variable 

STAT statisch Statische Variable werden im Instanz-DB gespeichert (gibt es nur bei FB) 

Die Daten bleiben nach Bausteinbearbeitung erhalten! 

TEMP temporär Temporäre Variable gelten nur während der Bausteinbearbeitung 

danach wird der Speicherplatz (Lokaldaten-Stack) wieder freigegeben! 

TEMP-Variable eignen also gut dafür, irgendwelche Zwischenergebnisse innerhalb des Bausteins zu speichern. 




2.7.3 Anwendungsbeispiel: Wie verwende ich innerhalb einer Funktion einen Timer? 

Problem: 

Innerhalb einer Funktion soll ein Timer benutzt werden. Bekanntermaßen ist der Name eines bestimmten Timers, 

z.B. T10 ein absoluter Operand, soll also nicht innerhalb von FC’s oder FB’s verwendet werden (siehe Abschnitt 

2.7.1). 

Lösung: 

Man verwendet in der Bausteinschnittstelle eine Lokale Variable vom Typ „TIMER“ (siehe Abschnitt 2.6.3 

Parametertypen) und übergibt bei den Absoluten Operanden T10 erst beim Funktionsaufruf .. 

Deklaration einer Eingangsvariablen 

mit dem 

Namen Timer1 vom 

Typ „TIMER 

Verwendung des 

Timers 

Übergabe vom Timer 

T10 beim Funktionsaufruf 

in einem OB. 

Vorteil: Von Außen sieht man, welche Ressourcen innerhalb der Funktion verwendet werden! 

Frage: Was könnte passieren, wenn innerhalb der Funktion FC1 direkt auf T10 zugegriffen wird? 




2.8 Systemspeicher in der CPU 

Als Bindeglied zwischen Betriebssystem und Anwender gibt es in der CPU der S7-Station den Systemspeicher. 

Sowohl das Betriebssystem als auch das Anwenderprogramm greifen auf den Systemspeicher zu. 

Beispielsweise sorgt das System für eine zyklische Aktualisierung der Prozessabbilder von Ein- und Ausgängen und 

für die Aktualisierung von Timern. 

Der Systemspeicher ist in bestimmte Bereiche unterteilt: Prozessabbild der Eingänge (E), Prozessabbild der 

Ausgänge (A), Merker (M), Timer (T), Zähler (Z), Daten (D), Lokaldaten (L), Eingangsperipherie (PE) und 

Ausgangsperipherie (PA). 

Prinzipiell kann man auf alle Bereiche dieses Speichers durch Programmanweisungen lesend und schreibend 

zugreifen. Bei den Peripheriedaten gibt es eine verständliche Ausnahme: PE kann nur gelesen, PA nur geschrieben 

werden. 

Die folgende Tabelle zeigt die Aufteilung des Systemspeichers. 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. 

Speicherbereich 

Zugriff über Einheiten der 

folgenden Größe 

S7- 

Notation 

Beschreibung 

Verfügbar bei CPU 312 IFM 

PAE Eingang (Bit) E PAE ist ein Speicherbereich, der vom Betriebs- E0.0...31.7, E124.0...127.7 

Prozeß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, AD124 

Merker Merker (Bit) M Anwender - Speicherbereich M0.0...M127.7 

MerkerByte MB MB0... MB127 

MerkerWort MW MW0...MW126 

MerkerDoppelwort MD MD0... MD124 

Zeiten Zeiten T Speicherbereich, in den vom Betriebssystem Z0... Z31 

Zeitwerte geschrieben werden 

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

Datenbausteine, 

adressiert mit 

Datenbaustein, geöffnet mit 

Operation "AUF DB" 

DB 

Datenbausteine werden im Anwenderprogramm 

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

DatenByte DBB steine auf sie zugreifen können (Globale DB) DBB 0 ... DBB 6143 

DatenWort DBW oder sie sind einem bestimmten FB oder SFB DBW 0... DBW 6142 

DatenDoppelwort DBD zugeordnet (Instanz-DB). DBD 0 ... DBD 6140 

Datenbausteine, Datenbaustein, geöffnet mit 

Durch zwei Register der CPU (DB-, DI-Register) 

DI 

adressiert mit Operation "AUF DI" 

können gleichzeitig zwei Datenbausteine 

DI 0 ... DI 63 

DI-Register DatenBit DIX adressiert werden. DIX 0.0 ... DIX 6143.7 

DatenByte DIB DIB 0 ... DIB 6143 

DatenWort DIW DIW 0 ... DIW 6142 

DatenDoppelwort 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 254 

LokaldatenDoppelwort LD zugehörigen Deklarationstabelle LD 0 ... LD 252 

Peripheriebereich PeripherieEingangsByte PEB Speicherbereich, der direkt mit den Daten der PEB0..31, PEB124..127, PEB256..383 

Eingä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..380 

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

PeripherieAusgDoppelwort PAD PAD0..28, PAD124, PAD256..380 

*) die CPU312IFM besitzt Onboard-Peripherie, die EB124..127 und AB124..127 zugeordnet ist 




2.8.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 Konfiguration der CPU kann man aber einen kleinen Teil der Merker, Zeiten, Zähler als „remanent“ festlegen. 

Remanente Daten bleiben bei Spannungsausfall oder beim Anlauf der CPU (Übergang STOP → RUN) erhalten. 

2.9 Adressierung 

2.9.1 Direkte Adressierung 

Normalerweise wird in STEP7 die direkte Adressierung verwendet, d.h. als Operand wird einfach der betreffende 

Variablenname eingetragen. Eine indirekte Adressierung ist in FUP und KOP auch gar nicht vorgesehen. 

Zur Kennzeichnung von Lokalen Variablen trägt man vor den Namen das Zeichen ‚#’ ein. Bei der Verwendung von 

Symbolen muss zur Unterscheidung die Symbolbezeichnung „in Anführungszeichen“ stehen! 

Beispiele für direkte Adressierung in AWL 

// Zugriff auf Lokale Variable 

U #Eingang1 //nur für BOOL 

L #Anzahl //BYTE, WORD, DWORD, S5Time, …. 

L #Messung.Temperatur //STRUCT 

L #Data[10] //ARRAY 

// Zugriff auf Absolute Operanden 

U E1.3 //Eingang 1.3 

L AB10 //Ausgangsbyte 10 

L MW100 //Merkerwort 100 

L T1 //Zeit von Timer 1 

// Zugriffe auf Symbole von Absoluten Operanden 

U „Aus_Taste“ //Namen in „!!!“ 

L „Tasten“ 

L „Sensoren“ 

Zugriff auf Lokale Variable in FUP 

Zugriff auf Lokale Variable in KOP 

Absolute Operanden und Symbole in FUP 

Absolute Operanden und Symbole in KOP 




2.9.2 Indirekte Adressierung 

Indirekte Adressierung ist nur unter AWL verfügbar. Es wird eine Speicherstelle bezeichnet, in der die eigentliche 

Adresse des Operanden abgelegt ist. 

Beispiele für Indirekte Adressierung: 

U A [MD 12] // UND-Operation; die Adresse des Ausgangs steht in MD12 

SI T [MW8] // Starte Timer; die Timer-Nummer steht in MW8 

2.9.3 Adressierung mit Pointer 

Pointer oder Zeiger enthalten die Adresse des Datenobjekts, auf das sie zeigen. Daher kann man Pointer sehr schön 

nutzen, um durch den Speicher zu wandern. Dazu braucht man lediglich den Wert des Pointers verändern. Wenn 

man beispielsweise innerhalb einer Programmschleife den Pointerinhalt ständig erhöht, hat man nacheinander eine 

zusammenhängende Datenmenge im Speicher adressiert. 

Unter AWL bestehen interessante Möglichkeiten, wie mit Zeigern und Adressen unter Zuhilfenahme von 

Adressregistern gerechnet werden kann. Dies ist jedoch nur für sehr wenige Anwendungen nötig und erfordert 

spezielles Wissen in STEP7. 

Wir beschränken uns deshalb auf die Anwendung im Zusammenhang mit dem Parametertyp ANY. Der Typ ANY tritt 

häufig auf, wenn Standardfunktionen aus S7-Bibliotheken benutzt werden sollen. Mit ANY kann „irgendein“ Datentyp 

oder ein Datenblock (d.h. ein zusammenhängender Speicherbereich) übergeben werden (siehe auch Abschnitt 

2.6.3). 

Syntax für ANY: 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 

Beispiel: Verwendung der Systemfunktion SFC20 „BLKMOV“ unter FUP 

Die Systemfunktion SFC20 „BLKMOV“ (Block-Move) kopiert einen Quelldatenblock (SRCBLK) in einen Zieldatenblock 

(DSTBLK)t. Im Beispiel werden 16 Byte vom Prozessabbild der Eingänge ab E1.0 in den Merkerbereich ab 

M10.0 kopiert. Der Ausgang RET_VAL gibt eine Information über das Gelingen der Operation aus. 




2.9.4 Adresszusammenhang Bit, Byte, Wort, Doppelwort 

Es ist wichtig zu wissen, wie Datentypen im Systemspeicher angeordnet sind. Es gibt nämlich keine getrennten 

Speicherbereiche für Bits, Bytes, Worte oder Doppelworte! 

Dies eröffnet dem STEP7-Programmierer bei der Verwendung von Absoluten Operanden (oder Symbolen) einige 

elegante Operationen, stellt aber für Einsteiger eine ernstzunehmende Gefahr dar, die zu schweren 

Programmierfehlern führen kann! 

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 Systemspeicher 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öchstwertigste Byte! 

Das folgende Beispiel zeigt, wie diese Verzahnung von Datentypen sinnvoll verwendet werden kann. 

Beispiel: Es sollen 16 Bit Eingangsdaten parallel Ausgangsdaten zugewiesen werden 

Angenommen, die Eingangsdaten sind: E11. 0 ... 

E12.7 und die Ausgangsdaten sind: A0.0 ... A1.7 

Die Operanden sind wie nebenstehend im 

Speicher angeordnet. Daher kann wie folgt parallel 

zugegriffen werden: 

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. 

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




3 Beispiele in FUP/KOP und AWL 

Die folgenden kleinen Programmbeispiele sind zum Vergleich jeweils in den 3 Sprachen dargestellt. FUP und KOP 

sind im Sprachumfang gleich. 

Insbesondere bei den etwas komplexeren Funktionen zeigt sich, dass FUP und KOP sehr ähnlich sind. Daher sollte 

man nicht mit FUP und KOP gleichermaßen arbeiten, sondern sich für eine der beiden Sprachen entscheiden! 

3.1 Logische Verknüpfung 

3.2 Flip Flop und Flankenerkennung 

Gezeigt ist ein ein FlipFlop mit dominantem 

Rücksetzeingang. 

Flankenerkennungen benötigen 

einen freien binären Operanden zum 

Speichern des früheren Signalzustands, 

hier M1.0. 

Gezeigt ist die Verwendung der 

Operation „P“ zur Erkennung einer 

positiven, d.h. ansteigenden Flanke. 

3.3 Timer 

Der Zeitwert ist vom Datentyp 

S5Time! 

Neben dem verwendeten Impulstimer 

gibt es noch Timer für 

Einschaltverzögerung, Ausschaltverzögerung 

und speichernde 

Einschaltverzögerung. 




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 = 0..999 

Neben dem dargestellten 

Rückwärtszähler gibt es auch 

Vorwärts- und Vorwärts/Rückwärtszähler. 

3.5 Arithmetische Operation 

Addition zweier Integerzahlen. 

3.6 Bausteinaufruf 

Gezeigt ist der bedingte Bausteinaufruf: 

FC2 wird nur dann 

bearbeitet, wenn die Variable „E3“ 

den Wert TRUE hat. 

Außerdem gibt es noch einen 

absoluten Bausteinaufruf (Bearbeitung 

immer, ohne Bedingung). 

Unter FUP darf der Eingang EN 

dann einfach unbeschaltet bleiben 

(s.a. Abschnitt 3.5) 




3.7 MOVE (Laden und Transferieren) 

Mit MOVE können alle Datentypen 

bis 32Bit Breite behandelt werden. 

(Byte, Wort, Doppelwort, INT, 

REAL, TIME, S5-TIME, DATE, 

TIME_OF_DAY etc.) 

Ausnahme: nicht zulässig für Bit- 

Operanden! 

Im Beispiel wird auf ein Strukturelement 

zugegriffen (z.B. vom 

Datentyp INT). 

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 hängt vom jeweiligen Betriebszustand ab: 

STOP: Das Anwenderprogramm wird nicht bearbeitet. Ausgänge sind auf 0 gesetzt. Die CPU prüft, ob Hardwareoder 

Systemfehler vorliegen. Das Urlöschen ist möglich (siehe Abschnitt 4.3) 

ANLAUF: Bevor die CPU nach dem Einschalten mit der Bearbeitung des Anwenderprogramms beginnt, veranlaßt 

das Betriebssystem den Aufruf des OB100 (Neustart). Im OB100 kann man 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 




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 

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

• 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 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: 

Es soll eine Funktion erstellt werden, die das Ergebnis Y = A*B*C zurückliefert. Die Variablen sind alle vom Typ DINT 

(Ganzzahl, 32 Bit). Wenn die Faktoren zu groß sind, wird der zulässige Zahlenbereich von Y überschritten und das 

Ergebnis ist falsch! Deshalb sollte der Erfolg der Berechnung dem aufrufenden Baustein mitgeteilt werden. 

Wegen Y= A*B*C= (A*B)*C kann die Berechnung 

der Multiplikation aus zwei hintereinandergeschalteten 

Multiplizierern mit jeweils 2 Eingängen 

zusammengesetzt werden. 

STEP7 stellt fertige Multiplizierer mit zwei Eingängen 

zur Verfügung. In der Liste der Programmelemente 

ist die Operation MUL_DI (Multiplikation für Variable 

vom Typ DINT) zu finden. 

Die Operanden EN und ENO kommen in FUP/KOP 

bei der Darstellung von FC‘s, FB‘s und aufwendigen 

Programmelementen, vor, wie auch die nebenstehende 

Beschreibung von MUL_DI zeigt. 

aus der Online-Hilfe zu MUL_DI 

5.1 Die Operanden EN (Enable) und 

ENO (Enable Out) 

Wenn unter FUP/KOP eine Funktion aufgerufen wird, erscheint ein Block mit den Bausteinparametern, die von 

außen entsprechend beschaltet werden. Eine Besonderheit sind dabei die Operanden EN auf der Eingangs- und 

ENO auf der Ausgangsseite. Sie werden zur Programmsteuerung und zur Behandlung von Laufzeitfehlern während 

der Bearbeitung verwendet. 

Die Operanden EN und ENO sind dem Wert des Statusflags „BIE“ (Binärergebnis) der CPU fest zugeordnet und 

brauchen deshalb im Baustein nicht deklariert zu werden. 

EN 

ENO 

entspricht dem Wert von BIE vor der Bearbeitung, 

entspricht dem Wert von BIE nach der Bearbeitung des jeweiligen Funktionsblocks. 

Unter AWL treten diese Operanden nicht auf. Hier wird stattdessen direkt mit dem Statusflag „BIE“ gearbeitet 

EN (Enable) 

Der betreffende Funktionsblock wird nur dann bearbeitet, wenn EN = 1 ist. Im anderen Fall wird er übersprungen. Im 

Zusammenhang mit einem Bausteinaufruf ist EN die Bedingung, ob der Baustein tatsächlich bearbeitet wird oder 

übersprungen wird. 

Bearbeitung des Funktionsblocks dann, wenn: EN = 1 

ENO (Enable Out) 

Der Wert von ENO bzw. BIE wird durch Programmanweisungen im betreffenden Funktionsblock festgelegt. Es gilt 

folgende Konvention zur Programmsteuerung: 

Man setzt ENO in Abhängigkeit von evtl. Laufzeitfehlern durch einem Schreibzugriff auf das Statusflag „BIE“ 

(Binärergebnis) auf folgenden Wert: 

Bearbeitung des Bausteins ohne Fehler: 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. 




Mit der Operation „SAVE“ wird der Inhalt des VKE (Verknüpfungsergebnis) dem BIE zugewiesen 

Man erstellt also ein VKE entsprechend der Programmsteuerungs-Konvention und weist am Bausteinende durch 

eine „SAVE“-Operation den Wert dem BIE-Flag zu. 

Da von den vielen Operationsbefehlen unter STEP7 lediglich SAVE einen Einfluß auf das BIE-Flag besitzt, gilt 

außerdem noch die folgende Regel: 

Wenn keine Operation „SAVE“ vorkommt, ist: 

ENO = EN 

Beispiel: BIE soll mit dem Wert von Merker M1.0 belegt werden. In den verschiedenen Sprachen sieht die Operation 

so aus: 

FUP KOP AWL 

U M1.0 

SAVE 

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

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

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




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 

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

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




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

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

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




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. 

6.3 Adressierung der Daten 

Der folgende Abschnitt betrifft den Zugriff auf Daten sowohl in Instanz- als auch in Global-Datenbausteinen. 

Die CPU hat für die Adressierung der jeweiligen Datenbausteine 2 Register zur Verfügung, so daß gleichzeitig zwei 

DB’s komfortabel adressiert werden können: 

DB-Register 

DI - Register 

speichert die Nummer des (globalen) Datenbaustein 

speichert die Nummer des Instanz-Datenbausteins 

Grundsätzlich gibt es gibt zwei Möglichkeiten, auf Daten zuzugreifen: 

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




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

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




7 Funktionsbaustein (FB) 

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

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

7.2.1 FB Erstellen 

FB10: 

Deklaration der lokalen Variablen 

FB10: Anweisungsteil 




7.2.2 FB Aufrufen 

Es muß dafür gesorgt werden, daß die 

Bearbeitung des FB in gleichen Zeitabständen 

erfolgt. Dies kann sehr einfach mit dem OB35, 

ein periodischer Zeitinterrupt oder „Weckalarm“, 

realisiert werden (s.a. Abschnitt 10.2, 

Weckalarm) 

Vom Betriebssystem wird dem OB35 beim 

Aufruf die Abtastzeit übergeben (lokale Variable 

„OB35_EXC_FREQ“). Mit „PEW288“ wird ein 

direkter Peripheriezugriff auf eine analoge 

Eingangsbaugruppe mit der Adresse 288 

veranlaßt. 

Beim Aufruf des FB10 (symbolischer Name 

„d/dt“) muß der Name des Instanz-DB 

angegeben werden, hier DB10 

(„GeschwDB“) 

OB35: Aufruf des FB10 

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




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

8.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 selbstverständlich, 

daß Änderungen an der 

Eingangsperipherie erst im nächsten Zyklus bemerkt 

werden. 

Entsprechend den PAE-Daten, Merkern, anderen 

Daten und Anweisungen des Programms wird der 

OB1 abgearbeitet. Anweisungen im OB1 hinsichtlich 

der Ausgänge verändern den CPU-Speicherbereich 

PAA (Prozeßabbild der Ausgänge). Sie betreffen 

aber nicht die eigentlichen, an der Peripherie 

befindlichen Ausgänge! 

Erst am Ende des OB1 wird der Wert des PAA auf 

die Ausgänge transferiert. 

Beim Auftreten von irgendwelchen 

Systemereignissen wird der OB1 entsprechend der 

Priorität der zugehörigen OB’s unterbrochen und 

nach deren Bearbeitung wieder fortgesetzt. 

Falls es spezielle Problemstellungen erfordern, kann auch innerhalb des OB1-Zyklus direkt auf die Peripherie 

zugegriffen werden. Dies geschieht durch Lese/Schreibzugriffe auf den CPU-Speicherbereich PE (Peripheriebereich 

Eingänge) bzw. PA (Peripheriebereich Ausgänge) . 

Beispiel: L PEB 12 (lade PEB 12 in Akku1) 

T PAW 2 (transferiere Inhalt von Akku1 nach PAW2 




8.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 mit dem Schlüsselschalter eingeschaltet wird oder ob plötzlich eine eingebrochene 

Netzspannung wiederkehrt. Deshalb wird vom Betriebssystem die Vorgeschichte in lokale Variable des OB100 

eingetragen. 

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

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




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) 




8.3 Weckalarm = Periodischer Zeitinterrupt (OB30..OB38) 

Eine periodische Unterbrechung der zyklischen OB1-Bearbeitung ist mit den Organisationsbausteinen OB30 bis 

OB38 möglich. Allerdings ist die verfügbare Anzahl der Weckalarm-OB’s abhängig von der jeweiligen CPU, wie die 

nachfolgende Tabelle zeigt: 

CPU 

verfügbare Weckalarm-OB's 

CPU 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 

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

Weckalarm-OB’s Zeittakt in ms Prioritätsklasse 

OB 30 5000 7 

OB 31 2000 8 

OB 32 1000 9 

OB 33 500 10 

OB 34 200 11 

OB 35 100 12 

OB 36 50 13 

OB 37 20 14 

OB 38 10 15 

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. 

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

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




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

8.4.1 Alarm-Freischaltung in der CPU 

Die CPU muß entsprechend parametriert werden, damit die entsprechenden Interruptanforderungen bearbeitet 

werden. Dies geschieht mit dem SIMATIC Manager : 

Die betreffende SIMATIC-Station mit rechter Maustaste anklicken, dann ⇒ Objekteigenschaften. 

es erscheint das Fenster ‘Hardware-Konfiguration’. Die ausgewählte CPU in der rechten Maustaste anklicken, 

⇒ Objekteigenschaften ⇒ Integrierte Funktion 

Ausgewählt wird die Integrierte Funktion 

‚Alarmeingang‘. 

Mit ‚Parametrieren‘ wird das nächste 

Fenster gewählt, in dem die Bedingungen 

zur Freischaltung eines Prozeßalarms 

definiert werden können. 

Im diesem Beispiel soll der Alarm dann 

auftreten, wenn entweder am Alarmeingang1 

eine steigende Flanke oder am 

Alarmeingang2 eine fallende Signalflanke 

erscheint. 

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




Literaturangaben 

Im Labor für Automatisierungstechnik liegen folgenden Handbücher im Zusammenhang mit STEP7 aus. Sie werden 

alle von der Firma Siemens AG herausgegeben: 

1. Elektronische Handbücher auf CD-ROM (aktuelle Ausgabe) 

enthalten als PDF-Dateien 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

Simatic S7 von Siemens - Portal Automatisierungstechnik der tsm

Erfolgreiche ePaper selbst erstellen

Template löschen?

Als Template speichern?