kurze Ankündigung, bevor ich jetzt also hier mit den Folien weitermache,
in der kommenden Woche wird es in den Übungsgruppen,
sprich Montag und Dienstag, Weihnachtsgeschenke geben.
Okay, es gibt litere Geschenke. In diesem Fall wird es
sich also jetzt nur um die Musterlösung der ersten Übungsaufgaben handeln. Das heißt,
ich bin jetzt also irgendwie seit zwei Tagen dabei,
die Drucker bei uns zu quälen und sprich als Vorbereitung dann eben auch später für die Klausur,
wo ja,
wie ich ja gesagt hatte,
im Prinzip dann eigentlich ähnlich wie in den Übungsaufgaben,
also sagen wir mal
vergleichbare Fragestellungen drauf drankommen
Werde ich oder habe ich da jetzt eben nochmal entsprechend,
hoffentlich vernünftig dokumentierte Musterlösungen erzeugt,
wo dann also auch jeweils für die einzelnen Aufgaben beziehungsweise Aufgabentypen
jetzt wirklich der Lösungsweg beschrieben ist und eben,
sagen wir mal, die Gedankengänge, die so dahinter stehen,
dass man das dann eben auch entsprechend nachvollziehen kann und sagen wir jetzt anders als bei den Vorlesungsfolien,
da dann eben vielleicht auch noch ein bisschen mehr kleinen Text dabei hat.
Wie gesagt, die können sich dann am Montag bzw. Dienstag in ihren jeweiligen Übungsgruppen abholen.
Gut zur Not kann man die dann also auch noch irgendwann später Polen,
beziehungsweise dann vielleicht schon auch bei uns im Sekretariat,
aber im Prinzip gibt es da dann also schon mal einen kleinen Stapel Papier.
Gut, vorgestern hatte ich ja im Prinzip motiviert,
war es jetzt Schaltwerke sind, das heißt,
dass ich dann eben noch zusätzlich diese Rückkopplung habe und je nachdem,
wie diese Rückkopplung sich auswirken. Das heißt,
ob die jetzt eben wirklich nur über reine Gatterverzögerung oder Verzögerungsglieder arbeiten,
habe ich dann eben entweder asynchronische Schaltwerke Oder wenn ich dann eben wirklich jetzt Flip-Flops einsetze in diesem Rückkopplungsfaz synchronische Schaltwerke,
wobei Flip-Flop selber sind eben in Anführungszeichen sauber entworfene, asynchrone Schaltwerke.
Flip-Flop-Typen, das war ja das, womit ich noch mal letztes Mal eigentlich aufgehört hatte. Wie gesagt,
in Hades gibt es dann im Prinzip diese D-Ledges,
das heißt pegelgesteuerte Elemente, Vorderflanken gesteuerte Elemente Und davon heißt eben unterschiedliche Varianten,
wo ich dann eben noch sowas wie ein asynchrones Reset,
irgendwelche Enable-Signale habe oder eben auch sowas wie diese JK-Flip-Plops,
die ich ja eingangs auch noch mal kurz vorgestellt hatte.
Was dann eben bei Flip-Flops eigentlich immer entscheidend ist,
wo es jetzt also auch in den aktuellen Übungsaufgaben dann also eine entsprechende Aufgabe zu gibt,
ist dann eben wirklich dies zeitliche Verhalten,
wo man dann eben auch versucht,
jetzt in der Simulation, in dem zeitlichen Ablauf,
also jetzt mit so einem Impulsdiagramm dann eben zu zeigen,
das unter bestimmten Bedingungen quasi Zeitbedingungen, die,
die jetzt eigentlich eingehalten worden sind, eben verletzt worden sind.
Und das signalisiert man dann eben in der Regel dadurch,
dass man am Ausgang des Flip-Flops dann,
also sowas wie hier so einen undefinierten Wert,
also in diesem Fall jetzt hier einfach so einen Zyren gezeichneten Wert einträgt.
Nicht, also hier, wenn jetzt nochmal,
sagen wir mal, die beiden, in Anführungszeichen,
interessanten Flip-Flop-Typen, nämlich einmal ein Deletch und ein Vorderflanken gesteuertes D-Flip-Flop.
Und hier oben ist also irgendwie eine willkürliche Kurve jetzt also für das Taktsignal,
hier dann den Dateneingang. Beide Flipfroffs sind dann jeweils mit einem Dälter oder wie immer man das dann nennen möchte,
Verzögerung quasi gerechnet oder durchgespielt und was man dann eben hier sieht,
ist, dass quasi beim, sowohl beim Ledge,
also beim D-Flipfrop, dann also jetzt hier entsprechend dieser Zeitbedingungen,
also hier jetzt der Vorderflanke beziehungsweise dem Wert 1, an dem Blog-Eingang,
dann eben der Dateneingang mit 1 um einen Tag hier verzögert oder eine Zeiteinheit für mehr verzögert auftritt.
Hier an dieser Stelle mit dem Datenangang, würde ich dann
also hier quasi das Flip-Flop da wieder auf null zurücksetzen.
Das heißt also, diese Aktie,
also mit dieser Flanke erzeuge ich dann eben hier diese Aktion.
Und hier wäre jetzt eben eine Taktforderflanke,
wo dann eben hier entsprechend dieser Wette übernommen wird.
Und die großen Unterschiede sind jetzt eben bei Vorderflanken gesteuerten Flip-Flops
ist eigentlich immer nur diese vordere Flanke entscheiden.
Das heißt, immer nur ein Takt nach dieser Vorderflanke kann
sich der Ausgang entsprechend ändern. Unter der Voraussetzung,
dass sich also nicht gleichzeitig Dateneingang und dieser Eingang hier ändern.
Nicht dem zufolge habe ich dann eben entsprechend dieser Flanke hier
den Wert auf eins und an dieser Stelle über diese Flanke
würde ich dann also hier diese Null entsprechend einspeichern.
So und bei dem Ledge sieht man jetzt eben also
mal hier eigentlich eher so einen interessanten Fall,
wo jetzt eben der Takteingang dann eben eine ganze Zeit lang
eins ist
Und dadurch, dass hier der Dateneingang,
also erst eins ist, dann eben einmal null,
dann eben wieder eine Zeit lang eins,
ergibt sich quasi jetzt hier diese Abfolge eins,
also quasi das Ziel für diesen Wert,
die null um einen verzögert jetzt für diesen Wert,
die eins hier jetzt für diesen Wert,
nicht und dann schaltet das Ledge ab, das heißt,
der Wert, der jetzt quasi hier letztendlich am Ende dieser Taktperiode anliegt,
bleibt dann eben entsprechend lange gespeichert,
nicht hier würde dann jetzt eben wieder eine Eins übernommen werden,
so und jetzt habe ich hier an dieser Stelle aber eben genau den Fall,
dass also mit dem Abschalten des Takteingangs sich gleichzeitig der Dateneingang ändert.
Nicht das führt dann dazu, dass das Ledge jetzt hier in ein,
also zumindest in der Simulation in einen ohndefinierten Zustand geht.
Nicht das macht man eben genau deshalb,
um dann eben auch wirklich jetzt dem Entwerfer,
der jetzt also ein Hade ist oder wo auch immer seine Schaltung jetzt also eingegeben hat,
dann eben in der Simulation auch zu zeigen.
Du hast da also irgendwo ein Side-Problem und musst dann entweder an deinen Dateneingängen,
also Clock bzw. D jetzt, also irgendwo was mit dem
Timing tun oder du hast also grundsätzlich unsauber gemachten Entwurf,
aber so kriegt man das dann dementsprechend angezeigt.
Rein praktisch wird das natürlich immer so sein,
dass jetzt also irgendwelche Schaltungen natürlich jetzt nicht irgendwie undefiniert sind,
sondern da wird sich entweder eine Null oder eine 1 einstellen,
vielleicht auch noch irgendwie so ein mehrmaliger Wertewechsel,
das heißt also irgendwelche dynamischen Hazards,
nicht bloß es ist eben letztendlich dann nicht genau vorhersagbar,
was sich tut, weil, wie gesagt,
diese Idealvorstellung, dass ich eben beide Signale,
also wirklich zum identisch Leichenzeitpunkt ändern.
Also das wird ja in der Praxis dann eben auch nie vorkommen.
Und dadurch hat man dann eben wirklich aufgrund minimaler Laufzeitunterschiede beziehungsweise dann eben wirklich den internen Verhältnissen,
wie sie jetzt also im Aufbau der Flip-Flops auftauchen,
dann eben den Wert,
dass sich da dann eben entweder eine Null oder eine Eins logischerweise einstellte.
Gut, mit diesen Zeitbedingungen, wie gesagt,
die werden eigentlich eingeführt,
um jetzt also Schaltwerke eben deutlich einfacher zu entwerfen
In der Regel bei dem, was wir jetzt am Schaltwerksentwurf machen,
wird man dann eben mit im Rückkopplungsfahrt,
also irgendwelche Flanken gesteuerten Flip-Props einsetzen,
wo ich dann eben entsprechend mit diesem einem Taktsignal den Zustand des Schaltwerks umschalten kann.
Ich habe aber, wie gesagt,
jedes Flip-Flop selber ist eben ein asynchrones Schaltwerk mit der Grundvoraussetzung,
dass eben für das Flip-Flop diese spezifischen Zeitbedingungen eingehalten werden
Also auf Nenner gebracht, kann man dann eigentlich immer sagen,
dann und Hackdarangänge dürfen sich also nicht gleichzeitig ändern.
Rein praktisch kann man dann immer noch unterscheiden zwischen sogenannten Vorlauf-
und Haltezeiten. Das ist also jetzt hier mal am Beispiel
eines Vorderflanken gesteuerten D-Flipflops modelliert. Und zwar besagt also,
dass die Vorlaufzeit beziehungsweise im Englischen dann entsprechend Setup-Time eben die Zeit ist,
wo sich das Datensignal jetzt vor der Taktflanke eben nicht mehr ändern darf.
Das heißt, wenn ich jetzt also hier mit der roten Linie jetzt,
also ich meine Taktflanke mir da irgendwo rein definiere, ich dann besagt halt,
diese Set-up-Time,
dass ich also spätestens an diesem Zeitpunkt der Dateneingang geändert haben
muss und danach eben keine Änderung mehr auftreten darf,
wenn jetzt eben eine Änderung des Dateneingangs quasi jetzt hier in dieses Zeitintervall,
also in dieses TS reinfällt,
würde dann eben
das Simulationsmodell von dem Flipflop sagen im Ausgang undefiniert
Entsprechend ist, gibt es dann eben auch in der anderen Richtung,
das heißt nach der Tagflanke, dann eben die Haltezeit,
beziehungsweise im Englischen an Hotime.
Das wäre dann eben die Zeit, wann eben frühestens sich
ein Datenangang des Flipflops auch wieder ändern kann.
Nicht dem zuvor kann man dann immer sagen,
dass also in diesem Bereich um die Taktflanke,
das heißt Taktflanke minus Setup zahlt bzw. Taktflanke plus Hohlzeit,
sich der Datenangang nicht ändern darf
Gleichzeitig gibt es dann eben noch, oder ist jeder noch angezeigt,
dann so eine Verzögerungszeit des Flip-Flops selber,
womit dann eigentlich nur ausgedrückt ist.
Also es wird ja quasi jetzt mit der Taktflanke dieser Wert des Dateneingangs übernommen.
Und bis der dann am Ausgang des Flip-Flops selber liegt,
wird das natürlich auch noch irgendeine gewisse Zeit dauern.
Das ist dann eben diese TFF-Verzögerungszeit des Flip-Flops
So, wenn ich jetzt sage, ich nehme Flip-Flops,
um in Schaltwerken letztendlich den aktuellen Zustand zu speichern und damit
eigentlich die Synchronisation des Schaltwerks zu gewährleisten. Das heißt,
ich habe hier jetzt also irgendwo meinen Flip-Flop drin, habe dann,
also in diesem Fall jetzt hier zum Beispiel ein Murschaltwerk mit dem Ausgangsschalten,
jetzt Lamda,
was also aus dem Zustand ein Ausgangsfektor berechnet und in diesem Zustandsübergang Oder Zustandsübergangsfunktionen der da,
die dann also quasi aus dem aktuellen Zustand und einem Eingabevektor eben einen Folgezustand berechnet.
So, und wenn man jetzt sagt, also hier an
der Stelle habe ich ein ganz normales Flip-Flop drin, also ein Flankengesteuertes Flip-Flop.
Welche Zeitbedingungen ergeben sich dann also für Änderungen in meinem Eingangs-Vektor X?
Kann ich sagen, wenn ich jetzt irgendwo einen Takt habe,
dass Flip-Flop jetzt hier also irgendwo einen Zustand,
der am Ahlengang anliegt, speichern oder übernehmen soll,
muss eben gelten, dass also die Hohlzeit eingehalten wird.
Und demzufolge ergibt sich jetzt für Änderungen in dem Eingangsvektor,
dass der eben mit einer minimalen Verzögerungszeit,
also T. Del Damin, hier irgendwie an diesem Ausgang anliegt.
Wenn ich das jetzt also hier von der Hohlzeit abziehe,
habe ich dann also quasi jetzt hier eine Minimalzeit,
wo sich also jetzt hier der Eingangsvektor nach der Taktflanke
ändern darf
Gut, andersrum gerechnet kann ich dann aber eben sagen,
vorm nächsten Takt,
wann darf sich da dann der Eingangsvektor jetzt also irgendwo ändern,
da habe ich jetzt eben zum einen die Setup-Zeit des Flip-Flops,
zum anderen habe ich dann eben hier auch eine Verzögerungszeit,
wobei ich jetzt also hier mit dem, in Anführungszeichen, längsten Fahrt,
das heißt mit einer maximalen Verzögerungszeit rechne und damit erhält man dann eben quasi jetzt hier über diese Summe ein Wert beziehungsweise ein Pfad, wann sich eben als letztmöglicher Zeitpunkt vor dieser Tagflanke T2 der Eingang ändern darf.
So war das zusammengenommen, führt dann dazu,
dass man dann also hier quasi letztendlich oder dann eben sowas wie so ein Intervall erhält,
wo sich der Eingang ändern darf,
das ist jetzt hier natürlich also irgendwie entsprechend überspitzt gezeichnet,
sondern rein praktisch, also so das heißt im Verhältnis zu den Taktflanken,
wo dieses Intervall natürlich sehr groß sein,
aber man sieht da eben, dass sich einmal hinter der Tagflanke,
beziehungsweise hier vor dieser nächsten Tagflanke,
da ist da dann eben Bereiche gibt,
die dann also aufgrund der Setup und holt Bedingungen und zusätzlich dieser Verzögerungszeit,
die sich hier in diesem Schaltnetz ergibt,
die dann also quasi jetzt nicht zulässig sind für Änderungen in dem Ahrgangsfektor X. Gut,
alles,
was ich gerade eben jetzt schon an der Grafik erklärt habe,
ist also jetzt hier auf dieser Folie dann eben auch nochmal kurz-textuell beschrieben.
Gut, die einzelnen Punkte will ich jetzt also nicht nochmal vorlesen.
Das heißt, da können sie aber dann nochmal entsprechend nachsehen,
wie sich jetzt also diese Zeiten entsprechend ergeben.
Analog dazu kann man jetzt eben auch sagen,
welche Zeitbedingungen sich jetzt eben für Änderungen innerhalb des internen Zustands bzw. dort innerhalb der Taktung ergeben.
Und zwar kann ich da dann eben auch mit diesen Zeitbedingungen
jetzt hier in diesem Delta-Schaltennetz rechnen, dass ich sage,
Mit einem Taktsignal habe ich jetzt eine Verzögerungszeit, die erstmal vergeht,
bis also hier dieser Eingangsvektor quasi am Ausgang erscheint.
Dann hat er sich also jetzt hier geändert. Dann habe ich jetzt also einen Bereich,
wo ich jetzt also zwischen Tower, Delta Mien und Tower,
Delta Max, also jetzt hier die Verzögerungszeit in diesem Delta-Schaltnetz habe.
Das heißt, wie lange es dann eben dauert,
bis ich also durch diese Änderung des Zustandswektors,
also aufgrund des Tagsignals dann eben hier auch ein neuer Wert für den Folgezustand errechnet.
Das heißt, rein praktisch wird dann eben in diesem Grau
gekennzeichneten Kästchen sich irgendwann mal, oder vielleicht dann eben der Folgezustand ändern.
Und was dann eben gewährleistet sein muss, ist,
dass also dieser Bereich erst nach der Hohlzeit des Flip-Flops und vor der Z-Upside des Flip-Flops,
wenn ich dann also den nächsten Tag betrachte, Letztendlich,
also dann in diesem Bereich hier angesiedelt sein muss.
So, jetzt habe ich ja also bei beiden Beispielen eigentlich immer gesagt,
ich habe hier Deltamin, Delta, Max,
also irgendwie unterschiedliche Verzögerungszeiten durch dieses Schaltnetz.
Jetzt habe ich natürlich die Frage vermisst, warum noch keiner
gefragt hat, also warum sich da unterschiedliche Verzögerungszeiten ergeben.
Deshalb wird es also die Frage in die Runde,
hätte jemand eine Idee,
woran das liegen kann
Eine Antwort, Versügungszeit innerhalb der Schaltung Gelder. Ja. Genau vorhersehen,
wie schnell die Schaltung kommt, aber für die Umweltbedingungen,
Temperaturen, durch die Stromstärke, die an die und weitere Parameter.
Ja, so lange kann die Dauer sein,
aber ich denke, genauso ist es. Gut,
also die Antwort war jetzt,
es geht ja im Prinzip erstmal nur um die Verzögerungszeiten hier
in dem Delta und ich hatte ja also als ich jetzt überhaupt die ganzen Zeitbedingungen und Verzögerungszeiten motiviert habe,
ja gesagt, also aufgrund von Unwaldparametern für Sorgenspannung,
Alterung und was weiß ich, sind die Elemente unterschiedlich schnell.
Könnte man jetzt vermuten, dass das jetzt also hier die Antwort wäre,
muss ja aber sagen, ist es leider nicht.
Also das spielt natürlich auch letztendlich mit rein,
dass Ich also sowieso erst mal, also bei der Vorhersage jetzt von solchen Verzögerungszeiten eine gewisse Unsicherheit habe.
Und wenn man jetzt in irgendwelche Datenblätter von irgendwelchen Bauelementen reinguckt,
da ist es auch wirklich so,
also dass dort die Hersteller auch in der Regel sagen,
das ist also, sagen wir mal, der typische Wert,
der trifft also 90 Prozent der Fälle zu.
Und dann gibt es einen Minimalwert und einen Maximalwert und sie garantieren eben,
dass die Bausteine quasi innerhalb dieser Grenzen letztendlich funktionieren.
Nicht, aber es kann dann eben zu Schwankungen kommen bzw.
einzelne Instanzen oder einzelne Individuen können sich eben auch immer Betrieb letztendlich noch verändern.
Also das ist richtig, das ist aber jetzt also gar
nicht das, was sich jetzt direkt hiermit meinte.
Die vorne Wankenmeldung war das auch in die Richtung oder eine andere Idee.
War in die Richtung. Alles mit Ambelblau.
Das hat im Endeffekt gefragt, was das Signal quasi,
bin ich dazu schon aufgebaut hat
Gut, also da war jetzt die Antwort,
dass das jetzt irgendwie Bauteil abhängig ist, also sprich,
je nachdem, ob ich jetzt also quasi mit einem nennt oder Nore oder mit irgendwas anderem rechne.
Habe ich das jetzt so richtig verstanden oder habe ich das falsch wiedergegeben? Ich dachte eher,
dass man quasi, weil das hat auch der quasi drauf,
stand mit dem Händler und Nores,
selber schon mal das drehende Zustand,
sich gerade in meinen Tag hätte herausgegeben,
wenn ich Anfragen brauche,
weil das ist das,
was Signal in der Hälfte von Servers Kreuzberscheidung
ja erstmal auch wieder zu tun
Nee, leider hier, hier jetzt auch nicht.
Also das, also die Antwort war jetzt,
also dass es da ja im Prinzip ist,
also um die Kreuzverschaltung in den Flipflops geht und dass man da jetzt ja unterschiedliche Fahrer hat.
Das ist ja, ist ja hier unten.
Das ist ja erstmal außen vor. Also das,
was ich jetzt sage, ist,
dass ich nur einfach eine Schaltfunktion habe, wo ich einfach hier,
also X und Set reingebe und ich kriege hier irgendwas raus.
Und hier drin, also dies ist jetzt wirklich ein
reines Schaltennetz, da habe ich also noch keinerlei Rückkopplungen drin
Ähm... Don'ts da hinten war noch eine Meldung.
Ja, ich weiß nicht genau, wie das war.
Auffall heißt, aber es ist ein Auge.
Er geht der Taktereien und er hat eine gewisse Verzögerung.
Und dann geht es erst um das Zelt und inszeniert.
Dann geht es erst um die Weltverschaltung.
Und das X geht ja der Eckpfalm.
Deswegen hat man ja
quasi eben
Ja, gut, also es ist jetzt auch noch nicht das,
was ich meinte, also das,
was sie jetzt ja gerade geantwortet hatten,
ist ja im Prinzip, dass ich unterschiedliche Pfade habe,
also ob ich jetzt quasi hier das Set betrachte,
wo ich also letztendlich hier noch diese Verzögerung in dem Flip-Flop habe oder ob ich das X betrachte.
Ich denke mir, da ist vielleicht ein bisschen verwirrend,
dass ich also hier diese Folie immer noch habe liegen lassen.
Das, was ich jetzt also wirklich meine, ist,
dass man jetzt ja nur innerhalb dieses einzelnen Schaltennetzes, also mit unterschiedlichen Faden für diese Verzögerung hier rechnet.
Und das ist letztendlich jetzt eigentlich dadurch begründet oder kann begründet sein,
dass ich, also jetzt abhängig davon,
welche Schaltfunktion ich hier realisiert habe, ich natürlich entsprechend,
mal gucken, ob ich jetzt hier irgendwie mal ein sinniges Beispiel finde,
wo ich dann also eben sehr unterschiedliche Pfade in meinem Schaltennetz,
also ich muss jetzt also hier nochmal, also wirklich ein Kapitel zurückgehen,
weil ich jetzt hier wirklich nur sage, ich habe im Prinzip,
nehmen wir hier so was, also ich habe jetzt hier einfach nur ein Schaltennetz, Und beispielsweise ändert sich jetzt hier ein Eingangssignal.
So, und die Änderung dieses Eingangssignals wirkt sich,
wie man hier zum Beispiel ganz gut sieht, also über unterschiedliche Pfade aus,
nämlich einmal quasi über dieses und und das Odergatter.
Und einmal hier jetzt über ein Inverter und das und und das Odergatter.
Das wäre jetzt also zum Beispiel dafür,
wo ich also jetzt für eine Änderung eines einzelnen Signals,
also mit unterschiedlichen Faden rechnen muss, nämlich je nachdem,
ob ich jetzt,
also meinetwegen von 1 nach 0 oder von 0 noch 1 schalte,
ist quasi einmal dieser Pfad hier obenrum entscheiden und einmal dieser
Fatih untenrum entscheidend
Und dadurch ergeben sich dann innerhalb eines einzigen Schaltnetzes für
ein Eingangswerk oder dann eben auch schon unterschiedliche Verzögerungszeiten,
wann sich am Ausgang entsprechend jetzt etwas ändern kann.
Das war jetzt das, was ich da eben im Prinzip
jetzt bei den Beispielen mit den Schaltwerken
gemeint hatte
Gut, also das jetzt nur noch mal als Erklärung,
dass man eben hier auch im Prinzip,
wenn man schon mit unterschiedlichen Zeiten arbeiten muss und demzufolge dann eben hier auch unterschiedliche Intervalle dann,
also sich ergeben. Gut, also auch hier zu,
also jetzt noch mal zu diesem Taktschema,
also auf diesen Folien dann, also entsprechend die Begründung,
wo jetzt also im Prinzip einmal erst mal gesagt ist,
dass ich also innerhalb dieses grau gezeichneten Bereichs,
das heißt für Zührungszeit des Flipflops plus Minimalzeit bis Verzögerungszeit des Flip-Flops plus maximaler Verzögerungszeit kann sich eben der Wert des Folgezustands
Z plus ändern. Das ist dann eben hier genau das,
wo sich dann also hier das Set plus ändern kann.
Und das muss eben nach der Hohlzeit und vor der Setup-Zeit des nächsten Tagssignals dann eben letztendlich hier angekommen sein,
damit ich dann eben bei dem Tag,
also zum einen nicht zu schnell bin,
aufgrund dieser Hohlzeitbedingungen zum anderen aber eben das Ganze jetzt eben auch so langsam takte,
dass ich also dann entsprechend hier schon stabil die Werte habe,
bevor dann hier der nächste Tag kommt und dann eben noch ansprechend diese Setup-Bedingungen erfüllt sein muss.
Gut, also auch hier nochmal die textuellen Beschreibungen des Ganzen in entsprechenden Items,
wo dann eben letztendlich genau beschrieben ist,
wie sich die Zeiten zusammensetzen bzw. waren sich dort eben entsprechende Änderungen eingestellt haben müssen.
So, wenn man jetzt diese Aussagen zu den Eingangsvektoren beziehungsweise jetzt zu den Taktbedingungen zusammenfasst,
kann man eigentlich dann auch letztendlich Aussagen treffen, wo es dann also darum geht,
mit welcher maximalen Taktfrequenz die Schaltung ist überhaupt, betrieben werden kann.
Zum einen muss natürlich gelten, dass, sagen wir mal,
insgesamt die Taktfrequenz, beziehungsweise da die Periode,
also größer ist als die Summe, als ausholt und Setup-Zeit.
Im Flip-Flop war dann, habe ich sonst nämlich gar keinen gültigen Zeitpunkt,
wo sich also am Allengang irgendwas ändern darf.
Und zum anderen muss jetzt eben gelten,
dass die Verzögerungszeit im Flip-Flop plus der Setup-Zeit plus eben dieser
maximalen Verzögerungszeit in irgendwelchen vorgeschalteten Gattern kleiner ist, als die Taktperiode.
Mich war ich sonst eben automatisch damit erreiche,
dass quasi hier diese Verzögerungszeit plus Delta Marx eben schon sogo groß ist,
dass sich das Ganze dann eben quasi hier in die Setup-Zeit fällt.
Und auch dann würde die Schaltung letztendlich hier in dieser Setup-Zeit
dann eben irgendwelche falschen Werte übernehmen, was dann dazu führt,
dass die Schaltung dann Im Zweifelsfall irgendwie falsch rechnet,
in falsche Zustände gelangt oder was weiß ich, sich auch immer komisch verhält.
Und das ist also im Prinzip genau das,
was dann also bei solchen Übertaktungen eigentlich bei rauskommen würde.
Gut, jetzt kommen nochmal so ein paar kleine Folien,
wo es also jetzt im Prinzip um die unterschiedlichen Funktionsweisen von Taktsignalen geht.
Das führt jetzt also hier mal relativ schnell gehen. Also das,
was sie bislang immer vorgestellt hatte,
jetzt so als Taktsignal für irgendwelche Schaltungen oder das,
was man sich meistens immer irgendwie so vorstellt,
ist eigentlich irgendwo so ein periodischer,
symmetrischer Takt mit irgendwie einer bestimmten Taktperiode,
die dann also quasi hier einmal komplett das Ganze umfasst.
Grundsätzlich ist also erstmal nicht von vornherein gesagt,
also dass der Takt also immer symmetrisch sein muss.
Das heißt, es kann also auch ruhig so aussehen,
wie es also unten angedeutet ist,
wo ich jetzt eben ihnen relativ kleine einzelne
deutlich größere Nullphase hätte
Und gerade bei einigen Takt-Shimata, wie diesen Zwei-Phasen-Tag,
den ich nachher noch kurz vorstellen werde,
wird man sowas dann in der Regel auch einsetzen,
war ich dann im Prinzip, also mit mehreren Takten arbeite,
die dann so ineinander verschränkt sind,
dass sie sich dann aber gegenseitig eben nicht überlappen dürfen.
Gut, die Steuerungsvarianten sind ja eigentlich genau das,
was also schon durch die Flipflops selber vorgegeben ist,
nämlich dass ich eben entweder eine Pegelsteuerung habe. Das heißt,
wenn das Taktsignal eins oder null ist,
wird eben der Eingang durchgeleitet oder eben das, womit wir dann,
sagen wir mal, auch meistens arbeiten oder arbeiten werden,
ist dann eigentlich eher so was wie eine Flankensteuerung,
wo ich dann eben wirklich nur zu einem Wertewechsel von 0 nach 1,
also dann eine Förderflankensteuerung hätte oder eben zu einem Wertewechsel von 1 nach 0 mal einen Wert übernehme.
Andere Tagschemata, also zwei Phasentakte mehr,
Phasentakte werde ich also hier gleich noch mal als Beispiel zeigen,
wo man das letztendlich braucht, ist,
wenn ich also im Rückkopplungsfahrt mit Pegelsteuerung arbeite,
war ich dann mit einer Flanke,
weil die sonst eben nicht funktionieren würden
Die, sagen wir mal, richtigen Tagschemata oder Taktvarianten,
wie sie dann also letztendlich nachher in Prozessor Pipelines eingesetzt werden,
wo man dann also jetzt teilweise dann also auch mit
sehr ausgeklügelten Methoden der Taktung arbeitet,
um die Schaltung dann eben möglichst effizient und möglichst schnell
zu machen
Werde ich also jetzt hier nicht weiter vorstellen,
weil da muss man dann also doch schon wieder
sehr genau jetzt auch auf schaltungstechnische Tricks eingehen,
die dort also beispielsweise dann eben in Prozesse Pipelines eingesetzt werden,
wo ich im Prinzip dann nämlich die logischen Funktionen von Schaltwerken
und das speichernde Verhalten von Elementen
miteinander verknüpfen kann
Wo man dann also im Prinzip ins Wasser reinkommt. Gut,
also hier nur noch mal als Grafik aufgezeichnet, also im Prinzip die unterschiedlichen Varianten.
Also wenn ich jetzt hier so ein Taktsignal habe,
wie gesagt, bei der Pegelsteuerung,
also zum Beispiel ist es als High-Aktiv,
wäre dann eben quasi dieser rot gekennzeichnete Bereich interessant,
vor der Flanke wäre dann eben entweder jetzt hier bzw. Rückflanke
dann eben an diesen Stellen
in meinem Taktsignal
Gut, bislang hatte ich da ein paar Taktsignale ja immer nur so als schön gezeichnete Rechtecke vorgestellt,
also sowas wie dieses hier oben,
rein praktisch kann man natürlich sagen,
ich müsste eigentlich in einer unendlich kurzen Zeit von meinem Eingangswert Null,
wie auch immer ich den interpretiere, auf den Eingangswert 1 kommt,
das wird natürlich also schon mal irgendwo nicht gehen,
sondern also man redet dann eigentlich auch immer erstmal von Taktflanken,
das heißt also es dauert zumindest ein gewisses ein Bereich,
der natürlich möglichst kurz sein sollte,
aber eben doch einen gewissen Bereich, wo dann also im Prinzip,
wenn ich das jetzt also hier wirklich als analoges Ereignis mir ansehe und sage,
das entspricht irgendwelchen Spannungspegeln,
der dann eben quasi von null Volt auf zweieinhalb Wort oder was auch immer entsprechend ansteigt.
Und also auch da sieht es dann so aus,
dass das immer noch eine Abstraktion ist von einem Verhalten,
was dann eigentlich also eher so einer Kurve entspricht,
wo ich dann also hier irgendwelche überschwingende Effekte habe und nicht,
dass dann also hier beliebig sich, also irgendwie rauf und runter zittert.
Nicht so würde das dann also wirklich in Realenscheidungen aussehen bzw. um das,
also wenn wir wirklich auf die Spitze zu treiben,
habe ich hier also nochmal ein Screenshot von einem Ostzeloskop.
Also das, was man hier sieht, also diese Kurve hier oben,
ist ein 33-Megahertz-Takt-Signal eines PCI-Buses, der dann allerdings jetzt über irgendwelche Flachbandkabel,
die dafür also auch nicht so richtig geeignet sind, also irgendwie weitergeführt werden.
Also dieses hier oben ist die High-Pegel, das ist eine Rückflanke,
dieses hier ist dann der Lobpegel und das ist dann hier wieder die Vorderflanke. Also wenn man das nicht weiß,
sieht man da also jetzt irgendeinen komischen Sägezahn oder was weiß ich,
dann kann man sich eigentlich sowieso immer nur wundern,
weswegen die Schaltung, also jetzt wirklich als Digitalschaltung,
also dann bei solchen Signalen immer noch funktionieren und wenn man dann eben jetzt eben auch in den Bereich geht,
wo man sagt,
also ich möchte ja jetzt mit möglichst viel Performance irgendwo im Gigahertz-Bereich arbeiten,
nicht.
Da habe ich dann also auch sowas nicht,
sondern sind das alles nur noch mehr oder minder irgendwelche Sinuskurven,
beziehungsweise dann eben auch mit solchen Zacken oben und unten noch,
weil da kann man eigentlich dann also keine Plateaus mehr ausmachen,
sondern da schwingt das eigentlich auch nur noch irgendwo auf und runter.
Was man bei solchen Taktsignalen dann eben auch immer noch machen
sollte oder was sie auch noch quasi beschrieben ist,
ist also, dass sich tunlichst dann immer zusehe,
dass man eben hier ein sehr steiles Ansprechen,
das heißt also sehr steile Flanken hat.
Das heißt, dass man eben oder dass eben irgendwelche elektrischen Schaltkreise letztendlich
immer noch unterscheiden können zwischen diesem Anstieg hier und irgendwelchen Überschwingern,
die sich also jetzt hier beispielsweise ergeben. Was man dann teilweise noch machen kann,
sind dann eben jetzt wirklich irgendwelche Elektrotechnischen Schaltungstricks,
wo man jetzt also beispielsweise mit besonderen Gattern sogenannten Schmidtträgern dann also wieder dafür sorgt,
dass solche in Anführungszeichen sehr unsauberen Signale dann wieder so umgewandelt werden,
dass sie dann also wieder vergleichsweise vernünftige Flanken bekommen.
Das ist also beispielsweise da noch das,
was also in den meisten oder in vielen Bauelementen dann eben auch passiert,
die jetzt also irgendwie beispielsweise im Computer auf Motherboard irgendwo verbaut sind,
wo ich also jetzt von irgendwelchen Peripheriebausteinen jetzt erstmal in Anführungszeichen sehr unsichere oder sehr schlechte Takte bekomme,
dass dort, wenn das dann also letztendlich in den Chip hineingeht,
dort über entsprechende Eingangsschaltung dafür gesorgt wird,
dass man also quasi innen drin dann also möglichst sauber,
das heißt also zumindest also irgendwie sowas oder sowas an Signalen erhält und damit dann also letztendlich dann wieder weiterrechnen kann.
Gut, ich hatte dann, Angas, ja auch schon gesagt,
mit Pegelsteuerung kann es dann Probleme geben,
wenn ich jetzt also irgendwelche Taktpegel gesteuerten Elemente,
das heißt also irgendwelche einfachen Ledges nehmen würde,
um damit beispielsweise jetzt so was wie Schadwerke aufzubauen,
weil, was man natürlich bei der Pegelsteuerung ja hart ist,
dass also während des aktiven Signals, also beispielsweise beim HR-aktiven Ledge,
wenn da das Taktsignal 1 ist,
werden die Eingangswerte ja direkt auf den Ausgang weitergeleitet.
Das heißt, wenn ich in meinem Schallnetz irgendwelche Rückkopplungspfade habe,
die dann eben beispielsweise jetzt auch noch irgendwie sowas wie invertieren.
Das heißt, im Minimalfall hätte ich jetzt also hier sowas
wie ein Pegelstarter Sledge und hier ein Inverter.
Dann habe ich also hier nichts anderes als im Prinzip,
wenn immer nur so eine oszillierende Rückkopplung,
wie ich das ja so eingangs da auch schon bei dieser einen Beispielschaltung mit dem Ringoszellator beschrieben hatte.
Das heißt, mit einzelnen Delages kann man eben nicht in Automaten quasi jetzt hier die Rückkopplung in seinem,
für sein Zustandsregister aufbauen, weil das ja eben bei Pegel Hai dazu führen würde,
dass das also hier zyklisch vielleicht irgendwie undefinierte Werte erzeugt.
Deshalb muss man entweder flankengesteuerte Elemente nehmen in diesen Rückkopplungsfaden oder
man setzt also ähnlich solchen Masterslave-Anordnungen wie ich das,
also bei einem Aufbau von Flipflops, der beschrieben hatte,
zwei pegelgesteuerte Zeit, die da hintereinander,
die dann eben mit unterschiedlichen Takten geschaltet werden.
Das heißt, ich habe da dann eben wirklich zwei Ledges,
die getrennte, takte 4-1 und 4-2 haben für die Ansteuerung.
Und eben beim Takt 4-1 quasi dann das vordere Flipflop den Wert übernimmt.
Das zweite ist dann dementsprechend erst mal gesperrt. Anschließend schaltet
der Takt 4-1 ab dann der Takt Fee 2 entsprechend wieder ein.
Und das Ganze, oder der aktuelle Zustand hat sich dann entsprechend geändert.
Das heißt, das ist eigentlich direkt vergleichbar mit diesem Masterslave-Prinzip,
wo ich also D-Flipflops aus Ledges aufbaue.
Also zwei Phasentakt im Prinzip kann man sich das also erstmal natürlich so vorstellen,
dass ich sage, ich habe hier meinen Eintakt und hier dann erstmal einen invertierten Tag.
Da ich jetzt natürlich aufgrund interner Schwankung, immer nicht genau garantieren kann.
Also ob sich dann nicht doch irgendwie diese beiden Phasen noch gegeneinander verschieben,
sieht man dann eben bei solchen zwei Phasentakten dann auch wirklich zu,
dass man also jetzt wirklich das jungte Takte hat.
Das heißt, jetzt nicht nur einen Takt und irgendwas invatiertes,
sondern also die Takte dann eben so als asymmetrische Takte,
wie jetzt also hier unten angedeutet, aufgebaut sind,
wo ich dann eben diesen Takt 4A als Tier in Takt 42 habe und eben bei kleinen Verschiebungen,
die immer noch unabhängig voneinander sind
Gut, solche zwei Phasen-Takte kann man sich dann also auch über entsprechende Schaltungen oder über
entsprechende rückgekoppelte Schaltungen relativ einfach erzeugen. Also hier wäre dann mal ein Beispiel in Hades,
wo ich dann So,
wo ich jetzt also hier mal mit einer entsprechend langen Verzögerungszeit,
damit man das sieht, im Prinzip eine von einer Eingangs-Clock,
die ich also jetzt hier umschalte,
quasi zwei abgeleitete Takte,
nämlich diesen und diesen hier mehr erzeuge und aufgrund dieser entsprechend langen nachgeschalteten Verzögerungen sieht man aber dann auch hier sehr deutlich,
dass es eben zwischendurch immer noch diese eine Phase oder diese Bereiche gibt,
wo dann also wirklich auch beide abgeleiteten Signale
jeweils null sind
Gut, so würde das Ganze dann also beispielsweise jetzt auch von Hades
nochmal ausgeplottet dann als Impulsdiagramm aussehen und da sieht man dann eben sehr gut,
wie man dann also wirklich diese nicht überlappenden zwei Phasen takt,
also hier den einen, die unten den anderen,
dann hart,
die man dann eben für solche oder für die Ansteuerung
solcher Schaltung
benutzen könnte
Gut, das waren jetzt, sag ich mal,
eigentlich erstmal so die Grundlagen zu Schaltwerken.
Das heißt, wie sind sie prinzipiell aufgebaut?
Worauf muss man jetzt bei der Taktung achten?
Wie werden jetzt also in Schaltwerken die Rückkopplungspfade? Das heißt,
die Speicherung des Zustands realisiert,
das heißt eben entweder über zwei Ledges und solche zwei Phasentakte
oder eben in der Regel,
und das wird jetzt also hier in allen Beispielen
noch immer der Fall sein,
über irgendwelche Flanken gesteuerten Elemente
Jetzt werde ich hier noch mal kurz vorstellen,
wie man Schaltwerk jetzt wirklich beschreibt und entwirft.
Auch dazu gibt es also ähnlich wie beim Schalten-Netzentwurf,
also mehrere unterschiedliche Möglichkeiten, also sprich grafische Möglichkeiten,
Textbeschreibungen, Gebranche, Formen, irgendwelche Flusstafeln und Ausgangstafeln.
Das ist also quasi ein Äquivalent zu einer Funktionstabelle oder eben
irgendwelche verschiedenen Arten von Diagrammen
Gut, zum einen Flusstafel und Ausgangstafel ist im Prinzip
nichts anderes als die Funktionstabelle von Charlottennetzen. Nur dadurch,
dass sich jetzt hier quasi zwei Schaltnetze haben,
nämlich einmal dies Zustandsübergangsschaltennetz, also die Stelta-Schaltennetz,
spricht man dann eben einmal von der Flusstafel,
wo ich eben die Folgezustände als Funktion von aktuellem Zustand
und Eingangswert
Auf der anderen Seite dann eben für das Ausgangsschaltennetz,
also für das Lamdaschalten. Jetzt habe ich dann eben meine Ausgangstafel,
was dann eben eine Funktionstabelle ist,
wo ich dann eben die Ausgabewerte eben als Funktion von Zustand beziehungsweise,
also beim Mua-Automaten beziehungsweise als Funktion von Zustand und Eingabewert beim Mili-Automaten beschreiben kann.
Gut, dazu am besten relativ einfaches Beispiel,
eine einzelne Ampel Soll der Reihe nach immer vier Zuständen durchlaufen.
Nämlich einmal rotes Licht an, dann rot und gelb gleichzeitig an,
dann grün an, dann wurde sie wieder gelb und anschließend
sieht man dann wieder eine Rotphase.
Das könnte ich jetzt also direkt einfach als zwei Bit-Vactor quasi mit kodieren.
Einfach jetzt wieder Reihe nach binär durchgezählt. Hätte ich dann
eben für diese Ampelschaltung oder für diesen Ampelautomaten dann eben folgende Flusstafel,
wo ich dann also jetzt hier quasi meine Zustände beziehungsweise die
zuhörigen Kodierungen habe und dann eben die entsprechenden Folgezustände,
wo ich dann eben in diesem Fall immer nur mit jedem Tag von einem Zustand zum nächsten Zustand weitergehe.
Das heißt, hier gibt es also auch noch gar keine weitere Eingabe.
Gut, und dieses Ganze so aufgezeichnet würde sich dann
eben entsprechend Schlusstafeln nennen. Ausgangstafel analog dazu,
dass ich jetzt eben sage, ich habe jetzt hier
meine Zustände beziehungsweise die zugehörigen Kodierungen,
welche Ausgänge sind dazu
Entsprechend aktiv. Und da würde man dann eben auch,
ähnlich wie beim,
bei der Flusstafel bzw. ganz normal beim Schaltnetzentwurf dann eben sagen,
gut, ich habe jetzt eben hier drei Schaltfunktionen,
die man dann eben wie gewohnt beispielsweise in Form von KV-Diagramm minimiert oder eben,
also hier jetzt, also relativ einfach irgendwo ablesen kann,
waren welche Ausgänge aktiv sind.
Eine andere Beschreibungsmöglichkeit neben diesen direkten Beschreibung als Funktionstabelle dieser beiden Funktionen. Wir sind dann eben Zustandsdiagramme,
was dann also die grafische Darstellung von Schaltwerken macht,
wo ich dann eben sage,
für jeden Zustand nehme ich einen Knoten des Diagramms,
für jeden Übergang von einem Zustand zum einem anderen Zustand,
habe ich dann eben entsprechend eine Kante.
Und in den Kanten habe ich dann eben die Eingabemuster,
wo ich dann eben sage, unter welcher Bedingung ich jetzt eben
welchen Übergang von einem Zustand in einen anderen Zustand vollziehe.
Die Unterschiede zwischen Mili und Moor-Automaten äußern sich dann eben dadurch,
dass ich sage, gut,
beim Moor-Automaten ist der Ausgangswert ja nur vom aktuellen Zustand abhängig.
Demzufolge kann ich also die Ausgabe des Automaten direkt an diese Knoten anhängen und dort reinschreiben.
Wer bei Mili-Automaten ist die Ausgabe ja vom Zustand und der Eingabe abhängig.
Demzufolge würde man dort die Ausgabe dann an den hm,
anbringen, wo ich dann eben sage,
ich starte mit diesem Zustand,
habe die und die Eingabe und würde dann eben zu einem anderen Zustand gehen.
Wie sieht sowas aus, als Moorautomat hätte ich jetzt also
hier beispielsweise irgendeinen einfachen Automaten mit vier Zuständen.
Nicht im Zustand, dann immer entsprechend irgendeinen Namen oder Bezeichner
, was auch immer.
Und dann eben da die Ausgabe hier nur vom Zustand abhängig ist,
kann ich in dem Zustand dann eben auch schon
irgendeine Ausgabevektor notieren
So, für die Übergänge von einem Zustand zum nächsten Zustand habe ich dann eben hier diese Kanten und in den Kanten oder an die Kanten wird dann eben quasi eine Eingangsbedingung geschrieben,
unter der der Zustand verlassen wird und ich dann eben einen Übergang habe,
also beispielsweise wenn x gleich eins ist,
würde ich eben von dem Zustand A in den Zustand B übergehen,
wenn x gleich null ist,
also in diesem Vorwärtsjahr von dem x quer gekennzeichnet,
würde ich dann eben von A nach C übergehen.
Hier in diesem Zustand B hätte ich jetzt eben
eine Ein Zustandsübergang, der unabhängig von irgendwelchen Eingaben ist.
Deswegen ist diese Kante jetzt hier einfach mit so einer Eins gekennzeichnet.
Das heißt, in jedem Fall wird dieser Zustand dann
einfach verlassen und ich lande hier in einem Zustand sehe.
Hier sieht man jetzt eben beispielsweise dann auch,
wo ein Automat über mehrere Takte in einem Zustand verbleiben kann.
Das heißt, da habe ich dann eben eine entsprechende
Rückführung auf den Zustand selber
Was man dann meistens in den Automaten auch immer noch hat, ist, dass der Staatszustand eben entsprechend markiert ist. Das heißt also,
in der Literatur findet man dazu dann eben entweder,
dass also quasi jetzt hier irgendwelche Umrandungen oder Kreise entsprechend dick gezeichnet sind oder doppelt gezeichnet sind oder das,
was ich also dann auch immer mache und was man auch häufig findet,
ist dann quasi beim Staatszustand,
also dann hier noch so ein Segment dieses Zustands dann entsprechend irgendwie eingefärbt ist.
Gut, beim Mili-Automaten würde das Ganze dann eben so aussehen,
auch dort irgendwie jetzt entsprechend den Zuständen hier die einzelnen Knoten. Und der Unterschied ist jetzt eben,
dass ich hier dann auch jetzt wieder die an den Kanten,
die Zustandsübergänge habe von einem Zustand zum nächsten,
aber da beim Mili-Automaten ja die Ausgabe auch vom Eingang abhängt,
hat man dann eben in der Regel bei der Beschreibung dieser Zustandsübergänge,
also dieser Pfeil dann immer so eine Notation,
wo ich dann eben einmal die Bedingung anschreibe und dann eben mit slash oder wie auch immer getrennt,
anschließend eben den entsprechenden Ausgabe Vektor.
Das, was man dann also hier sieht, ist,
wäre dann eben, dass ich beispielsweise sage, vom Zustand A,
mit der Eingabe x gleich 1, gehe ich eben in den Zustand
B und die Ausgabe ist 1,00 und vom Zustand A mit der Eingabe x ist gleich null,
würde ich eben in den Zustand C gehen und die Ausgabe ist 1,11.
Gut, so lesen sich jetzt im Prinzip diese Zustandsübergangsdiagramme Und wie gesagt,
das ist dann also auch eine sehr effiziente und sehr übersichtliche Beschreibung von endlichen Automaten.
Was man dann teilweise noch findet, sind dann,
sagen wir mal, so hierarchische Versionen, solche Automaten.
Das Ganze nennt sich dann immer im Englischen dann Stage Charts,
wo ich dann das dahingehend erweitere, dass ich sage,
also solche Knoten sind jetzt also nicht nur die eigentlichen Zustände der entsprechenden Automaten,
sondern ein Knoten kann dann eben sowas wie Unterautomaten entsprechen und
den kann man dann eben auch wieder auflösen und dafür dann eben einen eigenen,
ein eigenes Zustandsübergangsdiagramm einführen.
Gerade bei etwas komplexeren Automaten ist das also eine relativ beliebte Beschreibung,
weil man sonst natürlich sehr schnell einfach in der Beschreibung oder in der Darstellung zu irgendwelchen Automaten kommt,
die dann also einige zig oder einige hundert Zustände haben.
Das Ganze wird demzufolge dann also natürlich extrem unübersichtlich und mit solchen hierarchischen Beschreibungen
Kann man dann also gerade im Bereich von eingebetteten Systemen oder von irgendwelchen Kommunikationssystemen,
wo ich also jetzt zum Beispiel unterschiedliche Protokolle mitbearbeiten muss, ganz gut arbeiten.
Eingeführt wurde das Ganze, also beispielsweise von David Harrell in einem entsprechenden Artikel,
den man sich, also hier dann auch runterladen und ansehen kann,
wenn man sich dafür interessiert oder auch nicht.
Ansonsten, also hier nur nochmal ein Ausschnitt von dem Ganzen,
da hat er im Prinzip jetzt über solche Zustandsübergangsdiagramme,
dann also eine Digitaluhr oder die logische Funktion so einer kleinen Digitaluhr entsprechend dann beschrieben.
Gut, neben Beschreibung von den Funktionen in Form von Ausgangstafeln,
Flusstafeln, neben grafischen Beschreibungen, wie jetzt eben solchen Zustandsübergangsdiagrammen oder Stageharts,
hat man dann eben noch die Möglichkeiten,
das Verhalten von Automaten jetzt,
also über textuelle Beschreibungen irgendwie formal zu fassen.
Das heißt also, ich beschreibe quasi jetzt das Verhalten
so eines Schaltwerks jetzt eigentlich wie ein Programm.
Das kann man machen im Prinzip ganz normalen Hochsprachen.
Was man dann häufig hat, sind dann also im Prinzip
für irgendwelche Sprachen, also irgendwelche speziellen Bibliotheken.
Also beispielsweise gibt es dann für C dann so eine Bibliothek System C,
wo man dann im Prinzip Hardware-Beschreibung realisieren kann und da dann eben unter anderem auch entsprechende Methoden hat,
um Dann solche endlichen Automaten zu beschreiben,
in Hardes gibt es im Prinzip was Ähnliches.
Oder es gibt eben wirklich spezielle Hardware-Beschreibungssprachen zu nennen,
wenn es also hier VHDL bzw. Very Lock.
Ich habe jetzt hier nochmal zwei Folien,
wo jetzt also nochmal kurze Beispiele sind, wie jetzt also im Prinzip
so ein D-Flip-Flop oder das Verhalten eines D-Flip-Flops in so einer Hardware-Beschreibungssprache aussehen würde.
Ansonsten aus Zeitgründen kann ich also jetzt das Ganze dann nicht weiter vorstellen,
was man im Prinzip jetzt mit Hardware-Beschreibungssprachen machen kann.
Man kann sich das eigentlich immer vorstellen,
also zum Beispiel gerade VHDL, wirklich wie eine ganz normale imperative Programmiersprache,
wo ich dann also im Prinzip jetzt einfach mit den Mitteln,
die man also aus der Programmierung kennt, mein Verhalten beschreiben kann,
wird man jetzt also hier dann gleich auch noch an den Beispielen kurz sehen.
Und das, was dann eben Hardware-Beschreibungssprachen eben noch ein bisschen besonders macht,
ist dann, dass zusätzlich dann eben auch mitspezifiziert ist in der Semantik der Sprache,
wie jetzt im Prinzip die Parallelität von irgendwelchen Abläufen,
wie es hier in der Hardware gibt,
dann eben auch in der Sprache beschrieben wird,
beziehungsweise dann eben auch für solche Simulationen von Schaltungen verfügbar gemacht werden.
Gut, in der Hardware-Beschreibungssprache Very Lock kann man sich da also zum Beispiel jetzt einen D-Flip-Flop,
also letztendlich so vorstellen, nicht,
also es gibt dann hier oben irgendwie unter so einem Bezeichner Modul,
nahm für das Ganze,
dann gibt es also hier eine Liste von Ein- und Ausgängen,
die jetzt also hier irgendwelche beliebigen Bezeichner bekommen.
Da kann man sich jetzt eben irgendwas ausdenken. Gleichzeitig wird dann
eben für diese entsprechenden Elemente gesagt, was davon eingang und was davon ausgang ist.
Zusätzlich wird dann also hier über ein Element Reck beschrieben,
dass dieser Ausgang dann eben sowas wie ein Speichernes Verhalten auch noch mit implementieren soll. So,
und dieses hier unten ist dann im Prinzip nichts anderes als sagen wir jetzt so eine Art Task,
der dann also nachher für die Simulation sagt, Jedes Mal,
wenn ich eine Vorderflanke von meiner Clock habe oder wenn das Reset-Signal aktiv ist,
muss ein Simulationsprogramm sich diesen Task quasi ansehen und einmal durchrechnen.
In allen anderen Fällen, das heißt,
wenn ich keine Vorderflanke von einer Clock habe oder wenn sich in einem Reset-Signal nichts tut,
kann ich diesen Code hier vergessen, weil dann interessiert er nicht.
Das ist also quasi hier so was wie so eine Art Triggerbedingungen. Und hier drin ist jetzt eben einfach das Verhalten,
wo jetzt eben drin steht, also If-Reset,
in diesem Fall ist das jetzt also so was wie so eine Art Bullsche Variablen,
nicht also Reset ist eins,
dann soll der Datenausgang auf einen Binärwert, null gesetzt werden,
ansonsten, wenn ich also jetzt nicht Reset habe,
dann muss das Ganze jetzt hier quasi durch die Vorderflanke von der Glocke getriggert sein,
dann soll der Datenausgang den Datenangang übernehmen.
Das heißt, damit habe ich diese Speicherung. In der Hardware-Beschreibungssprache VHDL,
die ein bisschen neuer ist als Very Lock,
anders als Very Lockdown,
also auch in Europa deutlich populärer und entsprechend verbreiteter,
wird das Ganze
so aussehen
Akronym für HDL ist, sagen wir jetzt ein bisschen,
doppelt zusammengemischt, steht dann eigentlich für VHS IC,
Hardware Description Language und VHS IC is and very high speed integrated circuit.
Also das ist jetzt ein Hardware-Beschreibungssprache,
die im Prinzip Ende der 80er Jahre entwickelt wurde,
relativ viel mit einem alten Ada-Standard gemeinsam hat,
also auch hinsichtlich der Syntax und auch auch teilweise hinsichtlich der Semantik.
Und da wurde ein D-Flip-Flop dann eben so aussehen,
dass sich hier quasi einmal zwischen Entity-D-F-F- bis End-Entity, sowas habe wie eine Blackbox-Beschreibung.
Das heißt, da sage ich erst mal,
welche Leitungen gehen rein, welche Leitungen gehen raus,
von welchem Typ sind die und die kriegen dann hier noch irgendeinen Bezeichner.
Und dann gibt es zu dieser Entity dann eine Architecture und in
dieser Architektur wird dann quasi das Verhalten des Ganzen beschrieben,
diese Architektualisierung beliebigen Namen und in diesem Fall ist jetzt also hier ein einzelner Prozess drin enthalten,
der dann eben angesprochen wird,
wenn sich eben auch entweder der Reset oder Clock ändern.
In einem Prozess passiert dann nichts anderes,
als das quasi jetzt einfach mit so einem IF-Konstrukt abgefragt wird.
Nicht bei Reset gleich 1, wird der Datenausgang null.
Ansonsten gibt es dann hier so eine vordefinierte Funktion.
Rising Edge von Clock, womit ich schon die Vorderflanke abfrage.
Wie hin, wenn ich das habe,
dann würde ich dann irgendwie einen Wert übernehmen. Gut,
das heißt also, das wären jetzt nur sehr kleine Beispiele,
wie man jetzt im Prinzip mit solchen Sprachlichen oder textuellen Beschreibungen,
also in diesem Fall ist das mit Hardwarebeschreibungssprachen dann das Verhalten von Automaten eingeben kann.
Gut, wenn jetzt Schaltwerke entworfen werden sollen,
was ja dann also auch noch im Rahmen einer Übungsaufgabe in der kommenden Woche dann ansteht,
dann hat man im Prinzip eigentlich sagen wir jetzt mehrere Schritte oder mehrere Abfolgungen,
die einem da einmal wieder begegnen.
Also man kriegt in diesem Fall jetzt, also Übungsaufgabe vorgesetzt,
so eine Art Spezifikation bei der Übungsaufgabe ist es textuell,
das kann aber auch grafisch sein,
das heißt,
man kann dann auch irgendwie sowas
wie so ein Zustandsübergangsdiagramm haben
Wie komme ich damit jetzt, also zu dem eigentlichen Schaltwerk? Das heißt,
wie komme ich jetzt von so einer Textbeschreibung oder so einer grafischen Beschreibung dann jetzt wirklich zu meiner Hades-Schaltung, die ich simulieren kann? Dazu würde man jetzt eben als erstes so eine formale Übergangstabelle,
das heißt, eben diese beiden entsprechenden Flusstafeln und Ausgangstafeln aufbauen,
sich überlegen, dann würde man gegebenenfalls, gut,
das wird jetzt hier bei unserem Beispiel nicht auftreten, sich noch überlegen,
wie baue ich das Ganze so auf, dass ich da,
also sag ich mal, möglichst wenig Zustände nur habe,
weil, also es kann sein, dass solche Spezifikationen,
gerade wenn sie jetzt also textuell beschrieben sind und vielleicht nicht ganz sauber spezifiziert sind,
also erstmal dazu führen, dass man,
also jetzt eine sehr große Anzahl von Zuständen, sich überlegt,
dann aber feststellen kann, dass eigentlich viele Zustände davon redundan sind,
weil beispielsweise ich dann, also meinetwegen jetzt hier feststelle,
also der Zustand und der Zustand,
die tun eigentlich funktional genau das Gleiche.
Das heißt, die haben die gleich,
also in diesem Beispiel ist es natürlich nicht so, aber angenommen,
die hätten die gleiche Ausgabe und würden unter den Leichen Bedingungen,
entsprechende Zustandsübergänge haben, dann könnte man sich eben überlegen, dass man dort Zustände zusammenfasst.
Nicht, das wäre dann eben die Reduktion der Zahl der Zustände. Anschließend müsste man sich jetzt eben überlegen,
wie kodiere ich die Zustände,
in dem Beispiel von der Armbreadschaltung hatte ich jetzt eben einfach erstmal nur gesagt,
einfach binär durchzählen, 0-0,
0-1, 1-0,
1-1. Man kann aber auch beliebig viele andere Kodierungen wählen,
was dann auch teilweise entsprechende Auswirkungen dann eben auf die Zustandsübergangs beziehungsweise auf die Ausgabefunktionen hat,
weil die dann natürlich vielleicht deutlich einfacher zu realisieren sind.
Also dazu werde ich gleich auch noch ein kleines Beispiel zeigen.
Und dann würde man dann irgendwie ganz normal jetzt beim Schaltennetzentwurf
Die Schaltennetze entsprechend minimieren und das Ganze dann eben beispielsweise jetzt über eine Simulation überprüfen.
Nicht zu dem Beispiel der Zustandskudierung, hat er gesagt,
also das Einfachste ist natürlich erstmal irgendwie sowas für so eine binäre Kodierung.
Gut, damit habe ich natürlich einfach über die Definition die
minimale Anzahl von Zuständen beziehungsweise die minimale Anzahl von Bits,
die für die Speicherung der Zustände brauchen
Was man aber auch oft hat,
weil das dann also vielleicht hinterher technisch in den Delta- und Lamda-Schaltnetzen einfacher umzusetzen ist,
ist, dass man also einschrittige Codes benutzt oder sowas wie solche One-Hot-Codierungen,
wo ich dann eben weiß, in jedem Zustand ist nur ein einzelnes Flip-Frop mit einer Eins belegt.
Alle anderen sind null. Dadurch kann ich dann also
zum Beispiel die Dekodierung von Zuständen wieder sehr einfach machen.
Wie gesagt, zu einigen davon oder auch ein sehr triviales Beispiel.
Dazu gibt es also gleich noch ein entsprechendes Beispiel. Ansonsten kann ich immer nur sagen,
ähnlich wie jetzt also bei der Minimierung von Schalnetzen,
gibt es also auch bei solchen,
bei den Möglichkeiten zur Zustandskodierung dann eben auch entsprechende Entwurfsprogramme beziehungsweise Simulationsprogramme,
die einem dann eben versuchen, da eine möglichst gute,
möglichst effiziente Lösung automatisch zu generieren und man kann dann eben sagen,
ich möchte mir mal angucken,
wenn ich jetzt beispielsweise die Art der Kodierung nehme,
wie effizient kriege ich
das entsprechend umgesetzt
Nicht letztendlich ist die Aufgabenstellung von dem Ganzen ja also ähnlich wie bei der Minimierung von Schaltfunktionen,
dass ich eben sage, ich habe Ausgangsfunktionen,
ich habe Übergangsfunktionen und ich habe jetzt also noch einen bestimmten Aufwand jetzt für die Flip-Flops in diesen Rückkopplungsfaden.
Und all das soll letztendlich gemeinsam minimiert werden. Gut,
wenn man jetzt Schaltwerke entwirft, dann kann man immer sagen,
wenn ich das Ganze jetzt ausgehen von Funktionstabellen mache,
dann funktioniert das eigentlich immer relativ problemlos.
War ich also in den Funktionstabellen, dadurch,
dass ich also vollständig spezifiziere, sind alle Eingangsbelegungen, alle Zustände berücksichtigt habe,
beziehungsweise was man dort dann ja auch ganz gerne verwendet,
sind dann eben für nicht benutzte Belegungen, solche Don't-Care-Therme.
Wenn ich als Spezifikation sowas wie Zustandsdiagramme bekomme,
dann ist das also schon nicht mehr ganz so einfach,
weil da können sich im Prinzip zwei Arten von Fehlern einschleichen,
die man also, sagen wir mal so,
auf den ersten Blick zumindest mal ein bisschen komplizierteren Diagrammen so schnell nicht mehr sieht.
Zum einen, dass ich Widersprüche in den Beschreibungen drin habe.
Das heißt, in einem Zustand bei einer Eingangsbelegung kann ich
eben entweder den Zustandsübergang oder einen anderen Zustandsübergang ausführen.
Nicht, dass wenn also Widersprüche, die andere Möglichkeit ist,
dass ich sage, die Eingangsbelegung bzw. die Übergänge sind gar nicht vollständig beschrieben.
Das heißt, ich habe jetzt also irgendeinen Zustand und kann
den aber bei bestimmten Angangsbelegungen gar nicht verlassen,
weil es dafür also keine entsprechende Kante in dem Diagramm gibt
Das heißt, da geht es dann also um die Vollständigkeit von solchen Diagrammen.
So formal gesehen kann man das Ganze jetzt dadurch überprüfen,
dass ich sage, wenn ich in meinem Schaltwerk eine Anzahl
von P-Zuständen habe und ich in dem Diagramm jetzt Kanten habe,
die dann also bezeichnet sind als HIJ von X,
das heißt der Zustand I wird unter der Bedingung X verlassen und man nimmt ihnen den Zustand J ein.
Wenn ich dann wäre, also die Vollständigkeit,
dass man also für jeden einzelnen Zustand überprüft,
also für alle I,
ist die Desjunktion aller Kanten in diesem Zustand gleich eins.
Das heißt, kommen wirklich alle möglichen Eingangsbelegungen,
die es gibt,
also auch in Kanten vor
Beispiel dazu, wären Sie also gleich, psss, pss.
Wählen Sie also gleich entsprechend dann nochmal sehen. Gut,
die andere Art von Problemen, die auftreten können,
waren ja im Prinzip Widersprüche. Das heißt,
auch hier habe ich jetzt wieder Zustände P, die kannten HIJ,
die jetzt eben von einem Zustand I in einen Zustand J unter der Bedingung X übergehen.
Und Widersprüche zu überprüfen, ist dann im Prinzip die Aufgabe,
dass sich dann eben auch für alle Zustände gucke,
wenn ich in einem Zustand zwei Kanten habe oder andersrum.
Also es muss gewährleistet sein, dass jede Kombination von zwei Kanten,
die in einem Zustand sind, wenn die jetzt miteinander unverknüpft sind,
dass sich dann eben die leere Menge erhaltet, also spricht,
dass die Bedingungen unter denen ich einen Zustand verlasse, zueinander desjunkt sind.
Beispiel, denk mal, dann wird das Ganze ein bisschen klarer. Ich betrachte hier diesen Grafen,
wo ich also hier in Zustand A habe,
den unter der Bedingung X1 nach B verlasse,
den unter der Bedingung X1 nicht und X0 nach C verlasse
und den unter der Bedingung X1 nicht nach D verlasse.
So die Vollständigkeit wäre jetzt,
dass ich quasi jetzt für diesen Zustand prüfe, gilt,
X1 oder X1, Nicht- und X0. Oder X1 nicht gleich 1.
Und wenn man das jetzt also entsprechend ausrechnen würde,
entsprechender googelt schon argebar, sieht man, das gilt.
Das heißt, diese Beschreibung ist vollständig. Bei der zweiten Bedingung,
also dieser Widerspruchsfreiheit, geht es jetzt eben darum,
dass ich quasi jetzt zu jeder Zustand immer paarweise die Kanten überprüfe.
Das ist genau hier diese Aussage,
dass ich die paarweise jetzt immer mit dem Mond verknüpfe.
Das heißt, ich nehme jetzt hier X1 und X1 nicht X0.
Das Ergebnis davon ist null, ist in Ordnung.
X1 und X1 nicht. Auch da würde ich sagen, das Ergebnis ist null. So,
und wenn ich jetzt also hier diese beiden Bedingungen oder dieses Paar überprüfe,
dann würde ich eben sagen, X1 nicht und X-0 und X1 nicht.
Und das ist eben ungleich null. War das es ihm genau X1, nicht X-0? Das heißt,
dass wir jetzt die formale Überprüfung, nicht also rein anschaulich,
kann man auch eben sagen, wenn ich die Eingangsbelegung habe,
X1 ist null und X-0 ist 1,
kann ich mir letztendlich aussuchen, ob ich diese Kante nehme,
also quasi hiernach möglich ist oder ob ich diese Kante nehme, was also hiernach möglich ist.
Das heißt, das Ganze ist jetzt also hier nicht widerspruchsfrei,
demzufolge wäre das jetzt also hier zumindest für einen deterministischen,
ähnlichen Automaten, also eine entsprechend schlechte Beschreibung, weil sie eben nicht funktioniert.
Gut, dann kommen jetzt noch einige kleine Beispiele zu Schaltwerken. Zum einen erstmal oder dann auch schon wieder. Also diese Verkehrsampel,
wo ich also jetzt nochmal zeige,
wie sich eigentlich diese unterschiedlichen Zustandskodierungen auswirken können,
dann auch nochmal kurz aufgezählt, dann so ein bisschen Wasser,
mal so wie einfache Zielschaltung,
weil im Prinzip ist eigentlich jeder Zähler formal gesehen nichts anderes als ein endlicher Automat,
bis auf die Tatsache,
dass dann meistens relativ wenig Eingaben hat und ich mit jedem Tag dann einfach nur 0-1,
2, 3, also letztendlich ein weiter zähle,
aber auch das ist im Sinne der Automatentheorie erst mal ein Automat,
den man entsprechend beschreiben kann.
Und ja, sofern die Zeit dazu lässt,
werde ich dann also noch mal kurz ein bisschen was zur
Digitalware oder irgendwelche BCD-Zähler, also andere Beispiele zeigen.
Gut einfachstes Beispiel, also was wie eine Ampel- oder Ampelschaltung.
Ich habe jetzt also, wie gesagt, hier meine vier Zustände,
die ich eben schon beschrieben hatte, in entsprechender Reihenfolge.
Ich habe zusätzlich drei Ausgänge, die ich betrachte,
nämlich einfach jetzt erst mal drei getrennte Leitungen für rote, gelbe und grüne Lampe.
Und in diesem Fall ist das jetzt natürlich erst mal relativ trivial aufgebaut.
Ich habe also keinen Eingang, sondern die Zustände werden einfach
immer nur der Reihe nach so zyklisch durchlaufen. So,
jetzt hatte ich ja eben schon gesagt, die Schritte,
um jetzt also so eine Schaltung aufzubauen,
wären dann eben als erstes das Aufstellen des Zustandsdiagramms,
war der Kodierung,
anschließend dann eben die entsprechenden Tafeln für Delta und Lamda-Schaltnetze aufzubauen und
dann eben entsprechend der ganz normalen Beschreibung von Funktionen bzw. Schaltfunktionen
dann eben die Minimierung der entsprechenden Schaltnetze
So, erste Variante, im Prinzip genau das, was ich eben schon auf den Folien drauf hatte, die Kodierung der vier Zustände einfach als zwei BitVactor. Nicht,
wenn ich das Ganze jetzt quasi die Fluss- und die Ausgangstafel zusammenfasse,
hätte ich jetzt also hier meine vier Zustände entsprechend einfach 00110 und 1110 und 11. Durchkodiert,
hätte dann quasi jetzt hier für die Flusstafel hier meine vier Folgezustände,
wo dann eben Ich immer nur den Übergang von dem Zustand rot,
in den Zustand rot, gelb,
von dem Zustand rot, gelb, in den Zustand,
grün, den hier von Zustand grün,
in Zustand gelb und von da aus wieder auf rot,
im Prinzip da rein nach Durchlaufe und gleichzeitig wird jetzt eben für jeden Zustand,
also wie man dann sieht,
das Ganze ist jetzt hier dann natürlich dann auch ein einfaches Moor-Modell,
für den Zustand dann eben der entsprechende Ausgangsvektor angegeben.
So aus diesen Fünf Schaltfunktionen, kann ich dann eben letztendlich
die resultierenden Schaltnetze ablesen. Man kann das dann also formal
mit KV-Diagrammen machen, also bei solchen einfachen Sachen,
kann man sich das also dann auch so relativ schnell ablesen.
Nicht also im Prinzip dieser Zustand, Z1 plus,
also der Folgezustand,
wäre da nichts anderes als die XOR-Verknüpfung von Z1 und Z0.
Nämlich an diesen beiden Stellen hat eine Eins in den anderen eine Null.
Z0 plus ist im Prinzip
nichts anderes als Z0 invertiert
Und für die Ausgänge gilt, dass das rote Licht quasi an ist,
wenn ich nicht in dem Zustand Set 1 bin.
Das gelbe Licht ist an, wenn ich,
oder nein, nein, Zustand Z1 nicht,
sondern das Zustands-BZ1 invertiert ist, in einem gelben,
das gelbe Licht ist, entspricht dann quasi genau dem Zustands-BZ.
Null. Und das grüne Licht ist eben an,
wenn Z1 und Z0
nicht an sind
Gut, das Ganze kann man dann eben entsprechend in Hades
angeben und könnte das dann eben zur Verifikation dann nochmal simulieren.
Und wenn ich jetzt hier der Reihe nach das Ganze entsprechend durchtakte,
dann sieht man das also hoffentlich an den Ausgängen dann eben
die entsprechende Folge
Durchlaufen wird,
beziehungsweise wenn ich mir jetzt also hier die Werte für meinen Zustandsvektor,
also quasi Kuh ansehe, würde man dann eben auch sehen,
wie das Ganze dann dementsprechend der Reihe nach passend durchlaufen wird.
Gut, in der zweiten Variante werden jetzt die vier Zustände
als ein Drei-Bit-Vector kodiert,
also jetzt quasi nicht minimal binär durchkodiert,
sondern als Drei-Bit-Vector
Wobei man jetzt hier quasi den Trick anwendet, dass man sagt,
na gut, also die Zustandsbits korrespondieren einfach direkt mit den entsprechenden Lampen.
Das heißt, wenn ich in dem Zustand rot bin,
habe ich dann halt hier grünes Licht, gelbes Licht,
rotes Licht, dann dementsprechend das rote Licht an, in rot,
gelb, die beiden, in grün das, in gelb das.
Zusätzlich gibt es dann hier nochmal sowas wie so ein Reset-Zustand. Nicht einfach nur,
um zu sagen, dass man dann natürlich, also dadurch,
dass man jetzt also auch mehr Zustände beschreiben kann,
den Automaten auch noch so ein bisschen aufbauen kann
Der Vorteil mit dieser Kodierung direkt mit den Lampen ist natürlich,
dass also die Ausgangsfunktion, also die ist Landerschallnetz quasi minimal wird,
weil da brauche ich jetzt kein Schaltnetz,
um jetzt also aufgrund des Zustandes irgendwie die Lampen zu dekodieren,
sondern nehme ich jetzt einfach nur das entsprechende Zustandsspitch.
Das heißt, dieses hier wäre dann eben die grüne Lampe,
gelbe Lampe, rote Lampe. Und wenn man das jetzt eben entsprechend nimmt,
sich anguckt bei den Zuständen,
welche Folgezustände habe ich und das dann eben aufbaut,
und minimiert würde man dann eben zu diesem Schaltnetz kommen.
Nicht, was man dann eben entsprechend auch jetzt wieder mit
Hades simulieren könnte. Ich fuhr ich dann also jetzt,
als ich hier mit rot, rot, gelb,
grün, gelb, rot entsprechend durchlaufe.
Und in diesem Fall ist also hier quasi die Dekodierung der Lahmen
einfach direkt dem Zustandsbit entspricht. Ich aber dann natürlich für die Zustandsübergänge,
also jetzt hier entsprechend mehr Logik einsetzen muss, um die dann zu beschreiben.
Das ist dann eben letztendlich immer so ein Trade-off,
also wie viel brauche ich quasi jetzt hier an Aufwand für welches Schaltnetz? Gut,
und als abschließende dritte Variante könnte man jetzt eben auch noch sagen,
ich kodiere das Ganze als so einen sogenannten One-Hot-Vactor, One-Hot-Kodierung,
hatte ich also ja ganz am Anfang auch schon mal kurz vorgestellt,
ist im Prinzip sowas, wo ich dann sage,
entsprechende Anzahl der Zustände brauche ich Jetzt einzelne Bits in meinem Vector und die sind dann eben so aufgebaut, dass ich quasi immer nur ein einzelnes Eins-Bit gesetzt habe.
Alle anderen sind dann eben null. Das heißt,
ich hätte jetzt also hier die entsprechenden Zustände mit ihren Codierungen,
hier dann die zugeordneten Folgezustände und was man jetzt eben sieht,
ist also, dass natürlich also hier Zustand und Folgezustand nichts anderes ist,
als dass quasi hier diese Eins einfach immer nur um ein Bit weitergeschoben wird.
Das heißt, in diesem Fall ist dass die Zustandsübergangsfunktion minimal,
weil das nichts anderes ist, als einfach nur ein Schieberegister bzw. am Ende wird es quasi einmal wieder zurückgeschoben.
Das heißt, da muss ich nichts machen und man hat
es dann eben hier in diesem Fall dann auch noch so, dass die Ausgabefunktion selber auch sehr einfach ist. Das heißt,
hier habe ich jetzt zwar mehr Aufwand,
weil ich jetzt also nicht zwei oder drei,
sondern also in diesem Fall jetzt vier Register aufwenden muss,
nicht aber auf der anderen Seite habe ich dann also hier
keinerlei Aufwand mehr für die Zustandsübergangsfunktion,
sondern dies eine Bit wird einfach immer nur von einem Register
ins nächste geschoben und am Ende dann quasi über diese Leitung dann eben hier wieder in das Erste reingeschoben und die unterschiedlichen Ampelschaltungen lassen sich dann eben hier auch sehr einfach mit zwei oder Gattern entsprechend minimieren und realisieren.
Gut, damit werde ich dann für heute mit den Schaltwerken
Schluss machen.
Ich wünsche ein schönes Wochenende