Web Server ESP32 dengan LED RGB: pilih warna dari ponselmu
Buat web server ESP32 untuk LED RGB dan atur warnanya dari pemilih warna ponsel: rangkaian anoda/katoda bersama, HEX ke RGB, PWM LEDC, gamma, dan WS2812B.
Web server ESP32 dengan LED RGB memungkinkanmu mengganti warna LED tanpa memasang aplikasi apa pun: ESP32 menyajikan halaman web kecil, kamu memilih warna di pemilih warna yang terbuka di browser ponsel, dan LED langsung berganti. Ada tiga hal yang terjadi di balik layar: browser mengubah pilihanmu menjadi kode HEX seperti #FF8800 dan mengirimnya lewat Wi-Fi, ESP32 memecah kode itu menjadi tiga angka untuk merah, hijau, dan biru, lalu setiap angka menjadi sinyal PWM yang dibangkitkan oleh periferal LEDC.
Di panduan ini kamu akan belajar cara merangkai LED RGB katoda bersama atau anoda bersama ke ESP32, nilai resistor yang cocok untuk 3,3 V, cara menulis kode LEDC yang berjalan di core ESP32 Arduino 2.x maupun 3.x, cara mengonversi HEX ke RGB, dan bagaimana koreksi gamma membuat warna tampak seperti yang diharapkan matamu. Di akhir, kamu menyambungkan antarmuka ponsel yang sama ke strip LED WS2812B tanpa menyentuh satu baris HTML pun.

Bagaimana cara kerjanya? Dari pemilih warna sampai ke LED
- Dengan ponsel di jaringan Wi-Fi yang sama dengan ESP32, kamu membuka alamat IP ESP32 di browser dan ESP32 mengirim balik halaman HTML kecil berisi pemilih warna.
- Elemen <input type="color"> di halaman membuka pemilih warna bawaan ponsel dan mengembalikan pilihan dalam format #ff8800.
- Beberapa baris JavaScript mengirim nilai itu ke /set?hex=ff8800; selama jarimu bergeser, warna-warna baru terkirim satu demi satu.
- ESP32 memecah enam digit itu menjadi tiga angka, 255, 136, dan 0, lalu menerapkan koreksi gamma pada masing-masing.
- LEDC membangkitkan PWM 5 kHz di tiga pin; duty cycle menentukan kecerahan setiap warna, dan matamu mencampur ketiga cahaya itu menjadi satu warna.
Daftar komponen
- Papan pengembangan ESP32 DevKit (30 atau 38 pin)
- Satu LED RGB (5 mm, katoda bersama atau anoda bersama)
- Resistor 150 Ω untuk merah dan resistor 100 Ω untuk hijau dan biru (tiga resistor 220 Ω juga bisa kalau itu yang kamu punya)
- Breadboard dan beberapa kabel jumper
- Kabel USB yang bisa mengirim data
- Opsional: strip LED WS2812B, catu daya 5 V, resistor 330 Ω, dan kapasitor 1000 µF
Katoda bersama vs anoda bersama: tabel rangkaian
Pada LED RGB berkaki empat, kaki terpanjang adalah kaki bersama. Pada LED katoda bersama (CC), kaki ini ke GND, dan kamu menyalakan sebuah warna dengan memberi pin warna itu HIGH. Pada LED anoda bersama (CA), kaki bersama ke tegangan catu dan warna menyala ketika pinnya LOW. Kalau tidak tahu jenis LED-mu, sambungkan kaki terpanjang ke GND dan kaki lain ke 3V3 lewat resistor 150 Ω: jika menyala, LED-nya katoda bersama. Jika tidak, balik sambungannya; jika sekarang menyala, itu anoda bersama. Pada kebanyakan model, urutan kaki dari sisi yang datar adalah merah, bersama, hijau, biru.
| Kaki | Katoda bersama (CC) | Anoda bersama (CA) | Resistor |
|---|---|---|---|
| Merah (R) | GPIO 25 | GPIO 25 | 150 Ω |
| Kaki bersama (terpanjang) | GND | 3V3 | Tidak ada |
| Hijau (G) | GPIO 26 | GPIO 26 | 100 Ω |
| Biru (B) | GPIO 27 | GPIO 27 | 100 Ω |
| Pengaturan di kode | COMMON_ANODE = false | COMMON_ANODE = true | Tidak ada |
| Duty cycle untuk warna pada kecerahan penuh | 1023 (maksimum) | 0 (kode membaliknya untukmu) | Tidak ada |
Perhitungan resistor adalah penerapan sederhana hukum Ohm: R = (3,3 V − tegangan LED) / arus. LED merah butuh sekitar 2,0 V; dengan 150 Ω arusnya (3,3 − 2,0) / 150 ≈ 8,7 mA. LED hijau dan biru bekerja di sekitar 2,8 sampai 3,1 V, jadi ruang sisanya sangat kecil pada 3,3 V; dengan 100 Ω mengalir 3 sampai 5 mA dan warnanya cukup terang. Dengan 220 Ω di ketiga kaki rangkaian tetap bekerja, tetapi biru dan hijau jelas lebih redup dan putih jadi kemerahan muda. Untuk menghitung dengan nilai LED-mu sendiri, pakai kalkulator resistor LED. Jangan tarik lebih dari 20 mA terus-menerus dari pin ESP32.
PWM LEDC ESP32: tiga kanal, 5 kHz, 10 bit
Di ESP32, padanan analogWrite pada Arduino Uno adalah periferal LEDC. ESP32 klasik punya 16 kanal PWM independen, dan kamu memilih frekuensi dan resolusi masing-masing. Proyek ini memakai 5 kHz dan 10 bit: 10 bit berarti duty cycle bergerak dari 0 sampai 1023, yang menghasilkan transisi jauh lebih halus daripada 8 bit, terutama di warna gelap. 5 kHz cukup cepat sehingga baik matamu maupun kebanyakan kamera ponsel tidak melihat kedipan. Satu hal yang perlu diwaspadai: fungsi LEDC berubah di versi 3.0 core ESP32 Arduino, karena itu banyak kode lama dari internet tidak lagi bisa dikompilasi di instalasi baru. Sketch di bawah memeriksa konstanta ESP_ARDUINO_VERSION_MAJOR dan bekerja di kedua versi. Untuk dasarnya, lihat panduan apa itu PWM.
| Versi core | Pengaturan | Menulis nilai |
|---|---|---|
| 3.x (terbaru) | ledcAttach(pin, 5000, 10) | ledcWrite(pin, duty) |
| 2.x (lama) | ledcSetup(kanal, 5000, 10) dan ledcAttachPin(pin, kanal) | ledcWrite(kanal, duty) |
Uji rangkaiannya dulu
Memastikan rangkaian sudah benar sebelum lanjut ke web server menghemat waktu. Unggah sketch di bawah: LED harus menyala merah, hijau, biru, dan putih masing-masing satu detik, lalu mati selama satu detik. Jika warnanya datang dengan urutan lain (misalnya hijau di tempat merah), ubah urutan di array PINS. Jika LED selalu menyala dan justru padam ketika putih, LED-mu anoda bersama; ubah COMMON_ANODE menjadi true.
1// RGB LED bağlantı testi: kırmızı, yeşil, mavi, beyaz, kapalı
2// RGB LED wiring test: red, green, blue, white, off
3const int PINS[3] = {25, 26, 27}; // R, G, B pinleri / R, G, B pins
4const bool COMMON_ANODE = false; // ortak anot ise true / true for common anode
5const int PWM_FREQ = 5000; // 5 kHz, titreme yok / 5 kHz, no flicker
6const int PWM_BITS = 10; // 0-1023
7const int PWM_MAX = (1 << PWM_BITS) - 1;
8
9void pwmSetup() {
10 for (int i = 0; i < 3; i++) {
11#if ESP_ARDUINO_VERSION_MAJOR >= 3
12 ledcAttach(PINS[i], PWM_FREQ, PWM_BITS); // çekirdek 3.x: pin tabanlı / core 3.x: pin based
13#else
14 ledcSetup(i, PWM_FREQ, PWM_BITS); // çekirdek 2.x: kanal i / core 2.x: channel i
15 ledcAttachPin(PINS[i], i);
16#endif
17 }
18}
19
20void pwmWrite(int i, int duty) {
21 if (COMMON_ANODE) duty = PWM_MAX - duty; // ortak anotta mantık ters / logic is inverted for common anode
22#if ESP_ARDUINO_VERSION_MAJOR >= 3
23 ledcWrite(PINS[i], duty);
24#else
25 ledcWrite(i, duty);
26#endif
27}
28
29void setRaw(int r, int g, int b) { // gamasız ham değer / raw duty, no gamma
30 pwmWrite(0, r);
31 pwmWrite(1, g);
32 pwmWrite(2, b);
33}
34
35void setup() {
36 pwmSetup();
37}
38
39void loop() {
40 setRaw(PWM_MAX, 0, 0); delay(1000); // kırmızı / red
41 setRaw(0, PWM_MAX, 0); delay(1000); // yeşil / green
42 setRaw(0, 0, PWM_MAX); delay(1000); // mavi / blue
43 setRaw(PWM_MAX, PWM_MAX, PWM_MAX); delay(1000); // beyaz / white
44 setRaw(0, 0, 0); delay(1000); // kapalı / off
45}Mengonversi kode warna HEX ke RGB
Di web, warna ditulis sebagai #RRGGBB: dua digit pertama adalah nilai merah, dua berikutnya hijau, dan dua terakhir biru, masing-masing dari 0 sampai 255 dan ditulis dalam basis enam belas (heksadesimal). Pada #FF8800, FF = 255, 88 = 8 × 16 + 8 = 136, dan 00 = 0, jadi merah penuh, sedikit hijau, dan tanpa biru: oranye. Kode melakukannya dalam dua langkah: strtol(hex, NULL, 16) mengubah teks enam digit menjadi satu angka (0xFF8800), lalu pergeseran bit dan mask memisahkan tiga byte: (rgb >> 16) & 0xFF untuk merah, (rgb >> 8) & 0xFF untuk hijau, dan rgb & 0xFF untuk biru.
| HEX | Merah | Hijau | Biru | Warna |
|---|---|---|---|---|
| #FF0000 | 255 | 0 | 0 | Merah |
| #00FF00 | 0 | 255 | 0 | Hijau |
| #0000FF | 0 | 0 | 255 | Biru |
| #FF8800 | 255 | 136 | 0 | Oranye |
| #800080 | 128 | 0 | 128 | Ungu |
| #FFFFFF | 255 | 255 | 255 | Putih |
| #000000 | 0 | 0 | 0 | Mati |
Koreksi gamma: mengapa warnanya tampak pudar?
Matamu tidak menangkap kecerahan secara linear: di tempat gelap ia sangat peka terhadap perubahan kecil, sedangkan di cahaya terang ia sulit membedakan bahkan lompatan besar. Karena itu duty cycle 50 % sudah tampak hampir terang penuh, dan warna pastel yang kamu pilih di layar berubah menjadi warna pudar yang nyaris putih di LED. Solusinya adalah menerapkan koreksi gamma pada setiap kanal: keluaran = maksimum × (masukan / 255)^2,2. Layar memakai kurva yang sama, jadi setelah koreksi warna di ponsel dan warna LED jauh lebih mirip. Tabel ini menunjukkan seberapa kuat kurva menekan warna gelap, dan mengapa 10 bit membantu:
| Nilai yang dipilih (0–255) | PWM 8 bit (0–255) | 10-bit PWM (0–1023) |
|---|---|---|
| 16 | 1 | 2 |
| 32 | 3 | 11 |
| 64 | 12 | 49 |
| 128 | 56 | 225 |
| 192 | 137 | 548 |
| 255 | 255 | 1023 |
Sketch utama: web server dengan pemilih warna untuk ponselmu
Sketch utama memakai pustaka WebServer yang sudah ikut bersama core ESP32, jadi tidak ada yang perlu dipasang tambahan. Masukkan nama jaringan dan kata sandimu, unggah sketch, lalu buka Serial Monitor pada 115200 baud. Setelah beberapa detik kamu akan melihat alamat seperti http://192.168.1.45; buka di browser ponsel yang ada di jaringan Wi-Fi yang sama. ESP32 hanya bisa tersambung ke jaringan 2,4 GHz, dan ponsel harus berada di jaringan yang sama.
1// ESP32 RGB LED: telefondaki renk seçiciden Wi-Fi ile renk ayarı
2// ESP32 RGB LED: set the colour over Wi-Fi from a colour picker on your phone
3#include <WiFi.h>
4#include <WebServer.h>
5#include <math.h>
6
7const char* WIFI_SSID = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
8const char* WIFI_PASS = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
9
10const int PINS[3] = {25, 26, 27}; // R, G, B pinleri / R, G, B pins
11const bool COMMON_ANODE = false; // ortak anot ise true / true for common anode
12const int PWM_FREQ = 5000; // 5 kHz, titreme yok / 5 kHz, no flicker
13const int PWM_BITS = 10; // 0-1023, koyu tonlar daha yumuşak / smoother dark tones
14const int PWM_MAX = (1 << PWM_BITS) - 1;
15const float GAMMA = 2.2; // algısal parlaklık düzeltmesi / perceptual correction
16
17WebServer server(80);
18String currentHex = "000000"; // son seçilen renk / last chosen colour
19
20// Telefonda açılan sayfa / the page opened on the phone
21const char PAGE[] PROGMEM = R"rawliteral(
22<!DOCTYPE html><html><head><meta charset="utf-8">
23<meta name="viewport" content="width=device-width,initial-scale=1">
24<title>ESP32 RGB</title>
25<style>
26body{font-family:sans-serif;text-align:center;background:#111;color:#eee;margin-top:40px}
27input[type=color]{width:200px;height:200px;border:none;background:none}
28button{font-size:18px;padding:10px 20px;margin:6px}
29</style></head><body>
30<h2>ESP32 RGB LED</h2>
31<input type="color" id="c" value="#%HEX%">
32<p id="t">#%HEX%</p>
33<button onclick="pick('#000000')">Kapat / Off</button>
34<button onclick="pick('#ffffff')">Beyaz / White</button>
35<button onclick="pick('#ff8800')">Turuncu / Orange</button>
36<script>
37let busy = false, next = null;
38function send(h) {
39 if (busy) { next = h; return; }
40 busy = true;
41 fetch('/set?hex=' + h.substring(1)).finally(() => {
42 busy = false;
43 if (next) { const n = next; next = null; send(n); }
44 });
45}
46function show(h) { document.getElementById('t').textContent = h; send(h); }
47function pick(h) { document.getElementById('c').value = h; show(h); }
48document.getElementById('c').addEventListener('input', e => show(e.target.value));
49</script></body></html>
50)rawliteral";
51
52void pwmSetup() {
53 for (int i = 0; i < 3; i++) {
54#if ESP_ARDUINO_VERSION_MAJOR >= 3
55 ledcAttach(PINS[i], PWM_FREQ, PWM_BITS); // çekirdek 3.x: pin tabanlı / core 3.x: pin based
56#else
57 ledcSetup(i, PWM_FREQ, PWM_BITS); // çekirdek 2.x: kanal i / core 2.x: channel i
58 ledcAttachPin(PINS[i], i);
59#endif
60 }
61}
62
63void pwmWrite(int i, int duty) {
64 if (COMMON_ANODE) duty = PWM_MAX - duty; // ortak anotta mantık ters / logic is inverted for common anode
65#if ESP_ARDUINO_VERSION_MAJOR >= 3
66 ledcWrite(PINS[i], duty);
67#else
68 ledcWrite(i, duty);
69#endif
70}
71
72int gammaCorrect(int v) { // 0-255 -> 0-PWM_MAX
73 return (int)(pow(v / 255.0, GAMMA) * PWM_MAX + 0.5);
74}
75
76void setColor(int r, int g, int b) {
77 pwmWrite(0, gammaCorrect(r));
78 pwmWrite(1, gammaCorrect(g));
79 pwmWrite(2, gammaCorrect(b));
80}
81
82bool isHex6(const String& s) { // tam 6 onaltılık hane mi? / exactly 6 hex digits?
83 if (s.length() != 6) return false;
84 for (int i = 0; i < 6; i++) {
85 if (!isxdigit((unsigned char)s[i])) return false;
86 }
87 return true;
88}
89
90void handleRoot() {
91 String page(PAGE);
92 page.replace("%HEX%", currentHex); // sayfa son renkle açılsın / open with the last colour
93 server.send(200, "text/html", page);
94}
95
96void handleSet() {
97 String hex = server.arg("hex"); // örnek / example: ff8800
98 if (!isHex6(hex)) {
99 server.send(400, "text/plain", "hex?");
100 return;
101 }
102 long rgb = strtol(hex.c_str(), NULL, 16); // "ff8800" -> 0xFF8800
103 int r = (rgb >> 16) & 0xFF; // 255
104 int g = (rgb >> 8) & 0xFF; // 136
105 int b = rgb & 0xFF; // 0
106 setColor(r, g, b);
107 currentHex = hex;
108 server.send(200, "text/plain", "OK");
109}
110
111void setup() {
112 Serial.begin(115200);
113 pwmSetup();
114 setColor(0, 0, 0);
115 WiFi.mode(WIFI_STA);
116 WiFi.begin(WIFI_SSID, WIFI_PASS);
117 while (WiFi.status() != WL_CONNECTED) {
118 delay(500);
119 Serial.print(".");
120 }
121 WiFi.setSleep(false); // daha hızlı yanıt / faster response
122 Serial.println();
123 Serial.print("Telefonda aç / open on your phone: http://");
124 Serial.println(WiFi.localIP());
125 server.on("/", handleRoot);
126 server.on("/set", handleSet);
127 server.begin();
128}
129
130void loop() {
131 server.handleClient();
132}Cara kerja kode
| Bagian | Fungsinya |
|---|---|
| PAGE | HTML, CSS, dan JavaScript yang dikirim ke ponsel; R"rawliteral(...)" memungkinkanmu menulisnya tanpa meng-escape tanda kutip |
| input type="color" | Membuka pemilih warna bawaan ponsel dan mengembalikan pilihan sebagai #rrggbb |
| send() dan busy | Hanya mengirim satu permintaan dalam satu waktu; dari warna yang menumpuk selama kamu menggeser, hanya yang terbaru yang dikirim |
| /set?hex=ff8800 | Permintaan yang sampai ke ESP32; handleSet() menjawabnya |
| isHex6() | Memeriksa bahwa teksnya tepat enam digit heksadesimal dan menolak permintaan yang rusak |
| strtol dan pergeseran bit | Mengubah teks menjadi angka dan memisahkan byte merah, hijau, dan biru |
| gammaCorrect() | Memetakan nilai 0–255 ke 0–1023 mengikuti kurva gamma 2,2 |
| pwmWrite() | Membalik nilai untuk anoda bersama dan memanggil ledcWrite yang benar sesuai versi core |
| %HEX% | Menampilkan warna terakhir setiap kali halaman dibuka, sehingga ponsel kedua juga melihat warna yang sedang aktif |
| WiFi.setSleep(false) | Mematikan mode hemat daya Wi-Fi agar perubahan warna sampai tanpa jeda |
Antarmuka yang sama dengan strip WS2812B
Jika kamu lebih suka mengendalikan strip berisi puluhan LED daripada satu LED RGB, HTML dan web server sama sekali tidak perlu disentuh; kamu cukup mengganti fungsi yang menggerakkan LED. Setiap LED WS2812B punya chip pengendali sendiri, jadi satu pin data sudah cukup. Sambungkan ujung DIN strip ke GPIO 13 lewat resistor 330 Ω, beri daya strip dari catu 5 V terpisah, dan satukan GND catu dengan GND ESP32. Setiap LED menarik sekitar 60 mA pada putih penuh; strip 30 LED bisa mencapai 1,8 A, karena itu kode membatasi kecerahan ke 80/255. Kapasitor 1000 µF di terminal daya melindungi LED dari lonjakan arus ketika dinyalakan. Dengan strip di 5 V, sinyal data 3,3 V dari ESP32 biasanya cukup; jika muncul kedipan atau warna acak, tambahkan level shifter seperti 74AHCT125. Detail strip ada di panduan WS2812B NeoPixel. Ganti empat fungsi LED di sketch utama dengan potongan di bawah, lalu pasang pustaka Adafruit NeoPixel dari Library Manager:
1// WS2812B şerit: ana koddaki pwmSetup, pwmWrite, gammaCorrect ve setColor yerine bunu koy
2// WS2812B strip: use this instead of pwmSetup, pwmWrite, gammaCorrect and setColor in the main sketch
3#include <Adafruit_NeoPixel.h>
4
5const int STRIP_PIN = 13; // DIN, 330 Ω direnç üzerinden / through a 330 Ω resistor
6const int NUM_LEDS = 30; // şeritteki LED sayısı / number of LEDs on the strip
7Adafruit_NeoPixel strip(NUM_LEDS, STRIP_PIN, NEO_GRB + NEO_KHZ800);
8
9void pwmSetup() { // adı aynı, setup() değişmez / same name, setup() stays as is
10 strip.begin();
11 strip.setBrightness(80); // akımı sınırla / limit the current
12}
13
14void setColor(int r, int g, int b) {
15 strip.fill(strip.gamma32(strip.Color(r, g, b))); // kütüphanenin gama tablosu / the library's gamma table
16 strip.show();
17}
Konversi yang sama di MicroPython (ESP32 dan Pico)
Jika kamu memprogram ESP32 atau Raspberry Pi Pico dengan MicroPython, jalur dari HEX ke PWM sama saja; bedanya hanya duty cycle ditulis dalam 16 bit (0–65535). Kamu bisa menambahkan fungsi di bawah ke web server atau kode MQTT-mu sendiri. Di Pico, misalnya, kamu bisa memakai GP11, GP12, dan GP13 untuk merah, hijau, dan biru.
1# MicroPython (ESP32 ya da Pico): HEX rengi üç PWM kanalına yazar
2# MicroPython (ESP32 or Pico): writes a HEX colour to three PWM channels
3from machine import Pin, PWM
4
5PINS = (25, 26, 27) # Pico'da örneğin (11, 12, 13) / on a Pico e.g. (11, 12, 13)
6GAMMA = 2.2
7leds = []
8for p in PINS:
9 pwm = PWM(Pin(p))
10 pwm.freq(5000)
11 leds.append(pwm)
12
13def set_hex(color):
14 color = color.lstrip("#")
15 rgb = (int(color[0:2], 16), int(color[2:4], 16), int(color[4:6], 16))
16 for led, v in zip(leds, rgb):
17 led.duty_u16(int(((v / 255) ** GAMMA) * 65535)) # 16 bit görev oranı / 16-bit duty
18
19set_hex("#ff8800") # turuncu / orangeIde proyek LED RGB dengan ESP32
- Lampu suasana: masukkan LED RGB ke dalam toples kaca buram dan ubah ke oranye hangat dari ponselmu di malam hari.
- Lampu notifikasi: buat LED menjadi biru ketika ada email atau pesan masuk; untuk pesan, lihat panduan bot Telegram ESP32.
- Pencahayaan ambient kamar: terapkan antarmuka yang sama pada strip RGB 12 V biasa dengan MOSFET; detailnya ada di panduan kontrol strip LED RGB.
- Semua melihat warna yang sama: pakai WebSocket alih-alih HTTP agar warna yang dipilih di satu ponsel langsung muncul di semua halaman lain yang terbuka; panduan WebSocket ESP32 menunjukkan caranya.
- Alarm matahari terbit: ambil waktu lewat NTP dan, setengah jam sebelum kamu bangun, pelan-pelan beralih dari merah tua ke putih; untuk jamnya, lihat panduan jam NTP ESP32.
- Integrasi rumah pintar: kendalikan warna dari Home Assistant lewat MQTT; langkah-langkahnya ada di panduan ESP32 dengan MQTT dan Home Assistant.
Kesalahan umum dan solusinya
| Gejala | Penyebab | Solusi |
|---|---|---|
| Kamu memilih merah, yang menyala hijau | Kaki-kakinya ada di pin yang berbeda | Ubah urutan array PINS agar sesuai dengan LED-mu |
| Hitam membuat LED terang penuh dan putih mematikannya | LED-nya anoda bersama | Atur COMMON_ANODE = true dan sambungkan kaki bersama ke 3V3 |
| Biru dan hijau sangat redup, putih tampak merah muda | Resistor terlalu besar untuk 3,3 V | Pakai 100 Ω atau 68 Ω untuk hijau dan biru |
| 'ledcSetup' was not declared in this scope | Kode lama di core ESP32 3.x | Pakai pemeriksaan #if ESP_ARDUINO_VERSION_MAJOR dari panduan ini |
| Halaman tidak mau terbuka | Ponsel ada di jaringan lain, jaringan tamu, atau data seluler | Sambungkan ponsel ke jaringan 2,4 GHz yang sama dengan ESP32 dan baca lagi IP-nya di Serial Monitor |
| Perubahan warna tersendat | Mode hemat daya Wi-Fi atau terlalu banyak permintaan | WiFi.setSleep(false) dan flag busy; jika sinyal lemah, dekatkan ESP32 ke router |
Memilih warna dari ponsel adalah proyek Wi-Fi pertama yang sama edukatifnya dengan menariknya: satu rangkaian memperlihatkan web server, permintaan HTTP, PWM, dan koreksi gamma. Di aplikasi BlueGrays, proyek Kontrol LED RGB ESP32 dan Lampu Pencampur Warna ESP32 dengan tiga potensiometer memandumu lewat rangkaian ini langkah demi langkah dengan diagram rangkaian dan kode siap pakai, supaya kamu bisa membawa idenya ke lampu buatanmu sendiri.
Pertanyaan umum
Bagaimana cara mengendalikan LED RGB dengan ESP32?
Sambungkan kaki merah, hijau, dan biru LED RGB ke tiga pin GPIO lewat resistor, dan kaki bersama ke GND (ke 3V3 untuk anoda bersama). Pasang kanal PWM ke setiap pin dengan LEDC dan atur kecerahan tiap warna dengan mengubah duty cycle. Dengan mencampur ketiganya, kamu mendapat warna apa pun.
Mengapa ledcSetup tidak berfungsi di core ESP32 3.0?
Fungsi LEDC berubah di versi 3.0 core ESP32 Arduino: ledcSetup dan ledcAttachPin dihapus, ledcAttach(pin, frekuensi, resolusi) menggantikannya, dan ledcWrite kini menerima pin, bukan kanal. Dengan pemeriksaan #if ESP_ARDUINO_VERSION_MAJOR >= 3, kode yang sama bisa dikompilasi di kedua versi.
Bagaimana cara tahu LED RGB-ku anoda bersama atau katoda bersama?
Sambungkan kaki terpanjang ke GND dan kaki lain ke 3,3 V lewat resistor; jika menyala, itu katoda bersama. Jika tidak, balik sambungannya; jika sekarang menyala, itu anoda bersama. Pada anoda bersama logika kode terbalik dan warna menyala ketika pinnya LOW.
Resistor apa yang dipakai untuk LED RGB di ESP32?
Pada 3,3 V, 150 Ω untuk merah dan 100 Ω untuk hijau dan biru adalah titik awal yang baik. Dengan 220 Ω di ketiga kaki LED tetap bekerja, tetapi hijau dan biru tetap redup. Jangan tarik lebih dari 20 mA terus-menerus dari satu pin.
Bagaimana cara mengonversi warna HEX ke RGB?
Dalam format #RRGGBB, setiap pasang digit adalah nilai heksadesimal satu warna. Pada #FF8800, FF = 255 merah, 88 = 136 hijau, dan 00 = 0 biru. Di kode Arduino, kamu bisa mengubah teks menjadi angka dengan strtol(hex, NULL, 16) dan memisahkan kanal dengan menggeser 16 dan 8 bit ke kanan.
Bisakah strip WS2812B dikendalikan dari ponsel dengan ESP32?
Bisa. Halaman web dan kode server tetap sama; hanya fungsi yang menulis warna yang berganti ke panggilan fill dan show dari pustaka Adafruit NeoPixel. Beri daya strip dari catu 5 V terpisah dan satukan ground-nya.
Proyek untuk dibuat setelah membaca ini
Lihat semua proyek
LED Berkedip dengan ESP32
Mengajarkan penggunaan output GPIO dasar dengan ESP32. Kita membuat efek berkedip dengan menyalakan dan mematikan LED dari pin digital. Versi ESP32 dari proyek blink klasik di Arduino UNO; perintah blink dasar di lingkungan Arduino sama, tetapi susunan pin ESP32 dan level GPIO 3,3 V-nya berbeda dengan Arduino UNO.

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.

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 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.

Web Server Asinkron ESP32 (dengan Tampilan IP di LCD)
Di proyek ini, kita mengubah ESP32 menjadi web server asinkron yang bisa kamu kendalikan dari ponsel atau komputer di jaringan Wi-Fi yang sama. Berkat library ESPAsyncWebServer, server bisa memproses beberapa permintaan bersamaan (berbeda dengan WebServer.h klasik, yang memblokir pada satu permintaan). Kamu bisa membuka alamat IP ESP32 di browser dan mengklik tombol ON/OFF (rute /on dan /off) untuk menyalakan dan mematikan LED yang tersambung ke GPIO 5.

Penghitung WebSocket ESP32 (2 Tombol + LCD + Web Real-Time)
Di proyek ini, dua tombol yang tersambung ke ESP32 (GPIO 5 menghitung naik, GPIO 4 menghitung turun) mengubah sebuah penghitung. Nilainya langsung diperbarui di LCD I2C 16x2 sekaligus, lewat dukungan WebSocket ESPAsyncWebServer, di setiap browser yang tersambung tanpa memuat ulang halaman. Alih-alih polling HTTP, dipakai satu koneksi yang tetap terbuka, dan ESP32 mengirim nilai baru ke semua orang dengan ws.textAll().

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.
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

