Teil IV: Schaltwerke; Sequentielle Schaltungen; Lineare Schaltkreise

Teil IV
Schaltwerke
1

Teil IV.1
Flip–Flops
2

Bistabile Kippstufe
• Ziel: Speichere Ausgabe einer Schaltung.
• Ansatz: Leite Ausgabe wieder als Eingabe in die Schaltung.
x
t
&
Q
Q = x + P
t + t
t
t
y
t
&
P
P = y + Q
t + t
t
t
• Ergebnis: Sei ∆t die Laufzeit des Signals:
• Wenn das P –Gatter zuerst schaltet:
Q t+∆t = x t + P t+∆t , P t+∆t = y t + Q t
• Wenn das Q–Gatter zuerst schaltet:
Q t+∆t = x t + P t , P t+∆t = y t + Q t+∆t
3

Verhalten in mehreren Stufen
• P -Gatter schaltet zuerst:
x t y t P t+∆t = y t Q t Q t+∆t = x t P t+∆t P t+2∆t = y t Q t+∆t Q t+2∆t = x t P t+2∆t
0 0 1 1 1 1
0 1 Q t 1 0 1
1 0 1 0 1 0
1 1 Q t Q t Q t Q t
• Q-Gatter schaltet zuerst:
x t y t Q t+∆t = x t P t P t+∆t = y t Q t+∆t Q t+2∆t = x t P t+∆t P t+2∆t = y t Q t+2∆t
0 0 1 1 1 1
0 1 1 0 1 0
1 0 P t 1 0 1
1 1 P t P t P t P t
• Verhalten:
• Ausgabe schwingt nach 2 Takten ein.
• Eingabe (0, 0) führt immer zu Ausgabe P = Q = 1
• Eingaben (0, 1) und (1, 0) führen zu P = Q
(0, 1) setzt Q (set), (1, 0) löscht Q (reset).
• Für Eingabe (1, 1) gilt nur dann P t+∆ = Q t+∆ , wenn P t = Q t ,
daher muß Eingabe (0, 0) ausgeschlossen werden.
In diesem Fall gilt (1, 1) hält Q (hold).
4

RS–Flip–Flop
• Takt: C wird periodisch zwischen 0 und 1 geschaltet, bei 1 Aktion,
bei 0 keine Aktion. Zwei Schritte (C t = 1, C t+∆t = 0) entsprechen
einem Takt.
• Set: S setzt den Ausgang Q auf 1.
• Reset: R setzt den Ausgang Q auf 0.
• Schaltung: mittels vorgeschaltetem NAND Gatter:
S
&
&
Q
S
Q
C
C
&
&
Q
R
R
Q
5

RS–Flip–Flop (cont.)
• Es gilt:
x = SC
y = RC
• Verhalten:
Q t+2∆t = x t + P t+∆t
= x t + y t Q t
= SC + RCQ t
= SC + ( R + C ) Q t
= SC + ( )
RQ t + CQ t
= C · (S + RQ t ) + CQ t .
• Für C = 1: Q t+2∆t = Q n+1 = S + (R · Q n ), S · R = 0
• Für C = 0: Q t+2∆t = Q n+1 = Q n 6

Wahrheitstabelle für RS–Flip–Flop
R S Q n+1 Q n+1 Aktion
0 0 Q n Q n lesen
0 1 1 0 setzen
1 0 0 1 löschen
1 1 1 1 nicht erlaubt
7

JK–Flip–Flop
• Problem: Verhindere, dass S · R = S = R = 1
• Lösung: Zwei neue Eingänge J, K und Rückkopplung von Ausgang
Q.
• Schaltung:
R n+1 = K · Q n
S n+1 = J · Q n
Q n+1 = S n+1 + (R n+1 · Q n )
= J · Q n + (K · Q n · Q n )
= J · Q n + ((K + Q n ) · Q n )
= J · Q n + K · Q n
8

Wahrheitstabelle für JK–Flip–Flop
J K Q n Q n+1 S R Aktion
0 0 0 0 0 − lesen
0 0 1 1 − 0 lesen
0 1 0 0 0 − löschen
0 1 1 0 0 1 löschen
1 0 0 1 1 0 setzen
1 0 1 1 − 0 setzen
1 1 0 1 1 0 invertieren
1 1 1 0 0 1 invertieren
R = S = 1 ist erfolgreich verhindert.
9

Spezialfall D–Flip–Flop
• Delay–Flip–Flop: Wie RS–Flip–Flop mit S = D, R = D; dadurch
wird die verbotene Eingabe (1, 1) ausgeschlossen.
• Wahrheitstabelle:
D Q n+1 Aktion
0 0 Speichere die Eingabe 0
1 1 Speichere die Eingabe 1
10

Teil IV.2
Sequentielle Schaltungen
11

Beispiel: Register
• Parallele Eingänge: x 0 , x 1 , x 2 , x 3
• Serieller Eingang: x s
• Parallele Ausgänge: y 0 , y 1 , y 2 , y 3
• Takt T
• Schalter E: serielles Lesen (= 0), paralleles Lesen (= 1)
• Schalter A: durchschalten der Ausgänge (= 1), oder konstante Belegung mit
1 (= 0)
12

Sequentielle Maschine
Mealy–Automat M = (E, S, Z, δ, γ, s 0 )
• Eingabealphabet: E ⊆ B n e
• Ausgabealphabet: Z ⊆ B n a
• Menge von Zuständen: S ⊆ B n z
• Startzustand: s 0 ∈ S
• Übergangsfunktion: δ : E × S → S
• Ausgabefunktion γ : E × S → Z
13

Beispiel: JK–Flip–Flop
• Wahrheitstabelle:
S = Q n E = J, K δ(s, e) = Q n+1 γ(s, e) = Q n
0 00 0 0
0 01 0 0
0 10 1 0
0 11 1 0
1 00 1 1
1 01 0 1
1 10 1 1
1 11 0 1
• Automat:
14

Beispiel: 2-Bit Register (I)
• Schaltung:
15

Beispiel: 2-Bit Register (II)
• Automat:
16

Beispiel: 1–Bit Addition
Ziel: Serielle Addition von zwei (beliebig langen) Bitströmen
• Eingabealphabet: E = {00, 01, 10, 11}
• Ausgabealphabet: Summe Z = {0, 1}
• Zustände: Übertrag S = {0, 1}
• Startzustand: s 0 = 0 (kein Übertrag)
• Übergangsfunktion: siehe Übertrag in Volladdierer
• Ausgabefunktion: siehe Summe in Volladdierer
17

Beispiel: 1–Bit Addition (cont.)
• Automat
• Wahrheitstabelle
c xy δ(c, x, y) γ(c, x, y)
0 00 0 0
0 01 0 1
0 10 0 1
0 11 1 0
1 00 0 1
1 01 1 0
1 10 1 0
1 11 1 1
18

Realisierung mit JK–Flip–Flop
• Übertrag: δ : E × S → S
δ(c, x, y) = cxy + cxy + cxy + cxy
= cxy + cx + cy
= cxy + c(x + y)
• Für JK–Flip–Flop gilt:
Q n+1 = J · Q n + K · Q n
Substitution: Q n+1 = δ(c, x, y) , Q n = c
J = xy , K = x + y
• Summe: γ(c, x, y) = c ⊕ x ⊕ y
• Schaltung:
19

Beispiel: Modulo 6 Zähler
• Eingabealphabet: E = {0, 1}
• Ausgabealphabet: Summe Z = {000, 001, 010, 011, 100, 101}
• Zustände: S = Z
• Startzustand: s 0 = 000
• Übergangsfunktion:
δ(S, 1) = (S + 1) mod 6
δ(S, 0) = (S − 1) mod 6
• Ausgabefunktion:
γ(S, E) = S
20

Automat für Modulo 6 Zähler
• Automat:
• Übergangstabelle:
e q 0 q 1 q 2 δ 0 δ 1 δ 2
0 0 0 0 0 0 1
0 0 0 1 0 1 0
0 0 1 0 0 1 1
0 0 1 1 1 0 0
0 1 0 0 1 0 1
0 1 0 1 0 0 0
1 0 0 0 1 0 1
1 0 0 1 0 0 0
1 0 1 0 0 0 1
1 0 1 1 0 1 0
1 1 0 0 0 1 1
1 1 0 1 1 0 0
21

Realisierung mit RS–Flip–Flops
• Wahrheitstabelle für RS–Flip-Flops:
Q Q ′ R S
0 0 ∗ 0
0 1 0 1
1 0 1 0
1 1 0 ∗
• Eingesetzt in Übergangstabelle:
e q 0 q 1 q 2 q
0 ′ q
1 ′ q
2 ′ R 0 S 0 R 1 S 1 R 2 S 2
0 0 0 0 0 0 1 ∗ 0 ∗ 0 0 1
0 0 0 1 0 1 0 ∗ 0 0 1 1 0
0 0 1 0 0 1 1 ∗ 0 0 ∗ 0 1
0 0 1 1 1 0 0 0 1 1 0 1 0
0 1 0 0 1 0 1 0 ∗ ∗ 0 0 1
0 1 0 1 0 0 0 1 0 ∗ 0 1 0
1 0 0 0 1 0 1 0 1 ∗ 0 0 1
1 0 0 1 0 0 0 ∗ 0 ∗ 0 1 0
1 0 1 0 0 0 1 ∗ 0 1 0 0 1
1 0 1 1 0 1 0 ∗ 0 0 ∗ 1 0
1 1 0 0 0 1 1 1 0 0 1 0 1
1 1 0 1 1 0 0 0 ∗ ∗ 0 1 0
22

Realisierung mit RS–Flip–Flops (cont.)
• Ansteuergleichungen: mittels Karnaugh-Verfahren unter Ausnutzung
der don’t cares (*).
R 0 = eq 0 q 2 + eq 0 q 2 = q 0 · (e ⊕ q 2 )
S 0 = e q 0 q 1 q 2 + eq 0 q 1 q 2
R 1 = eq 1 q 2 + eq 1 q 2 = q 1 · (e ⊕ q 2 )
S 1 = e q 0 q 1 q 2 + eq 0 q 2
R 2 = q 2
S 2 = q 2
23

Realisierung mit RS–Flip–Flops (cont.)
• Schaltung:
q 0 q 1 q 2
S S S
FF 0 FF 1 FF 2
T T T
R R R
e
Takt
1
&
&
&
&
&
&
24

Teil IV.3
Lineare Schaltkreise
25

Bausteine
a) Addierer
b) Skalarmultiplizierer
c) Delay
26

Anwendung: Codierung
• Gegeben:
Polynome a(x) = a 0 + a 1 x + . . . + a k−1 x k−1
Ein festes Codierungspolynom h(x) = h 0 + h 1 x + . . . h n−k x n−k
• Berechne:
Codierung: a(x) ∗ h(x) = f(x) = f 0 + f 1 x + . . . + f n−1 x n−1
Decodierung: f(x)/h(x) = a(x)
• Schaltung für Multiplikation:
27

Wie funktionierts?
Polynomkoeffizienten werden mit dem höchsten a k−1 beginnend der
Reihe nach eingegeben. Die Delays sind mit Nullen vorbelegt.
• Schritt 1:
O = f n−1 = a k−1 · h n−k
d 0 = a k−1
• Schritt 2:
O = f n−2 = a k−2 · h n−k + d 1 · h n−k−1 = a k−2 · h n−k + a k−1 · h n−k−1
d 0 = a k−2 , d 1 = a k−1
• Schritt k:
O = f n−k = a 0 · h n−k + a 1 · h n−k−1 + . . . a k−1 · h n−2k+1
d 0 = a 0 , . . . , d n−k−1 = a k−1
• Schritt k + 1: a i = 0 für i ≥ k
O = f n−k−1 = a 0 · h n−k−1 + . . . a k−2 · h n−2k+1
d 0 = 0, . . . , d n−k−1 = a k−2
• Schritt n − k:
O = f 0 = a 0 · h 0
28

Beispiel für E = {0, 1}
• Codierungspolynom:
h(x) = 1 ⊕ x 3 ⊕ x 4 ⊕ x 5
• Wg. E = B:
Skalarmultiplikation entfällt, Addition: modulo 2 (xor)
• Schaltung:
29

Spiegelschaltung für Division
• Schritt 1 bis n − k − 1:
O = 0
• Schritt n − k:
O = f n−1 · h −1
n−k = a k−1
• Schritt n − k + 1:
O = (f n−2 − f n−1 h n−k−1 h −1 )h −1
n−k = a k−2.
30

Beispiel für E = {0, 1}
• Codierungsplynom:
h(x) = 1 ⊕ x ⊕ x 4
• Wg. E = B gilt:
h i = −h i , h n−k = 1
• Schaltung:
31