Panduan · 8 mnt baca

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.

LED 5 mm
LED 5 mm: untuk efek lilin pilih warna kuning, oranye, atau putih hangat; LED biru dan putih dingin tidak terlihat seperti api.

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 LEDTegangan maju (kira-kira)Resistor (Uno, 5 V)Resistor (Pico, 3,3 V)Tampilan lilin
Kuning2,0–2,1 V220 Ω (~13 mA)220 Ω (~6 mA)Sangat bagus, warna lilin klasik
Oranye / amber2,0–2,1 V220 Ω (~13 mA)220 Ω (~6 mA)Nuansa paling hangat dan paling realistis
Putih hangat3,0–3,2 V150 Ω (~12 mA)Tidak disarankan (terlalu redup)Terang, seperti lilin LED modern
Merah1,8–2,0 V220 Ω (~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

C++ (Arduino IDE)
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

ParameterDefaultKalau kamu turunkanKalau kamu naikkan
FLAME_MIN90Api berkedip lebih dalam dan terlihat hampir padamApi jadi tenang dan menyala hampir stabil
FLAME_MAX255Lilin jadi lebih redup, seperti lampu tidur255 adalah batas atas; untuk lebih terang kamu perlu arus LED yang lebih besar
CHANGE_CHANCE8 (%)Api yang diam di ruangan tanpa anginKedipan cepat dan gelisah yang lama-lama melelahkan
GUST_CHANCE3 (%)Hampir tidak ada embusan anginApi yang sering meliuk, seperti di dekat jendela terbuka
SMOOTH41–2: lompatan mendadak, seperti bohlam rusak8 ke atas: kecerahan berayun pelan seperti gelombang
STEP_MS25 msApi yang lebih cepat dan lebih hidupPada 50 ms ke atas terlihat seperti gerak lambat
Selama mengatur, ubah satu parameter dalam satu waktu dan lihat LED lewat kertas atau kaca buram, bukan secara langsung; pada LED telanjang, kedipannya selalu terlihat lebih kasar daripada aslinya. Bagi kebanyakan orang, hasil paling alami didapat dengan FLAME_MIN di 80–110, SMOOTH di 3–5, dan CHANGE_CHANCE di 6–10.

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.

KoneksiArduino Uno / NanoRaspberry Pi Pico
Lilin 1 (resistor ke kaki panjang LED)D3GP14
Lilin 2D5GP15
Lilin 3D6GP16
Lilin 4D9GP17
Kaki pendek LEDGNDGND
Tombol (kaki lainnya ke GND)D2GP2
Hubungkan lilin hanya ke pin yang mendukung PWM: di Uno dan Nano pin itu adalah 3, 5, 6, 9, 10, dan 11 (ditandai ~ di board). LED di pin lain tidak akan berkedip dengan analogWrite(); LED itu mati untuk nilai di bawah 128 dan menyala penuh di atasnya. Hubungkan tombol ke pin 2, karena sketch bangun dari sleep lewat interrupt di pin ini (INT0). Untuk peta pin Nano, lihat panduan Pinout Arduino Nano.
Arduino Nano
Arduino Nano: prosesor ATmega328P dan pin PWM yang sama dengan Uno, tapi cukup kecil untuk muat di dasar lingkaran Adven.

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.

C++ (Arduino IDE)
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}
KodeFungsinya
level[i], target[i] (array per lilin)Kecerahan dan target masing-masing lilin; keempat api berkedip secara mandiri
i >= litCountMematikan 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 1EEPROM yang belum pernah ditulis terbaca 255; pada start pertama kali dimulai dengan satu lilin
ON_TIMESetelah 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 dayaKapasitas yang bisa dipakaiMalam 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 malamPerlu diisi ulang 4–5 kali selama masa Adven
18650 + TP4056 + konverter boost 5 V~1600 mAh (pada 5 V)~4 malamDiisi lewat USB, muat di kotak
Power bank USB 10,000 mAh~6300 mAh (pada 5 V)~16 malamBisa mati sendiri selama sleep karena arusnya rendah
Adaptor USB 5 V 1 ATak terbatasTak terbatasSolusi paling mudah untuk lingkaran di atas meja
Jangan hubungkan empat baterai AA alkaline langsung ke pin 5V: baterai alkaline baru totalnya bisa mencapai 6,4 V, dan di pin 5V yang melewati regulator, ini melebihi batas 5,5 V prosesor. Baterai 9 V juga bukan pilihan bagus; kapasitasnya sekitar 500 mAh dan regulator di VIN mengubah kelebihan tegangan menjadi panas. Kalau kamu ingin lilin yang lama berjalan dengan baterai, Arduino Pro Mini yang LED power-nya dilepas bisa menurunkan arus sleep sampai level mikroampere.

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.

MicroPython
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

GejalaKemungkinan penyebabSolusi
LED tidak berkedip, hanya menyala atau matiLED terhubung ke pin non-PWMPindahkan LED ke pin 3, 5, 6, 9, 10, atau 11
Api berkedut seperti lampu neon rusakSMOOTH terlalu kecil atau target berganti di setiap langkahAtur SMOOTH ke 4–6 dan turunkan CHANGE_CHANCE di bawah 10
Semua lilin berkedip dengan cara yang sama secara bersamaanSatu variabel level ditulis ke semua pinPakai array level dan target terpisah untuk setiap lilin
Board tidak bangun dari sleepTombol tidak di D2 atau interrupt-nya bukan level LOWHubungkan tombol ke D2 dan pakai attachInterrupt(..., LOW)
Pola kedipan sama setiap kali dinyalakanrandomSeed tidak dipanggil atau A0 terhubung ke sesuatuPanggil randomSeed(analogRead(A0)) dengan pin analog yang mengambang
Baterai habis dalam beberapa hariLED power dan chip USB Nano tetap menarik arus selama sleepPakai adaptor atau ganti ke Pro Mini yang LED power-nya dilepas
Amati lilin asli di ruangan gelap selama beberapa menit dan hitung seberapa sering kecerahannya berubah, lalu atur STEP_MS dan CHANGE_CHANCE berdasarkan pengamatanmu. Kebanyakan api terlihat bergoyang dua atau tiga kali per detik dan baru benar-benar meliuk sekali setiap beberapa menit.

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.

Lihat semua proyek
LED Berkedip
AR-1Pemula

LED Berkedip

"Halo" pertama di dunia elektronika: menyalakan dan mematikan satu LED. Arduino menyalakan dan mematikan LED dengan jeda singkat, sehingga cahayanya berkedip cepat.

4.6(200)
1246
Dua LED Berkedip Bergantian
AR-2Pemula

Dua LED Berkedip Bergantian

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

4.6(110)
362
Nyala/Mati LED dengan Tombol (On/Off)
AR-10Pemula

Nyala/Mati LED dengan Tombol (On/Off)

Tekan tombol sekali dan lampu menyala, tekan lagi dan lampu mati, persis seperti sakelar lampu di kamarmu.

4.7(103)
177
Menggunakan LED RGB
AR-39Pemula
Premium

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.

4.9(73)
100
Transisi Warna Halus dengan LED RGB
AR-40Pemula
Premium

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.

4.8(58)
78
LED Fade dengan PWM ESP32
ES-8Pemula

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.

4.8(36)
55
Kendali Kecerahan LED dengan Potensiometer ESP32 (Analog → PWM)
ES-13Menengah
Premium

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.

4.5(19)
32
LED Fade PWM Raspberry Pi Pico (Efek Bernapas)
PI-14Pemula

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.

4