Gut, ja, wir sind jetzt inzwischen bei den Schaltwerken angekommen.
Als letztes hatte ich ja letzte Woche also vorgeführt,
dass im Prinzip bei Schaltnetzen, beziehungsweise generell,
also erst mal bei guten Ausdrücken,
aufgrund der technischen Realisierung in den Gattern letztendlich Verzögerungszeiten auftreten,
die eben dazu führen, dass die Funktionen,
die man da jetzt dann als Schaltfunktion realisiert,
beziehungsweise was in einem Schaltnetz dann entsprechend realisiert,
dass die dann eben auch eine gewisse Zeit brauchen
So, und das ist jetzt letztendlich entscheidend,
wenn man zu dem Thema Schaltwerke kommt,
weil bei Schaltnetzen ist es also erstmal reiner Gebrage zu sehen, dass man sagt,
ich habe so rumgesehen eigentlich immer nur eine Funktion oder ein ganzes Funktionen Bündel,
wo ich also ein Eingangsfektor habe,
x und erzeugt mir dann eben aufgrund dieser,
die spulschen Ausdrucks hinter dieser Funktion dann eben irgendeinen bestimmten Ausgangsvektor.
Und die Ausgabe hängt wirklich nur, wie in einem mathematischen Funktion,
also direkt eins zu eins von der Eingabe ab
Und was wir jetzt eben gelernt haben,
es wird dabei dann eben auch noch ein bisschen Zeithöhe vergehen.
So war es bei Schaltwerken jetzt der entscheidende Unterschied ist,
ist, dass es daran eben auch noch Rückkopplung in den Schaltungen geben kann.
So, und dadurch habe ich also grundsätzlich erstmal ganz andere Eigenschaften in dem System,
weil da nämlich die Ausgänge nicht nur vom aktuellen Eingangsfektor abhängig sind,
sondern gegebenenfalls auch noch von irgendeiner Vorgeschichte. Das heißt,
es gibt dann sowas wie interne Zustände und im Einfach,
sondern einen privialsten Fall, brauchen wir diese infinitären Zustände dann natürlich in einer Informatik,
um irgendwelche Werte oder um irgendwelche Informationen zu speichern.
Nicht so rumgesehen kann man eben sagen, das,
was wir jetzt in der Programmierung als Variablen irgendwo haben,
wird technisch dann eben, gut sicherlich natürlich,
also jetzt in Mautfreshung umgesetzt,
aber wenn ich da jetzt also auf Ebene in die CPU reingucke,
in den Registern, dann stellt das dann eben funktional,
wir sind sowas wie die internen Zustände eines Schaltwerks letztendlich dar.
Und da drin ist dann eben sowas wie die Geschichte, Historie von dem Ganzen letztendlich gespeichert.
So, bei diesen internen Zuständen, beziehungsweise bei dem,
was du mit diesen Rückkopplungen passiert, kann man jetzt sagen,
wenn wir Glück haben, haben wir so etwas wie stabile Zustände.
Da kann ich nämlich Informationen auch wirklich speichern. Wenn ich das nicht sauber entwerfe,
nicht richtig mache, dann habe ich da also gelinde gesagt,
sowas wie ein leicht chaotisches Verhalten, kann man sich relativ einfach,
einfach dadurch vorstellen, dass ich sage,
ich habe hier zum Beispiel sowas wie X ist gleich nicht X,
ich kann nicht jetzt sagen, okay,
technisch kann ich das aufbauen,
ich habe hier Irgendwie ein Enwärter.
Und der Eingang und der Ausgang sind einfach jetzt so eins zu eins miteinander verbunden.
Und das, was eben auch rein praktisch passieren würde,
das dann eben letztendlich abhängig von der Technologie dieses ganze System,
also irgendwo schwingt.
Möchte man nicht, sondern ich möchte also irgendwo meine Werte speichern.
Wenn ich das jetzt also nicht irgendwie so auf der Ebene von Gattern mache,
kann ich ja auch immer noch sagen, gut,
also ich kann das also auch entsprechend mit abstrakteren Beispielen machen.
Ich habe ja zum Beispiel sowas wie eine Alu.
Da mache ich jetzt beispielsweise eine Addition. Habe hier einfach als Konstante
sowas wie ein Vektor, der mit der Minerals repräsentiert.
Und hätte hier dann also irgendwie sowas wie so eine Rückkopplung. Und ja,
das, was man sich vielleicht da drunter vorstellen kann,
ist sowas wie ein Erzähler,
das ich also irgendwie immer raufzähle.
Braucht man gelegentlich
meiner Programmierung
So wird es natürlich nicht funktionieren,
weil dieses ist eben ein reines Schaltnetz und irgendein Wert,
der hier ist, wird dann also letztendlich,
also jetzt nur abhängig von den Gatterverzögerungszeiten hier drin,
irgendwie durchrauschen und gelegentlich würden da also vielleicht mal richtige inkrementierte Werte auftauchen.
Und zwar ist es Wahl,
passiert da aber dann doch irgendwie relativ viel Unsinn.
Das heißt, so wird sowas dann also nicht funktionieren,
sondern da braucht, sondern eben noch ein bisschen andere Sachen.
Das ist dann eben genau das,
was letztendlich dann in diesem Kapitel dann hier mit dran ist.
Gut, wie gesagt, also Rückkopplung ist also der allereinfachste Variante.
Man kann sich das noch ein bisschen komplizierter machen mit
zwei Variablen
Also wie das da beschrieben ist, also X ist gleich.
Und Y nicht. Und Y ist B und X nicht.
Wobei das eine Schaltung ist, die man tatsächlich sogar braucht.
Aber dazu kommen wir gleich. Gut, wie sieht jetzt
ein Schaltwerk erstmal generell gesprochen aus? Da kann man sagen,
ich habe im Prinzip sowas wie ein Schaltnetz. Ich habe hier irgendwelche Eingangsvariablen X,
berechne hier irgendwelche Ausgangswerte und eben einen Teil dieser Werte,
also dieser berechneten Werte hier aus diesen Schaltfunktionen,
stellt mir sowas wie ein Zustand dar, wo ich dann eben letztendlich in diesem Schaltnetz,
also jetzt auch über eine Schaltfunktion dann, eben entsprechend Folgezustand berechne,
in dieser Folgezustand eben entweder nach einer bestimmten Verzögerungszeit, dem aktuellen Zustand entspricht.
Oder wo man dann eben sagt, das heißt,
da habe ich jetzt eben nur reine Verzögerungszeiten,
ich habe sowas wie an dieser Stelle jetzt noch eben zusätzliche Speichernde Elemente,
die da nämlich also auch noch, deswegen ist es die Gestriche gezeichnet,
die dann nämlich auch noch ein Taktsignal erhalten,
womit ich da nämlich genau das erreiche,
was wir eigentlich typischerweise benutzen, Synchrone, getaktete Systeme,
wo ich dann also quasi über ein Taktsignal sagen kann,
zu diskreten Zeitpunkten ändern sich ja ihm hier Zustände,
beziehungsweise Ausgangswerte, abhängig von einem aktuellen Zustand und von Eingangsvariablen.
Gut, im Prinzip sieht es jetzt eben so aus,
dass man hier unterscheidet, wenn letztendlich als Verzögerung,
also dieses Tau hier dann eben nur innen drin, also die Gatterverzögerung aus dem Schalennetz wirken,
dann spricht man eben von asynchron bzw. nicht getakteten Schaltwerken.
Ansonsten hat man eben getaktete bzw. Synchrone, Schaltwerke,
die dann eben hier noch so ein zusätzliches Signal erhalten.
Gut, ja, das hatte ich eigentlich schon gerade eben letztendlich beschrieben.
Vor- und Nachteile von dem Ganzen, also wie gesagt,
synchronische Schaltwerke, Taktsignal ist eigentlich das, was,
ich sage es mal, zu 90 Prozent in der Computertechnik eigentlich verwendet wird,
weil man damit dann eben wirklich sehr gut und systematisch sein System beschreiben und handhaben kann.
Asynchronische Haltwerke, wo also im Prinzip jetzt nur Verzögerungszeiten,
die sich dann eben entweder,
also auf der untersten Ebene aus den einzelnen Gattern beziehungsweise hier drin sind dann ja auch irgendwelche Gatter,
also voller Dia und was auch immer,
an Verzögerung haben, wenn du das wirksam wird,
dann habe ich eben asynchronische Haltwerke.
Prinzipiell kann man sagen, mit asynchronen Schaltwerken könnte ich,
Computer bauen ihnen
etwas höhere Arbeitsgeschwindigkeit haben
Warum wird das nicht gemacht? Wo doch immer alle sagen,
wunderbar, immer noch ein bisschen schneller.
Das Problem ist, also zum einen ist der Entwurf,
also selbst vor relativ einfache Sachen, also schon alles andere als trivial.
Zum anderen habe ich dort dann eben wirklich genau das Problem,
dass ich eben wirklich das System schwierig eigentlich irgendwie ganz stabiler entwerfen kann,
weil solche Gatterverzögerungszeiten sind letztendlich natürlich von irgendwelchen technischen Ratbedingungen abhängig.
Und das heißt, wenn sich Temperatur, Versorgungsspannung ändern,
kann es eben sein, dass diese Verzögerung hier drin eben mal ein bisschen länger,
mal ein bisschen kürzer ist. Wenn die Bauteile älter werden,
habe ich da im Prinzip auch noch irgendwelche Alterungseffekte,
die ja teilweise mit reinspielen können und, und, und.
Also da gibt es also relativ viel an Effekten,
die eigentlich dafür sorgen, dass sich, Entschuldigung,
dass ich also nicht stabile oder zuverlässig sagen kann,
so ein Entwärter hat immer die und die Verzögerungszeit,
also vorausgesetzte kommen jetzt immer von den gleichen Herstellern, beziehungsweise ein Herstellungsprozess.
Und damit kann ich dann eigentlich weiterarbeiten und rechnen. So,
und nicht deswegen hat man in der Regel eigentlich so was wie asynchronische Schaltung nicht,
beziehungsweise versucht das da jetzt von systematischen Entwurf eigentlich zu vermeiden.
Gut, was steckt da an Theorie dahinter? Nicht der Informator ist jetzt natürlich immer glücklich,
wenn er in der Theorie ein Tupel definieren kann über irgendwas,
also das, was dem Ganzen jetzt hier zugrunde liegt,
sind endliche Automaten im Englischen, Fine-Ad-State Machine bzw. FSM immer abgekürzt,
beziehungsweise eigentlich ist das, was wir hier benutzen,
ein deterministischer, endlicher Automaten mit Ausgabe.
Dazu gibt es rum gesehen, hier jetzt bei uns zwei
Modelle, die funktional gesehen Äquivalent sind. Das heißt,
ich kann also sowohl mit dem einen Modell, dem Mili-Automaten,
also mit dem anderen Modell, dem Moor-Automaten eigentlich genau das Gleiche beschreiben.
Das heißt, es sind also quasi gleichmächtig eine Beschreibungsmöglichkeit.
So, wie sind diese Automaten definiert? Als sechs Tubel,
das heißt, ich habe eine Menge von Zuständen.
Ich habe ein Eingabealphabet, ich habe ein Ausgabealphabet,
das heißt typischerweise ein Vektor aus Nullen und Einsen
in beiden Fällen
Ich habe dann zwei Funktionen. Eine Übergangs- bzw. Zustandsübergangsfunktion Delta,
die berechnet aus einem aktuellen Zustand und einem Eingabevektor ein Folgezustand.
Und ich habe eine Ausgabefunktion Lamda. Und da unterscheiden sich
jetzt eben Mili- und Moormodelle eigentlich nur,
die jetzt eben sagt, beim Mili-Modell, abhängig von Zustand.
Und Eingabe-Vector berechne ich den Folgezustand. Nee, berechne ich die Ausgabe.
Und beim Moormodell Habe ich jetzt gerade leider verwechselt, Entschuldigung.
Also bei Moore Ausgabefunktionen, also wie gesagt, bei Mini-Modell,
Zustand und Eingabewektor, bei Moore-Modell ist die Ausgabe eben nur vom Zustand abhängig.
Und die Übergangsfunktionen sind natürlich immer von Zustand und Eingabewektor abhängig.
Und es gibt dann eben noch sowas wie einen ausgewählten Startzustand.
So, das Ganze kann man dann, wie gesagt,
ist hier also nochmal entsprechend die beiden entscheidenden Unterschiede
Ausgabefunktion über Führungsfunktionen. Und ich habe dann eben in dem Rückkopplungspfad diese Speicherglieder,
wenn ich das Ganze jetzt nochmal grafisch darstelle,
also sprich das,
was ich davor an Grafikkarte, hier nochmal entsprechend aufteile,
kann man das eben entsprechend so ansehen, dass man sagt,
also ich habe eben hier hinter diesen Zeitgliedern beziehungsweise irgendeinen getakteten Speicherelement,
mein Zustand.
Ich habe hier mein Eingabevektor und beim Mili-Automaten ergibt sich
die Ausgabe eben als Funktion von Eingabe und internen Zustand.
Und der Folgezustand berechnet sich eben immer aus Eingabe und Zustand
und beim Moorautomaten ist halt die Ausgabe nur vom internen Zustand abhängig.
Gut, was kann man damit im Prinzip machen? Also wie gesagt,
einfachstes Beispiel jetzt für sowas sind eben letztendlich solche Schaltungen mit Rückkopplung.
In dem Fall jetzt also zum Beispiel hier einfach nur sowas,
wo ich jetzt nicht wie hier an der Tafel einentwerte,
sondern also irgendwie so eine ganze Kette von den Wärtern habe.
Wichtig ist eben nur, dass letztendlich sowas wie eine ungerade Anzahl ist,
nicht dann gibt es hier noch so was wie ein Nantgarter,
womit ich dann eben sagen kann, wenn Hier der Eingang entsprechend null ist,
dann erzwinge ich hier eine Eins und das Ganze ist letztendlich dann stabil und angehalten.
Nicht, wenn dieser Eingang von null nach Eins wechselt,
dann habe ich eben genau dieses schwingende Verhalten hier in einem System und das,
was hier eigentlich dann dran hängt, ist ja nichts anderes als ein Zähler,
der einfach immer nur mitzählt, wie sich null und eins verändern. So,
und das Ganze kann man dann eben entsprechend auch,
hier in Hades gibt es es also dann eben auch hier entsprechend fertig,
als Beispiel dann irgendwie durchsimulieren und dann sieht man also im Prinzip in seinem Impulsdiagramm wieder also das Ganze schwingt und gut,
die Frequenz, mit der das schwingt,
ist dann eben davon abhängig, in Hades jetzt natürlich,
was ich also quasi hier als Verzögerung für die Gatter eingestellt habe,
in realen Schaltungen, wäre das dann eben technologieabhängig,
also sprich, welcher Herstellungsprozess, wie groß die Strukturen sind, nicht nur demzufolge das Ganze.
Solche Schaltungen werden beispielsweise dann eben auch irgendwo während der Cheffertigung nochmal also mit aufgebracht,
um eben zum Beispiel zu gucken,
wie jetzt die Güte von irgendwie bestimmten Elementen ist um da einfach hinterher nochmal so einen Test zu machen,
um eben beispielsweise dann sowas wie so eine Bauteilselektion zu machen,
dass man eben sagt,
nicht wenn das Ganze besonders schnell schwingt und besonders gut arbeitet,
nicht dann wird das also quasi die Hochpreis-CBU,
die dann eben bis Tagfrequenz so und so viel ausgegeben wird,
wenn das eben jetzt nicht mehr ganz so schnell schwingt,
weil eben während der Fertigung,
also vielleicht irgendwo im Diffusionsprozess ein bisschen was anders gelaufen ist und irgendwelche Transistoren,
also auf einmal ein bisschen langsamer schalten,
dann wird das eben die entsprechend langsamere oder niedriger,
klassifizierte CPU dann entsprechen.
Also sowas wird eben unter anderem da dann eben auch immer noch mitgemacht. Gut,
ja, jetzt habe ich jetzt ja gesagt, okay,
also formal gesehen, endlicher Automat,
zwei Schaltnetze und ich habe da irgendwo jetzt meine Verzögerung,
wie sieht das jetzt also erst mal aus,
wenn ich im Prinzip jetzt rein asynchrone Schaltung entwerfe,
beziehungsweise damit müssen wir uns also jetzt erst mal befassen,
um zu sehen,
wie man jetzt speichernde Elemente für synchrone Schaltungen hinkriegt
Da sieht es eben so aus, dass man sagen kann,
also je nachdem, wie intern diese Strukturen aufgebaut sind,
kann ich eben stabile oder nicht stabile Zustände erreichen.
Weil ich da natürlich jetzt abhängig von, was ja schon gesagt hatte,
diesen Parametern unterschiedlich schnelle oder langsame Verzögerungen habe.
Wenn ich jetzt wirklich sowas wie ein Zähler asynchron aufbauen,
wollen, oder würde aufbauen wollen, dann muss man sich dann eben wirklich noch irgendwelche Gedanken machen.
Also in der Regel, also es gibt solche Schaltungen,
aber dann braucht man also relativ aufwendige Protokolle, die letztendlich sagen,
dass wenn ich also hier am Ausgang jetzt also irgendwie stabil meine Werte habe,
dass dann erst dafür gesorgt wird,
dass also diese Rückkopplung dann zu dem nächsten Durchlauf dann wieder aktiv wird.
Wie gesagt, sowas kann man entwerfen,
ist aber da dann in der Regel dann also nicht
so ganz einfach zur Hand haben
Wie gesagt, deswegen hat man typischerweise in der Praxis dann eben synchronische Schaltwerke.
Und dort würden dann eben in diesen Verzögerungskreis,
das heißt irgendwo hier in dieser Rückkopplung,
dann eben Elemente eingebaut werden,
die mit einem Taktsignal quasi synchron zu dem Takt den Zustand aufnehmen und dann eben mit dem Takt entsprechend sich ändern.
Und damit könnte ich dann eben beispielsweise so einen Plus-1-Zähler entsprechend realisieren.
Und das, was dort dann als speicherndes Element genommen wird,
sind eben
sogenannte Flip-Flops
Ein Flip-Flop ist im Prinzip nichts anderes als selber ein asynchrones Schaltwerk.
Was aber so entworfen ist, dass es stabile Zustände hat
und dadurch in sich jetzt nicht ständig irgendwie schwingen würde.
Und diese Flip-Flops kann man dann eben im Prinzip so aufbauen bzw. so erweitern,
dass sie dann eben noch mit zusätzlichen Eingangssignalen,
die ich dann eben letztendlich als Taktsignal benutze,
so gesteuert werden können, dass man dann eben in größeren Zusammenhang,
also sprich in solchen Beispielen dann eben letztendlich sein System aufbauen kann.
Da gibt es jetzt also noch mehrere Varianten,
wie jetzt das mit dem Taktsignal umgesetzt werden kann,
würde ich nachher dann also auch noch entsprechend vorstellen.
Gut, und wie gesagt, solche Synchronschaltwerke,
das ist eigentlich in der Regel das,
was also hier jetzt nochmal im Rahmen von irgendwelchen kleinen Übungsaufgaben
vielleicht mal vorkommen wird und das,
was also auch rein praktisch in der Regel genommen wird
Gut, also die Flip-Flops hatte ich ja schon gesagt,
sind im Prinzip selber dann asynchronische Schaltwerke,
die werden dann eben so aufgebaut,
dass sie zwei stabile Zustände haben können,
was sie mit diesen zwei stabilen Zuständen, natürlich erreiche ich,
dass letztendlich genau ein Bett irgendwie speichern kann.
In der Literatur findet man dann häufig statt den Begriff Flip-Flop,
dann also auch immer noch irgendwie sowas wie bisstabile Bauelemente,
Kippglieder, was auch immer, also ob das irgendwie eingedeutscht ist oder nicht.
Letztendlich Ist das damit aber im Prinzip das Gleiche.
Gut, wie wenn solche Flip-Flops beschrieben,
beziehungsweise was ist da dann die Basis dafür? Letztendlich,
hatte er ja schon gesagt, werden die in solchen Rückkopplungsfaden eingesetzt,
sind dadurch eigentlich die elementaren Bauelemente,
die dann also im größeren Zusammenhang in Schaltwerken eingesetzt werden.
Typischerweise haben die dann eben genau zwei Zustände und werden beschrieben durch etwas,
was natürlich auf der nächsten Folie kommt,
ein Zustandsdiagramm bzw. sogenanntes Zustandsübergangsdiagramm
Haben dann eben in der Regel einen Ausgang, der dann
letztendlich den Zustand irgendwie ausgibt, also sprich 0 oder 1.
Meistens hatten wir dann eben auch noch einen direkten invertierten Ausgang. Gut,
ich hatte ja schon gesagt,
Flipflop selber sind eben an sich eigentlich asynchronische Schaltwerke,
die sind aber eben so entworfen, beziehungsweise sollten so angesteuert werden,
dass sie eben quasi jetzt keine,
oder nicht ins Schwingen kommen und dadurch dann eben quasi genau diese beiden stabilen Zustände haben.
Gut, von dem Flipflop selber gibt es dann also einen ganzen Satz unterschiedlicher Typen,
die werden jetzt also hier im Einzelnen noch vorgestellt.
Gut, was ist Grundfunktion oder Grundfunktionalität,
wie man sowas aufbauen kann
Also, wir stellen uns von dem,
wir nehmen also entweder zwei Endgatter, so wie hier,
oder zwei Norgatter, sowie unten,
und beschalten die quasi jetzt hier mit zwei Eingängen.
R und S für Reset und Set.
Und die Ausgänge dieser Gatter sind dann quasi überkreuzt,
dann jeweils hier in den zweiten Ahlengang die Sendung,
beziehungsweise hier dieser Endgatter,
So wie es jetzt die grobe Funktionsweise,
wenn man sich das also jetzt einfach mal veranschaulicht,
ist im Prinzip dieser Tabelle hier zu entnehmen.
Ich will das jetzt also hier an einem Beispiel,
also in diesem Fall beispielsweise mal an dem Norm, RS-Flip-Flop beschreiben.
Also wenn, ich beispielsweise den S-Eingang,
also das S steht dann für Set,
er steht für Reset, dieses S auf Einsätze
Geht hier in einen Norgatter rein. Damit erzwinge ich an
dem Ausgang hier eine Null. So, gleichzeitig sage ich
jetzt, ich bin jetzt hier genau in dieser Zeile.
Es ist gleich eins. Gleichzeitig ist R gleich Null.
Jetzt ist hier der Eingang eine Null. Dieser zweite Eingang
ist auch eine Null. Das erzeugt hier an dem Ausgang
einer Eins. Das heißt, dieser Ausgang Kuh wäre eins.
Das Flipflop hat eins gespeichert. Daher dann ja auch
der Name S for Set, weil damit habe ich jetzt
nämlich hier eine Eins reingespeichert
Hier ist eine Eins und gut, die erzeugt hier wieder eine Null,
beziehungsweise das hatte ich ja hier schon durch den Eingang.
So, wenn jetzt aber das S von 1 wieder auf Null zurückgeht,
habe ich dadurch, dass ich hier einmal diese Eins reingespeichert habe,
den Effekt, dass ich das Ganze dann quasi erhält.
Das heißt, in diesem Fall ist es gleich Null und Erst,
gleich Null, wenn ich vorher entsprechend das hier an einmal gesetzt habe,
bleibt der Wert gespeichert.
Zurücksetzen kann ich das ganze Land eben mit Er wird gleich eins,
es bleibt gleich null, wird das Ganze entsprechend durchgehen.
Und das führt dann dazu, dass eben hier der Ausgang Q0 wird und NQ1 wird.
So, und das Ganze funktioniert jetzt eben für die Fälle,
dass man sagt, wenn beide Heingänge null sind, ändert sich nichts.
Ein Wert bleibt letztendlich gespeichert. Wenn ich was setzen möchte
, ist es gleich eins erdleich null.
Wenn ich was zurücksetzen möchte, ist gleich null erdleich 1.
Nur für den Fall, wenn beide gleichzeitig eins sind,
habe ich die Situation, dass ich hier an beiden Ausgängen jeweils eine Null erzeuge?
Das stört erst mal nicht. Das Problem taucht nur genau dann auf,
wenn ich von diesem Zustand beide gleichzeitig auf 0-0
schalte und hier diese Verzögerungszeiten letztendlich auch gleich groß sind,
weil dann würde das Ganze zwischen 0 und 1 hin und her schwingen.
Deswegen steht dann also hier in dieser Tabelle vorbinden, weil das sollte dann eigentlich dieser Phase nicht auftritt. Muss dann auch wieder sagen,
rein technisch in irgendwie technischen Schaltungen wird das nicht auftreten,
weil man auch da dann wieder sagen kann,
in der Regel sind die Verzögerung von zwei Gattern,
also nicht komplett identisch,
sondern werden sich dann doch irgendwie noch um ein paar Pico-Sekunden unterscheiden,
was dann doch dazu führt,
dass das Ganze dann also bei irgendwie einem bestimmten Zustand dann entweder eins oder null gespeichert dann hängen bleibt.
So, genau das Gleiche oder genau in der gleichen Weise
funktioniert im Prinzip das Ganze dann mit solchen Rückgekoppelten Nance.
Da ist es jetzt nur so, dass sich hierbei,
wenn ich also hier quasi mit dem Hund arbeite,
der aktive Effekt dadurch erzeugt war,
dass ein Eingang auf Null geht, deswegen sind hier,
wenn das Ganze inaktiv ist, es gleich 1 und Erdgleich 1.
Und wenn es dann gleich null wird,
dann erzwinge ich eben genau hier am Ausgang eine 1.
Und es tut sich dann was, beziehungsweise wenn Erdgleich null ist,
erzwinge ich hier eine 1. Demzufolge wird dann also die Tabelle gehen.
Gut, also wie gesagt, das kann man sich ja so relativ einfach überlegen,
beziehungsweise selber also auch mal mit Hades durchspielen. So und wie gesagt,
wenn ich jetzt eben diese Ansteuerung dieser beiden Signale R und S. entsprechend nach diesem Schema mache,
dann habe ich im Prinzip mit diesen beiden Gattern eine Struktur,
wo ich eben wirklich stabil entweder einen Wert eins oder ein Wert null irgendwo speichern kann.
Gut, und dieses Grundprinzip von eben irgendwie so über Kreuzrückgekoppelten Gattern,
das liegt eigentlich allen speichernden Elementen in Computern
letztendlich irgendwo zugrunde
Zumindest solange ich jetzt im Bereich der CPU bin,
das heißt also quasi im Prozessor selber,
wenn ich beim Hauptspeicher bin, also beim DRAM, also das,
was man also im Prinzip so als Speicherregel entsprechend reintut,
da ist ein anderes Funktionsprinzip wie Informationen gespeichert wird.
Da passiert das im Prinzip so, dass auf einem Kondensator
letztendlich elektrisch, also irgendwo der entweder aufgeladen wird,
Information ist gleich eins oder der entladen wird.
Information ist gleich null. Da habe ich dann aber eben
genau wie jetzt wieder den Nachteil, die Bauteile entladen sich selber auch.
Das heißt, von Zeit zu Zeit muss eben dafür gesorgt werden,
dass also quasi diese gespeicherte Information dann also nochmal wiederhergestellt wird.
Das Ganze nennt sich dann Refresh. Und wie gesagt,
da ist das dann ein bisschen anders. Das ist aber dann
natürlich noch ein bisschen effektiver jetzt von einem Größen bzw. von dem Platzbedarf.
Weil da kann ich sagen, ja gut,
da kann ich Jetzt natürlich problemlos so und so viele Gigabyte
an Hauptspeicher irgendwo haben und brauche für jedes Bit so rumgesehen,
so was wie einen einzigen Transistorum, die Informationen zu speichern.
Bei so einem Basis-RRS-Flip-Flop, wie ich das hier habe,
kann ich jetzt eben sagen, brauche ich acht Transistoren,
um das zu machen, zumindest in dieser Schaltungstechnik.
Es gibt auch noch andere Schaltungstechniken,
wo man noch mit ein bisschen weniger auskommt,
aber im Großen und Ganzen braucht man dafür dann eben entsprechend
Mehr Aufwand kostet mich mehr Fläche. Demzufolge habe ich daran
auch entsprechend das Ganze nur in den Teilen,
wo es dann eben wirklich entsprechend nötig ist.
Dafür braucht man aber bei sowas dann eben keinen Reflege,
sondern solange die Schaltung hier an der Versorgungsspannung hängt, bleibt die Information erhalten.
Gut, ja, solche RS-Flip-Flops. Wie gesagt,
in der Regel hat man immer diese überkreuzt dargestellten Funktionen.
Man kann das Ganze auch entzerrt zeichnen. Also hier ist
das Ganze mein hartes dann also einmal ein bisschen anders gezeichnet.
Letztendlich habe ich da dann aber eben auch Hier eben eine Rückkorblung,
nicht weil das ist eigentlich letztendlich immer der entscheidende Teil, der dafür sorgt.
Gut, wie funktioniert sowas jetzt,
beziehungsweise wie wird das dann eigentlich jetzt funktional noch weiter beschrieben,
um jetzt also solche Asynchronschaltungen beziehungsweise Schaltwerke überhaupt erst mal zu beschreiben?
Das, was man dazu typischerweise hat,
ist dann eben so was wie dieses hier Zustandsdiagramm,
beziehungsweise Zustandsübergangsdiagramm oder etwas, was sie auf der rechten Seite ist, was sich Flusstafel nennt.
Wie ist das Ganze letztendlich zu lesen? Ich habe für jeden Zustand,
wie gesagt, wir können jetzt auch in die Theorie gehen,
Automatentheorie, ich habe irgendwelche Zustände,
einen Übergangswechsel zwischen Zuständen wird dann eben immer mit irgendwelchen Fahlen
gekennzeichnet und als Beschriftung an den Kanten habe ich dann eben sowas wie einen Eingangsvektor,
der mir dann eben beschreibt, unter welchen Eingangsvariablen ich, von welchem Zustand, in welchen anderen Zustand wechseln.
Nicht und innen drin in den Knoten bzw. in den Zuständen
habe ich dann in dem Fall jetzt den Zustandsvektor,
also sprich mal eine aktuelle Kodierung des Zustandes,
was also beim S-Flip-Flop, eben eine von den vier Kombinationen ist.
Nämlich 1-1, 1-0, 0-1.
Und 0-0,
was ich im Prinzip hier haben kann und die Eingänge wäre
dann eben die entsprechenden Kombinationen für S und R. Gut und wie funktioniert das Ganze jetzt?
Also wie gesagt, ich habe hier meinen Zustand.
Ich habe hier meine Eingänge oder meine Eingabe für Set und Reset.
Und beim Nore war das ja so,
dass ich quasi als inaktiven Teil beide Null habe.
Und wenn Set gleich eins ist, gehe ich eben und erdleich Null,
gehe ich eben in den Zustand,
Kuh oder in den Zustand 1-0,
also Kuh ist gleich Null, NQ oder Kuh ist gleich 1, NQ ist gleich Null.
Ich ist dann eben hier entsprechend abzulesen, dass ich sagen kann,
wenn ich in dem Zustand 1-0 bin und die Eingabe 1-0 ist,
Dann blage ich in diesem Zustand, wenn ich in dem Zustand 00 bin,
Eingabe 1-0 gehe ich wie in den Zustand 1-0 und so weiter.
So und dadurch kann man dann eben jetzt für alle Eingabekombinationen letztendlich dann immer sehen,
wie ich jetzt also von einem Zustand hier entsprechend wechsle in einen anderen Zustand und was man dann eben hier erst dieser Flussthafe dann immer sehr gut ablesen kann,
ist eben das, was hier rot gekennzeichnet ist,
nämlich sogenannte stabile Zustände, wo ich dann eben sagen kann,
entweder, wenn ich beispielsweise hier Sätzen aktiv habe oder gar nichts aktiv,
also es ist gleich 0 und er ist gleich 0,
ich bin in dem Zustand 1-0,
ich bleibe in diesem Zustand, wenn beispielsweise ich jetzt in diesem Zustand bin,
das Reset wird aktiv führt das dann eben dazu,
dass ich in den Zustand 0-0 gehe,
in dem Zustand 0-0, resect aktiv, gehe ich in den Zustand 0-1, in dem Zustand 0-1, resect aktiv bleibe ich.
Hier habe ich hier meinen stabilen Zustand erreicht. Das heißt,
ich würde dann beispielsweise jetzt einen Übergang gehabt haben von dem Zustand 1-0 nach 0-1,
wenn das Reset aktiv ist,
nämlich über diese Kante und über diese Kante lande ich dann
eben entsprechend in diesem Zustand
So, damit habe ich dann also eine Möglichkeit,
also das Verhalten grafisch zu veranschaulichen zu beschreiben,
beziehungsweise dann eben hier nochmal eben diese Übergänge beziehungsweise Zustandsübergänge dann in zu nahe Flusstafel anzeigen zu lassen.
Gut, das, was man jetzt natürlich haben möchte,
hat er gesagt, also im Prinzip aller einfachste Form ist im Prinzip mit diesen beiden rückgekoppelten nennt oder Norgattern.
Wenn ich jetzt das Ganze mit sowas wie einem einzelnen Taktsignal benutzen möchte,
dann gibt es da eben eine Erweiterung,
dass ich dann also dieses,
die Signale Reset beziehungsweise Set beispielsweise dann also hier noch irgendwie,
wenn das jetzt also hier so ein Nor-RS-Flip-Flop ist,
wo sie quasi aktiv eins sind,
dann eben über einen und Gatta mit dem Taktsignal verknüpfe,
sodass ich eben sagen kann, wenn der Takt nicht aktiv ist,
Dann bleibt eben hier alles Intren gespeichert,
weil ich damit letztendlich mit C gleich Null erzwinge,
dass beide Eingänge hier gleich Null sind.
Wenn der Takt 1 ist und sowohl Set als auch inaktiv
sind, bleibt es logischerweise auch gespeichert.
Ansonsten habe ich eben hier entweder Set, gleich 1,
Reset, gleich Null, das Setzen.
Sorum kodiert das Rücksetzen und auch da kann ich natürlich wieder so
eine Situation haben über etwas, was eigentlich so erstmal nicht vorkommen sollte.
Gut, die schalt Funktionen, kann ich logischerweise an je direkt,
also rauslesen und hätte dann eben in diesem Fall dann also quasi über diesen Ausdruck dann mein Verhalten.
Und auch das kann man dann dementsprechend alles simulieren,
sich also so nochmal anzeigen lassen, also nochmal entsprechend passend visualisieren. Nicht,
was man eben hier sieht, ist, dass letztendlich,
also Set und Reset, also genau nur dann natürlich aktiv werden,
wenn der Takt gleich eins ist,
nicht wenn der Takt gleich null ist und hier ändert sich was,
dann ändert sich also logischerweise an den Ausgängen auch nichts.
In der Regel kann ich jetzt eben immer sagen, in diesem Bereich,
wo Clock gleich eins ist, Würde sich hier was ändern?
Nicht was hier schon so ein bisschen eingezeichnet ist.
Also hier ist es also keine Skalierung oder kein Maßstab mit drin
ist, aber eben so eine Art Verzögerungszeiten oder Verzögerungsmodell.
Nicht, dass man eben sagt, okay,
wenn der Takt hier eins ist und ich habe eben beispielsweise eine eins gespeichert,
also Kurs gleich eins, NQ ist gleich null.
Reset wäre jetzt ein Set, ist gleich null,
dass dann eben entsprechend dieser Wechsel irgendwann nach Diesen Bereich hier
stattfindet und dann eben hier auch nochmal so ein bisschen angedeutet,
dass sie also erst Q ändert und an NQ ändern wird.
Gut, und das Ganze ergibt sich dann eben letztendlich also aus der ganzen Schaltung,
könnte man es eben beispielsweise, indem ich jetzt irgendwelche Verzührungszeiten eintrage,
also direkt in Hades einmal eingeben, simulieren,
beziehungsweise sich dann dort nochmal genau sowas als Impulsdiagramm dann eben beispielsweise anzeigen oder erzeugen lassen.
Gut, Ja, damit kommen wir jetzt eigentlich zu dem,
wie man Fliprops jetzt meistens dann wirklich benutzt, weil,
dass man nämlich sagt, okay, zum einen habe ich also irgendwie einen Takt dahin Gang.
Zum anderen möchte ich jetzt aber nicht irgendwie zwei getrennte Eingänge,
Reset und Set haben, sondern ich möchte eigentlich nur noch haben,
ich habe sowas wie einen Dateneingang,
also beispielsweise hier den Zählerstand und es kommt irgendwie das Takt-Signal
und dann soll eben dieser Zählerstand hier irgendwo gespeichert werden
Beziehungsweise wenn das jetzt hier natürlich ein Vector ist,
also beispielsweise ein 32-Betzähler, hätte ich hier letztendlich innen drin dann,
also 32 von solchen Flip-Flops,
die dann eben für jedes Bild eben genau speichern,
was ist dann eben der Wert und in der Gesamtheit wäre das dann eben der Vector,
der dort dann also quasi ähnlich wie oder analog eigentlich zu einer Variablen dann irgendwo gespeichert wird.
Gut, da möchte ich aber da jetzt eben nicht Reset und Set getrennt haben,
demzufolge kommt man dann zu einer Schaltung,
wo ich eigentlich also aus folgender Tabelle mit Takteingang und Dateneingang,
wir dann also nur die Funktion irgendwie rauslesen,
beziehungsweise mithilfe der Bulschen Algebar minimieren muss, dass ich sage,
okay, wenn der Takt gleich null ist,
dann soll sich der Zustand nicht ändern.
Das heißt, der Folgezustand ist immer gleich dem aktuellen Zustand,
unabhängig vom Datenwert. Wenn der Takt gleich eins ist,
dann soll quasi der Dateneingang entweder null oder eins
jeweils gespeichert werden
Nicht, das wäre das, was man dann als pegelgesteuertes Flipflop bezeichnet,
beziehungsweise da findet man auch häufig den Begriff.
Also ich werde ihn dann sicherlich auch verwenden. Das Ganze
nennt sich dann eben Ledge. Dahinter ist dann im Prinzip,
werden immer gemeint, implizit, abhängig vom Tag pegeln.
Was damit gemeint ist, wird also letztendlich gleich klar,
beziehungsweise ist ja aus der Tabelle ersichtlich,
weil wenn der Takt eins ist, wird ja quasi der Dateneingang übernommen.
Das heißt, was passiert, wenn sich während des Tages C,
jetzt hier irgendwie der Dateneingang ändert,
das also quasi am Ausgang, Kuh letztendlich,
also beispielsweise hier war das irgendwie null mit einer gewissen Verzögerung quasi jede Dateneingang entsprechend übernommen wird.
Und wenn er dann aber während der Takt aktiv ist,
also sprich immer noch eins ist,
würde dann eben auch wieder diese Änderung entsprechend übernommen werden.
Nicht deswegen Taktpegel, weil in diesem Fall der Taktpegel von C,
nämlich gleich eins entscheidet, was an den Ausgang gelangt.
So wie man sich denken kann,
kann ich jetzt natürlich das mit dem Clock-Signal auch noch spiegeln.
Nebenzufolge kann man einmal unterscheiden zwischen High-Aktiv, das ist das,
was hier an der Tafel ist oder low-aktiv,
wo im Prinzip dann nicht bei einer Eins,
sondern bei einer Null der Dateneingang durchgelassen wird.
Ich würde dann eben heißen,
dass also quasi hier eine Eins und hier
eine Null jeweils steht
Gut, und wie gesagt,
das Ganze kann man dann eben technisch realisieren, indem man sagt,
ich habe letztendlich als speichernde Struktur hier hinten eben wieder irgendwie so ein rückgekoppeltes RS-Fi-Flop,
beziehungsweise ein Basis-RS-Flip-Flop und habe dann hier vorne eben noch irgendwie die Logik,
die mir dann quasi die Set- und Reset-Eingänge von dem hier irgendwie jetzt als Schaltagebranchen-Ausdruck,
den ich mir also quasi hier dann entsprechend rausrechnen kann,
realisiert in diesem Fall dadurch, dass ich sage,
ich habe hier Clock und die nicht als Reset,
low-aktives Signal und habe das Ganze und hier die Clock dann eben entsprechend hier,
beziehungsweise dazu dann quasi invertiert dazu, das ist eigentlich das,
was diese Schaltung hier dann nur macht, dann eben mein Set-Signal hier an dieser Stelle.
Gut, das Ganze findet man dann auch immer in Hades,
also wie gesagt, Delage dann als Schalt-Symbol,
das heißt, anstatt das jetzt also intern zu zeigen,
wie das jetzt also aus irgendwie einzelnen Gattern aufgebaut ist,
findet man dann eben auch so ein Symbol,
wo ich dann im Prinzip Dateneingang habe, den Takteingang,
der ist bei Ledges,
also bei Pegel gesteuerten Elementen dann immer durch so ein quasi kleines Rechtecke kennzeichnenden Datenausgang und einen invertierten Datenausgang.
Gut, und ansonsten,
wie gesagt, Funktion Nicht also Funktion, wie gesagt,
relativ dreht Vorwort, also solange Takteingangblock gleich null ist,
kann ich hier an dem Tateneingang irgendwas hin und her schalten,
da ändert sich nichts.
Wenn Block gleich eins ist,
wird eben entsprechend des Dateneingangs hier Q bzw. NQ gesetzt und
eben beim Ledge eins aktiv
Wird dann eben entsprechend dann immer der Wert von D hier gespeichert.
Wenn die jetzt irgendeinen Wert hat, der Takt wechselt wieder auf null,
dann bleibt eben genau der Wert, den ich davor mal irgendwie eingestellt habe,
gespeichert, solange bis es hier wieder aktiv wird.
Gut, auch dazu kann man jetzt schon wieder so ein Zustandsdiagramm beziehungsweise eine Flusstafel aufstellen.
Die ist in dem Fall jetzt ein bisschen deutlich einfacher,
weil da habe ich eben jetzt genau zwei Zustände eigentlich zu unterscheiden,
nämlich entweder eine Null gespeichert oder eine Eins gespeichert.
Ich habe meine beiden Eingänge, Und dann ein Eingang,
nicht irgendwas, sondern eben sieht,
dass wenn die Block gleich null ist,
was also quasi in diesen beiden Zahlen der Fall ist,
dann bleibt jeweils der Zustand eins zu eins erhalten.
Ich habe immer einen stabilen Zustand, wenn Glock gleich eins ist.
Nicht dann ändert sich gegebenenfalls dann eben der Zustand abhängig
von dem Dateneingang. Das heißt, beim Dan.
Glock gleich eins
Datenleitung gleich eins wechsle ich eben in Zustand eins,
weil die habe ich, werde ich dann speichern, beziehungsweise umgekehrt,
glock gleich eins, Datennahlgang 0 wechsle ich in den Zustand holen.
Gut, das ist jetzt erstmal die Variante, wo man jetzt sieht,
was passiert ist mit dem Tag Pegel. So,
jetzt kann man natürlich sagen, na gut, wunderbar,
mit sowas bin ich doch eigentlich glücklich und könnte also hier so eine Schaltung,
also so ein Zähler, der irgendwie raufzählt, theoretisch aufbauen.
So, und dann muss er eben sagen,
mit pegelgesteuerten Elementen kann ich sowas nicht machen.
Aus genau diesem Grund, Block ist gleich eins,
die ganze Zeit heißt ja, der Dateneingang wird einfach durchgeleitet. Das heißt,
wenn ich hier als Tagssignal eben irgendwo so eine Periode habe,
dann habe ich letztendlich während dieser Phase nichts anderes erreicht,
als dass ich genau das, was ich vorher nämlich hatte,
hier einfach eine direkte Rückkopplung habe und irgendwelche Werte Hier irgendwie Mund da durchrauschen und nur das Ganze nur dann anhält,
wenn der Takt also irgendwann dann hier wieder von 1 nach 0 wechselt.
Nicht, das heißt, solche direkt rückgekoppelten Elemente kann ich
jetzt also mit solchen pegelgesteuerten Flip-Flops beziehungsweise mit Ledges nicht entwerfen.
War ich genau daran, also quasi eben wieder diese Rückkopplung
habe und das Ganze nicht funktioniert. Das heißt,
das, was ich jetzt also irgendwo brauche, ist,
im Mechanismus, der dafür sorgt,
dass ich jetzt Hier nicht ständig irgendwelche Rückkopplungen habe,
sondern der dafür sorgt,
dass ich also im Prinzip irgendwelche strengen Diskretenzeitpunkte habe oder vielleicht minimal kleine Zeitintervalle.
Ich könnte natürlich sagen, ja gut, ich mache ja die Taktperiode irgendwie immer kleiner.
Und wenn das hier letztendlich kleiner ist, also dieser High-Anteil,
als das, was hier innen drin als Verzögerungszeit auftritt, würde das theoretisch funktionieren.
Rein praktisch will man sowas aber eben auch nicht machen,
weil abhängig von dem, was sie eben gesagt habe,
Versorgungsspannung, Betriebstemperatur, diversen anderen Parametern verändern sich eben hier die Verzögerungszeiten.
Und irgendwann kann es eben sein, dass die Schadung,
die Form mal funktioniert hat,
wenn sie jetzt also irgendwie besonders warm geworden ist oder wenn es also ja noch,
dass es dann eben nicht mehr richtig funktioniert.
So, deswegen möchte man da eigentlich sagen, okay,
also mit diesem Trick komme ich nicht weiter, sondern das,
was man dann eben versucht oder versuchen müsste, ist,
dass man eben sagt,
ich möchte hier eigentlich nur Zeitpunkte definieren und da betrachtet man dann eben typischerweise sowas wie diese Taktflanken.
Das heißt, ein Wechsel von 0 nach 1 oder ein Wechsel von einer 1 nach 0. Und das ist dann eben das,
was also jetzt hier beschrieben ist, ein flankengesteuertes Flip-Flop,
wo man dann im Prinzip die Speicherung erreicht,
wenn sich eben das Taktsignal von 0 nach 1 ändert,
dann spricht man von einer Vorderflankensteuerung,
wenn sich das von Arzt nach 0 ändert
Hätte ich dann analog dazu eine Rückflankensteuerung.
So ein vorderflankengesteuertes Flipflop ist hier an dieser Tabelle angedeutet,
beziehungsweise beschrieben, wo man sagt, also abhängig,
wenn der Takt konstant null oder eins ist, bleibt der Wert gespeichert.
Und nur wenn ich die Vorderflanke habe,
was also hier mit diesem Fall nach oben gekennzeichnet sein soll,
dann würde ich eben diesen Datennaheingang übernehmen und das Ganze speichern.
So, und damit kann ich dann eben genau so eine Schaltung
letztendlich sicher entwerfen, weil ich dann eben sagen kann,
okay, interessant ist jetzt eben hier von so einem
Periodisch wechselnden Taktsignal immer nur die Vorderflanke
Dann wird hier ein Zählerstand genommen,
der bleibt gespeichert nach der Vorderflanke,
anschließend würde dann hier in einem Schaltnetz,
also irgendwie der nächste Zählerstart oder der nächste Wert berechnet werden und mit dem nächsten Takt,
mit der nächsten Taktvorderflanke,
also hier hinten,
wurde dann eben dieser neue Zählerstand hier gespeichert werden und
das Schaltwerk würde dann formal gesehen dann letztendlich seinen Zustand,
also den Folgezustand entsprechend ändern
Gut, wie kann man solche Flankensteuerungen erreichen? Da gibt es im Prinzip zwei Varianten,
die triviale Variante ist zu sagen,
ich nehme sowas wie so ein pegelgesteuertes Element,
also ein Ledge und schalte davon zwei hintereinander,
die letztendlich jetzt mit inversen Takten betrieben werden.
Kann man jetzt hier auf der Folie nachlesen? Ich werde das jetzt,
also ja, fahr erstmal rein praktisch in dem Beispiel erklären.
Also was ist das hier? Ich habe hier Ledge,
was jetzt beispielsweise bei Takteingang gleich null transparent ist.
Das heißt, der Wert, der hier am Dateneingang anliegt,
wird beim Takteingang gleich null quasi durchgeleitet und kommt hier hinten eins zu eins raus.
Der kommt aber nicht bis zu dem Ausgang der Schaltung,
weil dieser hintere Teil jetzt eben quasi genau umgekehrt dazu letztendlich,
also hier vom Takt her beschaltet ist
Und der leidet es eben immer nur durch,
wenn der Takteingang gleich eins ist. Das heißt,
hier habe ich irgendwas gespeichert, aber solange der Takt noch null ist,
werden Änderungen hier quasi nur bis hier wirksam.
Also, das Ganze einmal kurz in Hades angezeigt.
Also, Jetzt wollen wir hier mal was reingespeichert haben.
Also der Takt ist gleich null. Der Dateneingang ändert sich
. Und was man dann eben sieht, dieses hier war
ein Ledge, war es letztendlich null transparent ist.
Das heißt also, mit Takt leicht null wird eben dieser Eingang
hier bis hier durchgeleitet. Aber weiter kommt das Ganze nicht,
weil hier irgendwas gespeichert ist und das erst hier weitergeleitet wird,
wenn der Takt gleich eins ist. So,
wenn ich jetzt den Wechsel habe im Takt von null nach
eins und hier beispielsweise jetzt an diesem Eingang eine Null habe,
dann wird Im Prinzip dieser Teil hier transparent,
das heißt also von das, was an diesem Dateneingang anliegt,
wird hier darin gespeichert, beziehungsweise erzeugt den Ausgang Q und NQ.
Jetzt in dem Zustand,
wo der Tag gleich eins ist und der Dateneingang insgesamt ändert sich,
wird sich dieser Wert aber nicht mehr ändern,
weil das Ganze hier nicht weitergeleitet wird und Hier in dem Eingang letztendlich nur das wirksam wird,
was hier drin gespeichert ist.
Das heißt, insgesamt erreicht man jetzt also mit diesen beiden hintereinander Geschalteten,
Teilen, also das nennt man dann eben immer Masterslave.
Das eine ist da Amaster, das hier ist der Slave,
die dann also quasi invest voneinander dann hintereinander geschadet sind,
dass, wenn ich ein Nulltransparent ist und ein einst transparentes Flipflop hintereinander schalte,
habe ich eben ein vorderflankengesteuertes Flipflop,
wenn ich das umgekehrt mache,
habe ich ein Rückflanken gesteuertes Flipflop
Wie gesagt, dieses hier ist in Fortauf lang gesteuertes.
Also Takt ist gleich. Null. Irgendwas liege ich meinetwegen
wieder nahe an den Dateneingang an.
Der Takt ändert sich. Das Ganze geht auf den Ausgang
. Jetzt nach der Vorderflanke kann sich aber jeder Dateneingang wieder
beliebig ändern und das Ganze wird sich hier nie weiter auswirken
Nicht, das ist im Prinzip die Funktionsweise von diesem Master Slay Flip Flop,
also wie gesagt, hier ist es nochmal so ein bisschen länglich beschrieben,
dass man eben sagt,
also ich habe eben ein Low-Aktives und ein Hai-Aktives,
letztlich hintereinander und funktional gesehen eben warm Wechsel von Zielgleich,
nur nach Zielgleich 1,
wird eben der Dateneingang quasi genau gespeichert und dadurch erreiche ich insgesamt dann eben so eine Flankensteuerung,
dass der Wert, also gehen genau nur dann interessant wird,
wenn sich der Tag von 0 nach 1 ändert.
Gut, Ich hatte jetzt gesagt,
das ist also die, in Anführungszeichen, triviale Variante.
Man kann das Ganze noch ein bisschen intelligenter und ein bisschen anders aufbauen.
Also das ist dann hier so eine Schaltung.
Auch hier eben diese beiden Signale, Clock und Dateneingang
und das Ganze verhält sich eben wie ein Vorderflankengesteuertes Flipflop.
So, warum das Ganze sich jetzt so verhält,
will ich jetzt also hier Gattermäßig nicht mehr simulieren.
Keine Angst, das wird also auch nicht als Übungsaufgabe kommen.
Wie gesagt, man kann sich das dann aber im Prinzip
in Hades theoretisch ansehen oder nachvollziehen, wie das Ganze funktioniert.
Wie gesagt, Grundidee von dem Ganzen
Ist eben immer, dass es Teile gibt,
die eben einmal bei null und tade die Arme bei eins transparent sind und die dann eben Geeignisse hintereinander geschaltet sind. So,
und wie gesagt,
das Ganze funktioniert jetzt eben dann quasi perfekt als speicherndes Element in diesen Rückkopplungsfaden von Schaltwerken,
weil nach wie vor sind wir eigentlich bei endlichen Automaten und ich habe jetzt also hier irgendwie meinen neuen Zustandsvektor,
in diesem Fall hier ein Zählerwert und ich habe hier die Rückkopplung über dieses Zeitglied,
was dann eben in dem Fall jetzt so was wie ein Vorderflankengesteuertes Register ist,
also ein ganzer Satz von irgendwie solchen vorderflankengesteuerten D-Flip-Flops.
Und der hier drin enthaltene Zählerstand wäre dann letztendlich,
sondern der interne Zustand dieses Automaten,
der dann eben entsprechend hier immer weiter inkrementiert und raufgezählt wird.
So, das funktioniert stabil, zumindest in gewissen Grenzen,
weil Taktflanke, ja, war es jetzt nicht sein darf,
ist, dass sich dann abhängig oder relativ zur Taktflanke da dann eben noch bestimmte Sachen ändern.
Nicht deswegen hat man da dann eben auch noch Zeitbedingungen,
die jetzt also gleich noch, ich glaube,
übernächste Folie ist es dann entsprechend dann noch weiter beschrieben werden können.
Gut, jedenfalls also das, was man zwingend wissen muss,
was also auch hängen bleiben soll,
was sind Ledges
Oder pegelgesteuerte Flip-Flops, welche, wo entweder bei 1 oder bei
null transparent quasi der Dateneingang an den Ausgang weitergeleitet wird.
Bei Flanken gesteuerten Elementen habe ich dann eben entweder Forder oder Rückflanke als entscheidendes Kriterium,
um entsprechend meine Werte zu machen und mit solchen Flanken gesteuerten Elementen kriegt man dann eben auch die Rückkopplung in Schaltwerken allgemein hin. Gut,
daneben gibt es also noch gefühlt zehn verschiedene andere Flip-Flop-Typen,
also eines der Bekannteren ist dann noch hier sowas,
was ich dort K-Flip-Flop nennen,
wo ich dann da sowas wie einen Takteingang habe,
in diesem Fall Forderflanken gesteuert und dann also irgendwie zwei Steuereingänge,
die dann also letztendlich sowas wie setzen, rücksetzen, bewirken,
die dann aber eben auch noch so was quasi als,
anstatt jetzt zu sagen, ich habe einen verbotenen Zustand,
gibt es dann eben noch eine Kombination,
wo ich dann eben noch invertieren kann, also auch das,
da gibt es also noch diverse andere Varianten,
will ich jetzt also gar nicht weiter darauf eingehen,
also hier finden Sie jetzt noch irgendwie so irgendwelche Schaltbilder zu JK-Flip-Flops,
Aber das brauchen wir jetzt also hier nicht weiter,
noch genauer zu betrachten.
Da muss man auch mal sagen, die sind,
kommen im Prinzip noch so aus der Zeit,
wie man hier dann auch schon sieht,
nicht so ab den 70er, 80er Jahren, irgendwelche 74er-Bausteine.
Also auch das gab es dann irgendwann mal so als ein einfaches Flip-Flop,
um damit dann jetzt irgendwie größere Schaltungen aufzubauen.
Was dann in diesem Fall dann also aus irgendwie acht nennt,
Gattern bestand, die dann also so wie hier dargestellt dann
also irgendwie miteinander verschaltet waren
Von der Funktion her, in dem Fall dann.
Also letztendlich sowas hier realisiert haben. Gut, daneben diverse
andere Varianten, was man sich alles noch irgendwie ausdenken kann.
Aber wie gesagt, das werde ich jetzt nicht irgendwie weiter abfragen.
Nicht nur, dass man also Bescheid weiß,
wenn man jetzt in Hades mal guckt, welche Flip-Flops, welche Flip-Flop-Typen es gibt.
Also wie gesagt, das würde man jetzt also sehen,
wenn ich jetzt hier quasi Editor-mäßig irgendwie sage, Create,
Flip-Flops, da gibt es dann also irgendwie D-Flip-Flops, Ledges,
JK-Flip-Flop und dann also hier noch ein paar andere Typen,
die dann aber im Prinzip auch nicht wahrt oder größer benutzt werden können.
Hier ist das Ganze dann eben dann eigentlich mal anhand dieser
Schalssymbole realisiert nicht. Also Ledges sind immer dadurch gekennzeichnet,
dass sie haben also hier quasi am Taktsignal so ein Rechteck haben bei flankengesteuerten Elementen,
also im Prinzip Vorderflanken gesteuertes Flipflop,
habe ich dann im Hier immer so ein Dreieck.
Low-aktive Ledges, da wäre dieses hier ausgefüllt, gezeichnet bei Rückflanken gesteuerten Flipflops,
gibt es das dann also auch noch hier mit so einer ausgefüllten Dreieck,
zumindest also in den Dean-Symbolen für solche Elemente,
ist das dann eben auch entsprechend genau festgelegt,
wie sowas ist.
Was man dort dann also auch noch findet und was man
also auch relativ häufig braucht,
sind da noch irgendwie so Zusatzeingänge für Set oder Reset
In der Regel sind das dann also auch noch Schaltungen,
die dann letztendlich asynchron wirken.
Auch dazu jetzt wieder, warum brauche ich da jetzt sowas?
Vielleicht noch. Also bleiben wir einfach mal bei dieser Schaltung.
Ich habe hier sowas wie so einen Zähler.
Das Ding ist irgendwo in meinem Computer verbaut.
Was passiert beim Einschalten? Strom geht an. Versorgungsspannung ist
da. Und dann ist es eben die Frage,
welchen Zählerstand habe ich hier zu begehen nach dem Einschalten des Gerätes
So, und da sagt man jetzt also, niemand,
weil dahinter steckt ja letztendlich sowas wie so ein... Rückgekoppeltes.
Also im Prinzip hier dieses Basis, S-Flip-Flop,
also sprichst du zu zwei Nenntkarte, die jetzt also irgendwie rückgekoppelt sind. So,
und da ist jetzt nicht von vornherein vorgegeben, an einer Stelle,
also sprich hier an dem Ausgang Q nach dem Einschalten,
dass hier irgendwie immer eine Null ist und hier immer eine Eins,
sondern abhängig von eben auch irgendwelchen Bauteiltoleranzen, irgendwelchen Parametern,
kann eben hier auch nach dem Einschalten der Eins und hier eine Null stehen.
So, das heißt,
das Ding ist jetzt hier natürlich irgendwo innen drin,
in diesen Flip-Flops letztendlich verbaut,
so das Gerät wird eingeschaltet und jetzt soll es also irgendwie anfangen,
was zu machen, um meinetwegen irgendwie zu zählen.
Also das ist jetzt also jeder Programmzähler in meinem Computer.
Der soll jetzt sagen, von Adresse Null hol mir den
ersten Befehl und von da aus wird es dann also im Zweifelsfall losgehen,
dass ab dort beispielsweise das Betriebssystem irgendwo startet und steht, als Startbefehl.
So, jetzt muss ich aber technisch natürlich sagen, ja,
hier kann irgendwas Beliebiges drinstehen. Damit kann ich nicht weiterarbeiten. Das heißt,
ich muss einen Mechanismus haben,
um quasi wie in der Programmierung, wo ich eine variable,
initial irgendwo mal initialisiere, eben genau zu sagen,
mit dem Startwert meinetwegen null oder was auch immer man sich da jetzt ausdenkt,
lauf los und dann mit jedem Tag da zieht er beispielsweise jetzt eben brav Einweiter.
So, und um sowas zu erreichen,
haben die meisten oder haben eben viele Flipflops dann eben noch solche Asynchron,
Reset oder Set-Eingänge, mit denen ich eben sagen kann,
unabhängig vom Taktsignal,
wird quasi dann hier in dieses Flip-Flop an allen oder in diesem Register an allen Stellen letztendlich dann irgendwo eine Null eingespeichert.
Und dann weiß ich, okay, nach dem Einschalten habe ich hier einen Startwert null.
Anschließend kommt der erste Takt und dann zählt das Ganze eben auch
sauber 0-1, 2-3 und so weiter durch.
Also das möchte man erreichen, dafür braucht man eben genau solche Signale. Und das,
was die Geräte dann eben typischerweise eben auch haben, ist,
dass man dann letztendlich Solche Reset-Signale oder solche Set-Signale dann eben auch über ein bisschen elektrische Tricks quasi so automatisch generiert,
dass man jetzt nicht sagt, ja wunderbar,
ich schalte den Computer an und anschließend muss der Benutzer erstmal auch eine Reset-Taster drücken,
sondern es passiert auch quasi automatisch beim Einschalten, dass in dem Gerät,
sonst reset ausgelöst wird und dadurch an allen Stellen,
wo ich eben bestimmte definierte Werte brauche, ich diese auch einstellen kann.
Gut, rein formal gesehen entspricht das,
wenn wir jetzt mal wieder sagen, ja, Gregé,
da sind wir jetzt also irgendwie so mit einer abstrusen Nicht mit irgendwelchen abstrusen Gattern und sonstigen nicht,
aber auch in der Theorie habe ich sowas natürlich rein formal gesehen,
entspricht das, nämlich der im Einstellen,
so eines Staatszustandes, dass ich eben sagen kann,
dieses technische System hart als Automat gesehen, einen Staatszustand,
wo es quasi starten kann und von da aus kann es definiert loslaufen bzw. weiterlaufen.
Gut, was man jetzt bei diesem Flipflop Wie gesagt,
die Grundtypen sollte man wissen und was man dann eben auch noch wissen wollte,
ist eben letztendlich die Funktionsweise. Sprich, das,
was also hier zum Beispiel einen solchen Impulsdiagramm dann dargestellt ist,
weil bei sowas kann es dann schon mit einer gewissen Wahrscheinlichkeit sein,
dass das in Übungsaufgaben oder auch mit einer Klausur drankommt.
Hier beispielsweise einmal dargestellt, wo ich jetzt sage,
ich habe jetzt also hier ein Einbit Dateneingang, Taktsignal.
Und ich gucke mir jetzt eben an,
in diesem Fall dann auch mit so einer Einheitsverzögerung, wie das,
was ich also letzten Freitag im Prinzip bei den Gatta-Verzögerungen vorgestellt hatte,
wie verhalten sich eben ein Ledge und wie verhält sich ein Flip-Flop,
also ein vorderflankengesteuertes Bauelement in dem Fall.
Und dann kann man sagen,
ich gehe jetzt hier von einem Startwert aus,
wo jetzt also beide irgendwie mit einem Wert null initialisiert sind,
Dateneingang ändert sich, solange kein der Takt nicht aktiv ist,
wird sich also auch hier nie was ändern.
Wenn jetzt hier der Takt aktiv ist,
dann erreiche ich quasi hier durch diese Taktforderflanke,
dass eben dieser Wert von D einen Tag später sowohl beim
vorderflankengesteuerten Flipflop als auch beim Ledge quasi aktiv wird.
Nicht wenn dann der Takt ausgeht, der Dateneingang bleibt stabil
, der Dateneingang ändert sich dann irgendwann später,
aber der Takt ist nicht aktiv, bleiben diese Werte jeweils gespeichert.
Nicht hier mit der nächsten Taktforderflanke wird dann eben beispielsweise sowohl Flip-Flop als auch Ledge zurückgesetzt. So,
und der Unterschied zwischen Ledge und Flip-Flop,
das sieht man jetzt eben genau an so einer Situation,
wo quasi der während der Daten oder der Takteingang quasi hier aktiv ist,
ändert sich dann jeder Dateneingang und während das vorderflankengesteuerte Flip-Flop eben genau diesen Wert hier eine Zeiteinheit später übernommen hat,
war es natürlich auch für das Ledge gilt, Bleibt das dann eben bis zur nächsten Vorderflanke gespeichert.
Wir haben beim Ledge, wenn sich jetzt zwischenzeitlich der Datenheingang ändert,
während der Takt 1 ist, wird das Ganze dann eben entsprechend transparent weiter ausgegeben.
Das ist also dann hier dieser Unterschied. So und was
man dann hier auch noch sieht, ist jetzt eben die Situation,
was passiert, wenn sich bzw. eine Situation haben wir nicht da.
Sprich, was passiert, wenn sich Datenheingang und Takteingang gleichzeitig ändern?
Oder was passiert, wenn war im Ledge, wie hier angedeutet,
der Takteingang auf Null geht und der Dateneingang ändert sich zu dem Zeitpunkt.
So und da habe ich jetzt also hier in dem Fall
dann sowas wie dann auch wieder so ein undefiniert eingezeichnet,
was also hier jetzt nicht heißt,
da wird jetzt irgendein dritter Wert gespeichert,
sondern da steht logischerweise natürlich schon in einem realen Bauelement immer eine Null oder eine Eins drin,
was man aber eben hat ist, bei so einer Gleichzeitigkeit von Kontakteingang und irgendwelchen Datenwerte wechseln.
Das ist dann eben von irgendwelchen externen Parametern,
hatte ich ja schon gesagt, Temperaturversorgungsspannung, Bauteiltoleranzen, abhängig ist,
ob da jetzt eine Null oder eine Eins drin steht.
So, und das wäre jetzt also ein Beispiel für Situationen,
wo es eben bestimmte Abhängigkeiten zwischen Takt und Dateneingang gibt,
die eben dafür sorgen,
dass man oder das in den Schaltungen dort bestimmte Zeitsituationen
nicht vorkommen sollten
Das Ganze sieht man dann eben typischerweise noch ein bisschen genauer bei dem,
was also jetzt gleich noch vorgeschrieben wird, beschrieben wird,
wo es eben genau darum geht zu sagen, welche Abhängigkeiten dort gelten.
Ich prinzipiell muss man ja mal sagen,
also die Flip-Flops hatte ich ja eingeführt,
um jetzt eben hier in solchen Situationen, unabhängig von irgendwie den Gatterverzorgungszeiten zu sein,
sondern ich habe hier ein sauber entworfenes,
synchrones Schaltwerk und benutze das dann in meinem Automaten oder in meinem größeren Schaltwerk eben in diesem Rückkopplungspfad,
um quasi den Zustand zu speichern.
So, was aber gelten muss, jetzt eben für diesen Teil selber,
ist, dass man eben sagt,
in der Regel Daten- und Takteingänge dürfen sich eben nicht gleichzeitig ändern,
weil dann eben beispielsweise nicht klar ist, welcher Wert wird dann jetzt wirklich gespeichert. Das heißt,
wenn ich jetzt eben diese Situation habe, Takteingang ändert sich,
gleichzeitig würde eben hier an dieser Stelle sich hervorragend,
nasse Kreide, würde sich dann also hier der Dateneingang ändern,
nicht, dann kann man sagen, naja,
auch da ist es eben wieder wirklich davon abhängig,
wie ist das Ganze verdrahtet,
wie sehen also wirklich die einzelnen Verzögerungszeiten in den Norgat dann aus oder wir arbeiten wie schnell oder wie langsam arbeiten,
eine einzelne Transistoren und dann wird eben entweder mal der Wert vor dieser Taktflanke,
also die Null übernommen, es kann aber eben auch sein,
dass der Wert hier nach dieser Taktflanke,
also diese Einzige übernommen wird
Und deswegen würde man jetzt eben,
wenn man sowas quasi jetzt über ein Simulationsprogramm versucht irgendwie zu beschreiben,
sagen, in deinem System hast du hier irgendwas,
was potenziell gefährlich ist.
Und deswegen ist es vielleicht sinnvoll,
an dieser Stelle dann eben irgendwie sowas wie so
einen undefinierten Wert auszugeben, um zu zeigen,
da kann Problem auftreten
So, wie wären solche Werte bzw. diese Abhängigkeiten beschrieben?
Typischerweise hat man dazu folgende Zeitbedingungen. Ich habe jetzt hier
mein Taktsignal. Jetzt sieht man, hier wird das Ganze
schon so ein bisschen realistischer angedeutet. Also die Vorderflanke ist,
geht natürlich auch nicht unendlich schnell hoch,
sondern die braucht natürlich auch irgendwie eine gewisse Zeit,
wenn jetzt eine Spannung sich von null nach,
meinetwegen null wollt, nach 2,5 Volt ändert,
dass das also irgendwie nicht Instantan da ist,
sondern also auch eine gewisse Zeit braucht.
So, während dieser Taktforderflanke kann man jetzt eben sagen,
Die Damen müssen eben eine bestimmte Zeit davor quasi stabil sein.
Das Ganze nennt sich dann Setup, Setup-Zeit oder im Englischen eine Setup-Time, also Vorlaufzeit.
Das ist eben dieses Side-Intervall, wo man sagt,
okay, wenn sich die Daten das letzte Mal,
also außerhalb hier geändert haben, dann wird dieser Wert stabil übernommen.
Wenn sich die Daten irgendwie hier in diesem Intervall ändern,
dann ist eben nicht klar, was da letztendlich gespeichert wird.
Gleiches gilt dann eben auch noch nach der Taktflanke,
dass wir dann die Holdtime beziehungsweise Haltezeit,
wo sich dann eben auch die Daten jetzt nicht ändern dürfen.
Und letztendlich ergeben sich dadurch dann hier in diesem Intervall dann Zeitbedingungen,
die dazu führen, dass,
wenn sich hier irgendwie die Daten ändern, im Flipflop,
also mal der eine, mal der andere Wert gespeichert wird.
So, hinzu kommt zusätzlich noch, dass das Flipflop selber natürlich auch eine gewisse Verzögerungszeit hat.
Das heißt, wenn am Eingang jetzt hier irgendwelche Werte anliegen,
nicht intern läuft das ja nun auch durch irgendwie diverse Gatter,
bis sich das also an den Ausgang auswirkt, wird natürlich da dann auch nochmal Zeit vergehen.
Nicht, das ist dann das, was sie hier mit diesem TFF, also die Verzögerungszeit des Flipflops, angedeutet ist. Gut, sowas,
also gerade solche Zeitdiagramme, findet man dann also in beliebig komplizierter,
neben typischerweise auch in den Datenblättern von irgendwelchen elektrischen Bauelementen,
also sprich, wenn ich mir jetzt irgendwie was kaufe,
wird dann eben für alle möglichen Ein- und Ausgangssignale so ein Impuls,
die er gerade mit dabei sein, wo abzeigt, Abhängigkeiten,
die vielleicht vorhanden sind, dann eben genauer beschrieben sind,
wo also gesagt wird, was ist also minimale,
was ist die maximale Verzögerungszeit,
welche Randbedingungen müssen gelten,
damit das System sauber und stabil funktioniert.
Und das wird dann eben in Form solcher Impuls,
die er kam und da dann typischerweise dargestellt. Gut,
jetzt haben wir unser Schaltwerk, also unseren endlichen Automaten,
bestehend also aus diesen beiden Schaltnetzen, Delta und Lamda.
Ich habe hier in der Rückkopplung
jetzt flankengesteuerte Flipflops
So und jetzt kann man sich,
also wenn ich das jetzt also hier einfach mal in diese Grafik von dem Automaten übertrage,
kann man sich jetzt eben überlegen,
welche Zeitbedingungen müssen gelten für den Tag, beziehungsweise für die Taktperiode.
Welche Zeitbedingungen müssen gelten für irgendwelche Eingangswechsel relativ zum Takt und
was ergibt sich da dann eben an Zeitbedingungen für die einzelnen Elemente beziehungsweise für die Schalennetze hier.
So, hier ist jetzt also einmal dargestellt, was letztendlich gilt,
für den Eingangsvektor. Ich habe hier meinen Flipflop,
das hatte jetzt also irgendwie vorderflankengesteuerten Taktsignal. So,
und was jetzt passiert ist, dass natürlich,
wenn der Tag kommt,
wann darf sich das nächste Mal erst wieder der Eingangsvektor ändern,
der wird sich ändern
Hier drin habe ich eine Verzögerungszeit. Tau von diesem Schaltnetz. Typischerweise,
dadurch, dass ich natürlich einen ganzen Vektor habe,
habe ich innen drin in diesem Schaltennetz ja,
sagen wir mal, unterschiedliche Ausbreitungspfade.
Und deswegen unterscheidet man dann, also hier typischerweise noch einmal
zwischen Minimum und Maximumwerten. Nicht weil bleiben wir beim Beispiel Zähler,
wenn sich jetzt also irgendwie ein Wert malt wegen von drei
nach vier ändert oder von 4 nach 5, ändern sich ja andere Bits.
Demzufolge kann es eben sein, dass diese Verzögerung hier einmal
über drei Gatter läuft und einmal nur über ein einzelnes Gatter.
Nicht demzufolge habe ich hier drin, also auch nicht irgendwie eine konstante Verzögerung,
sondern abhängig von dem, was hier als Schaltfunktion dahinter liegt,
kann man eben minimale und maximale Verzögerungen dort reinbringen.
Das ist also letztendlich nur das, was also wodurch dieses
hier motiviert ist. Gut, jetzt habe ich also hier
meinen Takt,
der Eingangsvektor ändert sich
Jetzt soll ja gelten für das Flip-Frop, ich muss eine gewisse Hohlzeit einhalten.
So, wann kann sich das früheste Mal nach dem Takt dann wieder der Eingangsvektor ändern?
Na, die Hohlzeit gilt natürlich hier an dem Eingang,
jetzt kommt hier aber natürlich noch eine Verzögerungszeit hinzu dem zuvor,
würde ich jetzt also von dieser Hohlzeit dann diese minimale Verzögerungszeit hier abziehen.
Das heißt, Worst Case darf also nach der Taktflanke dann also in diesem Bereich,
also ab diesem Bereich sich da eingangs Vektor ändern.
So, jetzt kommt irgendwann der Takt ist periodisch, die nächste Taktflanke,
dann muss natürlich gelten, bis wann darf sich der Eingangsvektor ändern?
Zum einen habe ich die Setup-Zeit des Flip-Flops und ich habe
jetzt hier die maximale Verzögerungszeit hierdurch und dann lande ich letztendlich in diesem Grün gekennzeichneten Bereich,
der dann eben sagt, zwischen zwei Takten darf sich jeder Eingang ändern,
dann verletze ich hier keine Zeitbedingungen.
Wenn ich näher an die Taktflanke oder näher hier an die nächste Taktflanke ranrücke,
nicht daran kann ich eben immer Situationen konstruieren, wo sich also,
wo Zeitbedingungen verletzt werden und wo das ganze Ding dann eben nicht mehr vernünftig arbeitet.
Also das ist jetzt die Abhängigkeit zwischen Takt und Eingangsvektor,
also es ist hier letztendlich nochmal beschrieben,
was also gelten muss, nicht,
also dass im Prinzip frühestens Takt plus die holt minus T-Del-Damin gelten muss,
beziehungsweise nächster Tagzeitpunkt-T-Set-up minus T-Del-Damax.
Und in diesem Bereich dürfen sich Angangswerte ändern. So,
jetzt kann ich auch noch ableiten, wie sind die Abhängigkeiten
in diesem Schaltwerk jetzt für den internen Zustand.
Ich habe mein Taktsignal. Aufgrund dieses Taktsignals wird dieser Wert
hier übernommen. Der wird nach einer Verzögerung,
abhängig von einem Flip-Flop, also T-F-F hier am Ausgang wirksam
Dann ändert sich hier im Prinzip in diesem Bereich zwischen Te-Delta-Min und Te-Delta-Marx, der Ausgangsvektor.
Das heißt, damit habe ich jetzt also hier diesen grauen Bereich.
Und diese Änderung hier muss eben letztendlich in die Lücke
fallen zwischen Takt plus Hohlzeit bzw. nächster Tag minus Setup-Zeit.
Und solange das hier gewährleistet ist,
dass das letztendlich diese Verzögerung hier so groß ist,
dass ich hier also außerhalb der Hohlzeit bin.
Und ich meine, Gesamtsystem,
also sagen wir jetzt nicht so schnell Takte,
dass ich also hier quasi mit der Setup-Zeit hier wieder reinrutsche,
würde das Ganze eben entsprechend stabil laufen.
Also wie gesagt, das kann man sich relativ einfach so überlegen.
Auch das ist hier nochmal entsprechend etwas länger ausgeschrieben
Ja, das eigentlich zu den Sachen. Jetzt kann man eben sagen,
okay, was gilt jetzt als Randbedingung daraus für die maximale Taktfrequenz in der Schaltung? Gut,
da kann man jetzt eben sagen,
logischerweise kann ich meine Schaltung natürlich nicht schneller takten als das,
was sich jetzt durchholt und Setup-Zeit vorgegeben habe,
weil ich eigentlich ja nur dazwischen,
also sprich,
wenn ich das Ganze schneller takten würde und diese Takte jetzt hier entsprechend zusammenrutschen würden,
dazwischen brauche ich einen Bereich,
in dem sich
die Eingangswerte noch irgendwie ändern dürfen
Nicht. Und wenn ich das eben zu schnell takte,
dann würden sich also hier holt und Setup zwischen zwei Takten letztendlich überlappen.
Und ich würde dann eben immer irgendwie so eine Zeitbedingung verletzen.
Nicht das muss gelten und was dann eben auch gelten muss oder gelten wird natürlich,
ist, dass die Taktperiode größer sein muss,
als die Verzögerungszeit durch einen Flip-Flop,
plus die Delta Max plus die Setup.
Nicht das,
was also im Prinzip diesem hier entsprecht,
nämlich dem Ende dieser grauen Phase
So nicht. Und das sind also letztendlich die Zeitbedingungen,
die also irgendwie eingehalten werden müssen, damit Schaltwerke stabil funktionieren.
Und was passiert eben letztendlich beim Übertagten,
wenn es dann also auf einmal irgendwie nicht mehr richtig funktioniert,
wenn ich eben irgendwie falsche Werte habe.
Nicht, dass ich also diese Taktperiode eben so klein wähle,
dass hier irgendwelche von diesen Bedingungen nicht mehr richtig gelten.
Wozu führt das? Bleiben wir jetzt hier bei diesem Beispiel mit dem Zähler,
dass hier eben die Taktperiode hier so groß wird,
dass eben noch nicht der neue Zählerstand hier quasi aus dem Schaltennetz richtig berechnet worden ist.
Nicht, dann kommt der Takt, es wird hier irgendwas gespeichert
und das entspricht dann aber eben nicht dem Plus 1,
sondern eben irgendeinem zufälligen erratischen Wert.
Und wenn das also irgendwo an entscheidender Stelle im Programm ist,
dann würde es dann eben entsprechend Fehler geben.
Also das ist erstmal so ganz grob beschrieben,
die Art und Weise, weswegen Ich dann,
also wenn ich jetzt immer weiter, immer schneller tagte,
letztendlich da dann also irgendwo Probleme bekomme.
Also wie gesagt, lass jetzt das hier auf der Ebene von Schaltwerken,
wenn ich jetzt also im Prinzip in die Speicherung von Informationen gehe.
Auch da gibt es dann ja immer entsprechend ähnlich komplizierte Abhängigkeiten
zwischen Zeiten in Bezug auf solche Zeitintervalle.
Nicht und irgendwann verletzt sich da dann eben genau solche Abhängigkeiten
und würde dann eben auch wieder irgendwie mit falschen Werten weiterrechnen.
Und das System funktioniert dann nicht mehr stabil. Gut,
damit werde ich jetzt an dieser Stelle für heute Schluss machen.
Und dann entsprechend hier dann noch diesen Tal zu den Schaltwerken
passend beenden