Ausgänge erweitern mit 74HC595

Ein Arduino Uno hat 20 Pins, und die sind schnell vergeben: Display, Taster, Sensoren. Für eine Reihe von acht LEDs, eine Siebensegmentanzeige oder eine Relaiskarte bleibt dann nichts übrig. Der 74HC595 löst das: Er nimmt Daten seriell über drei Leitungen entgegen und gibt sie an acht parallelen Ausgängen aus. Schaltest du mehrere hintereinander, bleibt es bei drei Pins, egal ob du 8, 16 oder 64 Ausgänge brauchst.

Der Baustein ist ein Schieberegister mit nachgeschaltetem Speicherregister. Diese zweite Stufe ist der Grund für seine Beliebtheit: Während du neue Daten hineinschiebst, bleiben die Ausgänge ruhig. Erst ein Übernahmeimpuls schaltet alle acht gleichzeitig um, ohne Flackern.

Schaltplan

• IC1, 74HC595: Schieberegister mit Speicherregister. In manchen Datenblättern heißen die Pins anders: SER statt DS, SRCLK statt SH_CP, RCLK statt ST_CP, QA bis QH statt Q0 bis Q7.
• DS (Pin 14): Dateneingang. Hier liegt das Bit, das als Nächstes hineingeschoben wird.
• SH_CP (Pin 11): Schiebetakt. Jede steigende Flanke schiebt alle Bits eine Stelle weiter und übernimmt DS in die erste Stelle.
• ST_CP (Pin 12): Übernahmetakt (Latch). Eine steigende Flanke kopiert den Inhalt des Schieberegisters auf die Ausgänge.
• O̅E̅ an Masse: Ausgänge freigegeben. Mit High werden sie hochohmig.
• M̅R̅ an +5 V: Das Löschen des Schieberegisters bleibt ungenutzt.
• R1–R8, 470 Ω, und LED1–LED8: je eine LED mit Vorwiderstand pro Ausgang.
• C1, 100 nF: Abblockkondensator, so nah wie möglich an Pin 16 und Pin 8.
• Q7S (Pin 9): serieller Ausgang, an dem das achte Bit herausfällt.

Die drei Arduino-Pins sind die Hardware-SPI-Leitungen des Uno (MOSI, SCK) und ein beliebiger dritter Pin. So kannst du später ohne Umbau auf SPI umsteigen.

So funktioniert die Schaltung

Im Baustein stecken zwei Reihen aus je acht Flipflops. Die erste Reihe ist das Schieberegister: Bei jeder steigenden Flanke an SH_CP wandert jedes Bit eine Stelle weiter, das Bit an DS rückt in die erste Stelle nach, das Bit aus der letzten Stelle erscheint an Q7S. Nach acht Takten steht das ganze Byte im Register, das zuerst geschickte Bit ganz hinten.

Die zweite Reihe ist das Speicherregister. Es hängt an den Ausgängen und ändert sich nur bei einer steigenden Flanke an ST_CP. Dann übernimmt es alle acht Bits gleichzeitig. Bis dahin zeigen die Ausgänge unverändert das alte Muster.

Weil die Bits einzeln nacheinander kommen, spricht man von serieller Übertragung, am Ausgang stehen sie parallel. Wie aus einem Byte die acht Stellen werden, zeigt Zahlensysteme.

Das Programm erledigt alles mit der Arduino-Funktion shiftOut, die ein Byte Bit für Bit auf DS legt und SH_CP dazu taktet:

const int DATEN = 11;       // → DS (Pin 14)
const int TAKT = 13;        // → SH_CP (Pin 11)
const int UEBERNAHME = 10;  // → ST_CP (Pin 12)

void schreibe(byte muster) {
  digitalWrite(UEBERNAHME, LOW);
  shiftOut(DATEN, TAKT, MSBFIRST, muster);  // Bit 7 zuerst → landet an Q7
  digitalWrite(UEBERNAHME, HIGH);           // steigende Flanke: Ausgänge schalten
}

void setup() {
  pinMode(DATEN, OUTPUT);
  pinMode(TAKT, OUTPUT);
  pinMode(UEBERNAHME, OUTPUT);
  schreibe(0);                              // alle LEDs aus
}

void loop() {                               // Lauflicht von Q0 nach Q7
  for (int i = 0; i < 8; i++) {
    schreibe(1 << i);
    delay(100);
  }
}

Dimensionierung

1. Ausgangsspannung unter Last. Das Datenblatt garantiert bei 4,5 V Versorgung und 6 mA Laststrom mindestens 3,84 V am Ausgang, typisch 4,3 V. Mit diesem typischen Wert rechnest du den Vorwiderstand.

2. Vorwiderstand. Für eine rote LED mit U_F = 2,0 V und gewünschten 5 mA:

Der nächste Normwert der E12-Reihe ist 470 Ω, damit fließen 4,9 mA. Moderne LEDs sind damit gut hell. Wie du den Vorwiderstand allgemein bestimmst, steht unter LED-Vorwiderstand berechnen.

3. Gesamtstrom. Die Grenze sind nicht die einzelnen Ausgänge, sondern die Versorgungspins: Über VCC oder GND dürfen höchstens 70 mA fließen, pro Ausgang 35 mA.

Das liegt mit Abstand unter 70 mA. Bei voller 5-V-Versorgung steigt die Ausgangsspannung etwas, der Strom auf etwa 5,5 mA je LED und 44 mA insgesamt – immer noch sicher.

4. Geschwindigkeit. shiftOut braucht auf dem Uno etwa 0,1 ms pro Byte. Mit der SPI-Hardware bei 8 MHz Takt ist ein Byte in rund 1 μs übertragen. Der 74HC595 schafft bei 4,5 V mindestens 25 MHz Schiebetakt, beides ist also unkritisch.

Bauteilliste

Erweiterungen

Kaskadieren. Q7S des ersten Registers geht an DS des zweiten; SH_CP und ST_CP aller Register hängen parallel an denselben Pins. Du schiebst dann zwei Bytes hintereinander und gibst erst danach den Übernahmeimpuls. Das zuerst geschickte Byte landet im hintersten Register. Ab etwa vier Registern lohnt ein eigener Abblockkondensator an jedem Baustein und eine Verstärkung der Taktleitung.

Helligkeit per PWM. Hängst du O̅E̅ statt an Masse an einen PWM-Pin, dimmst du alle Ausgänge gemeinsam. Weil der Eingang aktiv Low ist, bedeutet analogWrite(9, 0) volle Helligkeit und analogWrite(9, 255) aus.

Größere Lasten. Für Relais, Magnetventile oder LED-Streifen setzt du hinter jeden Ausgang einen Transistor, etwa wie im NPN-Low-Side-Schalter oder unter Relais am Arduino ansteuern. Bequemer ist der TPIC6B595: gleiche Logik, aber Open-Drain-Ausgänge für 150 mA und 50 V.

Eingänge erweitern. Das Gegenstück ist der 74HC165: Er liest acht Taster parallel ein und schiebt sie seriell zum Controller. Beide lassen sich am selben Takt betreiben.

3,3-V-Controller. Ein 74HC595 an 5 V erwartet bei High mindestens 3,5 V (70 % der Versorgung), ein ESP32 liefert 3,3 V, garantiert sogar nur 2,64 V – das reicht nicht. Der 74HCT595 erkennt High schon ab 2,0 V und passt direkt. Alternativ betreibst du den 74HC595 an 3,3 V, wenn die LEDs das erlauben, oder setzt einen bidirektionalen Pegelwandler ein.

Typische Fehler

• LEDs flackern oder zeigen Zufallsmuster: M̅R̅ oder O̅E̅ hängen in der Luft. Beide brauchen einen festen Pegel.
• Muster spiegelverkehrt: MSBFIRST und LSBFIRST vertauscht oder die LEDs in falscher Reihenfolge gesteckt. Denk daran, dass Q0 an Pin 15 liegt, Q1 bis Q7 aber an Pin 1 bis 7.
• Muster verrutscht um eine Stelle: Störspitzen auf langen Taktleitungen erzeugen Doppeltakte. Kurze Leitungen, der Abblockkondensator und ein Serienwiderstand von 100 Ω direkt am Arduino-Pin helfen.
• LEDs werden dunkler, je mehr leuchten: Der Gesamtstrom ist zu hoch, die Ausgangsspannung bricht ein. Vorwiderstände vergrößern oder Treiber nachschalten.
• Alles leuchtet beim Einschalten kurz: Nach dem Einschalten ist der Inhalt zufällig. Halte O̅E̅ über einen 10-kΩ-Pull-up auf High und gib die Ausgänge erst frei, nachdem setup() ein definiertes Muster geschrieben hat.

Selbsttest