Guías · 10 min de lectura

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.

LED RGB de cuatro patas
LED RGB: en una sola cápsula hay tres LED, rojo, verde y azul; la pata más larga es la común.

¿Cómo funciona? Del selector de color al LED

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.

PataCátodo común (CC)Ánodo común (CA)Resistencia
Rojo (R)GPIO 25GPIO 25150 Ω
Pata común (la más larga)GND3V3Ninguna
Verde (G)GPIO 26GPIO 26100 Ω
Azul (B)GPIO 27GPIO 27100 Ω
Ajuste en el códigoCOMMON_ANODE = falseCOMMON_ANODE = trueNinguna
Ciclo de trabajo para el color al máximo1023 (el máximo)0 (el código lo invierte solo)Ninguna
Conecta la pata común de un LED de ánodo común al pin 3V3 del ESP32, no al 5V. Si la conectas a 5 V, incluso con el pin en HIGH quedan unos 1,7 V sobre el LED: el rojo se queda encendido a medias y la corriente vuelve por los diodos de protección hacia el pin de 3,3 V, que con el tiempo se daña.

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 coreConfiguraciónEscribir 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.

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}

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.

HEXRojoVerdeAzulColor
#FF000025500Rojo
#00FF0002550Verde
#0000FF00255Azul
#FF88002551360Naranja
#8000801280128Morado
#FFFFFF255255255Blanco
#000000000Apagado

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

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.

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}

¿Cómo funciona el código?

ParteQué hace
PAGEEl 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 busyEnvía una sola petición a la vez; de los colores acumulados mientras deslizas, manda solo el último
/set?hex=ff8800La 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 bitsConvierte 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
Mientras deslizas el dedo por el selector, el navegador genera decenas de eventos input por segundo. Mandarlos todos a la vez satura el pequeño servidor web del ESP32 y los colores llegan con retraso. La bandera busy del código no envía una petición nueva hasta que termine la anterior y, de los valores acumulados, manda solo el último; así el LED sigue tu dedo sin demora. Si agregas la página a la pantalla de inicio del celular, se abre con un toque, como una app.

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:

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 direccionable WS2812B
WS2812B: cada LED lleva su propio chip controlador; con una sola línea de datos se ajusta el color de cientos de LED por separado.

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.

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

Ideas 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íntomaCausaSolución
Eliges rojo y se enciende el verdeLas patas están en otros pinesCambia el orden del arreglo PINS según tu LED
Con negro el LED brilla al máximo y con blanco se apagaEl LED es de ánodo comúnPon COMMON_ANODE = true y conecta la pata común a 3V3
Azul y verde muy apagados, el blanco sale rosadoResistencia demasiado alta para 3,3 VUsa 100 Ω o 68 Ω para el verde y el azul
'ledcSetup' was not declared in this scopeCódigo viejo con el core 3.x del ESP32Usa la condición #if ESP_ARDUINO_VERSION_MAJOR de esta guía
La página no abreEl celular está en otra red, en la red de invitados o con datos móvilesConecta 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 trabaAhorro de energía del WiFi o demasiadas peticionesWiFi.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.

Ver todos los proyectos
LED Parpadeante con ESP32
ES-1Principiante

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.

4.7(37)
108
Control de LED RGB con ESP32
ES-9Principiante

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.

4.6(29)
52
Lámpara con mezclador de colores ESP32 (3 potenciómetros + LED RGB + OLED)
ES-36Avanzado
Premium

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

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

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.

4.8(36)
55
Control de la tira NeoPixel WS2812B con ESP32
ES-24Intermedio
Premium

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.

4.9(19)
30
Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)
ES-27Avanzado

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

4.8(16)
26
Contador ESP32 WebSocket (2 botones + pantalla LCD + web en tiempo real)
ES-28Avanzado
Premium

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

4.5(14)
23
Brillo de LED con Potenciómetro en ESP32 (Analógico → PWM)
ES-13Intermedio
Premium

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.

4.5(19)
32