Guide · 9 min di lettura

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.

LED RGB a quattro piedini
Un LED RGB: in un solo contenitore ci sono tre LED, rosso, verde e blu; il piedino più lungo è quello comune.

Come funziona? Dal selettore colore al LED

  1. 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.
  2. L'elemento <input type="color"> della pagina apre il selettore colore del telefono e restituisce la scelta nel formato #ff8800.
  3. 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.
  4. L'ESP32 divide le sei cifre in tre numeri, 255, 136 e 0, e applica a ciascuno la correzione gamma.
  5. 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.

PiedinoCatodo comune (CC)Anodo comune (CA)Resistenza
Rosso (R)GPIO 25GPIO 25150 Ω
Piedino comune (il più lungo)GND3V3Nessuna
Verde (G)GPIO 26GPIO 26100 Ω
Blu (B)GPIO 27GPIO 27100 Ω
Impostazione nel codiceCOMMON_ANODE = falseCOMMON_ANODE = trueNessuna
Duty cycle per un colore al massimo1023 (il massimo)0 (il codice lo inverte da solo)Nessuna
Collega il piedino comune di un LED ad anodo comune al pin 3V3 dell'ESP32, non al 5V. A 5 V, anche con il pin a HIGH restano circa 1,7 V sul LED: il rosso resta debolmente acceso e la corrente torna attraverso i diodi di protezione verso il pin a 3,3 V, che con il tempo si danneggia.

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

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}

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.

HEXRossoVerdeBluColore
#FF000025500Rosso
#00FF0002550Verde
#0000FF00255Blu
#FF88002551360Arancione
#8000801280128Viola
#FFFFFF255255255Bianco
#000000000Spento

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

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.

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}

Come funziona il codice

ParteCosa fa
PAGEHTML, 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 busyInvia una sola richiesta alla volta; dei colori accumulati mentre scorri, parte solo l'ultimo
/set?hex=ff8800La 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 bitTrasformano 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
Mentre trascini il dito sul selettore, il browser genera decine di eventi input al secondo. Inviarli tutti insieme intasa il piccolo web server dell'ESP32 e i colori arrivano in ritardo. Il flag busy del codice non invia una nuova richiesta finché la precedente non è terminata e, dei valori accumulati, invia solo l'ultimo; così il LED segue il dito senza ritardi. Se aggiungi la pagina alla schermata Home del telefono, si apre con un tocco, come un'app.

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:

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 indirizzabile WS2812B
WS2812B: ogni LED ha il proprio chip di controllo; con una sola linea dati si regola il colore di centinaia di LED uno per uno.

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.

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

Idee 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

SintomoCausaSoluzione
Scegli il rosso e si accende il verdeI piedini sono su altri pinCambia l'ordine dell'array PINS in base al tuo LED
Con il nero il LED è al massimo, con il bianco si spegneIl LED è ad anodo comuneImposta COMMON_ANODE = true e collega il piedino comune a 3V3
Blu e verde molto deboli, il bianco sembra rosaResistenza troppo alta per 3,3 VUsa 100 Ω o 68 Ω per verde e blu
'ledcSetup' was not declared in this scopeCodice vecchio con il core ESP32 3.xUsa il controllo #if ESP_ARDUINO_VERSION_MAJOR di questa guida
La pagina non si apreIl telefono è su un'altra rete, sulla rete ospiti o sui dati mobiliCollega il telefono alla stessa rete a 2,4 GHz dell'ESP32 e rileggi l'IP nel Monitor seriale
Il cambio di colore va a scattiRisparmio energetico del Wi-Fi o troppe richiesteWiFi.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.

Vedi tutti i progetti
LED Lampeggiante con ESP32
ES-1Principiante

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.

4.7(37)
108
Controllo LED RGB ESP32
ES-9Principiante

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.

4.6(29)
52
Lampada con miscelatore di colori ESP32 (3 potenziometri + LED RGB + OLED)
ES-36Avanzato
Premium

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

4.7(6)
10
Dissolvenza LED ESP32 con PWM
ES-8Principiante

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.

4.8(36)
55
Controllo della striscia LED NeoPixel WS2812B con ESP32
ES-24Intermedio
Premium

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.

4.9(19)
30
Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)
ES-27Avanzato

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

4.8(16)
26
Contatore WebSocket ESP32 (2 pulsanti + LCD + Web in tempo reale)
ES-28Avanzato
Premium

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

4.5(14)
23
Luminosità di un LED con Potenziometro su ESP32 (Analogico → PWM)
ES-13Intermedio
Premium

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.

4.5(19)
32