Gut. Letzte Woche hatte ich ja im Prinzip angefangen,
Minimierungsverfahren für Schaltfunktionen vorzustellen und da dann also auch diverse Beispiele mal so gezeigt oder durchgerechnet,
wo es also im Prinzip jetzt erstmal aufgrund den oder aufgrund der Rechnerregeln der Bulschen Algebra jetzt Minimierung gemacht wurde,
wo denke ich mir eigentlich schon relativ klar geworden ist,
dass das, sagen wir mal,
dann doch immer nicht so ganz trivial ist,
weil man dann eben wirklich erstmal sehen muss,
welche Therme kann ich irgendwie zusammenfassen,
wo kann ich da jetzt noch irgendwo
was machen
Und deswegen empfiehlt es sich dann eigentlich jetzt bei minimieren von Schaltfunktionen
dann eben als anderes Verfahren im Prinzip ein grafisches Verfahren zu nehmen.
Hatte ich auch schon ganz kurz eingeleitet, dass man da eigentlich was nimmt,
was im Prinzip auf KV-Diagramm aufbaut, die ich ja jetzt vor anderthalb Wochen, also schon mal kurz vorgestellt hatte.
Das ist ja so im Prinzip um einschrittige kurz ging. Und wie gesagt,
also hier noch mal kurz zur Erinnerung, also KV-Diagramme,
sind ja im Prinzip jetzt erstmal die Beschreibung,
wo ich grafisch, also zwardimensional, in diesem Fall jetzt,
dass ich hier mit 16 Feldern für die Möglichkeiten von vier Eingangsvariablen,
jetzt also hier irgendwo meine Werte eintragen kann und was dort dann eben interessant ist,
ist, dass letztendlich die Reihenfolge der Variablen beziehungsweise die stellende Variablen dann eben hier in so einem einschrittigen Code vorliegen,
was dann eben immer implizit dann auch heißt,
dass also zwei benachbarte Felder sich dann eben auch immer nur um einziges,
ein einziges Bit unterscheiden.
Das war dann, glaube ich, die letzte Folie,
die ich also dann am Freitag noch aufliegen hatte,
also hier nochmal so die gängigen KV-Diagramme für zwei bis vier Variablen,
wo man dann also im Prinzip auch immer mit diesen Beschreibungen,
beziehungsweise diesen Sortierungen der Variablen arbeiten sollte,
das gilt dann eben auch bezieht dann,
also für die Übungsaufgaben, also jetzt in dem neuen Übungszettel,
der offiziell heute und mit danach rauskommt, seit gestern,
also im Prinzip auf der Webseite, ist,
wird sowas dann eben beispielsweise entsprechend auch benötigt.
Gut, was erreiche ich jetzt eben mit diesem KV-Diagramm?
Wie gesagt, nachbarte Felder unterscheiden sich eben jetzt nur um ein einziges Bit.
In die KV-Diagramme kann ich dann eben die Werte Der Schaltfunktion,
nämlich die jeweiligen Stellen 0 und 1 eintragen,
beziehungsweise wenn die Schaltfunktion nicht vollständig spezifiziert ist,
Beispiele dazu folgenden auch heute noch.
Kann man dann eben noch so einen Stern für Don't Care-Werte
eintragen und benutzen. Und letztendlich ist so ein KV-Diagramm,
also nichts anderes als eine äquivalente Darstellung in der Funktionstabelle.
Gut, das, was man dort jetzt von den Größen
her typischerweise beschreibt, sind dann eben Diagramme von drei bis
maximal sechs Eingängen
Ich hatte für vier Eingänge wäre das. Dieses hier,
wenn ich fünf Eingänge bräuchte,
müsste ich dann zwei von diesen vier mal vier Diagrammen nehmen.
Für sechs Eingänge bräuchte ich dann vier von diesen Diagrammen.
Dann fängt das aber auch schon an, relativ unübersichtlich zu werden.
So, wie trägt man jetzt die Schaltfunktion ein?
Wenn ich jetzt so eine Schaltfunktion als Funktionstabelle habe,
habe ich ja im Prinzip,
also jetzt beispielsweise jetzt über zwei Eingangsfahrrigablen hier
meine entsprechenden Kombinationen für die Eingangsfahrrigablen
von 0,0 bis
Und hier dann eben die zugehörigen Funktionswerte.
Und was man dann eben hier entsprechend in die KV-Diagramme einträgt,
sind dann eben die Funktionswerte an den jeweiligen Stellen.
Das heißt, hier an der Stelle 0-0 dieser Funktionswerte wird demzufolge dann hier auch eingetragen.
Und hier das Ganze dann eben noch mal jetzt für ein Beispiel mit drei, eingangs variablen und dann eben dem entsprechenden KV-Diagramm. So,
wenn ich jetzt wirklich irgendwelche Funktionen nehme,
wo dann also irgendwelche Werte drinstehen, beispielsweise sowas,
würde das dann quasi, wenn man das jetzt überträgt,
so aussehen, dass ich dann eben sage,
beispielsweise diese eins hier ist eben der Funktionswert für X2 gleich null,
X1 gleich eins und X0 gleich eins und X2 gleich null,
ist hier die obere Zeile,
X1 gleich 1 und X0 gleich 1 habe ich jetzt eben hier an dieser dritten Stelle
Demzufolge ist diese eins quasi hieraus entsprechend eingetragen. Also wie gesagt,
wenn man das Prinzip verstanden hat, ist es eigentlich relativ einfach.
Es dreht Vorwart, beziehungsweise dann kann man einfach diese Tabelle
so der Reihe nach hier entsprechend eintragen. Das ASC,
wo man dann eben immer nur darauf achten muss,
ist halt eben beim Durchzielen hinsichtlich der Stellenwertigkeit,
dass sie dann eben im Erzähler 0-1,
2-3, also sprich, die Arme,
die sind Dreher drin,
habe.
Und das dann entsprechend dann immer berücksichtigen muss
Gut, hier ein Beispiel für, jetzt eine Charlotte Funktion,
die gegeben ist, durch die dissunktive Normalform mit Heatherm.
Das sollen jetzt hier diese vier Therme sein.
Wenn ich das Ganze jetzt eben hier in das KV-Diagramm eintrage,
erhalte ich dieses hier, indem ich dann eben einfach sage,
bei der disjunktiven Normalform beschreibe ich über die Mintherme die Eins stellen.
Das heißt, Jeder dieser Therme ist quasi mintern und sagt mir,
wo im KV Diagramm eine Eins drin steht.
Demzufolge würde ich jetzt hier einfach aus diesem ersten Therm herauslesen,
X3 nicht und X2 nicht und X1 nicht und X0 nicht.
Das heißt, extra leicht, 0, X2,
leicht, 0, X1, gleich 0 und X0 gleich 0.
Und das ist genau dieses erste Feld hier.
Das heißt, diese Eins entspricht oder ergibt sich aus diesem Menther
Anderes Beispiel, gehen wir hier hin, X3er gleich 1,
X war gleich null, X1 gleich 1, X-0 gleich null.
In diesem Intern und der entsprechende Wert oder die entsprechende 1 im KV-Diagramm ergibt sich eben dadurch,
dass ich dann einfach sage, X3 muss eins sein,
X2 muss null sein, X3 gleich 1,
X2 gleich null,
das ist also hier in dieser Zeile und die müssen beide eins sein,
das ist hier in dieser Spalte,
in demzufolge ist diese eins oder gibt sich diese eins eben aus diesem Intern?
Also wenn man das entsprechend weiß,
kann man eigentlich auch relativ schnell sowas direkt in das KV-Diagramm eintragen,
musste jetzt also nicht erst rumrechnen und quasi hieraus dann also
erstmal so was wie eine Funktionstabelle generieren, die man dann quasi einträgt.
So und was man jetzt macht für die Minimierung der Schaltfunktion ist,
dass man jetzt eben sagt, benachbarte Felder unterscheiden sich um einen Bit.
Wenn ich in zwei benachbarten Feldern jeweils eine Eins habe,
heißt das, dass die Funktion quasi an dieser Stelle oder an diesen beiden benachbarten Eins sind,
eben letztendlich nicht von der Variablen,
die sich eben entsprechend da jetzt unterscheidet, abhängt.
Demzufolge kann man dann also quasi so eine Schleife bilden,
das heißt also so ein Kreis um alles ziehen und hat die Funktion dann demzufolge zusammengefasst.
So, und das kann ich jetzt eben nicht nur für Zweierfelder machen,
also einmal zwei oder zweimal eins,
sondern ich kann das also auch für vier benachbarte Felder oder acht benachbarte Felder machen.
Das einzige, was gegeben sein muss, diese Gruppen sind logischerweise immer Zweierpotenzen.
Gut, gehen wir mal in das Beispiel,
dann wird das, denke ich mal, klarer.
Also diese ganz einfache Schaltfunktion war jetzt hier in dem Winter
oder in dem KV-Diagramm quasi dieses hier und dann kann man also relativ einfach sagen,
okay, hier habe ich zwei benachbarte Einsen,
bilde da diese grüne Schleife herum. Das entspricht letztendlich,
also hier diesen beiden Zeilen in der Funktionstabelle und die Minimierung ist dann eben letztendlich,
dass ich also quasi das Ergebnis unabhängig hier,
das ist das, was die Schleife eigentlich aussagt,
dass ich das Ergebnis hier unabhängig von X.0 habe.
Nicht weil die Eins habe ich sowohl, wenn X.0 gleich
Eins ist, als auch wenn X.0 gleich Null ist.
Das heißt, das Ergebnis Mainz kommt genau dann raus,
wenn X1, gleich 1 ist,
also macht diese Schaltfunktion nichts anderes als X1, einfach nur auszugeben.
Was man in diesem Fall dann auch relativ einfach natürlich jetzt
an der Funktionstabelle ablesen kann. Ich war also hier die erste Spalte,
ist genau das, was ja auch das Ergebnis ist.
Hier in der Schalfunktion in dem zweiten Beispiel,
jetzt mit drei Angangsvariablen,
würde ich dann eben letztendlich hier einmal hier rüber eine Zweierschleife
bilden,
einmal hier
über eine Zweierschleife
Wie man sieht, die Schleifen dürfen sich eben auch überlappen.
Letztendlich geht es immer nur darum,
dass man möglichst große Schleifen bildet und das eben auch gewährleistet ist,
dass diese Schleifenden also quasi jetzt immer aus solchen benachbarten Gruppen von zweieinhalb Potenzen bestehen.
Das heißt, ich kann jetzt hier nicht irgendwie so eine Dreierschleife bilden,
sondern nicht, also einmal mache ich das quasi über diese Schleife,
unabhängig von X.0.
Das ist nämlich die Variable, die sich hier unterscheidet.
Und hier mache ich
das Ganze unabhängig von
Das ist nämlich das, wovon sich das hier unterscheidet. So,
und dann kann ich entsprechend den Ausdrücken jetzt aus diesem Schleifen,
also quasi hier aus dem KV-Diagramm einfach ablesen,
die minimierte Funktion, indem ich eben sage,
wenn ich jetzt die grüne Schleife nehme,
X2 muss null sein und X1 muss eins sein,
das ist genau das, womit ich dieses hier beschreibe.
Also X2 nicht und X1. Die blaue Schleife,
Wäre jetzt unabhängig von X2. Dafür muss aber eben gegeben sein X1 gleich 1, X0
gleich 0. Was dann eben, genau, dieses ist,
also X1 und X0 nicht. Und das wäre dann eben
die entsprechende minimierte Schaltfunktion dazu. Gut, hier,
das Ganze jetzt eben noch mal für dieses Beispiel jetzt mit diesen Viererschleifen oder mit diesen Viereingangsvariablen,
wo dann eben hier auch zwei Schleifen gebildet werden.
Und was ich also damals auch schon bei der KV-Diagramm jetzt bei diesen einschrittigen kurz erläutert habe,
dass man sich das quasi im Außen herum verbunden vorstellen kann,
dass es eben hier in dieser grünen Schleife quasi angedeutet,
dass ich eben sage, diese beiden Einsen kann ich zusammenfassen.
Und demzufolge müsste ich dann, wenn ich das Ganze jetzt hier entsprechend ausdrücke,
dann eben sagen, ich muss einmal hier diese Zeile auswählen,
das heißt dann eben X3 nicht und X2 nicht.
Und ich muss dafür sorgen, dass X-0 gleich eins ist,
nee, X-0 gleich 0 ist,
also hier und hier ist das Ganze jetzt unabhängig von XR,
6-0 ist 0, also X-3 nicht,
X-2 nicht, X-0 nicht.
Das heißt, dieser Term entspricht dann eben der Grünen,
minimierten Schleife. Gut, das Ganze, wie gesagt,
in den Übungsaufgaben dann auch immer jeweils auf Papier oder sonstig irgendwie grafisch zu lösen.
Ansonsten gibt es also für sowas dann also auch immer so ein bisschen,
beziehungsweise teilweise findet man das also auch noch woanders im Netz, also irgendwelche Airplats, die das Ganze dann veranschaulichen. Eins davon ist von meinem Kollegen Norman Hendrik,
der zugesundes interaktiven Skripts da mal was gemacht hatte,
zu finden, quasi hier unter dieser Webadresse,
wobei ich dann also auch gleich sagen muss,
beziehungsweise line noch zwar Anmerkungen machen muss,
also zum einen diese Applets sind da teilweise schon ein bisschen älter,
das ist also alles noch aus der Zeit,
als man noch sehr euphorisch mit Ja war und Ja war Skript umgegangen ist,
inzwischen ist es so aufgrund der ganzen Sicherheitslücken,
ist die Policy bei den Plugins in den Browsern also deutlich restriktiver geworden und es hat mich also auch erstmal relativ viel Aufwand gekostet,
das Ganze überhaupt,
erstmal also hier irgendwie gleich mal zum Leben zu bringen,
weil also irgendwelche Policy CC-Einstellung von der Java-Engine,
also erstmal dafür gesorgt haben, dass diese App jetzt alle nicht starten,
weil die dann also nicht passend komplett durchsigniert sind.
Nicht, das heißt, aufgrund, dass ich Herzlücken wage,
kann sich dann natürlich die Tools dann,
also auch wenn das jetzt nicht aus vertrauenswürdiger Quelle stammt,
da jetzt also beliebige Programme auszuführen.
Nicht deswegen möchte ich nur darauf hinweisen, wenn sie das also ausprobieren,
was ja sicherlich auch gerne machen sollen. Also nicht wundern,
wenn es nicht klappt, sondern da muss man wirklich mal
so ein bisschen Suchmaschine bemühen und gucken, was man dort noch entsprechend einstellen muss, wie man das zum Leben kriegt. Ansonsten,
wie gesagt, also hier unter Quasi Startseite von Tarmstar,
also sprich vom Fachbereich aus, über die Arbeitsbereiche,
Daniels de Terms, dann slash Airplats,
dann finden sich also irgendwie so diverse Sachen,
unter anderem dann eben auch dieses KVD, KV-Diagramm-Editor,
nachdem ich das also nur mit expliziten Ausnahmeregeln und sonstigen versehen habe,
muss ich jetzt also nur noch sagen,
dass sie also irgendwie einmal bestätigen und dann gehen also entsprechend zwei Fenster auf,
die dann also hier auch noch mit irgendwelchen Warnhinweisen versehen sind,
wo das Ganze dann also letztendlich angezeigt ist.
So, und was man dann also hier im Prinzip sieht,
ist jetzt eben wirklich, also in diesen Phasen ein KV-Diagramm mit drei Eingangsvariablen,
jetzt also irgendwie eine zufällig gewählte Funktion.
Und jetzt kann ich, was hier unten dann,
kann man jetzt wieder nicht größer machen, sinnigerweise.
Nee, natürlich nicht. Also das, was hier unten an,
also im Prinzip dann also noch als Beschreibung dazu ist,
kann man darüber jetzt also hier entsprechend jetzt, also anfangen,
seine Schleifen zu bilden, hat hier dann quasi die Realisierung
Mit oder und Gattern und in Wärtern und je nachdem,
wie ich dann meine Schleifen bilde,
wird das Ganze dann entsprechend kleiner.
Was würde man jetzt hier in diesem Beispiel machen?
Um jetzt irgendwo Schleifen zu bilden,
vielleicht mal Frage an das Plenum
1. Alles klar, genau. Gut,
also das war jetzt im Prinzip also auch genau das,
was man also hier jetzt überhaupt nur entsprechend minimieren kann. Nicht,
das heißt also 3, also Zweiergruppen und je nachdem,
wie ich das dann also gemacht habe,
sah man dann eben auch,
dass also hier quasi die der Realisierung entsprechend vereinfacht wurde und man da dann eben seine Minimalösung hatte.
Ansonsten gilt jetzt hier nur, also bei diesen Schaltfunktionen,
wie gesagt, also ich könnte mir jetzt hier einfach irgendwie neue,
passend oder zufällig generieren lassen,
mit zwei Punkten,
Schaltform ist
ein bisschen zu einfach
So, das wäre jetzt, dass ich hier mit sechs Variablen,
sind vier mal vier Beispiel, nicht wo man dann also schon sieht,
hier wird es jetzt also nicht mehr ganz so einfach,
dass entsprechend zusammenzufassen,
nicht weil man dann eben teilweise auch wirklich schon gucken muss,
also habe ich hier zum Beispiel irgendwelche Sachen,
wo ich dann also meinetwegen sage, also irgendwelche Stellen,
die jetzt also beispielsweise jetzt ja in allen vier Zahlen mit drin sind,
das sehe ich jetzt zumindest hier in dem Fall jetzt nicht,
aber eben zum Beispiel sowas wie diese eins
Und diese Eins lassen sich hier dann eben zum Beispiel auch
schon mal zusammenfassen. Da sieht man, also da muss
man dann eben teilweise über diese PV-Diagramme noch rübergehen und so.
Also das ist da dann also schon nicht mehr ganz so einfach,
das entsprechend zu machen. Aber wie gesagt, also da
, so würde man da dann eben auch entsprechend weiterverfahren.
Hier nur noch mal der Hinweis für die Übungsaufgaben ist dieses
Applet allerdings nicht geeignet.
Wohlweislich, weil hier also
eine andere Variablenordnung drinsteckt
Das heißt, wenn man jetzt also
die Funktion für die Übungsaufgaben versucht, hier irgendwie einzutragen,
dann würde das nämlich alles irgendwie ganz anders aussehen.
Und die Übungsgruppenleiter würden sich nämlich also auch bedanken,
wenn sie das dann entsprechend korrigieren sollen.
Aber das ist eben nur als Beispiel,
wie das im Prinzip aussieht oder aussehen könnte,
was sich dahinter verbirgt und wie man eben letztendlich dann da
auch diese Minimierung mitmachen kann
Gut, ja, so viel, also wie gesagt,
erstmal hier zu diesem Applet, was man da entsprechend machen kann,
hier nochmal so ein paar Screenshots,
wo das Ganze dann eben auch nochmal visualisiert ist,
also falls man das jetzt also nicht hätte starten können,
also hier dann eben nochmal diese Beispiele,
wo man eben sieht,
nicht minimierte Funktion und dann eben,
wie das Ganze dann eben entsprechend den Schleifen bei
der Minimierung aussieht
Dann hatte ich ja auch schon gesagt, don't care terme. Damit ist eben ihn letztendlich gemeint,
dass wenn ich jetzt also nicht vollständig spezifizierte Schaltfunktionen habe,
also beispielsweise sowas wie ein BCD-Dekoda,
wo ich dann eben quasi mit vier Eingangsvariablen arbeite.
Damit kann ich dann ja die Ziffern 0 bis 9
und Hexer dezimal dann ja noch A bis 11 darstellen.
Jetzt soll das Ganze aber nur als Dezimalzahl dekodiert werden.
Das heißt also alles, was dann nach der Neuen kommt,
also sprich A bis F, werden eigentlich nicht weiter benutzt.
Das wäre dann so ein typisches Beispiel, wo man dann eben sagt,
okay, da kann ich jetzt eben für die Minimierung benutzen,
dass sich dann eben im KV-Diagramm an den entsprechenden Stellen an eben solche Don't Cash eintrage.
Und je nachdem, wie mir das dann wirklich am besten passt,
weil das ist ja ein Fall, wo ich erstmal sage,
der kommt in der Realität nicht vor oder er soll zumindest nicht vorkommen.
Und je nachdem, wie mir das dann am besten passt,
kann ich dann also für dieses Don't Cair sagen,
okay, wenn ich damit eine Schleife bilden kann,
wird das für mich eine Eins, dann packe ich das mit dazu,
wenn das jetzt nur irgendwo einzeln ist oder wenn mir das sonst nichts weitern wird,
dann ignoriere ich das,
dann wird das quasi von der Schaltfunktion her eine Null.
Man kann die dann eben wirklich benutzen,
um solche Schleifen dann eben möglichst groß zu machen. Hier,
also auch nochmal so ein Screenshot, wo sowas mit drin ist,
wo also hier beispielsweise hier um diese Eins zu realisieren,
eigentlich hier also eine entsprechend große Schleife gemacht wurde,
wo dann also letztendlich hier diese ganzen Lonecares jeweils noch mitbenutzt wurden.
Nicht das Ganze, aber eben wirklich deshalb,
weil wenn ich das als Schaltalgebranchen Ausdruck nehme und nur diese Eins beschreibe,
wäre die Eins dann eben letztendlich Inol und II nicht und
I2 nicht und I3 nicht und I4 und I5 nicht.
Nicht, das wäre jetzt also die Eins wirklich als mintern beschrieben.
Wenn ich jetzt diese gelbe Schleife nehme, würde ich dann eben sagen,
das Ganze ist I1 nicht und I3 nicht und I4.
Und das war's,
weil das ist dann eben wirklich unabhängig von Inol und I2 und I5.
Nicht deswegen lohnt es sich also auch für diese eine einzige eins,
dass ich hier im Prinzip diese Don't Cast mitzubenutzen.
Das ist dann, also ich erinnere mich genau,
dieser gelbe Term, wo ich dann sonst was entsprechend Größeres hatte.
Gut, damit bin ich jetzt eigentlich schon mit diesem Minimierung mit den KfVD-Rahmen durch.
Hier nur noch mal der Vollständigkeit halber. Ich hatte das also
nur mal kurz dem Namen nach angesprochen in der letzten Woche,
also Minimierung von Schaltnetzen, also aufgrund der Bulschen Argebar,
da gibt es dann eben so einen klassischen Algorithmus für den Herrn Quain,
McKlaski, der ist hier so ein bisschen kurz beschrieben,
beziehungsweise hier entsprechende Referenzen in die Literatur.
Da war das jetzt hier nicht weiter benutzen,
werde ich mir jetzt also keine zwei Minuten lang,
also irgendwie die Folie runterbrummen,
sondern dann gleich in das nächste Kapitel einsteigen,
wo es dann um Schaltnetze gehen wird.
Also, was sind Schaltnetze, Schaltnetze kann ich eigentlich sagen,
ist Erweiterung von Schaltfunktionen beziehungsweise letztendlich sowas wie ein Bündel von mehreren Schaltfunktionen.
Formal gesehen, kann ich sagen,
Schaltnetz beziehungsweise findet dann auch oft immer kombinatorische Schaltung beziehungsweise im
Englischen dann Combinational Logic Circled, ist eben ein System,
wo ich also irgendwie einen Eingangsvector aus in Eingängen habe und einen Ausgangswektor aus M
Ausgängen daraus berechne und der Wert dieses Ausgangs Vectors hängt eben wirklich
nur quasi wie in so einer Funktion von dem aktuellen Wert des Eingangs Vectors ab.
Deswegen hier diese Schreibweise, wo das dann quasi über so
eine Vector-Funktion beschrieben ist. Nicht in rein praktisch,
es ist also nichts anderes, als dass ich sage,
ich habe jetzt eben aus meinen 4-Eingangsvariablen nicht nur eine einzige Ausgangsvariable,
sondern gleich mehrere Ausgangsvariable,
das heißt also letztendlich ist in Schalten jetzt
nichts anderes als eine Ansammlung von mehreren Schaltfunktionen,
die alle die identische Eingänge benutzen
Wichtig dabei ist dann eben nur, dass das Ganze dann eben wirklich
nur von den aktuellen Werten der Angangsvarialen abhängt. Das heißt,
in den Beschreibungen in den Netzen dürfen dann keine Rückkopplungen auftreten,
was das dann nämlich zur Folge hat,
wird uns dann nämlich im nächsten Kapitel weiter beschäftigen,
wo es dann also um Schaltwerke bzw. um Automaten geht,
wo dann quasi diese Definition dann eben hier noch entsprechende Rückkopplungen
erweitert wird
Gut, das,
wo wir uns jetzt hier auch so ein bisschen bewegen,
ist so ein bisschen mehr an die technische Seite oder technische Realisierung von dem Ganzen dann also auch mit angeknüpft,
dem zufolge werden uns dann also auch relativ viele,
also solche grafischen Darstellungen in Formen von irgendwelchen Skelematics,
das heißt also solchen Schaltplänen begegnen,
ich deswegen da dann eben auch nochmal hier der Verweis dann eben wirklich,
was dann also mit diesem Begriff Schaltnetz häufig gemeint ist,
wo man dann eben wirklich schon eine konkrete technische Realisierung mit dahinter hat.
Typischerweise habe ich dann als eigentliche Funktionen oder Talfunktionen dahinter dann also relativ einfache Gata-Funktionen,
weil man da dann eben auch gleich an die technische Umsetzung letztendlich denkt.
Bei dem, was wir jetzt also hier als erstes betrachten,
geht es also jetzt erstmal noch nicht um irgendwelches Zeitverhalten von Entschaltungen,
sondern jetzt wirklich Im mathematischen Sinne einer Funktion, dass ich eben sage,
Eingangsvektor, ich berechne draußen, habe daraus einen Ausgangsvektor.
Rein praktisch, nachher in der Realisierung, wenn ich sage,
diese Funktion oder Funktionalität wird durch irgendwelche Bauelemente technisch umgesetzt.
Es ist natürlich so, dass diese Bauelemente nicht unendlich schnell schalten.
Das würde uns zwar freuen, weil die Computer dann also natürlich noch schneller wären,
sondern dass da dann eben eine gewisse Zeit immer noch vergeht.
Das heißt, wenn ich am Eingang der Schaltung sich irgendwo an Wert ändert,
dann dauert es eben eine gewisse Zeit,
bis am Ausgang dieser Wert dann also irgendwas zur Folge hat.
Nicht das ist das, was dann eben hier als Gatterlaufzeit beschrieben ist,
was wir dann also am Ende dieses Kapitels,
beziehungsweise wenn es dann nachher also auch um die Schaltwerke geht,
dann auch noch ein bisschen genauer betrachten werden.
Und das ist dann eben letztendlich auch der Grund,
warum man bei der technischen Realisierung jetzt in Computern eben sagen kann,
okay, ich habe eben bestimmte Taktraten oder Taktfrequenzen,
die ich einhalten muss, wo ich eben das System nicht übertakten kann,
beziehungsweise wo es dann eben anfängt,
nachher irgendwo rein technisch gesehen einfach falsch zu rechnen.
Davon abgesehen, dass ich dann also mit der Leistungsaufnahme und
daraus resultierenden Abwärme dann also auch noch massive Probleme bekomme,
nicht aber darauf rechnen, also teilweise auch nochmal kurz eingehen.
Gut, das, was uns jetzt hier erstmal begegnen wird,
sind also wirklich so ganz elementare, ganz einfache, digitale Schaltung.
Dazu würde ich ja so ein bisschen die Schalssymbole Grundgatta vorstellen.
Und dann eben wirklich ein paar einfache Beispiele von entsprechend klassischen,
einfachen Schaltnetzen beschreiben, beziehungsweise dann, wo war das denn schützenweise,
Freitag sein wird, dann noch auf atatmetische,
logische Operationen eingehen würde, wo es dann nämlich wirklich darum geht,
ganz am Anfang hatte ich ja Zahnsysteme erklärt,
wie rechnet man damit, wie funktioniert das Binärsystem,
was hat das also mit dieser Addition mit dem Zweierkompliment auf sich.
Jetzt hier wird uns das Ganze dann eben wirklich rein technisch begegnen,
wo wir dann eben wirklich sehen,
wie ich jetzt mit irgendwelchen technischen Bauelementen dafür sorgen kann,
dass also letztendlich sowas wie zwei, acht Bit oder zwei,
16 Bit Vektoren durch irgendein Schaltnetz durchlaufen und ich dann hinterher
sowas wie die Summe oder die Differenz zwischen beiden berechnet habe.
Gut, Schaltpläne oder im Englischen dann immer Skematics sind dann im Prinzip
sowas wie so eine Darstellung von Schaltung wie alles in Deutschland,
da natürlich also auch brav mit irgendwelchen genormten Symbolen versehen.
Das, was man dort dann hat,
sind natürlich jetzt also zum einen so was wie rein analoge Komponenten,
also Spannungsquellen, Stromquellen, Messgeräte, Schalter, Relais,
Widerstände, Kondensatoren, Schwulen, nicht lineare Elemente, die Unen und Transistoren.
Das wird uns hier glücklicherweise nicht weiter beschäftigen,
weil das war also früher mal in Rechnerstrukturen drin,
ist dann also Wunderbar rein, mathematisch,
was der Lösen von Differenzialgleichungssystemen und etwas, wo man als Informatiker sagt,
ja, was soll ich mit Strömen und Spannung,
ich will null oder eins haben und das war's.
Demzufolge werden wir uns also hier mit Gartern beschäftigen,
das heißt also quasi logischen Grundoperationen und oder nicht in solchen
einfachen Sachen und dann eben im nächsten Kapitel mit irgendwelchen Speichernelementen,
also Flip-Flops beziehungsweise Ledges.
Nicht, dann habe ich dann einen Charles-Plan typischerweise
noch irgendwelche Verbindungen
Anschlusspunkte und so weiter. Und das,
was man dann eben auch ganz dringend braucht, ist,
dass ich Möglichkeiten habe, Hierarchien zu beschreiben. Das heißt,
ich kann mir jetzt also aus irgendwelchen einfachen Bauelementen,
zum Beispiel sowas wie ein Einbit, Volladira zusammenbauen und kann sagen,
wenn ich jetzt ein 32-Bit-Adira mache, als Ribble Carry-Adira,
kann ich diesen einen Bit-Adira dann entsprechend oft instanzieren und als Komponente irgendwo weiter benutzen.
Das heißt, man setzt dort dann also was
wie so eine Hierarchie mit ein
Schalssymbole, hier so aus dem Buch von Schiff und Schmitz,
technische Informatik, rauskopiert und nur kurz veranschaulicht, also in der deutschen Diennorm,
sind das also hier immer diese relativ schmucklosen Symbole für und oder nicht exklusiv oder also eckige Gäste mit irgendeiner Beschriftung drin.
In Amerika haben sich dann eigentlich immer diese Symbole durchgesetzt,
das was ich meistens hier benutzen werde,
beziehungsweise was sie dann also auch in den praktischen Beispielen dann häufig mitbenutzen werden,
was sie also leider nur vorstellen werde,
sind dann also eher Symbole in der Art und Weise,
wo ich dann eben sage,
und Glied ist dann im Prinzip so beschrieben oder Glied,
etwas, wo dann also quasi diese Linie entsprechend durchgehen.
Negierung ist dann eben durch so einen dicke Zeichneten Punkt hier mit drin,
das heißt also, dieses wäre dann eben ein Nichtglied,
also ein Nordexklusiv oder ist dann eben hier durch so ein Äquivalenzzeichen durchgestrichen,
Äquivalenz, das heißt ein X-Nor, Wäre dann,
so war es und so weiter und so fort.
Gut, das war es jetzt hier mit diesen Schalssymbolen ja eigentlich
erst mal beschrieben wird, ist dann eben wirklich das,
was man dann also auch in der technischen Realisierung nachher mit drin hat,
nämlich ein logisches Gatter.
Das heißt eben irgendeine relativ einfache Funktion von einem bis typischerweise sechs Eingangsvariablen,
die dann eben sowas wie eine Negierung und oder nicht und
sowas entsprechend realisieren kann
Hier das Ganze dann dementsprechend aufgezählt. Wenn ich es damit
jetzt beliebige oder aus solchen Gattern beziehungsweise aus solchen Sachen jetzt eben jetzt wirklich meine Schaltfunktion,
beziehungsweise meine Schaltnetze aufbauen möchte, brauche ich,
jetzt kommen wir also auf die mathematische Grundlage dazu, dann eben eine vollständige Basismenge.
Das ist also genau das, was da immer mit drin war,
wenn man sagt, na gut,
also was brauche ich dann eben jetzt wirklich für die technische Realisierung,
wenn ich jetzt also Funktionen in GF2 ausdrücken muss,
das war dann eben entweder sowas wie Und exklusiv oder und eins oder,
und, oder nicht oder nennt oder nor.
Das ist eben das, was dann hier mit mindestens allen Gatter bezeichnet ist.
Dann hier auch noch noch mal der Verweis,
das hatte ich auch schon mal kurz gesagt.
Im Prinzip diese Gatter mit den Invertierungen am Ausgang.
Das heißt also jetzt nicht End und Ohr, also und,
und, oder, sondern typischerweise nennt und nor werden eigentlich technisch genommen,
weil bei dem, was heutzutage eigentlich halblader Technologie ist,
also Zielmausschaltungstechnik, beziehungsweise generell Mois-Schaltungstechnik funktioniert immer so,
dass die Ausgänge letztendlich invertiert werden.
Gut, um damit jetzt also irgendwelche Schaltungen, Schaltnetze aufzubauen,
hat man dann eben klassischerweise jetzt also irgendwelche Werkzeuge,
um das quasi grafisch darzustellen und gleichzeitig eben auch noch mit zu simulieren.
Das heißt, sowas wie ein Schaltplan Editor und ein Schaltplan Simulator,
wo man dann eben dadurch dann wirklich so ein vergleichsweise spielerischen Zugang dazu gewinnen kann.
Und eben auch direkt letztendlich sieht, welche Werte sich wie jetzt irgendwie auswirken.
Dazu gibt es viele verschiedene Ansätze, Systeme teilweise,
natürlich, wenn man jetzt also wirklich in professionellen Chip-Schaltungsentwurf geht,
dann also irgendwelche unendlich teuren und unendlich großen Pakete, mit denen man arbeiten kann,
aber eben auch aus dem Open-Source bzw. Public-Domain-Sektor findet sich da einiges.
Ein vergleichsweise älteres Tool ist die Sticklock,
was der Herr Lazaro Aus Berkeley in den 90er Jahren,
oder an, ja,
Anfang 90er Jahre entwickelt hat und eben von Norman Hendrich,
also hier dieses Hades,
auf das ich jetzt also hier auch immer verweise,
was dann teilweise auch in den Übungen benutzt werden soll und was ich jetzt also auch gleich nochmal ein bisschen genauer vorstellen werde,
beziehungsweise sämtliche Beispiele dieses Kapitels,
beziehungsweise dann auch des nächsten Kapitels,
sind dann also auch entsprechend in Hades verfügbar,
beziehungsweise da dann sogar auch
schon komplett fertig
Ursprünglich ist die Idee von dem Hades eigentlich gewesen.
Also auch da die Demos im Webbrowser laufen zu lassen.
Problem hatte ich ja eben schon angesprochen. Das heißt also
hier findet sich dann unter anderem eben auch sowas wie hier dieses Hades,
wo ich dann also hier quasi auf dieser Startseite lande.
Und hier drunter ist jetzt also relativ viel,
unter anderem eben auch so ein Download-Bereich, wo sehr viele, sehr unterschiedliche Beispiele beschrieben werden.
Das Ganze also wirklich mit einer vorbildlichen Dokumentation,
wo dann eben auch alles Mögliche beschrieben ist und das Ganze dann eben vorhin,
sagen wir mal, wirklich sehr einfachen Beispielen,
also sprich irgendwelchen Schalennetzen, wie das,
was ich jetzt hier noch vorstellen will,
dann also wirklich bis zu irgendwelchen kleinen Prozessoren,
wo man dann also im Prinzip sowas wie einen 32-Bit-Mips-Prozesse
oder 16-Bit-Peak-Controller dann eben auch dort als Simulationsmodell hat,
beziehungsweise das dann eben auch wirklich in so einer Simulationsumgebung
benutzen und programmieren kann
Gut. Das, womit wir uns jetzt hier eher beschäftigen werden, ist etwas,
was dann also hier in dem Bereich der einfachen Sachen ist.
Also wie gesagt, hier über diesen Browser habe ich jetzt hier sehr viele unterschiedlich,
also wie gesagt, von ganz einfachen Gardern,
dann wirklich bis zu kleinen Prozessoren, sehr viele sehr unterschiedliche Sachen.
Also hier ist das Ganze jetzt textuell beschrieben. Hiermit kommt
man halt mal jeweils auf die jeweilige Seite als Applet,
dann gibt es noch die Möglichkeit, dann so eine Art Webstart zu machen,
wo das Ganze dann also quasi runtergeladen, lokal gestartet wird.
Und wie gesagt, bei Applet landet man da so bei etwas,
wo dann hier auch wieder so eine Sicherheitswarnung aufgeht.
Genau, und das ist jetzt eben hier genau der Effekt,
den man hat, wenn man diese Seite nicht explizit jetzt also schon irgendwo als Ausnahmeregel eingetragen hat. So,
und da man das jetzt also hier nicht bei unbedingt 60 Seiten und 60 verschiedenen Beispielen machen möchte,
habe mich ja, ich mir also am Wochenende erlaubt,
die ganzen Beispiele schon mal so weit zusammen zu glauben,
dass wir dazu im Prinzip auf der Seite jetzt von der Vorlesung,
wenn ich also hier bei den Rechnerstrukturen und der Unterlagen,
findet sich also hier Kapitel 11 und dann hadesrs.zip,
wo dann das eigentliche Programm ist,
das heißt also der Schaltplan Editor,
Simulator, alles, was da dazu gehört.
Und auch eben sämtliche Beispiele, die ich dann eben hier
im Rahmen der Vorlesung dann eben auch entsprechend mit vorstellen werde.
Zusammengesammelt sind. Das heißt, das können sich dann eben entsprechend runterladen,
auspacken und damit arbeiten. Das ist auch das,
was sie jetzt immer hier für die Vorführung benutzen werde.
Und gut, sagen wir mal, noch mal Hendrik,
weil damit ist es auch nicht ganz so glücklich, aber wie gesagt,
für den privaten Gebrauchen innerhalb der Vorlesung ist das also vertretbar,
dass ich das dann also hier entsprechend mal so gemacht und also auf die Webseiten dann gestellt habe.
So, wenn man das jetzt macht, auspackt,
erhält man dann also quasi hier immer so einen kompletten Baum,
wo dann also alle möglichen Beispiele von diesem Introbeispielen bis zu mehreren größeren,
komplizierteren Sachen beschrieben ist,
hier unter Dokumentationen gibt es dann eben noch ein auch etwas längeres Tutorial,
wo das dann alles nochmal beschrieben ist, eine Referenzkarte,
wie man mit dem Tal dann noch entsprechend umgehen kann und so weiter und so fort.
Das heißt, da ist das dann also auch entsprechend alles soweit nochmal mit beschrieben.
Ansonsten sieht die Herangehensweise so aus, also wie gesagt,
schießt sie auf den nächsten Folien, wird das nochmal kurz vorgestellt,
aber ich denke, das ist jetzt einfach schlau,
wenn ich das einfach mal direkt live zeige.
Das heißt, man würde sich jetzt also dieses HDSRS-Zip runterladen,
auspacken, hat dann also quasi so einen ganzen Baum,
wo das alles ist.
Sollte logischerweise dann eben auch unabhängig vom Betriebssystem sein. Ich muss
nur eben passende, passende Strava überhaupt erstmal installiert haben. Und okay,
also hier bei dem heiß geliebten Linux sieht das dann eben so aus,
dass sich dann also letztendlich hier so das Verzeichnis gehe,
wo das Ganze also rumliegt.
Das heißt, im Prinzip, also in dieses Verzeichnis,
wo ich jetzt hier diese Dateien habe und unter anderem dann
eben auch die Sardestra und gestartet wird das dann eben über Java Strah.
Ades. So, und dann hat man anschließend,
zack, ein Fenster skaliert hier irgendwie immer in einem,
bei dem Monitor nicht so ganz schön
Machen wir jetzt mal von Hand. So,
dann hat man also hier ein Fenster,
wo ich dann, also hier letztendlich erstmal nichts anderes habe,
als so eine Zeichenfläche,
nöchtern hier so das übliche Fall Open Edit und so weiter und so fort.
Und was man dann eben macht,
womit das Ganze dann eben auch veranschaulicht wird, ist,
wenn ich dann also quasi hier irgendwelche Hades-Beispiele reinladen würde.
Also fangen wir mal einfach an.
Intro, Welcome,
erstes Welcome, so und was man hier jetzt sieht,
ist also so ein bisschen Text rundherum,
der jetzt also hier noch zusätzlich mit reingezeichnet wurde und dann eben hier so eine,
in diesem Fall jetzt sehr einfache Schaltung,
wo also hier also irgendwie so ein Teil anscheinend sowas macht,
wie so eine periodisches Taktsignal.
Man sieht hier auch schon das,
wird dann also auch noch irgendwie hier entsprechend visualisiert dargestellt
Und ich habe dann also hier irgendeinen Baustein, der,
was weiß ich, was macht und dann sowas wie eine sieben Segmentansage,
die mir also hier anscheinend irgendwie dann immer von 0 bis F durchzählt.
Und da sieht man eben schon, wie das Ganze dann aussieht und funktioniert. Also wie gesagt,
Grundidee ist, dass ich mir hier irgendwelche Komponenten nehme,
hier quasi auf meiner Fläche dann als Skematic platziere, mit Leitung,
miteinander verbinde Gleichzeitig, das sieht man hier unten dann immer schon,
läuft eben für das Ganze dann auch immer schon eine Simulation mit.
Das heißt, ich kann dann eben entweder interaktiv oder in diesem Fall,
wo das hier automatisch wie so ein Taktgenerator hin und her wackelt,
dann eben sehen, was sich da entsprechend tut.
So, nehmen wir ein, wie gesagt, hier gibt es dann also entsprechend viele Beispiele,
wo man also beschrieben ist, welcome, tool Chips,
Tim Control, Also Simulationen kann ich hier unten mit den Tasten beeinflussen.
Zurzeit läuft das Ding einfach automatisch. Nicht hiermit könnte ich das Ganze entsprechend anhalten. Habe jetzt hier also irgendeine bestimmte Zeit,
kann hier das dann wieder weiterlaufen lassen oder eben die Zeit zurücksetzen,
wobei das, was jetzt also hier an Zeit beschrieben ist,
also er zählt jetzt immer irgendwie in einer fiktiven Zeiteinheit,
beispielsweise sind das jetzt also irgendwie sowas wie Nanosekunden,
wird jetzt natürlich nur interessant,
wenn ich dann eben auch wirklich was habe,
wo ich mit simulierter Zeit arbeite,
was sie ja eben schon gesagt hatte,
im Prinzip bei einfachen oder normalen Gattern wird uns das erstmal nicht weiter begegnen.
Nicht, weil man kann das dann eben auch nehmen,
um dann eben solche Zeiteffekte auch mit zu simulieren.
Gut, nehmen wir mal ein anderes, einfaches Beispiel,
um sozusagen, was dann eigentlich schon machbar ist,
beziehungsweise wie man
den Simulator bedient
So, hier habe ich jetzt also die allereinfachsten Gatter,
die man sich so vorstellen kann, nämlich ein sogenannter Buffer.
Das heißt, ein Eingang wird eins zu eins auf den Ausgang durchgeleitet,
ein Inverter, ein unten mit zwei Eingängen,
ein Ent mit zwei Eingängen oder mit zwei Eingängen oder Normit zwei Eingängen.
Und was jetzt hier, das sind dann eben diese Götter,
gleich mit dran ist, sind dann eben irgendwelche Eingangspins,
die ich dann eben interaktiv,
indem ich da einfach draufklicke mit der linken Maustaste, schalten kann.
Und was ich dann eben auch schon sehe,
das Ganze nennt sich dann in der Hades-Terminologie Glow-Mode,
das quasi entsprechend den Werten, die dort dran liegen,
nämlich eine Null ist grau dargestellt.
Eine Eins ist rot dargestellt,
ich dann also quasi wirklich entsprechend in der Simulation schon sehe,
was ich tut, also sprich bei mir.
Und Gatta, nicht beide Eingänge sind eins, der Ausgang ist eins.
Und wenn ich jetzt so sich ein, da Eingänge wechsel,
geht der Ausgang auf null und eben nur in diesem einen einzigen Fall,
wenn beide eins sind, ist der Ausgang auch entsprechend da eins.
Gut, das ist jetzt nichts anderes als dann
eben grafische Darstellung und Simulator von dem Ganzen. So,
und damit kann man jetzt eben wirklich Selarea sehr schön einfach seine Schaltung aufbauen.
Dazu habe ich dann also hier diverse Bibliotheken,
unter anderem zur Verfügung oder am einfachsten könnte ich das jetzt machen,
indem ich also zum Beispiel jetzt hier irgendwo die rechte Maustaste drücke, dann kriegt man so einen Kontext, sensitives Menü. Ja,
dann könnte ich zum Beispiel sagen, Create, IO,
Epen, den habe ich jetzt also quasi hier dranhängen,
setz den irgendwo hin und habe dann nämlich einfach hier so einen zusätzlichen Eingangskomponente,
habe, könnt jetzt hiervon, wenn ich mehrere bräuchte,
Noch, die also auch noch alle irgendwo hierhin platzieren,
wenn ich jetzt fertig bin,
würde ich dann eben entsprechend entweder Escape drücken oder eben mit der Rechtmaus,
dass irgendwie was anderes machen in diesem Fall,
wo wir also hier als IO ein Open,
das ist nämlich quasi dieses Tal, hier das Äquivalent dazu,
irgendwo hinsetzen.
Dann könnte ich jetzt also irgendeine Gatterfunktion Also beispielsweise ein X-Or
mit zwei Eingängen nehmen, hierhin platzieren.
Da liegt jetzt hier natürlich was anderes drüber.
Das ist dumm. Was macht man jetzt? Also Move
. Und dann kann ich das Element, weiß ich,
also hier drunter befahren, dann auch irgendwo anders hinverschieben.
So, und dann kann ich genauso eben auch hier mit
Wire Connect dann eben solche Leitungen ziehen
Könnt ihr jetzt also hier quasi dieses XOR mit den Eingängen und dem Ausgang verbinden.
So, was man jetzt hier noch sieht,
hier habe ich immer irgendwie grau, null, rot,
1, jetzt ist hier irgendwie so ein Zian,
was soll das jetzt sein?
Also wenn man sich dann die Hades-Doku anguckt,
man dann feststellen, das steht für noch nicht initialisiert.
Damit habe ich noch nichts weiter gemacht. Wenn ich jetzt also hier quasi einmal draufklicke,
könnte ich jetzt also hier immer auch wirklich definierte Werte,
nämlich 0 und 1, immer hin und her torgeln.
Und jedes Mal, wenn ich also irgendwo mit der linken Maustaste drauf drücke,
kriege ich den jeweiligen anderen Wert und dieses Zieren noch nicht initialisiert,
habe ich eben wirklich nur ganz am Anfang.
Dadurch sieht man dann eben auch sehr schön,
ob was richtig funktioniert. Das Ganze gilt eben genauso
auch für die Leitung
Und jetzt hätte ich hierbei zwei definierten Werten. 0 x or 0 ist null,
wenn einer oder genau einer von den beiden eins ist,
habe ich im Ausgang eine eins, wenn beide eins sind,
habe ich im Ausgang eine null.
Wenn ich das jetzt hier quasi andersrum mache, habe ich auch wieder eine eins.
Und Hurra, das Ganze verhält sich also wie ein X or.
So, was man hierbei auch noch mit hat,
ist, ich kann hier dann also noch Wie gesagt,
also wenn man sich dann die Doku von dem Hades anguckt,
dann also noch relativ viel einstellen.
Hab, wenn ich also jetzt hier bei so einem Element bin,
rechte Maus taste, kann ich mit Move Corpy irgendwie was machen.
Ich kann dem Namen geben, ich kann das logischerweise auch wieder löschen.
Ich und man kann damit dann eben an den Elementen irgendwie was machen.
Hier gibt es dann noch sowas wie so ein Edit.
Damit kann man jetzt bestimmte Eigenschaften einstellen. Instanzenname,
in der Regel wird er automatisch vergeben.
Dann gibt es ja so eine Art Delay
Das ist erstmal voreingestellt, nicht, aber ich konnte jetzt
hier zum Beispiel sagen, zwei Sekunden. Okay,
so und wenn ich jetzt, dass ich an dem Gatta was schalte,
wunderbar funktioniert nicht, oder ich hatte, nee genau,
ich habe hier den erwischt,
dann hat der jetzt nämlich hier also quasi eine Verzögerung von
zwei Sekunden,
bis der Ausgang sich entsprechend ändert
Gut, damit kann man jetzt quasi mit diesem grafischen Editor
seine Schalssymbole also irgendwie zusammenbauen, verbinden, irgendwie größere Schaltungen draus bauen.
Hat neben dem, was hier also quasi an irgendwelchen Gattern
ist, also auch noch deutlich mehr Elemente.
Ich habe hier unter View die Möglichkeit,
einen sogenannten Komponentenbrowser aufzumachen
Und hier unter Bild-In in diesem Fall Hades, Models,
habe ich jetzt, also hier diverse Modelle,
die also auch schon deutlich über das hinausgehen,
was sie also jetzt in diesem Kontext sensitiven Menü hier mit der rechten Maustaste erreichen kann.
Das heißt, da hat man jetzt also diverse Flip-Flops,
Gatta, irgendwelche anderen Sachen, die vielleicht für was anderes
später irgendwann mal benötigt werden, letztendlich zur Verfügung.
Also wie gesagt, das ist eigentlich eine Sache,
wo man mit entsprechend viel Spiel Freude und Spielwerter dann eigentlich
schon relativ schnell zu Streich, kommt da dann alles rausfindet.
Gut, für die Simulation, wie man hier sieht,
das läuft hier immer irgendwie im Hintergrund, kann ich jetzt natürlich,
also immer hier irgendwie so ein bisschen interaktiv hin und her schalten.
Jetzt möchte ich vielleicht sehen, wie sich irgendwas zeitlich verhält.
Auch da gibt es dann die Möglichkeit zu sagen,
dass ich hier, und das war falsch,
wo man den hier mal kurz nehmen und Move erstmal irgendwo hin,
wo ich da so ein bisschen so,
wenn ich jetzt hier irgendwo auf die Leitung gehe.
Gut, also da ist es nicht,
dann findet sich das Ganze unter Singles at Probes.
Da kann ich jetzt eben zu irgendwelchen Leitungen oder zu irgendwelchen
Ein- und Ausganggängen sogenannte Probes setzen. Das heißt,
also die werden dann quasi über die simulierte Zeit mit protokolliert.
Und ich kann mir das Ganze dann in Form eines Impulsdiagramms ansehen.
Das ist dann eben das, was dann hier als Waves
gemeint ist. So, jetzt will ich versuchen,
das hier für das... Achso, hier war Swire.
Gut, also... Oh ja,
Dann geht also hier so ein Fenster von Impulsdiagramm auf.
Ich habe hier dann quasi dieses Label N18 dranhängen,
was jetzt also deswegen in 18 heißt, weil das erstmal automatisch durchnummeriert wird.
Wenn ich jetzt sinnigerweise hier irgendwelchen Ein- und Ausgängen schon einen Namen gegeben hätte,
was hier rüber geht,
dann würde das nämlich nicht zwingend Ende 16,
sondern meinetwegen A heißen, A ist,
glaube ich,
schon irgendwo anders vergeben,
gleich mal gucken
So, nennen wir die jetzt hier mal A und B,
anschließend, sage ich hier, Ad Probe, auch Ad Probe und So,
die habe ich jetzt alle hier in meinem Impulsdiagramm.
Wie man sieht, ist, dass hier alles noch irgendwie undefiniert.
Also wollen wir jetzt mal hier kurz die Simulation anhalten,
zurücksetzen, neu laufen lassen. So,
und jetzt möchte ich hier mal irgendwie mal was machen,
wo sich dann also am Ausgang ein bisschen was tut.
Anschließend Update Waves machen. Und dann sieht man hier nämlich schon,
wie das, was ich jetzt eben hier von Hant gemacht habe,
dass sie nämlich A und B irgendwie umgeschaltet habe und sich dann demzufolge dann auch irgendwo an den Ausgängen,
an dem Ausgang, der also hier immer noch N18 heißt,
was getan hat, wie man das dann also wirklich so im zeitlichen Verlauf in Form seines Impuls, die er Rahmens sieht.
Das heißt, damit kann man dann eben auch sehr schön wirklich
irgendwelche Schaltungen simulieren und eben wirklich gucken, was sich damit tut.
Und dies Tool oder dieses Werkzeug,
also das Hades wird dann eben teilweise jetzt ja eben auch in den Übungsaufgaben dann Ja,
zum übernächsten Mal, beziehungsweise dann, ja,
ich denke mal, an die nächsten Aufgabenzettel entsprechend mit eingesetzt werden.
Gut, achso, dann könnte ich hier nochmal leben lassen.
Ja, das jetzt hier erstmal zur Vorstellung dazu.
Also jetzt hier, wie gesagt, auf den nächsten Folien
das Ganze nochmal kurz beschrieben. Ich habe hier dann auch
immer jeweils hier noch als entsprechenden Link das Ganze auf die Webseiten verlinkt.
Ansonsten Gates 00 Gates ist das eigentlich genau der Fahrt,
der dann auf die und dort dann eben basic,
der dann eben auf das entsprecht, den entsprechenden Hadesentwurf zeigt.
Nicht, das war hier zum Beispiel genau dieses Beispiel,
was sich hier eben gerade eingeladen und vorgeführt,
beziehungsweise da mit dem zusätzlichen Gatter gleich noch verhunzt hatte.
Ne, und wie gesagt,
damit hat man dann eben erstmal die einfachen Ein- und Ausgänge,
Taktgeneratoren, Sowas wie so ein Power-On-Reset-Anzeigen,
sieben Segmentanzeigen und so weiter und so fort.
Blow-Mode hatte ich eben auch schon kurz beschrieben. Also man kann
es generell ein- und ausschalten. Ansonsten habe ich ihm hier
meine beiden logischen Werte, die es zieren eben für Annon. Das,
was hier jetzt noch als Tree-State-Z bzw. Andy Find X beschrieben ist,
sind jetzt also Sachen, die wir dann später noch sehen werden,
wo es dann nämlich darum geht, zu sagen,
wie werden technisch gesehen Bussysteme realisiert,
weil dafür genügt mir null und eins nämlich nicht,
sondern da brauche ich noch was anderes.
Da hat man dann eben sogenannte Tree-State, Gatter dann mit drin,
die einem dann sowas einschalten können und was man dann häufig in der Simulation auch noch gerne hat oder haben möchte,
ist etwas, wo ich also sowas wie einen ungültigen Wert anzeigen lassen kann, sowas wie einen Kurzschluss.
So, und jetzt können wir gleich sehen,
das ist eigentlich immer das Schöne bei Hades,
man kann das Ganze hier natürlich alles wunderbar live vorführen,
indem ich dann also beispielsweise sage, okay,
ich nehme jetzt hier noch irgendwie so einen zusätzlichen Eingangspin Musik Ah,
das ist ein wunderbarer Vorführeffekt, den man sieht, aber eigentlich wollte ich jetzt nämlich das Ganze hier nochmal mit irgendwas annahmen, unsinnig zusammenschließen. So,
irgendwie geht es dann ja doch,
also auch wenn das jetzt bestimmt nicht so schön ist,
so und wenn ich jetzt also hier Im Prinzip jetzt also irgendwo dann eben so einen Kurzschluss erzeuge,
indem ich also hier den Ausgang,
also hier eigentlich mit diesem Eingang verbinde, nicht,
dann sieht man, dass also hier dann schon ein falscher Wert rauskommt,
wobei das jetzt eigentlich hier ein undefiniert ist,
war es nun nicht sein sollte,
sondern eigentlich müsste dann also was wie ein X rauskommen,
aber gut, das wird mir morgen bestimmt der Kollege Henrichter nochmal erklären,
wo da jetzt der Denkfehler ist,
aber im Prinzip sieht man da dann eben auch schon,
dass dann eben auch solche Fehler oder solche anderen Zustände damit dann also quasi Also eigentlich müsste dann also hier Magenta so einen Kurzschluss bei rauskommen,
aber dass man dann eben sieht, okay,
da können dann eben auch entsprechend andere Sachen damit auftreten.
Gut, ja, das im Glow-Mode, Bedienung,
wie gesagt, das Ganze einfach immer viel ausprobieren,
beziehungsweise da gibt es dann eben ja auch noch entsprechende Kurzreferenzen,
Tutorials,
Beschreibung und so weiter
Da sieht man eigentlich entsprechend, wie das funktioniert. Gut,
die grundsätzlichen Funktionen, also hier einfach nur erstmal da rein nach aufgelistet,
da habe ich im Prinzip so einfache Gatter-Buffer,
ist im Prinzip also einfach nur sowas wie ein Verstärker.
Da sagt man jetzt, na gut, was soll das Ding?
Ich gebe eine Eins rein, da kommt eine Eins raus,
ich gebe eine Null rein, da kommt eine Null raus,
nicht von der Bulschen All gebracht, das ist also irgendwie keinerlei Funktion.
Auch das ist jetzt eigentlich wieder eine Technologie geschuldet,
weil irgendwo später in der Halbleiter-Technologie,
wenn das Ganze wirklich also jetzt irgendwo in Silizium auf dem Ship realisiert wird,
funktionieren dann halt eben viele Sachen nicht so,
wie uns das jetzt die Buchschalgebra sagt,
sondern da kommen dann doch nur gewisse elektrische Randbedingungen mit hinzu und eine von diesen elektrischen Randbedingungen ist eben zum Beispiel,
dass wenn ich jetzt den Ausgang von irgendeinem Gatter nehme,
also meinetwegen ist das irgendein Nantgatter und diesen Ausgang
Weil das ist jetzt also was, was ich,
mein Taktsignal, was ich also an 50 anderen Stellen brauche,
irgendwo auf 50 Eingänge schalte,
dann würde die Schaltung eben rein elektrisch nicht mehr funktionieren,
weil dann musste ich nämlich wirklich gucken, was passiert dort.
Also jetzt nicht im Sinne von 0 und 1,
sondern was passiert dort mit Strömen und Spannung.
Das führt dann also letztendlich dazu,
dass ich dann eben auch nicht mehr das sehe,
was wir also hier im Impulsdiagramm immer sehen wollen,
also irgendwie sind idealisiertes 0 und 1,
nicht sondern rein praktisch
Geht das hier natürlich nicht in unendlich kurzer Zeit,
senkrecht nach oben, sondern rein praktisch wird das dann eben so aussehen,
dass es hier also irgendwie anfällt und hier dann also irgendwie runtergeht.
Je mehr Ausgänge oder nein, je mehr Eingänge ich quasi jetzt an einem Ausgang habe,
umso flacher werden diese Flanken. So und irgendwann,
wenn ich jetzt also wirklich diesen Fall habe,
wie ich das gerade eben beschrieben habe und ich habe den Ausgang eines Gatters,
da hängen da 50 Eingänge dran,
dann geht das also letztendlich so langsam hoch,
wenn ich dann aber hier eigentlich schon wieder umschalte,
dann wird dieser Wert dann eben hier eigentlich nicht mal als eins interpretiert.
Sondern dann muss ich eben wirklich sagen, okay,
das sind Null Volt, das sind zweieinhalb Volt.
Hier habe ich also noch nicht mal anderthalb Volt erreicht.
Das ist für mich dann nie eine eins gewesen und
deswegen macht die ganze Schaltung keinen Sinn. So,
und so ein Buffer ist eben etwas,
was man dann quasi an so einen Ausgang klemmen kann,
um dafür zu sorgen,
dass quasi der Wert entsprechend verstärkt wird und man dann also quasi so eine ganze Kaskade
Von... Von solchen Treibern dahinter setzt,
wo das dann also quasi jetzt nicht von einem Ausgang meinetwegen auf fünf,
dann auf 25 und so weiter, eben entsprechend einfach quasi vervielfacht wird.
Und ich damit dann dafür sorgen kann,
dass ich eben solche Situationen vermeide
Gut, in Wärter und nennt or North ist eigentlich klar.
Und selbsterklärend, deswegen bin ich ihn also gar nicht weiter.
Wie zeigen. Und Gatter mit zwei Eingängen oder Gatter
mit zwei Eingängen. Hier sieht man auch nochmal rein praktisch
das, was also diese Morgenregel ist.
Nicht, wo ich dann eben sagen kann, in der
Buhl schon Algebra. Nicht, was war das noch?
Also, wir haben hier und Gatter. A und B.
Nicht und Äquivalent
soll das Ganze sein
Das ist eben das, was diesen Regeln von der Morgen sagt.
Ich nehme das Ganze, eine Giers zweimal, wenn ich
das Pharma legiere, hat sie ja in der Funktion nichts geändert.
Nach dem Morgen kann ich dann eben auch sagen, okay,
ich habe hier außen meine erste Regierung und diesen Inneren,
diesen Ausdruck hier, setze ich dann eben um als A nicht oder B nicht und das Ganze dann wieder negiert.
Das ist also letztendlich das, was hiermit die Eingänge negieren
und den Ausgang negieren und aus dem Unten oder machen.
Das ist also das, was hier Bulsche-Algebar ist,
dort dann also als Schaltfunktion beschrieben. Gut, dann,
End- und Nantgarda mit 1, 2, 3, 4 Eingängen.
Wie gesagt, findet man dann alles dort über dieses kontextsensitive
Menü in der Bibliothek. Dann eben auch eine Sache,
ich hatte eben schon gesagt,
also beliebig viele Ausgänge sind technisch eigentlich nicht machbar,
also hier dem Hades selber macht das erstmal nichts
Das stört es nicht, weil das ist ja so
ein Simulator quasi auf Logik-Ebene und nicht auf elektrischer Ebene,
was hiermit noch mal kurz beschrieben ist, ist auch eine andere Sache,
die eigentlich wieder aus der technischen Realisierung herauskommt.
Wenn ich also beispielsweise ein Gatter habe, was sehr viele
Eingänge benötigt. Also beispielsweise ein Endgatter mit zwölf Eingängen.
Nicht, dann ist das in der bulischen Arge war einfach
hingeschrieben als Ausdruck
Technisch gesehen wird man das aber nie finden,
weil es, sagen wir mal,
in der Art der Schaltungstechnik bei C-Mausschaltung eben auch so ist,
dass man typischerweise bei den Gattern also vier bis maximal sechs Eingänge eigentlich nur spendiert,
weil wenn das mehr werden, würde das Gatter zwar funktionieren,
es würde aber so viel langsamer werden,
dass es effizienter ist, eigentlich sowas zu machen wie hier,
wo ich dann also quasi sage,
also so ein und Gatter mit zwölf Eingängen erzeuge ich mir dadurch,
dass ich hier also quasi das Ganze kaskadiere,
indem ich also hier eins mit vier Gattern habe und dann hier noch vier und Gatter mit jeweils drei Eingängen und quasi über diese zweistufige Schaltung das Ganze dann eben realisiere,
nicht beziehungsweise man kann das dann eben auch noch entsprechend der Butschen Algebar dann auch nochmal umsetzen,
nicht also rein technisch würde,
uns in Semos Schaltungstechnik dann eben auch eher sowas aus nennt und Norga dann begegnen,
aber eben auch das,
wie gesagt, also nur vor diesem Hintergrund,
dass man das also elektrotechnisch eigentlich jetzt nicht macht.
Gut, dann, oder Gatter, Norgatter, wie gesagt,
da ist nichts anderes. Hier auch nochmal ein Hinweis,
das findet man dann also auch bei dem Hades, wenn man also guckt nach Gattern, da begegnen uns dann also auch diese sogenannten Komplexgatter. Hier dann also auch die jeweiligen Chart-Elemente,
typischerweise sowas wie A-O-I and or in Word and mit zwei Eingängen und das Oder noch mit einem zusätzlichen Eingang ist,
also das ist jetzt hier die Thermoniologie,
die Norman hier gewählt hat, die entsprechend auch dem,
was man also häufig in technischen Zellbibliotheken findet,
nicht, wo man dann sieht,
also hier sind jetzt also auf einmal irgendwelche Gatter benutzt,
die in der Bullschen Algeba eigentlich so ein zweistufiger Ausdruck sind,
wo ich dann eben wirklich sage, okay,
hier dieses End-or-in-Word ist ja eben erstmal nichts anderes als,
dass ich sage, A, und B,
oder C,
und über das Ganze eine Negierung mache.
Das ist das, was also hier
dieses Gatter ist
So, ähm, für uns, vor allem mit der
bullschen Argebar eigentlich rechnen, ist das also irgendwie was Zweistufiges?
Komisch, kompliziert. Technisch gesehen, muss man sagen,
sind solche Komplexgatter genauso einfach oder genauso kompliziert wie jedes andere Gatter mit eurer Eingänge.
Das heißt also, dieses Gatter hier benötigt in SEM-Ausschaltungstechnik sechs Transistoren,
ein nennt Guarda mit drei Eingängen benötigt, auch sechs Transistoren.
Ein Norgat hat da mit drei Eingängen auch.
Deswegen findet man eben häufig in solchen Sale-Bibliotheken,
die dann also wirklich später dann auch auf die technische Realisierung abzielen,
beziehungsweise in dem,
was dann also auch hier in Hades drin ist und auch hier simuliert werden kann.
Solche Komplex-Gatta, wo dann eben solche zweistufigen Sachen letztendlich
mit drin sind. Das ist dann eben auch wieder über
die technische Realisierung
letztendlich motiviert
Gut, dann habe ich hier so die üblichen Sachen,
X, or X, Nore, also wie gesagt,
das ist eigentlich von den Schaltfunktionen, von allem,
was sie da kennen, also letztendlich alles nichts Neues,
also hier dann Beispiel, jetzt um mal zu sehen,
okay, wo hatten wir sowas überhaupt schon mal so rein praktisch,
mit den Gattern oder mit diesen Schaltfunktionen, Parität,
das war ja genau quasi gerade oder ungerade Parität,
indem ich dann also eben gucke, gerade oder ungerade Anzahl von Einsen,
wird eben Schaltalke Brage durch eine exklusiv- oder Verknüpfung gemacht,
beziehungsweise dann eben hier so als Vierbitt-Parität,
indem ich dann eben beispielsweise hier mit diesen drei X-Orgattern hier
die Eingänge nehme und dann eben quasi darüber das Ganze bilde.
Kurzzeitgedächtnis, Parity
Wo ich also hier das Ganze jetzt habe,
wenn ich jetzt hier eine einzige Eins anhabe,
diesen Fall jetzt hier,
gerade Parität, ist der Ausgang auch eins,
wenn ich jetzt hier noch irgendwo eine zweite mache,
ist der Ausgang dann wieder null.
Wenn ich jetzt eine dritte dazu einschalte, wieder eins.
Das heißt, das ist dann eben letztendlich
genau die Paritätsfunktion
Gut, hier jetzt als 4-Bit-Parität in dem nächsten Beispiel dann quasi als 8-Bit-Parität.
Ich also ein bisschen größer, wo ich dann also quasi hier Eingänge,
die 0 bis BD7 habe, darüber dann eben über so eine kaskadierte Lösung, eine Parität bereichnet.
Zusätzlich habe ich dann hier auch noch welche, kann sagen,
entweder ist es eine 10-Bit-Parität oder ich benutze diese Eingänge,
nicht deswegen ist das Ganze hier dann so überhaupt so aufgebaut,
dass ich sage,
könnt ihr jetzt eben nicht nur hier über 8-Bit,
sondern ich könnte jetzt auch eine Parität über 16 oder über 32 mitbilden,
indem ich jetzt mehrere von denen wieder kaskadiere und den Ausgang dann quasi hier über so ein,
dieses C dann eben in die nächste Stufe weiterführe.
Und ich kann auch beispielsweise dann eben hier mit diesem Eingang,
deswegen heißt er hier auch Ott, letztendlich umschalten,
ob ich sage gerade oder ungerade Parität,
nicht weil wenn der null ist,
würde ich eben eine gerade Parität berechnen,
wenn der eins ist,
würde ich
nur um gerade Parität berechnen
Damit kann man dann also so relativ universelle Schaltungen aufbauen und realisieren.
Eine andere Schaltung, die wir auch schon kennengelernt haben,
oder die ich schon mal kurz erwähnt hatte, Multiplexer,
also wirklich so ein Umschalter zwischen zwei Dateneingängen.
Das heißt, ich habe im Steuereingang zwar ein Gänge A1
und A0 in einen Ausgang Y,
als Schaltfunktion in der Funktionstabelle wäre das Ganze letztendlich so beschrieben.
Umgangsschwaachlich gesagt kann ich eben sagen, wenn S1 gleich 1 ist,
wird A1 zum Ausgang durchgeschaltet,
wenn es gleich 0 ist,
wird A0
zum Ausgang durchgeschaltet
Das ist das, was also multiplexer macht. Was man häufig dann auch findet,
um das also auch nochmal so ein bisschen mit Don't Cast zu motivieren,
ist eine etwas kompaktere Darstellung, indem ich da dann eben beispielsweise sage,
wenn es gleich null, ist es egal,
was A hat, oder A1 hat, nicht A-0,
null landet hier, A-1-1 landet hier,
beziehungsweise wenn ich dann also hier sowieso auch Variablen zulasse,
Dann sehe ich eben direkt die Funktion bei S gleich null,
wird A0 am Ausgang,
bei S gleich 1 wird A1 im Ausgang angelegt.
Gut, das Ganze kann man dann eben nicht nur als 2 zu 1,
sondern als N zu 1, Multiplexer machen,
wo ich sage, ich habe N-Dateneingänge, um die zu unterscheiden,
brauche ich quasi das Obergrenze, also Lorrath musst du alles,
N, Steuereingänge, Nicht, das heißt also,
mit drei Steuereingängen könnte ich dann eben bis zu acht Dateneingängen unterscheiden.
Hier in dem Beispiel mit zwei Steuereingängen,
S1 und S0 kann ich dann eben vier Fälle unterscheiden,
habe dann also hier meine vier Dateneingänge und sie dann eben hier entsprechend die Funktion.
Nicht und das Ganze wird dann eben auch hier entsprechend mit und Negation und oder Gatter realisiert,
beziehungsweise was man häufig findet,
ist dann eigentlich diese Umschaltfunktionalität in so einem grafischen Symbol,
wo ich dann eben wirklich sage,
abhängig von dieser Select-Leitung wird entweder der Eingang,
der hier mit eins bezeichnet ist, zum Ausgang durchgeschaltet oder der,
der hier mit null bezeichnet ist.
Damit hat man dann eben genau diese Auswahlverfahren.
Gut, auch das könnte man dann eben hier entsprechend
mit Hades simulieren
Wie gesagt, das bleibt dann eigentlich eben selbst überlassen,
das mal schnell auszuprobieren. Das Gegenteil von dem Ganzen ist ein Demultiplexer.
Ist quasi jetzt ein Schalter, wo ich dann sage,
ich habe einen Eingang oder ein Schaltnetz,
was also dafür sorgt,
ich habe einen Eingang,
habe dann eben in Ausgänge und abhängig von der Dekodierung hier
wird eben dieser einen Eingang auf einen
von den N-Ausgängen geschaltet
Nicht, also auch das ist so ein Bauelement, was man,
wenn man dann also jetzt in irgendwelchen technischen Realisierungen ist,
dann eben relativ häufig benötigt, also wohl multiplexer als auch Demultiplexer,
um jetzt eben dafür zu sorgen, dass,
wenn ich jetzt also beispielsweise nachher wirklich technisch gesehen,
also hier irgendwie sowas, wie eine Alu habe,
wo ich dann also jetzt hier irgendeinen Eingangsboss,
irgendeinen Ausgangsbus habe, zu sagen,
entweder Die Leitung soll hier drauf geschaltet werden oder eine andere Leitung oder irgendwas anderes,
soll da eben quasi hier auf diesen Eingang geschaltet werden.
Und an der Stelle hat man dann eben typischerweise irgendeinen Multiplexer,
um eben auszuwählen, was dort da dann draufgehen soll.
Gut, die Funktion oder Funktionalität, denke ich mal, ist dann soweit eigentlich klar. Deswegen verzichte ich jetzt hier mal,
also irgendwie auf irgendwelche Hadersvorführungen, ich denke mal,
das können sie dann entsprechend selber relativ einfach machen,
also hier das Ganze nochmal das Acht-Bild-Multiplexer,
dann auch wir in so einer typischen integrierten Schaltung, das,
was man also sagen wir mal so bis in die 70er,
80er Jahre hatte, um also irgendwelche logischen Elemente aufzubauen,
dann drin hatte, hier das Ganze dann eben nochmal als Demultiplexer und wie gesagt,
das kann man dann eben entsprechend simulieren.
Abschließend, hier jetzt vielleicht auch nochmal sieht man,
also wofür braucht man solche Demultiplexer,
typisch frischerweise eben zum Beispiel einfach als Adressdekoda,
ist hier dann eben auch noch mal
kurz in der Hades-Demo
Nicht, wo ich,
also jetzt hier auch ein hartes und Eingabeelement habe,
wo ich ja jetzt quasi die Hexerdezimale live hiermit umschalten kann,
also sprich von 0 bis 16,
habe hier jetzt also irgendeinen Eingang.
Das ist dann eben schon so angedeutet für so
einen kleinen Ship.
Dahinter verbirgt sich dann
eben diese Multiplexer-Funktion
Und hier meine Kontrolleingänge, die dann eben aus diesem Teil kommen,
wo ich dann eben Hexerdezima ist, die Werte von null bis F eingeben kann.
Und das, was dann eben hier an den Ausgängen passiert,
dass ich dann eben hier von X0 oder Y0 bis Y15,
16 Ausgänge habe und dann eben hier sehe,
wie mein Eingang, der jetzt hier null ist,
hier jetzt auf X0 geschaltet ist.
Und wenn ich das Ganze dann eben hier entsprechend weiter durchschalte,
Ähm... Auf eins, auf zwei,
auf drei und so weiter, sieht man dann eben,
wie das dann eben auf den jeweiligen Ausgang durchgeschaltet wird.
Das ist eben etwas, was, sondern beispielsweise auch braucht,
um in Speicher jetzt irgendwelche Adressen zu unterscheiden.
Da ist dann eben letztendlich genau auch so eine Multiplexer oder Demultiplexer-Funktion
dann letztendlich mit drin. Gut, damit mit dem Beispiel Exit,
jetzt also Schluss für heute und am Freitag geht es dann,
dass hiermit Hades in den Beispielen weiter