Ich möchte jetzt wiederholen von der letzten Stunde den
Folgenerkenner.
Da gehe ich jetzt natürlich etwas schneller durch, weil wir es ja
schon mal gemacht haben.
Und tut mir leid, dass es sich jetzt hier ein bisschen blendet auf der
Seite, aber ich weiß nicht, ob man das verhindern kann.
Sonst schauen Sie einfach auf die rechte Seite.
Also erstmal die verbale Aufgabenstellung.
Wir wollen ein synchrones Mili-Schaltwerk, also einen Mili-Automaten,
mit zwei Eingangssignalen haben und einem Ausgangssignal.
Und wir wollen am Binärzeichen empfangen, am Eingang X1.
Und der Eingang X2, der ist sozusagen so eine Art Trigger.
Solange der auf 0 steht, dann wird das Signal empfangen.
Wenn der auf 1 geht, ist entweder zu Ende, dann ist das Signal drin
oder wir brechen einfach ab.
Das heißt, wir können also mit X2 gleich 1 auch einfach zwischendrin
beenden.
Das ist der Witz dabei.
Wenn dann diese Folge, die soll 101 sein, wenn die innerhalb dieses
Beobachtungszeitraums aufgetaucht ist, am Eingang X1, wie gesagt X2
ist ja nur so ein Trigger, und dann mit X2 gleich 1 beendet wird, dann
geben wir sozusagen Y gleich 1 aus.
Das heißt, das ist sozusagen das Ergebnis, dass wir dann das gesehen
haben, was wir wollten.
Was ja für einen Automaten typisch ist.
Wir wollen also im Grunde genommen einfach mal eine Eingangssequenz
detektieren und dann daraufhin eine 1 ausgeben, wenn wir sie sehen.
Wenn wir sie nicht sehen, tun wir nichts.
Oder wenn eben das X2 am 1 wird zwischendrin.
Dann gibt es ein paar Randbedingungen.
Da kann man sich jetzt beliebige Randbedingungen überlegen.
Hier ist es jetzt, wir möchten eine möglichst geringe Gatteranzahl
haben.
Wir möchten nur NAND- oder NOR-Gatter haben.
Und wir möchten diese JK-Flipflops nehmen und davon eine minimale
Anzahl.
Da können wir jetzt gleich mal darüber philosophieren, wie viele es
denn sein müssen, wenn wir das tun wollen.
Also Eingabe ist jetzt wieder in der Richtung geschrieben, X1, X2.
Ausgabe soll Y sein.
Und jetzt ist die Frage, was muss ich denn jetzt tun?
Vielleicht können Sie mir Hinweise geben.
Sie haben es ja beim letzten Mal schon mal gehört.
Wie viele Zustände brauche ich denn?
Was denken Sie?
Ich will eine Folge von drei Zeichen erkennen.
Und ich habe noch ein weiteres Signal, was mir sozusagen sagt, ob das
jetzt valide war oder nicht.
Wie viele Zustände brauche ich denn da?
Wir brauchen vier Zustände.
Wir brauchen erstmal so einen Grundzustand, in dem wir starten und
dann warten wir auf die Beobachtung X2 gleich 0 und das erste Zeichen.
Wir wollen ja, dass X2 gleich 0 ist.
Wenn X2 gleich 1 ist, wird sozusagen abgebrochen.
Und das erste Zeichen X1 gleich 1.
Wir wollen ja 1, 0, 1 haben.
Dann, wenn das passiert ist, dann gehen wir auf das erste Zeichen X1
gleich 1.
Und dieser Folge, wenn wir sozusagen hier, also wir sind in einem
Wartezustand, das zeige ich Ihnen gleich in dem Automatengrafen, und
warten dann auf das zweite Zeichen X1 gleich 0.
Sonst wird abgebrochen, wenn wir eine Transition von 0 nach 1 haben.
Dann haben wir einen dritten Zustand, C.
Das zweite Zeichen wird empfangen, wir warten auf das dritte Zeichen,
das X1 gleich 1.
Oder wieder auf den Abbruch, wenn wir von 0 nach 1 eine Transition
haben für X2.
Und Miliautomat heißt ja, wir können gleichzeitig etwas ausgeben.
Ich habe ja schon gesagt, dass ein Miliautomat vielleicht immer etwas
schwerer zu verstehen ist als ein Moorautomat, weil beim Moorautomaten
gebe ich ja im Prinzip immer nur für einen bestimmten Zustand eine
bestimmte Ausgabe aus.
Hier kann ich jetzt eine Ausgabe ausgeben und gleichzeitig eine
Zustandstransition durchführen.
Und das finde ich, zumindest ich persönlich, finde es etwas schwerer
zu verstehen.
Aber deswegen muss man uns das halt jetzt genau vergegenwärtigen, was
wir hier machen wollen.
Und dann gibt es den Zustand D.
Jetzt haben wir das dritte Zeichen.
Und wie gesagt, wir können ja immer, wie es auch gerade gesagt wurde,
auf den Abbruch warten.
Oder sonst geben wir hier halt Y gleich 1 aus.
Dann haben wir sozusagen die gesamte Folge durch erkannt.
Ja, hoffentlich soweit klar.
Ich wiederhole es deshalb nochmal, weil es beim letzten Mal Fragen
gab.
Zumindest haben wir das so gehört.
Also wie gesagt, wenn das jetzt unklar ist, dann bitte stellen Sie die
Fragen jetzt.
Der Automatengraf.
Das ist jetzt der Automatengraf von einem Miliautomaten.
Und jetzt kann man sich vorstellen, wenn man hier startet im Zustand
A.
Welche Möglichkeiten gibt es denn jetzt, um von A nach B zu wechseln?
Das heißt also, ich bekomme X1.
Hier ist es ja nochmal angeschrieben.
X1, X2.
Ich bekomme X1 1 und X2 0.
Und dann gebe ich eine 0 aus und wechsle hier rüber.
Sonst bleibe ich halt die ganze Zeit hier drin.
Und dann wechsle ich entweder hier hin, also diesen Weg.
Da habe ich die Sequenz erkannt.
Das heißt, dann würden die gleichzeitig kommen.
Dann würde also sozusagen das X2 gleich 1 gleichzeitig kommen.
Dann würde ich diesen Weg nehmen oder sonst würde ich diesen Weg
nehmen.
Und das wäre sozusagen der normale Weg durch diesen Automatengraf.
Ich hoffe, den sehen Sie.
Und jetzt können wir ja, wenn wir den Automatengrafen haben, können
wir jetzt die Automatentabelle aufstellen.
Das sollte ja eigentlich schon fast Routine sein.
Deswegen wiederhole ich es nur noch ganz kurz.
Also wir haben hier immer den Zustand aktuell ABCD.
Und wir haben ja gesagt, wir fangen zunächst mit symbolischen
Zuständen an.
Also ABCD ist ja, glaube ich, ganz gut.
Wir hatten ja in der Vorlesung davor immer mal wieder 1, 2, 3, 4 oder
irgendwas.
Da habe ich ja gesagt, das ist vielleicht verwirrend.
Hier haben wir jetzt wirklich symbolische Zustände, die einfach
alphanumerisch bezeichnet sind.
Und von denen gehen wir jetzt aus.
Und jetzt lege ich in einem Zustand ein bestimmtes X1, X2 an.
Also ich lese das von rechts wieder.
X1, X2 lege ich jetzt hier an.
Und dann springe ich praktisch in diesen neuen Zustand und gebe dabei
das entsprechende Y aus.
Und ich glaube, das müssen wir nicht weiter diskutieren.
Das ist ja ziemlich klar, wenn man diesen Grafen hat, dass wir dann
entsprechend auf diese Tabelle kommen.
Jetzt ist die Frage, was müssen wir noch machen?
Jetzt haben wir ja eine rein symbolische Darstellung des Zustandes.
Und das reicht uns ja nicht.
Wir wollen ja eine numerische, am besten in einer Dualzahlenform.
Das heißt also, wir müssen jetzt diese vier Zustände durch eine
Dualzahl darstellen.
Und das heißt, das müssen wir auch nicht groß durchgehen.
Der Mindestzahl der Flipflops ist jetzt zwei.
Wir brauchen also zwei Flipflops, um vier Zustände darzustellen.
Jedes kann 0 oder 1 darstellen.
Und jetzt nehmen wir also binäre Zustandsvariable Z1 und Z2.
Und jetzt haben wir hier eine willkürliche Zuordnung.
Und wir haben ja schon mal über Wettläufe gesprochen.
Das müssen wir also gar nicht wiederholen.
Hier ist jetzt also eine eindeutige, aber willkürliche Zuordnung, dass
wir das so machen.
Also das wäre der Zustand A, B, C und D.
Wenn wir die jetzt haben, dann können wir jetzt die gleichen Übergänge
nochmal betrachten.
Wir können jetzt also sagen, wir haben jetzt hier die Eingabe.
Das sind also die Eingaben.
Das sind die Zustände zum aktuellen Zeitpunkt.
Und die haben wir jetzt eben als eine Dualzahl codiert.
Und dann gehen wir zu einem Zustand zum nächsten Zeitpunkt, zu dem wir
hinspringen.
Und jetzt ist natürlich die Frage, wir haben ja gesagt, wir wollen
diese JK-Flipflops nehmen.
Was muss ich mit denen machen?
Um zum Beispiel hier in dem Zustand zu bleiben.
Hier in dem Zustand zu bleiben.
Hier von 1 auf 0 zu gehen.
Hier von 0 auf 1 zu gehen und so weiter.
Sie erinnern sich, dieses spezielle Flipflop funktioniert so, dass wir
den J-Eingang haben.
Der setzt.
Der K-Eingang setzt zurück.
Wenn ich J und K gleich einsetze, was bei manchen anderen Flipflops
verboten war, dann wird einfach getoggelt.
Das nutzen wir noch nicht mal hier.
Das heißt also, wir wollen einfach nur diese Zustandstransitionen hier
durchführen.
Also das sind eben die beiden Flipflops.
Und wir wollen praktisch von dem Zustand zu diesem Zustand kommen.
Und das können wir jetzt ja...
Ah, das ist ein bisschen langwierig hier animiert, aber ist ja
ziemlich klar.
Also hier muss ich, wenn sich nichts tut, muss ich sozusagen den J
-Eingang, den Setz-Eingang auf 0 lassen.
Was für den anderen Eingang kommt, ist egal.
Dann muss ich aber hier was setzen.
Hier setze ich jetzt ja von 0 nach 1.
Dann muss ich J2 setzen, weil Z2 1 wird und so weiter.
Ich glaube, es sei denn, wenn es jetzt eine Frage gibt, können wir da
glaube ich ziemlich schnell durchgehen.
Das heißt also, wir müssen entweder rücksetzen oder setzen, aber
jeweils der andere Eingang ist uns egal.
Das heißt, da haben wir Freiheitsgrade, wenn wir jetzt den Entwurf
machen, die entsprechende Ansteuerung machen, dann haben wir da
entsprechende Freiheitsgrade.
Und jetzt das gleiche für Z1.
Und das gehe ich jetzt auch ganz schnell durch.
Hier müssen wir nichts tun.
Also K1 muss nichts machen.
Hier muss rückgesetzt werden von 1 auf 0.
Dann kriegen wir hier eine 1 und ich glaube, da können wir jetzt ganz
schnell durchgehen.
Bekommen wir also die entsprechende Tabelle und wir sehen, wir haben
hier ziemlich viele solche Wildcard-Symbole.
Das heißt, wo wir einfach nichts machen müssen.
Und die können wir jetzt gleich nutzen.
Das heißt, wir werden jetzt dann gleich von der codierten
Ablauftabelle, wie sozusagen dieses Schaltwerk arbeitet, kommen wir
jetzt dann zu den Ansteuerfunktionen.
Und hier müssen wir glaube ich auch nicht lange darüber diskutieren,
es gibt eine Frage.
Wir haben jetzt halt hier die entsprechenden Einser und Nuller, hier
die entsprechenden Wildcards und jetzt können wir halt versuchen, hier
zusammenzufassen.
Und wir wollen natürlich wieder in dem KV-Diagramm den größtmöglichen
Einserblock zusammenfassen.
Na gut, das kriegen wir dann hin, wenn wir hier eine 1 verfügen.
Wir haben ja gesagt, wenn wir sozusagen Wildcards haben, dann verfügen
wir entsprechend.
Und viel mehr können wir auch nicht machen.
Also das können wir nicht zusammenfassen, dies hier können wir nicht
zusammenfassen.
Das heißt, das ist das Größte, was wir tun können.
Na gut, und das ist entweder so oder so dargestellt.
Also wir bekommen raus, Z1 oder X1 oder X2 nicht.
Okay, für K2 das gleiche Spielchen, müssen wir auch entsprechend
verfügen.
Hier wird es ein bisschen komplizierter, haben wir eine entsprechende
Verfügung, bekommen dieses Ergebnis raus.
Und dann für das Flipflop 1 haben wir natürlich auch die entsprechende
Ansteuerfunktion.
So, und jetzt beim Mili-Automaten haben wir die Besonderheit, dass wir
noch ein Y haben.
Wir müssen also noch ein Y festlegen, nicht nur die Ansteuerfunktion.
Es ist also nicht so, dass es nur eben aus dem Zustand kommt, sondern
wir kommen auch direkt in den Ausgang.
Und das heißt, wir können hier diese Ausgabefunktion festlegen.
Na gut, das ist auch ziemlich einfach, dass wir hier dann eben
zusammenfassen und bekommen diese Ausgabefunktion.
So, und hier ist es.
Ja, das ist jetzt das Schaltwerk, was wir bekommen.
Und ich denke, das ist eigentlich schon eine ganz schöne Sache.
Wir bekommen also ein elegantes Schaltwerk raus.
Wir nehmen also zwei JK-Flipflops, haben die entsprechenden
Ansteuerfunktionen, die wir gerade optimiert haben.
Und Sie sehen, wir haben natürlich auch die entsprechenden
Rückkopplungen und bekommen jetzt so einen Folgenerkenner in Hardware
realisiert.
Hier ist der Takteingang und hier sind die beiden Eingänge X1, X2.
Also X1, wo sozusagen die Folge angelegt wird, und X2, was sozusagen
zum Terminieren dient.
Und das Y gibt uns sozusagen immer das Signal, ob die Folge
eingelaufen ist.
Gibt es Fragen soweit?
Okay, dann das als kleine Wiederholung.
Und das war also jetzt dieser Folgenerkenner mit allem Drum und Dran.
Das heißt, wir haben das jetzt mal komplett durchgespielt.
Und da sollten Sie jetzt also in der Lage sein, so etwas auch selber
zu machen.
Jetzt kommen wir zu speziellen Schaltwerkbausteinen.
Und zwar Register, Schieberegister, Zähler und programmierbare
Bausteine.
Und bei den programmierbaren Bausteinen kann ich es wahrscheinlich ein
bisschen kürzer machen, weil das ist etwas, was Sie sich dann selber
durchlesen können.
Aber die ersten drei Dinge, die wollen wir nochmal in Ruhe gemeinsam
durchschauen.
Und zwar, wir können jetzt bei solchen Schaltwerken, ganz ähnlich wie
bei den Schaltnetzen, also bei den kombinatorischen Schaltungen,
können wir jetzt komplexe Bausteine aus elementaren Elementen
zusammensetzen.
Das haben wir ja da schon gelernt, dass wir das machen können.
Und genau das wollen wir jetzt hier auch wieder aufgreifen.
Das heißt also, fangen wir mal an mit Registern.
Ein Register ist ja nichts anderes, als dass ich einen Wert speichere.
Und das kann ich natürlich ganz einfach machen, indem ich einfach eine
Anzahl von D-Flipflops zum Beispiel, das sind ja die einfachsten, die
wir kennengelernt haben, indem ich einfach eine Anzahl von D-Flipflops
habe und die einfach lade und damit den Wert speichere.
Das wäre so ein ganz simples Register-File.
Das heißt, wir haben eine lineare Anordnung von Flipflops und die
sollen einfach mehrere Bits speichern, und wir haben einen gemeinsamen
Takt, das ist also synchron.
Und das einfachste Register, wie gerade gesagt, wären eben jetzt
einfach unverkoppelt nebeneinander gesetzte D-Flipflops, das kann man
machen.
Aber typischerweise haben wir natürlich noch Steuersignale.
Wir wollen ja irgendwie gemeinsam an diese Flipflops ran, entweder die
enablen oder den Takt angeben oder irgendwas.
Das heißt also, wir werden gemeinsame Steuersignale haben.
Okay, und wenn ich jetzt mal so einen Baustein habe, hier ist der
dargestellt, so wird der Baustein aussehen.
Ich habe hier also die Möglichkeit, parallel vier Bit anzulegen.
Hier werden vier Bit ausgelesen.
Ich habe hier einen Takt, und zwar flankengesteuert, und ich habe
einen Enable-Eingang.
Und das kann man sich jetzt hier so vorstellen.
Ich habe also hier das Enable.
Klar, das ist einfach eine Verundung von den Eingängen und dem Enable.
Und dann habe ich hier jeweils einen Takt, der hier auf diese
Taktflankensteuerung geht.
Und nur wenn das Enable gleich 1 ist, werden die Daten übernommen.
Also das ist, glaube ich, ziemlich einfach.
Das wäre also die einfachste Möglichkeit, so ein 4-Bit-Register aus D
-Flipflops zusammenzubauen.
Okay, dann gibt es Schieberegister.
Schieberegister sind schon nicht mehr ganz so einfach.
Und auch wichtig.
Was machen wir da?
Wir haben eine Kette von Registern, die in Reihe geschaltet sind.
Und jeweils der Ausgang ist mit dem Eingang des nächsten verbunden.
Und was wir also machen wollen ist, man sieht das hier an dem
Schaltsymbol.
Diese Schaltsymbole sind da vielleicht sogar ganz erhellend.
Ja, wir legen hier einfach einen Wert an, hier den Takt, und dann
takten wir den Wert oder die Werte einfach in das Schieberegister
rein.
Und das heißt, hier können wir vier Werte eintakten und dann liegen
die vier Werte, wenn wir sie eingetaktet haben, hier hinten am Ausgang
an.
Und das ist das entsprechende Bildchen dazu, das entsprechende
symbolische Bild dazu, wie das aussehen könnte.
Es muss ja nicht so aussehen.
Ich meine, wenn Sie so einen Baustein kaufen, dann muss der natürlich
nicht so aufgebaut sein.
Hauptsache, er tut das, was dieses Bild suggeriert.
Das heißt, der taktet jetzt hier vorne einen Wert ein, der wird hier
hinten ausgegeben, hier wieder ausgegeben, hier wieder ausgegeben und
dann jeweils hier angezeigt.
Und jetzt kann man natürlich ein paar mehr Sachen machen.
Man kann jetzt mit weiteren Steuereingängen ein paar mehr Sachen
machen, wie zum Beispiel, ich kann parallel eingeben anstatt seriell.
Ich kann rechts und links schieben.
Ich kann die Eingänge verriegeln.
Also es gibt ganz viele Möglichkeiten, was man mit so einem Baustein
machen kann.
Und das ist ein wichtiger Baustein.
Also zum Beispiel hier kann ich jetzt so eine Serienparallelwandlung
machen.
Das heißt also, was wir gerade schon gesehen haben, ein serieller
Bitstrom, der wird hier vorne aufgelegt und dann wird der parallel
hier ausgegeben.
Und dann, wenn das Ding gefüllt ist, dann kann ich die hier abgreifen
oder ich kann sie alle wieder seriell am Ausgang out entnehmen, indem
ich dann wieder raus takte.
Das kann man genauso machen.
Das heißt, ich kann sie reintakten, parallel abgreifen und ich kann
sie reell abgreifen.
Dann kann ich jetzt parallel Serienwandlung durchführen.
Das heißt also, ich lege parallel an, bekomme eine Serie raus.
Ich kann eine Warteschlange definieren, so einen Stapel.
Ich kann das also so machen, dass ich so einen Load-Eingang habe.
Dann schalte ich um auf eine parallele Eingabe.
Dann werden im Prinzip die Daten, die hier anliegen, die werden
parallel eingeladen und liegen dann hier an den entsprechenden
Ausgängen an.
Und dann kann ich jetzt eine Serienparallelwandlung machen.
Das können also diese Bausteine dann problemlos durchführen.
Und das ist ja dann, glaube ich, in dem Schaltbild auch schön zu
erkennen.
Jetzt natürlich etwas, was vielleicht gar nicht so unwichtig ist.
Wir wollen multiplizieren.
Das kommt ja noch.
Wir werden ja vielleicht sogar heute noch anfangen, auch zu rechnen,
Arithmetik zu machen.
Man kann jetzt multiplizieren, und zwar mit dem Faktor 2.
Also ich kann durch 2 teilen, ich kann mit 2 mal nehmen, ich kann mit
2 mal 2 mal 2 mal 2, was auch immer.
Kann ich jetzt mal nehmen.
Warum?
Weil ich einfach rechts schieben oder links schieben kann.
Das heißt also, wenn ich eine Bitfolge als eine Dualzahl
interpretiere, dann kann ich im Prinzip durch rechts und links
schieben, kann ich mit 2 mal nehmen, durch 2 teilen.
Das ist, glaube ich, ziemlich klar.
Und das ist ja hier nochmal gesagt, also hält man Multiplikation mit
2.
Das heißt, ich kann also mit so einem Schieberegister wirklich
rechnen.
Und das wird übrigens auch gemacht.
Damit kann ich sehr effizient natürlich eine Multiplikation
durchführen.
Wir werden auch sehen, Multiplikation ist normalerweise sonst ziemlich
aufwendig mit einer beliebigen Zahl.
Und das kann ich jetzt hier mit 2er Potenzen sehr einfach hinbekommen.
Dann kann ich so einen Umlaufspeicher haben.
Wenn man jetzt den seriellen Ausgang mit dem Eingang verbindet, so wie
es hier gezeigt ist, auch das hier wieder so ein entsprechendes
Blockschaltbild, dann enthält man so einen Umlaufspeicher, einen
Ringzähler.
Und der kann jetzt im Prinzip so eine Bitfolge hier im Kreis laufen
lassen, so wie es hier gezeigt ist.
Das heißt, ich kann das hier jetzt beliebig im Kreis laufen lassen.
Das wäre ein Ringzähler.
Und jetzt gibt es hier so einen konkreten Baustein.
Den kann man auch kaufen in der Form und deswegen zeigen wir den.
Also 74LS194, den können Sie als so einen Baustein kaufen.
Der hat also hier eine parallele Eingabe, parallele Ausgabe, hat
entsprechende Steuereingänge, hat einen Takt und so weiter.
Und jetzt gucken wir uns mal an, was der alles macht.
Also, wir können Daten, die an den vier Paralleleingängen anliegen,
die können wir parallel laden.
Die werden dann seriell übernommen und wir können im Prinzip schieben.
Wir können also alte Registerinhalte entsprechend weiterschieben.
Wir können seriell übernehmen, alte Registerinhalte nach oben schieben
oder über mehrere Takte speichern, wie auch immer.
Und wir können über den Rücksetzeingang, kann man das Schieberegister
jetzt auch asynchron rücksetzen.
Das heißt also, wir können jederzeit auf null setzen.
Und dann gibt es da entsprechend diese Betriebsarten.
Und gut, ich glaube, da muss man jetzt nicht im Detail durchgehen.
Aber wir haben im Prinzip hier diese Ms, die geben die Betriebsart
vor.
Das R ist der Rücksetzeingang.
Also wenn R gleich null ist, also R quer gleich null ist, dann wird
rückgesetzt, sieht man hier.
Und dann haben wir noch den Takt und mit der steigenden Taktflanke
werden die Daten übernommen, was man hier sieht.
Werden die Daten eben übernommen.
Okay, jetzt zum nächsten Thema Zähler.
Zähler, das wird jetzt etwas komplizierter vielleicht.
Da wollen wir uns jetzt mal genau überlegen, wie kann ich eigentlich
einen Zähler definieren?
Wie kann ich das eigentlich machen?
Welche Möglichkeiten gibt es?
Es gibt Synchron-Zähler und es gibt Asynchron-Zähler.
Und wir wollen jetzt erstmal mit Synchron-Zählern anfangen und dann
kommen wir zu den Asynchronen.
Klar, man will Impulse abzählen und man möchte natürlich, wenn man
jetzt so einen Befehlszähler hat, möchte man aufeinanderfolgende
Adressen im Speicher adressieren.
Dafür ist ein Zähler gut.
Man kann im Prinzip Frequenzteile definieren.
Das heißt also, wir bekommen einfach eine Impulsfolge und teilen die
runter in der Frequenz.
Und jetzt kann man das also so verwenden, dass man sagt, wenn das Bit
i einer Zahl sich nur 2 hoch minus i mal so oft ändert, wenn ich also
jetzt hochzähle, ist ja klar, das letzte Bit ändert sich sehr schnell,
das zweite Bit ändert sich langsamer usw.
Das heißt, damit kann ich die Frequenz runter teilen.
Das möchte man also nutzen, dass man also so einen Frequenzteiler
definiert.
Und wir haben so ein grundlegendes Übergangsdiagramm.
Und zwar, wir starten in dem Zustand Z0, wie auch immer der jetzt
geartet ist, laufen dann los Z1 usw.
bis Zn-2, Zn-1 und dann, wenn wir einen Zähler haben, der sozusagen
umläuft, dann kommen wir wieder in Z0 zurück.
Das heißt also, der läuft einfach modulo im Kreis.
Das heißt also, wir könnten jetzt Sätze oder Rücksätzeingänge haben,
wir können Freigabeeingänge haben usw.
Wir können vorwärts, rückwärts zählen und in dieser Grundstruktur, die
ich gerade gezeigt habe, dann könnte eben so ein Modulo-N-Zähler
vorliegen, der einfach immer wieder im Kreis zählt.
Und wenn die Zustände dual codiert sind, das nehmen wir jetzt hier mal
an, haben wir einen Dual-Zähler und wenn wir N gleich 2 auch M haben,
dann haben wir einen M-stelligen Zähler.
Das sind also mal so die grundlegenden Voraussetzungen.
Schallsymbole.
Was für Schallsymbole haben wir denn für Zähler?
Wir haben jetzt für einen M-stelligen Zähler, da schreiben wir einfach
hin, Counter M und hier vorne legen wir das Taktsignal an und der
zählt uns hier hinten sozusagen hoch, was wir hier an Takten anlegen.
Das heißt, der zählt einfach die ganze Zeit hoch.
Hier ist noch kein Rücksetzeingang oder irgendwas.
Und hier bei dem ist es jetzt so, dass wir Modulo zählen, das heißt
also, dass der bei N umklappt.
Das heißt also immer wieder umläuft und dann können wir natürlich
jetzt, wie gesagt, noch mehr Eingänge haben.
Rücksetzeingänge, Setzeingänge, was auch immer.
Jetzt schauen wir uns mal an einen synchronen, dreistelligen Dual
-Zähler.
Wie sieht denn der aus?
Und zwar, da kommen wir gleich drauf, wir werden jetzt, wenn wir D
-Flipflops nehmen, werden wir jetzt entsprechende Ansteuerung
vornehmen.
Wir werden also entsprechend ansteuern, das D0, also das erste
Flipflop oder das Nullte, wird mit Z0 quer angesteuert, das erste so,
das zweite so und so weiter.
Das werden wir gleich mal herleiten, warum das so ist.
Aber was Sie jetzt schon mal sehen ist, dass sozusagen die Komplexität
der Ansteuerung, die nimmt einfach zu.
Das heißt also, wenn wir jetzt einen Zähler hätten mit zehn Stellen,
dann würde diese Ansteuertabelle enorm kompliziert.
Das sehen wir jetzt schon mal.
Jetzt schauen wir uns mal an, wie müsste denn überhaupt so ein
Netzwerk aussehen, wenn wir D-Flipflops hätten.
Und das sieht jetzt folgendermaßen aus.
Wir haben jetzt hier mal drei solche D-Flipflops.
Die müssen wir jetzt irgendwie ansteuern.
Und die Frage ist halt, wir haben ja hier so einen Taktflankeneingang
bei denen und das haben wir immer so gekennzeichnet mit C1.
Und dann haben wir jetzt einen Takt.
Der Takt liegt also jetzt hier an.
Liegt also hier an, das wäre der Takt.
Und jetzt haben wir dann noch einen Eingang D0, wir haben Eingang D1
und wir haben Eingang D2.
Und der Witz ist jetzt eben, wir müssen jetzt mal herleiten und
darüber denken Sie jetzt mal scharf nach, weil das ist sozusagen
gleich meine nächste Frage.
Wie müssen denn jetzt eigentlich diese Eingänge, D0, D1, D2, wie
müssen die eigentlich jetzt beschaffen sein, sodass das Ding wirklich
zählt.
Was wir doch jetzt haben wollen ist, dass wenn wir jetzt bei 0
anfangen und ich bekomme hier unten Takte.
Das heißt, ich bekomme hier unten immer so Taktflanken, dann soll der
doch jetzt hochzählen.
Also das heißt, kommt natürlich noch der Ausgang, den habe ich jetzt
noch nicht reingezeichnet.
Der Ausgang soll doch jetzt im Prinzip 0, 0, 0, 1, 0, 0 und so weiter.
Sollte doch dual hochzählen.
Und wie kriegen wir das hin?
Denken Sie mal scharf nach.
Also wir haben also hier den Ausgang und wir haben jetzt hier Z0, Z1
und Z2.
Was müssen wir denn prinzipiell machen, damit das Ding überhaupt
zählt?
Ich meine, so zählt er ja offenbar noch nicht.
So macht er ja noch gar nichts.
Was müssen wir denn tun, damit er zählt?
Das ist eine Idee.
Der Takt liegt ja schon an.
Das heißt, alles ist bestens.
Das heißt, wir haben hier diese D-Flip-Flops, der Takt liegt an und
immer wenn wir hier was anlegen wollen, aber es liegt ja noch frei,
immer wenn wir hier jetzt was anlegen würden, würde ja beim D-Flip
-Flop bei jedem steigenden Takt, würde der Wert übernommen.
Das heißt also, wenn ich jetzt hier bei D0 eine 1 anlege, der Takt
steigt, also wir haben die Flanke, dann würde das übernommen.
Wie mache ich denn jetzt, dass das Ding zählt?
Das brauche ich erstmal als ganz grundlegendes Konstrukt.
Das wäre mal das Wichtigste, was wir jetzt sagen können.
Das brauche ich als ganz grundlegendes Konstrukt.
Wir sind ja bei einem Schaltwerk.
Ja.
Genau.
Exakt.
Das ist genau das, was wir brauchen.
Wir brauchen also jetzt ein Feedback von Z0, Z1, Z2 auf D0, D1, D2.
Und das ist auch gar nicht so schwierig zu sehen, aber deswegen
verrate ich es Ihnen erstmal nicht, damit Sie mal selbst drauf kommen,
weil wenn ich es Ihnen hinschreibe, sagen Sie, das ist ja total
einfach, deswegen sage ich es Ihnen erstmal nicht.
Kommen Sie mal selber drauf, was muss ich denn tun?
Und vor allem, was ist das Schöne bei der Schaltung?
Sie hat nämlich jetzt eine ganz witzige Art des Entwerfens, die man
normalerweise vielleicht nicht hat.
Ich muss nämlich nicht alles auf einmal entwerfen, sondern was muss
ich machen?
Sieht man gleich.
Ich gebe Ihnen mal einen Tipp.
Wie muss Z0 sich verhalten, wenn ich T anlege?
T kommt jetzt sozusagen, ja, immer Pulse.
T kommen immer solche Pulse.
Was wird mit Z0 passieren?
Ich zähle auf Sie.
Was wird mit Z0 passieren, wenn T jetzt in seiner Pulsfolge kommt?
Ja, aber das wollen Sie ja designen.
Der Witz ist ja, das D0 wollen wir jetzt ja angeben, aber was erwarten
Sie denn für Z0, was passieren wird?
Was muss für Z0 passieren?
Genau, der muss einfach mit dem Takt wechseln.
Genau, das heißt also, Z0, Takt wird einfach mit, geht ja nicht
anders.
Weil wenn ich jetzt eine Dualzahl anschaue, ich habe eine Dualzahl,
die hat auch in der letzten Stelle immer 010101 und so weiter.
Ja, aber jetzt kommt die zweite Stelle.
In der zweiten Stelle steht ja 00110011.
Ja, und in der dritten Stelle steht dann 0000111 und so weiter.
Ja, das heißt also, wir müssen genau das hinbekommen.
Also eigentlich das simpelste System, was man jetzt entwerfen kann,
aber so trivial ist es eben trotzdem nicht.
Das heißt, wir müssen jetzt auf D0 so zurückkoppeln, dass Z0 ständig
toggelt bei jedem Takt.
Das kriegen wir noch hin.
Z1 muss bei jedem zweiten Takt toggeln.
Und Z2 muss bei jedem vierten Takt eben toggeln.
Also einfach zweier Potenzen.
Das schauen wir uns jetzt mal an.
Wir machen jetzt mal die Herleitung.
Dafür...
Also, das heißt, für den ersten Schritt.
Ja, wenn wir jetzt haben Z0 und wir wollen für Z0 D0 haben.
Dann können wir also sagen, wenn das 0 und das 1 ist, dann wollen wir
hier eine 1 und eine 0.
Wir wollen also einfach toggeln.
Und wir können also sagen, dass D0 einfach Z0 quer ist.
Wir können den Zähler auch anders definieren, aber so ist es bestimmt
eine ganz vernünftige Art, den Zähler zu definieren.
Das heißt also, die letzte Stelle, das least significant bit, toggelt
einfach immer hin und her.
Und jetzt können wir uns überlegen, was passiert mit dem zweiten.
Bei dem zweiten, und deswegen habe ich ja gesagt, wir können das jetzt
sozusagen unabhängig entwerfen, dann haben wir jetzt Z1 und Z0.
Und wir haben noch D1.
Und was muss jetzt passieren?
Jetzt haben wir ja wohl 0, 1, 0, 1.
Hier haben wir 0, 0, 1, 1.
Und für D1 muss jetzt folgendes passieren.
Wenn ich jetzt hier eine 1 habe, werde ich wohl hier eine 0 haben.
Und dann zählt der auch.
Das heißt, ich muss ja eine Dualzahl hochzählen.
Das heißt, was muss ich jetzt hier bekommen?
0, 1, 1, 0.
Weil wenn ich zwei Einser habe, dann geht der wieder auf 0 und die
nächste Stelle zählt auch.
Das heißt, so kann ich meinen entsprechenden Zähler realisieren.
Und hier kann ich jetzt einfach sagen, ja, was ist D1 eigentlich?
Sehen Sie das?
Was ist D1?
Ja?
Genau.
Das ist eine Antivalenz.
Wir können es auch mal so hinschreiben.
Das heißt, wir haben also Z1, Z0 quer oder Z1, Z0 quer.
Genau.
Das heißt, jetzt haben wir schon mal den Fall Nummer 2.
Und jetzt kommt Fall Nummer 3.
Fall Nummer 3 bedeutet, wir nehmen alle drei Bits mit.
Und dann haben wir also Z2, Z1, Z0 und wir wollen dann D2 haben.
Und jetzt wird es schon etwas weniger lustig.
Also wir zählen da hinten am schnellsten durch.
0,1, 0,1, 0,1, 0,1.
Da zählen wir am schnellsten durch.
Dann hier vorne zählen wir natürlich am zweitschnellsten durch.
Und dann hier hinten am langsamsten.
So, und jetzt ist wieder die Frage, wir müssen ja jetzt, wenn
praktisch dreimal vergangen ist, dann zählen wir praktisch auf die 1
hoch.
Das heißt, wir müssen hier also drei Nuller haben, kommen dann auf die
1, bekommen dann entsprechende Einser und gehen dann wieder auf die
Null zurück.
Weil dann klappt der Zähler wieder um.
Also wenn wir wollen, dass der Zähler wieder umklappt.
Sonst könnte man dann natürlich auch einfach stehen bleiben.
Das heißt also, das wäre unser Zähler.
Wir haben also vier Nuller, vier Einser und drei Nuller kommen erst,
dann vier Einser und dann wieder die Null.
So, und jetzt können wir das ja optimieren.
Und da jetzt als kleine Übung machen wir jetzt mal das Ganze mit dem
KV -Diagramm.
Und zwar...
Was haben wir denn da?
Wir können doch jetzt in dem KV-Diagramm, können wir jetzt mal
eintragen, wir haben hier Z0, das ist ja beliebig, aber ich habe jetzt
hier immer Z0 genommen, hier Z1 und hier Z2.
So, und dann können wir jetzt mal eintragen, das habe ich jetzt so
gemacht, dass ich hier auch nochmal eingetragen habe.
0, 1, 2, 3,
4, 5, 6, 7.
So, und dann trage ich die jetzt mal ein.
Das heißt, wir haben jetzt hier entsprechend Nuller und dann hier
Ja, und jetzt können wir mal überlegen, wie wir das zusammenfassen
können.
Wie wollen wir denn das optimieren?
Wir wollen ja jetzt wieder sozusagen die kleinstmögliche
Darstellungsform haben.
Und dann können wir sagen, dass wir zum Beispiel das so
zusammenfassen.
So, so und so.
Ja, und dann hätten wir eben das D2.
Das wäre jetzt...
Ich fange wieder von rechts an zu schreiben, also das wäre Z0, Z1, Z2
nicht.
Das wäre sozusagen der komplizierteste Term.
Das wäre der hier.
Und dann kommen noch ein paar einfachere Terme, nämlich Z2, Z1 nicht
und Z2, Z0 nicht.
Das wäre jetzt also der entsprechende Zähler.
Das heißt, wir würden die Eingänge mit den Ausgängen so beaufschlagen,
dass wir also ein Feedback haben und dass wir damit zählen können.
Ja, und das wäre jetzt die entsprechende Herleitung.
Also das wird natürlich, wie Sie sehen, immer komplizierter.
Das ist ja gerade schon mal vorhergesagt, dass das also immer
komplizierter wird.
Also wenn Sie 4, 5 oder was weiß ich oder 100 Bit zählen möchten,
können Sie es so nicht machen.
Da müssen wir also gleich nochmal dazu kommen, wie man das dann macht.
Und so sieht es dann aus.
Und das ist ja noch relativ überschaubar.
Wir haben also hier den Reset-Eingang, haben hier diese entsprechenden
Flipflops und Sie sehen, der erste Eingang, D0, der ist noch ziemlich
simpel.
Und die anderen Eingänge, D1 und D2, die werden jetzt also rasant
komplizierter.
Und das heißt, wir werden hier, ich würde mal sagen, so eine lineare
Anzahl von Termen haben.
Das heißt also, das wird man nicht lange durchhalten, um so einen
Zähler zu definieren.
Gibt es Fragen soweit?
Aber jetzt haben wir immerhin einen Synchron-Zähler definiert, der
funktioniert und entsprechende Flipflops nutzt.
Also wir hatten ja gerade diesen synchronen, dreistelligen Dual-Zähler
gesehen.
Und ich hoffe, Sie sehen ein, was der Vorteil ist, dass wir jetzt hier
wirklich synchron zählen.
Und was der Nachteil ist, dass wir, ja Sie sehen schon, wie wir uns
verrenkt haben bei 3-Bit.
Überlegen Sie mal, wir müssten 8-Bit machen.
Das ist eigentlich fast nicht mehr machbar.
Weil die Ansteuerlogik einfach von links nach rechts, so wie ich es
jetzt hier hingemalt habe, das heißt also von den LSBs zu den MSBs,
einfach immer größer wird.
Ich denke, das ist klar.
Und jetzt kann man sich überlegen, was macht man jetzt?
Wir könnten natürlich sagen, statt synchronen Zählern nehmen wir jetzt
asynchrone Zähler, sogenannte Ripple-Counter.
Und da haben wir das Problem eben nicht, dass das so stark ansteigt.
Und das sieht jetzt folgendermaßen aus.
Und jetzt sehen Sie den Unterschied.
Der Takt wird jetzt hier nur an das erste Element angelegt, an das
erste Flip-Flop angelegt.
Dann bekommen wir ein Ausgangssignal.
Das Ausgangssignal wird an das nächste angelegt und so weiter.
Naja, und was passiert?
Wir haben natürlich eine Verzögerung.
Das heißt also immer, wenn wir jetzt einen Takt anlegen, der Takt wird
sozusagen nur an das erste Element angelegt, dann wird der Takt
verzögert und verzögert und verzögert.
Aber asynchrone Zähler sind schon attraktiv, weil ich kann jetzt im
Grunde genommen hiermit einen 100-Bit-Zähler sofort realisieren und
ich habe kein Problem damit.
Währenddessen davor, was wir gerade gesagt haben, das können wir gar
nicht.
Das ist unmöglich.
Das wäre viel zu aufwendig.
Das heißt also, das hier wäre, da müssen wir gar nicht groß
nachdenken, wäre das schon mal ein asynchroner, dreistelliger Dual
-Zähler.
Da sehen Sie mal, wie einfach der plötzlich ist.
Sehen Sie, wie er funktioniert?
Wir führen praktisch immer zurück.
Hier auch beim letzten wieder zurück auf den entsprechenden Eingang
und damit zählt er bei jedem Takt einfach entsprechend hoch.
Und es wird nach hinten immer langsamer.
Hier vorne wird bei jedem Takt sozusagen getoggelt.
Dann jedes zweite Mal, dann jedes vierte Mal und so weiter.
Und genau das macht er auch.
Also das heißt, so kann man asynchrone Zähler sehr viel einfacher
realisieren, aber mit dem Problem der Zeitverzögerung.
Das haben wir ja schon diskutiert.
Und jetzt können wir das mal einzeichnen.
Wie funktioniert der eigentlich?
Wenn man sich den mal anguckt, was macht der eigentlich genau?
Malen wir es mal hin.
Wir haben jetzt hier den Takt.
Hier kommt der Takt rein.
Das wäre T.
Und jetzt wollen wir ja zählen.
Das bedeutet, wir wollen bei Z0, Z1, Z2 die entsprechende Dualzahl
herausbekommen.
Also Z0 soll sozusagen am schnellsten toggeln.
Z1 am zweitschnellsten und so weiter.
Jetzt versuche ich das mal einzuzeichnen.
Ob meine Zeichenkünste reichen dafür?
Das heißt also, was wird denn wohl passieren?
Das heißt, wir haben hier auf jeden Fall mal Z0.
Ich hoffe, ich mache das richtig.
Korrigieren Sie mich, wenn es nicht stimmt.
Das wäre jetzt hier Z0.
Und Z0 wechselt praktisch bei der entsprechenden Flanke hier.
Da wird gewechselt.
Habe ich das jetzt überhaupt richtig gemacht?
Das muss ich mal mitzählen hier.
Ja, das stimmt auch.
Also wie gesagt, kontrollieren Sie, was ich mache.
Hier vorne sieht man immer noch viel schlechter, was man tut, als was
Sie von hinten sehen.
Das müsste eigentlich passen.
Das wäre jetzt der Takt Z0.
Jetzt Z1.
Z1 müsste jetzt halb so schnell sein.
Das heißt, ich gehe erstmal bis hier hin.
Gehe dann hoch.
Gehe bis hier hin.
Gehe dann runter.
Hier hin, hoch, hier hin, runter.
Das heißt, wir haben hier nur zwei Flanken.
Diese und diese.
Doch alles richtig?
Und dann, das wäre Z1.
Ah ja, und Z2 muss jetzt nochmal halb so schnell sein.
Das heißt, ich muss jetzt eigentlich gehen bis hier hin.
Ich hoffe, ich treffe jetzt immer die richtigen Flanken.
Und dann bis hier hin.
Und dann haben wir sozusagen unseren 3-Bit-Counter auch erschöpft.
Ja, hier hinten haben wir jetzt sozusagen diesen gemeinsamen Abfall.
Ja, das ist richtig.
Das heißt also, wenn Sie jetzt mal gucken, Sie gehen an eine bestimmte
Stelle hin und wollen zum Beispiel wissen, wie viel habe ich jetzt bis
hier hin gezählt.
Das heißt, ich habe bis hier hin zwei Stück gesehen.
Ich sehe den ersten und ich sehe den zweiten.
An der Stelle habe ich also 0, 1, 0.
Das sind zwei.
Also das heißt, das stimmt.
Ich kann jetzt an jeder Stelle einfach gucken, im Binärformat, als
Dualzahl, wie viele Pulse habe ich bis dahin schon gesehen.
Das heißt also, das kann diese asynchrone Zähle.
Okay.
Das Problem ist jetzt, dass natürlich diese Schaltung langsamer ist
als die Synchrone, da jedes Flip-Flop jetzt natürlich einfach diese
Laufzeit hat.
Wir haben ja über Laufzeiten gesprochen.
Ja, jedes Flip-Flop hat jetzt diese Laufzeit.
Und wenn ich jetzt 10 Bit zum Beispiel zähle, dann muss das ja erst
einmal ganz durch.
Ja, das heißt also, ich habe diese Laufzeit mal die Anzahl der Bit.
Und das ist natürlich schlecht.
Und das Problem ist natürlich auch noch, die Ausgänge von der
Schaltung, die ändern sich nicht gleichzeitig.
Das heißt also, das Z0, das liegt schon an, während das Z1 noch gerade
berechnet wird.
Das will man eigentlich nicht.
Das heißt also, diese Schaltung ist träge.
Und ich kann nicht einfach dieses jetzt an eine nachfolgende Schaltung
weitergeben.
Ganz klar.
Also, das heißt, das Problem ist jetzt, jetzt sind wir in der
Zweckmühle.
Wenn wir eine größere Stellenanzahl haben wollen, sind die
Asynchronzähler zu langsam.
Die können eben keine 24 Bit zählen mit dem Asynchronzähler, weil das
einfach zu lange dauert.
Ein Synchronzähler mit 24 Bit ist zu aufwendig.
So, und jetzt kann man folgendes machen.
Man kann jetzt, ja, Sie kennen das ja wahrscheinlich, ja, divide and
conquer.
Das heißt, Sie teilen den Zähler in kleinere Einheiten auf,
partitionieren, und diese kleineren Einheiten, das haben wir ja schon
mehrfach diskutiert, die sind dann jeweils synchron, wie auch die
einzelnen Flip-Flops synchron arbeiten, wenn wir in solchen Systemen
arbeiten.
Und diese werden dann asynchron ineinander verkoppelt, ineinander
verschaltet.
Und das ist vernünftig.
Okay.
Fragen bis hierhin.
Okay, also die Frage ist, wenn die Takte nicht synchron kommen, die
Takte sind also nicht äquidistant, das würde genauso funktionieren.
Ich sehe jetzt kein Problem bei der Schaltung, dass die Schaltung das
nicht genauso kann, wenn die jetzt irgendwie beliebig kommen.
Das heißt, ich kann auch etwas nicht Äquidistantes in der Zeit vorne
eingeben, und er würde mir das trotzdem zählen.
Ja, weil es ja immer nur um die Flanken geht, die gezählt werden.
Genau.
Okay.
Partitionierung ist klar.
Ja,
diese Sache, was wir gerade gesagt haben, dass man im Prinzip sagt,
man hat so kleinere Teilzähler, die werden jetzt asynchron miteinander
verschaltet oder verkoppelt.
Das ist klar.
Okay, dann kommen wir jetzt zu programmierbaren Bausteinen.
Da habe ich ja gesagt, das werde ich jetzt etwas schneller machen.
Weil das Problem ist, das ist eigentlich etwas, was Sie sich zu Hause
selber durchlesen sollten.
Das ist für mich in der Vorlesung frustrierend, so etwas zu erzählen.
Deswegen gehen wir da jetzt ganz schnell durch.
Wir sagen jetzt mal, es gibt verschiedene Arten von Bausteinen.
Es gibt diese MPGAs, das sind Maskenprogrammierbare oder Mask
Programmable Gate Arrays, MPGAs oder eben diese ASICs, Application
Specific Gate Arrays.
Die können Sie jetzt verwenden.
So wie wir Schaltnetze hatten, da haben wir einiges kennengelernt,
können wir jetzt auch Schaltwerke entsprechend programmieren.
Nur, ich glaube, wir sollten da jetzt nicht zu detailliert durchgehen,
sondern das sollten Sie sich selber mal anschauen.
Zum Beispiel, wenn Sie jetzt so ein NAND-Gatter haben, was hier
dargestellt ist, dann könnten Sie das im Prinzip, Sie haben hier so
Eingangsschienen und Sie haben hier so Versorgungsschienen, also das
wäre hier die Stromversorgungsschiene, das wäre hier die Masseschiene,
Ground, und Sie könnten im Prinzip jetzt hier über Ihre
Versorgungsschienen, das wäre jetzt N1 und N2, das wäre also A und B,
würden Sie jetzt hier N-Transistoren und P-Transistoren verknüpfen.
Aber das ist so klar, das muss ich Ihnen, glaube ich, jetzt nicht
erklären, dass man das machen kann, das wird sozusagen ab Werk
gemacht, das heißt, im Werk werden da entsprechende Masten aufgelegt,
die verknüpfen jetzt hier zum Beispiel hier diesen Out-Ausgang, Out
wäre jetzt das Y.
Da ist, glaube ich, ziemlich klar, dass man jetzt hier diese P
-Transistoren und N-Transistoren entsprechend verknüpfen kann.
Also das heißt, wir haben so mehrere Reihen von N- und P-Transistoren,
die können wir jetzt miteinander verbinden und diese
Verbindungskanäle, die werden ab Werk festgelegt.
Der Hersteller gibt das vor.
Also ich gehe da jetzt mal flott durch.
Wie gesagt, unterbrechen Sie mich einfach, wenn irgendwelche Fragen
sind.
Aber ich glaube, das können Sie sich wirklich selber durchlesen, das
ist einfach, so ein bisschen totes Wissen, das können Sie sich selber
durchschauen.
Kann man für große Schaltungen verwenden, längere Fertigungszeiten ist
klar, Sie müssen ja Masken programmieren, höhere Grundkosten, das kann
man nicht für ein Stück machen, sondern das muss für mehrere gemacht
werden.
Und was als Alternative dann kommt, sind eben diese FPGAs, diese Field
Programmable Data Arrays, die man eben selber online programmieren
kann mit einer Hardware-Beschreibungssprache, zum Beispiel VHDL.
Damit kann man die Dinger selber beschreiben und da kommen wir jetzt
vielleicht gleich mal drauf, das wäre so ein FPGA.
Da gibt es jetzt eine Sprache und das ist vielleicht das Wichtigste,
was ich Ihnen heute mitgeben kann.
Sie beschreiben damit Hardware durch eine Beschreibungssprache.
Das heißt also, der Unterschied zwischen Software und Hardware geht
verloren.
Das heißt also, Sie können im Prinzip jetzt so ein FPGA, den können
Sie durch eine Beschreibung wie, als wenn Sie ein C programmieren,
beschreiben Sie jetzt diese Hardware.
Und diese Hardware verhält sich dann auch genau so, wie Sie das
beschrieben haben.
Und das ist das Spannende dabei.
Und ich glaube, viel mehr kann ich Ihnen heute auch gar nicht
vermitteln, weil die Details dazu machen eigentlich gar keinen Sinn.
Klar, Sie haben jetzt so logische Blöcke, Sie haben so
Verdrahtungsmöglichkeiten, Sie haben natürlich so ein Grid, Sie haben
Einausgabezellen, Sie können sogar analoge Bauteile mit auf den FPGA
nehmen und so weiter.
Ich glaube, das macht nicht viel Sinn, das jetzt alles hier zu
diskutieren.
Da schauen Sie sich mal in Ruhe an, wie die genau aufgebaut sind.
Sie haben so gleichartige Grundelemente, so logische Blöcke und wie
gesagt bis hin zu analogen Blöcken und dann wird das programmiert.
Sie haben also eine Beschreibungssprache und damit wird das dann
entsprechend programmiert.
Hier haben wir jetzt mal ein Beispiel Xilinx Xilinx Vertex, aber ich
glaube, da möchte ich jetzt auch nicht so sehr darauf eingehen.
Da haben Sie halt eine ganz bestimmte Architektur, solche logischen
Blöcke und solche Multiplexer und solche Switch Matrices.
Das macht glaube ich jetzt keinen Sinn und hier sieht man jetzt auch,
wie ein so ein inneres Teil aufgebaut ist.
Klar, was ist der Nachteil?
Es ist teurer, als wenn Sie das jetzt irgendwie für große Stück
zahlen, ist es natürlich teurer den FPGA zu verwenden, weil die ASICs
natürlich viel dichter sind.
Das heißt, Sie haben hier eine relativ geringe Geschwindigkeit und
eine geringere Logikdichte.
Aber im Prinzip ist es natürlich schon sinnvoll, das zu verwenden,
wenn Sie jetzt einen Prototypen entwickeln.
Dann können Sie hiermit sehr, sehr schön und viel schneller als
übrigens eine CPU, können Sie hiermit entsprechende Schaltungen
umsetzen.
Okay, also, schauen Sie sich das alles mal durch.
Wir können natürlich weniger FPGAs auf einem Wafer unterbringen,
geringere Ausbeute und so weiter, das ist völlig klar.
Das haben wir ja gerade gesagt.
Und dann so ein Entwurfsprozess, wie läuft der ab?
Sie spezifizieren beispielsweise, Sie wollen eine Kamera auswerten.
Sie haben eine Kamera, wollen die auswerten mithilfe eines FPGAs,
spezifizieren das, führen eine Logikoptimierung durch, Technologie
wird abgebildet auf dem Chip.
Es wird platziert, verdrahtet, verdrahtet natürlich nur per Software.
Und dann werden die Programmierdaten runtergeladen auf den
entsprechenden Chip.
Und da gehen wir jetzt mal schnell durch.
Also, Hardwarebeschreibungssprache, DHTL zum Beispiel.
Und dann wird die Logik optimiert, genauso wie wir es kennengelernt
haben.
Natürlich werden wir da nicht irgendwie mit KV-Diagrammen arbeiten,
sondern das ein bisschen optimaler machen.
Da habe ich Ihnen ja entsprechende Techniken gezeigt.
Technologie wird abgebildet, das heißt also, die Logikblöcke werden
auf die Logikblöcke abgebildet, die das System hergibt.
Dann wird platziert, das heißt also, die entsprechenden Logikblöcke
werden auf dem FPGA platziert, genauso wie wir das auch kennengelernt
hatten.
Dann wird verdrahtet und dann am Ende kommen die Daten für das CAD
-System raus.
Schauen Sie sich das mal an.
Ich denke, das ist etwas, was Sie sich einfach durchlesen können.
Das müssen wir nicht hier diskutieren in der Vorlesung.
Wenn es soweit vielleicht Fragen gibt, kann ich die gerne beantworten.
Sonst würde ich vielleicht zu einem komplizierteren Thema übergehen.
Gibt es Fragen?
Okay.
Dann schlage ich vor, wir machen jetzt noch 15 Minuten und dann werden
wir auf die Evaluierung gehen.
Dann zeige ich Ihnen mal das Ergebnis der Evaluierung und jetzt machen
wir erstmal Rechnerarithmetik.
Also, ein neues Kapitel.
Sie sehen es auch gleich, die Nummerierung fängt auch neu an.
Wir haben das jetzt ganz neu nummeriert.
Das heißt also jetzt Rechnerarithmetik.
Wir werden uns also befassen mit Addition und Subtraktion.
Das wird aber heute nur passieren.
Subtraktion, Multiplikation und so weiter, das wird alles später
kommen.
Wir machen heute eigentlich nur noch die Addition, die letzten 15
Minuten.
Okay.
Wir wollen Grundrechenarten implementieren.
Und zwar, wir wollen wissen, wie eine arithmetische logische Einheit,
also diese ALU, wie die aufgebaut ist, die sozusagen diese ganzen
Operationen integriert.
Und zwar, was brauchen wir dafür?
Wir brauchen Adderer.
Der Adderer wird das wichtigste sein, was wir eigentlich jetzt
kennenlernen werden.
Und ich glaube, in den nächsten 15 Minuten werde ich Ihnen mal ein
paar Adderer zeigen.
Volladderer, Halbadderer und dann natürlich das gleiche wieder, wenn
wir das Ganze asynchron machen.
Das heißt also, synchron, wie gerade auch diskutiert, bei den
Erzählern oder asynchron.
Und dann kommen wir eben zu diesen carry-repl-Adderern oder wenn wir
es dann besser machen wollen, carry-log-ahead.
Also, was wollen wir machen?
Wir wollen Festkommodualzahlen addieren.
Und die sind sozusagen die Grundlage für die Durchführung aller
arithmetischen Verknüpfungen.
Warum?
Subtraktion ist natürlich klar, ist darstellbar durch die Addition.
Eine Multiplikation ist genauso darstellbar durch eine Addition.
Das heißt, wir können im Prinzip durch wiederholte Additionen auch
eine Multiplikation darstellen.
Und so wollen wir es auch machen.
Also, wir werden einen Multiplizierer kennenlernen, der das auch
genauso macht.
Wir wollen das also zurückführen und das ist ein Exponent, die werden
jetzt separat verarbeitet.
Wir wollen ja im Prinzip jetzt hier mit Festkommazahlen, mit
Festkommodualzahlen arbeiten.
Das ist die Idee dabei.
Also, das heißt Grundtypen von Addierern sind wichtig.
So, jetzt fangen wir an mit Voll- und Halbadierern.
Fangen wir nochmal an mit dem Halbadierer.
Ein Halbadierer macht nichts anderes, als dass er zwei Bit addiert.
Das heißt also, wir haben jetzt hier zwei Bit, A und B und A und B
addiert gibt jetzt hier die Summe und da sind wir ja wieder bei dem
gleichen, was wir gerade schon hatten, oder?
Das hier ist
genau.
Wir haben eine Antivalenz.
Das heißt also, die Summe ist eine Antivalenz und der Übertrag
entsprechend, wenn wir zwei Einser haben, kommt hier der Übertrag
zustande.
Das ist ein Halbadierer.
Das heißt also, wir können ein Bit addieren.
Wir wollen aber vielleicht mehr als ein Bit addieren.
Das heißt, wir müssen dann gleich mal gucken, was machen wir denn,
wenn jetzt mehr Bit kommen.
Und das machen wir auch gleich.
Wir haben also jetzt hier erstmal die Gleichung.
Das wäre jetzt ein Halbadierer.
Antivalenz, AB nicht oder A nicht B.
Das wäre sozusagen die Summe.
Diese Teilsumme und dann der Übertrag wäre einfach, was wir gerade
gesehen haben, A und B.
Und das wäre jetzt hier das Schaltbild und das Schaltsymbol von so
einem Ein-Bit-Halbadierer.
Also das wäre hier das Schaltsymbol, das wäre das Schaltbild, wie wir
das Ganze umsetzen.
So, jetzt kommen wir mal zu einem Volladdierer.
Und da will ich Ihnen mal ein paar Sachen einmalen,
dass wir das klar haben.
Die Funktionstabelle ist glaube ich ziemlich klar, oder?
Dass sie so aussehen muss.
Wir nehmen jetzt den Übertrag, den letzten Übertrag hinzu und kommen
auf einen neuen Übertrag.
Das heißt, wir haben hier den Übertrag davor und jetzt den Übertrag
danach als Ergebnis.
Und jetzt können wir ja mal gucken, jetzt nennen wir das mal, wir
nennen das eine mal Propagate Carry.
Das wäre dieser Teil.
Jetzt nennen wir PI.
Das wäre Propagate Carry.
Das heißt also, wir haben jetzt PI Antivalent mit ÜI.
Der Übertrag davor.
Und dann können wir jetzt hier unten noch definieren, dass wir noch so
einen Generate Carry haben.
Das heißt also diesen hier, den nennen wir jetzt mal Generate Carry.
Also einfach GI.
Generate Carry.
Das ist also der Übertrag, der erzeugt wird.
Und dann können wir den hier unten, also wenn wir das hier wieder
umbenennen, das ist wieder PI.
Dann können wir das Ganze hier schreiben als PI mal ÜI oder GI.
Das heißt also, damit haben wir schon mal eine gewisse Vereinfachung
hergestellt, damit wir das uns auch merken können.
Wir wollen damit gleich weiterrechnen.
Wir wollen damit gleich entsprechend, auf der nächsten Folie kommt das
auch gleich, wollen wir das Ganze darstellen mit Halbadierern.
Vielleicht sehen Sie es ja sogar.
Wie macht man denn das?
Kann ich das jetzt mit Halbadierern schon darstellen?
Ich will doch hier im Prinzip jetzt eben dieses PI Antivalent UI und
dann hier unten habe ich noch mal PI und UI oder den Generate Carry.
Wie kann ich denn das darstellen?
Kann ich doch mal gleich in die nächste Folie gehen.
Wir haben so ein Schaltnetz und das entsprechende Symbol dazu.
Das kommt sofort.
Dann malen wir doch mal alle Dinge ein.
Also wir haben doch hier an der Stelle, hier kommt auch das PI.
Das PI ist an der Stelle AI Antivalent BI.
Das ist an der Stelle.
Und dann haben wir noch diesen Generate Carry, der ist hier, der ist
GI, der ist AI und BI.
Das heißt also, ich habe hier meinen PI.
Wir gehen noch mal zurück.
In der Funktionstabelle, wir wollen ja hier tatsächlich eine 1
bekommen.
Das heißt also, wenn die beiden hier ist Antivalent, also die beiden
sind 1, dann kommt hier eine 0.
Und hier kommt die 1 wegen dem Übertrag und das stimmt genau hier.
Das heißt also, wenn die beiden 1 sind, kommt hier die 0 raus.
Also das passt schon.
Das ist also die Antivalenz.
Ist das richtig?
Sonst denken die mal alle drüber nach.
Genau.
Vielen Dank.
Vielen Dank für die Unterstützung.
Und jetzt machen wir mal weiter.
Und jetzt fehlen mir noch ein paar Begriffe hier drin.
Und zwar, hier oben fehlt noch das PI, richtig?
Das ist auch noch GI.
Und ich glaube, genau, das GI hier fehlt noch.
Und dann haben wir, glaube ich, alles eingetragen.
Bis auf...
Ah ja, hier unten kann ich noch eintragen.
Das hier unten ist natürlich noch offensichtlich PI mal UI.
Das heißt also, wir haben hier unten noch den Übertrag PI UI.
So.
Und jetzt müsste ich eigentlich alles eingetragen haben.
Und jetzt kommen wir auf das entsprechende Symbol.
Also das ganze Ding, was jetzt in gelb hinterlegt wird, dummerweise
ist meine Handschrift jetzt weg, das war nicht beabsichtigt, wird
jetzt so dargestellt als so ein Symbol.
Das ist jetzt der entsprechende Addierer, der Volladdierer.
Und mit dem arbeiten wir jetzt weiter.
Wenn wir nämlich jetzt überlegen, wir könnten jetzt so eine
Volladdierung, die könnten wir jetzt auch seriell machen, wie gerade
diskutiert bei dem entsprechenden Zähler.
Dann könnte ich doch im Grunde genommen einfach einen Volladdierer
nehmen, mir einen Flipflop nehmen, also so ein D-Flipflop, was jetzt
hier den Eingang jeweils speichert.
Und dann könnte ich doch das Ganze auch sehr einfach durch ein
Feedback realisieren.
Und mit genau den gleichen Nachteilen kann ich das machen, das kann
man machen.
Man kann im Prinzip jetzt hier aufsummieren.
Ich habe hier A, I und B, I.
Die kommen sozusagen jetzt einfach mit seriell an, so wie hier
gezeigt.
Der Übertrag wird einfach in den D-Flipflop gespeichert.
Das heißt, der Übertrag kommt hier raus, geht hier vorne wieder rein
und läuft sozusagen hier einfach rum.
Und mit den gleichen Nachteilen, wir brauchen natürlich ewig, bis wir
ein Ergebnis bekommen.
Also wir brauchen einfach am N-Mal, also wenn wir N-Bit haben,
brauchen wir N-Takte, bis wir durch sind.
Okay, jetzt würde ich sagen, können wir eigentlich hier schon fast aufhören.