
Sequenzielle Logik bezeichnet einen Bereich der Digitaltechnik, bei dem der Ausgang nicht nur vom aktuellen Eingang, sondern auch vom vorherigen Zustand abhängt, d.h. sequenzielle Schaltungen besitzen ein Gedächtnis. Die Unterschiede zur kombinatorischen Logik sind in der folgenden Tabelle aufgelistet:
| Kombinatorische Logik | Sequenzielle Logik |
|---|---|
| Ausgang hängt nur von den aktuellen Eingängen ab | Ausgang hängt von Eingängen + vergangenem Zustand ab |
| Kein Speicher | Enthält Flipflops, Latches oder Register als Speicher |
| Beispiel: AND, OR, XOR, Decoder | Beispiel: RS-Flipflop, Zähler, Register, Zustandsautomaten |
Sequenzielle Logik verwendet meist Speicherbausteine wie:
Flip-Flops (D, T, JK, RS)
Register (mehrere Flip-Flops)
Zähler (auf- oder abwärts)
Diese Bausteine speichern ein Bit oder mehrere Bits über einen Takt hinweg. Viele sequenzielle Schaltungen sind getaktet, d. h. sie ändern ihren Zustand nur bei steigenden oder fallenden Taktflanken. Dadurch wird das System vorhersagbar und stabil.
Zähler sind ein wichtiger Teil der Digitaltechnik. Man kann sie zum Beispiel benutzen, um Stückzahlen zu zählen, die Umdrehungen eines Motors oder eine Zeiteinheit zu messen. Die Impulse zur Ansteuerung des Zählers liefert eine Zeitbasis oder unterschiedliche Sensoren. Die Zählfunktion, also das Addieren und Subtrahieren (immer 1) und das Speichern, kann man mit Flipflops realisieren. Die gezählten Impulse erscheinen an einem Parallelausgang. Wie viele Flipflops du brauchst, hängt davon ab, wie viele Zähler man haben will.
Bei einem Asynchronzähler wird der Takt nur dem ersten Flipflop zugeführt. Die nachfolgenden Stufen werden jeweils von der Vorstufe gesteuert.
Im folgenden Bild wurden zum Aufbau eines Vorwärtszählers JK-Flipflops eingesetzt. Die Arbeitsweise der Flipflops entspricht hier der von T-Flipflops, da J=K=1 anliegt. Der Zähler wird bei jedem Impuls am Eingang CL (Clock) um eins erhöht. Der Zähler zählt von 0 bis 15 (0000…1111). Ist der Zähler bei 16 angelangt, setzt er sich auf 0 zurück und beginnt wieder von vorne.

4-Bit asynchroner Vorwärtszähler.
Das Prinzip des zuvor beschriebenen 4-Bit-Asynchron-Vorwärtszählers kann man mit dem Arduino simulieren. Dabei zählt der Arduino bei jeder fallenden Flanke des Taktsignals um eins weiter.

| Bauteil | Anzahl | Beschreibung |
|---|---|---|
| Arduino Uno oder Nano | 1 | Mikrocontroller |
| Breadboard + Kabel | 1 Set | Aufbau & Verbindung |
| LED, 2 mA | 4 | Low-Current LED, 3 oder 5 mm Durchmesser |
| Widerstand 1,5 kΩ | 4 | bedrahtet (für Low-Current-LED) |
| Taster | 1 | Schließerkontakt |
// 4-Bit Asynchronzähler (Vorwärtszähler) mit Arduino
// Ausgabe über LEDs an D8-D11
// Takt per Taster an D2
const int clockPin = 2; // Taster als "Clock"
const int outputs[4] = {11, 10, 9, 8}; // LEDs für H0-H3 (LSB → MSB)
int lastClockState = HIGH;
unsigned char counter = 0; // Zählerstand 0..15
void setup() {
pinMode(clockPin, INPUT_PULLUP); // Taster mit Pullup
for (int n = 0; n st 4; n++) {
pinMode(outputs[n], OUTPUT);
digitalWrite(outputs[n], LOW);
}
}
void loop() {
int clockState = digitalRead(clockPin);
// Flanke erkennen (fallend: HIGH -> LOW)
if (lastClockState == HIGH && clockState == LOW) {
counter = (counter + 1) & 0x0F; // auf 4 Bit begrenzen (0..15)
// Bits auf LEDs ausgeben
for (int n = 0; n st 4; n++) {
int bitVal = (counter >> n) & 0x01; // i-tes Bit auslesen
digitalWrite(outputs[n], bitVal==1 ? HIGH : LOW);
}
delay(50); // Entprellen
}
lastClockState = clockState;
}
Der Dual-Rückwärtszähler zählt von seinem möglichen Höchstwert ab rückwärts. Er zählt bis 0. Ab dort beginnt er wieder von seinem Höchstpunkt an zu zählen.
Der Zähler wird bei jedem Impuls am Eingang CL (Clock) um eins erniedrigt. Der Zähler zählt von 15 bis 0 (1111...0000). Ist der Zähler bei 0 angelangt, setzt er sich auf 15 zurück und beginnt wieder von vorne.

4-Bit asynchroner Rückwärtszähler.
Die Zählrichtung eines Zählers hängt von der Nutzung seiner Ausgänge ab. Das Ausgangssignal Q wird für die Vorwärtsrichtung verwendet. Q (neg.) wird dagegen für die Rückwärtszählrichtung verwendet. Das bedeutet: Je nachdem, welche Ausgänge verwendet werden, zählt ein Zähler vorwärts oder rückwärts.
Um die Zählrichtung steuern bzw. umschalten zu können, muss man eine Steuerschaltung zwischen die Flip-Flops einsetzen. Mit dieser kann die Zählrichtung umgeschaltet werden.

4-Bit umschaltbarer Dualzähler.
Asynchron arbeitende Zähler haben keinen gemeinsamen Takt. Die Flip-Flops in einem solchen Zähler werden zu unterschiedlichen Zeiten geschaltet. Bei einer hohen Zählfrequenz macht sich die Verschiebung des Zählimpulses von Flip-Flop zu Flip-Flop negativ bemerkbar. Damit die Flip-Flops zur gleichen Zeit kippen, ist eine Steuerung mit einem gemeinsamen Takt notwendig. Solche Zähler werden als Synchronzähler bezeichnet.

4-Bit Synchronzähler.
Schieberegister bestehen aus hintereinander geschalteten D- oder JK-Flipflops mit untereinander verbundenen Takteingängen. Sie geben die gespeicherte Information jeweils mit einem Takt von Flipflop zu Flipflop
weiter. Die Datenbits können dabei nach links oder rechts geschoben werden.
Die Anzahl der Flipflops, die man für ein Schieberegister braucht, hängt davon ab, wie viele Bits man speichern will. Die gebräuchlichsten Schieberegister bestehen aus acht Flipflops (acht Bits = ein Byte).
Normalerweise sind Schieberegister in der Regel noch mit einem Clear- oder Reset-Eingang ausgestattet.
Schieberegister speichern oder bewegen Daten. Sie werden oft in Taschenrechnern oder Computern verwendet. Sie speichern zum Beispiel zwei Binärzahlen, bevor sie addiert werden. Oder sie konvertieren serielle Daten in parallele oder parallele in serielle Daten. Alle Flipflops, aus denen sich ein Schieberegister zusammensetzt, werden von einem gemeinsamen Taktsignal gesteuert. Dadurch sind sie synchron.

Prinzip Schieberegister.
Ein Schieberegister kann als Port Expander serielle Daten in parallele Daten umwandeln und umgekehrt. Dadurch kann z.B. die Anzahl der Verbindungsleitungen zwischen einer Steuerelektronik und einer Diodenanzeige so gering wie möglich gehalten werden. Mit Schieberegistern kann man z.B. die Anzahl der digitalen Ein- und Ausgänge des Arduino erweitern.
Um mit dem Arduino ein Schieberegister zu simulieren, benötigen wir den Aufbau eines 4-Bit-Asynchron-Vorwärtszählers (SIPO).
Das Impulsdiagramm unseres Vorwärts-Schieberegisters sieht dann folgendermaßen aus:


Arduino Sketch.
| Bauteil | Anzahl | Beschreibung |
|---|---|---|
| Arduino Uno oder Nano | 1 | Mikrocontroller |
| Breadboard + Kabel | 1 Set | Aufbau & Verbindung |
| LED, 2 mA | 4 | Low-Current LED, 3 oder 5 mm Durchmesser |
| Widerstand 1,5 kΩ | 4 | bedrahtet (für Low-Current-LED) |
| Taster | 1 | Schließerkontakt |
// 4-Bit Schieberegister vorwärts mit Arduino
// LEDs an Pins 8-11 (Q0-Q3)
// Taster an Pin 2 als Clock-Eingang
// Taster an Pin 3 als Data-Eingang
const int clockPin = 2; // Takt-Taster
const int dataPin = 3; // Takt-Taster
const int outputs[4] = {11, 10, 9, 8}; // LEDs = Schieberegister-Ausgänge
unsigned char shiftReg = 0b0001; // Startmuster (nur Bit0 aktiv)
int lastClockState = HIGH;
void setup() {
//Eingänge
pinMode(clockPin, INPUT_PULLUP); // Taster mit Pullup
pinMode(dataPin, INPUT_PULLUP); // Taster mit Pullup
//Ausgänge
for (int n = 0; n lt 4; n++) {
pinMode(outputs[n], OUTPUT);
digitalWrite(outputs[n], LOW);
}
digitalWrite(outputs[0], HIGH);
}
void loop() {
int clockState = digitalRead(clockPin);
int dataState = digitalRead(dataPin); // aus 0 wird eine 1 und umgekehrt
// Flankenerkennung (fallend)
if (lastClockState == HIGH && clockState == LOW) {
// Muster eins nach links schieben
shiftReg shift= 1;
// Falls das MSB rausfällt, von vorne beginnen
if (shiftReg > 0b1000) {
shiftReg = 0b0001;
shiftReg |= dataState;
}
// Ausgabe auf LEDs
for (int n = 0; n lt 4; n++) {
int bitVal = (shiftReg >> n) & 0x01;
digitalWrite(outputs[n], bitVal==1 ? HIGH : LOW);
}
delay(50); // Entprellen
}
lastClockState = clockState;
}
Funktionsweise:
Zu Beginn ist nur Q0 aktiv (0001).
Bei jedem Tastendruck von CL wird die 1 um eine Stelle nach links geschoben, d.h. 0001 → 0010 → 0100 → 1000 → 0001 usw.
Die LEDs zeigen, wie das Bit „wandert“.
Das Register wird bitweise mit seriellen Daten geladen, wobei die gespeicherten Daten parallel am Ausgang verfügbar sind. Ein typischer Vertreter hierfür ist der SN74164.

4-Bit-Vorwärts-SIPO-Schieberegister
Die Daten werden, jeweils ein Bit nach dem anderen in linker oder rechter Richtung unter Taktung, seriell in und aus dem Register geschoben.

4-Bit-Vorwärts-SISO-Schieberegister
Die Daten werden gleichzeitig parallel in das Register geladen und ein Bit nach dem anderen unter Taktsteuerung aus dem Register seriell geschoben. Ein typischer Vertreter hierfür ist der SN74HC165

4-Bit-Vorwärts-PISO-Schieberegister
Die parallelen Daten werden gleichzeitig ins Register geladen und gemeinsam mit dem gleichen Takt an ihre jeweiligen Ausgänge übertragen.

4-Bit-Vorwärts-PIPO-Schieberegister
Jetzt herunterladen.
Lade mein Freebie - "Die 10 wichtigsten Konzepte, die du wirklich verstehen musst" hier herunter.
ÜBER MICH
Ich möchte dich durch inspirierende Projekte und nützliche Anleitungen unterstützen, um deine digitalen Fähigkeiten zu verbessern und selbstbewusst in die Welt der Elektronik einzutauchen.
Erstellt mit © systeme.io • Datenschutzerklärung • AGB