74HC595 Arduino : registre à décalage pour 8+ LED sur 3 broches

Le 74HC595 est un circuit intégré à 16 broches, un registre à décalage (shift register) très bon marché qui te permet de commander 8 sorties indépendantes avec seulement 3 broches numériques de ton Arduino. Un Arduino Uno compte 20 broches utilisables, et elles s'épuisent vite dès que tu veux construire un effet K2000 à 16 LED, un tableau de score à deux chiffres ou une carte de 8 relais. Le 74HC595 règle le problème en recevant les données bit par bit sur une seule ligne : la puce range les bits les uns après les autres puis, quand tu lui dis que tu es prêt, les recopie en même temps sur ses huit sorties. En chaînant plusieurs puces, les mêmes 3 broches pilotent 16, 24, voire 80 sorties.

Dans ce guide, tu vas découvrir le brochage du 74HC595 (DS, SH_CP, ST_CP, OE, MR et Q7'), la structure interne qui transforme des données série en sorties parallèles, la fonction shiftOut() d'Arduino et la différence entre les ordres de bits MSBFIRST et LSBFIRST. Tu monteras ensuite un compteur binaire, un chenillard, une chaîne de 16 LED et un afficheur 7 segments, puis tu piloteras le même circuit des dizaines de fois plus vite avec le SPI matériel. Les dernières sections présentent le code pour ESP32 et Raspberry Pi Pico (MicroPython), les limites de courant de la puce et les solutions aux erreurs de latch les plus fréquentes.

Qu'est-ce que le 74HC595 et comment fonctionne-t-il ?

La puce contient deux registres de 8 bits placés l'un derrière l'autre. Le premier est le registre à décalage : à chaque front montant sur la broche SH_CP (horloge), le 0 ou le 1 présent sur la broche DS entre dans la première case et les bits déjà présents avancent d'une position. Après huit impulsions d'horloge, les huit bits envoyés sont à l'intérieur. Le second est le registre de stockage (latch) : sur un front montant de la broche ST_CP, les huit bits du registre à décalage y sont copiés d'un seul coup et apparaissent sur les sorties Q0–Q7. Grâce à cette structure en deux étages, les LED ne scintillent pas pendant le décalage des bits ; les sorties ne changent que lorsque tu déclenches la broche de latch.

Tu peux le comparer à une gare : les wagons (les bits) arrivent sur le quai les uns après les autres par une seule voie, mais les portes ne s'ouvrent qu'une fois le train complètement arrêté, et tous les passagers descendent en même temps. Ouvrir les portes, c'est le rôle de la broche de latch. Comme les données entrent en série et sortent en parallèle, on appelle aussi le 74HC595 un registre SIPO (serial-in, parallel-out). Son frère, qui fait l'inverse et te permet de lire 8 boutons sur une seule ligne, est le 74HC165 (PISO). Tous deux appartiennent à la famille logique de la série 74 ; tu peux consulter les portes et les références de cette famille dans l'outil Portes logiques.

Brochage du 74HC595 (pinout)

L'encoche en demi-lune ou le petit point sur la puce repère la broche 1. Encoche en haut et puce vue de dessus, les broches 1–8 descendent sur le côté gauche et les broches 9–16 remontent sur le côté droit. Les fabricants ne nomment pas les broches de la même façon : NXP et la plupart des ressources Arduino utilisent DS, SH_CP et ST_CP, tandis que Texas Instruments utilise SER, SRCLK et RCLK. Le tableau ci-dessous donne les deux. OE et MR sont des entrées actives à l'état bas : elles agissent lorsqu'elles sont à LOW, et les fiches techniques les représentent avec une barre au-dessus du nom.

Câblage avec Arduino Uno, ESP32 et Pico

Tous les exemples Arduino de ce guide utilisent le même circuit. Choisir dès le départ les broches du SPI matériel (D11 et D13) pour les lignes de données et d'horloge t'évite de déplacer le moindre fil quand tu passeras le code en SPI. La patte longue (anode) de chaque LED va sur une sortie, la patte courte (cathode) va au GND à travers une résistance. N'oublie pas un condensateur céramique de 100 nF entre les broches VCC et GND de la puce, le plus près possible de celle-ci ; il lisse les petites chutes de tension quand beaucoup de LED commutent en même temps et évite des erreurs aléatoires. Tu peux aussi vérifier les broches SPI de ta carte dans l'outil Pinout.

La fonction shiftOut() et l'ordre des bits (MSBFIRST / LSBFIRST)

Le plus simple pour envoyer des données au 74HC595 depuis Arduino est la fonction intégrée shiftOut(dataPin, clockPin, bitOrder, value). Elle écrit les huit bits de l'octet value l'un après l'autre sur la broche de données et, après chaque bit, met la broche d'horloge à HIGH puis à LOW ; le 74HC595 prend le bit précisément sur ce front montant. shiftOut() ne touche pas à la broche de latch : tu dois donc mettre ST_CP à LOW avant l'envoi et à HIGH après. Comme la fonction s'appuie sur les fronts montants, la broche d'horloge doit aussi être à LOW avant l'appel, sinon le premier bit risque d'être perdu.

Le paramètre bitOrder indique par quel bout les bits sont envoyés. Le premier bit envoyé se retrouve à l'autre extrémité, sur Q7, après huit décalages, tandis que le dernier reste sur Q0. Avec MSBFIRST, le bit de poids fort (bit 7) part en premier, si bien que chaque bit de l'octet arrive sur la sortie de même numéro : le bit 0 sur Q0, le bit 7 sur Q7. Avec LSBFIRST, l'ordre s'inverse et le bit 0 apparaît sur Q7, le bit 7 sur Q0. Tous les exemples de ce guide utilisent MSBFIRST, pour que les bits du nombre dans le code correspondent exactement aux numéros des LED. Si tu veux réviser les nombres binaires et la notation 0b, lis le guide sur les systèmes de numération et opérations bit à bit.

Pas à pas : un compteur binaire à 8 LED

1. Place le 74HC595 à cheval sur la rainure centrale de la breadboard, pour que les deux rangées de pattes se trouvent de part et d'autre. Si tu ne connais pas les connexions internes d'une breadboard, lis d'abord Qu'est-ce qu'une breadboard ?.
2. Relie VCC (broche 16) et MR (broche 10) au 5V, et GND (broche 8) et OE (broche 13) au GND. Place le condensateur de 100 nF entre VCC et GND.
3. Relie DS (14) à D11, SH_CP (11) à D13 et ST_CP (12) à D10.
4. Branche les pattes longues de huit LED sur les sorties Q0–Q7 et leurs pattes courtes au GND via des résistances de 470 Ω. N'oublie pas que Q0 est la broche 15.
5. Téléverse le code ci-dessous. Les LED doivent compter en binaire de 0 à 255 ; la LED de Q0 clignote le plus vite et celle de Q7 le plus lentement.

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}

Le cœur du code est la fonction write595() : elle met le latch à LOW, envoie huit bits avec shiftOut() puis met le latch à HIGH pour les recopier tous en même temps sur les sorties. C'est aussi pour cela que les LED ne scintillent pas : pendant le décalage, les sorties gardent leur ancienne valeur. Quand n vaut 5 (0b00000101), les LED de Q0 et Q2 s'allument ; à 200 (0b11001000), ce sont celles de Q3, Q6 et Q7. Sur l'Uno, tu verras peut-être la LED intégrée L de D13 frémir légèrement avec le signal d'horloge ; c'est normal et sans effet sur le circuit.

Chenillard et effet K2000

Pour un chenillard, il suffit de mettre un seul bit à 1 à chaque étape. La macro bit(i) d'Arduino produit un nombre dont seul le bit i vaut 1 : bit(0) vaut 1, bit(3) vaut 8 et bit(7) vaut 128. Le code ci-dessous enchaîne trois effets : une LED qui court de Q0 à Q7, un balayage aller-retour façon K2000 et une barre qui se remplit petit à petit. Pour comparer avec la version classique branchée directement sur les broches, consulte Chenillard et effet K2000 avec Arduino ; là-bas chaque LED utilise sa propre broche, ici 3 broches suffisent en tout.

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}

Dans la partie K2000, la boucle aller va de 0 à 6 et la boucle retour de 7 à 1 : ainsi, les LED des extrémités ne s'allument pas deux fois de suite et le mouvement paraît fluide. Dans la barre, l'opération |= (OU bit à bit) ajoute une nouvelle LED en laissant les précédentes allumées ; c'est la base d'un bargraphe à LED qui affiche la valeur d'un potentiomètre ou d'un capteur. Comme le code utilise delay(), l'Arduino ne peut rien faire d'autre pendant l'effet. Pour lire un bouton ou changer la vitesse en direct pendant l'effet, gère le temps avec millis() ; tu trouveras la méthode dans le guide millis() et delay().

Chaîner plusieurs 74HC595 (Q7')

La broche 9 de la puce, Q7' (QH'), fait sortir le bit qui déborde du registre à décalage. Relie-la à l'entrée DS d'un second 74HC595, et les deux puces se comportent comme un seul registre de 16 bits. Les lignes SH_CP et ST_CP sont communes à toutes les puces : qu'il y en ait trois ou dix dans la chaîne, seuls 3 fils partent toujours de l'Arduino. Chaque nouvel octet pousse le précédent vers la puce suivante. C'est pourquoi le premier octet envoyé atterrit dans la dernière puce de la chaîne, tandis que le dernier octet reste dans la première puce, celle reliée à l'Arduino. Au déclenchement du latch, les sorties de toutes les puces se mettent à jour en même temps.

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() et lowByte() découpent le nombre de 16 bits en deux octets. L'octet de poids fort part en premier : il voyage donc jusqu'à la dernière puce de la chaîne et commande les LED 8–15, tandis que l'octet de poids faible reste dans la première puce. Pour ajouter une troisième puce, il suffit d'envoyer un octet de plus, en commençant toujours par la puce la plus éloignée ; avec beaucoup de puces, il est plus propre de ranger les octets dans un tableau et de les envoyer avec une boucle. Une chaîne n'a pas de limite théorique, mais chaque puce allonge la mise à jour et charge davantage la ligne d'horloge commune. Dans les longues chaînes, donne à chaque puce son propre condensateur de 100 nF, garde des fils d'horloge et de latch courts et, si la ligne devient très longue, renforce l'horloge avec un tampon comme le 74HC244.

Piloter un afficheur 7 segments avec le 74HC595

Un afficheur 7 segments à un chiffre contient exactement huit LED : sept segments de a à g et un point (dp). Les huit sorties d'un 74HC595 correspondent donc parfaitement à un chiffre. Si tu relies Q0 au segment a, Q1 au b et ainsi de suite, Q6 tombe sur g et Q7 sur le point ; le bit 0 de l'octet représente alors le segment a et le bit 6 le segment g. Le tableau ci-dessous donne le câblage d'un afficheur courant à 10 broches et cathode commune. Les broches communes (3 et 8) vont au GND et chaque segment reçoit sa propre résistance de 470 Ω. La disposition des lettres des segments et la différence entre anode commune et cathode commune sont détaillées dans le guide Afficheur 7 segments avec 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}

Sur un afficheur à anode commune, les broches communes vont au 5V et un segment s'allume quand sa sortie est à LOW. Quand tu mets COMMON_ANODE à true dans le code, l'opérateur ~ inverse tous les bits et le même tableau continue de fonctionner. Pour un compteur à deux chiffres, ajoute un second 74HC595 à la chaîne et envoie d'abord le motif du chiffre le plus éloigné, puis celui du chiffre le plus proche de l'Arduino. Avec cette méthode, chaque chiffre a sa propre puce : pas besoin de multiplexage, l'afficheur ne scintille jamais et utiliser delay() dans loop() ne pose aucun problème. Pour quatre chiffres ou plus, tu peux multiplexer avec deux 74HC595 ou passer à des pilotes comme le TM1637 ou le MAX7219, qui gèrent le balayage tout seuls.

Pilotage rapide en SPI

shiftOut() est lente parce qu'elle écrit chaque bit séparément avec digitalWrite() : sur un Arduino Uno, envoyer un octet prend environ 100 µs. Avec quelques LED, ça ne se voit pas, mais ça ne suffit plus si tu veux rafraîchir une chaîne de 10 puces des milliers de fois par seconde, régler la luminosité des LED par logiciel ou balayer un cube de LED multiplexé. La bonne nouvelle, c'est que le protocole du 74HC595 est en fait du SPI : DS correspond à MOSI, SH_CP à SCK et ST_CP à la broche de sélection (CS). Le SPI matériel de l'Uno envoie un octet en environ 1 µs à 8 MHz ; même avec le coût des appels de fonction, il est des dizaines de fois plus rapide que shiftOut(). Tu peux découvrir le fonctionnement du SPI dans le guide Qu'est-ce que le 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}

En SPI_MODE0, les données sont lues sur le front montant de l'horloge, exactement comme le fait le 74HC595. MSBFIRST envoie toujours le bit 7 vers Q7, donc les motifs des exemples précédents fonctionnent sans changement. Sur l'Uno, D10 doit être une sortie pour que le SPI matériel reste en mode maître ; SPI.begin() s'en charge déjà, et c'est aussi pourquoi D10 est la meilleure broche pour le latch. Si la chaîne compte plusieurs puces, il suffit d'appeler SPI.transfer() une fois par puce entre le passage du latch à LOW et à HIGH. MISO (D12) n'est pas utilisée dans ce circuit et reste libre pour un autre périphérique SPI.

Luminosité avec OE et remise à zéro avec MR

La broche OE (output enable) est un interrupteur qui active ou coupe toutes les sorties d'un coup. Si tu la relies à l'une des broches PWM de l'Uno, par exemple D9, au lieu du GND, tu peux régler la luminosité de toutes les LED ensemble en PWM. Comme OE est active à LOW, la logique est inversée : analogWrite(9, 0) donne la luminosité maximale et analogWrite(9, 255) éteint tout. Écrire analogWrite(9, 255 - luminosite) dans ton code simplifie les choses. Cette méthode agit sur toutes les LED de la même façon ; pour régler la luminosité de chaque LED séparément, il faut le faire par logiciel avec des mises à jour SPI rapides ou passer à des LED adressables comme les WS2812B.

Quand la broche MR (master reset) passe à LOW, tous les bits du registre à décalage sont effacés, mais les sorties ne s'éteignent pas aussitôt, car le registre de stockage garde son ancienne valeur. Pour éteindre aussi les sorties, il faut envoyer un front montant sur la broche de latch pendant que MR est à LOW. En pratique, relier MR directement au VCC et effacer par logiciel avec write595(0) t'économise une broche et un fil. Reste la question de la mise sous tension : à l'allumage, le registre de stockage démarre avec une valeur aléatoire et les LED peuvent s'allumer un instant en désordre. Sur une carte de relais, cela peut être dangereux ; pour l'éviter, tire OE au VCC avec 10 kΩ, appelle d'abord write595(0) dans setup(), puis mets la broche OE à LOW.

74HC595 avec ESP32 : 3,3 V et SPI

Les broches de l'ESP32 délivrent 3,3 V. Si tu alimentes le 74HC595 en 5 V, une entrée a besoin d'environ 0,7 × VCC, soit 3,5 V, pour être vue comme HIGH ; 3,3 V reste en dessous de ce seuil et le fonctionnement devient instable. La solution la plus propre consiste à alimenter aussi la puce par la broche 3V3 de l'ESP32, puisque le 74HC595 fonctionne dès 2 V. Si tu dois absolument alimenter la puce en 5 V, utilise le 74HCT595, dont les entrées voient comme HIGH toute tension au-dessus de 2 V, ou ajoute un convertisseur de niveau logique. Sous 3,3 V, 220 Ω conviennent aux LED rouges, jaunes et vertes ; les LED bleues et blanches, dont la tension directe tourne autour de 3 V, éclairent très faiblement sous 3,3 V.

L'exemple ci-dessous utilise les broches VSPI de l'ESP32 (SCK sur GPIO 18, MOSI sur GPIO 23) pour jouer un effet K2000 sur 16 LED reliées à deux 74HC595 chaînés ; GPIO 5 sert de latch. La vitesse SPI est réglée sur 4 MHz, car la vitesse maximale du 74HC595 diminue avec la tension d'alimentation et 4 MHz laisse une large marge de sécurité sous 3,3 V. shiftOut() fonctionne aussi sur l'ESP32 et y est bien plus rapide que sur l'Uno grâce au processeur à 240 MHz ; utiliser le SPI libère quand même le processeur pour des tâches comme le Wi-Fi. Pour les bases de la carte et le choix de broches sûres, consulte Qu'est-ce que l'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 avec Raspberry Pi Pico et MicroPython

Sur la Pico, alimente aussi le 74HC595 par la broche 3V3(OUT). MicroPython n'a pas d'équivalent tout prêt de shiftOut() d'Arduino, mais le SPI matériel fait largement l'affaire : on utilise les broches GP18 (SCK) et GP19 (MOSI) de l'unité SPI0, et n'importe quel GPIO peut servir de latch ; ici, c'est GP17. MicroPython réserve aussi la broche MISO de SPI0 (GP16) pour le SPI, donc n'y branche rien d'autre. Si tu passes plusieurs octets à spi.write(), tu mets à jour toutes les puces de la chaîne en une fois, et là encore le premier octet va à la puce la plus éloignée. Pour l'installation et les premiers pas, consulte Qu'est-ce que la 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)

Charges plus fortes : transistor, ULN2803 et TPIC6B595

Les sorties du 74HC595 ne conviennent qu'à de petits courants de LED. Ne branche pas directement des charges comme une bobine de relais (70–90 mA), un petit moteur, plusieurs buzzers ou un ruban LED 12 V. Tu peux placer un transistor NPN derrière chaque sortie, ou utiliser l'ULN2803, qui réunit huit transistors Darlington dans un seul boîtier : il commute jusqu'à 500 mA par canal côté GND et intègre des diodes de protection pour les charges inductives ; pour qu'elles agissent, relie sa broche COM à l'alimentation de la charge. Une solution plus compacte est le TPIC6B595, qui se programme exactement comme le 74HC595 mais possède de puissantes sorties à drain ouvert : il supporte 150 mA en continu par sortie et peut commuter des charges jusqu'à 50 V. Il a 20 broches, donc un brochage différent, et les charges se branchent entre le positif et la sortie.

74HC595, MAX7219 ou TM1637 ?

S'il te faut une simple barre de LED, une carte de 8 relais ou des sorties numériques qui ont chacune leur rôle, le 74HC595 est le choix le moins cher et le plus souple. Pour les matrices de LED 8x8 ou les afficheurs à plusieurs chiffres, le MAX7219, qui gère seul le multiplexage, te simplifie beaucoup la vie. Si tu veux des lumières colorées commandées une par une, les LED WS2812B NeoPixel fonctionnent avec une seule broche de données.

Idées de projets avec le 74HC595

• K2000 à 16 LED : Monte l'effet aller-retour avec deux puces chaînées et règle sa vitesse avec un potentiomètre.
• Bargraphe de niveau : Affiche la valeur d'un capteur ou un niveau sonore sur une barre de 8 à 16 LED.
• Radar de recul : Allume de plus en plus de LED, du vert au rouge, à mesure que la distance mesurée par un HC-SR04 diminue.
• Tableau de score à deux chiffres : Réalise un compteur à boutons sans scintillement avec deux afficheurs 7 segments et deux puces chaînées.
• Horloge binaire : Affiche heures, minutes et secondes en binaire sur des colonnes de LED, en lisant l'heure sur un module horloge RTC.
• Cube de LED 3x3x3 : Crée des animations en 3D en pilotant les étages avec des transistors et les colonnes avec des 74HC595 ; tous les détails sont dans le guide Cube de LED Arduino.
• Carte de 8 relais : Commande huit relais avec 3 broches grâce à un ULN2803 ou un TPIC6B595.

Erreurs fréquentes et solutions

Le 74HC595 est la façon la moins chère et la plus formatrice de régler un manque de broches. Une fois l'idée du décalage et du latch comprise, tu la retrouves dans les périphériques SPI, les pilotes de matrices de LED et les modules d'affichage, et aussi pour lire des boutons avec un 74HC165. Commence par le compteur à 8 LED, puis allonge la chaîne et passe au SPI. Dans l'application BlueGrays, tu trouveras des projets de chenillard, d'effet K2000, d'effets à vitesse réglable et de compteurs 7 segments pour Arduino, ESP32 et Raspberry Pi Pico, pas à pas avec schémas et code.