WEBVTT

00:08.340 --> 00:11.440
Herzlich willkommen zur 14.

00:11.640 --> 00:16.220
Vorlesung in Digitaltechnik und Entwurfsverfahren, heute im Hörsaal am

00:16.220 --> 00:16.840
Fassadengarten.

00:17.700 --> 00:20.160
Ich bin mir nicht genau sicher, ob heute aufgezeichnet wird, aber

00:20.160 --> 00:21.320
lassen wir uns mal überraschen.

00:24.040 --> 00:25.480
Also, wo haben wir aufgehört?

00:25.780 --> 00:29.300
Letzte Woche waren Multiplexer, Demultiplexer, Implementierung

00:29.300 --> 00:33.800
beliebiger Schaltfunktionen mit diesen, mikrokormierte Logik und dann

00:33.800 --> 00:36.860
haben wir noch Speicher, SRAM, DRAM und ROMs kennengelernt.

00:38.100 --> 00:41.100
Heute machen wir da ein bisschen weiter und werden dann weiter zum

00:41.100 --> 00:41.880
nächsten Thema gehen.

00:44.560 --> 00:48.740
Also, wir haben ja gesagt, bei diesen Demultiplexern zum Beispiel

00:48.740 --> 00:50.840
haben wir immer die disjunktive Normalform realisiert.

00:54.700 --> 00:59.480
Heißt natürlich auch, dass wir Mintermins benutzt haben, um die

00:59.480 --> 01:00.480
Funktion darzustellen.

01:02.460 --> 01:05.060
Bei großen Funktionen kann es natürlich sehr aufwendig werden.

01:05.200 --> 01:07.780
Das heißt, vielleicht will man da sich ein bisschen Aufwand sparen.

01:07.880 --> 01:11.960
Deswegen versucht man dann, die disjunktive Minimalform zu verwenden,

01:12.180 --> 01:14.340
weil auch hier lässt sich die Funktion ein bisschen kompakter

01:14.340 --> 01:14.820
darstellen.

01:15.380 --> 01:20.520
Und dafür gibt es diese sogenannten Programmable Logic Arrays, PLAs

01:20.520 --> 01:21.140
abgekürzt.

01:22.740 --> 01:28.360
Und im Vergleich zum ROM, der Unterschied zum ROM ist, dass wir hier

01:28.360 --> 01:31.300
tatsächlich nicht Minterme verknüpfen, sondern Primimplikanten.

01:33.880 --> 01:37.840
Und dafür werden wir dann im Schaltbild diesen Decoder durch eine UND

01:37.840 --> 01:38.600
-Matrix ersetzen.

01:38.840 --> 01:40.300
Das sehen wir jetzt hier auf dem nächsten Schaubild.

01:41.580 --> 01:45.860
Wir haben hier unsere Konjunktionen, die dann hier disjunktiv

01:45.860 --> 01:46.700
verwendet werden.

01:47.700 --> 01:48.940
Wie kann man sich das vorstellen?

01:51.820 --> 02:04.080
Wenn ich hier n Eingänge habe, das heißt, nehmen wir das mal x0 und

02:04.080 --> 02:11.160
das hier xn-1, dann kann ich hier entweder die Variable bejaht oder

02:11.160 --> 02:14.200
verneint zur Verfügung stellen, indem ich hier einen Kontakt

02:14.200 --> 02:14.680
herstelle.

02:15.200 --> 02:18.600
Beim xn-1 könnte ich hier zum Beispiel eine negierte Version von xn-1

02:18.600 --> 02:25.360
nehmen und könnte dann auf einen der Ausgänge beide verknüpfen.

02:25.920 --> 02:33.820
Das heißt, ich habe hier eine Verundung von x0 und xn-1 nicht und

02:33.820 --> 02:39.280
würde dann hier verschiedene Terme zum Beispiel oder verknüpfen

02:39.280 --> 02:39.520
können.

02:39.700 --> 02:40.800
Das würde dann hier so aussehen.

02:46.240 --> 02:49.440
Dazu ein kleines Beispiel vielleicht, also ein konkretes Beispiel.

02:50.180 --> 02:53.060
Gegeben seien die schon minimierten Funktionen f1 und f2.

02:53.520 --> 03:00.160
f1 sei dann ab nicht oder ac und f2 sei a nicht c nicht oder ac oder

03:00.160 --> 03:01.060
abc nicht.

03:01.760 --> 03:06.240
Und wir sehen hier schon, dass unser ac jeweils in den Funktionen

03:06.240 --> 03:09.900
zweimal auftaucht, also in f1 auftaucht sowie in f2.

03:10.400 --> 03:11.840
Das heißt, man kann es hier zweimal verwenden.

03:13.460 --> 03:15.740
Und jetzt würde bei einer konkreten Implementierung würde es so

03:15.740 --> 03:24.820
aussehen, dass wir zunächst die Implikanten hier zum Beispiel ab

03:24.820 --> 03:29.200
nicht, wenn wir ab nicht betrachten, dann können wir das herstellen,

03:29.260 --> 03:33.780
indem wir hier a und b nicht auf diese Leitung verknüpfen.

03:34.940 --> 03:40.760
Das heißt, hier wird a und b nicht erzeugt auf dieser Leitung und es

03:40.760 --> 03:45.440
wird dann verodert für die Funktion f1 einmal hier.

03:47.120 --> 03:49.200
Reicht allerdings nicht, ich brauche ja noch das ac.

03:52.550 --> 03:57.350
Das heißt, ac könnte ich mir erzeugen, indem ich hier a verbinde und c

03:57.350 --> 03:57.970
verbinde.

03:58.150 --> 04:02.170
Das heißt, auf der Leitung liegt jetzt mein a und c und das muss

04:02.170 --> 04:03.330
natürlich auch,

04:10.100 --> 04:19.740
indem ich hier ac und ab nicht mache, könnte ich hier f1 erzeugen.

04:19.960 --> 04:21.880
Hier würde dann mein f1 als Ausgang liegen.

04:21.920 --> 04:25.100
Also ich hoffe, dass ist jedem klar, dass ich hier quasi so eine

04:25.100 --> 04:28.300
Matrix habe, so ein Array habe, wo ich Unverknüpfungen erstelle.

04:28.400 --> 04:30.540
Auf der rechten Seite habe ich mein oder-Glied.

04:30.780 --> 04:34.360
Hier verknüpfe ich dann meine oder-Elemente miteinander, also meine

04:34.360 --> 04:35.500
Prämium, die kann mit einem oder.

04:35.800 --> 04:39.060
Das heißt, ich kann hier Dissjunktive Minimalformen recht gut

04:39.060 --> 04:41.620
abbilden, weil wir auch hier eine zweistufige Implementierung haben.

04:41.760 --> 04:44.020
Ich habe auf der linken Seite meine ganzen und-Elemente, auf der

04:44.020 --> 04:45.240
rechten Seite habe ich mein oder-Element.

04:46.660 --> 04:49.320
Wem ist das nicht klar, wie das funktioniert?

04:51.480 --> 04:51.840
Prinzipiell?

04:52.580 --> 04:53.480
Also jeder hat es verstanden.

04:54.720 --> 04:55.080
Wunderbar.

04:55.880 --> 04:57.460
Dann haben wir die Funktion f2.

04:58.160 --> 04:59.580
Hier sehen wir a, c nicht.

05:00.820 --> 05:01.820
Machen wir das auch mal rot.

05:03.900 --> 05:06.080
Also a nicht, c nicht.

05:06.480 --> 05:09.620
Das könnte ich mir jetzt erzeugen auf einer anderen Leitung.

05:10.140 --> 05:15.100
Da würde ich dann hier zum Beispiel das negierte a und hier das

05:15.100 --> 05:16.340
negierte c abgreifen.

05:16.780 --> 05:22.480
Das heißt, auf dieser Leitung liegt jetzt mein a nicht und c nicht.

05:23.960 --> 05:26.580
Und hier auf der rechten Seite habe ich natürlich noch die

05:26.580 --> 05:28.760
Dissjunktion meiner Prämiumlikanten.

05:28.940 --> 05:31.420
Das heißt, für f2 muss natürlich dieser Term mit rein.

05:31.980 --> 05:36.080
Wir implementieren jetzt aber zunächst einmal a, b, c nicht.

05:36.540 --> 05:37.620
Können wir mit grün machen.

05:40.380 --> 05:41.880
a, b, c nicht wäre dann hier der erste.

05:42.100 --> 05:46.940
Ich würde hier das positive a, positives b und hier das negierte c

05:46.940 --> 05:47.560
abgreifen.

05:47.740 --> 05:51.180
Das heißt, hier würde dann a, b, c nicht entstehen auf dieser Leitung.

05:52.380 --> 05:55.020
Und natürlich habe ich jetzt alle Terme, alle Prämiumlikanten, die ich

05:55.020 --> 05:59.620
brauche, um mir hier meine Funktion f2 zusammenzubauen.

05:59.760 --> 06:05.380
Das heißt, ich habe einmal a, c, was jetzt doppelt vorkam.

06:05.480 --> 06:07.800
Ich habe einmal a nicht, c nicht.

06:08.380 --> 06:08.940
Das haben wir hier.

06:10.120 --> 06:11.900
Und ich habe einmal a, b, c nicht.

06:12.860 --> 06:16.520
Und diese drei Prämiumlikanten werden jetzt mit oder verknüpft und

06:16.520 --> 06:17.720
landen dann zu f2.

06:17.840 --> 06:19.840
Das heißt, ich habe hier die Implementierung von f2.

06:22.920 --> 06:23.400
Straightforward.

06:24.120 --> 06:27.240
Das Einzige, was jetzt hier interessant ist nochmal zusätzlich, ist

06:27.240 --> 06:30.280
natürlich, dass wir hier a, c haben und dieser Term zweimal vorkommt.

06:31.440 --> 06:33.320
Und ich das tatsächlich auch hier nutzen kann.

06:33.400 --> 06:36.400
Ich habe einmal a, c für f1 genutzt und ich habe es nochmal für f2

06:36.400 --> 06:36.960
nutzen können.

06:37.320 --> 06:44.360
Das heißt, wenn man jetzt so ein PLA hat, dann versucht man nicht

06:44.360 --> 06:47.080
Funktionen einzeln zu minimieren, sondern wir versuchen eine

06:47.080 --> 06:48.400
Bündelminimierung durchzuführen.

06:48.840 --> 06:53.060
Das heißt, man versucht möglichst viele Terme zu finden, die in

06:53.060 --> 06:57.520
mehreren Funktionen gleichzeitig vorkommen, wie bei a, c in dem

06:57.520 --> 06:58.220
letzten Beispiel.

06:59.580 --> 07:01.860
Bündelminimierung selber haben wir schon besprochen in der Übung, wo

07:01.860 --> 07:02.960
das auch nochmal kurz behandelt.

07:05.200 --> 07:10.000
Der Straightforward-Ansatz wäre natürlich, das grafisch zu lösen.

07:10.120 --> 07:14.920
Das heißt, ein paar KV-Diagramme nebeneinander zu stellen und visuell

07:14.920 --> 07:17.120
dann zu schauen, was sich da überschneidet.

07:18.060 --> 07:21.060
Ansonsten kann man natürlich auch es formell machen mit dem Espresso

07:21.060 --> 07:21.560
-Algorithmus.

07:21.920 --> 07:24.960
Auf den sind wir tatsächlich nicht so tief eingegangen und es ist auch

07:24.960 --> 07:26.340
nicht Teil der Vorlesung jetzt.

07:28.400 --> 07:30.820
Genau, wir versuchen den Gesamtaufwand zu minimieren.

07:30.920 --> 07:32.540
Dafür ist eine Bündelminimierung notwendig.

07:33.900 --> 07:37.180
Jetzt gibt es noch verschiedene Variationen vom PLA.

07:41.980 --> 07:43.920
Zunächst mal, wie werden PLAs hergestellt?

07:44.020 --> 07:46.240
Die werden ähnlich wie bei ROMs während der Herstellung

07:46.240 --> 07:46.960
personalisiert.

07:47.160 --> 07:51.820
Das heißt, entweder gibt es diese Teile schon vorgefertigt für eine

07:51.820 --> 07:54.700
bestimmte Funktion oder man kann das in Auftrag geben und die werden

07:54.700 --> 07:57.240
dann für die einzelnen Bedürfnisse hergestellt.

07:58.180 --> 08:00.140
Das heißt, es ist ähnlich wie bei den ROMs.

08:00.180 --> 08:03.300
Es ist so ein Read-Only, so ein einmaliges Ding.

08:03.880 --> 08:06.760
Wenn man jetzt komplizierte Baute oder wenn man ein bisschen variabler

08:06.760 --> 08:11.000
oder dynamischer sein will, kann man natürlich programmierbare

08:11.000 --> 08:11.900
Elemente hier nehmen.

08:12.040 --> 08:16.360
Da gibt es einmal das FPLA, den Field Programmable Logic Array.

08:17.580 --> 08:20.880
Den gibt es dann für eine bestimmte Anzahl von Eingangsvariablen n und

08:20.880 --> 08:23.380
Produktterm k sowie Ausgangsvariablen m.

08:25.040 --> 08:26.800
Und den Rest kann man natürlich selber programmieren.

08:26.920 --> 08:29.480
Das heißt, hier braucht man noch ein Programmiergerät, der tatsächlich

08:29.480 --> 08:32.620
die UND- und die ODER-Matrix, also auf der linken und auf der rechten

08:32.620 --> 08:37.210
Seite, frei programmieren kann.

08:38.970 --> 08:39.610
Doch so viele?

08:41.570 --> 08:44.270
Okay, also FPLA haben wir gesagt, frei programmierbar.

08:45.570 --> 08:47.730
Frei programmierbar heißt natürlich aber auch ein bisschen teurer.

08:48.370 --> 08:49.270
Programmiergerät ein bisschen teurer.

08:49.370 --> 08:50.690
Ich habe eine UND- und eine ODER-Matrix.

08:52.230 --> 08:54.630
Wenn man es ein bisschen günstiger haben will, kann man zu PAL

08:54.630 --> 09:02.250
-Bausteinen, Programmable Array Logic, ein bisschen ungünstige

09:02.250 --> 09:05.930
Abkürzung, weil PLA, PAL... PAL unterscheiden sich eigentlich nur

09:05.930 --> 09:09.010
darin, dass diese ODER-Matrix bereits während der Herstellung

09:09.010 --> 09:12.870
festgelegt wird, also personalisiert entweder den eigenen Ansprüchen

09:12.870 --> 09:15.950
oder vorgefertigt, nach was halt am häufigsten verwendet wird.

09:17.330 --> 09:19.510
Und frei programmierbar ist dann einfach dieser UND-Teil auf der

09:19.510 --> 09:19.990
linken Seite.

09:20.570 --> 09:24.130
Jetzt haben wir hier so ein kleines Beispiel, die schematische

09:24.130 --> 09:25.790
Darstellung eines PAL-Bausteins.

09:26.190 --> 09:29.390
Wir haben hier auf der linken Seite K-Produktherme einer Funktion F1,

09:29.550 --> 09:31.430
die kann man dann hier mit UND verknüpfen.

09:31.990 --> 09:34.510
Und auf der rechten Seite, wie man hier sieht, sind die ODER-Elemente

09:34.510 --> 09:35.330
schon festgelegt.

09:35.450 --> 09:39.570
Das heißt, ich habe hier beispielsweise ein F1, das ich dann natürlich

09:39.570 --> 09:44.610
auch höchstens mit vier Produktthermen verODERn kann oder ein Fm,

09:45.350 --> 09:48.430
abhängig davon, wie der Baustein aufgebaut ist.

09:49.790 --> 09:53.930
Jetzt braucht man aber natürlich nicht immer vier Produkttherme,

09:54.030 --> 09:55.430
manchmal braucht man vielleicht nur drei.

09:59.310 --> 10:04.450
Daher muss man diese unbenutzten Eingänge mit Dummy-Thermen belegen,

10:04.670 --> 10:05.970
die die Funktion selber nicht verändern.

10:06.150 --> 10:06.870
Was kann man da machen?

10:06.970 --> 10:11.310
Man kann zum Beispiel bereits vorhandene Produkttherme einfach noch

10:11.310 --> 10:12.050
mal drüber schalten.

10:12.170 --> 10:13.110
Das sehen wir hier in dem Beispiel.

10:13.670 --> 10:18.150
Ich habe hier ein ODER-Element mit vier Eingängen und ich habe hier

10:18.150 --> 10:22.330
die Produkttherme bc, ac nicht und ab, die ich implementieren möchte.

10:22.970 --> 10:25.270
Diesen einen Eingang, den lasse ich dann allerdings nicht frei,

10:25.430 --> 10:29.510
sondern ich versuche tatsächlich einfach das bc beispielsweise doppelt

10:29.510 --> 10:31.090
zu belegen, auch auf die erste Leitung.

10:31.690 --> 10:35.590
Damit umgehe ich das Problem einfach.

10:37.530 --> 10:39.530
Ändert für meine Implementierung der Funktion nichts.

10:39.650 --> 10:42.810
Es ist immer noch die gleiche Funktion und ich kann natürlich hier ein

10:42.810 --> 10:45.290
günstigeres Bauteil benutzen.

10:47.690 --> 10:50.390
So, dann wären wir mit dem Kapitel zunächst mal durch oder mit dem

10:50.390 --> 10:50.950
Unterkapitel.

10:51.190 --> 10:52.990
Das nächste Kapitel wären Laufzeiteffekte.

10:55.390 --> 10:56.750
Gibt es hierzu noch Fragen?

10:59.430 --> 10:59.870
Keine mehr?

11:00.110 --> 11:00.270
Gut.

11:01.150 --> 11:02.330
Also, Laufzeiteffekte.

11:03.050 --> 11:05.850
Wir werden jetzt zunächst mal das Todzeitmodell kennenlernen.

11:06.070 --> 11:07.450
Also wir werden zunächst mal schauen, was sind überhaupt

11:07.450 --> 11:08.170
Laufzeiteffekte?

11:09.210 --> 11:12.890
Warum ist es für uns problematisch oder kritisch oder interessant?

11:13.670 --> 11:15.430
Dann lernen wir das Todzeitmodell kennen.

11:15.890 --> 11:20.430
Wir werden Hazards und Hazardfehler kennenlernen und diese dann auch

11:20.430 --> 11:21.410
analysieren bzw.

11:21.630 --> 11:22.850
versuchen zu beheben.

11:25.330 --> 11:26.050
Laufzeiteffekte.

11:26.770 --> 11:31.510
Wir haben immer bisher Gutter auf Gutterebene als ideale logische

11:31.510 --> 11:32.450
Verknüpfungen betrachtet.

11:32.590 --> 11:34.270
Das heißt, es gibt keinerlei Verzögerungswerte.

11:34.970 --> 11:37.810
Die Bauteile schalten von 0 auf 1 sofort.

11:38.470 --> 11:41.670
Wenn man verschiedene Eingabebelegungen verändert, wechseln sie alle

11:41.670 --> 11:42.270
gleichzeitig.

11:44.290 --> 11:46.330
In der Realität sieht es natürlich ein bisschen anders aus.

11:46.410 --> 11:49.970
In der Realität muss man die Sachen bauen und dann legt man

11:49.970 --> 11:52.590
irgendwelche Widerstände an, hat man irgendwelche Widerstände in den

11:52.590 --> 11:53.030
Elementen.

11:53.110 --> 11:56.350
Man legt bestimmte Spannungen an und das Spannungsverhalten verändert

11:56.350 --> 11:59.190
sich abhängig von der Qualität der Bauteile, abhängig von den

11:59.190 --> 12:02.910
Bauteilen selber, abhängig von Kapazitäten und so weiter.

12:04.370 --> 12:07.610
Das heißt, wenn wir uns jetzt mal den zeitlichen Signalverlauf von dem

12:07.610 --> 12:10.510
realen Gutter anschauen, sieht er ungefähr so aus.

12:12.190 --> 12:16.490
Wir haben jetzt hier UX, das ist unsere Eingabespannung.

12:16.930 --> 12:18.350
UY ist die Ausgabespannung.

12:18.830 --> 12:22.630
XT wäre meine Eingabevariable und YT wäre meine Ausgabevariable, wie

12:22.630 --> 12:23.230
ich sie gerne hätte.

12:23.890 --> 12:25.510
Und dieses Bauteil wird jetzt erstmal inverter.

12:26.290 --> 12:31.050
Idealerweise würden wir jetzt natürlich erwarten, dass wenn ich einen

12:31.050 --> 12:38.990
Inverter habe und ich habe hier ein XT, dass ich so einen Verlauf

12:38.990 --> 12:39.370
bekomme.

12:39.930 --> 12:41.130
Das wäre mein Idealverlauf.

12:42.290 --> 12:43.690
Also das ist meine Eingabevariable.

12:44.710 --> 12:47.510
Das müsste ich idealerweise links eingeben und auf der anderen Seite,

12:47.570 --> 12:50.630
auf der rechten Seite, würde ich dann idealerweise gerne sowas haben.

12:53.570 --> 12:59.810
Genau da, wo meine Eingabevariable 1 ist, hätte ich gerne eine 0 und

12:59.810 --> 13:02.250
da, wo meine Eingabevariable 0 ist, hätte ich hier gerne eine 1.

13:03.410 --> 13:07.510
Das ist das Verhalten, was wir bisher gesehen haben, was wir bisher

13:07.510 --> 13:08.530
vorausgesetzt haben.

13:09.130 --> 13:11.950
Und jetzt schauen wir uns die Realität an und werden ein bisschen

13:11.950 --> 13:12.470
ernüchtert.

13:12.810 --> 13:15.330
In der Realität sieht es nämlich so aus, dass ich einen Spannungspegel

13:15.330 --> 13:15.590
habe.

13:16.290 --> 13:20.790
Der ist nicht ganz bei 1 oder bei, wenn jetzt 1 bei 5 Volt wäre, wäre

13:20.790 --> 13:24.010
der jetzt nicht ganz bei 5 Volt, sondern ist dann bei 4,8 oder sowas.

13:24.630 --> 13:26.750
Und ich hätte dann hier irgendwann einen Spannungsabfall.

13:27.090 --> 13:28.950
Der geht nicht ganz runter bis 0, der hat noch ein bisschen

13:28.950 --> 13:32.750
Restspannung hier und würde dann hier ein bisschen weiterlaufen.

13:33.170 --> 13:36.910
Und man sieht, dass hier auch der Abfall selber, dass der nicht so ein

13:36.910 --> 13:41.110
rechtwinkliger, sofortiger Abfall ist, sondern ich habe hier leichte

13:41.110 --> 13:41.830
Verzögerungen.

13:42.130 --> 13:46.030
Also hier geht es ein bisschen, zunächst mal langsam runter und dann

13:46.030 --> 13:47.170
flacht es hier wieder ab.

13:47.490 --> 13:51.430
Also ich habe hier so eine runde Ecke quasi.

13:54.250 --> 13:57.430
Ich schaue mir das Ausgangssignal an und auch beim Ausgangssignal sehe

13:57.430 --> 13:58.950
ich, dass man hier so eine Steigung hat.

13:59.070 --> 14:02.910
Dann gibt es eine Sättigung, pegelt sich wieder ein auf 4, irgendwas

14:02.910 --> 14:07.830
Volt und dann würde hier der Abfall wieder so aussehen, dass ich hier

14:07.830 --> 14:10.210
einen Abfall habe und dann wieder so ein Einpendeln der Spannung.

14:11.190 --> 14:14.850
Hier interessant natürlich bei der Ausgangsspannung, dass man im

14:14.850 --> 14:18.290
Gegensatz zur Eingangsspannung nicht direkt beim Abfall die

14:18.290 --> 14:20.750
Idealkennlinien hat, sondern dass die Idealkennlinien viel früher

14:20.750 --> 14:20.950
kommen.

14:21.090 --> 14:25.990
Das heißt, der Spannungsanstieg und der Spannungsabfall, die sind

14:25.990 --> 14:26.930
zeitlich verzögert.

14:28.350 --> 14:31.330
Hängt damit zusammen, dass man natürlich keinen idealen Bauteil hat.

14:31.410 --> 14:34.970
Man hat irgendwelche Kapazitäten, irgendwelche Widerstände und in der

14:34.970 --> 14:38.110
Elektrotechnik ist halt so, dass auch nicht alles ideal ist.

14:39.110 --> 14:43.070
Und dann kommt hier so eine zeitliche Verzögerung rein, bei unserem

14:43.070 --> 14:43.830
Ausgabessignal.

14:45.090 --> 14:46.910
Jetzt können wir natürlich Schaltungen, die wir entwerfen wollen,

14:46.990 --> 14:48.050
können wir genauso modellieren.

14:48.850 --> 14:51.610
Können uns hier die Funktionen raussuchen und das Schaltverhalten und

14:51.610 --> 14:54.170
so, aber es macht die ganze Sache sehr, sehr viel komplizierter, als

14:54.170 --> 14:55.110
es eigentlich sein müsste.

14:55.970 --> 14:57.210
Deswegen sparen wir uns das.

14:57.370 --> 15:02.550
Wir wollen das nicht so kompliziert haben, sondern wir versuchen,

15:03.790 --> 15:05.850
diese Effekte annähernd zu beschreiben.

15:06.750 --> 15:08.970
Es gibt natürlich einfache bis komplexe Modelle.

15:09.270 --> 15:11.570
Das einfache Modell, was wir jetzt betrachten werden, ist das

15:11.570 --> 15:12.270
Todzeitmodell.

15:13.010 --> 15:15.390
Und was wir hier machen werden, ist, wir werden lediglich die durch

15:15.390 --> 15:17.970
die Gatter und Leitungen entstehenden Verzögerungen berücksichtigen.

15:18.090 --> 15:21.570
Das heißt, wir schauen uns mal an, wie viel Verzögerung entsteht, wenn

15:21.570 --> 15:23.950
ich eine Eingabevariable an einen Gatter schicke und das, was

15:23.950 --> 15:25.390
rauskommt, wie viel Verzögerung ist da.

15:26.010 --> 15:27.170
Das ist jetzt für uns interessant.

15:28.010 --> 15:30.650
Das heißt, Thema Todzeitmodell.

15:34.140 --> 15:37.960
Wir modellieren im Todzeitmodell ein Verknüpfungsglied oder ein Gatter

15:37.960 --> 15:40.160
durch zwei Elemente.

15:40.380 --> 15:43.260
Einmal durch ein ideales Verknüpfungsglied ohne Verzögerungsanteil.

15:43.460 --> 15:43.940
Das haben wir hier.

15:48.450 --> 15:51.610
Das ist unser ideales Verknüpfungsglied.

15:51.710 --> 15:55.330
Das könnte jetzt ein und, oder Negation und so weiter sein.

15:56.310 --> 15:58.010
Und wir haben ein Todzeitglied.

15:59.190 --> 16:06.090
Dieses Todzeitglied ist ein reines Verzögerungsglied und verzögert die

16:06.090 --> 16:11.570
Ausführung dieser implementierten Funktion um einen bestimmten

16:11.570 --> 16:12.270
Zeitwert Tau.

16:17.420 --> 16:21.260
Wie gesagt, diese Verzögerung kann einmal durch die Schaltzeit des

16:21.260 --> 16:24.520
Gatters entstehen und einmal durch die Leitungsverzögerungen.

16:24.620 --> 16:26.940
Wenn man größere Leitungen hat, ist die Kapazität ein bisschen größer.

16:27.040 --> 16:31.960
Es gibt kapazitative Effekte beispielsweise und hier kann es dann auch

16:31.960 --> 16:32.700
zu Verzögerungen kommen.

16:33.120 --> 16:35.340
Das alles soll hier mit reingespielt werden in dieses Tau.

16:35.440 --> 16:38.120
Das heißt, wir idealisieren auch diesen Ablauf und sagen, einmal gibt

16:38.120 --> 16:43.120
es ein ideales Gatter und danach haben wir ein Verzögerungsglied, das

16:43.120 --> 16:44.320
uns einfach eine Verzögerung gibt.

16:47.540 --> 16:51.860
So, zeitliches Verhalten, binäre Größe.

16:53.800 --> 16:55.060
Was heißt das jetzt für uns?

16:55.120 --> 16:58.780
Wir haben einmal eine Eingabevariable A zu einem bestimmten Zeitpunkt

16:58.780 --> 16:59.000
T.

17:00.460 --> 17:05.100
Wir haben hier das Verzögerungsglied Tau und was jetzt rauskommt auf

17:05.100 --> 17:08.240
der anderen Seite ist mein BT und mein BT entspricht nichts anderem

17:08.240 --> 17:13.240
als mein A zum Zeitpunkt T minus Tau.

17:14.840 --> 17:17.740
Das heißt, hier gibt es keine Funktion, es gibt keine Veränderung der

17:17.740 --> 17:20.340
Eingabenvariable, denn die einzige Veränderung ist einfach nur diese

17:20.340 --> 17:21.780
zeitliche Veränderung.

17:25.950 --> 17:30.270
So kann man jetzt dieses Verzögerungsglied verstehen und formalisieren

17:30.270 --> 17:32.510
und wir werden jetzt gleich nochmal ein paar Sachen uns anschauen.

17:32.670 --> 17:34.290
Dafür werden wir das auch gleich nochmal brauchen.

17:35.090 --> 17:40.470
Aber zunächst einmal wieder der Inverter.

17:40.890 --> 17:43.990
Ich habe jetzt hier, wenn ich einen Signalverlauf betrachte von X,

17:44.890 --> 17:52.270
habe ich hier meine 1, die logische und hier meine 0.

17:54.410 --> 18:01.410
Und jetzt wird natürlich, wenn ich hier Y Strich hätte, nehmen wir

18:01.410 --> 18:03.430
eine andere Farbe

18:07.870 --> 18:10.090
für das hier.

18:11.350 --> 18:13.850
Rot auf Grün ist ganz gut lesbar, glaube ich.

18:14.390 --> 18:17.650
Nehmen wir das hier mal Y Strich und ich habe hier meine

18:17.650 --> 18:22.570
Eingabevariable X, einmal hier 1, einmal 0, einmal 1.

18:23.190 --> 18:27.350
Dann würde ich, wenn ich jetzt Y Strich abgreife, hätte ich natürlich

18:27.350 --> 18:29.530
genau das Inverse.

18:31.310 --> 18:33.070
Es handelt sich hier um ein ideales Glied.

18:35.940 --> 18:38.900
Wenn ich jetzt aber Y betrachte, also nach meinem Verzögerungsglied,

18:38.960 --> 18:41.560
dann habe ich einfach diese rote Kennlinie,

18:46.300 --> 18:51.740
die sich einfach nur um diesen Zeitfaktor Tau verschiebt, nach rechts.

18:53.300 --> 18:58.420
Und mein Ausgabesignal sieht dann genauso aus wie hier das rote, nur

18:58.420 --> 19:03.020
ein bisschen um den Faktor Tau nach rechts verschoben, die Translation

19:03.020 --> 19:03.860
Tau nach rechts verschoben.

19:04.840 --> 19:07.440
Das ist im Grunde jetzt unser Modell, mit dem wollen wir jetzt

19:07.440 --> 19:11.160
arbeiten oder mit dem wollen wir jetzt unsere Leitungsverzögerungen

19:11.160 --> 19:12.580
einfach modellieren.

19:12.700 --> 19:13.600
Funktioniert ganz gut.

19:13.880 --> 19:16.200
Wir werden jetzt ein paar Regeln noch mal anschauen, wie man hier

19:16.200 --> 19:17.640
vorgehen kann oder was man machen kann.

19:18.340 --> 19:20.520
Dafür gibt es zum Beispiel eine Anwendung eines Inverters.

19:21.000 --> 19:22.360
Das wäre jetzt nur eine Beispielschaltung.

19:22.620 --> 19:25.200
Die Funktion selber macht was genau?

19:27.060 --> 19:28.420
Wir haben ein Eingabesignal E.

19:29.740 --> 19:33.460
Das wird mit oder verknüpft mit der Invertierung des Eingabesignals.

19:34.700 --> 19:39.020
Und wir wissen ja, E oder E nicht ist immer 1.

19:40.380 --> 19:42.480
Das heißt, hier bei A müsste immer 1 auskommen.

19:44.780 --> 19:45.220
Idealerweise.

19:46.960 --> 19:48.680
Klar, natürlich macht das jetzt nicht wirklich viel Sinn.

19:48.780 --> 19:50.340
Man könnte auch direkt die 1 auf A schalten.

19:50.920 --> 19:55.800
Aber hier zum Verdeutlichen der Problematik wollen wir jetzt diese

19:55.800 --> 19:56.980
Schaltung einfach mal betrachten.

19:58.520 --> 20:01.580
Wir gehen jetzt davon aus, dass jedes dieser logischen Gatter eine

20:01.580 --> 20:03.420
Verzögerungszeit von einer Nanosekunde hat.

20:04.640 --> 20:07.940
Und wir sehen hier schon, dass wenn ich jetzt die Schaltung betrachte,

20:08.640 --> 20:11.520
bekomme ich hier eine zusätzliche Verzögerung von einer Nanosekunde

20:11.520 --> 20:12.520
wegen meines Inverters.

20:13.620 --> 20:17.060
Das heißt, hier könnte es sein, dass es irgendwann kracht.

20:18.200 --> 20:22.360
Meine Erwartungshaltung ist, egal was ich bei E mache, A müsste immer

20:22.360 --> 20:22.920
1 sein.

20:24.000 --> 20:25.880
Jetzt schauen wir uns das Beispiel noch mal an.

20:26.100 --> 20:29.160
Wir haben hier unsere Modellierung des Todzeitglieds.

20:29.220 --> 20:31.780
Das heißt, wir haben hier eine Verzögerung von einer Nanosekunde,

20:31.860 --> 20:34.120
jeweils nach den einzelnen Gattern.

20:34.800 --> 20:36.840
Und wir schauen uns den zeitlichen Verlauf an.

20:37.960 --> 20:42.240
Jetzt wollen wir bei Zeitindex 4 von E 0 auf 1 wechseln und bei

20:42.240 --> 20:45.360
Zeitindex 9 wollen wir von 1 auf 0 wechseln.

20:45.920 --> 20:48.580
Wir trachten uns für den ersten Abschnitt E gleich 0.

20:50.140 --> 20:52.160
Also wir gehen davon aus, dass es vorher auch schon 0 war.

20:52.300 --> 20:56.600
Das heißt, an dieser Stelle nach der Negation wäre es natürlich auch

20:56.600 --> 21:00.040
schon längere Zeit 1, würde die 1 schon länger stabil anliegen.

21:02.560 --> 21:06.140
Das heißt, wenn ich jetzt, nennen wir das mal,

21:10.880 --> 21:13.100
wie nennen wir das, nennen wir E Strich,

21:16.510 --> 21:17.770
dann wäre das hier E Strich.

21:21.500 --> 21:24.280
Das heißt, ich habe hier die Negation von 0 ist natürlich 1, klar.

21:25.020 --> 21:29.840
Ich könnte hier die 1 einzeichnen für E, jetzt ist es bei A drin.

21:31.160 --> 21:32.200
Okay, macht nichts.

21:34.540 --> 21:36.060
Ich zeichne das einfach nochmal neu.

21:41.610 --> 21:47.130
Das ist für A, das heißt, ich habe jetzt hier E Strich, wäre die ganze

21:47.130 --> 21:47.890
Zeit bei 1.

21:53.060 --> 21:56.060
Ich habe dann hier einen Wechsel von 0 auf 1 bei E.

21:56.840 --> 22:01.580
Der Wechsel von 0 auf 1 wirkt sich dann hier direkt aus.

22:01.840 --> 22:05.200
Das heißt, ich hätte hier nach meiner Negation hätte ich direkt eine 0

22:05.200 --> 22:05.600
stehen.

22:06.120 --> 22:09.320
Diese 0, die hier entsteht, die wird allerdings erst nach dem

22:09.320 --> 22:12.840
Verzögerungsteil, nach diesem Verzögerungsglied hier ankommen.

22:13.040 --> 22:14.940
Also ich habe eine Verzögerung von eine Sekunde.

22:15.500 --> 22:21.640
Das heißt, für E kann ich dann nach einer Sekunde die 0 weiterleiten.

22:23.420 --> 22:24.040
Für E Strich.

22:26.720 --> 22:29.840
Das heißt, im ersten Moment habe ich hier natürlich auch eine 1,1

22:29.840 --> 22:31.920
stehen und wechsle dann zu einer 1,0.

22:32.440 --> 22:34.160
Was heißt das hier für meinen Ausgang?

22:34.300 --> 22:37.140
Ich habe hier die Verknüpfung 0,1 mit oder.

22:37.700 --> 22:41.140
Das heißt, hier direkt kommt eine 1 an.

22:41.880 --> 22:43.740
1 oder 1 kommt eine 1 an.

22:44.000 --> 22:46.220
1 oder 0 kommt auch eine 1 an.

22:46.300 --> 22:50.000
Und diese 1 wird verzögert durch dieses Verzögerungsglied und kommt

22:50.000 --> 22:51.540
eine Nanosekunde später natürlich an.

22:51.620 --> 22:52.360
Ändert sich aber erst mal nichts.

22:52.460 --> 22:53.960
Das heißt, es ist erst mal eine konstante 1.

22:55.020 --> 23:00.860
So, wir sind jetzt bei E gleich 1 und E Strich gleich 0.

23:01.160 --> 23:01.400
Also hier.

23:03.700 --> 23:06.200
So, dann geht es erst mal ein bisschen weiter bis hierhin.

23:06.420 --> 23:07.560
Da ist nämlich der nächste Wechsel.

23:10.420 --> 23:13.180
Jetzt wechselt E von 1 auf 0.

23:15.140 --> 23:19.180
Das heißt, zunächst mal kommt die 0 hier an, kommt dann eine

23:19.180 --> 23:21.080
Nanosekunde später bei E Strich an.

23:21.600 --> 23:26.540
Das heißt, ich gehe hier einen Zeitabschnitt weiter und bleib dann

23:26.540 --> 23:27.180
wieder bei der 0.

23:37.290 --> 23:39.730
Wir haben hier allerdings 1 oder 0 gehabt.

23:39.870 --> 23:40.990
Das heißt, hier kam eine 1 an.

23:41.330 --> 23:47.230
Jetzt habe ich aber kurzfristig, da jetzt die 0 hier vorher anlag und

23:47.230 --> 23:51.010
die Negation der 0 die 1 ist, die 1 aber erst eine Nanosekunde später

23:51.010 --> 23:53.990
hier ankommt, habe ich hier zunächst mal eine Konstellation, wo ich 0

23:53.990 --> 23:54.490
,0 habe.

23:55.710 --> 24:00.430
Und 0,0 verodert würde hier natürlich nicht 1 geben, sondern 0.

24:00.710 --> 24:03.710
Das heißt, hier kommt eine 0 an und eine Nanosekunde später kommt

24:03.710 --> 24:05.390
diese 0 dann tatsächlich auch auf den Ausgang.

24:08.700 --> 24:09.120
Fokuswechsel.

24:10.860 --> 24:14.880
Also hier im ersten Moment bleibt es noch auf 1, wechselt dann aber

24:14.880 --> 24:15.900
kurzfristig auf die 0.

24:18.540 --> 24:21.200
Sobald sich hier aber die Lage wieder stabilisiert hat, das heißt die

24:21.200 --> 24:25.600
Negation dieser 0 auf E Strich landet, also eine Nanosekunde später,

24:25.660 --> 24:26.900
habe ich hier wieder 0,1 stehen.

24:27.100 --> 24:31.900
0,1 verodert gibt eine 1, eine Nanosekunde später kommt die 1 hier

24:31.900 --> 24:32.500
hinten wieder an.

24:32.940 --> 24:34.820
Das heißt, hier habe ich dann wieder einen Wechsel nach rechts.

24:37.180 --> 24:41.200
Hier waren wir die ganze Zeit bei... müsste so aussehen.

24:42.940 --> 24:43.640
Fragen dazu?

24:45.220 --> 24:46.000
Was haben wir jetzt?

24:46.020 --> 24:52.720
Wir haben jetzt hier ein kleines Problem, weil hier ist ja mein A,0

24:52.720 --> 24:59.200
und wir haben ja vorhin gesehen, rein logisch betrachtet unabhängig

24:59.200 --> 25:02.140
von meiner Eingabevariable müsste hinten immer eine 1 rauskommen.

25:02.220 --> 25:06.460
Aber ich habe ein kleines Segment, wo tatsächlich die Eingabe auf 0

25:06.460 --> 25:06.940
wechselt.

25:11.040 --> 25:13.500
Und das hier werden wir gleich noch mal ein bisschen näher betrachten,

25:13.900 --> 25:14.920
nennen wir dann einen Hazardfehler.

25:16.560 --> 25:19.740
Also die Probleme, die wir bei einem idealen Schaltnetz nicht haben,

25:20.760 --> 25:26.280
nämlich dass sich das Ausgangssignal nicht ändert, wenn alte und neue

25:26.280 --> 25:29.860
Belegungen denselben logischen Verknüpfungswert liefern, haben wir

25:29.860 --> 25:31.100
hier beim realen Schaltnetz nicht.

25:31.300 --> 25:35.100
Änderungen können auf verschiedenen Wegen zum Ziel kommen und diese

25:35.100 --> 25:37.520
verschiedenen Wege können verschiedene Verzögerungen haben und dadurch

25:37.520 --> 25:39.820
können sie auch das Schaltverhalten des Netzes verändern.

25:40.500 --> 25:43.680
Das heißt, etwas, was logischerweise nicht auftreten sollte, kann dann

25:43.680 --> 25:44.560
tatsächlich passieren.

25:45.200 --> 25:48.560
Und das sind natürlich Sachen, die man nicht haben will, wenn man eine

25:48.560 --> 25:53.160
Airbag -Schaltung hätte mit so etwas und da taucht kurzzeitig eine 1

25:53.160 --> 25:54.560
auf, dann geht der Airbag los beispielsweise.

25:56.140 --> 25:57.060
Nicht so optimal.

25:58.780 --> 26:00.280
Wie definieren wir einen Hazardfehler?

26:01.200 --> 26:05.160
Wir sagen, wenn mehrfache Änderungen des Ausgangssignals auftreten,

26:05.260 --> 26:07.140
beziehungsweise den Hazardfehler selber werden wir nachher noch mal

26:07.140 --> 26:08.740
definieren, aber vielleicht ein bisschen vorgegriffen.

26:09.260 --> 26:15.060
Hazardfehler heißt, dass wenn ich eine Änderung habe, meine Eingabe-

26:15.060 --> 26:17.280
und keinen monotonen Ausgang habe.

26:17.440 --> 26:19.260
Das heißt, wenn sich zwischendrin nochmal etwas ändert.

26:19.560 --> 26:21.340
Aber mehr zur Definition vielleicht ein bisschen später.

26:27.620 --> 26:28.140
Beispiel.

26:28.380 --> 26:32.740
Wir haben jetzt eine Funktion, also Beispiel Todzeitmodellierung.

26:33.080 --> 26:37.400
Wir haben jetzt eine Funktion A, die heißt E1 nicht, E2 verodert mit

26:37.400 --> 26:38.440
E1 und E3.

26:38.860 --> 26:39.580
Das sehen wir jetzt auch hier.

26:42.080 --> 26:44.000
E1 nicht und E2.

26:44.480 --> 26:46.900
Das ist E1 nicht und E2, die beiden hier.

26:47.600 --> 26:48.980
Und ich habe E1, E3.

26:49.100 --> 26:50.180
E1, E3 ist das hier.

26:50.320 --> 26:53.440
Also in meinem KV-Diagramm würde diese Funktion so aussehen.

26:53.940 --> 26:56.720
Wenn ich es von der Implementierung her betrachte, habe ich einmal E1

26:56.720 --> 27:03.020
negiert, verundet mit E2 und verodert mit E1 und E3.

27:03.140 --> 27:04.620
Und E1 und E3 habe ich hier.

27:04.820 --> 27:08.980
E1 und E3 und verodert natürlich als Funktion.

27:10.680 --> 27:13.600
Das Interessante in diesem Schaltenetz jetzt hier ist, dass wir

27:15.300 --> 27:19.060
strukturell sagen, wir nehmen hier jetzt mal an, dass dieses und

27:19.060 --> 27:25.180
-Gatter, das ist eine Verzögerung von Dreitau hat und die restlichen

27:25.180 --> 27:28.480
Bauteile eine Verzögerung von einem Tau haben.

27:29.640 --> 27:33.120
Das heißt, nicht jedes und-Bauteil muss die gleiche Verzögerung haben.

27:33.260 --> 27:38.280
Das kann mit der qualitativen Herstellung, Herstellungsprozess

27:38.280 --> 27:39.260
irgendwie zu tun haben.

27:39.340 --> 27:41.100
Es kann sein, dass man teurere Elemente irgendwo nimmt oder

27:41.100 --> 27:41.860
günstigere.

27:42.320 --> 27:43.540
Und die haben halt ein verschiedenes Verhalten.

27:43.880 --> 27:46.600
Das heißt, obwohl ich jetzt hier zwei und-Bauteile habe, zum Beispiel

27:46.600 --> 27:49.740
hat dieses ein Tau und dieses in dieser Modellierung Dreitau.

27:53.940 --> 27:56.860
Wir wollen jetzt verschiedene Eingabewechsel in dieser Funktion

27:56.860 --> 27:57.420
betrachten.

27:58.200 --> 28:04.500
Zum einen seien E2 und E3 jeweils konstant auf 1.

28:04.700 --> 28:08.460
Das heißt, wir betrachten nur einen Eingabewechsel von E1 und im

28:08.460 --> 28:12.340
ersten Fall soll E1 von 0 auf 1 wechseln und im zweiten Fall soll E1

28:12.340 --> 28:13.360
von 1 auf 0 wechseln.

28:15.300 --> 28:17.980
Und dieses Verhalten schauen wir uns ein bisschen detaillierter jetzt

28:17.980 --> 28:18.240
an.

28:19.380 --> 28:26.720
Zunächst mal im KV-Diagramm habe ich den Wechsel von 0, 1, also von E1

28:26.720 --> 28:30.100
von 0 auf 1 und E2, E3 konstant auf 1.

28:30.340 --> 28:33.660
Finde ich erst mal heraus, okay, was ist meine Startbelegung?

28:33.800 --> 28:35.340
Also wo ist mein Startfunktionswert?

28:36.300 --> 28:40.640
Und anhand des KV-Diagramms kann ich jetzt hier ermitteln, dass das

28:40.640 --> 28:41.700
hier mein Anfangswert ist.

28:41.780 --> 28:44.820
Also wenn bei der Belegung 1, 1, 0 hätte ich hier die Ausgabe 1, das

28:44.820 --> 28:45.460
ist hier der rote Ring.

28:47.220 --> 28:51.920
Und bei der Eingabebelegung 1, 1, 1, also wenn E1 von 0 auf 1

28:51.920 --> 28:55.640
wechselt, habe ich diese zweite Belegung, das ist hier in diesem Feld

28:55.640 --> 28:57.480
und hier ist meine Ausgabe auch 1.

28:57.860 --> 29:02.920
Das heißt, ich betrachte den Wechsel von diesem Feld auf dieses Feld

29:02.920 --> 29:05.180
und ich sehe, dass beide Ausgaben 1 sind.

29:05.880 --> 29:11.660
Das heißt, bei diesem Eingabewechsel müsste mein Ergebnis oder mein

29:11.660 --> 29:14.720
Ergebnis dürfte sich nicht ändern, es müsste konstant auf 1 bleiben.

29:18.250 --> 29:21.390
Allerdings können wir tatsächlich dieses Verhalten nicht garantieren.

29:22.830 --> 29:25.190
Warum wir das nicht garantieren können, betrachten wir uns jetzt

29:25.190 --> 29:25.570
gleich nochmal.

29:26.310 --> 29:31.770
Hier jetzt nochmal unsere Schaltung und wir betrachten jetzt die

29:31.770 --> 29:33.810
Eingabesignale im Zeitdiagramm.

29:33.910 --> 29:39.770
Das heißt, E2 und E3 konstant auf 1 und E1 wechselt von 0 auf 1 zum

29:39.770 --> 29:40.590
Zeitpunkt T0.

29:43.370 --> 29:48.310
Dann können wir uns zuerst X1 betrachten, also hier nach der Negation

29:48.310 --> 29:51.570
von E1 und nach dem Todzeitglied.

29:53.150 --> 29:57.550
Wir gehen davon aus, dass jedes dieser eine Striche einen Zeitabstand

29:57.550 --> 30:01.890
von Tau hat.

30:05.910 --> 30:08.130
X1 ist ja die Negation von E1.

30:09.110 --> 30:11.250
Das heißt, ich komme hier von der 0 auf die 1.

30:11.350 --> 30:14.050
Das heißt, X1 müsste bei 1 anfangen und müsste dann auf die 0

30:14.050 --> 30:14.550
wechseln.

30:15.070 --> 30:16.690
Allerdings mit einer Verzögerung von Tau.

30:16.810 --> 30:20.560
Das bedeutet, anstatt dass ich jetzt hier bei T0 wechsle, wechsle ich

30:20.560 --> 30:21.860
bei T0 plus Tau.

30:24.660 --> 30:25.220
Offensichtlich.

30:26.580 --> 30:27.680
Recht einfach, glaube ich.

30:27.780 --> 30:29.120
Ich glaube, da gibt es keine Fragen dazu.

30:30.300 --> 30:32.360
Dann betrachten wir als nächstes X2.

30:33.820 --> 30:40.880
X2 ist jetzt hier die Unverknüpfung von X1 und E2, zusätzlich mit

30:40.880 --> 30:42.100
einer Verzögerung von Tau.

30:42.640 --> 30:45.880
Das heißt, zunächst einmal betrachten wir die Unverknüpfung von X1 und

30:45.880 --> 30:46.300
E2.

30:47.500 --> 30:49.020
E2 ist konstant auf 1.

30:49.980 --> 30:54.320
Verundet mit X1 heißt es, dass wir bis zu diesem Zeitpunkt bei 1 sind

30:54.320 --> 30:56.400
und ab da müssen wir dann auf die 0 wechseln.

30:57.600 --> 31:00.720
Allerdings nochmal mit einer zusätzlichen Verzögerung von Tau, wie

31:00.720 --> 31:02.000
jetzt hier nach diesem und da ist.

31:02.100 --> 31:06.560
Das heißt, der Wechsel findet nicht bei T0 statt, nicht bei T0 plus

31:06.560 --> 31:09.280
Tau, sondern der Wechsel findet bei T0 plus Tau statt.

31:09.860 --> 31:11.060
Und hier wechseln wir dann auf die 0.

31:15.070 --> 31:18.310
Als nächstes betrachten wir uns den Signalverlauf von X3.

31:19.470 --> 31:22.610
X3 ist die Verundung von E1 und E3.

31:22.930 --> 31:25.410
Wir wissen, E3 ist eine Konstante 1.

31:25.570 --> 31:29.390
Das heißt, im Grunde habe ich den gleichen Signalverlauf wie E1,

31:30.010 --> 31:31.870
allerdings mit einer Verzögerung von 3 Tau.

31:32.310 --> 31:38.730
Das heißt, ich komme hier bei 0 an, zum Zeitpunkt T0, warte 3 Tau

31:38.730 --> 31:41.430
-Zeitabschnitte und wechsle dann auf die 1.

31:45.420 --> 31:48.060
So, dann schauen wir uns unsere Ausgabe an.

31:48.140 --> 31:52.540
Unsere Ausgabe A ist die Veroderung von X2 und X3.

31:52.940 --> 31:55.940
Das heißt, ich betrachte diesen und diesen Signalverlauf und ich muss

31:55.940 --> 31:56.800
beides oder nehmen.

31:58.000 --> 32:01.040
Das heißt, überall wo zumindest eine dieser Variablen in der 1 ist,

32:01.040 --> 32:01.980
bin ich direkt bei der 1.

32:02.300 --> 32:04.000
Wenn beide 0 sind, bin ich auf 0.

32:04.760 --> 32:07.320
Das heißt, wenn ich jetzt hier den Signalverlauf betrachte, bin ich

32:07.320 --> 32:11.620
bei T0 plus 2 Tau, bin ich definitiv bei 1.

32:12.440 --> 32:18.500
Und hier zwischen T0 plus 2 Tau und T0 plus 3 Tau habe ich tatsächlich

32:18.500 --> 32:21.300
einen Abschnitt, wo X2 und X3 0 sind.

32:22.080 --> 32:30.120
Das heißt, für meinen Signalverlauf bin ich bei 1, 1, 1 und komme dann

32:30.120 --> 32:34.400
hier auf die 0, natürlich mit einer Verzögerung von Tau und wechselte

32:34.400 --> 32:35.960
dann später hier wieder auf die 1.

32:36.180 --> 32:38.940
Also T0 plus 3 Tau müsste ich wieder auf die 1.

32:39.280 --> 32:42.820
Das zusätzliche Tau hier am Schluss sorgt dann dafür, dass es bei 4

32:42.820 --> 32:43.240
Tau ist.

32:44.640 --> 32:52.800
Und jetzt sehen wir schon, ein Eingabewechsel und zweimal wechselnde

32:52.800 --> 32:53.280
Ausgabe.

32:54.140 --> 32:56.740
Ich habe einmal von 1 auf 0 gewechselt und einmal von 0 auf 1.

33:00.400 --> 33:01.160
Mit Sound.

33:02.860 --> 33:04.320
Das hier ist unser Hazardfehler.

33:04.820 --> 33:10.860
Unser Tritt jetzt hier einen Zeitabschnitt von Tau lang tritt dieser

33:10.860 --> 33:11.520
Fehler auf.

33:13.100 --> 33:17.580
Also Ausgabe müsste konstant auf 1 sein und tatsächlich ist er hier

33:17.580 --> 33:18.580
kurzfristig auf 0.

33:21.620 --> 33:24.720
Betrachten wir noch mal den zweiten Eingabewechsel.

33:24.920 --> 33:28.300
Wir haben gesagt, die zweite Aufgabe wäre, dass E1 von 1 auf 0

33:30.320 --> 33:30.760
wechselt.

33:30.760 --> 33:32.160
Hier gehen wir ein bisschen schneller durch.

33:32.320 --> 33:37.240
Wir haben x1 ist die Negation von E1, das heißt ich habe hier 1 0, bin

33:37.240 --> 33:39.640
hier bei 0 1, allerdings mit einer Verzögerung von Tau.

33:40.980 --> 33:46.840
Ich habe x2, hier ist x1 und E2 noch mal mit Tau verzögert.

33:47.440 --> 33:53.140
x1 und E2, was die ganze Zeit 1 ist, ist quasi x1, allerdings mit Tau

33:53.140 --> 33:53.640
verzögert.

33:53.760 --> 33:56.880
Das heißt ich kann hier Tau verzögern und schreibe dann hier den

33:56.880 --> 33:58.120
Signalverlauf von x1 ab.

33:59.280 --> 34:02.240
x3 ist E1 und E3.

34:02.400 --> 34:05.900
E3 ist die ganze Zeit 1, das heißt der Signalverlauf von E1 mit 3 Tau

34:05.900 --> 34:06.540
verzögert.

34:06.740 --> 34:10.500
Ich schaue mal E1 an, ich komme bei 1 und wechsle auf 0 nach 3 Tau.

34:11.480 --> 34:15.740
So und dann habe ich hier wieder das oder mit x2 und x3, das heißt

34:15.740 --> 34:20.280
hier ist überall x3 1, in diesem Bereich ist x2 1, das heißt hier

34:20.280 --> 34:22.460
meine Ausgabe ist konstant auf 1 durchgehend.

34:24.220 --> 34:27.120
Und hier sehe ich interessanterweise, hier habe ich keinen

34:27.120 --> 34:34.300
Hazardfehler, also hier habe ich keinen Hubbel, der kurzfristig von 1

34:34.300 --> 34:35.920
auf 0 wechselt.

34:37.140 --> 34:41.680
Obwohl es die gleiche variablen Belegung ist, nur einmal in die eine

34:41.680 --> 34:43.020
Richtung und einmal in die andere Richtung.

34:45.160 --> 34:51.180
Also wir halten fest, das Ergebnis beim Wechsel von 0 auf 1 liefert

34:51.180 --> 34:56.160
uns das Ausgangssignal nicht ständig den korrekten Funktionswert.

34:56.340 --> 35:00.280
Wir haben hier einen Hazardfehler festgestellt und beim Wechsel von 1

35:00.280 --> 35:03.520
auf 0 gibt es keine Probleme.

35:09.430 --> 35:12.350
So jetzt ist natürlich, wenn ich jetzt jede Schaltung so betrachten

35:12.350 --> 35:16.390
müsste, immer die Signalverläufe hinschreiben müsste, immer überlegen

35:16.390 --> 35:19.930
müsste, wie sieht das jetzt aus, wo ist mein x1, x2, x3 und so weiter.

35:20.110 --> 35:21.190
Das wird ein bisschen komplizierter.

35:21.610 --> 35:24.070
Das heißt, wir versuchen jetzt uns die Sache ein bisschen einfacher zu

35:24.070 --> 35:24.230
machen.

35:26.490 --> 35:30.970
Und eine Methode hier ist, dass wir alle Verzögerungszeiten sukzessive

35:30.970 --> 35:34.970
zum Eingang des Schaltnetzes verschieben und alles was wir nach zum

35:34.970 --> 35:38.650
Eingang verschoben haben und wir werden jetzt hier generell so

35:38.650 --> 35:42.150
verfahren, dass unser Schaltnetz von links nach rechts verläuft, das

35:42.150 --> 35:45.290
heißt unsere Eingabevariablen sind links und unsere Ausgabevariable

35:45.290 --> 35:46.170
ist auf der rechten Seite.

35:46.730 --> 35:49.570
Das heißt, wir verschieben die Verzögerungsteile von rechts nach links

35:49.570 --> 35:52.390
und werden auf der linken Seite all ankommenden Verzögerungsteile

35:52.390 --> 35:52.910
aufaddieren.

35:54.170 --> 35:56.850
Dadurch erreichen wir, dass wir das Schaltnetz in zwei Teile

35:56.850 --> 35:57.390
aufteilen.

35:57.850 --> 36:02.130
Einmal in einen reinen Verzögerungsteil auf der linken Seite und einen

36:02.130 --> 36:05.050
reinen Verknüpfungsteil, der natürlich idealerweise keine Verzögerung

36:05.050 --> 36:06.050
hat, auf der rechten Seite.

36:09.030 --> 36:11.950
Dafür müssen wir uns allerdings noch ein paar Sachen überlegen.

36:12.350 --> 36:15.790
Wenn wir jetzt alles nach links verschieben wollen, brauchen wir

36:15.790 --> 36:18.330
bestimmte Eigenschaften unseres Drottzeitenmodells oder dieser

36:20.630 --> 36:21.110
Drottzeiten.

36:21.470 --> 36:24.090
Das ist zum einen die Addierbarkeit, die wir benötigen.

36:33.480 --> 36:38.200
Das heißt, wir haben beispielsweise ein Schaltglied.

36:40.920 --> 36:42.520
Nein, wir haben kein Schaltglied, wir haben nur die

36:42.520 --> 36:43.620
Verzögerungszeiten.

36:43.620 --> 36:46.060
Wir haben zwei Verzögerungselemente hintereinander.

36:47.700 --> 36:50.460
Einmal sei das Tau1, einmal sei es Tau2.

36:54.090 --> 36:58.610
Und wir haben hier die Eingabevariable A zum Zeitpunkt von T und wir

36:58.610 --> 37:03.250
haben die Ausgabevariable C zum Zeitpunkt T.

37:04.290 --> 37:07.790
Und zwischendrin, das hier nennen wir dann einfach mal B von T.

37:14.410 --> 37:20.450
Jetzt wissen wir ja, dass der Signalverlauf von B um den Faktor Tau1

37:20.450 --> 37:24.810
verzögert wird.

37:25.030 --> 37:32.650
Das heißt, wir wissen, B zum Zeitpunkt T ist nichts anderes als A zum

37:32.650 --> 37:36.230
Zeitpunkt T minus Tau1.

37:42.830 --> 37:51.550
Und wir wissen, dass C nichts anderes ist als B zum Zeitpunkt T minus

37:51.550 --> 37:52.310
Tau2.

37:57.040 --> 37:59.480
Das können wir jetzt allerdings einsetzen von vorher.

37:59.600 --> 38:03.380
Wir wissen ja hier, können die zwei Sachen hier einsetzen.

38:03.520 --> 38:08.940
Das heißt, ich möchte statt T, T minus Tau2 hier haben und wäre dann

38:08.940 --> 38:18.020
bei, mal hier weiter, also ich ersetze B durch A, komme dann auf A T

38:18.020 --> 38:23.140
minus Tau2 minus Tau1.

38:27.170 --> 38:30.810
Und wenn ich das nochmal umforme und ein bisschen neu sortiere, dann

38:30.810 --> 38:37.510
komme ich hier auf A von T minus Klammer auf Tau1 plus Tau2.

38:42.430 --> 38:46.070
Das heißt, wir können jetzt hier zeigen, dass wir tatsächlich die

38:46.070 --> 38:48.270
Verzögerungsteile aufaddieren können.

38:49.430 --> 38:53.090
Wenn ich jetzt das neue Schaltbild zeichnen würde, würde es so

38:53.090 --> 38:55.610
aussehen, dass ich ein Verzögerungsteil habe.

38:58.130 --> 39:01.190
Ich habe hier meine Eingabevariable A von T, ich habe hier meine

39:01.190 --> 39:09.730
Ausgabevariable C von T und ich habe hier Tau1 plus Tau2.

39:15.090 --> 39:16.030
Soweit klar?

39:18.570 --> 39:19.510
Jemand Fragen dazu?

39:23.290 --> 39:23.790
Wunderbar.

39:25.530 --> 39:29.790
So, dann ist die zweite Sache, die wir noch zeigen wollen, die

39:29.790 --> 39:31.030
Durchschiebbarkeit.

39:42.560 --> 39:46.920
Dafür betrachten wir uns ein Schaltglied als Funktion, sei das hier

39:46.920 --> 39:52.080
mal F, die Funktion F, und wir haben Eingabevariable A1 zum Zeitpunkt

39:52.080 --> 39:55.500
T und wir haben Eingabevariable A2 zum Zeitpunkt T.

39:59.630 --> 40:04.870
Das Zwischenstück, das nenne ich wieder B von T, damit wir besser

40:04.870 --> 40:06.170
beschreiben können, was wir hier machen.

40:06.290 --> 40:11.050
Und dann gibt es hier nochmal ein Totzeitglied mit Tau, Verzögerung,

40:11.490 --> 40:13.970
und ich habe hier als Ausgabe mein C von T.

40:16.910 --> 40:21.030
So, das heißt, B ist ja die Implementierung meiner Funktion, ich habe

40:21.030 --> 40:26.510
keine Verzögerungszeiten, das heißt, mein B von T entspricht meiner

40:26.510 --> 40:29.150
Funktion mit zwei Variablen.

40:30.190 --> 40:35.030
Das ist einmal A1 zum Zeitpunkt T und einmal A2 zum Zeitpunkt T.

40:38.730 --> 40:44.030
Und ich weiß, dass mein C, im Grunde mein B von T ist nur mit einer

40:44.030 --> 40:49.950
Verzögerung, das heißt, ich habe hier B von T minus Tau müsste es

40:49.950 --> 40:50.190
sein.

40:55.410 --> 41:01.070
So, ich kann wieder einsetzen, das heißt, T minus Tau eingesetzt,

41:01.290 --> 41:10.130
komme ich hier auf F von straightforward eigentlich A1 T minus Tau und

41:10.130 --> 41:13.370
A2 T minus Tau.

41:39.760 --> 41:40.740
Alles richtig?

41:42.640 --> 41:49.040
So, was heißt das jetzt, wenn wir uns jetzt die entstehende Schaltung

41:49.040 --> 41:49.580
anschauen?

41:49.700 --> 41:51.460
Habe ich ja hier meine Funktion F,

41:54.700 --> 42:04.000
ich habe hier meine Ausgabe C von T und ich habe hier ein

42:04.000 --> 42:10.540
Verzögerungsglied von Tau, hier auch, und hier meine ursprünglichen

42:10.540 --> 42:16.460
Eingabevariablen A1 von T und einmal A2 von T.

42:22.510 --> 42:24.930
An der Stelle, wenn ich jetzt hier abgreifen würde,

42:28.110 --> 42:37.310
hätte ich natürlich A1 von T minus Tau und an dieser Stelle hätte ich

42:37.310 --> 42:41.830
A2 von T minus Tau.

42:44.870 --> 42:46.710
Also das ist das, was jetzt hier steht quasi.

42:46.970 --> 42:50.730
Ich habe hier zwei Eingabevariablen A1 von T minus Tau ist hier, A2

42:50.730 --> 42:55.230
von T minus Tau ist da unten und das ist meine Funktion C von T.

42:55.930 --> 43:00.070
Und wir haben jetzt gesehen, wir können einfach, also was lernen wir

43:00.070 --> 43:00.350
daraus?

43:00.450 --> 43:03.810
Wir können ein Todzeitglied, das nach einer Funktion ist, können wir

43:03.810 --> 43:08.950
nach vorne ziehen, indem wir alle Eingabe Parameter, alle

43:08.950 --> 43:13.650
Eingabevariablen dieser Funktion mit diesem gleichen Todzeitglied

43:13.650 --> 43:15.630
belasten vielleicht.

43:17.690 --> 43:21.130
So, die zwei Sachen sollten zunächst mal reichen.

43:21.270 --> 43:24.210
Also wir haben die Addierbarkeit, dass wir zwei Todzeitglieder, die

43:24.210 --> 43:27.670
hintereinander auftreten, dass wir die aufaddieren können und wenn

43:27.670 --> 43:34.010
jetzt hier Schaltungen auftreten, dass wir die Todzeitglieder vor die

43:34.010 --> 43:36.670
Schaltung ziehen können, vor die Glieder ziehen können, also

43:36.670 --> 43:37.310
durchschieben können.

43:38.610 --> 43:44.670
Wir betrachten jetzt mal ein Beispiel, Beispiel 1 und würden jetzt

43:44.670 --> 43:48.050
hier, mal kurz schauen, ob ich hier noch schon reinkritzeln darf.

43:50.610 --> 43:51.230
Ich glaube ja.

43:52.370 --> 43:52.690
Okay,

43:56.600 --> 43:58.260
jetzt wollen wir das mal hier anwenden.

43:58.960 --> 44:02.260
Wir haben hier eine Beispiel- schaltung, die gleiche wie vorhin, mit

44:02.260 --> 44:05.920
unserem Tau jeweils nach den Gliedern und einmal drei Tau nach dem

44:05.920 --> 44:06.260
Unglied.

44:07.440 --> 44:09.760
Wir fangen jetzt hier auf der rechten Seite an und wollen jetzt immer

44:09.760 --> 44:11.060
die Todzeitglieder nach links schieben.

44:11.720 --> 44:16.720
Das heißt, ich habe jetzt hier ein Todzeitglied mit Tau, Verzögerung.

44:17.120 --> 44:21.000
Das würde ich jetzt einmal hier hinschieben und einmal dahin.

44:22.880 --> 44:29.080
Das heißt, aus diesem Tau macht aus diesem Tau ein Zweit-Tau, aus

44:29.080 --> 44:31.040
diesem Dreit-Tau wird ein Viert-Tau.

44:31.400 --> 44:32.500
Der kann mir nicht mehr folgen.

44:34.780 --> 44:35.600
Gut, weiter.

44:36.320 --> 44:39.880
Nächster Schritt, Zweit-Tau, einmal in die Richtung, einmal in die

44:39.880 --> 44:40.280
Richtung.

44:41.180 --> 44:46.300
Das heißt, aus diesem Tau, aus diesem Eins-Tau wird ein Dreit-Tau.

44:48.600 --> 44:51.080
Und hier habe ich erstmal nichts stehen, das heißt, hier ziehe ich

44:51.080 --> 44:53.500
dann einfach die 0 plus 2 Tau.

44:53.660 --> 44:57.400
Das heißt, hier komme ich dann bei 2 Tau.

44:58.420 --> 45:00.040
Und das hier kann ich dann streichen.

45:04.680 --> 45:08.220
Dann kann ich die Dreit-Tau vor die Negation ziehen.

45:08.820 --> 45:13.740
Das heißt, ich streiche die, habe hier ein Dreit-Tau.

45:15.900 --> 45:17.140
Hier bin ich ja schon am Anfang.

45:17.400 --> 45:20.080
Hier habe ich nochmal Viert-Tau, das kann ich vor das Umziehen.

45:20.400 --> 45:23.620
Da ich hier auch nichts mehr zum aufradieren habe, streiche ich das

45:23.620 --> 45:28.820
hier, mache einmal hier ein Viert-Tau und einmal hier ein Viert-Tau.

45:31.460 --> 45:33.440
Wenn wir jetzt das ein bisschen nach vorne zeichnen,

45:39.240 --> 45:42.520
dann sehen wir, dass jetzt auf der linken Seite unsere

45:42.520 --> 45:45.420
Verzögerungsglieder haben und auf der rechten Seite sollten wir jetzt

45:45.420 --> 45:47.640
nur noch ideale Schaltglieder haben.

45:51.870 --> 45:52.810
Jeder einverstanden damit?

45:58.630 --> 46:00.670
Eine kleine Unstimmigkeit gibt es ja schon noch.

46:03.150 --> 46:03.950
Wem fällt das auf?

46:04.090 --> 46:05.590
Was ist denn jetzt mit E1 eigentlich?

46:06.630 --> 46:09.950
Also jetzt habe ich ja hier eine Verzögerung von Dreit-Tau, da unten

46:09.950 --> 46:11.190
habe ich eine Verzögerung von Viert-Tau.

46:14.070 --> 46:15.550
Bisschen seltsam, oder?

46:16.310 --> 46:17.310
Oder ist alles okay?

46:17.450 --> 46:17.930
Kein Problem.

46:20.010 --> 46:20.510
Kein Problem.

46:21.010 --> 46:21.590
Okay, kein Problem.

46:21.650 --> 46:22.050
Machen wir weiter.

46:23.850 --> 46:25.310
Hier ein bisschen schöner gezeichnet.

46:25.690 --> 46:28.130
Dreit-Tau, Zweit-Tau, Viert-Tau, Viert-Tau.

46:28.450 --> 46:30.910
Ist gleich wie vorhin, nur dass wir hier den Verzögerungsteil in

46:30.910 --> 46:35.490
orange und einmal den Verknüpfungsteil nochmal in grün hervorgehoben.

46:37.730 --> 46:42.310
So, dann haben wir noch eine zusätzliche, worauf ich eigentlich hinaus

46:42.310 --> 46:44.690
wollte, Eigenschaft von Todzeiten.

46:44.950 --> 46:51.810
Und zwar, kann ich auch kurz zurückgehen hier, wir haben hier eine

46:51.810 --> 46:52.630
Mehrfachnutzung.

46:53.330 --> 46:55.830
Also wir benutzen hier E1 beispielsweise mehrfach.

46:56.410 --> 47:00.990
Hier ist es noch recht unproblematisch, weil ich die Verzögerungsteile

47:00.990 --> 47:02.370
direkt nach der Variablen habe.

47:03.070 --> 47:05.490
Was jetzt allerdings passieren kann, ich glaube ich muss ein bisschen

47:05.490 --> 47:06.350
vorgreifen, genau.

47:07.170 --> 47:09.510
Was jetzt allerdings passieren kann, ist zum Beispiel so ein Fall.

47:10.590 --> 47:12.930
Ich das jetzt nicht in der Eingabevariable doppelt verwende, sondern

47:12.930 --> 47:16.370
dass ich ein Schaltglied doppelt verwende.

47:16.950 --> 47:21.550
Wenn wir uns das hier anschauen beispielsweise, habe ich hier eine

47:21.550 --> 47:27.130
Oder -Verknüpfung von diesem Zweig, von diesem Zweig.

47:27.770 --> 47:31.270
Ich habe hier ein Und von diesen zwei Zweigen.

47:31.650 --> 47:33.270
Ich habe hier ein Und von diesen zwei.

47:34.310 --> 47:35.410
Ich habe eine Eingabevariable.

47:35.730 --> 47:40.030
Wenn ich jetzt die Pfade betrachte, wie die Variablen jetzt wandern,

47:40.110 --> 47:41.450
dann habe ich hier ein E1.

47:43.630 --> 47:45.710
Also ich kritzle mal alles voll, ich werde es nachher wieder weg

47:45.710 --> 47:47.610
machen, damit ihr nachher auch lesen könnt, was da steht.

47:48.670 --> 47:50.270
Hier ein E1, das hier landen wandert.

47:50.370 --> 47:53.070
Ich habe hier ein E2, das wandert hier entlang.

47:55.130 --> 47:57.010
Ich habe ein E2, das wandert nochmal hier entlang.

48:00.450 --> 48:02.950
Und das ist eigentlich mein problematischer Fall hier.

48:03.710 --> 48:05.990
Der ist nicht immer problematisch, aber in diesem Fall kann er

48:05.990 --> 48:11.570
problematisch werden, wenn wir uns nämlich... also E3 ist hier

48:11.570 --> 48:13.530
unerheblich, hat nur ein Pfad bis zum Ausgang.

48:15.950 --> 48:19.790
Hier verwende ich nämlich diese Negation zweimal.

48:20.310 --> 48:23.010
Jetzt kann es natürlich sein, wenn ich die Drohzeiten aufaddiere.

48:23.290 --> 48:24.170
Und das machen wir mal kurz.

48:24.290 --> 48:29.370
Wir haben hier einmal Tau, einmal 2 Tau und einmal Tau.

48:29.690 --> 48:34.590
Das heißt, dieser zweite Pfad, der würde hier eine Verzögerung von 4

48:34.590 --> 48:35.470
Tau bringen.

48:37.090 --> 48:40.370
Und wenn ich den unteren Pfad nehme, habe ich einmal Tau, einmal Tau

48:40.370 --> 48:41.090
und nochmal Tau.

48:41.250 --> 48:44.270
Das heißt, dreimal Tau habe ich hier eine Verzögerung von 3 Tau.

48:47.940 --> 48:52.000
Das bringt mich jetzt natürlich in eine blöde Situation, weil

48:52.000 --> 48:54.660
eigentlich möchte ich ja alle Tauzeiten ganz nach vorne ziehen, also

48:54.660 --> 48:55.400
vor die Bauteile.

48:57.280 --> 49:02.400
Und hier ist es einfach nicht mehr möglich, weil ich habe hier eine

49:02.400 --> 49:03.300
Inkonsistenz eigentlich.

49:03.380 --> 49:06.860
Ich habe hier ein Bauteil mit Negation, das ich hier zweimal benötige,

49:07.360 --> 49:08.920
das zwei verschiedene Tauzeiten hat.

49:12.100 --> 49:15.080
Das hier nennen wir mehrfach Nutzung von einem Schaltglied.

49:15.220 --> 49:16.860
Das heißt, wie würden wir jetzt hier vorgehen?

49:29.620 --> 49:35.480
Und vielleicht nochmal kurz, ich habe hier eine Funktion F1, ich habe

49:35.480 --> 49:47.920
hier ein Tauzeitglied Tau, dann habe ich eine Funktion F2 und ich habe

49:47.920 --> 49:53.140
eine Funktion F3 und

49:56.430 --> 49:58.690
die haben jeweils nochmal Tauzeiten.

49:58.830 --> 50:01.770
Einmal gehen wir mal davon aus, dass es Tau ist und das andere Mal

50:01.770 --> 50:04.630
gehen wir davon aus, dass es nicht Tau ist, sondern vielleicht

50:04.630 --> 50:08.090
Zweitau, um diesen Konflikt zu provozieren.

50:09.330 --> 50:13.530
Das sei mein BT und das hier sei mein C von T.

50:15.590 --> 50:18.170
Natürlich Eingabevariable nicht vergessen, also A von T.

50:19.410 --> 50:20.650
Also selber Fall wie gerade eben.

50:21.070 --> 50:22.930
Den Fall gerade eben werden wir noch mal ein bisschen detaillierter

50:22.930 --> 50:24.190
betrachten oder ein bisschen schöner.

50:25.850 --> 50:28.670
Ich habe hier Verzögerungszeiten von Zweitau, wenn ich von oben komme

50:28.670 --> 50:30.650
und einmal von Dreitau, wenn ich von unten komme.

50:31.250 --> 50:34.850
Und wie man jetzt dieses Problem lösen kann, ist, dass man einfach das

50:34.850 --> 50:37.890
entsprechende Bauteil, das doppelt verwendet wird, einfach doppelt

50:37.890 --> 50:38.370
ausführt.

50:39.950 --> 50:42.350
Das heißt, ich zeichne jetzt meine Schaltung neu.

50:42.850 --> 50:48.710
Diesmal allerdings mit zweimal F1.

50:53.240 --> 51:02.510
Ich kopiere jetzt quasi, ich kopiere diesen Teil hier und mache zwei

51:02.510 --> 51:03.730
Einzelne draus.

51:16.240 --> 51:17.660
Hier kann man natürlich zusammenfassen.

51:17.840 --> 51:19.400
Das heißt, das hier ist mein A von T.

51:21.760 --> 51:23.520
Und den Rest kann ich ganz normal abschreiben.

51:23.640 --> 51:30.600
Das heißt, hier meine Funktion 2, F2 mit der Todzeit Tau für B von T.

51:31.740 --> 51:41.300
Und meine Funktion 3 mit der Todzeit Zweitau und C von T.

51:44.000 --> 51:48.600
So und jetzt haben wir das Problem nicht mehr.

51:49.000 --> 51:51.000
Jetzt kann ich alle meine Todzeiten nach vorne ziehen.

51:51.640 --> 51:56.000
Das heißt, wenn wir das jetzt mal machen, habe ich ja hier eine

51:56.000 --> 52:00.500
Todzeit, ich habe da eine Todzeit, hier eine Todzeit und da eine

52:00.500 --> 52:01.100
Todzeit.

52:01.800 --> 52:06.860
Das heißt, die nach vorne gezogen habe ich einmal hier Zweitau.

52:07.860 --> 52:09.840
Ich habe unten Dreitau.

52:15.470 --> 52:19.650
Und wenn ich natürlich die nach vorne gezogenen Todzeiten lösche,

52:19.730 --> 52:23.090
bleibt hier nur noch F1 und F2 übrig.

52:26.470 --> 52:29.870
Und hier F1 und F3.

52:34.210 --> 52:35.850
Und natürlich meine Eingabevariable.

52:37.710 --> 52:38.990
Hier wäre wieder A von T.

52:42.550 --> 52:45.450
Das heißt, ich habe jetzt hier wieder die Möglichkeit, einen Bereich

52:45.450 --> 52:48.370
zu haben, wo nur meine Todzeitglieder drin sind und einmal wo meine

52:48.370 --> 52:49.610
logische Verknüpfung drin ist.

52:52.010 --> 52:55.370
B von T zur Vollständigkeit und C von T.

52:57.810 --> 52:58.770
Okay, soweit klar?

53:01.110 --> 53:03.890
Also doppelt verwendete Schaltglieder verdoppeln wir einfach auch in

53:03.890 --> 53:04.530
der Ausführung.

53:05.570 --> 53:09.670
Das heißt, dieser Bereich wird einfach geklont, einmal an den oberen

53:09.670 --> 53:12.490
Pfade und einmal in den unteren Pfade gehängt und dadurch bekomme ich

53:12.490 --> 53:14.290
dann hier eine Eingabevariable.

53:17.070 --> 53:19.550
Also ich habe hier dann wieder individuelle Pfade, wo ich tatsächlich

53:19.550 --> 53:22.170
die Todzeiten wieder nach vorne ziehen kann und hier meine

53:22.170 --> 53:26.590
Aufsplittung meines Schaltnetzes in zwei Teile wieder bewerkstelligen

53:26.590 --> 53:26.850
kann.

53:27.510 --> 53:29.790
Also hier noch mal zu dem Beispiel 2.

53:31.690 --> 53:33.210
Schöner gezeichnet wäre das hier.

53:33.470 --> 53:37.390
Das heißt, dieses doppelt vorkommende Negationsglied haben wir jetzt

53:37.390 --> 53:38.410
auch doppelt ausgeführt.

53:39.030 --> 53:41.090
Wir haben die Todzeiten nach vorne gezogen.

53:41.850 --> 53:45.890
Wir haben hier wieder unseren Verzögerungsanteil, der ist hier

53:45.890 --> 53:53.750
gesammelt und wir haben hier unseren Verknüpfungsanteil, der ist auf

53:53.750 --> 53:54.450
der rechten Seite.

54:02.540 --> 54:05.720
Soweit schon mal alles klar hoffentlich.

54:06.160 --> 54:06.920
Fragen dazu?

54:09.300 --> 54:09.600
Müde?

54:11.260 --> 54:12.540
Liegt hoffentlich nicht an mir.

54:14.540 --> 54:17.680
Ich kann auch schneller reden, wenn es besser wird, aber ich glaube es

54:17.680 --> 54:18.140
wird nicht besser.

54:19.580 --> 54:23.060
Was wir jetzt hier sehen, zusätzlich ist natürlich, dass wir unsere

54:23.060 --> 54:25.280
Eingabevariablen E1, E2, E3 hatten.

54:25.560 --> 54:29.740
Wir haben jetzt aber noch mal andere Eingabevariablen E11, E21, E22

54:29.740 --> 54:30.380
und E31.

54:31.080 --> 54:36.760
Und wie ihr seht, hat man diese neun Eingabevariablen nach dem

54:36.760 --> 54:37.600
Verzögerungsteil.

54:38.100 --> 54:42.280
Das heißt, wenn ich jetzt die linke Seite komplett ignorieren würde,

54:42.280 --> 54:43.440
also abgrün,

54:47.030 --> 54:53.410
wenn ich ab hier alles ignorieren würde, diese Seite, dann habe ich

54:53.410 --> 54:59.450
ein ganz uns schon bekanntes Schaltnetz einfach mit statt drei diesmal

54:59.450 --> 55:00.750
vier Eingabevariablen.

55:01.770 --> 55:04.830
Das werden wir uns gleich noch mal anschauen, was hier der Vorteil ist

55:04.830 --> 55:05.370
von dem Ganzen.

55:08.410 --> 55:13.650
Wir haben gesagt, wir trennen unser Schaltnetz in zwei Teile.

55:14.770 --> 55:18.230
Wir bekommen dadurch einen Verzögerungsteil auf der rechten Seite.

55:22.230 --> 55:26.850
Das, was wir hier jetzt mit E11, E21, E22 und E31 betrachtet haben,

55:27.410 --> 55:28.890
das nennen wir Pfadvariablen.

55:35.550 --> 55:38.170
Und diese Pfadvariablen, die werden immer doppelt indiziert.

55:40.050 --> 55:43.370
Und zwar wird der erste Index gekennzeichnet durch die ursprüngliche

55:43.370 --> 55:46.310
Eingabevariable selber, aus der diese Pfadvariable entstanden ist.

55:46.930 --> 55:50.090
Und der zweite Index ist einfach die Aufnummerierung der Vorkommnisse.

55:50.630 --> 55:54.290
Das heißt, wenn ich jetzt kurz noch mal zurückgehe, wir haben hier das

55:54.290 --> 55:58.390
erste Erscheinen von E1, das heißt unsere Pfadvariable hier wird mit

55:58.390 --> 56:00.090
E11 indiziert.

56:01.070 --> 56:04.910
Wir haben hier das erste Vorkommen der Pfadvariable E2, das heißt hier

56:04.910 --> 56:05.790
habe ich E21.

56:07.150 --> 56:10.810
Hier bin ich beim zweiten Vorkommen von E2, das heißt ich bleibe bei

56:10.810 --> 56:14.730
E2 und inkrementiere den zweiten Index, bin also bei E22.

56:15.810 --> 56:19.730
Dritte Variable kommt zum ersten Mal vor, also statt E3, ich war E31.

56:24.590 --> 56:27.830
Das betrifft jetzt unseren Verzögerungsteil, also die rechte Seite

56:27.830 --> 56:29.930
beziehungsweise die Eingabevariable unseres rechten Teils.

56:30.450 --> 56:33.610
Und diese Pfadvariablen zusammen bilden den Pfadvektor.

56:36.650 --> 56:51.210
Und den können wir jetzt schreiben in der Form E11, E21, E22 und E31.

56:52.590 --> 56:53.990
Das wäre jetzt mein Pfadvektor.

56:56.410 --> 57:01.590
Dann habe ich den linken Teil, das ist mein Verzögerungsteil, der

57:01.590 --> 57:03.850
rechte Teil ist mein Verknüpfungsteil.

57:06.770 --> 57:09.990
Also nochmal, Verzögerungsteil links.

57:10.110 --> 57:12.610
Ich habe die Farben jetzt falsch herum gewählt, deswegen die

57:12.610 --> 57:13.330
Verwirrung vielleicht.

57:14.610 --> 57:19.010
Links hier grün gezeichnet, hier dann rot und auf der rechten Seite

57:19.010 --> 57:22.470
rot und nachher dann grün indiziert.

57:22.950 --> 57:26.450
Also hier meine Eingabevariablen, hier meine Pfadvariablen, hier mein

57:26.450 --> 57:27.370
Verknüpfungsanteil.

57:28.610 --> 57:33.390
So, Verknüpfungsanteil oder mein Verknüpfungsteil bildet sich aus den

57:33.390 --> 57:36.190
Pfadvariablen und wir haben ein ideales Schaltnetz, also so wie wir es

57:36.190 --> 57:37.310
bisher auch kennengelernt haben.

57:37.890 --> 57:40.230
Und wir können verzögerungsfrei dieses Schaltnetz betrachten.

57:43.070 --> 57:46.030
Eine Eigenheit hier ist natürlich, durch die Konstruktion dieser

57:46.030 --> 57:50.190
Pfadvariablen haben wir das jetzt so gemacht, dass jede Pfadvariable

57:50.190 --> 57:52.770
nur einmal vorkommt als Eingabevariable.

57:54.650 --> 57:57.410
Und zusätzlich entsteht natürlich hier auch eine Baumstruktur.

57:59.370 --> 58:05.410
Das heißt, wir haben keinerlei Verzweigungen innerhalb wieder, das uns

58:05.410 --> 58:06.890
dann hier zu Komplikationen führen könnte.

58:10.190 --> 58:12.710
Wenn wir uns die algebraische Darstellungsform dieses

58:12.710 --> 58:15.270
Verknüpfungsteils anschauen, dann nennen wir diesen den

58:15.270 --> 58:16.870
Strukturausdruck des Schaltnetzes.

58:19.530 --> 58:22.090
Das heißt, das ist die Art und Weise, wie diese Funktion implementiert

58:22.090 --> 58:23.950
wurde oder die Struktur dieser Implementierung.

58:24.850 --> 58:27.410
Und wichtig hier ist, dass wir die Darstellungsform nicht ändern

58:27.410 --> 58:29.810
dürfen, weil wenn wir die Darstellungsform ändern, dieser Funktion,

58:29.970 --> 58:35.490
also man könnte ja sagen E oder nicht E oder E oder E nicht ist gleich

58:35.490 --> 58:37.990
1, also schreibe ich da einfach 1 hin, das geht nicht.

58:38.910 --> 58:41.630
Denn dadurch verlieren wir diese Information, wie tatsächlich dieses

58:41.630 --> 58:42.930
Schaltnetz aufgebaut ist.

58:44.370 --> 58:46.810
Das heißt, zusätzlich zu der Funktion beschreibt dieser

58:46.810 --> 58:50.470
Strukturausdruck auch die Struktur des Schaltnetzes offensichtlich.

58:52.090 --> 58:57.630
Okay, also nochmal, Pfadvektor sieht so aus und ein Strukturausdruck

58:57.630 --> 59:07.150
dieses Schaltnetzes wäre dann zum Beispiel E11 nicht und E21, also E11

59:07.150 --> 59:17.010
nicht ist hier und E21 oder E12 und E31.

59:18.770 --> 59:24.730
Also, statt dem vorherigen E1, E2, E3 haben wir jetzt hier den

59:24.730 --> 59:26.830
Strukturausdruck mit unseren Pfadvariablen.

59:30.610 --> 59:37.490
Okay, jetzt müsste ich nicht jedes Mal kurz überlegen, wo wir schon

59:37.490 --> 59:37.930
sind.

59:41.190 --> 59:45.730
Okay, betrachten wir unser Beispiel 2 mit dem Inverterglied, das wir

59:45.730 --> 59:46.510
jetzt verdoppelt haben.

59:48.050 --> 59:54.390
Dann ist unser Pfadvektor E11, E21, E22, E31 und der Strukturausdruck

59:54.390 --> 59:58.590
wäre dann E11 und E21 nicht.

01:00:00.370 --> 01:00:04.010
Oder E22 nicht und E31.

01:00:05.970 --> 01:00:06.590
Das sehen wir dann hier.

01:00:08.250 --> 01:00:12.530
Also, zusätzlich zur Funktion wird hier tatsächlich auch die

01:00:12.530 --> 01:00:14.570
Implementierung dieses Schaltnetzes nochmal beschrieben.

01:00:15.730 --> 01:00:16.990
So, wann brauchen wir das Ganze?

01:00:17.650 --> 01:00:24.070
Wollen wir nachher, wenn wir uns dieses Hazard-Problem nochmal

01:00:24.070 --> 01:00:26.450
anschauen wollen, dann brauchen wir das tatsächlich.

01:00:27.530 --> 01:00:33.650
Und das wird unsere Vorgehensweise erheblich erleichtern.

01:00:35.350 --> 01:00:38.330
Zum einen muss man natürlich nicht jedes Mal das Schaltnetz

01:00:38.330 --> 01:00:41.870
aufzeichnen, um rauszukriegen, wie mein Strukturausdruck oder wie mein

01:00:41.870 --> 01:00:43.890
Pfadvektor aussieht bzw.

01:00:43.950 --> 01:00:45.350
wie meine Pfadvariablen aussehen.

01:00:45.970 --> 01:00:50.090
Eine alternative Methode ist hier tatsächlich zu sagen, jedes Mal,

01:00:50.210 --> 01:00:55.150
wenn eine Variable wie E1, E2 oder E3 vorkommt, erzeuge ich einen

01:00:55.150 --> 01:01:03.590
zweiten Index, der mir das Vorkommnis dieser Eingabevariable bestimmt.

01:01:03.970 --> 01:01:14.750
Zum Beispiel haben wir hier die Funktion gehabt E1 und nicht E2 oder

01:01:14.750 --> 01:01:17.190
nicht E2, E3.

01:01:21.310 --> 01:01:26.030
Und aus dieser Funktionsbeschreibung kann ich dann einfach bei jedem

01:01:26.030 --> 01:01:29.910
Vorkommnis von E1 oder E2 oder E3 kann ich nochmal den zusätzlichen

01:01:29.910 --> 01:01:30.690
Index hinzufügen.

01:01:31.170 --> 01:01:33.290
Und genau so könnte ich auch hier auf den Strukturausdruck kommen.

01:01:33.410 --> 01:01:37.530
Das heißt, E1 zum ersten Mal vorgekommen, wird ein E11 draus.

01:01:37.770 --> 01:01:40.550
E2 zum ersten Mal vorgekommen, wird ein E21 draus.

01:01:40.630 --> 01:01:43.170
In dem Fall negiert, weil auch die Eingabevariable hier negiert ist in

01:01:43.170 --> 01:01:43.670
der Funktion.

01:01:44.210 --> 01:01:46.970
Dann habe ich mein oder, es kommt E2 zum zweiten Mal vor.

01:01:47.090 --> 01:01:51.610
Das heißt, hier wird ein zweites Mal der Index 2 oder der Index 2 wird

01:01:51.610 --> 01:01:53.290
zum ersten Mal hier hinzugefügt.

01:01:54.130 --> 01:01:56.830
Der Index, der hinzugefügt wird, ist hier jetzt eine 2, weil es zum

01:01:56.830 --> 01:01:57.650
zweiten Mal vorkommt.

01:01:57.790 --> 01:02:00.890
Und dann habe ich E3, was zum ersten Mal vorkommt, daher auch die E31.

01:02:01.570 --> 01:02:02.810
Das ist eine alternative Methode.

01:02:02.930 --> 01:02:04.550
Hier muss ich dann keinen Schalten jetzt hinzeichnen.

01:02:04.690 --> 01:02:07.710
Hier muss ich auch nicht überlegen, müssen sich hier irgendwelche

01:02:07.710 --> 01:02:09.910
Schalträder verdoppelt werden, sondern ich kann direkt aus der

01:02:09.910 --> 01:02:12.150
Funktion meine Pfadvariable generieren.

01:02:13.110 --> 01:02:16.190
Genau, das ist nochmal die Beschreibung dieser alternativen Methode.

01:02:19.730 --> 01:02:20.170
So,

01:02:24.350 --> 01:02:25.450
jetzt muss ich überlegen, was hier kommt.

01:02:27.790 --> 01:02:30.630
Im Grunde genau das, was ich gerade gemacht habe, nochmal auf einer

01:02:30.630 --> 01:02:31.190
neuen Folie.

01:02:31.770 --> 01:02:34.850
Wir haben hier die Funktion, zum Beispiel 2 allerdings jetzt, nicht

01:02:34.850 --> 01:02:35.630
zum Beispiel 1.

01:02:36.110 --> 01:02:41.390
Wir haben hier die funktionale Umsetzung von E1 und E2 nicht, oder E2

01:02:41.390 --> 01:02:42.670
nicht und E3.

01:02:43.230 --> 01:02:45.970
Und dann kann ich hier jedes Mal, wenn die Variable vorkommt, also

01:02:45.970 --> 01:02:50.590
hier kommt E1 zum ersten Mal vor, also habe ich hier die zusätzliche

01:02:50.590 --> 01:02:51.030
1.

01:02:51.470 --> 01:02:54.210
Ich habe hier E2 zum ersten Mal, das heißt hier kommt meine

01:02:54.210 --> 01:02:55.230
zusätzliche 1.

01:02:55.650 --> 01:03:00.330
Ich habe hier E2 zum zweiten Mal, das heißt hier kommt eine 2 und dann

01:03:00.330 --> 01:03:03.270
habe ich hier wieder E3 zum ersten Mal, kommt auch hier eine 1.

01:03:04.730 --> 01:03:07.310
Habe ich das Beispiel jetzt zu Beispiel 1 oder Beispiel 2 gemacht?

01:03:08.330 --> 01:03:10.070
Wir haben das hier schon gemacht für Beispiel 2.

01:03:10.070 --> 01:03:13.390
Machen wir es nochmal für Beispiel 1, dann ist es vollständig.

01:03:16.270 --> 01:03:24.710
Hier war ja meine ursprüngliche Funktion E1 negiert und E2 oder E1 und

01:03:24.710 --> 01:03:25.170
E3.

01:03:28.110 --> 01:03:30.130
Und hier wieder das gleiche Spielchen.

01:03:31.270 --> 01:03:34.450
Erste Vorkommen von E1, also füge ich noch eine 1 hinzu.

01:03:35.030 --> 01:03:37.450
Erstes Vorkommen von E2 fügt noch eine 1 hinzu.

01:03:37.990 --> 01:03:41.330
Zweites Vorkommen von E1, also füge ich eine 2 hinzu.

01:03:41.850 --> 01:03:44.470
Erstes Vorkommen von E3, also füge ich hier eine 1 hinzu.

01:03:48.350 --> 01:03:53.230
Also haben wir es für beide Beispiele nochmal nachvollzogen.

01:03:55.370 --> 01:03:58.330
Jetzt wollen wir verschiedene Begriffe nochmal definieren, damit wir

01:03:58.330 --> 01:04:03.890
nachher, wenn wir die ganzen Methoden erklären, dass wir auch vom

01:04:03.890 --> 01:04:04.610
Gleichen reden.

01:04:05.250 --> 01:04:08.170
Zum einen haben wir die Definition des Eingabewechsels.

01:04:08.390 --> 01:04:11.470
Ein Eingabewechsel ist die Änderung einer oder mehrerer

01:04:11.470 --> 01:04:13.710
Eingabevariablen zu einem bestimmten Zeitpunkt.

01:04:15.050 --> 01:04:18.150
Falls sich mehrere Eingabevariablen ändern sollen, so müssen diese

01:04:18.150 --> 01:04:19.490
gleichzeitig sich ändern.

01:04:19.750 --> 01:04:25.050
Also wir gehen hier von einem idealen Eingabewechsel aus.

01:04:25.410 --> 01:04:27.150
Natürlich ist es in der Realität nicht der Fall.

01:04:27.230 --> 01:04:30.510
Haben wir schon jetzt mehrfach betont, dass wenn ein Eingabewechsel

01:04:30.510 --> 01:04:34.850
stattfindet, dass durch die Struktur des Netzes, durch verschiedene

01:04:34.850 --> 01:04:40.470
Verzögerungsglieder, dass verschiedene Variablen schneller oder

01:04:40.470 --> 01:04:42.450
verschiedene Variablen langsamer sich ändern können.

01:04:43.150 --> 01:04:46.490
Das heißt, wir müssen noch einen Übergang definieren.

01:04:47.030 --> 01:04:50.070
Übergang ist der Vorgang im Schaltnetz, der vom Eingabewechsel

01:04:50.070 --> 01:04:50.790
ausgelöst wird.

01:04:51.290 --> 01:04:53.590
Er beginnt mit dem Eingabewechsel und endet mit dem Eintreten des

01:04:53.590 --> 01:04:55.810
neuen Ruhezustands.

01:04:56.370 --> 01:04:58.470
Und hier wichtig natürlich Ruhezustand.

01:04:58.570 --> 01:05:00.830
Das heißt, das Netz selber muss sich noch einmal stabilisieren.

01:05:05.370 --> 01:05:06.370
Kleines Beispiel.

01:05:14.050 --> 01:05:18.550
Wir können jeden Übergang mit dem in- und auslösenden Eingabewechsel

01:05:18.550 --> 01:05:19.270
identifizieren.

01:05:21.750 --> 01:05:27.150
Wir benennen jetzt Eingabebelegungen mit bi und bij.

01:05:27.710 --> 01:05:32.270
Das heißt, wenn wir jetzt von bi nach bij wechseln, so kennen wir den

01:05:32.270 --> 01:05:33.810
Eingabewechsel als auch den Übergang.

01:05:34.430 --> 01:05:37.090
Und wir sagen hier von bi nach bij, haben wir zum Beispiel ein

01:05:37.090 --> 01:05:40.930
Beispiel, wenn wir die Eingabevariablen e1 bis e3 haben, mit einer

01:05:40.930 --> 01:05:46.610
Belegung von 1 1 0 und wechseln auf die Belegung 1 1 1, dann wechseln

01:05:46.610 --> 01:05:48.710
wir von der Belegung 6 auf die Belegung 7.

01:05:49.770 --> 01:05:50.410
Also binär.

01:05:51.930 --> 01:05:57.570
Und wir sehen aber auch in diesem Übergang, dass sich hier nur eine

01:05:57.570 --> 01:05:58.670
Eingabevariable ändert.

01:05:58.770 --> 01:06:01.350
In dem Fall ist es hier e1, wechselt von 0 auf 1.

01:06:02.170 --> 01:06:02.890
Warum ist das wichtig?

01:06:02.970 --> 01:06:03.910
Werden wir auch nochmal gleich sehen.

01:06:07.250 --> 01:06:09.370
Ein paar Einschränkungen zu der Definition.

01:06:13.580 --> 01:06:17.400
Einmal der Ruhezustand des Netzes, also das Netz kommt zur Ruhe.

01:06:26.690 --> 01:06:30.990
Dann, dass alle Verzögerungen endlich sind und dass wir immer nur

01:06:30.990 --> 01:06:32.610
einen Ausgang betrachten werden.

01:06:34.090 --> 01:06:37.590
Ein paar Einschränkungen, die wollen wir uns einfach voraussetzen und

01:06:37.590 --> 01:06:39.890
machen uns das Leben ein bisschen leichter, dass wir nicht so viele

01:06:39.890 --> 01:06:41.070
Spezialfälle betrachten müssen.

01:06:42.730 --> 01:06:46.090
So, dann haben wir vorhin gesehen, dass ein Hazardfehler aufgetreten

01:06:46.090 --> 01:06:49.730
ist bei einem Übergang und jetzt wollen wir nochmal definieren, was

01:06:49.730 --> 01:06:50.970
genau ein Hazardfehler ist.

01:06:52.130 --> 01:06:54.530
Und wir sagen, ein Hazardfehler ist eine mehrmalige Änderung der

01:06:54.530 --> 01:06:58.770
Ausgabevariablen während eines Überganges.

01:06:59.250 --> 01:07:03.630
Es findet ein Eingabewechsel statt und es gibt nur eine Änderung an

01:07:03.630 --> 01:07:06.610
der Eingabe und es gibt mehrere Änderungen an der Ausgabe, wenn ihr so

01:07:06.610 --> 01:07:06.850
wollt.

01:07:08.230 --> 01:07:12.370
Und wir sagen ein Hazard, also wir unterscheiden zwischen Hazardfehler

01:07:12.370 --> 01:07:12.910
und Hazard.

01:07:13.030 --> 01:07:14.630
Die Unterscheidung ist tatsächlich sehr, sehr wichtig.

01:07:14.630 --> 01:07:21.630
Wir werden gleich nochmal anschauen, wie man das unterscheidet.

01:07:22.150 --> 01:07:25.930
Und wir sagen, ein Hazard ist die durch das Schaltnetz gegebene

01:07:25.930 --> 01:07:28.870
logisch -strukturelle Vorbedingung für einen Hazardfehler, ohne

01:07:28.870 --> 01:07:31.050
Berücksichtigung der konkreten Verzögerungswerte.

01:07:32.090 --> 01:07:36.590
Das heißt, ein Hazard kann in einem Schaltnetz bestehen, muss nicht

01:07:36.590 --> 01:07:38.170
unbedingt einen Fehler auslösen.

01:07:39.130 --> 01:07:42.570
Wenn aber ein Hazardfehler ausgelöst wurde, dann ist auf alle Fälle

01:07:42.570 --> 01:07:43.310
ein Hazard da.

01:07:49.350 --> 01:07:52.910
Für diese ganze Betrachtung von Hazardfehler und Hazard betrachten wir

01:07:52.910 --> 01:07:55.230
immer nur einen ganz bestimmten Übergang in einem Schaltnetz.

01:07:55.570 --> 01:07:57.830
Das ist auch sehr wichtig, also wir betrachten nicht das gesamte

01:07:57.830 --> 01:08:02.730
Schaltnetz und sagen, das Schaltnetz hat einen Hazard, sondern wir

01:08:02.730 --> 01:08:07.290
sagen, zu einem bestimmten Übergang im Schaltnetz besteht ein Hazard

01:08:07.290 --> 01:08:08.030
oder ein Hazardfehler.

01:08:09.510 --> 01:08:12.890
Und dafür muss natürlich ein bestimmter Übergang Hazard behaftet sein.

01:08:13.550 --> 01:08:18.110
Das heißt, uns interessieren hier wieder zwei Sachen.

01:08:18.770 --> 01:08:21.150
Einmal die logische Funktion, die durch das Schaltnetz realisiert

01:08:21.150 --> 01:08:21.450
wurde.

01:08:22.070 --> 01:08:25.770
Wenn hier ein Hazard auftritt, dann unterscheiden wir das im Gegensatz

01:08:25.770 --> 01:08:29.210
zu dem, wenn ein Hazard auftritt, der durch die Struktur des

01:08:29.210 --> 01:08:30.210
Schaltnetzes bedingt ist.

01:08:30.730 --> 01:08:32.650
Das heißt, Struktur des Schaltnetzes sind die Anzahl der

01:08:32.650 --> 01:08:36.230
Verknüpfungsfunktionen, die genaue Implementierung an der Gata und die

01:08:36.230 --> 01:08:37.330
Verzögerungswerte und so weiter.

01:08:38.330 --> 01:08:41.510
Also einmal die logische Funktion tatsächlich, was macht meine

01:08:41.510 --> 01:08:45.350
Funktion und zum anderen die konkrete Implementierung der Funktion.

01:08:45.530 --> 01:08:47.830
Also was für Schaltnetze, was für Schaltglieder habe ich verwendet,

01:08:47.910 --> 01:08:50.130
was für Verzögerungszeiten haben diese und so weiter.

01:08:52.770 --> 01:08:52.770
Okay.

01:08:55.930 --> 01:08:57.270
Wann kommen unsere Beispiele?

01:09:01.960 --> 01:09:03.600
Also, das haben wir schon gesagt.

01:09:04.240 --> 01:09:07.900
Wenn wir einen Hazardfehler finden, dann wissen wir auf alle Fälle,

01:09:08.060 --> 01:09:14.740
dass bei diesem Übergang, also sehr wichtig, es geht um den Übergang

01:09:14.740 --> 01:09:19.320
selber, dass dieser Übergang einen Hazard beinhaltet.

01:09:22.300 --> 01:09:23.580
Umkehrung gilt allerdings nicht.

01:09:23.780 --> 01:09:27.600
Also aus dem Hazardfehler folgt ein Hazard, aus dem Hazard folgt aber

01:09:27.600 --> 01:09:28.540
nicht ein Hazardfehler.

01:09:29.940 --> 01:09:33.380
Aus dem Hazard folgt nur ein Hazardfehler, wenn wir noch zusätzlich

01:09:34.220 --> 01:09:35.440
ungünstige Verzögerungswerte haben.

01:09:38.000 --> 01:09:41.640
Also der Rückkehrschluss funktioniert nur, wenn wir zusätzlich noch

01:09:41.640 --> 01:09:44.580
die Bedingungen einfügen, dass wir ungünstige Verzögerungswerte haben.

01:09:45.740 --> 01:09:47.420
Jetzt sollten wir uns ein paar Beispiele anschauen.

01:09:47.580 --> 01:09:50.100
Also hier nochmal zur Wiederholung aus unserem ersten Beispiel.

01:09:50.220 --> 01:09:53.600
Wir hatten hier den Übergang von E1 von 0 auf 1 und haben hier einen

01:09:53.600 --> 01:09:54.720
Hazardfehler festgestellt.

01:09:55.340 --> 01:09:59.000
Wir hatten hier den gleichen Übergang in die andere Richtung, also

01:09:59.000 --> 01:10:01.140
nicht den gleichen Übergang, sondern den Übergang in die andere

01:10:01.140 --> 01:10:02.380
Richtung, den Umkehrschluss.

01:10:02.900 --> 01:10:05.420
Und hier haben wir den E1 von 1 auf 0 gewechselt und hier haben wir

01:10:05.420 --> 01:10:06.780
keinen Hazardfehler feststellen können.

01:10:08.260 --> 01:10:10.220
Das heißt, wir können jetzt sagen, hier ist der Hazardfehler

01:10:10.220 --> 01:10:10.820
aufgetreten.

01:10:10.960 --> 01:10:13.140
Das heißt, dieser Übergang ist Hazardbehaftet.

01:10:16.500 --> 01:10:20.900
Um festzustellen, dass diese Hazardbehaftung da ist, also dass der

01:10:20.900 --> 01:10:25.460
Hazard da ist, reicht tatsächlich nur, einen Hazardfehler zu finden.

01:10:26.200 --> 01:10:28.660
Also sobald ich einen Hazardfehler gefunden habe, weiß ich, der

01:10:28.660 --> 01:10:29.800
Übergang ist Hazardbehaftet.

01:10:33.670 --> 01:10:38.190
So, das war das Beispiel mit unserem 3-Tau, wo unser Hazardfehler

01:10:38.190 --> 01:10:39.050
aufgetreten ist.

01:10:39.810 --> 01:10:43.870
Wenn wir jetzt allerdings das Schalten ins Ändern würden,

01:10:45.810 --> 01:10:49.650
beispielsweise wollen wir hier aus diesem 3-Tau jetzt 1-Tau machen,

01:10:49.790 --> 01:10:53.270
also wir wollen hier die Verzögerung dieses Ungliedes verändern oder

01:10:53.270 --> 01:10:57.330
die Todzeit des Ungliedes verändern, dann können wir nochmal

01:10:57.330 --> 01:10:58.770
betrachten, was dann genau passiert.

01:10:59.070 --> 01:11:02.290
Also, bei 3-Tau haben wir gesehen, Hazardfehler an der Ausgabe.

01:11:02.750 --> 01:11:05.790
Wenn ich jetzt hier, mal schauen, wie meine Animationen geordnet

01:11:05.790 --> 01:11:06.050
waren.

01:11:08.190 --> 01:11:12.270
So, also, wenn ich jetzt hier zunächst mal meine Verzögerungszeit

01:11:12.270 --> 01:11:16.390
ändere auf Tau, von 3-Tau auf Tau, dann wird sich das zunächst auf X3

01:11:16.390 --> 01:11:16.710
aus.

01:11:17.230 --> 01:11:20.050
X3, haben wir gesagt, ist die Verundung von E1 und E3.

01:11:21.250 --> 01:11:24.550
E1 ist die Eingabevariable mit dem Wechsel, E3 war konstant 1.

01:11:25.210 --> 01:11:28.530
Das heißt, hier habe ich genau den Verlauf von E1 mit der Verzögerung

01:11:28.530 --> 01:11:29.030
von Tau.

01:11:29.810 --> 01:11:33.330
Das heißt, hier ändert sich mein X3, dass er ab hier nicht 3-Tau

01:11:33.330 --> 01:11:36.050
-Verzögerungen hat, sondern nur 1-Tau-Verzögerungen und dann auf 1

01:11:36.050 --> 01:11:36.950
wechselt.

01:11:37.650 --> 01:11:41.630
Und dann habe ich hier, X3 wirkt sich auf A aus, hat keine

01:11:41.630 --> 01:11:43.430
Auswirkungen auf X1 oder X2.

01:11:43.870 --> 01:11:47.710
Das heißt, hier habe ich die Veroderung von X2 und X3, also ich

01:11:47.710 --> 01:11:51.150
betrachte diese zwei Signalverläufe und verodere die.

01:11:51.550 --> 01:12:02.490
Und jetzt sehe ich, dass X2 bis T0 plus 2-Tau auf 1 ist und X3 von 0

01:12:02.490 --> 01:12:07.110
bis oder von Anfang an bis T0 plus Tau auf 0 ist und danach auf 1

01:12:07.110 --> 01:12:07.530
wechselt.

01:12:07.810 --> 01:12:10.250
Das heißt, ich habe hier ständig ein Element, das immer 1 ist.

01:12:10.710 --> 01:12:13.250
Das heißt, für meine Ausgabefunktion heißt es dann, dass ich hier auf

01:12:13.250 --> 01:12:14.370
einer konstanten 1 bin.

01:12:15.050 --> 01:12:18.830
So, das heißt, für den Fall, dass ich jetzt mein Verzögerungsglied von

01:12:18.830 --> 01:12:22.230
3 -Tau auf Tau ändere, habe ich hier keinen Hazardfehler mehr.

01:12:22.350 --> 01:12:23.130
Habe ich noch einen Hazard?

01:12:26.070 --> 01:12:26.490
Warum?

01:12:27.290 --> 01:12:28.110
Weil es da steht.

01:12:30.370 --> 01:12:32.530
Also, der Hazard, an dem ändert sich nichts.

01:12:32.670 --> 01:12:34.890
Wir haben gesagt, der Hazard ist unabhängig von meiner konkreten

01:12:34.890 --> 01:12:36.510
Implementierung, hängt von der Funktion ab.

01:12:37.310 --> 01:12:40.390
Und tatsächlich hier habe ich nur meine Verzögerungszeiten geändert.

01:12:40.710 --> 01:12:42.890
Nur durch die Änderung meiner Verzögerungszeiten werde ich den Hazard

01:12:42.890 --> 01:12:43.530
so nicht los.

01:12:44.370 --> 01:12:47.590
Den Hazardfehler schon, sehen wir offensichtlich, haben wir hier

01:12:47.590 --> 01:12:48.270
beseitigen können.

01:12:48.730 --> 01:12:52.710
Aber der Hazard selber, die Hazardbehaftung meines Überganges bleibt

01:12:52.710 --> 01:12:54.010
trotzdem bestehen.

01:12:56.830 --> 01:13:02.250
So, jetzt noch ein paar Definitionen.

01:13:02.310 --> 01:13:03.210
Wie stehen wir zeitlich?

01:13:03.530 --> 01:13:03.970
Ganz gut.

01:13:05.230 --> 01:13:07.610
Also, zunächst mal statischer Übergang.

01:13:07.810 --> 01:13:10.510
Wir sagen, ein statischer Übergang ist ein Übergang, bei dem Anfangs-

01:13:10.510 --> 01:13:13.670
und Endwert des Ausgangssignals gleich sind, unabhängig davon, ob

01:13:13.670 --> 01:13:14.890
jetzt ein Hazard auftritt oder nicht.

01:13:15.410 --> 01:13:18.350
Das heißt, ich rede von einem statischen Nullübergang, wenn meine

01:13:18.350 --> 01:13:20.510
Anfangs - und Endbelegung beide Null sind.

01:13:20.630 --> 01:13:23.530
Ich rede von einem statischen Einsübergang, wenn Anfangs- und Endwert

01:13:23.530 --> 01:13:25.090
des Ausgangssignals beide 1 sind.

01:13:27.030 --> 01:13:28.230
Genau das, was wir vorhin hatten.

01:13:28.370 --> 01:13:33.930
Wir hatten Ausgabe, Anfangs- und Endwert meines Ausgangssignals waren

01:13:33.930 --> 01:13:35.710
1, zwischendrin bin ich kurz auf die Null.

01:13:35.790 --> 01:13:38.190
Das heißt, hier hätten wir einen statischen Einsübergang.

01:13:41.170 --> 01:13:44.170
Umkehrschluss wäre natürlich, wir haben ja nur vier Möglichkeiten.

01:13:44.470 --> 01:13:47.650
Wir können von 0 auf 0, 0 auf 1, 1 auf 0, 1 auf 1.

01:13:48.770 --> 01:13:51.090
Offensichtlich, wenn ich von 0 auf 0 und 1 auf 1 abgedeckt habe,

01:13:51.190 --> 01:13:52.750
bleiben noch 0, 1 und 1, 0 übrig.

01:13:53.090 --> 01:13:54.950
Und diese zwei nennen wir dann dynamischen Übergang.

01:13:55.430 --> 01:13:57.670
Das heißt, ein dynamischer Übergang, bei dem Anfangs- und Endwert des

01:13:57.670 --> 01:14:01.050
Anfangssignals verschieden sind, nennen wir dann dynamischen Übergang.

01:14:01.250 --> 01:14:04.630
Wir unterscheiden zwischen einem dynamischen 0-1-Übergang, wenn der

01:14:04.630 --> 01:14:07.330
Anfangswert 0 und der Endwert 1 sind offensichtlich, und einem

01:14:07.330 --> 01:14:10.230
dynamischen 1-0-Übergang, wenn Anfangswert 1 und der Endwert 0 sind.

01:14:12.970 --> 01:14:16.710
Zur Verdeutlichung, ich glaube, das ist recht trivial.

01:14:17.010 --> 01:14:20.410
Trotzdem wollen wir uns das im KV-Diagramm anschauen.

01:14:21.130 --> 01:14:24.950
Mein statischer Einsübergang wäre zum Beispiel der Übergang von diesem

01:14:24.950 --> 01:14:25.750
Feld zu diesem.

01:14:25.830 --> 01:14:31.050
Das heißt, meine Ausgabefunktion wäre 1, anfangs eine 1 und zum Ende

01:14:31.050 --> 01:14:31.730
auch eine 1.

01:14:32.330 --> 01:14:33.910
Hier habe ich einen statischen Einsübergang.

01:14:35.530 --> 01:14:38.070
Ein dynamischer 0-1-Übergang wäre zum Beispiel der Übergang von diesem

01:14:38.070 --> 01:14:42.110
Feld zu diesem und der dynamische 1-0-Übergang wäre genau die

01:14:42.110 --> 01:14:44.530
umgekehrte Richtung, also von 1 nach 0.

01:14:47.490 --> 01:14:50.890
Das war die Definition der Übergänge.

01:14:51.950 --> 01:14:56.990
Wir können analog dazu die Hazards definieren.

01:14:57.170 --> 01:15:02.610
Das heißt, statt statischen 0-Hazards, statischen 0-Übergängen reden

01:15:02.610 --> 01:15:06.710
wir dann von einem statischen 0-Hazard und statt dynamischen 0-1- oder

01:15:06.710 --> 01:15:10.070
1 -0-Übergängen reden wir dann von dynamischen 1-0- und 0-1-Hazards.

01:15:11.750 --> 01:15:14.670
Ein Hazard in einem statischen 0-Übergang nennen wir dann auch Folge

01:15:14.670 --> 01:15:15.910
dessen statischen 0-Hazard.

01:15:15.990 --> 01:15:17.630
Wie würde so ein Hazard aussehen?

01:15:19.050 --> 01:15:24.210
Ich erwarte einen konstanten Verlauf auf 0 und bekomme hier noch mal

01:15:24.210 --> 01:15:28.530
zusätzlich einen Wechsel von 0 auf 1 und auch wieder zurück von 1 auf

01:15:28.530 --> 01:15:28.750
0.

01:15:29.150 --> 01:15:31.630
Also das wäre ein Beispiel für einen statischen 0-Hazard-Fehler.

01:15:32.890 --> 01:15:35.830
Das wäre auch ein Beispiel für einen statischen 0-Hazard-Fehler.

01:15:36.210 --> 01:15:41.210
Ich sehe am Anfang eine Anfangsbelegung, hier ist 0, meine Endbelegung

01:15:41.210 --> 01:15:43.350
hier ist 0, auch hier 0.

01:15:44.430 --> 01:15:48.450
Das heißt, unabhängig davon, wie oft ich jetzt hier diesen Wechsel

01:15:48.450 --> 01:15:52.710
habe, ob es jetzt einmal oder zweimal ist, sobald es mindestens einmal

01:15:52.710 --> 01:15:54.270
auftritt, habe ich hier ein Problem.

01:15:56.770 --> 01:16:00.930
Analog dazu, statischer 1-Hazard-Fehler wäre genau andersrum.

01:16:01.030 --> 01:16:05.210
Das heißt, ich wäre hier bei 1 und müsste dann auch wieder bei 1

01:16:05.210 --> 01:16:05.690
rauskommen.

01:16:06.750 --> 01:16:09.810
Auch hier die Anzahl der Wechsel interessiert mich nicht.

01:16:10.190 --> 01:16:12.770
Sobald der Wechsel mindestens einmal auftritt, reden wir hier von

01:16:12.770 --> 01:16:14.210
einem statischen 1-Hazard-Fehler.

01:16:16.670 --> 01:16:19.570
Dynamischer 0-1-Hazard, hier wird es ein bisschen interessanter

01:16:19.570 --> 01:16:24.730
vielleicht, weil ich im Idealverlauf ja auch von 0 auf 1 wechsle.

01:16:24.850 --> 01:16:30.090
Das heißt, ich würde erwarten, dass ich einmal wechsle und jede

01:16:30.090 --> 01:16:33.150
zusätzliche Änderung würde bedeuten, dass ich hier nochmal so einen

01:16:33.150 --> 01:16:33.770
Einbruch habe.

01:16:33.990 --> 01:16:35.970
Also ich habe hier drei Wechsel statt einem Wechsel.

01:16:37.210 --> 01:16:40.050
Also ich brauche mindestens drei Wechsel und hier brauche ich dann,

01:16:40.310 --> 01:16:43.150
der nächste Schritt wäre dann, dass ich dann fünf Wechsel hätte.

01:16:45.090 --> 01:16:51.130
Also 1, 2, 3, 4 zusätzliche und das hier ist mein regulärer Wechsel.

01:16:51.570 --> 01:16:52.570
Den brauche ich so oder so.

01:16:55.650 --> 01:16:57.750
1-0-Hazard-Fehler, selbes.

01:16:58.010 --> 01:17:02.170
Also wir haben gesagt, wir klassifizieren die Übergänge als statisch

01:17:02.170 --> 01:17:06.070
und dynamisch und bei den statischen sagen wir, es gibt 0-Übergänge, 1

01:17:06.070 --> 01:17:09.170
-Übergänge, also ein statischer 0-Übergang, statischer 1-Übergang und

01:17:09.170 --> 01:17:12.190
dynamisch haben wir gesagt, es gibt 0-1-Übergänge und 1-0-Übergänge

01:17:12.190 --> 01:17:14.510
und jetzt haben wir noch gesagt, statt Übergänge können wir einfach

01:17:14.510 --> 01:17:15.850
das Wort ersetzen durch Hazards.

01:17:16.170 --> 01:17:18.390
Dann haben wir die Klassifizierung von Hazards und würden dann nicht

01:17:18.390 --> 01:17:22.250
Übergänge, sondern Hazards definieren und von der Definition her

01:17:22.250 --> 01:17:23.390
bleibt es wieder dasselbe.

01:17:24.850 --> 01:17:26.030
Hört ihr die Animationsgeräusche?

01:17:27.090 --> 01:17:27.830
Ich wollte sie rausnehmen.

01:17:29.050 --> 01:17:32.390
Okay, eine wichtige Sache noch.

01:17:34.250 --> 01:17:38.510
Ja, Funktions-Hazards und Struktur-Hazards, das ist die andere Sache,

01:17:38.650 --> 01:17:39.210
die wir unterscheiden.

01:17:39.390 --> 01:17:43.810
Wir haben ja gesagt, wir wollen einmal unterscheiden bei der Hazard

01:17:43.810 --> 01:17:47.610
-Behaftung, ob es abhängt von der Funktion und einmal, ob es von der

01:17:47.610 --> 01:17:49.130
Implementierung dieser Funktion abhängt.

01:17:49.410 --> 01:17:52.530
Und was wir hier sagen ist, die Unterscheidung hier, die wir hier

01:17:52.530 --> 01:17:56.550
treffen, ist einmal, dass wir den ersten Hazard ein Funktions-Hazard

01:17:56.550 --> 01:17:58.710
nennen und den zweiten ein Struktur-Hazard.

01:17:59.730 --> 01:18:04.050
Das heißt, bei einem Funktions-Hazard liegt die Ursache in der zu

01:18:04.050 --> 01:18:09.110
realisierenden Funktion selber und beim Struktur-Hazard liegt das

01:18:09.110 --> 01:18:11.590
Problem in der Implementierung dieser Funktion.

01:18:11.790 --> 01:18:15.950
Das heißt, hier könnte das Schaltnetz selber, je nachdem was für

01:18:15.950 --> 01:18:18.950
Knüpfungsfunktionen ich verwendet habe, wie sie angeordnet sind, was

01:18:18.950 --> 01:18:21.770
für Todzeiten wir haben und so weiter, verantwortlich dafür sein, dass

01:18:21.770 --> 01:18:23.290
dieser Struktur-Hazard entsteht.

01:18:23.970 --> 01:18:26.090
Beim Funktions-Hazard selber ist es unabhängig von der

01:18:26.090 --> 01:18:26.610
Implementierung.

01:18:26.730 --> 01:18:28.770
Das heißt, ich brauche mir die Struktur überhaupt nicht anschauen.

01:18:28.910 --> 01:18:31.550
Ich weiß direkt von der Funktion ausgehen, kann ich direkt

01:18:31.550 --> 01:18:33.550
feststellen, dass dieser Funktions-Hazard vorhanden ist.

01:18:36.890 --> 01:18:40.450
Also, Funktions-Hazard-Definition ist ein Hazard, dessen Ursache in

01:18:40.450 --> 01:18:41.710
der zu realisierenden Funktion liegt.

01:18:41.870 --> 01:18:44.630
Er tritt in jedem möglichen Schaltnetz für diese Funktion auf und kann

01:18:44.630 --> 01:18:45.630
nicht behoben werden.

01:18:47.090 --> 01:18:49.150
Der Funktions-Hazard kann nicht behoben werden.

01:18:49.790 --> 01:18:53.450
Wir werden nachher feststellen, dass wir den Funktions-Hazard-Fehler

01:18:53.450 --> 01:18:57.730
eventuell beheben können, aber nicht den Funktions-Hazard selber.

01:18:57.950 --> 01:18:58.670
Also, der ist immer da.

01:18:59.650 --> 01:18:59.930
Bzw.

01:19:00.050 --> 01:19:02.610
wir haben das vorhin schon gesehen in der Funktion, indem wir die

01:19:02.610 --> 01:19:05.850
Verzögerungsteile geändert haben oder die Verzögerungswerte der

01:19:05.850 --> 01:19:08.050
Todzeiten geändert haben, haben wir den Fehler beheben können.

01:19:08.410 --> 01:19:09.970
Der Funktions-Hazard selber war aber noch da.

01:19:11.370 --> 01:19:16.610
Dann Definition 2.1.2 Struktur-Hazard ist ein Hazard, dessen Ursache

01:19:16.610 --> 01:19:22.390
in der Struktur des realisierten Schaltnetzes liegt.

01:19:23.270 --> 01:19:26.370
Ein Struktur-Hazard kann deshalb immer durch Änderung der

01:19:26.370 --> 01:19:29.350
Schaltnetzstruktur bei gleicher Schaltnetzfunktion behoben werden und

01:19:29.350 --> 01:19:31.410
es ist auch grundsätzlich möglich, ein anderes Schaltnetz zu

01:19:31.410 --> 01:19:34.310
entwerfen, das dieselbe Funktion realisiert, aber diesen Struktur

01:19:34.310 --> 01:19:35.110
-Hazard beseitigt.

01:19:37.830 --> 01:19:39.190
Klassifizierung von Laufseiteeffekten.

01:19:39.290 --> 01:19:41.750
Wir haben auf der linken Seite, was wir erkennen wollen.

01:19:42.290 --> 01:19:45.170
Einmal Funktions-Hazard, Struktur-Hazard, Funktions-Hazard-Fehler,

01:19:45.290 --> 01:19:48.010
Struktur -Hazard-Fehler und auf der oberen Seite haben wir, was wir

01:19:48.010 --> 01:19:48.810
dafür benötigen.

01:19:49.430 --> 01:19:52.310
Für den Funktions-Hazard benötigen wir offensichtlich nur die Funktion

01:19:52.310 --> 01:19:53.070
des Schaltnetzes.

01:19:54.250 --> 01:19:57.990
Um den Struktur-Hazard zu erkennen, benötigen wir natürlich die

01:19:57.990 --> 01:20:02.350
Struktur des Schaltnetzes und um einen Funktions-Hazard-Fehler oder

01:20:02.350 --> 01:20:06.590
einen Struktur-Hazard-Fehler zu erkennen, benötigen wir die konkreten

01:20:06.590 --> 01:20:09.530
Verzögerungen der Gatter zur gegebenen Struktur des Schaltnetzes.

01:20:10.250 --> 01:20:13.690
Ohne diese Informationen kann ich diese Fehler oder diese Funktions

01:20:13.690 --> 01:20:15.370
-Hazards selber nicht erkennen.

01:20:17.390 --> 01:20:21.410
Okay, ich glaube, bei der Folie höre ich auf.

01:20:22.190 --> 01:20:26.110
Wir haben Donnerstag, nächsten Dienstag geht es weiter mit

01:20:26.110 --> 01:20:26.590
Vorlesungen.

01:20:26.690 --> 01:20:29.410
Nächsten Donnerstag werden wir noch mal ein paar Übungen dazu rechnen,

01:20:29.510 --> 01:20:30.650
zum Todzeitmodell.

01:20:32.270 --> 01:20:33.790
Wieder zurück im Audimax.

01:20:37.130 --> 01:20:40.790
Die Anmeldungen für die Klausur, vielleicht für diejenigen, die... ihr

01:20:40.790 --> 01:20:44.890
seid jetzt TI1, das heißt die meisten von euch betrifft es vielleicht

01:20:44.890 --> 01:20:50.610
nicht, aber wenn jetzt irgendwelche Studenten von euch die Klausur

01:20:50.610 --> 01:20:53.390
vorziehen wollen oder so, dann ist die Anmeldung für die Klausur

01:20:53.390 --> 01:20:54.070
freigeschaltet.

01:20:54.330 --> 01:20:56.790
Ihr könnt auf der Homepage noch mal ein paar Informationen dazu

01:20:56.790 --> 01:20:58.250
nachlesen.

01:20:58.370 --> 01:21:01.390
Ansonsten wünsche ich euch viel Spaß und wir sehen uns nächste Woche.