ESP32 LED RGB web server: scegli il colore dallo smartphone
Web server ESP32 per LED RGB con il selettore colore dello smartphone: anodo e catodo comune, da HEX a RGB, PWM LEDC, correzione gamma e striscia WS2812B.
Con un web server ESP32 per LED RGB cambi il colore di un LED senza installare nessuna app: l'ESP32 serve una piccola pagina web, scegli una tonalità nel selettore colore che si apre nel browser dello smartphone e il LED cambia all'istante. Dietro le quinte succedono tre cose: il browser trasforma la scelta in un codice HEX come #FF8800 e lo invia via Wi-Fi, l'ESP32 divide il codice in tre numeri per rosso, verde e blu, e ogni numero diventa un segnale PWM generato dalla periferica LEDC.
In questa guida imparerai a collegare all'ESP32 un LED RGB a catodo comune o ad anodo comune sulla breadboard, a scegliere le resistenze giuste per 3,3 V, a scrivere codice LEDC che funziona sia con il core Arduino ESP32 2.x sia con il 3.x, a convertire da HEX a RGB e ad applicare la correzione gamma perché i colori appaiano come se li aspetta l'occhio. Alla fine collegherai la stessa interfaccia dello smartphone a una striscia LED WS2812B senza toccare una sola riga di HTML.

Come funziona? Dal selettore colore al LED
- Con lo smartphone sulla stessa rete Wi-Fi dell'ESP32, apri nel browser l'indirizzo IP dell'ESP32, che risponde con una piccola pagina HTML con il selettore colore.
- L'elemento <input type="color"> della pagina apre il selettore colore del telefono e restituisce la scelta nel formato #ff8800.
- Poche righe di JavaScript inviano quel valore all'indirizzo /set?hex=ff8800; mentre fai scorrere il dito, i nuovi colori partono uno dopo l'altro.
- L'ESP32 divide le sei cifre in tre numeri, 255, 136 e 0, e applica a ciascuno la correzione gamma.
- Il LEDC genera un PWM a 5 kHz su tre pin; il duty cycle stabilisce la luminosità di ogni colore e l'occhio mescola le tre luci in un'unica tonalità.
Materiale
- Scheda di sviluppo ESP32 DevKit (a 30 o 38 pin)
- Un LED RGB (5 mm, catodo comune o anodo comune)
- Una resistenza da 150 Ω per il rosso e due da 100 Ω per verde e blu (in mancanza, vanno bene anche tre da 220 Ω)
- Breadboard e qualche cavetto jumper
- Un cavo USB che trasmetta dati
- Facoltativo: striscia LED WS2812B, alimentatore da 5 V, resistenza da 330 Ω e condensatore da 1000 µF
Catodo comune e anodo comune: tabella dei collegamenti
Nei LED RGB a quattro piedini, il più lungo è quello comune. In un LED a catodo comune (CC) va a GND e accendi un colore portando a HIGH il suo pin. In un LED ad anodo comune (CA) il piedino comune va alla tensione di alimentazione e il colore si accende quando il suo pin è LOW. Se non sai quale hai, collega il piedino più lungo a GND e un altro piedino a 3V3 tramite una resistenza da 150 Ω: se si accende, è a catodo comune. Se no, inverti il collegamento; se ora si accende, è ad anodo comune. Nella maggior parte dei modelli l'ordine dei piedini, partendo dal lato piatto, è rosso, comune, verde, blu.
| Piedino | Catodo comune (CC) | Anodo comune (CA) | Resistenza |
|---|---|---|---|
| Rosso (R) | GPIO 25 | GPIO 25 | 150 Ω |
| Piedino comune (il più lungo) | GND | 3V3 | Nessuna |
| Verde (G) | GPIO 26 | GPIO 26 | 100 Ω |
| Blu (B) | GPIO 27 | GPIO 27 | 100 Ω |
| Impostazione nel codice | COMMON_ANODE = false | COMMON_ANODE = true | Nessuna |
| Duty cycle per un colore al massimo | 1023 (il massimo) | 0 (il codice lo inverte da solo) | Nessuna |
Il calcolo della resistenza è un'applicazione diretta della legge di Ohm: R = (3,3 V − tensione del LED) / corrente. Un LED rosso richiede circa 2,0 V; con 150 Ω la corrente è (3,3 − 2,0) / 150 ≈ 8,7 mA. I LED verde e blu lavorano intorno a 2,8–3,1 V, quindi a 3,3 V resta pochissimo margine; con 100 Ω passano da 3 a 5 mA e i colori risultano abbastanza luminosi. Con 220 Ω su tutti e tre i piedini il circuito funziona, ma blu e verde sono nettamente più scuri e il bianco tende al rosa. Per calcolare con i valori del tuo LED usa il calcolatore della resistenza per LED. Non chiedere a un pin dell'ESP32 più di 20 mA in modo continuo.
PWM LEDC dell'ESP32: tre canali, 5 kHz, 10 bit
Sull'ESP32 l'equivalente di analogWrite dell'Arduino Uno è la periferica LEDC. L'ESP32 classico ha 16 canali PWM indipendenti e per ciascuno scegli frequenza e risoluzione. In questo progetto usiamo 5 kHz e 10 bit: 10 bit vuol dire che il duty cycle va da 0 a 1023, con passaggi molto più morbidi rispetto agli 8 bit, soprattutto nei toni scuri. 5 kHz è abbastanza veloce perché né l'occhio né la maggior parte delle fotocamere degli smartphone vedano sfarfallio. L'unica attenzione: nella versione 3.0 del core Arduino ESP32 le funzioni LEDC sono cambiate, per questo molto codice vecchio trovato in rete non compila più su un'installazione nuova. Gli sketch qui sotto controllano la costante ESP_ARDUINO_VERSION_MAJOR e funzionano con entrambe le versioni. Per le basi, guarda la guida cos'è il PWM.
| Versione del core | Configurazione | Scrivere il valore |
|---|---|---|
| 3.x (attuale) | ledcAttach(pin, 5000, 10) | ledcWrite(pin, duty) |
| 2.x (precedente) | ledcSetup(canale, 5000, 10) e ledcAttachPin(pin, canale) | ledcWrite(canale, duty) |
Prima prova i collegamenti
Verificare i collegamenti prima di passare al web server ti fa risparmiare tempo. Carica lo sketch qui sotto: il LED deve accendersi rosso, verde, blu e bianco, un secondo ciascuno, e poi spegnersi per un secondo. Se i colori arrivano in un altro ordine (per esempio verde al posto del rosso), cambia l'ordine nell'array PINS. Se il LED resta sempre acceso e si spegne proprio sul bianco, il tuo LED è ad anodo comune; imposta COMMON_ANODE a 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}Convertire un codice colore HEX in RGB
Sul web i colori si scrivono nel formato #RRGGBB: le prime due cifre sono il valore del rosso, le due successive del verde e le ultime due del blu, ciascuno da 0 a 255 e scritto in base sedici (esadecimale). In #FF8800, FF = 255, 88 = 8 × 16 + 8 = 136 e 00 = 0: rosso al massimo, un po' di verde e niente blu, cioè arancione. Nel codice lo facciamo in due passi: strtol(hex, NULL, 16) trasforma il testo di sei cifre in un unico numero (0xFF8800), poi lo scorrimento dei bit e una maschera separano i tre byte: (rgb >> 16) & 0xFF per il rosso, (rgb >> 8) & 0xFF per il verde e rgb & 0xFF per il blu.
| HEX | Rosso | Verde | Blu | Colore |
|---|---|---|---|---|
| #FF0000 | 255 | 0 | 0 | Rosso |
| #00FF00 | 0 | 255 | 0 | Verde |
| #0000FF | 0 | 0 | 255 | Blu |
| #FF8800 | 255 | 136 | 0 | Arancione |
| #800080 | 128 | 0 | 128 | Viola |
| #FFFFFF | 255 | 255 | 255 | Bianco |
| #000000 | 0 | 0 | 0 | Spento |
Correzione gamma: perché i colori sembrano sbiaditi?
L'occhio non percepisce la luminosità in modo lineare: al buio nota benissimo le piccole variazioni, mentre con molta luce fatica a distinguere anche i salti grandi. Per questo un duty cycle del 50 % sembra già quasi alla massima luminosità, e le tinte pastello che scegli sullo schermo diventano sul LED colori sbiaditi, quasi bianchi. La soluzione è applicare a ogni canale una correzione gamma: uscita = massimo × (ingresso / 255)^2,2. Gli schermi usano la stessa curva, quindi dopo la correzione il colore sullo smartphone e quello del LED si somigliano molto di più. La tabella mostra quanto la curva comprime i toni scuri e perché i 10 bit aiutano:
| Valore scelto (0–255) | PWM a 8 bit (0–255) | PWM a 10 bit (0–1023) |
|---|---|---|
| 16 | 1 | 2 |
| 32 | 3 | 11 |
| 64 | 12 | 49 |
| 128 | 56 | 225 |
| 192 | 137 | 548 |
| 255 | 255 | 1023 |
Sketch principale: web server con selettore colore per lo smartphone
Lo sketch principale usa la libreria WebServer inclusa nel core ESP32, quindi non devi installare altro. Inserisci nome e password della rete, carica lo sketch e apri il Monitor seriale a 115200 baud. Dopo qualche secondo vedrai un indirizzo come http://192.168.1.45; aprilo nel browser di uno smartphone collegato alla stessa rete Wi-Fi. L'ESP32 si collega solo a reti a 2,4 GHz e il telefono deve trovarsi proprio su quella rete.
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}Come funziona il codice
| Parte | Cosa fa |
|---|---|
| PAGE | HTML, CSS e JavaScript inviati al telefono; grazie a R"rawliteral(...)" si scrive senza fare l'escape delle virgolette |
| input type="color" | Apre il selettore colore integrato del telefono e restituisce la scelta come #rrggbb |
| send() e busy | Invia una sola richiesta alla volta; dei colori accumulati mentre scorri, parte solo l'ultimo |
| /set?hex=ff8800 | La richiesta che arriva all'ESP32; risponde handleSet() |
| isHex6() | Controlla che il testo abbia esattamente sei cifre esadecimali e rifiuta le richieste malformate |
| strtol e scorrimento dei bit | Trasformano il testo in numero e separano i byte di rosso, verde e blu |
| gammaCorrect() | Porta il valore 0–255 su 0–1023 seguendo la curva gamma 2,2 |
| pwmWrite() | Inverte il valore con l'anodo comune e chiama ledcWrite in base alla versione del core |
| %HEX% | Mostra l'ultimo colore a ogni apertura della pagina, così anche un secondo telefono vede il colore attuale |
| WiFi.setSleep(false) | Disattiva il risparmio energetico del Wi-Fi perché i cambi di colore arrivino senza ritardo |
La stessa interfaccia con una striscia WS2812B
Se invece di un singolo LED RGB vuoi pilotare una striscia di decine di LED, non tocchi né l'HTML né il web server: sostituisci solo le funzioni che comandano il LED. Ogni LED WS2812B ha il proprio chip di controllo, quindi basta un solo pin dati. Collega l'ingresso DIN della striscia a GPIO 13 tramite una resistenza da 330 Ω, alimenta la striscia con un alimentatore separato da 5 V e unisci il suo GND a quello dell'ESP32. Ogni LED assorbe circa 60 mA sul bianco pieno; una striscia da 30 LED può arrivare a 1,8 A, per questo il codice limita la luminosità a 80/255. Un condensatore da 1000 µF sui morsetti di alimentazione protegge i LED dallo spunto di corrente all'accensione. Con la striscia a 5 V, il segnale dati a 3,3 V dell'ESP32 di solito basta; se vedi sfarfallii o colori casuali, aggiungi un traslatore di livello come il 74AHCT125. I dettagli sulle strisce sono nella guida striscia LED WS2812B NeoPixel. Metti il frammento qui sotto al posto delle quattro funzioni del LED nello sketch principale e installa la libreria Adafruit NeoPixel dal Gestore librerie:
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}
La stessa conversione in MicroPython (ESP32 e Pico)
Se programmi il tuo ESP32 o il tuo Raspberry Pi Pico in MicroPython, il percorso da HEX a PWM è lo stesso; cambia solo che il duty cycle si scrive a 16 bit (0–65535). Puoi aggiungere la funzione qui sotto al tuo web server o al tuo codice MQTT. Sul Pico puoi usare, per esempio, GP11, GP12 e GP13 per rosso, verde e blu.
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 / orangeIdee di progetto con LED RGB ed ESP32
- Lampada d'atmosfera: metti il LED RGB in un barattolo di vetro satinato e la sera passalo a un arancione caldo dallo smartphone.
- Spia di notifica: fai diventare blu il LED quando arriva un'e-mail o un messaggio; per la messaggistica guarda la guida bot Telegram con ESP32.
- Luce d'ambiente: applica la stessa interfaccia a una normale striscia RGB a 12 V con dei MOSFET; i dettagli sono nella guida controllo della striscia LED RGB.
- Tutti vedono lo stesso colore: usa WebSocket invece di HTTP, così il colore scelto su un telefono compare subito su tutte le altre pagine aperte; la guida ESP32 con WebSocket spiega come.
- Sveglia all'alba: prendi l'ora via NTP e mezz'ora prima della sveglia passa lentamente dal rosso scuro al bianco; per l'orologio guarda la guida orologio NTP con ESP32.
- Domotica: comanda il colore da Home Assistant via MQTT; i passaggi sono nella guida ESP32, MQTT e Home Assistant.
Errori comuni e soluzioni
| Sintomo | Causa | Soluzione |
|---|---|---|
| Scegli il rosso e si accende il verde | I piedini sono su altri pin | Cambia l'ordine dell'array PINS in base al tuo LED |
| Con il nero il LED è al massimo, con il bianco si spegne | Il LED è ad anodo comune | Imposta COMMON_ANODE = true e collega il piedino comune a 3V3 |
| Blu e verde molto deboli, il bianco sembra rosa | Resistenza troppo alta per 3,3 V | Usa 100 Ω o 68 Ω per verde e blu |
| 'ledcSetup' was not declared in this scope | Codice vecchio con il core ESP32 3.x | Usa il controllo #if ESP_ARDUINO_VERSION_MAJOR di questa guida |
| La pagina non si apre | Il telefono è su un'altra rete, sulla rete ospiti o sui dati mobili | Collega il telefono alla stessa rete a 2,4 GHz dell'ESP32 e rileggi l'IP nel Monitor seriale |
| Il cambio di colore va a scatti | Risparmio energetico del Wi-Fi o troppe richieste | WiFi.setSleep(false) e il flag busy; se il segnale è debole, avvicina l'ESP32 al router |
Scegliere il colore dallo smartphone è un primo progetto Wi-Fi tanto istruttivo quanto bello da vedere: in un solo circuito trovi web server, richieste HTTP, PWM e correzione gamma. Nell'app BlueGrays, i progetti Controllo LED RGB con ESP32 e Lampada miscelatrice di colori ESP32 con tre potenziometri ti guidano passo passo in questo circuito con schema dei collegamenti e codice pronto, così poi puoi portare l'idea sulla tua lampada.
Domande frequenti
Come si controlla un LED RGB con l'ESP32?
Collega i piedini rosso, verde e blu del LED a tre pin GPIO tramite resistenze e il piedino comune a GND (a 3V3 per l'anodo comune). Assegna un canale PWM a ogni pin con LEDC e regola la luminosità di ciascun colore variando il duty cycle. La miscela dei tre dà la tonalità che vuoi.
Perché ledcSetup non funziona con il core ESP32 3.0?
Nella versione 3.0 del core Arduino ESP32 le funzioni LEDC sono cambiate: ledcSetup e ledcAttachPin sono state eliminate, al loro posto c'è ledcAttach(pin, frequenza, risoluzione) e ledcWrite ora riceve il pin invece del canale. Con un controllo #if ESP_ARDUINO_VERSION_MAJOR >= 3 lo stesso codice compila con entrambe le versioni.
Come capisco se il mio LED RGB è ad anodo comune o a catodo comune?
Collega il piedino più lungo a GND e un altro piedino a 3,3 V tramite una resistenza; se si accende, è a catodo comune. Se no, inverti il collegamento; se ora si accende, è ad anodo comune. Con l'anodo comune la logica del codice è invertita e un colore si accende con il pin a LOW.
Che resistenza usare per un LED RGB con l'ESP32?
A 3,3 V, 150 Ω per il rosso e 100 Ω per verde e blu sono un buon punto di partenza. Con 220 Ω su tutti e tre i piedini il LED funziona, ma verde e blu restano deboli. Non chiedere a un pin più di 20 mA in modo continuo.
Come si converte un colore HEX in RGB?
Nel formato #RRGGBB ogni coppia di cifre è il valore esadecimale di un colore. In #FF8800, FF = 255 di rosso, 88 = 136 di verde e 00 = 0 di blu. In uno sketch Arduino strtol(hex, NULL, 16) trasforma il testo in numero e uno scorrimento a destra di 16 e 8 bit separa i canali.
Posso controllare una striscia WS2812B dallo smartphone con l'ESP32?
Sì. La pagina web e il codice del server restano uguali; cambia solo la funzione che scrive il colore, che usa fill e show della libreria Adafruit NeoPixel. Alimenta la striscia con un alimentatore separato da 5 V e unisci le masse.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
LED Lampeggiante con ESP32
Insegna l'uso di base delle uscite GPIO con l'ESP32. Otteniamo un effetto lampeggiante accendendo e spegnendo un LED dal pin digitale. Versione ESP32 del classico progetto blink su Arduino UNO; i comandi di base di blink nell'ambiente Arduino sono gli stessi, ma la disposizione dei pin e i livelli GPIO a 3,3 V dell'ESP32 sono diversi da quelli di Arduino UNO.

Controllo LED RGB ESP32
Generazione illimitata di colori con un singolo LED RGB invece di 3 LED separati. La transizione arcobaleno avviene impostando i valori R/G/B con analogWrite() come in Arduino. La teoria dei colori (come rosso+verde=giallo) viene vista in pratica.

Lampada con miscelatore di colori ESP32 (3 potenziometri + LED RGB + OLED)
Una lampada mixer di colori smart: gira 3 potenziometri sull'ESP32 e mescola il colore che vuoi! Mentre ruoti i potenziometri rosso, verde e blu, il LED RGB a catodo comune cambia colore all'istante. Il display OLED SSD1306 mostra in tempo reale il valore 0-255 di ogni colore, barre di riempimento e il codice colore web HEX (come #FF8040).

Dissolvenza LED ESP32 con PWM
Modificare la luminosità del LED in modo fluido da 0 a max, da max a 0. Controlliamo il PWM con analogWrite() come in Arduino - la stessa sintassi con ESP32 Arduino Core 3.0+ funziona senza problemi. La definizione del pin + pinMode + analogWrite è sufficiente.

Controllo della striscia LED NeoPixel WS2812B con ESP32
I LED indirizzabili WS2812B (NeoPixel) sono LED RGB intelligenti collegabili in catena e controllati da un solo pin dati. Pilotiamo una striscia WS2812B da 8 LED con la libreria Adafruit_NeoPixel e creiamo un arcobaleno fluido. La logica a 3,3 V dell'ESP32 va bene con quasi tutti i WS2812B; in caso di instabilità mostriamo la soluzione con una resistenza in serie da 470Ω e un condensatore da 1000µF. L'animazione sposta la tonalità nello spazio HSV.

Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)
In questo progetto trasformiamo l'ESP32 in un server web asincrono che potrete controllare dal vostro telefono o computer collegato alla stessa rete Wi-Fi. Grazie alla libreria ESPAsyncWebServer, il server è in grado di elaborare più richieste contemporaneamente (a differenza del classico WebServer.h, che si blocca su una singola richiesta).

Contatore WebSocket ESP32 (2 pulsanti + LCD + Web in tempo reale)
In questo progetto due pulsanti collegati all'ESP32 (GPIO 5 incrementa, GPIO 4 decrementa) modificano un contatore. Il valore si aggiorna all'istante su un display LCD I2C 16x2 e, grazie al supporto WebSocket di ESPAsyncWebServer, in tutti i browser collegati senza ricaricare la pagina. Al posto del polling HTTP si usa un'unica connessione persistente e l'ESP32 invia il nuovo valore a tutti con ws.textAll().

Luminosità di un LED con Potenziometro su ESP32 (Analogico → PWM)
In questo progetto controlliamo in modo analogico la luminosità di un LED tramite un potenziometro. Il pin ADC dell'ESP32 legge la tensione tra 0 e 3,3 V dal potenziometro; il valore viene convertito in un segnale PWM (Pulse Width Modulation) e inviato al LED. Ruotando il potenziometro, il LED si accende e si spegne gradualmente. Con Arduino Core 3.0+ si usa direttamente analogWrite(); su ESP32-S2/S3 la risoluzione dell'ADC è fissata a 12 bit.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

