LED Küp Arduino: 3x3x3 ve 4x4x4 Yapımı, Devre ve Animasyon Kodu

LED küp, Arduino ile yapabileceğin en göz alıcı ışık projelerinden biridir: üç boyutlu bir ızgaraya dizilmiş LED'ler katman katman yanarak havada dönen düzlemler, yağan damlalar ve büyüyüp küçülen küpler çizer. Arduino ile LED küp yapmaya 3x3x3 (27 LED) ya da 4x4x4 (64 LED) boyutundan başlamak en doğrusudur; bu boyutlarda Arduino Uno'nun pinleri, birkaç transistör ve sabırlı bir lehim çalışması yeterlidir. İşin sırrı her LED'e ayrı pin ayırmak yerine katman-sütun çoklama denen yöntemi kullanmaktır: 27 LED'i 12 pinle, 64 LED'i ise iki 74HC595 entegresi yardımıyla yalnızca 7 pinle kontrol edersin.

Bu rehberde LED küpün çalışma mantığını, lehim şablonu hazırlamayı, katmanları adım adım birleştirmeyi, katmanları neden transistörle sürmen gerektiğini ve direnç değerlerinin nasıl hesaplandığını öğreneceksin. Ardından 3x3x3 küp için dizilerle animasyon oynatan Arduino kodunu, 74HC595 ile 4x4x4 küpe büyütmeyi, ESP32 ve Raspberry Pi Pico (MicroPython) sürümlerini, renkli bir küp için WS2812B alternatifini ve ters LED ile soğuk lehim gibi en sık yapılan montaj hatalarının çözümlerini bulacaksın.

LED küp nedir, nasıl çalışır?

Bir LED küp, aynı aralıklarla dizilmiş LED'lerden oluşan yatay katmanların üst üste konmasıyla oluşur. Her katmanda bütün LED'lerin katot (−) bacakları birbirine lehimlenir; böylece her katmanın tek bir ortak katot hattı olur. Üst üste duran LED'lerin anot (+) bacakları ise dikey olarak birbirine lehimlenir ve sütunları oluşturur. 3x3x3 bir küpte 3 katman ve 9 sütun, 4x4x4 bir küpte 4 katman ve 16 sütun vardır. Her LED tam olarak bir katman ile bir sütunun kesişimindedir: bir LED'i yakmak için onun sütununa artı gerilim verir, katmanını GND'ye bağlarsın.

Küpteki her LED'i üç koordinatla tanımlayabilirsin: x (soldan sağa), y (önden arkaya) ve z (alttan üste). Bu yazıdaki kodlarda sütun numarası c = y × 3 + x (4x4x4'te c = y × 4 + x) formülüyle hesaplanır, z ise katman numarasıdır. Ekrandaki piksele benzer şekilde küpteki tek bir ışık noktasına voksel (hacim pikseli) denir. Animasyon yapmak, aslında hangi voksellerin hangi anda yanacağına karar vermektir.

Katman-sütun çoklama (multiplexing) nasıl çalışır?

Aynı anda birden fazla katmanı açarsan bir sütuna verdiğin artı gerilim o sütundaki bütün açık katmanlarda LED yakar; yani istediğin deseni çizemezsin. Bu yüzden küp katman katman taranır: Arduino önce bütün katmanları kapatır, birinci katmanın sütun desenini pinlere yazar, yalnızca o katmanı birkaç milisaniye açar, sonra kapatıp ikinci katmana geçer. Bu döngü saniyede yüz defadan fazla tekrarlandığında göz ışığı kısa bir süre tuttuğu için (görme sürekliliği) bütün katmanları aynı anda yanıyor görürsün.

Tarama hızını hesaplamak kolaydır: yenileme frekansı = 1 / (katman sayısı × katman süresi). 3x3x3 küpte her katmanı 3 ms açık tutarsan bir tur 9 ms sürer ve küp saniyede yaklaşık 110 kez yenilenir. 4x4x4'te katman başına 2 ms ile tur 8 ms, frekans 125 Hz olur. 50–60 Hz'in altında titreme gözle fark edilir; 100 Hz'in üzeri göze tamamen titremesiz görünür ve telefon kamerasındaki bantlanmayı da azaltır. Bunun bedeli parlaklıktır: her katman zamanın yalnızca 1/3'ünde (4x4x4'te 1/4'ünde) yandığı için bir LED'in ortalama akımı anlık akımının o kadarına düşer.

Malzeme listesi

Lehim şablonu (jig) hazırlamak

Düzgün bir küpün sırrı şablondur. LED'leri elde tutarak lehimlersen aralıklar kayar, katmanlar eğri durur ve küp yamuk görünür. Şablon, LED'lerin ters çevrilip kubbeleri aşağıda olacak şekilde oturduğu, eşit aralıklı deliklere sahip bir tahta parçasıdır. Aralığı belirleyen şey katot bacağının boyudur: çoğu 5 mm LED'in kısa bacağı 25 mm civarındadır, ama sen kendi LED'ini cetvelle ölç. Bacağı gövdeye 2–3 mm mesafeden 90° büktüğünde kalan yatay kısım komşu LED'in bacağına 2–3 mm binmelidir; bu yüzden 20 mm aralık iyi bir başlangıçtır.

1. Kontrplak, MDF ya da kalın bir mukavvanın üzerine cetvelle 3x3 (ya da 4x4) bir ızgara çiz; noktalar arası 20 mm olsun ve kenarlardan en az 2 cm pay bırak.
2. Her noktayı önce bir çiviyle işaretle, sonra 5 mm matkap ucuyla dik olarak del. LED delikte oturmalı ama zorlanmadan çıkabilmeli; çok sıkıysa deliği hafifçe genişlet.
3. Şablonun bir kenarına katot yönünü gösteren bir ok çiz; bütün LED'lerin kısa bacağı aynı yöne bakacak.
4. Katmanları birleştirirken üstteki katmanı taşıyacak, katman aralığına uygun boyda ve eşit yükseklikte dört takoz hazırla; tahta çıta parçaları ya da katlanmış karton iş görür.

Adım adım montaj: katmanlar ve sütunlar

1. Bacakları bük: Her LED'in kısa (katot) bacağını gövdeye 2–3 mm mesafeden, şablondaki oka doğru 90° yatay bük. Uzun (anot) bacak dik kalır.
2. İlk katmanı diz: LED'leri kubbeleri aşağıda olacak şekilde deliklere yerleştir. Bir sıradaki her katot bacağı yanındaki LED'in katot bacağına değsin; sıranın sonundaki LED'in bacağı boşta kalabilir.
3. Katotları lehimle: Her temas noktasını havya 320–350 °C'deyken en fazla 2–3 saniyede lehimle. Sonra sıraları birbirine bağlamak için sıraların ucuna dik gelen düz bir tel (kesilmiş direnç bacağı ya da kalaylı bakır tel) lehimle. Böylece katman hem tek bir elektrik hattı hem de sağlam bir çerçeve olur; 4x4x4'te iki uca birer tel koymak katmanı daha da sağlamlaştırır.
4. Katmanı test et: Katmanı şablondan çıkarmadan katot hattını GND'ye bağla ve her anot bacağına 220 Ω'luk bir direnç üzerinden 5 V değdir. Yanmayan LED varsa şimdi değiştir.
5. Diğer katmanları hazırla: Aynı işlemle toplam 3 (ya da 4) katman yap. Her katmanda katot bacaklarının yönü aynı olsun ki sütunlar tam üst üste gelsin.
6. Katmanları birleştir: Bir katmanı şablonda bırak, sıradaki katmanı takozların üzerinde tam üstüne hizala. Alttaki LED'lerin yukarı bakan anot bacağının ucuna 2 mm'lik küçük bir kıvrım ver; bacak üstteki LED'in gövdesinin yanından geçip onun anot bacağına yaslansın. Önce dört köşeyi lehimle, hizayı kontrol et, sonra kalan sütunları bitir.
7. Katman tellerini çıkar: Her katmanın katot hattına bir tel lehimleyip küpün bir kenarından aşağıya indir. Bu teller birbirine ve sütunlara değmemeli; aralarında birkaç milimetre boşluk bırak.
8. Tabana yerleştir: Küpü ters çevir; en son eklediğin katmanın serbest anot bacakları artık aşağıya bakar ve tabana en yakın katman, yani alt katman (z = 0) bu katman olur. Bacakları ve katman tellerini delikli pertinaksa geçirip lehimle, sütun dirençlerini her sütunun yanına yerleştir.

Katmanları transistörle sürmek

Bir sütun pini tek bir LED'e akım verir, ama bir katman açıldığında o katmandaki bütün LED'lerin akımı aynı katot hattından GND'ye döner. 3x3x3 küpte bu 9 LED × 12,7 mA ≈ 115 mA, 74HC595'li 4x4x4 küpte 16 LED × 5 mA ≈ 80 mA eder. Arduino Uno'nun bir pini için önerilen sınır 20 mA, mutlak sınır 40 mA olduğundan katman hattını doğrudan pine bağlayamazsın. Çözüm her katmanın altına bir NPN transistör koymaktır: kollektör katman hattına, emiter GND'ye, beyz ise bir direnç üzerinden Arduino pinine bağlanır. Pin HIGH olduğunda transistör doyuma girer ve katmanı GND'ye çeker. Transistörü anahtar gibi tam açmak için beyz akımını kollektör akımının yaklaşık 1/10–1/20'si seçersin: 115 mA için 6–12 mA gerekir ve (5 V − 0,7 V) / 470 Ω ≈ 9 mA tam bu aralıktadır. Ayrıntılar için Transistör Nedir? yazısına, bacak dizilimleri için transistör aracına bakabilirsin.

Direnç hesabı: sütun ve beyz dirençleri

Sütun direnci LED akımını sınırlayan tek elemandır ve her sütunda bir tane bulunur; her LED'e ayrı direnç gerekmez, çünkü bir sütunda aynı anda yalnızca bir LED yanar. Formül Ohm Kanunu'ndan gelir: R = (Vbesleme − VLED − VCE(sat)) / ILED. 5 V beslemede ileri gerilimi 2,0 V olan kırmızı bir LED ve doyumda yaklaşık 0,2 V düşüren bir transistörle 12 mA hedeflersen R = (5 − 2,0 − 0,2) / 0,012 ≈ 233 Ω çıkar. En yakın standart değer olan 220 Ω, LED'den yaklaşık 12,7 mA geçirir. İleri gerilimi 3,1 V olan mavi bir LED'de aynı 220 Ω yaklaşık 7,7 mA verir; bu da çoklama altında rahatça görünen bir parlaklıktır.

74HC595'li küpte dirençleri bilerek büyük seçiyoruz: bu entegrenin VCC ya da GND pininden toplamda en fazla 70 mA geçebilir ve bir katman açıkken sekiz çıkışın hepsi birden yanabilir. 8 × 5,5 mA ≈ 44 mA güvenli bir paydır. Algılanan parlaklığı belirleyen ortalama LED akımı ise anlık akımın katman sayısına bölümüdür: 3x3x3'te 12,7 / 3 ≈ 4,2 mA, 4x4x4'te 5,5 / 4 ≈ 1,4 mA. Günümüzün verimli LED'leri bu akımlarda iç mekânda net görünür, ama çok aydınlık bir odada 4x4x4 küp biraz sönük kalabilir. Kendi LED'inin değerleriyle hesaplamak için LED direnci ve LED gerilimleri araçlarını kullanabilirsin.

3x3x3 LED küp bağlantı şeması

3x3x3 LED küp Arduino kodu: dizilerle animasyon

Animasyonun her karesi katman başına bir sayı olarak tutulur. 3x3x3'te bir katmanda 9 LED olduğu için 9 bitlik bir değer yeter; bunu uint16_t türünde saklarız ve bit c, c numaralı sütunu temsil eder. Kareler PROGMEM ile flash belleğe yazılır; böylece yüzlerce karelik animasyonlar bile Uno'nun 2 KB'lık RAM'ini doldurmaz. Aşağıdaki kod ek kütüphane gerektirmez.

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}

Kodun kalbi showFrame() fonksiyonudur. Her katman için önce sütun desenini pinlere yazar, sonra yalnızca o katmanın transistörünü 3 ms açar ve sütunlar değişmeden önce katmanı kapatır. Bu sıra önemlidir: katman açıkken sütunları değiştirirsen bir önceki katmanın deseni kısa bir an yeni katmanda görünür ve gölgelenme (ghosting) oluşur. bitRead(bits, c) sayının c'inci bitini 0 ya da 1 olarak verir, pgm_read_word() ise flash'taki 16 bitlik değeri okur. loop() önce katmanları tek tek, sonra merkezi ve küpün 12 kenarını gösterir; ardından dikey bir düzlemi dört konumda döndürerek fırıldak efekti oluşturur.

Kendi animasyonunu tasarlamak

Yeni bir kare çizmek için küpe yukarıdan bak ve her katmanı 3x3'lük bir kareli kâğıt gibi düşün. Yanmasını istediğin sütunları işaretle ve ikilik sayıyı 0b'den sonra soldan sağa, bit 8'den bit 0'a doğru yaz. Örneğin dört köşe 0, 2, 6 ve 8 numaralı sütunlardır; bu da 0b101000101 eder. Aynı değeri üç katmana yazarsan dört köşede dikey çubuklar, yalnız ortadaki katmana yazarsan havada asılı dört nokta elde edersin. İkilik sayılar sana yabancıysa Sayı Sistemleri ve Bit İşlemleri yazısı bu mantığı ayrıntılı anlatır. Kod yazarken işine yarayacak birkaç teknik:

• Bit kaydırma: Bir katmanın değerini 3x3x3'te 3, 4x4x4'te 4 bit sola kaydırırsan desen bir sıra arkaya geçer; taşan bitleri & ile temizleyerek dalga ve kayan yazı efektleri yaparsın.
• Katman kopyalama: Katman dizisini bir basamak aşağı ya da yukarı kopyalamak yağmur, yükselen kabarcık ve asansör efektleri verir.
• Rastgelelik: random() ile seçilen voksellerin kısa süre yanıp sönmesi yıldız ya da kıvılcım efekti oluşturur.
• Ters çevirme: ~ işlemiyle bir kareyi negatifine çevirebilir, iki kare arasında hızla geçerek yanıp sönen bir vurgu elde edebilirsin.

4x4x4 LED küp: 74HC595 ile büyütme

4x4x4 küpte 16 sütun ve 4 katman vardır; doğrudan sürmek 20 pin ister ki bu, Uno'nun D0 ve D1 dahil bütün pinleri demektir. Sütunları zincirlenmiş iki 74HC595 kaydırmalı yazmaç ile sürersen 16 sütun için yalnızca 3 pin (veri, saat ve latch) harcarsın; katmanlar için 4 pin daha eklenince toplam 7 pin eder. Birinci entegrenin Q7' (9. pin) çıkışı ikinci entegrenin DS girişine gider, saat ve latch hatları ise iki entegrede ortaktır. Sütun 0–7 (ön iki sıra) birinci entegrenin Q0–Q7 çıkışlarına, sütun 8–15 (arka iki sıra) ikinci entegreye bağlanır. Aynı yöntem 5x5x5 küp için 4, 8x8x8 küp için 8 entegreyle büyür.

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}

Bu sürümde tarama refresh() fonksiyonunda engellemeyen (non-blocking) bir yapıyla yapılır: fonksiyon her çağrıldığında micros() ile 2 ms geçip geçmediğine bakar; geçmişse eski katmanı kapatır, yeni katmanın 16 bitini iki entegreye gönderir ve yeni katmanı açar. Böylece animasyon kodu yalnızca cube[] dizisini değiştirir, ekranı yenileme işiyle uğraşmaz. holdFor() beklerken refresh()'i çağırmayı sürdürür, bu yüzden programın hiçbir yerinde uzun bir delay() kullanmamalısın. setVoxel(x, y, z) koordinatla tek bir LED yakmanı sağlar; sweep() bunu kullanarak dikey bir düzlemi küp boyunca kaydırır, rain() ise katmanları birer basamak aşağı kopyalayıp en üste rastgele damlalar ekler. delay() ile millis() farkını millis() ve delay() yazısında, taramayı bir zamanlayıcı kesmesine taşımayı ise Arduino Interrupt yazısında bulabilirsin.

ESP32 ile LED küp

ESP32'nin pinleri 3,3 V verir. Bu gerilim, ileri gerilimi 3 V civarında olan mavi ve beyaz LED'leri doğrudan sürmeye yetmez; direnç ve transistör üzerinde düşen gerilimden sonra geriye neredeyse hiçbir şey kalmaz. Bu yüzden ESP32'de sütunları 5 V ile beslenen bir 74HCT595 üzerinden sürmek en temiz çözümdür: HCT ailesi 2 V'u bile HIGH kabul ettiği için 3,3 V'luk sinyalleri sorunsuz okur, LED'ler ise 5 V'tan beslenir. Katman transistörlerinin beyzine yine 470 Ω koy; (3,3 − 0,7) / 470 ≈ 5,5 mA, 80 mA'lik katman akımı için yeterlidir. Yukarıdaki 4x4x4 kodu ESP32'de olduğu gibi derlenir; yalnızca pin sabitlerini tablodaki değerlerle (23, 18, 5 ve 25, 26, 27, 32) değiştirmen yeter. İstersen ESP32'nin Wi-Fi'siyle animasyonları telefondan açılan bir web sayfasından da seçebilirsin; başlangıç için ESP32 Nedir? yazısına bakabilirsin.

Raspberry Pi Pico ve MicroPython ile LED küp

Pico da 3,3 V'luk bir karttır ve pinleri varsayılan ayarda yalnızca birkaç miliamper verir; bu nedenle aynı 74HCT595'li devreyi kullanırsın. Entegreleri ve LED'leri USB'nin 5 V'unu veren VBUS (40. pin) üzerinden besle. MicroPython'da 16 biti göndermek için donanım SPI'si kullanılır: SPI0'ın GP18 (SCK) ve GP19 (MOSI) pinleri saat ile veri hattını, GP17 ise latch'i sürer. Kod aynı mantıkla çalışır: show() kareyi verilen süre boyunca katman katman tarar, yağmur efektinde ise liste dilimlemesiyle (cube[1:]) bütün katmanlar bir basamak aşağı kayar. Kurulum ve ilk adımlar için Raspberry Pi Pico Nedir? yazısına bakabilirsin.

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)

Daha büyük küpler: 5x5x5 ve 8x8x8

Küp büyüdükçe iki sorun da büyür. Birincisi akımdır: 8x8x8 bir küpte bir katmanda 64 LED vardır ve LED başına 10 mA ile katman akımı 640 mA eder; bu artık küçük bir TO-92 transistörün değil, lojik seviye MOSFET'in işidir. İkincisi tarama süresidir: 8 katmanla 100 Hz'i korumak için katman başına 1,25 ms kalır ve her katmanda 64 biti (8 bayt) göndermek gerekir; shiftOut() bu iş için yavaş kalır, donanım SPI'si şarttır. Ayrıca her LED zamanın yalnızca 1/8'inde yandığı için parlaklık düşer; büyük küplerde sütunlar için daha güçlü sürücüler, besleme için de USB yerine 5 V'luk harici bir adaptör gerekir (bkz. Arduino güç besleme). Bu yüzden ilk küpün 3x3x3 ya da 4x4x4 olmalı; 512 LED'i lehimlemeden önce teknikte ustalaşırsın.

Alternatif: WS2812B ile renkli LED küp

Tek renkli küp yerine her LED'in rengini ayrı ayrı seçmek istiyorsan WS2812B gibi adreslenebilir LED'ler kullanabilirsin. Bu LED'lerin her birinde kendi sürücü yongası olduğu için çoklama, transistör ve sütun direnci gerekmez: 64 LED; 5 V, GND ve veri hattıyla zincir halinde bağlanır ve tek bir pinle sürülür. Küp için 4 bacaklı 5 mm adreslenebilir LED'ler (PL9823, APA106 gibi) ya da kesilmiş WS2812B şerit parçaları kullanılır. Bunun bedeli akımdır: tam beyazda LED başına yaklaşık 60 mA, 64 LED için 3,8 A eder. Bu yüzden 5 V 4 A'lik bir adaptör kullan, beslemeye 1000 µF kondansatör, veri hattına 330 Ω direnç ekle ve parlaklığı yazılımla sınırla. Kod Adafruit NeoPixel kütüphanesini kullanır.

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}

Koddaki idx() fonksiyonu x, y, z koordinatını zincirdeki sıra numarasına çevirir ve LED'leri her sırada aynı yönde bağladığını varsayar. Kabloyu zikzak çektiysen tek numaralı sıralarda x yerine 3 − x kullanman gerekir. 5 mm'lik adreslenebilir LED'lerin bir kısmı renkleri RGB sırasıyla bekler; kırmızı yerine yeşil görüyorsan NEO_GRB'yi NEO_RGB yap. setBrightness(40) parlaklığı yaklaşık %16'ya indirir, böylece en kötü durumda bile akım 0,6 A civarında kalır.

LED küp proje fikirleri

• Müziğe dans eden küp: Bir ses sensörüyle ölçtüğün ses seviyesine göre yanan katman sayısını artırarak üç boyutlu bir ekolayzır yap.
• 3D yılan oyunu: 4x4x4 küpte bir joystick ve bir butonla yılanı üç eksende yönet; başka oyun fikirleri için Arduino oyun projeleri yazısına bak.
• Zar küpü: Bir butona basınca vokseller hızla karışsın ve küp 1 ile 6 arasında bir sayıyı nokta desenleriyle göstersin.
• Bilim fuarı projesi: Katman süresini bir potansiyometreyle uzatıp titremenin başladığı anı göstererek görme sürekliliğini anlat; diğer fikirler için TÜBİTAK proje fikirleri yazısına göz at.
• Telefondan animasyon seçmek: HC-05 Bluetooth modülüyle gönderdiğin her harf farklı bir animasyonu başlatsın.
• Renkli gece lambası: WS2812B küpte yavaş renk geçişleri kur; ESP32 kullanıyorsan WLED ile efektleri telefondan yönet.

Sık yapılan hatalar ve çözümleri

LED küp, tek bir projede lehim, transistör, direnç hesabı, çoklama ve bit işlemlerini birlikte öğreten nadir projelerden biridir. 3x3x3 ile başla, kodu ve animasyon mantığını oturttuğunda 74HC595 ile 4x4x4'e, renk istersen WS2812B'ye geç. LED'leri sırayla yakma mantığını önce düz bir sırada denemek istersen Arduino karaşimşek ve yürüyen LED yazısı iyi bir ısınma olur. BlueGrays uygulamasında yürüyen LED, karaşimşek, WS2812B animasyonları ve LED matris projelerini adım adım devre şemaları ve kodlarıyla bulabilirsin.