Gut, ich hatte letzte Woche ja schon angefangen jetzt,
also hier Schaltwerke einzuführen, Schaltwerke,
wie gesagt, sind Schaltungen, die interne Zustände haben,
als Modelle hatte ich dort also kurz motiviert,
gibt es dann eben quasi zwei unterschiedliche Varianten,
Miliem-Automat oder Moorautomark, beides sind deterministische,
ähnliche Automaten von mal gesehen und als das,
was dann also quasi aus so einem Schaltwerk rauskommt,
beziehungsweise was man dann in dem Schaltwerk dann auch immer als Rückkopplungs- oder Element dieses Rückkopplungspfades mit drin hat, um eben Zustände zu speichern.
Du hast gesagt, gibt es dann eben quasi Elemente namens Frip Flops,
die letztendlich auch nichts anderes sind als in Anführungszeichen,
sauber entworfene Schaltwerke, die eben den Vorteil haben,
dass sie eben wirklich ein definiertes,
festes Verhalten in der Regel abhängig von irgendwelchen Taktsignalen haben,
dass man sich da jetzt also nicht abhängig von irgendwelchen Umgebungsparametern Versorgung,
Spannung, Temperatur oder irgendwie sowas Probleme mit dem Laufzeitverhalten Nein handelt.
So, und die einfachste Variante,
so eine Flip-Frops sind halt eben diese Basis, S-Flip-Flop,
also quasi so ein Nanch oder ein Nord,
was dann also über Kreuz zurückgekoppelt ist,
was sich eben explizit entweder mit Nullen oder im Falle des
Nord-Flip-Flops mit Einsen eben setzen oder zurücksetzen kann und wo man
dann eben letztendlich ein einzelnes Bit speichern kann
Dazu werde ich heute,
also jetzt sag mal jetzt die ganzen weiteren Varianten vorstellen und auch das,
was dann also letztendlich jetzt rein technisch immer überall umgesetzt wird,
was dann aber eben auch wirklich der zentrale speichernde Bestandteil jetzt
von irgendwelchen Registern in den CPUs unserer Rechner ist,
wo man eben letztendlich sagt,
ich habe für 32 Bit oder 64 Bit Datenworte irgendwelche speichernden Elemente,
die sind eben irgendwo an Takt angeschlossen und abhängig von irgendwelchen
Taktbedingungen oder anderen Steuerleitungen kann ich dann eben dort eins in Wort reinspeichern und das bleibt dann eben über eine längere Zeit Zumindest solange die Versorgungsspannung eingeschaltet ist, erhalten.
Gut, bei diesen Flip-Flops,
wie gesagt, also das ist die alleralleinfachste Variante,
grob die Funktionalität hatte ich ja schon am Freitag kurz vorgestellt.
Ansonsten werde ich jetzt also noch ein bisschen was dazu den Erweiterungen sagen.
Und in der aktuellen Übungsaufgabe wird dann also auch noch
ein bisschen was in der Richtung raufkommen.
Gut, also hier nur unterschiedlich gezeichnete Varianten. Wie gesagt,
entscheidend immer irgendwie eine Art von Rückführung. Letztendlich dies ist nichts anderes,
als das diese Schaltung eben einmal so ein bisschen entzerrt gezeichnet,
aber eben eine Rückkopplung ist dann wirklich da.
Gut, wie kann man diese Flip-Flops beschreiben bzw. die Funktionalität beschreiben?
Später im Laufe der heutigen Vorlesung werde ich dazu also dann auch nochmal
ein bisschen genauer diesen Formalismus beschreiben, der dann eigentlich solchen Diagramm zugrunde liegt.
Das Ganze nennt sich Zustandsdiagramm und ist letztendlich immer irgendwie so zu lesen,
dass man sagt, ich habe quasi hier in diesen Kreisen
den Zuständen immer irgendwie jetzt den aktuellen internen Zustand der Schaltung.
Und an diesen Feiern angedeutet, sind dann quasi immer die
Übergänge beschrieben, die unter einer bestimmten Eingangsbelegung letztendlich stattfinden.
Also Zustandsdiagramme, die eine Art und Weise der Beschreibung,
das, was man dann auch noch häufig hat,
sind also sonst solche Flusstafeln, auch dazu eine kurze Beschreibung.
Also ich habe jetzt hier einfach da rein nach aufgelistet meine Zustände,
die sind hier immer kodiert,
einfach durch die Kombination von Q bzw. Q Strich,
sprich das, was ich hier dann wirklich in den Schaltung,
wenn ich das jetzt zum Beispiel mit Hades simulieren würde,
also am Ausgang aufsehen würde, für die beiden Leitungen.
Das ist jeweils zu lesen quasi der aktuelle Zustand und unter den Eingaben.
Ich habe hier zwei Steuersignale, Set und Reset.
Demzufolge kann ich also vier unterschiedliche Eingabekombinationen haben.
Das sind also dann immer hier diese Spalten und unter den
jeweiligen Eingaben kann ich dann eben hier ablesen,
wenn ich in einem bestimmten Zustand bin und eine bestimmte Eingabe
habe,
was ist der Folgezustand
Das Ganze ist dann eben letztendlich so zu interpretieren,
dass man sagt, okay,
also ich kann das eben entweder hier in dieser Flusstafel oder hier in einem Zustandszirkram machen,
also angenommen, ich bin jetzt hier in einem Zustand 1.0,
das heißt, es ist also irgendwie in diesem, ja,
es flippt flop ner 1 gespeichert und als Eingabe wird jetzt quasi irgendwas angegeben,
was für das Set don't care ist,
aber das Reset soll eins sein,
dann wechselt eben hier der interne Zustand von 1.0 nach
Was dann eben auch entsprechend entweder dieser oder dieser,
diesem einen Tag in der entsprechenden Flusstafel entspricht.
So und wenn das Reset dann eben immer noch eins ist und das hätte Signal beispielsweise null,
würde ich dann also quasi unter der Eingabe 0-1,
erst sein Übergang nach hier und dann in diesen Zustanden waren,
nicht was man dann eben hier auch entsprechend ablesen kann,
von 1-0 würde ich mit der Eingabe 0-1 in den Zustand.
0-0 gehen und im Zustand 0
-0 mit der Eingabe 0-1 in den Zustand
0-1 im Zustand 0-1 mit dieser Eingabe
bleibe ich, was in diesem Fall dann also quasi hier
durch diese Rückführung auf sich selbst gekennzeichnet ist. Nicht,
wenn ich hier starten würde als Eingabe 1-1 habe,
bleibe ich eben erstmal hier bei diesem Zustand letztendlich hängen.
Und was man hier auch sieht,
es gibt dann eben sowas wie stabile Zustände, nämlich diejenigen,
wo ich also quasi ausgehend von einem Zustand mit einer bestimmten Eingabe in diesem Zustand bleibe.
Nicht in das ist letztendlich das, was man dann auch erreichen möchte,
dass ich eben sagen kann, okay,
ich habe einem bestimmten internen Zustand dieses Schaltwerks erreicht und der soll dann eben auch stabil erhalten bleiben.
Also in diesem Beispiel soll man das ja auch,
dass ich also hier von dieser 1-0 über diesen
temporären Zustand letztendlich dann hier lande und dann eben hier in einem stabilen Zustand bin, vorausgesetzt.
Ich habe dann eben als in Anführungszeichen gültige Eingabe
sowas wie eine 0-1 gehabt
Gut, solche Zustandsdiagramme beziehungsweise die Flusstafeln werden uns später in
den Beispielen zu den endlichen Automaten, dann also auch nochmal weiter begegnen.
Da wird das Ganze also nochmal so ein bisschen formaler dargestellt.
Nicht aber das eben eigentlich als die eine Art und Weise,
wie man jetzt solche Automaten beschreiben kann, beziehungsweise das Verhalten dieser Automaten beschreiben kann.
Gut ausgehend von dieser Grundstruktur mit dieser Rückkopplung entweder zwei Nances oder zwei Norths,
die dann also quasi immer so über Kreuz zurückgekoppelt sind,
kann man sich jetzt also diverse unterschiedliche Varianten von Flip-Flops also irgendwie ausdenken oder überlegen.
Beispielsweise kann ich sagen, gut, ich führe noch sowas
wie so eine dritte Eingangsleitung hinzu, nenne ich C für Clock. Wenn ich das also jetzt hier im Falle so eines NoRS-Flip-Flops mache und das Ganze dann also hiermit unverknüpfe,
kann ich dann eben quasi über diese Clock-Leitung letztendlich dafür sorgen,
dass hier, und er ist jeweils komplett ausgeschaltet werden,
wenn Clock gleich null ist,
was also dann hier in so einer Funktionstabelle sich dann eben dadurch äußern würde,
dass man sagt, okay,
wenn ich hier null habe und hier dann also quasi sowas wie so ein Don't Care eintrage,
da hat jetzt leider Kollege,
weil das ist jetzt also nicht von mir gezeichnet,
also sowas wie ein X drin gehabt,
ändert sich hier letztendlich nichts, wenn Klock gleich eins ist,
habe ich dann eben abhängig von den Eingängen,
Set und Preset jeweils mit eins aktiv dann eben meine entsprechenden Übergänge,
wo ich dann eben, wenn die beiden null sind,
ändert sich auch nichts, wenn die Reset 1 ist,
wird der Ausgang auf null zurückgesetzt, wenn Set gleich eins ist,
wird der Ausgang auf eins gesetzt und eben,
dass beide gleich eins ist,
so nach wie vor als verboten,
erstmal gehandhabt werden
Gut, funktional. Ich, Pulshar Age war,
hat man dann eben entsprechend, also hier da dann die entsprechenden Charlotte-Funktionen.
Letztendlich ist das ja nichts anderes,
als dann eben eine mathematische Beschreibung von dem Ganzen. Gut,
könnte man dann eben auch in Form so eines Impulsdiagramms von
der Funktion her sich überlegen, beziehungsweise dann entsprechend simulieren.
Ich will nicht also hier Set und Reset habe,
wie dann also der Ausgang Kuh bzw. NQA aussehen.
Nicht, wo ich dann einfach jeweils für die entsprechenden Zeitpunkte
letztendlich durchspielen muss
Mit welchen Schaltfunktionen, welche Ausgaben sich wann ändern.
Und grob kann man jetzt einfach sagen, okay,
also lang, glock, gleich eins ist,
da ist es überhaupt noch interessant. Das heißt also,
hier zu diesen Perioden, wo Clock gleich null ist,
kann sich da also erstmal nichts weiter ändern.
Und wenn hier Crock-Lise eins ist und hier also beispielsweise an dieser hier jetzt,
also das Set-Gesetz,
das Reset auf null,
würde ich eben am Ausgang Kuna eins erhalten und NQ
auf null gehen und die zeitlichen Abhängigkeiten hierzwischen ergeben sich dann
eben über die Gatterverzögerungszeiten letztendlich hier in Entscheidungen
Gut, auch in der Richtung gibt es jetzt also nochmal so eine kleine Übungsaufgabe,
wo man das dann also wirklich nochmal selber durchspielen kann oder was man auch machen kann,
Schaltungen HSA eingeben, entsprechend da ein bisschen was an Zeiten raufsetzen,
dass da aber dann also mal vielleicht passend durchzusimulieren.
Gut, grundsätzlich kann man sagen,
diese Schaltung mit den Set und Reset,
Flipflops ist zwar eigentlich die eigentliche speichernde Komponente,
rein praktisch das, was also technisch realisiert wird,
haben wir eigentlich Immer nur Schaltung oder möchten wir eigentlich Schaltungen haben,
wo wir jetzt also irgendwie die Werte von einem Dateneingang speichern.
Also sprich von der groben Grundidee her, dass man eben sagt,
ich habe jetzt hier irgendwo meine Schaltung,
wo also im Prinzip was gespeichert werden soll.
Ich habe hier irgendwo einen Dateneingang D,
Datenausgang Kuh und eben hier jetzt also irgendein Clock-Signal,
wie auch immer das jetzt erstmal wirken mag, womit ich dann eben entscheide,
dass dieser Wert hier irgendwann hier drin gespeichert wird.
Und ich möchte jetzt eben nichts explizit zwei Steuerleitungen haben,
Set und Reset, sondern quasi dieser Dateneingang soll als Steuerleitung fungieren.
So, die einfachste Variante davon ist eben das,
was man als sogenanntes Pegelgesteuertes, D-Flip-Flop kennt.
Also wie gesagt, D kommt von den Daten. Pegel in dem Sinne heißt,
dass man eben sagt, wenn beispielsweise das Tagsignal C-Clock,
also gleich eins ist, wird am Ausgang letztendlich das ausgegeben,
was hier in dem Datenaheingang angelegt wird, mit einer gewissen Verzögerung.
Das heißt, in dem Fall zählt gleich eins,
wird das Ganze eben hier durchgeschaltet,
wenn sie auf null wechselt, beziehungsweise C gleich null ist,
bleibt eben hier ein Wert letztendlich gespeichert und erhalten.
Das ist also das, was man direkt aus dieser Tabelle herauslesen kann.
Da gibt es dann immer noch zwei Varianten,
entweder sogenannte High-Aktive oder low-aktive Ledges,
also sprich abhängig davon,
ob bei C
gleich eins
Durchgeleitet wird. Das, was also auch hier in dieser Tabelle
steht oder ob das Ganze bei C gleich Null passiert,
dann ist das entsprechend implementiert zu machen.
So rein technisch kann man das eben direkt am einfachsten dadurch umsetzen,
dass ich also letztendlich die Signale Set und Reset aus dem Dateneingang heraus generiere,
indem ich den dann eben Set gleich D und Reset
gleich nicht die mache oder das Ganze eben mit dieser vorherigen Schaltung mache oder das dann eben schon ein bisschen umforme und dann landet man eben letztendlich hier bei so einer Struktur.
Nicht das wäre dann eben so eine eine Instruktur,
die dann eben beispielsweise so was wie jetzt so ein die pegelgesteuertes D-Flip-Flop realisiert.
Auch noch zu der Benahmung, so war ich das also gelegentlich,
also vielleicht, wenn also hier auch nochmal irgendwie anders nennen werde,
man nennt das dann auch immer Ledge.
Also Ledge ist immer diese Eigenschaft,
dass das Ganze vom Spannungs- oder vom Pegel, also sprich,
ob Clock gleich null oder Clock gleich eins, ist abhängig.
Im Gegensatz zu den Flanken gesteuerten Flip-Flops,
die jetzt nämlich gleich kommen werden
Als Schalssymbol, also auch ein Hardess hat sich dann immer sowas hier eingebürgert,
wo man dann also quasi jetzt hier für diese Clock dann,
also hier so einen eckigen Kasten macht, nicht und je nachdem,
ob da ausgefüllt oder nicht ausgefüllt gezeichnet ist,
steht das dann eben für ein Low oder für Haie aktives Ledge.
Gut, Zustandsdiagramm und Flusstafel,
sehen also hier vergleichsweise einfach aus,
nämlich ich habe zwei stabile Zustände,
entweder ist es eine Eins gespeichert oder eine Null gespeichert und beziehungsweise als
interner Zustand und abhängig von dem Dateneingang und der Clock Was dann also hier diese Eingangskombination letztendlich,
also Glock als erste Datenangang als zweites macht,
wechsle ich dann eben gegebenenfalls zwischen den Zuständen.
Natürlich nur, wenn die Glock gleich eins ist,
wenn die Glock gleich null ist, bleibe ich in dem jeweils aktuellen Zustand.
Gut, die Flusstafel gestaltet sich denn hier dann also auch relativ einfach,
wo man dann eben sieht, wie dann also letztendlich hier die Zustände aussehen.
Gut, als nächstes hätten wir dann das Flammengesteuerte D-Flip-Flop beziehungsweise je nachdem, über welche Taktflanke man redet, dann auch gerne Forder- oder Rückflanken gesteuert. Da ist halt die Idee,
dass es also hier in dieser Tabelle dann eben mit diesem Fall nach oben skizziert,
dass man sagt,
wenn ich jetzt also hier mein Taktsignal habe und der jetzt also hier mehr oder männer irgendwie periodisch wechselt,
dass der entscheidende Zeitpunkt eben dadurch festgelegt wird,
dass also der Tag von null nach eins wechselt,
also dem zufolge dann eben hier als Idee dieser Fall nach oben,
dann wäre das eben ein Vorderflanken gesteuertes Flip-Flop,
das heißt immer zu dem Zeitpunkt,
hier wird der Wert vom Dateneingang übernommen und gespeichert und zu allen anderen Zeitpunkten hier zwischen,
also sprich, wenn der Tag danach dauerhaft eins ist,
null ist oder eben hier die Rückflanke kommt,
ist egal,
was sich am Dateneingang tut,
der alte Wert bleibt erhalten
Wie kann man das Ganze jetzt technisch umsetzen? Nicht,
wenn man jetzt sagt, ja, Vorderflanke,
wie kriege ich das denn jetzt überhaupt hin?
Einfachste Idee ist sogenanntes Masters Lave-Play-Prinzip. Und zwar,
man nimmt jetzt einfach Delages und schaltet davon zwei hintereinander und das Ganze mit invertiertem Takt.
Und damit kriegt man dann im Prinzip so eine Flankensteuerung hin,
bevor ich das jetzt also hier irgendwie alles runterbete und dann
also nicht so ganz klar wird,
was damit eigentlich gemeint ist.
Wie gesagt, hier einmal der Verweis auf die entsprechende Schaltung,
beziehungsweise ich werde das Ganze jetzt gleich mal kurz mit Hades
selber starten
Und dann kurz an der Hand der Simulation erklären,
weil das ist dann im Zweifelsfall die einfachste Variante.
So, also wie gesagt, hier haben wir letztendlich,
sagt das was so.
Hier haben wir also letztendlich also wirklich
diese Struktur zweimal
Von diesem, die Ledge jeweils drin gehabt.
Also das heißt, hier als Daten, Dateneingang und Takteingang
der hinteren Stufe und hier Takteingang und Dateneingang der vorderen Stufe.
Und der Trick dabei ist jetzt zu sagen, die haben halt,
was dann also hier durch diese Inverter realisiert ist, invertierte Takte.
Und bei dem Ledge war es ja immer so,
dass wenn der Takt quasi eins ist,
wenn das jetzt ein hart transparentes Ledge ist,
wird der Eingang zum Ausgang direkt durchgeschaltet.
Das ist in diesem Fall jetzt hier bei diesem vorderen Teil
der Fall. Das heißt also,
hier kann ich jetzt also den Dateneingang ändern und man sieht,
das Ganze wirkt sich dann eben hier direkt bis zum Ausgang hindurch.
Bei dem Hinteren ist es jetzt aber so, der ist jetzt,
also der hier vorne ist jetzt quasi mit der 1 transparent geschaltet,
der hier ist jetzt mit der nulltransparent geschaltet.
Das heißt, der ist jetzt in dem Zustand,
wo der alte Wert gespeichert unterhalten bleibt.
In diesem Fall, hier mit Zion gekennzeichnet, dieses noch nicht initialisierte.
So, und was jetzt eben passiert ist,
wenn ich jetzt also den Takt umschalte, von 0 nach 1,
dass dann quasi der hier in den speichernden Zustand geht.
Das heißt, wenn ich jetzt den Dateneingang ändere,
hat das also hier auf den Ausgang keine Auswirkungen mehr.
Der hintere jetzt aber transparent geschaltet wird. Das heißt,
das, was hier am Eingang ist,
was sich aber jetzt ja nicht mehr ändern kann,
wird dann auf den Ausgang durchgeschaltet
Das heißt, ich habe die Eins,
die jetzt also zu dem Umschaltzeitpunkt am Dateneingang lag,
hier drin gespeichert und die geht dann eben bis hier.
Und wenn es den Tag wieder zurückschaltet,
ich würde das jetzt zum Beispiel mal ändern, passiert dann eben wieder Folgendes,
dass hier der gespeicherte Wert jetzt erhalten bleibt und dieser vordere Teil wieder transparent geschaltet wird.
Jetzt kann ich jetzt zwar so wieder ändern,
aber das wird sich nie bis hier hinten fortpflanzen. So,
das heißt, damit hat man dann eben wirklich diese Funktionalität erreicht,
dass eben der Dateneingang in dieser Struktur eben immer nur dann gespeichert werden kann,
wenn sich wirklich der Tag von null nach eins ändert.
Nicht, dass also die Grundidee,
die man dort also letztendlich jetzt bei diesen Flanken gesteuerten Elementen macht,
wo ich dann eben wirklich zwei solche Teile dann hintereinander schade,
nicht befordere Master genannt, weil der dann eben bei Clock gleich null transparent ist und der hintere Slave,
der dann also quasi Den vorherigen Wert gespeichert hat,
war Clock gleich nur bei Clock gleich eins, dann eben genau entsprechend umgekehrt.
Ich dachte also, die Grundidee,
wie man das Ganze dann realisiert und wie gesagt,
in dieser Aufeinanderfolge der erste ist bei null transparent,
der zweite war eins transparent,
kann ich eben in diesem Fordern eine Förderflankensteuerung machen und wenn ich jetzt also sowas wie ein Rückflanken gesteuertes Element haben wollte,
müsste ich einfach nur quasi diese beiden Philipp Loss oder diese beiden Arten der Flip-Props Andersrum anordnen,
beziehungsweise wenn ich jetzt also hier in dieser Hades-Schaltung bin und diesen Innenwärter hier letztendlich weglasse,
hätte ich dann da so ein Rückflanken gesteuertes Element,
jetzt also hier in diesem Fall.
Gut, das Ganze kann man natürlich dann auch noch mit irgendwelchen Tricks da rein,
eine Bulschenallgebäude, also irgendwie passend minimieren und kriegt dann noch ein bisschen kleinere Schaltungen,
die dann noch ein bisschen eleganter aussehen.
Aber gut, also da will ich jetzt also gar nicht erklären,
wieso das tut und funktioniert. Also wie gesagt,
kann man sich einzeln überlegen, beziehungsweise es war einfach eben in Hades einmal aufmachen,
einmal ein bisschen durchsimulieren, ein bisschen mit rumspielen und sehen das eben entsprechend funktioniert.
Entscheidend für das Ganze ist aber, und das ist eben jetzt das,
was hier unten angedeutet ist, sind eben halt doch bestimmte Zeitabhängigkeiten,
weil wenn ich jetzt sage, okay, ich übernehme den Dateneingang,
wenn sich die Flanke ändert, Was passiert,
wenn zu diesem Zeitpunkt sich dann eben auch der Dateneingang ändert?
Welcher Wert wird gespeichert? Der Alte oder der Neue? Und das ist eben letztendlich dann so ein Problem,
was dazu führt,
dass man für solche Flanken gesteuerten Elemente dann eben in der Regel auch noch bestimmte Zeitbedingungen formuliert,
beziehungsweise formulieren muss, die man dann meistens auch noch in solche Simulationsmodelle,
also das ist dann in Hades eben beispielsweise auch schon alles geschehen,
mit reinbringen muss, die dann eben dafür sorgen,
dass Bei solchen Situationen quasi irgendwie den Benutzer signalisiert wird.
Du hast hier vielleicht sowas wie ein Timing-Problem. Nicht,
weil das sind immer so die typischen Situationen, wo man sagen kann,
okay, ich habe meine Schaltung sauber entworfen, das tut alles.
Und abhängig von jetzt eben beispielsweise der Betriebstemperatur,
also ich finde das also im Auto verbaut ist und ich
das also irgendwie morgens bei minus 15 Grad irgendwie starte,
nicht, dann verhält es sich anders,
als wenn das also irgendwie eine Dreiviertelstunde gelaufen ist,
der Motorraum warm geworden ist.
Nicht, weil in dem einen Fall schaltet das vielleicht
ein bisschen schneller, dann übernehme ich den Wert.
Im anderen Fall schaltet es ein bisschen langsamer, dann übernehme ich den Wert.
Und das ist natürlich dann also ein Nichteterministisches Verhalten,
was man nicht haben möchte. So,
das sind dann eben Sachen, die dann nachher sozusagen Zeitbedingungen führen,
werde ich also auch gleich noch ein bisschen was zu sagen, was man dort typischerweise dann macht. Gut,
im Prinzip sind diese beiden Flip-Flock-Typen, also sprich Flankengesteuertes,
die Flip-Flop bzw. Pegelgesteuertes, die Flip-Flop oder alias Ledge, die beiden Entscheidenden,
die man also heutzutage auch immer noch in den Computern verbaut hat,
rein technisch, nicht früher in Form von irgendwelchen integrierten Bausteinen,
Texas-Instruments 74-Irgendwas-Serie, inzwischen eben irgendwo als Teil der WLSA-Schaltung,
die dann eben beispielsweise dann eben eine CPU ausmacht.
So, und das, was hier jetzt auch beschrieben ist,
JK-Flip-Flop ist, dann sagen wir noch so eine Erweiterung,
wieder um zwei Steuerheingänge,
wo ich dann eben sagen kann,
ich habe nicht nur sowas wie Sätzen und Zurücksetzen,
sondern ich kann auch noch einen Wert gezielt torgeln,
also hin und her schalten
Nicht damit kann man,
wenn man dann so ein bisschen mit der bulschen Alge war,
rumrechnet, dann also zum Beispiel also auch noch irgendwie relativ schick,
also irgendwelche Zähler bauen, Beispiele zu folgen nachher auch noch,
rein technisch muss man sagen, ist das also irgendwie inzwischen,
also nicht mehr so richtig doll verbreitet,
deswegen würde ich dir jetzt das auch nicht stundenlang drauf rumreiten und also hier irgendwie die Tabellen erklären,
Funktion des JK Flip Props wird,
also in der Klausur nicht abgefragt,
aber eben sowas wie Ledge bzw. flankengesteuerte Elemente,
sollte man wissen,
dazu kommt auch nochmal explizit an sowas wie
eine Übungsaufgabe mit rein
Gut, also auch das kann man dann eben irgendwie entsprechend minimiert eingeben und in Hade simulieren,
beziehungsweise findet sich dann also auch dort ein passendes Beispiel dazu.
Aber wie gesagt, das ist dann eben eher so aus der Zeit,
70er, 80er Jahre, als man eben noch mit diesen 74er-Bausteinen irgendwie was gemacht hat.
Also interessant, eigentlich solche, die Flip-Flops,
die dann eben entsprechend entweder als pegelgesteuerte Elemente,
wie gesagt, diesen eckigen Kasten oder als flankengesteuerte Elemente,
dann hat man hier quasi immer so einen Fall reingezeichnet, realisiert werden.
Daneben gibt es dann auch immer noch Erweiterungen,
das ist also auch das,
was hier noch so ein bisschen mit drin ist,
beziehungsweise dass diejenigen, die das Rechnerstruktur- und Praktikum gemacht haben,
also im ersten Bogen dort, der hat auch schon kennengelernt haben,
dass man da noch so zusätzliche Leitungen hat,
sowas wie dieses hier oder Ah, nee,
das ist jetzt die in J. Carflift-Frop.
Also die ist hier oben, wo man im Prinzip dem Flip-Flop explizit,
also jetzt unabhängig von Clock und Dateneingang auch noch sagen kann,
der Ausgang soll auf null oder auf eins gesetzt werden.
Also quasi nochmal sowas wie so zusätzliche Set oder Reset-Leitung.
In der Regel ist das Ganze dann technisch so realisiert,
dass die letztendlich,
also hier an diesen sparchenden Stufen mit der Rückkopplung
noch irgendwo als zusätzlicher Eingang mit rangehen,
wo ich dann eben hier das Ganze eben noch explizit
einmal setzen oder zurücksetzen kann
Braucht man das? Nicht also auch das, dann
immer irgendwie wieder so die gerne gestellte Frage. Naja,
wenn ich solche Elemente habe und ich möchte damit eben zum Beispiel
sowas wie irgendein Zähler realisieren oder ich möchte damit also irgendwie sowas wie einen Automaten beschreiben.
Kommt auch gleich noch als Beispiel, wo ich sage,
der soll einen bestimmten Anfangszustand haben.
Ich schalte den Computer ein, der soll irgendwo loslaufen,
der soll irgendwo loslaufen, heißt aber,
dass eben in bestimmten Registern beispielsweise ein Wert aus lauter Nullen drin steht.
Das ist technisch gesehen nicht zwingend so, dass beim Einschalten
von Strom in jedem Register oder in jedem Flip-Flop eine Null gespeichert ist.
Es kann auch eine Eins drin stehen. Das ist dann
eben auch wieder jetzt von der Schaltungstechnik und von irgendwelchen Verzögerungszeiten
von den Gattern abhängig. Um jetzt also dafür zu sorgen,
ich möchte explizit einen bestimmten Wert haben,
ist es dann eben ganz sinnvoll,
solche Elemente dann eben teilweise auch noch um solche Sätze oder Rücksetzeingänge zu erweitern.
Also da ist nur der Hintergrund,
wofür man das dann eben beispielsweise auch noch bei euch stimmt
Gut, entscheidender Teil, also zu dem,
was sie jetzt, Unterscheidung von Flankensteuerten, Flip-Flops und Ledges angeht,
ist dann eigentlich jetzt also sowas wie diese Zeichnung hier,
weil das wird dann also, wie schon angedroht,
dann also auch nochmal in der Übungsaufgabe,
im Zweifelsfall über die Weihnachtszeit folgen,
wo man dann nämlich also auch mal nochmal den Unterschied in der Funktion eigentlich sieht oder sehen kann,
und zwar hier mein Dateneingang, hier mein jeweiliger Takteingang.
Einmal der Datenausgang gibt es von Ledge und einmal hier von vorder Flanken gesteuertes Flip-Flop.
Angenommen, das Ganze jetzt eben jeweils so mit einer Verzögerungszeit
jetzt hier von irgendeiner fiktiven Zeitanheit, in diesem Fall jetzt hier also so ein Kästchen.
Und ja, was tut sich? Also angenommen,
ich habe am Anfang in den jeweiligen Registern,
also hier sowas wie so ein Wert Null,
Dateneingang ändert sich, wirkt sich also hier nicht weiter aus,
weil die Clock noch nicht aktiv ist,
wenn die Clock jetzt hier von 0 auf 1 wechselt,
was also zu diesem Zeitpunkt passiert und hiermit angedeutet ist,
soll dann quasi ein Eine Verzögerungseinheit später würde dann eben das vorderflankengesteuerte Flip-Flop den Wert hier vom Dateneingang eben übernehmen.
Das heißt also von 0 nach 1 wechseln,
für das Ledge gilt letztendlich genau das Gleiche. So,
und dann bleibt er hier auf eins, geht irgendwann auf null.
Irgendwann später ändert sich dieser Dateneingang, das,
was dann eben technisch gesehen passiert ist, dass dieser Wert,
der hier reingespeichert ist, dann eben so lange erhalten bleibt,
bis der Takt mal hier wieder auf eins geht und aktiv wird.
Und dann würde dann eben letztendlich diese Null hier beziehungsweise hier eingespeichert werden.
So ein Unterschiede ergeben sich jetzt eben beispielsweise an dieser Stelle,
wo ich dann eben sagen kann, okay,
beim jede Vorderflanke, Dateneingang 1,
wurde also quasi sowohl das Ledge als auch das Vorderflankesteuerte Philipp Flop auf 1 gehen,
wenn aber jetzt, wenn der Takt aktiv ist, zwischenzeitlich der Dateneingang auf Null geht,
wurde dann eben mit der jeweiligen entsprechenden Verzögerung im Ledge quasi der Ausgang dem hier jeweils folgen.
Ich während das flankengesteuerte Flip-Flop eben den Wert,
den es da siehe vorne einmal abgetastet hat, also nicht wieder ändern kann,
bevor ich also die nächste Taktflanke hier was tut.
So, interessant ist jetzt also hier noch diese Stelle,
nicht weil da geht es jetzt nämlich genau um diese Sache mit diesen Zeitbedingungen,
wo man jetzt eben sagt, okay, was passiert?
Also ich habe jetzt hier einen Ledge. Ledge haben wir gesagt,
okay, der lässt letztendlich das durch was,
also passiert, wenn da ein Nagengang gleich eins ist.
Wenn jetzt aber gleichzeitig Firma von Gleichzeitigkeit reden kann.
Der Takt auf Null geht, der Dateneingang sich ändert, was wird hier gespeichert?
Diese Null oder diese Eins. So, und das,
was dann eben in der Simulation passiert oder passieren sollte,
ist, darf man irgendwo den Benutzer signalisieren möchte.
Du hast da also irgendwo jetzt von deiner Eingangssignalen die Situation,
da kann es zu Problemen kommen
Rein technisch wird er natürlich nicht irgendein undefiniert gespeichert,
sondern da wird eine Null oder eine Eins drin stehen,
aber es kann eben mal der eine, mal der andere wert sein.
Trotzdem machen die Simulationsmodelle, dass dann eben typischerweise so,
dass sie dann eben so einen Zustand,
dafür gibt es den Haar,
dass dann eben diesen Wert X für Andy Find dann also quasi dort reinschreiben,
damit man eben auch wirklich in der Simulation,
in so einem Impulsdiagramm sehen kann, okay,
da habe ich gelegentlich ein Problem.
Gut, das ist eben das,
was dort dann also letztendlich durch die Simulation mit reinkommt,
nämlich solche Zeitbedingungen
Um das Ganze jetzt eben nochmal so ein bisschen zusammenzufassen.
Letztendlich jedes Flipflop selber ist ein asynchrones Schaltwerk, was aber
eben vergleichsweise sauber entworfen ist und eben stabile Zustände enthält.
Nämlich in der Regel das, was sich da also
quasi irgendwo am Eingang oder als Bitt gespeichert haben möchte.
Und die Flipflop selber werden jetzt aber eben verwendet,
dass wenn ich jetzt also wirklich meine eigenen Schaltungen werfe,
meine ähnlichen Automaten, Millimodell, Moormodell.
Und ich habe einen Zustand und möchte eben unterscheiden zwischen Zustand und Folgezustand,
dass ich eben dort an den Stellen,
also an den Stellen hier in der Rückkopplung dann eben sage,
dieses Tau ist jetzt nicht irgendeine Gatta-Verzögerungszeit oder eine Verzögerungszeit,
die sich also durch die Leitungslauflängen irgendwie sowas ergibt,
sondern an dieser Stelle habe ich dann eben irgendein speicherndes Element.
In der Regel wird das also ein Flankengesteuertes Flip-Flop sein.
Dort wird der Zustand abgelegt und mit jedem Tag kann
dieser Automat eben seinen Zustand ändern.
Und damit habe ich das sicher entworfen und habe jetzt hier
nicht also irgendwelche Rückkopplungen, die dann also letztendlich von irgendwelchen
internen Laufzeiten abhängig sind
Gut, ja, das, wie gesagt,
deswegen eben diese Sache da noch mit den zusätzlichen Zeitbedingungen,
die man dann eben in den Flipflops noch mit reinbringt.
Wie gesagt, die Fragestellung eben immer, wenn sich Datenpaktereiengang gleichzeitig ändern, was passiert.
Und das führt dazu, dass man typischerweise ein Modell hat, wie das,
was hier quasi beschrieben ist, also jetzt mal am Beispiel so eines Vorderflankengesteuerten Flipflops.
Ich habe hier also den Takt, der geht irgendwann von null nach eins,
also hier auch schon mal so ein bisschen realistischer gezeichnet,
also jetzt nicht so als Recht, sondern nicht rein technisch gesehen wird,
dass also natürlich auch irgendwann die,
wenn das also eine Spannung sein soll, die irgendwie sukzessive irgendwann mal ansteigen.
Nach einer bestimmten Verzögerungszeit, das ist das,
was also hier mit TFF gekennzeichnet ist,
wird sich dann eben auch ein Dateneingangswert,
also am Ausgang diese Flip-Props wieder zeigen,
das ist also quasi die Verzögerung von Tagflanke und ich habe
hier ein Datum,
bis ich die Änderung dieses internen Zustandes
am Ausgang zeigt
Und was war dann typischerweise noch hart, sind dann eben Setup-Zeiten beziehungsweise hold sein.
Das heißt also Zeiten vor und nach der Tagflanke,
wo man eben sagt, gut,
innerhalb dieses Zeitintervalls rund um die Taktflanke darf sich eben eigentlich der Dateneingang nicht ändern,
sondern eben die letzte Änderung da letztendlich dann höchstens hier stattfinden.
Nicht dann muss das Datum eigentlich stabil sein und die nächste Änderung dann auch erst nachverstreichen, dieser Hohlzeit. Gut,
und letztendlich ist es daneben bauteilabhängig wie Großsetup und Hohlzeiten sind,
aber damit ist man dann eben letztendlich auf der sicheren Seite,
was den Betrieb angeht und kann eben sagen, gut,
wenn ich diese Zeitbedingungen einhalte und die letzte Datenänderung irgendwo hier stattfindet und die nächste sagen,
hier ist wieder, dann werde ich eben auch immer wirklich definierte Werte,
die letztendlich dann also hier in dem Bereich der Tagflanke liegen,
in meinem Flip-Flop gespeichert haben.
Gut, welche Auswirkungen beziehungsweise wie sie das jetzt überhaupt mit irgendwelchen Zeiten oder Verzögerungszeiten
aus jetzt in Bezug auf den Betrieb von solchen Schaltwerken.
Dazu ist jetzt hier rechts einmal gekennzeichnet,
also nochmal so grob diese Idee eines Schaltwerks.
In diesem Fall, das gleiche Prüfungsfrage stellen,
was ist das für ein Automat,
Mili-Modell oder Moor-Modell
Keiner traut sich, 50-prozentige Trefferchance. Also in diesem Fall
ist das ein Moor-Automat. Unterschied war immer, also beim
Moor-Automat ist der Ausgang nur von dem aktuellen Zustand abhängig.
Beim Mili-Automat wäre er dann auch abhängig von diesem Eingang hier. Gut,
da hast du jetzt allerdings nur hier die Zeit interessiert,
ist es also letztendlich ja sowieso egal,
was man an dieser Stelle hier hat.
Gut, ja, wie sieht das da jetzt mit den
Zeitbedingungen aus? Weil ich habe ja jetzt jemand Flip-Flop,
das kriegt irgendwo
einen Takt
Also für diesen Tag gelten jetzt eben letztendlich diese Zeitbedingungen.
Ich habe eben so was wie eine Setup-Zeit. Ich habe
sowas wie eine Hohlzeit und ich habe intern hier drin eben
auch noch irgendeine Verzögerungszeit. Und wenn die Tagforderflanke kommt,
wird eben beispielsweise dann eben hier dieser Eingangsvektor entsprechend übernommen.
Der Zustand ändert sich. Und auf deiner Seite,
das, was er sich jetzt eigentlich angedeutet ist,
ist eben, wie sieht es dann zeitlich gesehen aus,
wann dürfen sich auch nur die Eingänge ändern
Nicht, weil, was ich jetzt ja nicht machen darf,
ist, dass ich also quasi durch das Eingangsänderung hier eine Änderung in dem Folgezustand habe,
der zeitlich gesehen dann eben in dieses Zeitintervall hier reinfällt.
Kann man dann eben dadurch beschreiben, dass man sagt,
okay, ich habe hier meinem Mahngangsvektor,
der geht jetzt also durch dieses Zustandsübergangsschalennetz oder Delta-Schaltennetz,
hat dort abhängig von dem, durch welche Fahrer,
also durch welche Gatter er da läuft, eben eine bestimmte Verzögerungszeit.
Typischerweise sieht das dann auch immer so aus, dass,
wenn man jetzt wirklich elektrische Schaltungen betrachtet,
dort es natürlich immer abhängig von der Fertigung, also irgendwelche Bauteilstreuungen geben kann. Das,
was aber letztendlich vom Hersteller immer garantiert wird, ist,
dass er sagt, okay, ich sage,
das ist der Worst Case und das ist der Best Case,
quasi als Grenzwerte, nicht die langsamste und die schnellste Schaltung,
die man haben kann und alles,
was ich ausliefe und ihr verkaufe,
mein lieber Kunde,
das liegt eben letztendlich in diesem Bereich dazwischen
Nein. Das sind dann also auch die Grünen,
Gründe, also mit diesen Bauteilschwankungen,
weswegen man eben zum Beispiel auch sagen kann, okay,
wenn ich mir also irgendwie so einen Prozess hocke oder kaufe und meinen Desktop-Rechner setze und sage,
okay, den möchte ich irgendwie übertakten,
weil ich nun also irgendwie enthusiastischer Gamer bin und zu viel Geld habe,
dann kann man dort also abhängig von der nominaren Taktfrequenz da also auch noch so ein bisschen was rausquetschen.
Man kann aber jetzt eben nicht sagen, den kann ich generell
immer irgendwie 10 Prozent schneller machen oder 20 Prozent oder 30 Prozent schneller,
sondern das ist dann eben wirklich vom aktuellen Exemplar abhängig.
Es gibt welche, da hat man Glück, da klappt das hervorragend.
Es gibt auch welche, da klappt das eben nicht so richtig gut,
weil der Hersteller sowieso nur garantiert, okay,
das ist eben Nominalfrequenz und danach ist letztendlich Schluss.
Und wenn man selber da jetzt also irgendwie was macht und
die Dinger dann außerhalb der Spezifikation betreibt, okay,
kann man machen oder kann man teilweise machen,
ist aber dann eben letztendlich auf eigene Verantwortung.
Gut, also das ist dann das,
was immer so ein bisschen dahinter steht,
eben diese Bautalstreuung und wie gesagt,
in dem Fall,
ich habe jetzt hier also ein Schalnetz,
also sprich irgendwelche Funktionen
Wo eben dann ihm letztendlich für jedes einzelne Gatter,
also sprich jetzt für jedes nennt und Norgatter, also irgendwie hinterlegt ist.
Also das kann maximal in 0,2 Pico-Sekunden schalten oder eben Worst Case,
also irgendwie 0,35 Pico-Sekunden. Und alles dazwischen ist nicht.
Deswegen gibt es da dann letztendlich dann immer irgendwie solche Intervallbildung.
Nicht demzufolge kann man dann hier sagen,
für diese Verzögerung, durch dieses Schaltennetz gibt es eben
so ein Minimum und ein Maximum wert
So, und was muss jetzt also gelten letztendlich, wenn sich jeder Eingangsvektor ändert?
Ich muss zum einen hier die Hohlbedingungen für dieses Flip-Flop erreichen.
Das heißt, wenn der sich, ich habe hier meine Taktflanke,
so lange muss der Wert noch stabil sein.
Ich habe quasi als schnellsten Fahrt hierdurch dann eben diese minimale Verzögerungszeit. So,
und wenn ich jetzt also quasi Noch weiter,
die kann ich jetzt also von der Hohlzeit letztendlich abziehen,
wenn ich dann noch weiter davor meinen Eingangswert ändere,
dann kann es eben sein, dass ich hier diese Hohlbedingungen verletze.
Wenn ich ihn danach ändere, dann nicht dadurch,
dass also diese Zeit hier noch entsprechend draufkommt,
ab dieser Zeit, hier bin ich dann immer in dem,
in Anführungszeichen, normalen Bereich außerhalb von dem Hohlt.
Und auf der anderen Seite kann ich eben sagen,
ich muss vor der nächsten Tagflanke dann eben zum einen die Setup-Bedingungen einhalten,
dadurch, dass aber ja dann auch noch die Verzögerungszeit durch dieses Schadennetz selber hindurch dazukommen kann.
Und in diesem Fall nehme ich jetzt natürlich den langsamsten Fall,
also Tau, der da mag. Kann es da dann eben sein,
dass ich dann letztendlich das noch hiermit draufzählen muss,
dass man unterm Strich dann quasi in diesem Grün gekennzeichneten Bereich landet,
wo sich der Eingangsvektor ändern darf.
In allen anderen Fällen führt das eben dazu,
dass ich als Worst Case eben in dem Zustandsregister,
also an diesem Flip-Props,
irgendwie Setup oder Holzheim
verletzen kann
Gut, das ist also hier nochmal textuell beschrieben,
was ich gerade eben soweit erklärt habe,
nicht,
dass man eben letztendlich rechnen muss,
Taktzeitpunkt plus Tee holt minus Tee Delta Men,
als die eine Schranke und die andere dann eben nächsten Tag minus Setupzeit minus Tau Delta Max,
dann als das Anno und dann bleibt eben letztendlich dieser Bereich
Gut, das sind jetzt die Änderungen für den Eingangswerk,
da wann der sich ändern darf. Jetzt kann er natürlich auch noch sagen,
okay, dadurch, dass sich jetzt der Zustand selber ändert,
habe ich natürlich quasi über diese Rückkopplung von,
ich habe hier irgendeinen Zustandsneuen Zustand, der Tag kommt,
dieser Zustand wird hier gespeichert und das läuft hier auch quasi wieder durch und geht dann hier wieder in einen anderen Eingang des Flipflops.
Also auch dadurch habe ich natürlich irgendwelche Zeitbedingungen,
die dann in diesem Fall dann eben durch den internen Zustand bedingt werden.
Und hier müsste man an ihm letztendlich rechnen,
dass Verzögerungszeit von dem Flip-Flop plus minimale Verzögerungszeit hierdurch quasi größer sein muss als die Hohlzeit,
weil sonst hätte ich quasi hierum eine Rückkopplung,
wo dann also quasi durch den Taktimpuls die eigene Holtbedingung verletzt wird.
Und auf der anderen Seite, dass man eben sagen muss,
wenn ich jetzt die Verzögerung,
hier durch das Flipfrock nehme, plus längste Verzögerungszeit hierdurch,
dass das noch rechtzeitig vor der nächsten Tagflanke minus Setup-Site passieren muss.
Nicht, dass dann dadurch dann eben letztendlich irgendwo hier dann seine Änderungen hat,
das aber eben noch innerhalb von diesem Intervall passieren muss.
David wird dann eben alles in allem,
nämlich letztendlich die maximale Tagfrequenz von solchen Schaltungen bestimmt.
Nicht dadurch, dass man sagt, okay,
ich könnte diese Schaltung jetzt hier eben noch schneller machen.
Das heißt, die Takte würden eben entsprechend schneller aufeinander folgen.
Ich aber irgendwann verletzt sich dann eben hier mit diesen Zeitbedingungen eben entwederholt oder Setup-Zeiten.
Und dann kann man dort dann eben auch nicht mehr dafür garantieren,
dass die Schaltung eben noch vernünftig funktioniert. Gut,
dass hier also auch nochmal der entsprechende Text zu dem Ganzen,
was ich jetzt also gerade eben an dem Beispiel direkt schon erklärt hatte,
dass man also quasi sagen kann,
auf der einen Seite waren frühestens diese Zeitänderungen Wieder rückgekoppelt werden sein,
weil ich damit also quasi die Hohlzeit sonst nicht verletze und waren spätestens,
damit man da dann die Setup etc. So,
im Prinzip ergeben sich jetzt also aus diesen Rahmenbedingungen dann eben diese Eigenschaften für so eine maximale Taktfrequenz von Entschaltungen.
Nämlich zum einen kann ich sagen, ja gut,
also generell darf die Taktfrequenz sowieso schon mal nicht höher sein als die Summe von Hold und Setup-Zeit,
weil dann habe ich in jedem Fall irgendwie eine Verletzung von dem Ganzen.
Und wenn man jetzt Im Prinzip diese Zeiten von dem Beispiel vorher nimmt,
dass man eben sagt, okay, die Verzögerungszeit durch das Flip-Flop,
die sich also im Prinzip jetzt also erstmal beim Speichern der Werte ergibt,
plus maximale Verzögerungszeit durch das Delta-Schaltennetz,
also jetzt quasi bei der Bereich nun des Volkezustands,
muss eben kleiner, beziehungsweise plus Setup-Zeit, nicht,
dass das dann eben letztendlich die Tagfrequenz an der Stelle und eben auch entsprechend bestimmt.
So, und solange diese Weinbedingungen eben für die Stelta Tee
entsprechend eingehalten sind, habe ich dann eben letztendlich einen stabilen Betrieb.
Und das wäre dann in dem Fall dann,
also die maximale Taktrate. Gut, wenn ich das unterschreite,
kann es eben sein, dass man falsche Werte einspeichert und
die Schaltung dann eben mit falschen Werten weiterrechnet
Gut, hier nochmal skizziert, beziehungsweise mal ein paar Anmerkungen jetzt,
dass es zu diesem Thema Takt oder Taktsignal, nicht also das,
was man sich da typischerweise immer jetzt mal vorstellt,
ist also wirklich so ein Mehr- oder minderperiodisches Signal von Nullen und Einsen.
Generell kann man natürlich sagen,
das Ding muss also nicht zwingend symmetrisch sein,
wie das in diesem oberen Impulsdiagramm angedeutet ist,
sondern es kann also auch irgendwie beliebig asymmetrisch sein,
ich war gerade also auch bei flankengesteuerten Takten geht es ja letztendlich nur darum,
wann habe ich hier also meine Vorderflank oder hier jeweils meine Rückflanke,
da ist es also erstmal relativ egal,
wie lang,
also hier eins oder null
Pulse entsprechend sind
Zwei Phasentakte, die ich also auch gleich noch vorstellen werde,
sind also in der Regel sowieso schon mal asymmetrisch,
war man da eben auch dafür sorgen muss,
dass die Systeme dann so ein bisschen anders sind.
Gut, die Varianten, hier auch noch mal kurz. Wie gesagt,
Pegelsteuerung, nämlich einmal das,
wo ich dann also jetzt nur gucke,
ist der Takt null oder ist der Takt 1 und eben Flankensteuerung für Wechsel von 0 nach 1,
für eine Vorderflankensteuerung oder Wechsel für 1 nach null für eine Rückflankensteuerung.
Gut, hier ist das Ganze nochmal so ein bisschen grafisch visualisiert.
Also wenn ich jetzt hier meinen Takt habe,
Für einen High-aktive Pegelsteuerung wäre das dann also quasi mal jeweils dieser Bereich,
der interessant ist, bei Vorderflanken habe ich dann dementsprechend die Teile bei Rückflanken, die Teile.
Gut, wenn man jetzt solche Flip-Frops in Automaten nimmt oder einsetzt,
kann man sich ja auch überlegen,
wären da überhaupt alle von diesen hier sinnvoller einsetzbar
Oh Gott, heute fragt er. Hat keiner eine Idee. Naja gut,
also was habe ich hier in den Schaltungen? Typischerweise, ich habe hierüber irgendwie eine Rückkopplung. Das heißt,
also wenn ich sowas wie ein Pegelgesteuertes Element nehme,
also ein Ledge, funktioniert das so erstmal schon mal gar nicht,
weil wenn das also beispielsweise haaraktiv ist,
der Takt ist gleich eins,
nicht dann rauscht der Wert hier sowieso immer irgendwie komisch durch und ich war jetzt gar nicht mehr,
also Fondsgesetze,
der ändert sich dann Oder wer nicht die ganze Zeit irgendwie stabil hätte ich da dann also immer irgendeine komische Änderung und hätte dadurch dann eben entsprechend nicht deterministisches Verhalten.
Das heißt also alles,
wo man sagt, also ähnliche Automat mit Zuständen,
mit irgendwie Ausgang und hier in Rückkopplung, Zustand wird irgendwo gespeichert,
funktioniert in der Regel eigentlich nur mit Flanken gesteuerten Elementen.
Also nicht nur in der Regel, sondern funktionieren nur mit Flanken gesteuerten Elementen,
vor allem anderen braucht man quasi zwei Phasentakte.
Kommt auch gleich noch ein Beispiel,
das heißt nämlich einmal ein low-aktives Namen High-Aktives hintereinander geschaltet mit unterschiedlichen,
beziehungsweise in der Regel des jungen Takten
Gut, also wie gesagt, lass du noch mal so
zu den Taktsignal-Varianten. Jetzt kommen wir so die Folie,
wo man also den Informatiker der Nullen und Einzelnen denkt,
dann ja also immer zeigen muss, ja,
also ganz so perfekt ist die Welt ja nun nicht.
Also das, was wir hier natürlich betrachten,
sind immer irgendwie solche Sachen,
rein praktisch ist das immer schon so ein bisschen mehr so und
rein elektrisch habe ich hier mal von so einer Schaltung,
das sind auch schon ein paar Jährchen hier,
also mal so ein Wirklich ein Screenshot beziehungsweise abfotografiert von irgendeinem Ostsyloskopbild gemacht.
Also das, was man hier sieht, ist ein Taktsignal.
Das ist jetzt also auch noch nicht sonderlich Dolles und Wildes und Abstruses.
Das ist also damals, hatte man also auf den Motherboards,
also bevor es PCIE gab, noch,
also irgendwie PCI-Bus, da auch noch eine Langsam-Variante.
Das sind 33 Megaherz. Also das ist jetzt hier in
33 Megaherz-Taktsignal. Das ist quasi Yahai, Rückflanke,
das ist Low und das hier ist die Vorderflanke
Ist schon nicht mehr so ganz einfach, rauszusehen,
beziehungsweise man muss es wissen und es ist dann immer nur erstaunlich,
wenn man sowas also wirklich sieht,
wie also wirklich die Signale sich dann also wirklich elektrisch verhalten,
dass man dann sagt,
die Schaltungen funktionieren trotzdem immer noch, mehr oder männerstabil.
Und wenn man jetzt also quasi intern auf die Chips oder in die Chips gehen würde und sich da mal anguckt,
was also letztendlich jetzt also irgendwie bei einem Gigahertz-Tag passiert,
da ist also nichts mit Taktsignal,
sondern da war so irgendwie so ein komischen Ich sag jetzt mal,
also irgendwie verrauschten, verzerrten Sinus, eigentlich nur irgendwie so eine Welle,
die rauf und runter geht.
Und also der eine Teil, das soll die Vorderflanke sein,
das ist die Rückflanke. Ich war, da muss man auch sagen,
da ist es natürlich gerade in dem Wagenstand, also wirklich extrem ausgeknautscht.
Gut, nee, aber was man eben hier auch nur sieht oder was,
dass ich auch nochmal kurz angesprochen wird, ist eben,
was man elektrisch an ihm auch häufig hat, sind eben solche Überschwinger. Das heißt also nicht,
also hier sieht man das noch so ein bisschen mehr so in diesem handgezeichneten Ding,
nicht also, dass quasi nach so einer Vorderflanke ich jetzt also nicht sage,
okay, das hier sind Null Volt,
das sind zweieinhalb Volt und das Ding bleibt dann genau bei zweieinhalb Volt,
wenn es also hier angestiegen ist, stehen,
sondern das schießt erstmal so ein bisschen rüber und schwingt sich dann irgendwie sukzessive ein, bei der Rückflanke hat man das dann eben teilweise auch.
Und wenn ich das dann eben noch schneller mache,
dann habe ich eben eigentlich nur noch irgendwie diese komischen Schwingungseffekte.
Gut, also das zu den Sachen,
wie das Ganze, also wirklich elektrisch irgendwo aussieht.
Inzwischen ist es aber eben so, oder glücklicherweise so,
dass wir sagen können, okay, Hat man mal gesehen.
Erstaunlicherweise funktionieren die Computer trotzdem, haben eben jetzt irgendwelche Elektronikingenieure
zusammengebaut, die sie mit sowas ein bisschen auskennen.
Und für mich als Informatiker kann ich eben sagen,
ich habe hier irgendwie diskret eine Null und eine Eins und
keine Strömen und Spannung und abstrahiere davon und kann dann eben wirklich in dieser digitalen Welt bleiben.
Gut, ja, hier nochmal zu dem, was ich
gerade eben schon mal angesprochen hatte, also Probleme mit Pegelsteuerung.
Also wie gesagt, wenn ich sowas wie Pegelsteuerung hier in so einer Rückkopplung habe,
also hier irgendwelche Schaltungen und sei das nun ein Einfacher in Wärter,
funktioniert das Ganze natürlich nicht.
Demzufolge kann man mit solchen Pegelgesteuerten Zeitlinien,
also mit Ledges, letztendlich keine stabilen Zustände speichern.
Was man dann dort macht oder machen muss,
ist eben ententsprechend entweder zwei hintereinander schalten oder das,
was man typischerweise hat,
gleich irgendwelche Flanken gesteuerten Elemente zu nehmen,
weil man da dann eben definiert mit Vorderflanke und Rückflanke
entsprechend arbeiten kann
Gut, zwei Phasentakt ist jetzt eben etwas,
was man also gerade bei solchen Pegelgesteuerten Sachen dann auch machen könnte,
ist, dass man also quasi zwei separate Takte,
4-1 und 4-2 hat,
die dann eben mal das eine,
mal das andere pegelgesteuerte Flipflop in so einem Rückkopplungsfahrt letztendlich ansteuern,
weil was man ja eben nicht haben möchte, ist,
dass sich also eine Rückkopplung reinbekomme.
Demzufolge kann ich jetzt auch nicht sagen,
ich nehme jetzt einfach einen normalen Tag, der wird irgendwo einmal,
geht er mal in das eine rein, wird invertiert,
geht in das andere rein,
weil es da dann eben auch zeitlich Bereiche geben kann,
wo dann vielleicht dann doch beide durchleiten und man dann eben wieder diese Rückkopplung beziehungsweise dann dort entstehenden Zeitbedingungen verletzen würde.
Rein technisch kann man sich das dann eben so vorstellen,
dass man sagt, okay,
wenn ich jetzt hier in Takt und hier einen invertierten Takt habe,
nicht also noch besser wäre es dann eben das Ganze noch so
ein bisschen so um diese Flanken nach hinten beziehungsweise nach vorne zu verschieben.
Nicht, dass ich da dann also quasi zu wirklich zwei Tagsignalen 4-1 und 4-2 komme,
die, wenn ich sie jetzt eben übereinanderlege,
also wirklich sauber um diese Tagflanken herum, Nasen des Jungtenbereich haben,
wo dann eben nicht beide aktiv sein können.
So, und dann kann ich eben jetzt über so eine Scheidung und dann so ein Zwei-Phasentakt auch dafür sorgen, dass ich also hierüber dann irgendwie eine Rückkopplung schalten kann. Nicht,
also das wäre also die Grundidee,
die man bei so einem Zwei-Phasentakt hat,
den kann man dann auch durch relativ einfache,
sinnige Schaltungen, also sich dann erzeugen,
also dass wir dann also hier so ein hartes Beispiel,
wie man dann also im Prinzip so ein Zwei-Phasentakt sich erzeugen kann aus einem einzigen Tag,
der dann also auch hier über solche vollgekoppelten Gatter und dann eben hier noch so zusätzliche Verzögerung,
weil das ist dann eben der entscheidende Teil,
der dann also hier für diese des jungen Bereiche sorgt,
dafür sorgen kann, dass das Ganze dann eben genau dieses Verhalten liefert.
Wie gesagt, auch das kann man sich dann so ein hartes Ansehen entsprechend simulieren. Nicht,
wenn man das dann macht,
würde man dann eben letztendlich sowas haben,
wo man dann eben hier den Eingangstakt hat und dann eben hier
seine beiden Takte PRs und Feed 2. Und zwischendurch gibt es dann eben wirklich Bereiche, wo letztendlich beide inaktiv sind.
Damit könnte man dann eben so eine Schaltung anschauen. Gut,
ja, verlassen wir jetzt wieder so ein bisschen diese technische Ebene
und kommen jetzt eben wieder zu dem etwas formaleren Teil,
nämlich wirklich, wenn ich jetzt also Schaltwerke habe und entwerfe,
also sprich Mili oder Mur-Modell für jetzt eben irgendwie eine Schaltung.
Wie kann ich das eingeben? Wie kann ich das beschreiben
? Wie entwirft man das dann beispielsweise?
Und auch da gibt es dann eben
sehr viele verschiedene Möglichkeiten
Einige davon haben wir ja schon grob kennengelernt. Das würde ich jetzt,
dass ich hier gleich nochmal ein bisschen genauer vertiefen und auch
nur als Vertiefung und als Ausblick dann nochmal also auf sowas wie Stageharts kurz eingehen,
auch nur um nochmal so ein bisschen für spätere Veranstaltungen in der Informatik zu motivieren,
wo man dann eben da dann also in der Richtung noch
ein bisschen mehr macht oder noch ein bisschen mehr tut war.
Also dieses Grundkonzept von endlichen Automaten
Ist also jetzt nichts, wo man sagt,
naja gut, das ist also irgendwo so ein Rechnerstrukturen,
das muss sich im ersten Semester also irgendwie mal hören und dann kann ich das wieder vergessen.
Also eigentlich will ich programmieren und mit diesem ganzen Hardware-Getüdel nichts zu tun haben.
Also dieses Grundkonzept von Automaten und Zuständen und dem,
was sich dahinter verbirgt, ist also ein relativ entscheidendes Konzept,
was dann also ein sehr vielen sehr unterschiedlichen Stellen, also in der Informatik brauchen würde.
Also dazu kommen dann also nochmal so ein paar kleine Folien,
der das nochmal so ein bisschen motivieren soll. Gut,
was wir schon kennengelernt haben,
sind im Prinzip diese tabellenartigen Beschreibung, also Flusstafel bzw. Ausgangstafel,
rein praktisch ist das also nichts anderes als das,
was wir also schon bei Schaltnetzen kennengelernt haben,
also als eine Funktionstabelle,
mit der ich eben entweder im Falle der Flusstafel das Zustandsübergangsschaltennetz,
also das Delta-Schaltennetz beschreibe oder als Ausgangstafel dann eben die Funktionstabelle,
die mir dann eben die Ausgangsfunktion,
also das Lambda-Schaltennetz beschreibt
Dazu haben wir jetzt also ein sehr anspruchsvolles Beispiel,
nämlich eine Ambridge-Schaltung, die also nichts anderes macht als die vier Zustände,
Ampel ist rot, geht auf rot an und gelb an,
geht auf grün, geht dann wieder auf gelb,
geht anschließend wieder auf rot und so weiter, immer jeweils nur zyklisch durchläuft.
Gut, das kann ich jetzt in einfachster Folge natürlich so machen,
dass ich sage, na gut,
ich habe vier Zustände, die muss ich irgendwie kodieren,
also um jetzt vier unterschiedliche Zustände unterscheiden zu können,
brauche ich also irgendwie zwei Bit,
ich kann dann eben aus diesen Kombinationen von 0 bis 1,
1 eben meine vier Zustände kodieren.
Da denke ich mir jetzt, also irgendeine Kodierung aus und sage eben,
dieser Zustand wird eben dadurch kodiert, dieser Zustand durch den Vektor und so weiter.
Wir können ja entsprechenden Tabelle wird dann eben letztendlich einfach nur,
wie wir das ja also vorhin schon bei den Schaltfunktionen gehabt haben,
dann eben eingetragen, quasi hier Z1 und Z-Nol,
also der aktuelle Zustand, dem zufolge dann als Eingangslektor und das,
was dann also daraus berechnet wird, nämlich der Folgezustand,
also sprich Z1 beziehungsweise Z0. Plus dann eben als Folgezustand.
Und das wäre dann eben letztendlich meine Flusstafel von der Schaltung.
Und das, was man hier dann eben drin hat,
ist, ich bin eben in einem Zustand.
Ampel ist rot, kodiert durch diese beiden Witz.
Nächster Zustand sollte er hier sein. Also gebe ich entsprechend dessen kodieren als Folgezustand ahnen. So,
und hier mache ich dann also nichts anderes, als das,
was er nun vorher bei den Schadenätzen gemacht haben,
dass ich quasi sage, okay, das ist eben eine Schaltfunktion,
das ist eine andere Schaltfunktion nicht.
Und dann kann ich anfangen, die jetzt entweder mit Bulschalge
war KV-Diagramm oder wie auch immer, zu minimieren und zu entwerfen.
Gut, für die Ausgänge, auch eigentlich genau das Gleiche.
Ich habe meine Kodierung, ich sage, okay,
wann soll das rote Licht angehen, wann soll das gelbe Licht angehen,
wann soll das grüne Licht angehen?
Das ist in diesem Fall jetzt also nur abhängig von irgendwie dem internen Zustand.
Demzufolge haben wir auch hier sowas wie einen Moor-Automaten.
Nicht Ausgang ist nur abhängig vom Zustand
Ich muss dann eben hier einfach nur die entsprechenden Werte eintragen
und habe dann eben hier nochmal wieder drei Chart-Funktionen,
die man dann eben entsprechend minimieren und entwerfen kann.
Gut, das wäre jetzt eben dieses Beschreibung jetzt durch Flussstafel und Ausgangstafel. Andere Variante,
das, was sie ja auch schon gezeigt habe,
dann also dieses Zustandsdiagramm,
das ist dann eben letztendlich diese grafische Darstellung,
Zustand entsprechend eben quasi im Kreis,
also im Knoten und die kannten,
stellen dann letztendlich
die Übergänge dar
Dazu hat man dann folgende Beschreibung, Moore und Mili-Schaltwerk werde
ich dann gleich anhand der Beschreibung noch entsprechend kurz unterscheiden.
So ähnlich wie das hier dargestellt ist.
Ich habe hier quasi als Knoten jeweils immer meinen Zustand.
Der kriegt einen Namen, Bezeichner oder was auch immer.
Und wenn ich einen Moor-Automaten habe,
beim Moor-Automaten ist die Ausgabe nur vom aktuellen Zustand abhängig,
kann ich in den Knoten also auch noch
die zugehörigen Ausgangswerte eintragen
Ich, also bei dem, was so vorher bei den Flip-Flops drin hatten,
war der Zustand letztendlich nichts anderes als das gespeicherte oder der gespeicherte Wert,
also das Bit Null oder das Bit 1,
was sich letztendlich in meiner Schaltung drin habe.
So, das sind also dann die Knoten und die Übergänge
werden dann eben quasi durch diese Pfeile beschrieben und ich habe an den Pfeilen dann eben die jeweilige Bedingung,
die dann eben letztendlich so zu lesen ist,
dass wenn ich in dem Zustand A bin, Hier,
jetzt X steht,
ist das also quasi nur eine Kurzschreibweise für X ist gleich eins.
Also sprich, wenn X gleich, also das soll
nichts anderes als ein butscher Ausdruck sein.
Also wenn X gleich eins ist, gehe ich in den Zustand
B. Wenn X negiert, also X quer ist,
also sprich X gleich 0, gehe ich in den Zustand
C. So ist das Ganze zu lesen. Und was hier
jetzt nicht mit eingezeichnet ist oder was nicht mit eingezeichnet wird,
sondern was dann implizit mit drin ist,
ist dann die Art und Weise,
wo jetzt ein Taxsignal ins Spiel kommt
Nicht, weil hier beschreibe ich jetzt, wie ich von
einem Zustand unter irgendeinem bestimmten Eingangsvektor in einen anderen Zustand gehe.
Und das Ganze passiert dann eben nur zu den Tagzeitpunkten,
also beispielsweise, wenn ich im Rückkopplungsfahrt vor der Flanke gesteuerte Register habe,
wenn sich der Tag mit einer Vorderflanke eben entsprechend ändert. Das heißt,
ein Tag kommt, ich gehe von A nach B,
der nächste Tag kommt, diese Eins ist so zu lesen,
dass also quasi das Ganze unabhängig von irgendwelchen Eingängen ist,
mit dem Takt gehe ich in den Zustand,
Und je nachdem, welche Bedingungen dort dann gilt,
würde ich in dem nächsten Takt eben entweder in C bleiben oder eben je nach B rübergehen,
wie auch immer.
Wächst du, wir sind dann im Prinzip diese Zustandsdiagramme zu lesen.
Was man teilweise dann in den Automaten auch immer noch hat,
ist, also ein definierter Startzustand. Nicht,
weil da hatte ich ja gesagt,
wenn ich also quasi sowas wie einen Zähler habe oder irgendwie ein bestimmtes Protokoll abarbeiten möchte oder so,
möchte man eben sagen, nach dem Einschalten, ich bin genau an der Stelle.
Das kann man dann eben technisch erreichen durch solche Reset-Leitungen oder Setzleitungen,
die dann eben teilweise noch an die Flipflops gehen,
dass ich eben in einem bestimmten Zustand starte,
zeichentechnisch oder grafisch dann eben häufig so gemacht, dass man,
wenn ich jetzt also hier so einen Zustand habe,
also hier dann also irgendwie sowas wie so ein Talsegment quasi einfärbe und man das dann auch macht oder es eben irgendwie anders durch unterstreichen oder einen doppelten Krängel noch irgendwie besonders hervorhebt.
Nicht okay, das macht jeder Outdoor ein bisschen anders.
Nicht bloß, wenn ihnen irgendwie sowas begegnet,
dass man weiß, okay, das ist ein besonderer Zustand.
Ansonsten kann man da eben nochmal nachfragen, was ist jetzt
damit gemeint. Aber dass man eben auch sagen kann,
okay, ich habe eben noch sowas wie ein expliziten Startzustand
häufig noch
Gut, wie sieht das Ganze? Beim Mili-Automatenhaus,
Mili-Automat, das wäre derjenige,
wo eben die Ausgabe nicht nur abhängig vom Zustand,
sondern abhängig von Zustand und Eingangsvektor ist, führt dann dazu,
dass man also hier quasi im Zustand nur jetzt eben irgendeine Bezeichnung oder irgendeinen Namen hat.
Und an die Zustandsübergänge dann eben auch die jeweiligen Ausgangswerte geschrieben werden.
Also sprich so zu lesen,
ich bin in dem Zustand A und X ist gleich eins.
Dann hätte ich als Ausgabe 100 und wenn der Takt kommt,
wäre dann der nächste Zustand B. Wenn ich in dem Zustand habe und nächstes gleich null,
hätte ich als Ausgabe dann eben 1-1-1 und mit dem nächsten Tag bin ich in diesem Zustand.
Das heißt also, dadurch habe ich dann eben die Ausgabe
hier an den Zustand und die aktuelle Eingabe gekoppelt.
Das ist also die Art und Weise,
wie diese Zustandsdiagramme daneben zu lesen sind und was dann
eben dort auch den Unterschied zwischen Moor und Mili ausmacht
So, wenn man das weiß und begriffen hat, ist es eigentlich trivial und einfach.
Und dann wird es also bei den nächsten Übungsaufgaben dann auch wieder heißen,
ja, also warum fragt er so was? Nichtsdestotrotz ist es doch häufig so,
weil eigentlich kann man das wirklich also aus dem Auto,
wenn man so ein Diagramm hat und das vorgegeben ist,
also direkt ableiten und sagen, okay,
wenn ich den Ausgangsvektor hier reingeschrieben habe,
dann hängt das eben nur vom Zustand ab,
dann muss es ein Moor-Automat sein.
Ja, es ist einfach ein trivial, nichtsdestotrotz,
also auch in der Klausur kommt sowas als Frage,
wo man sagen kann,
hurra,
geschenkte Punkte
Leider machen, das sind doch immer nicht alle richtig.
Also, dass man eben einfach nur weiß, okay,
also, moo-Automat sieht das Ganze so aus.
Im Gegensatz dazu, beim Meli-Automat habe ich eben die Ausgänge
hier an den Kanten mit dran notiert.
Da kann man das also relativ einfach entscheiden,
beziehungsweise, wenn dann gefragt wird,
handelt es sich um einen Moor- oder Milli-Modell und begründen Sie das Ganze nicht,
dann schreibt man also irgendwie so einen Einsatz.
Es ist ein Milli-Modell, war die Ausgabe eben auch von
der Eingabe abhängt und schon hat man entsprechend richtig geantwortet
Gut, ja, dann nur kurzer Ausblick jetzt also auf die Stage Charts,
beziehungsweise das, was dahinter erweitert, noch gedacht ist.
Das sind also quasi, jetzt noch so eine Erweiterung von solchen Zustandsdiagrammen,
um Konzepte wie Hierarchie, weil, sagen wir mal,
so ein Automaten oder hier, also hier sowas wie hier,
den ich da sagte, ja gut,
das ist ja trivial, das ist einfach,
da habe ich aber auch nur vier Zustände.
Wenn ich jetzt mit so einem Automatenmodell irgendwie ein bisschen was
komplexes beschreiben möchte, also beispielsweise die Funktionsweise eines Taschenrechners,
Kann man auch alles in solcher Modelle reingießen?
Habe ich eben irgendwie ein paar mehr Zustände und
dann wird das Ganze also sehr schnell sehr unübersichtlich.
Deswegen möchte man eben zum Beispiel sowas wie Hierarchie mit einbauen können,
um dann eben zu sagen,
ich habe jetzt das und das gemacht und bin jetzt also
irgendwie in der Art und Weise der Verarbeitung,
wo jetzt also nur die und die Eingaben notwendig sind
und kann dafür dann eben andere Teile ausblenden,
beziehungsweise davon abstrahieren
Also das sind dann eben solche Sachen, wo man das dann also noch irgendwie so um Hierarchien erweitern kann.
Dann kommen dann noch so was wie Historien oder Default-Sachen mit hinzu,
dass wenn ich eben irgendwelchen Zuständen reingehe,
die dann also quasi hierarchisch beschrieben sind und ich habe sie verlassen und ich gehe da wieder rein,
wo starte ich da innen drin jetzt wieder,
starte ich da wieder bei null oder an der Stelle,
wo ich vorher in dem Automaten war, nicht,
da kann man auch unterschiedliche Sachen machen,
dann gibt es dann Möglichkeiten,
sowas wie Nebenläufigkeiten zu beschreiben,
also bislang hatten wir eh
nur einen einzelnen Automaten
Häufig ist es so, dass ich quasi sowas wie gekoppelte Automaten habe.
Wofür brauche ich das? Bleiben wir einfach bei diesem Beispiel,
auch wenn es doof ist, Ampelschaltung. Ich möchte jetzt beschreiben,
irgendwie so eine Ampel, wo ich also irgendwie darauf drücke,
mal als Fußgänger, kriege ich irgendwann mal grün und diese grünen Phase soll für eine bestimmte Zeit lang erhalten bleiben.
Jetzt kann ich natürlich sagen, okay, das modelliere ich einfach dadurch,
dass ich 20.000 Zustände habe, wo drin steht,
Fußgänger, Grün, Auto, Rot, Fußgänger, Grün,
Auto, Rot, Fußgänger, Grün, Auto, Rot.
Die laufe ich der Reihe nach durch und irgendwann kommt dann wieder der Fall,
Fußgänger rot und Autorot und irgendwann danach dann Autogäbe und Fußgänger rot. Kann man machen,
führt dann aber eben zu diesen sehr unübersichtlichen Beschreibungen als gekoppelter Automat,
sage ich, ich habe also mein Grundautomaten,
der mir eben sagt,
ich bin in dem oder dem oder dem Zustand und um jetzt solche zusätzlichen Zeitbedingungen mit reinzubringen,
habe ich dann eben noch so was wie irgendwie so ein Zähler oder ein Timer,
der quasi gestartet wird der entweder raufzählt oder runterzählt.
Und wenn ich eben eine Endzeit erreicht habe oder wenn das Ding
beim Runterzählen gleich null ist, dann kommt erst wieder der nächste Zustandswechsel.
Also führt dann eigentlich auch so ein bisschen so ein Konzept
von so einer Abstraktion oder Hierarchie mit ein.
Aber sowas kann man dann eben auch so übernehmen,
läufig kann. Dann nehmen zum Beispiel auch mit Beschreiben.
Gut, Timer-Zustände nach irgendwie bestimmten Zeiten verlassen. Sowas braucht man
auch relativ vor. Gut, ja, wie gesagt,
also Stage-Charts bzw. generell ähnliche Automaten sind eben wirklich, relativ zentral für die Informatik.
Deswegen kommen dazu auch gleich noch so ein paar Beispiele.
Hier nochmal also aus dem Originalartikel von Harrell,
was rausgezogen wurde, also um diese Stage-Charts dann nochmal ging.
Damals hat er also revolutionär 1987 über eine warmen japanischen Uhrenhersteller
quasi für die Steuerung einer Digitaluhr was gemacht, wo man eben sagt,
okay, wenn ich irgendwo einen Modus eingestellt habe,
ich möchte die Zeit stellen,
dann soll der Tastendruck das und das will wirken.
Und wenn ich im Modus bin,
der Alarm geht an und ich möchte ihn ausstellen,
dann soll der Tastnok irgendwie was anderes bedienen.
Und diese unterschiedlichen Modi kann man dann eben über solche hierarchischen Zustände eben ganz gut beschreiben.
Nicht in Wasser man hier immer irgendwie so sieht,
sind also quasi ineinander geschachtelte Dinger und innen drin dann eben wirklich sowas wie einzelne kleine Automaten,
die dann eben irgendwie so ein bisschen zusammengefasst werden,
die dann teilweise,
also in diesem Fall dann sowas wie Nebenläufigkeiten auch noch mitmodellieren und,
und,
Gut, wie gesagt,
endliche Automaten als eines der gängigen Konzepte der Informatik,
der ja so relativ häufig benutzt werden,
wo man eben quasi solche zeitlichen Abfolgen oder irgendwelche Zustandswechsel mit modelliert,
wo man eben beschreibt,
wie ein System auf irgendwelche Arten von Ereignissen reagieren soll,
wo man sagt,
wenn ich jetzt also irgendwelche Folgen von Aktionen haben möchte,
wie man das modelliert, nicht das wird da also relativ häufig benutzt.
Hier jetzt eigentlich auch nur zur Motivation nochmal so ein bisschen
die Folien dazu
Also bleiben wir mal bei der Theorie, formale Sprachen.
Es soll also ein Parser entwickelt werden,
der eine Eingabe A, B, A als richtig erkennt.
Alle anderen Eingaben als falsch. Kann man als Automaten beschreiben,
wo man sagt, okay, ich bin hier am Zustand S.0.
Dort starte ich, wenn ich als Eingabezeichen ein A halte,
gehe ich in den Zustand S.1,
wenn ich als Eingabezeichne jetzt irgendwas anderes oder ein B erhalte,
bin ich eben in einem Zustand S.4,
wo dann also quasi die falsche Eingabelampe angeht
Und hier, wenn ich ein B erhalte, gehe ich eben hierhin,
wenn ich ein A halte, eben auch wieder in diesen Fehlerzustand.
Und irgendwann, wenn ich dann, also A, B,
A, richtig gelesen habe oder eingegeben oder gepasst habe,
wie auch immer man das nennen möchte,
bin ich eben hier in einem Zustand S3,
der dann sagt, okay, gültige Eingabe.
Ich habe, wie gesagt,
das eben auch so als so ein Konzept,
wie man eben natürlich jetzt also sehr auf Low-Level-Ebene bezogen,
aber eben solche Benutzereingaben dann eben auch mitbeschreiben kann,
nicht und formal dann eben auch relativ einfach über solche Automatenmodelle
Anderes Beispiel, die arbeiten also jetzt hier bei einem Spielehersteller und er sagt,
okay, bauen wir mal jetzt hier für meine Bots in dem Spiel jetzt also irgendwie ein Modell,
was das Verhalten dieses Bots irgendwie modelliert.
Da kann man sagen, okay, der läuft durch die Gegend,
wenn der Spieler quasi in der Nähe ist,
wie man sieht, dass ein Blutrollenstil dieses Spiel,
soll der Blots also entsprechend angreifen,
wenn der Spieler nicht mehr in der Nähe ist,
okay,
dann sollte er auch wieder irgendwie unmotiviert so ein bisschen durch
die Gegend klatschen
Und so, wenn der Spieler sich jetzt beim Angreifen dummerweise wehrt,
dann versucht der Wort natürlich erstmal irgendwie zu entkommen,
bevor er da gefragt wird.
Und wenn er jetzt also irgendwie entsprechend schwerer verletzt ist oder so,
auch noch versuchen, also er ist da irgendwie die
wertvollen Medizinfläschchen aufzusammeln und sich selber zu heilen.
Und da kann das dementsprechend wieder weitergehen.
Oder wenn der Spieler jetzt also nicht entschlossen genug nachsetzt,
dann kann man ihn ja auch wieder angreifen.
Ja, solche Sachen. Also auch das ist eigentlich nichts
anderes als ein Automatenmodell und nicht, wo man sagt,
Zustand, Aktion, Zustand,
Aktion,
damit kann er dann eben
relativ viel
Solche Sachen beschreiben. Anderes Beispiel, das ist jetzt hier bei uns
aus dem Bereich Robotik, wo man also so typische kleinen Serverarchitekturen hat.
Es gibt irgendeinen Prozess, der macht einen Server. Es gibt also irgendeinen Prozess,
der macht einen Client, der Client will irgendwas von dem Server,
demzufolge sieht das dann eben auch so aus, dass dieser Server-Mechanismus,
also quasi jetzt irgendwie von dem Client ein Goal angefragt bekommt,
also liefert mir irgendein Datum oder mach irgendwas, was der also quasi machen soll.
Dann gibt es hier über solche Automatenbeschreibungen dann eben auch unterschiedliche Aktionen,
also ich das jetzt ausführen, wird das gerade ausgeführt,
wo das erfolgreich ausgeführt oder wird das irgendwie abgebrochen,
was auch immer man sich da jetzt an unterschiedlichen Varianten ausdenken kann.
Und auf der anderen Seite habe ich also irgendwie diese kleinen Seiten,
die dann sagt, okay, Sand Goal und warte,
bis der Server mir da irgendwie darauf antwortet oder,
oder, oder nicht.
Also auch sowas wird dann eben über entsprechende Beschreibung,
die dann eben letztendlich nichts anderes sind als solche endlichen Automaten umgesetzt.
Hier auch Boost, das ist auch eine fertige Programmierbibliothek,
die man also dann für seine Projekte mitbenutzen kann
Wo unter anderem dann eben auch, also sowas wie Stage Charts möglich sind,
also sprich so hierarchischen Automaten, das ist ja auch noch aus der Dokumentation,
war so ein Teil, so eine Screenshots rausgenommen.
Nee, wo ist also im Prinzip dann auch als Beispiel darum geht,
also sowas wie eine Kamera zu beschreiben,
wo ich dann eben quasi sagen konnte, okay,
also was passiert, wenn ich einen Auslöser drücke, nicht,
also ist das Ding eben entweder eidel oder startet gerade.
Nicht, wenn ich den Auslöser drücke. Gut, dann gehe ich
eben hier in diesem Teil des Automaten. Ich würde dann eben sagen kann,
okay, es wird versucht, erst mal zu fokussieren,
wenn das passiert ist und erfolgreich gelaufen ist nicht,
dann kann also den Sensor auslesen, das Bild irgendwo speichern und so weiter.
Also sowas kann man dann eben alles ganz gut in solche Automaten mit reinbringen. Ich denke,
es ist unterschiedliche Tools,
mit denen man also auch solche endlichen Automaten beschreiben kann,
teilweise dann eben auch wie hier angedeutet mit solchen grafischen Oberflächen,
wo man dann eben letztendlich dann also hier immer seine Zustände und irgendwelche Zustandsübergänge damit beschreiben kann,
wenn dieses hier natürlich dann also auch auf einer Ebene,
die jetzt eigentlich der Programmierung entspricht und jetzt nicht irgendwelchen Bits und Bytes,
wie jetzt also vorhin in den Beispielen in Rechnerstrukturen.
Gut, ja, das ist also jetzt noch mal so ein bisschen zur Motivation,
weswegen ich ja so ein bisschen mehr jetzt,
also auf endlichen Automaten herumgeritten bin.
Dann möchte ich, ja doch, so viel Zeit ist noch, noch mal
Die letzten drei Minuten auf eine andere Art von Beschreibung eingehen,
auch die jetzt hier nur grob dem Namen nach vorgestellt.
Also das, was wir jetzt das Jahren praktisch brauchen,
sind also eben eher so Flusstafel, Ausgangstafelzustandsübergangsdiagramme. Es gibt auch textuelle Beschreibungen,
also gerade bei Hardware-Beschreibungssprachen sieht das eben typischerweise so aus,
dass sich eben so ein Verhalten dann eben auch quasi wie in so einem Programm funktional beschreiben kann.
Und da gibt es dann eben auch spezielle Hardware-Beschreibungssprachen,
was man dann eben auch beispielsweise ist,
also hier für den Schaltungsentwurf nutzen kann, weil dann nicht,
also auch da muss man natürlich sagen, wenn ich jetzt also als Firma,
also irgendwo meinen Prozessor mit 8 Milliarden Transistoren irgendwie entwerfe,
dann fange ich nicht an,
einzelne Gatter oder irgendwie einzelne Transistoren zu begrüßen,
sondern da sagt man eigentlich, also das und das soll die Schaltung tun,
beziehungsweise da gibt es dann eben entsprechend vorgefertigte Blöcke,
die man nehmen kann,
zusammenfügen kann und damit dann also entsprechend seine Sachen mit modelliert nicht.
Also wie gesagt, hier nicht weiter vertieft, hier nun mal als Motivation,
wie also im Prinzip so ein D-Flip-Frop in gängigen Hardware-Beschreibungssprachen aussieht.
Also die eine Sprache ist Verylock und das, was man hier eigentlich sagt,
ist, oder was typisch für solche Hardware-Beschreibungssprachen ist,
dass man eben einmal sowas wie eine Blackbox-Beschreibung hat.
Das heißt, ich sage, was sind Eingänge der Schaltung,
nämlich Daten, Clock und was ist der Ausgang der Schaltung,
also in diesem Fall Q,
demzufolge definiert man hier also für so ein Modul Ein- und Ausgänge von eben einem bestimmten Typ und kann dann eben noch sagen, wo was gespeichert werden soll.
Und dann habe ich hier quasi als Beschreibung für das,
was ich tun soll. So eine Anweisung,
die sagt, always at post-edge, also jedes Mal,
wenn ich eine Taktvorderflanke habe oder wenn das Research-Signal irgendwas macht,
muss ich gucken, es kann sich intern hier irgendwie was ändern.
Und wenn das Research-Signal verantwortlich ist, wird das Ding eben auf Null zurückgesetzt.
Wenn ich nicht nicht ein Reset habe, dann werde ich hier einen Taktförderflanke haben.
Also speichere ich den Wert, der im Datennaheingang ist,
also quasi unten nehmen das in den Ausgang.
So, bei VHDL, das ist das,
was wir hier also teilweise auch in einigen Veranstaltungen auch mit benutzen,
etwas andere Syntax, gleiche Funktionalität. Nicht also auch hier Beschreibung,
Blackbox mit Eingängen und Ausgängen und dann habe ich hier unter Architecture dann quasi so eine interne Beschreibung,
wo ich also hier sage, es gibt einen Prozess,
if reset gleich 1, dann Datenausgang gleich 0,
wenn ich in den Takt vorderflanke habe,
dass es eine Funktion Rising Edge.
Dann soll der Datenausgang den Wert hier übernehmen und das Ganze speichern und fertig ist.
Und das liest sich im Prinzip, also wie so eine
sehr einfache, imperative Programmiersprache. Und wenn ich jetzt sage,
okay, in Hardware habe ich dann ja natürlich noch so ein paar zusätzliche Eigenschaften,
also zum Beispiel Nebenläufigkeit, mache ich eben hier dann einfach dadurch,
dass ich sage, ich habe nicht nur einen so einen Prozess,
sondern ich habe mehrere Prozesse und jeder von denen ist quasi sowas wie ein parallel arbeitendes Teil,
was dann also letztendlich Hardware inhärent daneben arbeiten kann.
Gut, bei Very Lock letztendlich genau das Gleiche
Gut, damit sind wir jetzt eigentlich mit diesen Formalia durch.
Jetzt kommen hier noch ein paar Beispiele,
werde ich dann übermorgen vorstellen und da müssen wir dann eigentlich
dann mit diesem Tal zu den Schaltwerken dann diese Woche sicherlich auch noch fertig.
Gut, dann genug für heute.