74HC595 Arduino: Schieberegister für 8+ LEDs an nur 3 Pins

Der 74HC595 ist ein günstiges Schieberegister-IC mit 16 Pins, mit dem du über nur 3 digitale Pins deines Arduino 8 separate Ausgänge steuerst. Ein Arduino Uno hat 20 nutzbare Pins, und die sind schnell aufgebraucht, sobald du ein Knight-Rider-Lauflicht mit 16 LEDs, eine zweistellige Anzeigetafel oder eine 8-Kanal-Relaiskarte bauen willst. Der 74HC595 löst das Problem, indem er die Daten Bit für Bit über eine einzige Leitung empfängt: Der Chip sammelt die ankommenden Bits nacheinander und überträgt sie, sobald du es ihm sagst, gleichzeitig auf alle acht Ausgänge. Schaltest du mehrere Chips hintereinander, steuern dieselben 3 Pins 16, 24 oder sogar 80 Ausgänge.

In diesem Artikel lernst du die Pinbelegung des 74HC595 (DS, SH_CP, ST_CP, OE, MR und Q7'), den inneren Aufbau, der serielle Daten in parallele Ausgänge umwandelt, die Arduino-Funktion shiftOut() und den Unterschied zwischen den Bitreihenfolgen MSBFIRST und LSBFIRST kennen. Danach baust du einen Binärzähler, ein Lauflicht, eine Kette mit 16 LEDs und eine 7-Segment-Anzeige auf und steuerst dieselbe Schaltung mit Hardware-SPI um ein Vielfaches schneller. Die letzten Abschnitte zeigen Code für ESP32 und Raspberry Pi Pico (MicroPython), die Stromgrenzen des Chips und Lösungen für die häufigsten Latch-Fehler.

Was ist der 74HC595 und wie funktioniert er?

Im Chip stecken zwei hintereinandergeschaltete 8-Bit-Register. Das erste ist das Schieberegister: Bei jeder steigenden Flanke am Pin SH_CP (Takt) wandert die 0 oder 1 am Pin DS in die erste Zelle, und die vorhandenen Bits rücken um eine Stelle weiter. Nach acht Taktimpulsen sind alle acht gesendeten Bits im Chip. Das zweite ist das Speicherregister (Latch): Bei einer steigenden Flanke am Pin ST_CP werden die acht Bits aus dem Schieberegister auf einen Schlag hineinkopiert und erscheinen an den Ausgängen Q0–Q7. Dank dieses zweistufigen Aufbaus flackern die LEDs nicht, während die Bits geschoben werden; die Ausgänge ändern sich erst, wenn du den Latch-Pin auslöst.

Stell dir einen Bahnhof vor: Die Waggons (Bits) rollen auf einem einzigen Gleis nacheinander an den Bahnsteig, aber die Türen öffnen sich erst, wenn der Zug ganz steht, und alle Fahrgäste steigen gleichzeitig aus. Das Öffnen der Türen übernimmt der Latch-Pin. Weil die Daten seriell hinein- und parallel herauskommen, nennt man den 74HC595 auch ein SIPO-Register (serial-in, parallel-out). Sein Gegenstück, mit dem du 8 Taster über eine Leitung einliest, ist der 74HC165 (PISO). Beide gehören zur Logikfamilie der 74er-Serie; die Gatter und Chipnummern dieser Familie findest du im Werkzeug Logikgatter.

Pinbelegung des 74HC595 (Pinout)

Die halbmondförmige Kerbe oder der kleine Punkt auf dem Chip markiert Pin 1. Liegt die Kerbe oben und schaust du von oben auf den Chip, verlaufen links die Pins 1–8 von oben nach unten und rechts die Pins 9–16 von unten nach oben. Die Hersteller benennen die Pins unterschiedlich: NXP und die meisten Arduino-Quellen verwenden DS, SH_CP und ST_CP, Texas Instruments dagegen SER, SRCLK und RCLK. Die Tabelle unten zeigt beide Varianten. OE und MR sind Low-aktive Eingänge, das heißt, sie wirken, wenn sie LOW sind, und werden in Datenblättern mit einem Strich über dem Namen dargestellt.

Anschluss an Arduino Uno, ESP32 und Pico

Alle Arduino-Beispiele in diesem Artikel nutzen dieselbe Schaltung. Wenn du für Daten- und Taktleitung von Anfang an die Hardware-SPI-Pins (D11 und D13) wählst, musst du später beim Umstieg auf SPI kein einziges Kabel umstecken. Das lange Bein (Anode) jeder LED kommt an einen Ausgang, das kurze Bein (Kathode) über einen Widerstand an GND. Vergiss nicht einen 100-nF-Keramikkondensator zwischen VCC und GND, so nah wie möglich am Chip; er glättet die kurzen Spannungseinbrüche, wenn viele LEDs gleichzeitig schalten, und verhindert zufällige Fehler. Die SPI-Pins deines Boards kannst du auch im Werkzeug Pinout nachsehen.

Die Funktion shiftOut() und die Bitreihenfolge (MSBFIRST / LSBFIRST)

Am einfachsten schickst du Daten mit der eingebauten Funktion shiftOut(dataPin, clockPin, bitOrder, value) an den 74HC595. Sie schreibt die acht Bits des Bytes value nacheinander auf den Datenpin und setzt nach jedem Bit den Taktpin erst auf HIGH und dann auf LOW; der 74HC595 übernimmt das Bit genau bei dieser steigenden Flanke. shiftOut() rührt den Latch-Pin nicht an. Deshalb musst du ST_CP vor dem Senden auf LOW und danach auf HIGH setzen. Weil die Funktion mit steigenden Flanken arbeitet, sollte der Taktpin vor dem Aufruf außerdem LOW sein, sonst kann das erste Bit verloren gehen.

Der Parameter bitOrder legt fest, von welchem Ende aus die Bits gesendet werden. Das zuerst gesendete Bit landet nach acht Schiebevorgängen ganz am Ende, also an Q7, das zuletzt gesendete bleibt an Q0. Bei MSBFIRST geht zuerst das höchstwertige Bit (Bit 7) raus, daher landet jedes Bit des Bytes am Ausgang mit derselben Nummer: Bit 0 an Q0, Bit 7 an Q7. Bei LSBFIRST kehrt sich die Reihenfolge um, und Bit 0 erscheint an Q7, Bit 7 an Q0. Alle Beispiele in diesem Artikel verwenden MSBFIRST, damit die Bits der Zahl im Code genau den LED-Nummern entsprechen. Wenn du Binärzahlen und die Schreibweise mit 0b auffrischen willst, lies den Artikel über Zahlensysteme und Bitoperationen.

Schritt für Schritt: Binärzähler mit 8 LEDs

1. Setze den 74HC595 über die Rille in der Mitte des Steckbretts, sodass die beiden Beinreihen auf verschiedenen Seiten liegen. Wenn du die inneren Verbindungen eines Steckbretts nicht kennst, lies zuerst Was ist ein Breadboard?.
2. Verbinde VCC (Pin 16) und MR (Pin 10) mit 5V, GND (Pin 8) und OE (Pin 13) mit GND. Stecke den 100-nF-Kondensator zwischen VCC und GND.
3. Verbinde DS (14) mit D11, SH_CP (11) mit D13 und ST_CP (12) mit D10.
4. Schließe die langen Beine von acht LEDs an die Ausgänge Q0–Q7 und die kurzen Beine über 470-Ω-Widerstände an GND an. Denk daran, dass Q0 Pin 15 ist.
5. Lade den Code unten hoch. Die LEDs sollten binär von 0 bis 255 zählen; die LED an Q0 blinkt am schnellsten, die an Q7 am langsamsten.

1// 74HC595 ile 8 LED'de ikilik sayaç / Binary counter on 8 LEDs with a 74HC595
2const int DATA_PIN = 11;   // DS (14)
3const int CLOCK_PIN = 13;  // SH_CP (11)
4const int LATCH_PIN = 10;  // ST_CP (12)
5
6void write595(byte value) {
7  digitalWrite(LATCH_PIN, LOW);                    // latch'i indir / pull the latch low
8  shiftOut(DATA_PIN, CLOCK_PIN, MSBFIRST, value);  // 8 biti kaydır / shift the 8 bits in
9  digitalWrite(LATCH_PIN, HIGH);                   // yükselen kenar: çıkışlara aktar / rising edge: copy to the outputs
10}
11
12void setup() {
13  pinMode(DATA_PIN, OUTPUT);
14  pinMode(CLOCK_PIN, OUTPUT);
15  pinMode(LATCH_PIN, OUTPUT);
16  digitalWrite(CLOCK_PIN, LOW);                    // saat LOW başlamalı / the clock must start low
17  write595(0);                                     // açılışta hepsi sönük / all off at startup
18}
19
20void loop() {
21  for (int n = 0; n < 256; n++) {
22    write595(n);                                   // n'in bitleri Q0–Q7'de / the bits of n on Q0–Q7
23    delay(200);
24  }
25}

Das Herz des Codes ist die Funktion write595(): Sie setzt den Latch auf LOW, schickt mit shiftOut() acht Bits und setzt den Latch auf HIGH, um alle gleichzeitig auf die Ausgänge zu übertragen. Hier liegt auch die Antwort, warum die LEDs nicht flackern: Während geschoben wird, behalten die Ausgänge ihren alten Wert. Ist n gleich 5 (0b00000101), leuchten die LEDs an Q0 und Q2; bei 200 (0b11001000) leuchten die LEDs an Q3, Q6 und Q7. Am Uno siehst du vielleicht, dass die eingebaute L-LED an D13 mit dem Taktsignal leicht flimmert; das ist normal und stört die Schaltung nicht.

Lauflicht und Knight-Rider-Effekt

Für ein Lauflicht musst du bei jedem Schritt nur ein einziges Bit auf 1 setzen. Das Arduino-Makro bit(i) erzeugt eine Zahl, in der nur Bit i gleich 1 ist: bit(0) ergibt 1, bit(3) ergibt 8 und bit(7) ergibt 128. Der Code unten spielt drei Effekte nacheinander ab: eine einzelne LED, die von Q0 nach Q7 läuft, einen hin und her laufenden Knight-Rider-Scanner und einen Balken, der sich nach und nach füllt. Zum Vergleich mit der klassischen Variante direkt an den Pins sieh dir Arduino Lauflicht und Knight-Rider-Effekt an; dort braucht jede LED einen eigenen Pin, hier reichen insgesamt 3 Pins.

1// Yürüyen LED, karaşimşek ve dolan çubuk / Running light, Knight Rider and filling bar
2const int DATA_PIN = 11;   // DS
3const int CLOCK_PIN = 13;  // SH_CP
4const int LATCH_PIN = 10;  // ST_CP
5const int STEP_MS = 80;    // adım süresi (ms) / step time (ms)
6
7void write595(byte value) {
8  digitalWrite(LATCH_PIN, LOW);
9  shiftOut(DATA_PIN, CLOCK_PIN, MSBFIRST, value);
10  digitalWrite(LATCH_PIN, HIGH);
11}
12
13void setup() {
14  pinMode(DATA_PIN, OUTPUT);
15  pinMode(CLOCK_PIN, OUTPUT);
16  pinMode(LATCH_PIN, OUTPUT);
17  digitalWrite(CLOCK_PIN, LOW);
18  write595(0);
19}
20
21void loop() {
22  // 1) Yürüyen LED: Q0'dan Q7'ye / running light: Q0 to Q7
23  for (int i = 0; i < 8; i++) {
24    write595(bit(i));               // yalnızca i. bit 1 / only bit i is 1
25    delay(STEP_MS);
26  }
27
28  // 2) Karaşimşek: git-gel, 3 tur / Knight Rider: back and forth, 3 rounds
29  for (int r = 0; r < 3; r++) {
30    for (int i = 0; i < 7; i++) { write595(bit(i)); delay(STEP_MS); }
31    for (int i = 7; i > 0; i--) { write595(bit(i)); delay(STEP_MS); }
32  }
33
34  // 3) Dolan çubuk / filling bar
35  byte bar = 0;
36  for (int i = 0; i < 8; i++) {
37    bar |= bit(i);                  // bir LED daha ekle / add one more LED
38    write595(bar);
39    delay(STEP_MS * 2);
40  }
41  write595(0);
42  delay(300);
43}

Im Knight-Rider-Teil läuft die Vorwärtsschleife von 0 bis 6 und die Rückwärtsschleife von 7 bis 1; so leuchten die äußeren LEDs nicht zweimal hintereinander, und die Bewegung wirkt flüssig. Beim Füllbalken fügt die Operation |= (bitweises ODER) eine neue LED hinzu, während die vorherigen an bleiben; das ist die Grundlage einer LED-Balkenanzeige für den Wert eines Potentiometers oder Sensors. Da der Code delay() nutzt, kann der Arduino während des Effekts nichts anderes tun. Willst du währenddessen einen Taster abfragen oder die Geschwindigkeit live ändern, steuere das Timing mit millis(); wie das geht, steht im Artikel millis() und delay().

Mehrere 74HC595 kaskadieren (Q7')

Pin 9 des Chips, Q7' (QH'), gibt das Bit aus, das aus dem Schieberegister herausfällt. Verbindest du ihn mit dem DS-Eingang eines zweiten 74HC595, verhalten sich beide Chips wie ein einziges 16-Bit-Register. Die Leitungen SH_CP und ST_CP teilen sich alle Chips; ob drei oder zehn Chips in der Kette hängen, vom Arduino gehen weiterhin nur 3 Kabel ab. Jedes neue Byte schiebt das vorherige in den nächsten Chip. Deshalb landet das zuerst gesendete Byte im letzten Chip der Kette, das zuletzt gesendete dagegen im ersten Chip, der am Arduino hängt. Beim Auslösen des Latch aktualisieren sich die Ausgänge aller Chips gleichzeitig.

1// İki zincirli 74HC595 ile 16 LED / 16 LEDs on two daisy-chained 74HC595s
2const int DATA_PIN = 11;   // 1. entegrenin DS'si / DS of chip 1
3const int CLOCK_PIN = 13;  // iki entegrede ortak SH_CP / shared SH_CP
4const int LATCH_PIN = 10;  // iki entegrede ortak ST_CP / shared ST_CP
5
6void write16(uint16_t value) {
7  digitalWrite(LATCH_PIN, LOW);
8  shiftOut(DATA_PIN, CLOCK_PIN, MSBFIRST, highByte(value));  // önce uzaktaki entegre (LED 8–15) / far chip first (LEDs 8–15)
9  shiftOut(DATA_PIN, CLOCK_PIN, MSBFIRST, lowByte(value));   // sonra yakındaki (LED 0–7) / then the near chip (LEDs 0–7)
10  digitalWrite(LATCH_PIN, HIGH);                             // 16 çıkış aynı anda değişir / all 16 outputs change at once
11}
12
13void setup() {
14  pinMode(DATA_PIN, OUTPUT);
15  pinMode(CLOCK_PIN, OUTPUT);
16  pinMode(LATCH_PIN, OUTPUT);
17  digitalWrite(CLOCK_PIN, LOW);
18  write16(0);
19}
20
21void loop() {
22  for (int i = 0; i < 16; i++) {    // ileri / forward
23    write16(bit(i));
24    delay(50);
25  }
26  for (int i = 14; i > 0; i--) {    // geri / backward
27    write16(bit(i));
28    delay(50);
29  }
30}

highByte() und lowByte() teilen die 16-Bit-Zahl in zwei Bytes. Das High-Byte wird zuerst gesendet, wandert also in den letzten Chip der Kette und steuert die LEDs 8–15; das Low-Byte bleibt im ersten Chip. Für einen dritten Chip schickst du einfach ein Byte mehr und beginnst wieder mit dem am weitesten entfernten Chip; bei vielen Chips ist es übersichtlicher, die Bytes in einem Array zu halten und per Schleife zu senden. Eine Kette hat keine theoretische Grenze, aber jeder Chip verlängert die Aktualisierung und belastet die gemeinsame Taktleitung stärker. Gib in langen Ketten jedem Chip seinen eigenen 100-nF-Kondensator, halte Takt- und Latch-Kabel kurz und verstärke den Takt bei sehr langen Leitungen mit einem Puffer-IC wie dem 74HC244.

7-Segment-Anzeige mit dem 74HC595 ansteuern

Eine einstellige 7-Segment-Anzeige enthält genau acht LEDs: sieben Segmente von a bis g und einen Punkt (dp). Die acht Ausgänge eines 74HC595 passen also genau für eine Stelle. Verbindest du Q0 mit Segment a, Q1 mit b und so weiter, landet Q6 bei g und Q7 beim Punkt; Bit 0 des Bytes steht dann für Segment a und Bit 6 für Segment g. Die Tabelle unten zeigt die Verdrahtung für eine verbreitete 10-polige Anzeige mit gemeinsamer Kathode. Die gemeinsamen Pins (3 und 8) kommen an GND, und jedes Segment bekommt einen eigenen 470-Ω-Widerstand. Die Anordnung der Segmentbuchstaben und den Unterschied zwischen gemeinsamer Anode und Kathode findest du ausführlich im Artikel 7-Segment-Anzeige am Arduino.

1// 74HC595 ile tek haneli 7 segment: 0–9 sayacı / Single-digit 7-segment 0–9 counter with a 74HC595
2const int DATA_PIN = 11;
3const int CLOCK_PIN = 13;
4const int LATCH_PIN = 10;
5const bool COMMON_ANODE = false;    // ortak anotsa true / true for common anode
6
7// bit 0 = a ... bit 6 = g, bit 7 = dp (1 = yanar / 1 = on)
8const byte DIGITS[10] = {
9  0b00111111, // 0
10  0b00000110, // 1
11  0b01011011, // 2
12  0b01001111, // 3
13  0b01100110, // 4
14  0b01101101, // 5
15  0b01111101, // 6
16  0b00000111, // 7
17  0b01111111, // 8
18  0b01101111  // 9
19};
20
21void write595(byte value) {
22  if (COMMON_ANODE) value = ~value;   // ortak anotta LOW yakar / LOW lights a common-anode segment
23  digitalWrite(LATCH_PIN, LOW);
24  shiftOut(DATA_PIN, CLOCK_PIN, MSBFIRST, value);
25  digitalWrite(LATCH_PIN, HIGH);
26}
27
28void setup() {
29  pinMode(DATA_PIN, OUTPUT);
30  pinMode(CLOCK_PIN, OUTPUT);
31  pinMode(LATCH_PIN, OUTPUT);
32  digitalWrite(CLOCK_PIN, LOW);
33}
34
35void loop() {
36  for (int n = 0; n < 10; n++) {
37    byte pattern = DIGITS[n];
38    if (n % 2 == 1) pattern |= 0b10000000;   // tek sayılarda nokta yanar / dot on for odd numbers
39    write595(pattern);
40    delay(800);
41  }
42}

Bei einer Anzeige mit gemeinsamer Anode kommen die gemeinsamen Pins an 5V, und ein Segment leuchtet, wenn sein Ausgang LOW ist. Setzt du COMMON_ANODE im Code auf true, invertiert der Operator ~ alle Bits, und dieselbe Tabelle funktioniert weiter. Für einen zweistelligen Zähler hängst du einen zweiten 74HC595 an die Kette und schickst zuerst das Muster für die entfernte Stelle, dann das für die Stelle am Arduino. So hat jede Stelle ihren eigenen Chip, Multiplexing ist überflüssig, die Anzeige flackert nie, und delay() in loop() stört nicht. Für vier oder mehr Stellen kannst du mit zwei 74HC595 multiplexen oder auf Treiber wie TM1637 oder MAX7219 umsteigen, die das Abtasten selbst übernehmen.

Schnelle Ansteuerung mit SPI

shiftOut() ist langsam, weil es jedes Bit einzeln mit digitalWrite() schreibt: Am Arduino Uno dauert ein Byte etwa 100 µs. Bei ein paar LEDs merkst du das nicht, aber es reicht nicht mehr, wenn du eine Kette aus 10 Chips tausende Male pro Sekunde aktualisieren, die LED-Helligkeit per Software regeln oder einen gemultiplexten LED-Würfel abtasten willst. Die gute Nachricht: Das Protokoll des 74HC595 ist im Grunde nichts anderes als SPI. DS entspricht MOSI, SH_CP entspricht SCK und ST_CP dem Chip-Select-Pin (CS). Die Hardware-SPI-Einheit des Uno sendet ein Byte bei 8 MHz in etwa 1 µs; selbst mit dem Overhead der Funktionsaufrufe ist sie um ein Vielfaches schneller als shiftOut(). Wie SPI funktioniert, erfährst du im Artikel Was ist SPI?.

1// 74HC595'i donanım SPI ile sürmek (Arduino Uno) / Driving a 74HC595 over hardware SPI (Arduino Uno)
2#include <SPI.h>
3
4const int LATCH_PIN = 10;   // ST_CP; D11 (MOSI) = DS, D13 (SCK) = SH_CP
5
6void write595(byte value) {
7  SPI.beginTransaction(SPISettings(8000000, MSBFIRST, SPI_MODE0));  // 8 MHz, mod 0 / 8 MHz, mode 0
8  digitalWrite(LATCH_PIN, LOW);
9  SPI.transfer(value);              // 8 bit yaklaşık 1 µs'de / 8 bits in about 1 µs
10  digitalWrite(LATCH_PIN, HIGH);    // çıkışlara aktar / copy to the outputs
11  SPI.endTransaction();
12}
13
14void setup() {
15  pinMode(LATCH_PIN, OUTPUT);
16  SPI.begin();                      // D11 ve D13 SPI'ye geçer / D11 and D13 switch to SPI
17  write595(0);
18}
19
20void loop() {
21  static byte pattern = 0b00000001;
22  write595(pattern);
23  pattern = (pattern << 1) | (pattern >> 7);   // sola döndür / rotate left
24  delay(100);
25}

Im SPI_MODE0 werden die Daten bei der steigenden Taktflanke übernommen, genau wie beim 74HC595. MSBFIRST schickt Bit 7 wieder an Q7, sodass die Muster aus den vorherigen Beispielen unverändert funktionieren. Am Uno muss D10 ein Ausgang sein, damit die Hardware-SPI im Master-Modus bleibt; SPI.begin() erledigt das bereits, und deshalb ist D10 auch der beste Pin für den Latch. Hängen mehrere Chips in der Kette, rufst du zwischen Latch LOW und HIGH einfach SPI.transfer() einmal pro Chip auf. MISO (D12) wird in dieser Schaltung nicht genutzt und bleibt für ein anderes SPI-Gerät frei.

Helligkeit mit OE regeln und mit MR löschen

Der Pin OE (Output Enable) ist ein Schalter, der alle Ausgänge auf einmal ein- oder ausschaltet. Schließt du ihn statt an GND an einen PWM-Pin des Uno an, zum Beispiel D9, regelst du die Helligkeit aller LEDs gemeinsam per PWM. Weil OE Low-aktiv ist, ist die Logik umgekehrt: analogWrite(9, 0) bedeutet volle Helligkeit, analogWrite(9, 255) ganz aus. Mit analogWrite(9, 255 - helligkeit) im Code wird es einfacher. Diese Methode wirkt auf alle LEDs gleich; willst du jede LED einzeln dimmen, musst du das per Software mit schnellen SPI-Aktualisierungen lösen oder auf adressierbare LEDs wie den WS2812B umsteigen.

Wird der Pin MR (Master Reset) LOW, werden alle Bits im Schieberegister gelöscht, die Ausgänge gehen aber nicht sofort aus, weil das Speicherregister seinen alten Wert behält. Damit auch die Ausgänge ausgehen, musst du bei MR = LOW eine steigende Flanke an den Latch-Pin geben. In der Praxis legst du MR direkt an VCC und löschst per Software mit write595(0); das spart einen Pin und ein Kabel. Dazu kommt das Einschaltverhalten: Beim Anlegen der Spannung startet das Speicherregister mit einem zufälligen Wert, und die LEDs können kurz wild aufleuchten. Bei einer Relaiskarte kann das gefährlich sein; um es zu verhindern, ziehst du OE mit 10 kΩ auf VCC, rufst in setup() zuerst write595(0) auf und setzt danach den OE-Pin auf LOW.

74HC595 am ESP32: 3,3 V und SPI

Die Pins des ESP32 liefern 3,3 V. Versorgst du den 74HC595 mit 5 V, braucht ein Eingang etwa 0,7 × VCC, also 3,5 V, um als HIGH zu gelten; 3,3 V liegen darunter, und der Betrieb wird unzuverlässig. Die sauberste Lösung ist, den Chip ebenfalls am 3V3-Pin des ESP32 zu versorgen, denn der 74HC595 läuft ab 2 V. Musst du den Chip unbedingt mit 5 V betreiben, nimm den 74HCT595, dessen Eingänge schon ab 2 V HIGH erkennen, oder setze einen Pegelwandler dazwischen. Bei 3,3 V passen 220 Ω für rote, gelbe und grüne LEDs; blaue und weiße LEDs mit etwa 3 V Durchlassspannung leuchten bei 3,3 V nur sehr schwach.

Das Beispiel unten nutzt die VSPI-Pins des ESP32 (SCK an GPIO 18, MOSI an GPIO 23) für einen Knight-Rider-Effekt mit 16 LEDs an zwei kaskadierten 74HC595; GPIO 5 dient als Latch. Die SPI-Geschwindigkeit steht auf 4 MHz, weil die Geschwindigkeitsgrenze des 74HC595 mit der Versorgungsspannung sinkt und 4 MHz bei 3,3 V viel Reserve lassen. shiftOut() funktioniert auch am ESP32 und ist dank des 240-MHz-Prozessors viel schneller als am Uno; SPI entlastet den Prozessor aber für Aufgaben wie WLAN. Grundlagen zum Board und zur sicheren Pinwahl findest du in Was ist der ESP32?.

1// ESP32 + iki 74HC595 (SPI) ile 16 LED karaşimşek / 16-LED Knight Rider on ESP32 with two 74HC595s (SPI)
2#include <SPI.h>
3
4const int SCK_PIN = 18;    // SH_CP
5const int MOSI_PIN = 23;   // DS
6const int LATCH_PIN = 5;   // ST_CP
7
8void write16(uint16_t value) {
9  SPI.beginTransaction(SPISettings(4000000, MSBFIRST, SPI_MODE0));  // 3,3 V için 4 MHz yeterli / 4 MHz is plenty at 3.3 V
10  digitalWrite(LATCH_PIN, LOW);
11  SPI.transfer(highByte(value));    // önce uzaktaki entegre / far chip first
12  SPI.transfer(lowByte(value));     // sonra yakındaki / then the near chip
13  digitalWrite(LATCH_PIN, HIGH);
14  SPI.endTransaction();
15}
16
17void setup() {
18  pinMode(LATCH_PIN, OUTPUT);
19  SPI.begin(SCK_PIN, -1, MOSI_PIN, -1);   // MISO ve SS kullanılmıyor / MISO and SS unused
20  write16(0);
21}
22
23void loop() {
24  for (int i = 0; i < 16; i++) { write16(bit(i)); delay(40); }   // ileri / forward
25  for (int i = 14; i > 0; i--) { write16(bit(i)); delay(40); }   // geri / backward
26}

74HC595 mit Raspberry Pi Pico und MicroPython

Versorge den 74HC595 auch am Pico über den Pin 3V3(OUT). MicroPython hat kein fertiges Gegenstück zu shiftOut(), aber die Hardware-SPI erledigt den Job mühelos: Genutzt werden GP18 (SCK) und GP19 (MOSI) der Einheit SPI0, als Latch eignet sich jeder GPIO, hier GP17. MicroPython reserviert außerdem den MISO-Pin von SPI0 (GP16) für SPI, schließ dort also nichts anderes an. Übergibst du spi.write() mehrere Bytes, aktualisierst du alle Chips der Kette auf einmal, und wieder geht das erste Byte an den am weitesten entfernten Chip. Installation und erste Schritte findest du in Was ist der Raspberry Pi Pico?.

1# Pico + 74HC595: yürüyen LED ve ikilik sayaç (SPI) / Pico + 74HC595: running light and binary counter (SPI)
2from machine import Pin, SPI
3import time
4
5# GP18 = SCK -> SH_CP, GP19 = MOSI -> DS; GP16 (MISO) boş kalır / GP16 (MISO) stays unconnected
6spi = SPI(0, baudrate=4000000, polarity=0, phase=0, sck=Pin(18), mosi=Pin(19))
7latch = Pin(17, Pin.OUT, value=1)    # ST_CP
8
9def write595(*values):
10    # birden çok bayt = zincirdeki entegreler, ilk bayt en uzaktakine
11    # several bytes = chained chips, the first byte goes to the far chip
12    latch.value(0)
13    spi.write(bytes(values))
14    latch.value(1)                   # yükselen kenar: çıkışlara aktar / rising edge: copy to the outputs
15
16write595(0)
17while True:
18    for i in range(8):               # yürüyen LED / running light
19        write595(1 << i)
20        time.sleep_ms(80)
21    for n in range(256):             # ikilik sayaç / binary counter
22        write595(n)
23        time.sleep_ms(20)

Größere Lasten: Transistor, ULN2803 und TPIC6B595

Die Ausgänge des 74HC595 eignen sich nur für kleine LED-Ströme. Schließe Lasten wie eine Relaisspule (70–90 mA), einen kleinen Motor, mehrere Summer oder einen 12-V-LED-Streifen nicht direkt an. Du kannst hinter jeden Ausgang einen NPN-Transistor setzen oder den ULN2803 verwenden, der acht Darlington-Transistoren in einem Gehäuse vereint: Er schaltet bis zu 500 mA pro Kanal auf der GND-Seite und hat Freilaufdioden für induktive Lasten eingebaut; damit sie wirken, verbindest du den COM-Pin mit der Versorgung der Last. Noch kompakter ist der TPIC6B595, der genauso programmiert wird wie der 74HC595, aber kräftige Open-Drain-Ausgänge hat: Er trägt dauerhaft 150 mA pro Ausgang und schaltet Lasten bis 50 V. Er hat 20 Pins und damit eine andere Pinbelegung; die Last kommt zwischen Pluspol und Ausgang.

74HC595, MAX7219 oder TM1637?

Brauchst du einen einfachen LED-Balken, eine 8-Kanal-Relaiskarte oder digitale Ausgänge mit jeweils eigener Aufgabe, ist der 74HC595 die günstigste und flexibelste Wahl. Bei 8x8-LED-Matrizen oder mehrstelligen Anzeigen macht dir der MAX7219, der das Multiplexing selbst übernimmt, das Leben viel leichter. Willst du farbige, einzeln steuerbare Lichter, laufen WS2812B-NeoPixel-LEDs an einem einzigen Datenpin.

Projektideen mit dem 74HC595

• Knight Rider mit 16 LEDs: Baue den Hin-und-her-Effekt mit zwei kaskadierten Chips und regle seine Geschwindigkeit mit einem Potentiometer.
• LED-Balkenanzeige: Zeige einen Sensorwert oder einen Pegel auf einem Balken aus 8–16 LEDs an.
• Einparkhilfe: Lass von Grün bis Rot immer mehr LEDs leuchten, je kürzer der mit dem HC-SR04 gemessene Abstand wird.
• Zweistellige Anzeigetafel: Baue mit zwei 7-Segment-Anzeigen und zwei kaskadierten Chips einen flackerfreien Zähler mit Tastern.
• Binäruhr: Zeige Stunden, Minuten und Sekunden als Binärzahlen in LED-Spalten an und hole die Zeit von einem RTC-Uhrenmodul.
• 3x3x3-LED-Würfel: Erzeuge 3D-Animationen, indem du die Ebenen mit Transistoren und die Spalten mit 74HC595 ansteuerst; Details im Artikel Arduino-LED-Würfel.
• 8-Kanal-Relaiskarte: Steuere mit einem ULN2803 oder TPIC6B595 acht Relais über 3 Pins.

Häufige Fehler und ihre Lösungen

Der 74HC595 ist der günstigste und lehrreichste Weg, Pinmangel zu beheben. Hast du das Prinzip aus Schieben und Latchen einmal verstanden, erkennst du es bei SPI-Geräten, LED-Matrix-Treibern und Anzeigemodulen wieder, und auch beim Einlesen von Tastern mit dem 74HC165. Fang mit dem Zähler mit 8 LEDs an, verlängere dann die Kette und steig auf SPI um. In der BlueGrays-App findest du Projekte mit Lauflicht, Knight-Rider-Effekt, Effekten mit einstellbarer Geschwindigkeit und 7-Segment-Zählern für Arduino, ESP32 und Raspberry Pi Pico, Schritt für Schritt mit Schaltplänen und Code.