Speicherprogrammierbare Steuerungen (SPS)...

TESLA INSTITUTE

Speicherprogrammierbare

Steuerungen (SPS)

Grundlagen

Peter Witt

TESLA INSTITUTE Speicherprogrammierbare Steuerungen Grundlagen

Inhaltsverzeichnis

Inhaltsverzeichnis.........................................................................2

Speicherprogrammierbare Steuerungen Grundlagen..........................9

Grundlagen der Digitaltechnik.......................................................12

Mathematische Grundlagen..........................................................14

Zahlensysteme........................................................................15

Dezimalsystem........................................................................19

Dualzahlen - Das binäre Zahlensystem........................................21

Dualzahlen umrechnen.............................................................25

Positive Ganzzahlen nach Dezimalzahlen umrechnen..................25

Positive gebrochene Zahlen nach Dezimalzahlen umrechnen.......28

Positive Ganzzahlen von Dezimal nach Dual umrechnen.............29

Positive gebrochene Dezimalzahlen nach Dual umrechnen..........31

Näherungswerte bei der Umrechnung gebrochener Dualzahlen in

Dezimalzahlen......................................................................32

Addieren - Die Additionsregeln bei Dualzahlen..........................34

Subtrahieren - Subtraktionsregeln bei Dualzahlen......................39

Komplementbildung - Einerkomplement und Zweierkomplement

bilden.................................................................................44

Multiplizieren - Multiplikationsregeln bei Dualzahlen...................50

Dividieren - Division im Dualsyste...........................................54

Gebrochene Dezimalzahlen....................................................58

Gebrochene Dualzahlen multiplizieren......................................63

Dualsystem in Step7................................................................69

Hexadezimalsystem.................................................................75

Hexadezimalzahlen umrechnen...............................................81

www.tesla-institute.com 2

http://www.tesla-institute.com/


BCD - Binär Codierte Dezimalzahlen...........................................86

BCD-Zahlen bei Speicherprogrammierbaren Steuerungen...........90

Zahlenformate bei Speicherprogrammierbaren Steuerungen...........92

Ganzzahlen..........................................................................92

Gleitpunktzahlen..................................................................94

Unterschiede bei 32 Bits und 64 Bits........................................95

Umrechnung dezimaler Gleitpunktzahlen in duale Gleitpunktzahlen

.........................................................................................96

Umrechnung einer dezimalen Gleitpunktzahl in Dual..................99

Bit und Byte.............................................................................103

Bitadressen...........................................................................105

Byteadressen........................................................................105

Wortadressen........................................................................106

Doppelwortadressen...............................................................108

Besonderheiten bei der Adressierung........................................109

Adressierungsregeln............................................................110

Schaltwerttabelle......................................................................111

Schaltwerttabelle mit 2 Eingängen............................................112

Schaltfunktion mit Hilfe einer Schaltwerttabelle..........................114

Schaltfunktion in mathematischer Form..................................115

Schaltfunktion in boolescher Form.........................................116

Vereinfachung von Schaltfunktionen..........................................117

KV-Diagramm: Vereinfachen mit einem Karnaugh-Veitch-Diagramm

...........................................................................................119

Vorgehensweise bei der Arbeit mit KV-Diagrammen.................119

Aufbau eines KV-Diagrammes...............................................120

Zusammenfassen der Terme.................................................123

Boolesche Algebra in der Steuerungstechnik - Schaltalgebra............129

Darstellung und Verknüpfungen...............................................130




Kommutativgesetz (Vertauschungsgesetz)..............................132

Assoziativgesetz (Verbindungsgesetz)....................................132

Distributivgesetz (Verteilungsgesetz).....................................133

Absorptionsgesetz...............................................................133

Negationsgesetz.................................................................134

DeMorgan'sche Gesetze.......................................................135

Doppelte Negation..............................................................136

Ausmultiplizieren................................................................136

Vorrangregeln und Klammerregeln........................................137

Binäre Operationen....................................................................139

Binäre Verknüpfungen und Abfragen.........................................142

Die Negation......................................................................143

Die UND-Verknüpfung, Konjunktion (AND, UND)......................143

Die ODER-Verknüpfung, Disjunktion (OR, ODER).....................144

Die Exklusiv-ODER-Verknüpfung (XOR)..................................145

Negation einer UND- oder OR-Verknüpfung.............................145

NAND-Verknüpfung..........................................................146

NOR-Verknüpfung............................................................146

Negierte Exklusiv-ODER-Verknüpfung, auch Exklusiv-NICHT-

ODER genannt (XNOR).....................................................148

Zusammengesetzte Verknüpfungen.......................................148

Zuweisung des Ausgangs über das Verknüpfungsergebnis, VKE. 149

Zusammengesetzte binäre Verknüpfungen.................................150

UND vor ODER-Verknüpfungen..............................................150

ODER vor UND-Verknüpfungen..............................................151

Exklusiv-ODER vor UND-Verknüpfungen.................................152

Exklusiv-ODER vor ODER-Verknüpfungen................................153

UND vor Exklusiv-ODER-Verknüpfungen.................................153

ODER vor Exklusiv-ODER-Verknüpfungen................................154




Das Verknüpfungsergebnis VKE................................................155

VKE während der Abarbeitung des SPS-Programms..................155

Verlauf des VKE bei einem Beispielprogramm..........................156

Verlauf des VKE während eines Programmablaufs....................157

Merker - Speichern von Zwischenergebnissen in der SPS.............163

Verwendung von Merkern.....................................................165

Speicherfunktionen in SPS - SR- und RS-Flipflops.......................167

Funktionsweise von Speicherfunktionen..................................167

Speicherverhalten mit UND-, ODER-Gliedern realisieren............169

Trennung der Setz- und Rücksetzanweisung............................171

Direktes Setzen eines Ausgangsoperanden.............................172

Verriegeln von Speichergliedern............................................173

Verriegeln von SR- und RS-Flipflops..........................................174

Gegenseitiges Verriegeln......................................................174

Reihenfolgeverriegelung.......................................................175

Gegenseitiges Verriegeln über den Rücksetzeingang.................175

Gegenseitiges Verriegeln über den Setzeingang.......................176

Reihenfolgeverriegelung über den Setzeingang........................177

Reihenfolgeverriegelung über Rücksetzeingang.......................177

Setz- und Rücksetzdominanz der Speicherglieder....................179

Flankenauswertung in SPS-Programmen....................................179

Positive und negative Flanke.................................................181

Funktionsweise der Flankenauswertung...............................182

Impulsoperand einer Flanke..................................................183

Flankenauswertung mit Speichergliedern................................185

Binäruntersetzer....................................................................187

Binäruntersetzer mit einer SPS.............................................188

Stromstoßschalter realisieren...................................................192

Stromstoßschalter mit XOR..................................................192




Stromstoßschalter mit SR-Flipflops........................................194

Stromstoßschalter mit einer Sprungfunktion...........................196

Taktsignale in der Steuerungstechnik........................................198

Erzeugung von Taktsignalen.................................................198

Taktgeber mit Zeitfunktionen programmieren..........................200

Taktsignale über einen Taktmerker erzeugen...........................201

Taktmerker in der Hardwarekonfiguration festlegen..................201

Weckalarme als Taktsignal nutzen.........................................203

Zeitfunktionen (Timer) in einer SPS..........................................207

Zeitfunktionen programmieren..............................................212

Zeitfunktion SA - Ausschaltverzögerung.................................221

Zeitfunktion SE - Einschaltverzögerung..................................224

Zeitfunktion SI - Impuls.......................................................227

Zeitfunktion SS - speichernde Einschaltverzögerung.................230

Zeitfunktion SV - verlängerter Impuls....................................234

Zählerfunktionen, Counter mit einer SPS realisieren....................238

Zähler programmieren............................................................244

Digitale Operationen..................................................................250

Übertragungsfunktionen: Lade- und Transferfunktionen,

Akkumulatorfunktionen...........................................................252

Akkumulatorfunktionen........................................................257

Vergleichsfunktionen: Vergleicher in SPS...................................263

Vergleichsfunktion in FUP.....................................................264

Schiebefunktionen..................................................................267

Schiebefunktion in FUP........................................................268

Weitere Schiebefunktionen...................................................269

Arithmetische Funktionen........................................................272

Umwandlungsfunktionen.........................................................276

Digitale Verknüpfungen...........................................................279




Digitale UND-Verknüpfung....................................................280

Digitale ODER-Verknüpfung..................................................280

Digitale EXKLUSIV-ODER-Verknüpfung...................................281

Digitale Verknüpfungen in FUP..............................................281

Operanden in SPS.....................................................................283

SPS Adressierung......................................................................286

Datentypen bei Programmierung von Steuerungsaufgaben..............288

Parametertypen in Step7............................................................295

Zuordnungstabelle - Eine Steuerung mit einer Zuordnungsliste planen

..............................................................................................298

Symboliktabelle - Die symbolische Adressierung............................300

Codebausteine in Step7..............................................................303

Organisationsbausteine OB in S7..............................................305

Uhrzeitalarm OB's - Organisationsbausteine OB10 bis OB17......309

Verzögerungsalarm OB's, OB20, OB21, OB22, OB23................316

Weckalarm OB's, OB30, OB31, OB32, OB33, OB34, OB35, OB36,

OB37, OB38.......................................................................322

Prozessalarm OB's, OB40, OB41, OB42, OB43, OB44, OB45, OB46,

OB47................................................................................328

DPV1-Alarme - Updatealarm, Statusalarm, herstellerspezifischer

Alarm................................................................................333

Funktion FC oder SFC.............................................................337

Funktionsbausteine FB oder SFB in S7.......................................343

Variablen in Graph..............................................................345

Datenbausteine in SPS...............................................................354

Instanzdatenbausteine............................................................360

Globaldatenbausteine.............................................................363




Speicherprogrammierbare Steuerungen Grundlagen

Um mit mit einer SPS-Programmiersoftware wie z.B. mit SIMATIC Step7

programmieren zu können, werden allgemeine Grundkenntnisse auf

dem Gebiet der Automatisierungstechnik vorausgesetzt. Weiterhin wird

davon ausgegangen das der Leser Kenntnisse über die Verwendung von

Computern bzw. PC-ähnlichen Arbeitsmitteln (Programmiergeräte etc.)

besitzt und Erfahrungen im Umgang mit Betriebssystemen hat.

Aus unserem Leben ist das Zehnerzahlensystem, auch Dezimalsystem

genannt, nicht mehr wegzudenken. Dieses Zahlensystem wurde vor

mehr als 2500 Jahren von den Indern entwickelt. Die Inder erfanden

auch die Zahl Null. Im Mittelalter lernten europäische Kaufleute dieses

Zahlensystem beim Handel in den arabischen Ländern kennen und

brachten es mit nach Europa. Daher werden die Ziffern von 0 bis 9 auch

arabische Ziffern genannt. Durch die Verwendung dieser Ziffern stellt

man Informationen dar die wir für unser Leben benötigen.

Zahlensysteme als SPS-GrundlagenZu den SPS-

Grundlagen gehören die Zahlensysteme




Eine SPS aber kann nur Informationen mit zwei Zustandsmöglichkeiten

verarbeiten, binäre Informationen. Die Logik für das binäre System

ergibt sich dadurch, dass der Computer, eine SPS ist im Grunde nichts

anderes, nur zwei Zustände erkennen kann. Entweder es fließt Strom

oder es fließt kein Strom. Das System kann man auch auf das binäre

System übertragen. Denn das binäre System kennt ebenfalls nur zwei

Zustände. Diese binären Informationen werden in der Digitaltechnik mit

Hilfe des Dualsystems dargestellt. Im Dualsystem gibt es nur zwei

Ziffern, die "0" und die "1". Diese zwei Ziffern verbindet man in der

Digitaltechnik mit Signalzuständen. Die "0" entspricht dem

Signalzustand "AUS" und die "1" dem Signalzustand "EIN". Eine binäre

Information hat diese zwei Zustände, "0" (AUS) oder "1" (EIN). Diese

Information nennt man "Bit". Bit ist die Abkürzung von "Binary Digit"

und heißt frei ins Deutsche übersetzt Signal (Digit) das zwei Zustände

(binary, binär) haben kann. Das Bit ist die Einheit für ein binäres Signal

und damit die kleinste informationstechnische Einheit. Informationen

können aus mehreren Bit's bestehen. Besteht die Information aus 8

Bit's, dann spricht man von einem "Byte". Ein Byte ist die Einheit von 8

aufeinanderfolgenden bzw. zusammenhängenden Bit's. Komplexere

Informationen werden mit 2 Byte oder 4 Byte dargestellt. Bei einer

Informationsgröße die 2 Byte benötigt spricht man von einem Wort (im

digitalen Sinn). Zwei Wörter ergeben wiederum ein Doppelwort. Das

Doppelwort besteht also aus 2 Wörtern die 4 Byte enthalten und damit

32 Bit.

Dies ist wichtig zu wissen und zu verstehen um eine SPS

programmieren zu können da es sonst bei der Programmierung zu




Codierungsproblemen kommen kann. Eine speicherprogrammierbare

Steuerung funktioniert nach den gleichen Prinzipien wie man es vom

Computer her kennt. Daher gehören die Zahlensysteme wie das

Dualsystem, Hexadezimalsystem oder der BCD-Code zu den SPS-

Grundlagen. Ein SPS-Programmierer sollte sie kennen und beherrschen.

Auch mit Dualzahlen kann man, wie man es von unserem

Dezimalsystem her kennt, rechnen. Man kann Dualzahlen addieren,

subtrahieren, multiplizieren oder dividieren. Selbst gebrochene

Dualzahlen kann man multiplizieren. Diese mathematischen Grundlagen

zählen zu den SPS-Grundlagen, weil man so die Logik, quasi die

"Denkweise" einer SPS, kennt. Und die Logik einer SPS ist im Grunde

ziemlich einfach. Entweder Strom fließt oder nicht.

Die mathematischen Grundlagen sind auch deshalb wichtig, damit man

die Datentypen versteht, mit denen eine SPS arbeitet. Beispielsweise

benötigt man für ein binäres Signal nur ein Bit. Ein Bit reicht, um

praktisch die Logik eines Schalters abzubilden. Aber wie verhält es sich,

wenn man komplexe Datentypen wie beispielsweise die Uhrzeit, eine

Füllmenge oder einen Zählerstand abbilden möchte. Hier benötigt man

mehrere Bits, in 8 Bit zusammengefasst Bytes. Je komplexer und größer

der Informationsgehalt einer Information ist, umso mehr Bits werden

benötigt um diese im Computer abzubilden. Und der Begriff

Informationstechnik wird mit der Computertechnik deshalb oft

gleichgesetzt, weil der Mensch versucht, die Informationen die er aus

der realen Welt kennt, im Computer abzubilden.




Grundlagen der Digitaltechnik

Wie arbeitet bzw. funktioniert eine Fahrstuhl- oder eine automatische

Pumpensteuerung? Wie werden die Abläufe in einer Kläranlage geregelt

und gesteuert? Wie steuert und regelt man ein modernes Bürohochhaus

klimatechnisch? Wie addiert man Zahlen elektrisch? Wie werden digitale

Informationen gespeichert?

Die Grundlage für eine Abstraktion dieser vielfältigen Fragestellungen

bilden die Zahlensysteme. Deren Verständnis benötigt man bei vielen

Anwendungen: beim Aufbau einer Schaltwerttabelle, bei binärem

Zählen, bei elektronischem Rechnen oder auch bei

Codierungsproblemen in speicherprogrammierbaren Steuerungen und

bei einfachen Programmiersprachen.

Binäre Grundverknüpfungen wie die Negation (NOT, NICHT),

Konjunktion (AND, UND) und Disjunktion (OR, ODER) dürften bekannt

sein und können zur Lösung einfacher digitaltechnischer Probleme

herangezogen werden.

Komplexere Lösungswege werden mit Hilfe von Schaltwerttabellen, auch

Wahrheitstafel genannt, dargestellt, in denen man die Abhängigkeiten

der Ausgangsvariablen von den Eingangsvariablen zum Ausdruck bringt.

Diese Lösungsansätze werden dann vereinfacht und umformuliert in




eine mathematisch logische Schreibweise um daraus dann ein

Schaltschema aufzubauen. Hierbei wendet man entweder die Regeln

und Gesetze der Schaltalgebra an oder man vereinfacht

Schaltfunktionen anhand von KV-Diagrammen.




Mathematische Grundlagen

Mathematik ist die Grundlage für die Programmierung und Funktion

eines Computer und somit auch einer SPS. Die Menschen denken im

Dezimalsystem, dessen Ziffernvorrat aus 0 bis 9 besteht. Das hat sich

so ergeben, weil der Mensch 10 Finger hat und beim Zählen häufig die

Finger benutzt wurden. Im Dezimalsystem kann man

Rechenoperationen wie Addition, Subtraktion, Multiplikation, Division,

Potenzen usw. durchführen und den Menschen ist der Umgang mit dem

Dezimalsystem bekannt.

Ein Computer, wozu auch eine SPS zählt, arbeitet jedoch nicht mit dem

Dezimalsystem. Die Ursache hierfür liegt im technischen Grundaufbau

eines Computers, der eben nur erkennen kann, ob Strom fließt oder

nicht fließt. Für den Computer ist daher nur erkennbar, ob das Signal 1

(Strom fließt) oder 0 (Strom fließt nicht) ist.

Daher benötigt eine SPS ein Zahlensystem, mit dem gearbeitet werden

kann und das ist grundsätzlich das Dualsystem. Das Dualsystem kennt

nur 2 Ziffern (0, 1) und eignet sich daher sehr gut für die interne

Verarbeitung von Zahlen in einer SPS. Das Dualsystem hat jedoch einen

großen Nachteil. Für selbst kleinste Zahlen benötigt man riesige

Ziffernfolgen. Daher haben sich zwei weitere Zahlensysteme etabliert,

mit denen bei der SPS-Programmierung gearbeitet wird. Das sind die

Zahlensysteme Hexadezimalsystem und BCD Code.




Zahlensysteme

Ein SPS-Programmierer sollte sich daher mit diesen 3 Zahlensystemen

vertraut machen. Häufig werden Eingaben in BCD-Format, als

Hexadezimalzahl oder als Dualzahl erwartet oder man muss die

entsprechenden Ziffernfolgen auswerten können. Intern wird jedoch

immer mit dem Dualsystem gearbeitet, da eine SPS nur die logischen

Zustände 0 und 1 (An und Aus) kennt und die Arbeitsweise einer

Schaltung durch diese beiden logischen Zustände beschrieben werden

kann. Auch bei der SPS-Programmierung werden diese beiden logischen

Zustände verwendet.

Siehe auch Bit und Byte.

Eine SPS-Programmierer muss sich also neben dem Dezimalsystem mit

weiteren Zahlensystemen beschäftigen. Zahlensysteme werden durch

drei Merkmale beschrieben:

• Basis: Gibt im Zahlensystem die Anzahl der Ziffern an. Im

Dezimalsystem hat man z.B. 10 Ziffern (0 - 9), also ist die Basis

10. Im Dualsystem hat man 2 Ziffern (0, 1), also ist die Basis 2.

Im Hexadezimalsystem hat man 16 Ziffern (0 - 9 und A - F).

• Ziffern: Damit wird angegeben, welche Ziffern im jeweiligen

Zahlensystem Gültigkeit hat. Die Ziffer X kommt z.B. im

Dezimalsystem nicht vor. Bei den römischen Zahlen wäre es

dagegen gültig.




• Stellenwerte: Der Stellenwert einer Ziffer gibt, jeweils höherwertig

von rechts nach links, die Wertigkeit im Zahlensystem an. Die

Ziffernfolge 10 hat im Dezimalsystem die Wertigkeit von 10, da

die Basis 10 ist und die Ziffer 1 sich an der zweiten Stelle befindet

und daher mit 101 multipliziert wird. Im Dualsystem hätte die

Ziffernfolge nur die Wertigkeit von 2 (Multiplikation mit 21). Denn

die Basis des Dualzahls ist 2. Im Hexadezimalsystem hätte die

Ziffernfolge 10 die Wertigkeit von 16 (Multiplikation mit 161). Für

jede Stelle nach links muss man den Exponent der Potenz um 1

erhöhen, um die Wertigkeit zu ermitteln. Beispielsweise hätte die

Ziffernfolge 100 im Hexadezimalsystem die Wertigkeit von 256

(1 x 16 x 16 oder 1 x 162). Die Ziffernfolge 1000 hätte die

Wertigkeit von 4096 (1 x 16 x 16 x 16 oder 1 x 163).

Darstellungsarten in Zahlensystemen

Dezimalzahlen werden mit einer tiefgestellten 10 gekennzeichnet, z.B.

510

Dual- oder Binärzahlen werden mit einer tiefgestellten 2

gekennzeichnet, z.B. 10102

Hexadezimalzahlen werden mit einer tiefgestellten 16

gekennzeichnet, z.B. AC2316

Zahlen im BCD Code werden mit tiefgestellten BCD gekennzeichnet,

z.B. 1001 0110 0011BCD




Die Ziffernfolge bezeichnet im jeweiligen Zahlensystem den Wert, wobei

auch ungültige Ziffernfolgen vorkommen können, weil das

Zahlensystem eine Ziffer nicht kennt bzw. diese im Zahlensystem nicht

vorkommt. Einige Beispiele:

• Gültige Ziffernfolge im Dezimalsystem: 1010. Die Zehn mit den

Ziffern 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ist die Basis des Dezimalsystems

und mit der Ziffernfolge 1010 wird der Wert 10 dargestellt.

• Ungültige Ziffernfolge im Dezimalsystem: 1X01010. Das ist keine

gültige Dezimalzahl, denn die Ziffer X kommt im Dezimalsystem

nicht vor.

• Gültige Ziffernfolge im Dualsystem: 102. Die Zwei mit den Ziffern

0 und 1 ist die Basis des Dualsystems und mit der Ziffernfolge 102

wird der Dezimalwert 210 dargestellt.

• Ungültige Ziffernfolge im Dualsystem: 1302. Das ist keine gültige

Dualzahl, da im Dualsystem die Ziffer 3 nicht existiert.

• Gültige Ziffernfolge im Hexadezimalsystem: 1016. Die Sechzehn

mit den Ziffern 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F ist die

Basis des Hexadezimalsystems und mit der Ziffernfolge 1016 wird

der Dezimalwert 1610 dargestellt.

• Ungültige Ziffernfolge im Hexadezimalsystem: 1H016. Das ist eine

ungültige Ziffernfolge, denn im Hexadezimalsystem existiert die

Ziffer H nicht.




Beispiele mit Ziffernfolgen bei Zahlensystemen




Dezimalsystem

Das Dezimalsystem ist ein Zahlensystem mit folgenden Merkmalen:

• Ziffern: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. Diese Ziffern sind im

Dezimalsystem gültig.

• Basis: 10, da 10 verschiedene Ziffern existieren.

• Stellenwerte: Potenzen der Basis 10.

Das System: Im Dezimalsystem existieren die Ziffern 0 - 9. Mehr Ziffern

gibt es im Dezimalsystem nicht. Diese Ziffern werden eigentlich auch

arabische Ziffern genannt, da sie ursprünglich aus dem arabischen

Raum stammen und von den Europäern übernommen wurden.

Darauf aufbauend beruht das Dezimalsystem auf der Basis 10. Denn,

die Basis bestimmt die Anzahl der Ziffern im Zahlensystem und die

Ziffern 0 bis 9 ergeben 10 verschiedene Ziffern.

• Die Stellenwerte werden durch die Potenzen zur Basis gebildet,

um durch Multiplikation der Ziffer mit dem Stellenwert die

Wertigkeit der Ziffer zu erhalten. Dabei beginnt man mit der

Potenz 100. Für jede Stelle nach links wird der Exponent um 1

erhöht. Beispiele:

• Ziffernfolge 5: Ergibt 5, da 5 x 100 = 5 ist.




• Ziffernfolge 35: Ergibt 35, da 5 x 100 = 5 ist und 3 x 101 = 30 ist.

Die Werte 30 + 5 ergeben zusammen 35.

• Ziffernfolge 435: Ergibt 435, da 5 x 100 = 5 ist, 3 x 101 = 30 ist

und 4 x 102 = 400 ist. Die Werte 400 + 30 + 5 ergeben

zusammen 435.

Auf diese Weise kann man jeden beliebigen Wert im Dezimalsystem

abbilden. Vereinfacht ausgedrückt, nennt man die erste Stelle der

Ziffernfolge Einer, die nächste Stelle wird Zehner bezeichnet, die

nächste Stelle Hunderter, danach käme Tausender, Zehntausender etc.

Anders ausgedrückt, für jede Stelle multipliziert man die Ziffer mit 10.

Befindet sich die Ziffer an erster Position, entfällt die Multiplikation. Die

Ziffer an zweiter Stelle wird mit 10 multipliziert. Die Ziffer an dritter

Stelle wird mit 10 x 10 multipliziert. Die Ziffer an vierter Stelle mit 10 x

10 x 10 usw.

Auf das Dezimalsystem wird hier nicht weiter eingegangen da die

Beherrschung des Systems und seiner Rechenregeln vorausgesetzt

wird.




Dualzahlen - Das binäre Zahlensystem

Die Funktionsweise jedes Computers basiert auf dem Dualsystem. Der

Grund ist einfach. Ein Computer kann nur 2 Zustände erkennen.

Entweder es fließt Strom oder es fließt kein Strom. Anders ausgedrückt

kann ein Computer nur die beiden Zustände AN und AUS erkennen. Das

Zahlensystem wird als Dualsystem (nur 2 Zustände) oder Binärsystem

bezeichnen.

Eine speicherprogrammierbare Steuerung ist vom Grundprinzip her

auch ein Computer. Das Dualsystem hat folgende Merkmale:

• Ziffern: 0, 1. Andere Ziffern wären ungültig.

• Basis: 2, da nur 2 verschiedene Ziffern vorhanden sind.

• Stellenwerte: Potenzen der Basis 2

Das System: Im Dualsystem existieren nur die Ziffern 0 und 1. Andere

Ziffern gibt es in diesem Zahlensystem nicht.

Darauf aufbauend beruht das Dualsystem auf der Basis 2. Denn, die

Basis bestimmt die Anzahl der Ziffern im Zahlensystem und die Ziffern 0

und 1 ergeben 2 verschiedene Ziffern.

Um die Wertigkeit einer Ziffernfolge zu ermitteln, werden die




Stellenwerte durch die Potenzen zur Basis von 2 gebildet. Beim

Dualsystem beginnt man dabei mit der Potenz 20. Wie beim

Dezimalsystem wird für jede Stelle nach links der Exponent um 1

erhöht. Beispiele:


• Ziffernfolge 11: Ergibt die Dezimalzahl 3, da 1 x 20 = 1 ist und 1 x

21 = 2 ist. Die Werte 2 + 1 ergeben zusammen 3.

• Ziffernfolge 111: Ergibt die Dezimalzahl 7, da 1 x 20 = 1 ist, 1 x 21

= 2 ist und 1 x 22 = 4 ist. Die Werte 4 + 2 + 1 ergeben

zusammen 7.

Bei großen Zahlen hat man bei Dualzahlen eine sehr lange Ziffernfolge.

Um eine bessere Übersicht zu haben, teilt man große Dualzahlen in

Vierergruppen auf.

Beispiel: 0100 0111 0110 11012

Einerkomplement und Zweierkomplement (Darstellung negativer

Dualzahlen) sind unter Dualzahlen erklärt. Die Umrechnung von

Dualzahlen wird unter Dualzahlen umrechnen erklärt.




Tabelle mit den Dezimalzahlen 0 bis 15 und den entsprechenden

Dualzahlen

Umrechnung von Dualzahlen in Dezimalzahlen

Beispiel zur Umrechnung: Die Dualzahl 10102 entspricht der

Dezimahlzahl 1010. Diesen Zahlenwert erhält man, wenn man jede Ziffer

mit ihrem Stellenwert multipliziert und die erhaltenen Produkte addiert.

Am Beispiel der Dualzahl 10102 sieht das so aus: Die erste Stelle (von

rechts beginnend) ist die duale Null. Um diese ins Dezimalsystem




umzurechnen muss man diese Null mit ihrem Stellenwert multiplizieren:

0 x 20 = 0.

Dasselbe macht man nun mit der zweiten Stelle links vom Komma:

1 x 21 = 2.

Nun zur dritten Stelle: 0 x 22 = 0.

Nun noch das gleiche mit der vierten Stelle links vom Komma,

1 x 23 = 8.

Als nächstes addiert man die so erhaltenen Ergebnisse miteinander:

8 + 0 + 2 + 0 = 10.




Dualzahlen umrechnen

Positive Ganzzahlen nach Dezimalzahlen

umrechnen

Beim Rechnen von Dualzahlen und Dezimalzahlen hat man das Problem,

dass in beiden Zahlensystemen die Ziffern 0 und 1 vorkommen. Damit

man Dualzahlen von Dezimalzahlen unterscheiden kann, werden sie

unterschiedlich gekennzeichnet. Dualzahlen werden mit einer

tiefgestellten 2 gekennzeichnet, z.B. 1002. Alternativ könnte man

Dualzahlen auch mit dem tiefgestellten Zusatz dual kennzeichnen, z.B.

100dual. Dezimalzahlen werden einer tiefgestellten 10 gekennzeichnet,

z.B. 12510. Alternativ kann man Dezimalzahlen auch mit dem

tiefgestellten Zusatz dezimal kennzeichnen, z.B. 125dezimal.

Dualzahlen können in Dezimalzahlen umgerechnet werden. Ein Beispiel

zur Veranschaulichung der Umrechnung von Dualzahlen: Die Dualzahl

10112 soll in die Dezimalzahl umgerechnet werden.

Vorgehensweise: Zuerst multipliziert man die Ziffern mit dem

Stellenwert aus. Danach addiert man die Teilergebnisse.




In der Zeile Dualzahl sind die dualen Ziffern 0 oder 1 dargestellt. In der

Zeile "zu addierende Werte" sind die Dezimalwerte zu den dualen Ziffern

enthalten. Je nachdem, ob die duale Ziffer eine 0 oder 1 ist, erhält man

als Dezimalwert eine 0 oder einen anderen Dezimalwert. 0dual

multipliziert mit dem Stellenwert ergibt immer den Dezimalwert 0dezimal.

1dual multipliziert mit dem Stellenwert ergibt einen Wert und ist somit

abhängig von der Stelle der dualen Ziffer in der Ziffernfolge.

Der Stellenwert der dualen Ziffer 1dual in der 4. Spalte von rechts ist 23.

Möchte man die Wertigkeit dieser Ziffer ermitteln, muss man 1 · 23 oder

1 · 2 · 2 · 2 rechnen. Das Ergebnis wäre 8dezimal. Würde hier

stattdessen die Ziffer 0dual stehen, würde das 0dezimal ergeben. Denn,

0 · 23 = 0.

Tabelle mit den dazugehörigen Dezimalwerten für die Dualzahl

1111 11112

Die Wertigkeit einer Ziffer innerhalb einer Ziffernfolge im Dualsystem

nimmt von rechts nach links zu. Deutlich wird das anhand des Beispiels

mit der Dualzahl 1111 11112, dessen Dezimalwert 25510 ist.




In der Zeile Dualzahl ist wieder eine Dualzahl, in diesem Fall 1111

11112, dargestellt. Jede Ziffer in der Ziffernfolge hat, abhängig von der

Stelle in der Ziffernfolge, einen entsprechenden Wert, der als

Dezimalwert dargestellt werden kann.

Den Stellenwert der dualen Ziffer kann man in der Zeile Potenz

ablesen. Der Stellenwert beginnt (von rechts) mit 20 und mit jeder

weiteren Stelle nach links wird der Exponent um 1 erhöht, also 21, 22,

23 usw.

Die Stelle in der Ziffernfolge entscheidet im Grunde über die

Wertigkeit der Ziffer. Dabei ist die Ziffer ganz rechts die 1. Ziffer in der

Ziffernfolge und erhöht sich bei jeder Stelle nach links um 1.

Den Dezimalwert der dualen Ziffer kann man in der Zeile Zahlenwert

dezimal ablesen. Der Dezimalwert entspricht immer der dualen Ziffer,

multipliziert mit dem Stellenwert. Also 1 · 20, 1 · 21, 1 · 22 usw. Dabei

wird deutlich, dass der Dezimalwert sich mit jeder Stelle nach links

verdoppelt. 1, 2, 4, 8, 16, 32, 64 und 128. Das Ergebnis aller

Dezimalwerte zusammen ist 255dezimal.




Positive gebrochene Zahlen nach Dezimalzahlen

umrechnen

Man kann auch positive, gebrochene Dualzahlen nach Dezimalzahlen

umrechnen.

Vorgehensweise: Auch hierbei werden die Ziffern mit den Stellenwerten

ausmultipliziert. Danach werden die Teilergebnisse addiert. Zu beachten

ist dabei, dass die Stellenwerte der Dualzahlen vor dem Komma kleiner

als 1 sind und pro Stelle nach rechts um die Hälfte abnimmt. Die erste

Ziffer rechts vom Komma hat den Stellenwert 0,5, die zweite Ziffer

0,25, die dritte Ziffer 0,125 usw.

Eine gute Frage ist: Warum hat z.B. die erste Ziffer rechts vom Komma

einen Wert von 0,5 und die nächsten Ziffern jeweils die Hälfte? Die

Basis im Dualsystem ist 2 und spiegelt die Anzahl der Ziffern (0 und 1)

im Ziffernvorrat wieder. Der Stellenwert wird durch den Potenzen der

Basis 2 gebildet. Die erste Stelle links vom Komma hat den Stellenwert

20. Die erste Stelle rechts vom Komma beginnt mit 2-1. Der Exponent

ist also negativ. Für jede Stelle rechts vom Komma wird der negative

Exponent um 1 erhöht, also 2-2, 2-3, 2-4 usw. Wenn man z.B. die erste

Stelle rechts vom Komma betrachtet und die Potenz 2-1 ausrechnet,

dann erhält man 0,5 (1 : 2). Bei 2-2 erhält man 0,25 (1 : 22), bei 2-3 ist

das Ergebnis 0,125 (1 : 23) usw.

Man kann hier auch die Dezimalzahlen vergleichen. Hat man z.B. eine

Dezimalzahl 10,5, dann wird der Wert der ersten Ziffer rechts vom

Komma gebildet, indem man die Ziffer mit dem Stellenwert

multipliziert. Der Stellenwert im Dezimalsystem wird mit den Potenzen

der Basis 10 gebildet, also 10-1, 10-2, 10-3 usw. 10-1 ergibt 0,1. Diese




Zahl multipliziert man in diesem Beispiel mit 5 und erhält die

Dezimalzahl 0,5. Die prinzipielle Herangehensweise ist beim Dualsystem

gleich.

Ein Beispiel zur Veranschaulichung: Die Dualzahl 110.11 soll in eine

Dezimalzahl umgerechnet werden.

Positive Ganzzahlen von Dezimal nach Dual

umrechnen

Man kann natürlich nicht nur Dualzahlen nach Dezimal umrechnen,

sondern auch umgekehrt. Für die Umrechnung haben sich zwei

Verfahrensweisen etabliert. Die beiden Verfahren nennt man

Restwertalgorithmus und Subtraktion der Zweierpotenz. Beide

Verfahren unterscheiden sich dahingehend, dass die Ziffern der Dualzahl

Stück für Stück in unterschiedlichen Richtungen ermittelt werden. Beim

Restwertalgorithmus fängt man mit der 1. Ziffer rechts an und ermittelt

die jeweils nächste linke Ziffer. Bei der Subtraktion der Zweierpotenz

fängt man mit der 1. linken Ziffer an und ermittelt die jeweils nächste

rechte Ziffer.

Restwertalgorithmus: Bei diesem Verfahren dividiert man die

Dezimalzahl durch die Basis 2. Danach notiert man den Quotienten und

den Rest. Der Rest kann dabei entweder 0 oder 1 sein. Ein Rest von 1

ergibt sich bei positiven dezimalen Ganzzahlen, wenn diese nicht durch




die Basis von 2 teilbar sind. Das betrifft alle ungeraden positiven

Dezimalzahlen, also 3, 5, 7, 9 usw. Den Quotienten teilt man solange

durch die Basis und notiert den Rest, bis man den Quotienten 0 erhält.

Beispiel für Restwertalgorithmus anhand der Dezimalzahl 10010:

• 100 : 2 = 50, Rest 0: Ziffer für die 1. Stelle (ganz rechts)

• 50 : 2 = 25, Rest 0: Ziffer für die 2. Stelle






Das Ergebnis der Umrechnung mit dem Restwertalgorithmus ist:

11001002.

Subtraktion der Zweierpotenzen: Bei diesem Verfahren wird zuerst

von der Dezimalzahl die größtmögliche Zweierpotenz (x1) subtrahiert.

Danach notiert man die Ziffer 1 an die erste Stelle der Dualzahl. Als

nächstes wird vom Rest die nächst kleinere Zweierpotenz subtrahiert.

Ist das Ergebnis unter 0, notiert man eine 0 an die nächste Stelle der

Dualzahl. Ist das Ergebnis 1 oder größer, notiert man eine 1. Das

Verfahren wird so lange durchlaufen, bis man alle kleineren

Zweierpotenzen durch hat.

Beispiel für die Subtraktion der Zweierpotenz anhand der Dezimalzahl

10010:

• Größtmögliche Zweierpotenz von 100 ist: 26, 1 · 26 = 64

• Subtrahiere 64 von 100 = 36, 1 als erste Ziffer (ganz links)




• Nächstkleinere Zweierpotenz ist 25, 1 · 25 = 32

• Subtrahiere 32 von 36 = 4, 1 als nächste Ziffer


• Subtrahiere 16 von 4 = unter 0, 0 als nächste Ziffer



• Nächstkleinere Zweierpotenz ist 22, 1 · 22 = 4,

• Subtrahiere 4 von 4 = 0, 1 als nächste Ziffer





Das Ergebnis der Umrechnung durch Subtraktion der Zweierpotenzen

ist: 11001002.

Positive gebrochene Dezimalzahlen nach Dual

umrechnen

Positive gebrochene Dezimalzahlen können ebenfalls nach Dual

umgewandelt werden. Hierbei muss man die Stellen links vom Komma

und rechts vom Komma trennen. Die Stellen links vom Komma werden

wie bei positiven Ganzzahlen umgewandelt. Die Stellen rechts vom

Komma lassen sich nur umwandeln, wenn man sie aus der Summe der

negativen Potenzen 2-1, 2-2, 2-3 usw. bilden kann.




Näherungswerte bei der Umrechnung gebrochener

Dualzahlen in Dezimalzahlen

Nicht alle gebrochenen Dezimalzahlen lassen sich exakt in gebrochene

Dualzahlen darstellen. Das ist dann der Fall, wenn die Stellen rechts

vom Komma nicht aus der Summe der negativen Potenzen 2-1, 2-2, 2-3

usw. errechnen lassen. Häufig kann man lediglich einen Näherungswert

ermitteln und muss diese dann runden. Das bedeutet, eine gebrochene

Dezimalzahl von 0,5 ist in Dual darstellbar, weil die negative Potenz 2-1

= 0,5 (1 : 2) ist. Weitere negative Potenzen wären z.B.:

• 2-2 = 0,25 (1 : 22)

• 2-3 = 0,125 (1 : 23)

• 2-4 = 0,0625 (1 : 24)

• 2-5 = 0,03125 (1 : 25)

• 2-6 = 0,015625 (1 : 26)

• 2-7 = 0,0078125 (1 : 27)

Einige Beispiele zur Veranschaulichung, ob eine gebrochene Dezimalzahl

in Dual dargestellt werden kann.




Addieren - Die Additionsregeln bei Dualzahlen

Das Dualsystem ist ein Zahlensystem, mit dem wie bei Dezimalzahlen

addiert werden kann. Das Dezimalsystem beruht auf der Basis von 10,

das Dualsystem auf der Basis von 2. Die Frage ist nun: Wie addiert man

mit einem Zahlensystem, in dem nur die Ziffern 0 und 1 vorkommen?

Bei der schriftlichen Addition geht man im Grunde wie beim

Dezimalsystem vor. Das bedeutet:

• Man beginnt mit den Ziffern, die den kleinsten Wert haben.

• Die Ziffern, die den kleinsten Wert haben, stehen an 1. Stelle

rechts.

• Hat man die Addition der 1. Ziffern beendet, addiert man

stellenweise nach links, die nächsten Ziffern.

• Dabei kann es vorkommen, dass ein Übertrag gebildet wird. Im

Dezimalsystem entsteht ein Übertrag, wenn man z.B. 8+4 addiert.

In dem Fall würde man die 2 notieren und 1 als Übertrag bilden.

Im Dualsystem gibt es zwar nur die Zahlen 0 und 1, ein Übertrag

kann hier trotzdem gebildet werden. Das passiert, wenn man 1+1

rechnet. In dem Fall notiert man die 0 und 1 wird als Übertrag

gebildet.

Bei der Addition von Dualzahlen gibt es folgende Additionsregeln, die es

zu beachten gilt:

• 0 + 0 = 0

• 0 + 1 = 1

• 1 + 0 = 1

• 1 + 1 = 10, 1 + 1 ergibt 0 mit Übertrag 1 an die nächste Stelle

nach links




Additionsregeln bei Dualzahlen

Mehrere Dualzahlen addieren

Möchte man mehr als 2 Dualzahlen addieren, muss man wie folgt

vorgehen:

• Beispiel 1 + 1 + 1 = 11: Zunächst werden 1 + 1 addiert, man

notiert die 0 und 1 wird als Übertrag an die nächste Stelle nach

links gebildet. Man erhält also die Ziffernfolge 10. Als nächsten

Schritt addiert man die notierte 0 mit der dritten 1. Das Ergebnis

wäre 1. Zusammen mit dem Übertrag ist das Ergebnis 11.

Das System kann man natürlich auch bei mehr als 3 Ziffern anwenden.

• Beispiel: 1 + 1 + 1 + 1 = 100: Auch hier addiert man zunächst

1 + 1. Man notiert die 0 und 1 wird als Übertrag gebildet. Man

erhält die Ziffernfolge 10. Die 0 wird mit der dritten 1 addiert.

Man erhält zusammen mit dem Übertrag die Ziffernfolge 11.

Danach addiert man die 1 mit der vierten 1. Das Ergebnis ist 0

und 1 wird als Übertrag gebildet.

• Jetzt muss man aufpassen. Denn, an der zweiten Stelle befinden

sich nun 2x die Ziffern 1, die als Übertrag gebildet wurden. Auch

diese Ziffern müssen addiert werden. 1 + 1 ergibt 0 und 1 wird

als Übertrag an die dritte Stelle gebildet und man erhält als

Ergebnis der gesamten Berechnung 100.




Man kann sich das mit dem Übertrag auch wie folgt merken:

• Wenn 2 Ziffern mit der Zahl 1 addiert werden, wird der Übertrag

an der nächsten Stelle (2. Stelle) gebildet. Wenn 4 Ziffern mit der

Zahl 1 addiert werden, entsteht der Übertrag an der übernächsten

Stelle (3. Stelle). Werden 8 Ziffern mit der Zahl 1 addiert,

entsteht der Übertrag an der wiederum nächsten Stelle (4. Stelle).

Additionsregeln bei mehreren Dualzahlen

Addition mehrerer Ziffernfolgen

Eine Dualzahl besteht häufig nicht nur aus einer Ziffer, sondern aus

einer Ziffernfolge.

• Beispiel 1101 + 1110 = 11011: Man beginnt wieder mit der 1

+ 0 an der 1. Stelle (ganz rechts). Das Ergebnis wäre 1, ohne

Übertrag.

• Addiert man die Ziffern an der 2. Stelle 0 + 1, entsteht wieder

eine 1, ohne Übertrag.

• An der 3. Stelle der beiden Ziffernfolgen ist jeweils eine 1. Das

Ergebnis wäre eine 0 mit 1 als Übertrag an der 4. Stelle.




• Durch den Übertrag sind an der 4. Stelle 1 + 1 + 1 zu berechnen.

1 + 1 ergibt 0 mit Übertrag von 1 an der 5. Stelle. An der 4. Stelle

ist noch eine 1 übrig. Diese Ziffer wird mit der entstandenen 0

addiert. 0 + 1 ergibt 1 an der 4. Stelle

• An der 5. Stelle ist der Übertrag aus der Addition der 4. Stelle

übrig geblieben. Hier bedarf es keiner weiteren Addition und die 1

wird an der 5. Stelle notiert.

• Das Ergebnis der Addition: 1101 + 1110 = 11011.

Addition mehrerer Ziffernfolgen im Dualsystem

Als Gegenprobe kann man die Dualzahlen in Dezimalzahlen umrechnen

und das Ergebnis überprüfen.

• 1101 ist in Dezimal: 13


• 13 + 14 = 27


Das Ergebnis der Dualzahladdition ist richtig.

Addition gebrochener Dualzahlen

Man kann natürlich nicht nur ganze Dualzahlen addieren, sondern auch




gebrochene Dualzahlen. Die Additionsregeln bei gebrochenen

Dualzahlen sind dieselben wie bei ganzen Dualzahlen. Damit man eine

bessere Übersicht hat, ist es üblich, dass man bei der Addition von

Dualzahlen unterschiedlicher Längen die Dualzahl mit führenden Nullen

füllt, die weniger Stellen hat. Beispielsweise könnte man bei der

Addition der beiden Dualzahlen 1001.11 und 11.01 die Zahl 11.01 auch

mit 0011.01 darstellen.

• Beispiel: 1001.11 + 0011.01 = 1101.00: Wie bei den ganzen

Dualzahlen beginnt man mit den 1. Ziffern (ganz rechts). 1 + 1

ergibt 0 mit 1 als Übertrag.

• Durch den Übertrag sind an der 2. Stelle (1. Stelle rechts vom

Komma) wieder 2x die Zahlen 1 zu addieren. 1 + 1 ergibt wieder

0. Der Übertrag von 1 wird an die nächste Stelle übergeben, das

ist die 3. Stelle (1. Stelle links vom Komma).

• An der 1. Stelle links vom Komma sind, bedingt durch den

Übertrag, die Ziffern 1 + 1 + 1 zu addieren. Das ergibt 1 mit 1 als

Übertrag an der 4. Stelle (2. Stelle links vom Komma).

• An der 2. Stelle links vom Komma sind, wieder bedingt durch den

Übertrag, die Ziffern 1 + 1 zu addieren. Das ergibt 0 und die 1

wird als Übertrag an der 5. Stelle (3. Stelle links vom Komma)

gebildet.

• An der 3. Stelle links vom Komma werden die Ziffern 0 + 1

(entstand aus dem Übertrag) addiert. Das ergibt 1, diesmal ohne

Übertrag.

• An der 4. Stelle links vom Komma werden die Ziffern 1 + 0

addiert. Das ergibt wieder eine 1.

• Das Ergebnis der Addition: 1001.11 + 0011.01 = 1101.00.




Addition gebrochener Dualzahlen

Als Gegenprobe könnte man wieder die Dualzahlen in Dezimalzahlen

umrechnen und das Ergebnis überprüfen.

• 1001.11 ist in Dezimal: 9,75


• 9,75 + 3,25 = 13

• 1101.00 ist in Dezimal: 13

Das Ergebnis der Addition gebrochener Dualzahlen ist richtig.

Subtrahieren - Subtraktionsregeln bei

Dualzahlen

Das Dualsystem ist ein Zahlensystem, mit dem wie bei Dezimalzahlen

subtrahiert werden kann. Anders als beim Dezimalsystem beruht das

Dualsystem auf der Basis von 2. Dabei kommen nur die Ziffern 0 und 1

vor.

Bei der schriftlichen Subtraktion wird im Grunde genauso vorgegangen

wie beim Dezimalsystem. Das bedeutet, dass man dabei folgende

Rechenregeln anwendet:

• Man beginnt wie bei der Addition von Dualzahlen mit den Ziffern




mit dem kleinsten Wert.

• Die Ziffern mit dem kleinsten Wert befinden sich von rechts

gesehen an der 1. Stelle.

• Ist die Subtraktion der 1. Ziffern durchgeführt, subtrahiert man

stellenweise die nächsten Ziffern nach links.

• Bei der Subtraktion wird die Differenz zwischen dem

Subtrahenden und Minuenden ermittelt. Wenn der Minuend kleiner

(0) als der Subtrahend (1) ist, wird ein Übertrag an der nächsten

Stelle gebildet.

Bei der Subtraktion von Dualzahlen gibt es folgende Subtraktionsregeln,

die es zu beachten gilt:

• 0 - 0 = 0

• 0 - 1 = 1, mit Übertrag 1 an die nächste Stelle nach links

• 1 - 0 = 1

• 1 - 1 = 0

Subtraktion von Dualzahlen

Borrow-Bit: Subtraktion durch Borgen

Bei den Subtraktionsregeln gilt, dass bei 0 - 1 eine 1 notiert wird und 1

als Übertrag entsteht. Diesen Vorgang nennt man "Borgen", weil man

dabei ein Bit aus der nächsten Stelle "borgt". Das übertragene Bit wird

umgangssprachlich auch "Borrow-Bit" genannt, was aus dem Englischen




kommt und in etwa "geborgtes Bit" bedeutet.

Subtraktion mehrerer Ziffernfolgen

Dualzahlen bestehen in der Regel nicht nur aus einer Ziffer. Meistens

sind Dualzahlen als Ziffernfolgen anzutreffen. Diese können genauso mit

den Subtraktionsregeln subtrahiert werden.

• Beispiel 1110 - 111 = 111: Man beginnt mit der Subtraktion an

der 1. Stelle (ganz rechts). 0 - 1 ist 1 mit 1 als Übertrag.

• Durch den Übertrag sind an der 2. Stelle 1 - 1 - 1 zu berechnen. 1

- 1 ergibt 0. Dadurch bleibt 0 - 1 übrig. Das ergibt wieder 1 mit 1

als Übertrag.

• An der 3. Stelle sind wieder 1 - 1 - 1 zu berechnen. 1 - 1 ergibt

wieder 0 und 0 - 1 ergibt wieder eine 1 mit 1 als Übertrag.

• An der 4. Stelle rechnet man zum Schluss 1 - 1 (entstand durch

den Übertrag) und das ergibt 0.

• Das Ergebnis der Subtraktion: 1110 - 111 = 0111. Die führende 0

kann weggelassen werden und so entsteht als Ergebnis 111.

Subtraktion mehrerer Ziffernfolgen im Dualsystem




Man kann als Gegenprobe die Dualzahlen in Dezimalzahlen umrechnen

und das Ergebnis überprüfen.



• 14 - 7 = 7


Das Ergebnis der Dualzahlsubtraktion ist richtig.

Darstellung negativer Zahlen mit Most-Significant-Bit (MSB)

Bei der Subtraktion von dualen Zahlen hat man kein Problem, solange

der Minuend größer ist als der Subtrahend. Anders ausgedrückt, die

abzuziehende Zahl kleiner ist als die Grundzahl, von der subtrahiert

werden soll.

Ist der Subtrahend jedoch größer als der Minuend, dann ist das

Ergebnis eine negative Zahl. Man kennt das aus dem Dezimalsystem,

dass 5 - 8 = -3 ergibt. Es muss also einen Weg geben, negative Zahlen

im Dualsystem darzustellen. Eine Möglichkeit ist, die negative Zahl mit

dem Most-Significant-Bit darzustellen. Dabei wird das Bit dem höchsten

Stellenwert als Vorzeichenbit benutzt.

Wird z.B. für eine Ganzzahl ein Speicherbereich von 1 Byte (8 Bits)

reserviert, dann ist das Bit mit dem niedrigsten Stellenwert Bit 0 und Bit

7 das Bit mit dem höchsten Stellenwert. Demzufolge würde Bit 7 als

Vorzeichenbit benutzt werden. Bei eine Ganzzahl, für die ein

Speicherbereich von 2 Bytes reserviert werden, wäre Bit 15 das

Vorzeichenbit. Die Vorzeichenbits werden wie folgt dargestellt:

• Positive Zahl: 0




• Negative Zahl: 1

Eine Bitmuster 10000001 würde mit MSB demnach die negative

dezimale Zahl -1 darstellen. Ob ein Ergebnis negativ ist, erkennt man

bei der Berechnung der letzten Ziffern (ganz links). Bleibt ein Übertrag

(Borrow-Bit) übrig, ist das Ergebnis negativ und die 1 wird als MSB

notiert. Die Zwischenräume zwischen dem Ergebnis und MSB werden

mit 0 gefüllt.

• Beispiel 011 - 111 = 10000100: Man beginnt wieder mit den

Ziffern ganz rechts. 1 - 1 = 0.

• An der nächsten Stelle wird wieder 1 - 1 gerechnet. Das Ergebnis

ist wieder 0.

• An der dritten Stelle wird 0 - 1 gerechnet. Das Ergebnis ist 1 und

1 bleibt als Übertrag übrig.

• Man notiert die 1 als MSB und füllt die Zwischenbits mit 0.

• Das Ergebnis ist 10001000.

Darstellung negativer Zahlen mit MSB

Diese Art der Darstellung negativer Zahlen nennt man Vorzeichen und

Absolutbetrag. Dabei zeigt das MSB das Vorzeichen an, die restlichen

Ziffern zeigen die Zahl als Absolutbetrag an. Die Zahlendarstellung mit

Vorzeichen und Absolutbetrag kann man zwar in rechnergestützten




Systemen einsetzen. Es gibt hierbei aber einen großen Nachteil. Denn,

für Addition und Subtraktion braucht man 2 voneinander getrennte

Recheneinheiten. Es gibt daher noch die Möglichkeit, aus einer Dualzahl

ein Einerkomplement oder Zweierkomplement zu bilden, um negative

Dualzahlen darzustellen. Auch bei der Komplementbildung spielt das

MSB eine Rolle. Das Zweierkomplement wird dabei vom

Einerkomplement abgeleitet. Der Vorteil bei der Bildung des

Zweierkomplements ist, dass man Dualzahlen mittels Addition

subtrahieren kann.

Komplementbildung - Einerkomplement und

Zweierkomplement bilden

Wenn man sich eine Dualzahl mit einer Bitlänge von 8 Bits anschaut,

dann ist der darstellbare Bereich 00000000 - 11111111, womit man die

Dezimalwerte 0 - 255 darstellen würde. Was macht man aber, wenn

man negative Werte darstellen möchte? Eine Lösung ist, ein Bit für die

Darstellung des Vorzeichens zu benutzen, das Vorzeichenbit genannt

wird.

Das Vorzeichenbit sollte natürlich nicht irgendwo inmitten der

Ziffernfolge stehen, sondern entweder ganz links oder ganz rechts, so

dass man es schnell identifizieren kann.




Least Significant Bit

Wenn man die erste Bitstelle von rechts als Vorzeichenbit nimmt, nennt

man das Least Significant Bit, da diese Bitstelle die geringste Wertigkeit

hat. Deutlich wird das anhand der Tabelle. Bei der Benutzung der ersten

Bitstelle als Vorzeichenbit hat man allerdings das Problem, dass die

Darstellung der Ziffern nicht den Wertigkeiten entspricht. Beispiel: Man

beginnt mit der kleinsten Ziffer, der 1. Die Ziffer 1 links neben dem

Vorzeichenbit sollte die Zahl 1 darstellen. Die zweite Bitstelle hat jedoch

die Wertigkeit der Dezimalzahl 2. Es wären unnötige Rechenoperationen

nötig, um mit den korrekten Zahlen zu arbeiten.

Most Significant Bit

Das erste Bit von rechts eignet sich nicht besonders als Vorzeichenbit.

Daher nimmt man das erste Bit von links als Vorzeichenbit. Da diese

Bitstelle die höchste Wertigkeit hat, nennt man das Most Significant Bit.

Die Ziffern rechts vom MSB würden für die Darstellung der Zahlenwerte

genutzt werden. Hierbei wird das MSB wie folgt eingesetzt:

• Positive Zahlen: MSB = 0

• Negative Zahlen: MSB = 1

Eine Bitfolge 10000001 würde die negative Dezimalzahl -1 darstellen,




da MSB = 1 ist. Diese Art der Zahlendarstellung nennt man Vorzeichen

und Absolutbetrag, da das MSB das Vorzeichen darstellt und die übrigen

Zahlenwerte den Absolutbetrag. Hierbei stößt man allerdings wieder auf

ein Problem. Für Addition und Subtraktion benötigt man voneinander

getrennte Recheneinheiten. Daher hat sich die Komplementbildung mit

Einerkomplement und Zweierkomplement etabliert.

Einerkomplement bilden

Das Einerkomplement wird gebildet, wenn man alle Ziffern negiert. Aus

der Ziffer 0 wird 1, aus der 1 wird 0. Die Darstellung der Dezimalzahl -8

im Einerkomplement wäre 1111 0111. Allerdings hat man auch hier

wieder ein Problem. Denn, betrachtet man die Speicherlänge von 8 Bits,

dann kann man damit "normalerweise" 256 verschiedene Zahlenwerte

(0 - 255) darstellen. Betrachtet man aber die darstellbaren Zahlenwerte

im Einerkomplement, dann befinden sich die Zahlenwerte im Bereich

-127 (10000000) bis +127 (01111111). Wenn man 2 x 127

multipliziert, ergibt das 254, plus die 0, ergibt 255 verschiedene

Zahlenwerte. Wo ist der 256. Zahlenwert geblieben? Eine Zahl muss

doppelt vorkommen. Und das ist die 0. Im Einerkomplement kann man

für die 0 die Dualzahlen 00000000 oder 11111111 benutzen. Es gäbe

eine positive und eine negative 0. Daher wird vom Einerkomplement




das Zweierkomplement abgeleitet, um eine Eindeutigkeit zu

gewährleisten.

Zweierkomplement bilden

Das Zweierkomplement wird wie folgt gebildet:

• Bilden des Einerkomplements durch negieren aller Ziffern.

• Addition von 1 zum Einerkomplement.

Die negative Zahl -8 hätte im Zweierkomplement folgendes Bitmuster:

11111000. Dadurch erhöht sich auch der darstellbare Zahlenbereich um

1, da die Null nicht mehr doppelt vorkommt. So kann z.B. bei einem

Speicherbereich mit 8 Bits die Zahlenwerte -128 bis +127 darstellen.

Dualzahlen durch Addition des Zweierkomplements

subtrahieren

Nachdem man ein Zweierkomplement gebildet hat, kann man eine

Dualzahl mit dem Zweierkomplement addieren und auf diesem Wege

subtrahieren. Diesen Vorgang nennt man Subtrahieren durch Addition

des Zweierkomplements.

Beispiel: Die Dualzahl 1001 (910) soll von der Dualzahl 1111 (1510)




subtrahiert werden. Das Ergebnis ist auf jeden Fall positiv, da der

Minuend größer ist als der Subtrahend.

• 1. Schritt: Einerkomplement bilden: 0110

• 2. Schritt: Mit 1 Addieren: 0111

• Zweierkomplement ist: 0111

Jetzt kann man 1111 + 0111 rechnen, um 15 - 9 auszurechnen. Dabei

kann ein Überlauf entstehen, der gestrichen wird. Verbleiben führende

Nullen, können diese ebenfalls gestrichen werden.

Das Ergebnis der Berechnung ist 110. Diese Zahl entspricht Dezimal 6.

15 - 9 ist 6. Das Ergebnis stimmt.

Beispiel mit negativem Ergebnis

Bei diesem Beispiel soll diesmal so subtrahiert werden, dass ein

negatives Ergebnis entsteht. Die Zahl 1111 (1510) soll von 1001 (910)

subtrahiert werden.

• 1. Schritt: Einerkomplement bilden: 0000

• 2. Schritt: Mit 1 Addieren: 0001

• Zweierkomplement ist: 0001




Jetzt kann man die 1001 + 0001 rechnen. Das Ergebnis 1010. Das

Ergebnis muss wieder rekomplementiert werden, um den Absolutwert

der negativen Zahl zu erhalten.

• Einerkomplement bilden: 0101

• Mit 1 addieren: 0110

• Das Ergebnis der negativen Zahl ist -6.

Ist das Ergebnis eine positive Zahl, wird das Ergebnis nicht

rekomplementiert, da die Zahl bereits positiv und somit der

Absolutbetrag ist. Ist das Ergebnis negativ, muss man eine

Rekomplementierung vornehmen, um den Absolutbetrag zu ermitteln.




Multiplizieren - Multiplikationsregeln bei

Dualzahlen

Die Basis eines Zahlensystems zeigt an, welche Ziffern im Ziffernvorrat

des Zahlensystems existieren. Im Dualsystem existieren nur die Ziffern

0 und 1. Daher basiert das Dualsystem auf der Basis von 2. Wie bei

Dezimalzahlen kann man auch im Dualsystem Zahlen multiplizieren. Es

ist sogar einfacher als im Dezimalsystem, da man nur die Ziffern 0 und

1 hat und daher nur diese beiden Ziffern multiplizieren kann.

Möchte man schriftlich Dualzahlen multiplizieren, geht man vom Prinzip

her genauso vor wie bei Dezimalzahlen. Das bedeutet:

• Man schreibt beide Ziffernfolgen, getrennt von einem Malzeichen,

nebeneinander auf.

• Danach multipliziert man jede Ziffer auf der rechten Seite mit

jeder Ziffer auf der linken Seite.

• Anders als im Dezimalsystem muss man dabei nicht Ziffer für

Ziffer multiplizieren. Man kann jede Ziffer auf der rechten Seite

mit der gesamten Ziffernfolge auf der linken Seite multiplizieren.

Das ist eine erhebliche Vereinfachung, da man sich keine

Überträge merken muss, die bei der Multiplikation im

Dezimalsystem entstehen.

• Die Zwischenergebnisse werden dem Stellenwert entsprechend

jeweils nach links versetzt untereinander aufgeschrieben.

• Zum Schluss addiert man alle Zwischenergebnisse zusammen und

erhält das Ergebnis der Multiplikation. Hierfür muss man die

Addition von Dualzahlen beherrschen.

Beim Multiplizieren von Dualzahlen muss man folgende




Multiplikationsregeln beachten:

• 0 · 0 = 0

• 0 · 1 = 0

• 1 · 0 = 0

• 1 · 1 = 1

Multiplikation von Dualzahlen

Ziffernfolgen multiplizieren bei Dualzahlen

Dualzahlen bestehen meistens nicht nur aus einer Ziffer, sondern aus

Ziffernfolgen.

• Beispiel 101 · 101 = 11001: Man multipliziert zunächst jede

Ziffer auf rechten Seite mit der Ziffernfolge auf der linken Seite

und schreibt die Zwischenergebnisse untereinander auf.

• Zu beachten ist dabei, dass die Zwischenergebnisse dem

Stellenwert entsprechend, jeweils nach links versetzt, angeordnet

sind.

• 1 · 101 = 101. Die Ziffernfolge wird notiert.

• 0 · 101 = 000. Die Ziffernfolge wird um eine Stelle nach links

versetzt notiert.

• 1 · 101 = 101. Die Ziffernfolge wird wieder um eine Stelle nach

links versetzt notiert.




• Zum Schluss werden die Ziffernfolgen addiert.

• Das Ergebnis der Multiplikation: 101 · 101 = 11001.

Multiplikation von Ziffernfolgen im Dualsystem

Man kann als Gegenprobe die Dualzahlen in Dezimalzahlen umrechnen

um zu überprüfen, ob das Ergebnis richtig ist.


• 5 · 5 = 25


Das Ergebnis der Multiplikation ist richtig.

Multiplikation gebrochener Dualzahlen

Gebrochene Dualzahlen lassen sich ebenso mit diesem Verfahren

multiplizieren. Bei gebrochenen Dualzahlen muss man beachten, dass

man das Komma richtig setzt. Hierbei gibt es mehrere Möglichkeiten.

Eine Möglichkeit ist, die Anzahl der Nachkommastellen beider

Ziffernfolgen zu addieren. Danach zählt man beim Ergebnis der Anzahl

entsprechend von rechts nach links die Ziffern und setzt das Komma an




die Stelle.

• Beispiel für die Multiplikation der Ziffernfolgen 11.1 · 10.1

= 1000.11: Jede Ziffer auf der rechten Seite wird mit der

gesamten Ziffernfolge auf der linken Seite multipliziert und das

Zwischenergebnis wird dem Stellenwert entsprechend notiert.

• 1 · 111 = 111

• 0 · 111 = 000

• 1 · 111 = 111

• Zum Schluss werden die Ziffernfolgen addiert.

In diesem Beispiel ist die Anzahl der Nachkommastellen beider

Ziffernfolgen 2. Also wird das Komma nach der 2. Ziffer von rechts nach

links zählend gesetzt.

Multiplikation gebrochener Dualzahlen

Zur Überprüfung kann man die Dualzahlen in Dezimalzahlen

umrechnen.



• 3,5 · 2,5 = 8,75


Das Ergebnis der Multiplikation gebrochener Dualzahlen ist richtig.




Dividieren - Division im Dualsyste

Dualzahlen beruhen auf der Basis von 2. Denn, der Ziffernvorrat kennt

nur die Ziffern 0 und 1. Man kann Dualzahlen wie bei Dezimalzahlen

dividieren. Allerdings gelten hier dieselben Einschränkungen wie bei

Dezimalzahlen. Das bedeutet:

• 0 geteilt durch 0 ist nicht definiert.

• 0 geteilt durch 1 (oder irgendeine andere Zahl) ergibt immer 0.

• 1 geteilt durch 0 ist ebenfalls nicht definiert.

• 1 geteilt durch 1 ergibt 1.

Division von Dualzahlen

Um das Ergebnis einer Division zu erhalten, teilt man den Dividenden

durch den Divisor und erhält als Ergebnis den Quotienten.

Bei der schriftlichen Division von Dualzahlen geht man im Grunde

genauso vor wie bei Dezimalzahlen. Bei Dualzahlen kommt die

Besonderheit hinzu, dass man nur die Ziffern 0 und 1 hat. Daher geht

man beim Dividieren von Dualzahlen wie folgt vor:

• Man beginnt mit der höchsten Stelle des Dividenden, holt diese

Ziffer runter und prüft, ob der Divisor kleiner oder gleich groß ist.




• Ist der Divisor kleiner oder gleich groß, notiert man eine 1 an die

Stelle des Quotienten.

• Man subtrahiert den Divisor von der Ziffer bzw. Ziffernfolge, die

nächste Stelle des Dividenden wird runtergeholt und es wird

wieder geprüft, ob der Divisor kleiner ist.

• Ist der Divisor größer als die Ziffer bzw. der Ziffernfolge, notiert

man eine 0 an die Stelle des Quotienten. In diesem Fall wird die

nächste Ziffer des Dividenden angehängt, ohne dass man den

Divisor von der Ziffer bzw. Ziffernfolge subtrahiert.

Diese Art der Division nennt man auch fortgesetzte Subtraktion des

Divisors vom Dividenden. Das Ergebnis (Quotient) wird dabei

stellenweise, von links nach rechts, gebildet. Führende Nullen beim

Dividenden, Divisor und Quotienten können entfernt werden.

• Beispiel 11 : 1 = 11: Man holt vom Dividenden die erste Ziffer

runter.

• Man prüft, ob der Divisor kleiner oder gleich groß ist bzw.

enthalten ist. Das ist hier der Fall.

• Man notiert die 1 beim Quotienten.

• Man subtrahiert die Ziffer und holt die nächste Ziffer vom

Dividenden. Das ist in diesem Fall wieder die 1.

• Man prüft wieder, ob der Divisor enthalten ist. Das ist hier erneut

der Fall.

• Man notiert die 1 beim Quotienten.

• Das Ergebnis der Division 11 : 1 = 11




Schriftliche Division von Dualzahlen

Als Gegenprobe kann man die Dualzahlen in Dezimalzahlen umrechnen.

• 11 in Dezimal ist: 3

• 1 in Dezimal ist: 1

• 3 : 1 = 3

Das Ergebnis der Division ist richtig.

Beispiel 1111 : 101

Damit man beim Quotienten keine führenden Nullen erhält, kann man

auch gleich die Ziffernfolge vom Dividenden runterholen, die größer

oder gleich als der Divisor ist.

• Beispiel 1111 : 101 = 11: Würde man lediglich die erste Ziffer

vom Dividenden runterholen, wäre die erste Ziffer des Quotienten

0, da 101 nicht kleiner oder gleich groß ist als 1.

• Dasselbe trifft auf die Ziffernfolge 11 zu.

• In dem Fall kann man gleich die Ziffernfolge 111 runterholen,

denn 101 ist kleiner als 111. Man notiert die 1 beim Quotienten.

• Das Ergebnis der Subtraktion ist 010 bzw. 10 (ohne führende 0).

• Man holt die nächste Ziffer vom Dividenden runter und erhält 101.

• Diese Ziffernfolge ist gleich groß wie 101, daher notiert man

wieder eine 1 beim Quotienten.

• Der Vollständigkeit halber subtrahiert man 101 von 101 und erhält




0.

• Es sind keine weiteren Ziffern zum Runterholen vorhanden.

• Das Ergebnis der Division: 1111 : 101 = 11.

1 1 1 1 : 1 0 1 = 1 1- 1 0 1= 0 1 0 1- 1 0 1= 0 0 0

Die Dualzahlen werden in Dezimalzahlen umgewandelt, um eine

Gegenprobe durchzuführen.

• 1111 ist Dezimal: 15


• 15 : 5 = 3


Das Ergebnis der Division ist richtig.




Gebrochene Dezimalzahlen

Man kann gebrochene Dezimalzahlen in gebrochene Dualzahlen

umwandeln. Allerdings gibt es hier einige Einschränkungen. Zunächst

einmal muss man die Ganzzahlen (Zahlen links vom Komma) trennen.

Die Ganzzahlen kann man ganz gewöhnlich in Dualzahlen umrechnen.

Die Ziffernfolge rechts vom Komma kann man nicht immer exakt

berechnen. Häufig kann man nur einen Näherungswert ermitteln.

Exakt berechnen lassen sich die Stellen rechts vom Komma, wenn man

die Zahl aus der Summe der negativen Potenzen (2-1, 2-2, 2-3, 2-4 usw)

bilden kann. Lässt sich die Zahl nicht aus der Summe der negativen

Potenzen bilden, kann man nur einen Näherungswert ermitteln und

danach runden. Einige Beispielwerte für negative Potenzen:

• 2-1 = 0,5 (1 : 21)

• 2-2 = 0,25 (1 : 22)

• 2-3 = 0,125 (1 : 23)

• 2-4 = 0,0625 (1 : 24)

• 2-5 = 0,03125 (1 : 25)

• 2-6 = 0,015625 (1 : 26)

• 2-7 = 0,0078125 (1 : 27)

Das bedeutet in der Praxis, dass man z.B. folgende Zahlen in

Dualzahlen umrechnen kann:

• 0,5: Ist die Potenz 2-1




• 0,75: Ist die Summe der Potenzen 2-1 und 2-2

• 0,0703125: Ist die Summe der Potenzen 2-4 und 2-7

Die Nachkommastellen gebrochener Dezimalzahlen werden wie folgt

umgewandelt:

• Das Ergebnis wird stellenweise von links nach rechts ermittelt.

• Man multipliziere die gebrochene Dezimalzahl, inkl. dem Komma

und der 0 davor, mit der Zahl 2.

• Ist nach dem Multiplikationsvorgang die Ziffer vor dem Komma

eine 0, notiert man eine 0 zum Ergebnis.

• Ist das Ergebnis >=1, notiert man eine 1 zum Ergebnis und zieht

die 1 von der Zahl ab, so dass wieder eine 0 vor dem Komma

steht.

• Danach fährt man wieder mit Schritt 2 fort, also Multiplikation mit

2 usw.

• Diesen Vorgang wiederholt man solange, bis die gewünschte

Genauigkeit erreicht ist oder bis der Rest 0 ist oder bis sich der

Rest wiederholt.

Beispiel, um die Dezimalzahl 0,7578125 in Dual umzurechnen:




Das Ergebnis der Umrechnung: 0,757812510 = 0,11000012

0,757812510 setzt sich zusammen aus: 0,510 (2-1

) + 0,2510 (2-2

) +

0,007812510 (2-7

)

Beispiel für eine nicht exakt in Dual darstellbare gebrochene

Dezimalzahl

Die Dezimalzahl 0,876 soll in Dual umgerechnet werde




Man kann die Umrechnung der gebrochenen Dezimalzahl 0,876 weiter

durchführen. Bei diesem Beispiel wurde mit der 32. Nachkommastelle




aufgehört, was einem Näherungswert von 0,87599999993108210

entspricht. Die Dualzahl hierfür wäre

0,111000000100000110001001001101112. Der Dezimalwert von

0,876 ist zwar nicht exakt darstellbar, allerdings hat man einen sehr

guten Näherungswert erreicht.




Gebrochene Dualzahlen multiplizieren

Im Dualsystem lassen sich gebrochene Dualzahlen, bzw. die

Nachkommastellen einer Dualzahl, genauso multiplizieren wie

Ganzzahlen. Hierfür sind Kenntnisse über Multiplikation von Dualzahlen

sowie Addition von Dualzahlen notwendig. Man muss dabei

berücksichtigen, dass nicht alle gebrochenen Dezimalzahlen in

gebrochene Dualzahlen umrechnen lassen. Vielfach kann man nur einen

Näherungswert ermitteln. Das ist dem Umstand zu verdanken, dass die

Basis im Dezimalsystem 10 ist und im Dualsystem 2. Daher kann man

im Dualsystem nur Nachkommastellen exakt darstellen, die aus der

Summe der negativen Potenzen (2-1 bis 2-n) gebildet werden können.

Beispielsweise kann man die Zahl 0,75 exakt als Dualzahl darstellen, da

die Zahl aus 0,5 (2-1) + 0,25 (2-2) gebildet wird. Diese Zahlen

entsprechen Dual 0.1 (0,5) und 0.01 (0,25). Bei 0,876 kann man nur

einen Näherungswert ermitteln.

Multipliziert werden Dualzahlen genauso wie Dezimalzahlen. Hierbei hat

man sogar eine Vereinfachung, da nur die Ziffern 0 und 1 vorkommen.

Man geht dabei so vor, dass man jede Ziffer auf der rechten Seite mit

der gesamten Ziffernfolge auf der linken Seite multipliziert und

stellenversetzt untereinander aufschreibt. Zum Schluss addiert man die

Ziffern nach den Regeln der Addition für Dualzahlen.

Beim Multiplizieren von gebrochenen Dualzahlen muss man überlegen,

wie man mit den Kommastellen umgeht, bzw. nach der Berechnung das

Komma an die richtige Stelle setzt. Hierbei gibt es folgende

Möglichkeiten.




• Man zählt die Nachkommastellen beider Ziffernfolgen, zählt beim

Ergebnis von rechts nach links die Ziffern und setzt das Komma

an die entsprechende Stelle. Das ist die einfachste Variante.

• Man versetzt vor der Berechnung das Komma in beiden

Ziffernfolgen nach rechts, so dass die beiden Kommas entfallen.

Wenn z.B. die linke Ziffernfolge 1.110011 ist und die rechte

Ziffernfolge 1.11, dann wird aus der linken Ziffernfolge 1110011

und aus der rechten Ziffernfolge 111. Diese beiden Ziffernfolgen

werden multipliziert. Beim Ergebnis muss man dann wieder das

Komma von rechts nach links zählend um die entsprechende

Anzahl versetzen. Hierbei muss man natürlich beide Ziffernfolgen

berücksichtigen. Hat man wie in diesem Beispiel das Komma in

der linken Ziffernfolge um 6 Stellen, in der rechten Ziffernfolge

um 2 Stellen versetzt, ergibt das insgesamt eine

Nachkommastelle von 8.

• Eine andere Möglichkeit ist, das Komma in beiden Ziffernfolgen

nach rechts zu versetzen, so dass beide Kommas erneut entfallen.

Danach nimmt man sich den Anteil beider Ganzzahlen und

multipliziert diese, so dass man weiß, wie viele Stellen der Anteil

der Ganzzahlen hat. Danach multipliziert man beide kompletten

Ziffernfolgen. Durch die Nebenrechnung weiß man, wie viele

Ziffern der Anteil der ganzen Zahlen hat. Dann zählt man von

links nach rechts und setzt das Komma an die entsprechende

Stelle.

Beispiel 1: Die beiden Dualzahlen 11.1 und 11.1 sollen

multipliziert werden.

• Man nimmt rechts die 1. Ziffer und multipliziert diese mit der

gesamten Ziffernfolge auf der linken Seite. Die Zahl 111 wird




aufgeschrieben.

• Der selbe Vorgang wird auf die 2. und 3. Ziffer angewendet, nur

mit dem Unterschied, dass die Ziffernfolge 111 jeweils

stellenversetzt untereinander aufgeschrieben wird.

• Danach addiert man die drei Ziffernfolgen.

• Die Anzahl der Nachkommastellen beider Ziffernfolgen ist 2.

Daher wird beim Ergebnis das Komma so gesetzt, dass 2

Nachkommastellen entstehen.

Bei Bedarf kann man die Dualzahlen in Dezimalzahlen umrechnen und

das Ergebnis überprüfen.


• 3,5 · 3,5 = 12,25

• 1100.01 ist in Dezimal: 12,25

Das Ergebnis stimmt.

Beispiel 2: Die beiden Dualzahlen 1.110011 und 1.11 sollen

multipliziert werden.

• Zuerst werden in beiden Ziffernfolgen die Kommas nach rechts

verschoben, so dass diese entfallen.

• In der ersten Ziffernfolge wird das Komma um 6 Stellen nach

rechts verschoben.




• In der zweiten Ziffernfolge wird das Komma um 2 Stellen nach

rechts verschoben.

• Insgesamt ergibt das eine Nachkommastelle von 8.

• Danach werden die beiden Ziffernfolgen nach den Regeln der

Multiplikation von Dualzahlen miteinander multipliziert.

Nachdem die beiden Ziffern miteinander multipliziert worden sind, muss

das Komma so gesetzt werden, dass 8 Nachkommastellen vorhanden

sind. Als Gegenprobe werden die Dualzahlen wieder in Dezimalzahlen

umgewandelt.

• 1.110011 ist in Dezimal:1,796875


• 1,796875 · 1,75 = 3,14453125

• 11.00100101 ist in Dezimal: 3,14453125

Das Ergebnis der Multiplikation stimmt.

Beispiel 3: Die gebrochenen Dualzahlen 1101.1101 und

101.101 sollen miteinander multipliziert werden

• In der linken Ziffernfolge wird das Komma um 4 Stellen nach

rechts verschoben.

• In der rechten Ziffernfolge wird das Komma um 3 Stellen nach




rechts verschoben.

• Diesmal wird mit den ganzzahligen Anteilen zuerst eine

Nebenrechnung durchgeführt, damit man weiß, wie viele Ziffern

das Ergebnis links vom Komma hat.

Nebenrechnung: 1101 · 101 = 1000001. Das sind insgesamt 7 Stellen.

Laut Nebenrechnung hat das Ergebnis 7 Stellen vor dem Komma. Daher

wird das Komma so gesetzt, dass der ganzzahlige Anteil 7 Stellen hat.

Aus 10011011011001 wird 1001101.1011001. Als Gegenprobe werden

wieder die Dualzahlen in Dezimalzahlen umgewandelt.

• 1101.1101 ist in Dezimal: 13,8125

• 101.101 ist in Dezimal: 5,625

• 13,8125 · 5,625 = 77,6953125

• 1001101.1011001 ist in Dezimal: 77,6953125

Das Ergebnis der Multiplikation gebrochener Dualzahlen stimmt.




Beispiel 4: Multiplikation der Dualzahlen 11.1110111 und

111.111011

Kleine Übungsaufgabe:

• Setzen Sie das Komma an die richtige Stelle.

• Wandeln Sie die Dualzahlen in Dezimalzahlen um.

• Prüfen Sie, ob das Ergebnis stimmt.




Dualsystem in Step7

Ein Computer benutzt als Zahlensystem das Dualsystem, in dem nur die

Ziffern 0 und 1 vorkommen. Eine SPS ist im Grunde ebenfalls ein

Computer. Nun steht man vor dem Problem, dass man Zahlen

unterschiedlicher Längen in einer SPS darstellen muss. Hierbei hängt es

von der Bitlänge ab, welchen Zahlenumfang man darstellen kann.

Beispiele:

• Hat man nur 1 Bit zur Verfügung, kann man nur 2 Ziffern

darstellen. 0 und 1.

• Hat man 2 Bits zur Verfügung, kann man bereits 4 Ziffern

darstellen. 00, 01, 10, 11. In Dezimal umgerechnet wären das die

Zahlen 0, 1, 2 und 3.




Übersicht über Dualzahlen bei einer Bitlänge von 4 Bits. Der darstellbare

Zahlenumfang wäre in diesem Fall 0000 - 1111. Das wären in Dezimal

die Zahlen 0 - 15.




Mit 8 Bits, das zusammengefasst umgangssprachlich als 1 Byte oder 1

Buchstabe bezeichnet wird, kann man einen Zahlenumfang 00000000 -

11111111 darstellen. Dezimal wären das die Zahlen 0 - 255.

Ein Wort besteht aus mindestens 2 Buchstaben. In der Digitaltechnik

bedeutet das, dass ein Wort sich aus 2 Bytes zusammensetzt, was einer

Bitlänge von 16 entspricht. Mit 2 Bytes kann man einen Zahlenumfang

von 0000000000000000 - 1111111111111111 darstellen. Dezimal

wären das die Zahlen 0 - 65535.

Darstellung negativer Zahlen: Einerkomplement, auch 1er-

Komplement genannt

Bisher wurden nur die darstellbaren Zahlen größer oder gleich 0

betrachtet. Eine Möglichkeit, negative Zahlen darzustellen, ist das

Einerkomplement. Hierbei wird das Bit mit dem höchsten Stellenwert als

Vorzeichenbit reserviert. Hat man z.B. für eine Zahl einen

Speicherbereich von 1 Byte (Bit 0 - Bit 7), dann fungiert Bit 7 als

Vorzeichenbit. Das Bit wird auch Most-Significant-Bit (MSB) bezeichnet.

Die übrigen Ziffern (rechts vom Vorzeichenbit) stellen den Zahlenwert

dar. Ist das Vorzeichenbit eine 0, dann ist stellt die Ziffernfolge rechts

vom Vorzeichenbit eine positive Zahl dar.

• Beispiel für die positive Dezimalzahl 8: 00001000.




Möchte man negative Zahlen darstellen, kommt das Einerkomplement

ins Spiel. Dabei wird das Vorzeichenbit auf 1 gesetzt, womit klar wird,

dass es sich dabei um eine negative Zahl handelt. Die übrigen Ziffern

rechts vom Vorzeichenbit, werden negiert. Das bedeutet, alle dualen

Ziffern mit 0 werden zu 1, alle dualen Ziffern mit 1 werden zu 0.

• Beispiel für die negative Dezimalzahl -8: 11110111.

Dadurch, dass ein Bit quasi "verloren" geht, verkürzt sich der

darstellbare Zahlenraum. Dafür kann man sowohl positive als auch

negative Zahlen darstellen. Bei einem Speicherbereich von 8 Bits würde

das bedeuten, dass 7 Bits übrig bleiben und damit kann man einen

Zahlenraum 10000000 - 011111111 darstellen, was Dezimal -127 bis

+127 wäre.

Die Darstellung mit dem Einerkomplement hat einen Nachteil. Für die

Zahl 0 gibt es 2 Darstellungsmöglichkeiten. Eine positive 0 (00000000)

und eine negative 0 (11111111). Hier kann man das Einerkomplement

auf das Zweierkomplement erweitern.

Zweierkomplement, auch 2er-Komplement genannt

Damit man das Problem mit den 2 möglichen Darstellungen für die 0

ausschließt, hat man ein Verfahren entwickelt, das Zweierkomplement

genannt wird. Dabei geht man wie folgt vor.

• Zuerst wird das Einerkomplement gebildet.

• Zum Einerkomplement wird die duale Zahl 1 addiert.

Beispiel für die positive Zahl 8: 00001000

• Für die negative Darstellung Einerkomplement bilden: 11110111

• 11110111 + 1 addieren: 11111000




Die Darstellung der negativen Zahl -8 im Zweierkomplement wäre:

11111000.

Beispiel mit der Dezimalzahl 5

• Positive Dezimalzahl in Dual: 0101

• Einerkomplement bilden: 1010

• Die Zahl 1 addieren: 1011

• Zweierkomplement für die negative Dezimalzahl -5: 1011

Zusammenfassung zur Bildung des Zweierkomplements

• Das Bit mit dem höchsten Stellenwert kennzeichnet das

Vorzeichen.

• Ist das Vorzeichenbit 0, ist es eine positive Zahl.

• Ist das Vorzeichenbit 1, ist die Zahl negativ.

• Die größtmögliche positive Zahl wird dargestellt, indem man das

Vorzeichenbit auf 0 setzt und die übrigen Ziffern auf 1.

• Die größtmögliche negative Zahl wird dargestellt, indem man das

Vorzeichenbit auf 1 setzt und die übrigen Ziffern auf 0.

Zur Veranschaulichung zwei Tabellen mit positiven und negativen Zahlen

im Dualsystem bei einem Speicherbereich von 4 Bits.




Hexadezimalsystem

In der Informationstechnologie wird das Dualsystem verwendet, um

damit Rechenoperationen durchzuführen. Das Dualsystem hat allerdings

einen großen Nachteil. Selbst für kleine Zahlen werden riesige Bitlängen

benötigt, z.B. 11111111 für die Dezimalzahl 255. Damit man mit

möglichst wenig Ziffern große Zahlenwerte darstellen kann, hat sich das

Hexadezimalsystem etabliert. Das Zahlensystem hat dabei folgende

Merkmale:

• Ziffern: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F. Andere Ziffern

sind ungültig.

• Basis: 16, da 16 verschiedene Ziffern existieren.

• Stellenwerte: Potenzen der Basis 16

Die Ziffern A - F haben dabei in Dezimal umgerechnet folgende Werte:

• A: 10

• B: 11

• C: 12

• D: 13

• E: 14

• F: 15

Das System: Im Hexadezimalsystem existieren 16 verschiedene

Ziffern, 0 - 9 und A - F. Andere Ziffern in der Ziffernfolge würde die Zahl

ungültig machen.

Die Basis eines Zahlensystems bestimmt die Anzahl unterschiedlicher

Ziffern. Da im Hexadezimalsystem 16 verschiedene Ziffern existieren,

ist die Basis 16.




Eine Hexadezimalzahl besteht natürlich meistens nicht nur aus einer

Ziffer, sondern aus einer Ziffernfolge. Daher muss man wissen, wie die

Wertigkeit einer Ziffernfolge in der Ziffernfolge ist. Vergleicht man

hierfür z.B. die Dezimalzahl 56, dann betrachtet man die Ziffer 5 auch

nicht als 5 sondern als den Wert von 50. Nach demselben Prinzip kann

man die Wertigkeit von Hexadezimalzahlen ermitteln. Die Wertigkeit

einer Ziffernfolge wird durch die Potenzen zur Basis von 16 gebildet.

Dabei beginnt man mit der Potenz 160. Für jede Stelle nach links wird

der Exponent um 1 erhöht. Einige Beispiele:


• Ziffernfolge 12: Ergibt die Hexadezimalzahl 18, da 2 x 160 = 2 ist

und 1 x 161 = 16 ist. 16 + 2 ergeben zusammen 18.

• Ziffernfolge A13: Ergibt die Dezimalzahl 2579, da 3 x 160 = 3 ist,

1 x 161 = 16 ist und 10 x 162 = 2560 ist. Die Werte 2560 + 16+

3 ergeben zusammen 2579.




Übersicht über die einstelligen Hexadezimalzahlen, den

Dezimal- und Dualzahlen




Bei Speicherprogrammierbaren Steuerungen wird die hexadezimale

Darstellung von Zahlen häufig verwendet. Es verkürzt die Darstellung

erheblich. Wenn man z.B. die Dualzahl 1111 1111 vergleicht, in

Hexadezimal braucht man nur FF angeben. Im Dualsystem werden die

Ziffernfolgen häufig in 4 Bits zusammengefasst, um eine übersichtliche

Darstellung großer Ziffernfolgen zu erhalten. Mit 4 Bits kann man 16

unterschiedliche Werte darstellen. Da man im Hexadezimalsystem mit

einer Ziffer ebenfalls 16 unterschiedliche Werte darstellen kann, nutzt

man diese Gemeinsamkeit, um Dualzahlen übersichtlicher in

Hexadezimal darzustellen. Die Dualzahl 1110 0111 1010 0111 0101

0111 ist z.B. in jeweils 4 Bit Einheiten zusammengefasst. Diese

Dualzahl kann man nun in Hexadezimal als E7A757 darstellen. Das

Beispiel verdeutlicht die Vereinfachung und dadurch werden auch Fehler

beim Lesen von Dualzahlen minimiert.

Bei Speicherprogrammierbaren Steuerung werden Hexadezimalzahlen

insbesondere beim Verarbeiten von Zahlen, bei Maskierungen in

Verbindung mit UND- und ODER-Befehlen sowie zum Ausblenden von

Binärstellen in Operanden verwendet.

Umwandeln von Zahlen im Hexadezimalsystem

Zahlen können von einem Zahlensystem in das andere umgewandelt

werden. Genauso wie man Dezimalzahlen in Dual unwandeln kann, gibt

es eine Möglichkeit, Dezimalzahlen in Hexadezimal umzuwandeln und

umgekehrt. Beim Umwandeln von Dezimalzahlen in Hexadezimal wird

der Restwertalgorithmus verwendet.

• Beispiel: Umwandeln der Dezimalzahl 10010.




Zuerst dividiert man die Zahl 100 durch 16. Als Ergebnis erhält man die

Zahl 6,25. Im nächsten Schritt nimmt man den ganzzahligen Anteil des

Quotienten und multipliziert die Zahl mit 16, um den Rest zu 100 zu

ermitteln. 16 · 6 = 96, der Rest zu 100 ist 4. Somit hätten wir die erste

Ziffer (beginnend von rechts). Als nächstes dividiert man den

Quotienten erneut durch 16. 6 : 16 ist 0, Rest 6 bleibt übrig. Die zweite

Ziffer wäre 6. Somit hätte man die Zahl 6416 für die Dezimalzahl 10010.

Umrechnen zwischen Dualzahlen und Hexadezimalzahlen

Man kann Hexadezimalzahlen nicht nur in Dezimalzahlen umrechnen

sondern auch direkt in Dualzahlen. Das geht sogar einfacher als bei

Dezimalzahlen. Bei der Umwandlung einer Hexadezimalzahl in eine

Dualzahl bildet man sogenannte Nybbles. Ein Nybble besteht aus 4 Bits

und wird dabei als eine Ziffer aus dem Hexadezimalsystem dargestellt.

Einige Beispiele:

• 516 soll in Dual umgewandelt werden. Das Ergebnis ist: 0101.

• A516 soll in Dual umgewandelt werden: Das Ergebnis ist: 1010

0101.

• CA516 soll in Dual umgewandelt werden: Das Ergebnis ist: 1100

1010 0101

• A3CA516 soll in Dual umgewandelt werden: Das Ergebnis ist:

1010 0011 1100 1010 0101.

Mit dieser Methode braucht man nicht einmal etwas auszurechnen, um

schnell von Hexadezimal in Dual umzuwandeln.




Addition von Hexadezimalzahlen

Im Hexadezimalsystem kann man wie im Dezimalsystem auch addieren.

Die Addition erfolgt dabei vom Prinzip her wie bei Dezimalzahlen. Das

bedeutet:

• Stellenweise werden die Ziffern von rechts (kleinster Stellenwert)

nach links (größter Stellenwert) addiert.

• Dabei kann wie im Dezimalsystem auch, ein Übertrag entstehen.

Der Übertrag entsteht, wenn der Ziffernvorrat überschritten wird.

Beim Hexadezimalsystem wird der Ziffernvorrat nach F

übersprungen. In solchen Fällen muss an Übertrag an der

nächsten Stelle berücksichtigt werden.

Subtraktion von Hexadezimalzahlen

Nach demselben Prinzip wie bei Dezimalzahlen kann man

Hexadezimalzahlen subtrahieren. Das bedeutet:

• Stellenweise von rechts (kleinster Stellenwert) nach links (größter

Stellenwert) wird die Differenz zwischen dem Subtrahenden und

dem Minuenden ermittelt.

• Bei der Subtraktion entsteht ein Übertrag, wenn der Minuend

kleiner ist als der Subtrahend. In solchen Fällen wird wieder ein

Übertrag an der nächsthöheren Stelle berücksichtigt.




Hexadezimalzahlen umrechnen

Wenn man mit Hexadezimalzahlen und Dezimalzahlen rechnet, steht

man vor dem Problem, dass in beiden Zahlensystemen die Ziffern 0, 1,

2, 3, 4, 5, 6, 7, 8, 9 vorkommen. Damit man ein

Unterscheidungsmerkmal hat, kann man die Ziffern bzw. Ziffernfolgen

unterschiedlich kennzeichnen. Hexadezimalzahlen werden mit einer

tiefstellten 16 gekennzeichnet, z.B. AF116. Alternativ könnte man die

Zahl auch den tiefgestellten Zusatz hex kennzeichnen, z.B. AF1hex. Da

das Dezimalsystem auf der Basis 10 beruht, kennzeichnet man

Dezimalzahlen mit einer tiefgestellten 10, z.B. 280110. Alternativ kann

man Dezimalzahlen auch mit dem tiefgestellten Zusatz dez oder dezimal

kennzeichnen, z.B. 2801dez.

Bei der Betrachtung einer Hexadezimalzahl steht man häufig vor dem

Problem, dass man nicht weiß, welchen Zahlenwert in Dezimal mit der

Ziffernfolge eigentlich dargestellt werden soll. Man kann natürlich

Hexadezimalzahlen umrechnen und so den Dezimalwert ermitteln.

Zur Veranschaulichung soll z.B. die Hexadezimalzahl 203116 in eine

Dezimalzahl umgerechnet werden.

Vorgehensweise: Man multipliziert die Ziffern mit dem Stellenwert aus

und addiert die Teilergebnisse.




In der Zeile Hexadezimalzahl sind die hexadezimalen Ziffern 2, 0, 3, 1

dargestellt. In der Zeile "zu addierende Werte" sind die Dezimalwerte zu

den hexadezimalen Ziffern enthalten. Je nachdem, ob die Ziffer der

Hexadezimalzahl eine 0 oder eine andere Ziffer ist, erhält man als

Dezimalwert eine 0 oder einen anderen Dezimalwert. 016 multipliziert

mit dem Stellenwert ergibt immer den Dezimalwert 010. 116 multipliziert

mit dem Stellenwert ergibt einen Wert und ist somit abhängig von der

Stelle der hexadezimalen Ziffer in der Ziffernfolge.

Der Stellenwert der hexadezimalen Ziffer 216 in der 4. Spalte von rechts

ist 163. Möchte man die Wertigkeit dieser Ziffer ermitteln, muss man die

Ziffer mit dem Stellenwert, also 2 · 163 oder 2 · 16 · 16 · 16 rechnen.

Das Ergebnis wäre 819210. Würde hier stattdessen die Ziffer 116

stehen, würde das 409610 ergeben. Denn, 1 · 163 = 4096.

Stellenwerte und Dezimalwerte bei Hexadezimalen Zahlen

Der Wert einer Ziffer innerhalb einer Ziffernfolge im Hexadezimalsystem

nimmt mit jeder Stelle zu. Das wird anhand des Beispiels einer

Hexadezimalzahl 1111 111116 deutlich. Dessen Dezimalwert ist

28633115310.




Der Wert einer Ziffer ist abhängig von der Stelle in der Ziffernfolge, der

einen entsprechenden Dezimalwert hat. Der Stellenwert einer

hexadezimalen Ziffer wird in der Zeile Potenz abgelesen, wobei man

rechts mit 160 beginnt und mit jeder weiteren Stelle nach links den

Exponenten um 1 erhöht, also 161, 162, 163 usw.

Der Dezimalwert einer hexadezimalen Ziffer kann in der Zeile

Zahlenwert dezimal abgelesen werden. Der Dezimalwert entspricht

dabei immer der hexadezimalen Ziffer, multipliziert mit dem

Stellenwert. Dabei wird deutlich, dass der Dezimalwert sich mit jeder

Stelle nach links um das 16-fache erhöht.

Zusammenfassung zur Umrechnung von Hexadezimal nach

Dezimal

Die Umrechnung von Hexadezimalzahlen in Dezimalzahlen erfolgt nach

folgendem Schema:

• Man beginne von rechts und multipliziere die erste Zahl mit 160.

• Mit jeder weiteren Stelle nach links erhöht sich der Exponent bei

der Potenz um 1, also 161, 162, 163 usw.

Beispiel: Die Hexadezimalzahl B12F soll in eine Dezimalzahl

umgerechnet werden




• Die 1. Zahl F ist umgerechnet 15.

• Die 2. Zahl ist 2. Diese multiplizieren wir mit 16. 2 · 16 ergibt 32.

• Die 3. Zahl ist 1. Diese multiplizieren wir mit (16x16) 256. Ergibt

256.

• Die 4. Zahl B ist umgerechnet 11. Wir multiplizieren die Zahl mit

(16x16x16) 4096. Macht 45056.

• Alle Zwischenergebnisse werden addiert:

15+32+256+45056=45359.

Man sieht, Hexadezimalzahlen umzurechnen ist gar nicht so schwer.

Für die Umrechnung ist ein Javascript auf der Seite Hexadezimalsystem

eingebaut. Man braucht nur die Hexadezimalzahl einzugeben, die

Umrechnung erledigt das Script.

Auch wenn solche Scripts Hexadezimalzahlen umrechnen können, sollte

man das Umrechnen beherrschen. Man kann mit Hexadezimalzahlen

auch Addieren, Subtrahieren, Multiplizieren und Dividieren.

Dezimalzahlen nach Hexadezimal umrechnen

Die Umrechnung zwischen Hexadezimalzahlen und Dezimalzahlen kann

auch in die umgekehrte Richtung erfolgen. Eine Möglichkeit ist der

Restwertalgorithmus. Dabei fängt man die Ermittlung der 1. Ziffer von

rechts an und ermittelt Schrittweise die nächsten Ziffern jeweils links.

Restwertalgorithmus: Bei diesem Verfahren wird die die Dezimalzahl

durch die Basis 16 geteilt. Danach wird der ganzzahlige Quotient mit 16

malgenommen und das Ergebnis wird von der Dezimalzahl abgezogen.

Der Rest ergibt die Ziffer für die 1. Hexadezimalzahl. Hierbei muss man

natürlich aufpassen, dass die Ziffer für den Rest in Hexadezimal notiert




wird, z.B. A für 10. Im nächsten Schritt fängt man wieder damit an, den

Quotienten durch 16 zu teilen. Diese Schritte wiederholt man solange,

bis der Quotient 0 ist.

Beispiel für Restwertalgorithmus anhand der Dezimalzahl 10010:

• 100 : 16 = 6, 6 · 16 = 96, Rest 4: Ziffer für die 1. Stelle (ganz

rechts)


Das Ergebnis der Umrechnung mit dem Restwertalgorithmus ist: 6416.

Beispiel für Restwertalgorithmus anhand der Dezimalzahl

160010:

• 1600 : 16 = 100, 100 · 16 = 1600, Rest 0: Ziffer für die 1. Stelle

(ganz rechts)

• 100 : 16 = 6, 6 · 16 = 96, Rest 4: Ziffer für die 2. Stelle


Das Ergebnis der Umrechnung ist: 64016.




BCD - Binär Codierte Dezimalzahlen

In der informationsverarbeitenden Technologie wird als Zahlensystem

das Dualsystem benutzt, da man technisch nur erfassen kann, ob Strom

fließt oder nicht fließt. Diese beiden Zustände werden im Dualsystem

durch die beiden Signale 0 und 1 abgebildet. Der Mensch denkt und

rechnet im Dezimalsystem, auch Zehnersystem genannt, in dem die

Ziffern 0 - 9 vorkommen. Für einen Programmierer muss es eine

Möglichkeit geben, große Ziffernfolgen mit vielen Bits des Dualsystems

schnell in Dezimal abzulesen, auszuwerten oder selbst Ziffernfolgen des

Dualsystems in das System einzugeben. Eine Möglichkeit hierfür ist,

Dezimalzahlen binär zu kodieren. Diesen Code nennt man Binär kodierte

Dezimalzahlen oder einfach BCD-Code.

Für BCD-Zahlen gibt es keine besondere Norm. Auch in Step7 gibt es

keinen besonderen Datentypen für BCD-Code. BCD-Zahlen sind eine

Teilmenge der Hexadezimalzahlen, für die man die Datentypen BYTE,

WORD und DWORD benutzt. Daher werden BCD-Zahlen als

Hexadezimalzahlen in STEP7 eingegeben, es werden aber nur die Ziffern

0 bis 9 verwendet, so wie beim Dezimalsystem. Die hexadezimalen

Ziffern A bis F werden nicht verwendet. Durch die Verwendung der BCD-

Zahlen auf der Grundlage des 8421-Codes (wird am häufigsten

verwendet und ist auch die bekannteste BCD-Kodierung) ist es möglich,

Zahlendarstellungen vereinfacht darzustellen. Damit ist es möglich,

Binärworte so darzustellen, dass man den dezimalen Wert ziffernweise

ablesen kann. Wir gehen davon aus, das das direkte Lesen und

Verstehen von Dualzahlen kein Problem darstellt.




Die Abkürzung BCD steht für Binary Coded Decimal. Dabei wird jede

Stelle einer Dezimalzahl unter Benutzung des binären Zeichenvorrats

(0, 1) kodiert. Für die Kodierung der Dezimalziffern 0 bis 9 benötigt

man mindestens 4 Binärstellen. Daher werden BCD-Zahlen ebenfalls in

4-Bit Blöcken dargestellt. Mit 4 Bits lassen sich insgesamt 16

verschiedene Zahlenwerte (0 - 15) darstellen. Man benötigt aber nur die

Werte für 0 - 9. Deshalb unterteilt man BCD-Ziffernfolgen in gültige (0 -

9) und ungültige (10 - 15) Ziffernfolgen. Alle gültigen Ziffernfolgen

werden als Tetraden bezeichnet. Alle ungültigen Ziffernfolgen

bezeichnet man als Pseudotetraden, da sie nicht benutzt werden und

somit unnötig und überflüssig sind.




Übersicht über die Dezimalzahlen 0 bis 9 und die

dazugehörigen BCD-Zahlen im 8421-Code:

Die nicht verwendeten Ziffernfolgen, die in der Tabelle mit aufgeführt

sind, da man sie theoretisch mit 4 Bits darstellen kann, sind die




Pseudotetraden. Mit 4 Tetraden (16 Bits) kann man einen dezimalen

Zahlenwert innerhalb des Bereichs 0 bis 9999 darstellen. Dabei muss

man jede Tetrade als eine Ziffer im Dezimalsystem vorstellen. Von

rechts nach links gesehen hat man wie im Dezimalsystem Einer, Zehner,

Hunderter, Tausender usw.

Der am häufigsten verwendete BCD-Code wird als 8421-Code genannt,

da die Wertigkeit der vierstelligen Dualzahl 1111 von Stelle zu Stelle

sich verdoppelt. Rechnet man diese in Dezimal um, hat man die

Zahlenwerte 1, 2, 4 und 8 (von rechts nach links lesend) oder 8, 4, 2, 1

(von links nach rechts lesend). Beispiel für eine Dezimalzahl, die als

BCD-Code dargestellt wird.

• Dezimalzahl: 5862

• Als BCD-Code: 0101 1000 0110 0010




BCD-Zahlen bei Speicherprogrammierbaren

Steuerungen

BCD-Zahlen werden in Step7 beim Einstellen von Zahlen und bei der

Anzeige von Ziffern benutzt. Weiterhin verwendet man BCD-Zahlen bei

der Eingabe von Zeiten bei Zeitgliedern und bei der Eingabe von

Zählwerten bei Zählern. Diese Eingaben sind 16 Bit breit. Für die

Eingabe von Zeiten und Zählwerten werden aber die Bits 0 bis 11

verwendet, mit der Maximaleingabe der "9".

Bit 12 bis Bit 15 bleiben bei Zählern unbenutzt, sind also irrelevant und

haben den Wert 0. Siehe auch Zählfunktionen - Zählwerteingabe.

Bei der Eingabe eines Zeitwerts werden zur Angabe der Zeitbasis die

Bits 12 und 13 verwendet. Siehe auch Zeitfunktionen.

Verwendet werden hierbei zwei Bitlängen. Entweder 16-Bit breite oder

32-Bit breite BCD-Zahlen. Dabei gibt es vorzeichenlose und

vorzeichenbehaftete BCD-Zahlen.

Beispiel für die Eingabe einer vorzeichenlosen 16-Bit breiten BCD-Zahl,

die so direkt in Step7 verarbeitet wird:

Dezimalzahl: 5683

• In Step7: W#16#5683

• Eingabe über BCD-Zahleneinsteller: 5683

• Bitmuster: 0101 0110 1000 0011

Beispiel für die Eingabe einer vorzeichenbehafteten 16-Bit BCD-Zahl, die

so direkt in Step7 mit Hilfe der Umwandlungsfunktion 16-Bit BCD TO




INT verarbeitet wird. Die Umwandlungsfunktion 16-Bit BCD TO INT

wertet den am weitesten links stehenden Stellenwert als

Vorzeichenstelle. Das bedeutet, dass vorzeichenbehaftete 16-Bit BCD-

Zahlen einen dezimalen Zahlenumfang von -999 bis +999 haben. Der

am weitesten links stehende Stellenwert wird nach "0" oder "1"

ausgewertet. "0" bedeutet hierbei positiv und "1" bedeutet negativ. Die

Schreibweise der am weitesten links stehenden Tetrade ist dann

folgendermaßen:

• 0*** für positive, vorzeichenbehaftete 16-Bit BCD-Zahlen

• 1*** für negative, vorzeichenbehaftete 16-Bit BCD-Zahlen

Beispiel für die positive Dezimalzahl: +358

• In Step7: W#16#0358


• Bitmuster: 0000 0011 0101 1000

Beispiel für die negative Dezimalzahl: -358

• In Step7: W#16#8358


Bitmuster: 1000 0011 0101 1000




Zahlenformate bei Speicherprogrammierbaren Steuerungen

In einer SPS werden viele Zahlen verarbeitet. Dabei gibt es

unterschiedliche Zahlenformate, für die es unterschiedliche Datentypen

gibt. Grundsätzlich wird zwischen Ganzzahlen und Gleitpunktzahlen

unterschieden. Eine häufige Fehlerquelle ist, dass man versucht, Zahlen

mit unterschiedlichen Datentypen zu addieren. Hierbei kommt es dabei

häufig zu Problemen bzw. es ist erst gar nicht möglich. Zahlen mit

unterschiedlichen Datentypen kann man nicht addieren. In solchen

Fällen muss man zuerst die Zahl in einen identischen Datentypen

umwandeln.

Ganzzahlen

Mit Ganzzahlen sind ganze Zahlen, ohne Nachkommastelle gemeint. Der

darstellbare Zahlenraum hängt von der Anzahl der zur Verfügung

stehenden Bits ab. Mit nur einem Bit kann man z.B. nur die Ziffern 0

und 1 darstellen. Bei Speicherprogrammierbaren Steuerungen werden

Ganzzahlen mit unterschiedlichen Datentypen verwendet. Diese sind:

• Integer-Zahlen, Kurzform INT: Ganzzahlen vom Typ Integer

haben eine Bitlänge von 16 (Bit 0 bis Bit 15). Die belegte Bitlänge

wird auch als ein Wort oder 2 Bytes bezeichnet. Als Vorzeichenbit

MSB, das für die Unterscheidung zwischen negativen und

positiven Zahlen benötigt wird, wird dabei Bit 15 benutzt.

• Doppelinteger-Zahlen, Kurzform DINT: Ganzzahlen vom Typ




Doppelinteger haben eine Bitlänge von 32 (Bit 0 bis Bit 31). Die

Bitlänge wird auch als Doppelwort oder 4 Bytes genannt. Als

Vorzeichenbit wird bei DINT-Zahlen Bit 31 benutzt.

INTEGER: Bei Ganzzahlen vom Typ INT wird Bit 15 als Vorzeichenbit,

auch MSB oder Most Significant Bit genannt, benutzt. Dementsprechend

bleiben 15 Bits (Bit 0 bis Bit 14) für die Darstellung der Zahlenwerte

übrig. Da sowohl positive als auch negative Zahlen dargestellt werden

können, erstreckt sich der darstellbare Bereich von -3276810 (-215) bis

+3276710 (215).

DOPPELINTEGER: Bei Ganzzahlen vom Typ DINT wird Bit 31 als

Vorzeichenbit benutzt. Für die Darstellung der Zahlenwerte bleiben

somit 31 Bits (Bit 0 bis Bit 30) übrig. Damit kann man einen

Zahlenbereich von -214748364810 (-231) bis +214748364710 (231)

darstellen.

Vorzeichenbit MSB:

Das Vorzeichenbit wird dabei wie folgt belegt:

• Negative Zahlen: Vorzeichenbit auf 1

• Positive Zahlen: Vorzeichenbit auf 0

Das bedeutet, ist das Bit mit dem höchsten Stellenwert (Bit 15 bei INT,

Bit 31 bei DINT) eine 0, dann ist die dargestellte Zahl positiv, z.B.

würde die Zahl 0000 0000 0000 10002 vom Typ INT eine positive 8

darstellen.

Bei der Darstellung negativer Zahlen wird das Zweierkomplement

gebildet. Das bedeutet, alle Ziffern werden negiert (Einerkomplement)

und mit der Dualzahl 1 addiert. Die negative Zahl -8 hätte demnach




folgendes Bitmuster: 1111 1111 1111 10002.

Gleitpunktzahlen

Mit Gleitpunktzahlen sind Zahlen gemeint, die eine Nachkommastellen

haben, also z.B. die Dezimalzahl 8,7510. Bei Speicherprogrammierbaren

Steuerungen werden Gleitpunktzahlen mit folgendem Datentypen

verwendet:

• REAL: Gleitpunktzahlen vom Datentyp REAL haben eine Bitlänge

von 32 (Bit 0 bis Bit 31). Auch hierbei wird das Bit mit dem

höchsten Stellenwert als Vorzeichenbit (Bit 31) benutzt. Mit dem

Datentyp REAL können einerseits sehr große Zahlen darstellen.

Andererseits kann man damit auch sehr kleine Zahlen sehr genau

darstellen, da man auch Nachkommastellen abbilden kann.

Für die Darstellung von Gleitpunktzahlen vom Datentyp REAL werden

die zur Verfügung stehenden 32 Bits in 3 Bereiche aufgeteilt. Diese

werden bei der Auswertung einzeln berücksichtigt.

• Bit 31 wird als Vorzeichenbit MSB benutzt.

• Bit 30 (27) bis Bit 23 (20), (8 Bits) wird als Exponent benutzt. Der

Exponent gibt die Potenz der Basis an, die man mit der Zahl

multiplizieren muss. Bei Dualzahlen ist die Basis die 2. Bei

Speicherprogrammierbaren Steuerungen wird der Exponent als 8

Bit Dualzahl ohne Vorzeichen dargestellt und ergibt sich aus der




Subtraktion der Zahl 12710. Damit wird die Kommaposition

abgebildet.

• Bit 22 ( 2-1 ) bis Bit 0 ( 2-23) wird als Mantisse benutzt. Hier

werden die Zahlenwerte rechts vom Komma abgelegt. Somit

entscheidet die Mantisse darüber, wie genau die Gleitpunktzahlen

dargestellt werden können. Der Mantisse wird eine 1

vorangestellt, die nicht darstellbar ist und auch nicht gespeichert

wird. Mit dem Zahlenwert der Mantisse ergibt das einen

Zahlenwert zwischen 110 und 210.

Beim Exponenten gilt folgendes: 1 <= Exponent <= 254 und durch die

Verwendung des BIAS +127 entfällt ein extra Vorzeichen.

Unterschiede bei 32 Bits und 64 Bits

In der heutigen Zeit werden 32-Bit Rechner und 64-Bit Rechner

eingesetzt. Daher musste festgelegt werden, wie viele Stellen für den

Exponenten und wie viele Stellen für die Mantisse bei den jeweiligen

Systemen reserviert werden sollen, um Gleitpunktzahlen darzustellen.

Hier hat die IEEE zwei Normen festgelegt und dabei den Datentyp REAL

in SHORT REAL und LONG REAL unterteilt.

• 32 Bits: SHORT REAL, Bit 31 als Vorzeichenbit, Bit 30 - 23 für

den Exponenten (8 Bits), Bit 22 - Bit 0 für die Mantisse (23 Bits).

Der darstellbare Zahlenbereich ist dabei 1,5 x 10-45 bis 3,4 x

1038.




• 64 Bits: LONG REAL, Bit 63 als Vorzeichenbit, Bit 62 - 52 für den

Exponenten (11 Bits), Bit 0 - Bit 51 für die Mantisse (52 Bits). Der

darstellbare Zahlenbereich ist dabei 5,0 x 10-324 bis 1,7 x 10308.

Bei Speicherprogrammierbaren Steuerungen wird für die Darstellung

von Gleitpunktzahlen der Datentyp SHORT REAL mit einer Bitlänge von

32 benutzt und der Datentyp wird lediglich REAL genannt.

Umrechnung dezimaler Gleitpunktzahlen in

duale Gleitpunktzahlen

Duale Gleitpunktzahlen lassen sich in dezimale Gleitpunktzahlen

umrechnen und umgekehrt. Allerdings ist eine exakte Umrechnung von

dezimalen Gleitpunktzahlen in duale Gleitpunktzahlen nicht immer

möglich. Das liegt daran, dass die Basis von Dualzahlen 2 ist. Daher

haben die Nachkommastellen die Wertigkeit der negativen Potenz zur

Basis von 2 (2-1 - 2-n). Somit kann man nur die Nachkommastellen

exakt abbilden, die sich aus der Summe der negativen Potenzen zur

Basis von 2 ergeben. Bei allen anderen Nachkommastellen kann man

nur Näherungswerte ermitteln.

• Beispiel 0,510: Lässt sich exakt in Dual darstellen, da die Zahl die

negative Potenz 2-1 ist.

• Beispiel 0,7510: Lässt sich ebenfalls exakt in Dual darstellen, da

die Zahl aus der Summe der negativen Potenzen 2-1 und 2-2




gebildet wird.

• Beispiel 0,110: Lässt sich nicht exakt darstellen, da man mit der

Summe der negativen Potenzen 2-1 - 2-n die Zahl nicht darstellen

kann.

Für die Zahl 0,110 kann man nur folgende Näherungswerte ermitteln:

• 0,0999999940395355210, entspricht der dualen Gleitpunktzahl 0

0111 1011 100110011001100110011012

• 0,1000000014901161210, entspricht der dualen Gleitpunktzahl 0

0111 1011 100110011001100110011012.

Bei Speicherprogrammierbaren Steuerungen ist für die Eingabe von

Gleitpunktzahlen vom Datentyp REAL häufig eine Beschränkung

vorhanden. Die Eingabe weiterer Nachkommastellen ist dabei nicht

möglich. In Step7 liegt die Beschränkung z.B. bei 6 Nachkommastellen.

Beispiel für die Umrechnung einer dualer Gleitpuntzahl in

Dezimal

Umrechnung einer dualen Gleitpunktzahl in eine dezimale

Gleitpunktzahl. Folgende Bitmuster-darstellung ist gegeben:

• Vorzeichenbit MSB: 0. Die Zahl ist positiv.

• Exponent: 0111 1000. Bedeutet = 12010.

• Mantisse: Bit 22 ist "1", entspricht 2-1 also 0,5. Die übrigen Ziffern

sind 0 und werden daher nicht betrachtet.




Formel für die Umrechnung:

1 + Mantisse · ( 2(Exp-127) ) = 1,5 · ( 2(120-127) ) = 1,5 · (2-7) = 1,5 ·

0,0078125 = 0,01171875.

Zum Schluss noch das Vorzeichen setzen: + 0,01171875




Umrechnung einer dezimalen Gleitpunktzahl in

Dual

Man kann auch dezimale Gleitpunktzahlen (z.B. 3,210) in eine duale

Gleitpunktzahlen umrechnen. Zu beachten ist hier, dass nicht alle

Nachkommastellen exakt in Dual dargestellt werden können. Man kann

nur die Nachkommastellen exakt darstellen, die sich aus der Summe

der negativen Potenzen 2-1 - 2-23 bilden lassen (bei 32 Bit).

Im 1. Schritt berechnet man die Mantisse der Gleitpunktzahle. Hierfür

verwendet man die Formel Mantisse = GPZ10 · ( 2n ), sodass sich im

Ergebnis diese Form ergibt:

• 1 <= Mantisse < 2

Das bedeutet, der Exponent n bei ( 2n) muss so gewählt werden, dass

das Ergebnis für die Mantisse einen Wert zwischen 1 und 2 hat.

Wenn für den Exponenten n die Zahl kleiner als -1210 oder größer als

+12710 errechnet wird, dann kann die Zahl als SHORT REAL nicht

dargestellt werden. Das Ergebnis wäre dann nämlich entweder 0 oder

unendlich und wird als NaN bezeichnet, was übersetzt Not a Number

bedeutet.

Um negative Werte zu vermeiden, wird der Exponent mit dem BIAS-

Wert verrechnet, der bei SHORT-Real 127 ist. Daher kann man nur die

Exponenten im Bereich -126 bis +127 speichern, die als Charakteristik

zwischen 1 - 255 gespeichert werden. Somit bleiben die Werte 0 und




255 übrig. Diese beiden Werte sind als Charakteristik für die

Zahlenwerte Null und Unendlich und somit als NaN reserviert.

Im 2. Schritt werden die Nachkommastellen der Mantisse in Dual

dargestellt. Hier hat man entweder das Glück, dass die

Nachkommastellen durch die Summe der negativen Potenzen 2-1 - 2-23

dargestellt werden können oder man kann nur einen Näherungswert

ermitteln. Ist eine negative Potenz in der Mantisse enthalten, wird eine

1 an die entsprechende Stelle gesetzt. Ist eine negative Potenz nicht

enthalten, setzt man eine 0.

Im 3. Schritt ermittelt man den Exponenten der Gleitpunktzahl als

Dualzahl. Dabei verwendet man folgende Formel:

• Exponent = (y) + ( EBias)

EBias ist hier die Zahl 127 die bereits weiter oben im Beispiel benutzt

wurde. EBias legt die Größe des Zahlenbereichs fest, bei 32 Bit GPZ2

eben durch 12710 und bei 64 Bit GPZ2 ist es die 102310.

Beispiel für die Umrechnung der Gleitpunktzahl 3,210

Ermitteln der Mantisse unter Verwendung der Formel GPZ10 · ( 2n ) und

Auswahl des Exponenten, so dass man die Mantisse in der Form 1 <=

Mantisse < 2 erhält:

• Mantisse von 3,210 = 3,210 x 2-1 = 1,6

Hier wurde der Exponent 2-1 gewählt, weil dadurch das Ergebnis

zwischen 1 und 2 liegt.




Nun wird die Dezimalzahl 0,6 in Dual umgerechnet. Die Dezimalzahl 0,6

kann nicht exakt in Dual dargestellt werden, da man die Zahl nicht aus

der Summe der Potenzen 2-1 - 2-23 bilden kann. Also wird ein

Näherungswert ermittelt. Wird eine Potenz verwendet, schreibt man

eine 1 in die Mantisse, bei nicht verwendeten Potenzen wird eine 0

eingesetzt.

Für Umrechnung der Nachkommastelle 0,6 sähe das folgendermaßen

aus:

1x2-1 + 0x2-2 + 0x2-3 + 1x2-4 + 1x2-5 +0x2-6 + 0x2-7 + 1x2-8 +

1x2-9 + 0x2-10 + 0x2-11 + 1x2-12 + 1x2-13 + 0x2-14 + 0x2-15 +

1x2-16 + 1x2-17 + 0x2-18 + 0x2-19 + 1x2-20 + 1x2-21 + 0x2-22 +

1x2-23

• Das ergibt die Dualzahl 100 1100 1100 1100 1100 11012

• Der Näherungswert entspricht dabei

0,60000002384185791075625

• Die Mantisse wäre: 1 + 0,60000002384185791075625 =

1,60000002384185791075625

Daraus ergibt sich folgendes Aussehen für die Stellen in der Mantisse:

X XXXX XXXX 100 1100 1100 1100 1100 11012

Nun der Exponent für:

Exponent = (y) + ( EBias) für Dezimalzahlen >= 1

Exponent = ( - y) + ( EBias) für Dezimalzahlen < 1

Exponent = 110 + 12710 = 12810




Bei Gleitpunktzahlen >= 1 wird für die Variable (y) der positive Wert

des Exonenten eingesetzt, der bei der Ermittlung der Mantisse GPZ10 ·

(2-n) als (n) verwendet wurde. Bei Gleitpunktzahlen < 1 setzt man den

negativen Wert des ermittelten Exponenten ein.

In diesem Fall wird 12810 nach dual umgewandelt. Man erhält 1000

00002.

Zum Schluss setzt man noch das Vorzeichenbit und man erhält

folgendes Ergebnis:

• 0 1000 0000 100 1100 1100 1100 1100 1101

Die Zahl ist positiv, der Exponent und die Mantisse wurden ermittelt.

Rechnet man die duale Gleitpunktzahl in Dezimal um, erhält man 3,210




Bit und Byte

In der informationsverarbeitenden Technologie wird als Zahlensystem

mit dem Dualsystem gearbeitet. In diesem Zahlensystem kommen nur

die Ziffern 0 und 1 vor und damit kann man abbilden, ob Strom fließt

oder nicht fließt, dessen Erkennung die Grundlage der

Computertechnologie ist. Diese Einheit wird als binäres Signal oder

anders ausgedrückt BIT genannt. Ein Bit ist im Grunde eine Ziffer im

dualen Zahlensystem, der nur die beiden Werte 0 und 1 haben kann. Bit

ist die Abkürzung für Binary Digit und stellt die kleinste Einheit in der

Computertechnologie dar.

Nun macht es keinen Sinn, lediglich nur die Ziffern 0 und 1 darzustellen,

sondern man möchte technologisch gesehen höhere Zahlenwerte

verarbeiten. Der Trick liegt einfach darin, dass man die Bitlängen

erhöht. Mit 2 Bits kann man z.B. die Zahlen 00, 01, 10 und 11

darstellen, womit man bereits 4 Zustände hätte. Für die Erweiterung

der Bitlängen hat man Namen vergeben. Diese sind:

• Halbbyte: Wenn 4 Bits zusammengefasst werden, nennt man das

Halbbyte oder auch Nybble.

• Byte: 8 Bits werden zu einem Byte zusammengefasst. Das wären

2 Halbbytes/Nybbles. Mit 1 Byte kann man 256 verschiedene

Zustände abbilden. Damit könnte man z.B. die Zahlenwerte 0 bis

255, -127 bis +127 oder auch Buchstaben aus dem ASCII-

Zeichenvorrat darstellen. Daher wird 1 Byte auch häufig als Wert

einer Buchstabe betrachtet.

• Word: Kommt aus dem Englischen und damit ist auch das Wort




gemeint. Ein Wort besteht aus mindestens 2 Buchstaben. Daher

besteht ein Wort aus 2 Bytes, was insgesamt 16 Bits wären.

• DWord: Es gibt noch das Doppelwort, das aus 2 Wörtern besteht.

Das sind 32 Bits oder 4 Bytes.

Auch bei Speicherprogrammierbaren Steuerungen bzw. bei der SPS-

Programmierung werden die Begriffe Bit, Byte, Wort und Doppelwort

verwendet. Wenn man also meint, die Zahl ist 1 Doppelwort lang, dann

meint eine Bitlänge von 32 Bits. Die Begriffe werden auch häufig in

Verbindung mit der Adressierung benutzt. Möchte man z.B. einen Taster

abfragen, schließt man den Taster an die SPS an. Dabei bekommt der

Taster eine eindeutige Adresse. Über diese Adresse kann der Taster

dann eindeutig identifiziert und z.B. im SPS-Programm abgefragt

werden. Dabei gibt es Bitadressen, Byteadressen, Wort- und

Doppelwortadressen.




Bitadressen

Ein Byte besteht aus 8 Bits. Für jedes Bit wird dabei eine Bitadresse

zugeordnet. So wird jedes Bit einer eindeutigen Adresse zugeordnet,

der darüber auch direkt angesprochen werden kann. Die Adressierung

eines Bytes fängt dabei mit der ersten Bitstelle auf der rechten Seite an

und erhöht sich mit jeder Bitstelle nach links um 1. In Zahlen

ausgedrückt bedeutet das, die Bitstelle ganz rechts erhält die Bitadresse

0 und die Bitstelle ganz links die Bitadresse 7.

Darstellung der Bitadressen 0 bis 7:

Byteadressen

Jedes einzelne Byte wiederum erhält ebenfalls eine Nummer, die

Byteadresse. Außerdem wird noch der Operand bezeichnet. EB1 steht

für Eingangsbyte 1 oder AB2 für Ausgangsbyte 2. Ein einzelnes Bit wird

eindeutig durch die Kombination von Bit- und Byteadresse adressiert,

z.B. E0.1 für Bitadresse 1 von Eingangsbyte 0. Hierbei wird die




Bitadresse durch einen Punkt von der Byteadresse getrennt. Links vom

Punkt steht die Byteadresse und rechts vom Punkt die Bitadresse. Bei

dem Ausgang A2.3 handelt es sich also um das 4. Bit (die Bitnummern

fangen bei 0 an) im zweiten Byte einer Ausgangsbaugruppe.

Darstellung einer Byteadresse:

Wortadressen

Ein Wort besteht aus mindestens 2 Buchstaben (2 Bytes). Wenn 2 Bytes

zusammengefasst adressiert werden sollen, benutzt man Wortadressen,

die nummeriert werden. Die Wortadresse bei der Verwendung von

Eingangswörtern EW, Ausgangswörtern AW und Merkerwörtern MW ist

immer die kleinere Byteadresse der beiden im Wort befindlichen Bytes.

Bei Doppelwörtern verhält es sich genauso, hier ist die kleinere

Wortadresse die Adresse des Doppelwortes.




Darstellung von Wortadressen:




Doppelwortadressen

Ein Doppelwort besteht aus 2 Wörtern, das sich aus wiederum aus 2

Bytes zusammensetzt (32 Bits). Auch hier gilt, dass man bei der

Verwendung von Doppelwörtern bei Eingängen (ED), Ausgängen (AD)

und Merkern (MD) immer die kleinere Byteadresse nummeriert. Wenn

man also AD0 nummeriert, dann erstreckt sich das Doppelwort über die

Ausgangsbytes AB0, AB1, AB2 und AB3.




Besonderheiten bei der Adressierung

Aus dem oberhalb farbigen dargestellten Schaubildern lässt sich also

folgendes ableiten:

• Ausgangswort AW0 besteht aus Ausgangsbyte AB0 und

Ausgangsbyte AB1

• Ausgangsbyte AB0 besteht aus den Ausgangsbits A0.0 bis A0.7



Ausgangsbyte AB3




Ausgangsbyte AB2



Dasselbe gilt auch für die Adressierung von Doppelwörtern. Auch hier ist

bei der Adressierung besondere Sorgfalt geboten. Würde man nach

obigen Schema der Wortadressen ein Ausgangsdoppelwort AD0

adressieren dann besteht dieses Ausgangsdoppelwort AD0 aus

folgenden Adressen:

• Ausgangsdoppelwort ADW0 besteht aus Ausgangswort AW0 und

Ausgangswort AW2





Ausgangsbyte AB1


Ausgangsbyte AB3

• Ausgangsbyte AB0 besteht aus den Ausgangsbits 0.0 bis A0.7




Adressierungsregeln

Hinweis: Wenn man ein Byte, Wort oder Doppelwort bereits

adressiert, dann kann man innerhalb des adressierten Bereichs

ein Bit, Byte, Wort oder Doppelwort nicht noch einmal

adressiert, da hier eine Überschneidung stattfinden würde.

Würde man z.B. das Ausgangsdoppelwort AD0 adressieren, dann

belegt das Doppelwort die Ausgangsbytes 0, 1, 2 und 3. Möchte

man ein weiteres Ausgangsdoppelwort adressieren, dann kann

man nicht einfach AD1 nehmen. Das nächste

Ausgangsdoppelwort das für die Adressierung frei ist, wäre in

diesem Fall AD4.

Dies gilt für alle Adressierungen bei Eingängen, Ausgängen und

Merkern ebenso wie bei der Adressvergabe bei Ganzzahlen (INT,

DINT) und Gleitkommazahlen (REAL).




Schaltwerttabelle

Um eine Steuerungsaufgabe systematisch zu lösen, kann man

Schaltwerttabellen benutzen. Ein anderes Wort für eine

Schaltwerttabelle ist Funktionstabelle.

Auf dem Bild sehen Sie eine einfache Schaltwerttabelle. In dieser ist ein

Eingang (E1) und ein Ausgang (A1). Es ist also die Minimalform

einer Schaltwerttabelle. Ein Eingang kann ein Schalter sein, ein Ausgang

beispielsweise ein Motor, das über ein Schütz angetrieben wird.

Der Eingang E1 kann 2 Zustände haben. Entweder EIN oder AUS,

digitaltechnisch gesehen 1 oder 0. Dementsprechend können wir jetzt

für den Ausgang A1 die Steuerung festlegen. Das heißt, wann soll A1

EIN oder AUS sein, also 0 oder 1. In diesem Fall haben wir festgelegt,

dass wenn E1 das Signal 1 hat, der Ausgang A1 ebenfalls das Signal 1

bekommen soll.

Einfache Schaltwerttabelle mit einem

Ein- und Ausgang

Man hätte es auch anders lösen können. Es ist auch möglich




festzulegen, bei einem Signal 0 von E1, den Ausgang A1 auf 1 zu

schalten. Anders ausgedrückt hätte man auch festlegen können, dass

A1 ausgehen soll, wenn E1 angeht.

Schaltwerttabelle mit 2 Eingängen

Auf dem Bild sehen wir nun eine Schaltwerttabelle mit 2 Eingängen.

Diesmal verhält es sich so, dass die Eingänge 4 Zustände haben

können, nämlich:

• Beide Eingänge AUS

• E1 EIN, E2 AUS

• E1 AUS, E2 EIN

• Beide Eingänge EIN

Diese Steuerung wäre vergleichbar mit einer Lampenschaltung für einen

langen Flur mit 2 Schaltern.

• Erst sind beide Schalter AUS, also ist die Lampe auch AUS.

• Mit dem einen oder

• anderen Schalter wird die Lampe angemacht.

• Sobald der 2. Schalter betätigt wird, wird die Lampe wieder

ausgemacht.




Schaltwerttabelle mit 2 Eingängen und einem Ausgang.

Sobald ein Eingang hinzukommt, verdoppelt sich die Anzahl der

möglichen Zustände. Mit nur einem Eingang hatten wir 2 mögliche

Zustände, bei zwei Eingängen haben wir nun 4 mögliche Zustände.

Sobald ein dritter Eingang hinzukommt, hätten wir 8 mögliche

Zustände, bei 4 Eingängen 16.

Die Schaltwerttabelle sollte so angeordnet sein, dass die Eingänge nach

links angeordnet werden, die Ausgänge nach rechts. So ist es

problemlos möglich, die Schaltwerttabelle zu erweitern. Wir könnten in

diesem Fall problemlos zusätzliche Ein- und Ausgänge hinzufügen.

Die möglichen Zustände sollten so angeordnet werden, dass die Zeilen

untereinander immer mit +1 gerechnet werden. Wir haben in der ersten

Zeile 00, in der zweiten Zeile wird 1 addiert, also haben wir 01. In der

dritten Zeile wird wieder 1 addiert, also haben wir 10, in der vierten

Zeile 11. So kann man alle möglichen Zustände geordnet erfassen und




es wird nichts vergessen. Daher sollten Sie das Kapitel Dualzahlen

addieren beherrschen, damit Sie die Schaltwerttabelle korrekt erstellen

können.

Schaltfunktion mit Hilfe einer Schaltwerttabelle

Um eine Steuerungsaufgabe zu realisieren, kann man eine

Schaltfunktion mit Hilfe einer Schaltwerttabelle erstellen. Die

Schaltfunktion beschreibt die Steuerung als eine mathematische

Funktion.

Nehmen wir als Beispiel die Schaltwerttabelle aus dem vorherigen

Kapitel. Wir richten unser Augenmerk auf die beiden Zeilen, in der am

Ausgang 1 steht, also wann die Lampe etc. angehen soll. Wann soll die

Lampe nun angehen? Wir haben 2 mögliche Szenarien.

Szenario 1: E1 ist AN, E2 ist AUS

ODER

Szenario 2: E1 ist AUS, E2 ist AN

Verbal ausgedrückt könnte man die Steuerung so beschreiben, dass der

Ausgang eingeschaltet werden soll, wenn:

E1 an ist UND E2 aus ist ODER E1 aus ist UND E2 an ist.




Damit man die Struktur einer Schaltfunktion besser erkennen kann,

setzen wir diesmal Klammern ein, benutzen die Zahlen 0 und 1 für die

Zustände AUS und EIN und setzen den Ausgang in die Funktion ein:

(E1=1 UND E2=0) ODER (E1=0 UND E2=1) = A1

Das wäre schon fast eine richtige Schaltfunktion, die wir mit Hilfe der

Schaltwerttabelle erstellt haben. Es beschreibt, wann der Ausgang den

Zustand AN oder AUS haben soll.

Schaltfunktion anhand einer Schaltwerttabelle erstellen.

Schaltfunktion in mathematischer Form

Wenn wir die Schaltfunktion korrekt in mathematischer Schreibweise

darstellen wollen, muss sie etwas verändert werden. Dazu sollte man

folgende Dinge wissen:

• Um zu beschreiben, dass ein Operand (Eingang oder Ausgang) AN

ist, schreibt man beispielsweise nicht E1=1, sondern man

verkürzt es einfach auf E1.

• Um zu beschreiben dass ein Operand AUS ist, schreibt man nicht




E1=0 sondern man zeichnet über dem Operanden einen Strich,

also in der Form E1.

• Statt ODER nimmt man das Pluszeichen, also +

• Statt UND nimmt man das Malzeichen, also .

Die obere Schaltfunktion wird in mathematischer Form wie folgt

dargestellt:

Die obere Schaltfunktion in mathematischer Form

Schaltfunktion in boolescher Form

Die Schaltfunktion kann auch in boolescher Form dargestellt werden.

Hier gibt es im Gegensatz zur mathematischen Form lediglich zwei

Abweichungen.

• Ein UND wird mit einem ^ dargestellt

• Ein ODER wird mit einem umgekehrten Hütchen dargestellt

Die obere Schaltfunktion in boolescher Form:

Schaltfunktion in boolescher Form




Vereinfachung von Schaltfunktionen

Nachdem man eine Schaltfunktion direkt aus der Schaltwerttabelle

entnommen hat, kann man diese als Steuerung umsetzen. Eine

Schaltfunktion die direkt aus der Schaltwerttabelle entnommen wird, ist

in den meisten Fällen viel zu kompliziert bzw. unnötig lang.

Diese Schaltfunktion kann man mit den Gesetzen der Schaltalgebra

vereinfachen. Eine andere Möglichkeit bietet die grafische

Vereinfachungsform mit Hilfe eines KV-Diagramms.

Der Sinn liegt darin, dass man ein Steuerungsprogramm nicht unnötig

aufbläht. Man kann ein langes Steuerungsprogramm mit Hilfe der

Schaltalgebra so minimieren, dass die Steuerungsaufgabe erfüllt wird

und die Steuerung trotzdem sehr klein ist.

Beispiel für eine Vereinfachung

Gegeben ist die Schaltfunktion:

Wenn man die Schaltfunktion genau betrachtet, dann erkennt man,

dass es auf die Variable c überhaupt nicht ankommt. Diese

Vereinfachung nennt man auch Absorptionsgesetz.




Übrig bleiben die beiden Terme, die identisch sind. Ein Term kann

entfernt werden.

Übrig bleibt die vereinfachte Schaltfunktion a b. ∧

Anhand dieses kleinen Beispiels wird deutlich, dass eine sehr lange

Schaltfunktion mit wenigen Schritten erheblich verkleinert werden kann.




KV-Diagramm: Vereinfachen mit einem Karnaugh-Veitch-Diagramm

Schaltfunktionen können mit den Regeln der Schaltalgebra

umgewandelt, bzw. vereinfacht werden. Diese Anwendung ist jedoch,

insbesondere bei großen Schaltfunktionen, sehr aufwendig. Das Problem

kann man lösen, indem man für die Vereinfachung der Schaltfunktion

eine grafische Methode wählt, nämlich das Karnaugh-Veitch-Diagramm,

auch KV-Diagramm genannt.

Ein KV-Diagramm ist ein Minimierungsverfahren, das grafisch lösbar und

im Gegensatz zur Schaltalgebra einfacher ist. Dabei werden die

Signalzustände der Ausgangsvariablen in das Diagramm übertragen und

enthält alle möglichen Miniterme. Bei n Eingangsvariablen hat das KV-

Diagramm 2n-Felder. Der Term, bei dem alle Variablen genau einmal

vorkommen und die Verknüpfung konjunktiv (UND-Verknüpfung) ist, ist

ein Miniterm.

Vorgehensweise bei der Arbeit mit KV-

Diagrammen

• Man übernimmt die Terme der disjunktiven Normalform DNF oder

der konjunktiven Normalform KNF aus der Wahrheitstabelle.

• Die Felder werden entsprechend der Tabelle mit 0 oder 1 belegt.




• Dann werden die Blöcke zusammengefasst.

• min DNF: Zusammenfassung der Blöcke mit 1

• min KNF: Zusammenfassung der Blöcke mit 0

Aufbau eines KV-Diagrammes

Eine Schaltwerttabelle mit nur einer Variable hat zwei Zeilen, da eine

Variable nur zwei mögliche Zustände hat (0 oder 1). Das KV-Diagramm

hat somit zwei Kästchen, in die die Zeilennummern der Übersicht halber

in kleiner Schrift rechts angezeigt werden.

Hat eine Schaltwerttabelle zwei Variablen, verdoppelt sich die

Zeilenanzahl auf 4 (Zeilen 0 bis 3). Das KV-Diagramm muss daher

erweitert werden. Hierfür wird das KV-Diagramm nach unten

aufgeklappt. Die neu hinzugekommenen Zeilennummern werden

gespiegelt eingetragen. Das heißt, nach 0 und 1 wären die nächsten

Zeilennummern 2 und 3. Die Zahl 2 würde gespiegelt zu 0 eingetragen.

Die Zahl 3 würde gespiegelt zu 1 eingetragen.




Bei drei Variablen verdoppelt sich die Zeilenanzahl erneut (Zeilen 0 bis

7). Das KV-Diagramm wird diesmal nach rechts gespiegelt aufgeklappt.

Die neu hinzugekommenen Zeilennummern sind 4, 5, 6, und 7. In

diesem Verbund ist 4 die kleinste Zeilennummer und wird daher

gespiegelt zu 0 eingetragen, da die Zeilennummer 0 ebenfalls die

kleinste Zahl im vorhergehenden Verbund (0, 1, 2, und 3) ist. Die

Zeilennummer 5 wird gespiegelt zu 1 eingetragen, die Zeilennummer 6

wird gespiegelt zu 2 eingetragen und die Zeilennummer 7 wird zur

Zeilennummer 3 gespiegelt.

Mit einer weiteren Variable wird das KV-Diagramm nach unten




aufgeklappt und die neuen Zeilennummer erneut gespiegelt

eingetragen. Nach diesem Schema kann man im Grunde beliebig

fortführen. Mit jeder hinzukommenden Variable spiegelt man das KV-

Diagramm einmal nach rechts und einmal nach unten und trägt die

neuen Zeilennummern gespiegelt zu vorhergehenden Zeilennummern

ein. Allerdings wird das irgendwann sehr unübersichtlich und man

braucht sehr viel Platz, da das KV-Diagramm mit jeder neuen Variable

sich die doppelte Größe einnimmt.

Die Ausgänge schreibt man in das KV-Diagramm in großer Schrift. Im

folgenden Beispiel führt der Ausgang in den Zeilen 0, 1, 2 und 4 das

Signal 1 und die übrigen Zeilen das Signal 0. Die Zustände werden im

KV-Diagramm entsprechend eingetragen.




Zusammenfassen der Terme

Folgende Regeln gelten zum Zusammenfassen:

• Es können nur Blöcke mit 2, 4, 8, 16, usw. Elementen

zusammengefasst werden.

• Die Elemente sind entweder benachbart, und/oder symmetrisch

bezüglich einer oder mehrerer horizontalen oder vertikalen

Symmetrieachsen.

Auf den folgenden zwei Abbildung sind z.B. Blöcke mit zwei oder vier

Elementen zusammengefasst.




Man könnte Blöcke aus 4 oder 8 Elementen auch wie folgt

zusammenfassen.

Man muss sich das KV-Diagramm dabei wie eine Kugel vorstellen und

erhält so benachbarte Elemente. Daher ist sind auch folgende




Zusammenfassungen möglich.




Vereinfachung anhand eines Beispiels

Die folgende Schaltwerttabelle soll mit Hilfe eines KV-Diagramms

vereinfacht werden.

Bei der Reihenfolge der Zusammenfassung ist man frei. In diesem

Beispiel werden zunächst die Zeilen 0 und 1 zusammengefasst. Die

Terme der Zeilen sind wie folgt:

• Zeile 0: ¬a ¬b ¬c ¬d∧ ∧ ∧• Zeile 1: a ¬b ¬c ¬d∧ ∧ ∧

Auf a kommt es nicht an. Daher werden die beiden Terme wie folgt

zusammengefasst: ¬b ¬c ¬d∧ ∧




Im nächsten Schritt werden die Zeilen 0 und 2 zusammengefasst.

• Zeile 0: ¬a ¬b ¬c ¬d∧ ∧ ∧• Zeile 2: ¬a b ¬c ¬d∧ ∧ ∧

Auf b kommt es nicht an und die Zusammenfassung ist wie folgt: ¬a ∧¬c ¬d∧




Zum Schluss werden die Zeilen 0 und 4 zusammengefasst.

• Zeile 0: ¬a ¬b ¬c ¬d∧ ∧ ∧• Zeile 4: ¬a ¬b c ¬d∧ ∧ ∧

Auf c kommt es nicht an und die Zusammenfassung ist: ¬a ¬b ¬d∧ ∧

Die vereinfachte Schaltfunktion wäre: ¬b ¬c ¬d ¬a ¬c ∧ ∧ ∨ ∧ ∧¬d ¬a ¬b ¬d∨ ∧ ∧

Aus 4 Termen wurden 3 Terme und das KV-Diagramm bot dabei eine

hilfreiche Unterstützung.




Boolesche Algebra in der Steuerungstechnik - Schaltalgebra

Bei Speicherprogrammierbaren Steuerungen wird mit den binären

Verknüpfungen UND, ODER und NICHT eine Aussagenlogik realisiert. Mit

einer Aussagenlogik wird im Grunde eine Schaltfunktion abgeleitet.

Beispiel: Die beiden Taster S1 und S2 müssen gleichzeitig ein Signal 1

liefern, damit die Stanze nach unten bewegt wird.

Es gibt die Möglichkeit, solch eine Aussagenlogik mit Hilfe einer

Schaltwerttabelle darzustellen und abzulesen. Alternativ könnte man

eine Schaltfunktion auch mit Hilfe einer besonderen Art mathematisch

darstellen. Die Darstellung in mathematischer Form nennt man

Schaltalgebra. Diese hat ihre Grundlagen in der booleschen Algebra,

weshalb auch hier die Gesetze der gewöhnlichen Algebra angewendet

werden.

Der Vorteil, eine Schaltfunktion in einen schaltalgebraischen Ausdruck

zu bringen ist, dass man diese mathematisch berechnen und mit Hilfe

der algebraischen Gesetze umwandeln kann. Ein SPS-Programmierer

sollte daher die Schaltalgebra sowie die Gesetze für die Umwandlung

eines schaltalgebraischen Ausdrucks kennen.

Ein schaltalgebraischer Ausdruck kann man wie eine mathematische

Formel betrachten, z.B. S1 · S2 = Q. Es enthält Variablen, bei der die

Buchstaben in Großbuchstaben dargestellt werden. Die Variablen

können dabei, bezugnehmend auf das Dualsystem in der Digitaltechnik,

nur die beiden Zustände 0 (Aus) oder 1 (An) haben.




Darstellung und Verknüpfungen

Um eine Aussagenlogik mit den binären Verknüpfungen UND, ODER und

NICHT in einem schaltalgebraischen Ausdruck darzustellen, haben sich

verschiedene Darstellungsarten etabliert. Hierbei wird grundsätzlich

zwischen der Darstellungsart in boolescher Algebra und in

mathematischer Form unterschieden.




Übersicht über die Gesetze und Eigenschaften der Booleschen

Algebra




Kommutativgesetz (Vertauschungsgesetz)

Die Aussagenlogik A UND B UND C ist dasselbe wie C UND A UND B.

Das bedeutet, dass in diesem Fall die Variablen vertauscht werden

können. Das Vertauschungsgesetz nennt man Kommutativgesetz und

kann angewendet werden, wenn alle Variablen durch UND- oder ODER-

Gliedern verknüpft sind. In solchen Fällen können die Variablen beliebig

vertauscht werden.

Assoziativgesetz (Verbindungsgesetz)

In der Mathematik kommt die Klammersetzung vor, wenn die

Berechnung zweier Variablen zusammengefasst wird. Dabei

unterscheidet man zwischen Klammersetzung bei Addition und

Klammersetzung bei Multiplikation. Berechnungen, in den die

Klammersetzung keine Rolle spielt, sind assoziativ. Das bedeutet, es ist

z.B. egal, ob man beim algebraischen Ausdruck A UND B UND C die

Berechnung A UND B zusammenfasst oder B UND C. Es ist dem

Vertauschungsgesetz ähnlich.




Distributivgesetz (Verteilungsgesetz)

In der Mathematik wird häufig ausgeklammert und ausmultipliziert.

Auch in der Schaltalgebra kann, unter Berücksichtigung mathematischer

Gesetze, ausgeklammert und ausmultipliziert werden. Ein Ausdruck, der

aus UND- oder ODER-Gliedern besteht, kann dabei umgeformt und

vereinfacht werden. Die Gesetze der Ausklammerung und

Ausmultiplizierung nennt man Distributivgesetz.

Absorptionsgesetz

Die Variablen eines Ausdrucks können durch die Logik absorbiert, sprich

entfernt werden. Wenn man z.B. den Ausdruck betrachtet A ODER (A

UND B), dann wird schnell klar, dass es auf B überhaupt nicht ankommt.

Denn, für B alleine trifft die Aussage nicht zu, da die Aussagenlogik (A

UND B) enthält. Die Aussagenlogik trifft aber zu, wenn A selbst 1 ist, da




die Aussagenlogik A ODER enthält. Man kann es auch so formulieren: "B

braucht A, A braucht aber B nicht. Daher kommt es alleine auf A an".

Negationsgesetz

Mit den Negationsgesetzen wird beschrieben was passiert, wenn man

die Aussage negiert. Beispiele:

• NICHT A = B ist dasselbe wie A = NICHT B.

• A = NICHT NICHT A

Zu den Negationsgesetzen gehört auch folgende Logik.

• NICHT A UND A ist 0. NICHT A ODER A ist 1.




DeMorgan'sche Gesetze

Der englische Mathematiker DeMorgan hat die Gesetze der

Schaltalgebra um einige nützliche Gesetze erweitert. Diese neuen

Gesetze sind sehr praktisch, insbesondere wenn man negierte

Ausdrücke auflösen möchte. Darunter fallen Gesetze für folgende

Verknüpfungen:

Für die NAND-Verknüpfung gilt: Eine NAND-Verknüpfung kann

aufgelöst werden, indem man das UND-Glied in ein ODER-Glied

umwandelt und die Negation auf die einzelnen Variablen anwendet.

Für die NOR-Verknüpfung gilt: Das Ganze funktioniert auch in die

umgekehrte Richtung. Eine NOR-Verknüpfung kann aufgelöst werden,

indem man das ODER-Glied in ein UND-Glied umwandelt und die

Negation auf die einzelnen Variablen anwendet.

Die Regeln von DeMorgan lassen sich natürlich nicht nur auf NAND- und

NOR-Verknüpfungen anwenden. Hierbei wendet man folgende Regeln

an:

• Jede einzelne Variable wird negiert.

• Zusätzlich wird der gesamte Term negiert.

• Der Operator UND wird zu ODER, ODER wird zu UND vertauscht.




Doppelte Negation

NICHT NICHT A ist dasselbe wie A. Daraus kann man ableiten, dass sich

eine doppelte Negation aufhebt. Dies erkennt man auch bei der

Umwandlung von NOR- oder NAND-Verknüpfungen. Hierbei geht man

wie folgt vor.

Beispiel NAND-Verknüpfung:

• Die einzelnen Variablen werden negiert.

• Der Operator UND wird zu ODER.

• Zusätzlich wird der gesamte Term negiert.

• Dadurch, dass über dem gesamten Term bereits eine Negation

vorhanden war, sind nach diesen 3 Vorgängen 2 Negationen.

• Eine doppelte Negation hebt sich auf und übrig bleibt ein Term, in

dem die einzelnen Variablen negiert sind und mit ODER verknüpft

sind.

Ausmultiplizieren

Mit dem Absorptionsgesetz können durch Ausmultiplizieren auch Terme

zu einem Ausdruck hinzugefügt werden. Beispiel für den Term A ODER

(NICHT A UND B).

Multipliziert man das aus, erhält man erstmal:




• A ODER A und NICHT A ODER A UND B ODER NICHT A UND B.

• A UND NICHT A ergibt gemäß Negationsgesetz 0 und kann

gestrichen werden.

• Übrig bleibt A ODER A UND B ODER NICHT A UND B.

• Bei A UND B ODER NICHT A UND B wird das Absorbtionsgesetz

angewendet.

• A ODER NICHT A spielt also keine Rolle und kann ebenfalls

gestrichen werden.

• Übrig bleiben A ODER B.

Vorrangregeln und Klammerregeln

Vorrangregeln

Wie in der Mathematik, gibt es auch innerhalb der Schaltalgebra

Vorrangregeln, in den festgelegt wird, in welcher Reihenfolge die

Operationen durchzuführen sind. Diese sind:

• Negation oder Inversion (NICHT - Verknüpfung)

• Disjunktive Normalform DNF (ODER - Verknüpfung)

• Konjunktive Normalform KNF (UND - Verknüpfung)




Klammerregeln

NOR - Verknüpfung: Eine Klammerung ist nicht notwendig.

UND - Verknüpfung: Eine Klammerung ist nicht notwendig.

ODER - Verknüpfung: Da UND-Verknüpfungen vor ODER-Verknüpfungen

gehen (Punkt- vor Strichrechnun), ist eine Klammerung notwendig. Vor

allem wenn die Regeln von DeMorgan bei NAND- und NOR-

Verknüpfungen angewendet werden, ist eine Klammerung unabdingbar.




Binäre Operationen

Auf den folgenden Seiten findet man Informationen zu den

Grundlagen einer speicherprogrammierten Steuerung.

Binäre Verknüpfungen und Abfragen

• Variablennegation

• Die UND-Verknüpfung, Konjunktion (AND, UND)

• Die ODER-Verknüpfung, Disjunktion (OR, ODER)

• Die Exklusiv-ODER-Verknüpfung (XOR)

• Die Negation einer Verknüpfung

• NAND-Verknüpfung

• NOR-Verknüpfung

• Das Verknüpfungsergebnis VKE

Zusammengesetzte binäre Grundverknüpfungen

• Beispiel einer UND-vor-ODER Verknüpfung

• Beispiel einer ODER-vor-UND Verknüpfung

• Exklusiv-ODER-Verknüpfungen vor einer UND-Verknüpfung

• UND-Verknüpfungen vor einer Exklusiv-ODER-Verknüpfung

• Exklusiv-ODER-Verknüpfungen vor einer ODER-Verknüpfung

• ODER-Verknüpfungen vor einer Exklusiv-ODER-Verknüpfung

• Verwendung von Merkern

Speicherfunktionen, Flipflops

• Entstehung des Speicherverhaltens

• Verriegeln von Speicherfunktionen

Gegenseitiges Verriegeln




• Verriegeln über den Rücksetzeingang

• Verriegelung über den Setz-Eingang

Reihenfolgeverriegelung

• Verriegelung über den Setz-Eingang

• Verriegelung über den Rücksetz-Eingang

Flankenauswertung in Step7

• Positive Flanke, Abfrage "0" auf "1"

• Negative Flanke, Abfrage "1" auf "0"

• Flankenoperand FO

Binäruntersetzer

• Binäruntersetzer in Step7

• schematische Anweisungsliste für einen Binäruntersetzer in

Step7®

Zeitfunktionen / Timer in Step7

• Zeitfunktion SA - Ausschaltverzögerung

• Zeitfunktion SE - Einschaltverzögerung

• Zeitfunktion SI - Impuls

• Zeitfunktion SS - speichernde Einschaltverzögerung

• Zeitfunktion SV - verlängerter Impuls

Erzeugung von Taktsignalen in Step7

• Taktgeber

• Taktmerker

• Weckalarm-Organisationsbausteine

Zählerfunktionen / Counter in Step7




• Allgemeines zu Zählern, Zählfunktionen, Counter

• Übersicht über die drei Zähler nach DIN EN 61131-3

• Zählerfunktionen in Step7

• Zählerfunktionen in Step7 programmieren




Binäre Verknüpfungen und Abfragen

Wenn binäre Signalzustände (0 oder 1) von Variablen über eine

Funktion miteinander verbunden werden, so spricht man von

Verknüpfungen. Mit der Negation (NICHT) und den

Grundverknüpfungen UND bzw. ODER lassen sich sämtliche

Verknüpfungen realisieren, auch wenn sie noch so kompliziert sind. Eine

Erleichterung beim Programmieren einer SPS stellt die Verknüpfung

XOR (Exklusiv-ODER) dar, die in den meisten SPS bereits als fertige

Verknüpfung vorhanden ist. Die Verknüpfungen UND, ODER usw.

werden als Operatoren bezeichnet. Diese Operatoren verknüpfen die

Operanden (Eingänge, Merker, Zähler oder Zeiten) miteinander.

Für die tabellarische Darstellung einer Schaltfunktion kann man

Schaltwerttabellen benutzten, die auch Funktionstabellen genannt

werden. Damit werden die Aussagenlogiken der binären Verknüpfungen

verständlicher dargestellt. Die Eingangsvariablen werden links

angeordnet, die Ausgansvariablen rechts. Anhand der Schaltwerttabelle

kann man genau sehen, wie sich die Ausgänge, abhängig vom Zustand

der Eingänge, verhalten.




Die Negation

Eine Negation (NOT, NICHT) wird dann verwendet, wenn der

Signalwert einer Variablen negiert werden soll. (0 = 1, 1 = 0).

Darstellung in KOP, FUP und AWL hier.

Schaltwerttabelle:

Anhand der Schaltwerttabelle wird deutlich, wie sich eine Negation

auswirkt. Der Ausgang wird negiert, wenn der Eingang ein Signal von 1

liefert. Das bedeutet wiederum, wenn der Eingang ein Signal von 0

liefert, hat der Ausgang das Signal 1.

Die UND-Verknüpfung, Konjunktion (AND, UND)

Für eine effektive Umsetzung der UND-Verknüpfung braucht man

mindestens 2 Eingangsvariablen, die mit dem UND-Glied miteinander

verknüpft werden. Die Logik der Schaltfunktion ist, dass das Signal der

Ausgangsvariable nur eine 1 ist, wenn auch alle Eingangsvariablen das

Signal 1 haben. Sobald irgendeine Eingangsvariable das Signal 0 liefert,

hat die Ausgangsvariable ebenfalls das Signal 0. Darstellung in KOP,

FUP und AWL hier.



https://www.sps-lehrgang.de/anweisungsliste-awl/#c868

https://www.sps-lehrgang.de/funktionsplan-fup/#c696

https://www.sps-lehrgang.de/kontaktplan-kop/#c278


Schaltwerttabelle:

Die ODER-Verknüpfung, Disjunktion (OR, ODER)

Auch beim ODER-Glied braucht man für die effektive Umsetzung

mindestens 2 Variablen, die über das ODER-Glied miteinander verknüpft

werden. Hier verhält sich die Schaltfunktion anders. Hier braucht nur

eine einzige Eingangsvariable das Signal 1 zu liefern, damit die

Ausgangsvariable ebenfalls eine 1 hat. Nur wenn alle Eingangsvariable

das Signal 0 liefern, hat die auch Ausgangsvariable das Signal 0.


Schaltwerttabelle:




Die Exklusiv-ODER-Verknüpfung (XOR)

Das Exklusiv-ODER-Glied, auch XOR-Glied genannt, ist eine Erweiterung

des ODER-Glieds. Die Schaltfunktion verhält sich so, dass die

Ausgangsvariable bei 2 Eingängen nur dann ein Signal von 1 hat, wenn

eine Eingangsvariable exklusiv auf 1 steht. Das bedeutet, in dem Fall

darf die andere Eingangsvariable nicht auf 1 stehen. Darstellung in

KOP, FUP und AWL hier.

Schaltwerttabelle:

Negation einer UND- oder OR-Verknüpfung

Das Ergebnis einer UND- oder einer ODER-Verknüpfung kann negiert

werden. In dem Fall wird der Ausgang durch die Operation NOT negiert.

Ist der Ausgang einer UND-Verknüpfung negiert, bezeichnet man als

NAND-Verknüpfung (NICHT-UND). Ist der Ausgang einer ODER-

Verknüpfung negiert, bezeichnet man das als NOR-Verknüpfung (NICHT-

ODER).




NAND-Verknüpfung

Durch die Negation wird bei der NAND-Verknüpfung das Ergebnis einer

UND-Verknüpfung umgedreht. Die Ausgangsvariable hat das Signal von

1, wenn alle Eingangsvariablen nicht ein Signal von 1 haben.


Schaltwerttabelle:

NOR-Verknüpfung

Bei der NOR-Verknüpfung wird das Ergebnis einer ODER-Verknüpfung

umgedreht. Die Ausgangsvariable hat nur dann ein Signal von 1, wenn

alle Eingangsvariablen ein Signal von 0 liefern. Darstellung in KOP, FUP

und AWL hier.




Schaltwerttabelle:




Negierte Exklusiv-ODER-Verknüpfung, auch Exklusiv-NICHT-ODER genannt (XNOR)

Das Ergebnis einer XOR-Verknüpfung kann ebenfalls negiert werden. In

dem Fall spricht man von einer Exklusiv-NICHT-ODER-Verknüpfung

(XNOR). Auch hier verhält es sich genau umgekehrt wie bei der XOR-

Verknüpfung. Die Ausgangsvariable hat ein Signal von 1, wenn das

Signal der Eingangsvariablen nicht exklusiv ist.

Schaltwerttabelle:

Zusammengesetzte Verknüpfungen

Bei der SPS-Programmierung wird nicht nur ein Verknüpfungsglied

benutzt. SPS-Programme bestehen in der Regel aus einer Vielzahl an

ODER-, UND- oder XOR-Gliedern und weitere Dinge mehr. Da hierbei

viele Verknüpfungen zusammengesetzt werden, spricht man von

zusammengesetzten Verknüpfungen. Dabei bleibt das grundsätzliche

Verhalten jedes einzelnen Glieds erhalten.




Zuweisung des Ausgangs über das

Verknüpfungsergebnis, VKE

Beim Einsatz von binären Verknüpfungen, entscheidet der abgefragte

Zustand der Eingänge darüber, ob der Ausgang 0 oder 1 sein soll. Ob

das Ergebnis eine 0 oder 1 ist, wird über einen Zwischenspeicher, dem

Verknüpfungsergebnis (VKE) realisiert. Bei der Abarbeitung eines SPS-

Programms wird das VKE auf 0 oder 1 gesetzt. Der Zustand des VKE

kann sich dabei Zeile für Zeile ändern. Bei der Zuweisung eines

Ausgangsoperanden wird der Wert aus dem VKE übernommen.




Zusammengesetzte binäre Verknüpfungen

Ein SPS-Programm besteht nicht nur aus einem ODER-, UND- oder XOR-

Glied. Ein SPS-Programm besteht in der Regel aus einer Vielzahl an

binären Verknüpfungen. Da hierbei viele Verknüpfungen

zusammengesetzt werden, spricht man von zusammengesetzten

Verknüpfungen. Dabei werden viele ODER-, UND- oder XOR-Glieder

miteinander verknüpft, um ein gewünschtes Schaltungsverhalten zu

realisieren.

UND vor ODER-Verknüpfungen

UND vor ODER-Verknüpfungen liegen dann vor, wenn die UND-Glieder

vor dem ODER-Glied positioniert werden. In solchen Fällen führen die

Ausgänge der UND-Glieder an das ODER-Glied.

Auf dem Beispielbild führen die Ausgänge der zwei ODER-Glieder mit je

zwei Eingangsvariablen an eine ODER-Box. Das Schaltverhalten ist

identisch mit dem einer XOR-Verknüpfung.

Vor dem ODER-Glied müssen nicht ausschließlich alle Ausgänge einer

UND-Verknüpfung zum ODER-Glied führen. Es kann auch eine

Kombination aus UND vor ODER und einer anderen Verknüpfung




vorhanden sein. Auf dem Beispielbild werden die beiden UND-

verknüpften Eingänge E0.1 und E0.2 abgefragt. Zusätzlich wird an dem

ODER-Glied der Eingang E0.3 abgefragt.

ODER vor UND-Verknüpfungen

Bei dieser Form ist es genau umgekehrt. Bei der ODER vor UND-

Verknüpfung führend die Ausgänge der ODER-Glieder zum UND-Glied.

Bei dieser Form ist die Schaltfunktion konjunktiv.

Das bedeutet, nur wenn alle Bedingungen zutreffen (da UND-

verknüpft), erhält der Ausgang das Signal 1. Sollen weitere

Bedingungen hinzukommen, fügt man deren Ausgänge einfach vor die

UND-Box.

Auch bei der ODER vor UND-Verknüpfung müssen die Glieder vor dem

UND-Glied nicht ausschließlich aus ODER-Gliedern bestehen. Eine




Kombination ist hier ebenfalls möglich.

Auf dem Beispielbild wird ein ODER-Glied (E0.1, E0.2) abgefragt.

Außerdem wird die die Eingangsvariable E0.3 auf den Zustand der

Negation abgefragt.

Exklusiv-ODER vor UND-Verknüpfungen

Führen die Ausgänge von XOR-Gliedern zum ODER-Glied, hat man es

mit einer Exklusiv-ODER vor UND-Verknüpfung zu tun. Hierbei

verknüpft man XOR-Glieder mit einem UND-Glied. In der

Darstellungsart AWL erkennt man, dass bei dieser Variante die XOR-

Verknüpfungen in Klammern stehen. Schaltungstechnisch ist das so zu

verstehen, dass bei den beiden XOR-Gliedern jeweils eine

Eingangsvariable exklusiv das Signal 1 haben muss, damit der Ausgang

das Signal 1 hat.




Exklusiv-ODER vor ODER-Verknüpfungen

Auch wenn die Ausgänge der XOR-Glieder zu einem ODER-Glied führen,

ist in der Darstellungsart AWL ersichtlich, dass die XOR-Verknüpfungen

in Klammern stehen. Schaltungstechnisch verhält es sich hier aber

anders als beim XOR-vor-UND-Verknüpfung. Der Ausgang hat ein Signal

von 1, wenn lediglich eine Eingangsvariable von den zwei XOR-Gliedern

exklusiv das Signal 1 hat.

UND vor Exklusiv-ODER-Verknüpfungen

Führen die Ausgänge von UND-Gliedern zu XOR-Gliedern, dann spricht

man von UND vor Exklusiv-ODER-Verknüpfungen. In der Darstellungsart

AWL verhält es sich hier umgekehrt. Diesmal stehen die UND-

Verknüpfungen in Klammern. Schaltungstechnisch ist das so zu

verstehen, dass exklusiv eine von den beiden UND-Boxen das Signal 1

führen müssen.




ODER vor Exklusiv-ODER-Verknüpfungen

Führen die Ausgänge von ODER-Gliedern zum XOR-Glied, nennt man

das ODER vor Exklusiv-ODER-Verknüpfung. In der Darstellungsart AWL

wird deutlich, dass diesmal die ODER-Verknüpfungen in Klammern

stehen. Schaltungstechnisch ist das so zu verstehen, dass der Ausgang

das Signal 1 hat, wenn ein ODER-Glied exklusiv das Signal 1 führt.

Wenn beide ODER-Glieder das Signal 1 führen, was durchaus

vorkommen kann, dann ist der Ausgang 0.




Das Verknüpfungsergebnis VKE

Bei einem Programmablauf werden die binären Verknüpfungen

ausgewertet, indem man z.B. den Zustand der Eingänge über den

Prozessabbild der Eingänge abfragt. Je nachdem, ob die Eingänge eine 0

oder 1 als Signal liefern, haben die Ausgänge, abhängig von der

Schaltungslogik, über Zuweisungen eine 0 oder 1. Diese Zuweisung

erfolgt über einen Zwischenspeicher. Der Zwischenspeicher wird

Verknüpfungsergebnis oder abgekürzt VKE genannt, der nur die

beiden Zustände 0 oder 1 haben kann.

VKE während der Abarbeitung des SPS-

Programms

Die Abarbeitung eines SPS-Programms erfolgt durch die SPS in AWL.

Dabei wird das Programm Zeile für Zeile ausgewertet. Die erste

Abfrageoperation einer Verknüpfungskette nennt sich Erstabfrage. Das

Ergebnis einer Erstabfrage wird als VKE übernommen und dadurch wird

das vorherige VKE überschrieben. Bei der nächsten Abfrageoperation

wird das VKE mit der Abfrageoperation verknüpft und das VKE wird neu

gebildet. Bei den nächsten Abfrageoperationen erfolgt dasselbe, bis das

Programm abgearbeitet ist. Daher kann sich das VKE Zeile für Zeile

ändern. Erfolgt im Programm eine Zuweisung, wird der Wert vom VKE

übernommen. Nach Beendigung der Verknüpfungskette, z.B. über

Zuweisung, erfolgt bei der Abfrageoperation erneut eine Erstabfrage.

Das VKE kann im Programmablauf manuell auf 0 oder 1 gesetzt werden.

Hierfür gibt es die Befehle "CLR" und "SET". Diese Befehle können nur




in der Darstellungsart AWL programmiert werden und ermöglichen, dass

das VKE unabhängig vom Zustand der Operanden auf 0 oder 1 gesetzt

wird.

Verlauf des VKE bei einem Beispielprogramm

Um das Verhalten des VKE zu verstehen, ist nachfolgend eine

Bildergalerie mit einem Beispielprogramm. Bei jedem Bild liefern die

Eingangsoperanden unterschiedliche Signale. So kann man sehen, wie

sich das VKE bei den unterschiedlichen Zuständen in jeder Zeile verhält.

In Step7 wird das VKE für die Programmbeobachtung nur in AWL

angezeigt. Hierfür schaltet man zuerst auf die Darstellungsart AWL um.

Nach dem Einschalten der Programmbeobachtung kann man auf der

rechten Seite das VKE sehen. Wird das VKE nicht angezeigt, klickt man

mit der rechten Maustaste in den rechten Bereich, öffnet das Menü

"Einblenden" und wählt aus dem öffnenden Menü

"Verknüpfungsergebnis" aus.




Verlauf des VKE während eines

Programmablaufs

Bild 1: Das Beispielprogramm. Eine einfache ODER vor UND-

Verknüpfung.

Bild 2: Alle Eingangsoperanden sind 0. Das VKE ist daher

durchgehend 0.




Bild 3: Eingangsoperand E0.1 ist 1.

• In Zeile 1 wird mit U( das Erstabfragebit /ER auf 0 gesetzt. Das

bedeutet, dass die nächste Verknüpfungskette mit einer

Erstabfrage beginnt.

• Die Erstabfrage erfolgt in Zeile 2. Das Ergebnis 0 wird als VKE

übernommen.

• In Zeile 3 wird die Abfrageoperation O E0.1 mit dem VKE

verknüpft. Es wird in etwa abgefragt "Ist das VKE oder E0.1 eine

1?".

• In Zeile 5 wird /ER auf 0 gesetzt. Damit beginnt die nächste

Verknüpfungskette wieder mit einer Erstabfrage.

• Die nächste Erstabfrage in Zeile 6 ergibt das Ergebnis 0. Das

Ergebnis wird in das VKE geschrieben. Auch die nächsten Zeilen

ergeben ein VKE 0 0.





• Diesmal ist das VKE bereits bei der Erstabfrage eine 1. Ansonsten

gibt es keine großen Unterschiede zu Bild 3.





• Dies mal ist das Ergebnis der Erstabfrage sowie der

nachfolgenden Abfrageoperationen bis zur 6. Zeile 0.

• In Zeile 7 hat zwar das VKE eine 1, da E1.1 eine 1 liefert.

• Durch das Flag der UND-Verknüpfung mit der vorherigen Abfrage

ist das VKE in Zeile 8 aber wieder 0.


• Hier verhält es sich wie bei Bild 5, außer dass das VKE bereits in

Zeile 6 eine 1 ist.




Bild 7: E0.0 und E1.0 sind 1.

• Diesmal führen beide Ausgänge der ODER-Glieder eine 1, da an

beiden Gliedern jeweils ein Eingangsoperand eine 1 liefert.

• Das VKE ist bereits bei der Erstabfrage eine 1.

• Am Ende erfolgt die Zuweisung mit dem Wert des VKE, der eine 1

ist.




Bild 8: E0.1 und E1.1 sind 1.

• Hier verhält es sich wie in Bild 7. Lediglich die Erstabfrage und die

Abfrageoperation in Zeile 6 sind unterschiedlich.

• Der Ausgang erhält am Ende trotzdem den Wert 1 vom VKE, da

am jeweils ein Eingangsoperand der beiden ODER-Glieder eine 1

liefern.




Merker - Speichern von Zwischenergebnissen in der SPS

Merker sind Adressregister innerhalb der CPU. Die Anzahl der

verfügbaren Merkerbytes hängt von der jeweiligen CPU ab und kann aus

den technischen Daten entnommen werden. Man kann in einem SPS-

Programm Merkerbits, Merkerbytes, Merkerwörter oder

Merkerdoppelwörter benutzen. Je nachdem wie viele Bitstellen man

benötigt.

Beispiele für die Adressierung:

• Merkerbitadresse: M13.5

• Merkerbyteadresse: MB18

• Merkerwortadresse: MW2

• Merkerdoppelwortadrese: MD6




Die Adressen im Register Merker können für vielfältige Aufgaben

nützlich sein. Hauptsächlich werden sie als Zwischenspeicher benutzt.

Daher kommt auch der Name. Die Adressen im Register merken sich

Signale, ohne dabei irgendeinen Ausgangsoperanden zu verwenden.

Man kann Merker auch als interne Speicher betrachten, die für

vielfältige Aufgaben in einem SPS-Programm verwendet werden

können. Wenn z.B. das Ergebnis einer Verknüpfung nicht zu einem

Ausgangssignal 1 führen soll, man das Ergebnis der Verknüpfung aber

"irgendwo" speichern möchte, da man das Ergebnis der Verknüpfung an

einer anderen Stelle im Programm erneut abfragt, dann kann man zum

Speichern des Ergebnisses eine Merkeradresse verwenden.

Beispiel:

• Man hat zwei Eingangsoperanden mit einer UND-Verknüpfung.

• Wenn man dieselbe UND-Verknüpfung mit denselben

Eingangsoperanden mehrfach im Programm verwenden möchte,

kann man das Ergebnis der UND-Verknüpfung in einer

Merkerbitadresse speichern.

• An jeder Stelle des Programms, an dem die UND-Verknüpfung mit

den beiden Eingangsoperanden verwendet werden soll, braucht

man nicht mehr jedes Mal eine neue UND-Verknüpfung zu

erstellen.

• Stattdessen nimmt man einfach die Merkerbitadresse, die den

Zustand der UND-Verknüpfung erhalten hat.

Häufig werden Merker auch als Flankenoperanden bei einer

Flankenauswertung verwendet, da man hier eine Bitadresse benötigt,

der nur intern verwendet wird. Mit Merkern kann man in Verbindung mit




SR-Gliedern auch Schrittketten realisieren. Dabei wird zunächst einmal

den SR-Gliedern Merkeradressen zugewiesen. Die Zuweisung der

Ausgänge erfolgt dann über die Merker. So hätte man eine Trennung

zwischen dem Programmcode und den Ausgängen. Sollen Ausgänge

vertauscht werden, braucht man nur die Zuweisungen zu ändern, indem

man die Merkeradressen vertauscht.

Verwendung von Merkern

Auch wenn die Verwendung von Merkern vielfältige Vorteile bietet und in

SPS-Programmiernorm IEC 61131-3 als Operanden genannt werden, die

einen festen Speicherplatz innerhalb der CPU haben, sollte man sich

angewöhnen, auf Merker weitestgehend zu verzichten. In der Praxis

wird es auch so gehandhabt, dass man auf die Verwendung von

Merkern wo es geht verzichtet. Der Grund ist, dass Merkeradressen

feste Adressen sind, die in einem Anwenderprogramm

bausteinübergreifend gültig sind. Wenn Bausteine (FB, FC)

programmiert werden, führt die Verwendung von Merkern dazu, dass

diese nicht mehr bibliotheksfähig sind.

Ein weiterer Grund ist, dass wenn Merkeradressen benutzt werden,

besonders bei großen Programmen die Übersicht verloren geht. Es

besteht die Gefahr, dass Merker doppelt verwendet werden, was dann

zu Fehlern im Programm führt. Die Fehlersuche zum Beheben des

Problems kann dabei sehr zeitaufwendig sein. Deshalb wird in der

Praxis, insbesondere bei der Programmierung von großen

Anwenderprogrammen auf die Verwendung von Merkern weitestgehend




verzichtet.

Durch den Verzicht auf Merker hat man den Vorteil, dass Codebausteine

bibliotheksfähig sind und somit beliebig oft verwendet werden können,

da die in den Bausteinen verwendeten Variablen frei zuweisbar sind.

Werden Signale in Merkern gespeichert, behalten sie auch außerhalb

des Bausteins ihre Gültigkeit. Bei Spannungsausfall gehen diese

verloren. Es gibt auch sogenannte remanente Merker, die ihre

gespeicherten Informationen bei einem Spannungsausfall nicht

verlieren. Nichtremanente Merker haben dagegen nach einem Neustart

der CPU oder bei einem erneuten Anlaufen den Signalzustand "0".




Speicherfunktionen in SPS - SR- und RS-Flipflops

Bei der Realisierung von Steuerungsaufgaben mit den UND-, ODER-

oder XOR-Verknüpfungen hat man das Verhalten, dass der

Ausgangsoperand nur solange das Signal 1 liefert, solange der Zustand

der Eingangsoperanden gemäß der Schaltungslogik ist. Das bedeutet,

wenn sich der Zustand eines Eingangsoperanden ändert, kann sich auch

das Signal des Ausgangsoperanden ändern.

Häufig möchte man jedoch den Zustand des Ausgangsoperanden

beibehalten (speichern), auch wenn sich im Nachhinein die

Eingangsoperanden ändern. Insbesondere in Verbindung mit der

Flankenauswertung wird ein "speicherndes Verhalten" des

Ausgangsoperanden gebraucht, da bei einer Flankenauswertung

lediglich ein kurzzeitiges Signal geliefert wird. Hierfür gibt es bei

Speicherprogrammierbaren Steuerungen sogenannte Speicherglieder.

Mit den Speicherfunktionen ist es möglich, solch ein kurzzeitiges Signal

zu nutzen, um Ausgangsoperanden solange auf 1 zu setzen, bis man

diese mit einem anderen Signal zurücksetzt.

Funktionsweise von Speicherfunktionen

Ein kurzzeitiges Signal reicht aus, damit ein Ausgangsoperand über die

Speicherfunktion das Signal 1 hat und den Zustand speichert. Das

kurzzeitige Signal setzt dabei über den Setzeingang des Speicherglieds




diesen auf 1. Es gibt jedoch auch eine Möglichkeit, das Speicherglied

wieder auf 0 zu setzen. Das wird über den Rücksetzeingang realisiert.

Dementsprechend haben Speicherglieder einen Setz- und einen

Rücksetzeingang. Deshalb nennt man diese auch SR-Glieder oder RS-

Glieder. Der Unterschied zwischen SR und RS ist:

• SR-Glieder sind rücksetzdominant

• RS-Glieder sind setzdominant

Die Unterscheidung zwischen setz- und rücksetzdominanten

Speichergliedern ist deshalb wichtig, da es durchaus vorkommen kann,

dass an beiden Eingängen (Setz- und Rücksetzeingang) ein Signal von 1

liegt. In solchen Fällen muss die SPS wissen, was geschehen soll, setzen

oder rücksetzen. Bei setzdominanten (RS-Gliedern) Speichergliedern

wird gesetzt, bei rücksetzdominanten (SR-Gliedern) wird rückgesetzt.

Warum SR-Flipflops rücksetzdominant und RS-Flipflops setzdominant

sind, erkennt man, wenn sich das Programm in AWL anschaut. Bei SR-

Flipflops kommt die Anweisung zum Setzen des Speicherglieds zuerst,

danach kommt die Anweisung zum Rücksetzen. Da das SPS-Programm

von oben nach unten abgearbeitet wird, gilt das, was zuletzt in der

Anweisung steht. Und das ist bei SR-Flipflops Rücksetzen. Umgekehrt

verhält es sich bei RS-Flipflops. Hier kommt die Anweisung zum




Rücksetzen des Speicherglieds zuerst und danach die Anweisung zum

Setzen.

Wichtig: Ob ein SR- oder RS-Glied setz- oder rücksetzdominant ist, ist

nicht einheitlich. Gemäß IEC 61131 ist ein SR-Glied setzdominant und

ein RS-Glied rücksetzdominant. Hierbei wird zur besseren

Unterscheidung eine 1 an den dominanten Eingangsbuchstaben

angehängt (S1 oder R1). Bei der S7-300 Reihe wird beispielsweise

davon abgewichen (SR-Glied rücksetzdominant, RS-Glied setzdominant,

keine 1 am dominanten Eingangsbuchstaben). Da wir uns auf diesen

Seiten hauptsächlich auf die S7-Reihe ab 300 beziehen, wird in den

vorgestellten Beispielen und Lösungen auch davon ausgegangen! Das

Dominanzverhalten der Speicherglieder sollte bei jedem Gerät vorher

geprüft bzw. aus der Dokumentation entnommen werden.

Speicherverhalten mit UND-, ODER-Gliedern

realisieren

Die Programmiersoftware der meisten Hersteller enthalten bereits




fertige SR- und RS-Speicherglieder nach der Programmiernorm IEC

6113-3 als Standardbausteine. Man kann die Speicherglieder in der

Darstellungsart FUP oder KOP direkt auswählen und braucht nur die

Operanden an den Setz- und Rücksetzeingängen einzutragen bzw. die

symbolischen Bezeichnungen gemäß Symboltabelle. Alternativ kann

man das Setz- und Rücksetzverhalten von Speichergliedern direkt in

AWL programmieren.

Man kann auch ein Speicherverhalten nur mit UND- und ODER-Gliedern

realisieren. Um ein rücksetzdominantes Speicherverhalten zu

realisieren, benutzt man eine ODER vor UND-Verknüpfung. Für ein

setzdominantes Speicherverhalten benutzt man eine UND vor ODER-

Verknüpfung. Nachfolgend die Abbildungen für setz- und

rücksetzdominantem Speicherverhalten.

Das Speicherverhalten wird in beiden Beispielen dadurch realisiert, dass

man den Ausgang wieder als Eingangsoperanden benutzt. Dadurch wird

erreicht, dass der Ausgang dauerhaft ein Signal von 1 hat, nachdem der

Eingangsoperand, in diesem Beispiel E0.1, kurzzeitig das Signal 1 hat.

Der Ausgangsoperand selbst sorgt dafür, dass er selbst das Signal von 1

hält. Diese Art des Speicherverhaltens nennt man daher auch

Selbsthaltung.




Die Dominanz des Setz- oder Rücksetzeingangs realisiert man durch

eine UND vor ODER-Verknüpfung oder umgekehrt. Zum

rücksetzdominantem Speicherverhalten braucht man eine UND-

Verknüpfung mit dem Eingangsoperanden, in diesem Beispiel E0.2, zum

Rücksetzen. Solange E0.2 kein Signal von 1 hat, ist die Bedingung für

das Speicherverhalten gegeben. Ist E0.2 eine 1, ist die Bedingung nicht

mehr gegeben und der Ausgangsoperand erhält das Signal 0. Dadurch

hat man ein rücksetzdominantes Verhalten.

Ein setzdominantes Verhalten erreicht man durch eine ODER-

Verknüpfung. Wenn E0.2 ein Signal von 1 liefert, würde die Bedingung

für die Selbsthaltung nicht gegeben sein. Es sei denn, der

Eingangsoperand am ODER-Glied, in diesem Beispiel E0.1, hat das

Signal 1. Dadurch, dass dieser mit dem ODER-Glied verknüpft ist, ist die

Bedingung zum Setzen des Ausgangsoperanden gegeben, da bei einer

ODER-Verknüpfung es ausreicht, wenn nur eine Bedingung zutrifft. Ein

setzdominantes Verhalten wäre realisiert.

Trennung der Setz- und Rücksetzanweisung

Die Anweisung zum Setzen oder Rücksetzen eines Operanden muss

nicht direkt hintereinander erfolgen. Man kann die Anweisung auch

getrennt voneinander, an unterschiedlichen Stellen im Programm,

ausführen. Hierfür enthalten die meisten Programmiersoftware eigene

Bausteine, die lediglich eine Setz- oder Rücksetzanweisung enthalten.

Man kann Setz- und Rücksetzanweisungen auch in AWL an




verschiedenen Stellen im Programm eingeben.

Nachteilig bei dieser Variante ist, dass die Übersicht verloren geht, da

die Bedingungen zum Setzen und Rücksetzen an unterschiedlichen

Stellen im Programm stehen. Der Vorteil ist, dass man den Zustand des

VKE nutzen kann und mehrere Setz- oder Rücksetzanweisungen auch

hintereinander eingeben kann.

Setz-, Rücksetz- oder Zuweisungsoperationen hintereinander ändern

nicht das VKE. Daher kann man diese hintereinander eingeben. Erst bei

einer erneuten Abfrageoperation wird das VKE mit der Abfrageoperation

verknüpft und neu gebildet. Nachfolgend ein Beispiel, wie man Setz-

und Rücksetzbefehle separat für unterschiedliche Ausgangsoperanden

hintereinander eingeben kann.

Direktes Setzen eines Ausgangsoperanden

Wenn man ein SR- oder RS-Glied benutzt, dann erwartet die CPU

zwingend einen Operanden zum Setzen bzw. zum Rücksetzen. Hierbei




kann ein Ausgangsoperand direkt gesetzt oder rückgesetzt werden. Man

kann zum Setzen und Rücksetzen auch einen Merker benutzen und die

Zuweisung mit dem Ausgang des SR- oder RS-Glieds verbinden.

Verriegeln von Speichergliedern

In Steuerungen muss man häufig Speicherglieder verriegeln, damit z.B.

ein Speicherglied nur gesetzt werden kann, wenn ein anderes

Speicherglied gesetzt ist. Man kann Speicherglieder auch so verriegeln,

dass sie nur rückgesetzt werden können, wenn andere Speicherglieder

bereits rückgesetzt sind. Ein Beispiel wäre eine Förderbandanlage mit

mehreren Förderbändern. Ein Förderband soll nur gesetzt werden, wenn

das Förderband davor ebenfalls gesetzt wurde, um Staus zu vermeiden.




Verriegeln von SR- und RS-Flipflops

Steuerungen enthalten häufig die Anforderung, dass man

Speicherglieder verriegeln muss. Wenn man z.B. eine Förderbandanlage

mit mehreren Förderbändern hat, ein Förderband noch nicht läuft und

die anderen aber bereits anfangen anzulaufen, können die auf den

Förderbändern transportierten Materialien Staus verursachen. Im

schlimmsten Fall entstehen große finanzielle Schäden. In solchen Fällen

kann man Speicherglieder verriegeln und die Bedingung für das Setzen

mit anderen Speichergliedern verknüpfen. Dabei gibt es mehrere Arten

von Verriegelungen:

• Gegenseitige Verriegelung

• Reihenfolgeverriegelung

Gegenseitiges Verriegeln

Diese Variante der Verriegelung wird dann genutzt, wenn niemals zwei

oder mehrere Speicherglieder gleichzeitig gesetzt werden dürfen. Wenn

ein Speicherglied bereits gesetzt wurde, dürfen die anderen

Speicherglieder nicht gesetzt werden. Das gesetzte Speicherglied

verriegelt dabei die anderen.

Ein Beispiel wäre hierfür z.B. das Setzen zweier Elektromotoren an

einem Tor. Der eine Motor hat einen Rechtslauf zum Öffnen, der andere

einen Linkslauf zum Schließen des Tors. Beide Motoren dürfen hierbei

nie gleichzeitig laufen, da ansonsten große Schäden entstehen können.




Reihenfolgeverriegelung

Diese Variante der Verriegelung wird dann genutzt, wenn

Speicherglieder nur gesetzt (oder rückgesetzt) werden dürfen, wenn

andere Speichergelieder bereits gesetzt (oder rückgesetzt) sind.

Ein Beispiel für diese Variante wäre eine Mischanlage mit zwei Ventilen

zum Mischen von Materialien. Ein Ventil soll nur öffnen und den Behälter

mit Materialien füllen, wenn das andere bereits Ventil geöffnet und den

Behälter füllt.

Gegenseitiges Verriegeln über den

Rücksetzeingang

Bei dieser Variante dürfen nur rücksetzdominante Speicherglieder (SR-

Glieder) verwendet werden, da man hier die Rücksetzdominanz zu

Nutze macht und die Operanden der jeweils anderen Speicherglieder an

den Rücksetzeingang einträgt. Dadurch wird erreicht, dass sobald ein

anderes Speicherglied gesetzt wurde, ein Speicherglied nicht mehr

gesetzt werden kann. Selbst wenn am Setzeingang die Bedingung zum

Setzen erfüllt wird, setzt das bereits gesetzte Speicherglied diesen

aufgrund der Rücksetzdominanz der SR-Glieder zurück.




In diesem Beispiel werden die Ausgangsoperanden A0.1 und A0.2

verwendet. Ist A0.1 bereits gesetzt, kann A0.2 nicht mehr gesetzt

werden. Umgekehrt verhält es sich genauso. Ist A0.2 bereits gesetzt,

kann A0.1 nicht mehr gesetzt werden. Man hätte eine gegenseitige

Verriegelung erreicht.

Gegenseitiges Verriegeln über den Setzeingang

Mehrere Speicherglieder können auch über den Setzeingang gegenseitig

verriegelt werden. Hierfür werden die anderen Speicherglieder mit einer

UND-Verknüpfung am Setzeingang eingetragen und negiert. Dadurch

wird erreicht, dass ein Speicherglied nur gesetzt werden kann, wenn die

Operanden der anderen Speicherglieder das Signal 0 haben und somit

nicht gesetzt sind.

Der Unterschied zwischen dem Verriegeln über den Rücksetzeingang

und dem Setzeingang ist, dass beim Verriegeln über den Setzeingang

die Bedingung zum Setzen des Speicherglieds erst gar nicht gegeben




ist. Beim Verriegeln über den Rücksetzeingang kann es der Fall sein,

dass die Bedingung zum Setzen des Speicherglieds zwar gegeben ist,

aber nur aufgrund der Rücksetzdominanz des Speicherglieds nicht

gesetzt wird.

Reihenfolgeverriegelung über den Setzeingang

Bei dieser Variante kann ein Speicherglied nur gesetzt werden, wenn

andere Speicherglieder bereits gesetzt wurden. Die Ausgangsoperanden

werden UND-verknüpft an den Setzeingang eingetragen. So kann das

Speicherglied nur gesetzt werden, wenn die anderen Speicherglieder

bereits gesetzt wurden. In diesem Beispiel wird A0.1 am Setzeingang

von A0.2 vorausgesetzt.

Reihenfolgeverriegelung über Rücksetzeingang

Bei dieser Variante wird eine Reihenfolgeverriegelung über den

Rücksetzeingang realisiert. Die Speicherglieder, die vorausgesetzt

werden, trägt man ODER-verknüpft am Rücksetzeingang und negiert

diese. Haben die vorausgesetzten Speicherglieder nicht das Signal 1,




kann ein Speicherglied aufgrund der Rücksetzdominanz nicht gesetzt

werden. In diesem Beispiel kann A0.2 nicht gesetzt werden, solange

A0.1 ein Signal 0 liefert.

Der Unterschied zwischen den beiden Varianten zur

Reihenfolgeverriegelung ist, dass beim Verriegeln über den Setzeingang

die Bedingung zum Setzen erst gar nicht gegeben ist, wenn die

vorausgesetzten Speicherglieder nicht gesetzt wurden. Beim Verriegeln

über den Rücksetzeingang kann die Voraussetzung zum Setzen gegeben

sein, wird jedoch nur durch das rücksetzdominante Verhalten nicht

gesetzt, wenn die vorausgesetzten Speicherglieder nicht gesetzt

wurden.

Außerdem kann beim Verriegeln über den Rücksetzeingang der Fall

eintreten, dass ein Speicherglied zurückgesetzt wird, wenn ein anderes

Speicherglied das Signal 0 liefert. Beim Verriegeln über den Setzeingang

wird das Speicherglied nicht mehr vom 0 Signal des vorausgesetzten

Speicherglieds zurückgesetzt, wenn es einmal gesetzt wurde. Man muss

also bei der Auswahl entscheiden, was passieren soll, wenn nach dem

Setzen der Speicherglieder ein vorausgesetztes Speicherglied den

Signalzustand von 1 auf 0 ändert.




Setz- und Rücksetzdominanz der

Speicherglieder

Bei den gezeigten Beispielen wird davon ausgegangen, dass ein SR-

Glied rücksetzdominant und ein RS-Glied setzdominant ist. Das ist z.B.

bei der S7-300 Reihe der Fall. Es gibt auch Geräte, da ist es umgekehrt.

Hierbei wird auch meistens eine 1 am dominanten Eingangsbuchstaben

geführt (S1 oder R1).

Flankenauswertung in SPS-Programmen

In Steuerungsprogrammen müssen häufig Signalveränderungen

erfasst und verarbeitet werden. Das passiert sehr häufig in Verbindung

mit der Erkennung von Bewegungen oder wenn ein Signalwechsel

eine zeitgesteuerte oder zählbare Aktion auslösen soll. Aus

Erfahrung wissen wir, dass die Flankenauswertung häufig Verwirrung

auslöst oder für viele SPS-Programmierer zumindest in der Anfangszeit

schwierig zu verstehen ist. Daher ein ausführliches Beispiel mit einem

Paketaufkleber:

• An einer Förderbandanlage ist eine Lichtschranke angebracht, die

das Signal 1 gibt, wenn die Lichtschranke unterbrochen wird

(Schließer). Es soll eine Aktion ausgelöst werden, sobald ein Paket

an der Lichtschranke ankommt und die Lichtschranke unterbricht,

z.B. Paketaufkleber kleben. Sobald das Paket die Lichtschranke




berührt, wechselt das Signal von 0 auf 1, denn vorher war

noch kein Paket da und die Lichtschranke hatte das Signal 0. Es

liegt also eine Signalveränderung vor.

• Wenn man die auszuführende Aktion, z.B. Paketaufkleber kleben,

nicht an die Signalveränderung koppeln würde, sondern

lediglich anweisen würde, den Paketaufkleber zu bewegen, wenn

die Lichtschranke das Signal 1 gibt, dann würde der

Paketaufkleber mehrmals bewegt werden, zumindest solange,

bis das Paket die Lichtschranke wieder verlassen hat und

das Signal 0 ist.

• Da ein Paket eine gewisse Länge hat, die Lichtschranke also

weiterhin das Signal 1 liefert, obwohl bereits der Paketaufkleber

1x bewegt wurde, muss eine Möglichkeit her, den Paketaufkleber

an ein Signalwechsel der Lichtschranke, in diesem Fall von 0

auf 1, zu koppeln.

• In diesem Fall würde der Paketaufkleber nur 1x bewegt werden,

nämlich nur dann, wenn ein Paket an der Lichtschranke

ankommt und somit das Signal der Lichtschranke von 0 auf 1

ändert. Ob danach die Lichtschranke weiterhin das Signal 1 gibt,

interessiert den Paketaufkleber nicht mehr. Denn der

Paketaufkleber wird nur tätig, bei Signalveränderungen und

nicht nur bloß, weil die Lichtschranke das Signal 1 liefert.

• Solche Steuerungen lassen sich mit Flankenauswertungen

realisieren.




Positive und negative Flanke

Eine Flankenauswertung bedeutet also, eine Signalveränderung zu

erfassen. Es gibt aber zwei Möglichkeiten der Signalveränderung. Wenn

man das Beispiel mit dem Paketaufkleber nimmt, dann muss man

folgendes feststellen. Wenn das Paket an der Lichtschranke ankommt,

ändert sich das Signal von 0 auf 1. Beim Verlassen der Lichtschranke,

ändert sich das Signal von 1 auf 0. Beide Signalveränderungen können

in einer Steuerung genutzt werden. Beispielsweise könnte man an der

Förderbandanlage mit dem Paketaufkleber programmieren, dass

nachdem das Paket die Lichtschranke wieder verlassen hat, das Signal

also von 1 auf 0 gefallen ist, ein Zylinder bewegt wird, um das Paket auf

ein anderes Förderband zu schieben.

Für den Einsatz einer Flankenauswertung gibt es also viele

Möglichkeiten. Signalveränderungen von 0 auf 1 oder von 1 auf 0

werden unterschiedlich erfasst und verarbeitet. Diese sind:

• Positive Flanke: Erfassung einer Signalveränderung von 0 auf 1.

Wird auch häufig "steigende Flanke" genannt, da hier eine

Signalveränderung von 0 auf 1, also steigende Veränderung,

erfasst wird.

• Negative Flanke: Erfassung einer Signalveränderungen von 1

auf 0. Wird auch "fallende Flanke" genannt, weil hier eine

Signalveränderung von 1 auf 0, also fallende Veränderung, erfasst

wird.




Funktionsweise der Flankenauswertung

Die Programmiersoftware der meisten Hersteller stellen bereits

vorgefertigte Standardbausteine zur Flankenauswertung zur Verfügung.

Nachfolgend die Abbildung mit einem Baustein für die Auswertung einer

positiven Flanke und für die Auswertung einer negativen Flanke.

Die positive Flanke ist mit P gekennzeichnet, die negative Flanke mit N.

Beide Bausteine benötigen zunächst einmal 2 Operanden.

• Eingangsoperanden

• Flankenoperanden

Der Eingangsoperand ist der Operand, der ausgewertet wird, also

dessen Signalveränderung erfasst wird. Auf den Beispielbildern

sind das die Operanden E0.1 und 1.1. Der Eingangsoperand wird links

am Eingang des Bausteins eingetragen.

Der Flankenoperand wird auch häufig Flankenmerker oder

Flankenspeicher genannt. Hierfür benötigt man eine freie Bitadresse,

wofür häufig ein freier Merker verwendet wird. Man kann aber auch ein

statisches Lokaldatenbit oder ein Datenbit in Globaldatenbausteinen

verwenden. Im Organisationsbaustein OB1 ist es auch möglich, ein

temporäres Lokaldatenbit zu verwenden. In Funktionsbausteinen oder




Funktionen ist die Verwendung von temporären Lokaldatenbits nicht

möglich, da der Flankenoperand ein speicherndes Verhalten hat.

Der Flankenoperand wird benötigt, um überhaupt eine

Signalveränderung erfassen zu können. Das bedeutet, im

Flankenoperanden wird der Zustand des Operanden gespeichert, dessen

Signalveränderung (Eingangsoperand) erfasst wird. Daher verläuft der

Flankenoperand synchron mit dem Eingangsoperanden. Ist der

Eingangsoperand eine 0, ist auch der Flankenoperand eine 0. Ist der

Eingangsoperand eine 1, ist auch der Flankenoperand eine 1.

Nur wenn das Programm "weiß", wie der vorherige Zustand des

Eingangsoperanden ist, kann auch eine Signalveränderung festgestellt

werden. Bei der Abarbeitung des Programms wird der aktuelle

Signalzustand des VKE-Bits mit dem vorherigen Zustand des VKE-Bits

des Flankenoperanden geprüft.

Impulsoperand einer Flanke

Wenn man also einen Baustein zur Flankenauswertung benutzt, dann

gibt man den Operanden an, dessen Signalveränderung erfasst werden

soll. Man benutzt eine freie Bitadresse, damit die Erfassung einer

Signalveränderung möglich ist. Möchte man eine Signalveränderung von

0 auf 1 erfassen, benutzt man eine positive Flanke. Im umgekehrten

Fall eine negative Flanke. Wenn die zu erfassende Signalveränderung

eintritt, dann wird am Ausgang der Bausteine kurzzeitig ein Impuls

abgegeben. Der Impuls ist zwar kurzzeitig, reicht aber aus, um z.B.

einen Ausgangsoperanden zum Setzen zu bringen. Der Operand, der




den kurzzeitigen Impuls erhält, wird auch Impulsoperand genannt. Bei

dem obigen Beispiel wäre z.B. der Paketaufkleber der Impulsoperand,

der über das kurzzeitige Signal bewegt werden würde. Häufig werden

hierfür SR-Glieder benutzt, da hierfür nur ein kurzes Signal zum Setzen

des Glieds benötigt wird. Das Speicherglied würde dann wieder durch

ein anderes Signal, z.B. dem Endschalter des Paketaufklebers,

zurückgesetzt werden.

Positive Flanke: Flankenauswertung von 0 auf 1

Negative Flanke: Flankenauswertung von 1 auf 0




Flankenauswertung mit Speichergliedern

Flankenauswertungen kann man auch erstellen, ohne auf die

Standardbausteine der Programmiersoftware zuzugreifen. Hierfür

benötigt man im Grunde nur Speicherglieder. Für eine positive Flanke

benutzt man ein SR-Glied als Flankenoperanden. Für eine negative

Flanke benutzt man ein setzdominantes RS-Glied. Nachfolgend je ein

Beispiel, komplett mit einem SR-Glied für den Impulsoperanden.






Wer es ganz exotisch haben möchte, kann auch auf die vorgefertigten

Speicherglieder verzichten und mit UND-/ODER-Gliedern

zusammengesetzte Verknüpfungen realisieren, die dasselbe Verhalten

wie Speicherglieder haben. Das Programm wäre dann zwar riesig,

fehleranfällig und würde viel zu lange dauern, um die Schaltlogik zu

realisieren, es wäre aber grundsätzlich möglich.




Binäruntersetzer

In Steuerungsaufgaben wird häufig gefordert, das Verhalten eines

Binäruntersetzers, Englisch auch binary scaler genannt, zu realisieren.

Mit einem Binäruntersetzer kann man erreichen, dass ein Ausgang nach

einer definierten Anzahl von Eingangsimpulsen einen Impuls gibt.

Beispiel:

• Eingangssignal erhält Impuls

• Ausgangssignal wird auf 1 gesetzt

• Eingangssignal erhält wieder einen Impuls


• Eingangssignal erhält nächsten Impuls


Bei diesem Beispiel haben die Eingangs- und Ausgangsimpulse

unterschiedliche Frequenzen. Die Frequenz des Eingangssignals ist 2,

die des Ausgangssignals ist 1. Für je 2 Eingangssignale wird 1

Ausgangssignal erzeugt. Das Verhältnis zwischen Eingangs- und

Ausgangsimpulsen wird Teilungsverhältnis genannt, das ist in diesem

Beispiel 2:1. Bei einem Teilungsverhältnis von 2:1 ist das Verhalten wie

bei einem Stromstoßschalter.

Es ist natürlich möglich, Binäruntersetzer mit einem größeren

Teilungsverhältnis realisieren. Beispielsweise könnte man ein SPS-

Programm erstellen, bei dem der Ausgang erst mit jedem dritten

Eingangsimpuls das Ausgangssignal ändert. In der

Automatisierungstechnik werden für solche Impulsgeber auch T-Flipflop,

T-Kippglied oder Toggle-Flipflop bezeichnet.




Schaltung eines asynchronen 4-Bit-Dualzähler mit JK-Flip-Flops

Binäruntersetzer mit einer SPS

Mit einer SPS gibt es mehrere Möglichkeiten, einen Binäruntersetzer zu

programmieren. Eine Möglichkeit ist die Realisierung mit der

Flankenauswertung in Verbindung mit Speichergliedern. Bei einem

Teilungsverhältnis von 2:1 besteht die Aufgabe darin, eine

Schaltungslogik zu realisieren, bei der der Ausgang jedes Mal den

Signalzustand verändert, wenn das Eingangssignal eine positive Flanke

gibt. Zum Verständnis des Zusammenhangs zwischen Eingang und

Ausgang ein Impulsdiagramm.




Aus dem Impulsdiagramm wird deutlich, dass man hierfür eine positive

Flankenauwertung benötigt, da der Ausgang den Zustand bei jeder

positiven Flanke verändern soll. Als Eingangssignal wird in diesem

Beispiel der Operand E0.1 benutzt. Damit man das Eingangssignal nicht

manuell per Hand von 0 auf 1 und umgekehrt setzen muss, könnte man

hier auch einen Taktmerker benutzen. So würde man automatisch

Taktsignale erzeugen, die stets im gleichen Intervall eine 1 oder 0

liefern.

Netzwerk 1:

Das erste Netzwerk wird dafür benutzt, die positive Flanke des

Eingangsoperanden E0.1 auszuwerten und den Impulsoperanden in

einer Bitadresse zu speichern. Der Einfachheit halber wird hierfür in

diesem Beispiel der Merkerbit M1.1 benutzt. Als Flankenoperanden, der

bei einer Flankenauswertung immer benötigt wird, wird der Merkerbit

M0.1 genommen.

Netzwerk 2:

Im nächsten Schritt muss nun realisiert werden, dass wenn der

Impulsoperand ein Signal bekommt (positive Flanke), dass der Ausgang

A0.1 gesetzt wird, aber nur, wenn er nicht bereits gesetzt wurde.

Hierfür verwendet man eine UND-Verknüpfung, trägt den

Impulsoperanden (M1.1) und den negierten Ausgang (A0.1) als

Eingänge der UND-Verknüpfung ein. Gleichzeitig setzt man den

Impulsoperanden zurück, damit eine erneute positive Flanke

ausgewertet werden kann.

Netzwerk 3:

Im 2. Netzwerk wurde realisiert, dass der Ausgang gesetzt wird, wenn

er nicht bereits gesetzt wurde. Man braucht noch ein Netzwerk, für den




umgekehrten Fall. Nämlich dass der Ausgang rückgesetzt wird, wenn er

bereits gesetzt wurde. Hierfür verwendet man erneut ein UND-Glied und

trägt den Impulsoperanden (M1.1) und den Ausgang (A0.1) an die

Eingänge des UND-Glieds. Diesmal wird A0.1 am UND-Glied nicht

negiert. Der Ausgang des UND-Glieds führt zum Rücksetzen von A0.1.

Die 3 Netzwerke in AWL mit Kommentaren

U E 0.1 //Eingang E0.1

FP M 0.1//Abfrage einer positive Flanke von E0.1 über

Flankenoperanden M0.1 = M 1.1 //Zuweisen eines Impulses an den Impulsoperanden M1.1 U M 1.1 //Abfrage des Impulsoperanden M1.1

UN A 0.1 //Abfrage und Negation des Signalzustandes des Ausgangs

A0.1 S A 0.1 //Ausgang A0.1 setzen R M 1.1 //Rücksetzen des Impulsoperanden U M 1.1 //Abfrage des Impulsoperanden U A 0.1 //Abfrage des Ausgangs A0.1 R A 0.1 //Rücksetzen des Ausgangs 0.1

So hätte man einen Binäruntersetzer mit einem Teilungsverhältnis von




2:1 realisiert. Braucht man ein größeres Teilungsverhältnis, muss man

lediglich mehrere Binäruntersetzer hintereinander schalten, also das

Prinzip von Netzwerk 2 und 3 erneut zwischen Netzwerk 1 und 2

einsetzen und statt dem Ausgang irgendeine Bitadresse (Merker)

benutzen. So würde man erreichen, dass beim 2. Signal nicht der

Ausgang das Signal zum Setzen erhält, sondern die Bitadresse.




Stromstoßschalter realisieren

Eine immer wiederkehrende Frage in SPS-Schulungen ist, ob und wie

man das Verhalten eines Stromstoßschalters mit einer SPS realisieren

kann. Die Lösungsmöglichkeiten sind vielfältig und können daher

ziemlich einfach bis kompliziert sein. Auf dieser Seite wollen wir Ihnen

einige Lösungsvorschläge zeigen. In diesem Beispiel gehen wir davon

aus, dass wir einen Taster E0.1 und einen Ausgang A0.1 haben. Mit

jedem Betätigen des Tasters soll der Ausgang A0.1 seinen Zustand

wechseln. Beim ersten Betätigen EIN, beim nächsten Betätigen AUS,

danach wieder EIN usw.

Stromstoßschalter mit XOR

Eine sehr einfache Möglichkeit für die Realisierung eines

Stromstoßschalters ist die Lösung mit einer XOR-Verknüpfung und einer

positiven Flanke. Hierbei bedient man sich eines einfachen Tricks und

die Steuerungslösung ist wie folgt zu verstehen. Im Grundzustand wird

der Taster E0.1 betätigt und eine positive Flanke wird erzeugt. Der

Ausgang steigt von 0 auf 1, weil die XOR-Bedingung erfüllt ist. Denn in

dem Moment in dem die positive Flanke erzeugt wird, ist sie exklusiv.

Das zweite "Signal am Eingang" A0.1 ist noch auf 0. Danach wird es

trickreich. Der Ausgang wird auf 1 gesetzt. In dem Moment wird die

XOR-Bedingung wieder erfüllt, nur umgekehrt. Es gibt keine positive

Flanke am ersten Eingang, das zweite "Signal am Eingang" A0.1 ist




jedoch auf 1 und somit ist die XOR-Bedingung erfüllt. Dadurch wird

quasi eine Selbsthaltung erzeugt und der Ausgang A0.1 bleibt auf 1.

Stromstoßschalter mit XOR

Der Ausschaltvorgang ist wie folgt zu verstehen. Wird der Taster E0.1

nochmal betätigt, ist die XOR-Bedingung nicht mehr erfüllt. Denn, beide

Signale an den Eingängen sind auf 1 (positive Flanke am E0.1 und der

Ausgang A0.1). Daher wird der Ausgang A0.1 auf 0 gesetzt. Die

Selbsthaltung ist somit unterbrochen.




Stromstoßschalter mit SR-Flipflops

Eine weitere Möglichkeit das Verhalten eines Stromstoßschalters zu

realisieren ist die Lösung mit SR-Flipflops.

Stromstoßschalter mit SR-Flipflops









Die abgebildete Lösung ist wie folgt zu verstehen. Im Grundzustand

sind die beiden Merker M0.0 und M0.1 im zurückgesetzten Zustand,

wobei M0.1 aktiv zurückgesetzt ist, da weder der Taster E0.1 noch der

Merker M0.0 ein Signal 1 haben.

Nach dem ersten Betätigen von E0.1 wird die Rücksetzbedingung am

Merker M0.1 aufgehoben. Gleichzeitig wird die Setzbedingung für

Merker M0.0 erfüllt und der Ausgang A0.1 wird auf 1 gesetzt. Nach dem

Loslassen von Taster E0.1 wird die Setzbedingung für M0.1 erfüllt und

M0.1 wird ebenfalls gesetzt.

Beim nächsten Betätigen von E0.1 ist die Rücksetzbedingung für M0.0

erfüllt. Denn sowohl E0.1 und M0.1 liefern in dem Moment eine 1. Somit

wird M0.0 und der Ausgang A0.1 zurückgesetzt. Nach dem Loslassen

des Tasters E0.1 wird M0.1 ebenfalls zurückgesetzt. Denn in dem

Moment ist auch diese Bedingung erfüllt, Taster E0.1 ist auf 0, M0.0

ebenfalls. Beide Merker sind so in den Ausgangszustand zurück versetzt

worden. Mit diesen beiden Flipflops wurde eine Stromstoßschaltung

realisiert und sie funktioniert genauso gut wie die Lösung mit einer

XOR-Verknüpfung. Der einzige Nachteil dieser Lösung ist, dass das SPS-

Programm größer ist.




Stromstoßschalter mit einer Sprungfunktion

Eine ebenfalls einfache Möglichkeit für die Realisierung eines

Stromstoßschalters ist die Lösung mit einer Sprungfunktion. Auf dem

Bild sehen Sie ein Beispielprogramm.

Stromstoßschalter mit einer Sprungfunktion

Um die Übersichtlichkeit zu bewahren haben wir das Programm in FUP

und AWL erstellt. Man könnte es natürlich auch komplett in einem

einzigen Netzwerk in AWL realisieren. Das abgebildete Programm ist wie




folgt zu verstehen.

Im Grundzustand ist der Ausgang A0.1 eigentlich auf 1. Denn Nicht-

Ausgang A0.1 ist = Ausgang. Durch die Negation wird jedoch erreicht,

dass am Ausgang ein 0 Signal geliefert wird. Im ersten Netzwerk ist die

bedingte Sprungfunktion SPBN. Wenn das VKE auf 0 ist, wird zum

Sprungziel ENDE gesprungen. Da im Grundzustand der Taster E0.1 nicht

betätigt ist, wird quasi permanent zum Sprungziel ENDE gesprungen.

Der Ausgang A0.1 liefert solange ein 0 Signal. Erfolgt eine Betätigung

des Tasters E0.1 und liegt somit eine positive Flanke vor, wird die

Sprungoperation unterbrochen und Netzwerk 2 wird bearbeitet. Durch

die Negation wird der Wert am Ausgang A0.1 umgedreht. Danach

erfolgt bis zum nächsten Betätigen des Tasters E0.1 wieder ein

permanentes Überspringen von Netzwerk 2. Wird der Taster erneut

betätigt, wird der Wert im Netzwerk 2 erneut umgedreht. So hätte man

mit einer Sprungfunktion einen Stromstoßschalter realisiert.

Es gibt noch weitere Möglichkeiten, einen Stromstoßschalter mit einer

SPS zu realisieren, z.B. mit Binäruntersetzern, in Kombination mit

Zählern und Vergleichern oder gar mit einer Schrittkette in Graph.

Beispielsweise wurde für die Aufgabe 7-Segmentanzeige eine Lösung für

die geänderte Aufgabenstellung (statt 4 Schalter nur noch ein Taster) in

S7-Graph realisiert. Die Lösung für die geänderte Aufgabenstellung, die

dem Verhalten eines Stromstoßschalters ähnelt, nur mit dem

Unterschied, dass nicht nur ein Ausgang sondern mehrere Segmente

mit jedem Tastendruck ihren Signalzustand ändern.




Taktsignale in der Steuerungstechnik

In vielen SPS-Programmen werden Taktsignale benötigt, die in einem

vordefiniertem Intervall immer wieder eine bestimmte Zeit lang ein

Signal geben, z.B. 1 Sekunde 1, 1 Sekunde 0, 1 Sekunde 1, 1 Sekunde

0 usw. Solche Taktsignale könnte man in Kombination mit

Binäruntersetzern oder Stromstoßschaltern dafür benutzen, um z.B. die

Lichter einer Beleuchtungsanlage zu steuern, die immer im selben Takt

an und aus gehen sollen. Solche Taktsignale werden in der

Steuerungstechnik auch periodische Signale genannt, die ein Puls-

Pause-Verhalten haben. Dabei können Taktsignale unterschiedliche

Pulsdauer haben. Auch kann das Verhältnis zwischen Puls und Pause

unterschiedlich sein, z.B. 2 Sekunden Puls, 1 Sekunde Pause.

Erzeugung von Taktsignalen

Fast jede Programmiersoftware für SPS-Steuerungen enthalten bereits

fertige Bausteine, die Taktsignale erzeugen. Hier sollte man die

Hilfefunktion der Programmiersoftware aufrufen und schauen, wie ein




Taktsignal in der jeweiligen Software erzeugt werden kann. Die

Standardbausteine haben dabei häufig ein Puls-Pause-Verhältnis von 1

zu 1. Das bedeutet, eine Sekunde lang ein Puls, eine Sekunde Pause.

Benötigt man ein anderes Puls-Pause-Verhältnis, muss man diese häufig

selbst mit Zeitgliedern erstellen. Hier hat man den Vorteil, dass man die

Puls- und Pausendauer selbst festlegen kann.

Mit Step7 hat man mehrere Möglichkeiten, Taktsignale zu erzeugen und

im Programm zu verwenden:

• Zeitfunktionen: Durch die Kombination verschiedener Zeitglieder

kann man einen Taktgeber selbst programmieren.

• Taktmerker: Eine Merkerbyteadresse aus dem Register der

Merker kann für die Taktsignale parametriert werden, dessen

einzelne Bitadressen dann unterschiedliche Taktsignale liefern.

Häufig wird hierfür Merkerbyte 100 genommen.

• Weckalarm: In den S7-CPU's werden Weckalarm-

Organisationsbausteine zur Verfügung gestellt. Diese Bausteine

können so eingestellt werden, dass sie periodisch aufgerufen

werden und so die Programmabarbeitung unterbrechen.




Taktgeber mit Zeitfunktionen programmieren

In Step7 können Taktgeber durch die Verknüpfung von mehreren

Zeitfunktionen programmiert werden. Der Vorteil bei dieser Variante ist,

dass man selbst die Puls- und Pausendauer frei bestimmen kann und

daher sehr flexibel ist. Nachfolgend ein Beispiel mit zwei Zeitgliedern

vom Typ verlängerter Impuls.

Erläuterung zum Programm:

Ein Zeitglied vom Typ verlängerter Impuls hat das Verhalten, dass

sobald ein Impuls am Setzeingang vorhanden ist, das Zeitglied gesetzt

wird und die eingestellte Zeit abläuft. Als Startimpuls wurde beim

Zeitglied eine positive Flanke des Operanden E0.1 gewählt. Nachdem

die Zeit bei T1 abgelaufen ist, wird das Zeitglied zurückgesetzt. Diese

negative Flanke wird dafür genutzt, das zweite Zeitglied (T2) zu setzen.

Ist die Zeit bei T2 abgelaufen, wird die negative Flanke genutzt, um

diesmal T1 wieder zu setzen. Auf diese Art und Weise werden beide

Zeitglieder über die negative Flanke abwechselnd gesetzt. Mit dem

Operanden E0.3 werden beide Zeitglieder zurückgesetzt. Man könnte




nun das Signal eines Zeitglieds wählen und einem Ausgangsoperanden

zuweisen. Hierbei hat man die Auswahl, welches Zeitglied man wählt.

Taktsignale über einen Taktmerker erzeugen

Die meisten Programmiersoftware bieten die Möglichkeit, eine

Merkerbyte-Adresse als Taktmerker zu parametrieren. Häufig benutzt

man hierfür die Merkerbyte-Adresse 100. Ist ein Taktmerker

parametriert, können die Bitadressen des Taktmerkers, z.B. 100.7, als

Taktsignale genutzt werden. Die Frequenzen der einzelnen Bitadressen

sind dabei unterschiedlich und fest eingestellt. Sie sind also nicht

veränderbar. Sie haben dabei das Puls-Pause-Verhältnis 1 zu 1. Eine

Übersicht mit den zur Verfügung stehenden Frequenzen eines

Taktmerkerbytes:

Taktmerker in der Hardwarekonfiguration

festlegen

Welche Merkerbyte-Adresse man verwendet, legt der Programmierer

selbst fest. Die Festlegung hierfür erfolgt in der Hardwarekonfiguration

der CPU. Man geht dabei wie folgt vor:




• Starten der Hardwarekonfiguration

• Rechtsklick auf die CPU

• Aus dem Kontextmenü Eigenschaften auswählen

• Im Fenster Eigenschaften das Register Zyklus/Taktmerker

auswählen

• Taktmerker aktivieren

• Merkerbyteadresse eingeben.

• Hardwarekonfiguration laden

Danach können die einzelnen Bitadressen des Taktmerkers genutzt

werden, die je nach gewählter Bitadresse, ein Taktsignal geben.

Hat man z.B. die Merkerbyteadresse 100 gewählt, kann man M100.7

einem Ausgangsoperanden zuweisen und die Taktsignale beobachten.

.




Weckalarme als Taktsignal nutzen

Innerhalb der CPU's sind mehrere Organisationsbausteine verfügbar, die

die zyklische Programmabarbeitung von OB1 aufgrund der höheren

Prioritätsklasse unterbrechen können. Darunter befinden sich auch die

Weckalarm-OB's. In Step7 sind das die Organisationsbausteine OB30 bis

OB38.

Die Weckalarm-OB's werden bei der Programmabarbeitung in

regelmäßigen Intervallen aufgerufen. Sie unterbrechen dabei die

Abarbeitung von OB1 und das im Weckalarm befindliche Programm wird

ausgeführt. Die Weckalarm-OB's beginnen mit dem Zeittakt beim

Wechsel des Betriebszustands der SPS von STOP zu RUN. Nachfolgend

ein Beispiel in einer Bildergalerie, wie man mit Weckalarm-OB's in

regelmäßigen Intervallen das Signal 1 am Ausgang A1.0 erhält.

Bild 1: Neuen Organisationsbaustein erzeugen




Bild 2: Weckalarm-OB auswählen, z.B. OB30

Bild 3: Programm im Weckalarm-OB erstellen, laden und beobachten

Wenn man mehrere Weckalarm-OB's benutzt, dann muss man darauf

achten, dass für jeden Weckalarm-OB genug Zeit zur Verfügung steht

und es keine Überschneidungen mit anderen Weckalarm-OB's gibt, da

die OB's mit der höheren Prioritätsklasse die Abarbeitung unterbrechen




können bzw. ein OB mit der niedrigeren Priorität nicht starten kann.

Die Zeittakte für die Weckalarm-OB's sind feste Werte, die im

Parameterblock der CPU vorgegeben sind. Welcher OB welchen Zeittakt

hat, kann man in der Hardwarekonfiguration in den Objekteigenschaften

der CPU, im Register Weckalarme, sehen. Hier hat man auch die

Möglichkeit, eigene Zeittakte für die OB's zu vergeben. Ob, wie viele

OB's man selbst parametrieren kann und welchen Maximalwert man

dabei eingeben kann, ist jedoch abhängig von der benutzten CPU.

Die Zeit der Weckalarm-OB's wird in Millisekunden (ein Tausendstel

einer Sekunde) angegeben. Möchte man den Zeittakt umrechnen in

Sekunden, muss man die angegebene Zeit durch 1000 teilen.

Es gibt auch die Möglichkeit, dass man einen Weckalarm abwählen




kann. Diese dürfen dann im Programm nicht benutzt werden. Werden

abgewählte OB's im Programm benutzt, wird ein Programmfehler in der

CPU erzeugt und geht in den Zustand STOP.

Bei der Verwendung mehrerer Weckalarm-OB's kann man durch die

Programmierung einer Phasenverschiebung erreichen, dass mehrere

Weckalarm-OB's nicht gleichzeitig gestartet werden können. Mit der

Phasenverschiebung wird erreicht, dass, dass die Bearbeitung des

aufgerufenen Weckalarms nach dem Ablaufen des eingestellten

Zeittaktes um einen bestimmten Zeitraum verschoben wird. Die

Phasenverschiebung errechnet sich nach der Formel:

Phasenverschiebung = m(Phasenverschiebung) multipliziert mit

Grundtakt (Bedingung: 0 ≤ m < t(t=Zeittakt des Weckalarm-OB's))

Übersicht über die voreingestellten Zeittakte und

Prioritätsklassen der Weckalarm-OBs.

Wenn man Weckalarm-OB's verwendet, ändert sich dadurch auch die

Zykluszeit des Programms, die abhängig ist von der verwendeten CPU.

Sie verlängert sich um ca. 220µs bis zu 380µs.




Zeitfunktionen (Timer) in einer SPS

In SPS-Programmen werden häufig Zeitfunktionen benötigt, um z.B.

eine zeitgesteuerte Aktion auszulösen. Das kann z.B. ein Zylinder sein,

der in Endlage mehrere Sekunden verbleiben soll, ehe es wieder

zurückbewegt wird. Oder eine Alarmleuchte, die für mehrere Sekunden

aufleuchten soll. Für solche Aktionen benötigt man Zeitglieder, mit

denen zeitgesteuerte Funktionen programmiert werden können. Gemäß

der Programmiernorm 61131-3 wurden vier Zeitfunktionen festgelegt.

Diese sind:

• Echtzeituhr

• Funktionsbaustein für die Erzeugung eines Impulses (TP)

• Funktionsbaustein für die Einschaltverzögerung (TON)

• Funktionsbaustein für die Ausschaltverzögerung (TOF)

Übersicht Standardfunktionsbausteine nach DIN EN 61131-3




Erklärung der Operanden:

• IN = Startbedingung, Signalwechsel von 0 auf 1

• PT = Zeitvorgabe

• Q = Status der Zeit

• ET = aktueller Zeitwert

Zeitfunktionen in der Programmiersoftware

Die vier Zeitfunktionen, die in der Programmiernorm 61131-3 festgelegt

wurden, waren den Ansprüchen vieler Programmierer nicht gerecht.

Beispielsweise sehen die Zeitfunktionen nach 61131-3 keine Möglichkeit

der Rücksetzung eines Zeitglieds. Daher haben viele Hersteller von SPS-

Programmiersoftware eigene, in der Funktionalität erweiterte,

Zeitfunktionen. In Step7 sind folgende erweiterte Zeitfunktionen

enthalten:

• Zeitfunktion SA: Ausschaltverzögerung

• Zeitfunktion SE: Einschaltverzögerung

• Zeitfunktion SI: Impuls

• Zeitfunktion SS: Speichernde Einschaltverzögerung

• Zeitfunktion SV: Verlängerter Impuls




Übersicht über die Bezeichnungen und Impulsdiagramme von

Zeitfunktionen in Step7




Möchte man in Step7 die drei Standardzeitfunktionen TP, TON und TOF

verwenden, muss man dies über den Aufruf folgender

Systemfunktionsbausteinen realisieren:

• SFB3: Für TP

• SFB4: Für TON

• SFB5: Für TOF

Wenn diese Systemfunktionsbausteine verwendet werden, müssen für

diese auch jeweils ein Instanzdatenbaustein zugeordnet sein, damit die

notwendigen Daten als statische Lokalvariablen vorhanden sind. Benutzt

man dagegen die firmenspezifischen Zeitfunktionen, muss man anstatt

einem Instanzdatenbaustein einen Zeitoperanden, z.B. T1, verwenden.

Man kann die Zeitoperanden auch global in der Symboltabelle

definieren.

Die firmenspezifischen Zeitfunktionen in Step7 sind im Handling

einfacher und haben einen größeren Funktionsumfang. Beispielsweise

hat jede Zeitfunktion einen Rücksetzeingang. Als Datentyp für die Zeit

wird dabei S5TIME verwendet.

Wie die SPS intern die Zeitbildung umsetzt, kann für den Programmierer

egal sein. Man muss dabei nur wissen, dass ein interner Taktgeber

Zählimpulse bereitstellt, über den die Zeit rückwärts abläuft. Wenn man

also bei einem Zeitglied eine Zeit einstellt, dann wird der Zähler

voreingestellt. Durch die Zählimpulse läuft die Zeit ab und der Zähler

erhält mit Ablauf der Zeit den Zählerstand 0.

Die zyklische Abarbeitung des Programms wird dabei nicht beeinflusst,

da die Zeitfunktion asynchron zur Programmabarbeitung aktualisiert

wird. Dadurch haben Zeitglieder am Zyklusanfang einen anderen Wert

als am Zyklusende.




Verwendung der Echtzeituhr

In allen CPU's der Baureihen S7-300 und S7-400 ist wurde eine Uhr,

entweder als Echtzeituhr oder Software-Uhr, implementiert. Eine

integrierte Uhr kann dabei auf zwei verschiedene Art und Weise genutzt

werden:

• Master: In diesem Fall fungiert die integrierte Uhr als Hauptuhr.

• Slave: In diesem Fall spielt die Uhr eine untergeordnete Rolle

eines Masters und sich mit dem Master synchronisiert.

Mit einer integrierten Uhr können bei Bedarf Uhrzeitalarme oder auch

Betriebsstundenzähler realisiert werden. Dabei zeigt die Uhr folgende

Werte:

• Uhrzeit, mindestens mit der Anzeige von Sekunden

• Datum

• Wochentag

Ob auch die Millisekunden angezeigt werden, hängt von der

verwendeten CPU ab. Hier muss man im Referenzhandbuch des Geräts

nachschauen, um Näheres zu erfahren.

Das Datum und die Uhrzeit Uhr kann vom Programmierer selbst gestellt

werden. Hierfür ist der Aufruf folgender Systemfunktion im SPS-

Programm notwendig:

• SFC0 (SET_CLK)

Alternativ kann man das auch über das Menü des Programmiergeräts

realisieren. Hierfür geht man im Programmiergerät online, öffnet das

Menü Zielsystem und wählt aus dem Menü Uhrzeit stellen. Man kann

die Zeit entweder direkt vom Programmiergerät/PC übernehmen oder




selbst ein Datum und Uhrzeit eingeben.

So kann man auch die aktuelle Uhrzeit und das Datum der CPU

auslesen. Um das Datum und die Uhrzeit direkt im Programm

auszulesen, benutzt man die Systemfunktion SFC1 (READ_CLK).

Zeitfunktionen programmieren

In der SPS-Programmiersoftware Step7 hat man grundsätzlich zwei

Möglichkeiten, Zeitfunktionen zu programmieren. Wenn man nach

der Programmiernorm 61131-3 programmieren möchte, verwendet man

die Systemfunktionsbausteine SFB2 (TP), SFB3 (TON) und SFB4 (TOF).

Man kann aber auch auf die firmenspezifischen Zeitfunktionen SA, SE,

SI, SS und SV zugreifen. Diese haben einen größeren Funktionsumfang

und sind einfacher im Handling. Beispielsweise besitzen alle

Zeitfunktionen Rücksetzeingänge.

In welcher Darstellungsart man die Zeitfunktion programmiert, spielt im




Grunde keine Rolle, da alle Zeitfunktionen über dieselben Eingangs- und

Ausgangsvariablen verfügen. Die Zeitglieder sind in einem

Speicherbereich im Systemspeicher der CPU's abgelegt. Wieviele

Zeitglieder in einem Programm verwendet werden können, hängt davon

ab, welche CPU man benutzt. Hier muss man im Referenzhandbuch des

Geräts nachschauen, um Näheres zu erfahren. Sofern in einem

Programm mehr Zeitglieder benutzt wurden, als die CPU zur Verfügung

stellt, wird eine Fehlermeldung (synchroner Fehler) erzeugt und OB121

wird gestartet.

Zeitfunktionen bzw. TIMER gehören zu den Parametertypen und haben

die Größe von 16 Bits (2 Bytes, 1 Wort).

Aufbau eines Zeitglieds

Ein Zeitglied ist wie auf Bild abgebildet aufgebaut. Die Eingangs- und

Ausgangsoperanden haben dabei folgende Bedeutung:

• Tx: Bezeichnung für das Zeitglied. Hier muss man anstelle von x

eine Nummer für den Zeitoperanden vergeben, z.B. T1.




• T-Funktion: Hier steht der Typ des Zeitglieds, z.B. SA, SE usw.

• S: Setzeingang des Zeitglieds. Über ein binäres Signal (0 oder 1)

wird das Zeitglied gesetzt und die festgelegte Zeit beginnt,

abzulaufen.

• TW: Die Zeitdauer, die festgelegt werden soll. Belegt die Größe

von 16 Bits (1 Wort, 2 Bytes).

• R: Rücksetzeingang. Das Zeitglied kann mit dem binären Signal 1

rückgesetzt werden.

• DUAL: Hier wird der Restwert der ablaufenden Zeit dualcodiert

angezeigt. Kann ausgelesen werden, wofür 16 Bits benötigt

werden.

• DEZ: Hier wird der Restwert der ablaufenden Zeit BCD-codiert

angezeigt (S5TIME). Kann ebenfalls ausgelesen werden und hat

ebenfalls eine Größe von 16 Bits.

• Q: Ausgang des Zeitglieds. Solange das Zeitglied gesetzt ist, ist Q

= 1.

Verwendung von Datentypen und Operanden für Ein-

und Ausgänge von Zeitgliedern

Folgende Operanden und Datentypen werden für die Ein- und Ausgänge

verwendet:

• Tx: Operand T, Datentyp TIMER.

• S: Operanden E, A, M, DBX, L, T, und Z, Datentyp Bool.

• TW: Konstante, EW, AW, MW, DBW und LW, Datentyp S5TIME.

• R: E, A, M, DBX, L, T, und Z, Datentyp Bool.

• DUAL: EW, AW, MW, DBW und LW, Datentyp WORD.




• DEZ: EW, AW, MW, DBW und LW, Datentyp WORD.

• Q: E, A, M, DBX und L, Datentyp Bool.

Starten eines Zeitglieds

Eine Zeitfunktion wird über den Setzeingang gestartet. Hierbei kommt

es darauf an, welchen Typ man gewählt hat. Bei SE, SI, SS und SV wird

das Zeitglied über eine positiven Flanke gesetzt. Bei SA wird das

Zeitglied mit einer negativen Flanke gesetzt. Mit dem Setzen des

Zeitglieds beginnt die am Eingang TW eingestellte Zeitdauer abzulaufen.

Eingabe der Zeitdauer am Eingang TW

Am Eingang TW erfolgt die Eingabe der Zeitdauer. Diese kann in Step7

auf zwei verschiedene Art und Weisen eingegeben werden. Einmal als

Variable mit Hilfe des BCD-Codes oder als Konstante. Für die Eingabe

der Zeitdauer ist etwas Hintergrundwissen erforderlich. Denn, das hat

Auswirkungen sowohl für die Eingabe als Konstante als auch für die

Eingabe als Variable. Die Bitbelegung für S5TIME sieht wie folgt aus:

Die Zeitdauer mit dem Datentypen S5TIME wird im Akku als BCD-Zahl

abgelegt und belegt dabei 16 Bits (1 Wort, 2 Bytes). Eine Ziffernfolge

von 4 Bits entspricht im BCD-Code einer Tetrade. Mit einer Tetrade kann

man die Zahlen 0 - 9 darstellen. Die erste Tetrade entspricht dabei den




Einern, die zweite den Zehnern und die dritte den Hundertern. Im

Datentypen S5TIME sind die ersten 12 Bits (Bit 0 bis Bit 11) für den

Zeitwert reserviert und das sind genau 3 Tetraden. Da man mit jeder

Tetrade maximal die Zahl 9 darstellen kann, kann man einen maximalen

Zeitwert von 999 darstellen.

Die Bits 12 und 13 sind für die Zeiteinheit reserviert. Mit diesen 2 Bits

kann man umgerechnet einen Dezimalwert von 0 - 3 darstellen. Für die

Darstellung der Zeiteinheit im Datentypen S5TIME gilt folgendes:

• 0 entspricht einer Zeiteinheit von 0,01 Sekunden (1/100 Sekunde)

• 1 entspricht einer Zeiteinheit von 0,1 Sekunden (1/10 Sekunde)

• 2 entspricht einer Zeiteinheit von 1 Sekunde

• 3 entspricht einer Zeiteinheit von 10 Sekunden

Die Bits 14 und 15 können ignoriert werden, sie werden nicht bzw. mit

0 belegt.

Das bedeutet, für eine Zeitdauer von z.B. 20ms hätte man folgendes

Bitmuster:

• 00 00 0000 0000 0010

Erläuterung von links nach rechts:

• Die ersten 2 Bits werden ignoriert.

• Die nächsten 2 Bits sind 00, also die Zahl 0. Entspricht der

Zeiteinheit 0,01 Sekunden.

• Die übrigen 12 Bits (3 Tetraden) entsprechen der Zahl 2.

• 2 · Zeiteinheit, also 2 · 0,01 Sekunden = 0,02 Sekunden oder

20ms.




Maximale Zeitdauer

Dadurch wird klar, dass man für ein Zeitglied nur eine maximale

Zeitdauer von 10s x 999 = 9990 Sekunden eingeben kann. Das

entspricht einer Zeitdauer von genau 2 Stunden, 46 Minuten und 30

Sekunden.

Rundungen bei der Eingabe der Zeitdauer

Es kann der Fall eintreten, dass nicht die exakte Zeitdauer übernommen

wird.

Hierfür ein Beispiel für die Zeitdauer 3 Minuten und 25,3 Sekunden =

205,3 Sekunden. Das Bitmuster hierfür wäre:

• 00 10 0010 0000 1001

Erläuterung (von links nach rechts):

• Die ersten 00 werden ignoriert.

• Die nächsten 2 Bits entsprechen der Zahl 2, also ist die Zeiteinheit

1 Sekunde.

• Die nächsten 12 Bits (3 Tetraden) entsprechen der Zahl 205.

• 205 · 1 Sekunde = 205 Sekunden.

• Die 0,3 Sekunden wurden gerundet

Die Ursache hierfür ist, dass man mit der Zeiteinheit 1 (0,1 Sekunden)

bei 3 Tetraden eine Zahl von 2053 bräuchte, um 205,3 Sekunden exakt

darstellen zu können (2053 x 0,1 = 205,3 Sekunden). Da man mit den

3 Tetraden aber nur Zahlen bis 999 eingeben kann, wurde automatisch

die nächsthöhere Zeiteinheit genommen und es musste gerundet

werden. Die Rundung erledigt das Programm übrigens auch




automatisch.

Innerhalb folgender Bereiche kann eine exakte Zeitdauer

eingegeben werden

Eingabe der Zeit als Konstante

Die Eingabe einer konstanten Zeitdauer erfolgt in folgender Form:

• S5T#wHxxMyySzzzMS

• Beispiel: S5T#5S

Nicht benutzte Einheiten können dabei entfallen. Das w steht für

Stunden (H, Hours), das xx für die Minuten (M, Minutes), yy für die

Sekunden (S, Seconds) und zzz für die Millisekunden (MS,

Milliseconds).

Die Umwandlung der Zahl in ein 16 Bit breites Bitmuster mit Auswahl

der Zeiteinheit und Darstellung des Zeitwerts erledigt das Programm

automatisch im Hintergrund.

Eingabe der Zeitdauer in BCD

Die Eingabe der Zeitdauer als Variable mit Hilfe der BCD-Zahl erfolgt in

der Form:

• W#16#zttt




• Beispiel: W#16#3999

Das z steht dabei für die Zeiteinheit und ttt für den Zeitwert.

Zeitglieder rücksetzen

Ein Vorteil der Zeitfunktionen in Step7 gegenüber den Zeitfunktionen

gemäß Programmiernorm 6113-3 ist, dass diese einen Rücksetzeingang

haben. Mit einem Signal 1 über den Rücksetzeingang (R) können diese

rückgesetzt werden. Die ablaufende Zeit wird gestoppt und das Zeitglied

kann erst wieder gestartet werden wenn kein Signal 1 am

Rücksetzeingang anliegt und wenn am Setzeingang das Signal 1 anliegt.

Wenn das Zeitglied nicht aktiviert ist, hat das Signal 1 am

Rücksetzeingang keinerlei Auswirkungen auf die Ausgänge DUAL, DEZ

und Q. Würde man den Zeitoperanden oder die Restzeitwerte abfragen,

würde man den Wert 0 erhalten.

Restlaufzeit abfragen

Die Restlaufzeit einer ablaufenden Zeit kann über Ladebefehle im

Funktionsplan FUP mit dem Übergabeparameter MOVE und in SCL

über eine Wertzuweisung ( : = ) abgefragt werden. Mit Hilfe der

Anweisungen L Tx (dualcodiertes laden des Restzeitwertes) und LC Tx

(BCD-codiertes Laden des Restzeitwertes) kann der Restzeitwert in den

Akku geladen werden. Bei einem dualcodiertem Laden der Restlaufzeit

gehen die beiden Bits für die Zeiteinheit verloren. Das bedeutet, Bit 12

und Bit13 erhalten im Akku den Wert 0. Übrig bleiben Bit 0 bis Bit 11.

Das entspricht einer positiven Ganzzahl des Zahlenformats INT und man

kann den Wert bei Vergleichsfunktionen nutzen. Wird die Restlaufzeit

BCD-codiert geladen, gehen die Bits 12 und 13 nicht verloren und




bleiben im Akku erhalten. So kann man den Wert erneut nutzen, um

z.B. eine andere Zeitfunktion zu starten und den Eingang TW mit der

Restlaufzeit zu belegen.

Zeitoperanden Tx abfragen

Ebenso wie Eingänge, Ausgänge oder Merker können auch die

Zeitoperanden Tx über binäre Abfragen wie UND, ODER, NAND, NOR

oder XOR abgefragt werden. Bei der mehrmaligen Abfrage von einem

Zeitoperanden in einem SPS-Programm ist es empfehlenswert, die

Zeitoperanden einem Hilfsoperanden zuzuweisen und den

Hilfsoperanden statt den Zeitoperanden abzufragen. Dadurch kann einer

Fehlfunktion vorgebeugt werden, weil ein Zeitoperand während der

Abarbeitung unterschiedliche Werte haben kann. Als Hilfsoperanden

können beispielsweise Merker benutzt werden.




Zeitfunktion SA - Ausschaltverzögerung

Mit der Zeitfunktion SA wird eine Ausschaltverzögerung realisiert. Das

bedeutet, man verzögert die Ausschaltung eines Signals. Hierfür setzt

man das Zeitglied vor dem Operanden, dessen Ausschaltung verzögert

werden soll. Damit etwas ausgeschaltet werden kann, muss es erstmal

eingeschaltet sein. Liegt am Setzeingang das Signal 1, führt auch der

Ausgang Q das Signal 1. Die Zeitfunktion SA wird dann gesetzt, wenn

das Signal am Setzeingang von 1 auf 0 fällt und somit eine negative

Flanke vorliegt.

Ist das Zeitglied gesetzt, beginnt die am Eingang TW eingestellte Zeit

abzulaufen und der Ausgang Q führt weiterhin das Signal 1. Die

Restlaufzeit kann über die Ausgänge DUAL oder DEZ abgefragt werden.

Ist die am Eingang TW eingestellte Zeit abgelaufen, wird das Zeitglied

zurückgesetzt und der Ausgang Q erhält ebenfalls das Signal 0. Auf

diese Art und Weise realisiert man, dass der Ausgang Q nach dem

Signalwechsel am Setzeingang von 1 auf 0 weiterhin das Signal 1 führt,

bis die Zeit abgelaufen ist. Die Verzögerung des Ausschaltens wird

damit realisiert.

Über den Rücksetzeingang wird das Zeitglied rückgesetzt. Die

Zeitfunktion SA ist rücksetzdominant. Das bedeutet, wenn am

Setzeingang das Signal 1 ist, gleichzeitig der Rücksetzeingang eine 1

hat, so hat das zur Folge, dass der Ausgang Q eine 0 führt. Auch die

Abfrage der Restlaufzeit über die Ausgänge DUAL und DEZ ergibt 0.

Wenn am Rücksetzeingang das Signal 1 anliegt, nachdem die




Zeitfunktion gesetzt wurde und die voreingestellte Zeit dabei ist,

abzulaufen, wird das Zeitglied rückgesetzt, der Ausgang Q führt das

Signal 0 und die Abfrage der Restlaufzeit über die Ausgänge DUAL und

DEZ führt ebenfalls zum Ergebnis 0.

Darstellung für den Aufruf der Zeitfunktion SA in den

Programmiersprachen FUP, KOP, AWL und SCL

Aufrufen der Zeitfunktion Ausschaltverzögerung (SA) in AWL

Ausschaltverzögerung in FUP (Darstellung in KOP ähnlich)




Ausschaltverzögerung in SCL

Verkürztes Aufrufen der Zeitfunktion Ausschaltverzögerung (SA)

in AWL

Verkürzter Aufruf der Ausschaltverzögerung in FUP (Darstellung

in KOP ähnlich)

Verkürzte Form der Ausschaltverzögerung in SCL




Zeitfunktion SE - Einschaltverzögerung

Mit der Zeitfunktion SE realisiert man eine Einschaltverzögerung. Die

Zeitfunktion wird dann genutzt, wenn bei einem Operanden das Signal

von 0 auf 1 wechselt und der Wechsel um eine bestimmte Zeit verzögert

werden soll. Liegt am Setzeingang einer Einschaltverzögerung das

Signal 0, hat auch der Ausgang Q das Signal 0. Die Zeitfunktion wird

gestartet, wenn das Signal am Setzeingang von 0 auf 1 wechselt, somit

eine positive Flanke vorliegt.

Wenn die Zeitfunktion gestartet wird, beginnt die am Eingang TW

eingestellte Zeit abzulaufen. Während dieser Zeit führt der Ausgang

weiterhin das Signal 0.

Ist die am Eingang TW eingestellte Zeit abgelaufen, wechselt der

Ausgang des Zeitglieds Q von 0 auf 1. Das Signal 1 am Ausgang bleibt

solange erhalten, solange am Setzeingang ebenfalls das Signal 1

anliegt.

Während die Zeit abläuft, können die Restlaufzeiten über die Ausgänge

DUAL und DEZ abgefragt werden. Wechselt das Signal am Setzeingang

von 1 auf 0, nachdem die Zeit abgelaufen ist, wechselt auch der

Ausgang von 1 auf 0.

Wechselt das Signal am Setzeingang von 1 auf 0, wenn die Zeit noch

nicht abgelaufen ist, dann wird die Zeit gestoppt und die Restlaufzeit

kann über die Ausgänge DUAL und DEZ abgefragt werden. Bei einem

erneuten Wechsel des Signals von 0 auf 1 am Setzeingang, beginnt die

gesamte am Eingang TW eingestellte Zeit abzulaufen und nicht nur die

Restlaufzeit, die beim Wechsel von 1 auf 0 übrig war.




Über den Rücksetzeingang wird das Zeitglied rückgesetzt. Hierfür wird

das Signal 1 benötigt. Das Zeitglied ist rücksetzdominant. Wenn am

Setzeingang das Signal von 0 auf 1 wechselt, während am

Rücksetzeingang das Signal 1 anliegt, beginnt die voreingestellte Zeit

nicht abzulaufen, der Ausgang führt das Signal 0 und auch die Abfrage

der Restlaufzeiten über DUAL und DEZ führt zum Ergebnis 0.

Wenn der Rücksetzeingang das Signal 1 erhält, während der

Setzeingang eine 0 führt, so hat das keinerlei Auswirkungen. Der

Ausgang Q führt weiterhin das Signal 0 und die Abfrage der Restlaufzeit

ergibt ebenfalls 0.

Darstellung für den Aufruf der Zeitfunktion SE in den


Aufrufen der Zeitfunktion Einschaltverzögerung (SE) in AWL




Einschaltverzögerung in FUP (Darstellung in KOP ähnlich)

Einschaltverzögerung in SCL

Verkürztes Aufrufen der Zeitfunktion Einschaltverzögerung (SE)

in AWL

Verkürzter Aufruf der Einschaltverzögerung in FUP (Darstellung

in KOP ähnlich)




Verkürzte Form der Einschaltverzögerung in SCL

Zeitfunktion SI - Impuls

Die Zeitfunktion SI nennt man Impuls. Es verhält sich im Grunde

genauso wie die Ausschaltverzögerung SA. Der Unterschied zwischen

den Zeitgliedern SA und SI ist, dass die Ausschaltverzögerung mit einer

negativen Flanke am Setzeingang gesetzt wird und der Impuls mit einer

positiven Flanke.

Wird das Zeitglied SI mit einer positiven Flanke gesetzt, dann beginnt

die am Eingang TW eingestellte Zeit abzulaufen. Während dieser Zeit

hat der Ausgang Q das Signal 1 und die Restlaufzeit kann über die

Ausgänge DUAL und DEZ abgefragt werden.

Nachdem die Zeit abgelaufen ist, wird das Zeitglied rückgesetzt und der

Ausgang hat das Signal 0. So wird realisiert, dass ein Operand nach der

eingestellten Zeit zurückgesetzt wird, wenn der Eingang das Signal 1

erhält.




Wenn das Signal am Setzeingang von 1 auf 0 wechselt, nachdem das

Zeitglied gesetzt wurde und die eingestellte Zeit noch nicht abgelaufen

ist, wird das Zeitglied gestoppt, der Ausgang hat das Signal 0 und über

die Ausgänge DUAL und DEZ kann die Restlaufzeit abgefragt werden.

Bei einem erneuten Wechsel des Setzeingangs von 0 auf 1 beginnt die

komplette Zeit abzulaufen und nicht nur die Restlaufzeit, die beim

Signalwechsel von 1 auf 0 übrig war.

Über den Rücksetzeingang wird das Zeitglied rückgesetzt. Dabei gehen

alle Restlaufzeiten verloren und die Abfrage der Ausgänge über DUAL

oder DEZ führt zum Ergebnis 0.

Wenn beim Setzeingang das Signal dauerhaft anliegt, auch wenn die

Zeit bereits abgelaufen ist, hat das keine Wirkung. Nach dem Ablaufen

der Zeit führt der Ausgang auch in diesem Fall eine 0 und die Ausgänge

DUAL und DEZ ebenfalls.

Der Rücksetzeingang ist rücksetzdominant. Wenn am Setzeingang das

Signal von 0 auf 1 wechselt, während am Rücksetzeingang das Signal 1

anliegt, hat das keinerlei Auswirkungen. Die Zeit läuft nicht ab, der

Ausgang Q bleibt 0, die Ausgänge DUAL und DEZ ebenfalls.




Darstellung für den Aufruf der Zeitfunktion SI in den


Aufrufen der Zeitfunktion Impuls (SI) in AWL

Impuls in FUP (Darstellung in KOP ähnlich)

Impuls in SCL

Verkürztes Aufrufen der Zeitfunktion Impuls (SI) in AWL




Verkürzter Aufruf des Impuls in FUP (Darstellung in KOP

ähnlich)

Verkürzte Form des Impuls in SCL

Zeitfunktion SS - speichernde

Einschaltverzögerung

Mit der Zeitfunktion SS wird eine speichernde Einschaltverzögerung

realisiert. Der Unterschied zur Einschaltverzögerung SE liegt darin, dass

beim Zeitglied SE die ablaufende Zeit gestoppt wird, wenn nach dem

Setzen des Zeitglied das Signal am Setzeingang von 1 auf 0 wechselt.

Bei der speichernden Einschaltverzögerung hat ein Signalwechsel von 1

auf 0 keine Wirkung, nachdem das Zeitglied gesetzt wurde.

Mit einer positiven Flanke am Setzeingang beginnt die am Eingang TW




eingestellte Zeit abzulaufen. Während die Zeit abläuft, kann das Signal

am Setzeingang wieder auf 0 wechseln, die ablaufende Zeit wird

dadurch nicht gestoppt. Die Restlaufzeit kann über die Ausgänge DUAL

und DEZ abgefragt werden.

Nachdem die Zeit abgelaufen ist, hat das Signal am Ausgang Q das

Signal 1. Der Ausgang Q behält das Signal 1, bis das Zeitglied über den

Rücksetzeingang rückgesetzt wird.

Verbleibt das Signal 1 dauerhaft am Setzeingang, obwohl die Zeit

bereits abgelaufen ist und der Ausgang Q. das Signal 1 führt, hat dies

keine Auswirkungen auf den Ausgang, der weiterhin das Signal 1 führt.

Eine Abfrage der Restlaufzeit würde in dem Fall eine 0 ergeben.

Wenn über eine positive Flanke am Setzeingang der Zeitablauf gestartet

wird und erfolgt am Setzeingang eine erneute positive Flanke, dann

beginnt die gesamte am TW eingestellte Zeit von neuem abzulaufen.

Diesen Vorgang nennt man auch Nachtriggern. Das Nachtriggern kann

beliebig oft durchgeführt werden, solange die am Eingang TW

eingestellte Zeit noch nicht abgelaufen ist.

Das Zeitglied ist rücksetzdominant. Wenn am Rücksetzeingang das

Signal 1 anliegt, hat eine positive Flanke am Setzeingang keine

Auswirkung. Die Zeit läuft nicht ab, der Ausgang bleibt 0 und auch die

Abfrage der Restlaufzeit ergibt 0. In diesem Fall kann der Zeitablauf nur

gestartet werden, wenn das Signal am Rücksetzeingang auf 0 wechselt

und der Setzeingang erneut eine positive Flanke erhält.




Darstellung für den Aufruf der Zeitfunktion SS in den


Aufruf der speichernden Einschaltverzögerung in AWL

Speichernde Einschaltverzögerung in FUP (Darstellung in KOP

ähnlich)




Speichernde Einschaltverzögerung in SCL

Verkürztes Aufrufen der speichernden Einschaltverzögerung

(SS) in AWL

Verkürzter Aufruf der speichernden Einschaltverzögerung in FUP

(Darstellung in KOP ähnlich)

Verkürzte Form der speichernden Einschaltverzögerung in SCL




Zeitfunktion SV - verlängerter Impuls

Die Zeitfunktion SV nennt man verlängerten Impuls. Es funktioniert

ähnlich wie eine Ausschaltverzögerung und das Verhalten ähnelt der

Zeitfunktion SI. Der Unterschied zwischen der Zeitfunktion SI und SV

ist, dass bei SI die Zeit gestoppt wird, wenn am Setzeingang das Signal

von 1 auf 0 wechselt, nachdem das Zeitglied gestartet wurde. Bei SV

läuft die Zeit trotzdem weiter ab.

Das Zeitglied SV wird mit einer positiven Flanke am Setzeingang

gestartet. Damit beginnt die am Eingang TW eingestellte Zeit

abzulaufen und der Ausgang Q hat das Signal 1. Die Restlaufzeit kann

während des Zeitablaufs über die Ausgänge DUAL und DEZ abgefragt

werden.

Nachdem die Zeit abgelaufen ist, wird das Zeitglied rückgesetzt, der

Ausgang Q hat das Signal 0 und die Ausgänge DUAL und DEZ liefern bei

einer Abfrage ebenfalls 0. Auf diese Weise kann man realisieren, dass

mit einer positiven Flanke ein Operand für eine gewisse Zeit auf 1

gesetzt wird und nach Ablauf der Zeit auf 0.

Wenn das Signal am Setzeingang von 1 auf 0 wechselt, nachdem das

Zeitglied gestartet wurde, hat das keine Auswirkungen. Die Zeit läuft

weiterhin ab und der Ausgang führt während des Zeitablaufs das Signal

1. Die Restlaufzeit kann über die Ausgänge DUAL und DEZ abgefragt

werden.

Erfolgt jedoch eine erneute positive Flanke am Setzeingang, nachdem

das Zeitglied bereits gesetzt wurde und die Zeit dabei ist, abzulaufen,

dann beginnt die am Eingang TW eingestellte Zeit, von vorne

abzulaufen. Dieser Vorgang wird auch Nachtriggern genannt. Man kann




beliebig oft nachtriggern, solange die Zeit noch nicht abgelaufen ist.

Auch beim Nachtriggern bleibt der Ausgang bei 1 und die Restlaufzeit

kann über DUAL und DEZ abgefragt werden.

Das Zeitglied wird über den Rücksetzeingang rückgesetzt. Wenn

während des Zeitablaufs der Rücksetzeingang das Signal 1 erhält, wird

das Zeitglied gestoppt, der Ausgang hat das Signal 0 und die Abfrage

der Restlaufzeit ergibt ebenfalls 0.

Auch das Zeitglied SV ist rücksetzdominant. Wenn am Rücksetzeingang

das Signal 1 anliegt und am Setzeingang eine positive Flanke erfolgt,

hat das keine Auswirkungen. Der Ausgang Q bleibt 0 und die

Restlaufzeit ebenfalls.

Darstellung für den Aufruf der Zeitfunktion SV in den


Aufrufen der Zeitfunktion Verlängerter Impuls (SV) in AWL




Verlängerter Impuls in FUP (Darstellung in KOP ähnlich)

Verlängerter Impuls in SCL

Verkürztes Aufrufen der Zeitfunktion Verlängerter Impuls (SV)

in AWL

Verkürzter Aufruf des verlängerten Impuls in FUP (Darstellung

in KOP ähnlich)




Verkürzte Form des verlängerten Impuls in SCL




Zählerfunktionen, Counter mit einer SPS realisieren

In vielen SPS-Programmen benötigt man Zählerfunktionen, damit bei

einem Impuls ein Zähler hoch- oder runtergezählt werden kann. So

kann man viele Produktionsschritte mengenmäßig erfassen.

Beispielsweise könnte man erfassen, wie hoch die Produktionszahl war

und wie oft der Ausschusszylinder bewegt wurde, um die Fehlerquote

messbar zu machen. Man könnte auch realisieren, dass eine Aktion nur

solange gestartet werden kann, solange der Zählerstand unter einem

bestimmten Wert liegt. Der Einsatzgebiet von Zählern ist vielfältig und

im Grunde könnte man jeden Produktionsschritt zählen.

In einem Steuerungsprogramm werden drei Arten von Zählern

eingesetzt:

• Vorwärtszähler: Zählen bei einem Impuls +1

• Rückwärtszähler: Zählen bei einem Impuls -1

• Vorwärts- und Rückwärtszähler: Diese haben 2 Eingänge, um +1

und -1 zählen zu können.

Die Zählimpulse können dabei auf zwei verschiedene Art und Weisen

erfasst werden:

• Zählen im Programm: Bei dieser Variante werden entweder

fertige Funktionsbausteine benutzt, die einen Eingang zum

Vorwärts- und/oder Rückwärtszählen haben, oder es wird ein

Speicherbereich mit dem Datentyp INT oder DINT mit der Zahl 1

addiert oder subtrahiert. Dieser Speicherbereich kann ausgelesen

und auf einer Anzeige wiedergegeben werden. Der Nachteil des




Zählens im Programm ist, dass man externe Zählimpulse nur

bedingt berücksichtigen kann, da die Verarbeitungsmöglichkeit

von der Zykluszeit abhängt.

• Zählen über eine Baugruppe: Bei dieser Variante werden

Zähler als Teil der CPU oder als zusätzliche Baugruppe benutzt.

Damit ist es möglich, externe Zählimpulse unabhängig von der

Zykluszeit zu erfassen. Solche Zähler werden auch schnelle Zähler

genannt, da sie sehr schnelle Zählimpulse erfassen können. Im

Programm können die Zählerstände ausgelesen werden.

• Die Programmiernorm DIN EN 61131-3 beschreibt drei Arten von

Zählerfunktionen als Standardfunktionsbausteine:

• CTU: Count-Up, Vorwärtszähler

• CTD: Count-Down, Rückwärtszähler

• CTUD: Count-Up-Down, Vorwärts- und Rückwärtszähler

Bei allen drei Zählerfunktionen erfolgt der Zählimpuls über eine positive

Flanke an den Zähleingängen, auch beim Rückwärtszähler.




Übersicht über die drei Zählerfunktionen nach DIN EN 61131-3

Vorwärtszähler

Rückwärtszähler

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

Die Eingangs- und Ausgangsoperanden der Zählerfunktionen nach DIN

EN 61131-3 sind wie folgt:




• CU - Zähleingang zum Vorwärtszählen

• CD - Zähleingang zum Rückwärtszählen

• LD - Ladeeingang

• R - Rücksetzeingang

• PV - Ladewert

• QU - Abfrage des Status Zählerstand (unter der Voraussetzung

das CV größer gleich dem Ladewert ist)

• QD - Abfrage des Status Zählerstand (unter der Voraussetzung

das CV kleiner gleich 0 ist)

• CV - Zählerstand

Zeitfunktionen in der Programmiersoftware

Wie bei den Zeitfunktionen waren die in der Programmiernorm 61131-3

festgelegten Standardfunktionsbausteine den Ansprüchen mancher SPS-

Programmierer nicht gerecht. Daher haben viele Hersteller von

Programmiersoftware eigene, firmenspezifische Zählerfunktionen. In

Step7 sind das folgende Zählerfunktionen:

• Z_VORW: Vorwärtszähler

• Z_RUECK: Rückwärtszähler

• ZAEHLER: Vorwärts- und Rückwärtszähler




Funktionsplandarstellung der Zähler in Step7:

Vorwärtszähler

Rückwärtszähler

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

Falls man in Step7 trotzdem die drei Zählerfunktionen nach der




Programmiernorm 61131-3 CTU, CTD und CTUD benutzen möchte,

muss man hierfür folgende Systemfunktionsbausteine benutzen:

• SFB0: Für CTU

• SFB1: Für CTD

• SFB2: Für CTUD

Sollten diese Systemfunktionsbausteine benutzt werden, muss man

hierfür auch jeweils einen Instanzdatenbaustein zuordnen, damit als

statische Lokalvariablen die notwendigen Daten verfügbar sind.




Zähler programmieren

n der SPS-Programmiersoftware Step7 hat man zwei Möglichkeiten,

Zähler zu programmieren. Möchte man gemäß der Programmiernorm

61131-3 programmieren, muss man die Systemfunktionsbausteine

SFB0 (CTU), SFB1 (CTD) oder SFB2 (CTUD) benutzen. Man kann aber

auch auf die firmenspezifischen Zählerbausteine Z_VORW, Z_RUECK

und ZAEHLER zurückgreifen. Diese benötigen im Gegensatz zu den

Systemfunktionsbausteinen keinen Instanzdatenbaustein. Dafür vergibt

man den Zählern einen Zähleroperanden Zx, z.B. Z1.

Ob man die Programmierung der Zähler in Anweisungsliste AWL,

Funktionsplan FUP bzw. Kontaktplan KOP und der Programmiersprache

SCL vornimmt, spielt im Grunde keine Rolle. Die Zähler werden im

Systemspeicher der CPU's abgelegt. Wieviele Zähler in einem SPS-

Programm benutzt werden können, hängt von der verwendeten CPU ab.

Hier muss man im Referenzhandbuch des Geräts nachschauen, um

Näheres zu erfahren.

Zähler bzw. COUNTER gehören zu den Parametertypen und haben die

Größe von 16 Bits (2 Bytes, 1 Wort).

Bedeutung der Ein- und Ausgänge anhand des Vorwärts- und

Rückwärtszählers (ZAEHLER)




Ein Zähler ist aufgebaut wie auf dem Bild dargestellt. Bei diesem

Beispiel handelt es sich um einen Vorwärts- und Rückwärtszähler. Die

Eingangs- und Ausgangsoperanden haben dabei folgende Bedeutung:

• Zx: Die Bezeichnung für den Zähler, z.B. Z1, Z2 usw.

• ZAEHLER: Hier steht der Typ des Zählers, in diesem Beispiel ist

das ein Vorwärts- und Rückwärtszähler. Z_VORW ist nur ein

Vorwärtszähler, Z_RUECK ist ein Rückwärtszähler.

• ZV: Der Eingang für den Vorwärtszählimpuls.

• ZR: Der Eingang für den Rückwärtszählimpuls.

• S: Der Setzeingang des Zählers.

• ZW Eingang für den Zählwert. Darüber kann der Zähler

voreingestellt werden (Wortoperand 16 Bit breit).

• R: Der Rücksetzeingang des Zählers (Bitoperand)

• DUAL Ausgabe des aktuellen Zählwertes dual codiert als

Wortoperand 16 Bit breit.

• DEZ: Ausgabe des aktuellen Zählwerts dezimal codiert als

Wortoperand 16 Bit breit.

• Q: Ausgang des Zählers zum Abfragen des Zählers als Bitoperand.




Verwendung von Datentypen und Operanden für Ein-

und Ausgänge von Zählern

Folgende Operanden und Datentypen werden für die Ein- und Ausgänge

verwendet:

• Zx: Operand Z, Datentyp COUNTER.

• ZV: Operanden E, A, M, DBX, L, T, und Z, Datentyp Bool.

• ZR: Operanden E, A, M, DBX, L, T, und Z, Datentyp Bool.

• S: Operanden E, A, M, DBX, L, T, und Z, Datentyp Bool.

• ZW Konstante, EW, AW, MW, DBW und LW, Datentyp WORD.

• R: Operanden E, A, M, DBX, L, T, und Z, Datentyp Bool.

• DUAL EW, AW, MW, DBW und LW, Datentyp WORD.

• DEZ: EW, AW, MW, DBW und LW, Datentyp WORD.

• Q: E, A, M, DBX und L, Datentyp Bool.

Ausgang Q

Der Ausgang Q hat das Signal 1, solange der Zählerstand über 0 ist.

Wird der Zähleroperand, z.B. Z1, abgefragt und der Zählerstand ist über

0, dann erhält man das Signal 1 zurück, was soviel bedeutet wie "Der

Zählerstand ist nicht Null". Den Status des Zählers kann man in

Verbindung mit den binären Grundverknüpfungen (AND, OR, XOR,

NAND, NOR etc.) verwenden.

Ausgänge DUAL und DEZ

Über diese beiden Ausgänge kann der aktuelle Zählerstand abgefragt

werden.




Setzen eines Zählers

Über eine positive Flanke am Setzeingang, wird der Zählerstand auf den

Zählwert gesetzt, den man am Eingang ZW eingeben kann.

Eingabe des Zählwerts

Der Zählwert am Eingang ZW kann entweder als Konstante oder BCD-

codiert eingegeben werden. Beispiele:

• C#999, Eingabe als Konstante

• W#16#999, Eingabe BCD-codiert

Ein Zählwert kann auch mit dem Ladebefehl L geladen werden, z.B. L

C#999 oder L W#16#999. Der Befehl L steht für Laden in den

Akkumulator 1. Im Programmablauf sollte man natürlich immer zuerst

der Zählwert in den Akku laden und erst danach den Setzbefehl geben.

Man kann den Zählwert auch aus Eingangs-, Ausgangs-, Merker-,

Lokaldaten- oder Datenwörtern laden.

Der Zählwert belegt im Akku eine Bitlänge von 16 Bits (1 WORD, 2

Bytes) und liegt als BCD-Code vor. Auch wenn der Datentyp WORD 16

Bit breit ist, werden dabei nur die ersten 12 Bits (Bit 0 - Bit 11) belegt.

Ein Block von 4 Bits wird dabei als eine Tetrade bezeichnet und mit

einer Tetrade kann man die Ziffern 0 - 9 darstellen. Es stehen 3

Tetraden zur Verfügung. Daher kann man nur einen Maximalwert von

999 eingeben.

Die Eingabe des Zählwerts ist ähnlich wie bei der Programmierung von

Zeitgliedern. Der Unterschied ist, dass bei Zeitgliedern zusätzlich die

Bits 12 und 13 benutzt werden, um eine Zeiteinheit anzugeben. Bei




Zählern werden diese Bitstellen nicht benutzt. Zeitglieder und Zähler

benutzen auch die Bitstellen 14 und 15 nicht.

Werden Zähler in SPS-Programmen außerhalb von Step7 nach der

Programmiernorm 61131-3 programmiert, gibt es die Möglichkeit der

Zählwerteingabe von -32768 bis 32767. Hier muss man in der

Hilfefunktion der jeweiligen Software nachschauen, inwieweit die

Zählwerteingabe begrenzt ist.

Rücksetzen eines Zählers

Über den Rücksetzeingang wird ein Zähler rückgesetzt. Der Zählerstand

erhält dadurch den Wert 0, der Ausgang ist dann ebenfalls 0. Ein Zähler

ist rücksetzdominant. Solange ein Signal 1 am Rücksetzeingang anliegt,

kann nicht gezählt werden und der Zähler kann auch nicht auf den

Zählwert gesetzt werden.

Vorwärts- und Rückwärtszählen

Eine positive Flanke am Eingang ZV (Vorwärtszählers) oder am

Eingang ZR (Rückwärtszählen) lässt den aktuellen Zählerstand um 1

hoch- bzw. runterzählen. Dabei kann der Zählerstand nur Zahlenwerte

innerhalb 0 - 999 haben. Bei einem Versuch, darüber oder darunter zu

zählen, bleibt der Zählerstand an der Wertegrenze stehen (bei 0 oder

999).




Zählerfunktionen einzeln verwenden

Man kann in Step7 einzelne Zählerfunktionen auch separat bedienen wie

folgende Übersicht zeigt.




Digitale Operationen

Im Unterschied zu den binären Operationen werden bei den digitalen

Operationen vorwiegend "zählbare" Signale verarbeitet. Betrachten Sie

als Beispiel die binäre UND-Verknüpfung. Entscheidend für das Ergebnis

sind die Eingänge, die den Zustand 0 oder 1 haben können.

Bei den digitalen Operationen werden dagegen überwiegend

Wertebereiche verarbeitet. Als Beispiel betrachten wir hier z.B. die

arithmetischen Funktionen. Damit können Zahlenwerte berechnet

werden, beispielsweise möchten Sie Addieren und dafür haben Sie zwei

Werte. Die zu addierenden Werte sind jedoch keine einfachen binären

Signale sondern können große Zahlenwerte beinhalten, z.B. 01010110

+ 11010111. Man verarbeitet also große "zählbare" Signale. Das ist der

Unterschied zwischen binären und digitalen Operationen.

Ob und wann digitale Operationen sinnvoll sind, hängt von der

jeweiligen Aufgabe ab. Ein SPS-Programmierer sollte sie auf jeden Fall

kennen.

Neben den arithmetischen Operationen gibt es natürlich viele weitere

Operationen, die man zu den digitalen Operationen zählen kann. Wir

haben auf diesen Seiten die wichtigsten aufgelistet.

• Dazu gehören die Übertragungsfunktionen die benutzt werden um

Daten von einer Adresse zur anderen zu übertragen.

• Die Vergleichsfunktionen werden benutzt, um Werte miteinander

zu vergleichen.

• Mit den Schiebefunktionen werden die Bitmuster nach rechts oder




links verschoben.

• Umwandlungsfunktionen werden dann genutzt, wenn der

Datentyp geändert werden soll, z.B. von REAL zu INT.

• Digitale Verknüpfungen dienen dazu, Binärstellen und Konstanten

miteinander zu verknüpfen.

• Mit numerischen Funktionen werden Werte ermittelt, z.B. SIN,

COS.




Übertragungsfunktionen: Lade- und Transferfunktionen, Akkumulatorfunktionen

Übertragungsfunktionen werden genutzt, um beispielsweise Daten von

einer Adresse zur anderen Adresse zu übertragen. Dabei werden die

Daten in den Akkumulator der CPU geladen danach in ein anderes Ziel

transferiert. Der Datentransfer kann dabei zwischen den

verschiedensten Betriebsmitteln der Steuerung stattfinden, z.B.

zwischen Eingängen, Ausgängen, Merkern oder Datenbausteinen.

Eine andere Möglichkeit besteht darin, zwischen den Akkumulatoren ein

Datenaustausch stattfinden zu lassen. Das wird bei folgenden digitalen

Operationen benötigt:

• Vergleichsfunktionen

• Schiebefunktionen

• Arithmetische Funktionen

• Digitale Verknüpfungen

Da hierbei Daten zwischen den Akkumulatoren ausgetauscht werden,

sind mindestens zwei Akkmulatoren nötig. Je mehr Akku's eine CPU

besitzt, umso besser ist das natürlich. Denn dann können diese für

Zwischenergebnisse oder Zwischenspeicherung genutzt werden.

Lade- und Transferfunktionen

Wenn Sie Daten von einer Adresse zu einer anderen transferieren




möchten, benötigen Sie dafür die Lade- und Transferfunktionen. Dabei

werden die Daten zuerst in den Akku 1 geladen, danach aus dem Akku

ausgelesen und zu einem definierten Ziel transferiert. Beim Laden der

Daten in den Akku 1 wird der ursprüngliche Inhalt von Akku 1 in den

Akku 2 transferiert und verbleibt dort. Der ursprüngliche Inhalt von

Akku 2 geht bei diesem Vorgang verloren. Der Zustand des VKE oder

Statusbits spielt beim Laden und Transferieren keine Rolle

Folgende Werte können geladen werden:

• Eingänge

• Ausgänge

• Merker

• Zeiten

• Zählwerte

• Konstanten

• Datenbausteine

• Peripherie

• Variablen

Sie können folgende Adressen laden und transferieren:

• Byteadresse

• Wortadresse

• Doppelwortadresse

Der Datentyp kann dabei folgendes Format haben:

• INT

• DINT

• REAL

Ein Schaubild zur Verdeutlichung der Vorgänge beim Laden und




Transferieren:

Vorgänge während einer Lade- und Transferfunktion

Die Belegung des Akkus beim Laden und Transferieren

Es ist wichtig zu verstehen, wie die Akkus oder das Adressregister beim

Laden und Transferieren belegt werden, welche Bytes auf der rechten

Seite und welche auf der linken Seite stehen. Grundsätzlich gilt: Die

höhere Byteadresse wird rechtsbündig geladen und die restlichen

Bytes werden mit 0 gefüllt.

Wenn ein Byte geladen und transferiert wird, wird der Akku oder das

Adressregister rechtsbündig mit einem Byte belegt, da das Byte bereits

die höchste Adresse ist. Ein Schaubild wie der Akku belegt wird, wenn




ein Byte geladen wird.

Belegung des Akkus beim Laden von ein Byte

Dementsprechend gilt beim Laden und Transferieren von ein Wort: Das

höhere Byte steht auf der rechten Seite, das niedrigere auf der

linken Seite. Der Rest wird wieder mit 0 gefüllt. Ein Schaubild beim

Laden von ein Wort in den Akku.

Das höhere Byte steht auf der rechten Seite

Beim Laden und Transferieren eines Doppelworts werden alle 4 Bytes

des Akku 1 belegt. Die höchste Byteadresse steht dabei wieder ganz




rechts. Auch hier wieder ein Schaubild.

Laden eines Doppelworts in den Akku

Beim Transferieren verhält es sich analog wie beim Laden in den Akku.

Das bedeutet, dass der Inhalt, der ganz links im Akku steht, zur

kleinsten Byteadresse transferiert und die weiter rechts stehenden

Bytes jeweils zur höheren Byteadresse transferiert werden.

Die MOVE-Box in FUP

Das Laden und Transferieren wird in FUP über die MOVE-Box realisiert.

Dabei werden die am Eingang IN anstehenden Daten wie zuvor

dargestellt in den Akku 1 geladen und danach an die am OUT-Ausgang

definierte Byteadresse transferiert.

Zusätzlich besitzt die MOVE-Box den Eingang EN, an den ein

Freigabesignal zur Bedingung gemacht werden kann. ENO ist der

Freigabeausgang und führt das Signal 1, wenn der Baustein fehlerlos

abgearbeitet wird.




Akkumulatorfunktionen

Akkumulatorfunktionen werden dann gebraucht, wenn die Inhalte

zwischen den Akkus getauscht oder verschoben werden sollen. Sie

werden wie bei Lade- und Transferfunktionen unabhängig vom Zustand

des Statusbits und VKE durchgeführt.

Nachfolgend eine Auflistung über die Akkumulatorfunktionen sowie die

Wirkungsweise.

PUSH: Der Befehl PUSH sorgt dafür, dass die Inhalte der Akkus in die

jeweils höheren Akkus verschoben wird. Das bedeutet bei Geräten mit 4

Akkus:

• Der Inhalt von Akku 1 wird in Akku 2 verschoben



Dementsprechend ändert sich der Inhalt von Akku 1 nicht. Bei Geräten

mit nur 2 Akkus wird der Inhalt lediglich von Akku 1 nach Akku 2

verschoben. Ein Schaubild zur Verdeutlichung der Vorgänge.




Beim PUSH-Befehl werden die Inhalte in den höheren Akku

verschoben

POP: Beim POP-Befehl verhält es sich genau umgekehrt. Hierbei

werden die Inhalte in den jeweils niedrigeren Akku verschoben.

Bei diesem Vorgang ändert sich logischerweise der Inhalt des höchsten

Akkus nicht. Bei Geräten mit nur 2 Akkus wird der Inhalt lediglich von

Akku 2 in Akku 1 verschoben. Wieder ein Schaubild:




Beim POP-Befehl werden Inhalte in den niedrigeren Akku

verschoben

TAK: Bei diesem Vorgang werden die Inhalte von Akku 1 und Akku 2

vertauscht.

TAK vertauscht die Inhalte von Akku 1 und Akku 2

TAW: Dieser Befehl sorgt dafür, dass die Inhalte der rechten Bytes im

Akku 1 vertauscht werden.




Die Inhalte der beiden rechten Bytes werden beim TAW-Befehl

getauscht

TAD: Der TAD-Befehl vertauscht den Inhalt von Akku 1 spiegelverkehrt.

Spiegelverkehrter Tausch mit TAD

Nur ab S7-400er Reihe gültig

ENT: Mit dieser Funktion wird der Inhalt von Akku 2 und Akku 3 in den

jeweils höheren Akku verschoben. Der Inhalt von Akku 1 und Akku 2

ändert sich dementsprechend nicht.




Inhalte von Akku 2 und 3 werden mit ENT in höhere Akkus

verschoben

LEAVE: Beim LEAVE-Befehl verhält es sich wieder umgekehrt. Die

Inhalte von Akku 4 und Akku 3 werden in die jeweils niedrigeren Akkus

verschoben. Die Inhalte von Akku 1 und Akku 4 ändern sich bei diesem

Vorgang nicht.




Mit LEAVE den Inhalt von Akku 4 und 3 in die niedrigeren Akkus

verschieben




Vergleichsfunktionen: Vergleicher in SPS

Wie in der Mathematik müssen in Steuerungen manchmal

Vergleichsfunktionen eingebaut werden. Beispielsweise könnte man

einen Zählerstand mit einem Wert vergleichen und abhängig vom

Ergebnis die Ausgänge auf 0 oder 1 setzen.

Bei diesem Vorgang werden zwei Operanden miteinander verglichen, die

denselben Datentyp haben müssen. Trifft der Vergleich zu, steht ein

boolescher Signal 1 zur Verfügung, ansonsten 0. Die nachfolgenden

Vergleichsfunktionen werden bei Speicherprogrammierbaren

Steuerungen eingesetzt:

• == (GLEICH)

• <> (UNGLEICH)

• <= (KLEINER o. GLEICH)

• >= (GRÖßER o. GLEICH)

• < (KLEINER)

• > (GRÖßER)

Folgende Operanden können für Vergleichsfunktionen eingesetzt

werden:

• Bit

• Byte

• Wort

• Doppelwort

Dabei können die Datentypen vom folgenden Format sein:

• INT




• DINT

• REAL

• DATE-AND-TIME

• STRING

• CHAR

Vergleichsfunktionen werden unabhängig vom VKE mit Hilfe der

Ladefunktion der CPU durchgeführt. Daher werden für die Durchführung

wieder die beiden Akkus der CPU benötigt. Der Vorgang bei der

Durchführung einer Vergleichsfunktion ist wie folgt:

1. Der Wert des ersten Vergleichsoperanden wird in den Akku 1

geladen

2. Der Inhalt von Akku 1 wird in Akku 2 verschoben

3. Der Wert des zweiten Vergleichsoperanden wird in Akku 1 geladen

4. Die Vergleichsoperation folgt, indem der Inhalt von Akku 1 mit

Akku 2 verglichen wird

5. Trifft der Vergleich zu, wird das VKE zu 1.

6. Das VKE kann über weitere Funktionen ausgewertet werden.

Vergleichsfunktion in FUP

Beispielhaft eine Vergleicherbox in FUP. An den beiden Eingängen IN1

und IN2 sind zwei Operanden die miteinander verglichen werden. In

diesem Beispiel werden sie auf Gleichheit geprüft. Zu erkennen an

CMP==I.

CMP kommt von Compare und bedeutet übersetzt Vergleichen. Mit

== wird angegeben, dass die beiden Werte auf Gleichheit verglichen




werden sollen. Das I gibt den Datentyp an, in dem Fall INT. Sind die

beiden Werte gleich, soll das Signal am Ausgang A4.0 eine 1 sein. Da

der Datentyp INT 16 Bit breit ist, müssen die Operanden Wörter sein.

Vergleicher-Box in FUP

Eine Vergleicherbox für Datentyp DINT in FUP

Der Vergleicher für den Datentyp DINT sieht genauso aus. Nur mit dem

Unterschied, dass statt einem I ein D hinter dem Vergleichszeichen

steht. Der Datentyp DINT ist 32 Bit breit. Daher werden an den

Eingängen IN1 und IN2 Doppelwörter benötigt.

Vergleicher-Box für Datentyp DINT

Vergleicherbox für Datentyp REAL

Der Vollständigkeit halber noch ein Vergleicher für den Datentyp REAL,

zu erkennen an dem Zeichen R nach dem Vergleichszeichen. Der

Datentyp REAL ist ebenfalls 32 Bit breit und benötigt Doppelwörter an




den Eingängen.

Neben der Box für den Vergleich auf Gleichheit gibt es natürlich

separate Vergleicher für Ungleich, Kleiner, Größer etc.

Vergleicher für den Datentyp REAL




Schiebefunktionen

Mit Schiebefunktionen werden die Bits um eine bestimmte Anzahl von

Stellen links oder rechts verschoben. Dabei werden entweder auf der

linken oder rechten Seite Stellen frei. Diese werden mit 0 gefüllt.

Schiebefunktionen werden unabhängig von sonstigen Bedingungen im

Akku 1 ausgeführt. Das Ergebnis verbleibt ebenfalls im Akku 1. Anbei

ein Schaubild über das was passiert, wenn eine Schiebefunktion um 5

Stellen nach links durchgeführt wird.

Schiebefunktion um 5 Stellen nach links

Schiebefunktionen sind VKE-neutrale Operationen und beeinflussen das

VKE nicht. Sie werden einfach ausgeführt. In diesem Beispiel wurde der

Inhalt des gesamten Akkus um 5 Stellen nach links verschoben. In

solchen Fällen spricht man von einer Schiebefunktion für den Datentyp

Doppelwort.

Eine interessante Tatsache ist jedoch, was passiert, wenn man die

Schiebefunktion für den Datentyp Wort durchführt. In diesem Fall wird

nämlich die rechte Seite von Akku 1 verschoben. Die linke Seite bleibt

unberührt. Wieder ein Schaubild zur Verdeutlichung für den Datentyp




Wort.

Schiebefunktion für den Datentyp Wort

Schiebefunktion in FUP

Auf dem nachfolgenden Bild sehen Sie die Darstellung der

Schiebefunktion in FUP. In diesem Beispiel wurde die Schiebefunktion

nach rechts für den Datentyp INT benutzt. Zu erkennen an SHR_I.

Auch Schiebefunktionen haben einen Freigabeeingang, hier mit E0.1

adressiert, und einen Freigabeausgang. Am IN-Eingang kommt die

Adresse des zu schiebenden Bitmusters. Am OUT-Ausgang wird das

Ergebnis der Verschiebung transferiert. IN und OUT müssen nicht

unterschiedlich sein. Am N-Eingang wird die Anzahl der Stellen

Hexadezimal angegeben, um die das Bitmuster verschoben werden soll.

In unserem Beispiel um 3 Stellen. Möchten wir das Bitmuster um 21

Stellen verschieben, hätten wir W#16#15 angeben müssen.

Das Ergebnis der Verschiebung von AB10/11 (AW10) sehen Sie an den

Ausgangsbytes AB20/21. Das Bitmuster ist um 3 Stellen nach rechts

verschoben.




Schiebefunktion nach rechts in FUP

Weitere Schiebefunktionen

Eine Übersicht über die Schiebefunktionen in Step7. Ob nach rechts

oder links verschoben wird, erkennen Sie an den Buchstaben R oder L.

Der einzige Unterschied bei den Schiebeboxen ist die Länge des zu

schiebenden Bitmusters (Wort, Doppelwort) und der dazugehörige

Datentyp. Der Rest ist gleich. Aus dem Grund gehen wir nicht näher auf

die einzelnen Boxen ein.

Rotieren

Rotieren ist eine weitere Möglichkeit, Bitmuster zu verschieben. Beim

Rotieren gehen die hinausgeschobenen Bits nicht verloren, sondern

füllen die Stellen, die sonst mit 0 gefüllt werden. So wird das Bitmuster

"im Kreis" verschoben.




Beim Rotieren wird quasi im "Kreis" verschoben

Rotierfunktion in FUP

Auch für die Rotierfunktion gibt es eine Box für die Darstellung in FUP.

Neben ROL_DW für "Rotieren nach links" gibt es ROR_DW für "Rotieren

nach rechts". Beide Boxen rotieren den Inhalt eines Doppelworts.

Rotierbox in FUP

Besonderheiten bei der Programmierung in AWL

Sowohl für die Schiebe- als auch für die Rotierfunktionen gibt es

Besonderheiten bei der Programmierung in AWL. Beim Programmieren

von Schiebefunktionen in AWL ist die Angabe der Stellen, um die das

Bitmuster verschoben werden soll, nicht nötig. In diesem Fall wird die

Zahl genommen, die sich im Akku 2 befindet. Ist beim Wortschieben die

Zahl größer als 16 oder beim Doppelwortschieben größer als 32, dann

wird um 16, bzw. 32 Stellen verschoben.

Für die Rotierfunktion gibt es in Step7 keine Boxen für Wörter, Bytes




oder Bits, obwohl das möglich ist. Diese Möglichkeit ist bei der

Programmierung in AWL vorhanden.




Arithmetische Funktionen

Mit arithmetischen Funktionen werden die 4 Grundrechenarten

Addieren, Subtrahieren, Multiplizieren sowie Dividieren ausgeführt. So

kann eine SPS auch rechnen.

Arithmetische Funktionen werden ebenfalls unabhängig vom VKE

ausgeführt. Während des Rechenvorgangs können Sie das Ergebnis

über die Statusbits einsehen. Der Vorgang ist dabei wie folgt:

• Der erste Operand wird in Akku 1 geladen


• Der zweite Operand wird in Akku 1 geladen

• Die Rechenoperation wird mit dem Inhalt von Akku 1 und 2

durchgeführt

• Das Ergebnis wird in Akku 1 geschrieben

Für fast alle Rechenoperationen werden daher zwei Akkus gebraucht.

Für die Addition von Konstanten mit bestimmten Datentypen wird nur

ein Akku gebraucht. Beim Dividieren dient Akku 2 als Dividend und

Akku 1 als Divisor. Akku 2 wird also durch Akku 1 dividiert.

Generell müssen beide Operanden den gleichen Datentyp haben. Das

Ergebnis hat ebenfalls den Datentyp der Operanden. Wenn Sie

arithmetische Funktionen in der Darstellungsart FUP erstellen, werden

Sie auf fehlerhafte Datentypen aufmerksam gemacht. Das ist in AWL

leider nicht so. In AWL wird der Datentyp nicht geprüft. So können sich

Fehler einschleichen.




Arithmetische Funktion in FUP

Auf dem Bild sehen Sie die arithmetische Funktion Addieren von

Integerwerten in der Darstellungsart FUP. Die beiden Operanden

AW10 und AW20 wurden addiert und das Ergebnis wurde in AW30

geschrieben. Die arithmetischen Boxen haben neben den beiden

Operandeneingängen IN1, IN2 und dem Ausgang OUT zusätzlich die

Freigabeein- und -ausgänge EN und ENO.

Addieren von Integer

Arithmetische Funktionen in Step7

In Step7 befinden sich die arithmetischen Funktionen unterhalb des

Knotens Festpunktfunktionen sowie unter Gleitpunktfunktionen. Der

Knoten Festpunktfunktionen beinhaltet alle Boxen zum Berechnen von

Integer- und Doppelintegerwerten. Unter Gleitpunktfunktionen befinden

sich alle arithmetischen Funktionen für den Datentyp REAL. Hier sind

zusätzlich weitere Funktionen wie z.B. ABS, SQRT etc. Diese zählen

jedoch zu den numerischen Funktionen.




Arithmetische Funktionen

Bei vielen Operationen kann es passieren, dass der zulässige

Zahlenbereich verlassen wird. Diese werden durch die Statusbits OS

und OV gemeldet. Bei einer Division durch 0 ergibt als Ergebnis beim

Quotienten und Rest jeweils eine 0 und die Statusbits OV und OS

werden ebenfalls auf 1 gesetzt. Außer bei Integerwerten werden alle

Ergebnisse der Rechenoperation im gesamten Akku 1 gespeichert.

Besonderheiten beim Berechnen von Integerwerten:

• Die Operanden werden rechtsbündig in Akku 1 und Akku 2

geladen

• Beim Addieren/Subtrahieren wird das Ergebnis wird rechtsbündig

im Datenformat INT in Akku 1 gespeichert

• Beim Multiplizieren wird das Ergebnis wird im Datenformat DINT

im gesamten Akku 1 gespeichert

• Beim Dividieren wird der ganzzahlige Quotient im rechten Wort

von Akku 1 geschrieben, der Rest im linken Wort

Besonderheit beim Dividieren von Doppelintegerzahlen:

Beim Rechnen mit Doppelintegerwerten wird der gesamte Akku 1




gebraucht. Daher gibt es für die Division zwei Anweisungen. DIV und

MOD. Mit DIV wird der ganzzahlige Quotient und mit MOD der Rest in

Akku 1 gespeichert.




Umwandlungsfunktionen

Umwandlungsfunktionen werden verwendet, wenn das Datenformat in

ein anderes Datenformat konvertiert werden soll. Sie werden alle im

Akku 1 ausgeführt und gelten ebenfalls als VKE-neutrale Funktionen,

d.h. sie beeinflussen das VKE nicht und werden unabhängig vom VKE

ausgeführt.

In Step7 befinden sich die Umwandlungsfunktionen unterhalb des

Knotens Umwandler.

Umwandler

Durch die Benutzung der einzelnen Funktionen werden die Datentypen

wie folgt umgewandelt:

• BCD_I: BCD-Zahl in Integerzahl




• I_BCD: Integerzahl in eine BCD-Zahl

• I_DI: Integerzahl in Doppelintegerzahl

• BCD_DI: BCD-Zahl in Doppelinteger

• DI_BCD: Doppelinteger in BCD-Zahl

• DI_R: Doppelintegerzahl in Gleitpunktzahl

• INV_I: Integerzahl invertieren (Einerkomplement)

• INV_DI: Doppelintegerzahl invertieren (Einerkomplement)

• NEG_I: Integerwert negieren (Zweierkomplement)

• NEG_DI: Doppelintegerwert negieren (Zweierkomplement)

• ROUND: Gleitpunktzahl zu Ganzzahl runden

• TRUNC: Nachkommastelle abschneiden, Ganze Zahl erzeugen

• CEIL: Aus Gleitpunktzahl nächsthöhere Ganzzahl erzeugen

• FLOOR: Aus Gleitpunktzahl nächstniedrigere Ganzzahl erzeugen

Neben diesen gibt es die Möglichkeit der Umwandlung von Bool, Byte,

Wort und Doppelwort. Dafür werden die Lade- und Transferfunktionen

benutzt. Umwandlungsfunktionen in FUP haben einen Eingangsvariablen

IN und den Ausgangsvariablen OUT. Daneben haben sie den

Freigabeein- und -ausgang EN und ENO. Beim Umwandeln können

Fehler auftreten, z.B. wenn der erlaubte Zahlenbereich verlassen oder

die angegebene Gleitpunktzahl ungültig ist. Wenn beim Umwandeln ein

Fehler auftritt, wird der Freigabeausgang ENO auf 0 gesetzt.




Digitale Verknüpfungen

Digitale Verknüpfungen werden einmal verwendet, wenn einzelne Bits

von zwei Operanden miteinander verknüpft werden sollen. Die zweite

Möglichkeit ist, einen Operanden mit einer Konstante zu verknüpfen.

Dabei werden keine Überträge gebildet. Auch bei digitalen

Verknüpfungen spielt das VKE keine Rolle und das Ergebnis der

Verknüpfung beeinflusst das VKE nicht.

Für die Verknüpfung werden beide Akkus gebraucht. Der Vorgang ist

dabei wie folgt:

• Der Inhalt des ersten Operanden wird in Akku 1 geladen

• Der Inhalt von Akku 1 wird danach in Akku 2 verschoben

• Der Inhalt des zweiten Operanden oder die Konstante wird in Akku

1 geladen

• Der Inhalt von Akku 2 wird mit Akku 1 mit der angegebenen

Verknüpfungsoperation verknüpft

• Das Ergebnis wird in Akku 1 gespeichert

Es gibt drei Arten von digitalen Verknüpfungen:

• UND (AND)

• ODER (OR)

• EXKLUSIV-ODER (XOR)

Die Operanden die verknüpft werden, müssen in der Darstellungsart

FUP folgende Datenformate haben:

• Wort




• Doppelwort

Der Datentyp wird in AWL nicht geprüft. In AWL kann ein Ergebnis ohne

Zwischenspeicherung weiter verknüpft werden. In FUP wird eine

Zwischenspeicherung benötigt.

Digitale UND-Verknüpfung

Die digitale UND-Verknüpfung funktioniert nach folgendem Schema:

• 1 und 1=1

• 1 und 0=0

• 0 und 1=0

• 0 und 0=0

Beispiel für eine digitale UND-Verknüpfung:

Operand 1: 0011010101110011

Operand 2: 1011011000100101

Ergebnis: 0011010000100001

Digitale ODER-Verknüpfung

Die digitale ODER-Verknüpfung funktioniert nach folgendem Schema:

• 1 und 1=1

• 1 und 0=1

• 0 und 1=1

• 0 und 0=0

Beispiel für eine digitale ODER-Verknüpfung:




Operand 1: 0011010101110011

Operand 2: 1011011000100101

Ergebnis: 1011011101110111

Digitale EXKLUSIV-ODER-Verknüpfung

Die digitale ODER-Verknüpfung funktioniert nach folgendem Schema:

• 1 und 1=0

• 1 und 0=1

• 0 und 1=1

• 0 und 0=0

Beispiel für eine digitale EXKLUSIV-ODER-Verknüpfung:

Operand 1: 0011010101110011

Operand 2: 1011011000100101

Ergebnis: 1000001101010110

Digitale Verknüpfungen in FUP

Die Boxen für digitale Verknüpfungen befinden sich in Step7 unterhalb

des Knotens Wortverknüpfung. Hier sind die Boxen für

Wortverknüpfungen und Doppelwortverknüpfungen. An den beiden IN-

Eingängen werden die zu verknüpfenden Operanden adressiert, das

Ergebnis wird an den OUT-Ausgang geschrieben. Zusätzlich gibt es den

Freigabeeingang EN und den Freigabeausgang ENO.




Digitale Verknüpfungen in Step7




Operanden in SPS

Darstellung der Operanden

Für die Darstellung der Eingänge, Ausgänge etc. werden Operanden benötigt,

damit die SPS weiß, was er mit wem machen soll. Hierfür gibt es verschiedene

Arten von Operanden. Wenn beispielsweise der Signalzustand eines Schalters

abgefragt werden soll, dann wird dafür ein Operand vom Typ Eingang benutzt. Soll

z.B. ein Motor eingeschaltet werden, wird dafür ein Operand vom Typ Ausgang

benutzt. Jeder Operand hat einen Adressierungsbereich (Bit, Byte, Wort,

Doppelwort). Welcher Adressierungsbereich benutzt wird, hängt vom Datentyp ab.

Die Bezeichnung der Operanden ist entweder vom Hersteller vorgegeben oder

kann international nach der Norm EN 61131 vorgenommen werden. Nachfolgend

eine Übersicht über die Operanden, aufgeteilt nach IEC (Norm 61131) oder die

Bezeichnung in Step7.

IEC Step7 Beschreibung, Beispiel Datentyp AdressbereichI E Eingangsbit, E0.0 BOOL 0.0 bis 65535.7IB EB Eingangsbyte, EB1 BYTE, CHAR 0 bis 65535

IW EW Eingangswort, EW10

WORD, INT,

S5TIME,

DATE

0 bis 65534

ID ED Eingangsdoppelwort, ED20

DWORD,

DINT, REAL,

TOD, TIME

0 bis 65532

Q A Ausgangsbit, A0.0 BOOL 0.0 bis 65535.7




QB AB Ausgangsbyte, AB1 BYTE, CHAR 0 bis 65535

QW AW Ausgangswort, AW10

WORD, INT,

S5TIME,

DATE

0 bis 65534

QD AD Ausgangsdoppelwort, AD20

DWORD,

DINT, REAL,

TOD, TIME

0 bis 65532

M M Merkerbit, M0.0 BOOL 0.0 bis 65535.7MB MB Merkerbyte, MB1 BYTE, CHAR 0 bis 65535

MW MW Merkerwort, MW10

WORD, INT,

S5TIME,

DATE

0 bis 65534

MD MD Merkerdoppelwort, MD20

DWORD,

DINT, REAL,

TOD, TIME

0 bis 65532

PIB PEBPeripherieeingangsbyte,

PEB10BYTE, CHAR 0 bis 65535

PQB PABPeripherieausgangsbyte,

PAB10BYTE, CHAR 0 bis 65535

PIW PEWPeripherieeingangswort,

PEW10

WORD, INT,

S5TIME,

DATE

0 bis 65534

PQW PAWPeripherieausgangswort,

PAW10

WORD, INT,

S5TIME,

DATE

0 bis 65534

PID PEDPeripherieeingangs-

Doppelwort, PED10

DWORD,

DINT, REAL,

TOD, TIME

0 bis 65532

PQD PADPeripherieausgangs-

Doppelwort, PAD10

DWORD,

DINT, REAL,

TOD, TIME

0 bis 65532




T T Timer, T1 TIMER 0 bis 65535C Z Zähler, Z1 COUNTER 0 bis 65535FB FB Funktionsbaustein, FB10 FB 0 bis 65535OB OB Organisationsbaustein, OB1 OB 1 bis 65535

DB DBDatenbaustein, DB10,

DBX0.0, DBB1, DBW1

DB, FB,

SFB, UDT1 bis 65535

FC FC Funktion, FC1 FC 0 bis 65535

SFB SFBSystemfunktionsbaustein,

SFB30SFB 0 bis 65535

SFC SFC Systemfunktion, SFC30 SFC 0 bis 65535VAT VAT Variablentabelle 0 bis 65535UDT UDT Userdefinierter Datentyp UDT 0 bis 65535




SPS Adressierung

Eine Adresse in der SPS ist ein Wert mit dem festgelegt wird

• wo an welcher Stelle in einem Arbeitsspeicher Informationen

abgespeichert bzw. ausgelesen werden sollen

• welche Peripherie angesprochen werden soll (Eingänge,

Ausgänge)

Eine Adressangabe sieht z.B. folgendermaßen aus:

• Eingangsadresse: E0.0

• Ausgangsadresse: A4.0

• Merker: M10.0

Ein anderes Wort für die Adressangabe ist Operand. Welche Adressen in

einer SPS möglich sind, ist unter Operanden in SPS aufgelistet.

Mit Adressierung wird die Adressangabe in einem Anwenderprogramm

gemeint. Dabei gibt es unterschiedliche Arten der Adressierung.

Adressierung fest

Wird auch feste, direkte oder absolute Adressierung genannt.

• vorgegebene (feste) Adressen von Steckplätzen für

Eingangsbaugruppen oder Ausgangbaugruppen

• vorgegebene (feste) Adressen von Anschlussklemmen von

analogen oder digitalen Ein- und Ausgängen

• ein SPS-Operand mit einer festen Adresse wie z.B. A0.0 ist in




allen Codebausteinen (der Operand muss nicht deklariert werden)

global gültig und bekannt

Adressierung indirekt

• indirekte Adressierung ermöglicht es Operanden anzusprechen deren

Adresse sich während des Ablaufes eines Anwenderprogrammes verändern

kann

Adressierung symbolisch

• bei der Adressierung wird mit eindeutigen Symbolen (Bezeichnungen)

gearbeitet, hierbei wird durch eine Zuordnungsliste / Deklaration einer

Adresse ein Symbol zugeordnet, z.B. Adresse E0.0 hat das Symbol

NOT_AUS

• die symbolische Adressierung ist nur lokal gültig

• die symbolische Adressierung darf nur einen Unterstrich

beinhalten, d.h. NOT_AUS und nicht NOT__AUS

Näheres auch unter Symbolische Adressierung.

Adressierung variabel

• parametrierbare Baugruppenadresse, die Adresse einer Baugruppe kann frei

gewählt werden




Datentypen bei Programmierung von Steuerungsaufgaben

Bei der Erstellung von SPS-Programmen hat man es mit verschiedenen

Datentypen zu tun. Mit den verschiedenen Datentypen werden unterschiedliche

Speicherinhalte voneinander abgegrenzt, für die unterschiedliche Speicherbereiche

reserviert werden.

• Beispiel für das Signal 1: Datentyp Bool

• Benötigter Speicherplatz: 1 Bit

• Menge der darstellbaren Ziffern: 2 (0 und 1)

Die Angabe eines Datentyps wird insbesondere bei der

Variablendeklaration von Funktionen oder Funktionsbausteinen benötigt.

Bei der Deklaration einer Variable "weiß" das Programm z.B. nicht, ob

es sich um einen booleschen Wert (1 Bit groß) handelt, ob es sich um

eine Byteadresse (8 Bits) handelt usw. Durch die Angabe des

Datentypen legt man im Grunde fest, in welcher Form die Daten bei

einer Abfrage erwartet werden oder wie die Daten bei einer Ausgabe

abgelegt werden sollen. Innerhalb eines SPS-Programms werden die

Daten auch häufig mit einem bestimmten Datentypen erwartet. Wenn

die SPS z.B. für die Durchführung eines Befehls für den Wert eine

Bitlänge von 16 Bits erwartet, kann man nicht eine Bitlänge von 8 Bits

übergeben. Durch den Datentypen werden außerdem viele

Wertebereiche begrenzt. Beispiel:




• Datentyp für den Zeitwert in S7: S5TIME

• Datenlänge: 16 Bits, wovon die letzten 2 Bits ignoriert werden

• Darstellbare Wertebereiche: 10 Millisekunden bis 9990 Sekunden

In der Programmiernorm 61131-3 wurden für Steuerungsaufgeben

verschiedene Datentypen festgelegt. Dabei wurden auch sogenannte

Schlüsselwörter für Datentypen festgelegt, die nicht anderweitig

verwendet werden dürfen.

Die Datentypen werden in 2 Kategorien eingeteilt. Diese sind:

• Elementare Datentypen: Diese haben eine maximale Länge von

32 Bits. Damit werden, wie der Name schon andeutet, elementare

Daten beschrieben, z.B. eine Ganzzahl mit einer Länge von 16

Bits.

• Zusammengesetzte Datentypen: Diese Datentypen können aus

mehreren elementaren Datentypen bestehen. Wenn man z.B.

einen Datentypen mit einer Ganzzahl und einer Zeichenkette

benutzt, so hat man es hier mit einem zusammengesetzten

Datentypen zu tun. Daher können diese auch größer als 32 Bits

sein. Diese sind auch vordefiniert. Das bedeutet, der

Programmierer hat nicht die Auswahl festzulegen, um welchen

Datentypen es sich dabei handelt, wenn er in der

Variablendeklaration zusammengesetzte Datentypen benutzt.




Elementare Datentypen in Step7

Name Datentyp Größe Wertebereich

BOOL Boolescher Wert 1BitFalse (logisch 0), True

(logisch 1)

BYTE

Dual- und

Hexadezimalzahlen mit

8 Bits

8 Bits

Dualzahlen 00000000 -

11111111

Hexadezimal B#16#0 -

B#16#FF

WORD

Dual- und


16 Bits

16 Bits

Dualzahlen von 0 bis 1111

1111 1111 1111

Hexadezimal W#16#0 -

W#16#FFFF

BCD-Zahlen von 0 bis 999

Dezimal ohne Vorz. B#(0,0)

bis B#(255,255)

DWORD

Dual- und


32 Bits

32 Bits

Dualzahlen von 0 bis 1111

1111 1111 1111 1111 1111

1111 1111

Hexadezimal von

DW#16#0000 0000 bis

DW#16#FFFF FFFF

Dezimal ohne Vorz. von

B#(0,0,0,0) bis

B#(255,255,255,255)

CHAR ASCII-Zeichen 8 BitBuchstaben, z.B. A, B, C, D

usw.

INT

Ganze Zahlen mit

Vorzeichen

(Festpunktzahlen)

16 Bit -32768 bis +32768




DINT

Ganze Zahlen mit

Vorzeichen

(Festpunktzahlen)

32 Bit -2147483648 bis

+2147483648

REAL

Reelle Zahlen

(IEEE

Gleitpunktzahlen)

32 Bit

Dezimalzahl mit Punkt

(156,235)

Exponentialdarstellung

(1.568 E+04)

S5TIME

Zeitdauer im S5T#-

Format

Step7 Zeit in Schritten

von 10ms

16 Bit

S5T#0H_0M_0S_10MS bis

S5T#2H_46M_30S_0MS und

S5T#0H_0M_0S_0MS

TIME

Zeitdauer im IEC-

Format

IEC-Zeit in Schritten

von 1ms, Ganzzahl mit

Vorzeichen

32 Bit

-

T#24D_20H_31M_23S_648

MS

bis

T#24D_20H_31M_23S_647

MS

TIME_OF

_DAY

Uhrzeit (Tageszeit)

in Schritten von 1ms32 Bit

TOD#0:0:0.0 bis

TOD#23:59:59.999

z.B.

TIME_OF_DAY#23:59:59,9

DATE

IEC-Datum in Schritten

von

1 Tag

16 Bit

D#1990-1-1 bis D#2168-

12-31

z.B. DATE#2006-05-10

Für BCD-Zahlen gibt es keinen besonderen Datentypen in der Norm, auch nicht in

Step7. BCD-Zahlen werden als Hexadezimalzahlen eingegeben wobei man die

Datentypen BYTE, WORD und DWORD und die Ziffern 0 bis 9 verwendet. Am

Beispiel des Datentyps WORD würde die Eingabe zur Erzeugung der vierstelligen




BCD-Zahlen "1234" so aussehen: (W#)16#1234. Davon unberührt existiert nach

wie vor auch noch das BCD-Zahlenformat. Dafür gibt es entsprechende

Codeumsetzer, z.B. ITB (INTEGER nach BCD).

Zusammengesetzte Datentypen in Step7

In Step7 benutzt man neben den elementaren Datentypen auch noch die

zusammengesetzten Datentypen. Damit werden Datengruppen definiert, die

größer als 32 Bit sind. In Step7 kann man folgende zusammengesetzte

Datentypen definieren:

• DATE_AND_TIME, DT

• STRING

• ARRAY (Feld)

• STRUCT (Struktur)

• UDT (User Defined Data Typ, Anwenderdefinierte Datentypen)

• FB (Funktionsbaustein)

• SFB (Systemfunktionsbaustein)

Schlüsselwort Datentyp Beschreibung

DATE_AND_

TIME

DATE_AND_TIME definiert

einen Bereich mit 64 Bits

(8 Bytes) und wird in

einem binärcodierten

Dezimalformat

gespeichert.

DT#1990-1-1-0:0:0.0 bis

DT#2089-12-31-

23:59:59.999 (erlaubter

Bereich für die Eingabe von

Datum und Zeit)

ARRAY

Mit diesem Datentyp

definiert man ein Feld bzw.

eine

Messwerte: ARRAY[1...3]

OF INT; Jede

Feldkomponente wird über




Gruppierung von

Komponenten gleichen

Datentyps (entweder

elementar oder

zusammengesetzt). Man

kann maximal 6

Dimensionen in einem Feld

definieren.

den Feldindex

angesprochen:

L Messwerte [Index]

T Messwerte [Index]

Der Index kann ein

beliebiger ganzzahliger

Wert von -32768 bis

+32767 sein und kann zur

Laufzeit des Programms

nicht verändert werden.

Über SFC20 können ARRAY-

Variablen kopiert werden.

STRUCT

Mit dem Datentyp STRUCT

kann man eine

Gruppierung von beliebig

kombinierten Datentypen

bzw. Komponenten

definieren, z. B. ein Feld

aus Strukturen oder eine

Struktur aus Strukturen

und Feldern.

Messwerte:STRUCT

Temperatur: INT;

Geschwindigkeit: REAL;

END_STRUCT;

In AWL sind die

Komponenten einzeln

ansprechbar, z.B:

T Messwerte.

Geschwindigkeit

Über SFC20 können

STRUCT-Variablen kopiert

werden.




FB, SFB

Mit FB oder SFB wird die

Struktur des

zugeordneten

Instanzdatenbausteins

bestimmt.

Die Bestimmung der

Struktur ermöglicht die

Übergabe von Instanzdaten

für mehrere FB-Aufrufe

innerhalb eines

Instanzdatenbausteins.

UDT

User Defined Data Typ:

Durch die Verwendung von

UDTs ist es möglich große

Datenmengen zu

strukturieren.

Dies vereinfacht das

Eingeben von Datentypen

bei der Erzeugung von

Datenbausteinen und bei

der Deklaration von

Variablen. In Step7

können elementare

und zusammengesetzte

Datentypen verknüpft

werden. Dadurch

entstehen UDTs, die

einen eigenen Namen

haben und dadurch

mehrfach verwendbar

sind.

Ein UDT ist in allen

Bausteinen global gültig.

Ist vom Aufbau her wie ein

STRUCT.




Parametertypen in Step7

Im Step7 System werden aus elementaren und zusammengesetzten

Datentypen noch besondere Datentypen verwendet die man unter dem

Oberbegriff Parametertypen zusammenfasst.

Parametertypen in Step7 sind z.B. Bausteinparameter mit den

Datentypen BLOCK_FC, BLOCK_FB, BLOCK_DB und BLOCK_SDB,

dann Zeitgliederparameter und Zählerparameter mit den Datentypen

TIMER und COUNTER und sogenannte Zeiger mit den Datentypen

ANY und POINTER.

Mit Parametertypen werden Parameter definiert die an

Funktionsbausteine (FB) und Funktionen (FC) übergeben werden sollen.

BLOCK

BLOCK_FC, BLOCK_FB, BLOCK_DB und BLOCK_SDB: Der

Parametertyp BLOCK legt in Verbindung mit den Deklarationen den

Baustein fest der als Eingang oder Ausgang verwendet werden soll.

Durch die Deklaration von BLOCK wird die Bausteinart (FB, FC, DB,

SDB) bestimmt die benutzt wird.

TIMER / COUNTER

Mit den Parametertypen TIMER oder COUNTER wird eine bestimmte Zeit

oder ein bestimmter Zähler festgelegt, der bei der Bearbeitung




verwendet werden soll. Versorgt man einen Formalparameter vom

Parametertyp TIMER bzw. COUNTER, muss der zugehörige

Aktualparameter als Zeit oder Zähler definiert sein. Dies erreicht man

durch ein vorangestelltes "T" für TIMER oder "Z" für COUNTER denen

eine positive Ganzzahl folgt.

ANY

Den Datentyp ANY verwendet man wenn der Datentyp eines

Aktualparameters unbekannt ist oder wenn ein beliebiger Datentyp

eingesetzt werden kann. In Step7 ist eine Variable vom Datentyp ANY

80 Bits lang. Deshalb kann ANY nicht in AWL-Anweisungen verwendet

werden weil er die Akkubreite von 32 Bits übersteigt. Ordnet man ANY

Aktualparameter zu, wird in Step7 die Startadresse, der Datentyp und

die Länge des Aktualparameters in diesen 80 Bits codiert. Diese 80

Datenbits werden durch den aufgerufenen Baustein analysiert. Dadurch

erhält man die Informationen die für die weitere Bearbeitung verwendet

werden sollen.

Deklariert man einen Formalparameter für den Datentyp ANY, kann

diesem Formalparameter ein Aktualparameter mit beliebigem Datentyp

zugeordnet werden. Aktualparametern können in Step7® folgende

Datentypen zugeordnet werden:

• mit elementaren Datentypen gibt man die absolute Adresse

oder den symbolischen Namen eines Aktualparameters an

• mit zusammengesetzten Datentypen gibt man den

symbolischen Namen von Daten mit zusammengesetzten

Datentyp wie Feldern und Strukturen an

• TIMER, COUNTER und Bausteine durch angeben der Nummer wie




T10, Z12 oder FB1.

Einem Parameter vom Typ ANY können aber nicht nur individuelle

Operanden wie zum Beispiel Merkerwörter (MW) zugeordnet werden.

Man kann mit ANY auch Datenbereiche angeben. Aktualparameter, die

einem Datenbereich zugeordnet sind, werden im Format einer

Konstanten übergeben welche die zu übergebenden Datenmengen

enthält. Dieses Format hat dann folgende Form:

Mit dem Element Datentyp können alle elementaren Datentypen und

der Datentyp DATE AND TIME angegeben werden. Werden im

Datentypen keine Booleschen Variablen übergeben so muss die

Bitadresse mit 0 (x.0) angegeben werden.

Beispiele für das Format zur Angabe von Speicherbereichen für die

Übergabe an einen Parameter vom Typ ANY:




Zuordnungstabelle - Eine Steuerung mit einer Zuordnungsliste planen

Für die Erstellung eines Steuerungsprogramms ist insbesondere die

Planungsphase wichtig. Die Planung eines SPS-Programms

unterscheidet sich gegenüber den Verbindungsprogrammierten

Steuerungen. Auch ist die Dokumentation eine andere.

Wichtig ist eine klare Aufgabenstellung sowie Hilfsmittel, um diese

Aufgabe lösen zu können. Zu den Hilfsmitteln gehören z.B.

Schaltwerttabellen, Schaltfunktionen, KV-Diagramme,

Zustandsdiagramme, Technologieschemen oder Funktionspläne. Ein

weiteres Hilfsmittel sind Zuordnungstabellen, genannt auch als

Zuordnungsliste.

Dabei werden alle für die Steuerung der Anlage relevanten

Betriebsmittel, beispielsweise Taster, Schalter, Motoren etc. aufgelistet

und den Eingängen und Ausgängen zugeordnet. Daher der Name

Zuordnungstabelle oder Zuordnungsliste.

Die Zuordnung der Betriebsmittel zu den Ein- und Ausgängen sind

normalerweise frei wählbar. In der Zuordnungstabelle wird genau

festgelegt, welche Adresse für welches Betriebsmittel zugeordnet

werden soll. Zusätzlich beschreibt ein Kommentar die genaue Funktion

des Betriebsmittels, ob es sich um einen Öffner oder Schließer handelt

sowie den Datentyp. So erhält man einen genauen Überblick über alle

verwendeten Adressen, Eingängen und Ausgängen.

Je nach Vorlieben kann die Kurzform oder die ausführliche Form




verwendet werden. Beispiel für eine Kurzform für eine Anlage mit den

Eingängen S1, S2, S3 und den Ausgängen H1 und H2.

Zuordnungstabelle in Kurzform

Es gibt auch die Möglichkeit, die Zuordnungstabelle ausführlich zu gestalten. Dazu

wieder ein Beispiel mit denselben Betriebsmitteln.

Zuordnungstabelle in Langform

Wie Sie sehen, erhält der Programmierer auf diese Art und Weise einen genauen

Überblick. Die Zuordnungstabelle dient als Grundlage für die Planung der

Steuerung sowie für die Deklaration der Variablen in Funktionen oder

Funktionsbausteinen und die Symboltabelle.




Symboliktabelle - Die symbolische Adressierung

Die Zuordnungstabelle dient dem Programmierer bei der Planung als Grundlage

für die Steuerung einer Anlage. So erhält er die Übersicht über alle verwendeten

Betriebsmittel und Operanden.

Der Programmierer kann das Programm in Step7 mit den absoluten

Adressen, z.B. E0.1, A0.1 etc. programmieren. In diesem Fall spricht

man von absoluter Adressierung.

Diese Art der Programmerstellung ist jedoch unübersichtlich. Besonders

bei großen Programmen, in den viele Ein- und Ausgänge zu adressieren

sind, geht schnell die Übersichtlichkeit verloren. Man muss evtl. ständig

in der Zuordnungstabelle nachschauen, welche Operanden welchen

Betriebsmitteln zugeordnet wurden.

In einem SPS-Projekt kann für einen Operanden aus Gründen der

besseren Verständlichkeit des Programms ein Symbol eingeführt und

beliebiger Datentyp vergeben werden, solange die Datengröße des

Operanden dafür passend ist. Für den Programmierer ist ein

symbolischer Name wie beispielsweise "Start-Taster" viel sprechender

als z.B. die Adresse E0.1. Daher sollte man sich von Anfang an daran

gewöhnen, mit symbolischen Namen zu programmieren.

Die symbolischen Namen werden in Step7 in der Symboltabelle

gepflegt. Markieren Sie den Knoten und öffnen Sie die Symboltabelle

mit einem Doppelklick auf Symbole.




Symboleditor

Der Symboleditor von Step7 wird geöffnet. In unserem Beispiel haben wir die

Symboltabelle für die Übungsaufgabe "Pumpensteuerung" erstellt. Neben dem

symbolischen Namen wird der Operand und der Datentyp festgelegt. Kommentare

sind optional und können bei Bedarf ebenso angelegt werden.

Symboltabelle in Step7

Symbolische Programmierung

Nun kann der Programmierer mit den symbolischen Namen programmieren. Auf

dem Bild ein Beispiel für die symbolische Programmierung.




Symbolische Programmierung

Sie sehen, dass es wesentlich einfacher ist zu erkennen, um welches

Betriebsmittel es sich jeweils handelt. Stellen Sie sich vor, statt Pumpe 2 würde

dort lediglich A4.2 stehen.




Codebausteine in Step7

Codebausteine in Step7 entsprechen den Programm-Organisationseinheiten POE.

Sie unterscheidet sich stark vom Bausteinkonzept der Norm EN 61131-3 ab und

jeder SPS-Programmierer sollte sie kennen.

In Codebausteinen ist das Anwenderprogramm enthalten. Zu den

Codebausteintypen gehören die Organisationsbausteine OB, die

Funktionsbausteine FB und SFB sowie die Funktionen FC und SFC. Die

zum Codebaustein gehörenden Daten werden in Datenbausteinen

gespeichert.

Die Organisationsbausteine, unter anderem auch OB1 in dem das

Programm bzw. die Programmstruktur vorhanden ist, werden vom

Betriebssystem aufgerufen. Alle anderen Codebausteine werden vom

Anwenderprogramm, insbesondere aus dem OB1 heraus, aufgerufen.

Man kann natürlich weitere Codebausteine aus einer Funktion oder

einem Funktionsbaustein heraus aufrufen. Es kommt ganz darauf an,

wie das Programm aufgebaut ist.

Im unteren Bild sehen Sie einen schematischen Aufbau eines

Beispielprogramms. Aus Vereinfachungsgründen haben wir auf den

Aufruf von Systemfunktionen SFC und Systemfunktionsbausteinen SFB

verzichtet. Diese können wie normale FC's und FB's aufgerufen werden.

Das Betriebssystem startet OB1. Falls irgendwelche besonderen

Ereignisse auftreten, unterbrechen andere OB's den Programmablauf in

OB1. Im OB1 wird zuerst FC1 aufgerufen.

Im FC1 wird wiederum FC2 aufgerufen und das Programm wird

abgearbeitet. Danach wird wieder zu FC1 zurückgekehrt. Als nächstes




wird im FC1 wieder ein Baustein aufgerufen. Diesmal FB1 mit dem

dazugehörigen DB1. Nachdem das Programm im FB1 abgearbeitet

wurde, wird wieder zu FC1 zurückgekehrt. Da die Abarbeitung im FC1

ebenfalls beendet ist, wird mit OB1 weitergemacht.

Als nächstes wird im OB1 der FB2 mit dem dazugehörigen DB2

aufgerufen. Nach der Abarbeitung des Programms im FB2 wird wieder

zu OB1 zurückgekehrt. Da das Programm im OB1 zu Ende ist, wird

wieder von vorne begonnen.

Auf Gobaldatenbausteine können von allen Codebausteinen aus

zugegriffen werden. In unserem Beispiel greifen FB1 und FB2 auf die

Daten im Globaldatenbaustein zu.

Schematische Darstellung einer Programmstruktur mit Codebausteinen und

Datenbausteinen




Organisationsbausteine OB in S7

n der Norm EN 61131-3 sind Tasks vorgesehen. Diese werden in Step7 in Form

von Organisationsbausteinen bereitgestellt und sind die Schnittstelle zwischen

dem Betriebssystem und dem Anwenderprogramm. Sie werden ausschließlich vom

bei bestimmten Ereignissen vom Betriebssystem gestartet. Sie können zwar nicht

vom Anwenderprogramm gestartet werden, man kann jedoch unter bestimmten

Bedingungen vom Anwenderprogramm aus das Betriebssystem antriggern, ein

Organisationsbaustein aufzurufen und abzuarbeiten.

Im OB1 befindet sich das Anwenderprogramm bzw. wird hier der Aufruf

weiterer Funktionen oder Funktionsbausteine veranlasst. Solange keine

besonderen Ereignisse oder Störungen auftreten, wird der

Organisationsbaustein OB1 zyklisch abgearbeitet. Damit der OB1 bei

Störungen die Abarbeitung unterbricht, sind Organisationsbausteine

nach Prioritäten kategorisiert.

Die OB's mit höherer Priorität stoppen die OB's mit der niedrigeren

Priorität und arbeiten ihr eigenes Programm ab. Sobald ein OB mit der

höheren Priorität das Programm abgearbeitet hat, wird mit der

Abarbeitung des OB mit der niedrigeren Priorität fortgesetzt. OB1 hat,

bis auf den OB90, die niedrigste Priorität mit 1 und demzufolge kann

fast (außer OB90) jeder andere OB die Abarbeitung im OB1 stoppen.

Die höchste Priorität bei den OB's hat OB122 mit der Priorität 29, wobei

die verfügbaren OB's von der CPU abhängig sind. Einige CPU's haben

beispielsweise als höchste OB nur OB100. Die Prioritäten sind

voreingestellt und bei einigen OB's können sie innerhalb bestimmter

Grenzen geändert, bei manchen nicht geändert werden. Die OB's

können entweder aus der Bibliothek genommen oder selbst erstellt

werden.




Nachfolgend eine Auflistung über alle OB's mit Beschreibung und der

Priorität:

Bausteinart BausteinBeschreibung und

EreignisPriorität

Anwenderprogramm OB1

Bearbeitung des

Anwenderprogramms nach

Wiederanlauf (Ende von

OB100) und am Zyklusende.

1

Uhrzeitalarm

OB10

OB11

OB12

OB13

OB14

OB15

OB16

OB17

Uhrzeit und Datum. Zu

einem bestimmten Zeitpunkt

kann angetriggert werden,

dass ein Uhrzeit OB (10 -

17) aufgerufen wird, der

dann ein Programm

abarbeitet. Wird auch

Uhrzeitalarm OB genannt.

2

2

2

2

2

2

2

2

Verzögerungsalarm

OB20

OB21

OB22

OB23

Verzögerungsalarme. Nach

einer Verzögerungszeit wird

der OB (20 - 23) aufgerufen

und das Programm wird

abgearbeitet.

3

4

5

6

Weckalarm OB30

OB31

OB32

OB33

OB34

OB35

OB36

OB37

Weckalarme, starten

periodisch nach einer

definierten Zeit. Ähnlich wie

Taktsignale, jedoch

wesentlich genauer.

Außerdem wird die

Bearbeitung des OB1 dabei

unterbrochen, da sie eine

7

8

9

10

11

12

13

14




OB38 höhere Priorität haben. 15

Prozessalarm

OB40

OB41

OB42

OB43

OB44

OB45

OB46

OB47

Prozessalarme. Reagieren an

alarmfähigen Eingangs-,

Ausgangs- oder

Funktionsbaugruppen auf

parametrierte Ereignisse,

z.B. positive Flanke,

Grenzwertüberschreitung.

Werden z.B. eingesetzt,

wenn die Reaktionszeit im

Programm zu lang ist.

16

17

18

19

20

21

22

23

DPV1-Alarm

OB55

OB56

OB57

DPV1-Alarme. In Verbindung

mit DPV1-Slaves werden

Status-, Update- oder

herstellerspezifische Alarme

ausgelöst.

2

2

2

Multicomputingalarm OB60Synchroner Betrieb mehrerer

CPU's25

Taktsynchronalarm

OB61

OB62

OB63

OB64

Kurze und gleichlange

Prozessreaktionszeiten am

Profibus-DP projektieren

25

25

25

25

RedundanzfehlerOB70

OB72Fehlerbearbeitung

25

28Asynchrone Fehler OB80

OB81

OB82

OB83

OB84

Zeitfehler, startet wenn OB1

eine definierte Zykluszeit

überschreitet

Stromversorgungsfehler

Diagnosealarm

25 bzw.

28




OB85

OB86

OB87

Ziehen/Steckenalarm

Hardwarefehler

Programmablauffehler

Baugruppenträgerausfall

Kommunikationsfehler

Hintergrundzyklus OB90

Für die

Programmbearbeitung im

Hintergrund

0.29

Anlauf

OB100

OB101

OB102

Nach Neustart (Warmstart)

der CPU

Nach Wiederanlauf der CPU

Nach Kaltstart der CPU

27

27

27

Synchrone FehlerOB121

OB122

Wenn ein Baugruppenfehler

auftritt

Wenn ein Baugruppenfehler

auftritt

29

29




Uhrzeitalarm OB's - Organisationsbausteine OB10 bis

OB17

Systemseitig gibt es in S7 bereits bis zu 8 Organisationsbausteine, die

Uhrzeitalarme auslösen und die Bearbeitung von OB1 stoppen können. Das sind

OB10 bis OB17. Der Aufruf dieser OB's kann einmalig oder in einem bestimmten

Intervall geschehen. Die Parametrierung erfolgt entweder über Step7 oder über

Systemfunktionen SFC. Sie können den Aufruf der OB's für folgenden Intervall

parametrieren:

• Einmalig

• Minütlich

• Stündlich

• Täglich

• Wöchentlich

• Monatlich

• Jährlich

• Jeweils am Monatsende (Monatsletzter)

Achtung: Bei der Parametrierung "monatlich" können Probleme

auftreten, da ein Monat zwischen 28 und 31 Tage haben kann. Stellen

Sie den Uhrzeitalarm für beispielsweise monatlich am 31. des Monats,

würde der Uhrzeitalarm an Monaten mit 28 bis 30 Tagen nicht

aufgerufen werden. Daher dürfen der 29., 30. und 31. eines Monats

nicht gesetzt werden. Wenn Sie den Monatsende parametrieren wollen,

nehmen Sie die Einstellung "Monatsletzter".

Einstellen und Aktivieren der Uhrzeitalarme OB10-OB17




Sie können die Uhrzeitalarme auf 3 verschiedene Art und Weisen einstellen und

aktivieren.

• Einstellen und aktivieren direkt in Step7 über die

Hardwarekonfiguration

• Einstellen in Step7 über die Hardwarekonfiguration und aktivieren

durch Aufruf von SFC30 "ACT_TINT"

• Einstellen durch Aufruf von SFC28 "SET_TINT" und aktivieren

durch Aufruf von SFC30 "ACT_TINT"

Über die Hardwarekonfiguration

Öffnen Sie die Hardwarekonfiguration. Klicken Sie doppelt auf die CPU und

wechseln Sie in das Register Uhrzeitalarme. Hier können Sie die Uhrzeitalarme

einstellen und aktivieren. Setzen Sie den Haken unter "Aktiv", unter "Ausführung"

stellen Sie den Intervall ein. In die nächsten Felder schreiben Sie ein gültiges

Startdatum und die Uhrzeit.




Uhrzeitalarm in der Hardwarekonfiguration einstellen und aktivieren

Zwei Dinge fallen auf dieser Registerkarte auf. Die Uhrzeitalarme OB11

bis OB17 sind deaktiviert und können nicht aktiviert werden. Das liegt

daran, dass fast alle CPU's S7-300er Baureihe nur 1 Uhrzeitalarm zur

Verfügung stellen. Die S7-412 hat 2 Uhrzeitalarme. S7-414 bereits 4.




Wie viele Uhrzeitalarme zur Verfügung stehen, hängt ganz von der CPU

ab und die Anzahl der verfügbaren Uhrzeitalarme steht im Handbuch

der CPU.

Die Prioritäten sind alle auf 2 voreingestellt. Wenn mehrere

Uhrzeitalarme mit der selben Priorität vorhanden und eingestellt

wurden, wird die Reihenfolge durch die Startereignisse bestimmt. Die

Priorität ist bei den Uhrzeitalarmen ab der S7-400er Baureihe und bei

CPU318 innerhalb des Bereichs 2 bis 23 änderbar.

Einstellen über die Hardwarekonfiguration und

aktivieren über Aufruf von SFC30 "ACT_TINT".

Wenn Sie in der Hardwarekonfiguration den Haken bei "Aktiv" nicht

setzen, die restlichen Einstellungen jedoch belassen, dann ist der

Uhrzeitalarm zwar deaktiviert, jedoch eingestellt. In unserem

Beispiel würde das bedeuten, dass die Einstellung auf täglich um 5:00

Uhr gesetzt ist.

Die Aktivierung erfolgt dann im Programm durch den Aufruf von

SFC30 "ACT_TINT". Anbei ein Beispielprogramm wie OB10 aufgerufen

werden kann mit den Kommentaren hinter den Zeilen.

CALL "ACT_TINT" //Rufe SFC30 auf

OB_NR:=10 //SFC30 ruft OB10 auf

RET_VAL:=MW30 //Schreibe evtl. Fehlercodes in MW30 ein

NOP 0




Einstellen über SFC28 und Aktivieren über SFC30

Die dritte Möglichkeit einen Uhrzeitalarm einzustellen und zu aktivieren

ist über die Systemfunktionen SFC28 und SFC30. Hierbei wird nichts in

der Hardwarekonfiguration eingestellt.

Das Einstellen wird über den Aufruf und Parametrierung von SFC 28

"SET_TINT" realisiert. Ein Beispielprogramm:

CALL "SET_TINT" //Aufruf von SFC28

OB_Nr:=10 //SFC28 ruft OB10 auf

SDT:#zeitpunkt //Variable für Startdatum und Zeitpunkt vom Typ DT

PERIOD:W#16#1001 //Intervall täglich

RET_VAL:MW30 //Schreibe Fehlercodes in MW30

Die Aktivierung kann wieder über den Aufruf von SFC30 (wie gezeigt)

erfolgen. Wichtig ist, dass der Wert "Time of Day" nicht direkt am SDT-

Eingang erfolgt, sondern über eine Variable, die im aufrufenden

Baustein deklariert wird. Im rechts abgebildeten Beispiel haben wir die

Variable "Zeitpunkt" direkt im OB1 deklariert und vom Typ "Date and

Time" angegeben. Über die Funktion (in der Bibliothek zu finden) FC3

weisen wir der Variable das Datum und die Uhrzeit zu. Im nächsten

Netzwerk haben wir über SFC28 den Uhrzeitalarm OB10 eingestellt und

die Variable "zeitpunkt" am SDT-Eingang zugewiesen. Mit SFC30 wurde

der Uhrzeitalarm OB10 aktiviert und arbeitet zum angegebenen

Zeitpunkt sein Programm ab, das wir separat im OB10 direkt erstellt

haben.




Beispielprogramm um ein Uhrzeitalarm mit SFC28 einzustellen

und mit SFC30 zu aktivieren




Uhrzeitalarm stornieren mit SFC29 "CAN_TINT"

Die Bearbeitung des Uhrzeitalarms kann durch SFC29 storniert werden.

Ein Beispielprogramm:

CALL "CAN_TINT"

OB_Nr:=10

RET_VAL:MW30

Abfragen des Uhrzeitalarms mit SFC31 "QRY_TINT"

Mit SFC31 kann der kann der Status des Uhrzeitalarms abgefragt

werden. Ein Beispielprogramm:

CALL "QRY_TINT" //Aufruf von SFC31

OB_Nr:=10 //Rufe Status von OB10 ab

RET_VAL:MW30 //Schreibe Fehlercodes in MW30

STATUS:MW40 //Schreibe Status in MW40

Status des Uhrzeitalarms

Bit 0=0, Uhrzeitalarm ist vom Betriebssystem freigegeben

Bit 1=0, neue Uhrzeitalarme werden nicht verworfen

Bit 2=0, Uhrzeitalarm ist nicht aktiviert oder ist abgelaufen

Bit 3=0, keine Bedeutung

Bit 4=0, Uhrzeitalarm-OB ist nicht geladen

Bit5=0, die Ausführung des Uhrzeitalarm-OB ist durch eine laufende

Testfunktion gesperrt.

Um das Programm im OB10 zu erstellen, öffnen Sie OB10 entweder

über die Bibliothek oder erstellen Sie OB10 manuell und schreiben das

Programm.




Verzögerungsalarm OB's, OB20, OB21, OB22,

OB23

In S7 gibt es systemseitig bis zu 4 Verzögerungsalarme, die unabhängig

von den Zeitfunktionen die Bearbeitung von OB1 stoppen und ein

anderes Programm nach Ablauf einer parametrierbaren Zeit abarbeiten

können. Diese sind OB20 bis OB23. Ob und wie viele

Verzögerungsalarme vorhanden sind, hängt von der jeweiligen CPU ab.

Die Anzahl der verfügbaren Verzögerungsalarme können Sie entweder

im Handbuch der CPU nachlesen oder über die Hardwarekonfiguration.

Öffnen Sie die Hardwarekonfiguration und danach die Eigenschaften der

CPU. Im Register Alarme sehen Sie, wie viele Verzögerungsalarme die

CPU besitzt sowie die Prioritätsklassen. Nicht verfügbare

Verzögerungsalarme sind im Eigenschaftsfenster deaktiviert. In

unserem Beispiel hat unsere CPU nur ein Verzögerungsalarm OB20 mit

der Prioritätsklasse 3. Bei einigen CPU's kann die Prioritätsklasse

innerhalb bestimmter Grenzen (2 bis 24) geändert werden.




In den Eigenschaften der CPU werden die Anzahl der

Verzögerungsalarme und die Priorität angezeigt

Verzögerungsalarme laufen nur im Betriebszustand RUN und können

bereits im Anlaufprogramm gestartet werden. Spätestens nach Ablauf

der Verzögerungszeit muss sich die CPU jedoch im RUN-Zustand




befinden. Befindet sich die CPU nicht im RUN-Zustand, wird mit dem

Aufruf des Verzögerungsalarm OB's gewartet bis die CPU im RUN-

Zustand ist. Beim Übergang in den RUN-Zustand werden

Verzögerungsalarme dann vor dem OB1 abgearbeitet, da dieser eine

höhere Priorität hat. Wenn andere OB's mit noch höherer Priorität

aufgerufen werden, so werden zuerst diese abgearbeitet

Der Aufruf eines Verzögerungsalarm OB's erfolgt durch den Aufruf von

SFC32 "SRT_DINT".

Der Aufruf des SFC32

Der SFC32 hat mehrere Parameter die zugewiesen werden müssen.




Diese sind wie folgt zu belegen.

Eingangsparameter

• OB_NR: Hier wird der Verzögerungs-OB angegeben, z.B. OB20.

• DTIME: Die Verzögerungszeit in ms (1 bis 60000) wird hier

angegeben, z.B. T#5000ms.

• SIGN: Ein Kennzeichen, das in der Startereignisinformation des

OB's beim Aufruf des Verzögerungsalarm-OB's erscheint, muss

hier angegeben werden, z.B. MW30.

Ausgangsparameter

• RET_VAL: Wenn während der Bearbeitung ein Fehler auftritt, wird

der Fehlercode in den Parameter geschrieben, z.B. in MW40.

Wenn die Verzögerungszeit abgelaufen ist, startet der

Verzögerungsalarm OB und arbeitet sein Programm ab. Die

Verzögerungszeit, die in ms angegeben wird, kann nach Ablauf immer

wieder neu gestartet werden. Größere Zeiten als 60000 ms können

realisiert werden, indem man im Verzögerungsalarm-OB einen Zähler

benutzt.

Der Aufruf von OB20 in AWL

CALL "SRT_DINT" //Aufruf von SFC32

OB_NR :=20 //Aufruf von OB20

DTIME :=T#5S //Verzögerungszeit

SIGN :=MW10 //Kennzeichen

RET_VAL:=MW30 //Adresse für Fehlercodes

NOP 0




Verzögerungsalarm stornieren mit SFC33 "CAN_DINT"

Mit SFC33 "CAN_DINT" kann die Bearbeitung eines Verzögerungsalarms

gestoppt, bzw. storniert werden. Der Verzögerungsalarm-OB wird

danach nicht mehr aufgerufen. Beim Aufruf von SFC33 muss bei

OB_NR die OB-Nummer angegeben werden, z.B. OB20 sowie bei

RET_VAL wieder eine Rückgabeadresse für Fehlercodes, z.B. MW40.

Verzögerungsalarm stornieren mit SFC33

Status des Verzögerungsalarms mit SFC34

"QRY_DINT" abfragen

Der Status eines Verzögerungsalarm-OB's kann mit SFC34 "QRY_DINT"

abgefragt werden. Neben der OB_NR und RET_VAL muss hier eine

Rückgabeadresse für den Status vom Datentyp WORD angegeben

werden, z.B. MW70. Hier kann der Status ausgewertet werden. Ist der

Rückgabewert von RET_VAL nicht 0, dann darf der Status nicht

ausgewertet werden da in diesem Fall ein Fehler vorliegt.




Den Status eines Verzögerungsalarm-

OB's mit SFC34 abfragen

Die Bedeutung des Status:

Bit 0=0: CPU ist im RUN

Bit 0=1: CPU ist im Anlauf

Bit 1=0: Interrupt ist freigegeben

Bit 1=1: Interrupt ist gesperrt durch Aufruf von SFC 39 "DIS_IRT"

Bit 2=0: Interrupt nicht aktiv oder abgelaufen

Bit 2=1: Interrupt aktiv

Bit 3= Ist immer 0

Bit 4=0: Der OB der bei OB_NR angegeben wurde existiert nicht

Bit 4=1: Der OB der bei OB_NR angegeben wurde ist geladen

Restlichen Bits= Sind alle auf 0 gesetzt




Weckalarm OB's, OB30, OB31, OB32, OB33,

OB34, OB35, OB36, OB37, OB38

Es gibt in S7 bis zu 9 Weckalarm-OB's, die wie die Verzögerungsalarme

unabhängig von den Zeitfunktionen die Bearbeitung von OB1 stoppen

können und ihr eigenes Programm abarbeiten. Das sind OB30 bis OB38.

Auch hierbei hängt von der eingesetzten CPU ab, ob und wie viele

Weckalarm-OB's zur Verfügung stehen. Um die Anzahl der Weckalarme

sowie die Priorität anzeigen zu lassen, öffnen Sie die

Hardwarekonfiguration. Im Register Weckalarme sehen Sie anhand der

aktivierten Weckalarme, wie viele in der aktuellen CPU vorhanden sind.

Bei manchen CPU's lässt sich die Prioritätsklasse innerhalb von 2 bis 24

ändern. In unserem Beispiel existiert nur ein Weckalarm OB35. Die

anderen Weckalarme sind deaktiviert. Hier lässt sich auch unter

Ausführung der Intervall in ms angeben, in dem der Weckalarm-OB

aufgerufen werden soll. In unserem Beispiel bedeutet das, dass alle 100

Millisekunden der OB35 vom Betriebssystem aufgerufen wird.




Anzeige der Weckalarme und der Priorität in den Eigenschaften

der CPU

Die Funktionsweise der Weckalarme sind demnach wie die eines

Taktsignals. In einem bestimmten Intervall wird die Abarbeitung von

OB1 unterbrochen und der Weckalarm-OB bearbeitet. Weckalarme sind




jedoch wesentlich genauer als Taktsignale über Taktmerker. Wenn es

also um die Genauigkeit ankommt, dann sollten immer Weckalarm-OB's

genommen werden. Außerdem wird bei einem Taktmerker die

Bearbeitung von OB1 nicht unterbrochen, da dafür kein anderer OB

aufgerufen wird, bei einem Weckalarm schon, da hierfür der

Weckalarm-OB aufgerufen wird und dieser eine höhere Priorität als OB1

hat.

Für den Aufruf eines Weckalarm-OB's benötigt man keine

Systemfunktion wie beim Uhrzeitalarm oder Verzögerungsalarm. Das

Betriebssystem ruft den Weckalarm-OB automatisch im vordefinierten

Intervall auf. Wichtig ist, dass der Weckalarm-OB sich überhaupt in der

CPU befindet. Dafür erstellt man den Weckalarm-OB manuell und lädt

ihn in die CPU. In unserem Beispiel haben wir OB35 erstellt und das

abgebildete Programm erstellt (UN A6.1 = A6.1).

Programm im Weckalarm OB35

Wenn wir die Ausführzeit auf 1000 ms stellen, dann würde der Ausgang

je 1 Sekunde ein Signal geben und 1 Sekunde kein Signal geben. Es ist




wichtig zu verstehen warum. Der OB35 wird jede Sekunde aufgerufen.

Man könnte auf die Idee kommen, dass der Ausgang jede Sekunde nur

einmal kurz flackern muss (ein Zyklus lang). Jedoch bleibt der Ausgang

1 Sekunde lang aktiv. Das ist deshalb so, weil der Ausgang nach der

Bearbeitung von OB35 so bleibt. Wenn wir unser Programm in

O E0.1

ON E0.1

=A6.1

ändern, dann sehen wir das genauer. Nach einer Sekunde würde A6.1

dauerhaft aktiv bleiben. Den Blinkeffekt im obigen Beispiel haben wir

nur durch die Invertierung von A6.1 erreicht. Deshalb war A6.1 für eine

Sekunde aktiv und für eine Sekunde inaktiv.

Weckalarme verzögern, sperren und freigeben

Die Bearbeitung von Weckalarmen kann verzögert, gesperrt und wieder

freigegeben werden. Dies erfolgt mit den Systemfunktionen SFC39 bis

SFC42.




Verzögern, sperren und freigeben von Weckalarmen mit

SFC39 - SFC42

Weckalarm sperren erfolgt über SFC39 "DIS_IRT". Die Parameter von

DIS_IRT müssen wie folgt belegt werden:

• OB_NR: Der Weckalarm-OB, der gesperrt werden soll.

• MODE: Der Sperrmodus in Byte.

• Mode 0: Sperren aller Alarme, Registrierung im

Diagnosebuffer.

• Mode 1: Sperren der Alarmgruppe. Zehnerstelle des

Parameters unter OB_NR. In unserem Beispiel Sperren von

OB30 bis OB38.

• Mode 2: Nur OB sperren der unter OB_NR angegeben ist.

• Mode 80, 81, 82: Sperren aller Alarme, jedoch ohne

Registrierung im Diagnosebuffer.




• RET_VAL: Rückgabeadresse für Fehlercodes.

Gesperrte Alarme können mit SFC40 "EN_IRT" wieder freigegeben

werden. Die Parameter sind wie beim SFC39 anzugeben, nur mit dem

Unterschied dass hier festgelegt wird wie und welche Weckalarm-OB's

freigegeben werden sollen.

Mit SFC41 "DIS_AIRT" werden Alarme verzögert und mit SFC41

"EN_AIRT" werden verzögerte Alarme wieder freigegeben. Hier wird nur

die Rückgabeadresse für Fehlercodes benötigt.




Prozessalarm OB's, OB40, OB41, OB42, OB43,

OB44, OB45, OB46, OB47

Bis zu 8 Prozessalarme können in S7 vorhanden sein. Das sind OB40 bis

OB47. Auch hier gilt, dass die Anzahl der verfügbaren Prozessalarme

von der CPU abhängen. In der Hardwarekonfiguration können Sie die

Anzahl der Prozessalarme im Register Alarme anzeigen lassen.




Anzeige über Anzahl und Priorität der Prozessalarme in den

Eigenschaften der CPU

In unserer Beispiel-CPU 315 ist nur ein Prozessalarm OB40 verfügbar

und die nicht verfügbaren Prozessalarme sind deaktiviert. Die Priorität

ist voreingestellt zwischen 16 und 23. Bei einigen CPU's lässt sich die




Priorität innerhalb von 2 bis 24 ändern. Die CPU 318-2 DP besitzt 2

Prozessalarme (OB40, OB41). Bei den S7-400 bis zu 8 Prozessalarme

(OB40 - OB47).

Prozessalarme werden in folgenden Situationen gebraucht. Die

Reaktionszeit in einem laufenden Programmzyklus kann unter

Umständen zu gering sein. Das kann z.B passieren wenn bestimmte

Ereignisse nicht lang genug anstehen. In diesen Fällen muss schneller

reagiert und je nach Ereignis ein angepasstes Programm abgearbeitet

werden. In solchen Fällen werden Prozessalarme benötigt, die vom

Betriebssystem aufgerufen werden und ihr eigenes Programm

abarbeiten. Um Prozessalarme aufrufen zu können, müssen die

Analogeingabe-, Digitaleingabe- und Funktionsbaugruppen

prozessalarmfähig sein.

Wenn während der Programmbearbeitung ein alarmauslösendes

Ereignis, dann wird der Prozessalarm automatisch aufgerufen. Die

Organisationsbausteine mit der niedrigeren Priorität werden gestoppt.

In den temporären Lokaldaten des Prozessalarms kann das

alarmauslösende Ereignis ausgewertet werden. Ist kein Prozessalarm

vorhanden, geht die CPU in den STOP-Modus.

Die Zeit, in der ab Auftreten des Alarms die erste Anweisung im Alarm-

OB bearbeitet wird, nennt man Alarmreaktionszeit. Wenn mehrere

Alarm-OB's aufgerufen werden, verlängert sich die Alarmreaktionszeit

der niedriger priorisierten Alarm-OB's.

Aktiviert und eingestellt wird der Prozessalarm bei alarmfähigen

Baugruppen in den Eigenschaften über die Hardwarekonfiguration. Hier

können Sie den Prozessalarm aktivieren und festlegen, bei welchen

Ereignissen der Prozessalarm ausgelöst werden soll. Auf dem




Beispielbild wurde die Eingangsbaugruppe so eingestellt, dass bei einer

positiven Flanke am Kanal 0 der Prozessalarm ausgelöst wird.

Prozessalarm an alarmfähiger Eingangsbaugruppe aktivieren

Bei Analogeingabebaugruppen kann z.B. ein oberer und unterer

Grenzwert angegeben werden. Werden die Grenzwerte über- oder

unterschritten, würde ein Prozessalarm ausgelöst werden. Mit den

Systemfunktionen SFC55 "WR_PARM", SFC56 "WR_DPARM" und SFC57

"PARM_MOD" kann die Parametrierung auch im laufenden

Programmzyklus erfolgen. Diese sind jedoch über Profinet IO nicht




einsetzbar. Im Register Adresse geben Sie an, welcher OB beim Eintritt

eines Prozessalarms aufgerufen soll. Standardmäßig ist OB40

voreingestellt. Natürlich muss der Prozessalarm-OB sich im Falle eines

Aufrufs im CPU-Programm befinden. Befindet sich der OB beim Aufruf

nicht im CPU-Pro

Prozessalarme verzögern, sperren und wieder

freigeben

Prozessalarme können wie unter Weckalarme gezeigt, mit den

Systemfunktionen SFC 39 "DIS_IRT", SFC 40 "EN_IRT", SFC 41

"DIS_AIRT" und SFC 42 "EN_AIRT" verzögert, gesperrt und wieder

freigegeben werden.




DPV1-Alarme - Updatealarm, Statusalarm,

herstellerspezifischer Alarm

Zu den DPV1-Alarmen zählen Updatealarme, Statusalarme und

herstellerspezifische Alarme. Diese sind nur bei DPV1-fähigen CPU's

vorhanden und werden in Verbindung mit Profibus DPV1-Slaves

verwendet. Sofern der Slave damit ausgestattet ist, können über einen

DPV1-Alarm die Organisationsbausteine OB55, OB56 und OB57

aufgerufen werden. Parametriert werden DPV1-Alarme über die

Hardwarekonfiguration in den CPU-Eigenschaften im Register Alarme.




Parametrierung der DPV1-Alarme in den CPU-Eigenschaften

Für jeden DPV1-Alarm muss im Register Speicher mindestens 20 Bytes

Lokaldaten reserviert werden.

• OB55: Statusalarm. Wird z.B. aufgerufen, wenn der DPV1-Slave

seinen Status, Betriebszustand ändert (von RUN auf STOP). Bei

welchen Ereignissen ein Statusalarm ausgelöst wird, muss aus der

Dokumentation des DPV1-Slaves entnommen werden.

• OB56: Update-Alarm. Wird aufgerufen, wenn der DPV1-Slave

aktualisiert wurde, z.B. über direkte Parametrierung oder über




Profibus. Auch hier muss der Dokumentation des DPV1-Slaves

entnommen werden, bei welchen Ereignissen ein Updatealarm

ausgelöst wird.

• OB57: Herstellerspezifischer Alarm. Dieser Alarm wird

aufgerufen, wenn ein vom Hersteller spezifiziertes Ereignis am

DPV1-Slave auftritt.

DPV1-Alarme werden nur im Betriebszustand RUN bearbeitet. Auch hier

gilt, dass für den Fall dass ein DPV1-Alarm auftritt, die

Organisationsbausteine in der CPU vorhanden sein müssen. Sind die

Organisationsbausteine nicht vorhanden, wird die asynchrone

Fehlerbearbeitung über OB85 (Programmablauffehler) aufgerufen, die

CPU geht in den STOP-Modus und schreibt eine Meldung in den

Diagnosepuffer. Wenn ein DPV1-Alarm während des Anlaufs auftritt,

wird eine Meldung im Diagnosepuffer und in die

Baugruppenzustandsdaten eingetragen. Im Alarm-OB kann abgefragt

werden, welcher DPV1-Slave den Alarm ausgelöst hat. In den Bytes 5, 6

und 7 stehen in den Startinformationen die Anfangsadressen der

jeweiligen Baugruppen. In den Bytes 8 bis 11 werden weitere

Informationen wie z.B. die Kennung oder der Alarmtyp eingetragen. Die

Zusatzinformationen werden mit SFB54 RALRM ausgewertet.

DPV1-Alarme verzögern, sperren und freigeben

Auch DPV1-Alarme können mit den Systemfunktionen SFC 39

"DIS_IRT", SFC 40 "EN_IRT", SFC 41 "DIS_AIRT" und SFC 42

"EN_AIRT" verzögert, gesperrt und freigegeben werden.

DPV1 resultiert aus der Weiterentwicklung der Norm EN 50170 für




Dezentrale Peripherie. Daraus entstand die Norm IEC 61158/EN 50170,

Volume 2.




Funktion FC oder SFC

Funktionen werden oft mit dem Kürzel FC und bezeichnet. SFC sind

Systemfunktionen, die im Betriebssystem der CPU integriert sind.

Funktionen sind Unterprogramme, die in strukturierten Programmen

eine Teilaufgabe übernehmen und für immer wieder kehrende Aufgaben

eingesetzt werden können. Funktionen werden entweder von

Organisationsbausteinen (z.B. OB1) oder von anderen Funktionen oder

Funktionsbausteinen aufgerufen. Funktionen besitzen im Gegensatz zu

Funktionsbausteinen keinen Speicherbereich, die über den

Bausteinaufruf hinaus gültig sind. Nach der Bearbeitung der Funktion

gehen die lokalen Daten (z.B. Temperatur) verloren.

In Funktionen können z.B. Operanden natürlich direkt eingesetzt

werden, jedoch ist diese Methode nicht empfehlenswert und so auch

nicht vorgesehen. Im Idealfall werden Funktionen mit

Formalparametern parametriert. Erst beim Aufruf werden sie mit

Aktualparametern versorgt. Die Deklaration der Formalparameter

erfolgt im Deklarationsteil der Funktion. Hier werden lokale Variablen

definiert, die in der Funktion eingesetzt werden können. Erst beim

Aufruf des Bausteins werden die Variablen mit echten Werten versorgt.




Deklaration der Variablen mit Angabe des Datentyps

Dabei wird zwischen zwei Variablentypen unterschieden:

• Lokale Variablen

• Bausteininterne Lokalvariablen

Lokale Variablen

Zu den lokalen Variablen gehören die Bausteinparameter IN, OUT und

IN_OUT.

• IN: Hier werden Eingangsvariablen deklariert. Diese werden im

Baustein nur abgefragt.

• OUT: Hier werden die Ausgangsvariablen deklariert. Diese werden

nur beschrieben.

• IN_OUT: Am IN_OUT werden die Variablen deklariert, die sowohl

beschrieben als auch abgefragt werden können.




Programmerstellung mit Variablen im FC

Bausteininterne Lokalvariablen

Diese gehören nicht zu den Bausteinvariablen. Beim FC gibt es nur eine

bausteininterne Lokalvariable. Das ist TEMP und wird als interner

Speicher, z.B. zum Zwischenspeichern von Ergebnissen, benutzt. Sie

sind nur innerhalb eines Programmzyklus gültig, haben also keine

Gedächtnisfunktion.

Die Vorgehensweise beim Einsatz von Funktionen ist im Idealfall wie

folgt:

1. Deklaration der Variablen im Deklarationsteil

2. Erstellung des Programms mit Variablen




3. Aufruf der Funktion im Organisationsbaustein oder in einer

anderen Funktion oder Funktionsbaustein

4. Zuweisung von Aktualparameter (Operanden, Zeitwerte etc.)

Beim Aufruf des FC werden die

Aktualparameter zugewiesen

Der Rückgabewert RET_VAL im Deklarationsteil

m Deklarationsteil einer Funktion kann der Datentyp des Rückgabewerts

definiert werden. Bei den vielen Systemfunktionen oder auch

Organisationsbausteinen wie z.B. der Weckalarm OB10 wird der

Rückgabewert RET_VAL dafür benutzt, um Fehlercodes zu schreiben.

Diese können dann über die Variable RET_VAL ausgelesen werden. Bei

selbsterstellten Funktionen kann, muss aber nicht, ein Wert in RET_VAL

geschrieben werden. Soll kein Rückgabewert im RET_VAL geschrieben




werden, können Sie im Deklarationsteil beim RET_VAL den Datentyp auf

Void setzen.

Funktionen können über Codebausteine aufgerufen werden und erhalten

auf diese Art und Weise als Ergebnis einen Rückgabewert, sozusagen als

Antwort auf den Funktionsaufruf. Neben dem RET_VAL sind natürlich

noch weitere Ausgänge deklarierbar. Die Norm EN 61131-3 sieht jedoch

vor, dass nur der Rückgabewert an den aufrufenden Codebaustein

übergeben wird. Wird der RET_VAL nicht genutzt, so muss zumindest

ein anderer Ausgang definiert werden. Wenn Funktionen oder

Funktionsbausteine z.B. über den ENO verkettet werden, dann wird

ebenfalls der RET_VAL für die Verkettung benutzt. In dem Fall braucht

man jedoch nichts deklarieren, das geschieht alles intern und

automatisch.

Freigabeeingang EN und Freigabeausgang ENO

Diese beiden Dinge wurden ausführlich unter Freigabeein- und -ausgang

EN und ENO beschrieben.

Systemfunktionen SFC

Im Betriebssystem sind bereits viele vordefinierte Funktionen

vorhanden, die für unterschiedliche Aufgaben eingesetzt werden

können. Sie befinden sich z.B. in den beiden Bibliotheksordnern

STDLIBS und Standard Library.




Funktionen in Step7 Bibliotheken

Sollte eine Funktion nicht direkt aus der Bibliothek per Drag and Drop im

Programm einfügbar sein (das betriff z.B. den Ordner stdlibs/builtin), dann gehen

Sie wie folgt vor. Öffnen Sie im Simatic Manager die Bibliotheken. Ziehen Sie die

Funktion in Ihr Projekt (unter Bausteine). Danach ist die Funktion je nach dem

was es ist im Ordner FC oder SFC verfügbar und kann per Drag and Drop in z.B.

OB1 gezogen werden.




Funktionsbausteine FB oder SFB in S7

Funktionsbausteine FB oder Systemfunktionsbausteine SFB sind wie die

Funktionen (FC, SFC) Unterprogramme. Sie können ebenfalls spezifische

Teilaufgaben übernehmen und man behält so die Übersichtlichkeit über sein

Programm. Es gibt jedoch Unterschiede zwischen Funktionen und

Funktionsbausteine.

FB's besitzen eine Gedächtnisfunktion. Während in FC's die Daten, die in

TEMP deklariert werden, nur für den Bausteinaufruf gültig sind,

besitzen FB's zusätzlich den bausteininternen Variablentypen STAT. Die

hier abgelegten Daten sind auch außerhalb des Bausteinaufrufs gültig.

So kann man z.B. die Umgebungstemperatur, Prüfwerte etc. in diesen

Datenbereich ablegen und jederzeit auslesen. Ansonsten haben FB's

genauso wie Funktionen die Deklarationstypen für lokale Variablen IN,

OUT und IN_OUT. FB's werden immer dann benutzt, wenn ein

speicherndes Verhalten der bausteininternen Variablen benötigt wird.

Die Variablendeklaration in FB's erfolgt genauso wie beim FC, nur mit

dem Unterschied dass hier der Deklarationstyp STAT hinzugekommen

ist. Bei Graph ist die Sache etwas anders. Da Schrittkettenprogramme

in Graph anders aufgebaut sind, befindet sich der Deklarationsteil an

einer anderen Stelle. Hinzu kommt, dass im Deklarationsteil einer

Schrittkette bereits viele vordefinierte Variablen vom Deklarationstyp

IN, OUT und STAT vorhanden sind. Eine Übersicht über die bereits

vorhandenen Variablen finden Sie unter Variablen in Graph.




Variablendeklaration in Graph

Man kann zusätzlich noch eigene Variablen definieren und diese auch




mit Anfangswerten versehen. Die Möglichkeit, Variablen mit

Anfangswerten zu versehen ist optional und bei FC's gibt es diese

Möglichkeit nicht.

Es gibt aber noch weitere Unterschiede zwischen FC's und FB's. Beim

Aufruf von einem FC müssen den deklarierten Variablen vom

Deklarationstyp IN, OUT und IN_OUT entsprechende Operanden oder

andere Variablen zugewiesen werden. Bei FB's können sie zugewiesen

werden, müssen es jedoch nicht. Wenn die Zuweisung nicht erfolgt,

werden genau die hier vorgegebenen Anfangswerte benutzt.

Instanzdatenbaustein für ein FB

Beim Aufruf eines FB's muss ein Instanzdatenbaustein (z.B. DB1)

angegeben werden. So wird dem FB beim Aufruf ein interner

Speicherbereich zugewiesen, in dem Daten abgelegt werden können.

Das Besondere dabei ist, dass dem FB für jeden Aufruf ein anderer

Datenbaustein angegeben werden kann. So kann der FB mehrmals

benutzt und bei jedem Aufruf mit unterschiedlichen Daten versorgt

werden.

Variablen in Graph

Schrittkettenprogramm in Graph werden immer in FB's erstellt und

besitzen den üblichen Deklarationsteil für Variablen. In S7 Graph sind

bereits viele vordefinierte Variablen vom Deklarationstyp IN, OUT und




STAT vorhanden. Diese können nicht gelöscht und auch nicht geändert

werden. Beim Bausteinaufruf können Sie diese wie selbst definierte

Variablen nutzen und Operanden (IN, OUT) oder sonstige Werten (STAT)

zuweisen. Achtung: Die vordefinierten Variablen können unterschiedlich

sein. Verantwortlich dafür ist die Einstellung im Graph unter EXTRAS -

BAUSTEINEINSTELLUNGEN. Hier können Sie über die

Optionsschaltflächen die FB Parameter einstellen.

In den Bausteineinstellungen können in Graph die FB

Parameter eingestellt werden

Je nachdem ob Sie Minimal, Standard, Maximal oder Anwenderdefiniert

auswählen, sind die FB Parameter vorhanden oder nicht. Bei allen Variablen vom

Typ Bool kann der Haken bei Ausschlussoperand oder Abbruchoperand gesetzt




werden. Das bedeutet, damit wird der Operand als Ausschluss- oder

Abbruchoperand für die Prozessdiagnose festgelegt. Die Bedeutung der Variablen

ist wie folgt festgelegt.

Vordefinierte Variablen vom Typ IN

• OFF_SQ: Mit diesem Operanden wird die Schrittkette ausgeschaltet.

Bedeutet Off Sequence.

• INIT_SQ: Bedeutet Initialize Sequence und damit wird die

Schrittkette in den Initialzustand versetzt.

• ACK_EF: Acknowledge Error Fault. Damit werden alle Störungen

und Fehler quittiert.

• REG_EF: Register Error Fault. Alle Störungen und Fehler werden

registriert.

• ACK_S: Acknowledge Error Fault Step. Den im S_NO angezeigten

Schritt quittieren.

• REG_S: Register Error Fault Step. Den im Schritt S_NO

angezeigten Schritt registrieren.

• HALT_SQ: Hold Sequence. Schrittkette sofort anhalten

(einfrieren).

• HALT_TIMES: Hold Times. Die Zeiten in der Schrittkette sofort

anhalten (einfrieren).

• ZERO_OP: Zero Operands. Alle Operanden, die mit N, L, D

zugewiesen wurden, sofort zurücksetzen.

• EN_IL: Enable Interlocks. Die Bearbeitung der Verriegelung

aktivieren.

• EN_SV: Enable Supervisions. Die Bearbeitung der Überwachung

aktivieren.




• EN_ACKREQ: Enable Acknowledgement Required. Die

Quittierpflicht aktivieren.

• EN_SSKIP: Enable Step Skipping. Überspringen eines Schritts

aktivieren.

• DISP_SACT: Display Active Steps. Nur die aktiven Schritte

anzeigen.

• DISP_SEF: Display Steps with Error Fault. Nur die Schritte die

fehlerhaft oder gestört sind anzeigen.

• DISP_SALL: Display All Steps. Alle Schritte anzeigen.

• S_PREV: Previous Step. Vorherigen Schritt im S_NO anzeigen.

• S_NEXT: Next Step. Nächsten Schritt im S_NO anzeigen.

• SW_AUTO: Switch to Automatic. Betriebsart auf Automatik

einstellen.

• SW_TAP: Switch to Transition and Push. Auf Tippbetrieb mit T

und T_PUSH einstellen.

• SW_TOP: Switch to Transition or Push. Auf Tippbetrieb mit T oder

T_PUSH einstellen.

• SW_MAN: Switch to Manual. Auf Handbetrieb einstellen.

• S_SEL: Step Select. Schritt zum Anzeigen in S_NO vorgeben.

• S_SELOK: Step Select OK. Den Wert in S_SEL für S_NO

übernehmen.

• S_ON: Step On. Den Schritt im S_NO aktivieren.

• S_OFF: Step Off. Den Schritt im S_NO deaktivieren.

• T_PREV: Previous Transition. Die vorherige Transition im T_NO

anzeigen.

• T_NEXT: Next Transition. Die nächste Transition im T_NO

anzeigen.

• T_PUSH: Push Transition. Die Schaltfreigabe für Transition bei




SW_TAP und SW_TOP.

Variablen in Graph vom Typ IN

Variablen vom Typ OUT

• S_NO: Step Number. Die Schrittnummer.

• S_MORE: More Steps. Weitere Schritte zum Anzeigen verfügbar

machen.




• S_ACTIVE: Step Active. Schritt S_NO aktiv setzen.

• S_TIME: Step Time. Aktivierungszeit des Schritts.

• S_TIMEOK: Step Time OK. Schrittaktivierungszeit fehlerfrei

setzen.

• S_CRITLOC: Step Criteria Interlock. Kriterienbits für

Verriegelung.

• S_CRITLOCERR: Step Criteria Interlock Last Error. Kriterienbits

für Verriegelung bei Ereignis L1.

• S_CRITSUP: Step Criteria Supervision. Kriterienbits für

Überwachung.

• S_STATE: Step State. Zustandsbits für Schritt.

• T_NO: Transition Number. Die Transitionsnummer.

• T_MORE: Weitere gültige Transitionen zum Anzeigen verfügbar

machen.

• T_CRIT: Transition Criteria. Kriterienbits für Transition.

• T_CRITOLD: Transition Criteria Last Cycle. Kriterienbits für

Transition vom letzten Zyklus.

• T_CRITFLT: Transition Criteria Last Fault. Kriterienbits für

Transition bei Ereignis V1.

• ERROR: Interlock Error. Sammelfehler für Verriegelungen.

• FAULT: Supervision Fault. Sammelfehler für Überwachungen.

• ERR_FLT: Interlock Error or Supervision Fault. Sammelfehler für

Verriegelungen oder Überwachungen.

• SQ_ISOFF: Sequence is Off. Kein aktiver Schritt. Schrittkette ist

ausgeschaltet.

• SQ_HALTED: Sequence is Hold. Schrittkette ist angehalten,

eingefroren.

• TM_HALTED: Times are Hold. Zeiten sind angehalten,




eingefroren.

• OP_ZEROED: Operands are Zeroed. Alle Operanden die mit L, N

oder D zugewiesen sind, sind genullt.

• IL_ENABLED: Interlocks Enabled. Die Verriegelungsbearbeitung

ist aktiviert.

• SV_ENABLED: Supervision Enabled. Die

Überwachungsbearbeitung ist aktiviert.

• ACKREQ_ENABLED: Acknowledgement Requirement is Enabled.

Die Quittierpflicht ist aktiviert.

• SSKIP_ENABLED: Step Skipping is Enabled. Schritt überspringen

ist aktiviert.

• SACT_DISP: Active Steps are Displayed. Nur aktive Schritte

anzeigen.

• SEF_DISP: Steps with Error Fault are Displayed. Nur Schritte die

fehlerhaft oder gestört sind anzeigen.

• SALL_DISP: All Steps are Displayed. Alle Schritte anzeigen.

• AUTO_ON: Automatic On. Automatik ist an.

• TAP_ON: Transition and Push On. Betriebsart SW_TAP

eingeschaltet.

• TOP_ON: Transition or Push On. Betriebsart SW_TOP

eingeschaltet.

• MAN_ON: Manual On. Betriebsart SW_MAN eingeschaltet.




Variablen vom Typ OUT in Graph

Variablen vom Typ STAT

• S_DISPLAY: Set Display Internal. Interne S_NO Anzeige.

• S_SEL_OLD: Set Selected Previous Value. Letzter S_SEL Wert.

• S_DISPIDX: Transition Display Index. Index der Transition, der in

T_NO angezeigt wird.




• MOP: Mode Of Operation. Die Betriebsart.

• TICKS: Time Ticks. Die Zeittakte.

• SQ_FLAGS: Sequence Flags. Die Schrittkettenmerker.

Variablen vom Typ STAT




Datenbausteine in SPS

In einem Datenbaustein werden anders als bei Codebausteinen keine

Programmcodes abgelegt sondern Daten. Als Daten kämen z.B. Stückzahlen,

Uhrzeiten, Namen der Fertigungsmitarbeiter und viele weitere Informationen in

Frage. Daher ist die Festlegung des Datentyps wichtig. Für Stückzahlen benötigt

man z.B. einen anderen Datentyp als für Namen, Zeit oder Datum. In den

Codebausteinen kann während des laufenden Betriebs auf diese gespeicherten

Daten zurückgegriffen werden.

Datenbausteine enthalten kein Programmteil, in den man wie z.B. in

AWL, FUP oder KOP Programmcode ablegt. Sie enthalten nur den

Deklarationsteil. Ein Datenbaustein lässt sich ähnlich wie ein

Codebaustein einfügen, indem man mit Rechtsklick auf den Knoten

Bausteine das Kontextmenü öffnet und dann über den Menüpunkt

Neues Objekt einfügen den Punkt Datenbaustein auswählt.

Einen Datenbausteine einfügen

Im nächsten Fenster werden die Einstellungen für den Datenbaustein eingegeben.




Einstellungen für den Datenbaustein

Insbesondere ist hier der Name des Datenbausteins wichtig. In

unserem Beispiel wurde der Name DB1 eingegeben. Über den Namen

und kann später der Datenbaustein ausgewählt und auf die Werte

zugegriffen werden. Es ist auch wichtig auszuwählen, ob der

Datenbaustein ein Globaldatenbaustein ist oder ein

Instanzdatenbaustein. Bei Typ ist die Option Instanzdatenbausteine erst

verfügbar, wenn zuerst ein Funktionsbaustein existiert. Denn ein

Instanzdatenbaustein ist der Datenbaustein für einen

Funktionsbaustein. Ist ein Funktionsbaustein vorhanden und wurde als

Typ Instanz-DB ausgewählt, kann, sofern mehrere Funktionsbausteine

vorhanden sind, der Funktionsbaustein ausgewählt werden, dem der

Datenbaustein zugeordnet werden soll.




Datenbausteine können auch mit symbolischen Namen und einem

Symbolkommentar versehen werden, z.B. Prüfdaten, Akustikwerte etc.

So kann bei symbolischer Programmierung mit den symbolischen

Namen gearbeitet werden. Denn, es ist einfacher symbolische Namen

wie z.B. den Datenbaustein "Prüfdaten" zu merken als beispielsweise

DB26.

Die Erstellsprache ist bei Datenbausteinen standardmäßig immer DB.

Projektpfad und Speicherort werden automatisch vergeben und können

nicht verändert werden. Zum Schluss kann der Datenbaustein mit

einem längeren Kommentar versehen werden. All diese Informationen

sind im Register Allgemein - Teil 1 verfügbar bzw. änderbar.

Register Allgemein Teil 2

Im Register Allgemein Teil 2 können noch weitere Einstellungen

vorgenommen werden. Insbesondere ist hier die Option Unlinked

wichtig.




Weitere Einstellungen im Register Allgemein Teil 2

Unlinked

Im Ladespeicher der CPU können mehrere Datenbausteine abgelegt

werden. Da der Arbeitsspeicher nur eine begrenzte Größe hat, ist es

sinnvoll, diese auch im Ladespeicher zu belassen und nur bei Bedarf in

den Arbeitsspeicher zu laden. Dafür müssen die Datenbausteine als

Unlinked projektiert und in die CPU geladen werden. Denn nur so

bleiben sie vorerst im Ladespeicher und werden nicht in den

Arbeitsspeicher geladen. So wird Platz im Arbeitsspeicher gespart. Wenn

im laufenden Betrieb die Inhalte dieser Datenbausteine benötigt

werden, können Sie mit den Systemfunktionen SFC20 "BLKMOV" oder

SFC83 "READ_DBL" in den Arbeitsspeicher transferiert werden. Danach




kann mit den Lade- und Transferbefehlen Daten in den Akku 1

transferiert werden, z.B. mit dem Befehl "L DB2.DBW2". Es ist auch

wichtig, dass der Datenbausteine zuerst in den Arbeitsspeicher geladen

wird. Wenn man versucht, Daten in den Akku 1 zu laden, ohne vorher

mit den Systemfunktionen in den Arbeitsspeicher zu laden, geht die CPU

in den STOP-Modus. Bei der quellorientierten Programmierung, z.B. in

AWL wird einem DB mit dem Schlüsselwort Unlinked zwischen

DATA_BLOCK_DB DB_NR und der STRUCT-Definition des DB diese

Eigenschaft zugewiesen.

DB ist schreibgeschützt in der AS

Der Datenbaustein wird im Automatisierungssystem schreibgeschützt

und kann durch den Programmablauf nicht geändert werden.

KNOW HOW Schutz

Ist die Option aktiviert, kann der Deklarationsteil nicht eingesehen

werden. Nur die Eigenschaften sichtbar.

Non-Retain

Damit wird das Remanenz-Verhalten des Datenbausteins festgelegt.

Damit diese Option wirkt, muss die CPU Retaineigenschaften von DB's

unterstützen. Ist die Option Non-Retain abgelegt, wird der

Datenbaustein nicht im Remanenzspeicher der CPU abgelegt und belegt

somit kein Platz im Remanenzspeicher. So würde der Datenbaustein

nach jedem Netz-AUS auf die Ladewerte zurückgesetzt.




Standard Baustein

Diese Option können nur Standardbausteine enthalten und vom

Programmierer nicht geändert werden.

Baustein schreibgeschützt

Der Baustein wird schreibgeschützt und kann nicht geändert werden.

Name (Header)

Der Header kann bis zu 8 Zeichen enthalten. Der Header wird in die

Quelle eingetragen. Dasselbe gilt für Familie und Autor.

Version

Ist die Bausteinversion nicht größer, wird beim Exportieren eine

Meldung angezeigt.

In den nächsten beiden Registern können die Aufrufe und Attribute

eingesehen werden.




Instanzdatenbausteine

Instanz-DB sind einem Funktionsbaustein FB direkt zugeordnet. Anders

als Global-DB kann auf Instanz-DB nur aus dem zugehörigen

Funktionsbaustein zugegriffen werden. Ein Instanz-DB ist sozusagen

das Gedächtnis des FB. Ob ein Datenbaustein als Globaldatenbaustein

oder Instanzdatenbaustein angelegt wird, wird bei der Erstellung des

Datenbausteins festgelegt. Damit ein Datenbaustein als Instanz-DB

angelegt wird, muss der Funktionsbaustein bereits existieren.

Wenn ein Instanzdatenbaustein geöffnet wird, können Sie über den

Menüpunkt ANSICHT zwischen Datensicht und Deklarationssicht

wechseln.

Datensicht im Instanzdatenbaustein

Der einzige Unterschied besteht hier, dass bei der Datensicht die

Aktualwerte eingesehen und geändert werden können. Ansonsten

können die Variablen und auch die Anfangswerte eines Instanz-DB nicht

deklariert bzw. geändert werden. Denn diese werden im dazugehörigen




Funktionsbaustein deklariert und geändert. Die Daten für die Variablen

werden dann im Instanz-DB gespeichert. Hierbei kann es zu

Inkonsistenzen kommen. Beispiel:

• Ein Funktionsbaustein FB1 wird erzeugt

• Die Variablen in FB1 werden deklariert

• Ein Instanzdatenbaustein DB1 wird erzeugt

• Die Variablendeklaration im FB1 wird geändert

In diesem Fall ist im FB1 eine andere, aktuellere Variablendeklaration

als im DB1. Die Lösung hier ist denkbar einfach. DB1 löschen und neu

erzeugen. Somit wäre die Variablendeklaration in beiden Bausteinen

wieder konsistent. Eine andere Möglichkeit ist, bei der Zuordnung des

Datenbausteins zu einem FB. Dabei wird erkannt, dass DB und FB

unterschiedliche Zeitstempel haben und man wird gefragt, ob der DB

neu generiert werden soll. Wenn auf ja geklickt wird, wird der DB neu

generiert.

Aktualwerte eines Instanz-DB

Die Aktualwerte eines Instanzdatenbausteins können Sie selbst

definieren. So haben Sie die Möglichkeit, für einen Funktionsbaustein

mehrere Instanzdatenbausteine anzulegen, diesen mehrfach aufzurufen

und dabei mit unterschiedlichen Aktualwerten zu versorgen.

Datenbaustein initialisieren

Die Aktualwerte können sich von den Anfangswerten unterscheiden, die

im Funktionsbaustein deklariert werden. Wenn die Aktualwerte auf die

Anfangswerte zurückgesetzt werden sollen, können Sie dies über den




Menüpunkt BEARBEITEN - DATENBAUSTEIN INITIALISIEREN

erreichen.




Globaldatenbausteine

Im Gegensatz zu Instanzdatenbausteinen können auf die Daten in

Globaldatenbausteinen von allen Codebausteinen aus zugegriffen

werden. Daher unterscheidet sich auch die Variablendeklaration von

Globaldatenbausteinen. Während man bei Instanz-DB nur die

Aktualwerte ändern kann, werden bei Global-DB die

Variablendeklaration sowie die Anfangswerte vom Programmierer im

Global-DB selbst festgelegt.

Nachdem Sie ein Datenbaustein vom Typ Global-DB erstellt haben,

können Sie es öffnen und parametrieren.

Globaldatenbaustein parametrieren

Pro Zeile sind mehrere Spalten zu füllen. Die erste Zeile dient als

Platzhalter und kann gelöscht, bzw. überschrieben werden. Die

einzelnen Spalten sind wie folgt zu füllen:

• Name: Der Name für die Variable.

• Typ: Der Datentyp (INT, BOOL etc.)

• Anfangswert: Der Anfangswert für die Variable

• Kommentar: Ein Kommentar für die Variable



Speicherprogrammierbare Steuerungen (SPS)...

Documents

Transcript of Speicherprogrammierbare Steuerungen (SPS)...