74HC595 и Arduino: сдвиговый регистр для 8+ светодиодов на 3 пинах

74HC595 — дешёвая 16-выводная микросхема сдвигового регистра, которая позволяет управлять 8 отдельными выходами всего через 3 цифровых пина Arduino. У Arduino Uno 20 пинов, и они быстро заканчиваются, если собирать бегущие огни Knight Rider на 16 светодиодах, двухразрядное табло или 8-канальную плату реле. 74HC595 решает это, принимая данные по одному биту по единственной линии: микросхема собирает приходящие биты один за другим и, когда ты сообщаешь, что всё готово, разом копирует их на все восемь выходов. Соедини несколько микросхем цепочкой, и те же 3 пина будут управлять 16, 24 и даже 80 выходами.

В этом руководстве ты разберёшь распиновку 74HC595 (DS, SH_CP, ST_CP, OE, MR и Q7'), внутреннее устройство, которое превращает последовательные данные в параллельные выходы, функцию Arduino shiftOut() и разницу между порядком битов MSBFIRST и LSBFIRST. Затем соберёшь двоичный счётчик, бегущий огонь, цепочку из 16 светодиодов и 7-сегментный индикатор и заставишь ту же схему работать в десятки раз быстрее через аппаратный SPI. В последних разделах — код для ESP32 и Raspberry Pi Pico (MicroPython), пределы тока микросхемы и решения для самых частых ошибок с защёлкой.

Что такое 74HC595 и как он работает?

Внутри микросхемы два 8-битных регистра, соединённых друг за другом. Первый — сдвиговый регистр: на каждом нарастающем фронте на пине SH_CP (тактирование) 0 или 1 с пина DS попадает в первую ячейку, а уже находящиеся внутри биты сдвигаются на одну позицию вперёд. После восьми тактовых импульсов внутри все восемь отправленных битов. Второй — регистр хранения (защёлка): по нарастающему фронту на пине ST_CP восемь битов из сдвигового регистра разом копируются в него и появляются на выходах Q0–Q7. Благодаря такой двухступенчатой схеме светодиоды не мерцают, пока биты сдвигаются; выходы меняются только тогда, когда срабатывает пин защёлки.

Представь железнодорожную станцию: вагоны (биты) один за другим въезжают на платформу по единственному пути, но двери открываются, только когда поезд полностью остановился, и все пассажиры выходят одновременно. Открывать двери — работа пина защёлки. Поскольку данные входят последовательно, а выходят параллельно, 74HC595 называют ещё регистром SIPO (serial-in, parallel-out, последовательный вход — параллельный выход). Его собрат, делающий обратное и позволяющий читать 8 кнопок по одной линии, — 74HC165 (PISO). Оба относятся к логическому семейству серии 74; элементы и номера микросхем этого семейства можно посмотреть в утилите «Логические элементы».

Распиновка 74HC595

Полукруглая выемка или маленькая точка на микросхеме отмечает вывод 1. Если выемка сверху и смотреть на микросхему сверху, выводы 1–8 идут вниз по левой стороне, а 9–16 — вверх по правой. Производители называют выводы по-разному: NXP и большинство материалов по Arduino используют DS, SH_CP и ST_CP, а Texas Instruments — SER, SRCLK и RCLK. В таблице ниже указаны оба варианта. OE и MR — входы с активным LOW, то есть выполняют свою функцию, когда на них LOW, и в даташитах их рисуют с чертой над названием.

Подключение к Arduino Uno, ESP32 и Pico

Все примеры для Arduino в этом руководстве используют одну схему. Если с самого начала выбрать для линий данных и тактирования пины аппаратного SPI (D11 и D13), при переводе кода на SPI потом не придётся переставлять ни одного провода. Длинная ножка каждого светодиода (анод) идёт к выходу, а короткая (катод) — к GND через резистор. Не забудь керамический конденсатор 100 nF между пинами VCC и GND микросхемы как можно ближе к ней: он сглаживает короткие провалы напряжения, когда разом переключается много светодиодов, и предотвращает случайные сбои. Пины SPI своей платы можно проверить в утилите «Распиновка».

Функция shiftOut() и порядок битов (MSBFIRST / LSBFIRST)

Самый простой способ отправить данные в 74HC595 на Arduino — встроенная функция shiftOut(dataPin, clockPin, bitOrder, value). Она по очереди записывает восемь битов байта value на пин данных и после каждого бита ставит пин тактирования в HIGH, а затем в LOW; 74HC595 принимает бит ровно на этом нарастающем фронте. shiftOut() не трогает пин защёлки, поэтому перед отправкой нужно поставить ST_CP в LOW, а после — в HIGH. Поскольку функция опирается на нарастающие фронты, перед вызовом пин тактирования тоже должен быть в LOW, иначе первый бит может потеряться.

Параметр bitOrder задаёт, с какого конца отправляются биты. Первый отправленный бит после восьми сдвигов оказывается в дальнем конце, на Q7, а последний остаётся на Q0. С MSBFIRST первым идёт старший бит (бит 7), так что каждый бит байта попадает на выход с тем же номером: бит 0 на Q0, бит 7 на Q7. С LSBFIRST порядок обратный: бит 0 появляется на Q7, а бит 7 — на Q0. Все примеры в этом руководстве используют MSBFIRST, поэтому биты числа в коде один в один совпадают с номерами светодиодов. Освежить двоичные числа и запись 0b можно в руководстве о системах счисления и побитовых операциях.

Шаг за шагом: двоичный счётчик на 8 светодиодах

1. Поставь 74HC595 поперёк выемки посередине макетной платы, чтобы два ряда ножек оказались по разные стороны. Если непонятно, как макетная плата соединена внутри, сначала прочитай Что такое макетная плата?
2. Подключи VCC (вывод 16) и MR (вывод 10) к 5V, а GND (вывод 8) и OE (вывод 13) — к GND. Поставь конденсатор 100 nF между VCC и GND.
3. Подключи DS (14) к D11, SH_CP (11) к D13 и ST_CP (12) к D10.
4. Длинные ножки восьми светодиодов подключи к выходам Q0–Q7, а короткие — к GND через резисторы 470 Ω. Помни, что Q0 — это вывод 15.
5. Загрузи код ниже. Светодиоды должны считать от 0 до 255 в двоичном виде; светодиод на Q0 должен мигать быстрее всех, а на Q7 — медленнее всех.

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}

Сердце кода — функция write595(): она ставит защёлку в LOW, отправляет восемь битов через shiftOut() и ставит защёлку в HIGH, чтобы разом скопировать их на выходы. Поэтому светодиоды и не мерцают: пока биты сдвигаются, выходы держат прежнее значение. Когда n равно 5 (0b00000101), горят светодиоды на Q0 и Q2; при 200 (0b11001000) — на Q3, Q6 и Q7. На Uno можно заметить, что встроенный светодиод L на D13 слабо мерцает вместе с тактовым сигналом; это нормально и на схему не влияет.

Бегущий огонь и эффект Knight Rider

Для бегущего огня на каждом шаге достаточно установить в 1 всего один бит. Макрос Arduino bit(i) даёт число, в котором единица только в бите i: bit(0) равно 1, bit(3) — 8, а bit(7) — 128. Код ниже по очереди показывает три эффекта: один светодиод бежит от Q0 к Q7, огни Knight Rider бегают туда-обратно, а полоса постепенно заполняется. Сравнить с классической версией, где светодиоды подключены прямо к пинам, можно в статье Knight Rider и бегущие огни на Arduino; там каждому светодиоду нужен свой пин, а здесь всего хватает 3 пинов.

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}

В части Knight Rider прямой цикл идёт от 0 до 6, а обратный — от 7 до 1, чтобы крайние светодиоды не загорались дважды подряд и движение выглядело плавным. В заполняющейся полосе операция |= (побитовое ИЛИ) добавляет новый светодиод, сохраняя предыдущие горящими; на этом основана светодиодная шкала, показывающая значение потенциометра или датчика. Поскольку в коде есть delay(), пока идёт эффект, Arduino больше ничего не может делать. Если хочешь читать кнопку или менять скорость прямо во время эффекта, отсчитывай время через millis(); как это сделать, описано в руководстве millis() и delay().

Цепочка из нескольких 74HC595 (Q7')

Вывод 9 микросхемы, Q7' (QH'), выдаёт бит, который «выталкивается» из сдвигового регистра. Подключи его к входу DS второго 74HC595, и две микросхемы будут вести себя как один 16-битный регистр. Линии SH_CP и ST_CP общие для всех микросхем, так что будь в цепочке три микросхемы или десять, от Arduino по-прежнему идут только 3 провода. Каждый новый отправленный байт проталкивает предыдущий в следующую микросхему. Поэтому первый отправленный байт оказывается в последней микросхеме цепочки, а последний остаётся в первой, подключённой к Arduino. Когда срабатывает защёлка, выходы всех микросхем обновляются одновременно.

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() и lowByte() делят 16-битное число на два байта. Старший байт отправляется первым, поэтому уходит в последнюю микросхему цепочки и управляет светодиодами 8–15, а младший остаётся в первой микросхеме. Чтобы добавить третью микросхему, просто отправь ещё один байт, снова начиная с самой дальней микросхемы; при многих микросхемах аккуратнее хранить байты в массиве и отправлять их в цикле. Теоретического предела у цепочки нет, но каждая микросхема удлиняет обновление и нагружает общую линию тактирования. В длинных цепочках ставь каждой микросхеме свой конденсатор 100 nF, делай провода тактирования и защёлки короткими, а если линия очень длинная, усиль тактовый сигнал буферной микросхемой вроде 74HC244.

Управление 7-сегментным индикатором через 74HC595

В одноразрядном 7-сегментном индикаторе ровно восемь светодиодов: семь сегментов от a до g и одна точка (dp). Значит, восемь выходов одного 74HC595 идеально подходят для одного разряда. Подключи Q0 к сегменту a, Q1 к b и так далее, и Q6 окажется на g, а Q7 на dp; тогда бит 0 байта соответствует сегменту a, а бит 6 — сегменту g. В таблице ниже подключение для распространённого 10-выводного индикатора с общим катодом. Общие выводы (3 и 8) идут на GND, а у каждого сегмента свой резистор 470 Ω. Расположение букв сегментов и разницу между общим анодом и общим катодом подробно разбираем в руководстве 7-сегментный индикатор.

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}

У индикатора с общим анодом общие выводы идут на 5V, а сегмент загорается, когда на его выходе LOW. Если в коде поставить COMMON_ANODE в true, оператор ~ инвертирует все биты, и та же таблица продолжает работать. Для двухразрядного счётчика добавь в цепочку второй 74HC595 и отправляй сначала узор для дальнего разряда, а затем для ближнего к Arduino. При таком способе у каждого разряда своя микросхема, поэтому мультиплексирование не нужно, индикатор никогда не мерцает, а delay() в loop() не мешает. Для четырёх и более разрядов можно мультиплексировать с двумя 74HC595 или перейти на драйверы TM1637 или MAX7219, которые сами выполняют сканирование.

Быстрое управление через SPI

shiftOut() медленная, потому что записывает каждый бит отдельно через digitalWrite(): на Arduino Uno отправка одного байта занимает около 100 µs. С несколькими светодиодами этого не заметно, но этого не хватит, если нужно обновлять цепочку из 10 микросхем тысячи раз в секунду, программно управлять яркостью светодиодов или сканировать мультиплексированный светодиодный куб. Хорошая новость: протокол 74HC595 — по сути SPI: DS соответствует MOSI, SH_CP — SCK, а ST_CP — пину выбора микросхемы (CS). Аппаратный блок SPI у Uno отправляет байт примерно за 1 µs на 8 MHz; даже с накладными расходами на вызов функции это в десятки раз быстрее, чем shiftOut(). Как работает SPI, можно узнать в руководстве Что такое 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}

В SPI_MODE0 данные считываются по нарастающему фронту тактового сигнала — ровно так, как работает 74HC595. MSBFIRST снова отправляет бит 7 на Q7, так что узоры из предыдущих примеров работают без изменений. На Uno D10 должен быть выходом, чтобы аппаратный SPI оставался в режиме ведущего; SPI.begin() уже настраивает это, и поэтому D10 — лучший пин для защёлки. Если в цепочке больше одной микросхемы, просто вызывай SPI.transfer() по разу на каждую микросхему между LOW и HIGH на защёлке. MISO (D12) в этой схеме не используется и остаётся свободным для другого SPI-устройства.

Яркость через OE и очистка через MR

Пин OE (output enable, разрешение выходов) — выключатель, который разом включает или выключает все выходы. Если подключить его не к GND, а к одному из пинов PWM у Uno, например D9, яркость всех светодиодов можно регулировать вместе через PWM. Поскольку OE — активный LOW, логика инвертирована: analogWrite(9, 0) означает полную яркость, а analogWrite(9, 255) — полное выключение. Упростит дело запись analogWrite(9, 255 - brightness) в коде. Этот способ действует на все светодиоды одинаково; чтобы задавать яркость каждого светодиода отдельно, нужно делать это программно быстрыми обновлениями по SPI или перейти на адресные светодиоды вроде WS2812B.

Когда пин MR (master reset, общий сброс) уходит в LOW, все биты сдвигового регистра очищаются, но выходы гаснут не сразу, ведь регистр хранения держит прежнее значение. Чтобы погасить и выходы, нужно, пока MR в LOW, подать нарастающий фронт на пин защёлки. На практике MR подключают прямо к VCC, а очищают программно через write595(0) — это экономит и пин, и провод. Есть ещё проблема при включении: когда подаётся питание, регистр хранения начинается со случайного значения, и светодиоды могут на мгновение загореться вразнобой. На плате реле это может быть опасно; чтобы этого избежать, подтяни OE к VCC резистором 10 kΩ, первым делом в setup() вызови write595(0), а затем переведи пин OE в LOW.

74HC595 с ESP32: 3,3 V и SPI

Пины ESP32 выдают 3,3 V. Если питать 74HC595 от 5 V, чтобы вход засчитал HIGH, нужно около 0,7 × VCC, то есть 3,5 V; 3,3 V не дотягивают до этого порога, и работа становится ненадёжной. Самое чистое решение — питать микросхему тоже от пина 3V3 ESP32, ведь 74HC595 работает от 2 V. Если микросхему обязательно нужно питать от 5 V, используй 74HCT595, у которого входы считают HIGH всё выше 2 V, или поставь между ними преобразователь логических уровней. При 3,3 V резисторы 220 Ω подходят для красных, жёлтых и зелёных светодиодов, а синие и белые, с прямым напряжением около 3 V, при 3,3 V горят очень тускло.

Пример ниже использует пины VSPI у ESP32 (SCK на GPIO 18, MOSI на GPIO 23), чтобы показать эффект Knight Rider на 16 светодиодах, подключённых к двум 74HC595 в цепочке; защёлкой служит GPIO 5. Скорость SPI выставлена на 4 MHz, потому что предел скорости 74HC595 падает вместе с напряжением питания, а 4 MHz оставляют при 3,3 V большой запас. shiftOut() тоже работает на ESP32 и благодаря процессору на 240 MHz гораздо быстрее, чем на Uno; и всё же SPI освобождает процессор для таких задач, как Wi-Fi. Основы платы и безопасный выбор пинов — в статье Что такое 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 с Raspberry Pi Pico и MicroPython

На Pico 74HC595 тоже питай от пина 3V3(OUT). В MicroPython нет готового аналога shiftOut() из Arduino, но аппаратный SPI легко справляется: используются пины GP18 (SCK) и GP19 (MOSI) блока SPI0, а защёлкой может быть любой GPIO, здесь GP17. MicroPython резервирует под SPI ещё и пин MISO у SPI0 (GP16), поэтому не подключай к нему ничего другого. Если передать в spi.write() несколько байтов, обновятся сразу все микросхемы цепочки, и снова первый байт уходит в самую дальнюю. Установка и первые шаги — в статье Что такое 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)

Нагрузки помощнее: транзисторы, ULN2803 и TPIC6B595

Выходы 74HC595 подходят только для небольших токов светодиодов. Не подключай напрямую такие нагрузки, как катушка реле (70–90 mA), небольшой мотор, несколько зуммеров или светодиодная лента на 12 V. Можно поставить за каждым выходом NPN-транзистор или использовать ULN2803, где в одном корпусе восемь транзисторов Дарлингтона: он коммутирует до 500 mA на канал со стороны GND и имеет встроенные защитные диоды для индуктивных нагрузок; чтобы они работали, подключи его пин COM к питанию нагрузки. Решение поаккуратнее — TPIC6B595, который программируется точно так же, как 74HC595, но имеет мощные выходы с открытым стоком: он постоянно держит 150 mA на выход и может коммутировать нагрузки до 50 V. У него 20 выводов, поэтому распиновка другая, а нагрузки подключаются между плюсом питания и выходом.

74HC595, MAX7219 или TM1637?

Если нужна простая светодиодная шкала, 8-канальная плата реле или цифровые выходы, каждый из которых делает своё, 74HC595 — самый дешёвый и гибкий выбор. Для светодиодных матриц 8x8 и многоразрядных индикаторов жизнь сильно облегчает MAX7219, который сам занимается мультиплексированием. Если нужен цветной свет с отдельным управлением, светодиоды WS2812B NeoPixel работают на одном пине данных.

Идеи проектов с 74HC595

• Knight Rider на 16 светодиодах: сделай эффект туда-обратно на двух микросхемах в цепочке и регулируй скорость потенциометром.
• Светодиодный индикатор уровня: показывай значение датчика или уровень звука на шкале из 8–16 светодиодов.
• Парктроник: зажигай всё больше светодиодов, от зелёного к красному, по мере того как сокращается расстояние, измеренное HC-SR04.
• Двухразрядное табло: собери счётчик без мерцания с кнопками на двух 7-сегментных индикаторах и двух микросхемах в цепочке.
• Двоичные часы: показывай часы, минуты и секунды двоичными числами в столбцах светодиодов, беря время с модуля часов RTC.
• Светодиодный куб 3x3x3: создавай 3D-анимации, управляя слоями транзисторами, а столбцами — микросхемами 74HC595; подробности в руководстве Светодиодный куб на Arduino.
• 8-канальная плата реле: управляй восемью реле с 3 пинов через ULN2803 или TPIC6B595.

Частые ошибки и как их исправить

74HC595 — самый дешёвый и самый поучительный способ решить проблему нехватки пинов. Когда идея «сдвинуть и защёлкнуть» понятна, ты узнаешь её в SPI-устройствах, драйверах светодиодных матриц и модулях дисплеев, а также при чтении кнопок через 74HC165. Начни со счётчика на 8 светодиодах, затем удлини цепочку и переходи на SPI. В приложении BlueGrays есть проекты бегущего огня, Knight Rider, эффекта с регулировкой скорости и счётчика на 7-сегментном индикаторе для Arduino, ESP32 и Raspberry Pi Pico — пошагово, со схемами и кодом.