Tutorial do 74HC595 com Arduino: registrador de deslocamento para 8+ LEDs com 3 pinos

O 74HC595 é um CI registrador de deslocamento barato, de 16 pinos, que permite controlar 8 saídas separadas usando só 3 pinos digitais do seu Arduino. Um Arduino Uno tem 20 pinos utilizáveis, e eles acabam rápido quando você tenta montar um Knight Rider com 16 LEDs, um placar de dois dígitos ou uma placa de relés de 8 canais. O 74HC595 resolve isso recebendo os dados bit a bit por uma única linha: o chip junta os bits que chegam um atrás do outro e, quando você avisa que está pronto, os copia para as oito saídas de uma vez. Ligue vários chips em cascata e os mesmos 3 pinos podem controlar 16, 24 ou até 80 saídas.

Neste guia você vai aprender a pinagem do 74HC595 (DS, SH_CP, ST_CP, OE, MR e Q7'), a estrutura interna que transforma dados seriais em saídas paralelas, a função shiftOut() do Arduino e a diferença entre as ordens de bits MSBFIRST e LSBFIRST. Depois vai montar um contador binário, um LED sequencial, uma cadeia de 16 LEDs e um display de 7 segmentos e acionar o mesmo circuito dezenas de vezes mais rápido com SPI por hardware. As seções finais trazem código para ESP32 e Raspberry Pi Pico (MicroPython), os limites de corrente do chip e soluções para os erros de latch mais comuns.

O que é o 74HC595 e como ele funciona?

Dentro do chip há dois registradores de 8 bits ligados um depois do outro. O primeiro é o registrador de deslocamento: a cada borda de subida no pino SH_CP (clock), o 0 ou 1 presente no pino DS entra na primeira célula e os bits que já estão dentro avançam uma posição. Depois de oito pulsos de clock, os oito bits que você enviou estão lá dentro. O segundo é o registrador de armazenamento (latch): em uma borda de subida no pino ST_CP, os oito bits do registrador de deslocamento são copiados para ele de uma vez e aparecem nas saídas Q0–Q7. Graças a esse projeto em dois estágios, os LEDs não piscam enquanto os bits estão sendo deslocados; as saídas só mudam quando você aciona o pino de latch.

Pense em uma estação de trem: os vagões (bits) chegam à plataforma um atrás do outro em um único trilho, mas as portas só abrem quando o trem para por completo, e todos os passageiros descem no mesmo instante. Abrir as portas é o trabalho do pino de latch. Como os dados entram em série e saem em paralelo, o 74HC595 também é chamado de registrador SIPO (entrada serial, saída paralela). O irmão que faz o contrário, permitindo ler 8 botões por uma linha, é o 74HC165 (PISO). Os dois pertencem à família lógica 74; você pode consultar as portas e os números de chips dessa família na ferramenta Portas lógicas.

Pinagem do 74HC595

O entalhe em meia-lua ou o pontinho no chip marca o pino 1. Com o entalhe para cima e olhando o chip de cima, os pinos 1–8 descem pelo lado esquerdo e os pinos 9–16 sobem pelo lado direito. Os fabricantes dão nomes diferentes aos pinos: a NXP e a maioria dos materiais de Arduino usam DS, SH_CP e ST_CP, enquanto a Texas Instruments usa SER, SRCLK e RCLK. A tabela abaixo lista os dois. OE e MR são entradas ativas em LOW, ou seja, fazem o seu trabalho quando estão em LOW, e os datasheets as mostram com uma barra sobre o nome.

Ligação com Arduino Uno, ESP32 e Pico

Todos os exemplos de Arduino deste guia usam o mesmo circuito. Escolher desde o início os pinos de SPI por hardware (D11 e D13) para as linhas de dados e clock significa que você não vai precisar mudar nenhum fio quando passar o código para SPI depois. A perna longa (ânodo) de cada LED vai a uma saída, e a perna curta (cátodo) vai ao GND através de um resistor. Não esqueça um capacitor cerâmico de 100 nF entre os pinos VCC e GND do chip, o mais perto possível dele; ele suaviza as pequenas quedas de tensão quando muitos LEDs mudam ao mesmo tempo e evita falhas aleatórias. Você também pode conferir os pinos SPI da sua placa na ferramenta Pinagem.

A função shiftOut() e a ordem dos bits (MSBFIRST / LSBFIRST)

A forma mais fácil de enviar dados a um 74HC595 no Arduino é a função embutida shiftOut(dataPin, clockPin, bitOrder, value). Ela escreve os oito bits do byte value no pino de dados, um atrás do outro, e, depois de cada bit, coloca o pino de clock em HIGH e depois em LOW; o 74HC595 recebe o bit exatamente nessa borda de subida. shiftOut() não mexe no pino de latch, então você precisa colocar o ST_CP em LOW antes de enviar e em HIGH depois. Como a função depende de bordas de subida, o pino de clock também deve estar em LOW antes da chamada; caso contrário, o primeiro bit pode se perder.

O parâmetro bitOrder define por qual ponta os bits são enviados. O primeiro bit enviado vai parar na ponta mais distante, Q7, depois de oito deslocamentos, enquanto o último bit enviado fica no Q0. Com MSBFIRST, o bit mais significativo (bit 7) vai primeiro, então cada bit do byte cai na saída de mesmo número: bit 0 no Q0, bit 7 no Q7. Com LSBFIRST a ordem se inverte, e o bit 0 aparece no Q7 e o bit 7 no Q0. Todos os exemplos deste guia usam MSBFIRST, então os bits do número no código correspondem um a um aos números dos LEDs. Se quiser revisar números binários e a notação 0b, leia o guia sistemas numéricos e operações com bits.

Passo a passo: um contador binário com 8 LEDs

1. Coloque o 74HC595 atravessando o vão no meio da protoboard, de modo que as duas fileiras de pernas fiquem em lados opostos. Se não tem certeza de como uma protoboard é ligada por dentro, leia antes O que é uma protoboard?.
2. Ligue VCC (pino 16) e MR (pino 10) ao 5V, e GND (pino 8) e OE (pino 13) ao GND. Coloque o capacitor de 100 nF entre VCC e GND.
3. Ligue DS (14) ao D11, SH_CP (11) ao D13 e ST_CP (12) ao D10.
4. Ligue as pernas longas de oito LEDs às saídas Q0–Q7 e as pernas curtas ao GND através de resistores de 470 Ω. Lembre-se de que o Q0 é o pino 15.
5. Carregue o código abaixo. Os LEDs devem contar de 0 a 255 em binário; o LED do Q0 deve piscar mais rápido e o do Q7, mais devagar.

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}

O coração do código é a função write595(): ela coloca o latch em LOW, envia oito bits com shiftOut() e coloca o latch em HIGH para copiar todos para as saídas de uma vez. É também por isso que os LEDs não piscam: enquanto os bits estão sendo deslocados, as saídas mantêm o valor antigo. Quando n vale 5 (0b00000101), acendem os LEDs do Q0 e do Q2; em 200 (0b11001000), acendem os LEDs do Q3, do Q6 e do Q7. No Uno, você pode notar o LED L embutido no D13 piscando fraquinho com o sinal de clock; isso é normal e não afeta o circuito.

LED sequencial e efeito Knight Rider

Para um LED sequencial, basta colocar um único bit em 1 a cada passo. A macro bit(i) do Arduino gera um número em que só o bit i é 1: bit(0) vale 1, bit(3) vale 8 e bit(7) vale 128. O código abaixo toca três efeitos seguidos: um único LED correndo do Q0 ao Q7, um Knight Rider de vaivém e uma barra que vai se enchendo. Para comparar com a versão clássica ligada direto nos pinos, veja Knight Rider e LED sequencial com Arduino; lá cada LED usa o seu próprio pino, aqui 3 pinos bastam no total.

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}

Na parte do Knight Rider, o laço de ida vai de 0 a 6 e o de volta, de 7 a 1, assim os LEDs das pontas não acendem duas vezes seguidas e o movimento fica suave. Na barra que se enche, a operação |= (OU bit a bit) acrescenta um novo LED mantendo os anteriores acesos; essa é a base de uma barra de LEDs que mostra o valor de um potenciômetro ou de um sensor. Como o código usa delay(), o Arduino não consegue fazer mais nada enquanto o efeito roda. Se quiser ler um botão ou mudar a velocidade ao vivo durante o efeito, faça a temporização com millis(); você encontra o método no guia millis() vs delay().

Como ligar vários 74HC595 em cascata (Q7')

O pino 9 do chip, Q7' (QH'), fornece o bit que transborda do registrador de deslocamento. Ligue-o à entrada DS de um segundo 74HC595 e os dois chips se comportam como um único registrador de 16 bits. As linhas SH_CP e ST_CP são compartilhadas por todos os chips, então, tenha a cadeia três chips ou dez, continuam saindo só 3 fios do Arduino. Cada byte novo que você envia empurra o anterior para o chip seguinte. Por isso o primeiro byte que você envia vai parar no último chip da cadeia, enquanto o último byte enviado fica no primeiro chip, o que está ligado ao Arduino. Quando o latch dispara, as saídas de todos os chips se atualizam ao mesmo tempo.

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() e lowByte() dividem o número de 16 bits em dois bytes. O byte alto é enviado primeiro, então ele viaja até o último chip da cadeia e controla os LEDs 8–15, enquanto o byte baixo fica no primeiro chip. Para acrescentar um terceiro chip, basta enviar mais um byte, de novo começando pelo chip mais distante; com muitos chips, é mais organizado guardar os bytes em um array e enviá-los em um laço. Uma cadeia não tem limite teórico, mas cada chip faz a atualização demorar mais e aumenta a carga na linha de clock compartilhada. Em cadeias longas, dê a cada chip o seu próprio capacitor de 100 nF, mantenha curtos os fios de clock e de latch e, se a linha ficar muito longa, reforce o clock com um chip buffer como o 74HC244.

Como acionar um display de 7 segmentos com um 74HC595

Um display de 7 segmentos de um dígito tem exatamente oito LEDs: sete segmentos, de a a g, e um ponto (dp). Ou seja, as oito saídas de um 74HC595 encaixam perfeitamente em um dígito. Ligue o Q0 ao segmento a, o Q1 ao b e assim por diante, e o Q6 fica no g e o Q7 no dp; o bit 0 do byte passa a representar o segmento a e o bit 6, o segmento g. A tabela abaixo mostra a ligação de um display comum de 10 pinos com cátodo comum. Os pinos comuns (3 e 8) vão ao GND, e cada segmento ganha o seu próprio resistor de 470 Ω. Você encontra em detalhe a disposição das letras dos segmentos e a diferença entre ânodo comum e cátodo comum no guia do display de 7 segmentos.

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}

Em um display de ânodo comum, os pinos comuns vão ao 5V e um segmento acende quando a saída dele está em LOW. Quando você coloca COMMON_ANODE em true no código, o operador ~ inverte todos os bits e a mesma tabela continua funcionando. Para um contador de dois dígitos, acrescente um segundo 74HC595 à cadeia e envie primeiro o padrão do dígito mais distante e depois o do dígito mais perto do Arduino. Com esse método, cada dígito tem o seu próprio chip, então não é preciso multiplexação, o display nunca pisca e usar delay() no loop() não é problema. Para quatro dígitos ou mais, você pode multiplexar com dois 74HC595 ou passar para drivers TM1637 ou MAX7219, que fazem a varredura sozinhos.

Acionamento rápido com SPI

shiftOut() é lento porque escreve cada bit separadamente com digitalWrite(): em um Arduino Uno, enviar um byte leva cerca de 100 µs. Você não percebe isso com poucos LEDs, mas não dá conta quando você quer atualizar uma cadeia de 10 chips milhares de vezes por segundo, controlar o brilho de LEDs por software ou varrer um cubo de LEDs multiplexado. A boa notícia é que o protocolo do 74HC595 na verdade é SPI: DS corresponde ao MOSI, SH_CP ao SCK e ST_CP ao pino de seleção do chip (CS). A unidade de SPI por hardware do Uno envia um byte em cerca de 1 µs a 8 MHz; mesmo com o custo da chamada de função, isso é dezenas de vezes mais rápido que shiftOut(). Você pode aprender como o SPI funciona no guia O que é 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}

No SPI_MODE0, os dados são amostrados na borda de subida do clock, exatamente como o 74HC595 funciona. MSBFIRST de novo envia o bit 7 para o Q7, então os padrões dos exemplos anteriores funcionam sem mudanças. No Uno, o D10 precisa ser saída para o SPI por hardware continuar no modo mestre; SPI.begin() já configura isso, e é também por isso que o D10 é o melhor pino para o latch. Se a cadeia tiver mais de um chip, basta chamar SPI.transfer() uma vez por chip entre o latch em LOW e em HIGH. O MISO (D12) não é usado neste circuito e fica livre para outro dispositivo SPI.

Brilho com OE e limpeza com MR

O pino OE (habilitação das saídas) é uma chave que liga ou desliga todas as saídas de uma vez. Se você o ligar a um dos pinos PWM do Uno, como o D9, em vez do GND, pode ajustar o brilho de todos os LEDs juntos com PWM. Como o OE é ativo em LOW, a lógica fica invertida: analogWrite(9, 0) significa brilho máximo e analogWrite(9, 255) significa totalmente apagado. Escrever analogWrite(9, 255 - brilho) no código facilita isso. Esse método afeta todos os LEDs por igual; para ajustar o brilho de cada LED individualmente, você precisa fazer isso por software com atualizações rápidas por SPI ou passar para LEDs endereçáveis como o WS2812B.

Quando o pino MR (reset geral) vai a LOW, todos os bits do registrador de deslocamento são apagados, mas as saídas não desligam na hora, porque o registrador de armazenamento mantém o valor antigo. Para desligar as saídas também, você precisa mandar uma borda de subida ao pino de latch enquanto o MR está em LOW. Na prática, ligar o MR direto ao VCC e limpar por software com write595(0) economiza um pino e um fio. Há também a questão da energização: quando a alimentação é aplicada, o registrador de armazenamento começa com um valor aleatório e os LEDs podem acender embaralhados por um instante. Em uma placa de relés isso pode ser perigoso; para evitar, puxe o OE para o VCC com 10 kΩ, chame write595(0) primeiro no setup() e depois coloque o pino OE em LOW.

74HC595 com ESP32: 3,3 V e SPI

Os pinos do ESP32 fornecem 3,3 V. Se você alimentar o 74HC595 com 5 V, uma entrada precisa de cerca de 0,7 × VCC, ou 3,5 V, para contar como HIGH; 3,3 V fica abaixo desse limite e o funcionamento fica instável. A solução mais limpa é alimentar o chip também pelo pino 3V3 do ESP32, já que o 74HC595 funciona a partir de 2 V. Se você realmente precisar alimentar o chip com 5 V, use o 74HCT595, cujas entradas entendem como HIGH qualquer valor acima de 2 V, ou coloque um conversor de nível lógico no meio. Em 3,3 V, 220 Ω serve para LEDs vermelhos, amarelos e verdes, enquanto LEDs azuis e brancos, com tensão direta perto de 3 V, ficam muito fracos em 3,3 V.

O exemplo abaixo usa os pinos VSPI do ESP32 (SCK no GPIO 18, MOSI no GPIO 23) para tocar um efeito Knight Rider em 16 LEDs ligados a dois 74HC595 em cascata; o GPIO 5 faz o papel de latch. A velocidade do SPI fica em 4 MHz porque o limite de velocidade do 74HC595 cai com a tensão de alimentação, e 4 MHz deixa uma boa margem de segurança em 3,3 V. shiftOut() também funciona no ESP32 e é bem mais rápido que no Uno graças ao processador de 240 MHz; mesmo assim, usar SPI libera o processador para tarefas como o Wi-Fi. Para o básico da placa e a escolha segura de pinos, veja O que é o 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 com Raspberry Pi Pico e MicroPython

No Pico, alimente o 74HC595 também pelo pino 3V3(OUT). O MicroPython não tem um equivalente pronto do shiftOut() do Arduino, mas o SPI por hardware dá conta do trabalho com facilidade: são usados os pinos GP18 (SCK) e GP19 (MOSI) da unidade SPI0, e qualquer GPIO pode ser o latch; aqui é o GP17. O MicroPython também reserva o pino MISO do SPI0 (GP16) para o SPI, então não ligue nada nele. Se você passar vários bytes para spi.write(), atualiza todos os chips da cadeia de uma vez, e de novo o primeiro byte vai para o chip mais distante. Para a configuração e os primeiros passos, veja O que é o 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)

Cargas maiores: transistores, ULN2803 e TPIC6B595

As saídas do 74HC595 só servem para correntes pequenas de LED. Não ligue direto cargas como a bobina de um relé (70–90 mA), um motor pequeno, vários buzzers ou uma fita de LED de 12 V. Você pode colocar um transistor NPN depois de cada saída ou usar o ULN2803, que reúne oito transistores Darlington em um encapsulamento: ele chaveia até 500 mA por canal no lado do GND e tem diodos de proteção embutidos para cargas indutivas; para que eles funcionem, ligue o pino COM à alimentação da carga. Uma solução mais organizada é o TPIC6B595, programado exatamente como o 74HC595, mas com saídas potentes de dreno aberto: ele aguenta 150 mA contínuos por saída e chaveia cargas de até 50 V. Ele tem 20 pinos, então a pinagem é diferente, e você liga as cargas entre o positivo da alimentação e a saída.

74HC595, MAX7219 ou TM1637?

Se você precisa de uma barra de LED simples, de uma placa de relés de 8 canais ou de saídas digitais que fazem cada uma um trabalho diferente, o 74HC595 é a escolha mais barata e flexível. Para matrizes de LED 8x8 ou displays de vários dígitos, o MAX7219, que cuida da multiplexação sozinho, facilita muito a vida. Se você quer luzes coloridas controladas individualmente, os LEDs WS2812B NeoPixel funcionam com um único pino de dados.

Ideias de projetos com 74HC595

• Knight Rider com 16 LEDs: monte o efeito de vaivém com dois chips em cascata e ajuste a velocidade com um potenciômetro.
• Medidor de nível em barra de LEDs: mostre o valor de um sensor ou o nível de som em uma barra de 8–16 LEDs.
• Sensor de estacionamento: acenda mais LEDs, do verde ao vermelho, conforme a distância medida com um HC-SR04 diminui.
• Placar de dois dígitos: monte um contador sem cintilação com botões usando dois displays de 7 segmentos e dois chips em cascata.
• Relógio binário: mostre horas, minutos e segundos como números binários em colunas de LEDs, pegando a hora de um módulo de relógio RTC.
• Cubo de LEDs 3x3x3: crie animações em 3D acionando as camadas com transistores e as colunas com 74HC595; os detalhes estão no guia cubo de LEDs com Arduino.
• Placa de relés de 8 canais: controle oito relés com 3 pinos usando um ULN2803 ou um TPIC6B595.

Erros comuns e como corrigi-los

O 74HC595 é a forma mais barata e didática de resolver a falta de pinos. Quando você entende a ideia de deslocar e travar (latch), passa a reconhecê-la em dispositivos SPI, drivers de matriz de LED e módulos de display, e ao ler botões com um 74HC165. Comece pelo contador de 8 LEDs, depois aumente a cadeia e passe para o SPI. No app BlueGrays você encontra projetos de LED sequencial, Knight Rider, efeitos com controle de velocidade e contador de 7 segmentos para Arduino, ESP32 e Raspberry Pi Pico, passo a passo, com esquemas do circuito e código.