Servidor web ESP32 com LED RGB: escolha a cor pelo celular
Monte um servidor web ESP32 com LED RGB e defina a cor pelo seletor do celular: ligação anodo/catodo comum, HEX para RGB, PWM LEDC, gama e WS2812B.
Um servidor web ESP32 com LED RGB permite mudar a cor de um LED sem instalar nenhum app: o ESP32 serve uma pequena página web, você escolhe um tom no seletor de cores que abre no navegador do celular, e o LED muda na hora. Três coisas acontecem nos bastidores: o navegador transforma a sua escolha em um código HEX como #FF8800 e o envia pelo Wi-Fi, o ESP32 divide esse código em três números para vermelho, verde e azul, e cada número vira um sinal PWM gerado pelo periférico LEDC.
Neste guia você vai aprender a ligar um LED RGB de catodo comum ou anodo comum ao ESP32, quais resistores combinam com 3,3 V, como escrever código LEDC que funciona nos cores ESP32 Arduino 2.x e 3.x, como converter HEX em RGB e como a correção de gama deixa as cores do jeito que o seu olho espera. No fim, você liga a mesma interface do celular a uma fita de LED WS2812B sem mexer em uma única linha de HTML.

Como funciona? Do seletor de cores até o LED
- Com o celular na mesma rede Wi-Fi do ESP32, você abre o endereço IP do ESP32 no navegador e ele devolve uma pequena página HTML com um seletor de cores.
- O elemento <input type="color"> da página abre o seletor de cores do próprio celular e devolve a escolha no formato #ff8800.
- Algumas linhas de JavaScript enviam esse valor para /set?hex=ff8800; enquanto você desliza o dedo, novas cores saem uma após a outra.
- O ESP32 divide os seis dígitos em três números, 255, 136 e 0, e aplica a correção de gama a cada um.
- O LEDC gera PWM de 5 kHz em três pinos; o ciclo de trabalho define o brilho de cada cor, e o seu olho mistura as três luzes em um só tom.
Lista de materiais
- Placa de desenvolvimento ESP32 DevKit (30 ou 38 pinos)
- Um LED RGB (5 mm, catodo comum ou anodo comum)
- Um resistor de 150 Ω para o vermelho e resistores de 100 Ω para o verde e o azul (três resistores de 220 Ω também servem, se for o que você tem)
- Protoboard e alguns jumpers
- Um cabo USB que transmita dados
- Opcional: fita de LED WS2812B, fonte de 5 V, resistor de 330 Ω e capacitor de 1000 µF
Catodo comum vs anodo comum: tabela de ligação
Nos LEDs RGB de quatro terminais, o terminal mais longo é o comum. Em um LED de catodo comum (CC), ele vai ao GND, e você acende uma cor colocando o pino dela em HIGH. Em um LED de anodo comum (CA), o terminal comum vai à tensão de alimentação e a cor acende quando o pino dela está em LOW. Se não souber qual é o seu, ligue o terminal mais longo ao GND e outro terminal ao 3V3 por um resistor de 150 Ω: se acender, o LED é de catodo comum. Se não, inverta a ligação; se acender agora, é de anodo comum. Na maioria dos modelos, a ordem dos terminais, a partir do lado chato, é vermelho, comum, verde, azul.
| Terminal | Catodo comum (CC) | Anodo comum (CA) | Resistor |
|---|---|---|---|
| Vermelho (R) | GPIO 25 | GPIO 25 | 150 Ω |
| Terminal comum (o mais longo) | GND | 3V3 | Nenhum |
| Verde (G) | GPIO 26 | GPIO 26 | 100 Ω |
| Azul (B) | GPIO 27 | GPIO 27 | 100 Ω |
| Configuração no código | COMMON_ANODE = false | COMMON_ANODE = true | Nenhum |
| Ciclo de trabalho de uma cor em brilho máximo | 1023 (máximo) | 0 (o código inverte para você) | Nenhum |
O cálculo do resistor é uma aplicação simples da lei de Ohm: R = (3,3 V − tensão do LED) / corrente. Um LED vermelho precisa de cerca de 2,0 V; com 150 Ω a corrente é (3,3 − 2,0) / 150 ≈ 8,7 mA. LEDs verdes e azuis trabalham por volta de 2,8 a 3,1 V, então sobra muito pouca margem em 3,3 V; com 100 Ω passam de 3 a 5 mA e as cores ficam brilhantes o bastante. Com 220 Ω nos três terminais o circuito ainda funciona, mas o azul e o verde ficam bem mais fracos e o branco puxa para o rosa. Para calcular com os valores do seu LED, use a calculadora de resistor para LED. Não puxe mais de 20 mA contínuos de um pino do ESP32.
PWM LEDC do ESP32: três canais, 5 kHz, 10 bits
No ESP32, o equivalente ao analogWrite do Arduino Uno é o periférico LEDC. O ESP32 clássico tem 16 canais PWM independentes, e você escolhe a frequência e a resolução de cada um. Este projeto usa 5 kHz e 10 bits: 10 bits significa que o ciclo de trabalho vai de 0 a 1023, o que dá transições muito mais suaves do que 8 bits, principalmente nos tons escuros. 5 kHz é rápido o bastante para que nem o seu olho nem a maioria das câmeras de celular vejam cintilação. O único cuidado é que as funções LEDC mudaram na versão 3.0 do core ESP32 Arduino, e por isso muito código antigo da internet não compila mais em uma instalação nova. Os sketches abaixo verificam a constante ESP_ARDUINO_VERSION_MAJOR e funcionam nas duas versões. Para o básico, veja o guia o que é PWM.
| Versão do core | Configuração | Escrita do valor |
|---|---|---|
| 3.x (atual) | ledcAttach(pin, 5000, 10) | ledcWrite(pino, duty) |
| 2.x (antiga) | ledcSetup(canal, 5000, 10) e ledcAttachPin(pino, canal) | ledcWrite(canal, duty) |
Teste a ligação primeiro
Garantir que a ligação está certa antes de passar ao servidor web economiza tempo. Carregue o sketch abaixo: o LED deve acender em vermelho, verde, azul e branco por um segundo cada e depois apagar por um segundo. Se as cores vierem em outra ordem (verde no lugar do vermelho, por exemplo), mude a ordem no array PINS. Se o LED fica sempre aceso e apaga justamente no branco, o seu LED é de anodo comum; mude COMMON_ANODE para 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}Convertendo um código de cor HEX em RGB
Na web, as cores são escritas como #RRGGBB: os dois primeiros dígitos são o valor do vermelho, os dois seguintes o do verde e os dois últimos o do azul, cada um de 0 a 255 e escrito em base dezesseis (hexadecimal). Em #FF8800, FF = 255, 88 = 8 × 16 + 8 = 136 e 00 = 0, ou seja, vermelho cheio, um pouco de verde e nada de azul: laranja. O código faz isso em duas etapas: strtol(hex, NULL, 16) transforma o texto de seis dígitos em um único número (0xFF8800), e depois deslocamento de bits e uma máscara separam os três bytes: (rgb >> 16) & 0xFF para o vermelho, (rgb >> 8) & 0xFF para o verde e rgb & 0xFF para o azul.
| HEX | Vermelho | Verde | Azul | Cor |
|---|---|---|---|---|
| #FF0000 | 255 | 0 | 0 | Vermelho |
| #00FF00 | 0 | 255 | 0 | Verde |
| #0000FF | 0 | 0 | 255 | Azul |
| #FF8800 | 255 | 136 | 0 | Laranja |
| #800080 | 128 | 0 | 128 | Roxo |
| #FFFFFF | 255 | 255 | 255 | Branco |
| #000000 | 0 | 0 | 0 | Apagado |
Correção de gama: por que as cores parecem desbotadas?
O seu olho não percebe o brilho de forma linear: no escuro ele nota muito bem pequenas mudanças, enquanto na luz forte tem dificuldade até com degraus grandes. Por isso um ciclo de trabalho de 50 % já parece quase brilho total, e os tons pastel que você escolhe na tela viram cores desbotadas, quase brancas, no LED. A solução é aplicar a correção de gama a cada canal: saída = máximo × (entrada / 255)^2,2. As telas usam a mesma curva, então depois da correção a cor do celular e a do LED ficam bem mais parecidas. A tabela mostra o quanto a curva comprime os tons escuros e por que 10 bits ajudam:
| Valor escolhido (0–255) | PWM de 8 bits (0–255) | 10-bit PWM (0–1023) |
|---|---|---|
| 16 | 1 | 2 |
| 32 | 3 | 11 |
| 64 | 12 | 49 |
| 128 | 56 | 225 |
| 192 | 137 | 548 |
| 255 | 255 | 1023 |
Sketch principal: um servidor web com seletor de cores para o celular
O sketch principal usa a biblioteca WebServer, que já vem com o core do ESP32, então não há nada extra para instalar. Coloque o nome e a senha da sua rede, carregue o sketch e abra o Monitor Serial a 115200 baud. Depois de alguns segundos aparece um endereço como http://192.168.1.45; abra-o no navegador de um celular na mesma rede Wi-Fi. O ESP32 só se conecta a redes de 2,4 GHz, e o celular precisa estar nessa mesma rede.
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}Como o código funciona
| Parte | O que faz |
|---|---|
| PAGE | O HTML, o CSS e o JavaScript enviados ao celular; R"rawliteral(...)" permite escrevê-los sem escapar aspas |
| input type="color" | Abre o seletor de cores embutido do celular e devolve a escolha como #rrggbb |
| send() e busy | Envia só uma requisição por vez; das cores que se acumulam enquanto você desliza, só a mais recente sai |
| /set?hex=ff8800 | A requisição que chega ao ESP32; handleSet() responde a ela |
| isHex6() | Verifica se o texto tem exatamente seis dígitos hexadecimais e rejeita requisições malformadas |
| strtol e deslocamento de bits | Transformam o texto em número e separam os bytes de vermelho, verde e azul |
| gammaCorrect() | Mapeia o valor de 0–255 para 0–1023 pela curva de gama 2,2 |
| pwmWrite() | Inverte o valor para anodo comum e faz a chamada ledcWrite certa para a versão do core |
| %HEX% | Mostra a última cor sempre que a página abre, para que um segundo celular também veja a cor atual |
| WiFi.setSleep(false) | Desliga a economia de energia do Wi-Fi para que as mudanças de cor cheguem sem atraso |
A mesma interface com uma fita WS2812B
Se preferir controlar uma fita com dezenas de LEDs em vez de um único LED RGB, você não mexe no HTML nem no servidor web; só troca as funções que acionam o LED. Cada LED WS2812B tem o próprio chip controlador, então basta um pino de dados. Ligue a ponta DIN da fita ao GPIO 13 por um resistor de 330 Ω, alimente a fita com uma fonte separada de 5 V e una o GND da fonte ao GND do ESP32. Cada LED consome cerca de 60 mA em branco total; uma fita de 30 LEDs pode chegar a 1,8 A, e por isso o código limita o brilho a 80/255. Um capacitor de 1000 µF entre os terminais de alimentação protege os LEDs do pico de corrente ao ligar. Com a fita em 5 V, o sinal de dados de 3,3 V do ESP32 normalmente basta; se aparecer cintilação ou cores aleatórias, adicione um conversor de nível como o 74AHCT125. Os detalhes da fita estão no guia WS2812B NeoPixel. Coloque o trecho abaixo no lugar das quatro funções de LED do sketch principal e instale a biblioteca Adafruit NeoPixel pelo Gerenciador 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}
A mesma conversão em MicroPython (ESP32 e Pico)
Se você programa o ESP32 ou o Raspberry Pi Pico em MicroPython, o caminho de HEX até PWM é o mesmo; a única diferença é que o ciclo de trabalho é escrito em 16 bits (0–65535). Você pode adicionar a função abaixo ao seu próprio servidor web ou código MQTT. Em um Pico, dá para usar GP11, GP12 e GP13 para vermelho, verde e azul, por exemplo.
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 / orangeIdeias de projetos com LED RGB e ESP32
- Luminária de ambiente: coloque o LED RGB em um pote de vidro fosco e mude para um laranja quente pelo celular à noite.
- Luz de notificação: faça o LED ficar azul quando chegar um e-mail ou uma mensagem; para mensagens, veja o guia bot do Telegram com ESP32.
- Iluminação ambiente do quarto: aplique a mesma interface a uma fita RGB comum de 12 V com MOSFETs; os detalhes estão no guia controle de fita de LED RGB.
- Todos veem a mesma cor: use WebSocket em vez de HTTP para que uma cor escolhida em um celular apareça na hora em todas as outras páginas abertas; o guia WebSocket com ESP32 mostra como.
- Despertador de nascer do sol: pegue a hora via NTP e, meia hora antes de você acordar, passe devagar do vermelho escuro ao branco; para o relógio, veja o guia relógio NTP com ESP32.
- Integração com casa inteligente: controle a cor pelo Home Assistant via MQTT; os passos estão no guia ESP32 com MQTT e Home Assistant.
Erros comuns e soluções
| Sintoma | Causa | Solução |
|---|---|---|
| Você escolhe vermelho e acende verde | Os terminais estão em outros pinos | Mude a ordem do array PINS para combinar com o seu LED |
| Preto deixa o LED no brilho máximo e branco apaga | O LED é de anodo comum | Defina COMMON_ANODE = true e ligue o terminal comum ao 3V3 |
| Azul e verde muito fracos, branco puxa para o rosa | Resistor grande demais para 3,3 V | Use 100 Ω ou 68 Ω para o verde e o azul |
| 'ledcSetup' was not declared in this scope | Código antigo no core ESP32 3.x | Use a verificação #if ESP_ARDUINO_VERSION_MAJOR deste guia |
| A página não abre | O celular está em outra rede, na rede de convidados ou nos dados móveis | Coloque o celular na mesma rede de 2,4 GHz do ESP32 e leia o IP de novo no Monitor Serial |
| As mudanças de cor engasgam | Economia de energia do Wi-Fi ou requisições demais | WiFi.setSleep(false) e a flag busy; se o sinal estiver fraco, aproxime o ESP32 do roteador |
Escolher uma cor pelo celular é um primeiro projeto Wi-Fi tão educativo quanto chamativo: um único circuito mostra servidor web, requisições HTTP, PWM e correção de gama. No app BlueGrays, o projeto Controle de LED RGB com ESP32 e a Luminária Misturadora de Cores com ESP32 e três potenciômetros guiam você por esse circuito passo a passo, com esquema de ligação e código pronto, para depois levar a ideia a uma luminária só sua.
Perguntas frequentes
Como controlar um LED RGB com ESP32?
Ligue os terminais vermelho, verde e azul do LED RGB a três pinos GPIO por resistores e o terminal comum ao GND (ao 3V3 no anodo comum). Associe um canal PWM a cada pino com o LEDC e defina o brilho de cada cor mudando o ciclo de trabalho. Misturando as três, você obtém qualquer tom.
Por que o ledcSetup não funciona no core ESP32 3.0?
As funções LEDC mudaram na versão 3.0 do core ESP32 Arduino: ledcSetup e ledcAttachPin foram removidas, ledcAttach(pino, frequência, resolução) entrou no lugar delas, e o ledcWrite agora recebe o pino em vez do canal. Com uma verificação #if ESP_ARDUINO_VERSION_MAJOR >= 3, o mesmo código compila nas duas versões.
Como saber se o meu LED RGB é de anodo comum ou de catodo comum?
Ligue o terminal mais longo ao GND e outro terminal a 3,3 V por um resistor; se acender, é de catodo comum. Se não, inverta a ligação; se acender agora, é de anodo comum. No anodo comum a lógica do código é invertida e uma cor acende quando o pino dela está em LOW.
Que resistor usar em um LED RGB no ESP32?
Em 3,3 V, 150 Ω para o vermelho e 100 Ω para o verde e o azul são um bom ponto de partida. Com 220 Ω nos três terminais o LED funciona, mas o verde e o azul ficam fracos. Não puxe mais de 20 mA contínuos de um pino.
Como converter uma cor HEX em RGB?
No formato #RRGGBB, cada par de dígitos é o valor hexadecimal de uma cor. Em #FF8800, FF = 255 de vermelho, 88 = 136 de verde e 00 = 0 de azul. No código Arduino, você transforma o texto em número com strtol(hex, NULL, 16) e separa os canais deslocando 16 e 8 bits para a direita.
Dá para controlar uma fita WS2812B pelo celular com ESP32?
Sim. A página web e o código do servidor continuam iguais; só a função que escreve a cor passa a usar as chamadas fill e show da biblioteca Adafruit NeoPixel. Alimente a fita com uma fonte separada de 5 V e una os terras.
Projetos para montar depois desta leitura
Ver todos os projetos
LED piscando com ESP32
Ensina o uso básico de uma saída GPIO no ESP32. Fazemos um LED piscar ligando e desligando um pino digital. É a versão para ESP32 do clássico projeto blink do Arduino UNO: os comandos básicos de blink no ambiente Arduino são os mesmos, mas a disposição dos pinos e os níveis de 3,3 V dos GPIOs do ESP32 diferem dos do Arduino UNO.

Controle de LED RGB com ESP32
Gere inúmeras cores com um único LED RGB em vez de 3 LEDs separados. Como no Arduino, ajustamos os valores R/G/B com analogWrite() para criar uma transição de arco-íris. Você vê a teoria das cores na prática, como vermelho + verde = amarelo.

Luminária com mistura de cores e ESP32 (3 potenciômetros + LED RGB + OLED)
Uma luminária inteligente que permite misturar a cor que você quiser girando três potenciômetros com o ESP32! Ao girar os potenciômetros de vermelho, verde e azul, o LED RGB de cátodo comum muda de cor em tempo real. O display OLED SSD1306 mostra os valores de cada cor na faixa de 0–255, barras de preenchimento e o código HEX da cor para a web, como #FF8040.

Variação gradual do brilho do LED com PWM no ESP32
Varie suavemente o brilho do LED de 0 ao máximo e do máximo a 0. Controlamos o PWM com analogWrite(), como no Arduino. A mesma sintaxe funciona sem problemas com ESP32 Arduino Core 3.0+. Basta definir o pino e usar pinMode e analogWrite.

Controle de fita WS2812B NeoPixel com ESP32
Os LEDs endereçáveis WS2812B (NeoPixel) são LEDs RGB inteligentes que podem ser controlados em cadeia por um único pino de dados. Neste projeto, vamos controlar uma fita WS2812B de 8 LEDs com a biblioteca Adafruit_NeoPixel para criar uma animação suave de arco-íris. Embora o nível lógico de 3,3V do ESP32 funcione sem problemas na maioria dos lotes de WS2812B, vamos mostrar uma solução com um resistor de 470Ω em série e um capacitor de 1.000µF para casos de instabilidade.

Servidor web assíncrono com ESP32 (IP no LCD)
Neste projeto, transformamos o ESP32 em um servidor web assíncrono que você pode controlar pelo celular ou computador na mesma rede Wi-Fi. Com a biblioteca ESPAsyncWebServer, o servidor processa várias requisições ao mesmo tempo (ao contrário do WebServer.h tradicional, que bloqueia a execução ao processar uma requisição). Você poderá abrir o endereço IP do ESP32 no navegador e clicar nos botões ON/OFF (as rotas /on e /off) para ligar e desligar o LED conectado ao GPIO 5.

Contador WebSocket com ESP32 (2 botões + LCD + web em tempo real)
Neste projeto, dois botões conectados ao ESP32 (GPIO 5 aumenta, GPIO 4 diminui) alteram um contador. O valor é atualizado instantaneamente no LCD I2C 16x2 e, com o suporte a WebSocket do ESPAsyncWebServer, em todos os navegadores conectados, sem recarregar a página. Em vez de consultas periódicas por HTTP, usamos uma única conexão persistente, e o ESP32 envia o novo valor a todos com ws.textAll().

Brilho do LED com potenciômetro no ESP32 (analógico → PWM)
Neste projeto, controlamos o brilho de um LED de forma analógica com um potenciômetro. O pino ADC do ESP32 lê a tensão de 0-3,3V do potenciômetro e converte esse valor em um sinal PWM (modulação por largura de pulso), enviado ao LED. Assim, ao girar o potenciômetro, o brilho do LED aumenta e diminui gradualmente. Com Arduino Core 3.0+, você pode usar analogWrite() diretamente; no ESP32-S2/S3, a resolução do ADC é fixada em 12 bits.
Mais artigos
- Como usar um LED RGB: mistura de cores com Arduino, ânodo comum vs cátodo comum
- Servidor web assíncrono no ESP32 com WebSocket: painel de controle em tempo real
- Fita de LED WS2812B NeoPixel com Arduino: guia de LEDs RGB endereçáveis
- O que é PWM? Guia de analogWrite, ciclo de trabalho e frequência no Arduino
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

