WEBVTT

00:04.480 --> 00:06.240
Herzlich willkommen zur 15.

00:06.440 --> 00:06.960
Vorlesung.

00:08.540 --> 00:11.940
Wir wollen uns heute mit verschiedenen Flip-Flop-Arten beschäftigen

00:11.940 --> 00:15.360
und falls wir soweit kommen, nochmal den Serienaddierer betrachten.

00:16.680 --> 00:21.780
RS-Flip-Flop kennt ihr ja schon, zumindest das asynchrone RS-Flip

00:21.780 --> 00:22.040
-Flop.

00:23.100 --> 00:28.640
Und wir haben festgestellt, dass bei asynchronen Schaltwerken Probleme

00:28.640 --> 00:34.520
auftreten, die wir beheben können, wenn wir bei asynchronen

00:34.520 --> 00:36.560
Schaltwerken einen zentralen Takt benutzen.

00:39.440 --> 00:44.380
Wir hatten ja kritische Zustandsübergänge betrachtet und bei

00:44.380 --> 00:47.840
Synchronen funktioniert das so, dass sich die Eingabenbelegungen

00:47.840 --> 00:50.880
stabilisieren, bevor ein neuer Zustand eingenommen wird.

00:51.380 --> 00:54.760
Das heißt, dieses Problem wird dadurch behoben.

00:58.200 --> 01:02.040
Dafür benötigen wir allerdings taktische Zustandsspeicher und diese

01:02.040 --> 01:07.520
Zustandsspeicher, wie ihr auch schon kennt, implementieren wir durch

01:07.520 --> 01:08.880
verschiedene Arten von Flip-Flops.

01:10.220 --> 01:12.980
Und wir wollen jetzt hier die verschiedenen Flip-Flop-Typen nochmal

01:12.980 --> 01:16.300
anschauen und ein bisschen genau betrachten.

01:17.000 --> 01:18.540
Anfangen tun wir mit dem RS-Flip-Flop.

01:18.820 --> 01:20.560
Das kennen wir ja schon, das asynchrone zumindest.

01:21.640 --> 01:24.220
Wir haben zwei Eingänge, einmal R und einmal S.

01:25.280 --> 01:28.980
Die Interpretation sieht so aus, dass... Ist die Akustik okay

01:28.980 --> 01:29.360
eigentlich?

01:29.660 --> 01:30.020
Zu laut?

01:30.100 --> 01:30.480
Zu leise?

01:31.420 --> 01:31.740
Gut.

01:32.400 --> 01:33.260
Wie sieht es hinten aus?

01:35.000 --> 01:35.500
Einwandfrei.

01:36.820 --> 01:41.160
Also Interpretation sieht so aus, dass R für Reset steht, S für Set.

01:42.140 --> 01:46.880
Wenn ich jetzt die Eingabebelegung RS00 habe, dann habe ich die

01:46.880 --> 01:49.660
Funktion Speichern, das heißt der interne Zustand meines Flip-Flops

01:49.660 --> 01:51.340
wird gespeichert, er wird nicht verändert.

01:52.400 --> 01:56.980
Wenn ich S gleich 1 habe und R gleich 0, dann setze ich, also habe ich

01:56.980 --> 02:01.520
einen Set-Aufruf, ich setze den Zustand auf 1, das heißt mein

02:01.520 --> 02:04.520
Folgezustand ist unabhängig vom vorherigen Zustand, die 1.

02:05.700 --> 02:09.440
Und genauso, wenn ich ein R1 habe und S0 habe, setze ich zurück,

02:10.560 --> 02:13.140
resette ich den Zustand auf die 0.

02:14.980 --> 02:18.920
Wir haben hier diese rückgekoppelte Schaltung betrachtet und das

02:18.920 --> 02:22.760
Schaltsymbol dieses asynchronen RS-Flip-Flops sehen wir hier rechts

02:22.760 --> 02:23.060
unten.

02:24.780 --> 02:29.620
Hier sehen wir RS-Eingänge, einmal Q, den Ausgang, und einmal den

02:29.620 --> 02:31.000
negierten Ausgang, nicht Q.

02:35.660 --> 02:37.040
Behalten haben wir schon beschrieben.

02:37.780 --> 02:39.540
Hier noch mal zum Nachlesen.

02:40.660 --> 02:43.000
Das Einzige, was wir jetzt noch nicht gesagt hatten, aber was ihr auch

02:43.000 --> 02:45.940
schon zigmal gehört habt bestimmt, ist, dass wir eine verbotene

02:45.940 --> 02:49.980
Eingabebelegung haben, R und S gleichzeitig auf 1, die haben wir

02:49.980 --> 02:51.000
nämlich vorher nicht betrachtet.

02:51.580 --> 02:57.560
Wenn diese Eingabe stattfindet, dann ist das Verhalten des Flip-Flops

02:57.560 --> 03:00.480
unvorhersehbar, deswegen verbieten wir das einfach

03:04.380 --> 03:07.340
und wollen dann P und Q.

03:08.280 --> 03:13.140
Q und Q nicht eigentlich, beziehungsweise wenn wir jetzt das Q nicht

03:13.140 --> 03:16.720
als P bezeichnen, dann haben wir hier zwei Ausgaben des Flip-Flops,

03:16.900 --> 03:17.780
die komplementär sind.

03:22.820 --> 03:27.080
Wir betrachten jetzt das pegelig gesteuerte RS-Latch, das RS-Flip-Flop

03:27.080 --> 03:34.000
und dafür werden wir ein Taktsignal einführen, welches bei Inaktivität

03:34.000 --> 03:41.440
die Änderung der Zustandsvariablen verhindert.

03:41.660 --> 03:44.160
Und das kann man ganz leicht implementieren, indem man die

03:44.160 --> 03:46.480
verschiedenen Eingänge mit diesem Taktsignal verundet.

03:46.920 --> 03:51.900
Das heißt, wir haben hier S und Takt an den Eingang S unseres Flip

03:51.900 --> 03:57.600
-Flops, wir haben R und Takt an den Eingang R unseres RS-Flip-Flops.

03:58.440 --> 04:02.920
Das heißt, wenn mein T auf 0 wechselt, also wenn ich eine Low-Phase

04:02.920 --> 04:07.740
meines Taktes habe, dann werden automatisch R und S auf 0 gezwungen

04:07.740 --> 04:11.960
und 00, die Eingangsbelegung kennen wir ja schon, die steht ja für die

04:11.960 --> 04:15.100
Funktion Speichern, das heißt der interne Zustand des RS-Flip-Flops

04:15.100 --> 04:16.720
wird gespeichert, also nicht verändert.

04:18.380 --> 04:22.500
Und dementsprechend wirken sich dann die Änderungen an kleinen S und

04:22.500 --> 04:24.620
kleinen R nicht auf das RS-Flip-Flop aus.

04:25.160 --> 04:28.820
Habe ich dann ein T gleich 1, dann übernehme ich quasi hier das R oder

04:28.820 --> 04:32.820
das S, was jeweils anliegt, an den kleinen Eingängen und leite die

04:32.820 --> 04:34.120
dann weiter an das große SR.

04:38.380 --> 04:40.220
Das Schallsymbol sehen wir jetzt rechts unten.

04:40.880 --> 04:43.280
Im Vergleich zum vorherigen hat sich jetzt etwas geändert.

04:43.400 --> 04:46.020
Wir haben einmal ein T dazu bekommen und wir haben hier die

04:46.020 --> 04:52.120
Bezeichnungen statt S und R haben wir jetzt 1S und 1R und zusätzlich

04:52.120 --> 04:58.360
haben wir ein C1 beim Takt, C für Clock aus dem Englischen und 1 zeigt

04:58.360 --> 04:59.440
uns hier die Abhängigkeiten.

05:00.740 --> 05:02.600
Wie sieht es genau aus mit diesen Abhängigkeiten?

05:03.920 --> 05:08.320
Diese Ziffer 1 an den Eingängen bedeutet, dass sie in der Wirksamkeit

05:08.320 --> 05:14.720
von diesem C abhängen und das 1 nach dem C bedeutet, dass dieses Clock

05:14.720 --> 05:16.880
Auswirkungen hat auf dieses S und R.

05:17.620 --> 05:22.480
Also zusammengefasst, wenn ein Eingang die Abhängigkeit verursacht, so

05:22.480 --> 05:30.120
folgt die Ziffer auf die Variable wie beim C und wird sie beeinflusst

05:30.120 --> 05:35.180
von einem anderen Eingang, so geht sie der Variablen voraus.

05:38.960 --> 05:41.480
Dann haben wir Ansteuertabellen betrachtet.

05:44.500 --> 05:51.360
Wenn wir synchronische Haltwerke entwerfen wollen, dann kennen wir ja

05:51.360 --> 05:54.140
meistens die Zustände und die Folgezustände, in welche wir übergehen

05:54.140 --> 05:54.420
wollen.

05:56.520 --> 06:00.340
Was wir suchen, sind die Ansteuervariablen für die verschiedenen Flip

06:00.340 --> 06:08.500
Flops, die hier für Zustandsspeicher stehen und die Werte dieser

06:08.500 --> 06:11.480
Ansteuervariablen können wir leicht aus der Ansteuertabelle der

06:11.480 --> 06:13.000
verschiedenen Flip Flops bestimmen.

06:18.210 --> 06:24.710
Diese lassen sich leicht aus den Ansteuertabellen der Flip Flops

06:24.710 --> 06:31.390
schließen und wir können uns hier ein Beispiel anschauen, wenn wir die

06:31.390 --> 06:35.370
Ansteuertabelle eines RS Flip Flops herleiten wollen, haben wir zwei

06:35.370 --> 06:35.930
Zustände.

06:36.510 --> 06:39.810
Wir haben einmal den Zustand 0 und einmal 1, repräsentativ für die

06:39.810 --> 06:44.770
interne Variable, die gespeichert wird, also für den internen Bitwert,

06:44.770 --> 06:47.210
den das RS Flip Flop speichert.

06:48.910 --> 06:55.250
Und wir haben hier eine Tabelle aufgestellt mit aktuellem Zustand auf

06:55.250 --> 06:59.490
der linken Seite und dem Folgezustand auf der rechten Seite und hier

06:59.490 --> 07:03.190
haben wir unsere Ansteuervariablen R und S jeweils zum Zeitpunkt T.

07:05.030 --> 07:08.030
Und jetzt wollen wir wissen, was passiert, wenn ich zum Beispiel im

07:08.030 --> 07:10.650
Zustand 0 bin und ich möchte im Zustand 0 bleiben.

07:12.490 --> 07:15.930
Ich habe zwei Möglichkeiten, wie ich das bewerkstelligen kann.

07:18.330 --> 07:24.070
Zum einen kann ich den Wert 0 speichern, das heißt, ich kann den

07:24.070 --> 07:26.190
aktuellen Zustand meines Flip Flops beibehalten.

07:26.750 --> 07:31.150
Das mache ich mit der Eingangsbelegung 00 oder ich kann sagen, ich

07:31.150 --> 07:35.870
möchte, egal was für einen aktuellen Zustand ich momentan in meinem RS

07:35.870 --> 07:37.750
Flip Flop gespeichert habe, zurücksetzen.

07:38.210 --> 07:41.810
Das bewerkstellige ich mit einem R gleich 1 und S gleich 0.

07:43.090 --> 07:48.050
Zusammenfassend kann ich sagen, solange S gleich 0 ist, spielt das R

07:48.050 --> 07:48.530
keine Rolle.

07:49.410 --> 07:52.410
Das heißt, R kann 0 oder 1 sein, in dem Fall also ein Don't Care sein.

07:53.010 --> 07:56.670
Das heißt, mit der Eingabebelegung Don't Care 0 würde ich auf alle

07:56.670 --> 08:00.130
Fälle im Zustand 0 bleiben.

08:00.970 --> 08:05.210
Also starten im Zustand 0 und als Folgezustand im Zustand 0 haben.

08:05.670 --> 08:07.930
Das heißt, hier trage ich meine Don't Care 0 ein.

08:10.750 --> 08:13.830
Was passiert jetzt, wenn ich vom Zustand 0 in den Zustand 1 wechseln

08:13.830 --> 08:13.990
will?

08:15.090 --> 08:16.410
Da gibt es nur eine Möglichkeit.

08:16.690 --> 08:20.930
Ich kann dem Flip Flop sagen, er soll bitte das Bit setzen und das

08:20.930 --> 08:24.190
mache ich mit meiner 01, also mit Eingangsbelegung Set.

08:25.730 --> 08:28.890
Und hier habe ich die 01, die trage ich dann hier in meiner Tabelle

08:28.890 --> 08:29.170
ein.

08:34.360 --> 08:37.980
Genauso, wenn ich von der 1 auf die 0 will, muss ich zurücksetzen,

08:38.120 --> 08:41.440
also Resetten und das Bewerkstatten legt sich dann auch mit 1, 0 für

08:41.440 --> 08:44.320
Reset und auch das kann ich eintragen in 1, 0.

08:44.740 --> 08:47.780
Wenn ich jetzt im Zustand 1 bin und ich möchte im Zustand 1 bleiben,

08:48.040 --> 08:49.360
habe ich wieder zwei Möglichkeiten.

08:50.080 --> 08:53.560
Genauso wie beim ersten Zustand kann ich sagen, entweder ich bleibe in

08:53.560 --> 09:00.040
meinem Zustand 1, also Speichern, oder ich setze die 1 als Zustand.

09:01.640 --> 09:03.680
Beide Fälle sind 00, 01.

09:03.880 --> 09:06.320
Das heißt, hier kann ich das S wieder zusammenfassen als ein Don't

09:06.320 --> 09:10.660
-Care und ich bekomme hier die Eingangsbelegung 0 Don't-Care und trage

09:10.660 --> 09:11.560
das auch hier ein.

09:12.580 --> 09:15.460
So, das rechts unten nennt sich Ansteuertabelle für das Flipflop.

09:16.540 --> 09:22.880
Das heißt, wie muss ich das Flipflop ansteuern, um von einem gegebenen

09:22.880 --> 09:25.320
Zustand in einen Folgezustand zu gelangen.

09:32.020 --> 09:37.040
Ansteuertabelle des Asynchron RS Flipflops kennt ihr schon, sieht

09:37.040 --> 09:38.180
eigentlich genauso aus.

09:39.160 --> 09:43.400
Wir hatten hier nur tatsächlich die Voraussetzung gesetzt, dass keine

09:43.400 --> 09:45.580
unerlaubten Eingabebelegungen auftreten dürfen.

09:46.820 --> 09:49.200
Und bei Asynchron wisst ihr ja, dass es ein bisschen komplizierter

09:49.200 --> 09:56.600
ist, weil vor allem, wenn ich einen Wechsel habe zum Beispiel von 01

09:56.600 --> 10:01.520
auf 10, dann habe ich abhängig von der Schaltgeschwindigkeit, also der

10:01.520 --> 10:03.900
Änderungsgeschwindigkeit, was sich zuerst ändert, welche

10:03.900 --> 10:07.820
Eingabevariante sich zuerst ändert, kann ich tatsächlich in diesen

10:07.820 --> 10:12.560
unerlaubten Zustand gelangen.

10:19.280 --> 10:21.600
Zusammengefasst hatten wir gesagt, für diese verbotene

10:21.600 --> 10:27.480
Eingabebelegung, dass wir eine Nebenbedingung haben, die heißt R und S

10:27.480 --> 10:28.160
ist gleich 0.

10:29.120 --> 10:32.960
Solange diese Nebenbedingung erfüllt ist, sind wir sicher.

10:33.240 --> 10:34.300
Das heißt, da kann nichts passieren.

10:34.620 --> 10:36.640
Wir kommen nicht in diese verbotene Eingabebelegung.

10:37.520 --> 10:42.780
Und wenn ich jetzt meinen RS-Flipflop betrachte, wie kann ich das

10:42.780 --> 10:43.500
bewerkstelligen?

10:44.000 --> 10:48.020
Ich könnte zum Beispiel einen neuen Eingang erzeugen, den nennen wir

10:48.020 --> 10:53.520
jetzt Eingang D, und führe diesen Eingang D negiert zu meinem R

10:53.520 --> 10:53.960
-Eingang.

10:55.980 --> 11:02.600
Somit gewährleiste ich, dass wenn D1 ist, ist S1 und R gleich 0.

11:03.140 --> 11:05.880
Wenn D0 ist, ist S0 und R gleich 1.

11:10.620 --> 11:14.880
Das garantiert mir, dass diese Nebenbedingung immer erfüllt ist.

11:16.120 --> 11:18.140
Funktioniert natürlich auch nur, weil wir hier synchron sind.

11:18.240 --> 11:20.580
Das heißt, wir haben hier einen Takt und zu diesen bestimmten

11:20.580 --> 11:25.040
Taktzeiten muss natürlich diese Eingabebelegung stabil anliegen.

11:25.500 --> 11:27.760
Ansonsten habe ich genau das gleiche Problem wie beim Asynchron.

11:29.540 --> 11:33.120
Wenn ich jetzt einen blauen Kasten drum herum mache und ein neues

11:33.120 --> 11:38.680
Schaltsymbol für diese Schaltung definiere, dann reden wir von einem

11:38.680 --> 11:45.320
sogenannten D-Latch aus einem D-Flipflop und hier sehen wir einmal den

11:45.320 --> 11:51.900
Takt als Eingabe C1 und einmal 1D, abhängig vom Takt, den D-Eingang

11:51.900 --> 11:54.300
und Ausgabe sind wieder Q und nicht Q.

11:58.080 --> 12:01.200
Wie sieht die Funktionstabelle meines D-Latches aus?

12:05.280 --> 12:07.360
Wir können uns das jetzt folgern.

12:07.460 --> 12:10.780
Wir haben ja ein RS-Flipflop, das heißt, das D wird ja an mein S

12:10.780 --> 12:15.200
weitergeleitet und das negierte D wird an mein R weitergeleitet.

12:15.960 --> 12:23.040
Das heißt, bin ich im Zustand 0 und habe ein D gleich 0, dann ist mein

12:23.040 --> 12:25.700
Set -Eingang 0 und mein Reset-Eingang ist 1.

12:26.480 --> 12:29.280
Das heißt, wenn D 0 ist, habe ich immer die Reset-Bedingung.

12:30.000 --> 12:31.560
Ich setze immer zurück auf 0.

12:32.600 --> 12:34.560
Das heißt, mein Folgezustand ist die 0.

12:35.040 --> 12:39.920
Genauso bei Zustand 1 habe ich bei D gleich 0 wieder dieses Reset.

12:40.260 --> 12:44.640
Das heißt, ich gehe über in den Folgezustand 0, habe ich auf D gleich

12:44.640 --> 12:49.520
1, also habe ich hier bei D gleich eine 1, ist ja mein Set-Eingang

12:49.520 --> 12:52.380
gesetzt und mein Reset-Eingang ist negiert, also die 0.

12:53.240 --> 12:57.080
Das heißt, mein Folgezustand ist dann auch hier die 1.

12:57.780 --> 13:01.860
Auch bei Zustand 1 mit dem D gleich 1 bin ich auch im Folgezustand 1.

13:03.320 --> 13:04.960
Was sagt uns das über das Verhalten?

13:07.040 --> 13:10.680
Wir sehen hier eigentlich, dass der Folgezustand immer genau meinem

13:10.680 --> 13:11.840
Eingabewert entspricht.

13:13.680 --> 13:18.680
Das heißt, egal was mein Zustand ist, ich übernehme einfach den

13:18.680 --> 13:22.220
Eingabezustand als Folgezustand.

13:25.890 --> 13:28.870
Wie können wir jetzt die Ansteuertabelle daraus bekommen?

13:29.430 --> 13:32.230
Also das ist die Funktionstabelle.

13:33.050 --> 13:34.690
Wir haben hier die Eingabebelegung.

13:35.450 --> 13:38.750
Daraus folgt dann, wie ich von einem bestimmten Zustand in den

13:38.750 --> 13:44.050
nächsten komme und wir wollen jetzt die Ansteuertabelle haben.

13:44.190 --> 13:47.450
Das heißt, wir wollen wissen, wenn ich einen Zustand habe und ich

13:47.450 --> 13:52.790
möchte in einen bestimmten Folgezustand, wie muss ich meinen Flipflop

13:52.790 --> 13:55.190
beschalten oder wie muss ich meine Eingabebelegung verändern.

13:56.290 --> 13:59.110
Und das können wir hier ganz einfach machen, indem wir die Spalten

13:59.110 --> 14:00.250
tauschen zunächst.

14:00.670 --> 14:05.850
Also wir ziehen Qt und Qt plus 1 nach vorne und

14:10.770 --> 14:14.150
zusätzlich muss ich dann hier die Zeile 2 und Zeile 3 auch nochmal

14:14.150 --> 14:14.610
tauschen.

14:15.070 --> 14:17.570
Das heißt, ich ziehe die Zeile 3 nach vorne, damit ich hier einfach

14:17.570 --> 14:20.470
die Durchnummerierung überleistet habe.

14:22.950 --> 14:25.370
Folglich ist es hier nur eine paar Mutationen und ich sehe dann, ich

14:25.370 --> 14:28.470
habe hier aus meiner Funktionstabelle meine Ansteuertabelle für das D

14:28.470 --> 14:29.170
-Flipflop gewonnen.

14:31.590 --> 14:32.530
Dazu Fragen?

14:39.290 --> 14:39.730
Keine?

14:39.730 --> 14:41.270
Schaltsymbol haben wir gesagt, sieht so aus.

14:41.390 --> 14:45.290
D-Flipflop, D-Eingang, Takteingang, Q und nicht Q als Ausgabe.

14:46.390 --> 14:54.710
Wenn wir jetzt ein Impulsdiagramm betrachten, also wie sehe dann das

14:54.710 --> 14:57.810
Verhalten meines D-Flipflops aus bei einer bestimmten Eingabebelegung

14:57.810 --> 15:02.870
und einem bestimmten Takt, dann habe ich hier einmal den Takt, wie man

15:02.870 --> 15:07.710
das also kennt und markiert hier sind die gelben Bereiche, wo der Takt

15:07.710 --> 15:08.230
null ist.

15:08.870 --> 15:13.110
Das heißt, das sind die Bereiche, wo das Flipflop nicht reagiert auf

15:13.110 --> 15:15.650
die Eingabe, also deaktiviert wird.

15:16.950 --> 15:19.630
Habe ich jetzt eine Eingabenbelegung, die so aussieht, also das lege

15:19.630 --> 15:26.710
ich jetzt an D an, eine kurze Impulsierung im weißen Bereich des

15:26.710 --> 15:30.490
Taktes, noch einen Impuls und noch mal einen Impuls im gelben Bereich.

15:31.710 --> 15:37.710
Dann kann ich sagen, sieht das Ausgabesignal genau so aus, das heißt,

15:38.450 --> 15:43.070
in dem weißen Bereich werden die anliegenden Eingabebelegungen

15:43.070 --> 15:48.790
übernommen, in unserem Fall sind es zwei Impulse und wenn der Takt

15:48.790 --> 15:52.570
null ist, also das Flipflop quasi deaktiviert ist, dann wird nur der

15:52.570 --> 15:54.570
aktuelle Zustand des Flipflops beibehalten.

15:55.170 --> 15:58.110
Das heißt, jegliche Eingaben hier werden ignoriert und haben dann auch

15:58.110 --> 15:59.590
keine Auswirkungen auf meinen Ausgang.

16:06.110 --> 16:10.910
Das hier nennen wir ein pegelgesteuertes D-Flipflop, das heißt, immer

16:10.910 --> 16:13.950
wenn der Pegel meines Taktes hoch ist, reagiert das Flipflop.

16:14.430 --> 16:18.230
Immer wenn der Pegel niedrig ist, also low ist, ist das Flipflop

16:18.230 --> 16:24.630
gesperrt und hält einfach nur den Zustand, den es aktuell hat, bei und

16:24.630 --> 16:26.670
reagiert nicht auf Eingabedaten.

16:27.950 --> 16:30.750
Was wir jetzt noch machen können, ist ein taktflankengesteuertes D

16:30.750 --> 16:31.190
-Flipflop.

16:31.290 --> 16:34.650
Das heißt, wir wollen jetzt nicht mehr nur reagieren, wenn der Takt

16:34.650 --> 16:41.350
high ist, also auf 1 ist, sondern wir wollen reagieren, wenn der Takt

16:42.010 --> 16:42.410
wechselt.

16:43.270 --> 16:47.210
Also bei einem Wechsel von 0 nach 1 habe ich eine Taktflanke, in dem

16:47.210 --> 16:51.610
Fall von 0,1 reden wir von einer Aufwärtsflanke und einer

16:51.610 --> 16:53.410
Abwärtsflanke, wenn wir von 1 nach 0 gehen.

16:57.150 --> 17:01.610
Um das zu implementieren, benutzen wir zwei D-Flipflops, die wir

17:01.610 --> 17:02.350
hintereinander schalten.

17:03.170 --> 17:06.990
Wir reden hier von einem Master-Slave-Flipflop, weil das erste das

17:06.990 --> 17:08.890
Masterledge ist und das zweite das Slaveledge.

17:09.750 --> 17:14.690
Ich hatte letztes Semester, glaube ich, die gleiche Vorlesung gehalten

17:14.690 --> 17:18.030
und habe dann gesagt, Master-Slave wurde, glaube ich, meines Wissens

17:18.030 --> 17:18.810
nach abgeschafft.

17:19.130 --> 17:21.810
Ich habe es dann nochmal gegoogelt, dann war es immer noch Master

17:21.810 --> 17:22.150
-Slave.

17:23.350 --> 17:25.090
Ich war der Meinung, es hätte man jetzt geändert.

17:26.450 --> 17:30.430
Also, Master-Slave-System, wie sieht das aus?

17:30.890 --> 17:34.710
Ich habe hier einen D-Flipflop, ich habe da einen D-Flipflop und ich

17:34.710 --> 17:35.670
habe hier einen Takteingang.

17:36.210 --> 17:39.570
Dieser Takteingang wird einmal negiert zum ersten geführt und nicht

17:39.570 --> 17:40.990
negiert zum zweiten Flipflop.

17:41.590 --> 17:44.950
Wenn ich jetzt Q1 betrachte, ist es hier mein Zwischenergebnis.

17:45.090 --> 17:52.390
Q1 ist die Ausgabe meines Master-Ledges und Q ist die Ausgabe meines

17:52.390 --> 17:53.370
Slave -Ledges.

17:54.170 --> 17:55.010
Was passiert jetzt?

17:56.690 --> 18:02.390
Wenn der Takt 0 ist, sperrt das zweite Flipflop.

18:03.950 --> 18:08.970
Das erste negiert den Takt, das heißt, der Takt 0 wird zu 1 und 1

18:08.970 --> 18:12.410
heißt, für das erste Flipflop übernimmt bitte alles, was bei D

18:12.410 --> 18:12.870
anliegt.

18:14.650 --> 18:19.850
Also, solange T 0 ist, wird alles, was hier als Eingabe anliegt, als

18:19.850 --> 18:24.090
Zustand in diesen Master-Ledge übernommen.

18:25.350 --> 18:29.430
Wenn ich jetzt wechsle von 0 auf 1, dann fängt an, meinen ersten

18:29.430 --> 18:30.370
Flipflop zu sperren.

18:31.130 --> 18:35.210
Das heißt, jegliche Veränderungen an D werden ignoriert, haben wir

18:35.210 --> 18:35.990
hier schon mal gesehen.

18:37.850 --> 18:41.610
Solange es bei 0 ist, beziehungsweise das erste Flipflop ist ja dann

18:41.610 --> 18:43.930
bei 1, werden alle Veränderungen übernommen.

18:44.890 --> 18:49.710
Sobald der Takt wieder auf 0 geht, ignorieren wir die Eingaben.

18:51.810 --> 18:54.430
Das heißt, hier durch die Negation ist es natürlich wieder umgedreht.

18:54.590 --> 18:59.770
Das heißt, bei T 0 öffnet er hier die Pforten und bei T 1 sperrt

18:59.770 --> 19:00.450
dieses Flipflop.

19:01.150 --> 19:04.330
Bei einem Wechsel von 0 nach 1 wird jetzt hier der aktuelle Zustand

19:04.330 --> 19:07.530
gehalten, wird aber hier bei Q 1 angelegt.

19:09.010 --> 19:14.110
Und das zweite Flipflop, das jetzt gesperrt war, übernimmt jetzt auf

19:14.110 --> 19:17.990
einmal diesen gespeicherten Zustand und reicht ihn dann weiter an Q.

19:20.770 --> 19:26.510
Das heißt, diese Konstellation reagiert dann nur, wenn der Takt von 0

19:26.510 --> 19:29.170
auf 1 wechselt, also ein aufwärtstaktgeflanktes.

19:30.550 --> 19:36.890
Hier nochmal die Funktionsweise beschrieben zum Nachlesen.

19:38.310 --> 19:39.610
Wie sieht das Schaltsymbol aus?

19:40.070 --> 19:45.650
Wenn wir Taktflanken haben, wollen wir hier ein Dreieck beim

19:45.650 --> 19:46.950
Takteingang spezifizieren.

19:47.990 --> 19:50.710
Wenn wir mit negativen Taktflanken, also mit einem

19:50.710 --> 19:54.870
abwärtstaktgeflankten Flipflop arbeiten wollen, haben wir hier nochmal

19:54.870 --> 19:59.470
ein Negationszeichen vor dem T, also einen Kreis für die Negation.

20:03.390 --> 20:04.070
So weit so klar?

20:04.950 --> 20:05.330
Fragen?

20:14.320 --> 20:14.960
Erstmal ja.

20:16.120 --> 20:19.420
Also ich gehe kurz nachher nochmal drauf ein, was natürlich nicht

20:19.420 --> 20:23.220
alles idealisiert ist, aber idealisiert würde es tatsächlich so

20:23.220 --> 20:23.740
funktionieren.

20:27.540 --> 20:30.520
Also ein flankengesteuertes D-Flipflop, Schaltsymbol haben wir gesagt,

20:30.600 --> 20:32.080
sieht jetzt so aus mit diesem Dreieck.

20:34.360 --> 20:38.360
Angenommen, das ist jetzt mein Takt im Impulstdiagramm und das ist

20:38.360 --> 20:39.000
meine Eingabe.

20:42.260 --> 20:45.200
Jetzt habe ich meine Auftaktflanken markiert als rot.

20:46.040 --> 20:53.800
Hier geht die Flanke immer nach oben und das sind genau die

20:53.800 --> 20:59.920
Zeitpunkte, wo mein D-Flipflop die Eingabevariable übernimmt als

20:59.920 --> 21:00.820
seinen eigenen Zustand.

21:01.740 --> 21:07.940
Das heißt, ich kann jegliches vorne dran und danach kann ich alles

21:07.940 --> 21:08.460
ignorieren.

21:08.760 --> 21:11.600
Ich betrachte tatsächlich nur zu diesem Zeitpunkt, was liegt hier

21:11.600 --> 21:12.320
stabil an.

21:13.340 --> 21:15.440
Also es ist wichtig, dass etwas stabil anliegt.

21:16.360 --> 21:18.820
Problematisch wäre es, wenn zum Beispiel jetzt D genau an dieser

21:18.820 --> 21:19.780
Stelle wechseln würde.

21:20.720 --> 21:21.680
Was würde man dann machen?

21:21.900 --> 21:24.980
Normalerweise, wir machen das immer so, wir interpretieren dann immer

21:24.980 --> 21:28.020
das, was vorher dran lag, weil ein Wechsel dauert immer ein bisschen

21:28.020 --> 21:28.360
länger.

21:31.500 --> 21:35.040
Kurz demonstrieren, was passieren würde, wenn wir so etwas haben.

21:36.480 --> 21:40.980
Dann würde man hier die Null annehmen als Eingabevariable.

21:41.740 --> 21:46.380
Weil, wie der Kollege schon gesagt hat, ist ja nicht ideal.

21:46.380 --> 21:48.260
Normalerweise würde das so verlaufen.

21:50.240 --> 21:51.920
Ich greife ein bisschen vor.

21:53.940 --> 21:58.600
Wir übernehmen jetzt immer, wenn hier die Auftaktflanke ist,

21:58.640 --> 21:59.620
übernehmen wir den Eingang.

21:59.760 --> 22:03.460
Das heißt, wenn unsere Ausgabe oder der interne Zustand zunächst Null

22:03.460 --> 22:05.220
war, übernehmen wir hier die 1.

22:06.260 --> 22:07.740
Das ist mein Ausgabewechsel zu 1.

22:08.380 --> 22:11.400
Jeglicher Wechsel hier wird komplett ignoriert, bis wir zur nächsten

22:11.400 --> 22:12.420
Auftaktflanke kommen.

22:13.020 --> 22:14.140
Hier habe ich meine Auftaktflanke.

22:14.280 --> 22:17.480
Das heißt, hier betrachte ich dann, was ist meine Eingabebelegung bei

22:17.480 --> 22:17.700
D.

22:18.220 --> 22:18.940
Die ist Null.

22:19.380 --> 22:22.160
Das heißt, hier muss ich dann wechseln auf die Null und somit habe ich

22:22.160 --> 22:23.320
dann mein Ausgabesignal.

22:25.340 --> 22:25.660
Wenn

22:30.100 --> 22:33.880
das Ganze so toll funktioniert mit dem D-Flipflop, wieso mache ich das

22:33.880 --> 22:34.920
nicht mit dem RS-Flipflop?

22:36.000 --> 22:39.140
Mit dem RS-Flipflop würde genau das so nicht funktionieren.

22:41.960 --> 22:47.440
Wir können uns den Grund nochmal anschauen, was passiert, wenn wir

22:47.440 --> 22:51.980
hier, also was erwarten wir hier, wenn wir sagen, wir wollen das mit

22:51.980 --> 22:53.400
dem RS-Flipflop implementieren.

22:53.820 --> 23:00.580
Wir erwarten ja, dass immer zu der Auftaktflanke der aktuelle Zustand

23:00.580 --> 23:04.360
von R und S übernommen wird und angewendet wird auf den internen

23:04.360 --> 23:04.800
Zustand.

23:06.640 --> 23:13.240
R und S gleich Null bedeutet in unserem Fall safe, also behalte deinen

23:13.240 --> 23:14.580
aktuellen Zustand bei.

23:16.220 --> 23:23.720
Und normalerweise bei einer ursprünglichen Ausgabe von Q gleich 1

23:23.720 --> 23:26.620
würde das heißen, hier sollte die 1 weiterhin anliegen.

23:29.160 --> 23:31.880
In der gleichen Konstruktion mit diesem RS-Flipflop funktioniert das

23:31.880 --> 23:32.260
aber nicht.

23:32.260 --> 23:32.640
Warum?

23:34.080 --> 23:39.420
Wenn wir jetzt Q1 haben und während T0 kurzzeitig R auf 1 geht, das

23:39.420 --> 23:42.860
sehen wir hier in diesem Impuls, dann haben wir hier kurzfristig eine

23:42.860 --> 23:45.220
Belegung von R gleich 1 und S gleich Null.

23:45.700 --> 23:48.940
Das heißt, ich sende das Kommando Reset an meinen RS-Flipflop.

23:51.520 --> 23:55.420
Das Reset kommt hier direkt an, weil mein T ja Null ist, das heißt

23:55.420 --> 23:59.820
hier ein C1 von T gleich 1 ankommt.

23:59.960 --> 24:02.940
Das heißt, alles was hier ankommt, wird verarbeitet.

24:04.580 --> 24:07.340
Das Flipflop wird angewiesen, den internen Zustand zurückzusetzen auf

24:07.340 --> 24:07.700
die Null.

24:08.020 --> 24:08.700
Das sehen wir hier.

24:09.640 --> 24:10.940
Q1 wechselt auf Null.

24:12.560 --> 24:15.960
Wenn der Takt jetzt kippt von Null auf 1, wird dieses Flipflop

24:15.960 --> 24:16.420
gesperrt.

24:16.500 --> 24:19.020
Das heißt, ich habe hier anliegend eine Null.

24:19.940 --> 24:24.700
Diese Null geht an meinen Set-Eingang und das Komplementäre von Null,

24:24.780 --> 24:26.200
also die 1 an meinen Reset-Eingang.

24:26.320 --> 24:28.920
Das heißt, hier wird wieder zurückgesetzt und meine Ausgabe wechselt

24:28.920 --> 24:32.820
dann letztendlich von der 1 auf die Null.

24:35.540 --> 24:39.140
Also, das funktioniert nicht mit dem RS.

24:39.320 --> 24:42.780
Mit dem D-Flipflop hat es gut funktioniert, mit dem RS hat es jetzt

24:42.780 --> 24:43.380
nicht funktioniert.

24:50.160 --> 24:53.820
Zusammenfassend, D-Flipflops sind am einfachsten zu realisierenden

24:53.820 --> 24:57.000
flackengestörten Speicherelemente und die haben einen sehr geringen

24:57.000 --> 25:00.460
Flächenbedarf, weswegen sie bei integrierten Schaltungen sehr häufig

25:00.460 --> 25:01.140
verwendet werden.

25:05.050 --> 25:07.330
Wie kann man Schaltwerke mit D-Flipflops bauen?

25:08.650 --> 25:10.310
Man hat zwei Teile.

25:11.370 --> 25:13.870
Einmal den linken Teil mit den Flipflops, das sind meine

25:13.870 --> 25:14.710
Zustandsspeicher.

25:15.210 --> 25:16.950
Auf der rechten Seite habe ich ein Schaltnetz.

25:17.270 --> 25:20.590
Die Ausgaben meiner Flipflops werden in das Schaltnetz gespeist,

25:20.790 --> 25:25.030
werden dort verarbeitet und dieses Schaltnetz produziert dann eine

25:25.030 --> 25:29.250
Ausgabe, die als Eingabe für das Flipflop, für die Flipflop-Reihe

25:29.250 --> 25:32.470
hier, für die D-Flipflops dient, aber erst im nächsten Takt.

25:34.070 --> 25:40.230
Und das Ganze funktioniert tatsächlich nur, weil wir diesen Takt

25:40.230 --> 25:41.410
haben, weil das Ganze synchron ist.

25:41.830 --> 25:44.710
Und das Schaltnetz hier hat Zeit, sich zu stabilisieren, also die

25:44.710 --> 25:48.630
Ausgaben der D-Flipflops zu verarbeiten, weiterzuleiten an die D

25:48.630 --> 25:50.810
-Flipflops und erst bei einer 0.1.

25:50.910 --> 25:54.970
Flanke werden diese Änderungen in die D-Flipflops übernommen.

26:00.060 --> 26:02.380
Das haben wir alles schon gesagt, ein bisschen was für euch zum

26:02.380 --> 26:02.840
Nachlesen.

26:06.420 --> 26:09.080
Wir können jetzt synchrone Schaltungen, aber nicht nur mit

26:09.080 --> 26:12.200
flankengesteuerten Flipflops, sondern auch mit pegelgesteuerten

26:12.200 --> 26:15.020
Flipflops, mit diesen Latches, aufbauen.

26:17.040 --> 26:19.340
Dazu muss man aber das Schaltnetz ein bisschen aufteilen.

26:19.640 --> 26:23.220
Sieht dann so aus, dass wir hier zwei Teile haben, einmal den oberen,

26:23.360 --> 26:24.200
einmal den unteren Teil.

26:25.000 --> 26:27.280
Wir haben hier ein Schaltnetz 1 und ein Schaltnetz 2.

26:28.100 --> 26:33.080
Alles, was vom Schaltnetz 2 ausgegeben wird, dient als Eingang für die

26:33.080 --> 26:37.320
Latches mit T2, also die mit dem Takt 2 gesteuert werden.

26:37.820 --> 26:41.520
Und alles, was das Schaltnetz 1 produziert, dient als Eingang für die

26:41.520 --> 26:43.760
Latches, die vom T1 gespeist werden.

26:44.140 --> 26:46.960
Das heißt, wir benötigen hier einen Zwei-Phasen-Takt.

26:47.080 --> 26:48.940
Wir haben immer T1 und T2 als Takt.

26:50.660 --> 26:59.960
Und hier ist natürlich auch wichtig, also nochmal zum Nachlesen, ist

26:59.960 --> 27:12.520
wichtig, dass wenn T2 offen ist, dass T1 gesperrt ist und wenn T1

27:12.520 --> 27:15.500
offen ist, T2 gesperrt ist.

27:15.880 --> 27:20.500
Weil wir sonst eine Konstellation haben, die eigentlich genau dem

27:20.500 --> 27:22.980
entspricht, was wir verweilen wollen, nämlich dem Asynchronen.

27:26.520 --> 27:31.740
Wie sieht das Ganze aus?

27:31.780 --> 27:36.500
Ich habe hier meinen Zwei-Phasen-Takt, T1 und T2, und hier muss ich

27:36.500 --> 27:40.660
immer darauf achten, dass immer nur einer der beiden Takte ein High

27:40.660 --> 27:40.920
hat.

27:43.020 --> 27:48.560
Deswegen sieht man hier, wenn man das markiert, gibt es immer Phasen,

27:48.860 --> 27:55.040
wo T2 hoch ist, T1 hoch ist, T2 hoch ist, T1 hoch ist.

27:56.260 --> 28:00.580
Also, beide Takte sind nie gleichzeitig High.

28:02.000 --> 28:10.490
Das heißt, es gibt immer einen Zeitbereich, wo beide Null sind und das

28:10.490 --> 28:12.910
ist der Zeitbereich, wo sich das Schaltnetz oder die beiden

28:12.910 --> 28:15.930
Schaltnetze stabilisieren können und die Eingaben, die von den

28:15.930 --> 28:20.550
entsprechenden Flipflops kommen, verarbeiten können.

28:23.670 --> 28:26.890
Das haben wir schon gesagt, wenn die gleichzeitig aktiv sind, würde

28:26.890 --> 28:29.590
eine Rückkopplung entstehen und wir haben dann genau das, was wir bei

28:29.590 --> 28:33.730
den Asynchronschaltwerken haben.

28:36.070 --> 28:36.470
Zusatzbetrachtung.

28:38.990 --> 28:41.530
Das Flipflop ist nur zu einem genau festgelegten Zeitpunkt der Flanke

28:41.530 --> 28:42.470
0.1 entriegelt.

28:42.850 --> 28:44.670
Jetzt kommen wir zu dem, was du gesagt hast.

28:45.750 --> 28:49.450
In der Realität sieht es so aus, dass wir natürlich nicht ideal von 0

28:49.450 --> 28:51.210
auf 1 wechseln, sondern wir haben einen Übergang.

28:53.890 --> 28:56.850
Und wenn wir jetzt sicherstellen wollen, dass es tatsächlich so

28:56.850 --> 29:01.190
funktioniert, wie wir uns das wünschen, also dass es idealisiert, wie

29:01.190 --> 29:03.750
beim Idealisierten funktioniert, dann müssen wir auch sicherstellen,

29:04.230 --> 29:09.910
dass wir einen bestimmten Zeitbereich haben um die Taktflanke herum,

29:10.150 --> 29:12.030
wo sich die Eingabebelegungen nicht verändern.

29:14.850 --> 29:18.710
Hier sehen wir den realen Takt.

29:20.490 --> 29:23.030
Idealerweise, was wir uns gerne wünschen, ist natürlich das hier.

29:24.970 --> 29:26.010
Ein sofortiger Wechsel.

29:27.910 --> 29:30.070
Wie gesagt, in der Realität passiert das nicht.

29:30.750 --> 29:34.410
Wir haben hier einen langsamen Wechsel, einen ansteigenden Wechsel und

29:34.410 --> 29:36.710
deswegen definieren wir hier zwei Bereiche.

29:39.530 --> 29:43.250
Einmal die Setup-Time, also den Bereich vor dem Wechsel.

29:45.490 --> 29:49.090
Das ist die Vorbereitungszeit und das ist das Zeitintervall, in dem

29:49.090 --> 29:52.970
das anliegende Signal vor der Taktflanke mindestens stabil sein muss.

29:53.770 --> 29:57.570
Und wir haben die Hold-Time, das ist die Haltezeit, also die Zeit nach

29:57.570 --> 30:02.650
dem Wechsel, in der genauso das Eingangssignal stabil sein muss.

30:03.290 --> 30:08.430
Zusammen ergibt das Ganze das Empfindlichkeitsintervall des Flip-Flops

30:08.430 --> 30:12.210
und hier muss natürlich gewährleistet sein, dass in diesem Intervall

30:12.210 --> 30:13.750
keine Veränderungen stattfinden.

30:16.930 --> 30:19.770
Was passiert, wenn dieses Empfindlichkeitsintervall zu groß ist?

30:21.810 --> 30:25.870
Wir werden sehen, so heute nicht mehr wahrscheinlich, aber in der

30:25.870 --> 30:28.190
Übung vielleicht in der nächsten oder in den nächsten Vorlesungen,

30:28.810 --> 30:31.670
dass wenn man Flip-Flops hintereinander schaltet, was man machen kann,

30:32.390 --> 30:38.170
dass wir dann tatsächlich Probleme bekommen, weil das Signal des

30:38.170 --> 30:42.290
ersten Flip-Flops noch nicht stabil anliegt oder die Veränderung im

30:42.290 --> 30:44.290
ersten Flip-Flop noch nicht stabil an das zweite Flip-Flop

30:44.290 --> 30:45.290
weitergereicht werden kann.

30:46.310 --> 30:47.530
Wie kann man das lösen?

30:48.330 --> 30:50.730
Man löst es mit zwei flankengesteuerten Flip-Flops.

30:51.550 --> 30:52.730
Was bedeutet das genau?

30:55.150 --> 30:59.350
Wir haben ja im Takt zwei Flanken, einmal die Aufwärtsflanke und

30:59.350 --> 31:00.290
einmal die Abwärtsflanke.

31:01.470 --> 31:04.350
Und was wir jetzt machen wollen ist, wir wollen in der ersten

31:04.350 --> 31:10.150
Taktflanke die Eingabebelegung übernehmen, intern im Flip-Flop

31:10.150 --> 31:16.850
verarbeiten und das resultierende Ergebnis erst bei der

31:16.850 --> 31:18.730
Abwärtstaktflanke weitergeben.

31:19.670 --> 31:23.390
Dadurch haben wir gewährleistet, dass ein bestimmtes Eingabesignal

31:23.390 --> 31:26.510
stabil ankommt und wir dieses verarbeiten können, aber dann auch

31:26.510 --> 31:29.210
stabil ans nächste Flip-Flop weitergeben können.

31:30.930 --> 31:35.270
Problem dabei ist natürlich, dass wir eine kleine Verzögerung

31:35.270 --> 31:38.490
reinbekommen und diese Verzögerung beträgt ganz genau einen halben

31:38.490 --> 31:38.830
Takt.

31:43.910 --> 31:45.490
Wie kann man das Ganze implementieren?

31:46.450 --> 31:50.210
Wer an euch erinnert, wir haben gesagt, das Pegelgesteuerte D-Flip

31:50.210 --> 31:53.770
-Flop haben wir aus zwei D-Flip-Flops, das Taktflankengesteuerte Flip

31:53.770 --> 31:57.130
-Flop haben wir aus zwei Pegelgesteuerten D-Flip-Flops, D-Ledges

31:57.130 --> 31:59.710
gebaut und hier benutzen wir einfach drei Stück.

32:02.230 --> 32:09.170
Das heißt, das Taktflankensignal kommt hier an bei einem Wechsel von

32:09.170 --> 32:10.030
0, 1.

32:10.730 --> 32:16.670
Also das erste wird mit dem negativen Takt gefüttert, das zweite D

32:16.670 --> 32:19.410
-Ledge mit dem positiven und das dritte wieder mit dem negativen.

32:21.830 --> 32:26.490
Wenn ich jetzt eine Aufwärtstaktflanke habe von 0 nach 1, wird das

32:26.490 --> 32:29.670
Datum hier übernommen, hier ausgegeben und erst bei der

32:29.670 --> 32:32.110
Abwärtstaktflanke wird das hier wieder weitergegeben.

32:32.750 --> 32:36.790
Das heißt, ich bekomme einen halben Taktzyklus Verzögerung rein, das

32:36.790 --> 32:46.170
wollen wir hier kennzeichnen mit diesem Zeichen, was einer halben

32:46.170 --> 32:47.330
Taktflanke entspricht.

32:47.590 --> 32:49.490
Also geradeaus nach rechts und einmal runter.

32:53.240 --> 32:55.620
Und das symbolisiert hier an der rechten Seite quasi in unserem

32:55.620 --> 32:58.460
Schaltsymbol, dass wir diese Verzögerung von einem halben Takt haben.

33:00.900 --> 33:03.460
So, wie sieht das Schaltsymbol aus?

33:04.860 --> 33:10.260
Haben wir schon gesagt, Impulsdiagramm, einmal der Takt und einmal

33:10.260 --> 33:13.100
unsere Eingabe.

33:15.020 --> 33:20.540
Markiert ist jetzt einmal rot meine Aufwärtstaktflanke und einmal blau

33:20.540 --> 33:22.220
die negative Taktflanke.

33:23.640 --> 33:28.560
Das Verhalten sieht jetzt so aus, dass bei rot die Veränderung

33:28.560 --> 33:31.840
übernommen wird, aber erst bei blau ausgegeben wird.

33:33.200 --> 33:39.940
Genau an diesen Stellen übernehme ich den Inhalt meiner

33:39.940 --> 33:44.360
Eingabebelegung und genau an diesen Stellen wirkt sich das an der

33:44.360 --> 33:45.820
Ausgabe aus.

33:48.020 --> 33:54.380
Sprich, ich betrachte an dieser Stelle mein D, D ist hier 1, das heißt

33:54.380 --> 33:58.280
der Zustand meines D-Flip-Flops müsste von 0 auf 1 wechseln, wechselt

33:58.280 --> 34:00.260
sich aber erst bei der blauen.

34:01.120 --> 34:05.200
Genauso hier, ich habe hier den Zustand 0, also die Eingabe 0, müsste

34:05.200 --> 34:09.860
hier mein Zustand auf 0 wechseln von 1, kann das aber erst im nächsten

34:09.860 --> 34:13.040
Taktzyklus machen.

34:16.240 --> 34:17.960
Okay, soweit so klar?

34:18.740 --> 34:20.580
Fragen dazu?

34:22.140 --> 34:22.760
Keine?

34:23.200 --> 34:23.800
Wunderbar.

34:25.260 --> 34:27.880
Machen wir weiter mit dem JK-Flip-Flop.

34:30.140 --> 34:35.800
Wir haben ja gesagt, ich glaube schon fünfmal mindestens, dass bei RS

34:35.800 --> 34:40.940
1 verboten ist und wir wollen jetzt dieses Problem umgehen, indem wir

34:40.940 --> 34:43.800
ein anderes Flip-Flop konstruieren, was genau diese Eingabebelegung

34:43.800 --> 34:45.240
benutzt, um was anderes zu machen.

34:47.480 --> 34:51.560
Wir haben ja die Funktionen speichern, setzen und zurücksetzen und wir

34:51.560 --> 34:54.840
wollen jetzt zusätzlich bei der Kombination RS gleich 1

34:56.200 --> 34:56.660
komplementieren.

34:57.040 --> 35:00.060
Das heißt, der Inhalt soll gekippt werden, wenn eine 1 der aktuelle

35:00.060 --> 35:04.140
Zustand war, soll eine 1 draus werden.

35:06.660 --> 35:11.280
Dazu definieren wir das JK-Flip-Flop, einmal mit dem J und einmal mit

35:11.280 --> 35:18.300
dem K-Eingang und wir können uns das merken, warum JK.

35:20.200 --> 35:25.120
Wir haben einmal J für Jump und einmal K für Kill.

35:30.190 --> 35:36.110
Also einmal springt es nach oben, quasi mein Setz-Eingang und einmal

35:36.110 --> 35:38.130
lösche ich meinen Inhalt, Kill.

35:39.410 --> 35:45.470
Wir können natürlich dieses Verhalten durch die Zusatzbeschaltung

35:45.470 --> 35:46.690
bekannter Flip-Flops erreichen.

35:47.290 --> 35:53.230
Erstmal, wie sieht die Ansteuerung so eines Flip-Flops aus?

35:53.950 --> 36:00.150
Wir haben gesagt, wir haben hier unsere Zustände Q jeweils 0 und 1,

36:00.150 --> 36:04.350
wir haben die Eingangsbelegungen J und K, wir haben den Folgezustand

36:04.350 --> 36:05.290
Qt plus 1.

36:05.970 --> 36:09.950
Jetzt wollen wir genau diese Funktion implementieren.

36:10.470 --> 36:18.070
Also JK gleich 0, genauso wie beim RS-Flip-Flop als Speichern, 0,1

36:18.070 --> 36:24.630
genauso wie beim RS-Flip-Flop als Rücksetzen, 1,0 als Setzen und 1,1

36:24.630 --> 36:26.070
als Zustand wechseln.

36:26.850 --> 36:32.010
Also Qt plus 1 ist einmal Qt, Qt plus 1 ist gleich 0, gleich 1 und

36:32.010 --> 36:34.370
einmal die Negation vom aktuellen Zustand Qt.

36:36.630 --> 36:39.190
Jetzt tragen wir das hier ein auf der linken Seite.

36:39.390 --> 36:44.390
Einmal sagen wir okay, wir sind im Anfangszustand 0, also Qt ist 0.

36:44.970 --> 36:46.410
Ich habe JK gleich 0,0.

36:47.310 --> 36:49.890
Wenn Qt gleich 0 ist, ist mein Folgezustand auch 0.

36:51.570 --> 36:57.250
Bin ich im Zustand 0 und habe eine 0,1, dann setze ich zurück.

36:57.390 --> 36:58.990
Das heißt, mein Endzustand ist wieder die 0.

36:59.470 --> 37:01.530
Bin ich im Zustand 0 und mache ein 1,0.

37:02.110 --> 37:04.170
Als ich setze den Zustand, bin ich auf der 1.

37:04.670 --> 37:07.770
Und bei 0 will ich mit der 1,1 wechseln.

37:08.050 --> 37:09.630
Das heißt, ich komme von der 0 auf die 1.

37:10.070 --> 37:13.010
Genauso wie ich mit der 1 bin, kann ich hier den aktuellen Zustand

37:13.010 --> 37:14.030
speichern, ist die 1.

37:14.130 --> 37:15.430
Ich kann resetten, ist die 0.

37:15.790 --> 37:16.830
Ich kann setzen, ist die 1.

37:16.910 --> 37:19.130
Und ich kann den internen Zustand wechseln, komme ich von der 1 auf

37:19.130 --> 37:19.450
die 0.

37:20.770 --> 37:22.050
Okay, soweit sollte das klar sein?

37:23.050 --> 37:24.170
Kein Problem, oder?

37:25.550 --> 37:26.450
Wer hat damit Probleme?

37:28.810 --> 37:31.810
Gut, dann schrauben wir die Schwierigkeit ein bisschen höher.

37:33.670 --> 37:38.210
Wir wollen jetzt dieses Flipflop mit einem D-Flipflop implementieren.

37:38.990 --> 37:42.350
Das heißt, wir betrachten jetzt, wie müsste ich einen D-Flipflop

37:42.350 --> 37:44.450
ansteuern, um genau dieses Verhalten zu erreichen.

37:45.330 --> 37:49.530
Dazu betrachte ich einmal meinen Anfangszustand Qt und den

37:49.530 --> 37:56.150
Folgezustand Qt plus 1 und füge eine neue Spalte hinzu, die die

37:56.150 --> 37:58.330
Eingabebelegung meines neuen Flipflops entspricht.

37:58.430 --> 38:03.550
In unserem Fall ein D-Flipflop und stelle dann fest, ich brauche, um

38:03.550 --> 38:07.650
von 0 auf die 0 zu kommen, eine Eingabebelegung von 0 auf D, von 0 auf

38:07.650 --> 38:09.630
0 eine 0, 0 auf 1 eine 1.

38:10.030 --> 38:15.590
Also im Grunde nehme ich diese Spalte hier und kopiere sie dahin.

38:16.950 --> 38:19.110
Funktioniert natürlich nur beim D-Flipflop, beim ES würde es ein

38:19.110 --> 38:19.950
bisschen anders funktionieren.

38:23.070 --> 38:28.350
So, dann kann ich sagen, wie müsste dann mein D als Schaltfunktion

38:28.350 --> 38:31.830
realisiert sein, in Abhängigkeit von Qt, J und K.

38:32.470 --> 38:34.010
Ich komme dann hier auf diesen Term.

38:35.710 --> 38:40.570
Das kann ich machen mit dem KV-Diagramm, das kann ich machen, wenn ich

38:40.570 --> 38:45.170
es ganz oft schon gemacht habe und es direkt sehe, oder man rechnet es

38:45.170 --> 38:46.170
einfach algebraisch aus.

38:46.410 --> 38:47.530
Ja, verschiedene Möglichkeiten.

38:49.330 --> 38:52.670
Also, zusammenfassend, links haben wir alle möglichen Kombinationen

38:52.670 --> 38:55.670
des aktuellen Zustands Qt und den Eingabevariablen J und K.

38:56.670 --> 38:58.910
Rechts haben wir den Folgezustand und die daraus resultierenden

38:58.910 --> 39:00.770
Ansteuerwerte meines neuen Flipflops.

39:00.890 --> 39:02.530
Wie gesagt, in unserem Fall das D-Flipflop.

39:03.810 --> 39:07.250
Und wir wollen die Ansteuervariable D aus den Variablen Q, J und K

39:07.250 --> 39:07.890
erzeugen.

39:08.450 --> 39:09.390
Qt in dem Fall.

39:18.060 --> 39:20.860
Und das mache ich dann, indem ich hier minimiere und ich komme dann

39:20.860 --> 39:28.740
hier auf die Funktion Qt und nicht K oder nicht Qt und J.

39:31.560 --> 39:33.300
So, wie sieht die Implementierung aus?

39:34.440 --> 39:36.500
Ich habe hier ein Schaltnetz, das sieht genau so aus.

39:36.620 --> 39:43.740
Ich habe hier mein Q als Eingabe, ich habe hier das Nicht-K als

39:43.740 --> 39:46.380
Eingabe, das entspricht diesem Term hier.

39:46.840 --> 39:47.600
Ich verunde das.

39:48.080 --> 39:51.360
Ich habe auf der rechten Seite Nicht-Q und J.

39:51.800 --> 39:55.720
Hol ich mir von hier, das ist mein Nicht-Q, das ist mein J, verunde

39:55.720 --> 39:59.380
das beide und das Ergebnis von beiden wird geodert und dient als

39:59.380 --> 40:01.360
Eingabe in meinem D-Flipflop.

40:03.360 --> 40:06.500
Zusätzlich zu einem Takt-Symbol kann ich jetzt hier wieder so einen

40:06.500 --> 40:10.120
schönen blauen Rahmen drumherum machen und habe dann hier eine

40:10.120 --> 40:13.700
Implementierung des JK-Flipflops mit einem D-Flipflop erreicht.

40:19.180 --> 40:24.140
Schaltsymbol soll so aussehen, also J und K als Eingaben, hier meine

40:24.140 --> 40:28.080
Taktflanke und wie gewöhnlich Q und Nicht-Q als Ausgabe.

40:32.100 --> 40:33.720
So, nehmen wir es wieder weg.

40:37.970 --> 40:40.610
Wie kriege ich jetzt meine Ansteuertabelle für meinen JK-Flipflop?

40:40.970 --> 40:44.010
Das kann ich aus meiner verkürzten Funktionstabelle erreichen, das

40:44.010 --> 40:48.490
heißt ich habe hier mein JK, habe hier meine Funktion, die jeweils

40:48.490 --> 40:53.910
erreicht wird, kann daraus dann diese Tabelle ausfüllen, das heißt ich

40:53.910 --> 40:57.270
schaue, wie komme ich denn von meinem Zustand Qt auf den folgenden

40:57.270 --> 41:02.710
Zustand Qt plus 1, das erreiche ich hier mit 0, don't care, wie komme

41:02.710 --> 41:06.890
ich von der 0 auf die 1, mit 1, don't care, don't care 1 und don't

41:06.890 --> 41:07.230
care 0.

41:09.710 --> 41:13.550
Bisschen detaillierter betrachtet, interner Zustand wie bei jedem

41:13.550 --> 41:17.930
Flipflop sind zwei Zustände, einmal 0 und 1, hier unsere Tabelle, die

41:17.930 --> 41:23.610
wir eigentlich ausfüllen wollen, dann was für Möglichkeiten habe ich,

41:23.610 --> 41:26.930
also genauso wie vorhin beim RS-Flipflop, was für Möglichkeiten habe

41:26.930 --> 41:29.590
ich, wenn ich im Zustand 0 bin, im Zustand 0 zu bleiben?

41:30.850 --> 41:33.610
Ich kann einmal speichern und einmal rücksetzen, das ist quasi genau

41:33.610 --> 41:36.950
das gleiche wie beim RS-Flipflop, nur hier haben wir jetzt die

41:36.950 --> 41:41.290
Eingabebelegungen J und K und ich kann es erreichen mit jeweils 0, 0

41:41.290 --> 41:45.010
und 0, 1, das heißt hier kann ich das 0 und die 1 des Ks

41:45.010 --> 41:47.610
zusammenfassen zu einem don't care, das heißt ich lande dann hier bei

41:47.610 --> 41:51.370
einem 0, don't care und 0, don't care ist dann das, was ich dann hier

41:51.370 --> 41:52.070
eintragen muss.

41:54.010 --> 41:59.110
Von 0 nach 1 habe ich jetzt eine Möglichkeit mehr als beim RS

41:59.110 --> 42:01.610
-Flipflop, ich habe nämlich beim RS-Flipflop nur die Möglichkeit

42:01.610 --> 42:02.490
gehabt zu setzen.

42:02.750 --> 42:07.110
Ich konnte ein Set machen von 0 auf 1, also ich setze direkt eine 1 in

42:07.110 --> 42:12.750
meinen Speicher, hier kann ich sagen, ich will noch wechseln, also ich

42:12.750 --> 42:16.850
wechsle den internen Zustand, ich kippe das Bit von 0 auf die 1, hier

42:16.850 --> 42:20.530
entspricht das dann dem Fall 1, 0 und 1, 1, hier kann ich wieder das K

42:20.530 --> 42:24.050
zusammenfassen zu einem don't care und lande dann bei einem 1, don't

42:24.050 --> 42:27.310
care, trage ich dann hier in meiner zweiten Zeile ein.

42:28.550 --> 42:32.790
Rückwärts genauso, hier kann ich auch wieder rücksetzen und wechseln,

42:32.930 --> 42:37.190
auch wieder eine Eingabebelegung mehr als beim RS-Flipflop und

42:37.190 --> 42:40.630
resultiert in einem don't care 1, was dann hier in die dritte Zeile

42:40.630 --> 42:45.930
kommt und letztendlich der vierte Übergang ist genauso wie beim RS

42:45.930 --> 42:49.290
-Flipflop, einmal speichern und einmal setzen, auch hier kann ich

42:49.290 --> 42:50.970
wieder zusammenfassen, kommen wir auf die don't care 0.

42:53.970 --> 42:57.930
Also so entsteht die Tabelle und diese Tabelle nennen wir die Ansteuer

42:57.930 --> 42:58.330
-Tabelle.

43:07.820 --> 43:13.320
Erstmal vielleicht dazu fragen, wer hat es nicht verstanden?

43:15.340 --> 43:17.140
Alle haben es verstanden, super.

43:18.280 --> 43:19.220
Gut, dann machen wir weiter.

43:20.940 --> 43:25.180
Wir haben die synchronen Eingänge betrachtet, das sind hier unser 1j

43:25.180 --> 43:25.940
und 1k.

43:26.900 --> 43:29.920
Zusätzlich zu diesen synchronen Eingängen können wir noch asynchrone

43:29.920 --> 43:30.620
Eingänge haben.

43:30.900 --> 43:35.360
In unserem Fall wollen wir zum Beispiel ein R definieren, daran zu

43:35.360 --> 43:40.400
erkennen, dass hier keine 1 weder davor noch dahinter ist und dieses R

43:40.400 --> 43:41.440
soll ein Reset sein.

43:43.380 --> 43:48.040
Und zwar wollen wir nämlich das Flipflop auf den Ausgangszustand

43:48.040 --> 43:50.920
zurücksetzen, das heißt wir wollen den internen Zustand auf die 0

43:50.920 --> 43:53.220
setzen und das passiert hier asynchron.

43:53.880 --> 43:57.640
Wenn wir uns jetzt hier die... mal gucken, ob da eine Animation drin

43:57.640 --> 43:57.960
ist...

43:57.960 --> 43:58.560
ist eine drin.

43:59.500 --> 44:02.080
Wenn wir uns hier das Inputs-Diagramm anschauen, haben wir hier den

44:02.080 --> 44:08.760
Takt, ich reagiere hier immer auf den Auftakt, also hier sind meine

44:08.760 --> 44:09.160
Flanken.

44:14.980 --> 44:18.240
Ignoriere ich zuerst meinen Reset-Eingang, wie würde mein

44:18.240 --> 44:19.420
Ausgabesignal aussehen?

44:20.160 --> 44:26.560
Ich habe genau an dieser Stelle einen J1 K0, das heißt ich setze hier

44:26.560 --> 44:35.220
meinen Ausgang, das heißt hier müsste es hochgehen bis hier hin.

44:44.140 --> 44:49.460
An dieser Stelle habe ich einen J0 K0, entspricht meinem Speichern,

44:49.640 --> 44:52.500
also ich behalte meinen internen Wert bei.

44:59.140 --> 45:03.700
Hier habe ich einen Wechsel, Jump1 und Kill1, also hier switche ich

45:03.700 --> 45:05.360
meine Ausgabe.

45:05.900 --> 45:14.480
Und an der letzten Stelle habe ich hier ein K gleich 1 und Wert gleich

45:14.480 --> 45:15.860
0, das heißt ich kille.

45:16.440 --> 45:19.980
Ich setze hier wieder zurück auf die 0, würde dann hier auf der 0

45:19.980 --> 45:20.360
bleiben.

45:24.120 --> 45:27.320
Was passiert jetzt aber, wenn ich den Reset-Eingang betrachte?

45:28.440 --> 45:31.180
Mein Reset-Eingang, wohlgemerkt, ist hier asynchron, das heißt er

45:31.180 --> 45:32.980
reagiert hier auch ohne Taktflanke.

45:32.980 --> 45:42.020
Und sobald jetzt hier Reset getriggert, setzt mein Flipflop zurück und

45:42.020 --> 45:42.920
geht bei der 0 weiter.

45:44.060 --> 45:47.280
Jetzt habe ich an dieser Stelle aber gesagt, normalerweise würde ich

45:47.280 --> 45:51.240
von 1 auf 0 wechseln, weil mein Flipflop hier sagt 1 1, also switch.

45:52.080 --> 45:55.680
Das heißt hier müsste ich hochgehen, würde dann bei der 1 bleiben und

45:55.680 --> 45:57.400
hier würde ich dann wieder auf die 0 zurückgehen.

45:59.660 --> 46:02.420
Und genau so sieht das Ergebnis aus.

46:12.320 --> 46:13.440
Fragen dazu?

46:15.280 --> 46:16.520
Asynchroner Reset-Eingang.

46:17.380 --> 46:18.200
Wofür brauche ich den?

46:19.480 --> 46:21.500
Einmal brauche ich ihn natürlich beim Initialisieren meines

46:21.500 --> 46:24.680
Schaltwerkes, weil wenn ich mein Schaltwerk anwerfe, dann ist er in

46:24.680 --> 46:25.800
einem undefinierten Zustand.

46:26.340 --> 46:29.120
Und wenn ich in einem undefinierten Zustand starte, dann kann alles

46:29.120 --> 46:29.860
mögliche passieren.

46:30.300 --> 46:32.260
Abhängig natürlich vom Flipflop, das ich jetzt habe.

46:35.520 --> 46:41.240
Zum anderen haben wir hier die Bezeichnung, aber das habe ich schon

46:41.240 --> 46:44.480
gesagt glaube ich, dass wir hier daran erkennen, dass hier keine 1

46:44.480 --> 46:47.020
wieder davor noch dahinter ist, dass es sich hier um einen asynchronen

46:47.020 --> 46:47.620
Eingang handelt.

46:51.560 --> 46:55.520
So, dann wollen wir zum letzten Flipflop, das T-Flipflop.

46:57.680 --> 47:01.580
T für Toggle, also Kippen.

47:02.280 --> 47:04.580
Und dieses T-Flipflop besitzt nur einen Eingang.

47:05.100 --> 47:10.320
Und dieser eine Eingang soll, wenn er gesetzt ist, dafür sorgen, dass

47:10.320 --> 47:12.860
mein interner Zustand kippt, also sich verändert.

47:14.440 --> 47:18.180
Also, habe ich eine interne 1, kippe ich auf die 0, habe ich eine

47:18.180 --> 47:19.420
interne 0, kippe ich auf die 1.

47:27.640 --> 47:30.620
Habe ich dann die 0 als Eingang, das ist vielleicht noch wichtig, also

47:30.620 --> 47:34.540
dieses Kippen ist nur, wenn ich hier eine 1 an meinem Eingang habe,

47:34.780 --> 47:37.600
habe ich eine 0 an meinem Eingang, so wird natürlich der interne

47:37.600 --> 47:38.560
Zustand beibehalten.

47:40.880 --> 47:43.180
Implementierung ist recht einfach, weil wir jetzt das JK-Flipflop

47:43.180 --> 47:46.040
schon kennengelernt haben und in dem JK-Flipflop haben wir genau diese

47:46.040 --> 47:47.740
Funktion auch schon implementiert.

47:47.840 --> 47:51.380
Wir haben gesagt, wenn J und K gleich 1 sind, dann soll gekippt

47:51.380 --> 47:54.180
werden, wenn J und K gleich 0 sind, dann soll der interne Zustand

47:54.180 --> 47:55.000
beibehalten werden.

47:55.520 --> 47:59.240
Das heißt, ich kann jetzt hier eine Eingangsvariable definieren, die

47:59.240 --> 48:03.100
ich an J und auch an K durchreiche.

48:03.780 --> 48:08.140
Das heißt, wenn jetzt hier eine 1 anliegt, dann liegt eine 1 an J und

48:08.140 --> 48:12.500
eine 1 an K an, das heißt, mein Flipflop wird angewiesen, den Zustand

48:12.500 --> 48:13.100
zu wechseln.

48:13.460 --> 48:18.640
Liegt hier eine 0 an E an, so ist eine 0 an J und eine 0 an K, das

48:18.640 --> 48:20.780
heißt, das Flipflop wird hier angewiesen, den internen Zustand

48:20.780 --> 48:21.480
beizubehalten.

48:23.620 --> 48:28.820
So sieht mein Schaltbild aus, von meinem T-Flipflop, synchrones T

48:28.820 --> 48:32.300
-Flipflop natürlich, hier mit einer Taktflankensteuerung, einmal mit T

48:32.300 --> 48:36.040
für den Takt und einmal E für Eingabe, könnte man natürlich auch T als

48:36.040 --> 48:36.640
Eingabe nennen.

48:39.220 --> 48:43.820
Funktionstabelle ist recht einfach, ich habe hier Eingabe 0 und 1, bei

48:43.820 --> 48:47.280
0 wird gespeichert, bei 1 wird der Zustand invertiert.

48:49.940 --> 48:52.860
Das Problem hier ist natürlich, dass ich jetzt keinerlei

48:52.860 --> 48:56.960
Anfangszustand definiert habe, das heißt, ich kann dem Flipflop nicht

48:56.960 --> 48:58.840
sagen, es soll den Zustand 0 annehmen.

48:59.480 --> 49:01.480
Ich kann auch nicht sagen, er soll den Zustand 1 annehmen, ich kann

49:01.480 --> 49:03.480
nur sagen, ändere deinen Zustand.

49:05.320 --> 49:09.120
Das heißt, nur mit dem Eingang E ist ein Rücksetzen nicht möglich.

49:09.810 --> 49:12.620
Das bedeutet aber auch zusätzlich, dass ich jetzt hier einen weiteren

49:12.620 --> 49:16.140
Rücksetzeingang benötige, und zwar sowas wie den Reset-Eingang, den

49:16.140 --> 49:18.780
wir uns vorhin angeschaut haben beim JK-Flipflop.

49:21.300 --> 49:28.400
Ansteuertabelle des T-Flipflops, haben wir gesagt, hier Folgezustand

49:28.400 --> 49:32.000
und hier habe ich meine Eingabe, also mit welcher Eingabe erreiche ich

49:32.000 --> 49:32.900
diesen Zustandswechsel.

49:33.720 --> 49:37.120
Und das ist recht einfach, wenn ich hier gleich bin, habe ich eine 0,

49:37.340 --> 49:39.580
wenn sich hier der Zustand wechselt, habe ich jeweils eine 1.

49:40.160 --> 49:42.620
Und wenn 1,1 ist, habe ich auch wieder den gleichen Zustand, das

49:42.620 --> 49:44.200
heißt, ich bleibe dann hier wieder bei einer 0.

49:46.260 --> 49:48.840
Zusammenfassend haben wir jetzt vier neue Flipflops kennengelernt,

49:49.120 --> 49:54.440
oder drei neue und eins ein bisschen spezieller.

49:55.160 --> 49:59.800
Erst einmal das RS-Flipflop, das Asynchrone, das kannten wir ja schon,

50:00.320 --> 50:03.760
haben wir hier gesagt, dass R gleich S gleich 1 ist verboten, das

50:03.760 --> 50:04.780
sechste Mal glaube ich jetzt.

50:06.620 --> 50:09.720
Daraus haben wir aber auch dieses RS-Latch abgeleitet, also den

50:09.720 --> 50:13.080
pegelgesteuerten RS-Flipflop.

50:13.920 --> 50:17.640
Dann haben wir das D-Flipflop kennengelernt, den D-Latch, den

50:17.640 --> 50:21.420
pegelgesteuerten, wo wir gesagt haben, man kann es bauen aus einem RS

50:21.420 --> 50:29.180
-Flipflop, wenn wir hier R und S negiert anschließen, dann haben wir

50:29.180 --> 50:31.940
einen D-Flipflop, dadurch wird dieses Verbot aufgehoben.

50:33.160 --> 50:37.100
Wir haben auch gesagt, um dieses Verbot zu umgehen, haben wir beim JK

50:37.100 --> 50:41.180
-Flipflop die Möglichkeit, diese verbotene Eingabebelegung zu

50:41.180 --> 50:44.840
verändern und daraus eine neue Funktion zu basteln, das wäre hier

50:44.840 --> 50:45.180
kippen.

50:45.740 --> 50:48.360
Und dann haben wir noch das T-Flipflop kennengelernt, wo wir gesagt

50:48.360 --> 50:52.220
haben, es hat nur einen Eingang und kippt immer nur den internen

50:52.220 --> 50:52.600
Zustand.

50:55.280 --> 51:02.540
Okay, ich glaube, hier nochmal das wichtigste Hilfsmittel, was man

51:02.540 --> 51:06.140
hier braucht, sind tatsächlich die Ansteuertabellen der verschiedenen

51:06.140 --> 51:07.000
Flipflops.

51:08.680 --> 51:10.720
Also RS, was passiert?

51:12.860 --> 51:16.780
Wie komme ich von einem gegebenen Anfangszustand in den Folgezustand?

51:17.340 --> 51:23.280
Was muss ich an den jeweiligen Flipflops als Eingabebelegung anlegen,

51:23.480 --> 51:26.040
um genau diesen Zustandsübergang zu erreichen?

51:26.520 --> 51:30.020
Einmal für das RS-Flipflop, für das JK-Flipflop, für das D-Flipflop

51:30.020 --> 51:30.980
und das T-Flipflop.

51:32.200 --> 51:36.280
Das könnt ihr auswendig lernen, das könnt ihr euch herleiten, wenn ihr

51:36.280 --> 51:39.100
verstanden habt, wie die Flipflops funktionieren, wenn ihr euch die

51:39.100 --> 51:44.380
Kürzel gemerkt habt, also R für Reset, S für Set, könnt ihr euch das

51:44.380 --> 51:45.160
sofort herleiten.

51:46.160 --> 51:50.520
Wenn ihr JK euch gemerkt habt mit Jump und Kill, könnt ihr euch das

51:50.520 --> 51:51.200
auch herleiten.

51:51.980 --> 51:55.620
Wenn ihr beim D-Flipflop euch gemerkt habt, dass es für Data steht

51:55.620 --> 52:00.080
vielleicht, also übernehmt das Datenwort vom Eingang, dann kann man es

52:00.080 --> 52:03.640
sich auch sofort herleiten und T-Flipflop mit Toggle sollte auch recht

52:03.640 --> 52:04.300
trivial sein.

52:05.600 --> 52:07.860
Egal, wie ihr es macht, diese Anstellentabellen solltet ihr können,

52:07.980 --> 52:11.140
weil ohne diese Tabellen können wir dann die bestimmten Aufgaben, die

52:11.140 --> 52:13.800
wir jetzt nachher nochmal kurz anschauen werden, nicht lösen.

52:14.840 --> 52:16.720
Das heißt, das ist ein ganz wichtiges Lösungsmittel für euch.

52:19.240 --> 52:20.140
So, dazu Fragen?

52:23.690 --> 52:25.110
Keine Fragen, sehr schön.

52:26.690 --> 52:29.090
Dann machen wir weiter, liegen gut in der Zeit.

52:31.110 --> 52:33.930
Wir betrachten jetzt den Entwurf synchroner Schaltwerke.

52:35.990 --> 52:37.890
Wie stellt man Automatengrafen auf?

52:39.210 --> 52:41.650
Wie stellt man die Automatentafel auf?

52:42.470 --> 52:44.170
Was für eine Zustandscodierung wählt man?

52:46.070 --> 52:49.070
Wie baut man die Ausgabe- und Übergangsschaltnetze?

52:49.770 --> 52:53.170
Und wir wollen das Ganze später mit einem Folgenerkenner

52:53.170 --> 52:54.910
demonstrieren.

52:55.580 --> 53:00.570
Aber zunächst einmal wollen wir das Ganze an einem Beispiel erläutern,

53:01.150 --> 53:02.950
und zwar am Beispiel des Serienaddierers.

53:04.170 --> 53:06.290
Was ist ein Serienaddierer?

53:06.910 --> 53:10.190
Ein Serienaddierer addiert zwei beliebig lange Dualzahlen

53:10.190 --> 53:10.890
stellenweise.

53:12.890 --> 53:17.470
Dazu fängt die Addition mit der niederwertigsten Stelle an, also mit

53:17.470 --> 53:18.910
der Stelle der niedrigsten Wertigkeit.

53:18.910 --> 53:23.890
Ich stelle euch einen Bitstream vor von 0.1.1.1.0.0.0.1, irgendwas

53:23.890 --> 53:25.410
unter zwei Bitstreams.

53:25.850 --> 53:29.370
Und wir wollen jetzt wie bei der normalen Addition von hinten anfangen

53:29.370 --> 53:33.890
und jeweils die einzelnen Stellen zusammen addieren und daraus dann

53:33.890 --> 53:34.790
eine Summe generieren.

53:37.570 --> 53:41.150
Dazu ist natürlich wichtig, wie bei der normalen Addition auch, dass

53:41.150 --> 53:42.250
man den Übertrag beachtet.

53:42.830 --> 53:46.450
Das heißt, wenn ich 0.0 addiere, kommt 0 raus, wenn ich 1.0 addiere,

53:46.610 --> 53:47.530
kommt der 1 raus.

53:47.530 --> 53:50.650
Wenn ich aber 1.1 addiere, bekomme ich eine 0 und habe den einen

53:50.650 --> 53:53.430
Übertrag, den ich übernehmen muss, auf die nächste Stelle.

53:56.370 --> 54:00.330
Die Zahlen kommen bitweise an und in jedem Taktschritt bekommen wir

54:00.330 --> 54:00.890
eine Stelle.

54:02.670 --> 54:05.030
Und die Ausgabe soll auch bitweise erfolgen.

54:05.510 --> 54:11.830
Dabei soll zu jedem Zeitpunkt die Ausgabe der Summe der bisherigen

54:11.830 --> 54:15.070
Eingabefolgen entsprechen, ohne dass man diesen Übertrag beachtet.

54:16.610 --> 54:19.710
Ich gehe nochmal ein bisschen detaillierter darauf ein gleich.

54:21.530 --> 54:26.910
Zunächst mal wollen wir den Automatengrafen aufstellen.

54:27.930 --> 54:30.770
Dazu definieren wir unsere zwei Eingabevariablen in Folge.

54:30.970 --> 54:36.190
Einmal x als unsere erste Zahl, einmal y als die zweite Zahl und wir

54:36.190 --> 54:39.890
wollen die Ausgabe s produzieren, was der Summe entsprechen soll.

54:42.030 --> 54:44.650
Was brauchen wir jetzt in jedem Additionsschritt?

54:44.650 --> 54:48.710
Wir brauchen eigentlich als Vorgeschichte lediglich den Übertrag aus

54:48.710 --> 54:49.750
der vorherigen Addition.

54:51.150 --> 54:53.010
Alles andere interessiert uns nicht.

54:53.910 --> 54:59.670
Aus dem Übertrag und den zwei Stellen meines Bitstreams kann ich dann

54:59.670 --> 55:03.530
hier sofort die Summe berechnen und kann dann nochmal den Übertrag

55:03.530 --> 55:05.410
erzeugen, den ich für die nächste Stelle weitergebe.

55:07.630 --> 55:10.650
Das heißt, wir brauchen nur zwei Zustände.

55:11.390 --> 55:16.550
Wir brauchen einmal den Zustand Ü für Übertrag oder wie Tamim sagen

55:16.550 --> 55:25.950
würde, U-Umlaut und wir haben den K-Ü für kein Umlaut.

55:28.430 --> 55:31.430
Kein Umlaut, kein Übertrag natürlich.

55:32.170 --> 55:34.650
Also Ü für Übertrag und K für kein Übertrag.

55:34.890 --> 55:36.550
Das sind unsere zwei Zustände, die wir benötigen.

55:39.130 --> 55:42.090
Wie sieht das Blockschaltbild meines Serienaddierers aus?

55:42.150 --> 55:47.530
Ich habe hier einmal XT, also zum Zeitpunkt T habe ich eine Eingabe

55:47.530 --> 55:50.770
für X, zum Zeitpunkt T habe ich eine Eingabe für Y.

55:51.390 --> 55:55.050
Ich produziere zum gleichen Zeitpunkt die Summe daraus und ich

55:55.050 --> 55:58.970
produziere hier meinen Übertrag aus der Summe.

56:01.230 --> 56:04.630
Und ich muss natürlich diesen Übertrag mir merken für den nächsten

56:04.630 --> 56:05.330
Additionsschritt.

56:06.710 --> 56:12.050
Das heißt, dieses ZT plus 1 geht dann weiter und wird im nächsten

56:12.050 --> 56:16.810
Schritt als ZT wieder in dieses Addier-Schaltennetz gespeist.

56:18.350 --> 56:23.550
Das heißt, hier haben wir unser Schaltennetz und hier gibt es dann

56:23.550 --> 56:28.010
unser Flipflop, unser Schaltwerk, was genau dieses Speichern des

56:28.010 --> 56:29.170
Zustandes für uns übernimmt.

56:31.410 --> 56:33.030
Wie sieht der Automatengraph aus?

56:33.030 --> 56:38.950
Wir haben hier zunächst mal mit einem Mili-Schaltwerk das Ganze

56:38.950 --> 56:39.510
implementiert.

56:39.610 --> 56:39.770
Warum?

56:41.070 --> 56:44.950
Weil unsere Ausgabe, also die Summe, von der Eingabe abhängt.

56:45.750 --> 56:49.690
Also abhängig von dem, was mein Eingabestream mir sagt, produziere ich

56:49.690 --> 56:53.970
eine andere Ausgabe und das kann ich natürlich hier nur mit einem Mili

56:53.970 --> 56:54.690
-Schaltwerk machen.

56:55.230 --> 56:58.950
Und in unserer Interpretation, dass wir sagen, unsere zwei Zustände

56:58.950 --> 57:03.630
unterscheiden sich, K für keinen Übertrag und Ö für Übertrag, muss ich

57:03.630 --> 57:05.390
dann natürlich auch ein Mili-Schaltwerk benutzen.

57:06.530 --> 57:07.670
Automatengraph sieht so aus.

57:07.870 --> 57:10.150
Also hier die Legende, wir haben hier unseren Startzustand, kein

57:10.150 --> 57:10.670
Übertrag.

57:11.170 --> 57:13.730
Logischerweise, wenn ich anfange zu addieren, habe ich zunächst mal

57:13.730 --> 57:14.490
keinen Übertrag.

57:15.350 --> 57:19.990
Ich habe hier meine Übergangspfeile, die jeweils dem X und dem Y

57:19.990 --> 57:24.190
entsprechen und dann noch eine Summe produzieren.

57:26.310 --> 57:29.310
Also, zwei Kreise, mein Startzustand, K, Ü.

57:30.930 --> 57:35.710
Wenn ich in K, Ü bin und ich bekomme jetzt eine 0, 0, dann addiere ich

57:35.710 --> 57:41.070
die 0 und die 0, produziere als Ausgabe eine 0 und ich habe keinen

57:41.070 --> 57:42.630
Übertrag für die nächste Addition.

57:42.950 --> 57:45.130
Das heißt, ich bleibe in meinem K, Ü.

57:46.330 --> 57:50.450
Habe ich eine 0 und die 1, addiere ich die 0 und die 1, komme ich

57:50.450 --> 57:55.790
binär auf die 1, produziere als Ausgabe eine 1 und habe wieder keinen

57:55.790 --> 57:56.350
Übertrag.

57:56.470 --> 57:58.510
Das heißt, ich bleibe hier wieder im gleichen Zustand.

57:59.470 --> 58:00.730
1, 0, genauso.

58:01.050 --> 58:04.990
Ich habe als Summe 1, also meine Ausgabe ist die 1 und mein

58:04.990 --> 58:09.010
Folgezustand ist immer noch kein Übertragszustand.

58:10.630 --> 58:15.110
Erst wenn ich die 1 und die 1 addiere, produziere ich hier die Summe

58:15.110 --> 58:18.430
0, weil 1 plus 1 binär die 1, 0 ist.

58:19.330 --> 58:23.550
Das heißt, hier ist meine Summe 0 und ich gehe in den Zustand Ü über

58:23.550 --> 58:24.390
für Übertrag.

58:24.790 --> 58:26.610
Und zwar ist es die 1, die ich vorne dran hatte.

58:28.210 --> 58:31.630
Wenn ich jetzt in diesem Zustand Ü, sieht meine Addition ein bisschen

58:31.630 --> 58:32.310
anders aus.

58:32.830 --> 58:38.130
Ich muss beide Variablen addieren und ich muss zusätzlich nochmal eine

58:38.130 --> 58:40.850
1 drauf addieren, weil ich muss ja den Übertrag aus der vorherigen

58:40.850 --> 58:42.290
Addition mit betrachten.

58:42.390 --> 58:48.050
Das heißt, ich habe hier eine 1 plus 0 plus 1 und auf die 1, 0.

58:48.850 --> 58:52.370
1, 0 bedeutet 0 als Ausgabe und 1 als Übertrag.

58:52.370 --> 58:54.070
Das heißt, ich bleibe im gleichen Zustand.

58:54.710 --> 58:58.030
Ich habe eine 1 plus 1 plus 0, ist wieder die 1, 0.

58:58.270 --> 58:59.570
Selbe Geschichte.

59:00.350 --> 59:04.270
Ich habe hier eine 1 plus 1 plus 1, ist binär die 1, 1.

59:04.950 --> 59:09.010
Das heißt, ich produziere die hintere Stelle, die 1, als Ausgabe und

59:09.010 --> 59:10.470
bleibe wieder in meinem Übertrag.

59:11.050 --> 59:16.790
Nur wenn ich die Eingabebelegung 0, 0 habe, habe ich hier 1 plus 0

59:16.790 --> 59:22.550
plus 0, habe das Ergebnis 1 und erzeuge diesmal aber keinen Übertrag.

59:22.690 --> 59:26.790
Das heißt, hier muss ich dann meinen Zustand von Ü nach KÜ wechseln.

59:30.030 --> 59:30.190
Okay?

59:31.650 --> 59:32.290
Hat es jeder verstanden?

59:34.150 --> 59:35.110
Wer hat es nicht verstanden?

59:37.850 --> 59:38.670
Gut, leider.

59:40.590 --> 59:41.390
Nächster Schritt.

59:41.530 --> 59:43.150
Wir wollen die Automatentafel aufstellen.

59:45.670 --> 59:48.510
Dazu betrachten wir unseren Automaten-Graphen, den wir hier erzeugt

59:48.510 --> 59:55.800
haben und haben hier die Vorlage für unsere Automatentafel.

59:57.470 --> 01:00:00.730
Links haben wir unsere Zustände KÜ und Ü.

01:00:01.530 --> 01:00:07.030
Auf der rechten Seite haben wir in den jeweiligen Spalten haben wir

01:00:07.030 --> 01:00:13.210
einmal den Folgezustand Z plus und S als Ausgabe.

01:00:13.570 --> 01:00:15.510
Also das wollen wir hier drin haben.

01:00:16.350 --> 01:00:18.190
Und wir haben hier die Eingabebelegung XY.

01:00:21.230 --> 01:00:21.990
Also...

01:00:21.990 --> 01:00:25.770
Angenommen, ich bin in meinem Zustand KÜ.

01:00:26.310 --> 01:00:29.930
Ich habe die Eingabebelegung XY00.

01:00:30.710 --> 01:00:32.370
Also das ist genau dieser Fall hier.

01:00:33.650 --> 01:00:37.170
Dann ist mein Folgezustand KÜ und meine Ausgabe ist 0.

01:00:44.060 --> 01:00:48.180
Bin ich im Zustand kein Übertrag, habe die Eingabebelegung 01.

01:00:49.120 --> 01:00:50.120
Diese Zeile hier.

01:00:51.300 --> 01:00:56.100
Dann produziere ich die Ausgabe 1 und bleibe im Folgezustand KÜ.

01:00:56.340 --> 01:00:59.000
Das heißt, ich habe hier KÜ Strich 1.

01:00:59.960 --> 01:01:00.740
1, 0.

01:01:01.920 --> 01:01:02.520
Genauso.

01:01:03.340 --> 01:01:09.960
Ich habe die Ausgabe 1, bleibe in meinem Folgezustand KÜ und bei 1, 1

01:01:09.960 --> 01:01:13.840
habe ich den Wechsel in den Zustand Ü.

01:01:14.160 --> 01:01:17.080
Das heißt, mein Folgezustand hier ist Ü und meine Ausgabe ist 0.

01:01:20.620 --> 01:01:21.220
Okay?

01:01:22.700 --> 01:01:23.920
Wer hat das nicht verstanden?

01:01:25.500 --> 01:01:26.500
Wer kennt das schon?

01:01:29.500 --> 01:01:30.140
1, 2.

01:01:30.340 --> 01:01:30.580
Okay.

01:01:30.800 --> 01:01:31.760
Also für den Rest ist es neu.

01:01:33.960 --> 01:01:34.560
Machen wir weiter.

01:01:34.960 --> 01:01:38.960
Ich bin im Zustand Ü, habe die Eingabebelegung 00.

01:01:39.760 --> 01:01:43.480
Das heißt, hier habe ich einen Wechsel auf KÜ und meine Ausgabe ist 1.

01:01:45.600 --> 01:01:49.140
Und hier bei den anderen drei Fällen habe ich jeweils die Ausgabe 001

01:01:49.140 --> 01:01:51.180
und ich bleibe im Folgezustand Ü.

01:01:51.180 --> 01:01:54.060
Also 001 und der Folgezustand ist jeweils Ü.

01:01:59.600 --> 01:02:04.820
Ihr solltet das hier kennen aus Asynchronschaltwerken.

01:02:07.240 --> 01:02:09.600
Bei Asynchronschaltwerken haben wir hier die stabilen Zustände

01:02:09.600 --> 01:02:10.120
definiert.

01:02:10.240 --> 01:02:13.200
Wir haben gesagt, bei einer bestimmten Eingabebelegung, wenn der

01:02:13.200 --> 01:02:16.160
Folgezustand gleich dem aktuellen Zustand ist, dann reden wir hier von

01:02:16.160 --> 01:02:17.360
stabilen Zuständen.

01:02:17.540 --> 01:02:21.320
Falls ihr euch erinnert, es sah so aus, dass man hier gesagt hat, man

01:02:21.320 --> 01:02:22.060
macht hier Kreise.

01:02:23.360 --> 01:02:24.800
Wer kann sich daran erinnern?

01:02:26.380 --> 01:02:27.760
Okay, immerhin ein paar mehr.

01:02:28.920 --> 01:02:30.380
Gut, warum machen wir das jetzt hier nicht?

01:02:32.780 --> 01:02:35.380
Weil wir das nicht brauchen, weil wir hier mit synchronen Schaltwerken

01:02:35.380 --> 01:02:35.800
arbeiten.

01:02:36.260 --> 01:02:39.020
Und wir gehen davon aus, dass unsere Eingabebelegung jedes Mal stabil

01:02:39.020 --> 01:02:40.820
anliegt, wenn unser Taktzyklus sich ändert.

01:02:41.720 --> 01:02:46.040
Das heißt, hier müssen wir tatsächlich nicht mehr die aktuellen

01:02:46.040 --> 01:02:51.100
Zustände, die Folgezustände oder die aktuellen Zustände betrachten und

01:02:51.100 --> 01:02:53.980
hier instabile oder stabile Übergänge betrachten.

01:02:59.630 --> 01:03:01.150
Wahl der Zustandscodierung.

01:03:01.510 --> 01:03:04.850
Ihr erinnert euch, glaube ich, auch, das wurde schon besprochen bei

01:03:04.850 --> 01:03:06.930
den asynchronen Schaltwerken.

01:03:07.490 --> 01:03:10.030
Wir haben gesagt, bei den asynchronen Schaltwerken ist die Wahl der

01:03:10.030 --> 01:03:11.670
Zustandscodierung sehr, sehr kritisch.

01:03:13.150 --> 01:03:20.770
Weil abhängig von dieser Zustandscodierung kann mein Schaltwerk

01:03:20.770 --> 01:03:22.390
funktionieren oder nicht funktionieren.

01:03:23.110 --> 01:03:27.450
Wenn ich in diese Loop komme, dass ich von einem instabilen Zustand in

01:03:27.450 --> 01:03:29.690
den nächsten instabilen Zustand springe, kann es sein, dass mein

01:03:29.690 --> 01:03:30.870
Schaltwerk überhaupt nicht funktioniert.

01:03:32.370 --> 01:03:35.390
Das heißt, die Wahl der Zustandscodierung ist bei asynchronen

01:03:35.390 --> 01:03:36.630
Schaltwerken sehr, sehr kritisch.

01:03:37.330 --> 01:03:39.650
Bei synchronen Schaltwerken ist sie unkritisch.

01:03:40.350 --> 01:03:42.510
Aus den gleichen Gründen, die wir vorhin genannt haben.

01:03:43.350 --> 01:03:46.310
Es funktioniert grundsätzlich mit jeder eindeutigen Zustandscodierung.

01:03:46.450 --> 01:03:48.570
Also hier sehr wichtig, dass wir hier eindeutig sind.

01:03:52.900 --> 01:03:59.780
Allerdings können wir durch die Wahl einer guten Zustandscodierung den

01:03:59.780 --> 01:04:01.380
Schaltungsaufwand ein wenig reduzieren.

01:04:05.280 --> 01:04:14.260
Allgemein haben wir gesagt, für K-Zustände ist die minimale Anzahl der

01:04:14.260 --> 01:04:19.320
Flip -Flops der Obergrenze des Logarithms Duales bei einer Zustände K.

01:04:21.680 --> 01:04:22.700
Was heißt das?

01:04:23.020 --> 01:04:28.660
Das heißt, wenn ich zwei Zustände habe, brauche ich einen Flip-Flop.

01:04:33.060 --> 01:04:36.020
Wenn ich vier Zustände habe, brauche ich zwei Flip-Flops.

01:04:41.360 --> 01:04:44.760
Bei acht brauche ich drei und so weiter.

01:04:47.080 --> 01:04:48.540
Was brauche ich bei zwölf?

01:04:50.760 --> 01:04:51.320
Vier.

01:04:52.680 --> 01:04:54.140
Was brauche ich bei sechzehn?

01:04:56.540 --> 01:04:57.380
Auch vier.

01:04:59.260 --> 01:05:00.380
Weil, Obergrenze.

01:05:07.640 --> 01:05:12.180
In unserem Fall für den Serienadderer ist die Zustandscodierung

01:05:12.180 --> 01:05:14.460
trivial, weil wir nur zwei Zustände haben.

01:05:14.620 --> 01:05:17.320
Das heißt, für zwei Zustände brauche ich nur einen Flip-Flop und ich

01:05:17.320 --> 01:05:20.080
brauche also nur eine Zustandsvariable.

01:05:20.080 --> 01:05:24.180
In unserem Fall nennen wir diese Zustandsvariable Ü für Übertrag und

01:05:24.180 --> 01:05:27.920
definieren, dass Ü null ist, wenn kein Übertrag ist und Ü eins ist,

01:05:28.220 --> 01:05:29.520
falls ein Übertrag existiert.

01:05:32.260 --> 01:05:34.260
Die Ausgabe in Übergangsschaltnetze.

01:05:35.400 --> 01:05:36.260
Was machen wir hier?

01:05:36.320 --> 01:05:39.180
Wir setzen erstmal die Zustandscodierung in unsere Automatentafel ein

01:05:39.780 --> 01:05:42.180
und dann wollen wir die codierte Ablauftabelle des Schaltwerkes

01:05:42.180 --> 01:05:43.040
nochmal betrachten.

01:05:43.720 --> 01:05:48.820
Das heißt, das war unsere Automatentafel, die wir vorhin hergeleitet

01:05:48.820 --> 01:05:50.440
haben aus unserem Automatengrafen.

01:05:51.160 --> 01:05:55.760
Hier wollen wir jetzt unsere Zustandscodierung entsprechend einsetzen.

01:05:55.940 --> 01:06:00.100
Das heißt, statt KÜ schreibe ich jetzt 0 und statt Ü schreibe ich

01:06:00.100 --> 01:06:00.600
jetzt 1.

01:06:03.880 --> 01:06:07.240
Dann habe ich hier auf der rechten Seite meine codierte Ablauftabelle

01:06:08.780 --> 01:06:14.080
und will hier für jede Kombination von aktuellem Zustand und

01:06:14.080 --> 01:06:18.220
Eingabebelegung einen Folgezustand und die Ausgabe generieren.

01:06:18.220 --> 01:06:20.520
Die kann ich quasi aus der Tabelle ablesen.

01:06:20.980 --> 01:06:25.600
Das heißt, wenn ich hier im Zustand Ü0 bin, bin ich in der ersten

01:06:25.600 --> 01:06:30.240
Zeile, habe ich hier eine Eingabebelegung von X und Y gleich 0,0 bin

01:06:30.240 --> 01:06:31.180
ich in der ersten Spalte.

01:06:31.480 --> 01:06:36.300
Das heißt, mein Folgezustand ist 0, ist mein ÜT plus 1 und meine

01:06:36.300 --> 01:06:41.220
Ausgabe ist S, ist hier auf der rechten Seite auch 0.

01:06:42.340 --> 01:06:47.140
Betrachte ich die zweite Zeile, habe ich hier den Zustand 0, habe X

01:06:47.140 --> 01:06:49.440
und Y jeweils 0,1 als Eingabe.

01:06:49.560 --> 01:06:51.120
Das heißt, ich bin in der zweiten Spalte.

01:06:52.020 --> 01:06:55.840
Mein Folgezustand ist die 0, mein ÜT plus 1 ist 0, meine Ausgabe ist

01:06:55.840 --> 01:06:56.280
die 1.

01:06:57.980 --> 01:06:59.000
Soweit ist klar, glaube ich.

01:06:59.600 --> 01:07:02.400
Das macht man dann für die ganze Automatentafel.

01:07:04.200 --> 01:07:07.720
Hier ist natürlich interessant, wir haben gesagt, wir haben ja die

01:07:07.720 --> 01:07:11.640
Zustandscodierung eingesetzt, das heißt, überall wo mein aktueller

01:07:11.640 --> 01:07:17.220
Zustand 0 ist, entspricht eigentlich meinem Zustand KÜ für keinen

01:07:17.220 --> 01:07:17.740
Übertrag.

01:07:18.240 --> 01:07:23.000
Überall wo mein ÜT 1 ist, entspricht eigentlich dem Zustand Ü für

01:07:23.000 --> 01:07:23.560
Übertrag.

01:07:26.400 --> 01:07:27.420
Soweit so klar?

01:07:32.620 --> 01:07:33.480
Nächster Schritt.

01:07:34.680 --> 01:07:37.640
Wir können hier schon vielleicht zunächst mal Anmerkungen.

01:07:39.280 --> 01:07:42.980
Aus dieser codierten Ablauftabelle, also aus dem hier,

01:07:46.300 --> 01:07:48.840
kann man bereits Funktionsausdrücke für die Ausgabe Schaltnetze

01:07:48.840 --> 01:07:49.280
ableiten.

01:07:49.500 --> 01:07:53.080
Das heißt, unsere S, also unsere Ausgabe S, können wir hier schon

01:07:53.080 --> 01:07:53.810
direkt erzeugen.

01:07:55.560 --> 01:07:59.680
Das ist nichts anderes als eine Funktion, die am Anfang des Semesters

01:07:59.680 --> 01:08:01.560
mit KV-Diagrammen zum Beispiel gelöst hat.

01:08:03.520 --> 01:08:11.000
Wir können, für die Erzeugung der Überführungsfunktion, brauchen wir

01:08:11.000 --> 01:08:13.840
zuerst mal den Typ des Flipflops, den wir verwenden wollen.

01:08:14.780 --> 01:08:17.140
Das heißt, wir wollen wissen, wie will ich denn überhaupt meinen

01:08:17.140 --> 01:08:18.380
Serienadderer implementieren.

01:08:18.500 --> 01:08:22.220
Ich könnte einen JK-Flipflop, einen D-Flipflop, T-Flipflop oder auch

01:08:22.220 --> 01:08:23.660
einen RS-Flipflop benutzen.

01:08:23.660 --> 01:08:25.680
Hier muss ich mich festlegen.

01:08:26.580 --> 01:08:30.640
Abhängig davon, welchen Flipflop-Typ ich hier wähle, muss man

01:08:30.640 --> 01:08:32.340
natürlich auch die Ansteuerung anders machen.

01:08:34.260 --> 01:08:37.060
Und natürlich, die Wahl des Flipflops beeinflusst die Größe der

01:08:37.060 --> 01:08:38.020
Überführungsschaltnetze.

01:08:38.540 --> 01:08:41.680
Und auch eine Güte der Zustandskodierung kann erst bestimmt werden,

01:08:42.100 --> 01:08:43.340
wenn wir den Flipflop-Typ kennen.

01:08:45.140 --> 01:08:49.300
Wir wollen hier das Ganze mit einem JK-Flipflop realisieren.

01:08:50.540 --> 01:08:53.320
Wir erinnern uns, das ist die Ansteuertabelle eines JK-Flipflops.

01:08:53.840 --> 01:08:56.860
Das sind meine Anfangszustände, meine Folgezustände und das sind die

01:08:56.860 --> 01:09:01.920
Belegungen des JK-Flipflops, die ich anlegen muss, um genau diese

01:09:01.920 --> 01:09:02.840
Funktion zu erreichen.

01:09:04.260 --> 01:09:06.960
Wir gehen zurück auf die kodierte Ablauftabelle.

01:09:09.380 --> 01:09:12.140
Also das ist genau das, was ihr auf dem vorherigen Folien gehabt habt.

01:09:12.960 --> 01:09:21.660
Der Fokus liegt jetzt hier auf meinem Zustand UT und im Folgezustand

01:09:21.660 --> 01:09:22.880
UT plus 1.

01:09:26.880 --> 01:09:30.620
Da wir gesagt haben, wir wollen einen JK-Flipflop verwenden, brauche

01:09:30.620 --> 01:09:33.520
ich hier meine Ansteuerleitungen für meinen JK-Flipflop, also einmal J

01:09:33.520 --> 01:09:33.960
und K.

01:09:35.080 --> 01:09:38.320
Und ich muss jetzt für jede Zeile bestimmen, wie gelange ich von

01:09:38.320 --> 01:09:40.560
meinem aktuellen Zustand UT

01:09:44.100 --> 01:09:46.140
auf den Folgezustand UT plus 1.

01:09:48.340 --> 01:09:49.920
Dafür brauche ich meine Ansteuertabelle.

01:09:50.540 --> 01:09:53.140
Das heißt, ich betrachte jetzt, wie komme ich von 0 nach 0.

01:09:53.880 --> 01:09:56.140
Und das ist in diesem Fall ein Null-Don't-Care.

01:09:56.700 --> 01:09:58.660
Das heißt, ich kann hier ein Null-Don't-Care eintragen.

01:09:59.380 --> 01:10:01.820
Wie komme ich von...

01:10:02.500 --> 01:10:04.520
Das kennen wir schon, das kennen wir auch schon.

01:10:05.140 --> 01:10:07.180
Das Erste, wo es sich ändert, ist hier von 0 auf 1.

01:10:08.180 --> 01:10:10.560
Also Null-Don't-Care, Null-Don't-Care, Null-Don't-Care.

01:10:11.060 --> 01:10:15.980
Wenn ich von 0 auf die 1 will, wenn ich von 0 auf die 1 will,

01:10:16.200 --> 01:10:20.600
betrachte ich hier diese Zeile und merke, ich brauche ein J1 und ein K

01:10:20.600 --> 01:10:21.060
-Don't -Care.

01:10:21.340 --> 01:10:22.160
Also 1-Don't-Care.

01:10:23.580 --> 01:10:28.960
Dann habe ich hier ein 1-0 und schließlich ein 1-1.

01:10:29.180 --> 01:10:30.860
Und dann der Rest bleibt auf 1-1.

01:10:31.360 --> 01:10:35.540
Das heißt, ich habe hier ein Don't-Care-1 als nächstes und danach ein

01:10:35.540 --> 01:10:37.500
Don't -Care-0 für den Rest der Tabelle.

01:10:41.200 --> 01:10:41.800
Soweit so klar?

01:10:43.540 --> 01:10:44.860
Wer hat das nicht verstanden?

01:10:48.430 --> 01:10:50.930
Ich bin im Übungsmodus, ich frage euch immer noch, ob ihr das

01:10:50.930 --> 01:10:51.490
verstanden habt.

01:10:53.250 --> 01:10:56.330
Aber ihr könnt ruhig einwerfen, falls euch das zu schnell geht oder

01:10:56.330 --> 01:10:58.590
falls euch irgendwas nicht klar ist.

01:10:58.630 --> 01:10:59.850
Dann könnt ihr ruhig unterbrechen.

01:11:02.630 --> 01:11:05.490
Ich glaube, das ist die vorletzte Folie, wenn ich mich recht erinnere.

01:11:06.750 --> 01:11:08.930
Der nächste Schritt ist, dass man tatsächlich diese Funktion

01:11:08.930 --> 01:11:09.710
herleitet.

01:11:09.890 --> 01:11:18.630
Das heißt, wir nehmen jetzt J als Ausgabe der Funktion von Ü, X und Y.

01:11:19.790 --> 01:11:23.390
Das Ü, X und Y habe ich in meinem KV-Diagramm und habe hier mein J

01:11:23.390 --> 01:11:24.110
eingetragen.

01:11:24.650 --> 01:11:26.370
Die großen X hier sind meine Don't-Cares.

01:11:27.050 --> 01:11:30.750
Ich mache das Gleiche hier für J, einmal für K.

01:11:31.770 --> 01:11:34.210
Also komplementär auf der rechten Seite hier Don't-Cares, auf der

01:11:34.210 --> 01:11:35.250
linken Seite hier Don't-Cares.

01:11:35.750 --> 01:11:36.910
Hier habe ich die Funktionswerte.

01:11:36.910 --> 01:11:39.870
Das S haben wir gesagt, das konnten wir schon direkt machen, bevor wir

01:11:39.870 --> 01:11:43.330
überhaupt das J und K bestimmt haben, konnten wir schon die

01:11:43.330 --> 01:11:47.850
Funktionsgleichung für S bestimmen, beziehungsweise die Min-Therme für

01:11:47.850 --> 01:11:50.070
das S bestimmen und in unser KV-Diagramm eintragen.

01:11:50.970 --> 01:11:55.270
Der nächste Schritt ist jetzt einfach, dass wir sagen, wir optimieren.

01:11:56.710 --> 01:12:00.370
Wir suchen unsere Premium-Likanten, können einmal hier diesen Block

01:12:00.370 --> 01:12:03.530
zusammenfassen, können für das K einmal diesen Block zusammenfassen.

01:12:04.230 --> 01:12:06.950
Für das S gibt es leider nicht so eine tolle Möglichkeit.

01:12:07.250 --> 01:12:09.110
Hier hat man tatsächlich nur die einzelnen Min-Therme, die man

01:12:09.110 --> 01:12:13.090
zusammenfassen muss.

01:12:14.790 --> 01:12:15.550
Bisschen tief.

01:12:17.110 --> 01:12:23.370
Und daraus ergibt sich dann tatsächlich einmal hier, für das J ein Y

01:12:23.370 --> 01:12:33.350
und X, für das K ein Nicht-Y, Nicht-X, also Nicht-X, jeweils T für den

01:12:33.350 --> 01:12:34.170
Zeitpunkt T.

01:12:34.710 --> 01:12:36.170
Könnte man jetzt hier aber auch erstmal weglassen.

01:12:37.030 --> 01:12:40.030
Und für das S hätte man natürlich die einzelnen Min-Therme, vier

01:12:40.030 --> 01:12:42.770
Stück, die dann jeweils diesen Min-Thermen hier entsprechen.

01:12:43.410 --> 01:12:45.450
Zusammenfassend kann man hier auch sagen, das ist ein Äquivalenz

01:12:45.450 --> 01:12:49.530
-Therm, also wenn X äquivalent ist zu Y oder äquivalent ist zu Ü, also

01:12:49.530 --> 01:12:53.410
wenn alle drei gleich sind, dann hat man hier eine Eins-Belegung.

01:12:56.350 --> 01:13:03.210
So, jetzt haben wir die Funktions- Funktionen haben wir jetzt bestimmt

01:13:03.210 --> 01:13:05.330
für J, K und S.

01:13:06.210 --> 01:13:08.670
Und der letzte Schritt ist tatsächlich die Implementierung.

01:13:09.850 --> 01:13:12.070
Wenn wir uns die Implementierung anschauen, haben wir einmal

01:13:15.470 --> 01:13:20.690
hier unsere Ausgabe S als ein Verodern von vier Thermen.

01:13:20.830 --> 01:13:21.550
Das ist unser Oder.

01:13:21.950 --> 01:13:23.970
Das sind die vier Uns, die da reinlaufen.

01:13:24.610 --> 01:13:27.190
Dann haben wir hier X, Nicht-Y, Ü zum Beispiel.

01:13:27.190 --> 01:13:38.350
Das ist Nicht-X, das hier ist Nicht-Ü und das hier ist Y.

01:13:39.110 --> 01:13:42.190
Also Nicht-X, Nicht-Ü und Y.

01:13:42.810 --> 01:13:43.250
War das richtig?

01:13:44.310 --> 01:13:45.730
Ja, das ist dieser Term hier.

01:13:48.190 --> 01:13:53.990
Und das sind die vier einzelnen Imimplikanten oder Min-Thermen in

01:13:53.990 --> 01:13:54.450
diesem Fall.

01:13:55.930 --> 01:14:01.110
Für die Ansteuerung J unseres Flip-Flops hier haben wir X und Y.

01:14:01.490 --> 01:14:06.990
Das heißt, ich habe hier ein Und von X, Y und X.

01:14:07.850 --> 01:14:13.850
Und ich habe hier für das K einmal Nicht-X und einmal Nicht-Y.

01:14:15.450 --> 01:14:19.770
Also hier das Schaltnetz, hier unser Flip-Flop und hier die

01:14:19.770 --> 01:14:23.570
Rückleitung zu dem Schaltnetz selber.

01:14:27.340 --> 01:14:27.820
Genau.

01:14:28.640 --> 01:14:31.360
Was man hier jetzt noch machen kann, ist die Initialisierung mit dem

01:14:31.360 --> 01:14:36.660
invertierten asynchronen Reset-Eingang.

01:14:37.140 --> 01:14:38.780
Hier zu sehen an dem Kreis.

01:14:39.520 --> 01:14:42.520
Und dass es invertiert ist, das signalisiert man dadurch, dass man

01:14:42.520 --> 01:14:46.720
hier über dem Initialisierungseingang die Negation drüber laufen hat.

01:14:47.170 --> 01:14:48.520
Und hier natürlich der Takt.

01:14:51.100 --> 01:14:56.500
Und damit hat man dann N-Serien-Addierer realisiert.

01:14:59.020 --> 01:15:00.120
Fragen dazu?

01:15:02.420 --> 01:15:03.080
Keine?

01:15:03.580 --> 01:15:03.880
Super.

01:15:04.760 --> 01:15:05.660
Dann sind wir, glaube ich, durch.

01:15:06.080 --> 01:15:08.900
Ich bedanke mich und bis zum nächsten Mal.

