Digitale Schaltungen Grundlagen

Wir wollen uns in diesem Teil weiteren Klassen der digitalen Schaltungstechnik widmen.
Es geht um speichernde Elemente.
Solche und auch die schon bekannten Elemente sind nicht nur in Rechner vorhanden, sondern auch in täglichen Gebrauchsgütern. Im Jahr 2012 wird (wurde) die analoge Übertragung der Fernsehsignale über Satelit abgeschaltet - dann geht es eben digital.
Auch der Rundfunk wird irgendwann ebenfalls digital werden. Die Komprimierungsverfahren von analogen Signalen wie mp3 oder m4a(v) sind so weit fortgeschritten, dass die notwendige Bandbreite schon eine Übertragung im Mittelwellen und Kurzwellenbereich zulässt. Das ganze bietet dann UKW ähnliche Quallität, in Stereo und zusätzlicher Informationsübertragung - und man kann in ganz Europa im Autoradio immer den gleichen Sender hören (auch außerhalb, aber da kommt man weniger mit dem Auto hin). Diese Technik wird als DRM (Digital Radio Mondaile) bezeichnet
Firmen, wie auch CONRAD, bieten bereits für den Bastler entsprechende Bausätze an,
man braucht dazu:


Kurzwellen-Retroradio zum Selberbauen Best.Nr.: 192214_V0	DRM-Erweiterungsbausatz Best.Nr.: 192243_V0	einen Rechner mit Soundkarte und entsprechender Software.

- es wird höchste Zeit, sich damit zu beschäftigen!

Eine große Gruppe der digitalen Schaltungen entsteht unter Verwendung von speichernden digitalen Elementen (siehe dazu auch Digitaltechnik; "Kleiner Grundlagen-Kurs" bzw. "RS-Flip-Flops"). Sie entstehen bei Rückkopplung des Ausgangs an den Eingang unter dem möglichen Hinzufügen weiterer digitaler Bauelemente. Diese Dinger heißen dann

Latch oder Flip-Flops.

Jeder der schon ein wenig gebastelt hat, weiß, dass Rückkopplungen zum Schwingen des Systems führt.

Das ist das klassische Problem, man kommt mit dem Mikrofon in den Ausstrahlungsbereich des Lautsprechers und schon pfeift es furchterregend! Bei analogen Schaltungen passiert das so, bei digitalen Schaltungen gibt es andere Ergebnisse.

Der Ausgang vom zweiten Gatter wird wieder auf das erste Gatter geführt. Der jeweils andere Eingang wird mittels Taster auf 0 (Masse) gelegt. Wird z.B. Taster x1 betätigt, leuchtet die LED, lässt man den Taster wieder los, leuchtet die LED weiter. Betätigt man hingegen den Taster x2 geht die LED aus und bleibt auch aus wenn man den Taster wieder los lässt - diese Wirkung der Rückkopplung ist schon eigenartig, aber man kann diesen Effekt sehr gut gebrauchen, man kann sagen, die Schaltung würde sich merken, welcher Taster als letztes betätigt wurde, oder auch, die Schaltung würde die letzte Situation speichern. Damit wird nun ein gewaltiger neuer Anwendungsbereich aufgetan.
Das betrifft nicht nur neue Arten von Schaltungen wie Zähler und Teiler, sondern tatsächlich Speicher von Rechnern.

Aus der zunächst schlechten Eigenschaft der ungewollten Rückkopplung wird digital ein neues ganz wichtiges Bauelement - das ist ganz toll! (siehe dazu auch: Kleiner Grundlagen-Kurs" und "RS-Flip-Flops" )

Es hat sich zum vorhergehenden Bild lediglich geändert, dass eine zusätzliche LED eingebaut wurde.
Was passiert?
Nehmen wir einmal an, dass die untere LED leuchtet, die obere nicht, d.h. der Ausgang des unteren NAND ist 1, des oberen 0.
So wie die Schaltung dargestellt ist, liegt an den Eingängen jeweils eine 1 an. Für das obere NAND gilt:

e1 = 1; e2 = 1; 1 AND 1 = 1 -> neg 0

Für das untere NAND gilt:

e1 = 0; e2 = 1; 0 AND 1 = 0 -> neg 1

Es ändert sich nichts an der Schaltung, die LED unten leuchtet, die obere nicht, sie speichert den Wert.
Jetzt wird der Taster x1 betätigt, es wird eine 0 an den Eingang e1 des oberen NAND gelegt. Oben entsteht nun:

0 AND 1 = 0 -> neg 1

Es entsteht also eine 1 am Ausgang, die LED oben leuchtet, aber die 1 hat auch einen Einfluss auf das untere NAND, denn nun gilt hier:

1 AND 1 = 1 -> neg 0

Also die untere LED geht aus.
Lässt man den Taster wieder los, bleibt die Einstellung bestehen, die Schaltung speichert nun diese neue Situation - das ist einfach genial!

Die großen Wissenschaftler der Welt haben sich nun geeinigt, dass grundsätzlich mit 1 geschaltet werden soll. Das lässt sich ganz einfach durch vorschalten von Negatoren an den Eingängen erreichen (als Negatoren werden NANDs mit zwei Eingängen verwendet):

Nun entspricht alles den Regeln. Da man natürlich nicht
immer die ganze Schaltung aufmalen will, gibt es ein Symbol,
welches dieses Bauelement beschreibt.

Man muss genau hinschauen, denn durch wenig Veränderung am Symbol wird ein komplett anderes Bauelement mit komplett anderem Verhalten beschrieben, das wollen wir auch noch untersuchen. Das Bauelement ist ein neues Grundelement und hat nun einen neuen Namen, im amerikanischen Sprachgebrauch:

RS-Latch

im deutschsprachigen Raum

RS-Flip-Flop (die sollen im weiteren Text auch mit FF bezeichnet werden)

Es gibt leider keine Einheitliche Definition, hängt also immer vom Autor ab (man muss es eben nur beachten).

Wie das Bauelement funktioniert wird durch eine Wahrheitstabelle beschrieben. Es werden 4 Bereiche definiert:
(Qa und Qan - alte Ausgangswerte (Zustand); Q und Qn - die sich einstellende Werte)

Speicherbereich:		S = 0; R = 0; die alten Ausgangswerte Qa und Qan werden weiterhin ausgegeben (Q und Qn)
SET:		S = 1; R = 0; unabhängig von den alten Werten Qa und Qan wird am Ausgang Q = 1 und Qn = 0 bereitgestellt
RESET:		S = 0; R = 1; unabhängig von den alten Werten Qa und Qan wird am Ausgang Q = 0 und Qn = 1 bereitgestellt
unerlaubt:		S = 1; R = 1; diese Situation hat keine definierte Ergebnisse zu Folge, man kann die Werte Q und Qn nicht nutzen. Das bedeutet nicht, dass das Bauelement mit dieser Eingangsbelegung zerstört wird, sondern die Ergebnisse dann unbrauchbar sind! In Abhängigkeit der inneren Beschaltung werden auch Werte bereit gestellt, in unserem Fall wird Q = Qn = 1. Das "unerlaubt" steht als Forderung für den Anwender, er muss dafür sorgen, dass diese Eingangswerte nicht auftreten.

An einem Taktdiagramm kann man für verschiedene Eingangssituationen die Reaktion des Bauelementes sehen und die Funktion verstehen:

Es sollen die einzelnen Abschnitte untersucht werden:

t0-t1:		wird in diesem Bereich der Speicher-Zustand festgelegt, so hat man keinen Einfluss auf das Ausgangssignal, denn beim Einschalten des Latch ist auf Grund fertigungsbedingter unterschiedlicher Laufzeiten der Gatter nicht definiert welches Signal sich einstellt.
t1-t2:		das Latch wird in den SET-Zustand versetzt (Q = 1; Qn = 0).
t2-t3:		das ist der Speicher-Zustand, Q und Qn behalten den alten Wert (Q = 1; Qn = 0).
t3-t4:		hier wird der RESET-Zustand eingestellt (Q = 0; Qn = 1)
t4-t5:		da S = R = 0 sind wird gespeichert und die alten Werte (Q = 0; Qn = 1) ausgegeben.
t5-t6:		wieder der SET-Zustand
t6-t7:		das ist nun ein Problem, die Ausgangswerte sind zu 50% falsch, die Belegung ist ja auch unerlaubt, aber es folgt eine richtige Belegung.
t7-t8:		SET; das Ergebnis ist wieder richtig
t8-t9:		speichern
t9-t10:		SET
t10-t11:		unerlaubte Eingangsbelegung
t11-t12:		speichern - das ist nun aber ein ganz großes Problem, denn es ist nicht klar was gespeichert wird!!!

Nun wollen wir mit diesem Grundelement etwas rumexperimentieren und dabei neue Eigenschaften kennenlernen. Zunächst einmal sollen weitere Bauelemente zum Grundelement zugeschaltet werden:

Was soll damit erreicht werden?
Bisher war es so, dass die Änderung am Eingang auch sofort am Ausgang sichtbar wird. Das bereitet bei einigen Anwendungen Schwierigkeiten. Es kann sein, dass der Übergang von S und R nicht schlagartig erfolgt sondern real langsamer. Die Folge daraus ist, dass es Pegel zwischen 0 und 1 gibt, für die das Bauelement nicht definiert ist und somit falsche Ergebnisse bringt, man muss die Einschwingzeit abwarten (sagt der Fachmann). Für diese Leistung eignet sich die eben gezeigte Schaltung. S und R können sich beliebig ändern, wenn aber T = 0 ist, wird an die Eingänge des RS-Latch nichts durchgestellt, hier bleibt am Eingang jeweils eine 0, also haben wir den Speicherfall. Erst wenn an T eine 1 liegt wird der Wert von S und R zum Latch durchgestellt. Das Bauelement wird durch ein neues Symbol dargestellt:

Man sagt dazu:

Takt-Zustands-gesteuertes Latch

Als Unterstützung zum Verstehen der Funktion soll wieder ein Taktdiagramm dargestellt werden. Es sollen wieder die gleichen Folgen für R und S genutzt werden:

Veränderungen im Gegensatz zum RS-Latch geschehen nur wenn T = 1 ist. Das Problem am Ende des Diagramms (ab t11) bleibt bestehen, es ist undefiniert.

Ganz nebenbei haben wir einen elektronischen Schalter kennen gelernt, denn jedes AND funktioniert so:

x AND 1 = x bzw. x AND 0 = 0 (x = 0 / 1)

Wenn der zweite Eingang 0 ist, ist der Schalter geöffnet, es kommt immer 0 heraus. Anders bei T = 1, da wird immer das durchgestellt, was am ersten Eingang anliegt, der Schalter ist geschlossen. Man kann natürlich nicht feststellen, ob die 0 von T = 0 oder dem Wert = 0 kommt.

Jetzt wollen wir eine andere Erweiterung vornehmen, dazu gebrauchen wir ein neues Element:

Das Element soll Impulsglied heißen und wie folgt reagieren:

an den Eingang T wird ein Taktsignal T gelegt
an den Eingang E zu einer beliebigen Zeit ebenfalls ein 1 Signal

Beim normalen AND-Glied erscheint am Ausgang A wenn beide Eingänge 1 sind ebenfalls eine 1 (solange wie beide 1 sind). Jetzt soll aber folgendes passieren (siehe Diagramm):

Der Eingang E ist 1 und wenn sich das Taktsignal von 0 auf 1 ändert (t1) soll die Schaltung eine 1 für eine ganz kurze Zeit ausgeben, einen schmalen Impuls.
Man sagt auch dazu, dass bei ansteigender Flanke ein Impuls erzeugt wird!

Wie das Teil aussieht, wollen wir nicht erarbeiten, als Elektroniker ahnt man, dass hier Kondensatoren umgeladen werden, der Strom zeigt so einen Verlauf.

Das Ding wollen wir nun wie zuvor jeweils vor die Eingänge R und S schalten:

Prinzipiell funktioniert es wie bei der Taktzustands-Steuerung. Da war für die ganze Zeit bei T = 1 eine Änderung des Zustands möglich.
Jetzt wissen wir schon, dass nur noch ein sehr kurzer Augenblick das Signal am Ausgang der Impulsglieder 1 wird. Und die Werte von R und S genau zu diesem Augenblick werden für die Steuerung des Latch benutzt. Man kann also exakt zu einer bestimmten Zeit schalten. Wir wissen dass das genau bei der ansteigenden Flanke des Taktsignals erfolgt. Es gibt ein neues Symbol:

Man bezeichnet das Gebilde als:

RS-Flip-Flop, Steuerung mit ansteigender Flanke

Das Taktsignal wird zu C (Clock) umbenannt. Jetzt gibt es aber auch noch ein zweites Element welches bei abfallender Flanke schaltet. Das Symbol sieht so aus:

Man muss schon exakt hinschauen um zu sehen, dass es nun ein

RS-Flip-Flop, Steuerung mit abfallender Flanke

ist. Als Alternative gibt es auch das Symbol mit ausgefülltem Dreieck (rechts).

Aufgabe1:

Wie sich für diesen Fall das Taktdiagramm ändert, sei bereits eine Aufgabe.

(erst einmal probieren, dann später hier nachsehen)

Die nächste Erweiterung basiert auf der letzten Schaltung. Vor S und R wird ein weiteres AND geschaltet welches den einen Wert jeweils aus dem entgegen gesetzten Ausgang entnimmt:

Speichern		Nehmen wir an, dass Q = 0 und Qn = 1 ist. Die Eingänge J und K haben den Wert 0. Am Ausgang a11 entsteht S = 1 AND 0 = 0 . Dieses Signal kann keine Änderung bewirken. Am Ausgang a12 entsteht R = 0 AND 0 = 0 . Auch dieses Signal kann keine Änderung bewirken, wir haben den Speicherfall.
SET		J soll nun den Wert 1 annehmen, S = 1 AND 1 = 1, das kann schalten. K sei 0, dann wird R = 0 AND 0 = 0. Das RS-Flip-Flop könnte in den SET-Zustand gelangen, geht aber nur wenn C gerade eine ansteigende Flanke hat.
RESET		K = 1 und J = 0, führt in den RESET-Zustand Aufgabe2: Überprüfe diese Aussage! (erst einmal probieren, dann später hier nachsehen)
Kippen		Äußerst interessant wird der Fall J = K = 1. Nehmen wir wieder an, dass Q = 0 und Qn = 1 ist. An a11 stellt sich S = 1 AND 1 = 1, an a12 R = 0 AND 1 = 0 - bei ansteigender Flanke erhalten wir den SET-Zustand. Nun wird an S = 0 AND 1 = 0 und an R = 1 AND 1 = 1 bereitgestellt, mit der nächsten ansteigenden Flanke erhalten wir den RESET-Zustand. Ganz wichtig - die Eingangsbelegung J = K = 1 ist nun erlaubt, sie ändert den Zustand des Flip-Flops in den immer entgegen gesetzten Zustand, der Zustand wird als "kippen" bezeichnet (oder triggern oder toggle (engl. Knebel)).

(Hier gibt es eine Seite, die die Funktion des JK-Flip-Flops simuliert: JK-FF Wie das genau funktioniert wird etwas später beschrieben.)

Die Wahrheitstabelle soll beim Verstehen der Funktion des Bauelementes helfen:

Dafür haben wir wieder ein neues Symbol:

Anders zum Flanken gesteuerten RS-Flip-Flop haben sich die Buchstaben geändert, S wird zu J und R zu K. Das Ding heißt nun:

Flanken gesteuertes JK-Flip-Flop (ansteigende (1. Bild)/abfallende(2. und 3. Bild))

J hat die Bezeichnung "Jump" und K steht für "Kill".
Nun kann man einmal das 1.Symbol wieder als Schaltung auflösen indem nacheinander alle inneren Symbole durch Schaltungen ersetzt werden:

Was auch für dieses Bauelement noch fehlt ist ein Taktdiagramm als Beispiel. Wir nutzen dazu wieder unseren bekannten Fall:

Am Anfang tritt natürlich wieder das Problem auf, dass nicht bekannt ist, in welchen Zustand das Bauelement kommt. Bei t1 wird alles richtig gestellt, es entsteht der SET-Fall. Bei t2 war bisher eine unerlaubte Ansteuerung, jetzt kippen die Ausgänge einfach in den anderen Zustand. Analog wird t3 behandelt.

Leider reicht das noch immer nicht, denn wenn dieses Bauelement eingeschaltet wird stellen sich schaltungsbedingt irgendwelche Zustände ein (siehe oben). Um diese definiert setzen zu können, brauchen wir wieder S und R, diese sollten aber taktunabhängig sein. Dafür kann man sich folgende Schaltung ausdenken:

Wir bauen zusätzlich ein ODER hinter a21 und a22 ein, dann kann das Signal wahlweise von e1 oder e2 kommen. Das ganze ist aber nur eine prinzipielle Lösung, denn wenn gesetzt wird darf kein Taktsignal wirken, d.h. in die C-Leitung muss wieder ein elektronischer Schalter, der von S oder R gesteuert wird. Schaut man sich dazu die Wahrheitstabelle eines realen JK-Flip-Flops, z.B. vom IC 4027, an, kann man das so auch sehen:

Ist S oder R gleich 1, können C, J und K beliebige Werte annehmen (Don't Care), sie haben keinen Einfluss auf das Setzen (3 letzten Zeilen der Tabelle)

Das Teil hat natürlich auch wieder ein Symbol:

Und es ist das Bauelement, was wir vorrangig für den Aufbau von Zählern oder Register gebrauchen. Der große Vorteil dieses Bauelementes ist, dass der Übergang von 0 nach 1 und auch 1 nach 0 immer durch zwei Möglichkeiten erreicht werden kann, durch SET oder RESET aber auch durch kippen. Das macht die Berechnung von größeren Schaltungen einfacher.
Was man aber auch sehen sollte ist, dass durch Beschaltung der Elemente durch weitere logische Elemente, auch selbst weitere Latch, völlig neue Bauelemente entstehen. Da ist noch lange nicht ein Ende zu sehen, jedoch werden sie immer spezieller und für weniger Anwendungen brauchbar, da wird die Industrie kein Bauelement erstellen. Was wir ebenfalls nicht behandelt haben sind D, T und Master-Slave Flip-Flops, da gibt es wieder jede Menge interessante Varianten.

Erst die Nutzung von Flip-Flops macht den Aufbau von Zählern und natürlich auch von Teilern und Registern möglich.

Wir wollen uns zunächst mit Zählern beschäftigen. Gemeint sind nicht der Strom- oder Gas-Zähler, das sind analoge Einrichtungen, funktionieren aber ähnlich:

Es gibt mehrere Scheiben mit Zahlen, alle können sich um eine Achse drehen, so dass im Anzeigefeld fortlaufend andere Zahlen stehen. Nur die erste Scheibe rechts, die mit dem kleinsten Stellenwert, wird angetrieben. Beim Stromzähler durch einen Art Motor, der in Abhängigkeit vom Strombedarf, schneller oder langsamer dreht.
Nach der 9 im Anzeigefeld kommt natürlich wieder die 0. Das ist richtig, wir haben aber einen Übertrag in die nächste Stelle, in das zweite Zahlenrad. Dieses wird beim Übergang von 9 auf 0 beim 1.Zahlenrad genau um eine Zahl weiter gedreht. Die Anzeige wäre nun 010. Wir vermerken:

Es wird Stellenweise gezählt, der Wert wird immer um 1 erhöht (bei den höherwertigen Stellen).

Wo gibt es noch Zähler? Zum Beispiel die Digital-Uhr:

19 : 14 : 37

Je nach dem, wo man beginnt, gibt es eine kleinste Stelle. In diesem Fall sollen das die Sekunden sein. Man könnte das sicher auch mit Zahlenrädern gestalten, wir wollen nun aber hier eine digitale Zählung einsetzen.
Man weiß sofort, dass man 3 Zahlenräder braucht, für Sekunden und Minuten mit den Zahlen von 00 bis 59 und die Stunden von 00 bis 23. Das sind natürlich recht große Räder und auch digital ist das ein erheblicher Aufwand. Der Aufwand wird kleiner, wenn man jede Stelle durch 2 Räder, also insgesamt 6, realisiert.
Die rechte Stelle der Sekunden läuft von 0 bis 9, dann wird die nächste Stelle erhöht, das hat nun sehr viel Ähnlichkeit mit unserem analogen Zähler. Allerdings läuft die nächste Stelle nur zwischen 0 und 5. Die Minuten funktionieren in gleicher Weise. Bei den Stunden gibt es ein Problem, denn die rechte Stelle muss zwei mal von 0 bis 9 laufen
(00 … 09 10 … 19 Uhr) dann aber nur bis 3 und muss danach wieder bei 0 beginnen, die Stelle muss zurück gesetzt werden, was mechanisch nicht ganz einfach ist, elektronisch jedoch leicht.

Also bauen wir "elektronische Zahlenräder"!

Als "Motor" brauchen wir einen Taktgenerator mit genau 1Hz Taktfrequenz. Die Schaltung muss sich aber eine Sekunde lang merken, wo sie gerade war - der Takt kommt, der Wert war 3 also muss daraus 4 werden, war er 9 muss daraus 0 werden und die Schaltung muss einen Übertrag (Impuls = Taktimpuls für die nächste Stelle) bereitstellen. Die einzelnen Stellen müssen den Wert mindest eine Sekunde (die zweite 10sec, die 3. 60sec usw.) speichern - d.h. wir brauchen Speicher-Elemente.
Das sind z.B. Latch und Flip-Flops, die haben wir oben kennengelernt.

Fangen wir mit dem kleinen "Rad" an. Es zählt:

… 5 0 1 2 3 4 5 0 1 2 …

Wir müssen also digital maximal die 5 darstellen, das ist: 101(2) = 1 x 2² + 0 x 2¹ + 1 x 2⁰ (dual).
Man braucht als 3 duale Stellen. Jetzt wird eine Tabelle geschrieben, in der links der momentane Wert und rechts der Zielwert steht:

Richtig ist auch die letzte Zeile, es geht von 5 nach 0
Wir habe schon festgestellt, dass die Stellen den Wert speichern müssen, also ordnen wir die Stellen den Zuständen eines Flip-Flops zu, beschrieben jeweils durch den Ausgang Q.

Nun wird einfach wie bei den unter "Digitale Schaltungen erstellen" verfahren, indem von den 3 neuen Zuständen immer dann, wenn dort eine 1 steht aus den alten Zuständen (links) die Schaltfunktion aufgestellt wird. Das sieht dann so aus:

Der nächste Schritt ist, Vereinfachungen der Gleichungen zu versuchen. Das kann man "per Hand" oder mit Hilfsmittel realisieren, wie z.B. mit dem Karnaugh-Veitch-Verfahren:

Damit haben wir alle notwendigen Funktionen und "müssten" daraus auch eine Schaltung ableiten können!

Wir brauchen noch etwas Wichtiges:

Die "charakteristische Gleichung" eines Flip-Flops

Es heißt oben bewusst "müssten", denn es fehlt noch der Bezug zu den zu verwendenden Flip-Flops! Das kann man für alle bisher erarbeiteten Flip-Flops ableiten, wir wollen es für die JK-Flop-Flops einmal komplett herleiten. Dazu brauchen wir erneut die Wahrheitstabelle des Flip-Flops, allerdings mit der Erweiterung des alten Zustands Q:

Insbesondere für das "Kippen" wird diese Funktion nun ganz genau beschrieben. Wie gehabt, wird nun für Q die Schaltfunktion aufgestellt, d.h. wir tragen die Kombnationen gleich in ein KV-Diagramm ein und versuchen zu vereinfachen.

Wir verallgemeinern noch etwas und sprechen dann von der

"charakteristischen Gleichung" eines JK-Flip-Flops

Das ist der Bezug zum JK-Flip-Flop!

Für die anderen Flip-Flops gibt es natürlich auch charakteristische Gleichungen, die werden in ähnlicher Weise hergeleitet,
Wie aber kommen wir damit weiter? Wir wollen das zunächst an Q1neu durchführen:

Die charakteristische Gleichung wird auf diesen Fall angepasst, x wird zu 1 (Glg.4). Die Schaltfunktion Q1neu wird so umgeordnet, dass Q1 und Q1n jeweils an der gleichen Position stehen wie in der char. Glg. Wenn dass so angeordnet ist (Glg.3) sieht man, dass J1 dem Teil Q2n Q0 entspricht. Analog bei K1, jedoch muss hier noch etwas umgeformt werden. Und man sieht es nicht sofort, aber die beiden Gleichungen (5) und (8) beschreiben die Beschaltung des Flip-Flop 1. Vielleicht noch einmal verbal:

Das Signal am Eingang J wird aus der AND-Verknüpfung vom negierten Ausgang des Flip-Flops2 und Q-Ausgang des Flip-Flops 0 gebildet. K aus einer OR-Verknüpfung von Q0 und Q2

Das kann man aufzeichnen:

Es fehlen nun nur noch die beiden anderen Flip-Flop-Beschaltungen, um die Ausgänge bereitzustellen. Bei FF2 kann man wie eben beschrieben verfahren

Man kann zwar den einen Teil entsprechend umordnen, indem Q0n ausgeklammert wird, aber einen Teil Q0 gibt es nicht?
Und da kommt dann eigentlich eine logische Aussage - aber zunächst doch gewöhnungsbedürftig!
Der Teil mit Q0 ist nicht da, d.b. er muss 0 sein. Damit kann man für Kn einen Wert einsetzen der die AND-Verknüpfung zu 0 werden lässt.
Das geht natürlich nur dann, wenn Kn = 0 ist!
Wenn wir dann die Negation für K aufheben (beide Seiten der Gleichung werden einzeln negiert; die Negation der Negation hebt sich auf), muss 0 negiert werden und damit wird K = 1.
Natürlich gibt es sofort eine neue Frage, was bedeutet K = 1 und wie wird das beschaltet - das ist einfach eine Verbindung zur Betriebsspannung! Nun kann man die komplette Schaltung aufmalen.

Das Ding soll nun immer von 0 bis 5 zählen - ob das so stimmt?

Das Verstehen der Funktion der Schaltung ist vielleicht etwas schwierig. Nur bei ansteigender Flanke werden die 3 FF parallel verändert, d.h. an den Eingängen müssen bereits die notwendigen Signale anliegen. Die FFs ändern sich in den notwendigen Zustand, der sich einstellende Ausgang hat aber keinen Einfluss auf die momentane Änderung. Mit den Ausgangswerten werden nun bereits die J und K-Werte für die nächste Zustandsänderung bereitgestellt aber nicht wirksam, da das nur mit ansteigender Flanke passieren kann.

Eine Kontrolle der Schaltung wäre schon gut. Man kann in einem ersten Schritt eine Wahrheitstabelle aufstellen, etwa so:

Das ist sehr mühevoll, da wie oben beschrieben, immer von den vorhergehenden Q-Werten die Berechnung von den J und K-Werten erfolgen muss. Da kommt man sehr schnell durcheinander und dann geht gar nichts mehr.

Eine andere Variante ist, die Schaltung zu simulieren. Dazu kann man den bereits aus Teil "Digitale Schaltungen selbst erstellen" genannten "DigitalSimulator Version 5.57" nutzen, der kann frei aus dem Netz heruntergeladen werden. Zur Installation und zur Nutzung braucht man Administrator-Rechte. Wenn man zur Nutzung des Simulators nicht Administrator ist, kann man ihn als anderer User, als Administrator starten. Folgendes Erscheinungsbild hat der Simulator:

Im linken Fenster unten kann man eine Bauelemente-Gruppe auswählen, in diesem Fall war das die Gruppe Gatter. Oben links erscheinen dann die vorhandenen Elemente. Die lassen sich zumeist noch modifizieren, also AND mit 5 Eingängen ist möglich. Rechts auf dem Arbeitsblatt wird die Schaltung generiert. Dazu sollte oben der viertletzte Button, das Zahnrad, nicht heruntergedrückt sein.
Zur Generierung zieht man sich zunächst die Bauelemente auf das Arbeitsblatt. Die müssen noch nicht an der richtigen Stelle stehen, die kann man später hinrücken. Die Verbindungen der Elemente untereinander ist ebenfalls recht einfach, man hält am Ausgang des Bauelementes die linke Maustaste fest und zieht zum Eingang des gewünschten Bauelementes. Beim Ziehen gehen die Leitungen z.T. durch die Bauelemente. Lässt man dann los, werden sie besser, können aber noch durch Bauelemente hindurchgehen. Zur Veränderung klickt man die Verbindung an und kann an den Eckpunkten diese verändern. Manchmal geht das nicht, dann muss man das Ziel anders positionieren, im Bild betraf das die beiden rechten Gatter (AND, OR). Als Taktgenerator wird ein einfacher Taster verwendet. Klickt man ihn an, schaltet er kurz nach 1 und sofort wieder zurück, wir haben eine ansteigende Flanke. Man kann auch einen richtigen Generator einsetzen.
Ein Problem gibt es mit Verzweigungen, die gibt es nicht bzw. habe ich noch nicht gefunden, man muss erneut vom Ausgang eine Verbindung ziehen. Damit es dann übersichtlich bleibt, habe ich die Eckpunkte so verlegt, dass die Linien übereinander liegen und dann quasi abzweigen, dann fehlt jedoch der üblichen Punkt.
Ganz positiv ist, dass die Verbindungen blau oder rot dargestellt sind, rot bedeutet 1 und blau 0.
Für den dargestellten Fall (Anzeige 000, Vorbereitung für den Fall 001 - die Reihenfolge der Stellen ist vertauscht, es beginnt mit Q0 links). An FF0 liegt J=K=1 an, das FF kippt bei der nächsten ansteigenden Flanke, FF1 kommt in den Speicherzustand (J=K=0), wie auch gleichfalls FF2. Das ist richtig, denn um von 000 nach 001 zu kommen braucht sich nur die Stelle Q0 zu ändern.

Es wurde aus allen 6 Fällen ein animiertes Gif erstellt (es wackelt etwas, da nicht immer exakt der gleiche Ausschnitt getroffen wurde):

Schaut man sich die Animation genauer an, kann man feststellen, dass J0 und K0 sich nicht verändern, die sind immer rot, also 1. Dann kann man das auch gleich so beschalten

Die Frage ist natürlich, warum das KV-Diagramm nicht dieses Ergebnis bringt?

Schauen wir uns dazu noch einmal die Wahrheitstabelle an.
Wenn man genau hinsieht, sollte auffallen, dass links 2 Kombinationen fehlen, die 6 (110) und 7 (111). Was soll passiert wenn diese Kombination links durch Zufall entsteht, z.B. beim Einschalten. Wir können ja schon festlegen wo es hingehen soll, z.B. von 6 und von 7 nach 0, dann läuft er wie gehabt.

Wir können aber auch sagen, dass es uns egal ist was in diesem Fall passiert, der passiert nicht und wir nutzen die Kombinationen wie es uns am Besten passt. Es soll egal sein ob 1 oder 0, wir schreiben dafür x. Links ist die so entstandene Tabelle zu sehen.

Der Nutzen wird erst richtig sichtbar im KV-Diagramm. Zuerst einmal wollen wir uns Q0neu ansehen:

Wir tragen wie oben dreimal eine 1 ein. Nun kommen aber zusätzlich an Position 6 und 7 die x zum Einsatz. Man nennt die Stellen

Don't care

Setzt man davor noch ein I, dann wird daraus

I don't care (engl.) - ist mir egal (deutsch)

Und genau das wollen wir tun, immer wenn das x passt nutzen wir es als 1, ansonsten lassen wir es weg. Bei Q0 bedeutet das, dass wir das linke x (6) nutzen um mit den 3 Einsen zusammen einen 4-er-Block zu schaffen. Das rechte x (7) lassen wir einfach weg. Das Ergebnis ist, dass die funktionelle Beschreibung für Q0neu sehr kurz wird:

Q0neu = Q0n (Formel steht auch beim KV-Diagramm)

Mit den gleichen Überlegungen wie oben (Teil Q0 fehlt, ist also K0n = 0) erhalten wir:

J0 = 1; K0 = 1

Genauso verfahren wir mit Q1neu:

Die 1 bei Position (2) kann mit dem x (6) zu einer Gruppe zusammengefasst werden, die andere 1 lässt sich nicht mit einem anderen Wert zu einem Block verbinden.

Etwas anders verhält es sich bei Q2neu:

Eigentlich kann man 2 2-er Blöcke bilden. Die obere Formel in dem Kasten gilt. Man sieht es nicht sofort, aber der Teil mit Q2n fehlt (zur Berechnung von J2). Das kann man wieder richtig stellen, indem der erste Teil der Formel mit 1 "erweitert" wird:

Q1 Q0 1 = Q1 Q0 (Q2 v Q2n) = Q1 Q0 Q2 v Q1 Q0 Q2n

Jetzt ist auch Q2n vorhanden, das neu entstandene Q2 muss mit dem zweiten Teil der Formel zusammengefasst werden:

Q2neu = Q1 Q0 Q2n v (Q1 Q0 v Q0n) Q2

Eine andere Variante um Q2n zu erzeugen verlangt eine größere Erfahrung beim Umgang mit solchen Problemen. Man bildet den rechten Block aus x (7) und 1 (3) nicht, sondern nimmt die 1 ohne Vereinfachung. Da diese 1 nicht in Q2 liegt, erhalten wir nun doch wieder Q2n (untere Formel im Kasten).
Die wichtigste Erkenntnis ist, dass wir 3 verschiedenen Formeln zur Darstellung des gleichen Sachverhaltes haben. Ob die nun auch wirklich gleich sind, kann man herausfinden, indem wie im Teil 1 der "Digitalen Schaltungen" von allen die KDNF (Kanonisch Disjunktive Normal-Form) gebildet wird und diese gleich sind. Man kann natürlich alle Varianten im oben genannten Simulator probieren, sie sollten gleich funktionieren.

Hier nun die Formeln und die berechneten J- und K-Werte:

Und damit gibt es dann auch wieder eine Schaltung:

Man kann es nicht leugnen, die ist die bisher kleinste Schaltung für unseren Zähler. Man sollte also immer versuchen, ob Vereinfachungen möglich sind. Zur ersten Schaltung haben wir immerhin 3 OR-Gatter und eine Reihe von Leitungen eingespart!
Aber wie es so in der Natur ist, bekommt man Nichts umsonst, irgendwo gibt es andere Probleme.
Bei uns ist das eine fehlerhafte Anfangsbelegung z.B. mit 6 (110) oder 7 (111), die Schaltung arbeit natürlich damit auch. Der schlimmste Fall der uns passieren könnte, wäre, dass diese vereinfachte Schaltung von z.B. 6 (110) wieder auf 6 (110) führen würde, Der Zähler würde auf der Stelle stehen bleiben!
Dem Problem kann man auf zweierlei Arten begegnen. Man organisiert eine Anfangsbelegung beim Einschalten, die die Schaltung beispielsweise auf 0 führt (oder anderen Wert außer 6 oder 7). Die andere Möglichkeit ist, man probiert z.B. am Simulator aus was passiert. In diesem Fall passiert folgendes:

6 (110) führt zu 7 (111) und
7 (111) führt zu 0 (000)

Danach ist der Zähler im richtigen Zählmodus. Es gibt beim Einschalten maximal 2 fehlerhafte Ergebnisse, dann ist alles ok und der Zähler läuft sich nicht fest! Wenn diese möglichen Fehler den Gesamtablauf der vielleicht größeren Schaltung nicht stören, können wir alles so lassen! Das Setzen von Anfangswerten verlangt natürlich JK-FFs mit zusätzlichem R und S Eingang.

Fazit:

Wir haben richtig gerechnet und können uns einer weiteren Zählstelle widmen.

Eine andere Art der Simulation kann man sich selbst schaffen, wenn man programmieren kann. Sehr günstig eignet sich dazu C++ (oder auch andere objektorientierten Sprachen). Es geht damit leichter, aber auch Programmierung unter C wäre möglich, die Sprache sollte dann über den Datentyp "Array" verfügen.
Bei C++ erstellt man sich eine Klasse "jk-ff". Als Eingabe gibt es j und k und als Rückgabewert q. Aus der Klasse werden 3 Objekte FF generiert. Das tolle ist, dass jedes Objekt auch seinen Zustand selbst hütet, man braucht nicht wie unter C die Zustände in einem extra Array verwalten.
Auch für die Gatter könnte man solche Klassen schaffen. Das macht aber keinen Sinn, da diese Elemente nicht Speichern. Man schafft sich einfach eine entsprechende Funktion, mit Funktionen wird es übersichtlicher.

z.B. AND:

fkt AND(Par1,Par2)
intern funktioniert sie wie unser Bauelement: erg=Par1 and Par2
über den Namen AND wird das Ergebnis dann bereitgestellt.

Die Programmierung ist dann nur noch ein fortlaufendes Aufrufen der Objekte und Funktionen:

Q0=FF0(1,1)
J1=AND(Q2n,Q0)
K1=OR(Q2,Q0)
Q1=FF1(J1,K1)
J2=AND(Q1,Q0)
K2=OR(Q1,Q0)
Q2=FF2(J2,K2)
Q2n=NOT(Q2)
Anzeige Q0,Q1,Q2

Die Schreibweise entspricht nur symbolisch einer Programmiersprache, soll nur das Prinzip zeigen. Der aufmerksame Beobachter wird sofort ein Problem sehen, denn z.B. kann in der zweiten Zeile J1 nicht berechnet werden, da Q2 ja noch nicht bekannt ist - das stimmt nicht!
Die Schaltung arbeitet immer mit den bereits eingestellten Zuständen (Q-Werte) der FFs, die dürfen in der Berechnung nicht verändert werden, erst wenn die neuen J und K-Werte berechnet sind, werden mit den FFs die neuen Q-Werte berechnet. Unser Programm muss eine andere Reihenfolge haben:

Q2n=NOT(Q2)
J1=AND(Q2n,Q0)
K1=OR(Q2,Q0)
J2=AND(Q1,Q0)
K2=OR(Q1,Q0)
Q0=FF0(1,1)
Q1=FF1(J1,K1)
Q2=FF2(J2,K2)
Anzeige Q0,Q1,Q2

Ein anderes völlig unerwartetes Mittel zur Kontrolle bietet das Internet - sofern man den Zugang zu einem Server hat, dynamische Seiten erstellen kann und wieder eine Programmiersprache wie z.B. php nutzen kann.
Das sind drei Kriterien, die sicherlich nur Wenige erfüllen können. Den ersten Teil kann man umgehen, indem man sich auf seinen Rechner einen eigenen WWW-Server installiert. Ein solches Teil ist z.B. "xampp". Da erhält man sofort einen WWW-Apache-Server mit php-Interpreter und wer will auch eine MySQL-Datenbank. Was aber bleibt, ist das programmieren dynamischer WWW-Seiten. Hier helfen auch keine WWW-Baukästen, hier muss man auf Befehle von php und dem html-Format herunter steigen.
Eine sehr ungewöhnliche Art der Nutzung der dynamischen Seite ist, dass die Seite sich selbst aufruft. Das hat nichts mit der Rekursion von normalen Programmiersprachen zu tun, richtig ist, es wird der Server angewiesen eine WWW-Seite bereitzustellen, dass das nun zufällig die gleiche ist, die der Browser schon hat, spielt keine Rolle, es ist generell eine "andere" Seite. Das hat aber genau die Konsequenz, dass Nichts im Programm der Seite zu speichern ist - geht so nicht. Man kann lediglich Parameter mit zum Aufruf schicken oder Daten in einer externen Datei speichern und dann wieder lesen. Das mit den Parametern ist gut, da wir über diesen Weg z.B. die 3 Q-Werte der nächsten Seite mitteilen und diese zur Berechnung der neuen J und K-Werte nutzen. Ist das geschehen werden die Q-Werte berechnet und mit diesen wieder die Seite aufgerufen. Als erstes jedoch sollte man auf der Seite die Q-Werte darstellen, oder man tut es gleich nach der Berechnung vor dem Aufruf.
Im folgenden Bild soll noch einmal die php-Nutzung im WWW dargestellt werden:

Hier gibt es eine bessere Beschreibung der Variante anhand des Programms zur Simulation des Zählers.

Im WWW ist immer die Frage nach der Sicherheit zu stellen. In der Seite jk_t1.php stehen in diesen Fall zwar keine geheimen Dinge, aber wenn doch, dann werden sie nicht im Netz übertragen, sondern durch den Interpreter im Server bearbeitet, daraus html-Code erzeugt (dafür ist der Hersteller verantwortlich) und dieser wieder dem Browser zugeschickt. Durch das Netzt läuft also nur das Ergebnis der Bearbeitung.
Diese Arbeitsweise ist nicht nur nachteilig, sondern es kann, sofern man die Datei auf einem öffentlichen Server unterbringt, die ganze Welt das Beispiel sehen und auch nutzen!

Man kann das Beispiel nachvollziehen, indem einfach die Adresse und Seite :

Zähler von 0 bis 6 (Variante1: ohne Don't Care)
Zähler von 0 bis 6 (Variante2: mit Don't Care)

im Browser angegeben wird, schon sollte es funktionieren. In der Adresszeile kann man die Parameter sehen.

Nun haben wir einen Zähler bereit gestellt. Da alle Speicher-Glieder (FFs) zur gleichen Zeit Ihren Zustand ändern, spricht man von einem

"synchronen Zähler".

Damit ist angedeutet, es gibt auch nicht synchrone Zähler, man spricht von

"asynchronen Zählern".

Der entscheidende Unterschied ist also, dass die Speicherglieder nacheinander in den neuen Zustand schalten, der Ausgang des Vorgängers ist das Taktsignal für das aktuelle Speicher-Element. Das richtige Ausgangssignal der gesamten Einrichtung stellt sich nach und nach ein. Ihr Vorteil ist, dass sie zumeist mit weniger zusätzlichen Gattern auskommen, nachteilig ist, es gibt nicht solche eindeutigen Berechnungsmethoden.

Nehmen wir 3 JK-FFs, dann kann man von 0 bis 7 zählen, danach fängt die Schaltung wieder von 0 an. Die Schaltung dazu sieht wie folgt aus:

Es wird mit abfallender Flanke getaktet. Die Schaltung wird mit "setzbaren" FFs aufgebaut. Man sieht auch, dass Q0 der Eingang für das zweite Gatter ist und Q1 für das dritte Gatter. Hier wurde der S auf 0 gelegt, R soll zwischen 0 und 1 geschaltet werden können (bei Schalter sind Pull-Down-Widerstände erforderlich!), es kann also nur zwischen Speichern und RESET umgeschaltet werden. J und K werden bei allen FFs mit 1 belegt, damit gelangen sie in den Kipp-Modus, der Zustand der FFs kippt bei jeder abfallenden Flanke in den entgegen gesetzten Zustand.

Das Taktdiagramm kann weitere Hinweise zur Funktion geben.

Zum Zeitpunkt t0 werden mit abfallender Flanke alle drei FFs auf 0 (000) gesetzt, danach werden entsprechend der dualen Zahlen alle Werte bis 7 (111) durchlaufen usw.

Wie soll aber nun nur bis zu einem bestimmten Wert z.B. 5 gezählt werden?

Das Grundprinzip ist:

Man baut einfach Dual-Zähler auf, die dann an einer gewünschten Bit-Kombination zurückgesetzt werden, die FFs werden alle auf 0 gesetzt.
Dann beginnt die Abarbeitung wieder von vorn.

Alle FFs befinden sich im Kipp-Modus (J=K=1).
Also bei unserem Zähler muss festgestellt werden, dass der Wert 6 falsch ist und der Zähler sofort wieder auf 0 gesetzt werden muss. Eine Frage kann man in der Elektronik schlecht stellen, aber man kann genau den Fall feststellen,

wenn Q0=0 und Q1=1 und Q2=1

ist, dann muss zurück gesetzt werden, das erfüllt genau wieder ein AND-Gatter:

Q0 wird negiert, d.h. wenn der Wert 6 (110) ist, sind alle Eingänge von AND-Gatter 1, somit ist das Ergebnis auch 1. Diese 1 wird über OR-Gatter an alle RESET-Eingänge gelegt. Da S=0 erfolgt das Rücksetzen. Das OR-Gatter wurde nur eingebaut um zu zeigen, dass die Schaltung auch per Hand zurück gesetzt werden kann.

Auch hier das Taktdiagramm dazu.

Und es werden dann auch Probleme der Schaltung sichtbar. Das AND-Gatter kann ja erst reagieren, wenn der falsche Wert vorhanden ist. Das AND-Gatter und die FFs brauchen aber auch eine kleine Zeit um die 1 zu erzeugen und die FFs umzukippen, d.h. in dieser Zeit steht eventuell ein falscher Wert am Ausgang eines FF und trägt zu einem insgesamt falschen Ergebnis bei.
Bei unserem Beispiel gibt es bei Q0 kein Problem, denn der Wert war ohnehin schon 0. Anders dagegen Q1, der Wert wird auf 1 gesetzt, muss aber sofort wieder auf 0 zurück (Prb.1). Das Ergebnis kann sein, dass Nadel-Impulse entstehen und ins System übertragen werden - das kann arge Probleme bereiten. Man braucht weitere Schaltungen um diese Dinger unwirksam zu machen.
Q2 ist nicht ganz so kritisch, der alte Wert war 1 und das FF bleibt etwas länger auf diesen Wert, wird dann auch verzögert auf 0 gesetzt (Prb.2).

Die Darstellung ist natürlich nur schematisch zu verstehen, sicher ist das ein frequenzabhängiges Problem, denn nähern wir uns mit der Takt-Frequenz der Laufzeit der Gatter, wird das Problem immer wirksamer.
Die Gatter schalten etwa in 200ns um. Da alles hintereinander erfolgt, nehmen wir etwa 500ns für den gesamten Rücksetzvorgang an, d.b. das sind etwa 2Mhz, bei der Taktfrequenz würde es sicher Probleme mit der Schaltung geben!

Noch einmal ein kompletter Dual-Zähler

Wir wollen die gleichen Anfangsbedingungen wie oben setzen(<t0 111), aber mit ansteigender Flanke schalten. Das Taktdiagramm sieht dann wie folgt aus:

Unten wurden die sich einstellenden Dezimalwerte aufgeschrieben – die Einrichtung zählt nun von 7 nach 0 und wieder von 7 usw. Man bezeichnet diesen Zähler als
Rückwärtszähler.
Die Schaltung des Rückwertszählers ist mit der vorhergehenden Schaltung, die wir nun als
Vorwärtszähler
bezeichnen wollen, identisch, wir brauchen lediglich FFs mit ansteigender Flanke!
Natürlich wäre auch ein Rückwärtszähler von 5 bis 0, 5 usw. möglich. Hinter 0 muss 5 kommen, eingestellt wird aber 7, also muss man die 7 abfragen und die FFs auf 5 setzen (101; 1. und 3. FF mit SET auf 1, 2. FF mit RESET auf 0.

Aufgabe3:

Die Schaltung für einen asynchronen Rückwärtszähler von 5, …,0,5, … ist zu entwickeln!

(erst einmal probieren, dann später hier nachsehen)

Auch Zähler die von einem Anfangswert x bis zu einer bestimmten Zahl y zählen, ist möglich, z.B. … ,1,2,3,4,1,2,3,4, …
Asynchron geht das wie folgt:
Es handelt sich um einen Vorwärtszähler von 1 bis 4, der Anfangswert wird durch Setzen eingestellt, der Endwert wird durch Gatter abgefragt und wieder auf den Anfangswert gesetzt.
1 (001) wird durch FF0 SET (Q0=1), FF1 und FF2 RESET (Q1, Q2=0), die Ende-Abfrage erfolgt bei 5 (101); vorwärts Zählen wird mit FFs mit abfallender Flanke erreicht.

Synchron
geht das natürlich auch, es wird eine Tabelle gebraucht:

Es gibt wieder 3 Gleichungen zur Bestimmung von den J und K-Werten und damit eine Schaltung.
Berechnet werden:

J0 = (Q2n AND Q1) OR (Q2 AND Q1n);	K0 = 1
J1 = Q2n AND Q0;	K1 = Q2 OR Q0
J2 = Q1 AND Q0;	K2 = 1

Aufgabe:

Die Schaltung für diesen Zähler ist aufzuzeichnen!

(Frequenzteiler)

Das sind Schaltungen die eine Frequenz einer digitalen Einrichtung auf eine bestimmte andere Frequenz heruntersetzen.

Damit ist nicht gemeint, dass tatsächlich die Frequenz immer genau halbiert wird, sondern auch jede andere kleinere Frequenz. Im Prinzip haben wir solche Schaltungen schon beschrieben, denn unsere Zähler sind gleichzeitig auch Teiler.

Beginnen wir mit den Asynchronen Teilern, hier dazu eine Schaltung:

Alle FFs befinden sich im Kipp-Modus. Es soll die Taktfrequenz auf 1/6 heruntergesetzt werden, z.B. von 6GHz auf 1GHz. Solche Baugruppen braucht man im Rechner, da nicht alle Baugruppen des Rechners mit der hohen Taktfrequenz des Generators arbeiten können.
Es interessiert nur noch das Signal Q2, die anderen Signale bleiben intern. Wir nehmen wieder unseren Zähler von 0 bis 5, das sind aber genau 6 Takte, also nach 6 Takten soll Q2 genau einen Takt ausgeführt haben.

Was ist ein Takt?

Ein Takt ist dann abgelaufen, wenn das Signal genau wieder den Anfangswert erreicht hat, er beginnt bei t0 mit 0, wird dann bei t1 1 und dann bei t2 wieder 0, der Wert hat seinen Ausgangswert wieder erreicht – oder das Signal muss mit einer Richtung den Wert ändern und mit einer entgegen gesetzten Richtung wieder den ersten Wert annehmen. Dabei ist es egal, wo begonnen wird.

Sehen wir uns dazu noch einmal das Taktdiagramm an:

Oben bei T sind die Takte bezeichnet, 12 mal ändert sich die Richtung, also 6 Takte. Q2 ändert in der Zeit 2 mal die Richtung, also genau ein Takt. Das Dumme ist, dass das Signal nicht symmetrisch ist. Nach Definition ist es ein Takt und das Signal hat nur 1/6 der Eingangsfrequenz vom Signal T. Man sagt:

Das ist ein Teiler 6 : 1 (6 zu 1) mit einem 0 zu 1 Verhältnis von 4 zu 2 bzw. 2 zu 1.

Solchen Teiler sind durchaus ausreichend, man kann hieraus auch wieder ein symmetrisches Teilerverhältnis von
12 : 1 schaffen.

Das wollen wir an einem Beispiel demonstrieren, indem wir einen Teiler 3 : 1 schaffen und das Ausgangssignal dann wieder 2 : 1 teilen, also insgesamt 6 : 1!

Der Unterschied zum vorhergehenden Beispiel ist gering, es fehlt ein Negator und das AND-Gatter hat nur 2 Eingänge.
Wir zählen mit den beiden ersten Gattern von 0,1,2, bei 3 werden die beiden FFs wieder auf 0 gesetzt. Das FF2 kippt angesteuert durch das Signal Q1 bei jeder abfallenden Flanke um, das Signal wird noch einmal geteilt.

Das Taktdiagramm kann weitere Erklärung leisten:

Q0 ist ein „unsauberes“ Signal, es treten Spitzen auf. Q1 sieht ordentlich aus, es zeigt aber auch zugleich ein Problem, ungerade Teilerverhältnisse, hier 3 : 1 können nur ein unsymmetrisches Verhältnis von 0 zu 1 aufzeigen. Symmetrisch würde bedeuten, dass Q1 einmal mit ansteigender Flanke und einmal mit abfallender Flanke schalten müsste –
das geht nicht!
Aber man sieht auch, dass am Ende wieder ein völlig symmetrisches Signal entsteht, denn es wird immer mit abfallender Flanke geschaltet, ob dazwischen nun ein ganz kurzer Impuls oder ein langes Signal liegt, spielt keine Rolle, das Signal muss abfallen und das geht nun mal nur, wenn zuvor irgendwann das Signal ansteigend war.

Nun das ganze synchron.

Das geht auch recht einfach, man muss eine Tabelle aufstellen, in der 6 Zustände vorhanden sind und Q-Ausgang hintereinander dreimal 1 und dreimal 0 zeigt:

Das funktioniert wenn nicht fortlaufend gezählt wird, von 2 geht es nicht nach 3 sondern 4 (100). Damit haben wir bei Q2 schon mal eine 1. Die beiden folgenden, 5 (101) und 6 (110) bringen die weiteren beiden 1 Werte. Danach kommt eine 0 und am Anfang zwei weitere 0, damit sollte es klappen. Mit der unter synchronen Zählern beschriebenen Methode lassen sich nun wieder Gleichungen für die J und K-Werte aufstellen:

Die sehen relativ einfach aus und damit entsteht auch eine einfache Schaltung

(das kann man unter Teiler 6:1 syn. testen)

Bei T wird das zu teilende Signal eingespeist und bei Q2 das Signal mit 1/6 der Frequenz entnommen. Q0 und Q1 sind nur für den inneren Ablauf des Zählers notwendig.
Nun kann man sich dazu auch noch das Taktdiagramm ansehen:

Aber es geht noch mehr.
Es sind von 0 bis 7 vier Zahlen die vorne eine 0 (0,1,2,3) und vier Zahlen die vorne eine 1 (4,5,6,7) haben (Q2 war das). Um einen 6 : 1 Teiler zu erzeugen braucht man 3 von beiden Gruppen. Wir hatten:

0,1,2, 4,5,6, 0 …

Das muss nicht so sein. Es geht auch:

0,2,3, 4,5,7, 0, …

Nun kann man wild kombinieren: 4 links mit 4 rechts, links z.B.:

0,1,2 oder 1,2,3 oder 0,2,3 oder 0,1,3

Es kommt noch schlimmer, die Reihenfolge ist nicht notwendig:

0,3,1 7,4,6

geht auch!

Beim genauen Hinsehen stellt man fest, dass nun auch Q0 als Teiler-Ausgang 6 : 1 genutzt werden könnte und Q1 stellt ein Signal im Verhältnis 2 : 1 zum Taktsignal bereit.
Die Schaltung ist gar nicht so viel aufwendiger.

(das kann man unter Teiler 6:1 syn.2 testen)

Der Mehraufwand besteht in einem Gatter, es geht aber. Dass an Q1 ein Verhältnis von 2 : 1 herauskommt ist sofort deutlich, den dieses FF wird nur im Kipp-Modus betrieben.
Und nun kann man auch noch Don't Care-Elemente für 2 und 5 nutzen!
Was gut ist, ist Erfahrungssache und muss man probieren, man kann vielleicht irgendwo Bauelemente sparen oder nur AND oder OR verwenden - da hilft nur probieren, bzw. erstmal simulieren.
Damit könnte man nun eigentlich zufrieden sein, aber wir haben uns bisher nur auf eine Gruppe Flip-Flops konzentriert, auf JK-FFs. Es gibt aber auch RS und D-Flip-Flops und damit lassen sich auch Zähler aufbauen, alle haben auch eine charakteristische Gleichung, allerdings sind die Möglichkeiten etwas geringer als die der JK-FFs, damit könnten die Schaltungen etwas aufwendiger werden. Das hängt aber vom zu lösenden Problem ab.
Diese FFs wollen wir nicht mehr nutzen und uns einer anderen Art der Zusammenschaltung von FFs widmen, den

Schiebe -

Register sind Speicher (meist in linearer Struktur). Als Speicherelemente werden FFs verwendet.
Bevor es so richtig los geht, wollen wir noch einen synchronen Zähler herstellen. Er soll wie folgt zählen:

… 8, 1, 2, 4, 8, 1, …

Die Wahrheitstabelle (Zustandsübergangstabelle) sieht dann wie folgt aus:

Zunächst sehen wir sofort, dass wir nicht mehr mit 3 Stellen auskommen (8 = 1000). Mit 4 Stellen gibt es 16 verschiedenen Kombinationen, davon haben wir gerade mal 4 benutzt. Das bedeutet nun, dass wir an 12 Stellen Don't Care einsetzen können, da sollte dann viel vereinfacht werden können.

Mit Don't Care sieht die Tabelle dann so aus.

Zunächst sollte man ein KV-Diagramm erstellen in dem nur alle Don't Care eingetragen sind. Die Anordnung der Zeilen und Spalten entspricht der Darstellung im Teil " Digitale Schaltungen selbst erstellen " . Diese Anordnung kann man für alle 4 Fälle zunächst übernehmen:
Dann sind noch die 1 Stellen einzutragen und das ist nur eine pro neuer Ausgangsgröße Q. Im Folgenden wurden alle 4 Diagramme aufgestellt und man sieht sofort, dass sehr große Blöcke mit 8 Stellen gebildet werden können. Man muss das natürlich erst sehen, auch wenn 7 von den 8 Stellen Don't Care sind, sollte man immer die größte Variante nutzen.

Das Ergebnis ist zunächst auch etwas schwierig, da in keinem Block die gewünschte Größe enthalten ist, z.B. Q1neu = Q0. Da kann man sich natürlich helfen indem der Wert mit 1 und dann mit der fehlenden Größe erweitert wird (unten z.B. Q3 mit Q0 und Q0neg). Dann kann man den Vergleich mit der charakteristischen Gleichung durchführen und erhält in allen Fällen für J und K keine logischen Funktionen, sondern nur den Ausgang des Vorgänger FF.
Damit ist die Schaltung dann auch ganz einfach:

(das simulierte Beispiel: r_schieb_li )

Wenn man das startet, ist man enttäuscht, es passiert Nichts!

Entweder ist das Programm falsch oder die simulierten Formeln falsch oder man macht einen Fehler?
Im Prinzip trifft alles nicht zu, es ist alles richtig, wir haben leider ein Startproblem. Wie oben bereits beschrieben, hat die Don't Care-Nutzung das Problem, dass man nicht weiß, was beim Aufruf dieser Kombinationen geschieht. Da keine Parameter beim Start vorhanden sind, werden alle Q's auf 0 gesetzt und die Kombination (0000) führt offensichtlich wieder auf 0000, der Zähler hat sich "festgelaufen". Wir müssen also einmal einen definierten Wert setzen. Das Simulationssystem hat nicht die Möglichkeit R und S der FFs zu setzen, man kann aber die Q's als Parameter verändern. Der komplette Aufruf des Simulationsprogramm sieht beim zweiten mal so aus:

www.u-r-rennert.de/dig/r_schieb_li.php?q0=0&q1=0&q2=0&q3=0

Und jetzt ändern wir … &q3=0 zu …&q3=1
Mit "Enter" danach kommt nun doch was sinnvolles raus (danach weiter mit "ok-Bottom").

www.u-r-rennert.de/dig/r_schieb_li.php?q0=0&q1=0&q2=0&q3=1

Das animierte Gif zeigt, wie es funktioniert:

Das Bit Q0 landet beim zweiten Aufruf in Q1, dann in Q2 und danach in Q3. Danach erscheint das Bit wieder in Q0. Es sieht so aus als wenn das Bit durch die Schaltung "geschoben" wird, so zu sagen im Kreis, man nennt diese Anordnung deshalb "Ringschiebe-Register". Und da von den niederen Stellenwerten zu den höheren geschoben wird und üblicher Weise links der größte Stellen-Wert steht, spricht man von einer "Linksverschiebung".
Nun kann man die Simulation noch einmal verändern, indem folgende Parameter eingetragen werden:

www.u-r-rennert.de/dig/r_schieb_li.php?q0=1&q1=0&q2=0&q3=1

Jetzt werden 2 Bits durch die Schaltung geschoben:

0011 > 0110 > 1100 > 1001

Die Schaltung ist offensichtlich nicht nur für die vereinbarte Wertefolge funktionsfähig, sondern kann eine beliebige Bit-Folge durchschieben. Das kann man auch mit den anderen Bitfolgen probieren, das funktioniert. Wir haben mit dem Bearbeitungsschema eine Basisschaltung geschaffen, die für weitere Anwendungsfälle geeignet ist.
Und man kann nun annehmen, dass der erste Test auch richtig war, wir haben eine Null (bzw. mehrere Nullen) weiter geschoben - die sieht man natürlich nicht und es macht auch keinen Sinn!

Nun wollen wir die Schaltung noch etwas modifizieren:

Es gibt zur vorhergehenden Schaltung drei wesentliche Änderungen:

Als FF werden ersetzt durch solche die auch über S und R-Eingänge verfügen und diese durch Taster gesteuert
Die Rückführung des Signals von FF3 (Q3, Q3n) nach FF0 (J0, K0) wurde aufgehoben
Das Eingangssignal für J0 wird durch einen Taster bereitgestellt, K0 entsteht aus der Negation von J0

Die Taster sollen nur die Funktion darstellen, könnten sonst auch Leitungen sein (dann fallen die Widerstände weg). Jetzt kann man die FFs setzen, z.B. S0=1, S1=1 die anderen sollen 0 sein. Somit sollte an den Q-Ausgängen nun 0011 erscheinen. Kommt jetzt eine ansteigende Flanke vom Takt wird das Signal nach links geschoben, es erscheint an den Ausgängen 0110. Q0 wird zu 0, da S0=0 und R0=1 ist.
Der Dezimalwert der ersten Ausgabe war 3, der der zweiten 6. Schieben wir noch einmal geschoben, entsteht 12. Also jedes Schieben um eine Stelle nach links bedeutet Multiplikation mit 2 (solange alle Bits vorhanden bleiben). Wird noch einmal geschoben, geht das erste Bit verloren, es entsteht 1000 also 8. Ein weiteres Schieben erzeugt an allen Q's 0.
Die Anordnung wird als "Schieberegister" bezeichnet.
Wir haben so etwa einen Speicher, genauer Akku, für unseren 4-Bit-Prozessor erzeugt, anstelle vom Befehl SLR könnte der Akku nun den Befehl SRR realisieren. Die Taster TR und TS sind Leitungen zum Datenbus des Prozessors.
Aber unsere Schaltung kann noch mehr. Würde man die 4 Bit vom Bus seriell über den Taster Tein bereitstellen, so erscheit die Bitfolge nach 4 Takten (T und Tein laufen synchron) wieder parallel an den Q-Ausgängen, wir haben einen Seriell-Parallel-Wandler (natürlich sehr vereinfacht).
Das ist denn doch sehr erstaunlich, wie aus dem einfachen Flip-Flop ein ordentlich funktionierender Speicher (Register) für 4 Bit entsteht.
Um auch ein Schieben nach rechts zu ermöglichen, muss das Register etwas umgebaut werden. Das könnte man natürlich auch berechnen, aber man sieht hier auch sofort die Wirkungsweise:

Nach links: FF0-Signal nach FF1; … FF3 nach FF3, …

Nun muss die Reihenfolge getauscht werden:

Nach rechts: FF3-Signal nach FF2, … FF1 nach FF0, …

Die Schaltung sieht dann so aus:

Kombiniert man Diese Schaltung mit der vorhergehenden (man kann entsprechend eines Umschalters links oder rechts schieben), entsteht ein universelles Schieberegister, was in ähnlicher Form in jedem Rechner vorhanden ist.

Wir haben nun einen Speicher (Register), in den wir parallel etwas einspeichern und wieder lesen können, aber auch seriell ein und ausgeben können.
Zumeist besteht auch die Möglichkeit, sofern es sich um den Akku handelt, auch eine Verbindung zum Carry-Flag zu schaffen, d.h. der Inhalt der höherwertigsten Speicherstelle wird ins Carry geschoben. In der Folge läßt sich dann gut Auswerten, ob es eine 1 oder 0 war und daraus eine Entscheidung für den weiteren Programmablauf gewinnen.
Eine tiefergründige Beschreibung findet man z.B. beim 4-Bit-Prozessor ERNA.

Übrigens, nach rechts schieben bedeutet Division durch 2, z.B. 8 / 2 = 4 stimmt, denn 1000 einmal rechts ist 0100, eben 4. Oder 11 / 2 = ?. 1011 rechts 0101 = 5, es wird ganzzahlig geteilt!

zurück zur Start-Seite