Ratgeber · 8 Min. Lesezeit

ESP32 RGB LED Webserver: Farbe per Handy-Farbwähler einstellen

ESP32 RGB LED Webserver mit Farbwähler im Handy: gemeinsame Anode/Kathode anschließen, HEX in RGB umrechnen, LEDC-PWM, Gammakorrektur und WS2812B-Streifen.

Mit einem ESP32 RGB LED Webserver änderst du die Farbe einer LED, ohne eine App zu installieren: Der ESP32 liefert eine kleine Webseite aus, du wählst im Farbwähler, der sich im Browser deines Handys öffnet, einen Farbton, und die LED wechselt sofort dorthin. Im Hintergrund passieren drei Dinge: Der Browser wandelt deine Wahl in einen HEX-Code wie #FF8800 um und schickt ihn per WLAN, der ESP32 zerlegt diesen Code in drei Zahlen für Rot, Grün und Blau, und jede Zahl wird zu einem PWM-Signal, das die LEDC-Einheit erzeugt.

In dieser Anleitung lernst du, wie du eine RGB-LED mit gemeinsamer Kathode oder gemeinsamer Anode auf dem Steckbrett an den ESP32 anschließt, welche Widerstände für 3,3 V passen, wie LEDC-Code aussieht, der auf dem ESP32-Arduino-Core 2.x und 3.x läuft, wie du HEX in RGB umrechnest und wie die Gammakorrektur dafür sorgt, dass die Farben so aussehen, wie dein Auge es erwartet. Am Ende hängst du dieselbe Handy-Oberfläche an einen WS2812B-LED-Streifen, ohne eine einzige HTML-Zeile zu ändern.

RGB-LED mit vier Beinen
Eine RGB-LED: In einem Gehäuse stecken drei LEDs, Rot, Grün und Blau; das längste Bein ist der gemeinsame Anschluss.

Wie funktioniert es? Vom Farbwähler zur LED

  1. Ist dein Handy im selben WLAN wie der ESP32, öffnest du im Browser die IP-Adresse des ESP32, und er schickt eine kleine HTML-Seite mit Farbwähler zurück.
  2. Das Element <input type="color"> der Seite öffnet den Farbwähler des Handys und liefert die Auswahl im Format #ff8800.
  3. Ein paar Zeilen JavaScript schicken diesen Wert an /set?hex=ff8800; während du den Finger bewegst, gehen neue Farben nacheinander hinaus.
  4. Der ESP32 zerlegt die sechs Stellen in die drei Zahlen 255, 136 und 0 und wendet auf jede die Gammakorrektur an.
  5. LEDC erzeugt an drei Pins PWM mit 5 kHz; das Tastverhältnis (Duty Cycle) bestimmt die Helligkeit jeder Farbe, und dein Auge mischt die drei Lichter zu einem Farbton.

Bauteile

  • ESP32-DevKit-Entwicklungsboard (30 oder 38 Pins)
  • Eine RGB-LED (5 mm, gemeinsame Kathode oder gemeinsame Anode)
  • Ein 150-Ω-Widerstand für Rot und 100-Ω-Widerstände für Grün und Blau (zur Not gehen auch drei mit 220 Ω)
  • Steckbrett und ein paar Jumperkabel
  • Ein USB-Kabel mit Datenleitungen
  • Optional: WS2812B-LED-Streifen, 5-V-Netzteil, 330-Ω-Widerstand und 1000-µF-Kondensator

Gemeinsame Kathode und gemeinsame Anode: Anschlusstabelle

Bei RGB-LEDs mit vier Beinen ist das längste Bein der gemeinsame Anschluss. Bei einer LED mit gemeinsamer Kathode (CC) kommt es an GND, und du schaltest eine Farbe ein, indem du ihren Pin auf HIGH setzt. Bei gemeinsamer Anode (CA) kommt der gemeinsame Anschluss an die Versorgungsspannung, und die Farbe leuchtet, wenn ihr Pin LOW ist. Weißt du nicht, welche du hast, verbinde das längste Bein mit GND und ein anderes Bein über einen 150-Ω-Widerstand mit 3V3: Leuchtet sie, hat sie eine gemeinsame Kathode. Wenn nicht, dreh die Verbindung um; leuchtet sie jetzt, ist es eine gemeinsame Anode. Bei den meisten Modellen ist die Reihenfolge, von der abgeflachten Seite aus, Rot, gemeinsam, Grün, Blau.

BeinGemeinsame Kathode (CC)Gemeinsame Anode (CA)Widerstand
Rot (R)GPIO 25GPIO 25150 Ω
Gemeinsames Bein (längstes)GND3V3Keiner
Grün (G)GPIO 26GPIO 26100 Ω
Blau (B)GPIO 27GPIO 27100 Ω
Einstellung im CodeCOMMON_ANODE = falseCOMMON_ANODE = trueKeiner
Tastverhältnis für volle Helligkeit1023 (Maximum)0 (der Code dreht es selbst um)Keiner
Verbinde das gemeinsame Bein einer LED mit gemeinsamer Anode mit dem 3V3-Pin des ESP32, nicht mit 5V. An 5 V bleiben auch bei HIGH am Pin rund 1,7 V über der LED: Rot glimmt weiter, und Strom fließt über die Schutzdioden zurück in den 3,3-V-Pin, der dabei mit der Zeit Schaden nimmt.

Die Berechnung des Widerstands ist angewandtes ohmsches Gesetz: R = (3,3 V − LED-Spannung) / Strom. Eine rote LED braucht etwa 2,0 V; mit 150 Ω fließen (3,3 − 2,0) / 150 ≈ 8,7 mA. Grüne und blaue LEDs arbeiten bei etwa 2,8 bis 3,1 V, bei 3,3 V bleibt also kaum Spielraum; mit 100 Ω fließen 3 bis 5 mA und die Farben wirken hell genug. Mit 220 Ω an allen drei Beinen funktioniert die Schaltung zwar, aber Blau und Grün sind deutlich dunkler und Weiß wird rosa. Mit den Werten deiner eigenen LED rechnest du im LED-Vorwiderstandsrechner. Belaste einen ESP32-Pin dauerhaft nicht mit mehr als 20 mA.

ESP32 LEDC-PWM: drei Kanäle, 5 kHz, 10 Bit

Das Gegenstück zu analogWrite vom Arduino Uno ist beim ESP32 die LEDC-Einheit. Der klassische ESP32 hat 16 unabhängige PWM-Kanäle, für jeden wählst du Frequenz und Auflösung. Dieses Projekt nutzt 5 kHz und 10 Bit: 10 Bit heißt, das Tastverhältnis reicht von 0 bis 1023, was vor allem in dunklen Tönen viel weichere Übergänge als 8 Bit ergibt. 5 kHz ist schnell genug, dass weder dein Auge noch die meisten Handykameras ein Flimmern sehen. Aufpassen musst du nur an einer Stelle: In Version 3.0 des ESP32-Arduino-Cores haben sich die LEDC-Funktionen geändert, deshalb lässt sich viel älterer Code aus dem Netz auf einer frischen Installation nicht mehr kompilieren. Die Sketche unten prüfen die Konstante ESP_ARDUINO_VERSION_MAJOR und laufen auf beiden Versionen. Die Grundlagen findest du im Artikel Was ist PWM.

Core-VersionEinrichtenWert schreiben
3.x (aktuell)ledcAttach(pin, 5000, 10)ledcWrite(pin, duty)
2.x (älter)ledcSetup(kanal, 5000, 10) und ledcAttachPin(pin, kanal)ledcWrite(kanal, duty)

Zuerst die Verdrahtung testen

Prüfst du die Verkabelung, bevor du zum Webserver übergehst, sparst du Zeit. Lade den Sketch unten hoch: Die LED sollte je eine Sekunde rot, grün, blau und weiß leuchten und dann eine Sekunde aus sein. Kommen die Farben in anderer Reihenfolge (etwa Grün statt Rot), ändere die Reihenfolge im Array PINS. Leuchtet die LED ständig und geht genau bei Weiß aus, hast du eine LED mit gemeinsamer Anode; setze COMMON_ANODE auf 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}

HEX-Farbcode in RGB umrechnen

Im Web werden Farben als #RRGGBB geschrieben: Die ersten zwei Stellen sind der Rotwert, die nächsten zwei Grün und die letzten zwei Blau, jeweils von 0 bis 255 und im Sechzehnersystem (hexadezimal). Bei #FF8800 ist FF = 255, 88 = 8 × 16 + 8 = 136 und 00 = 0, also volles Rot, etwas Grün und kein Blau: Orange. Im Code geht das in zwei Schritten: strtol(hex, NULL, 16) macht aus dem sechsstelligen Text eine Zahl (0xFF8800), dann trennen Bitverschiebung und Maske die drei Bytes: (rgb >> 16) & 0xFF für Rot, (rgb >> 8) & 0xFF für Grün und rgb & 0xFF für Blau.

HEXRotGrünBlauFarbe
#FF000025500Rot
#00FF0002550Grün
#0000FF00255Blau
#FF88002551360Orange
#8000801280128Lila
#FFFFFF255255255Weiß
#000000000Aus

Gammakorrektur: Warum wirken die Farben blass?

Das Auge nimmt Helligkeit nicht linear wahr: Im Dunkeln bemerkt es kleine Änderungen sehr gut, im Hellen kann es selbst große Stufen kaum unterscheiden. Deshalb wirkt die LED schon bei 50 % Tastverhältnis fast voll hell, und die Pastelltöne, die du auf dem Bildschirm wählst, werden auf der LED zu blassen, fast weißen Farben. Die Lösung ist eine Gammakorrektur für jeden Kanal: Ausgang = Maximum × (Eingang / 255)^2,2. Bildschirme nutzen dieselbe Kurve, daher passen die Farbe auf dem Handy und die Farbe der LED nach der Korrektur viel besser zusammen. Die Tabelle zeigt, wie stark die Kurve die dunklen Töne zusammendrückt und warum 10 Bit helfen:

Gewählter Wert (0–255)8-Bit-PWM (0–255)10-Bit-PWM (0–1023)
1612
32311
641249
12856225
192137548
2552551023

Hauptsketch: Webserver mit Farbwähler fürs Handy

Der Hauptsketch nutzt die Bibliothek WebServer, die mit dem ESP32-Core kommt; du musst also nichts zusätzlich installieren. Trag Netzwerkname und Passwort ein, lade den Sketch hoch und öffne den Seriellen Monitor mit 115200 Baud. Nach ein paar Sekunden erscheint eine Adresse wie http://192.168.1.45; öffne sie im Browser eines Handys im selben WLAN. Der ESP32 verbindet sich nur mit 2,4-GHz-Netzen, und das Handy muss in genau diesem Netz sein.

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}

So funktioniert der Code

TeilAufgabe
PAGEHTML, CSS und JavaScript, die ans Handy gehen; dank R"rawliteral(...)" ohne Escapen der Anführungszeichen geschrieben
input type="color"Öffnet den eingebauten Farbwähler des Handys und liefert die Wahl als #rrggbb
send() und busySchickt immer nur eine Anfrage; von den Farben, die sich beim Wischen ansammeln, geht nur die neueste hinaus
/set?hex=ff8800Die Anfrage an den ESP32; handleSet() beantwortet sie
isHex6()Prüft, ob der Text genau sechs Hex-Stellen hat, und lehnt fehlerhafte Anfragen ab
strtol und BitverschiebungMachen aus dem Text eine Zahl und trennen die Bytes für Rot, Grün und Blau
gammaCorrect()Bildet den Wert 0–255 entlang der Gammakurve 2,2 auf 0–1023 ab
pwmWrite()Kehrt den Wert bei gemeinsamer Anode um und ruft ledcWrite passend zur Core-Version auf
%HEX%Zeigt beim Öffnen der Seite die letzte Farbe, so sieht auch ein zweites Handy die aktuelle Farbe
WiFi.setSleep(false)Schaltet den WLAN-Stromsparmodus ab, damit Farbwechsel ohne Verzögerung ankommen
Während du den Finger über den Farbwähler ziehst, feuert der Browser Dutzende input-Ereignisse pro Sekunde. Alle auf einmal zu schicken verstopft den kleinen Webserver des ESP32, und die Farben hinken hinterher. Das Flag busy im Code sendet keine neue Anfrage, bevor die vorherige fertig ist, und schickt von den angesammelten Werten nur den neuesten; so folgt die LED deinem Finger ohne Verzögerung. Legst du die Seite auf den Startbildschirm deines Handys, öffnet sie sich wie eine App mit einem Tipp.

Dieselbe Oberfläche mit einem WS2812B-Streifen

Willst du statt einer einzelnen RGB-LED einen Streifen mit Dutzenden LEDs ansteuern, fasst du weder HTML noch Webserver an; du tauschst nur die Funktionen, die die LED treiben. Jede WS2812B-LED hat ihren eigenen Treiberchip, daher genügt ein einziger Datenpin. Schließ den DIN-Anschluss des Streifens über einen 330-Ω-Widerstand an GPIO 13 an, versorge den Streifen aus einem eigenen 5-V-Netzteil und verbinde dessen GND mit dem GND des ESP32. Jede LED zieht bei vollem Weiß etwa 60 mA; ein Streifen mit 30 LEDs kommt auf bis zu 1,8 A, deshalb begrenzt der Code die Helligkeit auf 80/255. Ein 1000-µF-Kondensator an den Versorgungsanschlüssen schützt die LEDs vor dem Einschaltstrom. Bei einem Streifen an 5 V reicht das 3,3-V-Datensignal des ESP32 meistens aus; siehst du Flackern oder zufällige Farben, setz einen Pegelwandler wie den 74AHCT125 dazwischen. Details zu Streifen stehen im Artikel WS2812B NeoPixel. Setze das Fragment unten an die Stelle der vier LED-Funktionen im Hauptsketch und installiere die Bibliothek Adafruit NeoPixel über den Bibliotheksverwalter:

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}
Adressierbare RGB-LED WS2812B
WS2812B: Jede LED trägt ihren eigenen Treiberchip; über eine einzige Datenleitung lässt sich die Farbe von Hunderten LEDs einzeln einstellen.

Dieselbe Umrechnung in MicroPython (ESP32 und Pico)

Programmierst du deinen ESP32 oder Raspberry Pi Pico mit MicroPython, ist der Weg von HEX zu PWM derselbe; nur wird das Tastverhältnis mit 16 Bit (0–65535) geschrieben. Die Funktion unten kannst du in deinen eigenen Webserver oder deinen MQTT-Code übernehmen. Am Pico eignen sich zum Beispiel GP11, GP12 und GP13 für Rot, Grün und Blau.

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

Projektideen mit ESP32 und RGB-LED

  • Stimmungslicht: Steck die RGB-LED in ein Glas aus Milchglas und stell sie abends per Handy auf warmes Orange.
  • Benachrichtigungslicht: Lass die LED blau leuchten, wenn eine E-Mail oder Nachricht eintrifft; für Nachrichten siehe den Artikel ESP32 Telegram-Bot.
  • Raumbeleuchtung: Übertrag dieselbe Oberfläche mit MOSFETs auf einen gewöhnlichen 12-V-RGB-Streifen; Details im Artikel RGB-LED-Streifen steuern.
  • Alle sehen dieselbe Farbe: Nutze WebSocket statt HTTP, damit eine auf einem Handy gewählte Farbe sofort auf allen anderen offenen Seiten erscheint; wie das geht, zeigt der Artikel ESP32 WebSocket.
  • Lichtwecker: Hol dir die Uhrzeit per NTP und blende eine halbe Stunde vor dem Aufstehen langsam von Dunkelrot nach Weiß auf; zur Uhr siehe den Artikel ESP32 NTP-Uhr.
  • Smart-Home-Anbindung: Steuere die Farbe aus Home Assistant per MQTT; die Schritte stehen im Artikel ESP32, MQTT und Home Assistant.

Häufige Fehler und Lösungen

SymptomUrsacheLösung
Du wählst Rot und Grün leuchtetDie Beine hängen an anderen PinsReihenfolge im Array PINS an deine LED anpassen
Bei Schwarz leuchtet die LED voll, bei Weiß geht sie ausDie LED hat eine gemeinsame AnodeCOMMON_ANODE = true setzen und das gemeinsame Bein an 3V3 anschließen
Blau und Grün sehr dunkel, Weiß wirkt rosaWiderstand für 3,3 V zu großFür Grün und Blau 100 Ω oder 68 Ω verwenden
'ledcSetup' was not declared in this scopeAlter Code auf dem ESP32-Core 3.xDie #if-ESP_ARDUINO_VERSION_MAJOR-Abfrage aus dieser Anleitung verwenden
Die Seite öffnet sich nichtHandy in einem anderen Netz, im Gästenetz oder in mobilen DatenHandy ins selbe 2,4-GHz-Netz wie den ESP32 bringen und die IP im Seriellen Monitor neu ablesen
Farbwechsel ruckeltWLAN-Stromsparmodus oder zu viele AnfragenWiFi.setSleep(false) und das busy-Flag; bei schwachem Signal den ESP32 näher an den Router stellen

Die Farbe vom Handy aus zu wählen ist ein erstes WLAN-Projekt, das genauso lehrreich wie hübsch anzusehen ist: In einer einzigen Schaltung siehst du Webserver, HTTP-Anfragen, PWM und Gammakorrektur. In der BlueGrays-App führen dich die Projekte ESP32 RGB-LED-Steuerung und ESP32 Farbmischer-Lampe mit drei Potentiometern Schritt für Schritt mit Schaltplan und fertigem Code durch diese Schaltung, damit du die Idee danach auf deine eigene Lampe übertragen kannst.

Häufige Fragen

Wie steuere ich eine RGB-LED mit dem ESP32?

Schließ die Beine für Rot, Grün und Blau über Widerstände an drei GPIO-Pins an und das gemeinsame Bein an GND (bei gemeinsamer Anode an 3V3). Ordne jedem Pin mit LEDC einen PWM-Kanal zu und stelle die Helligkeit jeder Farbe über das Tastverhältnis ein. Die Mischung der drei ergibt jeden gewünschten Farbton.

Warum funktioniert ledcSetup im ESP32-Core 3.0 nicht?

In Version 3.0 des ESP32-Arduino-Cores haben sich die LEDC-Funktionen geändert: ledcSetup und ledcAttachPin wurden entfernt, an ihre Stelle trat ledcAttach(pin, frequenz, auflösung), und ledcWrite erwartet jetzt den Pin statt des Kanals. Mit einer Abfrage #if ESP_ARDUINO_VERSION_MAJOR >= 3 kompiliert derselbe Code auf beiden Versionen.

Hat meine RGB-LED eine gemeinsame Anode oder Kathode?

Verbinde das längste Bein mit GND und ein anderes Bein über einen Widerstand mit 3,3 V; leuchtet sie, hat sie eine gemeinsame Kathode. Wenn nicht, dreh die Verbindung um; leuchtet sie jetzt, ist es eine gemeinsame Anode. Bei gemeinsamer Anode ist die Logik im Code umgekehrt, eine Farbe leuchtet bei LOW am Pin.

Welchen Vorwiderstand brauche ich für eine RGB-LED am ESP32?

Bei 3,3 V sind 150 Ω für Rot und 100 Ω für Grün und Blau ein guter Start. Mit 220 Ω an allen drei Beinen funktioniert die LED, aber Grün und Blau bleiben dunkel. Belaste einen Pin dauerhaft mit höchstens 20 mA.

Wie rechne ich eine HEX-Farbe in RGB um?

Im Format #RRGGBB ist jedes Ziffernpaar der hexadezimale Wert einer Farbe. Bei #FF8800 sind FF = 255 Rot, 88 = 136 Grün und 00 = 0 Blau. Im Arduino-Code machst du mit strtol(hex, NULL, 16) aus dem Text eine Zahl und trennst die Kanäle durch Verschieben um 16 und 8 Bit nach rechts.

Kann ich einen WS2812B-Streifen mit dem ESP32 vom Handy aus steuern?

Ja. Webseite und Servercode bleiben gleich; nur die Funktion, die die Farbe schreibt, nutzt stattdessen fill und show aus der Bibliothek Adafruit NeoPixel. Versorge den Streifen aus einem eigenen 5-V-Netzteil und verbinde die GND-Leitungen.

Alle Projekte ansehen
LED Blinken mit ESP32
ES-1Anfänger

LED Blinken mit ESP32

Lehrt die grundlegende Verwendung von GPIO-Ausgängen mit ESP32. Wir erreichen einen Blinkeffekt, indem wir eine LED über einen digitalen Pin ein- und ausschalten. ESP32-Version des klassischen Blink-Projekts auf Arduino UNO; die grundlegenden Blink-Befehle in der Arduino-Umgebung bleiben gleich, aber die Pinbelegung und die GPIO-Pegel von 3,3 V des ESP32 unterscheiden sich von denen des Arduino UNO.

4.7(37)
108
ESP32 RGB-LED-Steuerung
ES-9Anfänger

ESP32 RGB-LED-Steuerung

Unbegrenzte Farberzeugung mit einer einzigen RGB-LED anstelle von 3 separaten LEDs. Wie in Arduino machen wir Regenbogenübergänge, indem wir R/G/B-Werte mit analogWrite() setzen. Die Farbtheorie (z. B. Rot+Grün=Gelb) wird praktisch umgesetzt.

4.6(29)
52
ESP32-Farbmischerlampe (3 Potentiometer + RGB-LED + OLED)
ES-36Fortgeschritten
Premium

ESP32-Farbmischerlampe (3 Potentiometer + RGB-LED + OLED)

Eine smarte Farbmischer-Lampe: Dreh an 3 Potentiometern am ESP32 und misch dir jede Farbe! Während du die Potis für Rot, Grün und Blau drehst, wechselt die RGB-LED mit gemeinsamer Kathode sofort die Farbe. Das SSD1306-OLED zeigt live für jede Farbe den Wert von 0-255, Füllbalken und den HEX-Webfarbcode (etwa #FF8040).

4.7(6)
10
ESP32 LED-Überblendung mit PWM
ES-8Anfänger

ESP32 LED-Überblendung mit PWM

Ändern Sie die Helligkeit der LED stufenlos von 0 bis max, von max bis 0. Wir steuern PWM mit analogWrite() wie in Arduino - die gleiche Syntax mit ESP32 Arduino Core 3.0+ funktioniert reibungslos. Pin-Definition + pinMode + analogWrite ist genug.

4.8(36)
55
Steuerung des ESP32 WS2812B NeoPixel-Streifens
ES-24Mittel
Premium

Steuerung des ESP32 WS2812B NeoPixel-Streifens

WS2812B-LEDs (NeoPixel) sind adressierbare RGB-LEDs, die sich in Reihe über einen einzigen Datenpin steuern lassen. Wir steuern einen WS2812B-Streifen mit 8 LEDs über die Bibliothek Adafruit_NeoPixel und erzeugen eine flüssige Regenbogenanimation. Die 3,3-V-Logik des ESP32 klappt bei den meisten WS2812B; bei Instabilität hilft ein 470Ω-Serienwiderstand plus 1000µF-Kondensator. Die Animation verschiebt den Farbton im HSV-Farbraum.

4.9(19)
30
ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)
ES-27Fortgeschritten

ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)

Wir machen den ESP32 zu einem asynchronen Webserver, den du per Handy oder Computer im selben WLAN steuerst. Dank der Bibliothek ESPAsyncWebServer verarbeitet der Server mehrere Anfragen gleichzeitig (er blockiert nicht wie das klassische WebServer.h bei einer einzigen Anfrage). Öffne im Browser die IP-Adresse des ESP32 und schalte mit den Tasten ON/OFF (Adressen /on und /off) die LED an GPIO 5 ein und aus.

4.8(16)
26
ESP32-WebSocket-Zähler (2 Tasten + LCD + Web-Echtzeit)
ES-28Fortgeschritten
Premium

ESP32-WebSocket-Zähler (2 Tasten + LCD + Web-Echtzeit)

In diesem Projekt ändern zwei am ESP32 angeschlossene Taster (GPIO 5 zählt hoch, GPIO 4 zählt herunter) einen Zähler. Der Wert wird sofort auf einem 16x2-I2C-LCD und über die WebSocket-Unterstützung von ESPAsyncWebServer in allen verbundenen Browsern aktualisiert, ohne die Seite neu zu laden. Statt HTTP-Polling wird eine einzige dauerhafte Verbindung genutzt; der ESP32 sendet den neuen Wert mit ws.textAll() an alle.

4.5(14)
23
ESP32: LED-Helligkeit mit Potentiometer (Analog → PWM)
ES-13Mittel
Premium

ESP32: LED-Helligkeit mit Potentiometer (Analog → PWM)

In diesem Projekt steuern wir die Helligkeit einer LED analog über ein Potentiometer. Der ADC-Pin des ESP32 liest die vom Potentiometer kommende Spannung von 0-3,3 V aus, woraufhin dieser Wert in ein PWM-Signal (Pulsweitenmodulation) umgewandelt und an die LED gesendet wird. So leuchtet die LED beim Drehen des Potentiometers stufenweise auf und erlischt wieder. Mit Arduino Core 3.0+ kann analogWrite() direkt verwendet werden; bei ESP32-S2/S3 ist die ADC-Auflösung auf 12 Bit festgelegt.

4.5(19)
32