Systemtheorie Digitaler Systeme - Technische Universität Chemnitz

Systemtheorie
Digitaler Systeme
Skript
Vorlesung
Inhaltsverzeichnis
1. Grundlagen....................................................................................... 5
1.1
Einführung in die Theorie der Schaltsysteme .......................................... 5
1.1.1
Definition (von Wunsch): System ........................................................................ 5
1.1.2
Signalverarbeitungsschema (Black Box) ............................................................. 5
1.1.3
Signalklassifizierung ............................................................................................ 6
1.1.4
Schaltsysteme ....................................................................................................... 6
1.1.5
Mathematisches Modell ....................................................................................... 6
1.1.6
Aufgaben der Schaltalgebra ................................................................................. 7
1.1.7
Geschichte der Schaltalgebra ............................................................................... 7
1.1.8
Technische Entwicklung ...................................................................................... 7
1.1.9
Literatur (Eine subjektive Auswahl von R. Rohde) ............................................. 7
1.2
Binäre Funktionen .................................................................................... 8
1.2.1
Modellbildung ...................................................................................................... 8
1.2.2
Zuordnungstabelle ................................................................................................ 8
1.2.3
Binäre Variable .................................................................................................... 9
1.2.4
Binärvektoren ....................................................................................................... 9
1.2.5
Binäre Funktion .................................................................................................... 9
1.2.6
Mathematische Modelle für binäre Funktionen ................................................. 10
1.3
Elementare Funktionen, Operationen, Gesetze, Verknüpfungsgatter .... 15
1.3.1
Hardware-Realisierungsmöglichkeiten von Booleschen Operationen ............... 16
1.3.2
Rechenregeln für Boolesche Ausdrücke ............................................................ 18
1.3.3
Analyse und Vereinfachung von Kontaktschaltungen ....................................... 18
1.3.4
Antivalenz-Operation (XOR): ≁, ↮,  ............................................................. 19
1.3.5
Äquivalenz-Operation (XAND): ~, , , ⨀ .................................................... 20
1.3.6
Orthogonalität-Lemma ....................................................................................... 21
1.4
Entwicklungs-/ Zerlegungssätze und Normalformen ............................. 21
1.4.1
Normalform (NF) ............................................................................................... 21
1.4.2
Disjunkte Zerlegung ........................................................................................... 22
1.4.3
Konjunktive Normalform (KNF) ....................................................................... 23
1.5
Transformation der Modelle und Formen .............................................. 25
1.5.1
K(f)  KP .......................................................................................................... 25
1.5.2
A(f)  KP .......................................................................................................... 26
1.5.3
E(f)  KP .......................................................................................................... 26
2
2. Entwurf kombinatorischer Schaltsysteme ..................................... 28
2.1
Syntheseprinzipien .................................................................................. 28
2.1.1
Entwurfsgrundlage: Gatter (gate = Tor, Pforte) ................................................. 28
2.1.2
Gatter- und Zweigschaltungen ........................................................................... 28
2.1.3
Analyse des Verhaltens ...................................................................................... 28
2.1.4
Wesentliche Informationen zur Synthese ........................................................... 29
2.2
Synthese von zwei- und mehrstufigen Schaltnetzen .............................. 29
2.2.1
Zweistufiges binäres System .............................................................................. 29
2.2.2
Effektiver Synthesealgorithmus mit TVL .......................................................... 30
2.3
Einfache Synthese von mehrstufigen kombinatorischen Systemen ....... 32
2.3.1
Grundprinzip: Anwendung des Assoziativgesetzes ........................................... 32
2.3.2
Anwendungen ..................................................................................................... 32
2.4
Entwurf von Multiplexer-Schaltungen ................................................... 33
2.5
Statische Nebenbedingungen .................................................................. 34
2.5.1
Technische Interpretation der Nebenbedingung ................................................ 34
2.5.2
Auswirkungen der Nebenbedingungen auf die Hauptfunktionen/Sollverhalten 35
3. Automaten und sequentielle Schaltsysteme .................................. 37
3.1
Modell ..................................................................................................... 37
3.1.1
Praktische Erfahrung .......................................................................................... 37
3.1.2
Allgemeine Struktur ........................................................................................... 37
3.1.3
Allgemeines Verhaltensmodell .......................................................................... 37
3.1.4
Zeitliches Verhalten eines Automaten ............................................................... 38
3.1.5
Automatentypen: Moore-Automaten und Mealy-Automaten ............................ 39
3.1.6
Grenzfälle ........................................................................................................... 39
3.1.7
Beschreiben des Verhaltens/ weitere Automatenmodelle .................................. 39
3.2
Binäre Automaten ................................................................................... 41
3.2.1 Aus technischen Gründen (z.B. Störsicherheit, einfache Realisierbarkeit, …)
werden alle auftretenden Größen binär codiert ................................................................ 41
4. Entwurf sequentieller Schaltsysteme............................................. 44
4.1
Schaltsysteme mit konzentrierten Speicherelementen ........................... 44
4.1.1
Struktur von FF Schaltwerken ............................................................................ 44
4.1.2
FF-Schema/ Symbolik ........................................................................................ 45
4.1.3
Verhaltensbeschreibung unterschiedlicher FF-Typen ........................................ 46
4.1.4
Synthese von Schaltungen mit FF ...................................................................... 50
4.2
Analyse des Verhaltens von FF-Schaltungen ......................................... 54
4.2.1
Analyse Algorithmus.......................................................................................... 54
3
4.3
Speichertechnische Realisierungen ........................................................ 57
5. Zusammenfassung Konsultation ................................................... 58
6. Anhang ........................................................................................... 59
6.1
Boolesche Ausdrücke/ Boolesche Formen (BF) .................................... 59
6.2
Reine Formen Boolescher Funktionen ................................................... 59
6.3
Rechenregeln der Booleschen Algebra................................................... 60
6.3.1
Boolescher Verband BV(k) ................................................................................ 60
6.3.2
Boolesche Ringe BR(k) ...................................................................................... 61
6.3.3
Transformationsgesetze ...................................................................................... 61
6.4 Alle Schaltfunktionen von zwei Variablen und ihre Interpretation als
binäre Operation............................................................................................... 62
6.5 Realisierungsbasis und zugehörige Form einer Funktion-TVL für den
zweistufigen Kombinatorikentwurf (nach D. Bochmann) .............................. 63
6.6
Flip-Flop (FF) – Gleichungen................................................................. 63
6.7
Tabelle der FF-Ansteuerwerte ................................................................ 64
4
1.
Grundlagen
1.1
Einführung in die Theorie der Schaltsysteme
1.1.1
Definition (von Wunsch): System
Ein von der Umwelt abgrenzbares einheitliches Ganzes wird als System bezeichnet.
1.1.2
Signalverarbeitungsschema (Black Box)
(technisches) System mit Ein- und Ausgangsgrößen zur Kommunikation mit der Umwelt.
Op {X, Z}
X
Y
Z
Bündel von Leitungen
𝑋1
Vektor der Eingangsgrößen: 𝑋 = ( ⋮ )
𝑋𝑛
𝑌1
Vektor der Ausgangsgrößen: 𝑌 = ( ⋮ )
𝑌𝑚
𝑍1
Vektor der Zustandsgrößen: 𝑍 = ( ⋮ ), Op = Operationen = Verhalten des Systems
𝑍𝑙
Gilt 𝑛 > 1 oder/und 𝑚 > 1 => Mehrgrößensystem, sonst Eingrößensystem.
Eingangs-, Ausgangs- und Zustandsgrößen werden durch ihren Verlauf nach als Signale
(Träger von Informationen) bezeichnet.
Information = beseitigte Unsicherheit
Mathematisches Modell für Signal:
Zeitfunktion 𝑥(𝑡) mit 𝑥 ∈ 𝑋, 𝑡 ∈ 𝑇
[oder Raum-Zeit-Funktionen 𝑥(𝑡, ℎ1 , ℎ2 , 𝑣), h = horizontale Komponente, v = vertikale
Komponente]
mit 𝑋 ⊂ ℝ; 𝑋 = 𝑊[𝑋(𝑡)] = Wertebereich und 𝑇 ⊂ ℝ; 𝑇 = 𝐷[𝑋(𝑡)] = Definitionsbereich
5
1.1.3
Signalklassifizierung
T
Kontinuierlich
(zeitstetig)
X
Diskontinuierlich
(zeitdiskret)
x(t)
x(k)
t
Analoges Signal
TA
k
Abtastperiode TA
Abtastzeit 𝑡 = 𝑘 ∙ 𝑇𝐴 , 𝑘 ∈ ℤ
Abtastsignal 𝑥(𝑘) (sampled
signal)
x(t)
x(k)
Diskret
(wertdiskontinuierlich)
t
TA
k
Diskretisierung des Wertebereichs
Analog
(wertkontinuierlich)
Stufen-/Treppensignal
Digitales Signal
Nur bestimmte Werte zugelassen,
(Spezial:
Binäres Signal)
Quantisierung des Wertebereichs
Diskretisierung des Definitionsbereichs
1.1.4
Schaltsysteme
Technische Einrichtungen in denen die wesentlichen Kenngrößen nur diskrete, speziell binäre
Werte annehmen und in denen die Signalverarbeitung auf der Grundlage boolescher
Operationen erfolgt.
Bestimmungszweck ist die Übertragung, Verarbeitung und Speicherung digitaler Signale.
Beispiele für Schaltsysteme/ Digitale Systeme

Digitalrechner

Digitale Kommunikationstechnik/ Handy

Digitale Messtechnik

Digitale Steuer- und Automatisierungstechnik

Modelle für nichttechnische Systeme (Simulation, Datenbanken, …)
Teilsysteme mit CPU, Signalprozessoren, Speicher, Relais, digitale Anzeigen
1.1.5
Mathematisches Modell
Schaltalgebra (technische Definition):
Struktur- und Verhaltenstheorie der Schaltsysteme
Schaltalgebra (mathematische Definition):
Algebra des Booleschen Verbandes (BV) = Boolesche Algebra
6
Algebra = [vordefinierte] Rechenvorschrift = algebraische/ mathematische Struktur
A = (M, Op) mit M = Trägermenge, Op = Operationen auf Relationen
Idealisierungen
a)
wohldefinierte diskrete Zustände (technische Toleranzen)
b)
sprungförmige Änderungen (begrenzte Gültigkeit des Moduls)
c)
Abstraktion von Energieträger, Typ, Bauform, Technologie
1.1.6
a)
b)
c)
d)
1.1.7
Aufgaben der Schaltalgebra
Strukturentwurf/ Schaltungssynthese
Verhaltensanalyse
Prüfung und Fertigung von Schaltsystemen
Lösung aussagenlogischer Probleme
Geschichte der Schaltalgebra
Aussagenlogik: Aristoteles
Schaltalgebra: Gottfried Wilhelm Leibniz (1646 – 1716), George Boole (1815 – 1864),
Augustus De Morgan (1806 – 1870)
Moderne Schaltalgebra: Nakashima (1936), Shegalkin (1928), Shannon (1938), Pearce/
Quine/ McCluskey (1952, 1956), Reed/ Muller (1953), Karnaugh/ Zakrewski (1961), Thayse
(1981), Brayton (1986), Yang/ Ciesielski (2000)
1.1.8
Technische Entwicklung
1938 Relaisrechner
1940 Elektronenröhren Rechner (Zuse, etc.)
1955 Transistor
1965 Mikroelektronik (IC’s)
1.1.9
Literatur (Eine subjektive Auswahl von R. Rohde)
Gleichungen und Übrungsblätter http://www.tu-chemnitz.de/etit/st/inhalt.php#rt

Bücher mit akzeptabler theoretischer Basis
Bochmann, Dieter: Einführung in die strukturelle Automatentheorie, Hanser Fachbuchverlag
Zander, Joachim: Logischer Entwurf binärer Systeme, Verlag Technik
Gössel, Michael: Automatentheorie für Ingenieure, Akademie-Verlag

weitere Bücher
Scarbata, Gerd: Synthese und Analyse digitaler Schaltungen, Oldenbourg Verlag
Pernards, Peter: Digitaltechnik, Hüthig Verlag
Lipp, Hans Martin: Grundlagen der Digitaltechnik, Oldenbourg Verlag
7

Bücher zur Digitaltechnik mit Anwendungsaspekten, aber theoretischem Bastelniveau
Lichtberger, Bernhard: Praktische Digitaltechnik, Hüthig Verlag
Orlowski, Peter: Angewandte Digitaltechnik, diagonal-Verlag
Jutzi, Wilhelm: Digitalschaltungen – Eine Einführung, Springer
Weißel, Ralph: Digitale Schaltungstechnik, Springer

Englischsprachige Darstellungen
Daniels, Jerry: Digital Design from Zero to One, Wiley
Mano, Morris: Digital Design, Prentice Hall
Lee, Samuel: Modern Switching Theory and Digital Design, Prentice Hall
Nelson, Victor P.: Digital Logic Circuit Analysis and Design, Prentice Hall
Fabricius, Eugene D.: Modern Digital Design and Switching Theory, CDC Press
1.2
Binäre Funktionen
1.2.1
Modellbildung
Grundlage ist die Zuordnung deutlich unterscheidbarer/ klassifizierbarer Werte einer
gegebenen (physikalischen) Größe zu binären, d.h. zweiwertigen Symbolen (0 und 1, „wahr“
und „nicht wahr“, Low und High, -1 und 1, etc.) einer mathematischen Modellvariablen x.
1.2.2
Zuordnungstabelle
Nr.
Logik Wert 0
Logik Wert 1
Niedrig, Low
Hoch, High
Hoch, High
Niedrig, Low
3
4
5
Physikalische Größe
(elektrisches) Potenzial
Positive Logik
(elektrisches) Potenzial
Negative Logik
Strom
Leitwert
Widerstand
Klein bzw. 0
Klein
Klein
6
Kontakt
In Ruhe (nichtleitend)
7
8
Lampe, LED
Transistor
Aus
Gesperrt
Groß
Groß
Groß
In Arbeitsstellung
(leitend)
An
Durchgeschaltet
1
2
Technisch/ Physikalisch existieren Toleranzbereiche, „Nichtentscheidbarkeitsbereiche“
8
x(t)
xbin
ES
1
0
t
t
Zuordnung
x(t)
TO
xbin
1
TU
0
t
t
ES = Entscheidungsschwelle, T = Threshold = Schwelle, ■ Unentscheidbarkeitsbereiche
1.2.3
Binäre Variable
𝑥 ∈ {0,1} = 𝐵, Belegungsmenge
Einheit: 1 Bit, Binary Digit (Binärzahl) = Informationsatom
1.2.4
Binärvektoren
𝑥 = (𝑥1 , … , 𝑥𝑘 ) ∈ {0,1}𝑘 = 𝐵 𝑘
Bk repräsentiert die Menge aller k-stelligen binären Belegungsvektoren und enthält 2k
Elemente.
Mächtigkeit der Menge: |𝐵1 | = 21 = 2, |𝐵 2 | = 22 = 4
Eine konkrete Auswahl eines Binärvektors 𝑐 = (𝑐1 , 𝑐2 , … , 𝑐𝑘 ) ∈ 𝐵 𝑘 zur wertmäßigen
Konkretisierung der Variablen x1 bis xk heißt Belegungsvektoren.
1.2.5
Binäre Funktion
Abbildung 𝑓: 𝐵 𝑘 → 𝐵
Schreibweise: 𝑦 = 𝑓(𝑥1 , … , 𝑥𝑘 ) = 𝑓(𝑥) ∈ {0,1}
Binäre Vektorfunktion (Funktionenbündel) 𝑓: 𝐵 𝑘 → 𝐵 𝑛 mit 𝑦1 = 𝑓1 (𝑥), … , 𝑦𝑛 = 𝑓𝑛 (𝑥) und
𝑥 ∈ 𝐵𝑘
Blockschaltbild-Interpretation für Eingrößensystem:
x
f(x)
y
9
Blockschaltbild-Interpretation für Mehrgrößensystem:
x
1.2.6
a)
f(x)
y
x
f(x)
y
Mathematische Modelle für binäre Funktionen
Funktionswerte-/Wahrheitstabelle
Binäre Funktionen einer Variablen: 𝑦 = 𝑓(𝑥) mit 𝑥, 𝑦 ∈ 𝐵1
(verschiedene Ausgangverhalten bei den möglichen Eingangsbelegungen)
x f0 f1 f2 f3
0 0 1 0 1
1 0 0 1 1
f0, f3 triviale Konstantenfunktion
1
Wie viele Funktionen 𝑛𝑓𝑘 gibt es über B1?  𝑛𝑓1 = 4 = 22 = 22
Binäre Funktionen von 2 Variablen:
x1 x2 f0 f1 f2 f3 f4 f5 f6 f7
0 0 0 1 0 1 0 1 0 1
0 1 0 0 1 1 0 0 1 1
1 0 0 0 0 0 1 1 1 1
1 1 0 0 0 0 0 0 0 0
2
 𝑛𝑓2 = 16 = 24 = 22
Allgemein gilt: Die Anzahl der binären
f8
0
0
0
1
f9 f10 f11 f12 f13 f14 f15
1 0 1 0 1 0 1
0 1 1 0 0 1 1
0 0 0 1 1 1 1
1 1 1 1 1 1 1
Funktionen über Bk in Form von 𝑦𝑖 = 𝑓𝑖 (𝑥) mit 𝑥 ∈
𝑘
𝑘
𝐵 𝑘 in Abhängigkeit von k Variablen beträgt 𝑛𝑓𝑘 = 22 = 2𝑛𝑥
10
10
Beispiel: 𝑘 = 10  𝑛10
= 1024  22 = 21024 ≈ 10300
𝑥 =2
𝑛𝑥 = Anzahl der Argumentvarianten
𝑛𝑓 = Anzahl der Funktionswerte
b)
Dezimalkennzeichnung
Beispiel: BCD (Binary Coded Decimal)
x2
x1
x0
f(x)
dez(x)
0
0
0
0
0
0
0
1
0
1
0
1
0
1
2
0
1
1
1
3
1
0
0
0
4
1
0
1
1
5
1
1
0
0
6
1
1
1
1
7
Binärdarstellung der Zahlen beliebige Dezimaldarstellung
Funktion
der Zahlen
𝑥 = 𝑏𝑖𝑛(𝑥)
Dezimalkennzeichnung von 𝑓(𝑥): 𝑓[𝑑𝑒𝑧(𝑥)] = {𝑑𝑒𝑧(𝑥)|𝑓(𝑥) = 1} = {2,3,5,7}
10
c)
Dezimaläquivalent der f-Spalte (Summe der 2er-Potenzen von dez(x))
siehe Beispiel: 𝑓𝑑𝑒𝑧 = 22 + 23 + 25 + 27 = 172
Eindeutige Kennzeichnung von f, aber Zahlen eventuell sehr groß und wenig für Operationen
mit f geeignet.
d)
Listendarstellung
BVL = Binärvektorliste = {𝑥|𝑓(𝑥) = 1} (Zeilen der TVL sind Lösungen der Funktion
(Konjunktionen))
𝑥2 𝑥1 𝑥0
0 1 0
𝑓(𝑥) = 0 1 1 = Menge von Binäevektoren
1 0 1
1 1 1
Kompaktere Darstellung oft in TVL = Ternärvektorliste (dreiwertig: 0, 1, -) (drittes Zeichen
beliebig, meist ein waagerechter Strich oder φ)
Mathematische Begründung: Tautologie 𝑥 ∨ 𝑥 = 1 (stets wahr)
𝑎 𝑏
𝑎 𝑏
Weiter gilt: 𝑎𝑏𝑎𝑏 = 𝑎 ∙ (𝑏 ∨ 𝑏) = 𝑎 → 1 0 →
1 −
1 1
𝑥2 𝑥1 𝑥0
𝑥2 𝑥1 𝑥0
0 1 0
zu Beispiel: 𝑓(𝑥) = 0 1 1 = 0 1 −
1 0 1
1 − 1
1 1 1
𝑥2 𝑥1 𝑥0 ∨ 𝑥2 𝑥1 𝑥0 = 𝑥2 𝑥1 ∙ (𝑥0 ∨ 𝑥0 ) = 𝑥2 𝑥1 ∙ 1 = 𝑥2 𝑥1
e)
Karnaugh-Plan (KP, K-map), bzw. Karnaugh-Veitch-Diagramm (KVD, KV-Diagram)
Ein KP ist eine rechteckige Anordnung von Funktionswerten f(x), wobei die den Zeilen und
Spalten zugeordneten Belegungsteilvektoren von x in Gray-Code angegeben werden.
zu Beispiel: → [𝑓(𝑥2 𝑥1 𝑥0 ) = 1][(𝑥2 = 0) ∧ (𝑥1 = 1) ∧ (𝑥0 = 0)]
x2
0 0 1
1 0 0
0 1
0 0
𝑥1
f(x)
1
1
1
1
0
1
0
1
0
 x2| 0
x1
x0
1
0
f(x)
1 0
1 1
𝑥0
Im rechten Diagramm werden die Spalten/ Zeilen mit einem Strich markiert, in der die
jeweilige Variable 1 ist.
Für algebraische Darstellung vergleiche BVL, d.h. sammeln aller Elementarkonjunktionen
EK, für die gilt 𝑓(𝑥) = 𝑓(𝐸𝐾𝑥 ) = 1.
𝑓(𝑥) = 𝑥2 𝑥1 𝑥0 ∨ 𝑥2 𝑥1 𝑥0 ∨ 𝑥2 𝑥1 𝑥0 ∨ 𝑥2 𝑥1 𝑥0
11
2n zusammenhängende Einsfelder kann man auch vor dem Auslesen zusammenfassen.
x1
f(x)
0 1
x2| 0 0
1
1
0
1
x0
𝑓(𝑥) = 𝑥2 𝑥1 ∨ 𝑥2 𝑥0
zu Gray-Code:
Von Codewort zu Codewort ändert sich genau eine Stelle. Zyklisch fortsetzbar.
Symmetrieeigenschaften. In 𝑥10 – Spalten wellenförmige ‚0’ und ‚1’– Fortschreibung mit der
Periode 2i+2.
Codetabelle:
x3 x2 x1 x0
xi
0 0 0 0
0 0 0 1 Nebensymmetrieachse
0 0 1 1
0 0 1 0 Nebensymmetrieachse
0 1 1 0
0 1 1 1
0 1 0 1
0 1 0 0 Hauptsymmetrieachse
1 1 0 0
1 1 0 1
1 1 1 1
1 1 1 0
1 0 1 0
1 0 1 1
1 0 0 1
1 0 0 0
x3 höchstwertigste Spalte, an Symmetrieachsen wird gespiegelt, jede Spalte beginnt mit 2i
Nullen
Beispiel: KP mit 4 Variablen
c d
g(x)
0 0 0 0 1 0
0 1 1 0 1 1
𝑐|
b
a
g(x)
0 0 1 0
1 0 1 1
↔
1 1 1 0 1 1
1 0 1 0 1 0
0 1 1 0
0 0 1 1
𝑏
1 0 1 1
1 0 1 0
𝑎
|𝑑
↔ D(g) =
a b c d
1 1 - - 0 - 1
0 0 1 1 -
- 1
D(g) = Disjunktive Funktion
Schritte beim Auslesen:
Möglichst große zusammenhängende Einsfelder (nur 2n viele Felder, die zusammen eine
rechteckige Figur formen) bilden. Jede Eins muss in mindestens einem Feld berücksichtigt
werden.
12
Diese Auslesen und den Variablen nach folgendem Schema Werte in der TVL zuweisen:
- wenn Feld nur 0 der Variable überdeckt, dann ist Variable auch 0 in TVL
- wenn Feld nur 1 der Variable überdeckt, dann ist Variable auch 1 in TVL
- wenn Feld sowohl 0 und 1 der Variable überdeckt, dann ist sie in TVL „–“, wird also in
der Konjunktion nicht berücksichtigt
In dem Fall ■ überdeckt das Feld die Variable b nur bei 0, die Variable d nur bei 1, die
Variablen a und c sowohl bei 1 und 0, dadurch ergibt sich für die Konjunktion 𝑏𝑑.
Für die gesamte Funktion: 𝑔(𝑥) = 𝑎𝑏 ∨ 𝑎𝑑 ∨ 𝑏𝑑 ∨ 𝑎𝑏𝑐
Redundante (überflüssige) Konjunktion ■ entfernen, da alle Einsen schon von anderen
Konjunktionen überdeckt werden. So ergibt sich: 𝑔(𝑥) = 𝑎𝑏 ∨ 𝑏𝑑 ∨ 𝑎𝑏𝑐
Beispiel: KP mit 5 Variablen
d e
h(x)
0 0
0 1
1 1
1 0
0 1 1 0 0 1 1 0
c
0 0 1 1 1 1 0 0 b
0 0 0 0 1 1 1 1
a
f)
Boolescher Raum (Bk, RE = Raumstruktur, rierende Eigenschaft)
g)
Entscheidungsbäume
BDD = Binary Decision Diagramm
zu Beispiel:
𝑥2
0
𝑓(𝑥) = 0
1
1
𝑥1
1
1
0
1
𝑥0
𝑥2 𝑥1 𝑥0
0
1 = 0 1 −
1
1 − 1
1
Im BDD entspricht jeder Pfad genau einer Belegung.
Wurzelknoten
root-node
f
x0
V1
0
1
V2
x1
0
1
V4
x2
0
V5
0
1
0
0
innere Knoten
internal nodes
V3
0
1
1
V6
1
0
0
V7
1
0
1
13
0
1
1
1
Endknoten
terminal nodes
(enthalten f-Werte)
Siehe ob es in oberer Tabelle Kombinationen gibt, wenn nicht dann 0.
Reduzierung des Baumes:

nur jeweils einen ‚0’ und ‚1’ TN (Terminal Node)

TVL-Regeln 𝑎𝑏 ∨ 𝑎𝑏 = 𝑎  Knoten von a entfällt
f
x0
f
V1
0
1
V2
x1
x2
0
V3
1
0
1
V4
V5
V6
V7
1
0
0
1
0
1
V2
0
1
V1
0
0
V3
0
1
1
1
1
0
V5
V6
0
0
1
1
0
1
V4 und V7 entfallen, weil sie redundant sind.
h)
Algebraische Funktionsdarstellung
Grundlegende Beweismittel. Siehe Umdruck (Skript) „Boolesche Formen“ (BF).
Einfachste Formen: Konstanten 0, 1 und Variablen x0, x1, …, xk (oder auch a, b, c, …, etc.)
Beispiel: 𝑓1 (𝑥) = 0 = 0(𝑥), 𝑓2 (𝑥) = 𝑥1 , 𝑓3 (𝑥) = 𝑥2
BF höheren Grades: Verknüpfung mit ∨ (Disjunktion, OR) und ∧ (Konjunktion, AND)
Beispiel: 𝑓4 (𝑥) = 𝑓2 ∧ 𝑓3 = 𝑥1 ∧ 𝑥2 = 𝑥1 𝑥2  [𝑓4 (𝑥) = 1]  [(𝑥1 = 1) ∧ (𝑥2 = 0)] 
[(𝑥1 = 1) und (𝑥2 = 0)]
Beispiel: 𝑓5 (𝑥) = 𝑓2 ∨ 𝑓3 = 𝑥1 ∨ 𝑥2  [𝑓5 (𝑥) = 1]  [(𝑥1 = 1) ∨ (𝑥2 = 0)]
Auslesen einer BF aus BVL, Funktionswertetabelle, KP, etc.
Alle Belegungen 𝑐 ∈ 𝐵 𝑘 mit 𝑓(𝑐) = 1 werden als Konjunktion mit den Variablen 𝑥𝑖 ∈ 𝑥
ausgelesen, wobei gilt:
(𝑐𝑖 = 1)  (xi in Konjunktion)
a)
(𝑐𝑖 = 0)  (𝑥𝑖 in Konjunktion)
b)
(𝑐𝑖 = −)  (xi nicht in Konjunktion)
c)
Die ausgelesene Konjunktion von f(x) werden alle disjunktiv zu einer BF von f(x) verknüpft
 D(f).
14
zu Beispiel:
𝑥2
0
𝑓(𝑥) = 0
1
1
𝑥1
1
1
0
1
𝑥0
𝑥2 𝑥1 𝑥0
0
1 = 0 1 −
1
1 − 1
1
𝑓(𝑥) = 𝑥2 𝑥1 𝑥0 ∨ 𝑥2 𝑥1 𝑥0 ∨ 𝑥2 𝑥1 𝑥0 ∨ 𝑥2 𝑥1 𝑥0 = 𝑥2 𝑥1 ∨ 𝑥2 𝑥0
siehe e) für mehr Informationen
1.3
Elementare Funktionen,
Verknüpfungsgatter
Operationen,
Binäre Funktion als Verhaltensmodell von Schaltnetzen.
Ziel: Verhaltensanalyse (Gesamtverhalten ermitteln)
c
x
f(x)
0
a 1
b
0 1 1 0
0 1 1 0
b
c
0 0 1 1
a
0 0 1 0
c
g(x)
0
0 1 0 0
1
1 1 1 0
0 1 1 0
b
0 0 1 1
a
y1=f(x)
y2
h*(y)
0
1 1
1
0 1
y2=g(x)
0 1
z=h*(y)=h(x)
y1
gesucht ist ℎ(𝑥)
Abbildungsprodukt
𝑧 = ℎ∗ [𝑦2 , 𝑦1 ] = ℎ[𝑔(𝑎, 𝑏, 𝑐), 𝑓(𝑎, 𝑏, 𝑐)] = ℎ(𝑎, 𝑏, 𝑐) = ℎ(𝑥)
Gesamtverhalten 𝑧 = ℎ(𝑥):
c
h(x)
a
0
1 1 1 1
b
1
0 0 1 1
c
z=h(x)
0 1 1 0
b
0 0 1 1
a
15
Gesetze,
Schauen nach Zustand von a, b, c → herausfinden von y1, y2 → nachschauen in ℎ∗ (𝑦)
Tabelle, was es nun wird → erhaltener Wert für ℎ∗ (𝑦) in ℎ(𝑦) Tabelle für a, b, c Zustände
eintragen.
In ℎ(𝑥) genau die doppelte Anzahl von Nullen und Einsen wie in ℎ∗ [𝑦2 , 𝑦1 ].
Problem: unhandliche, dimensionsbegrenzte Darstellung in KP  Nutzung anderer Modelle
unter Einführung geeigneter Operationen
1.3.1

Hardware-Realisierungsmöglichkeiten von Booleschen Operationen
Kontaktschaltungen KS mit 1 Kontakt (Ursprungsform/ Strompfade = Leitwertlogik)
𝑓 = 1 wenn Lampe leuchtet, AK = Arbeitskontakt, RK = Ruhekontakt
f1
f2
+
+
f3
+
f2
f1
AK
BF
a
RK
a
f1
0
0
1
1
𝑓1 = 𝑎
Identität
a
0
1
f4
+
f3
f4
a
f2
1
0
𝑓2 = 𝑎
Negation/NOT
a
f3
a
f4
0
1
0
0
1
1
1
0
𝑓3 = 1
𝑓4 = 0
immer 1
immer 0
Konstant-/Trivialfunktionen
Realisierung mir Relais (R betätigt r):
+
+
R

r
RK
f2=a
Gatterschaltungen mit 1 Kontakt (Potenziallogik eventuell gemischt mit Leitwertlogik)
zu f2: Negator
DIN 44300, 40900 (Verknüpfungsschaltungen und Schaltsymbole)
a
1
f2=a
16
CMOS (Complementary Metal Oxide Surface)-Schaltungen für Inverter/Negator:
(Transistoren im Bild vom Anreicherungstyp (Enhancement Type))
Strom fließt nur wenn
+
Tp
Tp
high
low
p-leitend
a
low
f2=a
n-leitend
Strom fließt nur wenn
Tn
high
high
low
Tn
a
0
Potenziale
1
Tn
Tp
f
0
1
1
1
0
0
Leitwertlogik
Wenn 𝑎 = 0 fließt über Tp Strom zu f2.
Nur im Umschaltmoment fließen Ströme (hohe Frequenzen → hohe Ströme), sonst recht
effektiv. 0 und 1 sind Potenziale bei a (z.B. -5V, 5V).

Kontaktschaltungen mit 2 Kontakten
f5
f6
+
+
f5
f6
a
a
b
b
a b f5
a b f6
0 0 0
0 0 0
0 1 0
0 1 1
1 0 0
1 0 1
1 1 1
1 1 1
𝑓5 = 𝑎 ∧ 𝑏 = 𝑎𝑏
𝑓2 = 𝑎 ∨ 𝑏 = 𝑎 + 𝑏
BF
Reihenschaltung, UND (AND) Parallelschaltung, ODER (OR)

Gatterschaltungen mit 2 Kontakten
zu f5: UND-Gatter
a
b
&
f5=ab
17
zu f6: ODER-Gatter
a
b
1
f6=ab
NAND (NOT-AND)-Gatter:
nach De Morgan: 𝑓NAND = 𝑎𝑏 = 𝑎 ∨ 𝑏
a
0
0
1
1
b fNAND
0
1
1
1
0
1
1
0
wenn 𝑎 = 𝑏 = 1, dann 𝑓 = 0, sonst 1
Schaltsymbol
Kontaktschaltung
CMOS-Schaltung
+
+
a
b
a
&
p
b
fNAND
p
fNAND
fNAND
a
a
b
b
n
n
Definition: Die mathematische Struktur (Trägermenge: Binärvektoren Bk, Operationen: ∧, ∨,
Negation) heißt Boolescher Verband (BV)
1.3.2
Rechenregeln für Boolesche Ausdrücke
𝑎∨𝑎 =𝑎
𝑎 ∨ 𝑎𝑏 = 𝑎 ∨ 𝑏
und noch viele mehr
1.3.3
Analyse und Vereinfachung von Kontaktschaltungen
Methoden:

Reihen- und Parallelschaltungen extrahieren (Reihe =∧, Parallel =∨)
Beispiel: Schaltungen aus Schließer oder Öffner (Negierte Logik). Beim Auslesen muss man
sich fragen, was getan werden muss, damit Strom fließt? (betätigen = 1, nichts tun = 0)
18
+
a
b
a
c
𝑎∨𝑏
(𝑎 ∧ 𝑏) ∨ 𝑐
b
f
Verknüpfung der beiden Teile durch UND (Reihenschaltung) → (𝑎 ∨ 𝑏) ∧ ((𝑎 ∧ 𝑏) ∨ 𝑐)
𝑓 = 𝑎𝑐 ∨ 𝑎𝑎𝑏
⏟ ∨ 𝑏𝑐 ∨ 𝑎𝑏𝑏
⏟ = 𝑎𝑐 ∨ 𝑏𝑐 = (𝑎 ∨ 𝑏) ∧ 𝑐
0
0
dadurch reduziert sich die Schaltung zu
+
a
b
c
f

alle möglichen Strompfade (Teilfunktionen, Konjunktionen → Reihenschaltung)
extrahieren und disjunktiv (ODER) verknüpfen
𝑓 = 𝑎𝑎𝑏 ∨ 𝑎𝑐 ∨ 𝑏𝑎𝑏 ∨ 𝑏𝑐 = 𝑎𝑐 ∨ 𝑏𝑐 = (𝑎 ∨ 𝑏) ∧ 𝑐
1.3.4
Antivalenz-Operation (XOR): ≁, ↮, 
Funktion ist gleich 1, wenn die Anzahl aller mit 1 belegten Variablen ungerade ist.
a
0
0
1
1
b
0
1
0
1
f
0
1
1
0
𝑓≁ = 𝑎 ≁ 𝑏 = 𝑎̅𝑏 ∨ 𝑎𝑏̅
a
b
=1
f ~
19

Eigenschaften und Regeln (siehe auch Anhang)
𝑥 ≁ 𝑦 = 1 ≁ (𝑥 ≁ 𝑦) = 𝑥̅ ≁ 𝑦 = 𝑥 ≁ 𝑦̅
𝑥 ≁ 𝑎 = 𝑏 → beide Seiten mit ≁ 𝑎 erweitern → 𝑎 ≁ 𝑏 = 𝑥 → Umformen möglich
Homogenisieren: wenn 𝑎 = 𝑏 → 𝑎 ≁ 𝑏 = 0
Definition: Die mathematische Struktur (Vektor von Variablen Bk, ∧, ≁) ist ein Ring, der
wegen
𝑎≁𝑎=0
und
𝑎∧𝑎 =𝑎
als
Boolescher
Antivalenz-Ring
𝐵𝑅≁ (𝑘) bezeichnet wird.
BV = Boolescher Verband
BR = Boolescher Ring
Umrechnungsgesetze 𝐵𝑉(𝑘) ⇔ 𝐵𝑅≁ (𝑘)
𝐵𝑅≁ (𝑘)
𝑎 ≁ 𝑏 ≁ 𝑎𝑏
1≁𝑎
𝑎≁𝑏
𝐵𝑉(𝑘)
𝑎∨𝑏
𝑎
𝑎𝑏 ∨ 𝑎𝑏
Äquivalenz-Operation (XAND): ~, , , ⨀
1.3.5
Funktion ist gleich 1, wenn die Anzahl aller mit 0 belegten Variablen gerade ist.
a
0
0
1
1
b
0
1
0
1
f
1
0
0
1
𝑓~ = 𝑎~𝑏 = 𝑎𝑏 ∨ 𝑎𝑏
a
b

=
f~
Eigenschaften und Regeln (siehe auch Anhang)
𝑥~𝑎 = 𝑏 → beide Seiten mit ~𝑎 erweitern → 𝑎~𝑏 = 𝑥 → Umformen möglich
Auch Homogenisieren möglich.
Definition: Die mathematische Struktur (Vektor von Variablen Bk, ∨, ~) ist ein Ring, der
wegen 𝑎~𝑎 = 1 und 𝑎𝑎 = 𝑎 als Boolescher Äquivalenz-Ring 𝐵𝑅~ (𝑘) bezeichnet wird.
Umrechnungsgesetze 𝐵𝑉(𝑘) = 𝐵𝑅~ (𝑘)
𝐵𝑉(𝑘)
𝐵𝑅~ (𝑘)
𝑎∧𝑏
𝑎
𝑎𝑏 ∨ 𝑎𝑏
𝑎~𝑏~(𝑎 ∨ 𝑏)
0~𝑎
𝑎~𝑏
20
1.3.6
Orthogonalität-Lemma
Definition: Gilt für eine Menge f1, …, fn von binären Funktionen 𝑓𝑖 = 𝑓𝑖 (𝑥) mit 𝑥 ∈ 𝐵 𝑘 die
Bedingung ∀𝑖 ≠ 𝑗: 𝑓𝑖 (𝑥) ∧ 𝑓𝑗 (𝑥) = 0(𝑥), so heißen diese Funktionen orthogonal zueinander
und es folgt
𝑛
𝑛
⋁ 𝑓𝑖 (𝑥) = ∑ 𝑓𝑖 (𝑥)
𝑖=1
𝑖=1
orthogonal!
Hinweis: im Allgemeinen gilt 𝑓𝑖 (𝑥) ∨ 𝑓𝑗 (𝑥) = 𝑓𝑖 ≁ 𝑓𝑗 ≁ 𝑓𝑖 ∧ 𝑓′𝑗 = 0, wenn fi orthogonal fj
Beispiel:
x2
0 1 0 1 1
1 0 1 1 0
0 1 1 0 x1
0 0 1 1 x0
■ 𝑓1 (𝑥), ■ 𝑓2 (𝑥), ■ 𝑓3 (𝑥)
Orthogonalität bedeutet nicht überlappende Felder im KP → 𝑓1 ⊥ 𝑓2 ⊥ 𝑓3
im Bk
011
001
x2
111
101
010
110
x1
x0
000
100
Disjunkte Mengen von Belegungsvektoren „on-sets“
𝑥0 𝑥1 𝑥2
𝐷(𝑓1 ) =
𝐷(𝑓2 ) =
𝐷(𝑓3 ) =
1.4
− 0 0
1 1 −
0 1 1
Entwicklungs-/ Zerlegungssätze und Normalformen
𝑓(𝑋) = 𝑓 ( ⏟
𝑎 , 𝑃) mit 𝑃 = Parametervariable
𝑥0
1.4.1
Normalform (NF)
Standarddarstellung für Funktionenmengen mit funktionscharakteristischen Koeffizienten

Kanonische Funktionsdarstellungen („gerade, regelmäßig, mit Wiederholstruktur, …“)
21


in den kanonischen Normalformen werden die Funktionen nach allen Variablen
entwickelt und die kanonischen Normalformen sind den binären Funktionen eindeutig
zugeordnet
Entwicklungs-/ Zerlegungssätze dienen zur Koeffizientenbestimmung
1.4.2
Disjunkte Zerlegung
Ansatz: 𝑓(𝑥) = 𝑓 (𝑎, 𝑥1 ) = 𝑎𝑝 (𝑥1 ) ∨ 𝑎𝑞 (𝑥1 )
p, q = Restfunktionen / Teilfunktionen / Kofaktoren
𝑎 = 0: 𝑓 = 𝑝 (𝑥1 )
𝑎 = 1: 𝑓 = 𝑞 (𝑥1 )

Boole-Shannon-Zerlegungssatz
𝑓(𝑥) = 𝑎 ∙ 𝑓(𝑎 = 0) ∨ 𝑎 ∙ 𝑓(𝑎 = 1) = 𝑎 ∙ 𝑓0 ∨ 𝑎 ∙ 𝑓1
orthogonal: 𝑓(𝑥) = 𝑎̅ ⋅ 𝑓(𝑎 = 0) ≁ 𝑎 ⋅ 𝑓(𝑎 = 1)
Beispiel:
c
0 0 0
1 1 1
0 1
0 0

f(x)
0
1
1
1
1
1
0 b
1 a

c
p=f(a=0)
0 0 0
1 1 1
0 1 b
c
q=f(a=1)
0 1 0
1 1 1
0 1 b
Entwicklung nach 2 und 3 Variablen
𝑓(𝑎, 𝑏) = 𝑎𝑓(0, 𝑏) ∨ 𝑎𝑓(1, 𝑏) = 𝑎 ∙ [𝑏𝑓(0,0) ∨ 𝑏𝑓(0,1)] ∨ 𝑎 ∙ [𝑏𝑓(1,0) ∨ 𝑏𝑓(1,1)]
Kanonische Disjunkte Normalform: 𝐷𝑁𝐹(𝑓) = 𝑎𝑏𝑓0,0 ∨ 𝑎𝑏𝑓0,1 ∨ 𝑎𝑏𝑓1,0 ∨ 𝑎𝑏𝑓1,1
Bei mehr Variablen alle möglichen Varianten (2n Funktionen, n = Anzahl der Variablen).
fx,y = Funktionswert für die Belegung mit a = x, b = y
zu Beispiel:
𝐷𝑁𝐹(𝑓) = 𝑎𝑏𝑐
⏟ ∨ 𝑎𝑏𝑐 ∨ 𝑎𝑏𝑐 ∨ 𝑎𝑏𝑐 ∨ 𝑎𝑏𝑐
Elementarkonjunktion
𝑘
𝐸𝐾(𝑐, 𝑥) = ⋀(𝑐𝑖 ~𝑥𝑖 )
𝑖=1
𝐷𝑁𝐹(𝑓) = ⋁ 𝐸𝐾(𝑐, 𝑥) ∙ 𝑓(𝑐)
∀𝑐∈𝐵𝑘
c = Variable (nicht mit c verwechseln), k = Anzahl aller Variablen
Verkürzte Form für alle EK, die c enthalten, in KV 4 Stück, ganze Reihe.
Für alle Funktionswerte = 1 werden die Konjunktionen herausgeschrieben, Nullen bei
Variablen durch Negation ausgedrückt.
22
abc
000
001
011
010
110
111
101
100
𝑐 ∈ 𝐵3
f(x)
0
1
1
0
0
1
1
1
EK
ED
𝑎∨𝑏∨𝑐
𝑎𝑏𝑐
𝑎∨𝑏∨𝑐
𝑎𝑏𝑐
𝑎𝑏𝑐
𝑎∨𝑏∨𝑐
𝑎𝑏𝑐
𝑎∨𝑏∨𝑐
𝑎𝑏𝑐
𝑎∨𝑏∨𝑐
𝑎𝑏𝑐
𝑎∨𝑏∨𝑐
𝑎∨𝑏∨𝑐
𝑎𝑏𝑐
𝑎∨𝑏∨𝑐
𝑎𝑏𝑐
zu DNF,
zu KNF,
𝑓(𝑐)
1 dominant 0 dominant
Elementardisjunktionen (ED), bei denen f(x) = 0 ist, werden mit UND zur Konjunktive
Normalform (KNF) verknüpft. EDs sind die Negation nach De Morgan der EKs (z.B. EK =
𝑎̅𝑏̅𝑐̅ ⟶ ED = EK = 𝑎̅𝑏̅𝑐̅ = 𝑎 ∨ 𝑏 ∨ 𝑐).
Elementarkonjunktionen (EK), bei denen f(x) = 1 ist, werden mit ODER zur Disjunktiven
Normalform (DNF) verknüpf.
Technische Interpretation der DNF: Multiplexer (MUX)
zu Beispiel: MUX3 bzw. MUX 8-to-1 (1 aus 8)
a, b, c = Adresse, Selektierungs-/ Steuervariable
a=1
a=0
b=1
a=1
a=0
a=1
b=0
a=0
b=1
c=1
a=1
a=0
b=0
c=0
f(0,0,0)
…
MUX
8-to-1
f(c)
f(1,1,1)
a b c
Jede binäre Funktion ist schaltungstechnisch realisierbar, d.h. das Syntheseproblem ist stets
allgemein lösbar.
1.4.3
Konjunktive Normalform (KNF)
𝑔(𝑥) = 𝑓(𝑥)
𝑔(𝑎) = 𝑎𝑔(𝑎 = 0) ∨ 𝑎𝑔(𝑎 = 1)
𝑓(𝑎) = 𝑎𝑓(𝑎 = 0) ∨ 𝑎𝑓(𝑎 = 1)
𝑓(𝑎) = (𝑎𝑓0 ) ∧ (𝑎𝑓1 )
𝑓(𝑎) = [𝑎 ∨ 𝑓(𝑎 = 0)] ∧ [𝑎 ∨ 𝑓(𝑎 = 1)]
23
𝑓(𝑎, 𝑏) = [𝑎 ∨ 𝑏 ∨ 𝑓0,0 ] ∙ [𝑎 ∨ 𝑏 ∨ 𝑓0,1 ] ∙ [𝑎 ∨ 𝑏 ∨ 𝑓1,0 ] ∙ [𝑎 ∨ 𝑏 ∨ 𝑓1,1 ]
In Elementardisjunktionen (ED) werden Variablen negiert, wenn sie gleich 1 sind. Z. B.
Wenn 𝑎 = 0, nicht 𝑎 eintragen, sondern a. Gleiches gilt für das Eintrag in den KV: a bedeutet
𝑎 = 0.
Alle EDs mit 𝑓 = 0 werden durch Konjunktionen zur KNF verknüpft. EDs mit 𝑓 = 1 fallen
automatisch wegen ODER Verknüpfung heraus.
zu Beispiel:
KNF(𝑓) = [𝑎 ∨ 𝑏 ∨ 𝑐] ∙ [𝑎 ∨ 𝑏 ∨ 𝑐] ∙ [𝑎 ∨ 𝑏 ∨ 𝑐]
Zur Bestimmung der KNF aus der DNF wird zunächst die DNF doppelt negiert:
DNF(𝑓) = 𝑎𝑏𝑐 ∨ 𝑎𝑏𝑐 ∨ 𝑎𝑏𝑐 ∨ 𝑎𝑏𝑐 ∨ 𝑎𝑏𝑐 = 𝑎𝑏𝑐 ∨ 𝑎𝑏𝑐 ∨ 𝑎𝑏𝑐 ∨ 𝑎𝑏𝑐 ∨ 𝑎𝑏𝑐
Auflösen der ersten Negation nach De Morgan und Ausmultiplizieren:
(𝑎 ∨ 𝑏 ∨ 𝑐)(𝑎 ∨ 𝑏 ∨ 𝑐)(𝑎 ∨ 𝑏 ∨ 𝑐)(𝑎 ∨ 𝑏 ∨ 𝑐)(𝑎 ∨ 𝑏 ∨ 𝑐) = 𝑎𝑏𝑐 ∨ 𝑎𝑏𝑐̅ ∨ 𝑎𝑏𝑐̅
Abschließend zweite Negation nach De Morgan:
(𝑎 ∨ 𝑏 ∨ 𝑐)(𝑎 ∨ 𝑏 ∨ 𝑐)(𝑎 ∨ 𝑏 ∨ 𝑐) = KNF(𝑓)
Eine binäre Funktion f(x) heißt eineindeutig in DNF(f) [bzw. KNF(f)] dargestellt, wenn sie
nach allen Variablen von 𝑥 ∈ 𝐵 𝑘 disjunktiv [konjunktiv] zerlegt wurde. Sie besteht aus so
vielen 𝐸𝐾(𝑐, 𝑥) / Maxterme [𝐸𝐷(𝑐, 𝑥) / Minterme] wie die Funktion Einswerte [Nullwerte]
besitzt.
Wegen Orthogonalität gilt:
𝐷𝑁𝐹(𝑓) = ⋁ 𝐸𝐾(𝑐, 𝑥) ∙ 𝑓(𝑐) = ∑ 𝐸𝐾(𝑐, 𝑥) ∙ 𝑓(𝑐) = 𝐴𝑁𝐹(𝑓)
𝑐∈𝐵𝑘
𝑐∈𝐵𝑘
Antivalenz- und Disjunktive Normalform sind bis auf die Hauptoperationszeichen ∨ bzw. ≁
gleich.
𝐾𝑁𝐹(𝑓) = ⋀ [𝐸𝐷(𝑐, 𝑥) ∨ 𝑓(𝑐)] =
𝑐∈𝐵𝑘
 [𝐸𝐷(𝑐, 𝑥) ∨ 𝑓(𝑐)] = 𝐸𝑁𝐹(𝑓)
cB k
Äquivalenzform entspricht KNF mit unterschiedlichen Hauptzeichen.
Beispiel: 𝑓(𝑥) = 𝐸𝑁𝐹(𝑓) = (𝑎 ∨ 𝑏 ∨ 𝑐)~(𝑎 ∨ 𝑏 ∨ 𝑐)~(𝑎 ∨ 𝑏 ∨ 𝑐)
24
1.5
Transformation der Modelle und Formen
Grundlage: reine boolesche Formen
Schema:
Disjunktive Form
D(f)
Konjunktive Form
K(f)
BF, KP,
TVL
Orthogonalisierung
Antivalenzform
A(f)
1.5.1
Äquivalenzform
E(f)
K(f)  KP

Methode A: Klammern auflösen entsprechend Distributivgesetz („Ausmultiplizieren“),
K(f) → D(f)

Methode B: Negation von f(x) nach De Morgan → 𝑔(𝑥) = 𝑓(𝑥), Eintragen der Einsen
von g(x) und Negieren der Zelleninhalte
Beispiel:
𝑓(𝑥) = (𝑎 ∨ 𝑏)(𝑏 ∨ 𝑐 ∨ 𝑑)(𝑎 ∨ 𝑑)
𝑓(𝑥) = (𝑎 ∨ 𝑏)(𝑏 ∨ 𝑐 ∨ 𝑑)(𝑎 ∨ 𝑑)
𝑔(𝑥) = (𝑎 ∨ 𝑏) ∨ (𝑏 ∨ 𝑐 ∨ 𝑑) ∨ (𝑎 ∨ 𝑑) = 𝑎𝑏 ∨ 𝑏𝑐𝑑 ∨ 𝑎𝑑
c
0
0
1
1

d
0
1
1
0
1
1
1
1
0
0
1
0
0
0
1
0
1
1
1
0
1
1
g(x)
0
1
1
0
0 b
1 a

c
0
0
1
1
d
0
1
1
0
0
0
0
0
0
0
0
1
1
1
1
0
0
0
0
1
1
1
f(x)
1
0
0
1
0 b
1 a
Methode C: Direkter Weg über Eintragen der Nullen von f(x) unter Beachtung der
negierten Bedeutung der Variablen in den EDs (𝑎 = 0 und 𝑎̅ = 1). Das Bilden einer
K(f) aus einem KP erfolgt analog durch Auslesen der Nullen aus KP und Bildung der
disjunktiv verknüpften EDs, wobei die Variablen wieder negiert zu notieren sind.
𝑎 𝑏 𝑐 𝑑
orthogonal → 𝐷𝑜 (𝑓) = 0 1 − 1 = 𝑎𝑏𝑑 ∨ 𝑏𝑐𝑑 ∨ 𝑎𝑏̅𝑑̅
− 1 1 0
1 0 − 0
da orthogonal 𝐷𝑜 (𝑓)𝐴𝑜 (𝑓) = 𝑎𝑏𝑑 ≁ 𝑏𝑐𝑑̅ ≁ 𝑎𝑏̅𝑑̅
(im Allgemeinen 𝑥 ∨ 𝑦 = 𝑥 ≁ 𝑦 ≁ 𝑥𝑦)
25

Schematisierung des Eintragens von K(f) mittels TVL
𝑎 𝑏 𝑐 𝑑
𝑎 𝑏 𝑐 𝑑
geg.: 𝐾(𝑓) = 1 1 − − ↔ 𝐷(𝑓) = 0 0 − −
0 − 1 1
1 − 0 0
0 − − 0
1 − − 1
mit den Transformationsgleichungen 0 ↔ 1, 1 ↔ 0, −↔ −
Formale Schreibweise: TVL-Transformation 𝐷(𝑓) = 𝐾(𝑓)
Erkenntnisse: um eine K(f) zu erhalten, wird 𝑓(𝑥) = 𝑔(𝑥) benötigt als 𝐷(𝑓) = 𝐷(𝑔); 𝑓(𝑥)
kann z.B. erhalten werden, in dem aus dem KP für f(x) die Nullen ausgelesen werden (siehe
oben Methode C).
1.5.2
A(f)  KP
Überlagern der Einsen beachten → „Pünktchenmethode“:
1=1
1 ≁ 1 = 0 ↓ alternierend
1≁1≁1=1
Statt einer Eins wird ein Punkt in jedes Feld einer Elementarkonjunktion eingetragen. Am
Ende werden die Punkte durch eine Null ersetzt, wenn ihre Anzahl im Feld gerade ist, oder
durch eine Eins, wenn ihre Anzahl im Feld ungerade ist.
Auslesen von A(f) aus KP: Überlagerung der Einsen schwer kontrollierbar → Ao(f)
orthogonal auslesen.
Beispiel: 𝑓(𝑥) = 𝑎𝑏 ≁ ad ≁ bd ≁ acd
𝑏
𝑐|
• ••
• ••
𝑎
𝐴𝑜 (𝑓) = 0
1
1
(eventuell 𝑥
1.5.3
𝑏
•
••• •
|𝑑
••
•
𝑎
→
0
1
1
𝑐|
0
0
0
0
0
1
1
0
1
0
1
|𝑑
0
0
𝑎
𝑏 𝑐 𝑑
0 − 1 → 𝑓(𝑥) = 𝑎𝑏𝑑 ≁ acd ≁ a𝑏𝑑
− 0 1
1 − 0
= 1 ≁ x anwenden)
E(f)  KP
Überlagerung der Nullen beachten → „Pünktchenmethode“:
0=0
0~0 = 1 ↓ alternierend
0~0~0 = 0
26
Statt einer Null wird ein Punkt in jedes Feld einer Elementardisjunktion eingetragen. Am
Ende werden die Punkte durch eine Null ersetzt, wenn ihre Anzahl im Feld ungerade ist, oder
durch eine Eins, wenn ihre Anzahl im Feld gerade ist.
Beispiel: 𝑓(𝑥) = (𝑎𝑏)~(𝑏 ∨ 𝑑)~(𝑎 ∨ 𝑐 ∨ 𝑑)~(𝑐 ∨ 𝑑)
(𝑐 ∨ 𝑑 = 0 ↔ (𝑐 = 1) ∧ (𝑑 = 1))
↔
𝑐∙𝑑 =1
Hilfs-TVL:
𝑎
1
𝐸(𝑓) = −
1
−
𝑏
1
1
−
−
𝑐
−
−
0
0
𝑑
𝑎 𝑏
− 𝑁𝐷𝑀
0 0
𝐸(𝑓) = − 0
0 →
1
0 −
0
− −
𝑏
•
••
•••
𝑐|
••
•
•
𝑐 𝑑
− −
− 1
1 0
1 1
𝑏
•
|𝑑
••
•
𝑎
→
0
1
0
𝑐|
1
1
1
0
0
1
1
0
1
1
0
|𝑑
1
1
𝑎
Auslesen E(f) orthogonal als TVL (nach Nullen schauen).
𝑎 𝑏 𝑐 𝑑
𝑎 𝑏 𝑐 𝑑
0 − 1 1
1 − 0 0
0
1
1
0
𝐸𝑜 (𝑓) =
→ 𝐸0 (𝑓) = 1 0 0 1 = 𝐾0 (𝑓)
1 1 1 1
0 0 0 0
1 0 0 1
0 1 1 0
0 0 0 0
1 1 1 1
27
2.
Entwurf kombinatorischer Schaltsysteme
2.1
Syntheseprinzipien
2.1.1
Entwurfsgrundlage: Gatter (gate = Tor, Pforte)
DIN: verzögerungsfreies Verknüpfungselement / Operator → technische Realisierung einer
BF
2.1.2
Gatter- und Zweigschaltungen
Beispiel: 𝑓 = 𝑎𝑏 ∨ 𝑐
gate-type
branch-type
+
a
b
c
&
f
1
f
a
c
b
Realisierungsprinzip
gate-type
branch-type
Operator Gatterelement Kopplung (Struktur → RS: Reihenschaltung, PS: Parallelschaltung
Variable
Kopplung
Element (Kontakt)
2.1.3
Analyse des Verhaltens
Beispiel:
a
b
=1
f  a ~ b
a
b
&
a
&
b
v1
1
f‘(x)
v2
v1, v2 = Zwischenvariable, Teilfunktion
𝑣1 = 𝑎𝑏, 𝑣2 = 𝑎𝑏
𝑓 ′ (𝑥) = 𝑣1 ∨ 𝑣2 = (𝑎𝑏) ∨ (𝑎𝑏) = 𝑎 ≁ 𝑏

a)
b)
Analyseprinzip
Einführung von Zwischenvariablen (Teilfunktion)
Schrittweise Teilfunktion ersetzen
28
Beispiel:
a
&
&
g2
g1
&
&
b
f(x)
g3
𝑓(𝑥) = 𝑔2 𝑔3 = 𝑔2 ∨ 𝑔3
𝑔1 = 𝑎𝑏
𝑔2 = 𝑎𝑔1 = 𝑎 ∙ 𝑎𝑏 = 𝑎 ∨ 𝑎𝑏 = 𝑎 ∨ 𝑏
𝑔3 = 𝑏𝑔1 = 𝑏 ∙ 𝑎𝑏 = 𝑏 ∨ 𝑎𝑏 = 𝑏 ∨ 𝑎
𝑓(𝑥) = 𝑎𝑏 ∨ 𝑎𝑏 = 𝑎 ≁ 𝑏
2.1.4
Wesentliche Informationen zur Synthese



zu realisierende Funktion f(x) und eventuelle Nebenbedingungen (NB)
vorgegebene Realisierungsbasis (RB), z.B. NAND-Gatter
Grundstruktur (z.B. zweistufige Gatterschaltung)


RB: Grundmenge von Gattertypen (Teilfunktionen)
VRB: vollständige RB liegt vor, wenn damit eine beliebige binäre Funktion realisierbar
ist
2.2
Synthese von zwei- und mehrstufigen Schaltnetzen
2.2.1
Zweistufiges binäres System
Vorteile:

beliebige Funktion bei gegebener VRB realisierbar

hohe Arbeitsgeschwindigkeit

einfacher Entwurf (TVL-Algorithmen)

Zwischenschritt für Weiterentwurf
Nachteile:

im Allgemeinen erhöhter Schaltungsaufwand

technisch ist Forderung nach hoher Gattereingangszahl nicht erfüllbar
29
Prinzip:
?
x1
x2
?
x2
…
f(x)
?
?
xk
1., 2. Stufe
0. Stufe
(Negation)
hier homogene Ebenen (in einer Ebene nur gleiche Gatterart)
2.2.2
i)
ii)
Effektiver Synthesealgorithmus mit TVL
Grundstruktur und RB wählen, bzw. vorgegeben
Ansteuervariablen für Gatter der 1. Ebene aus zugeordneter TVL bestimmen (TVL
enthält Struktur-Info)
Anmerkung: 𝐷(𝑓) = 𝑁𝐷𝑀
NDM mit TVL: 0 → 1, 1 → 0,  → ; und Formänderung beachten
z.B. gilt 𝐾(𝑓) = 𝐷(𝑓) es folgt: 𝐾(𝑓) = 𝐷(𝑓) etc.
Beispiel 1: AND-OR
c
0 1 1
1 0 1
0 1
0 0
𝑎
𝐷(𝑓) = 0
0
1
c
&
a
&
b
a
&
c
f(x)
0
1
0 b
1 a
0
1
1
1
𝑏
−
1
−
1
𝑐
0= 𝑎
⏟
̅𝑐̅ ∨ 𝑎⏟
̅𝑏 ∨ 𝑎𝑐
⏟
− ⏟
𝐴𝑁𝐷 𝐴𝑁𝐷 𝐴𝑁𝐷
1
𝑂𝑅
f
Beispiel 2: NAND-NAND
𝑓 = 𝑓 = (𝑎
⏟̅𝑐̅) ∧ (𝑎̅𝑏) ∧ (𝑎𝑐)
𝑁𝐴𝑁𝐷
c
a
b
a
c
&
&
&
f
&
30
Beispiel 3: OR-AND (Nullen von KV auslesen)
𝑎 𝑏 𝑐 𝑁𝐷𝑀
𝑎 𝑏 𝑐
𝐷(𝑓) = 1 − 0 → 𝐷(𝑓) = 𝐾(𝑓) = 0 − 1 = 𝑓(𝑥) = (𝑎̅ ∨ 𝑐) ∧ (𝑎 ∨ 𝑏 ∨ 𝑐̅)
0 0 1
1 1 0
a
c
a
b
c
1
1
f
&
Beispiel 4: NOR-NOR (siehe Beispiel 3)
(𝑎̅ ∨ 𝑐) ∨ (𝑎 ∨ 𝑏 ∨ 𝑐̅)
𝑓(𝑥) = ⏟
𝑁𝑂𝑅
a
c
a
b
c
1
1
1
f
Beispiel 5: NOR-OR
𝑎 𝑏 𝑐
𝑎 𝑏 𝑐
𝑁𝐷𝑀
(𝑎 ∨ 𝑐) ∨ (𝑎
(𝑎̅ ∨ 𝑐̅)
𝐷(𝑓) = 0 − 0 → 𝐷(𝑓) = 1 − 1 → 𝑓(𝑥) = ⏟
⏟ ∨ 𝑏̅) ∨ ⏟
0 1 −
1 0 −
𝑁𝑂𝑅
𝑁𝑂𝑅
⏟
𝑁𝑂𝑅
0 − 0
1 − 1
𝑂𝑅
c
a
1
f
1 1
b
a
1
c
Nach zweifacher Negation, auflösen beider äußerer und einer inneren Negation.
Beispiel 6: OR-NAND (𝐷(𝑓))
𝑓(𝑥) = (𝑎𝑐)∧(𝑎𝑏̅) ∧ (𝑎̅𝑐̅)
c
a
b
a
c
1
1
&
f
1
Zweifache Gesamtnegation. Eine auflösen, dann innere auflösen, zweite äußere belassen.
Beispiel 7: NAND-AND
𝑎 𝑏 𝑐
𝐷(𝑓) = 1 − 0 → 𝑓(𝑥) = (𝑎𝑐̅
⏟) ∧ (𝑎
⏟̅𝑏̅𝑐)
𝑁𝐴𝑁𝐷
⏟
0 0 1
𝑁𝐴𝑁𝐷
𝐴𝑁𝐷
31
c
a
a
b
c
&
&
&
f
Beispiel 8: AND-NOR (𝐷(𝑓))
𝑓(𝑥) = (𝑎𝑐̅
⏟) ∨ (𝑎
⏟̅𝑏̅𝑐)
𝐴𝑁𝐷
⏟
𝐴𝑁𝐷
𝑁𝑂𝑅
c
a
a
b
c
&
&
1
f
𝐷(𝑓) → Einsen auslesen, Konjunktionen mit ODER verknüpfen
𝐾(𝑓) = 𝐷(𝑓)
→ Nullen auslesen, für 𝐾(𝑓) dann negieren. Wenn man Konjunktionen
durch ODER verknüpft = 𝑓(𝑥)
2.3
Einfache
Synthese
von
kombinatorischen Systemen
2.3.1
Grundprinzip: Anwendung des Assoziativgesetzes
mehrstufigen
Beispiel:
an
f(x)
ai+1
an
&
…
ai+1
&
&
…
ai
…
a1
ai
a1
&
&
f(x)
Noch weitere Aufspaltung möglich.
𝑓(𝑥) = 𝑎1 ∙ 𝑎2 … ∙ 𝑎𝑛 = (𝑎1 ∙ 𝑎2 ) ∙ (… ) ∙ (… ∙ 𝑎𝑛 )
2.3.2
a)
b)
Anwendungen
Die begrenzte Anzahl technisch realisierbarer Gattereingänge zwingt zum Empfang von
mehrstufigen Schaltungen.
Die Signaldurchlauf-/ Verzögerungszeiten in der Gesamtschaltung werden größer, aber
die Anzahl der Eingänge pro Gatter werden realisiert.
32

OR-Gatter
𝑓𝑂𝑅 = [(𝑏1 ∨ 𝑏2 ∨ … ∨ 𝑏𝑖 ) ∨ (𝑏𝑖+1 ∨ … ∨ 𝑏𝑛 )]

NAND-Gatter:
𝑓𝑁𝐴𝑁𝐷 = (𝑎1 ∙ … ∙ 𝑎𝑖 ) ∙ (𝑎𝑖+1 ∙ … ∙ 𝑎𝑛 ) → Auflösen durch doppeltes Negieren.
𝑓𝑁𝐴𝑁𝐷 = (𝑎1 ∙ … ∙ 𝑎𝑖 ) ∙ (𝑎𝑖+1 ∙ … ∙ 𝑎𝑛 ) → 3 Elemente von NAND-Gattern. Bei jeder weiteren
Aufteilung zwei weitere je Teilstück.
…
a1
& &
&
…
an

f(x)
& &
NOR-Gatter
𝑓𝑁𝑂𝑅 = (𝑏1 ∨ 𝑏2 ∨ … ∨ 𝑏𝑖 ) ∨ (𝑏𝑖+1 ∨ … ∨ 𝑏𝑛 )
2.4
Entwurf von Multiplexer-Schaltungen
MUX realisieren direkt die kanonische DNF(f), d.h. die Shannon-Expansion
f(a=1)
1
MUX
2-to-1
0
f(a=0)
f(x)
a
𝑓(𝑥) = 𝑎 ∙ 𝑓(𝑎
⏟ = 0) ∨ 𝑎 𝑓(𝑎
⏟ = 1)
𝑓0
𝑓1
f0, f1 = Kofaktoren, Restfunktionen
a = Selektierungs-/ Steuer-/ Adress-Unterraum-Variable
2 Variablen
f1,1
11
f1,0
10
f0,1
01
f0,0
00
MUX
4-to-1
f(x)
a
b
𝑓(𝑥) = 𝑎̅𝑏̅ 𝑓0,0 ∨ 𝑎̅𝑏𝑓0,1 ∨ 𝑎𝑏̅𝑓1,0 ∨ 𝑎𝑏𝑓1,1
33
Beispiel:
c
0
0
1
1
d
0
1
1
0
f(x)
0
1
0
1
0
0
1
1
1
1
1
0
0
1
1
1
1
1
1
0
0
1
0 b
1 a
a, b = Selektierungsvariablen
Es wird immer zugehöriger Unterraum betrachtet, welche Funktion für restliche Variablen
könnte die dortigen Ergebnisse bringen?
𝑓0,0 = 𝑓(𝑎 = 0, 𝑏 = 0) = 𝑐 ≁ 𝑑
𝑓0,1 = 1
𝑓1,1 = 𝑐 ∨ 𝑑
𝑓1,0 = 𝑑̅
c
d
c
d
1
11
d
10
1
01
=1
MUX
4-to-1
f(x)
00
a
b
2.5
Statische Nebenbedingungen
Beispiel: Langhobelmaschine
a
b
a, b = Endschalter
Umsteuersignal (Sollverhalten) 𝑈(𝑥) = 𝑎 ∨ 𝑏
Physikalische Nebenbedingung:
Die Endschalter a und b können (im Normalfall) niemals gleichzeitig durch den
Werkzeugschlitten betätigt werden.
Statische Nebenbedingung 𝜑(𝑥) = 𝑎𝑏 = 0 (restriktive/ ausschließende Gleichung)
2.5.1
a)
b)
Technische Interpretation der Nebenbedingung
technisch physikalisch nicht mögliche Werte der Variablen, oder
verbotene Belegungen (z.B. CPU-Pseudo-Codes oder wegen Gefahrensituationen, etc.),
oder
34
c)
innere Freiheitsgrade (entstehen z.B. im Schaltungsentwurf bei der Dekomposition oder
durch nicht benutzte binäre Zustände, Pseudotetraden, …)
2.5.2
a
0
0
1
1
Auswirkungen
der
Nebenbedingungen
Hauptfunktionen/Sollverhalten
auf
die
b U  U* U1 U2
0 0 0 0
0
0
1 1 0 1
1
1
1 1 1  0
1
0 1 0 1
1
1
U = vorläufige Funktion
 = Nebenbedingung
U* = endgültige Funktion
U1, U2 = mögliche Funktionen, die sich aus U* ergeben
Bei Zustand 𝑎 = 𝑏 = 1 ist Funktionswert egal, weil er nicht interessiert → binärer
Freiheitsgrad = „don’t care condition“ (dc). Bei den drei anderen Zuständen sind
Funktionswerte definiert/gebunden.
Erkenntnisse: ∅ ∈ {0,1} und frei wählbar, da im Beispiel die Belegung (𝑎, 𝑏) = (1,1) niemals
auftreten kann, d.h. der zugehörige Funktionswert von 𝑈(𝑥) = 𝑈(1,1) ist frei wählbar
→ 𝑈1 (𝑥) ∈ 𝑈 ∗ (𝑥) und 𝑈2 (𝑥) ∈ 𝑈 ∗ (𝑥) mit 𝑈 ∗ (𝑥) = [𝑈(𝑥), 𝜑(𝑥)] und wird auch teilweise
bestimmte Funktionen (incompletely specified function)
→ Bei n -Feldern ergeben sich 2n unterschiedliche Funktionen, die alle die gleichen
gebundenen Werte besitzen und untereinander äquivalent bezüglich der Nebenbedingungen
sind!
Beispiel: D(f) gegeben
𝑎 𝑏
0 −
𝐷(𝑓) =
0 1
− 1
𝐷(𝜑1 ) = 1 1
𝑁𝐵 {
𝐷(𝜑2 ) = − −
𝑐
−
0
0
−
1
𝑑
1
} 𝑓∗
−
1
−
1
𝜑(𝑥) = 𝜑1 (𝑥) ∨ 𝜑2 (𝑥)
Möglichst zuerst die  Felder in den KP eintragen.
c
0
0
1
1
d
f*
1
0 0 1  0
1 1 1  0
1     2
0 0 0  0
0 1 1 0 b
0 0 1 1 a
35
𝑛 = 7 → 27 = 128 Funktionen in einem Funktionenverband mit einer kleinsten (alle ∅ = 0)
und einer größten (alle ∅ = 1) Funktion.

optimale Funktion bezüglich 1 (möglichst große Einsfelder anlegen)
𝑏
0
1
1
𝑐|
0
1
1
1
0
1
1
0
0
0
0
|𝑑
0
0
𝑎
𝑎 𝑏 𝑐 𝑑
𝐷(𝑓𝑜𝑝𝑡 ) = 0 − − 1
− 1 0 −
a
&
d
fopt
&
b
&
c

kleinste Funktion = Implinum (alle ∅ = 0)
𝑏
0
1
0
𝑐|
0
1
1
0
0
0
0
0
0
0
0
|𝑑
0
0
𝑎
𝑓𝑚𝑖𝑛 = 𝑎̅𝑏𝑐̅ ∨ 𝑎̅𝑐̅𝑑

größte Funktion = Supremum (alle ∅ = 1)
𝑏
0
1
1
𝑐|
0
1
1
1
0
1
1
1
1
0
0
|𝑑
1
0
𝑎
𝑓𝑚𝑎𝑥 = 𝑓𝑜𝑝𝑡 ∨ 𝑎𝑏 ∨ 𝑐𝑑
Allgemein gilt: 𝑓𝑚𝑖𝑛 ≤ (𝑓 ∈ 𝑓 ∗ ) ≤ 𝑓𝑚𝑎𝑥
36
3.
Automaten und sequentielle Schaltsysteme
3.1
Modell
Automat = Selbstständig arbeitende Einrichtung
3.1.1
Praktische Erfahrung
Es gibt Schaltsysteme, bei denen die Ausgangswerte nicht eindeutig allein durch die
Eingangswerte bestimmt werden.
x(t)
y(t)
z
Beispiel: Frequenzteiler (Zähler)
t 0 1 2 3 4 5 6 7 8 9 10 11 12
x 0 1 0 1 0 1 0 1 0 1 0 1 0
y 0 0 0 0 0 1 0 0 0 0 0 1 0
Verhalten nicht kombinatorisch erzeugbar. System benötigt intern Bitspeicher für die
„Vorgeschichte“. Neue Systemklasse: sequentielle Schaltwerke/ Folgeschaltungen/ Speicher
behaftete Schaltungen.
3.1.2
Allgemeine Struktur
e
a
s
𝑒 ∈ 𝐸 = Eingangsalphabet (Menge vereinbarter Zustände/ Werte)
𝑠 ∈ 𝑆 = Speicheralphabet
𝑎 ∈ 𝐴 = Ausgangsalphabet
3.1.3
Allgemeines Verhaltensmodell
stationäre / „rheolineare“ Systeme → gleichbleibendes Verhalten (kann sich ändern, aber
immer nur in bekannten gleichen Verhalten, stationär ≠ statisch)
Automatengleichungen:
𝑎(𝑡) = 𝜆[𝑒(𝑡), 𝑠(𝑡)]
1
𝑠 = 𝑠(𝑡 + Δ𝑡) = 𝑠(𝑡 + 𝑇) = 𝛿[𝑒(𝑡), 𝑠(𝑡)]
1
s = Folgezustand von s(t)
𝜆: (𝑒, 𝑠) → 𝑎 Ergebnisfunktion (Abbildung von e und s)
𝛿: (𝑒, 𝑠) → 1𝑠 Überführungsfunktion
37
bzw. 𝛿: (𝑒, 𝑛𝑠) →
𝑛+1
𝑠
A-Modell = Verhaltensmodell = abstrakter Automat A:
𝐴 = (𝐸, 𝑆, 𝐴, 𝛿, 𝜆) ist ein n-Tupel
Begriffe:

endlicher Automat: E, A und S sind endliche Mengen

initialer Automat: besitzt einen festen Startzustand 𝑠0 = 𝑠(𝑡 = 0)

deterministischer Automat: δ und λ sind eindeutig
Veranschaulichung des Automatenverhaltens als Graphenkante
e/a
s
1s
e, s = Ursache
1
s, a = Wirkung (s, δ und λ)
nichtdeterministischer Ausdruck (ND-Verhalten), δ ist mehrdeutig
1s
1
e/a
s
e/a
…
e/a
1s
2
1s
n
3.1.4
Zeitliches Verhalten eines Automaten
s(0)
e(0)/a(0)
s(1)
e(1)/a(1)
s(1)
…
s(n)
Endliche Automaten: Zustandszyklen (werden am Ende wiederholt)
Technischer Fall: Endlichkeit von S
Beispiel:
a)
Muss nicht vom gleichen starten und nicht vom Start wiederholen
Anfangszustand
38
b)
Mehrere Zyklen
3.1.5
Automatentypen: Moore-Automaten und Mealy-Automaten
Moore:
e
s
δ
a
λ
s
𝑎 = 𝜆(𝑠) ⟶ Ausgang nicht direkt vom Eingang abhängig
1
𝑠 = 𝛿(𝑒, 𝑠)
Mealy:
e
s
δ
s
a
λ
𝑎 = 𝜆(𝑒, 𝑠) ⟶ Ausgang direkt vom Eingang abhängig
1
𝑠 = 𝛿(𝑒, 𝑠)
3.1.6
Grenzfälle
Autonomer Automat besitzt kein echtes Eingangssignal.
𝑎 = 𝜆(𝑠)
1
𝑠 = 𝛿(𝑠)
Reine Kombinatorik besitzt keine Speicher: 𝑎 = 𝜆(𝑒)
3.1.7

Beschreiben des Verhaltens/ weitere Automatenmodelle
Automatentabellen von 𝛿(𝑒, 𝑠) und 𝜆(𝑒, 𝑠)
Beispiel:
𝛿(𝑒, 𝑠) zeigt Zustandsübergänge abhängig vom Eingang und aktuellen Zustands
39
e
s
1
2
3
4
5
α β
γ
2
4
1
3
5
3
4
1
2
4
4
2
1
4
3
𝜆(𝑒, 𝑠) zeigt die Ausgangsbelegung abhängig vom Zustandswechsel
e
s
1
2
3
4
5
α β
γ
1
1
1
1
0
0
1
1
0
0
0
0
1
0
0
α, β und γ sind verschiedene Verhalten
𝐴 = {0,1} 𝑆 = {1,2,3,4,5} 𝐸 = {𝛼, 𝛽, 𝛾}

Automatengraph und Phasenliste (PHL)
Graphenkante = zulässige Phase
s
e/a
1s
Ursache
Wirkung
1
( 𝑒,
𝑠, 𝑎 )
⏟𝑠 , ⏟
Ursache Wirkung
zu Beispiel: Graph für die Verhalten α und β
β /0
1
β /1
α/1
2
β/0
α/1
3
α/1
α/1
T4 – Zyklus
(Länge 4)
für α
4
β /0
β /0
5
α/0
Zyklus bezeichnet einen geschlossenen Umlauf und die Anzahl der Stationen die Länge.
40
PHL:
e
α
α
α
α
α
1
s
1
2
3
4
5
s
2
4
1
3
5
a
1
1
1
1
0
e
β
β
β
β
β
s
1
2
3
4
5
1
s
4
2
1
4
3
a
0
0
1
0
0
e
γ
γ
γ
γ
γ
s
1
2
3
4
5
1
s
3
4
1
2
4
a
0
1
1
0
0
Erklärung:
Mit Verhalten α geht Automat von Zustand 1 zu 2 über und gibt dabei eine 1 aus.
Mit Verhalten β geht Automat von Zustand 2 zu 2 über und gibt dabei eine 0 aus.

Analyse qualitativ und quantitativ
a)
Zyklen z.B. (e = a = konstant)  (T1-Zyklus in 𝑠 = 5 bei 𝑎 = 0)  (T4-Zyklus
beginnend in 𝑠 = 1 mit 𝑎 = 1)
Finalverhalten z.B. (𝑠 = 1, 𝛽 = 0) ⟹ (Trajektorie = Raumkurve endet in 𝑠 = 4 =
stabiler Zustand, d.h. Schlinge bei konstanter Ansteuerung)
Anfangszustand = Zustand wird bei bestimmter Ansteuerung verlassen und ist nie
wieder erreichbar
Endzustand = wird bei bestimmter Ansteuerung erreicht und kann nie wieder verlassen
werden
b)
c)
d)
3.2
Binäre Automaten
3.2.1
Aus technischen Gründen (z.B. Störsicherheit, einfache
Realisierbarkeit, …) werden alle auftretenden Größen binär codiert
Beispiel:
BCD-Code: direkte Zuordnung der Zahlendarstellung
𝑥 = 5 = 0101
𝑛−1
𝑥 = ∑ 𝑥𝑖 ⋅ 2𝑖
𝑖=0
mit 𝑥𝑖 ∈ {0,1} und n binäre Stellen
Andere Codes: Graycode, etc.

Zuordnungen
𝑒 ⟺ 𝑥 = (𝑥1 , … , 𝑥𝑘 ) ∈ 𝐵 𝑘 ; 𝑥𝑖 ∈ 𝐵 = {0,1}
𝑠 ⟺ 𝑧 = (𝑧1 , … , 𝑧𝑙 ) ∈ 𝐵 𝑙
𝑎 ⟺ 𝑦 = (𝑦1 , … , 𝑦𝑛 ) ∈ 𝐵 𝑛

Verhalten: Automatengleichungen
𝑎 = 𝜆(𝑒, 𝑠) ⟺ 𝑦 = 𝑘(𝑥, 𝑧)
41
1
𝑠 = 𝛿(𝑒, 𝑠) ⟺ 1𝑧 = 𝑓(𝑥, 𝑧) Realisierung als Funktionenbündel
Beispiel:
1
𝑧1 = 𝑥 ⋅ 𝑧1 ∨ 𝑧1 𝑧2 = 𝑓1 (𝑥, 𝑧)
1
𝑧2 = 𝑥̅ ⋅ (𝑧1 ≁ 𝑧2 ) = 𝑓2 (𝑥, 𝑧)
𝑦 = 𝑧1 = ℎ([𝑥], 𝑧)
Automatentabelle: KP
z1 z2
0 0
0 1
1 1
1 0
x
1
z1
1
1
1
0
1
0
0
1
0
0
1
0
1
0
1
0
z2
0
0
0
0
1
y
1
1
0
0

0
0
0
1
0
𝑧̇1
1
1
0
1
1
𝑧̇2
0
1
1
0
1
0
0
1
1
0
𝑧̇ 1 und 𝑧̇ 2 sind Änderungsgrößen und ergeben sich durch Antivalenzbildung zwischen dem vorigen
und dem folgenden Zustand:
𝑧̇ 𝑖 = 1𝑧𝑖 ≁ 𝑧𝑖
Kante im Automatengraph:
x/y
z
1z
z
y
x
z 1z 2
1 z 1z
1 2
z1 z2
 Moore Automat
Automatengraph:
y=1
0
01
11
x=0
z2
1
z1z2
00
x=0

1
01
0
z1  z2  1
z1
x=1
z1  0, z2  1
10
x=1
z1  1, z2  0
0
Änderungsgrößen
Definition:
𝜕𝑧𝑖 (𝑡)
𝑧̇ 𝑖 =
= lim 𝑧𝑖 (𝑡) ≁ 𝑧𝑖 (𝑡 + Δ𝑡)
Δ𝑡→0
𝜕𝑡
42
für getaktete Systeme ist Δ𝑡 = 𝑇 (Taktzeit)  Boolesche Differenz
⟹ 𝑧̇ 𝑖 = 𝑧𝑖 ≁ 1𝑧𝑖
⟹ 𝑧̇𝑖 (𝑡) = 𝑧𝑖 ≁ 𝑓𝑖 (𝑥, 𝑧) = 𝑔𝑖 (𝑥, 𝑧)
⟹ 𝑧̇ = 𝑔(𝑥, 𝑧)
zu Beispiel:
𝑧̇ 1 = 𝑧1 ≁ 1𝑧1 = 𝑧1 ≁ (⏟𝑥𝑧1 ∨ 𝑧1 𝑧2 ) = 𝑥𝑧1 ≁ 𝑧1 𝑧2 = 𝑥𝑧1 ∨ 𝑧1 𝑧2 = 𝑔1
da orthogonal ≁
̅𝑧1 ≁ 𝑥
̅𝑧2 ) = 𝑥
̅𝑧1 ≁ 𝑥𝑧2 = 𝑥
̅𝑧1 ∨ 𝑥𝑧2 = 𝑔2
𝑧̇ 2 = 𝑧2 ≁ (𝑥
Auflösung nach 1𝑧𝑖 :
𝑧̇ 𝑖 = 𝑧𝑖 ≁ 1𝑧𝑖
𝑧̇ 𝑖 ≁ 𝑧𝑖 = 𝑧𝑖 ≁ 1𝑧𝑖 ≁ 𝑧𝑖 = 1𝑧𝑖
43
4.
Entwurf sequentieller Schaltsysteme
4.1
Schaltsysteme mit konzentrierten Speicherelementen
Einbitspeicher = Flip-Flop (FF) (Klipp-Klapp, Purzelbaum, …) = bistabiles Speicherelement
Q = Zustandsvariable des FF
x = Vektor der FF-Eingänge (einschließlich eventuelle Taktsignale)
Allgemeine Gleichung des FF:
1
𝑄 = 𝐹(𝑄, 𝑥)
1
𝑄 = 𝑄̅ ⋅ 𝐹(𝑄 = 0, 𝑥) ∨ 𝑄 ⋅ 𝐹(𝑄 = 1, 𝑥) = 𝑄̅ 𝐹0 ∨ 𝑄𝐹1
𝑄 ∈ {0,1}
Automatengraph des FF:
F0
Q
0
F0
1
F1
F1
𝑄 = 0: 1𝑄 = 𝐹0
𝑄 = 1: 1𝑄 = 𝐹1
Übergangstypen:
F0 F1 Q
0 0 0
0 0 1
1 1 0
1 1 1
0 1 0
0 1 1
1 0 0
1 0 1
4.1.1
1
Q
0
0
1
1
0
1
1
0
Nullübergang 1𝑄 = 0
Einsübergang 1𝑄 = 1
Speicherübergang 1𝑄 = 𝑄
̅
Kippübergang 1𝑄 = 𝑄
Struktur von FF Schaltwerken
1z
x
1
FF1
z
…
kombinatorisches
Funktionenbündel
für 1z = f(x, z)
z1
1z
k
FFk
zk
C = Takt an jeden FF
44
λ
kombinatorisches
Bündel
y

eventuelle Zeitprobleme
FF-Inhalt und ebenso die zu bildenden
eventuell gleichzeitig geändert.
Lösung:
a)
FF mit Taktflanke
1
𝑧𝑖 -Werte werden zum Taktzeitpunkt benötigt, aber
C
C = Clock, Takt mit 𝐶̇ = 𝐶 ≁ 𝐶 1 = 𝐶(𝑡) ≁ 𝐶(𝑡 + Δ𝑡), Δ𝑡 → 0
C1  CC C2  CC
b)
x
Master-Slave-Technik (serielles Doppel FF)
Master
FF
Slave
FF
C1  CC
C2  CC
Q
Informationsübernahme mit unterschiedlichen Taktflanken
4.1.2
FF-Schema/ Symbolik
E1
E2
Ei1
…
…
&
…
Eik
Q
Q
CLK
Beispiel: JK-FF mit statischen (ungetakteten, asynchronen) Setz- und Rücksetzeingang
(vorrangig)
S
T
Q
J
C C
CLK
K
R
T = Trigger (Auslöser)
J, C, K = Haupteingänge
45
Schaltsymbol:
S
J
CLK
K
Q
R
4.1.3

Verhaltensbeschreibung unterschiedlicher FF-Typen
RS-FF: NOR-Typen
Satz:
Durch interne (ungetaktete „freie“) Rückführungen sind stabile Zustände in einem
kombinatorischen System erzeugbar.
Beispiel:
R
S
a)
b)
0 1
1
1
1 0
1 0
0 1
Q
Q
 𝑅 = 0, 𝑆 = 1 ⟶ 1𝑄 = 1 ⟶ Q wird gesetzt (set)
 𝑅 = 1, 𝑆 = 0 ⟶ 1𝑄 = 0 ⟶ Q wird zurück gesetzt (reset)
An einem Eingang der NOR-Gliedern liegt der alte Wert von Q an, bevor dieser vom neuen
überschrieben wird. Gewöhnlich ist Q zu Beginn unbekannt, man rechnet dann allgemein.
Berechnung von Q: Man betrachtet das NOR-Glied, an dem eine 1 anliegt, denn 1 ODER
irgendwas = immer 1. Negiert wird daraus 0. Nun hat man die Belegung für die beiden
Eingänge des anderen NOR-Gliedes.
c)
𝑅 = 0, 𝑆 = 0 ⟶ 1𝑄 = 𝑄 ⟶ FF-Zustand bleibt erhalten
d)
𝑅 = 1, 𝑆 = 1 ⟶ 1𝑄 = 0, !aber auch 1𝑄 = 0 ⟶ geht
(Folgezustand ungewiss), verbotene Eingangsbelegung
nicht,
kein
FF-Verhalten
Berechnung von Q bei c): Man benutzt (probiert) mit eventuellen vorangegangenen Zustand
von Q (0 oder 1), daraus folgt 1Q ist von Q abhängig. So wie Q war, wird 1Q werden. 1𝑄 = 𝑄
Wegen d) wird Nebenbedingung benötigt:
𝜑𝑁𝑂𝑅−𝐹𝐹 = 𝑅 ∧ 𝑆 = 0
Nebenbedingung ist für Belegung d) nicht erfüllt → verbotene Belegung.
Verhalten:
1
𝑄 = 𝑆 ∨ 𝑅𝑄 mit NB 𝜑 = 𝑅 ∧ 𝑆 = 0
46
verkürzte Automatentabelle und –graph:
R S
0 0
0 1
1 0
1 1
1
Q
Q
1
0

S
0
S
1
R
R

JK-FF
K (=R)
&
1
Q
1
Q
C
J (=S)
&
Getaktet mit C. Austasten („Toren“) des K-Signals bei 𝑄 = 0. Austasten von J bei 𝑄 = 1 ↷
𝑄 = 0. Keine Nebenbedingung.
Verhalten: 1𝑄 = 𝑄𝐽 ∨ 𝑄𝐾 = 𝑄𝐽 ≁ 𝑄𝐾
J K
0 0
0 1
1 0
1 1
1
Q
𝑄
0
1
𝑄
J
J
0
1
K
K
wenn getaktet lautet Verhalten:

1
𝑄 = 𝑄 ⋅ 𝐽 ⋅ 𝐶 ∨ 𝑄 ⋅ (𝐾 ⋅ 𝐶)
JR-FF
Rücksetzvorgang:
1
𝑄 = 𝑅 ⋅ (𝐽 ∨ 𝑄)
47
J R
0 0
0 1
1 0
1 1
1
Q
Q
0
1
0
JR
0
RJ
1
R
R

SK-FF
Setzvorgang:
S K
0 0
0 1
1 0
1 1
1
𝑄 =𝑆∨𝐾⋅𝑄
1
Q
Q
0
1
1
S
0
S
1
SK
SK

D-FF
Delay Flip Flop, Verhalten:
D
0
1
1
𝑄=𝐷
1
Q
0
1
D
D
0
1
D
D Q
C
D
schwer real zu realisieren

T-FF
Trigger Flip Flop, wenn Takt kommt und 𝑇 = 1 ist, ändert sich Q, wie bei JK-FF wenn 𝐽 =
𝐾=1
Verhalten: 1𝑄 = 𝑄 ≁ 𝑇 = 𝑄𝑇 ∨ 𝑄𝑇
48
𝑄̇ = 𝑇
T
0
1
1
Q
Q
𝑄
T
0
T
1
T
T Q
C
T

DV-FF
FF mit Verhinderungseingang (prevent)
Verhalten: 1𝑄 = 𝑉𝑄 ∨ 𝑉𝐷
D V
0 0
0 1
1 0
1 1

1
Q
Q
0
Q
1
RST-FF
Verhalten: 1𝑄 = 𝑆 ∨ 𝑇 ⋅ 𝑄 ∨ 𝑅 ⋅ 𝐹 ⋅ 𝑄
Nebenbedingung: 𝑅𝑆 ∨ 𝑅𝑇 ∨ 𝑆𝑇 = 0
ungünstig wegen langer Nebenbedingung
R S T
0 0 0
0 0 1
0 1 0
0 1 1
1 0 0
1 0 1
1 1 0
1 1 1
1
Q
Q
𝑄
1

0



ST
ST
0
1
RT
RT
49

L-FF
„Anfang“ / Latch-FF, lässt sich nicht allein durch L auf 0 zurücksetzen, deshalb statisches
Rücksetzsignal R. Setz FF bei 𝑅 = 1 auf 0 zurück. Vorteil: einfache Schaltung.
Verhalten:
L
0
1
1
𝑄 =𝑄∨𝐿
1
Q
Q
1
L
&
L
0
L
4.1.4
1
R
1
Q
&
Synthese von Schaltungen mit FF
Geänderte Aufgabenstellung, Zustandsänderung 𝑄 → 1𝑄 wertmäßig vorgegeben. Gesucht
sind die Ansteuerwerte der FF-Eingänge.
Beispiel: JK-FF
J
J
0
1
K
K
Tabelle der FF-Ansteuerwerte:
vorgegebene Wirkung Ursache
1
Q
Q
J
K
𝑄̇
0
0
0
0 
0
1
1
1 
0


 
1
0
1
 1
1
1
0
 0
1


 
mit  = beliebig und 𝑄̇ = 𝑄 ≁ 1𝑄
Ergänzung zu FF-Typen: taktflankengesteuertes JK-FF
𝑄̇ = 𝑄 ≁ 1𝑄 = 𝑄(𝑡) ≁ 𝑄(𝑡 + 𝑇)
𝑄̇𝐶 = 𝐶 ⋅ 𝐶̇ ⋅ (𝑄 ≁ 1𝑄 )
50
C(t)
1
t
0
JK-FF:
̅ )] = 𝐶 ⋅ 𝐶̇ ⋅ [𝑄 ⋅ (1 ≁ 𝐾
̅ ) ≁ 𝑄̅ 𝐽] = 𝐶 ⋅ 𝐶̇ ⋅ [𝑄̅ 𝐽 ≁ 𝑄𝐾]
𝑄̇𝐶,𝐽𝐾 = 𝐶 ⋅ 𝐶̇ ⋅ [𝑄 ≁ (𝑄̅ 𝐽 ≁ 𝑄𝐾
Beispiel: ungetaktetes dynamisch gesteuertes T-FF
C
1
t
0
Q(t)dyn
C  C
1
t
0
𝑄̇𝑇𝑑𝑦𝑛 = 𝐶 ⋅ 𝐶̇

Algorithmus: Synthese der Ansteuerkombinatorik für FF-Schaltungen
i)
Die Funktionen 1𝑧𝑖 = 𝑓𝑖 (𝑥, 𝑧)∀𝑖 bzw. 𝑧̇𝑖 = 𝑔𝑖 (𝑥, 𝑧) bestimmen und in Tabellen
(vorzugsweise KP) eintragen.
ii)
Für jeden FF-Eingang aller n Zustandskomponenten 𝑧𝑖 , ∀ KP auflegen und die, aus der
𝑛
iii)

𝑖=1
Tabelle der FF-Ansteuerwerte für den gewählten FF-Typ abzulesenden, für jeden
Übergang eintragen.
Struktursynthese der kombinatorischen Schaltung für jeden FF-Eingang entsprechend
der vorgegebenen bzw. gewählten Realisierungsbasis.
Entwurfsbeispiel 1:
gegeben: 1𝑧 = 𝑎̅𝑏 ∨ 𝑎̅𝑧 ∨ 𝑏𝑧
gesucht: verschiedene FF-Realisierungen
Lösung:
𝑏
1
z
0 1 0 0
𝑧| 1 1 1 0
𝑎
a)
D-FF: 1𝑄 = 𝐷 ⇒ 1𝑧 = 𝐷
𝑏
1
z
0 1 0 0
𝑧| 1 1 1 0
𝑎
Zufällig die gleiche Tabelle bei D-FF.
51
Realisierungsbasis: NOR-NOR  K(f)
𝑎 𝑏 𝑧
𝑎 𝑏 𝑧
negieren
̅) = 1 − 0 →
Disjunktion von 𝐷 → 𝐷(𝐷
𝐾(𝐷) = 0 − 1
1 0 −
0 1 −
− 0 0
− 1 1
𝐷 = (𝑎̅ ∨ 𝑧) ∧ (𝑎̅ ∨ 𝑏) ∧ (𝑏 ∨ 𝑧)
Zwischenfunktion
1z bilden bei Taktflanke
a
1
D
a
z
1
1
D Q
b
b
z
1
C
b)
RS-FF
𝑏
𝑏
1
z
0 1 0 0
𝑧| 1 1 1 0
𝑎
→
𝑏
R
- 0 - 𝑧| 0 0 0 1
𝑎
𝑧|
S
0 1 0 0
- - - 0
𝑎
Übergang von z zu 1z betrachten, um Tabellen für R und S auszufüllen:
 𝑧 = 0 ändert sich zu 1𝑧 = 0 → in Tabelle für R ein „“ und für S eine 0
 𝑧 = 0 ändert sich zu 1𝑧 = 1 → in Tabelle für R eine 0 und für S eine 1
 𝑧 = 1 ändert sich zu 1𝑧 = 1 → in Tabelle für R eine 0 und für S ein „“
 𝑧 = 1 ändert sich zu 1𝑧 = 0 → in Tabelle für R eine 1 und für S eine 0
Realisierungsbasis: AND-OR
𝑅 = 𝑎𝑏̅ 𝑆 = 𝑎̅𝑏
a
b
Q
R
&
z
C
a
b
c)
&
S
DV-FF
𝑏
1
z
0 1 0 0
𝑧| 1 1 1 0
𝑎
1. Möglichkeit
𝑏
D
0
0 0
1
- →
- - 0
𝑧|
1 1 1
𝑎
𝑏
V
- 1
0
0 0
0 0 0
1
𝑧|
- - 𝑎
2. Möglichkeit
In den Tabellen von D und V gibt es für viele Felder 2 verschiedene Möglichkeiten.
Entscheidet man sich im Feld einer Tabelle für eine Möglichkeit, muss man dieselbe für das
entsprechende Feld in der anderen Tabelle nehmen. Entscheidungen sind jeweils für ein Feld
52
bindend. Für verschiedene Felder können verschiedene Möglichkeiten gewählt werden. Z.B.
wenn man im linken oberen Feld von Tabelle D die 0 wählt, muss man im linken oberen Feld
von Tabelle V das „“ nehmen.
𝑏
𝑧|
𝑏
D
0 1 - 0
- 1 1 0
𝑎
V
- 1 0 𝑧| 0 - - 1
𝑎
Realisierungsbasis: NAND
𝐷(𝐷) = 𝑏 𝐷(𝑉) = 𝑎̅𝑏 ∨ 𝑎𝑏̅
b
a
b
a
b
d)
D
Q
z
C
&
&
V
&
T-FF
𝑇 = 𝑄̇ ⇒ 𝑇 = 𝑧̇ = 𝑧 ≁ 1𝑧
𝑏
𝑏
1
z
0 1 0 0
𝑧| 1 1 1 0
𝑎
→
𝑇 = 𝑧̇
0 1 0 0
𝑧| 0 0 0 1
𝑎
Realisierungsbasis: NAND
𝐷(𝑇) = 𝑎̅𝑏𝑧̅ ∨ 𝑎𝑏̅𝑧
a
b
a
b

&
&
&
T
C
Q
z
z
Entwurfsbeispiel 2:
Zu entwerfen ist ein Mod3-Zähler mit RS-FF und NAND-Gattern, der für 𝑥 = 1 vorwärts und
für 𝑥 = 0 rückwärts zählt und die Zahlen im direkten Binärcode ausgibt.
Lösung: Variante 𝑦 = 𝑧 (kein extra Zuordner nötig)
53
S
z1z0
unbekannter
Zustand
0
00
x
x
x
x
2
10
11
x
1
01
x
1
z
z
1
1
z1 z0
z1
z0
0 0 1 0 0 1
0 1 0 1 0 0
1
1
-
-
-
1
0
x
0 0 1 0
0 1 0 1
R1
S1
R0
S0
0 - 1 0 - 0 0 1
- 0 0 1 1 1 0 0
0 0 - - 0 0 - - - 0 0 - - 0 0
1 1 0 0 0 - 1 0
0 1 0 1 0 1 0 1
-
Zwei Zustandsvariablen → zwei Flip Flops. R1 und S1 ergeben sich durch Vergleich von z1
mit 1z1, R0 und S0 ergeben sich durch Vergleich von z0 mit 1z0.
𝐷(𝑅1 ) = 𝑧1 𝐷(𝑆1 ) = 𝑥𝑧̅1 𝑧0 ∨ 𝑥̅ 𝑧̅1 𝑧̅0 𝐷(𝑅0 ) = 𝑧0 𝐷(𝑆0 ) = 𝑥𝑧̅1 𝑧̅0 ∨ 𝑥̅ 𝑧1 𝑧̅0
R1
x
z0
&
z1
x
z0
&
&
S1
R
Q
R0
z1=y1
C
x
z1
S
z0
x
z1
Q
z0=y0
C
&
&
&
R
S0
S
Wenn man z1, z0, R1, R0, S1, S0 gegeben hat, kann man mit Hilfe der FF-Tabelle auch
nachschauen, wie 1z1, 1z0 sein müssten. Danach übertragbar in Automatengraph (in diesem
Beispiel von (1, 1) nach (0, 1), egal wie x).
4.2
Analyse des Verhaltens von FF-Schaltungen
4.2.1
Analyse Algorithmus
i)
ii)
iii)
Aus einer gegebenen Schaltung heraus werden die Ansteuerfunktionen aller FFEingänge und die Funktionen aller Schaltungsausgänge (Ergebnisfunktion) ermittelt.
Die ermittelten Ansteuerfunktionen werden in die den FF-Typen entsprechenden FFGleichungen eingesetzt: 1𝑧 = 𝑓(𝑥, 𝑧) [eventuell 𝑧̇ = 𝑔(𝑥, 𝑧)], 𝑦 = ℎ(𝑥, 𝑧)
Veranschaulichung des Verhaltens über:
a)
Automatentabelle [KP]
b)
Automatengraph
c)
Phasenlisten
54
x, y
z
Kante
1z
Phase (x, z, 1z, y)
Ursache Wirkung
iv)
Qualitative und quantitative Analyse [mit rechnerischen Mitteln]
Beispiel:
x
=1
D1
z1=D2
Q
D
C
z2=J3
V
J
Q
z3=y
C
K3
K
Ansteuer- und Ausgangsfunktionen ermitteln
𝐷1 = 𝑥 ≁ 𝑧3
ii)
Q
C
V2
i)
D
𝐷2 = 𝑧1
𝑉2 = 𝑥
𝐽3 = 𝑧2
𝐾3 = 𝑧2
𝑦 = 𝑧3
Einsetzen der Funktionen in FF-Gleichungen
D-FF: 1𝑄 = 𝐷 ⟹ 1𝑧1 = 𝐷1 = 𝑥 ≁ 𝑧3
DV-FF: 1𝑄 = 𝑉𝑄 ∨ 𝐷𝑉 ⟹ 1𝑧2 = 𝑉2 𝑧2 ∨ 𝐷2 𝑉2 = 𝑥̅ 𝑧2 ∨ 𝑧1 𝑥
JK-FF: 1𝑄 = 𝑄𝐽 ∨ 𝑄𝐾 ⟹ 1𝑧3 = 𝑧3 𝐽3 ∨ 𝑧3 𝐾3 = 𝑧3 𝑧2 ∨ 𝑧3 𝑧2 = 𝑧2
iii)
Veranschaulichung
Automatentabelle:
z1 z2 z3
0 0 0
0 0 1
0 1 1
0 1 0
1 1 0
1 1 1
1 0 1
1 0 0
x
1
z1
0 1
1 0
1 0
0 1
0 1
1 0
1 0
0 1
0 1
1
z2
0 0
0 0
1 0
1 0
1 1
1 1
0 1
0 1
0 1
1
0
0
1
1
1
1
0
0
0
z3
0
0
1
1
1
1
0
0
1
y
0
1
1
0
0
1
1
0
Für 1z1 zum Eintragen der Antivalenz die Pünktchenmethode verwendet.
55
Automatengraph:
011
z1z2z3
001
111
101
010
110
 x=0
000
100
Phasenliste 𝐷𝑃𝐻𝐿 =
x
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
1
iv)
Ursache
z1 z2
0 0
0 0
0 1
0 1
1 1
1 1
1 0
1 0
1 0
1 0
1 1
1 1
0 1
0 1
0 0
0 0
z3
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1
0
1
z1
0
1
1
0
0
1
1
0
1
0
0
1
1
0
0
1
Wirkung
1
z2 1z3
0
0
0
0
1
1
1
1
1
1
1
1
0
0
0
0
1
0
1
0
1
1
1
1
0
1
0
1
0
0
0
0
y
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1
0
Qualitative und quantitative Analyse
Für 𝑥 = 0 gibt es 2 Teilverhalten:
𝑧2 = 0 Einlaufen in stabilen Zustand (000)
𝑧2 = 1 Einlaufen in stabilen Zustand (111)
Für 𝑥 = 1:
T6-Zyklus von 𝑧 = 0 ausgehend
T2-Zyklus zwischen (010) und (101)
56
4.3
Speichertechnische Realisierungen
Grundprinzip: Speicheradresse = (𝑥, 𝑧) = Ursache bzw. Gesamtzustand und Speicherinhalt
= ( 1𝑧, 𝑦) = Wirkung
Memory
x
y(t-1)
(1z, y)
Adresse
z
Takt an jedes Register FF-Register
Beispiel:
gegeben: Automatengraph
gesucht: Schaltung aus RS-FF und NAND
z 1z 0
0/0
10
1/1
x/y
0/0
1/1
1/0
00
z1 z0
0 0
0 1
1 1
1 0
x
1
z1
1 0
0 1
1 0
0 1
0 1
1
0
1
0
0
0
z0
1
1
1
0
1
R1
0
0
1
0
𝑅1 = 𝑥̅ 𝑧1 𝑧̅0 ∨ 𝑥𝑧1 𝑧0
x
z0
z1
z0
x
x
z0
&
&
01
S1
0
1
0
1
1
0
0
0
0/1
R0
S0
0 - 0 0 1
1 0 0 - 0 1 0 0 - - - 0 0
1 0 1 0 1
𝑆1 = 𝑥̅ 𝑧̅1 𝑧̅0 ∨ 𝑥𝑧̅1 𝑧0
Q
&
𝑆0 = 𝑥𝑧̅1
&
R0
R
𝑦 = 𝑥𝑧1 ∨ 𝑧̅1 𝑧0
Q
C
z1
x
z1
C
z0
S
&
0
1
1
1
1
x
z1
R
&
y
0
1
0
0
0
𝑅0 = 𝑥̅ 𝑧1
R1
&
z1
z0
x
11
z1
x
z1
S1
57
&
S
S0
&
&
&
y
z0
5.
Zusammenfassung Konsultation
𝐷(𝑓) = 1 auslesen ⟶ 𝑎𝑏 ∨ 𝑎𝑐 ∨ 𝑎𝑏𝑐 …
𝐷(𝑓) = 0 auslesen ⟶ 𝑎𝑏 ∨ 𝑎𝑐 ∨ 𝑎𝑏𝑐 …
𝐾(𝑓) = 𝐷(𝑓) ⟶ 𝐷(𝑓) negieren, also 0 in 1 und 1 in 0 wandeln, ∨ in ∧. Oder Nullen
auslesen, aber statt für 𝑎 = 0 ein 𝑎 zu schreiben, ein normales 𝑎 ⟶ (𝑎 ∨ 𝑏) ∧ (𝑎 ∨ 𝑐). Auch
beim Eintragen aufpassen.
(nur so nebenbei: 𝐾(𝑓) = 𝐷(𝑓))
Beispiel:
1 1 0
0 1 0
0 1
0 0
1
0
1
1
1
0
0 a
1 b
𝐷(𝑓) = 𝑎̅𝑏̅ ∨ 𝑏𝑐
𝐷(𝑓)𝑏𝑐̅ ∨ 𝑎𝑏̅
𝐾(𝑓) = (𝑏̅ ∨ 𝑐) ∧ (𝑎̅ ∨ 𝑏)
𝐷(𝑓) = 𝐴(𝑓) Antivalenzform
Aber nur bei Auslesen aus KV, nicht bei Eintragen (für A die Pünktchenmethode verwenden,
bei ungerader Anzahl Punkte eine 1 eintragen). 𝐴(𝑓) = 𝑎𝑏 ≁ 𝑎𝑐 ≁ ⋯
𝐸(𝑓) = Äquivalenzform = (𝑎 ∨ 𝑏)~(𝑎 ∨ 𝑐)~ …
Wie bei K(f) bedeutet ein 𝑎 → 𝑎 = 0. Beim Eintragen Pünktchenmethode verwenden (bei
gerader Anzahl von Punkten eine 1 eintragen). Sieht aus wie K(f) nur eben mit ~ statt ∧
zwischen den einzelnen Elementardisjunktionen (Gliedern).
Aufpassen bei NOR und NAND, meist doppelte Negation nötig, denn man braucht: 𝑎 ∧ 𝑏 bei
NAND und 𝑎 ∨ 𝑏 für NOR. Unterschiedliche Darstellung nur zur besseren Anschaulichkeit,
Eingangswerte ändern sich dadurch nicht. Aufstellen einer Schaltung mit vorgegebenen
Gliedern.
Nebenbedingungen:
Wenn NB eine 1 enthält, gibt es an der Stelle einen Freiheitsgrad  im KV: ∅ = {0,1}.
Automaten:
Mehr oder weniger feste Befehlsfolge, nicht nur von Eingangsvariablen abhängig, sondern
auch vom (internen) Speicher.
58
6.
Anhang
6.1
Boolesche Ausdrücke/ Boolesche Formen (BF)
Boolesche Ausdrücke (BF) sind:
a)
Konstante 0 und 1, Variable x1, x2, …, xk (beliebige Bezeichnungen für die Variablen).
b)
c)
d)
Mit der Booleschen Form 𝑓(𝑥) ist auch 𝑓(𝑥) (nicht f, f negiert) eine BF.
Mit den BF-en f und g sind auch 𝑓 ∧ 𝑔, 𝑓 ∨ 𝑔, 𝑓 ≁ 𝑔 und 𝑓~𝑔 BF-en.
Beliebige Boolesche Formen müssen in endlich vielen Schritten mit Hilfe der Regeln a),
b) und c) konstruierbar sein!
Satz:
Jeder binären Funktion 𝑓(𝑥), 𝑥 ∈ 𝐵 𝑘 , lässt sich (mindestens) ein Boolescher Ausdruck
zuordnen. Jedem Booleschen Ausdruck (BF) 𝑓(𝑥) über 𝐵 𝑘 ist eindeutig eine binäre
(Boolesche) Funktion zugeordnet, d.h. bei Belegung der Variablen von x mit konstanten
Werten 𝑐 ∈ 𝐵 𝑘 ergeben sich eindeutig die Funktionswerte 𝑓(𝑐).
6.2
Reine Formen Boolescher Funktionen
Reine Formen von 𝑓(𝑥) bestehen nur aus Konstanten und Konjunktionen [oder
Disjunktionen], die alle mit einer einheitlichen Operation verknüpft sind. Sie erlauben das
Transformieren in andere Boolesche Modelle, z.B. das Eintragen in den Karnaugh Plan (KP)
oder in eine Ternärvektorliste (TVL), sind aber in den Fällen A(f) und E(f) nicht rein im Sinne
der algebraischen Struktur eines Booleschen Ringes 𝐵𝑅≁ (𝑘) = (𝐵𝑘 , ≁,∧) mit der additiven
Operation Antivalenz ≁ bzw. 𝐵𝑅~ (𝑘) = (𝐵 𝑘 , ~,∨) mit der additiven Operation Äquivalenz ~,
da in A(f) bzw. E(f) auch negierte Variable auftreten können [nicht aber in einem BR(k)]!
i)
Disjunktive Form
𝑚
𝐷(𝑓) = 𝑐 ∨ ⋁ 𝐾𝑗 (𝑥) ,
𝑐 ∈ 𝐵1 ,
𝑥 ∈ 𝐵𝑘
𝑗=1
mit den Konjunktionen
𝑙
𝐾𝑗 (𝑥) = ⋀ 𝑣𝑖 , 𝑙 ≤ 𝑘,
𝑣𝑖 ∈ {𝑥𝑖 , 𝑥𝑖 },
𝑣𝑖 ≠ 𝑣𝑗
𝑖=1
ii)
Konjunktive Form
𝑚
𝐾(𝑓) = 𝑐 ∧ ⋀ 𝐷𝑗 (𝑥) ,
𝑐 ∈ 𝐵1 ,
𝑥 ∈ 𝐵𝑘
𝑗=1
mit den Disjunktionen
𝑙
𝐷𝑗 (𝑥) = ⋁ 𝑣𝑖 , 𝑙 ≤ 𝑘,
𝑣𝑖 ∈ {𝑥𝑖 , 𝑥𝑖 },
𝑣𝑖 ≠ 𝑣𝑗
𝑖=1
59
iii)
Antivalenzform
𝑚
𝐴(𝑓) = 𝑐 ≁ ∑ 𝐾𝑗 (𝑥) ,
𝑐 ∈ 𝐵1 ,
𝑥 ∈ 𝐵𝑘
𝑗=1
mit den Konjunktionen
𝑙
𝐾𝑗 (𝑥) = ⋀ 𝑣𝑖 , 𝑙 ≤ 𝑘,
𝑣𝑖 ∈ {𝑥𝑖 , 𝑥𝑖 },
𝑣𝑖 ≠ 𝑣𝑗
𝑖=1
iv)
Äquivalenzform
m
𝐸(𝑓) = 𝑐~
E 𝐷 (𝑥),
j 1
𝑗
𝑐 ∈ 𝐵1 ,
𝑥 ∈ 𝐵𝑘
mit den Disjunktionen
𝑙
𝐷𝑗 (𝑥) = ⋁ 𝑣𝑖 , 𝑙 ≤ 𝑘,
𝑣𝑖 ∈ {𝑥𝑖 , 𝑥𝑖 },
𝑣𝑖 ≠ 𝑣𝑗
𝑖=1
Sind alle Konjunktionen von D(f) bzw. A(f) Elementarkonjunktionen (Minterme), in denen
jeweils alle Variablen des Booleschen Raumes Bk negiert oder nichtnegiert genau einmal
auftreten, so heißt DNF(f) die disjunktive (kanonische) Normalform von f(x) und es gilt
𝐷𝑁𝐹(𝑓) = 𝐴𝑁𝐹(𝑓). Analog dazu enthält die konjunktive (kanonische) Normalform von f(x)
nur Elementardisjunktionen (Maxterme) und es gilt 𝐾𝑁𝐹(𝑓) = 𝐸𝑁𝐹(𝑓).
6.3
Rechenregeln der Booleschen Algebra
6.3.1
Boolescher Verband BV(k)
Rechenregel mit Hauptoperation Konjunktion ∧,

1=0
𝑥∧0 =0
𝑥∧1 =𝑥
𝑥=𝑥
𝑥∧𝑥 =0
𝑥∧𝑥 =𝑥
𝑥 ∨ 𝑥𝑦 = 𝑥
Duale Beziehung mit der Operation
Disjunktion ∨, +
0=1
𝑥∨1 =1
𝑥∨0 =𝑥
𝑥∨𝑥 =1
𝑥∨𝑥 =𝑥
𝑥(𝑥 ∨ 𝑦) = 𝑥
𝑥 ∨ 𝑥𝑦 = 𝑥 ∨ 𝑦
𝑥(𝑥 ∨ 𝑦) = 𝑥𝑦
𝑥 ∧ (𝑦 ∧ 𝑧) = (𝑥 ∧ 𝑦) ∧ 𝑧
𝑥∧𝑦 =𝑦∧𝑥
𝑥 ∧ (𝑦 ∨ 𝑧) = 𝑥𝑦 ∨ 𝑥𝑧
𝑥∧𝑦 =𝑥∨𝑦
𝑥 ∨ (𝑦 ∨ 𝑧) = (𝑥 ∨ 𝑦) ∨ 𝑧
𝑥∨𝑦 =𝑦∨𝑥
𝑥 ∨ (𝑦 ∧ 𝑧) = (𝑥 ∨ 𝑦)(𝑥 ∨ 𝑧)
𝑥∨𝑦 =𝑥∧𝑦
𝑛
𝑛
⋀ 𝑥𝑖 = ⋁ 𝑥𝑖
𝑖=1
𝑖=1
𝑥𝑦 ∨ 𝑥𝑦 = 𝑥
(𝑥 ∨ 𝑦)(𝑥 ∨ 𝑧) = 𝑥𝑧 ∨ 𝑥𝑦
𝑥𝑦 ∨ 𝑥𝑧 = 𝑥𝑦 ∨ 𝑥𝑧 ∨ 𝑦𝑧
𝑛
𝑛
(DEMORGANsche Gesetze)
⋁ 𝑥𝑖 = ⋀ 𝑥𝑖
𝑖=1
(Neutrale Elemente)
(Dominanz)
(Neutralität)
(Doppelte Negation)
(Komplementtheorem)
(Idempotenz)
(Absorption)
(Nichtorthogonale
Minimierung)
(Assoziativität)
(Kommutativität)
(Distributivität)
(DEMORGANsche Gesetze)
𝑖=1
(𝑥 ∨ 𝑦)(𝑥 ∨ 𝑦) = 𝑥
𝑥𝑦 ∨ 𝑥𝑧 = (𝑥 ∨ 𝑧)(𝑥 ∨ 𝑦)
(𝑥 ∨ 𝑦)(𝑥 ∨ 𝑧) = (𝑥 ∨ 𝑦)(𝑥 ∨ 𝑧)(𝑦 ∨ 𝑧)
60
(Vereinfachungstheorem)
(Faktorisierungstheorem)
(Consensustheorem)
6.3.2
Boolesche Ringe BR(k)
𝐵𝑅⨁ (𝑘)
Antivalenz, EXOR ≁, ⨁
𝑥 ≁ 𝑥 = 𝑥⨁𝑥 = 0
𝑥≁0=𝑥
𝑥≁𝑥=1
𝑥≁1=𝑥
𝑥 ≁ 𝑥𝑦 = 𝑥(1 ≁ 𝑦) = 𝑥𝑦
𝑥 ≁ (𝑦 ≁ 𝑧) = (𝑥 ≁ 𝑦) ≁ 𝑧
𝑥≁𝑦=𝑦≁𝑥
𝑥 ∧ (𝑦 ≁ 𝑧) = 𝑥𝑦 ≁ 𝑥𝑧
𝑥 ≁ 𝑦 = 𝑥~𝑦 = 𝑥~𝑦
𝑥 ≁ 𝑦 ≁ 𝑧 = 𝑥~𝑦~𝑧 = 𝑥~𝑦~𝑧
𝑛
∑ 𝑥𝑖 =
n
𝑖=1
𝑛
n
𝑖=1
6.3.3
n
E𝑥 = E𝑥
i 1
∑ 𝑥𝑖 =
n
𝑖
i 1
𝑖
n
i 1
i 1
𝑛
𝑖
𝑛
E 𝑥 = ∑𝑥 = ∑𝑥
i 1
𝑖
n
E𝑥 = E𝑥
𝑖
𝐵𝑅⨂ (𝑘)
Äquivalenz, EXAND ~, ⨂
𝑥~𝑥 = 𝑥⨂𝑥 = 1
𝑥~1 = 𝑥
𝑥~𝑥 = 0
𝑥~0 = 𝑥
𝑥~(𝑥 ∨ 𝑦) = 𝑥 ∨ (0~𝑦) = 𝑥 ∨ 𝑦
(Assoziativität)
𝑥~(𝑦~𝑧) = (𝑥~𝑦)~𝑧
(Kommutativität)
𝑥~𝑦 = 𝑦~𝑥
(Distributivität)
𝑥 ∨ (𝑦~𝑧) = (𝑥 ∨ 𝑦)~(𝑥 ∨ 𝑧)
𝑥~𝑦 = 𝑥 ≁ 𝑦 = 𝑥 ≁ 𝑦
𝑥~𝑦~𝑧 = 𝑥 ≁ 𝑦 ≁ 𝑧 = 𝑥 ≁ 𝑦 ≁ 𝑧
𝑖
𝑖
𝑖=1
𝑖=1
𝑛
𝑛
E 𝑥 = ∑𝑥 = ∑𝑥
i 1
𝑖
𝑖
𝑖=1
𝑖
n gerade
n ungerade
𝑖=1
Transformationsgesetze
𝐵𝑅≁ (𝑘) → 𝐵𝑉(𝑘):
𝐵𝑅~ (𝑘) → 𝐵𝑉(𝑘):
𝑥 ≁ 𝑦 = 𝑥𝑦 ∨ 𝑥𝑦 = (𝑥 ∨ 𝑦)(𝑥 ∨ 𝑦) 𝑥~𝑦 = 𝑥𝑦 ∨ 𝑥̅ 𝑦̅ = (𝑥 ∨ 𝑦)(𝑥 ∨ 𝑦)
1≁𝑥=𝑥
0~𝑥 = 𝑥
𝐵𝑉(𝑘) → 𝐵𝑅≁ (𝑘):
𝑥 ∨ 𝑦 = 𝑥 ≁ 𝑦 ≁ 𝑥𝑦
𝑥=1≁𝑥
𝐵𝑉(𝑘) → 𝐵𝑅~ (𝑘):
𝑥 ∧ 𝑦 = 𝑥~𝑦~(𝑥 ∨ 𝑦)
𝑥 = 0~𝑥
61
erste Inhibition
𝑎∧𝑏
b
𝑎∧𝑏
a
𝑎≁𝑏
0010
0011
0100
0101
0110
62
ÄQUIVALENZ, EXAND
erste NEGATION, NOT
𝑎∨𝑏
𝑎~𝑏
𝑎
𝑎→𝑏
𝑏
𝑏→𝑎
𝑎∧𝑏
1
1000
1001
1010
1011
1100
1101
1110
1111
Einsfunktion
NICHT-UND-Verknüpfung, NAND
zweite IMPLIKATION
zweite NEGATION, NOT
erste IMPLIKATION
NICHT-ODER-Verknüpfung, NOR
𝑎∨𝑏
y = 0111
ODER-Verknüpfung
ANTIVALENZ, EX[clusiv]OR
zweite Identität
zweite Inhibition
erste Identität
UND-Verknüpfung, AND
𝑎∧𝑏
0001
Nullfunktion
Bezeichnung der Funktion bzw. der
Operation
0
𝑦 = 𝑓(𝑎, 𝑏)
0000
𝑎 = 0101
𝑏 = 0011
nicht (a und b), a nand b
b impliziert a
nicht b, b negiert
a impliziert b
nicht a, a negiert
a äquivalent b
nicht (a oder b), a nor b
a oder b
a antivalent b
a und nicht b
nicht a und b
a und b
Sprechweise
1(𝑥)
𝑎 ⋅ 𝑏 = (𝑎𝑏)
𝑏 + 𝑎 = 𝑏 + 𝑎
1⨁𝑏
𝑎 + 𝑏 = 𝑎 + 𝑏
1⨁𝑎
𝑎⨂𝑏 = 𝑎 ↔ 𝑏 = (𝑎𝑏) + (𝑎̅𝑏̅)
𝑎 + 𝑏 = (𝑎 + 𝑏)
𝑎+𝑏
𝑎⨁𝑏 = 𝑎 ↮ 𝑏 = (𝑎𝑏) + (𝑎𝑏)
a
𝑎 ⋅ 𝑏 = 𝑎 ⋅ 𝑏
b
𝑎 ⋅ 𝑏 = 𝑎 ⋅ 𝑏
𝑎⋅𝑏
0(𝑥)
Alternative Schreibweise
6.4
Alle Schaltfunktionen von zwei Variablen und ihre
Interpretation als binäre Operation
6.5
Realisierungsbasis und zugehörige Form einer
Funktion-TVL
für
den
zweistufigen
Kombinatorikentwurf (nach D. Bochmann)
2. Stufe
1.Stufe
AND
OR
NAND
NOR
AND OR NAND NOR
D(f)
X
𝐷(𝑓)
X
X
𝐷(𝑓)
D(f)
X
𝐷(𝑓) X
X 𝐷(𝑓)
X
K(f)
X
K(f)
X = keine Realisierungsbasis
Vereinbarung: „NDM“ = „Negation nach De Morgan“
Interpretation in der Tabelle:
𝐷(𝑓) bedeutet NDM von f(x), also mittels TVL 0 → 1, 1 → 0, −→ − ⟹ 𝐾(𝑓) = 𝐷(𝑓), d.h.
Nullen aus dem KP von f(x) auslesen für 𝐷(𝑓) und dann NDM.
6.6
Flip-Flop (FF) – Gleichungen
Q = interne FF-Zustandsvariable
1
𝑄 = 𝑄(𝑡 + 1) bzw. 1𝑄 = 𝑄(𝑡 + Δ𝑡) = interne Folgezustandsvariable
R, S, T, J, K, D, V, etc. = FF-Eingänge (Ansteuervariablen)
Das Gesamtverhalten eines FF wird durch die angegebene Gleichung und durch eine
eventuell gültige Nebenbedingung (NB)  bestimmt und ist insgesamt (also mit NB)
umgesetzt worden in die Tabelle der FF-Ansteuerwerte!
RS-FF: 1𝑄 = 𝑆 ∨ 𝑅𝑄 mit der NB 𝜑 = 𝑅𝑆 = 0
JK-FF: 1𝑄 = 𝑄𝐽 ∨ 𝑄𝐾 = 𝑄𝐽 ≁ 𝑄𝐾
D-FF: 1𝑄 = 𝐷
T-FF: 1𝑄 = 𝑄 ≁ 𝑇 = 𝑄𝑇 ∨ 𝑄𝑇 bzw. 𝑄̇ = 𝑇, da gilt 𝑄̇ = 1𝑄 ≁ 𝑄
DV-FF: 1𝑄 = 𝑉𝑄 ∨ 𝐷𝑉
JR-FF: 1𝑄 = 𝑅 ⋅ (𝐽 ∨ 𝑄)
SK-FF: 1𝑄 = 𝑆 ∨ 𝐾𝑄
RST-FF: 1𝑄 = 𝑆 ∨ 𝑇𝑄̅ ∨ 𝑅̅ 𝑇̅𝑄 mit der Nebenbedingung 𝜑 = 𝑅𝑆 ∨ 𝑅𝑇 ∨ 𝑆𝑇 = 0
63
6.7
Tabelle der FF-Ansteuerwerte
gegeben: Übergang 𝑄 ⇒ 1𝑄 bzw. Änderungsrichtung 𝑄̇ = 𝑄 ≁ 1𝑄
gesucht: Ansteuerwerte für FF-Eingänge
Q 𝑄̇
R S
J
K
0
0
0
-
0
0
-
0
1
1
0
1
1
-
0
-
-
0
-
0
-
-
1
0
1
1
0
-
1
1
1
0
0
-
-
0
1
-
-
0
-
0
-
-
Q
1
J R S K D V D T R S T L
0 0 0 0 0 - 0 0 0
- 1
- 0
0 0 1
1 0 1 - 1 1 1 1
1
0 1 0
- 0 0
- - - - - - - - 0 - 0 0 0 0 0 1
- 1 0 1 0 1 0 1
X
1 0 0
- 0 - 0
- 0
1 0 0 - 0 1 - 1 - 0 0
- - - - - - - - 0 - 0 0 0 -
X = nicht realisierbar
64