Und wir bekommen S6 über den oberen Eingang der ALU.
Auf der anderen Seite haben wir diesen Offset hier zur Adressierung.
Das ist normalerweise ein 16-Bit-Vorzeichen behaftetes Offset.
Wird auf 32-Bit erweitert.
Und der sollte jetzt eigentlich an den zweiten Eingang der ALU, damit
die ALU in dem Fall die Adresse, also die Ladeadresse bestimmt.
Und man sieht hier, dass wir an diesem zweiten Eingang von der ALU, am
zweiten Eingang von der ALU, auf der einen Seite ein Registerinhalt
hier an den Eingang durchschalten sollen und auf der anderen Seite bei
einem Ladebefehl
den erweiterten Offset durchschalten wollen.
Und wie macht man das?
Das macht man mit Hilfe von einem Multiplexer.
Das heißt, das ist ein Multiplexer, der hat zwei Eingänge.
Einmal der Eingang aus dem Registersatz, einmal der Eingang aus dieser
Vorzeichenerweiterungseinheit.
Und mit Hilfe von einem einzigen Steuersignal, das ist die ALU-Quelle,
also woher bekommt die ALU ihre Information, können wir festlegen, ob
jetzt tatsächlich bei einem R-Befehl der Registerinhalt hier auf dem
zweiten Eingang der ALU durchgeschaltet werden muss oder ob dieser
Offset auf dem Eingang der ALU durchgeschaltet wird.
Wir wissen ja aus der DLX-Pipeline, dass die Sache auch weitergeht,
dass wir in dem einen Fall ein Ergebnis rechnen.
Bei einem arithmetischen Befehl berechnen wir das Ergebnis und
schreiben das Ergebnis zurück in den Registersatz.
Oder bei einem Ladebefehl berechnen wir die Adresse und das Datum
dieser Adresse wird ja geladen in das Register S4.
Das heißt, man sieht hier auch auf die gleiche Art und Weise, dass wir
am Ausgang hier die gleiche Situation haben.
Also wir müssen entweder S4 hier schreiben oder wir müssen S0
beschreiben in der Write-Back-Phase von der DLX-Pipeline.
Und um dies zu entscheiden, haben wir einen Multiplexer am Ausgang
hier.
Zwei Eingänge, einen einzigen Steuereingang, der heißt MEM2-Register.
Und je nachdem, ob das 0 und 1, wie das hier intern implementiert ist,
interessiert uns an der Stelle nicht, wird entschieden, ob jetzt das
geladene Datum in S4 geschrieben wird oder ob das Ergebnis der
Addition von S1 und S2 in S0 geschrieben wird.
Das heißt, es ist jetzt kein Baustein, den wir einfach einführen, weil
wir so lustig sind, sondern wir sehen hier einen ganz konkreten
Anwendungsfall, wo diese Bausteine verwendet werden.
So, also nochmal hier animiert.
Auf der einen Seite der Eingang und der Eingang hier, die müssen auf
den gleichen Eingang der ALU, deshalb der Multiplexer hier.
Und auf der anderen Seite der Ausgang hier bei dem LADI-Befehl bzw.
das Ergebnis einer Addition muss auch irgendwie auf den Registersatz
hier, auf diesen Write Data Eingang zugreifen und deshalb dort dieser
Multiplexer.
Man sieht also, mithilfe von diesem Multiplexer kann man den
Signalfluss steuern auf eine wunderbare Art und Weise.
Und jetzt wissen wir, dass dieser Multiplexer nichts anderes ist als
ein Schaltnetz.
Der hat Eingangssignale, der hat Steuersignale, der hat aber nur einen
einzigen Ausgang.
Worum es hier aber in der Vorlesung geht, wir wollen gucken, wie
können wir mit diesen Bausteinen welche Funktionen realisieren.
Bei den Und, Oder und Negationsbausteine oder Inverter wissen wir, wir
haben eine destruktive Normalform, wir haben eine Minimalform und wir
müssen Produktthermie oder Summenthermie bilden und miteinander
verknüpfen.
Und die Frage ist, wie kann man jetzt Multiplexer nutzen, nicht nur
zur Steuerung von Datenflüssen, wie wir gerade gesehen haben, sondern
zur Realisierung von Buhlschirmfunktionen.
Und mithilfe von diesen Multiplexern, also zum Beispiel mithilfe von
einem 2 hoch N zu 1 Multiplexer kann man eine logische Funktion mit N
plus 1 Variablen realisieren.
Und wie das Ganze funktioniert, will ich im Folgenden zeigen, und zwar
mithilfe einer sogenannten Implementierungstabelle.
Das ist nur eine andere Darstellungsform für die Funktionstabelle
einer Funktion, wie ich gleich zeigen will.
Und wie diese Implementierungstabelle aufgebaut ist, steht hier auf
der Folie.
Die brauchen wir nicht unbedingt zu lesen, aber die Folie hat mehrere
Spalten.
Zwei Hochendspalten für alle möglichen Belegungen der Steuereingänge
und zwei Zeilen für die negierte und nicht negierte N plus 1 Variable
der Funktion.
Und in dieser Tabelle tragen wir dann die Funktionswerte in
Abhängigkeit von den Steuervariablen.
Und dann ordnen wir jede Spalte oder betrachten wir jede Spalte für
sich und wir ordnen ihr eine einstellige Funktion, die entweder die
Konstante 0 ist, die Konstante 1, oder die N plus 1 Variable, also Xn,
beziehungsweise ihre Negation zu.
Das klingt ziemlich kompliziert hier, aber wir wollen es anhand von
einem Beispiel sehen.
Gegeben sei eine Funktion von drei Eingangsvariablen C, B und A und
wir wollen diese Funktion hier mit Hilfe von einem Multiplexer
realisieren.
Das heißt, wir gucken unsere Implementierungstabelle.
Wir wollen, dass die Variablen C und B unsere Steuervariablen sind.
Also wir wollen zwei Steuervariablen haben.
Das heißt, wir wollen das Ganze mit Hilfe von einem 4 zu 1 Multiplexer
realisieren.
Und was man macht hier in dieser Tabelle, das sind die Steuervariablen
C und B.
Das sind alle möglichen Belegungen der Steuervariablen 00, 01, 10 und
11.
Und die dritte Variable, die keine Steuervariable ist, die ist hier
angegeben.
Einmal A ist gleich 0 und einmal B ist gleich 1.
Und das ist unsere einstellige Funktion, die wir jetzt bestimmen
anhand von den Belegungen, die wir hier haben.
Das heißt, was man hier hin macht, man muss gucken, welchen Wert...
Wenn wir jetzt eine Funktion mit vier Eingangsvariablen haben, müssen
wir natürlich hier C, B oder D, C, B schreiben oben.
Und dann haben wir acht Belegungen dieser Steuervariablen.
Und da realisieren wir die Funktion beispielsweise mit einem 8 zu 1
Multiplexer.
Also keine Beschränkung der Allgemeinheit hier, dass wir das anhand
von einem Beispiel mit drei Eingangsvariablen betrachten.
Was wir jetzt feststellen müssen ist, welchen Wert hat die Funktion F,
wenn die Steuervariablen C und B 0,0 sind und wenn A 0 ist.
Wenn C 0 ist, dann sehen wir, der erste Term ist 0, der zweite Term
ist 0 und wenn B auch gleich 0, der dritte Term ist auch 0.
Das heißt, unabhängig von A haben wir eine 0.
Das habe ich gerade gesehen, unabhängig von A hat die Funktion bei der
Belegung 0,0, Belegung C, B gleich 0,0, den Wert 0, also das heißt
hier auch 0.
Das heißt, die einstellige Funktion G ist nichts anderes als die
konstante Funktion 0.
Wenn die Belegungen der Steuervariablen C und B 0,0 sind, dann hat die
Funktion den Wert 0.
Im zweiten Fall, wenn C gleich 0 und B gleich 1, C gleich 0, sieht
man, der Term verschwindet hier unabhängig von A.
Wenn C gleich 0, sehen wir, dass der Term hier AB wird, der dritte
Term ist A und B.
Wenn also B gleich 0,
dann ist der gesamte Term 0.
Das heißt, wenn C gleich 0, verschwindet der erste Term und der zweite
Term, es bleibt der dritte und der dritte wird zu AB.
B ist gleich 1, dann ist es nichts anderes als 0, wenn A gleich 0 und
1, wenn A gleich 1.
Also insgesamt nichts anderes als A.
Man sieht also, die einstellige Funktion hier in dem Fall ist die
nicht negierte dritte Variable A.
So, wenn C gleich 1 und B gleich 0, dann verschwindet der Term hier, C
gleich 1, B gleich 0, das heißt, der zweite Term wird zu 1 und somit
ist die Funktion 1 unabhängig von A.
Was bedeutet das?
Das bedeutet, die einstellige Funktion G ist in dem Fall 1, unabhängig
davon, ob A gleich 0 oder A gleich 1 ist.
So, wenn C und B gleich 1 sind, dann haben wir hier A quer, dann haben
wir hier B quer.
Der Term verschwindet, weil B quer C und B ist gleich 1, dann ist es
0.
Der Term hier ist dann in dem Fall 0, weil C ist 1, also C quer ist 0.
Das heißt eigentlich, das Ganze hängt von dem hier ab.
Also, wenn C gleich 1 und A gleich 0, dann wissen wir, das ist dann
eine 1.
Und wenn C gleich 1 und wenn A gleich 1, das heißt A quer gleich 0,
dann ist die Funktion 0.
Und man sieht, wenn man die vierte Spalte hier betrachtet, dass die
einstellige Funktion G nichts anderes als A quer ist.
Also, wenn A gleich 0, dann hat die Funktion den Wert 1, wenn A gleich
1, dann hat die Funktion den Wert 0.
Was bedeutet das eigentlich?
Das bedeutet auf der einen Seite, wir haben uns oder in dem Beispiel
wollen wir jetzt die Realisierung dieser Funktion mithilfe von einem
Multiplexer mit zwei Steuervariablen.
Die haben wir festgelegt, das sind C und B.
Also, das ist 0, das ist 1, C ist und B.
Also, das ist ein 4 zu 1 Mux.
Und wir haben hier vier Eingänge in dem Fall.
Und die vier Eingänge, die bezeichnen wir mit 0, 1, 2, 3 und das ist
hier unsere Funktion F.
Und was wir hier jetzt gerade gesucht haben, anhand von unserer
Implementierungstabelle, ist, wie müssen wir diese Eingänge hier
beschalten, damit die Funktion F realisiert wird, wenn B und C die
Steuervariablen von dem Multiplexer sind.
Und das ist genau, was wir bekommen haben.
Die Funktion G gibt uns die Antwort, wie wir die Eingänge von diesem
Multiplexer beschalten müssen.
Das heißt, wenn wir das Ganze hier mal ein bisschen betrachten, das
ist nochmal das Gleiche von oben, das 4 zu 1 Multiplexer wird auch mit
dem Symbol G, das ist also diese Steuervariablen, die Steuern, die
geht, die mit 0 bis 3 gekennzeichnet sind, diese Eingänge.
Und wir sehen, wenn C und B 0 0 sind, dann ist es der 0.
Der Eingang, der muss dort an die 0 anliegen.
Wenn am ersten Eingang, also B gleich 1 und C gleich 0, muss ein A
anliegen.
Wenn C gleich 1 und B gleich 0, also am zweiten Eingang eine 1 und am
dritten Eingang eine A quer.
Somit haben wir diese Funktion, die oben zu sehen ist, wenn man die
realisieren will, da braucht man hier ein und, ein und und ein und,
also dreimal und und ein oder mit drei Eingängen.
Zwei und mit zwei Eingängen, ein und mit drei Eingängen.
Und da können wir das Ganze halt mit Hilfe von diesem komplexeren
Baustein, den sogenannten Multiplexer hier beschreiben.
So, wie bei allen anderen Themen dieser Vorlesung, es geht nicht nur
darum, dass wir Schaltungen entwerfen, sondern wir wollen ja
Schaltungen analysieren.
Das heißt, jetzt haben wir im Beispiel gesehen, wie wir eine Funktion
mit Hilfe von einem Multiplexer realisieren.
Die Frage ist, wie kann man jetzt hier, wenn man sowas vorgegeben hat,
die Funktion ablesen.
Und diese Funktion abzulesen, das ist natürlich auch einfach, wenn man
die charakteristische Gleichung von einem Multiplexer kennt.
Das heißt, die Funktion hier, die hängt von den Variablen C, B und A.
Und wir wissen, zunächst mal, das ist der 0.
Eingang, C quer, B quer wird mit 0 multipliziert.
Oder C quer, B, das ist der Eingang 1.
Das ist konjunktiv verknüpft mit A, mit dem was am Eingang 1 anliegt.
Oder das ist C, B quer, also der zweite Eingang, konjunktiv verknüpft
mit 1.
Oder C, B, also wobei die Steuervariablen nicht negiert auftauchen,
und das Ganze konjunktiv verknüpft mit A quer.
Das heißt, wenn man das Ganze hier auswertet, dann sieht man, dass die
Funktion ist C quer, B, A.
Oder C, B quer.
Oder C, B, A quer.
So, gut, jetzt ein zweites Beispiel, bzw.
die Realisierung dieser Funktion mit anderen Steuervariablen.
Das ist sehr willkürlich, welche Variablen der Funktion als
Steuervariablen selektiert werden.
Und hier sehen wir das Beispiel für B und A als Steuervariablen.
Dann ist natürlich C die dritte Variable, die Funktion G, die
einstellige Funktion G, die zu jeder Belegung der Eingangsvariablen
hier einen Wert hat.
Sehen wir, das ist immer identisch C und in der letzten Spalte C quer.
Das heißt, die gleiche Funktion kann man auf die Art und Weise
realisieren, wo die ersten drei Eingänge oder an den ersten drei
Eingängen C anliegt und am vierten Eingang hier von der Multiplexer C
quer.
Die gleiche Vorgehensweise.
Und das ist diese Implementierungstabelle, die wir hier sehen, das ist
eigentlich nichts anderes als eine andere Darstellung für die
Funktionstabelle.
Das heißt, wenn wir jetzt hier die Funktionstabelle mal für diese
Funktion eingeben, F und das sind die Variablen C, B, A.
Das kennen wir alles.
So, dann wissen wir, wenn C gleich 0, also diese Funktionstabelle
können wir natürlich aus dem Ausdruck hier herleiten.
In den ersten vier Fällen C gleich 0 verschwinden die ersten zwei
Terme und dann bleibt A, B und wir sehen A, B, das heißt nur in dem
Fall hat die Funktion den Wert A.
Der dritte Term, dann bleibt A quer oder B quer.
Das heißt, wenn einer von denen 0 ist, das heißt 1, 1, 1, 0.
Das ist ja die Funktionstabelle und wenn man das Ganze hier mal
versucht zu übertragen, sieht man in der Tabelle B und A 0 0 und C 0,
dann hat die Funktion den Wert 0.
Wenn B und A gleich 0, 1 hat 0, also bleiben wir zunächst mal in der
Zeile hier, C gleich 0, B, A gleich 0, 0 ist 0, 0, 1 ist 0, 1, 0 ist 0
und 1, 1 ist 1.
Und wenn C gleich 1 ist, sehen wir, dass die Funktion 1, 1, 1, 0 hat,
also 1, 1, 1, 0.
Das heißt, das ist ja nichts Neues oder nichts Besonderes, sondern
eine andere Darstellungsform der Funktionstabelle der Funktion F.
So, jetzt kurz mal auf die charakteristische Gleichung eines
Multiplexer, weil wie wir sehen, können wir mithilfe von diesem
Multiplexer anscheinend Funktionen realisieren.
Die Frage ist, wie kann man so ein Multiplexer, letztendlich müssen
wir so ein Multiplexer aus MOS-Transistoren, am besten aus CMOS
-Technologie realisieren, also aus UND-GATA oder GATA-INVERTER usw.
Das heißt, wie kann man das machen?
Dazu betrachtet man die charakteristische Gleichung von einem
Multiplexer, die können wir nochmal hier aufschreiben.
Und zwar A ist nichts anderes in dem Fall als S1 S0 quer multipliziert
mit E0 oder S1 quer S0 E1 oder S1 S0 quer E2 oder S1 S0 E3.
Das ist klar, das gibt uns nichts anderes als das Verhalten, was wir
gerade beschrieben haben.
Wenn beide Eingangsvariablen 0 sind, Steuervariablen 0 sind, dann
kommt E0 am Ausgang, weil alle anderen verschwinden.
Wenn alle 1 sind, dann kommt E3 am Ausgang.
Und so eine Funktion in disjunktiver Form können wir realisieren.
Das heißt, wir brauchen nur UND-GATA oder GATA-INVERTER.
Und das will ich mal kurz hier machen.
Das heißt, nehmen wir mal an, wir haben hier unsere Variable S1 und
wir wissen, da können wir hier die Negation von S1 bilden mithilfe von
einem Inverter.
Das ist die zweite Variable S0 und das ist S0 quer hier.
Und jetzt haben wir 4 Produktterme, also wir brauchen 4 UND-GATA.
Und diese 4 UND-GATA, wie wir sehen, die Eingänge sind einmal S1 quer,
S0 quer, dann S1 quer und S0, dann S1 und S0 quer und dann S1 und S0
Und dann haben wir hier der dritte Eingang E0, hier der dritte Eingang
E1, hier E2 und hier E3
Und dann haben wir hier ein ODER mit 4 Eingängen,
wo diese Produktterme, also ein GATA, welches all diese 4 Produktterme
miteinander verknüpft, um die Funktion A zu realisieren.
Das heißt, man sieht hier eigentlich, dass dieses komplexe Baustein,
den wir kennengelernt haben heute, mithilfe von diesen Grundbausteinen
des vollständigen Operatorensystems Konjunktion, Disjunktion und
Negation realisiert werden kann.
Gut, gibt es Fragen dazu?
Okay, so jetzt gibt es eine andere Methode, mit der man Bullshit
-Funktionen mithilfe von Multiplexern realisieren kann.
Auf der einen Seite mithilfe oder unter Verwendung der
Implementierungstabelle, die wir gerade kennengelernt haben, wo man
entscheiden muss, was sind die Steuervariablen einer Funktion.
Die andere Möglichkeit für die Realisierung ist die Verwendung von dem
sogenannten Challenging-Entwicklungssatz, den wir kennengelernt haben,
um systematisch die disjunktive oder die konjunktive Normalform einer
Funktion zu bestimmen.
Das heißt, wir wissen, wenn wir jetzt bei einer Funktion hier nach
einer Variablen entwickeln, in der disjunktiven Form, dann setzen wir
den Wert dieser Variable auf 1, z.B.
hier C gleich 1, verknüpfen wir die Restfunktion FAB1 mit C konjunktiv
und das Ganze nochmal mit C querkonjunktiv verknüpft mit der
Restfunktion, die sich ergibt aus der originellen Funktion,
ursprünglichen Funktion, wenn man UC0 einsetzt.
Und die Vorgehensweise jetzt, wenn man diesen Entwicklungssatz
verwenden will, um Funktionen mithilfe von Multiplexern zu
realisieren, dass man die Funktion schrittweise nach allen Variablen
entwickelt, die man als Steuervariablen haben will.
Das heißt, in unserem Beispiel vorher, wir haben einmal entschieden,
die Steuervariablen sollen B und C, das heißt, wir entwickeln die
Funktion zunächst mal nach B und dann nach C.
Und die verbleibenden Restfunktionen sind dann das, was man an den
Eingängen von dem Multiplexer anlegen muss.
Das wollen wir auch anhand von einem Beispiel angucken, gegeben sei
eine Funktion mit drei Eingangsvariablen, A quer C oder B quer C oder
A, B, C quer.
Und die Steuervariable soll jetzt hier bei einem 2 zu 1 Multiplexer.
2 zu 1 Multiplexer heißt, dass wir nur eine einzige Steuervariable und
zwei Eingänge haben.
Also wir haben folgendes.
Die Funktion soll mithilfe von einem 2 zu 1 Mux realisiert werden.
Der hat einen Eingang, der soll C sein und dann hat ein Steuereingang
C und zwei Eingänge hier, die mit irgendetwas beschaltet werden, damit
die Funktion hier realisiert wird.
Wie macht man das?
Wir entwickeln also die Funktion jetzt nach C, mal A quer oder B quer,
C quer, A oder B.
Das heißt eigentlich, wenn C gleich 1 am ersten Eingang und wenn C
gleich 0, wenn C gleich 0, dann müssen wir A quer oder B ist A, B
quer.
Das heißt, man kann eigentlich den gleichen Term einmal realisieren A,
B und an den beiden Eingängen hier nutzen.
Einmal nicht negiert und einmal negiert.
Also hier Fu C gleich 0 A, B, Fu C gleich 1 A, B negiert.
Das heißt eigentlich, die Realisierung würde so aussehen, dass die
Variable C und dann an den Eingang 0 müssen wir A, B anlegen.
Also die Restfunktion, wie man sieht hier A, B und am Eingang 1 muss
man A, B quer, also wo man noch einen Inverter hier dazu braucht.
Natürlich kann man das gleiche, die Funktion realisieren mithilfe von
zwei Steuervariablen.
Da muss man die Funktion jetzt weiterhin nach einer weiteren Variable
entwickeln.
Das heißt, hier haben wir nach C entwickelt.
Wir können nochmal nach B oder nach A entwickeln und dann haben wir
die Realisierungen, die wir vorher eingangs gesehen haben.
Gut, gibt es Fragen dazu?
Das heißt, wir halten fest, Multiplexer sind Bausteine, die auf der
einen Seite, wie wir aus Rechnerorganisation, Stichwort DLX-Pipeline
bereits kennen, die dienen, den Signalfluss in einer Schaltung
festzulegen, zu steuern.
Auf der anderen Seite wissen wir ja jetzt seit heute, dass man
mithilfe von diesen Multiplexern auch boolische Funktionen oder
logische Funktionen realisieren kann.
Zwei Methoden haben wir ja kennengelernt, wie man das macht.
Auf der einen Seite mithilfe der Implementierungstabelle, auf der
anderen Seite mithilfe von dem sogenannten chernischen
Entwicklungssatz.
Und zu diesem Multiplexer, das heißt, ein komplexer Baustein, der N
-Steuereingänge, zwei Hoch-N-Eingänge und nur einen Ausgang gibt, gibt
es natürlich ein Gegenstück.
Und dieses Gegenstück heißt Demultiplexer bzw.
Decoder.
Das heißt, das ist ein Baustein, der nur einen Eingang hat, E, und
mithilfe von N Steuerleitungen, S0 und S1, diesen Eingang E auf einen
dieser Ausgänge hier durchschaltet.
So, das heißt, das logische Verhalten ist hier angegeben.
S0 und S1 sind die Steuervariablen.
Wenn sie Null sind, dann erscheint das, was am E anliegt, hier am
nullten Ausgang.
Wenn 0,1, dann erscheint, was am E anliegt, am ersten Ausgang.
Bei 1,0 am zweiten und bei 1,1 am dritten.
So, und die Frage ist, wie funktioniert das Ganze?
Also, nochmal hier steht die Erklärung auf der Folie.
Wenn zunächst mal der E-Eingang, der sogenannte Enable-Eingang, Null
ist, dann sieht man, wenn E gleich Null, dass an allen Ausgängen in
dieser Matrix eine Null steht.
Das heißt, an allen Ausgängen hat man eine Null.
Sonst, wenn E ungleich Null ist, das heißt 1 in unserem Fall hier,
dann bedeutet das, die 2-Bit-Zahl, die am Eingang, an den Eingängen
dekodiert vorliegt, erscheint oder wird an den Ausgang dekodiert,
indem der entsprechende Ausgang 1 wird.
Das heißt, wenn E gleich 1 ist, dann sieht man, dass diese 2-Bit-Zahl,
die an den Steuereingängen anliegt, dekodiert am Ausgang erscheint.
Also, es erscheint am Ausgang A0, es erscheint am Ausgang A1, bei 2 am
Ausgang 2, bei 3 am Ausgang 3.
Das heißt, der Demultiplexer wird deshalb auch Dekodierer genannt.
Und diesen Dekodierer haben wir auch kennengelernt in
Rechnerorganisationen, wie ich gleich zeigen werde.
Eine ganz wichtige Besonderheit von diesem Demultiplexer ist die
Tatsache, dass der Demultiplexer immer die Mindthermie aller
Steuersignale an den Ausgängen zur Verfügung stellt.
Was bedeutet das eigentlich?
Das bedeutet, wenn wir jetzt hier die charakteristische Gleichung
angeben, die charakteristische Gleichung angeben für die Ausgänge AI,
dann ist es nichts anderes als S1², S0², E oder S1², S0, E oder S1,
S0², E oder S1, S0, E.
Und wenn wir die hier aufschreiben für A0, bei A0 wissen wir, dass die
beiden Steuervariablen S1 und S0, 0 sind.
Das heißt eigentlich, es bleibt hier nichts anderes übrig als S1, S0²,
mal 1.
Für A1 wissen wir bei A1, dass S1 gleich 0 ist und S0 gleich 1.
Das heißt, es bleibt nichts anderes als S1², S0 und E, 1.
Und A2 ist dann nichts anderes als S1, S0² und 1 und A3 ist nichts
anderes als S1, S2 und 1.
Was bedeutet das eigentlich?
Wenn wir jetzt hier diese zwei Variablen S1 und S0 betrachten, dann
sehen wir, dass wir am Ausgang oder an den Ausgängen A0 bis A3 nichts
anderes als die Min-Thermie, also die Produktthermie, bei denen alle
Steuervariablen auftauchen haben.
Und das ist eine ganz wesentliche Eigenschaft, die man nutzt, um
Bullshit -Funktionen zu realisieren.
Das heißt, wenn wir wissen, ein Decoder oder ein Demultiplexer liefert
an den Ausgängen die Min-Thermie, alle Min-Thermie, wie man sieht, das
ist Min-Therm 0, das ist Min-Therm 1, Min-Therm 2, Min-Therm 3,
liefert alle Min-Thermie, warum schreit keiner hier,
liefert alle Min-Thermie der Steuervariablen.
Was bedeutet das?
Das bedeutet eigentlich, dieser Decoder oder Demultiplexer ist
hervorragend geeignet, um disjunktiv...
Ich habe alle Min-Thermie an den Ausgängen, da brauche ich die Min
-Thermie nur disjunktiv miteinander zu verknüpfen und dann habe ich
die disjunktive Normalform der Funktion.
Das heißt, der Decoder erzeugt alle zwei hoch N Min-Thermie seine N
-Steuervariablen.
Wenn wir jetzt ein Beispiel nehmen, was wir in der ersten Übung auch
betrachtet haben, die Berechnung der Anzahl von Einzel- bzw.
Min-Thermie plus Übertrag, das ist ja das Gleiche, dann haben wir
gesehen, dass wir für die Summe hier nichts anderes als die Min
-Thermie 1, 2, 4 und 7 hatten und dass wir für den Übertrag 5, 3, 5, 6
und 7 haben.
Das heißt, wir haben die zwei Funktionen Summe und Übertrag bei der
Addition von zwei Zahlen und diese Funktionen, die sind hier
beschrieben durch ihre Min-Thermie und dazu haben wir also eine
Funktion mit drei Eingangsvariablen.
Wir wollen die zum Beispiel disjunktive Normalform hier realisieren.
Da brauchen wir ein Multiplexer, wo alle diese drei Variablen als
Steuervariablen auftreten.
Man sieht hier A, B und C als Steuervariablen.
Am Enable-Eingang haben wir eine 1.
Dann wissen wir also, am Ausgang 0 ist Min-Therm 0, am Ausgang 1 Min
-Therm 1 und somit können wir einfach diese Min-Thermie nehmen, um die
Summe S bzw.
den Übertrag U umlaut hier zu realisieren.
Das heißt einfach die Ausgänge von dem D-Multiplexer verordern, also
mit Hilfe von einem ORDER-Gatter verknüpfen und dann hat man die
Funktion realisiert.
Gibt es Fragen dazu?
Das ist bisher nicht der Fall, deshalb mache ich weiter.
Was wir bis jetzt kennengelernt haben, also wir haben bisher Bausteine
wie Gatter, Multiplexer, Hoity und D-Multiplexer gehen wir immer davon
aus, dass die Funktion eigentlich fest verdrahtet realisiert wird.
Das heißt wir generieren oder entwerfen Schaltungen, die einfach durch
die Verdrahtung von Gattern, von komplexeren Bausteinen die gewünschte
Funktion realisieren.
Bei der Realisierung von hochintegrierten Schaltungen müssen aber die
Verknüpfungsbausteine eine größere Flexibilität anbieten.
Das heißt zum Beispiel, dass sie auf unterschiedlichen Anwendungen
anpassbar sein sollen.
Als nächstes werden wir solche Bausteine kennenlernen, wo man
tatsächlich die Realisierung anpasst auf unterschiedliche Anwendungen.
Diese Anpassung bezeichnet man als Personalisierung bzw.
Programmierung von den Bausteinen.
Also statt dass wir jetzt hier über eine fest verdrahtete Logik
sprechen, wie bis jetzt, wollen wir gucken, wie die Realisierung
burscher Funktionen in mikroprogrammierter Logik aussieht.
Die zwei Begriffe sind nicht neu für uns.
Wenn wir an die Steuerwerke, also an die Vorlesung
Rechnerorganisationen, denken, hatten wir die zwei Extremfälle der
Realisierung des Steuerwerks eines Rechners, wo wir gesagt haben, alle
CISC Rechner in den Anfängen waren mikroprogrammiert.
Das heißt eigentlich, das Programm war in einem Festwertspeicher
abgelegt und die Decodierung und Ausführung eines Programms bedeutete
nichts anderes, als die Startadresse des Mikroprogramms zu bestimmen
und dann die entsprechenden Mikroinstruktionen auszuführen.
Auf der anderen Seite haben wir gesehen, dass die Idee der RISC
Rechner kam, wo dieses Steuerwerk nicht mehr mikroprogrammiert war,
sondern fest verdrahtet.
Und die zwei Begriffe wollen wir jetzt hier auch in dem Zusammenhang
der Realisierung von logischen Funktionen betrachten.
Das heißt, bis jetzt haben wir eine fest verdrahtete Logik.
Wir können beliebig komplexe Funktionen realisieren, wir können sie
minimieren, dazu haben wir alle Werkzeuge kennengelernt.
Und wir können diese Funktionen mithilfe von unseren Standardgattern,
die wir kennengelernt haben, beziehungsweise mithilfe von komplexeren
Bausteinen wie Multiplexer und Demultiplexer realisieren.
Das ist eine Möglichkeit.
Die zweite Möglichkeit ist, wie kann man eigentlich sonst logische
Funktionen realisieren.
Man kann logische Funktionen realisieren, indem man die komplette
Funktionstabelle irgendwo speichert.
Das liegt doch an der Hand.
Also statt dass ich jetzt irgendwelche Bausteine miteinander
verschalte und entwerfe, speichere ich einfach blind die komplette
Funktionstabelle im Speicher.
Und wir haben ja die Speicherbausteine kennengelernt in der Vorlesung
der Rechnerorganisation.
Und das ist genau, was wir hier machen.
Das heißt, wir wissen jetzt, dass wir mithilfe von Demultiplexern
Alimentärme der Funktion, Alimentärme der Steuervariablen von diesem
Multiplexer an den Ausgängen haben.
Das heißt, wenn ich n Eingangsvariablen habe für den Demultiplexer,
also dieses Enable-Signal ist nicht mehr hier dargestellt, aber den
muss man sich auch so vorstellen.
Das ist ein Demultiplexer, das heißt es gibt ein Enable-Signal, der
ist immer auf 1.
Ja, dieses E.
Und jetzt haben wir aber n Eingangsvariablen.
Das sind die Steuervariablen dieses Multiplexer.
Wir wissen, für diese n Steuervariablen von dem Multiplexer haben wir
2 hoch n Mintermi an den Ausgängen.
n Steuervariablen, das heißt, da haben wir hier die Mintermi.
Da haben wir hier die Mintermi M0, M1 und so weiter und so fort bis M2
hoch n minus 1.
Das sind Alimentärme der Funktion.
Und diese Mintermi der Funktion, die sind eigentlich nichts anderes
als Adressen.
Das heißt, wir adressieren in einer Speicherordnung, also diese Matrix
hier, wir adressieren eine Zeile.
Aha, da werden bestimmte Erinnerungen wach an die Organisation von
Speicherbausteinen, Rechnerorganisation, wo wir von einem Spalten- und
Zeilendecoder geredet haben, wo ein Teil der Adresse zur Adressierung
einer Zeile und der zweite Teil zur Adressierung einer Spalte diente.
Das ist genau dieser Demultiplexer, den wir heute kennengelernt haben.
Ja, wir haben hier unsere Eingangssignale, das ist zum Beispiel die
Adresse.
Je nachdem, was an diesen Eingängen anliegt, wird einer dieser
Ausgänge von diesem Demultiplexer selektiert.
Also eigentlich wird eine Zeile in dieser Speicherordnung adressiert.
Und anschließend können wir hier, wir wollen hier nicht nur etwas
speichern, sondern wollen Bulsche Funktionen realisieren.
Und wir wissen, dass wir zum Beispiel Bulsche Funktionen realisieren
können als Dysfunktion von Mintermen.
Das heißt, mit Hilfe von dieser Anordnung, wenn ich die Spalten hier
nehme, dann kann ich M unterschiedliche Bulsche Funktionen, also M
Ausgangsvariablen realisieren, indem ich hingehe und sage, oh, die
Funktion 1, die hat den Minterm 0, den Minterm 2 hoch N-1 und so
weiter und so fort.
Die verbinde ich hier miteinander.
Das heißt, dieser Minterm wird in der Realisierung von M1 aufgenommen.
Die Funktion 2 hat zum Beispiel Minterm 0 und Minterm 3 und so weiter
und so fort.
Die Funktion M-1 hat diese Minterm hier.
Das heißt, auf diese Art und Weise kann ich jetzt nicht nur eine
einzige Funktion realisieren, sondern ich kann M unterschiedliche
Funktionen realisieren, wie man hier sieht.
Wir können das ein bisschen hier erweitern, wenn wir zum Beispiel noch
ein paar Zeilen hier hinzufügen, in Schwarz vielleicht,
damit man es besser sieht.
Dann können wir sehen, die Funktion hier hat diese Minterme, also das
ist Minterm 2, das ist Minterm 3 und die Funktion ist Minterm 0 und
Minterm 3 und so weiter.
Und die Funktion hier ist Minterm 1, 2 und 3 und 4 und so weiter und
so fort.
Und das hier, wie ich bereits jetzt gerade angekündigt habe, ist
nichts anderes als das, was wir kennengelernt haben.
Das ist die Adressierung einer Speicherzelle.
Wir haben ja diese Matrixanordnung kennengelernt in der
Rechnerorganisation, wo wir gesehen haben, dass das gleiche Beispiel
übrigens aus der Vorlesung der Rechnerorganisation, wir haben hier
eine Adresse, eine 4-Bit-Adresse, wir haben hier eine Matrixanordnung
von Speicherzellen und dann haben wir ja damals gesehen, dass wir hier
einen Zeilen-Adress-Decoder haben, eins aus N-Decoder, also der
selektiert eine Zeile und wir haben hier einen Spalten-Adress-Decoder,
der selektiert also eine Spalte, basierend auf der Adressinformation,
die er anlegt.
Und diese Adressinformation, die haben wir bekommen.
Die Adressinformation, das sind nichts anderes als die Steuersignale,
für die Sie Spalten- und Zeilen-Decoder, also ein Teil der Adresse,
zum Beispiel die niedrigwertigen Teile der Adresse, die dienten dazu,
eine Zeile zu selektieren.
Das heißt in dem Fall, dieser Zeilen-Decoder hat zwei Steuersignale.
Wenn sie 1-0 sind, dann wird die zweite Zeile hier selektiert.
Die höherwertigen Bits der Adresse, also in dem Fall hier Bit 3 und 4,
dienen dazu, eine Spalte hier zu selektieren.
Das heißt, das sind die Steuersignale für den Spalten-Decoder.
In dem Fall, wenn das 1-1 ist, wird also die dritte Spalte dekodiert,
so dass wir hier eine Zeile in dieser Speicher-Matrix-Anordnung
adressieren oder ansprechen können.
Okay, und das Ganze haben wir auch so kennengelernt.
Wenn wir hier die Organisation vom Speicher-Baustein betrachten, dann
sehen wir unsere Adressen von A0 bis A1.
Diese Adressen wurden unterteilt.
Die niedrigwertigen Bits der Adresse, also A0 bis A1, waren die Zeilen
-Adresse.
Die sind also Eingangssignale von einem Zeilen-Decoder, der eine Zeile
in dieser Speicher-Matrix adressiert.
Der Rest der Adresse, also die höherwertigen Bits, A1 bis A1, sind
nichts anderes als die Steuersignale für einen Spalten-Decoder, der
also eine Zeile hier oder eine Spalte hier in der selektierten Zeile
anspricht und somit ein Element in der Speicher-Matrix.
Das ist nur zur Wiederholung hier, das haben wir alles kennengelernt.
Was für ein Speicher-Baustein ist das?
Das ist nur eine Wiederholung zur Rechner-Organisation.
Kann mir jemand von euch sagen, was für ein Speicher-Baustein ist hier
dargestellt?
Also wir haben ja die unterschiedlichen ROM, BROM, NV-RAM, SRAM, DRAM,
EU -BROM usw.
Was ist das für einer?
Damit ihr nur ein bisschen aufwacht.
Ich bin enttäuscht.
Weiß es wirklich keiner?
Einer weiß es, ja?
DRAM.
Okay, DRAM.
Er sagt DRAM.
Warum?
Oder hast du nur geraten?
War das geraten oder hast du dir dabei was überlegt?
Du hast es in Erinnerung, du hast es alle auswendig gelernt.
Okay, also wenn ich dir sage, es ist ein DRAM, kannst du mir sagen,
warum oder woran ich das erkenne?
Wenn ich euch sage, das ist ein DRAM, woran erkenne ich das?
Genau.
Und warum hast du dich nicht gemeldet von Anfang an?
Oder hast du es so lange gebraucht?
Also, das ist auf jeden Fall, und das ist mein Punkt eigentlich immer
in dieser Vorlesung, dass man sich nicht erschrecken lassen darf durch
diese Blogschaltbilder, die ich hier auf den Folien werfe.
Man muss nachdenken.
Und er hat ein bisschen nachgedacht und hat gesehen, es gibt ein RW
hier.
Ja, das ist ein Signal, das kennen wir, Lese-Schreib-Signal, also muss
ein Lese-Schreibe-Baustein sein.
Steht auch hier, Lese-Schreibe-Verstärker, das ist noch der zweite
Punkt.
Aber anhand von RW wissen wir, das ist ein Baustein, was wir lesen und
schreiben können.
Was sind das für uns?
Das ist RAM.
Aber das könnte entweder SRAM oder DRAM sein, oder?
Und er hat gesagt, so wie ich ihn verstanden habe, da dort Lese
-Schreibe -Verstärker steht, muss es ein DRAM sein.
Hast du das gesagt?
Genau.
Und das ist korrekt, weil, kannst du uns sagen warum?
Wenn es SRAM wäre, dann muss man was?
Genau, also, ihr könnt euch vielleicht erinnern, dass die SRAM
-Bausteine aus Flip-Flops realisiert waren und dass die DRAM-Bausteine
mit Hilfe von einem Kondensator realisiert werden, wo die Ladung auf
dem Kondensator mit der Zeit wegfließt durch Schleckströme, aber auch
immer wieder der Kondensator entladen wird, wenn man die Zelle liest.
Das war ja ein destruktives Lesen, das heißt, man zerstört die
Information und deshalb muss man die Information entweder periodisch
immer wieder auffrischen oder nach jedem Lesen von einer DRAM
-Speicherzelle.
Aber das ist nicht das Thema der heutigen Vorlesung, das haben wir ja
bereits behandelt und du bist vollkommen richtig, das ist auf jeden
Fall ein Lese-Schreibe-Baustein, also SRAM oder DRAM und da wir hier
einen Lese-Schreibe-Verstärker haben, der wahrscheinlich beim
Auffrischen verwendet wird, muss das ein DRAM-Baustein sein.
Okay, jetzt zurück zum Thema, wir wollen diese Bausteine, ich habe
jetzt hoffentlich genug motiviert und klar gemacht, dass diese
Decoder, die wir heute kennengelernt haben, mit dem Ziel, die zu
verwenden, um Bullshit-Funktionen zu realisieren, dass wir sie bereits
kennen aus der Anwendung bei der Adressierung oder bei der
Organisation von Speicher-Bausteinen.
Aber jetzt wollen wir zum Thema zurückkehren und wollen wir gucken,
wie können wir mithilfe von Speicher-Bausteinen allgemein, egal ob
RAM, DRAM, ROM, EEPROM und so weiter und so fort, eine Bullshit
-Funktion realisieren.
Das war ja das Ziel, dass wir sagen, wir wollen Bullshit-Funktionen
mithilfe von mikroprogrammierter Logik realisieren.
Und dazu betrachten wir ein Beispiel, wir wollen ein Schaltnetz
realisieren mit drei Eingangsvariablen, das sind die 3-Bit
-Eingangszellen, also 3-Bit E2, E1 und E0.
Und dieses Schaltnetz soll zu jeder Zahl, die am Eingang anliegt, ihr
Quadrat bilden.
Das heißt, wir wissen ja, mit den drei Bits hier, E1, E2, E1, E0,
können wir die Zahlen von 0 bis 7 darstellen.
Am Ausgang wollen wir das Quadrat haben.
Das heißt, Quadrat von 0 ist nach wie vor 0, glaube ich, und von 7 49.
Und damit wir 49 darstellen können, brauchen wir 6 Bits.
Also das sind die Bits A5 bis A0.
Das heißt, die Funktionstabelle sieht wie folgt aus.
Ich habe hier meine Zahlen von 0 bis 7.
Das sind die Eingangsvariablen vom Schaltnetz E2, E1, E0.
Die Quadrate sind hier eingegeben.
Und dann, wie die Quadrate am Ausgang dargestellt werden, sieht man
hier, also 1 ist 1, 4 ist 4, 9 ist 8 plus 1, 16 ist 16, 25 ist 16 plus
8 plus 1 und 36 ist 32 plus 4 und 49 ist 32 plus 16 plus 1.
So, das heißt, die Aufgabenstellung ist klar, oder?
Wir haben drei Eingangsvariablen und wir haben sechs
Ausgangsvariablen.
Und ich habe es bereits gesagt, Funktionen mithilfe von
Speicherbausteinen zu realisieren, bedeutet, oder am einfachsten, die
komplette Funktionstabelle irgendwo speichern.
Wenn ich diese Funktionstabelle irgendwo speichere, dann habe ich ja
die Funktion realisiert.
Spricht was dagegen eigentlich?
Oder seid ihr alle damit einverstanden?
Wer ist dagegen?
Okay, das heißt, alle sind davor, alle sind einverstanden.
Aber wir sind hier in dieser Vorlesung und müssen natürlich gucken,
dass wir vielleicht irgendwann mal irgendwas sparen.
Es geht immer darum, so billig wie möglich Sachen zu realisieren.
Wenn wir also diese Funktionstabelle hier angucken, dann sehen wir,
dass bestimmte Ausgangsvariablen eigentlich trivial sind.
Zum Beispiel A1 ist immer 0.
Aha, warum soll ich also diese Spalte, das sind letztendlich 8 Bits in
einem Speicherbaustein.
Also warum soll ich diese 8 Bits dort realisieren?
Geht es nicht einfacher vielleicht, dass ich diesen Ausgang A1 mit der
0 verbinde und dann brauche ich keine 8 Bits im Speicherbaustein?
Wenn man noch schärfer hinguckt, dann sieht man, dass A0 identisch mit
E0 ist.
Also man sieht hier A0, die Spalte A0, das ist 0 1 0 1 0 1 0 1.
Das ist identisch mit E0 und A1 ist gleich 0 die ganze Zeit,
unabhängig von den E2 bis E0.
Also was bedeutet das?
Das bedeutet, diese zwei Spalten brauche ich nicht zu realisieren.
Ich brauche eigentlich nur 32 Bits, also für A5 bis A2 und mal 8, also
4 mal 8.
Ich brauche irgendeinen Speicherbaustein mit Speicherkapazität von 32
Bits, wo ich natürlich den Speicherbaustein korrekt adressieren kann
und auf die Ausgänge korrekt zugreifen kann.
Und das können wir hier machen, indem wir sagen, die zwei brauchen wir
nicht zu realisieren.
Hier habe ich einen ROM-Baustein, also Read-Only-Memory-Baustein.
Der hat jetzt hier drei Eingänge, das sind die Adresseeingänge.
Man sieht hier mit drei Eingängen kann man also 2 hoch 8
Speicherzellen realisieren.
Und jede Speicherzelle hat 4 Bits oder ist 4 Bit breit.
Das hat die Bezeichnung hier 8 mal 4 bei diesem ROM-Baustein.
Und an den Ausgängen, also das sind die Datenausgänge von diesem ROM
-Baustein, erscheinen nichts anderes als die Ausgangsvariablen A2, A3,
A4 und A5.
Man sieht, dass A0 gleich E0 ist und dass A1 immer 0 ist.
Was bedeutet das?
Das bedeutet eigentlich diese Belegungstabelle, die Speicherbelegung
von diesem ROM-Baustein, 8 mal 4 ROM-Baustein.
Das heißt, der hat drei Adresseingänge A0 bis A2.
Damit kann man 8 Speicherzellen oder 8 Speicherworte adressieren.
Mit drei Adressleitungen kann ich 2 hoch 3, also 8 Wörter adressieren.
Und jedes Wort ist 4 Bit breit.
Und man sieht hier, dass D0 nichts anderes ist als der Ausgang A2.
D1 ist A3 und D2 ist A4 und D3 ist A5.
So viel dazu.
Also, wir können jetzt hier für diese Funktion so einen
Speicherbaustein, könnte natürlich ein anderer Speicherbaustein sein,
hier beispielhaft nur für einen ROM-Baustein dargestellt nehmen, um
diese Funktion zu realisieren.
Okay, ich will euch nur kurz daran erinnern, da wir jetzt die Begriffe
RAM und ROM usw.
verwendet haben, dass wir das Thema Rechnerorganisation behandelt
haben.
Wir sind auf die Eigenschaften bzw.
die Realisierungsformen speziell von statischem RAM und dynamischem
RAM dort eingegangen, wo wir gesagt haben, dass eine statische RAM
-Zelle aus 2, wie war die Definition nochmal?
Da habt ihr euch so schwer damit getan, Rechnerorganisation.
Zwei Kreuz rückgekoppelte Inverter realisiert ist, oder?
Könnt ihr euch erinnern?
Das war eine wilde Zeichnung.
Keine Chance für euch damals das zu verstehen, aber jetzt könnt ihr
das verstehen.
Jetzt könnt ihr das verstehen, weil wir wissen, was alles hier
bedeutet auf dieser Folie.
Wir wissen, dass T3 ein Inverter bildet, dass T1 und T3 auch ein
Inverter bilden und dass T4 und T5 nichts anderes als NMOS
Transistoren sind.
Ich habe euch damals gesagt, ihr müsst euch das wie folgt vorstellen,
dass wir zwei Inverter haben und
dass sie so rückgekoppelt sind.
Und das ist genau was hier dargestellt ist.
Das ist zunächst mal der erste Inverter, der rote.
Und das ist hier der zweite Inverter.
Also NMOS Transistor unten und PMOS Transistor oben, das sind ja die
zwei Inverter.
Und jetzt schauen wir mal, der Ausgang von dem einen Inverter, der
Ausgang von dem roten Inverter, das ist der hier, das ist der Ausgang
von dem, oder?
Der Ausgang von dem hier ist der Eingang von dem Inverter.
Und der Ausgang von dem Inverter, das ist nichts anderes als der hier,
ist der Eingang von dem Inverter.
Das ist genau was hier dargestellt ist.
Und da konnten wir sehen, wenn wir hier eine 0 haben, dann ist es hier
1, dann ist es eine 0, dann speichern wir eine 0 in dieser Zelle.
Beziehungsweise wenn wir hier eine 0 haben, dann haben wir hier eine 1
und dann ist hier eine 1.
Also kein Widerspruch und dann speichern wir eine 1 in dieser Zelle.
Und da haben wir die zwei Transistoren T4 und T5, die dienen
eigentlich nur dazu, diese Zelle hier an die Bitleitungen B0 und B1
anzubinden.
Und wie wird das hier angesprochen?
Über die Adressleitung, wenn wir hier eine 1 haben an der
Adressleitung, dann wissen wir zum Beispiel, dass diese beiden
Transistoren dann leiten, weil das ein NMOS Transistor, dann liegt
eine 1 am Gate, beziehungsweise der hier, es liegt auch eine 1 am
Gate.
Das heißt, wir können den Inhalt dieser Zelle einmal über B0 lesen und
einmal über B1 lesen.
Das heißt, in dem einen Fall greifen wir hier in die Mitte zu, lesen
wir zum Beispiel die 1 und an der anderen Bitleitung lesen wir die 0
oder umgekehrt.
Warum ich die Folie hier bringe, weil ich das für sehr wichtig halte,
dass ihr jetzt wirklich guckt, wie das damals gemeint war und dass ihr
seht, dass man jetzt hier mit dem, was wir kennengelernt haben in
dieser Vorlesung, dass man hier ein komplettes Verständnis für das
Material, was wir hier besprechen, hat.
Das gleiche gilt natürlich für die dynamische Zelle, von der ich
vorher gesprochen habe, wo wir gesagt haben, dass bei dieser
dynamischen Speicherzelle, das wird so realisiert, dass man hier
praktisch die Informationen auf einem Kondensator speichert, das ist
der Speicherkondensator und dieser Speicherkondensator ist eigentlich
kein zweiter Baustein.
Also wir haben einen Speicherkondensator und einen Speichertransistor
und dieser Speichertransistor ist ein NMOS Transistor.
Das ist Substrat, B dotiert, das ist Source mit N und das ist Drehen.
Aber die Besonderheit hier bei dieser dynamischen Zelle, wie man
sieht, im Gegensatz zu einem stinknormalen Transistor, ist, dass diese
Drehzone ein bisschen breiter ist.
Also die Drehzone ist nicht wie die S-Zone hier, sondern die ist
breiter, wie man sieht.
Und was bedeutet das, warum macht man das?
Die ist ein bisschen breiter, wie man hier sieht.
Man macht sie breiter, damit man gleichzeitig den Transistor und die
Kapazität hier realisiert.
Das heißt, das hier ist nichts anderes als diese Speicherkapazität.
Also diese vergrößerte Drehzone ist nicht anders als der
Speicherkondensator der dynamischen Speicherzelle.
Und wir haben ja das letzte Mal oder in der Vorlesung gesehen, okay,
wie lesen wir die, wenn wir das lesen wollen, dann müssen wir
irgendwas an A anlegen, z.B.
einen High-Pegel, dann leitet der Transistor hier, weil das ist ein
NMOS Transistor.
Und wenn er leitet, dann werden bei einem entsprechenden Pegel hier z
.B.
Ladungen abfließen.
Den Stromfluss misst man an der Leitung B und weiß, da war eine 0 oder
1 in der Zelle gespeichert.
Das heißt, mit dem, was wir jetzt kennengelernt haben hier, verstehen
wir die Zusammenhänge, wie dieses Lesen bzw.
Schreiben einer dynamischen Zelle funktioniert.
Okay, das wollte ich nur kurz hier zur Erinnerung bringen, weil das
rundet alles ab, was wir bis jetzt kennengelernt haben.
Gibt es Fragen dazu?
Gut, das nächste, was wir behandeln wollen, wir haben bis jetzt mit
Hilfe vor allem von Demultiplexern, haben wir gesehen, bzw.
Speicherbausteinen, dass wir auf...
Hört mal zu, was ich erzähle, die Folie könnt ihr nachher lesen.
Ich kann das ausblenden.
So, das ist schlecht für die Aufzeichnung.
Also wir haben gesehen, mit Hilfe von Demultiplexern haben wir die
Mintermi am Ausgang.
Wenn wir diese Mintermi nehmen und disjunktiv miteinander verknüpfen,
dann haben wir die disjunktive Normalform der Funktion realisiert.
Wir haben Speicherbausteine, wo wir die komplette Funktionstabelle
dort speichern können und somit auch die Funktion realisieren.
Da fragt sich der eine oder andere, und was soll der Quatsch?
Wir haben uns jetzt so viele Vorlesungen mit Minimierung von Bulsche
Funktionen beschäftigt, wo wir versucht haben, die Termi kürzer zu
machen und Kosten zu sparen.
Letztendlich, wo bleibt das?
Also wie kann ich jetzt hier komplexere, spezielle Bausteine haben,
mit denen ich Bulsche Funktionen in minimierter Form realisieren?
Also verwendet man statt jetzt die Normalform oder die
Funktionstabelle die disjunktive Minimalform, dann lassen sich die
Funktionen natürlich kompakter und preisgünstiger darstellen.
Und wir wollen hier die Möglichkeiten der Realisierung mithilfe von
programmierbarer Logik, also Programmable Logic Array, im Unterschied
zu ROM zum Beispiel, also Read Only Memory, werden bei diesen PLAs
eingangs nicht die Min-Termi, sondern die Prim-Implikanten der
Minimalüberdeckung der Funktion erzeugt und realisiert.
Also dazu wird dann der Decoder, den wir kennengelernt haben zur
Realisierung der Funktion, wird ersetzt, also die Min-Termi der
Funktion, durch eine Und-Matrix, die die Prim-Implikanten der Funktion
realisiert.
Wie sieht das Ganze aus?
Das sieht wie folgt aus.
Das heißt, wir haben keinen Decoder, der die Min-Termi der Funktion
realisiert, sondern für N Eingangsvariablen hier, die sowohl BIAT als
auch NIGIR zur Verfügung stehen, haben wir eine Und-Matrix und
mithilfe von dieser Und-Matrix können wir jetzt hingehen und unsere
Produkt -Termi, die aus der Minimierung rauskam, unsere Produkt-Termi
realisieren.
Die verknüpfen wir disjunktiv miteinander, sodass wir die
Funktionen...
Wie sieht das Ganze hier aus?
Das ist ein Beispiel für zwei Funktionen.
Man sieht also mit einer bestimmten Und-Matrix hier.
Man muss sich vorstellen, jede Zeile dieser Und-Matrix kann man
nutzen, um ein Produkt-Term zu realisieren.
Und wenn man ein Produkt-Term realisiert, der ist hier.
Das ist ein Produkt-Term jetzt hier.
Nehmen wir mal A und das ist hier C.
Das ist also der Produkt-Term AC.
AC liegt hier.
Wir brauchen für die Funktion noch ein Produkt-Term, der ist zum
Beispiel A-Quer, C-Quer.
Dann habe ich A-Quer, C-Quer hier.
Und andere natürlich.
Und jetzt schauen wir mal hier, dann sehen wir bei der Oder-Matrix.
Die Oder-Matrix hat nicht nur einen Ausgang, sondern mehrere Ausgänge.
Das bedeutet eigentlich, ich kann diese Oder-Matrix nutzen, um
gleichzeitig mehrere Funktionen der gleichen Eingangsvariablen zu
realisieren.
Aha, woran erinnert uns das?
Das erinnert uns an die Bündel-Minimierung, die wir kennengelernt
haben.
Beispiel.
Gucken wir mal F1 und F2.
Und da sehen wir hier, das sind schon minimierte Funktionen.
Das sind hier Primimplikanten der Funktionen A, B-Quer bzw.
A und C sind Primimplikanten von F1.
Und A-Quer, C-Quer bzw.
AC und AB, C-Quer sind Primimplikanten von F2.
Und wie realisiert man das?
Mithilfe von einem PLA.
Man geht hin und realisiert alle diese Produkt-Termi, wie man sieht.
Und man sieht hier, dass dieser Produkt-Term AC in beiden Funktionen
auftaucht.
Das ist auch ein Prim-Term, Primimplikant in der ersten Funktion und
Primimplikant in F2.
Also wir haben das Prim-Koppel-Term genannt.
Und man sieht hier, dass man diesen Prim-Koppel-Term nur einmal zu
realisieren braucht.
Und zwar hier und kann man den einmal nutzen, um F1 zu realisieren.
Wo F1 nichts anderes als A-Quer, AC oder AB-Quer bzw.
den gleichen Term hier auch nutzen.
Bei der Realisierung von F2, wo F2 nichts anderes als AC oder A-Quer,
C -Quer oder AB-C-Quer.
Gibt es Fragen dazu?
Das heißt, wir machen jetzt Gebrauch aus dem, was wir gelernt haben
vorher.
Dass wir die Funktion minimieren und statt jetzt die Min-Termi am
Ausgang von dem Demultiplexer die Produkt-Termi an den Ausgängen hier
von dieser Und-Matrix haben.
So, der Term AC in dem letzten Beispiel könnte man für beide
verwenden.
Wie bereits erwähnt, man sollte auch Funktionen nie einzeln
realisieren, sondern wenn es darum geht, mehrere Funktionen zu
realisieren, sollte man gucken, ob man diese Funktion nicht im Bündel
minimieren kann, um den gesamten Aufwand hier zu optimieren.
Die PLAs, die wir jetzt gesehen haben in dem Beispiel hier, die werden
ähnlich wie ROM-Bausteine bereits bei der Herstellung personalisiert.
Was bedeutet das?
Man bedeutet eigentlich, wenn man seine Funktion hat, dann muss man
das zum Hersteller geben und der Hersteller tut diese Knoten in der
Und - und Oder-Matrix.
Das heißt, es wird schon bei der Herstellung fest.
Man kann das natürlich nicht mehr ändern.
Also diese Knoten, die hier angegeben sind, der Baustein wird bei der
Herstellung personalisiert, sagt man.
Aber das ist nicht eigentlich, was wir immer wollen.
Wir wollen eine gewisse Freiheit haben, dass wir vielleicht mal eine
Funktion selber implementieren.
Oder dass wir nicht bei den Matrizen jetzt die Und- und Oder-Matrix
fest haben, sondern etwas noch Bewegungsfreiheit bei der
Implementierung oder bei der Realisierung haben.
Und hierzu gibt es programmierbare PLAs, wo die Anzahl der
Eingangsvariablen fest ist, also N Eingangsvariablen, Anzahl der
Produktthermie, die man realisieren kann, also die Zahl der Und-Matrix
fest ist und die Ausgangsvariablen, die nennt man Field Programmable
Logic Array Bausteine.
Alternativ dazu werden PAL-Bausteine auch angeboten, bei denen die
Oder -Matrix bereits bei der Herstellung personalisiert ist, aber die
Und -Matrix noch offen ist.
Wie sieht das aus?
Das sieht wie folgt aus.
Das heißt, man bekommt so einen PAL-Baustein, bei dem die Oder-Matrix,
das ist hier am Ausgang, diese Oder-Matrizen, die sind personalisiert.
Das heißt, man sieht hier, das ist zunächst mal ein Oder, das ist
nochmal ein Oder.
Die sind fest, weil diese Oder-Gatter hier, die sind immer verbunden
mit allen Zeilen der Und-Matrixen.
Aber die Und-Matrix ist frei.
Das heißt, man weiß, ich habe hier n Eingangsvariablen der Funktion.
Ich kann hier k-Produktthermie verwenden, um f1 zu realisieren und
keine Ahnung, l-Produktthermie haben, um fm zu realisieren.
So, was bedeutet das?
Das bedeutet eigentlich, dass man hier für die Funktion f1 alle
Produktthermie wissen.
Dann kann man hingehen und kann man anfangen hier Verbindungen
herzustellen.
Das heißt beispielsweise, der erste Produkttherm sieht wie folgt aus.
Der zweite Produkttherm, keine Ahnung, so aus.
Und dann natürlich diese Produktthermie, die man hier durch das
Herstellen von Verbindungen in der Und-Matrix hat, die werden
miteinander disjunktiv verknüpft, um f1 zu realisieren,
beziehungsweise auf ähnliche Art und Weise werden solche
Produktthermie verwendet, um fm zu realisieren.
Verschiedene Paltypen unterscheiden sich dabei sowohl in der Anzahl
der Eingänge, Produktthermie, als auch in der Programmierung der Oder
-Matrix.
Die Anzahl der Eingänge von PALs ist damit fest vorgegeben und
unbenutzte Eingänge, das heißt zum Beispiel hier in unserem Beispiel,
nehmen wir mal an, f1 hat nur zwei Produktthermie, aber wir sehen
hier, wir haben noch weitere Eingänge an diesem Oder-Gata, die müssen
wir auch entsprechend berücksichtigen.
Die dürfen wir nicht einfach so in der Luft fliegen lassen, sondern
die müssen wir mit irgendwas verbinden und die werden mit sogenannten
Dummy -Terms verbunden.
Zum Beispiel, wenn wir hier die Produktthermie bc, acq und ab haben,
um eine Funktion zu realisieren, bei unserer Und-Matrix haben wir aber
vier Eingänge, wie wir sehen hier bei der Oder, bei der Ausgangsstufe,
dann dürfen wir diesen Eingang,
kann man hier tun, am einfachsten natürlich nochmal eins dieser
Produktthermie dorthin verbinden, weil wir wissen ja laut Idempotenz
-Gesetz, bc oder bc, da ändert sich nichts an der Funktion.
Oder man könnte natürlich in dem Fall eine 0 dort, man könnte
natürlich diesen Eingang mit 0 verbinden.
Habt ihr was verstanden?
Hat es Spaß gemacht?
Wir haben heute spezielle Bausteine kennengelernt, mit denen wir
Funktionen realisieren.
Einmal Multiplexer, die wir schon kennen eigentlich aus Rechner
-Organisationen.
Heute haben wir gesehen, wie man sie nutzt, um Bullshit-Funktionen zu
realisieren.
Wir haben Demultiplexer, die wir auch bereits kennengelernt haben,
aber heute wissen wir mehr darüber, und zwar, wie man sie nutzt, um
Bullshit -Funktionen zu realisieren.
Dann haben wir programmierbare Bausteine kennengelernt, also
Realisierung von Funktionen mithilfe von Speicher-Bausteinen.
Und am Ende haben wir programmierbare Logic-Arrays kennengelernt, mit
denen wir nicht jetzt die Funktionen in ihrer disjunktiven Normalform,
beziehungsweise die komplette Funktionstabelle, wie bei Speicher
-Bausteinen, implementieren können, sondern tatsächlich die kürzesten
Produkttherme, die man von der Minimierung bekommt, implementieren
kann.
Und dabei haben wir auch gesehen, dass diese Bausteine eine super
Möglichkeit anbieten, diese Bündel-Minimierung, also Produkttherme,
die bei mehreren Funktionen auftreten, einmal zu realisieren und
einmal zu implementieren und dann zur Realisierung mehrerer Funktionen
nutzen.
Für heute möchte ich die Vorlesung beenden und somit das Thema auch
Realisierung burscher Funktionen oder Schaltnetze.
Wir werden das nächste Mal auf ein besonders spannendes Thema zu
sprechen kommen, und zwar, wie sieht es aus mit Laufzeiteffekten aus.
Bis jetzt, bei allen diesen Bausteinen, bei allen diesen
Betrachtungen, die wir gemacht haben, gehen wir davon aus, dass die
Signale Eingangsbelegungen sofort auf den Ausgang auswirken.
Wir haben aber gesehen, oder wir wissen, dass alle Bausteine, die wir
kennengelernt haben, letztendlich aus Silizium bestehen.
Das heißt, es gibt eine endliche Ausbreitungsgeschwindigkeit der
Signale.
Es gibt bestimmte Verzögerungen bei der Ausbreitung der
Eingangsvariablen auf die Ausgänge.
Die könnten zu Problemen führen, die wir das nächste Mal hier in der
Vorlesung behandeln werden.
Für heute bedanke ich mich für die Aufmerksamkeit und wünsche euch
einen schönen Nachmittag.