Lilin LED Arduino: Nyala Api yang Berkedip Realistis dan Lingkaran Adven
Buat lilin LED Arduino yang berkedip seperti api asli dengan PWM dan keacakan yang dihaluskan: lingkaran Adven 4 lilin, pengaturan kedipan, umur baterai dengan Nano, dan versi Pico.
Di proyek lilin LED Arduino ini, kamu membuat LED biasa berkedip seperti nyala lilin asli dengan memakai PWM dan keacakan yang terkendali. Hasilnya adalah lilin yang menyala dengan aman di meja, di jendela, atau di kamar anak, tanpa api, jelaga, atau risiko terguling. Kebanyakan lilin LED siap pakai hanya mengulang satu pola kedipan; kalau kamu menulis kodemu sendiri, kamu sendiri yang menentukan seberapa tenang atau hidup apinya, rentang terang dan redupnya, dan seberapa sering api itu meliuk tertiup "angin".
Di panduan ini kamu akan menemukan dulu logika di balik efek kedipan dan sketch pendek untuk satu lilin, lalu tabel yang menunjukkan bagaimana setiap parameter mengubah nyala api. Setelah itu kamu akan merakit lingkaran Adven empat lilin: setiap kali tombol ditekan, satu lilin lagi menyala, pilihannya disimpan di EEPROM, dan rangkaian masuk ke mode sleep sendiri setelah 6 jam. Terakhir, ada cara memasukkannya ke kotak kecil dengan Arduino Nano, perhitungan umur baterai, dan versi MicroPython untuk Raspberry Pi Pico.

Bagaimana cara kerja efek lilin LED?
Pin Arduino hanya bisa mengeluarkan 0 V atau 5 V; untuk menyalakan LED dengan setengah terang, pin dinyalakan dan dimatikan ratusan kali per detik. Ini disebut PWM (pulse width modulation, modulasi lebar pulsa). Nilai 0–255 di analogWrite(pin, nilai) menentukan berapa lama pin tetap menyala dalam setiap periode: 64 berarti sekitar 25% dan 191 sekitar 75% kecerahan. Di Uno dan Nano, frekuensi PWM sekitar 980 Hz di pin 5 dan 6, dan sekitar 490 Hz di pin 3, 9, 10, dan 11; mata tidak bisa melihat kecepatan ini sehingga LED terlihat stabil tapi redup. Detailnya ada di panduan apa itu PWM.
Rahasia api yang realistis adalah menghaluskan keacakannya. Kalau kamu menulis analogWrite(pin, random(0, 256)) setiap 20 milidetik, LED akan berkedut seperti lampu neon yang rusak, karena api asli tidak pernah melompat dari nol ke terang penuh dalam sekejap. Cara yang lebih baik adalah memilih kecerahan target secara acak dan menggeser kecerahan sekarang sedikit lebih dekat ke target itu di setiap langkah: level = level + (target − level) / 4. Targetnya berganti sesekali dan level mengalir halus menuju target. Tambahkan penurunan dalam yang jarang terjadi, yaitu api yang meliuk tertiup angin, maka mata akan menganggapnya lilin sungguhan.
Komponen dan memilih LED
| Warna LED | Tegangan maju (kira-kira) | Resistor (Uno, 5 V) | Resistor (Pico, 3,3 V) | Tampilan lilin |
|---|---|---|---|---|
| Kuning | 2,0–2,1 V | 220 Ω (~13 mA) | 220 Ω (~6 mA) | Sangat bagus, warna lilin klasik |
| Oranye / amber | 2,0–2,1 V | 220 Ω (~13 mA) | 220 Ω (~6 mA) | Nuansa paling hangat dan paling realistis |
| Putih hangat | 3,0–3,2 V | 150 Ω (~12 mA) | Tidak disarankan (terlalu redup) | Terang, seperti lilin LED modern |
| Merah | 1,8–2,0 V | 220 Ω (~14 mA) | 220 Ω (~6 mA) | Terlalu gelap kalau sendirian; bagus dipadukan dengan kuning |
- Arduino Uno atau Nano: Uno untuk mencoba di meja, Nano untuk dimasukkan ke kotak. Kedua board ini punya pin dan kode yang sama.
- 4 LED kuning atau oranye dan resistor dari tabel untuk masing-masing. Resistor untuk LED lain bisa kamu cari dengan kalkulator resistor LED.
- 1 push button: Untuk mengganti jumlah lilin dan mematikan. Pull-up internal dipakai, jadi tidak perlu resistor tambahan.
- Breadboard dan kabel jumper, plus PCB lubang (perfboard) dan timah solder untuk lingkaran yang permanen.
- Daya: Adaptor USB, power bank, atau tempat baterai. Pilihan baterainya kita tentukan dengan perhitungan di bawah.
- Badan lilin: Potongan pipa PVC putih, lilin bekas yang dilubangi bagian dalamnya, atau gelas buram; apa saja yang bisa menyebarkan cahaya LED.
Satu lilin: sketch kedipan pertama
1const byte LED_PIN = 9; // PWM pini, 220 ohm ile LED / PWM pin, LED through 220 ohm
2
3int level = 180; // şu anki parlaklık / current brightness
4int target = 180; // hedef parlaklık / target brightness
5
6void setup() {
7 pinMode(LED_PIN, OUTPUT);
8 randomSeed(analogRead(A0)); // her açılışta farklı titreme / different flicker on every start
9}
10
11void loop() {
12 if (random(100) < 8) { // %8 ihtimalle yeni hedef / 8% chance of a new target
13 target = random(90, 256);
14 if (random(100) < 5) target = 40; // nadir esinti: alev eğilir / rare gust: the flame dips
15 }
16 level += (target - level) / 4; // hedefe yumuşak yaklaş / ease toward the target
17 analogWrite(LED_PIN, level);
18 delay(random(15, 40)); // düzensiz adım / irregular step
19}Hubungkan LED lewat resistor 220 Ω ke pin 9, kaki pendeknya ke GND, lalu upload sketch-nya. Di setiap perulangan ada peluang 8% untuk target baru antara 90 dan 255; dengan peluang 5% target ditarik turun ke 40 untuk penurunan yang dalam. Baris level += (target − level) / 4 menambahkan seperempat selisihnya agar transisinya halus, dan jeda acak 15–40 ms membuat polanya makin tidak teratur. Baris randomSeed(analogRead(A0)) memakai derau di pin A0 yang mengambang untuk memulai deret acak yang berbeda setiap kali dinyalakan; tanpa baris ini lilin akan berkedip dengan cara yang sama setiap kali.
Tabel parameter kedipan
| Parameter | Default | Kalau kamu turunkan | Kalau kamu naikkan |
|---|---|---|---|
| FLAME_MIN | 90 | Api berkedip lebih dalam dan terlihat hampir padam | Api jadi tenang dan menyala hampir stabil |
| FLAME_MAX | 255 | Lilin jadi lebih redup, seperti lampu tidur | 255 adalah batas atas; untuk lebih terang kamu perlu arus LED yang lebih besar |
| CHANGE_CHANCE | 8 (%) | Api yang diam di ruangan tanpa angin | Kedipan cepat dan gelisah yang lama-lama melelahkan |
| GUST_CHANCE | 3 (%) | Hampir tidak ada embusan angin | Api yang sering meliuk, seperti di dekat jendela terbuka |
| SMOOTH | 4 | 1–2: lompatan mendadak, seperti bohlam rusak | 8 ke atas: kecerahan berayun pelan seperti gelombang |
| STEP_MS | 25 ms | Api yang lebih cepat dan lebih hidup | Pada 50 ms ke atas terlihat seperti gerak lambat |
Lingkaran Adven empat lilin: pengkabelan
Lingkaran Adven adalah tradisi, sangat populer terutama di Jerman, Austria, dan Swiss, di mana satu lilin lagi dinyalakan pada setiap hari Minggu dari empat hari Minggu sebelum Natal. Pada 2026, hari Minggu Adven jatuh pada 29 November, 6 Desember, 13 Desember, dan 20 Desember. Di lingkaran kita, empat LED mewakili empat lilin; tekan tombol sebentar untuk menambah satu lilin yang menyala (0, 1, 2, 3, 4, lalu kembali ke 0), dan tekan lama untuk mematikan rangkaian. Setiap lilin punya status kedipannya sendiri, jadi keempat api terlihat mandiri dan alami.
| Koneksi | Arduino Uno / Nano | Raspberry Pi Pico |
|---|---|---|
| Lilin 1 (resistor ke kaki panjang LED) | D3 | GP14 |
| Lilin 2 | D5 | GP15 |
| Lilin 3 | D6 | GP16 |
| Lilin 4 | D9 | GP17 |
| Kaki pendek LED | GND | GND |
| Tombol (kaki lainnya ke GND) | D2 | GP2 |

Kode lingkaran Adven: satu lilin lagi setiap hari Minggu
Sketch ini berjalan dengan millis() alih-alih delay(), jadi kedipannya tidak pernah berhenti selama sketch mendengarkan tombol dan menghitung timer. Cara ini dijelaskan di panduan millis() vs delay(). Setiap 25 ms status keempat lilin diperbarui, dan lilin yang tidak menyala tetap di nilai PWM nol. Jumlah lilin yang kamu pilih ditulis ke alamat EEPROM 0; meskipun kamu cabut lalu colok lagi, lingkaran menyala kembali dengan jumlah lilin yang sama.
1#include <EEPROM.h>
2#include <avr/sleep.h>
3
4const byte CANDLES = 4;
5const byte CANDLE_PINS[CANDLES] = {3, 5, 6, 9}; // PWM pinleri / PWM pins
6const byte BUTTON_PIN = 2; // buton -> GND, INT0 / button -> GND, INT0
7
8// Titreme ayarları / flicker settings
9const int FLAME_MIN = 90; // en kısık alev / dimmest flame
10const int FLAME_MAX = 255; // en parlak alev / brightest flame
11const byte CHANGE_CHANCE = 8; // her adımda yeni hedef olasılığı (%) / chance of a new target per step (%)
12const byte GUST_CHANCE = 3; // esinti olasılığı (%) / chance of a gust (%)
13const byte SMOOTH = 4; // büyüdükçe alev yavaşlar / higher = calmer flame
14const unsigned long STEP_MS = 25; // adım süresi / step time
15const unsigned long ON_TIME = 6UL * 60 * 60 * 1000; // 6 saat sonra uyku / sleep after 6 hours
16
17int level[CANDLES];
18int target[CANDLES];
19byte litCount = 1; // yanan mum sayısı (0-4) / number of lit candles (0-4)
20unsigned long onSince = 0;
21unsigned long lastStep = 0;
22
23void wakeUp() {} // yalnız uyandırmak için / only used to wake the chip
24
25void goToSleep() {
26 for (byte i = 0; i < CANDLES; i++) analogWrite(CANDLE_PINS[i], 0);
27 while (digitalRead(BUTTON_PIN) == LOW) {} // butonun bırakılmasını bekle / wait for release
28 delay(50);
29 set_sleep_mode(SLEEP_MODE_PWR_DOWN);
30 sleep_enable();
31 noInterrupts();
32 attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), wakeUp, LOW);
33 interrupts();
34 sleep_cpu(); // burada uyur / sleeps here
35 sleep_disable(); // butona basınca buradan devam / resumes here on press
36 detachInterrupt(digitalPinToInterrupt(BUTTON_PIN));
37 while (digitalRead(BUTTON_PIN) == LOW) {} // uyandıran basış sayılmasın / ignore the wake-up press
38 delay(50);
39 onSince = millis();
40}
41
42void flicker() {
43 for (byte i = 0; i < CANDLES; i++) {
44 if (i >= litCount) { // bu mum henüz yakılmadı / not lit yet
45 analogWrite(CANDLE_PINS[i], 0);
46 continue;
47 }
48 if (random(100) < CHANGE_CHANCE) {
49 target[i] = random(FLAME_MIN, FLAME_MAX + 1);
50 if (random(100) < GUST_CHANCE) target[i] = FLAME_MIN / 2; // alev eğilir / the flame bends
51 }
52 level[i] += (target[i] - level[i]) / SMOOTH;
53 analogWrite(CANDLE_PINS[i], level[i]);
54 }
55}
56
57void setup() {
58 pinMode(BUTTON_PIN, INPUT_PULLUP);
59 for (byte i = 0; i < CANDLES; i++) {
60 pinMode(CANDLE_PINS[i], OUTPUT);
61 level[i] = target[i] = 200;
62 }
63 randomSeed(analogRead(A0));
64 litCount = EEPROM.read(0); // son seçimi hatırla / remember the last choice
65 if (litCount > CANDLES) litCount = 1; // boş EEPROM 255 okur / empty EEPROM reads 255
66 onSince = millis();
67}
68
69void loop() {
70 if (digitalRead(BUTTON_PIN) == LOW) {
71 unsigned long pressStart = millis();
72 while (digitalRead(BUTTON_PIN) == LOW) {
73 if (millis() - pressStart > 1500) { // uzun basış: kapat / long press: switch off
74 goToSleep();
75 return;
76 }
77 }
78 if (millis() - pressStart > 50) { // kısa basış: bir mum daha / short press: one more candle
79 litCount = (litCount + 1) % (CANDLES + 1);
80 EEPROM.update(0, litCount);
81 onSince = millis();
82 }
83 }
84
85 if (millis() - onSince > ON_TIME) goToSleep(); // zamanlayıcı / auto-off timer
86
87 if (millis() - lastStep >= STEP_MS) {
88 lastStep = millis();
89 flicker();
90 }
91}| Kode | Fungsinya |
|---|---|
| level[i], target[i] (array per lilin) | Kecerahan dan target masing-masing lilin; keempat api berkedip secara mandiri |
| i >= litCount | Mematikan lilin yang belum tiba gilirannya; untuk hari Minggu ke-2 litCount = 2 |
| EEPROM.update(0, litCount) | Tidak menulis kalau nilainya tidak berubah, sehingga umur sel EEPROM terjaga |
| jika litCount > CANDLES maka 1 | EEPROM yang belum pernah ditulis terbaca 255; pada start pertama kali dimulai dengan satu lilin |
| ON_TIME | Setelah 6 jam mematikan lilin dan masuk sleep; lingkaran yang terlupa semalaman tidak menghabiskan baterai |
| goToSleep() | Menghentikan prosesor dengan SLEEP_MODE_PWR_DOWN; menekan tombol membangunkan board lewat interrupt INT0 |
Dalam mode sleep, clock ATmega328P berhenti dan arus prosesor turun ke level mikroampere. Untuk membangunkannya, interrupt level LOW dipasang di pin 2; dalam mode power-down hanya interrupt level yang bisa membangunkan prosesor, jadi CHANGE atau FALLING tidak berfungsi di sini. Setelah bangun, kode menunggu tombol dilepas agar tekanan yang membangunkan tidak ikut dihitung sebagai penambahan lilin. millis() juga berhenti selama sleep, karena itu timer di-reset ketika bangun.
Ukuran kecil dengan Nano dan perhitungan umur baterai
Lama baterai bertahan kamu hitung dengan waktu pakai (jam) = kapasitas yang bisa dipakai (mAh) / arus rata-rata (mA). Ayo hitung arus lingkarannya: LED yang berkedip rata-rata menarik sekitar 70% dari arus puncaknya, jadi sekitar 8–9 mA untuk LED 12 mA. Empat lilin jadi sekitar 35 mA; tambahkan 15–20 mA yang dipakai Nano klon itu sendiri, totalnya sekitar 50 mA. Satu malam 6 jam menghabiskan 300 mAh. Selama sleep prosesor hampir tidak menarik arus, tapi karena LED power, chip USB, dan regulator di board, kebanyakan Nano klon tetap memakai beberapa mA (biasanya sekitar 5 mA); 18 jam sleep menambah sekitar 90 mAh. Kamu bisa mencoba skenario lain dengan kalkulator umur baterai.
| Sumber daya | Kapasitas yang bisa dipakai | Malam 6 jam (≈50 mA) | Catatan |
|---|---|---|---|
| 3 × AA alkaline (≈4,5 V, ke pin 5V) | ~2000 mAh | ~5 malam (termasuk kehilangan selama sleep) | LED makin redup seiring baterai melemah |
| 4 × AA NiMH isi ulang (≈4,8 V, ke pin 5V) | ~1900 mAh | ~5 malam | Perlu diisi ulang 4–5 kali selama masa Adven |
| 18650 + TP4056 + konverter boost 5 V | ~1600 mAh (pada 5 V) | ~4 malam | Diisi lewat USB, muat di kotak |
| Power bank USB 10,000 mAh | ~6300 mAh (pada 5 V) | ~16 malam | Bisa mati sendiri selama sleep karena arusnya rendah |
| Adaptor USB 5 V 1 A | Tak terbatas | Tak terbatas | Solusi paling mudah untuk lingkaran di atas meja |
Versi MicroPython Raspberry Pi Pico
Setiap pin GPIO di Pico bisa mengeluarkan PWM, jadi lilin dihubungkan ke GP14–GP17 dan tombol ke GP2. Di MicroPython kecerahan diatur dengan duty_u16() dari 0 sampai 65535; kode mempertahankan nilai 0–255 dari versi Arduino dan mengalikannya dengan 257 agar skalanya sama (255 × 257 = 65535). Alih-alih EEPROM, jumlah lilin disimpan di file mum.txt (bahasa Turki untuk “lilin”) di sistem file Pico. Simpan kodenya sebagai main.py, maka lingkaran langsung menyala begitu Pico mendapat daya.
1from machine import Pin, PWM
2import time, random
3
4PINS = (14, 15, 16, 17) # 4 mum: GP14-GP17, 220 ohm / 4 candles, 220 ohm each
5button = Pin(2, Pin.IN, Pin.PULL_UP) # buton -> GND / button -> GND
6
7FLAME_MIN = 90 # 0-255 ölçeğinde / on a 0-255 scale
8FLAME_MAX = 255
9CHANGE_CHANCE = 8 # yeni hedef olasılığı (%) / chance of a new target (%)
10GUST_CHANCE = 3 # esinti olasılığı (%) / chance of a gust (%)
11SMOOTH = 4
12STEP_MS = 25
13
14leds = []
15for p in PINS:
16 pwm = PWM(Pin(p))
17 pwm.freq(1000) # 1 kHz, göz titreşimi görmez / 1 kHz, no visible strobing
18 leds.append(pwm)
19
20level = [200] * len(PINS)
21target = [200] * len(PINS)
22
23try:
24 with open("mum.txt") as f: # son seçimi oku / read the last choice
25 lit = int(f.read())
26except (OSError, ValueError):
27 lit = 1
28
29
30def save(n):
31 with open("mum.txt", "w") as f:
32 f.write(str(n))
33
34
35last_button = 1
36while True:
37 b = button.value()
38 if b == 0 and last_button == 1: # basıldığı an / the moment it is pressed
39 lit = (lit + 1) % (len(PINS) + 1)
40 save(lit)
41 time.sleep_ms(30) # basit debounce / simple debounce
42 last_button = b
43
44 for i, led in enumerate(leds):
45 if i >= lit:
46 led.duty_u16(0)
47 continue
48 if random.randint(0, 99) < CHANGE_CHANCE:
49 target[i] = random.randint(FLAME_MIN, FLAME_MAX)
50 if random.randint(0, 99) < GUST_CHANCE:
51 target[i] = FLAME_MIN // 2
52 level[i] += (target[i] - level[i]) // SMOOTH
53 led.duty_u16(level[i] * 257) # 0-255 -> 0-65535
54 time.sleep_ms(STEP_MS)Karena Pico bekerja pada 3,3 V, LED putih hangat (tegangan maju sekitar 3 V) hampir tidak menyala; pakai LED kuning atau oranye dengan resistor 220 Ω. Versi ini tidak punya timer atau mode sleep; kalau mau, hitung 6 jam dengan time.ticks_ms() lalu atur semua nilai duty ke nol. Frekuensi PWM Pico kita atur ke 1 kHz; pada frekuensi yang lebih rendah, garis-garis bisa muncul di video yang direkam dengan kamera ponsel.
Membuat tampilannya realistis
- Sebarkan cahayanya: Buramkan ujung LED dengan amplas halus atau masukkan sedikit kapas ke dalam badan lilin; seluruh badan lilin akan bersinar, bukan hanya satu titik.
- Api dua LED: Pasang LED kuning dan oranye dalam satu lilin di pin PWM terpisah dan kedipkan dengan kecepatan berbeda, maka warna apinya ikut bergerak; enam pin PWM di Uno cukup untuk tiga lilin seperti ini.
- Badan lilin: Pakai pipa PVC putih berdiameter 2–3 cm, lilin asli yang dilubangi, atau gelas buram. Badan lilin asli menyebarkan cahaya paling alami.
- Dasar lingkaran: Hias keempat lilin dengan ranting cemara tiruan dan buah pinus, sembunyikan Nano dan baterai di bawah dasar, dan letakkan tombol di sudut yang mudah dijangkau.
- Suhu warna: Kalau kamu memakai LED putih hangat, lembaran plastik transparan oranye di depannya membuat cahayanya lebih mendekati warna api asli.
Kesalahan umum dan solusinya
| Gejala | Kemungkinan penyebab | Solusi |
|---|---|---|
| LED tidak berkedip, hanya menyala atau mati | LED terhubung ke pin non-PWM | Pindahkan LED ke pin 3, 5, 6, 9, 10, atau 11 |
| Api berkedut seperti lampu neon rusak | SMOOTH terlalu kecil atau target berganti di setiap langkah | Atur SMOOTH ke 4–6 dan turunkan CHANGE_CHANCE di bawah 10 |
| Semua lilin berkedip dengan cara yang sama secara bersamaan | Satu variabel level ditulis ke semua pin | Pakai array level dan target terpisah untuk setiap lilin |
| Board tidak bangun dari sleep | Tombol tidak di D2 atau interrupt-nya bukan level LOW | Hubungkan tombol ke D2 dan pakai attachInterrupt(..., LOW) |
| Pola kedipan sama setiap kali dinyalakan | randomSeed tidak dipanggil atau A0 terhubung ke sesuatu | Panggil randomSeed(analogRead(A0)) dengan pin analog yang mengambang |
| Baterai habis dalam beberapa hari | LED power dan chip USB Nano tetap menarik arus selama sleep | Pakai adaptor atau ganti ke Pro Mini yang LED power-nya dilepas |
Lilin LED yang dibuat dengan beberapa LED, beberapa resistor, dan satu tombol ini menggabungkan PWM, pengaturan waktu dengan millis(), EEPROM, mode sleep, dan perhitungan baterai dalam satu proyek yang hangat. Kamu bisa membawa efek lilin ke proyekmu sendiri dengan melihat skema rangkaian dan kode langkah demi langkah untuk proyek cahaya dasar di aplikasi BlueGrays, seperti menyalakan LED, menyalakan dan mematikan LED dengan tombol, transisi warna halus dengan LED RGB, dan meredupkan dengan PWM di ESP32 atau Pico.
Pertanyaan umum
Bagaimana cara membuat lilin LED yang berkedip dengan Arduino?
Hubungkan LED lewat resistor 220 Ω ke salah satu pin PWM Arduino dan ubah kecerahannya secara acak tapi halus dengan analogWrite(). Hasil terbaik didapat dengan memilih kecerahan target secara acak dan menggeser kecerahan sekarang pelan-pelan ke target itu di setiap langkah. Penurunan dalam yang sesekali muncul meniru api yang meliuk tertiup angin.
Warna LED apa yang sebaiknya dipakai untuk lilin LED?
LED kuning atau oranye (amber) paling mendekati warna api asli. LED putih hangat lebih terang dan mirip lilin LED modern, tapi tetap redup di board 3,3 V. LED biru dan putih dingin tidak terlihat seperti api.
Resistor apa yang harus kupakai untuk menghubungkan LED ke Arduino?
Pada 5 V, resistor 220 Ω untuk LED kuning atau merah dan 150 Ω untuk LED putih hangat menghasilkan sekitar 12–14 mA, yang aman. Nilainya dihitung dengan (tegangan catu daya − tegangan LED) / arus yang diinginkan. Tanpa resistor, LED dan pin Arduino bisa rusak.
Pin Arduino mana saja yang mendukung PWM?
Di Arduino Uno dan Nano, pin PWM adalah 3, 5, 6, 9, 10, dan 11, ditandai ~ di board. Pin 5 dan 6 bekerja pada sekitar 980 Hz, sisanya sekitar 490 Hz. Di Raspberry Pi Pico, setiap pin GPIO bisa mengeluarkan PWM.
Berapa lama lilin LED Arduino bertahan dengan baterai?
Lingkaran empat lilin dengan Nano menarik sekitar 50 mA; dengan tiga baterai AA 2000 mAh, termasuk kehilangan selama sleep, itu sekitar lima malam masing-masing 6 jam. Power bank 10,000 mAh bertahan sekitar 16 malam. Untuk umur baterai yang panjang, pakai Pro Mini yang LED power-nya dilepas ditambah mode sleep.
Pada hari apa lilin di lingkaran Adven dinyalakan?
Pada lingkaran Adven, satu lilin lagi dinyalakan pada setiap hari Minggu dari empat hari Minggu sebelum Natal. Pada 2026, hari-hari itu adalah 29 November, 6 Desember, 13 Desember, dan 20 Desember. Tekan tombol di proyek ini sekali setiap hari Minggu untuk menambah jumlah lilin yang menyala.
Proyek untuk dibuat setelah membaca ini
Lihat semua proyek
LED Berkedip
"Halo" pertama di dunia elektronika: menyalakan dan mematikan satu LED. Arduino menyalakan dan mematikan LED dengan jeda singkat, sehingga cahayanya berkedip cepat.

Dua LED Berkedip Bergantian
Dua LED berkedip cepat secara bergantian: ketika satu menyala, yang lain mati, seperti sedang saling melempar bola.

Nyala/Mati LED dengan Tombol (On/Off)
Tekan tombol sekali dan lampu menyala, tekan lagi dan lampu mati, persis seperti sakelar lampu di kamarmu.

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.

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

