Lampu tangga otomatis Arduino: LED anak tangga dengan sensor gerak PIR
Buat lampu tangga otomatis dengan Arduino: dua sensor PIR mendeteksi arah, anak tangga menyala satu per satu dengan strip WS2812B atau MOSFET, plus mode malam LDR dan kode ESP32.
Lampu tangga otomatis Arduino hanya butuh sebuah Arduino, dua sensor gerak, dan satu LED strip: begitu kamu menginjak anak tangga paling bawah, anak tangga menyala satu per satu dari bawah ke atas, dan ketika kamu datang dari atas, gelombang cahayanya berjalan ke arah sebaliknya. Sekitar 15 detik setelah gerakan terakhir, anak tangga padam dengan urutan yang sama. Mata sistem ini adalah dua sensor gerak PIR di ujung bawah dan atas tangga ditambah sebuah LDR yang menjaga lampu tetap mati di siang hari; otaknya adalah state machine yang hanya beberapa baris.
Di panduan ini kamu akan melihat dua pendekatan: strip addressable WS2812B yang mengendalikan ratusan LED satu per satu lewat satu kabel data, dan cara klasik dengan strip 12 V satu warna terpisah di tiap anak tangga yang dinyalakan dan dipadamkan secara halus oleh MOSFET. Kamu juga mendapat tabel LED dan daya berdasarkan jumlah anak tangga, skema pengkabelan, kode Arduino Uno, versi 16 anak tangga dengan PCA9685, dan versi ESP32 yang bisa diatur dari ponsel.

Bagaimana cara kerja lampu tangga otomatis?
Logikanya terdiri dari empat keadaan: siaga, menyalakan, menyala, dan memadamkan. Selama siaga, Arduino memantau kedua sensor PIR dan mengecek LDR untuk melihat apakah sekitarnya gelap. Kalau sensor bawah terpicu, arahnya disimpan sebagai “naik”; kalau sensor atas yang terpicu, arahnya “turun”, lalu anak tangga menyala satu per satu dengan jeda 100–200 ms. Begitu anak tangga terakhir menyala, sistem bertahan di keadaan menyala, dan setiap pemicu baru mengulang timer dari awal. Ketika waktu yang ditentukan berlalu tanpa gerakan, lampu padam ke arah yang sama, seperti gelombang yang mengikuti orang yang lewat. Struktur ini disebut state machine, dan semuanya berjalan tanpa blocking berkat millis(), sehingga sensor tetap dibaca bahkan selagi lampu beranimasi.
| Keadaan | Apa yang terjadi? | Perpindahan ke keadaan berikutnya |
|---|---|---|
| Siaga | LED mati, LDR dibaca | Dalam gelap, pemicu PIR bawah atau atas memulai proses menyalakan |
| Menyalakan | Anak tangga menyala satu per satu sesuai arah jalan | Begitu anak tangga terakhir menyala, sistem masuk ke keadaan menyala |
| Menyala | Semua anak tangga menyala, setiap gerakan memperpanjang waktu | Ketika waktu (mis. 15 dtk) berlalu tanpa gerakan, proses memadamkan dimulai |
| Memadamkan | Anak tangga padam satu per satu ke arah yang sama | Gerakan baru mengembalikan ke menyalakan; begitu semua padam, kembali ke siaga |
Daftar komponen dan dua pilihan rangkaian
- Arduino Uno atau Nano (ESP32 kalau kamu ingin mengubah pengaturan dari ponsel).
- 2 × sensor PIR HC-SR501: satu di anak tangga terbawah, satu di anak tangga teratas.
- LDR dan resistor 10 kΩ: pembagi tegangan untuk mendeteksi malam hari.
- Opsi A: strip WS2812B (30 atau 60 LED/m), catu daya 5 V, kapasitor 1000 µF, dan resistor 330 Ω.
- Opsi B: sepotong LED strip 12 V satu warna untuk tiap anak tangga, satu MOSFET IRLZ44N dan resistor 10 kΩ per anak tangga, modul PWM 16 kanal PCA9685, dan catu daya 12 V.
- Kabel dan pemasangan: kabel 0,75–1,5 mm² (18–16 AWG) untuk jalur daya, kabel serabut tipis untuk sinyal, profil aluminium dengan diffuser untuk strip.
| Fitur | Opsi A: WS2812B | Opsi B: MOSFET + strip satu warna |
|---|---|---|
| Jalur kontrol | Satu pin data | 2 pin I2C dengan PCA9685 (sampai 16 anak tangga) |
| Pengkabelan | Rantai 3 kabel melewati semua anak tangga (5V, GND, DIN) | 2 kabel terpisah dari tiap anak tangga ke pengendali |
| Efek | Warna, pelangi, animasi per LED | Fade halus per anak tangga, satu warna |
| Tegangan | 5 V (12 V dengan WS2815) | 12 V atau 24 V |
| Jalur panjang | Ada drop tegangan, perlu injeksi daya | Rugi-rugi lebih kecil berkat tegangan yang lebih tinggi |
| Konsumsi siaga | Sekitar 0,5–1 mA per LED yang padam | Hampir nol ketika MOSFET mati |
Tabel LED dan daya berdasarkan jumlah anak tangga
Pada WS2812B, tiap LED menarik sekitar 60 mA pada putih penuh dan kecerahan penuh (20 mA per warna). Tetapi di tangga, kamu menjalankan LED dengan warna putih hangat pada kecerahan sekitar 30%; cara ini tidak menyilaukan dan memangkas arus menjadi kira-kira sepertiganya. Kolom “putih penuh” di tabel adalah kasus terburuk: meskipun kodemu membatasi kecerahan, semua LED bisa saja menyala putih penuh ketika pengujian. Jadi pilih catu daya dengan rating minimal 1,5 kali arus praktisnya, dan tentukan ukuran kabel berdasarkan putih penuh. Kolom terakhir menunjukkan RAM yang dibutuhkan kode untuk menyimpan warna LED; ingat, Uno hanya punya RAM 2 KB.
| Anak tangga | LED / anak tangga | Total LED | Putih penuh (60 mA) | Kecerahan 30% (~18 mA) | Catu daya 5 V yang disarankan | RAM (3 byte/LED) |
|---|---|---|---|---|---|---|
| 10 | 10 | 100 | 6,0 A | 1,8 A | 5 V 3 A | 300 byte |
| 12 | 15 | 180 | 10,8 A | 3,2 A | 5 V 5 A | 540 byte |
| 14 | 15 | 210 | 12,6 A | 3,8 A | 5 V 6 A | 630 byte |
| 16 | 20 | 320 | 19,2 A | 5,8 A | 5 V 10 A | 960 byte |
| 16 | 30 | 480 | 28,8 A | 8,6 A | 5 V 15 A atau strip 12 V | 1440 byte (terlalu besar untuk Uno) |
Opsi B lebih mudah dihitung, karena strip 12 V satu warna dinyatakan dalam watt per meter. Strip 2835 dengan 60 LED/m menarik sekitar 4,8 W/m. Dengan 60 cm strip di tiap anak tangga, kamu mendapat 2,9 W per anak tangga dan 46 W untuk 16 anak tangga, yaitu 3,8 A pada 12 V. Dengan margin 20%, catu daya 12 V 5 A (60 W) sudah cukup. Kamu bisa mengonversi arus, tegangan, dan daya dengan cepat memakai kalkulator hukum Ohm.
Skema pengkabelan dan tabel pin
| Sambungan | Arduino Uno | ESP32 | Catatan |
|---|---|---|---|
| OUT PIR bawah | D2 | GPIO 27 | VCC PIR ke 5 V, GND bersama |
| OUT PIR atas | D3 | GPIO 26 | Kabel 3 inti kalau ujung atas jauh |
| Titik tengah pembagi LDR | A0 | GPIO 34 | LDR ke 5 V (3,3 V di ESP32), 10 kΩ ke GND |
| WS2812B DIN | D6 (lewat 330 Ω) | GPIO 4 (lewat 74AHCT125) | Opsi A |
| PCA9685 SDA / SCL | A4 / A5 | GPIO 21 / 22 | Opsi B |
| Strip + dan - | 5 V dan GND catu daya | 5 V dan GND catu daya | Bukan dari pin 5V board |
Dengan LDR di antara 5 V dan A0 serta resistor 10 kΩ di antara A0 dan GND, nilai bacaan naik seiring ruangan makin terang. Hambatan LDR naik sampai kisaran megaohm dalam gelap dan turun ke 1–10 kΩ di siang hari; kalkulator pembagi tegangan menunjukkan tegangan yang dihasilkan pembagi pada tiap tingkat cahaya. Output HC-SR501 naik ke 3,3 V ketika terpicu; Uno membacanya sebagai HIGH, dan tegangan itu langsung cocok untuk ESP32. Putar potensiometer waktu pada sensor ke minimum (sekitar 3 detik) dan pasang jumper di posisi H (pemicu berulang); biarkan kode yang menentukan berapa lama lampu menyala, bukan sensornya. Selengkapnya tentang sensor ini ada di panduan sensor gerak PIR.
Perakitan langkah demi langkah
- Hitung anak tanggamu dan tentukan berapa LED yang dipasang di tiap anak tangga; potong strip WS2812B hanya di tanda potong tembaganya.
- Rangkai potongan strip secara berantai mulai dari anak tangga terbawah: ujung DOUT tiap potongan masuk ke ujung DIN potongan di anak tangga di atasnya. Dengan begitu, anak tangga 0 di kode adalah yang paling bawah.
- Setiap 2–3 anak tangga (kira-kira tiap 100 LED), tarik 5 V dan GND secara terpisah dari catu daya; injeksi daya ini mencegah warna menguning di anak tangga bagian atas.
- Pasang sensor PIR di dinding setinggi kira-kira 30–50 cm (12–20 inci), menghadap anak tangga pertama dan terakhir; tabung pendek di depan lensa mempersempit bidang pandangnya.
- Tempatkan LDR di posisi yang tidak terkena cahaya lampu tangga secara langsung tetapi masih mendapat cahaya dari jendela atau lampu lorong.
- Uji dulu rangkaiannya di meja dengan strip pendek untuk 2–3 anak tangga, lalu ubah STEPS dan LEDS_PER_STEP di kode sesuai tanggamu.
- Beri sensor PIR waktu pemanasan 30–60 detik setelah dinyalakan; pemicu acak selama waktu itu normal.
Opsi A: kode Arduino dengan WS2812B
Kode ini memakai library Adafruit NeoPixel, yang bisa kamu instal dari Library Manager. Jumlah anak tangga, LED per anak tangga, kecepatan gelombang, lama menyala, dan ambang gelap diatur lewat konstanta di bagian atas file. Dasar-dasar WS2812B bisa kamu temukan di panduan LED NeoPixel WS2812B.
1// Arduino merdiven aydınlatması: 2 PIR + LDR + WS2812B / Arduino stair lighting: 2 PIR + LDR + WS2812B
2#include <Adafruit_NeoPixel.h>
3
4const uint8_t PIN_PIR_BOTTOM = 2; // alt basamak PIR / bottom step PIR
5const uint8_t PIN_PIR_TOP = 3; // üst basamak PIR / top step PIR
6const uint8_t PIN_LDR = A0; // LDR bölücü orta noktası / LDR divider midpoint
7const uint8_t PIN_STRIP = 6; // WS2812B DIN (330 ohm üzerinden / through 330 ohm)
8
9const uint8_t STEPS = 14; // basamak sayısı / number of steps
10const uint8_t LEDS_PER_STEP = 15; // basamak başına LED / LEDs per step
11const uint16_t STEP_DELAY_MS = 150; // basamaklar arası gecikme / delay between steps
12const unsigned long ON_TIME_MS = 15000; // son hareketten sonra açık kalma / on time after last motion
13const int DARK_LEVEL = 300; // bunun altı karanlık / below this is dark
14const int LIGHT_LEVEL = 400; // bunun üstü aydınlık / above this is bright
15
16Adafruit_NeoPixel strip(STEPS * LEDS_PER_STEP, PIN_STRIP, NEO_GRB + NEO_KHZ800);
17const uint32_t WARM_WHITE = Adafruit_NeoPixel::Color(255, 150, 50); // sıcak beyaz / warm white
18
19enum State { IDLE, TURNING_ON, LIT, TURNING_OFF };
20State state = IDLE;
21int8_t direction = 1; // 1: aşağıdan yukarı / bottom-up, -1: yukarıdan aşağı / top-down
22uint8_t stepCount = 0; // dalgada kaçıncı basamak / position in the wave
23unsigned long lastStepTime = 0;
24unsigned long lastMotion = 0;
25bool isDark = true;
26
27// Yöne göre k'inci sıradaki fiziksel basamak (0 = en alt) / physical step at position k (0 = bottom)
28uint8_t stepAt(uint8_t k) {
29 return (direction == 1) ? k : (STEPS - 1 - k);
30}
31
32void setStep(uint8_t step, uint32_t color) {
33 uint16_t first = step * LEDS_PER_STEP;
34 for (uint8_t i = 0; i < LEDS_PER_STEP; i++) strip.setPixelColor(first + i, color);
35 strip.show();
36}
37
38// LDR'yi yalnız ışıklar sönükken oku, iki eşikli / read the LDR only while lights are off, with hysteresis
39void updateDarkness() {
40 int level = analogRead(PIN_LDR);
41 if (isDark && level > LIGHT_LEVEL) isDark = false;
42 else if (!isDark && level < DARK_LEVEL) isDark = true;
43}
44
45void startWave(State next, int8_t dir) {
46 state = next;
47 direction = dir;
48 stepCount = 0;
49 lastStepTime = millis() - STEP_DELAY_MS; // ilk basamak hemen yansın / first step at once
50}
51
52void setup() {
53 pinMode(PIN_PIR_BOTTOM, INPUT);
54 pinMode(PIN_PIR_TOP, INPUT);
55 strip.begin();
56 strip.setBrightness(80); // yaklaşık %30 parlaklık / about 30% brightness
57 strip.show(); // hepsi kapalı / all off
58}
59
60void loop() {
61 unsigned long now = millis();
62 bool bottom = digitalRead(PIN_PIR_BOTTOM) == HIGH;
63 bool top = digitalRead(PIN_PIR_TOP) == HIGH;
64
65 if (state == IDLE) updateDarkness();
66
67 if (bottom || top) {
68 if ((state == IDLE && isDark) || state == TURNING_OFF) {
69 startWave(TURNING_ON, bottom ? 1 : -1); // yön: hangi sensör önce / direction: which sensor first
70 }
71 if (state != IDLE) lastMotion = now; // her hareket süreyi uzatır / every motion extends the time
72 }
73
74 switch (state) {
75 case TURNING_ON:
76 case TURNING_OFF:
77 if (now - lastStepTime >= STEP_DELAY_MS) {
78 lastStepTime = now;
79 setStep(stepAt(stepCount), state == TURNING_ON ? WARM_WHITE : 0);
80 stepCount++;
81 if (stepCount >= STEPS) state = (state == TURNING_ON) ? LIT : IDLE;
82 }
83 break;
84 case LIT:
85 if (now - lastMotion >= ON_TIME_MS) startWave(TURNING_OFF, direction); // aynı yönde sön / fade out the same way
86 break;
87 default:
88 break;
89 }
90}| Konstanta atau fungsi | Kegunaan |
|---|---|
| STEPS, LEDS_PER_STEP | Ukuran tangga; jumlah total LED adalah hasil kali keduanya |
| STEP_DELAY_MS | Jeda antaranak tangga; 100–200 ms terasa seperti kecepatan jalan yang alami |
| ON_TIME_MS | Berapa lama lampu tetap menyala setelah gerakan terakhir |
| DARK_LEVEL, LIGHT_LEVEL | Deteksi malam dengan dua ambang; mencegah nyala-mati bergantian di waktu senja |
| stepAt(k) | Mengembalikan anak tangga fisik pada urutan ke-k sesuai arah yang sedang berlaku |
| updateDarkness() | Membaca LDR hanya selagi lampu padam |
Opsi B: fade halus dengan MOSFET dan PCA9685
Tiap strip satu warna butuh kanalnya sendiri, padahal Uno hanya punya 6 pin PWM. Untuk fade halus sampai 16 anak tangga, pakai modul PCA9685: modul ini terhubung lewat I2C dan menghasilkan PWM 12-bit (0–4095) di masing-masing dari 16 kanalnya. Tiap kanal menggerakkan gate sebuah MOSFET logic-level IRLZ44N, yang menyambungkan kabel negatif strip ke GND. Resistor 10 kΩ di antara gate dan source mencegah strip berkedip acak selagi Arduino booting. Dasar-dasarnya ada di panduan MOSFET Arduino.
| Kaki MOSFET | Terhubung ke |
|---|---|
| Gate (G) | Output kanal PCA9685; 10 kΩ ke Source |
| Drain (D) | Kabel - strip |
| Source (S) | GND catu daya 12 V (bersama dengan GND Arduino) |
| + strip | + catu daya 12 V |
1// Arduino merdiven aydınlatması: PCA9685 + MOSFET ile yumuşak geçiş / stair lighting: smooth fades with PCA9685 + MOSFETs
2#include <Wire.h>
3#include <Adafruit_PWMServoDriver.h>
4
5Adafruit_PWMServoDriver pwm(0x40); // PCA9685 varsayılan adres / default address
6
7const uint8_t PIN_PIR_BOTTOM = 2;
8const uint8_t PIN_PIR_TOP = 3;
9const uint8_t PIN_LDR = A0;
10
11const uint8_t STEPS = 16; // kanal 0 = en alt basamak / channel 0 = bottom step
12const uint16_t STEP_DELAY_MS = 120; // dalga hızı / wave speed
13const uint16_t FADE_MS = 400; // bir basamağın açılma süresi / fade time of one step
14const uint16_t MAX_PWM = 3000; // 4095 = tam parlaklık / full brightness
15const unsigned long ON_TIME_MS = 15000;
16const int DARK_LEVEL = 300, LIGHT_LEVEL = 400;
17
18uint16_t level[STEPS]; // her basamağın parlaklığı / brightness of each step
19bool lightsOn = false; // hedef: açık mı / target: on?
20bool waveRunning = false;
21int8_t direction = 1;
22unsigned long waveStart = 0, lastMotion = 0;
23bool isDark = true;
24
25void updateDarkness() {
26 int v = analogRead(PIN_LDR);
27 if (isDark && v > LIGHT_LEVEL) isDark = false;
28 else if (!isDark && v < DARK_LEVEL) isDark = true;
29}
30
31void startWave(bool on) {
32 lightsOn = on;
33 waveStart = millis();
34 waveRunning = true;
35}
36
37// Her basamağın parlaklığı = dalga başlangıcından geçen süre - sıra x gecikme
38// Brightness of each step = time since wave start - position x delay
39void updateWave(unsigned long now) {
40 bool finished = true;
41 for (uint8_t k = 0; k < STEPS; k++) {
42 uint8_t step = (direction == 1) ? k : STEPS - 1 - k;
43 long t = (long)(now - waveStart) - (long)k * STEP_DELAY_MS;
44 uint32_t p = constrain(t, 0L, (long)FADE_MS); // 0..FADE_MS
45 if (p < FADE_MS) finished = false;
46 uint32_t q = lightsOn ? p : FADE_MS - p;
47 uint16_t target = q * q * MAX_PWM / ((uint32_t)FADE_MS * FADE_MS); // karesel: göze doğal / quadratic: natural to the eye
48 uint16_t next = lightsOn ? max(level[step], target) : min(level[step], target);
49 if (next != level[step]) {
50 level[step] = next;
51 pwm.setPin(step, next);
52 }
53 }
54 if (finished) waveRunning = false;
55}
56
57void setup() {
58 pinMode(PIN_PIR_BOTTOM, INPUT);
59 pinMode(PIN_PIR_TOP, INPUT);
60 pwm.begin();
61 pwm.setPWMFreq(1000); // 1 kHz, titremesiz / no visible flicker
62 for (uint8_t i = 0; i < STEPS; i++) {
63 level[i] = 0;
64 pwm.setPin(i, 0);
65 }
66}
67
68void loop() {
69 unsigned long now = millis();
70 bool bottom = digitalRead(PIN_PIR_BOTTOM) == HIGH;
71 bool top = digitalRead(PIN_PIR_TOP) == HIGH;
72
73 if (!lightsOn && !waveRunning) updateDarkness(); // yalnız hepsi sönükken / only while all are off
74
75 if (bottom || top) {
76 if (!lightsOn && (isDark || waveRunning)) { // karanlıkta ya da sönerken / when dark or while fading out
77 direction = bottom ? 1 : -1;
78 startWave(true);
79 }
80 if (lightsOn) lastMotion = now;
81 }
82 if (lightsOn && now - lastMotion >= ON_TIME_MS) startWave(false);
83 if (waveRunning) updateWave(now);
84}Jantung kode ini adalah fungsi updateWave(): kecerahan tiap anak tangga dihitung dari waktu sejak gelombang dimulai dan posisi anak tangga itu dalam urutan. Kecerahan naik secara kuadratik, bukan linear, karena mata jauh lebih peka terhadap perubahan pada kecerahan rendah, sehingga fade terlihat lebih alami. Kalau ada gerakan baru selagi lampu meredup, tiap anak tangga naik lagi dari kecerahannya ketika itu, tanpa lompatan mati-nyala yang kasar. Dengan frekuensi PWM 1 kHz, kamu tidak akan melihat kedipan bahkan lewat kamera ponsel.
Versi ESP32: atur kecerahan dan lama menyala dari ponsel
Pindahkan logika yang sama ke ESP32 dan kamu bisa mengatur lampu tangga lewat Wi-Fi. Kode di bawah terhubung ke jaringan rumahmu dan menyajikan halaman pengaturan kecil di alamat IP ESP32; di sana kamu mengubah kecerahan dan lama menyala serta melihat bacaan LDR terbaru. Kalau Wi-Fi gagal terhubung, sistem tetap berjalan secara offline setelah 10 detik, jadi tangga tidak pernah gelap gulita. Karena ADC ESP32 beresolusi 12-bit, ambangnya berkisar dari 0 sampai 4095, dan pembagi LDR bekerja pada 3,3 V. Untuk penyiapannya, lihat Apa itu ESP32?.
1// ESP32 merdiven aydınlatması + Wi-Fi ayar sayfası / ESP32 stair lighting + Wi-Fi settings page
2#include <WiFi.h>
3#include <WebServer.h>
4#include <Adafruit_NeoPixel.h>
5
6const char* WIFI_SSID = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
7const char* WIFI_PASS = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
8
9const uint8_t PIN_PIR_BOTTOM = 27;
10const uint8_t PIN_PIR_TOP = 26;
11const uint8_t PIN_LDR = 34; // ADC1, yalnız giriş / input only
12const uint8_t PIN_STRIP = 4; // 74AHCT125 üzerinden DIN / to DIN via 74AHCT125
13
14const uint8_t STEPS = 14;
15const uint8_t LEDS_PER_STEP = 15;
16const uint16_t STEP_DELAY_MS = 150;
17const int DARK_LEVEL = 1200, LIGHT_LEVEL = 1600; // 12 bit ADC: 0-4095
18
19uint8_t brightness = 80; // web sayfasından değişir / set from the web page
20unsigned long onTimeMs = 15000;
21
22Adafruit_NeoPixel strip(STEPS * LEDS_PER_STEP, PIN_STRIP, NEO_GRB + NEO_KHZ800);
23WebServer server(80);
24
25enum State { IDLE, TURNING_ON, LIT, TURNING_OFF };
26State state = IDLE;
27int8_t direction = 1;
28uint8_t stepCount = 0;
29unsigned long lastStepTime = 0, lastMotion = 0;
30bool isDark = true;
31int lastLdr = 0;
32
33uint32_t warmWhite() { // parlaklığı renge uygula / apply brightness to the color
34 return Adafruit_NeoPixel::Color(255 * brightness / 255, 150 * brightness / 255, 50 * brightness / 255);
35}
36
37void setStep(uint8_t step, uint32_t color) {
38 for (uint8_t i = 0; i < LEDS_PER_STEP; i++) strip.setPixelColor(step * LEDS_PER_STEP + i, color);
39 strip.show();
40}
41
42void startWave(State next, int8_t dir) {
43 state = next;
44 direction = dir;
45 stepCount = 0;
46 lastStepTime = millis() - STEP_DELAY_MS;
47}
48
49void handleRoot() {
50 if (server.hasArg("b")) brightness = constrain(server.arg("b").toInt(), 5, 255);
51 if (server.hasArg("t")) onTimeMs = constrain(server.arg("t").toInt(), 5, 300) * 1000UL;
52 String html = "<!DOCTYPE html><html><head><meta name='viewport' content='width=device-width'></head><body>";
53 html += "<h2>Merdiven / Stairs</h2><form>";
54 html += "Parlaklik / Brightness (5-255): <input name='b' type='number' value='" + String(brightness) + "'><br>";
55 html += "Sure / Time (s): <input name='t' type='number' value='" + String(onTimeMs / 1000) + "'><br>";
56 html += "<button>Kaydet / Save</button></form>";
57 html += "<p>LDR: " + String(lastLdr) + (isDark ? " (gece / night)" : " (gunduz / day)") + "</p></body></html>";
58 server.send(200, "text/html", html);
59}
60
61void setup() {
62 Serial.begin(115200);
63 pinMode(PIN_PIR_BOTTOM, INPUT);
64 pinMode(PIN_PIR_TOP, INPUT);
65 strip.begin();
66 strip.show();
67 WiFi.mode(WIFI_STA);
68 WiFi.begin(WIFI_SSID, WIFI_PASS);
69 unsigned long t0 = millis();
70 while (WiFi.status() != WL_CONNECTED && millis() - t0 < 10000) delay(250); // en çok 10 s / at most 10 s
71 if (WiFi.status() == WL_CONNECTED) Serial.println(WiFi.localIP());
72 else Serial.println("Wi-Fi yok, cevrimdisi calisiyor / no Wi-Fi, running offline");
73 server.on("/", handleRoot);
74 server.begin();
75}
76
77void loop() {
78 server.handleClient();
79 unsigned long now = millis();
80 bool bottom = digitalRead(PIN_PIR_BOTTOM) == HIGH;
81 bool top = digitalRead(PIN_PIR_TOP) == HIGH;
82
83 if (state == IDLE) { // LDR yalnız ışıklar sönükken / LDR only while lights are off
84 lastLdr = analogRead(PIN_LDR);
85 if (isDark && lastLdr > LIGHT_LEVEL) isDark = false;
86 else if (!isDark && lastLdr < DARK_LEVEL) isDark = true;
87 }
88
89 if (bottom || top) {
90 if ((state == IDLE && isDark) || state == TURNING_OFF) startWave(TURNING_ON, bottom ? 1 : -1);
91 if (state != IDLE) lastMotion = now;
92 }
93
94 if ((state == TURNING_ON || state == TURNING_OFF) && now - lastStepTime >= STEP_DELAY_MS) {
95 lastStepTime = now;
96 uint8_t step = (direction == 1) ? stepCount : STEPS - 1 - stepCount;
97 setStep(step, state == TURNING_ON ? warmWhite() : 0);
98 if (++stepCount >= STEPS) state = (state == TURNING_ON) ? LIT : IDLE;
99 } else if (state == LIT && now - lastMotion >= onTimeMs) {
100 startWave(TURNING_OFF, direction);
101 }
102}Penempatan sensor dan sensor alternatif
Sensor PIR mendeteksi perubahan panas: ia bereaksi ketika panas tubuh bergerak melintasi bidang pandangnya. Masalah paling umum di tangga adalah sensor terpicu oleh orang yang lewat di lorong bawah atau oleh pemanas ruangan. Miringkan sensor ke arah anak tangga, tutup sebagian lensa Fresnel dengan selotip, dan putar potensiometer sensitivitas ke tengah. Untuk deteksi yang lebih presisi, pasang HC-SR04 atau VL53L0X di tiap ujung dan pakai seperti penghalang cahaya: ketika jarak yang terukur tiba-tiba memendek, berarti ada orang yang menginjak anak tangga. Sebaliknya, sensor radar RCWL-0516 bisa melihat menembus dinding dan terpicu dari ruangan sebelah, jadi tidak disarankan di sini.
| Sensor | Kelebihan | Kekurangan | Kecocokan untuk tangga |
|---|---|---|---|
| PIR HC-SR501 | Murah, jangkauan 5–7 m, bisa diatur | Pemicu palsu dari sumber panas, waktu buta 2–3 dtk | Sangat baik |
| PIR mini AM312 | Kecil, bekerja pada 3,3 V, muat di dalam anak tangga | Tidak bisa diatur, jangkauan 3–5 m | Baik |
| HC-SR04 atau VL53L0X | Mendeteksi kaki di anak tangga dengan andal | Perlu kode untuk pengukuran terus-menerus | Baik (seperti penghalang cahaya) |
| Radar RCWL-0516 | Bisa disembunyikan di balik penutup | Menembus dinding, terpicu dari ruangan sebelah | Tidak disarankan |
Kesalahan umum dan cara mengatasinya
- Warna menguning di anak tangga bagian atas: ada drop tegangan di jalur 5 V; lakukan injeksi daya setiap 2–3 anak tangga dan pakai kabel daya yang tebal.
- LED pertama benar, sisanya menampilkan warna acak: tidak ada ground bersama atau jalur datanya terlalu panjang; satukan semua GND, pasang resistor 330 Ω dekat dengan strip, dan jaga kabel data tidak lebih dari beberapa meter.
- Lampu berjalan ke arah yang salah: rantai strip dimulai dari anak tangga teratas; mulai rantainya dari bawah atau balik logika arah di kode.
- Menyala di siang hari atau tidak pernah menyala di malam hari: ambang LDR salah atau LDR terkena cahaya lampu tangga; ukur nilainya di Serial Monitor dan pindahkan LDR.
- Lampu tidak pernah padam: potensiometer waktu PIR diatur terlalu lama atau sensor menghadap sumber panas; putar potensiometer ke minimum dan arahkan ulang sensornya.
- Arduino reset secara acak: tegangan catu daya turun ketika LED menyala, atau strip diberi daya dari pin 5V board; pakai catu daya yang lebih besar dan beri daya strip secara terpisah.
- MOSFET panas: kamu memakai MOSFET yang bukan logic-level; ganti dengan komponen seperti IRLZ44N dan jaga resistor gate di antara 100 dan 220 Ω.
Ide untuk mengembangkan lampu tanggamu
- Mode lampu malam: selagi tidak ada gerakan, biarkan hanya anak tangga pertama dan terakhir menyala 5% untuk menunjukkan letak tangga.
- Gelombang warna: dengan WS2812B, nyalakan tiap anak tangga dengan warna pelangi yang berbeda dan ganti warnanya ketika hari raya.
- Perluasan ke lorong: pakai logika yang sama untuk menerangi lorong panjang dengan PIR di tiap ujungnya.
- Otomasi rumah: hubungkan ESP32 ke Home Assistant lewat MQTT dan kendalikan tangga bersama lampu-lampumu yang lain.
- Firmware siap pakai: kalau kamu ingin efek tanpa menulis kode, instal WLED dan hubungkan sensor PIR ke sana.
Lampu tangga menggabungkan pembacaan sensor, pengaturan waktu, perhitungan daya, dan penggerak LED dalam satu proyek, jadi ia memberi nilai tambah yang awet untuk rumahmu sekaligus mengajarimu banyak hal. Coba dulu di meja dengan strip pendek untuk dua anak tangga, lalu pindahkan ke tanggamu. Di aplikasi BlueGrays, proyek Lampu Tangga dan Lorong Pintar memandumu melalui skema rangkaian dan kodenya langkah demi langkah, dan proyek WS2812B serta PIR membantumu mengenal tiap komponen satu per satu.
Pertanyaan umum
Berapa LED yang dibutuhkan per anak tangga?
Tergantung lebar anak tangga dan kerapatan strip. Strip 30 LED/m menghasilkan 27 LED pada anak tangga selebar 90 cm (36 inci); di kebanyakan tangga, 10–20 LED per anak tangga memberi cahaya yang merata. Memasang strip di dalam profil aluminium dengan diffuser menyamarkan titik-titik LED.
Berapa besar catu daya yang dibutuhkan untuk lampu tangga LED?
Untuk WS2812B, kalikan jumlah total LED dengan 18 mA (kecerahan sekitar 30%) lalu tambahkan cadangan 50%; untuk 210 LED, misalnya, catu daya 5 V 6 A sudah pas. Untuk strip 12 V satu warna, kalikan watt per meter dengan panjang total, bagi dengan 12, lalu tambahkan margin 20%.
WS2812B atau LED strip satu warna untuk tangga?
Kalau kamu ingin warna dan animasi, WS2812B lebih fleksibel dan hanya butuh satu kabel data. Kalau kamu hanya ingin cahaya putih hangat di jalur yang panjang, strip 12 V atau 24 V satu warna dengan MOSFET lebih efisien, drop tegangannya lebih kecil, dan konsumsi siaganya hampir nol.
Kenapa sensor PIR-ku menyalakan lampu tangga sendiri?
Sensor PIR bereaksi terhadap perubahan panas, jadi pemanas ruangan, sinar matahari dari jendela, aliran udara hangat, atau hewan peliharaan bisa memicunya. Pemicu dalam 30–60 detik pertama setelah dinyalakan juga normal. Arahkan sensor ke anak tangga, tutup sebagian lensanya, dan turunkan sensitivitasnya.
Bagaimana agar lampu tangga tidak menyala di siang hari?
Tambahkan LDR dan terima pemicu PIR hanya ketika bacaan cahaya di bawah ambang. Memakai dua ambang alih-alih satu (histeresis) mencegah lampu nyala-mati bergantian di waktu senja. Tempatkan LDR di posisi yang tidak terkena lampu tangga dan baca nilainya hanya selagi lampu padam.
Berapa banyak LED WS2812B yang bisa digerakkan Arduino Uno?
Tiap LED memakai 3 byte RAM; dengan RAM 2 KB milik Uno dan variabel-variabelmu yang lain, batas praktisnya sekitar 400–500 LED. Untuk tangga yang lebih panjang, pakai Arduino Mega atau ESP32, atau kurangi jumlah LED per anak tangga. Arus disediakan oleh catu daya, jadi batasnya adalah memori, bukan daya.
Proyek untuk dibuat setelah membaca ini
Lihat semua proyek
Lampu Tangga dan Koridor Pintar
Injak tangga atau masuk ke lorong, dan lampu menyala satu per satu ke arah kamu berjalan.

Lampu Tidur dengan LDR
Lampu tidur kecil yang menyala sendiri ketika gelap dan mati ketika pagi tiba. Sensor cahaya mengukur seberapa terang ruangan, dan Arduino menyalakan LED ketika cukup gelap lalu mematikannya lagi…

Menggunakan LED Strip WS2812B
Kenalan dengan LED strip pintar yang setiap lampunya bisa kamu warnai sendiri-sendiri.

LED Berjalan WS2812B (Efek Isi)
Strip lampu yang terisi dan kosong seperti segelas air. Arduino menyalakan sepuluh LED warna satu per satu dengan warna oranye dan membiarkannya menyala; begitu strip penuh, ia mematikannya satu per…

Pendeteksi Gerakan dengan Sensor Gerak
Penjaga sederhana yang memberi tahu ketika ada orang masuk ke ruangan. Sensor gerak menangkap panas yang dipancarkan tubuh manusia, dan Arduino menjaga LED tetap menyala selama ada gerakan lalu…

Lampu Otomatis dengan Sensor Gerak PIR ESP32
Di proyek ini, sensor gerak PIR HC-SR501 mendeteksi ketika seseorang masuk ke ruangan dan otomatis menyalakan LED. Lama LED menyala dilacak dengan millis(); setiap bacaan HIGH memperbarui waktu gerakan terakhir, dan LED mati minimal 10 detik setelah bacaan HIGH terakhir. Kode yang sekarang juga menunggu 50 ms di setiap loop dengan delay(50), jadi loopnya belum sepenuhnya non-blocking. Proyek ini bisa dipakai untuk lampu tangga.

Lampu Pintar ESP32 (PIR + LDR + Relay + OLED)
Ubah lorong, kamar mandi, atau gudangmu menjadi lampu pintar dengan ESP32! Dengan sensor gerak PIR, sensor cahaya LDR, dan modul relay, kita membuat skenario klasik "lampu menyala ketika ada gerakan dalam gelap"; jika sudah terang, gerakan TIDAK menyalakan lampu, jadi energi hemat di siang hari. Lampu menyala 30 detik; jika gerakan berlanjut, timer diulang. OLED SSD1306 menampilkan status dengan font besar (NYALA / SIANG / MENUNGGU) dan hitung mundur.

Kendali Strip NeoPixel WS2812B ESP32
LED addressable WS2812B (NeoPixel) adalah LED RGB pintar yang bisa dikendalikan secara berantai lewat satu pin data. Di proyek ini, kita mengendalikan strip WS2812B 8 LED dengan library Adafruit_NeoPixel untuk membuat animasi pelangi yang halus. Meskipun level logika 3,3V ESP32 bekerja lancar dengan sebagian besar komponen WS2812B, kita menunjukkan solusi dengan resistor seri 470Ω dan kapasitor 1000µF untuk berjaga-jaga jika tidak stabil. Animasinya dibuat dengan menggeser nilai hue.
Artikel lainnya
- LED Strip WS2812B NeoPixel dengan Arduino: Panduan LED RGB Addressable
- Sensor Gerak PIR (HC-SR501): Mendeteksi Gerakan dengan Arduino, ESP32, dan Pico
- Apa Itu Sensor Cahaya LDR? Mengukur Cahaya dengan Arduino dan Lampu Tidur Otomatis
- Panduan MOSFET Arduino: Mengendalikan LED Strip 12V, Motor, dan Pompa
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

