74HC595 Arduino-tutorial: schuifregister voor 8+ LED's op 3 pinnen
74HC595 Arduino-tutorial: pinout, shiftOut() en bitvolgorde, chips doorkoppelen, looplicht en 7-segment, snelle SPI, ESP32- en Pico-code, stroomlimieten.
De 74HC595 is een goedkope schuifregister-IC met 16 pinnen waarmee je 8 afzonderlijke uitgangen bestuurt met slechts 3 digitale pinnen van je Arduino. Een Arduino Uno heeft 20 bruikbare pinnen, en die raken snel op als je een Knight Rider-scanner met 16 LED's, een scorebord met twee cijfers of een relaisboard met 8 kanalen wilt bouwen. De 74HC595 lost dat op door data bit voor bit over één lijn te ontvangen: de chip verzamelt de binnenkomende bits achter elkaar en kopieert ze, zodra jij aangeeft dat je klaar bent, in één keer naar alle acht de uitgangen. Koppel meerdere chips door en dezelfde 3 pinnen kunnen 16, 24 of zelfs 80 uitgangen aansturen.
In deze gids leer je de pinout van de 74HC595 (DS, SH_CP, ST_CP, OE, MR en Q7'), de interne opbouw die seriële data omzet in parallelle uitgangen, de Arduino-functie shiftOut() en het verschil tussen de bitvolgorde MSBFIRST en LSBFIRST. Daarna bouw je een binaire teller, een looplicht, een keten van 16 LED's en een 7-segmentdisplay, en stuur je dezelfde schakeling tientallen keren sneller aan met hardware-SPI. De laatste delen gaan over code voor ESP32 en Raspberry Pi Pico (MicroPython), de stroomlimieten van de chip en oplossingen voor de meest voorkomende latchfouten.
Wat is de 74HC595 en hoe werkt hij?
In de chip zitten twee 8-bits registers die achter elkaar zijn geschakeld. Het eerste is het schuifregister: bij elke stijgende flank op de SH_CP-pin (klok) gaat de 0 of 1 die op de DS-pin staat de eerste cel in en schuiven de bits die al binnen zijn één plaats op. Na acht klokpulsen zitten alle acht bits die je hebt gestuurd erin. Het tweede is het opslagregister (latch): bij een stijgende flank op de ST_CP-pin worden de acht bits uit het schuifregister in één keer naar dit register gekopieerd en verschijnen ze op de uitgangen Q0–Q7. Dankzij dit ontwerp met twee trappen knipperen de LED's niet terwijl de bits schuiven; de uitgangen veranderen pas als je de latchpin activeert.
Zie het als een treinstation: de wagons (bits) rollen op één spoor achter elkaar het perron op, maar de deuren gaan pas open als de trein helemaal stilstaat, en alle passagiers stappen op hetzelfde moment uit. Het openen van de deuren is de taak van de latchpin. Omdat data serieel binnenkomt en parallel naar buiten gaat, heet de 74HC595 ook een SIPO-register (serial-in, parallel-out). Zijn broertje dat het omgekeerde doet, waarmee je 8 knoppen over één lijn uitleest, is de 74HC165 (PISO). Beide horen bij de 74-serie logica; de poorten en chipnummers van deze familie vind je in de tool Logische poorten.
| Eigenschap | Waarde |
|---|---|
| Type | 8-bits schuifregister met seriële ingang en parallelle uitgang (SIPO) + 8-bits opslagregister |
| Voedingsspanning (VCC) | 2–6 V (74HCT595: 4,5–5,5 V) |
| Behuizing | DIP-16 (past op een breadboard), SOIC-16, TSSOP-16 |
| Uitgangsstroom | Ongeveer 6 mA per uitgang (testwaarde uit de datasheet bij 4,5 V) |
| Absolute limieten | ±35 mA per uitgang; in totaal ±70 mA door de VCC- of GND-pin |
| Maximale klokfrequentie | Gegarandeerd tot 25 MHz bij 4,5 V, 5 MHz bij 2 V |
| HIGH-ingangsdrempel (VIH) | Minimaal 3,15 V bij een voeding van 4,5 V (ongeveer 0,7 × VCC) |
| Uitgangstype | 3-state; als OE HIGH is, zweven Q0–Q7 |
Pinout van de 74HC595
De halvemaanvormige inkeping of het kleine puntje op de chip markeert pin 1. Met de inkeping boven en de chip van bovenaf bekeken lopen pin 1–8 langs de linkerkant naar beneden en pin 9–16 langs de rechterkant omhoog. Fabrikanten geven de pinnen verschillende namen: NXP en de meeste Arduino-bronnen gebruiken DS, SH_CP en ST_CP, terwijl Texas Instruments SER, SRCLK en RCLK gebruikt. De tabel hieronder toont beide. OE en MR zijn actief-LOW ingangen: ze doen hun werk als ze LOW zijn, en datasheets tonen ze met een streep boven de naam.
| Pin | NXP-naam | TI-naam | Functie | Aansluiten op |
|---|---|---|---|---|
| 15, 1–7 | Q0, Q1–Q7 | QA, QB–QH | Parallelle uitgangen (Q0 op pin 15, Q1–Q7 op pin 1–7) | LED's via weerstanden |
| 8 | GND | GND | Massa | GND |
| 9 | Q7' | QH' | Seriële uitgang: het laatste bit van het schuifregister | DS-pin van de volgende 74HC595 (keten) |
| 10 | MR | SRCLR | Wist het schuifregister (actief LOW) | VCC |
| 11 | SH_CP | SRCLK | Schuifklok; neemt 1 bit op bij de stijgende flank | Arduino D13 (SCK) |
| 12 | ST_CP | RCLK | Latch; kopieert de data naar de uitgangen bij de stijgende flank | Arduino D10 |
| 13 | OE | OE | Schakelt de uitgangen in (actief LOW) | GND (of een PWM-pin voor helderheid) |
| 14 | DS | SER | Seriële data-ingang | Arduino D11 (MOSI) |
| 16 | VCC | VCC | Voeding | 5V (3,3 V bij ESP32 en Pico) |
Bedrading naar Arduino Uno, ESP32 en Pico
Alle Arduino-voorbeelden in deze gids gebruiken dezelfde schakeling. Door vanaf het begin de hardware-SPI-pinnen (D11 en D13) te kiezen voor de data- en klokdraad, hoef je later geen enkele draad te verplaatsen als je de code naar SPI omzet. Het lange pootje (anode) van elke LED gaat naar een uitgang en het korte pootje (kathode) gaat via een weerstand naar GND. Vergeet niet een keramische condensator van 100 nF tussen de VCC- en GND-pin van de chip te plaatsen, zo dicht mogelijk bij de chip; die vlakt de korte spanningsdips af als veel LED's tegelijk schakelen en voorkomt willekeurige storingen. Je kunt de SPI-pinnen van je board ook opzoeken in de tool Pinout.
| 74HC595-pin | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| DS (14) | D11 | GPIO 23 | GP19 |
| SH_CP (11) | D13 | GPIO 18 | GP18 |
| ST_CP (12) | D10 | GPIO 5 | GP17 |
| OE (13) | GND | GND | GND |
| MR (10) | 5V | 3V3 | 3V3(OUT) |
| VCC (16) | 5V | 3V3 | 3V3(OUT) |
| GND (8) | GND | GND | GND |
| Q0–Q7 | LED + 470 Ω | LED + 220 Ω | LED + 220 Ω |
De functie shiftOut() en de bitvolgorde (MSBFIRST / LSBFIRST)
De eenvoudigste manier om data naar een 74HC595 te sturen op Arduino is de ingebouwde functie shiftOut(dataPin, clockPin, bitOrder, value). Die schrijft de acht bits van de bytewaarde na elkaar naar de datapin en zet na elk bit de klokpin HIGH en daarna LOW; de 74HC595 neemt het bit precies op die stijgende flank op. shiftOut() raakt de latchpin niet aan, dus je moet ST_CP vóór het sturen LOW zetten en erna HIGH. Omdat de functie op stijgende flanken leunt, moet de klokpin ook vóór de aanroep LOW zijn; anders kan het eerste bit gemist worden.
De parameter bitOrder bepaalt vanaf welk uiteinde de bits worden verstuurd. Het eerst verstuurde bit komt na acht verschuivingen aan het verre uiteinde, Q7, terecht, terwijl het laatst verstuurde bit op Q0 blijft staan. Bij MSBFIRST gaat het meest significante bit (bit 7) eerst, zodat elk bit van de byte op de uitgang met hetzelfde nummer landt: bit 0 op Q0, bit 7 op Q7. Bij LSBFIRST is de volgorde omgekeerd en verschijnt bit 0 op Q7 en bit 7 op Q0. Alle voorbeelden in deze gids gebruiken MSBFIRST, zodat de bits van het getal in de code één op één overeenkomen met de LED-nummers. Wil je binaire getallen en de 0b-notatie opfrissen, lees dan de gids getalsystemen en bitbewerkingen.
| Verstuurde waarde | Uitgangen aan met MSBFIRST | Uitgangen aan met LSBFIRST |
|---|---|---|
| 0b00000001 (1) | Q0 | Q7 |
| 0b10000000 (128) | Q7 | Q0 |
| 0b00001111 (15) | Q0, Q1, Q2, Q3 | Q4, Q5, Q6, Q7 |
| 0b10100101 (165) | Q0, Q2, Q5, Q7 | Q0, Q2, Q5, Q7 (symmetrisch patroon) |
Stap voor stap: een binaire teller met 8 LED's
- Plaats de 74HC595 over de opening in het midden van het breadboard, zodat de twee rijen pootjes aan weerszijden komen te liggen. Weet je niet zeker hoe een breadboard van binnen is verbonden, lees dan eerst Wat is een breadboard?.
- Sluit VCC (pin 16) en MR (pin 10) aan op 5V, en GND (pin 8) en OE (pin 13) op GND. Plaats de condensator van 100 nF tussen VCC en GND.
- Sluit DS (14) aan op D11, SH_CP (11) op D13 en ST_CP (12) op D10.
- Sluit de lange pootjes van acht LED's aan op de uitgangen Q0–Q7 en hun korte pootjes via weerstanden van 470 Ω op GND. Onthoud dat Q0 pin 15 is.
- Upload de onderstaande code. De LED's moeten binair van 0 tot 255 tellen; de LED op Q0 moet het snelst knipperen en die op Q7 het langzaamst.
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}Het hart van de code is de functie write595(): die zet de latch LOW, stuurt acht bits met shiftOut() en zet de latch HIGH om ze in één keer naar de uitgangen te kopiëren. Daarom knipperen de LED's ook niet: terwijl de bits schuiven, behouden de uitgangen hun oude waarde. Als n 5 (0b00000101) is, lichten de LED's op Q0 en Q2 op; bij 200 (0b11001000) lichten de LED's op Q3, Q6 en Q7 op. Op de Uno kan het zijn dat de ingebouwde L-LED op D13 zwak meeflikkert met het kloksignaal; dat is normaal en heeft geen invloed op de schakeling.
Looplicht en Knight Rider-effect

Voor een looplicht hoef je bij elke stap maar één bit op 1 te zetten. De Arduino-macro bit(i) levert een getal op waarin alleen bit i 1 is: bit(0) is 1, bit(3) is 8 en bit(7) is 128. De onderstaande code speelt drie effecten achter elkaar af: een enkele LED die van Q0 naar Q7 loopt, een heen-en-weer Knight Rider-scanner en een balk die steeds verder vol raakt. Om het te vergelijken met de klassieke versie die direct op de pinnen is aangesloten, zie Arduino Knight Rider en looplicht; daar gebruikt elke LED een eigen pin, hier zijn 3 pinnen in totaal genoeg.
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}In het Knight Rider-deel loopt de voorwaartse lus van 0 tot 6 en de achterwaartse lus van 7 tot 1, zodat de LED's aan de uiteinden niet twee keer achter elkaar oplichten en de beweging vloeiend oogt. In de vullende balk voegt de bewerking |= (bitwise OR) een nieuwe LED toe terwijl de vorige blijven branden; dit is de basis van een ledbalk die de waarde van een potentiometer of sensor toont. Omdat de code delay() gebruikt, kan de Arduino niets anders doen zolang het effect loopt. Wil je tijdens het effect een knop uitlezen of de snelheid live aanpassen, regel de timing dan met millis(); de methode vind je in de gids millis() versus delay().
Meerdere 74HC595's doorkoppelen (Q7')
Pin 9 van de chip, Q7' (QH'), geeft het bit uit dat uit het schuifregister overloopt. Sluit hem aan op de DS-ingang van een tweede 74HC595 en de twee chips gedragen zich als één 16-bits register. De lijnen SH_CP en ST_CP worden door alle chips gedeeld, dus of de keten nu drie of tien chips heeft, er komen nog steeds maar 3 draden van de Arduino. Elke nieuwe byte die je stuurt duwt de vorige naar de volgende chip. Daarom komt de eerste byte die je stuurt in de laatste chip van de keten terecht, terwijl de laatste byte die je stuurt in de eerste chip blijft, die met de Arduino is verbonden. Als de latch afgaat, worden de uitgangen van alle chips tegelijk bijgewerkt.
| Verbinding | Chip 1 | Chip 2 |
|---|---|---|
| DS (14) | Arduino D11 | Q7' (pin 9) van chip 1 |
| SH_CP (11) | Arduino D13 | Arduino D13 (gedeeld) |
| ST_CP (12) | Arduino D10 | Arduino D10 (gedeeld) |
| Q7' (9) | Naar de DS-pin van chip 2 | Niet aangesloten of naar de DS-pin van chip 3 |
| OE (13) / MR (10) | GND / 5V | GND / 5V |
| Uitgangen | LED's 0–7 | LED's 8–15 |
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() en lowByte() splitsen het 16-bits getal in twee bytes. De hoge byte wordt als eerste verstuurd, reist dus naar de laatste chip in de keten en bestuurt LED 8–15, terwijl de lage byte in de eerste chip blijft. Om een derde chip toe te voegen, stuur je gewoon nog een byte, opnieuw beginnend met de chip die het verst weg zit; bij veel chips is het netter om de bytes in een array te bewaren en in een lus te versturen. Een keten heeft theoretisch geen limiet, maar elke chip maakt de update langer en belast de gedeelde klokdraad meer. Geef in lange ketens elke chip een eigen condensator van 100 nF, houd de klok- en latchdraden kort en versterk de klok, als de lijn erg lang wordt, met een bufferchip zoals de 74HC244.
Een 7-segmentdisplay aansturen met een 74HC595

Een 7-segmentdisplay met één cijfer bevat precies acht LED's: zeven segmenten van a tot g en één punt (dp). Dat betekent dat de acht uitgangen van één 74HC595 perfect passen bij één cijfer. Sluit Q0 aan op segment a, Q1 op b enzovoort, zodat Q6 op g en Q7 op dp uitkomt; bit 0 van de byte staat dan voor segment a en bit 6 voor segment g. De tabel hieronder toont de bedrading voor een gangbaar display met 10 pinnen en gemeenschappelijke kathode. De gemeenschappelijke pinnen (3 en 8) gaan naar GND en elk segment krijgt een eigen weerstand van 470 Ω. De indeling van de segmentletters en het verschil tussen gemeenschappelijke anode en gemeenschappelijke kathode vind je uitgebreid in de gids over het 7-segmentdisplay.
| 74HC595-uitgang | Segment | Displaypin |
|---|---|---|
| Q0 (15) | a | 7 |
| Q1 (1) | b | 6 |
| Q2 (2) | c | 4 |
| Q3 (3) | d | 2 |
| Q4 (4) | e | 1 |
| Q5 (5) | f | 9 |
| Q6 (6) | g | 10 |
| Q7 (7) | dp | 5 |
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}Bij een display met gemeenschappelijke anode gaan de gemeenschappelijke pinnen naar 5V en licht een segment op als de uitgang LOW is. Zet je COMMON_ANODE in de code op true, dan keert de operator ~ alle bits om en blijft dezelfde tabel werken. Voor een teller met twee cijfers voeg je een tweede 74HC595 aan de keten toe en stuur je eerst het patroon voor het verste cijfer en daarna dat voor het cijfer dat het dichtst bij de Arduino zit. Bij deze methode heeft elk cijfer een eigen chip, dus multiplexen is niet nodig, het display knippert nooit en het gebruik van delay() in loop() is geen probleem. Voor vier of meer cijfers kun je multiplexen met twee 74HC595's of overstappen op TM1637- of MAX7219-drivers die het scannen zelf doen.
Snel aansturen met SPI
shiftOut() is traag omdat elk bit apart met digitalWrite() wordt geschreven: op een Arduino Uno duurt het versturen van één byte ongeveer 100 µs. Bij een paar LED's merk je dat niet, maar het schiet tekort als je een keten van 10 chips duizenden keren per seconde wilt bijwerken, de LED-helderheid via software wilt regelen of een gemultiplexte ledkubus wilt scannen. Het goede nieuws is dat het protocol van de 74HC595 eigenlijk gewoon SPI is: DS komt overeen met MOSI, SH_CP met SCK en ST_CP met de chip-select-pin (CS). De hardware-SPI-eenheid van de Uno verstuurt een byte in ongeveer 1 µs bij 8 MHz; zelfs met de overhead van de functieaanroep is dat tientallen keren sneller dan shiftOut(). Hoe SPI werkt, leer je in de gids Wat is 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}In SPI_MODE0 wordt data bemonsterd bij de stijgende flank van de klok, en zo werkt de 74HC595 ook. MSBFIRST stuurt bit 7 weer naar Q7, dus de patronen uit de eerdere voorbeelden werken ongewijzigd. Op de Uno moet D10 een uitgang zijn zodat de hardware-SPI in mastermodus blijft; SPI.begin() regelt dit al, en daarom is D10 ook de beste pin voor de latch. Heeft de keten meer dan één chip, roep dan gewoon SPI.transfer() één keer per chip aan tussen latch LOW en HIGH. MISO (D12) wordt in deze schakeling niet gebruikt en blijft vrij voor een ander SPI-apparaat.
Helderheid met OE en wissen met MR
De OE-pin (output enable) is een schakelaar die alle uitgangen in één keer aan- of uitzet. Sluit je hem in plaats van op GND aan op een van de PWM-pinnen van de Uno, zoals D9, dan kun je de helderheid van alle LED's samen regelen met PWM. Omdat OE actief-LOW is, is de logica omgekeerd: analogWrite(9, 0) betekent volle helderheid en analogWrite(9, 255) betekent helemaal uit. Met analogWrite(9, 255 - brightness) in je code is dit makkelijker te doen. Deze methode werkt voor alle LED's gelijk; om de helderheid van elke LED afzonderlijk in te stellen, moet je het in software doen met snelle SPI-updates of overstappen op adresseerbare LED's zoals de WS2812B.
Als de MR-pin (master reset) LOW wordt, worden alle bits in het schuifregister gewist, maar de uitgangen gaan niet meteen uit omdat het opslagregister zijn oude waarde behoudt. Om ook de uitgangen uit te zetten, moet je een stijgende flank naar de latchpin sturen terwijl MR LOW is. In de praktijk bespaart het rechtstreeks aansluiten van MR op VCC en wissen in software met write595(0) zowel een pin als een draad. Er is ook het opstartprobleem: zodra er spanning komt, begint het opslagregister met een willekeurige waarde en kunnen de LED's heel even door elkaar oplichten. Op een relaisboard kan dat gevaarlijk zijn; om dit te voorkomen trek je OE met 10 kΩ omhoog naar VCC, roep je eerst write595(0) aan in setup() en zet je daarna de OE-pin LOW.
74HC595 met ESP32: 3,3 V en SPI
De pinnen van de ESP32 geven 3,3 V af. Voed je de 74HC595 met 5 V, dan heeft een ingang ongeveer 0,7 × VCC, oftewel 3,5 V, nodig om als HIGH te tellen; 3,3 V valt onder die drempel en de werking wordt onbetrouwbaar. De schoonste oplossing is de chip ook te voeden vanaf de 3V3-pin van de ESP32, want de 74HC595 werkt vanaf 2 V. Moet je de chip echt met 5 V voeden, gebruik dan de 74HCT595, waarvan de ingangen alles boven 2 V als HIGH zien, of zet er een niveauconverter tussen. Bij 3,3 V is 220 Ω geschikt voor rode, gele en groene LED's, terwijl blauwe en witte LED's, met een doorlaatspanning rond 3 V, bij 3,3 V erg zwak branden.
Het onderstaande voorbeeld gebruikt de VSPI-pinnen van de ESP32 (SCK op GPIO 18, MOSI op GPIO 23) om een Knight Rider-effect af te spelen op 16 LED's die zijn aangesloten op twee doorgekoppelde 74HC595's; GPIO 5 dient als latch. De SPI-snelheid is ingesteld op 4 MHz omdat de snelheidslimiet van de 74HC595 meedaalt met de voedingsspanning, en 4 MHz laat bij 3,3 V een ruime veiligheidsmarge. shiftOut() werkt ook op de ESP32 en is dankzij de processor van 240 MHz veel sneller dan op de Uno; toch maakt SPI de processor vrij voor taken zoals Wi-Fi. Voor de basis van het board en veilige pinkeuzes, zie Wat is de 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 met Raspberry Pi Pico en MicroPython
Voed de 74HC595 op de Pico ook vanaf de 3V3(OUT)-pin. MicroPython heeft geen kant-en-klaar equivalent van Arduino's shiftOut(), maar hardware-SPI regelt het makkelijk: de pinnen GP18 (SCK) en GP19 (MOSI) van de SPI0-eenheid worden gebruikt, en elke GPIO kan de latch zijn; hier is dat GP17. MicroPython reserveert ook de MISO-pin van SPI0 (GP16) voor SPI, dus sluit die niet op iets anders aan. Geef je meerdere bytes mee aan spi.write(), dan werk je alle chips in de keten in één keer bij, en ook hier gaat de eerste byte naar de chip die het verst weg zit. Voor de installatie en eerste stappen, zie Wat is de 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)Grotere belastingen: transistors, ULN2803 en TPIC6B595
De uitgangen van de 74HC595 zijn alleen geschikt voor kleine LED-stromen. Sluit belastingen zoals een relaisspoel (70–90 mA), een kleine motor, meerdere buzzers of een ledstrip van 12 V niet rechtstreeks aan. Je kunt achter elke uitgang een NPN-transistor zetten, of de ULN2803 gebruiken, die acht darlingtontransistors in één behuizing heeft: hij schakelt tot 500 mA per kanaal aan de GND-kant en heeft ingebouwde beschermdiodes voor inductieve belastingen; om die te laten werken, sluit je zijn COM-pin aan op de voeding van de belasting. Een nettere oplossing is de TPIC6B595, die precies als de 74HC595 wordt geprogrammeerd maar krachtige open-drain-uitgangen heeft: hij draagt continu 150 mA per uitgang en kan belastingen tot 50 V schakelen. Hij heeft 20 pinnen, dus zijn pinout is anders, en je sluit de belastingen aan tussen de positieve voeding en de uitgang.
74HC595, MAX7219 of TM1637?
| Eigenschap | 74HC595 | MAX7219 | TM1637 | WS2812B |
|---|---|---|---|---|
| Stuurpinnen | 3 (DS, SH_CP, ST_CP) | 3 (DIN, CLK, CS) | 2 (CLK, DIO) | 1 (DIN) |
| Uitgangen | 8 per chip, doorkoppelbaar | 64 LED's (8 cijfers of een 8x8-matrix) | 7-segment met 4–6 cijfers | Elke LED afzonderlijk adresseerbaar |
| Stroombegrenzing | Een weerstand voor elke LED | Eén weerstand (RSET) voor alle LED's | Ingebouwd in de module | In de LED zelf |
| Helderheid | Globale PWM via OE | 16 niveaus, via software | 8 niveaus | 256 niveaus per kleurkanaal |
| Het best voor | Ledbalken, relaisboards, algemene uitgangen | Ledmatrices, displays met meerdere cijfers | Klokken, tellers | Kleurrijke effecten, strips |
Heb je een eenvoudige ledbalk, een relaisboard met 8 kanalen of digitale uitgangen die elk een andere taak hebben nodig, dan is de 74HC595 de goedkoopste en meest flexibele keuze. Voor 8x8-ledmatrices of displays met meerdere cijfers maakt de MAX7219, die het multiplexen zelf regelt, het leven een stuk makkelijker. Wil je kleurrijke, individueel aangestuurde lichtjes, dan werken WS2812B NeoPixel-LED's met één datapin.
Projectideeën met de 74HC595
- Knight Rider met 16 LED's: Bouw het heen-en-weer-effect met twee doorgekoppelde chips en pas de snelheid aan met een potentiometer.
- Ledbalk als niveaumeter: Toon een sensorwaarde of geluidsniveau op een balk van 8–16 LED's.
- Parkeersensor: Laat meer LED's oplichten, van groen naar rood, naarmate de met een HC-SR04 gemeten afstand kleiner wordt.
- Scorebord met twee cijfers: Bouw een teller met knoppen die niet knippert, met twee 7-segmentdisplays en twee doorgekoppelde chips.
- Binaire klok: Toon uren, minuten en seconden als binaire getallen in kolommen LED's, waarbij je de tijd haalt uit een RTC-klokmodule.
- 3x3x3-ledkubus: Maak 3D-animaties door de lagen met transistors en de kolommen met 74HC595's aan te sturen; de details staan in de gids Arduino-ledkubus.
- Relaisboard met 8 kanalen: Bestuur acht relais met 3 pinnen via een ULN2803 of TPIC6B595.
Veelgemaakte fouten en hoe je ze oplost
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| Geen enkele LED licht op | OE zweeft of is HIGH, MR zit vast op LOW | Sluit OE aan op GND en MR op VCC |
| De LED's veranderen nooit | De latch (ST_CP) wordt nooit geactiveerd of zit op de verkeerde pin | Zet de latch na shiftOut() van LOW naar HIGH en controleer het pinnummer |
| LED's knipperen tijdens het schuiven of het patroon is één bit verschoven | SH_CP en ST_CP zijn aan elkaar gekoppeld; het schuifregister loopt dan altijd één klokpuls voor op het opslagregister | Gebruik een aparte pin voor de latch en zet hem pas HIGH nadat alle bytes zijn verstuurd |
| De LED's lichten in omgekeerde volgorde op | Bitvolgorde verwisseld of Q0 op de verkeerde plek | Wissel MSBFIRST en LSBFIRST om en controleer of Q0 op pin 15 zit |
| Chips in de keten zijn verwisseld of één loopt een stap achter | Bytes in de verkeerde volgorde verstuurd, of DS van chip 2 is aangesloten op Q7 (pin 7) in plaats van op Q7' | Stuur de byte van de verste chip eerst en sluit DS aan op pin 9 |
| Als veel LED's branden, worden ze allemaal zwakker en wordt de chip warm | De totale stroom overschrijdt de limiet van 70 mA | Gebruik weerstanden van 470 Ω–1 kΩ of een ULN2803 / TPIC6B595 |
| LED's flitsen willekeurig en veranderen als je de draden aanraakt | Geen condensator, lange draden of een zwevende ingang | Voeg 100 nF toe tussen VCC en GND, kort de draden in en laat OE of MR nooit zweven |
| Onbetrouwbaar met een ESP32 of Pico | De chip wordt gevoed met 5 V en het signaal van 3,3 V wordt niet als HIGH gezien | Voed de chip vanaf 3V3 of gebruik een 74HCT595 |
De 74HC595 is de goedkoopste en leerzaamste manier om een tekort aan pinnen op te lossen. Als je het idee van schuiven en latchen eenmaal begrijpt, herken je het in SPI-apparaten, drivers voor ledmatrices en displaymodules, en bij het uitlezen van knoppen met een 74HC165. Begin met de teller met 8 LED's, laat daarna de keten groeien en stap over op SPI. In de BlueGrays-app vind je projecten met looplicht, Knight Rider, een effect met regelbare snelheid en een 7-segmentteller voor Arduino, ESP32 en Raspberry Pi Pico, stap voor stap met schakelschema's en code.
Veelgestelde vragen
Waarvoor wordt de 74HC595 gebruikt?
De 74HC595 is een schuifregister dat seriële data van een microcontroller omzet in 8 parallelle uitgangen. Hiermee bestuur je 8 LED's, een 7-segmentdisplay of, via transistors, relais met slechts 3 Arduino-pinnen. Door chips door te koppelen krijg je met dezelfde 3 pinnen 16, 24 of meer uitgangen.
Hoeveel 74HC595's kun je doorkoppelen?
Er is geen theoretische limiet: de Q7'-uitgang van elke chip gaat naar de DS-ingang van de volgende chip, en de klok- en latchlijnen worden gedeeld. In de praktijk wordt de limiet bepaald door de updatetijd en de belasting van de gedeelde klokdraad; op de Uno voegt shiftOut() ongeveer 100 µs per chip toe, terwijl het met SPI daalt tot een paar microseconden. Geef in lange ketens elke chip een condensator van 100 nF en houd de draden kort.
Hoeveel stroom kan een uitgang van de 74HC595 leveren?
De datasheet garandeert de uitgangsspanningen bij 6 mA per uitgang; de absolute limiet is 35 mA per uitgang en in totaal 70 mA door de VCC- of GND-pin. Omdat alle acht LED's tegelijk aan kunnen staan, is mikken op 6–8 mA per LED veilig. Bij 5 V komt dat overeen met een weerstand van ongeveer 470 Ω.
Werkt de 74HC595 met een ESP32 op 3,3 V?
Ja. De 74HC595 werkt op 2 tot 6 V, dus hij kan worden gevoed vanaf de 3V3-pin van een ESP32 of Pico en leest signalen van 3,3 V zonder problemen. Voed je de chip met 5 V, dan kunnen signalen van 3,3 V onder de HIGH-drempel vallen; gebruik in dat geval een 74HCT595 of een niveauconverter.
Wat doet de latchpin op een 74HC595?
De latchpin (ST_CP of RCLK) is de trigger die de bits die je in het schuifregister hebt geschoven naar de uitgangen kopieert. Terwijl de bits schuiven, behouden de uitgangen hun oude waarde; als er een stijgende flank op de latchpin komt, worden alle acht de uitgangen tegelijk bijgewerkt. Zo knipperen de LED's niet terwijl er data wordt verstuurd en veranderen alle chips in een keten in één keer.
Kan een 74HC595 een relais of een motor aansturen?
Niet rechtstreeks; zijn uitgangen zijn alleen geschikt voor LED-stromen van een paar milliampère. Voeg voor relais, motoren of ledstrips een transistor toe aan elke uitgang of gebruik een ULN2803, die tot 500 mA per kanaal kan schakelen. De TPIC6B595, op dezelfde manier geprogrammeerd, is een krachtig alternatief dat 150 mA per uitgang kan voeren.
Projecten om hierna te bouwen
Alle projecten bekijken
LED-looplicht
Lichten die na elkaar aangaan, alsof ze rennen. De Arduino laat zes LED's een voor een branden; elke LED licht even op en gaat uit, zodat het licht van begin tot eind loopt en dan opnieuw begint.

Knight Rider-ledeffect
Het klassieke scannerlicht: een lichtpunt schuift van het ene uiteinde van zes LED's naar het andere en komt dan terug.

LED-looplicht met instelbare snelheid
Zes LED's gaan na elkaar aan, zodat het licht van het ene uiteinde naar het andere lijkt te rennen.

Knight Rider-ledeffect met instelbare snelheid
Een licht rent van het ene uiteinde van zes LED's naar het andere, draait om en rent weer terug.

ESP32 Knight Rider-ledlicht
6 leds die na elkaar van links naar rechts en van rechts naar links bewegen (Knight Rider-stijl). Een basisvoorbeeld van het gebruik van for-lussen en arrays. Leert je de logica van richtingswisseling.

Raspberry Pi Pico-looplicht (6 leds)
De klassieke "looplicht"-animatie met de Pico, versie met 6 leds! Zes leds gaan na elkaar aan van links naar rechts, alsof het licht langs de rij loopt. Je leert Python-lijsten (LED_PINS = [14, 13, 12, 11, 10, 9]), list comprehensions, pins aansturen met een for-lus en enumerate(). De zes leds komen op pin GP9-GP14, elk met een 220Ω-weerstand als stroombegrenzer.

Cijfers 0-9 tonen op een 7-segmentdisplay
Schrijf zelf die bekende cijfers die je in liften en digitale klokken ziet. Op een display van zeven kleine lichtbalkjes toont de Arduino elke seconde een cijfer van 0 tot 9 en begint daarna opnieuw.

Getallen van 0-99 tonen op een 7-segmentdisplay
Een display met twee cijfers, opgebouwd uit kleine streepjes zoals op een rekenmachine, telt van 0 tot 99.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

