Guias · 10 min de leitura

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.

LED RGB de quatro terminais
Um LED RGB: um só encapsulamento guarda três LEDs, vermelho, verde e azul; o terminal mais longo é o comum.

Como funciona? Do seletor de cores até o LED

  1. 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.
  2. O elemento <input type="color"> da página abre o seletor de cores do próprio celular e devolve a escolha no formato #ff8800.
  3. Algumas linhas de JavaScript enviam esse valor para /set?hex=ff8800; enquanto você desliza o dedo, novas cores saem uma após a outra.
  4. 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.
  5. 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.

TerminalCatodo comum (CC)Anodo comum (CA)Resistor
Vermelho (R)GPIO 25GPIO 25150 Ω
Terminal comum (o mais longo)GND3V3Nenhum
Verde (G)GPIO 26GPIO 26100 Ω
Azul (B)GPIO 27GPIO 27100 Ω
Configuração no códigoCOMMON_ANODE = falseCOMMON_ANODE = trueNenhum
Ciclo de trabalho de uma cor em brilho máximo1023 (máximo)0 (o código inverte para você)Nenhum
Ligue o terminal comum de um LED de anodo comum ao pino 3V3 do ESP32, não ao 5V. Em 5 V, sobra cerca de 1,7 V sobre o LED mesmo com o pino em HIGH: o vermelho fica aceso fraquinho, e a corrente volta pelos diodos de proteção para o pino de 3,3 V, o que o danifica aos poucos.

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 coreConfiguraçãoEscrita 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.

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}

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.

HEXVermelhoVerdeAzulCor
#FF000025500Vermelho
#00FF0002550Verde
#0000FF00255Azul
#FF88002551360Laranja
#8000801280128Roxo
#FFFFFF255255255Branco
#000000000Apagado

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

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.

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}

Como o código funciona

ParteO que faz
PAGEO 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 busyEnvia só uma requisição por vez; das cores que se acumulam enquanto você desliza, só a mais recente sai
/set?hex=ff8800A 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 bitsTransformam 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
Enquanto você arrasta o dedo pelo seletor de cores, o navegador dispara dezenas de eventos input por segundo. Enviar todos de uma vez entope o pequeno servidor web do ESP32 e as cores ficam atrasadas. A flag busy no código não envia uma nova requisição até a anterior terminar e, dos valores acumulados, envia só o mais recente; assim o LED segue o seu dedo sem atraso. Adicione a página à tela inicial do celular e ela abre com um toque, igual a um app.

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:

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 endereçável WS2812B
WS2812B: cada LED traz o próprio chip controlador, então uma única linha de dados define a cor de centenas de LEDs individualmente.

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.

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

Ideias 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

SintomaCausaSolução
Você escolhe vermelho e acende verdeOs terminais estão em outros pinosMude a ordem do array PINS para combinar com o seu LED
Preto deixa o LED no brilho máximo e branco apagaO LED é de anodo comumDefina COMMON_ANODE = true e ligue o terminal comum ao 3V3
Azul e verde muito fracos, branco puxa para o rosaResistor grande demais para 3,3 VUse 100 Ω ou 68 Ω para o verde e o azul
'ledcSetup' was not declared in this scopeCódigo antigo no core ESP32 3.xUse a verificação #if ESP_ARDUINO_VERSION_MAJOR deste guia
A página não abreO celular está em outra rede, na rede de convidados ou nos dados móveisColoque 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 engasgamEconomia de energia do Wi-Fi ou requisições demaisWiFi.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.

Ver todos os projetos
LED piscando com ESP32
ES-1Iniciante

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.

4.7(37)
108
Controle de LED RGB com ESP32
ES-9Iniciante

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.

4.6(29)
52
Luminária com mistura de cores e ESP32 (3 potenciômetros + LED RGB + OLED)
ES-36Avançado
Premium

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.

4.7(6)
10
Variação gradual do brilho do LED com PWM no ESP32
ES-8Iniciante

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.

4.8(36)
55
Controle de fita WS2812B NeoPixel com ESP32
ES-24Intermediário
Premium

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.

4.9(19)
30
Servidor web assíncrono com ESP32 (IP no LCD)
ES-27Avançado

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.

4.8(16)
26
Contador WebSocket com ESP32 (2 botões + LCD + web em tempo real)
ES-28Avançado
Premium

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

4.5(14)
23
Brilho do LED com potenciômetro no ESP32 (analógico → PWM)
ES-13Intermediário
Premium

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.

4.5(19)
32