Skript DT WiSe21

Fachbereich VI - Informatik und Medien
Technische Informatik Bachelor

Prof. Dr.-Ing. Sven-Hendrik Voß
Digitaltechnik
(136028/9)
Skript zur Vorlesung
Autor: Prof. Dr. Sven-Hendrik Voß
12. Oktober 2021 - vollständige und korrigierte Version

Vorwort und Erläuterungen
Vorwort
Das vorliegende Skript dient als Grundlage für die Vorlesung Digitaltechnik“ im zweiten
”
Semester des Bachelor-Studiengangs Technische Informatik Embedded Systems“ an der
”
Berliner Hochschule für Technik. Es dient als Referenz für die in der Vorlesung behandelten
Themenbereiche, deckt aber nicht alle peripheren Themengebiete ab.
Es gilt zu beachten, dass das vorliegende Werk eine reine Vorlesungsausarbeitung darstellt,
kein Lehrbuch. Entsprechend ist es sprachlich eher knapp gehalten und inhaltlich sicher
an einigen Stellen weit weniger umfangreich als es ein entsprechendes Lehrbuch. Ich hoffe,
dass es trotzdem den Studierenden bei der Vor- und Nachbereitung des seminaristischen
Unterrichts, sowie der Prüfungsvorbereitung hilfreich sein wird. Es steht außer Frage, dass
dieses Skript keinesfalls den Vorlesungsbesuch ersetzt.
Dieses Skript stellt nur einen Teil der Unterlagen für die Vorlesung Digitaltechnik“ dar.
”
Zusätzlich werden Kopien der Folien aus der Vorlesung, sowie ausgewählte Dokumente
zum Labor (Aufgabenblätter, Datenblätter, Schaltpläne und Handbücher) zur Verfügung
gestellt. Vorlesung und Laborübungen sind aufeinander abgestimmt, wobei die praktischen
Übungen der Vertiefung des im Unterricht vermittelten Wissens dienen.
Im Labor werden kombinatorische und sequentielle Schaltungen entworfen, realisiert und
simuliert. Ferner werden die erzeugten Schaltungen synthetisiert und auf eine FPGA-
Hardware geladen. Als Entwicklungsumgebung werden ModelSim und Quartus II von
Altera verwendet. Die Handhabung der eingesetzten Software muss der Studierende mit
Eigenengagement bewerkstelligen. Die bereitgestellten Dokumente leisten einen helfenden
Beitrag dazu.
Zum Inhalt: Die Vorlesung Digitaltechnik“ baut inhaltlich auf der Veranstaltung Grund-
” ”
lagen digitaler Systeme“ auf. So wird empfohlen, die dort vermittelten Stoffinhalte vor
Teilnahme an dieser Veranstaltung zu wiederholen. Auch die empfohlene Fachliteratur ist
zur Vertiefung heranzuziehen.
Zur Form: Es hat sich im Sprachgebrauch etabliert, die englischen Fachbegriffe zu ver-
wenden. Teilweise macht eine deutsche Übersetzung keinen Sinn oder ist nicht möglich.
Sind deutsche Fachbegriffe vorhanden, so werden diese verwendet. Der englische Termino-
logie wird meist in Klammern ergänzt oder kursiv hervorgehoben. Das vorliegende Skript
basiert auf Fachliteratur und teilweise auf im Internet verfügbaren Unterlagen. Es ist
nicht möglich alle Quellen im Detail zu benennen. An dieser Stelle sei den Kollegen, Au-
toren und Helfern gedankt, die benannt oder unbenannt zum Gelingen dieses Skriptes
beigetragen haben.
Berliner Hochschule für Technik II Prof. Dr.-Ing. Sven-Hendrik Voß

Der Text dieses Skriptums wurde natürlich mit LATEX geschrieben. Eingesetzt wurde die
integrierte Benutzeroberfläche TeXmaker 4.0.3 mit MacTeX 2013 unter Mac OSX.
Verbesserungsvorschläge, Hinweise auf Fehler und jedwede qualifizierte Kritik sind herzlich
willkommen.
Berlin, im Oktober 2021 Sven-Hendrik Voß
Hinweis
Die Informationen in diesem Dokument werden ohne Rücksicht auf einen eventuellen Pa-
tentschutz veröffentlicht. Die erwähnten Soft- und Hardware-Bezeichnungen können auch
dann eingetragene Warenzeichen sein, wenn darauf nicht besonders hingewiesen wird. Sie
gehören den jeweiligen Warenzeicheninhabern und unterliegen gesetzlichen Bestimmun-
gen. Das Skript wurde mit größter Sorgfalt erstellt und korrigiert. Dennoch können Fehler
und Ungenauigkeiten nicht ausgeschlossen werden. Für fehlerhafte Angaben oder gar de-
ren Folgen wird keine juristische Verantwortung oder irgendeine Haftung übernommen.
Berliner Hochschule für Technik III Prof. Dr.-Ing. Sven-Hendrik Voß

Lehrinhalt und Lernziele
Das vorliegende Skript ergänzt die Vorlesung Digitaltechnik“. Ziel dieser Veranstaltung
”
ist die Vermittlung der grundlegenden Funktionsweise digitaler Schaltungen und deren
systematischer Entwurf.
Die algorithmische Vorgehensweisen bei der Hardware-Entwicklung und die Anwendung
adäquater Simulations- und Testverfahren stehen im Vordergrund. Damit sollen die Stu-
dierenden in die Lage versetzt werden eigenständig Hardware-Lösungen planen, realisie-
ren, optimieren und analysieren zu können.
Themenschwerpunkte sind:
• synchrone sequentielle Logik
• Automaten (Mealy und Moore)
• Entwurfsmethoden für synchrone sequentielle Logik
• Algorithmische Beschreibung komplexer digitaler Systeme
• Programmierbare Logik
• Rechnerunterstützter Schaltungsentwurf (VHDL)
• Hardware-Beschreibungssprache zur Simulation und Synthese von Hardware
Voraussetzungen
• Veranstaltung Grundlagen digitaler Systeme“
”
• Grundverständnis Logik
• Grundkenntnisse C/C++
• Grundverständnis E-Technik
• Freude an der Hardware
Berliner Hochschule für Technik IV Prof. Dr.-Ing. Sven-Hendrik Voß

Skripte, Bücher etc.
• Prof. Dr.-Ing. Sven-Hendrik Voß: Folien und Skript
• Jürgen Reichardt, Bernd Schwarz: VHDL-Synthese - Entwurf digitaler Schaltungen
und Systeme (Oldenbourg Verlag)
• Jürgen Reichardt: Lehrbuch Digitaltechnik (Oldenbourg Verlag München)
• Hans M. Lipp, Jürgen Becker: Grundlagen der Digitaltechnik (Oldenbourg)
• Johannes Borgmeyer: Grundlagen der Digitaltechnik (Carl Hanser Verlag
München/Wien)
• Roland Woitowitz, Klaus Urbanski: Digitaltechnik (Springer Verlag Berlin)
• Klaus Beuth: Digitaltechnik (Vogel Buchverlag Würzburg)
• Volnei A. Pedroni: Circuit Design with VHDL (MIT Press)
Berliner Hochschule für Technik V Prof. Dr.-Ing. Sven-Hendrik Voß

Inhaltsverzeichnis
Abbildungsverzeichnis X
Tabellenverzeichnis XI
1 Einführung 1
1.1 Übersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 Technische und mathematische Grundlagen . . . . . . . . . . . . . . . . . . 2
1.2.1 Gegenüberstellung von Analog- und Digitaltechnik . . . . . . . . . 2
1.2.2 Zahlensysteme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2.3 Komplementdarstellung . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2.4 Fehlererkennung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2.5 Elementare Logikverknüpfungen . . . . . . . . . . . . . . . . . . . . 8
2 Grundlagen der Digitaltechnik 11

2.1 Logische Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.1.1 Darstellung logischer Funktionen . . . . . . . . . . . . . . . . . . . 11
2.1.2 Vereinfachung logischer Funktionen . . . . . . . . . . . . . . . . . . 12
2.1.3 Beschreibung mit VHDL . . . . . . . . . . . . . . . . . . . . . . . . 13
2.2 Schaltnetze und Schaltwerke . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.3 Speicherelemente sequentieller Logik . . . . . . . . . . . . . . . . . . . . . 19
2.4 Zeitverhalten digitaler Schaltungen . . . . . . . . . . . . . . . . . . . . . . 24
2.5 Sequentielle Grundschaltungen . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.5.1 Schieberegister . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.5.2 Zählerschaltungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.5.3 Frequenzteiler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3 Systematischer Schaltungsentwurf 30
3.1 Synchrone sequentielle Schaltungen . . . . . . . . . . . . . . . . . . . . . . 30
3.1.1 Beschreibung mittels Zeitverlaufsdiagramm . . . . . . . . . . . . . . 31
3.1.2 Beschreibung mittels Zustandsübergangsdiagramm . . . . . . . . . 31
3.2 Schaltungsanalyse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
3.3 Schaltungsynthese . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.4 Endliche Automaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.4.1 Mealy Automat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.4.2 Moore Automat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
3.4.3 Medwedjew Automat . . . . . . . . . . . . . . . . . . . . . . . . . . 44
3.4.4 Entwurfsmethoden für Automaten . . . . . . . . . . . . . . . . . . . 48
4 Rechnergestützter Schaltungsentwurf mit VHDL 49

4.1 Einführung in VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4.1.1 Aufbau von VHDL Designs . . . . . . . . . . . . . . . . . . . . . . 50
4.1.2 Design Flow mit VHDL . . . . . . . . . . . . . . . . . . . . . . . . 51
4.1.3 Typologie und VHDL Operatoren . . . . . . . . . . . . . . . . . . . 53
VI
Inhaltsverzeichnis
4.2 Modellierungskonzepte im Architecture Entwurf . . . . . . . . . . . . . . . 56

4.2.1 Verhaltensbeschreibung durch Modellierung des Datenflusses . . . . 57
4.2.2 Verhaltensbeschreibungen durch Prozesse . . . . . . . . . . . . . . . 58
4.2.3 Strukturbeschreibung . . . . . . . . . . . . . . . . . . . . . . . . . . 65
4.3 Wiederverwendbarkeit und Effizienz in Designs . . . . . . . . . . . . . . . . 67
4.3.1 Generische Beschreibungen . . . . . . . . . . . . . . . . . . . . . . . 67
4.3.2 Generische Instanziierung von Komponenten . . . . . . . . . . . . . 69
4.3.3 Schleifen in VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
4.3.4 Eigene Datentypen und Arrays . . . . . . . . . . . . . . . . . . . . 72
4.4 Entwurf von Zustandsautomaten in VHDL . . . . . . . . . . . . . . . . . . 74
4.4.1 FSM Beschreibungsformen in VHDL . . . . . . . . . . . . . . . . . 74
4.4.2 Konvertierung von Automaten . . . . . . . . . . . . . . . . . . . . . 80
4.4.3 Optimierung von FSM Implementierungen . . . . . . . . . . . . . . 84
5 Simulation und Zeitverhalten im Digitalentwurf 89

5.1 Testbench-Entwurf für die Simulation . . . . . . . . . . . . . . . . . . . . . 89
5.2 Signalverzögerungen und Laufzeiteffekte . . . . . . . . . . . . . . . . . . . 91
5.3 Simulation von VHDL-Prozessen . . . . . . . . . . . . . . . . . . . . . . . 94
5.3.1 Simulationsablauf . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
5.3.2 Verzögerungsmodelle . . . . . . . . . . . . . . . . . . . . . . . . . . 96
6 Logikarchitekturen und Halbleitertechnologie 99

6.1 Programmierbare Speicher- und Logikbausteine . . . . . . . . . . . . . . . 99
6.1.1 Kombinatorische Logik mit PROM . . . . . . . . . . . . . . . . . . 102
6.1.2 Kombinatorische Logik mit PAL . . . . . . . . . . . . . . . . . . . . 104
6.1.3 Field Programmable Gate Arrays . . . . . . . . . . . . . . . . . . . 107
6.2 Halbleitertechnologie und Schaltungstechnik . . . . . . . . . . . . . . . . . 113
6.2.1 Digitale Schaltkreisfamilien . . . . . . . . . . . . . . . . . . . . . . 116
6.2.2 Metal Oxide Semiconductor (MOS) . . . . . . . . . . . . . . . . . . 118
6.2.3 Complementary MOS (CMOS) . . . . . . . . . . . . . . . . . . . . 120
6.2.4 CMOS Kennwerte . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
Literatur 129
Berliner Hochschule für Technik VII Prof. Dr.-Ing. Sven-Hendrik Voß

Abbildungsverzeichnis
2.1 Schaltbild der Beispielfunktion . . . . . . . . . . . . . . . . . . . . . . . . . 14

2.2 Analogie der Beschreibung in VHDL . . . . . . . . . . . . . . . . . . . . . 15
2.3 Schaltnetz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.4 Schaltwerk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.5 Gewinnung der Zustandsvariable . . . . . . . . . . . . . . . . . . . . . . . 19
2.6 RS-Latch aus NOR-Gattern . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.7 RS-Latch aus NAND-Gattern . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.8 Gated RS-Latch mit Schaltsymbol . . . . . . . . . . . . . . . . . . . . . . . 21
2.9 Gated D-Latch mit Schaltsymbol . . . . . . . . . . . . . . . . . . . . . . . 22
2.10 Flankendetektorschaltung für steigende und fallende Flanken . . . . . . . . 22
2.11 Verhalten von Latch und Flipflop in der Gegenüberstellung . . . . . . . . . 22
2.12 Flankengetriggerte Flipflops . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.13 JK-Flipflop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.14 Propagation Delay . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.15 Setup-Zeit und Haltezeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.16 Zusammenspiel der dynamischen Kenndaten . . . . . . . . . . . . . . . . . 25
2.17 Berechnung der maximalen Taktfrequenz aus dynamischen Kenndaten . . . 26
2.18 4-Bit-Schieberegister . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.19 Asynchroner 3-Bit Binärzähler . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.20 Synchroner 3-Bit Binärzähler . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.1 Allgemeiner Aufbau synchroner sequentieller Schaltungen . . . . . . . . . . 30

3.2 Typischer Zeitverlauf eines RS-Flipflops . . . . . . . . . . . . . . . . . . . . 31
3.3 Zustandsübergangsdiagramm eines RS-Flipflops . . . . . . . . . . . . . . . 31
3.4 Beispielschaltung für die Schaltungsanalyse . . . . . . . . . . . . . . . . . . 32
3.5 Beschriftung der Zustandsspeicher und Ausgänge . . . . . . . . . . . . . . 33
3.6 KV-Tafeln für die Schaltungsanalyse . . . . . . . . . . . . . . . . . . . . . 34
3.7 Zustandsgraph zur Schaltungsanalyse . . . . . . . . . . . . . . . . . . . . . 36
3.8 Zustandsgraph zur Schaltungssynthese . . . . . . . . . . . . . . . . . . . . 37
3.9 KV-Tafeln für die Schaltungssynthese . . . . . . . . . . . . . . . . . . . . . 39
3.10 Resultat der Schaltungssynthese als Schaltbild . . . . . . . . . . . . . . . . 40
3.11 Zeitverlaufsdiagramm zum Schaltungssynthesebeispiel . . . . . . . . . . . . 40
3.12 Mealy Automatenmodell . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.13 Modifiziertes Mealy Automatenmodell . . . . . . . . . . . . . . . . . . . . 42
3.14 Moore Automatenmodell . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
3.15 Unterschiede im Zeitverhalten zwischen Mealy und Moore . . . . . . . . . 43
3.16 Medwedjew Automatenmodell . . . . . . . . . . . . . . . . . . . . . . . . . 44
3.17 Zustandsgraph für Medwedjew-Automatenrealisierung . . . . . . . . . . . . 45
3.18 KV-Tafeln für den D-Eingang der Flipflops . . . . . . . . . . . . . . . . . . 46
3.19 Schaltbild für Medwedjew-Automatenrealisierung . . . . . . . . . . . . . . 47
3.20 Zeitverhalten des hergeleiteten Medwedjew-Automaten . . . . . . . . . . . 47
3.21 Graphischer FSM Entry . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
VIII
4.1 Hardware-Sicht eines VHDL Designs . . . . . . . . . . . . . . . . . . . . . 50

4.2 Design Flow mit VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
4.3 Netzliste nach Synthese . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
4.4 Schaltsymbol und Funktionstabelle eines 2:1-Multiplexers . . . . . . . . . . 57
4.5 Unterschied zwischen nebenläufigen und sequentiellen Anweisungen . . . . 59
4.6 Typische if-then-else“-Anweisung im Prozess . . . . . . . . . . . . . . . . 60
”
4.7 Syntheseergebnis des Prioritäts-Encoders . . . . . . . . . . . . . . . . . . . 61
4.8 Typische case“-Anweisung im Prozess . . . . . . . . . . . . . . . . . . . . 62
”
4.9 Syntheseergebnis des 2:1-Multiplexers . . . . . . . . . . . . . . . . . . . . . 63
4.10 Zeitverhalten in einem Prozess . . . . . . . . . . . . . . . . . . . . . . . . 65
4.11 Schaltung eines 3-Input AND aus mehreren 2-Input AND-Gattern . . . . . 66
4.12 Syntheseergebnis der 8-Bit AND-Schaltung . . . . . . . . . . . . . . . . . . 70
4.13 Array-Datentypen in VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . 73
4.14 Moore-Automat als Beispiel für die Beschreibung in VHDL . . . . . . . . . 74
4.15 FSM in Ein-Prozess Darstellung . . . . . . . . . . . . . . . . . . . . . . . . 75
4.16 Timing-Diagramm der Ein-Prozess Beschreibung . . . . . . . . . . . . . . . 76
4.17 Syntheseergebnis der Ein-Prozess Beschreibung . . . . . . . . . . . . . . . 76
4.18 Zustandsgraph des Syntheseergebnisses (Ein-Prozess Beschreibung) . . . . 77
4.19 FSM in Zwei-Prozess Darstellung . . . . . . . . . . . . . . . . . . . . . . . 77
4.20 Timing-Diagramm der Zwei-Prozess Beschreibung . . . . . . . . . . . . . . 78
4.21 Syntheseergebnis der Zwei-Prozess Beschreibung . . . . . . . . . . . . . . . 79
4.22 Zustandsgraph des Syntheseergebnisses (Zwei-Prozess Beschreibung) . . . . 79
4.23 FSM in Drei-Prozess Darstellung . . . . . . . . . . . . . . . . . . . . . . . 79
4.24 Konvertierter Mealy-Automat (links) und Vereinfachung (rechts) . . . . . . 82
4.25 Timing-Diagramm des Mealy-Automaten in Drei-Prozess Beschreibung . . 83
4.26 Syntheseergebnis der Mealy-Variante . . . . . . . . . . . . . . . . . . . . . 83
4.27 Zustandsgraph zur Mealy-Variante . . . . . . . . . . . . . . . . . . . . . . 84
4.28 Entkopplung von Zustandsautomaten durch Flipflops . . . . . . . . . . . . 84
4.29 Gebräuchliche Zustandscodierungen für eine gegebene FSM . . . . . . . . . 85
5.1 Schematische Darstellung einer Testbench . . . . . . . . . . . . . . . . . . 89

5.2 Beispielschaltung und zugehöriges KV-Diagramm für Race Conditions . . . 92
5.3 Auftretende Hazards bei der Beispielschaltung . . . . . . . . . . . . . . . . 93
5.4 Modifizierte Beispielschaltung mit eliminierten Race Conditions . . . . . . 93
5.5 Simulationsablauf in VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . 94
5.6 Beispielschaltung zur Analyse der Simulationsweise . . . . . . . . . . . . . 95
5.7 Unterschiede zwischen Inertial und Transport Delay Modell in der Simulation 97
5.8 Transaktionsliste für Signaländerungen in der Simulation . . . . . . . . . . 98
6.1 Prinzipieller Aufbau der PLDs . . . . . . . . . . . . . . . . . . . . . . . . . 100

6.2 PROM (Programmable Read Only Memory) . . . . . . . . . . . . . . . . . 102
6.3 Symbolische Darstellung eines 8x4 PROM . . . . . . . . . . . . . . . . . . 102
6.4 Paritätsgenerator als Implementierungsbeispiel für 8x4 PROM . . . . . . . 103
6.5 PAL (Programmable Array Logic Device) . . . . . . . . . . . . . . . . . . . 104
6.6 Symbolische Darstellung eines 9 x 20 x 4 PAL . . . . . . . . . . . . . . . . 104
6.7 Paritätsgenerator als Implementierungsbeispiel für 3x8x2 PAL . . . . . . . 105
6.8 Grundstruktur eines PAL (GAL) . . . . . . . . . . . . . . . . . . . . . . . 106
6.9 Prinzipieller Aufbau von FPGAs . . . . . . . . . . . . . . . . . . . . . . . . 107
Berliner Hochschule für Technik IX Prof. Dr.-Ing. Sven-Hendrik Voß

6.10 Aufbau eines Logic Elements . . . . . . . . . . . . . . . . . . . . . . . . . . 109

6.11 Aufbau eines Logic Array Blocks (LAB) . . . . . . . . . . . . . . . . . . . 110
6.12 Aufbau eines I/O Elements (IOE) . . . . . . . . . . . . . . . . . . . . . . . 111
6.13 Entwicklung in der Mikroelektronik . . . . . . . . . . . . . . . . . . . . . . 113
6.14 Schematischer Aufbau eines MOS-Transistors . . . . . . . . . . . . . . . . 118
6.15 Schaltzeichen eines MOS-Transistors . . . . . . . . . . . . . . . . . . . . . 119
6.16 Vereinfachtes Schaltzeichen eines MOS-Transistors . . . . . . . . . . . . . . 119
6.17 Aufbau und Charakterisierung eines NMOS Inverters . . . . . . . . . . . . 120
6.18 NOT-Gatter in CMOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
6.19 NAND-Gatter in CMOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
6.20 NOR-Gatter in CMOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
6.21 Transistor-Schalter-Analogie . . . . . . . . . . . . . . . . . . . . . . . . . . 124
6.22 CMOS Inverter in Schalterdarstellung . . . . . . . . . . . . . . . . . . . . . 124
6.23 Leistungsaufnahme aufgrund dynamischen Kurzschlußstroms . . . . . . . . 126
6.24 Fan-Out der Gatterausgänge . . . . . . . . . . . . . . . . . . . . . . . . . . 127
6.25 Noise Margin für den Low“- und High“-Signalbereich . . . . . . . . . . . 127
” ”
Berliner Hochschule für Technik X Prof. Dr.-Ing. Sven-Hendrik Voß

Tabellenverzeichnis
1.1 Darstellung der Wertigkeiten . . . . . . . . . . . . . . . . . . . . . . . . . . 1

1.2 Bitcodierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3 Umrechnung vom Dezimalsystem . . . . . . . . . . . . . . . . . . . . . . . 5
1.4 Binärcode mit Parity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.5 AND-Verknüpfung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.6 OR-Verknüpfung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.7 NAND-Verknüpfung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.8 NOR-Verknüpfung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.9 XOR-Verknüpfung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.10 XNOR-Verknüpfung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.1 Funktionstabelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.2 Wahrheitstabelle RS-Latch mit NOR-Gattern . . . . . . . . . . . . . . . . 20
2.3 Wahrheitstabelle RS-Latch mit NAND-Gattern . . . . . . . . . . . . . . . 21
2.4 Wahrheitstabelle Gated RS-Latch . . . . . . . . . . . . . . . . . . . . . . . 21
2.5 Anregungstabelle für die gängigen Flipfloptypen . . . . . . . . . . . . . . . 24
2.6 Zahlenwerte für ein Philips Dual D-Flipflop 74AHC74 . . . . . . . . . . . . 26
3.1 Zustandsfolgetabelle für die Schaltungsanalyse . . . . . . . . . . . . . . . . 34

3.2 Übergangstabelle des JK-Flipflops . . . . . . . . . . . . . . . . . . . . . . . 35
3.3 Vereinfachte Zustandsfolgetabelle für die Schaltungsanalyse . . . . . . . . . 35
3.4 Vereinfachte Zustandsfolgetabelle für die Schaltungssynthese . . . . . . . . 37
3.5 Zustandsfolgetabelle für die Schaltungssynthese . . . . . . . . . . . . . . . 38
3.6 Zustandsfolgetabelle für Medwedjew Zähler . . . . . . . . . . . . . . . . . . 45
3.7 Übergangstabelle des D-Flipflops . . . . . . . . . . . . . . . . . . . . . . . 46
4.1 Wertevorrat beim Datentyp std logic“ . . . . . . . . . . . . . . . . . . . . 54

”
4.2 Beschaltung des Multiplexers Selector0“ in Syntheseergebnis . . . . . . . . 76
”
4.3 Ursprüngliche Übergangs- / Ausgabetabelle des Moore-Automaten . . . . . 81
4.4 Konvertierte Übergangs- / Ausgabetabelle für Mealy-Automaten . . . . . . 82
5.1 Evaluierung der Gatter in Beispielschaltung . . . . . . . . . . . . . . . . . 95

5.2 Evaluierung der Gatter durch Delta-Zyklen . . . . . . . . . . . . . . . . . . 96
6.1 Bausteine zur Speicherung einer Tabelle (Programm) . . . . . . . . . . . . 100

6.2 Bausteine zur Speicherung einer Logikfunktion . . . . . . . . . . . . . . . . 101
6.3 Zusammenfassung zu PROM und PAL . . . . . . . . . . . . . . . . . . . . 106
6.4 Einordnung programmierbarer Hardware-Architekturen . . . . . . . . . . . 112
6.5 Integrationsdichte von integrierten Schaltungen . . . . . . . . . . . . . . . 115
6.6 Funktionstabelle des CMOS Inverters . . . . . . . . . . . . . . . . . . . . . 121
6.7 Funktionstabelle des CMOS NAND-Gatters . . . . . . . . . . . . . . . . . 122
6.8 Funktionstabelle des CMOS NOR-Gatters . . . . . . . . . . . . . . . . . . 123
XI
1 Einführung
1.1 Übersicht
Die Digitaltechnik ist heute ein Teilgebiet der Technischen Informatik, deren Aufgabe
es ist, Informationen zu verarbeiten und darzustellen. Über die letzten Jahrzehnte hat
dieses Gebiet immer mehr an Bedeutung gewonnen. Dies ist den wesentlichen Vorzügen
der Digitaltechnik zu verdanken, die es erlauben, sehr komplexe Systeme aufzubauen.
Das Grundkonzept besteht in der Verwendung eines eingeschränkten Zeichensatzes. Dafür
werden zwei Wertigkeiten verwendet, die je nach Verwendungsbereich in unterschiedlicher
Form dargestellt werden, wie in Tabelle 1.1 dargestellt.
Die in der Digitaltechnik übliche Repräsentationen in Form von 0“ und 1“ sind als Si-
” ”
gnalzustände mit entsprechend definierten Spannungspegeln zu verstehen. Diese können
in logischen Gattern mit stark nichtlinearem Übertragungsverhalten ohne Fehlerfortpflan-
zung übertragen werden. Letztlich wird dadurch eine relativ einfache physikalische Reali-
sierung ermöglicht, was der Digitaltechnik in den sechziger und siebziger Jahren letztlich
zum Durchbruch verholfen und die Verwendung von Halbleiter-Technologien zur Realisie-
rung von zigtausenden logischen Gattern auf einem Chip ermöglicht hat.
Anwendungsbereich Form
Digitaltechnik 0“ und 1“
” ”
Ausagenlogik wahr“ oder falsch“
” ”
Physik low“ oder high“
” ”
Tabelle 1.1: Darstellung der Wertigkeiten
Diese technische Entwicklung bildete schließlich die Grundlage für die Entwicklung und
Verwendung von Field Programmable Gate Arrays (FPGAs). FPGA sind integrierte elek-
tronische Bausteine, die durch Konfiguration beliebige digitale Schaltungen realisieren
können. Die Konfiguration1 erfolgt dabei auf der strukturellen Ebene durch eine anwen-
dungsspezifische Verschaltung der physikalisch auf dem FPGA vorhandenen Hardware-
elemente.
FPGAs haben durch ihr breites Anwendungsgebiet und ihre immer weiter steigende Inte-
grationsdichte die Welt der konfigurierbaren Logik bedeutend verändert. Moderne FPGAs
verfügen über sehr große Ressourcen von Logikgattern und RAM-Blöcken und ermöglichen
1
Oft wird im Zusammenhang mit FPGAs auch von Programmierung“ statt von Konfiguration“ gespro-
” ”
chen. Dies ist allerdings unpräzise bis falsch, da tatsächlich die Logik des FPGA durch den geschriebenen
Code konfiguriert und nicht programmiert wird. Daher wird in diesem Skript ausschließlich die korrekte
Terminologie des Konfigurierens“ benutzt.
”
1
KAPITEL 1. EINFÜHRUNG
somit auch sehr umfangreiche und komplexe Implementierungen. Für die Implementierung
effizienter FPGA-Designs ist es daher unumgänglich, die dazu gebräuchlichen Methoden
zu beherrschen.
Zur (textuellen) Beschreibung der Schaltungen werden sog. Hardwarebeschreibungsspra-
che (engl. Hardware Description Languages (HDL)) wie VHDL und Verilog genutzt. Für
die Verschaltung komplexerer Systeme setzt man mitunter auch graphische Entwicklungs-
werkzeuge (Matlab Simulink, Labview) und höhere Programmiersprachen (SystemC, Han-
delC, HLS) ein. Letztgenannte setzen jedoch eine etwas andere Herangehensweise und viel
Erfahrung und Kenntnisse in den Hardware-Compiler Methoden voraus, um effizient zu
arbeiten. Daher wird hier ausschließlich der klassische Entwurf mittels Hardwarebeschrei-
bungssprache anhand von VHDL behandelt. Bei VHDL handelt es sich um die in Europa
am weitesten verbreitete Sprache2 für den Hardware-Entwurf.
Der Entwurf digitaler Schaltungen, angefangen von simplen Grundschaltungen wie Zähler
oder Schieberegister bis hin zu komplexen Automaten fußt auf der Kenntnis elementarer
Methoden zur Schaltungsanalyse, -synthese und -beschreibung. Fundamentale Konzepte
zur Beherrschung großer Komplexität in Schaltungen wie die Automatentheorie sind da-
bei ebenso wichtig wie die elementaren Beschreibungs- sowie Berechnungsmethoden aus
der Boolschen Algebra. In Verbindung mit einem wachsenden Kenntnisstand in der Hard-
warebeschreibungssprache VHDL wird es bald jedem möglich sein, auch komplexe digitale
Schaltungen nach Zielvorgabe entwerfen und beurteilen zu können.
Die Vorlesung bereitet die wesentlichen Konzepte des Designs digitaler Schaltungen sowie
der Hardwarebeschreibungssprache VHDL auf und gibt eine Einführung in den Entwurf
digitaler Schaltungen und Systeme. Dabei wird der Bogen vom Logikentwurf auf Gat-
terebene bis hin zu komplexeren Systemen auf Register-Transfer-Ebene gespannt. Die
vermittelten Techniken und Methoden werden in den Übungen mit modernen Entwurfs-
werkzeugen praktisch umgesetzt.
1.2 Technische und mathematische Grundlagen

Zunächst sollen einige technische und mathematische Grundlagen wiederholt werden.
1.2.1 Gegenüberstellung von Analog- und Digitaltechnik
Die Digitaltechnik bietet in vielen Anwendungsbereichen gegenüber der analogen Signal-

verarbeitung erhebliche Vorteile. Die Ursache liegt in der grundsätzlich anderen Dar-
stellungsart. Analoge Größen sind physikalische Größen, die innerhalb eines bestimmten
Bereiches jeden Werte annehmen können. Bei der analogen Darstellung werden Informa-
tionen durch physikalische Größen dargestellt, deren Maßzahl wie z.B. Spannung, Strom
oder Frequenz direkt der Information entspricht. Je genauer diese physikalischen Größen
gemessen werden können, desto genauer ist die Darstellung der jeweiligen analogen Größe.
Analoge Schaltungen höchster Genauigkeit sind aufwändig und teuer.
2
Weltweit ist Verilog die am weitesten verbreitete HDL.
Berliner Hochschule für Technik 2 Prof. Dr.-Ing. Sven-Hendrik Voß

Digitale Größen sind physikalische Größen, die innerhalb eines bestimmten Dynamikbe-
reiches nur diskrete Werte annehmen können. Digitale Größen bestehen aus abzählbaren
Elementen und können mit hoher Genauigkeit dargestellt werden. Werden pro digita-
lem Signal nur zwei Zustäde unterschieden, spricht man von Binärsignalen. Ein einzelnes
binäres Zeichen wird als Bit (Abkürzung für engl. binary digit) bezeichnet.
Ein Bit ist die kleinste Einheit an Information und hat nur zwei mögliche Zustände:
an/aus oder 1/0 o.ä. Eine Information mit der Größe zwei Bit hat 22 = 4 Zustände, denn
jedes der beiden Bits kann 1 oder 0 sein (siehe Tabelle 1.2). Bei drei Bits sind es 23 = 8
Zustände und bei jedem weiteren Bit verdoppelt sich die Zahl der Möglichkeiten. Die
Anzahl verschiedener Werte, die in n Bits darstellbar sind, beträgt 2n .
In der üblichen Schreibweise werden die einzelnen Bits von rechts nach links abgezählt.
MSB“ (Abk. für engl.: Most Significant Bit) nennt man das höchstwertige Bit (ganz links,
”
Bit 7), LSB“ (Abk. für engl.: Least Significant Bit) das niederwertigste (ganz rechts, Bit
”
0). Mit 8 Bits sind bereits 28 = 256 Zustände darstellbar. Heutzutage sind Bytes die
kleinsten adressierbaren Speichereinheiten. Kleinere Einheiten müssen aus einem Byte
extrahiert werden.
Bit 1 Bit 0
0 0 Zustand 0
0 1 Zustand 1
1 0 Zustand 2
1 1 Zustand 3
Tabelle 1.2: Bitcodierung
Digitale Signale können also durch entprechende Erweiterung der Bitbreite in ihrem Dy-
namikbereich beliebig genau gemacht werden und sind weniger störanfällig als analoge
Signale. Zudem sind durch entsprechende Codierungen viele verschiedene Anwendungen
möglich und die Informationen können direkt mit Hilfe von digitalen Gattern verarbei-
tet werden. Der technische Fortschritt bei der Miniaturisierung der Komponenten der
Digitaltechnik gestattet schließlich eine effiziente Realisierung des hohen Aufwands.
1.2.2 Zahlensysteme
Verschiedene Zahlensysteme können entsprechend ihrer Basis (oder Radix) r definiert

werden, z.B. r = 2, 8, 10, 16, usw. Für ein gegebenes Basissystem mit der Basis r muss ein
Satz von r-Symbolen definiert werden, um die r Werte von 0 bis r − 1 darzustellen:
S = {s0 , s1 , · · · , sr−1 }
Nun kann eine Zahl X der Basis r als
X = (xm xm−1 · · · x2 x1 x0 x−1 x−2 · · · x−n )r

geschrieben werden, wobei xi ∈ S. (Das tiefgestellte r kann entfallen, wenn die Basis
implizit bekannt ist). Der Wert von X ist somit definiert als:
m
X
W ert(X) = xi r i
i=−n
Ein Zahlensystem, das jeder im täglichen Gebrauch hat, ist das Dezimalsystem (r = 10)
mit dem Zeichenvorrat di ∈ {0, 1, 2, · · · , 9}. Als Beispiel ergibt sich für X = 123, 4510 die
Gewichtung der einzelnen Stellen zu:
W ert(X) = 1 × 102 + 2 × 101 + 3 × 100 + 4 × 10−1 + 5 × 10−2
Das Binärsystem (r = 2) wurde im letzten Abschnit bereits durch die Informationsdar-

stellung anhand von einem Bit mit nur zwei mögliche Zustände bi ∈ {0, 1} aufgegriffen.
Somit gilt für die Darstellung von X = 1101, 012 :
W ert(X) = 1 × 23 + 1 × 22 + 0 × 21 + 1 × 20 + 0 × 2−1 + 1 × 2−2

= (8 + 4 + 0 + 1 + 0 + 0.25)10 = 13, 2510
Eine n-Bit Binärzahl X = xn−1 xn−2 · · · x1 x0 kann einen beliebigen ganzzahligen Wert
im Bereich 0 ≤ X ≤ 2n − 1 darstellen (z.B. wenn n = 3, dann 0 ≤ X ≤ 7). Um allerdings
den Wert X = 2n darzustellen, sind schon n + 1 Bits nötig.
Das Oktalsystem ist ein Stellenwertsystem mit der Basis r = 8 mit oi ∈
{0, 1, 2, 3, 4, 5, 6, 7}. Der Wert X = 736, 48 entspricht
W ert(X) = 7 × 82 + 3 × 81 + 6 × 80 + 4 × 8−1
= (448 + 24 + 6 + 0.5)10 = 478, 510
Oktalzahlen werden gern benutzt, weil die Umwandlung vom und ins Binärsystem einfach
ist. Jede Ziffer einer Oktalzahl kann durch drei Bit dargestellt werden und umgekehrt.
Ähnliches gilt für das Hexadezimalsystem und die Gruppierung in vier Bit, was einer
übersichtlicheren Darstellung von großen dualen Zahlen dient. Für die Digitaltechnik ist
die binäre Darstellung von elementarer Bedeutung interessant. Der Übersicht halber wird
bei größeren Zahlen gern die Hexadezimaldarstellung gewählt.
Im Hexadezimalsystem (r = 16) werden als Ziffern hi ∈ {0, 1, · · · , 8, 9, A, B, C, D, E, F }
definiert. So steckt hinter der Zahl X = F 3, B16 der Wert
W ert(X) = 15 × 161 + 3 × 160 + 11 × 16−1

= (240 + 48 + 0.6875)10 = 288, 687510
Durch das Prinzip der Wertigkeit der einzelnen Stellen zur Basis (r = 2) ist eine Umrech-
nung von Binär- zu Dezimaldarstellung relativ simpel. Umgekehrt gilt für die Umwand-
lung von Dezimal- zu Binär-, Oktal- und Hexadezimaldarstellung folgendes Schema, das
in Tabelle 1.3 anhand eines Beispiels der Umwandlung der Dezimalzahl 41.687510 in die
Binärdarstellung illustriert wird.

b6 b5 b4 b3 b2 b1 b0 b−1 b−2 b−3 b−4

Exponent 6 5 4 3 2 1 0 -1 -2 -3 -4
Wertigkeit 64 32 16 8 4 2 1 0,5 0,25 0,125 0,0625
ausreichend?3 0 1 0 1 0 0 1, 1 0 1 1
Tabelle 1.3: Umrechnung vom Dezimalsystem
Aus Tabelle 1.3 ist zu ersehen, dass die Umwandlung 41, 687510 = 0101001, 10112 er-
gibt. Die Umwandlung ins Oktal- und Hexadezimalsystem gestaltet sich dann als simples
Zusammenfassen von 3 Bits (Oktalsystem) bzw. 4 Bits (Hexadezimalsystem):
41, 687510 = 101001, 10112

41, 687510 = 51, 548 , 5 × 81 + 1 × 80 + 5 × 8−1 + 4 × 8−2 = 41, 687510
41, 687510 = 29, B16 2 × 161 + 9 × 160 + 11 × 16−1 = 41, 687510
Daraus lässt sich verallgemeinernd folgende systematische Methodik ableiten: Wenn ein
Wert X in einem bestimmten Zahlensystem vorliegt und dieser in ein anderes Basissystem
r konvertiert werden soll, müssen zunächst alle xi in dem Ausdruck gefunden werden:
x4 x3 x2 x1 x0 . x−1 x−2 x−3 x−3 x−4
Der Wert des ganzzahligen Anteils des obigen Ausdrucks ist
W ert(Xint ) = x4 r4 + x3 r3 + x2 r2 + x1 r + x0 = (((x4 r + x3 )r + x2 )r + x1 )r + x0
Dividiert man diesen durch r, so erhält man x0 als Rest. Wird der vorige Quotient weiter
durch r geteilt, erscheinen die nachfolgenden xi (i = 1, 2, · · ·) jeweils als Rest. Für die
Umrechnung werden die Ergebnisse also so lange durch r dividiert bis das Ergebnis Null
ist. Der Rest ist dann das Ergebnis.
Für den gebrochenen Anteil erfolgt die Umrechnung umgekehrt, also nicht durch Division,
sondern durch Multiplikation. Der gebrochene Anteil von X beträgt
W ert(Xf rac ) = x−1 r−1 +x−2 r−2 +x−3 r−3 +x−4 r−4 = r−1 (x−1 +r−1 (x−2 +r−1 (x−3 +r−1 x−4 )))
Wird dieser mit r multipliziert, entsteht x−1 als ganzzahliger Anteil des Produkts. Multi-
pliziert man den Bruchteil des vorigen Produkts weiter mit r, erhält man die nachfolgenden
xi (i = −2, −3, · · ·) als weitere ganze Zahlen des Produkts.
3
Ausgehend von der höchsten Wertigkeit wird durch sukzessive durch Subtraktion geprüft, welche Zahlen
zur Darstellung des Wertes aus dem Binärsystem nötig sind und diese werden anschließend zusammen-
gefügt: 41 − 32 = 9; 9 − 8 = 1; 0.6875 − 0.5 = 0.1875; 0.1875 − 0.125 = 0.0625.

1.2.3 Komplementdarstellung
In Hardware ist die Anzahl der Bits n für die Darstellung eines ganzzahligen Wertes
festgeschrieben. Jeder Wert, der mehr als n Bits erfordert, kann nicht korrekt in n Bits
dargestellt werden.
Das Einerkomplement einer n-Bit Binärzahl X = bn−1 · · · b1 b0 ist definiert als:
2n − 1 − X = 100 · · · 00 − 1 − X = 11 · · · 11 − bn−1 bn−2 · · · b1 b0 = bn−1 bn−2 · · · b2 b1 b0
Dies ist entspricht einfach der bitweisen Vertauschung von von X (1 → 0, 0 → 1).
Das Zweierkomplement einer n-Bit Binärzahl X = bn−1 · · · b1 b0 ist definiert als
2n − X = (2n − 1 − X) + 1 = 2n − 1 − (X − 1)
und kann auf unterschiedliche Weisen gebildet werden:

1. Subtraktion gemäß 2n − X
2. Einerkomplement und anschließende Addition mit 1
3. Subtraktion von 1 von X, dann bitweises Komplement
4. Übernahme aller niederwertigen Nullen und der ersten 1, dann bitweises Komple-
ment der restlichen Bits
Die aufgezählten Varianten der Bildung werden im folgenden Beispiel anschaulich ver-
deutlicht:
b4 b3 100 = 11111 − b4 b3 100 + 1 = b4 b3 011 + 1 = b4 b3 100
Es gilt zu beachten, dass die Komplementdarstellung immer auf der Anzahl verfügbarer
Bits n basiert. Das Komplement von Null ist zudem immer noch Null. Bei der Bildung
des Komplements des Komplements entsteht wieder der ursprüngliche Wert, wie folgende
Umwandlung zeigt:
X = 2n − X, X = 2n − X = 2n − (2n − X) = X
Das Zweierkomplement ist substantiell für arithmetische Implementierungen in digitalen

Schaltungen. Diese Darstellung wird verwendet, um negative Zahlen und Subtraktionen
zu behandeln, da das Komplement wie soeben erläutert einer Negation gleichkommt:
−(−X) = X, −0 = 0. Dadurch können Operationen effizient umgesetzt werden.
Für die Zweierkomplementdarstellung einer ganzen Zahl muss unterschieden werden, ob
der darzustellende Wert X größer oder kleiner als 0. Liegt der darzustellende Wert im
Bereich 0 ≤ X ≤ (2n−1 − 1), so wird der Wert in der gewohnten binären Form dargestellt,
aber das MSB muss 0 sein. Liegt er im Bereich −2n−1 ≤ X ≤ −1, so wird der Wert
durch das Zweierkomplement seines Betragswertes |X| ausgedrückt, jedoch muss das MSB
immer 1 sein. Beide Fälle können wie folgt dargestellt werden:
(
2n + X = X, if X ≥ 0
2n + X =
2n − |X| , if X < 0

Somit kann das MSB als das Vorzeichenbit gedeutet werden, das angibt, ob die Zahl positiv
(M SB = 0) oder negativ (M SB = 1) ist. Für die Vorzeichenerweiterung gilt dann, dass
eine beliebige Anzahl von Nullen einer gegebenen positiven Zahl vorangesetzt werden
kann, ohne deren Wert zu verändern. Ebenso kann eine beliebige Anzahl von Einsen
hinzugefügt werden, wenn die Zahl in der Zweierkomplementdarstellung vorliegt.
Zusammenfassend gilt für den Bereich der im Zweierkomplement darstellbaren Werte:
−2n−1 ≤ X ≤ (2n−1 − 1)
1.2.4 Fehlererkennung
Neben der Darstellung von Zahlen in Hardware ist auch die Übertragung von Da-
ten von Bedeutung, bei der davon ausgegangen werden muss, dass Störungen auf den
Übertragungswegen zu auftretenden Bitfehlern führen. Ursachen dafür können Störsignale
von außen, Spannungsspitzen aus dem Rauschen aktiver Bauelemente oder auch statische
oder dynamische Fehler in digitalen Speichern sein.
Binärcode Parity Bit ungerade Parity Bit gerade

0000 1 0
0001 0 1
0010 0 1
0011 1 0
0100 0 1
0101 1 0
0110 1 0
0111 0 1
1000 0 1
1001 1 0
1010 1 0
1011 0 1
1100 1 0
1101 0 1
1110 0 1
1111 1 0
Tabelle 1.4: Binärcode mit Parity
Zur Erkennung solcher Bitfehler können spezielle Codes verwendet werden, die man -
je nach Komplexität und Verhalten - fehlererkennende oder fehlerkorrigierende Codes
nennt.
Die einfachste Form der Fehlererkennung ist die Erweiterung des zu übertragenden Bit-
musters um ein weiteres Bit (Prüfbit), das sogenannte Paritätsbit (Parity Bit). Mit dem

Paritätsbit wird die Anzahl der in der Bitfolge vorkommenden Bits auf eine gerade oder
ungerade Anzahl ergänzt. Je nachdem spricht man von einer geraden Parität (even parity)
oder einer ungeraden Parität (odd parity).
In Tabelle 1.4 ist als Beispiel eine Liste von Binärzahlen (von 0 bis 15) mit den Paritätsbits
für gerade (even) und ungerade (odd) Parität aufgeführt.
Mithilfe des Parity Bits können Einbitfehler erkannt werden. Das Auftreten von Zweibit-
fehlern würde allerdings nicht erkannt werden, weil diese sich in der Erkennung aufheben
würden. Die Erkennung von drei fehlerhaften Bits (oder allgemein: ungeraden Mehrfach-
fehlern) ist dagegen möglich.
Eine Fehlerkorrektur ist durch die Erweiterung mittels Parity Bit nicht möglich. Da-
zu bedarf es fehlerkorrigierender Codes. Diese sind ähnlich aufgebaut, jedoch mathe-
matisch komplexer4 , da sie eine eindeutige Bestimmung der Position des aufgetretenen
Fehlers ermöglichen müssen. Ein Beispiel für einen fehlerkorrigierenden Code ist der sog.
Hamming-Code (vgl. Grundlagen digitaler Systeme“).
”
1.2.5 Elementare Logikverknüpfungen
Logische Verknüpfungen sind in der Aussagenlogik bzw. Booleschen Algebra sehr wichtig.
In ihrer Implementierung als Logikgatter sind sie auch ein ganz elementarer Bestandteil
der Digitaltechnik. Dort dienen sie dazu, verschiedene digitale Signale logisch zu ver-
knüpfen.
In der folgenden Darstellung werden abgesehen von der NOT-Verknüpfung nur Ver-
knüpfungen von zwei Variablen betrachtet. Ebenso wird die positive Logik“ vorausge-
”
setzt, bei der der Zustand LOW der logischen 0 und der Zustand HIGH der logischen 1
entspricht.
Für eine AND-Verknüpfung (Konjunktion) mit zwei Eingangsbedingungen (auch Ein-
gangsvariablen genannt) gibt es vier Kombinationsmöglichkeiten, wie in Tabelle 1.5 zu
sehen. Nur wenn beide Eingangsvariablen gesetzt sind, ergibt sich für das Ergebnis Y der
Wert 1.
x1 x0 y
0 0 0
0 1 0
1 0 0
1 1 1
Tabelle 1.5: AND-Verknüpfung
4
An dieser Stelle sei auf die Wahlfachvorlesung Kanal- und Quellencodierung“ im Bachelor-Studiengang
”
Technische Informatik an der Berliner Hochschule für Technik, die jeweils im Wintersemester von mir
gehalten wird.

Bei der in Tabelle 1.6 gezeigten OR-Verknüpfung (Disjunktion) wird das Ergebnis Y auf
1 gesetzt, falls mindestens eine der Eingangsvariablen den Wert 1 besitzt.
x1 x0 y
0 0 0
0 1 1
1 0 1
1 1 1
Tabelle 1.6: OR-Verknüpfung
Das Ergebnis Y der NAND-Verknüpfung zeigt nur dann eine 0, wenn beide Eingangs-
variablen gesetzt sind. Für alle anderen Kombinationen erscheint eine 1 als Ergebnis.
Tabelle 1.7 zeigt die zugehörige Wahrheitstabelle.
x1 x0 y
0 0 1
0 1 1
1 0 1
1 1 0
Tabelle 1.7: NAND-Verknüpfung
Bei der NOR-Verknüpfung (Tabelle 1.8) tritt als Ergebnis immer dann eine 0 auf, wenn
mindestens eine Eingangsvariable den Wert 1 hat.
x1 x0 y
0 0 1
0 1 0
1 0 0
1 1 0
Tabelle 1.8: NOR-Verknüpfung
Bei der XOR-Verknüpfung (Antivalenz) ist das Ergebnis immer dann 1, wenn nur (genau)
eine Eingangsvariable eine 1 führt, d.h. die Eingangsvariablen unterschiedliche Werte be-
sitzen wie in Tabelle 1.9 dargestellt. Dies lässt sich leicht merken, da das Schaltsymbol
nach DIN-Norm eine =1“ zeigt.
”

x1 x0 y
0 0 0
0 1 1
1 0 1
1 1 0
Tabelle 1.9: XOR-Verknüpfung
Für die in Tabelle 1.10 gezeigte XNOR-Verknüpfung gilt, dass nur der gleiche Zustand (0
oder 1) bei den Eingangsvariablen zu einer 1 am Ausgang führt. Auch dies ist leicht zu
behalten, da das Schaltsymbol das Gleichzeichen zeigt.
x1 x0 y
0 0 1
0 1 0
1 0 0
1 1 1
Tabelle 1.10: XNOR-Verknüpfung
Bei der NOT-Verknüpfung (Negation) wird einfach der Wert der Eingangsvariable im
Ergebnis invertiert.
Alle hier gezeigten Verknüpfungen können schaltungstechnisch auf verschiedene Arten
realisiert werden, z.B. durch Dioden und Transistoren (sog. DTL-Technik) oder mittels
Feldeffekttransistoren (FETs in MOS- oder CMOS-Technik). Darauf wird ausführlich in
einem späteren Kapitel eingegangen.
Die bis hierhin dargestellten Sachverhalte sollen als Wiederholung von bereits vermittel-
tem Grundlagenwiessen einen Einstieg in das Themengebiet erleichtern und zum fundier-
ten Verständnis und zur sicheren Anwendung in den nun folgenden Themenkomplexen
rund um den Logikentwurf, die Analyse und Beschreibung, sowie systematische Entwick-
lung von digitalen Schaltungen beitragen.
Einschlägige Kenntnisse in der Booleschen Algebra und Aussagelogik aus der Vorlesung
Grundlagen digitaler Systeme“ werden vorausgesetzt, ebenso ein mathematisches Grund-
”
verständnis, sowie Grundlagenkenntnisse der Elektrotechnik.

2 Grundlagen der Digitaltechnik
In diesem Kapitel sollen die elementaren Grundlagen und Methoden beschrieben wer-
den, mit denen sich Funktionen in Form digitaler Hardware-Schaltungen beschreiben und
umsetzen lassen. Neben den Unterscheidungsmerkmalen zwischen kombinatorischen und
sequentiellen Schaltungen wird hier auch der Einstieg in die Hardwarebeschreibungsspra-
che VHDL gegeben.
2.1 Logische Funktionen

In digitalen Schaltungen werden meist mehrere binäre Eingaben zu einer binären Ausgabe
verknüpft. Dies geschieht nach definierten logischen Beziehungen zwischen den Eingangs-
signalen und dem zugeordneten Ausgangssignal.
2.1.1 Darstellung logischer Funktionen
Um diese logischen Funktionen5 übersichtlich darzustellen, existieren verschiedene Dar-

stellungsformen:
• Funktionstabelle (Wahrheitstabelle)
• schaltalgebraische Gleichung → Normalformen (DNF, KNF)
• Schaltbild nach DIN (oder US-Schreibweise)
In der Wahrheitstabelle werden allen möglichen Wertekombinationen der Eingangsvaria-
blen die Werte der jeweiligen Ausgangsvariable(n) zugeordnet. Zu jeder kombinatorisch
möglichen Eingangsbelegung gibt es eine Zeile, die die entsprechenden Eingangssignale
und das zugehörige Ausgangssignal beschreiben
Die schaltalgebraische Gleichung (Funktionsgleichung) definiert die logischen Ver-
knüpfungen zwischen den Eingangsvariablen und dem Ausgangssignal durch eine mathe-
matische Gleichung in geschlossener Form. Damit lassen sich die logischen Beziehungen
noch kompakter darstellen, als dies durch die Wertetabelle möglich wäre.
Die Funktionsgleichung wird in der Regel aus der Wahrheitstabelle ermittelt. Die Nor-
malformdarstellung liefert einen einheitlichen Weg dahin. Man unterscheidet zwischen der
disjunktiven und der konjunktiven Normalform, je nachdem ob disjunktive Verknüpfungen
von Mintermen (disjunktive Normalform oder auch SOP (Sum of Products)) oder konjunk-
tive Verknüpfungen von Maxtermen (konjunktive Normalform oder auch POS (Product
of Sums)) vorliegen. Ein Minterm stellt dabei die konjunktive Verknüpfung, ein Maxterm
5
Die Begriffe logische Funktion“, Schaltfunktion“ und Boolesche Funktion“ werden in der Regel – und
” ” ”
so auch hier – synonym verwendet.
11
KAPITEL 2. GRUNDLAGEN DER DIGITALTECHNIK
die disjunktive Verknüpfung aller Eingangsvariablen dar, wobei jede Eingangsvariable in

negierter oder nichtnegierter Form vorkommen muss.
Ein Minterm gibt die Werte an, die die Variablen annehmen müssen, damit die Funktion
eine 1 als Ausgangswert annimmt, ein Maxterm analog mit 0. Beide Normalformen sind
gleichwertig und lassen sich nach dem Dualitätsprinzip ineinander überführen.
Das Schaltbild gibt Auskunft über die elektrotechnische Realisierung einer Schaltfunk-
tion als digitale Schaltung. Dabei realisieren elementare Logikbausteine die Grundver-
knüpfungen. Diese nennt man Logikgatter“ oder einfach Gatter“. Jedes dieser Gatter
” ”
hat ein eigenes Schaltzeichen6 . Im Schaltbild ist grafisch definiert welche Gatter wie mit-
einander verbunden sind und wie diese somit auf die Eingangsvariablen wirken. Abgeleitet
wird das Schaltbild in der Regel aus der Funktionsgleichung.
2.1.2 Vereinfachung logischer Funktionen
Die Vereinfachung einer gegebenen Schaltfunktion (entweder als boolescher Ausdruck oder
als Wahrheitstabelle) ist in der Regel immer empfehlenswert, da so der Aufwand zur
Realisierung der Funktion in Bezug auf die Anzahl der logischen Gatter und die Anzahl
der zur Darstellung der Funktion erforderlichen Eingänge zu diesen Gattern reduziert
werden kann.
Zur Vereinfachung logischer Funktionen können folgende Ansätze angewendet werden:
• Algebraische Vereinfachung
• Vereinfachung mit KV-Tafeln
• Verfahren nach Quine und McClusky
Die Methode der algebraischen Vereinfachung nutzt die Sätze der Booleschen Algebra,
um die gegebene Schaltfunktion durch Ausklammern, Kürzen, Zusammenfassen, u.a. zu
vereinfachen. Diese Methode kann bei langen Funktionsgleichungen sehr umständlich und
unübersichtlich werden.
Die Vereinfachung mit KV-Tafeln zählt zu den graphischen Methoden, da hier die Wahr-
heitstabelle der logischen Funktion graphisch dargestellt wird. Sie wird in Abhängigkeit
der Anzahl der Eingangsvariablen (n) in eine entsprechende Anzahl (2n ) von Feldern
unterteilt, von denen jedes entweder einen Minterm oder Maxterm repräsentiert. Die Zu-
ordnung der Felder erfolgt so, dass sich zwischen benachbarten Feldern immer genau nur
eine Eingangskombination unterscheidet. Durch Zusammenfassen benachbarter Felder in
Größen von Zweierpotenzen und damit Wegfall von Variablenabhängigkeiten entstehen
so kürzere Ausdrücke für die Funktion. Diese Methode ist sehr komfortabel und gelingt
in der Regel immer. Ab einer Anzahl von 6 Eingangsvariablen wird diese Methode jedoch
unübersichtlich und nicht mehr praktikabel.
6
Üblich ist die Internationale Norm DIN EN 60617-12, sowie die Amerikanische Norm ANSI 91-1984. In
der Literatur findet sich auch häufig noch die frühere deutsche Norm DIN 40700. In diesem Skript, sowie
im Unterricht werden nur die Symbole nach DIN EN 60617-12 verwendet.

Das Verfahren nach Quine und McClusky (auch: tabellarische Methode) ist ein systema-
tisches Minimierungsverfahren und eignet sich daher sehr gut für den Einsatz in Compu-
teralgorithmen, nicht zuletzt, da sich deterministisch bestimmen lässt, ob die minimale
Form einer Booleschen Funktion erreicht ist. Zudem ist die Methode für beliebig viele
Eingangsvariablen anwendbar. Die Grundidee basiert analog zur KV-Tafel auf dem Zu-
sammenfassen von Termen, die in genau einer Variablen komplementär belegt sind. Dazu
müssen zunächst alle Minterme ermittelt und im nächsten Schritt zur Vereinfachung aus-
gewählt werden. Diesen Vorgang wiederholt man rekursiv in mehreren Stufen so lange,
bis keine weiteren Vereinfachugen mehr möglich sind.
2.1.3 Beschreibung mit VHDL
Gegeben sei die in Tabelle 2.1 gezeigte Funktionstabelle.
x2 x1 x0 y
0 0 0 0
0 0 1 1
0 1 0 0
0 1 1 1
1 0 0 1
1 0 1 0
1 1 0 1
1 1 1 1
Tabelle 2.1: Funktionstabelle
Die Funktion y verfügt über 3 Eingangsvariablen. Die DNF-Darstellung dieser Funktion

lautet:
y = m1 ∨ m3 ∨ m4 ∨ m6 ∨ m7
= (x2 ∧ x1 ∧ x0 ) ∨ (x2 ∧ x1 ∧ x0 ) ∨ (x2 ∧ x1 ∧ x0 ) ∨ (x2 ∧ x1 ∧ x0 ) ∨ (x2 ∧ x1 ∧ x0 )
Die Funktion lässt sich durch die in Abbildung 2.1 gezeigte Schaltung beschreiben. Wie
für alle Normalformen üblich, weist die Schaltung eine zweistufige Struktur auf. Die erste
Stufe wird durch die Konjunktionen gebildet, die zweite Stufe durch die Disjunktion der
Ergebnisse aus der ersten Stufe. Auf eine Vereinfachung wird hier verzichtet. Stattdessen
soll der Fokus auf eine Darstellung in VHDL gerichtet werden.
Ein VHDL-Modell besteht aus einer Entity Deklaration und der Definition einer (oder
mehrerer) Architectures. Die Entity ist als Black Box zu verstehen und kapselt die gesamte
Schaltung (ohne Details über deren Implementierung). Zudem definiert die Entity den
Namen der Entwurfseinheit, sowie die Schnittstellen zu ihrer Umgebung, unterteilt nach
Richtungen (in oder out).

Die Architecture definiert die Funktion der Schaltung. Dies kann auf verschiedenen Ab-
straktionsebenen erfolgen. Abbildung 2.2 stellt anschaulich die Entsprechungen von Entity
und Architecture in der Schaltung dar.
x2 x1 x0
1 1 1
&
&
& >=1 y
&
&
Abbildung 2.1: Schaltbild der Beispielfunktion
Listing 2.1 zeigt die komplette VHDL Beschreibung der Beispielschaltung. Der benutzer-
definierte7 Name der Entity lautet Normalform“. Unter diesem, d.h. dem gleichen Namen
”
wie in der Entity angegeben, muss die Datei mit der Endung .vhd“ auch gespeichert sein,
”
da nur so eine eindeutige Referenzierung möglich ist. In VHDL wird grundsätzlich nicht
zwischen Groß- und Kleinschreibung unterschieden. Daher sollte man selbst konsequent
in der Benennung und Kennzeichnung sein.
In der Port Deklaration sind die Schnittstellen definiert, die von der Entwurfseinheit
zur Kommunikation mit ihrer Umgebung verwendet werden. Das Semikolon dient als
Trennzeichen. Zudem ist der Datentyp (hier: bit“) und die Richtung des Datenflusses
”
über den Port definiert. Der Wertevorrat des Datentyps bit“ besteht aus den logischen
”
Werten 0 und 1.
Neben den Richtungen IN (Eingang zur Entity) und OUT (Ausgang von Entity) gibt es
noch die Modi INOUT (Ein- oder Ausgang), sowie BUFFER. Die zwei letztgenannten
sollten von Anfängern jedoch vermieden werden, da sie in der Anwendung problematisch
sind und einige Erfahrung im Umgang erfordern.
INOUT und BUFFER erlauben beide das Zurücklesen eines Wertes von einem Ausgang.
7
Für benutzerdefinierte Benennungen von Entities, Architectures, Ports und Signalen, etc. gilt, dass diese
immer mit einem Buchstaben beginnen müssen, aus Buchstaben, Ziffern und Unterstrichen bestehen
können und keine reservieren Schlüsselwörter (wie z.B. Begin“, End“, Signal“, Variable“, etc. sein
” ” ” ”
dürfen.

Eingangsports Entity (Black Box mit

x2 x1 x0
Interface-Beschreibung)
Architecture
(Implementierung der Funktion)
1 1 1
&
&
Ausgangs-
port
& >=1 y
&
&
Abbildung 2.2: Analogie der Beschreibung in VHDL
Dabei entspricht der Modus BUFFER einfach einem Register, d.h. hier wird der Ausga-
bewert zusätzlich gespeichert, um ihn später zurücklesen zu können. Ein Einlesen des an
den Port angelegten externen Signalwertes ist allerdings nicht möglich. Der Modus IN-
OUT setzt dagegen einen Tri-State Buffer voraus. Die meisten FPGAs verfügen allerdings
über keine internen Tri-State-Puffer außer an der externen Schnittstelle zum Chip. Wird
dieses Konstrukt dennoch also verwendet, führt dies zu einer unverhältnismäßig erhöhten
Hardware-Komplexität, da das Verhalten mit den in der regulären Logik vorhandenen
Ressourcen nachgebildet werden muss. Bei der Verwendung ist zudem Sorgfalt geboten,
denn es existieren zwei separate Treiber für ein einzelnes Signal. Daher muss das Signal
immer explizit auf hochohmig gestellt werden, um den Wert eines externen Signals lesen
zu können und umgekehrt.
Die Architecture beschreibt die Implementierung der Funktion. Wie die Entity verfügt
auch die Architecture über einen benutzerdefinierten Namen, der eindeutig das jeweilige
Architekturmodell beschreibt. Wie in Listing 2.1 gezeigt, wird die Architecture mit Namen
DNF“ in der ersten Zeile durch das Schlüsselwort OF“ mit der Entity verknüpft.
” ”
Innerhalb der Architecture sind hier fünf Signale definiert, die der Verknüpfung der Min-
terme in der letzten Anweisungszeile dienen. Sie sind durch das Schlüsselwort Signal“
”
in der Architekturbeschreibung definiert und nur hier verfügbar. Signale benötigen keine
Richtungsangabe, wohl aber die Angabe eines Datentypes. Bei Zuweisungen von Port-
signalen zu internen Signalen und vice versa ist auf die Verwendung von gleichen Da-
tentypen zu achten. Die Zuweisung von Signalen erfolgt durch den Zuweisungsoperator
<=. Links steht das Ziel der Zuweisung, rechts vom Zuweisungsoperator der oder die
Signalnamen, von denen der Wert ausgeht.
In kombinatorischen Beschreibungen, d.h. Zuweisungen von Kombinationen von Eingangs-
werten durch Gatter und Negatoren ohne Rückkopplung und Speicherelemente, die zu

einem beliebigen Zeitpunkt immer dieselbe Ausgangsbelegung, entsprechen Signale Lei-

tungen. Diese können zugewiesen und gelesen werden. Nur bei der Zuweisung auf Signale
der Entity mit Richtung OUT ist darauf zu achten, dass von ihnen nicht zurückgelesen
werden kann.

ENTITY Normalform IS
PORT ( X0 , X1 , X2 : IN bit ; -- Eingangsports
Y : OUT bit -- Ausgangsport
);
END Normalform ;
ARCHITECTURE DNF OF Normalform IS
SIGNAL m1 , m3 , m4 , m6 , m7 : bit ;
BEGIN
m1 <= ( NOT X2 ) AND ( NOT X1 ) AND X0 ;
m3 <= ( NOT X2 ) AND X1 AND X0 ;
m4 <= X2 AND ( NOT X1 ) AND ( NOT X0 ) ;
m6 <= X2 AND X1 AND ( NOT X0 ) ;
m7 <= X2 AND X1 AND X0 ;
Y <= m1 OR m3 OR m4 OR m6 OR m7 ;
END DNF ;
Listing 2.1: VHDL Code der Beispielschaltfunktion
Alle Zuweisungen in einer kombinatorischen Beschreibung erfolgen nebenläufig und ohne

Zeitversatz. Daher spielt im hier gezeigten Beispiel auch keine Rolle, in welcher Reihenfolge
die einzelnen Zuweisungen der Minterme formuliert werden. Für die logische Verknüpfung
finden die logischen Operatoren AND, OR, und NOT von VHDL Anwendung. Anweisun-
gen enden mit einem Semikolon. Ein doppelter Bindestrich (–) lässt Kommentare in der
VHDL-Codedatei zu.
Die Architecture kann ebenso die Implementierung der Funktion als KNF beschreiben
(hier nicht gezeigt). Die Komplexität der Schaltung wäre aufgrund der kleineren Anzahl
an Nullen für dieses Beispiel sogar deutlich geringer. Weitere Details zu VHDL, der Ent-
stehung von VHDL, dem Gebrauch von Signalen und weiteren typischen Konstrukten
finden sich in einem späteren Kapitel (Kapitel 4).
2.2 Schaltnetze und Schaltwerke

Man unterscheidet in der Digitaltechnik grundsätzlich zwischen Schaltnetzen (kombina-
torischer Logik) und Schaltwerken (sequentieller Logik).
Schaltnetze umfassen eine Zusammenschaltung von Logikgatter, die über n Eingänge
E = {E1 , · · · , En } und n Ausgänge A = {A1 , · · · , An } verfügen. Die Schaltung kann
entweder zweistufig (z.B. zur Realisierung einer DNF oder KNF) oder mehrstufig ausgelegt
sein. Das logisches Verhalten ist direkt durch Boolesche Funktionen beschreibbar. Der
Ausgangszustand A ist dabei nur vom aktuellen Eingangszustand E abhängig. Das heißt,
zu jedem beliebigen Zeitpunkt ist der Ausgang Ai eine Funktion der 2n Kombinationen
der aktuellen Eingänge (ohne Gedächtnis):
Ai = fi (E1 , · · · , En )
Für jeden Eingangszustand existiert genau ein Ausgangszustand (vgl. Abbildung 2.3).
Kombinatorische Schaltungen können zum Aufbau von Schaltungen einfacher Logik ver-
wendet werden.

Schaltnetz
E A
0 & 0 >=1
0 0
0 0
A=f(E)
E1 A1
E2 A2
E= E3 A= A3
En An
Abbildung 2.3: Schaltnetz
Schaltwerke bestehen aus kombinatorischer Logik und einer verzögerten Rückführung mit
Speicherelementen. Sie verfügen ebenfalls über n Eingänge E = {E1 , · · · , En } und n
Ausgänge A = {A1 , · · · , An }, hier stellt zu jedem beliebigen Zeitpunkt der Ausgang Ai
aber eine Funktion nicht nur des aktuellen Eingangs, sondern auch der vorangegangenen
Eingangszustände dar:
Ai (t) = fi (E(t), E(tn ), E(tn−1 · · · , E(t0 )
Für jeden Eingangszustand ist also mehr als ein Ausgangszustand möglich (vgl. Abbil-
dung 2.4).
Schaltwerk
E A
0 & 0 >=1
0 0
0 0
A(tn)=f(E(tn),E(tn-1),…,E(t0))
E1 A1
E2 A2
E= E3 A= A3
En An
Abbildung 2.4: Schaltwerk

Als elementaren Gegensatz hat das Schaltwerk also ein Gedächtnis bzw. einen inneren
”
Zustand“. Dies ist der Grund weshalb man auch von sequentieller Logik spricht: Hier wird
eine Sequenz an Eingängen verarbeitet. Dies setzt die Fähigkeit zur Speicherung dieser
inneren Zustände (gewissermaßen der Vorgeschichte“ der Schaltung) voraus, skizziert in
”
Abbildung 2.5.
Schaltwerk
E A
0 & 0 >=1
0 0
0 0
Kombinatorische
Schaltung
Zustands-
variable
Speicher oder
Verzögerung
Abbildung 2.5: Gewinnung der Zustandsvariable
Je nachdem welche Art von Speicherelementen zur Speicherung und Rückführung dieser
Zustandsvariablen verwendet werden, können die Schaltwerk entweder synchron (taktge-
steuert) oder asynchron arbeiten. Grundsätzlich unterscheidet man zwischen zwei Vari-
anten:
• einfache Rückkopplung oder Verwendung von Latches (asynchrone seq. Logik)
• Verwendung getakteter Flipflops (synchrone sequentielle Logik)
Mit sequentiellen Schaltungen können sehr komplexe Logiksysteme realisiert werden.
2.3 Speicherelemente sequentieller Logik

Speicherelemente werden in der Digitaltechnik in zwei Gruppen unterteilt:
• Flipflops (taktflankengesteuert)
• Latches (ungetaktete Flipflops)
Rückkopplung ist der Schlüssel zur Realisierung von Speichern. Abbildung 2.6 zeigt eine
der einfachsten Schaltungen zur Speicherung von 1 Bit: ein RS-Latch.
Ein einfaches RS-Latch kann durch zwei rückgekoppelte NOR-Gatter mit der folgenden
Wahrheitstabelle (Tabelle 2.2) aufgebaut werden, wobei S für Set und R für Reset steht.
Qn+1 bezeichnet den Wert des Ausgangs Q nach einem betrachteten Wechsel, Qn den
Wert davor.
Indem man als Logikgattern entweder NAND- oder NOR-Gatter verwendet, können zwei
Arten von Latches können aufgebaut werden. Abbildung 2.7 zeigt die Realisierung in
NAND-Gattern, Tabelle 2.3 die zugehörige Wahrheitstabelle.

R
>=1 Q
>=1 Q
S
Abbildung 2.6: RS-Latch aus NOR-Gattern
S R Qn+1 Qn+1
0 0 Qn Qn
0 1 0 1
1 0 1 0
1 1 0 0
Tabelle 2.2: Wahrheitstabelle RS-Latch mit NOR-Gattern
Wenn die Wirkung des Latches durch ein zusätzliches Freigabesignal synchronisiert wer-
den soll, können gemäß Abbildung 2.8 zwei zusätzliche AND-Gatter mit einem gemein-
samen Eingang EN (für engl. Enable) zusammen mit den beiden Eingängen R und S
verwendet werden. Wenn EN = 0, bleibt das Latch unverändert oder deaktiviert, sein
Ausgang ist unabhängig von den Eingängen R und S. Der Ausgangszustand wird verrie-
gelt. Wenn EN = 1, wird das Latch jedoch aktiviert, um auf R und S zu reagieren. Es ist
dann schaltfähig. Dieses Latch mit zweistufigem Aufbau wird Gated RS-Latch genannt.
Tabelle 2.4 stellt das Schaltverhalten dar. X bedeutet don’t care“.
”
S
& Q
& Q
R
Abbildung 2.7: RS-Latch aus NAND-Gattern
Besonderes Augenmerk soll nun auf das Verhalten des RS-Latches gerichtet werden für
den Fall, dass beide Eingänge R und S aktiviert sind. Wenn EN = 1, sind beide
Ausgänge Qn+1 und Qn+1 auf 1. Wenn EN auf 0 geht, haben beide NAND-Gatter an
ihren Eingängen zwei Einsen, so dass sowohl Qn+1 als auch Qn+1 auf 0 gehen. Aber auf-
grund der Rückkopplungen versuchen beide, den anderen auf 1 zu setzen. Dies stellt eine
instabile Situation dar, die schließlich auf der Grundlage der Asymmetrie der beiden Gates
mit unvorhersehbarem Ausgang aufgelöst wird.

S R Qn+1 Qn+1
1 1 Qn Qn
1 0 0 1
0 1 1 0
0 0 1 1
Tabelle 2.3: Wahrheitstabelle RS-Latch mit NAND-Gattern
Um dieses Problem zu vermeiden, können R und S immer komplementär zueinander

gesetzt werden. So werden zwei der vier Fälle, die R = S = 1 und R = S = 0 entspre-
chen, eliminiert werden. Die resultierende Schaltung wird als D-Latch bezeichnet (Abbil-
dung 2.9). Sie arbeitet mit einem einzigen Eingang D mit S = D und R = D, zzgl. dem
Enable-Eingang. Bei EN = 1 verhält sich das D-Latch transparent, bei EN = 0 wird
der letzte Eingangswert übernommen, der Ausgang bleibt unverändert. Es ist leicht zu
erkennen, dass der Ausgang Q eines D-Latches immer dem Eingang D folgt.
S
&
& Q
S Q
EN EN
R Q
& Q
&
R
Abbildung 2.8: Gated RS-Latch mit Schaltsymbol
EN S R Qn+1 Qn+1
0 X X Qn Qn
1 0 0 Qn Qn
1 0 1 0 1
1 1 0 1 0
1 1 1 1 1
Tabelle 2.4: Wahrheitstabelle Gated RS-Latch
Alle bisher gezeigten Schaltungen sind pegelgetriggert, d.h. die Schaltungen sind immer
aktiv, wenn das Enable-Signal auf 1 ist. Folglich können die Eingänge während der ge-
samten aktiven Phase die Ausgänge beeinflussen und es kann zu unvorhersehbaren oder
ungewünschten Ausgangssignalen kommen, je nachdem, wann genau das Enable-Signal
inaktiv wird. Um dies zu vermeiden, können die Schaltungen flankengetriggert realisiert
werden. Der Ausgang wird dann nicht durch den Pegel, sondern durch die (steigende oder
fallende) Flanke des Taktsignals bestimmt. Dies setzt eine entsprechende Flankenerken-
nung voraus. Abbildung 2.10 illustriert die Funktionsweise der Flankenerkennung.

D
&
& Q
D Q
EN EN
Q
& Q
&
1
Abbildung 2.9: Gated D-Latch mit Schaltsymbol
Mit Taktflankensteuerung werden aus asynchronen Latches synchrone Speicherelemente

(Flipflops). Diese zeichnen sich dadurch aus, dass sie nur zu bestimmten diskreten Zeit-
punkten schaltfähig sind und dadurch eine höhere Störsicherheit erreichen. Abbildung 2.11
stellt das unterschiedliche Zeitverhalten von Latch und Flipflop im Timingdiagramm ge-
genüber.
Takt Takt
& Takt* & Takt*
1 1
Takt Takt
Takt Takt
Takt Takt
Takt* Takt*
Positiv-verlaufende Transition Negativ-verlaufende Transition
Abbildung 2.10: Flankendetektorschaltung für steigende und fallende Flanken
Grundsätzlich kann eine Flankensteuerung sowohl bei der steigenden (positiven), als auch
bei der fallenden (negativen) Flanke stattfinden. Auf welche Flanke das Flipflop reagiert
ist eindeutig aus der Kennzeichnung des Takteinganges (als Takt oder Clock bezeichnet)
im Schaltzeichen ersichtlich. Ist der Eingang negiert, reagiert das Flipflop auf die negative
Flanke. Ist keine Negierung eingezeichnet, reagiert das Flipflop auf die positive Flanke.
Abbildung 2.12 zeigt eine Übersicht der wichtigsten Flipfloptypen und deren Schaltzei-
chen.
Störung
Daten
Takt
Latch
Ausgang
Flipflop
Ausgang
Abbildung 2.11: Verhalten von Latch und Flipflop in der Gegenüberstellung

D- und JK-Flipflops werden am häufigsten in sequentieller Logik eingesetzt. Das JK-

Flipflop zeichnet sich dadurch aus, dass die Ausgänge Q und Q zu den Eingangs-NAND-
Gattern, wie in Abbildung 2.13 gezeigt, zurückgekoppelt werden. Ähnlich wie beim D-
Flipflop wird auch hier die Kombination R = S = 1 vermieden. Durch die Rückkopplung
ist gewährleistet, dass Q und Q immer komplementär sind. Die zwei Eingängen entspre-
chen J = S und K = R. Setzt man J = K = 1 invertiert das Flipflop jeweils seinen
vorherigen Ausgangwert.
Positiv-flankengetriggerte Flipflops
S Q D Q J Q
R Q Q K Q
Symbol am
Takteingang
Negativ-flankengetriggerte Flipflops negativer
Logikpunkt
S Q D Q J Q
R Q Q K Q
Abbildung 2.12: Flankengetriggerte Flipflops
Daraus resultiert eine weitere Abwandlung, nämlich die Realisierung eines T-Flipflops. Bei
diesem sind die Eingänge J und K zu einem einzigen Eingang namens T zusammengefasst.
Dadurch werden wiederum zwei der vier Fälle mit unterschiedlichen Inputs (J = K)
eliminiert. Bei Aktivierung des Flipflops durch T = 1 schaltet der Ausgang jeweils auf
den invertierten Wert um.
J
&
& Q
Takt
&
1
& Q
&
K
Abbildung 2.13: JK-Flipflop
Zusammenfassend stellt Tabelle 2.5 die verschiedenen Typen von Flipflops anhand ihrer
Funktionsweise dar. Die linke Seite zeigt den gewünschten Übergang von Qn → Qn+1 ,
die rechte Seite gibt die Triggersignale der verschiedenen Flipfloptypen an, die für die
Übergänge benötigt werden. In der Praxis kommt häufig jeweils noch ein asynchroner
Eingänge zum Setzen (Preset) und Löschen (Clear) hinzu.

Übergang D T J K S R
0→0 0 0 0 X 0 X
0→1 1 1 1 X 1 0
1→0 0 1 X 1 0 1
1→1 1 0 X 0 X 0
Tabelle 2.5: Anregungstabelle für die gängigen Flipfloptypen
2.4 Zeitverhalten digitaler Schaltungen

In der Praxis weisen alle Gatter, aus denen Digitalschaltungen aufgebaut sind, und damit
diese selbst auch, ein spezifisches Zeitverhalten aufgrund von Verzögerungen auf. Man
fasst diese Verzögerungen als dynamische Kenndaten zusammen. Diese beschreiben z.B.
wie schnell ein Flipflop oder Latch reagiert.
Die Kenntnis dieser dynamischen Kenndaten ist elementar wichtig, um die Funktionssi-
cherheit von Schaltungen zu gewährleisten. Insbesondere dient meist das zeitliche Zusam-
menspiel von Takt- und Datensignal dazu, die Kenngröße zu definieren.
Die Setup-Zeit, Haltezeit und die Durchlaufzeit (auch Verzögerungszeit oder engl. Propa-
gation Delay) sind die drei wichtige Parameter beim Entwurf einer sequentiellen Schal-
tung.
tp
Takt
t
Q
t
Abbildung 2.14: Propagation Delay
Jede logische Schaltung hat eine endliche Verzögerungszeit. Das Propagation Delay tp
ist die charakteristische Zeit, die ein Signal benötigt, um vom Eingang des Gatters zu
dessen Ausgang zu gelangen. Für ein Flipflop entspricht das der Zeit, um dessen Ausgang
nach der aktiven Taktflanke, die letzlich der Übernahme der Daten am Eingang dient,
zu ändern. Das Propagation Delay wird normalerweise zwischen den 50%-Signalpegeln
definiert, wie in Abbildung 2.14 dargestellt.
In einer kombinatorischen Schaltung mit mehreren Stufen ist das Propagation Delay die
Summe der Propagation Delays durch jedes Element im sog. kritischen Pfad. Dieser be-
schreibt in der Schaltungstechnik den zeitlich längsten“ Pfad zwischen Ein- und Ausgang,
”
der die größte Gesamtverzögerung aufweist.

ts th
Takt
t
Daten müssen in der Setup-
und Hold-Phase stabil sein
D
t
Daten können Daten können
sich ändern sich ändern
Abbildung 2.15: Setup-Zeit und Haltezeit
Die Setup-Zeit ts (auch Vorbereitungszeit, Einschwingzeit oder engl. Setup Time) definiert
die minimale Zeitspanne, in der der Dateneingang vor der aktiven Flanke8 des Taktsignals
stabil sein muss, damit die Daten vom Taktsignal korrekt abgetastet und übernommen
werden können.
Die Haltezeit th (engl. Hold Time) definiert die Zeitspanne, in der der Dateneingang nach
der aktiven Flanke des Taktsignals immer noch stabil anliegen muss, damit die Daten vom
Taktsignal korrekt abgetastet und übernommen werden können. Beide charakterischen
Zeitspannen sind in Abbildung 2.15 dargestellt.
Das Zusammenspiel aller dynamischen Kenndaten sind in Abbildung 2.16 am Beispiel
eines D-Flipflops noch einmal zusammengefasst.
ts th
Takt
t
D
t
t pLH
Q
t
Abbildung 2.16: Zusammenspiel der dynamischen Kenndaten
Um Zustände korrekt zu speichern, erfordern alle Speicherelemente, dass die Eingangs-

daten für das charakteristische Entscheidungsintervall td = ts + th verfügbar und stabil
sind. Darüber hinaus führen alle in der Schaltung enthaltenen Gatter durch das Propa-
gation Delay tp zu zusätzlichen Verzögerungen bei der Verteilung der Eingangsdaten, die
8
Dies kann die steigende oder fallende Taktflanke sein, je nach Schaltung bzw. Komponenten.

berücksichtigt werden müssen.

Die Summe der Laufzeit(en) der kombinatorischen Logik zwischen Flipflops muss also klei-
ner sein als die Taktperiode (Kehrwert der Taktfrequenz) abzüglich Setup- und Haltezeit
der Flipflops. Bei mehreren Stufen bestimmt der kritische Pfad die maximale Taktfre-
quenz.
x D Q D Q z
1
Q Q
Clock
Abbildung 2.17: Berechnung der maximalen Taktfrequenz aus dynamischen Kenndaten
Als Beispiel für die Berechnung der maximalen Taktfrequenz für eine gegebene Schal-
tung dient Abbildung 2.17 mit den exemplarischen Werten tpF F = 10ns, tpN OT = 8ns,
tsF F = 5ns und thF F = 0, 5ns. Für die minimale Taktperiode Tmin ist die Summe aller
Verzögerungszeiten entscheidend:
Tmin = tpF F + tpN OT + tsF F = 10ns + 8ns + 5ns = 23ns
Da beide Flipflops durch den gleichen Takt versorgt werden, ändern auch beide gleichzeitig
ihren Wert, so dass in der Rechnung aufgrund des identischen Timings nur ein Flipflop
berücksichtigt ist. Durch die Bildung des Kehrwertes erhält man die maximal zulässige
Taktfrequenz für diese Schaltung:
1 1
fmax = = = 43, 48M Hz
Tmin 23ns
Da das Propagation Delay zwischen Eingang und Ausgang in der Regel größer ist als die
zugrundeliegende Haltezeit der verwendeten synchronen Elemente, sind Verletzungen der
Haltezeit in der Regel weitaus weniger problematisch, sollten aber dennoch in Betracht
gezogen werden, da jede Verletzung der dynamischen Kennwerte mit hoher Wahrschein-
lichkeit zu einem falschen oder unvorhersehbaren Verhalten der Schaltung führt. Diese
Größenbeziehung th << tp ist letztlich der Schlüssel dazu, dass eine direkte Kopplung
von Flipflop-Ausgängen auf Flipflop-Eingänge in einem synchronen System möglich ist.
Natürlich gilt dies unter der Maßgabe, dass evtl. mögliche Taktverschiebungen (engl. Clock
Skew ) vermieden werden.
Tabelle 2.6 zeigt reale Zahlenwerte für die dynamischen Kenndaten am Beispiel einer
Advance High Density (AHC) CMOS-Logikfamilie [Phil99].
ts th tpLH tpHL
6 ns 0,5 ns 11,9 ns 11,9 ns
Tabelle 2.6: Zahlenwerte für ein Philips Dual D-Flipflop 74AHC74

Das Propagation Delay tp trägt offensichtlich am meisten zur Verzögerung bei und hängt
in der Regel von der eingesetzten Schaltungstechnologie und damit auch von der Belastung
der Schaltung ab, d.h. davon wie viel Last die Schaltung treiben muss. Dies wiederum
hängt vom Leitungswiderstand und der kapazitiven Last ab. Entscheidend ist hier also die
Anzahl der an einem einzigen Ausgang angeschlossenen Gatter, die Länge der Leiterbahn
und schließlich auch die Dielektrizitätskonstante des Substratmaterials auf einem PCB
(engl. Printed Circuit Board ).
2.5 Sequentielle Grundschaltungen

Es gibt einige sequentielle Grundschaltungen, die eine breite Anwendung finden und auch
als Teilkomponente für größere Designs immer wieder eine Rolle spielen. Diese sind hier
zusammengefasst.
2.5.1 Schieberegister
Ein Schieberegister besteht aus mehreren in Reihe geschalteten Flipflops (meist D-

Flipflops), die synchron von einem gemeinsamen Taktsignal versorgt werden. In einem
n-Bit breiten Register werden die Daten pro Taktflanke jeweils um eine Stelle nach links
oder rechts verschoben
Eine der häufigsten Anwendungen von Schieberegistern ist die Seriell-Parallel-Wandlung,
sowie die Multiplikation und Division von positiven Binärzahlen mit 2. Abbildung 2.18
zeigt ein 4-Bit-Schieberegister mit serieller Eingabe und paralleler Ausgabe.
serieller D Q D Q D Q D Q
Dateneingang
Q Q Q Q
Takt
Q0 Q1 Q2 Q3
Abbildung 2.18: 4-Bit-Schieberegister
2.5.2 Zählerschaltungen
Zähler sind den Registern recht ähnlich, da beide eine kaskadierte Anordnung von mehr
als einem Flipflop mit oder ohne zusätzliche Kombinatorik umfassen. Man unterscheidet
je nach Art des Taktsignals Asynchronzähler und Synchronzähler. Die eigentliche Zählung
entspricht dabei der Anzahl angekommener Taktimpulse.
Der Asynchronzähler (auch engl. Ripple Counter ) besteht aus einer Kaskadierung von
(meist) D-Flipflops. Die einzelnen Flipflops werden dabei jeweils zeitverzögert vom vorigen
Flipflopausgang als Takt versorgt, das Taktsignal wird nur an das erste Flipflop direkt

angelegt. Das führt dazu, dass die Schaltzeiten der einzelnen Ausgänge des Zählers nicht
konstant sind, sondern von deren Position in der Schaltung abhängen. Das erste Bit hat
die kürzeste, das letzte Bit die längste Schaltzeit.
1
Q0 Q1 Q2
J Q J Q J Q
Takt
K Q K Q K Q
Takt
Q0 0 1 0 1 0 1 0 1 0
Wiederanfang
bei 000
Q1 0 0 1 1 0 0 1 1 0
Q2 0 0 0 0 1 1 1 1 0
Abbildung 2.19: Asynchroner 3-Bit Binärzähler
Die Summe aller Gatterlaufzeiten (pro Gatter z.B. 50ns) bestimmt somit die maximale
Taktfrequenz (z.B. 12-Bit Zähler mit 12 · 50ns), so dass Asynchronzähler im Betrieb in
der Regel langsamer sind als ihre synchronen Gegenstücke. Sowohl das Design als auch
die Implementierung des Asynchronzählers ist dagegen sehr einfach, wie Abbildung 2.19
zeigt. Allerdings arbeitet dieser ausschließlich mit fester Zählfolge (hoch oder runter).
Q0 Q1 Q2 Q3
&
&
1
J0 J1 J2 J3
J Q J Q J Q J Q
K0 K1 K2 K3
K Q K Q K Q K Q
Takt
Takt
Q0
Q1
Q2
Q3
Abbildung 2.20: Synchroner 3-Bit Binärzähler
Mehr Flexibilität gestattet dagegen der Synchronzähler, da dieser als rückgekoppelter Zu-
standsautomat jede erdenkliche Zählreihenfolge ermöglicht. Das Zählverhalten wird dabei
durch die Rückkopplungslogik (rein kombinatorisch) bestimmt. So können alle Flipflops
synchron mit demselben Takt versorgt werden.

Sowohl das Design als auch die Implementierung des Synchronzähler sind umso komplexer,
je höher die Anzahl an Zuständen wird. Abbildung 2.20 zeigt die Implementierung anhand
von JK-Flipflops.
Dem Entwurf der Beschaltung der Flipflops liegen folgende Überlegungen zugrunde:
• Flipflop 0 kippt mit jeder fallenden Flanke: J0 = K0 = 1
• Flipflop 1 kippt nur, wenn Q0 = 1 ist → J1 = K1 = Q0
• Flipflop 2 darf nur kippen, wenn Q0 ∧ Q1 = 1 ist → J2 = K2 = Q0 ∧ Q1
• Flipflop 3 darf nur kippen, wenn Q0 ∧ Q1 ∧ Q2 = 1 ist → J3 = K3 = Q0 ∧ Q1 ∧ Q2
Im Gegensatz zum Asynchronzähler haben alle Ausgangsbits eine konstante Laufzeit
(nach einer Verzögerungszeit ∆t liegen alle Bits des Zählers als gültiger Wert vor). Bei
diesem Zähler bestimmen die Setup- und Haltezeit der Flipflop-Eingänge die maximale
Taktfrequenz.
Zählerschaltungen finden häufig Anwendung in Schaltungen zur Ereignissynchronisati-
on und Frequenzmessung, Schätzung von Winkelpositionen bei Sensoren, sowie bei der
Zeitmessung von Ereignissen.
2.5.3 Frequenzteiler
Frequenzteiler sind Schaltungen, die die Frequenz eines Signals in einem bestimmten
Verhältnis herunterteilen. Sie sind damit sehr ähnlich zu den Zählerschaltungen, allerdings
liefern sie keine Ausgabe von internen Zählerständen. Stattdessen wird für eine bestimmte
Anzahl von Eingangsimpulsen am Ende ein einziger Ausgabeimpuls erzeugt.
Auch bei diesen Schaltungen ist sowohl ein synchroner, als auch asynchroner Aufbau
möglich, ebenso ist das Teiler- und Tastverhältnis beliebig. Dies resultiert in Realisierun-
gen, die von einfachen Flipflop-Schaltungen bis hin zu komplexen Automaten reichen.
Die wichtigsten Begriffe zum Frequenzteilerverhalten sind:
fein
• Teilerverhältnis: VT eiler = faus
thigh
• Tastverhältnis: VT ast = thigh +tlow
Das Teilerverhältnis beschreibt das Verhältnis zwischen Ein- und Ausgangsfrequenz. Das
Tastverhältnis (engl. Duty Cycle) gibt das Verhältnis zwischen Impulsdauer und Peri-
odendauer an.

3 Systematischer Schaltungsentwurf
Dieses Kapitel behandelt die elementaren Zusammenhänge zwischen der allgemeinen Be-
schreibung einer spezifischen logischen Funktionalität und dem methodischen Vorgehen
zur Entwicklung einer digitalen Schaltung zu dieser Beschreibung.
3.1 Synchrone sequentielle Schaltungen

Sequentielle Logikschaltungen zeichnen sich dadurch aus, dass sie eine endliche Anzahl
an Zuständen annehmen können, die nacheinander (sequentiell) durchlaufen werden.
Latches und Flipflops sind die Grundbausteine von sequentiellen Schaltungen. Wie bereits
in Abschnitt 2.2 erläutert, können diese Schaltungen, je nach Verwendung des Speicher-
elements, entweder zustandsgesteuert (asynchron) oder taktgesteuert ausgelegt sein. Von
synchronen sequentiellen Schaltungen spricht man, wenn alle Schaltvorgänge auf ein be-
stimmtes Taktsignal synchronisiert sind. Man verwendet dazu flankengetriggerte Flipflops
(D-, JK-, RS- oder T-Flipflops).
Schaltwerk
E A
0 & 0 >=1
0 0
0 0
Kombinatorische
Schaltung
flankengetriggerte
Flipflops
Abbildung 3.1: Allgemeiner Aufbau synchroner sequentieller Schaltungen
In Abgrenzung zu allgemeinen sequentiellen Schaltungen erfolgt bei synchronen sequen-

tiellen Schaltungen die Änderung der Zustände also zu genau definierten Zeitpunkten,
die durch das Taktsignal festgelegt sind. Welcher Zustand dann im jeweils nächsten Takt
angenommen wird, hängt wie in Abbildung 3.1 dargestellt von dem Eingang und dem ak-
tuellen Zustand (Rückkopplung) ab. Die Zustandsvariablen sind in gleichzeitig getakteten
Flipflops gespeichert.
Da eine direkte Abbildung Eingänge → Ausgänge (wie bei der Kombinatorik) nicht mehr
existiert, lässt sich die Funktion der Schaltung nicht mehr nur durch Funktions- oder
Wahrheitstabellen beschreiben. Es sind spezielle Funktionsdarstellungsformen erforder-
lich, die im Folgenden kurz vorgestellt werden.
30
KAPITEL 3. SYSTEMATISCHER SCHALTUNGSENTWURF
3.1.1 Beschreibung mittels Zeitverlaufsdiagramm
Das Zeitverlaufsdiagramm (engl. Timing Diagram) stellt ein Verhaltensdiagramm dar

und verdeutlicht dynamische Aspekte. Auf der x-Achse ist die Zeit, auf der y-Achse die
Signalzustände aufgetragen. Aufgrund der Beschränkung auf binäre Systeme kommen hier
pro Signal immer nur zwei unterschiedliche Zustandswerte (0 oder 1) über der Zeitachse
zum Einsatz.
t1 t2
Abbildung 3.2: Typischer Zeitverlauf eines RS-Flipflops
Abbildung 3.2 zeigt den typischen Zeitverlauf eines RS-Flipflops. Konzentriert man sich
auf die Eingänge bzw. Ausgänge zu den beiden Zeitpunkten t1 und t2 , ist leicht zu
erkennen, dass dieses spezifische dynamische Verhalten sich kaum durch eine einfache
Funktionstabelle darstellen liesse. Die Eingänge sind identisch, die Ausgänge jedoch un-
terschiedlich. Es liegt auf der Hand, dass beim RS-Flipflop die Ausgangswerte aus der
Vorgeschichte“ der Eingangsbeschaltung resultiert.
”
3.1.2 Beschreibung mittels Zustandsübergangsdiagramm
Eine weitere Möglichkeit, um das dynamische Verhalten einer Schaltung, einer Kompo-
nente oder eines ganzen Systems zu beschreiben, stellt das Zustandsübergangsdiagramm
(auch Zustandsdiagramm, Zustandsgraph oder engl. State Diagram) dar. Es visualisiert
die Zustände, die eine Schaltung annehmen kann, und welche Ereignisse (in diesem Sinne
Signaländerungen) Zustandsübergänge bewirken. Wie später noch gezeigt wird, werden
Zustandsdiagramme oft zur Beschreibung von endlichen Automaten eingesetzt,
S=1
R=0
S =0 S beliebig
R beliebig
Q=0 Q=1 R=0
S=0
R=1
Abbildung 3.3: Zustandsübergangsdiagramm eines RS-Flipflops
Abbildung 3.3 zeigt das Zustandsübergangsdiagramm eines RS-Flipflops. Allgemein wer-

den die Zustände einer Schaltung durch Kreise dargestellt. Die Zustände sind durch Pfeile

verbunden, wobei die Pfeile die Zustandsänderung symbolisieren. Die Beschriftung der
Pfeile dient zur Darstellung der Eingangsbelegung, die zu der Zustandsänderung führt.
Beide Darstellungsformen, das Zeitverlaufsdiagramm und der Zustandsgraph, sind eleme-
natare Werkzeuge zur Durchführung von Schaltungsanalyse und Schaltungssynthese.
3.2 Schaltungsanalyse
Einfache Systeme können meist auf rein intuitivem Weg entworfen werden. Bei einer
größeren Komplexität, inbesondere beim Entwurf synchroner sequentieller Schaltungen
bedarf es jedoch eines systematischen Entwurfsverfahrens. Man nennt dies Schaltungs-
synthese.
Bevor die Schaltungssynthese behandelt wird, steht die inverse Vorgehensweise – die Schal-
tungsanalyse – im Fokus. Durch Umkehrung aller durchlaufenen Schritte ist die Synthese
einer derartigen Schaltung direkt ableitbar.
Eingang x & Ausgang z

>=1
J Q
1 K Q
Clock
J Q
1 K Q
Abbildung 3.4: Beispielschaltung für die Schaltungsanalyse
Die Schaltungsanalyse soll anhand einer gegebenen synchronen sequentiellen Schaltung

gemäß Abbildung 3.4 exemplarisch durchgeführt werden. Ziel der Analyse soll schließlich
eine abstrakte Beschreibung der Schaltung in Form eines Zustandsgraphen sein.
Die Vorgehensweise folgt einem festen Ablauf, der sich in folgende Schritte gliedert:
1. Funktionsgleichungen ermitteln
2. KV-Tafeln für die Eingänge J und K der Flipflops (zzgl. Ausgang z) aufstellen
3. Zustandsfolgetabelle (Nachfolgezustände aus Zustandskombinationen und
möglichen Eingangskombinationen) aufstellen
4. vereinfachte Zustandsfolgetabelle mit symbolischen Namen für die Zustandskombi-
nationen ermitteln
5. Zustandsgraph aus vereinfachter Tabelle generieren

Eingang x & Ausgang z

>=1
y1
J1 Q
y1
1 K1 Q
Clock
J0 Q
y0 y0
1 K0 Q
Abbildung 3.5: Beschriftung der Zustandsspeicher und Ausgänge
Bei einer Schaltung mit mehr als einem Flipflop empfiehlt sich eine eindeutige Kennzeich-
nung aller Ein- und Ausgänge der vorhandenen Flipflops, wie in Abbildung 3.5 umgesetzt.
Die Eingänge des oberen Flipflops (im Folgenden Flipflop 1) werden mit J1 und K1 be-
zeichnet, die des unteren Flipflops (Flipflop 0) mit J0 und K0 .
Da die Flipflops als Zustandsspeicher genutzt werden, werden deren Ausgänge jeweils
mit y1 , respektive y0 benannt. Die Bezeichnung mit y für Zustände wird sich durch den
gesamten Analyse- und Synthese-Prozess ziehen.
Gemäß des oben erläuterten Ablaufs werden zunächst die Funktionsgleichungen aus der
Abbildung abgeleitet.
Schritt 1
z = (x + y1 ) · y0 = x · y0 + y1 · y0
J1 = x
K1 = x
J0 = x · y0 + y1 · y0
K0 = J0
Anschließend werden die KV-Tafeln für die Eingänge J und K der Flipflops aufgestellt.
Zusätzlich muss auch die KV-Tafel für den Ausgang z gebildet werden. Da im vorliegenden
Beispiel z = J0 gilt, entspricht die KV-Tafel von z der von J0 . Abbildung 3.6 zeigt die
fertigen Tabellen.

Schritt 2
y1 y1
J1 K1
y0 y0
0 0 0 0 1 1 1 1
x 1 1 1 1 x 0 0 0 0
y1 y1
J0 K0
y0 y0
0 0 0 1 1 1 1 0
x 1 0 0 1 x 0 1 1 0
Abbildung 3.6: KV-Tafeln für die Schaltungsanalyse
Nun wird die Zustandsfolgetabelle aufgestellt. In dieser werden alle Nachfolgezustände für
alle möglichen Zustandskombinationen in Verbindung mit allen Eingangskombinationen
spezifiziert.
Schritt 3
Gegenwärtiger Nächster Zustand Gegenwärtiger

Zustand (Folgezustand) Ausgang
x=0 x=1 x=0 x=1
y1 y0 y1+ y0+ y1+ y0+ z z
0 0 0 0 1 1 0 1
0 1 0 0 1 0 0 0
1 1 0 0 1 0 0 0
1 0 0 1 1 1 1 1
Tabelle 3.1: Zustandsfolgetabelle für die Schaltungsanalyse
In der vorliegenden Schaltung gibt es zwei binäre Zustandsspeicher (Flipflop 1 und Flipflop
0) mit jeweils einem logischen Ausgang (0 oder 1). Daher müssen in der Zustandsfolgeta-
belle, wie in Tabelle 3.1 zu sehen, insgesamt 22 = 4 unterschiedliche Zustände vorgesehen
werden. Diese werden zunächst in die erste Spalte unter Gegenwärtiger Zustand“ aufge-
”
listet, und zwar in der den KV-Tafeln entsprechenden Kombinationsreihenfolge (bezüglich
y0 und y1 ). Dies erleichtert das Herauslesen der Werte und das Eintragen an die korrekte
Stelle in der Zustandsfolgetabelle.
Anschließend wird durch Vergleich mit den in Tabelle 3.2 gegebenen Beschaltungskombi-
nationen des JK-Flipflops ermittelt, welcher Folgezustand (gekennzeichnet mit einem Plus

Übergang J K
0→0 0 X
0→1 1 X
1→0 X 1
1→1 X 0
Tabelle 3.2: Übergangstabelle des JK-Flipflops
über der Zustandsvariable, z.B. y0+ ) vom gegenwärtigen Zustand aus bei entsprechender
Belegung der Eingänge J und K erreicht wird. Dieser wird für die Zustandsvariablen y0
und y1 getrennt in die mittleren Spalten unter Nächster Zustand“ eingetragen, jeweils
”
abhängig davon, ob am Eingang x eine 0 oder 1 anliegt.
Die letzte Spalte stellt den Gegenwärtigen Ausgang“ dar und lässt sich durch einfache
”
Drehung der entsprechenden KV-Tafel um 90 Grad im Uhrzeigersinn und anschließende
Spiegelung an der vertikalen Achse bestimmen. Wegen z = J0 wird hier die KV-Tafel von
J0 zugrundegelegt.
Im nächsten Schritt wird die Zustandsfolgetabelle nun vereinfacht. Für die zu ermittelnde
abstrakte Darstellung der Funktionalität anhand eines Zustandsgraphen ist das interne
Verhalten nämlich irrelevant. Nur das Verhalten der Ausgänge ist wichtig. Daher werden
für die konkreten Zustandskombinationen (y1 y0 ) einfach symbolische Namen vergeben.
Die Zuordnung ist frei wählbar, es empfiehlt sich der Übersicht halber jedoch bei der in
der Zustandsfolgetabelle zugrundegelegten Abfolge zu bleiben, so geschehen bei folgender
Zuordung:
a = 00, b = 01, c = 11, d = 10
Tabelle 3.3 zeigt die vereinfachte Tabelle, basierend auf der oben genannten Zuordnung.
Schritt 4
Gegenwärtiger Folgezustand, Folgezustand,

Zustand gegenw. Ausgang gegenw. Ausgang
bei x = 0 bei x = 1
a a, 0 c, 1
b a, 0 d, 0
c a, 0 d, 0
d b, 1 c, 1
Tabelle 3.3: Vereinfachte Zustandsfolgetabelle für die Schaltungsanalyse
Im letzten Schritt kann schließlich der Zustandsgraph direkt aus der vereinfachten Zu-
standsfolgetabelle abgeleitet werden. Die Zustände sind durch ihre symbolischen Namen

benannt und durch Pfeile verbunden. An den Pfeilen steht jeweils die Eingangsbelegung,
die zu der Zustandsänderung führt, sowie durch ein Komma getrennt die begleitende
Ausgangsbelegung. Abbildung 3.7 zeigt das Resultat.
Schritt 5
0/0
a 0/0
0/0
1/1
b c
1/0 1/1
0/1 d 1/0
Abbildung 3.7: Zustandsgraph zur Schaltungsanalyse
Mit dem ermittelten Zustandsgraphen ist die Schaltungsanalyse somit beendet.
3.3 Schaltungsynthese
In umgekehrter Reihenfolge entspricht die soeben erläuterte Prozedur genau der Schal-
tungssynthese. Bei dieser wird ausgehend von einer abstrakten Funktionsbeschreibung
eine dazu passende Schaltung entwickelt.
Eine Schaltungssynthese beginnt mit einer eindeutigen Beschreibung der Funktionalität.
Ausgangspunkt ist meist eine verbale Problembeschreibung, die zunächst in eine visuelle
Darstellung in Form eines Zustandsdiagrammes überführt werden muss. Manchmal liegt
diese als Teil der Aufgabenbeschreibung bereits vor.
Die Vorgehensweise bei der Schltungssynthese ist durch folgende Schritte gekennzeich-
net:
1. Zustandsgraph mit vollständigen Zuständen und zugehörigen Ausgangswerten auf-
stellen
2. vereinfachte Zustandsfolgetabelle gemäß des Zustandsgraphen ableiten
3. symbolische Namen durch Zustandskombinationen (Binärkombinationen) ersetzen
und Zustandsfolgetabelle für Binärkombinationen der Zustände aufstellen
4. Flipflop-Typ wählen und KV-Diagramm für Übergangsverhalten des gewählten
Flipflops aufstellen
5. Gleichungen für die Flipflop-Eingänge mittels KV-Diagramm ableiten

6. Schaltung zeichnen (aus KV-Diagramm-Resultat oder direkt aus Zustandsfolgeta-

belle)
7. ggf. exemplarisches Timing-Diagramm zeichnen
Im Folgenden werden alle Schritte der Schaltungssynthese anhand einer konkreten exem-
plarischen Aufgabenstellung demonstriert.
Es soll eine synchrone sequentielle Schaltung entwickelt werden, die über einen Eingang
x eine bestimmte Datensequenz erkennt und entsprechend den Ausgang z setzt. Die zu
erkennende Datensequenz bestehe aus 3 aufeinanderfolgenden (zum Taktsignal synchro-
nen) Einsen, die beispielsweise den Beginn von zu empfangenen Daten markiere. Nach
Erkennung der zweiten 1 soll der Ausgang, der normalerweise auf logisch 0 verweilt, für
genau einen Takt auf 1 gesetzt werden. Anschließend soll der Ausgang unabhängig vom
Eingang permanent auf 0 bleiben.
Gemäß der Beschreibung wird zunächst der Zustandsgraph (Abbildung 3.8) hergeleitet.
Schritt 1
0/0 1/0
1/0 1/0 1/1

a b c d
0/0 0/0 0/0
Abbildung 3.8: Zustandsgraph zur Schaltungssynthese
Anschließend wird aus dem Zustandsgraphen direkt die vereinfachte Zustandsfolgetabelle,

wie in Tabelle 3.4 dargestellt, abgelesen.
Schritt 2
Gegenwärtiger Folgezustand, Folgezustand,

Zustand gegenw. Ausgang gegenw. Ausgang
bei x = 0 bei x = 1
a a, 0 b, 0
b a, 0 c, 0
c a, 0 d, 1
d d, 0 d, 0
Tabelle 3.4: Vereinfachte Zustandsfolgetabelle für die Schaltungssynthese
Den symbolischen Namen werden im nächsten Schritt konkrete Zustandskombinationen

(y1 y0 ) zugeordnet. Um zu demonstrieren, dass die Zuordnung frei wählbar ist, wird in
diesem Beispiel Folgendes festgelegt:

a = 00, b = 01, c = 10, d = 11
Es ist zu erkennen, dass diese Zuordnung nicht unmittelbar der Abfolge der Zustandsvaria-
blen in den KV-Tafeln folgt. Bezüglich der Variablen c und d wird daher eine Umsortierung
erforderlich, wie in den letzten beiden Zeilen in Tabelle 3.5 ersichtlich.
Schritt 3
Gegenwärtiger Nächster Zustand Gegenwärtiger

Zustand (Folgezustand) Ausgang
x=0 x=1 x=0 x=1
y1 y0 y1+ y0+ y1+ y0+ z z
0 0 0 0 0 1 0 0
0 1 0 0 1 0 0 0
1 1 1 1 1 1 0 0
1 0 0 0 1 1 0 1
Tabelle 3.5: Zustandsfolgetabelle für die Schaltungssynthese
Nun muss ein geeigneter Flipflop-Typ gewählt werden. Basierend auf diesem werden dann
die KV-Tafeln für das Übergangsverhalten der gewählten Flipflops aufgestellt. Falls es
keinen konkreten Hinweis auf den Einsatz eines bestimmten anderen Flipflop-Typs9 gibt,
kann ein JK-Flipflop verwendet werden. Die Schaltungssynthese mit JK-Flipflops ist ins-
besondere aufgrund der don’t care“-Möglichkeiten (vgl. Tabelle 3.2) vorteilhaft.
”
Die Zustandsfolgetabelle (Tabelle 3.5) definiert welcher Folgezustand vom gegenwärtigen
Zustand aus erreicht wird, abhängig davon, ob am Eingang x = 0 oder x = 1 anliegt. Das
Vorhandensein von 22 = 4 unterschiedlichen Zuständen lässt wiederum auf zwei binäre
Zustandsspeicher (Flipflop 1 und Flipflop 0) schließen.
Durch Vergleich mit Tabelle 3.2 können die Eingangsbelegungen für J und K für alle ge-
zeigten Kombinationen ermittelt werden. Diese werden in die entsprechenden KV-Tafeln
eingetragen. Die KV-Tafel für den Ausgang z kann wieder direkt aus der Zustandsfolge-
tabelle abgelesen werden. Abbildung 3.18 zeigt alle ermittelten KV-Tafeln.
9
Für den Einsatz von D-Flipflops spricht z.B. ein Verhalten, bei dem der Folgezustand immer nur vom
aktuellen Zustand ohne Abhängigkeit von einem eventuell vorhandenen Eingang abhängt.

Schritt 4
y1 y1
J1 K1
y0 y0
0 0 X X X X 0 1
x 0 1 X X x X X 0 0
y1 y1
J0 K0
y0 y0
0 X X 0 X 1 0 X
x 1 X X 1 x X 1 0 X
y1
z
y0
0 0 0 0
x 0 0 0 1
Abbildung 3.9: KV-Tafeln für die Schaltungssynthese
Aus den KV-Tafeln können anschließend die Funktionsgleichungen für alle Eingänge J
und K, sowie für den Ausgang z abgelesen werden.
Schritt 5
z = x · y1 · y0
J1 = y0 · x
K1 = y0 · x
J0 = x
K0 = y1
Mit den ermittelten Funktionsgleichungen kann nun auch die Schaltung gezeichnet werden.
Für eine übersichtliche Darstellung empfiehlt es sich, zunächst die Zustandsspeicher einzu-
zeichnen und anschließend die Eingangsbelegungen durch Hinzufügen der entsprechenden
Logikgatter in der Nähe der Flipflopeingänge vorzusehen. Erst zum Schluß werden die
Verbindungsleitungen eingezeichnet.

Schritt 6
Eingang x 1
& y1
&
J1 Q
y1 & Ausgang z
y1
& K1 Q
Clock
y0
J0 Q
y0
y0
K0 Q
Abbildung 3.10: Resultat der Schaltungssynthese als Schaltbild
Der Vollständigkeit halber wird auch der letzte Schritt gezeigt, das Aufzeichnen eines
exemplarischen Timing-Diagramms.
Schritt 7
Abbildung 3.11: Zeitverlaufsdiagramm zum Schaltungssynthesebeispiel
Abbildung 3.11 zeigt das Zeitverhalten des Schaltungssynthesebeispiels. Hier äußert sich
ein typisches Problem einer bestimmten Art von Schaltungen: Die Zustandsvariablen und
der Eingang wirken sich direkt auf den Ausgang aus. So kommt es dazu, dass sog. Spikes
am Ausgang auftreten, wenn das Eingangssignal sich nicht synchron zum Systemtakt
verhält. Das Verhalten der nachfolgenden Schaltung (sofern vorhanden) kann dadurch
unter Umständen dramatisch beeinflusst werden. Abhilfe schaffen hier nur der Einsatz
anderer Schaltungstypen auf der einen Seite oder eine Synchronisation der Eingangssignale
auf der anderen Seite. Weitere Details dazu finden sich im nächsten Abschnitt.

3.4 Endliche Automaten

Schaltwerke sind typische Beispiel für Automaten. Ein Automat beschreibt zunächst
grundsätzlich ein System, das auf seinen Eingang reagiert und einen Ausgang generiert.
Dieser Ausgang ist einerseits von dem Eingangssignal, andererseits eindeutig von dem
momentanen Zustand des Systems abhängig.
Automaten spielen eine wichtige Rolle in Steuerungs- und Kontrollaufgaben, beispiels-
weise bei der Ablaufsteuerung in Mikroprozessoren oder bei der Kommunikation zwi-
schen verschiedenen Baugruppen. Automaten sind eines der wichtigsten Konzepte zum
Hardware-Entwurf.
Sequentielle Schaltungen verfügen über eine endliche Anzahl von inneren Zuständen.
Ebenso ist die Menge der möglichen Eingabezeichen (Eingabealphabet) und die Men-
ge der möglichen Ausgabezeichen (Ausgabealphabet) begrenzt. Abstrakt gesehen lassen
sie sich also als endlicher Automat (engl. Finite State Machine, kurz: FSM) beschreiben.
Man unterscheidet folgende Automatentypen:
• Mealy-Automaten
• Moore-Automaten
• Medwedjew-Automaten
Alle Schaltungen der genannten Automatentypen besitzen einen Zustandsspeicher und
können zeitabhängige Ausgangssignale generieren. Somit ist es möglich mit ihnen einen
sequentiellen Ablauf zu modellieren. Sie sind in ihrem Logikverhalten äquivalent, d.h. in-
einander umformbar, unterscheiden sich jedoch geringfügig in ihrem zeitlichen Verhalten.
Beispielsweise reagiert der Mealy-Automat auf Eingangssignale schneller. Nachfolgend
werden die verschiedenen FSM Automatenmodelle detailliert beleuchtet.
3.4.1 Mealy Automat
Jede FSM besteht im wesentlichen aus einem Übergangsschaltnetz, einem Zustandsspei-

cher, sowie einem Ausgangsschaltnetz.
E/A
Z
Übergangs- Speicher Z
schaltnetz Z+
(Verzögerung)
Z Ausgangs-
E schaltnetz A
Abbildung 3.12: Mealy Automatenmodell
Die Eingangssignale E werden in dem Übergangsschaltnetz verarbeitet und erzeugen den

Folgezustand Z + des Automaten. Dieser wird bei Anliegen eines Taktsignals in den Zu-
standsspeicher – im einfachsten Fall ein Flipfop oder (falls mehrere Bits umfassend) ein

Register – übernommen. Daher verfügt der Speicher in jedem Fall auch mindestens über
ein zusätzliches Eingangssignal, nämlich das Taktsignal10 (meist Clk für engl. Clock ).
Der im Zustandsregister aktuell gespeicherte Zustand Z wirkt über das Ausgangs-
schaltnetz auf den Ausgang A. Zugleich hat der aktuelle Zustand Z durch eine
Rückkopplung auch Einfluss auf die Verarbeitung der Eingangssignale, da er den Aus-
gangspunkt für den nächsten Übergang definiert. Daher resultiert letztlich auch der Begriff
Übergangsschaltnetz.
Neben der Abhängigkeit vom aktuellen inneren Zustand Z ist für den Mealy Automaten
die direkte Beeinflussung des Ausganges durch die Eingänge E entscheidend. Dies zeigt
Abbildung 3.12 durch den unteren Pfeil im Blockschaltbild, der die direkte Verbindung
vom Eingang zum Ausgangsschaltnetz symbolisiert. Damit reagieren beim Mealy Automat
die Ausgänge unmittelbar auf Eingangsänderungen. Man nennt diesen Automatentyp
daher übergangsorientiert“.
”
Die Abhängkeit vom aktuellen Eingangssignal wird auch im zugehörigen Zustandsgra-
phen deutlich. Dies ist rechts vom Blockschaltbild in Abbildung 3.12 dargestellt. An den
Übergängen, in gewohnter Weise durch Pfeile markiert, werden die beeinflussenden Ein-
und Ausgänge festgelegt. Die Ausgangsänderungen erfolgen somit asynchron gegenüber
dem vorhandenen Takt.
Z
Übergangs-
Flipflops
schaltnetz Z+ Z
Synchronisation Ausgangs-
E schaltnetz A
E
Clock C
Timing-Diagramm
zur Clock C
... t n-1 tn t n-1 ...
Abbildung 3.13: Modifiziertes Mealy Automatenmodell
Verglichen mit den anderen Automatentypen benötigt ein Mealy Automat in der Regel
weniger Zustände für die gleiche logische Realisierung, da pro Ausgangsänderung kein
eigener Zustand, sondern lediglich ein Übergang erforderlich ist. Dieses Verhalten kann
jedoch zu kombinatorischen Schleifen und damit instabilem Verhalten in der Gesamtschal-
tung führen.
Um dies zu umgehen, wird der Mealy Automat auch gern in einer modifizierten Variante
als synchrones (getaktetes) Schaltwerk mit synchronisierten Eingangssignalen verwendet.
Abbildung 3.13 zeigt das entsprechende Blockschaltbild dazu. Der synchrone Mealy Au-
tomat unterscheidet sich vom Moore Automat nur durch die zusätzlichen Eingänge E am
10
Der Übersicht halber ist dieses hier nicht gezeigt. In einem späteren Abschnitt wird darauf noch Bezug
genommen.

Ausgangsschaltnetz. Die Ausgangsänderungen erfolgen synchron mit dem vorhandenen

Takt (Clock C).
3.4.2 Moore Automat
Im Unterschied zum Mealy Automat existiert beim Moore Automat keine direkte Verbin-
dung zwischen Eingangssignalen E und dem Ausgangsschaltnetz. Dies geht eindeutig aus
dem Blockschaltbild in Abbildung 6.13 hervor. Die Eingänge wirken somit nicht unmittel-
bar auf den Ausgang, stattdessen wird dieser über das Ausgangsschaltnetz ausschließlich
aus dem aktuellen Zustand Z hergeleitet. Man nennt diesen Automatentyp daher zu-
”
standsorientiert“.
Z Z
Übergangs- Speicher Ausgangs-
schaltnetz Z+
(Verzögerung)
Z
schaltnetz A A
E
Abbildung 3.14: Moore Automatenmodell
Auch der zugehörige Zustandsgraph verdeutlicht die unmittelbare Beeinflussung des Aus-
ganges durch den aktuellen Zustand, wie rechts vom Blockschaltbild in Abbildung 6.13
dargestellt. Den Zuständen, in gewohnter Weise durch Kreise markiert, ist jeweils ein
definierter Ausgang A zugeordnet. Da der Automat in Abhängigkeit seines aktuellen Zu-
standes reagiert, erfolgt auch die Bearbeitung der Eingangssignale zustandsabhängig. An
den durch Pfeile dargestellten Übergängen wird nur der beeinflussende Eingang festgelegt.
Die Ausgangsänderungen erfolgen somit synchron zum vorhandenen Takt.
Der Logikaufwand zur Implementierung eines Moore Automaten ist üblicherweise größer
als bei Mealy, da pro Ausgangsänderung ein eigener Zustand realisiert werden muss.
x x/y
s2 x x
s1 s3 s1 s2 s3
y
Takt Takt
s1 s2 s3 s1 s2 s3
x x
y y
Abbildung 3.15: Unterschiede im Zeitverhalten zwischen Mealy und Moore
Neben der Anzahl der nötigen Zustände ist insbesondere das Zeitverhalten grundsätzlich
unterschiedlich zwischen Moore und Mealy Automat. Dies ist in Abbildung 3.15 ge-

genübergestellt. Da beim Moore Automat (linke Seite) die Eingangsfunktion nur auf den
Zustandsübergang Einfluss hat, bleibt der Ausgang während der gesamten Taktzyklen
stabil. Durch die Verknüpfung von Eingangs- und Ausgangsfunktion bei Mealy (rechte
Seite) verhält sich das Ausgangssignal asynchron.
3.4.3 Medwedjew Automat
Der Medwedjew Automat ist eine Sonderform des Moore Automaten. Wie dieser arbeitet
der Medwedjew Automat zustandsorientiert. Ausgangsänderung erfolgen nur synchron
mit dem Takt. In Abgrenzung zum Moore Automat verfügt der Medwedjew Automat
allerdings nicht über ein gesondertes Ausgangsschaltnetz, wie aus Abbildung 3.16 ersicht-
lich. Stattdessen entspricht der Ausgang jeweils der aktuellen Zustandscodierung.
Z
Übergangs- Speicher Z=A
schaltnetz Z+
(Verzögerung)
A
E
Abbildung 3.16: Medwedjew Automatenmodell
Aufgrund dieser Beziehung korrespondiert die Anzahl der Zustandsspeicher direkt mit der
Anzahl der Ausgangsvariablen. Es ist also eine spezielle Zustandscodierung erforderlich,
die beim Entwurf des Medwedjew Automaten berücksichtigt werden muss. Üblicherweise
führt dies zu einem höheren Bedarf an Flipflop-Ressourcen als bei Moore.
Nachfolgend wird der Entwurf eines Medwedjew Automaten exemplarisch skizziert. Viele,
aber nicht alle, FSM besitzen einen Eingang. Hier soll ein spezieller Zähler ohne separaten
Eingang mit der folgenden zyklischen Zählsequenz realisiert werden:
0 − 1 − 3 − 2 − 6 − 4 − 5 − 7
Als Ausgabe dient entsprechend des Medwedjew Modells der Zustand selbst. Zunächst
wird der Zustandsgraph aus der beschriebenen Zählweise hergeleitet (Abbildung 3.17).

0
1 7
3 5
2 4
Abbildung 3.17: Zustandsgraph für Medwedjew-Automatenrealisierung
Anschließend wird aus dem Zustandsgraphen die Zustandsfolgetabelle, wie in Tabelle 3.6
dargestellt, ermittelt. Die Ausgänge brauchen nicht extra spezifiziert zu werden, da sie
identisch mit den Zustandsvariablen sind.
Gegenwärtiger Zustand Folgezustand

y0 y1 y2 y0+ y1+ y2+
0 0 0 0 0 1
0 0 1 0 1 1
0 1 1 0 1 0
0 1 0 1 1 0
1 1 0 1 0 0
1 0 0 1 0 1
1 0 1 1 1 1
1 1 1 0 0 0
Tabelle 3.6: Zustandsfolgetabelle für Medwedjew Zähler
Eine möglichst geschickte Wahl des Flipflop-Typen kann die resultierende Schaltungskom-
plexität günstig beeinflussen. Da wie aus Tabelle 3.6 ersichtlich der Folgezustand jeweils
nur vom gegenwärtigen Zustand abhängt, ist ein D-Flipflop hier das Mittel der Wahl.
Tabelle 3.7 zeigt die zu verwendende Übergangstabelle.

Übergang D
0→0 0
0→1 1
1→0 0
1→1 1
Tabelle 3.7: Übergangstabelle des D-Flipflops
Damit kann direkt mit der Emittlung der KV-Tafeln für die Eingänge D0 , D1 und D2 der
drei D-Flipflops fortgefahren werden. Abbildung 3.18 zeigt die vollständigen Tabellen.
y1 y1
D0 D1
y2 y2
0 0 0 1 0 1 1 1
y0 1 1 0 1 y0 0 1 0 0
y1
D2
y2
1 1 0 0
y0 1 1 0 0
Abbildung 3.18: KV-Tafeln für den D-Eingang der Flipflops
Die Funktionsgleichungen werden anschließend aus den KV-Tafeln abgelesen. Durch

Überführung der Gleichungen in die graphische Repräsentation erhält man schließlich
das in Abbildung 3.19 gezeigte Schaltbild.
D0 = y0 · y1 + y1 · y2
D1 = y1 · y2 + y0 · y1
D2 = y1

Set0 Set1 Set2
&
SET
>=1 D0 Q Q0
&
CLR
Q
&
SET
>=1 D1 Q Q1
&
CLR
Q
SET
D2 Q Q2
Takt
CLR
Q
Reset2 Reset1 Reset0
Abbildung 3.19: Schaltbild für Medwedjew-Automatenrealisierung
Zur Demonstration des zeitlichen Verhaltens zeigt Abbildung 3.20 schließlich noch das
Timing-Diagramm zu dem hergeleiteten Medwedjew-Automaten.
Takt
Reset
Q 0 1 3 2 6 4 5 7 0 1
Abbildung 3.20: Zeitverhalten des hergeleiteten Medwedjew-Automaten
Damit wurden nun alle drei Automatentypen hinreichend beleuchtet. Welcher Automa-
tentyp Anwendung findet, hängt von der jeweils zu lösenden Problemstellung ab. Als
Faustregel gilt, dass die beste Lösung diejenige ist, die die Anforderungen erfüllt und
dabei am wenigsten Ressourcen benötigt oder am einfachsten zu implementieren ist. Wel-
che Anforderungen konkret an einen Entwurf gestellt werden, kann je nach Designziel
(Geschwindigkeit, Komplexität, Leistungsbedarf, etc.) stark variieren.

3.4.4 Entwurfsmethoden für Automaten
Es existieren in der Praxis verschiedene Möglichkeiten zur Modellierung eines Zustands-

automaten. Der Entwurf digitaler Hardware auf Gatter- und Register-Transfer-Ebene er-
folgt heutzutage typischerweise mit Hilfe von Hardwarebeschreibungssprachen wie VHDL.
Auch innerhalb der Beschreibung mittels VHDL können unterschiedliche Ansätze zum
Tragen kommen.
Die manuelle Synthese entspricht genau der in Abschnitt 3.3 skizzierten Vorgehensweise.
Zunächst wird die Zustandsübergangstabelle aufgestellt und daraus die Gleichungen für
die verwendeten Flipflops abgeleitet. Die Flipflops für die Modellierung der Zustandsbits
werden gemäß geltender Designrichtlinien in VHDL beschrieben. Die VHDL Beschreibung
wird ergänzt durch die kombinatorische Verschaltung der Flipflops. Das Problem bei die-
ser Vorgehensweise besteht darin, dass der resultierende VHDL Entwurf bei größeren
Automaten sehr zeitintensiv und unübersichtlich wird.
Weitaus übersichtlicher, besser erweiterbar und zumeist intuitiver gestaltet sich die Be-
schreibung in VHDL durch getrennte Funktionsblöcke des FSM-Modells. Dies läßt eine
präzise Separierung von Daten- und Steuerpfad zu. Dies schlägt sich in einer entspre-
chend getrennt ausgelegten Verwendung von kombinatorischen und taktsynchronen Pro-
zessen nieder. Es existieren unterschiedliche Varianten (Ein-Prozess-, Zwei-Prozess-, Drei-
Prozess- Beschreibung), je nach Kapselung der drei Grundelemente (Übergangsschaltnetz,
Zustandsspeicher, Ausgangsschaltnetz) der Zustandsautomaten.
Abbildung 3.21: Graphischer FSM Entry
Auch die Beschreibung in graphischer Form anhand eines Zustandsgraphen ist möglich. So
verfügt beispielsweise die FPGA-Entwicklungsumgebung von Altera11 , Quartus II, über
einen graphischen FSM Entry (Abbildung 3.21). Nach Eingabe lässt sich die FSM in (syn-
thesefähigem) VHDL ausspeisen. Diese Vorgehensweise hat den großen Vorteil, dass sie
sowohl die Eingabe als auch die Visualisierung zusammenhängend vereint. Allerdings sind
wie üblich bei einer abstrakten Beschreibungsform die Eingriffsmöglichkeiten limitiert.
Kapitel 4 gibt eine detaillierte Einführung in die Schaltungsentwicklung mit VHDL.
11
Alle programmierbaren Logikbausteine von Altera werden von einer gemeinsamen Designumgebung
unterstützt. Die Quartus II Software ist in verschiedenen Editionen, u.a. auch einer kostenlosen web-
basierten Edition erhältlich. Altera Quartus II heißt mittlerweile Quartus Prime und trägt seit der
Übernahme von Intel auch den Zusatz Intel Quartus Prime.

4 Rechnergestützter Schaltungsentwurf
mit VHDL
In diesem Kapitel wird die Hardwarebeschreibung mit VHDL detailliert vorgestellt und
erläutert. Neben der Theorie zur Beschreibung einer Schaltung mit VHDL werden an-
hand zahlreicher Beispiele vertiefende Aspekte des Designs und der Modellierung für die
Schaltungssynthese dargestellt.
4.1 Einführung in VHDL

Nachdem in Abschnitt 2.1.3 bereits einige wichtige Konstrukte, die VHDL zum Schal-
tungsentwurf zur Verfügung stellt, vorgestellt und erläutert wurden, werden hier nun die
wesentlichen Konzepte von VHDL aufgezeigt und eine umfassende Einführung in Syntax
und Semantik der Sprache VHDL gegeben.
VHDL ist eine Beschreibungssprache für digitale Schaltungen. Der Name stellt ein
Akronym aus dem Begriff Very High Speed Integrated Circuit Hardware Description
”
Language“ dar. Die Sprache entstammt einer Initiative innerhalb des VHSIC - Programms
(Very High Speed Integrated Circuits) des amerikanischen Verteidigungsministeriums
Ende der 1970er und Anfang der 1980er Jahre. Der Zweck bestand in der Uneinheitlich-
keit vorhandener Werkzeuge, von denen die meisten für komplexe Hardware-Entwürfe
zudem ungeeignet waren.
Die Entwicklung von VHDL umfasste die folgenden Meilensteine:
• 1981 wurde VHDL erstmals als Hardware-Beschreibungssprache vorgeschlagen
• 1986 wurde VHDL als IEEE-Standard vorgeschlagen
• 1987 wurde der erste VHDL-Standard (IEEE-1076-1987) verabschiedet [VHDL87]
• 1993 wurde ein überarbeiteter VHDL-Standard (IEEE-1076-1993) verabschiedet
[VHDL93]
• 2002 wurde der aktuelle VHDL-Standard (IEEE-1076-2002) verabschiedet
[VHDL02]
VHDL hat sich in der Industrie und der akademischen Welt neben Verilog weltweit als
Standard für die Beschreibung von Hardware bei
• Dokumentation
• Simulation
• Synthese
etabliert. VHDL sind Komplexität großer digitaler Designs beherrschbar (Gatteranzahl)
49
KAPITEL 4. RECHNERGESTÜTZTER SCHALTUNGSENTWURF MIT VHDL
Trotz der Ähnlichkeit in der Syntax zur Programmiersprache C (und C++) weist VHDL
einen elementaten Unterschied auf: Die inhärente Nebenläufigkeit von Anweisungen und
Prozessen spiegelt zwar das Hardwareverhalten wider, erfordert jedoch ein hohes Maß an
Sorgfalt bei der Beschreibung. Es muss deutlich darauf verwiesen werden, dass VHDL
eine Modellierungssprache ist und keine Programmiersprache.
4.1.1 Aufbau von VHDL Designs
Ergänzend zu den in Abschnitt 2.1.3 bereits dargelegten Formvorgaben soll hier noch
einmal kurz der prinzipielle Aufbau von VHDL Designs geschildert werden. Abbildung 4.1
illustriert den Aufbau und die elementaren Bestandteile eines VHDL Designs, analog dazu
zeigt Listing 4.1 das Gerüst einer VHDL Beschreibung.
Eingangs- Ausgangs-
signale Signalmodi
Entwurfseinheit
Y out
in Schnittstellen (Ports)
inout
buffer
Architektur
Funktionalität:
Kombinatorische
oder
sequentielle Logik
Abbildung 4.1: Hardware-Sicht eines VHDL Designs
ENTITY E_NAME IS
-- Portliste
END E_NAME ;
ARCHITECTURE A_NAME OF E_NAME IS
-- Deklarationen
-- ( Liste interner Signale )
BEGIN
-- Nebenlaefige Zuweisungen
-- ( S i g n a l z u w e i s u n g e n )
END A_NAME ;
Listing 4.1: Gerüst eines VHDL Designs
Die Kombination aus Entity und Architecture ist das grundlegendste Konstrukt in VHDL.
Die Entity definiert den Namen der Entwurfseinheit (Black Box) und legt die Schnittstelle

des Funktionsblockes nach außen fest. Die Deklaration der Anschlüsse erfolgt über Port-
Anweisung, die Anschlüsse werden mit Signalen verbunden. Für die Synthese muss der
Entity-Name unbedingt mit dem Dateinamen übereinstimmen.
Die Architecture beschreibt das funktionale Innenleben. Dabei ist sowohl eine strukturelle
Beschreibung, als auch eine Beschreibung auf Verhaltensebene (Behavioural Description)
möglich. Es gibt klare Vorgaben für die Art der Anweisungen. So existiert die Möglichkeit
logische Operationen (AND, OR, etc.) anzuwenden, arithmetische Operatoren (+, -, etc.)
zu verwenden oder auch bestimmte vorgesehene Verhaltensausdrücke (if-then-else, etc.)
zu formulieren.
Entities und Architectures werden zusammen verwendet, um eine bestimmte Funktiona-
lität zu definieren. Die Architecture bezieht sich immer auf eine bestimmte Entity. Aller-
dings sind auch mehrere Architectures pro Design möglich. Zum Beispiel könnten für eine
Entity mehrere Architectures erstellt werden, die jeweils auf ein bestimmtes Entwurfsziel
optimiert sind:
• Performance
• Schaltungskomplexität
• Leistungsaufnahme
• Einfachheit der Testbarkeit (engl. Design For Testability, kurz DFT) oder der Si-
mulation
Die Auswahl der Architecture bei Vorhandensein mehrerer Designalternativen geschieht
mit der Configuration. Standardmäßig existiert eine Configuration für jede Entity, so-
fern nicht anders definiert ist dies die zuletzt synthetisierte Architecture für diese Entity.
Bei einer zusammenhängenden Beschreibung von Entity und Architecture in einer ge-
meinsamen Datei ist dies relativ eindeutig. Die Configuration muss für diesen Fall also
nicht explizit angegeben werden. Oft wird ein großes FPGA-Design in viele Entity- /
Architecture-Kombinationen unterteilt.
4.1.2 Design Flow mit VHDL
Ein typischer Design Flow mit VHDL beinhaltet die in Abbildung 4.2 dargestellten Schrit-
te. Neben VHDL als Eingabe ist auch ein graphischer Entry möglich (vgl. Schaltplan).
Die Synthese beschreibt die Übersetzung des HDL Codes in eine architekturspezifische
Netzliste. Diese beschreibt die Struktur eines Hardware-Designs auf Register-Transfer
Ebene (RTL), wie in Abbildung 4.3 beispielhaft dargestellt. Es gilt zu beachten, dass
VHDL ursprünglich nicht zum Zweck der Synthese, sondern zur Spezifikation und Do-
kumentation entwickelt wurde. Daher existieren auch zahlreiche VHDL-Anweisungen, die
nicht synthetisierbar sind. Wird VHDL zur Synthese benutzt, ist unbedingt auf einen
synthesefähigen Code zu achten.
Nach der Synthese erfolgt die Implementierung basierend auf der Zieltechnologie. Dazu
wird die Netzliste auf die Zieltechnologie (Bibliothekselemente einer ASIC-Bibliothek oder
eines FPGA-Devices) abgebildet.

VHDL-Code Schaltplan Testbench
Funktionale
Constraints Synthese
Simulation
Implementierung
Translation Floorplanning,
Layout
Map
Timing Analyse,
Place & Route DRC Checks
Zeitbehaftete
Konfigurations-
Tapeout Simulation
datei
FPGA ASIC
Abbildung 4.2: Design Flow mit VHDL
Field Programmable Gate Arrays (FPGAs) wurden bereits in Abschnitt 1.1 vorgestellt
und werden in Abschnitt 6.1 ausführlich behandelt. Diese programmierbaren Logikbau-
steine, die anfangs vornehmlich der Emulation von Schaltungsentwürfen für den späteren
ASIC Entwurf dienten, werden heutzutage nicht mehr nur für das Prototyping genutzt.
Sie finden indes Anwendung in verschiedenen Implementierungen, zum Beispiel im Auto-
motive Bereich, in Rechenzentren, in der Telekommunikation, dem Hochfrequenzhandel
und in der professionellen Videoverarbeitung und Formatkonvertierung.
Application Specific Integrated Circuits (ASICs) sind, wie der Name schon sagt, nicht-
standardisierte integrierte Schaltungen, die für einen bestimmten Zweck oder eine be-
stimmte Anwendung entwickelt werden. Aufgrund der Freiheitsgrade beim Design kann
ein ASIC Entwurf, insbesondere ein Full-Custom Design ohne Verwendung vordefinierter
Blöcke, sehr komplex werden. Zudem sind die Kosten für einen ASIC Entwurf immens
(geq 200.000 Euro, je nach Größe), so dass die Entwicklung sich nur bei hohen Stückzahlen
rentiert. ASICs sind nicht Gegenstand des Curriculums und werden daher nicht weiter
beleuchtet.
SET SET
Kombinatorische
D Q D Q
Kombinatorische Kombinatorische
Logik Logik Logik
CLR Q CLR Q
Clock
Abbildung 4.3: Netzliste nach Synthese
Die Implementierung für einen FPGA umfasst die Schritte Translation“, ”Mapping“ und
”
Place & Route“. Zunächst wird die Netzliste mit den einschränkenden Vorgaben (Cons-
”
traints) in eine zusammenhängende Repräsentation basierend auf architekturspezifischen

elementaren Elementen (sog. Primitives) überführt (Translation). Dann wird diese Re-
präsentation auf die verfügbaren Ressourcen abgebildet (Mapping). Schließlich findet die
Platzierung und Verdrahtung entsprechend den (timingrelevanten) Constraints auf den
FPGA Ressourcen statt.
Der Schritt des Placement & Routing ist einer der kritischsten für die spätere Performance
der Schaltung auf dem FPGA und in hohem Maße abhängig von der Qualität des VHDL
Codes. Die maximale Taktfrequenz, mit der die Schaltung betrieben werden kann, ist oft
von Details in der Art der Formulierung auf VHDL-Ebene abhängig. Umso wichtiger ist
es, dass stets die Hardware-Entsprechung des Codes beim Entwurf berücksichtigt wird
und Einzelheiten der Implementierung sorgfältig abgewogen und entsprechend umgesetzt
werden. Ein einziger kombinatorischer Logikpfad mit langer Verzögerung kann ausreichen,
um die gesamte Schaltung auszubremsen.
Mit Hilfe einer Konfigurationsdatei (Bitstream) kann das Design letztlich auf den FPGA
geladen werden. Begleitend zum Entwurf empfiehlt sich die Verifikation in verschiedenen
Etappen. Dies geschieht durch Simulation, zunächst auf funktionaler Ebene (siehe Block
Funktionale Simulation“ in Abbildung 4.2). Die Simulation erfordert die Nachbildung
”
der späteren Umgebung des Designs mit Hilfe von aussagekräftigen Simulationsstimuli
(Eingabewerten) in Form einer Testbench. Kapitel 5 beschäftigt sich noch ausführlich mit
diesem Thema.
Basierend auf den Simulationsergebnissen sind pro Design meist mehrere Iterationen
zur Behebung von Logikfehlern oder zur Optimierung des Verhaltens erforderlich. Nach
Durchlaufen aller genannten Implementierungsschritte existieren schließlich konkrete Ti-
minginformationen – insbesondere unter Berücksichtigung der Verdrahtung – für eine
zeitbehaftete Simulation (siehe entsprechenden Block in Abbildung 4.2)). Man nennt die-
se auch Post-Layout Simulation oder Post-R&R Simulation. Anhand dieser kann ermittelt
werden, ob alle Timing Constraints und die Zielfrequenzvorgabe für das Design eingehal-
ten werden konnten. Falls nicht, sind Anpassungen nötig.
4.1.3 Typologie und VHDL Operatoren
VHDL ist eine stark typisierte Sprache. Jedes Signal, jede Variable oder Konstante muss
einem bestimmten Datentyp zugeordnet sein und kann nur mit Ausdrücken des gleichen
Datentyps kombiniert werden. Ein Datentyp definiert eine Menge von festen und stati-
schen Werten. Eine Vermischung von Datentypen ist nicht zulässig und muss ggf. durch
explizite Typkonvertierung umgangen werden.
Es gibt einige grundlegende Datentypen, die in VHDL bereits vordefiniert sind. Für die
Verwendung anderer Datentypen ist die Einbindung von Packages nötig, in denen neben
spezifischen Datentypen auch Funktionen, Konstanten und Komponenten definiert sein
können. Diese wiederum sind in Bibliotheken (engl. Libraries) gegliedert. Dieses Konzept
verfolgt die Aufgabe Hardware Designs zu vereinfachen und Standardelemente einfach
verfügbar zu machen. Es ist auch möglich eigene benutzerdefinierte Datentypen anzu-
legen, wodurch höhere Abstraktionsebenen in VHDL Beschreibungen realisiert werden
können.

Für den Einstieg in den Hardware-Entwurf genügt die Kenntnis der folgenden drei Ty-
pen:
• boolean (für logische Abfragen, z.B. if)
• bit bzw. bit vector (für den Entwurf)
• std logic bzw. std logic vector (für Entwurf und Simulation)
Die Datentypen boolean“ und bit“ sind in VHDL bereits standardmäßig enthalten. Für
” ”
den Hardware-Entwurf sind die Möglichkeiten bei der Verwendung des bit“-Datentyps,
”
der nur die Elemente ’0’ und ’1’ umfasst, sehr beschränkt. So existiert beispielsweise keine
Möglichkeit Signale auf hochohmig zu legen, wie es bei Bus-Standards wie I2C üblich ist.
Auch ist eine Unterscheidung in schwache und starke Signale nicht möglich, was allerdings
für den ASIC-Entwurf unabdingbar ist. Daher wird für den Hardware-Entwurf und die
Simulation der 9-wertige Datentyp std logic“ empfohlen.
”
LIBRARY ieee ;
USE ieee . std_lo gic_1164 . ALL ;
Listing 4.2: Einbindung der Bibliothek ieee.std logic 1164
Für die Verwendung von std logic“ muss die Bibliothek ieee.std logic 1164, wie in Lis-
”
ting 4.2 gezeigt, eingebunden werden. Mit Hilfe der Angabe all“ werden alle Sub-
”
Elemente des Package der Bibliothek sichtbar. Tabelle 4.1 zeigt den Wertevorrat, sowie
den Einsatzzweck.
Wert Bedeutung Einsatz

’0’ starke logische ’0’ (entspricht Synthese und Simulation
bit-Datentyp)
’1’ starke logische ’1’ (entspricht Synthese und Simulation
bit-Datentyp)
’L’ schwache logische ’0’ Synthese, technisch: Pull-Down Wider-
stand, Open Source (offener Emitter)
’H’ schwache logische ’1’ Synthese technisch: Pull-Up Widerstand,
Open Drain (offener Kollektor)
’W’ schwach undefiniert Simulation (Erkennung von Buskonflikten
zwischen ’L’ und ’H’)
’Z’ hochohmig Synthese und Simulation, techn.: Tri-State
Buffer)
’U’ nicht initialisiert Simulation
’X’ undefiniert, mehrere Treiber Simulation (Erkennung von Buskonflikten)
’-’ Don’t Care (Zustand irrelevant) Synthese (Wertetabellen)
Tabelle 4.1: Wertevorrat beim Datentyp std logic“

”

Bei std logic“ können mehrere Treiber für ein Signal existieren, z.B. für bidirektionale
”
Busse mit mehreren Treibern. Eine Auflösungsfunktion entscheidet, welches Signal sich
durchsetzt. Diese ist ebenfalls Teil der std logic 1164 Package Spezifikation. Alternativ
kann der Datentyp std ulogic“ (u für unresolved ) verwendet werden, der mehrere Treiber
”
verbietet. Signale dürfen nur in einem Prozess, bzw. einer nebenläufigen Anweisungen eine
Wertzuweisung erfahren. Damit ist dieser Datentyp weniger flexibel, lässt aber die einfache
Erkennung versehentlicher Mehrfachzuweisungen durch entsprechende Fehlermeldungen
im Simulator zu.
Signale gleichen Datentyps können zu Vektoren zusammengefasst werden und entsprechen
der Deklaration von Bussignalen. Ein bit vector stellt beispielsweise einen aus mehreren
bit-Signalen bestehenden Bus dar. Dieser kann entweder aufsteigend, z.B. als bit vector(0
to 7), oder absteigend als bit vector(7 downto 0) deklariert werden. Gleiches gilt auch
für einen std logic vector. Eine Deklaration mit absteigender Indizierung entspricht der
in der Digitaltechnik üblichen Interpretation von Binärzahlen und ist daher vorzuziehen.
Listing 4.3 zeigt gebräuchliche Möglichkeiten der Signalzuweisung. Es sei darauf hingewie-
sen, dass die gezeigten Zuweisungsbeispiele nur Ausschnitte darstellen und in der gezeigten
Form durch die gleichzeitigen Signalzuweisungen Konflikte verursachen würden.
Wenn alle Bits eines Busses mit demselben Wert belegt werden sollen, empfiehlt sich das
others-Konstrukt. Einzelne konstante Werte müssen in Hochkommata, mehrere konstante
Werte in Anführungszeichen eingeschlossen werden. Mit dem Konkatenationsoperator &
lassen sich Zeichen und Zeichenketten zusammenfügen.
SIGNAL s_ABC , s_DEF : s t d _ l o g i c _ v e c t o r (7 DOWNTO 0) ;
s_ABC <= ( OTHERS = > ’1 ’) ; -- Setzen von s_ABC auf 0 xFF

s_DEF <= ( OTHERS = > ’0 ’) ; -- Setzen von s_DEF auf 0 x00
s_ABC <= " OO11O1O1 " ; -- Zuweisung von 0 x35 zu s_ABC

s_DEF <= s_ABC (7 DOWNTO 4) & " 1100 " -- Uebernahme von Bits 7 -4 aus s_ABC
-- und Konkatenation mit 0 x6
s_ABC (3) <= ’1 ’; -- Setzen des Bit 3 auf 1

s_ABC (2 DOWNTO 0) <= " 010 " -- Setzen der drei untersten Bits aus 010
Listing 4.3: Möglichkeiten der Signalzuweisung
Um Daten miteinander zu verknüpfen, stellt VHDL unterschiedliche Operatoren bereit:

• logische Operatoren
• Vergleichsoperatoren
• arithmetische Operatoren
• Schiebeoperatoren
Logische Operatoren werden verwendet, um kombinatorische Logik zu erzeugen. Die logi-
schen Operatoren umfassen die assoziativen Verknüpfungen AND, OR, XOR und NOT,
sowie die nichtassoziativen NAND, NOR und XNOR12 . Bei Ausdrücken mit mehr als zwei
12
Nichtassoziative Verknüpfungen verbieten die Verknüpfung von mehr als zwei Operanden, da das Er-
gebnis nicht eindeutig bestimmt werden kann.

Signalen empfiehlt sich die Klammerung zur Verdeutlichung der Priorität der logischen
Operatoren. Bei nichtassoziativen Verknüpfungen ist dies sogar zwingend. Die logischen
Operatoren sind für die Datentypen boolean, bit und std logic (auch als Vektor) defi-
niert.
Relationale Operatoren (Vergleichsoperatoren) werden verwendet, um Gleichheits-
oder Größenvergleichsfunktionen zu implementieren. VHDL stellt die Operatoren =
(Gleichheit), /= (Ungleichheit), < (kleiner), > (größer), <= (kleiner gleich), >=
(größer gleich) zur Verfügung. Die Gleichheitsoperatoren sind für alle Datentypen
definiert, die Größenvergleichsoperatoren sind dagegen nur für numerische Typen,
Aufzählungstypen und einige Arrays definiert. Als Ergebnis wird immer der Datentyp
boolean zurückgeliefert.
Arithmetische Operatoren werden verwendet, um arithmetische Funktionsblöcke zu er-
stellen. Zu den arithmetischen Operatoren zählen: + (Addition), - (Subtraktion), * (Mul-
tiplikation), / (Division), MOD (Modulo), REM (Rest), ABS (Betrag), sowie ** (Poten-
zierung). Diese Operatoren sind für numerische Datentypen wie integer und real definiert,
meist werden allerdings die Datentypen signed bzw. unsigned verwendet, die arithmeti-
sche Interpretationen vom std logic Datentyp sind. Zu deren Verwendung muss die Bi-
bliothek ieee.numeric std eingebunden werden. Es sei anzumerken, dass die Verwendung
arithmetischer Operatoren in einem Entwurf dazu führen kann, dass sehr große Mengen
kombinatorischer Logik erzeugt werden. Daher ist hier besondere Sorgfalt gefragt.
Schiebeoperatoren sind für Vektoren vom Typ boolean, bit und std logic definiert und
wurden erst im IEEE-1076-1993 [VHDL93] Standard eingeführt. Enthalten sind die lo-
gischen Schiebeoperatoren SLL (Shift Left) und SRL (Shift Right), die arithmetischen
Schiebeoperatoren SLA (Shift Left) und SRA (Shift Right), sowie die Rotationsoperato-
ren ROL (Rotate Left) und ROR (Rotate Right).
4.2 Modellierungskonzepte im Architecture Entwurf

Für die Beschreibung der Architecture gibt es verschiedene Möglichkeiten. Grob unter-
scheidet man zwischen
• Verhaltensbeschreibung
• Strukturbeschreibung
Die Verhaltensbeschreibung dient der Beschreibung der Funktionalität. Dies kann wieder-
um auf zwei verschiedene Arten mit spezifischen Abbildungsmöglichkeiten erfolgen. Zum
einen existiert die Datenflussbeschreibung bestehend aus nebenläufigen Signalzuweisun-
gen von booleschen Gleichungen. Zum anderen gibt es die Prozessbeschreibung, die die
mit Hilfe von Prozessen die Funktionalität beschreibt.
Die Strukturbeschreibung dient der Modul- und Hierarchiebildung und basiert auf der In-
stanziierung und Verbindung von Komponenten. Dazu werden bereits vorhandene VHDL-
Module oder Bibliothekselemente verwendet. Die hierarchische bzw. modulare Verwen-
dung von vorhandenen Schaltungsteilen dient einem übersichtlichen Entwurf, macht auch
komplexe Schaltungsentwürfe handhabbar und kann den Gesamtentwurf beschleunigen.

Anstatt eine Architecture ausschließlich in einem der genannten Entwurfsstile zu beschrei-

ben, können diese auch kombiniert werden.
4.2.1 Verhaltensbeschreibung durch Modellierung des Datenflusses
Zunächst wird die Verhaltensbeschreibung anhand des Datenfluss-Stils beschrieben. Die

Datenflussbeschreibung modelliert den Datenfluss über kombinatorische logische Funktio-
nen ohne Prozesse. Die Abhängigkeiten von Daten in der Beschreibung entsprechen denen
in einer typischen Hardware-Implementierung. Die Datenflussbeschreibung impliziert da-
mit direkt eine entsprechende Gate-Level Implementierung.
Datenflussbeschreibungen bestehen aus einer oder mehreren nebenläufigen Signalzuwei-
sungen. Sie stellen einen Spezialfall der Verhaltensbeschreibung dar, wobei dies in der
Literatur oft nicht eindeutig unterschieden wird.
S
EN S IB IA Y
1 x x x 0
IA 0
Y 0 1 0 x 0
IB 1 0 1 1 x 1
0 0 x 0 0
0 0 x 1 1
EN
Abbildung 4.4: Schaltsymbol und Funktionstabelle eines 2:1-Multiplexers
Die in Abschnitt 2.1.3 gezeigte, erste VHDL-Beschreibung war bereits ein Beispiel für
eine Datenflussbeschreibung. Hier folgt ein weiteres Beispiel anhand eines 2:1-Multiplexers
mit Enable-Signal (low-active). Abbildung 4.4 zeigt das Schaltsymbol und die zugehörige
Funktionstabelle.
ENTITY Mux2x1 IS
PORT ( IA , IB : IN bit ; -- data input
S : IN bit ; -- select input
E : IN bit ; -- enable
Y1 , Y2 , Y3 : OUT bit
);
END Mux2x1 ;
ARCHITECTURE Mux OF Mux2x1 IS
BEGIN -- Variante 1
Y1 <= ( IA AND NOT E AND NOT S ) OR
( IB AND NOT E AND S ) ;
-- ------- -- Variante 2
WITH S SELECT
Y2 <= ( IA AND NOT E ) WHEN ’0 ’ ,
( IB AND NOT E ) WHEN ’1 ’;
-- ------- -- Variante 3
Y3 <= ( IA AND NOT E ) WHEN S = ’0 ’ ELSE
( IB AND NOT E ) ;
END Mux ;
Listing 4.4: Unterschiedliche Beschreibungsformen der Signalzuweisung

Die Spezifikation der Funktionalität des 2:1-Multiplexers erfolgt in Listing 4.4 in drei un-
terschiedlichen Beschreibungsformen. Würden diese alle auf denselben Ausgang Y geleitet
werden, würde es aufgrund von mehreren Treibern zu einem Signalkonflikt kommen. Statt
einem Ausgang Y bedient sich die VHDL-Beschreibung daher drei Ausgängen Y 1, Y 2 und
Y 3.
Das Signal Y 1 ist der Ausgang von Variante 1. Hier liegt eine unbedingte Signalzuweisung
vor. Diese besteht aus einer simplen Zuweisung.
Das Signal Y 2 ist der Ausgang von Variante 2. Man spricht hier von einer selektive Si-
gnalzuweisung. Aus einer Reihe gleichberechtigter Möglichkeiten wird je nach erfüllter
Bedingung – gegeben durch das with select“ - Konstrukt – eine ausgewählt. Die in dem
”
Konstrukt angegebenen Optionen müssen sich gegenseitig ausschließen, d.h. eine Aus-
wahlmöglichkeit kann nicht mehr als einmal verwendet werden. Darüber hinaus müssen
alle möglichen Werte des durch with“ angegebenen Signals in der Auflistung der Op-
”
tionen enthalten sein. Diese Art der Signalzuweisung entspricht in der Umsetzung einer
Multiplexerstruktur.
Variante 3 liefert das Ausgangssignal Y 3. Hier liegt eine bedingte Signalzuweisung vor,
zu erkennen an der when else“ - Formulierung (vergleichbar mit einem if then else“ -
” ”
Konstrukt). Bei dieser Art der Signalzuweisung werden die Ausdrücke nach der when“-
”
Klausel nacheinander ausgewertet bis ein wahrer Ausdruck gefunden wird. Die Zuwei-
sung, die diesem wahren Ausdruck entspricht, wird durchgeführt. Infolgedessen haben die
zuerst ausgewerteten Ausdrücke eine höhere Priorität als die späteren. Wenn keiner der
Ausdrücke zutreffend ist, hat die letzte Zuordnung Bestand. In der Implementierung führt
diese Art der Beschreibung zu einer Verschachtelung von Gattern und damit funktional
zu einem Prioritäts-Encoder.
Grundsätzlich gilt bei Datenflussbeschreibungen darauf zu achten, dass mehrere Zuwei-
sungen auf ein- und dasselbe Signal unbedingt vermieden werden müssen. Aufgrund der
Nebenläufigkeit der Zuweisungen entstehen hierbei Konflikte (Kurzschlüsse).
4.2.2 Verhaltensbeschreibungen durch Prozesse
Eine andere Form der Verhaltensbeschreibung ist der Prozess. Ein Prozess stellt zudem die
Umgebung für sequentiell abgearbeitete Anweisungen zur Verfügung – eine Möglichkeit,
die ausschließlich mit Prozessen umgesetzt werden kann.
Alle bisher behandelten VHDL-Signalzuweisungen waren nebenläufig. Die Anweisungen
wurden unabhängig voneinander sofort ausgeführt und ergaben in der Schaltungssynthese
kombinatorische, asynchrone Schaltnetze. Zuweisungen wirken dabei unmittelbar, wenn
sich ein Signal auf der rechten Seite der Signalzuweisung ändert. Damit lassen sich nur
sehr einfacher Funktionsblöcke realiseren. Für komplexere digitale Funktionsblöcke ist die
Verwendung von Prozessen unabdingbar.
Prozesse bestehen aus einer Folge sequentieller Anweisungen, die bei Aktvierung des Pro-
zesses nacheinander ausgeführt werden. Deutlich wird dieser Unterschied in Abbildung 4.5.

Datenflussbeschreibung Prozessbeschreibung
Begin Begin
Anweisung Anweisung
Anweisung Anweisung
Anweisung Anweisung
End End
Abbildung 4.5: Unterschied zwischen nebenläufigen und sequentiellen Anweisungen
In der Hardware existieren natürlich keine Prozesse13 , sondern diese stellen lediglich in der
Beschreibungssprache VHDL ein Konstrukt dar, mit dessen Hilfe sich synchrone Schalt-
werke synthetisieren lassen. Das Synthesewerkzeug versucht also die Anweisungen auf
entsprechende Hardwarefunktionselemente abzubilden. So lassen sich Schaltungen mit
zeitlichen Signalabfolgen realisieren (z.B. Zähler).
Mit Hilfe von Prozessen ist die Modellierung prozeduraler Vorgänge, wie Verzweigungen,
Schleifen, etc. möglich. Mehrere Prozesse (in einer Architecture) werden dabei wie Kombi-
natorik nebenläufig abgearbeitet und entsprechen in der Umsetzung parallelen Schaltungs-
teilen. Der Informationsaustausch zwischen Prozessen erfolgt durch Verwendung lokaler
Signale der Architecture.
Die Verwendung eines Bezeichners (Label) für Prozesse ist optional. Der Aufbau eines
Prozesses gliedert sich in:
• Sensitivitätsliste (alternativ: wait-Anweisungen)
• Deklarationsteil mit eigenen Datentypen, Konstanten oder Variablen
• Ausführungsteil (zwischen begin und end process)
Die Sensitivitätsliste gibt die Signale an, auf die der Prozess reagiert und die Änderungen
in den Anweisungen des Prozesses bewirken. Sie wird dazu verwendet, den Zustand einer
Schaltung zwischen Änderungen beizubehalten. Dies bezieht sich auf das Verhalten in
der Simulation. Der Prozess wird für die Simulation über die Sensitivitätsliste aktiviert,
wenn sich ein Signal der Sensitivitätsliste ändert ( Event“). Infolgedessen wird der Prozess
”
(erneut) ausgewertet.
Dadurch wird die Konsistenz zwischen Simulation und Synthese sichergestellt. Die Sen-
sitivitätsliste dient nur der Simulation und hat keinen Einfluss auf das Syntheseergebnis.
Sie muss allerdings für synthesefähige Prozesse zwingend vorhanden sein. Doch selbst
13
Daher ist von Formulierungen der Art Auf dem FPGA läuft ein Prozess...“ dringlichst abzusehen.
”
Prozesse laufen auf CPUs. Auf FPGAs werden Schaltungen implementiert.

bei unvollständiger oder überausgefüllter Senstitivitätsliste bleibt das Syntheseergebnis

gleich. Allerdings würde unter Umständen das Simulationsergebnis diesem Syntheseer-
gebnis nicht mehr entsprechen. Daher ist die korrekte Angabe der Sensitivitätsliste unab-
dingbar.
Alternativ zur Sensitivitätsliste können wait-Anweisungen verwendet werden. Da die-
se zwar simulations- aber nicht synthesefähig sind, empfiehlt sich dies allerdings aus-
schließlich für Beschreibungen, für die eine Synthesefähigkeit nicht benötigt wird. Dies ist
zum Beispiel in Testbenches (vgl. Abschnitt 5.1) zur Angabe von Verzögerungszeiten der
Fall.
Im Deklarationsteil können Variablen und Konstanten deklariert, sowie eigene Daten-
typen angelegt werden. Konstanten legen einmalig Werte fest. Dies kann lokal für den
Prozess, als auch für die gesamte Architecture erfolgen. Innerhalb des Prozesses können
Variable unterschiedlicher Datentypen verwendet werden. Variablen speichern temporär
Werte und werden sequentiell im Prozess benutzt. Sie besitzen ein anderes Zeitverhalten
als Signale und sind zudem nur lokal verwendbar, d.h. ihr Wert ist außerhalb des Prozesses
nicht zugreifbar. Die Sprache VDHL gestattet zudem die Deklaration beliebiger eigener
Datentypen.
Der Ausführungsteil umfasst sequentielle Anweisungen, die in begin und end geklammert
sind. Erlaubt sind unbedingte Signalzuweisungen und sequentielle Anweisungen, selektive
und bedingte Zuweisungen sind nicht zulässig. Stattdessen existiert die Möglichkeit, case-
und if-Anweisungen zu verwenden.
if
elsif
elsif
...
else
Abbildung 4.6: Typische if-then-else“-Anweisung im Prozess

”
Prozesse werden in einer (impliziten) Endlosschleife durchlaufen. Die Aktualisierung aller

Signalzuweisungen erfolgt immer erst am Prozessende. Dies hat den Hintergrund, dass das
Ergebnis der Simulation unabhängig von der Reihenfolge der Prozesse im Quelltext bzw.
von der Simulationsreihenfolge sein muss. Durch diese Art der Auswertung ist es innerhalb
des Prozesses nicht möglich auf aktuelle, d.h. im selben Prozessdurchlauf zugewiesene
Werte zuzugreifen14 . Da alle Zuweisungen im Prozess sequentiell interpretiert werden,
ermöglicht dies allerdings die konfliktfreie mehrfache Zuweisung auf ein- und dasselbe
14
Mit Variablen ist dies möglich, allerdings ist bei dieser Praxis Vorsicht geboten.

Signal. Der tatsächlich übernommene Signalwert bei Mehrfachzuweisung innerhalb eines

Prozesses ist der Wert der zuletzt ausgeführten Signalzuweisung.
ENTITY Priority IS
PORT ( A : IN bit_vector (3 DOWNTO 0) ;
Y : OUT bit_vector (1 DOWNTO 0)
);
END Priority ;
ARCHITECTURE Prio OF Priority IS
BEGIN
PROCESS ( A )
BEGIN
Y <= " 00 " ; -- Default Zuweisung
IF ( A (3) = ’1 ’) THEN -- erste Bedingung
Y <= " 11 " ;
ELSIF ( A (2) = ’1 ’) THEN -- zweite Bedingung
Y <= " 10 " ;
ELSIF ( A (1) = ’1 ’) THEN -- dritte Bedingung
Y <= " 01 " ;
ELSIF ( A (0) = ’1 ’) THEN -- vierte Bedingung
Y <= " 00 " ;
END IF ;
END PROCESS ;
END Prio ;
Listing 4.5: Beispiel eines Prioritäts-Encoders
a
A[3]
Y~1
2 A[2] 0
1'h1 1 Y[1..0]
A[3..0]
A[2]
Y~0 A[3]
1 A[1] 0 Y~2
0
1'h0 1
1'h1 1
Abbildung 4.7: Syntheseergebnis des Prioritäts-Encoders
Prozesse und nebenläufige Anweisungen können äquivalent verwendet werden, d.h. jede
nebenläufige Signalzuweisung kann auch als Prozess formuliert werden. Andersherum gilt
diese Analogie nicht. Sequentielle Signalzuweisungen sind ausschließlich innerhalb eines
Prozesses möglich. Wie bei Datenflussbeschreibungen ist grundsätzlich auch bei Prozess-
beschreibungen auf eine sorgfältige Praxis der Signalzuweisungen zu achten. Signale, denen
in einem Prozess ein Wert zugewiesen wird, dürfen außerhalb des Prozesses keinen Wert
zugewiesen bekommen.
Innerhalb eines Prozesses existieren spezielle Konstrukte zur Schaltungsbeschreibung. Ei-
ne davon ist die if-then-else“-Anweisung, deren Prinzip in Abbildung 4.6 verdeutlicht
”
wird. Diese entspricht dem when else“-Konstrukt in der Datenflussmodellierung. Durch
”
die Schachtelung von Bedingungen ergeben sich unterschiedliche Prioräten, die in der
Synthese je nach Verzweigungen entweder zu Multiplexern oder einem Prioritätsencoder
(sequentielle Modellierung) führen.

Durch die Priorisierung ist die Reihenfolge bei der Abfrage der Bedingungen entschei-
dend. Die Bedingungen sind voneinander unabhängig und können sich auf unterschied-
liche Prüfgegenstände beziehen. Ein Abschluss der Abfrage ohne ‘else“ ist syntaktisch
erlaubt, führt allerdings zu einer unvollständigen Spezifikation.
Listing 4.5 zeigt die Beschreibung eines Prioritäts-Encoders in VHDL im Rahmen ei-
nes kombinatorischen Prozesses. Wenn eine if-Anweisung nicht vollständig spezifiziert ist,
d.h. wenn kein else-Zweig explizit angegeben ist, muss auf den zuletzt zugewiesenen Wert
zurückgegriffen werden. Das Synthesewerkzeug fügt dazu ein speicherndes Element in
Form eines Latches ein. Dies ist allerdings ungewollt, da es die Schaltungskomplexität auf-
bläht, den Entwurf unübersichtlich macht (Stichwort: unsichtbare Speicher, d.h. Speicher,
die im Entwurf nicht explizit spezifiziert sind) und dem Prinzip einer kombinatorischen
Schaltung widerspricht, in dem der Ausgang ausschließlich eine Funktion des Eingangs
ohne internen Zustand (Speicher) sein soll.
Ein weiterer praktischer Aspekt besteht darin, dass moderne FPGAs zugunsten der Lo-
gikdichte mittlerweile auf einen Latch-Modus in den Flipflops verzichten. Daher würde die
Latch-Funktion mit Hilfe von Lookup-Tables (LUTs) emuliert werden, was in der Pra-
xis zu signifikanten Routing-Verzögerungen und damit schlechter Timing Performance
führt. Um die ungewollte Generierung von Latches zu vermeiden, sollte eine if-Anweisung
immer mit einem else-Zweig abgeschlossen werden. Alternativ hat die Zuweisung eines
Default-Wertes an den Ausgang vor der Abfrage den gleichen Effekt. Die zweitgenannte
Möglichkeit ist in Listing 4.5 umgesetzt.
case
when1 when2 when3 … when others
Abbildung 4.8: Typische case“-Anweisung im Prozess

”
Das Syntheseergebnis der VHDL-Beschreibung ist in Abbildung 4.7 dargestellt. Die Kenn-
zeichnung am Gatter (hier: Multiplexer) gibt die Bitbreite und den Wert der angelegten
Konstante an: 1’h1 → Bitbreite 1 / Wert 1 in Hexadezimaldarstellung und 1’h0 → Bit-
breite 1 / Wert 0 in Hexadezimaldarstellung.
Anders als die if-then-else“-Anweisung stellt die case“-Anweisung eine Mehrfach-
” ”
Verzweigung dar, bei der sich alle Auswahloptionen auf den gleichen Prüfgegenstand
beziehen, wie in Abbildung 4.8 skizziert. Diese Art der Abfrage entspricht dem with
”
select“-Konstrukt in der Datenflussmodellierung.
In der Hardwareumsetzung resultiert daraus eine Multiplexerstruktur (sequentielle Mo-
dellierung) oder ein Decoder. Auch Wertetabellen lassen sich komfortabel umsetzen, was
insbesondere für den FPGA-Entwurf sehr interessant ist, da die Tabellen bis zu einer be-
stimmten Größe praktisch unverändert in die Lookup-Tables (LUTs) der konfigurierbaren
Logikblöcke (engl. Configurable Logic Blocks, kurz: CLBs) geschrieben werden, wodurch
die erwünschte Schaltnetzfunktion realisiert wird.
Durch die Auswahl verschiedener Optionen für denselben Prüfgegenstand ist die Reihen-
folge der Optionen beliebig. Diese müssen sich allerdings gegenseitig ausschließen, d.h.

keine Auswahloption darf in zwei oder mehr Verzweigungen berücksichtigt werden. Fer-
ner müssen alle möglichen Werte für den abzufragenden Prüfgegenstand vorkommen. Mit
Hilfe des others“-Zweiges kann ein Default-Fall konstruiert werden, der immer dann zum
”
Tragen kommt, wenn keine der zuvor gelisteten Bedingungen erfüllt wird.
ENTITY Mux2x1New IS
PORT ( IA , IB : IN bit ;
S : IN bit ;
E : IN bit ;
Y : OUT bit
);
END Mux2x1New ;
ARCHITECTURE CaseMux OF Mux2x1New IS
BEGIN
PROCESS ( IA , IB , S , E )
BEGIN
IF ( E = ’0 ’) THEN
CASE S IS
WHEN ’0 ’ = > Y <= IA ;
WHEN ’1 ’ = > Y <= IB ;
WHEN OTHERS = > Y <= ’0 ’;
END CASE ;
ELSE
Y <= ’0 ’;
END IF ;
END PROCESS ;
END CaseMux ;
Listing 4.6: Beispiel eines 2:1-Multiplexer
E
S Y~1
1'h0 0
Y~0
0 1 Y
IA
1
IB
Abbildung 4.9: Syntheseergebnis des 2:1-Multiplexers
Listing 4.6 zeigt die Beschreibung eines 2:1-Multiplexers mit Enable-Signal in VHDL, das
zugehörige Syntheseergebnis ist in Abbildung 4.9 dargestellt.
Für die Beschreibung synchroner Schaltungen ist ein eindeutiger Umgang mit Taktsigna-
len erforderlich. Dieser ist durch den sog. taktsynchronen Rahmen gegeben, der wie in
Listing 4.7 gezeigt aus einer Abfrage des Clock-Signals am Anfang des Prozesses defi-
niert ist. Durch die Formulierung CLOCK = ’1’ and CLOCK’event wird die steigende
Flanke des Taktsignals abgefragt. Entsprechend ließe sich auch die fallende Flanke durch
eine Abfrage auf CLOCK = ’0’ beschreiben. Das Signalattribut event ist Bestandteil der
Sprache VHDL und bezeichnet einen beliebigen Signalwechsel.
Alle Signale, denen in einem taktsynchronen Rahmen ein Wert zugewiesen wird, werden zu
Flipflops bzw. Registern synthetisiert. Durch die Zuweisung von Eingang x auf Ausgang y
in Listing 4.7 entspricht die Beschreibung einem flankengetriggerten Flipflop. Die Ausgabe
des Flip-Flops ändert sich nur dann, wenn eine (in diesem Falle) positive Taktflanke
empfangen wird. Andernfalls bleibt die vorherige Ausgabe bestehen.

PROCESS ( CLOCK ) -- nur durch Takt gesteuert

BEGIN
IF ( CLOCK ’ event AND CLOCK = ’1 ’) THEN -- ansteigende Flanke
Y <= X ; -- S i g n a l u e b er n a h m e
END IF ;
END PROCESS ;
Listing 4.7: Taktsynchroner Rahmen in einem Prozess
Häufig werden zusätzlich zu einem synchronen Taktsignal noch ein oder mehrere asyn-
chrone Eingänge (z.B. Reset) verwendet. In diesem Falle müssen die asynchronen Signale
immer vor der Taktflankenabfrage abgefragt werden. Ebenso ist darauf zu achten, dass in
der if-Abfrage der Flanke keine weitere Bedingung (wie z.B. Enable-Abfrage) steht. Jede
weitere Abfrage würde zu einem zusätzlichen Gatter (z.B. AND-Gatter) auf der Clock-
leitung führen und somit eine Verzögerung in der Verteilung des Taktsignals bewirken.
Der resultierende Taktversatz (engl. Clock Skew ) zu weiteren Schaltungsteilen würde das
Designprinzip synchroner Schaltungen verletzen.
ENTITY ABC IS
PORT ( X , Reset , CLK : IN bit ;
Y : OUT bit
);
END ABC ;
ARCHITECTURE Test OF ABC IS
SIGNAL s_h1 , s_h2 : bit ;

BEGIN
PROCESS ( CLK , RESET )

VARIABLE v_h3 : bit ;
BEGIN
IF reset = ’1 ’ THEN
Y <= ’0 ’;
ELSIF clk ’ event AND clk = ’1 ’ THEN
s_h1 <= X ;
s_h2 <= NOT s_h1 ;
v_h3 := s_h1 XOR s_h2 ;
Y <= X AND v_h3 ;
END IF ;
END PROCESS ;
END Test ;
Listing 4.8: Beispiel zur Verdeutlichung des Zeitverhaltens
Signalzuweisungen können in einem Prozess kombinatorisch oder getaktet erfolgen. In

kombinatorischem Code nehmen die Signale unmittelbar nach Auswertung des Prozesses
den Wert ihrer Zuordnung an und entsprechen in der realen Schaltung einfachen Leitun-
gen. In sequentiellem Code werden Signale zur Erzeugung von Flipflops verwendet. Diese
benötigen einen Taktzyklus, um den Wert ihrer Zuweisung anzunehmen. Erst mit der
nächsten Taktflanke wird eine Änderung am Ausgang sichtbar.
Variablen haben ein anderes Zuweisungs- und damit Zeitverhalten als Signale. Zudem
existiert für sie kein eindeutiges Gegenstück in der Hardware. Sie werden nur für Zwi-
schenrechnungen oder als Substitution längerer Ausdrücke verwendet und durch die Syn-
these entweder in real existierende aber nicht eindeutig spezifizierte Hardwarekomponen-
ten gegossen oder wegoptimiert. Da mit Variablen leicht Hardwarestrukturen beschrieben

Abbildung 4.10: Zeitverhalten in einem Prozess
werden können, die sich von den Entwicklungswerkzeugen nur schwer oder gar nicht syn-
thetisieren lassen, und zudem in ihrem Zeitverhalten Verwirrung stiften können, sollten
Anfänger die Verwendung von Variablen vermeiden. Abbildung 4.10 illustriert das un-
terschiedliche Zeitverhalten in einem Prozess. Die zugehörige VHDL Beschreibung ist in
Listing 4.8 gegeben.
4.2.3 Strukturbeschreibung
Neben der Verhaltensbeschreibung ist es auch möglich eine Schaltung in Form ihrer Kom-
ponenten zu beschreiben. Diese Form wird Strukturbeschreibung genannt und erfordert
hierarchische Konstrukte.
Die Strukturbeschreibung basiert auf der Verwendung von bereits vorhandenen Schal-
tungsteilen und fügt diese in einen größeren Kontext ein. Dies soll hier anhand eines
Beispiels genauer erläutert werden. Listing 4.9 zeigt die Beschreibung eines AND-Gatters
mit zwei Eingängen.
ENTITY And_2 IS
PORT ( a , b : IN std_logic ;
o : OUT std_logic
);
END And_2 ;
ARCHITECTURE Behavior OF And_2 IS
BEGIN
o <= a AND b ;
END Behavior ;
Listing 4.9: 2-Input AND als Basiskomponente
Basierend auf dieser Basiskomponente soll ein AND-Gatter mit drei Eingängen gemäß
der in Abbildung 4.11 gezeigten Struktur beschrieben werden. Damit die vorhandene
Schaltung (2-Input AND) in der neuen Beschreibung (3-Input AND) benutzt werden
kann, muss sie zunächst als Komponente eingebunden werden. Dies geschieht durch das

Schlüsselwort Component“. Danach folgt die Schnittstellenbeschreibung der Komponen-

”
te, wobei die Signale in derselben Form und in derselben Reihenfolge aufgelistet werden
wie bei der Entity Deklaration der Komponente. Daher empfiehlt es sich hier praktisch
mit Copy & Paste“ zu arbeiten.
”
c
c
a
a u2 o
a a And2
o o
u1 s_connect
And2
o b
b
b b
Abbildung 4.11: Schaltung eines 3-Input AND aus mehreren 2-Input AND-Gattern
Anschließend wird die Komponente im Architecture Body instanziiert. Jede Instanz erhält
eine Bezeichnung zur eindeutigen Referenzierung. Mittels Port Map werden für jede In-
stanz die an der Komponente vorhandenen Portsignale den Signalen der Hauptkomponen-
te zugeordnet. Man spricht bei dieser Hauptkomponente von der Top Entity, da diese ja
aufgrund der Hierarchiebildung der oder den eingebundenen Komponenten übergeordnet
ist.
In der für die Port Map erforderlichen Auflistung muss wieder genau die Reihenfolge der
usprünglichen Entity Deklaration eingehalten werden. Die Portsignale der Komponente
stehen dabei auf der linken Seite, die Signale der Top Entity auf der rechten. Die Zuord-
nung erfolgt durch das Zeichen => (umgedrehter Zuweisungsoperator).
ENTITY And_3 IS
PORT ( a , b , c : IN std_logic ;
o : OUT std_logic
);
END And_3 ;
ARCHITECTURE Struct OF And_3 IS
COMPONENT And_2 IS -- Name und Port - Definition genau so wie in And2 - Entity
o : OUT std_logic
);
END COMPONENT ;
SIGNAL s_connect : std_logic ;
BEGIN
u1 : And_2 -- erste Instanz u1 des And2 - Gatters und Port Mapping
PORT MAP (
a => a, -- Reihenfolge der uebergebenen Signale muss identisch
b => b, -- zu den Signalen in der K o m p o n e n t e n d e k l a r a t i o n sein
o = > s_connect ) ;
u2 : And_2 -- zweite Instanz u2 des And2 - Gatters und Port Mapping
PORT MAP (
a => c,
b = > s_connect ,
o => o );
END Struct ;
Listing 4.10: 3-Input AND unter Vewendung der Basiskomponente

Für Verbindungen, die nicht direkt zum Port der Top Entity führen, müssen interne
Signale angelegt werden. Signalen repräsentieren in VHDL physikalische Leitungen bzw.
Busse. Für das gezeigte Beispiel ist das der Fall für die Verbindung zwischen dem Ausgang
des ersten 2-Input AND (Ausgang o von u1) und dem Eingang des zweiten AND-Gatters
(Eingang b von u2). Listing 4.10 zeigt die Beschreibung des 3-Input AND-Gatters unter
Verwendung von zwei 2-Input AND-Gattern.
Die Vorgehensweise in der Strukturbeschreibung mit VHDL entspricht genau dem typi-
schen Vorgehen im diskreten Schaltungsentwurf. Man setzt vorhandene Komponenten mit
genau spezifizierter Funktionalität ein und verdrahtet diese anhand der Informationen des
Datenblattes über die Zuordnung der physikalischen Pins zu den logischen Anschlüssen.
4.3 Wiederverwendbarkeit und Effizienz in Designs

Ein großer Vorteil bei der Entwicklung von Schaltungen in VHDL ist die Wiederverwend-
barkeit. Neben der Einbindung bereits vorhandener Schaltungsteile als Komponente bietet
VHDL weitere Konstruktionen, die die Wiederverwendbarkeit von Komponenten und die
effiziente Beschreibung komplexer Schaltungen unterstützen.
4.3.1 Generische Beschreibungen
Die Entwicklung von Designs mit Generics“ ermöglicht die Wiederverwendbarkeit von
”
Modulen und erhöht die Flexibilität bei der Einbindung dieser Module. Basierend auf
einer gemeinsamen Grundstruktur kann die Beschreibung ähnlicher Schaltungen mit un-
terschiedlicher Struktur und unterschiedlichem Verhalten erfolgen. Dies geschieht durch
Parametrisierung von Signalvektoren oder parametrisierter Instanziierung von Kompo-
nenten. Erst zum Zeitpunkt der Synthese wird das generische Design mit konkreten Wer-
ten versehen, die dann in der realen Schaltung abgebildet werden.
Listing 4.11 zeigt als Beispiel die Entity eines generischen AND-Gatters. Die Definition
von Parametern für ein VHDL-Modul erfolgt jeweils in der Entity des Moduls.
LIBRARY IEEE ;
USE IEEE . std_lo gic_1164 . ALL ;
ENTITY Andn IS
GENERIC ( n : integer := 8) ;
PORT ( a : IN s t d _ l o g i c _ v e c t o r (n -1 DOWNTO 0) ;
b : IN s t d _ l o g i c _ v e c t o r (n -1 DOWNTO 0) ;
o : OUT s td _ l o g i c _ v e c t o r (n -1 DOWNTO 0)
);
END Andn ;
Listing 4.11: Generisches AND-Gatter
Es ist öft nützlich, wenn auch nicht zwingend erforderlich, einen Default-Wert für das
Generic“ anzugeben. Bei der Instanziierung einer generischen Komponente kann der
”
Default-Wert, wie in Listing 4.12 zu sehen, mit generic map“ überschrieben werden. Wenn
”

der Default-Wert verwendet werden soll, kann das generic map“ weggelassen werden, ist
”
kein Wert hinterlegt, so ist das generic map“ obligatorisch.
”
u1 : Andn
GENERIC MAP (
n = > 16)
PORT MAP (
...... ) ;
Listing 4.12: Instanziierung einer generischen Komponente
Ein große Vorteil von Generics“ liegt in der unterschiedlichen Instanziierung einer Kom-
”
ponente innerhalb eines Moduls. Jedem Generic“ kann dabei ein anderer Wert zugewiesen
”
werden. Listing 4.13 verdeutlicht dies durch Beispiele.
u2 : Andn
GENERIC MAP (
n = > 16)
PORT MAP (
...... ) ;
u3 : Andn
GENERIC MAP (
n = > 32)
PORT MAP (
...... ) ;
Listing 4.13: Flexibilität bei der Instanziierung
Zur Erhöhung der Übersichtlichkeit können Konstanten verwendet werden. Konstanten

legen einmalig Werte fest, meist geschieht das in der Architecture15 . Dadurch wird die
Lesbarkeit erhöht – die Verwendung von aussagekräftigen Namen vorausgesetzt – und
die Fehleranfälligkeit (z.B. bei späterem Wartungseingriff) reduziert. Es ist also eine gute
Designpraxis alle statischen Zahlenwerte als Konstante zu definieren und im Design zu
benutzen. Listing 4.14 zeigt Beispiele für die praktische Anwendung.
ARCHITECTURE Struct OF Beispiel IS
CONSTANT bus_width : INTEGER := 32;
BEGIN
u4 : Andn
GENERIC MAP (
n = > bus_width )
PORT MAP (
...... ) ;
END Struct ;
Listing 4.14: Übersichtliche Instanziierung mit Konstanten
15
Konstanten können auch innerhalb von Packages oder Entities definiert werden. Hier wird dies jedoch
nicht näher betrachtet.

4.3.2 Generische Instanziierung von Komponenten
Viele digitale Systeme können als regelmäßige iterative Zusammenschaltung von Grund-
strukturen oder Komponenten implementiert werden. Wenn ein Entwurf als eine Wieder-
holung von Komponenten beschrieben werden kann, sollte es möglich sein, die Komponen-
te einmal zu spezifizieren und anschließend zu beschreiben wie sie wiederholt instanziiert
werden soll, anstatt jede Instanziierung einzeln zu beschreiben
Die Generate“-Anweisung in VHDL ist ein Konstrukt, das diesen Ansatz für die ef-
”
fiziente Beschreibung eines Entwurfs bzw. für die Erzeugung der iterativen Strukturen
des Entwurfs nutzt. Dabei werden die Komponenten in einer for-Schleife (for-generate-
Anweisung) automatisch instanziiert. Generate“-Anweisungen müssen immer ein Label
”
besitzen. Der Schleifenindex muss nicht extra deklariert werden und kann innerhalb der
Schleife (z.B. bei der Verwendung von Bussignalen) verwendet werden. Durch eine End-
”
Generate“-Anweisung wird die Schleife beendet.
ARCHITECTURE Complete OF Andn IS
COMPONENT And_2 IS
o : OUT std_logic
);
END COMPONENT ;
BEGIN
AndnGen : FOR i IN 0 TO n -1 GENERATE
UAnd2 : And_2
PORT MAP ( a => a(i),
b => b(i),
o => o(i));
END GENERATE ;
END Complete ;
Listing 4.15: Verwendung von Generate“-Anweisung für breites AND-Gatter

”
Listing 4.15 zeigt als Beispiel die Beschreibung eines generischen n-fachen AND-Gatters
unter Wiederverwendung des in Listing 4.9 bereits beschriebenen AND-Gatters mit zwei
Eingängen. Gemäß des Generic“ aus der Entity (vgl. Listing 4.11 werden mit dieser
”
Anweisung n Gatter generiert. Für n = 8 zeigt Abbildung 4.12 das Syntheseergebnis der
resultierenden 8-Bit AND-Schaltung.
Nicht zuletzt durch das gezeigte Syntheseergebnis wird deutlich, dass Generate“-
”
Anweisungen nebenläufige VHDL-Konstrukte sind, die weitere nebenläufige Anweisun-
gen enthalten können, die repliziert werden sollen. Generate“-Anweisungen können in
”
Verbindung mit Generics“ oder Konstanten verwendet werden, um sich wiederholende
”
Strukturen auf effiziente Weise zu erzeugen.

Abbildung 4.12: Syntheseergebnis der 8-Bit AND-Schaltung
4.3.3 Schleifen in VHDL
Schleifen-Konstrukte in VHDL umfassen eine oder mehrere Anweisungen, die gemäß ver-
schiedener Schleifentypen und Iterationsbedingungen wiederholt werden. Sie dienen al-
lerdings nicht der Beschreibung sequentiell ausgeführter Logik, sondern der Spezifikation
einer parallelen regelmässigen Struktur.
Es existieren zwei Schleifentypen, die FOR-Schleife und die WHILE-Schleife. Listing 4.16
zeigt die Anwendung einer FOR-Schleife zur Umverdrahtung zwischen MSBs und LSBs
innerhalb eines 12 Bit breiten Busses. Die Anzahl der Iterationen wird durch den in
der Anweisung direkt angegebenen Wertebereich gesteuert. Die dazu nötige Laufvariable
(im gezeigten Beispiel die Variable i) ist nur innerhalb der FOR-Schleife bekannt und
wird bei Verwendung implizit deklariert, muss also vorher nicht definiert werden. Die
nimmt automatisch den Datentyp der Elemente des Wertebereichs an, im in Listing 4.16
gezeigten Beispiels ist dies der Typ INTEGER. Um die Synthetisierbarbeit des Entwurfs
sicherzustellen, müssen die Grenzen des Wertebereichs konstant und bekannt sein.
Variante1 : PROCESS ( x )
CONSTANT bus_width : INTEGER := 11;
BEGIN
FOR i IN 0 TO bus_width LOOP
y ( bus_width - i ) <= x ( i ) ; -- Eingang x auf Ausgang y in
END LOOP ; -- geaenderter Abfolge
END PROCESS Variante1 ;
Listing 4.16: Anwendung einer FOR-Schleife
Eine alternative Beschreibung ohne FOR-Schleife zur Umkehrung der Bits von Ein- zu
Ausgangsbus ist in Listing 4.17 gegeben. Beide Beispiele sind absolut gleichwertig, erzeu-
gen in der Synthese also exakt die gleiche Logik, nur sind die Lösungen in ihrer Beschrei-
bung unterschiedlich elegant.

Variante2 : PROCESS ( x )
BEGIN
y (11) <= x (0) ;
y (10) <= x (1) ;
y (9) <= x (2) ;
y (8) <= x (3) ;
y (7) <= x (4) ;
y (6) <= x (5) ;
y (5) <= x (6) ;
y (4) <= x (7) ;
y (3) <= x (8) ;
y (2) <= x (9) ;
y (1) <= x (10) ;
y (0) <= x (11) ;
END PROCESS Variante2 ;
Listing 4.17: Alternative ohne Verwendung der FOR-Schleife
Der WHILE-Schleifentyp gestattet gegenüber FOR-Schleifen eine detailliertere Kontrolle

über die Funktion, den abzudeckenden Bereich, sowie über die Abbruchbedingung. Lis-
ting 4.18 zeigt die Anwendung einer WHILE-Schleife zum Zählen vorkommender Einsen
in einem 8 Bit breiten Eingangsbus. Der Zählwert wird über den Ausgang ausgegeben.
Dieses Beispiel zeigt überdies die praktische Anwendung einer Typkonvertierung16 von
Integer zu std logic vector.
LIBRARY ieee ;
USE ieee . numeric_std . ALL ;
ENTITY DEF IS
PORT ( X : IN s t d _ l o g i c _ v e c t o r (7 DOWNTO 0) ;
Y : OUT s t d _ l o g i c _ v e c t o r (3 DOWNTO 0)
);
END DEF ;
ARCHITECTURE Test OF DEF IS

BEGIN
Wasist : PROCESS ( x )
VARIABLE i : INTEGER ;
VARIABLE cnt : INTEGER ;
BEGIN
i := 0;
cnt := 0;
WHILE i < 8 LOOP -- Bedingung wird vor Beginn jedes einzelnen
IF x ( i ) = ’1 ’ THEN -- S c h l e i f e n d u r c h l a u f s abgefragt
cnt := cnt +1;
END IF ;
i := i + 1; -- Laufvariable wird in der Schleife veraendert
END LOOP ;
Y <= s t d _ l o g i c _ v e c t o r ( to_unsigned ( cnt , Y ’ LENGTH ) ) ;
END PROCESS Wasist ;
END Test ;
Listing 4.18: Anwendung einer WHILE-Schleife
16
Die Datentypkonvertierung in VHDL ist sehr inkonsistent. Je nachdem von welchem Datentyp in wel-
chen Datentyp eine Konvertierung durchgeführt werden muss, sehen Syntax und Form aufgrund der
genutzten Bibliotheken anders aus. Daher sollte im Falle der Notwendigkeit in der entsprechenden Bi-
bliotheksreferenz nachgeschlagen werden, anstatt den Ehrgeiz aufzubringen alle Konvertierungsformen
auswendig zu lernen.

Im Unterschied zur FOR-Schleife muss die Laufvariable außerhalb der Schleife explizit
deklariert werden. Auch die Änderung der Laufvariable und der Abbruch werden explizit
gesteuert. Die WHILE-Schleife iteriert solange über den eingeschlossenen Code, bis der
Ausdruck, auf den sie prüft, nicht mehr als wahr gewertet wird. Im in Listing 4.18 gezeigten
Beispiel ist dies der Fall, wenn die Laufvariable i, die innerhalb der Schleife bei jedem
Durchgang inkrementiert wird, aus dem Bereich < 8 läuft.
Nicht immer muss mit Laufvariablen so regulär verfahren werden. WHILE-Schleifen eig-
nen sich insbesondere für Situationen, in denen im Voraus nicht genau bekannt ist wieviele
Iterationen erforderlich sein werden. Dies bedingt allerdings auch, dass WHILE-Schleifen
nicht einheitlich synthetisierbar sind. Sie sind insbesondere nicht synthetisierbar, wenn die
Abbruchbedingung dynamisch bestimmt wird und die Anzahl der Iterationen auf VHDL
Quellcode-Ebene nicht bekannt ist. Ebenso sind Endlos-Schleifen möglich.
Wie aus der Syntax ersichtlich, weisen die Schleifen eine Ähnlichkeit zur Generate“-
”
Anweisung auf und verhalten sich auch so. Sie dienen einem ähnlichen Zweck, allerdings
sind diese Konstrukte sequentielle Anweisungen und damit nur in Prozessen erlaubt.
4.3.4 Eigene Datentypen und Arrays
Zur effizienten Beschreibung komplexerer Strukturen kann es sinnvoll sein mit eigenen
Datentypen zu arbeiten.
TYPE Bit IS ( ’0 ’ , ’1 ’) ;
TYPE Boolean IS ( False , True ) ;
TYPE Even IS ( ’2 ’ , ’4 ’ , ’6 ’ , 8 ’) ;
TYPE Int_Byte IS RANGE 0 TO 255;
TYPE Bit_Index IS RANGE 31 DOWNTO 0;
Listing 4.19: Definition skalarer Datentypen in VHDL
Listing 4.19 zeigt Beispiele für die Definition von skalaren Datentypen. Skalare Datentypen
sind solche, deren Elemente nicht mehr weiter zerlegt werden können. In den zwei ersten
Zeilen ist zu Anschauungszwecken die Definition der bereits vordefinierten Datentypen
boolean“ und bit“ gegeben. Die dritte Zeile zeigt die Definition eines eigenen Datentyps
” ”
als Aufzählungstyp durch Angabe einer geordneten Menge von Zeichen. In den zwei letzten
Zeilen werden jeweils eigene Datentypen durch Einschränkung des dem vordefinierten
Datentyps Integer“ entsprechenden, ganzzahligen Intervalls
”
−2.147.483.647 bis + 2.147.483.647
definiert.
TYPE row IS ARRAY (7 DOWNTO 0) OF std_logic ; -- Array aus std_logic

TYPE matrix IS ARRAY (0 TO 3) OF row ; -- Array von Vektoren ( Array )
SIGNAL x : row ;
SIGNAL y : matrix ;
x (0) <= y (1) (2) ; -- zwei Klammern , da y ein Array von Vektoren
Listing 4.20: Definition von Array-Datentypen in VHDL

Durch Definition von Arrays lassen sich mehrere Datenelemente zu einem neuen Datentyp
kombinieren, wobei alle Elemente vom gleichen Datentyp sein müssen. Arrays können
eindimensional oder zweidimensional sein, auch Arrays von Vektoren sind möglich, wie
aus Abbildung 4.13 ersichtlich. Höherdimensionale Arrays sind nicht synthetisierbar.
0 1 0 0 1 0 1 0 0 1
0 0 1 0 0 1 0 0 1 0 1 0 0 1 0 1
1 0 1 1 0 1 0 1 1 0
Skalar Array Array aus Vektoren 2D-Array

Abbildung 4.13: Array-Datentypen in VHDL
Es gibt keine vordefinierten 2D- oder Vektor-Arrays. Entsprechende Datentypen müssen

vom Entwickler selbst definiert werden. Listing 4.20 zeigt einige Beispiele.
In der ersten Zeile wird ein Array bestehend aus 7 std logic Werten mit MSB auf der linken
Seite definiert. Die zweite Zeile zeigt die Definition eines Matrix-Datentypen bestehend
aus einem Array des Arrays. Dies entspricht einem vier Zeilen umfassenden Array des in
der vorigen Definition geschaffenen Datentyps. In den nachfolgenden zwei Zeilen werden
jeweils Signale für die zuvor definierten Datentypen deklariert. Auf die einzelnen Elemente
von Arrays kann über Indizes zugegriffen werden. Dies zeigt schließlich die letzte Zeile.
TYPE matrix IS ARRAY (0 TO 3) OF s t d _ l o g i c _ v e c t o r (7 DOWNTO 0) ;

-- Alternative Methode fuer Array von Vektoren ( Array )
TYPE matrix2d IS ARRAY (0 TO 3 , 7 DOWNTO 0) OF std_logic ;
-- Definition eines 2 D Arrays
SIGNAL y : matrix ;
SIGNAL z : matrix2d ;
x (1) <= y (2) (3) ; -- zwei Klammern , da y ein Array von Vektoren
x (2) <= z (2 ,1) ; -- eine Klammer , da z ein 2 D Array
Listing 4.21: Weitere Möglichkeiten zur Definition von Array-Datentypen
Listing 4.21 zeigt eine alternative Möglichkeit zur Definition eines Arrays von Vektoren
(Zeile 1). Darüber hinaus ist ist auch die zweidimensionale Array-Konstruktion gezeigt, die
nicht auf Vektoren, sondern vollständig auf einer 2D-Anordnung von Skalaren basiert.
TYPE dataset IS
RECORD
a : s t d _ l o g i c _ v e c t o r (11 DOWNTO 0) ;
b : s t d _ l o g i c _ v e c t o r (2 DOWNTO 0) ;
c : std_logic ;
END RECORD ;
TYPE combination IS ARRAY (0 TO 3) OF dataset ;

SIGNAL s_setting : combination ;
s_setting (0) . a <= " 011101111101 " ;
s_setting (2) . b <= " 100 " ;
s_setting (0) . c <= ’1 ’;
Listing 4.22: Definition von Struktur-Datentypen in VHDL

Mit Hilfe von Struktur-Datentypen lassen sich auch Elemente unterschiedlicher Daten-
typen zusammenfassen. Dies geschieht durch das Schlüsselwort record“. Die einzelnen
”
Subelemente des neuen Datentyps werden mit Hilfe von Elementnamen referenziert. Lis-
ting 4.22 veranschaulicht dies.
Für nähere Details zur Definition und Verwendung aller möglichen Datentypen sei auf die
Lektüre des Language Reference Manual [VHDL87] (inkl. späterer Ergänzungen) verwie-
sen.
4.4 Entwurf von Zustandsautomaten in VHDL

Wie bereits in Abschnitt 3.4 ausführlich behandelt, können komplexe sequentielle Schal-
tungen als endliche Automaten (FSMs) beschrieben werden. In VHDL lassen diese sich
leicht mit Hilfe von Prozessen und case-Anweisungen spezifizieren. Das Syntheseergebnis
ist eine Netzliste mit booleschen Gattern und D-Flipflops.
4.4.1 FSM Beschreibungsformen in VHDL
Für die Realisierung von Zustandsautomaten in VHDL existieren unterschiedliche Be-

schreibungsformen, die sich darin unterscheiden wieviele Prozesse für die unterschiedlichen
Bestandteile eines Automaten (Übergangsschaltnetz, Zustandsspeicher, Ausgangsschalt-
netz) verwendet werden.
Reset
s1
1
1 0
s2 s3
1 0
s4
0
Abbildung 4.14: Moore-Automat als Beispiel für die Beschreibung in VHDL
Dies soll an dem Beispiel eines Moore-Automat mit asynchronem Reset gemäß Abbil-
dung 4.24 veranschaulicht werden. Dieser Automat zeichnet sich durch
• 4 Zustände s1, s2, s3, s4
• 5 Übergänge
• 1 Eingang x
• 1 Ausgang y

aus. Im folgenden wird die Spezifikation dieses Automaten in VHDL durch die verschie-
denen Beschreibungsformen erläutert.
Ein-Prozess Beschreibung
Bei der Ein-Prozess Beschreibung dient gemäß Abbildung 4.15 genau ein taktsynchroner
Prozess der Beschreibung des Automaten.
Reset
Übergangs- Zustands-
schaltnetz speicher
Clock Ausgangs-
x schaltnetz
y
Nur für Mealy
Prozess
Abbildung 4.15: FSM in Ein-Prozess Darstellung
Durch die Zuweisung des Ausgangs innerhalb des taktynchronen Prozesses werden auto-
matisch zusätzliche Register am Ausgang integriert, so dass die Ausgaben immer takt-
synchron erfolgen. Dies mag als Vorteil ausgelegt werden.
Der Nachteil dieser Beschreibungsform liegt in der nicht vorhandenen Trennung zwi-
schen kombinatorischer und taktsynchroner Schaltungsteile. Dies macht den Entwurf
unübersichtlich und spiegelt zudem nur unzureichend die reale Struktur des Automaten
wieder, in der lediglich der Zustandsspeicher ein synchrones Element sein muss.
LIBRARY IEEE ;
ENTITY FSM IS
PORT ( Clk , Reset , x : IN std_logic ;
y : OUT std_logic ) ;
END ENTITY ;
ARCHITECTURE Eins OF FSM IS
TYPE Zustaende IS ( s1 , s2 , s3 , s4 ) ; -- Definition der Zustaende
SIGNAL Zustand : Zustaende ;
BEGIN
PROCESS ( Clk , Reset ) -- sensitiv fuer Clk + Reset
BEGIN
IF ( Reset = ’1 ’) THEN -- asynchrones Reset
Zustand <= s1 ; y <= ’1 ’; -- Initialz ustand und - wert
ELSIF ( Clk = ’1 ’ AND Clk ’ event ) THEN
CASE Zustand IS -- Z u s t a n d s g l i e d e r u n g m . case
WHEN s1 = > IF x = ’1 ’ THEN Zustand <= s2 ; y <= ’1 ’; -- Folgezustand und
ELSE Zustand <= s3 ; y <= ’0 ’; -- Ausgabewert des
END IF ; -- Folgezustands !
WHEN s2 = > Zustand <= s4 ; y <= ’0 ’;
WHEN s3 = > Zustand <= s4 ; y <= ’0 ’;
WHEN s4 = > Zustand <= s1 ; y <= ’1 ’;
WHEN OTHERS = > Zustand <= s1 ; y <= ’1 ’; -- verhindert Blockierung
END CASE ;
END IF ;
END PROCESS ;
END Eins ;
Listing 4.23: Ein-Prozess Beschreibung des Automaten in VHDL

Abbildung 4.16: Timing-Diagramm der Ein-Prozess Beschreibung
Die VHDL Beschreibung als Ein-Prozess Darstellung ist in Listing 4.23 gegeben. Durch
das synchrone Umfeld ist das Ausgangssignal y ein Register und entspricht bei der Zu-
weisung dem Ausgabewert des Folgezustandes. Dies zeigt sich letztlich auch in dem in
Abbildung 4.16 dargestellten Zeitverhalten durch synchrone Änderungen am Ausgang.
Eingang Beschaltung
SEL[0] Zustand
SEL[1] y
SEL[2] Zustand
Data[0] V CC
Data[1] GN D
Data[2] x
Tabelle 4.2: Beschaltung des Multiplexers Selector0“ in Syntheseergebnis

”
Abbildung 4.17 zeigt das Syntheseergebnis der Ein-Prozess Beschreibung. Zur näheren
Erläuterung sind in Tabelle 4.2 Details zur internen Verschaltung gegeben. In Abbil-
dung 4.18 ist der dem Syntheseergebnis entsprechende Zustandsgraph abgebildet.
Abbildung 4.17: Syntheseergebnis der Ein-Prozess Beschreibung

Abbildung 4.18: Zustandsgraph des Syntheseergebnisses (Ein-Prozess Beschreibung)
Zwei-Prozess Beschreibung
Die Trennung von kombinatorischen (Übergangs- und Ausgangsschaltnetz) und se-
quentiellen Elementen (Zustandsspeicher) führt direkt zur Zwei-Prozess Beschreibung,
wie in Abbildung 4.19 dargestellt. Diese liegt näher an der Hardware und ist zudem
übersichtlicher und leichter erweiterbar.
Reset
schaltnetz speicher
Clock Ausgangs-
x schaltnetz
y
Prozess 2
Nur für Mealy
Prozess 1
Abbildung 4.19: FSM in Zwei-Prozess Darstellung
Prozess 1 ist kombinatorisch ausgelegt und dient der gemeinsamen Realisierung von
Ausgangs- und Übergangsschaltnetz. Prozess 2 arbeitet taktsynchron und beschreibt den
Zustandsspeicher (D-Flipflops) als Synchronisationsblock für die Weiterschaltung zum
nächsten Zustand.
Die VHDL Beschreibung als Zwei-Prozess Darstellung ist in Listing 4.24 gegeben. Man be-
achte die Sensitivitätslisten der beiden Prozesse. Da für den synchronen Prozess lediglich
das Takt- und das Resetsignal entscheidend sind, finden sich auch nur diese beiden Signale
in der Sensitivitätsliste. Bei asynchronen Prozessen führt die Auflistung aller durch ent-
sprechende Abfragekonstrukte (if..., case...) betroffenen Signale, sowie – falls zutreffend –
alle bei unbedingten Zuweisungen vorkommenden Signale rechts neben dem Signalzuwei-
sungsoperator zu einer korrekten und vollständigen Liste.
Durch die Zuweisung des Ausgangssignals in einem nebenläufigen Prozess bezieht diese
sich immer auf den aktuellen Zustand. Es gibt hier keine Verzögerung wie bei der Ein-
Prozess Darstellung. Die Übernahme des unmittelbar ermittelten Folgezustandes in den
aktuellen Zustand erfolgt jeweils bei der nächsten Taktflanke.

LIBRARY IEEE ;
ENTITY FSM IS
END ENTITY ;
ARCHITECTURE Zwei OF FSM IS
TYPE Zustaende IS ( s1 , s2 , s3 , s4 ) ; -- Definition der Zustaende
SIGNAL Zustand , Folgezustand : Zustaende ;
BEGIN
Z u s t a n d s s p e i c h e r : PROCESS ( Clk , Reset ) -- sensitiv fuer Clk + Reset
BEGIN
IF ( Reset = ’1 ’) THEN -- asynchrones Reset
Zustand <= s1 ; -- Initial zustand s1
Zustand <= Folgezustand ; -- synchrones We iterscha lten
END IF ;
END PROCESS Z us t a n d s s p e i c h e r ;
Transitionen : PROCESS (x , Zustand ) -- Folgezustands - und A u s g a n g s b e r e c h n u n g
BEGIN
y <= ’1 ’; -- Initialwert fuer Ausgang
Folgezustand <= s1 ; -- erster Folgezustand vor Auswahl
CASE Zustand IS
WHEN s1 = > IF x = ’1 ’ THEN Folgezustand <= s2 ; -- Folgezustand
ELSE Folgezustand <= s3 ;
END IF ; y <= ’1 ’; -- Ausgabewert des
WHEN s2 = > Folgezustand <= s4 ; y <= ’1 ’; -- aktuellen Zustands !
WHEN s3 = > Folgezustand <= s4 ; y <= ’0 ’;
WHEN s4 = > Folgezustand <= s1 ; y <= ’0 ’;
WHEN OTHERS = > Folgezustand <= s1 ; y <= ’1 ’; -- verhindert Blockierung
END CASE ;
END PROCESS Transitionen ;
END Zwei ;
Listing 4.24: Zwei-Prozess Beschreibung des Automaten in VHDL
Abbildung 4.20: Timing-Diagramm der Zwei-Prozess Beschreibung
Die Trennung in zwei Prozesse gestattet bei der Simulation des Zeitverhaltens, wie in Ab-
bildung 4.16 ersichtlich, den Zugriff auf Zwischensignale (hier: das Signal Folgezustand“
”
). Dies kann die Fehlersuche erheblich erleichtern. Zudem führt die Implementierung von
FSMs in Zwei-Prozess Darstellung in der Regel zu kleineren Netzlisten und damit zu
besseren Synthese-Ergebnissen. Natürlich hängt dies in hohem Maße von der Synthese-
Software ab, liegt aber schon darin begründet, dass durch die Trennung von kombinato-

rischen und synchronen Elementen eine günstigere Ausgangslage geschaffen wird. Das in
Abbildung 4.21 gezeigte Syntheseergebnis unterstreicht dies, Abbildung 4.22 ergänzt das
Ergebnis um den Zustandsgraphen.
Abbildung 4.21: Syntheseergebnis der Zwei-Prozess Beschreibung
Abbildung 4.22: Zustandsgraph des Syntheseergebnisses (Zwei-Prozess Beschreibung)
Drei-Prozess Beschreibung
Werden die zwei kombinatorischen Schaltnetze zur Steuerung des Übergangs- und Aus-
gabeverhaltens ebenfalls voneinander getrennt, resultiert daraus unmittelbar die in Ab-
bildung 4.23 skizzierte Drei-Prozess Beschreibung. Diese verfolgt das gleiche modulare
Prinzip wie die Zwei-Prozess Beschreibung, nur granularer. Von allen Varianten ist diese
am übersichtlichsten und stellt somit die empfohlene bzw. bevorzugte Variante dar.
Reset
schaltnetz speicher
Clock Ausgangs-
x schaltnetz
y
Nur für Mealy
Prozess 1 Prozess 2 Prozess 3
Abbildung 4.23: FSM in Drei-Prozess Darstellung
Prozess 1 dient der Realisierung des Übergangsschaltnetzes, Prozess 3 stellt die separate
Realisierung des Ausgangsschaltnetzes dar. Beide sind kombinatorisch ausgelegt. Prozess
2 ist taktsynchron und dient der Realisierung des Zustandsspeichers (D-Flipflops).

In Listing 4.25 ist die vollständige VHDL Beschreibung der Drei-Prozess Darstellung
gegeben. Besonderes Augenmerk sei neben der funktionalen Aufteilung auf die einzelnen
Prozesse auch hier wieder auf die jeweiligen Sensitivitätslisten gerichtet. Zeitverhalten
und Syntheseergebnis entsprechen exakt der Zwei-Prozess Beschreibung, weswegen diese
hier nicht extra nocheinmal gezeigt werden.
LIBRARY IEEE ;
ENTITY FSM IS
END ENTITY ;
ARCHITECTURE Drei OF FSM IS
TYPE Zustaende IS ( s1 , s2 , s3 , s4 ) ;
SIGNAL Zustand , Folgezustand : Zustaende ;
BEGIN
Z u s t a n d s s p e i c h e r : PROCESS ( Clk , Reset )
BEGIN
IF ( Reset = ’1 ’) THEN
Zustand <= s1 ;
Zustand <= Folgezustand ;
END IF ;
END PROCESS Z us t a n d s s p e i c h e r ;
Folgezustand : PROCESS (x , Zustand )
BEGIN
CASE Zustand IS
WHEN s1 = > IF x = ’1 ’ THEN Folgezustand <= s2 ;
ELSE Folgezustand <= s3 ;
END IF ;
WHEN s2 = > Folgezustand <= s4 ;
WHEN OTHERS = > Folgezustand <= s1 ;
END CASE ;
END PROCESS Folgezustand ;
Ausgang : PROCESS ( Zustand )
BEGIN
CASE Zustand IS
WHEN s1 = > y <= ’1 ’;
WHEN s2 = > y <= ’1 ’;
WHEN s3 = > y <= ’0 ’;
WHEN s4 = > y <= ’0 ’;
WHEN OTHERS = > y <= ’0 ’;
END CASE ;
END IF ;
END PROCESS Ausgang ;
END Drei ;
Listing 4.25: Drei-Prozess Beschreibung des Automaten in VHDL
4.4.2 Konvertierung von Automaten
Da FSMs lediglich mathematische Abstraktionen von sequentiellen Schaltkreisen darstel-

len, ist es auch möglich diese ineinander zu überführen. Ein Moore-Automat kann immer
in einen äquivalenten Mealy-Automaten konvertiert werden (und umgekehrt). Für die
technische Umsetzung birgt dies Vorteile. So haben Mealy-Automaten in der Regel we-
niger Zustandsvariablen und benötigen daher weniger Speicherelemente. In technischen
Anwendungen sind Mealy-Automaten daher weiter verbreitet als Moore-Automaten.
Im Folgenden wird die Konvertierung des in Abbildung 4.24 gegebenen Moore- in einen

Mealy-Automaten gezeigt. Diese folgt einem festen Ablauf, der sich in folgende Schritte
gliedert:
1. Zustandsfolgetabelle des Moore-Automaten aufstellen
2. zweite Tabelle nach Mealy-Übergangsformat vorbereiten, nach dem die Folge-
zustände und Ausgänge je nach Eingangskonfiguration gruppiert werden.
3. alle Zustände der Zustandsfolgetabelle des Moore-Automaten in das Format des
Mealy-Automaten übertragen, wobei die Ausgabe der Zustände der ersten Spalte
(Moore) verwendet und entsprechend in der zweiten und dritten Spalte (Mealy)
platziert wird
4. evtl. Tabelle durch Entfernung redundanter Zustände vereinfachen
5. Zustandsgraph aus ermittelter Zustandsfolgetabelle des Mealy-Automaten ableiten
Tabelle 4.3 zeigt die Zustandsfolgetabelle des Moore-Automaten. Bei diesem Automaten-
typ hängt der Wert der Ausgangsfunktion ausschließlich vom aktuellen Zustand ab. Daher
lassen sich die erste und letzte Spalte der Tabelle direkt aus Abbildung 4.24 ablesen. In
der mittleren Doppelspalte werden die Übergänge zu den Folgezuständen, abhängig vom
Eingang x eingetragen.
Aktueller Zustand Folgezustand Ausgang

bei x = 0 bei x = 1
s1 s3 s2 1
s2 s4 s4 1
s3 s4 s4 0
s4 s1 s1 0
Tabelle 4.3: Ursprüngliche Übergangs- / Ausgabetabelle des Moore-Automaten
In Tabelle 4.4 ist die konvertierte Zustandsfolgetabelle des Mealy-Automaten dargestellt.

Diese hat ein anderes Format als die Moore-Tabelle und muss entsprechend vorbereitet
werden. Während beim Moore-Automaten die Ausgabe fest an den aktuellen Zustand
gebunden ist, findet beim Mealy-Automaten eine Zuordnung des Ausgangs zum Folge-
zustand statt. Die Werte aus der Zustandsfolgetabelle des Moore-Automaten werden
entsprechend umsortiert und der Ausgang des Folgezustandes aus der Zuordnung zum
aktuellen Zustand der ursprünglichen Tabelle abgelesen.
Beim Moore-Automat ist der Ausgang von s3 = 0. Daher wird für den Ausgang von s3
in der Spalte des Folgezustandes bei der Zustandsfolgetabelle des Mealy-Automaten in
Tabelle 4.4 eine 0 eingetragen. Ferner ist bekannt, dass der Ausgang von s4 = 0 und von
s1 = 1 ist. Der gleiche Vorgang wird also für alle weiteren Zustandsübergänge wiederholt,
bis die Tabelle vollständig ausgefüllt ist.
Bei der Konvertierung von Moore nach Mealy bleibt die Anzahl der Zustände immer
gleich. Allerdings kann es vorkommen, dass sich mehrere Zustände funktional identisch
verhalten, also die gleiche Funktion realisieren. In der resultierenden Tabelle für den

Aktueller Zustand Eingang x = 0 Eingang x = 1

Folgezustand Ausgang Folgezustand Ausgang
s1 s3 0 s2 1
s2 s4 0 s4 0
s3 s4 0 s4 0
s4 s1 1 s1 1
Tabelle 4.4: Konvertierte Übergangs- / Ausgabetabelle für Mealy-Automaten
Mealy-Automaten (Tabelle 4.4) sind dies die Zustände s2 und s3. Sie haben jeweils den
gleichen Folgezustand bei gleichem Ausgang, sind also äquivalent.
Reset Reset
0/0
s1 s1
1/1 0/0 1/1
s2
s2 x/1 s3 x/1
x/0
x/0 x/0 s4
s4
Abbildung 4.24: Konvertierter Mealy-Automat (links) und Vereinfachung (rechts)
Besitzt ein Automat zwei äquivalente Zustände, so können diese zusammengefasst und der
Automat vereinfacht werden. Abbildung 4.24 zeigt den Zustandsgraphen des konvertier-
ten Mealy-Automaten in seiner ursprünglichen Form, sowie die vereinfachte Form durch
Zusammenfassung der Zustände s2 und s3 zu nur einem Zustand s2.
Uebergang : PROCESS (x , Zustand )

BEGIN
CASE Zustand IS -- durch Trennung von Zustand und
WHEN s1 = > Folgezustand <= s2 ; -- Ausgang : Einsparung eines Zustandes
WHEN OTHERS = > Folgezustand <= s1 ;
END CASE ;
END PROCESS Uebergang ;
Ausgang : PROCESS (x , Zustand )
BEGIN
CASE Zustand IS
WHEN s1 = > IF ( x = ’1 ’) THEN y <= ’1 ’; -- Ausgabewerte abhaengig vom
ELSE y <= ’0 ’; -- aktuellen Eingangswert
END IF ; -- ( nur in Zustand s1 !)
WHEN s2 = > y <= ’0 ’;
WHEN s4 = > y <= ’1 ’;
WHEN OTHERS = > y <= ’0 ’;
END CASE ;
END PROCESS Ausgang ;
Listing 4.26: Variante als Mealy-Automat in Drei-Prozess Beschreibung

Die Konvertierung von Mealy nach Moore erfolgt nach dem gleichen Prinzip, allerdings
ergibt sich dabei nicht automatisch die gleiche Anzahl von Zuständen. Ein Moore-Automat
benötigt mehr Zustände, so dass diese bei der Zieltabelle entsprechend ergänzt werden
müssen.
Man ermittelt die zu ergänzenden Zustände, indem man die Anzahl der verschiedenen
Ausgänge bestimmt, die einem Folgezustand zugeordnet sind. Die betroffenen Zustände
werden entsprechend der unterschiedlichen, ihm zugeordneten Ausgänge auf mehrere
Zustände aufgeteilt. Das weitere Vorgehen entspricht dem gezeigten Schema in umge-
kehrter Reihenfolge.
Listing 4.26 zeigt nun den Entwurf des Übergangs- und Ausgangsschaltnetzes für den
Automaten in der Mealy-Variante basierend auf der Drei-Prozess Beschreibung. Die Mo-
dellierung des Zustandsspeichers bleibt unverändert. Der Zeitverhalten dieser Variante ist
in Abbildung 4.25 dargestellt und verdeutlicht die Anfälligkeit für Hazards, deutlich zu
sehen im Ausgangssignal y.
Abbildung 4.25: Timing-Diagramm des Mealy-Automaten in Drei-Prozess Beschreibung
Die mealy-typische Beschreibung des Ausgangsschaltnetzes als kombinatorischer Pro-

zess in Abhängigkeit des Eingangssignals zeigt sich deutlich im Syntheseergebnis (Abbil-
dung 4.26), das die Bestimmung des Ausgangssignals y über einen Multiplexer realisiert,
dessen Dateneingang direkt aus dem Eingang x und der Select-Eingang direkt aus dem
Zustandsspeicher gewonnen wird. Der in Abbildung 4.27 dargestellte Zustandsgraphen des
Automaten unterstreicht zudem das weniger aufwendige Syntheseergebnis durch weniger
Zustände.
Abbildung 4.26: Syntheseergebnis der Mealy-Variante

Abbildung 4.27: Zustandsgraph zur Mealy-Variante
4.4.3 Optimierung von FSM Implementierungen
Die modulare Entwurfsmethodik in VHDL erlaubt es, sehr komplexe Entwürfe mit einem
hierarchischen Ansatz realisieren zu können. Dies erfolgt durch die Partitionierung eines
Systems in Module. Dieser Ansatz lässt sich auch auf die Realisierung von Zustandsauto-
maten anwenden. Allerdings sind je nach Automatentyp Anpassungen und Optimierungen
notwendig.
Beim Mealy-Automaten werden die Übergangs- und die Ausgangslogik als kombinato-
rische Schaltungen realisiert. Werden mehrere Mealy-Automaten modular hintereinan-
der geschaltet, besteht die Gefahr von kombinatorischen Schleifen. Zusätzlich entstehen
lange Pfade. Die maximale Taktfrequenz wird durch die längste Laufzeit eines Signals
durch die kombinatorische Logik zwischen je zwei Flipflops bestimmt (kritischer Pfad,
vgl. Abschnitt 2.4). Bei gekoppelten Automaten entspricht die Gesamtlaufzeit der Sum-
me der Laufzeiten durch das Ausgangsschaltnetz des ersten Automaten und der durch
das Übergangsschaltnetz des zweiten Automaten. Eine Signaländerung braucht also re-
lativ lange, um sich durch die zusammengesetzte kombinatorische Logik zur nächsten
Flipflopstufe fortzupflanzen. Daher ist die Taktfrequenz stark limitiert.
SET SET
Eingang D Q D Q Ausgang
Kombinatorische
Logik
CLR
Q CLR
Q
Clock
Abbildung 4.28: Entkopplung von Zustandsautomaten durch Flipflops
Kombinatorische Schleifen können vermieden und der kritische Pfad verkürzt werden,
wenn am Eingang und / oder Ausgang zusätzliche Flipflops eingefügt werden. Dies ent-
spricht einer Ein- bzw. Ausgangssignalsynchronisation, schematisch angedeutet in Abbil-
dung 4.28. Man spricht von registerten Ein- bzw. Ausgängen.
Auf VHDL-Ebene entspricht die direkte Verwendung der Port-Eingangssignale einer Enti-
ty einer kombinatorischen Weiterleitung (nicht-registert). Sollen registerte Eingänge reali-
siert werden, muss dies durch eine Beschreibung mit internen Signalen, die im sequentiellen
Prozess zugewiesen werden, erfolgen. Für Ausgangssignale gilt das ebenso. Nebenläufige

Zuweisungen oder Zuweisungen innerhalb eines kombinatorischen (ungetakteten) Prozes-

ses führen zu nicht-registerten Ausgängen. Sollen Register am Ausgang eingefügt werden,
so müssen alle Zuweisungen innerhalb eines sequentiellen (getakteten) Prozesses erfol-
gen.
Register an den Ausgängen haben in der Praxis eine höhere Relevanz als Register an
den Eingängen. Werden diese konsequent eingebaut, so können bei Kaskadierung meh-
rerer Module die nachfolgenden Blöcke mit sicheren17 Eingangsdaten arbeiten und beim
Entwurf des Folgemoduls mehr Designflexibilität umgesetzt werden. Indem alle Ausgänge
getaktet werden, wird die Ausgangslogik vom nächsten Logikblock des nachfolgenden
Moduls getrennt, wodurch der Weg durch die Logikelemente verkürzt wird und höhere
Taktfrequenzen möglich sind. Darüber hinaus haben Synthesewerkzeuge oft Probleme bei
der Geschwindigkeitsoptimierung von Logikpfaden, die Modulgrenzen passieren. Durch
Taktung der Ausgänge können diese Probleme vermieden werden.
Neben der Entkopplung von Ein- und Ausgängen bei Zustandsautomaten lässt auch die
Art der Zustandscodierung einige Optimierungen zu. Die Codierung der Zustände einer
FSM beeinflusst deren Performance in Bezug auf
• den störungssicheren Betrieb
• den Hardwareaufwand bzw. die Ressourcennutzung (Anzahl von Logikgattern und
Registern)
• die Verarbeitungsgeschwindigkeit
• den potentiellen Stromverbrauch (durch aktive Schaltungsteile)
In Abbildung 4.29 sind die gängigsten Zustandscodierungen zusammengefasst. Die bevor-
zugte Codierung hängt von der Art des Designs ab.
s1
Zustand Binär Gray One-Hot
s1 00 00 0001
s2 01 01 0010 s4 s2
s3 10 11 0100
s4 11 10 1000
s3
Abbildung 4.29: Gebräuchliche Zustandscodierungen für eine gegebene FSM
Bei der Binärcodierung werden die Zustände sequentiell durchnummeriert. Damit lässt
sich eine minimale Anzahl an Flipflops zur Codierung erreichen, allerdings auf Kos-
ten komplexer kombinatorischer Logik. Daher sind vor allem CPLDs gut für die Im-
plementierung geeignet, da diese über breite Gatterstrukturen und eine große Menge an
kombinatorischer Logik pro Register verfügen. Mit n Flipflops lassen sich 2n Zustände
17
Da sich die Daten nur mit der aktiven Taktflanke ändern, sind somit Hazards und Spikes ausgeschlossen.

repräsentieren. Für Realisierungen von Zustandmachinen mit weniger als 8 Zuständen

ist die Binärcodierung normalerweise die bevorzugte Variante, sofern keine anderen Ein-
schränkungen vorherrschen.
Allerdings kann es bei dieser Codierung vorkommen, dass sich bei einem Zustandswechsel
jederzeit mehr als ein Bit ändern kann18 , was zu Hazards führt und damit die Fehlersicher-
heit beeinträchtigt. Auch ist die Binärcodierung nicht geeignet, falls der Strombedarf ein
entscheidendes Kriterium für die Implementierung darstellt, da der dynamische Leistungs-
verbrauch direkt von der Anzahl schaltender Gatter und Register (Flipflops) abhängt.
Die einschrittige Codierung (Gray Codierung) kann Störungen und Fehlzustände in ei-
ner FSM reduzieren, die durch das gleichzeitige Schalten mehrerer Flipflops entstehen.
Aufeinanderfolgende (benachbarte) Zustandscodes unterscheiden sich bei dieser Codie-
rung nur um ein Bit, so dass beim Wechsel aufeinanderfolgender Zustände jeweils nur ein
Flipflop schaltet. Die Umsetzung der Gray Codierung ist möglich bei Zustandsautomaten
mit limitierten oder keinen Verzweigungen, da sich die Codierung nach den erreichbaren
Folgezuständen richtet. Der Bedarf an Flipflops ist vergleichbar mit der Binärcodierung.
Da sich pro Übergang nur die minimale Anzahl an Bits ändert, hat die Steuerlogik für
die Flipflops eine geringere Komplexität. Auch lässt sich die Eigenschaft der geringen
Schaltaktivität für ein Low-Power Design ausnutzen, bei dem der Strombedarf minimal
gehalten werden muss.
Bei der One-Hot Codierung wird jedem Zustand ein Bitmuster zugeordnet, in dem nur
ein Bit 1“oder hot“ ist, alle andere Zustandsbits sind Null. Die One-Hot Codierung
” ”
hat den Vorteil, ungültige Zustände relativ simpel erkennen zu können. Sie ist in der
Regel schneller, da die nötige Vergleichslogik eine relativ geringe Komplexität aufweist
und daher wenig Logikressourcen erforderlich sind. Die Geschwindigkeit ist unabhängig
von der Anzahl der Zustände und hängt stattdessen nur von der Anzahl der Übergänge
in einen bestimmten Zustand ab. Dafür werden mehr Flipflops benötigt, für n Zustände
sind das n Flipflops. Dadurch eignet sich die One-Hot-Codierung sehr gut für FPGA-
Designs, bei denen Flipflops reichlich vorhanden sind. Aufgrund der geringen Anzahl an
erforderlichen Logikgattern ist auch der Strombedarf minimal.
FSMs sollten so entworfen werden, dass sie leicht zu verstehen und zu warten sind.
Für die Definition der Zustandssignale und deren Codierung existieren in VHDL meh-
rere Möglichkeiten, die in Listing 4.27 zusammenfassend dargestellt sind. Am einfachs-
ten gestaltet sich die Definition eines eigenen Datentypen als Aufzählungstyp (vgl. Ab-
schnitt 4.3.4), der die Referenzierung der Zustände gemäß der in Abbildung 4.29 gezeigten
Bezeichnung der Zustände (s1, s2, ... usw.) zulässt. Die Zustände werden durch Namen
codiert. Zur Verwendung muss anschließend ein Zustandssignal deklariert werden. Dies
macht den Entwurf übersichtlich, einfach zu verstehen und zu erweitern. Zustände können
leicht hinzugefügt oder geändert werden, ohne dabei vorhandene Zustände zu beeinflussen.
Die eigentliche Codierung der Zustände auf Bitebene wird bei dieser abstrakten Definition
automatisch vom Synthesetool übernommen. Entsprechende Einstellungen, die Zustands-
codierung zu beeinflussen können in der Regel über die Oberfläche der Software getätigt
werden.
18
Insbesondere beim Design von Zählern ist dies kritisch, da es dort häufig zu Zustandswechseln und
einem Umschalten in die höherwertigere Bitebene kommt.

-- o d e r --
ATTRIBUTE enum_encoding : string ;
ATTRIBUTE enum_encoding OF Zustaende : TYPE IS " 11 10 01 00 " ;
-- o d e r --
SUBTYPE Zustaende IS bit_vector (3 DOWNTO 0) ;

CONSTANT s1 : Zustaende := " 1000 " ;
Listing 4.27: Zustandscodierung für FSMs in VHDL
Es birgt Vorteile, die Zustandscodierung der FSM selbst in die Hand zu nehmen. Die
konkrete Art der Zustandscodierung lässt sich auf Typ-Ebene definieren. Das Synthese-
attribut enum encoding ist Bestandteil der Sprache VHDL und definiert wie zuvor defi-
nierte Aufzählungstypen bei der Synthese codiert werden sollen. Beliebige, benutzerde-
finierte Codierungen sind möglich. Das Attribut enum encoding muss der Definition des
Aufzählungstypen folgen, aber seiner Verwendung vorausgehen. Darüber hinaus muss der
Attributwert ein String sein, das die beliebige Benutzercodierung angibt. Diese besteht
letztlich aus einer durch Leerzeichen getrennten Liste von Codes. Die Liste muss so viele
Codes enthalten wie Elemente im Aufzählungstyp vorhanden sind, außerdem müssen alle
Codes die gleiche Länge haben.
Je nach Synthesetool gibt es bei der Verwendung des Attributes enum encoding Ein-
schränkungen. Die volle Kontrolle über die Zustandscodierung der FSM und damit die
Unabhängigkeit von der Leistungsfähigkeit der Synthesesoftware liefert die manuelle Co-
dierung. Es wird ein eigener Subtyp eines bestehenden Vektordatentypen angelegt und
anschließend Konstanten dieses Typs. Die Konstanten sind so definiert, dass sie die ent-
sprechenden Zustände des Zustandsautomaten repräsentieren. Bei der Festlegung der Co-
des hat der Entwickler alle Freiheiten. Der Vorteil dieser Variante besteht darin, dass
die Festlegung der Codierung zwischen verschiedenen Synthesewerkzeugen portabel und
damit herstellerunabhängig ist. Der Nachteil ist der erhöhte Schreibaufwand auf VHDL
Code-Ebene.
Je nachdem, wie viele Zustände ein Zustandsautomaten besitzt und welche Zustandsco-
dierungsart gewählt wurde, gilt dieser als sicher oder unsicher. Im Zuge der Optimierung
sollte es auch das erklärte Ziel sein, den zu entwickelnden Zustandsautomaten sicher zu
machen. Wenn die Anzahl der Zustände m eine Potenz von 2 ist und ein binärer oder Gray
Code verwendet wird, ist der Zustandsautomat sicher. Zur Zustandscodierung werden
dann n Flipflops gemäß m = 2n verwendet. Da alle möglichen Zustandswerte (oder Flip-
flopzustände) erreichbar sind, ist der Entwurf sicher. Existieren allerdings m Zuständen
und es gilt m < 2n , oder es wird keine Binär- oder Gray-Codierung verwendet, so ist
der Zustandsautomat unsicher. In diesem Falle können Bitsequenzen vorkommen, die zur
Codierung nicht ausgenutzt werden. Man spricht von Pseudozuständen.
Generell werden die nicht erreichbaren Pseudozustände vom Synthesetool wegoptimiert.

Manchmal führt die Optimierung jedoch nicht zu einer für alle Szenarien sicheren Schal-
tung. Wird die Schaltung schon per Reset in einen ungültigen Zustand versetzt oder wird
diese in einer extremen Umgebung betrieben, kann beispielsweise durch Spannungsspit-
zen oder induzierte Strahlung ein fehlerhafter Zustand entstehen, der dazu führt, dass der
Automat hängebleibt“ und unbegrenzt in dem undefinierten Zustand verbleibt und nie
”
wieder in seinen normalen Betriebszustand zurückkehrt.
Pseudozustände müssen also im Entwurf explizit adressiert werden. Eine sinnvolle Zu-
standscodierung kann helfen, ebenso die klare Definition über eine mögliche Rückkehr
aus Pseudozuständen. Es existieren drei wesentliche Strategien zur Risikominimierung
von Pseudozuständen:
• Aufzählungstyp für Zustände mit Anzahl von Elementen (Zustandsnamen) dekla-
rieren, die Zweierpotenz entspricht
• case-Anweisung einer FSM mit when others“-Statement abschließen, um Rückkehr
”
aus unvorhergesehenen Zuständen explizit zu spezifizieren
• Codierungsschema für Elemente (Zustandsnamen) auf Bitebene spezifizieren
Falls möglich, sollte die Anzahl der Zustände immer auf eine Potenz von 2 gebracht wer-
den. Entscheidend ist dabei, dass alle Zustände auch genutzt werden. Allgemein können
Pseudozustände auch durch das when others“-Statement einer case-Anweisung abgedeckt
”
werden. Die Default-Einstellung der meisten Synthesetools entfernt allerdings unerreich-
bare Zustände, um die Performance der resultierenden Schaltung zu erhöhen. Dieser Op-
timierungsschritt birgt die Gefahr wiederum eine unsichere Schaltung zu generieren. Am
sichersten ist die Strategie, eine manuelle Codierung auf Bitebene per Konstanten zu ver-
wenden (vgl. Listing 4.27, Beispiel 3). Unabhängig von der Anzahl der Zustände wird das
Syntheseergebnis – auch bei Durchführung von Optimierungen seitens des Synthesetools
– aufgrund der nicht änderbaren Konstanten immer sicher sein.

5 Simulation und Zeitverhalten im
Digitalentwurf
Dieses Kapitel beschreibt die Grundsätze und Details bei der Designverifikation mit
VHDL. Ansätze für Verifikationsstrategien werden vermittelt, ebenso stehen die Struk-
turierung und der Entwurf umfangreicher und komplexer VHDL-Testbenches im Fokus.
Grundlagen zur digitalen Simulation ergänzen den Inhalt.
5.1 Testbench-Entwurf für die Simulation

Nach dem üblichen Design Flow mit VHDL (vgl. Abbildung 4.2) sind in unterschiedlichen
Etappen des Entwurfs Simulationen der entworfenen Schaltung nötig, bevor das Design
auf der Zielhardware in Betrieb genommen wird. Die Simulation liefert eine Vorhersage des
Verhaltens des Designs und bietet bessere Untersuchungsmöglichkeiten bezogen auf das
Verhalten einzelner Signale als die heuristische Trial and Error Methode. Darüberhinaus
werden bei sorgfältiger Simulation Schäden an der Hardware durch eventuell auftretende
Fehler vermieden.
Testbench
Stimuli- DUT Auswertung

Generierung Device Under Test
Abbildung 5.1: Schematische Darstellung einer Testbench
Nach Eingabe des VHDL-Codes und vor der Synthese lässt sich zunächst eine funktio-
nale Simulation durchführen, die der syntaktischen und funktionalen Überprüfung des
Codes dient. VHDL bietet viele Funktionen, die für die Simulation von digitalen Schal-
tungsentwürfen genutzt werden können. Dies geschieht im Rahmen einer sogenannten
Testbench, einer Umgebung zur Validierung des Entwurfs oder Modells, schematisch dar-
gestellt in Abbildung 5.1.
Die Testbench ist selbst eine VHDL-Datei, allerdings mit leerer Schnittstelle. In ihr sind
Schaltungsstimuli (Stimulisignale) und die entsprechenden, erwarteten Ausgaben hinter-
legt, die das zeitliche Verhalten der zu testenden Schaltung (DUT, engl. Device Under
Test) abbilden. Das DUT kann einzeln oder mit anderen DUTs getestet werden. Testben-
ches sind ein integraler Bestandteil eines jeden VHDL-Projekts und sollten immer zusam-
men mit der eigentlichen Schaltung entworfen werden. Aufgrund der Überprüfung aller
89
KAPITEL 5. SIMULATION UND ZEITVERHALTEN IM DIGITALENTWURF
Möglichkeiten haben Testbenches oft eine beachtliche Größe und deutlich mehr VHDL-
Code als das Design selbt. Auch kann die Simulationszeit beträchtlich sein.
Listing 5.1 zeigt das Gerüst einer Testbench für einen Multiplexer als DUT. Der Stimulus-
Prozess in der Architecture beschreibt die Zeitverläufe der Anregungssignale. Nicht darge-
stellt in dem Gerüst sind die obligatorische Instanziierung des DUT, sowie ein optionaler
Prozess zur Überprüfung der Ausgaben.
ENTITY tb_Mux2x1New IS -- keine externen E i ng an gs s ig na le

END tb_Mux2x1New ;
ARCHITECTURE testbench OF tb_Mux2x1New IS
SIGNAL IA , IB , S , E , Y : bit ; -- Deklaration lokaler Signale
-- hier : Einbindung der zu testenden Komponente ( nicht abgebildet )
BEGIN
stimulus : PROCESS -- keine S e n s i t i v i t a e t s l i s t e
BEGIN
E <= ’1 ’; S <= ’1 ’; IA <= ’1 ’; IB <= ’0 ’; WAIT FOR 150 ns ;
END PROCESS stimulus ; -- nach 600 ns wieder von vorne
END testbench ;
Listing 5.1: Stimulus-Prozess einer Testbench
Prozesse in der Testbench dürfen keine Sensitivitätsliste19 enthalten, stattdessen kom-

men wait-for-Anweisungen mit der Angabe konkreter Zeiten zum Einsatz. Die wait-for-
Anweisung ist nur innerhalb von Prozessen zulässig, alternativ kann die after-Anweisung
außerhalb von Prozesses verwendet werden (Listing 5.2). Beide Sprachkonstrukte sind
durch die Angabe konkreter Zeitwerte nicht synthesefähig. Der Vorteil bei der Verwen-
dung von Prozessen in der Testbench liegt darin, dass die Abarbeitung nach Durchlaufen
aller Anweisungen automatisch von vorn beginnt.
IA <= ’1 ’ AFTER 0 ns , ’0 ’ AFTER 150 ns , ’1 ’ AFTER 300 ns , ’0 ’ AFTER 500 ns ;

IB <= ’0 ’ AFTER 0 ns , ’1 ’ AFTER 150 ns , ’0 ’ AFTER 300 ns , ’1 ’ AFTER 400 ns ;
E <= ’1 ’ AFTER 0 ns , ’0 ’ AFTER 150 ns ;
S <= ’1 ’ AFTER 0 ns , ’0 ’ AFTER 300 ns , ’1 ’ AFTER 400 ns , ’0 ’ AFTER 500 ns ;
Listing 5.2: Generierung von Stimulisignalen außerhalb eines Prozesses
Das Verhalten des VHDL-Simulators lässt sich in definierten Fehlerfällen durch die Aus-
gabe von Fehlermeldungen und Warnungen bei bestimmen Bedingungen beeinflussen.
Dies geschieht durch sogenannte Assertions. Listing 5.3 illustriert dies anhand von zwei
Beispielen.
19
Die Testbench ist hierarchisch eine übergeordnete Einheit. Daher enthält sie keine Portsignale nach
außen und kann in ihren Prozessen auch nicht auf Signale reagieren. Eine Sensitivitätsliste ergibt also
keinen Sinn.

ASSERT ( x = y )
REPORT " Hinweis : x ist nicht y ! "
SEVERITY NOTE ;
ASSERT ( z = ’0 ’)
REPORT " Fehler gefunden ! z muss 0 sein ! "
SEVERITY FAILURE ;
Listing 5.3: Ausgabe von Fehlermeldungen und Warnungen
Die Assert-Anweisung prüft die angegebene boolesche Bedingung und gibt im Falle eines
falschen Prüfwertes eine Nachricht mit dem report-String im Simulator aus. Die Fehler-
klasse kann durch das Schlüsselwort Severity als Hinweis (engl. note), Warnung (engl.
warning), Fehler (engl. error ) oder Defekt (engl. failure) definiert und folgendermaßen
genutzt werden:
• note → dient der Ausgabe von allgemeinen Informationen
• warning → dient der Anzeige von möglichen unerwünschten Bedingungen
• error → dient der Meldung über den Erhalt eines falschen Ergebnisses
• failure → dient der Anzeige über eine nicht durchführbare Operation und führt
normalerweise zum Abbruch der Simulation
Wird in der Anweisung keine Fehlerklasse angegeben, findet eine Einordnung in die Klasse
error statt. Auch ist die Angabe eines Benachrichtigungstextes per report-String nicht
zwingend. Wird diese weggelassen, so wird eine Standardmeldung ausgegeben. Assertions
können sowohl als nebenläufige (direkt in der Architecture), als auch als sequentielle
Anweisungen (innerhalb eines Prozesses) formuliert werden. Da diese in der Hardware-
Umsetzung jedoch keine Bedeutung haben, werden sie vom Synthesetools ignoriert.
Die reine Funktionssimulation approximiert das Verhalten eines Schaltungsentwurfs unter
der Annahme, dass sich alle Ausgänge gleichzeitig ändern. Verzögerungszeiten spielen bei
der funktionalen Simulation keine Rolle, da in der Regel genau die Schaltungsbeschrei-
bungen simuliert werden, die später auch auf der Ziel-Hardware (FPGA) implementiert
werden. Die tatsächlichen Verzögerungszeiten sind ohnehin erst nach dem Placement &
Routing auf dem FPGA verfügbar.
Verzögerungszeiten können allerdings schon in der Simulation durch symbolische Lauf-
zeiten nachgebildet werden. Damit ist die Evalierung von Laufzeiteffekten und da-
mit des genauen Verhaltens der Hardware möglich. Man nutzt verzögerungsbehaftete
Signalzuweisungen, die nicht synthesefähig sind. In VHDL existieren unterschiedliche
Verzögerungsmodelle, auf die in Abschnitt 5.3 näher eingegangen wird.
5.2 Signalverzögerungen und Laufzeiteffekte

Jedes reale Logikgatter besitzt eine Signalverzögerungszeit, wie bereits in Abschnitt 2.4
ausführlich behandelt. Die Größenordnung des Propagation Delay tp beträgt einige ns.
Bei (älteren) TTL-Logikfamilien verhält sich tp unterschiedlich für die Übergänge Low →

High und High → Low, in der MOS-Technologie sind tpLH und tpHL in etwa gleich (vgl.
Abschnitt 6.2).
Während die funktionale Simulation einzig der syntaktischen und funktionalen
Überprüfung des Codes dient, lässt sich duch eine Timing-Analyse beobachten wie lange
es dauert, bis sich eine Änderung an den Eingängen auf den Ausgang auswirkt und welche
laufzeitbedingten Phänomente zum Tragen kommen.
Verschiedene Pfade durch die kombinatorische Logikschaltung benötigen unterschiedli-
che Signallaufzeiten, da Gatter in unterschiedlicher Anzahl und mit unterschiedlichen
Propagation Delays vorkommen können. Dadurch entstehen kritische Wettrennen“ von
”
Signalen, die Race Conditions genannt werden und zu fehlerhaften Zwischenzuständen
(Hazards) führen können. Da die Ursache in der Struktur des realisierten Schaltnetzes
liegt, spricht man von Strukturhazards. Abbildung 5.2 zeigt dazu eine Beispielschaltung
mit zugehörigem KV-Diagramm. Es sei angenommen, dass jedes Gatter ein Propagation
Delays von tp = 10ns aufweise.
X1 c1 X0
&
Y :
X2
c2 >=1 Y
X2 1 0 0 0 1
&
X0 c3 X1 0 1 1 1
Abbildung 5.2: Beispielschaltung und zugehöriges KV-Diagramm für Race Conditions
In der zugehörigen VHDL-Beschreibung können die Propagation Delays mit symbolischen

Laufzeiten bei der Signalzuweisung gemäß Listing 5.4 abgebildet werden. Abbildung 5.3
zeigt die Simulation der VHDL-Beschreibung.
ENTITY Hazard IS
PORT ( X0 , X1 , X2 : IN bit ;
Y : OUT bit
);
END Hazard ;
ARCHITECTURE Timing OF HAZARD IS
SIGNAL c1 , c2 , c3 : bit ;
BEGIN
c1 <= X1 AND X2 AFTER 10 ns ;
c2 <= NOT X2 AFTER 10 ns ;
c3 <= X0 AND c2 AFTER 10 ns ;
Y <= c1 OR c3 AFTER 10 ns ;
END Timing ;
Listing 5.4: VHDL-Beschreibung mit symbolischen Laufzeiten
Alle drei Eingänge x0, x1 und x2 sind zu Anfang auf den Signalwert 1 gesetzt. Bei
t = 100ns ändert sich der Wert des Signals x2 von 1 auf 0. Für die Bestimmung des
Ausgangs y wird x2 einmal in seiner negierten und einmal in seiner nicht-negierten Form
verwendet. Durch die am NOT-Gatter auftretende Verzögerung wird der Zwischenwert c1

Abbildung 5.3: Auftretende Hazards bei der Beispielschaltung
früher gebildet als der Zwischenwert c3, beide sind jedoch durch das OR-Gatter verknüpft
für den Ausgang y verantwortlich. Da der Sprung 0 → 1 durch das NOT-Gatter verzögert
an c3 auftritt, liegt am OR-Gatter für eine Dauer von 10ns auf beiden Eingängen eine 0
an und kommt es bei t = 125ns zu einem Hazard des Ausgangssignals y.
Bei t = 200ns ändert sich der Wert des Signals x2 erneut, diesmal von 0 auf 1 zurück.
Ein bei t = 225ns theoretisch möglicher Hazard tritt hier allerdings nicht auf, da durch
den verzögerten Wechsel 1 → 0 an c3 dennoch immer mindestens eine 1 am OR-Gatter
anliegt. Logisch hat dies keine Auswirkung auf y.
Ein Strukturhazard ist grundsätzlich behebbar durch Änderung der Struktur des Schalt-
netzes unter Beibehaltung der Funktion. Die Ursache von Strukturhazards liegt immer in
unverbundenen Vereinigungsblöcken. Im vorliegenden Beispiel sind das die Terme x1 · x2
und x0 · x2. Beim Pegelwechsel von x2 wird von einem Produktterm auf den anderen um-
geschaltet, wegen der Invertierung des x2-Signals dauert die Bildung der Produktterme
aber unterschiedlich lange. Ein zusätzlicher, überlappender Produktterm schafft hier Ab-
hilfe. Diese Methode funktioniert immer. Abbildung 5.4 zeigt die resultierende Schaltung
inklusive KV-Tafel.
X1 c1
&
X0
c2
X2 1 Y :
c3 X2
& >=1 Y
X0 0 0 0 1

X1 0
1
1
1
c4
&
Abbildung 5.4: Modifizierte Beispielschaltung mit eliminierten Race Conditions

5.3 Simulation von VHDL-Prozessen

Die Simulation von VHDL-Beschreibungen erfolgt zeitdiskret und ereignisgesteuert. Wenn
sich ein Signalwert ändert, wird diese Änderung als ein Ereignis (Signal Event) betrachtet,
das verarbeitet werden muss, um dessen Auswirkung auf die anderen Signale zu ermitteln.
Ereignisse treten zu diskreten Zeiten auf und Signale werden jeweils im nächsten diskreten
Zeitintervall aktualisiert.
5.3.1 Simulationsablauf
Um die Gleichzeitigkeit von Ereignissen und damit eine kontinuierliche Simulation in

einem sequentiell arbeitenden Simulator nachzustellen, existieren in VHDL sogenannte
Delta-Zyklen. Ein Delta-Zyklus ist eine imaginäre Zeiteinheit, in der Signalzuweisungen
gesammelt und aktualisiert werden. Dieser stellt die kleinste mögliche Zeiteinheit in der
Simulation dar, die dazu dient, Ereignisse zu trennen, die im gleichen Simulationszyklus
innerhalb der Simulationszeit auftreten. Pro Simulationszeitpunkt können beliebig viele
Delta-Zyklen existieren. Die Unterscheidung von simulierter Realzeit und Delta-Schritten
bildet die Nebenläufigkeit von Hardware nach.
Warten
Ausführung Signal-
beendet ereignis
Ausführen
+1d
Abbildung 5.5: Simulationsablauf in VHDL
Während der Simulation befindet sich jeder Prozess gemäß Abbildung 5.5 in einem
von zwei aufeinanderfolgenden Zuständen. Bei Änderung eines Signals aus der Sensiti-
vitätsliste (Signal Event) geht der Prozess in den Ausführungszustand über.
Im Ausführungszustand werden alle Anweisungen des Prozesses innerhalb eines Delta-
Zyklus sequentiell abgearbeitet und solange wiederholt, bis sich ein stabiler Zustand
einstellt. Delta-Zyklen werden so oft zu einer Simulationszeit hinzugefügt, wie es Si-
gnaländerung zu diesem Simulationszeitpunkt gibt. Signale werden dabei noch nicht
verändert. Die Änderungen werden (mit Zeitstempel) in einer Transaktionsliste vorge-
merkt. Die Simulationszeit bleibt dabei stehen. Gibt es keine Signaländerungen mehr,
wird ein echter Zeitschritt bis zum nächsten Ereignis getätigt
Innerhalb eines Prozesses können Signalen unterschiedliche Werte zugewiesen werden.
Erst am Ende des Prozesses werden alle Signale, die durch den Prozess verändert wur-
den, entsprechend der Transaktionslist aktualisiert. Bei Zuweisung unterschiedlicher Wer-
te wird die letzte Zuweisung übernommen. Zeitverzögerte Änderungen erfolgen entspre-
chend später. Im Wartezustand bleiben alle Signalwerte bis zum nächsten Prozessdurch-
lauf unverändert. Die Simulationszeit schreitet voran bis zum nächsten auszuwertenden
Ereignis.

Die gegenseitige Aktivierung von Prozessen verläuft ebenfalls in jeweils einem Delta-
Zyklus. Alle aktiven Prozesse werden quasi parallel abgearbeitet. Im Simulator werden
die Signale erst angezeigt, wenn das System stabil ist. Das Konzept der Delta-Zylen lässt
sich am besten anhand eines Beispiels verdeutlichen. Für die in Abbildung 5.6 gezeigte
Beispielschaltung soll das Verhalten am Ausgang c für eine Eingangsänderung 1 → 0
bestimmt werden.
a
In: 1à0 1 c
&
b
&
1
Abbildung 5.6: Beispielschaltung zur Analyse der Simulationsweise
Das Eingangssignal muss insgesamt drei Gatter passieren, ehe der Ausgang c bestimmt
werden kann. Nach dem NOT-Gatter am Eingang (Zwischensignal a) können für die
Bestimmung von c zwei Pfade eingeschlagen werden. Entweder es wird zuerst das NAND-
Gatter (Zwischensignal b) oder das AND-Gatter (Ausgang c) evaluiert. Je nachdem wel-
cher Pfad zuerst bestimmt wird, kann es zu zwischenzeitlichen Wechseln bei den zu be-
stimmenden Signalwerten kommen. Tabelle 5.1 verdeutlicht dies.
NAND-Gate zuerst evaluiert AND-Gate zuerst evaluiert

IN: 1→0 IN: 1→0
a: 0→1 a: 0→1
b: 1→0 c: 0→1
c: 0→0 b: 1→0
c: 1→0
Tabelle 5.1: Evaluierung der Gatter in Beispielschaltung
Je nach Komplexität der Schaltung können auch mehrere Iterationen erforderlich sein,
um das Ausgangssignal schließlich zu bestimmen. Es gestaltet sich mit diesem Vorgehen
also zufällig nach wievielen Schritten das Ergebnis vorliegt, je nachdem welcher sequenti-
elle Ablauf in der Evaluierung der Gatter gewählt wurde. Diese Problematik wird durch
Delta-Zyklen vermieden. Die gleiche Problemstellung mit Hilfe von Delta-Zyklen gelöst
zeigt Tabelle 5.2. Besonderes Augenmerk sei auf die Abfolge mehrerer Delta-Zyklen zu
einem festen Simulationszeitpunkt gerichtet. Zu jedem Delta-Zyklus ist das auslösende
Signalereignis, sowie die sich daraus ergebende Abhängigkeit für den nächsten Schritt
aufgetragen.
Die Herausforderung einer sinnvollen Abfolge in der Logikevaluierung, wie sie durch das
Hilfmittel der Delta-Zyklen ermöglicht wird, ist in realen Schaltungen natürlich nicht
gegeben, sondern tritt nur in physikalischen Simulationen auf.

Zeit Delta Event

0 ns 1 IN: 1→0
evaluiere Inverter
2 a: 0→1
evaluiere NAND, AND
3 b: 1→0
c: 0→1
evaluiere AND
4 c: 1→0
1 ns
Tabelle 5.2: Evaluierung der Gatter durch Delta-Zyklen
5.3.2 Verzögerungsmodelle
Delta-Zyklen werden benötigt, um Schaltungen, die ohne Verzögerungszeit modelliert

sind, sauber auflösen und simulieren zu können. Es lassen sich jedoch auch gezielt
Verzögerungen in der Zuweisung abbilden, wie bereits in Listing 5.4 angewendet. In VHDL
exisieren zwei verschiedene Arten von Verzögerungen:
• Trägheits-Verzögerung (Inertial Delay Modell)
• Nichtträge Verzögerung (Transport Delay Modell)
Das Inertial Delay Modell ist die in VHDL implementierte Standardverzögerung, die dem
Verhalten realer Hardware sehr ähnlich ist. Die Verzögerungszeit eines Gatters oder einer
Operation wird durch das after“-Statement spezifiziert. Alle Eingangspulse, die kürzer
”
sind als die spezifizierte Verzögerungszeit, werden ignoriert. Dies entspricht dem geltenden
Phänomen, dass physikalische Gatter kurze Impulse (Spikes) an den Eingängen absorbie-
ren und nur dann reagieren, wenn der Signalwert für eine bestimmte Zeitspanne an ihren
Eingängen verbleibt. Mit dem Inertial Delay Modell lassen sich also reale Bauelemen-
te mit endlicher Übertragungsbandbreite modellieren. Eingangsstörungen, deren Dauer
kürzer als diese Bandbreite ist, werden ignoriert.
Das Transport Delay Modell dagegen gibt alle Eingangspulse verzögert weiter.
Da es nicht die Standardverzögerung darstellt, muss es exlizit durch Angabe des
Schlüsselwortes transport“ spezifiziert werden. Dieses Verzögerungsmodell ist nützlich
”
zur Beschreibung von einfachen Drahtverbindungen oder PCB-Leitungen (engl. Prin-
ted Circuit Board ). Ebenso lassen sich hierdurch ideale Bauelemente mit unbegrenzter
Übertragungsbandbreite modellieren, was nützlich sein kann zur Simulation idealisierter
Bedingungen.
Listing 5.5 illustriert die beiden Verzögerungsmodelle. Es gibt ein Eingangsssignal
dummy in“, das jeweils mit einer Verzögerung von 10ns in invertierter Form auf
”
die Ausgänge dummy1 out“ und dummy2 out“ geleitet wird. Die unterschiedlichen
” ”
Verzögerungsmodelle kommen bei den Signalzuweisungen der Ausgangssignale in der Ar-

chitecture zum Tragen.
LIBRARY ieee ;
ENTITY Delaymodel IS
PORT ( dummy_in : IN bit ;
dummy1_out , dummy2_out : OUT bit
);
END Delaymodel ;
ARCHITECTURE Behavior OF Delaymodel IS
BEGIN
dummy1_out <= NOT dummy_in AFTER 10 ns ;
dummy2_out <= TRANSPORT NOT dummy_in AFTER 10 ns ;
END Behavior ;
Listing 5.5: VHDL Delay-Modelle im Vergleich
Das Simulationsergebnis ist in Abbildung 5.7 dargestellt. Der Signalverlauf des Ein-
gangssignals zeigt einen 5ns kurzen Signalwechsel bei 200ns, der beim Ausgangssignal
dummy1 out“ nicht mehr zu sehen ist. Der Signalwechsel ist kürzer als die spezifizier-
”
te Verzögerung und wird daher durch das Trägheitsmodell entfernt. Das Ausgangssignal
dummy2 out“ zeigt indes den kurzen Signalwechsel. Die nichtträge Verzögerung führt
”
dazu, dass das Ausgangssignal dem Eingang in der in der Verzögerungsanweisung ange-
gebenen Zeitspanne folgt, unabhängig davon wie schnell Signaländerungen erfolgen.
Die unterschiedliche Wirkungsweise der Verzögerungsmodelle wird durch das Vorgehen
des Simulators anhand der Transaktionsliste, schematisch dargestellt in Abbildung 5.8,
ermöglicht. Alle Signalzuweisungen werden zur späteren Aktualisierung in die Transakti-
onsliste eingetragen. Diese umfasst die Wertezuweisungnen sowie den Zeitpunkt, zu dem
diese Transaktion stattfinden soll. Signalzuweisungen erfolgen also nicht sofort.
Abbildung 5.7: Unterschiede zwischen Inertial und Transport Delay Modell in der Simulation
Die Liste ist nach zunehmender Zeit sortiert. Wenn eine neue Transaktion zeitlich vor
der ursprünglichen Transaktion liegt, wird die vorhandene Transaktion überschrieben.
Liegt die neue Transaktion zeitlich nach der ursprünglichen Signaländerung, wird die
neue Transaktion am Ende der Liste hinzugefügt. Dies sollte insbesondere bei verzögerten
Signalzuweisungen in Testbenches berücksichtigt werden, bei denen die einzelnen Zeit-
schritte bei aufeinanderfolgenden after-Anweisungen auch immer in aufsteigender zeitli-
cher Abfolge spezifiziert sein müssen.
Je nach Verzögerungsmodell werden die Transaktionen in der Liste unterschiedlich be-
handelt. Beim Transport Delay Modell erfolgt die Behandlung wie soeben beschrieben.

Der Unterschied beim Inertial Delay Modell besteht darin, dass zusätzlich zu dem Vorge-
hen Transaktionen mit kürzerer Impulsdauer als die spezifizierte Impulsverzögerungszeit
entfernt werden.
Transaktionen
Zeit …. t4 t3 t2 t1 0
Treiberwert
Wert …. v4 v3 v2 v1 Signal
Signaltreiber
Abbildung 5.8: Transaktionsliste für Signaländerungen in der Simulation
Das Inertial Delay Modell, wie auch das Transport Delay Modell, ermöglichen es dem
Entwickler, verschiedene zeitliche Verhaltensweise auf der VHDL-Ebene zu modellieren.
Insbesondere bei der Testbench-Modellierung kann dies nützlich sein, um Verzögerungen
sowohl auf Board-Ebene als auch innerhalb eines Schaltkreises darzustellen und zu unter-
suchen.

6 Logikarchitekturen und
Halbleitertechnologie
Dieses Kapitel widmet sich programmierbaren Logikarchitekturen und den Grundlagen

der Halbleitertechnologie. Programmierbare Logik hat im Vergleich zu festverdrahten Lo-
gikbausteinen viele Vorzüge und unterstützt zudem die Steigerung der Integrationsdichte.
Kenntnisse in den Grundlagen der mikroelektronischen Integrationstechnik sind zudem
für die Realisierung und das Verständnis logischer Vorgänge in integrierten Schaltungen
unabdingbar.
6.1 Programmierbare Speicher- und Logikbausteine

Programmierbare Bausteine, sogenannte Programmable Logic Devices (PLD), können zur
Implementierung beliebiger Logikfunktionen verwendet werden. Es sind integrierte Schalt-
kreise, deren Funktionalität erst nach der Chipherstellung durch den Anwender durch
Konfiguration bzw. Programmierung festgelegt wird.
Bei der Verwendung von Standard-ICs20 im Logikdesign werden eine hohe Anzahl ver-
schiedener ICs benötigt. Damit geht ein beträchtlicher Platzbedarf auf der Leiterplatte
einher. Zudem ist diese Designpraxis mit einem hohen Zeit- und Kostenaufwand für das
Einsetzen, Löten und Testen verbunden und sehr fehleranfällig.
Durch den Einsatz von PLDs kann ein einziger IC-Typ für verschiedenste Logikfunktionen
verwendet werden und eine große Zahl verschiedener Teilfunktionen mit ihm realisiert wer-
den. Dadurch werden insgesamt weniger ICs auf der Leiterplatte benötigt, der Platzbedarf
ist also geringer. Es fallen weniger kostspielige Montageprozesse an und durch die gerin-
gere Anzahl an Komponenten fällt auch der Energiebedarf deutlich geringer aus. Auch
die Fehlersuche und -behebung profitiert von der geringeren Anzahl an ICs und Schal-
tungsverbindungen. Diese Art der Logikimplementierung ist daher zuverlässiger und auch
flexibler, da Designfehler direkt im PLD korrigiert werden können und nicht so zeit- und
kostenintensiv sind wie Modifikationen auf Platinenebene.
Es gibt zwei grundlegende Arten von programmierbaren Bausteinen, wobei die Unterschei-
dung danach erfolgt wie die Logikfunktion umgesetzt wird. Einerseits kann die Funktion
als Wahrheitstabelle in Hardware realisiert werden. Tabelle 6.1 gibt einen Überblick über
die Bausteine dieser Kategorie. Die Speicherung der Tabelle kann flüchtig (als RAM,
Abk. engl. Random Access Memory) oder nichtflüchtig (als ROM, Abk. engl. Read Only
Memory) erfolgen.
20
Damit sind ICs mit fester Funktion gemeint, die für eine bestimmte Aufgabe konzipiert worden sind.
Diese diskreten Bauteile müssen auf einer Leiterplatte zu einer kompletten Schaltung zusammengefügt
werden. Dies bedingt in der Regel auch die Verwendung weiterer peripherer simpler Logik (engl. Glue
Logic), um die handelsüblichen integrierten Schaltungen zu verbinden.
99
KAPITEL 6. LOGIKARCHITEKTUREN UND HALBLEITERTECHNOLOGIE
Read Only Memory Random Access Memory

Festwertspeicher, nichtflüchtig Schreib-Lesespeicher, flüchtig
nichtlöschbar löschbar - SRAM (statisch)
- ROM - EPROM - DRAM (dynamisch)
- PROM (Ultraviolett-Löschung)
- OTP-ROM - EEPROM
(anwenderprog. ROM) elektr. löschb. (in circuit)
Tabelle 6.1: Bausteine zur Speicherung einer Tabelle (Programm)
ROMs enthalten bei der Herstellung verdrahtete und nicht änderbare Information, ein
PROM (Abk. engl. Programmable ROM ) kann dagegen einmalig vom Anwender program-
miert werden. Daher ist auch die Bezeichnung OTP-ROM (engl. One Time Programmable)
üblich, beschreibt aber das gleiche. Zu den Speichern, die löschbar und wiederbeschreibbar
sind, zählen EPROM (engl. Erasable Programmable Read Only Memory) und EEPROM
(engl. Electrically Erasable Programmable Read-Only Memory).
Das Löschen erfolgt bei EPROMs durch eine UV-Lichtquelle (Ultraviolett), die durch ein
Quarzfenster in das Innere des EPROM-Gehäuses scheint. Beim EEPROM wird ein elek-
trisches Feld anstelle einer UV-Lichtquelle verwendet. Die Programmierung erfolgt mit
Hilfe spezieller Programmiergeräte. EPROMs bieten im Vergleich zu PROMs eine gerin-
gere Speicherdauer, da das EPROM für Strahlung und elektrisches Rauschen empfänglich
ist. EEPROMs sind weniger anfällig.
Eingabe- Programmierbare Ausgabe-

Eingang Ausgang
Block UND/ODER-Matrix Block
Programmierbare
Rückkopplung
Abbildung 6.1: Prinzipieller Aufbau der PLDs
Wahrheitstabellen können auch in flüchtigen Speichern abgelegt werden. Dazu zählen sta-
tische und dynamische Speicher, also SRAM (Abk. engl. Static Random Access Memory)
oder DRAM (Abk. engl. Dynamic Random Access Memory). Diese können im Betrieb
beliebig beschrieben und ausgelesen werden, verlieren aber ihren Speicherinhalt nach dem
Abschalten der Versorgungsspannung.
Andererseits kann die Logik direkt als boolesche Funktion realisiert werden. In dieser
Kategorie unterscheidet man wiederum zwischen PLDs und FPGAs. Tabelle 6.2 gibt einen
Überblick über die Bausteine dieser Kategorie. Zu den PLDs zählen das PLA (Abk. engl.
Programmable Logic Array) und das PAL (Abk. eng. Programmable Array Logic). Diese
einfachen programmierbaren logischen Schaltungen bestehen typischerweise aus einem
Array von AND-Gattern und einem Array von OR-Gattern.
Abbildung 6.1 zeigt den prinzipiellen Aufbau. Einzelne PLDs unterscheiden sich in Breite
und Programmierbarkeit der Arrays. Eine Rückkopplung ermöglicht die Einbeziehung des

Ausgangssignals in den Verknüpfungen. Die internen logischen Gatter und Verbindungen

von PLDs können durch einen Programmierprozess verändert bzw. konfiguriert werden.
Die genannten Typen von PLDs unterscheiden sich in der Platzierung der programmier-
baren Verbindungen in den UND-ODER-Anordnungen.
Programmable Logic Device (PLD) Field Programmable Gate

Array (FPGA)
nichtflüchtig flüchtig, nichtflüchtig
Programmable Logic Complex PLD (CPLD) Matrix-Architektur von konfigu-
Array (PLA) rierbaren Logikblöcken (Lookup
Tables in CLBs)
Programmable Array Matrix-Architektur hierarchisch strukturierte kombi-

Logic (PAL) von mehreren PALs natorische Logik möglich
In-Circuit Programming
Tabelle 6.2: Bausteine zur Speicherung einer Logikfunktion
PALs wurden 1978 von der Firma Monolithic Memories Inc. (MMI) eingeführt. PALs
sind Sonderformen von PLAs, bei denen sowohl das UND-Array als auch das ODER-
Array programmierbar ist. PLAs sind inzwischen sehr selten und fast vollständig vom
Markt verschwunden. Während PALs nur einmal beschreibbar sind, stellen GALs (Abk.
engl. Generic Array Logic) eine Weiterentwicklung der PALs dar, die mehrfach (elektrisch)
beschreibbar ist.
Ein CPLD (Abk. engl. Complex Programmable Logic Device) kombiniert intern eine Viel-
zahl von PLD-Blöcken, deren Ein- und Ausgänge durch eine globale Verbindungsmatrix
miteinander verbunden sind. Somit hat ein CPLD zwei Ebenen der Programmierbarkeit:
Jeder PLD-Block kann programmiert werden, zusätzlich auch die Verbindungen zwischen
den PLDs.
Field Programmable Gate Arrays (FPGAs) wurden erstmals 1985 von der Firma Xilinx
vorgestellt und bestehen ähnlich wie ein CPLD aus untereinander vernetzten Blöcken,
jedoch sind diese komplexer. Es existieren drei programmierbare Hauptkomponenten:
Logikzellen, Verbindungsnetze und Input/Output-Zellen. Diese können vom Anwender
zuammenhängend programmiert werden. Die physikalische Struktur und die Art der Pro-
grammierung durch entsprechende Design-Software ist herstellerabhängig. Zu den größten
Herstellern zählen neben Xilinx noch Altera (inzwischen Intel21 ) und Lattice.
Heutzutage hat nur noch der Einsatz von CPLDs und FPGAs praktische Relevanz.
Dies ist – verglichen mit den anderen programmierbaren Bausteinen – in den geringeren
Einschränkungen, den größeren Logikressourcen und der Verwendung einer einheitlichen
Hardware-Programmiersprache begründet.
21
Die Übernahme des Chipherstellers Altera durch Intel wurde Ende 2015 abgeschlossen.

6.1.1 Kombinatorische Logik mit PROM
Mit einem ROM können kombinatorische Schaltungen realisiert werden, da der ROM-
Inhalt als Funktion der anliegenden Adresse interpretiert werden kann. Die Information
über das Verhalten der Schaltung wird in der Struktur und den Verbindungen des Spei-
chers gehalten, ohne dass tatsächlich Speicherkapazität benötigt wird.
I0 O0
feste UND-Matrix programmierbarer
I1 O1
ODER-Speicher
In-1 n à 2n Adress-Decoder 2n / k Matrix Ok-1
2n Minterm-Leitungen
Abbildung 6.2: PROM (Programmable Read Only Memory)
Abbildung 6.2 zeigt die Struktur des Speichers mit n Eingängen und k Ausgängen. Das
PROM verfügt über eine feste AND-Matrix (als n/2n -Decoder aufgebaut) und program-
mierbare Verbindungen zu der OR-Matrix am Ausgang.
Das PROM implementiert boolesche Funktionen als Summen von Mintermen, indem jede
Eingangsadresse eine von 2n Minterm- Ausgangsleitungen auswählt. Alle 2n Minterme
können auf jeden der k OR-Ausgänge gelegt werden, wobei jede mögliche OR-Verbindung
einem Programmierbit entspricht.
I2 I1 I0
1
prog. Verbindungen
&
&
&
&
&
&
&
&
>=1
>=1
>=1
>=1
O3 O2 O1 O0
Abbildung 6.3: Symbolische Darstellung eines 8x4 PROM

Mit m = 2n lassen sich in einem m x k -PROM (2n · k)-Bit programmieren (entspricht 2n -

Speicherworten mit Wortbreite k Bit). Abbildung 6.3 stellt den Aufbau eines 8x4 PROM,
also einem PROM mit 8 Mintermleitungen und 4 Ausgängen, symbolisch dar. Die AND-
Matrix kann wie eine Wahrheitstabelle angesehen werden, so dass jedes Bit des Inhalts
als boolesche Funktion der Adressbits I2 , I1 und I0 behandelt wird. Je nach gewünschter
logischer Funktion werden die Funktionen dann beliebig durch die OR-Matrix verschaltet.
Jeder Minterm läßt sich in allen OR-Verknüpfungen verwenden.
Die Voraussetzung für die Programmierung des PROMs ist die Normalform-Darstellung,
also keine minimierten Gleichungen. Die Wahrheitstabelle, die das kombinatorische Sys-
tem beschreibt, entspricht dann genau der Programmiertabelle.
Um das interne Logikdiagramm für solche Technologien in einer übersichtlichen Form dar-
zustellen, sind spezielle Symbole für die Matrix-Logik erforderlich. Abbildung 6.4 zeigt die
Matrix-Logiksymbole für die fest verdrahteten AND-Gatter mit mehreren Eingängen (fest
→ Kreis) und die programmierbaren OR-Gatter mit mehreren Eingängen (programmier-
bar → Kreuz) anhand eines Implementierungsbeispiels für das 8x4 PROM.
feste Verbindungen
x0 1
x1 1
x2 1
& & & & & & & &
entspricht
x x x x >=1 y0 x0
prog. Verbindungen
x x x x >=1 y1 x1
x x x x >=1 y2 x2
x x x x >=1 y3 Parity-Bit
Abbildung 6.4: Paritätsgenerator als Implementierungsbeispiel für 8x4 PROM
Das Implementierungsbeispiel umfasst einen Paritätsgenerator für 3 Eingangsbits und un-

gerade Parität. In Tabelle 1.4 wurde die Wahrheitstabelle für gerade und ungerade Parity
gereits angegeben. Die Eingangsleitungen zur AND-Matrix sind fest verdrahtet und ent-
sprechen allen möglichen Eingangskombinationen. Die Ausgangsleitungen zur OR-Matrix
sind programmierbar und wurden gemäß der beabsichtigten Funktionalität an den Stel-
len verbunden, an denen die entsprechende Eingangskombination in der Wahrheitstabelle
eine 1 liefert. Anders ausgedrückt, alle Minterme mit einer geraden Anzahl von Einsen
müssen am OR-Gatter des Ausgangs y3 , die durchgeschalteten Eingänge jeweils am ent-
sprechenden Ausgang y2 , y1 und y0 angeschlossen sein.

6.1.2 Kombinatorische Logik mit PAL
Sowohl ROM als auch PAL können verwendet werden, um beliebige logische Funktionen in
Form von Summenprodukten zu implementieren. Beim Entwurf mit einem PAL-Baustein
müssen die booleschen Funktionen allerdings vereinfacht werden, was in der Struktur des
Bausteins begründet ist.
I0 O0
programmierbare
I1 feste ODER-Matrix O1
UND-Matrix
In-1 mit 2n Eingängen Ok-1
p Produktterm-Leitungen
Abbildung 6.5: PAL (Programmable Array Logic Device)
Ein Blockdiagramm des PAL ist in Abbildung 6.5 dargestellt. Es besteht aus n Eingängen,
k Ausgängen und p Produkttermen. In PALs wird anstelle eines Decoders wie in PROMs
eine AND-Matrix bestehend aus p AND-Gattern verwendet, wobei p < 2n ist.
prog. UND-Matrix
x0 1
x1 1
x2 1
x3 1
x4 1
x5 1
x6 1
x7 1
x8 1
>=1 y0
>=1 y1
>=1 y2
>=1 y3
Abbildung 6.6: Symbolische Darstellung eines 9 x 20 x 4 PAL

Jedes der AND-Gatter kann so programmiert werden, dass es einen Produktterm der
Eingangsvariablen und nicht wie im ROM alle Minterme erzeugt. Alle n Eingänge können
in jedem Produktterm verwendet werden22 . Von den p Produktterme wird über die festen
Verbindungen der OR-Matrix eine beschränkte Anzahl zu je einem Ausgang verknüpft.
Da das PAL k Ausgänge hat, beträgt die Anzahl der OR-Gatter ebenfalls k.
Ein Produktterm kann nicht für mehrere Ausgänge gemeinsam verwendet werden. Dies
schränkt die Flexibilität bei der Implementierung ein. Zudem sollte beachtet werden, dass
beim PAL nur die Terme, die tatsächlich benötigt werden, in der AND-Matrix program-
miert werden, während in einem ROM alle Minterme durch die AND-Matrix erzeugt
werden müssen. Die Kennzeichnung eines PALs erfolgt in Abgrenzung zum ROM durch
die Angabe n x p x k.
x x
x0 1
prog. Verbindungen
x x
x x
x1 1
x x
x x
x2 1
x x
feste Verbindungen
& & & & & & & &
entspricht
>=1 y0 Parity-Bit
>=1 y1
Abbildung 6.7: Paritätsgenerator als Implementierungsbeispiel für 3x8x2 PAL
Der in Abbildung 6.6 gezeigte Aufbau eines 9 x 20 x 4 PAL zeichnet sich durch 9 Eingänge
und 4 Ausgänge aus. Jeder Eingang hat ein Buffer-Inverter-Gatter, jeder Ausgang wird
durch ein festes OR-Gatter erzeugt. Der Baustein hat 4 Abschnitte, die jeweils aus einer
5-Bit breiten AND-OR-Verbindung bestehen, d.h. in jedem Abschnitt gibt es 5 program-
mierbare AND-Gatter. Jedes AND-Gatter hat 18 programmierbare Eingangsanschlüsse,
die durch 18 horizontale Linien (als Ausgänge der Buffer-Inverter-Gatter) angezeigt wer-
den, die jede vertikale Linie schneiden. Die vertikale Linie symbolisiert die Mehrfach-
Eingangskonfiguration eines AND-Gatters.
Jeder Produktterm ist einem speziellen OR-Gatter zugeordnet. Damit ist die Anzahl der
Produktterme in jedem Abschnitt festgelegt. Wenn die Anzahl der Terme in der Funktion
groß ist, d.h. die Breite der Abschnitte aus AND-OR-Verbindungen übersteigt, kann es
notwendig sein, zwei oder mehr Abschnitte zu verwenden, um eine Boolesche Funktion zu
implementieren. Eine DNF-Minimierung ist in jedem Falle empfehlenswert. Die reduzierte
Anzahl von P-Termen in dem zu realisierenden kombinatorischem Ausdruck ermöglicht
so eine bessere Nutzung der PAL-Hardware.
Am Beispiel des Paritätsgenerators zeigt Abbildung 6.7 die Implementierung für ein 3x8x2
PAL. Eine Minimierung des Ausdrucks ist nicht möglich, es werden 4 Terme gebildet. Die
22
Bei manchen Bausteinen gibt es Einschränkungen. Es sollte in jedem Falle das Datenblatt zu Rate
gezogen werden.

Abbildung 6.8: Grundstruktur eines PAL (GAL)
in dem gewählten Baustein zur Verfügung stehenden Ressourcen reichen zum Durch-
schleifen der Eingänge nicht aus. Daher wird nur ein Ausgang für die Anzeige der Parity-
Information genutzt.
In der Praxis sind PALs oft mit variablen konfigurierbaren Ausgangsblöcken ausgestattet.
Die Ausgangszelle kann dabei als kombinatorischer Ausgang, als registerter Ausgang oder
als Eingang genutzt werden. Flipflops dienen unter anderem der Implementierung einer
Zustandsmaschine. So können sowohl rein kombinatorische, als auch sequentielle Schal-
tungen realisiert werden. Einige der PAL-Ausgänge sind mit zusätzlichen Buffer-Inverter-
Gattern verbunden und werden über programmierte Verbindungen zu den Eingängen
der AND-Matrix zurückgekoppelt. Gleiches gilt auch für GALs. In Abbildung 6.8 ist die
gesamte Struktur eines PAL (GAL) dargestellt. Tabelle 6.3 fasst die wesentlichen Unter-
schiede zwischen PROM und PAL abschließend noch einmal zusammen.
PROM PAL
Programmierbar ODER-Matrix UND-Matrix
Vorteil gemeinsam nutzbare Minterme Implementierungsvorteile bei

minimierten Gleichungen
Nachteil DNF-Darstellung mit vollstän- keine gemeinsam nutzbaren
digen Mintermen erforderlich Produktterme wegen fester
Zuordnung zu den ODER-
Gattern
Tabelle 6.3: Zusammenfassung zu PROM und PAL

6.1.3 Field Programmable Gate Arrays
Field Programmable Gate Arrays (FPGAs) unterscheiden sich von PLDs darin, wie die
zu konfigurierenden Logikblöcke angeordnet sind, wie diese zur Implementierung (kombi-
natorischer und auch sequentieller) Logik genutzt werden, sowie in der Technologie der
Konfigurationszellen.
Bei PLDs werden die Verbindungen zwischen den Logikblöcken durch eine zentrale Schalt-
matrix geführt. Diese gewährleistet, dass die Blöcke untereinander fast beliebig miteinan-
der verbunden werden können. Die geometrische Lage der Blöcke zueinander auf Chipe-
bene hat weder für das Routing, noch für das Zeitverhalten der Signale eine Bedeutung.
Allerdings ist durch diese Architektur die erreichbare Logikdichte sehr beschränkt, da die
Schaltmatrix mit zunehmender Anzahl von Logikblöcken quadratisch wachsen muß. Bei
FPGAs existiert keine zentrale Schaltmatrix. Vielmehr sind die konfigurierbaren Logik-
blöcken (CLBs) gleichmäßig über die Chipfläche in Matrixanordnung verteilt. Die grund-
legende Struktur ist in Abbildung 6.9 anschaulich dargestellt.
programmierbare
Verbindungen
I/O Blöcke
Logikzellen
Abbildung 6.9: Prinzipieller Aufbau von FPGAs
FPGAs basieren auf dem Prinzip, dass nahezu jede digitale Schaltung aus den beiden
Grundelementen Lookup Tables (LUTs) und Flipflops realisiert werden kann. Diese bei-
den Elemente, zusammen mit Multiplexern, die für die interne Verschaltung innerhalb
der Blöcke nötig sind, bilden die Basis für die CLBs. Jeder CLB kann so konfiguriert
werden, dass er eine beliebige Boolesche Funktion seiner Eingangsvariablen implemen-
tiert. Die Implementierung sequentieller Logik wird durch das Vorhandensein der Flipflops
ermöglicht.
Typischerweise haben CLBs zwischen 4-6 Eingangsvariablen. Funktionen mit einer
größeren Anzahl von Variablen werden über mehrere CLBs verteilt. Diese werden mitein-
ander verbunden, um das Zieldesign vollständig zu implementieren. Die Verbindung der
CLBs, ebenso wie die Anbindung an externe Anschlüsse erfolgt mit einem konfigurierbaren
Verbindungsnetzwerk.
Die programmierbaren Verbindungen stellen horizontale und vertikale Routingkanäle be-
reit. Im Gegensatz zu PLDs ist die geometrische Lage der Logikblöcke maßgebend für
den Verlauf der genutzten Verbindungswege und damit auch für das Zeitverhalten der
zu realisierenden Schaltung. Signale zwischen nicht direkt benachbarten Zellen müssen

über geeignete Verbindungsresourcen geführt werden. Diese fügen dem Design zusätzliche
Verzögerungen hinzu, die umso größer sind, je größer der Abstand der zu verschaltenden
Blöcke ist und je mehr Verbindungspunkte genutzt werden.
Aufgrund des hohen Einflusses des Routings auf die Performance lässt sich per Constraints
angeben, welche Verbindungen zeitkritisch sind. Da meist verschieden schnelle Routing-
kanäle zur Verfügung stehen und kurze Verbindungen schneller sind als solche, die mehr
Verbindungspunkte nutzen, lässt sich auf das Routing so etwas Einfluss nehmen. Belastba-
re Aussagen über das Zeitverhalten der implementierten Schaltung sind immer erst nach
Durchlaufen des Placement & Routing Schrittes im Design Flow (vgl. Abschnitt 4.1.2)
möglich.
Um mit der Außenwelt zu kommunizieren, d.h. um Signale in den Chip herein- und wie-
der herauszuführen, existieren konfigurierbare I/O Blöcke, die das Innenleben mit den
physischen Pins des FPGA-Chips verbinden. Diese bestehen aus Eingangs- und Aus-
gangsbuffern mit Tristate- und Open-Collector Ausgängen. Typischerweise befinden sich
an den Ausgängen Pull-Up Widerstände, manchmal auch Pull-Down Widerstände, die
zur Terminierung von Signalen und Bussen verwendet werden können, ohne dass diskrete
Widerstände auf Board-Ebene außerhalb des Chips erforderlich sind.
Die Polarität der Ausgänge kann für eine active-high oder active-low Signalisierung pro-
grammiert werden, in der Regel können auch die beabsichtige Signalgeschwindigkeit
bzw. Flankensteilheit (engl. slew rate) sowie diverse I/O Standards konfiguriert wer-
den. Dazu zählen Single-Ended-, sowie differentielle Signalstandards einschließlich LVDS-
Terminierung durch digital gesteuerte Impedanz- und Signalhub-Bereiche. Die Ausgänge
sind mit Flipflops ausgestattet, so dass getaktete Signale ohne nennenswerte Verzögerung
direkt an die Pins geleitet werden können, was die Anforderungen an die Setup-Zeit
der nachfolgenden Schaltungen verringert. In gleicher Weise reduzieren Flipflops an den
Eingängen die Verzögerung bei der Weiterleitung in die CLBs und somit die erforderliche
Haltezeit des FPGAs.
Zusätzlich zur in Abbildung 6.9 dargestellten Struktur verfügen moderne FPGA Archi-
tekturen meist noch über weitere zusätzliche Funktionsblöcke, wie DSPs (engl. Digital
Signal Processing), integrierte RAM-Blöcke, High-Speed Transceiver, integrierte Prozes-
soren, sowie DCMs (engl. Digital Clock Manager ) und PLLs (engl. Phase Lock Loop,
Phasenregelschleifen zur Frequenzgenerierung) zur Verwendung bei der internen Takter-
zeugung.
Mit Hilfe mehrerer tausend unabhängiger DSP-Blöcke in modernen FPGAs sind Multipli-
kationen und Additionen auf breiten Datenstrukturen (typischerweise 18 · 27 Bit), sowie
Berechnungen in Fließkomma-Arithmetik möglich. Integrierte RAM-Blöcke der Größe 2
bis 33 Mbit (je nach FPGA-Typ) dienen zum einen der einfachen lokalen Zwischenspei-
cherung hoher Mengen von Daten im FPGA, zum anderen der Realisierung anwendungs-
spezifischer Speicherarchitekturen wie FIFOs (First In First Out) oder Lookup Tables
(LUTs). Die konfigurierbaren High-Speed Transceiver für schnelle serielle Verbindungen
unterstützen aggregierte Datenraten von 10 - 100 Gbit/s bei einer Kanaldatenrate von
maximal 6,25 Gbit/s. Über Extension-Boards oder entsprechende On-Board Anbindun-
gen lassen sich damit beispielsweise Gigabit Ethernet oder QSFP+ Schnittstellen, sowie
PCIe- oder Hypertransport-Links realisieren.

Die Integration eines Prozessors innerhalb eines FPGAs bietet oft Vorteile: mehr Flexibi-
lität im Design, weniger Komponenten auf Platinenebene, einfache Adaptierbarkeit. Man
unterscheidet zwischen Hardcores und Softcores. Letztere sind Prozessorimplementierun-
gen in einer HDL-Sprache ohne umfangreiche Optimierung für die Zielarchitektur. Sie
haben in der Regel eine geringere Performance und sind in Bezug auf die Ressourcennut-
zung weniger effizient. Hardcore-Prozessoren sind auf die Zielarchitektur optimiert und
in diese als Hardware-Modul eingebettet, also in den Silizium-Chip des FPGA physika-
lisch integriert. Die Logik-Ressourcen des FPGAs werden somit nicht genutzt und stehen
weiterhin in vollem Umfang zur Verfügung.
Abbildung 6.10: Aufbau eines Logic Elements
Grundsätzlich stehen für jeden FPGA diverse Bibliotheken mit fertigen Schaltungsblöcken
(IP Cores, engl. Intellectual Property) über den Hersteller kostenlos oder kostenpflichtig
zur Verfügung. Diese können zur Ergänzung eigener Designs eingesetzt werden.
Sowohl die Funktionalität der Logikzellen, als auch die Verbindungen zwischen den CLBs
werden durch den Konfigurationsspeicher bestimmt. Dieser besteht aus SRAM-Zellen,
die auf dem FPGA-Chip verteilt sind. Da SRAM eine flüchtige Speichertechnologie ist,
muss ein FPGA beim Einschalten jeweils neu konfiguriert werden. Dies erfordert entweder
eine Verbindung zu einem PC (über JTAG23 ) oder einen Flash-EEPROM Baustein auf
dem FPGA-Board, aus dem die Konfigurationsdaten beim Einschalten geladen werden
können.
FPGAs werden meist mit Taktraten zwischen 20 - 200 MHz getaktet, also sehr viel langsa-
mer als moderne CPUs. Durch die massiv parallele Datenverarbeitung lassen sich dennoch
23
JTAG (Joint Test Action Group) bezeichnet den IEEE-Standard 1149.1 zur Programmierung und zum
Debugging von Hardware und auf Leiterplatten.

enorme Performance-Gewinne erzielen, so dass ein 50 MHz Design auf einem FPGA (je
nach Anwendung) eine Software-Realisierung auf einem 3 GHz Prozessor spielend in Re-
chenzeit und Leistungsaufnahme übertreffen kann.
Im begleitenden Labor zu dieser Vorlesung werden unterschiedliche digitale Schaltungen
entworfen und simuliert, die in ihrer Komplexität von einfachen Funktionen bis hin zu
komplexen Automaten reichen. Grundlage der Implementierung ist das Terasic Altera
DE2-115 Board [Tera10]. Dieses Board kombiniert eine Vielzahl von Logik- und I/O-
Bausteinen auf einer gemeinsamen Leiterplatte. Das Kernstück bildet ein Altera Cyclone
IV EP4CE115 FPGA mit ≈ 114.480 Logikelementen24 (LE, engl. Logic Elements), der
kleinsten Einheit, die der Implementierung beliebiger kombinatorischer sowie sequentieller
Logikstrukturen dient.
Abbildung 6.11: Aufbau eines Logic Array Blocks (LAB)
Es stehen mehrere Speicherkomponenten (SDRAM, SRAM und Flash-RAM), sowie LC-

Display, zahlreiche LEDs, Taster und Schalter zur Verfügung. Darüber hinaus verfügt
das DE2-115 Board über zahlreiche Schnittstellen, wie PS/2-Tastatur, USB-Maus, VGA-
Monitor, Kamera, Mikrofon, Lautsprecher, Ethernet, RS-232 (serieller Anschluss), SD-
Karte und IrDA (Infrarot). Diese werden in den Laborversuchen zwar nicht explizit be-
nutzt, könnten jedoch interessant für weitere eigene Entwicklungen sein.
24
Jeder FPGA-Hersteller benennt die logischen Basisblöcke unterschiedlich. In einem FPGA von Altera
werden Sie mit Logic Element“, kurz LE, bezeichnet. Xilinx nutzt den Begriff Configurable Logik
” ”
Block“, kurz CLB. In diesem Skript wurde dafür bisher einheitlich der Begriff CLB verwendet.

Der Cyclone IV zählt zu Alteras Low-Cost, Low-Power FPGA Famile. Produziert wird
diese in einer TSMC25 60nm-Technologie (2009). Bausteine mit bis zu 150k Logic Elements
(LE) sind verfügbar. Die LEs sind in Logic Array Blocks (LAB) gruppiert, die spalten-
und reihenweise über den Baustein verteilt sind.
Zur lokalen Speicherung gibt es RAM-Speicherblöcke, die als Dualport- oder Singleport-
Speicher mit einer Breite von 1 bis 36 Bit konfiguriert und bei einer Frequenz von bis zu 200
MHz betrieben werden können. Die Speicherblöcke sind spaltenweise zwischen bestimmten
LABs angeordnet. Pro Speicherblock stehen 4 kBit plus Parität (4.608 Bit) zur Verfügung,
insgesamt beläuft sich das Speichervolumen auf bis zu 6,3 Mbit Embedded Memory. Die
FPGA-Familie bietet in Ergänzung zu den Logikressourcen bis zu 360 Multiplizierer der
Breite 18 · 18 Bit für DSP Anwendungen, sowie bis zu 8 High-Speed Transceiver (je max.
3,125 Gbps, inkl. 8B/10B Encoder/Decoder) [Alte16].
Abbildung 6.12: Aufbau eines I/O Elements (IOE)
Abbildung 6.10 zeigt den Aufbau eines Logic Elements. FPGA-typisch werden Logikgat-
ter mit Hilfe einer LUT implementiert, die hier als 16x1 SRAM mit vier Eingängen und
einem Ausgang vorliegt. Die Wahrheitstabelle für die gewünschte Funktion wird während
der Programmierung in den SRAM geladen. Eine einzelne LUT kann jede beliebige kom-
25
TSMC ist die Abkürzung für Taiwan Semiconductor Manufacturing Corporation, der weltweit dritt-
größte Halbleiterhersteller.

binatorische Funktion mit vier Eingängen und einem Ausgang modellieren, indem die
über die angelegten Adressen des SRAM die konfigurierte Logikfunktion selektiert wird.
4
Rechnerisch führt dies zu 22 = 216 verschiedenen Logikfunktionen.
Komplexere Logikfunktionen erfordern Verbindungen zwischen mehreren Logikelemen-
ten. Die LUTs können über Multiplexer kaskadiert werden, zudem existiert eine spezielle
Carry-Logik zur Implementierung von zeitkritischen Strukturen (Addierer, Akkumulato-
ren, Zähler,etc.), sowie eine Carry Chain zur direkten (schnellen) Verbindung benachbar-
ter LEs in derselben Spalte. Der Ausgang der LUT kann in ein D-Flipflop und dann in das
Verbindungsnetzwerk eingespeist werden. Clock-, Clear- und Preset-Signale können durch
interne Logik oder einen externen I/O-Pin angesteuert werden. Das Flipflop kann so kon-
figuriert werden, dass es als D-Flipflop, T-Flipflop, JK-Flipflop oder SR-Latch arbeitet,
zudem ist eine Rückkopplung des Flipflopausgangs auf den Eingang der LUT möglich.
Das Flipflop kann in Verbindung mit der LUT oder eigenständig genutzt werden.
Abbildung 6.11 zeigt den Aufbau eines Logic Array Block (LAB). Ein LAB umfasst 16
LEs, Kontrollsignale, LE Carry Chains, Registerketten, lokale Interconnect-Ressourcen,
sowie einen Zugang zu den chipweiten Zeilen- und Spaltenverbindungen. Die Verschal-
tung der einzelnen Blöcke des FPGAs erfolgt an den horizontalen und vertikalen Kreu-
zungspunkten der Leitungssegmente (Schaltmatrizen). Zum Zwecke einer flexiblen und
dennoch leistungsfähigen Zusammenschaltung von Ressourcen existiert eine hierarchisch
untergliederte Verbindungsarchitektur mit Leitungssegmenten unterschiedlicher Länge:
Local Interconnects, DirectLink-Verbindungen und MultiTrack Interconnects. So können
die Einflüsse von Leitungswiderstand und Signalverzögerungszeit reduziert werden.
PAL / GAL CPLD FPGA

Logik-Ressourcen wenige, sehr einfache wenige, komplexe viele, sehr einfache
Ressourcen Ressourcen Elemente
Umsetzung von kom-
plexer Logik erfor-
dert viele Module
Verbindungen Verdrahtungsmatrix Schaltmatrix Logik kann global
und lokal genutzt
werden
Geschwindigkeit sehr schnell, lang- schnell abhängig von Place-
sam beim Einsatz ment & Routing
von Rückkopplungen
Zeitl. Verhalten vorhersagbar vorhersagbar nicht vorhersagbar
Software PLD-Compiler Mapper / Fitter Simulation, Synthe-
se, Place & Route
Tabelle 6.4: Einordnung programmierbarer Hardware-Architekturen
Local Interconnects dienen der Verbindung einzelner Logikelemente innerhalb eines LABs.
DirectLink-Verbindungen stellen die nächsthöhere Ebene dar. Sie verbinden unmittelbar
benachbarte FPGA Logikblöcke und bieten das flexibelste und schnellste Routing über
Logikblock-Grenzen hinweg. Einen globaleren Ansatz verfolgen MultiTrack Interconnects.

Sie verbinden Blöcke mit größerer räumlicher Distanz über horizontale und vertikale
Verbindungskanäle unterschiedlicher Länge. Zur Minimierung von Laufzeitunterschieden
beim Verteilen des Taktsignals existieren bis zu 20 globale High-Speed Taktnetze. Jedes
Taktnetz umfasst bis zu vier PLL-Strukturen zur Anpassung der Phase und Frequenz.
Die Konfiguration erfolgt wie bei den LEs durch das Setzen von SRAM-Speicherbits.
Jeder I/O-Pin des Cyclone IV FPGAs wird von einem I/O-Element (IOE) gespeist, das
sich an den Enden der LAB-Zeilen und -Spalten an der Peripherie des Bausteins befin-
det. Es werden verschiedene Single-Ended- und differentielle I/O-Standards unterstützt,
jedes IOE enthält einen bidirektionalen I/O-Buffer sowie drei Register zur Speicherung
von Eingangs-, Ausgangs- und Enable-Signalen (1 Input Register, 2 Output Register, 2
OE Register). Vier Takt-I/Os sind mit den acht globalen Low-Skew-Taktleitungen des
Bausteins verbunden. Den Aufbau eines I/O Elements (IOE) zeigt Abbildung 6.12.
Als Zusammenfassung stellt Tabelle 6.4 nocheinmal alle wesentlichen Merkmale der be-
schriebenen programmierbaren Bausteine gegenüber.
6.2 Halbleitertechnologie und Schaltungstechnik

Alle bisher behandelten Logikfunktionen können durch verschiedene Typen von Halb-
leiterbauelementen realisiert werden. Halbleiterbauelemente bestehen aus einem Ma-
terial, das weder ein guter Leiter noch ein guter Isolator ist. Aufgrund ihrer Zu-
verlässigkeit, Miniaturisierbarkeit und geringen Kosten eignen sie sich zur Integration
in komplexe, aber leicht aufzubauende mikroelektronische Schaltungen. Dies macht sie
zur Schlüsseltechnologie der meisten elektronischen Systeme.
Abbildung 6.13: Entwicklung in der Mikroelektronik
Integrierte Schaltungen bestehen aus einigen wenigen bis zu Milliarden Bauelementen, die
auf einem einzigen Halbleitersubstrat oder Wafer hergestellt und miteinander verbunden
sind. Die fortlaufende Miniaturisierung integrierter Schaltungen aus Transistoren, Dioden

und Speicherkondensatoren sorgt unter anderem für schnellere Datenverarbeitung und

sinkenden Energieverbrauch und wird durch das sog. Moore’sche Gesetz beschrieben.
Das Mooresche Gesetz ist die empirische Beobachtung von Gordon E. Moore (Intel),
dass die Anzahl der integrierten Transistoren exponentiell ansteigt und sich die Kom-
plexität und die Leistung integrierter Schaltungen in etwa alle 18 Monate verdoppelt26
[Moor65] [Moor75]. Geleitet durch die von Robert H. Dennard (IBM) formulierte Dennard-
Skalierungsregel [Denn74], intelligente Optimierung, rechtzeitige Einführung neuer Pro-
zesstechnologien, immer feineren Bauteilstrukturen und Materialien hat sich das Moo-
re’sche Gesetz 40 Jahre lang ungebrochen fortgesetzt.
Abbildung 6.13 zeigt die Entwicklung in der Mikroelektronik anhand der fortschreiten-
den Integrationsdichte bis ins Jahr 2020. Über einen Zeitraum von 40 Jahren hat sich die
Anzahl der Transistoren in Mikroprozessoren in etwa alle 2 Jahre verdoppelt. Die Taktfre-
quenz hat sich ebenfalls alle 2 Jahre verdoppelt, die Chipfläche wuchs aufgrund von immer
kleineren Strukturen dagegen nur jeweils um 14%. Allerdings beginngt diese Entwicklung
bereits zu stocken. Die Ursache liegt in thermischen Problemen, die unvermeidlich ent-
stehen, wenn immer mehr Stromkreise auf immer kleinere Flächen integriert werden. Die
sich immer schneller durch kleinere Schaltkreise bewegenden Elektronen heizen die Chips
zu stark auf und Wärme ist schwer abzuführen.
Die Hersteller erkannten dieses Problem und griffen zu der Lösung, statt einer Erhöhung
der Taktfrequenz die Integration mehrerer Rechenkerne voranzutreiben. So ließ sich trotz
der stagnierenden Taktfrequenz weiterhin die Leistungskurve des Mooreschen Gesetzs
einhalten. Aus Abbildung 6.13 ist klar ersichtlich, dass die maximale Taktfrequenz seit
2005 nicht mehr gestiegen ist. Eine weitere beliebige Verkleinerung von Siliziumstrukturen
wird allerdings nicht möglich sein, weil immer mehr unwägbare Quanteneffekte zum Tra-
gen kommen, die die Zuverlässigkeit beeinträchtigen. Zukünftig werden 3D-Integration
und neue Werkstoffe an Bedeutung gewinnen und die Integration von Nicht-Standard-
Komponenten im Vordergrund stehen.
Ein gängiges Maß für die Komplexität einer Integrierten Schaltung (IC) ist das Gatter-
Äquivalent (GE). Es gibt die ungefähre Anzahl der diskreten Logikgatter an, die für die
Implementierung der gleichen Funktion erforderlich wäre. Meist ist ein Gatter-Äquivalent
auf 1 NAND-Gatter bezogen, allerdings kann dies auch auf alle elementaren NOT-, OR-
und AND-Logikfunktionen bezogen werden. Das Gatter-Äquivalent ist also eine Maßein-
heit, mit der die fertigungstechnisch unabhängige Komplexität digitaler elektronischer
Schaltungen angegeben werden kann.
Es gibt verschiedene Ordnungen von Integrationsdichten für integrierte Schaltungen. Ta-
belle 6.5 zeigt eine Übersicht. Die ersten integrierten Schaltkreise enthielten nur wenige
Transistoren und wurden daher als Small Scale Integration (SSI)“ bezeichnet. Sie enthiel-
”
ten < 10 unabhängige Gatter, deren Ein- und Ausgänge direkt mit den Pins des Gehäuses
verbunden waren (diskrete Gatter). Auf SSI folgte die Einführung von Komponenten, die
26
Gordon Moores Vorhersage aus dem Jahr 1965 besagte, dass sich die Anzahl der Komponenten auf
einem integrierten Schaltkreis jedes Jahr verdoppeln würde. Als die Integration bis 1975 erstaunliche
65.000 Komponenten erreichte, revidierte Moore sein Gesetz der Verdopplung der Transistoranzahl auf
alle 2 Jahre. Das wiederum bedeutete, dass sich die Leistung von Computerchips etwa alle 18 Monate
verdoppeln würde (ohne Zunahme des Stromverbrauchs).

Integrations- Zeitraum Anzahl Gatter- Typische

level Transistoren äquivalente Anwendung
SSI 1950er 1 − 40 1 − 10 einzelne Logikgatter
MSI späte 1960er 40 − 400 10 − 100 einfache Schaltnetze
und Schaltwerke
LSI späte 1970er 400 − 60k 100 − 10k Taschenrechner,
Speicher, PLD
VLSI Mitte 1980er 60k − 1M 10k − 600k Mikroprozessor,
Speicher, CPLD
ULSI 1990er 1M − 40M 600k − 10M System-On-A-Chip
GSI Gegenwart > 40M > 10M Pentium-IV, Dual-
Core, etc.
Tabelle 6.5: Integrationsdichte von integrierten Schaltungen
bis zu 400 Transistoren auf jedem Chip enthielten und daher Medium Scale Integration
”
(MSI)“ genannt wurden. Dabei wurden bis zu 100 Gatter in spezifischen Funktionen inte-
griert, z.B. Addierer, Multiplexer und Decoder. MSI war wirtschaftlich attraktiv, da die
Systeme mit geringeren Kosten, kleineren Leiterplatten, weniger Montageaufwand und
einer Reihe weiterer Vorteile hergestellt werden konnten.
Die nächste Entwicklung war die Large Scale Integration (LSI)“, die beginnend in den
”
1970er Jahren in großen Mengen die Halbleiterwelt eroberte. Die Entwicklung von LSI
wurde durch wirtschaftliche Faktoren vorangetrieben und jeder Chip bestand aus Zehn-
tausenden von Transistoren. Bis zu 10k Gatter auf einem Chip ermöglichten digitale
Komponenten wie PLDs und auch integrierte Speicherlösungen.
Auf LSI folgte die Very Large Scale Integration (VLSI)“, bei der Hunderttausende von
”
Transistoren integriert wurden. Erstmalig konnte eine CPU auf einer einzigen integrier-
ten Schaltung hergestellt werden, um so einen Microprozessor zu produzieren. Auch die
Speicherdichte erhöhte sich und 1986 wurde der ersten 1-Mbit-RAM-Chip präsentiert,
der auf mehr als einer Million Transistoren basierte. Mitte der 1990er Jahre produzierte
Microprozessor-Chips enthielten bereits mehr als drei Millionen Transistoren. ULSI steht
für Ultra Large Scale Integration (VLSI)“ und entspricht mehr als 1 Million Transisto-
”
ren. Es gibt jedoch keinen qualitativen Sprung zwischen VLSI und ULSI, daher wird in
Fachtexten meist der Begriff VLSI für ULSI verwendet.
Giga Scale Integration (GSI)“ ist die Technologie mit der derzeit höchsten Integrations-
”
dichte und mehr als einhundert Millionen bis zu einer Milliarde Transistoren pro Chip.
Entsprechende integrierte Schaltungen arbeiten mit Strukturbreiten von 50nm und darun-
ter. Die meisten integrierten Lösungen, wie aktuelle System-On-A-Chips, Computer- und
Mobilprozessoren, Audio- / Videocodecs, Grafikverarbeitungseinheiten, FPGAs, High-
End Mikrocontroller, große Speicherchips, DSPs, sowie Video-/Bildprozessoren basieren
auf GSI.
Der Pentium-IV Prozessor wurde im Jahr 2000 auf den Markt gebracht. Er wurde in
180-nm Technologie (Kanallänge eines MOSFET) gebaut, wobei die Transistoranzahl 42

Millionen betrug. Typischerweise fallen also alle modernen Chiplösungen ausschließlich

in die GSI-Kategorie. Heutige Designs haben mehrere Millionen und sogar mehr als eine
Milliarde Gatter pro IC. Alle Logik-, Speicher- und Analogkomponenten werden heute in
einem einzigen SoC-IC gefertigt.
6.2.1 Digitale Schaltkreisfamilien
Logikgatter lassen sich verschiedenartig aufbauen und in Schaltkreisfamilien kategorisiert.

Historisch haben sich viele unterschiedliche Schaltkreisfamilien entwickelt. Sie unterschei-
den sich in ihrem Aufbau und in ihren elektrischen Eigenschaften. Zu den bedeutendsten
Schaltkreisfamilien zählen:
• RTL (Resistor Transitor Logic)
• DTL (Diode Transistor Logic)
• TTL (Transistor Transistor Logic)
• ECL (Emitter-Coupled Logic)
• MOS (Metal-Oxide Semiconductor)
• CMOS (Complementary Metal-Oxide Semiconductor)
Es gibt zwei Grundtypen der Halbleitertechnik, die in digitalen Schaltkreisfamilien An-
wendung finden. Die Unterscheidung erfolgt nach Art des Transistors. Entweder es wird
ein Bipolartransistor vom npn- oder pnp-Typ, stromgesteuert, angewendet oder ein Metal-
Oxide Semiconductor (MOS)-Feldeffekttransistor (FET) vom n-Kanal- oder p-Kanal-Typ,
spannungsgesteuert.
Bei der Resistor Transistor Logic“ werden die Gatter mit Widerständen und Bipolar-
”
transistoren aufgebaut, wobei die logischen Verknüpfungen durch Reihen- und Parallel-
schaltung der Transistoren umgesetzt werden. Die Gatter der Diode Transistor Logic“
”
sind hauptsächlich mit Dioden und Transistoren aufgebaut. Die Dioden realisieren die
logischen Verknüpfungen, während die Transistoren der anschließenden Verstärkung und
Invertierung dienen. Um die Dioden bei der Logikumsetzung zu ersetzen, werden bei der
Transistor Transistor Logic“ bipolare Transistoren mit mehreren Emitter-Anschlüssen
”
zum Einsatz. Durch die stromgesteuerten Transistoren ist TTL mit einer hohen Strom-
aufnahme verbunden. Es gibt allerdings spezielle TTL-Varianten, die auf niedrigen Strom-
verbrauch optimiert sind.
Die Gatter der Emitter-Coupled Logic“ sind mit bipolaren Transistoren und Wi-
”
derständen nach dem Prinzip eines Differenzverstärkers aufgebaut. Diese Schaltkreisfa-
milie hat sehr kurze Schaltzeiten, die Leistungsaufnahme ist jedoch extrem hoch. Zudem
erschwert die negative Betriebsspannung die Verbindung mit anderer Logik. Die Logik in
Metal-Oxide Semiconductor“ basiert auf der Verwendung von n-Kanal- oder p-Kanal-
”
MOSFETs aufgebaut. Die Bezeichnung MOS bezieht sich typischerweise auf ein Metall-
Gate, eine Oxid-Isolierung und einen Halbleiter (typischerweise Silizium). Allerdings kann
als Gate-Material auch eine Schicht aus polykristallinem Silizium Anwendung finden, ne-
ben Oxid können auch verschiedene dielektrische Materialien verwendet werden, um eine
stärkere Kanalausprägung bei kleineren angelegten Spannungen zu erhalten.

Der Vorteil der MOSFETs besteht darin, dass diese fast keine Steuerleistung benötigen,
relativ kompakt sind und leicht in Massenproduktion hergestellt werden können. Aller-
dings wirken die Kapazitäten der MOSFETs kurzen Schaltzeiten entgegen und sorgen für
langsame Schaltgeschwindigkeiten. Des weiteren sind MOSFETs empfindlich gegen stati-
sche Aufladungen, die zur Zerstörung der Bauteile führen kann. Der überwiegende Anteil
integrierter digitaler Schaltungen wird nach wie vor in MOS-Technologie gefertigt.
Bei in Complementary Symmetry-Metal Oxide Semiconductor“ ausgeführten Logikgat-
”
tern werden n-Kanal- und p-Kanal-MOSFETs paarweise eingesetzt. Dadurch verfügen
CMOS Gatter über einen sehr geringen Ruhestrom und damit auch über einen sehr ge-
ringen statischen Leistungsverbrauch. CMOS ist gegenüber NMOS allerdings aufwendiger
und hat eine ungünstigere Packungsdichte. Zudem sind die Schaltzeiten langsamer und
CMOS-Schaltungen reagieren empfindlicher gegenüber äußeren elektrischen Störungen.
Charakteristische Parameter der Schaltkreisfamilien sind:
• Fan-Out (Treiben von Lasten)
• Propagation Delay (Verzögerungszeit)
• Noise Margin (Rauschabstand)
• Power Consumption (Energieverbrauch)
Für jede Schaltkreisfamilie wird ein Basisgatter (NAND, NOR bzw. Inverter) definiert,
für das diese Parameter üblicherweise angegeben werden. Das Fan Out entspricht dem
Ausgangslastfaktor und ist insbesondere bei Zusammenschaltung mehrer Gatter bzw.
Schaltungsteilen relevant. Der Eingang einer Schaltung stellt eine Last für die Treiber-
schaltung dar, die diesen Eingang bedienen muss. Eine Logikschaltung, die bestimmte
Ausgangsspegel erzeugt, muss an ihren Eingängen mit entsprechenden Strompegeln an-
gesteuert werden. Für die Zusammenschaltung von Schaltungen ist es also wichtig, den
Ausgangsstrom der treibenden Schaltung korrekt auszulegen und die Summe der Ein-
gangsströme der getriebenen Schaltungen adäquat zu berücksichtigen. Fan Out-Werte
werden üblicherweise als Vielfache der Werte für das Basisgatter definiert und geben so
die Anzahl der Gatter an, die an einem Gatterausgang angeschlossen werden dürfen, ohne
dass dessen Betriebsverhalten gestört wird.
Das Propagation Delay ist bereits aus Abschnitt 2.4 bekannt und ein wichti-
ger Parameter für die Perfomance des Timing-Verhaltens jeder Schaltung, da es
die mittlere Verzögerungszeit einer Ausgangssignal-Pegeländerung als Folge eines
Eingangssignal-Pegelwechsel angibt. Resultierende Laufzeiten werden jeweils bezogen
auf die Hälfte der Eingangs-/Ausgangssignalamplituden angegeben. Das Noise Margin
(Störspannungsabstand) definiert die Stabilität bei statischen Störeinflüssen. Es wird ein
maximaler Störpegel festgelegt, der einem Gatterausgangssignal überlagert werden darf,
ohne das es zu Fehlinterpretationen am nachfolgenden Eingangsgatter kommt.
Jede Schaltung hat auch einen Energiebedarf pro Zeiteinheit. Dieser wird durch die Leis-
tungsaufnahme (Stromverbrauch), üblicherweise in mW (Milliwatt), ausgedrückt. Neben
dem Begriff Power Consumption für die Leistungsaufnahme wird auch oft der Begriff
Power Dissipation (Verlustleistung) verwendet. Streng genommen gibt die Verlustleistung
aber nur denjenigen Anteil an aufgenommener Leistung an, der nicht in der gewünschten

Form abgegebener Leistung umgesetzt wird. Meist besteht dieser Anteil in abgegebener
Wärme.
6.2.2 Metal Oxide Semiconductor (MOS)
Transistoren dienen dazu, Ströme und Spannungen zu steuern und zu verstärken.

Während der Bipolartransistor durch einen geringen Strom zwischen der Basis und
dem Emitter den viel höheren Stromfluss zwischen dem Kollektor- und dem Emitter-
anschluss beeinflussen kann, nutzt der Feldeffekttransistor eine Steuerspannung (Gate-
Source-Spannung), um den Stromfluss im Halbleiterbereich zwischen den beiden elektri-
schen Anschlüssen Drain und Source zu steuern.
Der Feldeffekttransistor (FET) liefert schließlich die Grundfunktion der MOS-Technologie.
Er wird als unipolarer Transistor bezeichnet, da nur eine Ladungsträgerart am Strom-
leitungsmechanismus beteiligt ist (Elektronen oder Löcher). Abbildung 6.14 zeigt den
schematischer Aufbau der Halbleiterbereiche der beiden MOS-Transistortypen, n-Kanal
(Elektronen als Ladungsträger) und p-Kanal (Löcher als Ladungsträger).
Gate (-) Gate (+)

Drain (-) Source -U Drain (+) Source +U
p +++++ p n ----- n
Löcher Elektronen
n-dotiertes Substrat p-dotiertes Substrat

Löcherüberschuss Elektronenüberschuss
p-Kanal n-Kanal
Abbildung 6.14: Schematischer Aufbau eines MOS-Transistors
Der Source-Anschluss ist intern jeweils mit dem Substrat verbunden, der Gate-
Steueranschluss ist vom Silizium durch Metalloxyd isoliert aufgebracht. Durch die Be-
wegung von positiven und negativen Ladungsträgern wird ein Kanal gebildet, dessen Wi-
derstandswert beeinflusst werden kann. Der Kanal ist eine Verbindungsstrecke zwischen
der dotierten Zone unterhalb des Source-Anschlusses und der dotierten Zone unterhalb
des Drain-Anschlusses.
Das Grundmaterial des p-Kanal MOS Transistors (PMOS) ist schwach n-leitend. Source
und Drain bestehen aus stark p-dotiertem Material. In der Mitte liegt durch Siliziumdioxid
isoliert die Gate-Elektrode. Zwischen Drain und Source kann in dieser Anordnung kein
Strom fliessen, da immer einer der beiden pn-Übergänge der pnp-Struktur in Sperrrichtung
gepolt ist. Das Material des n-dotierten Substrats wirkt als Widerstand. Wird zwischen
Gate und Source eine negative Spannung VGS < VT H < 0 angelegt, bildet sich unter dem
Gate ein Kanal mit Löcherleitung, der Drain und Source verbindet. Ein über VGS < 0
erzeugtes elektrisches Feld zieht die im n-dotierten Substrat vorhandenen Löcher an und
führt dazu, dass die ursprünglich n-dotierte Schicht unterhalb der Oxidschicht p-leitend
wird. So kann ein Strom vom Source- zum Drain-Anschluss fließen.
Beim n-Kanal MOS Transistors (NMOS) ist das Grundsubstrat leicht p-dotiert, die beiden
Zonen für Source und Drain sind entsprechend stark n-dotiert. Source, Drain und das p-

dotierte Grundsubtrat bilden eine npn-Struktur. Wird zwischen Gate und Source eine
positive Spannung VGS > VT H > 0 angelegt, bildet sich unter dem Gate ein Kanal mit
Elektronenleitung, der Drain und Source verbindet. Ein über VGS > 0 erzeugtes Feld zieht
die im p-dotierten Substrat vorhandenen Elektronen an, so dass die Leitfähigkeit zwischen
n-dotierten Drain- und Source-Bereichen erhöht wird. So fließt ein Strom vom Drain zum
Source-Anschluss. Die ursprüngliche p-dotierte Schicht unterhalb der Oxidschicht ist n-
leitend geworden, der n-Kanal ist entstanden.
Bei gleicher Geometrie weisen p-Kanal Transistoren einen wesentlich größeren Kanalwi-
derstand auf, da die Beweglichkeit der Löcher viel geringer ist als die Beweglichkeit der
Elektronen. Daher sind die meisten MOS-Transistoren als diskrete Bauelemente selbst-
sperrende n-Kanal Transistoren. In integrierten Schaltungen werden alle verfügbaren Ty-
pen verwendet.
Drain Drain
Substrat Substrat
Gate Gate
Source Source
p-Kanal n-Kanal
Abbildung 6.15: Schaltzeichen eines MOS-Transistors
In Abbildung 6.15 sind die Schaltzeichen der beiden MOS Transistortypen dargestellt.
Die Unterbrechung des jeweils leitenden Kanals ohne angelegte Steuerspannung VGS mit
Bezug zum Substrat ist darin eindeutig gekennzeichnet. Der Pfeil gibt jeweils die Ver-
schiebung der Elektronen im Substrat an, wenn |VGS | > 0. Oft wird auch die vereinfachte
Darstellung, wie in Abbildung 6.16 zu sehen, verwendet. Der Pfeil zeigt hier die technische
Stromrichtung für den Fall an, dass der Kanal mit |VGS | > |VT H | leitfähig wird.
Für jede im digitalen Schaltungsentwurf verwendeten Technologie ist das grundlegende
Schaltungselement der logische Inverter. Die durch Evaluierung der Funktionsweise und
Charakterisierung dieser Inverterschaltung gewonnenen Ergebnisse können dann auf den
Entwurf weiterer Logikgatter bis hin zu komplexeren Schaltungen angewendet werden.
Abbildung 6.17 fasst dies für den n-Kanal MOS Inverter (NMOS Inverter) zusammen.
Drain Drain
Gate Gate
Source Source
p-Kanal n-Kanal
Abbildung 6.16: Vereinfachtes Schaltzeichen eines MOS-Transistors

Aus der gegebenen Abbildung ist ersichtlich, dass die Eingangsspannung Vin des Inverters
gleich der Gate-Source-Spannung VGS des NMOS-Transistors ist und die Ausgangsspan-
nung Vout gleich der Drain-Source-Spannung VDS . Der Source-Anschluss ist mit der Masse
verbunden, am Drain-Anschluss wird der Ausgang Y abgenommen. Die Spannungsver-
sorgung der Schaltung ist durch VDD gegeben. Die Last besteht aus einem einfachen
Linearwiderstand RD und der Drainstrom iD ist gleich dem Laststrom.
Solange die Spannung am Eingang des Transistors kleiner als die Schwellenspannung VT H
ist (Vin < VT H ), befindet sich der Transistor im Sperrbereich und leitet keinen Strom.
Somit ist der Spannungsabfall über dem Lastwiderstand gleich Null und die Ausgangs-
spannung ist gleich VDD .
Übersteigt die Eingangsspannung die Schwellenspannung (Vin > VT H ), beginnt der Tran-
sistor einen Strom ungleich Null zu leiten und geht in den Sättigungsbereich. Wird die
Eingangsspannung weiter erhöht, tritt der Transistor in den linearen Bereich ein und die
Spannung am Ausgang Vout nimmt ab. Ist schließlich Vin = VDD und damit logisch 1, so
nähert sich Vout dem Massepotential und entspricht logisch 0.
VDD Vout iD
Linearer Bereich Sättigung
Vin = VDD
VDD VDD / RD
RD
iD
Y=A‘
VDS = Vout
Vin VDS
A VTH VDD VDD
+ VDS = VGS - VTH
Vin Vin = VDD à FET durchgeschaltet, iD = max, VDS = min = 0V
- - Vin = 0 à FET gesperrt, iD = min, VDS = max = 5V
Abbildung 6.17: Aufbau und Charakterisierung eines NMOS Inverters
Die dargestellten Übertragungskennlinien zeigen jeweils den Betriebsmodus des Transis-

tors, sowie die Spannungspunkte. Auffallend ist, dass bei dieser Schaltung im durchge-
schalteten Betrieb des Transistors immer Strom verbraucht wird. Zudem muss RD sehr
hoch sein, um einen niedrigen Low“-Ausgangswert und geringen Leistungsverbrauch zu
”
erreichen. Große Widerstandswerte nehmen allerdinsg viel Platz ein. Eine mögliche Lösung
besteht darin, den Widerstand mit einem p-Kanal MOSFET zu ersetzen, der immer durch-
geschaltet ist.
6.2.3 Complementary MOS (CMOS)
Die CMOS-Schaltungstechnik ist weit verbreitet. Sie ist dadurch gekennzeichnet, dass
eine beliebige Funktion Y = f (X1 , · · · , Xn ) immer durch zwei Netzwerke implementiert
wird, die logisch komplementär sind. Die Netzwerke bestehen jeweils aus einem der bei-
den Typen der MOS Transistoren, die miteinander verbunden die gewünschte logische
Funktion bilden und wechselseitig ein- bzw. ausgeschaltet werden. Logische AND- und

OR-Verknüpfungen werden durch Transistoren in Reihe bzw. parallel implementiert, alle

weiteren Funktionen daraus abgeleitet.
Durch Ersetzung des in Abbildung 6.17 gezeigten Widerstands durch einen p-Kanal MOS-
FET entsteht ein CMOS Inverter. Bei diesem liegen also zwei MOSFETs (jeweils ein n-
und ein p-Kanal FET) in Serie zwischen Masse (GN D) und Betriebsspannung (VDD ).
Die Eingänge beider Transistoren sind miteinander verbunden. Je nach Eingangspotenti-
al leitet entweder der obere oder untere Transistor. Der jeweils andere wird dabei extrem
hochohmig und sperrt völlig (ideal) die angelegte Gleichspannung.
VDD
UGS1 = -VDD
S
à T1 an
G
T1 p-Kanal
Y=A‘
A D
=0
T2 n-Kanal
à T2 sperrt
G
S
UGS2 = 0
Abbildung 6.18: NOT-Gatter in CMOS
Abbildung 6.18 veranschaulicht die Funktionsweise beider Transistoren. Der Source-

Anschluss des p-Kanal Transistors T 1 ist mit der Versorgungsspannung VDD verbunden
und dient als Pull-Up Glied. Der Source-Anschluss des n-Kanal Transistors T 2 ist mit
Masse verbunden und dient somit als Pull-Down Glied. Während eines Pegelwechsels am
Eingang A fließt ein Querstrom durch T 1 und T 2 und verursacht so einen Verlustleis-
tungsbeitrag. Diesem dynamischen Verhalten steht das statische Verhalten gegenüber.
Dieses ist von einer sehr geringen Verlustleistung geprägt, da jeweils ein MOSFET immer
ausgeschaltet ist. Tabelle 6.6 zeigt die Funktionstabelle des CMOS Inverters.
UA UGS2 UGS1 T1 T2 UY
Low = GN D 0 −VDD leitet sperrt High = VDD
High = VDD VDD 0 sperrt leitet Low = GN D
Tabelle 6.6: Funktionstabelle des CMOS Inverters
Während der CMOS Inverter nur über einen Eingang verfügt, hat das CMOS NAND-
Gatter zwei Eingänge (A und B). Es besteht aus zwei parallelen p-Kanal Transistoren
und zwei dazu in Reihe geschalteten n-Kanal Transistoren, gezeigt in Abbildung 6.19.
Die Transistoren T 2 und T 3 ähneln dem in Reihe geschalteten komplementären Paar
aus der Inverterschaltung in Abbildung 6.18. Es handelt sich bei beiden um p-Kanal
MOSFETs, die durch das gleiche Eingangssignal (Eingang A) gesteuert werden, wobei

der obere Transistor sperrt und der untere Transistor leitet, sobald der Eingang High“
”
ist und umgekehrt.
VDD
p-Kanal p-Kanal
T1 T2
Y=(AB)‘
n-Kanal
T3
A
T4 n-Kanal
Abbildung 6.19: NAND-Gatter in CMOS
In ähnlicher Weise werden auch die Transistoren T 1 und T 4 durch das gleiche Eingangssi-
gnal (Eingang B) gesteuert und liefern das gleiche Leit- bzw. Sperr-Verhalten für die glei-
chen Eingangslogikpegel. Diese beiden Transistoren sind n-Kanal MOSFETs. Die Source-
und Drain-Anschlüsse der oberen beiden Transistoren (T 1 und T 2) sind parallel geschal-
tet, während die unteren Transistoren (T 3 und T 4) in Reihe geschaltet sind.
Das Verhalten der Gesamtschaltung lässt sich wie folgt charakterisieren: Sind beide
Eingänge (A, B) auf High“, so leiten die n-Kanal Typen und die p-Kanal Typen sperren.
”
In diesem Falle ist der Ausgang Y dann auf Low“. Ist nur ein Eingang auf Low“, sperrt
” ”
der zugehöriger n-Kanal Typ und der zugehöriger p-Kanal Typ leitet. Der Ausgang Y ist
in diesem Fall dann auf High“. Tabelle 6.7 dokumentiert die vollständige Funktionsweise
”
des CMOS NAND-Gatters für alle Eingangskombinationen.
UA UB T1 T2 T3 T4 UY
Low Low leitet leitet sperrt sperrt High
Low High sperrt leitet sperrt leitet High
High Low leitet sperrt leitet sperrt High
High High sperrt sperrt leitet leitet Low
Tabelle 6.7: Funktionstabelle des CMOS NAND-Gatters
Wie das CMOS NAND-Gatter besteht auch das CMOS-NOR-Gatter aus vier MOSFETs,
allerdings in einer anderen Anordnung. Anstelle von zwei an der Spannungsquelle parallel

geschalteten und zwei zur Masse in Reihe geschalteten Transistoren, verwendet das NOR-
Gatter an der Spannungsquelle zwei in Reihe geschaltete Transistoren (vom Typ p-Kanal),
sowie zwei parallel geschaltete n-Kanal Transistoren, deren Source-Anschluss an Masse
liegt. Abbildung 6.20 zeigt die Schaltung.
VDD
T1
A
T2
B
Y=(A+B)‘
T3 T4
Abbildung 6.20: NOR-Gatter in CMOS
Wie beim NAND-Gatter arbeiten die Transistoren T 1 und T 3 als komplementäres Paar,
ebenso die Transistoren T 2 und T 4. Jedes Paar wird von einem zugehören Eingangssignal
gesteuert. Wenn entweder Eingang A oder Eingang B High“ sind, wird mindestens einer
”
der unteren n-Kanal Transistoren (T 3 oder T 4) durchgeschaltet, wodurch der Ausgang
auf Masse gezogen und Low“ wird. Der zugehöriger p-Kanal Typ im oberen Teil sperrt
”
jeweils.
Nur wenn beide Eingänge Low“ sind, befinden sich die beiden unteren n-Kanal Tran-
”
sistoren im Sperrmodus und die beiden oberen p-Kanal Transistoren sind leitend. Damit
liegt der Ausgang auf dem gleichen Potential wie die Spannungsquelle und liefert einen
High“-Pegel. Dieses Verhalten definiert offensichtlich die NOR-Logikfunktion, wie in ??
”
zusammengefasst.
UA UB T1 T2 T3 T4 UY
Low Low leitet leitet sperrt sperrt High
Low High leitet sperrt sperrt leitet Low
High Low sperrt leitet leitet sperrt Low
High High sperrt sperrt leitet leitet Low
Tabelle 6.8: Funktionstabelle des CMOS NOR-Gatters
In allen bisher diskutierten Fällen wurde der Transistor als einfacher Schalter wahrgenom-

men. Dieses Verhalten wird erreicht, indem der Transistor bewusst unter- oder übersteuert
wird. Grundsätzlich führt ein kleiner Eingangsstrom zur Basis des Transistors zu einem
großen Ausgangsstrom zwischen dem Kollektor und dem Emitter. Wird der Transistor
in einem nach oben und unten definierten Arbeitsbereich betrieben, so verhält er sich
wie ein Verstärker. Ein Betrieb außerhalb dieses Arbeitsbereiches führt zu Unter- bzw.
Übersteuerung.
Ein MOS Transistor kann also als spannungsgesteuerter elektronischer Schalter verstanden
werden. Wenn keine Basisspannung vorhanden ist oder die Spannung weniger als 0,7 V
beträgt, ist der Schalter ausgeschaltet. Wenn eine Spannung an die Basis angelegt wird,
leitet der Transistor Strom über die Kollektor-Emitter-Strecke. Wenn die Spannung an
der Basis in den Sättigungsbereich geht, kann der Kollektorstrom ohne Einschränkung
fließen. Der Schalter ist dann also durchgeschaltet. Die Leitfähigkeit zwischen Source und
Drain wird dabei stromlos, d.h. rein kapazitiv gesteuert. Damit ist im statischen Betrieb
der Transistor nahezu frei von Verlustleistung.
Abbildung 6.21: Transistor-Schalter-Analogie
Abbildung 6.21 zeigt das Schaltprinzip einer Ersatzschaltung. Demnach entspricht ein
sperrender Transistor einem geöffneten Schalter und ein leitender Transistor einem ge-
schlossenen Schalter. Auch eine komplette Inverterschaltung kann wie in Abbildung 6.22
gezeigt in Schalterdarstellung umgesetzt werden. Der CMOS Inverter besteht demnach
aus einem oberen Öffner (p-Kanal) und einem unteren Schließer (n-Kanal). Liegt am Ein-
gang Vin Low“ Pegel schließt der obere Schalter und der untere öffnet. Der Ausgang
”
liefert so das Komplement des Eingangs: Vout = VDD .
VDD = 5V
Vin Vout
Abbildung 6.22: CMOS Inverter in Schalterdarstellung

6.2.4 CMOS Kennwerte
In Abschnitt 6.2.1 wurde bereits auf die charakteristischen Parameter der Schaltkreis-
familien hingewiesen. Diese sollen nun für die CMOS-Schaltkreisfamilie näher erläutert
werden.
Die Leistungsaufnahme setzt sich aus mehreren Anteilen zusammen:
• statischer Anteil (durch Leckströme der Drain- und Sourcedioden, sowie durch den
Kanal)
• dynamischer Anteil zum Auf- und Entladen von Last- und parasitären Kapazitäten
• dynamischer Kurzschlußstrom zwischen VDD und Masse während des Schaltens
In CMOS Schaltungen ist immer einer der paarweise auftretenden Transistoren leitend. Es
existitert keine direkte Verbindung zwischen VDD und Masse. Die leitenden Transistoren
haben einen geringen Innenwiderstand, die sperrenden Transistoren führen nahezu keinen
Strom. Allerdings sperren die Transistoren nur im Idealfall komplett. Über die Gate-
Oxid-Kapazität gibt es eine Koppelung vom Gate-Anschluss auf den aktiven Kanal. Der
resultierende statische Strom durch den eigentlich sperrenden Transistor wird Leckstrom
genannt und ist sehr klein. Die Leistungsaufnahme bei statischen Pegeln ist daher sehr
gering (z.B. Pstat = 0, 01mW ) und unabhängig von der Aktivitätsfrequenz. Sie ist immer
vorhanden, sobald die Schaltung an der Versorgungsspannung angeschlossen ist.
Der hauptsächliche Anteil der Leistungsaufnahme ist auf dynamische Effekte
zurückzuführen. Diese sind das Ergebnis des Schaltens kapazitiver Lasten zwischen zwei
verschiedenen Spannungszuständen ( High“ und Low“). Während einer Taktperiode
” ”
wird die Lastkapazität jeweils einmal auf- und entladen. Die Ladung auf der Lastkapazität
CL ist durch
Q = VDD · CL
definiert. Bei einer gegebenen Frequenz f fließt ein mittlerer Strom der Größe
I =f ·Q
durch die Schaltung. Daraus resuliert die mittlere Leistung, die ausgedrückt wird durch:
2
P = I · VDD = (f · VDD · CL ) · VDD = f · VDD · CL
2
Während des Ladens wird 1/2 · C · VDD im PMOS umgesetzt, beim Entladen der Rest
im NMOS. Um die dynamische Leistungsaufnahme einer CMOS Schaltung zu reduzie-
ren, lassen sich gemäß der Formel mehrere Strategien ableiten. Es kann einerseits die
umzuladende Kapazität verringert werden. Dieser Weg verläuft meist über die Miniatu-
risierung von Strukturgrößen und damit über die Anwendung modernerer und kleinerer
Strukturbreiten im Nanometerbereich. Des weiteren stehen die dynamische Leistung P
und die Versorgungsspannung VDD in einem quadratischen Verhältnis. Eine Reduzierung
von VDD und des verwendeten Spannungshubs kann die dynamische Leistung somit er-
heblich beeinflussen. Schließlich haben auch die Schaltaktivität und die Betriebsfrequenz
einen (linearen) Einfluss, da keine Leistung verbraucht wird, wenn sich die Potentiale
nicht ändern. Bei niedrigen Frequenzen ist die Leistungsaufnahme allerdings gering. Dies

ist einer der Gründe, warum die CMOS-Technologie eine so beliebte Wahl für Schaltungs-
realisierungen ist.
Neben dem Umladen von externen (durch Leitungen und Eingänge der Folgestufen) und
internen (innerhalb eines Gatters befindlichen) Kapazitäten ist ein weiterer dynamische
Anteil der Leistungsaufnahme durch dynamische Kurzschlußströme bedingt. Diese entste-
hen dadurch, dass Transistoren ihren Leitfähigkeitszustand nicht mit einem Mal, sondern
in endlicher Zeit ändern. So entstehen dynamische Querströme.
Die pro Schaltvorgang verbrauchte Energie ist sowohl von der Spannung, als auch dem
Spitzenpegel des Stroms abhängig und hat einen direkten Bezug zur Schaltzeit:
E = tsw · VDD · Ipeak
Durch das bekannte Verhältnis von Energie E zu Leistung P gilt für die Leistung damit:
P = E/t = VDD · Ipeak
Diese Leistungsaufnahme findet nur während des Schaltvorgangs statt. Die Anstiegszeiten
tsw der Signale sollten daher so kurz wie möglich sein. Abbildung 6.23 illustriert den
Sachverhalt. Auch hier gilt, dass die Leistungsaufnahme frequenzabhängig ist.
Die Leistungsaufnahme ist nur einer von mehreren physikalischen Aspekten der CMOS
Gatter. Ein Logikgatter hat in der Regel mehrere Ein- und Ausgänge. Die Eingänge eines
CMOS Gatters nehmen in der Regel keinen statischen Strom auf, nur die dynamische
Belastung ist relevant. Der Begriff Fan-In beschreibt die Anzahl der Eingänge eines Lo-
gikgatters. Beispielsweise verfügt ein AND-Gatter mit zwei Eingängen über einen Fan-In
von 2, ein 3-Input OR somit über ein Fan-In von 3. Ein NOT-Gatter hat immer einen
Fan-In von 1. Die Anzahl der Eingänge kann für jede Logikschaltung nicht über diese,
durch das Fan-In definierte endliche Zahl hinaus erhöht werden.
VDD
S VDD
G
VDD-VTH
Vin
D VTH
t
i Vout
iPeak
Vin D
i
G
t
S tsw
Abbildung 6.23: Leistungsaufnahme aufgrund dynamischen Kurzschlußstroms
Als Fan-Out wird die Anzahl der Gatter beschrieben, die jedes Logikgatter an seinem
Ausgang ansteuern kann, ohne dass der Spannungspegel am Ausgang einen garantierten
Bereich verlässt. Das Fan-Out hängt von der Menge an elektrischem Strom ab, die ein Gate
erzeugen oder aufnehmen kann, während es andere Gates antreibt. Je höher das Fan-Out,
desto höher die kapazitive Last am treibenden Gatter und damit auch die Verzögerung

der Signalwechsel (Propagation Delay). Die Eingangskapazitäten der getriebenen Gatter

hinter dem Ausgang addieren sich und müssen über den äquivalenten Widerstand des
treibenden Gatters geladen werden. Ein hoher Fan-Out ist vorteilhaft, da er den Bedarf
an zusätzlichen Treibern zur Speisung einer größeren Anzahl an Gattern reduziert. Ab-
bildung 6.24 zeigt das Konzept des Fan-Out (z.B. ∼ 30 bei 1MHz).
1
1
2
1 1
Fan-Out = N
……
treibendes Gatter
N
1
Abbildung 6.24: Fan-Out der Gatterausgänge
Genau betrachtet liegt die Ursache des Propagation Delay im kapazitiven Verhalten durch
Ladungsträger-Transportvorgänge beim Aufbau und Leeren eines Kanals. Aufgrund des
symmetrischen Aufbaus von CMOS Gattern sind die Zeiten tpLH und tpHL daher auch
gleich. Gemessen wird wie bereits in Abschnitt 2.4 beschrieben zwischen den 50% Pegeln
der Ein- und Ausgangssignale.
VDD VDD
VOH
„High“-Zustand
Störspannungsabstand
VIH
VIL
„Low“-Zustand
Störspannungsabstand
VOL
0 0
Ausgangsspannungsbereich Eingangsspannungsbereich
Abbildung 6.25: Noise Margin für den Low“- und High“-Signalbereich

” ”
CMOS Schaltungen sind in der Regel so konstruiert, dass sie Schwankungen der Eingangs-
und Ausgangsspannungspegel durchaus tolerieren. Abweichungen vom Nennpegel sind in
der Regel das Ergebnis mehrerer unterschiedlicher Faktoren:
• unsaubere bzw. instabile Versorgungsspannung VDD
• Drift des Transistorarbeitspunktes (Spannungs- und Stromkennlinien) durch hohe
Betriebstemperaturen
• Übersprechen auf Signalleitungen durch Stromimpulse oder Einkopplungen über
Versorgungsleitungen

Die durch die genannten Faktoren auftretenden unerwünschten Signalschwankungen sind

den normalen Betriebsspannungspegeln überlagert und werden als Rauschen bezeichnet.
Alle CMOS Gatter sind so ausgelegt, dass sie an ihren Eingangs- und Ausgangsports
ein gewisses Maß an Rauschen tolerieren. Der maximale Rauschspannungspegel, der von
einem Gatter toleriert wird, wird als Noise Margin (Rauschabstand) bezeichnet.
Im statischen Betrieb ist der Ausgang immer mit VDD oder Masse verbunden. Ein voller
Logikhub führt zu einem maximalen Rauschabstand. Dieser wird in der Praxis allerdings
so gut wie nie ausgenutzt. Stattdessen gelten gemäß Abbildung 6.25 für die Low“- und
”
High“-Signalbereiche entsprechende Korridore, die durch die Signalhübe ∆H bzw. ∆L
”
definiert sind: ∆H = VOH − VIH (für High“-Ausgang) und ∆L = VIL − VOL (für High“-
” ”
Ausgang).
Störspannungen, die sich einem Ausgangspegel überlagern, dürfen die Signalhübe ∆H
bzw. ∆L nicht überschreiten. Andernfalls ist es der Eingangsstufe eines CMOS Gatters als
Konsequenz nicht möglich, korrekte Low“- oder High“-Erkennungen zu bewerkstelligen.
” ”
Als Zahlenbeispiel sei auf ein CMOS NAND der Reihe 74AHC00 verwiesen: ∆H = VOH −
VIH = 4, 6V − 3, 5V = 1, 1V und ∆L = VIL − VOL = 1, 5V − 0, 3V = 1, 2V

Literaturverzeichnis
[Phil99] Philips: ”74AHC74; 74AHCT74 Dual D-type flip-flop with set and reset; positive-
edge trigger”, Product specification, File under Integrated Circuits, IC06, 1999
[VHDL87] VHDL Language Reference Manual; IEEE Std 1076-1987, ISBN 1-55937-181-1
[Tera10] Terasic Altera DE2-115 User Manual; Terasic Technologies, Taiwan, 2010
[Alte16] Cyclone IV Device Handbook; Altera Corporation, USA, 2016
[Moor65] G. E. Moore: Cramming more components onto integrated circuits; Electronics,
Volume 38, No 8, Seiten 114-118, 1965
[Moor75] G. E. Moore: Progress in Digital Integrated Electronics; Technical Digest, IEEE
International Electron Devices Meeting, Seiten 11-13, 1975
[Denn74] R.H. Dennard: Design of Ion-Implanted MOSFET?s with Very Small Physical
Dimensions; IEEE Journal of Solid-State Circuits, Vol. SC-9, No. 5, Seiten 256-268,
1974
129
Ende
Prof. Dr.-Ing. Sven-Hendrik Voß

FB VI, Informatik und Medien
E-mail: sven-hendrik.voss@bht-berlin.de

Skript DT WiSe21

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Skript DT WiSe21

Hochgeladen von

Copyright:

Verfügbare Formate

Fachbereich VI - Informatik und Medien

Technische Informatik Bachelor

Skript zur Vorlesung

Autor: Prof. Dr. Sven-Hendrik Voß

12. Oktober 2021 - vollständige und korrigierte Version

Berliner Hochschule für Technik II Prof. Dr.-Ing. Sven-Hendrik Voß

Berlin, im Oktober 2021 Sven-Hendrik Voß

Berliner Hochschule für Technik III Prof. Dr.-Ing. Sven-Hendrik Voß

Berliner Hochschule für Technik IV Prof. Dr.-Ing. Sven-Hendrik Voß

Berliner Hochschule für Technik V Prof. Dr.-Ing. Sven-Hendrik Voß

2 Grundlagen der Digitaltechnik 11

4 Rechnergestützter Schaltungsentwurf mit VHDL 49

4.2 Modellierungskonzepte im Architecture Entwurf . . . . . . . . . . . . . . . 56

5 Simulation und Zeitverhalten im Digitalentwurf 89

6 Logikarchitekturen und Halbleitertechnologie 99

Berliner Hochschule für Technik VII Prof. Dr.-Ing. Sven-Hendrik Voß

2.1 Schaltbild der Beispielfunktion . . . . . . . . . . . . . . . . . . . . . . . . . 14

3.1 Allgemeiner Aufbau synchroner sequentieller Schaltungen . . . . . . . . . . 30

4.1 Hardware-Sicht eines VHDL Designs . . . . . . . . . . . . . . . . . . . . . 50

5.1 Schematische Darstellung einer Testbench . . . . . . . . . . . . . . . . . . 89

6.1 Prinzipieller Aufbau der PLDs . . . . . . . . . . . . . . . . . . . . . . . . . 100

Berliner Hochschule für Technik IX Prof. Dr.-Ing. Sven-Hendrik Voß

6.10 Aufbau eines Logic Elements . . . . . . . . . . . . . . . . . . . . . . . . . . 109

Berliner Hochschule für Technik X Prof. Dr.-Ing. Sven-Hendrik Voß

1.1 Darstellung der Wertigkeiten . . . . . . . . . . . . . . . . . . . . . . . . . . 1

3.1 Zustandsfolgetabelle für die Schaltungsanalyse . . . . . . . . . . . . . . . . 34

4.1 Wertevorrat beim Datentyp std logic“ . . . . . . . . . . . . . . . . . . . . 54

5.1 Evaluierung der Gatter in Beispielschaltung . . . . . . . . . . . . . . . . . 95

6.1 Bausteine zur Speicherung einer Tabelle (Programm) . . . . . . . . . . . . 100

1.2 Technische und mathematische Grundlagen

1.2.1 Gegenüberstellung von Analog- und Digitaltechnik

Die Digitaltechnik bietet in vielen Anwendungsbereichen gegenüber der analogen Signal-

Berliner Hochschule für Technik 2 Prof. Dr.-Ing. Sven-Hendrik Voß

Tabelle 1.2: Bitcodierung

Verschiedene Zahlensysteme können entsprechend ihrer Basis (oder Radix) r definiert

Nun kann eine Zahl X der Basis r als

X = (xm xm−1 · · · x2 x1 x0 x−1 x−2 · · · x−n )r

Berliner Hochschule für Technik 3 Prof. Dr.-Ing. Sven-Hendrik Voß

W ert(X) = 1 × 102 + 2 × 101 + 3 × 100 + 4 × 10−1 + 5 × 10−2

Das Binärsystem (r = 2) wurde im letzten Abschnit bereits durch die Informationsdar-

W ert(X) = 1 × 23 + 1 × 22 + 0 × 21 + 1 × 20 + 0 × 2−1 + 1 × 2−2

W ert(X) = 15 × 161 + 3 × 160 + 11 × 16−1

Berliner Hochschule für Technik 4 Prof. Dr.-Ing. Sven-Hendrik Voß

b6 b5 b4 b3 b2 b1 b0 b−1 b−2 b−3 b−4

Tabelle 1.3: Umrechnung vom Dezimalsystem

41, 687510 = 101001, 10112

x4 x3 x2 x1 x0 . x−1 x−2 x−3 x−3 x−4

Der Wert des ganzzahligen Anteils des obigen Ausdrucks ist

Berliner Hochschule für Technik 5 Prof. Dr.-Ing. Sven-Hendrik Voß

2n − 1 − X = 100 · · · 00 − 1 − X = 11 · · · 11 − bn−1 bn−2 · · · b1 b0 = bn−1 bn−2 · · · b2 b1 b0

und kann auf unterschiedliche Weisen gebildet werden:

Das Zweierkomplement ist substantiell für arithmetische Implementierungen in digitalen

Berliner Hochschule für Technik 6 Prof. Dr.-Ing. Sven-Hendrik Voß

Binärcode Parity Bit ungerade Parity Bit gerade

Tabelle 1.4: Binärcode mit Parity

Berliner Hochschule für Technik 7 Prof. Dr.-Ing. Sven-Hendrik Voß

1.2.5 Elementare Logikverknüpfungen

Tabelle 1.5: AND-Verknüpfung

Berliner Hochschule für Technik 8 Prof. Dr.-Ing. Sven-Hendrik Voß

Tabelle 1.6: OR-Verknüpfung

Tabelle 1.7: NAND-Verknüpfung

Tabelle 1.8: NOR-Verknüpfung

Berliner Hochschule für Technik 9 Prof. Dr.-Ing. Sven-Hendrik Voß

Tabelle 1.9: XOR-Verknüpfung