Ja, bevor ich jetzt mit der Vorlesung noch weitermache,
Nummer ein kurzer Hinweis, hier auf der Rechnerstrukturen-Webseite habe ich das jetzt nur entsprechend nochmal verlinkt,
beziehungsweise beschrieben, seit Montag hat das Rechnerstrukturenpraktikum angefangen.
Ich sage das nur deswegen nochmal explizit, weil es also irgendwie erstaunlicherweise so war,
dass also laut Stine die Kurse alle ausgebucht sind und irgendwie war es dann also doch so,
dass es jetzt eben quasi Blog-Veranstaltungen,
die also letztendlich jetzt in den Nächsten vier Wochen stattfinden wird,
jeweils zu den entsprechenden Terminen, dass dort dann jedenfalls doch viele,
die eigentlichen Platz gehabt hätten, also anscheinend nicht gekommen sind.
Gut, die Kurse nach wie vor voll,
weil es waren dann also welche,
die dann keine Wunschkurse hatten und quasi dann es versucht hatten zu tauschen und noch konnte der Kollege,
die dann also auch so weit unterbringen,
beziehungsweise dann vielleicht nur einen Reserveplatz in Anspruch nehmen,
nicht aber nur, dass man nochmal kurz daran erinnert sei,
weil das jetzt ja quasi so plötzlich im Semester losgeht,
dass dann eben entsprechend also jetzt auch die Praxikumskurse losgehen,
weil, wie gesagt,
also ein Termin kann man zur Not noch irgendwie so ein bisschen nacharbeiten.
Danach wird das dann aber dann entsprechend schwierig oder ist letztendlich nicht mehr machbar.
Gut, ja, das hier nur noch um Hogwarts als Hinweis. Dann hatte ich letzte Woche ja aufgehört,
also kurz zu beschreiben, an der Stelle, wo ich gesagt habe,
na gut, wir haben jetzt eigentlich kennengelernt, halt Funktionen,
also sprich die Algebraischen Ausdrücke, wie ich die beschreibe,
die Normalform, wie man Minimierung von Charles-Funktionen,
also typischerweise dann eben mit KV-Diagrammen vornimmt.
Und das, was jetzt in diesem Kapitel dann also quasi noch weiter beschrieben wird,
ist da also darüber hinausgehend dann eben sogenannte Schaltnetze,
letztendlich nichts anderes, als eben ein ganzes Funktional gesehen,
eben ein ganzes Bündel von Schaltfunktionen,
die dann eben jetzt nicht nur eine Einbitt-Variable,
sondern dann eben entsprechend mehrere Ausgangsvariablen haben, denen dann eben entsprechend irgendwie jetzt Werte zugewiesen werden können.
Ja, hatte ich ja sonst schon gesagt,
aufgebaut sind solche Schaltnetze dann eben typischerweise,
also jetzt gehen wir so ein bisschen so in Richtung,
wie das Ganze dann eigentlich auch wirklich in der Hardware dann teilweise umgesetzt wird,
eben aus einzelnen sogenannten Gattern,
Gatter oder Gatterfunktionen entsprechend dann eben wirklich so diesen Minimalfunktionen der Bullschen Algebra,
also sprich Komplexität mit zwei oder eben einigen wenigen Eingängen.
Und dann eben sowas wie und oder nichts. Damit habe
ich also letztendlich schon mal die Bulsche Algebra erschlagen rein.
Praktisch gibt es da dann immer noch typischerweise einiges mehr.
Werde ich also jetzt auch gleich nochmal so ein bisschen zeigen,
wenn ich die Werkzeuge beziehungsweise die Beispiele vorstelle,
mit denen wir dann also jetzt in diesem beziehungsweise noch im nächsten Kapitel da noch entsprechend arbeiten werden.
Was dort dann auch noch, jetzt sag mal als neuer Aspekt hinzukommt,
was ja bislang ja auch noch nicht betrachtet hatten,
ist dann eben auch wirklich das Reale, also das zeitliche Verhalten,
dass da solche Elemente an den Tag legen,
weil im Sinne einer Funktion kann man jetzt natürlich immer sagen,
ich habe einen Eingangsvektor, mathematisch gesehen wird daraus jetzt eben irgendeinen Ausgangswert berechnet.
Nun ist es aber eben so, man wäre froh,
wenn das beliebig schnell gehen würde.
Rein praktisch tut es das aber nicht, sondern kostet eben auch noch einiges an Zeit.
Inzwischen muss man sagen, sind diese Zeiten also entsprechend sehr, sehr kurz geworden. Das heißt,
da bewegt man sich dann also irgendwie so im Bereich von einigen bis einige hundert Pico-Sekunden,
nicht also gerade so um die Nase-Sekunden-Grenze herum,
was dann nämlich letztendlich der Grund dafür ist,
dass das, was wir so als Computer kennen,
als Rechner kennen dann eben irgendwie eine bestimmte Taktrate,
Taktfrequenz hat, die wird dann nämlich letztendlich indirekt dadurch vorgegeben,
dass innen drin,
also die Berechnung eben Zeit brauchen und zwischen zwei einzelnen Berechnungsschritten dann quasi jetzt in diesen Schaltnetzen letztendlich,
also erstmal gewartet werden muss,
bis dann also wirklich richtige stabile Ergebnisse anliegen.
Am Ende dieses Kapitels werden wir also darauf noch so ein bisschen eingehen,
da werde ich dann also auch noch so ein bisschen beschreiben,
weswegen es dort dann eben unter anderem auch Probleme geben kann.
Ja, das wird dann also da noch mal so ein bisschen. Gut,
ansonsten werde ich jetzt also hier erstmal anfangen mit im Prinzip ganz einfachsten Schaltung,
beziehungsweise dann anschließend in den Beispielen dann eben nochmal so ein bisschen drauf eingehen auf das,
was dann eigentlich nochmal so praxisrelevant ist, nämlich dass man sagt,
also wir haben so die Grundschaltung, also diejenigen von ihnen,
die jetzt also quasi Montag im Rechnerstrukturen-Praktikum sind,
werden das dann also schon so ein bisschen kennengelernt haben,
was da so an Grundelementen gibt.
Die werden jetzt also hier zumindest fast zeitnah,
also in der Vorlesung dann also auch nochmal richtig vorgestellt und
dann ist es natürlich also auch entscheidend,
dass wir also vielleicht nochmal sehen oder das nochmal so ein bisschen nachvollzogen werden soll,
wie Computer dann eben wirklich auch richtig rechnen können.
Also bislang habe ich ja so Zahlensysteme eingeführt, gesagt,
Vinärsystem, irgendwie an der Tafel bzw. in Übungsaufgaben,
wo dann eben gefragt, okay, wie kann man das machen?
Addition, Multiplikation, Subtraktion und so weiter. Hier geht
es jetzt eben wirklich so ein bisschen dann auch darum,
wie das Ganze dann also letztendlich technisch realisiert wird,
was dann nämlich auch die Grundlage ist dafür,
dass wir da mit unseren Computern irgendwie was machen.
So, was wir jetzt hier immer betrachten werden in diesem Kapitel,
sind dann eigentlich typischerweise Schaltpläne oder im Englischen Skematics.
Ist dann letztendlich
eine grafische Darstellung oder Veranschaulichung
der Schaltung
Ist ganz am Anfang, als ich mal so von Neumann-Architektur grob eingeführt habe,
auch schon mal so ein bisschen angeklungen,
wo es dann also quasi jetzt irgendwelche Blöcke gab, wo ich gesagt habe,
also die haben die und die Funktion oder Funktionalität, waren dann über irgendwelche Leitungen,
die dann also beispielsweise dann also irgendwie 16-Bit oder 32-Bit Werten entsprechen dann miteinander verbunden.
Und genau sowas wäre dann eben ein Schaltplan,
die kann man dann eben auch noch auf sehr unterschiedlichen Abstraktionsebenen betrachten,
das heißt also Aimer jetzt im Sinne von irgendwie Ganz oben,
dass ich also wirklich sage, okay,
ich nehme einen Rechner und wenn ich jetzt also irgendwie sowas wie ein ganzes Rechnernetz beschreibe,
mit Netzwerkkomponenten dazwischen, nüchtern wäre das dann, also sowas wie so eine oberste Abstraktionsebene.
Nicht, ich kann dann quasi in den Rechner selber reingehen und sagen,
was also im Prinzip ja bei dem,
bei der von Neumann-Architektur rangekommen ist, dass man sagt,
okay, unterteilt wird das Ganze dann irgendwie in den Speicher,
dann in die eigentliche CPU und darin befinden sich dann also irgendwie so Komponenten wie,
Operationswerk, nämlich das,
wo quasi jetzt mit den Werten gearbeitet wird und Steuerwerk,
das, wo die Befehle interpretiert werden,
dass das eben entsprechend unterteilt wird.
Dann kann man das eben noch weiter unterteilen und sagen,
gut, in dem Operationswerk habe ich jetzt irgendwelche Komponenten, mit denen ich rechne.
Sowas wie die Alu, Ares mit Hick Logic Unit.
Das werden wir also jetzt genau in diesem Kapitel Schaltnetz da
auch nochmal rudimentär kennenlernen, wie sowas im Prinzip aussieht.
Und das lässt sich dann eben auch noch weiter verfahren,
dass sie dann sagen, die ist dann wieder aufgebaut aus einzelnen nennt Morgattern,
was auch immer, da letztendlich drunter liegt. Nicht,
dann kann ich mit den Skemetteln, mit den Schalplänen,
mit den Skemetics dann eben weiter runtergehen und sagen,
okay, so eine Grundfunktion, so eines nennt Elements,
kann ich in CEMOs Schaltungstechnik mit vier Transistoren,
die so und so miteinander verbunden sind, letztendlich realisieren und nicht,
dann ist man also auf einmal weg von der digitalen Welt,
in die analoge Welt,
wo ich also Ströme und Spannung habe.
Das ist also das, wo ich vielleicht nochmal gelegentlich mal so irgendwie eine Folie auflege,
um mal zu beschreiben von der Idee her, wie also im Prinzip das Ganze funktioniert.
Ansonsten muss man sagen, okay, wir machen hier nicht Elektrotechnik,
also von daher werden wir uns da,
also jetzt nicht weiter mit beschäftigen,
sondern können dann also als Informatiker sagen,
ich bleibe in meiner heilen digitalen Welt und habe als Werte Nullen und Einsen und also ob das dann letztendlich ist,
hohe Spannung, niedrige Warnung oder irgendwie Strom fließt oder Strom fließt nicht,
davon kann man dann eben entsprechend abstrahieren.
Gut, grundsätzlich lassen sich aber eben solche Schaltpläne,
also mit irgendwelchen analogen Bauelementen zeigen, das, was wir hier betrachten,
sind eben Gatter, also sowas wie diese logischen Grundoperationen.
Und eben speichernde Elemente, die wir dann im nächsten Kapitel dann quasi als Flipflops kennenlernen.
Die sind dann eben mit irgendwelchen Leitungen letztendlich miteinander verbunden.
Und wenn ich die dann eben zusammenfasse, jetzt im Sinne einer Hierarchie, kann man daraus dann eben wirklich komplexere Sachen aufbauen bis zum kompletten Rechner bis zur kompletten CPU. Gut,
man muss jetzt eben sagen, sowas,
also aus einzelnen Gattern aufzubauen,
das war also Stand der Technik, in den 60er,
70er Jahren, wenn ich also ganz am Anfang hatte,
ich habe mal so ein paar Haltebilder,
wo man sowas also sieht, beziehungsweise heute war das,
also nachher vielleicht auch nochmal irgendwie, kurz warm,
habe ich also hier nochmal bei uns aus der Mortenkiste,
also hier sowas nochmal mitgebracht,
also das ist also hier irgendwie so eine Platine,
das ist also irgendwie Teil eines Rechners,
nicht wenn man das so mit heutigen Motherboards und so weiter vergleicht,
wo vielleicht noch so ein paar einzelne ICs drauf sind,
sieht man hier also wirklich eine Unmenge von
irgendwie relativ kleinen,
einfachen ICs
Nicht jeder von denen hat dann also irgendwie so eine Komplexität,
dass da vielleicht ein paar Nantgarder drin sind.
Und wenn ich also irgendwie 30 von diesen Platinen
in irgendwelchen Schränken habe und die miteinander verschaltet habe,
dann habe ich also eine CBU,
mit der ich dann letztendlich also 16 Bittbefehle abarbeiten kann.
Da muss man sagen, da sind wir also heute natürlich
dann weit von weg und eben insgesamt ist der Hardwareentwurf heutzutage
dann eben auch nicht mehr so auf der Ebene wie das,
was ich jetzt hier so vorstelle.
Also sprich, dass man mit grafischen Oberflächen eben solche Komponenten
instanziert miteinander verbindet, daraus eine Funktion aufbaut,
sondern da ist man eigentlich ähnlich wie in der Programmierung so,
dass man eben Hardware-Beschreibungssprachen hat.
Das hatte ich ja im letzten Kapitel schon mal ganz kurz angedeutet.
Und dann eben entsprechende Werkzeuge, die einem das dann
eben übersetzen in Schaltalgebranche, logische Ausdrücke bzw. entsprechende Elemente.
Gut, was sind da dann, sagen wir mal so,
die typischen Schalssymbole? Sollte man grob kennen,
weil wie gesagt, das taucht dann hier hier auf den
nächsten Folien dann teilweise auch immer nochmal auf
Struktur und Praktikum. Da ist jetzt immer das Schöne,
also jeder Autor oder jeder, der die Vorlesung hält,
macht das immer irgendwie so ein bisschen anders.
Also hier ist nun mal also aus dem Buch von
Schiffen und Schmitz, also nochmal quasi aufgelistet.
In Deutschland ist ja alles genormt. Da gibt es also die Dienenschalssymbol,
das sind immer so eckige Kästen,
wo dann also im Prinzip sowas wie ein und mit drei Eingängen
dann quasi durch so einen Kaufmannsunterschrieben würde oder nicht exklusiv oder
exklusiv oder negiert,
also quasi dann
die Äquivalenz
Und so weiter. Was hier in dem Werkzeug,
was wir nachher gleich noch kennenlernen, werden verwendet wird,
beziehungsweise was sie auf den Folien habe, entspricht dann also eher diesen Schalzeichen,
die so ein bisschen eigentlich diesem amerikanischen Standard angenähert sind,
beziehungsweise das, was man in Deutschland eigentlich gemacht hat,
wenn man jetzt also sag mal nicht,
also irgendwie auf diese Dien-Symbole gegangen ist,
also ein und, als so ein Halbkreis,
wo dann also die Linien draufstoßen beim oder laufen sie entsprechend rein,
Negation ist dann eben durch so einen Punkt gekennzeichnet und dann gibt es dann eben noch irgendwelche Symbole,
die letztendlich in diesem Fall jetzt mathematisch motiviert, Äquivalenz,
als eben diese drei oder Gleichzeichen mit diesen drei Strichen,
exklusiv oder ist mathematisch gesehen Antivalenz,
ist dann eben das Ganze dann durchgestrichen,
nicht uns weiter.
So, das sind dieses Schalsymbol. Wie gesagt,
dann hat man als Grundelemente sowas wie einfache Gatter,
mit denen man letztendlich seine Funktion beschreiben kann,
von ein bis zwei oder eben paar mehr Eingänge und das,
was er natürlich typischerweise haben sollte,
wäre also irgendwie sowas wie eine vollständige Basismenge.
Das heißt also irgendwas, womit ich dann eben letztendlich die gesamte Bulsche Algebra abbilden kann.
Nicht das, was man heutzutage in der Halbleitertechnologie hat,
sind dann eben typischerweise Gatter, die einen invertierten Ausgang haben.
Also wir rechnen ja quasi immer in positiver Logik,
also mit und und oder, technisch gesehen funktioniert das Ganze eigentlich immer so,
dass das also am Ausgang invertiert. Das heißt,
da hat man dann eigentlich eher Nant und No Gut,
braucht uns jetzt nicht weiter zu interessieren,
weil auch da muss er eben sagen,
wenn ich jetzt nicht Schaltung selber entwerfe, sondern sowas,
also jetzt wirklich auch technisch gesehen umsetzen will,
beschreibe ich das sowieso mit Hardware-Beschreibungssprachen.
Ich habe dann also die Möglichkeit, das Ganze dann eben so abzubilden,
dass das Ganze dann entsprechend funktioniert. Gut, das,
was wir jetzt in diesem Kapitel und eben auch in dem
nächsten Kapitel benutzen werden und wo dann eben relativ viele,
also auch von den Screenshots mit drin sind,
ist dann eben,
dass man sowas hat wie ein grafisches Tool,
um jetzt eben solche Schadpläne einzugeben,
also sprechen Editor und was da dann eben
auch noch mit dranhängt
Ist ein Simulator. Und was man damit dann eben machen kann,
ist letztendlich solche digitalen Schaltungen wirklich zu zeichnen,
entsprechend dann wie so ein Experimentierkasten, sich da also irgendwie
was aufzubauen und das Ganze dann eben interaktiv zu simulieren.
Dadurch kann man dann eben das Ganze immer sehr gut selber sich mal ausprobieren,
machen damit also irgendwelche Sachen machen,
höchstwahrscheinlich wird das dann also auch nochmal an irgendwelchen Übungsaufgaben auftauchen,
dass man da dann mal so ein Scamatic mit
abgeben soll und so weiter
Gut, wenn man so guckt als Open-Source-Programme mit einfachen Simulatoren,
gibt es da also unterschiedliche, also von was also vergleichsweise alt ist,
ist dieses Chipmunk von bzw. Deeklock von John Lazaro.
Das, was wir hier benutzen, ist Hardes,
das ist ein Programm, was ein Kollege, Norman Hendrik,
inzwischen also auch schon vor knapp 20 Jahren oder so,
geschrieben und entwickelt hat,
womit man dann eben sehr einfach mit Java seine Schadung eingeben kann,
simulieren kann und damit noch so ein paar
andere nette Sachen mitlaufen lassen kann
Ist hier direkt bei uns auf der Webseite zu finden. Sage ich gleich noch mal kurz was dazu. Und wie gesagt,
im Prinzip war es ursprünglich mal so, dass diese ganzen Demos dann eigentlich,
also das wäre dann also hier entsprechend der Link, also die Seite,
dass diese ganzen Demos, die dann also auch hier beschrieben sind,
ursprünglich irgendwann also auch mal direkt hier im Browser als Java Applet liefen,
da inzwischen natürlich Sag mal, aber typischerweise wegen Sicherheitsbedenken,
also irgendwelche Skripte, Ausführungen von JavaScript und so weiter, also immer gerne abgeschaltet werden.
Also ich habe dann eigentlich meistens also auch immer irgendwelche Blocker für dieses und jenes dann, also mit aktiv oder so weiter. Ist das jetzt,
glaube ich, sowieso nicht mehr möglich, das zu starten,
sondern das, was man dort dann machen würde,
wäre das Ganze sich dann also hier unter Download irgendwo runterzuladen,
beziehungsweise rein praktisch, wird das so aussehen,
dass ich habe das auf Linie verlinkt,
also entweder über Stine oder eben hier über die Seite,
bei den Unterlagen, zu dem Kapitel 9 findet sich dann also hier Hades,
rsb.zip, das ist dann eben entsprechende Zip-Datei,
runterladen, auspacken,
erzeugt dann Unterverzeichnis namens Hades RSB und dort sind dann also die ganzen Beispiele,
wovon ich jetzt da so einen ganz kleinen Teil nur zeigen
werde und da ist das Ganze dann also auch entsprechend dann laufähig
Wer das jetzt hier gerade versucht und also hier irgendwie im Edorom oder Uninetz ist,
Norman wollte das also jetzt nicht unbedingt extern alles irgendwie zugreifbar haben.
Deswegen ist das jetzt also vom Webserver her so,
dass es also nur aus dem Informatiknetz aufgerufen werden kann.
Das heißt, entweder in Stelling irgendwo runterladen,
wenn man dort im Netz ist oder irgendwie sowas wie ein VPN aufmachen.
Ansonsten würde ich jetzt hier nämlich auch nur ein Access die Neid bekommen. Gut,
ja, wenn man das ansonsten runtergeladen hat,
Sieht das dann folgendermaßen aus, dass,
wenn ich es ausgepackt habe, hier in dem Verzeichnis,
also irgendwie so ein ganzer Unterbaum ist,
jetzt von irgendwelchen unterschiedlichen Beispielen und Beispieldateien,
ist auch immer entsprechend dann hier in den Vorlesungsunterlagen entsprechend mit verlinkt.
Und das, was dann eigentlich jetzt interessant ist,
ich werde das jetzt hier gleich mal live zeigen,
ist dann eben, dass ich also im Prinzip da mit dem Java,
ich glaube,
größer gleich,
1 Punkt
5 oder 1.6 müsste es sein. Jedenfalls also im Prinzip
eigentlich auch eine uralte Version. Das Ganze quasi starte.
Und was man dort dann hat, beziehungsweise erhält,
ist dann also erst mal hier nur irgendwie so eine grafische Oberfläche,
so eine Zeichnung. Und hier unten irgendwie sowas,
wo ich so ein Anhalt oder Pause-Button rückwärts vorwärts laufen, irgendwas.
Zurzeit habe ich hier sowas wie eine grüne Ampel.
Und hier sieht man das also irgendwie Zeit läuft,
weil das ist eben nicht nur ein Editor für solche Komponenten,
sondern es ist eben auch gleich die Simulator,
wo dann also quasi jetzt eben auch noch mit irgendwelchen,
sofern es da Zeitmodelle gibt, dort dann eben auch noch irgendwas simuliert wird.
So, da ich jetzt hier keine Schadung drin habe,
macht der Simulator jetzt ja natürlich, also er ist mir relativ gar nichts,
also die Streams zufolge kann ich dir nochmal kurz pausieren.
So, ansonsten sieht das Ganze so aus, dass das,
was er jetzt auch gleich auf den Vorlesungsfolien kommt,
ich im Prinzip hier und da oben jetzt in meinen Dateibaum irgendwie reingehen kann
Und dort dann also so eine Beispielschaltung,
zum Beispiel aufmachen kann, beziehungsweise ein bisschen Beschreibung dazu.
Also da ist dann teilweise dann eben auch noch entsprechend viel Text mit dabei.
Ansonsten gibt es dann auch immer nochmal als Hinweis zu dem Hades,
war es also hier dann entsprechend, also auch beschrieben ist unter Documentation,
dass man dort dann eben auch noch ein Tutorial hat,
eine Kurzreferenz und so weiter, so ein paar Sachen,
die man da dann eben auch noch sich selber ansehen kann.
Ansonsten muss ich sagen,
ist das Tool also auch nicht so hochgradig kompliziert,
dass man da jetzt also irgendwie was machen
Was er machen würde. Gut, diese Schaltung,
hier ist es erst mal noch nicht ganz so interessant.
Also wir fangen jetzt hier erst mal mit was ganz einfach an.
Ach so, das ist ein schöner Vorfalleffekt.
Ist natürlich in dem Fall irgendwie genau
das Gleiche
So, also nehmen wir hier mal irgendwie so eine Folie. So,
das, was man hier jetzt eigentlich schon immer sieht,
ist, in diesem Fall, also hier irgendwie sowas wie unterschiedliche Elemente,
das ist das, was also hier dann also mit diesem Schalssymbol,
also für ein nicht invertierendes Element, das heißt,
da wird einfach nur der Eingangswert zu dem Ausgangswert gemacht und hier sowas wie ein Inverter,
also im Prinzip dieses Symbol mit zum so eine Annegation dahinter,
ein Untgatter, ein Odergatter, ein Nantgatter,
an dein Norgat, damit jeweils zwar einging.
So, und die sind jetzt mit irgendwelchen Eingängen, beziehungsweise Ausgängen
quasi miteinander verbunden. Und was dann eben auch noch ist,
das Ganze läuft jetzt mit dem etwas,
was sich dann also hier in Hade-Sprechweise dann ein Glow-Mode nennt.
Das heißt, ich sehe hier an der Farbe den Zustand.
Das heißt, dieses Grau entspricht dann eben einer logischen Null,
rot entspricht einer logischen Eins
Daneben gibt es dann noch diverse andere Werte,
aber wenn ich jetzt, also hier sieht man,
der Simulator läuft, hier quasi hingehe,
draufklicke und den Wert änder, ändert sich,
also hier quasi beim Eingang der Wert zwischen 0 und 1.
Und bei der hochkomplizierten Funktion des Inverters ändert sich demzufolge dann also auch direkter Ausgang.
Entsprechend invertiert dazu. So nicht. Und dadurch habe ich dann eben die Möglichkeit,
dann eben letztendlich, also hier meine Funktion,
meine Werte anzugeben, sieh, was da ist.
Dieser Glomode sagt jetzt eben zusätzlich noch,
dass dann eben auch die Leitung, also sprich diese Verbindung,
die jetzt hier zwischen diesen Eingängen und irgendwelchen Komponenten oder den
Eingängen von Komponenten und den Ausgängen von Komponenten gemacht sind,
dass die dann eben auch farbig dargestellt werden.
Ansonsten kann ich hier nicht, also das Ganze ist so rumgesehen dann,
also relativ selbsterklärend irgendwie reinzoomen, rauszoomen, irgendwie was umschalten.
Habe dann eben hier die Möglichkeit,
also den suchte ich jetzt nämlich eigentlich, wenn ich dieses Glow-Mode ausschalte,
dann sehe ich jetzt hier nur entsprechend die Leitung als blau gekennzeichnet und dadurch dann eben meine Verbindung.
So, und was man hier miteinander natürlich typischerweise macht oder machen würde,
ist, dass sich das jetzt eben einfach so als ein Schaltplan Editor benutze.
Das heißt, es gibt dann eben so was wie fertige Bibliotheken,
mit denen ich also Elemente hinzufügen kann.
In dem Fall würde ich jetzt also zum Beispiel mal sagen,
ich bin jetzt also hier ungern an einer Stelle,
habe dann mit der rechten Maustaste, kriegt man quasi kontextsensitiv dazu,
dann also irgendwie dann immer so ein Element,
wo ich dann also verschieben,
löschen oder eben Leitung zeichnen kann oder Elemente instanziieren kann.
Ich kann hier durchbrausen, ich kann aber hier zum Beispiel
dann also sowas wie solche Eingänge direkt dann auswählen.
Einmal hinklicken, dann wird er hier platziert.
So eine Funktion ist quasi immer so lange aktiv,
wie ich das Ganze entweder durch einen neuen Befehl beende oder
mit der rechten Maustaste dann quasi entsprechend wieder beende.
Nicht ansonsten sieht man hier oben auch Left Button,
Position Object,
Middle Ride
is Cancel
Das heißt, wenn ich jetzt mehrere Eingänge bräuchte,
könnte ich jetzt eben hier entsprechend fortfahren in den nächsten reinhängen. So,
und wenn ich jetzt also zum Beispiel so eine einfache Schaltung aufbaue,
würde ich dann also, was weiß ich,
hier irgendwo hin als Gate,
nehmen wir jetzt irgendwie mal so was wie ein Nant mit zwei Eingängen,
ich packe ich hier irgendwo hin,
würde hier jetzt noch so eine Ausgabe mir hier hinten dran hängen,
Und jetzt müsste ich das noch miteinander verbinden.
Also auch das kann ich eben entweder hier oben über die Menüs oder
eben auch direkt hier, indem ich dann an passende Stelle gebe,
war ja connect, kann dann hier hingehen.
Mal eine Schaltung miteinander verbinden. Da gibt es noch unterschiedliche Optionen.
Also ob das jetzt hier irgendwie schräg gezeichnete Linien haben darf
oder nur mit Manhattan-Geometrie, also spricht rechtwinklig, arbeitet.
Also da kann man dann letztendlich entsprechend arbeiten, ist so rumgesehen
eigentlich Selbst erklären, man kann da nichts falsch machen.
Also hier sieht man dann immer, was quasi jetzt gerade in Mausbelegung ist.
Wenn ich das Ganze jetzt abbreche. So,
und wenn ich jetzt also irgendwie feststelle,
irgendwas soll hier so nicht sein,
könnte ich eben die Leitung draufgehen, löschen,
beziehungsweise in diesem Fall, ich könnte hier irgendwelche Elemente,
wenn wir das jetzt also von der Anordnung nicht gefällt,
mit Move irgendwo hin bewegen,
sofern Leitung schon richtig angeschlossen sind,
werden die automatisch mitbewegt
Was man hier jetzt nämlich schon schön sieht, ist, was diese Leitung hier irgendwie verlustig gegangen ist.
So, und wie gesagt, Simulator läuft noch. Hier habe ich jetzt noch nichts weiter gemacht,
wenn ich jetzt also hier entsprechend also auf diese Eingänge raufgehe mit der linken Maustaste,
kann ich dann eben hier der Reihe nach meine Werte durchschalten,
so und wie man hier sieht, nennt Gatta,
nicht beide Eingänge, Also ein Eingang, mindestens ein Eingang ist null,
erzeugt mal im Ausgang eine Eins und nur in dem Fall,
wenn beide eins sind,
habe ich im Ausgang nennen wollen.
Gut, und damit könnte man sich jetzt eben entsprechend seine Schaltung zusammenbauen,
was man dort dann eben auch machen kann,
ist aus solchen einfachen Komponenten dann quasi seine eigenen Symbole zu generieren.
Das heißt also jetzt mit irgendwie einzelnen Gattern irgendwie was aufbauen,
zu sagen, das benutze ich als Komponente im größeren Kontext.
Nicht, dass es dann letztendlich das, wo ich vorhin gesagt habe,
damit kann man dann hierarchisch sein System im Prinzip aufbauen.
Nicht ansonsten gibt das dann hier oben Hilfesystem,
dann also noch so diverse Optionen in Bezug auf Einrasten,
auf Darstellung, auf Sonstiges. Ich kann solche Grafiken dann
eben auch, gut, das Ganze natürlich sinnigerweise speichern.
Ich kann das Ganze dann aber auch, gut,
also zum Eindrucken. Man kann das dann aber auch,
muss ich mal kurz gucken, wo das jetzt ist.
Genau, also irgendwie noch in Postscript oder in andere Grafikformate exportieren.
Das heißt, dadurch hat man dann eben die Möglichkeit,
sich so irgendwie seine Schaltung aufzubauen und war es jetzt in
diesem Fall jetzt natürlich dann erstmal ein interessanter Teil ist,
dann hier zu simulieren.
So, machen wir Glow-Mode wieder an. So,
und dann habe ich dann also hier entsprechend jetzt meine Schaltung.
Gut, das ist dann eben so ein typischer Schaltplan-Editor.
Also wie gesagt, da ist jetzt hier die in Anführungszeichen
sehr einfache Variante für wirklich so Hardwareentwurf oder so weiter.
Da gibt es dann natürlich dann etwas andere Werkzeuge,
die dann teilweise auch solche Oberflächen haben,
teilweise dann aber eben auch noch entsprechend
andere Möglichkeiten
Wie man damit dann entsprechend arbeiten kann. Gut, ja,
Grundkomponenten hatte ich ja eben schon kurz gezeigt. Also wie gesagt, Vorführung des Simulators war eigentlich das gerade ihm. Hier so ein bisschen,
also man hat eben so typischerweise seine Eingänge neben ganz einfachen Schaltern,
gibt es dann also auch noch welche,
wo ich dann so weiter quasi hexadezimal sowas wie so ein Vier-Bit-Werte durchgeben kann,
habe dann irgendwie meine Anzeige,
habe dann solche Sachen wie so einen automatischen Taktgenerator,
mit dem man dann Beispielsweise dann eben irgendwie periodisch,
Tagsignale immer wechseln von 0 nach 1 sich erzeugen lassen kann,
beziehungsweise und, und, und.
Und dann eben ganzen Satz von Beispiel Komponenten bis zu etwas komplizierteren Sachen,
wo man dann, also wenn ich jetzt hier in,
also hier habe ich dann die einfachen Elemente, also auf Gatter-Ebene,
nicht dann eben bis zu größeren Sachen, bzw. hier unter Applet,
Gallery habe, dann sieht man also hier da rein nach,
welche Sachen es dort entsprechend gibt, nicht von einfachen.
Gathan bist du irgendwie komplizierteren Sachen, bis zu irgendwelchen Speicherelementen,
das, was wir im nächsten Kapitel kennenlernen werden,
dann eben bis zu kompletten Adierran, Zeelern, und eben auch Speicherbaustein nicht.
Also letztendlich ist das, was im Rechnerstruktur- und Praktikum dann eben auch benutzt wird,
als Umgebung eben genauso dann eben auch letztendlich eine harte Simulation,
mit der da dann also saßen, sondern sein System geschrieben wird.
Gut, Glow-Mode hatte ich ja schon beschrieben, also wie gesagt,
das was wir hier haben oder jetzt erstmal benutzen, ist also
quasi logische null logische 1. Da gibt es dann noch etwas,
womit man dann einmal zeigen möchte, ob irgendwo Kurzschlüsse auftreten,
weil jetzt habe ich natürlich schon die Sache,
dass ich also irgendwie so einen Effekt habe,
wo ich letztendlich in meinem System natürlich irgendwie elektrische Verbindungen habe und war es jetzt natürlich,
also erstmal keinen Sinn macht oder machen würde, wäre,
wenn ich jetzt also hier irgendwie zwei Gatter habe und sage,
okay, ich nehme die Ausgänge und schade,
die war also elektrisch gesehen, es ist erstmal nichts anderes als Leitungsschade, die irgendwie zusammen.
Echt, das kann man in Hades wunderbar machen,
wenn ich das dann entsprechend simuliere, dann sollte,
zumindest wenn der Ausgang hier quasi eine Null generiert und der Ausgang hier eine Eins generiert,
diese Leitung dann also entsprechend Irgendwie sowas wie Magenta wären,
damit man eben sieht, ich habe an der Stelle eben einen Kurzschloss,
nicht beziehungsweise elektrisch gesehen,
würde dann eben in dem Fall irgendwie eins dieser Bauelemente kaputt gehen.
So, nun sieht es aber auch so aus, dass man in der,
oder technisch gesehen, eben es schon braucht bei sogenannten Brustsystemen,
dass dort mehrere Elemente quasi lesen oder schreiben.
Als Beispiel hatte ich ja immer genannt, wenn ich,
im Prinzip ist es wie bei diesem von Neumann-Konzept sage,
ich habe hier meine CPU, also Eigentlich ein Prozessor.
Ich habe dann hier den Arbeitsspeicher, also Rahmen,
der wird dann also quasi über einen Adressbus,
kann ich dann adressieren, auf welches Speicherelement soll geschrieben oder gelesen werden.
Nicht gleichzeitig habe ich dann eben hier eine Verbindung zwischen CBU und Speicher,
was dann ein Datenbus ist und was dann dort natürlich passiert,
also aus der CPU kommt das natürlich auch noch,
was dann dort eben letztendlich passiert ist, dass ich zum einen,
wenn ich in das Rahmen schreibe, worüber eine Verbindung in die Richtung habe, andersrum, aber wenn ich daraus lese, eine Verbindung hierüber in die Richtung.
So und umso war es jetzt technisch zu machen,
sieht das dann eben so aus,
dass im Prinzip so eine vidiorektionale Verbindung oder so ein bidirektionaler Bus hier eigentlich so aufgebaut ist,
dass ich hier intern, also quasi einmal etwas habe,
wo es reingeht und einmal etwas habe,
wo es rausgeht und ich lese letztendlich immer von dem von dem Bus,
bei dem, was hier aber geschrieben wird,
habe ich eben hier sowas wie so einen Schal da,
mit dem man dann eben sagen kann, wenn der Datentransfer hier rüber passiert,
dann wird dieses hier abgeschaltet und ich treibe aus diesem Bauelement jetzt nicht aktiv irgendwie den Boostbus,
das heißt, also ich schreibe dort jetzt nicht irgendwelche Werte 0 oder 1 rauf,
nicht weil wenn der und der das gleichzeitig machen,
dann habe ich eben genau diese Kurzschlusssituation, das heißt,
bei so einem Bussystem muss dann jede Komponente eben die Möglichkeit haben,
dass quasi in Richtung des Schreibens,
man das eben auch komplett abklemmen kann.
So, das lässt sich also elektrisch gesehen relativ einfach machen. In der Simulation wird das dann eben dadurch gekennzeichnet,
das, was ich sagen kann, ich habe,
wenn ich das jetzt also hier als eine bidirektionale Leitung sehe,
eben nicht nur die Möglichkeit zu sagen,
ich schreibe eine Null oder ich schreibe eine Eins,
sondern für den Fall, dass eben diese Leitung hier offen sein soll,
hat man dann eben einen speziellen Wert, Z für hochomig,
in dem Fall ist das dann nämlich,
der Schalter ist geöffnet
Und in diese Richtung fließt dort kein Strom,
beziehungsweise kann ich da eben keinen Spannungspegel drauflegen. Nicht,
das ist also das, was hier mit diesem Tree-State noch letztendlich gemeint ist.
Gut, das braucht man eben bei solchen bidirektionalen Bussen.
Werden wir jetzt hier im Rahmen der Vorlesung aber dann nicht weiter benötigen,
beziehungsweise nur mal das einmal kurz angesprochen ist.
Gut, ansonsten hat er ja schon gezeigt,
also es ist das Ganze doch einigermaßen selbsterklärend, nicht,
man kann nur noch so alle möglichen Sachen dann außer ein- und ausschalten.
Wie gesagt, also beschrieben ist es dann
eben hier
In der Kurzreferenz beziehungsweise dem entsprechenden Tutorial dazu.
Gut, was gibt es in Hardes so an Grundbauelementen?
Nicht das eine, was sie ja schon hatte,
sind natürlich also erstmal diese ganz trivialen, einfachen Gatter.
Nicht, das heißt, und oder nennt Nor in Werter. Buffer,
muss man jetzt auffragen, also warum brauche ich also irgendwie sowas wie ein elektrisches Element,
was irgendwas reinnimmt und genau das Gleiche rausgibt.
Auch da muss man jetzt wieder sagen, Nee,
weil da sind wir jetzt immer so ein bisschen an der Schnittstelle,
wo man jetzt also irgendwie versuchen muss,
jetzt von der bösen Elektrotechnik zu abstrahieren,
wo ich letztendlich in folgendes Problem laufe,
wenn ich jetzt hier so eine Schaltung habe,
also jetzt meinetwegen irgendwie ein Gatter,
da kommt jetzt irgendein Wert raus.
Dieser Wert da rauskommt, der soll natürlich dann irgendwo woanders funktional
ja weiter benutzt werden. Das heißt, da geht dann typischerweise,
was weiß ich jetzt meinetwegen jetzt hier irgendwie in so ein Odergatter mit rein.
So, und was jetzt aber eben sein kann,
Wenn da jetzt hier nur ein einzelnes Gatter treibt,
dann ist das nicht, interessiert mich das nicht weiter.
Problematisch wird das, wenn der jetzt meinetwegen an mehr als
sieben, acht, neun Gatter angeschlossen ist.
Und wenn der jetzt also hier irgendwie 50 oder 100 Gatter treibt,
beziehungsweise dieser Ausgang, Eingang von 100 anderen Gattern wäre,
würde das elektrisch auch nicht funktionieren.
Dafür braucht man dann eben genau solche Treiber,
die letztendlich nichts anderes sind als Verstärker,
wo ich dann eben sagen kann, okay,
Der logische Wert geht eins zu eins durch,
elektrisch gesehen gibt es da dann aber eben schon noch irgendeine Funktion,
die sich dahinter verbirgt.
Nämlich, dass sich da dann eben entsprechend jetzt mit stabilen
Spannungspegeln arbeiten kann. Also das nur als Grund dafür,
warum man jetzt solche nicht invertierenden Eins-zu-eins-Verbindungen hat. Gut,
ansonsten brauchen wir das hier also auch nicht weiter,
nicht, aber wie gesagt,
ich versuche hier immer nochmal so ein bisschen zu motivieren,
was da also letztendlich für einige funktional unsinnige Sachen,
worum es da sowas gibt.
Gut, ansonsten sind jetzt also hier
diese ganzen unterschiedlichen Beispiele
Also da kann man halt immer schön irgendwie simulieren,
unten mit zwei Eingängen. Ein Hund, was dann also
quasi aus dem Oder aufgebaut ist, entsprechende dem Morgenregeln,
nicht, also mit Invertierten Eingängen und einem invertierten Ausgang.
Nicht, dass man das dann eben entsprechend alles mal durchsimulieren kann. Wie gesagt,
es findet sich dann eben dann auch direkt unter Gates 00 Gates,
der Morgen, dann eben das entsprechende Beispiel,
was man sich da dann also letztendlich in Hades reinladen kann.
So, dann hat man so seine üblichen Gatter mit ein,
zwei,
drei,
vier Eingängen
Ich sage, ist egal, also ob das jetzt und,
Gatta oder wie hier. Oder Gatta sind.
Wenn man jetzt mehr Eingänge hat oder mehr Eingänge bräuchte.
Also beispielsweise sowas wie ein Ungatta mit zwölf Eingängen.
Auch da muss jetzt wieder sagen, findet sich dann also
hier bei den Beispielen dann eben sowas wie so ein End-Big.
Rein logisch kann ich natürlich sagen, okay,
ich baue jetzt also hier irgendwie so einen Gatta mit
zwölf Eingängen auf
Elektrisch würde es auch nicht mehr funktionieren,
beziehungsweise habe ich da dann eben auch relativ viel an Problemen,
die da reinkommen können,
beziehungsweise da sieht es dann auch so aus,
dass so eine Lösung wie hier,
wo das da so quasi so kaskadiert wird,
indem ich dann immer hier mit drei Eingängen das Ganze zusammenfasse
und dann diese Dreiergruppen dann eben wieder entsprechend dann mit
vier Dingern dann eben erweiter
So eine Schaltung oder so eine Schaltung jetzt also ausnennt und
Norgatan schneller ist und gut heutzutage verkauft sich alles über Gigahertz-Geschwindigkeiten,
eben auch schneller ist, als jetzt ein einzelnes Gatter,
was ich jetzt versuchen würde, irgendwie mit zwölf Eingängen direkt zu realisieren.
Deswegen hat man bei diesen Bibliotheken, die sich da finden,
also wenn ich da jetzt mal gucke,
was dort an Gattern in Hades vorhanden ist,
eben typischerweise so bis vier,
fünf,
sechs Eingänge bzw. bei den einfachen Gattern dann da eben
auch nicht sehr viel mehr
Auch da muss man sagen, hat dann eben wieder elektrotechnische Gründe.
Da müsste man jetzt wissen, wie die Gatte aufgebaut sind,
würde ich aber jetzt hier auch nicht weiter vertiefen. Eine andere Sache,
die da auch noch so ein bisschen mit reinkommt,
ist Folgendes, es gibt dann immer noch sogenannte Gatter mit,
so irgendwie so teilweise komischen Bezeichnungen,
haben wir in diesem Fall jetzt also aus der Bibliothek so eines Herstellers für Chips quasi geklaut,
so eine Art, oder die Art von Bezeichnung.
Und zwar handelt es sich da um sogenannte Komplexgatter. Komplexgatter ist etwas,
was Für uns im Sinne der Bullshen Algebra einfach ein mehrstufiges Schaltnetz ist.
Das heißt, ich habe hier sowas wie ein Und. Und
dessen Ausgang gilt dann eben nochmal in so ein Nant mit zwei Eingängen.
Und das Ganze ist dann eben und oder invertiert, deswegen AOI,
2, 1, weil ich hier zwar eingänge und da noch den einen zusätzlichen Eingang habe.
Gut, wie die Dinger benahmst sind, ist es letztendlich vollkommen egal.
Was man hier eben auch nur Wissen sollte, ist,
wie gesagt, für uns ist das eine zweistufige Logik,
elektrotechnisch gesehen ist sowas nicht komplizierter als ein Nantgutter mit drei Eingängen.
Also wenn ich so nenne, Cutter mit drei Eingängen habe,
brauche ich dafür, um das aufzubauen, Simos,
Technik, sechs Transistoren, 3P-Kanal und drei Endkanaltransistoren.
Und genau das Gleiche brauche ich hier, fühle mich auch.
Deswegen finden sich in solchen Bibliotheken und eben unter anderem dann also auch in Hades,
wenn ich jetzt also hier irgendwie Create unter Komplex Skates dann eben irgendwie alle diverse von diesen komischen Kombinationen,
die dann eben, ich kann nochmal eins instanzieren,
dass ich die dann eben letztendlich, also irgendwie so war es,
machen, wo ich dann im Prinzip so eine mehrstufige Sache habe.
So nicht. Und dadurch kann man dann,
also jetzt wieder in der technischen Umsetzung sehr einfach dann eben solche Schaltnetze,
nicht wenn ich jetzt also wieder dran denke,
an Schaltfunktionen und die Normalform dazu,
wo ich dann ja quasi hier sowas bilde,
wie beispielsweise an meine Min-Therme und das Ganze dann eben zusammenfasse.
Gut, in dem Fall hätte ich dann,
als ich hier noch einen Ausgang der Invertierung, nicht aber,
dass das Ganze dann also letztendlich dann so was wie ins wahlstufiges Schaltennetz,
also jetzt von solchen Realisierungen von Normalformen dann eben beispielsweise umsetzen würde.
Und wie gesagt, solche Komplexgatter sind da dann eben auch noch mit drin.
Dann habe ich hier so an Sachen exklusiv oder exklusiv oder negiert.
Nicht hier dann nochmal so das, wie uns das Ganze jetzt als Schalssymbol begegnet,
dass wie das Ganze dann technisch aufgebaut wird, für dich sind,
beziehungsweise technisch wurde es dann also eher so eine Nant-Realisierung entsprechend nicht.
Und letztendlich in solchen Umformungen hin steckt dann eigentlich immer nichts anderes. Nicht also letztendlich genau das Gleiche,
was hier gemacht wurde,
als die Rechenregeln der Poolschnalle gebrochen, dass ich sage,
okay, sind und kann ich eben realisieren als Nicht,
wenn ich hier habe, A und B nicht,
dann ist das ja nichts anderes als A und B,
zweimal negieren, nicht,
dann kann ich hiermit im Morgen das Ganze dann entsprechend reinnehmen,
hätte dann A nicht oder B nicht und das Ganze wieder negiert und ich,
und das ist also genau das,
was da die andere Lösung entsprechend,
also dieses hier ist.
Nicht, das heißt,
da sieht man dann eben einfach nur rein praktisch jetzt an
diesen Gattern wieder ein Asymposchal geworden und letztendlich funktioniert
Ja, und damit kann man dann eben das,
was wir in unterschiedlichen Beispielen irgendwo schon mal kennengelernt haben,
dann eben auch technisch realisieren. Also sprich sowas wie Fehler kennende Codes.
Da hat man irgendwie Prüfsummen, Parität, exklusiv oder nicht.
Dann kann ich also quasi eine 4-Bit-Parität, also über so ein,
beispielsweise mit diesen drei Gattern dann letztendlich technisch realisieren,
beziehungsweise wenn ich da jetzt also irgendwie mehr brauche,
kann ich dann eben daraus jetzt irgendwelche Bäume aufbauen.
Und genau das passiert, so umgesehen eben auch in den CPUs unserer Rechner,
dass dort dann eben entsprechend auch solchen Gatta-Funktionen, wenn dort irgendwo eine bestimmte Funktionalität,
meinetwegen ist also eine Parität über 32 oder über 64-Bit benötigt wird,
dass das dort dann eben wirklich in Form von Gattern in Form von Hardware irgendwie realisiert wird.
Anderes Bauelement, was man also auch ständig braucht,
was ja auch schon mal kurz vorgestellt habe, ist dann immer irgendwie sowas wie ein Multiplexer,
also hier jetzt als 2 zu 1, das heißt,
ich habe zwei Dateneingänge und einen Steuereingang, mit dem ich auswähle, welcher Dateneingang zum Ausgang durchgeschaltet wird.
Hatte ich also auch schon mal kurz beschrieben,
als Schaltfunktion entspricht, also letztendlich hier dieser Tabelle,
da ist ich nämlich abhängig von dem Steuereingang S,
hier am Ausgang, entweder A0 oder A1 ausgebe,
wie man also hier dann unschwer in der Funktionstabelle sieht,
beziehungsweise was man dann häufig macht, ist dann eben so eine Tabelle,
wo das Ganze noch ein bisschen kompakter geschrieben wird,
indem ich dann also entweder so Don't Cast verwende oder indem ich die Werte selber hier dann quasi als freie Variablen einsetzt,
wenn ich uns sage, wenn es null ist,
ist der Ausgang A0, wenn es eins ist,
ist der Ausgang A1 nicht,
dann sieht man das eigentlich direkt und relativ eindeutig,
wie das Ganze funktioniert.
So, und das gibt es jetzt natürlich nicht nur nur mit zwei Eingängen,
sondern also letztendlich als N zu eins multiplexer mit ihm entsprechend vielen Eingängen,
wo man dann im Prinzip jetzt mit Steuereingängen dann eben bis zu zwei hoch M minus eins, Dateneingänge, umschalten kann.
Also hier ist das Ganze dann für zwei Steuereingänge und vier Dateneingänge,
wo ich das Ganze dann eben hier letztendlich binär kodiert, entweder A0 oder A1 oder A2 oder A3 zum Ausgang durchschalte. Nicht und als Schalt-Netz dahinter verbirgt sich dann natürlich der entsprechende Schaltagobranche-Ausdruck,
der sich also dann aus einer Funktionstabelle heraus ergeben würde,
was man dann meistens aber hat, ist dann eben hierfür,
also jetzt im Sinne so eine Hierarchie,
wo das Ganze dann eben letztendlich aus kleineren Zahlen zusammengebaut wird,
dann eben so ein Element, wie so ein Multiplexer,
was dann eben entweder so gezeichnet ist,
wo man dann eben wirklich direkt diese Funktion,
dieses Wechselschalters sieht, beziehungsweise sonst häufig als Bauelement für ein Multiplexer,
dann eben irgendwie dann sowas, wo ich letztendlich sage,
ich habe hier meine Dateneingänge,
ich habe hier meine Steuerleitung und ich entscheide dann eben letztendlich über die Belegung hier 2,
2, 1, 0, nicht je nachdem,
was das hier an Werten ist,
welcher von diesen Eingängen hierhin umgeschaltet wird.
So, und das hat man dann eben auch typischerweise in der Computerhardware
dann natürlich nicht nur für einen Bit, sondern dann eben mal gleich für ein ganzes Leitungsbündel.
Nicht damit kann ich dann aber eben auswählen,
wenn ich jetzt eben zum Beispiel mehrere Quellen zur Verfügung habe,
von welchen Stellen oder von welchen Positionen jetzt,
also zum Beispiel irgendein Argument kommen soll oder damit dann irgendwie weitergerechnet wird.
Gut, daneben gibt es dann also auch genau das umgekehrte Demultiplexer,
wo ich dann also letztendlich hier Einleitung habe,
das Ganze dann eben auf entsprechend einen Satz von Ausgängen verteile und dann eben hier quasi beneakodiere,
ob das jetzt also in Y0, Y1, Substanz 2 oder Y3 entsprechend rausgeht.
Gut, ist eigentlich soweit selbsterklärend. Ja,
was hier dann teilweise auch noch mit drauf ist,
deswegen hatte ich eigentlich diesen Schrottner, dieses wertvolle Teil mitgebracht,
ist, dass hier teilweise jetzt also noch irgendwie so Beispiele drauf sind,
wo dann also irgendwie in der Folienüberschrift, also irgendwie drin steht,
integrierte Schaltung, 74, 1, 5, 1,
was ist damit gemeint?
Da muss er jetzt eben genau letztendlich wissen, also das,
was, worauf sich dieses hier bezieht, ist halt so eine,
eben die Bauteilserien von solchen ICs, also typischerweise sowas hier,
beziehungsweise das, was dann also hier zuhauf drauf ist,
wo es dann von den Herstellern letztendlich einen ganzen Satz von unterschiedlichen Gatta-Funktionalitäten gab,
die dann also quasi als einship zur Verfügung gestellt wurden.
Wenn man jetzt sagt, also dieses hier,
also in diesem Fall jetzt dieser Multiplexer,
wo ich jetzt also quasi hier aus acht Daten eingänge,
entsprechend mit drei Steuerleitungen,
einen von denen hier auf den Ausgang durchschalten kann.
Nicht das war halt eben so eine Schaltung,
die man dann eben quasi als einen so einen Baustein letztendlich kaufen konnte.
So wie man sieht, ist natürlich jetzt noch nichts mit
Hoch integriert und Milliardentransistoren, nicht sondern also hier sind damals
also gefühlt irgendwie 15 Gutter irgendwie mit drauf.
Und wenn ich das dann also letztendlich dann nochmal ausrechnen würde,
komme ich dann also irgendwie im Bereich von ein paar hundert Transistoren.
Das ist also dann letztendlich die Technik, die man früher hatte. Bloß wie gesagt,
also aus, ja, sagen wir mal, Gründen,
um jetzt solche Scheidungen zu beschreiben,
die auch noch ein bisschen von Menschen nachvollziehbar sind,
findet man dann häufig immer diese Referenzen oder Anspielungen auf diese 74er-Baureihen.
Nicht wie gesagt das, was sich dahinter dann verbirgt,
kann ich hier noch kurz in der Wikipedia zeigen nicht.
Also wie gesagt, das ist dann hier beschrieben,
letztendlich, worum es dann ging. Also wie gesagt,
damit wurden dann in den Anfängen der Computertechnik, als es dann,
also an die Medium-Scale-Integration ging, letztendlich Computer aufgebaut.
Da waren sie dann eben wirklich noch schrank groß.
Irgendwann dann konnten eben immer noch mehr Getalkomponenten integriert werden.
Das Ganze, wo dann eben denen zufolge dann,
Immer, noch kleiner. Und wie gesagt, so was,
was hier jetzt beispielsweise, ich werde jetzt bösartigerweise nicht spenden.
Also das, was jetzt eben beschrieben ist,
sind dann eben wirklich solche Sachen bis zu dem allereinfachsten Baustein 74.0.0. Nicht wie man hier sieht,
Fear nennt Gutter in so einem Gehäuse.
Das ist nämlich genau dieses Teil hier. Gut,
ja, das eigentlich nur mal so ein bisschen zur Historie
Gut. Deswegen sind jetzt hier eben noch so einige von diesen Beispielen.
Nicht Demultiplexer, wo ich dann also quasi mit vier Steuereingängen
einen Eingang dann eben auf einen von 16 Ausgängen schalten kann.
Wofür man solche Bausteine oder solche Demultiplexer im Prinzip braucht oder wo die implizit eigentlich mit drin sind,
ist beim Speicher für die Adressdekodierung, weil das,
was ich hier letztendlich mache, ist, dass wenn ich sage,
ich habe einen Speicherbaustein, also Rahmen, in das ich schreibe,
reinschreiben oder aus dem ich rauslesen kann.
Dort wird ja adressiert eine Speicherzelle,
in der sich dann, wo typischerweise erstmal ein Acht-Bit-Wort,
aber eben so rum gesehen eigentlich jetzt ein längeres Speicherwort verbirgt, dass sich irgendwo auswählen muss.
So, hier habe ich jetzt eben beispielsweise,
wenn ich jetzt sage, 10-Bit für die Adressen, 1024 Worte,
die ich adressieren kann und das, was hier vor ist,
ist dann eben letztendlich nichts anderes als ein Demultiplexer,
der quasi jetzt aus diesen zehn Adressleitungen eben genau für ein einziges Wort quasi diese Zelle aktiviert oder diese Zeile aktiviert und alle anderen nicht aktiviert lässt.
Also dafür sind dann eben beispielsweise solche Demultiplexer nötig. Gut,
sonst andere Schaltennetze für einige Sachen,
die wir ja so auch schon kennengelernt haben,
kommen jetzt hier noch ein paar triviale Beispiele,
wo das Ganze dann nochmal so ein bisschen gezeigt wird,
also hier mal als ein kleines Beispiel,
also angenommen wir möchten sowas machen, wie irgendwo einen elektronischen Würfel.
Das heißt, ich habe jetzt irgendeine Möglichkeit,
mir da jetzt also irgendwie Zufallszahn zu erzeugen,
mache daraus dann also irgendwie was,
wo ich dann also mit einer gleichen, gleichartigen Verteilung,
also irgendwie Werte von 1 bis 6 rausbekomme.
Und das Ganze soll jetzt irgendwie erst mal mit Leuchttionen beispielsweise, also Leuchtpunkten dann eben angezeigt werden.
Nicht könnte man dann so machen, dass man sagt,
okay, ich habe jetzt, also hier irgendwie sieben Leuchttionen,
die also wie hier angedeutet, angeordnet sind.
Und damit kann ich dann eben quasi hier meine Ausgaben,
wie hier angedeutet, dann eben entsprechend Anzeigen, nicht wobei ich dann eben sage,
wenn ich an der entsprechenden Variablen, also beispielsweise EAX7,
eine Eins habe, dann soll eben dieser Punkt leuchten.
Nicht wenn ich da eine Null habe, wie hier soll er dann eben entsprechend nicht leuchten. So,
und da macht man ja nichts anderes, als dann das,
was im vorigen Kapitel einfach dran war, dass man sagt,
okay, ich habe hier meine Werte,
ich habe hier meine Eingangskombination in diesem Fall null,
wo alles ausgeschaltet ist, bis sechs, alles dahinter,
sprich den Fall sieben betrachte ich dann als Don't Care.
Und Ich beschreibe dann hier jetzt eben für jede Funktion,
also sprich für jede LED dann eben eine entsprechende Funktion,
wo ich dann eben sage, wann ist er ausgeschaltet, wann ist er eingeschaltet.
So, und dann geht es in diesem Fall jetzt darum,
als Schaltnetz zu sagen, okay,
wie kriege ich das Ganze möglichst klein, möglichst kompakt aufgebaut?
Wenn man jetzt hier in die Tabelle guckt,
sieht man also schon mal, da sind also einige Sachen,
die nur vergleichsweise einfach oder ähnlich sind,
nicht,
also X1 und X7 sind identisch,
X2 und X6 sind identisch,
X3 und X5
sind identisch
Und das heißt, ich muss jetzt also hier nur noch irgendwie
diese vier Funktionen irgendwie beschreiben, abhängig von den Eingangsvariablen.
Und dann sieht man also auch relativ einfach sowas
wie eingangs variable B0 ist gleich X4.
Und bei den anderen kann ich das dann eben durch geeignete logische Kombinationen,
also X1 ist gleich B2 oder B1,
beziehungsweise X2 wäre dann B2 und
Mir da dann also irgendwie meine Schaltfunktion quasi raussuchen. So,
ich habe das jetzt hier natürlich nicht schön formal gemacht,
nicht, also eigentlich würde man jetzt anfangen,
das Ganze in KV-Diagramm zu übertragen, dort Schleifen zu bilden,
führt aber im Prinzip genau auch zu dem Gleichen,
was ich hier nämlich beschrieben habe,
nämlich die Funktion für XRs beziehungsweise X7 mit einem Odergatter,
XV und XX6 mit einem und das wird hier nur durchgeführt und X4 ist dann eben auch gleich wie null und damit kann ich dann eben das Ganze dann eben auch wirklich so methades letztendlich technisch aufbauen,
habe ihm meine Eingänge, hier jetzt meine Funktion,
das Ganze miteinander quasi so verdrahtet und könnte damit dann das auch entsprechend simulieren,
wollen wir diese,
den möchte ich nicht speichern.
So nicht und hier unter Würfel habe ich dann also hier in meine Schaltung,
in diesem Fall dann hier gleich mit so einer hexadizimalen Eingabe,
also bei null ist alles ausgeschaltet bei 1. Ist das an und ansonsten tut sich eigentlich genau das,
was man hier dann sinnigerweise auch erwartet.
So und bei allen anderen Werten. Gut,
da habe ich dann eben letztendlich irgendeine Minimierung,
die quasi jetzt irgendwelchen Don't Cars entspricht und dem
zuvor können da jetzt also Sachen auftreten,
die man jetzt vielleicht nicht so haben wollte.
Ist im Fall wiederholen sich, da ist nur ein paar Werte,
ist da jetzt also auch nicht weiter.
Schlimm. Gut,
das war jetzt also erstmal so ein ganz einfaches,
triviales Beispiel
Wie sowas aussieht. Anderes Beispiel für etwas, was du auch schon kennengelernt haben,
ist eben zum Beispiel Umwandlung von Dualcode in Greycode.
Nicht Greycode war ja das, wo ich dann so quasi,
wenn ich C direkt durchzähle, 0-1,
2-3, ich einen einschrittigen Code habe.
Nicht wo ich ja gesagt hatte, die Berechnungsvorschrift dafür ist,
dass ich immer quasi zwei benachbarte Bits betrachte, gucke,
haben die sich zueinander geändert, wenn die sich ändern,
erhalte ich als ausgangswertende einzelne im Greyboard,
wenn die sich nicht ändern,
erhalte ich als ausgangswertende Null
Habe ich ihn technisch gesehen, ich hatte da dann schon den Schaltal gebraschen aus,
so kennengeschrieben, kann man das dann eben auch einfach durch.
Oder Gatter machen, die dann eben quasi zwei über Nacht wartet,
bis es immer jeweils miteinander verbinden. Und so kann ich dann eben,
gibt es dann eben hier auch so eine entsprechende Schaltung,
wo ich dann also hier jetzt also in diesem Fall ein Vierbit
wie ein Nährwert habe und könnte dann eben hier direkt ein Vierbit Grey wert ablesen.
Beziehungsweise hättet ihn dann zur Verfügung. Nicht,
das hatten wir dann eben auch schon in umgekehrt kennengelernt,
wie man da so aus Grey wieder Dualcode macht. Also wie gesagt, all sowas findet sich dann eben letztendlich in ein Hadesbeispielen. Eine etwas komplexeres Beispiel ist,
Das, was ja nun auch quasi gerade dran ist oder warm gewesen ist,
wo es also nochmal so ein bisschen darum geht,
also in diesem 7-4-Hemming-Code irgendwie was zu machen,
wo ich dann eben letztendlich sage,
ich habe die Kodierung, habe dann also die Übertragung,
in dem Übertragungskanal können sich jetzt einzelne Bits ändern,
dadurch habe ich dann Hemmingode, war ja so gewählt,
dass man also quasi eine entsprechende Redundanz hat,
dass ich dann also ein Bit-Fehler korrigieren kann und Ah,
ein seltener Schreibfehler.
Hier sollte logischerweise ein C stehen, Dekoda und Fehlerkorrektur,
wo man das Ganze dann eben entsprechend diesem Fehlersyndrom dann eben wieder korrigieren kann. So,
alles zusammengefasst, auch dazu gibt es dann also hier so ein Beispiel,
was jetzt allerdings ein bisschen anders aufgebaut ist, das ist das,
was ich in den Übungsaufgaben dann gemacht oder gefragt habe,
wo ich also hier, ich weiß,
ich kann gleich mal die Demo starten, dann ist das,
glaube ich, ein bisschen einfacher, also Open Heming.
So, also ich habe hier jetzt meine vier Eingangsbilds.
Habe dann also hier entsprechend die drei Prüfpitzs,
die dann also entsprechend diesen Vorsteller dieser Berechnungsvorschrift dort dann also letztendlich noch hinzugefügt werden.
Hier ist das Ganze jetzt so, dass die jetzt also
in den Codebits quasi hier nicht richtig reinverschränkt sind.
Also das heißt, diese Reihenfolge hier entspricht, also jetzt nicht dem,
was also beispielsweise eine Übungsaufgabe mit der Nummerierung der Codebits drin ist.
So, dann habe ich hier jetzt quasi mal ein kodiertes Wort.
Das geht jetzt in die Übertragung, in der Übertragung,
also in dem Übertragungskanal können jetzt Fehler auftreten. Das wird hier dadurch simuliert,
dass ich hier quasi einfach exklusiv oder Gatte habe,
mit einem zusätzlichen Eingang, wenn alle Eingänge null sind,
dann wird quasi dieses Wort hier eins zu eins weitergeleitet,
wenn ich einen Einbittfehler habe, Kann ich hiermit einfach auswählen,
an welcher Stelle das Ganze passiert.
Sondern in diesem Fall wird also hier quasi jetzt dieses eine Datenbett falsch übertragen. So,
und das, was hier hinten dann passiert, ist,
dass dann eben hier draus dann eben berechnet wird,
quasi dieses Fehlersyndrom, also dieser Dreibettwerte,
der jetzt also sagt, an welcher Stelle,
ist der Fehler aufgetreten.
Das Ganze wird dann eben entsprechend dekodiert.
Nicht in diesem Fall ist das jetzt also an der Stelle
eins aufgetreten
Führt dann eben dazu, dass dann eben das entsprechende Bild
hier wieder mit dem Exklusiv oder dann quasi wieder entsprechend zurückgerechnet
wird und ich dann eben hier auch mal ein richtig übertragenes Eingangswort habe.
Echt? Da sieht man dann irgendwie das Ganze quasi funktioniert. Also auch,
wenn ich jetzt also an beliebigen anderen Stellen meine Fehler einbaue,
nicht in diesem Fall Fehler jetzt hier an der Stelle,
würde das dann eben hier auch entsprechend markiert werden.
So und wo das Ganze dann eben nicht mehr richtig funktioniert, ist,
wenn ich weil dafür ist der Hemming-Code ja nicht entworfen,
wenn ich jetzt eben zwei Wittfehler habe,
also in diesem Fall jetzt also quasi an dieser und an dieser Stelle,
weil dann kann ich das eben in dem Fall dann nicht mehr korrigieren,
beziehungsweise dann erzeugt diese Schaltung auch völlig falsche Ausgangswerte.
Nicht aber alles, was also letztendlich immer noch als Einwittfehler hier auftaucht,
wird, dann immer noch richtig korrigiert, also das heißt,
dieses Bitmesser und dieses Bitmuster sind entsprechend identisch.
Gut, darüber kann man dann eben auch nochmal sehen oder
nochmal so als Beispiel sehen, wie das Ganze funktioniert.
Wie gesagt, das ist jetzt hier natürlich schon etwas komplexeres Beispiel. Wie gesagt,
sowas wird in Übungsaufgaben dann also auch schon nicht mehr drankommen,
nicht aber um nochmal so ein bisschen zu zeigen,
also wofür man sowas dann eben auch wirklich praktisch nochmal benutzen kann,
weil wenn ich jetzt meine Schaltung irgendwie aufgebaut habe,
mir da irgendwie was überlegt habe,
zum Beispiel jetzt irgendein Fehlerkorrekturverfahren ausgedacht habe,
nicht kann man dann eben mit solchen Möglichkeiten Skematic Editour das Ganze mal eben schnell aufbauen,
mal eben simulieren, dann eben auch gleich rein praktisch sehen,
funktioniert das Ganze richtig.
Oder habe ich da noch irgendwo einen Fehler in irgendwelchen logischen Ausdrücken mit drin?
Habe ich da irgendwie was falsch gemacht oder falsch berechnet? Gut,
also das ist ein Beispiel, ein anderes Beispiel,
was uns dann vielleicht auch noch eine folgende Übungsaufgabe nochmal begegnen wird,
was immer ganz gerne genommen wird.
Sieben Segmentanzeigen, das ist also etwas, was man so als Anzeige aus einzelnen LEDs, also auch immer ganz gerne im Computerbereich verwendet. Wie gesagt,
Statusanzeige von irgendwelchen kleinen Geräten, Kontrolle von irgendwelchen Sachen,
Selbsttest auf Motherboards oder so weiter, ist,
was teilweise dann also irgendwo mit drauf, wo ich dann im Prinzip,
so wie hier angeordnet, sieben Leuchtdioden habe,
ich meistens dann eigentlich in der Praxis dann hier noch sowas wie ein Dezimalpunkt,
den habe ich jetzt hier weggelassen und je nachdem,
wie ich diese leuchtet und quasi ansteuere,
kann ich damit dann eben natürlich erstmal meine Ziffern von 0 bis 9 darstellen,
was man dann häufig noch hat.
Wir sind dann die entsprechenden Erweiterungen, um damit dann eben auch noch so hexadizimal,
also sowas wie ein großes A, ein kleines B,
ein großes C oder eben so ein,
noch eben so ein bisschen exadizimal Sachen mit zu visualisieren.
Nicht in das, was da rein praktisch dann ja passiert,
ist, dass ich sage,
ich kriege sowas wie ein Vier-Bit, wie nährwert oder Dualwert,
als Eingang und der wird letztendlich dekodiert in diese sieben Ausgangsfunktionen,
wo dann eben jetzt für den entsprechenden Wert jeweils drinsteht,
für ein einzelnes Segment soll es an sein,
soll es nicht an sein.
Nicht daneben kann man mit solchen Dingern dann eben auch noch so ein bisschen andere alphanumoirische Anzeigen machen.
Also gut, einige Buchstaben funktionieren also nicht so richtig,
aber so ein paar andere Sachen kann man damit dann als Spieler,
ja, Testweise dann eben auch noch so ein bisschen mit ausgeben.
Gut, hier ist das Ganze dann eben mal beschrieben. Er hat gesagt,
jetzt mal ist jetzt eben so zu lesen,
dass ich hier letztendlich als Schaltnetz, A, B,
C, D, E, FG,
das sind jetzt eben meine sieben Ausgangsfunktionen und die entsprechenden Eingangswerte wären dann eben letztendlich die hier zugehörigen Hexerdezimalwerte von 0 bis 15.
Und wenn ich jetzt also diese Zeichen A bis F nicht habe,
nicht dann würde man eben zum Beispiel bei sowas,
wenn ich jetzt nur von 0 bis 9 habe,
dann eben genau sowas wie Don't Cared Harme mit dort haben,
beziehungsweise mit benutzen
Gut, ja, und das ist eben so ein klassisches Beispiel,
wo man sagen kann,
okay, möchte ich jetzt irgendwie fertig haben als Schaltnetz,
typisch jetzt eben 4-Bit-Eingangsvektor, 7-Bit-Ausgangsvektor, wie kriege ich das Ganze jetzt,
also letztendlich umgesetzt, jetzt kann ich natürlich anfangen,
aus dem Ganzen hier jetzt für jede von diesen Funktionen mir da so irgendwelche KV-Diagramme zu zeichnen,
dann zu gucken,
welche Elemente oder welche Therme aus benachbarten oder aus anderen KV-Diagrammen kann ich vielleicht noch wiederverwenden,
weil man kann jetzt natürlich sagen, okay,
ich betrachte jetzt jede Funktion, also für das Segment A,
für das Segment B und so weiter einzeln für sich.
Ganz schön wäre es natürlich, wenn man ähnlich wie bei
diesem Würfelballspiel Teile als identisch oder ähnlich mitbenutzen kann,
sodass man da eben auch irgendwelche Teiltherme hat,
um sowas entsprechend zusammenzufassen
Gut, sowas als Übungsaufgabe zu machen, wäre jetzt bösartig.
Deswegen, also das mache ich natürlich nicht. Es gibt dann
so einige Lösungen, die man also in der Literatur findet.
Also Schiffmann, Schmitz in dem Buch. Also die haben letztendlich dann,
also hier sowas, also eine Art zweistufige Lösung,
wo dann also hier irgendwelche Taltherme gebildet werden und die dann
eben hier irgendwie zusammengefasst sind.
Das entspricht dann eigentlich eher
auch so einer relativ direkten Realisierung
Es gibt zu dem Ganzen, weil, wie gesagt,
nicht sieben Segmentanzeige, ist ja nun auch irgendwo sowas,
was also an die Computertechnik der 70er Jahre eher erinnert.
Natürlich dann also auch irgendwelche 74er-Bausteine, die sowas letztendlich mal an.
Ansonsten, um sowas quasi mit minimalen Gatteranzahlen zu machen,
finden sich dann also wirklich so vergleichsweise sehr unübersichtliche Lösungen,
also wie sowas hier, was von Donald Knuth gemacht wurde.
Er hat etwas in sich in dem Buch Art of Computer Programming findet,
wo also hier über Exklusiv-Oder und irgendwelche Ohrenfunktionen oder Funktionen dann eben entweder Eingänge oder Teiltherme,
die dann also hier gebildet werden, eben auch entsprechend wiederbenutzt werden.
Nicht dadurch kann man sagen,
habe ich mit sowas hier eine so umgesehen minimale Realisierung von dem Ganzen,
aber also mit irgendwelchen Minimierungen in KV-Diagramm auf sowas zu kommen,
würde man dann, glaube ich, nicht machen.
Deswegen, wie gesagt, macht keinen Spaß, das andere Weiz,
also auch nur Als abschreckendes Beispiel, ja immer gezeigt.
Also wie gesagt, das machen wir jetzt hier nicht weiter.
Gut, jetzt kommen wir aber eigentlich wieder zu etwas,
was also eher praktisch für uns interessant ist,
nämlich wie werden letztendlich logische und arathmetische Operationen umgesetzt?
Weil das ist ja etwas, wo man sagt, na gut,
also hier so multiplexer, dem multiplexer habe ich auch noch einen Bahnbauelementen.
Sowas mit einzelnen Gardern und daraus irgendwas zusammenbauen.
Und damit möchte ich mich im Zweifelsfall nicht befassen.
Was wir aber rein technisch natürlich irgendwo haben oder irgendwo mit benutzen,
ist, dass man dann sagt, okay,
hier irgendwo in der CBU, soll irgendwo gerechnet werden.
Ich habe dann eben irgendwie sowas wie diese ARU,
wo ich also quasi hier zwei Bit-Vectoren für A und B reingebe,
irgendwie ein Bit-Vector für das Ergebnis rauskommt.
Und dann kann ich sagen,
das sind dann eben beispielsweise jetzt also irgendwie zwei Komplimentssahnen,
mit denen ich dann also letztendlich eine Addition oder eine Subtraktion machen kann oder
meistens hat man dann eben hier noch so einen ganzen Satz von Steuerleitung,
wo ich dann eben unterschiedliche Funktionen hier
drin einstellen kann
So, wie kriegt man sowas jetzt eben technisch realisiert?
Und das ist so ein bisschen das, was also jetzt
hier im Rest dieses Kapitels dann eben oder noch mit beschrieben ist.
Nämlich, wie mache ich jetzt Addition von Zahlen?
Ich war, bislang habe ich immer gesagt, ja gut,
das macht man so wie auf der Tafel, wie im Dezimalsystem.
Ich nehme meine Elemente. Ich schreibe das dann also hier
immer irgendwie so als Vektor entsprechend untereinander auf.
Nicht und je nachdem, was ich da habe
Rechne ich dann einfach ganz stumpf und sage, okay,
ich kriege aus diesen beiden Argumenten,
hier ist eben eine Null,
habe dann eben hier sowas wie einen Übertrag,
muss dann eben dieses Fall jetzt hier drei Elemente addieren,
ich hätte hier wieder Nullen Übertrag und so weiter nicht und kann damit dann eben rechnen,
nicht, und das war also letztendlich die Arithmetik,
die ich vorgestellt hatte,
wenn man jetzt also entweder mit Unsigned oder mit zwei Compliments
Zahn letztendlich rechnet und hier geht es jetzt eben darum,
wie wird das Ganze dann eben so ein bisschen technisch realisiert
aus einzelnen Gardern
Dazu kommen wir jetzt erst mal dazu, dass man sich anguckt,
was passiert eigentlich als Schaltfunktion dahinter und das Einfachste ist also erst eine sogenannte Halbadierer,
wo ich dann eben sage, ich habe zwei Argumente A und B,
aus denen berechne ich dann eben Heiner Einbettsumme und einen Übertrag,
nämlich genau das,
was ich hier jetzt eben irgendwie immer auf der Tafel gemacht habe,
wo ich jetzt eben sage, beispielsweise hier an der niederwärtigsten Stelle,
Wie sieht Summe bzw. Übertrag aus,
wenn ich mit diese beiden Argumente A und B addiere?
Gut. Kann man dann eben hier auch einfach als zwei Funktionen entsprechend für Carry Out,
also sprich für den Übertrag und für die Summe aufzeichnen,
nicht die Funktion selber, sieht man,
sind dann vergleichsweise Trivialsumme,
ist also nichts anderes als ein Exklusiv-O-Oder von A und B. Carry wäre A und B,
nämlich wenn beide Eingänge 1 sind,
habe ich einen Übertrag in allen anderen Fällen nicht
Gut, jetzt kann ich damit natürlich nicht rechnen, weil das,
was ich hier gerade an der Tafel gemacht habe, nämlich dann,
also spätestens an der zweiten Stelle, brauche ich irgendwas,
wo ich dann also auf einmal drei Operanten addieren muss.
Dafür gibt es dann eben genau ein Volladdierer,
der dann eben letztendlich Summe und Übertrag aus zwei Eingangsbits und eben einem Eingangs-Carry berechnet. So,
auch das kann man jetzt hier einfach, Schaltalgage, aufschreiben,
die Funktionen dazu sich dann eben raussuchen und überlegen und das,
was man dann eben sieht, ist,
dass der Carrie letztendlich immer genau daran gesetzt wird,
wenn mindestens zwei Einsen vorhanden sind, nämlich genau die Fälle,
wo ich dann eben entsprechend meinen Ausgangs Carrie erzeugen kann.
Das heißt also hier, hier, hier und hier,
kann ich dann eben entsprechend hier einfach direkt jetzt rauslesen,
könnte jetzt noch beispielsweise irgendwie einmal so ein bisschen Klammerung rausziehen
und kriegt dann eben beispielsweise dann so einen Ausdruck,
aber kann auch letztendlich den nehmen.
Also das ist jetzt nur umgerechnet mit der guten Algebar.
Summe wäre exklusiv oder der drei Eingangsvariablen A,
B und Carrie
Gut, genau das kann man dann eben auch entsprechend einfach in Hades eingeben,
also ein Halbadierer, sind voll Adierer,
nicht wo dann in dem Fall jetzt also wirklich nur eins zu eins die Schaltalgebragenfunktionen,
also sprich diese Ausdrücke hier umgesetzt werden.
Gut, ja,
damit kann ich dann im Prinzip schon meine Addition von zwei Zahlen berechnen,
wie ich das jetzt also hier eigentlich gemacht habe,
dass ich eben sage,
ich habe meine Argumente A und B dann eben als Vektoren von 32 oder 64 Bild-Anzahlen zahlen.
Nicht gegebenenfalls habe ich dann eben noch einen entsprechend großen Vektor mit irgendwelchen Übertragswerten,
nicht weswegen ich dann spätestens ab der zweiten Stelle dann eigentlich volladdierer entsprechend brauche.
So, wenn man sich jetzt anguckt, wie dann die Berechnungen sind,
wie gesagt, für die einzelnen Summbits gilt,
dass die sich dann eben jeweils aus diesen drei Eingangsbits berechnen.
Wenn man sich den Übertrag ansieht,
dann sieht man das also an der Stelle für den Übertrag,
der so rumgesehen eigentlich Rekursiv definiert ist.
Das heißt also, an der niederwärtigsten Stelle habe ich jetzt nur die beiden Eingangsspits.
An der nächsten Stelle habe ich dann aber eben schon entsprechend den Ausdruck,
wo ich dann also hier die Eingangsspits und den Übertrag der vorherigen Stufe habe.
Und das Ganze zieht sich dann eben hier entsprechend immer ein weiter,
sodass ich eben generell sagen kann,
der Übertrag von Stufe N plus 1 ergibt sich dann eben
A-N und B-N. Nicht weil wenn beide Eingänge eins sind,
dann habe ich direkt einen Übertrag.
Ansonsten ist das Ganze dann eben vom Eingangs-Carry abhängig, wo ich dann eben sagen kann,
wenn der eins ist und A oder B noch an ist,
dann habe ich dann eben meinen Ausgangsübertrag.
So theoretisch kann ich damit jetzt natürlich so einen Adirer für 32 Bit-Wortbreite als zweistufige Schaltung realisieren. Nachteil ist,
da die Überträge hier rekursiv definiert sind,
beziehungsweise hier diese Überträge dann ja auch irgendwo mit eingehen,
würde das heißen, wenn ich jetzt also hier 32 Bit habe,
dass Also jetzt hier irgendwie ein Übertrag an einer höheren Stelle,
dann eben von auch sämtlichen Summenwitz der niedrigeren Stellen mit abhängt,
weil sich daraus dann ja eben auch die entsprechenden Überträge gegebenenfalls erzeugen lassen oder dazu führen,
dass dort Überträge entstehen.
Nicht das heißt, als zweistufige Lösung würde es heißen,
um eben zu entscheiden,
ob ich an dieser Stelle oder meinetwegen jetzt also hier einen weiter,
dieser Stelle hier einen Übertrag, also sprich den Ausgang hier habe,
müsste ich nicht nur diese beiden Witze betrachten,
sondern zusätzlich auch noch die und die und die,
weil die ja dazu führen können, dass wie in diesem Beispiel hier sind,
irgendwo weiter unten Übertrag entsteht und der sich dann also hier entsprechend durchrippelt.
So, das führt eben dazu, dass,
wenn ich das jetzt direkt in zweistufiger Logik aufbauen würde,
ich da also entsprechend viele Therme bräuchte,
was dann eben letztendlich also nicht mehr praktikabel ist,
nicht weil ihm genau diese rekursive Definition des Übertrags, mir das Ganze kaputt macht.
So, das, was man daran eben typischerweise hat,
was dann eben, sagen wir mal,
auch wenn man dann so ein bisschen das Problem ist bei der Addition ist,
ist eben das von niederwärtigeren Stellen, die Überträge, sich weiter oben irgendwo auswirken können.
So, und das führt dann eben dazu,
dass für solche arathmetischen Operationen, also beispielsweise die Addition,
ich das zum einen natürlich so machen kann,
wie das eigentlich hier angedeutet ist, wo ich dann also von der niederwärtigsten, zu den höheren Stellenern, quasi immer sukzessive weiterrechne. Das ist dann etwas,
was ich Ripple Carry Adira nennt,
wo sich dann eben sowas wie der Übertrag über die Stellen der Reihe nach dann durchrippelt oder durcharbeitet,
genau wie ich das jetzt eben hier an der Tafel entwickelt habe,
hat technisch gesehen den Vorteil, dass es eben vergleichsweise einfach ist,
hat praktisch gesehen den Nachteil, dass es dann eben sehr langsam ist,
weil ich Ob ich an dieser Stelle hier jetzt eine einzelne Null habe,
natürlich erst entscheiden kann, wenn hier dieser Übertrag berechnet wurde,
wenn dieser Übertrag fertig ist,
kann ich diesen Übertrag berechnen, wenn der fertig ist,
kann ich den berechnen und dann kann ich erst entscheiden,
habe ich hier einen Ausgangsübertrag und habe ich an dieser Stelle eine Null oder eine Eins.
Das ist eben genau dieses Durchrippeln von dem Übertrag
Das führt eben dazu, dass,
wenn ich jetzt den Rechner habe,
den jetzt mit einer bestimmten Tagfrequenz betreibe, diese Tagfrequenz,
wahrlich natürlich das alles erstmal abwarten muss.
Entsprechend niedrig ist. Nicht, das ist also das,
was hiermit gemeint ist. Es ist eben sehr langsam.
Und Lenea quasi mit der Größe der Wortbreite,
also sprich 32 Bit 64 Bit,
wird dann eben entsprechend die Frequenz oder Tagfrequenz
eben immer kleiner,
immer geringer
Das möchte man jetzt natürlich nicht haben in seiner Hardware.
Demzufolge gibt es dann eben auch noch andere Varianten, wie so eine Addition berechnet werden kann.
Dazu werde ich dann also hier nochmal im Prinzip oder zumindest von der Idee her noch zwei weitere Varianten vorstellen. Ansonsten,
wenn man in die Literatur guckt, muss man sagen,
dass es also grob gesehen, also ungefähr Eigentlich,
naja, also das sind inzwischen auch nicht mehr alle,
also irgendwie 15 verschiedene Adira-Typen gibt, weil wenn ich jetzt natürlich sage,
ich habe jetzt also mein High-Performance-Prozessor,
der soll möglichst schnell getaktet werden,
dann würde ich da so entsprechend viel Aufwand reinstecken,
damit ich solche Operationen wie also Additionen oder Subtraktionen von Zahlen,
die vergleichsweise häufig stattfinden, damit ich die also möglichst schnell machen kann.
Wenn ich sage, das Ding soll jetzt in irgendeinem Mikrocontroller sein,
der jetzt also hier, was weiß ich, in der Uhr läuft,
wo sich also vielleicht einmal in der Sekunde irgendwie was tut,
dann ist das egal, dann kann ich dafür eben langsam,
Adira, sowas wie so ein Rebel Carry Adira nehmen.
In dem Zufolge gibt es da so ganzen Variationen an unterschiedlichen Typen.
Wie gesagt, drei werde ich hier jetzt also mal kurz vorstellen,
also Rebel Carry und noch zwei andere. Ja,
nicht, dass man da einfach nochmal so ein bisschen sieht,
was also grob die Grundideen da zu sind. Gut,
ansonsten das Ganze im Prinzip dann zu den Adierern oder Adiernetzen bzw. zum Aufwaffen Alus,
dann am Freitag und für heute soll es das jetzt aber wirklich endlich mal gewesen sein.
Einen schönen Abend an allen