Kontrol LED Strip RGB Arduino: Mencampur Warna 12 V dengan MOSFET
Kontrol LED strip RGB dengan Arduino: menggerakkan strip 5050 12 V dengan MOSFET IRLZ44N, PWM tiga kanal, transisi warna, pemilih warna dengan potensiometer, plus kode ESP32 dan Pico.
Kontrol LED strip RGB dengan Arduino berarti menggerakkan kanal merah, hijau, dan biru dari strip RGB 5050 12 V yang non-addressable dengan tiga sinyal PWM terpisah supaya kamu bisa mendapatkan warna apa pun yang kamu mau. Pin Arduino tidak sanggup menangani arus berampere-ampere yang ditarik strip maupun tegangan 12 V, jadi setiap kanal memakai satu MOSFET: Arduino hanya mengirim sinyal 5 V ke gate MOSFET, dan MOSFET-lah yang membawa arus sebenarnya. Dengan begitu, mikrokontroler kecil bisa mengendalikan strip sepanjang bermeter-meter dengan aman.
Di panduan ini kamu akan mempelajari struktur dalam strip 5050, cara memilih MOSFET yang tepat, pengkabelan, dan perhitungan catu daya. Setelah itu kamu akan mencampur warna dengan Arduino Uno, membuat transisi warna halus berbasis millis(), memilih warna dan kecerahan dengan potensiometer, lalu menjalankan rangkaian yang sama dengan unit LEDC di ESP32 dan PWM MicroPython di Raspberry Pi Pico. Kamu juga akan menemukan perbedaan strip ini dengan WS2812B, dan di bagian akhir ada solusi untuk kesalahan yang paling sering terjadi.
Apa itu LED strip RGB dan bagaimana cara kerjanya?
Di strip RGB non-addressable, setiap kemasan SMD 5050 berisi tiga chip LED terpisah: merah, hijau, dan biru. Strip ini tersusun dari segmen 12 V yang terhubung paralel, masing-masing berisi tiga LED dan satu resistor pembatas arus untuk tiap warna; total tegangan maju tiga LED yang terhubung seri sekitar 6–9 V tergantung warnanya, dan sisanya ditanggung resistor. Strip punya empat sambungan: positif bersama (+12V) plus R, G, dan B. Jadi strip ini common anode: untuk menyalakan satu warna, kamu harus menarik jalur warna itu ke GND. Seluruh strip menampilkan satu warna dalam satu waktu; kamu tidak bisa menyalakan LED satu per satu dengan warna berbeda. Warnanya kamu atur lewat duty cycle PWM tiap kanal: merah dan hijau menyala penuh menghasilkan kuning, ketiganya menyala penuh menghasilkan cahaya yang mendekati putih.
| Fitur | Strip 30 LED/m | Strip 60 LED/m |
|---|---|---|
| Tipe LED | 5050 SMD (5,0 × 5,0 mm, 3 chip) | 5050 SMD (5,0 × 5,0 mm, 3 chip) |
| Tegangan kerja | 12 V DC | 12 V DC |
| Daya (putih penuh) | Sekitar 7,2 W/m | Sekitar 14,4 W/m |
| Arus (putih penuh) | Sekitar 0,6 A/m | Sekitar 1,2 A/m |
| Arus per kanal | Sekitar 0,2 A/m | Sekitar 0,4 A/m |
| Jarak potong | Setiap 3 LED (10 cm) | Setiap 3 LED (5 cm) |
| Sambungan | +12V, R, G, B | +12V, R, G, B |
Strip RGB vs WS2812B: apa bedanya?
Kedua strip sama-sama menghasilkan cahaya RGB, tetapi cara mengendalikannya sama sekali berbeda. Strip non-addressable mirip lampu: kamu mengatur warna seluruh strip dengan mengubah kecerahan tiga kanal. Di strip WS2812B NeoPixel, setiap LED punya chip driver kecil di dalamnya, dan kamu bisa mengirim warna berbeda ke tiap LED lewat satu jalur data. Tabel di bawah membantumu memutuskan mana yang dipilih:
| Fitur | Strip RGB 12 V (5050) | Strip WS2812B |
|---|---|---|
| Kontrol | Seluruh strip satu warna | Tiap LED warnanya sendiri |
| Catu daya | 12 V (ada juga versi 24 V) | 5 V |
| Kabel | 4 kabel: +12V, R, G, B | 3 kabel: 5V, DIN, GND |
| Rangkaian driver | Satu MOSFET per kanal | Tidak perlu, satu pin data sudah cukup |
| Kode | analogWrite / PWM | Library FastLED atau Adafruit NeoPixel |
| Arus (60 LED/m, putih penuh) | Sekitar 1,2 A/m (12 V) | Sekitar 3,6 A/m (5 V) |
| Jatuh tegangan | Biasanya aman sampai 5 m | Strip panjang perlu suntikan daya di beberapa titik |
| Efek | Warna tetap, transisi warna, efek bernapas | Lampu berjalan, pelangi, animasi |
| Harga | Murah | Lebih mahal |
Kenapa butuh MOSFET, dan mana yang sebaiknya dipilih?
Satu pin Arduino Uno dirancang untuk memberi arus sekitar 20 mA (batas mutlak 40 mA), padahal satu kanal strip 5 meter dengan 60 LED/m bisa menarik 2 A. Ditambah lagi, strip bekerja di 12 V. MOSFET kanal-N menyelesaikan masalah ini sebagai sakelar sisi bawah (low-side switch): kaki Drain ke jalur warna strip, kaki Source ke GND, dan tegangan di Gate menyalakan serta mematikan MOSFET. Poin pentingnya adalah memilih MOSFET logic-level; MOSFET standar seperti IRF520 atau IRF540N butuh sekitar 10 V agar menyala penuh, dan di 5 V hanya setengah terbuka lalu jadi panas. Daya yang terbuang di MOSFET dihitung dengan P = I² × Rds(on): untuk 2 A dan 0,025 Ω hasilnya 2 × 2 × 0,025 = 0,1 W, jadi tidak perlu heatsink. Untuk dasar-dasarnya, lihat Memakai MOSFET dengan Arduino.
| MOSFET | Tegangan gate | Rds(on) | Kecocokan |
|---|---|---|---|
| IRLZ44N | Logic-level, menyala penuh di 4–5 V | 0,025 Ω (di 5 V) | Ideal untuk Uno dan Nano; di 3,3 V hanya untuk strip pendek |
| IRLB8721 | Menyala dengan baik di 3,3 V juga | Sekitar 0,009 Ω (di 4,5 V) | Salah satu pilihan terbaik untuk ESP32 dan Pico |
| AO3400 (SMD) | Menyala di 2,5 V | Sekitar 0,03 Ω (di 4,5 V) | Board kecil, 2–3 A per kanal |
| IRF520 / IRF540N | Butuh sekitar 10 V | Tinggi di 5 V | Tidak disarankan, jadi panas |
Skema rangkaian dan tabel pengkabelan
Kamu merakit rangkaian kecil yang sama tiga kali, satu untuk tiap kanal warna. Pegang IRLZ44N dengan sisi bertulisan menghadap ke arahmu, maka urutan kakinya dari kiri ke kanan adalah Gate, Drain, Source; kamu juga bisa mengecek urutan kaki dengan alat pinout transistor. Pasang resistor 220 Ω di antara Gate dan pin board; resistor ini membatasi arus lonjakan yang ditarik dari pin ketika kapasitansi gate terisi. Tambahkan juga resistor pull-down 10 kΩ di antara Gate dan GND; resistor ini mencegah MOSFET menyala sendiri dan menyalakan strip secara acak ketika pin mengambang selama board menyala atau selama kode di-upload. Aturan paling penting: negatif adaptor 12 V wajib disambungkan ke GND board, kalau tidak sinyal gate tidak punya referensi. Kami membahasnya secara rinci di artikel Ground Bersama (GND).
| Sambungan | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Gate MOSFET merah (lewat 220 Ω) | D9 | GPIO 25 | GP11 |
| Gate MOSFET hijau (lewat 220 Ω) | D10 | GPIO 26 | GP12 |
| Gate MOSFET biru (lewat 220 Ω) | D11 | GPIO 27 | GP13 |
| Kaki Drain MOSFET | Kabel R, G, B strip | Kabel R, G, B strip | Kabel R, G, B strip |
| Kaki Source MOSFET | GND | GND | GND |
| Potensiometer warna (kaki tengah) | A0 | GPIO 34 | GP26 (ADC0) |
| Potensiometer kecerahan (kaki tengah) | A1 | Tidak dipakai | Tidak dipakai |
| Kaki luar potensiometer | 5V dan GND | 3V3 dan GND | 3V3 dan GND |
| Negatif adaptor 12 V | GND | GND | GND |
| Kabel +12V strip | Positif adaptor | Positif adaptor | Positif adaptor |
Perhitungan daya: adaptor mana yang sebaiknya dibeli?
Untuk memilih adaptor, hitung dulu arus strip pada putih penuh: I = meter × A/m. Strip 5 m dengan 60 LED/m menarik 5 × 1,2 = 6 A; dayanya P = V × I = 12 × 6 = 72 W. Selalu pilih adaptor dengan cadangan sekitar 20%: di contoh ini catu daya 12 V 8 A (96 W) adalah pilihan yang tepat. Strip 2 m dengan 30 LED/m menarik 1,2 A, jadi adaptor 12 V 2 A sudah cukup. Pilih kabel sesuai arusnya juga; di atas 5 A, pakai kabel minimal 0,75 mm² alih-alih kabel jumper. Kalau kamu ingin memberi daya ke board dari adaptor yang sama, jack daya atau pin Vin Arduino Uno menerima 12 V dan bekerja dengan baik pada beban ringan. Di board pengembangan ESP32 dan Pico, jangan sambungkan 12 V secara langsung; input VSYS Pico hanya menerima maksimal 5,5 V. Untuk board-board ini, solusi paling rapi adalah menurunkan 12 V menjadi 5 V dengan buck converter LM2596 lalu memberikannya ke pin 5V di ESP32 dan VSYS di Pico. Kamu bisa mengecek perhitungannya dengan kalkulator hukum Ohm dan membaca menghitung daya listrik untuk detailnya.
Pemasangan langkah demi langkah
- Rakit seluruh rangkaian sebelum mencolokkan adaptor ke stopkontak; jangan mengubah sambungan selama rangkaian masih teraliri listrik.
- Solder empat kabel ke pad solder strip atau pakai konektor jadi; sambungkan kabel +12V ke positif adaptor.
- Pasang tiga MOSFET dan sambungkan kaki Source-nya ke jalur GND bersama. Jalur breadboard cocok untuk sekitar 1 A; untuk strip yang menarik beberapa ampere, buat jalur arusnya dengan sambungan solder atau blok terminal.
- Sambungkan Drain tiap MOSFET ke kabel warna strip yang sesuai (R, G, B).
- Sambungkan kaki Gate ke D9, D10, dan D11 lewat resistor 220 Ω; tambahkan resistor 10 kΩ di antara tiap Gate dan GND.
- Sambungkan negatif adaptor 12 V ke pin GND Arduino untuk membuat ground bersama.
- Hubungkan Arduino ke komputer lewat USB, upload kode pertama, lalu colokkan adaptor.
- Cek bahwa tiap warna bisa menyala sendiri; kalau warna yang salah menyala, tukar nomor pin di kode.
Kode pertama: mencampur warna dengan Arduino
Setelah merakit rangkaian, awal yang paling aman adalah menguji tiap kanal satu per satu. Kode di bawah memakai pin PWM 9, 10, dan 11 di Uno dan menampilkan enam warna berbeda secara bergantian dengan fungsi setColor(). Kalau kamu penasaran cara kerja PWM, lihat Apa Itu PWM.
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}Ada perbedaan penting di sini: kalau kamu menghubungkan satu LED RGB common anode langsung ke pin, logikanya terbalik (255 mematikannya), tetapi di rangkaian MOSFET analogWrite(pin, 255) membuka MOSFET sepenuhnya dan menyalakan warna dengan kecerahan penuh; 0 mematikannya. Di Uno, pin 9 dan 10 terhubung ke Timer1 dan pin 11 ke Timer2, dan ketiganya berjalan di sekitar 490 Hz; di frekuensi ini matamu tidak menangkap kedipan. Namun, tone() memakai Timer2 sehingga merusak PWM di pin 11, dan library Servo menonaktifkan PWM di pin 9 dan 10. Kalau proyekmu memakai buzzer atau servo, rencanakan pinnya sesuai hal ini. Selain itu, kecerahan warna-warna di strip tidak sama; kalau putih terlihat kebiruan, kamu bisa menyeimbangkannya dengan menurunkan kanal biru ke sekitar 200.
Transisi warna pelan: roda warna dengan millis()
Agar strip berpindah dengan halus melewati semua warna, kita memakai roda warna: nilai rona dari 0–767 dibagi menjadi tiga wilayah. Di 256 langkah pertama merah turun dan hijau naik, di 256 langkah berikutnya bergeser dari hijau ke biru, dan di bagian terakhir dari biru ke merah. Karena dua kanal selalu berjumlah 255, warna-warnanya mengalir satu sama lain tanpa lompatan. Karena kita memakai millis() alih-alih delay(), loop() juga bisa mengerjakan hal lain seperti membaca tombol atau mengukur sensor. Mata kita tidak menangkap kecerahan secara linear: perubahan kecil di nilai rendah sangat terasa, sedangkan di nilai tinggi sulit terlihat. Karena itu fungsi gamma8() di kode menskalakan nilai dengan kuadratnya (v × v / 255) sehingga transisi di cahaya redup terlihat lebih alami. Kalau kamu memperbesar STEP_MS, satu putaran penuh jadi lebih lama; dengan 15 ms, satu putaran memakan waktu sekitar 11,5 detik.
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}Memilih warna dan kecerahan dengan potensiometer
Dua potensiometer sudah cukup untuk memilih warna secara manual: yang di A0 mengatur rona (0–767) dan yang di A1 mengatur kecerahan keseluruhan (0–255). Karena analogRead() mengembalikan 0–1023, kita menskalakannya ke rentang yang diinginkan dengan map(). Kecerahan diterapkan dengan mengalikan nilai tiap kanal dengan bri / 255, sehingga cahaya meredup sementara ronanya tetap terjaga. Kamu juga bisa mengatur R, G, dan B langsung dengan tiga potensiometer terpisah, tetapi roda warna dengan satu kenop jauh lebih intuitif dan memungkinkanmu mencapai semua warna jenuh kecuali putih.
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}Mengendalikan strip RGB dengan ESP32 (LEDC)
ESP32 memakai unit hardware LEDC untuk PWM; frekuensi dan resolusinya kamu tentukan sendiri. 5 kHz dan 8 bit memberikan cahaya bebas kedipan sekaligus rentang 0–255 yang sudah familiar. Di Arduino core 3.x kamu memakai ledcAttach(pin, frekuensi, resolusi) dan ledcWrite(pin, nilai), sedangkan di 2.x kamu menyiapkan kanal dulu dengan ledcSetup(), menghubungkannya ke pin dengan ledcAttachPin(), lalu ledcWrite() menulis ke kanal; kode di bawah mendukung kedua versi dengan #if. Karena pin ESP32 mengeluarkan 3,3 V, penting untuk memilih MOSFET dengan tegangan gate rendah, seperti IRLB8721 di tabel. Kami menyambungkan potensiometer ke GPIO 34, pin ADC1 yang tetap bekerja dengan baik meskipun Wi-Fi menyala; ADC-nya 12-bit sehingga nilainya 0–4095, dan delapan pembacaan dirata-rata untuk mengurangi derau. Untuk dasar-dasar board ini, lihat Apa Itu ESP32.
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}Kode MicroPython dengan Raspberry Pi Pico
Di Pico, setiap pin GPIO bisa menghasilkan PWM, dan duty_u16() menerima nilai 0–65535. Di kode, kita menskalakan nilai warna 0–255 ke rentang itu dengan mengalikannya dengan 257 (255 × 257 = 65535). Potensiometer tersambung ke GP26 (ADC0); read_u16() juga mengembalikan 0–65535, jadi mudah diubah menjadi nilai rona. GP12 dan GP13 berbagi slice PWM yang sama (slice 6); karena keduanya kita beri frekuensi yang sama, tidak ada masalah, tetapi kalau kamu mencoba mengatur frekuensi berbeda, pengaturan terakhir akan memengaruhi keduanya. Karena Pico bekerja di 3,3 V, saran MOSFET yang kita berikan untuk ESP32 berlaku juga di sini. Untuk instalasinya, baca Apa Itu Raspberry Pi Pico?.
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)Ide proyek dengan LED strip RGB
- Lampu suasana reaktif musik: ubah warna dan kecerahan strip mengikuti irama musik dengan sensor suara; detailnya di artikel LED reaktif musik.
- Lampu latar TV dengan remote: ubah warna dan kecerahan dari sofa dengan Penerima IR dan remote.
- Lampu tangga yang menyala karena gerakan: ketika sensor PIR mendeteksi seseorang, nyalakan strip perlahan dan matikan setelah beberapa waktu.
- Lampu tidur otomatis: ketika LDR mendeteksi ruangan mulai gelap, nyalakan warna oranye hangat dengan kecerahan rendah.
- Kontrol dari ponsel: buat web server di ESP32 dan pakai pemilih warna dari browser-mu.
- Alarm matahari terbit: mulai 20 menit sebelum waktu bangunmu, nyalakan strip perlahan dari merah tua ke putih.
Kesalahan umum dan cara mengatasinya
| Gejala | Kemungkinan penyebab | Solusi |
|---|---|---|
| Strip sama sekali tidak menyala | Tidak ada GND bersama atau kabel +12V tidak tersambung | Sambungkan negatif adaptor ke GND board dan cek kabel +12V strip |
| Satu warna terus menyala apa pun perintah kodenya | Drain dan Source MOSFET tertukar atau MOSFET rusak | Cek urutan kaki (G-D-S) dan ganti MOSFET jika perlu |
| Strip berkedip sendiri ketika board menyala | Tidak ada resistor pull-down di Gate | Tambahkan 10 kΩ di antara tiap Gate dan GND |
| MOSFET jadi sangat panas | Bukan MOSFET logic-level atau tegangan gate kurang di 3,3 V | Pakai MOSFET logic-level seperti IRLZ44N atau IRLB8721 |
| Warna tertukar (hijau menyala, bukan merah) | Label strip atau urutan kabel berbeda | Tukar nilai PIN_R, PIN_G, PIN_B di kode |
| Ujung strip terlihat kekuningan dan redup | Jatuh tegangan di strip yang panjang | Beri daya strip yang lebih dari 5 m dari kedua ujung dan pakai kabel yang lebih tebal |
| Board reset atau mulai ulang | Adaptor terlalu lemah, tegangan anjlok | Pakai adaptor yang lebih kuat dan beri daya board dari regulator terpisah |
| Kedipan atau garis-garis di kamera | Frekuensi PWM rendah | Naikkan frekuensi ke 1–5 kHz di ESP32 dan Pico |
Strip RGB non-addressable dengan tiga MOSFET dan tiga pin PWM adalah cara paling praktis untuk menambahkan lapisan cahaya yang terang dan murah ke kamar, meja, atau proyekmu. Kalau kamu ingin mengendalikan tiap LED secara terpisah, WS2812B bisa jadi langkah berikutnya. Di aplikasi BlueGrays kamu bisa menjelajahi proyek mencampur warna dengan LED RGB, transisi warna halus, lampu pencampur warna ESP32, dan siklus warna RGB Pico, langkah demi langkah lengkap dengan skema rangkaian dan kodenya.
Pertanyaan umum
Apakah LED strip RGB bisa disambungkan langsung ke Arduino?
Tidak. Strip 12 V bisa menarik lebih dari satu ampere per meter, sedangkan pin Arduino hanya bisa memberi sekitar 20 mA dan bekerja di 5 V. Kamu perlu menggerakkan strip lewat satu MOSFET logic-level untuk tiap kanal warna; Arduino hanya mengirim sinyal PWM ke gate MOSFET.
MOSFET apa yang sebaiknya kupakai untuk LED strip 12 V?
Untuk Arduino Uno dan Nano yang 5 V, IRLZ44N adalah pilihan yang umum dan cocok. Di board 3,3 V seperti ESP32 dan Raspberry Pi Pico, MOSFET yang menyala penuh dengan tegangan gate rendah, seperti IRLB8721 atau AO3400, memberi hasil lebih baik. IRF520 dan IRF540N tidak menyala penuh di 5 V, jadi mereka cepat panas.
Berapa ampere yang ditarik LED strip RGB 5 meter?
Strip 5050 dengan 60 LED/m menarik sekitar 1,2 A per meter pada putih penuh; 5 meter berarti sekitar 6 A dan 72 W. Untuk strip 30 LED/m, nilai-nilai ini jadi setengahnya. Pilih adaptor dengan cadangan 20%; untuk 6 A, adaptor 12 V 8 A adalah pilihan yang tepat.
Apa perbedaan LED strip RGB dan WS2812B?
Di strip RGB non-addressable, semua LED menampilkan warna yang sama dalam satu waktu dan strip digerakkan dengan tiga MOSFET. Di WS2812B, tiap LED punya chip driver sendiri dan kamu mengirim warna berbeda ke tiap LED dari satu pin data. WS2812B ideal untuk efek lampu berjalan, sedangkan strip RGB ideal untuk pencahayaan polos yang murah dan terang.
Di mana LED strip RGB boleh dipotong?
Strip 12 V bekerja dalam segmen berisi tiga LED dan hanya boleh dipotong di tanda potong pada pad tembaga; jaraknya 5 cm di strip 60 LED/m dan 10 cm di strip 30 LED/m. Kalau kamu memotong di tempat lain, segmen itu tidak akan menyala. Potongan strip bisa kamu sambungkan lagi dengan menyolder kabel ke pad atau memakai konektor jepit.
Bisakah aku memberi daya ke Arduino dari adaptor 12 V strip?
Kamu bisa memberi daya Arduino Uno dengan 12 V lewat jack daya atau pin Vin; regulator di board sanggup menanganinya pada beban ringan. Di board pengembangan ESP32 dan Raspberry Pi Pico, kamu perlu menurunkan 12 V menjadi 5 V dengan buck converter seperti LM2596. Dalam semua kasus, negatif adaptor wajib tersambung ke GND board.
Proyek untuk dibuat setelah membaca ini
Lihat semua proyek
Menggunakan LED RGB
Tiga warna tersembunyi di dalam satu LED: LED RGB menyala merah, lalu hijau, lalu biru, setiap warna menyala setengah detik dan mati setengah detik, sebelum siklusnya dimulai lagi.

Transisi Warna Halus dengan LED RGB
Satu LED RGB perlahan bergeser dari merah ke hijau, hijau ke biru, lalu kembali ke merah, berputar melewati warna pelangi tanpa pernah berhenti.

Kendali LED RGB ESP32
Menghasilkan warna tanpa batas dengan satu LED RGB alih-alih 3 LED terpisah. Seperti di Arduino, kita membuat transisi pelangi dengan mengatur nilai R/G/B lewat analogWrite(). Teori warna (seperti merah+hijau=kuning) terlihat secara praktis.

Lampu Pencampur Warna ESP32 (3 Potensiometer + LED RGB + OLED)
Lampu pencampur warna pintar: campur warna apa pun dengan memutar tiga potensiometer di ESP32! Ketika potensiometer merah, hijau, dan biru diputar, LED RGB katoda bersama berubah warna secara real-time. OLED SSD1306 menampilkan nilai setiap warna dalam rentang 0–255, bar pengisi, dan kode warna web HEX (seperti #FF8040). Studio warna mini yang mengajarkan teori warna RGB, pembacaan ADC, pengaturan kecerahan dengan PWM, dan desain layar I2C sekaligus.

Siklus Warna LED RGB Raspberry Pi Pico (PWM 3 Kanal)
Satu LED, jutaan warna! LED RGB berisi 3 LED: merah, hijau, dan biru. Masing-masing digerakkan dengan kanal PWM Pico sendiri: merah + hijau = kuning, hijau + biru = cyan, ketiganya = putih. LED berputar melewati 8 warna. Pelajari beberapa kanal PWM, mendefinisikan fungsi (def set_color(...)), pencampuran warna RGB (cara kerja layar), konversi 8-bit → 16-bit (x257 memetakan 0–255 ke 0–65535), dan LED katoda bersama vs anoda bersama.

LED Fade dengan PWM ESP32
Mengubah kecerahan LED secara halus dari 0 ke maksimum, dan dari maksimum ke 0. Kita mengendalikan PWM dengan analogWrite() seperti di Arduino; sintaks yang sama bekerja tanpa masalah di ESP32 Arduino Core 3.0+. Definisi pin + pinMode + analogWrite sudah cukup.

Kendali Kecerahan LED dengan Potensiometer ESP32 (Analog → PWM)
Di proyek ini, kita mengendalikan kecerahan LED secara analog memakai potensiometer. Pin ADC ESP32 membaca tegangan 0-3,3V dari potensiometer, lalu nilai ini diubah menjadi sinyal PWM (Pulse Width Modulation) dan dikirim ke LED. Hasilnya, ketika kamu memutar potensiometer, LED perlahan menerang dan meredup. Dengan Arduino Core 3.0+, analogWrite() bisa langsung dipakai; di ESP32-S2/S3, resolusi ADC tetap 12-bit.

LED Fade PWM Raspberry Pi Pico (Efek Bernapas)
LED tidak lagi sekadar berkedip, ia bernapas! Dengan PWM (Pulse Width Modulation) Pico, kecerahan LED naik lalu turun perlahan, seperti lampu MacBook yang tidur. Pelajari kelas machine.PWM, duty_u16() (kecerahan 16-bit 0–65535), frekuensi PWM (freq(1000): 1000 siklus per detik, tanpa kedipan terlihat), loop range() bertahap, dan output mirip analog dari pin digital. PWM juga dipakai untuk warna RGB, motor, servo, dan buzzer.
Artikel lainnya
Aplikasi BlueGrays
Rakit rangkaian ini langkah demi langkah di ponselmu
Skema pengkabelan, kode, dan daftar komponen dalam satu layar. 500+ proyek Arduino, ESP32, dan Pico siap dibuat.
Pindai dengan ponselmu
Arahkan kamera ke kode ini dan toko aplikasi di ponselmu akan terbuka.
atau buka toko aplikasi

