Tutorial 74HC595 Arduino: Shift Register untuk 8+ LED dengan 3 Pin

74HC595 adalah IC shift register 16 pin yang murah dan memungkinkanmu mengendalikan 8 output terpisah hanya dengan 3 pin digital Arduino-mu. Arduino Uno punya 20 pin yang bisa dipakai, dan pin-pin itu cepat habis begitu kamu mencoba membuat efek Knight Rider 16 LED, papan skor dua digit, atau board relay 8 kanal. 74HC595 memecahkan masalah ini dengan menerima data bit demi bit lewat satu jalur: chip mengumpulkan bit yang masuk satu per satu dan, ketika kamu memberi tahu bahwa kamu sudah siap, menyalin semuanya ke delapan output sekaligus. Rangkai beberapa chip, dan 3 pin yang sama bisa mengendalikan 16, 24, bahkan 80 output.

Di panduan ini kamu akan mempelajari pinout 74HC595 (DS, SH_CP, ST_CP, OE, MR, dan Q7'), struktur internal yang mengubah data serial menjadi output paralel, fungsi shiftOut() Arduino, dan perbedaan urutan bit MSBFIRST dan LSBFIRST. Setelah itu kamu akan membuat penghitung biner, lampu berjalan, rantai 16 LED, dan display 7-segmen, lalu mengendalikan rangkaian yang sama puluhan kali lebih cepat dengan SPI hardware. Bagian terakhir membahas kode ESP32 dan Raspberry Pi Pico (MicroPython), batas arus chip, dan solusi untuk kesalahan latch yang paling umum.

Apa itu 74HC595 dan bagaimana cara kerjanya?

Di dalam chip ada dua register 8 bit yang tersambung berurutan. Yang pertama adalah shift register: di setiap tepi naik pada pin SH_CP (clock), nilai 0 atau 1 yang ada di pin DS masuk ke sel pertama dan bit-bit yang sudah ada di dalam bergeser satu tempat ke depan. Setelah delapan pulsa clock, kedelapan bit yang kamu kirim sudah ada di dalam. Yang kedua adalah storage register (latch): pada tepi naik di pin ST_CP, delapan bit di shift register disalin ke sana sekaligus dan muncul di output Q0–Q7. Berkat desain dua tahap ini, LED tidak berkedip selama bit bergeser; output hanya berubah ketika kamu memicu pin latch.

Bayangkan seperti stasiun kereta: gerbong-gerbong (bit) masuk ke peron satu per satu di satu jalur, tapi pintunya baru terbuka setelah kereta benar-benar berhenti, dan semua penumpang turun pada momen yang sama. Membuka pintu adalah tugas pin latch. Karena data masuk secara serial dan keluar secara paralel, 74HC595 juga disebut register SIPO (serial-in, parallel-out). Saudaranya yang melakukan kebalikannya, memungkinkanmu membaca 8 tombol lewat satu jalur, adalah 74HC165 (PISO). Keduanya termasuk keluarga logika seri 74; kamu bisa mencari gerbang dan nomor chip keluarga ini di alat Gerbang logika.

Pinout 74HC595

Takik setengah lingkaran atau titik kecil di chip menandai pin 1. Dengan takik di atas dan chip dilihat dari atas, pin 1–8 berjajar turun di sisi kiri dan pin 9–16 naik di sisi kanan. Produsen memberi nama pin yang berbeda: NXP dan kebanyakan sumber Arduino memakai DS, SH_CP, dan ST_CP, sedangkan Texas Instruments memakai SER, SRCLK, dan RCLK. Tabel di bawah mencantumkan keduanya. OE dan MR adalah input aktif LOW, artinya keduanya menjalankan tugasnya ketika LOW, dan datasheet menampilkannya dengan garis di atas namanya.

Pengkabelan ke Arduino Uno, ESP32, dan Pico

Semua contoh Arduino di panduan ini memakai rangkaian yang sama. Memilih pin SPI hardware (D11 dan D13) untuk jalur data dan clock sejak awal berarti kamu tidak perlu memindahkan satu kabel pun ketika nanti mengubah kode ke SPI. Kaki panjang setiap LED (anoda) ke sebuah output dan kaki pendeknya (katoda) ke GND lewat resistor. Jangan lupa kapasitor keramik 100 nF di antara pin VCC dan GND chip, sedekat mungkin dengan chip; kapasitor ini meredam penurunan tegangan singkat ketika banyak LED berganti sekaligus dan mencegah gangguan acak. Kamu juga bisa mengecek pin SPI board-mu di alat Pinout.

Fungsi shiftOut() dan urutan bit (MSBFIRST / LSBFIRST)

Cara termudah mengirim data ke 74HC595 di Arduino adalah fungsi bawaan shiftOut(dataPin, clockPin, bitOrder, value). Fungsi ini menulis delapan bit dari byte value ke pin data satu per satu dan, setelah setiap bit, mengatur pin clock menjadi HIGH lalu LOW; 74HC595 mengambil bit tepat pada tepi naik itu. shiftOut() tidak menyentuh pin latch, jadi kamu perlu mengatur ST_CP menjadi LOW sebelum mengirim dan HIGH sesudahnya. Karena fungsi ini mengandalkan tepi naik, pin clock juga harus LOW sebelum fungsi dipanggil; kalau tidak, bit pertama bisa terlewat.

Parameter bitOrder menentukan dari ujung mana bit dikirim. Bit pertama yang dikirim berakhir di ujung terjauh, Q7, setelah delapan kali geser, sedangkan bit terakhir yang dikirim tetap di Q0. Dengan MSBFIRST, bit paling signifikan (bit 7) dikirim pertama, jadi setiap bit dari byte mendarat di output dengan nomor yang sama: bit 0 di Q0, bit 7 di Q7. Dengan LSBFIRST urutannya terbalik, dan bit 0 muncul di Q7 serta bit 7 di Q0. Semua contoh di panduan ini memakai MSBFIRST, jadi bit-bit angka di kode cocok satu per satu dengan nomor LED. Jika kamu ingin mengulang bilangan biner dan notasi 0b, baca panduan sistem bilangan dan operasi bit.

Langkah demi langkah: penghitung biner dengan 8 LED

1. Pasang 74HC595 melintasi celah di tengah breadboard agar dua baris kakinya berada di sisi yang berseberangan. Jika kamu belum yakin bagaimana breadboard tersambung di dalam, baca dulu Apa Itu Breadboard?.
2. Sambungkan VCC (pin 16) dan MR (pin 10) ke 5V, serta GND (pin 8) dan OE (pin 13) ke GND. Pasang kapasitor 100 nF di antara VCC dan GND.
3. Sambungkan DS (14) ke D11, SH_CP (11) ke D13, dan ST_CP (12) ke D10.
4. Sambungkan kaki panjang delapan LED ke output Q0–Q7 dan kaki pendeknya ke GND lewat resistor 470 Ω. Ingat bahwa Q0 adalah pin 15.
5. Upload kode di bawah. LED seharusnya menghitung dari 0 sampai 255 dalam biner; LED di Q0 berkedip paling cepat dan LED di Q7 paling lambat.

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}

Jantung kodenya adalah fungsi write595(): fungsi ini mengatur latch menjadi LOW, mengirim delapan bit dengan shiftOut(), lalu mengatur latch menjadi HIGH untuk menyalin semuanya ke output sekaligus. Ini juga alasan LED tidak berkedip: selama bit bergeser, output tetap menyimpan nilai lamanya. Ketika n bernilai 5 (0b00000101), LED di Q0 dan Q2 menyala; pada 200 (0b11001000), LED di Q3, Q6, dan Q7 menyala. Di Uno kamu mungkin melihat LED L bawaan di D13 berkedip samar mengikuti sinyal clock; ini normal dan tidak memengaruhi rangkaian.

Lampu berjalan dan efek Knight Rider

Untuk lampu berjalan, kamu hanya perlu mengatur satu bit menjadi 1 di setiap langkah. Makro bit(i) Arduino menghasilkan angka yang hanya bit i-nya bernilai 1: bit(0) sama dengan 1, bit(3) sama dengan 8, dan bit(7) sama dengan 128. Kode di bawah memainkan tiga efek berturut-turut: satu LED yang berjalan dari Q0 ke Q7, efek Knight Rider bolak-balik, dan bar yang terisi bertahap. Untuk membandingkannya dengan versi klasik yang disambung langsung ke pin, lihat Knight Rider dan LED Berjalan dengan Arduino; di sana setiap LED memakai pinnya sendiri, di sini cukup 3 pin 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}

Di bagian Knight Rider, loop maju berjalan dari 0 sampai 6 dan loop mundur dari 7 sampai 1, jadi LED di ujung tidak menyala dua kali berturut-turut dan gerakannya terlihat halus. Pada bar yang terisi, operasi |= (OR bitwise) menambahkan LED baru sambil menjaga LED sebelumnya tetap menyala; ini dasar dari grafik bar LED yang menampilkan nilai potensiometer atau sensor. Karena kodenya memakai delay(), Arduino tidak bisa melakukan hal lain selama efek berjalan. Jika kamu ingin membaca tombol atau mengubah kecepatan secara langsung selama efek, atur waktunya dengan millis(); kamu akan menemukan caranya di panduan millis() vs delay().

Merangkai beberapa 74HC595 (Q7')

Pin 9 chip, Q7' (QH'), mengeluarkan bit yang meluap dari shift register. Sambungkan ke input DS 74HC595 kedua, dan kedua chip berperilaku seperti satu register 16 bit. Jalur SH_CP dan ST_CP dipakai bersama oleh semua chip, jadi entah rantainya berisi tiga chip atau sepuluh, tetap hanya 3 kabel yang datang dari Arduino. Setiap byte baru yang kamu kirim mendorong byte sebelumnya ke chip berikutnya. Karena itu byte pertama yang kamu kirim berakhir di chip terakhir rantai, sedangkan byte terakhir yang kamu kirim tetap di chip pertama, yang tersambung ke Arduino. Ketika latch dipicu, output semua chip diperbarui pada waktu yang sama.

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() dan lowByte() memecah angka 16 bit menjadi dua byte. Byte tinggi dikirim dulu, jadi ia berjalan ke chip terakhir di rantai dan mengendalikan LED 8–15, sedangkan byte rendah tetap di chip pertama. Untuk menambahkan chip ketiga, cukup kirim satu byte lagi, lagi-lagi mulai dari chip yang paling jauh; dengan banyak chip lebih rapi menyimpan byte-byte dalam array dan mengirimnya dengan loop. Secara teori rantai tidak punya batas, tapi setiap chip membuat pembaruan lebih lama dan menambah beban pada jalur clock bersama. Di rantai yang panjang, beri setiap chip kapasitor 100 nF-nya sendiri, buat kabel clock dan latch pendek, dan jika jalurnya sangat panjang, perkuat clock dengan chip buffer seperti 74HC244.

Mengendalikan display 7-segmen dengan 74HC595

Display 7-segmen satu digit berisi tepat delapan LED: tujuh segmen dari a sampai g dan satu titik (dp). Artinya delapan output satu 74HC595 sangat pas untuk satu digit. Sambungkan Q0 ke segmen a, Q1 ke b, dan seterusnya, sehingga Q6 berakhir di g dan Q7 di dp; bit 0 byte lalu mewakili segmen a dan bit 6 segmen g. Tabel di bawah menunjukkan pengkabelan untuk display common cathode 10 pin yang umum. Pin common (3 dan 8) ke GND dan setiap segmen mendapat resistor 470 Ω-nya sendiri. Kamu akan menemukan tata letak huruf segmen dan perbedaan common anode dan common cathode secara rinci di panduan display 7-segmen.

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}

Pada display common anode, pin common ke 5V dan sebuah segmen menyala ketika output-nya LOW. Ketika kamu mengatur COMMON_ANODE menjadi true di kode, operator ~ membalik semua bit dan tabel yang sama tetap bekerja. Untuk penghitung dua digit, tambahkan 74HC595 kedua ke rantai dan kirim pola untuk digit yang jauh dulu, lalu pola untuk digit yang paling dekat dengan Arduino. Dengan cara ini setiap digit punya chip-nya sendiri, jadi tidak perlu multiplexing, display tidak pernah berkedip, dan memakai delay() di loop() bukan masalah. Untuk empat digit atau lebih, kamu bisa melakukan multiplexing dengan dua 74HC595 atau beralih ke driver TM1637 atau MAX7219 yang melakukan pemindaian sendiri.

Pengendalian cepat dengan SPI

shiftOut() lambat karena menulis setiap bit secara terpisah dengan digitalWrite(): di Arduino Uno, mengirim satu byte butuh sekitar 100 µs. Kamu tidak akan merasakannya dengan beberapa LED, tapi itu tidak cukup ketika kamu ingin memperbarui rantai 10 chip ribuan kali per detik, mengatur kecerahan LED lewat software, atau memindai kubus LED yang di-multiplex. Kabar baiknya, protokol 74HC595 sebenarnya adalah SPI: DS sesuai dengan MOSI, SH_CP dengan SCK, dan ST_CP dengan pin chip select (CS). Unit SPI hardware Uno mengirim satu byte dalam sekitar 1 µs pada 8 MHz; bahkan dengan overhead pemanggilan fungsi, ini puluhan kali lebih cepat daripada shiftOut(). Kamu bisa mempelajari cara kerja SPI di panduan Apa Itu 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}

Di SPI_MODE0, data diambil pada tepi naik clock, persis seperti cara kerja 74HC595. MSBFIRST lagi-lagi mengirim bit 7 ke Q7, jadi pola dari contoh-contoh sebelumnya bekerja tanpa perubahan. Di Uno, D10 harus menjadi output agar SPI hardware tetap di mode master; SPI.begin() sudah mengaturnya, dan itu juga alasan D10 adalah pin terbaik untuk latch. Jika rantai berisi lebih dari satu chip, cukup panggil SPI.transfer() sekali per chip di antara latch LOW dan HIGH. MISO (D12) tidak dipakai di rangkaian ini dan tetap kosong untuk perangkat SPI lain.

Kecerahan dengan OE dan pengosongan dengan MR

Pin OE (output enable) adalah saklar yang menyalakan atau mematikan semua output sekaligus. Jika kamu menyambungkannya ke salah satu pin PWM Uno, seperti D9, alih-alih GND, kamu bisa mengatur kecerahan semua LED bersama-sama dengan PWM. Karena OE aktif LOW, logikanya terbalik: analogWrite(9, 0) berarti kecerahan penuh dan analogWrite(9, 255) berarti mati total. Menulis analogWrite(9, 255 - brightness) di kodemu membuatnya lebih mudah. Cara ini memengaruhi semua LED sama rata; untuk mengatur kecerahan setiap LED secara terpisah, kamu perlu melakukannya lewat software dengan pembaruan SPI yang cepat atau beralih ke LED addressable seperti WS2812B.

Ketika pin MR (master reset) menjadi LOW, semua bit di shift register dikosongkan, tapi output tidak langsung mati karena storage register masih menyimpan nilai lamanya. Untuk mematikan output juga, kamu perlu mengirim tepi naik ke pin latch selama MR LOW. Dalam praktiknya, menyambungkan MR langsung ke VCC dan mengosongkan lewat software dengan write595(0) menghemat satu pin sekaligus satu kabel. Ada juga masalah ketika menyala: ketika daya diberikan, storage register mulai dengan nilai acak dan LED bisa menyala berantakan sesaat. Di board relay ini bisa berbahaya; untuk mencegahnya, tarik OE ke VCC dengan 10 kΩ, panggil write595(0) pertama di setup(), lalu atur pin OE menjadi LOW.

74HC595 dengan ESP32: 3,3 V dan SPI

Pin ESP32 mengeluarkan 3,3 V. Jika kamu memberi daya 74HC595 dari 5 V, sebuah input butuh sekitar 0,7 × VCC, atau 3,5 V, agar dianggap HIGH; 3,3 V berada di bawah ambang itu dan kerjanya jadi tidak andal. Solusi paling bersih adalah memberi daya chip juga dari pin 3V3 ESP32, karena 74HC595 bekerja mulai dari 2 V. Jika kamu benar-benar harus memberi daya chip dari 5 V, pakai 74HCT595, yang inputnya menganggap apa pun di atas 2 V sebagai HIGH, atau tambahkan konverter level logika di antaranya. Pada 3,3 V, 220 Ω cocok untuk LED merah, kuning, dan hijau, sedangkan LED biru dan putih, dengan tegangan maju sekitar 3 V, sangat redup di 3,3 V.

Contoh di bawah memakai pin VSPI ESP32 (SCK di GPIO 18, MOSI di GPIO 23) untuk memainkan efek Knight Rider di 16 LED yang tersambung ke dua 74HC595 berantai; GPIO 5 berfungsi sebagai latch. Kecepatan SPI diatur ke 4 MHz karena batas kecepatan 74HC595 turun mengikuti tegangan catu, dan 4 MHz menyisakan margin keamanan yang lebar di 3,3 V. shiftOut() juga bekerja di ESP32 dan jauh lebih cepat daripada di Uno berkat prosesor 240 MHz; tetap saja, memakai SPI membebaskan prosesor untuk tugas seperti Wi-Fi. Untuk dasar-dasar board dan pilihan pin yang aman, lihat Apa Itu 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 dengan Raspberry Pi Pico dan MicroPython

Di Pico, beri daya 74HC595 dari pin 3V3(OUT) juga. MicroPython tidak punya padanan siap pakai untuk shiftOut() Arduino, tapi SPI hardware mudah menangani tugas ini: pin GP18 (SCK) dan GP19 (MOSI) dari unit SPI0 dipakai, dan GPIO mana pun bisa menjadi latch; di sini GP17. MicroPython juga mencadangkan pin MISO SPI0 (GP16) untuk SPI, jadi jangan sambungkan ke hal lain. Jika kamu memberikan beberapa byte ke spi.write(), kamu memperbarui semua chip di rantai sekaligus, dan lagi-lagi byte pertama pergi ke chip yang paling jauh. Untuk instalasi dan langkah pertama, lihat Apa Itu 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)

Beban yang lebih besar: transistor, ULN2803, dan TPIC6B595

Output 74HC595 hanya cocok untuk arus LED yang kecil. Jangan sambungkan langsung beban seperti kumparan relay (70–90 mA), motor kecil, beberapa buzzer, atau LED strip 12 V. Kamu bisa memasang transistor NPN di belakang setiap output, atau memakai ULN2803, yang berisi delapan transistor Darlington dalam satu kemasan: chip ini menyaklarkan sampai 500 mA per kanal di sisi GND dan punya dioda pelindung bawaan untuk beban induktif; agar dioda itu bekerja, sambungkan pin COM-nya ke catu daya beban. Solusi yang lebih rapi adalah TPIC6B595, yang diprogram persis seperti 74HC595 tapi punya output open-drain yang kuat: chip ini membawa 150 mA terus-menerus per output dan bisa menyaklarkan beban sampai 50 V. Chip ini punya 20 pin, jadi pinout-nya berbeda, dan beban disambung di antara catu daya positif dan output.

74HC595, MAX7219, atau TM1637?

Jika kamu butuh bar LED sederhana, board relay 8 kanal, atau output digital yang masing-masing punya tugas berbeda, 74HC595 adalah pilihan paling murah dan paling fleksibel. Untuk matriks LED 8x8 atau display banyak digit, MAX7219 yang menangani multiplexing sendiri membuat semuanya jauh lebih mudah. Jika kamu menginginkan lampu warna-warni yang dikendalikan satu per satu, LED WS2812B NeoPixel berjalan dengan satu pin data.

Ide proyek 74HC595

• Knight Rider 16 LED: Buat efek bolak-balik dengan dua chip berantai dan atur kecepatannya dengan potensiometer.
• Pengukur level bar LED: Tampilkan nilai sensor atau tingkat suara di bar 8–16 LED.
• Sensor parkir: Nyalakan lebih banyak LED, dari hijau ke merah, ketika jarak yang diukur HC-SR04 makin pendek.
• Papan skor dua digit: Buat penghitung tanpa kedip dengan tombol memakai dua display 7-segmen dan dua chip berantai.
• Jam biner: Tampilkan jam, menit, dan detik sebagai bilangan biner di kolom-kolom LED, dengan waktu dari modul jam RTC.
• Kubus LED 3x3x3: Buat animasi 3D dengan mengendalikan lapisan lewat transistor dan kolom lewat 74HC595; detailnya ada di panduan kubus LED Arduino.
• Board relay 8 kanal: Kendalikan delapan relay dari 3 pin dengan ULN2803 atau TPIC6B595.

Kesalahan umum dan cara memperbaikinya

74HC595 adalah cara paling murah dan paling mendidik untuk mengatasi kekurangan pin. Begitu kamu memahami ide geser-lalu-latch, kamu akan mengenalinya di perangkat SPI, driver matriks LED, dan modul display, serta ketika membaca tombol dengan 74HC165. Mulailah dengan penghitung 8 LED, lalu perpanjang rantainya dan pindah ke SPI. Di aplikasi BlueGrays kamu akan menemukan proyek lampu berjalan, Knight Rider, efek dengan kecepatan yang bisa diatur, dan penghitung 7-segmen untuk Arduino, ESP32, dan Raspberry Pi Pico, langkah demi langkah dengan skema rangkaian dan kode.