Control LED RGB ESP32 WiFi: elige el color desde tu celular
Control de LED RGB con ESP32 por WiFi con el selector de color del celular: ánodo y cátodo común, HEX a RGB, PWM LEDC, corrección gamma y tira WS2812B.
Para el control de un LED RGB con ESP32 por WiFi no necesitas instalar ninguna app: el ESP32 levanta un pequeño servidor web, eliges el tono en el selector de color que aparece en el navegador de tu celular y el LED cambia al instante. Por detrás pasan tres cosas: el navegador convierte el color elegido en un código HEX como #FF8800 y lo envía por WiFi, el ESP32 separa ese código en tres números (rojo, verde y azul) y cada número se convierte en una señal PWM generada por el periférico LEDC.
En esta guía vas a aprender a conectar al ESP32 un LED RGB de cátodo común o de ánodo común en la protoboard, a elegir las resistencias correctas para 3,3 V, a escribir código LEDC que compile tanto en la versión 2.x como en la 3.x del core de Arduino para ESP32, a pasar de HEX a RGB y a aplicar la corrección gamma para que los colores se vean como en la pantalla. Al final conectarás la misma interfaz del celular a una tira LED WS2812B sin tocar una sola línea de HTML.

¿Cómo funciona? Del selector de color al LED
- Con el celular conectado a la misma red WiFi que el ESP32, abres en el navegador la dirección IP del ESP32 y este te envía una pequeña página HTML con un selector de color.
- El elemento <input type="color"> de la página abre el selector de color propio del celular y entrega la elección con el formato #ff8800.
- Unas pocas líneas de JavaScript envían ese valor a la dirección /set?hex=ff8800; mientras deslizas el dedo, los colores nuevos salen uno tras otro.
- El ESP32 separa los seis dígitos en tres números, 255, 136 y 0, y le aplica a cada uno la corrección gamma.
- El LEDC genera un PWM de 5 kHz en tres pines; el ciclo de trabajo (duty) fija el brillo de cada color y el ojo mezcla las tres luces en un solo tono.
Materiales
- Placa de desarrollo ESP32 DevKit (de 30 o 38 pines)
- Un LED RGB (5 mm, cátodo común o ánodo común)
- Resistencias de 150 Ω para el rojo y de 100 Ω para el verde y el azul (si no tienes, sirven tres de 220 Ω)
- Protoboard y algunos cables jumper
- Un cable USB que transmita datos
- Opcional: tira LED WS2812B, fuente de 5 V, resistencia de 330 Ω y capacitor de 1000 µF
Cátodo común y ánodo común: tabla de conexión
En los LED RGB de cuatro patas, la más larga es la común. En un LED de cátodo común (CC) esa pata va a GND y para encender un color pones en HIGH el pin de ese color. En uno de ánodo común (CA) la pata común va a la alimentación y el color se enciende cuando el pin está en LOW. Si no sabes cuál tienes, conecta la pata más larga a GND y otra pata a 3V3 a través de una resistencia de 150 Ω: si enciende, es de cátodo común. Si no enciende, invierte la conexión; si ahora enciende, es de ánodo común. En la mayoría de los modelos el orden de las patas, empezando por el lado plano, es rojo, común, verde y azul.
| Pata | Cátodo común (CC) | Ánodo común (CA) | Resistencia |
|---|---|---|---|
| Rojo (R) | GPIO 25 | GPIO 25 | 150 Ω |
| Pata común (la más larga) | GND | 3V3 | Ninguna |
| Verde (G) | GPIO 26 | GPIO 26 | 100 Ω |
| Azul (B) | GPIO 27 | GPIO 27 | 100 Ω |
| Ajuste en el código | COMMON_ANODE = false | COMMON_ANODE = true | Ninguna |
| Ciclo de trabajo para el color al máximo | 1023 (el máximo) | 0 (el código lo invierte solo) | Ninguna |
El cálculo de la resistencia es una aplicación directa de la ley de Ohm: R = (3,3 V − tensión del LED) / corriente. El LED rojo pide unos 2,0 V; con 150 Ω la corriente es (3,3 − 2,0) / 150 ≈ 8,7 mA. Los LED verde y azul trabajan alrededor de 2,8 a 3,1 V, así que a 3,3 V queda muy poco margen; con 100 Ω pasan de 3 a 5 mA y los colores se ven con buen brillo. Si pones 220 Ω en las tres patas el circuito funciona, pero el azul y el verde quedan claramente más apagados y el blanco tira a rosado. Para calcular con los valores de tu LED puedes usar la calculadora de resistencia para LED. No le pidas a un pin del ESP32 más de 20 mA de forma continua.
PWM LEDC del ESP32: tres canales, 5 kHz, 10 bits
El equivalente del analogWrite del Arduino Uno en el ESP32 es el periférico LEDC. El ESP32 clásico tiene 16 canales PWM independientes y en cada uno eliges la frecuencia y la resolución. En este proyecto usamos 5 kHz y 10 bits: 10 bits significa que el ciclo de trabajo va de 0 a 1023, lo que da transiciones mucho más suaves que 8 bits, sobre todo en los tonos oscuros. Y 5 kHz es lo bastante rápido como para que ni el ojo ni la mayoría de las cámaras de celular vean parpadeo. Lo único que debes tener en cuenta es que en la versión 3.0 del core de Arduino para ESP32 cambiaron las funciones LEDC, por eso muchos códigos viejos de internet ya no compilan en instalaciones nuevas. Los códigos de abajo consultan la constante ESP_ARDUINO_VERSION_MAJOR y funcionan en las dos versiones. Si quieres repasar lo básico, mira la guía qué es PWM.
| Versión del core | Configuración | Escribir el valor |
|---|---|---|
| 3.x (actual) | ledcAttach(pin, 5000, 10) | ledcWrite(pin, duty) |
| 2.x (anterior) | ledcSetup(canal, 5000, 10) y ledcAttachPin(pin, canal) | ledcWrite(canal, duty) |
Primero prueba la conexión
Antes de pasar al servidor web, asegurarte de que el cableado está bien te ahorra tiempo. Sube el código de abajo: el LED debe encenderse en rojo, verde, azul y blanco, un segundo cada uno, y luego apagarse un segundo. Si los colores salen en otro orden (por ejemplo verde en lugar de rojo), cambia el orden del arreglo PINS. Si el LED está siempre encendido y se apaga justo en el blanco, tu LED es de ánodo común: pon COMMON_ANODE en 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}Convertir el código de color HEX a RGB
En la web los colores se escriben con el formato #RRGGBB: los dos primeros dígitos son el valor del rojo, los dos siguientes el del verde y los dos últimos el del azul, cada uno entre 0 y 255 y escrito en base dieciséis (hexadecimal). En #FF8800, FF = 255, 88 = 8 × 16 + 8 = 136 y 00 = 0; es decir, rojo al máximo, un poco de verde y nada de azul: naranja. En el código lo hacemos en dos pasos: strtol(hex, NULL, 16) convierte el texto de seis dígitos en un solo número (0xFF8800) y luego, con desplazamiento de bits y una máscara, se separan los tres bytes: (rgb >> 16) & 0xFF para el rojo, (rgb >> 8) & 0xFF para el verde y rgb & 0xFF para el azul.
| HEX | Rojo | Verde | Azul | Color |
|---|---|---|---|---|
| #FF0000 | 255 | 0 | 0 | Rojo |
| #00FF00 | 0 | 255 | 0 | Verde |
| #0000FF | 0 | 0 | 255 | Azul |
| #FF8800 | 255 | 136 | 0 | Naranja |
| #800080 | 128 | 0 | 128 | Morado |
| #FFFFFF | 255 | 255 | 255 | Blanco |
| #000000 | 0 | 0 | 0 | Apagado |
Corrección gamma: ¿por qué los colores se ven lavados?
El ojo no percibe el brillo de forma lineal: en la oscuridad nota muy bien los cambios pequeños y con mucha luz le cuesta distinguir incluso los grandes. Por eso, cuando pones el ciclo de trabajo al 50 %, el LED te parece casi a pleno brillo, y los tonos pastel que eliges en la pantalla se convierten en colores lavados, casi blancos. La solución es aplicar a cada canal una corrección gamma: salida = valor máximo × (entrada / 255)^2,2. Como las pantallas usan la misma curva, después de la corrección el color del celular y el del LED quedan mucho más parecidos. La tabla muestra cuánto comprime la curva los tonos oscuros y por qué conviene usar 10 bits:
| Valor elegido (0–255) | PWM de 8 bits (0–255) | PWM de 10 bits (0–1023) |
|---|---|---|
| 16 | 1 | 2 |
| 32 | 3 | 11 |
| 64 | 12 | 49 |
| 128 | 56 | 225 |
| 192 | 137 | 548 |
| 255 | 255 | 1023 |
Código principal: servidor web con selector de color en el celular
El código principal usa la biblioteca WebServer que viene con el core del ESP32, así que no tienes que instalar nada más. Escribe el nombre y la contraseña de tu red, sube el código y abre el Monitor Serie a 115200 baudios. A los pocos segundos verás una dirección como http://192.168.1.45; ábrela en el navegador del celular conectado a la misma red WiFi. El ESP32 solo se conecta a redes de 2,4 GHz y el celular tiene que estar en esa misma red.
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}¿Cómo funciona el código?
| Parte | Qué hace |
|---|---|
| PAGE | El HTML, CSS y JavaScript que se envían al celular; gracias a R"rawliteral(...)" se escribe sin escapar las comillas |
| input type="color" | Abre el selector de color integrado del celular y entrega la elección como #rrggbb |
| send() y busy | Envía una sola petición a la vez; de los colores acumulados mientras deslizas, manda solo el último |
| /set?hex=ff8800 | La petición que llega al ESP32; la atiende handleSet() |
| isHex6() | Comprueba que el texto tenga exactamente seis dígitos hexadecimales y rechaza peticiones mal formadas |
| strtol y desplazamiento de bits | Convierte el texto en número y separa los bytes de rojo, verde y azul |
| gammaCorrect() | Lleva el valor de 0–255 a 0–1023 con la curva gamma 2,2 |
| pwmWrite() | Invierte el valor con ánodo común y llama a ledcWrite según la versión del core |
| %HEX% | Cada vez que abres la página muestra el último color; así, desde otro celular también ves el color actual |
| WiFi.setSleep(false) | Desactiva el ahorro de energía del WiFi para que el cambio de color llegue sin demora |
La misma interfaz con una tira WS2812B
Si en lugar de un solo LED RGB quieres usar una tira de decenas de LED, no tocas ni el HTML ni el servidor web: solo cambias las funciones que manejan el LED. Cada LED de la WS2812B lleva su propio chip controlador, así que basta con un pin de datos. Conecta el extremo DIN de la tira a GPIO 13 a través de una resistencia de 330 Ω, alimenta la tira con una fuente aparte de 5 V y une el GND de la fuente con el GND del ESP32. Cada LED consume unos 60 mA en blanco total; una tira de 30 LED puede llegar a 1,8 A, por eso el código limita el brillo a 80/255. Un capacitor de 1000 µF en los bornes de alimentación protege los LED del pico de corriente al encender. Con la tira alimentada a 5 V, la señal de datos de 3,3 V del ESP32 suele bastar; si ves parpadeos o colores al azar, agrega un adaptador de nivel como el 74AHCT125. Los detalles de las tiras están en la guía tira LED WS2812B NeoPixel. Pon el fragmento de abajo en lugar de las cuatro funciones del LED del código principal e instala la biblioteca Adafruit NeoPixel desde el Gestor de bibliotecas:
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 misma conversión en MicroPython (ESP32 y Pico)
Si usas tu ESP32 o tu Raspberry Pi Pico con MicroPython, el camino de HEX a PWM es el mismo; solo cambia que el ciclo de trabajo se escribe en 16 bits (0–65535). Puedes sumar la función de abajo a tu propio servidor web o a tu código MQTT. En la Pico puedes usar, por ejemplo, los pines GP11, GP12 y GP13 para rojo, verde y azul.
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 / orangeIdeas de proyectos con LED RGB y ESP32
- Lámpara de ambiente: mete el LED RGB en un frasco de vidrio esmerilado y por la noche pásalo a un naranja cálido desde el celular.
- Luz de notificaciones: que el LED se ponga azul cuando llegue un correo o un mensaje; para la mensajería mira la guía bot de Telegram con ESP32.
- Iluminación del cuarto: aplica la misma interfaz a una tira RGB común de 12 V con MOSFET; los detalles están en la guía control de tira LED RGB.
- Que todos vean el mismo color: usa WebSocket en lugar de HTTP para que el color elegido en un celular aparezca al instante en las demás páginas abiertas; la guía ESP32 con WebSocket explica cómo.
- Despertador amanecer: toma la hora por NTP y media hora antes de despertarte sube poco a poco el color del rojo oscuro al blanco; para la hora mira la guía reloj NTP con ESP32.
- Domótica: controla el color desde Home Assistant por MQTT; los pasos están en la guía ESP32, MQTT y Home Assistant.
Errores comunes y soluciones
| Síntoma | Causa | Solución |
|---|---|---|
| Eliges rojo y se enciende el verde | Las patas están en otros pines | Cambia el orden del arreglo PINS según tu LED |
| Con negro el LED brilla al máximo y con blanco se apaga | El LED es de ánodo común | Pon COMMON_ANODE = true y conecta la pata común a 3V3 |
| Azul y verde muy apagados, el blanco sale rosado | Resistencia demasiado alta para 3,3 V | Usa 100 Ω o 68 Ω para el verde y el azul |
| 'ledcSetup' was not declared in this scope | Código viejo con el core 3.x del ESP32 | Usa la condición #if ESP_ARDUINO_VERSION_MAJOR de esta guía |
| La página no abre | El celular está en otra red, en la red de invitados o con datos móviles | Conecta el celular a la misma red de 2,4 GHz que el ESP32 y vuelve a leer la IP en el Monitor Serie |
| El cambio de color se traba | Ahorro de energía del WiFi o demasiadas peticiones | WiFi.setSleep(false) y la bandera busy; si la señal es débil, acerca el ESP32 al router |
Elegir el color desde el celular es un primer proyecto WiFi tan didáctico como vistoso: en un solo circuito ves el servidor web, las peticiones HTTP, el PWM y la corrección gamma. En la app BlueGrays, los proyectos Control de LED RGB con ESP32 y Lámpara mezcladora de colores con ESP32 y tres potenciómetros te muestran este circuito paso a paso, con su diagrama y el código listo, para que después lleves la idea a tu propia lámpara.
Preguntas frecuentes
¿Cómo controlar un LED RGB con ESP32?
Conecta las patas roja, verde y azul del LED RGB a tres pines GPIO a través de resistencias y la pata común a GND (a 3V3 si es de ánodo común). Asigna un canal PWM a cada pin con LEDC y ajusta el brillo de cada color cambiando el ciclo de trabajo. La mezcla de los tres da el tono que quieras.
¿Por qué no funciona ledcSetup en el ESP32?
En la versión 3.0 del core de Arduino para ESP32 cambiaron las funciones LEDC: se eliminaron ledcSetup y ledcAttachPin, llegó ledcAttach(pin, frecuencia, resolución) y ledcWrite ahora recibe el pin en lugar del canal. Si usas la condición #if ESP_ARDUINO_VERSION_MAJOR >= 3, el mismo código compila en las dos versiones.
¿Cómo saber si mi LED RGB es de ánodo común o de cátodo común?
Conecta la pata más larga a GND y otra pata a 3,3 V con una resistencia; si enciende, es de cátodo común. Si no, invierte la conexión; si ahora enciende, es de ánodo común. Con ánodo común la lógica del código se invierte y el color se enciende con el pin en LOW.
¿Qué resistencia usar para un LED RGB con ESP32?
A 3,3 V, 150 Ω para el rojo y 100 Ω para el verde y el azul son un buen punto de partida. Con 220 Ω en las tres patas el LED funciona, pero el verde y el azul quedan apagados. No le pidas a un pin más de 20 mA de forma continua.
¿Cómo pasar un color HEX a RGB?
En el formato #RRGGBB, cada par de dígitos es el valor hexadecimal de un color. En #FF8800, FF = 255 de rojo, 88 = 136 de verde y 00 = 0 de azul. En Arduino puedes convertir el texto en número con strtol(hex, NULL, 16) y separar los canales desplazando 16 y 8 bits a la derecha.
¿Puedo controlar una tira WS2812B desde el celular con el ESP32?
Sí. La página web y el servidor quedan iguales; solo cambias la función que escribe el color por las funciones fill y show de la biblioteca Adafruit NeoPixel. Alimenta la tira con una fuente aparte de 5 V y une los GND.
Proyectos para hacer después de leer esto
Ver todos los proyectos
LED Parpadeante con ESP32
Enseña el uso básico de la salida GPIO con ESP32. Conseguimos un efecto de parpadeo encendiendo y apagando un LED desde el pin digital. Versión para ESP32 del clásico proyecto blink en Arduino UNO; los comandos básicos de blink en el entorno Arduino son los mismos, pero la distribución de pines y los niveles GPIO de 3,3 V del ESP32 difieren de los del Arduino UNO.

Control de LED RGB con ESP32
Generación ilimitada de colores con un solo LED RGB en lugar de 3 LEDs separados. Hacemos transición arco iris estableciendo valores R/G/B con analogWrite() como en Arduino. La teoría del color (como rojo+verde=amarillo) se ve de forma práctica.

Lámpara con mezclador de colores ESP32 (3 potenciómetros + LED RGB + OLED)
Una lámpara mezcladora de colores inteligente: gira 3 potenciómetros en el ESP32 y mezcla el color que quieras. Al girar los potenciómetros rojo, verde y azul, el LED RGB de cátodo común cambia de color al instante. La pantalla OLED SSD1306 muestra en vivo el valor de 0-255 de cada color, barras de relleno y el código de color web HEX (como #FF8040).

ESP32 LED Fade con PWM
Cambiar el brillo del LED suavemente de 0 a max, de max a 0. Controlamos PWM con analogWrite() como en Arduino - la misma sintaxis con ESP32 Arduino Core 3.0+ funciona sin problemas. Pin definición + pinMode + analogWrite es suficiente.

Control de la tira NeoPixel WS2812B con ESP32
Los LED direccionables WS2812B (NeoPixel) son LED RGB inteligentes que se encadenan y se controlan desde un solo pin de datos. Controlamos una tira WS2812B de 8 LED con la biblioteca Adafruit_NeoPixel y creamos un arcoíris fluido. La lógica de 3,3 V del ESP32 va bien con casi todos los WS2812B; si hay inestabilidad, mostramos la solución con una resistencia en serie de 470Ω y un condensador de 1000µF. La animación desplaza el tono en el espacio HSV.

Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)
En este proyecto, convertimos el ESP32 en un servidor web asíncrono que puedes controlar desde tu teléfono o tu ordenador, siempre que estén conectados a la misma red Wi-Fi. Gracias a la biblioteca ESPAsyncWebServer, el servidor puede procesar varias solicitudes al mismo tiempo (a diferencia del clásico WebServer.h, que se bloquea con una sola solicitud).

Contador ESP32 WebSocket (2 botones + pantalla LCD + web en tiempo real)
En este proyecto, dos botones conectados al ESP32 (GPIO 5 suma, GPIO 4 resta) cambian un contador. El valor se actualiza al instante en una pantalla LCD I2C de 16x2 y, gracias al soporte WebSocket de ESPAsyncWebServer, en todos los navegadores conectados sin recargar la página. En lugar del sondeo HTTP se usa una única conexión persistente y el ESP32 envía el nuevo valor a todos con ws.textAll().

Brillo de LED con Potenciómetro en ESP32 (Analógico → PWM)
En este proyecto controlamos el brillo de un LED de forma analógica mediante un potenciómetro. El pin ADC del ESP32 lee la tensión de 0-3,3 V procedente del potenciómetro y este valor se convierte en una señal PWM (modulación por ancho de pulso) que se envía al LED. Al girar el potenciómetro, el LED se enciende y se apaga gradualmente. Con Arduino Core 3.0+ se usa directamente analogWrite(); en el ESP32-S2/S3, la resolución del ADC es de 12 bits.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

