Inhaltsverzeichnis
1 Technische Informatik
5
1.1
Anwendungsbereiche der Technischen Informatik . . . . . . . . .
7
1.2
Teilbereiche der Technischen Informatik . . . . . . . . . . . . . .
7
1.2.1
Hardware-Entwurf . . . . . . . . . . . . . . . . . . . . .
8
1.2.2
Rechnerarchitektur . . . . . . . . . . . . . . . . . . . . .
8
1.2.3
Bewertung von Computersystemen . . . . . . . . . . . .
8
1.2.4
Echtzeit– und eingebettete Systeme . . . . . . . . . . . .
8
1.2.5
Betriebssysteme . . . . . . . . . . . . . . . . . . . . . . .
9
1.2.6
Kommunikationsnetze und verteilte Systeme . . . . . . .
9
1.3
Einordnung des Moduls Computersysteme . . . . . . . . . . . .
9
1.4
Weitere Kurse zur Technischen Informatik . . . . . . . . . . . .
10
2 Schaltnetze
2.1
13
Boole’sche Algebra . . . . . . . . . . . . . . . . . . . . . . . . .
15
2.1.1
Definition der Booleschen Algebra . . . . . . . . . . . . .
15
2.1.2
Schaltalgebra – ein Modell der Booleschen Algebra . . .
17
Schaltfunktionen . . . . . . . . . . . . . . . . . . . . . . . . . .
17
2.2.1
Definitionen . . . . . . . . . . . . . . . . . . . . . . . . .
17
2.2.2
Darstellung . . . . . . . . . . . . . . . . . . . . . . . . .
20
2.2.3
Minimierung von Schaltfunktionen . . . . . . . . . . . .
29
2.3
Analyse von Schaltnetzen . . . . . . . . . . . . . . . . . . . . .
37
2.4
Synthese von Schaltnetzen . . . . . . . . . . . . . . . . . . . . .
40
2.5
Code–Umsetzer . . . . . . . . . . . . . . . . . . . . . . . . . . .
41
2.2
1
2
Inhaltsverzeichnis
2.5.1
Schaltnetzentwurf für die 8421–BCD zu 7–Segment Umsetzung . . . . . . . . . . . . . . . . . . . . . . . . . . .
42
Schaltnetzentwurf für einen Adressdecodierer . . . . . . .
45
Addierglieder . . . . . . . . . . . . . . . . . . . . . . . . . . . .
46
2.6.1
Halbaddierer . . . . . . . . . . . . . . . . . . . . . . . .
46
2.6.2
Volladdierer . . . . . . . . . . . . . . . . . . . . . . . . .
47
2.6.3
Paralleladdierer . . . . . . . . . . . . . . . . . . . . . . .
48
2.7
Komparatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . .
51
2.8
Multiplexer . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
53
2.9
Arithmetik-Logik Einheit (ALU)
. . . . . . . . . . . . . . . . .
59
2.9.1
Zahlendarstellung und Zweierkomplement . . . . . . . .
60
2.9.2
Addierer/Subtrahierer . . . . . . . . . . . . . . . . . . .
62
2.10 Schaltnetze mit programmierbaren Bausteinen . . . . . . . . . .
65
2.10.1 ROM . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
67
2.10.2 PROM, EPROM . . . . . . . . . . . . . . . . . . . . . .
69
2.10.3 PAL . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
70
2.10.4 PLA . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
70
2.11 Laufzeiteffekte in Schaltnetzen . . . . . . . . . . . . . . . . . . .
71
2.12 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . .
76
2.13 Lösungen der Selbsttestaufgaben . . . . . . . . . . . . . . . . .
77
2.5.2
2.6
3 Schaltwerke
81
3.1
Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
82
3.2
Speicherglieder . . . . . . . . . . . . . . . . . . . . . . . . . . .
83
3.3
Automatenmodelle für Schaltwerke . . . . . . . . . . . . . . . .
88
3.3.1
Darstellungsformen . . . . . . . . . . . . . . . . . . . . .
91
3.3.2
Äquivalenz zwischen Mealy- und Moore-Automaten . . .
92
3.4
Analyse von Schaltwerken . . . . . . . . . . . . . . . . . . . . .
94
3.5
Synthese von Schaltwerken . . . . . . . . . . . . . . . . . . . . .
97
3.5.1
Umschaltbarer Gray-Code-Zähler . . . . . . . . . . . . .
97
3.5.2
Zustands-Minimierung . . . . . . . . . . . . . . . . . . . 100
Inhaltsverzeichnis
3.5.3
3.6
3
Zustands-Codierung . . . . . . . . . . . . . . . . . . . . 103
Implementierung von Schaltwerken . . . . . . . . . . . . . . . . 104
3.6.1
Programmierbare Logikbausteine . . . . . . . . . . . . . 104
3.6.2
Mikroprogrammsteuerwerke . . . . . . . . . . . . . . . . 105
3.7
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . 106
3.8
Lösungen der Selbsttestaufgaben . . . . . . . . . . . . . . . . . 107
4 Komplexe Schaltwerke
113
4.1
Entwurf von Schaltwerken . . . . . . . . . . . . . . . . . . . . . 114
4.2
Aufbau komplexer Schaltwerke . . . . . . . . . . . . . . . . . . . 115
4.3
RTL-Notation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
4.4
ASM-Diagramme . . . . . . . . . . . . . . . . . . . . . . . . . . 119
4.4.1
Zustandsboxen . . . . . . . . . . . . . . . . . . . . . . . 119
4.4.2
Entscheidungsboxen . . . . . . . . . . . . . . . . . . . . 120
4.4.3
Bedingte Ausgangsboxen . . . . . . . . . . . . . . . . . . 120
4.4.4
ASM-Block . . . . . . . . . . . . . . . . . . . . . . . . . 121
4.5
Konstruktionsregeln für Operationswerke . . . . . . . . . . . . . 122
4.6
Entwurf des Steuerwerks . . . . . . . . . . . . . . . . . . . . . . 124
4.7
Beispiel: Einsen-Zähler . . . . . . . . . . . . . . . . . . . . . . . 126
4.7.1
Lösung mit komplexem Moore-Schaltwerk . . . . . . . . 126
4.7.2
Lösung mit komplexem Mealy-Schaltwerk . . . . . . . . 128
4.7.3
Aufbau des Operationswerks . . . . . . . . . . . . . . . . 128
4.7.4
Moore-Steuerwerk als konventionelles Schaltwerk . . . . 129
4.7.5
Moore-Steuerwerk mit Hot-one-Codierung . . . . . . . . 132
4.7.6
Mealy-Steuerwerk als konventionelles Schaltwerk . . . . . 132
4.7.7
Mealy-Steuerwerk mit Hot-one-Codierung . . . . . . . . 134
4.7.8
Mikroprogrammierte Steuerwerke . . . . . . . . . . . . . 134
4.8
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . 136
4.9
Lösungen der Selbsttestaufgaben . . . . . . . . . . . . . . . . . 137
5 Aufbau und Funktionsweise eines Computers
141
4
Inhaltsverzeichnis
5.1
Erweiterung komplexer Schaltwerke . . . . . . . . . . . . . . . . 142
5.2
Komponenten eines Computers . . . . . . . . . . . . . . . . . . 143
5.2.1
Rechenwerk . . . . . . . . . . . . . . . . . . . . . . . . . 143
5.2.2
Leitwerk . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
5.2.3
Speicher . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
5.2.4
Ein-/Ausgabe . . . . . . . . . . . . . . . . . . . . . . . . 150
5.3
Interne und externe Busse . . . . . . . . . . . . . . . . . . . . . 150
5.4
Prozessorregister . . . . . . . . . . . . . . . . . . . . . . . . . . 152
5.5
Anwendungen eines Stapelzeigers . . . . . . . . . . . . . . . . . 154
5.6
5.7
5.5.1
Unterprogramme . . . . . . . . . . . . . . . . . . . . . . 155
5.5.2
Unterbrechungen (Interrupts) . . . . . . . . . . . . . . . 158
Rechenwerk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
5.6.1
Daten- und Adressregister . . . . . . . . . . . . . . . . . 165
5.6.2
Datenpfade . . . . . . . . . . . . . . . . . . . . . . . . . 166
5.6.3
Schiebemultiplexer . . . . . . . . . . . . . . . . . . . . . 167
5.6.4
Logische Operationen . . . . . . . . . . . . . . . . . . . . 168
5.6.5
Arithmetische Operationen . . . . . . . . . . . . . . . . . 169
5.6.6
Status-Flags . . . . . . . . . . . . . . . . . . . . . . . . . 169
Leitwerk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
5.7.1
Mikroprogrammierung . . . . . . . . . . . . . . . . . . . 172
5.7.2
Mikrobefehlsformat . . . . . . . . . . . . . . . . . . . . . 173
5.8
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . 174
5.9
Lösungen der Selbsttestaufgaben . . . . . . . . . . . . . . . . . 175
Index
177
Kapitel 1
Technische Informatik
Kapitelinhalt
1.1
Anwendungsbereiche der Technischen Informatik . . . . . .
7
1.2
Teilbereiche der Technischen Informatik . . . . . . . . . . .
7
1.3
Einordnung des Moduls Computersysteme . . . . . . . . . .
9
1.4
Weitere Kurse zur Technischen Informatik . . . . . . . . .
10
5
6
Kapitel 1. Technische Informatik
Die Informatik beschäftigt sich mit der automatischen Verarbeitung von
Informationen mit Computersystemen. Die Bezeichnung Informatik wurde von
Karl Steinbuch eingeführt und ergibt sich aus der Kombination der Begriffe
Information und Automatik.
Wir können im Wesentlichen drei Gebiete der Informatik unterscheiden:
• Theoretische Informatik,
• Praktische und Angewandte Informatik,
• Technische Informatik.
Die Theoretische Informatik widmet sich dabei den formalen und mathematischen Aspekten. Sie beantwortet grundlegende Fragen zu Logik und Deduktion, Formalen Sprachen, Automaten-, Berechenbarkeits- und Komplexitätstheorie sowie zur Algorithmentheorie.
Bei der Praktischen Informatik stehen keine abstrakten sondern konkrete
Problemstellungen im Vordergrund. Es werden Methoden und Werkzeuge für
die Erstellung von Softwarelösungen solcher Probleme entwickelt. Die wichtigsten Teilbereiche bilden die Softwaretechnik, Programmiersprachen, Datenstrukturen, Algorithmen, Datenbanken, Compilerbau und Betriebssysteme.
Zur Angewandten Informatik zählen die Teilbereiche Webbasierte Systeme, Mensch-Maschine-Schnittstellen, Multimediatechniken, Künstliche Intelligenz, Wissensbasierte Systeme, Bio-Informatik, Computergrafik, Bildverarbeitung und IT-Sicherheit.
Die Technische Informatik vereint Konzepte und Methoden zum Entwurf
von Computersystemen, die für verschiedene Anwendungsbereiche optimiert
werden. Im Folgenden werden wir – beginnend mit kleinen und wenig performanten Computersystemen – verschiedene Anwendungsbereiche vorstellen.
Wie bei vielen Klassifizierungen gilt auch hier, dass die Gebiete der Informatik nicht disjunkt sind. So gibt es beispielsweise starke Bezüge zwischen der
Softwaretechnik und der theoretischen Informatik im Bereich automatischer
Ableitung von Programmeigenschaften, die bei einer Code-Umstrukturierung
erhalten bleiben sollen. Beim Entwurf eines Mikrochips werden die Schaltnetze heute durch Hardware-Beschreibungssprachen spezifiziert, so dass sich
bei Chip-Entwurfssystemen beispielsweise auch umfangreiche softwaretechnische Fragestellungen ergeben.
Auch zur Einordnung einzelner Fachgebiete der Informatik finden sich in
der Literatur Unterschiede. So findet sich die Bildverarbeitung teils in der Angewandten, teils in der Technischen Informatik.
1.1. Anwendungsbereiche der Technischen Informatik
1.1
Anwendungsbereiche der Technischen Informatik
Eingebettete Systeme sind in großer Zahl in Geräten der Haushalts- und Unterhaltungselektronik sowie in modernen Fahrzeugen zu finden. Mobile Geräte
wie Smartphones oder Tablet-Computer verfügen zusätzlich über berührungsgesteuerte Bildschirme (touch screens) und Telekommunikationsschnittstellen.
Desktop-Computer (häufig auch Personal Computer oder PC genannt) besitzen meist großformatige und hochauflösende Bildschirme, eine Tastatur, leistungsstarke Mehrkern-Prozessoren sowie größere Haupt- und Sekundärspeicher.
Bei Server-Computern verzichtet man auf Bildschirm bzw. Tastatur und beschränkt sich auf den Zugriff über eine Netzwerk-Schnittstelle. Server sind
auf maximale Performanz optimiert und verfügen daher meist über mehrere
Mehrkern-Prozessoren sowie graphische Co-Prozessoren (Graphical Processing
Unit, GPU) zur Beschleunigung von rechenintensiven Programmen. Um die
Performanz weiter zu erhöhen, können mehrere Server über ein leistungsstarkes
lokales Netzwerk zu einem Cluster (engl. für Anhäufung) zusammengeschaltet
werden. Der Zusammenschluss mehrerer Cluster führt schließlich zum Grid–
oder Cloud-Computing, bei dem die Nutzer über das Internet auf extrem performante Parallelrechnersysteme zugreifen können.
Je nach Anwendungsbereich stehen verschiedene Entwurfsziele im Vordergrund. So sollen z.B. mobile Systeme möglichst wenig Energie verbrauchen, um
die Akkulaufzeiten zu verlängern. Im Gegensatz dazu haben PCs und Server
einen deutlich höheren Energieverbrauch, da es hier vor allem auf eine hohe
Performanz ankommt.
1.2
Teilbereiche der Technischen Informatik
Die Technische Informatik umfasst die Teilbereiche
• Hardware-Entwurf (engl. digital design),
• Rechnerarchitektur (engl. computer architecture),
• Messen, Modellieren und Bewerten,
• Echtzeit– und eingebettete Systeme,
• Betriebssysteme, und
• Rechnernetze und Verteilte Systeme.
wobei die Betriebssysteme in natürlicher Weise eine Schnittstelle zwischen Praktischer und Technischer Informatik bilden.
7
8
Kapitel 1. Technische Informatik
1.2.1
Hardware-Entwurf
Der Hardware-Entwurf befasst sich mit der computergestützten Erstellung von
Hardware-Schaltungen zur Realisierung von Schaltnetzen, Schaltwerken und
Prozessoren.
Die Bandbreite reicht von Überlegungen zur effizienten Realisierung von oft
benötigten Schaltungen, zum Beispiel Rechnerarithmetik, über die Eingabe von
Schaltungen mittels Hardware-Beschreibungssprachen bis zu Algorithmen zur
automatischen Erstellung von Test-Eingabemustern für Mikrochips zur Erkennung von Fabrikationsfehlern.
1.2.2
Rechnerarchitektur
Die Rechnerarchitektur befasst sich mit Organisationsformen von Prozessoren,
um verschiedene, teilweise in Konflikt stehende Entwurfskriterien wie Leistungsfähigkeit, Ressourcenverbrauch (Leistungsaufnahme, Anzahl Transistoren) und Zuverlässigkeit zu erfüllen.
Die Untersuchungen reichen von der Organisation von Zwischenspeichern
zur Erhöhung des Datendurchsatzes über die Anzahl, Auswahl und Steuerung
von Ausführungseinheiten für verschiedene Befehle bis zur Struktur von Instruktionssätzen.
1.2.3
Bewertung von Computersystemen
Bei der Bewertung von Computersystemen gibt es viele Ansätze auf der Basis
von Modellen verschiedener Detailgrade sowie durch Ausführung von Anwendungen auf dem realen System. Hierbei darf die Messung der relevanten Parameter zur Laufzeit (wie Leistungsaufnahme, Datendurchsatz oder Speicherzugriffszeit) die Ausführung nicht so beeinflussen, dass die Messung verfälscht
wird.
1.2.4
Echtzeit– und eingebettete Systeme
Eingebettete Systeme dienen oft der Steuerung von Geräten. Deshalb dürfen Reaktionen des Systems bestimmte Zeiten nicht überschreiten. Zum Beispiel wäre
es fatal, wenn die Weitergabe des Kommandos zum Bewegen der Vorderräder
beim Steer-by-Wire in Kraftfahrzeugen manchmal erst mit einer Verzögerung
von einer halben Sekunde erfolgen würde. Echtzeitsysteme erfüllen solche Eigenschaften.
Weiterhin sind solche Systeme oft mobil und daher von einer Batterie oder
Akku abhängig, so dass zum Beispiel eine Abwägung zwischen Leistungsfähigkeit und Leistungsaufnahme erfolgen muss.
1.3. Einordnung des Moduls Computersysteme
1.2.5
Betriebssysteme
Ein Betriebssystem stellt eine Abstraktionsschicht zwischen einer konkreten
Rechnerhardware und Anwendungsprogrammen zur Verfügung. Es ermöglicht
beispielsweise, dass mehrere Anwendungsprogramme quasi-gleichzeitig ausgeführt werden, und jedes dabei so ausgeführt werden kann, als ob es alleine
auf dem Rechner ausgeführt würde. Gleichzeitig koordiniert und beschränkt
es den Zugriff von Anwendungen auf Hardware-Einheiten wie Festplatten oder
Netzwerk-Karten.
1.2.6
Kommunikationsnetze und verteilte Systeme
Kommunikationsnetze sorgen dafür, dass verschiedene Rechner miteinander
kommunizieren können. Hierbei gibt es eine Fülle von Technologien unterschiedlichster Bandbreite, Verzögerung, oder Übertragungsmedien. Arbeiten mehrere
Rechner, die sich an verschiedenen Orten (und in der Regel unter verschiedener administrativer Kontrolle) befinden, an der Lösung eines Problems, so
spricht man von einem verteilten System. Mit dem Aufkommen des Grid– und
Cloud-Computing hat dieses Feld an Bedeutung zugenommen.
1.3
Einordnung des Moduls Computersysteme
Das Modul Computersysteme besteht aus den Kursen Computersysteme 1 und
Computersysteme 2.
Der Kurs Computersysteme 1 bietet eine Einführung in den HardwareEntwurf. Behandelt werden Schaltnetze, Schaltwerke und komplexe Schaltwerke
sowie die Grundlagen von Mikroprozessoren.
Der Kurs Computersysteme 2 bietet eine Einführung in die Rechnerarchitektur. Behandelt werden Befehlssatz-Architektur, Mikroarchitektur mit Pipelining, Superskalarität und Sprungvorhersage sowie die Speicherorganisation
einschließlich Caches und Externspeichern.
Vielleicht fragen Sie sich, weshalb diese Themen in Ihrem Studiengang vorkommen, wenn Sie doch, wie viele Studierende, eine Tätigkeit in der SoftwareEntwicklung oder –Administration anstreben. Die Leistungsfähigkeit einer Software hängt jedoch entscheidend von deren Zusammenwirken mit der benutzten
Hardware ab. Daher ist es wichtig, die grundlegenden Abläufe bei der Ausführung eines Programms auf der Hardware zu kennen. Daher gibt es sowohl
Empfehlungen der Gesellschaft für Informatik als auch Anforderungen der Akkreditierungsagenturen, die ein entsprechendes Fachwissen für ein Informatikstudium vorsehen.
Ein großer Teil der heutigen Software läuft nicht auf PCs oder Servern,
sondern auf mobilen oder eingebetteten Geräten. Die Software-Entwicklung für
9
10
Kapitel 1. Technische Informatik
solche Geräte verlangt damit auch Kenntnis von deren Besonderheiten (zum
Beispiel reduzierte Speichergrößen), um diese berücksichtigen zu können.
Während dies lange als Spezialgebiet galt, führen die Verbreitung von mobilen Geräten (Beispiel App-Entwicklung für Smartphones) sowie die Vision
vom Internet der Dinge, bei dem letztlich alle Alltagsgeräte computergesteuert
sind und über (drahtlose) Netzwerke kommunizieren, dazu, dass immer mehr
Software-Entwickler Anwendungen für solche Geräte programmieren.
Auch unabhängig vom Anwendungsfeld und trotz Unterstützung durch Softwareenwicklungs-Werkzeuge bedingt eine Performance-Optimierung von Anwendungen in der Regel Kenntnisse der zugrundeliegenden Architektur, zum
Beispiel der Cachegröße und –Organisation.
Last but not least: auch wenn Sie derzeit eine konkrete Tätigkeit im Fokus
haben, weiß niemand von uns mit Sicherheit, was er oder sie in 10 oder 20
Jahren beruflich machen wird. Hier ist eine gewisse Breite in der Grundlagenausbildung unabdingbar (womit wir wieder bei den Vorgaben der Akkreditierungsagenturen wären).
In diesem Sinne wünschen wir Ihnen viel Freude bei der Bearbeitung des
Moduls Computersysteme.
Falls wir Sie jetzt sogar neugierig auf Technische Informatik gemacht haben,
finden Sie im folgenden Abschnitt Informationen über weitere Module in diesem
Bereich.
1.4
Weitere Kurse zur Technischen Informatik
Der Pflichtkurs Betriebssysteme und Rechnernetze bietet eine Einführung in
die beiden genannten Bereiche. Zu jedem der Bereiche gibt es darüber hinaus
ein Wahlpflichtmodul mit vertiefenden Inhalten. Zusätzlich gibt es ein Wahlpflichtmodul Verteilte Systeme.
Das Wahlpflichtmodul PC-Technologie stellt die Hardware sowie Betriebssystem– und Hardware-nahe Software-Aspekte in PCs vor, und bietet somit
eine zu den vorigen Modulen orthogonale Herangehensweise.
Das Wahlpflichtmodul Parallele Programmierung und Grid-Computing bietet neben einer Einführung in die Programmierung von Rechnern mit mehreren
Prozessoren und verschiedenen Speicherorganisationen auch eine Einführung
ins Grid– und Cloud-Computing. Vertiefende Informationen zu diesen Bereichen bietet das Modul Advanced Parallel Computing.
Das Wahlpflichtmodul Virtuelle Maschinen befasst sich unter anderem mit
den Anforderungen an Instruktionssätze und Kontrollmechanismen von Prozessoren, wenn nicht wie bei einem Betriebssystem mehrere Prozesse quasigleichzeitig mit der Illusion, den Rechner alleine zu nutzen, ausgeführt werden,
sondern mehrere virtuelle Rechner, von denen jeder sein eigenes Betriebssystem
1.4. Weitere Kurse zur Technischen Informatik
nutzen kann, auf einem physikalischen Rechner ausgeführt werden.
Das Wahlpflichtmodul Anwendungsorientierte Mikroprozessoren stellt die
Architektur von Prozessoren vor, die nicht in PCs eingesetzt werden. Mikrocontroller dienen vorwiegend Steuerungsaufgaben und digitale Signalprozessoren dienen vorwiegend der Verarbeitung digitalisierter Signale, zum Beispiel
Audio– und Videodaten.
11
12
Kapitel 1. Technische Informatik
Kapitel 2
Schaltnetze
Kapitelinhalt
2.1
Boole’sche Algebra . . . . . . . . . . . . . . . . . . . . . . .
15
2.2
Schaltfunktionen . . . . . . . . . . . . . . . . . . . . . . . .
17
2.3
Analyse von Schaltnetzen . . . . . . . . . . . . . . . . . . .
37
2.4
Synthese von Schaltnetzen . . . . . . . . . . . . . . . . . . .
40
2.5
Code–Umsetzer . . . . . . . . . . . . . . . . . . . . . . . . .
41
2.6
Addierglieder . . . . . . . . . . . . . . . . . . . . . . . . . .
46
2.7
Komparatoren . . . . . . . . . . . . . . . . . . . . . . . . .
51
2.8
Multiplexer . . . . . . . . . . . . . . . . . . . . . . . . . . .
53
2.9
Arithmetik-Logik Einheit (ALU) . . . . . . . . . . . . . . .
59
2.10 Schaltnetze mit programmierbaren Bausteinen . . . . . . .
65
2.11 Laufzeiteffekte in Schaltnetzen . . . . . . . . . . . . . . . .
71
2.12 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . .
76
2.13 Lösungen der Selbsttestaufgaben . . . . . . . . . . . . . . .
77
13
14
Kapitel 2. Schaltnetze
Schaltnetze basieren auf elektronischen Schaltungen, die Spannungen als
logische Variablen 0 oder 1 interpretieren. Mit geeigneten Schaltungen ist man
in der Lage, alle grundlegenden Verknüpfungen der Boole’schen Algebra, auch
Schaltalgebra genannt, zu realisieren.
Schaltnetze enthalten mehrere Verknüpfungsglieder und realisieren eine Schaltfunktion oder Vektorfunktion:
F : {0, 1}n → {0, 1}m ,
Y = F (X)
(2.1)
Dabei ist X der Eingangsvektor mit den Eingangsvariablen x1 , x2 , . . . , xn ,
Y der Ausgangsvektor mit den Ausgangsvariablen y1 , y2 , . . . , ym , F die Zuordnungsvorschrift zwischen den Eingangs– und Ausgangsvariablen, gebildet durch
die Operatoren ∨, ∧, – und dargestellt durch die Schaltzeichen für die UND–,
ODER–, NICHT–Verknüpfung.
Die Schreibweise in Komponentendarstellung lautet:
y1 = f1 (x1 , x2 , . . . , xn )
y2 = f2 (x1 , x2 , . . . , xn )
..
..
.
.
ym = fm (x1 , x2 , . . . , xn )
(2.2)
Die Signallaufzeiten in den Verknüpfungsgliedern werden bei der Beschreibung der Schaltnetze nicht berücksichtigt. Unter dieser Voraussetzung gilt:
Die Ausgangsvariablen zu irgend einem Zeitpunkt sind eindeutig
bestimmt durch die Eingangsvariablen zum gleichen Zeitpunkt.
Die Definition der DIN–Norm (DIN44300/93) für ein Schaltnetz lautet deshalb:
Schaltnetz: Ein Schaltwerk1 , dessen Wert am Ausgang zu irgend
einem Zeitpunkt nur vom Wert am Eingang zu diesem Zeitpunkt
abhängt.
Schaltnetze werden mit Begriffen und Schaltzeichen der Schaltalgebra beschrieben. Im ersten Abschnitt dieses Kapitels werden Begriffe und Gesetze der
Schaltalgebra in einer Übersichtsform dargestellt. In der Analyse von Schaltnetzen wird ausgehend von einem Schaltplan die Funktionstabelle und die Funktionsgleichung erstellt. In der Synthese von Schaltnetzen gelangt man in umgekehrter Reihenfolge von einer Funktionstabelle oder Funktionsgleichung zum
Schaltplan.
Als Beispiele für Schaltnetze werden Funktionseinheiten digitaler Rechensysteme dargestellt: Code–Umsetzer, arithmetische Schaltnetze, Multiplexer.
Schaltnetze können nach zwei unterschiedlichen Methoden entworfen werden:
1
eine Funktionseinheit zum Verarbeiten von Schaltvariablen
2.1. Boole’sche Algebra
15
1. Realisierung durch einzelne Verknüpfungsglieder (UND, ODER, NICHT)
2. Realisierung durch adressierende Bausteine (Multiplexer, Festwertspeicher–ROM, PROM ...)
Zuordner F
x1
x2
Eingangsvektor
x
X .3
.
.
.
xn
y1
Schaltnetz
..
enthalt
&
_1
>
y2
y3
1
..
Verknupfungsglieder
. Y
.
.
.
Ausgangsvektor
ym
Abbildung 2.1: Blockschaltbild für ein Schaltnetz
In der DIN–Definition von Schaltnetzen werden Laufzeiteffekte nicht berücksichtigt. Reale Schaltnetze sind aus Verknüpfungsgliedern aufgebaut, bei
denen Signallaufzeiten auftreten. Deshalb werden am Ende des Kapitels Laufzeiteffekte in Schaltnetzen (Hazards) besprochen.
2.1
Boole’sche Algebra
Die Zweiwertigkeit von Schalterzuständen – Schalter ein/Schalter aus – führte zur praktischen Anwendung der Booleschen Algebra, zur Schaltalgebra. Die
Schaltalgebra ist eine Boolesche Algebra über der Menge B = {0, 1}. Die Realisierungsmöglichkeit der Schaltalgebra mit Schaltern (Verknüpfungsgliedern)
kommt in den Begriffen Schaltvariable, Schaltfunktion und Schaltalgebra selbst
zum Ausdruck. Die Schaltalgebra als Modell der Booleschen Algebra bildet die
theoretische Grundlage für den Entwurf von Schaltnetzen. Man kann sagen:
In digitalen Datenverarbeitungssystemen werden auf der physikalischen Ebene binäre Schaltvariablen mit elektronischen Schaltern (Verknüpfungsgliedern)
nach den Gesetzen der Schaltalgebra verknüpft.
2.1.1
Definition der Booleschen Algebra
Die Boolesche Algebra ist eine algebraische Struktur. Sie wird charakterisiert
durch folgende Eigenschaften:
16
Kapitel 2. Schaltnetze
1. Es existiert eine Menge B = {a, b, . . . , n}
∧ und ∨ sind eindeutige Verknüpfungen:
∧ : B × B −→ B
∨ : B × B −→ B
2. Für a, b, c ∈ B gelten folgende Gesetze:
2.1 Kommutativgesetze
a ∧ b = b ∧ a (K∧)
a ∨ b = b ∨ a (K∨)
2.2 Assoziativgesetze
(a ∧ b) ∧ c = a ∧ (b ∧ c) (A∧)
(a ∨ b) ∨ c = a ∨ (b ∨ c) (A∨)
2.3 Absorptionsgesetze
a ∧ (a ∨ b) = a (Ab∧)
a ∨ (a ∧ b) = a (Ab∨)
2.4 Distributivgesetze
a ∧ (b ∨ c) = (a ∧ b) ∨ (a ∧ c) (D∧)
a ∨ (b ∧ c) = (a ∨ b) ∧ (a ∨ c) (D∨)
2.5 Neutrale Elemente
Es gibt in B verschiedene Elemente e und n ∈ B, so dass für alle
a ∈ B gilt:
a ∧ e = a (N ∧)
a ∨ n = a (N ∨)
2.6 Komplementäres Element
Zu jedem a ∈ B existiert genau ein Element a ∈ B mit den Eigenschaften
a ∧ a = n (C∧)
a ∨ a = e (C∨)
2.7 Dualitätsprinzip
Ist A eine Aussage der Booleschen Algebra, so auch A, die man durch
Vertauschen von ∧ gegen ∨ und n gegen e erhält.
2.8 De Morgansche Regeln:
a∧b = a∨b
a∨b = a∧b
2.2. Schaltfunktionen
2.1.2
17
Schaltalgebra – ein Modell der Booleschen Algebra
Die Schaltalgebra ist ein Modell der Booleschen Algebra, die nur über zwei
Elementen, den beiden Elementen 0 und 1 definiert ist, d.h. die Schaltalgebra
ist eine Boolesche Algebra über der Menge B = {0, 1}. Sie wird durch folgende
Eigenschaften charakterisiert
1. Es existiert eine Menge B = {0, 1}
2. Es existieren die Verknüpfungen (Operatoren) ∧, ∨,–
Für die Verknüpfungszeichen werden Schaltzeichen eingeführt (DIN 40700
Teil 14).
3. Es gelten die Gesetze der Booleschen Algebra.
Operator
Schaltzeichen
Benennung
1
NICHT - Glied
(NOT)
V
&
UND - Glied
(AND)
V
>
_1
ODER - Glied
(OR)
Abbildung 2.2: Operatoren und Schaltzeichen nach DIN 40700
2.2
Schaltfunktionen
Die Schaltfunktionen der Schaltalgebra sind vergleichbar mit den Funktionen
der (allgemeinen) Algebra.
2.2.1
Definitionen
Eine Schaltfunktion ist eine Gleichung der Schaltalgebra, die die Abhängigkeit einer binären Schaltvariablen y (Ausgangsvariable) von einer (oder meh-
18
Kapitel 2. Schaltnetze
reren) unabhängigen binären Schaltvariablen x1 , (x2 , ...xn ) (Argument– oder
Eingangsvariablen) beschreibt (2.2). Die DIN–Formulierung lautet:
Schaltfunktion– eine Funktion, bei der jede Argumentvariable und
die Funktion selbst nur endlich viele Werte annehmen kann. (DIN
44300/87)
Eine Schaltvariable ist ein Symbol für die Elemente {0, 1} der Schaltalgebra.
Ist B = {0, 1}, dann bedeutet x ∈ B : die Variable x hat entweder den Wert
0 oder 1. DIN–Formulierung (44300/86): eine Variable, die nur endlich viele
Werte annehmen kann (am häufigsten sind binäre Schaltvariablen).
Ist x1 ∈ B und x2 ∈ B, dann hat die Produktmenge (kartesisches Kreuzprodukt) B × B = {(0, 0), (0, 1), (1, 0), (1, 1)} vier Elemente oder Wertekombinationen. Als Schreibweise für die Wertekombinationen verwendet man meist
folgende Darstellung:
(0,
(0,
(1,
(1,
0)
1)
0)
1)
=
ˆ x1
=
ˆ x1
=
ˆ x1
=
ˆ x1
x2
x2
x2
x2
Mit n Variablen können 2n Wertekombinationen gebildet werden. Für die
Schaltfunktion gilt deshalb:
Eine Schaltfunktion ist eine eindeutige Zuordnungsvorschrift, die
jeder Wertekombination von Schaltvariablen einen Wert zuordnet.
Jeder der insgesamt 2n Wertekombinationen der Variablen
x1 , x2 , . . . , xn
xi ∈ {0, 1}(i = 1, 2, . . . , n)
wird durch die Zuordnungsvorschrift f eindeutig ein Funktionswert
f (x1 , x2 , . . . , xn ) ∈ {0, 1} zugeordnet.
Man schreibt
y = f (x1 , x2 , . . . , xn )
und sagt
y ist eine Funktion von x1 , x2 , . . . , xn .
Der Ausdruck y = f (x1 , x2 , . . . , xn ) wird Schaltfunktion genannt.
Wird eine Schaltfunktion mit Hilfe eines Operationssymbols (∧, ∨,– ) dargestellt, dann heißt diese Schaltfunktion eine Verknüpfung (DIN 44300/87).
2.2. Schaltfunktionen
..
Verknupfung
19
UND
ODER
NICHT
x 2 x1 f (x1 , x 2 )
x 2 x1 f (x1 , x 2 )
x
f (x)
Wertetabelle
0
0
1
1
0
0
1
1
0
1
1
0
Schaltzeichen
x1
Darstellung
Funktion
x2
0
1
0
1
0
0
0
1
&
y = f (x1 , x 2 )
= x1 x2
y
x1
x2
0
1
1
1
0
1
0
1
>
_1
y
y = f (x1 , x 2 )
= x1 x2
x
1
y
y = f (x) = x
Abbildung 2.3: Grundverknüpfungen und ihre Darstellung
Mit diesen Operationssymbolen werden drei Grundverknüpfungen gebildet. Mit
diesen Grundverknüpfungen kann jede Schaltfunktion dargestellt werden, es
handelt sich bei (∧, ∨,– ) um ein sog. vollständiges Operatorensystem.
Es gibt für jede Verknüpfung drei gleichwertige Darstellungen (Abb. 2.3):
Wertetabelle, Schaltzeichen oder die Angabe der Funktion.
Weil mit n Eingangsvariablen 2n Wertekombinationen gebildet werden können
und die Ausgangsvariable zwei Werte 0, 1 annehmen kann, gibt es zu n Einn
gangsvariablen insgesamt 22 Ausgangsfunktionen. Für y = f (x) gibt es vier
Funktionen.
x f1 (x) f2 (x) f3 (x) f4 (x)
0
0
0
1
1
1
0
1
0
1
Bei f1 und f4 sind die Ausgangswerte unabhängig von den Eingangswerten
0 bzw. 1. Bei f2 ist der Ausgangswert gleich x, f3 bildet die Negation von x,
also f3 (x) = x.
Mit zwei Variablen x1 ∈ {0, 1} und x2 ∈ {0, 1} lassen sich insgesamt 16 unterschiedliche Verknüpfungen bilden, s. Tabelle 2.1.
Die wichtigsten Verknüpfungen, die als Digitalschaltungen realisiert sind,
sind in Abb. 2.4 dargestellt. Mit den in Abb. 2.4 angegebenen Verknüpfungen
werden mindestens zwei oder mehr Variablen miteinander verknüpft. Entsprechend haben die Schaltzeichen zwei oder mehr Eingänge. Die verbale Formulierung der Verknüpfung bedeutet
20
Kapitel 2. Schaltnetze
Funktionswert
Schreibweise
y = f (x1 , x2 )
mit den Zeichen
Benennung der
x1 = 0 1 0 1
∧∨−
Verknüpfung
x2 = 0 0 1 1
Null
y0 = 0 0 0 0
0
Konjunktion
y1 = 0 0 0 1
x1 ∧ x2
Inhibition
y2 = 0 0 1 0
x1 ∧ x2
Transfer
y3 = 0 0 1 1
x2
Inhibition
y4 = 0 1 0 0
x1 ∧ x2
Transfer
y5 = 0 1 0 1
x1
Antivalenz
y6 = 0 1 1 0 (x1 ∧ x2 ) ∨ (x1 ∧ x2 )
Disjunktion
y7 = 0 1 1 1
x1 ∨ x2
NOR–Verknüpfung y8 = 1 0 0 0
x1 ∨ x2
y9 = 1 0 0 1 (x1 ∧ x2 ) ∨ (x1 ∧ x2 )
Äquivalenz
Komplement
y10 = 1 0 1 0
x1
Implikation
y11 = 1 0 1 1
x1 ∨ x2
Komplement
y12 = 1 1 0 0
x2
Implikation
y13 = 1 1 0 1
x1 ∨ x2
NAND–Verknüpfung y14 = 1 1 1 0
x1 ∧ x2
y15 = 1 1 1 1
1
Eins
Bemerkung
Null
UND
Exclusiv–ODER
ODER
NICHT–ODER
NICHT–UND
Eins
Tabelle 2.1: Tabelle der möglichen Verknüpfungen mit zwei Variablen
• UND–Verknüpfung: Die Ausgangsvariable y ist dann 1, wenn alle Eingangsvariablen x1 , x2 , · · · xn gleich 1 sind.
• ODER–Verknüpfung: Die Ausgangsvariable y ist dann 1, wenn mindestens eine Eingangsvariable x1 oder x2 oder · · · xn gleich 1 ist.
• Antivalenz (Exklusiv–ODER, XOR): Die Ausgangsvariable y ist dann 1,
wenn entweder x1 oder x2 gleich 1 ist, aber nicht beide. Werden mehr als
zwei Variablen verknüpft, dann erfolgt die Verknüpfung durch Kaskadierung von zweifach XOR–Gliedern (((x1 ⊕ x2 ) ⊕ x3 ) ⊕ · · ·).
Selbsttestaufgabe 2.1 In Tabelle 2.1 gibt es 16 Schaltfunktionen mit zwei Variablen. Wie viele Schaltfunktionen gibt es mit vier Variablen?
Lösung auf Seite 77
2.2.2
Darstellung
Wie in Abb. 2.3 dargestellt, gibt es für die Grundverknüpfung drei gleichwertige
Darstellungen. Ebenso gibt es für Schaltfunktionen verschiedene gleichwertige
Darstellungsformen:
• Funktionstabelle
• Funktionsgleichung
2.2. Schaltfunktionen
Verknüpfung
21
Operator-Schreibweise
Schaltzeichen
Wertetabelle
x1 x0 y
UND
y = x0 ∧ x1
x0
x1
&
y
0
0
1
1
0
1
0
1
0
0
0
1
x1 x0 y
ODER
y = x0 ∨ x1
x0
x1
1
y
NICHT
y = x0
x0
1
y
0
0
1
1
0
1
0
1
0
1
1
1
x0 y
0
1
1
0
x1 x0 y
NAND
y = x0 ∧ x1
x0
x1
&
y
0
0
1
1
0
1
0
1
1
1
1
0
x1 x0 y
NOR
y = x0 ∨ x1
x0
x1
1
y
0
0
1
1
0
1
0
1
1
0
0
0
x1 x0 y
Antivalenz
y = x0 ≡ x1
x0
x1
=1
y
0
0
1
1
0
1
0
1
0
1
1
0
x1 x0 y
Äquivalenz
y = x0 ≡ x1
x0
x1
=
y
0
0
1
1
0
1
0
1
1
0
0
1
Abbildung 2.4: Wichtige Verknüpfungen der Digitalelektronik
• KV–Diagramm
• Schaltzeichen
• Binäres Entscheidungsdiagramm
Darstellung als Funktionstabelle
Die Funktionstabelle ist eine Zusammenstellung aller möglichen Wertekombinationen der Eingangsvariablen und der zugehörigen Werte der Ausgangsvariablen
(Tabelle 2.2). Sind für alle möglichen Wertekombinationen der Eingangsvariablen, (2n Kombinationen bei n Variablen), Werte für die Ausgangsvariablen
festgelegt, dann spricht man von einer vollständigen Funktionstabelle. In einer
unvollständigen Funktionstabelle ist nicht für jede mögliche Eingangskombination ein fester Wert der Ausgangsvariablen festgelegt.
22
Kapitel 2. Schaltnetze
Vollständige Funktionstabelle
x3 x2 x1
0
0
0
0
1
1
1
1
0
0
1
1
0
0
1
1
0
1
0
1
0
1
0
1
Unvollständige Funktionstabelle
f (x1 , x2 , x3 )
0
1
1
1
0
0
0
1
x3 x2 x1
f (x1 , x2 , x3 )
0
0
0
0
1
1
1
1
0
1
1
0
1
für diese Kombinationen
ist f (x1 , x2 , x3 ) nicht
definiert, sie heißen don’t
care Terme und können mit
0 oder 1 belegt werden.
0
0
1
1
0
0
1
1
0
1
0
1
0
1
0
1
Tabelle 2.2: Vollständige und unvollständige Funktionstabelle
Darstellung als Funktionsgleichung
Die allgemeine Schreibweise einer Schaltfunktion ist
y = f (a, b, c)
Die Verknüpfung der Argumentvariablen (a, b, c, · · ·) geschieht durch die Operatoren UND, ODER, NICHT mit den Symbolen ∧, ∨,– .
Beispiel
y = a∧b∨c
Setzen wir a = x1 ∨ x2 ; b = x1 ∧ x3 ; c = x2 ∧ x3
so folgt
y = f (x1 , x2 , x3 ) = (x1 ∨ x2 ) ∧ (x1 ∧ x3 ) ∨ (x2 ∧ x3 )
(2.3)
Für die Ausführung der Verknüpfungen gibt es Vorrangregeln. Die Negation
hat die höchste Priorität, sowohl für Einzelvariablen als auch für Ausdrücke.
Die UND–Verknüpfung hat Vorrang vor anderen Verknüpfungen
(analog – Punktrechnung geht vor Strichrechnung). Bei Formeln, die durch Verknüpfung anderer Formeln entstehen, sind Außenklammern vorgesehen (DIN
66000). Bei der direkten UND–Verknüpfung einzelner Variablen wird das UND–
Verknüpfungszeichen der besseren Lesbarkeit wegen weggelassen, z.B. statt
x1 ∧ x2 ∧ x3 schreibt man (x1 x2 x3 ).
2.2. Schaltfunktionen
23
Aus den Gesetzen der Schaltalgebra folgen Regeln, die für die Umformung
von Schaltfunktionen hilfreich sind:
a∧0
a∨0
a∧a
a∨a
=
=
=
=
0;
a;
a;
a;
a∧1
a∨1
a∧a
a∨a
x 1 x0 ∨ x1 x0
(x1 ∨ x0 ) ∧ (x1 ∨ x0 )
x1 ∨ x1 x0
x1 (x1 ∨ x0 )
x1 ∨ x1 x0
=
=
=
=
=
=
=
=
=
a
1
0
1
x1
x1
x1
x1
x1 ∨ x0
Aus dem Dualitätsprinzip folgt z.B. für die Antivalenz
y = x0 x1 ∨ x0 x1
y = (x0 ∨ x1 ) ∧ (x0 ∨ x1 )
(2.4)
(2.5)
d.h. aus y wird y wenn man in der Funktionsgleichung ∧ und ∨, sowie 0
und 1 vertauscht. Weiterhin folgt:
Es ist möglich, jede Schaltfunktion ausschließlich mit NAND– oder
nur mit NOR–Verknüpfungsgliedern zu realisieren.
z. B.: Darstellung der Antivalenz nur mit NAND–Verknüpfung
y = x0 x1 ∨ x0 x1
y = x0 x1 ∨ x0 x1
y = x0 x1 ∧ x1 ∧ x 0 ∧ x0 x1
nur mit NOR–Verknüpfung
y = x0 x1 ∨ x0 x1
y = (x0 ∨ x1 ) ∧ (x0 ∨ x1 ) Dualitätsprinzip
y = y = (x0 ∨ x1 ) ∧ (x0 ∨ x1 )
y = (x0 ∨ x1 ) ∨ (x0 ∨ x0 ∨ x1 ∨ x1 )
24
Kapitel 2. Schaltnetze
Normalformen
Für die Darstellung von Schaltfunktionen in Gleichungsform gibt es Standarddarstellungen oder Normalformen
• Disjunktive Normalform (DNF)
• Konjunktive Normalform (KNF)
Die Disjunktive Normalform einer Schaltfunktion ist eine Disjunktion (ODER–
Verknüpfung) von Mintermen. Jeder Minterm (mi ) ist dabei eine Konjunktion, die jede Eingangsvariable negiert oder nicht negiert enthält. Besteht eine
Schaltfunktion aus Disjunktionen von Konjunktionstermen, die nicht alle Eingangsvariablen enthalten, so spricht man von einer disjunktiven Form (DF).
Die Konjunktive Normalform einer Schaltfunktion ist eine Konjunktion (UND–
Verknüpfung) von Maxtermen. Jeder Maxterm (Mi ) ist dabei eine Disjunktion, die jede Eingangsvariable negiert oder nicht negiert enthält. Besteht eine
Schaltfunktion aus Konjunktionen von Disjunktionstermen, die nicht alle Eingangsvariablen enthalten, so spricht man von einer konjunktiven Form (KF).
Bei n Schaltvariablen gibt es 2n verschiedene Minterme. Jeder Minterm hat
nur bei einer Kombination der Wertetabelle den Wert 1, bei allen anderen
Kombinationen den Wert 0; deshalb der Name Minterm.
Folgende Tabelle zeigt die Kombinationen von zwei Schaltvariablen und die
möglichen Minterme mit ihren zugehörigen Werten.
x2 x1
x2 ∧ x1
x2 ∧ x1
x2 ∧ x1
x2 ∧ x1
0
0
0
0
0
1
0
1
0
0
1
0
1
0
0
1
0
0
1
1
1
0
0
0
Der Minterm, der für eine bestimmte Kombination den Wert 1 hat, ergibt
sich, indem man die UND–Verknüpfung aus allen Schaltvariablen hinschreibt
und die Schaltvariablen negiert, die bei dieser Kombination den Wert 0 haben.
Z.B. gehört zur Wertekombination 0 1 der Minterm x2 ∧ x1 .
Bei n Schaltvariablen gibt es 2n verschiedene Maxterme. Jeder Maxterm hat
nur bei einer Kombination der Wertetabelle den Wert 0, bei allen anderen
Kombinationen den Wert 1; deshalb der Name Maxterm.
Folgende Tabelle zeigt alle Kombinationen von zwei Schaltvariablen und
alle möglichen Maxterme mit ihren zugehörigen Werten.
2.2. Schaltfunktionen
x3 x2 x1
0
0
0
0
1
1
1
1
0
0
1
1
0
0
1
1
25
y = f (x3 , x2 , x1 )
Minterme
mi
Maxterme
1
0
0
1
1
1
0
0
x1 ∧ x2 ∧ x3
x1 ∧ x2 ∧ x3
x1 ∧ x2 ∧ x3
x1 ∧ x2 ∧ x3
x1 ∧ x2 ∧ x3
x1 ∧ x2 ∧ x3
x1 ∧ x2 ∧ x3
x1 ∧ x2 ∧ x3
m0
m1
m2
m3
m4
m5
m6
m7
x1 ∨ x2 ∨ x3
x1 ∨ x2 ∨ x3
x1 ∨ x2 ∨ x3
x1 ∨ x2 ∨ x3
x1 ∨ x2 ∨ x3
x1 ∨ x2 ∨ x3
x1 ∨ x2 ∨ x3
x1 ∨ x2 ∨ x3
0
1
0
1
0
1
0
1
Mi
M0
M1
M2
M3
M4
M5
M6
M7
Tabelle 2.3: Min– und Maxterme der Schaltfunktion
x2 x1
x2 ∨ x1
x2 ∨ x1
x2 ∨ x1
x2 ∨ x1
0
0
0
1
1
1
0
1
1
0
1
1
1
0
1
1
0
1
1
1
1
1
1
0
Der Maxterm, der für eine bestimmte Kombination den Wert 0 hat, ergibt
sich, indem man die ODER–Verknüpfung, gebildet aus allen Schaltvariablen
hinschreibt, und die Schaltvariablen negiert, die bei dieser Wertekombination
den Wert 1 haben. Z.B. gehört zur Wertekombination 0 1 der Maxterm x2 ∨ x1 .
Liegt für eine Schaltfunktion y = f (x1 , x2 , x3 ) eine vollständige Funktionstabelle vor, dann kann daraus die Funktionsgleichung in einer Normalform dargestellt werden.
In der disjunktiven Normalform treten genau die Minterme auf, bei denen
der Funktionswert f (x1 , · · · , xn ) den Wert 1 hat. Hat die Eingangsvariable xi
die Belegung 1, so steht im Minterm auch xi ; hat sie die Belegung 0, so steht im
Minterm xi . Die in Tabelle 2.3 dargestellte Schaltfunktion lautet in disjunktiver
Normalform
f (x1 , x2 , x3 ) = (x1 ∧ x2 ∧ x3 ) ∨ (x1 ∧ x2 ∧ x3 ) ∨
(x1 ∧ x2 ∧ x3 ) ∨ (x1 ∧ x2 ∧ x3 )
In der konjunktiven Normalform treten die Maxterme auf, bei denen der Funktionswert f (x1 , · · · , xn ) den Wert 0 hat. Hat die Eingangsvariable xi die Belegung
0, so steht im Maxterm auch xi , hat sie die Belegung 1, so steht im Maxterm
xi . Die in Tabelle 2.3 dargestellte Schaltfunktion lautet in konjunktiver Normalform
f (x1 , x2 , x3 ) = (x1 ∨ x2 ∨ x3 ) ∧ (x1 ∨ x2 ∨ x3 ) ∧
26
Kapitel 2. Schaltnetze
(x1 ∨ x2 ∨ x3 ) ∧ (x1 ∨ x2 ∨ x3 )
Jede Schaltfunktion kann in disjunktiver Normalform und konjunktiver Normalform dargestellt werden. Beide Darstellungen sind äquivalent und ineinander überführbar (Dualitätsprinzip).
Benutzen wir in der Darstellung einer Schaltfunktion die Abkürzung mi für die
Minterme und Mi für die Maxterme, dann erhalten wir für die Schaltfunktion
nach Tabelle 2.3
in DNF:
in KNF:
y = m0 ∨ m3 ∨ m4 ∨ m5
y = M1 ∧ M2 ∧ M6 ∧ M7
(2.6)
(2.7)
Für die Minterme, die nicht in der DNF enthalten sind gilt
y = m1 ∨ m2 ∨ m6 ∨ m7
(2.8)
y = y = m1 ∨ m2 ∨ m6 ∨ m7
y = m1 ∧ m2 ∧ m6 ∧ m7
(2.9)
Mit de Morgan folgt
Aus Vergleich von 2.7 und 2.9 folgt
mi = Mi
Für die Maxterme, die nicht in der KNF enthalten sind gilt
y = M0 ∧ M3 ∧ M4 ∧ M5
(2.10)
und mit de Morgan folgt
y = y = M0 ∧ M3 ∧ M4 ∧ M5
y = M0 ∨ M3 ∨ M4 ∨ M5
Aus Vergleich von 2.11 und 2.6 folgt ebenfalls
Mi = mi
(2.11)
2.2. Schaltfunktionen
x3 x2 x1 f (x1 , x2 , x3 )
0 0 0
0
0 0 1
1
0 1 0
0
0 1 1
1
1 0 0
1
0
1 0 1
1 1 0
1
1 1 1
0
27
x2 x1
x3
0
1
00
0
1
01
1
0
11
1
0
10
0
1
Tabelle 2.4: Funktionstabelle und zugehöriges KV–Diagramm
Karnaugh–Veitch–Diagramm
Ein KV–Diagramm ist die graphische Darstellung einer Wertetabelle oder Schaltfunktion. Das Diagramm ist in Matrixform angeordnet. Jeder Kombination der
Eingangsvariablen wird ein Feld der Matrix zugeordnet. Hat die Wertetabelle oder Schaltfunktion n Eingangsvariablen, dann hat das KV–Diagramm 2n
Felder. Die Anordnung oder Zuordnung der Felder zu den 2n möglichen Kombinationen der Eingangsvariablen wird so vorgenommen, dass sich beim Übergang von einem Feld zu einem benachbarten Feld nur der Wert einer Variablen
ändert, s. Tabelle 2.4. Anfangs– und Endfeld einer Zeile oder einer Spalte sind
benachbart. Die Matrix kann gleichsam vertikal und horizontal zu einem Zylinder zusammengerollt werden. Die Werte der möglichen Kombinationen werden
an den Matrixrand vor die Spalten und Zeilen geschrieben. In die Felder der
Matrix werden die zu den 2n möglichen Wertekombinationen gehörenden Funktionswerte geschrieben.
Soll eine gegebene Schaltfunktion, die in einer Normalform vorliegt, in einem KV–Diagramm dargestellt werden, dann werden den Feldern der Matrix
Minterme zugeordnet, wenn die Schaltfunktion in der DNF vorliegt (oder Maxterme, wenn die Schaltfunktion in der KNF vorliegt). Die Zuordnung der Min–
oder Maxterme zu den Feldern der Matrix wird wieder so vorgenommen, dass
sich beim Übergang von einem Feld zu einem benachbarten Feld innerhalb der
Terme nur eine Variable ändert. Die möglichen Terme werden an den Rand der
Matrix vor die Spalten und Zeilen geschrieben. Meist schreibt man zusätzlich
an den Matrixrand die Werte der Eingangskombinationen. In die Felder der
Matrix werden die zu den Termen gehörenden Funktionswerte geschrieben.
Beispiel 2.1 Die Schaltfunktion
y = (x1 ∧ x2 ∧ x3 ) ∨ (x1 ∧ x2 ∧ x3 ) ∨ (x1 ∧ x2 ∧ x3 ) ∨ (x1 ∧ x2 ∧ x3 )
soll in einem KV–Diagramm dargestellt werden. Die Schaltfunktion hat drei
Schaltvariablen und ist in der DNF angegeben. Für die in der Schaltfunktion vorkommenden Minterme ist der Funktionswert 1. Die Felder des KV–
28
Kapitel 2. Schaltnetze
Diagramms, die diesen Mintermen zugeordnet werden, enthalten eine 1. In die
übrigen Felder wird eine 0 eingetragen (Abb. 2.5).
x 2 x1 x 2 x1 x 2 x1 x 2 x1 x 2 x1
x3
x3
0
x3
1
00
01
11
10
1
0
1
0
1
0
0
1
Abbildung 2.5: Darstellung einer DNF–Schaltfunktion in einem KV–Diagramm
Beispiel 2.2 Die Schaltfunktion
y = (x1 ∨ x2 ∨ x3 ) ∧ (x1 ∨ x2 ∨ x3 ) ∧ (x1 ∨ x2 ∨ x3 ) ∧ (x1 ∨ x2 ∨ x3 )
soll in einem KV–Diagramm dargestellt werden. Die Schaltfunktion hat drei
Schaltvariablen und ist in der KNF angegeben. Für die in der Schaltfunktion vorkommenden Maxterme ist der Funktionswert 0. Die Felder des KV–
Diagramms, die diesen Maxtermen zugeordnet werden, enthalten eine 0. In die
übrigen Felder wird eine 1 eingetragen (Abb. 2.6).
x 2 x1 x 2 x1 x 2 x1 x 2 x1 x 2 x1
x3
x3
0
x3
1
00
01
11
10
1
0
1
0
0
1
1
0
Abbildung 2.6: Darstellung einer KNF–Schaltfunktion in einem KV–Diagramm
KV–Diagramme sind sehr hilfreich beim Vereinfachen (Minimieren) von
Schaltfunktionen und bei der Übertragung einer Funktionstabelle in eine Funktionsgleichung. Im weiteren werden wir, wenn nichts Spezielles erwähnt ist, stets
KV-Diagramme von disjunktiven Formen verwenden.
Mit Schaltzeichen
Nach Abb. 2.3 können die Grundverknüpfungen durch eine Wertetabelle, durch
eine Gleichung und durch Schaltzeichen dargestellt werden. DIN 40700 sagt:
Schaltzeichen werden in zweierlei Weise verwendet:
2.2. Schaltfunktionen
29
– als graphische Darstellung Boolescher Funktionen oder Operationen zum
Zweck der Beschreibung, des Entwurfs, der Synthese oder Analyse von
Systemen, die der Verarbeitung von binären Signalen dienen.
– als graphische Darstellung von technischen Systemen oder ihrer Teile in
Schaltungsunterlagen.
Folgende Schaltfunktion
y = f (x1 , x2 , x3 ) = (x1 ∨ x2 ) ∧ (x1 ∧ x3 ) ∨ (x2 ∧ x3 )
(2.12)
wird mit Schaltzeichen dargestellt:
Abbildung 2.7: Schaltfunktion dargestellt mit Schaltzeichen
Hierbei ist der Hardware-Aufwand proportional zur Anzahl der benutzten
Gatter. Die Durchlaufzeit oder Verzögerung eines Signals von einem Eingang
zu einem Ausgang ist proportional zum längsten Weg vom Eingang durch das
Schaltnetz zum Ausgang.
Selbsttestaufgabe 2.2 Eine Schaltfunktion sei als Funktionsgleichung
f (x1 , x2 , x3 ) = x1 ∧ (x2 ∨ x3 ) ∨ x2 ∧ x3
gegeben. Erstellen Sie die Wertetabelle, die DNF, das KV-Diagramm und eine
Darstellung mit Schaltzeichen.
Lösung auf Seite 77
2.2.3
Minimierung von Schaltfunktionen
Schaltfunktionen, die in einer Normalform gegeben sind oder die aus einer Funktionstabelle hergeleitet wurden, enthalten oft redundante Terme. Daher können
sie weiter vereinfacht werden.
30
Kapitel 2. Schaltnetze
Beispiel 2.3 Die Funktionsgleichung
y = (x1 ∧ x2 ∧ x3 ) ∨ (x1 ∧ x2 ∧ x3 ) ∨ (x1 ∧ x2 ∧ x3 ) ∨ (x1 ∧ x2 ∧ x3 )
ist äquivalent der Gleichung
y = (x1 ∧ x3 ) ∨ (x1 ∧ x3 )
Vereinfachung von Schaltfunktionen soll deshalb hier bedeuten:
Die Funktionsgleichungen werden in möglichst “kurzen” Ausdrücken
dargestellt: d.h. mit möglichst wenig Variablen und möglichst wenig
Verknüpfungen. Die vereinfachte Form einer Schaltfunktion wird
disjunktive Form (DF) bzw. konjunktive Form (KF) genannt.
Es gibt verschiedene Verfahren zur Vereinfachung von Schaltfunktionen. Grundlage aller Verfahren sind folgende zwei Gesetze der Schaltalgebra
x1 ∨ x1 = 1
x1 ∧ x1 = 0
Die wichtigsten Verfahren zur Vereinfachung von Schaltfunktionen basieren
auf:
– den Gesetzen der Schaltalgebra
– KV–Diagrammen oder
– der Methode von Quine–McCluskey
Verfahren mit den Gesetzen der Schaltalgebra
In dem Verfahren mit den Gesetzen der Schaltalgebra kann durch Ausklammern
von Variablen, Kürzen, Zusammenfassen, Anwendung der De Morganschen Gesetze eine Schaltfunktion vereinfacht werden.
Beispiel 2.4
y = (x1 ∧ x2 ∧ x3 ) ∨ (x1 ∧ x2 ∧ x3 ) ∨ (x1 ∧ x2 ∧ x3 ) ∨ (x1 ∧ x2 ∧ x3 )
= (x1 ∧ x3 ) (x2 ∨ x2 ) ∨ (x1 ∧ x3 ) (x2 ∨ x2 )
| {z }
| {z }
1
= (x1 ∧ x3 ) ∨ (x1 ∧ x3 )
1
2.2. Schaltfunktionen
31
Verfahren mit KV–Diagrammen
Das Verfahren mit KV–Diagrammen ist ein graphisches Verfahren. Ist in dem
KV–Diagramm eine Schaltfunktion in DNF dargestellt, dann werden benachbarte Felder, die mit 1 belegt sind, zusammengefasst. Die Zusammenfassung
wird so vorgenommen, dass sie möglichst viele Einsen einschließt. Dabei dürfen
aber nur rechteckige Blöcke mit eins, zwei, vier, acht usw. Feldern entstehen,
wobei das Zusammenfassen eines einzelnen Felds zu einem Block zwar einen
trivialen Fall darstellt, aber nicht vergessen werden darf. Felder der ersten
und letzten Zeile aber gleicher Spalte sind benachbart und können in einem
Block zusammengefasst werden; ebenso Felder der ersten und letzten Spalte
aber gleicher Zeile. Die vereinfachte Schaltfunktion wird dann aus den Termen
der zusammengefassten Blöcke und der übriggebliebenen Einzelfelder gebildet.
Die Terme der zusammengefassten Blöcke enthalten nur die Variablen, die sich
innerhalb eines Blockes nicht ändern.
In Abbildung 2.8 ist die Schaltfunktion in der DNF dargestellt und die mit
1 belegten Felder des KV–Diagramms werden zusammengefasst.
x 2 x1 x 2 x1 x 2 x1 x 2 x1 x 2 x1
x4 x 3
x 4 x 3 3.
00
x4 x 3
01
x4 x 3
11
x4 x 3
10
3.
00
01
11
10
1
0
1
1
0
1
1
0
0
0
1
1.
0
1
0
1
1
3.
2.
3.
Abbildung 2.8: Vereinfachung einer Schaltfunktion in DNF
Die vereinfachte Schaltfunktion lautet:
y = (x1 ∧ x2 ) ∨ (x1 ∧ x3 ∧ x4 ) ∨ (x1 ∧ x3 )
1.
2.
3.
Beispiel 2.5 Ist in dem KV–Diagramm eine Schaltfunktion in der KNF dargestellt, dann werden benachbarte Felder, die mit 0 belegt sind, zusammengefasst.
Die Zusammenfassung erfolgt wie oben erläutert und ist in Abb. 2.9 dargestellt.
32
Kapitel 2. Schaltnetze
x 2 x1 x 2 x1 x 2 x1 x 2 x1 x 2 x1
x4 x 3
x4 x 3
00
x4 x 3
01
x4 x 3
11
x4 x 3
10
00
01
11
1
0 2.
0
10
4.
0
0
1
1
1
1
1
0
3.
1
1
1
0
0
4.
1.
Abbildung 2.9: Vereinfachung einer Schaltfunktion in KNF
Die vereinfachte Schaltfunktion lautet:
y = (x1 ∨ x2 ∨ x3 ∨ x4 ) ∧ (x1 ∨ x3 ∨ x4 ) ∧ (x1 ∨ x2 ∨ x4 ) ∧ (x2 ∨ x3 )
1.
2.
3.
4.
Die Vereinfachung mit KV–Diagrammen eignet sich für Schaltfunktionen
mit maximal 6 Schaltvariablen. Sind mehr als 6 Schaltvariablen in der Schaltfunktion enthalten, dann wird dieses Verfahren unübersichtlich. Dies ist wie
folgt begründbar: Wenn durch redundante Variablen zusammenhängende Blöcke im KV–Diagramm entstehen sollen, dürfen in eine Koordinatenrichtung
höchstens zwei Variablen abgetragen werden. Schaltfunktionen mit 6 Schaltvariablen erfordern ein dreidimensionales KV–Diagramm. Damit hat die optische
Vorstellung ihre Grenze erreicht.
Quine–McCluskey Verfahren
Das Verfahren nach Quine–McCluskey arbeitet mit Tabellen. Es lassen sich
damit Schaltfunktionen mit vielen Variablen vereinfachen. Das Verfahren geht
von Schaltfunktionen aus, die in der DNF vorliegen. Die Methode lässt sich
leicht in ein Programm übertragen.
Für die Schreibweise wird folgendes vereinbart: Die Minterme der Schaltfunktion werden nicht durch die negierten und nichtnegierten Variablen dargestellt,
sondern durch ihr Binäräquivalent:
1
0
–
steht für eine nicht negierte Variable
steht für eine negierte Variable
steht für eine nicht auftretende Variable
2.2. Schaltfunktionen
Dez
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
33
x4
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
1
x3
0
0
0
0
1
1
1
1
0
0
0
0
1
1
1
1
x2
0
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1
x1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
f (x4 , x3 , x2 , x1 )
1
0
1
0
1
1
1
1
0
0
1
1
0
0
0
0
Tabelle 2.5: Funktionstabelle einer Schaltfunktion, zur Veranschaulichung des
Quine–McCluskey Verfahrens
Beispiele: x4 ∧ x3 ∧ x2 ∧ x1
x4 ∧ x3 ∧ x1
x4 ∧ x2
=
ˆ 1010
=
ˆ 10-0
=
ˆ 1-1-
Das weitere Verfahren wird anhand eines Beispiels erläutert. Eine Schaltfunktion f (x4 , x3 , x2 , x1 ) sei durch ihre Funktionstabelle gegeben (Tabelle 2.5).
Die Reihenfolge der Funktionswerte wird so angeordnet, dass die Binäräquivalente der Terme aufsteigenden Dualzahlen entsprechen. Zur weiteren Vereinfachung der Schreibweise wird die Reihenfolge der Terme durch Dezimalzahlen
als Indizes der Minterme dargestellt.
Im ersten Schritt werden die Minterme nach gewichteten Gruppen in eine
weitere Tabelle übertragen. Das Gewicht einer Gruppe wird durch die Anzahl
der Einsen in den Binäräquivalenten bestimmt (Gruppe 0: keine 1, Gruppe 1:
eine 1, usw.). Im zweiten Schritt werden die Minterme von benachbarten Gruppen zu einem um eine Variable kürzeren Term zusammengefasst entsprechend
dem Distributivgesetz sowie Eigenschaften von komplementärem und neutralem Element (s. Abschnitt 2.1.1):
(x2 ∧ x1 ) ∨ (x2 ∧ x1 ) = x2
Zwei Terme sind zusammenfassbar, wenn sie sich nur in einer Stelle um 0
und 1 unterscheiden.
Dies wird im Binäräquivalent durch ’–’ gekennzeichnet. Man beginnt mit
dem ersten Minterm einer Gruppe und versucht ihn mit allen Mintermen der
34
Kapitel 2. Schaltnetze
nächsten Gruppe zu verschmelzen. Verschmolzen werden können alle Minterme, die sich nur durch den Wert einer Variablen unterscheiden. Dabei können
die Minterme mehrmals verwendet werden. Alle Minterme, die so mit einem
√
anderen Minterm verschmolzen wurden, werden gekennzeichnet ( ). Die neu
entstandenen Terme werden wieder nach Gruppen geordnet und in eine Tabelle
eingetragen. An den Dezimalziffern, die in der ersten Spalte der Tabelle stehen,
ist erkennbar, aus welchen Mintermen der neue Term gebildet wurde. Somit
lauten die Tabellen des ersten und zweiten Schrittes:
Dez
0
2
4
5
6
10
7
11
x4
0
0
0
0
0
1
0
1
x3
0
0
1
1
1
0
1
0
x2
0
1
0
0
1
1
1
1
x1
0
0
0
1
0
0
1
1
√ Gruppe
0
√
1
√
√
2
√
√
√
3
√
Dez
0,2
0,4
2,6
2,10
4,5
4,6
5,7
6,7
10,11
x4
0
0
0
0
0
0
0
1
x3
0
0
1
1
1
1
0
x2
0
1
1
0
1
1
x1
0
0
0
0
0
1
-
√ Gruppe
0
√
√
1
√
√
√
√
2
Der zweite Schritt wird solange wiederholt, bis keine Verschmelzung mehr
durchgeführt werden kann. Die verschmolzenen Terme werden gekennzeichnet.
Terme die nicht gekennzeichnet sind, werden Primimplikanten genannt.
Als letzte Tabelle folgt für das Beispiel:
Dez
x4
0,2 ; 4,6 0
0,4 ; 2,6 0
4,5 ; 6,7 0
4,6 ; 5,7 0
x3
1
1
x2
-
x1
0
0
-
Gruppe
0
1
Entstehen bei der Bildung einer Tabelle in einer Gruppe mehrfach gleiche
Terme, so werden diese bis auf einen gestrichen. Die Schaltfunktion setzt sich
jetzt aus den Primimplikanten zusammen, die nicht gekennzeichnet sind. Für
das Beispiel folgt:
Indexdarstellung:
f (x4 , x3 , x2 , x1 ) = (2, 10) ∨ (10, 11) ∨ (0, 2, 4, 6) ∨ (4, 5, 6, 7)
Boolesche Form:
f (x4 , x3 , x2 , x1 ) = (x3 ∧ x2 ∧ x1 ) ∨ (x4 ∧ x3 ∧ x2 ) ∨ (x4 ∧ x1 ) ∨ (x4 ∧ x3 )
Diese Schaltfunktion lässt sich weiter vereinfachen, wiederum mit Tabellen: Primtermtabellen oder Primimplikantentafeln. Jeder Primimplikant ist aus
2.2. Schaltfunktionen
35
bestimmten Mintermen entstanden (dargestellt durch die Dezimalziffern als
Indizes der Minterme). Andererseits sind verschiedene Minterme in mehreren
Primimplikanten enthalten. Ziel der Vereinfachung ist es, diejenigen Primimplikanten zu finden, die alle Minterme überdecken. Diese werden wesentliche
Primimplikanten genannt.
Die Primimplikantentafel ist so aufgebaut, dass über den Spalten der Tafel die Indizes der Minterme stehen und an den Zeilen die Primimplikanten.
Für jeden Primimplikanten werden alle Minterme markiert, die durch ihn abgedeckt werden. In der Primimplikantentafel wird dies durch ein Kreuz in dem
Schnittpunkt der betreffenden Spalte und Zeile dargestellt (Abb. 2.10).
Abbildung 2.10: Primimplikantentafel
Jetzt sucht man alle Spalten, in denen nur eine Markierung steht und kennzeichnet sie, in der Tafel durch . Ein Primimplikant in der zu dieser Markierung gehörigen Zeile ist ein wesentlicher Implikant, wird Kernimplikant genannt, und muss in der Minimalform erscheinen. Aus den verbleibenden (nicht
wesentlichen) Primimplikanten sucht man eine minimale Anzahl von Primimplikanten aus, so dass alle Minterme überdeckt werden, minimale Restüberdeckung. Kernimplikanten und minimale Restüberdeckung sind im Beispiel durch
• gekennzeichnet.
Die Disjunktion der Kernimplikanten und der Restüberdeckung ist die Minimalform der Schaltfunktion.
f (x4 , x3 , x2 , x1 ) = (x4 ∧ x3 ∧ x2 ) ∨ (x4 ∧ x1 ) ∨ (x4 ∧ x3 )
Vektorfunktion
Der Ausdruck
y = f (x1 , x2 , . . . , xn )
stellt eine Schaltfunktion dar. Führt man für den Klammerausdruck
(x1 , x2 , . . . , xn ) eine Abkürzung X ein, wobei
X = (x1 , x2 , . . . , xn )
36
Kapitel 2. Schaltnetze
bedeutet, dann heißt diese Abkürzung Vektor X. Die Bestandteile xi des
Vektors werden Komponenten des Vektors X genannt. Eine Schaltfunktion
kann dann verkürzt geschrieben werden:
y = f (X)
Es gibt Schaltfunktionen, die alle von denselben Schaltvariablen abhängen.
Eine Zusammenfassung dieser Schaltfunktionen wird Funktionsbündel oder Vektorfunktion genannt. Die Schreibweise ist:
Y
Y
F
X
=
=
=
=
F (X)
(y1 , y2 , . . . , ym )
(f1 , f2 , . . . , fm )
(x1 , x2 , . . . , xn )
(2.13)
Der Ausdruck (2.13) steht für
y1 = f1 (x1 , x2 , . . . , xn )
y2 = f2 (x1 , x2 , . . . , xn )
..
.
ym = fm (x1 , x2 , . . . , xn )
Ebenso wie die Schaltfunktion y = f (x1 , x2 , . . . , xn ) kann auch die Vektorfunktion Y = F (X) durch eine Wertetabelle dargestellt werden. Als Beispiel sei
die Wertetabelle zur Codierung des Gray–Code in den Dual–Code angegeben.
Gray–Code
Dual–Code
x4 x3 x2 x1 y4 y3 y2 y1
0 0 0 0 0 0 0 0
0 0 0 1 0 0 0 1
0 0 1 1 0 0 1 0
0 0 1 0 0 0 1 1
0 1 1 0 0 1 0 0
0 1 1 1 0 1 0 1
0 1 0 1 0 1 1 0
0 1 0 0 0 1 1 1
Gray–Code
Dual–Code
x4 x3 x2 x1 y4 y3 y2 y1
1 1 0 0 1 0 0 0
1 1 0 1 1 0 0 1
1 1 1 1 1 0 1 0
1 1 1 0 1 0 1 1
1 0 1 0 1 1 0 0
1 0 1 1 1 1 0 1
1 0 0 1 1 1 1 0
1 0 0 0 1 1 1 1
Die Vektorfunktion Y = F (X) dieser Wertetabelle kann in vier Komponenten oder Schaltfunktionen dargestellt werden.
y1
y2
y3
y4
=
=
=
=
f1 (x1 , x2 , x3 , x4 )
f2 (x1 , x2 , x3 , x4 )
f3 (x1 , x2 , x3 , x4 )
f4 (x1 , x2 , x3 , x4 )
2.3. Analyse von Schaltnetzen
37
Eine andere Darstellungsform der Vektorfunktion ist das KV–Diagramm.
Die Vektorfunktion oder die zugehörige Wertetabelle kann nicht als Ganzes in
einem KV–Diagramm dargestellt werden, sondern für jede y–Komponente wird
ein KV–Diagramm angegeben. Soll eine Vektorfunktion mit Hilfe eines KV–
Diagramms vereinfacht werden, dann wird für jede y–Komponente ein Diagramm erstellt. Nach den bekannten Regeln werden Blöcke gebildet, um die
minimierte Schaltfunktion zu ermitteln. Vektorfunktionen finden häufig Anwendung in Schaltnetzen. Schaltnetze für Codierer, arithmetische Schaltungen
u.a. können als Vektorfunktionen dargestellt werden.
Selbsttestaufgabe 2.3 Minimieren Sie die Schaltfunktion aus Selbsttestaufgabe 2.2 mittels KV-Diagramm und mittels Quine-McCluskey-Verfahren.
Lösung auf Seite 77
2.3
Analyse von Schaltnetzen
Nach DIN 40700 bedeutet der Begriff Schaltzeichen graphische Darstellung einer Booleschen Funktion und graphische Darstellung von technischen Systemen
in Schaltungsunterlagen (Schaltplan). Analog wird hier der Begriff Schaltnetz
sowohl für die technische Realisierung einer Schaltfunktion als auch für die graphische Darstellung als Schaltplan verwendet.
Unter Analyse von Schaltnetzen verstehen wir deshalb das Lesen und Verstehen
von Schaltplänen, die der Verarbeitung binärer Signale dienen, und das Lesen
und Verstehen graphischer Darstellungen von Schaltfunktionen.
In der Analyse von Schaltnetzen wird untersucht, welche Werte die Ausgangsvariable(n) als Funktion der Eingangsvariablen annehmen. Dieser funktionale
Zusammenhang wird am besten durch eine Wertetabelle oder durch eine Funktionsgleichung dargestellt. Ausgehend von einem vorgegebenen Schaltplan wird
für jede Ausgangsvariable eine Schaltfunktion erstellt.
Die Ableitung der Schaltfunktion kann vom Eingang zum Ausgang oder vom
Ausgang zum Eingang vorgenommen werden. Vorteilhaft ist es, vom Eingang
zum Ausgang zu arbeiten, weil man dann am Ausgang der Verknüpfungsglieder Zwischenfunktionen einführen kann. Die Zwischenfunktionen werden zur
(Ausgangs)–Schaltfunktion zusammengefasst. In einer Wertetabelle werden die
möglichen Wertekombinationen der Eingangsvariablen eingetragen, dann die
Werte der Zwischenfunktionen gebildet und aus den Zwischenfunktionswerten
werden die Werte der Ausgangsvariablen ermittelt. Der Analysevorgang lässt
sich durch einen Ablaufplan angeben (Abb. 2.11).
Soll aus einem gegebenen Schaltplan die Funktionsgleichung ermittelt werden, so kann man folgendermaßen vorgehen:
– Ausgänge der Verknüpfungsglieder als Zwischenfunktionen z1 · · · zn kennzeichnen.
38
Kapitel 2. Schaltnetze
Wertekombinationen
der Eingangsvariablen
Schaltplan
Zwischenfunktionen
Wertetabelle
Funktionsgleichung
Abbildung 2.11: Ablaufplan für die Analyse eines Schaltnetzes
– Funktionsgleichungen der Zwischenfunktionen z1 · · · zn aufschreiben.
– Die Zwischenfunktionen durch zugehörige Funktionsgleichungen ersetzen.
Soll aus einem gegebenen Schaltplan eine Wertetabelle ermittelt werden, so
kann man folgendermaßen vorgehen:
– Alle möglichen Wertekombinationen der Eingangsvariablen in eine Wertetabelle eintragen.
– Ausgänge der Verknüpfungsglieder als Zwischenfunktion z1 · · · zn kennzeichnen.
– Funktionswerte der Zwischenfunktionen ermitteln und in die Wertetabelle
eintragen.
– Aus den Funktionswerten der Zwischenfunktionen die Werte der Ausgangsvariablen ermitteln und in die Wertetabelle eintragen.
Die Analyse von Schaltnetzen wird an einem Beispiel gezeigt. Abb. 2.12 zeigt
das zu analysierende Schaltnetz mit eingetragenen Zwischenfunktionen. In Tabelle 2.6 sind die Funktionswerte der Zwischenfunktionen und der Ausgangsfunktionen dargestellt.
Die Darstellung des Schaltnetzes in einer Funktionsgleichung ergibt:
2.3. Analyse von Schaltnetzen
a
b
39
c
Z1
&
>1
>1
Y2
Z2
&
&
Z3
&
Z4
&
Z5
>1
Z7
Y1
Z6
Abbildung 2.12: Beispiel zur Analyse von Schaltnetzen. Der Kringel am Eingang
des letzten UND-Gatters ist hierbei eine Kurzform für einen Inverter.
Eingangsvar.
Z1
Z2
Z3 Z4 Z5
abc a ∨ b ∨ c ab
Z6 = Y1
Z6
Z7
Y2
bc
ac Z3 ∨ Z4 ∨ Z5
0
0
0
0
1
0
0
1
0
0
0
0
1
1
1
0
1
0
0
0
0
1
1
1
1
0
1
1
0
0
1
0
0
0
0
0
0
1
0
0
0
0
1
1
1
1
0
1
0
1
0
0
1
1
0
0
0
1
1
0
0
1
0
1
0
1
0
0
0
1
1
1
1
1
1
1
1
1
0
0
1
c
b
a
0
0
0
0
0
0
0
1
0
0
1
0
0
1
1
Z2 ∧ Z6 Z1 ∨ Z7
Tabelle 2.6: Tabelle der Zwischenfunktionen zur Analyse des Schaltnetzes
Y1 = Z6 = Z3 ∨ Z4 ∨ Z5 = ab ∨ bc ∨ ac
Z 6 = Z3 ∨ Z4 ∨ Z5 = ab ∨ bc ∨ ac
= ab ∧ bc ∧ ac
Z6
= (a ∨ b) ∧ (b ∨ c) ∧ (a ∨ c)
Y2 = Z1 ∨ Z7 = Z1 ∨ (Z2 Z 6 ) = abc ∨ (a ∨ b ∨ c) Z 6
40
Kapitel 2. Schaltnetze
a Z 6 = a (a ∨ b) ∧ (b ∨ c) ∧ (a ∨ c)
= a(a ∨ b c) (b ∨ c)
a Z 6 = abc(b ∨ c) = abc
b Z6 =
= ba c
c Z6 =
= cab
Y2 = abc ∨ abc ∨ ba c ∨ cab
Auch die Durchlaufzeit lässt sich analysieren. Zwischen einem Eingang und
Ausgang Y2 beträgt sie 5 (zwei UND-Gatter, zwei ODER-Gatter, ein Inverter),
und zwischen einem Eingang und Ausgang Y1 beträgt sie 2.
Selbsttestaufgabe 2.4 Analysieren Sie das Schaltnetz aus Abb. 2.13.
Abbildung 2.13: Schaltnetz zum Selbsttest
Lösung auf Seite 78
2.4
Synthese von Schaltnetzen
In der Synthese von Schaltnetzen wird aus einer gegebenen Aufgabenstellung
der Schaltplan für ein Schaltnetz entworfen. Die Aufgabenstellung kann in
verbaler Formulierung, als Funktionsgleichung oder als Wertetabelle vorliegen. Deshalb ist der Syntheseweg von der Art der Aufgabenstellung abhängig.
Abb. 2.14 zeigt den Ablauf zur Synthese von Schaltnetzen.
Liegt die Aufgabenstellung als Funktionsgleichung vor, dann kann der Schaltplan direkt gezeichnet werden. Liegt die Aufgabenstellung als Wertetabelle vor,
wie es oft der Fall ist, dann wird aus der Wertetabelle die Funktionsgleichung
der Ausgangsvariablen in DNF oder KNF gebildet. Dann kann der Schaltplan
gezeichnet werden. Häufig ist es sinnvoll zuvor vereinfachte Funktionsgleichungen zu bilden (mit KV–Diagramm oder dem Verfahren von Quine-McCluskey)
2.5. Code–Umsetzer
Funktionsgleichung
41
verbale Formulierung
Wertetabelle
Variablenzuordung
Wertekombinationen
Wertetabelle
DNF
KNF
Schaltplan
Abbildung 2.14: Ablaufplan zur Synthese von Schaltnetzen
und dann das Schaltnetz zu zeichnen. Liegt die Aufgabenstellung in verbaler
Formulierung vor, werden zuerst die Eingangsvariablen und Ausgangsvariablen
definiert. Dann werden die Wertekombinationen der Eingangsvariablen in eine
Wertetabelle eingetragen und die Werte der Ausgangsvariablen, manchmal über
Bildung von Zwischenfunktionen, zugeordnet. Aus der Wertetabelle werden die
Funktionsgleichungen der Ausgangsvariablen in DNF oder KNF hergeleitet.
Dann kann der Schaltplan gezeichnet werden.
In den folgenden Abschnitten werden beispielhaft verschiedene Schaltnetze entworfen.
2.5
Code–Umsetzer
Ein Code–Umsetzer ist eine Vorschrift für die eindeutige Zuordnung (Codierung) der Zeichen eines Zeichenvorrats zu denjenigen eines anderen Zeichenvorrats (Bildmenge) (DIN 44300). Der Begriff Umsetzer bedeutet eine Funktionseinheit zum Ändern der Darstellung von Daten (DIN 44300/118).
42
Kapitel 2. Schaltnetze
Wir verstehen unter einem Code–Umsetzer ein Schaltnetz, das Informationen,
die in den Zeichen eines Codes A dargestellt sind, in die Zeichen eines Codes B überträgt. Diese Funktion wird durch ein Blockschaltbild dargestellt
(Abb. 2.15).
Information
in den Zeichen
des Codes A
Information
in den Zeichen
des Codes B
Code-Umsetzer
X/Y
Abbildung 2.15: Blockschaltbild für einen Code–Umsetzer
Die Anzahl der Eingänge und Ausgänge eines Code–Umsetzers ist abhängig
von der Wortlänge der Binärcodes, in denen die Information dargestellt ist.
2.5.1
Schaltnetzentwurf für die 8421–BCD
zu 7–Segment Umsetzung
In digitalen Datenverarbeitungssystemen werden Dezimalziffern sehr oft in einem BCD–Code2 dargestellt und in 7–Segmenteinheiten zur Anzeige gebracht.
Dafür ist ein Code–Umsetzer erforderlich. In dem hier betrachteten Beispiel
mögen die Dezimalziffern im 8421–BCD–Code vorliegen. Die Code–Umsetzung
kann durch das Blockschaltbild aus Abb. 2.16 dargestellt werden.
a
A
b
B
C
Code-Umsetzer
X/Y
c
d
e
f
D
g
Abbildung 2.16: Blockschaltbild für einen 8421–BCD–Code zu 7–Segment–
Code–Umsetzer
Die Zuordnung (Codierung) der Dezimalziffern vom 8421–BCD–Code zu
den Segmenten der 7–Segment–Anzeige wird nach Abb. 2.17 in einer Wertetabelle festgelegt (Tabelle 2.7).
2
BCD: binär codierte Dezimalzahl
2.5. Code–Umsetzer
Dezimal 8421–BCD–Code
7–Segment–Code
D C B
A
a b c d e f g
Ziffer
0
0 0 0
0
1 1 1 1 1 1 0
0 0 0
1
0 1 1 0 0 0 0
1
2
0 0 1
0
1 1 0 1 1 0 1
0 0 1
1
1 1 1 1 0 0 1
3
4
0 1 0
0
0 1 1 0 0 1 1
0 1 0
1
1 0 1 1 0 1 1
5
6
0 1 1
0
0 0 1 1 1 1 1
7
0 1 1
1
1 1 1 0 0 0 0
1 0 0
0
1 1 1 1 1 1 1
8
9
1 0 0
1
1 1 1 0 0 1 1
Tabelle 2.7: Zuordnungstabelle für 8421–BCD Code in 7–Segment Code
a
f
g
e
b
c
d
Abbildung 2.17: 7–Segment–Anzeige mit Bildung der Dezimalziffern
Für die Ausgangsvariablen a, b, . . . , g werden aus der Wertetabelle die Funktionsgleichungen in der DF hergeleitet. Geht man davon aus, dass die Kodierungen von 10 bis 15 (Pseudotetraden) nicht vorkommen, dann können diese
bei der Vereinfachung im KV–Diagramm als don’t care–Terme benutzt werden.
Nach der Vereinfachung ergeben sich für die Ausgangsvariablen die Funktionsgleichungen in der DF.
a
b
c
d
e
f
g
=
=
=
=
=
=
=
D ∨ (A ∧ C) ∨ (A ∧ C) ∨ (A ∧ B)
C ∨ (A ∧ B) ∨ (A ∧ B)
A∨B∨C
(A ∧ B) ∨ (A ∧ C) ∨ (B ∧ C) ∨ (A ∧ B ∧ C)
(A ∧ B) ∨ (A ∧ C)
D ∨ (A ∧ B) ∨ (A ∧ C) ∨ (B ∧ C)
(A ∧ B) ∨ (B ∧ C) ∨ (B ∧ C) ∨ D
Mit diesen Schaltfunktionen ergibt sich das Schaltnetz für den Code–Umsetzer
nach Abb. 2.18.
43
44
Kapitel 2. Schaltnetze
A B C D
1
1
1
1
&
&
A B
A C
&
A C
&
A B
&
A B
&
B C
&
A C
&
B C
&
A B C
A
B
C
C
D
>
_1
>
_1
>
_1
>
_1
>
_1
>
_1
>
_1
a
b
c
d
e
f
g
Abbildung 2.18: Schaltnetz für einen 8421–BCD–Code in 7–Segment Code Umsetzer
2.5. Code–Umsetzer
A2
0
0
0
0
1
1
1
1
A1
0
0
1
1
0
0
1
1
45
A0
0
1
0
1
0
1
0
1
Q0
1
0
0
0
0
0
0
0
Q1
0
1
0
0
0
0
0
0
Q2
0
0
1
0
0
0
0
0
Q3
0
0
0
1
0
0
0
0
Q4
0
0
0
0
1
0
0
0
Q5
0
0
0
0
0
1
0
0
Q6
0
0
0
0
0
0
1
0
Q7
0
0
0
0
0
0
0
1
Tabelle 2.8: Wertetabelle für einen 3 Bit Adressdecodierer
2.5.2
Schaltnetzentwurf für einen Adressdecodierer
Decodierer (decoder) sind Code–Umsetzer mit mehreren Eingängen und Ausgängen, bei denen für jede Kombination von Eingangssignalen immer nur je ein
Ausgang ein Signal abgibt (DIN 44300/121).
Am Ausgang eines Decodierers liegt die Information in den Zeichen eines
1 − aus − n Codes vor. Ein 1 − aus − n Code ist dadurch gekennzeichnet, dass
die Anzahl der Binärstellen gleich der Anzahl der darzustellenden Zeichen ist.
Wenn eine Bitstelle des Codewortes das 1–Signal führt, führen alle anderen
Stellen ein 0–Signal (Tabelle 2.8).
Abbildung 2.19: Blockschaltbild eines 3–Bit Adressdecodierers
Decodierer finden als Adressdecodierer Anwendung in digitalen Rechensystemen. Verschiedene Bausteine (Peripheriegeräte) oder Speicherzellen werden
mit einer Adresse angewählt. Über die Adresseingänge wird ein Ausgang des
Decodierers angewählt, der dann ein 1–Signal führt. Hat ein Adressdecodierer
n Eingänge, dann können 2n Ausgänge angewählt werden. Abb. 2.19 zeigt das
Blockschaltbild und Tabelle 2.8 die zugehörige Wertetabelle für einen 3–Bit
Adressdecodierer.
46
Kapitel 2. Schaltnetze
Selbsttestaufgabe 2.5 Entwerfen Sie die Funktionstabelle und ein Schaltnetz
für einen 2-Bit Adressdecodierer.
Lösung auf Seite 78
2.6
Addierglieder
Addierglieder sind Schaltnetze, die zwei Dualzahlen addieren. Dualzahlen bilden wie die Dezimalzahlen ein Stellenwertsystem, nur dass das Gewicht der
i-ten Stelle 2i ist, und nur Ziffern 0 und 1 erlaubt sind. Beispielsweise wird
durch die Dualzahl 101 die Zahl 1 · 22 + 0 · 21 + 1 · 20 = 5 dargestellt.
Dualzahlen werden wie Dezimalzahlen stellenweise addiert, beginnend bei
der wertniedrigsten Stelle. In einem Computer gehören Addierglieder zur ALU
(Arithmetic Logic Unit).
2.6.1
Halbaddierer
Werden zwei einstellige Dualzahlen A und B addiert, dann sind vier Additionen
möglich. Das Ergebnis wird mit Summe S und Übertrag Ü gekennzeichnet. Ü
und S bilden somit eine 2-stellige Dualzahl.
A
0
0
1
1
plus
plus
plus
plus
plus
B
0
1
0
1
Ü
0
0
0
1
S
0
1
1
0
Diese vier Additionen werden in eine Wertetabelle übertragen, A und B
sind die Eingangsvariablen, S und Ü die Ausgangsvariablen.
B
0
0
1
1
A
0
1
0
1
Ü
0
0
0
1
S
0
1
1
0
Aus dieser Wertetabelle können für S und Ü die Schaltfunktionen in einer
Normalform gewonnen werden.
Die Schaltfunktionen in DNF lauten:
S = (A ∧ B) ∨ (A ∧ B) = A ⊕ B
Ü = A ∧ B
2.6. Addierglieder
47
Die Übertragung der Schaltfunktionen in ein Schaltnetz ist in Abb. 2.20
dargestellt.
A
=1
S
A
..
U
&
B
Schaltnetz
HA
B
S
..
U
Schaltzeichen
Abbildung 2.20: Halbaddierer
Ein Schaltnetz, das zwei einstellige Dualzahlen addiert, Summe und Übertrag bildet, wird Halbaddierer (HA) genannt.
2.6.2
Volladdierer
Bei der Addition von zwei mehrstelligen Dualzahlen kommt es vor, dass nicht
zwei sondern drei Bit addiert werden, weil der Übertrag von der nächst niedrigeren Stelle hinzukommt. Solche Additionen können nicht mit einem HA durchgeführt werden. Ein Schaltnetz, das drei Bit addieren kann, daraus Summe
und Übertrag bildet, muss drei Eingänge und zwei Ausgänge haben und wird
Volladdierer (VA) genannt.
Aus der Aufgabenstellung lässt sich das Schaltnetz für einen Volladdierer
entwerfen. Die drei zu addierenden Bits werden mit den Variablennamen A,
B und C gekennzeichnet, teilweise auch Cin für eingehenden Übertrag (engl.
Carry). A, B und C werden addiert, die Summe wird mit S und der entstehende Übertrag mit Ü bezeichnet. Die möglichen Additionen werden in einer
Wertetabelle (Tabelle 2.9) dargestellt. Bei Nutzung eines VA in Addierern für
mehrstellige Dualzahlen werden die Ein– und Ausgänge mit einem Index, der
der Stelle entspricht, bezeichnet. Damit gilt Üi = Ci+1 , und auf die Bezeichnung
Üi wird verzichtet.
Aus der Wertetabelle lassen sich die Schaltfunktionen für die Summe S und
den Übertrag Ü gewinnen. Nach Vereinfachung ergeben sich die DF:
S =
=
Ü =
=
(A ∧ B ∧ C) ∨ (A ∧ B ∧ C) ∨ (A ∧ B ∧ C) ∨ (A ∧ B ∧ C)
A⊕ B⊕ C
(A ∧ B) ∨ (A ∧ C) ∨ (B ∧ C)
(A ∧ B) ∨ (A ∨ B) ∧ C
48
Kapitel 2. Schaltnetze
C
0
0
0
0
1
1
1
1
B
0
0
1
1
0
0
1
1
A
0
1
0
1
0
1
0
1
Ü
0
0
0
1
0
1
1
1
S
0
1
1
0
1
0
0
1
Tabelle 2.9: Zuordnungstabelle für die Addition von drei einstelligen Dualzahlen
In Abbildung 2.21 sind die Schaltfunktionen als Schaltnetz dargestellt.
Die Addition von zwei mehrstelligen Dualzahlen An−1 , . . . , A0 und Bn−1 , . . . , B0
kann bitseriell oder bitparallel ausgeführt werden. Man spricht daher von Serien–
und Paralleladdierer.
Beide Addiernetze unterscheiden sich wesentlich im Hardwareaufwand und
in der Addierzeit. Der Paralleladdierer führt die Addition aller Stellen in einem Schaltnetz ohne Zwischenspeicherung, d.h. während eines Taktschritts (s.
Kap. 3), aus. Der Serienaddierer führt während eines Taktschrittes die Addition von nur einer Stelle aus und nutzt als Schaltwerk Speicherelemente zum
Speichern von Zwischenergebnissen.
2.6.3
Paralleladdierer
Paralleladdierer können nach einer Vielzahl von Strategien realisiert werden,
wobei wir hier nur zwei Formen vorstellen:
– Paralleladdierer in Normalformlösung
– Ripple–Carry Adder
Normalform–Paralleladdierer
Bei einer Normalform entsteht immer ein dreistufiges Schaltnetz mit den Ebenen NICHT, UND, ODER. Die Addierzeit bei diesem Paralleladdierer ist von
der Stellenzahl der Summanden unabhängig. Sie ist konstant und beträgt 3
Laufzeiten. Der Hardwareaufwand steigt allerdings sehr schnell an. Abb. 2.22
zeigt das Blockschaltbild für die Addition von zwei 2–Bit Zahlen.
Für die Ausgangsvariablen ergeben sich die Funktionsgleichungen in DF.
Statt der Booleschen Schreibweise der UND-Verknüpfung mit dem Operator ∧
2.6. Addierglieder
49
a) vielstufiges Schaltnetz
b) dreistufiges Schaltnetz
Abbildung 2.21: Volladdierer
soll hier die algebraische Schreibweise als Multiplikation benutzt werden. Der ·
Operator wird, wie in der Mathematik üblich, nicht ausgeschrieben:
S0 = A0 B 0 ∨ A0 B0
= A0 ⊕ B0
S1 = A0 B0 A1 B1 ∨ A0 B0 A1 B 1 ∨ A0 A1 B1 ∨
A0 A1 B 1 ∨ B 0 A1 B1 ∨ B 0 A1 B 1
= A1 ⊕ B1 ⊕ (A0 B0 ) (mit C1 = A0 B0 )
50
Kapitel 2. Schaltnetze
A0
B0
Schaltnetz
S0
S1
A1
B1
C
Abbildung 2.22: Blockschaltbild für einen Paralleladdierer, der eine Normalform
realisiert
=
C =
=
=
A1 ⊕ B1 ⊕ C1
A1 B1 ∨ A0 B0 A1 ∨ A0 B0 B1
A1 B1 ∨ (A1 ∨ B1 )A0 B0
A1 B1 ∨ (A1 ∨ B1 )C1
(2.14)
(2.15)
(2.16)
Die Addition von zwei n–stelligen Summanden erfordert ein Schaltnetz mit
2 n Eingängen und (n + 1) Ausgängen. Für jeden Summenausgang müssen (ohne Minimierung) 2(2n−1) Min– oder Maxterme verknüpft werden. Die Anzahl
der Verknüpfungsglieder für die Summenausgänge wächst mit n · 2(2n−1) . Ein
Normalform–Paralleladdierer, der die Addition von 16– oder 32–Bit Summanden realisieren soll, ist hardwaremäßig nicht mehr realisierbar.
Der Normalform–Paralleladdierer ist ein Addiernetz mit minimaler Addierzeit
aber maximalem Hardwareaufwand.
Ripple–Carry Adder
Der Ripple–Carry Adder realisiert ein mehrstufiges Schaltnetz. Die Addition
der ersten oder wertniedrigsten Stelle wird von einem HA, der ein dreistufiges
Schaltnetz enthält, ausgeführt. Für jede weitere zu addierende Stelle wird ein
VA nachgeschaltet, der aus den Stellenbits und dem Übertrag der voraufgehenden Stelle wiederum einen Übertrag und eine Summe bildet. Abb. 2.23 zeigt
den so entstandenen Aufbau eines 4–Bit Ripple–Carry Adders.
B3 A3
C4
VA
S3
B2 A2
C3
VA
S2
B1 A 1
C2
VA
S1
B0 A 0
C1
HA
S0
Abbildung 2.23: 4–Bit Ripple–Carry Adder
2.7. Komparatoren
51
Mit jeder Stelle wächst das Schaltnetz um zwei Stufen. Summe und Übertrag einer Stelle i können erst gebildet werden, wenn Summe und Übertrag der
Stelle i−1 stabil sind, d.h. wenn der Übertrag durch alle Stufen des Schaltnetzes
durchgerieselt ist, wobei er durch UND– und ODER-Gatter muss. Die Signallaufzeit t durch ein n–stufiges Schaltnetz ergibt sich aus der Summe der Signallaufzeiten tP durch die einzelnen Volladdierer. Die Addierzeit des Ripple–Carry
Adders ist also proportional der Stellenzahl der Summanden. Werden taktweise Summanden an die Eingänge dieses Paralleladdierers angelegt, dann muss
die Pulsperiode größer sein als die Signallaufzeit (Addierzeit) t. Der Hardwareaufwand, die Anzahl der erforderlichen Verknüpfungsglieder, wächst linear mit
der Stellenzahl. Der Ripple–Carry Adder ist ein Addiernetz, bei dem Addierzeit
und Hardwareaufwand linear zur Stellenzahl n wachsen.
Selbsttestaufgabe 2.6 Konstruieren Sie aus Voll– und/oder Halbaddierern einen
4-Bit Ripple-Carry Addierer, der zusätzlich einen Eingangsübertrag C0 verarbeiten kann. Wie müssen Sie hierzu Abb. 2.23 verändern?
Lösung auf Seite 79
2.7
Komparatoren
Komparatoren sind Rechenelemente, die analoge oder binäre Signale vergleichen (DIN 40700 Blatt18/34). In digitalen Rechenanlagen sind Komparatoren Schaltnetze, die zwei Binärzahlen miteinander vergleichen. Werden zwei
Binärzahlen mit A und B bezeichnet, dann sind die Vergleichskriterien A = B,
A > B und A < B.
y1
b a
a
b
Komparator
Schaltnetz
a = b ( y1 )
a b ( y2 )
a b ( y3 )
Blockschaltbild
0
0
1
1
0
1
0
1
y2
y3
a=b a b a b
1
0
0
1
0
0
1
0
0
1
0
0
Wertetabelle
Abbildung 2.24: 1–Bit Komparator
Zuerst soll ein Komparatorschaltnetz entworfen werden, das zwei einstellige
Binärzahlen miteinander vergleicht. Als Blockschaltbild ergibt sich die Darstellung nach Abb. 2.24. Aus der Wertetabelle können die Schaltfunktionen direkt
angegeben werden.
52
Kapitel 2. Schaltnetze
y1 = a ≡ b
y2 = a ∧ b
y3 = a ∧ b
Abbildung 2.25 zeigt das zugehörige Schaltnetz, das zwei einstellige Binärzahlen vergleicht.
b
a
1
1
=
y1 (a = b)
&
y2 (a b)
&
y3 (a b)
Abbildung 2.25: Schaltnetz eines 1 Bit Komparators
Sollen zwei– oder mehrstellige Binärzahlen auf gleich, kleiner oder größer
untersucht werden, dann kann man unterschiedliche Entwurfsmethoden anwenden. Als Blockschaltbild kann die Aufgabenstellung nach Abb. 2.26 dargestellt
werden.
a0
A
B
a3
b0
b3
A = B (Y1)
Komparator
A B (Y2)
A B (Y3)
Abbildung 2.26: 4 Bit Komparator
Im ersten Schritt wird die Stellenwertigkeit der Binärzahlen festgelegt. Dann
kann der Vergleich der beiden Binärzahlen in einer Wertetabelle dargestellt
werden.
Für zwei zweistellige Binärzahlen A = a1 a0 und B = b1 b0 , wobei a0 , b0 den
Stellenwert 20 haben, und a1 , b1 den Stellenwert 21 , ergibt sich die Wertetabelle
aus Tabelle 2.10.
2.8. Multiplexer
53
B
b1
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
1
A
b0
0
0
0
0
1
1
1
1
0
0
0
0
1
1
1
1
a1
0
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1
a0
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
Y1
A=B
1
0
0
0
0
1
0
0
0
0
1
0
0
0
0
1
Y2
A<B
0
0
0
0
1
0
0
0
1
1
0
0
1
1
1
0
Y3
A>B
0
1
1
1
0
0
1
1
0
0
0
1
0
0
0
0
Tabelle 2.10: Wertetabelle für einen 2–Bit Komparator
Mit Hilfe der Wertetabelle ergeben sich nach Vereinfachung mit dem KV–
Diagramm die Schaltfunktionen in der DF:
Y 2 = a1 b 1 ∨ a1 a0 b 0 ∨ a0 b 1 b 0
Y 3 = a1 b 1 ∨ a0 b 1 b 0 ∨ a1 a0 b 0
Y1 = Y 2 · Y 3 = Y2 ∨ Y3
für A < B
für A > B
für A = B
Diese Schaltfunktionen können als Schaltnetz realisiert werden, das dann
zweistellige Dualzahlen miteinander vergleicht.
Für den Vergleich von mehrstelligen Binärzahlen wird ein Algorithmus angewandt, der schrittweise alle Bit–Stellen miteinander vergleicht. Der Vergleich
kann mit der werthöchsten oder der wertniedrigsten Stelle beginnen. Die Schaltnetze, die dann entstehen, sind mehrstufig.
Selbsttestaufgabe 2.7 Minimieren Sie die DNF für Y1 aus Tabelle 2.10. Stellen
Sie Y3 als Funktion von Y1 und Y2 dar, um eine weitere Minimierung zu sparen.
Lösung auf Seite 79
2.8
Multiplexer
Ein Multiplexer ist ein auswählendes Schaltnetz. Über Steuereingänge wird
einer von mehreren Dateneingängen auf den Ausgang durchgeschaltet.
54
Kapitel 2. Schaltnetze
Abbildung 2.27: Blockschaltbild eines Multiplexers
Abbildung 2.27a zeigt das Blockschaltbild eines Multiplexers. D0 , . . . , Dn
sind die Dateneingänge, S0 , . . . , Sm die Steuereingänge, Y ist der Ausgang.
Abb. 2.27b zeigt das genormte Schaltzeichen eines 4 zu 1 Multiplexers. Der
Buchstabe G bedeutet: Die Steuereingänge steuern die Dateneingänge durch
UND–Verknüpfung. E kennzeichnet den Aktivierungseingang Enable. Wenn
E = 1, d.h. E = 0, dann haben alle Ausgangssignale den Wert 0, unabhängig
vom Wert der Eingangssignale.
Die Funktion eines 4 zu 1 Multiplexers wird durch folgende Wertetabelle
beschrieben:
S1
0
0
1
1
S0
0
1
0
1
Y=
D0
D1
D2
D3
Jeweils ein Dateneingang wird mit dem entsprechenden Steuerwort UND –
verknüpft und auf den Ausgang geschaltet. Daraus folgt die Schaltfunktion
Y
= (S 0 ∧ S 1 ∧ D0 ) ∨ (S0 ∧ S 1 ∧ D1 ) ∨
(S 0 ∧ S1 ∧ D2 ) ∨ (S0 ∧ S1 ∧ D3 )
Aus der Schaltfunktion ergibt sich das Schaltnetz (Abb. 2.28).
Die Länge der Datenworte, die in einem Rechenwerk verarbeitet werden,
beträgt 4, 8, 16 oder 32 Bit. Deshalb ist es erforderlich, dass ein Multiplexer, der
die Datenworte von einem ausgewählten Register auf die ALU durchschaltet,
auch 4, 8, 16 oder 32 Bit Eingangsdaten auf den Ausgang mit entsprechender
Bit–Anzahl schaltet.
Abbildung 2.29 zeigt das Schaltsymbol eines 4 × 2 zu 1 Multiplexers und
die Wertetabelle. Entweder werden die vier Dateneingänge A0 , . . . , A3 oder
2.8. Multiplexer
55
D0
&
D1
&
>
_1
D2
Y
&
D3
&
1
S1
1
S0
Abbildung 2.28: Schaltnetz eines 4 zu 1 Multiplexers
Abbildung 2.29: 4 × 2 zu 1 Multiplexer
B0 , . . . , B3 auf den Ausgang Y = Y0 , . . . , Y3 durchgeschaltet. Die Funktion des
4 × 2 zu 1 Multiplexers wird durch die Wertetabelle beschrieben. Die Auswahl
der Eingangsdatenworte wird durch die Steuervariable S festgelegt und ist in
der Wertetabelle dargestellt.
Während der Multiplexer ein auswählendes Schaltnetz ist, ist der Demultiplexer ein verteilendes Schaltnetz. Über Steuereingänge wird ein Dateneingang
auf einen von mehreren Ausgängen geschaltet. Mit n Steuereingängen kann auf
einen von 2n Datenausgängen verteilt werden (Abb. 2.30).
In Abhängigkeit vom Eingangssteuerwort wird der Dateneingang auf einen
der möglichen Datenausgänge geschaltet. Für einen 1 zu 4 Demultiplexer ergibt
sich die Wertetabelle aus Abb. 2.30.
56
Kapitel 2. Schaltnetze
Abbildung 2.30: Demultiplexer
Steuerworteingänge und Dateneingang sind wie beim Multiplexer UND–
verknüpft. Daraus ergeben sich für die Ausgänge folgende Schaltfunktionen
Q0
Q1
Q2
Q3
=
=
=
=
S0 ∧ S1 ∧ D
S0 ∧ S 1 ∧ D
S 0 ∧ S1 ∧ D
S0 ∧ S1 ∧ D
Mit den Schaltfunktionen lässt sich das Schaltnetz für einen 1 zu 4 Demultiplexer zeichnen (Abb. 2.31).
D
&
Q
&
Q1
&
Q
&
Q
0
2
3
S0
S1
1
0
1
0
G3
1
Q
S0
Schaltnetz
Schaltzeichen
Abbildung 2.31: 1 zu 4 Demultiplexer
0
Q1
Q
D
S1
Q
2
3
2.8. Multiplexer
57
Wie beim Multiplexer deutet der Buchstabe G im Schaltzeichen auf die
UND–Verknüpfung von Steuereingängen und Dateneingang hin.
Um mehr–Bit Dateneingangsworte auf verschiedene mehr–Bit Ausgangskanäle zu schalten, müssen entsprechende Demultiplexer vorhanden sein.
Abbildung 2.32 zeigt die Funktion eines 4 × 1 zu 4 Demultiplexers. Das
Schaltverhalten eines solchen Demultiplexers wird durch die Wertetabelle beschrieben.
Abbildung 2.32: 4 × 1 zu 4 Demultiplexer
Multiplexer werden hauptsächlich als Datenwegschaltungen eingesetzt.
Selbsttestaufgabe 2.8 Bauen Sie aus einem 1-zu-4 Demultiplexer einen 2-Bit
Adressdecoder. Hierzu müssen Sie lediglich in Abb. 2.31 die Ein– und Ausgänge
des Schaltzeichens neu beschriften.
Lösung auf Seite 79
Selbsttestaufgabe 2.9 Konstruieren Sie aus fünf 1-zu-4 Demultiplexern einen
1-zu-16 Demultiplexer. Hierzu müssen Sie lediglich die Schaltzeichen der 1-zu-4
Demultiplexer geeignet mit Leitungen verbinden.
Lösung auf Seite 79
Die UND–Verknüpfung der Steuereingänge mit den Dateneingängen hat
dabei adressierende Eigenschaften. Jede Kombination der Steuervariablen wird
mit einem Dateneingang UND–verknüpft und auf den Ausgang durchgeschaltet. Dadurch wird ein Schaltnetz realisiert, das die Steuereingänge als Eingangsvariable hat. An den Dateneingängen liegen die Funktionswerte der Ausgangsvariablen. So kann jede Schaltfunktion mit einem Multiplexer realisiert
werden.
Am Beispiel eines Volladdierers wollen wir die Realisierung mit Hilfe von
Multiplexern betrachten (Abb. 2.33).
58
Kapitel 2. Schaltnetze
..
S
C U.. B A
S2 S1 S0
0
0
0
0
1
1
1
1
0
0
1
1
0
0
1
1
0
1
0
1
0
1
0
1
0
1
1
0
1
0
0
1
..
S U
Y0 Y1
0
1
1
0
1
0
0
1
0
0
0
1
0
1
1
1
8:1
MUX 1
U
0
0
0
1
0
1
1
1
8:1
MUX 2
S2
S1
S0
a) Tabelle
b) Schaltbild
Abbildung 2.33: Volladdierer mit zwei 8 zu 1 Multiplexern
Die Zuordnungstabelle enthält die Eingangsvariable A, B und Cü sowie
die Ausgangsvariable Summe und Übertrag. Jede Ausgangsvariable stellt eine
vollständige Schaltfunktion mit 8 möglichen Eingangskombinationen dar. Die
Eingangsvariablen werden zu Steuer– oder Adresseingängen der beiden 8 zu
1 Multiplexern. Je nach anliegender Eingangsadresse S2 S1 S0 wird von jedem
Multiplexer ein Eingang auf den Ausgang durchgeschaltet. Liegen an den Eingängen von Multiplexer 1 die Funktionswerte für die Summenbildung, an den
Eingängen von Multiplexer 2 die Funktionswerte der Übertragsbildung, dann
wird die Zuordnungstabelle realisiert. Jeder Multiplexer realisiert eine Schaltfunktion.
Der Volladdierer mit zwei 8 zu 1 Multiplexern nach Abb. 2.33b kann auch
mit zwei 4 zu 1 Multiplexern realisiert werden (Abb. 2.34).
Adresse
S2 S1
0
0
1
1
0
1
0
1
MUX 1 (S)
S0
S0
S0
S0
a) Tabelle
..
MUX 2 (U )
0
S0
S0
1
..
S
..
..
Multiplexer-Belegung fur die Dateneingange
S0
S0
S0
S0
4:1
MUX
U
0
S0
S0
1
4:1
MUX
S2
S1
b) Schaltbild
Abbildung 2.34: Volladdierer mit zwei 4 zu 1 Multiplexern
2.9. Arithmetik-Logik Einheit (ALU)
Das bedeutet eine wesentliche Vereinfachung. Dieser Vereinfachung liegt
folgende Überlegung zugrunde: die Adresse und der zugehörige Dateneingang
sind UND–verknüpft. Es ist also möglich die Eingangsvariablen aufzuspalten,
zwei (hier S1 S2 ) werden als Adresseingänge benutzt und die anderen werden
den Dateneingängen zugeführt. Dabei wird die eigentliche Ausgangsvariable
z.B. y0 (= S) durch die dritte Steuervariable (S0 ) oder durch die Konstanten
0 oder 1 ausgedrückt. Für S2 S1 = 00 gilt y0 = S0 , für S2 S1 = 01 gilt y0 = S 0 ,
für S2 S1 = 10 gilt y0 = S 0 , für S2 S1 = 11 gilt y0 = S0 . Damit ergibt sich
für die Belegung der Dateneingänge der beiden Multiplexer die Tabelle nach
Abb. 2.34.
Schaltfunktionen lassen sich also mit Multiplexern vereinfachen. Die als
Adresseingänge benutzten Eingangsvariablen werden aus der Schaltfunktion
eliminiert. Jede Schaltfunktion mit n Eingangsvariablen kann durch einen Multiplexer mit 2n−1 Eingängen realisiert werden. An die Dateneingänge werden
die Konstanten 0, 1 oder die verbleibende Eingangsvariable angelegt. Soll die
Schaltfunktion durch einen Multiplexer mit 2n−2 Eingängen realisiert werden,
dann werden an die Dateneingänge die Konstanten 0, 1, die restlichen Eingangsvariablen oder Verknüpfungen davon angelegt. Die Adresseingänge können aus
den Eingangsvariablen frei gewählt werden. Jedoch ist es zweckmäßig diejenigen Eingangsvariablen zu wählen, die in möglichst vielen Produkttermen der
Schaltfunktion (DNF) vorkommen.
2.9
Arithmetik-Logik Einheit (ALU)
Die ALU ist das Kernelement eines digitalen Rechensystems (Mikroprozessor).
Als Funktion betrachtet ist die ALU eines Rechners ein Schaltnetz, das binäre
Variablen miteinander verknüpft. Die wichtigste arithmetische Verknüpfung,
die in der ALU ausgeführt wird, ist die Addition. Die logischen (Booleschen)
Verknüpfungen sind UND, ODER, NICHT, XOR. Die Schaltnetze zur Addition (Addierglieder) und die Verknüpfungsglieder UND, ODER, NICHT, XOR
haben wir in diesem Kapitel beschrieben.
Neben der arithmetischen Verknüpfung Addition ist die Subtraktion ebenso
wichtig. Die Subtraktion kann durch ein eigenes Schaltnetz realisiert werden
oder auf die Addition zurückgeführt werden. Wird die Subtraktion auf die Addition zurückgeführt, dann ist für Addition und Subtraktion nur ein Schaltnetz,
z.B. ein Paralleladdierer, erforderlich.
In diesem Abschnitt soll eine einfache ALU entwickelt werden, bei der die
Subtraktion durch Zweierkomplementbildung auf die Addition zurückgeführt
wird.
59
60
Kapitel 2. Schaltnetze
2.9.1
Zahlendarstellung und Zweierkomplement
Für die Zahlendarstellung und Zahlenoperationen mit Schaltnetzen eignen sich
Binärcodes, besonders der Dualcode und der BCD–Code.
Ohne Vorzeichen werden im Dualcode positive Zahlen so addiert, wie im Dezimalcode Dezimalzahlen. Mit Vorzeichen werden positive und negative Zahlen
durch das höchstwertige Bit als Vorzeichen gekennzeichnet. Das höchstwertige
Bit ist bei positiven Zahlen die 0, bei negativen Zahlen die 1. Der eigentliche Zahlenwert wird durch die restlichen n-1 Bits dargestellt, positive Zahlen
im Dualcode, negative Zahlen durch das Zweierkomplement. Die Bildung des
Zweierkomplements einer Dualzahl erfolgt in zwei Schritten:
1. Bildung des Einerkomplements (Invertierung) z.B. Einerkomplement von
A = 011001 ist A = 100110
2. Addition einer 1 zum Einerkomplement
Einerkomplement
A = 100110
+1
Zweierkomplement (A + 1) = 100111
Addiert man eine n-Bit Dualzahl A und das Zweierkomplement dieser Zahl
(A + 1), so ist das Ergebnis eine Dualzahl der Form 1.000 · · · 00, eine
n + 1–Bit Zahl, die (n + 1)ste Stelle ist eine 1, die anderen n Stellen sind 0.
Streicht man die 1 an der werthöchsten Stelle, d.h. die 1 an der (n + 1)sten
Stelle, dann ist das Ergebnis 0.
Daraus folgt:
ohne Übertrag gilt
oder
A + (A + 1) = 0
A + 1 = −A
Das Zweierkomplement (A +1) einer Dualzahl A ist eine Darstellung für
-A.
Ist für die Darstellung von positiven und negativen Zahlen eine feste Bitanzahl vorgegeben, dann kann die Subtraktion einer Zahl durch die Addition des
Zweierkomplements dieser Zahl ausgeführt werden.
Abbildung 2.35 zeigt die Darstellung positiver und negativer 4–Bit Zahlen. Stehen n–Bit Worte für die Zahlendarstellung zur Verfügung, dann ist der
darstellbare Wertebereich
−2n−1 bis + 2n−1 − 1.
Bei arithmetischen Operationen kann das Ergebnis den darstellbaren Wertebereich überschreiten. Das Ergebnis ist dann eine nicht korrekte Zahl, die außerhalb der Bereichsgrenzen liegt, es entsteht ein Überlauf oder overflow.
Wird die Addition von zwei 4–Bit Zahlen A und B allgemein formuliert,
2.9. Arithmetik-Logik Einheit (ALU)
61
Abbildung 2.35: Darstellung positiver und negativer Zahlen
A
a3
a2
a1
a0
B
b3
b2
b1
b0
c4
c3
c2
c1
\
s4
s3
s2
s1
s0
wobei a3 , b3 die Vorzeichenbits sind, si die Stellensummen und ci die Stellenüberträge, dann entsteht ein overflow wenn:
• die Vorzeichenbits der Summanden gleich sind, d.h. a3 ≡ b3 ,
und
• die beiden höchstwertigen Bits der Überträge ungleich sind, d.h. c4 ⊕ c3 .
Sind nämlich die Vorzeichen der Summanden verschieden, so kann es zu keiner Bereichsüberschreitung kommen. In diesem Fall (a3 6= b3 ⇔ a3 ⊕b3 = 1) gilt
wegen ci+1 = ai bi ∨(ai ⊕bi )ci auch c4 = c3 . Sind die Vorzeichen der Summanden
gleich, so entsteht ein Overflow, wenn das Vorzeichenbit des Ergebnisses unterschiedlich zu denen der Summanden ist. Sind beide Summanden-Vorzeichen
positiv, also gleich 0, so entsteht ein Overflow, wenn das Ergebnis-Vorzeichen
negativ, also gleich 1, ist, was wegen si = ai ⊕ bi ⊕ ci nur passieren kann, wenn
c3 = 1 ist. In diesem Fall wird aber kein Übertrag c4 erzeugt. Die Überträge
sind also ungleich. Analog behandelt man den Fall zweier negativer Vorzeichen.
Selbsttestaufgabe 2.10 Welche Zahl wird durch 110011 im Zweierkomplement
dargestellt? Wie sieht die Darstellung der Dezimalzahl −42 im Zweierkomplement mit 8 Stellen (einschl. Vorzeichen) aus? Kann man die Dezimalzahlen
62
Kapitel 2. Schaltnetze
−17, −16, +10, +20 im Zweierkomplement mit 5 Stellen (einschl. Vorzeichen)
darstellen?
Lösung auf Seite 80
2.9.2
Addierer/Subtrahierer
Soll, wie oben vorgeschlagen, die Subtraktion mit einem Paralleladdierer durchgeführt werden, dann müssen wir durch ein zusätzliches Schaltnetz die Funktionsfähigkeit des Paralleladdierers erweitern. Das zu entwerfende Schaltnetz
muss also neben der Summe aus zwei Dualzahlen A und B auch deren Subtraktion, realisiert als Addition von A und B̄ mit Eingangsübertrag 1, beherrschen. Das Ergebnis der Subtraktion, ebenfalls als Dualzahl betrachtet,
ist nur sinnvoll, solange die durch B dargestellte Dualzahl nicht größer ist als
A. Sind hingegen A und B als Zweierkomplement gegeben, so ist auch das
Ergebnis der Addition als Zweierkomplement gegeben und korrekt, solange keine Bereichsüberschreitung auftritt. Eine Bereichsüberschreitung kann, wie in
Abschnitt 2.9.1 beschrieben, durch Vergleich der beiden Vorzeichenbits und
Vergleich der beiden letzten Überträge erkannt werden.
Im ersten Schritt wird ein Schaltnetz entworfen, das abhängig von einem
Steuersignal S0 ein Bit Bi einer Dualzahl invertiert (bei S0 = 1) oder nicht
invertiert (bei S0 = 0). Ein solches Schaltnetz besteht wegen
f (Bi , S0 ) = B̄i ∧ S0 ∨ Bi ∧ S¯0
= Bi ⊕ S0
nur aus einem XOR-Gatter. Damit kann ein Paralleladdierer/-Subtrahierer wie
in Abb. 2.36 realisiert werden. Bei S0 = 0 wird addiert, bei S0 = 1 subtrahiert.
Die Summenbits sind zur Unterscheidung vom Steuersignal mit Fi bezeichnet.
Das ODER-Gatter beim Eingangsübertrag sorgt dafür, dass bei der Addition
ein Eingangsübertrag berücksichtigt werden kann, bei der Subtraktion hingegen
ein Eingangsübertrag mit dem Wert 1 erzwungen wird.
In Abb. 2.37 ist das Addier–/Subtrahier-Schaltnetz zu einem Blockschaltbild zusammengefasst. Das n mit dem Schrägstrich bei A, B und F deutet an,
dass es sich hier eigentlich um n Leitungen handelt.
Man kann das Addier-Subtrahierschaltnetz um weitere Funktionen erweitern. Zum Beispiel wird die XOR-Funktion bereits als Teil der Summenbildung
berechnet. Wenn die Überträge ausgeschaltet werden, wird die XOR-Funktion
als Ergebnis des Addierers ausgegeben. Das Ausschalten“ eines Signals X er”
folgt dadurch, dass man es mit einem Steuersignal S1 UND-verknüpft. Denn
ist S1 = 1, dann gilt X ∧ S1 = X, d.h. das Signal X wird unverändert weitergeleitet. Ist S1 = 0, dann gilt X ∧ S1 = 0, d.h. das Signal X wird ausgeschaltet.
Die Schaltnetze zum gesteuerten Invertieren und Ausschalten können mittels
2.9. Arithmetik-Logik Einheit (ALU)
Abbildung 2.36: 4-Bit Addier-Subtrahierschaltnetz
Abbildung 2.37: Blockschaltbild für n-Bit Addier-Subtrahierschaltnetz
y = S0 ⊕ Ai ∧ S1 kombiniert werden. Abb. 2.38 zeigt das Blockschaltbild und
die Funktionstabelle.
Setzt man in Abb. 2.36 das Schaltnetz SN vor beide Eingänge der Volladdierer und vor den Eingangsübertrag (s. Abb. 2.39), dann kann zum Beispiel der
Eingang Bi invertiert werden (durch S0 = 1 und S1 = 1) und die Eingänge Ai
und Ci ausgeschaltet werden (durch S2 = S3 = S4 = 0), so dass das Ergebnis
der Addition“ wiederum B̄i ergibt.
”
In Tabelle 2.11 sind die sinnvollen Verknüpfungen enthalten, die mit dem
erweiterten Addier–/Subtrahier-Schaltnetz ausgeführt werden können.
Allerdings geht man in der Regel einen anderen Weg. Statt ein Schaltnetz
immer komplizierter zu machen, um mehr Funktionen mit ihm zu berechnen,
63
64
Kapitel 2. Schaltnetze
Abbildung 2.38: Schaltnetz zur Aufgabenstellung; a: Blockschaltbild, b: Funktionstabelle
Abbildung 2.39: Erweitertes Addier-Subtrahierschaltnetz
nimmt man verschiedene Schaltnetze für die Funktionen und selektiert die gewünschte Funktion mittels Multiplexern.
In der ALU werden neben den arithmetischen Verknüpfungen Addition und
Subtraktion die logischen Verknüpfungen UND, ODER und NICHT ausgeführt.
Das Addier–/Subtrahier-Schaltnetz nach Abb. 2.37 muss deshalb um Schaltnetze erweitert werden, die diese Verknüpfungen ausführen. In Abb. 2.40 ist
dieses erweiterte Schaltnetz dargestellt.
Es enthält das Schaltnetz aus Abb. 2.37, die Schaltnetze für die UND–,
ODER– und NICHT–Verknüpfung sowie Multiplexer. Die Komponenten A0 · · ·An−1
der Variablen A und die Komponenten B0 · · ·Bn−1 der Variablen B liegen gleichzeitig an dem Addier–/Subtrahier-Schaltnetz, dem UND-, dem ODER- und
dem NICHT-Schaltnetz an. In dem UND-Schaltnetz werden die Komponenten
A0 ∧B0 , . . . , An−1 ∧Bn−1 verknüpft. Entsprechend werden alle Verknüpfungen
2.10. Schaltnetze mit programmierbaren Bausteinen
S4
logisch
arithmetisch
Tabelle 2.11:
Schaltnetzes
0
1
Funktionstabelle
65
S3
0
0
0
0
1
1
1
1
1
S2
0
0
0
0
0
0
0
1
1
S1
0
0
1
1
0
1
1
0
1
S0
0
1
0
1
0
0
1
0
0
F
0
1
B
B
A
A⊕B
A ⊕B
A
A⊕B
1
1
1
0
0
1
1
1
1
0
1
0
A+B
A-B
B-A
des
erweiterten
Addier–/Subtrahier–
ausgeführt. Dabei spielt der Inverterblock eine Sonderrolle. Während in den
anderen Schaltnetzen die zwei Variablen zu einem Ergebnis verknüpft werden, muss hier gewählt werden, welche der beiden Variablen invertiert werden
soll. Deshalb gibt es einen Auswahl-Multiplexer vor dem Inverterblock mit dem
Steuersignal S1 . Der Ergebnis-Multiplexer wählt über die Steuereingänge S2 , S3
die Ausgänge von einem Verknüpfungsschaltnetz aus und schaltet sie auf den
Ausgang F durch. Mit dem Schaltnetz nach Abb. 2.40 können sowohl arithmetische als auch logische (Boolesche) Verknüpfungen durchgeführt werden.
2.10
Schaltnetze mit programmierbaren Bausteinen
Einfache Schaltnetze (s. vorige Beispiele) lassen sich mit diskreten Verknüpfungsgliedern realisieren. Für komplexe Schaltnetze gibt es Bausteine mit hochintegrierten Verknüpfungsgliedern, die vom Anwender zu einem Schaltnetz verbunden, d.h. programmiert werden. Solche Bausteine werden programmierbare
Logikbausteine genannt. Es sind PROMs, EPROMs, PALs und PLAs.
Wie zu Beginn dieses Kapitels dargestellt, ist ein Schaltnetz die Realisierung einer Schaltfunktion oder Vektorfunktion. Sind die Schaltfunktionen in
einer Normalform gegeben, dann liefert die Realisierung ein dreistufiges Schaltnetz. In einem Schaltnetz, das eine DNF realisiert – und jedes Schaltnetz kann
in der DNF dargestellt werden – werden die Minterme (Produktterme) disjunktiv verknüpft. Das Schaltnetz enthält in der ersten Stufe Inverter, in der zweiten
66
Kapitel 2. Schaltnetze
Abbildung 2.40: Schaltbild der Arithmetik-Logik Einheit (ALU) mit Blockschaltbild.
UND–Verknüpfungen, in der dritten Stufe ODER–Verknüpfungen. Abb. 2.41a
zeigt den Strukturaufbau eines Schaltnetzes in der DNF. Der Eingangsvektor X
hat hier die Komponenten X0 , X1 , X2 , sie liegen invertiert und nichtinvertiert
vor. In den UND–Gliedern werden die Produktterme p0 , . . . ,p7 gebildet. Die
Produktterme werden in den ODER–Gliedern disjunktiv verknüpft und bilden die Ausgangsvariablen. Die Kreuzungspunkte der Eingangsvariablen mit
den Eingängen der UND–Glieder wird UND–Matrix, die Kreuzungspunkte der
Produktterme mit den Eingängen der ODER–Glieder ODER–Matrix genannt.
In programmierbaren Logikbausteinen werden die für das Schaltnetz erforder-
2.10. Schaltnetze mit programmierbaren Bausteinen
lichen Kreuzungspunkte der UND– und/oder ODER–Matrix programmiert.
Abbildung 2.41b zeigt ein PLA mit Verknüpfungsgliedern, Abb. 2.41c ist
eine vereinfachte Darstellung von Abb. 2.41b. Hier sind die Eingangsleitungen der UND– und ODER–Glieder nicht mehr dargestellt. Jeder Punkt in
der UND–Matrix bedeutet, dass die entsprechende Eingangsvariable einen Beitrag zu der mit p gekennzeichneten UND–Verknüpfung liefert. Jeder Punkt der
ODER–Matrix bedeutet, dass dieser Produktterm einen Beitrag zur ODER–
Verknüpfung liefert. Nach der Programmierbarkeit der UND–Matrix und/oder
der ODER–Matrix unterscheidet man vier Gruppen von programmierbaren Logikbausteinen, dargestellt in der folgenden Übersicht:
ROM
PROM, EPROM
PAL
PLA
UND–Matrix
fest
fest
programmierbar
programmierbar
ODER–Matrix
fest
programmierbar
fest
programmierbar
Die Realisierung von Schaltnetzen mit den verschiedenen Arten programmierbarer Logikbausteine wird im Folgenden näher beschrieben.
2.10.1
ROM
ROM steht für Read Only Memory. Nach der Übersichtstabelle ist die UND–
Matrix und die ODER–Matrix dieser Bausteine fest. Dieser Baustein realisiert
ein Schaltnetz mit festem Inhalt, der vom Hersteller durch Maskenprogrammierung fest verdrahtet wurde. Der Inhalt kann nur gelesen werden, daher der
Name Nur–Lese–Speicher oder Festwertspeicher. ROM–Bausteine finden Anwendung z.B. als Programmspeicher, Tabellenspeicher und Codeumwandler.
Ein ROM–Baustein ist aus einem Adressdecodierer und einer Speichermatrix
aufgebaut. Der Adressdecodierer übernimmt die Funktion der UND–Matrix aus
Abb. 2.41. Mit der Speichermatrix wird die ODER–Matrix realisiert. Der Eingangsvektor X wird als Adresse an den Adressdecodierer gegeben, der dann eine
Zeile der Speichermatrix auswählt. Ist die Zeile mit einem Eingang der ODER–
Glieder verbunden, dann wird dieser Produktterm über ein ODER–Glied bzw.
die ODER–Glieder an die Komponenten des Ausgangsvektors geschaltet. Die
Verbindungspunkte, realisiert durch Koppelelemente (Dioden, Transistoren) einer Zeile der Speichermatrix, repräsentieren den Inhalt dieser Speicherzeile oder
das Speicherwort. Deshalb werden die Zeilen der Speichermatrix Wortleitungen
genannt und die Ausgänge der ODER–Glieder entsprechend als Datenleitungen
bezeichnet. Das Schaltnetz nach Abb. 2.42 realisiert einen Volladdierer.
67
68
Kapitel 2. Schaltnetze
X
P
UND..
Verknupfung
ODER..
Verknupfung
Y
1
X
a) Strukturmodell
X0
1
X1
UNDMatrix
1
X2
1
&
p7
&
p6
&
p5
&
p4
&
p3
&
p2
&
p1
&
p0
ODERMatrix
_1
>
Y0
_1
>
Y1
..
b) Darstellung mit Verknupfungsgliedern
X0
1
X1
UNDMatrix
1
X2
1
&
p7
&
p6
&
p5
&
p4
&
p3
&
p2
&
p1
ODERMatrix
c) vereinfachte Darstellung
Abbildung 2.41: Struktur einer PLA
&
p0
_1
>
Y0
_1
>
Y1
2.10. Schaltnetze mit programmierbaren Bausteinen
Speichermatrix
}
}
Adreβdecodierer
69
X0
X1
X/Y
X2
>
_1
>
_1
S
U
..
Abbildung 2.42: Schaltbild eines ROM (VA–Schaltnetz)
2.10.2
PROM, EPROM
PROM steht für Programmable Read Only Memory. Nach der Tabelle der programmierbaren Logikbausteine ist die UND–Matrix fest und die ODER–Matrix
programmierbar. Ein PROM–Baustein realisiert ein Schaltnetz, dessen Inhalt
vom Anwender programmiert wird. Der Aufbau besteht wie beim ROM aus
Adressdecodierer und Speichermatrix. Der Inhalt der Speichermatrix wird vom
Anwender festgelegt und einprogrammiert. An allen Kreuzungspunkten der
Wortleitungen mit den Datenleitungen befinden sich Koppelelemente. Sie sind
über einen Widerstand, der die Aufgabe einer Schmelzsicherung (fusible link)
hat, an die Wortleitung angeschlossen (Abb. 2.43).
UB
Schmelzsicherung
Schmelzsicherung
Abbildung 2.43: Koppelelement mit programmierbarer Schmelzsicherung
Um auf einer Datenleitung eine 0 zu programmieren, muss das Koppelelement im Kreuzungspunkt zur Wortleitung zerstört werden. Ein Überstrom wird
durch das Koppelelement geleitet, der den Widerstand zum Schmelzen bringt
70
Kapitel 2. Schaltnetze
und damit Wort– und Datenleitung entkoppelt. Das hier beschriebene Verfahren funktioniert nur, wenn die Koppelelemente einzeln programmiert werden.
EPROM steht für Erasable Programmable Read Only Memory (löschbarer
programmierbarer Festwertspeicher). Diese Bausteine haben gegenüber den nur
einmal programmierbaren PROMs den Vorteil, dass der Speicher dieser Bausteine gelöscht und dann neu programmiert werden kann. Das Koppelelement,
das Wort– und Datenleitung miteinander verbindet, wird beim Programmiervorgang nicht irreversibel abgekoppelt.
Zum Löschen wird der Baustein mit UV–Licht (Wellenlänge 200–300nm)
bestrahlt. Die Löschzeit beträgt einige Minuten. Es wird immer die Information
des ganzen Bausteines gelöscht.
Neben der Möglichkeit den Inhalt des Bausteins mit UV–Licht zu löschen,
gibt es auch die Möglichkeit elektrisch zu löschen. Diese Bausteine werden EEPROMs genannt (Electrically EPROM). Jede einzelne Bitzelle kann elektrisch
programmiert oder gelöscht werden.
2.10.3
PAL
PAL steht für Programmable Array Logic. PAL–Bausteine haben eine programmierbare UND–Matrix und eine feste ODER–Matrix.
Bei Schaltfunktionen in der DNF nimmt die Zahl der möglichen Produktterme mit jeder Eingangsvariablen um das Doppelte zu. Werden Schaltfunktionen
mit vielen Eingangsvariablen und wenig Ausgangsvariablen mit PROMs realisiert, sind alle möglichen Produktterme vorhanden. In den meisten Fällen werden aber nur einige Produktterme benötigt. PAL–Bausteine enthalten weniger
UND–Glieder als die Zahl möglicher Produktterme aus den Eingangsvariablen.
Beispiel 2.6
Der PAL–Baustein PLHS 18P8 hat zehn Eingangsvariablen.
Damit könnten 1024 Produktterme gebildet werden. Würden alle in UND–
Gliedern realisiert, ergäbe das für viele Anwendungen eine hohe Redundanz.
Der Baustein enthält eine programmierbare UND–Matrix mit 72 UND–Gliedern,
und acht Ausgänge. Jeweils neun UND–Glieder führen auf ein ODER–Glied.
Bei manchen PAL–Bausteinen können die Ausgänge direkt oder invertiert auf
die Eingänge zurückgeführt werden. Zusätzliche Treiber mit Tri–State Funktion und Ausgänge mit Speichergliedern ermöglichen eine große Flexibilität
und Anwendungsmöglichkeit der PAL–Bausteine.
2.10.4
PLA
PLA steht für Programmable Logic Array. PLA–Bausteine haben eine programmierbare UND–Matrix und eine programmierbare ODER–Matrix, deshalb können sie als universelle Bausteine bezeichnet werden. Programmierbare
UND–Terme können mehrfach ausgenutzt werden. Die UND–Glieder können
2.11. Laufzeiteffekte in Schaltnetzen
71
mit jedem der möglichen Eingänge verbunden werden. Vor jedem Ausgang liegt
ein ODER–Glied, das mit jedem UND–Glied verbunden werden kann. Wie bei
den PAL–Bausteinen besteht die Möglichkeit, bestimmte Ausgänge auf den
Eingang zurückzuführen.
Für die Programmierung aller programmierbaren Logikbausteine benötigt
der Anwender ein spezielles Programmiergerät. Bei PROM–Bausteinen werden die Koppelelemente der ODER–Matrix über Wertetabellen programmiert.
PAL–Bausteine werden direkt mit Schaltfunktionen programmiert.
2.11
Laufzeiteffekte in Schaltnetzen
Zu Beginn dieses Kapitels haben wir für die Funktionsbeschreibung von Schaltnetzen die Definition der DIN–Norm benutzt. Darin werden Schaltnetze mit
idealen Verknüpfungsgliedern realisiert und die Eigenschaften realer Verknüpfungsglieder bleiben bewusst unberücksichtigt. Eine Eigenschaft realer Verknüpfungsglieder ist für den Entwurf und das fehlerfreie Funktionieren von
Schaltnetzen besonders wichtig – die Signallaufzeit. In Schaltnetzen kann die
Signallaufzeit dazu führen, dass die Schaltvariablen Werte annehmen, die sie
theoretisch oder bei idealen Verknüpfungsgliedern nicht annehmen würden. Solche Falsch–Werte in Schaltnetzen treten als Antwort auf die Änderung der
Werte der Eingangsvariablen auf und werden Hazards genannt. In den folgenden einfachen Funktionsgleichungen bleibt der Funktionswert per Definition der
Gleichung und bei idealen Verknüpfungsgliedern konstant, auch wenn sich die
Eingangsvariable ändert.
y0
y1
y2
y3
=
=
=
=
x∧x
x∧x
x∨x
x∨x
=
=
=
=
0
1
1
0
In Abbildung 2.44 sind die Schaltnetze zu den Funktionsgleichungen dargestellt. Ein Signalweg führt immer durch zwei Verknüpfungsglieder, der andere
nur durch ein Verknüpfungsglied. Ein Weg dauert deshalb zwei Signallaufzeiten
(2 tp ) der andere eine (1 tp ). Dabei ist angenommen, dass die Signallauzeit tp in
allen Verknüpfungsgliedern gleich ist. Durch die unterschiedlichen Signallaufzeiten kommt es zu Falschwerten oder Hazards. Der Vorgang ist im Impulsdiagramm nach Abb. 2.45 dargestellt. Die so entstandenen Hazards werden
statische Hazards genannt.
Wird in einem Schaltnetz durch Änderung einer Eingangsvariablen auch eine
Ausgangsvariable verändert und entsteht in dem Schaltnetz auch ein statischer
Hazard, der die Ausgangsvariable nochmals auf den Wert vor der Änderung
72
Kapitel 2. Schaltnetze
Abbildung 2.44: Entstehung von Hazards: Schaltnetze und Funktionsgleichungen
×
×
y0
y1
y2
y3
tp
t0
1
2
3
4
5
6
7
Abbildung 2.45: Entstehung von Hazards: Impulsdiagramm
setzt, dann handelt es sich um einen dynamischen Hazard. Einem dynamischen
Hazard geht immer ein statischer Hazard voraus. In Abb. 2.46 ist die Entstehung von einem statischen und dynamischen Hazard dargestellt.
Im Punkt Y1 des Schaltnetzes wird eine XOR–Verknüpfung realisiert. In der
Funktionstabelle sind unter Y1 die Funktionswerte der idealen Verknüpfung dar-
2.11. Laufzeiteffekte in Schaltnetzen
Abbildung 2.46: Entstehung von statischen und dynamischen Hazards
gestellt. Durch die NICHT–Glieder wird der Signalweg der Eingangsvariablen
zu den UND–Gliedern unterschiedlich verzögert. Ändern sich die Eingangsvariablen von BA = 00 nach BA = 11, dann bleibt nach der Funktionstabelle der
Wert der Ausgangsvariablen unverändert auf 0–Signal. Nach dem Impulszeit–
Diagramm, das die vorhandenen Signallaufzeiten berücksichtigt, liegt an beiden
Eingängen der UND–Glieder kurzzeitig 1–Signal an und folglich zeitverzögert
dann auch an den Ausgängen. Eine weitere Signallaufzeit später liegt auch an
Y1 ein 1–Signal an. Dieser nach der Funktionstabelle falsche Wert ist ein statischer 1–Hazard. Ändern sich die Eingangsvariablen von BA = 10 nach BA = 01,
dann entsteht an Y1 ein statischer 0–Hazard. An Y2 entsteht ein dynamischer
Hazard, dargestellt im rechten Teil des Impulsdiagramms (Abb. 2.48).
Statische 0– oder 1– Hazards lassen sich vermeiden, wenn in den Schaltnetzen redundante Verknüpfungsglieder eingebaut werden. Das soll an einem
Beispiel gezeigt werden.
Aus einer gegebenen Funktionstabelle werden die minimierten Funktionsgleichungen in DF und KF ermittelt. Die Funktionsgleichungen werden in ein
Schaltnetz übertragen (Abb. 2.47).
73
74
Kapitel 2. Schaltnetze
x2 x1 x0 f (x0 , x1 , x2 )
0 0 0
0
0
0 0 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
x1 x0
x2
0
1
00
0
1
y = x0 x1 ∨ x0 x2 DF
y = (x0 ∨ x1 ) ∧ (x0 ∨ x2 )
01
0
0
11
1
1
10
0
1
KF
(2.17)
Abbildung 2.47: Schaltnetz mit Hazard (a) und (b), hazardfrei (c) und (d)
In dem Schaltnetz, das aus der DNF gewonnen wurde, entsteht beim Übergang x2 x1 x0 = 1 1 1 nach x2 x1 x0 = 1 1 0 ein statischer 0–Hazard.
Zur Vermeidung dieses 0-Hazards wird das Schaltnetz Abb. 2.47a um ein
redundantes UND-Glied erweitert, das x1 und x2 verknüpft und y auf 1 hält
(Abb. 2.47c). Die Entstehung eines statischen 1–Hazard in einem Schaltnetz,
das nach der KF gewonnen wird, ist analog. Der 1–Hazard entsteht dann beim
Übergang x2 x1 x0 = 0 0 0 nach x2 x1 x0 = 0 0 1.
2.11. Laufzeiteffekte in Schaltnetzen
75
Hazards können besonders die Funktion von Schaltwerken stören. Sie werden
dann Races (Wettlauferscheinungen) genannt. Dabei werden die falschen Werte
der Ausgangsvariablen eines Schaltnetzes von Speichergliedern aufgenommen
und auf den Eingang des Schaltnetzes rückgekoppelt. Um solche Fehler zu vermeiden werden taktflankengesteuerte Speicherglieder benutzt. Die Information
wird erst dann in die Speicherglieder übernommen, wenn die Hazards abgeklungen sind und am Schaltnetzausgang ein stabiler gültiger Signalzustand anliegt.
In Abb. 2.48 sind statische und dynamische Hazards in einer Übersicht
dargestellt.
statt
oder
Y1 =
0
0
0
0
0
Y1 =
1
1
1
1
1
0
1
0
0
0
Y1 =
1
0
1
1
1
entsteht
Y1 =
statischer 1 - Hazard
statischer 0 - Hazard
statt
oder
Y2 =
0
1
1
1
1
Y2 =
1
0
0
1
0
1
1
Y2 =
1
0
0
0
0
entsteht
Y2 =
dynamischer 0 - Hazard
1
0
dynamischer 1 - Hazard
Abbildung 2.48: Klassifikation von Hazards
0
76
Kapitel 2. Schaltnetze
2.12
Zusammenfassung
Nachdem Durcharbeiten dieses Kapitels sollten Sie gelernt haben,
• die verschiedenen Darstellungen von Schaltfunktionen zu verstehen, mit
ihnen zu arbeiten und sie ineinander zu überführen,
• Schaltfunktionen zu minimieren,
• Schaltnetze zu analysieren und zu synthetisieren,
• Zahlen im dualen Zahlensystem und im Zweierkomplement darzustellen
und mit solchen Zahlen zu rechnen,
• mit einfachen Schaltnetzen für oft gebrauchte Funktionalitäten zu arbeiten.
2.13. Lösungen der Selbsttestaufgaben
2.13
77
Lösungen der Selbsttestaufgaben
Selbsttestaufgabe 2.1 von Seite 20
n
4
In n = 4 Variablen gibt es 22 = 22 = 216 = 65536 Schaltfunktionen, wobei
etwa 1000 dieser Schaltfunktionen letztlich unabhängig von einer oder mehreren
der Variablen sind.
Selbsttestaufgabe 2.2 von Seite 29
Die Wertetabelle zu y = x1 ∧ (x2 ∨ x3 ) ∨ x2 ∧ x3 ist in Tabelle 2.12 zu sehen.
Die DNF lautet
x1 x2 x¯3 ∨ x1 x2 x3 ∨ x1 x¯2 x3 ∨ x¯1 x2 x3 .
Das KV-Diagramm sowie eine Darstellung mit Schaltzeichen sind in Abbildung
Abb. 2.49 zu sehen.
x1
0
0
0
0
1
1
1
1
x2
0
0
1
1
0
0
1
1
x3
0
1
0
1
0
1
0
1
y
0
0
0
1
0
1
1
1
Tabelle 2.12: Wertetabelle der Schaltfunktion aus Selbsttestaufgabe 2.2
Abbildung 2.49: KV-Diagramm und Schaltzeichnung der Schaltfunktion aus
Selbsttestaufgabe 2.2
Selbsttestaufgabe 2.3 von Seite 37
Die Übertragung der Minterme aus Tabelle 2.12 liefert mit anschließender Verschmelzung:
78
Kapitel 2. Schaltnetze
Dez
3
5
6
7
x3
0
1
1
1
x2
1
0
1
1
x1
1
1
0
1
√ Gruppe
2
√
√
√
3
Dez
3,7
5,7
6,7
x3
1
1
x2
1
1
x1
1
1
-
Gruppe
2
Man sieht, dass keine weiteren Verschmelzungen möglich sind, denn alle
Terme befinden sich in der gleichen Gruppe. Damit besteht die minimale disjunktive Form aus 3 Primimplikanten:
y = x1 x2 ∨ x1 x3 ∨ x2 x3 .
Abb. 2.50 zeigt die Primimplikanten im KV-Diagramm.
Abbildung 2.50: KV-Diagramm mit Primimplikanten der Schaltfunktion aus
Selbsttestaufgabe 2.3
Selbsttestaufgabe 2.4 von Seite 40
Es gilt
Z1
Z2
Z3
Z4
Z5
Z6
Z7
Z8
Z9
Y
=
=
=
=
=
=
=
=
=
=
X1 ∧ X2
X2 ∧ X3
X1 ∧ X3
X4 ∨ X5
Z1 ∨ Z2 ∨ Z3 = X1 X2 ∨ X2 X3 ∨ X1 X3
Z̄5 = X1 X2 ∨ X2 X3 ∨ X1 X3
Z5 ∧ Z4 = (X1 X2 ∨ X2 X3 ∨ X1 X3 ) ∧ (X4 ∨ X5 )
Z̄4 = X4 ∨ X5
Z6 ∧ Z8 = X1 X2 ∨ X2 X3 ∨ X1 X3 ∧ X4 ∨ X5
Z9 ∨ Z7 = (X1 X2 ∨ X2 X3 ∨ X1 X3 ) ∧ (X4 ∨ X5 )
∨ X 1 X2 ∨ X2 X 3 ∨ X 1 X3 ∧ X4 ∨ X5
Selbsttestaufgabe 2.5 von Seite 45
Die Funktionstabelle ergibt sich wie folgt. Das Schaltnetz ist in Normalform in
Abb. 2.51 zu sehen.
2.13. Lösungen der Selbsttestaufgaben
A1
0
0
1
1
A0
0
1
0
1
Q3
0
0
0
1
79
Q2
0
0
1
0
Q1
0
1
0
0
Q0
1
0
0
0
Abbildung 2.51: Schaltnetz in Normalform der Schaltfunktion aus Selbsttestaufgabe 2.5
Selbsttestaufgabe 2.6 von Seite 51
Der Halbaddierer der niederwertigsten Stelle in Abb. 2.23 wird durch einen
Volladdierer ersetzt, und der zusätzliche Eingang wird mit C0 verbunden.
Selbsttestaufgabe 2.7 von Seite 53
Die Minterme für Y1 befinden sich in den Gruppen 0, 2 und 4. Deshalb ist keine
weitere Minimierung der DNF möglich. Für Y3 gilt: Y3 = Y¯1 ∧ Y¯2 .
Selbsttestaufgabe 2.8 von Seite 57
Die Steuereingänge des Demultiplexers werden mit den Adresseingängen verbunden. Der Dateneingang wird fest mit dem Wert 1 verbunden. Die Ausgänge
des Demultiplexers entsprechen den Ausgängen des Adressdecoders.
Selbsttestaufgabe 2.9 von Seite 57
Die Schaltzeichnung ist in Abb. 2.52 zu sehen.
80
Kapitel 2. Schaltnetze
Abbildung 2.52: 1-zu-16 Demultiplexer aus 1-zu-4 Demultiplexern
Selbsttestaufgabe 2.10 von Seite 61
110011 stellt im Zweierkomplement eine negative Zahl dar. Um den Betrag der
Zahl zu erhalten, subtrahieren wir 1 und bilden wir das Einerkomplement. Wir
erhalten 001101, also die Darstellung von 13 als Dualzahl. Damit stellt 110011
im Zweierkomplement die Zahl −13 dar.
Um die Zweierkomplement-Darstellung der Zahl −42 zu erhalten, bilden wir
zunächst die Darstellung von +42 als Dualzahl, nämlich 32+8+2 = 25 +23 +21 ,
also 00101010. Wir bilden das Einerkomplement und addieren 1, womit wir
11010110 als Zweierkomplement erhalten.
Im Zweierkomplement mit 5 Stellen einschließlich Vorzeichenbit können
Zahlen von −16 (10000) bis +15 (01111) dargestellt werden. Deshalb sind −17
und +20 nicht darstellbar.
Kapitel 3
Schaltwerke
Kapitelinhalt
3.1
Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . .
82
3.2
Speicherglieder . . . . . . . . . . . . . . . . . . . . . . . . .
83
3.3
Automatenmodelle für Schaltwerke . . . . . . . . . . . . . .
88
3.4
Analyse von Schaltwerken . . . . . . . . . . . . . . . . . . .
94
3.5
Synthese von Schaltwerken . . . . . . . . . . . . . . . . . .
97
3.6
Implementierung von Schaltwerken . . . . . . . . . . . . . . 104
3.7
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . 106
3.8
Lösungen der Selbsttestaufgaben . . . . . . . . . . . . . . . 107
81
82
Kapitel 3. Schaltwerke
Charakteristisches Merkmal von Schaltnetzen ist, dass die von ihnen erzeugten Ausgangssignale ausschließlich von den anliegenden Eingangssignalen
abhängen. Es gibt jedoch viele Aufgabenstellungen, bei denen ein digitales System selbstständig (autonom) oder in Abhängigkeit von Eingangssignalen eine
Abfolge von Ausgangssignalen erzeugen soll. Beispiele sind Zähler oder Steuerungsschaltungen wie z.B. eine Ampelsteuerung.
In diesem Kapitel werden wir uns deshalb den Schaltwerken zuwenden. Bei
diesen ist die Ausgabe von den Eingabesignalen und von einem inneren Zustand
bestimmt. Dieser Zustand kann sich wiederum in Abhängigkeit der Eingangssignale zeitlich ändern. Zur Speicherung des inneren Zustands werden Speicherglieder benötigt. Diese werden zuerst unter Betrachtung ihres Aufbaus und
ihrer Kenngrößen eingeführt. Indem man die Ausgänge von Speichergliedern zusammen mit zusätzlichen Eingabesignalen in einem Schaltnetz verknüpft und
dann dessen Ausgangsvektor wieder auf die Eingänge derselben Speicherglieder
zurückführt, erhält man ein Schaltwerk. Struktur und Verhalten von Schaltwerken kann man mit Hilfe endlicher Automaten modellieren. Neben der Analyse
und der Synthese von Schaltwerken werden in diesem Kapitel auch verschiedene
Arten der Implementierung vorgestellt.
3.1
Motivation
Bevor wir uns näher mit der Realisierung von Speichergliedern befassen, wollen
wir ein einfaches Beispiel für ein Schaltwerk betrachten, in dem Speicherglieder
verwendet werden. Dazu dient ein Vorwärtszähler, der eine Wortbreite von zwei
Bit haben soll. Wir gehen davon aus, dass nach dem Einschalten der Betriebsspannung beide Ausgänge der Speicherglieder den Wert 0 haben. Die beiden
Bits kann man zu einem Wort Q1 Q0 zusammenfassen, das einen stellengewichteten Wert darstellt. Ein Vorwärtszähler muss zu diesem Wert 1 addieren, um
den nachfolgenden Zählerstand zu ermitteln. Diese Addition erfolgt mit Hilfe
eines Addier-Schaltnetzes, das auch als Inkrementierer bezeichnet wird (siehe
Kap. 2).
Ausgehend vom Anfangszustand 00 durchläuft dann unser Schaltwerk die
Folgezustände 01, 10 und 11. Danach wechselt es wieder in den Anfangszustand
und beginnt von vorne. Es können also insgesamt vier verschiedene Zustände
angenommen werden und man bezeichnet ein solches Schaltwerk als Modulo-4Zähler.
Für den Modulo-4-Zähler benötigen wir zwei Speicherglieder, die man auch
Flipflops nennt. Ein Flipflop ist in der Lage, einen von zwei Zuständen einzunehmen. Damit die Zustandsübergänge bei allen Flipflops gleichzeitig ausgeführt werden, verfügen sie über einen Takteingang, der meist von einem zentralen Taktsignal angesteuert wird.
In Abb. 3.1 ist das Schaltbild unseres einfachen Schaltwerks dargestellt. Die
Schaltung stellt ein autonomes Schaltwerk dar, da keine externen Steuereingän-
3.2. Speicherglieder
83
ge vorhanden sind. Ein allgemeines Schaltwerk verfügt über solche Eingänge.
Mit einem externen Steuereingang X könnte man den Zähler z.B. zu einem
umschaltbaren Vor-/Rückwärtszähler erweitern.
Abbildung 3.1: Aufbau eines Modulo-4-Zählers.
Speicherglieder erlauben es also, Berechnungen in mehrere Schritte (Takte)
zu zerlegen, indem sie Ergebnisse eines Schritts speichern und diese Werte im
nächsten Schritt als Eingabe der nächsten Berechnung dienen.
Selbsttestaufgabe 3.1 (Vor-/Rückwärtszähler)
a) Ihnen steht ein Halbaddierer und ein Volladdierer zur Verfügung. Entwerfen
Sie damit das Inkrementier-Schaltnetz nach Abb. 3.1.
b) Ersetzen Sie das Inkrementier-Schaltnetz durch ein umschaltbares Inkrementier/Dekrementier-Schaltnetz, das über ein externes Steuersignal X umgeschaltet werden kann. Der Modulo-4-Zähler soll für X = 0 vorwärts und für
X = 1 rückwärts zählen.
Lösung auf Seite 107
3.2
Speicherglieder
In einem Schaltnetz kann kein Wert gespeichert werden. Sobald die Eingabewerte nicht mehr an den Eingängen des Schaltnetzes anliegen, ist auch (nach einer
Verzögerungszeit durch das Schaltnetz) die dazu passende Ausgabe nicht mehr
vorhanden. Es ist allerdings nicht schwer, einen solchen Speicher aus Gattern
zu bauen, wenn man eine der Eigenschaften von Schaltnetzen aufgibt, die Zyklusfreiheit. Hierzu betrachten wir zwei Inverter, die als Kreis geschaltet sind
(siehe Abbildung 3.2), d.h. der Ausgang des einen ist mit dem Eingang des
anderen verbunden und umgekehrt.
84
Kapitel 3. Schaltwerke
Abbildung 3.2: Zwei kreisförmig verschaltete Inverter
Wenn wir dafür sorgen, dass sich am Punkt Q eine Zeitlang der Wert 1 befindet, dann wird wegen x̄ = x nach einer kurzen Verzögerungszeit der Inverter
1 am Punkt Q0 den Wert 0 erzeugen, und der Inverter 2 wird nach einer weiteren kurzen Verzögerung am Punkt Q den Wert 1 erzeugen, womit eine stabile
Rückkopplung erzeugt ist. Der Wert 1 wird nun dauerhaft an Q anliegen, zumindest solange die Schaltung mit Energie versorgt wird. Man sagt, dass der
Wert Q = 1 gespeichert ist. Das gleiche gilt übrigens für den Wert 0, so dass wir
einen Speicher für einen boole’schen Wert, also das Ergebnis einer Berechnung
in einem Schaltnetz, gefunden haben. Man nennt eine solche Schaltung Latch
oder Flipflop.
Es bleibt aber noch zu klären, wie man einen Wert (1 oder 0) in die Schaltung einbringt. Hierzu überlegen wir uns, dass bei einem NOR-Gatter gilt:
x NOR 0 = x̄ ,
x NOR 1 = 0 .
(3.1)
(3.2)
Ersetzt man also die beiden Inverter in Abbildung 3.2 durch zwei NOR-Gatter
(siehe Abbildung 3.3), und setzt die beiden zusätzlichen Eingänge S und R auf
0, dann hat man wegen Gleichung (3.1) die gleiche Situation wie oben.
Abbildung 3.3: Zwei kreisförmig verschaltete NOR-Gatter
Setzt man den Eingang S für eine gewisse Zeit auf den Wert 1, dann geht der
Ausgang des NOR-Gatters 2 wegen Gleichung (3.2) auf 0, unabhängig davon,
welchen Wert der Ausgang des NOR-Gatters 1 dem weiteren Eingang des NORGatters 2 liefert. Beim NOR-Gatter 1 haben beide Eingänge den Wert 0, so dass
der Ausgang des NOR-Gatters 1 den Wert 1 annimmt. Dieser Ausgang bildet
den zweiten Eingang des NOR-Gatters 2. Setzt man dessen S-Eingang von 1
3.2. Speicherglieder
zurück auf 0, dann ändert sich an der Funktionsweise nichts, da 1 NOR 1 =
1 NOR 0 = 0. Damit hat man den obigen Zustand, bei dem dauerhaft am
Punkt Q eine 1 und am Punkt Q0 eine 0 vorliegt, erreicht.
Man nennt den Vorgang, das Signal S für mindestens die doppelte Verzögerungszeit eines NOR-Gatters auf 1 zu setzen, und dann wieder auf 0 zu setzen,
einen Setz-Vorgang. Das Signal S nennt man das Setz-Signal oder Set.
Genauso kann man durch eine 1 am Eingang R, die mindestens zwei NORVerzögerungszeiten anliegt und danach wieder zur 0 wechselt, erreichen, dass
dauerhaft eine 0 an Q und eine 1 an Q0 anliegt. Diesen Vorgang nennt man
Rücksetzen, das Signal R nennt man Rücksetz-Signal oder Reset.
Die gesamte Schaltung bezeichnet man als SR-Latch, manchmal auch RSLatch. Man benutzt dafür das Schaltsymbol in Abbildung 3.4.
Abbildung 3.4: Schaltsymbol des SR-Latch
Üblicherweise zeichnet man die beiden NOR-Gatter nicht mit Verbindungen
in Form eines Kreises, sondern in Form einer Acht wie in Abbildung 3.5 gezeigt.
Man nennt die Verschaltung kreuzweise Rückkopplung.
Abbildung 3.5: Zeichnung des SR-Latch mit kreuzweiser Rückkopplung
Wir haben bisher noch nicht betrachtet, was passiert, wenn man beide Eingänge R und S auf 1 setzt. Dies ist einfach zu beantworten: sowohl an Q als
auch an Q0 liegt eine 0 an. Dieses Verhalten ist der Grund, dass man Q0 statt Q̄
schreibt, denn ansonsten (s.o.) haben die beiden Ausgänge zueinander inverse
Werte.
Während diese Ausnahme nicht schlimm ist, kann es zu einem seltsamen
Verhalten kommen, wenn man beide Eingänge gleichzeitig auf den Wert 0 zurücksetzt. Wenn die beiden Gatter ungleiche Verzögerungszeiten haben, dann
kann das SR-Latch danach gesetzt oder rückgesetzt sein, es kommt darauf an
welches Gatter schneller schaltet. Schalten beide Gatter hingegen gleichschnell,
85
86
Kapitel 3. Schaltwerke
dann haben bei beiden Gattern gleichzeitig beide Eingänge den Wert 0, und
beide Gatter schalten gleichzeitig ihren Ausgang auf 1. Damit liegen an beiden Gattern gleichzeitig die Eingänge auf 0 und 1, so dass beide Gatter ihren
Ausgang gleichzeitig auf 0 schalten. Man sagt: das SR-Latch flimmert. Die
Frequenz dieser Schwingung wird durch die Verzögerungszeit der Gatter bestimmt, und kann mehrere Gigahertz betragen. Die Schwingung endet erst bei
einem erneuten Setzen bzw. Rücksetzen, oder wenn eines der Gatter durch
unterschiedliche Betriebsbedingungen (z.B. Temperatur) eine unterschiedliche
Verzögerungszeit aufweist. Wegen der Gefahr des Flimmerns nach dem Rückschalten von R = S = 1 auf R = S = 0 gilt das gleichzeitige Setzen und
Rücksetzen als verboten.
Selbsttestaufgabe 3.2 (NAND-SR-Latch)
Man kann das SR-Latch auch mittels zweier NAND-Gatter aufbauen. Welche
Zusatzschaltung muss man dann für die Signale R und S vorsehen, damit die
Funktionsweise identisch zu der des SR-Latch mit NOR-Gattern ist?
Lösung auf Seite 107
Wir werden uns bei den weiteren Speichern auf die Darstellung der Funktionsweise beschränken und auf die detaillierte Darstellung des inneren Aufbaus
verzichten, da Flipflops normalerweise nicht aus Gattern, sondern direkt aus
Transistoren auf Chipebene aufgebaut werden.
Eine Weiterentwicklung des SR-Latch ist das JK-Latch. Dieses hat statt der
Eingänge S und R die Eingänge J und K. Es verhält sich wie ein SR-Latch,
nur bei J = K = 1 wird der gespeicherte Wert invertiert (getoggelt).
Während wir bisher mittels Steuereingängen angegeben haben, welcher Wert
im Flipflop gespeichert werden soll, wollen wir doch eigentlich den Wert eines
Datensignals, nämlich des Ausgangs eines Schaltnetzes, im Flipflop speichern.
Deshalb gibt es das D-Flipflop.
Das D-Flipflop speichert den Wert, der am Dateneingang des D-Flipflops
anliegt, wenn das Taktsignal, auch Clock oder CK genannt, eine steigende Flanke hat.
Ein Taktsignal ist hierbei ein im Allgemeinen periodisches Signal, d.h. es
hat abwechselnd die Werte 0 und 1. Den Übergang von 0 nach 1 nennt man
steigende Flanke, den von 1 nach 0 fallende Flanke. Die Abstände zwischen
steigenden Flanken sind normalerweise gleichlang und heißen Taktperiode, das
Intervall zwischen zwei steigenden Flanken heißt Takt.
Intern berechnet das D-Flipflop aus dem Wert des Datensignals und der
steigenden Flanke ein Setz– bzw. Rücksetzsignal geeigneter Länge für ein innenliegendes SR-Latch.
Damit das D-Flipflop funktionieren kann (damit zum Beispiel das interne
Setzsignal lang genug ist), darf sich der Wert des Datensignals für je ein Zeitintervall vor und nach der steigenden Flanke nicht ändern. Diese Zeitintervalle
3.2. Speicherglieder
heißen Setz-Zeit (Setup-Time) und Halte-Zeit (Hold-Time), zusammen nennt
man sie das Wirkintervall.
Das Intervall, in dem ein neu eingespeichertes Datensignal frühestens oder
spätestens am Datenausgang des Flipflop erscheint, heißt Kippintervall. Es handelt sich um ein Intervall, da die Verzögerung von der steigenden Taktflanke
zur Ausgabe je nach dem gespeicherten Wert (0 oder 1) unterschiedlich sein
kann, auch kann die Temperatur die Schaltgeschwindigkeit beeinflussen.
Abbildung 3.6 zeigt schematisch den zeitlichen Verlauf bei einem Taktsignal
CK, einem Dateneingang D und einem Datenausgang Q eines D-Flipflops, sowie
die Kipp– und Wirkintervalle. Wie groß Wirkintervall und Kippintervall genau
sind, und wie sie relativ zur steigenden Taktflanke liegen, hängt von der internen
Struktur eines Flipflops ab. Weiterhin zeigt die Abbildung das Schaltsymbols
des D-Flipflops.
Abbildung 3.6: Zeitverhalten und Schaltsymbol des D-Flipflops
Flipflops, bei denen sich Wirk– und Kippintervall nicht überlappen, heißen Master-Slave-Flipflops oder MS-Flipflops, da sie intern in der Regel aus
zwei hintereinandergeschalteten Latches mit zeitlich verschobenen Steuersignalen realisiert sind. Diese Eigenschaft ist wichtig, damit bei der Verwendung im
Schaltwerk Ausgangssignale des MS-Flipflops nicht über das Schaltnetz so auf
den Eingang rückgekoppelt werden, dass eine Änderung des Ausgangs (im Kippintervall) zu einer Änderung des Eingangs während des Wirkintervalls führt.
Dies würde nämlich verhindern, dass ein Wert zuverlässig im Flipflop gespeichert werden kann.
Wir werden im weiteren davon ausgehen, dass die Taktperiode eines Schaltnetzes stets lang genug ist, damit trotz der Verzögerung durch das Schaltnetz
das Wirkintervall des Speicherglieds respektiert wird.
Verbindet man mehrere D-Flipflops mit einem gemeinsamen Taktsignal, so
erhält man ein sogenanntes Register. Abbildung 3.7 zeigt ein 4-Bit-Register.
Neben dem Takteingang gibt es einen Load-Eingang, dessen Wert bei der steigenden Taktflanke angibt, ob tatsächlich gespeichert werden soll (bei Wert 1)
oder nicht (bei Wert 0). So kann in Schaltwerken bei Registern in manchen
Takten die Taktung ausgeblendet werden, so dass der gegenwärtige Inhalt noch
einen weiteren Takt bestehen bleibt.
87
88
Kapitel 3. Schaltwerke
Abbildung 3.7: Schaltbild eines ladbaren 4-Bit-Registers.
Schieberegister sind Register, die neben dem Takteingang ein Steuersignal
besitzen, mit dem entschieden wird, ob bei der steigenden Taktflanke ein neuer
Wert von den Eingängen geladen“ wird (bei Wert 1), oder ob (bei Wert 0)
”
die Inhalte von Bit i zu Bit i + 1 geschoben werden, sowie ein neuer Wert bei
D0 eingespeichert und der Inhalt des obersten Bits bei Qn−1 ausgegeben und
danach überschrieben wird. Genau wie Schieberegister mit linksschieben“ gibt
”
es auch Schieberegister mit rechtsschieben“, bei denen Bit i nach Bit i − 1
”
verschoben wird.
Selbsttestaufgabe 3.3 (Steuerbares Schieberegister)
Entwerfen Sie ein 3-Bit-Schieberegister, das folgende vier Funktionen ausführt:
S1
0
0
1
1
S0
0
1
0
1
Funktion
Rechtsschieben
Löschen
Parallel laden
Linksschieben
Hinweis: Verwenden Sie zum Entwurf 4:1-Multiplexer und D-Flipflops.
Lösung auf Seite 108
3.3
Automatenmodelle für Schaltwerke
Wenn das Ausgabeverhalten einer Digitalschaltung nicht nur von ihrer momentanen Eingabe abhängt, sondern auch auf vorhergehende Eingaben reagieren
soll, müssen wir sie als Schaltwerk implementieren. Zur abstrakten Darstellung
des Verhaltens verwendet man das Modell eines endlichen Automaten. Dabei
kann man zwei Automatentypen unterscheiden: Mealy- und Moore-Automaten.
Ein Automat ist ein Modell für ein diskretes, zeitveränderliches System.
Automaten können formal durch ein 6-Tupel beschrieben werden:
< I, S, O, s0 , f, g >
(3.3)
3.3. Automatenmodelle für Schaltwerke
89
Darin bezeichnen
• I die Menge der möglichen Eingabezeichen (Eingabealphabet),
• S die Menge der Zustände,
• O die Menge der möglichen Ausgabezeichen (Ausgabealphabet),
• s0 den Startzustand,
• g die Übergangsfunktion und
• f die Ausgangsfunktion.
Wenn die Mengen I, S und O endlich sind, so spricht man von einem endlichen Automaten (Finite State Maschine, FSM).
Finite State Maschine
Für jedes Paar aus einem Zustand und einem Eingabezeichen liefert die
Übergangsfunktion g einen eindeutig bestimmten Folgezustand:
g :S×I →S
(3.4)
Die Ausgabezeichen werden durch die Funktion f bestimmt. Für diese Funktion gibt es zwei verschiedene Definitionen. Die erste Möglichkeit besteht darin,
die Ausgabezeichen lediglich aus dem augenblicklichen Zustand abzuleiten:
f :S→O
(3.5)
Diese Variante wird als zustandsbasierter endlicher Automat oder MooreAutomat bezeichnet.
Moore-Automat
Eine andere Möglichkeit zur Definition von f besteht darin, zusätzlich das
aktuelle Eingabezeichen einzubeziehen. Man bezeichnet diese Variante als übergangsbasierter endlicher Automat oder Mealy-Automat. In diesem Fall gilt:
Mealy-Automat
f :S×I →O
(3.6)
Wenn die Elemente von I, S und O aus binären Zeichenketten bestehen, so
stellen die Funktionen f und g Boole’sche Funktionen dar. Sie können daher
durch Schaltnetze implementiert werden. Zur Speicherung der Zustände können
Flipflops bzw. Register mit geeignetem Zeitverhalten benutzt werden.
Wenn der Eingabevektor X eines Schaltwerks aus m Elementen besteht,
d.h. X = (xm−1 , . . . , x1 , x0 ), so ergibt sich die Menge I der Eingabezeichen
90
Kapitel 3. Schaltwerke
aus dem kartesischen Produkt der einzelnen Signalmengen. Im Falle binärer
Eingaben gilt also
I = {0, 1}m
(3.7)
Ähnlich erhalten wir die beiden anderen Mengen für ein Schaltwerk mit
einem k Bit langen Zustandsvektor bzw. -register Z = (zk−1 , . . . , z0 ) und einem
n-dimensionalen Ausgangsvektor Y = (yn−1 , . . . , y0 ). Im Falle binärer Signale
gilt:
S = {0, 1}k
O = {0, 1}n
Vollständigkeit
(3.8)
(3.9)
Ein Automat heißt vollständig, wenn für jeden Zustand und alle möglichen
Eingaben Zustandsübergänge (Kanten) spezifiziert sind. Eine Kante kann auch
durch eine ODER-Verknüpfung zweier oder mehrerer möglicher Eingaben markiert sein.
Widerspruchsfreiheit Ein Automat heißt widerspruchsfrei , wenn für jeden Zustand und alle möglichen Eingaben jeweils ein eindeutiger Folgezustand bestimmt ist, d.h. wenn g
tatsächlich eine Funktion ist1 . Für den Zustandsgraphen bedeutet dies, dass es
für jede mögliche Eingabe nur eine einzige auslaufende Kante aus einem Knoten
(Zustand) gibt.
Der Aufbau eines synchronen Schaltwerks nach den beiden oben beschriebenen Automatenmodellen ist in Abb. 3.8 dargestellt. Um eine korrekte Arbeitsweise des Schaltwerks zu gewährleisten, muss der Folgezustand Z t+1 stets durch
nicht-transparente Speicherglieder (z.B. Register mit Master-Slave-Flipflops)
vom aktuellen Z t entkoppelt sein. Dies wird durch die verschieden schraffierten
Bereiche des Registers angedeutet.
g
Register
xt
z t+1
f
yt
Takt
zt
Abbildung 3.8: Aufbau eines Mealy-Schaltwerks. Wenn die gestrichelte Verbindung weggelassen wird, erhalten wir ein Moore-Schaltwerk.
1
Da g in Def. 3.3 als Funktion definiert wurde, kann es eigentlich nur widerspruchsfreie
Automaten geben. Da in der Praxis aber Übergänge oft im Zustandsgraph spezifiziert werden,
kann es vorkommen, dass g eine Relation aber keine Funktion ist. Statt zu sagen, dies ist
kein Automat, sagt man, der Automat ist nicht widerspruchsfrei.
3.3. Automatenmodelle für Schaltwerke
3.3.1
91
Darstellungsformen
Es gibt im Wesentlichen zwei Möglichkeiten, um das Verhalten eines Schaltwerkes darzustellen:
• Zustandstabellen (oder Zustandsdiagramme) und
• Zustandsgraphen.
Die Zustandstabelle enthält pro Zeile als Eingangsvariablen die Komponenten
des Eingabevektors X t und die Komponenten des Zustandsvektors Z t , als Ausgangsvariablen die Komponenten des Ausgabevektors Y t und die Komponenten
des Folgezustandsvektors Z t+1 .
Ausgangsvariablen
Eingangsvariablen
t
zk−1
···
z0t
xtm−1
···
xt0
t+1
zk−1
···
z0t+1
t
yn−1
···
y0t
Die Werte der Ausgangsvariablen werden durch ein Schaltnetz aus den Werten
der Eingangsvariablen gebildet. Für jede Ausgangsvariable kann eine minimierte Schaltfunktion in der DNF oder KNF bestimmt werden.
Ein Zustandsgraph beschreibt das Verhalten eines Schaltwerks in graphischer Darstellung. Er besteht aus Knoten und Kanten. Die Knoten werden als
Kreise gezeichnet und stellen die inneren Zustände des Schaltwerks dar. Die
Kanten werden als gerichtete Verbindungen zwischen den Knoten gezeichnet
und stellen die Übergänge zwischen Zuständen dar (Abb. 3.9).
Kanten
zi
zj
Zustand i
Zustand j
Knoten
Abbildung 3.9: Grundform eines Zustandsgraphen.
Die Knoten (Kreise) enthalten die Zustandsnamen oder die zugehörigen
Kombinationen der Zustandsvariablen. An die Kanten wird die Belegung des
Eingabevektors geschrieben, die das Schaltwerk vom gegenwärtigen zum Folgezustand überführt. Beim Mealy-Automaten schreibt man zusätzlich hinter
92
Kapitel 3. Schaltwerke
die Eingabekombination die zum gegenwärtigen Zustand gehörige Belegung
des Ausgabevektors. Beim Moore-Automaten ist der Ausgabevektor eindeutig
durch den momentanen Zustand (Knoten) bestimmt. Daher müssen die Ausgaben an allen von diesem Knoten ausgehenden Übergangskanten gleich sein.
Alternativ schreibt man beim Moore-Automaten die Ausgabe deshalb auch
unterhalb des Zustandsnamens in den Zustand und nicht an die Kanten.
Der Übergang zum Folgezustand ist zwar taktabhängig, jedoch wird der
Takteingang nicht angegeben, da er kein Informationsträger ist. Eine auf den
Ausgangsknoten zurückführende Kante gibt an, dass bei dieser Belegung des
Eingabevektors keine Zustandsänderung auftritt.
Hat der Zustandsvektor eines Schaltwerkes k Variablen, dann hat der entsprechende Zustandsgraph höchstens 2k Knoten. Bei einem Eingabevektor mit
m Variablen können maximal 2m Kanten (Verzweigungen) von jedem Knoten
ausgehen.
3.3.2
Äquivalenz zwischen Mealy- und Moore-Automaten
Die beiden oben beschriebenen Automatenmodelle können so ineinander überführt werden, dass sie ein äquivalentes Ein-/Ausgabeverhalten aufweisen. Wir
beginnen mit dem aufwändigeren Fall: der Überführung eines Mealy-Automaten
in einen äquivalenten Moore-Automaten. Hier müssen wir dem äquivalenten
Moore-Automaten zugestehen, dass im Vergleich zum Mealy-Automaten alle
Ausgaben einen Takt verzögert erfolgen, und dass die Ausgabe im Startzustand nicht gewertet wird. Diese Einschränkung lässt sich nicht umgehen, da
im Mealy-Automat die Ausgabe im ersten Takt vom Startzustand und von der
Eingabe abhängig ist, während im Moore-Automat die Ausgabe im ersten Takt
nur vom Startzustand abhängig ist, und die Eingabe während des ersten Taktes nur den Folgezustand beeinflussen kann, und so erst im folgenden Takt auf
die Ausgabe wirken kann.
Bei der Transformation betrachten wir für jeden Knoten v des MealyAutomaten die eingehenden Kanten. Sind diese alle mit dem gleichen Ausgabevektor Y markiert, so wird im Moore-Automat der Knoten v mit dem
Ausgabevektor Y markiert. Gibt es auf den eingehenden Kanten verschiedene
Markierungen mit Ausgabevektoren Y1 , . . . , Yk , so werden im Moore-Automat
die Knoten v1 bis vk geschaffen, die mit den Ausgabevektoren Y1 bis Yk markiert
werden, und als eingehende Kante jeweils die erhalten, die im Mealy-Automat
mit dem betreffenden Ausgabevektor markiert war.
Abb. 3.10 zeigt ein Beispiel für die Transformation eines Mealy-Automaten.
Wir erkennen, dass der im linken oberen Teil dargestellte Mealy-Automat für
den Zustand 1 unterschiedlich markierte einlaufende Kanten aufweist. Daher
muss der Zustand 1 in zwei Zustände 10 und 11 aufgespalten werden. Über die in
Abb. 3.10 rechts oben dargestellte Zwischenstufe ist dann wieder eine einfache
Transformation zu einem äquivalenten Moore-Automaten möglich (Abb. 3.10
unten). Dabei kann, wie oben schon beschrieben, der Ausgabevektor im Zustand
3.3. Automatenmodelle für Schaltwerke
93
0 beliebig gewählt werden, da er ignoriert wird.
Abbildung 3.10: Umwandlung eines Mealy- in einen äquivalenten MooreAutomaten durch Einfügen zusätzlicher Zustände.
Bei der Überführung eines Moore-Automaten in einen äquivalenten MealyAutomaten müssen wir prinzipiell nichts tun, da ein Moore-Automat auch als
Mealy-Automat betrachtet werden kann, bei dem die Ausgangsfunktion f nicht
von ihrem zweiten Argument, dem Eingabevektor, abhängt. In der Darstellung
als Graph müsste man dann nur die Ausgabemarkierung jedes Zustands v als
Ausgabemarkierung auf alle von v ausgehenden Kanten übertragen. Um eine
Symmetrie zum Vorgehen bei der Transformation eines Mealy-Automaten in
einen Moore-Automaten zu erhalten, kann man allerdings auch die Ausgabemarkierung jedes Zustands auf die einlaufenden Kanten übertragen. Dann entfällt die Ausgabe des Startzustands und alle Ausgaben des Mealy-Automaten
erfolgen einen Takt früher als im Moore-Automaten.
Wir wollen dies an einem Beispiel demonstrieren. In der Abb. 3.11 sehen
wir auf der linken Seite den Zustandsgraphen eines Moore-Automaten. Zur
Umwandlung in einen äquivalenten Mealy-Automaten müssen die Ausgaben
aus den einzelnen Zuständen auf die einlaufenden Kanten übertragen werden.
Das Ergebnis der Umwandlung ist im rechten Teil von Abb. 3.11 zu sehen.
Selbsttestaufgabe 3.4 (Äquivalente Automaten)
Transformieren Sie den Mealy-Automaten mit dem Zustandsgraph aus Abb. 3.12
in einen äquivalenten Moore-Automaten.
Lösung auf Seite 108
94
Kapitel 3. Schaltwerke
Abbildung 3.11: Umwandlung eines Moore- in einen äquivalenten MealyAutomaten.
1/1
0/0
0
1
0/0
1/0
Abbildung 3.12: Zu transformierender Mealy-Automat
3.4
Analyse von Schaltwerken
Im Folgenden gehen wir davon aus, dass der Schaltplan eines Schaltwerks vorgegeben ist und wir die Aufgabe haben, sein Schaltverhalten zu analysieren.
Hierzu müssen wir zunächst die Übergangsfunktion g und die Ausgangsfunktion f anhand der vorgegebenen (Rückkopplungs-)Schaltnetze herleiten. Dann
wird ein Anfangszustand Z0 angenommen und mit den möglichen Werten der
Eingabevariablen und der Übergangsfunktion werden die erreichbaren Folgezustände bestimmt. Zusammen mit der Ausgangsfunktion können auf diese Weise
die Zeilen der Zustandstabelle erstellt werden. Mit Hilfe der vollständigen Zustandstabelle kann schließlich der Zustandsgraph gezeichnet werden, der das
Verhalten des Schaltwerks anschaulich darstellt.
Wir erläutern die Vorgehensweise anhand eines Schaltwerks, das aus (MasterSlave-)D-Flipflops nach Abb. 3.13 aufgebaut ist2 . Zunächst einige allgemeine
Bemerkungen zur Charakterisierung dieses Schaltwerks: Es handelt sich um
ein synchron angesteuertes Schaltwerk. Der Eingabevektor X und der Ausgangsvektor Y bestehen aus je einer Variablen. Das Schaltwerk enthält zwei
D-Flipflops als Speicherglieder, es hat also zwei Zustandsvariablen und kann
daher maximal vier Zustände einnehmen. Die Komponenten z0+ und z1+ des Folgezustandsvektors Z t+1 werden durch ein Schaltnetz aus dem Eingabevektor X
und aus den Komponenten z0 und z1 des Zustandsvektors Z zum Zeitpunkt t
gebildet. Der Ausgangsvektor Y wird aus dem Eingabevektor X und den Komponenten des Zustandsvektors Z gebildet. Daraus folgt, dass das Schaltwerk
einen Mealy-Automaten darstellt.
Aus der allgemeinen Charakterisierung ergibt sich eine erste Beschreibung
des Schaltwerks durch Schaltfunktionen. Die Analyse des Schaltnetzes liefert
die Komponenten des Folgezustandsvektors:
2
Der Einfachheit halber markieren wir im Folgenden die Komponenten des Folgezustandsvektors mit einem hochgestellten +“-Zeichen.
”
3.4. Analyse von Schaltwerken
95
1
x
&
&
&
&
_1
>
z1
z1
z0
z0
&
&
_1
>
1D
C1
&
_1
>
y
z +1
z 0+
1D
C1
C
Abbildung 3.13: Schaltwerk mit D-Flipflops.
z0+ = (z 0 ∧ x) ∨ (z 1 ∧ x)
z1+ = (z0 ∧ z 1 ) ∨ (z0 ∧ x) ∨ (z 0 ∧ z1 ∧ x)
(3.10)
(3.11)
Für den Ausgangsvektor Y ergibt sich:
y = (z0 ∧ z1 ∧ x) ∨ (z 0 ∧ z1 ∧ x)
(3.12)
Beim Übergang vom Zeitpunkt t zu t + 1 wird der Folgezustandsvektor zum
neuen Zustandsvektor Z(t) := Z(t + 1). Mit dieser Zuweisung und den Schaltfunktionen nach (3.10) und (3.11) kann die Zustandstabelle erstellt werden. Wir
gehen von einem Anfangszustand z0 = 0, z1 = 0 aus, d.h. die beiden Flipflops
sollen beim Einschalten der Betriebsspannung zurückgesetzt werden. Die Eingangsvariable soll zuerst den Wert x = 0 haben. Mit (3.10) folgt z0+ = 1, mit
(3.11) folgt z1+ = 0 und mit (3.12) folgt y = 0. Es ergibt sich die Zustandstabelle
3.1.
Mit der Zustandstabelle kann der Zustandsgraph gezeichnet werden (Abb. 3.14).
96
Kapitel 3. Schaltwerke
z1
0
0
0
0
1
1
1
1
z0
0
0
1
1
0
0
1
1
x
0
1
0
1
0
1
0
1
z1+
0
0
1
1
1
0
0
1
z0+
1
1
0
1
1
0
0
0
y
0
0
0
0
0
1
1
0
Tabelle 3.1: Zustandstabelle für das Schaltwerk mit D-Flipflops.
0/0
Start
00
01
1/0
1/0
0/1
0/0
1/1
1/0
11
0/0
10
Abbildung 3.14: Zustandsgraph für das Schaltwerk mit D-Flipflops.
Selbsttestaufgabe 3.5 (2-Bit-Synchronzähler)
Analysieren Sie den Synchronzähler aus Abb. 3.15.
Abbildung 3.15: Synchronzähler mit zwei Ausgängen.
3.5. Synthese von Schaltwerken
97
a) Bestimmen Sie, ausgehend vom Startzustand Q3 Q2 Q1 Q0 = 0001, den Zählzyklus für X = 1 und für X = 0 und erstellen Sie die Zustandstabelle!
b) Zeichnen Sie den Zustandsgraphen!
Lösung auf Seite 109
3.5
Synthese von Schaltwerken
Bei der Synthese wird aus einer (häufig verbal) gegebenen Aufgabenstellung
ein Schaltwerk entworfen. Dazu ist es notwendig, die Aufgabenstellung mit den
Beschreibungsmöglichkeiten eines Schaltwerks darzustellen. Es empfehlen sich
folgende Schritte für das Vorgehen:
• Festlegen der Zustandsmenge, die das Schaltwerk einnehmen soll. Daraus
ergibt sich die Anzahl der Zustandsvariablen und die Anzahl der erforderlichen Speicherglieder.
• Festlegen des Anfangszustandes. Hier wird meist der Nullvektor angenommen, der durch die Rücksetzeingänge der Flipflops beim Einschalten
der Betriebsspannung erzwungen werden kann.
• Definition der Eingangs- und Ausgangsvariablen.
• Darstellung der zeitlichen Zustandsfolge in Form eines Zustandsgraphen.
• Aufstellen der Zustandstabelle.
• Herleitung und Minimierung der Übergangs- und Ausgangsfunktion in
DNF bzw. KNF aus der Zustandstabelle.
• Darstellung des Schaltwerks in einem Schaltplan. Das bedeutet: Übertragen der Schaltfunktionen in ein Schaltnetz, Verbindungen mit den Flipflops herstellen, Kennzeichnen des Zustandsvektors und des Folgezustandsvektors.
• Implementierung des Schaltwerks.
3.5.1
Umschaltbarer Gray-Code-Zähler
Als Beispiel wollen wir einen zweistelligen, umschaltbaren Gray-Code-Zähler
auf Basis von D-Flipflops entwerfen. Kennzeichen des Gray-Codes ist es, dass
sich zwischen zwei aufeinander folgenden Codewörtern stets nur eine Bitstelle
ändert. Die Umschaltung soll durch eine Eingangsvariable x erfolgen. Für x = 0
ist die Zählfolge
00, 01, 11, 10, 00 usw.
98
Kapitel 3. Schaltwerke
und für x = 1 ist die Zählfolge
00, 10, 11, 01, 00 usw.
festgelegt.
• Zuerst ermitteln wir die Anzahl der nötigen Zustände. Da es insgesamt
vier verschiedene Codewörter gibt, sind genauso viele Zustände erforderlich. Zur Codierung dieser vier Zustände reichen zwei Zustandsvariablen
aus, die in zwei D-Flipflops gespeichert werden.
• Das Schaltwerk beginnt mit dem Anfangszustand Z(0) = 00.
• Die Umschaltung erfolgt durch die Eingangsvariable x. Die Ausgangsvariablen sind identisch mit den Zustandsvariablen, weil der Zählzustand
angezeigt werden soll. Wir können also auf ein Ausgangsschaltnetz f verzichten.
• Die zeitliche Zustandsfolge, die sich aus der obigen Beschreibung und den
Festlegungen ergibt, ist in Abb. 3.16 dargestellt.
1
00
00
10
10
0
1
0
1
0
0
01
01
11
11
1
Abbildung 3.16: Zustandsgraph des umschaltbaren Gray-Code-Zählers.
• Zustandstabelle
Aus dem Zustandsgraphen folgt unmittelbar die Zustandstabelle 3.2. Die
linke Seite der Tabelle enthält alle Wertekombinationen, die die Eingangsvariable x und die Zustandsvariablen z1 , z0 annehmen können. Die rechte
Seite der Tabelle enthält die Werte der Folgezustände.
• Schaltfunktionen (Übergangsfunktionen)
Aus der Zustandstabelle können wir die Übergangsfunktionen in der DF
aufstellen:
z1+ = (z0 ∧ x) ∨ (z 0 ∧ x)
z0+ = (z 1 ∧ x) ∨ (z1 ∧ x)
(3.13)
(3.14)
3.5. Synthese von Schaltwerken
z1
0
0
0
0
1
1
1
1
99
z0
0
0
1
1
0
0
1
1
z1+
0
1
1
0
0
1
1
0
x
0
1
0
1
0
1
0
1
z0+
1
0
1
0
0
1
0
1
Tabelle 3.2: Zustandstabelle für den umschaltbaren Gray-Code-Zähler.
Die beiden Schaltfunktionen können nicht weiter mit Karnaugh-Diagrammen (vgl. Kapitel 2) minimiert werden. z1+ entspricht der EXOR-Funktion
und z0+ der negierten EXOR-Funktion (Äquivalenz-Funktion).
• Zeichnen des Schaltwerkes (Abb. 3.17).
1
x
&
&
_1
>
z1
z1
z0
z0
&
&
_1
>
z +1
1D
C1
z 0+
1D
C1
C
Abbildung 3.17: Schaltplan des umschaltbaren Gray-Code-Zählers.
100
Kapitel 3. Schaltwerke
Selbsttestaufgabe 3.6 (3-Bit-Zähler)
Entwerfen Sie einen 3-Bit-Synchronzähler mit folgender Zählfolge:
0 − 1 − 3 − 7 − 6 − 5 − 0 − ···
Erstellen Sie hierzu:
• den Zustandsgraph,
• die Zustandstabelle,
• die minimierten Funktionsgleichungen und
• das Schaltbild des Schaltwerks.
Lösung auf Seite 110
3.5.2
Zustands-Minimierung
Werden zwei Schaltwerke durch die gleiche Folge von Eingabevektoren angesteuert und liefern sie die gleiche Folge von Ausgangsvektoren, so sind sie bezüglich ihres Verhaltens äquivalent. Es kann aber durchaus sein, dass sie intern
ganz anders arbeiten bzw. über eine unterschiedliche Zahl von Zuständen verfügen. Häufig enthalten die aus einer textuellen Beschreibung abgeleiteten Zustandsgraphen redundante Zustände. Um den Entwurfs- und Hardwareaufwand
zu minimieren, sollte man daher die Anzahl der Zustände im Zustandsgraphen
redundante Zustände
minimieren.
Um redundante Zustände zu erkennen, muss man die Äquivalenz zweier
bzw. mehrerer Zustände prüfen.
Zwei Zustände zi und zj sind äquivalent (zi ≡ zj ), wenn sie das gleiche
Ausgabeverhalten haben und – für alle Eingabevektoren – äquivalente Folgezustände einnehmen. Wir können folgende Äquivalenzrelation ≡“ definieren:
”
zi ≡ zj ⇔ ∀x(f (x, zi ) = f (x, zj )) und
∀x(g(x, zi ) ≡ g(x, zj )) d.h. ∀x(zi+ ≡ zj+ )
x∈I
(3.15)
(3.16)
Wenn eine der Bedingungen (3.15) oder (3.16) nicht erfüllt ist, folgt, dass
die Zustände zi und zj nicht äquivalent sind (zi 6≡ zj ). Die Bedingung in Gleichung (3.16) macht die Definition der Zustandsäquivalenz rekursiv, ohne dass
man ein Rekursionsende sieht. Zum Verständnis ist es hilfreich, das Gegenteil
zu betrachten: Zwei Zustände sind nicht äquivalent, wenn es eine natürliche
3.5. Synthese von Schaltwerken
101
Zahl r gibt, so dass nach r-facher Anwendung von Gleichung (3.16) eine NichtÄquivalenz durch Verletzung von (3.15) auftritt. Gibt es ein solches r nicht,
dann sind die Zustände äquivalent. Wegen der endlichen Zahl s = |S| von
Zuständen kann man sich auf r ≤ s(s − 1)/2 einschränken.
Aus der Definition der Zustandsäquivalenz können wir ein einfaches Ausschluss-Verfahren zur Zustands-Minimierung ableiten.
Zu Beginn erstellen wir eine Liste sämtlicher Zustandspaare, die (3.15) erfüllen. Für jedes Paar ermitteln wir alle Folge-Zustandspaare (g(x, zi ), g(x, zj ))
und tragen diese hinter dem zugehörigen Ausgangs-Zustandspaar ein.
Wegen der Symmetrie-Eigenschaft der Äquivalenzrelation (aus zi ≡ zj folgt
zj ≡ zi ) müssen nur die Zustandspaare mit i < j für i, j = 1, · · · , n betrachtet
werden.
Außerdem müssen nur Folge-Zustandspaare aufgenommen werden, die sich
vom Ausgangs-Zustandspaar unterscheiden. Als nächstes wird überprüft, ob
die eingetragenen Folge-Zustandspaare die Bedingung (3.15) der Äquivalenzrelation erfüllen. Wenn ein Folge-Zustandspaar nicht als Ausgangs-Zustandspaar
vorkommt, ist es zu streichen. Gleichzeitig impliziert die Streichung eines FolgeZustandspaares, dass auch das zugehörige Ausgangs-Zustandspaar nicht äquivalent sein kann und ebenfalls zu streichen ist.
Kennt man die Menge der äquivalenten Zustandspaare, so kann man mit
der Transitivitäts-Eigenschaft eventuell neue Zustandspaare bestimmen. Wenn
beispielsweise die Zustands-Paare (zi ,zj ) und (zj ,zk ) äquivalent sind, so ist auch
das Zustandspaar (zi ,zk ) äquivalent und die drei Zustände bilden eine Äquivalenzklasse. Alle Zustände einer Äquivalenzklasse können durch einen einzigen Äquivalenzklasse
Zustand ersetzt werden.
Im Folgenden soll die Anwendung des gerade beschriebenen Verfahrens an
einem Beispiel demonstriert werden. Das Schaltwerksverhalten sei durch die in
Tabelle 3.3 gegebene Zustandstabelle gegeben. Es handelt sich um ein MooreSchaltwerk mit einem Ein- und einem Ausgang.
Tabelle 3.3: Zustandstabelle für das Beispiel zur Zustands-Minimierung.
Zustand
1
2
3
4
5
6
7
8
Folge-Zustand für
X=0
X=1
4
3
6
8
5
4
1
5
3
1
6
2
2
8
3
7
Ausgang
0
0
1
0
1
1
0
1
102
Kapitel 3. Schaltwerke
In Tabelle 3.4 sind drei Stufen zur Bestimmung der Äquivalenzklassen dargestellt. In Stufe 0 werden zunächst die Ausgangs-Zustandspaare ermittelt.
Dann werden hinter jedes Ausgangs-Zustandspaar die entsprechenden FolgeZustandspaare geschrieben. In Stufe 1 wird von oben nach unten geprüft, ob
die rechts stehenden Folge-Zustandspaare auch als Ausgangs-Zustandspaare
vorhanden sind. Wenn dies nicht der Fall ist, werden die betreffenden FolgeZustandspaare und Ausgangs-Zustandspaare gestrichen. Bei der Stufe 1 wurden
bereits Streichungen aus vorangehenden Zeilen berücksichtigt. So erfolgt z.B. in
Zeile 9 und 10 die Streichung des Folge-Zustandspaars (1,2). In Stufe 2 verfährt
man in gleicher Weise und stellt dann fest, dass bei einem weiteren Durchlauf
keine Streichungen mehr möglich sind.
Tabelle 3.4: Ermittlung der Äquivalenzklassen.
(1,2)
(1,4)
(1,7)
(2,4)
(2,7)
(3,5)
(3,6)
(3,8)
(4,7)
(5,6)
(5,8)
(6,8)
Stufe 0
(4,6) (3,8)
(3,5)
(2,4) (3,8)
(1,6) (5,8)
(2,6)
(1,4)
(5,6) (2,4)
(3,5) (4,7)
(1,2) (5,8)
(1,2) (3,6)
(1,7)
(3,6) (2,7)
(1,2)
(1,4)
(1,7)
(2,4)
(2,7)
(3,5)
(3,6)
(3,8)
(4,7)
(5,6)
(5,8)
(6,8)
Stufe 1
(4,6) (3,8)
(3,5)
(2,4) (3,8)
(1,6) (5,8)
(2,6)
(1,4)
(5,6) (2,4)
(3,5) (4,7)
(1,2) (5,8)
(1,2) (3,6)
(1,7)
(3,6) (2,7)
(1,2)
(1,4)
(1,7)
(2,4)
(2,7)
(3,5)
(3,6)
(3,8)
(4,7)
(5,6)
(5,8)
(6,8)
Stufe 2
(4,6) (3,8)
(3,5)
(2,4) (3,8)
(1,6) (5,8)
(2,6)
(1,4)
(5,6) (2,4)
(3,5) (4,7)
(1,2) (5,8)
(1,2) (3,6)
(1,7)
(3,6) (2,7)
Aus der Stufe 2 der Tabelle 3.4 können wir ablesen, dass die beiden Zustandspaare (1,4) und (3,5) äquivalent sind. Wir können daher pro äquivalentes Zustandspaar je einen Zustand (z.B. die Zustände 4 und 5) mit dem jeweils
anderen Zustand vereinigen. Man beachte, dass die verbleibenden Zustände (1
und 3) wechselseitig Folgezustände voneinander sind.
Selbsttestaufgabe 3.7 (Benötigte Zustände ermitteln)
Eine Zustands-Minimierung ergab, dass die ursprünglich betrachteten acht
Zustände (1 bis 8) folgende äquivalente Zustandspaare enthalten: (1,3), (1,6),
(3,6), (4,5), (4,7) und (5,7). Wie viele Zustände werden insgesamt noch benötigt?
Lösung auf Seite 112
3.5. Synthese von Schaltwerken
Nachdem wir die minimale Zahl der Zustände ermittelt haben, stellen sich
folgende Fragen: Wie viele Bits (Flipflops) werden zu deren Codierung benötigt? Welche Codewörter sollen den jeweiligen Zuständen zugeordnet werden?
3.5.3
Zustands-Codierung
Nehmen wir an, dass nach der Zustandsminimierung n Zustände übrig bleiben.
Wir betrachten zwei Möglichkeiten der Codierung: unär und binär.
Hot-one-Codierung
Bei der unären oder Hot-One-Codierung gibt es pro Zustand ein Flipflop. Der
Zustand i wird dadurch repräsentiert, dass Bit i den Wert 1 hat und alle anderen
Bits den Wert 0. Beispielsweise ist bei n = 4 der Zustand 2 durch 0100 codiert.
Offensichtlich ist durch die Symmetrie ohne Belang, welcher Zustand welches Codewort erhält. Der Zustand des Schaltwerks entspricht dem gesetzten
Flipflop. Für Moore-Automaten kann das Ausgangsschaltnetz durch diese Art
der Zustandscodierung sehr einfach entworfen werden. Es besteht pro Ausgangsvariable aus einem OR-Schaltglied, dessen Eingänge mit allen Zuständen
(d.h. Flipflop-Ausgängen) verbunden sind, bei denen diese Ausgangsvariable
den Wert 1 liefern soll. Für Mealy-Automaten ist die Ansteuerung des ORSchaltglieds deutlich komplizierter. Sie erfolgt durch die AND-Verknüpfung
mit einem Vorgängerzustand und der Decodierung des für eine 1-Ausgabe zugeordneten Eingangsvektors. Die benötigten Schaltfunktionen können sehr gut
mit programmierbaren Logikbausteinen implementiert werden (vgl. Abschnitt
3.6.1).
Bei Verwendung von D-Flipflops kann auch die Übergangsfunktion sehr
einfach bestimmt werden. Jeder Knoten des Zustandsgraphen ist genau einem
Flipflop zugeordnet. Die Schaltfunktion des zugehörigen D-Eingangs ergibt sich
aus einer OR-Verknüpfung von Konjunktionstermen, die jeweils einer einlaufenden Kante in diesen Knoten entsprechen. Mit jedem dieser Konjunktionsterme
wird eine Bedingung für das Aktivieren des Zustands geprüft. Diese Bedingung
enthält einerseits den vorausgehenden Zustand (Ausgang Q des zugeordneten
Flipflops) und die Belegung des Eingabevektors, die diesen Zustandsübergang
auslöst. Darin treten allerdings nur diejenigen Eingangsvariablen auf, die Einfluss auf den Zustandsübergang haben.
Die Hot-one-Codierung sollte wegen ihrer Hardware-Redundanz nur angewandt werden, wenn die Zahl der Zustände klein ist (z.B. < 10). Bei Schaltwerken mit einer größeren Zahl von Zuständen sollte man die Binärcodierung
verwenden. Bei Problemstellungen mit einer sehr großen Zahl von Zuständen
(z.B. > 1000) ist ein systematischer Entwurf nach der oben beschriebenen Methode nicht mehr möglich. Man verwendet in diesem Fall komplexe Schaltwerke
(vgl. Kapitel 4).
103
104
Kapitel 3. Schaltwerke
Binäre Codierung
Zur binären Codierung der Zustände werden dlog2 ne Flipflops benötigt. Man
sieht, dass man bereits für n = 128 gegenüber der Hot-One-Codierung eine
große Einsparung erhält: 7 statt 128 Flipflops.
Flipflop i muss gesetzt werden, wenn einer der Zustände, in deren Binärcodierung Bit i den Wert 1 hat, als Nachfolgezustand auftritt. Deshalb müssen für
alle diese Zustände die eingehenden Kanten betrachtet werden. Jede Kante wird
durch einen Konjunktionsterm repräsentiert, der den Startzustand der Kante
und den zugeordneten Eingabevektor repräsentiert. Hat beispielsweise Zustand
0001 eine eingehende Kante, die vom Zustand 1110 ausgeht und mit der Eingabe 10 markiert ist, so wird für Bit 0 der Konjunktionsterm Q3 Q2 Q1 Q̄0 X1 X̄0
verwendet. Die Konjunktionsterme werden mit einem ODER-Gatter verknüpft,
dessen Ausgang mit dem Dateneingang des Flipflops i verbunden ist.
In diesem Fall ist die Zuordnung von Zuständen zu Binärwörtern durchaus
von Belang, was den Schaltungsaufwand für die Übergangsfunktion betrifft. Das
Zuordnungsproblem ist auch nicht trivial, da es n! = n·(n−1)·(n−2) · · · 1 mögliche Zuordnungen gibt. Für größere Werte von n gibt es deshalb ZuordnungsHeuristiken. Wir werden im weiteren die Zustände einfach durchnummerieren
und Zj mit der Binärcodierung von j zuordnen.
3.6
Implementierung von Schaltwerken
Wie wir gesehen haben, bestehen Schaltwerke aus einem Register und ein oder
zwei Schaltnetzen für die Funktionen f und g. Zur Implementierung von Schaltwerken müssen also im Wesentlichen Schaltnetze aufgebaut werden, die diese
beiden Funktionen realisieren. Diese Schaltnetze können entweder durch Verdrahten einzelner Schaltglieder (AND, OR, NOT) oder mit Hilfe programmierbarer Logikbausteine implementiert werden. Wir wollen im Folgenden die letztgenannte Möglichkeit genauer betrachten.
3.6.1
Programmierbare Logikbausteine
In Abschnitt 2.10 haben wir bereits PROMS, EPROMs, PALs und PLAs
kennengelernt. Eine Erweiterung von deren Funktionalität bieten so genannte
Gate Array Logic GALs (Gate Array Logic), die neben einem programmierbaren PAL für jeden
Ausgang auch noch ein Flipflop bereitstellen. Dessen Ausgang kann wiederum
auf die Eingänge des Schaltnetzes zurück gekoppelt werden. Mit einem solchen
Logikbaustein kann also ein komplettes Schaltwerk implementiert werden. Die
Programmierung kann bei neueren Bausteinen (z.B. Lattice ispGALs3 ) sogar
3
isp steht für in-system programmable.
3.6. Implementierung von Schaltwerken
105
im laufenden Betrieb erfolgen und wird mit Hilfe von Hardwarebeschreibungssprachen unterstützt.
Makrobefehl
X/Y
MIKROPROGRAMM
SPEICHER
Folgeadress -
Vektor
C
Steuer - Vektor
C
Status - Vektor
Operanden
ALU
Ergebnis
Abbildung 3.18: Mikroprogrammsteuerwerk auf Basis eines Speichers.
3.6.2
Mikroprogrammsteuerwerke
Auch mit einem Speicherbaustein, d.h. ROM, PROM, EPROM oder EEPROM,
kann leicht ein programmierbares Schaltwerk implementiert werden, vgl. Abb. 3.18.
Die beiden Schaltfunktionen f und g werden dann in zwei Teilbereichen des
Speichers abgelegt. Da man ein derartiges Schaltwerk häufig zur Realisierung
der Ablaufsteuerung in einem Prozessor verwendet, wird es auch als Mikroprogrammsteuerwerk bezeichnet. Sowohl das Holen als auch das Ausführen einzelner Maschinenbefehle kann mit Hilfe eines entsprechenden Mikroprogramms
sehr komfortabel und flexibel implementiert werden. In Kapitel 4 werden wir
noch einige Beispiele hierfür vorstellen.
Der Adresseingang des Speichers wird durch die Konkatenation von Eingabevektor X und Zustandsvektor Z angesteuert. Zu jeder angelegten Adresse
aktiviert der Adressdecoder genau eine Wortleitung mit 1 und steuert damit die
Bitleitungen an. Wenn der Vektor X den höherwertigen Adressbits zugeordnet
wird, kann man damit im Speicher die Startadresse des Mikroprogramms festlegen. Bei einem Prozessor verwendet man hierzu den so genannten Operationscode oder kurz Opcode, der über einen weiteren programmierbaren Logikbaustein
in die eigentliche Startadresse umgewandelt wird. Die Folgezustandsvariablen
Z + bilden zusammen mit dem gleichzeitig zwischengespeicherten Ausgangsvek-
106
Kapitel 3. Schaltwerke
tor4 Y einen Mikrobefehl. Jeder Mikrobefehl kann über die Folgezustandsvariablen nachfolgende Mikrobefehle adressieren. Die Auswahl der in einem Mikrobefehl auszuführenden Operationen erfolgt durch die Belegung des zugehörigen
Ausgangsvektors Y .
3.7
Zusammenfassung
Nach dem Durcharbeiten dieses Kapitels sollten Sie
• den Aufbau und die Funktionsweise von Speichergliedern verstanden haben,
• Kenntnis von Automatenmodellen und deren Anwendung auf Schaltwerke
erlangt haben,
• Verständnis des Zeitverhaltens und der Funktionsgrenzen von Schaltwerken entwickelt haben,
• Analyse und Synthese von Schaltwerken vornehmen können,
• die verschiedenen Methoden zur Implementierung von Schaltwerken anwenden können.
4
Lässt man die D-Flipflops vor dem Ausgangsvektor Y weg, so erhält man ein MealySchaltwerk.
3.8. Lösungen der Selbsttestaufgaben
3.8
Lösungen der Selbsttestaufgaben
Selbsttestaufgabe 3.1 von Seite 83
a)
Abbildung 3.19: Aufbau des Inkrementier-Schaltnetzes für einen reinen Vorwärtszähler.
b)
Abbildung 3.20: Aufbau des Schaltnetzes für einen umschaltbaren Vor/Rückwärtszähler. Für X = 0 wird wie in a) inkrementiert. Für X = 1 wird
die Zweierkomplement-Darstellung von -1 = 11 als zweiter Summand in den
2-Bit-Addierer eingespeist. Dadurch wird der Zustand mit jedem Takt dekrementiert.
Selbsttestaufgabe 3.2 von Seite 86
Man muss die beiden Steuersignale invertieren (siehe Abb. 3.21), denn wenn
zum Beispiel S̄ den Wert 0 hat (dies passiert genau dann wenn S = 1) geht der
Ausgang des oberen NAND-Gatters auf 1, und das Flipflop ist gesetzt.
107
108
Kapitel 3. Schaltwerke
Abbildung 3.21: Aufbau eines SR-Latches auf Basis von NAND-Schaltgliedern.
Selbsttestaufgabe 3.3 von Seite 88
Die Lösung ist in Abb. 3.22 dargestellt. Die Multiplexereingänge werden von
links nach rechts über S1 S0 = 00, 01, 10 und 11 ausgewählt.
Abbildung 3.22: Steuerbares Schieberegister.
Selbsttestaufgabe 3.4 von Seite 93
Man erkennt, dass Knoten 1 eingehende Kanten mit unterschiedlichen Ausgangswerten hat. Er muss dupliziert werden. Der resultierende Moore-Automat
ist als Zustandsgraph in Abb. 3.23 dargestellt.
3.8. Lösungen der Selbsttestaufgaben
109
0
1
0
0
1
1
10
0
0
0
11
1
Abbildung 3.23: Äquivalenter Moore-Automat
Selbsttestaufgabe 3.5 von Seite 96
a) Es handelt sich um einen Moore-Automaten, da die Ausgabe nur vom Zustand abhängig ist. Wir erhalten die Zustandstabelle gemäß Tabelle 3.5. Aus
dieser geht hervor, dass es sich um einen Automaten mit Hot-One-Codierung
(s. auch Abschnitt 3.5.3) handelt, denn ausgehend vom Zustand Z0 , codiert
als 0001, sind nur drei weitere Zustände (0010, 0100, 1000) erreichbar, also
insgesamt 4 Zustände. Die Ausgabe ist eine Binärcodierung der Zustandsnummer, also zum Beispiel erzeugt Zustand Z2 , codiert als 0100, die Ausgabe
10. Die Zählzyklen lassen sich ebenfalls aus der Tabelle ablesen:
• Für X = 0 ergibt sich der Zählzyklus 0 — 3 — 2 — 1 — 0, also ein
Modulo-4 Zähler, der aber runterzählt.
• Für X = 1 ergibt sich der Zählzyklus 0 — 1 — 3 — 2, also ein GrayCode-Zähler.
Tabelle 3.5: Zustandstabelle für Selbsttestaufgabe 3.5.
+
Y1 Y0
X Q3 Q2 Q1 Q0 Q+
3 · · · Q0
0
0001
1000
00
0
1000
0100
11
0
0100
0010
10
0
0010
0001
01
1
0001
0010
00
1
0010
1000
01
1
1000
0100
11
1
0100
0001
10
110
Kapitel 3. Schaltwerke
b) Der Zustandsgraph ist eine grafische Darstellung der Zählfolgen. Die Knoten enthalten die jeweiligen (Zähl-)Zustände, während an den Kanten die
Zustandsübergangsbedingungen eingetragen sind.
Abbildung 3.24: Zustandsgraph für das Schaltwerk von Selbsttestaufgabe 3.5.
Selbsttestaufgabe 3.6 von Seite 100
Den Zustandsgraphen für den Zähler zeigt Abb. 3.25.
Abbildung 3.25: Zustandsgraph für den 3-Bit–Synchronzähler.
Da keine Vorgaben gemacht wurden, welche Flipflop-Typen zu verwenden
sind, wählen wir D-Flipflops, weil sich damit wesentlich leichter synchrone
Zähler aufbauen lassen als mit JK-Flipflops. Auch die Automatentabelle (Tabelle 3.6) wird sehr einfach. Die Spalten der Ausgänge des Zeitpunktes tn+1
sind mit den Spalten der D-Eingänge identisch.
Tabelle 3.6: Zustandstabelle für Selbsttestaufgabe 3.6.
Q2 Q1
0
0
0
0
0
1
1
1
1
1
1
0
tn
Q0 D2 D1 D0
0
0
0
1
1
0
1
1
1
1
1
1
1
1
1
0
0
1
0
1
1
0
0
0
Q2
0
0
1
1
1
0
tn+1
Q1
0
1
1
1
0
0
Q0
1
1
1
0
1
0
3.8. Lösungen der Selbsttestaufgaben
Wir minimieren nun die Funktionsgleichungen für die D-Eingänge. Da die
Zustände mit dem Wert 2 und 4 nicht auftreten, werden sie als don’t care (×)
gekennzeichnet.
• D0 :
Abbildung 3.26: KV-Tafel für den Eingang D0 .
Wir erhalten: D0 = Q2 ∨ Q0 .
• D1 :
Abbildung 3.27: KV-Tafel für den Eingang D1 .
In diesem Fall nützen die don’t care-Terme nichts, da sie weder zur Vergrößerung eines Päckchens noch zum Einbinden einer alleinstehenden 1
dienen können. Die minimale DF lautet: D1 = Q0 Q1 ∨ Q0 Q2 .
• D2 :
Abbildung 3.28: KV-Tafel für den Eingang D2 .
Die minimale Gleichung für D2 lautet: D2 = Q1 .
111
112
Kapitel 3. Schaltwerke
Damit können wir die Schaltung angeben (Abb. 3.29).
Abbildung 3.29: Schaltbild zur Lösung der Selbsttestaufgabe 3.6.
Selbsttestaufgabe 3.7 von Seite 102
Es gibt die Äquivalenzklassen (1,3,6) und (4,5,7). Die Zustände 3 und 6 können
mit dem Zustand 1, die Zustände 5 und 7 mit dem Zustand 4 verschmolzen
werden, d.h. es werden insgesamt nur noch 4 Zustände (1,2,4 und 8) benötigt.
Kapitel 4
Komplexe Schaltwerke
Kapitelinhalt
4.1
Entwurf von Schaltwerken . . . . . . . . . . . . . . . . . . . 114
4.2
Aufbau komplexer Schaltwerke . . . . . . . . . . . . . . . . 115
4.3
RTL-Notation . . . . . . . . . . . . . . . . . . . . . . . . . . 116
4.4
ASM-Diagramme . . . . . . . . . . . . . . . . . . . . . . . . 119
4.5
Konstruktionsregeln für Operationswerke . . . . . . . . . . 122
4.6
Entwurf des Steuerwerks . . . . . . . . . . . . . . . . . . . 124
4.7
Beispiel: Einsen-Zähler . . . . . . . . . . . . . . . . . . . . . 126
4.8
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . 136
4.9
Lösungen der Selbsttestaufgaben . . . . . . . . . . . . . . . 137
113
114
Kapitel 4. Komplexe Schaltwerke
Im vorigen Kapitel haben wir Schaltwerke anhand von Zustandsgraphen
bzw. –tabellen entworfen. Da bei der Mikroprogrammierung die Tabellen direkt in einen Speicher übertragen werden können, ist diese Methode wesentlich
einfacher als der konventionelle Entwurf mit optimierten Schaltnetzen für die
Funktionen f und g. Aber auch diese einfachere Entwurfsmethode kann nur angewandt werden, solange die Zahl der Zustände und Eingangsvariablen klein“
”
ist.
Eine interessante Anwendung von Schaltwerken besteht darin, komplexere
arithmetische Operationen auf der Basis von Schaltnetzen für einfachere Operationen auszuführen und dadurch den Hardwareaufwand zu minimieren. So
kann beispielsweise eine Multiplikation auf mehrere Additionen zurückgeführt
werden. Schaltwerke für derartige Aufgabenstellungen können wegen der großen
Zahl der Eingangsvariablen bzw. möglichen Zustände nicht mit den bisher behandelten Methoden entworfen werden. Bei arithmetischen Aufgabenstellungen
ist außerdem die genaue Zahl der Zustände im Voraus nicht bekannt, weil die
Anzahl der nötigen Berechnungsschritte von den Operanden abhängt.
Um bei solch komplexen Aufgabenstellungen einen übersichtlichen Schaltwerksentwurf zu erreichen, verwendet man ein komplexes Schaltwerk, das aus
zwei kooperierenden Teilschaltwerken besteht. Ausgangspunkt für den Entwurf
eines komplexen Schaltwerks ist ein Hardware-Algorithmus für die gewünschte
Funktion. Die Umsetzung von Algorithmen in digitale Hardware erreicht man
am einfachsten durch eine funktionale Aufspaltung in einen steuernden und
einen verarbeitenden Teil. Ein komplexes Schaltwerk besteht daher aus einem
Steuer– und einem Operationswerk. Die Verwendung universeller Operationswerke führt im nächsten Kapitel zu den Grundlagen eines Computers.
4.1
Entwurf von Schaltwerken
In Kapitel 3 haben wir Methoden zum Entwurf von Schaltwerken kennengelernt. Die wesentlichen Entwurfsschritte sollen hier kurz wiederholt werden.
Ausgehend von einer verbalen (informalen) Beschreibung, kann man das
gewünschte Schaltverhalten mit einem Zustandsgraphen formal spezifizieren.
Die Zahl der Zustände wird minimiert, indem man äquivalente Zustände zusammenfasst. Dadurch werden weniger Flipflops benötigt. Durch eine geeignete
Zustands-Codierung kann der Aufwand zur Bestimmung der Folgezustände minimiert werden. Um die Schaltfunktionen für die Eingänge der D-Flipflops zu
finden, überträgt man den Zustandsgraphen in eine Zustandstabelle. In dieser
Tabelle stehen auf der linken Seite die Zustandsvariablen zkt und die Eingabevariablen xtm zum Zeitpunkt t. Auf der rechten Seite stehen die gewünschten
Folgezustände zkt+1 und die zugehörigen Ausgabevariablen ynt .
Die Entwurfsaufgabe besteht daher in der Erstellung der Zustandstabelle
und der Minimierung der damit spezifizierten Schaltfunktionen. Im Gegensatz
zu diesem konventionellen Entwurf kann bei Anwendung der Mikroprogram-
4.2. Aufbau komplexer Schaltwerke
115
mierung der zweite Schritt entfallen. Beide Entwurfsmethoden sind aber nur
anwendbar, solange die Zahl der Eingangsvariablen und möglichen inneren Zustände klein“ bleibt.
”
Beispiel 4.1 8-Bit-Dualzähler: Mit k Speichergliedern sind maximal 2k Zustände codierbar. Um z.B. einen 8-Bit-Dualzähler nach der beschriebenen Methode zu entwerfen, müsste eine Zustandstabelle mit 256 Zeilen erstellt werden.
Hiermit müssten acht Schaltfunktionen für die jeweiligen D-Flipflops ermittelt und minimiert werden. Obwohl es sich bei diesem Beispiel um eine relativ
einfache Aufgabenstellung handelt und außer der Taktvariablen keine weiteren
Eingangsvariablen vorliegen, ist ein Entwurf mit einer Zustandstabelle nicht
sinnvoll durchführbar.
Schaltwerke für komplizierte Aufgabenstellungen, d.h. Schaltwerke mit einer
großen Zahl von Zuständen, wollen wir als komplexe Schaltwerke bezeichnen. komplexe Schaltwerke
Um bei komplexen Schaltwerken einen effektiven und übersichtlichen Entwurf
zu erreichen, nimmt man eine Aufteilung in zwei kooperierende Teilschaltwerke
vor: ein Operationswerk (data path) und ein Steuerwerk (control path). Die
funktionale Aufspaltung in eine verarbeitende und eine steuernde Komponente
vereinfacht den Entwurf erheblich, da beide Teilschaltwerke getrennt voneinander entwickelt und optimiert werden können.
Beispiele für die Anwendung komplexer Schaltwerke sind:
• Ampelsteuerung mit flexiblen Phasen,
• Umrechnung von Messwerten (z.B. Temperatur von Grad Celsius in Fahrenheit),
• Arithmetische Einheiten für Gleitkommazahlen (Multiplikation, Division).
Für die o.g. Aufgabenstellungen könnten wir sehr leicht eine Lösung in Form
eines Algorithmus angeben und ein entsprechendes Programm schreiben. Aber
auch wenn wir eine Hardware-Lösung für die Aufgabenstellung suchen, können
wir einen Algorithmus als Ausgangspunkt für den Entwurf benutzen. Diesen
Hardware-Algorithmus implementieren wir dann mit einem komplexen Schaltwerk.
4.2
Aufbau komplexer Schaltwerke
Abb. 4.1 zeigt den Aufbau eines komplexen Schaltwerks. Wie bei einem gewöhnlichen Schaltwerk sind funktional zusammengehörende Schaltvariablen zu Vektoren zusammengefasst. Das Operationswerk bildet den verarbeitenden Teil,
d.h. hier wird der Eingabevektor X schrittweise zum Ausgabevektor Y umgeformt. Der Eingabevektor, Zwischenergebnisse und der Ausgabevektor werden
116
Kapitel 4. Komplexe Schaltwerke
hierzu in Registern gespeichert und über Schaltnetze (arithmetisch oder logisch) miteinander verknüpft. Die Datenpfade zwischen den Registern und solchen Operations-Schaltnetzen können mit Hilfe von Multiplexern oder Bussen
realisiert werden.
Steuervektor
Statusvektor
Die in einem Taktzyklus auszuführenden Operationen und zu schaltenden
Datenpfade werden durch die Belegung des Steuervektors bestimmt. Mit jedem Steuerwort wird ein Teilschritt des Hardware-Algorithmus abgearbeitet.
Das Steuerwerk hat die Aufgabe, die richtige Abfolge von Steuerwörtern zu
erzeugen. Dabei berücksichtigt es die jeweilige Belegung des Statusvektors, der
besondere Ergebniszustände aus den vorhergehenden Taktzyklen anzeigt. Über
eine Schaltvariable des Statusvektors kann z.B. gemeldet werden, dass ein Registerinhalt den Wert Null angenommen hat. Das Steuerwerk kann bestimmte
Statusvariablen abfragen und anschließend auf deren momentane Belegung reagieren. So ist es beispielsweise möglich, eine Schleife im Steueralgorithmus zu
verlassen, wenn das Register mit dem Schleifenzähler den Wert Null erreicht
hat.
Wir gehen im Folgenden davon aus, dass die beiden Teilschaltwerke synchron getaktet werden und die Rückkopplungsbedingungen stets erfüllt sind.
Eingabevektor X
Operationswerk
Steuervektor S
Ausgabevektor Y
Statusvektor V
Steuerwerk
Abbildung 4.1: Aufbau eines komplexen Schaltwerks.
4.3
RTL-Notation
In diesem Abschnitt wollen wir die so genannte RTL-Notation (Register Transfer Level) zur kompakten Beschreibung von Hardwarekomponenten und deren
Funktionen einführen. Wir bezeichnen Register durch Großbuchstaben. Sofern
4.3. RTL-Notation
117
die Register eine besondere Funktion haben, wählen wir eine passende Abkürzung, z.B. AR für ein Adressregister. Allgemeine Register zur Speicherung von
Daten können mit R bezeichnet und durchnummeriert werden.
Ein Register wird als Vektor definiert, indem man die Randbits“ angibt.
”
So bedeutet R2(7 : 0), dass R2 ein 8-Bit-Register ist. Das rechte Bit hat die
Wertigkeit 20 und wird daher auch als LSB (Least Significant Bit) bezeichnet. Das linke Bit hat die Wertigkeit 27 und wird als MSB (Most Significant
Bit) bezeichnet. Häufig fasst man 8 Bit zu einem Byte zusammen und verwendet dieses anstatt einzelner Bits als Basisgröße (z.B. bei Speicherung oder
Datenübertragung). Größere Wörter (z.B. 32 Bit) werden dann byteweise zerlegt bzw. zusammengesetzt. Beginnt man dabei mit dem höchstwertigen Byte
(D31 , · · · , D24 ) so spricht man von einer Big-endian-Reihung. Beginnt man mit
dem niederwertigsten Byte (D7 , . . . , D0 ), so spricht man von Little Endian.
Zuweisungen zu Registern werden durch den Ersetzungsoperator ← beschrieben. So bedeutet R1 ← 0, dass das Register R1 zurückgesetzt wird, d.h.
alle Bits werden Null. R1 ← R1 + R2 bedeutet, dass der Inhalt von R1 durch
die Summe der in den Registern R1 und R2 gespeicherten Werte ersetzt wird.
Soll ein Registerinhalt nicht mit jedem Taktzyklus verändert werden, so
kann man die Datenübernahme von einem Steuersignal abhängig machen. Dadurch erhalten wir eine bedingte Zuweisung in der Form:
if (S1 = 1) then (R1 ← R1 + R2 )
Schaltungstechnisch wirkt S1 in diesem Fall als Steuervariable, die das Taktsignal modifiziert. Dies wird durch ein AND-Schaltglied wie in Abb. 4.2 realisiert.
R1 +R 2
Takt
S1
&
R1
Abbildung 4.2: Bedingte Zuweisung durch Taktausblendung mit einem ANDSchaltglied.
Die o.g. if-Anweisung kann auch durch folgende verkürzte Schreibweise dargestellt werden:
S1 : R1 ← R1 + R2
Sollen zwei oder mehr Registertransfers gleichzeitig stattfinden, so werden
die Anweisungen in eine Zeile geschrieben und durch Kommata voneinander
getrennt. Man beachte, dass die Reihenfolge der Anweisungen innerhalb einer
Zeile keine Bedeutung hat, da alle gleichzeitig ausgeführt werden.
Zur Speicherung von Daten können neben einzelnen Registern auch Speicher
eingesetzt werden. Diese werden durch den Großbuchstaben M charakterisiert
118
Kapitel 4. Komplexe Schaltwerke
und durch ein Adressregister angesprochen, das als Index in eckigen Klammern
angegeben wird.
Beispiel 4.2 Befehlsholephase eines Prozessors
Wir werden später noch genauer untersuchen wie ein Prozessor Befehle
verarbeitet. Ein wichtiger Teilschritt bei der Befehlsverarbeitung ist die Befehlsholephase, bei der ein Maschinenbefehl aus dem Hauptspeicher ins Leitwerk
übertragen wird. Durch die Operation
IR ← M [P C], P C ← P C + 1
wird der durch den Befehlszähler (Programm Counter, PC) adressierte Befehl
aus dem Speicher in das Befehlsregister (Instruction Register, IR) geladen.
Gleichzeitig wird der Befehlszähler inkrementiert. Man beachte, dass am Ende eines Kippintervalls der noch unveränderte Befehlszähler zum Adressieren
des Speichers benutzt wird und dass der geholte Befehl sowie der neue Befehlszählerstand erst mit dem Wirkintervall des nachfolgenden Takts übernommen
werden. Das Inkrementieren des Befehlszählers kann auch durch die Schreibweise P C++ abgekürzt werden.
Die Register oder Speicherplätze auf der rechten Seite des Ersetzungssymbols ← können durch Operationen miteinander verknüpft werden, die durch
Boole’sche Schaltfunktionen beschrieben werden. Wir unterscheiden im Folgenden drei Kategorien und geben Beispiele für solche Mikrooperationen an.
1. Logische Mikrooperationen, bitweise ausgeführt
•
•
•
•
NOT
AND
OR
EXOR
¯
∧
∨
⊕
2. Arithmetische Mikrooperationen
• Addition +
• Um 1 inkrementieren ++
• Subtraktion –
(kann auf die Addition des Zweierkomplements zurückgeführt werden)
• Um 1 dekrementieren – –
• Einerkomplement ¬
(ist identisch mit der Negation)
3. Verschiebung und Konkatenation
• Schiebe um n Bit nach links n bzw. nach rechts n
• Rotiere um n Bit nach links ←- n bzw. nach rechts ,→ n
4.4. ASM-Diagramme
• Verbinde zwei Vektoren zu einem größeren Vektor k
Mikrooperationen können durch Schaltnetze (z.B. Addition) oder einfach
nur durch die An- bzw. Umordnung der Datenleitungen (z.B. Konkatenation,
Schiebemultiplexer) implementiert werden. Durch Verkettung dieser elementaren Mikrooperationen in einem Hardware-Algorithmus können mit einem Operationswerk komplexere Makrooperationen gebildet werden. So kann beispielsweise ein einfaches Operationswerk mit einer 8 Bit breiten ALU (Arithmetic Lo- ALU
gic Unit), die nur ganze Zahlen addieren bzw. subtrahieren kann, auch 32- oder
64-Bit-Gleitkommaoperationen ausführen. Man benötigt dazu einen HardwareAlgorithmus, der die Gleitkommaoperationen so zerlegt, dass sie durch eine
entsprechende Zahl von 8-Bit-Operationen umgesetzt werden können. Die Anzahl und Abfolge dieser Mikrooperationen ist von den Daten abhängig und
wird durch die Zwischenergebnisse (Statusbits) gesteuert. Die Anzahl der Mikrooperationen kann verringert werden, indem man die Wortbreite oder die
Komplexität der verfügbaren Funktionsschaltnetze erhöht.
Nachdem wir nun die grundlegenden Mikrooperationen kennengelernt haben, werden wir im nächsten Abschnitt sehen, wie diese in einen HardwareAlgorithmus integriert werden.
4.4
ASM-Diagramme
Als Hilfsmittel zur Beschreibung von Hardware-Algorithmen für ein komplexes
Schaltwerk verwendet man das so genannte Algorithmic State Machine Chart
oder ASM-Diagramm. Ein ASM-Diagramm ähnelt einem Flussdiagramm, enthält aber zusätzliche Informationen über die zeitlichen Abläufe der benutzten
Mikrooperationen. Es kann drei Arten von Boxen enthalten:
1. Zustandsboxen,
2. Entscheidungsboxen und
3. bedingte Ausgangsboxen.
Bei Moore-Schaltwerken gibt es keine bedingten Ausgangsboxen, da sie zustandsorientiert arbeiten. Dafür enthalten Moore-Schaltwerke in der Regel aber
mehr Zustandsboxen als Mealy-Schaltwerke. Aus den o.g. Elementen werden
wiederum ASM-Blöcke gebildet, die jeweils einen Zustand und dessen komplette Verzweigungsstruktur beinhalten.
4.4.1
Zustandsboxen
Die Zustandsbox wird durch einen symbolischen Zustandsnamen und einen Zustandscode bezeichnet (Abb. 4.3). Innerhalb einer Zustandsbox können einem
119
120
Kapitel 4. Komplexe Schaltwerke
oder mehreren Registern Werte zugewiesen werden. Die Zuweisungen werden
in der oben eingeführten RTL-Notation angegeben. In Zustandsboxen wird die
Aktion festgelegt, die beim Erreichen dieses Zustands im Operationswerk ausgeführt werden soll.
Zustandsname
Zustandscodierung
Z1
Zuweisungen
001
A
0
Abbildung 4.3: Zustandsbox, links: allgemeine Form, rechts: Beispiel.
In jedem ASM-Diagramm gibt es einen Anfangszustand Z0 , der nach dem
Einschalten der Betriebsspannung eingenommen wird. Die dazu erforderlichen
Datenpfade werden durch entsprechende Belegungen der Steuervariablen bestimmt, die wiederum durch den Anfangszustand des Steuerwerks festgelegt
sind.
4.4.2
Entscheidungsboxen
Entscheidungsboxen testen Registerinhalte oder Eingänge auf besondere Bedingungen (Abb. 4.4). Hierzu werden Status-Informationen durch einen Vergleicher (Komparator) abgefragt oder die Belegung von Eingängen mit bestimmten
Werten wird getestet. Die abgefragten Bedingungen steuern den Kontrollfluss
und legen damit die Ausgangspfade aus einem ASM-Block fest. Durch Entscheidungsboxen werden die Folgezustände festgelegt, die das Steuerwerk als
nächstes einnehmen soll. Eine Entscheidungsbox hat nur zwei Ausgänge, da
die abgefragte Bedingung nur wahr (1) oder falsch (0) sein kann.
1
Bedingung
0
1
A=0
0
Abbildung 4.4: Entscheidungsbox, links: allgemeine Form, rechts: Beispiel.
4.4.3
Bedingte Ausgangsboxen
Diese Komponente gibt es nur bei ASM-Diagrammen für Mealy-Schaltwerke.
Wie bei einer Zustandsbox können in der bedingten Ausgangsbox Variablen
4.4. ASM-Diagramme
121
oder Ausgängen Werte zugewiesen werden1 . Es werden jedoch nur diejenigen Ausgangsboxen ausgeführt, die auf dem genommenen Pfad liegen. Die
Zuweisungen der aktivierten bedingten Ausgangsboxen werden zeitgleich zu
den Zuweisungen in der vorgelagerten Zustandsbox ausgeführt. Zur Unterscheidung von einer Zustandsbox hat die bedingte Ausgangsbox abgerundete Ecken
(Abb. 4.5). Außerdem wird weder ein Zustandsname noch ein Zustandscode
zugeordnet.
Bedingte Zuweisung
K++
Abbildung 4.5: Bedingte Ausgangsbox, links: allgemeine Form, rechts: Beispiel.
Selbsttestaufgabe 4.1 (Erforderliches Steuerwerk)
Begründen Sie, dass bei Vorliegen einer bedingten Ausgangsbox in einem ASMDiagramm das Steuerwerk des betreffenden komplexen Schaltwerks als MealyAutomat ausgeführt werden muss.
Lösung auf Seite 137
4.4.4
ASM-Block
Ein ASM-Block enthält genau eine Zustandsbox, die als Eingang in den Block
dient. Ein Netzwerk aus hinter- bzw. nebeneinandergeschalteten Entscheidungsboxen, das im Falle von Mealy-Schaltwerken auch bedingte Ausgangsboxen enthalten kann, führt zu anderen Zuständen im ASM-Diagramm. Die ASM-Blöcke
können dadurch gekennzeichnet werden, dass man sie durch gestrichelte Linien
einrahmt oder grau hinterlegt. Das Netzwerk der ASM-Blöcke bildet schließlich
das ASM-Diagramm.
Beim Arbeiten mit ASM-Diagrammen müssen folgende Regeln beachtet
werden:
1. Die Entscheidungsboxen müssen so miteinander verbunden sein, dass jeder durch das Netzwerk der Entscheidungsboxen genommene Pfad (abhängig von der jeweiligen Variablenbelegung) zu genau einem Zustand
führt.
2. Variablen in der Zustandsbox oder in bedingten Ausführungsboxen dürfen
innerhalb eines ASM-Blocks nur einmal auf der linken Seite stehen, d.h.
sie dürfen nur einmal pro Taktzyklus beschrieben werden.
1
Man könnte sie daher auch als bedingte Zustandsboxen bezeichnen.
122
Kapitel 4. Komplexe Schaltwerke
3. Die Wertzuweisungen an die Variablen erfolgen erst am Ende eines Taktzyklus, d.h. innerhalb des Zustandes werden auf der rechten Seite von
Zuweisungen und in Entscheidungsboxen die Werte benutzt, die die Variablen am Anfang des Zustands haben. Die im Zustand neu zugewiesenen
Werte sind also erst kurz nach Ende des Taktzyklus (am Anfang des Folgezustands) gültig.
Selbsttestaufgabe 4.2 (ASM-Diagramm) Entscheiden Sie, ob der nachfolgende ASM-Block die in 1 angegebene Regel erfüllt.
Z1
D
E
A>B
1
X
A
0
1
B<0
0
C
1
Z2
Z3
Lösung auf Seite 137
Im Gegensatz zu einem normalen Flussdiagramm ordnet das ASM-Diagramm den einzelnen Anweisungen und Verzweigungen Zustände zu und definiert so, welche Speicher, Funktionsschaltnetze und Datenwegschaltungen im
Operationswerk benötigt werden. Da gleichzeitig auch der Kontrollfluss visualisiert wird, eignet sich das ASM-Diagramm zur vollständigen Spezifikation eines
komplexen Schaltwerks. Anhand der Darstellung mit einem ASM-Diagramm
können sowohl das Operations- als auch das Steuerwerk synthetisiert werden.
Bevor wir den Entwurf mit ASM-Diagrammen an einem Beispiel demonstrieren, wollen wir einige allgemeine Konstruktionsregeln für Operations- und
Steuerwerke vorstellen.
4.5
Konstruktionsregeln für Operationswerke
Da eine gegebene Aufgabenstellung durch viele verschiedene Algorithmen lösbar ist, gibt es für den Entwurf eines komplexen Schaltwerks keine eindeutige
Lösung. Die Kunst des Entwurfs besteht darin, einen guten Kompromiss zwischen Hardwareaufwand und Zeitbedarf zu finden.
4.5. Konstruktionsregeln für Operationswerke
123
Ist die Architektur des Operationswerks vorgegeben, so muss der Steueralgorithmus daran angepasst werden. Dies ist z.B. bei einem Rechenwerk eines
Computers der Fall. Das Rechenwerk ist ein universelles Operationswerk, das
zur Lösung beliebiger (berechenbarer) Problemstellungen benutzt werden kann.
Wenn dagegen die Architektur des Operationswerks frei gewählt werden
darf, hat der Entwickler den größten Spielraum — aber auch den größten Entwurfsaufwand. Für diesen Fall sucht man ein an die jeweilige Problemstellung
angepasstes Operationswerk. Wir werden im Folgenden Konstruktionsregeln
für den Entwurf solcher anwendungsspezifischer Operationswerke angeben.
Ausgangspunkt ist stets ein Algorithmus, der angibt, wie der Eingabevektor zum Ausgabevektor verarbeitet werden soll. Wie wir oben gesehen haben,
kann zur Beschreibung von Hardware-Algorithmen ein ASM-Diagramm benutzt
werden. Es enthält Anweisungen mit Variablen, Konstanten, Operatoren, Zuweisungen und bedingte Verzweigungen. Hiermit kann dann die Architektur
des Operationswerks wie folgt abgeleitet werden:
1. Für jede Variable, die auf der linken Seite einer Zuweisung steht, ist ein
Register erforderlich.
2. Wenn einer Variablen mehr als ein Ausdruck zugewiesen wird, muss vor
die Eingänge des Registers ein Multiplexer (Auswahlnetz) geschaltet werden. Um die Zahl der Verbindungsleitungen (Chipfläche) zu reduzieren,
können die Register auch in einem Registerblock zusammengefasst wer- Registerblock
den. Der Zugriff erfolgt in diesem Fall zeitversetzt über einen Bus. Soll auf
zwei oder mehrere Register gleichzeitig zugegriffen werden, so muss der
Registerblock über eine entsprechende Anzahl von Busschnittstellen verfügen, die auch als Ports bezeichnet werden. Man unterscheidet Schreib- Ports
und Leseports. Ein bestimmtes Register kann zu einem bestimmtem Zeitpunkt natürlich nur von einem Schreibport beschrieben werden. Es kann
aber gleichzeitig an zwei oder mehreren Leseports ausgelesen werden.
3. Konstanten können fest verdrahtet sein oder sie werden durch einen Teil
des Steuervektors definiert.
4. Die Berechnung der Ausdrücke auf den rechten Seiten von Wertzuweisungen erfolgt mit Funktionsschaltnetzen, welche die erforderlichen Mikrooperationen mit Hilfe Boole’scher Funktionen realisieren.
5. Wertzuweisungen an unterschiedliche Variablen können parallel (gleichzeitig) ausgeführt werden, wenn sie im Hardware-Algorithmus unmittelbar aufeinander folgen und wenn keine Datenabhängigkeiten zwischen Datenabhängigkeiten
den Anweisungen bestehen. Eine (echte) Datenabhängigkeit liegt dann
vor, wenn die vorangehende Anweisung ein Register verändert, das in der
nachfolgenden Anweisung als Operand benötigt wird.
124
Kapitel 4. Komplexe Schaltwerke
6. Zur Abfrage der Bedingungen für Verzweigungen müssen entsprechende
Statusvariablen gebildet werden.
Die gleichzeitige Ausführung mehrerer Anweisungen verringert die Zahl der
Taktzyklen und verkürzt damit die Verarbeitungszeit. Andererseits erhöht dies
aber den Hardwareaufwand, wenn in den gleichzeitig abzuarbeitenden Wertzuweisungen dieselben Mikrooperationen auftreten. Die Funktionsschaltnetze für
die parallel ausgeführten Operationen müssen dann mehrfach vorhanden sein.
In Abschnitt 4.7 wird die Anwendung der oben angegebenen Konstruktionsregeln demonstriert.
Selbsttestaufgabe 4.3 (Einfaches Operationswerk)
Skizzieren Sie ein Operationswerk mit zwei Registern R1 und R2 . Durch eine
Steuervariable S soll es möglich sein, eine der beiden folgenden Mikrooperationen auszuwählen.
S = 0 Tausche die Registerinhalte von R1 und R2 .
S = 1 Addiere die Registerinhalte von R1 und R2 und schreibe die Summe in
das Register R1 . Das Register R2 soll dabei unverändert bleiben.
Lösung auf Seite 137
4.6
Entwurf des Steuerwerks
Die Struktur eines Steuerwerks ist unabhängig von einem bestimmten Steueralgorithmus. Für den systematischen Entwurf haben wir drei Möglichkeiten
kennengelernt:
1. Entwurf mit Hilfe von Zustandsgraph/-tabelle, Zustandsminimierung und
binärer Zustandscodierung,
2. wie 1., allerdings mit einem Flipflop pro Zustand (Hot-one-coding),
3. Entwurf als Mikroprogrammsteuerwerk.
Die beiden erstgenannten Methoden sind nur dann anwendbar, wenn die
Zahl der Zustände nicht zu groß ist (z.B. bis 32 Zustände). Für umfangreichere
Steueralgorithmen kommt praktisch nur die Methode der Mikroprogrammierung
in Frage.
Ein verzweigungsfreier oder linearer Steueralgorithmus kann besonders leicht
implementiert werden. Wir benötigen nur einen Zähler und einen SteuerwortSpeicher (Control Memory), der die einzelnen Steuerwörter aufnimmt und von
den Zählerausgängen adressiert wird. Sobald der Eingabevektor anliegt, wird
4.6. Entwurf des Steuerwerks
125
Adresse
...
Ladbarer Zähler
der Zähler zurückgesetzt und gestartet. Am Ausgang des Steuerwort-Speichers
werden nun die Steuerwörter nacheinander ausgegeben und vom Operationswerk verarbeitet. Eine Schaltvariable des Steuervektors zeigt das Ende des
Steueralgorithmus an und stoppt den Zähler. Danach kann ein neuer Zyklus
beginnen.
Steuerwort
Load/Count
Verzweigungsadresse
Steuerwortspeicher
...
&
“test” Operationswerk
“zero”
Abbildung 4.6: Prinzip eines mikroprogrammierbaren Steuerwerks, das bedingte Verzweigungen ausführen kann.
Um Verzweigungen innerhalb des Steueralgorithmus zu ermöglichen, wird
ein ladbarer Zähler verwendet (Abb. 4.6). Der Einfachheit halber wollen wir
annehmen, dass nur Verzweigungen auf die Bedingung zero“, d.h. ein be”
stimmtes Register R des Operationswerks hat den Wert 0 angenommen, erlaubt sind. Diese Bedingung ist erfüllt, wenn alle Bits des Registers R den
Wert 0 haben. Eine entsprechende Statusvariable zero“ kann beispielsweise
”
mit einem NOR-Schaltglied erzeugt werden, das alle Bits als Eingabe erhält.
Durch eine Schaltvariable des Steuervektors wird diese Abfrage aktiviert. Falls
das zero“-Bit gesetzt ist, wird der (Mikroprogramm-)Zähler mit einer Verzwei”
gungsadresse aus dem Steuerwort-Speicher geladen. Die Abfrage der Steuervariablen zero“ wird durch eine 1 an der Steuervariablen test“ aktiviert. Die
”
”
AND-Verknüpfung liefert dann bei gesetztem zero“-Flag den Wert 1 und schal”
tet über den Load/Count−Eingang den Zähler vom Zähl- auf Ladebetrieb. Um
Speicherplatz zu sparen, wird ein Teil des Steuerworts als Verzweigungsadresse interpretiert. Das Steuerwort darf deshalb während der Abfrage einer Verzweigungsbedingung nicht im Operationswerk wirksam werden. Mit Hilfe des
Abfragesignals test“ kann z.B. der Takt des Operationswerks für einen Taktzy”
klus ausgeblendet werden. Dadurch wird jeweils ein Wirk- und ein Kippintervall
unterdrückt. Die durch die Verzweigungsadresse geschalteten Datenpfade und
Operationen werden unwirksam, da die D-Flipflops die Ergebnisse nicht übernehmen.
126
Kapitel 4. Komplexe Schaltwerke
Die Synchronisierung des Steuerwerks in Abb. 4.6 erfolgt durch Rücksetzen
des Zählers beim Start und durch ein Stop-Bit im Steuerwort. Beide Einrichtungen wurden der Übersicht halber nicht eingezeichnet.
Im Folgenden wollen wir an einem einfachen Beispiel verschiedene Entwürfe
von komplexen Schaltwerken vorstellen.
4.7
Beispiel: Einsen-Zähler
Ein komplexes Schaltwerk soll die Anzahl der Einsen in einem n Bit langen Wort
X bestimmen. Die Berechnung soll beginnen, sobald ein weiteres Eingangssignal
Start den Wert 1 annimmt. Das Ergebnis wird auf den Ausgangsvektor Y gelegt
und eine 1 auf einem weiteren Ausgangssignal zeigt an, dass das Ergebnis am
Ausgang anliegt.
Das hier vorliegende Problem ist für großes n sehr schwer zu lösen. Wir
könnten mit einem Volladdierer jeweils 3-Bit-Blöcke auswerten und daraus eine
2-Bit-Dualzahl für die Anzahl der Bits in diesem 3-Bit-Block gewinnen. Bei
n = 12 müssten wir dann aber vier Wörter“ zu je 2 Bit in einem übergeordneten
”
Addierschaltnetz aufsummieren.
Zur Lösung dieses Problems bietet sich ein ladbares Schieberegister A zur
Aufnahme des n-Bit-Worts an. Die Anzahl der Einsen wird in einem Zähler K
gespeichert, der zu Anfang zurückgesetzt wird. Der Zähler wird inkrementiert,
wenn das niederwertige (rechte) Bit A0 des Schieberegisters den Wert 1 hat.
Dann wird das Register A um ein Bit nach rechts geschoben, wobei eine 0 von
links nachgeschoben wird. Wenn alle Bits des Schieberegisters A den Wert 0
haben, kann K als Ergebnis an Y ausgegeben werden. Damit wir das Anliegen
eines gültigen Ergebnisses erkennen, wird gleichzeitig der Ausgang F ertig auf
1 gesetzt.
Selbsttestaufgabe 4.4 (12-Bit-Einsen-Zähler) Entwerfen Sie ein Schaltnetz, um
die Zahl der Einsen in einem 6 Bit langen Wort zu bestimmen. Erweitern Sie
die Wortbreite mit zwei derartigen 6-Bit-Modulen auf 12 Bit.
Lösung auf Seite 138
4.7.1
Lösung mit komplexem Moore-Schaltwerk
In Abb. 4.7 ist das ASM-Diagramm für die zustandsorientierte Lösung dargestellt. Solange das Start-Signal den Wert 0 führt, bleibt das Schaltwerk im
Zustand z0 . F ertig = 0 zeigt an, dass an Y noch kein gültiges Ergebnis anliegt. Wenn Start den Wert 1 annimmt, wird in den Zustand z1 verzweigt. Dort
wird der Eingangsvektor X in das Register A eingelesen. Gleichzeitig wird das
Zählregister K zurückgesetzt. Im Zustand z2 wird das niederwertige Bit A0 des
4.7. Beispiel: Einsen-Zähler
127
Z0
Fertig
0
0
Start = 1
1
Z1
A
K
X
0
Z2
0
1
A0 = 1
Z3
K++
Z4
A >> 1
1
0
A=0
Z5
Fertig
1
Y
K
Abbildung 4.7: ASM-Diagramm für ein komplexes Moore-Schaltwerk.
Schieberegisters abgefragt. Je nach Belegung wird K entweder inkrementiert
oder es erfolgt ein direkter Zustandswechsel nach z4 . Dort wird A nach rechts
geschoben und gleichzeitig geprüft, ob A noch Einsen enthält. Diese Statusinformation kann mit einem n-fach OR-Schaltglied erzeugt werden. Falls A noch
mindestens eine 1 enthält, verzweigt das Schaltwerk in den Zustand z2 . Sonst
wird für einen Taktzyklus die Zahl der Einsen auf Y ausgegeben. Dann springt
das Schaltwerk in den Anfangszustand und wartet auf ein neues Startereignis.
Der Zustand z2 erscheint zunächst überflüssig, da in ihm keine Zuweisung
erfolgt. Allerdings ist er notwendig, da im vorausgehenden Zustand (z1 bzw.
z4 ) eine Zuweisung an das Register A erfolgt, und in der Entscheidungsbox, die
zum ASM-Block von Zustand z2 gehört, das Register A abgefragt wird. Gäbe es
nun zwischen Zustand z1 (bzw. z4 ) und der Entscheidungsbox keinen weiteren
Zustand, so hätte die Zuweisung an A noch gar nicht stattgefunden, denn diese
wird gemäß Regel 3 erst am Ende des Takts vorgenommen.
128
Kapitel 4. Komplexe Schaltwerke
Z0
Fertig
0
0
Start = 1
1
Z1
A
K
X
0
Z2
0
1
A0 = 1
K++
1
0
A=0
Z3
A >> 1
Fertig
1
Y
K
Abbildung 4.8: ASM-Diagramm für ein komplexes Mealy-Schaltwerk.
4.7.2
Lösung mit komplexem Mealy-Schaltwerk
In Abb. 4.8 ist die entsprechende übergangsorientierte Lösung dargestellt. Im
Gegensatz zur Moore-Variante werden hier statt sechs nur vier Zustände benötigt. Zwei Zustände können durch die Verwendung bedingter Ausgangsboxen
eingespart werden. Dies bedeutet, dass zur Zustandscodierung nur zwei statt
drei Flipflops benötigt werden. Falls alle Bits des Eingangsvektors X mit dem
Wert 1 belegt sind, erfolgt die Auswertung eines Bits bei der Mealy-Variante in
einem statt in drei Taktschritten. Sie benötigt in diesem Fall auch nur ein Drittel der Zeit. Man beachte, dass die Bedingungen A0 = 1 und A 6= 0 gleichzeitig
ausgewertet werden, da sie dem gleichen ASM-Block zugeordnet sind.
4.7.3
Aufbau des Operationswerks
Bevor wir verschiedene Steuerwerkslösungen betrachten, entwerfen wir das Operationswerk (Abb. 4.9). Das Operationswerk ist für beide Schaltwerks-Varianten identisch. Wir benötigen ein Register A mit einer Wortbreite von n Bit und
4.7. Beispiel: Einsen-Zähler
129
ein Register K mit einer Wortbreite von dlog2 (n + 1)e Bit2 .
Da das Register A in zwei Zuständen (z1 und z4 ) auf der linken Seite steht,
d.h. geschrieben wird, befindet sich vor dem Dateneingang D des Registers ein
Multiplexer. Gleiches gilt für Register K.
Die Register benötigen Select-Eingänge sA und sK , die in dem Takt den
Wert 1 annehmen, wenn das Register tatsächlich beschrieben werden soll, denn
das Taktsignal hat in jedem Takt eine steigende Flanke. Sie entsprechen dem
Enable-Signal aus Kapitel 3. Weiterhin haben die Multiplexer jeweils ein Steuersignal mA und mK .
Schließlich benötigt man noch ein 1-Bit Register F für die Variable Fertig,
samt Steuersignal sF . Auch dieses Register müsste eigentlich einen vorgeschalteten Multiplexer besitzen, da Fertig in zwei Zuständen geschrieben wird. Da
die möglichen Werte hier aber 0 und 1 sind, entsprechen sie gerade dem Wert
des Multiplexer-Steuersignals mF , wodurch man den Multiplexer durch eine
direkte Verbindung von mF mit dem Register-Eingang ersetzen kann.
Weiterhin benötigen wir Schaltnetze zum Rechtsschieben sowie zum Inkrementieren, um die Berechnungen in den Zuständen z3 und z4 zu ermöglichen,
sowie ein Schaltnetz zum Test, ob A ungleich Null ist, was allerdings mit einem
ODER aller Bits von A realisiert werden kann.
Insgesamt empfängt das Operationswerk die Steuersignale sA , sK , sF , mA ,
mK und mF vom Steuerwerk sowie die Eingangsvariable X, und liefert die
Status-Signale A 6= 0 sowie A0 = 1 ans Steuerwerk, sowie die Ausgaben Fertig
und Y .
4.7.4
Moore-Steuerwerk als konventionelles Schaltwerk
Aus dem ASM-Diagramm in Abb. 4.7 sehen wir, dass sechs Zustände benötigt
werden. Zunächst müssen wir entsprechende Zustandscodierungen festlegen.
Wir wollen hierzu die Dualzahlen in aufsteigender Reihenfolge verwenden:
zt
Q2 Q1 Q0
z0
z1
z2
z3
z4
z5
000 001 010 011 100 101
Da die Codes 110 und 111 nicht vorkommen, können wir aus der obigen
Tabelle diejenigen Codierungen, die zu diesen beiden Codes einen HammingAbstand3 von 1 haben, weiter vereinfachen. Dies betrifft die Zustände z2 bis
z5 . Wir erhalten folgende Zustandscodierung, die gegenüber dem ersten Ansatz
durch ein einfacheres Übergangsschaltnetz g implementiert werden kann.
2
Der d e-Operator rundet auf die nächste ganze Zahl auf.
Der Hamming-Abstand gibt an, um wie viele Bit sich zwei Codes voneinander unterscheiden.
3
130
Kapitel 4. Komplexe Schaltwerke
Abbildung 4.9: Aufbau des Operationswerks für den Einsen-Zähler.
zt
Q2 Q1 Q0
z0
z1
z2
z3
z4
z5
000 001 ×10 ×11 1×0 1×1
Das × bedeutet, dass das betreffende Bit i beim Berechnen des Zustands
als Nachfolgezustand (Di ) den Wert 0 erhält, womit man Eindeutigkeit erzielt,
dass man es aber bei der Abfrage des gegenwärtigen Zustands (Qi ) nicht berücksichtigen muss, was die Gleichungen vereinfacht.
Wir gehen davon aus, dass das Steuerwerksregister aus D-Flipflops aufgebaut ist. Die Folgezustände ergeben sich durch die Belegungen an den Eingängen der D-Flipflops:
z t+1 = D2 D1 D0 (z t )
Zusammen mit Abb. 4.7 können wir nun die Schaltfunktionen für das Übergangsschaltnetz des Steuerwerks angeben.
D0 muss den Wert 1 annehmen, wenn die Folgezustände z1 , z3 oder z5 sind.
Der Zustand z1 wird erreicht, wenn sich das Schaltwerk im Zustand z0 befindet
und Start = 1 wird. Der Zustand z3 wird erreicht, wenn sich das Schaltwerk im
Zustand z2 befindet und A0 = 1 wird. Schließlich wird der Zustand z5 erreicht,
4.7. Beispiel: Einsen-Zähler
wenn im Zustand z4
131
A 6= 0 gilt. Daraus erhalten wir folgende Schaltfunktion:
D0 = z0 Start ∨ z2 A0 ∨ z4 (A 6= 0)
= Q2 Q1 Q0 Start ∨ Q1 Q0 A0 ∨ Q2 Q0 (A 6= 0)
Aus der Zustandstabelle der vorigen Seite sehen wir, dass der Zustand z2
durch die Kombination Q0 = 0 und Q1 = 1 eindeutig bestimmt ist und somit
in der Gleichung für D0 nur als Q1 Q0 auftaucht. Die Belegung von Q2 spielt für
die Definition des Zustands z2 keine Rolle. Ähnlich verfährt man im Folgenden
mit den Zuständen z3 bis z5 .
D1 muss für die Folgezustände z2 und z3 den Wert 1 annehmen, da für z4
und z5 das × mit 0 gleichgesetzt wird.
Aus Abb. 4.7 sieht man, dass z2 sich unbedingt aus z1 oder aus z4 und
gleichzeitig A 6= 0 ergibt. Der Zustand z3 wird erreicht, wenn in z2 A0 = 1 ist.
Damit erhalten wir folgende Schaltfunktion:
D1 = z1 ∨ z4 (A 6= 0) ∨ z2 A0
= Q2 Q1 Q0 ∨ Q2 Q0 (A 6= 0) ∨ Q1 Q0 A0
D2 muss nur für die Folgezustände z4 und z5 den Wert 1 annehmen, da
× für die Zustände z2 und z3 auf 0 gesetzt wird. Der Zustand z4 ergibt sich,
wenn in z2 A0 = 0 ist, oder unbedingt aus z3 . Der Zustand z5 wird schließlich
erreicht, wenn in z4 (A 6= 0) = 0 ist. Damit folgt:
D2 = z2 A0 ∨ z3 ∨ z4 (A 6= 0)
= Q1 Q0 A0 ∨ Q1 Q0 ∨ Q2 Q0 (A 6= 0)
Die o.g. Schaltfunktionen des Übergangsschaltnetzes definieren die Abfolge
der Zustände in Abhängigkeit der vom Operationswerk gelieferten Statusbits.
Um die Steuersignale für das Operationswerk zu gewinnen, benötigen wir noch
ein Ausgangsschaltnetz f . Dieses Schaltnetz wird durch folgende Schaltfunktionen bestimmt:
mA
sA
sK
mK
sF
mF
=
=
=
=
=
=
z4 = Q2 Q0
z1 ∨ z4 = Q2 Q1 Q0 ∨ Q2 Q0
z1 ∨ z3 = Q2 Q0
z3 = Q1 Q0
z0 ∨ z5 = Q2 Q1 Q0 ∨ Q2 Q0
z5 = Q2 Q0
Selbsttestaufgabe 4.5 (Nutzung von Schiebe– und Zählregistern) Für das Register A könnte ein Schieberegister genutzt werden, womit man sich das Schaltnetz zum Rechtsschieben und den Multiplexer sparen kann. Das Register K kann
132
Kapitel 4. Komplexe Schaltwerke
als Zählregister mit integriertem Inkrementierer realisiert werden. Argumentieren Sie, warum sich die Anzahl der Steuersignale bei dieser Optimierung des
Schaltwerks nicht ändert.
Lösung auf Seite 138
4.7.5
Moore-Steuerwerk mit Hot-one-Codierung
Die Zuordnung von bestimmten Zustandscodes kann entfallen, wenn man für
jeden Zustand ein einzelnes D-Flipflop vorsieht. Die Schaltfunktionen für die
Eingänge dieser Flipflops können direkt aus dem ASM-Diagramm abgelesen
werden:
D0
D1
D2
D3
D4
D5
=
=
=
=
=
=
Q0 Start ∨ Q5 ∨ Q5 Q4 Q3 Q2 Q1 Q0
Q0 Start
Q1 ∨ Q4 (A 6= 0)
Q2 A0
Q2 A0 ∨ Q3
Q4 (A 6= 0)
Wir gehen normal davon aus, dass alle Flipflops beim Einschalten der Betriebsspannung durch eine entsprechende Power-on-Schaltung auf 0 zurückgesetzt werden. Bei einer binären Zustandscodierung gelangt das Steuerwerk
so in den Zustand 0. Damit das Steuerwerk bei Hot-one-Codierung nach dem
Einschalten sicher in den Zustand 0 gelangt, muss Q0 gesetzt werden. Hierzu
muss in der Schaltfunktion für D0 der Term Q5 Q4 Q3 Q2 Q1 Q0 aufgenommen
werden.
Die Steuersignale für die Multiplexer im Operationswerk können direkt an
den Flipflopausgängen abgenommen werden, zur Bestimmung der RegisterEnable-Signale wird je ein ODER-Schaltglied benötigt.
mK
mA
mF
sK
sA
sF
4.7.6
=
=
=
=
=
=
Q3
Q4
Q5
Q1 ∨ Q3
Q1 ∨ Q4
Q0 ∨ Q5
Mealy-Steuerwerk als konventionelles Schaltwerk
Die Schaltfunktionen für das Mealy-Steuerwerk können wir wie im vorangehenden Abschnitt herleiten. Im ASM-Diagramm nach Abb. 4.8 gibt es nur vier
4.7. Beispiel: Einsen-Zähler
133
Zustände, so dass wir mit einem 2-Bit-Zustandsregister auskommen. Der Zustandsvektor wird wie folgt codiert:
zt
Q1 Q0
z0 z1 z2 z3
00 01 10 11
Wir gehen wieder davon aus, dass das Steuerwerksregister aus D-Flipflops
aufgebaut ist. Die Folgezustände ergeben sich durch die Belegungen an den
Eingängen der D-Flipflops:
z t+1 = D1 D0 (z t )
D0 muss den Wert 1 annehmen, wenn der Folgezustand z1 oder z3 ist. z1
erreicht man aus dem Zustand z0 , wenn Start = 1 ist, z3 aus dem Zustand z2 ,
wenn (A 6= 0) ist4 . Damit erhalten wir:
D0 = z0 Start ∨ z2 (A 6= 0)
= Q1 Q0 Start ∨ Q1 Q0 (A 6= 0)
D1 muss den Wert 1 annehmen, wenn der Folgezustand z2 oder z3 ist. z2
erreicht man aus dem Zustand z1 oder aus dem Zustand z2 , wenn (A 6= 0) ist.
z3 erhalten wir aus dem Zustand z2 , wenn (A 6= 0) gilt. Damit folgt:
D1 = z1 ∨ z2 (A 6= 0) ∨ z2 (A 6= 0)
= z1 ∨ z2
= Q1 Q0 ∨ Q1 Q0
Nachdem die Schaltfunktionen für das Übergangsschaltnetz g vorliegen,
müssen noch die Schaltfunktionen für die Steuersignale des Operationswerks
bestimmt werden (Ausgangsschaltnetz f ):
mA
sA
sK
mK
mF
sF
4
=
=
=
=
=
=
z2 (A 6= 0) = Q1 Q0 (A 6= 0)
z1 ∨ z2 (A 6= 0) = Q1 Q0 ∨ Q1 Q0 (A 6= 0)
z1 ∨ z2 A0 = Q1 Q0 ∨ Q1 Q0 A0
z2 A0 = Q1 Q0 A0
z3 = Q1 Q0
z0 ∨ z3 = Q1 Q0 ∨ Q1 Q0
Wenn man unsicher ist und ausführlich verfahren will, erstellt man zunächst aus dem
ASM-Diagramm den Zustandsgraph des Steuerwerks und leitet die Zustandsfolgetabelle ab.
Aus dieser ergeben sich ebenfalls die Gleichungen.
134
Kapitel 4. Komplexe Schaltwerke
4.7.7
Mealy-Steuerwerk mit Hot-one-Codierung
Durch die Hot-one-Codierung kann der Entwurf erleichtert werden. Die vier
Zustände werden dazu wie folgt codiert:
zt
Q3 Q2 Q1 Q0
z0
z1
z2
z3
0001 0010 0100 1000
Mit Hilfe von Abb. 4.8 erhalten wir folgende Schaltfunktionen für die FlipflopEingänge:
D0
D1
D2
D3
=
=
=
=
Q0 Start ∨ Q3 ∨ Q3 Q2 Q1 Q0
Q0 Start
Q1 ∨ Q2 (A 6= 0)
Q2 (A 6= 0)
Man beachte, dass der letzte Term in der Gleichung für D0 wieder zur Initialisierung nötig ist. Die Schaltfunktionen für das Ausgangsschaltnetz lauten:
mA
sA
sK
mK
mF
sF
=
=
=
=
=
=
Q2 (A 6= 0)
Q1 ∨ Q2 (A 6= 0)
Q1 ∨ Q2 A0
Q2 A0
Q3
Q0 ∨ Q3
Man sieht an den Gleichungen deutlich den Unterschied zwischen Moore–
und Mealy-Steuerwerk: in letzterem wirken die Status-Signale, die Eingangssignale des Steuerwerks bilden, direkt auf die Ausgangssignale des Steuerwerks, d.h. die Steuersignale. Im Moore-Steuerwerk sind die Ausgangssignale
des Steuerwerks nur vom aktuellen Zustand abhängig. Damit ist das MealySteuerwerk tatsächlich ein Mealy-Automat, und das Moore-Steuerwerk tatsächlich ein Moore-Automat.
4.7.8
Mikroprogrammierte Steuerwerke
Im Folgenden werden für die Moore- und Mealy-Variante mikroprogrammierte
Steuerwerke vorgestellt. Um die Kapazität des Mikroprogrammspeichers optimal zu nutzen, sollten die ASM-Blöcke nur höchstens zwei Ausgänge (Folgezustände) haben. Das bedeutet, dass wir auch nur zwischen zwei möglichen Folgezustandsvektoren unterscheiden müssen. Im Mikroprogrammsteuerwerk ist dies
durch einen 2:1-Multiplexer mit der Wortbreite des Zustandsvektors realisiert.
4.7. Beispiel: Einsen-Zähler
Dieser Multiplexer wird durch ein Schaltnetz zur Abfrage der jeweiligen Testbedingung angesteuert. Eine Testbedingung wird über je ein AND-Schaltglied
abgefragt, indem der zweite Eingang über eine Steuerleitung des Mikroprogrammspeichers aktiviert wird. Je nach Ergebnis dieses Tests wird dann aus
einer Spalte des Mikroprogrammspeichers die Folgeadresse für das Zustandsregister ausgewählt. Parallel zur Erzeugung der Folgeadressen werden aus den
Wortleitungen, die direkt den Zuständen zugeordnet sind5 , die Steuersignale
für das Operationswerk abgeleitet.
In Abb. 4.10 ist das Mikroprogrammsteuerwerk für die Moore-Variante dargestellt. Diese Lösung ist sehr ähnlich zu der Hot-one-Codierung aus 4.7.5.
Dies gilt auch beim Mikroprogrammsteuerwerk für die Mealy-Variante, das in
Abb. 4.11 zu sehen ist. Auch dort können die Zustands- und Ausgangsschaltfunktionen direkt aus den Gleichungen aus Abschnitt 4.7.7 entnommen werden.
Abbildung 4.10: Mikroprogrammsteuerwerk der Moore-Variante.
Abbildung 4.11: Mikroprogrammsteuerwerk der Mealy-Variante.
5
Eine Optimierung der Zustandscodierung wie in 4.7.4 ist nicht erforderlich, da der Adressdecoder des Mikroprogrammspeichers alle Minterme der Adressen (Zustände) ermittelt.
135
136
universelles
Operationswerk
Kapitel 4. Komplexe Schaltwerke
Zur Realisierung des Einsen-Zählers“ haben wir ein speziell auf die Pro”
blemstellung abgestimmtes Operationswerk verwendet. Neben solchen anwendungsspezifischen Operationswerken kann man jedoch auch universell verwendbare Operationswerke konstruieren, die für viele verschiedene Problemstellungen eingesetzt werden können. Zur Lösung einer bestimmten Aufgabe mit Hilfe
eines universellen Operationswerks müssen nur genügend“ viele Register und
”
Funktionsschaltnetze für nützliche“ Operationen vorhanden sein. Da im all”
gemeinen nicht alle vorhandenen Komponenten vom Hardware-Algorithmus
ausgenutzt werden, enthält ein universelles Operationswerk gegenüber einem
anwendungsspezifischen Operationswerk stets ein gewisses Maß an Redundanz.
Dafür eignet es sich jedoch sehr gut zur Realisierung von Computern.
Selbsttestaufgabe 4.6 (Modulo-X-Zähler)
Entwerfen Sie ASM-Diagramm und Operationswerk für einen Modulo-XZähler. Der Wert soll über den Eingabevektor X vorgegeben werden, der im
ersten Takt eingelesen wird, und beträgt maximal 1023 sowie minimal 2. Der
Zähler soll beim Wert 0 starten. Die Zählerstände sollen in einem Register A
gespeichert werden, das direkt mit dem Ausgabevektor Y verbunden ist. Zur
Bestimmung des Statusvektors steht ein Vergleicher mit den Eingängen A und
B zur Verfügung, der an seinem Ausgang A < B eine 1 ausgibt, sobald der
Wert an A kleiner als B ist. Außerdem seien ein Addierschaltnetz und ein
Subtrahierschaltnetz der benötigten Wortbreite vorhanden.
1. Wie groß ist die benötigte Wortbreite?
2. Skizzieren Sie das ASM-Diagramm!
3. Skizzieren Sie das Operationswerk!
4. In welchem Zustand nimmt Register A seinen maximalen Wert an?
Lösung auf Seite 138
4.8
Zusammenfassung
Nach dem Durcharbeiten dieses Kapitels sollten Sie
• den Aufbau und die Funktionsweise komplexer Schaltwerke verstanden
haben,
• Hardware-Algorithmen für komplexe Problemstellungen formulieren und
daraus komplexe Schaltwerke ableiten können.
4.9. Lösungen der Selbsttestaufgaben
4.9
137
Lösungen der Selbsttestaufgaben
Selbsttestaufgabe 4.1 von Seite 121
Die bedingte Ausgangsbox wird nur aktiviert, wenn sie auf einem Pfad durch
vorgelagerte Entscheidungsboxen erreicht wird. D.h. das Schreibsignal (Teil des
Steuervektors) des Registers der Variablen, die auf der linken Seite der Zuweisung in der bedingten Ausgangsbox steht, wird nur bei bestimmten Werten des
Statusvektors (der die Ergebnisse der Entscheidungsboxen enthält) aktiviert.
Der Steuervektor ist die Ausgabe des Automaten im Steuerwerk, der Statusvektor stellt die Eingabe dar. Damit ist in dem Automaten des Steuerwerks die
Ausgabe abhängig von der Eingabe. Dies erfordert einen Mealy-Automaten, da
bei einem Moore-Automaten die Ausgabe nur vom Zustand, nicht aber von der
Eingabe abhängig ist.
Selbsttestaufgabe 4.2 von Seite 122
Für jeden Wert von A wird z2 als Folgezustand gewählt. Solange B > 0 ist,
besteht kein Konflikt. Sobald aber B ≤ 0 wird, werden gleichzeitig z2 und z3 als
Folgezustände ausgewählt. Damit wird gegen die angegebene Regel verstoßen.
Selbsttestaufgabe 4.3 von Seite 124
Der Aufbau des Operationswerks ist in Abb. 4.12 dargestellt. Da das Register
R2 bei S = 1 nicht verändert werden darf, muss der Takt durch ein AND–
Schaltglied maskiert“ werden. Der Takt wird nur für S = 0 an R2 weiterge”
leitet. In diesem Fall übernimmt das Register R2 den Inhalt von Register R1 .
Gleichzeitig wird über den Multiplexer vor R1 das Register R2 zum Einspeichern in R1 ausgewählt. Für S = 1 wird die Summe von R1 und R2 ausgewählt
und von R1 übernommen.
+
0
1
Takt
S
R1
R2
&
Abbildung 4.12: Aufbau des Operationswerks
138
Lösungen der Selbsttestaufgaben
Selbsttestaufgabe 4.4 von Seite 126
In Abb. 4.13 ist der Aufbau der Schaltnetzlösung für 6 Bit dargestellt. Wenn wir
mit zwei dieser Modulen einen 12-Bit-Vektor auswerten, erhalten wir an den
Modul-Ausgängen zwei 3-Bit-Wörter. Diese müssen mit einem 4-Bit-Addierschaltnetz aufsummiert werden, damit das größtmögliche Ergebnis 12 (=0Chex )
dargestellt werden kann.
Bit 0
Bit 1
b0
b1
Bit 4
Bit 5
Y
C0
VA S
C1
S1
Ci
Bit 2
Bit 3
X
b2
b3
X
C0
Summe 2
Y
VA S
Summe 1
Ci
X
C0
Y
VA S
C0
S0
X
C0
Y
VA S
C0
Summe 0
Ci
Abbildung 4.13: Aufbau eines Schaltnetzes zum Zählen von Einsen in einem
6-Bit-Wort.
Selbsttestaufgabe 4.5 von Seite 131
Nutzt man ein ladbares Schieberegister, so entfällt zwar der Multiplexer, trotzdem muss aber zwischen den Fällen: Laden, Schieben, nichts tun unterschieden
werden, wozu (mindestens) zwei Steuersignale notwendig sind, da mit einem
Steuersignal nur 2 Fälle unterschieden werden können. Ähnlich verhält es sich
mit dem Zählregister. Auch hier sind die drei Fälle: Laden, Zählen, nichts tun
zu unterscheiden.
Selbsttestaufgabe 4.6 von Seite 136
1. Die benötigte Wortbreite beträgt 10 Bit, da 29 ≤ 1023 < 210 .
2. Siehe linke Seite von Abb. 4.14.
3. Siehe rechte Seite von Abb. 4.14. Über die Steuerleitung MA kann die
Zuweisungsquelle an A gewählt werden. Mit SB = 1 kann man B nur
im Zustand Z0 den um Eins verringerten Wert des Eingabevektors X
zuweisen. In den anderen Zustängen ist SB = 0.
Lösungen der Selbsttestaufgaben
Abbildung 4.14: ASM-Diagramm und Operationswerk zum Modulo-X-Zähler.
4. Damit A z.B. Werte von 0 bis 1022 annimmt (X = 1023, also B = 1022),
muss die Abfrage A < B lauten. Beim ersten Erreichen des Zustands Z2
hat A den Wert 1. Hat A beim wiederholten Erreichen von Z2 den Wert
1022 (Maximalwert), dann schlägt der Vergleich erstmalig fehl und es wird
in den Rücksetzzustand Z0 verzweigt. Beim Eintritt in den Rücksetzzustand gilt noch A = 1022. Dort wird am Ende des Taktzyklus wieder auf
0 zurückgesetzt.
139
140
Lösungen der Selbsttestaufgaben
Kapitel 5
Aufbau und Funktionsweise eines
Computers
Kapitelinhalt
5.1
Erweiterung komplexer Schaltwerke . . . . . . . . . . . . . 142
5.2
Komponenten eines Computers . . . . . . . . . . . . . . . . 143
5.3
Interne und externe Busse . . . . . . . . . . . . . . . . . . . 150
5.4
Prozessorregister . . . . . . . . . . . . . . . . . . . . . . . . 152
5.5
Anwendungen eines Stapelzeigers . . . . . . . . . . . . . . . 154
5.6
Rechenwerk . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
5.7
Leitwerk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
5.8
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . 174
5.9
Lösungen der Selbsttestaufgaben . . . . . . . . . . . . . . . 175
141
142
Kapitel 5. Aufbau und Funktionsweise eines Computers
Das folgende Kapitel beschreibt die grundlegenden Komponenten eines Computers und erläutert ihr Zusammenspiel bei der Abarbeitung von Maschinenprogrammen. Zunächst wird in das Operationsprinzip des von Neumann-Computers
eingeführt. Dieses ergibt sich aus einer Verallgemeinerung der komplexen Schaltwerke, die wir im letzten Kapitel kennengelernt haben. Das Operationsprinzip
des von Neumann-Computers basiert auf der Einführung von Maschinenbefehlen, die in einem Speicher abgelegt sind und die nacheinander von einem Prozessor ausgeführt werden. Der Prozessor besteht aus einem Rechen- und Leitwerk,
die das komplexe Schaltwerk bilden. Zur Steuerung des Befehlsablaufs dient ein
Programmzähler-Register. Weitere Prozessor-interne Speicher sind die Daten, Adress- und das Statusregister, die für den Zugriff auf die Operanden bzw.
zur Steuerung des Programmflusses benötigt werden. Das Rechenwerk enthält
neben den Datenregistern Schaltnetze für logische und arithmetische Operationen. Bei der Betrachtung des Leitwerkes beschränken wir uns in diesem Kapitel
auf Mikroprogramm-Steuerwerke, die Befehle in mehreren Taktzyklen umsetzen. Im Kurs Computersysteme 2 werden wir noch andere Möglichkeiten zur
Steuerung des Rechenwerks kennenlernen. Zum Schluss dieses Kapitels gehen
wir dann noch kurz auf Realisierungsformen von Speichern ein. Die Speicherorganisation heutiger Computer wird am Ende des Kurses Computersysteme 2
ausführlich behandelt.
5.1
Erweiterung komplexer Schaltwerke
In Kapitel 4 haben wir gesehen, dass beim komplexen Schaltwerk (nach der
Eingabe der Operanden) immer nur ein einziger Steueralgorithmus aktiviert
wird. Ein Computer entsteht aus der Erweiterung eines komplexen Schaltwerks
durch mehrere Steueralgorithmen für sogenannte Befehle (instructions) und
einen Registerblock, um die Operanden dafür vorzuhalten.
Opcode
Speicher
Angenommen, wir hätten Steueralgorithmen für die vier Grundrechenarten auf einem universellen Operationswerk entwickelt, das lediglich über einen
Dual-Addierer verfügt. Durch eine Verkettung der einzelnen Steueralgorithmen
könnten wir nun einen übergeordneten Algorithmus realisieren, der die Grundrechenarten als Operatoren benötigt. Die über Steueralgorithmen realisierten
Operationen können durch Operationscodes (kurz Opcode), z.B. die dualen
Darstellungen der Zahlen 0 bis 3, ausgewählt werden und stellen – zusammen
mit Adressinformationen für die Auswahl der Operanden – dem Programmierer
Maschinenbefehle bereit, die er in einem Programm benutzen kann.
Die zentrale Idee eines Computers besteht nun darin, die Befehle in einem
Speicher abzulegen und sie vor der Ausführung durch das Steuerwerk selbst
holen zu lassen. Es benötigt ein Befehlsregister für die Befehle (Opcodes plus
Operandenadressen) und einen Befehlszähler für die Adressierung dieser Befehle im Speicher. Man bezeichnet ein solches Steuerwerk als Leitwerk. Ein
universelles Operationswerk, das neben einer ALU auch einen Registerblock
5.2. Komponenten eines Computers
enthält, nennt man Rechenwerk.
Leitwerk und Rechenwerk bilden den Prozessor oder die CPU (Central Pro- Prozessor
cessing Unit). Damit der Prozessor nicht nur interne Berechnungen ausführen
kann, können im Speicher auch Daten abgelegt werden. Diese werden dann über
sogenannte Lade- und Speicher-Befehle (load, store instructions) in bzw. aus
dem Registerblock übertragen. Damit auch von außen (Benutzer-)Daten einbzw. ausgegeben werden können, benötigt ein Computer eine Schnittstelle zur
Umgebung, die als Ein-/Ausgabe bezeichnet wird.
Ein-/Ausgabe
5.2
Komponenten eines Computers
Wir unterscheiden also insgesamt vier Funktionseinheiten: Rechenwerk, Leitwerk, Speicher und Ein-/Ausgabe. Das Blockschaltbild in Abb. 5.1 zeigt, wie die
einzelnen Komponenten miteinander verbunden sind. Die Verbindungen wurden entsprechend ihrer Nutzung gekennzeichnet. Hierbei steht D für Daten, B
für Befehle, A für Adressen und S für Steuersignale. Die Zahl der Datenleitungen bestimmt die Maschinenwortbreite eines Prozessors, die von der jeweiligen
Anwendung abhängt. Während Desktop-Prozessoren heute meist 64 Bit Wortbreite haben, findet man bei eingebetteten Systemen oft nur Prozessoren mit
8 oder 16 Bit Wortbreite.
Der Zeitpunkt der Erfindung des ersten Computers wird weltweit diskutiert
und es ist äußerst schwierig, die Urheberschaft einer einzigen Person zuzuordnen. Ohne Zweifel sind in diesem Zusammenhang John V. Atanasoff (mit Clifford Berry), Charles Babbage, John von Neumann, Alan Turing und Konrad
Zuse (in alphabetischer Reihenfolge) zu nennen.
Im Folgenden werden wir zunächst die o.g. Komponenten und deren grundlegende Funktionsweise beschreiben. Die Darstellung entspricht im Wesentlichen dem Modell, das John von Neumann vorgeschlagen hat. Im Anschluss
an die Beschreibung der Grundlagen werden dann Modifikationen vorgestellt,
die sowohl die Implementierung als auch die Programmierung eines Computers
vereinfachen. Danach wird ausführlicher auf den Aufbau von Rechen-, Leitwerk
und Speicher eingegangen.
5.2.1
Rechenwerk
Ein Rechenwerk stellt ein universelles Operationswerk dar, das elementare arithmetische und logische Operationen beherrscht und über mehrere Register verfügt. Diese Register werden durch Adressen ausgewählt und nehmen die Operanden (Variablen oder Konstanten) auf, die miteinander verknüpft werden
sollen. Die ALU kann jeweils zwei Registerinhalte arithmetisch oder logisch
143
144
Kapitel 5. Aufbau und Funktionsweise eines Computers
Leitwerk
A
Befehlszähler (PC)
B
Befehlsregister (IR)
Opcode
Adressfeld
A
Ablaufsteuerung
Holen
S
Ausführen
S
D
ALU
Status
D
Registerblock
Rechenwerk
S
Shifter
Speicher
D/B
Befehl
Befehl
Datum
Datum
Befehl
Datum
Befehl
Befehl
A
D
S
Ein-/Ausgabe
D
A
Register
S
Peripheriegeräte
Abbildung 5.1: Blockschaltbild eines Computers.
Status-Flags
miteinander verknüpfen. Die Art der Verknüpfung wird durch ein Steuerwort
bestimmt und das Ergebnis wird wieder in ein Register des Registerblocks zurückgeschrieben. Meist ist auch eine Schiebeeinrichtung (Shifter) vorhanden,
mit der die Datenbits um eine oder mehrere Stellen nach links oder rechts verschoben werden können. Der Shifter ist besonders nützlich, wenn zwei binäre
Zahlen multipliziert oder dividiert werden sollen und die ALU nur addieren
kann. Das Statusregister dient zur Erfassung besonderer Ergebnisse, die das
Leitwerk auswertet, um bedingte Verzweigungen in Steueralgorithmen für Be-
5.2. Komponenten eines Computers
145
fehle auszuführen. Die einzelnen Bits des Statusregisters bezeichnet man als
Flags. Das Statusregister kann meist wie ein normales (Daten-)Register gelesen
und beschrieben werden.
5.2.2
Leitwerk
Das Leitwerk stellt ein umschaltbares Steuerwerk dar, das – gesteuert durch
den Operationscode (Opcode) der Befehle – die zugehörigen Steueralgorithmen
auswählt. Es steuert den Programmablauf, indem es Befehle aus dem Speicher
holt, im Befehlsregister IR (Instruction Register) speichert und die einzelnen Befehlsregister
Operationscodes in eine Folge von Steuerwörtern (Steueralgorithmus) umsetzt.
Es arbeitet zyklisch, d.h. die Holephase (fetch) und die Ausführungsphase (execute) wiederholen sich ständig (Abb. 5.2). Der Befehlszähler PC (Program Befehlszähler
Counter) wird benötigt, um im Speicher die Befehle und – bei dem hier behandelten Grundprinzip – auch deren Operanden zu adressieren. Während der
Holephase zeigt sein Inhalt auf den Maschinenbefehl, der vom Speicher in das
Befehlsregister geladen und anschließend ausgeführt wird. Nachdem ein neuer
Maschinenbefehl geholt wurde, wird der Befehlszähler erhöht.
Reset
Initialisiere Prozessor(-register):
z. B. Programmzähler
PC
XXXX
Wiederhole, solange Betriebsspannung vorhanden
Hole Operationscode:
IR
M[PC++]
HolePhase
Wiederhole bis Operanden vollständig
BefehlsZyklus
Operand bzw. Operandenadresse
M[PC++]
Operation gemäß Opcode
Verknüpfung
AusführungsPhase
Transfer
Rechenwerksregister
ändern
Register
externer
Speicher
Verzweigung
PC ändern
Abbildung 5.2: Befehlsabarbeitung durch das Leitwerk. Das Nachladen von
Operanden nach dem Holen des Befehls ist nur bei Mehr-Wort-Befehlen notwendig, s. Seite 149, und kann beim ersten Durchlesen ignoriert werden.
Wie man in Abb. 5.2 sieht, wird ein Befehl in zwei Teilschritten abgearbeitet. Die Holephase ist für alle Befehle gleich. Die Ausführungsphase kann eine
variable oder feste Anzahl von Taktschritten umfassen. Wir werden im Kurs
Computersysteme 2 Beispiele für verschiedene Implementierungsvarianten von
146
Kapitel 5. Aufbau und Funktionsweise eines Computers
Prozessoren kennenlernen. Der Abb. 5.2 entnimmt man, dass ein Prozessor im
Wesentlichen drei Befehlsarten unterstützt: Verknüpfungs-, Datentransfer- und
Verzweigungsbefehle. Im Folgenden geben wir jeweils die notwendigen Verarbeitungsschritte für die Maschinenbefehle aus diesen Klassen an. Es wird davon
ausgegangen, dass der Befehl bereits geholt wurde und während der Ausführungsphase im Befehlsregister gespeichert bleibt. Danach wird unter der P CAdresse der nächste Befehl geholt, und dieser Zyklus wiederholt sich, solange
der Prozessor mit Betriebsspannung versorgt wird1 .
1. Verknüpfung von Operanden
• Auslesen der beiden Operanden aus dem Registerblock,
• Verknüpfung in der ALU,
• Schreiben des Ergebnisses in den Registerblock.
Die Registeradressen sind Bestandteil des Maschinenbefehls und werden neben
dem Opcode in einem Adressfeld angegeben.
2. Datentransfer zwischen Speicher und Prozessor
Hier muss zwischen Lese- und Schreibzugriffen unterschieden werden:
a) Lesen (load)
• Bestimmung der Speicheradresse des Quelloperanden,
• Lesezugriff auf den Speicher (Speicheradresse ausgeben),
• Speichern des gelesenen Datums in das Zielregister.
b) Schreiben (store)
• Bestimmung der Speicheradresse des Zieloperanden,
• gleichzeitig kann der Inhalt des Quellregisters ausgelesen werden,
• Schreibzugriff auf den Speicher (Speicheradresse und Datum ausgeben
und Datum speichern).
Die Speicheradresse wird häufig als Summe eines Registerinhalts (Indexregister ) und einer konstanten Verschiebung (displacement, offset) bestimmt.
Beide Angaben sind Bestandteil des Maschinenbefehls und werden im Adressfeld (s.u.) spezifiziert.
1
Ausnahme: Bei manchen Prozessoren kann die Befehlsverarbeitung mit einem HALT Befehl gestoppt werden.
5.2. Komponenten eines Computers
147
3. Verzweigungsbefehle
Man kann in Maschinenprogrammen zwei Arten von Verzweigungen unterscheiden. Eine unbedingte Verzweigung oder Sprung (Jump) führt dazu, dass der
PC mit einem neuen Wert überschrieben wird. Der neue PC-Wert wird entweder als Operand des Sprung-Befehls direkt vorgegeben (absolute Adresse)
oder er wird berechnet, indem zum alten PC-Wert eine Adressverschiebung
(Offset) addiert wird. Da die Addition des Zweierkomplements einer Subtraktion entspricht, kann man damit auch Rückwärtssprünge ausführen. Im Fall der
Adressberechnung spricht man von PC-relativer sonst von absoluter Adressierung. Die bedingte Verzweigung (Branch) wird nur dann ausgeführt, wenn eine
im Befehl vorgegebene Bedingung erfüllt ist. Im Falle der Ausführung wird sie
analog zur unbedingten Verzweigung behandelt. Folgende Schritte werden bei
Verzweigungen ausgeführt:
• Bestimmung des neuen PC -Werts für das Verzweigungsziel,
• Prüfung der Verzweigungsbedingung (entfällt bei Sprüngen),
• bei Sprüngen immer, bei Verzweigungen bedingt: Überschreiben des PC
mit dem neuen Wert.
Damit ein Maschinenprogramm innerhalb des Adressraums beliebig verschiebbar bleibt, empfiehlt es sich, keine absolute, sondern nur PC -relative
Adressierung zuzulassen.
Selbsttestaufgabe 5.1 (PC-relative Verzweigung)
Betrachten Sie den folgenden Befehl, der eine relative Verzweigung ausführt,
wenn die beiden Register R1 und R2 den gleichen Wert haben:
Branch Relative if (R1==R2), Offset
Offset sei ein positiver oder negativer Zahlenwert. Jede Adresse des Speichers enthalte einen Maschinenbefehl. Der Maschinenbefehl soll an der Adresse
0008 stehen und im Falle gleicher Register nach 0004 verzweigen. Bestimmen
Sie den Wert des Offset.
Speicherausschnitt:
0004 Verzweigungsziel wenn (R1==R2)
0005 ...
0006 ...
0007 ...
0008 Branch_Relative_if (R1==R2), Offset
0009 ...
Lösung auf Seite 175
148
Kapitel 5. Aufbau und Funktionsweise eines Computers
Bedingte Verzweigungen können dazu benutzt werden, Schleifen der Form
do { Schleifenrumpf; R1<--R1+1; } while (R1<R2)
zu implementieren. In Selbsttestaufgabe 5.1 würden die Befehle 0004 bis 0006
den Schleifenrumpf enthalten, im Befehl 0007 würde Register R1 um 1 erhöht.
Die o.g. Teilschritte zur Befehlsausführung erfordern, abhängig vom jeweiligen Maschinenbefehl, einen oder mehrere Taktzyklen. Die Dauer einzelner
Befehle hängt stark von den unterstützten Adressierungs-Arten ab. Diese legen
fest, wie während der Befehlsausführung auf die Operanden zugegriffen wird.
Je mehr Adressierungsmöglichkeiten zur Verfügung stehen, desto kürzer werden die Maschinenprogramme. Andererseits steigen aber der Hardwareaufwand
und die Zahl der benötigten Taktzyklen zur Ausführung einzelner Befehle.
Die Implementierung eines Befehlssatzes ist umso einfacher, je gleichartiger die Teilschritte der drei Befehlsklassen sind. Wenn es schließlich gelingt
— als kleinsten gemeinsamen Nenner für alle Befehle — eine feste Zahl von
Teilschritten zu finden, wird eine Implementierung durch eine Befehlspipeline
möglich. Dabei können die Teilschritte mehrerer Befehle zeitlich überlappend
ausgeführt werden. Wie bei einem Fließband kann dadurch der Befehlsdurchsatz
erheblich gesteigert werden. Diese Philosophie wurde seit Mitte der achtziger
RISC-Prozessoren Jahre konsequent bei so genannten RISC-Prozessoren (Reduced Instruction Set
Computer) eingesetzt.
Dagegen werden Prozessoren, die einen möglichst hohen Komfort bei der
CISC-Prozessoren Programmierung in Maschinensprache bieten, als CISC-Prozessoren (Complex
Instruction Set Computer) bezeichnet. Während RISC-Prozessoren Speicherzugriffe nur mit den o.g. Load- und Store-Befehlen ermöglichen, können CISCBefehle die Operanden über vielfältige Adressierungsarten sogar direkt im Speicher ansprechen. Solche Befehle benötigen dann zwar keine expliziten Load- und
Store-Operationen, aber ihr Implementierungsaufwand ist deutlich höher. Außerdem können die Befehle wegen ihrer unterschiedlichen Länge (die Zahl der
Teilschritte ist variabel) nur nacheinander ausgeführt werden. Eine Fließbandverarbeitung wie bei RISC-Prozessoren ist daher nicht oder nur eingeschränkt
möglich.
Man findet heute in fast allen Computersystemen vorwiegend RISC-Prozessoren bzw. RISC-Kerne. Selbst Prozessoren, die eigentlich einen CISC-Befehlssatz anbieten (z.B. Intel x86) wandeln die komplexen Befehle in so genannte Micro-Ops (also Mikrobefehle) um und führen diese letztendlich auf einem
RISC-Kern aus.
Befehlsformate
Maschinenbefehle bestehen aus dem Opcode und einem Adressfeld , das entweder die Rechenwerksregister direkt adressiert, eine absolute Speicheradresse
5.2. Komponenten eines Computers
149
oder die Adresse eines Indexregister s sowie eine zusätzliche Adressverschiebung
(Offset) zu dessen Inhalt enthält.
Wenn die Operanden in Rechenwerksregistern stehen, genügt ein einziges
Maschinenwort zur Darstellung eines Befehls. Solche Ein-Wort-Befehle findet Ein-Wort-Befehle
man sowohl bei CISC- als auch bei RISC-Prozessoren, für die sie typisch sind.
Ein Ein-Wort-Befehl hat folgendes Befehlsformat:
Opcode Adressfeld
Wenn die Operanden oder Daten direkt im Speicher abgelegt sind, kann ein
Befehl aus zwei oder drei Maschinenwörtern bestehen. Man findet solche Mehr- Mehr-Wort-Befehle
Wort-Befehle ausschließlich bei CISC-Prozessoren. Ein typischer CISC-Befehl
hat z.B. folgendes Format:
Opcode Adresse 1. Operand
Adresse 2. Operand
Adresse Ergebnis
In diesem Beispiel steht der 1. Operand in einem Register, das über das Adressfeld des Befehls adressiert wird. Der 2. Operand wird aus dem Speicher geholt.
Hierzu muss zunächst dessen Adresse aus dem Speicher geladen und in ein (für
den Programmierer nicht sichtbares) Adressregister geschrieben werden. Mit
dieser Adresse erfolgt dann ein weiterer Speicherzugriff, um den 2. Operanden in ein prozessorinternes Hilfsregister zu kopieren. Dann wird die Verknüpfung gemäß dem Opcode durchgeführt und das Ergebnis in einem Hilfsregister
zwischengespeichert. Um es in den Speicher zu transportieren, muss zunächst
wieder die Speicheradresse für das Ergebnis geholt und ins (wiederum für den
Programmierer nicht sichtbare) Adressregister geladen werden. Der Speicher
wird dann über das Adressregister angesprochen und der Inhalt des Hilfsregisters in den Speicher kopiert. Wir sehen, dass ein solcher CISC-Befehl nicht
nur sehr viele Teilschritte bzw. Taktzyklen, sondern auch zusätzliche Hardware
erfordert (hier ein Hilfs- und Adressregister).
Zur symbolischen Darstellung von Maschinenbefehlen werden Abkürzungen
benutzt, die sich ein Programmierer leichter einprägen kann als eine Funktionsbeschreibung oder gar den binären Opcode eines Befehls. Ein Programm, das
aus solchen so genannten Mnemonics besteht, bezeichnet man als Assembler- Mnemonic
programm. Es kann mit Hilfe einer Entwicklungssoftware, die man Assembler Assembler
nennt, in die binäre Darstellung der Maschinenbefehle übersetzt werden. Assembler erlauben auch die Verwendung symbolischer Namen für Konstanten,
Variablen und Sprungziele.
150
Kapitel 5. Aufbau und Funktionsweise eines Computers
5.2.3
Speicher
Im Speicher eines Computers werden sowohl Maschinenbefehle als auch Daten abgelegt. Jeder Speicherplatz ist über eine binäre Adresse ansprechbar und
kann ein Maschinenwort (z.B. 32 oder 64 Bit) aufnehmen. Bei modernen Computersystemen werden verschiedene Arten von Speichern benutzt, um möglichst
geringe Kosten pro Bit und gleichzeitig hohe Zugriffsraten zu erreichen. Direkt mit dem Prozessor verbunden sind die Halbleiterspeicher, bei denen man
Schreib-/Lese-Speicher (Random Access Memory, RAM) und Nur-Lese- Speicher (Read-Only Memory, ROM) unterscheidet. Jedes Computersystem enthält
einen ROM-Speicher, in dem ein einfaches Betriebssystem (Monitor) oder kleines Urladeprogramm (Bootstrap Loader) permanent gespeichert ist. Bei den
meisten Computern wird das Betriebssystem nach dem Einschalten von einem
magnetomotorischen Speicher (Festplatte) geladen. Der Hauptspeicher wird im
Allgemeinen mit dynamischen Speicherbausteinen aufgebaut, deren Zugriffszeiten etwa um einen Faktor bis 100 größer sind als die Taktzykluszeit des Prozessors. Durch den Einbau von schnellen Pufferspeichern zwischen Prozessor und
Hauptspeicher können die Geschwindigkeitsverluste bei Speicherzugriffen verringert werden. Diese Cache-Speicher halten häufig benötigte Speicherblöcke
aus dem Hauptspeicher für den Prozessor bereit.
5.2.4
Ein-/Ausgabe
Die Ein-/Ausgabe dient als Schnittstelle eines Computersystems zur Umwelt.
Sie verbindet Peripheriegeräte wie z.B. Tastatur, Monitor oder Drucker mit dem
Prozessor. Durch direkten Speicherzugriff (Direct Memory Access, DMA) oder
einen Ein-/Ausgabe-Prozessor (Input/Output Processor, IOP) kann die CPU
bei der Übertragung großer Datenblöcke entlastet werden. Die Ein-/Ausgabe
erfolgt dann ohne zeitraubende Umwege über das Rechenwerk des Prozessors
unmittelbar zwischen der Ein-/Ausgabe und dem Hauptspeicher. Dies ist besonders beim Anschluss von Festplatten wichtig, damit z.B. Daten von der
Festplatten-Steuereinheit (Controller) ohne unnötige Zeitverzögerung abgeholt
werden.
Die hier skizzierten Komponenten eines Computers finden sich bis heute
bei integrierten Prozessoren (Mikroprozessoren) wieder. Im Laufe der technologischen Entwicklung wurden jedoch Modifikationen bzw. Erweiterungen vorgenommen, um die Implementierung zu vereinfachen, die Leistung zu erhöhen
und die Programmierung zu erleichtern. Diese Maßnahmen werden im Folgenden vorgestellt.
5.3
Interne und externe Busse
Wir können die Zahl der Verbindungsleitungen für die Übertragung von Daten bzw. Befehlen nach Abb. 5.1 reduzieren, wenn wir einen Datenbus einfüh-
5.3. Interne und externe Busse
151
ren. Ein Bus besteht aus einem Bündel von Leitungen, die alle dem gleichen
Zweck dienen. Durch die zeitlich versetzte Nutzung (Zeitmultiplex) werden die
vorhandenen Leitungen besser ausgelastet. Dadurch kann die Gesamtzahl der
Leitungen reduziert werden. Mit Hilfe von Adress- und Steuerleitungen, die
Bustreiber (z.B. TriState) oder elektronische Schalter (CMOS2 -Transmission
Gates) ansteuern, können Datenpfade in zwei Richtungen (bidirektional) geschaltet werden. Der interne Datenbus ist im Allgemeinen auf die Maschinenwortbreite ausgelegt und kann von zwei verschiedenen Datenquellen angesteuert
werden (Abb. 5.3): mögliche Quellen sind die Rechenwerksregister und der externe Datenbus. Um die Zahl der Anschlusskontakte (Pins) eines Prozessorchips
zu minimieren, ist der externe Datenbus jedoch nicht immer auf die volle Maschinenwortbreite ausgelegt. So verfügt z.B. der Motorola 68008 über einen
internen Datenbus mit 32 Bit und einen externen Datenbus mit nur 8 Bit. Dem
geringeren Verdrahtungsaufwand steht jedoch ein Verlust an Übertragungsgeschwindigkeit (Busbandbreite) gegenüber. Der externe Datenbus wird über
bidirektionale Bustreiber an den internen Datenbus angekoppelt.
Prozessor
interner
Datenbus
externer Adressbus
Leitwerk
externer Steuerbus
interner
Adressbus
interner
Steuerbus
Speicher
Ein-/Ausgabe
Peripheriegeräte
Rechenwerk
externer Datenbus
Abbildung 5.3: Interne und externe Busse erleichtern die Realisierung eines
Prozessors.
Das Leitwerk versorgt das Rechenwerk mit Adressleitungen für die Register.
Die internen Steuerleitungen bilden zusammen mit den Zustandsflags des Rechenwerks den internen Steuerbus. Über Bustreiber werden die Steuersignale
und Adressen für das externe Bussystem verstärkt. Dies ist nötig, damit eine große Zahl von Speicher- und Ein-/Ausgabe-Bausteinen angeschlossen werden kann. Die Bustreiber wirken als Leistungsverstärker und erhöhen die Zahl
der anschließbaren Schaltglieder. Der Ausgang eines TriState-Bustreibers hat
wie sein Eingang entweder die logische Belegung 0 oder 1, oder er befindet
sich im hochohmigen Zustand, d.h. der Ausgang ist (wie durch einen geöffneten Schalter) von der Busleitung abgekoppelt. Dieser (dritte) Betriebszustand
2
Complementary Metal Oxide Semiconductor.
152
Kapitel 5. Aufbau und Funktionsweise eines Computers
kann über eine zusätzliche Steuervariable ausgewählt werden. Die bidirektionalen Bustreiber, mit denen die Speicher- und Ein-/Ausgabe-Bausteine an den
externen Datenbus angeschlossen sind, werden durch die (externen) Steuer- und
Adressleitungen geschaltet. Die Richtung der Datenübertragung wird mit einer
R/W -Steuerleitung (1 für Read/0 für Write) bestimmt.
Jeder externe Baustein wird durch eine Adresse bzw. innerhalb eines Adressbereichs angesprochen. Die Bustreiber-Ausgänge in Richtung Datenbus dürfen
unter einer bestimmten Adresse nur bei einem einzigen externen Baustein aktiviert werden. Die hierzu erforderliche Adressdecodierung übernimmt ein besonderes Vergleicher-Schaltnetz. Bei älteren Prozessoren wurde durch eine Steuerleitung I/O (Input/Output) zwischen einer Adresse für die Ein-/Ausgabe
und Adressen für den Hauptspeicher unterschieden. Man kann aber die Ein/Ausgabe auch wie einen Speicher bzw. -bereich behandeln. Dieses Verfahren
wird als Memory-Mapped Input/Output bezeichnet und ist heute gebräuchlich.
Systembus
Durch die Einführung interner und externer Busse wird die Realisierung von
Mikrochips und deren Einsatz zum Aufbau von Computersystemen erleichtert.
Die Gesamtheit von externem Adress-, Daten- und Steuerbus wird auch Systembus oder Systembusschnittstelle genannt. Wegen des geringeren Verdrahtungsaufwands ist es einfacher, den Schaltplan zu entflechten und ein Chipoder Leiterplattenlayout zu erstellen. Ein weiterer Vorteil ist die geringere Zahl
von Anschlüssen bei Prozessoren, Speicher- und Ein-/Ausgabe-Bausteinen.
5.4
Prozessorregister
Die in einem Prozessor enthaltenen Register können in drei Klassen eingeteilt
werden:
1. Datenregister zur Aufnahme von Operanden und zur Speicherung von
Ergebnissen,
2. Adressregister zur Adressierung von Operanden,
3. Steuerregister, die den Ablauf der Befehlsverarbeitung steuern und besondere Programmiertechniken unterstützen.
Die Datenregister dienen zur kurzzeitigen Speicherung von Variablen oder Konstanten eines Programms. Da die Datenregister im Gegensatz zum Hauptspeicher ohne zusätzliche Zeitverzögerungen benutzt werden können, ist es ratsam,
häufig benötigte Operanden in Datenregistern zu halten, die Ergebnisse zu berechnen und dann in den Hauptspeicher zurückzuschreiben.
Zum Zugriff auf Operanden im Hauptspeicher kann nach dem oben eingeführten Operationsprinzip der Programmzähler als Adresse benutzt werden.
5.4. Prozessorregister
153
Damit können aber nur diejenigen Speicherplätze adressiert werden, die unmittelbar auf einen Maschinenbefehl folgen. Um Operanden überall im Hauptspeicher ablegen zu können, verwendet man daher Adressregister. Die verschiedenen Adressierungsarten, die man in Verbindung mit Adressregistern realisieren
kann, werden später im Kurs Computersysteme 2 vorgestellt. Bei den meisten heutigen Prozessoren kann jedes Register aus dem Registerblock sowohl als
Daten- als auch Adressregister verwendet werden.
Selbsttestaufgabe 5.2 (Indexregister)
Ein Indexregister kann dazu benutzt werden, um einen ganzen Speicherbereich
zu durchlaufen“: Zunächst enthält das Indexregister die Anfangsadresse des
”
Speicherbereichs, so dass mittels eines Lade-Befehls und Adressierung mittels
Indexregister plus Offset 0 der Inhalt der ersten Speicherzelle des Bereichs in
ein Register geladen werden kann. Wird das Indexregister um 1 erhöht, so lädt
der nächste Lade-Befehl den Inhalt der zweiten Speicherzelle des Bereichs in
ein Register, usw. Wir erweitern die Schleife aus Selbsttestaufgabe 5.1 wie folgt,
um die Inhalte des Speicherbereichs aufzuaddieren. Die Befehle 0000 bis 0003
besetzen die benutzten Register mit Werten (Verknüpfungsbefehle), die Befehle
0004 bis 0006 enthalten den Schleifenrumpf (ein Lade–, zwei Verknüpfungsbefehle), der Verknüpfungsbefehl 0007 erhöht den Schleifenzähler, und Befehl
0008 verzweigt, wenn noch nicht alle Inhalte des Speicherbereichs angesprochen wurden. Charakterisieren Sie, welche der benutzten Register R0 bis R4 als
Daten– und welche als Adress-Register benutzt werden.
Speicherausschnitt:
0000 R0 erhält den Wert 0 und wird später die Summe enthalten
0001 R1 erhält den Wert 0 und zählt die Schleifendurchläufe
0002 R2 erhält die Größe des Speicherbereichs
0003 R3 erhält die Anfangsadresse des Speicherbereichs
0004 Lade den Inhalt von Zelle mit Adresse R3 in Register R4
0005 Addiere R4 und R0, speichere Ergebnis in R0
0006 erhöhe R3 um 1
0007 erhöhe R1 um 1
0008 Branch_Relative_if (R1 < R2), -5 (Rücksprung nach 0004)
0009 ...
Lösung auf Seite 175
Zu den Steuerregistern zählt das Befehlsregister, das Statusregister, der Programmzähler und der Stapelzeiger (engl. Stackpointer, SP), dessen Aufgabe es Stapelzeiger
ist, im Hauptspeicher einen Stapelspeicher 3 (engl. Stack) zu verwalten. Neben
den genannten Steuerregistern gibt es bei manchen Prozessoren (z.B. Intel x86Prozessoren) auch Segmentregister, welche die Speicherverwaltung durch das
Betriebssystem unterstützen. Daneben verwaltet das Leitwerk auch prozessorinterne Register, auf die der Anwender nicht zugreifen kann.
3
auch Kellerspeicher genannt.
154
Kapitel 5. Aufbau und Funktionsweise eines Computers
5.5
Anwendungen eines Stapelzeigers
Ein Stapel ist ein wichtiges Hilfsmittel, das die Verarbeitung von Unterprogrammen (engl. Subroutines) und Unterbrechungen (Interrupts) ermöglicht.
Man kann einen Stapel entweder direkt in Hardware auf dem Prozessorchip
realisieren oder mit Hilfe eines Stapelzeigers im Hauptspeicher abbilden. Die
erste Methode ist zwar schneller, erfordert aber mehr Chipfläche als ein einziges Stapelzeiger-Register. Außerdem kann mit dem Stapelzeiger-Register die
Speichergröße des Stapels durch zusätzlichen Hauptspeicher beliebig vergrößert
werden.
LIFO-Prinzip
Ein Stapel arbeitet nach dem LIFO-Prinzip (Last In, First Out). Dabei
sind nur zwei Operationen erlaubt: PUSH und POP. Mit der PUSH-Operation
wird ein Maschinenwort auf den Stapel gelegt und mit der POP-Operation
wird es wieder zurückgeholt. Während des Zugriffs auf den Hauptspeicher wird
der Stapelzeiger als Adresse (Zeiger) benutzt. Außerdem wird der Stapelzeiger
durch die Ablaufsteuerung so verändert, dass ein Zugriff das LIFO-Prinzip erfüllt. Die Organisation eines Stapels ist prozessorspezifisch. Meist beginnt er am
Ende des Hauptspeichers und wächst“ in Richtung zu den niedrigeren Adres”
sen. Für diesen Fall beginnt das Programm am Anfang des Hauptspeichers.
An dieses schließt sich meist der Datenbereich an. Der Stapel darf niemals
so groß werden, dass er den Daten- oder sogar Programmbereich überschreibt
(Stapel-Überlauf). Wenn der Stapel trotzdem überläuft (z.B. aufgrund eines
Programmierfehlers), muss das Betriebssystem das betreffende Programm abbrechen.
Es gibt zwei Möglichkeiten, den Stapelzeiger zu verändern:
1. bei der PUSH-Operation vor dem Schreiben in den Speicher und bei der
POP-Operation nach dem Lesen des Speichers,
2. bei der PUSH-Operation nach dem Schreiben in den Speicher und bei der
POP-Operation vor dem Lesen des Speichers, POP-Operation.
Hier wollen wir ein Beispiel für den ersten Fall betrachten. Der Stapel soll
am Ende des Hauptspeichers beginnen. Der Stapelzeiger muss deshalb mit der
letzten Hauptspeicheradresse +1 initialisiert werden. Wenn der Inhalt des Registers A auf den Stapel gelegt werden soll (PUSH A), muss die Ablaufsteuerung
zunächst den Stapelzeiger SP dekrementieren und dann den Inhalt von Register A in den Speicherplatz schreiben, auf den SP zeigt. In RTL-Schreibweise:
PUSH A:
SP ← SP − 1
M [SP ] ← A
Entsprechend dazu wird die POP-Operation in umgekehrter Richtung definiert:
5.5. Anwendungen eines Stapelzeigers
POP A:
155
A ← M [SP ]
SP ← SP + 1
Hier wird der Stapelzeiger zuerst zur Adressierung benutzt und inkrementiert, nachdem A vom Stapel geholt wurde.
Der Stapel kann auch benutzt werden, um andere Prozessorregister kurzzeitig zu speichern4 . Dies ist z.B. nötig, wenn diese Register von einem Unterprogramm oder einer Unterbrechung benutzt werden. Zu Beginn eines solchen Programmteils werden die betreffenden Register mit PUSH-Operationen
auf den Stapel gebracht. Vor dem Rücksprung an die Aufruf- bzw. Unterbrechungsstelle werden sie dann durch POP-Operationen in umgekehrter Reihenfolge in den Prozessor zurückgeholt. Man beachte, dass die Zahl der PUSHund POP-Operationen innerhalb eines Unterprogramms (bzw. Unterbrechung)
stets gleich groß sein muss.
Selbsttestaufgabe 5.3 (Stapel am Anfang des Hauptspeichers) Wie werden die
PUSH- und POP-Operationen für die zweite Variante auf Seite 154 realisiert?
Der Stapel soll am Anfang des Hauptspeichers beginnen. Wie muss der Stapelzeiger initialisiert werden?
Lösung auf Seite 175
5.5.1
Unterprogramme
Wenn an verschiedenen Stellen in einem Programm immer wieder die gleichen
Funktionen benötigt werden, fasst man die dazugehörenden Befehlsfolgen in
einem Unterprogramm (engl. Subroutine) zusammen. Dadurch wird nicht nur
Speicherplatz gespart, sondern auch die Programmierung modularisiert. Im Allgemeinen übergibt man an ein Unterprogramm Parameter, die als Eingabewerte
für die auszuführende Funktion benutzt werden. Ebenso müssen Ergebnisse an
das aufrufende Programm zurückgegeben werden. Parameter und Ergebnisse
einer Funktion können in bestimmten Registern oder über den Stapel übergeben werden. Eine Sammlung von häufig benötigten Unterprogrammen kann in
einer (Laufzeit-)Bibliothek bereitgestellt werden. Sie enthält lauffähige Maschinenprogramme, die in Anwenderprogrammen eingebunden werden können. Der
Benutzer muss lediglich die Einsprungadresse und die Schnittstelle für die Eingabe der Parameter bzw. Ausgabe der Ergebnisse kennen. Ein Unterprogramm
wird mit dem CALL-Befehl aufgerufen und mit einem RETURN -Befehl abgeschlossen.
4
Wird oft auch als retten“ bezeichnet.
”
156
Kapitel 5. Aufbau und Funktionsweise eines Computers
CALL-Befehl
Der CALL-Befehl bewirkt eine Programmverzweigung in das Unterprogramm
und speichert die Rücksprungadresse auf dem Stapel. Die Ausführung eines
CALL-Befehls in der Form Call Ziel läuft gewöhnlich in vier Schritten ab.
1. Nachdem der CALL-Befehl geholt wurde, wird der Operationscode dekodiert. Der Programmzähler wird inkrementiert, damit er auf den nachfolgenden Befehl zeigt.
P C++
2. Nun wird die Verzweigungsadresse5 in ein zusätzliches Adressregister AR
gerettet.
AR ← Ziel
3. Damit der Prozessor das Hauptprogramm nach Abarbeiten des Unterprogramms an dieser Stelle fortsetzen kann, muss er diese Rücksprungadresse
auf den Stapel legen.
SP ← SP − 1
M [SP ] ← P C
4. Im letzten Schritt wird die Startadresse des Unterprogramms aus dem
Adressregister AR in den Programmzähler geladen.
P C ← AR
Nun beginnt die Befehlsabarbeitung des Unterprogramms, indem der Opcode unter der neuen Programmzähleradresse geholt wird. Sollen Parameter an Unterprogramme über den Stapel übergeben werden, so werden
diese vor dem CALL-Befehl auf den Stapel gelegt.
Beim Eintritt in das Unterprogramm muss die Rücksprungadresse vom
Stapel in ein freies Prozessorregister gerettet werden. Unmittelbar vor
dem Rücksprung muss der Inhalt dieses Registers mit einer PUSH-Operation auf den Stapel zurückgeschrieben werden.
Eventuell werden zuvor auch noch Ergebnisse für das aufrufende Programm auf dem Stapel abgelegt.
RETURN-Befehl
Ein Unterprogramm muss mit einem RETURN-Befehl (oft mit dem Mnemonic RTS für Return from Subroutine bezeichnet) abgeschlossen werden. Der
RETURN-Befehl bewirkt eine Umkehrung von Schritt 3 des CALL-Befehls. Die
Rücksprungadresse wird durch eine POP-Operation vom Stapel geholt und in
den Programmzähler geschrieben.
5
Startadresse des Unterprogramms.
5.5. Anwendungen eines Stapelzeigers
P C ← M [SP ]
SP ← SP + 1
Nachdem die Rücksprungadresse im Programmzähler wiederhergestellt ist, kann
das Hauptprogramm, beginnend mit einer Befehlsholephase, fortgesetzt werden.
Verschachtelung und Rekursion. Das beschriebene Verfahren zur Unterprogramm-Verarbeitung ermöglicht auch den Aufruf von Unterprogrammen aus
Unterprogrammen. Wenn sich Unterprogramme selbst oder gegenseitig aufrufen, spricht man von direkter oder indirekter Rekursion. Rekursive Aufrufe von
Unterprogrammen sind nur dann zulässig, wenn die im Unterprogramm benutzten Registerinhalte zu Beginn mit PUSH-Befehlen auf den Stapel gerettet und
am Ende des Unterprogramms durch POP-Befehle (in umgekehrter Reihenfolge wie die PUSH-Befehle) wiederhergestellt werden. Die mögliche Verschachtelungstiefe hängt in allen Fällen von der Größe des für den Stapel verfügbaren
Hauptspeicherbereichs ab. Folglich muss auch ein entsprechendes Rekursionsende gewährleistet sein. Ist dies nicht der Fall, so kommt es zu einem Überlauf
(Stapel-Überlauf).
Natürlich ist es auch bei nicht-rekursiven Unterprogrammen ratsam, die darin benutzten Register zu Beginn des Unterprogramms auf den Stapel zu retten
und vor dem Rücksprung ins aufrufende Programm von dort wiederherzustellen. Der damit verbundene Zeitaufwand ist allerdings nur dann gerechtfertigt,
wenn das aufrufende Programm die Bewahrung des Prozessorzustands auch
tatsächlich erfordert. Dies trifft für die während rekursiver Unterprogrammaufrufe benutzten Register immer zu. Wenn das aufrufende Programm jedoch
bestimmte Prozessorregister nicht oder nur als Hilfsregister nutzt, müssen diese
von den Unterprogrammen auch nicht gerettet werden.
Zeitbedarf. Der dynamische Aufbau einer Verbindung zwischen dem Hauptund Unterprogramm mit Hilfe der Befehle CALL und RETURN erhöht den
Zeitbedarf zur Ausführung einer Funktion. Dieser zusätzliche Zeitaufwand ist
der Preis für den eingesparten Speicherplatz. Bei zeitkritischen Anwendungen
kann es erforderlich sein, auf Unterprogramme zu verzichten und stattdessen
Makros zu verwenden. Hier werden an die Stelle eines CALL-Befehls alle Ma- Makros
schinenbefehle der auszuführenden Funktion eingefügt. Obwohl sich dadurch
der Speicherbedarf erhöht, wird die Zeit für den Aufruf eines Unterprogramms
und für die Rückkehr zum Hauptprogramm eingespart. Dies ist insbesondere
bei einfachen Funktionen günstiger. Assembler, welche die Verwendung von Makros unterstützen, werden Makroassembler genannt. Der Programmierer kann
einer Folge von Maschinenbefehlen einen symbolischen Namen zuordnen. Immer wenn dieser Name im weiteren Verlauf des Programms auftritt, wird er
durch diese Befehlsfolge ersetzt. Neben Makroassemblern erlauben auch einige
problemorientierte Sprachen wie z.B. C“ die Verwendung von Makros.
”
157
158
Kapitel 5. Aufbau und Funktionsweise eines Computers
5.5.2
Unterbrechungen (Interrupts)
Besondere Ereignisse inner- oder außerhalb des Prozessors können Unterbrechungen (engl. Interrupts) erzeugen, die zu einer Unterbrechung des normalen
Programmablaufs führen. Im Folgenden benutzen wir den englischen Begriff
Interrupt, da dieser gebräuchlicher ist. Als Reaktion auf einen Interrupt verzweigt der Prozessor zu einem Programmteil, der auf das eingetretene Ereignis
reagiert (Interrupt Service Routine). Interrupts werden vom Prozessor ähnlich
wie Unterprogramme behandelt. Sie unterscheiden sich von Unterprogrammen
lediglich durch die Art des Aufrufs. Interrupts werden nicht durch einen CALLBefehl ausgelöst, sondern durch intern oder extern erzeugte (Hardware)Signale.
Sie können an jeder beliebigen Stelle (asynchron zum Prozessortakt) während
der Abarbeitung eines Programms eintreffen. Wenn der Prozessor einen Interrupt akzeptiert, kann eine (mehr oder weniger) schnelle Reaktion auf das durch
das Signal angezeigte Ereignis erfolgen.
Anwendungen
Es gibt eine Vielzahl von Anwendungen für Interrupts. Wir wollen im Folgenden einige Beispiele kurz beschreiben.
Ein-/Ausgabe. Bei der Ein-/Ausgabe muss sich der Prozessor mit den angeschlossenen Peripheriegeräten synchronisieren. Eine Möglichkeit hierzu besteht
darin, ständig den Zustand der Ein-/Ausgabe-Bausteine abzufragen (BusyWaiting). Wesentlich günstiger ist jedoch die Interrupt-gesteuerte Ein-/Ausgabe.
Hier wird der Prozessor nur dann unterbrochen, wenn der Ein-/Ausgabe-Baustein bereit ist, Daten zu senden oder zu empfangen. Erst wenn diese Bereitschaft vorhanden ist (Ereignis), wird sie mittels eines Signals gemeldet. In der
Zwischenzeit kann der Prozessor nützlichere Dinge tun, als auf das Peripheriegerät zu warten.
Betriebssysteme. In so genannten Multitasking-Systemen schaltet der Prozessor ständig zwischen verschiedenen Benutzern (bzw. Prozessen) um. Jeder
Benutzer erhält den Prozessor nur während einer bestimmten Zeitspanne (Time Slice). Die Zuteilung des Prozessors wird durch den Betriebssystemkern
vorgenommen, der nach dem Ablauf einer Zeitscheibe durch einen Interrupt
aufgerufen wird. Die Erzeugung dieser Interruptsignale erfolgt i.Allg. mit Hilfe von programmierbaren Zeitgebern (Timer). Mit Zeitgebern können genau
bestimmbare Zeitverzögerungen erzeugt werden. Sie sind daher auch für die
Echtzeitprogrammierung wichtig. Im Gegensatz zu einfachen Betriebssystemen
muss bei Echtzeitbetriebssystemen der Zeitbedarf zur Abarbeitung eines Programms genau eingehalten werden.
SoftwareInterrupts
Software-Interrupts sind Maschinenbefehle, welche die gleiche Wirkung haben wie durch Hardware ausgelöste Interrupts. Mit Hilfe von Software-Interrupts kann der Benutzer bestimmte Ein-/Ausgabe-Operationen aufrufen, die
5.5. Anwendungen eines Stapelzeigers
159
das Betriebssystem bereitstellt (System Calls) und die nur im System-Modus
(privileged Mode oder Supervisor Mode) erlaubt sind.
Traps und Exceptions. Sowohl Hardware- als auch Softwarefehler können
zu kritischen Zuständen eines Computersystems führen, die sofort bereinigt
werden müssen. Solche Fehler werden durch eine geeignete Hardware erkannt,
die dann einen besonderen Interrupt auslöst, der in jedem Fall vom Prozessor akzeptiert und unverzüglich bearbeitet wird. Typische Softwarefehler sind
die Division durch Null (Divide by Zero), die Überschreitung des darstellbaren
Zahlenbereichs (Überlauf) und das Ausführen nicht existierender Maschinenbefehle (Illegal Instruction). Der zuletzt genannte Fehler kann z.B. auftreten,
wenn fälschlicherweise in einem Unterprogramm eine unterschiedliche Zahl von
PUSH- und POP-Befehlen auf dem Stapel ausgeführt wurden. Die angeführten Interrupts entstehen innerhalb des Prozessors und werden häufig als Trap Trap
(Falle) oder Exceptions bezeichnet. Zu den extern auftretenden Fehlern zählen Exceptions
z.B. Speicherdefekte, die durch eine Paritätsprüfung erkannt werden können.
Weitere Fehlerquellen dieser Art sind Einbrüche der Betriebsspannung oder
die Verletzung von Zeitbedingungen bei Busprotokollen. Um solche Fehler zu
erkennen, benutzt man so genannte Watchdog-Schaltungen.
Verarbeitung eines einzelnen Interrupts
Moderne Prozessoren besitzen ein kompliziertes Interrupt-System, das mehrere
Interrupt-Quellen unterstützt. Wir wollen jedoch zunächst annehmen, dass es
nur eine einzige Interrupt-Quelle gibt und erst im nächsten Abschnitt kompliziertere Interrupt-Systeme mit mehreren Interrupt-Quellen betrachten.
Um mit einem Prozessor Interrupts verarbeiten zu können, muss die Ablaufsteuerung der Holephase erweitert werden. Nur so können externe oder interne
Signale auf die Befehlsverarbeitung des Prozessors Einfluss nehmen. Da eine
Interrupt-Anforderung IRQ (Interrupt Request) zu jedem beliebigen Zeitpunkt
während eines Befehlszyklus eintreffen kann, muss sie zunächst in einem Flipflop zwischengespeichert werden. Bis zur Annahme und Bearbeitung durch den
Prozessor bleibt die Interrupt-Anforderung anhängig (pending). Die notwendige
Erweiterung der Holephase ist in Abb. 5.4 dargestellt. Dabei wurde angenommen, dass der Stapel am Ende des Hauptspeichers (RAM-Bereich) beginnt. Die
Notation M [- -SP ] bedeutet, dass der Stapelzeiger zuerst dekrementiert und
dann zur Adressierung des Speichers benutzt wird. Der Interrupt-Opcode legt
implizit die Startadresse der Service-Routine fest, die auch Interrupt-Vektor ge- Interrupt-Vektor
nannt wird. Mit dem Quittungssignal IN T A (Interrupt Acknowledge) bestätigt
der Prozessor dem anfordernden Gerät die Interrupt-Anforderung. Mit diesem
Signal kann auch das IRQ-Flipflop zurückgesetzt werden. Bevor die eigentliche Service-Routine beginnt, sollte zunächst das Statusregister auf den Stapel
gerettet werden. Damit die während der Service-Routine möglicherweise veränderten Flags sich nicht auf den Programmfluss des unterbrochenen Programms
160
RETI-Befehl
Kapitel 5. Aufbau und Funktionsweise eines Computers
auswirken, wird der gesicherte Inhalt des Statusregisters vor dem Rücksprung
ins unterbrochene Programm wieder vom Stapel zurückgeholt. Die Sicherung
des Statusregisters wird normalerweise automatisch durch die Ablaufsteuerung
(Mikroprogramm) erledigt. Am Ende einer Interrupt-Service-Routine steht ein
RETI-Befehl (Return from Interrupt), um – wie bei Unterprogrammen – die
Rücksprungadresse vom Stapel zu holen. Da zusätzlich auch das Statusregister zurückgeschrieben wird, unterscheidet sich der RETI-Befehl von einem
Unterprogramm-RETURN-Befehl. Bei älteren Prozessoren (z.B. Intel i8085)
muss der Programmierer selbst die Service-Routine in PUSH- und POP-Befehle
einbetten, die den Inhalt des Statusregisters für das unterbrochene Programm
retten.
IRQ = 1
J
M[--SP]
N
PC
M[PC++]
INTA-Signal
IR
Interrupt-Opcode
IR
Abbildung 5.4: Erweiterung der Holephase zur Bearbeitung eines Interrupts.
Das Statusregister wird nicht bei allen Prozessoren automatisch gerettet.
Mehrere Interrupts
Wenn ein Prozessor in der Lage sein soll, mehrere Interrupt-Quellen zu berücksichtigen, müssen zwei Probleme gelöst werden:
1. Jedem Interrupt muss eine eigene Startadresse für die Service-Routine
zugeordnet werden.
2. Wenn mehrere Interrupts gleichzeitig hängend sind, muss eine Entscheidung getroffen werden, welcher Interrupt vorrangig bearbeitet wird.
Prioritäten
Die Einführung von Prioritäten für die einzelnen Interrupts kann durch
Hardware oder Software erfolgen. Außerdem ist es sinnvoll, zwei Kategorien von
Interrupts zu unterscheiden: maskierbare und nicht maskierbare Interrupts. Die
maskierbaren Interrupts können vom Programmierer freigegeben oder gesperrt
werden. Während zeitkritischer Programmabschnitte ist es z.B. ratsam, alle
Interrupts dieser Art zu sperren, damit keine zusätzlichen Verzögerungszeiten
5.5. Anwendungen eines Stapelzeigers
161
durch Service-Routinen entstehen. Nicht-maskierbare Interrupts (Non Maskable Interrupts, NMI) können nicht gesperrt werden. Sie dienen zur Fehlerbehandlung und müssen deshalb unverzüglich bearbeitet werden. Ein weiteres
Beispiel für eine unaufschiebbare Fehlerbehandlung ist die Reaktion auf einen
Abfall der Betriebsspannung, die von einer Watchdog-Schaltung ausgelöst wird.
Beispiele für Prozessor-interne Ereignisse (Traps) wurden oben bereits beschrieben. Traps sind ebenfalls nicht maskierbar und haben zudem stets die höchste
Priorität.
Startadresse der Service-Routine. Um die Startadresse der Service-Routine
zu bestimmen, gibt es drei Möglichkeiten:
1. Abfragemethode,
2. Vektormethode,
3. Codemethode.
Die Abfragemethode (Polling) hat den geringsten Hardwareaufwand, da am
Prozessor weiterhin nur ein Interrupt-Eingang nötig ist. Die Interrupt-Anforderungen der einzelnen Ein-/Ausgabe-Bausteine werden durch eine OR-Funktion
miteinander verknüpft, die dann diesen Eingang IRQ ansteuert. Wenn während
der Holephase eine hängende Interrupt-Anforderung erkannt wird (IRQ = 1),
unterbricht der Prozessor das laufende Programm, indem er die zu dem (einzigen) Interrupt gehörende Service-Routine aufruft. Dieses Programm verwaltet alle“ Interrupts und wird deshalb Interrupt Handler genannt. Zunächst Interrupt Handler
”
muss die Interrupt-Quelle ermittelt werden. Dazu werden die Statusregister
der einzelnen Ein-/Ausgabe-Bausteine nacheinander gelesen und geprüft, ob
das Interrupt-Flag gesetzt ist. Der Interrupt Handler kennt die Startadressen
der Service-Routinen für jeden einzelnen Baustein. Sobald die Abfrage des Interruptflags positiv ist, wird durch einen unbedingten Sprung zu der (dem
Ein-/Ausgabe-Baustein) zugeordneten Service-Routine verzweigt. Dieses Device Handler-Programm muss dann mit dem RETI-Befehl abgeschlossen sein.
Die Reihenfolge der Abfrage entspricht der Priorität der angeschlossenen Ein/Ausgabe-Bausteine. Wechselnde Prioritäten sind durch Änderung dieser Reihenfolge leicht zu realisieren. Ein großer Nachteil der Abfragemethode ist jedoch der hohe Zeitbedarf zur Abfrage der einzelnen Ein-/Ausgabe-Bausteine
und Ermittlung des richtigen Device Handlers.
Die Vektormethode (vectored Interrupts) verursacht den größten Hardwareaufwand, da für jede mögliche Interrupt-Anforderung ein eigener Eingang am
Prozessor vorhanden sein muss. Die eintreffenden Interrupt-Anforderungen werden in einem besonderen Register ISRQ (Interrupt Service ReQuest) aufgefangen und mit einer Interrupt-Maske IM , die Bestandteil des Statusregisters ist, bitweise AND-verknüpft. Nehmen wir zunächst einmal an, dass sich
die Interrupt-Anforderungen wechselseitig ausschließen. Wenn ein freigegebener Interrupt erkannt wird, kann die Ablaufsteuerung der betreffenden Anforderungsleitung einen Maschinenbefehl zuordnen, der implizit die Startadresse
162
Kapitel 5. Aufbau und Funktionsweise eines Computers
für eine Service-Routine festlegt. Mit der Vektormethode können InterruptAnforderungen sehr schnell beantwortet werden, da die Startadresse des Device Handlers spätestens nach einem Befehlszyklus bekannt ist. Nachteilig ist
jedoch, dass jeder Anforderungsleitung nur ein Device Handler zugeordnet werden kann. Abhängig von ihrem momentanen Zustand benötigen Peripheriegeräte jedoch verschiedene Device Handler. Um trotzdem mit nur einer Anforderungsleitung auszukommen, bietet sich die direkte Abfrage eines Codes für die
gewünschte Service-Routine an.
Die Codemethode wird von sehr vielen Prozessoren angeboten, da sie ein
hohes Maß an Flexibilität bietet. Jeder Anforderungsleitung IRQi wird ein
Quittungssignal IN T Ai zugeordnet. Wenn ein Ein-/Ausgabe-Baustein auf eine Interrupt-Anforderung hin ein Quittungssignal erhält, antwortet er mit einem Codewort auf dem Datenbus6 . Aus diesem Codewort wird dann die Startadresse des gewünschten Device Handlers bestimmt. Unterstützt der Prozessor
vektorisierte Interrupts, so entspricht dem Codewort eine Vektornummer aus
der Interrupt-Tabelle (s.u.). Das Codewort kann aber auch einen CALL-Befehl
darstellen, und der Ein-/Ausgabe-Baustein übergibt im Anschluss daran die
Startadresse direkt an den Prozessor (vgl. Intel i8085).
Prioritäten lösen Konflikte. Wenn mehrere Interrupt-Anforderungen gleichzeitig hängend sind, liegt eine Konfliktsituation vor. Dieser Fall kann z.B. eintreten, wenn in einem Befehlszyklus zwei Interrupts gleichzeitig oder kurz hintereinander eintreffen. Welcher der beiden Interrupts wird dann zuerst bearbeitet?
Oder nehmen wir an, der Prozessor sei gerade in einer Service-Routine und ein
neuer Interrupt tritt auf. Soll die Service-Routine zuerst beendet werden oder
wird sie selbst unterbrochen? Um solche Konfliktsituationen zu beheben, müssen Prioritäten definiert werden, welche die Bedeutung der einzelnen Interrupts
gewichten. Wie wir bereits weiter oben gesehen haben, können Prioritäten sehr
leicht durch die Abfragereihenfolge in einem Interrupt Handler implementiert
werden. Die Abfragemethode ist jedoch sehr langsam.
InterruptController
Wir wollen im Folgenden den Aufbau und die Funktionsweise eines Interrupt-Controllers vorstellen. Eine Hardware-Lösung ist wesentlich schneller, da
sie den Prozessor nicht belastet. Die Priorität einer Anforderungsleitung wird
durch einen auf dem Chip integrierten Interrupt-Controller festgelegt. Die Startadressen sind in einer Tabelle, der sogenannten Interrupt-Tabelle, abgelegt.
Jeder Interrupt-Eingang kann mit Hilfe eines externen Controllers in weitere
Prioritätsebenen unterteilt werden. Sowohl interne als auch externe InterruptController haben prinzipiell den gleichen Aufbau.
In Abb. 5.5 ist ein Interrupt-Controller für vier Prioritätsebenen dargestellt. Wenn alle Interrupts freigegeben sind (IM = 1111), gelangen hängende
Anforderungen im ISRQ zu einem Prioritätsencoder, der die Nummer der Anforderung höchster Priorität als Dualzahl ausgibt. Für den Fall, dass keine
Anforderung hängend ist, wird eine Null ausgegeben. Deshalb ist auch ein 36
Das Codewort hat meist nicht die volle Maschinenwortbreite.
5.5. Anwendungen eines Stapelzeigers
163
Abbildung 5.5: Aufbau eines Interrupt-Controllers für vier Prioritätsebenen.
IRQ4
1
0
0
0
0
IRQ3
×
1
0
0
0
IRQ2
×
×
1
0
0
IRQ1
×
×
×
1
0
Code
100
011
010
001
000
Tabelle 5.1: Wahrheitstabelle eines Prioritätsencoders für 4 Interrupt-Eingänge.
× steht für don’t care.
Bit-Code notwendig. Nehmen wir an, dass IRQ4 die höchste Priorität hat, so
ergibt sich die Funktionstabelle 5.1 für den Prioritätsencoder.
Der vom Prioritätsencoder ausgegebene Code wird mit den Interrupt-Statusbits IS des Statusregisters verglichen. Diese Bits codieren die Prioritätsebene, in der sich der Prozessor gerade befindet. Ist der vorliegende Prioritäts-Code
kleiner als der IS-Code oder gleich groß, so wird keine Interrupt-Anforderung
an die Ablaufsteuerung weitergeleitet. Alle vorliegenden Interrupt-Anforderungen bleiben hängend. Falls der am Vergleicher-Eingang A anliegende Prioritäts-Code größer als der IS-Code ist, wird die Anforderung mit der höchsten
Priorität akzeptiert und wie folgt bearbeitet:
1. Mit Hilfe des Prioritäts-Codes wird die Startadresse der Service-Routine
nach einer der oben genannten Methoden bestimmt und das passende
IN T Ai -Signal wird ausgegeben.
2. Die Rücksprungadresse wird zusammen mit dem alten IS-Code (Statusregister) auf den Stapel gerettet.
3. Die Startadresse der Service-Routine wird in den Programmzähler geladen und der IS-Teil des Statusregisters wird mit dem aktuellen Prioritätscode7 überschrieben.
7
Vom Eingang A des Vergleichers.
164
Kapitel 5. Aufbau und Funktionsweise eines Computers
4. Nun kann die Abarbeitung der Service-Routine erfolgen. Sie wird mit einem RETI-Befehl abgeschlossen. Da dieser Befehl das alte Statusregister
wiederherstellt, bewirkt er eine Rückkehr in die unterbrochene Prioritätsebene.
Mit dem beschriebenen Interrupt-Controller können beliebig ineinander verschachtelte Interrupts verarbeitet werden. Dies wollen wir an einem konkreten
Beispiel noch einmal verdeutlichen.
Beispiel. Betrachten wir zwei Peripheriegeräte, die unterschiedliche Geschwindigkeitsanforderungen an eine Service-Routine stellen. Das Lesen eines Sektors bei einer Festplatte erfordert die sofortige Reaktion des Prozessors, sobald sich die gewünschte Spur unter dem Schreib-/Lesekopf befindet. Die zugehörige Service-Routine HD (Hard Disk) darf nicht unterbrochen werden, da
sonst Daten verloren gehen. Wir ordnen deshalb der Festplatte die InterruptAnforderung höchster Priorität, hier IRQ4 , zu. Als zweites Peripheriegerät soll
ein Drucker betrachtet werden, der zeilen- oder blockweise Daten empfängt und
seine Bereitschaft zur Aufnahme neuer Daten durch einen Interrupt signalisiert.
Die Service-Routine LP (Line Printer) kann jederzeit unterbrochen werden, da
sich dadurch lediglich die Zeit zum Ausdrucken verlängert. Der Ein-/AusgabeBaustein zum Anschluss des Druckers wird daher mit der Anforderungsleitung
niedrigster Priorität, hier IRQ1 , verbunden. Wir wollen annehmen, dass während der Abarbeitung des Hauptprogramms je ein Prozess zum Drucken und zur
Datei-Eingabe aktiv sind und vom Betriebssystem blockiert wurden, d.h. diese
Prozesse warten auf Interrupts der Peripheriegeräte. Wenn der Drucker über
IRQ1 Bereitschaft zum Drucken signalisiert, kann der Prozessor zum Device
Handler LP verzweigen. Die Rücksprungadresse und das Statusregister werden
auf den Stapel gerettet und der IS-Code auf 001 gesetzt. Trifft während der
Bearbeitung von LP ein IRQ4 ein, so wird LP unterbrochen, da der aktuelle
Interrupt-Prioritätscode 100 größer ist als der IS-Code. Nach der Verzweigung
zum Programm HD ist der IS-Code 100. Der Device Handler der Festplatte
kann demnach nicht unterbrochen werden, da alle anderen Interrupts niedrigere
Prioritätscodes haben8 . Sobald das Programm HD abgeschlossen ist, setzt der
Prozessor die Bearbeitung des Device Handlers LP fort. Nach dem Rücksprung
aus HD ist der IS-Code wieder 001. Man beachte, dass beide Interrupts durch
die Interrupt-Maske IM freigegeben sein müssen. Um Fehler zu vermeiden,
dürfen Änderungen der Interrupt-Maske nur vom Betriebssystem vorgenommen werden. Die meisten Prozessoren bieten daher hardwaremäßig die zwei
Betriebsarten User Mode und Supervisor Mode. Die Interrupt-Maske kann nur
im Supervisor Mode verändert werden.
Die oben beschriebene Hardware eines Interrupt-Controllers ist i.Allg. auf
dem Prozessorchip integriert. Zusätzliche Prioritätsebenen können durch die
Abfragemethode (Software), externe Interrupt-Controller oder durch eine Verkettung der IN T A-Signale einer Ebene erreicht werden (Daisy-Chain). Die
letztgenannte Methode ist besonders häufig, da sie nur geringen Mehraufwand
an Hardware verursacht. Sie wird meist mit der Codemethode zur Ermittlung
8
Ausgenommen NMIs.
5.6. Rechenwerk
165
der Startadresse kombiniert. Die Daisy-Chain-Priorisierung führt eine ortsabhängige Prioritätenfolge innerhalb einer Ebene ein, indem das IN T A-Signal
vom Prozessor über hintereinandergeschaltete Busmodule weitergereicht wird.
Jedes Busmodul stellt eine mögliche Interrupt-Quelle dar, die über eine Sammelleitung eine Interrupt-Anforderung erzeugen kann. Das erste Busmodul, das
einen Interrupt-Service wünscht, antwortet dem Prozessor mit einem Codewort
zur Bestimmung der Startadresse der Service-Routine, sobald es ein IN T ASignal registriert. In diesem Fall reicht das betreffende Busmodul das IN T ASignal nicht an nachfolgende Busmodule weiter. Somit hat das direkt auf das
Prozessormodul folgende Busmodul die höchste Priorität.
Selbsttestaufgabe 5.4 (Schaltnetz Prioritätsencoder) Bestimmen Sie die Schaltfunktionen für den Prioritätsencoder nach Tab. 5.1.
Lösung auf Seite 175
5.6
Rechenwerk
Wie schon gesagt, besteht das Rechenwerk im Wesentlichen aus Registern, Multiplexern und einer ALU. Im Folgenden sollen diese Bestandteile näher betrachtet werden.
5.6.1
Daten- und Adressregister
Wenn im Rechenwerk adressierbare Datenregister vorhanden sind, spricht man
von einer Registerarchitektur. Die Datenregister bilden einen Register-Block Registerarchitektur
oder ein Register File9 . Bei Registerarchitekturen unterscheidet man Ein-, Zweiund Drei-Adress-Maschinen. Der Adresstyp wird von der Zahl der internen
Daten- und Adressbusse bestimmt, die den Registerblock mit der ALU und
dem Speicher verbinden. Je mehr Datenregister gleichzeitig ausgewählt werden
können, umso weniger Taktzyklen werden zur Ausführung eines Maschinenbefehls benötigt.
Oft wird der Begriff X-Adress-Maschine auch auf das Format eines Maschinenbefehls bezogen. Da die Zahl der Adressen, die in einem Befehl angegeben
werden können, keine Auskunft über die Hardware-Implementierung des Rechenwerks (Maschine) gibt, sollte man in diesem Zusammenhang besser von
einem X-Adress-Befehlssatz sprechen.
Neben Registerarchitekturen gibt es die Stapelarchitekturen oder NullStapelarchitektur
Adress-Maschinen. Anstelle eines Register Files wird hier ein Stapel benutzt,
um Operanden oder Ergebnisse zu speichern. Eine echte Stapelarchitektur verfügt über einen auf dem Prozessor integrierten LIFO-Speicher. Die Realisierung
9
Wenn sehr viele Register vorhanden sind (z.B. bei RISC-Prozessoren).
166
Kapitel 5. Aufbau und Funktionsweise eines Computers
des Stapels im Hauptspeicher (mit Hilfe eines Stapelzeigers) ist in diesem Fall
nicht empfehlenswert, da die hohe Zahl von Speicherzugriffen die Prozessorleistung herabsetzt. Null-Adress-Befehle enthalten keine direkten Adressangaben,
sondern benutzen die Daten, die oben auf dem Stapel liegen, als Operanden
oder als Adressen (für Zugriffe auf den Hauptspeicher). Diese Daten werden
kurzzeitig in Latches zwischengespeichert und durch die ALU miteinander verknüpft. Das Ergebnis wird dann wieder auf den Top of Stack (TOS) gelegt. Diese Vorgehensweise entspricht der Berechnung eines arithmetischen Ausdrucks
in der umgekehrten Polnischen Notation (Reverse Polish Notation, RPN). Erst
müssen mit PUSH-Befehlen die Operanden auf den Stapel gebracht werden
und danach wird die gewünschte Operation angegeben. Da die Adresse fehlt,
sind Maschinenbefehle von Stapelarchitekturen sehr kompakt. Zur Lösung einer
bestimmten Aufgabe müssen jedoch viele Maschinenbefehle verwendet werden.
Obwohl es stackorientierte Programmiersprachen (z.B. FORTH) gibt, die durch
entsprechende Stapelmaschinen unterstützt werden, hat sich die Stapelarchitektur nicht durchsetzen können. Der überwiegende Anteil heutiger Prozessoren
gehört zur Klasse der Registerarchitekturen.
5.6.2
Datenpfade
In Abb. 5.6 ist ein Rechenwerk dargestellt, das ALU und Registerfeld nur mit
einem internen (bidirektionalen) Datenbus verbindet. Nachteilig ist an dieser
Datenpfadstruktur, dass die Abarbeitung eines Maschinenbefehls drei Taktzyklen erfordert: Zunächst müssen die beiden Operanden in zwei Hilfs-Register
gebracht werden. Da immer nur ein Operand pro Takt aus dem Register File
gelesen werden kann, benötigt man hierzu zwei Taktzyklen. Im dritten Taktzyklus wird das Ergebnis der Verknüpfung vom F(unction)-Ausgang der ALU
ins Register File geschrieben.
Abbildung 5.6: Rechenwerk einer Ein-Adress-Maschine.
Beispiel. Angenommen, der Drei-Adress-Befehl SUB R1,R2,R3 soll auf
einer Ein-Adress-Maschine ausgeführt werden. Die Realisierung dieses Befehls
erfordert die folgenden Mikrooperationen:
5.6. Rechenwerk
167
Taktzyklus
1
2
3
Operation
R1 → A
R2 → B
F → R3
Bei einer Zwei-Adress-Maschine kann der gleiche Befehl in zwei Taktzyklen
ausgeführt werden, da die Latches A und B gleichzeitig geladen werden. In
Abb. 5.7 wird die Datenpfad-Struktur einer Drei-Adress-Maschine dargestellt,
die für RISC-Prozessoren typisch ist. Der angeführte Beispiel-Befehl kann mit
einem solchen Rechenwerk in einem Taktzyklus ausgeführt werden, da sowohl
für die Operanden als auch für das Ergebnis eigene Datenbusse bereitstehen,
die separat adressierbar sind. Das Rechenwerk einer Drei-Adress-Maschine wird
auch als Register-ALU oder kurz RALU bezeichnet.
RALU
Abbildung 5.7: Rechenwerk einer Drei-Adress-Maschine.
5.6.3
Schiebemultiplexer
Schiebeoperationen sind z.B. für die Multiplikation oder Division nützlich. Sie
können durch einen Schiebemultiplexer (Shifter) an einem Eingang der ALU
realisiert werden. Der Schiebemultiplexer besitzt drei Eingänge mit Maschinenwortbreite (Abb. 5.8). Ein Eingang ist ganz normal mit dem internen Datenbus verbunden. Bei den beiden anderen Eingängen sind die Datenleitungen
einerseits um eine Stelle nach links, andererseits um eine Stelle nach rechts
verschoben. Über zwei Steuerleitungen wird die gewünschte Positionierung eines ALU-Operanden ausgewählt. Wenn der Operand verschoben wird, muss
entweder von links oder rechts ein Bit nachgeschoben werden (Eingänge: Left
Input, LI, und Right Input, RI). Das herausfallende“ Bit steht je nach Schie”
berichtung an den Ausgängen (Left Output, LO, bzw. Right Output, RO).
Oft wird bei Schiebeoperationen das Carry Flag benutzt, um entweder das
herausfallende Bit zwischenzuspeichern oder um den Inhalt des Carry Flags
nachzuschieben. Wenn die Schiebe-Eingänge mit den zugehörigen Ausgängen
verbunden werden10 , rotieren die Bits um eine Stelle nach links oder rechts. Mit
10
LO → LI bzw. RO → RI.
168
Kapitel 5. Aufbau und Funktionsweise eines Computers
mehreren Rotationsoperationen können Bitgruppen in jede gewünschte Position gebracht werden. Oft ist es auch möglich, über das Carry Flag zu rotieren,
d.h. der Schiebe-Ausgang wird mit dem Eingang des Carry Flags verbunden
und dessen Ausgang mit dem Schiebe-Eingang.
Abbildung 5.8: 4-Bit-Schiebemultiplexer (Shifter) vor einem ALU-Eingang.
5.6.4
Logische Operationen
In Kapitel 2 haben wir schon Schaltungen für arithmetische Operationen kennengelernt. Wir wollen im Folgenden kurz auf logische Operationen eingehen.
Da bei logischen Operationen jede Stelle eines Maschinenworts unabhängig von
den anderen Stellen verarbeitet werden kann, ist die Entwicklung entsprechender Schaltnetze unkritisch. Die Verzögerungszeiten logischer Operationen sind
im Vergleich zu arithmetischen Operationen vernachlässigbar und haben folglich keinen Einfluss auf die Taktrate des Prozessors. Mit zwei Variablen xi und
yi können 16 verschiedene logische Verknüpfungen gebildet werden. Erzeugt
man alle vier Minterme und ordnet jedem Minterm eine Steuervariable zu, die
kontrolliert, ob der Minterm genutzt wird oder nicht, so können mit dem Steuerwort alle logischen Operationen ausgewählt werden.
zi = s3 xi yi ∨ s2 xi yi ∨ s1 xi yi ∨ s0 xi yi
Als Beispiele sollen die Steuerwörter für die drei Boole’schen Grundoperationen angegeben werden:
1. Negation
zi = xi = xi (yi ∨ y i ) = xi yi ∨ xi y i ⇒ s3 s2 s1 s0 = 0011
2. Disjunktion
zi = xi ∨ yi
= xi (yi ∨ y i ) ∨ (xi ∨ xi )yi
= xi yi ∨ xi y i ∨ xi yi ∨ xi yi ⇒ s3 s2 s1 s0 = 1110
5.6. Rechenwerk
3. Konjunktion
zi = xi yi ⇒ s3 s2 s1 s0 = 1000
5.6.5
Arithmetische Operationen
Durch eine weitere Steuervariable s4 kann man auch die Überträge aus einem
Addierschaltnetz miteinbeziehen und so zwischen arithmetischen und logischen
Operationen umschalten.
Die inverse XOR-Funktion (⊕) wird Äquivalenz -Funktion genannt und mit
dem Symbol ≡ notiert. Für jede Stelle wird nun die folgende Funktion mit der
zusätzlichen Steuervariablen s4 gebildet:
fi = zi ≡ (s4 ∨ ci )
Für s4 = 1 gilt dann
fi = zi ≡ 1 = zi
⇒ logische Operationen wie oben
Für s4 = 0 folgt
fi = zi ≡ ci
⇒ arithmetische Operationen
Zur Addition zweier N -stelliger Dualzahlen berechnet sich die Stellensumme
wie folgt:
Si = xi ⊕ yi ⊕ ci
= xi ≡ yi ≡ ci
= (xi yi ∨ xi y i ) ≡ ci
i = 0 . . . N − 1, c0 = 0
Die Addition kann demnach mit dem Steuerwort s4 s3 s2 s1 s0 = 01001 ausgewählt werden, d.h. fi = Si .
Die Subtraktion kann auf die Addition des Zweierkomplements des Subtrahenden zurückgeführt werden. Daraus folgt für die Stellendifferenz in der i-ten
Stelle:
di = xi ≡ y i ≡ ci
= (xi y i ∨ xi yi ) ≡ ci
i = 0 . . . N − 1, c0 = 1
Die Subtraktion wird also mit dem Steuerwort s4 s3 s2 s1 s0 = 00110 ausgewählt, d.h. fi = di . Mit dem beschriebenen Steuerprinzip können 16 logische
und 32 arithmetische Operationen (c0 = 1/0) realisiert werden. Dabei entstehen
auch exotische“ Funktionen, die selten oder gar nicht benutzt werden.
”
Nun wollen wir zeigen, wie die wichtigsten Status-Flags bestimmt werden.
5.6.6
Status-Flags
Die Ausgänge fN −1 , . . . , f0 bilden den Ergebnisbus der ALU (vgl. Abb. 5.6
und Abb. 5.7). Aus der Belegung dieser Bits und der Belegung des Übertrags
169
170
Kapitel 5. Aufbau und Funktionsweise eines Computers
cN werden die Status-Flags gebildet. Die folgenden Flags sind bei fast allen
Prozessoren zu finden, da sie sehr einfach bestimmt werden können:
1. Carry C: Übertrag in der höchsten Stelle, C = cN
2. Zero Z: alle Bits von F sind Null, Z = fN −1 ∨ fN −2 ∨ . . . ∨ f0
3. Minus M: negatives Vorzeichen bei Zweierkomplement-Darstellung,
M = fN −1
4. Overflow (bzw. Underflow) V: das Ergebnis ist zu groß (klein), um mit
N -Bit-Wortbreite dargestellt zu werden,
V = cN ⊕ cN −1
Die Entstehung eines Overflows (bzw. Underflows) soll an einem Beispiel
erläutert werden. Wir betrachten dazu die Addition von 2- Bit-Zahlen in der
Zweierkomplement-Darstellung (vgl. Abb. 5.9). Ein Overflow (bzw. Underflow)
liegt vor, wenn bei der Addition die Grenze von +1 nach -2 (bzw. -2 nach +1)
überschritten wird. Die Erkennung einer solchen Fehlersituation ist äußerst
wichtig, da sonst falsche Ergebnisse zurückgeliefert werden. Sie kann (mit Hilfe
eines Interrupt Handlers) korrigiert werden, indem die Berechnung anschließend
mit doppelter Wortbreite ausgeführt wird.
Abbildung 5.9: Zweierkomplement-Darstellung einer 2-Bit-Zahl; innen: Dezimalwert, außen: duale Codierung.
Selbsttestaufgabe 5.5 (MiniALU) Entwerfen Sie eine ALU, die insgesamt nur
sieben elementare Funktionen gemäß der Tabelle 5.2 ausführen kann.
Hierbei bezeichnen A und B die beiden Eingänge und F den Ausgang der
ALU. Cin bezeichnet den eingehenden Übertrag und Compl = 1 soll intern
das Einerkomplement des Eingangs B erzeugen. Neben logischen Schaltgliedern AND, OR und XOR steht ein Addierschaltnetz und ein 4:1-Multiplexer in
Maschinenwortbreite zur Verfügung.
Lösung auf Seite 175
5.7. Leitwerk
171
S1
0
0
0
0
0
1
1
S0
0
0
0
0
1
0
1
Compl Cin
0
0
0
1
1
0
1
1
X
X
X
X
X
X
F
A+B
A+B+1
A−B−1
A−B
A∧B
A∨B
A⊕B
Tabelle 5.2: Funktionstabelle der MiniALU
5.7
Leitwerk
Das Leitwerk hat die Aufgabe, Maschinenbefehle (Makrobefehle) aus dem Hauptspeicher ins Befehlsregister zu laden (Holephase) und anschließend zu interpretieren (Ausführungsphase). Obwohl die Maschinenbefehle auch durch eine
sogenannte Einzyklus-Implementierung umgesetzt werden können, wird in der
Praxis ausschließlich die Mehrzyklen-Implementierung angewandt. Der Grund
dafür ist, dass aufwendige Funktionseinheiten wie z.B. eine ALU zeitlich versetzt genutzt werden können und daher nicht mehrfach vorhanden sein müssen.
Außerdem ergeben sich aufgrund der tiefen Schaltnetze bei einer EinzyklenImplementierung sehr lange Verzögerungszeiten und somit deutlich geringere
Taktfrequenzen.
Ein Maschinenbefehl wird bei einer Multizyklen-Implementierung durch eine Folge von Steuerwörtern (Mikrobefehle) für Rechenwerk, Speicher und Ein/Ausgabe umgesetzt. Diese Steuerwörter werden durch eine Ablaufsteuerung
erzeugt, die entweder festverdrahtet ist oder als Mikroprogramm-Steuerwerk
aufgebaut wird. CISC-Prozessoren verfügen über einen sehr umfangreichen Befehlssatz, der nur mit Hilfe der Mikroprogrammierung implementiert werden
kann. Im Folgenden werden wir die Besonderheiten zur die Implementierung
solcher Leitwerke genauer betrachten.
RISC-Prozessoren nutzen ebenfalls die Mehrzyklen-Implementierung. Aufgrund der einfacheren Befehle und Adressierungsarten kann hier die Technik
der Fließbandverarbeitung (Pipelining) zum Einsatz kommen. Im Gegensatz
zu CISC-Prozessoren wird hier bei jedem Maschinenbefehl stets die gleiche
Anzahl von Mikrobefehlsschritten ausgeführt. Daher können mehrere Maschinenbefehle zeitlich überlappend in durch Register voneinander entkoppelten
Hardwarestufen ausgeführt werden. Hiermit erreicht man sehr hohe Taktraten und im günstigsten Fall kann pro Takt ein Maschinenbefehl abgeschlossen
werden. Das Leitwerk vereinfacht sich hierbei wesentlich und es besteht nur
noch aus einem Decodierschaltnetz für den Opcode. Aufgrund dieser Vorzüge
nutzen alle modernen Prozessoren die Mehrzyklen-Implementierung in Kombination mit Pipelining. Wir werden im Kurs Computersysteme 2 ausführlich
darauf eingehen.
172
Kapitel 5. Aufbau und Funktionsweise eines Computers
5.7.1
Mikroprogrammierung
Mikroprogramm-Steuerwerke können leichter entwickelt und gewartet werden
als festverdrahtete Steuerwerke. Sie sind aber auch wesentlich langsamer als
diese, da sie die Mikrobefehle erst aus dem Steuerwort-Speicher holen müssen.
Um eine hohe Taktrate zu erreichen, muss dieser Speicher sehr schnell sein. Die
Kosten pro Speicherbit sind entsprechend hoch (vgl. Kapitel 4 in Kurs Computersysteme 2). Um die Chipfläche und die Kosten eines Prozessors zu minimieren, muss die Speicherkapazität des Steuerwort-Speichers optimal ausgenutzt
werden. Die dabei angewandten Techniken werden im Folgenden behandelt.
Der Befehlssatz eines Prozessors und die Fähigkeiten des Rechenwerks werden durch Mikroprogramme miteinander verknüpft. Zu jedem Makrobefehl
gibt es einen Bereich im Steuerwort-Speicher, der die zugehörigen Mikrobefehle enthält und den man als Mikroprogramm bezeichnet. Der Befehlssatz eines
Prozessors wird durch die Menge sämtlicher Mikroprogramme definiert. Die
meisten Mikroprozessoren haben einen festen Befehlssatz, d.h. der Anwender
kann die Mikroprogramme (Firmware) nicht verändern. Mikroprogrammierbare Rechner verfügen über RAM-Speicher zur Aufnahme der Mikroprogramme.
Die Mikroprogrammierung bietet viele Möglichkeiten bei der Rechnerentwicklung und Anwendung, wie z.B. die Emulation anderer Rechner. Dies ist ein
weiterer Vorteil von Mikroprogramm-Steuerwerken gegenüber festverdrahteten
Steuerwerken. Ein Mikroprogramm-Steuerwerk ist ein Hardware-Interpreter für
den Maschinenbefehlssatz. Um Mikroprogramme zu entwickeln, gibt es symbolische Sprachen, die mit Assemblern vergleichbar sind. Man nennt sie daher
auch Mikroassembler. Sie werden gebraucht, um symbolische Mikroprogramme
in Steuerspeicher-Inhalte zu übersetzen. Der Mikro-“Programmierer braucht
”
detaillierte Kenntnisse über den Hardware-Aufbau des Prozessors.
Die grundlegende Struktur eines Mikroprogramm-Steuerwerks haben wir
bereits in Kapitel 3 kennengelernt. In Abb. 5.10 wurde das in Abb. 3.18 dargestellte Mikroprogramm-Steuerwerk so erweitert, dass es als Leitwerk verwendet
werden kann.
Der Opcode wird im Befehlsregister abgelegt und durch ein Schaltnetz in
die Startadresse des zugehörigen Mikroprogramms umgeformt. Der SteuerwortSpeicher wird über das Control Memory Address Register (CMAR) adressiert,
das auf Mikroprogramm-Ebene die gleiche Funktion hat wie der Programmzähler für Makroprogramme. Dieser Mikroprogrammzähler wird zu Beginn mit
der Startadresse geladen und bei einem linearen Mikroprogramm mit jedem
Taktzyklus um eins inkrementiert. Am Ende jedes Mikroprogramms muss das
Befehlsregister mit dem nächsten Maschinenbefehl geladen werden und der beschriebene Ablauf wiederholt sich. Das Mikroprogramm für diese Holephase
wird somit am häufigsten durchlaufen.
5.7. Leitwerk
Adressfeld
StartadressTransformation
+1
0
1
2
CMAR
Opcode
173
SteuerwortSpeicher
Statusregister
Testmultiplexer
Interrupts
Steuerwort
Abbildung 5.10: Aufbau eines reagierenden Mikroprogramm-Steuerwerks zur
Ablaufsteuerung.
5.7.2
Mikrobefehlsformat
Mikrobefehle enthalten nicht nur Steuerbits, sondern auch Information zur
Adresserzeugung für den Mikrobefehlszähler. Da während eines Mikroprogramms
Interrupts und Status-Flags zu Verzweigungen führen können, benötigt man ein
reagierendes Mikroprogramm-Steuerwerk. Ein Mikrobefehl setzt sich im Wesentlichen aus zwei Teilen zusammen:
1. einem Steuerwort zur Auswahl der Operationen im Rechenwerk,
2. einem Adressauswahlwort, um die Adresse des nächsten Mikrobefehls festzulegen.
Der überwiegende Teil des Steuerworts wird zur Steuerung von Mikrooperationen im Rechenwerk benötigt. Wenn mehrere Funktionseinheiten im Rechenwerk vorhanden sind, können auch mehrere Mikrooperationen gleichzeitig
ausgeführt werden. Es werden dann auch weniger Mikroprogramm-Schritte zur
Ausführung eines Befehls gebraucht. Andererseits erhöht die Zahl der parallelen Mikrooperationen auch die Zahl der Steuer-Bits bzw. den Hardwareaufwand
des Rechenwerks.
In der Praxis arbeitet man mit codierten Mikrobefehlen, da nur ein geringer
Prozentsatz der theoretisch möglichen Steuerwörter sinnvolle Mikrooperationen
bewirkt. Wenn anstelle von Multiplexern Schalter (z.B. CMOS Transmission
Gates) oder Bustreiber vor den Registern benutzt werden, können bei uncodierter Ansteuerung Datenpfade geschaltet werden, die auf dasselbe Register
führen. Dabei würden sich die Daten gegenseitig verfälschen. Um den Aufwand
zur Decodierung gering zu halten, unterteilt man das Steuerwort in mehrere
voneinander unabhängige Felder. Jedes Steuerfeld codiert eine Mikrooperation, die gleichzeitig zu den Mikrooperationen anderer Steuerfelder ausgeführt
174
Kapitel 5. Aufbau und Funktionsweise eines Computers
werden kann. Man beachte, dass mit der Decodierung eine Zeitverzögerung
verbunden ist, die sich zur Zugriffszeit des Steuerwort-Speichers addiert.
Allgemein können wir zwei grundlegende Mikrobefehlsformate unterscheiden: horizontale und vertikale Mikrobefehle. Horizontale Mikrobefehle sind gekennzeichnet durch viele Steuer-Bits und eine hohe Zahl paralleler Mikrooperationen. Vertikale Mikrobefehle benutzen nur ein Steuerfeld und haben einen
hohen Decodierungsaufwand. Es wird in jedem Taktzyklus immer nur eine einzige Mikrooperation ausgeführt. Die genannten Mikrobefehlsformate findet man
in der Praxis selten in ihrer Reinform. Sie liegen meist in einer Mischform vor.
Wenn z.B. ein zweiter Speicher zur Decodierung langer horizontaler Steuerwörter benutzt wird, so spricht man von Nanoprogrammierung.
Wie oben bereits erwähnt ist die Mikroprogrammierung der Goldstandard
bei CISC-Prozessoren. Die Komplexität der Maschinenbefehle sowie deren Adressierungsarten erfordern unterschiedlich viele Mikrobefehle (Taktzyklen), die nur
durch Mikroprogrammierung flexibel implementiert werden können. Im nachfolgenden Kurs Computersysteme 2 werden wir Prozessoren zunächst aus der
Sicht des Programmierers beschreiben. Man bezeichnet diese Sichtweise auch
als Befehlssatzarchitektur, da sie nur die vom Prozessor bereitgestellte Funktionalität und nicht deren Realisierung beschreibt. Die Befehlssatzarchitektur
hat aber entscheidenden Einfluss auf die (logische und technische) Implementierung eines Prozessors, die man als Mikroarchitektur bezeichnet. Wir werden eine
RISC-Befehlssatzarchitektur kennenlernen, die statt durch Mikroprogrammierung auch durch das so genannte Pipelining implementiert werden kann. Da mit
Pipelining-Mikroarchitekturen die Hardware effizienter ausgenutzt und gleichzeitig die Rechenleistung gesteigert werden kann, bilden sie die Basis moderner
Mikroprozessoren.
5.8
Zusammenfassung
Nach dem Durcharbeiten dieses Kapitels
• kennen Sie die Komponenten eines Computers und können seine Funktionsweise anhand des grundsätzlichen Ablaufs von Befehlen erklären,
• verstehen Sie die Bedeutung interner und externer Bussysteme,
• können Sie die Arten und Aufgaben verschiedener Prozessorregister beschreiben,
• kennen die Komponenten eines Rechenwerks,
• können Sie mikroprogrammierbare Leitwerke für Mehrzyklenbefehle erklären, und
• haben Sie die wesentlichen Speicherarten sowie deren Zugriffzeiten kennengelernt.
5.9. Lösungen der Selbsttestaufgaben
5.9
Lösungen der Selbsttestaufgaben
Selbsttestaufgabe 5.1 von Seite 147
Bei Auswertung der Verzweigungsbedingung gilt PC=0009, d.h. wir müssen als
Offset den Wert 0004 − 0009= −5 wählen.
Selbsttestaufgabe 5.2 von Seite 153
Das Register R3 dient als Indexregister und damit als Adressregister. Die Register R0, R1, R2 und R4 dienen als Datenregister.
Selbsttestaufgabe 5.3 von Seite 155
PUSH A:
M [SP ] ← A
SP ← SP + 1
Entsprechend dazu wird die POP-Operation in umgekehrter Richtung definiert:
POP A:
SP ← SP − 1
A ← M [SP ]
Der Stapelzeiger muss mit dem Wert 0 initialisiert werden.
Selbsttestaufgabe 5.4 von Seite 165
Die Codebits seien mit C2 , C1 und C0 notiert.
Die Schaltfunktionen lauten:
C2 = IRQ4
C1 = IRQ4 ∧ (IRQ3 ∨ IRQ2 )
C0 = IRQ4 ∧ (IRQ3 ∨ IRQ3 ∧ IRQ2 ∧ IRQ1 )
Selbsttestaufgabe 5.5 von Seite 170
Das Schaltbild der MiniALU ist Abb. 5.11 dargestellt. Der Eingang B wird
über XOR-Schaltglieder in den zweiten Eingang des Addierschaltnetzes eingespeist. Ein Eingang jedes dieser XOR-Schaltglieder ist mit Compl verbunden.
175
176
Lösungen der Selbsttestaufgaben
=1
n
≥1
n
&
n-Bit
4:1
MUX
n
F
n
S
1
S
0
n
n
A
B
n
=1
n-Bit
AddiererSchaltnetz
Compl
Cin
Abbildung 5.11: Aufbau der MiniALU. Der Ausgangsübertrag des Addierers
ist nicht gezeigt.
Daher wird bei Compl = 1 und Cin = 0 das Einerkomplement bzw. mit Cin = 1
das Zweierkomplement gebildet. Der Ausgangsübertrag des Addierers ist nicht
gezeigt, da er in einer ALU normalerweise nicht zum Ausgang geht (die Zielregister haben wie die Quellregister eine Breite von n Bit), sondern zu einem
Statusregister.
Index
Addierglieder, 46
Adressdecodierer, 45
Adressfeld, 148
ALU, 59, 119
Äquivalenz, Automaten, 92
Äquivalenz, Zustände, 100
Äquivalenzklasse, 101
Assembler, 149
Ausführungsphase, 145
Automat, 88
Automat, endlicher, 89
Automat, Vollständigkeit, 90
Automat, Widerspruchsfreiheit, 90
Automatenmodelle, 88
fetch, 145
Finite State Maschine, 89
Firmware, 172
Flags, 145
FSM, 89
Funktionsgleichung, 22
Funktionsschaltnetz, 123
Funktionstabelle, 21
Funktionstabelle, unvollstandige, 21
Funktionstabelle, vollstandige, 21
BCD–Code, 42
Befehlsregister, 145
Befehlszähler, 145
Binäre Codierung, 104
Boolesche Algebra, 15
Bootstrap Loader, 150
Halbaddierer, 47
Hauptspeicher, 150
Hazard, 71
Holephase, 145
Hot-one-Codierung, 103
Cache, 150
CISC-Prozessoren, 148
Code–Umsetzer, 42
Computer, Grundlagen, 142
Control Memory, 124
CPU, 143
Indexregister, 149
Interrupt, 154, 158
–Anwendungen, 158
–Beispiel, 164
–Betriebssysteme, 158
–Codemethode, 162
–Ein-/Ausgabe, 158
–Prioritäten, 162
–Service-Routine, 161
–Verarbeitung, 159
–maskierbarer, 160
–nicht maskierbarer, 160
–polling, 161
Interrupt Handler, 161
Interrupt-Controller, 162
Interrupt-Vektor, 159
Interrupts
–Abfragemethode, 161
–Vektormethode, 161
Darstellungsformen, 91
Datenabhängigkeiten, 123
Datenbus, 150
Demultiplexer, 55
Drei-Adress-Maschine, 165
Ein-/Ausgabe, 143, 150
Ein-Adress-Maschine, 165
Ein-Wort-Befehle, 149
EPROM, 70
Exceptions, 159
Fehlerbehandlung, 159
GAL, 104
Gate Array Logic, 104
Grundverknupfung, 19
177
178
Index
Karnaugh–Veitch, 27
Kernimplikant, 35
Komparator, 51
Konstruktionsregeln, 122
KV–Diagramm, 27
Leitwerk, 145, 171
–Mikroprogrammierung, 172
–Steuerwort-Speicher, 172
LIFO-Prinzip, 154
Logische Operationen, 168
Makroassembler, 157
Makros, 157
Maxterm, 24
Mealy-Automat, 89
Memory-Mapped IO, 152
Mikroassembler, 172
Mikroprogramm-Steuerwerk
–Mikrobefehlsformat, 173
–Mikrooperation, 173
–Mikroprogrammzähler, 172
–reagierendes, 173
Mikroprogrammierung, 124
Mikroprogrammsteuerwerk, 105
Mikroprozessor, 150
Minimierung, 29
Minterm, 24
Mnemonic, 149
Moore-Automat, 89
Multiplexer, 53
Normalform, disjunktive, 24
Normalform, konjunktive, 24
Null-Adress-Maschine, 165
Opcode, 142, 145, 148
Operationscode, 145
Operationswerk, 115
–universelles, 136
overflow, 60
PAL, 70
Paralleladdierer, 48
PLA, 70
Primimplikant, 34
Prioritäten, 160
Prioritätsencoder, 162
Produktterm, 65
Programmierbare Logikbausteine, 104
PROM, 69
Prozessor, 143
Prozessorregister, 152
Quine–McCluskey, 32
Races, 75
RALU, 167
Rechenwerk, 143
– Registerarchitektur, 165
– Stapelarchitektur, 165
–Adressregister, 153, 165
–Datenpfade, 166
–Datenregister, 152, 165
–Status-Flags, 169
–logische Operationen, 168
Registerblock, 123
Rekursion, 157
RETI-Befehl, 160
Ripple Carry Adder, 50
RISC-Prozessoren, 148
ROM, 67
Schaltalgebra, 15, 17
Schaltfunktion, 17, 18
Schaltnetz, 14
Schaltvariable, 18
Schaltwerk, Analyse, 94
Schaltwerk, Implementierung, 104
Schaltwerk, komplexes, 115
Schaltwerk, Synthese, 97
Schaltzeichen, 28
Schiebemultiplexer, 167
Segmentregister, 153
Shifter, 144, 167
Signallaufzeit, 71
Software-Interrupt, 158
Speicher, 142, 150
Speicherglieder, 83
Stapel, 153
–Stapelzeiger, 153
Stapelzeiger, 154
Status-Flags, 169
Statusregister, 145
Statusvektor, 116
Steuerbus, 151
Steuervektor, 116
Index
Steuerwerk, 115
–Entwurf, 124
Steuerwort-Speicher, 124
Systembus, 152
Systembusschnittstelle, 152
Trap, 159
Unterbrechnung, 158
Unterbrechung, 154
Unterprogramm, 154, 155
–CALL-Befehl, 156
–RETURN-Befehl, 156
–Zeitbedarf, 157
Urladeprogramm, 150
Vektorfunktion, 35
Verschachtelung, 157
Volladdierer, 47
Zustands-Codierung, 103
Zustands-Codierung, Binäre Codierung,
104
Zustands-Codierung, Hot-one-Codierung,
103
Zustands-Minimierung, 100
Zustandstabelle, 114
Zustandsgraph, 91
Zustandstabelle, 91
Zwei-Adress-Maschine, 165
Zweierkomplement, 60
179