So, bevor ich jetzt nochmal mit der Vorlesung weitermache, nur nochmal eine Ansage.
Also es steht ja eigentlich auch schon auf den Webseiten seit einiger Zeit,
aber einer von den, ich hatte mir nochmal gesagt,
wir hatten ja noch einen dritten Tutoriumstermin am Montag angesetzt,
von 13 bis 14 Uhr, wenn ich das richtig erinnere.
Das war jetzt, sagen wir mal, nicht so bekannt,
beziehungsweise da sind also nochmal oder eigentlich immer nur vergleichsweise wenige von euch gekommen,
aber trotzdem ist nur nochmal als Ansage oder Mondoring.
Das heißt, wenn irgendwo Fragen sind zur Vorlesung,
zu den Themen, irgendwas, was sagt man jetzt,
innerhalb der Übungsgruppen nicht passt, beziehungsweise dort einfach zeitlich flach fällt,
besteht dann eben ja immer noch die Gelegenheit.
Jetzt blieb ich am Montag oder am Dienstag einfach mal irgendwie
zu dem Putorium zu erscheinen und sich dann dort,
also quasi die Fragen zu stellen und sich das dann dort nochmal ausführlich erklären zu lassen.
Gut, also wie gesagt, das sollte ich jetzt nur nochmal explizit ansagen.
Ansonsten hatte ich ja Letzte Woche am Freitag schon angefangen. Also jetzt wirklich für Schaltwerk oder für Schaltwerksentwurf entsprechende Beispiele zu bringen. Hatte da also jetzt als,
sagen wir mal, so ein Standardbeispiel, ja,
also quasi diese einfache Ampelschaltung, also sprich,
das eine Ampel ist einfach nur die entsprechenden vier Phasen durchläuft,
vorgestellt und da dann eben auch gezeigt,
dass man letztendlich also sehr viele Möglichkeiten hat, so Zustandskodierung nicht,
also dass sich das also entweder dual kodiere mit minimaler Anzahl der Zustände,
dass sich das Im Prinzip jetzt also über eine beliebige andere Codierung mache,
wo ich also letztendlich die Zustände den Ausgängen,
also sprich den Lampen direkt, zuordne,
was dann natürlich in diesem Fall dann das Lamda-Schalten jetzt minimal einfach macht,
oder eben, dass man das also über eine One-Hot-Codierung macht,
wo dann die Zustandsübergänge,
also das Delta-Schaltennetz dann minimal einfach werden.
Nicht je nachdem, was man da wählt,
hat man dann eben entsprechend unterschiedlich aufwendige Lösungen
Ich letztendlich sollte,
aber dieses Beispiel einfach erstmal nur zeigen,
dass man jetzt also generell beim Schaltwerksentwurf doch eben sehr viele Freiheitsgrade hat und in der Regel,
also gerade wenn es sich jetzt also wirklich um größere Automaten
handelt und jetzt also nicht nur solche Spielbeispiele es da dann eben auch entsprechend sinnvoll ist,
beziehungsweise da gibt es dann eben auch entsprechende Werkzeuge,
die einen dann da eben quasi softwaremäßig unterstützen,
um da dann eben eine
möglichst effiziente Lösung zu finden
Gut,
jetzt habe ich hier noch einige weitere Beispiele von Schaltwerken,
die ich also jetzt heute soweit noch zu Ende vorstellen werde und dann werde ich also im Prinzip diese Woche dann noch ein bisschen was zur Hardware beziehungsweise Hardware-Komponenten zusammenfassen,
wie man dann eben wirklich jetzt komplette Rechner oder Rechnersysteme,
also aus all dem, was ich also jetzt bislang,
also jetzt mit diesem Schaltwerkskapitel und mit dem Vorhergehenden zum Schalt-Netzentwurf vorgestellt habe,
wie man dann eben letztendlich zu kompletten Rechnersystemen kommen kann,
zumindest in der Theorie.
Gut, sehr einfache Automaten beziehungsweise die allereinfachsten Automaten sind eigentlich ganz normale Zähler,
wo ich dann im Prinzip einfach immer nur beispielsweise jetzt binär durchzähle.
Deswegen folgen jetzt also noch einige Beispiele zu verschiedenen Zielschaltungen mit entsprechenden Beschreibungen,
wie ich das ja also dann letzte Woche vorgestellt hatte,
also im Automatenentwurf mit Zustandszielrahmen beziehungsweise Flussstafeln.
Und das sind jetzt dann mal also relativ einfache Vorwärtszähler,
Zähler, die man also irgendwie zwischendurch anhalten kann,
zurücksetzen kann und so weiter und so fort.
Am Ende wird er nochmal als ein Beispiel für eine etwas größere Schaltung,
eine Digitaluhr beziehungsweise in diese Phase jetzt durch das Zahlzeichensignal DCF 77 gesteuerte Uhr kurz vorgestellt,
wobei ich da aber eigentlich auch nochmal grob die Komponenten vorstellen werde,
weil also den Entwurf jetzt hier im Einzelnen nachzuvollziehen,
wie er dann also doch deutlich zu aufwendig.
Gut, bei Zählern Zähler ist Automat,
da sagt man sich ja auch, das ist jetzt natürlich beliebig umständlich,
aber formal gesehen ist es eben schon so,
dass also eigentlich ein Zähler auch ein endlicher Automat ist.
Denn wenn man jetzt sagt, ich habe hier so ein zwei Wittzähler,
kann ich den also entsprechend so aufzeichnen als Zustandsübergangsdiagramm,
dass man eben sieht,
okay, es gibt jetzt gar keine Bedingungen,
sondern ich habe dann einfach mit jedem Tag,
dass der Zustand einen weiterläuft
Mich das, könnte ich jetzt das auch nehmen und sagen,
na gut, um damit zumindest so ein bisschen Eingangsbedingungen reinzubringen,
soll der Zähler noch sowas wie so eine Enable-Leitung haben.
Nicht, wo ich dann eben sage,
wenn ein Ebel gleich eins ist, soll gezählt werden,
wenn nicht, hält Erzähler an und im Sinne eines Automatenentwurfs
würde man dann eben das entsprechend über so eine Kante beschreiben,
wo der Zustand quasi auf sich selber abgebildet wird.
Das wäre dann,
also jetzt hier auf der linken Seite der Folie,
das entsprechende Zustandsdiagramm und auf der rechten Seite
dann eben das Ganze dann auch nochmal formal als Flusstafel aufgeschrieben
Gut, dieses Beispiel lässt sich jetzt also beliebig weiterspinnen.
Also ich kann jetzt sagen, hier jetzt mal als Dreibezähler,
der Zähler soll jetzt eben auch noch zusätzlich eine zweite Eingangsleitung haben,
mit der ich eben umschalten kann zwischen vorwärts und rückwärts zählen.
Und bei Enabled Live Null würde der Zustand quasi nicht verlassen werden.
Bayern Elbled gleich eins und V gleich eins für vorwärts zählen,
wird entsprechend vorwärts gezielt und bei Enabled
gleich eins und V gleich Null für rückwärts zählen wird dann
entsprechend rückwärts gezielt
Nicht jetzt mal das Ganze noch als 5 PC,
da fängt es dann schon an mehr als unübersichtlich zu werden. Das heißt,
wenn ich jetzt sowas wie so eine Reset-Bedingung habe,
die jetzt einfach hier nochmal eingearbeitet ist, nur dass man sieht,
wie sich das dann also im Zustandsdiagramm auswirkt,
sieht man,
dass sich also jetzt ab bei jedem beliebigen Zustand dann eben
quasi hier noch so eine Kante auf den ausgewählten Anfangszustand habe,
der dann quasi jetzt entsprechend dann eben dem Zielerstand Null entspricht
Gut, in der Regel macht man sich jetzt natürlich bei irgendwelchen Zehlern nicht die Mühe,
dass also jetzt irgendwie formal als Automat aufzuschreiben, beziehungsweise so herzuleiten,
mich aber im Prinzip ist es eben schon so,
dass also auch sämtliche Zähler letztendlich als Automaten aufgebaut werden.
Hier sind jetzt also dazu nochmal einige wirklich Schaltungen,
wie sie jetzt also in Hades realisiert werden,
nicht einmal hier als ein Vierbit-Binärzähler,
wo dann also auch mal diese ominösen JK-Flip-Flops eingesetzt werden.
Das waren also Flip-Flops, die jetzt quasi zwei Steuerleitungen haben,
wo ich dann eben sagen kann,
ich möchte sie entweder setzen, ich möchte sie zurücksetzen.
Zustand soll sich nicht ändern oder der interne Wert soll negiert werden.
Nicht, und das ist also genau das, was man
eigentlich beim Zählen ja macht. Wenn ich mir also vorstelle,
quasi an der niederwärtigsten Stelle,
wird beispielsweise mit jedem Tag das Bit quasi negiert,
was man dann also hier dadurch sieht,
dass ich sage,
hier konstant werden jetzt also diese beiden Eingänge jeweils mit eins
beschaltet und der würde dann eben mit jedem Takt
entsprechend negiert werden
Nicht bei der nächst höheren Stelle, da würde der Ausgang
jetzt eben entsprechend wechseln oder bei irgendwelchen höheren Stellen,
wenn aller niederwärtigsten Bits entsprechend mit eins gesetzt sind.
Das ist ja quasi genau das,
was man beim Zielen als Bedingungen immer hat,
dass wenn ich also beispielsweise einen Vier-Bit-Zähler habe und 0,
1, 1, 1 habe,
das dann mit dem nächsten Tag gleich dann quasi den Übertrag habe und demzufolge dann 1,
0, 0, 0 als Ausgang habe.
Und das ist dann hier immer dadurch,
in dieser Schaltung auch realisiert, dass quasi jetzt hier beim Bit1,
also dem zweiten niederwärtigsten Bit, quasi wenn dieser Ausgang eins ist,
würde der invertieren, bei dem Nächsten müssten,
müsste eben dieses Bit und dieses Bit 1 sein und hier hätte ich,
würde ich dann eben quasi das Ganze jetzt mit den
drei Ausgangsbits zusammenfassen
Gut, das war,
oder wäre dann ein Zähler mit Jörg Carflip-Flops, mit Deflip-Flops,
wo ich also letztendlich ja immer nur den Eingang auf den Ausgang übernehme,
müsste ich dann eben die zugehörige Logik entsprechend mit Gattern,
kodieren, hier jetzt als ein Beispiel, so ein Feelbit miniert Zähler,
der dann eben auch noch kaskadierbar ist, das heißt,
also es gibt dann eben sowas wie so einen Carry-in-Eingang und irgendwann am Ende dann eben auch ein Carry-out,
Ausgang, und das war es dann also letztendlich hier an Funktion dann auch jeweils stattfindet,
ist dann im Prinzip jetzt, also das,
was also in einer ganz normalen Arrethmetik für ein Zählen plus eins notwendig ist,
das heißt, beim niederwärtigsten Bit, das würde eben wechseln,
wenn der eigene Wert exklusiv oder dem Carry in gerechnet wird,
das heißt also, wenn Carry in eins ist,
würde es eben bei jedem Tag wechseln und bei den anderen Bitsfördern eben entsprechend gelten Carry in und alle niederwärtigeren Bits gleich eins,
also genau im Prinzip der gleiche Ausdruck wie vorher,
exklusiv oder dem entsprechenden,
eigenen Wert und dann wird das torgeln,
was dann also hier über diese Kaskade letztendlich aufgebaut ist.
Und also auch das könnte man dann So,
könnte man dann Assi hier entsprechend dann also auch in Hades simulieren,
wo ich jetzt also hier Carrie in gleich eins habe.
Und mit dem jeweiligen Tag würde das dann also hier dann entsprechend,
das sind dann die Ausgangsbilds, weitererzählen, also jetzt Zustand 3,
4, 5, 6, 7, 8,
wo ich dann den Übertrag hierüber habe und so weiter und so fort.
Und wenn ich Carrie in auf null setze,
sieht man, wird das Ganze letztendlich angehalten und Erzähler,
tut dann entsprechend nichts weiter, beziehungsweise wartet dann eben wieder auf diese Leitung.
Was man in vielen Schaltungen dann auch noch hat,
weil das ja so eine Vergleichsweise effiziente Realisierung von Zählern ist,
sind sogenannte asynchrone Zähler, weil alles,
was ich bis jetzt vorgestellt hatte, waren synchrone Zähler,
das heißt sämtliche Flipflops des Automaten kriegen den gleichen Tag.
Bei asynchronen Zählern benutze ich quasi das Bit,
der niedrigeren Stufe, dann als Takt der nächst höheren Stufe.
Das heißt, ich habe jetzt hier ein erstes Flip-Frop,
was also jetzt quasi hier den Ursprungstakt bekommt.
Dann einfach nur den negierten Ausgang auf den Eingang wieder zurückkoppelt.
Das heißt, der torgelt mit jedem Takt und der Ausgang
dieses Flip-Flops stellt dann eben den Takteingang der nächsten Stufe da und so weiter und so fort.
Und mit der Gesamtschaltung wird dann quasi jetzt mit jeder Stufe
der Takt letztendlich halbiert
Dadurch, dass ich hier jetzt eigentlich keinerlei Logik mehr drin habe,
hat man also den Vorteil,
dass diese Schaltung mit sehr hoher maximaler Taktrate betrieben werden kann,
um beispielsweise jetzt eben in irgendwelchen Schaltungen dann also auch einigermaßen einfach und effizient langsame Takte zu generieren.
Nachteil dieser ganzen Schaltung, deswegen also hier nochmal in Rot hervorgehoben, ist Achtung.
Bei Synchronzählern schalten alle Bits Im Prinzip gleichzeitig. Das heißt,
da habe ich eben wirklich nur die Verzögerungszeiten des Flip-Flops,
also das, was ich in der letzten Woche in diesen Grafiken
immer als Tau-FF bezeichnet hatte, die dort eigentlich wirksam werden.
Bei Asynchronschaltungen schalten die einzelnen Bits da quasi jetzt hier ein Bit,
was Storgle dann immer als Takteingang des Nächsten dient, mehr oder minder sequenziell nacheinander.
Also auch das könnte man dann sich beispielsweise in Hades,
wovon es da also dann, glaube ich,
auch eine entsprechende, langsamere Version gibt, ansehen.
Das war natürlich wieder die falsche Schaltung, Entschuldigung. So,
also hier sieht man jetzt im Prinzip, dass entsprechend Schnelle Taktsignal,
was dann also jetzt hier jeweils das erste Bit,
dann eben hier um einen runtergetaktet.
Also sprich, dann hier als takthalbiert, taktgeviertelt, durch acht geteilt,
durch 16 geteilt, durch 32 geteilt und so weiter und so fort.
Und was man sieht, also gerade,
wenn jetzt also hier entsprechend Überträge nach hier vorne auflaufen,
wie sich das Ganze dann eben teilweise hier wirklich so sukzessive durchhangelt,
beziehungsweise wenn man sich da jetzt,
also das über entsprechende Signale hier ansehen würde.
Ich werde hier mal einfach mal so ein paar von diesen
Props reinhängen. So, und wenn man das Ganze jetzt
einmal kurz laufen lässt, dann wieder anhält.
Ich hoffe, ich habe jetzt hier nicht zu viel versprochen.
Dann sollte man hier eigentlich sehen,
dass es hier also eine gewisse Zeitdifferenz gibt
Mhm. Das ist natürlich der Vorführeffekt,
wenn man das jetzt vorher nicht ausprobiert hatte.
Das tut mir jetzt leid. Also eigentlich sollten Propagation Delay,
gut, man müsste hier diese Zeit noch entsprechend weiter raufsetzen.
Sollten die Philip Floffs dann eben entsprechend ein bisschen langsamer nacheinander
schalten und das müsste man dann eben auch als Zeitversatz
eben in diesen Impulsdiagramm
direkt so sehen können
Gut, also asynchrone Zähler wäre jetzt im Prinzip eben immer
diese Hintereinanderschaltung von Zählen an, wo man das dann eben entsprechend macht.
Gut, und hier das Ganze dann eben auch nochmal als
hartes Beispiel als ein vorwärts und ein Rückwärtszähler,
wo dann im Prinzip der Zähler stand jetzt direkt auf so eine Sieben-Segmentanzeige gegeben ist.
Und ich hoffe, dass das jetzt so hier mal entsprechend
langsam getaktet ist, dass man da also jetzt was sieht.
Also das wäre jetzt hier der Vorwärtszähler,
wo ich jetzt eben da rein nach vorwärts umschalte,
so und eben hat man schon gesehen, dass es hier eine gewisse Verzögerung gab.
Und also spätestens jetzt, wenn ich also hier gleich den Übertrag,
also nach hier hinten hätte,
würden diese Ausgänge nacheinanderschalten beziehungsweise in dem,
in dieser sieben Segmentanzeige,
müsste man dann eben auch zwischendurch also beliebige,
ich sag mal,
unsinnige Werte sehen
Gut, also zumindest das hat jetzt mal geklappt.
Gut, und beim Rückwärtszähler eben entsprechend analog. Gut,
solche Zielschaltungen oder solche asynchronen Zielschaltungen, wie gesagt,
gibt es relativ viele, also gerade so anfangs in der Computertechnik,
also bei diesen 74er-Baureihen von ICs wurden die dann eben auch teilweise verwendet.
Also das ist jetzt auch hier ein IC-74-92,
auch irgendwie ein Zählertyp, den man mit 4 Jörg Carfliffrops,
den man eben benutzen kann, für unterschiedliche Teilerverhältnisse,
entweder als den Tag halbieren,
den Tag sechsteln oder den Tag durch zwölf teilen,
wo ich dann im Prinzip einmal hier getrennt die erste Stufe habe,
die den Tag durch 2 teilt und dann eben hier mit den drei Flip-Flops dann eine Zustandsfolge von 6 Zuständen durchlaufe,
Damit entsprechend eins durch sechs teilen kann.
Oder wenn ich eben diesen Takt nehme und den dann
als Eingangstag für diese zweite Stufe benutze,
könnte man dann eben eins durch zwölf teilen.
Gut durch entsprechende Beschaltung lässt sich das da machen. Also wenn sie wollen,
können sie es da so gerne auch nochmal mit dem Hades ausprobieren.
Ich habe das einfach nur mal so als so ein Beispiel für
jetzt unterschiedliche Zähleeingänge. Hier dann nochmal eine etwas komplexere Schaltung,
dann auch nochmal einen Vorwärts-Rückwärtszieler mit JK, Flip-Flops,
wo man dann im Prinzip auch über Entsprechende Beschaltung der Eingänge,
jetzt mit dieser Enable-Leitung dafür sorgt, dass ich zum einen vorwärts zielen kann.
Das heißt, der Übertrag wird jetzt eben erzeugt,
wenn Alan ideawertigsten Bits 1 sind oder rückwärts zielen kann.
Da wird der Übertrag eben genau dann erzeugt,
wenn alle niederwertigsten Bits null sind.
Also auch das kann man dann eben entsprechend ausprobieren,
will ich jetzt aber hier nicht weiter
Größer nochmal vorführen. So, als letztes Beispiel jetzt zu diesem Zählschaltung,
beziehungsweise als Beispiel nochmal für so einen etwas größeren Automaten oder
eigentlich so eine ganze Folge von Automaten.
Hier nochmal so ein Beispiel, wo es also im Prinzip
jetzt um diese DCF77 gesteuerte Digitaluhr geht.
Zum einen ist hier erstmal angedeutet, im Prinzip eine Zielschaltung,
mit der im Prinzip eine BCD-Arthmetik realisiert ist.
BCD war ja Bine-Recorded Desimil. Das heißt,
ich habe im Prinzip vier Bit-Zähler, die zählen aber eben
immer nur von 0 bis 9 und dann wieder zyklisch entsprechend weiter durch.
Sowas wird eben ganz gerne verwendet,
beispielsweise jetzt eben in solchen Schaltungen,
wo man dann eben direkt mit jeder Stelle dann also sowas
wie so eine 7-Segmentanzeige ansteuern möchte
Und das, was also jetzt hier in dieser Schaltung dann auch realisiert ist,
ist, dass man eben sagt,
das ist jetzt also ein Zähler, den ich,
wenn ich ihn also jetzt hier mit einem ein Herz takt,
beschalten würde, also sprich mit einem Sekundentakt, dann eben anfängt,
im Prinzip jetzt wie so eine Uhr-Sekunden genau zu zählen,
weil dieses hier ist jetzt jeweils immer eine Stelle, die zählt,
die dann eben hier höchster oder an dieser Stelle dann eben hier jetzt quasi als Impuls ein Übertrag erzeugt,
das heißt bei der neuen Und war es jetzt eben hier gemacht als Trick,
ist, dass quasi dieser Übertrag dann dadurch erzeugt wird,
dass ich hier über eine Logik, die den Ausgangswert sechs dekodiere,
der dann quasi ein Reset-Signal hier ansteuern würde.
Das heißt, wenn der jetzt eben hier nach,
oder wenn ich jetzt eben hier nach 59 gezählt habe,
dann hier den Übertrag hätte, würde der eigentlich weiter schalten,
die Sechs führt aber dazu,
dass der dann eben auch sich selber quasi wieder zurücksetzt und dann eben den Übertrag hat.
Das heißt, also hiermit hätte ich jetzt eben beispielsweise so
eine Modulo 950-Arrat-Meeting und würde dementsprechend da so raufzählen,
dass man dann eben beispielsweise hier die Sekunden zählt bei den Minuten hier
genau das Gleiche und bei den Stunden wird dann im Prinzip hier die 24 rauskodiert,
um dort die entsprechenden Überträge zu generieren.
Gut, das Ganze einmal in Hardesquads gezeigt. Wäre jetzt
also hier diese Schaltung, die jetzt also hier anfängt,
mit entsprechend langsamer Glock die Sekunden zu zählen.
Und wenn ich das Ganze jetzt hier gleich bei 59 habe,
würde dann eben der entsprechende Übertrag hier erzeugt werden und dann hier ein weiter zählen.
Hier kann man nochmal kurz das Ganze also auf etwas
Eine etwas schnellere Clock umschalten, um dann also auch noch ein paar andere Werte auszuprobieren. Gut,
das war jetzt, sagen wir mal, erst mal so eine Schaltung,
mit der man eben beispielsweise jetzt eine Uhrenschaltung mit entsprechenden Zählern und entsprechender Zusatzlogik so aufbauen kann,
dass ich jetzt eben so eine 24 Stunden, 59 Minuten,
59 Sekunden, Erdmetik in Sportler, realisiert bekomme.
Und das, was dann eben hier Folgen wir noch kurz vorgestellt,
ist es dann eben, dass man sagt, okay,
wenn ich so eine Schaltung habe,
wo ich das Ganze dann eben auf,
indem ich jetzt diese zähle oder diese entsprechenden Register dann eben auch noch so umbaue,
dass sie quasi mit Werten geladen werden können und diese Werte selber kommen jetzt eben wieder aus einem eigenen,
endlichen Automaten, der jetzt im Prinzip das macht,
was also in diesem DCF 77,
also in diesem Zeitzeichen Signal übertragen wird.
Nicht, das heißt, diese funkelsteuerte Uhr wäre dann eben
wirklich so ein Beispiel, so einen etwas komplexeren Scheidung,
wo ich dann eben Mehrere diese Einzelkomponenten entsprechend zusammenbaue.
Jede für sich ist quasi was wie ein eigener,
endlicher Automat, beziehungsweise eben entsprechender Zähler,
die dann eben miteinander gekoppelt sind, nicht in das,
was da dann eben passiert jetzt in diesem zusätzlichen Frontend,
ist, dass eben dieses Langwellensignal quasi dekodiert wird.
Das Signal ist so aufgebaut,
dass pro Sekunde ein einzelnes Bit übertragen wird,
in einer Minute selber
werden 59 Bit gesendet
Und technisch gesehen, also beispielsweise eine Beschreibung wäre,
also hier in der deutschen Wikipedia, sieht das so aus,
dass man, wenn ich jetzt,
also hier so ein Impulsdiagramm hätte, man das so interpretieren kann,
dass es eben einen Pegel gibt, der wird irgendwann abgesenkt,
bleibt dann eben eine Zeit lang auf Null,
wird dann wieder angehoben und bei der nächsten Absenkung,
also quasi in der Periode zwischen diesen beiden,
hat man jetzt genau eine Sekunde, dadurch wird quasi jetzt beschrieben,
wann eine neue Sekunde beginnt und dieser Null Pegel,
der dort quasi dann übertragen wird.
Den gibt es eben einmal in einer kurzen Variante von
100 Millisekunden und einem einer langen Variante von 200 Millisekunden,
die dann eben entweder als logische Null oder als Eins interpretiert wird.
Nicht in Varys kam man dann eben mit diesem Signal jetzt einzelne Bits übertragen. So,
und in diesem 59 Bit, die dann also übertragen werden,
ist dann quasi kodiert das Datum, die Uhrzeit der kommenden Minute,
ob innerhalb der nächsten 24 Stunden sowas wie eine Sommerzeit,
Winterzeitumstellung stattfindet,
ob während der nächsten oder kommenden 24 Stunden dann im Prinzip noch sowas wie eine Schaltsekunde folgt,
was ja dann alle paar Jahre auch immer mal passiert.
Und diverse andere Informationen. Wie gesagt, in der Wikipedia,
nur als Beispiel ist dann also im Prinzip dieses Protokoll dann entsprechend beschrieben.
Gut, dafür kann man sich dann eben auch irgendwo so ein Schaltwerk beschreiben als endlichen Automaten.
Und wenn man dann eben so ein Gesamtsystem mal simulieren möchte,
also hier dann die Referenz auf die entsprechende Hades Web-Demo,
beziehungsweise die entsprechenden Hades-Seiten, hätte man dann letztendlich diese Schaltung,
wo ich dann eben sage, ich habe hier einmal so eine Komponente,
die so tut, als ob sie einen DCF77-Sender ist. Das heißt,
oder dort kann man dann quasi die zu sendende Information einstellen und das wird dann eben in dem entsprechenden Protokoll hier über eine Einbettleitung rausgeschickt und gleichzeitig habe ich dann eben hier einmal einen Automaten,
der sich in dieses Protokoll einsynchronisiert, dann ihm irgendwann feststellt,
er hat eben eine Null oder eine Eins-Empfang,
wenn er sie richtig empfangen hat,
wird das quasi hier in so ein Schieberegister gegeben und wenn er das jetzt über eine ganze Minute richtig empfangen hat,
gibt es dann eben die entsprechende Information,
jetzt ist oder jetzt ein Datum und Uhrzeit übertragen und die empfangene Information wird dann eben in diese Zielregister von den Ansagen entsprechend geladen.
Gut, also wie gesagt, das Ganze können Sie dann
also gerne auch nochmal simulieren oder sich ansehen.
Auch hier nur kurz als Information. Ich habe jetzt die Folien alle nochmal etwas überarbeitet,
nachdem ich mich da also schon gelegentlich mal etwas blamiert habe,
als ich so die entsprechenden Hadesbeispiele irgendwo im Dateisystem gesucht habe.
Inzwischen sind Zumindest jetzt in diesem Kapitel,
ich werde das dann auch noch für die vorhergehenden Kapitel zu den Schaltennetzen entsprechend auch noch mit einbauen,
die jeweiligen Referenzen direkt auf die entsprechenden Webseiten mit angegeben,
sodass sich das Ganze dann,
wenn sie das selber mal ausprobieren möchten und zumindest also der
Akrobatrie der Externe oder der PDF-Frieda-Externe links unterstützt,
dass man das dann eben dann direkt von aus dem Skript
heraus starten kann
Gut, das wäre dann eben hier nochmal so ein Beispiel,
wie jetzt also irgendwie dieses Schaltwerk von diesem Dekoda aussieht.
Da kann man auch nur sagen, das ist Gelinde gesagt,
mehr als unübersichtlich, wobei ich dann auch mal natürlich sagen muss,
also solche Schaltungen sind dann meistens schon nicht mehr selber manuell entworfen.
Von daher brauchen sie dann also auch keine Angst zu haben.
Also sowas wird es also bestimmt nicht als Übungsaufgabe und schon gar nicht als innerhalb der Klausur geben. Nicht,
sondern also um jetzt auch irgendwie auf so eine Schaltung zu kommen,
arbeitet man dann in der Regel mit irgendwelchen programmiere oder entsprechenden Entwurfswerkzeugen, wo ich beispielsweise jetzt über Hardware-Beschreibungssprachen sage,
also die Schaltung soll den und den Automaten realisieren und ich schmeiße das dann eben in ein entsprechendes Werkzeug rein und kriege dann also sowas hier raus. Gut,
eine andere Sache,
die dann also hier bei diesen Beispielen dann auch immer noch mit drin ist,
ist dann etwas, was man dann also auch immer noch so als zusätzlichen Trick zum Beispiel bei solchen sieben Segmentanzeigen macht,
was also dann auch häufig bei irgendwelchen kleinen,
selbstgebastelten Schaltungen gerne gemacht wird, wenn ich,
wie jetzt also hier in diesem Beispiel,
entsprechend viele sieben Segmentanzeigen anzusteuern habe und sage, okay,
ich möchte jetzt noch gar nicht mal das Datum sehen,
sondern möchte jetzt einfach hier nur mal sechs Stellen für die entsprechenden Uhrzeit angezeigt haben,
dann sieht das bei irgendwelchen Hardwareaufbauten natürlich so aus,
dass ich quasi für jedes Segment eine einzelne Leitung habe,
also jetzt anders als hier bei diesem Hades-Beispiel,
wo ich jetzt so im Prinzip hier nun vier Bit-Binärwert reinschiebe und das Ganze hier innen drin quasi dekodiert wird.
Und ich hebe im Prinzip jetzt hier sowas wie eine Hexerdezimalanzeige habe,
sind eben wirklich jetzt physikalische Bausteine so aufgebaut,
dass man also alle Segmente unabhängig voneinander ansteuern kann.
Das heißt, ich habe hier jeweils sieben Leitung.
In der Regel hat man noch Spannungsversorgung,
Dezimalpunkt und so weiter und so fort.
Das heißt also irgendwie so Größenordnungsmäßig zehn Leitungen. Davon jetzt für sechs Anzeigen,
würde dann also irgendwie 60 Leitungen oder wenn ich das jetzt
hier als kleine Schaltung habe, also 60 ein Ausgabepins benötigen.
Dafür, dass man hier innen drin eigentlich nur irgendwie so
ein trivial einfachen Automaten hat.
Also nicht sonderlich viel tut, ist das natürlich
vergleichsweise viel
Hardware-Aufwand. Deswegen benutzt man dann eigentlich mal ganz gerne den
Trick, dass man ein Zeitmultiplex-Verfahren benutzt. Das heißt,
ich habe eigentlich nur für eine einzige sieben-Segmentanzeige die Ausgangsleitung
und wähle dann zusätzlich noch über einen zweiten Bus aus,
welche von diesen sieben-Segmentanzeigen jetzt quasi gerade angesteuert werden soll.
Und was man dann eben macht,
das ist man quasi von einer einen Stelle,
die entsprechende Belegung ausgibt,
die dann eben ansteuert
Die blitzt quasi einmal kurz auf,
anschließend nimmt man dann eben die nächste Stelle der Anzeige,
legt dann also quasi den Inhalt, der dort dargestellt werden soll,
auf diese sieben Ausgangsleitungen und beschreibt dann eben,
dass diese Stelle ausgegeben werden soll.
So, und wenn man das also entsprechend schnell macht,
kriegt man als Mensch das mit seinem Auge eben nicht mehr auseinander,
sondern die Anzeigen sind da halt einfach nur ein bisschen dunkler als normal,
aber man spart dadurch dann,
also wie jetzt hier in diesem Beispiel beschrieben,
dann eben entsprechend
viele Leitungen ein
Gut, also auch dazu gibt es dann hier nochmal so ein hartes Beispiel, wo das Ganze dann beschrieben ist.
Das werde ich jetzt aber, weil da also der Erkenntnisgewinn relativ gering ist, also jetzt nicht weiter vorstellen. Gut,
abschließend zu dem Kapitel Schaltwerke,
weil ich jetzt nochmal ein bisschen was zu Asynchronschaltungen sagen oder vorstellen,
weil ich hatte ja schon eine Angst gesagt,
wenn man jetzt eigentlich so ein Schaltwerksentwurf hat,
werden wir denn in der Regel eigentlich immer nur kennenlernen in der Art und Weise,
dass man sagt, ich habe,
muss ich mal ein bisschen zurückspulen,
Also ich habe hier sowas wie ein Mili oder ein Moor-Modell,
wo ich dann eben sage, gut,
ich beschreibe hier jetzt irgendwo meine Schaltnetze und habe an dieser Stelle dann eben wirklich ein Vorderflanken gesteuertes Register.
Das heißt, Zustand und Folgezustand sind dann eben immer über dieses Register voneinander getrennt.
Es gibt ein Taktsignal und entsprechend den Bedingungen,
die ich da dann ja also auch bei dem Zeitbedingungen hier vorgestellt habe,
ändern sich dann eben die Werte, beziehungsweise die Ausgänge und ich habe eben entsprechende Zeitbedingungen dann eben beispielsweise auch Verangangswerte.
Einzige Ausnahme, wo ich jetzt eben wirklich sowas wie eine asynchrone Schaltung habe,
sind die Flip-Flops selber, wo man dann eben sagen kann,
also ich habe quasi dieses Basis-RS-Flip-Flop und alles,
was dann da drauf aufbaut, was formal gesehen dann eben wirklich sehr sauber entworfene, asynchrone Schaltung sind.
Jetzt könnte man natürlich auf die Idee kommen und sagen, gut,
Ich versuche jetzt eben so ein Asynchronenentwurf nicht nur für solche Vergleichsweise einfachen Schaltungen zu machen,
wie jetzt also hier so ein RS-Flip-Flop,
sondern ich versuche so ein Asynchronenentwurf,
also wirklich schon für irgendwelche komplexeren Schaltungen zu machen,
um jetzt beispielsweise sowas wie jetzt also hier So ein etwas größeres Beispiel,
also hier diese Digitaluhr oder irgendwas, entsprechend zu realisieren.
Und da kann man sagen, also prinzipiell ist das möglich,
allerdings muss man da dann,
also beim Entwurf relativ viel Aufwand treiben.
Es geht aber im Prinzip und geht eben auch schon so weit,
dass man sagen kann,
also ich kann auch ganze Prozessoren oder Prozessorkerne als asynchronische
Haltung entwerfen
Zumindest also von dem Armprozessor gibt es also eine Variante,
die entsprechend arbeitet, die den Vorteil hat, dadurch,
dass ich keinen zentralen Tag tat, ist sie vergleichsweise sehr energiesparend.
Das ist dann eigentlich, sagen wir jetzt, auch der Grund,
wo man sowas einsetzt. Zum einen jetzt hinsichtliches Energieverbrauchs.
Zum anderen könnte man auch sagen, wenn man das sauber hinkriegt,
kann man, werden die Schaltungen im Prinzip auch schneller.
Das werde ich also, glaube ich, auf der nächsten Folie zeigen. Das Problem ist,
wenn ich jetzt sage, also ich nehme es,
dass ich hier irgendwie sowas Größeres wie jetzt, also irgendwie ein Vier-Kern-Prozessor,
da kriegt man das jetzt eben nicht mehr so einfach vom Entwurf her hin,
den jetzt wirklich in Form so eine Asynchronschaltung zu realisieren.
Deswegen gibt es da jetzt, also sagen wir mal,
von den großen Ship-Herstellern, also jetzt noch keine entsprechenden Prozessoren, die sowas im Prinzip machen.
Was man bei solchen Asynchronschaltungen im Prinzip dann eben immer machen muss,
ist, dass man sagt,
in der Regel sind eigentlich alle Prozessoren oder alle Schaltungen,
ähnlich wie ich das jetzt in diesem Beispiel mit dem DCF-Dekoder auch schon beschrieben habe,
Mehrere gekorpelte Automaten.
Das heißt, ich habe also irgendwie einen Zähler,
der irgendwas macht und ich habe irgendeinen anderen Automatel irgendwas macht und die unterhalten sich jetzt immer irgendwie miteinander.
Und wenn da ein jetzt, also sagen wir mal,
sein Ergebnis berechnet hat, kann der Nächste damit also jetzt entsprechend weiter arbeiten. Bei Asynchronenschaltungen,
wo ich das Ganze jetzt eben nicht über einen Takt synchronisiere,
muss ich dann eben zwischen diesen Teilen der Schaltung dann eben irgendwelche mehr oder minder aufwendigen Protokolle realisieren,
wo dann eben quasi gesagt wird,
dass Eine Berechnung nur starten kann,
wenn am Eingang quasi alle notwendigen Eingänge oder Operanten verfügbar sind.
Also wenn ich mir zum Beispiel sowas wie eine Alu vorstelle,
dann soll die Alu eben erst dann das Ergebnis ermitteln,
wenn also alle Eingangswerte gültig sind.
Und wenn das Ergebnis am Ausgang der Alu,
also nach der arathmetischen oder logischen Operation anliegt,
soll dann eben auch wieder eine Schaltung dafür sorgen,
dass nachfolgende Stufen eben feststellen,
jetzt kann ich mit diesem mir diesen Wert abholen und
damit weiterrechnen
Vorteil bei dem Ganzen eben dadurch, dass ich keinen zentralen Takt habe,
der sich immer nach der langsamsten Konmponente richten muss,
wird die Schaltung im Prinzip schneller. Problem ist allerdings,
wie gesagt, das wirklich sauber vom Entwurf her zu realisieren,
beziehungsweise dann eben auch schon mal überhaupt solche Schaltungen zu initialisieren.
Gut hinsichtlich der Performance hier nochmal die Grafik,
auf die ich eben schon angespielt hatte,
wo im Prinzip angedeutet ist, dass,
womit wir eigentlich in der Regel zu tun haben, sind synchrone Entwürfe,
wo ich also ein oder mehrere Tage meinetwegen auch habe.
Letztendlich arbeitet das aber alles eben immer so,
dass ich sage, irgendwo gibt es eine Komponente oder einen Rechenweg,
der in meinem gesamten Ablauf irgendwann mal am längsten dauert.
Und an dieser Maximalzeit wird dann letztendlich nachher die Taktperiode festgelegt,
wo ich dann eben sage,
die muss größer sein als die Zeit für diese Berechnung
Plus einer Setup-Zeit für irgendwelche Register, die dann also quasi dieses Ergebnis hier übernehmen.
Plus, das fehlt hier zumindest noch, dann also sowas wie eine Hohlzeit,
die dann quasi hier den Registerwert am Eingang von irgendwas hat.
So, diese Vergleichsweise noch lange Zeitraum tritt aber eben nur in ganz speziellen Fällen auf. Also hier zum Beispiel jetzt,
wenn man sagt, ich habe sowas wie einen Prozessor,
der jetzt also unterschiedliche Operationen ausführt,
die dann also irgendwo als Sambler-Befehle dort angegeben sind,
dann wird eben beispielsweise sowas wie eine Multiplikation in Hardware vergleichsweise aufwendig sein,
wird am längsten Zeit brauchen, nicht bei der Addition,
das geht schon deutlich schneller,
beziehungsweise kann dann eben auch noch abhängig sein,
mit welchen Operanten ich rechne und bei anderen Operationen habe ich dann eben auch sehr stark unterschiedliche Zeiten.
Nichtsdestotrotz verschenke ich hier natürlich immer entsprechend viel, weil ich einfach
hier diese Maximalzeit für die Berechnung der Tagperiode zugrunde legen muss.
Bei Asynchronenschaltungen sagt man eben, jede Schaltung braucht wirklich nur
so lange, wie für die eigentliche Berechnung.
Das heißt, Gatterlaufzeiten in der Arithmetik veranschlagt werden.
Und dann brauche ich eben noch mal zusätzlich hier vielleicht also bestimmte Zeiten,
wo dann eben genau dieses Protokoll,
was also jetzt hier als T-Handshake quasi gekennzeichnet ist,
dann eben abläuft, um dann zu sagen,
okay,
ich habe jetzt,
dass hier ein Ergebnis berechnet und das kann jetzt eben in
irgendeiner anderen Stufe für irgendeine andere Operation weiter benutzt werden
So, für diese Protokolle kann man sich jetzt also verschiedene
sehr unterschiedliche Realisierungen vorstellen. Also hier sind nur einige kurz skizziert.
Zum einen kann ich sagen, ich habe im Prinzip,
als ich hier sowas wie eine Datenleitung,
die von einem Block zum nächsten Block geht,
habe dann also hier einen Signal namens Request und ein anderes Signal namens Seknowledge.
Das ist eigentlich immer so das Einfachste, das Naheliegendste,
was einem Informatiker, sagen wir mal so, einfällt,
wie sich jetzt also irgendwelche asynchron laufenden Teile miteinander unterhalten.
Und da kann man dann eben auch unterschiedliche Teilprotokolle oder Implementationen
wählen. Zum einen kann ich das also pegelabhängig machen,
also deswegen hier als Level bezeichnet, wo dann eben sage,
irgendeine Komponente hat hier ihre Daten fertig berechnet.
Die stehen quasi zur Abholung jetzt bereit.
Demzufolge wird dann also dieses Request-Signal auf 1 gesetzt
Der Empfänger der Daten stellt das dann fest,
setzt seinerseits dann quasi das Knowledge-Signal auf 1, um dann eben zu signalisieren,
okay, ich werde mir jetzt gleich die Daten abholen.
Daraufhin kann dann eben dieser Sender wieder das Request-Signal auf null
zurücksetzen und der wird jetzt ihm hier entsprechend anfangen mit den Daten was zu machen,
wenn er damit fertig ist,
wird dann eben dieses Acnoledge auf null zurücksetzen,
woraufhin dann eben Dieser Sender jetzt quasi wieder neue Daten auf den Bus legen kann.
Oder man könnte sich das Ganze ein bisschen einfacher machen,
wo ich das dann eben nur flankenabhängig, deswegen heißt es,
oder hier als Edge gekennzeichnet machen würde,
wo ich dann eben sage, okay,
bei neuen Daten wechselt der Sender eben den Zustand von 0 nach 1 oder von 1 nach 0.
Und der Empfänger würde eben wechseln, wenn er die Daten komplett fertig verarbeitet hat.
Nicht, also das nur so als ein Beispiel,
wie jetzt ein Handshake-Protokoll aussehen kann. Andere Alternativen wären dann im Prinzip sowas,
indem ich hier eigentlich jetzt für die einzelnen Bits das jeweils kodiere,
indem ich dann also quasi jetzt hier zwei Datenbündel habe,
in denen eben kodiert ist.
Es gibt also einen gültigen Wert, null, beziehungsweise einen gültigen Wert 1.
Und es gibt dann eben einen ungültigen Wert,
womit dann eben signalisiert wird. Ich bin noch dabei,
hier irgendwas zu berechnen. Nicht letztendlich wird damit dann also
quasi die Funktion dieses Request auf der Bit-Ebene realisiert
Gut, eine beliebte Schadung bei diesen asynchronen Schaltungen oder
womit das dann also letztendlich dann auch realisiert werden kann,
ist etwas, was sich nach dem Erfinder dann Mala Seegate nennt.
Ist an sich als Schadung selber ein asynchrones Schaltwerk,
wo dann eben der Ausgang dieses Segates quasi dann auch als Eingang rückgekoppelt wird.
Und die Funktion ist also jetzt hier in diesem KV-Diagramm letztendlich beschrieben,
dass man eben sagt, wenn beide Eingänge null sind,
Dann wird auch der Ausgang null.
Wenn beide Eingänge eins sind, wird der Ausgang eins.
Und ansonsten ändert sich der Wert von diesem CG nicht.
Das heißt also, das sieht man hier eigentlich ganz gut,
wenn ich ja sie hier oben jetzt A und B habe.
Beide sind null. Damit erzeuge ich hier an diesem CG
dann oder am Ausgang dann eben auch eine Null.
Wenn beide eins sind, erzeuge ich hier eben auch entsprechende eins.
Und in den anderen beiden Fällen wurde sich dann eben,
wenn es CG null ist, nichts ändern.
Beziehungsweise wenn es CG eins ist, hier auch nichts ändern. Gut,
das Ganze kann man dann eben ganz normal über KVD-Rahmen,
also hier in drei Schleifen zusammenfassen,
hätte da dann eben quasi diese Rückkopplung von dem Ausgang hier auf diesen Eingang dann,
oder dieses CG dann eben auch als zusätzlichen Eingang und wäre dann also quasi bei dieser Hades-Schaltung.
Im Prinzip lässt sich das Ganze dann eben auch noch auf drei oder mehr Eingänge erweitern.
Was man dann eben machen kann mit diesem Segate, dadurch,
dass sie dann quasi diese Zustände selber dort eben auch zwischengespeichert werden,
das zu benutzen für diesen Signalisierungsmechanismus von so einem Handshake-Protokoll.
Und als ein, sag ich mal, sehr einfaches Beispiel dazu,
hätte ich jetzt also hier noch kurz eine sogenannte Mikropipeline,
das heißt, die Daten werden in irgendwelche Register,
beziehungsweise in dem Fall in Ledges hineingeschrieben und ich kann dann eben,
je nachdem, wie viele Daten ich reinschreibe, das Ganze entsprechend auch noch pofern.
Das heißt, die Pipeline kann dann eben entsprechend vorlaufen.
Was man hier jetzt im Prinzip sieht,
würde ich jetzt hier gleich nochmal an der Grafik erklären.
Ich habe hier im Prinzip sowas wie so ein Zwei-Phasen-Takt,
wo ich hier die Daten reinschiebe.
Das ist also quasi jetzt hier diese Mikropipeline,
wo also im Prinzip Daten immer irgendwie hier durch die
einzelnen Stufen durchlaufen können
Entsprechend dann hier gespeichert werden. Und was ich jetzt also
hier entweder als so ein Zwei-Phasen-Takt entsprechend dann realisieren würde.
Oder ich sage jetzt eben jede dieser Stufen wäre dann quasi ein einzelnes Speicherelement,
was sich dann also quasi per Request und Aknowledge mit der nächsten Stufe unterhält.
Nicht womit ich dann eben im Prinzip die Speicherung quasi jetzt über so
ein lokales Handshake realisieren kann, was natürlich deutlich effizienter ist,
als wenn ich das Video oben angedeutet, mit zwei zueinanderversetzten Takten machen würde.
Wenn das Ganze entspricht, dann letztendlich so ein Schieberegister mit zwei Endstufen,
wo ich dann im Prinzip die Werte durchschiebe. So,
und der Vorteil dieser unteren Lösung jetzt,
also über so ein Request und echnologisch ist dann eben auch,
dass wenn letztendlich diese einzelnen Stufen leer sind,
das erste Datenwort quasi bis hierhin komplett durchgeschoben wird,
Das nächste dann eben bis hier und so weiter.
Das heißt, diese Pipeline wird dann eben entsprechend optimal schnell befüllt.
Ich kann dann eben maximal von 0 bis entsprechende Anzahl
der Stufen 2 in Datenworte enthalten. Gut,
das Ganze kann man jetzt eben, wobei dann also wohl die Speicherung,
als auch die Signalisierung von dem Ganzen dann eben mit solchen Seagates gemacht wird,
mit folgender Schaltung erreichen, die ich jetzt also hier nochmal in Hades sagen möchte.
Nicht, also das wäre jetzt hier ihm ein einzelnes Segate,
wo ich dann eben sage, wenn beide Eingänge in Wert eins haben,
wird auch der Ausgang eins.
Ansonsten, wenn jetzt jeweils nur eine eins ist,
ändert sich nichts, wenn beide null sind,
wird dann auch der Ausgang null
Und so weiter und so fort. So, die sind jetzt also hier quasi in dieser Art und Weise verschaltet. Und was man jetzt hier sieht,
ist, dass ich hier zwei Eingänge habe,
Ride und Ried, wo ich dann eben sagen kann,
ich schiebe hier was rein in die Schaltung oder ich lese hier entsprechend was raus,
würde dann eben hier sehen, es sind Daten verfügbar,
die dann also eben entsprechend hier an dieser Stelle gespeichert werden würden,
beziehungsweise hier am Ende,
wenn das er sich in der letzten Stufe passiert wäre, die Pipeline Fall.
So, wenn ich jetzt hier entsprechend einmal das Wright of 1 setze,
sieht man,
wie es also hier die Pipeline in der ersten Stufe auf 1 durchgeschaltet ist,
wenn ich das das nächste Mal mache,
wo das dann eben hier die zweite Stufe,
die dritte Stufe und jetzt wäre es
voll und mit dem Read könnte ich dann immer jeweils
eine Stufe davon
einzeln auslesen
Gut, das wäre jetzt ihm nochmal so ein Beispiel für eine asynchrone Schaltung,
wenn jetzt natürlich also auch noch sehr einfach.
Also das heißt, hier fehlen jetzt noch mehrere Datenworte und
dann fehlt noch die Logiker dazwischen. Das heißt also,
hiermit ist man natürlich dann immer noch weit von irgendwie so
einem kleinen Prozessor, Kern oder irgendwelchen atometischen Einheiten entfernt.
Ich habe Wie gesagt, also jetzt sollte hier eigentlich nur nochmal
sehr schnell so ein bisschen dieses Grundprinzip von Asynchronschaltungen motiviert werden.
Wie gesagt, in der Regel das, womit wir arbeiten,
werden eigentlich immer irgendwelche Synchronenschaltungen oder Schalttelemente sein. Gut,
in dem jetzt folgenden Kapitel, was sich dann Grundkomponenten für Rechnersysteme schimpft,
werde ich eigentlich nochmal so ein bisschen zeigen,
wie man jetzt also aus endlichen Automaten und aus Schaltnetzen wirklich jetzt in Form von irgendwelchen Blöcken,
die miteinander verschaltet sind, dann also wirklich zu kompletten kleinen Rechnern oder Mikrocontrollern letztendlich kommen kann.
Nicht, weil das, was wir bis jetzt gesehen hatten,
waren ja also im Prinzip einzelne Gatter oder Schaltnetze.
Ich habe Flip-Flops als Speicherglieder und ich habe eben endliche Automaten,
mit denen ich jetzt also im Prinzip sowas wie einen Prozessor oder Prozessor-Kern steuern könnte.
Was immer noch fehlt, wenn ich jetzt also im Prinzip sowas nehme,
wie ich das ja so ganz am Anfang der Vorlesung schon mal angedeutet hatte,
beziehungsweise das, was diejenigen von ihnen, die,
also jetzt ja schon im Rechnerstrukturenpraktikum waren,
also dort im Prinzip dann auch mit den Schaltungen dann gesehen haben, es sind natürlich immer noch irgendwelche Speicher.
Dazu werde ich dann also nochmal kurz zeichnen, aufzeigen,
im Prinzip welche Speichertechniken es gibt, die also grob vorstellen,
dann eben noch ein bisschen was sagen zu Bussen oder Bussystemen und anschließend dann eben am Beispiel von sehr kleinen Mikrocontrollern,
also in diesem Fall vom Armprozessor, dann eben auch schon zeigen,
wie man jetzt eben wirklich mit solchen Elementen quasi als Registertransfer so einen Rechner aufbauen könnte.
Und abschließend dann also auch nochmal etwas zur Ablaufsteuerung sagen werde,
Ablaufsteuerung war ja, dass man sagt,
wenn wir ein von Neumann-Rechner haben oder es von Neumann-Konzept,
wo ich also befehle, Befehl dekodiere, operanten, hole,
damit ich jetzt irgendwie was rechne und so weiter und so fort, dass das ja irgendwo zeitlich miteinander synchronisiert werden soll.
Da kann ich jetzt natürlich sagen, ja gut, wunderbar. Kapitel vorher, endliche Automaten. Das setzt sich dann eben wirklich in so einen entsprechenden endlichen Automaten um. Ist die eine Möglichkeit,
also einer direkten Realisierung, eine andere Möglichkeit, die diejenigen von ihnen,
die also jetzt ja eben schon im Praktikum waren,
also dann auch schon kennengelernt haben,
ist dann im Prinzip die Mikroprogrammierung, nämlich, dass man sagt,
also ich kann so einen endlichen Automaten auch dadurch realisieren,
dass ich quasi die Abfolge der Zustände beziehungsweise das,
was dann also auch an irgendwelchen Ausgangssignalen für irgendwelche Schaltungen oder für irgendwelche Ausgänge wirksam wird,
eben in einen Rahmen oder in einen Rom schreiben kann und damit im Prinzip dann eben auch so einen Automaten realisieren kann und gerade bei Prozessoren verwendet man das dann eben ganz gerne,
dass man da dann eben auch noch die Möglichkeiten hat,
wenn das Ding ist, also nicht fest verdrahtet ein,
red ohne die Speicher ist,
sondern der eben vielleicht jetzt auch noch entsprechend minimal geändert werden kann,
dass man dann eben auch noch einige Firmenware-Bugs oder einige Probleme,
die sich dann also vielleicht hinterher dann doch noch mit der
Hardware ergeben,
damit entsprechend vermeiden kann durch entsprechende Umprogrammierung
Gut, jetzt kommen erstmal diverse Folien,
die ganze Phase schon etwas länger her sind,
die sie aber eigentlich alle schon gesehen haben.
Nee, wo ich also nochmal im Prinzip vorgestellt oder jetzt hier nochmal kurz nur als Wiederholung vorstelle.
Der Ablauf in einem Rechner oder in so einem Rechnersystem folgt ja also dem Konzept,
was John von Neumann mit zwei anderen Mitautoren, 1945 entwickelt hat,
Im Prinzip realisiert hat, dass man eben sagt,
ich habe eine abstrakte Maschine mit minimalem Hardwareaufwand,
die dann eben realisiert wird als ein System von einem zentralen Prozessor, irgendwelchen Speicherkomponenten und irgendwelchen Peripheriegeräten.
Und das Ganze ist eben durch ein Programm,
was in diesem Speicher abgelegt wird, so programmierbar,
dass das Problem oder die Probleme, die man damit berechnen kann,
eben unabhängig von der Hardware-Struktur von dem Ganzen sind.
Hört sich eigentlich immer trivial an, weil das ist das,
was wir eigentlich als Informatiker nun als CPU oder als Rechner irgendwie tagtäglich kennen,
aber wie gesagt,
bis Anfang der 40er Jahre war es eben wirklich so,
dass man also für entsprechende Aufgabestellungen wirklich die Rechner speziell entworfen hat und
die Rechner dann eben auch nur genau dieses eine einzige Programm oder diese eine Aufgabenstellung bearbeiten konnten und dann eben im Prinzip diese Programmierbarkeit durch eben austauschbaren Speicherinhalt nicht möglich war.
So, im ursprünglichen von Neumann, Entschuldigung, so,
im Ursprünglichen von Neumann-Konzept hat man eben ein gemeinsames Speicher,
sowohl für Programme als auch für Daten, fortlaufend adressiert.
Theoretisch können, sollte man aber nicht, Programme,
also wie Daten manipuliert werden, beziehungsweise Daten können eben auch als Programm ausgeführt werden.
So, die Abarbeitung dieser Programme läuft eben durch diesen Befehlszyklus.
Und damit hat man dann eben die entsprechend flexible Lösung,
auf der eigentlich alles, was wir jetzt so als Rechner kennen, aufbauen.
Also hier nochmal die Grafik, wo diese Grundkomponenten im Prinzip beschrieben sind,
also jetzt hier aus dem Buch von Tarnenbaum, Structured Computer Organization.
Ich wohne dann im Prinzip diese zentralen Komponenten, also das heißt,
ein Prozessor, der dann eben ein Steuerwerk und ein Rechenwerk enthält,
das heißt mit dem einen Teil des Prozessors rechne ich jetzt wirklich mit irgendwelchen Operanten,
mit der atmetisch-logischen Einheit, habe dort irgendwelche Register,
wo dann Zwischenwerte gespeichert werden.
Und zusätzlich gibt es dann eben eine Steuereinheit,
die dann eben als endliche Automat oder im Mikro programmiert,
realisiert sein kann, die dann eben für diesen Ablauf sorgt.
So, das Ganze wird eben in der Regel dann zusammengefasst,
bildet das, was wir dann eigentlich so als CPU kennen.
Nicht zusätzlich habe ich dann noch irgendwelche Ein- und Ausgabeeinheiten
Das, was bei uns dann eben jetzt über Chipsätze,
externe Busse und irgendwelche Peripherie-Controller realisiert wird.
Und dann eben noch irgendwo einen größeren Blogspeicher,
der dann letztendlich dort für Programme und Daten genutzt wird.
Gut, den Inhalt dieser Folie,
also hatte ich ja im Prinzip eben schon erklärt,
also Prozessor aufgebaut aus Steuerwerk und Operationswerk.
Steuerwerk eben für die Kontrolle
Kontrolle oder in zeitlichen Ablauf hervorzuheben, sind dort eigentlich immer noch
zwei besondere Register, nämlich einmal sowas wie ein Program-Counter.
Das heißt, das ist die Adresse oder die Speicheradresse,
wo dann eben der, in Anführungszeichen, nächste abzuarbeitende Befehl herkommen soll.
Das heißt, wenn ich mein Programm jetzt irgendwo im Speicher abgelegt habe,
dann sagt der Probe im Count, der ist eben immer,
von welcher Speicheradresse soll, möchte ich mir jetzt den nächsten Befehl holen.
Nicht in der Regel wird er quasi immer einem linearen Ablauf von Programmen inkrementiert.
Ausnahme ist jetzt eben bei irgendwelchen Sprüngen oder bei irgendwelchen Unterprogrammen aufrufen,
wo ich dann eben diesen linearen Ablauf verlasse.
Nicht dann muss ich eben dafür sorgen,
dass eben entweder die entsprechende sparische Adresse von dem passenden Unterprogramm
in diesem Programm-Counter geladen wird oder eben bei bedingten Sprüngen,
dass sich dann eben abhängig von der Bedingung sage,
ich nehme den nächsten Befehl oder eben irgendwo einen anderen entsprechend anderen Befehl.
Dann gibt es eben noch etwas, Wie ist Befehlsregister,
dort landet dann eben genau dieses Befehlswort, was dann quasi gerade in der Abarbeitung ist.
So, im Operationswerk haben wir eigentlich,
sagen wir mal, zentral oder als Einheiten das,
was ich im vorletzten Kapitel vorgestellt hatte, dann eben die Alu,
also sprich das eigentliche Rechenwerk, davon gegebenenfalls noch mehrere.
Nicht, dann hat man meistens noch irgendwelche Register,
theoretisch oder im ursprünglichen Konzept von John von Neumann
hatte man eigentlich nur ein einziges Register, einen sogenannten Akkumulator,
das heißt, da würden dann eben Zwischenergebnisse der Alu zwischengespeichert.
Inzwischen bei normalen Rechnern, wie wir sie jetzt also heutzutage benutzen,
hat man da natürlich deutlich mehr Register,
in der Regel auch sogar deutlich mehr als diese Zahl hier von 64,
die dann eben teilweise direkt angesprochen werden teilweise,
aber auch durch das Betriebssystem oder Betriebssystem Mittel verwaltet werden.
Gut, dann gibt es eben den großen Hauptspeicher,
meistens oder häufig hat man da dann eben noch einen Mix aus Speicher,
in dem jetzt auch geschrieben werden kann.
Das heißt also als Rahmen Random Access Memory, wo ich also sowohl lesen,
als er schreiben kann. Und Read Only Memory war es dann eben beispielsweise benutzt wird,
um beim Buten quasi sowas wie Startroutinen,
irgendwelche Anfangsadressen und die ganze Initialisierung des Systems herzustellen,
zumindest jetzt bei Standard-Universalrechnern, wenn ich sage, okay,
ich entwerfe jetzt also irgendeinen kleinen Rechner oder irgendeine kleine Schaltung,
die mir also die Waschmaschine steuert,
dann wird die in der Regel nicht so häufig umprogrammiert,
wenn überhaupt.
Das heißt, da gibt es dann eigentlich nur einen Read-Only-Speicher,
beziehungsweise den kann man dann gelegentlich vielleicht nochmal als Flash
irgendwie entsprechend mit einer neuen Firmware versehen,
aber ansonsten soll natürlich dieses Gerät dann eben auch nur diese
eine einzige Aufgabe ausführen
Gut, wenn man sich jetzt so ein Gesamtes Rechnersystem ansieht,
kann man eben sagen, dass das eigentlich aufgebaut ist,
aus eigentlich immer einer relativ festen Abfolge von irgendwelchen speichernden Komponenten.
Das können eben irgendwelche Register sein, Universalregister oder eben irgendwas,
was ich jetzt eben schon anhand dieses von Neumann-Konzepts vorgestellt habe.
Das heißt, die sind dann eben letztendlich als Auf unterster Ebene quasi in Flip-Flops realisiert,
in größeren Einheiten hat man dann sogenannte Registerbänke,
die dann eigentlich also auch schon auf andere Speichertechniken teilweise zugreifen als auf Flip-Flops.
Dazu werde ich also auch gleich nochmal oder zumindest dann Freitag ein kurzes Beispiel geben,
wie sowas aussieht. Ansonsten hat man dann eben natürlich als speicherndes Element das alles,
woraus jetzt irgendwelche Hauptspeicher bestehen können oder Speicher,
das heißt also irgendwelche Rahmenspeicher, entweder als statisch oder dynamische Speicher,
was das ist, wo da die Unterschiede sind,
wird also dann auch gleich noch folgen oder eben solche Red-Only-Speicher oder eben andere programmierbare Einheiten.
Dann hat man quasi zwischen diesen speichernden Elementen immer irgendwelche Schaltnetze,
was in der Regel, sagen wir jetzt natürlich,
so ein bisschen größere Schaltnetze sind, also sprich irgendwelche Adira, irgendwelche arathmetischen Schaltungen,
also sprich im Datenfahrt so eines Prozesses dann eben sowas wie die Alu, oder eben irgendwelche logischen Operationen, die dann eben dort auftreten. Und es gibt dann eben noch zentrale Verbindungsleitungen in meinem Computersystem,
die dann eben jetzt nicht nur als Punkt zu Punktleitung von Register zu Schaltnetz zum nächsten Register gehen,
sondern die dann eben beispielsweise dann auch vom physikalischen Ship irgendwie runtergehen in Form von irgendwelchen Bussen oder eben entsprechenden Leitungsbündeln,
die dann teilweise auch die Eigenschaft haben,
dass sie eben jetzt nicht nur einen einzigen Sender von Informationen haben,
also beispielsweise dann eben den Ausgang eines Gatters oder den Ausgang eines Registers und mehrere Empfänger,
die das dann lesen, sondern dass man eben auch häufig bidirektionale Leitungen,
wo ich dann eben sagen kann,
ich kann die Informationen in von unterschiedlichen Sendern haben,
beziehungsweise in unterschiedliche Richtungen übertragen und das einfach so,
das praktische Beispiel, was wir dann eigentlich alle kennen,
ist im Prinzip sowas wie ein Rahmenspeicher,
wo ich eben sagen kann,
den kann ich von meinem Prozessor oder von meinem System aus beschreiben,
das heißt,
da wandern die Daten dann eben vom Prozessor in den Rahmenbaustein hinein,
zumindest erstmal von der Idee her.
Oder wenn ich lese, wandern die Daten dann eben
vom Rahmenbaustein aus in den Prozessor rein
Rein praktisch sieht das natürlich bei modernen Computersystemen aus,
dass es dann also nicht nur diese zwei Komponenten gibt,
sondern häufig dann eben auch noch deutlich mehr,
die dann also beispielsweise Datentransfers dann auch unabhängig vom Prozessor ermöglichen.
Gut, das Ganze,
wenn man jetzt also sagen wir mal diese drei Grundkomponenten,
nämlich also irgendwas Speicherndes, irgendwelche Schaltnetze und irgendwelche Verbindungsleitungen zusammenfasst,
nennt sich dann eben,
weil man häufig immer Registerfunktion,
Register hat,
dann in der Regel Registertransfermodellierung
Gut, Beispiele dazu,
wie sowas dann also wird es wirklich auf Prozessor-Ebene dann auch aussieht,
werden dann also etwas später, also sprich übermorgen danach folgen,
jetzt werde ich, denke ich mal heute noch,
einiges vorstellen zu speichern oder Speicherbausteinen,
also bislang hatten wir als speichernde Eigenschaft im Prinzip immer nur Flip-Flops oder eben Register kennengelernt,
Register ist erstmal nichts anderes,
als dass ich dann eben für entsprechend viele Bit ein Flip-Flops habe,
bei dem wir jetzt Speicher aufgebaut sind,
das heißt also Speicherung jetzt für entsprechend mehr Informationen,
kann man sagen, in der Regel sieht das immer so aus,
dass ich in meinem Speicher quasi eine Wortbreite habe von,
jetzt beispielsweise M-Bit und eben eine Anzahl von Adressen,
die ich quasi unterscheiden kann,
typischerweise ist die Anzahl der Adressen dann eben immer sowas wie eine Zweierpotenz,
die dann quasi über eine N-Bit-Adressleitung quasi dekodiert wird und die Gesamtkapazität des Speichers ergibt sich demzufolge dann eben als zwei hochklein N mal M-Bit.
So, bei den unterschiedlichen Speichern oder Speichertypen,
die kamen jetzt eben auch sehr unterschiedlich klassifizieren.
Zum einen abhängig von der Kapazität, abhängig davon sind das
eben nur Lesespeicher oder kann ich dort auch schreiben.
Beim Schreiben wie funktioniert das? Kann ich also nur auf einzelne Bits zugreifen?
Kann ich auf Bytes zugreifen oder auf größere Funktionseinheiten?
Dann beim Schreiben, wie sieht das jetzt mit der Information
aus? Ist die letztendlich flüchtig oder dauerhaft geschrieben?
Also sprichst du was wie Flash-Speicher, wäre dann eben etwas,
wo dann eben auch deutlich dauerhafter geschrieben wird.
Alles andere, was wir also hier so im Computern haben,
sind dann eigentlich eher flüchtige Speicher. Das heißt,
nach Abschalten des Geräts, wenn die Versorgungsspannung weg ist, geht die Informationen weg.
Und dann eben noch unterschiedliche Klassifikation hinsichtlich der Zugriffszeit,
der Technologie und so weiter und so fort. Gut,
also darüber könnte man jetzt also auch schon relativ viel beschreiben,
wenn man jetzt also genau in die Technik geht,
da wir hier die Zeit leider nicht haben,
werde ich jetzt also hier immer nur einen vergleichsweise groben Überblick geben können.
Also die ist jetzt hier eine Tabelle aus dem Buch von Tarnbaum auch,
wo dann im Prinzip jetzt die oder einige der am häufigsten benutzten Speichervarianten an,
also schon mal aufgezählt sind, wo ich dann eben sagen kann,
dass sie was nur als S-RAM, also Static-RAM-Hart,
würde dann eben quasi lesen und schreiben erlauben, elektrisch gelöscht werden.
Ich habe dann eben nicht den Zugriffsmöglichkeit auf einzelne Bytes.
Das Ganze ist aber eben von der Versorgungsspannung abhängig, das heißt,
wenn die weg ist, ist die Information dann eben auch weg,
nicht in typischer Weise, würde dann sowas wie so ein S-RAM-Speicher zum Beispiel schnellen Speichersystemen, Cashes eingesetzt werden. Gut,
das ist dann also hier dann füllend die anderen dynamischen Speichertypen,
also DRAM, SD-RAM,
was also bei Computersystemen typischerweise eben sowas wie Hauptspeicher ist,
riet Oni-Speicher und die ganzen Varianten, die da drauf aufbauen,
werden dann eben Speichervarianten, die unabhängig von der Versorgungsspannung arbeiten und das,
was hier jetzt noch als Film vor Digital Camera klassifiziert ist,
also sprich Flash Speicher, nur etwas,
was also inzwischen auch in vielen Mobilgeräten Einzug gehalten hat,
beziehungsweise in Form von Solid Statesk,
also dann auch in größeren Rechnern oder anderen Rechnern,
also eingesetzt wird als Ersatz für eigentlich Festplattenspeicher.
Gut, für einigen der allereinfachsten Varianten,
also sprich Esram und Deram,
werde ich jetzt also nochmal beziehungsweise Rom werde ich nochmal kurz vorstellen,
wie das also im Prinzip technisch aufgebaut ist,
wobei das jetzt also hier dann auch nur ein relativ grobe Prinzip Erklärung sein wird.
Also Rom ist im Prinzip dann ja sowas wie ein Red-Only-Memory.
Kann man sich eigentlich immer vorstellen, wie das dann also
hier auch in dieser hartes Schaltung drin ist.
Das wäre jetzt, also hier gleich mal starten werden
So, und zwar ist die Funktion eigentlich immer,
dass ich sage,
also in diesem Fall wäre das jetzt nicht mehr für ein Beispiel von 16 mal 8 Bit,
entsprechender Wortbreite, also diesen 8 Bit,
hat man hier jetzt unterschiedliche sogenannte Zeilen beziehungsweise dann im Englischen dann immer Worldline,
entsprechend übersetzt und in diesen Zeilen wird dann quasi die Information fest,
hardwaremäßig reinkodiert oder reingebrannt.
Das ist dann eben das, was an der Seeds hier als Memory-Matrix bezeichnet wird.
Am Eingang gibt es dann eben ein Dekoda,
der dann eben jetzt für diese 16 Worte im Prinzip das Ganze dann aus einem Binärwert,
also sprich aus Vierbit, herausdekodiert und dann eben jeweils die entsprechende Zeile hier ansprechen kann.
Und technisch gesehen ist das Ganze dann eben so realisiert,
Das, also hier beispielsweise, jetzt gesagt wird,
diese Information, die ich jetzt hier rauslese,
also in diesem Fall diese eins oder dieses Wort 1,
0, 0, 0, 0, 0, 0,
was also jetzt hier quasi an der Adresse null gespeichert ist,
wird dadurch erzeugt,
dass sich quasi jetzt hier an diesem einen Kreuzungspunkt von dieser Leitung und dieser Leitung im Prinzip jetzt hier eine Diode eingebracht habe, die Ude ist im Prinzip also nochmal deutlich einfacher als ein Transistor.
Letztendlich ist das eben eine elektrisch leitende Verbindung, die dafür sorgt,
dass wenn quasi jetzt dieses Element hier eingebaut wurde,
diese Leitung quasi von eins, den sie normalerweise haben würde,
hier auf null geschaltet wird und dadurch,
dass dann hier am Ausgang noch ein Inverter ist,
wo dann also hier wieder eine eins erzeugt.
So und je nachdem, an welchen Stellen ich jetzt hier
eben irgendwelche Diuden reinbringe, man dann eben die entsprechenden Informationen.
Das heißt also beispielsweise jetzt hier an dieser Stelle oder an
dieser Worldline hätte ich dann eben hier an diesen Kreuzungspunkt nichts.
Das heißt, da würde jetzt überall eine Null ausgegeben werden.
Dann habe ich hier vier von diesen Bauelementen quasi jetzt verbaut.
Das heißt, diese unteren vier Bits sollten dann eben eine Eins erzeugen.
Und wenn ich da jetzt also die entsprechende Adresse auswähle,
was dann Diese hier ist,
habe ich dann eben hier genau als Ausgabe 4 Nullen und 4-1,
sind die dann eben quasi durch diese Elemente gemacht werden.
Gut, das Ganze benutzen wir jetzt eben, um beispielsweise Programme,
die der Rechner, also zum Beispiel jetzt zum Buten braucht,
um das Barris zu initialisieren oder was weiß ich,
also jetzt wirklich fest in Geräte reinzukodieren,
die dann eben auch hinterher nie wieder verändert werden müssen.
Nicht, weil im Prinzip diese Bauteile sind jetzt natürlich nicht irgendwelche diskreten Bauteile,
die da quasi jetzt irgendwo aufgelötet sind, sondern die sind dann eben in der Herstellungstechnik,
dann eben in Größenordnung von irgendwelchen Pananometern quasi in dem Ship oder in dem Speichership entsprechend angelegt, der da natürlich also auch mal etwas andere Kapazität hat.
Also diese hier angedeuteten 16 mal 8 Bett. Gut,
das wäre von der Idee her,
also dass wir jetzt so ein Ried-Only-Speicher oder Ried-Only-Memory funktioniert,
Bei dem Wiederbeschreibbaren Speicher, also bei einem random Access Memory,
das heißt, der dann eben sowohl gelesen hat als so geschrieben werden kann,
hatte ich ja schon gesagt,
der Speicher dient in der Regel dann eben als Arbeitsspeicher des Rechners,
entsprechend eben von Neumann-Prinzip dann,
also wofür bekomme er es auch für Daten,
hat keinerlei Abnutzungseffekte, also jetzt anders als zum Beispiel ein Flash-Beicher,
ist auch ähnlich wie so ein Raumspeicher dann über so eine Matrix-Struktur aufgebaut,
wo ich dann eben auch sage,
ich habe irgendwie einen Adressbus mit N-Adressbits,
der dann im Prinzip zwei Hochend-Wortleitungen unterscheiden kann, konzeptionell deshalb,
weil da spare ich ja meistens noch ein bisschen anders aufgebaut ist.
Dazu will ich dann also demnächst auch noch eine Folie vorstellen und
dann eben mit einer bestimmten Wortbreite. Und je nachdem,
wie so ein Rahmenspeicher dann letztendlich realisiert wird,
kann man eben sagen, dass es sich um ein statisches Rahmen handelt,
was dann eben etwas aufwendiger ist,
indem da dann eben mehrere Transistoren dafür sorgen,
dass also eine Information, die dort eingespeichert wurde,
zumindest solange die Versorgungsspannung anliegt, dann eben auch erhalten bleibt.
Oder eben als dynamisches Rahmen der Rahmen,
wo ich dann eben deutlich weniger Hardwareaufwand brauche,
wo ich dann demzufolge auch auf Sei mal gleicher Fläche,
dann eben natürlich auch sehr viel mehr Speicherkapazität unterbringen kann.
Und die Rahmen wäre dann eben zum Beispiel das,
womit eigentlich zum Beispiel jetzt bei uns bei Computern also sämtliche Hauptspeicher,
Grafikspeicher und alles, was wir jetzt mal so als Speicher bezeichnen, realisiert sind.
Gut, wie das dann prinzipiell aussieht, einige kleine Beispiele,
einige kleine Beispiele und wie man dann eben, sagen wir mal,
aus Speichern in Verbindung mit wo das System dann eben jetzt wirklich komplette Schaltung aufbaut,
werde ich dann übermorgen vorstellen.
Jetzt war aber hier noch eine Frage. Du weißt nicht,
wie bewusst das ist. Nee, war ich mir jetzt nicht bewusst,
aber das war jetzt also auch gerade mein Schlusswort.
Ja gut, also fünf Minuten. Gut, sorry,
dann also danke für die Geduld und bis Freitag