WEBVTT

00:07.620 --> 00:09.720
Ja, es ist ein neues Kapitel.

00:10.660 --> 00:11.320
Heißt 10.

00:12.240 --> 00:14.020
Geht primär um Busse.

00:14.120 --> 00:16.960
Also wir haben jetzt ja schon viel gesehen, was für Komponenten es

00:16.960 --> 00:18.200
alles so gibt in so einem System.

00:18.320 --> 00:21.560
Da gibt es die CPU, da gibt es eine ganze Menge anderes Zeug und die

00:21.560 --> 00:22.540
muss man irgendwie verbinden.

00:22.920 --> 00:25.700
Und dafür werden normalerweise Busse eingesetzt.

00:26.340 --> 00:28.820
In Bussen können halt eben mehrere Komponenten zusammengeschaltet

00:28.820 --> 00:30.800
werden, können miteinander reden und da gibt es halt irgendwie

00:30.800 --> 00:33.140
Protokolle dafür, die entscheiden, wie dieses Reden genau

00:33.140 --> 00:34.220
funktionieren soll.

00:34.220 --> 00:35.920
Und das gucken wir uns erstmal an.

00:36.000 --> 00:37.700
Es gibt verschiedene Zeitverhalten.

00:37.940 --> 00:40.920
Also wie protokolliert ist, wie die Kommunikation funktionieren soll.

00:43.040 --> 00:44.880
Dieses Wort wird jetzt noch eine Weile auftauchen.

00:45.600 --> 00:46.020
Bausteine.

00:46.540 --> 00:48.640
Systemsteuer- und Schnittstellenbausteine.

00:49.040 --> 00:52.500
Das Wort Bausteine hört sich für mich immer so an, als wäre das ein

00:52.500 --> 00:55.640
externer Chip, was wahrscheinlich auch wirklich gemeint war, als die

00:55.640 --> 00:57.260
Folien irgendwann mal erstellt worden sind.

00:57.980 --> 01:00.000
Prinzipiell gibt es die gleichen Dinger immer noch.

01:00.140 --> 01:02.240
Sie sind halt nur inzwischen auf dem Chip mit drauf.

01:02.240 --> 01:04.380
Das Wort Bausteine ist irgendwie nicht mehr so ganz passend.

01:04.500 --> 01:07.240
Aber ansonsten von den Konzepten ist es das gleiche geblieben wie

01:07.240 --> 01:07.460
vorher.

01:07.600 --> 01:09.820
Es ist nur einfach inzwischen quasi alles integriert worden.

01:11.280 --> 01:12.980
Ausnahmenbehandlung hatte ich früher schon mal kurz angerissen.

01:13.100 --> 01:14.000
Gibt es auch noch Folien für.

01:14.500 --> 01:15.640
DMA steht hier noch drauf.

01:15.740 --> 01:17.160
Kommt leider erstaunlich wenig von vor.

01:17.220 --> 01:21.780
Aber ein Punkt weiter hinten guckt sich auch DMA, also Direct Memory

01:21.780 --> 01:23.740
Access, das ist auch so eine Art, wie man auf dem Bus kommunizieren

01:23.740 --> 01:25.300
kann, guckt sich das genauer an.

01:26.140 --> 01:26.500
Gut.

01:28.060 --> 01:31.140
Ja, wenn man jetzt mehrere Komponenten an einem Bus zusammensteckt,

01:31.140 --> 01:33.480
müssen sich die Komponenten irgendwie einig werden, wie sie über

01:33.480 --> 01:35.640
dieses geteilte Medium kommunizieren wollen.

01:35.920 --> 01:37.040
Da gibt es verschiedene Protokolle für.

01:37.720 --> 01:39.320
Also wirklich viele Protokolle.

01:39.540 --> 01:43.440
Man kann die so klassifizieren in Synchrone, Semisynchrone und

01:43.440 --> 01:44.080
Asynchrone.

01:44.920 --> 01:49.740
Vorweg möchte ich kurz dazu sagen, alle von diesen dreien sind

01:49.740 --> 01:54.260
eigentlich auf irgendeiner Ebene betrachtet synchron im Sinne von, sie

01:54.260 --> 01:54.860
haben eine Glock.

01:55.300 --> 01:58.080
Es gibt eine Glock und die synchronisiert die genauen Daten, also

01:58.080 --> 01:59.880
Steuersignale und Datenaustausche.

02:00.320 --> 02:03.700
Hier ist mit Synchron noch ein Ticken was anderes gemeint, also Glock

02:03.700 --> 02:04.240
haben sie alle.

02:04.340 --> 02:06.960
Es gibt ja wirklich Sachen, die versuchen ohne Glock, ohne Taktgeber

02:06.960 --> 02:07.560
auszukommen.

02:07.660 --> 02:09.940
Das ist ziemlich kompliziert, aber es gibt sowas wirklich.

02:10.480 --> 02:12.520
Das wird aber bei Bussen eigentlich nicht eingesetzt.

02:15.020 --> 02:17.960
Wir werden einige Beispiele sehen von solchen Zeitdiagrammen.

02:18.060 --> 02:20.740
Wir fangen mit dem Synchronensystembus an.

02:21.220 --> 02:25.540
Also es gibt hier immer eine Zeitachse, die immer von links nach

02:25.540 --> 02:26.520
rechts gedacht läuft.

02:27.560 --> 02:37.620
Und hier entspricht der Takt auch gleichzeitig dem Buszyklus.

02:37.860 --> 02:40.880
Der Buszyklus, also hier ist ein Buszyklus beginnend, endend,

02:40.980 --> 02:42.320
aufgeteilt in zwei Phasen.

02:42.420 --> 02:43.800
Der erste und der zweite, A und B.

02:44.440 --> 02:46.840
Und in diesen verschiedenen Phasen wird irgendwas gemacht.

02:48.020 --> 02:51.860
Und hier ist es jetzt so gedacht, man guckt immer nur bei den Rising

02:51.860 --> 02:54.720
oder Falling Edges von diesem Takt auf das Signal.

02:54.720 --> 02:57.600
Also es ist eigentlich immer nur wichtig, was hier gerade für ein

02:57.600 --> 02:59.320
Signal anliegt, hier für ein Signal anliegt.

02:59.740 --> 03:01.460
Dazwischen darf das Signal machen, was es will.

03:01.560 --> 03:03.260
Es ist egal, das wird nicht abgefragt.

03:04.720 --> 03:08.000
In dem Fall hier, bei diesem Beispiel ist es so, dass bei der Falling

03:08.000 --> 03:13.860
Edge holt sich der Bus, holt sich das angesprochene Gerät, also CPU

03:13.860 --> 03:15.620
spricht mit einem Gerät über den Bus.

03:16.120 --> 03:19.140
Das angesprochene Gerät holt sich die Adresse über den Bus.

03:19.640 --> 03:23.300
Im Fall eines Lesezugriffs guckt es auch hier, was soll ich tun?

03:23.300 --> 03:24.200
Soll ich überhaupt was tun?

03:24.340 --> 03:25.460
Also gibt es meistens noch ein Extrasignal.

03:25.820 --> 03:26.620
Und dann, was soll ich tun?

03:26.720 --> 03:27.580
Lesen oder Schreiben?

03:28.180 --> 03:31.280
Und hier ist es jetzt so, diese Nomenklatur, insbesondere dieser

03:31.280 --> 03:35.620
Strich hier oben, der heißt immer Low Active.

03:36.060 --> 03:41.240
Also im Sinne von, wenn der Wert eine Eins ist, wird gelesen und wenn

03:41.240 --> 03:43.320
der Wert eine Null ist, wird geschrieben.

03:43.500 --> 03:44.940
Das heißt dieser Strich oben drüber.

03:45.360 --> 03:46.500
Also Low Active Write.

03:46.500 --> 03:49.360
Hier ist eine Eins, also schreiben.

03:51.100 --> 03:52.040
Dammit, lesen.

03:52.500 --> 03:53.940
Also nochmal, Eins lesen.

03:54.880 --> 03:56.620
Deswegen ist auch egal, was hier anliegt.

03:56.720 --> 04:00.520
Also auf dem Datenbus liegt noch nichts, weil die CPU teilt dem

04:00.520 --> 04:02.120
Peripheriegerät ja keinen Daten mit.

04:02.200 --> 04:03.480
Es fragt ja an nach Daten.

04:04.700 --> 04:09.540
Gut, das Peripheriegerät übernimmt diese Anfrage und antwortet

04:09.540 --> 04:09.940
irgendwann.

04:10.340 --> 04:14.460
Und zwar antwortet es hier am Ende von dieser zweiten Busphase.

04:14.460 --> 04:19.020
Also die erste Phase ist quasi dafür da, dass die CPU die Anfrage auf

04:19.020 --> 04:20.180
den Bus drauflegen kann.

04:20.560 --> 04:23.780
Bei der Falling Edge übernimmt das Peripheriegerät die Anfrage.

04:24.220 --> 04:26.520
Bei der nächsten Rising Edge antwortet das Peripheriegerät.

04:26.920 --> 04:29.320
In dem Fall halt eben mit den entsprechenden Daten.

04:31.420 --> 04:32.660
Schreiben ist so ähnlich.

04:35.100 --> 04:41.400
Nur, dass halt eben jetzt schon, jetzt schon, also zum einen ist klar,

04:41.500 --> 04:42.740
das Schreibsignal muss auf Null sein.

04:43.040 --> 04:46.520
Und dass eben jetzt schon bei der Anfrage, bei der Aufgabenstellung

04:46.520 --> 04:49.280
die Daten halt, die zu schreiben sind, auf dem Bus auch mit drauflegen

04:49.280 --> 04:49.560
müssen.

04:52.480 --> 04:55.540
Mit der Erklärung auf der nächsten Seite bin ich semi-einverstanden.

04:55.640 --> 04:57.840
Man kann auch in dem Bild sehen, also die meinen das wirklich so.

04:57.940 --> 04:59.360
Aber schauen wir mal kurz die Erklärung an.

05:00.300 --> 05:02.920
Beim Lesen ist es genau, wie es da zu sehen war.

05:04.000 --> 05:06.040
Zum Ende des Buszyklus werden die Daten geliefert.

05:06.320 --> 05:09.040
Übernahme der Daten im Prozessor mit der Rising Edge vom nächsten

05:09.040 --> 05:09.300
Takt.

05:09.900 --> 05:11.620
Beim Schreiben ist es aber hier so gemeint.

05:15.520 --> 05:21.640
Prozessor legt die Daten zu Beginn der zweiten Takthälfte auf den

05:21.640 --> 05:22.240
Systembus.

05:22.600 --> 05:24.080
Und das ist auch wirklich hier so eingemalt.

05:24.760 --> 05:30.400
Hier ist quasi zu Beginn der zweiten Takthälfte, zweite Takthälfte

05:30.400 --> 05:31.520
wäre hier oben dieses TB.

05:32.060 --> 05:35.200
Zu Beginn der zweiten Takthälfte werden hier die Daten auf den Bus

05:35.200 --> 05:35.560
gelegt.

05:36.280 --> 05:37.340
Das ist nicht gut.

05:39.060 --> 05:43.520
Also das Peripheriegerät übernimmt die Daten eigentlich zu Beginn.

05:43.620 --> 05:44.780
Also gerade bei diesem Wechsel.

05:44.920 --> 05:46.460
Das heißt Beginn und Ende, es wird nichts Beginn und Ende.

05:46.560 --> 05:48.800
Gerade bei dem Wechsel, da passiert irgendwas.

05:48.900 --> 05:50.580
Bei dem Wechsel werden die Daten übernommen.

05:50.580 --> 05:53.620
Also sollten die meiner Meinung nach entsprechend vorher auf den Bus

05:53.620 --> 05:54.180
gelegen haben.

05:54.560 --> 05:58.760
Also es wäre sicherer, wenn das irgendwie so aussehen würde.

05:59.240 --> 06:03.280
Also irgendwann, hier egal, irgendwann werden die Daten stabil auf den

06:03.280 --> 06:07.320
Bus gelegt und in genau diesem Moment übernimmt das Peripheriegerät

06:07.320 --> 06:07.440
sie.

06:07.500 --> 06:09.120
Genau in dem Moment, wo die Falling Edge kommt.

06:10.640 --> 06:13.220
Also diese Verschiebung plus minus ein bisschen, die ist jetzt auch

06:13.220 --> 06:15.200
ein paar Mal zu sehen auf den Folien, aber naja.

06:16.020 --> 06:18.720
Das Wichtige ist wirklich bei der Falling Edge, bei der Rising Edge,

06:18.860 --> 06:19.680
da passiert irgendwas.

06:21.920 --> 06:23.900
Gut, das war jetzt der Synchrone-Bus.

06:24.020 --> 06:28.680
Der Synchrone-Bus, wo wirklich CPU und Speicher genau wissen, es

06:28.680 --> 06:29.800
dauert genau einen Takt.

06:30.000 --> 06:32.860
Die wissen genau, bei welcher Falling, bei welcher Rising Edge müssen

06:32.860 --> 06:34.560
welche Daten irgendwo hingeschubst werden.

06:34.880 --> 06:37.160
Ist alles vorher abgesprochen, die beiden müssen sich kennen.

06:37.280 --> 06:40.420
Die beiden müssen das gleiche Protokoll, die gleiche Timing-Annahmen

06:40.420 --> 06:40.680
haben.

06:42.760 --> 06:44.680
Ja, das macht es irgendwo einfach.

06:44.940 --> 06:47.860
Also wenn man solche Bausteine hat, macht einem das Leben ziemlich

06:47.860 --> 06:48.200
einfach.

06:48.200 --> 06:51.260
Da muss man nichts extra machen, ziemlich stumpfsinnig, wenig

06:51.260 --> 06:52.260
Intelligenz erforderlich.

06:54.120 --> 06:58.520
Ja, und das war auch eigentlich immer so, die waren üblich an den

06:58.520 --> 07:01.860
Anfangsjahren der Mikrostifte.

07:02.660 --> 07:06.840
Also ich denke, das sollen Plural sein von Mikroprozessoren, aber habe

07:06.840 --> 07:07.940
ich so auch noch nicht gesehen.

07:10.260 --> 07:16.000
Gut, der Nachteil an der Sache ist, Sender und Empfänger müssen

07:16.000 --> 07:17.940
wirklich gleich schnell sein.

07:17.940 --> 07:21.140
Die müssen mit der gleichen Geschwindigkeit überhaupt kommunizieren

07:21.140 --> 07:21.520
können.

07:21.940 --> 07:24.040
Wenn das der Fall ist, super, einfachste Lösung.

07:24.700 --> 07:27.940
Wenn das nicht der Fall ist, was man heute immer häufiger sieht, die

07:27.940 --> 07:30.260
CPU auf dem Chip wird schneller, schneller, schneller.

07:30.560 --> 07:33.000
Und die externen Komponenten, wenn jetzt, es sind ja häufig noch

07:33.000 --> 07:34.180
welche außerhalb vom Chip.

07:34.300 --> 07:38.480
Die, die außerhalb vom Chip sind, werden nicht gleich viel schneller.

07:38.580 --> 07:40.420
Die werden auch ein bisschen schneller, aber die kommen nicht mit.

07:41.060 --> 07:44.620
Und wenn die jetzt auf diese Art synchron reden sollten, dann müsste

07:44.620 --> 07:46.560
die CPU künstlich ausgebremst werden.

07:46.560 --> 07:50.180
Und das ist das Problem, was man hat, wenn man wirklich verschieden

07:50.180 --> 07:53.320
schnelle Komponenten versucht zu kombinieren.

07:55.260 --> 07:59.500
Naja, und deswegen gibt es halt offenbar auch andere Varianten.

08:00.180 --> 08:03.420
Eine Variante wäre der Semisynchrone-Bus.

08:03.940 --> 08:07.300
Wie schon gesagt, alle von denen sind synchron im Sinne von, sie haben

08:07.300 --> 08:07.740
einen Takt.

08:08.280 --> 08:13.040
Und mit dem Wort hier synchron ist gemeint, die haben ein festes,

08:13.220 --> 08:15.820
starres, nicht veränderliches Zeitprotokoll.

08:15.820 --> 08:20.480
Und hier ist das Zeitprotokoll einfach so, es gibt einen Takt, aber

08:20.480 --> 08:23.940
das ist nicht mehr wie vorhin der System-Bus-Takt.

08:24.040 --> 08:26.800
Das ist einfach irgendein anderer Takt, könnte ziemlich schnell sein.

08:27.180 --> 08:29.700
Und deswegen wird gesagt, es gibt immer noch diese beiden Phasen.

08:30.220 --> 08:32.000
Aber die beiden Phasen entsprechen jetzt...

08:32.000 --> 08:36.500
Vorhin war es ja so, die eine Phase war quasi die eine halbe Takt, der

08:36.500 --> 08:38.340
0 -Pegel, nee, der 1-Pegel.

08:38.700 --> 08:41.720
Dann kam hier in der Mitte die Falling-Edge und das hier drüben, TB,

08:41.900 --> 08:42.780
war der 0-Pegel.

08:42.780 --> 08:46.640
Quasi nur ein halber Takt pro Buszyklus, pro diesem AB.

08:47.180 --> 08:51.240
Jetzt ist es so, hier sind zwei komplette Takte, hier ist einer, hier

08:51.240 --> 08:55.200
ist einer, für den A-Teil und auch zwei komplette Takte für den B

08:55.200 --> 08:55.420
-Teil.

08:56.500 --> 09:00.080
Und mit Semisynchron ist hier halt gemeint, es sind mehrere, es ist

09:00.080 --> 09:03.240
nicht konstant dieser halbe wie vorhin, es sind mehrere.

09:03.800 --> 09:08.580
Aber synchron hier im Sinne von, es sind konstant und vorab bekannt

09:08.580 --> 09:10.400
viele, hier zwei.

09:10.400 --> 09:13.200
Dann kann man schon ahnen, wie das Asynchrone aussehen wird.

09:13.520 --> 09:16.820
Es sind auch immer noch Takte, die benutzt werden, aber es ist nicht

09:16.820 --> 09:18.620
vorab festgelegt, wie viele es sein.

09:18.920 --> 09:21.480
Da muss halt irgendjemand sagen, jetzt ist es fertig.

09:21.800 --> 09:22.640
Aber trotzdem immer noch ein Takt.

09:22.740 --> 09:25.080
Aber schauen wir uns erstmal den Semisynchron weiter an.

09:26.560 --> 09:31.240
Wie zuvor, in der ersten Hälfte wird irgendwann die Adresse auf dem

09:31.240 --> 09:32.200
Bus gültig gemacht.

09:32.980 --> 09:39.920
Zusätzlich wird hier gesagt, dass es ein Lesebefehl ist, Daten sind

09:39.920 --> 09:40.300
egal.

09:40.860 --> 09:45.460
Also die Leseweise ist hier immer so, das sind dann echte Nutzdaten

09:45.460 --> 09:46.540
mit diesem Rauten.

09:46.660 --> 09:49.240
Es geht auseinander, weil es ein Bus ist, das sind mehrere Signale.

09:49.540 --> 09:52.000
Wenn es nur ein Signal ist und ein Bitsignal, ist es entweder oben

09:52.000 --> 09:52.700
oder unten.

09:52.940 --> 09:53.740
Hier ist es oben.

09:55.360 --> 09:59.120
Und das hier vorne heißt immer von der Beschreibweise her, ja da ist

09:59.120 --> 10:01.220
auch irgendwas, aber es interessiert niemanden.

10:01.220 --> 10:04.160
Also irgendwie der frühere Buszugriff, der ist gerade nicht wichtig.

10:04.640 --> 10:07.020
Wir gucken uns immer nur die Sachen hier in der Mitte an.

10:07.560 --> 10:12.500
Gut, also hier haben wir den Lesebefehl, Daten sind auch egal, Adresse

10:12.500 --> 10:14.980
ist übernommen worden, hat jetzt zwei Takte gedauert.

10:15.100 --> 10:19.060
Also immer noch diesen einen Buszyklus, den ersten Teil, aber jetzt

10:19.060 --> 10:20.340
zwei Systemtakte.

10:21.460 --> 10:26.080
Und irgendwann, also am Ende von dem zweiten, von dem TB-Teil, jetzt

10:26.080 --> 10:29.720
bei der Rising Edge, muss man halt eben genau absprechen, sind die

10:29.720 --> 10:30.520
Daten verfügbar.

10:30.780 --> 10:34.040
Die Daten werden in Wirklichkeit irgendwann früher verfügbar.

10:34.260 --> 10:37.240
Es hängt jetzt davon ab, wann genau, wie schnell der Chip ist, mit dem

10:37.240 --> 10:37.680
man redet.

10:38.100 --> 10:41.620
Das Einzige, was garantiert werden muss von dem Chip ist, spätestens

10:41.620 --> 10:43.340
hier sind sie verfügbar.

10:44.500 --> 10:48.720
Weil dort, bei dieser Rising Edge, werden sie von der CPU oder wer

10:48.720 --> 10:50.340
auch immer gefragt hat, übernommen.

10:51.560 --> 10:54.600
Da sollte man vielleicht mal dazu sagen, mit diesem spätestens.

10:54.600 --> 10:57.240
Also hier sind ja auch diese Rising Edge, wenn man es mal anschaut,

10:57.560 --> 10:59.080
die ist nicht unendlich steil.

10:59.220 --> 11:02.260
Die hat eine gewisse Flachheit, die geht schon ziemlich steil hoch,

11:02.320 --> 11:03.580
aber nicht unendlich steil.

11:04.560 --> 11:07.180
Und deswegen ist es auch, also es ist halt einfach technologisch so,

11:07.240 --> 11:09.620
dass bei allen Registern, also die halt irgendwie Daten übernehmen,

11:10.180 --> 11:13.080
die haben Zeitgrenzen, die man einhalten muss.

11:13.900 --> 11:17.760
Und zwar gibt es vor der Rising Edge eine sogenannte Setup Time und

11:17.760 --> 11:19.800
nach der Rising Edge eine sogenannte Hold Time.

11:19.800 --> 11:25.160
Und diese zwei Zeitgrenzen, in diesem Zeitperiode darf sich das Signal

11:25.160 --> 11:26.080
nicht verändern.

11:26.760 --> 11:30.120
Wenn sich das Signal in diesem Moment, also kurz vor der Rising Edge,

11:30.280 --> 11:33.040
kurz nach oder genau gleichzeitig zur Rising Edge, wenn sich jetzt in

11:33.040 --> 11:36.260
diesen Zeiten derweil das Eingabesignal für das Register ändern würde,

11:38.160 --> 11:41.000
dann hört das Register im Wesentlichen auf, sich digital zu verhalten.

11:41.440 --> 11:44.280
Also man kann es mit ungeschicktem Timing in diesem Bereich dazu

11:44.280 --> 11:45.700
bringen, dass es anfängt zu schwingen.

11:46.080 --> 11:47.960
Also das lässt sich nicht mehr mit Eins und Nullen beschreiben, das

11:47.960 --> 11:48.980
ist ein analoges Schwingen.

11:48.980 --> 11:51.880
Und deswegen gibt es einfach Vorgaben von den Herstellern der

11:51.880 --> 11:55.840
Technologie, Setup Time vorher, Hold Time danach, das Signal muss

11:55.840 --> 11:58.640
stabil anliegen, dann garantieren wir, der Hersteller von dem Chip,

11:58.900 --> 12:00.080
sowas wird nicht passieren.

12:00.420 --> 12:04.860
Also die Daten müssen immer eine gewisse Zeit, Setup Time, vor der

12:04.860 --> 12:07.820
entsprechenden Rising Edge stabil anliegen und müssen auch darüber

12:07.820 --> 12:11.620
hinaus eine gewisse Weile noch kurz, aber eine gewisse Weile stabil

12:11.620 --> 12:12.880
angehalten werden.

12:14.300 --> 12:16.700
Na gut, jetzt haben wir das Lesen erledigt, Daten sind angekommen.

12:16.700 --> 12:18.280
Wie sieht das Schreiben aus?

12:22.360 --> 12:24.760
Keine so große Überraschung, vielleicht eine Sache noch dazu.

12:25.340 --> 12:28.000
Das gleiche Adress ist klar, Lese, Schreiben ist klar.

12:28.640 --> 12:33.160
Jetzt ist hier liegen die Daten, die zu schreiben sind, an, müssen

12:33.160 --> 12:35.400
sie, weil da wird ja die Aufgabe übergeben.

12:36.960 --> 12:40.760
Jetzt ist es hier so gemacht, dass die Daten weiterhin bis zum

12:40.760 --> 12:44.480
Abschluss der Operation stabil auf dem Bus gehalten werden.

12:44.480 --> 12:48.760
Es gibt Chips, die erfordern das, und es gibt welche, wo es auch ohne

12:48.760 --> 12:48.980
geht.

12:49.920 --> 12:53.600
Bei denen, wo es ohne geht, wäre es quasi erlaubt, dass nachdem hier

12:53.600 --> 12:56.180
die Daten übernommen wurden, kann es gleich wieder zusammengehen und

12:56.180 --> 12:56.380
weg.

12:56.780 --> 12:59.800
Und dann muss der Chip, mit dem geredet worden ist, sie sich intern

12:59.800 --> 13:00.180
merken.

13:00.500 --> 13:03.740
Also irgendjemand muss sie sich merken, damit sie bei dem Array, bei

13:03.740 --> 13:06.920
dem Speicherarray, wenn es jetzt hier ein Speicher ist, stabil

13:06.920 --> 13:09.140
anliegen, damit sie in den Speicher geschrieben werden können.

13:09.140 --> 13:12.420
Und manche Chips, die sagen, das mache ich selber, da brauchst du,

13:12.560 --> 13:13.840
Bus, dich nicht darum zu kümmern.

13:14.320 --> 13:18.340
Und manche sagen, der Bus soll die gefälligst stabil anliegen lassen.

13:18.660 --> 13:20.700
Und ja, ich lasse sie einfach durch.

13:20.800 --> 13:22.340
Also es gibt da immer mehrere Varianten.

13:22.640 --> 13:25.280
Generell, das ist so ein typisches, es gibt unglaublich viele

13:25.280 --> 13:28.500
Varianten, es gibt auch unglaublich viele weitere Steuersignale bei

13:28.500 --> 13:29.120
normalen Bussen.

13:29.860 --> 13:31.560
Aber das hängt dann sehr davon ab, welcher Bus es ist.

13:34.740 --> 13:40.020
Ja, zum Beispiel gibt es auch welche, die haben ein Ready-Signal.

13:40.600 --> 13:43.980
Und ein Ready-Signal geht jetzt schon ein bisschen in die Richtung,

13:44.340 --> 13:50.180
dass das Gerät, das angesprochene Gerät von sich aus sagt, bin fertig,

13:50.300 --> 13:50.860
ja oder nein.

13:52.040 --> 13:55.460
Der Strich oben drüber heißt wieder Low Active, soll also heißen, das

13:55.460 --> 13:59.000
liest man so, wenn das Signal null ist, dann ist es ready.

13:59.000 --> 14:00.720
Also Low Active Ready.

14:02.000 --> 14:04.640
Das heißt, hier ist es ready.

14:06.080 --> 14:11.060
Wenn das Signal jetzt, also die Peripherie, das Gerät nicht sagen

14:11.060 --> 14:14.140
würde, dass es ready ist, dann muss entsprechend der Bus ein bisschen

14:14.140 --> 14:16.340
länger warten, bis die Daten wirklich anliegen.

14:16.440 --> 14:19.680
Ich meine, hier werden immer irgendwelche Daten anliegen.

14:20.240 --> 14:22.160
Es gibt nur Eins und Null, viel mehr gibt es da nicht.

14:22.400 --> 14:25.740
Aber das Gerät wird halt sagen, sind das die richtigen Daten, sind das

14:25.740 --> 14:26.620
die gültigen Daten?

14:26.620 --> 14:29.000
Ja, das sind die gültigen, ich war ready.

14:29.380 --> 14:31.860
Oder nee, das ist irgendwas, ignoriere das, ich war noch nicht ready,

14:31.940 --> 14:32.800
gib mir noch einen Takt.

14:37.440 --> 14:40.160
Ja, das ist, mal sehen, irgendwas übersehen?

14:41.800 --> 14:42.560
Nee, passt.

14:44.900 --> 14:48.680
Gut, also genau, die Idee ist halt eben, um langsam und insbesondere

14:48.680 --> 14:52.960
auch variabel langsam oder vorab unbekannt langsame Speicher zu

14:52.960 --> 14:56.260
benutzen, brauchen wir solche Steuersignale wie das Ready-Signal.

14:56.260 --> 14:59.800
Und wenn die halt eben noch nicht ready sind, also am Ende der

14:59.800 --> 15:02.880
erwarteten Zeit noch nicht ready sind, dann müssen entsprechend

15:02.880 --> 15:06.940
Wartezyklen eingefügt werden, dass halt eben die CWU, also genauer der

15:06.940 --> 15:11.460
Bus hier eigentlich, wartet, bis dann irgendwann mal das Ready-Signal

15:11.460 --> 15:14.320
von dem Gerät auf den richtigen Wert gesetzt wird.

15:15.500 --> 15:18.060
Können wir hier nochmal sehen, wie so ein Wartezyklus eingebaut wird.

15:18.060 --> 15:22.980
Wir haben wieder, wie vorhin, die erste Phase und die ehemals zweite,

15:23.080 --> 15:25.000
die allgemeine letzte Phase.

15:25.640 --> 15:28.320
Und dazwischen hat sich jetzt irgendwie so eine Wartephase gedrängt.

15:29.790 --> 15:31.680
Und hier schauen wir mal, wie das aussieht.

15:32.260 --> 15:39.100
Wir haben hier wieder Lesen, Adresse und mir doch egal als Übergabe an

15:39.100 --> 15:39.460
den Chip.

15:40.200 --> 15:46.160
Und dann bemerkt der Bus, zu dem Zeitpunkt, wo eigentlich die Antwort

15:46.160 --> 15:52.560
erwartet worden wäre, sagt das Gerät aber, sorry, bin noch nicht

15:52.560 --> 15:53.000
fertig.

15:53.320 --> 15:54.140
Wart's mal kurz.

15:54.700 --> 15:57.040
Und jetzt ist es halt eben leider so, und gut, damit wird das halt

15:57.040 --> 15:59.600
eben nicht TB, wie ihr hofft, sondern es wird TW, warten.

16:00.460 --> 16:05.280
Und dann heißt warten immer ein Vielfaches von, wie viele Takte die

16:05.280 --> 16:06.180
normalen Zyklen sind.

16:06.180 --> 16:09.520
Und wenn das hier zwei Takte sind und das hier zwei Takte, also das

16:09.520 --> 16:13.480
hier zwei Takte sind und das hier, B, zwei Takte sind, dann ist das

16:13.480 --> 16:15.040
Warteding halt eben auch zwei Takte.

16:15.100 --> 16:19.420
Das heißt, wir können jetzt nicht, also in diesem Semisynchron sind

16:19.420 --> 16:22.940
wir immer noch, Protokoll, nicht einfach bei der nächsten Rising Edge,

16:23.080 --> 16:25.680
bei der hat es nicht geklappt, also bei der hier, versuchen, sondern

16:25.680 --> 16:28.160
wir müssen auch wieder zwei Takte warten und können es erst hier

16:28.160 --> 16:28.840
wieder versuchen.

16:28.840 --> 16:32.920
Und ja, genau da ist dann das Ready-Signal auch entsprechend, also bis

16:32.920 --> 16:36.700
dahin war das Gerät fertig, Daten lagen auch auf dem Bus und konnten

16:36.700 --> 16:38.580
dementsprechend übernommen werden.

16:39.240 --> 16:39.800
Gut.

16:41.320 --> 16:45.980
Na ja, jetzt sieht man schon irgendwie, wenn hier pro Phase, pro TA,

16:46.280 --> 16:52.540
pro TB, ein Takt oder zwei Takte ist, okay, dann ist ein Warteding,

16:52.660 --> 16:55.680
siehe, mit einem weiteren oder zwei weiteren, vielleicht nicht so

16:55.680 --> 16:55.860
schlimm.

16:55.860 --> 16:59.280
Wenn jetzt TA und TB zehn Takte wären, dann wäre ja die

16:59.280 --> 17:01.900
Mindestwartezeit zehn weitere Takte.

17:02.240 --> 17:04.120
Das ist vielleicht ein bisschen sehr viel.

17:04.400 --> 17:07.600
Da will man feingranularer sein und das ist dann letztendlich der

17:07.600 --> 17:12.280
Schritt hin zum Asynchron, wo einfach nicht festgelegt wird, wie viele

17:12.280 --> 17:13.600
Takte es genau sein müssen.

17:13.720 --> 17:17.080
Es sind immer noch Takte, es ist immer noch clockbasiert synchron,

17:17.580 --> 17:20.760
aber es wird halt nicht mehr festgelegt, wie viele, sondern es wird

17:20.760 --> 17:22.800
komplett durch Steuersignale geregelt.

17:23.880 --> 17:26.580
Schreiben hatten wir vorher noch, genau das gleiche wie vorhin, den

17:26.580 --> 17:33.920
Schreibebefehl hier, schreiben und Daten und Adresse, genau, Adresse

17:33.920 --> 17:34.440
hatten wir ja oben.

17:34.960 --> 17:37.980
Und jetzt sagt hier der Speicher, hab's noch nicht und hier ist es

17:37.980 --> 17:38.500
dann fertig.

17:42.780 --> 17:44.140
Irgendwas übersehen?

17:45.260 --> 17:45.440
Nein.

17:46.560 --> 17:46.720
Gut.

17:48.660 --> 17:55.920
Und dann haben wir die Asynchronsystem-Bosse.

17:57.360 --> 18:01.440
Beispiel hier, also wenn der Takt jetzt gestrichelt ist, verstehe ich

18:01.440 --> 18:01.680
auch.

18:02.500 --> 18:07.060
Also hier ist jetzt einfach wieder Adresse, jetzt gibt es hier neue

18:07.060 --> 18:08.960
Signale, vielleicht erst mal, neue Signale.

18:09.780 --> 18:15.320
Address Strobe heißt im Wesentlichen, jetzt ist die Adresse zu

18:15.320 --> 18:15.880
übernehmen.

18:16.100 --> 18:19.120
Das, was ich jetzt sage, das ist die gültige Adresse.

18:19.840 --> 18:24.020
Und irgendwann später wird dann der Speicher antworten mit Data

18:24.020 --> 18:27.620
Acknowledge, also habt ihr die Daten übernommen, wenn er geschrieben

18:27.620 --> 18:31.680
werden soll, oder Daten sind jetzt da, wenn gelesen werden sollte.

18:35.160 --> 18:39.460
Gucken wir uns ein Beispiel an, Lesebefehl ReadWrite geschenkt.

18:39.460 --> 18:45.120
Jetzt haben wir hier oben irgendwo, das Address Strobe ist ab hier

18:45.120 --> 18:46.200
irgendwie lesbar.

18:46.660 --> 18:49.780
Könnte sein, dass hier zum Beispiel bei der Falling Edges übernommen

18:49.780 --> 18:50.140
wird.

18:50.680 --> 18:56.720
Und dann wird irgendwann später, wird der Chip mit den Daten antworten

18:56.720 --> 19:01.900
und wird dazu auch das Data Acknowledge auf den richtigen Wert legen,

19:02.100 --> 19:04.260
also Low Active Data Acknowledge.

19:04.260 --> 19:08.440
Also 0 heißt, es ist acknowledged, jetzt sind sie da und dann kann die

19:08.440 --> 19:13.560
CPU bei der nächsten Rising Edge halt eben merken, wie das Ready

19:13.560 --> 19:16.600
-Signal eigentlich, Daten sind jetzt da und nimmt dann, was auch immer

19:16.600 --> 19:19.300
gerade auf dem Bus liegt, entgegen.

19:22.400 --> 19:31.600
Ja, und schreiben ist hier... ich glaube, das ist auch wieder so

19:31.600 --> 19:34.020
gemeint gewesen, dass es bei der Falling Edges übernommen wird.

19:34.100 --> 19:37.400
Wir müssen nochmal korrigieren, glaube ich.

19:37.740 --> 19:38.820
Versuchen wir das nochmal.

19:42.780 --> 19:44.380
Jetzt würden die nicht so spät antworten, oder?

19:45.640 --> 19:48.180
Wahrscheinlich ist es ja auch echt so gemeint, dass... warum denn hier

19:48.180 --> 19:49.920
oben vor der Zweitakte, das ist alles so langsam.

19:50.700 --> 19:55.020
Dass hier vorne, dass erst bei der Falling Edge hier, da steht ja

19:55.020 --> 19:56.920
nicht da, die Daten übernommen werden.

20:02.600 --> 20:03.640
Das ist schon irgendwie komisch, oder?

20:03.780 --> 20:07.780
Low Active Data Acknowledge, das heißt doch hier eigentlich ist es

20:07.780 --> 20:10.520
acknowledged, aber es ist ein Lesebefehl, also das muss die Antwort

20:10.520 --> 20:10.880
sein.

20:12.380 --> 20:14.720
Das muss die Antwort sein, aber was macht denn der Teil hier hinten?

20:14.720 --> 20:16.560
Es ist ein bisschen interessant.

20:17.140 --> 20:18.060
Wie ist denn beim Schreiben?

20:20.240 --> 20:24.780
Schreiben habe ich hier vorne, den geht auf... will schreiben.

20:26.140 --> 20:28.140
Die Adresse ist... ja, zusammen mit der Adresse, das ist okay.

20:28.220 --> 20:31.380
Die Frage ist, irgendwann muss es übernommen werden und irgendwann...

20:31.380 --> 20:33.820
ja, der Strich hier würde ja andeuten, dass es hier übernommen wird,

20:33.900 --> 20:36.360
aber es ist... warum so spät?

20:39.160 --> 20:42.600
Tja, es muss hier abgeschlossen sein, denn hier ist das Data

20:42.600 --> 20:45.240
Acknowledge eindeutig auf Null und Null heißt ja, es wird

20:45.240 --> 20:47.300
acknowledged, also da waren die gültigen Daten.

20:47.720 --> 20:50.760
Dass es hier hinten zum Beispiel hier noch länger geht, ist einfach

20:50.760 --> 20:51.560
noch ein Ausläufer.

20:51.620 --> 20:53.000
Der Strich hier hinten ist, glaube ich, nicht wichtig.

20:53.000 --> 20:54.100
Weil hier ist ja zu spät.

20:54.180 --> 20:57.800
Es muss ja in dem Bereich, den ich hier gemalt habe, sowohl beim Lesen

20:57.800 --> 21:00.640
als auch beim Schreiben, da sind die Daten gültig, da müssen sie auch

21:00.640 --> 21:01.380
übernommen werden.

21:01.860 --> 21:04.520
Das kann ja dann eigentlich nur übernommen werden von der CPU.

21:04.680 --> 21:07.760
Die CPU war vorhin die ganze Zeit Rising Edge, also kann das

21:07.760 --> 21:12.980
eigentlich nur die Rising Edge sein oder vielleicht sogar die Rising

21:12.980 --> 21:13.340
Edge.

21:14.420 --> 21:17.200
Eigentlich die erste, eigentlich müsste es die erste der beiden sein.

21:17.720 --> 21:20.280
Und was dann der Strich hier soll, da beginnt dann irgendwann die

21:20.280 --> 21:22.120
nächste Transaktion, vielleicht ist es so gemeint.

21:24.340 --> 21:25.960
Naja, meist gibt es ja noch Text dazu.

21:27.540 --> 21:28.460
Hier noch irgendwas?

21:28.600 --> 21:29.960
Die Erklärung der Signale.

21:30.920 --> 21:34.360
Ja, okay, als wichtiges Konzept vielleicht, der Systemtakt spielt

21:34.360 --> 21:35.120
keine Rolle mehr.

21:35.180 --> 21:38.340
Das ist im Wesentlichen, worum es eigentlich geht, wofür das wichtig

21:38.340 --> 21:38.600
ist.

21:38.980 --> 21:42.100
Es ist nicht mehr wichtig, ob die CPU jetzt mit 100 MHz oder mit 1 GHz

21:42.100 --> 21:42.960
oder sowas läuft.

21:44.240 --> 21:47.160
Die Komponente, die Peripherie kann einfach in dem Moment sagen, ich

21:47.160 --> 21:48.560
habe es übernommen, wenn sie es fertig hat.

21:48.560 --> 21:50.960
Die kann intern mit 10 MHz laufen, völlig egal.

21:51.360 --> 21:54.060
Die sagt dann Bescheid, wann sie es benutzt hat.

21:54.400 --> 21:57.200
Und der Takt, der immer noch da ist, haben wir ja gesehen, der wird

21:57.200 --> 22:00.940
nur noch für die Synchronisierung der Steuersignale, also die beiden

22:00.940 --> 22:03.740
Steuerwerke von der CPU und von der Peripherie, die müssen ja reden

22:03.740 --> 22:05.460
und die reden mit dem Takt.

22:05.460 --> 22:08.100
Die müssen dann, also dieses Steuersignal muss dann schon mit der

22:08.100 --> 22:10.020
schnellen Frequenz von der CPU umgehen können.

22:10.320 --> 22:12.340
Aber der Speicher kann gerne langsamer sein.

22:12.420 --> 22:15.820
Der Speicher kann gerne 10, 20 Takte brauchen, je nachdem, wie lang es

22:15.820 --> 22:16.400
halt eben ist.

22:16.720 --> 22:22.720
Das ist der große Vorteil von diesen asynchronen Systembussen.

22:25.020 --> 22:25.780
Gut, Beispiele.

22:25.940 --> 22:29.520
Also vielleicht könnte man auch sagen, es gibt Busse, die es

22:29.520 --> 22:30.920
heutzutage gibt, ich meine, die gibt es auch.

22:31.140 --> 22:33.780
Also Motorola 68000 gibt es auch immer noch.

22:34.180 --> 22:35.300
Intel, klar, die gibt es überall.

22:36.360 --> 22:39.020
Es gibt bei vielen Bussen, wenn ich mir von Arm den AMBA-Bus oder

22:39.020 --> 22:42.740
sowas angucke, viel, viel mehr Steuersignale, weil die alle

22:42.740 --> 22:44.620
interessante Features haben.

22:44.620 --> 22:48.420
Zum Beispiel, was wir hier gesehen haben, war ja, wenn ich so einen

22:48.420 --> 22:52.100
langsamen Bus habe, der halt eben 20 Takte braucht, sorry, eine

22:52.100 --> 22:56.200
langsame Peripherie habe, der 20 Takte braucht, um zu antworten, dann

22:56.200 --> 22:59.520
ist der Bus für 20 Takte blockiert, weil der wird zwischendurch nicht

22:59.520 --> 22:59.760
freigegeben.

23:01.500 --> 23:03.600
Was gibt es denn für langsame Peripherien?

23:04.800 --> 23:09.060
Eine serielle Schnittstelle, UART, auch USB ist nicht notwendigerweise

23:09.060 --> 23:11.740
schnell, wenn es jetzt noch ein USB 1.1 oder sowas Gerät ist.

23:12.800 --> 23:16.320
Das kann dann schon aus CPU-Sicht viele, viele Takte, hunderte Takte

23:16.320 --> 23:18.800
dauern, bis der Bus wieder freigegeben wird, solange ist der

23:18.800 --> 23:19.200
blockiert.

23:19.200 --> 23:23.680
Und dafür gibt es ein Feature, das nennt sich Split Transaction, im

23:23.680 --> 23:28.140
Sinne von, eine Transaktion, sagt die Peripherie was, die Peripherie

23:28.140 --> 23:30.340
antwortet, kann unterbrochen werden.

23:31.980 --> 23:35.840
Erst wird der Peripherie gesagt, was sie tun soll, also Read, Write,

23:36.140 --> 23:40.320
Adresse, Daten, schreiben jetzt zum Beispiel, und dann kann die

23:40.320 --> 23:45.160
Peripherie sagen, warte mal ein bisschen, und dann kann die

23:45.160 --> 23:46.820
Transaktion unterbrochen werden.

23:46.820 --> 23:50.420
Der Bus wird wieder freigegeben, die Peripherie macht so lange weiter,

23:50.860 --> 23:54.000
der Bus kann so lange andere Transaktionen machen, und irgendwann

23:54.000 --> 23:57.320
später sagt die Peripherie von sich aus, also ich hätte es jetzt, wenn

23:57.320 --> 24:00.540
der Bus jetzt gerade mal wieder frei ist, könnten wir die vorhin

24:00.540 --> 24:02.620
unterbrochene Transaktion fertig machen.

24:02.620 --> 24:05.780
Und dadurch kann man den Bus halt eben bei so langsamen Peripherien

24:05.780 --> 24:08.760
viel besser nutzen, um halt eben andere Kommunikationen zu machen.

24:09.020 --> 24:11.500
Man muss sich überlegen, es gibt vielleicht nicht nur eine CPU im

24:11.500 --> 24:14.120
System, es könnte mehrere Geräte im System geben, die über den Bus

24:14.120 --> 24:16.560
kommunizieren wollen, dafür ist das einfach sehr hilfreich.

24:17.720 --> 24:20.880
Gut, und dann, weil wir eben gerade schon Speicher hatten, konnte ich

24:20.880 --> 24:23.240
es mir irgendwie nicht nehmen, hier dieses Beispiel noch einzubauen,

24:23.520 --> 24:25.260
weil das ist eins, an dem wir gerade selber arbeiten.

24:26.200 --> 24:29.620
Das ist ein Externer, also ein SRAM-Chip, den haben wir gekauft, wir

24:29.620 --> 24:31.900
brauchten für irgendeinen Bordspeicher.

24:33.780 --> 24:37.560
72 Megabit SRAM ist eine ganze Menge, das sind fast 10 Megabyte.

24:38.520 --> 24:42.800
200 Megahertz ist auch ziemlich schnell und der hat ein paar lustige

24:42.800 --> 24:43.220
Features.

24:43.360 --> 24:45.180
Und da wollte ich einfach mal sehen, wie sieht denn so ein Datenblatt

24:45.180 --> 24:48.020
aus, wie sehen da die Timing-Diagramme aus und da ist eine Menge

24:48.020 --> 24:49.080
komisches Zeug noch mit drin.

24:49.600 --> 24:52.100
Aber dieses Menge komische Zeug muss man sich halt eben echt alles

24:52.100 --> 24:54.220
angucken, wenn man jetzt diesen Chip verbinden will.

24:54.220 --> 24:58.800
Also wir hatten quasi ein System auf einem Bord mit Chips und Zeugs

24:58.800 --> 25:02.280
drauf und da konnte man Erweiterungen anschließen über Opens und dann

25:02.280 --> 25:04.400
hatten wir diesen Chip ausgesucht und gekauft.

25:04.840 --> 25:07.060
Jetzt muss man die beiden Dinge irgendwie zusammenkriegen.

25:08.380 --> 25:11.920
Der Speicher an sich ist ganz witzig, weil der mit einer relativ hohen

25:11.920 --> 25:14.360
Taktfrequenz, also für externe 200 Megahertz gar nicht so schlecht

25:14.360 --> 25:17.300
läuft, der ist intern gepipelined.

25:17.640 --> 25:21.700
Also das ist nicht so, dass der quasi in jedem Takt eine Antwort gibt,

25:22.020 --> 25:25.100
sondern der hat glaube ich vier interne Pipeline-Stufen, ich sage ihm,

25:25.240 --> 25:28.820
was er machen soll und dann dauert das, bis er es intern wirklich

25:28.820 --> 25:31.180
macht, aber ich kann ihm im nächsten 200 Megahertz-Takt gleich sagen,

25:31.240 --> 25:32.260
was er danach machen soll.

25:32.720 --> 25:36.740
Und er hat auch ein Feature, das nennt sich, komisches Feature, No

25:36.740 --> 25:37.800
Buzz Latency.

25:39.060 --> 25:43.140
Was damit gemeint ist, ist folgendes, ich kann quasi in jedem Takt

25:43.140 --> 25:45.920
zwischen einem Lese- und einem Schreibbefehl hin und her wechseln,

25:45.980 --> 25:48.840
auch wenn die halt in Wirklichkeit, die zuvor abgeschickten

25:48.840 --> 25:51.260
Lesebefehle sind noch gar nicht durchgeführt, ich kann schon mal einen

25:51.260 --> 25:53.520
Schreibbefehl hinterher schicken, die werden auch alle in der Pipeline

25:53.520 --> 25:54.460
einsortiert.

25:54.460 --> 25:56.840
Da kann man sich schon überlegen, dass es da irgendwie ganz schöne

25:56.840 --> 26:01.620
Verknotungen geben muss, wenn ich ein Lesebefehl hinschicke und der

26:01.620 --> 26:04.340
wird ja dann erst, weiß ich nicht, an der letzten Pipeline-Stufe

26:04.340 --> 26:07.460
sinnvollerweise in der vierten Pipeline-Stufe mit den Daten wirklich

26:07.460 --> 26:08.160
antworten.

26:08.160 --> 26:13.680
Und wenn ich nach dem Lesebefehl einen Schreibbefehl, also wenn das

26:13.680 --> 26:16.500
eine Zeitachse ist und das die vier Pipeline-Stufen von dem SRAM sind

26:16.500 --> 26:20.260
und das ist von mir aus ein Loadbefehl und ich habe danach einen

26:20.260 --> 26:25.840
Speicherbefehl und in dem letzten der Pipeline-Stufen wird der SRAM

26:25.840 --> 26:30.060
-Chip mit den Daten über den Bus antworten, naja, dann ist klar, dass

26:30.060 --> 26:35.540
ich bei dem Speicherbefehl nicht bereits im ersten Takt die Daten

26:35.540 --> 26:36.280
mitgeben kann.

26:36.280 --> 26:41.360
Weil dann wird es irgendwann zwei, drei Takte später ein

26:41.360 --> 26:44.260
Speicherbefehl geben, wenn das hier ein Speicherbefehl wäre, würden

26:44.260 --> 26:47.600
die Daten, die er speichern will, mit den Daten, die vorher gelesen

26:47.600 --> 26:49.600
werden sollen, die würden auf dem Bus kollidieren.

26:49.680 --> 26:52.500
Das ist auch eine gemeinsame Ressource, der Bus, und da würden die

26:52.500 --> 26:53.380
beiden zusammenstoßen.

26:53.840 --> 26:55.680
Das heißt, der Speicherbefehl ist ein bisschen seltener, man muss die

26:55.680 --> 26:58.300
Daten, die zu schreiben sind, echt absichtlich später geben.

26:58.300 --> 27:01.200
Man muss im ersten Takt sagen, die Adresse, man muss erst im dritten

27:01.200 --> 27:07.140
oder im vierten Takt sagen, und hier sind die Daten, weil erst im

27:07.140 --> 27:09.500
vierten Takt der Bus garantiert wieder frei ist.

27:11.160 --> 27:15.240
Na gut, schauen wir uns den mal an, also das ist so ein typisches

27:15.240 --> 27:18.940
Datenblatt, Logo, Werbung, Name, nein, Werbung nicht, aber

27:18.940 --> 27:23.240
Modellnummern, Kurzbeschreibung und dann so eine Übersicht, was kann

27:23.240 --> 27:24.480
das Ding halt eben alles.

27:25.540 --> 27:28.420
Meistens mit sehr unterhaltsamen Wörtern, die kein Mensch versteht,

27:28.480 --> 27:30.980
bis man dann anfängt, das Zeug wirklich zu lesen.

27:31.540 --> 27:37.160
Zum Beispiel das hier ist dieses ohne Wechsel, ohne Taktverlust von

27:37.160 --> 27:39.040
Lesen und Schreiben hin und her wechseln.

27:39.400 --> 27:41.320
Findet man aber auch erst raus, wenn man das Dokument mal komplett

27:41.320 --> 27:42.740
gelesen hat.

27:43.580 --> 27:47.720
Das ist auch noch ein Signal, was es häufig gibt, Output Enable, das

27:47.720 --> 27:51.920
heißt im Wesentlichen, soll dem Gerät überhaupt erlaubt werden,

27:52.040 --> 27:53.080
irgendwas auf dem Bus zu schreiben.

27:53.080 --> 27:56.320
Ich kann sagen, mach deine Outputs mal aus, du schreibst nicht, der

27:56.320 --> 27:57.640
Bus ist gerade für andere Sachen da.

27:58.080 --> 28:00.380
Das kann dann der Speicher auch so interpretieren, wenn ich nicht

28:00.380 --> 28:01.860
schreibe, dann kann er mich auch schlafen legen.

28:01.980 --> 28:05.620
Wir haben ja meist so verschiedene Schlafmodi, um Strom zu sparen.

28:07.000 --> 28:09.960
Feature einzelne Bytes zu schreiben ist noch da, sowas steht auch

28:09.960 --> 28:11.960
immer drin, welche Stromversorgung gebraucht werden.

28:12.040 --> 28:15.800
Der braucht jetzt offenbar einmal 3,3 Volt als Supply, als überhaupt,

28:16.100 --> 28:18.900
damit er läuft, aber die Iopens kann er auch mit verschiedenen

28:18.900 --> 28:21.460
Spannungen betreiben, kann man sich aussuchen.

28:23.200 --> 28:26.900
Clock Enable hat da auch mehrere gleich Pins, wo man auch sagen kann,

28:27.000 --> 28:28.880
leg dich schlafen, ich brauche dich nicht, ich spare Strom.

28:30.720 --> 28:33.000
Ja, und dann ist da noch eine Menge Zeug.

28:35.080 --> 28:38.300
Ein paar Bilder hatte ich rausgenommen, da kommt auch, also es ist

28:38.300 --> 28:39.140
alles aus dem Datenblatt jetzt.

28:39.300 --> 28:43.860
Das ist so ein 30, 40 Seiten Dokument, wo genau beschrieben wird, was

28:43.860 --> 28:45.680
dieser Chip tut und wie man mit ihm reden muss.

28:45.680 --> 28:52.760
Man kann im Wesentlichen so die Eingänge, die Adresssignale kann man

28:52.760 --> 28:58.900
hier erkennen, verschiedenste Chip Enable Signale, das sind

28:58.900 --> 29:02.200
verschiedene Byte, Write Enable Signale, überhaupt ein Write Enable,

29:02.300 --> 29:04.320
also das ist dieses Write oder Read, was wir vorhin auch gesehen

29:04.320 --> 29:08.940
haben, ein Clock mit einem Clock Enable, also zig verschiedene Inputs,

29:08.980 --> 29:10.020
die man dem irgendwie mitgeben kann.

29:10.440 --> 29:14.340
Und am Ende haben wir hier die Daten rausputzeln und irgendwie müssten

29:14.340 --> 29:17.100
sie auch, achso, das ist bidirektional, das ist auch der Input.

29:17.320 --> 29:19.560
Auch der Input und hier ist halt eben der Output.

29:20.960 --> 29:23.380
Also so ein Diagramm, dass man so eine Idee bekommt, wie das Ding

29:23.380 --> 29:24.700
intern überhaupt funktioniert.

29:26.340 --> 29:30.100
Und dann gibt es so etwas, wo dann für jeden Iopen gesagt wird, wofür

29:30.100 --> 29:32.040
ist denn der eigentlich gut, was macht der mit so einer

29:32.040 --> 29:33.860
Kurzbeschreibung, wofür der da ist.

29:34.520 --> 29:36.260
Da gibt es irgendwo noch ein bisschen mehr Text, wo es ausführlicher

29:36.260 --> 29:36.880
beschrieben wird.

29:36.880 --> 29:45.380
Wir haben hier zum Beispiel ein paar Adresspins, die extra nummeriert

29:45.380 --> 29:45.540
sind.

29:45.680 --> 29:47.540
Also das Ding hat mehr als drei Adresspins.

29:48.220 --> 29:51.280
Ach, hier kann man es noch sehen, A0, A1 und A.

29:52.100 --> 29:56.340
Ich habe da echt eine ganze Weile vor diesem Datenblatt gesessen.

29:57.360 --> 29:59.160
Da ist quasi noch ein anderes Bild, das habe ich jetzt nicht drin, wo

29:59.160 --> 30:02.100
quasi der Chip abgebildet ist, wo dann jeder einzelne Pin, das ist der

30:02.100 --> 30:04.020
so und so Pin, das ist der so und so Pin, so rundherum.

30:04.020 --> 30:06.480
Und dann ist da auch so eine Reihe von Adresspins.

30:07.160 --> 30:09.740
Und die heißen alle gleich, die heißen alle A.

30:11.480 --> 30:13.680
Welcher ist jetzt A5, welcher ist A6, welcher ist A7?

30:13.740 --> 30:16.560
Ich muss doch wissen, welcher Adresspin welcher ist.

30:17.120 --> 30:19.980
Bis mir irgendwann mal Licht aufgegangen ist, nein, das muss ich nicht

30:19.980 --> 30:20.260
wissen.

30:20.720 --> 30:24.140
Das ist ein SRAM, dem ist es egal, in welcher Reihenfolge man auf

30:24.140 --> 30:25.120
Adressen zugreift.

30:25.480 --> 30:28.920
Ich kann irgendeinen der Adresspins als A5 oder als A6 benutzen, das

30:28.920 --> 30:29.780
ist vollkommen Schnuppe.

30:30.380 --> 30:33.780
Ich habe da echt eine lange Weile in diesem Datenblatt gesucht, um

30:33.780 --> 30:35.200
herauszufinden, der muss doch irgendwo stehen.

30:35.760 --> 30:36.400
Es steht nicht.

30:36.880 --> 30:38.460
Genauso wie bei den Datenbussen.

30:38.620 --> 30:41.420
Es gibt da nicht irgendwie, der Pin ist Datenpin 0.

30:41.640 --> 30:42.840
Es ist egal, welcher das ist.

30:42.960 --> 30:44.220
Nimm irgendeinen, ist völlig egal.

30:44.880 --> 30:49.780
Hier sind deswegen zwei Adresspins extra hervorgehoben, weil der Chip

30:49.780 --> 30:51.240
auch so eine Art Burst-Modus kann.

30:51.240 --> 30:56.160
Im Sinne von, man kann ihm sagen, pass mal auf, ich gebe dir mal eine

30:56.160 --> 31:01.200
Adresse und die und die nächsten drei, da will ich folgend die vier

31:01.200 --> 31:01.980
Wörter hinschreiben.

31:02.320 --> 31:04.320
Und dann zählt er die Adresse innen drin selber hoch.

31:04.360 --> 31:06.280
Man muss dann quasi nicht alle Adressen einen nach dem anderen

31:06.280 --> 31:06.860
übertragen.

31:07.300 --> 31:11.000
Und deswegen für diesen Burst-Modus sind Adresspins 0 und 1 extra

31:11.000 --> 31:14.140
ausgewiesen, weil die können dann auch quasi intern hochgezählt

31:14.140 --> 31:14.440
werden.

31:15.200 --> 31:17.020
Und alle anderen Adresspins, naja, irgendwas.

31:19.040 --> 31:20.060
Haben wir noch was?

31:20.160 --> 31:23.040
Verschiedene Chip-Enables, Clock-Enables, Operating-Enables,

31:23.140 --> 31:23.880
Datensignale.

31:25.180 --> 31:31.460
Das ist quasi so ein Signal, was diesen internen Adress-Counter

31:31.460 --> 31:31.820
benutzt.

31:31.920 --> 31:33.020
Also das sind diese Bursts.

31:33.060 --> 31:35.840
Um diese Bursts zu aktivieren, dafür sind diese Signale im

31:35.840 --> 31:36.440
Wesentlichen da.

31:39.440 --> 31:42.560
Wahrheitstabellen, gut, es ist jetzt eine abgebildet, einfach mal.

31:42.620 --> 31:45.200
Es gibt ganz viele Wahrheitstabellen da drin, die beschreiben, wie das

31:45.200 --> 31:48.320
Ding funktioniert, wann es schlafen geht, wann es aufwacht, wann es

31:48.320 --> 31:48.940
irgendwas tut.

31:50.200 --> 31:53.480
Ja, und dann hat man so ein Timing-Diagramm, die sehen im Wesentlichen

31:53.480 --> 31:54.880
aus wie was wir gerade gesehen haben.

31:55.900 --> 31:58.680
Dann hat man die Definition noch, was Don't-Care ist und was einfach

31:58.680 --> 31:59.320
Undefined ist.

32:00.080 --> 32:05.560
Also Don't-Care heißt hier im Sinne von mir, dem Chip, ist egal, was

32:05.560 --> 32:06.060
du da anlegst.

32:06.960 --> 32:09.420
Ich werde es sowieso ignorieren, mach da irgendwas hin.

32:10.100 --> 32:14.960
Undefined ist, ich, der Chip, werde irgendwas ausgeben, aber ich

32:14.960 --> 32:17.520
garantiere dir nicht was, das ist Leases nicht.

32:17.920 --> 32:21.020
Nur da, wo es gültig ist, Leases, aber davor, irgendwas wird da

32:21.020 --> 32:22.680
stehen, aber Undefined, Leases nicht.

32:24.000 --> 32:27.540
Naja, dann kann man eben sehen, wie so, das ist jetzt für ein Read

32:27.540 --> 32:29.760
oder vielleicht auch Write, musst du mal genauer durchgucken,

32:30.320 --> 32:33.740
Diagramm, wo dann verschiedene Operationen sind, wie man sehen kann,

32:33.820 --> 32:38.300
wann bitteschön die Daten anlegen sollen und die Adresse anlegen

32:38.300 --> 32:38.600
sollen.

32:38.600 --> 32:41.940
Hier kann man zum Beispiel sehen, dass die Adresse hier deutlich vor

32:41.940 --> 32:45.100
den Daten auf dem Bus liegen muss, einfach weil der halt intern

32:45.100 --> 32:45.720
gepipelt ist.

32:45.780 --> 32:49.660
Solche Sachen kann man dann aus diesem Diagramm rausfusseln.

32:50.400 --> 32:52.600
Ja, gut, jetzt haben wir den Chip, haben verstanden, wie das Ding

32:52.600 --> 32:53.160
funktioniert.

32:53.500 --> 32:56.320
Jetzt muss der noch irgendwie angeschlossen werden an das Ding, was

32:56.320 --> 32:56.700
wir hatten.

32:57.640 --> 32:59.720
Das Ding, was wir hatten, war ein FPGA-Board.

33:00.400 --> 33:02.980
Jetzt kann man nicht so wirklich ohne weiteres erklären, was ein FPGA

33:02.980 --> 33:03.340
ist.

33:04.620 --> 33:08.580
Kurz gesagt könnte man einfach mal sagen, ein FPGA ist ein Chip, den

33:08.580 --> 33:11.580
kann man im Laden kaufen oder mit dem fertigen Board halt eben im

33:11.580 --> 33:12.260
Laden kaufen.

33:12.840 --> 33:16.860
Und dieser Chip, dem ist noch nicht so genau gesagt worden, was er tun

33:16.860 --> 33:17.160
soll.

33:17.560 --> 33:21.680
Also das ist ein Stück Hardware, aber innen drin sind ganz viele

33:21.680 --> 33:26.680
einzelne Gatter und man kann jedem Gatter sagen, verhalte du dich mal

33:26.680 --> 33:29.500
jetzt wie ein So-und-so-Gatter, ein Und-Gatter, verhalte du dich mal

33:29.500 --> 33:32.800
jetzt wie ein Oder-Gatter und man kann dem Chip sagen, verbinde mal

33:32.800 --> 33:35.160
das Gatter mit dem und das Gatter mit dem und das mit dem.

33:35.580 --> 33:38.740
Also man kann diesen Chip konfigurieren, wie er die Sachen innen drin

33:38.740 --> 33:39.800
zusammenschalten soll.

33:40.180 --> 33:42.960
Und dann kann er halt so tun, als wäre er irgendein anderer Chip, als

33:42.960 --> 33:45.460
würde er irgendeine Hardware-Funktionalität implementieren.

33:46.500 --> 33:50.200
Diese FPGAs nutzt man für gewöhnlich, wenn man einen echten Chip bauen

33:50.200 --> 33:53.480
will, dann entwirft man den nicht, bezahlt ein paar Millionen Euro, um

33:53.480 --> 33:55.600
ihn zu bauen, bekommt ihn zurück und sieht dann, er geht nicht.

33:55.680 --> 33:59.380
Man probiert das vorher und genau dafür sind diese FPGAs geeignet.

33:59.380 --> 34:04.920
Damit kann man quasi überschaubar günstig ein FPGA-Board kaufen und

34:04.920 --> 34:08.540
dann probieren, funktioniert meine Hardware-Schaltung, bevor ich sie

34:08.540 --> 34:10.340
in die Fertigung gehe, weil das ist wirklich teuer.

34:10.820 --> 34:12.800
Naja, zumindest hatten wir jetzt ein FPGA-Board, es hat

34:12.800 --> 34:15.720
Erweiterungspins und da wollten wir diesen SRAM dran haben, also muss

34:15.720 --> 34:19.600
irgendwo eine Platine her, mit der das verbunden werden kann.

34:20.560 --> 34:24.720
Die Verbindungspins zum FPGA, die sind quasi hier unten drunter, hier

34:24.720 --> 34:27.600
diese Pins, da geht nach unten ein Stecker, da wird das quasi

34:27.600 --> 34:30.760
reingesteckt, das in der Mitte ist halt eben der SRAM-Chip, hier sind

34:30.760 --> 34:33.480
einfach nur einzelne Kondensatoren, das ist quasi die Stromversorgung,

34:33.520 --> 34:36.460
man kann sehen, der hat eine ganze Menge Stromversorgungen, also jedes

34:36.460 --> 34:40.460
von diesen Doppelpaaren von Kondensatoren entkoppelt quasi eine der

34:40.460 --> 34:44.780
Stromversorgungen, entkoppelt im Sinne von, wenn so ein Chip schaltet,

34:44.980 --> 34:48.920
also quasi so einen Taktwechsel hat, dann macht die Logik innen drin

34:48.920 --> 34:53.520
irgendwas, der braucht quasi, wenn der Taktpegel stabil anliegt, macht

34:53.520 --> 34:54.240
das Ding nichts.

34:54.240 --> 34:57.420
Nur beim Wechsel vom Takt kommt eine neue Aufgabe und dann fängt er

34:57.420 --> 34:57.600
an.

34:57.960 --> 35:00.060
Also beim Wechsel vom Takt geht auf einmal der Stromverbrauch so

35:00.060 --> 35:02.560
spitzenmäßig hoch und danach ist wieder Ruhe.

35:02.880 --> 35:06.600
Und diese Ausreißer, dieses starke Wechseln von viel Stromverbrauch zu

35:06.600 --> 35:10.220
normal, das muss man irgendwie, das erzeugt Rauschen im System und

35:10.220 --> 35:12.320
damit das Rauschen sich nicht ausbreitet, muss jeder

35:12.320 --> 35:14.800
Stromversorgungspins entkoppelt werden, das ist genau, was die

35:14.800 --> 35:15.700
Kondensatoren hier machen.

35:16.320 --> 35:18.960
Und dann irgendwo noch dickere Kondensatoren, die halt eben so

35:18.960 --> 35:21.340
grundsätzlich Strom hinzufügen.

35:21.800 --> 35:23.140
Gut, ja, und dann der Chip in der Mitte.

35:23.500 --> 35:26.460
Hier kann man jetzt nur die Stromversorgung sehen, das ist die oberste

35:26.460 --> 35:28.420
Metallebene, das ist eine vierlagige Platine.

35:29.200 --> 35:32.480
Wenn ich die oberste Ebene und den Chip wegnehme, sieht das Ganze so

35:32.480 --> 35:32.820
aus.

35:34.140 --> 35:38.000
Da kann man jetzt sehen, also quasi die oberste Metallebene war nur

35:38.000 --> 35:39.320
Plus Stromversorgung.

35:39.700 --> 35:41.840
Die zweite Metallebene, die kann man hier nicht sehen, die ist

35:41.840 --> 35:43.400
komplett eine große Massefläche.

35:43.820 --> 35:46.780
Die dritte Metallebene, das ist das Orange, da laufen die Leitungen.

35:46.780 --> 35:50.840
Und die vierte Metallebene ist wieder nur einmal groß Ground-Masse.

35:51.940 --> 35:55.680
Und zwar, also wir hatten gerade gesehen, der Chip läuft mit 200 Mhz,

35:56.000 --> 35:57.680
wir benutzen ihn gerade bei 150 Mhz.

35:58.080 --> 36:02.200
Und das ist auch eine Frequenz, die jetzt nicht so mehr normal ist für

36:02.200 --> 36:02.840
einen Informatiker.

36:02.980 --> 36:04.560
Also da fehlten mir doch einiges an Grundlagen.

36:05.220 --> 36:08.240
Zumindest das einfach mal so zusammenbasteln, also das ist die zweite

36:08.240 --> 36:11.480
Version der Platine, einfach mal so zusammenschließen hat überhaupt

36:11.480 --> 36:12.200
nicht funktioniert.

36:12.680 --> 36:16.360
Und zwar bei höherfrequenten Sachen, so auf 100 Mhz, gibt es laut den

36:16.360 --> 36:21.080
E -Technikern irgend so ein Ding, das nennt sich Impedanz, das ist der

36:21.080 --> 36:21.940
Wellenwiderstand.

36:22.320 --> 36:26.140
Also für hochfrequente Signale den Widerstand, den sie sozusagen

36:26.140 --> 36:28.180
sehen, das ist Impedanz.

36:28.580 --> 36:32.440
Und den muss man berücksichtigen bei hochfrequenten Signalen, was mir

36:32.440 --> 36:33.980
vorher auch nicht so richtig klar war.

36:35.040 --> 36:37.960
Zumindest gibt es dann Tools, die sagen einem, pack deine

36:37.960 --> 36:40.760
Signalleitungen in den Ground-Layer ein, also unten Ground, dann

36:40.760 --> 36:44.920
Signal, dann wieder Ground und dann mach die Signalleitungen so und so

36:44.920 --> 36:48.640
dick, dann hast du eine Impedanz von wie viel willst du, 50 Ohm waren

36:48.640 --> 36:48.820
es hier.

36:49.680 --> 36:50.920
Deswegen mussten wir die so einpacken.

36:51.380 --> 36:54.480
Das andere ist halt eben, die Signalleitungen sollten im Idealfall

36:54.480 --> 36:57.620
gleich lang sein, damit es quasi alle gleichzeitig am Chip ankommen

36:57.620 --> 37:02.900
und deswegen diese Mäander, also dieses Hin und Hergewackel, um die

37:02.900 --> 37:04.460
Signalleitungen künstlich länger zu machen.

37:05.760 --> 37:09.380
Irgendwelche, die äußersten hier, die können halt nicht kürzer sein,

37:09.440 --> 37:12.120
weil die müssen irgendwie drumherum und alle anderen, die irgendwie in

37:12.120 --> 37:14.860
der Mitte sitzen halt eben, oder hier sind halt eben auch so Mäander,

37:15.280 --> 37:17.780
die müssen halt irgendwie künstlich verlängert werden, damit am Ende

37:17.780 --> 37:21.100
alle die gleiche Länge in Millimetern haben.

37:23.220 --> 37:26.100
Gut, wenn wir jetzt noch die unterste Ebene wegnehmen, können wir

37:26.100 --> 37:29.100
sehen, hier das schwarze Zeug links am Rand, das sind halt eben dann

37:29.100 --> 37:35.740
die Stecker nach unten, um das Board zu verbinden mit dem FPGA-Board.

37:36.340 --> 37:38.760
Ein Foto habe ich jetzt leider nicht, aber das Board ist hergestellt

37:39.680 --> 37:42.460
und funktioniert momentan sogar wirklich bei 150 Megahertz.

37:44.160 --> 37:45.800
Und zwar können wir das selber herstellen.

37:46.900 --> 37:49.220
Ich bin von den Bussen gerade ganz schön weit weggekommen, aber egal.

37:50.260 --> 37:51.440
Können wir das selber herstellen.

37:51.540 --> 37:55.380
Wir haben im Keller so ein lustiges kleines Labor, wo wir Platinen

37:55.380 --> 37:56.100
fertigen können.

37:56.180 --> 37:59.420
Das ist hier im Wesentlichen so ein Gesamtüberblick von dem gesamten

37:59.420 --> 37:59.740
Labor.

38:00.220 --> 38:03.440
Da gibt es im Wesentlichen erstmal eine Platinenfräse, das ist dieses

38:03.440 --> 38:04.560
Teil hier.

38:05.900 --> 38:12.100
Und das ist quasi hier, das wäre so eine Basisplatine, das ist FR4.

38:12.780 --> 38:16.560
FR4 heißt Feuerresistenz Nummer 4.

38:17.280 --> 38:19.680
Also irgendwie das Basismaterial von diesen Platinen.

38:19.760 --> 38:22.700
Es gibt auch FR1, das ist Pappe, sehr feuerresistente Pappe.

38:24.040 --> 38:27.620
FR4 ist so ein harzgetränktes Glasfaserzeug, also quasi alle Platinen

38:27.620 --> 38:28.340
sind aus FR4.

38:29.220 --> 38:32.900
Da ist oben, unten eine Kupferschicht drauf und dann kommt die in

38:32.900 --> 38:33.680
diese Fräse rein.

38:33.920 --> 38:37.240
Das ist hier quasi ein Vakuumtisch, die saugt die Platine fest.

38:37.800 --> 38:40.600
Und dann ist hier so ein Arbeitskopf, der kann sich von hier hinten,

38:40.660 --> 38:43.920
das ist ein 15-fach-Werkzeugwechsler, kann er sich verschiedene

38:43.920 --> 38:47.620
Bohrer, verschiedene Fräser rauspicken und macht dann da das Kupfer

38:47.620 --> 38:48.620
weg, wo es nicht hin soll.

38:48.620 --> 38:51.160
Und das, was überbleibt, das sind dann die Leiterbahnen.

38:52.080 --> 38:54.620
Und so werden dann quasi die Platinen auf der einen Seite gefräst,

38:54.680 --> 38:56.100
dann kann man sie umdrehen.

38:57.680 --> 39:00.380
Eigentlich ist eingekreist hier eher, dass die Kamera eigentlich nicht

39:00.380 --> 39:01.040
eingekreist habe.

39:01.420 --> 39:03.660
Da ist eine Kamera, die findet dann die Platine wieder, also die

39:03.660 --> 39:05.900
könnte ja ein bisschen anders hingelegt worden sein, kann dann die

39:05.900 --> 39:07.680
Rückseite fräsen.

39:08.280 --> 39:11.820
Und dann haben wir hier dieses Teil hier, das ist eine Presse.

39:12.620 --> 39:15.780
Damit kann man dann mehrere von diesen zweilagigen Platinen, da kommt

39:15.780 --> 39:18.220
so eine Klebe- und Isolationsschicht zwischen, da kann man mehrere

39:18.220 --> 39:19.720
davon zusammenpressen.

39:19.820 --> 39:21.900
Die gerade war halt eben eine vierlagige.

39:23.060 --> 39:26.560
Und da gab es für die Presse ein ganz tolles Zubehör, nämlich eine

39:26.560 --> 39:27.380
Hydraulikpumpe.

39:27.980 --> 39:29.320
Die gab es auch ohne zu kaufen.

39:29.700 --> 39:31.960
Und da hatten sie gesagt, dann muss halt eben jemand daneben stehen

39:31.960 --> 39:34.700
und mit so einem Pumparm diesen Druck aufbauen.

39:35.160 --> 39:37.520
Und irgendwann am Ende gibt es einen Schritt, der heißt Abkühlen, das

39:37.520 --> 39:38.640
wird halt mit Hitze und Druck gemacht.

39:38.980 --> 39:42.480
Und beim Abkühlen, wenn Sachen kalter werden, dann ziehen sie sich

39:42.480 --> 39:43.000
zusammen.

39:43.440 --> 39:46.000
Beim Abkühlen muss also derjenige, der daneben sitzt, den Druck

39:46.000 --> 39:49.840
nachpumpen, weil es zieht sich alles zusammen, der Druck soll konstant

39:49.840 --> 39:50.160
bleiben.

39:50.800 --> 39:53.680
Nee, also wer darauf Lust hat, also dann lieber die Pumpe.

39:55.580 --> 39:56.880
Ja, was gibt es noch?

39:56.920 --> 39:58.900
Das ist einfach so ein kleiner Ofen, um Sachen auszuärten.

39:59.000 --> 40:02.680
Das ist ein UV-Belichter, um halt zum Beispiel hier so Lötstopplack

40:02.680 --> 40:03.920
-Sachen drauf zu belichten.

40:06.740 --> 40:08.940
Und das hier ist für Durchkontaktierungen.

40:08.940 --> 40:11.240
Irgendwie muss man ja die verschiedenen Metallebenen auf den

40:11.240 --> 40:13.960
verschiedenen Kupferplatten verbinden können miteinander.

40:14.540 --> 40:15.640
Und das wird hier chemisch gemacht.

40:16.060 --> 40:18.820
Das sind diese vier verschiedenen Bäder.

40:19.300 --> 40:22.240
Das erste Bad ist einfach nur ein Reinigungsbad, was quasi Fett und

40:22.240 --> 40:23.100
sowas runterholt.

40:23.600 --> 40:27.740
Also dieser Rahmen, den man hier sieht, hier ist quasi so ein

40:27.740 --> 40:28.880
kreisförmiges Ding.

40:29.000 --> 40:30.860
Das dreht sich, also in der Mitte ist eine Drehachse.

40:31.280 --> 40:34.280
Und dann ist halt eben am Rand so ein Pin, der geht nach oben und der

40:34.280 --> 40:35.680
Pin geht in diesen Rahmen rein.

40:35.680 --> 40:38.560
Und dann wird der Rahmen quasi so hin und her gewackelt.

40:38.960 --> 40:41.540
Das ist ein Mechanismus, der wackelt die Platinen in diesem

40:41.540 --> 40:42.820
Flüssigkeitsbad hin und her.

40:43.560 --> 40:45.440
Damit die sich quasi bewegen, damit die Flüssigkeiten überall

40:45.440 --> 40:45.880
hinkommen.

40:46.540 --> 40:51.140
Also im ersten Bad, das ist eine Stunde Wackeln zum Fett entfernen.

40:51.740 --> 40:55.580
Dann kommt im zweiten Bad 15 Minuten Wackeln, um das Putzmittel wieder

40:55.580 --> 40:56.320
zu entfernen.

40:57.060 --> 41:00.720
Das dritte Bad ist 5 Minuten Wackeln, das ist der Aktivierer.

41:01.140 --> 41:05.100
Aktivierer, das ist eine pechschwarze Flüssigkeit, die irgendwie, ich

41:05.100 --> 41:10.340
weiß nicht, was das ist, dafür sorgt, dass eine dünne, leitfähige

41:10.340 --> 41:12.800
Schicht überall über die ganze Platine kommt.

41:14.140 --> 41:16.160
Das muss dann getrocknet werden und sowas.

41:16.520 --> 41:19.700
Und das vierte Bad, wo die eigentliche Durchglattierung passiert.

41:20.100 --> 41:22.680
Ich hätte vielleicht sagen sollen, bevor ich das erste Bad mache, muss

41:22.680 --> 41:24.140
ich halt eben die Durchglattierung bohren.

41:24.200 --> 41:26.680
Ich muss die Bohrlöcher haben, die müssen schon da sein und dann kommt

41:26.680 --> 41:27.100
es hier rein.

41:27.100 --> 41:31.260
Und im letzten Bad, das ist so ein Kupfersulfid.

41:31.360 --> 41:34.860
Das sind hier links und rechts dicke Kupferplatten, also Opferplatten,

41:35.320 --> 41:38.560
wo dann mit 10 Ampere Teilchen rausgerissen werden.

41:38.780 --> 41:41.960
Die lagern sich dann auf der Platine, auf dieser schwarzen Flüssigkeit

41:41.960 --> 41:42.200
an.

41:42.460 --> 41:43.640
Also da wächst Kupfer.

41:44.220 --> 41:46.720
Und da wächst insbesondere eben auch Kupfer durch diese Bohrlöcher

41:46.720 --> 41:47.080
durch.

41:47.380 --> 41:49.360
Und damit werden die Bohrlöcher durchkontaktiert.

41:49.680 --> 41:51.200
Und danach geht es wieder raus in die Fräse.

41:51.460 --> 41:54.640
Dann kann ich halt oben das Kupfer, die Leiterbahn machen sozusagen,

41:54.760 --> 41:55.880
also den Rest Kupfer wegnehmen.

41:55.880 --> 41:59.840
Erst bohren, dann durchkontaktieren und dann eben die Platine fräsen.

42:00.540 --> 42:01.580
Also die konnten wir selber herstellen.

42:01.640 --> 42:03.600
Das ist gerade eine Bachelorarbeit, die gerade läuft.

42:03.960 --> 42:07.360
Die Platine funktioniert inzwischen, ist also demnächst mal fertig.

42:07.560 --> 42:08.960
Ist eine ganz lustige Arbeit geworden.

42:11.980 --> 42:12.260
Gut.

42:13.460 --> 42:14.780
Wer es noch weiß, wir waren bei Bussen.

42:16.820 --> 42:20.080
Wir hatten jetzt schon alle möglichen verschiedene Arten von Bussen

42:20.080 --> 42:20.600
gesehen.

42:20.840 --> 42:23.140
Also diese verschiedenen Taktsachen und so weiter.

42:23.140 --> 42:26.680
Und jetzt gibt es halt eben noch was Multiplex-Bus.

42:27.200 --> 42:30.500
Multiplex ist ja immer so ein Ding, was aus mehreren Eingaben eine

42:30.500 --> 42:32.080
Ausgabe oder sowas aussuchen kann.

42:32.400 --> 42:38.980
Und hier ist eigentlich immer gemeint, ich brauche viele I

42:38.980 --> 42:42.920
.O.-Leitungen, wenn ich Adresse und Daten wirklich parallel von A nach

42:42.920 --> 42:43.620
B bringen will.

42:44.020 --> 42:48.320
Ich habe vielleicht mindestens 20 Adressleitungen, 32 Datenleitungen

42:48.320 --> 42:48.720
oder sowas.

42:48.920 --> 42:49.840
Das ist schon eine Menge Zeug.

42:49.840 --> 42:54.460
Und hier ist die Idee, naja, nehmen wir weniger Datenleitungen und

42:54.460 --> 42:55.540
machen das nacheinander.

42:56.060 --> 43:00.060
Also quasi über die gleiche Leitung schicken wir erst die Adresse und

43:00.060 --> 43:01.200
danach die Daten.

43:01.640 --> 43:04.560
Kostet offensichtlich Zeit, spart aber Leitungen.

43:04.760 --> 43:06.840
Und dann muss man sich überlegen, ob es einem das wert ist.

43:07.260 --> 43:11.500
Und es ist momentan ziemlich üblich, PCI-Bus hat ja sehr, sehr wenig

43:11.500 --> 43:15.380
wirklich physikalische Leitungen, aber jede von diesen Leitungen läuft

43:15.380 --> 43:17.260
auf unglaublichen Taktraten.

43:17.260 --> 43:19.640
Also Gigahertz-Taktrat, ich habe keine Ahnung, wie Sie das machen.

43:20.400 --> 43:21.800
Und deswegen, da funktioniert das halt.

43:21.860 --> 43:25.760
Da kann man ohne Zeitverlust das gut kommunizieren lassen.

43:26.720 --> 43:29.480
Naja, wenn man halt eben erst die Adresse überträgt und danach die

43:29.480 --> 43:32.140
Daten, ist klar, die Adresse muss irgendwo gemerkt werden.

43:32.220 --> 43:35.420
Das macht dann der Empfänger, der muss irgendeinen Flipflop haben und

43:35.420 --> 43:36.300
sich die Adresse merken.

43:37.320 --> 43:38.620
Als Bild könnte das so aussehen.

43:39.120 --> 43:43.060
Wenn das hier die Speichermatrix ist, oben der Adressecoder, dann ist

43:43.060 --> 43:46.200
klar, der braucht von hier irgendwie die Adresse und von da braucht er

43:46.200 --> 43:46.620
die Daten.

43:46.620 --> 43:49.180
Aber jetzt gibt es hier nur einen Bus, der beides gemeinsam

43:49.180 --> 43:49.680
kommuniziert.

43:49.820 --> 43:53.200
Also muss über diesen einen Bus beides nacheinander übertragen werden.

43:54.420 --> 43:57.180
Und da gibt es dann Steuersignale, die sagen, die Daten, die jetzt

43:57.180 --> 44:00.380
gerade auf dem Bus sind, wie sind die zu interpretieren?

44:00.880 --> 44:05.840
Und eines der Steuersignale ist dann das Address Latch Enable, was

44:05.840 --> 44:12.840
diesem Latch sagt, was jetzt gerade anlag, merkt ihr das?

44:13.240 --> 44:15.100
Weil das wird später als Adresse benutzt werden.

44:15.100 --> 44:19.900
Und im Takt- oder Buszyklus danach wird eben wieder eine Übertragung

44:19.900 --> 44:20.220
gemacht.

44:20.340 --> 44:25.740
Diesmal sind es die Daten und dann können die Daten geschrieben werden

44:25.740 --> 44:27.780
an die zuvor gespeicherte Adresse.

44:27.940 --> 44:29.960
Das ist im Wesentlichen die Idee davon.

44:31.640 --> 44:34.360
Lesen im Wesentlichen genauso.

44:34.480 --> 44:38.560
Man muss erst über den einen Bus die Adresse zum Lesen übertragen und

44:38.560 --> 44:42.960
danach über den gleichen Bus die Daten zurück übertragen.

44:48.920 --> 44:52.780
Der Multiplexer ist niemals bidirektional.

44:52.960 --> 44:55.060
Ein Multiplexer geht immer nur in eine Richtung.

44:56.140 --> 44:58.540
Man muss das bidirektional hier können, das ist klar.

44:58.680 --> 45:01.120
Das ist hier bei jedem Datenbus so, nicht nur bei dem hier.

45:01.440 --> 45:03.200
Die Datenleitung geht in beide Richtungen.

45:03.340 --> 45:05.480
Adresse okay, aber Datenleitung geht ja immer in beide Richtungen.

45:06.080 --> 45:07.060
Wie macht man eigentlich bidirektional?

45:08.740 --> 45:11.060
Da gibt es ein Ding für, es heißt Treegate.

45:11.580 --> 45:16.080
Man malt dafür gewöhnlich so ein Dreieck, hat einen Input, einen

45:16.080 --> 45:18.320
Output, dann gibt es noch ein Steuersignal.

45:19.660 --> 45:23.240
Und im Wesentlichen ist das einfach nur, wenn dieses Steuersignal,

45:23.720 --> 45:27.000
nennen wir es mal High Active Enable, dann wenn es eine Eins ist, dann

45:27.000 --> 45:30.000
wird egal was hier ist, wird einfach durchgelassen.

45:30.540 --> 45:36.180
Und wenn das eine Null ist, dann egal was links anliegt, rechts kommt

45:36.180 --> 45:36.940
nichts raus.

45:37.400 --> 45:39.580
Jetzt die Frage, was um alles in der Welt heißt denn nichts

45:39.580 --> 45:40.160
rauskommen?

45:40.160 --> 45:42.860
Es ist Logik, es ist Eins oder Null.

45:43.480 --> 45:45.700
Naja, deswegen heißt das Ding ja Treegate.

45:45.820 --> 45:47.560
Es gibt einen dritten Zustand.

45:47.940 --> 45:52.020
Und der dritte Zustand ist, trenne es physikalisch ab.

45:52.220 --> 45:53.860
Als würde man das Kabel rausziehen.

45:53.940 --> 45:56.440
Dann ist es auch nicht mehr Eins oder Null, es ist einfach mechanisch

45:56.440 --> 45:56.960
getrennt.

45:57.480 --> 45:59.260
Und hier drin ist es halt keine Mechanik.

45:59.460 --> 46:01.040
Es wird auch hochohmig genannt.

46:01.340 --> 46:04.780
Als wäre es verbunden über einen quasi unendlich großen Widerstand.

46:04.780 --> 46:08.400
Und dann hat es halt eben keinen Einfluss mehr, es treibt den Bus

46:08.400 --> 46:09.940
nicht, den Bus, der hier hinterkommt.

46:10.320 --> 46:14.700
Und dann kann halt irgendjemand anders, also wenn wir das hier nochmal

46:14.700 --> 46:22.860
versuchen, was auch immer hier von links reinkam, es kommt nicht raus,

46:22.940 --> 46:23.620
hier ist nur die Leitung.

46:24.040 --> 46:27.780
Jetzt kann also von rechts kommend jemand schreiben und das Schreiben

46:27.780 --> 46:29.820
wird dann quasi hier abgegriffen.

46:30.040 --> 46:34.060
Dann ist hier der Leseport und hier ist der Schreibport.

46:34.060 --> 46:37.320
Und das Triegel in der Mitte sagt dann, soll er lesen oder schreiben.

46:37.420 --> 46:38.460
Welche Richtung geht das gerade?

46:38.680 --> 46:41.620
So kann man das bidirektionell machen, aber das kommt definitiv nach

46:41.620 --> 46:42.520
dem Multiplexer.

46:46.580 --> 46:47.540
Gut, Zeitverhalten.

46:48.360 --> 46:52.220
Wir haben jetzt hier mehrere Buszyklen und hier ist jetzt ganz klar zu

46:52.220 --> 46:54.800
sehen, es gibt einen gemeinsamen Adress-Datenbus.

46:56.200 --> 47:00.680
Es gibt hier einen Steuersignal, das heißt jetzt ist die Adresse

47:00.680 --> 47:02.060
gültig, also Let's Enable.

47:03.500 --> 47:07.780
Am Anfang wird die Adresse übertragen, das Let's Enable hat irgendwann

47:07.780 --> 47:08.700
einen High-Pegel.

47:08.880 --> 47:11.000
Dann nochmal, das ist wie Phone, das ist bei der Falling Edge.

47:12.920 --> 47:16.400
Bei der Falling Edge die Daten übernimmt, eigentlich müsste es hier

47:16.400 --> 47:17.480
die Daten übernehmen.

47:17.760 --> 47:21.280
Hier werden die Daten dann übernommen, kurz danach werden sie intern

47:21.280 --> 47:21.720
sichtbar.

47:21.860 --> 47:23.900
Das ist hier, was dann intern in diesem Let's Enable Register

47:23.900 --> 47:25.160
verfügbar ist.

47:25.700 --> 47:29.680
Und dann werden danach die Daten auf dem gleichen Bus gelegt, das ist

47:29.680 --> 47:32.460
jetzt lesen oder schreiben, das ist egal, und werden dann auch

47:32.460 --> 47:34.660
entsprechend übernommen oder zurückgeliefert.

47:37.940 --> 47:42.740
Ja, Address Trope hatten wir, glaube ich, auch schon gesehen, oder?

47:42.840 --> 47:44.500
Also, dass jetzt die Daten gültig sind.

47:44.840 --> 47:46.880
Also, das sind verschiedene Namen für das Gleiche.

47:47.040 --> 47:49.200
Valid Memory Address sagt genau das Gleiche.

47:49.300 --> 47:52.460
Address Let's Enable, die gleiche Idee, verschiedene Namen.

47:55.600 --> 47:59.460
Ach so, man kann auch diese Multiplex-Technologie, also wenn man das

47:59.460 --> 48:00.940
schon hat, kann man es auch für andere Sachen benutzen.

48:01.020 --> 48:04.520
Hier war es jetzt Adress und Daten nacheinander, aber je nachdem, wie

48:04.520 --> 48:08.140
wenige Leitungen man hat, könnte man ja auch sagen, vielleicht will

48:08.140 --> 48:09.380
ich sogar noch weiter trennen.

48:09.480 --> 48:13.840
Vielleicht will ich erst die höherwertigen Adressbilds, danach die

48:13.840 --> 48:16.400
niederwertigen Adressbilds und danach kommen die Daten.

48:16.560 --> 48:18.520
Also, ich kann das in noch mehr Takte aufspalten.

48:19.160 --> 48:22.320
Oder vielleicht habe ich halt eben einen Adressbus, der zu klein ist

48:22.320 --> 48:24.500
und muss den zweimal benutzen, aber den Datenbus habe ich parallel.

48:24.680 --> 48:27.780
Also, da gibt es verschiedene Formen, wie man das zusammenmischen

48:27.780 --> 48:28.120
kann.

48:32.750 --> 48:35.870
Gut, dann gibt es verschiedene Systemsteuerbausteine.

48:36.050 --> 48:38.750
Also, Bausteine ignorieren wir gleich wieder, aber Steuer ist das

48:38.750 --> 48:39.970
Ding, was wir jetzt angucken wollen.

48:41.550 --> 48:45.850
Hier ist die Idee jetzt, also, das sind jetzt quasi typische

48:45.850 --> 48:48.290
Komponenten, die am Bus dranhängen.

48:48.290 --> 48:50.690
Wir haben uns Bus verschiedene Protokolle angeschaut, es gibt tausend

48:50.690 --> 48:51.930
weitere, aber so übliche.

48:52.570 --> 48:54.910
Und jetzt, was gibt es denn so, was am Bus alles dranhängt?

48:55.290 --> 48:56.870
Und das sind für gewöhnlich solche Sachen.

48:57.430 --> 48:59.670
Und die gibt es auch immer noch, nur dass halt eben inzwischen keine

48:59.670 --> 49:01.830
externen Bausteine mehr sind, sondern auf dem gleichen Chip.

49:02.370 --> 49:05.450
Jeder braucht irgendwo einen Takt, der muss irgendwie erzeugt werden,

49:05.550 --> 49:08.050
das ist irgendwie so ein analoges Ding, was einen Takt generiert und

49:08.050 --> 49:10.970
dann wird verteilt über den Chip, über die Platine oder was auch immer

49:10.970 --> 49:11.270
man hat.

49:13.710 --> 49:17.330
Ein Steuerbaustein, das ist quasi so eine Art Adapter.

49:17.330 --> 49:22.050
Ich habe irgendwo meinen Peripherie, meinen SRAM und der ist noch

49:22.050 --> 49:25.110
unabhängig davon, mit welchem Bus er mal betrieben werden soll.

49:25.570 --> 49:30.090
Und der Bussteuerbaustein ist quasi ein Adapter, der den SRAM an das

49:30.090 --> 49:32.670
Busprotokoll, was gerade benutzt wird, anbindet.

49:32.770 --> 49:34.090
Das war so im Wesentlichen die Idee davon.

49:36.670 --> 49:42.470
Ein Busarbeiter ist jemand, also jemand ist ein Stück Hardware.

49:43.370 --> 49:48.210
Wenn es mehrere Master am Bus gibt, im Sinne von, bisher hatten wir

49:48.210 --> 49:50.850
eigentlich immer so überlegt, so eine CPU und das war es.

49:51.130 --> 49:53.930
Aber warum nicht mal zwei oder drei CPUs am gleichen Bus hängen,

49:53.990 --> 49:54.570
verbietet ja niemand.

49:55.150 --> 49:58.470
Wenn es jetzt mehrere CPUs am Bus gibt, dann könnten die auch

49:58.470 --> 50:00.710
gleichzeitig versuchen, auf den Bus zuzugreifen.

50:00.870 --> 50:03.570
Das geht aber nicht, der Bus kann immer nur einen Zugriff gleichzeitig

50:03.570 --> 50:03.990
erlauben.

50:04.430 --> 50:06.730
Also er hat nicht genug Ressourcen, nicht genug Leitungen, um mehrere

50:06.730 --> 50:07.510
Zugriffe zu machen.

50:07.510 --> 50:12.310
Und wenn dann mehrere Master im System hängen, mehrere CPUs, dann muss

50:12.310 --> 50:14.810
es jemanden geben, der entscheidet, wer darf wann.

50:15.510 --> 50:16.290
Das ist der Arbeiter.

50:16.890 --> 50:19.030
Der hat innen drin eine Policy, da kann man manchmal vielleicht

50:19.030 --> 50:21.570
Prioritäten einstellen, welche von diesen Komponenten wichtiger ist

50:21.570 --> 50:22.170
als die andere.

50:22.550 --> 50:25.190
Und die entscheidet dann, du wolltest einen Buszugriff machen?

50:25.390 --> 50:26.750
Nee, warte mal, du wolltest einen machen?

50:27.050 --> 50:27.770
Bitte, go ahead.

50:29.070 --> 50:32.450
Dann gibt es da eben Beispiele für Peripherien, zum Beispiel deren

50:32.450 --> 50:32.970
Controller.

50:33.830 --> 50:37.970
Das ist ein Beispiel für eine Peripherie.

50:40.330 --> 50:41.390
Und noch mehr Beispiele.

50:43.250 --> 50:45.770
DMA-Controller, wie gesagt, so viel kommt dazu nicht mehr, das Wort

50:45.770 --> 50:47.090
taucht nachher nochmal auf, da habe ich noch einen Punkt

50:47.090 --> 50:47.590
hingeschrieben.

50:48.670 --> 50:51.210
Cache -Controller könnte man sich vorstellen, MMU könnte man sich

50:51.210 --> 50:51.630
vorstellen.

50:51.870 --> 50:55.630
Also je nachdem, welche von denen jetzt näher am Bus dran ist.

50:55.770 --> 50:58.650
Der Letzte, der am Bus dran ist, der redet mit dem Bus.

50:58.650 --> 51:05.290
Was es häufig aber gibt, sind Timer, die haben eine gewisse Referenz

51:05.290 --> 51:08.010
-Clock, die ist unabhängig von der System-Clock normalerweise, könnte

51:08.010 --> 51:08.710
auch die gleiche sein.

51:09.390 --> 51:13.830
Zumindest, die zählen hoch auf eine bekannte Art und Weise, so dass

51:13.830 --> 51:16.170
man die Zeit, die Uhrzeit daraus ableiten kann.

51:17.490 --> 51:21.210
Oder sie zählen hoch einfach den System-Takt und sagen einem, das hat

51:21.210 --> 51:24.430
jetzt 100 Takte gedauert, seitdem du letztes Mal gefragt hast.

51:24.930 --> 51:26.270
Für solche Sachen kann man die benutzen.

51:27.570 --> 51:31.230
Echtzeit-Uhren, das ist eher dann, wenn es sich wirklich mit einer

51:31.230 --> 51:38.690
Funkuhr quasi synchronisiert, um den aktuellen System-Uhrzeitszustand

51:38.690 --> 51:39.250
zu wissen.

51:40.390 --> 51:42.730
Erbrechungsbausteine, Interrupts kommen später noch, das sehen wir

51:42.730 --> 51:43.410
dann nochmal genauer.

51:45.690 --> 51:47.710
Gut, das sind alles Sachen, die am Bus hängen können.

51:47.810 --> 51:50.770
Dazwischen, wie gesagt, diese Verbindungsdinger, also Schnittstellen,

51:50.930 --> 51:53.590
das sind Schnittstellen für nach außen, das sind Peripherien nach

51:53.590 --> 51:53.910
außen.

51:55.230 --> 51:59.250
Zum Beispiel irgendwelche Ausgabedaten, wo dann die Geschwindigkeit

51:59.250 --> 52:02.450
angepasst werden muss, parallel, seriell.

52:03.030 --> 52:07.310
Also was es da vielleicht erwähnenswert ist, gibt auch bei PCI

52:07.310 --> 52:10.070
-Express, wo man es vorhin schon gesehen hat, da stand PCI, aber egal,

52:10.130 --> 52:11.430
Express eigentlich im Speziellen.

52:12.750 --> 52:16.470
Es sind ja sehr wenig Leitungen, die da physikalisch vorhanden sind,

52:16.550 --> 52:18.010
aber trotzdem wieder eine Menge Daten rüber.

52:18.010 --> 52:22.130
Also in der Hardware innen drin wird alles möglichst parallel

52:22.130 --> 52:26.510
verarbeitet, weil parallel braucht weniger hohe Taktfrequenzen, hohe

52:26.510 --> 52:28.230
Taktfrequenzen ist nicht gut für den Stromverbrauch.

52:28.690 --> 52:31.290
Also in der Hardware wird es parallel verarbeitet, aber die

52:31.290 --> 52:34.490
Übertragung, die wird dann häufig seriell gemacht, weil man mit

52:34.490 --> 52:37.990
wenigen Leitungen, kann man gut hohe Frequenzen fahren.

52:38.110 --> 52:41.870
Man kann auf großen Bussen, sagen wir mal so einen 32-Bit-Bus, den

52:41.870 --> 52:43.610
kann man nicht mit einer hohen Frequenz betreiben.

52:43.610 --> 52:45.430
Das würde dauernd zu Übersprechern kommen.

52:45.750 --> 52:49.170
Also quasi wenn eine Leitung von dem Bus 0.1 Wechsel hat, würde sich

52:49.170 --> 52:51.810
das auswirken auf die räumlich benachbarten Leitungen.

52:52.230 --> 52:55.350
Aber bei seriellen Bussen, also so ein, zwei Pins, kann man sehr, sehr

52:55.350 --> 52:56.230
hohe Frequenzen fahren.

52:56.550 --> 52:58.990
Und dann gibt es die Hardware-Bausteine, die müssen übersetzt werden

52:58.990 --> 53:02.310
von parallel im Chip zu seriell außerhalb vom Chip.

53:02.810 --> 53:07.050
Das sind sozusagen SerDes, also Seriell Deserialisierer.

53:08.150 --> 53:10.610
Also Serialisierer oder Deserialisierer.

53:11.170 --> 53:14.410
Die gibt es dann bei den IO-Pins, die sehen aus, als würde man da 8

53:14.410 --> 53:17.150
-Bit reinschreiben, aber in Wirklichkeit kommt dann auf einem IO-Pin

53:17.150 --> 53:20.210
mit einer 8-fach höheren Frequenz die Daten dann seriell raus.

53:24.330 --> 53:27.130
Steuer-Signale, Unterbrechungsanforderungen, okay, das sehen wir aber

53:27.130 --> 53:27.650
später noch.

53:28.930 --> 53:34.090
Und das sind im Wesentlichen so typische Bausteine, die irgendwie in

53:34.090 --> 53:36.590
quasi jedem System in irgendeiner Form drinstecken.

53:37.790 --> 53:39.750
Hier war die Bildlicht mal angedeutet.

53:41.170 --> 53:45.330
Der Kasten soll hier im Wesentlichen andeuten, das sind die System

53:45.330 --> 53:46.050
-Bausteine.

53:47.350 --> 53:51.450
Eigentlich könnte man sagen, das ist quasi alles auf dem gleichen

53:51.450 --> 53:51.730
Chip.

53:51.850 --> 53:54.670
Wenn man mal heute einen Chip malen würde, dann würde das im

53:54.670 --> 53:59.610
Wesentlichen fast alles umfassen, außer vielleicht den Hauptspeicher.

53:59.610 --> 54:03.830
Der ist dann doch meistens auf einem Extra-Chip außen, also ein DRAM

54:03.830 --> 54:04.950
-Chip, der noch dazukommt.

54:05.410 --> 54:09.390
Oder es gibt auch Mikrocontroller, wo zum Beispiel ein bisschen

54:09.390 --> 54:10.830
Speicher ist auf dem Chip mit drauf.

54:11.090 --> 54:12.650
Wenn das reicht, juhu, also z.B.

54:12.670 --> 54:13.410
echt nur kiloweit.

54:13.850 --> 54:16.210
Und wenn das nicht reicht, dann haben die halt eine Möglichkeit, um

54:16.210 --> 54:17.890
den externen Speicher noch anzuschließen.

54:17.990 --> 54:20.590
Also es ist teilweise mit drauf, teilweise nicht mit drauf.

54:20.590 --> 54:23.870
Aber die Komponenten an sich, also hier Analog-Digital-Wendler,

54:24.050 --> 54:27.630
umgekehrt Serienstützstellen, auch kein Mensch, Intercontroller, DMA,

54:27.930 --> 54:31.730
das ist alles noch so vorhanden, nur eben integriert.

54:35.230 --> 54:39.050
Wenn wir jetzt diese ganzen Peripherien haben, wie reden wir mit

54:39.050 --> 54:39.310
denen?

54:39.710 --> 54:40.850
Also okay, über den Bus.

54:41.430 --> 54:44.050
Aber an welcher Adresse?

54:44.410 --> 54:45.590
Wie sprechen wir die an?

54:45.590 --> 54:47.990
Da gibt es zwei verschiedene Arten.

54:49.370 --> 54:53.190
Einmal die eigentlich fast normalere, ist die speicherbezogene

54:53.190 --> 54:53.830
Adressierung.

54:53.990 --> 54:56.050
Wobei normal kommt immer darauf an, was man gewohnt ist.

54:57.670 --> 55:01.430
Memory-Mapped-IO heißt im Wesentlichen, ich habe eine neue Peripherie,

55:01.750 --> 55:03.930
vielleicht als externe Steckkarte, vielleicht einfach nur als

55:03.930 --> 55:06.130
Komponente, die ich in meinen Chip schon von Anfang an mit eingebaut

55:06.130 --> 55:06.450
habe.

55:07.130 --> 55:11.650
Die hänge ich an den Bus dran und ich sage ihr, also beim Entwurf,

55:11.790 --> 55:18.090
beim reinstecken, konfiguriert, sage ich ihr, du, Komponente, hörst

55:18.090 --> 55:19.890
auf folgenden Adressbereich.

55:20.470 --> 55:26.090
Du hörst auf alle Adressen, beginnt bei 0xf, alles Nullen, bis 0xf und

55:26.090 --> 55:27.570
dann wie viele Adressen sie halt eben hat.

55:28.330 --> 55:30.630
Und das sagt man nicht nur der Komponente, das sagt man eben auch dem

55:30.630 --> 55:32.950
Bus -Controller oder dem Bus-Arbiter.

55:33.290 --> 55:37.430
Damit er weiß, ja, die Adresse gibt es und das ist eine gültige

55:37.430 --> 55:38.250
Anfrage gewesen.

55:38.810 --> 55:42.430
Und dann hängen diese Geräte halt eben am Bus, lauschen die ganze Zeit

55:42.430 --> 55:42.970
an der Adresse.

55:43.110 --> 55:45.710
Ich meine, alle von diesen Geräten hängen am Bus und lauschen auf die

55:45.710 --> 55:46.050
Adresse.

55:46.630 --> 55:49.410
Und gucken halt, ist die Adresse, hat der mich gemeint?

55:49.610 --> 55:51.970
Wenn nein, dann irgendwer anders wird schon antworten.

55:52.350 --> 55:55.190
Und wenn ja, das heißt halt eben, jetzt mach was.

55:55.350 --> 55:57.950
Jetzt musst du halt eben die anderen Steuersignale angucken und darauf

55:57.950 --> 55:58.450
reagieren.

55:59.730 --> 56:00.690
Das ist die eine Variante.

56:01.130 --> 56:06.050
Und die andere Variante, isolierte Adressierung, ist fast dasselbe.

56:07.110 --> 56:11.050
Hier gibt es von der Idee her zwei verschiedene Adressräume.

56:11.250 --> 56:15.690
Also den einen Adressraum für Speicher und den anderen Adressraum, wo

56:15.690 --> 56:17.230
die ganzen Peripherien drin hängen.

56:17.990 --> 56:22.050
Und dann gibt es halt ein spezielles Auswählsignal, mit dem gesagt

56:22.050 --> 56:26.330
wird, die Adresse, die gerade angelegt, ist da gemeint, dass der

56:26.330 --> 56:29.850
Speicher -Adressraum angesprochen werden soll?

56:30.410 --> 56:34.610
Oder ist gemeint, dass der Peripherie, der IO-Adressraum angesprochen

56:34.610 --> 56:35.210
werden soll?

56:37.010 --> 56:40.630
Ist insofern fast dasselbe, als dass man sich dieses Signal auch

56:40.630 --> 56:41.110
einfach...

56:41.110 --> 56:43.570
Sagen wir mal, ich habe ein 32-Bit-Adressbus, dann kann ich mir dieses

56:43.570 --> 56:45.430
Signal auch als 33-Bit vorstellen.

56:45.570 --> 56:47.350
Dann habe ich auch zwei getrennte Adressräume.

56:47.430 --> 56:51.110
Einmal mit dem 33-Bit auf 1, einmal mit dem 33-Bit auf 0 und danach

56:51.110 --> 56:52.890
sind es zwei verschiedene Adressräume.

56:55.730 --> 56:57.070
Bildlich sieht das Ganze so aus.

56:57.530 --> 57:00.210
Bei der speicherbezogen ist es quasi für gewöhnlich...

57:00.210 --> 57:04.370
Wenn es geht, viele Peripherien zusammen in einem nahe

57:04.370 --> 57:05.510
zusammenhängenden Bereich.

57:05.950 --> 57:08.870
Der Bereich ist dann eben nicht mehr für normale Speichersachen

57:08.870 --> 57:12.630
vorgesehen, sondern nur noch für diese Peripherien, die darauf

57:12.630 --> 57:16.290
herrschen und der Rest ist normaler Speicherraum.

57:16.730 --> 57:20.350
Und hier ist eben diese Trennung nochmal angedeutet, wo es eben ein

57:20.350 --> 57:24.570
Steuersignal gibt, was unterscheidet, wie die Adresse zu

57:24.570 --> 57:25.210
interpretieren ist.

57:25.270 --> 57:26.690
Soll sie hier hin oder soll sie da hin?

57:28.550 --> 57:35.090
Wo man das unterschiedlich machen kann, ist vielleicht Sachen, die

57:35.090 --> 57:36.090
hier drin hängen.

57:36.310 --> 57:39.390
Ich meine, ich habe ja vorhin gesagt, die Peripherien hängen die ganze

57:39.390 --> 57:41.050
Zeit und lauschen am Bus.

57:41.790 --> 57:44.530
Also wenn da jetzt irgendwer böswillig ist und vielleicht mithören

57:44.530 --> 57:48.210
will, was ist, wenn ich es dediziert hierhin schicke, dann bekommt er

57:48.210 --> 57:48.770
das nicht mit.

57:49.370 --> 57:52.730
Das könnte vielleicht ein Unterschied sein, aber prinzipiell ist es

57:52.730 --> 57:53.670
einfach eine Definitionssache.

57:53.670 --> 57:56.070
Man macht so oder so, Hauptsache danach halten sich alle daran.

57:56.390 --> 57:57.890
Also alle in dem einen System zumindest.

58:01.250 --> 58:03.550
Gut, das sind die Sachen, die ich gerade gesagt hatte.

58:04.870 --> 58:11.750
Okay, ein weiterer Punkt bei Bussen ist, dass angeblich noch sehr,

58:11.970 --> 58:18.450
sehr viele Schnittstellen, Bausteine einen 8-Bit-Datenbus haben.

58:19.290 --> 58:21.450
Also ob das jetzt so, wer weiß.

58:21.450 --> 58:24.170
Aber prinzipiell ist das, dass das Problem existiert.

58:25.810 --> 58:29.370
Die Bausteine haben halt einen Datenbus, der so breit ist, wie für sie

58:29.370 --> 58:29.870
hilfreich.

58:30.270 --> 58:33.150
Der SRAM-Chip gerade, dann gab es dann drei verschiedene Varianten zu

58:33.150 --> 58:33.330
kaufen.

58:33.430 --> 58:36.350
Die gab es zu kaufen mit einem 8-Bit-Port, mit einem 16-Bit-Port und

58:36.350 --> 58:37.070
mit einem 32-Bit-Port.

58:37.530 --> 58:39.950
Also eigentlich waren es 9 und 18 und 36, da ist doch so ein

58:39.950 --> 58:40.650
Paritätsbit dabei.

58:41.170 --> 58:44.070
Also es gab dann verschiedene Varianten zu kaufen, die halt

58:44.070 --> 58:45.710
verschiedene breite Datenbusse haben.

58:46.470 --> 58:48.110
Dann konnte man sich aussuchen, welchen man haben will.

58:48.170 --> 58:50.210
Aber es gibt halt nicht unbedingt den, den man gerade braucht.

58:50.210 --> 58:55.210
Das heißt, man muss irgendwie in der Lage sein, Peripherien, wo der

58:55.210 --> 58:59.730
Datenbus, also die Datenbusbreite nicht passt, die Datenbusbreite von

58:59.730 --> 59:03.390
dem Gesamtsystem, die müssen irgendwie zusammengebracht werden können.

59:05.010 --> 59:09.510
Häufig gibt es dann diese Byte-Enable-Signale, die sagen, bei

59:09.510 --> 59:15.110
folgendem Zugriff sind nicht alle Datenwörter zu verarbeiten, sondern

59:15.110 --> 59:17.030
nur eine gewisse Menge an Bytes.

59:17.030 --> 59:21.770
Dann gibt es halt eben zum Beispiel, wenn es ein 32-Bit-Bus oder wenn

59:21.770 --> 59:26.930
es ein 64-Bit-Bus ist, gibt es dann so und so viele, so 4 oder 8 Byte

59:26.930 --> 59:30.230
-Enable -Signale, die halt sagen, folgendes Byte ist als ernst zu

59:30.230 --> 59:32.090
betrachten und die anderen bitteschön ignorieren.

59:34.570 --> 59:39.250
Hier haben wir mal so ein Beispiel, das wäre jetzt ein 32-Bit-CPU mit

59:39.250 --> 59:45.110
einem 32-Bit-Bus und einer 8-Bit-Komponente, die man irgendwie

59:45.110 --> 59:46.170
zusammenbringen muss.

59:46.170 --> 59:50.490
Und was dieses Bild im Wesentlichen noch versucht zu sagen ist, dass

59:50.490 --> 59:54.950
man tatsächlich sogar mehrere von diesen Byte-Übertragungen auch

59:54.950 --> 59:56.050
gleichzeitig machen kann.

59:57.550 --> 01:00:02.050
Das könnten jetzt verschiedene Peripherien sein oder verschiedene

01:00:02.050 --> 01:00:05.330
Register in dem gleichen Peripherie, das ist jetzt hier egal.

01:00:06.350 --> 01:00:09.830
Aber was hier zu sehen ist, ist diese vier verschiedenen Bytes, die

01:00:09.830 --> 01:00:14.690
quasi hier so angedeutet sind, vier verschiedene Bytes.

01:00:15.970 --> 01:00:22.310
Das könnte zum Beispiel so sein, dass das eine Byte immer von ihm

01:00:22.310 --> 01:00:25.550
gelesen wird und irgendeines der anderen Bytes wird immer von ihm

01:00:25.550 --> 01:00:25.890
gelesen.

01:00:26.010 --> 01:00:29.230
Also die könnten zum Beispiel auf die gleiche Adresse hören, dann habe

01:00:29.230 --> 01:00:34.270
ich vielleicht vier SRAM-Chips, die jeweils 8-Bit-Datenbus haben und

01:00:34.270 --> 01:00:38.070
die sage ich, hört mal auf die gleiche Adresse und dann muss ich die

01:00:38.070 --> 01:00:43.350
nur noch anschließen an das richtige Feld von den 32 Bits.

01:00:43.890 --> 01:00:49.530
Zum Beispiel scheint der hier an diese Bits 9-15 oder 8-15

01:00:49.530 --> 01:00:55.790
angeschlossen zu sein und der hier oben halt eben an 16-23

01:00:55.790 --> 01:00:56.330
angeschlossen.

01:00:57.170 --> 01:01:02.570
Und wenn ich halt eben nur eine Komponente habe, also nicht alle Bytes

01:01:02.570 --> 01:01:05.590
wirklich gültig sind, dann gibt es halt eben die Byte-Enable-Signale,

01:01:05.830 --> 01:01:08.510
die halt sagen können, welches von den Bytes eigentlich genommen

01:01:08.510 --> 01:01:09.130
werden soll.

01:01:10.030 --> 01:01:13.390
Hier zum Beispiel war jetzt einfach Byte 2 ausgewählt, also das wäre

01:01:13.390 --> 01:01:18.030
die Idee, dass die Komponente prinzipiell ihre Inputs von allen Bytes

01:01:18.030 --> 01:01:19.190
entgegennehmen könnte.

01:01:19.190 --> 01:01:22.870
Dann muss es halt eben auch hier innen drin oder am Übergang hier

01:01:22.870 --> 01:01:25.950
einen Multiplexer geben, der sagt, ich will nicht das 0., das 1., ich

01:01:25.950 --> 01:01:26.790
will das 2.

01:01:26.950 --> 01:01:28.270
Byte entgegennehmen.

01:01:30.490 --> 01:01:32.990
Gut, und so kann man die einfach zusammenschalten.

01:01:37.050 --> 01:01:41.350
Ja, jetzt eine Peripherie-Komponente am Bus.

01:01:41.810 --> 01:01:44.570
Also das hier ist die Schnittstelle nach außen, die Bus-Schnittstelle,

01:01:45.390 --> 01:01:49.470
und das hier ist die Schnittstelle zur eigentlichen Peripherie, zum

01:01:49.470 --> 01:01:51.650
SRAM, was auch immer die Peripherie ist.

01:01:51.650 --> 01:01:54.850
Und dann ist dazwischen so ein Verbindungs-Dingsy.

01:01:55.250 --> 01:01:57.910
Und das wäre dann, was dieses Bild hier im Wesentlichen in groß zeigt.

01:01:58.670 --> 01:02:03.510
Was hier angedeutet ist, ist einmal, der Datenbus kann erstmal

01:02:03.510 --> 01:02:04.410
entgegengenommen werden.

01:02:04.750 --> 01:02:09.050
Das Wichtige ist eigentlich, es gibt hier verschiedene Register und es

01:02:09.050 --> 01:02:15.010
gibt hier ein Steuerwerk, mit dem man konfigurieren kann, wie diese

01:02:15.010 --> 01:02:16.670
Komponente mit dem Bus reden soll.

01:02:16.670 --> 01:02:21.050
Also die ist erstmal dafür verantwortlich, das konkrete für jetzt den

01:02:21.050 --> 01:02:25.370
Einsatzzweck benutzte Bus-Protokoll wirklich zu sprechen, zu

01:02:25.370 --> 01:02:25.670
verstehen.

01:02:26.210 --> 01:02:29.630
Das muss auf Systemtakt-Ebene laufen, das hat die bekannten Signale

01:02:29.630 --> 01:02:31.410
Read, Write, Ready, Address.

01:02:31.410 --> 01:02:33.690
Jetzt haben wir hier noch ein Chip-Select-Signal.

01:02:34.170 --> 01:02:36.630
Chip-Select ist einfach nur, das hatte ich vorhin schon mal kurz

01:02:36.630 --> 01:02:39.090
erwähnt, geh an oder geh aus.

01:02:39.370 --> 01:02:41.370
Also ich brauche gerade keiner, ich kann schlafen gehen.

01:02:41.950 --> 01:02:43.630
Da wäre es mit dem Chip, es ist halt nicht selected.

01:02:43.950 --> 01:02:46.490
Es gibt aber auch ein Reset-Signal, was es eigentlich immer global für

01:02:46.490 --> 01:02:46.950
alle gibt.

01:02:47.290 --> 01:02:50.810
Und es gibt eben auch Interrupts, die eingehen können von außen, also

01:02:50.810 --> 01:02:52.310
einen Wunsch, mach mal was.

01:02:53.130 --> 01:02:56.990
Oder die ausgeschickt werden können im Sinne von irgendwann früher kam

01:02:56.990 --> 01:02:59.410
eine Anfrage, jetzt ist sie fertig, da wird jetzt ein Interrupt

01:02:59.410 --> 01:03:00.990
abgeschickt, ich habe es inzwischen erledigt.

01:03:02.150 --> 01:03:06.090
Und dann kann man halt eben hier mit diesen Registern steuern, was das

01:03:06.090 --> 01:03:07.570
Steuerwerk genau tun soll.

01:03:07.710 --> 01:03:11.190
Also Varianten vom Protokoll einstellen, solche Sachen.

01:03:11.190 --> 01:03:14.670
Und dann gibt es die eigentliche Ausführungseinheit, also wir reden

01:03:14.670 --> 01:03:17.250
jetzt nicht von der CPU, das ist jetzt nicht eine Ausführungseinheit

01:03:17.250 --> 01:03:18.150
von der CPU oder sowas.

01:03:18.430 --> 01:03:21.790
Das ist jetzt eine Ausführungseinheit, die die Verbindung zu der

01:03:21.790 --> 01:03:23.790
eigentlichen Peripherie steuert.

01:03:23.870 --> 01:03:29.590
Hier ist die Schnittstelle zum Peripheriegerät, die macht dann

01:03:29.590 --> 01:03:33.250
wirklich den Datentransfer vom Datenbus hier.

01:03:34.010 --> 01:03:38.110
Also ein Adapter, der vermitteln muss zwischen wie funktioniert die

01:03:38.110 --> 01:03:39.710
Peripherie, wie funktioniert der Bus.

01:03:44.490 --> 01:03:46.350
Mal sehen, irgendwas vergessen.

01:03:48.270 --> 01:03:48.930
Ne, passt.

01:03:52.210 --> 01:03:56.330
Bildlich, hier hätten wir jetzt quasi die CPU, das hier ist der Bus,

01:03:56.590 --> 01:03:59.130
in dem Fall jetzt nur mit einer Komponente, nämlich die

01:03:59.130 --> 01:04:03.130
Schnittstellenkomponente und dann hier Peripheriegeräte.

01:04:04.930 --> 01:04:09.070
Vorhin haben wir quasi diesen Teil hier im Zoomout gesehen, das ist

01:04:09.070 --> 01:04:11.470
dann das Big Picture, wie es zusammen angeschlossen ist.

01:04:11.470 --> 01:04:15.390
Also das Ding vermittelt zwischen dem Protokoll hier auf der linken

01:04:15.390 --> 01:04:18.830
Seite und dem Protokoll hier auf der rechten Seite, da hängt es quasi

01:04:18.830 --> 01:04:19.470
dazwischen.

01:04:23.530 --> 01:04:26.510
Datenleitungen, die können unidirektional sein, also nur in eine

01:04:26.510 --> 01:04:28.410
Richtung, bidirektional in beide Richtungen, die können parallel

01:04:28.410 --> 01:04:30.630
seriell sein, das muss alles angepasst werden.

01:04:31.010 --> 01:04:33.590
Steuerleitungen müssen angepasst werden, also Meldeleitungen, also

01:04:33.590 --> 01:04:37.870
Steuerleitung ist immer die Idee von der CPU zur Peripherie, die CPU

01:04:37.870 --> 01:04:41.770
steuert die Peripherie und umgekehrt, die Peripherie meldet zurück,

01:04:41.950 --> 01:04:42.670
wie der Status ist.

01:04:42.670 --> 01:04:44.790
Also ist dasselbe, nur verschiedene Richtungen sozusagen.

01:04:48.310 --> 01:04:54.030
Gut, jetzt haben wir die Peripherie angeschlossen an den Bus, zum

01:04:54.030 --> 01:04:55.210
Beispiel Memorymapped.

01:04:56.250 --> 01:05:00.010
Jetzt ist sie physikalisch ansprechbar, jetzt müssen wir aber

01:05:00.010 --> 01:05:02.790
irgendwann mal den Schritt nach oben in die Softwareebene machen, wie

01:05:02.790 --> 01:05:04.050
spreche ich sie denn jetzt an?

01:05:04.050 --> 01:05:07.190
Okay, Memorymapped, also ich kann offenbar ein Loadstore an eine

01:05:07.190 --> 01:05:08.810
gewisse Adresse, wird wohl ankommen.

01:05:09.230 --> 01:05:13.130
Und das ist auch genau, was die erste Variante, von deren drei es

01:05:13.130 --> 01:05:14.150
gibt, macht.

01:05:17.470 --> 01:05:22.730
Die Peripherie hat ein Statusregister, in dem drinsteht, was macht sie

01:05:22.730 --> 01:05:22.990
gerade?

01:05:23.310 --> 01:05:25.550
Ist sie fertig mit dem, was sie wollte oder nicht?

01:05:25.550 --> 01:05:27.410
Also, wenn es ein Bus,

01:05:30.670 --> 01:05:33.210
hier hatten wir ja auch ein Ready-Signal.

01:05:34.870 --> 01:05:39.310
Die Idee ist hier, ich habe diesen Verbindungsblock, diese

01:05:39.310 --> 01:05:42.290
Verbindungsschnittstelle, ich rede mit dieser

01:05:42.290 --> 01:05:42.570
Verbindungsschnittstelle.

01:05:44.190 --> 01:05:47.390
Das führt dazu, dass das, was ich tun möchte, in der

01:05:47.390 --> 01:05:52.230
Verbindungsschnittstelle entgegengenommen wird und danach ist die

01:05:52.230 --> 01:05:53.250
Transaktion zu Ende.

01:05:53.250 --> 01:05:57.410
Aber was ich gesagt habe, kann ja eine größere Aktion nach sich

01:05:57.410 --> 01:05:57.630
ziehen.

01:05:57.930 --> 01:06:00.970
Es könnte sein, dass diese Peripherie vielleicht ein Co-Prozessor war.

01:06:01.490 --> 01:06:06.290
Und ich sage dem Co-Prozessor, rechne mal aus Sinus von irgendwas.

01:06:06.570 --> 01:06:08.370
Irgendwas, was aufwendig ist, das dauert Zeit.

01:06:08.930 --> 01:06:12.990
Und deswegen hat er ein Status-Signal, in dem drinsteht, fertig, jetzt

01:06:12.990 --> 01:06:13.470
habe ich es.

01:06:13.630 --> 01:06:16.170
Das hat also nichts mit der ursprünglichen Transaktion zu tun, das ist

01:06:16.170 --> 01:06:18.170
eine spätere Transaktion und er sagt fertig.

01:06:18.170 --> 01:06:23.550
Zum Beispiel hatten wir mal einen anderen Chip, einen EEPROM-Chip, den

01:06:23.550 --> 01:06:26.230
wir anbinden wollten, einen anderen FPGA, ist egal.

01:06:27.210 --> 01:06:30.270
Zumindest, der hatte auch so eine Aufteilung, es gab innen drin

01:06:30.270 --> 01:06:33.150
irgendwo das EEPROM-Array, das hat man nicht gesehen.

01:06:33.550 --> 01:06:37.910
Es gab davor zwei kleine SRAM-Buffer, halbes Kilowatt jeweils und dann

01:06:37.910 --> 01:06:40.050
gab es eine Programmierschnittstelle, eine Steuerschnittstelle.

01:06:40.050 --> 01:06:44.510
Man hat quasi an gewisse Adressen Steuerbefehle geschickt, sowas wie,

01:06:44.950 --> 01:06:50.490
kopier mal von dem EEPROM-Array folgenden Bereich, folgende Seite in

01:06:50.490 --> 01:06:51.370
den SRAM-Buffer.

01:06:51.550 --> 01:06:53.470
Dann hat er das halt eben gemacht und irgendwann hat er mit dem

01:06:53.470 --> 01:06:55.410
Steuersignal gesagt, fertig.

01:06:55.950 --> 01:06:59.010
Dann konnte man wieder Programmierbefehle hinschicken oder man konnte

01:06:59.010 --> 01:07:02.090
auf dem SRAM-Array dann Daten hin und her austauschen.

01:07:02.090 --> 01:07:05.570
Man konnte ihm Steuerbefehle hinschicken, lösch mal folgende Seite im

01:07:05.570 --> 01:07:09.110
EEPROM -Array, lad mal folgende andere Seite in den zweiten SRAM

01:07:09.110 --> 01:07:09.470
-Buffer.

01:07:09.770 --> 01:07:12.030
Dann redet man ein bisschen mit dem SRAM-Buffer, dann sagt man, jetzt

01:07:12.030 --> 01:07:14.730
kopier mal den SRAM-Buffer-Inhalt zurück in das EEPROM-Array.

01:07:15.130 --> 01:07:18.370
Also es gab einmal den echten Datenaustausch mit dem SRAM-Buffer und

01:07:18.370 --> 01:07:21.290
dann gab es die Steuersignale, alles was irgendwie länger gedauert

01:07:21.290 --> 01:07:21.490
hat.

01:07:21.490 --> 01:07:28.530
Und dafür ist jetzt genau die Idee, die Sachen, die länger dauern, die

01:07:28.530 --> 01:07:32.370
werden dann in einem Statusregister, sind die abrufbar.

01:07:32.510 --> 01:07:33.230
Wie ist der Status?

01:07:33.450 --> 01:07:36.210
Ist das schon fertig oder ist das noch nicht fertig?

01:07:36.770 --> 01:07:39.430
Und diese Statusregister, die hängen halt eben auch am Bus.

01:07:39.610 --> 01:07:40.910
Also die sind auch Memory Map am Bus.

01:07:41.210 --> 01:07:44.090
Also ich kann ein Load machen auf die Adresse, wo das Statusregister

01:07:44.090 --> 01:07:47.830
ist und kann gucken, ist da das Operation Nummer 3 fertig?

01:07:47.830 --> 01:07:49.750
Flag auf 1 oder auf 0?

01:07:51.590 --> 01:07:54.570
Naja, und da kann ich halt eben, also die Software kann dann selber

01:07:54.570 --> 01:07:59.430
entscheiden, wie häufig, wann sie dieses Statusregister abfragen

01:07:59.430 --> 01:08:00.270
möchte.

01:08:00.870 --> 01:08:04.190
Die extreme Variante ist das sogenannte Busy Rating.

01:08:04.970 --> 01:08:07.250
Das heißt, die Software macht nichts anderes.

01:08:07.690 --> 01:08:12.090
In einer Schleife wird dauernd gefragt, Statusregister, ist fertig?

01:08:12.210 --> 01:08:12.410
Nein?

01:08:12.810 --> 01:08:13.490
Dann mach nochmal.

01:08:13.490 --> 01:08:17.810
Wird die ganze Zeit das Statusregister gepollt, abgefragt, bis es

01:08:17.810 --> 01:08:19.010
irgendwann mal fertig ist.

01:08:19.430 --> 01:08:23.030
Also Nachteil ist, die CPU macht nichts anderes währenddessen und

01:08:23.030 --> 01:08:26.890
Nachteil ist auch, das kostet eine Menge Strom.

01:08:28.690 --> 01:08:32.410
Es sind sehr, sehr, sehr viele Bustransaktionen, weil es ist klar, das

01:08:32.410 --> 01:08:36.150
war jetzt überhaupt nicht erwähnt hier, aber es ist klar, dass solche

01:08:36.150 --> 01:08:39.330
Peripherien, die dürfen nicht gecached werden.

01:08:39.330 --> 01:08:43.970
Also Speicherinhalt kann man cachen, weil Speicher ändert sich nicht

01:08:43.970 --> 01:08:44.530
von alleine.

01:08:45.030 --> 01:08:48.390
Aber der Inhalt von dem Statusregister, der soll sich ja von alleine

01:08:48.390 --> 01:08:48.710
ändern.

01:08:48.810 --> 01:08:51.150
Der soll ja den aktuellen Status widerspiegeln.

01:08:51.250 --> 01:08:55.110
Das heißt, es gibt in jedem Cache die Möglichkeit zu sagen, folgende

01:08:55.110 --> 01:08:56.910
Adressen sind non-cacheable.

01:08:57.070 --> 01:09:00.090
Die bitte nicht cachen, die müssen immer über den Bus von der

01:09:00.090 --> 01:09:02.950
Peripherie der aktuelle Wert abgefragt werden.

01:09:02.950 --> 01:09:06.650
Das heißt, dieses Busy-Waiting sind sehr, sehr viele Bustransaktionen

01:09:06.650 --> 01:09:09.970
und kostet dementsprechend Zeit und Energie.

01:09:10.610 --> 01:09:12.850
Und der Bus ist halt eben auch busy und kann nichts anderes nebenbei

01:09:12.850 --> 01:09:13.130
machen.

01:09:13.570 --> 01:09:17.170
Vorteil, muss ja auch einen Vorteil haben, viel schneller wird es

01:09:17.170 --> 01:09:17.510
nicht mehr.

01:09:17.630 --> 01:09:20.570
Also sobald es verfügbar ist, werde ich es ziemlich schnell

01:09:20.570 --> 01:09:21.110
mitbekommen.

01:09:21.390 --> 01:09:22.030
Das ist der Vorteil.

01:09:22.070 --> 01:09:23.630
Wenn ich dringend darauf warte, na gut, okay.

01:09:25.790 --> 01:09:28.530
Gut, das ist Programmable I.O.

01:09:29.050 --> 01:09:30.810
oder Programmed I.O.

01:09:30.810 --> 01:09:35.850
Interrupt-gesteuertes I.O., so langsam kommen wir in so nettere

01:09:35.850 --> 01:09:36.410
Verfahren.

01:09:37.090 --> 01:09:38.350
Interrupt -gesteuertes I.O.

01:09:38.550 --> 01:09:43.810
ist im Wesentlichen, die Peripherie hat nicht nur ein Statusregister,

01:09:44.370 --> 01:09:48.970
sondern sie kann auch selbstständig, nicht auf den Bus zugreifen, aber

01:09:48.970 --> 01:09:52.090
Interrupts, Unterbrechungen an die CPU schicken.

01:09:52.090 --> 01:09:57.970
Also sowas wie die CPU sagt, mach mal folgendes, kopiere mal folgende

01:09:57.970 --> 01:10:00.810
Seite von dem EEPROM in den SRAM-Buffer, um bei dem Beispiel zu

01:10:00.810 --> 01:10:05.110
bleiben und sag mir per Interrupt Bescheid, wenn du es fertig hast.

01:10:05.370 --> 01:10:08.550
Dann kann die CPU ganz normal ihr Zeug machen, weiterarbeiten, was

01:10:08.550 --> 01:10:09.370
auch immer sie tun möchte.

01:10:09.830 --> 01:10:13.690
Und irgendwann, wenn das Gerät, der EEPROM-Chip, fertig ist, wird er

01:10:13.690 --> 01:10:17.930
die CPU und ihre Abarbeitung unterbrechen, Interrupt, und dann

01:10:17.930 --> 01:10:20.770
mitteilen, so, fertig.

01:10:21.410 --> 01:10:24.370
Jetzt kann die CPU mit dem Interrupt-Händler, in dem da das Geeignete

01:10:24.370 --> 01:10:26.710
drinsteht, entscheiden, was als nächstes zu tun ist.

01:10:27.010 --> 01:10:29.750
Ob dann eben die nächste Aktion, die nächste Kopieaktion ausgelöst

01:10:29.750 --> 01:10:31.470
werden soll oder was auch immer.

01:10:32.690 --> 01:10:36.350
Vorteil, die CPU kann sich um anderen Kram kümmern, sie kann eben

01:10:36.350 --> 01:10:37.050
weiterarbeiten.

01:10:38.470 --> 01:10:41.930
Nachteil, um in diese Interrupt-Routine zu kommen, das sehen wir am

01:10:41.930 --> 01:10:45.810
Ende des Foliensatzes, es ist ein gewisser Overhead, also es kostet

01:10:45.810 --> 01:10:49.810
ein paar Befehle, um da reinzukommen, und dann muss man am Ende auch

01:10:49.810 --> 01:10:53.050
wieder aufräumen und wieder rauskommen, um quasi das Programm da

01:10:53.050 --> 01:10:55.550
weiter auszuführen, wo es eigentlich unterbrochen worden ist.

01:10:55.910 --> 01:10:58.130
Also da kommt ein bisschen Overhead rein, dadurch geht auch die

01:10:58.130 --> 01:11:01.830
Reaktionszeit ein bisschen runter, und man muss natürlich den

01:11:01.830 --> 01:11:04.570
Interrupt -Händler geeignet programmieren, dass da das Richtige

01:11:04.570 --> 01:11:06.130
drinsteht, was halt getan werden soll.

01:11:09.170 --> 01:11:15.390
Es ist nicht so völlig anders, aber die letzte Variante, also die DMA

01:11:15.390 --> 01:11:21.090
-Übertragung, mehr kommt dazu leider nicht, aber DMA-Übertragung ist

01:11:21.090 --> 01:11:22.250
wie folgt.

01:11:22.850 --> 01:11:30.550
DMA, also Direct Memory Access, heißt im Wesentlichen, ich habe eine

01:11:30.550 --> 01:11:35.470
Peripherie am Bus, das ist mein DMA-Controller, das ist eine extra

01:11:35.470 --> 01:11:36.030
Peripherie.

01:11:36.630 --> 01:11:41.510
Diese Peripherie ist ein Master am Bus, also so wie CBUs Master sind.

01:11:41.670 --> 01:11:46.730
Masters dürfen von sich aus den Bus belästigen, also Anfragen dahin

01:11:46.730 --> 01:11:46.990
schicken.

01:11:47.510 --> 01:11:51.370
Slaves lauschen nur, Slaves warten nur am Bus, lauschen, gucken sich

01:11:51.370 --> 01:11:54.410
die Adresse an, und warten, angesprochen zu werden, und erst danach

01:11:54.410 --> 01:11:55.270
reagieren sie.

01:11:55.270 --> 01:11:59.130
Masters, somit auch die DMA-Controller, darauf aktiv auf den Bus zu

01:11:59.130 --> 01:12:01.470
greifen und neue Transaktionen anstoßen.

01:12:02.650 --> 01:12:06.190
Und der wird benutzt für gewöhnlich, um Daten von A nach B zu

01:12:06.190 --> 01:12:06.550
kopieren.

01:12:07.930 --> 01:12:12.250
Angenommen, ich habe einen Hauptspeicher und das EEPROM-Speicherchen,

01:12:12.350 --> 01:12:15.190
wie auch immer, und will dann eine gewisse Menge an Daten übertragen,

01:12:15.770 --> 01:12:20.450
dann kann mir diese Aufgabe, ich kann entweder in der CPU Load vom

01:12:20.450 --> 01:12:22.610
Hauptspeicher, Store nach DRAM.

01:12:22.610 --> 01:12:26.530
Load vom Hauptspeicher, Store nach EEPROM.

01:12:26.830 --> 01:12:30.750
Also eine Schleife mit ganz vielen Loads von hier und Stores von da.

01:12:31.050 --> 01:12:32.650
Dann ist die CPU busy die ganze Zeit.

01:12:33.790 --> 01:12:38.910
Oder ich kann dem DMA-Controller sagen, lieber DMA-Controller, kopiere

01:12:38.910 --> 01:12:43.170
doch bitte mal von folgender Startadresse an folgende Zieladresse

01:12:43.170 --> 01:12:44.830
folgende Menge an Daten.

01:12:44.830 --> 01:12:48.650
Und häufig kann man denen sogar noch sowas sagen wie und nimm nicht

01:12:48.650 --> 01:12:54.630
jedes nächste Wort, das erste Wort, das nächste, das dritte, das

01:12:54.630 --> 01:12:57.830
vierte, sondern dann nimm folgendes Pattern.

01:12:58.830 --> 01:13:01.430
Nimm jedes sechste Wort, jedes zwölfte Wort.

01:13:01.650 --> 01:13:04.550
Also gewisse Muster, die DMA-Controller können meistens noch

01:13:04.550 --> 01:13:07.730
verschiedene Arten von Mustern automatisch supporten.

01:13:07.730 --> 01:13:13.910
Zum Beispiel, wenn ich habe ein Bild, ein Bild, wo abgelegt ist, rot,

01:13:13.990 --> 01:13:16.030
grün, blau, jeweils ein Byte oder sowas.

01:13:16.430 --> 01:13:18.470
Und ich hätte jetzt gerne nur den Rotanteil.

01:13:18.890 --> 01:13:23.410
Dann sage ich, Beginn von, Startadresse von dem Bild, nimm bitte jedes

01:13:23.410 --> 01:13:24.270
dritte Byte.

01:13:24.710 --> 01:13:27.850
Dann habe ich nur die Roteile von dem Bild irgendwo anders hin

01:13:27.850 --> 01:13:28.170
kopiert.

01:13:28.550 --> 01:13:31.630
Und bei dem Zielort steht dann rot, rot, rot, rot.

01:13:31.730 --> 01:13:33.270
Die Grüns und Blaus sind dazwischen nicht mehr da.

01:13:33.650 --> 01:13:35.490
Für solche Sachen kann man den DMA-Controller nehmen.

01:13:35.490 --> 01:13:37.410
Der macht das dann von alleine.

01:13:37.630 --> 01:13:39.310
Also der macht dann die ganzen Anfragen am Bus.

01:13:39.410 --> 01:13:42.350
Die CPU kann währenddessen, was auch immer, weiterrechnen.

01:13:42.830 --> 01:13:45.370
Und irgendwann, der DMA-Controller kann dann auch entweder über

01:13:45.370 --> 01:13:48.790
Statusregister abfragbar sein, ist es fertig, oder über InShot

01:13:48.790 --> 01:13:50.830
Bescheid sagen, dass er jetzt fertig ist.

01:14:01.390 --> 01:14:02.350
Ja, das...

01:14:03.430 --> 01:14:04.210
Handshakes, nee.

01:14:09.370 --> 01:14:12.330
Kommunikationsmodi, Vollduplex, Halbduplex, die Wörter sollte man

01:14:12.330 --> 01:14:13.370
zumindest mal gehört haben.

01:14:15.090 --> 01:14:19.350
Vollduplex heißt einfach nur, dass es für beide mögliche

01:14:19.350 --> 01:14:22.510
Übertragungsrichtungen, also von A nach B und von B nach A,

01:14:23.270 --> 01:14:26.490
unabhängige Daten- und Adress- und Steuer- und alles mögliche

01:14:26.490 --> 01:14:27.370
Leitungen gibt.

01:14:27.910 --> 01:14:30.650
Und Halbduplex, wir hatten bisher quasi immer nur Halbduplex gesehen,

01:14:30.650 --> 01:14:35.890
heißt, es gibt nur eine Verbindungsleitung und die kann entweder für

01:14:35.890 --> 01:14:38.750
Kommunikation von A Richtung B genommen werden oder die kann für

01:14:38.750 --> 01:14:41.450
Kommunikation von B Richtung A genommen werden, aber nicht für beides.

01:14:41.990 --> 01:14:44.750
Beim Bus habe ich ja immer so, ich habe nur einen Adress-Bus, ich habe

01:14:44.750 --> 01:14:47.410
einen Daten-Bus, der kann auch nur für eine Kommunikation genutzt

01:14:47.410 --> 01:14:47.630
werden.

01:14:47.990 --> 01:14:50.390
Aber bei Vollduplex könnte ich mir auch überlegen, vielleicht habe ich

01:14:50.390 --> 01:14:54.810
da zwei Adress-Busse und zwei Daten-Busse, sodass ich auf eine

01:14:54.810 --> 01:14:58.450
Peripherie gleichzeitig lesend und schreibend zugreifen kann.

01:14:58.450 --> 01:15:01.730
Brauche ich entsprechend auch die Steuerleitung, Request-Acknowledge,

01:15:01.810 --> 01:15:05.630
also Anforderung, das Verb, was vorhin im Wesentlichen Adress-Valid

01:15:05.630 --> 01:15:09.930
oder sowas hieß, und Acknowledge, Kommunikation abgeschlossen, brauche

01:15:09.930 --> 01:15:11.930
ich dann auch unabhängig in beide Richtungen.

01:15:14.650 --> 01:15:19.290
Okay, jetzt hatten wir schon in verschiedenen vorherigen Punkten

01:15:19.290 --> 01:15:23.110
diesen Interact auftauchen lassen, den wir sinnvoll einsetzen können

01:15:23.110 --> 01:15:24.450
für verschiedene Kommunikationen.

01:15:25.090 --> 01:15:26.750
Die müssen wir uns nochmal angucken.

01:15:28.430 --> 01:15:33.710
Interrupts sind eine Form von Unterbrechungen oder

01:15:33.710 --> 01:15:35.570
Ausnahmesituationen.

01:15:38.410 --> 01:15:43.530
Es gibt zwei verschiedene Gründe, die die auslösen können, die sehen

01:15:43.530 --> 01:15:44.130
wir gleich noch.

01:15:44.410 --> 01:15:48.530
Aber letztendlich ist es immer so, da kommt eine Anfrage von außen

01:15:48.530 --> 01:15:52.850
oder von innen, und darüber kommt eine Anfrage, dass doch jetzt die

01:15:52.850 --> 01:15:56.050
normale Programmausführung, der normale Software-Code, der sowieso

01:15:56.050 --> 01:16:01.650
gerade lief, unterbrochen werden soll, um auf diese Ausnahme geeignet

01:16:01.650 --> 01:16:02.370
zu reagieren.

01:16:02.910 --> 01:16:06.470
Dafür muss es eben auch ein Stück Hardware-Support geben, um dieses

01:16:06.470 --> 01:16:08.430
Reagieren durchführen zu können.

01:16:09.870 --> 01:16:14.970
Prinzipiell ist diese Ausnahme ähnlich zum Aufruf von einem

01:16:14.970 --> 01:16:15.790
Unterprogramm.

01:16:16.450 --> 01:16:19.330
Während das normale Programm läuft, wird was anderes gemacht, und

01:16:19.330 --> 01:16:22.130
danach geht es wieder zurück dahin, wo wir hergekommen sind.

01:16:25.110 --> 01:16:29.570
Unterschied beim Unterprogramm habe ich im Software-Code, im Assembler

01:16:29.570 --> 01:16:33.330
-Code, wo auch immer, explizit drinstehen, rufe folgendes

01:16:33.330 --> 01:16:34.330
Unterprogramm auf.

01:16:34.430 --> 01:16:36.570
Also das kann ich sehen, dass es genau da passieren wird.

01:16:37.170 --> 01:16:40.390
Bei Unterbrechungen ist es so, da steht im Software-Code nicht drin,

01:16:40.570 --> 01:16:41.930
das passiert, wenn es passiert.

01:16:42.310 --> 01:16:44.170
Und dann muss man halt eben darauf reagieren können.

01:16:44.170 --> 01:16:48.210
Und da kann man schon einen Unterschied sehen, was dieses Aufräumen

01:16:48.210 --> 01:16:48.550
angeht.

01:16:48.730 --> 01:16:51.590
Wenn ich ein Unterprogramm aufrufe, dann weiß ich das ja.

01:16:51.750 --> 01:16:56.970
Ich meine, da kann ich vorher entsprechend Eingabedaten in die

01:16:56.970 --> 01:16:59.910
richtigen Register reinschreiben, einen Stack aufbauen, all solche

01:16:59.910 --> 01:17:02.950
Sachen, und weiß, das wird am Ende auch genauso wieder abgebaut

01:17:02.950 --> 01:17:03.230
werden.

01:17:03.730 --> 01:17:05.510
Die Unterbrechung kommt irgendwann.

01:17:05.670 --> 01:17:08.050
Da war ich jetzt nicht drauf vorbereitet, es muss trotzdem irgendwie

01:17:08.050 --> 01:17:08.570
funktionieren.

01:17:10.030 --> 01:17:12.110
Rücksprung ist auch sehr ähnlich, kleiner Unterschied.

01:17:12.110 --> 01:17:13.970
Es gibt meistens zwei verschiedene Befehle dafür.

01:17:14.490 --> 01:17:18.110
Einmal das normale Return für Unterprogramme und Return from Interrupt

01:17:18.110 --> 01:17:20.350
für die Interrupt-Händler.

01:17:22.590 --> 01:17:27.240
Ein weiteres Problem ist auch noch, wo ist das Unterprogramm?

01:17:28.110 --> 01:17:31.570
Bei dem normalen Unterprogramm weiß ich, das Call sagt mir ja, wo ich

01:17:31.570 --> 01:17:32.330
hinspringen soll.

01:17:33.070 --> 01:17:35.750
Bei dem Interrupt weiß ich ja noch gar nicht, wo ist denn der Händler

01:17:35.750 --> 01:17:36.230
dafür überhaupt.

01:17:36.330 --> 01:17:39.370
Es gibt verschiedene Interrupts und da muss man erstmal finden, wo ist

01:17:39.370 --> 01:17:41.350
denn die Behandlung davon im Speicherhaupt abgelegt.

01:17:42.110 --> 01:17:46.990
Was es außerdem noch gibt, ist ein häufiges Steuerbit Interrupt

01:17:46.990 --> 01:17:47.450
-Enable.

01:17:47.730 --> 01:17:53.010
Es gibt manchmal Situationen, in denen Interrupts unerwünscht sind und

01:17:53.010 --> 01:17:55.010
deswegen ignoriert werden sollen.

01:17:55.230 --> 01:17:58.910
Wobei ignoriert hier nicht heißt, ignorieren und vergessen, sondern

01:17:58.910 --> 01:18:04.610
heißt, ignorieren und so lange zurückhalten, bis das Interrupt-Enable

01:18:04.610 --> 01:18:06.270
-Bit wieder es zulässt.

01:18:06.910 --> 01:18:09.290
Was sind das für Situationen, wenn Interrupts unerwünscht sind?

01:18:09.290 --> 01:18:13.450
Das eine ist zum Beispiel, wenn ich irgendwie eine zeitkritische

01:18:13.450 --> 01:18:17.890
Operation mache, wenn ich mit einer Peripherie rede, die sehr sensibel

01:18:17.890 --> 01:18:21.270
ist auf gewisse zeitliche Reihenfolgen, dann darf ich da nicht

01:18:21.270 --> 01:18:23.470
unterbrochen werden, das würde nicht funktionieren.

01:18:23.870 --> 01:18:27.390
Oder wenn ich einfach jemand anderem, dem Programmierer, eine Garantie

01:18:27.390 --> 01:18:30.870
abgegeben habe, dieser Teil des Codes wird niemals länger brauchen

01:18:30.870 --> 01:18:31.250
als.

01:18:31.930 --> 01:18:34.730
Wenn ein Interrupt kommt, dann ist meine Garantie hinfällig.

01:18:34.730 --> 01:18:37.630
In solchen Situationen würde ich es normalerweise verbieten.

01:18:37.990 --> 01:18:42.530
Oder der üblichste Fall eigentlich, wenn gerade schon ein Interrupt

01:18:42.530 --> 01:18:50.270
passiert ist und ich bin gerade in einem Interrupt-Händler drin, dann

01:18:50.270 --> 01:18:52.650
bin ich für gewöhnlich in einer Situation, in der alles gerade ein

01:18:52.650 --> 01:18:53.570
bisschen durcheinander ist.

01:18:54.010 --> 01:18:56.910
Wenn jetzt noch ein zweiter Interrupt kommt, das könnte sehr

01:18:56.910 --> 01:18:57.530
unangenehm werden.

01:18:57.630 --> 01:19:00.530
Deswegen das erste, was der Interrupt-Händler macht, er verbietet,

01:19:00.710 --> 01:19:02.150
dass weitere Interrupts passieren können.

01:19:02.150 --> 01:19:05.690
Und dann kann man sagen, man schreibt einen Interrupt-Händler-Code so,

01:19:06.210 --> 01:19:09.290
dass man es erlauben kann, dass er selbst unterbrochen wird.

01:19:09.350 --> 01:19:10.770
Da muss man gewisse Sachen für aufräumen.

01:19:11.210 --> 01:19:13.450
Oder man macht es halt eben nicht, dann sollte der Händler bitteschön

01:19:13.450 --> 01:19:15.510
sehr kurz sein, dass man möglichst schnell wieder rauskommt.

01:19:16.030 --> 01:19:19.630
Also häufig sind Händler selbst, dass sie halt eben keine weiteren

01:19:19.630 --> 01:19:22.950
Interrupts, keine Verschachtelten Interrupts zulassen.

01:19:25.770 --> 01:19:28.790
Gut, ich hatte irgendwann in der frühen Folge schon mal angedeutet, es

01:19:28.790 --> 01:19:29.470
gibt zwei verschiedene.

01:19:29.470 --> 01:19:32.250
Es gibt Interrupts und es gibt Traps.

01:19:33.890 --> 01:19:35.290
Interrupts sind Asynchron.

01:19:35.650 --> 01:19:39.870
Asynchron heißt hier, sie kommen von außerhalb der CPU, nicht von

01:19:39.870 --> 01:19:42.170
außerhalb des Chips, also könnte, muss aber nicht, sondern von

01:19:42.170 --> 01:19:45.430
außerhalb der CPU, werden insbesondere nicht durch einen

01:19:45.430 --> 01:19:49.330
Assemblerbefehl ausgelöst, sondern eine Peripherie sagt, ich habe es

01:19:49.330 --> 01:19:51.030
jetzt fertig, könnte irgendwann passieren.

01:19:51.510 --> 01:19:54.930
Ein Trap hingegen wird immer unmittelbar von einem Assemblerbefehl

01:19:54.930 --> 01:19:55.530
ausgelöst.

01:19:55.530 --> 01:19:58.810
Ein Assemblerbefehl, wo irgendwas schief geht, Division by Zero, das

01:19:58.810 --> 01:19:59.570
wäre so ein Trap.

01:19:59.650 --> 01:20:00.570
Da kommen gleich noch mehr Beispiele.

01:20:01.310 --> 01:20:03.130
Einfach nur, um die beiden zu unterscheiden.

01:20:04.210 --> 01:20:06.570
Typische externe Interrupts, also echte Interrupts.

01:20:07.350 --> 01:20:11.670
Reset ist klar, das ist ein Taster zum Beispiel, der das auslöst.

01:20:12.250 --> 01:20:16.710
Oder es gibt auch Überwachungseinheiten, die prüfen, ist die Spannung

01:20:16.710 --> 01:20:21.110
in einem tolerierbaren Bereich, so ein Brown-Out-Reset heißt das.

01:20:21.110 --> 01:20:25.650
Oder es gibt einen Watchdog, also CPUs haben keinen Watchdog, aber

01:20:25.650 --> 01:20:27.350
Microcontroller haben sehr häufig Watchdogs.

01:20:28.010 --> 01:20:32.870
Ein Wachhund ist einfach nur ein Zähler.

01:20:33.450 --> 01:20:35.130
Aber Zähler klingt immer so langweilig.

01:20:35.570 --> 01:20:41.750
Also das ist ein Zähler, der wird von dem Softwareprogramm auf Null

01:20:41.750 --> 01:20:43.990
gesetzt und danach zählt der hoch.

01:20:44.710 --> 01:20:48.410
Und der muss dauernd wieder auf Null gesetzt werden, denn wenn dieser

01:20:48.410 --> 01:20:53.090
Zähler jemals überlaufen sollte, dann heißt das, ich wurde nicht

01:20:53.090 --> 01:20:56.170
häufig genug auf Null gesetzt, vielleicht ist die Anwendung

01:20:56.170 --> 01:20:58.610
abgestürzt, vielleicht hängt die irgendwo fest.

01:20:58.830 --> 01:21:01.810
Sonst hätte sie mich ja wieder auf Null gesetzt, das ist die Idee

01:21:01.810 --> 01:21:02.110
davon.

01:21:02.370 --> 01:21:06.270
Also wenn dieser Zähler irgendwann überläuft, dann sagt er, resetze

01:21:06.270 --> 01:21:08.730
mal lieber das System, dann sind wir zumindest wieder in einem

01:21:08.730 --> 01:21:10.830
definierten Ausgangszustand und können von vorne anfangen.

01:21:11.130 --> 01:21:13.270
Anstatt wenn der da irgendwo in der Endlosschleife festhängt.

01:21:13.570 --> 01:21:15.190
Das ist die Idee von einem Watchdog.

01:21:18.970 --> 01:21:19.290
Halt...

01:21:22.490 --> 01:21:26.310
Das sind jetzt schon fast eher Traps eigentlich, es kommt darauf an,

01:21:26.550 --> 01:21:27.970
wie die ausgelöst werden.

01:21:30.490 --> 01:21:32.770
Zugriffskonflikt auf den Bus, könnte vom Bus ausgelöst werden, dann

01:21:32.770 --> 01:21:33.590
wäre es noch ein Interrupt.

01:21:34.930 --> 01:21:36.870
Busfehler, ja ist auch Interrupt, okay, das sind beides Interrupts.

01:21:36.910 --> 01:21:38.970
Also wird beides auf einmal vom Bus ausgelöst, das ist auch beides

01:21:38.970 --> 01:21:39.710
noch Interrupts.

01:21:45.970 --> 01:21:50.590
Ich hatte ja schon gesagt, es gibt dieses Interrupt Enabled Flag, mit

01:21:50.590 --> 01:21:52.310
dem man Interrupts abschalten, verbieten kann.

01:21:52.650 --> 01:21:54.030
Das geht aber nicht für alle Interrupts.

01:21:54.090 --> 01:21:58.570
Es gibt maskierbare Interrupts und maskierbar heißt, der hört auf das

01:21:58.570 --> 01:21:59.390
Interrupt Enabled Bit.

01:22:00.150 --> 01:22:04.150
Also wenn ein maskierbarer Interrupt kommt und das Interrupt Enabled

01:22:04.150 --> 01:22:06.810
Bit sagt, jetzt bitte nicht, dann muss er halt warten.

01:22:06.810 --> 01:22:10.910
Und dann gibt es halt eben nicht maskierbare Interrupts.

01:22:11.190 --> 01:22:14.730
Das heißt, die ignorieren das Interrupt Enabled Bit, weil es geht

01:22:14.730 --> 01:22:15.410
nicht anders.

01:22:16.610 --> 01:22:20.590
Zum Beispiel Zusammenbruch der Betriebssystemspannung, da kann ich

01:22:20.590 --> 01:22:24.350
nicht warten, bis die liebe Software sagt, so jetzt wäre ich soweit,

01:22:24.490 --> 01:22:25.490
bis dahin ist es zu spät.

01:22:26.030 --> 01:22:28.390
Also gewisse Sachen müssen einfach sofort passieren.

01:22:29.470 --> 01:22:33.690
Oder halt eben auch Division by Zero, das Programm läuft ja nicht

01:22:33.690 --> 01:22:34.850
weiter, da kann ich nicht warten.

01:22:35.550 --> 01:22:36.490
Womit soll ich warten?

01:22:36.650 --> 01:22:38.730
Das hat einen Fehler gemacht, das Programm hat etwas Falsches

01:22:38.730 --> 01:22:41.110
berechnet, da kann ich nicht warten.

01:22:41.370 --> 01:22:45.090
Also ja, deswegen maskierbare und nicht maskierbare.

01:22:45.470 --> 01:22:48.230
Man hört auch wirklich ab und zu in Gesprächen in der Ecke, wenn

01:22:48.230 --> 01:22:51.330
irgendwie so eine Gruppe von Leuten redet, kommt einer dazu und drängt

01:22:51.330 --> 01:22:54.310
sich dazwischen non-maskable Interrupt, weil er was Dringendes sagen

01:22:54.310 --> 01:22:56.090
will und sich nicht unterbrechen lassen will von den anderen.

01:22:56.550 --> 01:22:59.970
Also hat es teilweise wirklich sogar schon in die Umgebungssprache

01:22:59.970 --> 01:23:00.310
geschafft.

01:23:01.830 --> 01:23:05.010
Ja, das waren die Interrupts, jetzt haben wir noch die Prozessor

01:23:05.010 --> 01:23:07.510
-internen Sachen, also die Traps sozusagen.

01:23:08.150 --> 01:23:13.290
Einmal gibt es da die Möglichkeit, dass die Software absichtlich Trap

01:23:13.290 --> 01:23:13.490
auslöst.

01:23:14.190 --> 01:23:18.290
Also es gibt quasi einen Assembler-Befehl, der sagt, löse mal jetzt

01:23:18.290 --> 01:23:19.610
folgenden Trap aus.

01:23:20.090 --> 01:23:22.130
Und der Trap-Händler, den habe ich ja selber geschrieben, der macht

01:23:22.130 --> 01:23:23.350
dann, was ich gerade machen wollte.

01:23:25.650 --> 01:23:27.530
Hört sich jetzt an wie ein Funktionsaufruf.

01:23:27.530 --> 01:23:32.590
Gibt ein paar Gründe, wir sehen gleich nachher noch einen, wo der

01:23:32.590 --> 01:23:33.690
Unterschied vielleicht ein bisschen klarer wird.

01:23:35.870 --> 01:23:39.930
Ansonsten zum Beispiel hier ein Overflow, das wäre jetzt zum Beispiel

01:23:39.930 --> 01:23:41.830
irgendeine Rechnung, läuft über.

01:23:42.370 --> 01:23:45.950
Das ist nichts missionskritisches, passiert halt eben, aber man könnte

01:23:45.950 --> 01:23:48.290
sagen, vielleicht will man darauf reagieren, weil man gewisse

01:23:48.290 --> 01:23:50.230
Rundungsmodi implementieren will oder sowas.

01:23:50.630 --> 01:23:54.230
Das wäre sicherlich ein maskierbarer Trap, aber einer, der von einer

01:23:54.230 --> 01:23:56.490
Addition zum Beispiel ausgelöst werden könnte.

01:23:57.210 --> 01:24:00.510
Division by Zero ist sicherlich nicht maskierbar, danach kann man

01:24:00.510 --> 01:24:01.190
nicht weitermachen.

01:24:01.990 --> 01:24:04.690
Stack Overflow ist nicht maskierbar, danach kann man nicht

01:24:04.690 --> 01:24:05.270
weitermachen.

01:24:06.010 --> 01:24:08.850
Genauso hier, ungültiger Opcode, also wenn da ein Assembler-Befehl,

01:24:08.910 --> 01:24:12.370
ein 32-Bit-Wort reinkommt und dieses 32-Bit-Wort, was soll das für ein

01:24:12.370 --> 01:24:14.530
Befehl sein, kennt man nicht, kann man nicht weitermachen.

01:24:14.890 --> 01:24:17.350
Aber das sind alles Sachen, die führen relativ unmittelbar zum Beenden

01:24:17.350 --> 01:24:17.950
des Programms.

01:24:18.070 --> 01:24:18.950
Das geht einfach nicht anders.

01:24:18.950 --> 01:24:23.110
Wogegen folgende hier, Seitenfehler sind behandelbar, hatte ich ja

01:24:23.110 --> 01:24:24.590
schon bei den Seiten gesagt.

01:24:24.890 --> 01:24:27.530
Dann wird der Trap-Händler derartig sein, dass er die Seite vom

01:24:27.530 --> 01:24:32.310
externen Hauptspeicher reinholt, einem U-Bescheid sagt, da ist sie und

01:24:32.310 --> 01:24:33.670
dann zurück zur Software.

01:24:34.130 --> 01:24:37.810
Und die Software muss dann den gleichen Befehl, der den Trap ausgelöst

01:24:37.810 --> 01:24:39.150
hat, nochmal ausführen.

01:24:39.230 --> 01:24:41.030
Weil der hat ja vorhin nicht funktioniert, der hat getrappt.

01:24:41.610 --> 01:24:44.270
Jetzt ist die Seite auf dem Hauptspeicher, jetzt führt der Befehl

01:24:44.270 --> 01:24:45.950
nochmal aus, dann klappt es wahrscheinlich auch.

01:24:48.130 --> 01:24:50.490
Das ist zum Beispiel auch eine Sache, wo man immer wieder schrecklich

01:24:50.490 --> 01:24:51.150
ins Grübeln kommt.

01:24:51.710 --> 01:24:56.250
Wenn man einen Intrap-Händler schreibt, und man einen Intrap-Händler

01:24:56.250 --> 01:25:01.070
schreibt, der selbst keine Intraps ausführen darf, also keine

01:25:01.070 --> 01:25:04.430
verschachtelten Intraps erlaubt sind, dann muss man um Gottes Willen

01:25:04.430 --> 01:25:07.850
vermeiden, dass man auf irgendeine Speicherseite zugreift, die gerade

01:25:07.850 --> 01:25:09.110
gar nicht im Hauptspeicher drin ist.

01:25:09.370 --> 01:25:12.130
Weil dann müsste man ja verschachtelte Intraps supporten, um sie

01:25:12.130 --> 01:25:13.030
reinholen zu können.

01:25:13.030 --> 01:25:16.050
Also manchmal ist dieses Verschachteln sehr hilfreich, und wenn nicht,

01:25:16.110 --> 01:25:18.190
muss man sich vorher Gedanken machen, dass es auch garantiert ohne

01:25:18.190 --> 01:25:18.710
funktioniert.

01:25:20.070 --> 01:25:23.910
Für die Bagger gibt es häufig noch einen Trace, der einfach nach jedem

01:25:23.910 --> 01:25:27.310
Assemblerbefehl sagt, abbrechen, dass der Bagger gucken kann, wo sind

01:25:27.310 --> 01:25:28.250
wir gerade hängen geblieben.

01:25:31.750 --> 01:25:34.370
Gut, das schaffen wir heute auf keinen Fall mehr.

01:25:34.710 --> 01:25:37.410
Also wir schauen uns dann nächste Woche noch an, wie jetzt eigentlich

01:25:37.410 --> 01:25:40.850
gefunden wird, wo der Intrap-Händler im Code eigentlich steht und wie

01:25:40.850 --> 01:25:43.510
man dahinter zurückkommt und was eigentlich der Unterschied ist

01:25:43.510 --> 01:25:47.170
zwischen einem durch Software explizit ausgelösten Intrap und einem

01:25:47.170 --> 01:25:51.030
direkten Funktionsaufruf und machen dann nächste Woche mit dem

01:25:51.030 --> 01:25:52.050
nächsten Kapitel weiter.

01:25:52.290 --> 01:25:52.650
Dankeschön.