NeoPixel Matris Arduino: 8x8 ve 16x16 WS2812B LED Panel Rehberi

NeoPixel matris, Arduino ile kurabileceğin en göz alıcı ekranlardan biridir: 8x8 (64 LED) ya da 16x16 (256 LED) adet WS2812B adreslenebilir RGB LED'in bir panel üzerinde dizilmesiyle oluşur ve her pikselin rengini tek bir veri kablosuyla ayrı ayrı ayarlarsın. Kayan yazılar, simgeler, küçük oyunlar, ses spektrumu göstergeleri ve dekoratif animasyonlar için idealdir. Bu rehberde panelin içindeki zikzak dizilimi, x-y koordinatını LED numarasına çeviren fonksiyonu, kayan yazıyı ve animasyonları adım adım öğreneceksin.

Matrisle çalışmak tek bir NeoPixel şeridinden biraz daha fazla dikkat ister. 256 LED tam parlaklıkta 15 amperden fazla akım çekebilir, Arduino Uno'nun 2 KB'lık RAM'i büyük panellerde çabuk dolar, ESP32 ve Pico'nun 3,3 V'luk çıkışı ise bazı panellerde sorun çıkarabilir. Bu yüzden kodların yanında akım hesabını, parlaklık sınırlamayı ve bellek planlamasını da ele alacağız. WS2812B'nin temellerini henüz bilmiyorsan önce WS2812B NeoPixel LED yazısına göz atabilirsin.

NeoPixel LED matris nedir, nasıl çalışır?

Her WS2812B LED'in içinde kırmızı, yeşil ve mavi yongaların yanında küçük bir sürücü entegre bulunur. Mikrodenetleyici veri hattından 800 kHz hızında, LED başına 24 bitlik renk bilgisi gönderir; bu bitlerin sırası yeşil, kırmızı, mavidir (GRB). İlk LED gelen ilk 24 biti kendine alır, kalanını DOUT ucundan bir sonrakine aktarır ve zincir böyle devam eder. Matris panelde de durum aynıdır: 64 ya da 256 LED aslında kıvrılarak kare şekline getirilmiş uzun bir şerittir. Bir LED'e veri göndermek yaklaşık 30 mikrosaniye sürdüğü için 256 LED'lik paneli bir kez güncellemek yaklaşık 7,7 ms tutar; bu da saniyede 100 kareden fazla akıcı animasyon demektir.

Zikzak piksel dizilimi ve XY koordinat fonksiyonu

Kodda bir pikseli (x, y) koordinatıyla düşünmek istersin, ama LED'ler 0'dan başlayan tek bir sıra numarasıyla adreslenir. Esnek panellerin neredeyse tamamında ve 16x16 modellerde LED'ler zikzak (serpantin) düzende dizilir: ilk satır soldan sağa giderken ikinci satır sağdan sola döner, üçüncü satır yine soldan sağa ilerler. Bu düzen üretimi kolaylaştırır, çünkü her satırın sonu bir sonraki satırın başına en kısa yoldan bağlanır. Aşağıdaki tabloda 8x8 zikzak bir panelin ilk dört satırındaki LED numaralarını görebilirsin:

Formül buradan kendiliğinden çıkar: çift satırlarda indeks = y × W + x, tek satırlarda ise indeks = y × W + (W − 1 − x); burada W panelin genişliğidir. Örneğin 8x8 panelde (2, 1) noktası 1 × 8 + (7 − 2) = 13 numaralı LED'dir. Dikkat et: bazı sert PCB'li 8x8 kartlarda bütün satırlar aynı yönde ilerler (düz ya da progressive dizilim); bu durumda formül yalnızca y × W + x olur. Bazı panellerde ise LED'ler satırlar yerine sütunlar boyunca kıvrılır, yani x ile y'nin yer değiştirmesi gerekir. Panelin hangi türde olduğunu anlamanın en kesin yolu, LED'leri sırayla tek tek yakan bir test kodu çalıştırıp ışığın nasıl yürüdüğünü izlemektir.

NeoPixel matris bağlantısı: Arduino Uno, ESP32 ve Pico

Sağlam bir devre için üç küçük parça ekle: veri hattına seri bağlı 300–500 Ω bir direnç (ilk LED'in girişini ani gerilim sıçramalarına karşı korur), panelin 5V ile GND uçları arasına 1000 µF civarında bir elektrolitik kondansatör (kaynak ilk açıldığında oluşan akım darbesini yumuşatır) ve 3,3 V'luk kartlarda gerekiyorsa bir seviye dönüştürücü. WS2812B, 5 V beslemede veri girişinde en az yaklaşık 3,5 V (besleme geriliminin %70'i) görmek ister; ESP32 ve Pico'nun 3,3 V çıkışı çoğu panelde çalışsa da bu sınırın altındadır. Titreşen ya da rastgele renkler görürsen 74AHCT125 gibi bir tampon entegre kullan; ayrıntıları lojik seviye dönüştürücü yazısında bulabilirsin.

Adım adım ilk matris programı (Arduino Uno)

1. Arduino IDE'de Kütüphane Yöneticisi'ni aç ve Adafruit NeoPixel kütüphanesini kur.
2. Paneli tabloya göre bağla: DIN'i 330 Ω dirençle D6'ya, GND'yi Arduino GND'sine, 5V'u kaynağa bağla.
3. Koddaki W ve H değerlerini panelin boyutuna göre ayarla; 16x16 panel için ikisini de 16 yap.
4. İlk denemede parlaklığı düşük tut; setBrightness(30) 8x8 panelin akımını USB'nin kaldırabileceği seviyeye indirir.
5. Kodu yükle; çapraz kayan bir gökkuşağı görmelisin. Renkler satır satır kırık görünüyorsa panelin dizilimi farklıdır, xyIndex fonksiyonunu ona göre düzelt.

1#include <Adafruit_NeoPixel.h>
2
3#define PIN_DATA 6                 // DIN pini (330 ohm ile) / DIN pin (via 330 ohm)
4#define W 8                        // panel genişliği / panel width
5#define H 8                        // panel yüksekliği / panel height
6#define NUM_LEDS (W * H)
7
8Adafruit_NeoPixel strip(NUM_LEDS, PIN_DATA, NEO_GRB + NEO_KHZ800);
9
10// (x, y) koordinatını LED numarasına çevirir (zikzak) / converts (x, y) to LED index (serpentine)
11uint16_t xyIndex(uint8_t x, uint8_t y) {
12  if (y & 1) {
13    return y * W + (W - 1 - x);    // tek satırlar sağdan sola / odd rows run right to left
14  }
15  return y * W + x;                // çift satırlar soldan sağa / even rows run left to right
16}
17
18void setup() {
19  strip.begin();
20  strip.setBrightness(30);         // 0-255, düşük tut / keep it low
21  strip.clear();
22  strip.show();
23}
24
25void loop() {
26  static uint16_t hueBase = 0;
27  for (uint8_t y = 0; y < H; y++) {
28    for (uint8_t x = 0; x < W; x++) {
29      uint16_t hue = hueBase + (x + y) * 4096U;   // çapraz gökkuşağı / diagonal rainbow
30      strip.setPixelColor(xyIndex(x, y), strip.gamma32(strip.ColorHSV(hue)));
31    }
32  }
33  strip.show();                    // tamponu panele gönder / push the buffer to the panel
34  hueBase += 256;                  // renkleri kaydır / shift the colors
35  delay(20);
36}

Kodun kalbi xyIndex() fonksiyonudur: tek satırlarda x'i ters çevirerek zikzak dizilimi gizler, böylece kodun geri kalanında yalnızca koordinatla düşünürsün. ColorHSV() renk tekerleği üzerindeki 0–65535 arası bir ton değerini RGB'ye çevirir; x + y toplamı arttıkça ton kaydığı için çapraz renk şeritleri oluşur. gamma32() gözün parlaklık algısına göre düzeltme yapar ve renk geçişlerini daha doğal gösterir. Son olarak show() çağrılmadıkça hiçbir değişiklik panele gitmez; tüm pikselleri önce belleğe yazıp tek seferde göndermek akıcı görüntünün sırrıdır.

Kayan yazı: Adafruit NeoMatrix ile

Harf ve simge çizmek için piksel piksel uğraşmana gerek yok. Adafruit NeoMatrix kütüphanesi NeoPixel panelini Adafruit GFX uyumlu bir ekrana dönüştürür; böylece OLED ekranlarda kullandığın print(), drawLine(), fillRect() ve drawBitmap() gibi fonksiyonlar matriste de çalışır. Kütüphane Yöneticisi'nden Adafruit NeoMatrix'i kurarken Adafruit GFX ve Adafruit NeoPixel bağımlılıklarını da kur. Kurucu fonksiyondaki bayraklar panelin fiziksel düzenini tarif eder: NEO_MATRIX_TOP + NEO_MATRIX_LEFT ilk LED'in sol üst köşede olduğunu, NEO_MATRIX_ROWS LED'lerin satırlar boyunca dizildiğini, NEO_MATRIX_ZIGZAG ise satırların zikzak döndüğünü söyler; düz dizilimli bir kartta ZIGZAG yerine NEO_MATRIX_PROGRESSIVE yazman yeterli. Varsayılan 5×7 yazı tipi 8 satırlık panele tam oturur ve her karakter boşluğuyla birlikte 6 piksel genişliğindedir. Dokuz harfli yazı 54 piksel tutar; textWidth sabiti bunu otomatik hesaplar, x bu değerin altına düşünce yazı yeniden sağdan girer ve rengi değişir.

1#include <Adafruit_GFX.h>
2#include <Adafruit_NeoMatrix.h>
3#include <Adafruit_NeoPixel.h>
4
5#define PIN_DATA 6
6
7// 8x8 panel, ilk LED sol üstte, zikzak satırlar / 8x8 panel, first LED top-left, zigzag rows
8Adafruit_NeoMatrix matrix(8, 8, PIN_DATA,
9  NEO_MATRIX_TOP + NEO_MATRIX_LEFT + NEO_MATRIX_ROWS + NEO_MATRIX_ZIGZAG,
10  NEO_GRB + NEO_KHZ800);
11
12const char text[] = "BlueGrays";
13const int textWidth = (sizeof(text) - 1) * 6;   // karakter başına 6 piksel / 6 pixels per character
14int x = 8;                                      // yazı sağ kenardan başlar / text starts at the right edge
15uint8_t colorStep = 0;
16
17void setup() {
18  matrix.begin();
19  matrix.setTextWrap(false);       // satır kaydırma kapalı / no line wrap
20  matrix.setBrightness(40);
21  matrix.setTextColor(matrix.Color(255, 0, 0));
22}
23
24void loop() {
25  matrix.fillScreen(0);
26  matrix.setCursor(x, 0);
27  matrix.print(text);
28  if (--x < -textWidth) {          // yazı panelden tamamen çıktı / text fully left the panel
29    x = matrix.width();
30    colorStep = (colorStep + 1) % 3;
31    if (colorStep == 0) matrix.setTextColor(matrix.Color(255, 0, 0));
32    if (colorStep == 1) matrix.setTextColor(matrix.Color(0, 255, 0));
33    if (colorStep == 2) matrix.setTextColor(matrix.Color(0, 0, 255));
34  }
35  matrix.show();
36  delay(80);                       // kayma hızı / scroll speed
37}

Arduino Uno'da bellek sınırı

Arduino Uno'nun ATmega328P işlemcisinde yalnızca 2048 bayt RAM vardır ve her LED için 3 baytlık renk tamponu gerekir. 8x8 panel 192 baytla rahatça sığar, 16x16 panel ise 768 baytla RAM'in üçte birinden fazlasını tek başına kaplar. İşin sinsi tarafı şu: Adafruit NeoPixel bu tamponu program çalışırken ayırdığı için derleme sonunda görünen global değişken kullanım oranına dahil olmaz. Derleme %70 doluluk gösterse bile panel tamponu eklendiğinde bellek bitebilir; kart kilitlenir ya da anlamsız renkler görürsün. Ayrıca AVR kartlarda show() çalışırken kesmeler kapatılır; 256 LED'de bu yaklaşık 7,7 ms sürer, bu sırada millis() geri kalabilir ve Serial'den gelen veriler kaybolabilir. Büyük paneller için 8 KB RAM'li Arduino Mega ya da yüzlerce kilobayt RAM'i olan ESP32 çok daha rahat bir seçimdir.

Akım tüketimi ve parlaklık sınırlama

Bir WS2812B'nin her renk kanalı tam parlaklıkta yaklaşık 20 mA çeker; üç kanal birden yandığında, yani beyazda, LED başına 60 mA eder. Kaba hesap için I ≈ LED sayısı × 60 mA × (parlaklık / 255) formülünü kullanabilirsin. 16x16 panel tam beyazda 256 × 60 = 15.360 mA, yani 15 A'den fazla çeker; bu hem güç kaynaklarını hem de panelin ince bakır yollarını zorlar. İyi haber şu ki matris çok parlaktır: iç mekânda 255 üzerinden 20–50 arası bir parlaklık zaten göz alacak kadar net görünür. Gerçek animasyonlarda bütün LED'ler aynı anda beyaz yanmadığı için ortalama akım hesaplanandan epey düşüktür, ama kaynağı en kötü duruma göre seçmek ya da yazılımla sınırlamak gerekir.

16x16 panelde akımı yalnızca bir uçtan verirsen uzak köşedeki LED'lerde gerilim düşer ve beyaz renk sarımsı ya da kırmızımsı görünür. Bunu önlemek için 5V ve GND'yi panelin hem giriş hem çıkış ucundan, en az 0,75 mm² kesitli kablolarla besle; buna güç enjeksiyonu denir. Yazılım tarafında FastLED kütüphanesinin setMaxPowerInVoltsAndMilliamps(5, 2000) fonksiyonu her karede tahmini akımı hesaplar ve sınır aşılacaksa parlaklığı otomatik olarak düşürür. Pil kullanıyorsan devrenin ne kadar dayanacağını pil ömrü hesaplayıcısıyla kontrol edebilir, kaynak seçimiyle ilgili ayrıntılar için Arduino güç besleme yazısına bakabilirsin.

ESP32 ile 16x16 matris animasyonu (FastLED)

ESP32, geniş RAM'i ve 240 MHz'lik işlemcisiyle büyük paneller için çok daha rahat bir seçimdir; NeoPixel sinyalini RMT donanım birimiyle ürettiği için işlemciyi de fazla meşgul etmez. Aşağıdaki kod FastLED ile 16x16 panelde iz bırakarak süzülen iki renkli nokta çizer. beatsin8() zamanla sinüs biçiminde salınan bir koordinat üretir, fadeToBlackBy() ise her karede bütün pikselleri biraz karartarak kuyruk etkisi yaratır. Kütüphane Yöneticisi'nden FastLED'in güncel sürümünü kurman yeterli; güncel sürümler ESP32 Arduino çekirdeğinin 2.x ve 3.x sürümlerini destekler.

1#include <FastLED.h>
2
3#define DATA_PIN 16                // DIN -> GPIO 16 (330 ohm ile) / DIN -> GPIO 16 (via 330 ohm)
4#define W 16
5#define H 16
6#define NUM_LEDS (W * H)
7
8CRGB leds[NUM_LEDS];
9
10// Zikzak dizilim için koordinat dönüşümü / coordinate mapping for serpentine layout
11uint16_t xyIndex(uint8_t x, uint8_t y) {
12  return (y & 1) ? (y * W + (W - 1 - x)) : (y * W + x);
13}
14
15void setup() {
16  FastLED.addLeds<WS2812B, DATA_PIN, GRB>(leds, NUM_LEDS);
17  FastLED.setBrightness(60);                       // genel parlaklık / global brightness
18  FastLED.setMaxPowerInVoltsAndMilliamps(5, 2000); // 5 V, en fazla 2 A / 5 V, max 2 A
19  FastLED.clear(true);
20}
21
22void loop() {
23  static uint8_t hue = 0;
24  fadeToBlackBy(leds, NUM_LEDS, 30);               // iz efekti / trail effect
25
26  uint8_t px1 = beatsin8(13, 0, W - 1);            // sinüs salınımlı koordinatlar / sine-wave coordinates
27  uint8_t py1 = beatsin8(17, 0, H - 1);
28  uint8_t px2 = beatsin8(11, 0, W - 1, 0, 64);
29  uint8_t py2 = beatsin8(7, 0, H - 1, 0, 128);
30
31  leds[xyIndex(px1, py1)] = CHSV(hue, 255, 255);
32  leds[xyIndex(px2, py2)] = CHSV(hue + 128, 255, 255);
33
34  FastLED.show();
35  hue++;
36  delay(16);                                       // yaklaşık 60 kare/sn / about 60 fps
37}

Raspberry Pi Pico ve MicroPython ile NeoPixel matris

Pico'nun MicroPython yazılımında neopixel modülü hazır gelir; ek dosya kopyalamana gerek yoktur. Modül sinyal zamanlamasını kendisi üretir, sen yalnızca np[i] = (r, g, b) ile renk atayıp write() ile panele gönderirsin. MicroPython'da Adafruit kütüphanesindeki gibi bir setBrightness fonksiyonu olmadığı için parlaklığı renk değerlerini bir katsayıyla çarparak kendin sınırlarsın. Aşağıdaki örnek 8x8 panelde bir kalp simgesini yavaşça parlatıp söndürür; simge, her satırı bir bayt olan bir bitmap dizisinden çizilir ve en soldaki bit x = 0 sütununa karşılık gelir.

1from machine import Pin
2from neopixel import NeoPixel
3import time
4
5W, H = 8, 8
6np = NeoPixel(Pin(2), W * H)       # DIN -> GP2 (330 ohm ile) / DIN -> GP2 (via 330 ohm)
7BRIGHTNESS = 0.1                   # %10 parlaklık / 10% brightness
8
9HEART = [
10    0b01100110,
11    0b11111111,
12    0b11111111,
13    0b11111111,
14    0b01111110,
15    0b00111100,
16    0b00011000,
17    0b00000000,
18]
19
20def xy_index(x, y):
21    # zikzak dizilim / serpentine layout
22    if y % 2:
23        return y * W + (W - 1 - x)
24    return y * W + x
25
26def draw_bitmap(rows, color):
27    r, g, b = color
28    c = (int(r * BRIGHTNESS), int(g * BRIGHTNESS), int(b * BRIGHTNESS))
29    for y in range(H):
30        for x in range(W):
31            on = rows[y] & (0x80 >> x)     # soldaki bit x=0 / leftmost bit is x=0
32            np[xy_index(x, y)] = c if on else (0, 0, 0)
33    np.write()                     # panele gönder / push to the panel
34
35while True:
36    for level in range(0, 256, 8):         # kalp yavaşça yanar / heart fades in
37        draw_bitmap(HEART, (level, 0, 0))
38        time.sleep_ms(20)
39    for level in range(255, -1, -8):       # ve söner / and fades out
40        draw_bitmap(HEART, (level, 0, 0))
41        time.sleep_ms(20)

NeoPixel matris ile proje fikirleri

• Kayan yazı tabelası: ESP32 ile internetten alınan mesajları ya da saati panelde kaydır; saat için ESP32 NTP saat yazısındaki yöntemi kullanabilirsin.
• Yılan ve blok oyunları: 16x16 panel ve bir joystick ile renkli bir mini oyun konsolu yap.
• Müziğe duyarlı spektrum: Mikrofonla ölçülen ses seviyesini renkli sütunlar halinde göster; ayrıntılar müziğe duyarlı LED yazısında.
• Simge rozeti: 8x8 panelde gülen yüz, kalp ve ok gibi simgeleri bir butonla sırayla değiştir.
• Renkli termometre: DHT11 ile ölçülen sıcaklığa göre maviden kırmızıya dolan bir çubuk çiz.
• Telefondan kontrol: ESP32'ye WLED yükleyip paneli hazır 2D efektlerle Wi-Fi üzerinden yönet.
• Yılbaşı süsü: Kar yağışı ve yıldız animasyonlarıyla yılbaşı ağacı LED projene görsel bir panel ekle.

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

NeoPixel matris, uygun fiyatlı bir panelle projelerine renkli ve hareketli bir ekran kazandırmanın en eğlenceli yoludur. Küçük başla: önce 8x8 paneli düşük parlaklıkta çalıştır, xyIndex fonksiyonunu oturt, ardından kayan yazıya ve 16x16 animasyonlara geç. Yalnızca tek renkli yazı ve sayı göstereceksen MAX7219 LED matris daha az akım çeken bir alternatiftir. BlueGrays uygulamasında WS2812B polis çakarı, karaşimşek ve animasyon projelerini, 8x8 ve 16x16 matris yılan oyunlarını devre şemaları ve kodlarıyla adım adım inceleyebilirsin.