Kubus LED Arduino: Cara Membuat Kubus 3x3x3 dan 4x4x4 Lengkap dengan Kode

Kubus LED adalah salah satu proyek lampu paling mencolok yang bisa kamu buat dengan Arduino: LED yang tersusun dalam kisi tiga dimensi menyala lapisan demi lapisan untuk menggambar bidang yang berputar, tetesan hujan yang jatuh, dan kubus yang membesar dan mengecil di udara. Cara terbaik untuk memulai kubus LED Arduino adalah ukuran 3x3x3 (27 LED) atau 4x4x4 (64 LED); di ukuran ini, pin Arduino Uno, beberapa transistor, dan sedikit kesabaran menyolder sudah cukup. Triknya bukan memberi setiap LED pin sendiri, melainkan memakai metode yang disebut multiplexing lapisan-kolom: kamu mengendalikan 27 LED dengan 12 pin, dan 64 LED hanya dengan 7 pin berkat dua chip 74HC595.

Di panduan ini kamu akan belajar cara kerja kubus LED, cara membuat jig solder, cara menyambung lapisan langkah demi langkah, kenapa lapisan harus digerakkan oleh transistor, dan bagaimana nilai resistor dihitung. Setelah itu ada kode Arduino yang memutar animasi berbasis array di kubus 3x3x3, cara naik ke kubus 4x4x4 dengan 74HC595, versi ESP32 dan Raspberry Pi Pico (MicroPython), alternatif WS2812B untuk kubus berwarna, dan solusi untuk kesalahan perakitan yang paling sering terjadi, seperti LED yang terbalik atau solderan dingin.

Apa itu kubus LED dan bagaimana cara kerjanya?

Kubus LED dibuat dengan menumpuk lapisan horizontal berisi LED yang jaraknya sama rata. Di setiap lapisan, kaki katoda (−) semua LED disolder menjadi satu, sehingga setiap lapisan punya satu jalur katoda bersama. Kaki anoda (+) LED yang letaknya bertumpuk disolder secara vertikal dan membentuk kolom. Kubus 3x3x3 punya 3 lapisan dan 9 kolom, sedangkan kubus 4x4x4 punya 4 lapisan dan 16 kolom. Setiap LED berada tepat di persilangan satu lapisan dan satu kolom: untuk menyalakan sebuah LED, kamu memberi tegangan positif ke kolomnya dan menghubungkan lapisannya ke GND.

Kamu bisa menyebut setiap LED di kubus dengan tiga koordinat: x (kiri ke kanan), y (depan ke belakang), dan z (bawah ke atas). Di kode artikel ini, nomor kolom dihitung sebagai c = y × 3 + x (c = y × 4 + x di 4x4x4), dan z adalah nomor lapisan. Sama seperti piksel di layar, satu titik cahaya di kubus disebut voxel (piksel volume). Membuat animasi sebenarnya berarti menentukan voxel mana yang menyala di momen mana.

Bagaimana multiplexing lapisan-kolom bekerja?

Kalau kamu menyalakan lebih dari satu lapisan sekaligus, tegangan positif yang kamu berikan ke sebuah kolom akan menyalakan LED di setiap lapisan aktif pada kolom itu, jadi kamu tidak bisa menggambar pola yang kamu mau. Karena itu kubus dipindai lapisan demi lapisan: Arduino mula-mula mematikan semua lapisan, menulis pola kolom lapisan pertama ke pin, menyalakan hanya lapisan itu selama beberapa milidetik, lalu mematikannya dan pindah ke lapisan kedua. Ketika putaran ini berulang lebih dari seratus kali per detik, matamu menahan cahaya itu sejenak (persistensi penglihatan, persistence of vision), sehingga kamu melihat semua lapisan menyala bersamaan.

Menghitung kecepatan pemindaian itu mudah: refresh rate = 1 / (jumlah lapisan × waktu per lapisan). Kalau setiap lapisan kubus 3x3x3 kamu nyalakan selama 3 ms, satu putaran butuh 9 ms dan kubus diperbarui sekitar 110 kali per detik. Di 4x4x4 dengan 2 ms per lapisan, satu putaran butuh 8 ms dan kecepatannya 125 Hz. Di bawah 50–60 Hz mata melihat kedipan (flicker); di atas 100 Hz kubus terlihat benar-benar stabil di mata dan garis-garisnya (banding) lebih sedikit di kamera ponsel. Harganya adalah kecerahan: karena setiap lapisan hanya menyala 1/3 dari waktu (1/4 di 4x4x4), arus rata-rata LED turun menjadi pecahan itu dari arus instannya.

Daftar komponen

Membuat jig solder

Rahasia kubus yang rapi ada di jig-nya. Kalau kamu menyolder LED sambil memegangnya dengan tangan, jaraknya bergeser, lapisannya jadi miring, dan kubusnya terlihat mencong. Jig adalah sepotong kayu dengan lubang berjarak sama tempat LED duduk terbalik, dengan kubahnya menghadap ke bawah. Jaraknya ditentukan oleh panjang kaki katoda: di kebanyakan LED 5 mm, kaki pendeknya sekitar 25 mm, tapi ukur sendiri LED-mu dengan penggaris. Ketika kaki ditekuk 90° sekitar 2–3 mm dari bodi, bagian horizontal yang tersisa harus menumpuk 2–3 mm dengan kaki LED di sebelahnya, karena itulah jarak 20 mm adalah titik awal yang bagus.

1. Gambar kisi 3x3 (atau 4x4) dengan penggaris di atas triplek, MDF, atau kardus tebal, dengan jarak 20 mm antartitik dan margin minimal 2 cm dari tepi.
2. Tandai setiap titik dengan paku dulu, lalu bor lurus dengan mata bor 5 mm. LED harus duduk mantap di lubangnya tapi bisa dicabut tanpa dipaksa; kalau terlalu sempit, perlebar lubangnya sedikit.
3. Gambar panah di salah satu tepi jig untuk menunjukkan arah katoda; kaki pendek setiap LED akan menunjuk ke arah yang sama.
4. Siapkan empat pengganjal dengan tinggi yang sama sesuai jarak antarlapisan, untuk menopang lapisan atas ketika kamu menyambung lapisan; potongan bilah kayu atau kardus yang dilipat sudah cukup.

Perakitan langkah demi langkah: lapisan dan kolom

1. Tekuk kakinya: Tekuk kaki pendek (katoda) setiap LED secara horizontal 90°, 2–3 mm dari bodi, ke arah panah di jig. Kaki panjang (anoda) tetap tegak.
2. Susun lapisan pertama: Masukkan LED ke lubang dengan kubah menghadap ke bawah. Setiap kaki katoda dalam satu baris harus menyentuh kaki katoda LED berikutnya; kaki LED terakhir di baris itu boleh dibiarkan bebas.
3. Solder katodanya: Solder setiap titik sambungan dalam 2–3 detik dengan solder bersuhu 320–350 °C. Lalu solder kawat lurus (potongan kaki resistor atau kawat tembaga berlapis timah) melintang di ujung-ujung baris untuk menyatukannya. Lapisan itu menjadi satu jalur listrik sekaligus rangka yang kokoh; di 4x4x4, menambah kawat di kedua ujung membuat lapisan makin kuat.
4. Uji lapisannya: Tanpa mengeluarkan lapisan dari jig, hubungkan jalur katoda ke GND dan sentuhkan 5 V lewat resistor 220 Ω ke setiap kaki anoda. Kalau ada LED yang tidak menyala, ganti sekarang.
5. Buat lapisan lainnya: Ulangi prosesnya sampai kamu punya 3 (atau 4) lapisan. Arahkan kaki katoda ke arah yang sama di setiap lapisan supaya kolomnya sejajar dengan tepat.
6. Sambung lapisannya: Biarkan satu lapisan di jig dan sejajarkan lapisan berikutnya tepat di atasnya dengan bantuan pengganjal. Buat tekukan kecil 2 mm di ujung setiap kaki anoda LED bawah yang menghadap ke atas, supaya kaki itu lewat di samping bodi LED di atasnya dan menempel ke kaki anodanya. Solder keempat sudut dulu, periksa kesejajarannya, lalu selesaikan kolom sisanya.
7. Keluarkan kabel lapisan: Solder kabel ke jalur katoda setiap lapisan dan tarik ke bawah di salah satu sisi kubus. Kabel-kabel ini tidak boleh saling bersentuhan atau menyentuh kolom; sisakan beberapa milimeter di antaranya.
8. Pasang di alas: Balik kubusnya; kaki anoda bebas dari lapisan terakhir yang kamu tambahkan sekarang menghadap ke bawah, dan lapisan itu menjadi yang paling dekat dengan alas, yaitu lapisan bawah (z = 0). Masukkan kaki-kaki dan kabel lapisan menembus perfboard, solder, lalu pasang resistor kolom di sebelah setiap kolom.

Menggerakkan lapisan dengan transistor

Pin kolom memberi arus ke satu LED, tapi ketika sebuah lapisan dinyalakan, arus dari semua LED di lapisan itu kembali ke GND lewat jalur katoda yang sama. Di kubus 3x3x3 itu berarti 9 LED × 12,7 mA ≈ 115 mA, dan di kubus 4x4x4 dengan 74HC595 berarti 16 LED × 5 mA ≈ 80 mA. Batas yang disarankan untuk satu pin Arduino Uno adalah 20 mA dan batas mutlaknya 40 mA, jadi kamu tidak bisa menghubungkan jalur lapisan langsung ke pin. Solusinya adalah transistor NPN di bawah setiap lapisan: kolektor ke jalur lapisan, emitor ke GND, dan basis ke pin Arduino lewat resistor. Ketika pin menjadi HIGH, transistor masuk saturasi dan menarik lapisan ke GND. Supaya transistor menyala penuh, pilih arus basis sekitar 1/10 sampai 1/20 dari arus kolektor: 115 mA butuh 6–12 mA, dan (5 V − 0,7 V) / 470 Ω ≈ 9 mA pas di rentang itu. Detailnya ada di Apa Itu Transistor?, dan urutan pinnya di alat pinout transistor.

Hitungan resistor: resistor kolom dan resistor basis

Resistor kolom adalah satu-satunya komponen yang membatasi arus LED, dan ada satu di setiap kolom; kamu tidak butuh resistor per LED, karena hanya satu LED di sebuah kolom yang menyala pada satu momen. Rumusnya berasal dari hukum Ohm: R = (Vsupply − VLED − VCE(sat)) / ILED. Dengan catu daya 5 V, LED merah dengan tegangan maju 2,0 V, dan transistor yang menurunkan sekitar 0,2 V ketika saturasi, target 12 mA memberi R = (5 − 2,0 − 0,2) / 0,012 ≈ 233 Ω. Nilai standar terdekat, 220 Ω, mengalirkan sekitar 12,7 mA ke LED. Dengan LED biru 3,1 V, resistor 220 Ω yang sama memberi sekitar 7,7 mA, yang masih terlihat jelas dengan multiplexing.

Di kubus 74HC595 kita sengaja memilih resistor yang lebih besar: total arus yang boleh lewat pin VCC atau GND chip ini maksimal 70 mA, dan ketika satu lapisan menyala, kedelapan output bisa menyala bersamaan. 8 × 5,5 mA ≈ 44 mA menyisakan margin yang aman. Arus LED rata-rata, yang menentukan kecerahan yang terlihat, adalah arus instan dibagi jumlah lapisan: 12,7 / 3 ≈ 4,2 mA di 3x3x3 dan 5,5 / 4 ≈ 1,4 mA di 4x4x4. LED efisien zaman sekarang terlihat jelas di dalam ruangan pada arus ini, tapi di ruangan yang sangat terang kubus 4x4x4 bisa tampak agak redup. Untuk menghitung dengan nilai LED-mu sendiri, pakai alat kalkulator resistor LED dan tegangan LED.

Pengkabelan kubus LED 3x3x3

Kode Arduino kubus LED 3x3x3: animasi dengan array

Setiap frame animasi disimpan sebagai satu angka per lapisan. Satu lapisan 3x3x3 punya 9 LED, jadi nilai 9-bit sudah cukup; kita menyimpannya sebagai uint16_t, dan bit c mewakili kolom c. Frame ditulis ke memori flash dengan PROGMEM, jadi animasi dengan ratusan frame pun tidak memenuhi RAM 2 KB milik Uno. Kode di bawah ini tidak butuh library tambahan.

1// 3x3x3 LED küp: katman çoklama ve dizilerle animasyon / 3x3x3 LED cube: layer multiplexing and array animations
2const byte colPins[9]   = {2, 3, 4, 5, 6, 7, 8, 9, 10};   // sütun anotları, 220 ohm ile / column anodes via 220 ohm
3const byte layerPins[3] = {A0, A1, A2};                     // alt, orta, üst katman transistörü / bottom, middle, top layer transistor
4
5// Her kare 3 katman, her katman 9 bit: bit c = sütun c (c = y*3 + x)
6// Each frame has 3 layers of 9 bits: bit c = column c (c = y*3 + x)
7const uint16_t frames[][3] PROGMEM = {
8  {0b111111111, 0b000000000, 0b000000000},  // 0: alt katman / bottom layer
9  {0b000000000, 0b111111111, 0b000000000},  // 1: orta katman / middle layer
10  {0b000000000, 0b000000000, 0b111111111},  // 2: üst katman / top layer
11  {0b000000000, 0b000010000, 0b000000000},  // 3: yalnız merkez / centre only
12  {0b111101111, 0b101000101, 0b111101111},  // 4: tel kafes, 12 kenar / wireframe, 12 edges
13  {0b010010010, 0b010010010, 0b010010010},  // 5: dönen düzlem, 1. konum / rotating plane, step 1
14  {0b100010001, 0b100010001, 0b100010001},  // 6: dönen düzlem, 2. konum / rotating plane, step 2
15  {0b000111000, 0b000111000, 0b000111000},  // 7: dönen düzlem, 3. konum / rotating plane, step 3
16  {0b001010100, 0b001010100, 0b001010100},  // 8: dönen düzlem, 4. konum / rotating plane, step 4
17  {0b111111111, 0b111111111, 0b111111111}   // 9: hepsi açık / all on
18};
19
20void setup() {
21  for (byte c = 0; c < 9; c++) pinMode(colPins[c], OUTPUT);
22  for (byte z = 0; z < 3; z++) pinMode(layerPins[z], OUTPUT);  // LOW: katmanlar kapalı / LOW: layers off
23}
24
25// Bir kareyi verilen süre boyunca katman katman tarar / scans one frame layer by layer for the given time
26void showFrame(byte f, unsigned int ms) {
27  unsigned long start = millis();
28  while (millis() - start < ms) {
29    for (byte z = 0; z < 3; z++) {
30      uint16_t bits = pgm_read_word(&frames[f][z]);         // katman verisini oku / read the layer data
31      for (byte c = 0; c < 9; c++) digitalWrite(colPins[c], bitRead(bits, c));
32      digitalWrite(layerPins[z], HIGH);                      // katmanı aç / layer on
33      delay(3);                                              // 3 ms göster / show for 3 ms
34      digitalWrite(layerPins[z], LOW);                       // sütunlar değişmeden önce kapat / off before the columns change
35    }
36  }
37}
38
39void loop() {
40  for (byte f = 0; f <= 4; f++) showFrame(f, 500);           // katmanlar, merkez, kafes / layers, centre, wireframe
41  for (byte turn = 0; turn < 4; turn++)                      // düzlemi 4 tur döndür / spin the plane 4 times
42    for (byte f = 5; f <= 8; f++) showFrame(f, 120);
43  showFrame(9, 800);                                         // hepsi açık / all on
44}

Inti kodenya adalah fungsi showFrame(). Untuk setiap lapisan, fungsi ini mula-mula menulis pola kolom ke pin, lalu menyalakan hanya transistor lapisan itu selama 3 ms dan mematikan lapisannya sebelum kolom berubah. Urutan ini penting: kalau kamu mengubah kolom ketika sebuah lapisan masih menyala, pola lapisan sebelumnya muncul sekejap di lapisan baru dan menyebabkan ghosting. bitRead(bits, c) mengembalikan bit c dari angka itu sebagai 0 atau 1, dan pgm_read_word() membaca nilai 16-bit dari flash. loop() mula-mula menampilkan lapisan satu per satu, lalu bagian tengah dan 12 rusuk kubus, kemudian memutar bidang vertikal melewati empat posisi untuk membuat efek baling-baling.

Mendesain animasimu sendiri

Untuk menggambar frame baru, lihat kubus dari atas dan bayangkan setiap lapisan sebagai kertas berpetak 3x3. Tandai kolom yang ingin kamu nyalakan dan tulis bilangan binernya setelah 0b dari kiri ke kanan, dari bit 8 turun ke bit 0. Keempat sudut, misalnya, adalah kolom 0, 2, 6, dan 8, yang menghasilkan 0b101000101. Tulis nilai yang sama ke ketiga lapisan dan kamu mendapat batang vertikal di keempat sudut; tulis hanya ke lapisan tengah dan kamu mendapat empat titik yang melayang di udara. Kalau bilangan biner masih baru buatmu, Sistem Bilangan dan Operasi Bitwise menjelaskan konsepnya secara rinci. Beberapa teknik yang berguna ketika kamu menulis kodenya:

• Pergeseran bit: Geser nilai sebuah lapisan ke kiri 3 bit di 3x3x3 atau 4 bit di 4x4x4 dan polanya mundur satu baris; buang bit yang meluap dengan masker & untuk membuat efek gelombang dan teks berjalan.
• Menyalin lapisan: Menyalin array lapisan satu langkah ke bawah atau ke atas menghasilkan efek hujan, gelembung yang naik, dan lift.
• Keacakan: Voxel yang dipilih dengan random() dan berkedip sebentar menciptakan efek langit berbintang atau kerlap-kerlip.
• Membalik: Operator ~ mengubah sebuah frame menjadi negatifnya, dan berganti cepat di antara keduanya memberi efek sorotan yang berkedip.

Kubus LED 4x4x4: naik level dengan 74HC595

Kubus 4x4x4 punya 16 kolom dan 4 lapisan; menggerakkannya secara langsung butuh 20 pin, artinya semua pin Uno, termasuk D0 dan D1. Kalau kolomnya kamu gerakkan dengan dua shift register 74HC595 yang dirangkai berantai, 16 kolom hanya memakan 3 pin (data, clock, dan latch); tambah 4 pin untuk lapisan dan totalnya 7 pin. Output Q7' (pin 9) chip pertama masuk ke input DS chip kedua, sedangkan jalur clock dan latch dipakai bersama oleh kedua chip. Kolom 0–7 (dua baris depan) terhubung ke output Q0–Q7 chip pertama, dan kolom 8–15 (dua baris belakang) ke chip kedua. Metode yang sama bisa diperbesar menjadi 4 chip untuk kubus 5x5x5 dan 8 chip untuk kubus 8x8x8.

1// 4x4x4 LED küp: 2 adet 74HC595 (16 sütun) + 4 transistörlü katman / 4x4x4 LED cube: two 74HC595s (16 columns) + 4 transistor layers
2const byte DATA_PIN  = 11;                 // 74HC595 DS (14)
3const byte CLOCK_PIN = 13;                 // 74HC595 SH_CP (11)
4const byte LATCH_PIN = 10;                 // 74HC595 ST_CP (12)
5const byte layerPins[4] = {2, 3, 4, 5};    // alttan üste katman transistörleri, 470 ohm ile / layer transistors bottom to top, via 470 ohm
6
7uint16_t cube[4];                          // ekrandaki görüntü: katman başına 16 bit / current image: 16 bits per layer
8
9// Hazır kareler: bit c = sütun c (c = y*4 + x) / ready-made frames: bit c = column c (c = y*4 + x)
10const uint16_t frames[][4] PROGMEM = {
11  {0xFFFF, 0x0000, 0x0000, 0x0000},        // alt katman / bottom layer
12  {0x0000, 0xFFFF, 0x0000, 0x0000},
13  {0x0000, 0x0000, 0xFFFF, 0x0000},
14  {0x0000, 0x0000, 0x0000, 0xFFFF},        // üst katman / top layer
15  {0x9009, 0x0000, 0x0000, 0x9009},        // 8 köşe / 8 corners
16  {0xF99F, 0x9009, 0x9009, 0xF99F},        // tel kafes / wireframe
17  {0x0000, 0x0660, 0x0660, 0x0000}         // içteki 2x2x2 küp / inner 2x2x2 cube
18};
19const byte FRAME_COUNT = sizeof(frames) / sizeof(frames[0]);
20
21void write16(uint16_t v) {                 // 16 biti iki entegreye gönder / send 16 bits to both chips
22  digitalWrite(LATCH_PIN, LOW);
23  shiftOut(DATA_PIN, CLOCK_PIN, MSBFIRST, highByte(v));  // önce uzaktaki entegre / far chip first
24  shiftOut(DATA_PIN, CLOCK_PIN, MSBFIRST, lowByte(v));
25  digitalWrite(LATCH_PIN, HIGH);           // çıkışlara aktar / copy to the outputs
26}
27
28void refresh() {                           // her 2 ms'de sıradaki katmana geç / move to the next layer every 2 ms
29  static byte z = 0;
30  static unsigned long last = 0;
31  if (micros() - last < 2000) return;
32  last = micros();
33  digitalWrite(layerPins[z], LOW);         // eski katmanı kapat / old layer off
34  z = (z + 1) % 4;
35  write16(cube[z]);                        // yeni katmanın sütunları / columns of the new layer
36  digitalWrite(layerPins[z], HIGH);        // yeni katmanı aç / new layer on
37}
38
39void holdFor(unsigned int ms) {            // beklerken küpü yenilemeye devam et / keep refreshing while waiting
40  unsigned long start = millis();
41  while (millis() - start < ms) refresh();
42}
43
44void clearCube() {
45  for (byte z = 0; z < 4; z++) cube[z] = 0;
46}
47
48void setVoxel(byte x, byte y, byte z) {    // tek LED yak, x/y/z = 0..3 / light one LED, x/y/z = 0..3
49  bitSet(cube[z], y * 4 + x);
50}
51
52void loadFrame(byte f) {                   // PROGMEM'deki kareyi yükle / load a frame from PROGMEM
53  for (byte z = 0; z < 4; z++) cube[z] = pgm_read_word(&frames[f][z]);
54}
55
56void sweep() {                             // dikey düzlemi x ekseninde kaydır / sweep a vertical plane along x
57  for (byte x = 0; x < 4; x++) {
58    clearCube();
59    for (byte y = 0; y < 4; y++)
60      for (byte z = 0; z < 4; z++) setVoxel(x, y, z);
61    holdFor(150);
62  }
63}
64
65void rain(byte steps) {                    // yağmur: damlalar yukarıdan düşer / rain: drops fall from the top
66  clearCube();
67  for (byte s = 0; s < steps; s++) {
68    for (byte z = 0; z < 3; z++) cube[z] = cube[z + 1];   // her şeyi bir kat indir / move everything down a layer
69    cube[3] = bit(random(16)) | bit(random(16));         // üstte 1-2 yeni damla / 1-2 new drops on top
70    holdFor(120);
71  }
72}
73
74void setup() {
75  pinMode(DATA_PIN, OUTPUT);
76  pinMode(CLOCK_PIN, OUTPUT);
77  pinMode(LATCH_PIN, OUTPUT);
78  for (byte z = 0; z < 4; z++) pinMode(layerPins[z], OUTPUT);
79  randomSeed(analogRead(A0));              // boştaki A0'dan rastgele tohum / random seed from the unconnected A0
80}
81
82void loop() {
83  for (byte f = 0; f < FRAME_COUNT; f++) {
84    loadFrame(f);
85    holdFor(500);
86  }
87  for (byte i = 0; i < 3; i++) sweep();
88  rain(80);
89}

Di versi ini pemindaian terjadi di fungsi refresh() dengan desain tanpa blocking: setiap kali dipanggil, fungsi ini memakai micros() untuk mengecek apakah 2 ms sudah lewat; kalau sudah, lapisan lama dimatikan, 16 bit lapisan baru dikirim ke dua chip, dan lapisan baru dinyalakan. Dengan begitu kode animasi hanya mengubah array cube[] dan tidak pernah mengurus penyegaran tampilan. holdFor() terus memanggil refresh() selama menunggu, jadi jangan pakai delay() yang panjang di bagian mana pun dari program. setVoxel(x, y, z) memungkinkanmu menyalakan satu LED berdasarkan koordinatnya; sweep() memakainya untuk menggerakkan bidang vertikal menembus kubus, dan rain() menyalin lapisan satu langkah ke bawah lalu menambahkan tetesan acak di atas. Perbedaan delay() dan millis() ada di millis() vs delay(), dan cara memindahkan pemindaian ke interrupt timer di interrupt Arduino.

Kubus LED dengan ESP32

Pin ESP32 mengeluarkan 3,3 V. Itu tidak cukup untuk menggerakkan LED biru dan putih yang tegangan majunya sekitar 3 V secara langsung; setelah turun di resistor dan transistor, hampir tidak ada yang tersisa. Karena itu solusi paling rapi di ESP32 adalah menggerakkan kolom lewat 74HCT595 yang diberi daya 5 V: keluarga HCT sudah menganggap 2 V sebagai HIGH, jadi bisa membaca sinyal 3,3 V tanpa masalah, sementara LED-nya mendapat daya dari 5 V. Tetap pakai 470 Ω di basis transistor lapisan; (3,3 − 0,7) / 470 ≈ 5,5 mA sudah cukup untuk arus lapisan 80 mA. Kode 4x4x4 di atas bisa dikompilasi di ESP32 apa adanya; kamu hanya perlu mengganti konstanta pin ke nilai di tabel (23, 18, 5 dan 25, 26, 27, 32). Kalau mau, kamu juga bisa memakai Wi-Fi ESP32 untuk memilih animasi dari halaman web di ponselmu; untuk memulai, lihat Apa Itu ESP32?.

Kubus LED dengan Raspberry Pi Pico dan MicroPython

Pico juga board 3,3 V, dan dengan pengaturan bawaan pinnya hanya memberi beberapa miliampere, jadi kamu memakai rangkaian 74HCT595 yang sama. Beri daya chip dan LED dari VBUS (pin 40), yang membawa 5 V dari USB. Di MicroPython, 16 bit dikirim dengan SPI hardware: pin GP18 (SCK) dan GP19 (MOSI) milik SPI0 menggerakkan jalur clock dan data, dan GP17 menggerakkan latch. Kodenya mengikuti logika yang sama: show() memindai satu frame lapisan demi lapisan selama waktu yang ditentukan, dan di efek hujan, list slicing (cube[1:]) menggeser setiap lapisan satu langkah ke bawah. Untuk pengaturan dan langkah pertama, lihat Apa Itu Raspberry Pi Pico?.

1# Pico + 2 adet 74HCT595 ile 4x4x4 LED küp / 4x4x4 LED cube with a Pico + two 74HCT595s
2from machine import Pin, SPI
3import time
4import random
5
6# GP18 = SCK -> SH_CP, GP19 = MOSI -> DS; GP16 (MISO) boş kalır / GP16 (MISO) stays unconnected
7spi = SPI(0, baudrate=1000000, polarity=0, phase=0, sck=Pin(18), mosi=Pin(19))
8latch = Pin(17, Pin.OUT, value=0)                                # ST_CP
9layers = [Pin(n, Pin.OUT, value=0) for n in (10, 11, 12, 13)]    # alttan üste, 470 ohm ile / bottom to top, via 470 ohm
10
11def write16(v):
12    latch.value(0)
13    spi.write(bytes((v >> 8, v & 0xFF)))    # önce uzaktaki entegre / far chip first
14    latch.value(1)                          # çıkışlara aktar / copy to the outputs
15
16def show(frame, ms):
17    # kareyi ms boyunca katman katman tara / scan the frame layer by layer for ms
18    end = time.ticks_add(time.ticks_ms(), ms)
19    while time.ticks_diff(end, time.ticks_ms()) > 0:
20        for z in range(4):
21            write16(frame[z])
22            layers[z].value(1)              # katmanı aç / layer on
23            time.sleep_us(2000)
24            layers[z].value(0)              # sütunlar değişmeden kapat / off before the columns change
25
26FRAMES = [
27    [0x9009, 0x0000, 0x0000, 0x9009],       # 8 köşe / 8 corners
28    [0xF99F, 0x9009, 0x9009, 0xF99F],       # tel kafes / wireframe
29    [0x0000, 0x0660, 0x0660, 0x0000],       # içteki küp / inner cube
30]
31
32while True:
33    for f in FRAMES:
34        show(f, 600)
35    cube = [0, 0, 0, 0]
36    for _ in range(60):                     # yağmur: her şey bir kat iner / rain: everything drops a layer
37        drop = (1 << random.getrandbits(4)) | (1 << random.getrandbits(4))
38        cube = cube[1:] + [drop]
39        show(cube, 120)

Kubus yang lebih besar: 5x5x5 dan 8x8x8

Ketika kubus makin besar, dua masalah ikut membesar. Yang pertama arus: kubus 8x8x8 punya 64 LED per lapisan, dan dengan 10 mA per LED arus lapisannya 640 mA; itu bukan lagi pekerjaan transistor TO-92 kecil, melainkan MOSFET logic-level. Yang kedua waktu pemindaian: untuk mempertahankan 100 Hz dengan 8 lapisan, setiap lapisan mendapat 1,25 ms dan 64 bit (8 byte) harus dikirim per lapisan; shiftOut() terlalu lambat untuk ini, jadi SPI hardware wajib. Selain itu, setiap LED hanya menyala 1/8 dari waktu, jadi kecerahannya turun; kubus besar butuh driver kolom yang lebih kuat dan adaptor 5 V eksternal, bukan USB (lihat Cara Memberi Daya ke Arduino). Karena itulah kubus pertamamu sebaiknya 3x3x3 atau 4x4x4; kamu akan menguasai tekniknya sebelum menyolder 512 LED.

Alternatif: kubus LED berwarna dengan WS2812B

Kalau kamu lebih suka memilih warna setiap LED satu per satu daripada membuat kubus satu warna, kamu bisa memakai LED addressable seperti WS2812B. Setiap LED ini punya chip driver sendiri, jadi tidak perlu multiplexing, transistor, atau resistor kolom: 64 LED dirangkai berantai dengan 5 V, GND, dan satu jalur data, lalu digerakkan dari satu pin. Untuk kubus, kamu memakai LED addressable 5 mm berkaki 4 (seperti PL9823 atau APA106) atau potongan dari LED strip WS2812B. Harganya adalah arus: sekitar 60 mA per LED pada putih penuh, yaitu 3,8 A untuk 64 LED. Jadi pakai adaptor 5 V 4 A, tambahkan kapasitor 1000 µF di catu daya dan resistor 330 Ω di jalur data, lalu batasi kecerahannya lewat software. Kodenya memakai library Adafruit NeoPixel.

1// WS2812B ile 4x4x4 RGB LED küp / 4x4x4 RGB LED cube with WS2812B
2#include <Adafruit_NeoPixel.h>
3
4const byte DATA_PIN = 6;                   // 330 ohm ile ilk LED'in DIN ucuna / to the first LED's DIN via 330 ohm
5const byte N = 4;
6Adafruit_NeoPixel cube(N * N * N, DATA_PIN, NEO_GRB + NEO_KHZ800);
7
8uint16_t idx(byte x, byte y, byte z) {     // koordinattan zincirdeki sıraya / coordinate to position in the chain
9  return z * 16 + y * 4 + x;               // düz (zikzaksız) kablolama varsayılır / assumes straight, non-zigzag wiring
10}
11
12void setup() {
13  cube.begin();
14  cube.setBrightness(40);                  // parlaklığı ve akımı sınırla (0-255) / limit brightness and current (0-255)
15}
16
17void loop() {
18  static uint16_t hue = 0;
19  for (byte z = 0; z < N; z++)
20    for (byte y = 0; y < N; y++)
21      for (byte x = 0; x < N; x++)         // her katman farklı tonda / each layer gets a different hue
22        cube.setPixelColor(idx(x, y, z), cube.gamma32(cube.ColorHSV(hue + z * 8192U)));
23  cube.show();
24  hue += 256;                              // gökkuşağını kaydır / shift the rainbow
25  delay(20);
26}

Fungsi idx() di kode mengubah koordinat x, y, z menjadi posisi di rantai dan mengasumsikan kamu menyambung setiap baris dengan arah yang sama. Kalau pengkabelannya zigzag, kamu perlu memakai 3 − x sebagai ganti x di baris ganjil. Beberapa LED addressable 5 mm mengharapkan urutan warna RGB; kalau yang muncul hijau padahal seharusnya merah, ganti NEO_GRB menjadi NEO_RGB. setBrightness(40) menurunkan kecerahan menjadi sekitar 16%, jadi di kasus terburuk pun arusnya tetap sekitar 0,6 A.

Ide proyek kubus LED

• Kubus yang bereaksi terhadap musik: Naikkan jumlah lapisan yang menyala sesuai tingkat suara yang diukur dengan sensor suara untuk membuat equalizer tiga dimensi.
• Game ular 3D: Arahkan ular di tiga sumbu pada kubus 4x4x4 dengan joystick dan sebuah tombol; untuk ide game lainnya, lihat proyek game Arduino.
• Kubus dadu: Ketika kamu menekan tombol, voxel teracak dengan cepat dan kubus menampilkan angka 1 sampai 6 sebagai pola titik.
• Proyek pameran sains: Jelaskan persistensi penglihatan dengan memperpanjang waktu lapisan memakai potensiometer dan menunjukkan momen ketika kedipan mulai terlihat; untuk ide lainnya, lihat ide proyek Arduino untuk lomba sains.
• Memilih animasi dari ponsel: Buat setiap huruf yang kamu kirim lewat Modul Bluetooth HC-05 memulai animasi yang berbeda.
• Lampu tidur warna-warni: Atur perpindahan warna yang pelan di kubus WS2812B; kalau kamu memakai ESP32, kendalikan efeknya dari ponsel dengan WLED.

Kesalahan umum dan cara memperbaikinya

Kubus LED adalah salah satu proyek langka yang mengajarkan menyolder, transistor, hitungan resistor, multiplexing, dan operasi bit sekaligus. Mulailah dengan 3x3x3, dan begitu kode dan logika animasinya sudah kamu pahami, lanjut ke 4x4x4 dengan 74HC595, atau ke WS2812B kalau kamu ingin warna. Kalau ingin mencoba ide menyalakan LED berurutan di satu baris lurus dulu, LED berjalan Knight Rider Arduino adalah pemanasan yang bagus. Di aplikasi BlueGrays kamu akan menemukan proyek LED berjalan, Knight Rider, animasi WS2812B, dan LED matrix, lengkap dengan skema rangkaian langkah demi langkah dan kodenya.