So, ja, bevor ich jetzt glaube ich anfange,
nur noch mal kurz eine Info in eigener Sache.
Ich hatte ja, beziehungsweise generell ist ja so,
wir haben ja am Freitag eigentlich jetzt, also statt des Audimax 2,
weil dort also im Prinzip diese Trennwand kaputt ist und das
sollte eigentlich bis Mitte November repariert worden sein.
Jetzt heißt es also irgendwann Mitte Januar oder so,
also schätzensweise wird das dieses Semester nichts mehr,
sind wir am Freitag quasi in das Rechtshaus umgezogen.
Dort ist jetzt aber übermorgen, also sprich am Freitag,
9. Dezember eine Veranstaltung, weswegen wir an dem einen Termin,
also sprich einmalig übermorgen, im Fehl C Rechnerstrukturen haben,
also sprich hier nebenan im Füllturm im Hörsalzsee.
Nicht ansonsten wird das anschließend danach aber wieder ganz normal
wie gehabt, also Rechtshaus am Freitag stattfinden. Gut,
also hier auf der Webseite habe ich es eingestellt,
ich habe auch noch mal über Stine an alle Teilnehmenden eine Mail verschickt.
Nichtsdestotrotz, da ich auch mal weiß, wie ich mit meinen Mails umgehe,
hier also auch nochmal so der allgemeine Hinweis an sie,
dass sie da jetzt also nicht am Freitag durch die Gegend irren und die Vorlesung suchen.
Okay, ja, ich hatte ja letzte Woche im Prinzip aufgehört,
indem ich ja so kurz vorgestellt hatte,
was jetzt also Schaltwerke sind, nicht im Gegensatz zu Schaltnetzen,
wo ich also im Prinzip so eine ganze Bündel von Funktionen habe,
habe ich dann eben bei Schaltwerken noch zusätzliche Rückkopplung.
Aufgrund dieser Rückkopplung kommt es eben zu Effekten,
dass das Ganze Eben im Prinzip vorhergehende Zustände oder sprich also die Historie irgendwie speichert,
wie das passiert, werde ich dann also heute beziehungsweise dann übermorgen dann also noch kurz vorstellen.
Generell kann man dann eben immer unterscheiden,
das hatte ich also quasi abschließend noch vorgestellt zwischen getakteten und ungetakteten Schaltwerken,
bei ungetakteten Schaltwerken wirkt quasi in diesem Rückkopplungspfad als Zeit letztendlich nur die Verzögerungszeit in den Gattern,
also sprich das,
was ich also jetzt ganz am Ende des vorherigen Kapitels zu den Schaltnetzen vorgestellt hatte,
bei getakteten Schaltwerken hat man hier dann eben spezielle Speicherglieder,
Flip-Flops, die wir also jetzt im Rahmen dieses Kapitels dann eben auch noch entsprechend genauer kennenlernen werden.
Gut, hinter dem Ganzen steckt dann als Grundidee etwas,
was man in der theoretischen Informatik dann als endlichen Automaten,
beziehungsweise wenn man das jetzt also genau beschreiben möchte,
wäre das ein Deterministischer,
endlicher Automaten mit Ausgabe
Wie gesagt, ich spreche dann, also hier jetzt immer nur von endlichen Automaten,
beziehungsweise im Englischen wäre das dann immer erfahrener als State Machine
oder oft findet man noch als Kürzel FSM.
Bei dem, was wir jetzt brauchen an Automaten,
haben wir jetzt also vergleichsweise einfaches Modell.
Da gibt es in dem Fall jetzt hier also zwei Äquivalentebeschreibungsformen,
ein Mili bzw. Moormodell beim Mili-Modell hängt die Ausgabe des Automaten
letztendlich von der Eingabe und dem aktuellen Zustand ab.
Beim Murm-Modell hängt die Ausgabe eben nur von dem aktuellen Zustand ab. So,
wenn man jetzt auf die Terminologie aus der theoretischen Informatik abziehen würde,
würde man ja sagen, also ein endlicher Automat,
beziehungsweise an die Terministische endlicher Automat mit Ausgabe,
ist ein Sechstupel, wird gekennzeichnet durch eine Menge von Zuständen,
Set, ein Eingabealphabet, Sigma, ein Ausgabealphabet.
Lamda und zwei Funktionen. Die eine Funktion Delta ist eine Übergangsfunktion,
die quasi jetzt aus dem aktuellen Zustand,
Z und einer Eingabe aus dem Eingabealphabet Sigma eben einen neuen Zustand berechnet.
Und dann gibt es eben noch eine Ausgabefunktion beim Milli-Modell,
wird dann eben quasi mit der Ausgabefunktion aus Zustand und Eingabe,
ein Ausgabevektor errechnet,
beim Moor-Modell ist die Ausgabe Vector eben nur vom aktuellen Zustand abhängig.
Und dann gibt es eben noch ein ausgezeichneten Zustandsz-Nol,
das ist dann eben
der Startzustand
Gut, hier nochmal die Begriffe soweit aufgelistet,
hatte ich aber jetzt eben eigentlich alles schon entsprechend erklärt.
Grafisch findet man dann also auch immer irgendwie solche Veranschaulichungen,
wo man dann eben nochmal ganz gut sehen kann,
jetzt also diesen direkten Unterschied zwischen Mili und Murmodell,
wo man dann eben sagt,
also diese Funktion der Eltern bzw. Lamda,
jede von den Funktionen ist letztendlich nichts anderes als ein Schaltnetz,
wie das,
was wir
also in einem vorigen Kapitel kennengelernt haben
Wo ich dann eben jetzt von,
abhängig von Eingabe Vector und eben diesem Zustandsvektor ein Folgezustand,
also dann immer jetzt hier als Z, plus gekennzeichnet,
berechne, beziehungsweise dann eben hier für die Ausgabe dann eben
abhängig von Eingabe Vector und Zustand die Ausgabe berechne und beim Moorautomaten,
der dann also so rumgesehen ein bisschen einfacher ist,
ist die Ausgabe dann eben nur vom aktuellen Zustand abhängig.
Von der Mächtigkeit, was man also mit diesen Automaten beschreiben kann,
sind beide Modelle Äquivalent,
wobei da es dann eben immer so aussehen kann,
dass wenn ich also jetzt quasi von einer Beschreibung von einem Millimodellen expellentes Moor-Modell generiere,
wird das in der Regel mehr Zustände beinhalten,
aber formal gesehen nehmen die sich nichts.
Gut, was sind jetzt überhaupt erstmal solche Asynchronschaltungen?
Dazu hatte ich also auch schon ganz kurz letzten Freitag eingeführt,
sowas wie dieses hier, also mit diesem Widerspruch,
weil sie im Prinzip X gleich nicht X ist.
Also das heißt also irgendwas auf sich selbst zurückgekoppelt wird.
Genau das haben wir hier in etwas elaborierterer Form dann.
Also letztendlich mit Hades beschrieben, wo man dann eben sieht,
ich habe hier jetzt irgendwelche Inwärter mit einer gewissen Verzögerungszeit.
Ich habe dann hier noch so einen Endcutter, auch mit einer Verzögerungszeit. Und solange ich also hier quasi in dieser Rückkopplungskette eine ungerade Anzahl von Invertierungen habe,
habe ich eben genau diesen Perfekt, nicht mit diesem Garter,
das dient dann letztendlich eben nur dazu,
dass man dann also hier quasi mit so einem Taster dann eben sagen kann,
also entweder ich halte das Ganze an, es bleibt stabil,
nämlich wenn der Eingang gleich null ist,
dann tut sich dort also nichts,
während wenn der Eingang dann eben gleich eins ist,
habe ich eben hier diese Rückkopplung,
es kommt eben zu einer schnellen Folge von 0 und 1,
nicht das kann man dann eben beispielsweise dann hier mit so einem dran gehängten Zieler sich ansehen,
Und das war es dann also letztendlich,
letztendlich in der Simulation passiert, ist dann also auch nichts anderes,
als dass ich jetzt sage,
also das zählt jetzt hier eben entsprechend schnell rauf und wenn ich den hier also mal kurz anhalte,
dann bleibt er eben stehen.
Und anschließend läuft das Ganze dann irgendwie eben wieder entsprechend soweit durch.
Gut, Ja, das eigentlich erstmal nur so zu dieser,
so einem Beispiel, was jetzt also mal so eine einfachste Möglichkeit ist,
also solche Rückkopplungen sich anzusehen.
Gut und formal gesehen ist eben letztendlich so was erstmal ein endlicher Automat,
wenn auch also vergleichsweise trivial. Es gibt eben zwei Zustände,
nämlich, dass ich also jetzt hier irgendwo an einem Punkt,
also entweder eine Null habe oder eine Eins habe und der wechselt eben immer zwischen genau diesen beiden Zuständen hin und her.
Gut, und wenn man sich dann also in Hardest heißt,
also auch noch irgendwie solche Impulsdiagramme raufliegt,
dann würde man dann eben quasi in den Wave-Forms dann also entsprechend zu was sich ansehen können.
Gut, ansonsten haben solche Beispiele natürlich also eher akademischen Charakter,
weil rein praktisch will man das nicht benutzen, es seien,
also vielleicht ist es irgendwo testweise auf irgendwelchen Chips,
also um jetzt also irgendwie mal einzelne Transistoren auszutesten,
um zu gucken,
ob das also irgendwie richtig schnell geht oder richtig geht bzw.
wie schnell bestimmte Technologien letztendlich sind
Ansonsten, wenn man jetzt also quasi in seinem Computer irgendwo einen Takt aus Zillator hat,
also der an den Takt generiert,
dann wird das also nicht auf die Art und Weise passieren,
sondern dann passiert das mit etwas anderen Mechanismen,
weil dafür sind nämlich also hier solche rückgekoppelten Sachen dann eben auch schon wieder zu ungenau,
weil das ist dann etwas,
was ja auch schon mal kurz angesprochen hatte.
Also im Prinzip ist bei sowas dann,
also quasi diese Schwingungsfrequenz dann eben von Temperaturversorgungsspannung,
Alterung der Teile oder diversen anderen Parametern abhängig.
Nicht deswegen macht das also jetzt keinen Sinn,
so was jetzt also irgendwie als Taktgenerator,
also hier irgendwie auf sein Motherboard zu setzen,
dass sie sagen,
okay,
damit generiere ich mir jetzt
irgendwelche Takte
Gut, was man dann ja eben auch schon sieht,
was sie eben ja teilweise auch schon angesprochen habe,
das sind eben letztendlich die Probleme bei solchen Asynchronschaltungen,
was man hier eben sehr schön gesehen hat, nämlich,
dass ich also sowas wie diese nichtsstabilen Zustände habe.
Das heißt also, ich kann zwar unter bestimmten Bedingungen sagen,
okay, wenn ich das und das einstelle,
dann habe ich da so ein stabiles Verhalten.
Es kann aber eben auch beliebig hin und her schwingen und letztendlich die Oszlationsfrequenz ist eben nicht Apriori festgelegt,
sondern kann sich abhängig von irgendwelchen Umweltparametern entsprechend ändern.
Demzufolge wird man sowas also jetzt auch nicht benutzen,
um damit also größer irgendwelche Schaltungen, beziehungsweise irgendwelche Getagte im Schaltungen zu entwerfen,
sondern in der Praxis, das ist eigentlich das,
was also im Hardwareentwurf gang und gäbe ist und das,
was also jetzt auch immer weiter bei den Beschreibungen beziehungsweise noch bei den Beispielen von endlichen Automaten auftauchen wird,
arbeiten wir eigentlich mit Synchronenschaltwerken,
wo ich dann eben als Speicherglieder sogenannte Flipflops habe.
Das heißt, da habe ich also Spezielle Elemente,
die dann eben genau ein Bett speichern können,
beziehungsweise in Form von Riggistern und dementsprechend mehrere Bits,
rein funktional gesehen sind, diese Speicherglieder letztendlich gut entworfene,
asynchronische Haltwerke, wie die dann aussehen,
wird also jetzt gleich auf den Folien kommen.
Gut, wie gesagt, bei Synchronenschaltungen habe ich eben in diesen Rückkopplungsfaden
dann eben diese Flipflops mit drin. Dadurch wird dafür gesorgt,
dass quasi in diesen Modellen ich an dieser Stelle eben also wirklich
eine saubere Trennung habe zwischen einem aktuellen Zustand und einem Zustand
irgendwann später stattfinden wird und ich dann eben quasi über ein externes Taktsignal sage,
okay, jetzt soll sich dieser interne Zustand verändern.
Das heißt, der hier ausgerechnete Folgezustand wird dann eben der aktuelle Zustand.
Es wird dann zwar wieder ein neuer Folgezustand errechnet, aber dadurch,
dass sich das Ganze dann also quasi in diese Rückkopplung aufgetrennt habe,
hat man dann eben so einen Zustandswechsel dann eben nur zu definierten Zeitpunkten.
Gut, das ist eben das,
was eigentlich jetzt solche Synchronschaltungen ausmacht für die Art und Weise,
wie jetzt dieser Zustandswechsel stattfinden kann.
Gibt es jetzt also auch noch mehrere Möglichkeiten? Auch die
werde ich jetzt also im Folgenden gleich noch kurz skizzieren,
weil da kann man jetzt auch noch unterscheiden zwischen Taktpegelabhängigen oder
Taktflankenabhängigen Elementen
Gut, die eigentlichen Zeitlieder dazwischen, also diese Flipflops,
beziehungsweise in der deutschsprachigen Literatur,
wobei das jetzt ein bisschen ältere Begriffe sind,
findet man dann auch immer noch so was wie biestabile Bauelemente oder Kippglieder,
sind eben letztendlich sauber entworfene asynchronische Schaltwerke,
mit denen man eben letztendlich genau zwei stabile Zustände unterscheidet.
Das heißt, rein technisch gesehen speichert man damit dann eben
genau ein einzelnes Bit.
Gut, wie funktionieren die bzw. wie kann man die dann
entsprechend entwerfen
Gut, das hatte ich alles soweit schon kurz vorgestellt.
Dazu werde ich jetzt also hier mal einige typische Flipflop-Typen kurz vorstellen. Einmal sind die klassische RS-Flip-Flop als Grundschaltung,
dann eben noch sowas wie ein Taktsignal definieren,
wie man damit arbeitet und dann eigentlich das,
was man jetzt im technischen Umfeld immer benutzt,
beziehungsweise typischerweise verhindert, nämlich sogenannte D-Flip-Flops,
eben entweder in Form von Pegelgesteuerten, Elementen,
die dann auch immer als Ledge bezeichnet werden oder dann wirklich als Flanken gesteuerte Elemente.
Das ist dann eigentlich das, was man umgangssprachlich dann meistens unter Efelflop verbindet.
Gut, wie sieht es theoretisch oder überhaupt erst mal aus?
Wie kann ich ein einzelnes jetzt speichern mit solchen Rückkopplungen?
Dazu sehen wir uns also hier einfach mal diese beiden Schaltungen an,
wo ich also hier entweder in mit zwei Nantgattern
oder wie hier unten mit zwei Norgattern folgende Struktur habe.
Ich habe hier also quasi immer Ausgänge oder Eingänge,
S und R beziehungsweise in der Land-Realisierung nicht es und nicht er.
Ich habe hier irgendwelche Ausgänge, Kuh und Nicht-Kuh.
Und die Ausgänge der Flip-Frops sind dann quasi so entsprechend überkreuzt rückgekoppelt.
So, was passiert dort jetzt rein technisch oder rein praktisch gesehen?
Bei einem Land-Gutter kann ich jetzt immer sagen,
der in Anführungszeichen inaktive Zustand am Eingang ist,
wenn der Eingang gleich eins ist. Das ist also das,
was jetzt also hier quasi in Hades schon voreingestellt ist.
Also mit dem Eingang gleich eins, sorge ich dafür,
dass ich also jetzt hier beim Ondgatter letztendlich die Ausgangsfunktion von dem zweiten Eingang abhängt.
So, was würde jetzt hier passieren? Also angenommen,
in diesem Flip-Flop habe ich jetzt also hier beide Eingänge gleich eins und
ich habe hier an meinem Ausgang Q irgendwie ein Wert gespeichert, beispielsweise eins.
Das wurde dazu führen, dass ich sage,
ich habe hier eine Eins, der Eingang ist eins,
der Eingang ist eins, dem zuvor gewährt das Ergebnis eins,
negiert eine Null.
Diese Null und diese Eins ist Null, negiert,
hier am Ausgang, eine Eins. Das heißt,
ich habe dort keinen Widerspruch und das,
was ich dort also quasi gespeichert habe,
nämlich an dieser Stelle eine Eins, an dieser Stelle eine Null, wäre stabil.
Wenn ich jetzt sage, wie sieht das in einem anderen Fall aus?
Also immer noch beide Eingänge sind Eins, ich habe jetzt
hier eine Null. Würde heißen, mit dieser Null,
an dieser Stelle erzwinge ich hier eine Eins,
die ein und die eins mit einem Nordverknüpf,
der gibt hier im Ausgang
eine Null
Auch das ist stabil. Es gibt also dort keinen Widerspruch. Das heißt,
wenn die beiden Eingänge eins sind, wird der Wert,
der quasi in Kuh ist, beziehungsweise nicht Kuh ist, gespeichert.
Das ist also letztendlich die Erklärung, wie das Ganze funktioniert.
Wie kann ich jetzt also das Ganze beeinflussen,
indem ich dann eben sage, na gut,
also wenn ich hier entweder bei nicht esse oder bei nicht R,
jetzt nicht eine Eins, sondern eine Null annehme,
an genau einem von den beiden,
würde das dazu führen,
dass ich also quasi mit einer Null
hier an dieser Stelle hier eine Eins erzwinge
Was dann dazu führt, dass egal was auch immer hier letztendlich irgendwie vorher mal drauf war,
ich hier im Ausgang eine Eins habe und hier an diesem Ausgang eine Null.
Das heißt also, in dem Fall würde mit Estgleich Null
dieses hier rauskommen und das Ganze wird gesetzt.
Deswegen das S-First Set bzw. dadurch, dass es null aktiv ist,
dann eben immer noch diese angedeutete Negierung davor.
Analog dazu genau das Gleiche, wenn ich also R auf Null setze,
wird der hier eben auf Null gezwungen, der hier,
oder erst der auf 1, dann der auf Null.
Das heißt, das wäre dann eben das Reset,
damit wir das Ganze zurückgesetzt. So,
und was jetzt nicht passieren sollte, ist,
dass beide Eingänge gleichzeitig Null sind,
weil damit erzwinge ich hier eine 1 und hier eine 1. Und anschließend ist das Ergebnis davon abhängig,
in welcher Reihenfolge ich diese beiden Nullen quasi wieder abschalte,
weil wenn das letztendlich genau gleichzeitig passieren würde,
würde das Ding oszillieren
Ich ansonsten dann eine zeitliche Verzögerung habe, wird dann eben,
je nachdem, was also als Letztes zurückgenommen wird,
eben entweder ein Set oder ein Reset durchgeführt.
Deswegen sagt man eben hier an dieser Stelle Forbidden,
weil das sollte halt nicht sein oder nicht auftauchen. Gut,
das heißt also, damit kann man mit diesen zwei einfachen Gattern,
diese über Kreuzrückkopplung, genau dafür sorgen,
dass ich ein einzelnes Bit speichern kann.
Analog dazu kann ich das Ganze eben auch mit Norga dann machen.
In dem Fall ist es dann so,
dass also quasi der aktive Zustand in dem eine von den beiden Leitungen eins ist,
der inaktive Zustand eben, wenn beide gleichen wohl sind.
Wenn ich aber auch da letztendlich, also genau die gleiche Argumentation.
Gut, das ist also, sagen wir mal,
die Art und Weise, wie jetzt eben ein einzelnes Bit
eben mit so einem Basis-RS-Flip-Flop irgendwo gespeichert werden kann.
Also hier sieht man das nochmal. Hier unten ist
das Ganze dann also auch nochmal angedeutet,
weil also ich hatte jetzt ja eben auch schon gesagt,
also Rückkopplung über Kreuz und so weiter.
Also man kann es also auch zeichnerisch oder topologisch entzerren.
Also es ist eben letztendlich einmal hier irgendwo eine Rückkopplung mit drin.
Also mehr ist es an der Stelle da eigentlich auch
erstmal nicht
Gut, um solche Sachen beziehungsweise um dieses Verhalten zu beschreiben,
findet man jetzt also oft etwas,
was ich also hier schon mal vorab einführe,
was uns dann also gleich später noch ein bisschen genauer begegnen wird,
sogenannte Zustandsdiagramme beziehungsweise Flusstafeln,
was ist damit gemeint beziehungsweise wie muss man das lesen,
Zustandsdiagramm ist also im Prinzip sowas hier,
wo ich also jetzt hier meine Zustände durch entsprechende Kreise,
Markierung, wie auch immer, irgendwie symbolisiert habe.
Und ich habe dann eben hier irgendwelche Kanten oder Übergänge,
wo ich abhängig von bestimmten Eingangsbelegungen eben einen Zustandswechsel mache.
Die Zustände sind in diesem Fall jetzt also hier dadurch gekennzeichnet,
dass quasi hier innen drin jetzt einfach drinsteht,
was an den Ausgängen Kuh bzw. nicht Kuh letztendlich gespeichert würde.
So dieses Zustands-Übergangsdiagramm war es jetzt also quasi auflag,
war jetzt, also das hier für diese Norealisierung des RRS-Flip-Flops,
wo man sagt, ich habe hier letztendlich meine stabilen Zustände,
nämlich wo ich, wenn ich es gesetzt habe,
Set-Eingang gleich eins, nee, Kuh gleich eins,
nicht Kuhgleich null, beziehungsweise wenn ich es zurückgesetzt habe,
habe ich eben die Eigenschaft, dass Gugleich null ist, nicht Kuhgleich 1.
So, und abhängig von der Eingabebelegung, das heißt,
je nachdem, wie Set und Reset aussehen,
wird quasi jetzt hier für einen Zustand, in dem ich mich befinde,
und diese Eingabe eben irgendwo einen Folgezustand ermittelt.
So, und wenn man jetzt erstmal sagt, der normale Betriebsfall ist,
wir befinden, haben also jetzt beispielsweise hier das ganze Gesetz,
das heißt also, es ist irgendwie 1-0 in einem Flipflop gespeichert,
das heißt, ich befinde mich hier in diesem Zustand
Die Eingabe wäre 0-0, das heißt,
nichts ändert, sich,
das heißt, ich bin hier genau bei diesem Fall,
wo also quasi der gespeicherte Wert erhalten bleibt,
steht dann dementsprechend in dieser Tabelle,
Folgezustand ist auch wieder 1-0, deswegen ist er rot gekänzeichnet,
das ist nämlich ein sogenannter stabiler Zustand, nämlich einer,
wo unter dieser Eingabe quasi Zustand und Folgezustand identisch sind.
So, was passiert jetzt, wenn ich dieses Flip-Front nehme und jetzt zurücksetzen möchte,
was also in diesem Fall jetzt wäre, es ist gleich null.
Reset ist gleich eins, das heißt, ich hätte diese Eingabe,
würde dazu führen, dass ich eben in diesem Zustand 00 gehe.
Das ist eben dann hier auch entsprechend mit dieser Kante gekennzeichnet.
Erst habe ich einen Don't Care,
an Rieset habe ich ihn ein, eine 1,
ich bin in diesem Zustand 00 und verlasse diesen Zustand dann
eben auch gleich wieder mit dieser Eingabe 01 und lande dann eben hier in dem Reset-Zustand.
Und wäre jetzt also quasi unter dieser Eingabe in diesem Zustand und dort bleibe ich auch,
das ist dann nämlich ein stabiler Zustand,
was dann also hier durch diese Rückkopplung des Zustands auf sich selber gekennzeichnet ist.
Also das ist so die Art und Weise,
wie man jetzt die Funktion oder Funktionalität aus so einem Skrimatik
bzw. aus so einem Schaltplan dann eben entsprechend jetzt in so einen Zustandszieldiagramm bzw. in so eine Flusstafel umsetzt,
nicht diese Flusstafel ist letztendlich nichts anderes,
da ist eben eine textuelle Beschreibung dieses Zustandsdiagramms, wo man dann eben sieht,
abhängig von irgendeiner Eingabebelegung und einem aktuellen Zustand, in welchem Folgezustand lande ich.
Und was man hier dann eben auch sieht,
ist dann also beispielsweise dann eben diese Oststellation,
nämlich wenn sowohl Set als auch Reset beide gleich Eins sind,
wo ich dann eben hier in diesem Zustand 0-0 erst mal bin,
den er zwinge und wenn es ihm wirklich gleichzeitig von da aus zählt und Reset nach 1-1 gehen,
ich dann, oder nein,
von 1-1 dann wieder nach 0-0 gehen nicht,
dann hätte ich im Prinzip dann diese Ausstellation,
dass ich immer hier zwischen diesen beiden Zuständen
hin und her wechsle
Gut, das also erst mal zu der Grundschaltung. Er ist Flipflop,
eben entweder in Nant oder in Norddarstellung, was, womit man dann eben letztendlich ein einzelnes Bit speichern kann. Jetzt möchte ich natürlich in meiner Schaltung irgendwo in einem Computer jetzt nicht,
also irgendwie einzelne Bits mit Set und Reset,
also irgendwie so einzeln behandeln, sondern das,
was man dort eigentlich typischerweise eben hat,
beziehungsweise was war dann ja auch für endliche Automaten brauchen ist,
also irgendwas, wo ich also taktabhängig arbeite,
da kann man jetzt eben beispielsweise diese Struktur jetzt einfach nehmen und sagen,
gut, also wenn ich hier vor jetzt einfach noch entsprechend zwei Untkarta setze,
die dann noch gemeinsam mit einem Taktsignal C für Klock verbinde,
erreiche ich letztendlich folgende Funktionstabelle, dass ich eben sagen kann,
okay, solange Klock gleich Null ist,
habe ich also hier die Eingänge von diesem Basis-Nor-Flip-Flop sowieso immer irgendwie beide auf null.
Das heißt, ich bin in diesem Speicherzustand.
Also an dieser Stelle habe ich dann eben hier,
also dies X sollte jetzt eigentlich ein Don Care sein.
Gut, das ist jetzt leider ein Problem, dass Norman
das da so auf seinen Folien so ein bisschen ungünstig gemacht hatte.
Nicht, das heißt also Clock gleich null, ist gespeichert, wenn Clock gleich eins ist. Gut,
dann sind diese beiden Guard jeweils transparent geschaltet und das Ganze ist dann eben von Reset,
beziehungsweise Set-abhängig und ich habe dann eben letztendlich genau das Gleiche verhalten,
wie das so vorher auf der anderen Tabelle war,
wo ich dann eben mit 0-1 beziehungsweise 1-0 entsprechend hin und her schalte,
mit 0-0 bleibt das gespeichert und eben diese Kombination,
dass beide eins sind, ist in dem Fall dann nach wie vor verboten.
Gut, wenn man sich das jetzt also hier ansieht, durchsimuliert,
also mit unterschiedlichen Fällen, also jeder mal so als Impulsdiagramm,
jetzt hier für irgendwelchen abstrusen Kombinationen aus Set,
Reset und Taktsignal, dann sieht man das eben nur,
wenn der Takt wirklich eins ist, Letztendlich hier,
Set und Reset ausgewertet werden.
Das Flipflop wird gesetzt. Also erst wird also hier das Cool-Signal-Gesetz anschließend,
dass NQ, hier hätte ich dann eben genau den Fall,
wo dann also jeweils zurückgesetzt wird. Und gut,
hier hat man dann eben nochmal so ein Beispiel,
wo dann letztendlich, also man, langes, taggleich ein Signal folgt,
wo dann hier Erst das Ganze mit Set gesetzt wird,
anschließend kommt jetzt eigentlich hier dieser Bereich,
der dann immer als verboten gekennzeichnet ist,
nämlich wo sowohl Taktsignal-Assocriset als auch Clock.
Beide eins sind beide Ausgänge, wären quasi parallel auf Null gezogen. Gut,
und da hatte ich ja gesagt, das ist davon abhängig,
welches von denen hier zuerst oder welches von denen vielmehr,
also hier zuerst abschaltet in dem Fall.
Es ist also das Sales-Signal, deswegen landet man dann eben
hier auch wieder in einem definierten Zustand
Gut, das, was man eigentlich häufig hat,
als Funktion oder Funktionalität, ist dann eigentlich ein Element oder ein Schaltelement,
wo ich dann eigentlich nur sage,
ich habe am Eingang nur ein einzelnes Bit,
eine Leitung 0 oder 1 und ich habe eben irgendwie
ein Taktsignal und diese einzelne Information 0 oder 1 möchte ich eben speichern oder nicht speichern.
So, und das einfachste Element, was also genau das macht,
Wäre dann eben das D-Ledge beziehungsweise ein Pegel gesteuertes D-Flip-Flop,
wo ich eben sage, ich habe Taktsignal, ich habe einen Dateneingang.
Und was passiert ist, dass eben, wenn der Takt gleich eins ist,
wird der Dateneingang quasi eins zu eins zum Ausgang weitergeleitet.
Das heißt, wenn der Eingang eins ist,
habe ich am Ausgang eine Eins, wenn der Eingang null ist,
habe ich am Ausgang eine Null.
Wenn der Takt gleich Null ist, bleibt quasi der vorherige Wert gespeichert.
Von diesem Deletch gibt es dann also noch zwei Varianten.
Einmal das, was ich jetzt hier gerade eben vorgestellt habe,
nämlich wo ich quasi mit Takteingang gleich eins den Dateneingang zum Ausgang durchgebe,
dass wir dann ein sogenanntes High-aktives Ledge.
Es gibt auch noch eine Variante, wo dann quasi diese Tabelle
umgedreht ist. Ich dann also hier quasi an dieser Stelle
die Einzelnen und hier die Nolan hätte,
wo ich dann also quasi mit Takteingang
gleich null den Ahrgang zum Ausgang weiterschalte
Gut, auch das kann man sehr einfach,
dann also mit solchen einzelnen Gattern sich zurechtbauen,
indem ich dann eben letztendlich mir nur Schaltagebranche überlege,
wann wird Set, Run Word Reset für so eine Basisstruktur,
also für so ein klassisches RS-Flip-Flop irgendwie gesetzt.
Also wo ich dann letztendlich hier einfach nur die Wertetabelle entsprechend nochmal umrechne,
Ja, und man würde dann eben bei so einer Struktur,
wie beispielsweise dieser Nance-Struktur laden, wo ich dann eben hier Datenheilgang,
Takteingang entsprechend habe und hier hinten dann als eigentliches speicherndes Element dann eben so eine Basis,
er ist Struktur habe.
Gut, das Ganze gibt es dann auch immer fertig beispielsweise dann später in Hades,
würde dann immer durch so ein Symbol gekennzeichnet.
Ach so, hier auch nochmal, nur mal kurz der Hinweis,
also wenn ich jetzt hier also irgendwelche Gatan-Netzlisten auflege.
Also es wird nicht in der Klausur abgefragt,
bauen Sie ein Deletsch aus Nenntgattern auf,
weil gut könnte man vielleicht machen, einer Übungsaufgabe,
wenn man ein bisschen mehr Zeit hat,
für die Klausur wäre das erwartet zu aufwendig.
Gut, ich sehe hier auch schon die Köpfe geschickt,
dass die Köpfe geschüttelt werden.
Also ich denke mal, also auch in der Übungsaufgabe
wird das höchstwahrscheinlich nicht drankommen
Da haben wir bessere Aufgaben. Nee, weil,
also auch da muss ich immer sagen, okay,
also das, was ich hier eigentlich nur veranschaulichen will,
ist, also wie man letztendlich solche Teile oder solche Bauelemente,
also mit diesem Verhalten von DLED oder von flankengesteuerten Flip-Flop aus einzelnen Gattern aufbaut,
rein technisch gesehen wird das natürlich niemand so machen,
weil, also heutzutage eigentlich niemand mehr sagt, okay,
ich verbinde jetzt einzelne Endgatter,
das hat man also irgendwie Ende 60er Jahre mit der TTL-Technik,
also noch irgendwie machen müssen,
als ich also quasi in so einem IC letztendlich ein paar Nant Gatta irgendwie nur zur Verfügung hatte und die entsprechend miteinander verbunden habe.
Nicht heutzutage kann man sagen, so was wie ein Ledge,
beziehungsweise wie irgendein anderes, speicherndes Element, was also dann gleich noch kommen wird,
also flankengesteuerte Elemente, gibt es eben irgendwo fertig als vorgegebene Primitive, irgendwo für den Hardwareentwurf. Und da muss man sich jetzt aus dem CSV nicht selber darum kümmern,
wie die jetzt intern aufgebaut sind,
weil das ist dann also auch mal so ein bisschen so eine Sache,
dass, wenn man eigentlich jetzt noch ein bisschen genauer in die Schaltungstechnik von Computern geht,
einiges von dem, was sich also jetzt hier auch immer so vorstelle,
teilweise eben auch schon wieder überholt ist,
weil man eben sagen kann, okay,
also wenn ich so in einem Bereich von irgendwie drei,
vier Gigahertz-Tagfrequenzen bin, dann verwendet man dann teilweise ein bisschen andere Techniken,
wo ich dann nämlich speicherndes Verhalten und irgendwelche Rechenoperationen,
also ich hatte es ja auch schon mal ganz kurz angedeutet,
dass es zum Beispiel in irgendwelchen Alus und in ein paar Pipelining-Sachen,
also sowas dann eben auch schon mit drin ist,
dann eben miteinander verknüpft wird.
Nicht deswegen wird da dann eben auch nicht so eine Trennung passieren,
wo man dann also das jetzt hier irgendwie so aus den Arzenen Gattern aufbaut.
Gut, aber jedenfalls also hier von der Funktionsweise wichtig eben nur pegelgesteuert ist,
die Flipflop oder in meinem Sprech beziehungsweise sage man dann eben auch immer als Ledge D-Ledge bezeichnet.
So, wenn man sich da jetzt nämlich das Zustandsdiagramm und die Flusstafel ansieht,
ist es also dann schon deutlich vereinfacht gegenüber so einem RS-Flip-Flop,
wo ich dann also noch, oder diesen Basis-RS-Flip-Flop,
wo ich dann immer noch diese Ausstellationen mit drin habe.
Also hier sieht man eben, es gibt letztendlich genau zwei Zustände.
Eine Null ist gespeichert,
eine Eins ist gespeichert und abhängig von Taktsignal und Dateneingang gilt eben letztendlich in dem Fall,
dass der Takt,
das ist dann also hier quasi immer das erste Element,
gleich Eins ist
Entspricht der Zustand oder der gespeicherte, wer dann eben immer
dem Dateneingang, nämlich entweder null oder eins.
Und solange der aktiv ist, bleibe ich auch entsprechend in diesem Zustand.
Das ist dann also diese Beschriftung beziehungsweise diese Beschriftung hier in der Schleife,
wo ich dann eben quasi einen Übergang von null oder der Eingangsbedingungen.
Glock ist gleich eins. Dateneingang ist gleich eins,
in den Zustand habe und eben hier bleibe.
Und wenn ich dann eben in einem Zustand bin und den Takt abschalte,
das heißt, hier habe ich entweder hier oder hier eine Null,
bleibe ich eben auch konstant im Zustand
Gut, das ist die eine, vergleichsweise einfache Möglichkeit,
was zu speichern, das, was man meistens oder häufiger hat,
sind nicht pegelgesteuerte Elemente, also Ledges, sondern flankengesteuerte Elemente.
Da geht es darum, dass man sagt, also ich habe,
das ist also mit diesem Fall hier angedeutet, in dem,
zack, in dem Taktsignal. Was jetzt quasi so läuft,
den Übergang von Blog gleich null, nach Clock gleich eins,
nicht und ihm genau dieser Übergang,
weh oder dieser Wechsel wird dann eben damit bezeichnet,
dass ich sage, okay, das ist die Vorderflanke,
nicht und eben zu diesem Zeitpunkt oder zu diesem Zeitpunkt hätte ich dann eben jeweils mein Taktsignal,
analog dazu gibt es dann eben auch noch Rückflanke,
das heißt,
wenn ich dann nicht den Wechsel von 0 nach 1,
sondern von 1 nach 0 betrachte
Gut, und das, was dort dann eben passiert,
ist, dass ich eben nur genau zu diesem Flanken wechsel,
quasi am Ausgang den Eingangswert übernehme.
Und in allen anderen Fällen, das heißt,
wenn sich das Tagsignal nicht ändert und konstant Null ist oder
konstant eins ist oder wenn ich irgendwie die Rückflanke habe,
bleibt der Wert gespeichert.
Gut, wie kann man dieses Verhalten realisieren?
Dazu gibt es also letztendlich zwei Möglichkeiten,
die einfache Möglichkeit ist,
ein sogenanntes Master Slave,
Das ist letztendlich nichts anderes als dieses Element, ein Ledge und davon zwei Stück hintereinander.
Und das eine Ledge hat halt eben den invertierten Tag von dem anderen.
Und je nachdem, in welcher Reihenfolge man die anordnet, kann man damit also entweder Vorderflanken oder Rückflankensteuerung realisieren. Beispielsweise,
wenn ich als erstes Element eins habe,
was quasi bei nulltransparent ist, würde es eben heißen,
dass ein Eingangssignal durch dieses erste Ledge durchläuft,
an dem zweiten, aber stehen bleibt,
dort also nichts bewirkt, weil das zweite ist erst,
oder ist ja dann eben entsprechend bei einst transparent,
das heißt, dort kann sich am Ausgang nichts ändern,
wenn der Takt umschaltet,
würde quasi jetzt dieser Eingang von dem ersten Ledge sich nicht weiter auswirken,
dessen Ausgang geht dann quasi nach außen.
Und ich habe eben genau zu diesem Umschaltzeitpunkt dann eben den Wert,
der also kurz vorher hier am Eingang von dem Master lag, in den Slave entsprechend übernommen.
Damit hat man letztendlich dann ihm genauso eine Flankensteuerung realisiert. Gut,
rein technisch kann ich jetzt eben einfach sagen, okay,
ich nehme jetzt im Prinzip genau das,
was ich also vorher da gehabt habe,
nämlich einmal hier ein nulltransparentes Die Ledge und hier nochmal ein zweites dahinter,
was aber jetzt hier also quasi einen invertierten Tag tat.
Und dadurch habe ich dann eben genau dieses Verhalten realisiert.
Gut, auch das einmal kurz mit Hades gezeigt
Nicht, also wenn ich hier jetzt den Tag gleich null habe,
ist dieses Ledge jetzt quasi transparent geschaltet. Das heißt,
der Ausgang sollte jetzt eben immer das haben, was der Dateneingang hat,
was man also hier jetzt auch entsprechend in der Simulation sehen kann.
Dadurch, dass dies hintere Ledge hier bei dem Eingang null eben letztendlich nichts tut,
sondern das, was vorher drin ist, gespeichert bleibt,
habe ich hier immer noch quasi meine vorherigen undefinierten Werte.
So, und wenn ich jetzt also den Takt umschalte,
also von 0 nach 1, führt das eben dazu,
dass also gleich dieser Wert, der jetzt also zu Beginn dieses Umschalens,
also hier am Dateneingang, beziehungsweise dann eben hier rauskommt,
hier entsprechend weitergeleitet wird, Ich habe am Datenausgang,
jetzt also quasi meine Eins gespeichert.
Nicht jetzt wäre dieser Teil hier transparent. Andererseits ist dieses Ledge
jetzt hier abgeschaltet. Das heißt, ich kann jetzt also
auch hier beliebig mit dem Eingang hin und her wackeln.
Hier wird sich also nichts ändern, beziehungsweise demzufolge wird dann
eben hier durch dieses transparente Ledge dann also auch nie was anderes,
als diese hier gespeicherte Eins weitergeleitet. So,
und wenn ich dann eben entsprechend jetzt mit dem Tag wieder auf Null gehe,
Würde dieses Letzte wieder transparent werden, das ändert sich aber dadurch,
dass hier der gespeicherte Wert erhalten bleibt,
wird das also hier noch nicht übernommen.
Und jetzt nur wieder mit deinem nächsten Tag Flanke entsprechend weiter. Zwischengespeichert. Gut,
das wäre jetzt, sagen wir mal, die à la einfachste Variante,
wie man jetzt eben so ein flankengesteuertes Flip-Flop realisieren kann,
eben indem ich jetzt einfach zwei Ledges mit invertierten Takt hintereinandersetze.
Auch dazu gibt es dann noch so ein bisschen Einfachere Varianten,
die dann letztendlich eigentlich diese Funktionalität dann eben auch beinhalten,
aber dann eben Schaltalgebrage, beziehungsweise automatentheoretisch noch ein bisschen weiter minimiert worden sind.
Nicht nur in der Helmmase beispielsweise eben solche Strukturen,
wo ich dann im Prinzip dann eben auch genau dieses Verhalten habe,
also hier Takteingang, Dateneingang und man hat eben,
gut, also was man hier jetzt eigentlich nur noch sieht,
dann eben auch irgendwo zweimal so eine Rückkopplung in dieser Speicherung,
also hier einmal ganz hinten zum Basis,
RS-Flip-Flop und hier noch irgendwie so mit drin,
aber gut,
ja sie sind jetzt eben noch zusätzlich oder weitere Eingänge
mit drin
Gut, aber wie gesagt, also auch hier kann man eben sagen, das Ganze funktioniert so,
dass ich ihm letztendlich immer genau diese Flankensteuerung oder eben dieses Verhalten von der Flankensteuerung realisiert habe.
Wichtig bei dem Ganzen ist, ist eben,
dass das Ganze letztendlich dadurch funktioniert,
dass ich eben diese in den einzelnen Elementen letztendlich auch immer noch irgendwelche Garterlaufzeiten habe,
sodass eben auch schon beim ursprünglichen Basis er ist, Flipflop,
dass eben dadurch, dass ich Ausgänge eben minimal später,
als jetzt hier irgendwelche Eingänge ändern.
Ich ihm dafür sorgen kann, dass also hier quasi Werte
gespeichert bleiben und ich ihm in solchen stabilen Zuständen lande.
Bei solchen flankengesteuerten Elementen, aber auch bei pegelgesteuerten Elementen
ist es dann eigentlich wichtig, dass bestimmte Zeitbedingungen eingehalten werden.
Dazu folgen, also dann gleich noch ein paar Überlegungen,
was letztendlich gelten muss,
damit ich dann eben auch entsprechend jetzt
meine stabilen Zustände habe
Gut, hier abschließend nur nochmal der Vollständigkeit halber erwähnt,
etwas, was man also früher relativ gerne noch verwendet hatte,
was er sich ja auch noch an einigen Artesbeispielen auftaucht,
was man inzwischen heute jetzt allerdings nicht mehr so häufig nutzt,
sind also noch sogenannte JK-Flip-Flops.
Also hier auch in einer getakteten Version,
wo ich dann eben sagen kann, ich habe einen Takteingang,
ich habe zwei Steuereingänge, namens J und K für Jump und Kehl.
Letztendlich ist das also von der Funktionalität her so ein bisschen ähnlich
wie ein RS-Flip-Flop, wo ich dann eben sagen kann,
ich kann aber eben jetzt nicht nur Werte speichern.
Ich kann also gezielt setzen, zurücksetzen.
Ich kann aber eben mit dieser in Anführungszeichen verbotenen Bedingung,
wobei der nämlich irgendwie eins ist,
dann eben auch noch irgendwie was machen in diesem Fall.
Nämlich dann also quasi den gespeicherten Wert torgeln. Das heißt,
wenn ich eine Eins gespeichert habe, wird da draußen eine Null,
wenn ich eine Null wieder gespeichert habe,
wird dann aus einer Eins.
Das heißt, der Inhalt wird dann eben entsprechend invertiert.
Gut, also auch das kann man dann eben beispielsweise hier
jetzt in so einer Realisierung mit einem Flanken gesteuerten D-Flip-Flop
dann eben auch noch irgendwie logisch anders nachbilden
Dieses Verhalten nicht. Also hier dann als so ein Masters-Lave-Schaltung aus irgendwie entsprechend einzelnen Gattern,
beziehungsweise das ist dann die Art und Weise, wie das also,
ja, auch vor ungefähr 30 Jahren dann also mal in Form von diesen 74er-ICs dann also mal irgendwie realisiert worden ist,
wie man also dann letztendlich einzelne Bits in solchen JK-Flip-Flops dann also in so einem IC dann gespeichert hatte.
Gut, Hier nur noch mal kurz zusammengefasst, also die verschiedenen Flip-Flop-Typen,
beziehungsweise Komponenten, die es also dann in Hades gibt.
Also da gibt es im Prinzip dann also diese D-Ledges,
beziehungsweise die Flip-Flops von Symbole oder von der Symbolik her sieht das immer so aus,
dass man sich immer sagen kann, okay,
bei Ledges, also sprich bei den pegelgesteuerten Elementen,
wo ich also quasi hier von dem Takt pegel, null,
beziehungsweise eins abhängig bin, wird quasi an diesem Takteingang dann also immer irgendwie so ein Offenes oder ausgefülltes Quadrat gezeichnet bzw. Rechtecke zeichnet.
Bei Flanken gesteuerten Elementen hat man da dann immer so ein
kleines Dreieck drin. Und gut, das macht dann mal
jeder Autor auch immer noch so ein bisschen anders.
Häufig ist es dann eben mal so,
dass High-aktive Elemente quasi so gezeichnet werden, lohaktive Elemente,
da wäre das jetzt ausgefüllt.
Vorderflankensteuerung wäre. Dieses hier Rückflankensteuerung,
da wäre dann eben hier dieses Dreieck dann auch entsprechend ausgefüllt
Was man hier dann auch noch sieht, ist auch etwas,
was also in den Scheidungen auch entsprechend oft oder häufig vorkommt.
Nämlich etwas, was sich dann also hier teilweise noch findet.
Nämlich sowas wie ein, dieses NR2 oder dieses Enry Set bzw. Endset,
also irgendwelche Reset oder Set-Signale, die wirken in der Regel
Es sind jetzt also hier nirgends von irgendwelchen Skematics drin,
wirken aber in der Regel letztendlich dann nochmal als zusätzliche Eingänge
hier direkt auf diese RS-Struktur.
Damit kann man die Flip-Flops da nämlich unabhängig von dem Takteingang
quasi asynchron setzen oder zurücksetzen
Aber jetzt kann man den natürlich fragen, wofür brauche ich das?
Irgendwie so ein asynchrones Setzen oder Zurücksetzen. Nicht, weil an sich,
also ich habe ja irgendwo meinen Takt und ich habe hier irgendwo
einen Dateneingang und eigentlich kann ich auch sagen, okay,
also ein synchrones Setzen wäre dann ja nichts anderes.
Also dass beispielsweise der Dateneingang dann eben nach dem Takt auf eins
gelegt wird und dann wird es eben entsprechend gesetzt bzw. für einen Rücksatz nehmen, analog dazu.
So eine asynchrone Initialisierung braucht man in der Regel für etwas,
was also Ganz am Anfang dieser Vorlesung auch schon kurz angesprochen wurde.
Endlich Automat. Ich habe so was wie ausgewählte Anfangszustände. Z0. So,
und das ist also etwas, was man zwingt,
braucht bei allen Schaltungen, was jeder ihrer Rechner, jedes elektronische Gerät letztendlich macht.
Nämlich, dass ich nach dem Einschalten irgendwelche Initialzustände annehmen kann.
Also angenommen, ich habe jetzt einfach nur irgendwie sowas wie einen dummen Zähler.
Ich gehe erstmal davon aus, ich schalte ein,
das Ding startet irgendwo bei Null zu zählen und nicht bei irgendeinem beliebigen Zähler stand.
So rein technisch gesehen ist es aber nicht zwingend so,
dass jedes Flip-Flop oder jedes Register, wenn ich den Strom einschalte,
immer mit einem Wert Null startet, sondern da kann irgendwas drin stehen.
So, um jetzt dafür zu sorgen, dass sich wirklich solche definierten Anfangsbedingungen habe,
hat man eben gerne dann solche asynchronen Set oder Reset-Eingänge, die eben letztendlich genau dafür sorgen, dass also unabhängig von Takt ich entsprechend bestimmte Werte einstellen kann. Und rein technisch,
das ist jetzt nämlich auch noch so ein bisschen immer so eine Trickserei,
sieht das dann nämlich so aus,
dass ich eben beispielsweise dafür sorge, dass Bei batteriebetriebenen Geräten,
aber auch bei netzbetriebenen Geräten letztendlich genau Folgendes passiert,
dass wenn die mit der Spannung versorgt werden,
quasi automatisch und unabhängig von irgendwelchen Riese-Tastern,
nehmen wir jetzt vielleicht auch noch irgendwo mit drin hat,
ganz am Anfang automatisch ein kleines Reset-Signal generiert wird,
womit eben beispielsweise dafür gesorgt wird,
dass also wirklich ein Prozessor in einem bestimmten Anfangszustand ist und startet und dann kommt irgendwann der Tag und dann fängt das Ganze an,
vernünftig loszulaufen und das gilt eben letztendlich für alle technischen Geräte,
dass man also darüber dann eben so eine Initialisierung beziehungsweise dann eben so ein Zustands-Set-Null einstellen kann.
Gut, hier sieht man nochmal im Vergleich, die beiden Flipflock-Typen,
das ist also wirklich das Entscheidende, was hängen bleiben soll.
Dazu wird es dann also auch noch im Sarz-Fi sowas wie eine kleine Übungsaufgabe geben,
wo man also sieht,
also ich habe jetzt hier mein Taktsignal,
ich habe hier jetzt irgendeinen Dateneingang,
nicht das Ganze dann eben auch mit so einer Standardverzögerung von
genau eins und in dem Fall jetzt eben einmal den Datenausgang für ein Ledge und hier für einen Flip-Flop,
also einen Vorderflanken gesteuertes Element.
Die Sledge sollte jetzt also hier high-transparent sein. Da sieht man jetzt eben,
dass sich also hier quasi bei der Taktvorderflanke sowohl Ledge als
auch Flip-Flop, also hier diesen Dateneingang, eins übernehmen.
Nach dem Abschalten des Taktes bleibt da eben letztendlich in
beiden Elementen eben auch noch gespeichert.
Nicht, wenn dann also jetzt der nächste Tag kommt,
Dateneingang ist null, wird das Ganze dann eben
entsprechend hier auf null zurückgesetzt
Ich meine, hier hat man jetzt eben mal den Fall,
dass während eines Taktes sich der Dateneingang ändert und beim Flip-Flop,
wo das Ganze dann eben wirklich jetzt nur von der Taktforderflanke abhängig ist, habe ich ihn eins gespeichert.
Die bleibt eben auch gespeichert beim Ledge,
wenn sich jetzt also hier entsprechender Dateneingang während dieser High-Phase ändert,
hört das dann eben mit der entsprechenden Verzögerungszeit von einem Element hier an den Ausgang weitergegeben.
So und was man hier dann am Ende noch sieht,
ist dann eben nämlich genau dieser Fall,
wo ich dann also einen undefinierten Wert habe,
beziehungsweise wofür man das dann eben auch noch braucht,
wo ich dann nämlich sage, okay,
ich habe jetzt hier Den Fall,
dass sich der Dateneingang oder der Dateneingang D und das Taktsignal quasi gleichzeitig ändern.
Und dadurch, dass das jetzt hier die Rückflanke vom Takt ist,
hat das also jetzt keine Auswirkung auf das Flipflop.
Bei dem Ledge ist es aber letztendlich dann eben die Frage,
okay, was passiert ist eben bei so einer Gleichzeitigkeit.
Denn genau das ist also auch der Grund, wofür man in Hades,
also als ich das jetzt letzte Woche vorgestellt habe oder beziehungsweise letztendlich ja schon mit der vorletzten Woche,
weswegen man dort dann eben noch sowas wie so einen undefinierten Wert,
dieses Zügang gezeichnete oder dieses X eben hat,
ist eben um genau sowas zu signalisieren.
Das heißt, typischerweise haben dann eben solche Simulationsmodelle von Flipflops oder von Ledges eben diese Eigenschaft,
dass wenn sich gleichzeitig hier Daten eingang und Clock ändern,
die dann also an den Ausgängen eben letztendlich sowas wie so in undefinierte Werte generieren,
um eben den Benutzer dann eben auch zu zeigen,
okay, du hast hier letztendlich irgendwo ein Timing-Problem.
Rein technisch gesehen ist es natürlich so, da wird nicht irgendwie x gespeichert,
weil also da wird eine Null oder da wird eine 1 drin stehen,
aber man kann sich eben nicht sicher sein,
was genau es sein wird, nicht weil je nachdem,
ob jetzt also hier Weil also okay,
was ist absolute Leichtzeitigkeit, nicht?
Also das wird dann also innerhalb von irgendwie ein paar Pico-Sekunden,
also hier vielleicht doch noch irgendeine Verzögerung sein,
die dann eben dazu führt,
dass eben hier entweder eine Null- oder eine Eins gespeichert wird.
Und je nachdem, wie dann eben auch noch irgendwie solche Parameter für Versorgungsspannung oder sowas aussehen,
kann eben auch mal das eine, mal das andere passieren.
Das heißt, deswegen muss man da dann eben immer sagen,
okay, also genau dafür ist dann eben so ein X
oder so ein undefiniert dann eben auch noch entsprechend gut,
um dann eben zu zeigen,
okay,
es geht dann also hier
solche Zeitbedingungen
Okay, welche Zeitbedingungen müssen eingehalten werden in Fliptops?
Dazu werden wir uns jetzt also gleich mal anhand dieses Automatenmodells
kurz überlegen, was dort eigentlich gelten müsste.
Wie gesagt, ein Fliptrop selber ist in dem Sinne,
also sowas wie ein asynchrones Schaltwerk. Und um jetzt eben zu sagen,
dass das jetzt in einem definierten Zustand 0 oder 1 nach der und der Bedingung landet,
muss ich dann eben letztendlich, also irgendwo diese externen Zeitbedingungen haben.
Grob gesprochen kann man eigentlich immer sagen,
Daten- und Takteingänge dürfen sich nicht leichtzeitig ändern,
weil das war also genau das,
was also da eben der Fall war, wo man sagt, okay,
also ich schalte in einem Ledge quasi meinen Pegel ab und gleichzeitig ändert sich der Dateneingang und was wird dann eben genau gespeichert,
beziehungsweise bei Flipflops kann man dann eben auch sagen,
wenn ich hier also meinen Takt vorderflanke habe und sich eben gleichzeitig jetzt mit der Taktvorderflanke der Dateneingang ändert,
was wird dort gespeichert.
Deswegen werden typischerweise dort immer bestimmte Zeiten bzw. Zeitbedingungen beschrieben, die eingehalten werden müssen. Und das,
was man dort eigentlich immer sagt, ist,
also wenn ich jetzt sehe, dieses Impuls hier rahmen nehme,
ich habe sowas wie eine Vorlaufzeit und eine Haltezeit,
die so definiert sind, dass man sagt,
also wenn ich jetzt hier meinen Tag Vorderflanke habe,
ich höre sie hier jetzt also auch immer ein bisschen,
zumindest teilweise realistischer, also schon nicht mehr, also komplett als Rechtecke,
sondern also irgendwie mit so einem leichten trapezförmigen Anstieg,
dass man sagt, also von dieser Tagforderflanke habe ich eben eine Mindestzeit,
wo also quasi der Dateneingang stabil sein muss.
Und wenn diese Mindestzeit eingehalten ist, das heißt also,
der letzte Wechsel eben maximal hier stattgefunden hat,
dann habe ich eben definierten Ausgangswert.
Gleiches gilt dann eben quasi noch als, deswegen Setup-Zeit,
Whole-Site als Haltezeit nach dem Wechsel der Taktflanke
Und zusätzlich hat natürlich das Flip-Flop selber auch noch irgendwo intern eine Verzögerungszeit.
Das heißt, wenn ich jetzt also hier einen Wert übernommen habe,
dann wird der sich natürlich an dem Ausgang dann auch noch nach einer bestimmten Verzögerungszeit erst auswirken. Gut,
und deswegen wird typischerweise gerade mit diesen Setup- und Holzzeiten,
also letztendlich definiert, wenn man jetzt,
also wenn man irgendwelche Datenblätter von irgendwelchen Bausteinen reinguckt,
dass sich eben hier quasi so ein bestimmtes Intervall habe,
um die Flanke herum,
wo sich eben diese Eingänge nicht ändern sollten.
Nicht wenn das eingehalten wird, funktioniert das Ganze stabil,
wenn das
nicht eingehalten wird
Habe ich eben vielleicht den falschen Wert gespeichert, beziehungsweise das,
was die Simulationsmodelle oder eben teilweise Hades dann eben auch machen,
ist das dann eben entsprechend am Ausgang ein X erscheint,
wenn diese Zeitbedingungen nicht eingehalten wurde.
Gut, wodurch kommen jetzt diese Zeitbedingungen eigentlich genau zustande?
Also wenn wir jetzt wieder auf dieses formale Modell eines endlichen Automaten zurückgehen,
kann man sagen, okay, ich habe hier jetzt also ein Moorautomaten,
Ausgangsschalten jetzt, okay, das soll jetzt nicht weiter interessieren.
Also das, was uns interessiert, ist eigentlich jetzt,
also die Stelta-Schaltennetz und eben hier diese Verzögerung hier.
Einmal jetzt bezogen auf den Eingangsvektor, also auf meinen Wert X.
Und zwar, ich habe jetzt hier einen Takt,
zu diesem Tag soll sich der Zustand ändern. Wenn dieses jetzt also ein Flipflop ist mit Hohlzeit und mit Setup-Site,
Dann gilt quasi jetzt zwischen zwei Takten, also wenn ich jetzt sage,
ich habe hier einen Takt zum Zeitpunkt T1,
der nächste Tag kommt zum 2. T2,
wann darf sich überhaupt jetzt hier nur dieser Eingang ändern,
damit die Hohlzeitbedingungen eingehalten wird, muss quasi gelten,
Hohlzeit minus der schnellsten Verzögerung durch dieses Schaltnetz,
ist halt Dieser Bereich hier,
wo sich quasi nach einem Takt als frühestes der Eingang ändern kann.
Nicht, wenn sich der Eingang später ändert,
ist in Ordnung, dann habe ich also diese Hohlzeit nicht verletzt,
wenn er sich vorher ändert.
Das heißt also meinetwegen hier an dieser Stelle direkt nach der Taktflanke,
dieses Schalten jetzt jetzt hier sehr schnell ist,
würde sich also quasi noch innerhalb der Hohlzeit hier dieser Wert ändern.
Ich habe dann eben die Zeitbedingungen von dem Flipflop
letztendlich verletzt
So, auf der anderen Seite gilt in Bezug auf den
nächsten Takt. Ich habe sowas wie die Setup-Zeit und
ich habe hier natürlich also auch irgendwie eine maximale Verzögerungszeit,
die sich also in diesem Schaltennetz also irgendwie ergibt.
Und entsprechende Summe aus Setup-Zeit und maximaler Verzögerungszeit habe ich dann eben hier noch irgendwas,
wo dann also quasi vor dem Taktzeitpunkt T2 der Eingang sich dann also überhaupt erst ändern kann.
Das heißt, wenn man beides jetzt zusammennimmt,
bleibt eben letztendlich genau dieser grün markierte Bereich übrig,
zu dem sich also ein Eingangsvektor X zwischen zwei Takten Hier und hier ändern darf.
Gut, hier ist das Ganze also nochmal,
was hier gerade so gerade eben jetzt so beschrieben hatte,
also nochmal entsprechend aufgeschrieben zum Nachlesen. Also wie gesagt,
letztendlich, es gilt dann eben einmal als Bedingung aus der Haltezeit,
T-1 plus T holt, minus Tau, Del Damin.
Und entsprechend für die Vorlaufzeit zum nächsten Tag muss eben
gelten T-2 minus T-Setup, T-Del Dam Marx.
Und dann bleibt eben letztendlich genau dieser Bereich über.
Gut, das ist also jetzt das,
waren sich der Eingangsvektor
ändern darf
Was gilt jetzt andersrum gesehen für den internen Zustand?
Auch hier wieder diese Situation, zwei Taktflanken.
Zum Zeitpunkt T1 und T2. Was passiert?
Nach der Taktflanke habe ich im Flipflop eine Verzögerungszeit.
Das heißt, nach Ablauf dieser Verzögerungszeit, TFF,
wird sich der Zustand ändern.
Nämlich weil dann also hier quasi der Zustand ja
von diesem Z Plus entsprechend hier umschaltet
So, und dann kommt natürlich jetzt also auch wieder minimale oder maximale Verzögerungszeit hinzu.
Und was dann eben gelten muss, ist,
dass diese Verzögerungszeit plus minimale Verzögerungszeit größer sein muss als die Haltezeit,
also was jetzt also hier dieser Bereich ist,
wenn das kleiner ist als die Haltezeit,
hätte ich dort also
eine Haltezeitverletzung
Das wäre jetzt natürlich irgendwo was Unschönes,
weil das würde nämlich heißen, dass ich also hier einfach in dem Schaltnetz
schon mal irgendwie zusätzliche Gatter oder zusätzliche Verzögerung einbauen müsste,
damit das Ganze überhaupt noch funktioniert.
Ich weiß sonst quasi mit dem Takt sich selber
seine eigene Haltezeit kaputt macht. Gut,
und andersrum gesehen habe ich natürlich jetzt also aus Flipflow-Verzögerungszeit maximaler Verzögerungszeit,
also quasi hier die Maximalzeit, waren sich hier das Ergebnis ändert.
Und das muss jetzt natürlich
kleiner sein
Diese Maximalzeit, also das ja als die Setup-Zeit vor dem
nächsten Tag. Nicht, das heißt also,
solange ich hier mit diesem grauen Bereich oder diesem Bereich
jetzt hier zwischen diesen beiden Werten zwischenholt und Setup-Zeit bin,
ist alles in Ordnung.
Wenn ich da die Zeitbedingungen verletzt habe,
würde es ganz oder die Schaltung dann eben auch nicht funktionieren.
Gut, auch hier das Ganze nochmal entsprechend beschrieben
Gut, und das,
was man hier dann nämlich eben auch schon entsprechend sieht,
ist jetzt, mit welcher Maximalantaktgeschwindigkeit kann ich das Ganze betreiben?
Weil was würde jetzt eben passieren,
wenn ich das jetzt immer schneller takte? Okay,
es wird T1 und T2 immer weiter zusammenfallen,
solange ich also hier quasi mit diesem Bereich
immer noch zwischenholt und Setup-Zeit bin,
funktioniert die Schaltung
Wenn die Gesamttaktfrequenz dann aber eben immer höher wird,
beziehungsweise hier dann eben diese Periode entsprechend immer klarer werde ich ihm irgendwann entwederholt oder Setup seid verletzen.
Die Schaltung wäre übertaktet und würde dann eben nicht mehr funktionieren. Nicht,
das kann man dann eben hier letztendlich dann eben auch direkt,
also jetzt also aus diesen Überlegungen, also in diese beiden Gleichungen reinbringen,
nicht wo ich dann eben sage, okay, also es muss gelten,
also Flip-Flop-Verzögerungszeit plus Taudel da, Max plus Tauer, Setup.
Muss eben kleiner sein als insgesamt die Taktperiode und logischerweise muss die Tagperiode natürlich auch größer sein, als überhaupt, dass mal die Summe von Holt und Setup zeigt. So,
und alles andere wäre dann eben Verletzung von Zeitbedingungen bzw. rein praktisch eben genau das,
was passiert, wenn man sagt, okay,
ich fange jetzt eben an, das Ding zu übertagten,
wo man dann eben auch sagt oder sagen muss,
okay, Gerade dadurch, dass ich hier in diesen Rückkopplungen,
beziehungsweise in den Schaltnetzen ja immer unterschiedliche Pfade habe,
was ja dann eben hier immer auch mit diesem Delta,
Minne und Delta mag, gekennzeichnet ist,
kann es eben auch sein,
dass eben beim übertagten Forenschaltung es quasi datenabhängig eine ganze Zeit lang gut geht und funktioniert.
In bei bestimmten Daten dann aber ich dann also auf einmal genau,
also hier in diesem Maximumbereich bin oder hier hier in einem Minimumbereich,
je nachdem, wo ich da sehe,
die Verletzung habe.
Und dann funktioniert die Schaltung nicht und verrechnet sich
Also da ist nochmal so ein bisschen zu den Fehlfunktionen, die dort also letztendlich dann auch auftreten können. Gut,
generell, Takt oder Taktsignale, also das,
was man eigentlich immer typischerweise betrachten ist,
also hier ist so eine schöne brave digitale Welt,
nicht, also von irgendwie so einem Rechtecksignal,
war es also irgendwie zwischen logisch Nullen,
logisch eins hin und her wackelt, wo ich dann eben sagen kann,
ich habe hier irgendwo meine Periode, meistens,
also wenn ich hier sowas anzeichne,
sind diese Taktsignale auch immer symmetrisch,
das heißt also und null Pegel sind leicht lang.
Auch das muss nicht zwingend gegeben sein. Also ich kann auch
irgendwie völlig asymmetrische Taktsignale generieren, beziehungsweise damit würden die Scheidungen
auch funktionieren. Rein praktisch muss man dann aber sagen,
dass der Tag dann sowieso noch ein bisschen anders aussieht.
Kommt gleich noch, dann auch mal wirklich praktische Beispiele,
wie sowas dann letztendlich aussieht. Ansonsten,
also abhängig von den Flip-Flop-Typen haben wir ja schon gesehen,
es gibt Pegelsteuerung, wo ich eben entweder auf null oder auf eins Pegel gebe.
Es gibt dann eben Flankensteuerung, Forderflanke, Rückflanke.
Und bei einigen speziellen Elementen dann eben noch sowas wie zwei Phasentakte oder Mehrphasentakte.
Gut, hier sind nun mal die unterschiedlichen Varianten von Pegel,
Vorderflanke, Rückflanke, also für so ein Rechteck-Taktsignal aufgezeichnet.
Jetzt hatte ich ja schon gesagt, wie sieht das Ganze praktisch aus?
Also wie gesagt, wir stellen uns das immer irgendwie so vor.
Meistens wird das eher so sein, dass ich natürlich nicht
unendlich schnell von Spannung 0 auf Spannung 1 kommen kann, sondern wird schon irgendeine Zeit vergehen.
Nicht deswegen ist das dann eben technisch gesehen dann eigentlich auch eher so was. So,
und wenn man sich sowas also wirklich mal rein praktisch anguckt und jetzt sagt,
okay, ich sehe mir sowas mal, also irgendwie so auf dem Ostteleskop an,
was sie also hier vor einiger Zeit mal abfotografiert habe und das ist jetzt hier noch keine super Spezialschaltung,
die also hier irgendwie mit 4,6 Giga-Herz und übertaktet läuft,
sondern das ist also irgendwie so ein ganz stinknormaler,
einfacher PCI-Bus mit 33 Mega-Herz.
Allerdings, okay, man muss jetzt eben auch sagen,
auf dem Motherboard mit, also entsprechend schlecht abgeschirmten Leitungen,
dann sieht eine Digitalscheidung so aus, beziehungsweise das, was man misst.
Und also, obwohl das also relativ grauslich ist, das Ganze funktioniert. Also das hier ist das Taktsignal,
also dieses hier ist der Lobpegel,
das ist der High-Pegel, nicht eigentlich Zwitscher,
dass sie also irgendwie so ein bisschen so vor sich hin,
was man hier eben auch sieht, etwas,
was dann auch typisch ist, ist dann immer irgendwie so eine Art Überschwingen,
das heißt also nach so einer Flanke wird die Spannung erst mal größer.
Nicht, das beruhigt sich dann, nach dem Runterfallen häufig auch. Also hier sieht man das eben auch sehr schön. Nicht,
das sind jetzt also irgendwelche Datensignale,
die dann eben entsprechend hier einmal nach der Tagflanke umgeschaltet haben,
mit einer bestimmten Verzögerung, nicht hier dann auch,
die dann aber immer noch, sagen wir mal,
rechtzeitig vor der Rückflanke stabil sein sollten,
damit jetzt eben irgendwelche anderen Elemente,
die dann eben beispielsweise mit der Rückflanke da irgendwas mitmachen können oder die dann abhängig von der Rückflanke dann selber speichern und dann eben hier entscheiden können,
okay,
das ist eine Null und dieser Wechsel soll dann eben noch
rechtzeitig vor der Setup-Site passiert sein
Gut, aber so sieht das Ganze dann eben wirklich rein
technisch aus. Und wenn man jetzt also wirklich guckt,
was also auf den Chips passiert ist, also wirklich hochgetaktet sind,
wobei da kann man sich das nicht ansehen,
weil diese entsprechend hohen Tagfrequenzen sind wirklich nur Chip-intern und werden auch nur intern dort erzeugt.
Aber da muss man sagen,
da sind das eigentlich nur noch irgendwelche mehr oder minder sinusförmigen Verläufe,
wo das Ganze dann eben wirklich nur noch irgendwie so hin und her schwingt,
wenn ich mal sagen kann, okay,
also das interpretiere ich als Null, das interpretiere ich als eins,
aber wie gesagt,
das funktioniert.
Trotz alledem
immer noch sehr stabil
Gut, aber jetzt wieder zurück in die rein digitale Welt.
Wie gesagt, wir sahen jetzt nochmal bei den verschiedenen Taktarten.
Das, was man meistens immer nutzt in Schaltung,
sind jetzt wirklich flankengesteuerte Elemente,
wo ich eben genau über diesen Wechsel von 0-1 oder 1
-0 nach 0 gehe und nicht pegelgesteuerte Elemente.
Warum? Bei der Taktpegelgesteuerungsteuerung beziehungsweise eben bei den Ledges
ist es ja so, dass ich,
wenn ich diese Ledges jetzt als Zeitglieder in endlichen Automaten
benutzen würde
Das Ganze eigentlich nicht richtig funktionieren kann,
weil ich da dann ja letztendlich eine Rückkopplung habe,
solange das Ledge eben transparent geschaltet ist. Das heißt,
wenn das eben ein High-Transparentes Ledge ist und der Tag,
den mir konstant eins ist,
dann habe ich dort eben komplett eine Rückkopplung.
Wenn das ein Zähler ist,
der jetzt also quasi immer plus eins rechnen soll,
dann würde er eben da auch irgendwie munter rum oszillieren und
irgendein Wert würde sich ergeben.
Das möchte man da eben eben typischerweise nicht
Das heißt, das, was man dort dann machen kann,
ist, dass man dann eben noch sagen kann, okay,
ich nehme jetzt entsprechend zwei von diesen Pegelsteuernelementen direkt hintereinander,
mache dann eben so einen Zwei-Phasen-Takt oder man benutzt eben gleich irgendwelche flankengesteuernden Elemente.
Zwei-Phasen-Takt, wie gesagt, ist jetzt,
wenn ich einmal high-transparent, einmal low-transparent direkt hintereinander habe,
die dann teilweise dann auch noch mit Unterschied oder dann eben mit separaten Takten,
wobei man das dann auch eben gerade so im Sinne so ist,
schieberig ist das oder irgendwelcher logischer Elemente dann eben immer noch mit Logiker zwischen hat,
wie sie das letztendlich dann aus, also hier sind zwei Farben,
also hier jetzt zwei Takte, 4-1 und 4-
2. Letztendlich ist es im Prinzip so ähnlich wie die Smaster Slave-Prinzip,
nur dass es jetzt hier eben wirklich also noch getrennte Philip Props sind und dass man dann eben auch einen praktisch,
die jetzt nicht nur miteinander so verbunden hat,
um jetzt also quasi seine Werte Von hier,
nach hier und entsprechend weiter,
wo jetzt vielleicht noch mehr Elemente wären, durchzuschieben,
sondern wo dann eben teilweise dann eben hier zwischen auch noch irgendwelche Schaltnetze sitzen,
die dann eben irgendeine logische, eine rechnende Funktion haben,
wo ich dann eben sagen kann, okay,
also da wird dann eben noch beispielsweise jetzt irgendein Teil einer Multiplikation ausgeführt oder sowas.
Gut, und das Ganze funktioniert eben jetzt dadurch,
dass ich sage, okay,
wenn ich jetzt also hier zwei Takte habe,
die dann am besten, wir dann hier unten auch angedeutet,
dann eben wirklich so des Jungs sind,
dass sie sich hier auch nicht jetzt zwingend an den Flanken überschneiden,
wie das hier oben angedeutet ist.
Nicht dann würde das Ganze eben auch entsprechend sauber funktionieren und
man kann dann eben mit diesen Pakten entsprechend seine Werte hin und her schalten. Gut,
um sowas zu machen, jetzt kann man natürlich sagen,
okay, zwei Phasentakt hört sich ja erstmal vergleichsweise kompliziert an
und wie komme ich dann also hier zu solchen umständlich des Junkten tagten,
die kann man relativ einfach erzeugen,
also sagen wir mal durch so eine Struktur,
also hier wäre das,
wäre das entsprechende hartes Beispiel
Wo man, wenn man das jetzt mal also öffnet.
Ich hatte hier jetzt also quasi seinen Takt tat.
Gut, jetzt sieht man hier natürlich relativ wenig.
Dazu gibt es dann also das Ganze hier nochmal mit einer entsprechend größeren Verzögerungszeit.
Und wenn ich jetzt also hier gleich mal hin und her schade,
dann sieht man nämlich, also wie jetzt also diese beiden Takte,
die dann hier rausgeneriert werden, nämlich also auch entsprechend des Jungs sind.
Das heißt, wenn ich das jetzt hier eingeschaltet habe,
habe ich jetzt also hier Hiene Null, Jena 1,
wenn ich den jetzt gleich wechsle, wird eben erst der abschalten,
das heißt erst auf Null gehen und dann erst dieser Takt auf 1 gehen.
Und wenn ich jetzt wieder wechsle,
wird erst der auf Null gehen und dann der wieder auf 1
und damit hat man dann eben letztendlich genau das erreicht,
was man dann eben hier mit diesem Bein des jungen Takten
da so haben möchte,
um da jetzt also
seine Schaltung mit anzusteuern
Gut, hier wäre dann das Ganze dann eben auch nochmal als Impulsdiagramm, als Greenshot aufgezeichnet.
Also da sieht man das dann dementsprechend auch nochmal. Gut,
ja, das eigentlich erstmal so zur Theorie,
was sind endliche Automaten, asynchrone, endliche Automaten nehmen quasi dieses Basis-AS-Flip-Flop,
beziehungsweise dann eben in Erweiterung D-Ledges, D-Flip-Flops.
Das sind dann eben auch die Elemente, die letztendlich in Schaltwerken,
beziehungsweise endlichen Automaten an, also zur Speicherung der Zustände genutzt werden.
Wenn es jetzt darum geht, Schaltwerke zu beschreiben bzw. zu entwerfen,
dazu werde ich jetzt also hier nochmal,
schon mal grob anfangen vorzustellen, wie man das machen kann.
Also da gibt es also relativ viele verschiedene Möglichkeiten.
Ich kann das also entweder grafisch machen,
das heißt also durch solche schematischen Eingaben,
wie ich das also mit Hades mache, ich kann das irgendwie textuell machen.
Nicht, dann gibt es also im Prinzip Schadalgebranche,
Ausdrucke, die man nehmen kann, Flusstafel und Ausgangstafel,
sind uns ja also gerade eben schon bei den asynchronen Elementen kurz begegnet,
also damit kann man das im Prinzip auch machen.
Nicht dann Zustandsdiagramme und Erweiterung von Zustandsdiagrammen,
in diesem Fall die sogenannte Stage Charts,
werde ich dann also auch nochmal kurz vorstellen
Gut, die einfachste Beschreibungsmöglichkeit, die wir jetzt ja eben
auch schon kennengelernt haben, sind also im Prinzip Flussstafel und Ausgangstafel.
Letztendlich ist das nichts anderes als eine Funktionstabelle bei Schaltnetzen.
Das heißt, diese Flussstafel ist eigentlich nichts anderes als eine Beschreibung
des Delta-Schalennetzes. Ich habe die Beschreibung oder Codierung meines Zustandes
Und ich habe zusätzlich noch mal eine Eingangsvariablen. Nicht,
dass es dann quasi mein gesamter Eingangsvektor und abhängig von Zustand
und Eingangsvariablen habe ich dann eben eine Beschreibung des Folgezustandes.
Das heißt, das ist eigentlich nichts anderes als das,
was wir also in dem vorigen Kapitel bei Schaltnetzen in der Beschreibung
eben auch schon mit drin haben.
Ausgangstafel wäre dann eben eine Beschreibung des Landesschalennetzes,
wo ich dann eben sage,
abhängig vom Zustand habe ich eben entweder ein Ausgangsvektor für
ein Moor-Modell bzw. abhängig von Zustand und Eingangsvektor
habe ich dann eben beim Millimodell dann eben entsprechend
meinen Ausgangsvektor
So, triviales Beispiel, was uns dann also später auch noch mal kurz begegnen wird.
Eine ganz einfache Ampelsteuerung. Es sollen quasi jetzt einfach nur mal so eine Abfolge,
wie ich das jetzt, also bei so einer Ampel typische Weise habe,
durchlaufen werden von Ampel ist rot,
rot und gäbes Licht sind an,
anschließend wird die Ampel grün und zur nächsten Rotphase wechselt sie dann eben von Grün nach Gelb,
dann wieder bei Rot.
So, das heißt, diese vier Zustände werden einfach hier
erstmal nur der Reihe nach irgendwie zyklisch durchlaufen
Gut, das kann man jetzt ganz einfach natürlich machen,
indem man sagt, okay, vier Zustände,
brauche ich zwei Zustandsvariablen,
Nummer Rehe, die einfach durch,
von 0-0 bis 1-1 und kann dann quasi die Schlusstafel so aufstellen,
dass ich sage, okay,
ich habe hier meinen Zustand mit einer Zustandskodierung und habe dann eben hier jetzt quasi meinen Folgezustand mit entsprechender Zustandskodierung.
Ja, und dieses hier ist jetzt nichts anderes als eine Schaltennetzbeschreibung,
wo man dann sagen kann, okay, entwerfen Sie nicht,
beziehungsweise überführen Sie das, also ein KV-Diagramm,
minimieren Sie das und dann hält man so eine Schaltfunktion,
die mir letztendlich da nichts anderes macht,
als genau dieses Delta zu beschreiben
Nicht, das wäre also, sagen wir mal,
das einfachste Beispiel, wie man dann eben so eine Flusstafel macht.
Bei dem Ampelbeispiel die Ausgangstafel,
auch das hier mehr als trivial, dass man eben sagt,
okay, ich habe jetzt hier meine Kodierung und abhängig von
dem Zustand sollen jetzt eben hier für ein rotes,
gelbes und grünes Licht dann eben die entsprechenden Kombinationen eingeschaltet werden.
Gut, und dann kann man eben ganz normal hingehen und sagen,
okay, alles, was wir vorher schon gemacht haben,
ich habe jetzt meine Funktionstabellen, mir das Ganze,
gibt das Ganze dann eben entsprechend ein und habe damit dann also letztendlich die Stelta und das Lahm da von dem Automaten beschrieben.
Nicht, dann brauche ich noch entsprechende D-Ledges für die Speicherung der Zustände,
in diesem Fall zwei Stück und damit habe ich dann endlich einen Automaten aufgebaut.
Gut, andere Beschreibungsformen,
wie man damit dann noch weiter umgeht,
welche Möglichkeiten der Kodierung es gibt,
welche Vor- und Nachteile werden dann am Freitag folgen,
das soll es dann für heute gewesen sein,
dann einen schönen Abend