Rehberler · 8 dk okuma

Arduino RGB Şerit LED Kontrolü: MOSFET ile 12 V Renk Karıştırma

Arduino RGB şerit LED kontrolü: 12 V 5050 şeridi IRLZ44N MOSFET ile sürme, üç kanal PWM, renk geçişi, potansiyometreyle renk seçimi, ESP32 ve Pico kodu.

Arduino RGB şerit LED kontrolü, 12 V ile çalışan adreslenemeyen 5050 RGB şeridin kırmızı, yeşil ve mavi kanallarını üç ayrı PWM sinyaliyle sürüp istediğin rengi elde etmektir. Arduino'nun pinleri şeridin çektiği amperlerce akımı ve 12 V'u kaldıramadığı için araya her kanal için bir MOSFET girer: Arduino yalnızca MOSFET'in kapısına 5 V'luk sinyal gönderir, asıl akımı MOSFET taşır. Böylece metrelerce şeridi küçük bir mikrodenetleyiciyle güvenle kontrol edebilirsin.

Bu rehberde 5050 şeridin iç yapısını, doğru MOSFET seçimini, devre bağlantısını ve adaptör hesabını öğreneceksin. Ardından Arduino Uno ile renk karıştırma, millis() tabanlı yumuşak renk geçişi ve potansiyometreyle renk ile parlaklık seçimi yapacak, aynı devreyi ESP32'nin LEDC birimi ve Raspberry Pi Pico'nun MicroPython PWM'iyle çalıştıracaksın. Yazının içinde şeridin WS2812B'den farkını, sonunda da en sık yapılan hataların çözümlerini bulacaksın.

RGB şerit LED nedir, nasıl çalışır?

Adreslenemeyen RGB şeritte her 5050 SMD paketin içinde kırmızı, yeşil ve mavi olmak üzere üç ayrı LED çipi bulunur. Şerit, üç LED ve her renk için bir akım sınırlama direncinden oluşan 12 V'luk segmentlerin paralel bağlanmasıyla oluşur; seri bağlı üç LED'in toplam ileri gerilimi renge göre yaklaşık 6–9 V'tur, kalan gerilimi direnç üstlenir. Şeridin dört ucu vardır: ortak artı (+12V) ile R, G ve B. Yani şerit ortak anotludur: bir rengin yanması için o rengin hattını GND'ye çekmen gerekir. Tüm şerit aynı anda aynı rengi gösterir; LED'leri tek tek farklı renkte yakamazsın. Rengi her kanalın PWM doluluk oranıyla belirlersin: kırmızı ve yeşil tam açıksa sarı, üçü tam açıksa beyaza yakın bir ışık görürsün.

Özellik30 LED/m şerit60 LED/m şerit
LED tipi5050 SMD (5,0 × 5,0 mm, 3 çip)5050 SMD (5,0 × 5,0 mm, 3 çip)
Çalışma gerilimi12 V DC12 V DC
Güç (tam beyaz)Yaklaşık 7,2 W/mYaklaşık 14,4 W/m
Akım (tam beyaz)Yaklaşık 0,6 A/mYaklaşık 1,2 A/m
Kanal başına akımYaklaşık 0,2 A/mYaklaşık 0,4 A/m
Kesme aralığı3 LED'de bir (10 cm)3 LED'de bir (5 cm)
Uçlar+12V, R, G, B+12V, R, G, B

RGB şerit ile WS2812B arasındaki fark

İki şerit de RGB ışık verir ama kontrol mantıkları tamamen farklıdır. Adreslenemeyen şerit bir lamba gibidir: üç kanalın parlaklığını değiştirerek tüm şeridin rengini ayarlarsın. WS2812B NeoPixel şeritte ise her LED'in içinde küçük bir sürücü yonga vardır ve tek bir veri hattıyla her LED'e ayrı renk gönderebilirsin. Aşağıdaki tablo hangisini seçeceğine karar vermene yardımcı olur:

Özellik12 V RGB şerit (5050)WS2812B şerit
KontrolTüm şerit tek renkHer LED ayrı renk
Besleme12 V (24 V sürümleri de var)5 V
Kablo4 uç: +12V, R, G, B3 uç: 5V, DIN, GND
Sürücü devreHer kanal için bir MOSFETGerekmez, tek veri pini yeter
KodanalogWrite / PWMFastLED ya da Adafruit NeoPixel kütüphanesi
Akım (60 LED/m, tam beyaz)Yaklaşık 1,2 A/m (12 V)Yaklaşık 3,6 A/m (5 V)
Gerilim düşümü5 m'ye kadar genellikle sorun olmazUzun şeritte birkaç noktadan besleme gerekir
EfektlerSabit renk, renk geçişi, nefesKayan ışık, gökkuşağı, animasyon
FiyatUcuzDaha pahalı

Neden MOSFET gerekir ve hangisini seçmeliyim?

Arduino Uno'nun bir pini yaklaşık 20 mA akım vermek için tasarlanmıştır (mutlak sınır 40 mA), oysa 5 metrelik 60 LED/m'lik bir şeridin tek kanalı 2 A çekebilir. Üstelik şerit 12 V ile çalışır. N kanallı bir MOSFET bu işi alçak taraf anahtarı olarak çözer: Drain ucu şeridin renk hattına, Source ucu GND'ye bağlanır ve Gate'e uygulanan gerilim MOSFET'i açıp kapatır. Kritik nokta, lojik seviye bir MOSFET seçmektir; IRF520 ya da IRF540N gibi standart MOSFET'ler tam açılmak için yaklaşık 10 V ister, 5 V'ta yarı açık kalıp ısınır. MOSFET'te harcanan güç P = I² × Rds(on) formülüyle bulunur: 2 A ve 0,025 Ω için 2 × 2 × 0,025 = 0,1 W eder, yani soğutucuya gerek kalmaz. Temeller için Arduino MOSFET kullanımı yazısına göz atabilirsin.

MOSFETKapı gerilimiRds(on)Uygunluk
IRLZ44NLojik seviye, 4–5 V'ta tam açık0,025 Ω (5 V'ta)Uno ve Nano için ideal; 3,3 V'ta yalnız kısa şeritlerde
IRLB87213,3 V'ta da iyi açılırYaklaşık 0,009 Ω (4,5 V'ta)ESP32 ve Pico için en iyi seçeneklerden
AO3400 (SMD)2,5 V'ta açılırYaklaşık 0,03 Ω (4,5 V'ta)Küçük kartlar, kanal başına 2–3 A
IRF520 / IRF540NYaklaşık 10 V ister5 V'ta yüksekÖnerilmez, ısınır
Şeridin R, G ya da B ucunu asla doğrudan Arduino pinine, +12V ucunu da hiçbir koşulda Arduino'nun 5V ya da sinyal pinlerine bağlama. 12 V'un bir pine ulaşması mikrodenetleyiciyi anında yakar. Devreyi kurarken adaptörü fişten çek, bağlantıları kontrol ettikten sonra tak.

Devre şeması ve bağlantı tablosu

Her renk kanalı için aynı küçük devreyi üç kez kurarsın. IRLZ44N'yi yazılı yüzü sana bakacak şekilde tuttuğunda bacaklar soldan sağa Gate, Drain, Source sırasındadır; bacak sırasını transistör aracından da kontrol edebilirsin. Gate ile kart pini arasına 220 Ω direnç koy; bu direnç kapı kapasitesi şarj olurken pinden çekilen ani akımı sınırlar. Gate ile GND arasına da 10 kΩ pull-down direnç ekle; kart açılırken ya da kod yüklenirken pinler boşta kaldığında MOSFET'in kendi kendine açılıp şeridi rastgele yakmasını engeller. En önemli kural: 12 V adaptörün eksisi ile kartın GND'si mutlaka birleşmelidir, aksi halde kapı sinyalinin referansı olmaz. Bu konuyu ortak GND yazısında ayrıntılı anlattık.

BağlantıArduino UnoESP32Raspberry Pi Pico
Kırmızı MOSFET Gate (220 Ω üzerinden)D9GPIO 25GP11
Yeşil MOSFET Gate (220 Ω üzerinden)D10GPIO 26GP12
Mavi MOSFET Gate (220 Ω üzerinden)D11GPIO 27GP13
MOSFET Drain uçlarıŞeridin R, G, B uçlarıŞeridin R, G, B uçlarıŞeridin R, G, B uçları
MOSFET Source uçlarıGNDGNDGND
Renk tonu potansiyometresi (orta uç)A0GPIO 34GP26 (ADC0)
Parlaklık potansiyometresi (orta uç)A1KullanılmıyorKullanılmıyor
Potansiyometre uçları5V ve GND3V3 ve GND3V3 ve GND
12 V adaptör eksisiGNDGNDGND
Şerit +12V ucuAdaptör artısıAdaptör artısıAdaptör artısı

Güç hesabı: hangi adaptörü almalıyım?

Adaptörü seçmek için önce şeridin tam beyazdaki akımını hesapla: I = metre × A/m. 60 LED/m'lik 5 metre şerit 5 × 1,2 = 6 A çeker; güç P = V × I formülüyle 12 × 6 = 72 W eder. Adaptörü her zaman yaklaşık %20 pay bırakarak seç: bu örnekte 12 V 8 A (96 W) uygun olur. 30 LED/m'lik 2 metrelik bir şerit ise 1,2 A çektiği için 12 V 2 A'lik adaptör yeterlidir. Kabloyu da akıma göre seç; 5 A üzerindeki akımlarda jumper kablo yerine en az 0,75 mm² kesitli kablo kullan. Kartı aynı adaptörden beslemek istersen Arduino Uno'nun güç jakı ya da Vin pini 12 V'u kabul eder ve hafif yüklerde sorunsuz çalışır. ESP32 geliştirme kartlarında ve Pico'da ise 12 V'u doğrudan bağlama; Pico'nun VSYS girişi en fazla 5,5 V kabul eder. Bu kartlar için 12 V'u LM2596 voltaj düşürücü ile 5 V'a indirip ESP32'de 5V pinine, Pico'da VSYS pinine vermek en temiz çözümdür. Hesapları Ohm Kanunu hesaplayıcı ile kontrol edebilir, ayrıntılar için elektriksel güç hesaplama yazısını okuyabilirsin.

Adım adım kurulum

  1. Adaptörü prize takmadan önce tüm devreyi kur; devre enerjiliyken bağlantı değiştirme.
  2. Şeridin lehim pedlerine dört kablo lehimle ya da hazır konnektör kullan; +12V ucunu adaptörün artısına bağla.
  3. Üç MOSFET'i yerleştir ve Source bacaklarını ortak GND hattına bağla. Breadboard hatları yaklaşık 1 A için uygundur; birkaç amperlik şeritlerde akım yolunu lehimli bağlantı ya da klemensle kur.
  4. Her MOSFET'in Drain bacağını şeridin ilgili renk ucuna (R, G, B) bağla.
  5. Gate bacaklarını 220 Ω dirençlerle D9, D10 ve D11'e bağla; her Gate ile GND arasına 10 kΩ direnç ekle.
  6. 12 V adaptörün eksisini Arduino'nun GND pinine bağlayarak ortak toprağı oluştur.
  7. Arduino'yu USB ile bilgisayara bağla, ilk kodu yükle ve ardından adaptörü tak.
  8. Her rengin tek başına yandığını kontrol et; yanlış renk yanıyorsa kodda pin numaralarını yer değiştir.

İlk kod: Arduino ile renk karıştırma

Devreyi kurduktan sonra her kanalı tek tek yakarak test etmek en güvenli başlangıçtır. Aşağıdaki kod Uno'nun 9, 10 ve 11 numaralı PWM pinlerini kullanır ve setColor() fonksiyonuyla altı farklı rengi sırayla gösterir. PWM'in mantığını merak ediyorsan PWM nedir yazısına bakabilirsin.

C++ (Arduino IDE)
1const int PIN_R = 9;    // kırmızı MOSFET kapısı / red MOSFET gate
2const int PIN_G = 10;   // yeşil MOSFET kapısı / green MOSFET gate
3const int PIN_B = 11;   // mavi MOSFET kapısı / blue MOSFET gate
4
5void setColor(uint8_t r, uint8_t g, uint8_t b) {
6  analogWrite(PIN_R, r);   // 255 = tam parlak, 0 = sönük / 255 = full, 0 = off
7  analogWrite(PIN_G, g);
8  analogWrite(PIN_B, b);
9}
10
11void setup() {
12  pinMode(PIN_R, OUTPUT);
13  pinMode(PIN_G, OUTPUT);
14  pinMode(PIN_B, OUTPUT);
15  setColor(0, 0, 0);       // başlangıçta kapalı / off at start
16}
17
18void loop() {
19  setColor(255, 0, 0);     delay(1000);   // kırmızı / red
20  setColor(0, 255, 0);     delay(1000);   // yeşil / green
21  setColor(0, 0, 255);     delay(1000);   // mavi / blue
22  setColor(255, 120, 0);   delay(1000);   // turuncu / orange
23  setColor(160, 0, 255);   delay(1000);   // mor / purple
24  setColor(255, 255, 255); delay(1000);   // beyaz / white
25}

Burada önemli bir fark var: Tek bir ortak anotlu RGB LED'i doğrudan pine bağladığında mantık terstir (255 söndürür), ama MOSFET'li devrede analogWrite(pin, 255) MOSFET'i tamamen açar ve rengi tam parlaklıkta yakar; 0 ise söndürür. Uno'da 9 ve 10 numaralı pinler Timer1'e, 11 numaralı pin Timer2'ye bağlıdır ve üçü de yaklaşık 490 Hz'te çalışır; bu frekansta göz titreme fark etmez. Ancak tone() fonksiyonu Timer2'yi kullandığı için 11 numaralı pinin PWM'ini bozar, Servo kütüphanesi de 9 ve 10'daki PWM'i devre dışı bırakır. Projende buzzer ya da servo varsa pinleri buna göre planla. Ayrıca şeritteki renklerin parlaklığı eşit değildir; beyaz mavimsi görünürse mavi kanalı 200 civarına düşürerek dengeleyebilirsin.

Yavaş renk geçişi: millis() ile renk çarkı

Şeridin tüm renkleri yumuşakça dolaşması için renk çarkı mantığı kullanılır: 0–767 arasındaki bir ton değeri üç bölgeye ayrılır. İlk 256 adımda kırmızı azalıp yeşil artar, sonraki 256 adımda yeşilden maviye, son bölümde maviden kırmızıya geçilir. İki kanalın toplamı her adımda 255 olduğu için renkler kopmadan birbirine akar. Kodda delay() yerine millis() kullandığımız için loop() içinde buton okumak ya da sensör ölçmek gibi başka işler de yapabilirsin. Gözümüz parlaklığı doğrusal algılamaz: düşük değerlerdeki küçük değişimler çok belirgin, yüksek değerlerdekiler ise zor fark edilir. Bu yüzden koddaki gamma8() fonksiyonu değeri karesiyle ölçekler (v × v / 255) ve kısık ışıktaki geçişleri daha doğal hale getirir. STEP_MS değerini büyütürsen tam tur süresi uzar; 15 ms ile bir tur yaklaşık 11,5 saniye sürer.

C++ (Arduino IDE)
1const int PIN_R = 9;    // kırmızı / red
2const int PIN_G = 10;   // yeşil / green
3const int PIN_B = 11;   // mavi / blue
4
5const unsigned long STEP_MS = 15;   // 768 x 15 ms = yaklaşık 11,5 s / about 11.5 s per cycle
6unsigned long lastStep = 0;
7int hue = 0;                        // renk tonu 0-767 / hue 0-767
8
9uint8_t gamma8(uint8_t v) {
10  return (uint16_t)v * v / 255;     // basit gama düzeltmesi / simple gamma correction
11}
12
13void setColor(uint8_t r, uint8_t g, uint8_t b) {
14  analogWrite(PIN_R, gamma8(r));
15  analogWrite(PIN_G, gamma8(g));
16  analogWrite(PIN_B, gamma8(b));
17}
18
19void wheel(int h) {
20  uint8_t p = h % 256;
21  if (h < 256)      setColor(255 - p, p, 0);   // kırmızı -> yeşil / red -> green
22  else if (h < 512) setColor(0, 255 - p, p);   // yeşil -> mavi / green -> blue
23  else              setColor(p, 0, 255 - p);   // mavi -> kırmızı / blue -> red
24}
25
26void setup() {
27  pinMode(PIN_R, OUTPUT);
28  pinMode(PIN_G, OUTPUT);
29  pinMode(PIN_B, OUTPUT);
30}
31
32void loop() {
33  if (millis() - lastStep >= STEP_MS) {
34    lastStep = millis();
35    wheel(hue);
36    hue = (hue + 1) % 768;
37  }
38  // burada buton ya da sensör okuyabilirsin / you can read buttons or sensors here
39}

Potansiyometreyle renk ve parlaklık seçimi

Renk seçimini elle yapmak için iki potansiyometre yeterli: A0'daki potansiyometre renk tonunu (0–767), A1'deki ise genel parlaklığı (0–255) belirler. analogRead() 0–1023 arası değer döndürdüğü için map() ile istediğimiz aralığa ölçekliyoruz. Parlaklık, her kanal değerinin bri / 255 oranıyla çarpılmasıyla uygulanır; böylece renk tonu korunurken ışık kısılır. Üç ayrı potansiyometreyle R, G ve B'yi doğrudan ayarlamak da mümkündür, ama tek düğmeli renk çarkı çok daha sezgiseldir ve beyaz dışında tüm doygun renklere ulaşmanı sağlar.

C++ (Arduino IDE)
1const int PIN_R = 9;
2const int PIN_G = 10;
3const int PIN_B = 11;
4const int POT_HUE = A0;   // renk tonu / hue
5const int POT_BRI = A1;   // parlaklık / brightness
6
7void setup() {
8  pinMode(PIN_R, OUTPUT);
9  pinMode(PIN_G, OUTPUT);
10  pinMode(PIN_B, OUTPUT);
11}
12
13void loop() {
14  int hue = map(analogRead(POT_HUE), 0, 1023, 0, 767);
15  int bri = map(analogRead(POT_BRI), 0, 1023, 0, 255);
16
17  uint8_t r, g, b;
18  uint8_t p = hue % 256;
19  if (hue < 256)      { r = 255 - p; g = p;       b = 0; }       // kırmızı -> yeşil / red -> green
20  else if (hue < 512) { r = 0;       g = 255 - p; b = p; }       // yeşil -> mavi / green -> blue
21  else                { r = p;       g = 0;       b = 255 - p; } // mavi -> kırmızı / blue -> red
22
23  analogWrite(PIN_R, (uint16_t)r * bri / 255);   // parlaklığı uygula / apply brightness
24  analogWrite(PIN_G, (uint16_t)g * bri / 255);
25  analogWrite(PIN_B, (uint16_t)b * bri / 255);
26  delay(20);
27}

ESP32 ile RGB şerit kontrolü (LEDC)

ESP32'de PWM için donanımsal LEDC birimi kullanılır; frekansı ve çözünürlüğü sen belirlersin. 5 kHz ve 8 bit, hem titreşimsiz bir ışık hem de tanıdık 0–255 aralığı verir. Arduino core 3.x'te ledcAttach(pin, frekans, çözünürlük) ve ledcWrite(pin, değer) kullanılırken 2.x'te önce ledcSetup() ile bir kanal kurulur, ledcAttachPin() ile pine bağlanır ve ledcWrite() kanala yazar; aşağıdaki kod iki sürümü de #if ile destekler. ESP32'nin pinleri 3,3 V verdiği için tablodaki IRLB8721 gibi düşük kapı gerilimli bir MOSFET seçmek önemlidir. Potansiyometreyi Wi-Fi açıkken de sorunsuz çalışan ADC1 pinlerinden GPIO 34'e bağladık; ADC 12 bit olduğu için değerler 0–4095 arasındadır ve gürültüyü azaltmak için sekiz okumanın ortalaması alınır. Kartın temelleri için ESP32 nedir yazısına bakabilirsin.

C++ (Arduino IDE)
1const int PIN_R = 25;       // kırmızı MOSFET kapısı / red MOSFET gate
2const int PIN_G = 26;       // yeşil / green
3const int PIN_B = 27;       // mavi / blue
4const int POT_HUE = 34;     // ADC1, yalnız giriş / ADC1, input only
5const int PWM_FREQ = 5000;  // 5 kHz, titreşimsiz / flicker-free
6const int PWM_RES = 8;      // 8 bit: 0-255
7
8void setColor(uint8_t r, uint8_t g, uint8_t b) {
9#if ESP_ARDUINO_VERSION_MAJOR >= 3
10  ledcWrite(PIN_R, r);      // core 3.x: pine yaz / write to pin
11  ledcWrite(PIN_G, g);
12  ledcWrite(PIN_B, b);
13#else
14  ledcWrite(0, r);          // core 2.x: kanala yaz / write to channel
15  ledcWrite(1, g);
16  ledcWrite(2, b);
17#endif
18}
19
20void setup() {
21#if ESP_ARDUINO_VERSION_MAJOR >= 3
22  ledcAttach(PIN_R, PWM_FREQ, PWM_RES);
23  ledcAttach(PIN_G, PWM_FREQ, PWM_RES);
24  ledcAttach(PIN_B, PWM_FREQ, PWM_RES);
25#else
26  ledcSetup(0, PWM_FREQ, PWM_RES);
27  ledcSetup(1, PWM_FREQ, PWM_RES);
28  ledcSetup(2, PWM_FREQ, PWM_RES);
29  ledcAttachPin(PIN_R, 0);
30  ledcAttachPin(PIN_G, 1);
31  ledcAttachPin(PIN_B, 2);
32#endif
33  analogReadResolution(12);  // 0-4095
34  setColor(0, 0, 0);
35}
36
37void loop() {
38  long sum = 0;
39  for (int i = 0; i < 8; i++) {
40    sum += analogRead(POT_HUE);   // 8 okumayı topla / sum 8 readings
41  }
42  int hue = map(sum / 8, 0, 4095, 0, 767);
43  uint8_t p = hue % 256;
44  if (hue < 256)      setColor(255 - p, p, 0);   // kırmızı -> yeşil / red -> green
45  else if (hue < 512) setColor(0, 255 - p, p);   // yeşil -> mavi / green -> blue
46  else                setColor(p, 0, 255 - p);   // mavi -> kırmızı / blue -> red
47  delay(20);
48}

Raspberry Pi Pico ile MicroPython kodu

Pico'da her GPIO pini PWM üretebilir ve duty_u16() 0–65535 arası değer alır. Kodda 0–255 renk değerlerini 257 ile çarparak bu aralığa taşıyoruz (255 × 257 = 65535). Potansiyometre GP26'ya (ADC0) bağlıdır; read_u16() de 0–65535 döndürdüğü için ton değerine kolayca çevrilir. GP12 ve GP13 aynı PWM dilimini (slice 6) paylaşır; ikisine aynı frekansı verdiğimiz için sorun çıkmaz, ama farklı frekans ayarlamaya çalışırsan son ayar ikisini birden etkiler. Pico 3,3 V ile çalıştığından ESP32 için verdiğimiz MOSFET önerisi burada da geçerlidir. Kurulum için Raspberry Pi Pico nedir yazısını okuyabilirsin.

MicroPython
1from machine import Pin, PWM, ADC
2import time
3
4pins = (11, 12, 13)                      # R, G, B MOSFET kapıları / gates
5leds = []
6for p in pins:
7    pwm = PWM(Pin(p))
8    pwm.freq(1000)                       # 1 kHz PWM
9    pwm.duty_u16(0)                      # başlangıçta kapalı / off at start
10    leds.append(pwm)
11
12pot = ADC(26)                            # GP26 = ADC0
13
14def set_color(r, g, b):
15    # 0-255 değerini 0-65535'e çevir / convert 0-255 to 0-65535
16    leds[0].duty_u16(r * 257)
17    leds[1].duty_u16(g * 257)
18    leds[2].duty_u16(b * 257)
19
20def wheel(hue):
21    p = hue % 256
22    if hue < 256:
23        return 255 - p, p, 0             # kırmızı -> yeşil / red -> green
24    elif hue < 512:
25        return 0, 255 - p, p             # yeşil -> mavi / green -> blue
26    return p, 0, 255 - p                 # mavi -> kırmızı / blue -> red
27
28while True:
29    hue = pot.read_u16() * 767 // 65535  # 0-767 ton / hue
30    set_color(*wheel(hue))
31    time.sleep_ms(20)

RGB şerit LED ile proje fikirleri

  • Müziğe duyarlı ambiyans: Bir ses sensörüyle şeridin rengini ve parlaklığını müziğin ritmine göre değiştir; ayrıntılar müziğe duyarlı LED yazısında.
  • Kumandalı TV arkası aydınlatma: IR alıcı ve kumanda ile rengi ve parlaklığı koltuktan değiştir.
  • Hareketle yanan merdiven ışığı: PIR sensörü birini algıladığında şeridi yavaşça aç, bir süre sonra söndür.
  • Otomatik gece lambası: LDR ortam karardığında sıcak bir turuncu tonu kısık parlaklıkta yaksın.
  • Telefondan kontrol: ESP32 ile bir web sunucusu kurup renk seçiciyi tarayıcıdan kullan.
  • Gün doğumu alarmı: Uyanma saatinden 20 dakika önce şeridi koyu kırmızıdan beyaza doğru yavaşça aç.

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

BelirtiOlası nedenÇözüm
Şerit hiç yanmıyorOrtak GND yok ya da +12V ucu bağlı değilAdaptör eksisini kartın GND'sine bağla, şeridin +12V ucunu kontrol et
Bir renk kod ne derse desin sürekli yanıyorMOSFET'in Drain ve Source bacakları ters ya da MOSFET yanmışBacak sırasını (G-D-S) kontrol et, gerekirse MOSFET'i değiştir
Açılışta şerit kendiliğinden yanıp sönüyorGate pull-down direnci yokHer Gate ile GND arasına 10 kΩ ekle
MOSFET çok ısınıyorLojik seviye olmayan MOSFET ya da 3,3 V'ta yetersiz kapı gerilimiIRLZ44N, IRLB8721 gibi lojik seviye MOSFET kullan
Renkler karışık (kırmızı yerine yeşil yanıyor)Şerit etiketleri ya da kablo sırası farklıKodda PIN_R, PIN_G, PIN_B değerlerini yer değiştir
Şeridin sonu sarımsı ve solukUzun şeritte gerilim düşümü5 m'den uzun şeritleri iki uçtan besle, kalın kablo kullan
Kart resetleniyor ya da yeniden başlıyorAdaptör yetersiz, gerilim çöküyorDaha güçlü adaptör kullan, kartı ayrı bir regülatörden besle
Kamerada titreme ya da çizgilerDüşük PWM frekansıESP32 ve Pico'da frekansı 1–5 kHz'e çıkar

Adreslenemeyen RGB şerit, üç MOSFET ve üç PWM pini ile odana, masana ya da projene güçlü ve ucuz bir ışık katmanın en pratik yoludur. Her LED'i ayrı kontrol etmek istersen bir sonraki adım WS2812B olabilir. BlueGrays uygulamasında RGB LED ile renk karıştırma, yumuşak renk geçişi, ESP32 renk mikser lambası ve Pico RGB renk çevrimi projelerini adım adım devre şeması ve koduyla inceleyebilirsin.

Sıkça sorulan sorular

RGB şerit LED doğrudan Arduino'ya bağlanabilir mi?

Hayır. 12 V'luk şerit metre başına bir amperden fazla akım çekebilir, Arduino pini ise yaklaşık 20 mA verebilir ve 5 V'ta çalışır. Şeridi her renk kanalı için bir lojik seviye MOSFET üzerinden sürmen gerekir; Arduino yalnızca MOSFET'in kapısına PWM sinyali gönderir.

12 V şerit LED için hangi MOSFET kullanılır?

5 V'luk Arduino Uno ve Nano için IRLZ44N yaygın ve uygun bir seçimdir. ESP32 ve Raspberry Pi Pico gibi 3,3 V'luk kartlarda IRLB8721 ya da AO3400 gibi düşük kapı gerilimiyle tam açılan MOSFET'ler daha iyi sonuç verir. IRF520 ve IRF540N 5 V'ta tam açılmadığı için ısınır.

5 metre RGB şerit LED kaç amper çeker?

60 LED/m'lik 5050 şerit tam beyazda metre başına yaklaşık 1,2 A çeker; 5 metre yaklaşık 6 A ve 72 W eder. 30 LED/m'lik şeritte bu değerler yarıya iner. Adaptörü %20 pay bırakarak seçmelisin; 6 A için 12 V 8 A'lik bir adaptör uygundur.

RGB şerit LED ile WS2812B arasındaki fark nedir?

Adreslenemeyen RGB şeritte tüm LED'ler aynı anda aynı rengi gösterir ve üç MOSFET'le sürülür. WS2812B'de her LED'in kendi sürücü yongası vardır ve tek bir veri pininden her LED'e ayrı renk gönderilir. WS2812B kayan efektler için, RGB şerit ise ucuz ve güçlü düz aydınlatma için idealdir.

RGB şerit LED nereden kesilir?

12 V şeritler üç LED'den oluşan segmentlerle çalışır ve yalnızca bakır pedlerin üzerindeki kesme işaretlerinden kesilebilir; bu aralık 60 LED/m'de 5 cm, 30 LED/m'de 10 cm'dir. Başka bir yerden kesersen o segment yanmaz. Kestiğin parçayı pedlere kablo lehimleyerek ya da geçmeli konnektörle tekrar bağlayabilirsin.

Arduino'yu şeridin 12 V adaptöründen besleyebilir miyim?

Arduino Uno'yu güç jakından ya da Vin pininden 12 V ile besleyebilirsin; kart üzerindeki regülatör hafif yüklerde bunu karşılar. ESP32 geliştirme kartlarında ve Raspberry Pi Pico'da ise 12 V'u LM2596 gibi bir voltaj düşürücüyle 5 V'a indirmen gerekir. Her durumda adaptörün eksisi kartın GND'sine bağlı olmalıdır.

Tüm projeleri gör
RGB Led Kullanımı
AR-39Başlangıç
Premium

RGB Led Kullanımı

Tek bir LED'in içinde üç renk saklı: RGB LED önce kırmızı, sonra yeşil, sonra mavi yanar; her renk yarım saniye yanıp yarım saniye söner ve sıra baştan başlar.

4.9(73)
100
RGB Led İle Yumuşak Renk Geçişi
AR-40Başlangıç
Premium

RGB Led İle Yumuşak Renk Geçişi

Tek bir RGB LED kırmızıdan yeşile, yeşilden maviye, maviden yeniden kırmızıya yavaşça geçer ve bu gökkuşağı döngüsü hiç durmaz.

4.8(58)
78
ESP32 RGB LED Kontrolü
ES-9Başlangıç

ESP32 RGB LED Kontrolü

3 ayrı LED yerine tek RGB LED ile sınırsız renk üretme. Arduino'daki gibi analogWrite() ile R/G/B değerlerini ayarlayarak gökkuşağı geçişi yaparız. Renk teorisi (red+green=yellow gibi) pratik olarak görülür.

4.6(29)
52
ESP32 Renk Mikser Lambası (3 Pot + RGB LED + OLED)
ES-36İleri
Premium

ESP32 Renk Mikser Lambası (3 Pot + RGB LED + OLED)

ESP32 ile 3 potansiyometreyi çevirerek istediğin rengi karıştıran akıllı bir renk mikser lambası! Kırmızı, yeşil ve mavi potansiyometreleri çevirdikçe ortak katotlu RGB LED anında renk değiştirir. SSD1306 OLED ekranda her renk için 0-255 arası değer, dolgu çubukları ve HEX web renk kodu (#FF8040 gibi) canlı olarak gösterilir.

4.7(6)
10
Raspberry Pi Pico RGB LED Renk Çevrimi (3 Kanal PWM)
PI-15Başlangıç

Raspberry Pi Pico RGB LED Renk Çevrimi (3 Kanal PWM)

Tek LED, milyonlarca renk! RGB LED'in içinde aslında 3 ayrı LED var: kırmızı, yeşil ve mavi. Pico'nun 3 ayrı PWM kanalıyla her birinin parlaklığını ayrı ayrı ayarlayınca renkler karışır: kırmızı + yeşil = sarı, yeşil + mavi = camgöbeği, üçü birden = beyaz. Bu projede LED 8 renk arasında sırayla dönüyor.

6
ESP32 PWM ile LED Soldurma (Fade)
ES-8Başlangıç

ESP32 PWM ile LED Soldurma (Fade)

LED'in parlaklığını yumuşak şekilde 0'dan max'a, max'tan 0'a değiştirme. Arduino'daki gibi analogWrite() ile PWM kontrolü yapıyoruz — ESP32 Arduino Core 3.0+ ile aynı syntax sorunsuz çalışır. Pin tanımı + pinMode + analogWrite yeterli.

4.8(36)
55
ESP32 Potansiyometre ile LED Parlaklık (Analog → PWM)
ES-13Orta
Premium

ESP32 Potansiyometre ile LED Parlaklık (Analog → PWM)

Bu projede bir potansiyometre ile LED parlaklığını analog olarak kontrol ediyoruz. ESP32'nin ADC pini potansiyometreden gelen 0-3.3V gerilimi okur, ardından bu değer PWM (Pulse Width Modulation) sinyaline çevrilerek LED'e gönderilir. Böylece potansiyometreyi çevirdikçe LED kademeli olarak parlar ve söner. Arduino Core 3.0+ ile analogWrite() doğrudan kullanılabilir; ESP32-S2/S3'te ADC çözünürlüğü 12-bit'e sabitlenir.

4.5(19)
32
Raspberry Pi Pico PWM ile LED Fade (Nefes Efekti)
PI-14Başlangıç

Raspberry Pi Pico PWM ile LED Fade (Nefes Efekti)

LED artık sadece yanıp sönmüyor, nefes alıyor! Raspberry Pi Pico'nun PWM (Pulse Width Modulation, darbe genişlik modülasyonu) özelliğiyle LED'in parlaklığı yavaş yavaş artar, sonra yavaş yavaş azalır; uyku modundaki bir dizüstü bilgisayarın ışığı gibi sakin bir "nefes" efekti. Bu projede machine.PWM sınıfını, duty_u16() ile 0–65535 arası 16 bit parlaklık değerini ve PWM frekansını öğrenirsin.

4