Panduan · 8 mnt baca

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.

LED RGB berkaki empat
LED RGB: satu kemasan berisi tiga LED, merah, hijau, dan biru; kaki terpanjang adalah kaki bersama.

Bagaimana cara kerjanya? Dari pemilih warna sampai ke LED

  1. 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.
  2. Elemen <input type="color"> di halaman membuka pemilih warna bawaan ponsel dan mengembalikan pilihan dalam format #ff8800.
  3. Beberapa baris JavaScript mengirim nilai itu ke /set?hex=ff8800; selama jarimu bergeser, warna-warna baru terkirim satu demi satu.
  4. ESP32 memecah enam digit itu menjadi tiga angka, 255, 136, dan 0, lalu menerapkan koreksi gamma pada masing-masing.
  5. 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.

KakiKatoda bersama (CC)Anoda bersama (CA)Resistor
Merah (R)GPIO 25GPIO 25150 Ω
Kaki bersama (terpanjang)GND3V3Tidak ada
Hijau (G)GPIO 26GPIO 26100 Ω
Biru (B)GPIO 27GPIO 27100 Ω
Pengaturan di kodeCOMMON_ANODE = falseCOMMON_ANODE = trueTidak ada
Duty cycle untuk warna pada kecerahan penuh1023 (maksimum)0 (kode membaliknya untukmu)Tidak ada
Sambungkan kaki bersama LED anoda bersama ke pin 3V3 ESP32, bukan ke 5V. Pada 5 V, masih tersisa sekitar 1,7 V di LED bahkan ketika pin HIGH: merah tetap menyala redup, dan arus mengalir balik lewat dioda pelindung ke pin 3,3 V, yang lama-lama merusaknya.

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

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

HEXMerahHijauBiruWarna
#FF000025500Merah
#00FF0002550Hijau
#0000FF00255Biru
#FF88002551360Oranye
#8000801280128Ungu
#FFFFFF255255255Putih
#000000000Mati

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)
1612
32311
641249
12856225
192137548
2552551023

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.

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

BagianFungsinya
PAGEHTML, 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 busyHanya mengirim satu permintaan dalam satu waktu; dari warna yang menumpuk selama kamu menggeser, hanya yang terbaru yang dikirim
/set?hex=ff8800Permintaan yang sampai ke ESP32; handleSet() menjawabnya
isHex6()Memeriksa bahwa teksnya tepat enam digit heksadesimal dan menolak permintaan yang rusak
strtol dan pergeseran bitMengubah 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
Ketika kamu menyeret jari di pemilih warna, browser memicu puluhan event input per detik. Mengirim semuanya sekaligus membuat web server kecil ESP32 kewalahan dan warnanya tertinggal. Flag busy di kode tidak mengirim permintaan baru sebelum yang sebelumnya selesai, dan dari nilai yang menumpuk hanya mengirim yang terbaru; dengan begitu LED mengikuti jarimu tanpa jeda. Tambahkan halaman ini ke layar utama ponselmu, dan halaman terbuka dengan sekali ketuk, persis seperti aplikasi.

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:

C++ (Arduino IDE)
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}
LED RGB beralamat WS2812B
WS2812B: setiap LED membawa chip pengendalinya sendiri, jadi satu jalur data mengatur warna ratusan LED satu per satu.

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.

MicroPython
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 / orange

Ide 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

GejalaPenyebabSolusi
Kamu memilih merah, yang menyala hijauKaki-kakinya ada di pin yang berbedaUbah urutan array PINS agar sesuai dengan LED-mu
Hitam membuat LED terang penuh dan putih mematikannyaLED-nya anoda bersamaAtur COMMON_ANODE = true dan sambungkan kaki bersama ke 3V3
Biru dan hijau sangat redup, putih tampak merah mudaResistor terlalu besar untuk 3,3 VPakai 100 Ω atau 68 Ω untuk hijau dan biru
'ledcSetup' was not declared in this scopeKode lama di core ESP32 3.xPakai pemeriksaan #if ESP_ARDUINO_VERSION_MAJOR dari panduan ini
Halaman tidak mau terbukaPonsel ada di jaringan lain, jaringan tamu, atau data selulerSambungkan ponsel ke jaringan 2,4 GHz yang sama dengan ESP32 dan baca lagi IP-nya di Serial Monitor
Perubahan warna tersendatMode hemat daya Wi-Fi atau terlalu banyak permintaanWiFi.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.

Lihat semua proyek
LED Berkedip dengan ESP32
ES-1Pemula

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.

4.7(37)
108
Kendali LED RGB ESP32
ES-9Pemula

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.

4.6(29)
52
Lampu Pencampur Warna ESP32 (3 Potensiometer + LED RGB + OLED)
ES-36Mahir
Premium

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.

4.7(6)
10
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 Strip NeoPixel WS2812B ESP32
ES-24Menengah
Premium

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.

4.9(19)
30
Web Server Asinkron ESP32 (dengan Tampilan IP di LCD)
ES-27Mahir

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.

4.8(16)
26
Penghitung WebSocket ESP32 (2 Tombol + LCD + Web Real-Time)
ES-28Mahir
Premium

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

4.5(14)
23
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